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

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /* Copyright (c) 2018 Mellanox Technologies. All rights reserved */
   3
   4 #include <linux/err.h>
   5 #include <linux/gfp.h>
   6 #include <linux/kernel.h>
   7 #include <linux/list.h>
   8 #include <linux/netlink.h>
   9 #include <linux/rtnetlink.h>
  10 #include <linux/slab.h>
  11 #include <net/inet_ecn.h>
  12 #include <net/ipv6.h>
  13
  14 #include "reg.h"
  15 #include "spectrum.h"
  16 #include "spectrum_nve.h"
  17
  18 const struct mlxsw_sp_nve_ops *mlxsw_sp1_nve_ops_arr[] = {
  19         [MLXSW_SP_NVE_TYPE_VXLAN]       = &mlxsw_sp1_nve_vxlan_ops,
  20 };
  21
  22 const struct mlxsw_sp_nve_ops *mlxsw_sp2_nve_ops_arr[] = {
  23         [MLXSW_SP_NVE_TYPE_VXLAN]       = &mlxsw_sp2_nve_vxlan_ops,
  24 };
  25
  26 struct mlxsw_sp_nve_mc_entry;
  27 struct mlxsw_sp_nve_mc_record;
  28 struct mlxsw_sp_nve_mc_list;
  29
  30 struct mlxsw_sp_nve_mc_record_ops {
  31         enum mlxsw_reg_tnumt_record_type type;
  32         int (*entry_add)(struct mlxsw_sp_nve_mc_record *mc_record,
  33                          struct mlxsw_sp_nve_mc_entry *mc_entry,
  34                          const union mlxsw_sp_l3addr *addr);
  35         void (*entry_del)(const struct mlxsw_sp_nve_mc_record *mc_record,
  36                           const struct mlxsw_sp_nve_mc_entry *mc_entry);
  37         void (*entry_set)(const struct mlxsw_sp_nve_mc_record *mc_record,
  38                           const struct mlxsw_sp_nve_mc_entry *mc_entry,
  39                           char *tnumt_pl, unsigned int entry_index);
  40         bool (*entry_compare)(const struct mlxsw_sp_nve_mc_record *mc_record,
  41                               const struct mlxsw_sp_nve_mc_entry *mc_entry,
  42                               const union mlxsw_sp_l3addr *addr);
  43 };
  44
  45 struct mlxsw_sp_nve_mc_list_key {
  46         u16 fid_index;
  47 };
  48
  49 struct mlxsw_sp_nve_mc_ipv6_entry {
  50         struct in6_addr addr6;
  51         u32 addr6_kvdl_index;
  52 };
  53
  54 struct mlxsw_sp_nve_mc_entry {
  55         union {
  56                 __be32 addr4;
  57                 struct mlxsw_sp_nve_mc_ipv6_entry ipv6_entry;
  58         };
  59         u8 valid:1;
  60 };
  61
  62 struct mlxsw_sp_nve_mc_record {
  63         struct list_head list;
  64         enum mlxsw_sp_l3proto proto;
  65         unsigned int num_entries;
  66         struct mlxsw_sp *mlxsw_sp;
  67         struct mlxsw_sp_nve_mc_list *mc_list;
  68         const struct mlxsw_sp_nve_mc_record_ops *ops;
  69         u32 kvdl_index;
  70         struct mlxsw_sp_nve_mc_entry entries[];
  71 };
  72
  73 struct mlxsw_sp_nve_mc_list {
  74         struct list_head records_list;
  75         struct rhash_head ht_node;
  76         struct mlxsw_sp_nve_mc_list_key key;
  77 };
  78
  79 static const struct rhashtable_params mlxsw_sp_nve_mc_list_ht_params = {
  80         .key_len = sizeof(struct mlxsw_sp_nve_mc_list_key),
  81         .key_offset = offsetof(struct mlxsw_sp_nve_mc_list, key),
  82         .head_offset = offsetof(struct mlxsw_sp_nve_mc_list, ht_node),
  83 };
  84
  85 static int
  86 mlxsw_sp_nve_mc_record_ipv4_entry_add(struct mlxsw_sp_nve_mc_record *mc_record,
  87                                       struct mlxsw_sp_nve_mc_entry *mc_entry,
  88                                       const union mlxsw_sp_l3addr *addr)
  89 {
  90         mc_entry->addr4 = addr->addr4;
  91
  92         return 0;
  93 }
  94
  95 static void
  96 mlxsw_sp_nve_mc_record_ipv4_entry_del(const struct mlxsw_sp_nve_mc_record *mc_record,
  97                                       const struct mlxsw_sp_nve_mc_entry *mc_entry)
  98 {
  99 }
 100
 101 static void
 102 mlxsw_sp_nve_mc_record_ipv4_entry_set(const struct mlxsw_sp_nve_mc_record *mc_record,
 103                                       const struct mlxsw_sp_nve_mc_entry *mc_entry,
 104                                       char *tnumt_pl, unsigned int entry_index)
 105 {
 106         u32 udip = be32_to_cpu(mc_entry->addr4);
 107
 108         mlxsw_reg_tnumt_udip_set(tnumt_pl, entry_index, udip);
 109 }
 110
 111 static bool
 112 mlxsw_sp_nve_mc_record_ipv4_entry_compare(const struct mlxsw_sp_nve_mc_record *mc_record,
 113                                           const struct mlxsw_sp_nve_mc_entry *mc_entry,
 114                                           const union mlxsw_sp_l3addr *addr)
 115 {
 116         return mc_entry->addr4 == addr->addr4;
 117 }
 118
 119 static const struct mlxsw_sp_nve_mc_record_ops
 120 mlxsw_sp_nve_mc_record_ipv4_ops = {
 121         .type           = MLXSW_REG_TNUMT_RECORD_TYPE_IPV4,
 122         .entry_add      = &mlxsw_sp_nve_mc_record_ipv4_entry_add,
 123         .entry_del      = &mlxsw_sp_nve_mc_record_ipv4_entry_del,
 124         .entry_set      = &mlxsw_sp_nve_mc_record_ipv4_entry_set,
 125         .entry_compare  = &mlxsw_sp_nve_mc_record_ipv4_entry_compare,
 126 };
 127
 128 static int
 129 mlxsw_sp_nve_mc_record_ipv6_entry_add(struct mlxsw_sp_nve_mc_record *mc_record,
 130                                       struct mlxsw_sp_nve_mc_entry *mc_entry,
 131                                       const union mlxsw_sp_l3addr *addr)
 132 {
 133         u32 kvdl_index;
 134         int err;
 135
 136         err = mlxsw_sp_ipv6_addr_kvdl_index_get(mc_record->mlxsw_sp,
 137                                                 &addr->addr6, &kvdl_index);
 138         if (err)
 139                 return err;
 140
 141         mc_entry->ipv6_entry.addr6 = addr->addr6;
 142         mc_entry->ipv6_entry.addr6_kvdl_index = kvdl_index;
 143         return 0;
 144 }
 145
 146 static void
 147 mlxsw_sp_nve_mc_record_ipv6_entry_del(const struct mlxsw_sp_nve_mc_record *mc_record,
 148                                       const struct mlxsw_sp_nve_mc_entry *mc_entry)
 149 {
 150         mlxsw_sp_ipv6_addr_put(mc_record->mlxsw_sp,
 151                                &mc_entry->ipv6_entry.addr6);
 152 }
 153
 154 static void
 155 mlxsw_sp_nve_mc_record_ipv6_entry_set(const struct mlxsw_sp_nve_mc_record *mc_record,
 156                                       const struct mlxsw_sp_nve_mc_entry *mc_entry,
 157                                       char *tnumt_pl, unsigned int entry_index)
 158 {
 159         u32 udip_ptr = mc_entry->ipv6_entry.addr6_kvdl_index;
 160
 161         mlxsw_reg_tnumt_udip_ptr_set(tnumt_pl, entry_index, udip_ptr);
 162 }
 163
 164 static bool
 165 mlxsw_sp_nve_mc_record_ipv6_entry_compare(const struct mlxsw_sp_nve_mc_record *mc_record,
 166                                           const struct mlxsw_sp_nve_mc_entry *mc_entry,
 167                                           const union mlxsw_sp_l3addr *addr)
 168 {
 169         return ipv6_addr_equal(&mc_entry->ipv6_entry.addr6, &addr->addr6);
 170 }
 171
 172 static const struct mlxsw_sp_nve_mc_record_ops
 173 mlxsw_sp_nve_mc_record_ipv6_ops = {
 174         .type           = MLXSW_REG_TNUMT_RECORD_TYPE_IPV6,
 175         .entry_add      = &mlxsw_sp_nve_mc_record_ipv6_entry_add,
 176         .entry_del      = &mlxsw_sp_nve_mc_record_ipv6_entry_del,
 177         .entry_set      = &mlxsw_sp_nve_mc_record_ipv6_entry_set,
 178         .entry_compare  = &mlxsw_sp_nve_mc_record_ipv6_entry_compare,
 179 };
 180
 181 static const struct mlxsw_sp_nve_mc_record_ops *
 182 mlxsw_sp_nve_mc_record_ops_arr[] = {
 183         [MLXSW_SP_L3_PROTO_IPV4] = &mlxsw_sp_nve_mc_record_ipv4_ops,
 184         [MLXSW_SP_L3_PROTO_IPV6] = &mlxsw_sp_nve_mc_record_ipv6_ops,
 185 };
 186
 187 int mlxsw_sp_nve_learned_ip_resolve(struct mlxsw_sp *mlxsw_sp, u32 uip,
 188                                     enum mlxsw_sp_l3proto proto,
 189                                     union mlxsw_sp_l3addr *addr)
 190 {
 191         switch (proto) {
 192         case MLXSW_SP_L3_PROTO_IPV4:
 193                 addr->addr4 = cpu_to_be32(uip);
 194                 return 0;
 195         default:
 196                 WARN_ON(1);
 197                 return -EINVAL;
 198         }
 199 }
 200
 201 static struct mlxsw_sp_nve_mc_list *
 202 mlxsw_sp_nve_mc_list_find(struct mlxsw_sp *mlxsw_sp,
 203                           const struct mlxsw_sp_nve_mc_list_key *key)
 204 {
 205         struct mlxsw_sp_nve *nve = mlxsw_sp->nve;
 206
 207         return rhashtable_lookup_fast(&nve->mc_list_ht, key,
 208                                       mlxsw_sp_nve_mc_list_ht_params);
 209 }
 210
 211 static struct mlxsw_sp_nve_mc_list *
 212 mlxsw_sp_nve_mc_list_create(struct mlxsw_sp *mlxsw_sp,
 213                             const struct mlxsw_sp_nve_mc_list_key *key)
 214 {
 215         struct mlxsw_sp_nve *nve = mlxsw_sp->nve;
 216         struct mlxsw_sp_nve_mc_list *mc_list;
 217         int err;
 218
 219         mc_list = kmalloc(sizeof(*mc_list), GFP_KERNEL);
 220         if (!mc_list)
 221                 return ERR_PTR(-ENOMEM);
 222
 223         INIT_LIST_HEAD(&mc_list->records_list);
 224         mc_list->key = *key;
 225
 226         err = rhashtable_insert_fast(&nve->mc_list_ht, &mc_list->ht_node,
 227                                      mlxsw_sp_nve_mc_list_ht_params);
 228         if (err)
 229                 goto err_rhashtable_insert;
 230
 231         return mc_list;
 232
 233 err_rhashtable_insert:
 234         kfree(mc_list);
 235         return ERR_PTR(err);
 236 }
 237
 238 static void mlxsw_sp_nve_mc_list_destroy(struct mlxsw_sp *mlxsw_sp,
 239                                          struct mlxsw_sp_nve_mc_list *mc_list)
 240 {
 241         struct mlxsw_sp_nve *nve = mlxsw_sp->nve;
 242
 243         rhashtable_remove_fast(&nve->mc_list_ht, &mc_list->ht_node,
 244                                mlxsw_sp_nve_mc_list_ht_params);
 245         WARN_ON(!list_empty(&mc_list->records_list));
 246         kfree(mc_list);
 247 }
 248
 249 static struct mlxsw_sp_nve_mc_list *
 250 mlxsw_sp_nve_mc_list_get(struct mlxsw_sp *mlxsw_sp,
 251                          const struct mlxsw_sp_nve_mc_list_key *key)
 252 {
 253         struct mlxsw_sp_nve_mc_list *mc_list;
 254
 255         mc_list = mlxsw_sp_nve_mc_list_find(mlxsw_sp, key);
 256         if (mc_list)
 257                 return mc_list;
 258
 259         return mlxsw_sp_nve_mc_list_create(mlxsw_sp, key);
 260 }
 261
 262 static void
 263 mlxsw_sp_nve_mc_list_put(struct mlxsw_sp *mlxsw_sp,
 264                          struct mlxsw_sp_nve_mc_list *mc_list)
 265 {
 266         if (!list_empty(&mc_list->records_list))
 267                 return;
 268         mlxsw_sp_nve_mc_list_destroy(mlxsw_sp, mc_list);
 269 }
 270
 271 static struct mlxsw_sp_nve_mc_record *
 272 mlxsw_sp_nve_mc_record_create(struct mlxsw_sp *mlxsw_sp,
 273                               struct mlxsw_sp_nve_mc_list *mc_list,
 274                               enum mlxsw_sp_l3proto proto)
 275 {
 276         unsigned int num_max_entries = mlxsw_sp->nve->num_max_mc_entries[proto];
 277         struct mlxsw_sp_nve_mc_record *mc_record;
 278         int err;
 279
 280         mc_record = kzalloc(struct_size(mc_record, entries, num_max_entries),
 281                             GFP_KERNEL);
 282         if (!mc_record)
 283                 return ERR_PTR(-ENOMEM);
 284
 285         err = mlxsw_sp_kvdl_alloc(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_TNUMT, 1,
 286                                   &mc_record->kvdl_index);
 287         if (err)
 288                 goto err_kvdl_alloc;
 289
 290         mc_record->ops = mlxsw_sp_nve_mc_record_ops_arr[proto];
 291         mc_record->mlxsw_sp = mlxsw_sp;
 292         mc_record->mc_list = mc_list;
 293         mc_record->proto = proto;
 294         list_add_tail(&mc_record->list, &mc_list->records_list);
 295
 296         return mc_record;
 297
 298 err_kvdl_alloc:
 299         kfree(mc_record);
 300         return ERR_PTR(err);
 301 }
 302
 303 static void
 304 mlxsw_sp_nve_mc_record_destroy(struct mlxsw_sp_nve_mc_record *mc_record)
 305 {
 306         struct mlxsw_sp *mlxsw_sp = mc_record->mlxsw_sp;
 307
 308         list_del(&mc_record->list);
 309         mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_TNUMT, 1,
 310                            mc_record->kvdl_index);
 311         WARN_ON(mc_record->num_entries);
 312         kfree(mc_record);
 313 }
 314
 315 static struct mlxsw_sp_nve_mc_record *
 316 mlxsw_sp_nve_mc_record_get(struct mlxsw_sp *mlxsw_sp,
 317                            struct mlxsw_sp_nve_mc_list *mc_list,
 318                            enum mlxsw_sp_l3proto proto)
 319 {
 320         struct mlxsw_sp_nve_mc_record *mc_record;
 321
 322         list_for_each_entry_reverse(mc_record, &mc_list->records_list, list) {
 323                 unsigned int num_entries = mc_record->num_entries;
 324                 struct mlxsw_sp_nve *nve = mlxsw_sp->nve;
 325
 326                 if (mc_record->proto == proto &&
 327                     num_entries < nve->num_max_mc_entries[proto])
 328                         return mc_record;
 329         }
 330
 331         return mlxsw_sp_nve_mc_record_create(mlxsw_sp, mc_list, proto);
 332 }
 333
 334 static void
 335 mlxsw_sp_nve_mc_record_put(struct mlxsw_sp_nve_mc_record *mc_record)
 336 {
 337         if (mc_record->num_entries != 0)
 338                 return;
 339
 340         mlxsw_sp_nve_mc_record_destroy(mc_record);
 341 }
 342
 343 static struct mlxsw_sp_nve_mc_entry *
 344 mlxsw_sp_nve_mc_free_entry_find(struct mlxsw_sp_nve_mc_record *mc_record)
 345 {
 346         struct mlxsw_sp_nve *nve = mc_record->mlxsw_sp->nve;
 347         unsigned int num_max_entries;
 348         int i;
 349
 350         num_max_entries = nve->num_max_mc_entries[mc_record->proto];
 351         for (i = 0; i < num_max_entries; i++) {
 352                 if (mc_record->entries[i].valid)
 353                         continue;
 354                 return &mc_record->entries[i];
 355         }
 356
 357         return NULL;
 358 }
 359
 360 static int
 361 mlxsw_sp_nve_mc_record_refresh(struct mlxsw_sp_nve_mc_record *mc_record)
 362 {
 363         enum mlxsw_reg_tnumt_record_type type = mc_record->ops->type;
 364         struct mlxsw_sp_nve_mc_list *mc_list = mc_record->mc_list;
 365         struct mlxsw_sp *mlxsw_sp = mc_record->mlxsw_sp;
 366         char tnumt_pl[MLXSW_REG_TNUMT_LEN];
 367         unsigned int num_max_entries;
 368         unsigned int num_entries = 0;
 369         u32 next_kvdl_index = 0;
 370         bool next_valid = false;
 371         int i;
 372
 373         if (!list_is_last(&mc_record->list, &mc_list->records_list)) {
 374                 struct mlxsw_sp_nve_mc_record *next_record;
 375
 376                 next_record = list_next_entry(mc_record, list);
 377                 next_kvdl_index = next_record->kvdl_index;
 378                 next_valid = true;
 379         }
 380
 381         mlxsw_reg_tnumt_pack(tnumt_pl, type, MLXSW_REG_TUNNEL_PORT_NVE,
 382                              mc_record->kvdl_index, next_valid,
 383                              next_kvdl_index, mc_record->num_entries);
 384
 385         num_max_entries = mlxsw_sp->nve->num_max_mc_entries[mc_record->proto];
 386         for (i = 0; i < num_max_entries; i++) {
 387                 struct mlxsw_sp_nve_mc_entry *mc_entry;
 388
 389                 mc_entry = &mc_record->entries[i];
 390                 if (!mc_entry->valid)
 391                         continue;
 392                 mc_record->ops->entry_set(mc_record, mc_entry, tnumt_pl,
 393                                           num_entries++);
 394         }
 395
 396         WARN_ON(num_entries != mc_record->num_entries);
 397
 398         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(tnumt), tnumt_pl);
 399 }
 400
 401 static bool
 402 mlxsw_sp_nve_mc_record_is_first(struct mlxsw_sp_nve_mc_record *mc_record)
 403 {
 404         struct mlxsw_sp_nve_mc_list *mc_list = mc_record->mc_list;
 405         struct mlxsw_sp_nve_mc_record *first_record;
 406
 407         first_record = list_first_entry(&mc_list->records_list,
 408                                         struct mlxsw_sp_nve_mc_record, list);
 409
 410         return mc_record == first_record;
 411 }
 412
 413 static struct mlxsw_sp_nve_mc_entry *
 414 mlxsw_sp_nve_mc_entry_find(struct mlxsw_sp_nve_mc_record *mc_record,
 415                            union mlxsw_sp_l3addr *addr)
 416 {
 417         struct mlxsw_sp_nve *nve = mc_record->mlxsw_sp->nve;
 418         unsigned int num_max_entries;
 419         int i;
 420
 421         num_max_entries = nve->num_max_mc_entries[mc_record->proto];
 422         for (i = 0; i < num_max_entries; i++) {
 423                 struct mlxsw_sp_nve_mc_entry *mc_entry;
 424
 425                 mc_entry = &mc_record->entries[i];
 426                 if (!mc_entry->valid)
 427                         continue;
 428                 if (mc_record->ops->entry_compare(mc_record, mc_entry, addr))
 429                         return mc_entry;
 430         }
 431
 432         return NULL;
 433 }
 434
 435 static int
 436 mlxsw_sp_nve_mc_record_ip_add(struct mlxsw_sp_nve_mc_record *mc_record,
 437                               union mlxsw_sp_l3addr *addr)
 438 {
 439         struct mlxsw_sp_nve_mc_entry *mc_entry = NULL;
 440         int err;
 441
 442         mc_entry = mlxsw_sp_nve_mc_free_entry_find(mc_record);
 443         if (WARN_ON(!mc_entry))
 444                 return -EINVAL;
 445
 446         err = mc_record->ops->entry_add(mc_record, mc_entry, addr);
 447         if (err)
 448                 return err;
 449         mc_record->num_entries++;
 450         mc_entry->valid = true;
 451
 452         err = mlxsw_sp_nve_mc_record_refresh(mc_record);
 453         if (err)
 454                 goto err_record_refresh;
 455
 456         /* If this is a new record and not the first one, then we need to
 457          * update the next pointer of the previous entry
 458          */
 459         if (mc_record->num_entries != 1 ||
 460             mlxsw_sp_nve_mc_record_is_first(mc_record))
 461                 return 0;
 462
 463         err = mlxsw_sp_nve_mc_record_refresh(list_prev_entry(mc_record, list));
 464         if (err)
 465                 goto err_prev_record_refresh;
 466
 467         return 0;
 468
 469 err_prev_record_refresh:
 470 err_record_refresh:
 471         mc_entry->valid = false;
 472         mc_record->num_entries--;
 473         mc_record->ops->entry_del(mc_record, mc_entry);
 474         return err;
 475 }
 476
 477 static void
 478 mlxsw_sp_nve_mc_record_entry_del(struct mlxsw_sp_nve_mc_record *mc_record,
 479                                  struct mlxsw_sp_nve_mc_entry *mc_entry)
 480 {
 481         struct mlxsw_sp_nve_mc_list *mc_list = mc_record->mc_list;
 482
 483         mc_entry->valid = false;
 484         mc_record->num_entries--;
 485
 486         /* When the record continues to exist we only need to invalidate
 487          * the requested entry
 488          */
 489         if (mc_record->num_entries != 0) {
 490                 mlxsw_sp_nve_mc_record_refresh(mc_record);
 491                 mc_record->ops->entry_del(mc_record, mc_entry);
 492                 return;
 493         }
 494
 495         /* If the record needs to be deleted, but it is not the first,
 496          * then we need to make sure that the previous record no longer
 497          * points to it. Remove deleted record from the list to reflect
 498          * that and then re-add it at the end, so that it could be
 499          * properly removed by the record destruction code
 500          */
 501         if (!mlxsw_sp_nve_mc_record_is_first(mc_record)) {
 502                 struct mlxsw_sp_nve_mc_record *prev_record;
 503
 504                 prev_record = list_prev_entry(mc_record, list);
 505                 list_del(&mc_record->list);
 506                 mlxsw_sp_nve_mc_record_refresh(prev_record);
 507                 list_add_tail(&mc_record->list, &mc_list->records_list);
 508                 mc_record->ops->entry_del(mc_record, mc_entry);
 509                 return;
 510         }
 511
 512         /* If the first record needs to be deleted, but the list is not
 513          * singular, then the second record needs to be written in the
 514          * first record's address, as this address is stored as a property
 515          * of the FID
 516          */
 517         if (mlxsw_sp_nve_mc_record_is_first(mc_record) &&
 518             !list_is_singular(&mc_list->records_list)) {
 519                 struct mlxsw_sp_nve_mc_record *next_record;
 520
 521                 next_record = list_next_entry(mc_record, list);
 522                 swap(mc_record->kvdl_index, next_record->kvdl_index);
 523                 mlxsw_sp_nve_mc_record_refresh(next_record);
 524                 mc_record->ops->entry_del(mc_record, mc_entry);
 525                 return;
 526         }
 527
 528         /* This is the last case where the last remaining record needs to
 529          * be deleted. Simply delete the entry
 530          */
 531         mc_record->ops->entry_del(mc_record, mc_entry);
 532 }
 533
 534 static struct mlxsw_sp_nve_mc_record *
 535 mlxsw_sp_nve_mc_record_find(struct mlxsw_sp_nve_mc_list *mc_list,
 536                             enum mlxsw_sp_l3proto proto,
 537                             union mlxsw_sp_l3addr *addr,
 538                             struct mlxsw_sp_nve_mc_entry **mc_entry)
 539 {
 540         struct mlxsw_sp_nve_mc_record *mc_record;
 541
 542         list_for_each_entry(mc_record, &mc_list->records_list, list) {
 543                 if (mc_record->proto != proto)
 544                         continue;
 545
 546                 *mc_entry = mlxsw_sp_nve_mc_entry_find(mc_record, addr);
 547                 if (*mc_entry)
 548                         return mc_record;
 549         }
 550
 551         return NULL;
 552 }
 553
 554 static int mlxsw_sp_nve_mc_list_ip_add(struct mlxsw_sp *mlxsw_sp,
 555                                        struct mlxsw_sp_nve_mc_list *mc_list,
 556                                        enum mlxsw_sp_l3proto proto,
 557                                        union mlxsw_sp_l3addr *addr)
 558 {
 559         struct mlxsw_sp_nve_mc_record *mc_record;
 560         int err;
 561
 562         mc_record = mlxsw_sp_nve_mc_record_get(mlxsw_sp, mc_list, proto);
 563         if (IS_ERR(mc_record))
 564                 return PTR_ERR(mc_record);
 565
 566         err = mlxsw_sp_nve_mc_record_ip_add(mc_record, addr);
 567         if (err)
 568                 goto err_ip_add;
 569
 570         return 0;
 571
 572 err_ip_add:
 573         mlxsw_sp_nve_mc_record_put(mc_record);
 574         return err;
 575 }
 576
 577 static void mlxsw_sp_nve_mc_list_ip_del(struct mlxsw_sp *mlxsw_sp,
 578                                         struct mlxsw_sp_nve_mc_list *mc_list,
 579                                         enum mlxsw_sp_l3proto proto,
 580                                         union mlxsw_sp_l3addr *addr)
 581 {
 582         struct mlxsw_sp_nve_mc_record *mc_record;
 583         struct mlxsw_sp_nve_mc_entry *mc_entry;
 584
 585         mc_record = mlxsw_sp_nve_mc_record_find(mc_list, proto, addr,
 586                                                 &mc_entry);
 587         if (!mc_record)
 588                 return;
 589
 590         mlxsw_sp_nve_mc_record_entry_del(mc_record, mc_entry);
 591         mlxsw_sp_nve_mc_record_put(mc_record);
 592 }
 593
 594 static int
 595 mlxsw_sp_nve_fid_flood_index_set(struct mlxsw_sp_fid *fid,
 596                                  struct mlxsw_sp_nve_mc_list *mc_list)
 597 {
 598         struct mlxsw_sp_nve_mc_record *mc_record;
 599
 600         /* The address of the first record in the list is a property of
 601          * the FID and we never change it. It only needs to be set when
 602          * a new list is created
 603          */
 604         if (mlxsw_sp_fid_nve_flood_index_is_set(fid))
 605                 return 0;
 606
 607         mc_record = list_first_entry(&mc_list->records_list,
 608                                      struct mlxsw_sp_nve_mc_record, list);
 609
 610         return mlxsw_sp_fid_nve_flood_index_set(fid, mc_record->kvdl_index);
 611 }
 612
 613 static void
 614 mlxsw_sp_nve_fid_flood_index_clear(struct mlxsw_sp_fid *fid,
 615                                    struct mlxsw_sp_nve_mc_list *mc_list)
 616 {
 617         struct mlxsw_sp_nve_mc_record *mc_record;
 618
 619         /* The address of the first record needs to be invalidated only when
 620          * the last record is about to be removed
 621          */
 622         if (!list_is_singular(&mc_list->records_list))
 623                 return;
 624
 625         mc_record = list_first_entry(&mc_list->records_list,
 626                                      struct mlxsw_sp_nve_mc_record, list);
 627         if (mc_record->num_entries != 1)
 628                 return;
 629
 630         return mlxsw_sp_fid_nve_flood_index_clear(fid);
 631 }
 632
 633 int mlxsw_sp_nve_flood_ip_add(struct mlxsw_sp *mlxsw_sp,
 634                               struct mlxsw_sp_fid *fid,
 635                               enum mlxsw_sp_l3proto proto,
 636                               union mlxsw_sp_l3addr *addr)
 637 {
 638         struct mlxsw_sp_nve_mc_list_key key = { 0 };
 639         struct mlxsw_sp_nve_mc_list *mc_list;
 640         int err;
 641
 642         key.fid_index = mlxsw_sp_fid_index(fid);
 643         mc_list = mlxsw_sp_nve_mc_list_get(mlxsw_sp, &key);
 644         if (IS_ERR(mc_list))
 645                 return PTR_ERR(mc_list);
 646
 647         err = mlxsw_sp_nve_mc_list_ip_add(mlxsw_sp, mc_list, proto, addr);
 648         if (err)
 649                 goto err_add_ip;
 650
 651         err = mlxsw_sp_nve_fid_flood_index_set(fid, mc_list);
 652         if (err)
 653                 goto err_fid_flood_index_set;
 654
 655         return 0;
 656
 657 err_fid_flood_index_set:
 658         mlxsw_sp_nve_mc_list_ip_del(mlxsw_sp, mc_list, proto, addr);
 659 err_add_ip:
 660         mlxsw_sp_nve_mc_list_put(mlxsw_sp, mc_list);
 661         return err;
 662 }
 663
 664 void mlxsw_sp_nve_flood_ip_del(struct mlxsw_sp *mlxsw_sp,
 665                                struct mlxsw_sp_fid *fid,
 666                                enum mlxsw_sp_l3proto proto,
 667                                union mlxsw_sp_l3addr *addr)
 668 {
 669         struct mlxsw_sp_nve_mc_list_key key = { 0 };
 670         struct mlxsw_sp_nve_mc_list *mc_list;
 671
 672         key.fid_index = mlxsw_sp_fid_index(fid);
 673         mc_list = mlxsw_sp_nve_mc_list_find(mlxsw_sp, &key);
 674         if (!mc_list)
 675                 return;
 676
 677         mlxsw_sp_nve_fid_flood_index_clear(fid, mc_list);
 678         mlxsw_sp_nve_mc_list_ip_del(mlxsw_sp, mc_list, proto, addr);
 679         mlxsw_sp_nve_mc_list_put(mlxsw_sp, mc_list);
 680 }
 681
 682 static void
 683 mlxsw_sp_nve_mc_record_delete(struct mlxsw_sp_nve_mc_record *mc_record)
 684 {
 685         struct mlxsw_sp_nve *nve = mc_record->mlxsw_sp->nve;
 686         unsigned int num_max_entries;
 687         int i;
 688
 689         num_max_entries = nve->num_max_mc_entries[mc_record->proto];
 690         for (i = 0; i < num_max_entries; i++) {
 691                 struct mlxsw_sp_nve_mc_entry *mc_entry = &mc_record->entries[i];
 692
 693                 if (!mc_entry->valid)
 694                         continue;
 695                 mlxsw_sp_nve_mc_record_entry_del(mc_record, mc_entry);
 696         }
 697
 698         WARN_ON(mc_record->num_entries);
 699         mlxsw_sp_nve_mc_record_put(mc_record);
 700 }
 701
 702 static void mlxsw_sp_nve_flood_ip_flush(struct mlxsw_sp *mlxsw_sp,
 703                                         struct mlxsw_sp_fid *fid)
 704 {
 705         struct mlxsw_sp_nve_mc_record *mc_record, *tmp;
 706         struct mlxsw_sp_nve_mc_list_key key = { 0 };
 707         struct mlxsw_sp_nve_mc_list *mc_list;
 708
 709         if (!mlxsw_sp_fid_nve_flood_index_is_set(fid))
 710                 return;
 711
 712         mlxsw_sp_fid_nve_flood_index_clear(fid);
 713
 714         key.fid_index = mlxsw_sp_fid_index(fid);
 715         mc_list = mlxsw_sp_nve_mc_list_find(mlxsw_sp, &key);
 716         if (WARN_ON(!mc_list))
 717                 return;
 718
 719         list_for_each_entry_safe(mc_record, tmp, &mc_list->records_list, list)
 720                 mlxsw_sp_nve_mc_record_delete(mc_record);
 721
 722         WARN_ON(!list_empty(&mc_list->records_list));
 723         mlxsw_sp_nve_mc_list_put(mlxsw_sp, mc_list);
 724 }
 725
 726 static int mlxsw_sp_nve_tunnel_init(struct mlxsw_sp *mlxsw_sp,
 727                                     struct mlxsw_sp_nve_config *config)
 728 {
 729         struct mlxsw_sp_nve *nve = mlxsw_sp->nve;
 730         const struct mlxsw_sp_nve_ops *ops;
 731         int err;
 732
 733         if (nve->num_nve_tunnels++ != 0)
 734                 return 0;
 735
 736         nve->config = *config;
 737
 738         err = mlxsw_sp_kvdl_alloc(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
 739                                   &nve->tunnel_index);
 740         if (err)
 741                 goto err_kvdl_alloc;
 742
 743         ops = nve->nve_ops_arr[config->type];
 744         err = ops->init(nve, config);
 745         if (err)
 746                 goto err_ops_init;
 747
 748         return 0;
 749
 750 err_ops_init:
 751         mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
 752                            nve->tunnel_index);
 753 err_kvdl_alloc:
 754         memset(&nve->config, 0, sizeof(nve->config));
 755         nve->num_nve_tunnels--;
 756         return err;
 757 }
 758
 759 static void mlxsw_sp_nve_tunnel_fini(struct mlxsw_sp *mlxsw_sp)
 760 {
 761         struct mlxsw_sp_nve *nve = mlxsw_sp->nve;
 762         const struct mlxsw_sp_nve_ops *ops;
 763
 764         ops = nve->nve_ops_arr[nve->config.type];
 765
 766         if (mlxsw_sp->nve->num_nve_tunnels == 1) {
 767                 ops->fini(nve);
 768                 mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
 769                                    nve->tunnel_index);
 770                 memset(&nve->config, 0, sizeof(nve->config));
 771         }
 772         nve->num_nve_tunnels--;
 773 }
 774
 775 static void mlxsw_sp_nve_fdb_flush_by_fid(struct mlxsw_sp *mlxsw_sp,
 776                                           u16 fid_index)
 777 {
 778         char sfdf_pl[MLXSW_REG_SFDF_LEN];
 779
 780         mlxsw_reg_sfdf_pack(sfdf_pl, MLXSW_REG_SFDF_FLUSH_PER_NVE_AND_FID);
 781         mlxsw_reg_sfdf_fid_set(sfdf_pl, fid_index);
 782         mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdf), sfdf_pl);
 783 }
 784
 785 static void mlxsw_sp_nve_fdb_clear_offload(struct mlxsw_sp *mlxsw_sp,
 786                                            const struct mlxsw_sp_fid *fid,
 787                                            const struct net_device *nve_dev,
 788                                            __be32 vni)
 789 {
 790         const struct mlxsw_sp_nve_ops *ops;
 791         enum mlxsw_sp_nve_type type;
 792
 793         if (WARN_ON(mlxsw_sp_fid_nve_type(fid, &type)))
 794                 return;
 795
 796         ops = mlxsw_sp->nve->nve_ops_arr[type];
 797         ops->fdb_clear_offload(nve_dev, vni);
 798 }
 799
 800 struct mlxsw_sp_nve_ipv6_ht_key {
 801         u8 mac[ETH_ALEN];
 802         u16 fid_index;
 803 };
 804
 805 struct mlxsw_sp_nve_ipv6_ht_node {
 806         struct rhash_head ht_node;
 807         struct list_head list;
 808         struct mlxsw_sp_nve_ipv6_ht_key key;
 809         struct in6_addr addr6;
 810 };
 811
 812 static const struct rhashtable_params mlxsw_sp_nve_ipv6_ht_params = {
 813         .key_len = sizeof(struct mlxsw_sp_nve_ipv6_ht_key),
 814         .key_offset = offsetof(struct mlxsw_sp_nve_ipv6_ht_node, key),
 815         .head_offset = offsetof(struct mlxsw_sp_nve_ipv6_ht_node, ht_node),
 816 };
 817
 818 int mlxsw_sp_nve_ipv6_addr_kvdl_set(struct mlxsw_sp *mlxsw_sp,
 819                                     const struct in6_addr *addr6,
 820                                     u32 *p_kvdl_index)
 821 {
 822         return mlxsw_sp_ipv6_addr_kvdl_index_get(mlxsw_sp, addr6, p_kvdl_index);
 823 }
 824
 825 void mlxsw_sp_nve_ipv6_addr_kvdl_unset(struct mlxsw_sp *mlxsw_sp,
 826                                        const struct in6_addr *addr6)
 827 {
 828         mlxsw_sp_ipv6_addr_put(mlxsw_sp, addr6);
 829 }
 830
 831 static struct mlxsw_sp_nve_ipv6_ht_node *
 832 mlxsw_sp_nve_ipv6_ht_node_lookup(struct mlxsw_sp *mlxsw_sp, const char *mac,
 833                                  u16 fid_index)
 834 {
 835         struct mlxsw_sp_nve_ipv6_ht_key key = {};
 836
 837         ether_addr_copy(key.mac, mac);
 838         key.fid_index = fid_index;
 839         return rhashtable_lookup_fast(&mlxsw_sp->nve->ipv6_ht, &key,
 840                                       mlxsw_sp_nve_ipv6_ht_params);
 841 }
 842
 843 static int mlxsw_sp_nve_ipv6_ht_insert(struct mlxsw_sp *mlxsw_sp,
 844                                        const char *mac, u16 fid_index,
 845                                        const struct in6_addr *addr6)
 846 {
 847         struct mlxsw_sp_nve_ipv6_ht_node *ipv6_ht_node;
 848         struct mlxsw_sp_nve *nve = mlxsw_sp->nve;
 849         int err;
 850
 851         ipv6_ht_node = kzalloc(sizeof(*ipv6_ht_node), GFP_KERNEL);
 852         if (!ipv6_ht_node)
 853                 return -ENOMEM;
 854
 855         ether_addr_copy(ipv6_ht_node->key.mac, mac);
 856         ipv6_ht_node->key.fid_index = fid_index;
 857         ipv6_ht_node->addr6 = *addr6;
 858
 859         err = rhashtable_insert_fast(&nve->ipv6_ht, &ipv6_ht_node->ht_node,
 860                                      mlxsw_sp_nve_ipv6_ht_params);
 861         if (err)
 862                 goto err_rhashtable_insert;
 863
 864         list_add(&ipv6_ht_node->list, &nve->ipv6_addr_list);
 865
 866         return 0;
 867
 868 err_rhashtable_insert:
 869         kfree(ipv6_ht_node);
 870         return err;
 871 }
 872
 873 static void
 874 mlxsw_sp_nve_ipv6_ht_remove(struct mlxsw_sp *mlxsw_sp,
 875                             struct mlxsw_sp_nve_ipv6_ht_node *ipv6_ht_node)
 876 {
 877         struct mlxsw_sp_nve *nve = mlxsw_sp->nve;
 878
 879         list_del(&ipv6_ht_node->list);
 880         rhashtable_remove_fast(&nve->ipv6_ht, &ipv6_ht_node->ht_node,
 881                                mlxsw_sp_nve_ipv6_ht_params);
 882         kfree(ipv6_ht_node);
 883 }
 884
 885 int
 886 mlxsw_sp_nve_ipv6_addr_map_replace(struct mlxsw_sp *mlxsw_sp, const char *mac,
 887                                    u16 fid_index,
 888                                    const struct in6_addr *new_addr6)
 889 {
 890         struct mlxsw_sp_nve_ipv6_ht_node *ipv6_ht_node;
 891
 892         ASSERT_RTNL();
 893
 894         ipv6_ht_node = mlxsw_sp_nve_ipv6_ht_node_lookup(mlxsw_sp, mac,
 895                                                         fid_index);
 896         if (!ipv6_ht_node)
 897                 return mlxsw_sp_nve_ipv6_ht_insert(mlxsw_sp, mac, fid_index,
 898                                                    new_addr6);
 899
 900         mlxsw_sp_ipv6_addr_put(mlxsw_sp, &ipv6_ht_node->addr6);
 901         ipv6_ht_node->addr6 = *new_addr6;
 902         return 0;
 903 }
 904
 905 void mlxsw_sp_nve_ipv6_addr_map_del(struct mlxsw_sp *mlxsw_sp, const char *mac,
 906                                     u16 fid_index)
 907 {
 908         struct mlxsw_sp_nve_ipv6_ht_node *ipv6_ht_node;
 909
 910         ASSERT_RTNL();
 911
 912         ipv6_ht_node = mlxsw_sp_nve_ipv6_ht_node_lookup(mlxsw_sp, mac,
 913                                                         fid_index);
 914         if (WARN_ON(!ipv6_ht_node))
 915                 return;
 916
 917         mlxsw_sp_nve_ipv6_ht_remove(mlxsw_sp, ipv6_ht_node);
 918 }
 919
 920 static void mlxsw_sp_nve_ipv6_addr_flush_by_fid(struct mlxsw_sp *mlxsw_sp,
 921                                                 u16 fid_index)
 922 {
 923         struct mlxsw_sp_nve_ipv6_ht_node *ipv6_ht_node, *tmp;
 924         struct mlxsw_sp_nve *nve = mlxsw_sp->nve;
 925
 926         list_for_each_entry_safe(ipv6_ht_node, tmp, &nve->ipv6_addr_list,
 927                                  list) {
 928                 if (ipv6_ht_node->key.fid_index != fid_index)
 929                         continue;
 930
 931                 mlxsw_sp_ipv6_addr_put(mlxsw_sp, &ipv6_ht_node->addr6);
 932                 mlxsw_sp_nve_ipv6_ht_remove(mlxsw_sp, ipv6_ht_node);
 933         }
 934 }
 935
 936 int mlxsw_sp_nve_fid_enable(struct mlxsw_sp *mlxsw_sp, struct mlxsw_sp_fid *fid,
 937                             struct mlxsw_sp_nve_params *params,
 938                             struct netlink_ext_ack *extack)
 939 {
 940         struct mlxsw_sp_nve *nve = mlxsw_sp->nve;
 941         const struct mlxsw_sp_nve_ops *ops;
 942         struct mlxsw_sp_nve_config config;
 943         int err;
 944
 945         ops = nve->nve_ops_arr[params->type];
 946
 947         if (!ops->can_offload(nve, params, extack))
 948                 return -EINVAL;
 949
 950         memset(&config, 0, sizeof(config));
 951         ops->nve_config(nve, params, &config);
 952         if (nve->num_nve_tunnels &&
 953             memcmp(&config, &nve->config, sizeof(config))) {
 954                 NL_SET_ERR_MSG_MOD(extack, "Conflicting NVE tunnels configuration");
 955                 return -EINVAL;
 956         }
 957
 958         err = mlxsw_sp_nve_tunnel_init(mlxsw_sp, &config);
 959         if (err) {
 960                 NL_SET_ERR_MSG_MOD(extack, "Failed to initialize NVE tunnel");
 961                 return err;
 962         }
 963
 964         err = mlxsw_sp_fid_vni_set(fid, params->type, params->vni,
 965                                    params->dev->ifindex);
 966         if (err) {
 967                 NL_SET_ERR_MSG_MOD(extack, "Failed to set VNI on FID");
 968                 goto err_fid_vni_set;
 969         }
 970
 971         err = ops->fdb_replay(params->dev, params->vni, extack);
 972         if (err)
 973                 goto err_fdb_replay;
 974
 975         return 0;
 976
 977 err_fdb_replay:
 978         mlxsw_sp_fid_vni_clear(fid);
 979 err_fid_vni_set:
 980         mlxsw_sp_nve_tunnel_fini(mlxsw_sp);
 981         return err;
 982 }
 983
 984 void mlxsw_sp_nve_fid_disable(struct mlxsw_sp *mlxsw_sp,
 985                               struct mlxsw_sp_fid *fid)
 986 {
 987         u16 fid_index = mlxsw_sp_fid_index(fid);
 988         struct net_device *nve_dev;
 989         int nve_ifindex;
 990         __be32 vni;
 991
 992         /* Necessary for __dev_get_by_index() below. */
 993         ASSERT_RTNL();
 994
 995         mlxsw_sp_nve_flood_ip_flush(mlxsw_sp, fid);
 996         mlxsw_sp_nve_fdb_flush_by_fid(mlxsw_sp, fid_index);
 997         mlxsw_sp_nve_ipv6_addr_flush_by_fid(mlxsw_sp, fid_index);
 998
 999         if (WARN_ON(mlxsw_sp_fid_nve_ifindex(fid, &nve_ifindex) ||
1000                     mlxsw_sp_fid_vni(fid, &vni)))
1001                 goto out;
1002
1003         nve_dev = __dev_get_by_index(mlxsw_sp_net(mlxsw_sp), nve_ifindex);
1004         if (!nve_dev)
1005                 goto out;
1006
1007         mlxsw_sp_nve_fdb_clear_offload(mlxsw_sp, fid, nve_dev, vni);
1008         mlxsw_sp_fid_fdb_clear_offload(fid, nve_dev);
1009
1010 out:
1011         mlxsw_sp_fid_vni_clear(fid);
1012         mlxsw_sp_nve_tunnel_fini(mlxsw_sp);
1013 }
1014
1015 int mlxsw_sp_port_nve_init(struct mlxsw_sp_port *mlxsw_sp_port)
1016 {
1017         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1018         char tnqdr_pl[MLXSW_REG_TNQDR_LEN];
1019
1020         mlxsw_reg_tnqdr_pack(tnqdr_pl, mlxsw_sp_port->local_port);
1021         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(tnqdr), tnqdr_pl);
1022 }
1023
1024 void mlxsw_sp_port_nve_fini(struct mlxsw_sp_port *mlxsw_sp_port)
1025 {
1026 }
1027
1028 static int mlxsw_sp_nve_qos_init(struct mlxsw_sp *mlxsw_sp)
1029 {
1030         char tnqcr_pl[MLXSW_REG_TNQCR_LEN];
1031
1032         mlxsw_reg_tnqcr_pack(tnqcr_pl);
1033         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(tnqcr), tnqcr_pl);
1034 }
1035
1036 static int mlxsw_sp_nve_ecn_encap_init(struct mlxsw_sp *mlxsw_sp)
1037 {
1038         int i;
1039
1040         /* Iterate over inner ECN values */
1041         for (i = INET_ECN_NOT_ECT; i <= INET_ECN_CE; i++) {
1042                 u8 outer_ecn = INET_ECN_encapsulate(0, i);
1043                 char tneem_pl[MLXSW_REG_TNEEM_LEN];
1044                 int err;
1045
1046                 mlxsw_reg_tneem_pack(tneem_pl, i, outer_ecn);
1047                 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(tneem),
1048                                       tneem_pl);
1049                 if (err)
1050                         return err;
1051         }
1052
1053         return 0;
1054 }
1055
1056 static int __mlxsw_sp_nve_ecn_decap_init(struct mlxsw_sp *mlxsw_sp,
1057                                          u8 inner_ecn, u8 outer_ecn)
1058 {
1059         char tndem_pl[MLXSW_REG_TNDEM_LEN];
1060         u8 new_inner_ecn;
1061         bool trap_en;
1062
1063         new_inner_ecn = mlxsw_sp_tunnel_ecn_decap(outer_ecn, inner_ecn,
1064                                                   &trap_en);
1065         mlxsw_reg_tndem_pack(tndem_pl, outer_ecn, inner_ecn, new_inner_ecn,
1066                              trap_en, trap_en ? MLXSW_TRAP_ID_DECAP_ECN0 : 0);
1067         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(tndem), tndem_pl);
1068 }
1069
1070 static int mlxsw_sp_nve_ecn_decap_init(struct mlxsw_sp *mlxsw_sp)
1071 {
1072         int i;
1073
1074         /* Iterate over inner ECN values */
1075         for (i = INET_ECN_NOT_ECT; i <= INET_ECN_CE; i++) {
1076                 int j;
1077
1078                 /* Iterate over outer ECN values */
1079                 for (j = INET_ECN_NOT_ECT; j <= INET_ECN_CE; j++) {
1080                         int err;
1081
1082                         err = __mlxsw_sp_nve_ecn_decap_init(mlxsw_sp, i, j);
1083                         if (err)
1084                                 return err;
1085                 }
1086         }
1087
1088         return 0;
1089 }
1090
1091 static int mlxsw_sp_nve_ecn_init(struct mlxsw_sp *mlxsw_sp)
1092 {
1093         int err;
1094
1095         err = mlxsw_sp_nve_ecn_encap_init(mlxsw_sp);
1096         if (err)
1097                 return err;
1098
1099         return mlxsw_sp_nve_ecn_decap_init(mlxsw_sp);
1100 }
1101
1102 static int mlxsw_sp_nve_resources_query(struct mlxsw_sp *mlxsw_sp)
1103 {
1104         unsigned int max;
1105
1106         if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_NVE_MC_ENTRIES_IPV4) ||
1107             !MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_NVE_MC_ENTRIES_IPV6))
1108                 return -EIO;
1109         max = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_NVE_MC_ENTRIES_IPV4);
1110         mlxsw_sp->nve->num_max_mc_entries[MLXSW_SP_L3_PROTO_IPV4] = max;
1111         max = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_NVE_MC_ENTRIES_IPV6);
1112         mlxsw_sp->nve->num_max_mc_entries[MLXSW_SP_L3_PROTO_IPV6] = max;
1113
1114         return 0;
1115 }
1116
1117 int mlxsw_sp_nve_init(struct mlxsw_sp *mlxsw_sp)
1118 {
1119         struct mlxsw_sp_nve *nve;
1120         int err;
1121
1122         nve = kzalloc(sizeof(*mlxsw_sp->nve), GFP_KERNEL);
1123         if (!nve)
1124                 return -ENOMEM;
1125         mlxsw_sp->nve = nve;
1126         nve->mlxsw_sp = mlxsw_sp;
1127         nve->nve_ops_arr = mlxsw_sp->nve_ops_arr;
1128
1129         err = rhashtable_init(&nve->mc_list_ht,
1130                               &mlxsw_sp_nve_mc_list_ht_params);
1131         if (err)
1132                 goto err_mc_rhashtable_init;
1133
1134         err = rhashtable_init(&nve->ipv6_ht, &mlxsw_sp_nve_ipv6_ht_params);
1135         if (err)
1136                 goto err_ipv6_rhashtable_init;
1137
1138         INIT_LIST_HEAD(&nve->ipv6_addr_list);
1139
1140         err = mlxsw_sp_nve_qos_init(mlxsw_sp);
1141         if (err)
1142                 goto err_nve_qos_init;
1143
1144         err = mlxsw_sp_nve_ecn_init(mlxsw_sp);
1145         if (err)
1146                 goto err_nve_ecn_init;
1147
1148         err = mlxsw_sp_nve_resources_query(mlxsw_sp);
1149         if (err)
1150                 goto err_nve_resources_query;
1151
1152         return 0;
1153
1154 err_nve_resources_query:
1155 err_nve_ecn_init:
1156 err_nve_qos_init:
1157         rhashtable_destroy(&nve->ipv6_ht);
1158 err_ipv6_rhashtable_init:
1159         rhashtable_destroy(&nve->mc_list_ht);
1160 err_mc_rhashtable_init:
1161         mlxsw_sp->nve = NULL;
1162         kfree(nve);
1163         return err;
1164 }
1165
1166 void mlxsw_sp_nve_fini(struct mlxsw_sp *mlxsw_sp)
1167 {
1168         WARN_ON(mlxsw_sp->nve->num_nve_tunnels);
1169         WARN_ON(!list_empty(&mlxsw_sp->nve->ipv6_addr_list));
1170         rhashtable_destroy(&mlxsw_sp->nve->ipv6_ht);
1171         rhashtable_destroy(&mlxsw_sp->nve->mc_list_ht);
1172         kfree(mlxsw_sp->nve);
1173         mlxsw_sp->nve = NULL;
1174 }