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 = &ds->ports[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         struct switchdev_trans *trans = info->trans;
  37
  38         if (switchdev_trans_ph_prepare(trans)) {
  39                 if (ds->ageing_time_min && ageing_time < ds->ageing_time_min)
  40                         return -ERANGE;
  41                 if (ds->ageing_time_max && ageing_time > ds->ageing_time_max)
  42                         return -ERANGE;
  43                 return 0;
  44         }
  45
  46         /* Program the fastest ageing time in case of multiple bridges */
  47         ageing_time = dsa_switch_fastest_ageing_time(ds, ageing_time);
  48
  49         if (ds->ops->set_ageing_time)
  50                 return ds->ops->set_ageing_time(ds, ageing_time);
  51
  52         return 0;
  53 }
  54
  55 static int dsa_switch_bridge_join(struct dsa_switch *ds,
  56                                   struct dsa_notifier_bridge_info *info)
  57 {
  58         if (ds->index == info->sw_index && ds->ops->port_bridge_join)
  59                 return ds->ops->port_bridge_join(ds, info->port, info->br);
  60
  61         if (ds->index != info->sw_index && ds->ops->crosschip_bridge_join)
  62                 return ds->ops->crosschip_bridge_join(ds, info->sw_index,
  63                                                       info->port, info->br);
  64
  65         return 0;
  66 }
  67
  68 static int dsa_switch_bridge_leave(struct dsa_switch *ds,
  69                                    struct dsa_notifier_bridge_info *info)
  70 {
  71         bool unset_vlan_filtering = br_vlan_enabled(info->br);
  72         int err, i;
  73
  74         if (ds->index == info->sw_index && ds->ops->port_bridge_leave)
  75                 ds->ops->port_bridge_leave(ds, info->port, info->br);
  76
  77         if (ds->index != info->sw_index && ds->ops->crosschip_bridge_leave)
  78                 ds->ops->crosschip_bridge_leave(ds, info->sw_index, info->port,
  79                                                 info->br);
  80
  81         /* If the bridge was vlan_filtering, the bridge core doesn't trigger an
  82          * event for changing vlan_filtering setting upon slave ports leaving
  83          * it. That is a good thing, because that lets us handle it and also
  84          * handle the case where the switch's vlan_filtering setting is global
  85          * (not per port). When that happens, the correct moment to trigger the
  86          * vlan_filtering callback is only when the last port left this bridge.
  87          */
  88         if (unset_vlan_filtering && ds->vlan_filtering_is_global) {
  89                 for (i = 0; i < ds->num_ports; i++) {
  90                         if (i == info->port)
  91                                 continue;
  92                         if (dsa_to_port(ds, i)->bridge_dev == info->br) {
  93                                 unset_vlan_filtering = false;
  94                                 break;
  95                         }
  96                 }
  97         }
  98         if (unset_vlan_filtering) {
  99                 struct switchdev_trans trans = {0};
 100
 101                 err = dsa_port_vlan_filtering(&ds->ports[info->port],
 102                                               false, &trans);
 103                 if (err && err != EOPNOTSUPP)
 104                         return err;
 105         }
 106         return 0;
 107 }
 108
 109 static int dsa_switch_fdb_add(struct dsa_switch *ds,
 110                               struct dsa_notifier_fdb_info *info)
 111 {
 112         int port = dsa_towards_port(ds, info->sw_index, info->port);
 113
 114         if (!ds->ops->port_fdb_add)
 115                 return -EOPNOTSUPP;
 116
 117         return ds->ops->port_fdb_add(ds, port, info->addr, info->vid);
 118 }
 119
 120 static int dsa_switch_fdb_del(struct dsa_switch *ds,
 121                               struct dsa_notifier_fdb_info *info)
 122 {
 123         int port = dsa_towards_port(ds, info->sw_index, info->port);
 124
 125         if (!ds->ops->port_fdb_del)
 126                 return -EOPNOTSUPP;
 127
 128         return ds->ops->port_fdb_del(ds, port, info->addr, info->vid);
 129 }
 130
 131 static int
 132 dsa_switch_mdb_prepare_bitmap(struct dsa_switch *ds,
 133                               const struct switchdev_obj_port_mdb *mdb,
 134                               const unsigned long *bitmap)
 135 {
 136         int port, err;
 137
 138         if (!ds->ops->port_mdb_prepare || !ds->ops->port_mdb_add)
 139                 return -EOPNOTSUPP;
 140
 141         for_each_set_bit(port, bitmap, ds->num_ports) {
 142                 err = ds->ops->port_mdb_prepare(ds, port, mdb);
 143                 if (err)
 144                         return err;
 145         }
 146
 147         return 0;
 148 }
 149
 150 static void dsa_switch_mdb_add_bitmap(struct dsa_switch *ds,
 151                                       const struct switchdev_obj_port_mdb *mdb,
 152                                       const unsigned long *bitmap)
 153 {
 154         int port;
 155
 156         for_each_set_bit(port, bitmap, ds->num_ports)
 157                 ds->ops->port_mdb_add(ds, port, mdb);
 158 }
 159
 160 static int dsa_switch_mdb_add(struct dsa_switch *ds,
 161                               struct dsa_notifier_mdb_info *info)
 162 {
 163         const struct switchdev_obj_port_mdb *mdb = info->mdb;
 164         struct switchdev_trans *trans = info->trans;
 165         int port;
 166
 167         /* Build a mask of Multicast group members */
 168         bitmap_zero(ds->bitmap, ds->num_ports);
 169         if (ds->index == info->sw_index)
 170                 set_bit(info->port, ds->bitmap);
 171         for (port = 0; port < ds->num_ports; port++)
 172                 if (dsa_is_dsa_port(ds, port))
 173                         set_bit(port, ds->bitmap);
 174
 175         if (switchdev_trans_ph_prepare(trans))
 176                 return dsa_switch_mdb_prepare_bitmap(ds, mdb, ds->bitmap);
 177
 178         dsa_switch_mdb_add_bitmap(ds, mdb, ds->bitmap);
 179
 180         return 0;
 181 }
 182
 183 static int dsa_switch_mdb_del(struct dsa_switch *ds,
 184                               struct dsa_notifier_mdb_info *info)
 185 {
 186         const struct switchdev_obj_port_mdb *mdb = info->mdb;
 187
 188         if (!ds->ops->port_mdb_del)
 189                 return -EOPNOTSUPP;
 190
 191         if (ds->index == info->sw_index)
 192                 return ds->ops->port_mdb_del(ds, info->port, mdb);
 193
 194         return 0;
 195 }
 196
 197 static int dsa_port_vlan_device_check(struct net_device *vlan_dev,
 198                                       int vlan_dev_vid,
 199                                       void *arg)
 200 {
 201         struct switchdev_obj_port_vlan *vlan = arg;
 202         u16 vid;
 203
 204         for (vid = vlan->vid_begin; vid <= vlan->vid_end; ++vid) {
 205                 if (vid == vlan_dev_vid)
 206                         return -EBUSY;
 207         }
 208
 209         return 0;
 210 }
 211
 212 static int dsa_port_vlan_check(struct dsa_switch *ds, int port,
 213                                const struct switchdev_obj_port_vlan *vlan)
 214 {
 215         const struct dsa_port *dp = dsa_to_port(ds, port);
 216         int err = 0;
 217
 218         /* Device is not bridged, let it proceed with the VLAN device
 219          * creation.
 220          */
 221         if (!dp->bridge_dev)
 222                 return err;
 223
 224         /* dsa_slave_vlan_rx_{add,kill}_vid() cannot use the prepare phase and
 225          * already checks whether there is an overlapping bridge VLAN entry
 226          * with the same VID, so here we only need to check that if we are
 227          * adding a bridge VLAN entry there is not an overlapping VLAN device
 228          * claiming that VID.
 229          */
 230         return vlan_for_each(dp->slave, dsa_port_vlan_device_check,
 231                              (void *)vlan);
 232 }
 233
 234 static int
 235 dsa_switch_vlan_prepare_bitmap(struct dsa_switch *ds,
 236                                const struct switchdev_obj_port_vlan *vlan,
 237                                const unsigned long *bitmap)
 238 {
 239         int port, err;
 240
 241         if (!ds->ops->port_vlan_prepare || !ds->ops->port_vlan_add)
 242                 return -EOPNOTSUPP;
 243
 244         for_each_set_bit(port, bitmap, ds->num_ports) {
 245                 err = dsa_port_vlan_check(ds, port, vlan);
 246                 if (err)
 247                         return err;
 248
 249                 err = ds->ops->port_vlan_prepare(ds, port, vlan);
 250                 if (err)
 251                         return err;
 252         }
 253
 254         return 0;
 255 }
 256
 257 static void
 258 dsa_switch_vlan_add_bitmap(struct dsa_switch *ds,
 259                            const struct switchdev_obj_port_vlan *vlan,
 260                            const unsigned long *bitmap)
 261 {
 262         int port;
 263
 264         for_each_set_bit(port, bitmap, ds->num_ports)
 265                 ds->ops->port_vlan_add(ds, port, vlan);
 266 }
 267
 268 static int dsa_switch_vlan_add(struct dsa_switch *ds,
 269                                struct dsa_notifier_vlan_info *info)
 270 {
 271         const struct switchdev_obj_port_vlan *vlan = info->vlan;
 272         struct switchdev_trans *trans = info->trans;
 273         int port;
 274
 275         /* Build a mask of VLAN members */
 276         bitmap_zero(ds->bitmap, ds->num_ports);
 277         if (ds->index == info->sw_index)
 278                 set_bit(info->port, ds->bitmap);
 279         for (port = 0; port < ds->num_ports; port++)
 280                 if (dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))
 281                         set_bit(port, ds->bitmap);
 282
 283         if (switchdev_trans_ph_prepare(trans))
 284                 return dsa_switch_vlan_prepare_bitmap(ds, vlan, ds->bitmap);
 285
 286         dsa_switch_vlan_add_bitmap(ds, vlan, ds->bitmap);
 287
 288         return 0;
 289 }
 290
 291 static int dsa_switch_vlan_del(struct dsa_switch *ds,
 292                                struct dsa_notifier_vlan_info *info)
 293 {
 294         const struct switchdev_obj_port_vlan *vlan = info->vlan;
 295
 296         if (!ds->ops->port_vlan_del)
 297                 return -EOPNOTSUPP;
 298
 299         if (ds->index == info->sw_index)
 300                 return ds->ops->port_vlan_del(ds, info->port, vlan);
 301
 302         return 0;
 303 }
 304
 305 static int dsa_switch_event(struct notifier_block *nb,
 306                             unsigned long event, void *info)
 307 {
 308         struct dsa_switch *ds = container_of(nb, struct dsa_switch, nb);
 309         int err;
 310
 311         switch (event) {
 312         case DSA_NOTIFIER_AGEING_TIME:
 313                 err = dsa_switch_ageing_time(ds, info);
 314                 break;
 315         case DSA_NOTIFIER_BRIDGE_JOIN:
 316                 err = dsa_switch_bridge_join(ds, info);
 317                 break;
 318         case DSA_NOTIFIER_BRIDGE_LEAVE:
 319                 err = dsa_switch_bridge_leave(ds, info);
 320                 break;
 321         case DSA_NOTIFIER_FDB_ADD:
 322                 err = dsa_switch_fdb_add(ds, info);
 323                 break;
 324         case DSA_NOTIFIER_FDB_DEL:
 325                 err = dsa_switch_fdb_del(ds, info);
 326                 break;
 327         case DSA_NOTIFIER_MDB_ADD:
 328                 err = dsa_switch_mdb_add(ds, info);
 329                 break;
 330         case DSA_NOTIFIER_MDB_DEL:
 331                 err = dsa_switch_mdb_del(ds, info);
 332                 break;
 333         case DSA_NOTIFIER_VLAN_ADD:
 334                 err = dsa_switch_vlan_add(ds, info);
 335                 break;
 336         case DSA_NOTIFIER_VLAN_DEL:
 337                 err = dsa_switch_vlan_del(ds, info);
 338                 break;
 339         default:
 340                 err = -EOPNOTSUPP;
 341                 break;
 342         }
 343
 344         /* Non-switchdev operations cannot be rolled back. If a DSA driver
 345          * returns an error during the chained call, switch chips may be in an
 346          * inconsistent state.
 347          */
 348         if (err)
 349                 dev_dbg(ds->dev, "breaking chain for DSA event %lu (%d)\n",
 350                         event, err);
 351
 352         return notifier_from_errno(err);
 353 }
 354
 355 int dsa_switch_register_notifier(struct dsa_switch *ds)
 356 {
 357         ds->nb.notifier_call = dsa_switch_event;
 358
 359         return raw_notifier_chain_register(&ds->dst->nh, &ds->nb);
 360 }
 361
 362 void dsa_switch_unregister_notifier(struct dsa_switch *ds)
 363 {
 364         int err;
 365
 366         err = raw_notifier_chain_unregister(&ds->dst->nh, &ds->nb);
 367         if (err)
 368                 dev_err(ds->dev, "failed to unregister notifier (%d)\n", err);
 369 }