net/dsa/switch.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Handling of a single switch chip, part of a switch fabric
   4  *
   5  * Copyright (c) 2017 Savoir-faire Linux Inc.
   6  *      Vivien Didelot <vivien.didelot@savoirfairelinux.com>
   7  */
   8
   9 #include <linux/if_bridge.h>
  10 #include <linux/netdevice.h>
  11 #include <linux/notifier.h>
  12 #include <linux/if_vlan.h>
  13 #include <net/switchdev.h>
  14
  15 #include "dsa_priv.h"
  16
  17 static unsigned int dsa_switch_fastest_ageing_time(struct dsa_switch *ds,
  18                                                    unsigned int ageing_time)
  19 {
  20         int i;
  21
  22         for (i = 0; i < ds->num_ports; ++i) {
  23                 struct dsa_port *dp = dsa_to_port(ds, i);
  24
  25                 if (dp->ageing_time && dp->ageing_time < ageing_time)
  26                         ageing_time = dp->ageing_time;
  27         }
  28
  29         return ageing_time;
  30 }
  31
  32 static int dsa_switch_ageing_time(struct dsa_switch *ds,
  33                                   struct dsa_notifier_ageing_time_info *info)
  34 {
  35         unsigned int ageing_time = info->ageing_time;
  36
  37         if (ds->ageing_time_min && ageing_time < ds->ageing_time_min)
  38                 return -ERANGE;
  39
  40         if (ds->ageing_time_max && ageing_time > ds->ageing_time_max)
  41                 return -ERANGE;
  42
  43         /* Program the fastest ageing time in case of multiple bridges */
  44         ageing_time = dsa_switch_fastest_ageing_time(ds, ageing_time);
  45
  46         if (ds->ops->set_ageing_time)
  47                 return ds->ops->set_ageing_time(ds, ageing_time);
  48
  49         return 0;
  50 }
  51
  52 static bool dsa_switch_mtu_match(struct dsa_switch *ds, int port,
  53                                  struct dsa_notifier_mtu_info *info)
  54 {
  55         if (ds->index == info->sw_index)
  56                 return (port == info->port) || dsa_is_dsa_port(ds, port);
  57
  58         if (!info->propagate_upstream)
  59                 return false;
  60
  61         if (dsa_is_dsa_port(ds, port) || dsa_is_cpu_port(ds, port))
  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         int port, ret;
  71
  72         if (!ds->ops->port_change_mtu)
  73                 return -EOPNOTSUPP;
  74
  75         for (port = 0; port < ds->num_ports; port++) {
  76                 if (dsa_switch_mtu_match(ds, port, info)) {
  77                         ret = ds->ops->port_change_mtu(ds, port, info->mtu);
  78                         if (ret)
  79                                 return ret;
  80                 }
  81         }
  82
  83         return 0;
  84 }
  85
  86 static int dsa_switch_bridge_join(struct dsa_switch *ds,
  87                                   struct dsa_notifier_bridge_info *info)
  88 {
  89         struct dsa_switch_tree *dst = ds->dst;
  90
  91         if (dst->index == info->tree_index && ds->index == info->sw_index &&
  92             ds->ops->port_bridge_join)
  93                 return ds->ops->port_bridge_join(ds, info->port, info->br);
  94
  95         if ((dst->index != info->tree_index || ds->index != info->sw_index) &&
  96             ds->ops->crosschip_bridge_join)
  97                 return ds->ops->crosschip_bridge_join(ds, info->tree_index,
  98                                                       info->sw_index,
  99                                                       info->port, info->br);
 100
 101         return 0;
 102 }
 103
 104 static int dsa_switch_bridge_leave(struct dsa_switch *ds,
 105                                    struct dsa_notifier_bridge_info *info)
 106 {
 107         bool unset_vlan_filtering = br_vlan_enabled(info->br);
 108         struct dsa_switch_tree *dst = ds->dst;
 109         struct netlink_ext_ack extack = {0};
 110         int err, port;
 111
 112         if (dst->index == info->tree_index && ds->index == info->sw_index &&
 113             ds->ops->port_bridge_leave)
 114                 ds->ops->port_bridge_leave(ds, info->port, info->br);
 115
 116         if ((dst->index != info->tree_index || ds->index != info->sw_index) &&
 117             ds->ops->crosschip_bridge_leave)
 118                 ds->ops->crosschip_bridge_leave(ds, info->tree_index,
 119                                                 info->sw_index, info->port,
 120                                                 info->br);
 121
 122         /* If the bridge was vlan_filtering, the bridge core doesn't trigger an
 123          * event for changing vlan_filtering setting upon slave ports leaving
 124          * it. That is a good thing, because that lets us handle it and also
 125          * handle the case where the switch's vlan_filtering setting is global
 126          * (not per port). When that happens, the correct moment to trigger the
 127          * vlan_filtering callback is only when the last port leaves the last
 128          * VLAN-aware bridge.
 129          */
 130         if (unset_vlan_filtering && ds->vlan_filtering_is_global) {
 131                 for (port = 0; port < ds->num_ports; port++) {
 132                         struct net_device *bridge_dev;
 133
 134                         bridge_dev = dsa_to_port(ds, port)->bridge_dev;
 135
 136                         if (bridge_dev && br_vlan_enabled(bridge_dev)) {
 137                                 unset_vlan_filtering = false;
 138                                 break;
 139                         }
 140                 }
 141         }
 142         if (unset_vlan_filtering) {
 143                 err = dsa_port_vlan_filtering(dsa_to_port(ds, info->port),
 144                                               false, &extack);
 145                 if (extack._msg)
 146                         dev_err(ds->dev, "port %d: %s\n", info->port,
 147                                 extack._msg);
 148                 if (err && err != EOPNOTSUPP)
 149                         return err;
 150         }
 151         return 0;
 152 }
 153
 154 static int dsa_switch_fdb_add(struct dsa_switch *ds,
 155                               struct dsa_notifier_fdb_info *info)
 156 {
 157         int port = dsa_towards_port(ds, info->sw_index, info->port);
 158
 159         if (!ds->ops->port_fdb_add)
 160                 return -EOPNOTSUPP;
 161
 162         return ds->ops->port_fdb_add(ds, port, info->addr, info->vid);
 163 }
 164
 165 static int dsa_switch_fdb_del(struct dsa_switch *ds,
 166                               struct dsa_notifier_fdb_info *info)
 167 {
 168         int port = dsa_towards_port(ds, info->sw_index, info->port);
 169
 170         if (!ds->ops->port_fdb_del)
 171                 return -EOPNOTSUPP;
 172
 173         return ds->ops->port_fdb_del(ds, port, info->addr, info->vid);
 174 }
 175
 176 static int dsa_switch_hsr_join(struct dsa_switch *ds,
 177                                struct dsa_notifier_hsr_info *info)
 178 {
 179         if (ds->index == info->sw_index && ds->ops->port_hsr_join)
 180                 return ds->ops->port_hsr_join(ds, info->port, info->hsr);
 181
 182         return -EOPNOTSUPP;
 183 }
 184
 185 static int dsa_switch_hsr_leave(struct dsa_switch *ds,
 186                                 struct dsa_notifier_hsr_info *info)
 187 {
 188         if (ds->index == info->sw_index && ds->ops->port_hsr_leave)
 189                 return ds->ops->port_hsr_leave(ds, info->port, info->hsr);
 190
 191         return -EOPNOTSUPP;
 192 }
 193
 194 static int dsa_switch_lag_change(struct dsa_switch *ds,
 195                                  struct dsa_notifier_lag_info *info)
 196 {
 197         if (ds->index == info->sw_index && ds->ops->port_lag_change)
 198                 return ds->ops->port_lag_change(ds, info->port);
 199
 200         if (ds->index != info->sw_index && ds->ops->crosschip_lag_change)
 201                 return ds->ops->crosschip_lag_change(ds, info->sw_index,
 202                                                      info->port);
 203
 204         return 0;
 205 }
 206
 207 static int dsa_switch_lag_join(struct dsa_switch *ds,
 208                                struct dsa_notifier_lag_info *info)
 209 {
 210         if (ds->index == info->sw_index && ds->ops->port_lag_join)
 211                 return ds->ops->port_lag_join(ds, info->port, info->lag,
 212                                               info->info);
 213
 214         if (ds->index != info->sw_index && ds->ops->crosschip_lag_join)
 215                 return ds->ops->crosschip_lag_join(ds, info->sw_index,
 216                                                    info->port, info->lag,
 217                                                    info->info);
 218
 219         return 0;
 220 }
 221
 222 static int dsa_switch_lag_leave(struct dsa_switch *ds,
 223                                 struct dsa_notifier_lag_info *info)
 224 {
 225         if (ds->index == info->sw_index && ds->ops->port_lag_leave)
 226                 return ds->ops->port_lag_leave(ds, info->port, info->lag);
 227
 228         if (ds->index != info->sw_index && ds->ops->crosschip_lag_leave)
 229                 return ds->ops->crosschip_lag_leave(ds, info->sw_index,
 230                                                     info->port, info->lag);
 231
 232         return 0;
 233 }
 234
 235 static bool dsa_switch_mdb_match(struct dsa_switch *ds, int port,
 236                                  struct dsa_notifier_mdb_info *info)
 237 {
 238         if (ds->index == info->sw_index && port == info->port)
 239                 return true;
 240
 241         if (dsa_is_dsa_port(ds, port))
 242                 return true;
 243
 244         return false;
 245 }
 246
 247 static int dsa_switch_mdb_add(struct dsa_switch *ds,
 248                               struct dsa_notifier_mdb_info *info)
 249 {
 250         int err = 0;
 251         int port;
 252
 253         if (!ds->ops->port_mdb_add)
 254                 return -EOPNOTSUPP;
 255
 256         for (port = 0; port < ds->num_ports; port++) {
 257                 if (dsa_switch_mdb_match(ds, port, info)) {
 258                         err = ds->ops->port_mdb_add(ds, port, info->mdb);
 259                         if (err)
 260                                 break;
 261                 }
 262         }
 263
 264         return err;
 265 }
 266
 267 static int dsa_switch_mdb_del(struct dsa_switch *ds,
 268                               struct dsa_notifier_mdb_info *info)
 269 {
 270         if (!ds->ops->port_mdb_del)
 271                 return -EOPNOTSUPP;
 272
 273         if (ds->index == info->sw_index)
 274                 return ds->ops->port_mdb_del(ds, info->port, info->mdb);
 275
 276         return 0;
 277 }
 278
 279 static bool dsa_switch_vlan_match(struct dsa_switch *ds, int port,
 280                                   struct dsa_notifier_vlan_info *info)
 281 {
 282         if (ds->index == info->sw_index && port == info->port)
 283                 return true;
 284
 285         if (dsa_is_dsa_port(ds, port))
 286                 return true;
 287
 288         return false;
 289 }
 290
 291 static int dsa_switch_vlan_add(struct dsa_switch *ds,
 292                                struct dsa_notifier_vlan_info *info)
 293 {
 294         int port, err;
 295
 296         if (!ds->ops->port_vlan_add)
 297                 return -EOPNOTSUPP;
 298
 299         for (port = 0; port < ds->num_ports; port++) {
 300                 if (dsa_switch_vlan_match(ds, port, info)) {
 301                         err = ds->ops->port_vlan_add(ds, port, info->vlan,
 302                                                      info->extack);
 303                         if (err)
 304                                 return err;
 305                 }
 306         }
 307
 308         return 0;
 309 }
 310
 311 static int dsa_switch_vlan_del(struct dsa_switch *ds,
 312                                struct dsa_notifier_vlan_info *info)
 313 {
 314         if (!ds->ops->port_vlan_del)
 315                 return -EOPNOTSUPP;
 316
 317         if (ds->index == info->sw_index)
 318                 return ds->ops->port_vlan_del(ds, info->port, info->vlan);
 319
 320         /* Do not deprogram the DSA links as they may be used as conduit
 321          * for other VLAN members in the fabric.
 322          */
 323         return 0;
 324 }
 325
 326 static int dsa_switch_change_tag_proto(struct dsa_switch *ds,
 327                                        struct dsa_notifier_tag_proto_info *info)
 328 {
 329         const struct dsa_device_ops *tag_ops = info->tag_ops;
 330         int port, err;
 331
 332         if (!ds->ops->change_tag_protocol)
 333                 return -EOPNOTSUPP;
 334
 335         ASSERT_RTNL();
 336
 337         for (port = 0; port < ds->num_ports; port++) {
 338                 if (!dsa_is_cpu_port(ds, port))
 339                         continue;
 340
 341                 err = ds->ops->change_tag_protocol(ds, port, tag_ops->proto);
 342                 if (err)
 343                         return err;
 344
 345                 dsa_port_set_tag_protocol(dsa_to_port(ds, port), tag_ops);
 346         }
 347
 348         /* Now that changing the tag protocol can no longer fail, let's update
 349          * the remaining bits which are "duplicated for faster access", and the
 350          * bits that depend on the tagger, such as the MTU.
 351          */
 352         for (port = 0; port < ds->num_ports; port++) {
 353                 if (dsa_is_user_port(ds, port)) {
 354                         struct net_device *slave;
 355
 356                         slave = dsa_to_port(ds, port)->slave;
 357                         dsa_slave_setup_tagger(slave);
 358
 359                         /* rtnl_mutex is held in dsa_tree_change_tag_proto */
 360                         dsa_slave_change_mtu(slave, slave->mtu);
 361                 }
 362         }
 363
 364         return 0;
 365 }
 366
 367 static bool dsa_switch_mrp_match(struct dsa_switch *ds, int port,
 368                                  struct dsa_notifier_mrp_info *info)
 369 {
 370         if (ds->index == info->sw_index && port == info->port)
 371                 return true;
 372
 373         if (dsa_is_dsa_port(ds, port))
 374                 return true;
 375
 376         return false;
 377 }
 378
 379 static int dsa_switch_mrp_add(struct dsa_switch *ds,
 380                               struct dsa_notifier_mrp_info *info)
 381 {
 382         int err = 0;
 383         int port;
 384
 385         if (!ds->ops->port_mrp_add)
 386                 return -EOPNOTSUPP;
 387
 388         for (port = 0; port < ds->num_ports; port++) {
 389                 if (dsa_switch_mrp_match(ds, port, info)) {
 390                         err = ds->ops->port_mrp_add(ds, port, info->mrp);
 391                         if (err)
 392                                 break;
 393                 }
 394         }
 395
 396         return err;
 397 }
 398
 399 static int dsa_switch_mrp_del(struct dsa_switch *ds,
 400                               struct dsa_notifier_mrp_info *info)
 401 {
 402         if (!ds->ops->port_mrp_del)
 403                 return -EOPNOTSUPP;
 404
 405         if (ds->index == info->sw_index)
 406                 return ds->ops->port_mrp_del(ds, info->port, info->mrp);
 407
 408         return 0;
 409 }
 410
 411 static bool
 412 dsa_switch_mrp_ring_role_match(struct dsa_switch *ds, int port,
 413                                struct dsa_notifier_mrp_ring_role_info *info)
 414 {
 415         if (ds->index == info->sw_index && port == info->port)
 416                 return true;
 417
 418         if (dsa_is_dsa_port(ds, port))
 419                 return true;
 420
 421         return false;
 422 }
 423
 424 static int
 425 dsa_switch_mrp_add_ring_role(struct dsa_switch *ds,
 426                              struct dsa_notifier_mrp_ring_role_info *info)
 427 {
 428         int err = 0;
 429         int port;
 430
 431         if (!ds->ops->port_mrp_add)
 432                 return -EOPNOTSUPP;
 433
 434         for (port = 0; port < ds->num_ports; port++) {
 435                 if (dsa_switch_mrp_ring_role_match(ds, port, info)) {
 436                         err = ds->ops->port_mrp_add_ring_role(ds, port,
 437                                                               info->mrp);
 438                         if (err)
 439                                 break;
 440                 }
 441         }
 442
 443         return err;
 444 }
 445
 446 static int
 447 dsa_switch_mrp_del_ring_role(struct dsa_switch *ds,
 448                              struct dsa_notifier_mrp_ring_role_info *info)
 449 {
 450         if (!ds->ops->port_mrp_del)
 451                 return -EOPNOTSUPP;
 452
 453         if (ds->index == info->sw_index)
 454                 return ds->ops->port_mrp_del_ring_role(ds, info->port,
 455                                                        info->mrp);
 456
 457         return 0;
 458 }
 459
 460 static int dsa_switch_event(struct notifier_block *nb,
 461                             unsigned long event, void *info)
 462 {
 463         struct dsa_switch *ds = container_of(nb, struct dsa_switch, nb);
 464         int err;
 465
 466         switch (event) {
 467         case DSA_NOTIFIER_AGEING_TIME:
 468                 err = dsa_switch_ageing_time(ds, info);
 469                 break;
 470         case DSA_NOTIFIER_BRIDGE_JOIN:
 471                 err = dsa_switch_bridge_join(ds, info);
 472                 break;
 473         case DSA_NOTIFIER_BRIDGE_LEAVE:
 474                 err = dsa_switch_bridge_leave(ds, info);
 475                 break;
 476         case DSA_NOTIFIER_FDB_ADD:
 477                 err = dsa_switch_fdb_add(ds, info);
 478                 break;
 479         case DSA_NOTIFIER_FDB_DEL:
 480                 err = dsa_switch_fdb_del(ds, info);
 481                 break;
 482         case DSA_NOTIFIER_HSR_JOIN:
 483                 err = dsa_switch_hsr_join(ds, info);
 484                 break;
 485         case DSA_NOTIFIER_HSR_LEAVE:
 486                 err = dsa_switch_hsr_leave(ds, info);
 487                 break;
 488         case DSA_NOTIFIER_LAG_CHANGE:
 489                 err = dsa_switch_lag_change(ds, info);
 490                 break;
 491         case DSA_NOTIFIER_LAG_JOIN:
 492                 err = dsa_switch_lag_join(ds, info);
 493                 break;
 494         case DSA_NOTIFIER_LAG_LEAVE:
 495                 err = dsa_switch_lag_leave(ds, info);
 496                 break;
 497         case DSA_NOTIFIER_MDB_ADD:
 498                 err = dsa_switch_mdb_add(ds, info);
 499                 break;
 500         case DSA_NOTIFIER_MDB_DEL:
 501                 err = dsa_switch_mdb_del(ds, info);
 502                 break;
 503         case DSA_NOTIFIER_VLAN_ADD:
 504                 err = dsa_switch_vlan_add(ds, info);
 505                 break;
 506         case DSA_NOTIFIER_VLAN_DEL:
 507                 err = dsa_switch_vlan_del(ds, info);
 508                 break;
 509         case DSA_NOTIFIER_MTU:
 510                 err = dsa_switch_mtu(ds, info);
 511                 break;
 512         case DSA_NOTIFIER_TAG_PROTO:
 513                 err = dsa_switch_change_tag_proto(ds, info);
 514                 break;
 515         case DSA_NOTIFIER_MRP_ADD:
 516                 err = dsa_switch_mrp_add(ds, info);
 517                 break;
 518         case DSA_NOTIFIER_MRP_DEL:
 519                 err = dsa_switch_mrp_del(ds, info);
 520                 break;
 521         case DSA_NOTIFIER_MRP_ADD_RING_ROLE:
 522                 err = dsa_switch_mrp_add_ring_role(ds, info);
 523                 break;
 524         case DSA_NOTIFIER_MRP_DEL_RING_ROLE:
 525                 err = dsa_switch_mrp_del_ring_role(ds, info);
 526                 break;
 527         default:
 528                 err = -EOPNOTSUPP;
 529                 break;
 530         }
 531
 532         if (err)
 533                 dev_dbg(ds->dev, "breaking chain for DSA event %lu (%d)\n",
 534                         event, err);
 535
 536         return notifier_from_errno(err);
 537 }
 538
 539 int dsa_switch_register_notifier(struct dsa_switch *ds)
 540 {
 541         ds->nb.notifier_call = dsa_switch_event;
 542
 543         return raw_notifier_chain_register(&ds->dst->nh, &ds->nb);
 544 }
 545
 546 void dsa_switch_unregister_notifier(struct dsa_switch *ds)
 547 {
 548         int err;
 549
 550         err = raw_notifier_chain_unregister(&ds->dst->nh, &ds->nb);
 551         if (err)
 552                 dev_err(ds->dev, "failed to unregister notifier (%d)\n", err);
 553 }