drivers/net/ethernet/mellanox/mlxsw/spectrum_fid.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /* Copyright (c) 2017-2018 Mellanox Technologies. All rights reserved */
   3
   4 #include <linux/kernel.h>
   5 #include <linux/bitops.h>
   6 #include <linux/if_vlan.h>
   7 #include <linux/if_bridge.h>
   8 #include <linux/netdevice.h>
   9 #include <linux/rhashtable.h>
  10 #include <linux/rtnetlink.h>
  11 #include <linux/refcount.h>
  12
  13 #include "spectrum.h"
  14 #include "reg.h"
  15
  16 struct mlxsw_sp_fid_family;
  17
  18 struct mlxsw_sp_fid_core {
  19         struct rhashtable fid_ht;
  20         struct rhashtable vni_ht;
  21         struct mlxsw_sp_fid_family *fid_family_arr[MLXSW_SP_FID_TYPE_MAX];
  22         unsigned int *port_fid_mappings;
  23 };
  24
  25 struct mlxsw_sp_fid_port_vid {
  26         struct list_head list;
  27         u16 local_port;
  28         u16 vid;
  29 };
  30
  31 struct mlxsw_sp_fid {
  32         struct list_head list;
  33         struct mlxsw_sp_rif *rif;
  34         refcount_t ref_count;
  35         u16 fid_index;
  36         u16 fid_offset;
  37         struct mlxsw_sp_fid_family *fid_family;
  38         struct rhash_head ht_node;
  39
  40         struct rhash_head vni_ht_node;
  41         enum mlxsw_sp_nve_type nve_type;
  42         __be32 vni;
  43         u32 nve_flood_index;
  44         int nve_ifindex;
  45         u8 vni_valid:1,
  46            nve_flood_index_valid:1;
  47         struct list_head port_vid_list; /* Ordered by local port. */
  48 };
  49
  50 struct mlxsw_sp_fid_8021q {
  51         struct mlxsw_sp_fid common;
  52         u16 vid;
  53 };
  54
  55 struct mlxsw_sp_fid_8021d {
  56         struct mlxsw_sp_fid common;
  57         int br_ifindex;
  58 };
  59
  60 static const struct rhashtable_params mlxsw_sp_fid_ht_params = {
  61         .key_len = sizeof_field(struct mlxsw_sp_fid, fid_index),
  62         .key_offset = offsetof(struct mlxsw_sp_fid, fid_index),
  63         .head_offset = offsetof(struct mlxsw_sp_fid, ht_node),
  64 };
  65
  66 static const struct rhashtable_params mlxsw_sp_fid_vni_ht_params = {
  67         .key_len = sizeof_field(struct mlxsw_sp_fid, vni),
  68         .key_offset = offsetof(struct mlxsw_sp_fid, vni),
  69         .head_offset = offsetof(struct mlxsw_sp_fid, vni_ht_node),
  70 };
  71
  72 struct mlxsw_sp_flood_table {
  73         enum mlxsw_sp_flood_type packet_type;
  74         enum mlxsw_flood_table_type table_type;
  75         int table_index;
  76 };
  77
  78 struct mlxsw_sp_fid_ops {
  79         void (*setup)(struct mlxsw_sp_fid *fid, const void *arg);
  80         int (*configure)(struct mlxsw_sp_fid *fid);
  81         void (*deconfigure)(struct mlxsw_sp_fid *fid);
  82         int (*index_alloc)(struct mlxsw_sp_fid *fid, const void *arg,
  83                            u16 *p_fid_index);
  84         bool (*compare)(const struct mlxsw_sp_fid *fid,
  85                         const void *arg);
  86         int (*port_vid_map)(struct mlxsw_sp_fid *fid,
  87                             struct mlxsw_sp_port *port, u16 vid);
  88         void (*port_vid_unmap)(struct mlxsw_sp_fid *fid,
  89                                struct mlxsw_sp_port *port, u16 vid);
  90         int (*vni_set)(struct mlxsw_sp_fid *fid);
  91         void (*vni_clear)(struct mlxsw_sp_fid *fid);
  92         int (*nve_flood_index_set)(struct mlxsw_sp_fid *fid);
  93         void (*nve_flood_index_clear)(struct mlxsw_sp_fid *fid);
  94         void (*fdb_clear_offload)(const struct mlxsw_sp_fid *fid,
  95                                   const struct net_device *nve_dev);
  96         int (*vid_to_fid_rif_update)(const struct mlxsw_sp_fid *fid,
  97                                      const struct mlxsw_sp_rif *rif);
  98 };
  99
 100 struct mlxsw_sp_fid_family {
 101         enum mlxsw_sp_fid_type type;
 102         size_t fid_size;
 103         u16 start_index;
 104         u16 end_index;
 105         struct list_head fids_list;
 106         unsigned long *fids_bitmap;
 107         const struct mlxsw_sp_flood_table *flood_tables;
 108         int nr_flood_tables;
 109         enum mlxsw_sp_rif_type rif_type;
 110         const struct mlxsw_sp_fid_ops *ops;
 111         struct mlxsw_sp *mlxsw_sp;
 112         bool flood_rsp;
 113         enum mlxsw_reg_bridge_type bridge_type;
 114         u16 pgt_base;
 115         bool smpe_index_valid;
 116 };
 117
 118 static const int mlxsw_sp_sfgc_uc_packet_types[MLXSW_REG_SFGC_TYPE_MAX] = {
 119         [MLXSW_REG_SFGC_TYPE_UNKNOWN_UNICAST]                   = 1,
 120 };
 121
 122 static const int mlxsw_sp_sfgc_bc_packet_types[MLXSW_REG_SFGC_TYPE_MAX] = {
 123         [MLXSW_REG_SFGC_TYPE_BROADCAST]                         = 1,
 124         [MLXSW_REG_SFGC_TYPE_UNREGISTERED_MULTICAST_NON_IP]     = 1,
 125         [MLXSW_REG_SFGC_TYPE_IPV4_LINK_LOCAL]                   = 1,
 126         [MLXSW_REG_SFGC_TYPE_IPV6_ALL_HOST]                     = 1,
 127         [MLXSW_REG_SFGC_TYPE_UNREGISTERED_MULTICAST_IPV6]       = 1,
 128 };
 129
 130 static const int mlxsw_sp_sfgc_mc_packet_types[MLXSW_REG_SFGC_TYPE_MAX] = {
 131         [MLXSW_REG_SFGC_TYPE_UNREGISTERED_MULTICAST_IPV4]       = 1,
 132 };
 133
 134 static const int *mlxsw_sp_packet_type_sfgc_types[] = {
 135         [MLXSW_SP_FLOOD_TYPE_UC]        = mlxsw_sp_sfgc_uc_packet_types,
 136         [MLXSW_SP_FLOOD_TYPE_BC]        = mlxsw_sp_sfgc_bc_packet_types,
 137         [MLXSW_SP_FLOOD_TYPE_MC]        = mlxsw_sp_sfgc_mc_packet_types,
 138 };
 139
 140 bool mlxsw_sp_fid_is_dummy(struct mlxsw_sp *mlxsw_sp, u16 fid_index)
 141 {
 142         enum mlxsw_sp_fid_type fid_type = MLXSW_SP_FID_TYPE_DUMMY;
 143         struct mlxsw_sp_fid_family *fid_family;
 144
 145         fid_family = mlxsw_sp->fid_core->fid_family_arr[fid_type];
 146
 147         return fid_family->start_index == fid_index;
 148 }
 149
 150 struct mlxsw_sp_fid *mlxsw_sp_fid_lookup_by_index(struct mlxsw_sp *mlxsw_sp,
 151                                                   u16 fid_index)
 152 {
 153         struct mlxsw_sp_fid *fid;
 154
 155         fid = rhashtable_lookup_fast(&mlxsw_sp->fid_core->fid_ht, &fid_index,
 156                                      mlxsw_sp_fid_ht_params);
 157         if (fid)
 158                 refcount_inc(&fid->ref_count);
 159
 160         return fid;
 161 }
 162
 163 int mlxsw_sp_fid_nve_ifindex(const struct mlxsw_sp_fid *fid, int *nve_ifindex)
 164 {
 165         if (!fid->vni_valid)
 166                 return -EINVAL;
 167
 168         *nve_ifindex = fid->nve_ifindex;
 169
 170         return 0;
 171 }
 172
 173 int mlxsw_sp_fid_nve_type(const struct mlxsw_sp_fid *fid,
 174                           enum mlxsw_sp_nve_type *p_type)
 175 {
 176         if (!fid->vni_valid)
 177                 return -EINVAL;
 178
 179         *p_type = fid->nve_type;
 180
 181         return 0;
 182 }
 183
 184 struct mlxsw_sp_fid *mlxsw_sp_fid_lookup_by_vni(struct mlxsw_sp *mlxsw_sp,
 185                                                 __be32 vni)
 186 {
 187         struct mlxsw_sp_fid *fid;
 188
 189         fid = rhashtable_lookup_fast(&mlxsw_sp->fid_core->vni_ht, &vni,
 190                                      mlxsw_sp_fid_vni_ht_params);
 191         if (fid)
 192                 refcount_inc(&fid->ref_count);
 193
 194         return fid;
 195 }
 196
 197 int mlxsw_sp_fid_vni(const struct mlxsw_sp_fid *fid, __be32 *vni)
 198 {
 199         if (!fid->vni_valid)
 200                 return -EINVAL;
 201
 202         *vni = fid->vni;
 203
 204         return 0;
 205 }
 206
 207 int mlxsw_sp_fid_nve_flood_index_set(struct mlxsw_sp_fid *fid,
 208                                      u32 nve_flood_index)
 209 {
 210         struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
 211         const struct mlxsw_sp_fid_ops *ops = fid_family->ops;
 212         int err;
 213
 214         if (WARN_ON(fid->nve_flood_index_valid))
 215                 return -EINVAL;
 216
 217         fid->nve_flood_index = nve_flood_index;
 218         fid->nve_flood_index_valid = true;
 219         err = ops->nve_flood_index_set(fid);
 220         if (err)
 221                 goto err_nve_flood_index_set;
 222
 223         return 0;
 224
 225 err_nve_flood_index_set:
 226         fid->nve_flood_index_valid = false;
 227         return err;
 228 }
 229
 230 void mlxsw_sp_fid_nve_flood_index_clear(struct mlxsw_sp_fid *fid)
 231 {
 232         struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
 233         const struct mlxsw_sp_fid_ops *ops = fid_family->ops;
 234
 235         if (WARN_ON(!fid->nve_flood_index_valid))
 236                 return;
 237
 238         fid->nve_flood_index_valid = false;
 239         ops->nve_flood_index_clear(fid);
 240 }
 241
 242 bool mlxsw_sp_fid_nve_flood_index_is_set(const struct mlxsw_sp_fid *fid)
 243 {
 244         return fid->nve_flood_index_valid;
 245 }
 246
 247 int mlxsw_sp_fid_vni_set(struct mlxsw_sp_fid *fid, enum mlxsw_sp_nve_type type,
 248                          __be32 vni, int nve_ifindex)
 249 {
 250         struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
 251         const struct mlxsw_sp_fid_ops *ops = fid_family->ops;
 252         struct mlxsw_sp *mlxsw_sp = fid_family->mlxsw_sp;
 253         int err;
 254
 255         if (WARN_ON(fid->vni_valid))
 256                 return -EINVAL;
 257
 258         fid->nve_type = type;
 259         fid->nve_ifindex = nve_ifindex;
 260         fid->vni = vni;
 261         err = rhashtable_lookup_insert_fast(&mlxsw_sp->fid_core->vni_ht,
 262                                             &fid->vni_ht_node,
 263                                             mlxsw_sp_fid_vni_ht_params);
 264         if (err)
 265                 return err;
 266
 267         fid->vni_valid = true;
 268         err = ops->vni_set(fid);
 269         if (err)
 270                 goto err_vni_set;
 271
 272         return 0;
 273
 274 err_vni_set:
 275         fid->vni_valid = false;
 276         rhashtable_remove_fast(&mlxsw_sp->fid_core->vni_ht, &fid->vni_ht_node,
 277                                mlxsw_sp_fid_vni_ht_params);
 278         return err;
 279 }
 280
 281 void mlxsw_sp_fid_vni_clear(struct mlxsw_sp_fid *fid)
 282 {
 283         struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
 284         const struct mlxsw_sp_fid_ops *ops = fid_family->ops;
 285         struct mlxsw_sp *mlxsw_sp = fid_family->mlxsw_sp;
 286
 287         if (WARN_ON(!fid->vni_valid))
 288                 return;
 289
 290         fid->vni_valid = false;
 291         ops->vni_clear(fid);
 292         rhashtable_remove_fast(&mlxsw_sp->fid_core->vni_ht, &fid->vni_ht_node,
 293                                mlxsw_sp_fid_vni_ht_params);
 294 }
 295
 296 bool mlxsw_sp_fid_vni_is_set(const struct mlxsw_sp_fid *fid)
 297 {
 298         return fid->vni_valid;
 299 }
 300
 301 void mlxsw_sp_fid_fdb_clear_offload(const struct mlxsw_sp_fid *fid,
 302                                     const struct net_device *nve_dev)
 303 {
 304         struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
 305         const struct mlxsw_sp_fid_ops *ops = fid_family->ops;
 306
 307         if (ops->fdb_clear_offload)
 308                 ops->fdb_clear_offload(fid, nve_dev);
 309 }
 310
 311 static const struct mlxsw_sp_flood_table *
 312 mlxsw_sp_fid_flood_table_lookup(const struct mlxsw_sp_fid *fid,
 313                                 enum mlxsw_sp_flood_type packet_type)
 314 {
 315         struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
 316         int i;
 317
 318         for (i = 0; i < fid_family->nr_flood_tables; i++) {
 319                 if (fid_family->flood_tables[i].packet_type != packet_type)
 320                         continue;
 321                 return &fid_family->flood_tables[i];
 322         }
 323
 324         return NULL;
 325 }
 326
 327 static u16
 328 mlxsw_sp_fid_family_num_fids(const struct mlxsw_sp_fid_family *fid_family)
 329 {
 330         return fid_family->end_index - fid_family->start_index + 1;
 331 }
 332
 333 static u16
 334 mlxsw_sp_fid_flood_table_mid(const struct mlxsw_sp_fid_family *fid_family,
 335                              const struct mlxsw_sp_flood_table *flood_table,
 336                              u16 fid_offset)
 337 {
 338         u16 num_fids;
 339
 340         num_fids = mlxsw_sp_fid_family_num_fids(fid_family);
 341         return fid_family->pgt_base + num_fids * flood_table->table_index +
 342                fid_offset;
 343 }
 344
 345 int mlxsw_sp_fid_flood_set(struct mlxsw_sp_fid *fid,
 346                            enum mlxsw_sp_flood_type packet_type, u16 local_port,
 347                            bool member)
 348 {
 349         struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
 350         const struct mlxsw_sp_flood_table *flood_table;
 351         u16 mid_index;
 352
 353         if (WARN_ON(!fid_family->flood_tables))
 354                 return -EINVAL;
 355
 356         flood_table = mlxsw_sp_fid_flood_table_lookup(fid, packet_type);
 357         if (!flood_table)
 358                 return -ESRCH;
 359
 360         mid_index = mlxsw_sp_fid_flood_table_mid(fid_family, flood_table,
 361                                                  fid->fid_offset);
 362         return mlxsw_sp_pgt_entry_port_set(fid_family->mlxsw_sp, mid_index,
 363                                            fid->fid_index, local_port, member);
 364 }
 365
 366 int mlxsw_sp_fid_port_vid_map(struct mlxsw_sp_fid *fid,
 367                               struct mlxsw_sp_port *mlxsw_sp_port, u16 vid)
 368 {
 369         if (WARN_ON(!fid->fid_family->ops->port_vid_map))
 370                 return -EINVAL;
 371         return fid->fid_family->ops->port_vid_map(fid, mlxsw_sp_port, vid);
 372 }
 373
 374 void mlxsw_sp_fid_port_vid_unmap(struct mlxsw_sp_fid *fid,
 375                                  struct mlxsw_sp_port *mlxsw_sp_port, u16 vid)
 376 {
 377         fid->fid_family->ops->port_vid_unmap(fid, mlxsw_sp_port, vid);
 378 }
 379
 380 u16 mlxsw_sp_fid_index(const struct mlxsw_sp_fid *fid)
 381 {
 382         return fid->fid_index;
 383 }
 384
 385 enum mlxsw_sp_fid_type mlxsw_sp_fid_type(const struct mlxsw_sp_fid *fid)
 386 {
 387         return fid->fid_family->type;
 388 }
 389
 390 struct mlxsw_sp_rif *mlxsw_sp_fid_rif(const struct mlxsw_sp_fid *fid)
 391 {
 392         return fid->rif;
 393 }
 394
 395 enum mlxsw_sp_rif_type
 396 mlxsw_sp_fid_type_rif_type(const struct mlxsw_sp *mlxsw_sp,
 397                            enum mlxsw_sp_fid_type type)
 398 {
 399         struct mlxsw_sp_fid_core *fid_core = mlxsw_sp->fid_core;
 400
 401         return fid_core->fid_family_arr[type]->rif_type;
 402 }
 403
 404 static struct mlxsw_sp_fid_8021q *
 405 mlxsw_sp_fid_8021q_fid(const struct mlxsw_sp_fid *fid)
 406 {
 407         return container_of(fid, struct mlxsw_sp_fid_8021q, common);
 408 }
 409
 410 u16 mlxsw_sp_fid_8021q_vid(const struct mlxsw_sp_fid *fid)
 411 {
 412         return mlxsw_sp_fid_8021q_fid(fid)->vid;
 413 }
 414
 415 static void mlxsw_sp_fid_8021q_setup(struct mlxsw_sp_fid *fid, const void *arg)
 416 {
 417         u16 vid = *(u16 *) arg;
 418
 419         mlxsw_sp_fid_8021q_fid(fid)->vid = vid;
 420         fid->fid_offset = fid->fid_index - fid->fid_family->start_index;
 421 }
 422
 423 static enum mlxsw_reg_sfmr_op mlxsw_sp_sfmr_op(bool valid)
 424 {
 425         return valid ? MLXSW_REG_SFMR_OP_CREATE_FID :
 426                        MLXSW_REG_SFMR_OP_DESTROY_FID;
 427 }
 428
 429 static int mlxsw_sp_fid_op(const struct mlxsw_sp_fid *fid, bool valid)
 430 {
 431         struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
 432         char sfmr_pl[MLXSW_REG_SFMR_LEN];
 433         u16 smpe;
 434
 435         smpe = fid->fid_family->smpe_index_valid ? fid->fid_index : 0;
 436
 437         mlxsw_reg_sfmr_pack(sfmr_pl, mlxsw_sp_sfmr_op(valid), fid->fid_index,
 438                             fid->fid_offset, fid->fid_family->flood_rsp,
 439                             fid->fid_family->bridge_type,
 440                             fid->fid_family->smpe_index_valid, smpe);
 441         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfmr), sfmr_pl);
 442 }
 443
 444 static int mlxsw_sp_fid_edit_op(const struct mlxsw_sp_fid *fid,
 445                                 const struct mlxsw_sp_rif *rif)
 446 {
 447         struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
 448         char sfmr_pl[MLXSW_REG_SFMR_LEN];
 449         u16 smpe;
 450
 451         smpe = fid->fid_family->smpe_index_valid ? fid->fid_index : 0;
 452
 453         mlxsw_reg_sfmr_pack(sfmr_pl, MLXSW_REG_SFMR_OP_CREATE_FID,
 454                             fid->fid_index, fid->fid_offset,
 455                             fid->fid_family->flood_rsp,
 456                             fid->fid_family->bridge_type,
 457                             fid->fid_family->smpe_index_valid, smpe);
 458         mlxsw_reg_sfmr_vv_set(sfmr_pl, fid->vni_valid);
 459         mlxsw_reg_sfmr_vni_set(sfmr_pl, be32_to_cpu(fid->vni));
 460         mlxsw_reg_sfmr_vtfp_set(sfmr_pl, fid->nve_flood_index_valid);
 461         mlxsw_reg_sfmr_nve_tunnel_flood_ptr_set(sfmr_pl, fid->nve_flood_index);
 462
 463         if (rif) {
 464                 mlxsw_reg_sfmr_irif_v_set(sfmr_pl, true);
 465                 mlxsw_reg_sfmr_irif_set(sfmr_pl, mlxsw_sp_rif_index(rif));
 466         }
 467
 468         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfmr), sfmr_pl);
 469 }
 470
 471 static int mlxsw_sp_fid_vni_to_fid_map(const struct mlxsw_sp_fid *fid,
 472                                        const struct mlxsw_sp_rif *rif,
 473                                        bool valid)
 474 {
 475         struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
 476         char svfa_pl[MLXSW_REG_SVFA_LEN];
 477         bool irif_valid;
 478         u16 irif_index;
 479
 480         irif_valid = !!rif;
 481         irif_index = rif ? mlxsw_sp_rif_index(rif) : 0;
 482
 483         mlxsw_reg_svfa_vni_pack(svfa_pl, valid, fid->fid_index,
 484                                 be32_to_cpu(fid->vni), irif_valid, irif_index);
 485         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(svfa), svfa_pl);
 486 }
 487
 488 static int mlxsw_sp_fid_to_fid_rif_update(const struct mlxsw_sp_fid *fid,
 489                                           const struct mlxsw_sp_rif *rif)
 490 {
 491         return mlxsw_sp_fid_edit_op(fid, rif);
 492 }
 493
 494 static int mlxsw_sp_fid_vni_to_fid_rif_update(const struct mlxsw_sp_fid *fid,
 495                                               const struct mlxsw_sp_rif *rif)
 496 {
 497         if (!fid->vni_valid)
 498                 return 0;
 499
 500         return mlxsw_sp_fid_vni_to_fid_map(fid, rif, fid->vni_valid);
 501 }
 502
 503 static int
 504 mlxsw_sp_fid_vid_to_fid_map(const struct mlxsw_sp_fid *fid, u16 vid, bool valid,
 505                             const struct mlxsw_sp_rif *rif)
 506 {
 507         struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
 508         char svfa_pl[MLXSW_REG_SVFA_LEN];
 509         bool irif_valid;
 510         u16 irif_index;
 511
 512         irif_valid = !!rif;
 513         irif_index = rif ? mlxsw_sp_rif_index(rif) : 0;
 514
 515         mlxsw_reg_svfa_vid_pack(svfa_pl, valid, fid->fid_index, vid, irif_valid,
 516                                 irif_index);
 517         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(svfa), svfa_pl);
 518 }
 519
 520 static int
 521 mlxsw_sp_fid_8021q_vid_to_fid_rif_update(const struct mlxsw_sp_fid *fid,
 522                                          const struct mlxsw_sp_rif *rif)
 523 {
 524         struct mlxsw_sp_fid_8021q *fid_8021q = mlxsw_sp_fid_8021q_fid(fid);
 525
 526         /* Update the global VID => FID mapping we created when the FID was
 527          * configured.
 528          */
 529         return mlxsw_sp_fid_vid_to_fid_map(fid, fid_8021q->vid, true, rif);
 530 }
 531
 532 static int
 533 mlxsw_sp_fid_port_vid_to_fid_rif_update_one(const struct mlxsw_sp_fid *fid,
 534                                             struct mlxsw_sp_fid_port_vid *pv,
 535                                             bool irif_valid, u16 irif_index)
 536 {
 537         struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
 538         char svfa_pl[MLXSW_REG_SVFA_LEN];
 539
 540         mlxsw_reg_svfa_port_vid_pack(svfa_pl, pv->local_port, true,
 541                                      fid->fid_index, pv->vid, irif_valid,
 542                                      irif_index);
 543
 544         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(svfa), svfa_pl);
 545 }
 546
 547 static int mlxsw_sp_fid_vid_to_fid_rif_set(const struct mlxsw_sp_fid *fid,
 548                                            const struct mlxsw_sp_rif *rif)
 549 {
 550         struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
 551         struct mlxsw_sp_fid_port_vid *pv;
 552         u16 irif_index;
 553         int err;
 554
 555         err = fid->fid_family->ops->vid_to_fid_rif_update(fid, rif);
 556         if (err)
 557                 return err;
 558
 559         irif_index = mlxsw_sp_rif_index(rif);
 560
 561         list_for_each_entry(pv, &fid->port_vid_list, list) {
 562                 /* If port is not in virtual mode, then it does not have any
 563                  * {Port, VID}->FID mappings that need to be updated with the
 564                  * ingress RIF.
 565                  */
 566                 if (!mlxsw_sp->fid_core->port_fid_mappings[pv->local_port])
 567                         continue;
 568
 569                 err = mlxsw_sp_fid_port_vid_to_fid_rif_update_one(fid, pv,
 570                                                                   true,
 571                                                                   irif_index);
 572                 if (err)
 573                         goto err_port_vid_to_fid_rif_update_one;
 574         }
 575
 576         return 0;
 577
 578 err_port_vid_to_fid_rif_update_one:
 579         list_for_each_entry_continue_reverse(pv, &fid->port_vid_list, list) {
 580                 if (!mlxsw_sp->fid_core->port_fid_mappings[pv->local_port])
 581                         continue;
 582
 583                 mlxsw_sp_fid_port_vid_to_fid_rif_update_one(fid, pv, false, 0);
 584         }
 585
 586         fid->fid_family->ops->vid_to_fid_rif_update(fid, NULL);
 587         return err;
 588 }
 589
 590 static void mlxsw_sp_fid_vid_to_fid_rif_unset(const struct mlxsw_sp_fid *fid)
 591 {
 592         struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
 593         struct mlxsw_sp_fid_port_vid *pv;
 594
 595         list_for_each_entry(pv, &fid->port_vid_list, list) {
 596                 /* If port is not in virtual mode, then it does not have any
 597                  * {Port, VID}->FID mappings that need to be updated.
 598                  */
 599                 if (!mlxsw_sp->fid_core->port_fid_mappings[pv->local_port])
 600                         continue;
 601
 602                 mlxsw_sp_fid_port_vid_to_fid_rif_update_one(fid, pv, false, 0);
 603         }
 604
 605         fid->fid_family->ops->vid_to_fid_rif_update(fid, NULL);
 606 }
 607
 608 static int mlxsw_sp_fid_reiv_handle(struct mlxsw_sp_fid *fid, u16 rif_index,
 609                                     bool valid, u8 port_page)
 610 {
 611         u16 local_port_end = (port_page + 1) * MLXSW_REG_REIV_REC_MAX_COUNT - 1;
 612         u16 local_port_start = port_page * MLXSW_REG_REIV_REC_MAX_COUNT;
 613         struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
 614         struct mlxsw_sp_fid_port_vid *port_vid;
 615         u8 rec_num, entries_num = 0;
 616         char *reiv_pl;
 617         int err;
 618
 619         reiv_pl = kmalloc(MLXSW_REG_REIV_LEN, GFP_KERNEL);
 620         if (!reiv_pl)
 621                 return -ENOMEM;
 622
 623         mlxsw_reg_reiv_pack(reiv_pl, port_page, rif_index);
 624
 625         list_for_each_entry(port_vid, &fid->port_vid_list, list) {
 626                 /* port_vid_list is sorted by local_port. */
 627                 if (port_vid->local_port < local_port_start)
 628                         continue;
 629
 630                 if (port_vid->local_port > local_port_end)
 631                         break;
 632
 633                 rec_num = port_vid->local_port % MLXSW_REG_REIV_REC_MAX_COUNT;
 634                 mlxsw_reg_reiv_rec_update_set(reiv_pl, rec_num, true);
 635                 mlxsw_reg_reiv_rec_evid_set(reiv_pl, rec_num,
 636                                             valid ? port_vid->vid : 0);
 637                 entries_num++;
 638         }
 639
 640         if (!entries_num) {
 641                 kfree(reiv_pl);
 642                 return 0;
 643         }
 644
 645         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(reiv), reiv_pl);
 646         if (err)
 647                 goto err_reg_write;
 648
 649         kfree(reiv_pl);
 650         return 0;
 651
 652 err_reg_write:
 653         kfree(reiv_pl);
 654         return err;
 655 }
 656
 657 static int mlxsw_sp_fid_erif_eport_to_vid_map(struct mlxsw_sp_fid *fid,
 658                                               u16 rif_index, bool valid)
 659 {
 660         struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
 661         u8 num_port_pages;
 662         int err, i;
 663
 664         num_port_pages = mlxsw_core_max_ports(mlxsw_sp->core) /
 665                          MLXSW_REG_REIV_REC_MAX_COUNT + 1;
 666
 667         for (i = 0; i < num_port_pages; i++) {
 668                 err = mlxsw_sp_fid_reiv_handle(fid, rif_index, valid, i);
 669                 if (err)
 670                         goto err_reiv_handle;
 671         }
 672
 673         return 0;
 674
 675 err_reiv_handle:
 676         for (; i >= 0; i--)
 677                 mlxsw_sp_fid_reiv_handle(fid, rif_index, !valid, i);
 678         return err;
 679 }
 680
 681 int mlxsw_sp_fid_rif_set(struct mlxsw_sp_fid *fid, struct mlxsw_sp_rif *rif)
 682 {
 683         u16 rif_index = mlxsw_sp_rif_index(rif);
 684         int err;
 685
 686         err = mlxsw_sp_fid_to_fid_rif_update(fid, rif);
 687         if (err)
 688                 return err;
 689
 690         err = mlxsw_sp_fid_vni_to_fid_rif_update(fid, rif);
 691         if (err)
 692                 goto err_vni_to_fid_rif_update;
 693
 694         err = mlxsw_sp_fid_vid_to_fid_rif_set(fid, rif);
 695         if (err)
 696                 goto err_vid_to_fid_rif_set;
 697
 698         err = mlxsw_sp_fid_erif_eport_to_vid_map(fid, rif_index, true);
 699         if (err)
 700                 goto err_erif_eport_to_vid_map;
 701
 702         fid->rif = rif;
 703         return 0;
 704
 705 err_erif_eport_to_vid_map:
 706         mlxsw_sp_fid_vid_to_fid_rif_unset(fid);
 707 err_vid_to_fid_rif_set:
 708         mlxsw_sp_fid_vni_to_fid_rif_update(fid, NULL);
 709 err_vni_to_fid_rif_update:
 710         mlxsw_sp_fid_to_fid_rif_update(fid, NULL);
 711         return err;
 712 }
 713
 714 void mlxsw_sp_fid_rif_unset(struct mlxsw_sp_fid *fid)
 715 {
 716         u16 rif_index;
 717
 718         if (!fid->rif)
 719                 return;
 720
 721         rif_index = mlxsw_sp_rif_index(fid->rif);
 722         fid->rif = NULL;
 723
 724         mlxsw_sp_fid_erif_eport_to_vid_map(fid, rif_index, false);
 725         mlxsw_sp_fid_vid_to_fid_rif_unset(fid);
 726         mlxsw_sp_fid_vni_to_fid_rif_update(fid, NULL);
 727         mlxsw_sp_fid_to_fid_rif_update(fid, NULL);
 728 }
 729
 730 static int mlxsw_sp_fid_vni_op(const struct mlxsw_sp_fid *fid)
 731 {
 732         int err;
 733
 734         err = mlxsw_sp_fid_vni_to_fid_map(fid, fid->rif, fid->vni_valid);
 735         if (err)
 736                 return err;
 737
 738         err = mlxsw_sp_fid_edit_op(fid, fid->rif);
 739         if (err)
 740                 goto err_fid_edit_op;
 741
 742         return 0;
 743
 744 err_fid_edit_op:
 745         mlxsw_sp_fid_vni_to_fid_map(fid, fid->rif, !fid->vni_valid);
 746         return err;
 747 }
 748
 749 static int __mlxsw_sp_fid_port_vid_map(const struct mlxsw_sp_fid *fid,
 750                                        u16 local_port, u16 vid, bool valid)
 751 {
 752         struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
 753         char svfa_pl[MLXSW_REG_SVFA_LEN];
 754         bool irif_valid = false;
 755         u16 irif_index = 0;
 756
 757         if (fid->rif) {
 758                 irif_valid = true;
 759                 irif_index = mlxsw_sp_rif_index(fid->rif);
 760         }
 761
 762         mlxsw_reg_svfa_port_vid_pack(svfa_pl, local_port, valid, fid->fid_index,
 763                                      vid, irif_valid, irif_index);
 764         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(svfa), svfa_pl);
 765 }
 766
 767 static struct mlxsw_sp_fid_8021d *
 768 mlxsw_sp_fid_8021d_fid(const struct mlxsw_sp_fid *fid)
 769 {
 770         return container_of(fid, struct mlxsw_sp_fid_8021d, common);
 771 }
 772
 773 static void mlxsw_sp_fid_8021d_setup(struct mlxsw_sp_fid *fid, const void *arg)
 774 {
 775         int br_ifindex = *(int *) arg;
 776
 777         mlxsw_sp_fid_8021d_fid(fid)->br_ifindex = br_ifindex;
 778         fid->fid_offset = fid->fid_index - fid->fid_family->start_index;
 779 }
 780
 781 static int mlxsw_sp_fid_8021d_configure(struct mlxsw_sp_fid *fid)
 782 {
 783         return mlxsw_sp_fid_op(fid, true);
 784 }
 785
 786 static void mlxsw_sp_fid_8021d_deconfigure(struct mlxsw_sp_fid *fid)
 787 {
 788         if (fid->vni_valid)
 789                 mlxsw_sp_nve_fid_disable(fid->fid_family->mlxsw_sp, fid);
 790         mlxsw_sp_fid_op(fid, false);
 791 }
 792
 793 static int mlxsw_sp_fid_8021d_index_alloc(struct mlxsw_sp_fid *fid,
 794                                           const void *arg, u16 *p_fid_index)
 795 {
 796         struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
 797         u16 nr_fids, fid_index;
 798
 799         nr_fids = fid_family->end_index - fid_family->start_index + 1;
 800         fid_index = find_first_zero_bit(fid_family->fids_bitmap, nr_fids);
 801         if (fid_index == nr_fids)
 802                 return -ENOBUFS;
 803         *p_fid_index = fid_family->start_index + fid_index;
 804
 805         return 0;
 806 }
 807
 808 static bool
 809 mlxsw_sp_fid_8021d_compare(const struct mlxsw_sp_fid *fid, const void *arg)
 810 {
 811         int br_ifindex = *(int *) arg;
 812
 813         return mlxsw_sp_fid_8021d_fid(fid)->br_ifindex == br_ifindex;
 814 }
 815
 816 static int mlxsw_sp_port_vp_mode_trans(struct mlxsw_sp_port *mlxsw_sp_port)
 817 {
 818         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
 819         int err;
 820
 821         list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
 822                             list) {
 823                 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
 824                 u16 vid = mlxsw_sp_port_vlan->vid;
 825
 826                 if (!fid)
 827                         continue;
 828
 829                 err = __mlxsw_sp_fid_port_vid_map(fid,
 830                                                   mlxsw_sp_port->local_port,
 831                                                   vid, true);
 832                 if (err)
 833                         goto err_fid_port_vid_map;
 834         }
 835
 836         err = mlxsw_sp_port_vp_mode_set(mlxsw_sp_port, true);
 837         if (err)
 838                 goto err_port_vp_mode_set;
 839
 840         return 0;
 841
 842 err_port_vp_mode_set:
 843 err_fid_port_vid_map:
 844         list_for_each_entry_continue_reverse(mlxsw_sp_port_vlan,
 845                                              &mlxsw_sp_port->vlans_list, list) {
 846                 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
 847                 u16 vid = mlxsw_sp_port_vlan->vid;
 848
 849                 if (!fid)
 850                         continue;
 851
 852                 __mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port->local_port, vid,
 853                                             false);
 854         }
 855         return err;
 856 }
 857
 858 static void mlxsw_sp_port_vlan_mode_trans(struct mlxsw_sp_port *mlxsw_sp_port)
 859 {
 860         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
 861
 862         mlxsw_sp_port_vp_mode_set(mlxsw_sp_port, false);
 863
 864         list_for_each_entry_reverse(mlxsw_sp_port_vlan,
 865                                     &mlxsw_sp_port->vlans_list, list) {
 866                 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
 867                 u16 vid = mlxsw_sp_port_vlan->vid;
 868
 869                 if (!fid)
 870                         continue;
 871
 872                 __mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port->local_port, vid,
 873                                             false);
 874         }
 875 }
 876
 877 static int
 878 mlxsw_sp_fid_port_vid_list_add(struct mlxsw_sp_fid *fid, u16 local_port,
 879                                u16 vid)
 880 {
 881         struct mlxsw_sp_fid_port_vid *port_vid, *tmp_port_vid;
 882
 883         port_vid = kzalloc(sizeof(*port_vid), GFP_KERNEL);
 884         if (!port_vid)
 885                 return -ENOMEM;
 886
 887         port_vid->local_port = local_port;
 888         port_vid->vid = vid;
 889
 890         list_for_each_entry(tmp_port_vid, &fid->port_vid_list, list) {
 891                 if (tmp_port_vid->local_port > local_port)
 892                         break;
 893         }
 894
 895         list_add_tail(&port_vid->list, &tmp_port_vid->list);
 896         return 0;
 897 }
 898
 899 static void
 900 mlxsw_sp_fid_port_vid_list_del(struct mlxsw_sp_fid *fid, u16 local_port,
 901                                u16 vid)
 902 {
 903         struct mlxsw_sp_fid_port_vid *port_vid, *tmp;
 904
 905         list_for_each_entry_safe(port_vid, tmp, &fid->port_vid_list, list) {
 906                 if (port_vid->local_port != local_port || port_vid->vid != vid)
 907                         continue;
 908
 909                 list_del(&port_vid->list);
 910                 kfree(port_vid);
 911                 return;
 912         }
 913 }
 914
 915 static int
 916 mlxsw_sp_fid_mpe_table_map(const struct mlxsw_sp_fid *fid, u16 local_port,
 917                            u16 vid, bool valid)
 918 {
 919         struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
 920         char smpe_pl[MLXSW_REG_SMPE_LEN];
 921
 922         mlxsw_reg_smpe_pack(smpe_pl, local_port, fid->fid_index,
 923                             valid ? vid : 0);
 924         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smpe), smpe_pl);
 925 }
 926
 927 static int
 928 mlxsw_sp_fid_erif_eport_to_vid_map_one(const struct mlxsw_sp_fid *fid,
 929                                        u16 local_port, u16 vid, bool valid)
 930 {
 931         u8 port_page = local_port / MLXSW_REG_REIV_REC_MAX_COUNT;
 932         u8 rec_num = local_port % MLXSW_REG_REIV_REC_MAX_COUNT;
 933         struct mlxsw_sp *mlxsw_sp = fid->fid_family->mlxsw_sp;
 934         u16 rif_index = mlxsw_sp_rif_index(fid->rif);
 935         char *reiv_pl;
 936         int err;
 937
 938         reiv_pl = kmalloc(MLXSW_REG_REIV_LEN, GFP_KERNEL);
 939         if (!reiv_pl)
 940                 return -ENOMEM;
 941
 942         mlxsw_reg_reiv_pack(reiv_pl, port_page, rif_index);
 943         mlxsw_reg_reiv_rec_update_set(reiv_pl, rec_num, true);
 944         mlxsw_reg_reiv_rec_evid_set(reiv_pl, rec_num, valid ? vid : 0);
 945         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(reiv), reiv_pl);
 946         kfree(reiv_pl);
 947         return err;
 948 }
 949
 950 static int mlxsw_sp_fid_evid_map(const struct mlxsw_sp_fid *fid, u16 local_port,
 951                                  u16 vid, bool valid)
 952 {
 953         int err;
 954
 955         err = mlxsw_sp_fid_mpe_table_map(fid, local_port, vid, valid);
 956         if (err)
 957                 return err;
 958
 959         if (!fid->rif)
 960                 return 0;
 961
 962         err = mlxsw_sp_fid_erif_eport_to_vid_map_one(fid, local_port, vid,
 963                                                      valid);
 964         if (err)
 965                 goto err_erif_eport_to_vid_map_one;
 966
 967         return 0;
 968
 969 err_erif_eport_to_vid_map_one:
 970         mlxsw_sp_fid_mpe_table_map(fid, local_port, vid, !valid);
 971         return err;
 972 }
 973
 974 static int mlxsw_sp_fid_8021d_port_vid_map(struct mlxsw_sp_fid *fid,
 975                                            struct mlxsw_sp_port *mlxsw_sp_port,
 976                                            u16 vid)
 977 {
 978         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 979         u16 local_port = mlxsw_sp_port->local_port;
 980         int err;
 981
 982         err = __mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port->local_port, vid,
 983                                           true);
 984         if (err)
 985                 return err;
 986
 987         err = mlxsw_sp_fid_evid_map(fid, local_port, vid, true);
 988         if (err)
 989                 goto err_fid_evid_map;
 990
 991         err = mlxsw_sp_fid_port_vid_list_add(fid, mlxsw_sp_port->local_port,
 992                                              vid);
 993         if (err)
 994                 goto err_port_vid_list_add;
 995
 996         if (mlxsw_sp->fid_core->port_fid_mappings[local_port]++ == 0) {
 997                 err = mlxsw_sp_port_vp_mode_trans(mlxsw_sp_port);
 998                 if (err)
 999                         goto err_port_vp_mode_trans;
1000         }
1001
1002         return 0;
1003
1004 err_port_vp_mode_trans:
1005         mlxsw_sp->fid_core->port_fid_mappings[local_port]--;
1006         mlxsw_sp_fid_port_vid_list_del(fid, mlxsw_sp_port->local_port, vid);
1007 err_port_vid_list_add:
1008         mlxsw_sp_fid_evid_map(fid, local_port, vid, false);
1009 err_fid_evid_map:
1010         __mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port->local_port, vid, false);
1011         return err;
1012 }
1013
1014 static void
1015 mlxsw_sp_fid_8021d_port_vid_unmap(struct mlxsw_sp_fid *fid,
1016                                   struct mlxsw_sp_port *mlxsw_sp_port, u16 vid)
1017 {
1018         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1019         u16 local_port = mlxsw_sp_port->local_port;
1020
1021         if (mlxsw_sp->fid_core->port_fid_mappings[local_port] == 1)
1022                 mlxsw_sp_port_vlan_mode_trans(mlxsw_sp_port);
1023         mlxsw_sp->fid_core->port_fid_mappings[local_port]--;
1024         mlxsw_sp_fid_port_vid_list_del(fid, mlxsw_sp_port->local_port, vid);
1025         mlxsw_sp_fid_evid_map(fid, local_port, vid, false);
1026         __mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port->local_port, vid, false);
1027 }
1028
1029 static int mlxsw_sp_fid_8021d_vni_set(struct mlxsw_sp_fid *fid)
1030 {
1031         return mlxsw_sp_fid_vni_op(fid);
1032 }
1033
1034 static void mlxsw_sp_fid_8021d_vni_clear(struct mlxsw_sp_fid *fid)
1035 {
1036         mlxsw_sp_fid_vni_op(fid);
1037 }
1038
1039 static int mlxsw_sp_fid_8021d_nve_flood_index_set(struct mlxsw_sp_fid *fid)
1040 {
1041         return mlxsw_sp_fid_edit_op(fid, fid->rif);
1042 }
1043
1044 static void mlxsw_sp_fid_8021d_nve_flood_index_clear(struct mlxsw_sp_fid *fid)
1045 {
1046         mlxsw_sp_fid_edit_op(fid, fid->rif);
1047 }
1048
1049 static void
1050 mlxsw_sp_fid_8021d_fdb_clear_offload(const struct mlxsw_sp_fid *fid,
1051                                      const struct net_device *nve_dev)
1052 {
1053         br_fdb_clear_offload(nve_dev, 0);
1054 }
1055
1056 static int
1057 mlxsw_sp_fid_8021d_vid_to_fid_rif_update(const struct mlxsw_sp_fid *fid,
1058                                          const struct mlxsw_sp_rif *rif)
1059 {
1060         return 0;
1061 }
1062
1063 static const struct mlxsw_sp_fid_ops mlxsw_sp_fid_8021d_ops = {
1064         .setup                  = mlxsw_sp_fid_8021d_setup,
1065         .configure              = mlxsw_sp_fid_8021d_configure,
1066         .deconfigure            = mlxsw_sp_fid_8021d_deconfigure,
1067         .index_alloc            = mlxsw_sp_fid_8021d_index_alloc,
1068         .compare                = mlxsw_sp_fid_8021d_compare,
1069         .port_vid_map           = mlxsw_sp_fid_8021d_port_vid_map,
1070         .port_vid_unmap         = mlxsw_sp_fid_8021d_port_vid_unmap,
1071         .vni_set                = mlxsw_sp_fid_8021d_vni_set,
1072         .vni_clear              = mlxsw_sp_fid_8021d_vni_clear,
1073         .nve_flood_index_set    = mlxsw_sp_fid_8021d_nve_flood_index_set,
1074         .nve_flood_index_clear  = mlxsw_sp_fid_8021d_nve_flood_index_clear,
1075         .fdb_clear_offload      = mlxsw_sp_fid_8021d_fdb_clear_offload,
1076         .vid_to_fid_rif_update  = mlxsw_sp_fid_8021d_vid_to_fid_rif_update,
1077 };
1078
1079 #define MLXSW_SP_FID_8021Q_MAX (VLAN_N_VID - 2)
1080 #define MLXSW_SP_FID_RFID_MAX (11 * 1024)
1081 #define MLXSW_SP_FID_8021Q_PGT_BASE 0
1082 #define MLXSW_SP_FID_8021D_PGT_BASE (3 * MLXSW_SP_FID_8021Q_MAX)
1083
1084 static const struct mlxsw_sp_flood_table mlxsw_sp_fid_8021d_flood_tables[] = {
1085         {
1086                 .packet_type    = MLXSW_SP_FLOOD_TYPE_UC,
1087                 .table_type     = MLXSW_REG_SFGC_TABLE_TYPE_FID_OFFSET,
1088                 .table_index    = 0,
1089         },
1090         {
1091                 .packet_type    = MLXSW_SP_FLOOD_TYPE_MC,
1092                 .table_type     = MLXSW_REG_SFGC_TABLE_TYPE_FID_OFFSET,
1093                 .table_index    = 1,
1094         },
1095         {
1096                 .packet_type    = MLXSW_SP_FLOOD_TYPE_BC,
1097                 .table_type     = MLXSW_REG_SFGC_TABLE_TYPE_FID_OFFSET,
1098                 .table_index    = 2,
1099         },
1100 };
1101
1102 static bool
1103 mlxsw_sp_fid_8021q_compare(const struct mlxsw_sp_fid *fid, const void *arg)
1104 {
1105         u16 vid = *(u16 *) arg;
1106
1107         return mlxsw_sp_fid_8021q_fid(fid)->vid == vid;
1108 }
1109
1110 static void
1111 mlxsw_sp_fid_8021q_fdb_clear_offload(const struct mlxsw_sp_fid *fid,
1112                                      const struct net_device *nve_dev)
1113 {
1114         br_fdb_clear_offload(nve_dev, mlxsw_sp_fid_8021q_vid(fid));
1115 }
1116
1117 static void mlxsw_sp_fid_rfid_setup(struct mlxsw_sp_fid *fid, const void *arg)
1118 {
1119         fid->fid_offset = 0;
1120 }
1121
1122 static int mlxsw_sp_fid_rfid_configure(struct mlxsw_sp_fid *fid)
1123 {
1124         return mlxsw_sp_fid_op(fid, true);
1125 }
1126
1127 static void mlxsw_sp_fid_rfid_deconfigure(struct mlxsw_sp_fid *fid)
1128 {
1129         mlxsw_sp_fid_op(fid, false);
1130 }
1131
1132 static int mlxsw_sp_fid_rfid_index_alloc(struct mlxsw_sp_fid *fid,
1133                                          const void *arg, u16 *p_fid_index)
1134 {
1135         u16 rif_index = *(u16 *) arg;
1136
1137         *p_fid_index = fid->fid_family->start_index + rif_index;
1138
1139         return 0;
1140 }
1141
1142 static bool mlxsw_sp_fid_rfid_compare(const struct mlxsw_sp_fid *fid,
1143                                       const void *arg)
1144 {
1145         u16 rif_index = *(u16 *) arg;
1146
1147         return fid->fid_index == rif_index + fid->fid_family->start_index;
1148 }
1149
1150 static int mlxsw_sp_fid_rfid_port_vid_map(struct mlxsw_sp_fid *fid,
1151                                           struct mlxsw_sp_port *mlxsw_sp_port,
1152                                           u16 vid)
1153 {
1154         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1155         u16 local_port = mlxsw_sp_port->local_port;
1156         int err;
1157
1158         err = mlxsw_sp_fid_port_vid_list_add(fid, mlxsw_sp_port->local_port,
1159                                              vid);
1160         if (err)
1161                 return err;
1162
1163         /* Using legacy bridge model, we only need to transition the port to
1164          * virtual mode since {Port, VID} => FID is done by the firmware upon
1165          * RIF creation. Using unified bridge model, we need to map
1166          * {Port, VID} => FID and map egress VID.
1167          */
1168         err = __mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port->local_port, vid,
1169                                           true);
1170         if (err)
1171                 goto err_port_vid_map;
1172
1173         if (fid->rif) {
1174                 err = mlxsw_sp_fid_erif_eport_to_vid_map_one(fid, local_port,
1175                                                              vid, true);
1176                 if (err)
1177                         goto err_erif_eport_to_vid_map_one;
1178         }
1179
1180         if (mlxsw_sp->fid_core->port_fid_mappings[local_port]++ == 0) {
1181                 err = mlxsw_sp_port_vp_mode_trans(mlxsw_sp_port);
1182                 if (err)
1183                         goto err_port_vp_mode_trans;
1184         }
1185
1186         return 0;
1187
1188 err_port_vp_mode_trans:
1189         mlxsw_sp->fid_core->port_fid_mappings[local_port]--;
1190         if (fid->rif)
1191                 mlxsw_sp_fid_erif_eport_to_vid_map_one(fid, local_port, vid,
1192                                                        false);
1193 err_erif_eport_to_vid_map_one:
1194         __mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port->local_port, vid, false);
1195 err_port_vid_map:
1196         mlxsw_sp_fid_port_vid_list_del(fid, mlxsw_sp_port->local_port, vid);
1197         return err;
1198 }
1199
1200 static void
1201 mlxsw_sp_fid_rfid_port_vid_unmap(struct mlxsw_sp_fid *fid,
1202                                  struct mlxsw_sp_port *mlxsw_sp_port, u16 vid)
1203 {
1204         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1205         u16 local_port = mlxsw_sp_port->local_port;
1206
1207         if (mlxsw_sp->fid_core->port_fid_mappings[local_port] == 1)
1208                 mlxsw_sp_port_vlan_mode_trans(mlxsw_sp_port);
1209         mlxsw_sp->fid_core->port_fid_mappings[local_port]--;
1210
1211         if (fid->rif)
1212                 mlxsw_sp_fid_erif_eport_to_vid_map_one(fid, local_port, vid,
1213                                                        false);
1214         __mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port->local_port, vid, false);
1215         mlxsw_sp_fid_port_vid_list_del(fid, mlxsw_sp_port->local_port, vid);
1216 }
1217
1218 static int mlxsw_sp_fid_rfid_vni_set(struct mlxsw_sp_fid *fid)
1219 {
1220         return -EOPNOTSUPP;
1221 }
1222
1223 static void mlxsw_sp_fid_rfid_vni_clear(struct mlxsw_sp_fid *fid)
1224 {
1225         WARN_ON_ONCE(1);
1226 }
1227
1228 static int mlxsw_sp_fid_rfid_nve_flood_index_set(struct mlxsw_sp_fid *fid)
1229 {
1230         return -EOPNOTSUPP;
1231 }
1232
1233 static void mlxsw_sp_fid_rfid_nve_flood_index_clear(struct mlxsw_sp_fid *fid)
1234 {
1235         WARN_ON_ONCE(1);
1236 }
1237
1238 static int
1239 mlxsw_sp_fid_rfid_vid_to_fid_rif_update(const struct mlxsw_sp_fid *fid,
1240                                         const struct mlxsw_sp_rif *rif)
1241 {
1242         return 0;
1243 }
1244
1245 static const struct mlxsw_sp_fid_ops mlxsw_sp_fid_rfid_ops = {
1246         .setup                  = mlxsw_sp_fid_rfid_setup,
1247         .configure              = mlxsw_sp_fid_rfid_configure,
1248         .deconfigure            = mlxsw_sp_fid_rfid_deconfigure,
1249         .index_alloc            = mlxsw_sp_fid_rfid_index_alloc,
1250         .compare                = mlxsw_sp_fid_rfid_compare,
1251         .port_vid_map           = mlxsw_sp_fid_rfid_port_vid_map,
1252         .port_vid_unmap         = mlxsw_sp_fid_rfid_port_vid_unmap,
1253         .vni_set                = mlxsw_sp_fid_rfid_vni_set,
1254         .vni_clear              = mlxsw_sp_fid_rfid_vni_clear,
1255         .nve_flood_index_set    = mlxsw_sp_fid_rfid_nve_flood_index_set,
1256         .nve_flood_index_clear  = mlxsw_sp_fid_rfid_nve_flood_index_clear,
1257         .vid_to_fid_rif_update  = mlxsw_sp_fid_rfid_vid_to_fid_rif_update,
1258 };
1259
1260 static void mlxsw_sp_fid_dummy_setup(struct mlxsw_sp_fid *fid, const void *arg)
1261 {
1262         fid->fid_offset = 0;
1263 }
1264
1265 static int mlxsw_sp_fid_dummy_configure(struct mlxsw_sp_fid *fid)
1266 {
1267         return mlxsw_sp_fid_op(fid, true);
1268 }
1269
1270 static void mlxsw_sp_fid_dummy_deconfigure(struct mlxsw_sp_fid *fid)
1271 {
1272         mlxsw_sp_fid_op(fid, false);
1273 }
1274
1275 static int mlxsw_sp_fid_dummy_index_alloc(struct mlxsw_sp_fid *fid,
1276                                           const void *arg, u16 *p_fid_index)
1277 {
1278         *p_fid_index = fid->fid_family->start_index;
1279
1280         return 0;
1281 }
1282
1283 static bool mlxsw_sp_fid_dummy_compare(const struct mlxsw_sp_fid *fid,
1284                                        const void *arg)
1285 {
1286         return true;
1287 }
1288
1289 static int mlxsw_sp_fid_dummy_vni_set(struct mlxsw_sp_fid *fid)
1290 {
1291         return -EOPNOTSUPP;
1292 }
1293
1294 static void mlxsw_sp_fid_dummy_vni_clear(struct mlxsw_sp_fid *fid)
1295 {
1296         WARN_ON_ONCE(1);
1297 }
1298
1299 static int mlxsw_sp_fid_dummy_nve_flood_index_set(struct mlxsw_sp_fid *fid)
1300 {
1301         return -EOPNOTSUPP;
1302 }
1303
1304 static void mlxsw_sp_fid_dummy_nve_flood_index_clear(struct mlxsw_sp_fid *fid)
1305 {
1306         WARN_ON_ONCE(1);
1307 }
1308
1309 static const struct mlxsw_sp_fid_ops mlxsw_sp_fid_dummy_ops = {
1310         .setup                  = mlxsw_sp_fid_dummy_setup,
1311         .configure              = mlxsw_sp_fid_dummy_configure,
1312         .deconfigure            = mlxsw_sp_fid_dummy_deconfigure,
1313         .index_alloc            = mlxsw_sp_fid_dummy_index_alloc,
1314         .compare                = mlxsw_sp_fid_dummy_compare,
1315         .vni_set                = mlxsw_sp_fid_dummy_vni_set,
1316         .vni_clear              = mlxsw_sp_fid_dummy_vni_clear,
1317         .nve_flood_index_set    = mlxsw_sp_fid_dummy_nve_flood_index_set,
1318         .nve_flood_index_clear  = mlxsw_sp_fid_dummy_nve_flood_index_clear,
1319 };
1320
1321 static int mlxsw_sp_fid_8021q_configure(struct mlxsw_sp_fid *fid)
1322 {
1323         struct mlxsw_sp_fid_8021q *fid_8021q = mlxsw_sp_fid_8021q_fid(fid);
1324         int err;
1325
1326         err = mlxsw_sp_fid_op(fid, true);
1327         if (err)
1328                 return err;
1329
1330         err = mlxsw_sp_fid_vid_to_fid_map(fid, fid_8021q->vid, true, fid->rif);
1331         if (err)
1332                 goto err_vid_to_fid_map;
1333
1334         return 0;
1335
1336 err_vid_to_fid_map:
1337         mlxsw_sp_fid_op(fid, false);
1338         return err;
1339 }
1340
1341 static void mlxsw_sp_fid_8021q_deconfigure(struct mlxsw_sp_fid *fid)
1342 {
1343         struct mlxsw_sp_fid_8021q *fid_8021q = mlxsw_sp_fid_8021q_fid(fid);
1344
1345         if (fid->vni_valid)
1346                 mlxsw_sp_nve_fid_disable(fid->fid_family->mlxsw_sp, fid);
1347
1348         mlxsw_sp_fid_vid_to_fid_map(fid, fid_8021q->vid, false, NULL);
1349         mlxsw_sp_fid_op(fid, false);
1350 }
1351
1352 static int mlxsw_sp_fid_8021q_port_vid_map(struct mlxsw_sp_fid *fid,
1353                                            struct mlxsw_sp_port *mlxsw_sp_port,
1354                                            u16 vid)
1355 {
1356         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1357         u16 local_port = mlxsw_sp_port->local_port;
1358         int err;
1359
1360         /* In case there are no {Port, VID} => FID mappings on the port,
1361          * we can use the global VID => FID mapping we created when the
1362          * FID was configured, otherwise, configure new mapping.
1363          */
1364         if (mlxsw_sp->fid_core->port_fid_mappings[local_port]) {
1365                 err =  __mlxsw_sp_fid_port_vid_map(fid, local_port, vid, true);
1366                 if (err)
1367                         return err;
1368         }
1369
1370         err = mlxsw_sp_fid_evid_map(fid, local_port, vid, true);
1371         if (err)
1372                 goto err_fid_evid_map;
1373
1374         err = mlxsw_sp_fid_port_vid_list_add(fid, mlxsw_sp_port->local_port,
1375                                              vid);
1376         if (err)
1377                 goto err_port_vid_list_add;
1378
1379         return 0;
1380
1381 err_port_vid_list_add:
1382          mlxsw_sp_fid_evid_map(fid, local_port, vid, false);
1383 err_fid_evid_map:
1384         if (mlxsw_sp->fid_core->port_fid_mappings[local_port])
1385                 __mlxsw_sp_fid_port_vid_map(fid, local_port, vid, false);
1386         return err;
1387 }
1388
1389 static void
1390 mlxsw_sp_fid_8021q_port_vid_unmap(struct mlxsw_sp_fid *fid,
1391                                   struct mlxsw_sp_port *mlxsw_sp_port, u16 vid)
1392 {
1393         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1394         u16 local_port = mlxsw_sp_port->local_port;
1395
1396         mlxsw_sp_fid_port_vid_list_del(fid, mlxsw_sp_port->local_port, vid);
1397         mlxsw_sp_fid_evid_map(fid, local_port, vid, false);
1398         if (mlxsw_sp->fid_core->port_fid_mappings[local_port])
1399                 __mlxsw_sp_fid_port_vid_map(fid, local_port, vid, false);
1400 }
1401
1402 static const struct mlxsw_sp_fid_ops mlxsw_sp_fid_8021q_ops = {
1403         .setup                  = mlxsw_sp_fid_8021q_setup,
1404         .configure              = mlxsw_sp_fid_8021q_configure,
1405         .deconfigure            = mlxsw_sp_fid_8021q_deconfigure,
1406         .index_alloc            = mlxsw_sp_fid_8021d_index_alloc,
1407         .compare                = mlxsw_sp_fid_8021q_compare,
1408         .port_vid_map           = mlxsw_sp_fid_8021q_port_vid_map,
1409         .port_vid_unmap         = mlxsw_sp_fid_8021q_port_vid_unmap,
1410         .vni_set                = mlxsw_sp_fid_8021d_vni_set,
1411         .vni_clear              = mlxsw_sp_fid_8021d_vni_clear,
1412         .nve_flood_index_set    = mlxsw_sp_fid_8021d_nve_flood_index_set,
1413         .nve_flood_index_clear  = mlxsw_sp_fid_8021d_nve_flood_index_clear,
1414         .fdb_clear_offload      = mlxsw_sp_fid_8021q_fdb_clear_offload,
1415         .vid_to_fid_rif_update  = mlxsw_sp_fid_8021q_vid_to_fid_rif_update,
1416 };
1417
1418 /* There are 4K-2 802.1Q FIDs */
1419 #define MLXSW_SP_FID_8021Q_START        1 /* FID 0 is reserved. */
1420 #define MLXSW_SP_FID_8021Q_END          (MLXSW_SP_FID_8021Q_START + \
1421                                          MLXSW_SP_FID_8021Q_MAX - 1)
1422
1423 /* There are 1K 802.1D FIDs */
1424 #define MLXSW_SP_FID_8021D_START        (MLXSW_SP_FID_8021Q_END + 1)
1425 #define MLXSW_SP_FID_8021D_END          (MLXSW_SP_FID_8021D_START + \
1426                                          MLXSW_SP_FID_8021D_MAX - 1)
1427
1428 /* There is one dummy FID */
1429 #define MLXSW_SP_FID_DUMMY              (MLXSW_SP_FID_8021D_END + 1)
1430
1431 /* There are 11K rFIDs */
1432 #define MLXSW_SP_RFID_START             (MLXSW_SP_FID_DUMMY + 1)
1433 #define MLXSW_SP_RFID_END               (MLXSW_SP_RFID_START + \
1434                                          MLXSW_SP_FID_RFID_MAX - 1)
1435
1436 static const struct mlxsw_sp_fid_family mlxsw_sp1_fid_8021q_family = {
1437         .type                   = MLXSW_SP_FID_TYPE_8021Q,
1438         .fid_size               = sizeof(struct mlxsw_sp_fid_8021q),
1439         .start_index            = MLXSW_SP_FID_8021Q_START,
1440         .end_index              = MLXSW_SP_FID_8021Q_END,
1441         .flood_tables           = mlxsw_sp_fid_8021d_flood_tables,
1442         .nr_flood_tables        = ARRAY_SIZE(mlxsw_sp_fid_8021d_flood_tables),
1443         .rif_type               = MLXSW_SP_RIF_TYPE_VLAN,
1444         .ops                    = &mlxsw_sp_fid_8021q_ops,
1445         .flood_rsp              = false,
1446         .bridge_type            = MLXSW_REG_BRIDGE_TYPE_0,
1447         .pgt_base               = MLXSW_SP_FID_8021Q_PGT_BASE,
1448         .smpe_index_valid       = false,
1449 };
1450
1451 static const struct mlxsw_sp_fid_family mlxsw_sp1_fid_8021d_family = {
1452         .type                   = MLXSW_SP_FID_TYPE_8021D,
1453         .fid_size               = sizeof(struct mlxsw_sp_fid_8021d),
1454         .start_index            = MLXSW_SP_FID_8021D_START,
1455         .end_index              = MLXSW_SP_FID_8021D_END,
1456         .flood_tables           = mlxsw_sp_fid_8021d_flood_tables,
1457         .nr_flood_tables        = ARRAY_SIZE(mlxsw_sp_fid_8021d_flood_tables),
1458         .rif_type               = MLXSW_SP_RIF_TYPE_FID,
1459         .ops                    = &mlxsw_sp_fid_8021d_ops,
1460         .bridge_type            = MLXSW_REG_BRIDGE_TYPE_1,
1461         .pgt_base               = MLXSW_SP_FID_8021D_PGT_BASE,
1462         .smpe_index_valid       = false,
1463 };
1464
1465 static const struct mlxsw_sp_fid_family mlxsw_sp1_fid_dummy_family = {
1466         .type                   = MLXSW_SP_FID_TYPE_DUMMY,
1467         .fid_size               = sizeof(struct mlxsw_sp_fid),
1468         .start_index            = MLXSW_SP_FID_DUMMY,
1469         .end_index              = MLXSW_SP_FID_DUMMY,
1470         .ops                    = &mlxsw_sp_fid_dummy_ops,
1471         .smpe_index_valid       = false,
1472 };
1473
1474 static const struct mlxsw_sp_fid_family mlxsw_sp_fid_rfid_family = {
1475         .type                   = MLXSW_SP_FID_TYPE_RFID,
1476         .fid_size               = sizeof(struct mlxsw_sp_fid),
1477         .start_index            = MLXSW_SP_RFID_START,
1478         .end_index              = MLXSW_SP_RFID_END,
1479         .rif_type               = MLXSW_SP_RIF_TYPE_SUBPORT,
1480         .ops                    = &mlxsw_sp_fid_rfid_ops,
1481         .flood_rsp              = true,
1482         .smpe_index_valid       = false,
1483 };
1484
1485 const struct mlxsw_sp_fid_family *mlxsw_sp1_fid_family_arr[] = {
1486         [MLXSW_SP_FID_TYPE_8021Q]       = &mlxsw_sp1_fid_8021q_family,
1487         [MLXSW_SP_FID_TYPE_8021D]       = &mlxsw_sp1_fid_8021d_family,
1488         [MLXSW_SP_FID_TYPE_DUMMY]       = &mlxsw_sp1_fid_dummy_family,
1489         [MLXSW_SP_FID_TYPE_RFID]        = &mlxsw_sp_fid_rfid_family,
1490 };
1491
1492 static const struct mlxsw_sp_fid_family mlxsw_sp2_fid_8021q_family = {
1493         .type                   = MLXSW_SP_FID_TYPE_8021Q,
1494         .fid_size               = sizeof(struct mlxsw_sp_fid_8021q),
1495         .start_index            = MLXSW_SP_FID_8021Q_START,
1496         .end_index              = MLXSW_SP_FID_8021Q_END,
1497         .flood_tables           = mlxsw_sp_fid_8021d_flood_tables,
1498         .nr_flood_tables        = ARRAY_SIZE(mlxsw_sp_fid_8021d_flood_tables),
1499         .rif_type               = MLXSW_SP_RIF_TYPE_VLAN,
1500         .ops                    = &mlxsw_sp_fid_8021q_ops,
1501         .flood_rsp              = false,
1502         .bridge_type            = MLXSW_REG_BRIDGE_TYPE_0,
1503         .pgt_base               = MLXSW_SP_FID_8021Q_PGT_BASE,
1504         .smpe_index_valid       = true,
1505 };
1506
1507 static const struct mlxsw_sp_fid_family mlxsw_sp2_fid_8021d_family = {
1508         .type                   = MLXSW_SP_FID_TYPE_8021D,
1509         .fid_size               = sizeof(struct mlxsw_sp_fid_8021d),
1510         .start_index            = MLXSW_SP_FID_8021D_START,
1511         .end_index              = MLXSW_SP_FID_8021D_END,
1512         .flood_tables           = mlxsw_sp_fid_8021d_flood_tables,
1513         .nr_flood_tables        = ARRAY_SIZE(mlxsw_sp_fid_8021d_flood_tables),
1514         .rif_type               = MLXSW_SP_RIF_TYPE_FID,
1515         .ops                    = &mlxsw_sp_fid_8021d_ops,
1516         .bridge_type            = MLXSW_REG_BRIDGE_TYPE_1,
1517         .pgt_base               = MLXSW_SP_FID_8021D_PGT_BASE,
1518         .smpe_index_valid       = true,
1519 };
1520
1521 static const struct mlxsw_sp_fid_family mlxsw_sp2_fid_dummy_family = {
1522         .type                   = MLXSW_SP_FID_TYPE_DUMMY,
1523         .fid_size               = sizeof(struct mlxsw_sp_fid),
1524         .start_index            = MLXSW_SP_FID_DUMMY,
1525         .end_index              = MLXSW_SP_FID_DUMMY,
1526         .ops                    = &mlxsw_sp_fid_dummy_ops,
1527         .smpe_index_valid       = false,
1528 };
1529
1530 const struct mlxsw_sp_fid_family *mlxsw_sp2_fid_family_arr[] = {
1531         [MLXSW_SP_FID_TYPE_8021Q]       = &mlxsw_sp2_fid_8021q_family,
1532         [MLXSW_SP_FID_TYPE_8021D]       = &mlxsw_sp2_fid_8021d_family,
1533         [MLXSW_SP_FID_TYPE_DUMMY]       = &mlxsw_sp2_fid_dummy_family,
1534         [MLXSW_SP_FID_TYPE_RFID]        = &mlxsw_sp_fid_rfid_family,
1535 };
1536
1537 static struct mlxsw_sp_fid *mlxsw_sp_fid_lookup(struct mlxsw_sp *mlxsw_sp,
1538                                                 enum mlxsw_sp_fid_type type,
1539                                                 const void *arg)
1540 {
1541         struct mlxsw_sp_fid_family *fid_family;
1542         struct mlxsw_sp_fid *fid;
1543
1544         fid_family = mlxsw_sp->fid_core->fid_family_arr[type];
1545         list_for_each_entry(fid, &fid_family->fids_list, list) {
1546                 if (!fid->fid_family->ops->compare(fid, arg))
1547                         continue;
1548                 refcount_inc(&fid->ref_count);
1549                 return fid;
1550         }
1551
1552         return NULL;
1553 }
1554
1555 static struct mlxsw_sp_fid *mlxsw_sp_fid_get(struct mlxsw_sp *mlxsw_sp,
1556                                              enum mlxsw_sp_fid_type type,
1557                                              const void *arg)
1558 {
1559         struct mlxsw_sp_fid_family *fid_family;
1560         struct mlxsw_sp_fid *fid;
1561         u16 fid_index;
1562         int err;
1563
1564         fid = mlxsw_sp_fid_lookup(mlxsw_sp, type, arg);
1565         if (fid)
1566                 return fid;
1567
1568         fid_family = mlxsw_sp->fid_core->fid_family_arr[type];
1569         fid = kzalloc(fid_family->fid_size, GFP_KERNEL);
1570         if (!fid)
1571                 return ERR_PTR(-ENOMEM);
1572
1573         INIT_LIST_HEAD(&fid->port_vid_list);
1574         fid->fid_family = fid_family;
1575
1576         err = fid->fid_family->ops->index_alloc(fid, arg, &fid_index);
1577         if (err)
1578                 goto err_index_alloc;
1579         fid->fid_index = fid_index;
1580         __set_bit(fid_index - fid_family->start_index, fid_family->fids_bitmap);
1581
1582         fid->fid_family->ops->setup(fid, arg);
1583
1584         err = fid->fid_family->ops->configure(fid);
1585         if (err)
1586                 goto err_configure;
1587
1588         err = rhashtable_insert_fast(&mlxsw_sp->fid_core->fid_ht, &fid->ht_node,
1589                                      mlxsw_sp_fid_ht_params);
1590         if (err)
1591                 goto err_rhashtable_insert;
1592
1593         list_add(&fid->list, &fid_family->fids_list);
1594         refcount_set(&fid->ref_count, 1);
1595         return fid;
1596
1597 err_rhashtable_insert:
1598         fid->fid_family->ops->deconfigure(fid);
1599 err_configure:
1600         __clear_bit(fid_index - fid_family->start_index,
1601                     fid_family->fids_bitmap);
1602 err_index_alloc:
1603         kfree(fid);
1604         return ERR_PTR(err);
1605 }
1606
1607 void mlxsw_sp_fid_put(struct mlxsw_sp_fid *fid)
1608 {
1609         struct mlxsw_sp_fid_family *fid_family = fid->fid_family;
1610         struct mlxsw_sp *mlxsw_sp = fid_family->mlxsw_sp;
1611
1612         if (!refcount_dec_and_test(&fid->ref_count))
1613                 return;
1614
1615         list_del(&fid->list);
1616         rhashtable_remove_fast(&mlxsw_sp->fid_core->fid_ht,
1617                                &fid->ht_node, mlxsw_sp_fid_ht_params);
1618         fid->fid_family->ops->deconfigure(fid);
1619         __clear_bit(fid->fid_index - fid_family->start_index,
1620                     fid_family->fids_bitmap);
1621         WARN_ON_ONCE(!list_empty(&fid->port_vid_list));
1622         kfree(fid);
1623 }
1624
1625 struct mlxsw_sp_fid *mlxsw_sp_fid_8021q_get(struct mlxsw_sp *mlxsw_sp, u16 vid)
1626 {
1627         return mlxsw_sp_fid_get(mlxsw_sp, MLXSW_SP_FID_TYPE_8021Q, &vid);
1628 }
1629
1630 struct mlxsw_sp_fid *mlxsw_sp_fid_8021d_get(struct mlxsw_sp *mlxsw_sp,
1631                                             int br_ifindex)
1632 {
1633         return mlxsw_sp_fid_get(mlxsw_sp, MLXSW_SP_FID_TYPE_8021D, &br_ifindex);
1634 }
1635
1636 struct mlxsw_sp_fid *mlxsw_sp_fid_8021q_lookup(struct mlxsw_sp *mlxsw_sp,
1637                                                u16 vid)
1638 {
1639         return mlxsw_sp_fid_lookup(mlxsw_sp, MLXSW_SP_FID_TYPE_8021Q, &vid);
1640 }
1641
1642 struct mlxsw_sp_fid *mlxsw_sp_fid_8021d_lookup(struct mlxsw_sp *mlxsw_sp,
1643                                                int br_ifindex)
1644 {
1645         return mlxsw_sp_fid_lookup(mlxsw_sp, MLXSW_SP_FID_TYPE_8021D,
1646                                    &br_ifindex);
1647 }
1648
1649 struct mlxsw_sp_fid *mlxsw_sp_fid_rfid_get(struct mlxsw_sp *mlxsw_sp,
1650                                            u16 rif_index)
1651 {
1652         return mlxsw_sp_fid_get(mlxsw_sp, MLXSW_SP_FID_TYPE_RFID, &rif_index);
1653 }
1654
1655 struct mlxsw_sp_fid *mlxsw_sp_fid_dummy_get(struct mlxsw_sp *mlxsw_sp)
1656 {
1657         return mlxsw_sp_fid_get(mlxsw_sp, MLXSW_SP_FID_TYPE_DUMMY, NULL);
1658 }
1659
1660 static int
1661 mlxsw_sp_fid_flood_table_init(struct mlxsw_sp_fid_family *fid_family,
1662                               const struct mlxsw_sp_flood_table *flood_table)
1663 {
1664         enum mlxsw_sp_flood_type packet_type = flood_table->packet_type;
1665         struct mlxsw_sp *mlxsw_sp = fid_family->mlxsw_sp;
1666         const int *sfgc_packet_types;
1667         u16 num_fids, mid_base;
1668         int err, i;
1669
1670         mid_base = mlxsw_sp_fid_flood_table_mid(fid_family, flood_table, 0);
1671         num_fids = mlxsw_sp_fid_family_num_fids(fid_family);
1672         err = mlxsw_sp_pgt_mid_alloc_range(mlxsw_sp, mid_base, num_fids);
1673         if (err)
1674                 return err;
1675
1676         sfgc_packet_types = mlxsw_sp_packet_type_sfgc_types[packet_type];
1677         for (i = 0; i < MLXSW_REG_SFGC_TYPE_MAX; i++) {
1678                 char sfgc_pl[MLXSW_REG_SFGC_LEN];
1679
1680                 if (!sfgc_packet_types[i])
1681                         continue;
1682
1683                 mlxsw_reg_sfgc_pack(sfgc_pl, i, fid_family->bridge_type,
1684                                     flood_table->table_type, 0, mid_base);
1685
1686                 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfgc), sfgc_pl);
1687                 if (err)
1688                         goto err_reg_write;
1689         }
1690
1691         return 0;
1692
1693 err_reg_write:
1694         mlxsw_sp_pgt_mid_free_range(mlxsw_sp, mid_base, num_fids);
1695         return err;
1696 }
1697
1698 static void
1699 mlxsw_sp_fid_flood_table_fini(struct mlxsw_sp_fid_family *fid_family,
1700                               const struct mlxsw_sp_flood_table *flood_table)
1701 {
1702         struct mlxsw_sp *mlxsw_sp = fid_family->mlxsw_sp;
1703         u16 num_fids, mid_base;
1704
1705         mid_base = mlxsw_sp_fid_flood_table_mid(fid_family, flood_table, 0);
1706         num_fids = mlxsw_sp_fid_family_num_fids(fid_family);
1707         mlxsw_sp_pgt_mid_free_range(mlxsw_sp, mid_base, num_fids);
1708 }
1709
1710 static int
1711 mlxsw_sp_fid_flood_tables_init(struct mlxsw_sp_fid_family *fid_family)
1712 {
1713         int i;
1714
1715         for (i = 0; i < fid_family->nr_flood_tables; i++) {
1716                 const struct mlxsw_sp_flood_table *flood_table;
1717                 int err;
1718
1719                 flood_table = &fid_family->flood_tables[i];
1720                 err = mlxsw_sp_fid_flood_table_init(fid_family, flood_table);
1721                 if (err)
1722                         return err;
1723         }
1724
1725         return 0;
1726 }
1727
1728 static void
1729 mlxsw_sp_fid_flood_tables_fini(struct mlxsw_sp_fid_family *fid_family)
1730 {
1731         int i;
1732
1733         for (i = 0; i < fid_family->nr_flood_tables; i++) {
1734                 const struct mlxsw_sp_flood_table *flood_table;
1735
1736                 flood_table = &fid_family->flood_tables[i];
1737                 mlxsw_sp_fid_flood_table_fini(fid_family, flood_table);
1738         }
1739 }
1740
1741 static int mlxsw_sp_fid_family_register(struct mlxsw_sp *mlxsw_sp,
1742                                         const struct mlxsw_sp_fid_family *tmpl)
1743 {
1744         u16 nr_fids = tmpl->end_index - tmpl->start_index + 1;
1745         struct mlxsw_sp_fid_family *fid_family;
1746         int err;
1747
1748         fid_family = kmemdup(tmpl, sizeof(*fid_family), GFP_KERNEL);
1749         if (!fid_family)
1750                 return -ENOMEM;
1751
1752         fid_family->mlxsw_sp = mlxsw_sp;
1753         INIT_LIST_HEAD(&fid_family->fids_list);
1754         fid_family->fids_bitmap = bitmap_zalloc(nr_fids, GFP_KERNEL);
1755         if (!fid_family->fids_bitmap) {
1756                 err = -ENOMEM;
1757                 goto err_alloc_fids_bitmap;
1758         }
1759
1760         if (fid_family->flood_tables) {
1761                 err = mlxsw_sp_fid_flood_tables_init(fid_family);
1762                 if (err)
1763                         goto err_fid_flood_tables_init;
1764         }
1765
1766         mlxsw_sp->fid_core->fid_family_arr[tmpl->type] = fid_family;
1767
1768         return 0;
1769
1770 err_fid_flood_tables_init:
1771         bitmap_free(fid_family->fids_bitmap);
1772 err_alloc_fids_bitmap:
1773         kfree(fid_family);
1774         return err;
1775 }
1776
1777 static void
1778 mlxsw_sp_fid_family_unregister(struct mlxsw_sp *mlxsw_sp,
1779                                struct mlxsw_sp_fid_family *fid_family)
1780 {
1781         mlxsw_sp->fid_core->fid_family_arr[fid_family->type] = NULL;
1782
1783         if (fid_family->flood_tables)
1784                 mlxsw_sp_fid_flood_tables_fini(fid_family);
1785
1786         bitmap_free(fid_family->fids_bitmap);
1787         WARN_ON_ONCE(!list_empty(&fid_family->fids_list));
1788         kfree(fid_family);
1789 }
1790
1791 int mlxsw_sp_port_fids_init(struct mlxsw_sp_port *mlxsw_sp_port)
1792 {
1793         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1794
1795         /* Track number of FIDs configured on the port with mapping type
1796          * PORT_VID_TO_FID, so that we know when to transition the port
1797          * back to non-virtual (VLAN) mode.
1798          */
1799         mlxsw_sp->fid_core->port_fid_mappings[mlxsw_sp_port->local_port] = 0;
1800
1801         return mlxsw_sp_port_vp_mode_set(mlxsw_sp_port, false);
1802 }
1803
1804 void mlxsw_sp_port_fids_fini(struct mlxsw_sp_port *mlxsw_sp_port)
1805 {
1806         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1807
1808         mlxsw_sp->fid_core->port_fid_mappings[mlxsw_sp_port->local_port] = 0;
1809 }
1810
1811 int mlxsw_sp_fids_init(struct mlxsw_sp *mlxsw_sp)
1812 {
1813         unsigned int max_ports = mlxsw_core_max_ports(mlxsw_sp->core);
1814         struct mlxsw_sp_fid_core *fid_core;
1815         int err, i;
1816
1817         fid_core = kzalloc(sizeof(*mlxsw_sp->fid_core), GFP_KERNEL);
1818         if (!fid_core)
1819                 return -ENOMEM;
1820         mlxsw_sp->fid_core = fid_core;
1821
1822         err = rhashtable_init(&fid_core->fid_ht, &mlxsw_sp_fid_ht_params);
1823         if (err)
1824                 goto err_rhashtable_fid_init;
1825
1826         err = rhashtable_init(&fid_core->vni_ht, &mlxsw_sp_fid_vni_ht_params);
1827         if (err)
1828                 goto err_rhashtable_vni_init;
1829
1830         fid_core->port_fid_mappings = kcalloc(max_ports, sizeof(unsigned int),
1831                                               GFP_KERNEL);
1832         if (!fid_core->port_fid_mappings) {
1833                 err = -ENOMEM;
1834                 goto err_alloc_port_fid_mappings;
1835         }
1836
1837         for (i = 0; i < MLXSW_SP_FID_TYPE_MAX; i++) {
1838                 err = mlxsw_sp_fid_family_register(mlxsw_sp,
1839                                                    mlxsw_sp->fid_family_arr[i]);
1840
1841                 if (err)
1842                         goto err_fid_ops_register;
1843         }
1844
1845         return 0;
1846
1847 err_fid_ops_register:
1848         for (i--; i >= 0; i--) {
1849                 struct mlxsw_sp_fid_family *fid_family;
1850
1851                 fid_family = fid_core->fid_family_arr[i];
1852                 mlxsw_sp_fid_family_unregister(mlxsw_sp, fid_family);
1853         }
1854         kfree(fid_core->port_fid_mappings);
1855 err_alloc_port_fid_mappings:
1856         rhashtable_destroy(&fid_core->vni_ht);
1857 err_rhashtable_vni_init:
1858         rhashtable_destroy(&fid_core->fid_ht);
1859 err_rhashtable_fid_init:
1860         kfree(fid_core);
1861         return err;
1862 }
1863
1864 void mlxsw_sp_fids_fini(struct mlxsw_sp *mlxsw_sp)
1865 {
1866         struct mlxsw_sp_fid_core *fid_core = mlxsw_sp->fid_core;
1867         int i;
1868
1869         for (i = 0; i < MLXSW_SP_FID_TYPE_MAX; i++)
1870                 mlxsw_sp_fid_family_unregister(mlxsw_sp,
1871                                                fid_core->fid_family_arr[i]);
1872         kfree(fid_core->port_fid_mappings);
1873         rhashtable_destroy(&fid_core->vni_ht);
1874         rhashtable_destroy(&fid_core->fid_ht);
1875         kfree(fid_core);
1876 }