net/dsa/switch.c

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