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/netdevice.h>
  14 #include <linux/notifier.h>
  15 #include <net/switchdev.h>
  16
  17 #include "dsa_priv.h"
  18
  19 static unsigned int dsa_switch_fastest_ageing_time(struct dsa_switch *ds,
  20                                                    unsigned int ageing_time)
  21 {
  22         int i;
  23
  24         for (i = 0; i < ds->num_ports; ++i) {
  25                 struct dsa_port *dp = &ds->ports[i];
  26
  27                 if (dp->ageing_time && dp->ageing_time < ageing_time)
  28                         ageing_time = dp->ageing_time;
  29         }
  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         struct switchdev_trans *trans = info->trans;
  39
  40         if (switchdev_trans_ph_prepare(trans)) {
  41                 if (ds->ageing_time_min && ageing_time < ds->ageing_time_min)
  42                         return -ERANGE;
  43                 if (ds->ageing_time_max && ageing_time > ds->ageing_time_max)
  44                         return -ERANGE;
  45                 return 0;
  46         }
  47
  48         /* Program the fastest ageing time in case of multiple bridges */
  49         ageing_time = dsa_switch_fastest_ageing_time(ds, ageing_time);
  50
  51         if (ds->ops->set_ageing_time)
  52                 return ds->ops->set_ageing_time(ds, ageing_time);
  53
  54         return 0;
  55 }
  56
  57 static int dsa_switch_bridge_join(struct dsa_switch *ds,
  58                                   struct dsa_notifier_bridge_info *info)
  59 {
  60         if (ds->index == info->sw_index && ds->ops->port_bridge_join)
  61                 return ds->ops->port_bridge_join(ds, info->port, info->br);
  62
  63         if (ds->index != info->sw_index && ds->ops->crosschip_bridge_join)
  64                 return ds->ops->crosschip_bridge_join(ds, info->sw_index,
  65                                                       info->port, info->br);
  66
  67         return 0;
  68 }
  69
  70 static int dsa_switch_bridge_leave(struct dsa_switch *ds,
  71                                    struct dsa_notifier_bridge_info *info)
  72 {
  73         if (ds->index == info->sw_index && ds->ops->port_bridge_leave)
  74                 ds->ops->port_bridge_leave(ds, info->port, info->br);
  75
  76         if (ds->index != info->sw_index && ds->ops->crosschip_bridge_leave)
  77                 ds->ops->crosschip_bridge_leave(ds, info->sw_index, info->port,
  78                                                 info->br);
  79
  80         return 0;
  81 }
  82
  83 static int dsa_switch_fdb_add(struct dsa_switch *ds,
  84                               struct dsa_notifier_fdb_info *info)
  85 {
  86         const struct switchdev_obj_port_fdb *fdb = info->fdb;
  87         struct switchdev_trans *trans = info->trans;
  88
  89         /* Do not care yet about other switch chips of the fabric */
  90         if (ds->index != info->sw_index)
  91                 return 0;
  92
  93         if (switchdev_trans_ph_prepare(trans)) {
  94                 if (!ds->ops->port_fdb_prepare || !ds->ops->port_fdb_add)
  95                         return -EOPNOTSUPP;
  96
  97                 return ds->ops->port_fdb_prepare(ds, info->port, fdb->addr,
  98                                                  fdb->vid);
  99         }
 100
 101         ds->ops->port_fdb_add(ds, info->port, fdb->addr, fdb->vid);
 102
 103         return 0;
 104 }
 105
 106 static int dsa_switch_fdb_del(struct dsa_switch *ds,
 107                               struct dsa_notifier_fdb_info *info)
 108 {
 109         const struct switchdev_obj_port_fdb *fdb = info->fdb;
 110
 111         /* Do not care yet about other switch chips of the fabric */
 112         if (ds->index != info->sw_index)
 113                 return 0;
 114
 115         if (!ds->ops->port_fdb_del)
 116                 return -EOPNOTSUPP;
 117
 118         return ds->ops->port_fdb_del(ds, info->port, fdb->addr,
 119                                      fdb->vid);
 120 }
 121
 122 static int dsa_switch_mdb_add(struct dsa_switch *ds,
 123                               struct dsa_notifier_mdb_info *info)
 124 {
 125         const struct switchdev_obj_port_mdb *mdb = info->mdb;
 126         struct switchdev_trans *trans = info->trans;
 127         DECLARE_BITMAP(group, ds->num_ports);
 128         int port, err;
 129
 130         /* Build a mask of Multicast group members */
 131         bitmap_zero(group, ds->num_ports);
 132         if (ds->index == info->sw_index)
 133                 set_bit(info->port, group);
 134         for (port = 0; port < ds->num_ports; port++)
 135                 if (dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))
 136                         set_bit(port, group);
 137
 138         if (switchdev_trans_ph_prepare(trans)) {
 139                 if (!ds->ops->port_mdb_prepare || !ds->ops->port_mdb_add)
 140                         return -EOPNOTSUPP;
 141
 142                 for_each_set_bit(port, group, ds->num_ports) {
 143                         err = ds->ops->port_mdb_prepare(ds, port, mdb, trans);
 144                         if (err)
 145                                 return err;
 146                 }
 147         }
 148
 149         for_each_set_bit(port, group, ds->num_ports)
 150                 ds->ops->port_mdb_add(ds, port, mdb, trans);
 151
 152         return 0;
 153 }
 154
 155 static int dsa_switch_mdb_del(struct dsa_switch *ds,
 156                               struct dsa_notifier_mdb_info *info)
 157 {
 158         const struct switchdev_obj_port_mdb *mdb = info->mdb;
 159
 160         if (!ds->ops->port_mdb_del)
 161                 return -EOPNOTSUPP;
 162
 163         if (ds->index == info->sw_index)
 164                 return ds->ops->port_mdb_del(ds, info->port, mdb);
 165
 166         return 0;
 167 }
 168
 169 static int dsa_switch_vlan_add(struct dsa_switch *ds,
 170                                struct dsa_notifier_vlan_info *info)
 171 {
 172         const struct switchdev_obj_port_vlan *vlan = info->vlan;
 173         struct switchdev_trans *trans = info->trans;
 174         DECLARE_BITMAP(members, ds->num_ports);
 175         int port, err;
 176
 177         /* Build a mask of VLAN members */
 178         bitmap_zero(members, ds->num_ports);
 179         if (ds->index == info->sw_index)
 180                 set_bit(info->port, members);
 181         for (port = 0; port < ds->num_ports; port++)
 182                 if (dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))
 183                         set_bit(port, members);
 184
 185         if (switchdev_trans_ph_prepare(trans)) {
 186                 if (!ds->ops->port_vlan_prepare || !ds->ops->port_vlan_add)
 187                         return -EOPNOTSUPP;
 188
 189                 for_each_set_bit(port, members, ds->num_ports) {
 190                         err = ds->ops->port_vlan_prepare(ds, port, vlan, trans);
 191                         if (err)
 192                                 return err;
 193                 }
 194         }
 195
 196         for_each_set_bit(port, members, ds->num_ports)
 197                 ds->ops->port_vlan_add(ds, port, vlan, trans);
 198
 199         return 0;
 200 }
 201
 202 static int dsa_switch_vlan_del(struct dsa_switch *ds,
 203                                struct dsa_notifier_vlan_info *info)
 204 {
 205         const struct switchdev_obj_port_vlan *vlan = info->vlan;
 206
 207         if (!ds->ops->port_vlan_del)
 208                 return -EOPNOTSUPP;
 209
 210         if (ds->index == info->sw_index)
 211                 return ds->ops->port_vlan_del(ds, info->port, vlan);
 212
 213         return 0;
 214 }
 215
 216 static int dsa_switch_event(struct notifier_block *nb,
 217                             unsigned long event, void *info)
 218 {
 219         struct dsa_switch *ds = container_of(nb, struct dsa_switch, nb);
 220         int err;
 221
 222         switch (event) {
 223         case DSA_NOTIFIER_AGEING_TIME:
 224                 err = dsa_switch_ageing_time(ds, info);
 225                 break;
 226         case DSA_NOTIFIER_BRIDGE_JOIN:
 227                 err = dsa_switch_bridge_join(ds, info);
 228                 break;
 229         case DSA_NOTIFIER_BRIDGE_LEAVE:
 230                 err = dsa_switch_bridge_leave(ds, info);
 231                 break;
 232         case DSA_NOTIFIER_FDB_ADD:
 233                 err = dsa_switch_fdb_add(ds, info);
 234                 break;
 235         case DSA_NOTIFIER_FDB_DEL:
 236                 err = dsa_switch_fdb_del(ds, info);
 237                 break;
 238         case DSA_NOTIFIER_MDB_ADD:
 239                 err = dsa_switch_mdb_add(ds, info);
 240                 break;
 241         case DSA_NOTIFIER_MDB_DEL:
 242                 err = dsa_switch_mdb_del(ds, info);
 243                 break;
 244         case DSA_NOTIFIER_VLAN_ADD:
 245                 err = dsa_switch_vlan_add(ds, info);
 246                 break;
 247         case DSA_NOTIFIER_VLAN_DEL:
 248                 err = dsa_switch_vlan_del(ds, info);
 249                 break;
 250         default:
 251                 err = -EOPNOTSUPP;
 252                 break;
 253         }
 254
 255         /* Non-switchdev operations cannot be rolled back. If a DSA driver
 256          * returns an error during the chained call, switch chips may be in an
 257          * inconsistent state.
 258          */
 259         if (err)
 260                 dev_dbg(ds->dev, "breaking chain for DSA event %lu (%d)\n",
 261                         event, err);
 262
 263         return notifier_from_errno(err);
 264 }
 265
 266 int dsa_switch_register_notifier(struct dsa_switch *ds)
 267 {
 268         ds->nb.notifier_call = dsa_switch_event;
 269
 270         return raw_notifier_chain_register(&ds->dst->nh, &ds->nb);
 271 }
 272
 273 void dsa_switch_unregister_notifier(struct dsa_switch *ds)
 274 {
 275         int err;
 276
 277         err = raw_notifier_chain_unregister(&ds->dst->nh, &ds->nb);
 278         if (err)
 279                 dev_err(ds->dev, "failed to unregister notifier (%d)\n", err);
 280 }