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

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /* Copyright (c) 2016-2018 Mellanox Technologies. All rights reserved */
   3
   4 #include <linux/kernel.h>
   5 #include <linux/types.h>
   6 #include <linux/rhashtable.h>
   7 #include <linux/bitops.h>
   8 #include <linux/in6.h>
   9 #include <linux/notifier.h>
  10 #include <linux/inetdevice.h>
  11 #include <linux/netdevice.h>
  12 #include <linux/if_bridge.h>
  13 #include <linux/socket.h>
  14 #include <linux/route.h>
  15 #include <linux/gcd.h>
  16 #include <linux/if_macvlan.h>
  17 #include <linux/refcount.h>
  18 #include <linux/jhash.h>
  19 #include <linux/net_namespace.h>
  20 #include <linux/mutex.h>
  21 #include <linux/genalloc.h>
  22 #include <net/netevent.h>
  23 #include <net/neighbour.h>
  24 #include <net/arp.h>
  25 #include <net/inet_dscp.h>
  26 #include <net/ip_fib.h>
  27 #include <net/ip6_fib.h>
  28 #include <net/nexthop.h>
  29 #include <net/fib_rules.h>
  30 #include <net/ip_tunnels.h>
  31 #include <net/l3mdev.h>
  32 #include <net/addrconf.h>
  33 #include <net/ndisc.h>
  34 #include <net/ipv6.h>
  35 #include <net/fib_notifier.h>
  36 #include <net/switchdev.h>
  37
  38 #include "spectrum.h"
  39 #include "core.h"
  40 #include "reg.h"
  41 #include "spectrum_cnt.h"
  42 #include "spectrum_dpipe.h"
  43 #include "spectrum_ipip.h"
  44 #include "spectrum_mr.h"
  45 #include "spectrum_mr_tcam.h"
  46 #include "spectrum_router.h"
  47 #include "spectrum_span.h"
  48
  49 struct mlxsw_sp_fib;
  50 struct mlxsw_sp_vr;
  51 struct mlxsw_sp_lpm_tree;
  52 struct mlxsw_sp_rif_ops;
  53
  54 struct mlxsw_sp_crif_key {
  55         struct net_device *dev;
  56 };
  57
  58 struct mlxsw_sp_crif {
  59         struct mlxsw_sp_crif_key key;
  60         struct rhash_head ht_node;
  61         bool can_destroy;
  62         struct list_head nexthop_list;
  63         struct mlxsw_sp_rif *rif;
  64 };
  65
  66 static const struct rhashtable_params mlxsw_sp_crif_ht_params = {
  67         .key_offset = offsetof(struct mlxsw_sp_crif, key),
  68         .key_len = sizeof_field(struct mlxsw_sp_crif, key),
  69         .head_offset = offsetof(struct mlxsw_sp_crif, ht_node),
  70 };
  71
  72 struct mlxsw_sp_rif {
  73         struct mlxsw_sp_crif *crif; /* NULL for underlay RIF */
  74         struct list_head neigh_list;
  75         struct mlxsw_sp_fid *fid;
  76         unsigned char addr[ETH_ALEN];
  77         int mtu;
  78         u16 rif_index;
  79         u8 mac_profile_id;
  80         u8 rif_entries;
  81         u16 vr_id;
  82         const struct mlxsw_sp_rif_ops *ops;
  83         struct mlxsw_sp *mlxsw_sp;
  84
  85         unsigned int counter_ingress;
  86         bool counter_ingress_valid;
  87         unsigned int counter_egress;
  88         bool counter_egress_valid;
  89 };
  90
  91 static struct net_device *mlxsw_sp_rif_dev(const struct mlxsw_sp_rif *rif)
  92 {
  93         if (!rif->crif)
  94                 return NULL;
  95         return rif->crif->key.dev;
  96 }
  97
  98 struct mlxsw_sp_rif_params {
  99         struct net_device *dev;
 100         union {
 101                 u16 system_port;
 102                 u16 lag_id;
 103         };
 104         u16 vid;
 105         bool lag;
 106         bool double_entry;
 107 };
 108
 109 struct mlxsw_sp_rif_subport {
 110         struct mlxsw_sp_rif common;
 111         refcount_t ref_count;
 112         union {
 113                 u16 system_port;
 114                 u16 lag_id;
 115         };
 116         u16 vid;
 117         bool lag;
 118 };
 119
 120 struct mlxsw_sp_rif_ipip_lb {
 121         struct mlxsw_sp_rif common;
 122         struct mlxsw_sp_rif_ipip_lb_config lb_config;
 123         u16 ul_vr_id;   /* Spectrum-1. */
 124         u16 ul_rif_id;  /* Spectrum-2+. */
 125 };
 126
 127 struct mlxsw_sp_rif_params_ipip_lb {
 128         struct mlxsw_sp_rif_params common;
 129         struct mlxsw_sp_rif_ipip_lb_config lb_config;
 130 };
 131
 132 struct mlxsw_sp_rif_ops {
 133         enum mlxsw_sp_rif_type type;
 134         size_t rif_size;
 135
 136         void (*setup)(struct mlxsw_sp_rif *rif,
 137                       const struct mlxsw_sp_rif_params *params);
 138         int (*configure)(struct mlxsw_sp_rif *rif,
 139                          struct netlink_ext_ack *extack);
 140         void (*deconfigure)(struct mlxsw_sp_rif *rif);
 141         struct mlxsw_sp_fid * (*fid_get)(struct mlxsw_sp_rif *rif,
 142                                          const struct mlxsw_sp_rif_params *params,
 143                                          struct netlink_ext_ack *extack);
 144         void (*fdb_del)(struct mlxsw_sp_rif *rif, const char *mac);
 145 };
 146
 147 struct mlxsw_sp_rif_mac_profile {
 148         unsigned char mac_prefix[ETH_ALEN];
 149         refcount_t ref_count;
 150         u8 id;
 151 };
 152
 153 struct mlxsw_sp_router_ops {
 154         int (*init)(struct mlxsw_sp *mlxsw_sp);
 155         int (*ipips_init)(struct mlxsw_sp *mlxsw_sp);
 156 };
 157
 158 static struct mlxsw_sp_rif *
 159 mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp,
 160                          const struct net_device *dev);
 161 static void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif);
 162 static void mlxsw_sp_lpm_tree_hold(struct mlxsw_sp_lpm_tree *lpm_tree);
 163 static void mlxsw_sp_lpm_tree_put(struct mlxsw_sp *mlxsw_sp,
 164                                   struct mlxsw_sp_lpm_tree *lpm_tree);
 165 static int mlxsw_sp_vr_lpm_tree_bind(struct mlxsw_sp *mlxsw_sp,
 166                                      const struct mlxsw_sp_fib *fib,
 167                                      u8 tree_id);
 168 static int mlxsw_sp_vr_lpm_tree_unbind(struct mlxsw_sp *mlxsw_sp,
 169                                        const struct mlxsw_sp_fib *fib);
 170
 171 static unsigned int *
 172 mlxsw_sp_rif_p_counter_get(struct mlxsw_sp_rif *rif,
 173                            enum mlxsw_sp_rif_counter_dir dir)
 174 {
 175         switch (dir) {
 176         case MLXSW_SP_RIF_COUNTER_EGRESS:
 177                 return &rif->counter_egress;
 178         case MLXSW_SP_RIF_COUNTER_INGRESS:
 179                 return &rif->counter_ingress;
 180         }
 181         return NULL;
 182 }
 183
 184 static bool
 185 mlxsw_sp_rif_counter_valid_get(struct mlxsw_sp_rif *rif,
 186                                enum mlxsw_sp_rif_counter_dir dir)
 187 {
 188         switch (dir) {
 189         case MLXSW_SP_RIF_COUNTER_EGRESS:
 190                 return rif->counter_egress_valid;
 191         case MLXSW_SP_RIF_COUNTER_INGRESS:
 192                 return rif->counter_ingress_valid;
 193         }
 194         return false;
 195 }
 196
 197 static void
 198 mlxsw_sp_rif_counter_valid_set(struct mlxsw_sp_rif *rif,
 199                                enum mlxsw_sp_rif_counter_dir dir,
 200                                bool valid)
 201 {
 202         switch (dir) {
 203         case MLXSW_SP_RIF_COUNTER_EGRESS:
 204                 rif->counter_egress_valid = valid;
 205                 break;
 206         case MLXSW_SP_RIF_COUNTER_INGRESS:
 207                 rif->counter_ingress_valid = valid;
 208                 break;
 209         }
 210 }
 211
 212 static int mlxsw_sp_rif_counter_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
 213                                      unsigned int counter_index, bool enable,
 214                                      enum mlxsw_sp_rif_counter_dir dir)
 215 {
 216         char ritr_pl[MLXSW_REG_RITR_LEN];
 217         bool is_egress = false;
 218         int err;
 219
 220         if (dir == MLXSW_SP_RIF_COUNTER_EGRESS)
 221                 is_egress = true;
 222         mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
 223         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
 224         if (err)
 225                 return err;
 226
 227         mlxsw_reg_ritr_counter_pack(ritr_pl, counter_index, enable,
 228                                     is_egress);
 229         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
 230 }
 231
 232 int mlxsw_sp_rif_counter_value_get(struct mlxsw_sp *mlxsw_sp,
 233                                    struct mlxsw_sp_rif *rif,
 234                                    enum mlxsw_sp_rif_counter_dir dir, u64 *cnt)
 235 {
 236         char ricnt_pl[MLXSW_REG_RICNT_LEN];
 237         unsigned int *p_counter_index;
 238         bool valid;
 239         int err;
 240
 241         valid = mlxsw_sp_rif_counter_valid_get(rif, dir);
 242         if (!valid)
 243                 return -EINVAL;
 244
 245         p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
 246         if (!p_counter_index)
 247                 return -EINVAL;
 248         mlxsw_reg_ricnt_pack(ricnt_pl, *p_counter_index,
 249                              MLXSW_REG_RICNT_OPCODE_NOP);
 250         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
 251         if (err)
 252                 return err;
 253         *cnt = mlxsw_reg_ricnt_good_unicast_packets_get(ricnt_pl);
 254         return 0;
 255 }
 256
 257 struct mlxsw_sp_rif_counter_set_basic {
 258         u64 good_unicast_packets;
 259         u64 good_multicast_packets;
 260         u64 good_broadcast_packets;
 261         u64 good_unicast_bytes;
 262         u64 good_multicast_bytes;
 263         u64 good_broadcast_bytes;
 264         u64 error_packets;
 265         u64 discard_packets;
 266         u64 error_bytes;
 267         u64 discard_bytes;
 268 };
 269
 270 static int
 271 mlxsw_sp_rif_counter_fetch_clear(struct mlxsw_sp_rif *rif,
 272                                  enum mlxsw_sp_rif_counter_dir dir,
 273                                  struct mlxsw_sp_rif_counter_set_basic *set)
 274 {
 275         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
 276         char ricnt_pl[MLXSW_REG_RICNT_LEN];
 277         unsigned int *p_counter_index;
 278         int err;
 279
 280         if (!mlxsw_sp_rif_counter_valid_get(rif, dir))
 281                 return -EINVAL;
 282
 283         p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
 284         if (!p_counter_index)
 285                 return -EINVAL;
 286
 287         mlxsw_reg_ricnt_pack(ricnt_pl, *p_counter_index,
 288                              MLXSW_REG_RICNT_OPCODE_CLEAR);
 289         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
 290         if (err)
 291                 return err;
 292
 293         if (!set)
 294                 return 0;
 295
 296 #define MLXSW_SP_RIF_COUNTER_EXTRACT(NAME)                              \
 297                 (set->NAME = mlxsw_reg_ricnt_ ## NAME ## _get(ricnt_pl))
 298
 299         MLXSW_SP_RIF_COUNTER_EXTRACT(good_unicast_packets);
 300         MLXSW_SP_RIF_COUNTER_EXTRACT(good_multicast_packets);
 301         MLXSW_SP_RIF_COUNTER_EXTRACT(good_broadcast_packets);
 302         MLXSW_SP_RIF_COUNTER_EXTRACT(good_unicast_bytes);
 303         MLXSW_SP_RIF_COUNTER_EXTRACT(good_multicast_bytes);
 304         MLXSW_SP_RIF_COUNTER_EXTRACT(good_broadcast_bytes);
 305         MLXSW_SP_RIF_COUNTER_EXTRACT(error_packets);
 306         MLXSW_SP_RIF_COUNTER_EXTRACT(discard_packets);
 307         MLXSW_SP_RIF_COUNTER_EXTRACT(error_bytes);
 308         MLXSW_SP_RIF_COUNTER_EXTRACT(discard_bytes);
 309
 310 #undef MLXSW_SP_RIF_COUNTER_EXTRACT
 311
 312         return 0;
 313 }
 314
 315 static int mlxsw_sp_rif_counter_clear(struct mlxsw_sp *mlxsw_sp,
 316                                       unsigned int counter_index)
 317 {
 318         char ricnt_pl[MLXSW_REG_RICNT_LEN];
 319
 320         mlxsw_reg_ricnt_pack(ricnt_pl, counter_index,
 321                              MLXSW_REG_RICNT_OPCODE_CLEAR);
 322         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
 323 }
 324
 325 int mlxsw_sp_rif_counter_alloc(struct mlxsw_sp_rif *rif,
 326                                enum mlxsw_sp_rif_counter_dir dir)
 327 {
 328         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
 329         unsigned int *p_counter_index;
 330         int err;
 331
 332         if (mlxsw_sp_rif_counter_valid_get(rif, dir))
 333                 return 0;
 334
 335         p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
 336         if (!p_counter_index)
 337                 return -EINVAL;
 338
 339         err = mlxsw_sp_counter_alloc(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
 340                                      p_counter_index);
 341         if (err)
 342                 return err;
 343
 344         err = mlxsw_sp_rif_counter_clear(mlxsw_sp, *p_counter_index);
 345         if (err)
 346                 goto err_counter_clear;
 347
 348         err = mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
 349                                         *p_counter_index, true, dir);
 350         if (err)
 351                 goto err_counter_edit;
 352         mlxsw_sp_rif_counter_valid_set(rif, dir, true);
 353         return 0;
 354
 355 err_counter_edit:
 356 err_counter_clear:
 357         mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
 358                               *p_counter_index);
 359         return err;
 360 }
 361
 362 void mlxsw_sp_rif_counter_free(struct mlxsw_sp_rif *rif,
 363                                enum mlxsw_sp_rif_counter_dir dir)
 364 {
 365         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
 366         unsigned int *p_counter_index;
 367
 368         if (!mlxsw_sp_rif_counter_valid_get(rif, dir))
 369                 return;
 370
 371         p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
 372         if (WARN_ON(!p_counter_index))
 373                 return;
 374         mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
 375                                   *p_counter_index, false, dir);
 376         mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
 377                               *p_counter_index);
 378         mlxsw_sp_rif_counter_valid_set(rif, dir, false);
 379 }
 380
 381 static void mlxsw_sp_rif_counters_alloc(struct mlxsw_sp_rif *rif)
 382 {
 383         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
 384         struct devlink *devlink;
 385
 386         devlink = priv_to_devlink(mlxsw_sp->core);
 387         if (!devlink_dpipe_table_counter_enabled(devlink,
 388                                                  MLXSW_SP_DPIPE_TABLE_NAME_ERIF))
 389                 return;
 390         mlxsw_sp_rif_counter_alloc(rif, MLXSW_SP_RIF_COUNTER_EGRESS);
 391 }
 392
 393 static void mlxsw_sp_rif_counters_free(struct mlxsw_sp_rif *rif)
 394 {
 395         mlxsw_sp_rif_counter_free(rif, MLXSW_SP_RIF_COUNTER_EGRESS);
 396 }
 397
 398 #define MLXSW_SP_PREFIX_COUNT (sizeof(struct in6_addr) * BITS_PER_BYTE + 1)
 399
 400 struct mlxsw_sp_prefix_usage {
 401         DECLARE_BITMAP(b, MLXSW_SP_PREFIX_COUNT);
 402 };
 403
 404 #define mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) \
 405         for_each_set_bit(prefix, (prefix_usage)->b, MLXSW_SP_PREFIX_COUNT)
 406
 407 static bool
 408 mlxsw_sp_prefix_usage_eq(struct mlxsw_sp_prefix_usage *prefix_usage1,
 409                          struct mlxsw_sp_prefix_usage *prefix_usage2)
 410 {
 411         return !memcmp(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
 412 }
 413
 414 static void
 415 mlxsw_sp_prefix_usage_cpy(struct mlxsw_sp_prefix_usage *prefix_usage1,
 416                           struct mlxsw_sp_prefix_usage *prefix_usage2)
 417 {
 418         memcpy(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
 419 }
 420
 421 static void
 422 mlxsw_sp_prefix_usage_set(struct mlxsw_sp_prefix_usage *prefix_usage,
 423                           unsigned char prefix_len)
 424 {
 425         set_bit(prefix_len, prefix_usage->b);
 426 }
 427
 428 static void
 429 mlxsw_sp_prefix_usage_clear(struct mlxsw_sp_prefix_usage *prefix_usage,
 430                             unsigned char prefix_len)
 431 {
 432         clear_bit(prefix_len, prefix_usage->b);
 433 }
 434
 435 struct mlxsw_sp_fib_key {
 436         unsigned char addr[sizeof(struct in6_addr)];
 437         unsigned char prefix_len;
 438 };
 439
 440 enum mlxsw_sp_fib_entry_type {
 441         MLXSW_SP_FIB_ENTRY_TYPE_REMOTE,
 442         MLXSW_SP_FIB_ENTRY_TYPE_LOCAL,
 443         MLXSW_SP_FIB_ENTRY_TYPE_TRAP,
 444         MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE,
 445         MLXSW_SP_FIB_ENTRY_TYPE_UNREACHABLE,
 446
 447         /* This is a special case of local delivery, where a packet should be
 448          * decapsulated on reception. Note that there is no corresponding ENCAP,
 449          * because that's a type of next hop, not of FIB entry. (There can be
 450          * several next hops in a REMOTE entry, and some of them may be
 451          * encapsulating entries.)
 452          */
 453         MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP,
 454         MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP,
 455 };
 456
 457 struct mlxsw_sp_nexthop_group_info;
 458 struct mlxsw_sp_nexthop_group;
 459 struct mlxsw_sp_fib_entry;
 460
 461 struct mlxsw_sp_fib_node {
 462         struct mlxsw_sp_fib_entry *fib_entry;
 463         struct list_head list;
 464         struct rhash_head ht_node;
 465         struct mlxsw_sp_fib *fib;
 466         struct mlxsw_sp_fib_key key;
 467 };
 468
 469 struct mlxsw_sp_fib_entry_decap {
 470         struct mlxsw_sp_ipip_entry *ipip_entry;
 471         u32 tunnel_index;
 472 };
 473
 474 struct mlxsw_sp_fib_entry {
 475         struct mlxsw_sp_fib_node *fib_node;
 476         enum mlxsw_sp_fib_entry_type type;
 477         struct list_head nexthop_group_node;
 478         struct mlxsw_sp_nexthop_group *nh_group;
 479         struct mlxsw_sp_fib_entry_decap decap; /* Valid for decap entries. */
 480 };
 481
 482 struct mlxsw_sp_fib4_entry {
 483         struct mlxsw_sp_fib_entry common;
 484         struct fib_info *fi;
 485         u32 tb_id;
 486         dscp_t dscp;
 487         u8 type;
 488 };
 489
 490 struct mlxsw_sp_fib6_entry {
 491         struct mlxsw_sp_fib_entry common;
 492         struct list_head rt6_list;
 493         unsigned int nrt6;
 494 };
 495
 496 struct mlxsw_sp_rt6 {
 497         struct list_head list;
 498         struct fib6_info *rt;
 499 };
 500
 501 struct mlxsw_sp_lpm_tree {
 502         u8 id; /* tree ID */
 503         unsigned int ref_count;
 504         enum mlxsw_sp_l3proto proto;
 505         unsigned long prefix_ref_count[MLXSW_SP_PREFIX_COUNT];
 506         struct mlxsw_sp_prefix_usage prefix_usage;
 507 };
 508
 509 struct mlxsw_sp_fib {
 510         struct rhashtable ht;
 511         struct list_head node_list;
 512         struct mlxsw_sp_vr *vr;
 513         struct mlxsw_sp_lpm_tree *lpm_tree;
 514         enum mlxsw_sp_l3proto proto;
 515 };
 516
 517 struct mlxsw_sp_vr {
 518         u16 id; /* virtual router ID */
 519         u32 tb_id; /* kernel fib table id */
 520         unsigned int rif_count;
 521         struct mlxsw_sp_fib *fib4;
 522         struct mlxsw_sp_fib *fib6;
 523         struct mlxsw_sp_mr_table *mr_table[MLXSW_SP_L3_PROTO_MAX];
 524         struct mlxsw_sp_rif *ul_rif;
 525         refcount_t ul_rif_refcnt;
 526 };
 527
 528 static const struct rhashtable_params mlxsw_sp_fib_ht_params;
 529
 530 static struct mlxsw_sp_fib *mlxsw_sp_fib_create(struct mlxsw_sp *mlxsw_sp,
 531                                                 struct mlxsw_sp_vr *vr,
 532                                                 enum mlxsw_sp_l3proto proto)
 533 {
 534         struct mlxsw_sp_lpm_tree *lpm_tree;
 535         struct mlxsw_sp_fib *fib;
 536         int err;
 537
 538         lpm_tree = mlxsw_sp->router->lpm.proto_trees[proto];
 539         fib = kzalloc(sizeof(*fib), GFP_KERNEL);
 540         if (!fib)
 541                 return ERR_PTR(-ENOMEM);
 542         err = rhashtable_init(&fib->ht, &mlxsw_sp_fib_ht_params);
 543         if (err)
 544                 goto err_rhashtable_init;
 545         INIT_LIST_HEAD(&fib->node_list);
 546         fib->proto = proto;
 547         fib->vr = vr;
 548         fib->lpm_tree = lpm_tree;
 549         mlxsw_sp_lpm_tree_hold(lpm_tree);
 550         err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, lpm_tree->id);
 551         if (err)
 552                 goto err_lpm_tree_bind;
 553         return fib;
 554
 555 err_lpm_tree_bind:
 556         mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
 557 err_rhashtable_init:
 558         kfree(fib);
 559         return ERR_PTR(err);
 560 }
 561
 562 static void mlxsw_sp_fib_destroy(struct mlxsw_sp *mlxsw_sp,
 563                                  struct mlxsw_sp_fib *fib)
 564 {
 565         mlxsw_sp_vr_lpm_tree_unbind(mlxsw_sp, fib);
 566         mlxsw_sp_lpm_tree_put(mlxsw_sp, fib->lpm_tree);
 567         WARN_ON(!list_empty(&fib->node_list));
 568         rhashtable_destroy(&fib->ht);
 569         kfree(fib);
 570 }
 571
 572 static struct mlxsw_sp_lpm_tree *
 573 mlxsw_sp_lpm_tree_find_unused(struct mlxsw_sp *mlxsw_sp)
 574 {
 575         static struct mlxsw_sp_lpm_tree *lpm_tree;
 576         int i;
 577
 578         for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
 579                 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
 580                 if (lpm_tree->ref_count == 0)
 581                         return lpm_tree;
 582         }
 583         return NULL;
 584 }
 585
 586 static int mlxsw_sp_lpm_tree_alloc(struct mlxsw_sp *mlxsw_sp,
 587                                    struct mlxsw_sp_lpm_tree *lpm_tree)
 588 {
 589         char ralta_pl[MLXSW_REG_RALTA_LEN];
 590
 591         mlxsw_reg_ralta_pack(ralta_pl, true,
 592                              (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
 593                              lpm_tree->id);
 594         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
 595 }
 596
 597 static void mlxsw_sp_lpm_tree_free(struct mlxsw_sp *mlxsw_sp,
 598                                    struct mlxsw_sp_lpm_tree *lpm_tree)
 599 {
 600         char ralta_pl[MLXSW_REG_RALTA_LEN];
 601
 602         mlxsw_reg_ralta_pack(ralta_pl, false,
 603                              (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
 604                              lpm_tree->id);
 605         mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
 606 }
 607
 608 static int
 609 mlxsw_sp_lpm_tree_left_struct_set(struct mlxsw_sp *mlxsw_sp,
 610                                   struct mlxsw_sp_prefix_usage *prefix_usage,
 611                                   struct mlxsw_sp_lpm_tree *lpm_tree)
 612 {
 613         char ralst_pl[MLXSW_REG_RALST_LEN];
 614         u8 root_bin = 0;
 615         u8 prefix;
 616         u8 last_prefix = MLXSW_REG_RALST_BIN_NO_CHILD;
 617
 618         mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage)
 619                 root_bin = prefix;
 620
 621         mlxsw_reg_ralst_pack(ralst_pl, root_bin, lpm_tree->id);
 622         mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) {
 623                 if (prefix == 0)
 624                         continue;
 625                 mlxsw_reg_ralst_bin_pack(ralst_pl, prefix, last_prefix,
 626                                          MLXSW_REG_RALST_BIN_NO_CHILD);
 627                 last_prefix = prefix;
 628         }
 629         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralst), ralst_pl);
 630 }
 631
 632 static struct mlxsw_sp_lpm_tree *
 633 mlxsw_sp_lpm_tree_create(struct mlxsw_sp *mlxsw_sp,
 634                          struct mlxsw_sp_prefix_usage *prefix_usage,
 635                          enum mlxsw_sp_l3proto proto)
 636 {
 637         struct mlxsw_sp_lpm_tree *lpm_tree;
 638         int err;
 639
 640         lpm_tree = mlxsw_sp_lpm_tree_find_unused(mlxsw_sp);
 641         if (!lpm_tree)
 642                 return ERR_PTR(-EBUSY);
 643         lpm_tree->proto = proto;
 644         err = mlxsw_sp_lpm_tree_alloc(mlxsw_sp, lpm_tree);
 645         if (err)
 646                 return ERR_PTR(err);
 647
 648         err = mlxsw_sp_lpm_tree_left_struct_set(mlxsw_sp, prefix_usage,
 649                                                 lpm_tree);
 650         if (err)
 651                 goto err_left_struct_set;
 652         memcpy(&lpm_tree->prefix_usage, prefix_usage,
 653                sizeof(lpm_tree->prefix_usage));
 654         memset(&lpm_tree->prefix_ref_count, 0,
 655                sizeof(lpm_tree->prefix_ref_count));
 656         lpm_tree->ref_count = 1;
 657         return lpm_tree;
 658
 659 err_left_struct_set:
 660         mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
 661         return ERR_PTR(err);
 662 }
 663
 664 static void mlxsw_sp_lpm_tree_destroy(struct mlxsw_sp *mlxsw_sp,
 665                                       struct mlxsw_sp_lpm_tree *lpm_tree)
 666 {
 667         mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
 668 }
 669
 670 static struct mlxsw_sp_lpm_tree *
 671 mlxsw_sp_lpm_tree_get(struct mlxsw_sp *mlxsw_sp,
 672                       struct mlxsw_sp_prefix_usage *prefix_usage,
 673                       enum mlxsw_sp_l3proto proto)
 674 {
 675         struct mlxsw_sp_lpm_tree *lpm_tree;
 676         int i;
 677
 678         for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
 679                 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
 680                 if (lpm_tree->ref_count != 0 &&
 681                     lpm_tree->proto == proto &&
 682                     mlxsw_sp_prefix_usage_eq(&lpm_tree->prefix_usage,
 683                                              prefix_usage)) {
 684                         mlxsw_sp_lpm_tree_hold(lpm_tree);
 685                         return lpm_tree;
 686                 }
 687         }
 688         return mlxsw_sp_lpm_tree_create(mlxsw_sp, prefix_usage, proto);
 689 }
 690
 691 static void mlxsw_sp_lpm_tree_hold(struct mlxsw_sp_lpm_tree *lpm_tree)
 692 {
 693         lpm_tree->ref_count++;
 694 }
 695
 696 static void mlxsw_sp_lpm_tree_put(struct mlxsw_sp *mlxsw_sp,
 697                                   struct mlxsw_sp_lpm_tree *lpm_tree)
 698 {
 699         if (--lpm_tree->ref_count == 0)
 700                 mlxsw_sp_lpm_tree_destroy(mlxsw_sp, lpm_tree);
 701 }
 702
 703 #define MLXSW_SP_LPM_TREE_MIN 1 /* tree 0 is reserved */
 704
 705 static int mlxsw_sp_lpm_init(struct mlxsw_sp *mlxsw_sp)
 706 {
 707         struct mlxsw_sp_prefix_usage req_prefix_usage = {{ 0 } };
 708         struct mlxsw_sp_lpm_tree *lpm_tree;
 709         u64 max_trees;
 710         int err, i;
 711
 712         if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_LPM_TREES))
 713                 return -EIO;
 714
 715         max_trees = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_LPM_TREES);
 716         mlxsw_sp->router->lpm.tree_count = max_trees - MLXSW_SP_LPM_TREE_MIN;
 717         mlxsw_sp->router->lpm.trees = kcalloc(mlxsw_sp->router->lpm.tree_count,
 718                                              sizeof(struct mlxsw_sp_lpm_tree),
 719                                              GFP_KERNEL);
 720         if (!mlxsw_sp->router->lpm.trees)
 721                 return -ENOMEM;
 722
 723         for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
 724                 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
 725                 lpm_tree->id = i + MLXSW_SP_LPM_TREE_MIN;
 726         }
 727
 728         lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
 729                                          MLXSW_SP_L3_PROTO_IPV4);
 730         if (IS_ERR(lpm_tree)) {
 731                 err = PTR_ERR(lpm_tree);
 732                 goto err_ipv4_tree_get;
 733         }
 734         mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV4] = lpm_tree;
 735
 736         lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
 737                                          MLXSW_SP_L3_PROTO_IPV6);
 738         if (IS_ERR(lpm_tree)) {
 739                 err = PTR_ERR(lpm_tree);
 740                 goto err_ipv6_tree_get;
 741         }
 742         mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV6] = lpm_tree;
 743
 744         return 0;
 745
 746 err_ipv6_tree_get:
 747         lpm_tree = mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV4];
 748         mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
 749 err_ipv4_tree_get:
 750         kfree(mlxsw_sp->router->lpm.trees);
 751         return err;
 752 }
 753
 754 static void mlxsw_sp_lpm_fini(struct mlxsw_sp *mlxsw_sp)
 755 {
 756         struct mlxsw_sp_lpm_tree *lpm_tree;
 757
 758         lpm_tree = mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV6];
 759         mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
 760
 761         lpm_tree = mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV4];
 762         mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
 763
 764         kfree(mlxsw_sp->router->lpm.trees);
 765 }
 766
 767 static bool mlxsw_sp_vr_is_used(const struct mlxsw_sp_vr *vr)
 768 {
 769         return !!vr->fib4 || !!vr->fib6 ||
 770                !!vr->mr_table[MLXSW_SP_L3_PROTO_IPV4] ||
 771                !!vr->mr_table[MLXSW_SP_L3_PROTO_IPV6];
 772 }
 773
 774 static struct mlxsw_sp_vr *mlxsw_sp_vr_find_unused(struct mlxsw_sp *mlxsw_sp)
 775 {
 776         int max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
 777         struct mlxsw_sp_vr *vr;
 778         int i;
 779
 780         for (i = 0; i < max_vrs; i++) {
 781                 vr = &mlxsw_sp->router->vrs[i];
 782                 if (!mlxsw_sp_vr_is_used(vr))
 783                         return vr;
 784         }
 785         return NULL;
 786 }
 787
 788 static int mlxsw_sp_vr_lpm_tree_bind(struct mlxsw_sp *mlxsw_sp,
 789                                      const struct mlxsw_sp_fib *fib, u8 tree_id)
 790 {
 791         char raltb_pl[MLXSW_REG_RALTB_LEN];
 792
 793         mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
 794                              (enum mlxsw_reg_ralxx_protocol) fib->proto,
 795                              tree_id);
 796         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
 797 }
 798
 799 static int mlxsw_sp_vr_lpm_tree_unbind(struct mlxsw_sp *mlxsw_sp,
 800                                        const struct mlxsw_sp_fib *fib)
 801 {
 802         char raltb_pl[MLXSW_REG_RALTB_LEN];
 803
 804         /* Bind to tree 0 which is default */
 805         mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
 806                              (enum mlxsw_reg_ralxx_protocol) fib->proto, 0);
 807         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
 808 }
 809
 810 static u32 mlxsw_sp_fix_tb_id(u32 tb_id)
 811 {
 812         /* For our purpose, squash main, default and local tables into one */
 813         if (tb_id == RT_TABLE_LOCAL || tb_id == RT_TABLE_DEFAULT)
 814                 tb_id = RT_TABLE_MAIN;
 815         return tb_id;
 816 }
 817
 818 static struct mlxsw_sp_vr *mlxsw_sp_vr_find(struct mlxsw_sp *mlxsw_sp,
 819                                             u32 tb_id)
 820 {
 821         int max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
 822         struct mlxsw_sp_vr *vr;
 823         int i;
 824
 825         tb_id = mlxsw_sp_fix_tb_id(tb_id);
 826
 827         for (i = 0; i < max_vrs; i++) {
 828                 vr = &mlxsw_sp->router->vrs[i];
 829                 if (mlxsw_sp_vr_is_used(vr) && vr->tb_id == tb_id)
 830                         return vr;
 831         }
 832         return NULL;
 833 }
 834
 835 int mlxsw_sp_router_tb_id_vr_id(struct mlxsw_sp *mlxsw_sp, u32 tb_id,
 836                                 u16 *vr_id)
 837 {
 838         struct mlxsw_sp_vr *vr;
 839         int err = 0;
 840
 841         mutex_lock(&mlxsw_sp->router->lock);
 842         vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id);
 843         if (!vr) {
 844                 err = -ESRCH;
 845                 goto out;
 846         }
 847         *vr_id = vr->id;
 848 out:
 849         mutex_unlock(&mlxsw_sp->router->lock);
 850         return err;
 851 }
 852
 853 static struct mlxsw_sp_fib *mlxsw_sp_vr_fib(const struct mlxsw_sp_vr *vr,
 854                                             enum mlxsw_sp_l3proto proto)
 855 {
 856         switch (proto) {
 857         case MLXSW_SP_L3_PROTO_IPV4:
 858                 return vr->fib4;
 859         case MLXSW_SP_L3_PROTO_IPV6:
 860                 return vr->fib6;
 861         }
 862         return NULL;
 863 }
 864
 865 static struct mlxsw_sp_vr *mlxsw_sp_vr_create(struct mlxsw_sp *mlxsw_sp,
 866                                               u32 tb_id,
 867                                               struct netlink_ext_ack *extack)
 868 {
 869         struct mlxsw_sp_mr_table *mr4_table, *mr6_table;
 870         struct mlxsw_sp_fib *fib4;
 871         struct mlxsw_sp_fib *fib6;
 872         struct mlxsw_sp_vr *vr;
 873         int err;
 874
 875         vr = mlxsw_sp_vr_find_unused(mlxsw_sp);
 876         if (!vr) {
 877                 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported virtual routers");
 878                 return ERR_PTR(-EBUSY);
 879         }
 880         fib4 = mlxsw_sp_fib_create(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV4);
 881         if (IS_ERR(fib4))
 882                 return ERR_CAST(fib4);
 883         fib6 = mlxsw_sp_fib_create(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV6);
 884         if (IS_ERR(fib6)) {
 885                 err = PTR_ERR(fib6);
 886                 goto err_fib6_create;
 887         }
 888         mr4_table = mlxsw_sp_mr_table_create(mlxsw_sp, vr->id,
 889                                              MLXSW_SP_L3_PROTO_IPV4);
 890         if (IS_ERR(mr4_table)) {
 891                 err = PTR_ERR(mr4_table);
 892                 goto err_mr4_table_create;
 893         }
 894         mr6_table = mlxsw_sp_mr_table_create(mlxsw_sp, vr->id,
 895                                              MLXSW_SP_L3_PROTO_IPV6);
 896         if (IS_ERR(mr6_table)) {
 897                 err = PTR_ERR(mr6_table);
 898                 goto err_mr6_table_create;
 899         }
 900
 901         vr->fib4 = fib4;
 902         vr->fib6 = fib6;
 903         vr->mr_table[MLXSW_SP_L3_PROTO_IPV4] = mr4_table;
 904         vr->mr_table[MLXSW_SP_L3_PROTO_IPV6] = mr6_table;
 905         vr->tb_id = tb_id;
 906         return vr;
 907
 908 err_mr6_table_create:
 909         mlxsw_sp_mr_table_destroy(mr4_table);
 910 err_mr4_table_create:
 911         mlxsw_sp_fib_destroy(mlxsw_sp, fib6);
 912 err_fib6_create:
 913         mlxsw_sp_fib_destroy(mlxsw_sp, fib4);
 914         return ERR_PTR(err);
 915 }
 916
 917 static void mlxsw_sp_vr_destroy(struct mlxsw_sp *mlxsw_sp,
 918                                 struct mlxsw_sp_vr *vr)
 919 {
 920         mlxsw_sp_mr_table_destroy(vr->mr_table[MLXSW_SP_L3_PROTO_IPV6]);
 921         vr->mr_table[MLXSW_SP_L3_PROTO_IPV6] = NULL;
 922         mlxsw_sp_mr_table_destroy(vr->mr_table[MLXSW_SP_L3_PROTO_IPV4]);
 923         vr->mr_table[MLXSW_SP_L3_PROTO_IPV4] = NULL;
 924         mlxsw_sp_fib_destroy(mlxsw_sp, vr->fib6);
 925         vr->fib6 = NULL;
 926         mlxsw_sp_fib_destroy(mlxsw_sp, vr->fib4);
 927         vr->fib4 = NULL;
 928 }
 929
 930 static struct mlxsw_sp_vr *mlxsw_sp_vr_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id,
 931                                            struct netlink_ext_ack *extack)
 932 {
 933         struct mlxsw_sp_vr *vr;
 934
 935         tb_id = mlxsw_sp_fix_tb_id(tb_id);
 936         vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id);
 937         if (!vr)
 938                 vr = mlxsw_sp_vr_create(mlxsw_sp, tb_id, extack);
 939         return vr;
 940 }
 941
 942 static void mlxsw_sp_vr_put(struct mlxsw_sp *mlxsw_sp, struct mlxsw_sp_vr *vr)
 943 {
 944         if (!vr->rif_count && list_empty(&vr->fib4->node_list) &&
 945             list_empty(&vr->fib6->node_list) &&
 946             mlxsw_sp_mr_table_empty(vr->mr_table[MLXSW_SP_L3_PROTO_IPV4]) &&
 947             mlxsw_sp_mr_table_empty(vr->mr_table[MLXSW_SP_L3_PROTO_IPV6]))
 948                 mlxsw_sp_vr_destroy(mlxsw_sp, vr);
 949 }
 950
 951 static bool
 952 mlxsw_sp_vr_lpm_tree_should_replace(struct mlxsw_sp_vr *vr,
 953                                     enum mlxsw_sp_l3proto proto, u8 tree_id)
 954 {
 955         struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
 956
 957         if (!mlxsw_sp_vr_is_used(vr))
 958                 return false;
 959         if (fib->lpm_tree->id == tree_id)
 960                 return true;
 961         return false;
 962 }
 963
 964 static int mlxsw_sp_vr_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp,
 965                                         struct mlxsw_sp_fib *fib,
 966                                         struct mlxsw_sp_lpm_tree *new_tree)
 967 {
 968         struct mlxsw_sp_lpm_tree *old_tree = fib->lpm_tree;
 969         int err;
 970
 971         fib->lpm_tree = new_tree;
 972         mlxsw_sp_lpm_tree_hold(new_tree);
 973         err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, new_tree->id);
 974         if (err)
 975                 goto err_tree_bind;
 976         mlxsw_sp_lpm_tree_put(mlxsw_sp, old_tree);
 977         return 0;
 978
 979 err_tree_bind:
 980         mlxsw_sp_lpm_tree_put(mlxsw_sp, new_tree);
 981         fib->lpm_tree = old_tree;
 982         return err;
 983 }
 984
 985 static int mlxsw_sp_vrs_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp,
 986                                          struct mlxsw_sp_fib *fib,
 987                                          struct mlxsw_sp_lpm_tree *new_tree)
 988 {
 989         int max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
 990         enum mlxsw_sp_l3proto proto = fib->proto;
 991         struct mlxsw_sp_lpm_tree *old_tree;
 992         u8 old_id, new_id = new_tree->id;
 993         struct mlxsw_sp_vr *vr;
 994         int i, err;
 995
 996         old_tree = mlxsw_sp->router->lpm.proto_trees[proto];
 997         old_id = old_tree->id;
 998
 999         for (i = 0; i < max_vrs; i++) {
1000                 vr = &mlxsw_sp->router->vrs[i];
1001                 if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, old_id))
1002                         continue;
1003                 err = mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp,
1004                                                    mlxsw_sp_vr_fib(vr, proto),
1005                                                    new_tree);
1006                 if (err)
1007                         goto err_tree_replace;
1008         }
1009
1010         memcpy(new_tree->prefix_ref_count, old_tree->prefix_ref_count,
1011                sizeof(new_tree->prefix_ref_count));
1012         mlxsw_sp->router->lpm.proto_trees[proto] = new_tree;
1013         mlxsw_sp_lpm_tree_put(mlxsw_sp, old_tree);
1014
1015         return 0;
1016
1017 err_tree_replace:
1018         for (i--; i >= 0; i--) {
1019                 if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, new_id))
1020                         continue;
1021                 mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp,
1022                                              mlxsw_sp_vr_fib(vr, proto),
1023                                              old_tree);
1024         }
1025         return err;
1026 }
1027
1028 static int mlxsw_sp_vrs_init(struct mlxsw_sp *mlxsw_sp)
1029 {
1030         struct mlxsw_sp_vr *vr;
1031         u64 max_vrs;
1032         int i;
1033
1034         if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_VRS))
1035                 return -EIO;
1036
1037         max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
1038         mlxsw_sp->router->vrs = kcalloc(max_vrs, sizeof(struct mlxsw_sp_vr),
1039                                         GFP_KERNEL);
1040         if (!mlxsw_sp->router->vrs)
1041                 return -ENOMEM;
1042
1043         for (i = 0; i < max_vrs; i++) {
1044                 vr = &mlxsw_sp->router->vrs[i];
1045                 vr->id = i;
1046         }
1047
1048         return 0;
1049 }
1050
1051 static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp);
1052
1053 static void mlxsw_sp_vrs_fini(struct mlxsw_sp *mlxsw_sp)
1054 {
1055         /* At this stage we're guaranteed not to have new incoming
1056          * FIB notifications and the work queue is free from FIBs
1057          * sitting on top of mlxsw netdevs. However, we can still
1058          * have other FIBs queued. Flush the queue before flushing
1059          * the device's tables. No need for locks, as we're the only
1060          * writer.
1061          */
1062         mlxsw_core_flush_owq();
1063         mlxsw_sp_router_fib_flush(mlxsw_sp);
1064         kfree(mlxsw_sp->router->vrs);
1065 }
1066
1067 u32 mlxsw_sp_ipip_dev_ul_tb_id(const struct net_device *ol_dev)
1068 {
1069         struct net_device *d;
1070         u32 tb_id;
1071
1072         rcu_read_lock();
1073         d = mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev);
1074         if (d)
1075                 tb_id = l3mdev_fib_table(d) ? : RT_TABLE_MAIN;
1076         else
1077                 tb_id = RT_TABLE_MAIN;
1078         rcu_read_unlock();
1079
1080         return tb_id;
1081 }
1082
1083 static void
1084 mlxsw_sp_crif_init(struct mlxsw_sp_crif *crif, struct net_device *dev)
1085 {
1086         crif->key.dev = dev;
1087         INIT_LIST_HEAD(&crif->nexthop_list);
1088 }
1089
1090 static struct mlxsw_sp_crif *
1091 mlxsw_sp_crif_alloc(struct net_device *dev)
1092 {
1093         struct mlxsw_sp_crif *crif;
1094
1095         crif = kzalloc(sizeof(*crif), GFP_KERNEL);
1096         if (!crif)
1097                 return NULL;
1098
1099         mlxsw_sp_crif_init(crif, dev);
1100         return crif;
1101 }
1102
1103 static void mlxsw_sp_crif_free(struct mlxsw_sp_crif *crif)
1104 {
1105         if (WARN_ON(crif->rif))
1106                 return;
1107
1108         WARN_ON(!list_empty(&crif->nexthop_list));
1109         kfree(crif);
1110 }
1111
1112 static int mlxsw_sp_crif_insert(struct mlxsw_sp_router *router,
1113                                 struct mlxsw_sp_crif *crif)
1114 {
1115         return rhashtable_insert_fast(&router->crif_ht, &crif->ht_node,
1116                                       mlxsw_sp_crif_ht_params);
1117 }
1118
1119 static void mlxsw_sp_crif_remove(struct mlxsw_sp_router *router,
1120                                  struct mlxsw_sp_crif *crif)
1121 {
1122         rhashtable_remove_fast(&router->crif_ht, &crif->ht_node,
1123                                mlxsw_sp_crif_ht_params);
1124 }
1125
1126 static struct mlxsw_sp_crif *
1127 mlxsw_sp_crif_lookup(struct mlxsw_sp_router *router,
1128                      const struct net_device *dev)
1129 {
1130         struct mlxsw_sp_crif_key key = {
1131                 .dev = (struct net_device *)dev,
1132         };
1133
1134         return rhashtable_lookup_fast(&router->crif_ht, &key,
1135                                       mlxsw_sp_crif_ht_params);
1136 }
1137
1138 static struct mlxsw_sp_rif *
1139 mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp,
1140                     const struct mlxsw_sp_rif_params *params,
1141                     struct netlink_ext_ack *extack);
1142
1143 static struct mlxsw_sp_rif_ipip_lb *
1144 mlxsw_sp_ipip_ol_ipip_lb_create(struct mlxsw_sp *mlxsw_sp,
1145                                 enum mlxsw_sp_ipip_type ipipt,
1146                                 struct net_device *ol_dev,
1147                                 struct netlink_ext_ack *extack)
1148 {
1149         struct mlxsw_sp_rif_params_ipip_lb lb_params;
1150         const struct mlxsw_sp_ipip_ops *ipip_ops;
1151         struct mlxsw_sp_rif *rif;
1152
1153         ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt];
1154         lb_params = (struct mlxsw_sp_rif_params_ipip_lb) {
1155                 .common.dev = ol_dev,
1156                 .common.lag = false,
1157                 .common.double_entry = ipip_ops->double_rif_entry,
1158                 .lb_config = ipip_ops->ol_loopback_config(mlxsw_sp, ol_dev),
1159         };
1160
1161         rif = mlxsw_sp_rif_create(mlxsw_sp, &lb_params.common, extack);
1162         if (IS_ERR(rif))
1163                 return ERR_CAST(rif);
1164         return container_of(rif, struct mlxsw_sp_rif_ipip_lb, common);
1165 }
1166
1167 static struct mlxsw_sp_ipip_entry *
1168 mlxsw_sp_ipip_entry_alloc(struct mlxsw_sp *mlxsw_sp,
1169                           enum mlxsw_sp_ipip_type ipipt,
1170                           struct net_device *ol_dev)
1171 {
1172         const struct mlxsw_sp_ipip_ops *ipip_ops;
1173         struct mlxsw_sp_ipip_entry *ipip_entry;
1174         struct mlxsw_sp_ipip_entry *ret = NULL;
1175         int err;
1176
1177         ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt];
1178         ipip_entry = kzalloc(sizeof(*ipip_entry), GFP_KERNEL);
1179         if (!ipip_entry)
1180                 return ERR_PTR(-ENOMEM);
1181
1182         ipip_entry->ol_lb = mlxsw_sp_ipip_ol_ipip_lb_create(mlxsw_sp, ipipt,
1183                                                             ol_dev, NULL);
1184         if (IS_ERR(ipip_entry->ol_lb)) {
1185                 ret = ERR_CAST(ipip_entry->ol_lb);
1186                 goto err_ol_ipip_lb_create;
1187         }
1188
1189         ipip_entry->ipipt = ipipt;
1190         ipip_entry->ol_dev = ol_dev;
1191         ipip_entry->parms = ipip_ops->parms_init(ol_dev);
1192
1193         err = ipip_ops->rem_ip_addr_set(mlxsw_sp, ipip_entry);
1194         if (err) {
1195                 ret = ERR_PTR(err);
1196                 goto err_rem_ip_addr_set;
1197         }
1198
1199         return ipip_entry;
1200
1201 err_rem_ip_addr_set:
1202         mlxsw_sp_rif_destroy(&ipip_entry->ol_lb->common);
1203 err_ol_ipip_lb_create:
1204         kfree(ipip_entry);
1205         return ret;
1206 }
1207
1208 static void mlxsw_sp_ipip_entry_dealloc(struct mlxsw_sp *mlxsw_sp,
1209                                         struct mlxsw_sp_ipip_entry *ipip_entry)
1210 {
1211         const struct mlxsw_sp_ipip_ops *ipip_ops =
1212                 mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
1213
1214         ipip_ops->rem_ip_addr_unset(mlxsw_sp, ipip_entry);
1215         mlxsw_sp_rif_destroy(&ipip_entry->ol_lb->common);
1216         kfree(ipip_entry);
1217 }
1218
1219 static bool
1220 mlxsw_sp_ipip_entry_saddr_matches(struct mlxsw_sp *mlxsw_sp,
1221                                   const enum mlxsw_sp_l3proto ul_proto,
1222                                   union mlxsw_sp_l3addr saddr,
1223                                   u32 ul_tb_id,
1224                                   struct mlxsw_sp_ipip_entry *ipip_entry)
1225 {
1226         u32 tun_ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev);
1227         enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt;
1228         union mlxsw_sp_l3addr tun_saddr;
1229
1230         if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto)
1231                 return false;
1232
1233         tun_saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ipip_entry->ol_dev);
1234         return tun_ul_tb_id == ul_tb_id &&
1235                mlxsw_sp_l3addr_eq(&tun_saddr, &saddr);
1236 }
1237
1238 static int mlxsw_sp_ipip_decap_parsing_depth_inc(struct mlxsw_sp *mlxsw_sp,
1239                                                  enum mlxsw_sp_ipip_type ipipt)
1240 {
1241         const struct mlxsw_sp_ipip_ops *ipip_ops;
1242
1243         ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt];
1244
1245         /* Not all tunnels require to increase the default pasing depth
1246          * (96 bytes).
1247          */
1248         if (ipip_ops->inc_parsing_depth)
1249                 return mlxsw_sp_parsing_depth_inc(mlxsw_sp);
1250
1251         return 0;
1252 }
1253
1254 static void mlxsw_sp_ipip_decap_parsing_depth_dec(struct mlxsw_sp *mlxsw_sp,
1255                                                   enum mlxsw_sp_ipip_type ipipt)
1256 {
1257         const struct mlxsw_sp_ipip_ops *ipip_ops =
1258                 mlxsw_sp->router->ipip_ops_arr[ipipt];
1259
1260         if (ipip_ops->inc_parsing_depth)
1261                 mlxsw_sp_parsing_depth_dec(mlxsw_sp);
1262 }
1263
1264 static int
1265 mlxsw_sp_fib_entry_decap_init(struct mlxsw_sp *mlxsw_sp,
1266                               struct mlxsw_sp_fib_entry *fib_entry,
1267                               struct mlxsw_sp_ipip_entry *ipip_entry)
1268 {
1269         u32 tunnel_index;
1270         int err;
1271
1272         err = mlxsw_sp_kvdl_alloc(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
1273                                   1, &tunnel_index);
1274         if (err)
1275                 return err;
1276
1277         err = mlxsw_sp_ipip_decap_parsing_depth_inc(mlxsw_sp,
1278                                                     ipip_entry->ipipt);
1279         if (err)
1280                 goto err_parsing_depth_inc;
1281
1282         ipip_entry->decap_fib_entry = fib_entry;
1283         fib_entry->decap.ipip_entry = ipip_entry;
1284         fib_entry->decap.tunnel_index = tunnel_index;
1285
1286         return 0;
1287
1288 err_parsing_depth_inc:
1289         mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
1290                            fib_entry->decap.tunnel_index);
1291         return err;
1292 }
1293
1294 static void mlxsw_sp_fib_entry_decap_fini(struct mlxsw_sp *mlxsw_sp,
1295                                           struct mlxsw_sp_fib_entry *fib_entry)
1296 {
1297         enum mlxsw_sp_ipip_type ipipt = fib_entry->decap.ipip_entry->ipipt;
1298
1299         /* Unlink this node from the IPIP entry that it's the decap entry of. */
1300         fib_entry->decap.ipip_entry->decap_fib_entry = NULL;
1301         fib_entry->decap.ipip_entry = NULL;
1302         mlxsw_sp_ipip_decap_parsing_depth_dec(mlxsw_sp, ipipt);
1303         mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
1304                            1, fib_entry->decap.tunnel_index);
1305 }
1306
1307 static struct mlxsw_sp_fib_node *
1308 mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
1309                          size_t addr_len, unsigned char prefix_len);
1310 static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
1311                                      struct mlxsw_sp_fib_entry *fib_entry);
1312
1313 static void
1314 mlxsw_sp_ipip_entry_demote_decap(struct mlxsw_sp *mlxsw_sp,
1315                                  struct mlxsw_sp_ipip_entry *ipip_entry)
1316 {
1317         struct mlxsw_sp_fib_entry *fib_entry = ipip_entry->decap_fib_entry;
1318
1319         mlxsw_sp_fib_entry_decap_fini(mlxsw_sp, fib_entry);
1320         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
1321
1322         mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
1323 }
1324
1325 static void
1326 mlxsw_sp_ipip_entry_promote_decap(struct mlxsw_sp *mlxsw_sp,
1327                                   struct mlxsw_sp_ipip_entry *ipip_entry,
1328                                   struct mlxsw_sp_fib_entry *decap_fib_entry)
1329 {
1330         if (mlxsw_sp_fib_entry_decap_init(mlxsw_sp, decap_fib_entry,
1331                                           ipip_entry))
1332                 return;
1333         decap_fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
1334
1335         if (mlxsw_sp_fib_entry_update(mlxsw_sp, decap_fib_entry))
1336                 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1337 }
1338
1339 static struct mlxsw_sp_fib_entry *
1340 mlxsw_sp_router_ip2me_fib_entry_find(struct mlxsw_sp *mlxsw_sp, u32 tb_id,
1341                                      enum mlxsw_sp_l3proto proto,
1342                                      const union mlxsw_sp_l3addr *addr,
1343                                      enum mlxsw_sp_fib_entry_type type)
1344 {
1345         struct mlxsw_sp_fib_node *fib_node;
1346         unsigned char addr_prefix_len;
1347         struct mlxsw_sp_fib *fib;
1348         struct mlxsw_sp_vr *vr;
1349         const void *addrp;
1350         size_t addr_len;
1351         u32 addr4;
1352
1353         vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id);
1354         if (!vr)
1355                 return NULL;
1356         fib = mlxsw_sp_vr_fib(vr, proto);
1357
1358         switch (proto) {
1359         case MLXSW_SP_L3_PROTO_IPV4:
1360                 addr4 = be32_to_cpu(addr->addr4);
1361                 addrp = &addr4;
1362                 addr_len = 4;
1363                 addr_prefix_len = 32;
1364                 break;
1365         case MLXSW_SP_L3_PROTO_IPV6:
1366                 addrp = &addr->addr6;
1367                 addr_len = 16;
1368                 addr_prefix_len = 128;
1369                 break;
1370         default:
1371                 WARN_ON(1);
1372                 return NULL;
1373         }
1374
1375         fib_node = mlxsw_sp_fib_node_lookup(fib, addrp, addr_len,
1376                                             addr_prefix_len);
1377         if (!fib_node || fib_node->fib_entry->type != type)
1378                 return NULL;
1379
1380         return fib_node->fib_entry;
1381 }
1382
1383 /* Given an IPIP entry, find the corresponding decap route. */
1384 static struct mlxsw_sp_fib_entry *
1385 mlxsw_sp_ipip_entry_find_decap(struct mlxsw_sp *mlxsw_sp,
1386                                struct mlxsw_sp_ipip_entry *ipip_entry)
1387 {
1388         static struct mlxsw_sp_fib_node *fib_node;
1389         const struct mlxsw_sp_ipip_ops *ipip_ops;
1390         unsigned char saddr_prefix_len;
1391         union mlxsw_sp_l3addr saddr;
1392         struct mlxsw_sp_fib *ul_fib;
1393         struct mlxsw_sp_vr *ul_vr;
1394         const void *saddrp;
1395         size_t saddr_len;
1396         u32 ul_tb_id;
1397         u32 saddr4;
1398
1399         ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
1400
1401         ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev);
1402         ul_vr = mlxsw_sp_vr_find(mlxsw_sp, ul_tb_id);
1403         if (!ul_vr)
1404                 return NULL;
1405
1406         ul_fib = mlxsw_sp_vr_fib(ul_vr, ipip_ops->ul_proto);
1407         saddr = mlxsw_sp_ipip_netdev_saddr(ipip_ops->ul_proto,
1408                                            ipip_entry->ol_dev);
1409
1410         switch (ipip_ops->ul_proto) {
1411         case MLXSW_SP_L3_PROTO_IPV4:
1412                 saddr4 = be32_to_cpu(saddr.addr4);
1413                 saddrp = &saddr4;
1414                 saddr_len = 4;
1415                 saddr_prefix_len = 32;
1416                 break;
1417         case MLXSW_SP_L3_PROTO_IPV6:
1418                 saddrp = &saddr.addr6;
1419                 saddr_len = 16;
1420                 saddr_prefix_len = 128;
1421                 break;
1422         default:
1423                 WARN_ON(1);
1424                 return NULL;
1425         }
1426
1427         fib_node = mlxsw_sp_fib_node_lookup(ul_fib, saddrp, saddr_len,
1428                                             saddr_prefix_len);
1429         if (!fib_node ||
1430             fib_node->fib_entry->type != MLXSW_SP_FIB_ENTRY_TYPE_TRAP)
1431                 return NULL;
1432
1433         return fib_node->fib_entry;
1434 }
1435
1436 static struct mlxsw_sp_ipip_entry *
1437 mlxsw_sp_ipip_entry_create(struct mlxsw_sp *mlxsw_sp,
1438                            enum mlxsw_sp_ipip_type ipipt,
1439                            struct net_device *ol_dev)
1440 {
1441         struct mlxsw_sp_ipip_entry *ipip_entry;
1442
1443         ipip_entry = mlxsw_sp_ipip_entry_alloc(mlxsw_sp, ipipt, ol_dev);
1444         if (IS_ERR(ipip_entry))
1445                 return ipip_entry;
1446
1447         list_add_tail(&ipip_entry->ipip_list_node,
1448                       &mlxsw_sp->router->ipip_list);
1449
1450         return ipip_entry;
1451 }
1452
1453 static void
1454 mlxsw_sp_ipip_entry_destroy(struct mlxsw_sp *mlxsw_sp,
1455                             struct mlxsw_sp_ipip_entry *ipip_entry)
1456 {
1457         list_del(&ipip_entry->ipip_list_node);
1458         mlxsw_sp_ipip_entry_dealloc(mlxsw_sp, ipip_entry);
1459 }
1460
1461 static bool
1462 mlxsw_sp_ipip_entry_matches_decap(struct mlxsw_sp *mlxsw_sp,
1463                                   const struct net_device *ul_dev,
1464                                   enum mlxsw_sp_l3proto ul_proto,
1465                                   union mlxsw_sp_l3addr ul_dip,
1466                                   struct mlxsw_sp_ipip_entry *ipip_entry)
1467 {
1468         u32 ul_tb_id = l3mdev_fib_table(ul_dev) ? : RT_TABLE_MAIN;
1469         enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt;
1470
1471         if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto)
1472                 return false;
1473
1474         return mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, ul_dip,
1475                                                  ul_tb_id, ipip_entry);
1476 }
1477
1478 /* Given decap parameters, find the corresponding IPIP entry. */
1479 static struct mlxsw_sp_ipip_entry *
1480 mlxsw_sp_ipip_entry_find_by_decap(struct mlxsw_sp *mlxsw_sp, int ul_dev_ifindex,
1481                                   enum mlxsw_sp_l3proto ul_proto,
1482                                   union mlxsw_sp_l3addr ul_dip)
1483 {
1484         struct mlxsw_sp_ipip_entry *ipip_entry = NULL;
1485         struct net_device *ul_dev;
1486
1487         rcu_read_lock();
1488
1489         ul_dev = dev_get_by_index_rcu(mlxsw_sp_net(mlxsw_sp), ul_dev_ifindex);
1490         if (!ul_dev)
1491                 goto out_unlock;
1492
1493         list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list,
1494                             ipip_list_node)
1495                 if (mlxsw_sp_ipip_entry_matches_decap(mlxsw_sp, ul_dev,
1496                                                       ul_proto, ul_dip,
1497                                                       ipip_entry))
1498                         goto out_unlock;
1499
1500         rcu_read_unlock();
1501
1502         return NULL;
1503
1504 out_unlock:
1505         rcu_read_unlock();
1506         return ipip_entry;
1507 }
1508
1509 static bool mlxsw_sp_netdev_ipip_type(const struct mlxsw_sp *mlxsw_sp,
1510                                       const struct net_device *dev,
1511                                       enum mlxsw_sp_ipip_type *p_type)
1512 {
1513         struct mlxsw_sp_router *router = mlxsw_sp->router;
1514         const struct mlxsw_sp_ipip_ops *ipip_ops;
1515         enum mlxsw_sp_ipip_type ipipt;
1516
1517         for (ipipt = 0; ipipt < MLXSW_SP_IPIP_TYPE_MAX; ++ipipt) {
1518                 ipip_ops = router->ipip_ops_arr[ipipt];
1519                 if (dev->type == ipip_ops->dev_type) {
1520                         if (p_type)
1521                                 *p_type = ipipt;
1522                         return true;
1523                 }
1524         }
1525         return false;
1526 }
1527
1528 static bool mlxsw_sp_netdev_is_ipip_ol(const struct mlxsw_sp *mlxsw_sp,
1529                                        const struct net_device *dev)
1530 {
1531         return mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, NULL);
1532 }
1533
1534 static struct mlxsw_sp_ipip_entry *
1535 mlxsw_sp_ipip_entry_find_by_ol_dev(struct mlxsw_sp *mlxsw_sp,
1536                                    const struct net_device *ol_dev)
1537 {
1538         struct mlxsw_sp_ipip_entry *ipip_entry;
1539
1540         list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list,
1541                             ipip_list_node)
1542                 if (ipip_entry->ol_dev == ol_dev)
1543                         return ipip_entry;
1544
1545         return NULL;
1546 }
1547
1548 static struct mlxsw_sp_ipip_entry *
1549 mlxsw_sp_ipip_entry_find_by_ul_dev(const struct mlxsw_sp *mlxsw_sp,
1550                                    const struct net_device *ul_dev,
1551                                    struct mlxsw_sp_ipip_entry *start)
1552 {
1553         struct mlxsw_sp_ipip_entry *ipip_entry;
1554
1555         ipip_entry = list_prepare_entry(start, &mlxsw_sp->router->ipip_list,
1556                                         ipip_list_node);
1557         list_for_each_entry_continue(ipip_entry, &mlxsw_sp->router->ipip_list,
1558                                      ipip_list_node) {
1559                 struct net_device *ol_dev = ipip_entry->ol_dev;
1560                 struct net_device *ipip_ul_dev;
1561
1562                 rcu_read_lock();
1563                 ipip_ul_dev = mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev);
1564                 rcu_read_unlock();
1565
1566                 if (ipip_ul_dev == ul_dev)
1567                         return ipip_entry;
1568         }
1569
1570         return NULL;
1571 }
1572
1573 static bool mlxsw_sp_netdev_is_ipip_ul(struct mlxsw_sp *mlxsw_sp,
1574                                        const struct net_device *dev)
1575 {
1576         return mlxsw_sp_ipip_entry_find_by_ul_dev(mlxsw_sp, dev, NULL);
1577 }
1578
1579 static bool mlxsw_sp_netdevice_ipip_can_offload(struct mlxsw_sp *mlxsw_sp,
1580                                                 const struct net_device *ol_dev,
1581                                                 enum mlxsw_sp_ipip_type ipipt)
1582 {
1583         const struct mlxsw_sp_ipip_ops *ops
1584                 = mlxsw_sp->router->ipip_ops_arr[ipipt];
1585
1586         return ops->can_offload(mlxsw_sp, ol_dev);
1587 }
1588
1589 static int mlxsw_sp_netdevice_ipip_ol_reg_event(struct mlxsw_sp *mlxsw_sp,
1590                                                 struct net_device *ol_dev)
1591 {
1592         enum mlxsw_sp_ipip_type ipipt = MLXSW_SP_IPIP_TYPE_MAX;
1593         struct mlxsw_sp_ipip_entry *ipip_entry;
1594         enum mlxsw_sp_l3proto ul_proto;
1595         union mlxsw_sp_l3addr saddr;
1596         u32 ul_tb_id;
1597
1598         mlxsw_sp_netdev_ipip_type(mlxsw_sp, ol_dev, &ipipt);
1599         if (mlxsw_sp_netdevice_ipip_can_offload(mlxsw_sp, ol_dev, ipipt)) {
1600                 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ol_dev);
1601                 ul_proto = mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto;
1602                 saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ol_dev);
1603                 if (!mlxsw_sp_ipip_demote_tunnel_by_saddr(mlxsw_sp, ul_proto,
1604                                                           saddr, ul_tb_id,
1605                                                           NULL)) {
1606                         ipip_entry = mlxsw_sp_ipip_entry_create(mlxsw_sp, ipipt,
1607                                                                 ol_dev);
1608                         if (IS_ERR(ipip_entry))
1609                                 return PTR_ERR(ipip_entry);
1610                 }
1611         }
1612
1613         return 0;
1614 }
1615
1616 static void mlxsw_sp_netdevice_ipip_ol_unreg_event(struct mlxsw_sp *mlxsw_sp,
1617                                                    struct net_device *ol_dev)
1618 {
1619         struct mlxsw_sp_ipip_entry *ipip_entry;
1620
1621         ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1622         if (ipip_entry)
1623                 mlxsw_sp_ipip_entry_destroy(mlxsw_sp, ipip_entry);
1624 }
1625
1626 static void
1627 mlxsw_sp_ipip_entry_ol_up_event(struct mlxsw_sp *mlxsw_sp,
1628                                 struct mlxsw_sp_ipip_entry *ipip_entry)
1629 {
1630         struct mlxsw_sp_fib_entry *decap_fib_entry;
1631
1632         decap_fib_entry = mlxsw_sp_ipip_entry_find_decap(mlxsw_sp, ipip_entry);
1633         if (decap_fib_entry)
1634                 mlxsw_sp_ipip_entry_promote_decap(mlxsw_sp, ipip_entry,
1635                                                   decap_fib_entry);
1636 }
1637
1638 static int
1639 mlxsw_sp_rif_ipip_lb_op(struct mlxsw_sp_rif_ipip_lb *lb_rif, u16 ul_vr_id,
1640                         u16 ul_rif_id, bool enable)
1641 {
1642         struct mlxsw_sp_rif_ipip_lb_config lb_cf = lb_rif->lb_config;
1643         struct net_device *dev = mlxsw_sp_rif_dev(&lb_rif->common);
1644         enum mlxsw_reg_ritr_loopback_ipip_options ipip_options;
1645         struct mlxsw_sp_rif *rif = &lb_rif->common;
1646         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
1647         char ritr_pl[MLXSW_REG_RITR_LEN];
1648         struct in6_addr *saddr6;
1649         u32 saddr4;
1650
1651         ipip_options = MLXSW_REG_RITR_LOOPBACK_IPIP_OPTIONS_GRE_KEY_PRESET;
1652         switch (lb_cf.ul_protocol) {
1653         case MLXSW_SP_L3_PROTO_IPV4:
1654                 saddr4 = be32_to_cpu(lb_cf.saddr.addr4);
1655                 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_LOOPBACK_IF,
1656                                     rif->rif_index, rif->vr_id, dev->mtu);
1657                 mlxsw_reg_ritr_loopback_ipip4_pack(ritr_pl, lb_cf.lb_ipipt,
1658                                                    ipip_options, ul_vr_id,
1659                                                    ul_rif_id, saddr4,
1660                                                    lb_cf.okey);
1661                 break;
1662
1663         case MLXSW_SP_L3_PROTO_IPV6:
1664                 saddr6 = &lb_cf.saddr.addr6;
1665                 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_LOOPBACK_IF,
1666                                     rif->rif_index, rif->vr_id, dev->mtu);
1667                 mlxsw_reg_ritr_loopback_ipip6_pack(ritr_pl, lb_cf.lb_ipipt,
1668                                                    ipip_options, ul_vr_id,
1669                                                    ul_rif_id, saddr6,
1670                                                    lb_cf.okey);
1671                 break;
1672         }
1673
1674         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
1675 }
1676
1677 static int mlxsw_sp_netdevice_ipip_ol_update_mtu(struct mlxsw_sp *mlxsw_sp,
1678                                                  struct net_device *ol_dev)
1679 {
1680         struct mlxsw_sp_ipip_entry *ipip_entry;
1681         struct mlxsw_sp_rif_ipip_lb *lb_rif;
1682         int err = 0;
1683
1684         ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1685         if (ipip_entry) {
1686                 lb_rif = ipip_entry->ol_lb;
1687                 err = mlxsw_sp_rif_ipip_lb_op(lb_rif, lb_rif->ul_vr_id,
1688                                               lb_rif->ul_rif_id, true);
1689                 if (err)
1690                         goto out;
1691                 lb_rif->common.mtu = ol_dev->mtu;
1692         }
1693
1694 out:
1695         return err;
1696 }
1697
1698 static void mlxsw_sp_netdevice_ipip_ol_up_event(struct mlxsw_sp *mlxsw_sp,
1699                                                 struct net_device *ol_dev)
1700 {
1701         struct mlxsw_sp_ipip_entry *ipip_entry;
1702
1703         ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1704         if (ipip_entry)
1705                 mlxsw_sp_ipip_entry_ol_up_event(mlxsw_sp, ipip_entry);
1706 }
1707
1708 static void
1709 mlxsw_sp_ipip_entry_ol_down_event(struct mlxsw_sp *mlxsw_sp,
1710                                   struct mlxsw_sp_ipip_entry *ipip_entry)
1711 {
1712         if (ipip_entry->decap_fib_entry)
1713                 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1714 }
1715
1716 static void mlxsw_sp_netdevice_ipip_ol_down_event(struct mlxsw_sp *mlxsw_sp,
1717                                                   struct net_device *ol_dev)
1718 {
1719         struct mlxsw_sp_ipip_entry *ipip_entry;
1720
1721         ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1722         if (ipip_entry)
1723                 mlxsw_sp_ipip_entry_ol_down_event(mlxsw_sp, ipip_entry);
1724 }
1725
1726 static void mlxsw_sp_nexthop_rif_update(struct mlxsw_sp *mlxsw_sp,
1727                                         struct mlxsw_sp_rif *rif);
1728
1729 static void mlxsw_sp_rif_migrate_destroy(struct mlxsw_sp *mlxsw_sp,
1730                                          struct mlxsw_sp_rif *old_rif,
1731                                          struct mlxsw_sp_rif *new_rif,
1732                                          bool migrate_nhs)
1733 {
1734         struct mlxsw_sp_crif *crif = old_rif->crif;
1735         struct mlxsw_sp_crif mock_crif = {};
1736
1737         if (migrate_nhs)
1738                 mlxsw_sp_nexthop_rif_update(mlxsw_sp, new_rif);
1739
1740         /* Plant a mock CRIF so that destroying the old RIF doesn't unoffload
1741          * our nexthops and IPIP tunnels, and doesn't sever the crif->rif link.
1742          */
1743         mlxsw_sp_crif_init(&mock_crif, crif->key.dev);
1744         old_rif->crif = &mock_crif;
1745         mock_crif.rif = old_rif;
1746         mlxsw_sp_rif_destroy(old_rif);
1747 }
1748
1749 static int
1750 mlxsw_sp_ipip_entry_ol_lb_update(struct mlxsw_sp *mlxsw_sp,
1751                                  struct mlxsw_sp_ipip_entry *ipip_entry,
1752                                  bool keep_encap,
1753                                  struct netlink_ext_ack *extack)
1754 {
1755         struct mlxsw_sp_rif_ipip_lb *old_lb_rif = ipip_entry->ol_lb;
1756         struct mlxsw_sp_rif_ipip_lb *new_lb_rif;
1757
1758         new_lb_rif = mlxsw_sp_ipip_ol_ipip_lb_create(mlxsw_sp,
1759                                                      ipip_entry->ipipt,
1760                                                      ipip_entry->ol_dev,
1761                                                      extack);
1762         if (IS_ERR(new_lb_rif))
1763                 return PTR_ERR(new_lb_rif);
1764         ipip_entry->ol_lb = new_lb_rif;
1765
1766         mlxsw_sp_rif_migrate_destroy(mlxsw_sp, &old_lb_rif->common,
1767                                      &new_lb_rif->common, keep_encap);
1768         return 0;
1769 }
1770
1771 /**
1772  * __mlxsw_sp_ipip_entry_update_tunnel - Update offload related to IPIP entry.
1773  * @mlxsw_sp: mlxsw_sp.
1774  * @ipip_entry: IPIP entry.
1775  * @recreate_loopback: Recreates the associated loopback RIF.
1776  * @keep_encap: Updates next hops that use the tunnel netdevice. This is only
1777  *              relevant when recreate_loopback is true.
1778  * @update_nexthops: Updates next hops, keeping the current loopback RIF. This
1779  *                   is only relevant when recreate_loopback is false.
1780  * @extack: extack.
1781  *
1782  * Return: Non-zero value on failure.
1783  */
1784 int __mlxsw_sp_ipip_entry_update_tunnel(struct mlxsw_sp *mlxsw_sp,
1785                                         struct mlxsw_sp_ipip_entry *ipip_entry,
1786                                         bool recreate_loopback,
1787                                         bool keep_encap,
1788                                         bool update_nexthops,
1789                                         struct netlink_ext_ack *extack)
1790 {
1791         int err;
1792
1793         /* RIFs can't be edited, so to update loopback, we need to destroy and
1794          * recreate it. That creates a window of opportunity where RALUE and
1795          * RATR registers end up referencing a RIF that's already gone. RATRs
1796          * are handled in mlxsw_sp_ipip_entry_ol_lb_update(), and to take care
1797          * of RALUE, demote the decap route back.
1798          */
1799         if (ipip_entry->decap_fib_entry)
1800                 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1801
1802         if (recreate_loopback) {
1803                 err = mlxsw_sp_ipip_entry_ol_lb_update(mlxsw_sp, ipip_entry,
1804                                                        keep_encap, extack);
1805                 if (err)
1806                         return err;
1807         } else if (update_nexthops) {
1808                 mlxsw_sp_nexthop_rif_update(mlxsw_sp,
1809                                             &ipip_entry->ol_lb->common);
1810         }
1811
1812         if (ipip_entry->ol_dev->flags & IFF_UP)
1813                 mlxsw_sp_ipip_entry_ol_up_event(mlxsw_sp, ipip_entry);
1814
1815         return 0;
1816 }
1817
1818 static int mlxsw_sp_netdevice_ipip_ol_vrf_event(struct mlxsw_sp *mlxsw_sp,
1819                                                 struct net_device *ol_dev,
1820                                                 struct netlink_ext_ack *extack)
1821 {
1822         struct mlxsw_sp_ipip_entry *ipip_entry =
1823                 mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1824
1825         if (!ipip_entry)
1826                 return 0;
1827
1828         return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry,
1829                                                    true, false, false, extack);
1830 }
1831
1832 static int
1833 mlxsw_sp_netdevice_ipip_ul_vrf_event(struct mlxsw_sp *mlxsw_sp,
1834                                      struct mlxsw_sp_ipip_entry *ipip_entry,
1835                                      struct net_device *ul_dev,
1836                                      bool *demote_this,
1837                                      struct netlink_ext_ack *extack)
1838 {
1839         u32 ul_tb_id = l3mdev_fib_table(ul_dev) ? : RT_TABLE_MAIN;
1840         enum mlxsw_sp_l3proto ul_proto;
1841         union mlxsw_sp_l3addr saddr;
1842
1843         /* Moving underlay to a different VRF might cause local address
1844          * conflict, and the conflicting tunnels need to be demoted.
1845          */
1846         ul_proto = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt]->ul_proto;
1847         saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ipip_entry->ol_dev);
1848         if (mlxsw_sp_ipip_demote_tunnel_by_saddr(mlxsw_sp, ul_proto,
1849                                                  saddr, ul_tb_id,
1850                                                  ipip_entry)) {
1851                 *demote_this = true;
1852                 return 0;
1853         }
1854
1855         return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry,
1856                                                    true, true, false, extack);
1857 }
1858
1859 static int
1860 mlxsw_sp_netdevice_ipip_ul_up_event(struct mlxsw_sp *mlxsw_sp,
1861                                     struct mlxsw_sp_ipip_entry *ipip_entry,
1862                                     struct net_device *ul_dev)
1863 {
1864         return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry,
1865                                                    false, false, true, NULL);
1866 }
1867
1868 static int
1869 mlxsw_sp_netdevice_ipip_ul_down_event(struct mlxsw_sp *mlxsw_sp,
1870                                       struct mlxsw_sp_ipip_entry *ipip_entry,
1871                                       struct net_device *ul_dev)
1872 {
1873         /* A down underlay device causes encapsulated packets to not be
1874          * forwarded, but decap still works. So refresh next hops without
1875          * touching anything else.
1876          */
1877         return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry,
1878                                                    false, false, true, NULL);
1879 }
1880
1881 static int
1882 mlxsw_sp_netdevice_ipip_ol_change_event(struct mlxsw_sp *mlxsw_sp,
1883                                         struct net_device *ol_dev,
1884                                         struct netlink_ext_ack *extack)
1885 {
1886         const struct mlxsw_sp_ipip_ops *ipip_ops;
1887         struct mlxsw_sp_ipip_entry *ipip_entry;
1888         int err;
1889
1890         ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1891         if (!ipip_entry)
1892                 /* A change might make a tunnel eligible for offloading, but
1893                  * that is currently not implemented. What falls to slow path
1894                  * stays there.
1895                  */
1896                 return 0;
1897
1898         /* A change might make a tunnel not eligible for offloading. */
1899         if (!mlxsw_sp_netdevice_ipip_can_offload(mlxsw_sp, ol_dev,
1900                                                  ipip_entry->ipipt)) {
1901                 mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry);
1902                 return 0;
1903         }
1904
1905         ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
1906         err = ipip_ops->ol_netdev_change(mlxsw_sp, ipip_entry, extack);
1907         return err;
1908 }
1909
1910 void mlxsw_sp_ipip_entry_demote_tunnel(struct mlxsw_sp *mlxsw_sp,
1911                                        struct mlxsw_sp_ipip_entry *ipip_entry)
1912 {
1913         struct net_device *ol_dev = ipip_entry->ol_dev;
1914
1915         if (ol_dev->flags & IFF_UP)
1916                 mlxsw_sp_ipip_entry_ol_down_event(mlxsw_sp, ipip_entry);
1917         mlxsw_sp_ipip_entry_destroy(mlxsw_sp, ipip_entry);
1918 }
1919
1920 /* The configuration where several tunnels have the same local address in the
1921  * same underlay table needs special treatment in the HW. That is currently not
1922  * implemented in the driver. This function finds and demotes the first tunnel
1923  * with a given source address, except the one passed in the argument
1924  * `except'.
1925  */
1926 bool
1927 mlxsw_sp_ipip_demote_tunnel_by_saddr(struct mlxsw_sp *mlxsw_sp,
1928                                      enum mlxsw_sp_l3proto ul_proto,
1929                                      union mlxsw_sp_l3addr saddr,
1930                                      u32 ul_tb_id,
1931                                      const struct mlxsw_sp_ipip_entry *except)
1932 {
1933         struct mlxsw_sp_ipip_entry *ipip_entry, *tmp;
1934
1935         list_for_each_entry_safe(ipip_entry, tmp, &mlxsw_sp->router->ipip_list,
1936                                  ipip_list_node) {
1937                 if (ipip_entry != except &&
1938                     mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, saddr,
1939                                                       ul_tb_id, ipip_entry)) {
1940                         mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry);
1941                         return true;
1942                 }
1943         }
1944
1945         return false;
1946 }
1947
1948 static void mlxsw_sp_ipip_demote_tunnel_by_ul_netdev(struct mlxsw_sp *mlxsw_sp,
1949                                                      struct net_device *ul_dev)
1950 {
1951         struct mlxsw_sp_ipip_entry *ipip_entry, *tmp;
1952
1953         list_for_each_entry_safe(ipip_entry, tmp, &mlxsw_sp->router->ipip_list,
1954                                  ipip_list_node) {
1955                 struct net_device *ol_dev = ipip_entry->ol_dev;
1956                 struct net_device *ipip_ul_dev;
1957
1958                 rcu_read_lock();
1959                 ipip_ul_dev = mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev);
1960                 rcu_read_unlock();
1961                 if (ipip_ul_dev == ul_dev)
1962                         mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry);
1963         }
1964 }
1965
1966 static int mlxsw_sp_netdevice_ipip_ol_event(struct mlxsw_sp *mlxsw_sp,
1967                                             struct net_device *ol_dev,
1968                                             unsigned long event,
1969                                             struct netdev_notifier_info *info)
1970 {
1971         struct netdev_notifier_changeupper_info *chup;
1972         struct netlink_ext_ack *extack;
1973         int err = 0;
1974
1975         switch (event) {
1976         case NETDEV_REGISTER:
1977                 err = mlxsw_sp_netdevice_ipip_ol_reg_event(mlxsw_sp, ol_dev);
1978                 break;
1979         case NETDEV_UNREGISTER:
1980                 mlxsw_sp_netdevice_ipip_ol_unreg_event(mlxsw_sp, ol_dev);
1981                 break;
1982         case NETDEV_UP:
1983                 mlxsw_sp_netdevice_ipip_ol_up_event(mlxsw_sp, ol_dev);
1984                 break;
1985         case NETDEV_DOWN:
1986                 mlxsw_sp_netdevice_ipip_ol_down_event(mlxsw_sp, ol_dev);
1987                 break;
1988         case NETDEV_CHANGEUPPER:
1989                 chup = container_of(info, typeof(*chup), info);
1990                 extack = info->extack;
1991                 if (netif_is_l3_master(chup->upper_dev))
1992                         err = mlxsw_sp_netdevice_ipip_ol_vrf_event(mlxsw_sp,
1993                                                                    ol_dev,
1994                                                                    extack);
1995                 break;
1996         case NETDEV_CHANGE:
1997                 extack = info->extack;
1998                 err = mlxsw_sp_netdevice_ipip_ol_change_event(mlxsw_sp,
1999                                                               ol_dev, extack);
2000                 break;
2001         case NETDEV_CHANGEMTU:
2002                 err = mlxsw_sp_netdevice_ipip_ol_update_mtu(mlxsw_sp, ol_dev);
2003                 break;
2004         }
2005         return err;
2006 }
2007
2008 static int
2009 __mlxsw_sp_netdevice_ipip_ul_event(struct mlxsw_sp *mlxsw_sp,
2010                                    struct mlxsw_sp_ipip_entry *ipip_entry,
2011                                    struct net_device *ul_dev,
2012                                    bool *demote_this,
2013                                    unsigned long event,
2014                                    struct netdev_notifier_info *info)
2015 {
2016         struct netdev_notifier_changeupper_info *chup;
2017         struct netlink_ext_ack *extack;
2018
2019         switch (event) {
2020         case NETDEV_CHANGEUPPER:
2021                 chup = container_of(info, typeof(*chup), info);
2022                 extack = info->extack;
2023                 if (netif_is_l3_master(chup->upper_dev))
2024                         return mlxsw_sp_netdevice_ipip_ul_vrf_event(mlxsw_sp,
2025                                                                     ipip_entry,
2026                                                                     ul_dev,
2027                                                                     demote_this,
2028                                                                     extack);
2029                 break;
2030
2031         case NETDEV_UP:
2032                 return mlxsw_sp_netdevice_ipip_ul_up_event(mlxsw_sp, ipip_entry,
2033                                                            ul_dev);
2034         case NETDEV_DOWN:
2035                 return mlxsw_sp_netdevice_ipip_ul_down_event(mlxsw_sp,
2036                                                              ipip_entry,
2037                                                              ul_dev);
2038         }
2039         return 0;
2040 }
2041
2042 static int
2043 mlxsw_sp_netdevice_ipip_ul_event(struct mlxsw_sp *mlxsw_sp,
2044                                  struct net_device *ul_dev,
2045                                  unsigned long event,
2046                                  struct netdev_notifier_info *info)
2047 {
2048         struct mlxsw_sp_ipip_entry *ipip_entry = NULL;
2049         int err;
2050
2051         while ((ipip_entry = mlxsw_sp_ipip_entry_find_by_ul_dev(mlxsw_sp,
2052                                                                 ul_dev,
2053                                                                 ipip_entry))) {
2054                 struct mlxsw_sp_ipip_entry *prev;
2055                 bool demote_this = false;
2056
2057                 err = __mlxsw_sp_netdevice_ipip_ul_event(mlxsw_sp, ipip_entry,
2058                                                          ul_dev, &demote_this,
2059                                                          event, info);
2060                 if (err) {
2061                         mlxsw_sp_ipip_demote_tunnel_by_ul_netdev(mlxsw_sp,
2062                                                                  ul_dev);
2063                         return err;
2064                 }
2065
2066                 if (demote_this) {
2067                         if (list_is_first(&ipip_entry->ipip_list_node,
2068                                           &mlxsw_sp->router->ipip_list))
2069                                 prev = NULL;
2070                         else
2071                                 /* This can't be cached from previous iteration,
2072                                  * because that entry could be gone now.
2073                                  */
2074                                 prev = list_prev_entry(ipip_entry,
2075                                                        ipip_list_node);
2076                         mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry);
2077                         ipip_entry = prev;
2078                 }
2079         }
2080
2081         return 0;
2082 }
2083
2084 int mlxsw_sp_router_nve_promote_decap(struct mlxsw_sp *mlxsw_sp, u32 ul_tb_id,
2085                                       enum mlxsw_sp_l3proto ul_proto,
2086                                       const union mlxsw_sp_l3addr *ul_sip,
2087                                       u32 tunnel_index)
2088 {
2089         enum mlxsw_sp_fib_entry_type type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
2090         struct mlxsw_sp_router *router = mlxsw_sp->router;
2091         struct mlxsw_sp_fib_entry *fib_entry;
2092         int err = 0;
2093
2094         mutex_lock(&mlxsw_sp->router->lock);
2095
2096         if (WARN_ON_ONCE(router->nve_decap_config.valid)) {
2097                 err = -EINVAL;
2098                 goto out;
2099         }
2100
2101         router->nve_decap_config.ul_tb_id = ul_tb_id;
2102         router->nve_decap_config.tunnel_index = tunnel_index;
2103         router->nve_decap_config.ul_proto = ul_proto;
2104         router->nve_decap_config.ul_sip = *ul_sip;
2105         router->nve_decap_config.valid = true;
2106
2107         /* It is valid to create a tunnel with a local IP and only later
2108          * assign this IP address to a local interface
2109          */
2110         fib_entry = mlxsw_sp_router_ip2me_fib_entry_find(mlxsw_sp, ul_tb_id,
2111                                                          ul_proto, ul_sip,
2112                                                          type);
2113         if (!fib_entry)
2114                 goto out;
2115
2116         fib_entry->decap.tunnel_index = tunnel_index;
2117         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP;
2118
2119         err = mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
2120         if (err)
2121                 goto err_fib_entry_update;
2122
2123         goto out;
2124
2125 err_fib_entry_update:
2126         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
2127         mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
2128 out:
2129         mutex_unlock(&mlxsw_sp->router->lock);
2130         return err;
2131 }
2132
2133 void mlxsw_sp_router_nve_demote_decap(struct mlxsw_sp *mlxsw_sp, u32 ul_tb_id,
2134                                       enum mlxsw_sp_l3proto ul_proto,
2135                                       const union mlxsw_sp_l3addr *ul_sip)
2136 {
2137         enum mlxsw_sp_fib_entry_type type = MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP;
2138         struct mlxsw_sp_router *router = mlxsw_sp->router;
2139         struct mlxsw_sp_fib_entry *fib_entry;
2140
2141         mutex_lock(&mlxsw_sp->router->lock);
2142
2143         if (WARN_ON_ONCE(!router->nve_decap_config.valid))
2144                 goto out;
2145
2146         router->nve_decap_config.valid = false;
2147
2148         fib_entry = mlxsw_sp_router_ip2me_fib_entry_find(mlxsw_sp, ul_tb_id,
2149                                                          ul_proto, ul_sip,
2150                                                          type);
2151         if (!fib_entry)
2152                 goto out;
2153
2154         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
2155         mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
2156 out:
2157         mutex_unlock(&mlxsw_sp->router->lock);
2158 }
2159
2160 static bool mlxsw_sp_router_nve_is_decap(struct mlxsw_sp *mlxsw_sp,
2161                                          u32 ul_tb_id,
2162                                          enum mlxsw_sp_l3proto ul_proto,
2163                                          const union mlxsw_sp_l3addr *ul_sip)
2164 {
2165         struct mlxsw_sp_router *router = mlxsw_sp->router;
2166
2167         return router->nve_decap_config.valid &&
2168                router->nve_decap_config.ul_tb_id == ul_tb_id &&
2169                router->nve_decap_config.ul_proto == ul_proto &&
2170                !memcmp(&router->nve_decap_config.ul_sip, ul_sip,
2171                        sizeof(*ul_sip));
2172 }
2173
2174 struct mlxsw_sp_neigh_key {
2175         struct neighbour *n;
2176 };
2177
2178 struct mlxsw_sp_neigh_entry {
2179         struct list_head rif_list_node;
2180         struct rhash_head ht_node;
2181         struct mlxsw_sp_neigh_key key;
2182         u16 rif;
2183         bool connected;
2184         unsigned char ha[ETH_ALEN];
2185         struct list_head nexthop_list; /* list of nexthops using
2186                                         * this neigh entry
2187                                         */
2188         struct list_head nexthop_neighs_list_node;
2189         unsigned int counter_index;
2190         bool counter_valid;
2191 };
2192
2193 static const struct rhashtable_params mlxsw_sp_neigh_ht_params = {
2194         .key_offset = offsetof(struct mlxsw_sp_neigh_entry, key),
2195         .head_offset = offsetof(struct mlxsw_sp_neigh_entry, ht_node),
2196         .key_len = sizeof(struct mlxsw_sp_neigh_key),
2197 };
2198
2199 struct mlxsw_sp_neigh_entry *
2200 mlxsw_sp_rif_neigh_next(struct mlxsw_sp_rif *rif,
2201                         struct mlxsw_sp_neigh_entry *neigh_entry)
2202 {
2203         if (!neigh_entry) {
2204                 if (list_empty(&rif->neigh_list))
2205                         return NULL;
2206                 else
2207                         return list_first_entry(&rif->neigh_list,
2208                                                 typeof(*neigh_entry),
2209                                                 rif_list_node);
2210         }
2211         if (list_is_last(&neigh_entry->rif_list_node, &rif->neigh_list))
2212                 return NULL;
2213         return list_next_entry(neigh_entry, rif_list_node);
2214 }
2215
2216 int mlxsw_sp_neigh_entry_type(struct mlxsw_sp_neigh_entry *neigh_entry)
2217 {
2218         return neigh_entry->key.n->tbl->family;
2219 }
2220
2221 unsigned char *
2222 mlxsw_sp_neigh_entry_ha(struct mlxsw_sp_neigh_entry *neigh_entry)
2223 {
2224         return neigh_entry->ha;
2225 }
2226
2227 u32 mlxsw_sp_neigh4_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry)
2228 {
2229         struct neighbour *n;
2230
2231         n = neigh_entry->key.n;
2232         return ntohl(*((__be32 *) n->primary_key));
2233 }
2234
2235 struct in6_addr *
2236 mlxsw_sp_neigh6_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry)
2237 {
2238         struct neighbour *n;
2239
2240         n = neigh_entry->key.n;
2241         return (struct in6_addr *) &n->primary_key;
2242 }
2243
2244 int mlxsw_sp_neigh_counter_get(struct mlxsw_sp *mlxsw_sp,
2245                                struct mlxsw_sp_neigh_entry *neigh_entry,
2246                                u64 *p_counter)
2247 {
2248         if (!neigh_entry->counter_valid)
2249                 return -EINVAL;
2250
2251         return mlxsw_sp_flow_counter_get(mlxsw_sp, neigh_entry->counter_index,
2252                                          p_counter, NULL);
2253 }
2254
2255 static struct mlxsw_sp_neigh_entry *
2256 mlxsw_sp_neigh_entry_alloc(struct mlxsw_sp *mlxsw_sp, struct neighbour *n,
2257                            u16 rif)
2258 {
2259         struct mlxsw_sp_neigh_entry *neigh_entry;
2260
2261         neigh_entry = kzalloc(sizeof(*neigh_entry), GFP_KERNEL);
2262         if (!neigh_entry)
2263                 return NULL;
2264
2265         neigh_entry->key.n = n;
2266         neigh_entry->rif = rif;
2267         INIT_LIST_HEAD(&neigh_entry->nexthop_list);
2268
2269         return neigh_entry;
2270 }
2271
2272 static void mlxsw_sp_neigh_entry_free(struct mlxsw_sp_neigh_entry *neigh_entry)
2273 {
2274         kfree(neigh_entry);
2275 }
2276
2277 static int
2278 mlxsw_sp_neigh_entry_insert(struct mlxsw_sp *mlxsw_sp,
2279                             struct mlxsw_sp_neigh_entry *neigh_entry)
2280 {
2281         return rhashtable_insert_fast(&mlxsw_sp->router->neigh_ht,
2282                                       &neigh_entry->ht_node,
2283                                       mlxsw_sp_neigh_ht_params);
2284 }
2285
2286 static void
2287 mlxsw_sp_neigh_entry_remove(struct mlxsw_sp *mlxsw_sp,
2288                             struct mlxsw_sp_neigh_entry *neigh_entry)
2289 {
2290         rhashtable_remove_fast(&mlxsw_sp->router->neigh_ht,
2291                                &neigh_entry->ht_node,
2292                                mlxsw_sp_neigh_ht_params);
2293 }
2294
2295 static bool
2296 mlxsw_sp_neigh_counter_should_alloc(struct mlxsw_sp *mlxsw_sp,
2297                                     struct mlxsw_sp_neigh_entry *neigh_entry)
2298 {
2299         struct devlink *devlink;
2300         const char *table_name;
2301
2302         switch (mlxsw_sp_neigh_entry_type(neigh_entry)) {
2303         case AF_INET:
2304                 table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST4;
2305                 break;
2306         case AF_INET6:
2307                 table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST6;
2308                 break;
2309         default:
2310                 WARN_ON(1);
2311                 return false;
2312         }
2313
2314         devlink = priv_to_devlink(mlxsw_sp->core);
2315         return devlink_dpipe_table_counter_enabled(devlink, table_name);
2316 }
2317
2318 static void
2319 mlxsw_sp_neigh_counter_alloc(struct mlxsw_sp *mlxsw_sp,
2320                              struct mlxsw_sp_neigh_entry *neigh_entry)
2321 {
2322         if (!mlxsw_sp_neigh_counter_should_alloc(mlxsw_sp, neigh_entry))
2323                 return;
2324
2325         if (mlxsw_sp_flow_counter_alloc(mlxsw_sp, &neigh_entry->counter_index))
2326                 return;
2327
2328         neigh_entry->counter_valid = true;
2329 }
2330
2331 static void
2332 mlxsw_sp_neigh_counter_free(struct mlxsw_sp *mlxsw_sp,
2333                             struct mlxsw_sp_neigh_entry *neigh_entry)
2334 {
2335         if (!neigh_entry->counter_valid)
2336                 return;
2337         mlxsw_sp_flow_counter_free(mlxsw_sp,
2338                                    neigh_entry->counter_index);
2339         neigh_entry->counter_valid = false;
2340 }
2341
2342 static struct mlxsw_sp_neigh_entry *
2343 mlxsw_sp_neigh_entry_create(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
2344 {
2345         struct mlxsw_sp_neigh_entry *neigh_entry;
2346         struct mlxsw_sp_rif *rif;
2347         int err;
2348
2349         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, n->dev);
2350         if (!rif)
2351                 return ERR_PTR(-EINVAL);
2352
2353         neigh_entry = mlxsw_sp_neigh_entry_alloc(mlxsw_sp, n, rif->rif_index);
2354         if (!neigh_entry)
2355                 return ERR_PTR(-ENOMEM);
2356
2357         err = mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry);
2358         if (err)
2359                 goto err_neigh_entry_insert;
2360
2361         mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry);
2362         atomic_inc(&mlxsw_sp->router->neighs_update.neigh_count);
2363         list_add(&neigh_entry->rif_list_node, &rif->neigh_list);
2364
2365         return neigh_entry;
2366
2367 err_neigh_entry_insert:
2368         mlxsw_sp_neigh_entry_free(neigh_entry);
2369         return ERR_PTR(err);
2370 }
2371
2372 static void
2373 mlxsw_sp_neigh_entry_destroy(struct mlxsw_sp *mlxsw_sp,
2374                              struct mlxsw_sp_neigh_entry *neigh_entry)
2375 {
2376         list_del(&neigh_entry->rif_list_node);
2377         atomic_dec(&mlxsw_sp->router->neighs_update.neigh_count);
2378         mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry);
2379         mlxsw_sp_neigh_entry_remove(mlxsw_sp, neigh_entry);
2380         mlxsw_sp_neigh_entry_free(neigh_entry);
2381 }
2382
2383 static struct mlxsw_sp_neigh_entry *
2384 mlxsw_sp_neigh_entry_lookup(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
2385 {
2386         struct mlxsw_sp_neigh_key key;
2387
2388         key.n = n;
2389         return rhashtable_lookup_fast(&mlxsw_sp->router->neigh_ht,
2390                                       &key, mlxsw_sp_neigh_ht_params);
2391 }
2392
2393 static void
2394 mlxsw_sp_router_neighs_update_interval_init(struct mlxsw_sp *mlxsw_sp)
2395 {
2396         unsigned long interval;
2397
2398 #if IS_ENABLED(CONFIG_IPV6)
2399         interval = min_t(unsigned long,
2400                          NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME),
2401                          NEIGH_VAR(&nd_tbl.parms, DELAY_PROBE_TIME));
2402 #else
2403         interval = NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME);
2404 #endif
2405         mlxsw_sp->router->neighs_update.interval = jiffies_to_msecs(interval);
2406 }
2407
2408 static void mlxsw_sp_router_neigh_ent_ipv4_process(struct mlxsw_sp *mlxsw_sp,
2409                                                    char *rauhtd_pl,
2410                                                    int ent_index)
2411 {
2412         u64 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
2413         struct net_device *dev;
2414         struct neighbour *n;
2415         __be32 dipn;
2416         u32 dip;
2417         u16 rif;
2418
2419         mlxsw_reg_rauhtd_ent_ipv4_unpack(rauhtd_pl, ent_index, &rif, &dip);
2420
2421         if (WARN_ON_ONCE(rif >= max_rifs))
2422                 return;
2423         if (!mlxsw_sp->router->rifs[rif]) {
2424                 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
2425                 return;
2426         }
2427
2428         dipn = htonl(dip);
2429         dev = mlxsw_sp_rif_dev(mlxsw_sp->router->rifs[rif]);
2430         n = neigh_lookup(&arp_tbl, &dipn, dev);
2431         if (!n)
2432                 return;
2433
2434         netdev_dbg(dev, "Updating neighbour with IP=%pI4h\n", &dip);
2435         neigh_event_send(n, NULL);
2436         neigh_release(n);
2437 }
2438
2439 #if IS_ENABLED(CONFIG_IPV6)
2440 static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
2441                                                    char *rauhtd_pl,
2442                                                    int rec_index)
2443 {
2444         struct net_device *dev;
2445         struct neighbour *n;
2446         struct in6_addr dip;
2447         u16 rif;
2448
2449         mlxsw_reg_rauhtd_ent_ipv6_unpack(rauhtd_pl, rec_index, &rif,
2450                                          (char *) &dip);
2451
2452         if (!mlxsw_sp->router->rifs[rif]) {
2453                 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
2454                 return;
2455         }
2456
2457         dev = mlxsw_sp_rif_dev(mlxsw_sp->router->rifs[rif]);
2458         n = neigh_lookup(&nd_tbl, &dip, dev);
2459         if (!n)
2460                 return;
2461
2462         netdev_dbg(dev, "Updating neighbour with IP=%pI6c\n", &dip);
2463         neigh_event_send(n, NULL);
2464         neigh_release(n);
2465 }
2466 #else
2467 static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
2468                                                    char *rauhtd_pl,
2469                                                    int rec_index)
2470 {
2471 }
2472 #endif
2473
2474 static void mlxsw_sp_router_neigh_rec_ipv4_process(struct mlxsw_sp *mlxsw_sp,
2475                                                    char *rauhtd_pl,
2476                                                    int rec_index)
2477 {
2478         u8 num_entries;
2479         int i;
2480
2481         num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
2482                                                                 rec_index);
2483         /* Hardware starts counting at 0, so add 1. */
2484         num_entries++;
2485
2486         /* Each record consists of several neighbour entries. */
2487         for (i = 0; i < num_entries; i++) {
2488                 int ent_index;
2489
2490                 ent_index = rec_index * MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC + i;
2491                 mlxsw_sp_router_neigh_ent_ipv4_process(mlxsw_sp, rauhtd_pl,
2492                                                        ent_index);
2493         }
2494
2495 }
2496
2497 static void mlxsw_sp_router_neigh_rec_ipv6_process(struct mlxsw_sp *mlxsw_sp,
2498                                                    char *rauhtd_pl,
2499                                                    int rec_index)
2500 {
2501         /* One record contains one entry. */
2502         mlxsw_sp_router_neigh_ent_ipv6_process(mlxsw_sp, rauhtd_pl,
2503                                                rec_index);
2504 }
2505
2506 static void mlxsw_sp_router_neigh_rec_process(struct mlxsw_sp *mlxsw_sp,
2507                                               char *rauhtd_pl, int rec_index)
2508 {
2509         switch (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, rec_index)) {
2510         case MLXSW_REG_RAUHTD_TYPE_IPV4:
2511                 mlxsw_sp_router_neigh_rec_ipv4_process(mlxsw_sp, rauhtd_pl,
2512                                                        rec_index);
2513                 break;
2514         case MLXSW_REG_RAUHTD_TYPE_IPV6:
2515                 mlxsw_sp_router_neigh_rec_ipv6_process(mlxsw_sp, rauhtd_pl,
2516                                                        rec_index);
2517                 break;
2518         }
2519 }
2520
2521 static bool mlxsw_sp_router_rauhtd_is_full(char *rauhtd_pl)
2522 {
2523         u8 num_rec, last_rec_index, num_entries;
2524
2525         num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
2526         last_rec_index = num_rec - 1;
2527
2528         if (num_rec < MLXSW_REG_RAUHTD_REC_MAX_NUM)
2529                 return false;
2530         if (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, last_rec_index) ==
2531             MLXSW_REG_RAUHTD_TYPE_IPV6)
2532                 return true;
2533
2534         num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
2535                                                                 last_rec_index);
2536         if (++num_entries == MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC)
2537                 return true;
2538         return false;
2539 }
2540
2541 static int
2542 __mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp,
2543                                        char *rauhtd_pl,
2544                                        enum mlxsw_reg_rauhtd_type type)
2545 {
2546         int i, num_rec;
2547         int err;
2548
2549         /* Ensure the RIF we read from the device does not change mid-dump. */
2550         mutex_lock(&mlxsw_sp->router->lock);
2551         do {
2552                 mlxsw_reg_rauhtd_pack(rauhtd_pl, type);
2553                 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(rauhtd),
2554                                       rauhtd_pl);
2555                 if (err) {
2556                         dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to dump neighbour table\n");
2557                         break;
2558                 }
2559                 num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
2560                 for (i = 0; i < num_rec; i++)
2561                         mlxsw_sp_router_neigh_rec_process(mlxsw_sp, rauhtd_pl,
2562                                                           i);
2563         } while (mlxsw_sp_router_rauhtd_is_full(rauhtd_pl));
2564         mutex_unlock(&mlxsw_sp->router->lock);
2565
2566         return err;
2567 }
2568
2569 static int mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp)
2570 {
2571         enum mlxsw_reg_rauhtd_type type;
2572         char *rauhtd_pl;
2573         int err;
2574
2575         if (!atomic_read(&mlxsw_sp->router->neighs_update.neigh_count))
2576                 return 0;
2577
2578         rauhtd_pl = kmalloc(MLXSW_REG_RAUHTD_LEN, GFP_KERNEL);
2579         if (!rauhtd_pl)
2580                 return -ENOMEM;
2581
2582         type = MLXSW_REG_RAUHTD_TYPE_IPV4;
2583         err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
2584         if (err)
2585                 goto out;
2586
2587         type = MLXSW_REG_RAUHTD_TYPE_IPV6;
2588         err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
2589 out:
2590         kfree(rauhtd_pl);
2591         return err;
2592 }
2593
2594 static void mlxsw_sp_router_neighs_update_nh(struct mlxsw_sp *mlxsw_sp)
2595 {
2596         struct mlxsw_sp_neigh_entry *neigh_entry;
2597
2598         mutex_lock(&mlxsw_sp->router->lock);
2599         list_for_each_entry(neigh_entry, &mlxsw_sp->router->nexthop_neighs_list,
2600                             nexthop_neighs_list_node)
2601                 /* If this neigh have nexthops, make the kernel think this neigh
2602                  * is active regardless of the traffic.
2603                  */
2604                 neigh_event_send(neigh_entry->key.n, NULL);
2605         mutex_unlock(&mlxsw_sp->router->lock);
2606 }
2607
2608 static void
2609 mlxsw_sp_router_neighs_update_work_schedule(struct mlxsw_sp *mlxsw_sp)
2610 {
2611         unsigned long interval = mlxsw_sp->router->neighs_update.interval;
2612
2613         mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw,
2614                                msecs_to_jiffies(interval));
2615 }
2616
2617 static void mlxsw_sp_router_neighs_update_work(struct work_struct *work)
2618 {
2619         struct mlxsw_sp_router *router;
2620         int err;
2621
2622         router = container_of(work, struct mlxsw_sp_router,
2623                               neighs_update.dw.work);
2624         err = mlxsw_sp_router_neighs_update_rauhtd(router->mlxsw_sp);
2625         if (err)
2626                 dev_err(router->mlxsw_sp->bus_info->dev, "Could not update kernel for neigh activity");
2627
2628         mlxsw_sp_router_neighs_update_nh(router->mlxsw_sp);
2629
2630         mlxsw_sp_router_neighs_update_work_schedule(router->mlxsw_sp);
2631 }
2632
2633 static void mlxsw_sp_router_probe_unresolved_nexthops(struct work_struct *work)
2634 {
2635         struct mlxsw_sp_neigh_entry *neigh_entry;
2636         struct mlxsw_sp_router *router;
2637
2638         router = container_of(work, struct mlxsw_sp_router,
2639                               nexthop_probe_dw.work);
2640         /* Iterate over nexthop neighbours, find those who are unresolved and
2641          * send arp on them. This solves the chicken-egg problem when
2642          * the nexthop wouldn't get offloaded until the neighbor is resolved
2643          * but it wouldn't get resolved ever in case traffic is flowing in HW
2644          * using different nexthop.
2645          */
2646         mutex_lock(&router->lock);
2647         list_for_each_entry(neigh_entry, &router->nexthop_neighs_list,
2648                             nexthop_neighs_list_node)
2649                 if (!neigh_entry->connected)
2650                         neigh_event_send(neigh_entry->key.n, NULL);
2651         mutex_unlock(&router->lock);
2652
2653         mlxsw_core_schedule_dw(&router->nexthop_probe_dw,
2654                                MLXSW_SP_UNRESOLVED_NH_PROBE_INTERVAL);
2655 }
2656
2657 static void
2658 mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
2659                               struct mlxsw_sp_neigh_entry *neigh_entry,
2660                               bool removing, bool dead);
2661
2662 static enum mlxsw_reg_rauht_op mlxsw_sp_rauht_op(bool adding)
2663 {
2664         return adding ? MLXSW_REG_RAUHT_OP_WRITE_ADD :
2665                         MLXSW_REG_RAUHT_OP_WRITE_DELETE;
2666 }
2667
2668 static int
2669 mlxsw_sp_router_neigh_entry_op4(struct mlxsw_sp *mlxsw_sp,
2670                                 struct mlxsw_sp_neigh_entry *neigh_entry,
2671                                 enum mlxsw_reg_rauht_op op)
2672 {
2673         struct neighbour *n = neigh_entry->key.n;
2674         u32 dip = ntohl(*((__be32 *) n->primary_key));
2675         char rauht_pl[MLXSW_REG_RAUHT_LEN];
2676
2677         mlxsw_reg_rauht_pack4(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
2678                               dip);
2679         if (neigh_entry->counter_valid)
2680                 mlxsw_reg_rauht_pack_counter(rauht_pl,
2681                                              neigh_entry->counter_index);
2682         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
2683 }
2684
2685 static int
2686 mlxsw_sp_router_neigh_entry_op6(struct mlxsw_sp *mlxsw_sp,
2687                                 struct mlxsw_sp_neigh_entry *neigh_entry,
2688                                 enum mlxsw_reg_rauht_op op)
2689 {
2690         struct neighbour *n = neigh_entry->key.n;
2691         char rauht_pl[MLXSW_REG_RAUHT_LEN];
2692         const char *dip = n->primary_key;
2693
2694         mlxsw_reg_rauht_pack6(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
2695                               dip);
2696         if (neigh_entry->counter_valid)
2697                 mlxsw_reg_rauht_pack_counter(rauht_pl,
2698                                              neigh_entry->counter_index);
2699         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
2700 }
2701
2702 bool mlxsw_sp_neigh_ipv6_ignore(struct mlxsw_sp_neigh_entry *neigh_entry)
2703 {
2704         struct neighbour *n = neigh_entry->key.n;
2705
2706         /* Packets with a link-local destination address are trapped
2707          * after LPM lookup and never reach the neighbour table, so
2708          * there is no need to program such neighbours to the device.
2709          */
2710         if (ipv6_addr_type((struct in6_addr *) &n->primary_key) &
2711             IPV6_ADDR_LINKLOCAL)
2712                 return true;
2713         return false;
2714 }
2715
2716 static void
2717 mlxsw_sp_neigh_entry_update(struct mlxsw_sp *mlxsw_sp,
2718                             struct mlxsw_sp_neigh_entry *neigh_entry,
2719                             bool adding)
2720 {
2721         enum mlxsw_reg_rauht_op op = mlxsw_sp_rauht_op(adding);
2722         int err;
2723
2724         if (!adding && !neigh_entry->connected)
2725                 return;
2726         neigh_entry->connected = adding;
2727         if (neigh_entry->key.n->tbl->family == AF_INET) {
2728                 err = mlxsw_sp_router_neigh_entry_op4(mlxsw_sp, neigh_entry,
2729                                                       op);
2730                 if (err)
2731                         return;
2732         } else if (neigh_entry->key.n->tbl->family == AF_INET6) {
2733                 if (mlxsw_sp_neigh_ipv6_ignore(neigh_entry))
2734                         return;
2735                 err = mlxsw_sp_router_neigh_entry_op6(mlxsw_sp, neigh_entry,
2736                                                       op);
2737                 if (err)
2738                         return;
2739         } else {
2740                 WARN_ON_ONCE(1);
2741                 return;
2742         }
2743
2744         if (adding)
2745                 neigh_entry->key.n->flags |= NTF_OFFLOADED;
2746         else
2747                 neigh_entry->key.n->flags &= ~NTF_OFFLOADED;
2748 }
2749
2750 void
2751 mlxsw_sp_neigh_entry_counter_update(struct mlxsw_sp *mlxsw_sp,
2752                                     struct mlxsw_sp_neigh_entry *neigh_entry,
2753                                     bool adding)
2754 {
2755         if (adding)
2756                 mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry);
2757         else
2758                 mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry);
2759         mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, true);
2760 }
2761
2762 struct mlxsw_sp_netevent_work {
2763         struct work_struct work;
2764         struct mlxsw_sp *mlxsw_sp;
2765         struct neighbour *n;
2766 };
2767
2768 static void mlxsw_sp_router_neigh_event_work(struct work_struct *work)
2769 {
2770         struct mlxsw_sp_netevent_work *net_work =
2771                 container_of(work, struct mlxsw_sp_netevent_work, work);
2772         struct mlxsw_sp *mlxsw_sp = net_work->mlxsw_sp;
2773         struct mlxsw_sp_neigh_entry *neigh_entry;
2774         struct neighbour *n = net_work->n;
2775         unsigned char ha[ETH_ALEN];
2776         bool entry_connected;
2777         u8 nud_state, dead;
2778
2779         /* If these parameters are changed after we release the lock,
2780          * then we are guaranteed to receive another event letting us
2781          * know about it.
2782          */
2783         read_lock_bh(&n->lock);
2784         memcpy(ha, n->ha, ETH_ALEN);
2785         nud_state = n->nud_state;
2786         dead = n->dead;
2787         read_unlock_bh(&n->lock);
2788
2789         mutex_lock(&mlxsw_sp->router->lock);
2790         mlxsw_sp_span_respin(mlxsw_sp);
2791
2792         entry_connected = nud_state & NUD_VALID && !dead;
2793         neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
2794         if (!entry_connected && !neigh_entry)
2795                 goto out;
2796         if (!neigh_entry) {
2797                 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
2798                 if (IS_ERR(neigh_entry))
2799                         goto out;
2800         }
2801
2802         if (neigh_entry->connected && entry_connected &&
2803             !memcmp(neigh_entry->ha, ha, ETH_ALEN))
2804                 goto out;
2805
2806         memcpy(neigh_entry->ha, ha, ETH_ALEN);
2807         mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, entry_connected);
2808         mlxsw_sp_nexthop_neigh_update(mlxsw_sp, neigh_entry, !entry_connected,
2809                                       dead);
2810
2811         if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
2812                 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
2813
2814 out:
2815         mutex_unlock(&mlxsw_sp->router->lock);
2816         neigh_release(n);
2817         kfree(net_work);
2818 }
2819
2820 static int mlxsw_sp_mp_hash_init(struct mlxsw_sp *mlxsw_sp);
2821
2822 static void mlxsw_sp_router_mp_hash_event_work(struct work_struct *work)
2823 {
2824         struct mlxsw_sp_netevent_work *net_work =
2825                 container_of(work, struct mlxsw_sp_netevent_work, work);
2826         struct mlxsw_sp *mlxsw_sp = net_work->mlxsw_sp;
2827
2828         mlxsw_sp_mp_hash_init(mlxsw_sp);
2829         kfree(net_work);
2830 }
2831
2832 static int __mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp);
2833
2834 static void mlxsw_sp_router_update_priority_work(struct work_struct *work)
2835 {
2836         struct mlxsw_sp_netevent_work *net_work =
2837                 container_of(work, struct mlxsw_sp_netevent_work, work);
2838         struct mlxsw_sp *mlxsw_sp = net_work->mlxsw_sp;
2839
2840         __mlxsw_sp_router_init(mlxsw_sp);
2841         kfree(net_work);
2842 }
2843
2844 static int mlxsw_sp_router_schedule_work(struct net *net,
2845                                          struct mlxsw_sp_router *router,
2846                                          struct neighbour *n,
2847                                          void (*cb)(struct work_struct *))
2848 {
2849         struct mlxsw_sp_netevent_work *net_work;
2850
2851         if (!net_eq(net, mlxsw_sp_net(router->mlxsw_sp)))
2852                 return NOTIFY_DONE;
2853
2854         net_work = kzalloc(sizeof(*net_work), GFP_ATOMIC);
2855         if (!net_work)
2856                 return NOTIFY_BAD;
2857
2858         INIT_WORK(&net_work->work, cb);
2859         net_work->mlxsw_sp = router->mlxsw_sp;
2860         net_work->n = n;
2861         mlxsw_core_schedule_work(&net_work->work);
2862         return NOTIFY_DONE;
2863 }
2864
2865 static bool mlxsw_sp_dev_lower_is_port(struct net_device *dev)
2866 {
2867         struct mlxsw_sp_port *mlxsw_sp_port;
2868
2869         rcu_read_lock();
2870         mlxsw_sp_port = mlxsw_sp_port_dev_lower_find_rcu(dev);
2871         rcu_read_unlock();
2872         return !!mlxsw_sp_port;
2873 }
2874
2875 static int mlxsw_sp_router_netevent_event(struct notifier_block *nb,
2876                                           unsigned long event, void *ptr)
2877 {
2878         struct mlxsw_sp_router *router;
2879         unsigned long interval;
2880         struct neigh_parms *p;
2881         struct neighbour *n;
2882         struct net *net;
2883
2884         router = container_of(nb, struct mlxsw_sp_router, netevent_nb);
2885
2886         switch (event) {
2887         case NETEVENT_DELAY_PROBE_TIME_UPDATE:
2888                 p = ptr;
2889
2890                 /* We don't care about changes in the default table. */
2891                 if (!p->dev || (p->tbl->family != AF_INET &&
2892                                 p->tbl->family != AF_INET6))
2893                         return NOTIFY_DONE;
2894
2895                 /* We are in atomic context and can't take RTNL mutex,
2896                  * so use RCU variant to walk the device chain.
2897                  */
2898                 if (!mlxsw_sp_dev_lower_is_port(p->dev))
2899                         return NOTIFY_DONE;
2900
2901                 interval = jiffies_to_msecs(NEIGH_VAR(p, DELAY_PROBE_TIME));
2902                 router->neighs_update.interval = interval;
2903                 break;
2904         case NETEVENT_NEIGH_UPDATE:
2905                 n = ptr;
2906                 net = neigh_parms_net(n->parms);
2907
2908                 if (n->tbl->family != AF_INET && n->tbl->family != AF_INET6)
2909                         return NOTIFY_DONE;
2910
2911                 if (!mlxsw_sp_dev_lower_is_port(n->dev))
2912                         return NOTIFY_DONE;
2913
2914                 /* Take a reference to ensure the neighbour won't be
2915                  * destructed until we drop the reference in delayed
2916                  * work.
2917                  */
2918                 neigh_clone(n);
2919                 return mlxsw_sp_router_schedule_work(net, router, n,
2920                                 mlxsw_sp_router_neigh_event_work);
2921
2922         case NETEVENT_IPV4_MPATH_HASH_UPDATE:
2923         case NETEVENT_IPV6_MPATH_HASH_UPDATE:
2924                 return mlxsw_sp_router_schedule_work(ptr, router, NULL,
2925                                 mlxsw_sp_router_mp_hash_event_work);
2926
2927         case NETEVENT_IPV4_FWD_UPDATE_PRIORITY_UPDATE:
2928                 return mlxsw_sp_router_schedule_work(ptr, router, NULL,
2929                                 mlxsw_sp_router_update_priority_work);
2930         }
2931
2932         return NOTIFY_DONE;
2933 }
2934
2935 static int mlxsw_sp_neigh_init(struct mlxsw_sp *mlxsw_sp)
2936 {
2937         int err;
2938
2939         err = rhashtable_init(&mlxsw_sp->router->neigh_ht,
2940                               &mlxsw_sp_neigh_ht_params);
2941         if (err)
2942                 return err;
2943
2944         /* Initialize the polling interval according to the default
2945          * table.
2946          */
2947         mlxsw_sp_router_neighs_update_interval_init(mlxsw_sp);
2948
2949         /* Create the delayed works for the activity_update */
2950         INIT_DELAYED_WORK(&mlxsw_sp->router->neighs_update.dw,
2951                           mlxsw_sp_router_neighs_update_work);
2952         INIT_DELAYED_WORK(&mlxsw_sp->router->nexthop_probe_dw,
2953                           mlxsw_sp_router_probe_unresolved_nexthops);
2954         atomic_set(&mlxsw_sp->router->neighs_update.neigh_count, 0);
2955         mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw, 0);
2956         mlxsw_core_schedule_dw(&mlxsw_sp->router->nexthop_probe_dw, 0);
2957         return 0;
2958 }
2959
2960 static void mlxsw_sp_neigh_fini(struct mlxsw_sp *mlxsw_sp)
2961 {
2962         cancel_delayed_work_sync(&mlxsw_sp->router->neighs_update.dw);
2963         cancel_delayed_work_sync(&mlxsw_sp->router->nexthop_probe_dw);
2964         rhashtable_destroy(&mlxsw_sp->router->neigh_ht);
2965 }
2966
2967 static void mlxsw_sp_neigh_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
2968                                          struct mlxsw_sp_rif *rif)
2969 {
2970         struct mlxsw_sp_neigh_entry *neigh_entry, *tmp;
2971
2972         list_for_each_entry_safe(neigh_entry, tmp, &rif->neigh_list,
2973                                  rif_list_node) {
2974                 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, false);
2975                 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
2976         }
2977 }
2978
2979 enum mlxsw_sp_nexthop_type {
2980         MLXSW_SP_NEXTHOP_TYPE_ETH,
2981         MLXSW_SP_NEXTHOP_TYPE_IPIP,
2982 };
2983
2984 enum mlxsw_sp_nexthop_action {
2985         /* Nexthop forwards packets to an egress RIF */
2986         MLXSW_SP_NEXTHOP_ACTION_FORWARD,
2987         /* Nexthop discards packets */
2988         MLXSW_SP_NEXTHOP_ACTION_DISCARD,
2989         /* Nexthop traps packets */
2990         MLXSW_SP_NEXTHOP_ACTION_TRAP,
2991 };
2992
2993 struct mlxsw_sp_nexthop_key {
2994         struct fib_nh *fib_nh;
2995 };
2996
2997 struct mlxsw_sp_nexthop {
2998         struct list_head neigh_list_node; /* member of neigh entry list */
2999         struct list_head crif_list_node;
3000         struct list_head router_list_node;
3001         struct mlxsw_sp_nexthop_group_info *nhgi; /* pointer back to the group
3002                                                    * this nexthop belongs to
3003                                                    */
3004         struct rhash_head ht_node;
3005         struct neigh_table *neigh_tbl;
3006         struct mlxsw_sp_nexthop_key key;
3007         unsigned char gw_addr[sizeof(struct in6_addr)];
3008         int ifindex;
3009         int nh_weight;
3010         int norm_nh_weight;
3011         int num_adj_entries;
3012         struct mlxsw_sp_crif *crif;
3013         u8 should_offload:1, /* set indicates this nexthop should be written
3014                               * to the adjacency table.
3015                               */
3016            offloaded:1, /* set indicates this nexthop was written to the
3017                          * adjacency table.
3018                          */
3019            update:1; /* set indicates this nexthop should be updated in the
3020                       * adjacency table (f.e., its MAC changed).
3021                       */
3022         enum mlxsw_sp_nexthop_action action;
3023         enum mlxsw_sp_nexthop_type type;
3024         union {
3025                 struct mlxsw_sp_neigh_entry *neigh_entry;
3026                 struct mlxsw_sp_ipip_entry *ipip_entry;
3027         };
3028         unsigned int counter_index;
3029         bool counter_valid;
3030 };
3031
3032 static struct net_device *
3033 mlxsw_sp_nexthop_dev(const struct mlxsw_sp_nexthop *nh)
3034 {
3035         if (!nh->crif)
3036                 return NULL;
3037         return nh->crif->key.dev;
3038 }
3039
3040 enum mlxsw_sp_nexthop_group_type {
3041         MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4,
3042         MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6,
3043         MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ,
3044 };
3045
3046 struct mlxsw_sp_nexthop_group_info {
3047         struct mlxsw_sp_nexthop_group *nh_grp;
3048         u32 adj_index;
3049         u16 ecmp_size;
3050         u16 count;
3051         int sum_norm_weight;
3052         u8 adj_index_valid:1,
3053            gateway:1, /* routes using the group use a gateway */
3054            is_resilient:1;
3055         struct list_head list; /* member in nh_res_grp_list */
3056         struct mlxsw_sp_nexthop nexthops[];
3057 };
3058
3059 static struct mlxsw_sp_rif *
3060 mlxsw_sp_nhgi_rif(const struct mlxsw_sp_nexthop_group_info *nhgi)
3061 {
3062         struct mlxsw_sp_crif *crif = nhgi->nexthops[0].crif;
3063
3064         if (!crif)
3065                 return NULL;
3066         return crif->rif;
3067 }
3068
3069 struct mlxsw_sp_nexthop_group_vr_key {
3070         u16 vr_id;
3071         enum mlxsw_sp_l3proto proto;
3072 };
3073
3074 struct mlxsw_sp_nexthop_group_vr_entry {
3075         struct list_head list; /* member in vr_list */
3076         struct rhash_head ht_node; /* member in vr_ht */
3077         refcount_t ref_count;
3078         struct mlxsw_sp_nexthop_group_vr_key key;
3079 };
3080
3081 struct mlxsw_sp_nexthop_group {
3082         struct rhash_head ht_node;
3083         struct list_head fib_list; /* list of fib entries that use this group */
3084         union {
3085                 struct {
3086                         struct fib_info *fi;
3087                 } ipv4;
3088                 struct {
3089                         u32 id;
3090                 } obj;
3091         };
3092         struct mlxsw_sp_nexthop_group_info *nhgi;
3093         struct list_head vr_list;
3094         struct rhashtable vr_ht;
3095         enum mlxsw_sp_nexthop_group_type type;
3096         bool can_destroy;
3097 };
3098
3099 void mlxsw_sp_nexthop_counter_alloc(struct mlxsw_sp *mlxsw_sp,
3100                                     struct mlxsw_sp_nexthop *nh)
3101 {
3102         struct devlink *devlink;
3103
3104         devlink = priv_to_devlink(mlxsw_sp->core);
3105         if (!devlink_dpipe_table_counter_enabled(devlink,
3106                                                  MLXSW_SP_DPIPE_TABLE_NAME_ADJ))
3107                 return;
3108
3109         if (mlxsw_sp_flow_counter_alloc(mlxsw_sp, &nh->counter_index))
3110                 return;
3111
3112         nh->counter_valid = true;
3113 }
3114
3115 void mlxsw_sp_nexthop_counter_free(struct mlxsw_sp *mlxsw_sp,
3116                                    struct mlxsw_sp_nexthop *nh)
3117 {
3118         if (!nh->counter_valid)
3119                 return;
3120         mlxsw_sp_flow_counter_free(mlxsw_sp, nh->counter_index);
3121         nh->counter_valid = false;
3122 }
3123
3124 int mlxsw_sp_nexthop_counter_get(struct mlxsw_sp *mlxsw_sp,
3125                                  struct mlxsw_sp_nexthop *nh, u64 *p_counter)
3126 {
3127         if (!nh->counter_valid)
3128                 return -EINVAL;
3129
3130         return mlxsw_sp_flow_counter_get(mlxsw_sp, nh->counter_index,
3131                                          p_counter, NULL);
3132 }
3133
3134 struct mlxsw_sp_nexthop *mlxsw_sp_nexthop_next(struct mlxsw_sp_router *router,
3135                                                struct mlxsw_sp_nexthop *nh)
3136 {
3137         if (!nh) {
3138                 if (list_empty(&router->nexthop_list))
3139                         return NULL;
3140                 else
3141                         return list_first_entry(&router->nexthop_list,
3142                                                 typeof(*nh), router_list_node);
3143         }
3144         if (list_is_last(&nh->router_list_node, &router->nexthop_list))
3145                 return NULL;
3146         return list_next_entry(nh, router_list_node);
3147 }
3148
3149 bool mlxsw_sp_nexthop_is_forward(const struct mlxsw_sp_nexthop *nh)
3150 {
3151         return nh->offloaded && nh->action == MLXSW_SP_NEXTHOP_ACTION_FORWARD;
3152 }
3153
3154 unsigned char *mlxsw_sp_nexthop_ha(struct mlxsw_sp_nexthop *nh)
3155 {
3156         if (nh->type != MLXSW_SP_NEXTHOP_TYPE_ETH ||
3157             !mlxsw_sp_nexthop_is_forward(nh))
3158                 return NULL;
3159         return nh->neigh_entry->ha;
3160 }
3161
3162 int mlxsw_sp_nexthop_indexes(struct mlxsw_sp_nexthop *nh, u32 *p_adj_index,
3163                              u32 *p_adj_size, u32 *p_adj_hash_index)
3164 {
3165         struct mlxsw_sp_nexthop_group_info *nhgi = nh->nhgi;
3166         u32 adj_hash_index = 0;
3167         int i;
3168
3169         if (!nh->offloaded || !nhgi->adj_index_valid)
3170                 return -EINVAL;
3171
3172         *p_adj_index = nhgi->adj_index;
3173         *p_adj_size = nhgi->ecmp_size;
3174
3175         for (i = 0; i < nhgi->count; i++) {
3176                 struct mlxsw_sp_nexthop *nh_iter = &nhgi->nexthops[i];
3177
3178                 if (nh_iter == nh)
3179                         break;
3180                 if (nh_iter->offloaded)
3181                         adj_hash_index += nh_iter->num_adj_entries;
3182         }
3183
3184         *p_adj_hash_index = adj_hash_index;
3185         return 0;
3186 }
3187
3188 struct mlxsw_sp_rif *mlxsw_sp_nexthop_rif(struct mlxsw_sp_nexthop *nh)
3189 {
3190         if (WARN_ON(!nh->crif))
3191                 return NULL;
3192         return nh->crif->rif;
3193 }
3194
3195 bool mlxsw_sp_nexthop_group_has_ipip(struct mlxsw_sp_nexthop *nh)
3196 {
3197         struct mlxsw_sp_nexthop_group_info *nhgi = nh->nhgi;
3198         int i;
3199
3200         for (i = 0; i < nhgi->count; i++) {
3201                 struct mlxsw_sp_nexthop *nh_iter = &nhgi->nexthops[i];
3202
3203                 if (nh_iter->type == MLXSW_SP_NEXTHOP_TYPE_IPIP)
3204                         return true;
3205         }
3206         return false;
3207 }
3208
3209 static const struct rhashtable_params mlxsw_sp_nexthop_group_vr_ht_params = {
3210         .key_offset = offsetof(struct mlxsw_sp_nexthop_group_vr_entry, key),
3211         .head_offset = offsetof(struct mlxsw_sp_nexthop_group_vr_entry, ht_node),
3212         .key_len = sizeof(struct mlxsw_sp_nexthop_group_vr_key),
3213         .automatic_shrinking = true,
3214 };
3215
3216 static struct mlxsw_sp_nexthop_group_vr_entry *
3217 mlxsw_sp_nexthop_group_vr_entry_lookup(struct mlxsw_sp_nexthop_group *nh_grp,
3218                                        const struct mlxsw_sp_fib *fib)
3219 {
3220         struct mlxsw_sp_nexthop_group_vr_key key;
3221
3222         memset(&key, 0, sizeof(key));
3223         key.vr_id = fib->vr->id;
3224         key.proto = fib->proto;
3225         return rhashtable_lookup_fast(&nh_grp->vr_ht, &key,
3226                                       mlxsw_sp_nexthop_group_vr_ht_params);
3227 }
3228
3229 static int
3230 mlxsw_sp_nexthop_group_vr_entry_create(struct mlxsw_sp_nexthop_group *nh_grp,
3231                                        const struct mlxsw_sp_fib *fib)
3232 {
3233         struct mlxsw_sp_nexthop_group_vr_entry *vr_entry;
3234         int err;
3235
3236         vr_entry = kzalloc(sizeof(*vr_entry), GFP_KERNEL);
3237         if (!vr_entry)
3238                 return -ENOMEM;
3239
3240         vr_entry->key.vr_id = fib->vr->id;
3241         vr_entry->key.proto = fib->proto;
3242         refcount_set(&vr_entry->ref_count, 1);
3243
3244         err = rhashtable_insert_fast(&nh_grp->vr_ht, &vr_entry->ht_node,
3245                                      mlxsw_sp_nexthop_group_vr_ht_params);
3246         if (err)
3247                 goto err_hashtable_insert;
3248
3249         list_add(&vr_entry->list, &nh_grp->vr_list);
3250
3251         return 0;
3252
3253 err_hashtable_insert:
3254         kfree(vr_entry);
3255         return err;
3256 }
3257
3258 static void
3259 mlxsw_sp_nexthop_group_vr_entry_destroy(struct mlxsw_sp_nexthop_group *nh_grp,
3260                                         struct mlxsw_sp_nexthop_group_vr_entry *vr_entry)
3261 {
3262         list_del(&vr_entry->list);
3263         rhashtable_remove_fast(&nh_grp->vr_ht, &vr_entry->ht_node,
3264                                mlxsw_sp_nexthop_group_vr_ht_params);
3265         kfree(vr_entry);
3266 }
3267
3268 static int
3269 mlxsw_sp_nexthop_group_vr_link(struct mlxsw_sp_nexthop_group *nh_grp,
3270                                const struct mlxsw_sp_fib *fib)
3271 {
3272         struct mlxsw_sp_nexthop_group_vr_entry *vr_entry;
3273
3274         vr_entry = mlxsw_sp_nexthop_group_vr_entry_lookup(nh_grp, fib);
3275         if (vr_entry) {
3276                 refcount_inc(&vr_entry->ref_count);
3277                 return 0;
3278         }
3279
3280         return mlxsw_sp_nexthop_group_vr_entry_create(nh_grp, fib);
3281 }
3282
3283 static void
3284 mlxsw_sp_nexthop_group_vr_unlink(struct mlxsw_sp_nexthop_group *nh_grp,
3285                                  const struct mlxsw_sp_fib *fib)
3286 {
3287         struct mlxsw_sp_nexthop_group_vr_entry *vr_entry;
3288
3289         vr_entry = mlxsw_sp_nexthop_group_vr_entry_lookup(nh_grp, fib);
3290         if (WARN_ON_ONCE(!vr_entry))
3291                 return;
3292
3293         if (!refcount_dec_and_test(&vr_entry->ref_count))
3294                 return;
3295
3296         mlxsw_sp_nexthop_group_vr_entry_destroy(nh_grp, vr_entry);
3297 }
3298
3299 struct mlxsw_sp_nexthop_group_cmp_arg {
3300         enum mlxsw_sp_nexthop_group_type type;
3301         union {
3302                 struct fib_info *fi;
3303                 struct mlxsw_sp_fib6_entry *fib6_entry;
3304                 u32 id;
3305         };
3306 };
3307
3308 static bool
3309 mlxsw_sp_nexthop6_group_has_nexthop(const struct mlxsw_sp_nexthop_group *nh_grp,
3310                                     const struct in6_addr *gw, int ifindex,
3311                                     int weight)
3312 {
3313         int i;
3314
3315         for (i = 0; i < nh_grp->nhgi->count; i++) {
3316                 const struct mlxsw_sp_nexthop *nh;
3317
3318                 nh = &nh_grp->nhgi->nexthops[i];
3319                 if (nh->ifindex == ifindex && nh->nh_weight == weight &&
3320                     ipv6_addr_equal(gw, (struct in6_addr *) nh->gw_addr))
3321                         return true;
3322         }
3323
3324         return false;
3325 }
3326
3327 static bool
3328 mlxsw_sp_nexthop6_group_cmp(const struct mlxsw_sp_nexthop_group *nh_grp,
3329                             const struct mlxsw_sp_fib6_entry *fib6_entry)
3330 {
3331         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3332
3333         if (nh_grp->nhgi->count != fib6_entry->nrt6)
3334                 return false;
3335
3336         list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
3337                 struct fib6_nh *fib6_nh = mlxsw_sp_rt6->rt->fib6_nh;
3338                 struct in6_addr *gw;
3339                 int ifindex, weight;
3340
3341                 ifindex = fib6_nh->fib_nh_dev->ifindex;
3342                 weight = fib6_nh->fib_nh_weight;
3343                 gw = &fib6_nh->fib_nh_gw6;
3344                 if (!mlxsw_sp_nexthop6_group_has_nexthop(nh_grp, gw, ifindex,
3345                                                          weight))
3346                         return false;
3347         }
3348
3349         return true;
3350 }
3351
3352 static int
3353 mlxsw_sp_nexthop_group_cmp(struct rhashtable_compare_arg *arg, const void *ptr)
3354 {
3355         const struct mlxsw_sp_nexthop_group_cmp_arg *cmp_arg = arg->key;
3356         const struct mlxsw_sp_nexthop_group *nh_grp = ptr;
3357
3358         if (nh_grp->type != cmp_arg->type)
3359                 return 1;
3360
3361         switch (cmp_arg->type) {
3362         case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4:
3363                 return cmp_arg->fi != nh_grp->ipv4.fi;
3364         case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6:
3365                 return !mlxsw_sp_nexthop6_group_cmp(nh_grp,
3366                                                     cmp_arg->fib6_entry);
3367         case MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ:
3368                 return cmp_arg->id != nh_grp->obj.id;
3369         default:
3370                 WARN_ON(1);
3371                 return 1;
3372         }
3373 }
3374
3375 static u32 mlxsw_sp_nexthop_group_hash_obj(const void *data, u32 len, u32 seed)
3376 {
3377         const struct mlxsw_sp_nexthop_group *nh_grp = data;
3378         const struct mlxsw_sp_nexthop *nh;
3379         struct fib_info *fi;
3380         unsigned int val;
3381         int i;
3382
3383         switch (nh_grp->type) {
3384         case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4:
3385                 fi = nh_grp->ipv4.fi;
3386                 return jhash(&fi, sizeof(fi), seed);
3387         case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6:
3388                 val = nh_grp->nhgi->count;
3389                 for (i = 0; i < nh_grp->nhgi->count; i++) {
3390                         nh = &nh_grp->nhgi->nexthops[i];
3391                         val ^= jhash(&nh->ifindex, sizeof(nh->ifindex), seed);
3392                         val ^= jhash(&nh->gw_addr, sizeof(nh->gw_addr), seed);
3393                 }
3394                 return jhash(&val, sizeof(val), seed);
3395         case MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ:
3396                 return jhash(&nh_grp->obj.id, sizeof(nh_grp->obj.id), seed);
3397         default:
3398                 WARN_ON(1);
3399                 return 0;
3400         }
3401 }
3402
3403 static u32
3404 mlxsw_sp_nexthop6_group_hash(struct mlxsw_sp_fib6_entry *fib6_entry, u32 seed)
3405 {
3406         unsigned int val = fib6_entry->nrt6;
3407         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3408
3409         list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
3410                 struct fib6_nh *fib6_nh = mlxsw_sp_rt6->rt->fib6_nh;
3411                 struct net_device *dev = fib6_nh->fib_nh_dev;
3412                 struct in6_addr *gw = &fib6_nh->fib_nh_gw6;
3413
3414                 val ^= jhash(&dev->ifindex, sizeof(dev->ifindex), seed);
3415                 val ^= jhash(gw, sizeof(*gw), seed);
3416         }
3417
3418         return jhash(&val, sizeof(val), seed);
3419 }
3420
3421 static u32
3422 mlxsw_sp_nexthop_group_hash(const void *data, u32 len, u32 seed)
3423 {
3424         const struct mlxsw_sp_nexthop_group_cmp_arg *cmp_arg = data;
3425
3426         switch (cmp_arg->type) {
3427         case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4:
3428                 return jhash(&cmp_arg->fi, sizeof(cmp_arg->fi), seed);
3429         case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6:
3430                 return mlxsw_sp_nexthop6_group_hash(cmp_arg->fib6_entry, seed);
3431         case MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ:
3432                 return jhash(&cmp_arg->id, sizeof(cmp_arg->id), seed);
3433         default:
3434                 WARN_ON(1);
3435                 return 0;
3436         }
3437 }
3438
3439 static const struct rhashtable_params mlxsw_sp_nexthop_group_ht_params = {
3440         .head_offset = offsetof(struct mlxsw_sp_nexthop_group, ht_node),
3441         .hashfn      = mlxsw_sp_nexthop_group_hash,
3442         .obj_hashfn  = mlxsw_sp_nexthop_group_hash_obj,
3443         .obj_cmpfn   = mlxsw_sp_nexthop_group_cmp,
3444 };
3445
3446 static int mlxsw_sp_nexthop_group_insert(struct mlxsw_sp *mlxsw_sp,
3447                                          struct mlxsw_sp_nexthop_group *nh_grp)
3448 {
3449         if (nh_grp->type == MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6 &&
3450             !nh_grp->nhgi->gateway)
3451                 return 0;
3452
3453         return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_group_ht,
3454                                       &nh_grp->ht_node,
3455                                       mlxsw_sp_nexthop_group_ht_params);
3456 }
3457
3458 static void mlxsw_sp_nexthop_group_remove(struct mlxsw_sp *mlxsw_sp,
3459                                           struct mlxsw_sp_nexthop_group *nh_grp)
3460 {
3461         if (nh_grp->type == MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6 &&
3462             !nh_grp->nhgi->gateway)
3463                 return;
3464
3465         rhashtable_remove_fast(&mlxsw_sp->router->nexthop_group_ht,
3466                                &nh_grp->ht_node,
3467                                mlxsw_sp_nexthop_group_ht_params);
3468 }
3469
3470 static struct mlxsw_sp_nexthop_group *
3471 mlxsw_sp_nexthop4_group_lookup(struct mlxsw_sp *mlxsw_sp,
3472                                struct fib_info *fi)
3473 {
3474         struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
3475
3476         cmp_arg.type = MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4;
3477         cmp_arg.fi = fi;
3478         return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
3479                                       &cmp_arg,
3480                                       mlxsw_sp_nexthop_group_ht_params);
3481 }
3482
3483 static struct mlxsw_sp_nexthop_group *
3484 mlxsw_sp_nexthop6_group_lookup(struct mlxsw_sp *mlxsw_sp,
3485                                struct mlxsw_sp_fib6_entry *fib6_entry)
3486 {
3487         struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
3488
3489         cmp_arg.type = MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6;
3490         cmp_arg.fib6_entry = fib6_entry;
3491         return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
3492                                       &cmp_arg,
3493                                       mlxsw_sp_nexthop_group_ht_params);
3494 }
3495
3496 static const struct rhashtable_params mlxsw_sp_nexthop_ht_params = {
3497         .key_offset = offsetof(struct mlxsw_sp_nexthop, key),
3498         .head_offset = offsetof(struct mlxsw_sp_nexthop, ht_node),
3499         .key_len = sizeof(struct mlxsw_sp_nexthop_key),
3500 };
3501
3502 static int mlxsw_sp_nexthop_insert(struct mlxsw_sp *mlxsw_sp,
3503                                    struct mlxsw_sp_nexthop *nh)
3504 {
3505         return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_ht,
3506                                       &nh->ht_node, mlxsw_sp_nexthop_ht_params);
3507 }
3508
3509 static void mlxsw_sp_nexthop_remove(struct mlxsw_sp *mlxsw_sp,
3510                                     struct mlxsw_sp_nexthop *nh)
3511 {
3512         rhashtable_remove_fast(&mlxsw_sp->router->nexthop_ht, &nh->ht_node,
3513                                mlxsw_sp_nexthop_ht_params);
3514 }
3515
3516 static struct mlxsw_sp_nexthop *
3517 mlxsw_sp_nexthop_lookup(struct mlxsw_sp *mlxsw_sp,
3518                         struct mlxsw_sp_nexthop_key key)
3519 {
3520         return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_ht, &key,
3521                                       mlxsw_sp_nexthop_ht_params);
3522 }
3523
3524 static int mlxsw_sp_adj_index_mass_update_vr(struct mlxsw_sp *mlxsw_sp,
3525                                              enum mlxsw_sp_l3proto proto,
3526                                              u16 vr_id,
3527                                              u32 adj_index, u16 ecmp_size,
3528                                              u32 new_adj_index,
3529                                              u16 new_ecmp_size)
3530 {
3531         char raleu_pl[MLXSW_REG_RALEU_LEN];
3532
3533         mlxsw_reg_raleu_pack(raleu_pl,
3534                              (enum mlxsw_reg_ralxx_protocol) proto, vr_id,
3535                              adj_index, ecmp_size, new_adj_index,
3536                              new_ecmp_size);
3537         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raleu), raleu_pl);
3538 }
3539
3540 static int mlxsw_sp_adj_index_mass_update(struct mlxsw_sp *mlxsw_sp,
3541                                           struct mlxsw_sp_nexthop_group *nh_grp,
3542                                           u32 old_adj_index, u16 old_ecmp_size)
3543 {
3544         struct mlxsw_sp_nexthop_group_info *nhgi = nh_grp->nhgi;
3545         struct mlxsw_sp_nexthop_group_vr_entry *vr_entry;
3546         int err;
3547
3548         list_for_each_entry(vr_entry, &nh_grp->vr_list, list) {
3549                 err = mlxsw_sp_adj_index_mass_update_vr(mlxsw_sp,
3550                                                         vr_entry->key.proto,
3551                                                         vr_entry->key.vr_id,
3552                                                         old_adj_index,
3553                                                         old_ecmp_size,
3554                                                         nhgi->adj_index,
3555                                                         nhgi->ecmp_size);
3556                 if (err)
3557                         goto err_mass_update_vr;
3558         }
3559         return 0;
3560
3561 err_mass_update_vr:
3562         list_for_each_entry_continue_reverse(vr_entry, &nh_grp->vr_list, list)
3563                 mlxsw_sp_adj_index_mass_update_vr(mlxsw_sp, vr_entry->key.proto,
3564                                                   vr_entry->key.vr_id,
3565                                                   nhgi->adj_index,
3566                                                   nhgi->ecmp_size,
3567                                                   old_adj_index, old_ecmp_size);
3568         return err;
3569 }
3570
3571 static int __mlxsw_sp_nexthop_eth_update(struct mlxsw_sp *mlxsw_sp,
3572                                          u32 adj_index,
3573                                          struct mlxsw_sp_nexthop *nh,
3574                                          bool force, char *ratr_pl)
3575 {
3576         struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
3577         struct mlxsw_sp_rif *rif = mlxsw_sp_nexthop_rif(nh);
3578         enum mlxsw_reg_ratr_op op;
3579         u16 rif_index;
3580
3581         rif_index = rif ? rif->rif_index :
3582                           mlxsw_sp->router->lb_crif->rif->rif_index;
3583         op = force ? MLXSW_REG_RATR_OP_WRITE_WRITE_ENTRY :
3584                      MLXSW_REG_RATR_OP_WRITE_WRITE_ENTRY_ON_ACTIVITY;
3585         mlxsw_reg_ratr_pack(ratr_pl, op, true, MLXSW_REG_RATR_TYPE_ETHERNET,
3586                             adj_index, rif_index);
3587         switch (nh->action) {
3588         case MLXSW_SP_NEXTHOP_ACTION_FORWARD:
3589                 mlxsw_reg_ratr_eth_entry_pack(ratr_pl, neigh_entry->ha);
3590                 break;
3591         case MLXSW_SP_NEXTHOP_ACTION_DISCARD:
3592                 mlxsw_reg_ratr_trap_action_set(ratr_pl,
3593                                                MLXSW_REG_RATR_TRAP_ACTION_DISCARD_ERRORS);
3594                 break;
3595         case MLXSW_SP_NEXTHOP_ACTION_TRAP:
3596                 mlxsw_reg_ratr_trap_action_set(ratr_pl,
3597                                                MLXSW_REG_RATR_TRAP_ACTION_TRAP);
3598                 mlxsw_reg_ratr_trap_id_set(ratr_pl, MLXSW_TRAP_ID_RTR_EGRESS0);
3599                 break;
3600         default:
3601                 WARN_ON_ONCE(1);
3602                 return -EINVAL;
3603         }
3604         if (nh->counter_valid)
3605                 mlxsw_reg_ratr_counter_pack(ratr_pl, nh->counter_index, true);
3606         else
3607                 mlxsw_reg_ratr_counter_pack(ratr_pl, 0, false);
3608
3609         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ratr), ratr_pl);
3610 }
3611
3612 int mlxsw_sp_nexthop_eth_update(struct mlxsw_sp *mlxsw_sp, u32 adj_index,
3613                                 struct mlxsw_sp_nexthop *nh, bool force,
3614                                 char *ratr_pl)
3615 {
3616         int i;
3617
3618         for (i = 0; i < nh->num_adj_entries; i++) {
3619                 int err;
3620
3621                 err = __mlxsw_sp_nexthop_eth_update(mlxsw_sp, adj_index + i,
3622                                                     nh, force, ratr_pl);
3623                 if (err)
3624                         return err;
3625         }
3626
3627         return 0;
3628 }
3629
3630 static int __mlxsw_sp_nexthop_ipip_update(struct mlxsw_sp *mlxsw_sp,
3631                                           u32 adj_index,
3632                                           struct mlxsw_sp_nexthop *nh,
3633                                           bool force, char *ratr_pl)
3634 {
3635         const struct mlxsw_sp_ipip_ops *ipip_ops;
3636
3637         ipip_ops = mlxsw_sp->router->ipip_ops_arr[nh->ipip_entry->ipipt];
3638         return ipip_ops->nexthop_update(mlxsw_sp, adj_index, nh->ipip_entry,
3639                                         force, ratr_pl);
3640 }
3641
3642 static int mlxsw_sp_nexthop_ipip_update(struct mlxsw_sp *mlxsw_sp,
3643                                         u32 adj_index,
3644                                         struct mlxsw_sp_nexthop *nh, bool force,
3645                                         char *ratr_pl)
3646 {
3647         int i;
3648
3649         for (i = 0; i < nh->num_adj_entries; i++) {
3650                 int err;
3651
3652                 err = __mlxsw_sp_nexthop_ipip_update(mlxsw_sp, adj_index + i,
3653                                                      nh, force, ratr_pl);
3654                 if (err)
3655                         return err;
3656         }
3657
3658         return 0;
3659 }
3660
3661 static int mlxsw_sp_nexthop_update(struct mlxsw_sp *mlxsw_sp, u32 adj_index,
3662                                    struct mlxsw_sp_nexthop *nh, bool force,
3663                                    char *ratr_pl)
3664 {
3665         /* When action is discard or trap, the nexthop must be
3666          * programmed as an Ethernet nexthop.
3667          */
3668         if (nh->type == MLXSW_SP_NEXTHOP_TYPE_ETH ||
3669             nh->action == MLXSW_SP_NEXTHOP_ACTION_DISCARD ||
3670             nh->action == MLXSW_SP_NEXTHOP_ACTION_TRAP)
3671                 return mlxsw_sp_nexthop_eth_update(mlxsw_sp, adj_index, nh,
3672                                                    force, ratr_pl);
3673         else
3674                 return mlxsw_sp_nexthop_ipip_update(mlxsw_sp, adj_index, nh,
3675                                                     force, ratr_pl);
3676 }
3677
3678 static int
3679 mlxsw_sp_nexthop_group_update(struct mlxsw_sp *mlxsw_sp,
3680                               struct mlxsw_sp_nexthop_group_info *nhgi,
3681                               bool reallocate)
3682 {
3683         char ratr_pl[MLXSW_REG_RATR_LEN];
3684         u32 adj_index = nhgi->adj_index; /* base */
3685         struct mlxsw_sp_nexthop *nh;
3686         int i;
3687
3688         for (i = 0; i < nhgi->count; i++) {
3689                 nh = &nhgi->nexthops[i];
3690
3691                 if (!nh->should_offload) {
3692                         nh->offloaded = 0;
3693                         continue;
3694                 }
3695
3696                 if (nh->update || reallocate) {
3697                         int err = 0;
3698
3699                         err = mlxsw_sp_nexthop_update(mlxsw_sp, adj_index, nh,
3700                                                       true, ratr_pl);
3701                         if (err)
3702                                 return err;
3703                         nh->update = 0;
3704                         nh->offloaded = 1;
3705                 }
3706                 adj_index += nh->num_adj_entries;
3707         }
3708         return 0;
3709 }
3710
3711 static int
3712 mlxsw_sp_nexthop_fib_entries_update(struct mlxsw_sp *mlxsw_sp,
3713                                     struct mlxsw_sp_nexthop_group *nh_grp)
3714 {
3715         struct mlxsw_sp_fib_entry *fib_entry;
3716         int err;
3717
3718         list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
3719                 err = mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
3720                 if (err)
3721                         return err;
3722         }
3723         return 0;
3724 }
3725
3726 struct mlxsw_sp_adj_grp_size_range {
3727         u16 start; /* Inclusive */
3728         u16 end; /* Inclusive */
3729 };
3730
3731 /* Ordered by range start value */
3732 static const struct mlxsw_sp_adj_grp_size_range
3733 mlxsw_sp1_adj_grp_size_ranges[] = {
3734         { .start = 1, .end = 64 },
3735         { .start = 512, .end = 512 },
3736         { .start = 1024, .end = 1024 },
3737         { .start = 2048, .end = 2048 },
3738         { .start = 4096, .end = 4096 },
3739 };
3740
3741 /* Ordered by range start value */
3742 static const struct mlxsw_sp_adj_grp_size_range
3743 mlxsw_sp2_adj_grp_size_ranges[] = {
3744         { .start = 1, .end = 128 },
3745         { .start = 256, .end = 256 },
3746         { .start = 512, .end = 512 },
3747         { .start = 1024, .end = 1024 },
3748         { .start = 2048, .end = 2048 },
3749         { .start = 4096, .end = 4096 },
3750 };
3751
3752 static void mlxsw_sp_adj_grp_size_round_up(const struct mlxsw_sp *mlxsw_sp,
3753                                            u16 *p_adj_grp_size)
3754 {
3755         int i;
3756
3757         for (i = 0; i < mlxsw_sp->router->adj_grp_size_ranges_count; i++) {
3758                 const struct mlxsw_sp_adj_grp_size_range *size_range;
3759
3760                 size_range = &mlxsw_sp->router->adj_grp_size_ranges[i];
3761
3762                 if (*p_adj_grp_size >= size_range->start &&
3763                     *p_adj_grp_size <= size_range->end)
3764                         return;
3765
3766                 if (*p_adj_grp_size <= size_range->end) {
3767                         *p_adj_grp_size = size_range->end;
3768                         return;
3769                 }
3770         }
3771 }
3772
3773 static void mlxsw_sp_adj_grp_size_round_down(const struct mlxsw_sp *mlxsw_sp,
3774                                              u16 *p_adj_grp_size,
3775                                              unsigned int alloc_size)
3776 {
3777         int i;
3778
3779         for (i = mlxsw_sp->router->adj_grp_size_ranges_count - 1; i >= 0; i--) {
3780                 const struct mlxsw_sp_adj_grp_size_range *size_range;
3781
3782                 size_range = &mlxsw_sp->router->adj_grp_size_ranges[i];
3783
3784                 if (alloc_size >= size_range->end) {
3785                         *p_adj_grp_size = size_range->end;
3786                         return;
3787                 }
3788         }
3789 }
3790
3791 static int mlxsw_sp_fix_adj_grp_size(struct mlxsw_sp *mlxsw_sp,
3792                                      u16 *p_adj_grp_size)
3793 {
3794         unsigned int alloc_size;
3795         int err;
3796
3797         /* Round up the requested group size to the next size supported
3798          * by the device and make sure the request can be satisfied.
3799          */
3800         mlxsw_sp_adj_grp_size_round_up(mlxsw_sp, p_adj_grp_size);
3801         err = mlxsw_sp_kvdl_alloc_count_query(mlxsw_sp,
3802                                               MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
3803                                               *p_adj_grp_size, &alloc_size);
3804         if (err)
3805                 return err;
3806         /* It is possible the allocation results in more allocated
3807          * entries than requested. Try to use as much of them as
3808          * possible.
3809          */
3810         mlxsw_sp_adj_grp_size_round_down(mlxsw_sp, p_adj_grp_size, alloc_size);
3811
3812         return 0;
3813 }
3814
3815 static void
3816 mlxsw_sp_nexthop_group_normalize(struct mlxsw_sp_nexthop_group_info *nhgi)
3817 {
3818         int i, g = 0, sum_norm_weight = 0;
3819         struct mlxsw_sp_nexthop *nh;
3820
3821         for (i = 0; i < nhgi->count; i++) {
3822                 nh = &nhgi->nexthops[i];
3823
3824                 if (!nh->should_offload)
3825                         continue;
3826                 if (g > 0)
3827                         g = gcd(nh->nh_weight, g);
3828                 else
3829                         g = nh->nh_weight;
3830         }
3831
3832         for (i = 0; i < nhgi->count; i++) {
3833                 nh = &nhgi->nexthops[i];
3834
3835                 if (!nh->should_offload)
3836                         continue;
3837                 nh->norm_nh_weight = nh->nh_weight / g;
3838                 sum_norm_weight += nh->norm_nh_weight;
3839         }
3840
3841         nhgi->sum_norm_weight = sum_norm_weight;
3842 }
3843
3844 static void
3845 mlxsw_sp_nexthop_group_rebalance(struct mlxsw_sp_nexthop_group_info *nhgi)
3846 {
3847         int i, weight = 0, lower_bound = 0;
3848         int total = nhgi->sum_norm_weight;
3849         u16 ecmp_size = nhgi->ecmp_size;
3850
3851         for (i = 0; i < nhgi->count; i++) {
3852                 struct mlxsw_sp_nexthop *nh = &nhgi->nexthops[i];
3853                 int upper_bound;
3854
3855                 if (!nh->should_offload)
3856                         continue;
3857                 weight += nh->norm_nh_weight;
3858                 upper_bound = DIV_ROUND_CLOSEST(ecmp_size * weight, total);
3859                 nh->num_adj_entries = upper_bound - lower_bound;
3860                 lower_bound = upper_bound;
3861         }
3862 }
3863
3864 static struct mlxsw_sp_nexthop *
3865 mlxsw_sp_rt6_nexthop(struct mlxsw_sp_nexthop_group *nh_grp,
3866                      const struct mlxsw_sp_rt6 *mlxsw_sp_rt6);
3867
3868 static void
3869 mlxsw_sp_nexthop4_group_offload_refresh(struct mlxsw_sp *mlxsw_sp,
3870                                         struct mlxsw_sp_nexthop_group *nh_grp)
3871 {
3872         int i;
3873
3874         for (i = 0; i < nh_grp->nhgi->count; i++) {
3875                 struct mlxsw_sp_nexthop *nh = &nh_grp->nhgi->nexthops[i];
3876
3877                 if (nh->offloaded)
3878                         nh->key.fib_nh->fib_nh_flags |= RTNH_F_OFFLOAD;
3879                 else
3880                         nh->key.fib_nh->fib_nh_flags &= ~RTNH_F_OFFLOAD;
3881         }
3882 }
3883
3884 static void
3885 __mlxsw_sp_nexthop6_group_offload_refresh(struct mlxsw_sp_nexthop_group *nh_grp,
3886                                           struct mlxsw_sp_fib6_entry *fib6_entry)
3887 {
3888         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3889
3890         list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
3891                 struct fib6_nh *fib6_nh = mlxsw_sp_rt6->rt->fib6_nh;
3892                 struct mlxsw_sp_nexthop *nh;
3893
3894                 nh = mlxsw_sp_rt6_nexthop(nh_grp, mlxsw_sp_rt6);
3895                 if (nh && nh->offloaded)
3896                         fib6_nh->fib_nh_flags |= RTNH_F_OFFLOAD;
3897                 else
3898                         fib6_nh->fib_nh_flags &= ~RTNH_F_OFFLOAD;
3899         }
3900 }
3901
3902 static void
3903 mlxsw_sp_nexthop6_group_offload_refresh(struct mlxsw_sp *mlxsw_sp,
3904                                         struct mlxsw_sp_nexthop_group *nh_grp)
3905 {
3906         struct mlxsw_sp_fib6_entry *fib6_entry;
3907
3908         /* Unfortunately, in IPv6 the route and the nexthop are described by
3909          * the same struct, so we need to iterate over all the routes using the
3910          * nexthop group and set / clear the offload indication for them.
3911          */
3912         list_for_each_entry(fib6_entry, &nh_grp->fib_list,
3913                             common.nexthop_group_node)
3914                 __mlxsw_sp_nexthop6_group_offload_refresh(nh_grp, fib6_entry);
3915 }
3916
3917 static void
3918 mlxsw_sp_nexthop_bucket_offload_refresh(struct mlxsw_sp *mlxsw_sp,
3919                                         const struct mlxsw_sp_nexthop *nh,
3920                                         u16 bucket_index)
3921 {
3922         struct mlxsw_sp_nexthop_group *nh_grp = nh->nhgi->nh_grp;
3923         bool offload = false, trap = false;
3924
3925         if (nh->offloaded) {
3926                 if (nh->action == MLXSW_SP_NEXTHOP_ACTION_TRAP)
3927                         trap = true;
3928                 else
3929                         offload = true;
3930         }
3931         nexthop_bucket_set_hw_flags(mlxsw_sp_net(mlxsw_sp), nh_grp->obj.id,
3932                                     bucket_index, offload, trap);
3933 }
3934
3935 static void
3936 mlxsw_sp_nexthop_obj_group_offload_refresh(struct mlxsw_sp *mlxsw_sp,
3937                                            struct mlxsw_sp_nexthop_group *nh_grp)
3938 {
3939         int i;
3940
3941         /* Do not update the flags if the nexthop group is being destroyed
3942          * since:
3943          * 1. The nexthop objects is being deleted, in which case the flags are
3944          * irrelevant.
3945          * 2. The nexthop group was replaced by a newer group, in which case
3946          * the flags of the nexthop object were already updated based on the
3947          * new group.
3948          */
3949         if (nh_grp->can_destroy)
3950                 return;
3951
3952         nexthop_set_hw_flags(mlxsw_sp_net(mlxsw_sp), nh_grp->obj.id,
3953                              nh_grp->nhgi->adj_index_valid, false);
3954
3955         /* Update flags of individual nexthop buckets in case of a resilient
3956          * nexthop group.
3957          */
3958         if (!nh_grp->nhgi->is_resilient)
3959                 return;
3960
3961         for (i = 0; i < nh_grp->nhgi->count; i++) {
3962                 struct mlxsw_sp_nexthop *nh = &nh_grp->nhgi->nexthops[i];
3963
3964                 mlxsw_sp_nexthop_bucket_offload_refresh(mlxsw_sp, nh, i);
3965         }
3966 }
3967
3968 static void
3969 mlxsw_sp_nexthop_group_offload_refresh(struct mlxsw_sp *mlxsw_sp,
3970                                        struct mlxsw_sp_nexthop_group *nh_grp)
3971 {
3972         switch (nh_grp->type) {
3973         case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4:
3974                 mlxsw_sp_nexthop4_group_offload_refresh(mlxsw_sp, nh_grp);
3975                 break;
3976         case MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6:
3977                 mlxsw_sp_nexthop6_group_offload_refresh(mlxsw_sp, nh_grp);
3978                 break;
3979         case MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ:
3980                 mlxsw_sp_nexthop_obj_group_offload_refresh(mlxsw_sp, nh_grp);
3981                 break;
3982         }
3983 }
3984
3985 static int
3986 mlxsw_sp_nexthop_group_refresh(struct mlxsw_sp *mlxsw_sp,
3987                                struct mlxsw_sp_nexthop_group *nh_grp)
3988 {
3989         struct mlxsw_sp_nexthop_group_info *nhgi = nh_grp->nhgi;
3990         u16 ecmp_size, old_ecmp_size;
3991         struct mlxsw_sp_nexthop *nh;
3992         bool offload_change = false;
3993         u32 adj_index;
3994         bool old_adj_index_valid;
3995         u32 old_adj_index;
3996         int i, err2, err;
3997
3998         if (!nhgi->gateway)
3999                 return mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
4000
4001         for (i = 0; i < nhgi->count; i++) {
4002                 nh = &nhgi->nexthops[i];
4003
4004                 if (nh->should_offload != nh->offloaded) {
4005                         offload_change = true;
4006                         if (nh->should_offload)
4007                                 nh->update = 1;
4008                 }
4009         }
4010         if (!offload_change) {
4011                 /* Nothing was added or removed, so no need to reallocate. Just
4012                  * update MAC on existing adjacency indexes.
4013                  */
4014                 err = mlxsw_sp_nexthop_group_update(mlxsw_sp, nhgi, false);
4015                 if (err) {
4016                         dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
4017                         goto set_trap;
4018                 }
4019                 /* Flags of individual nexthop buckets might need to be
4020                  * updated.
4021                  */
4022                 mlxsw_sp_nexthop_group_offload_refresh(mlxsw_sp, nh_grp);
4023                 return 0;
4024         }
4025         mlxsw_sp_nexthop_group_normalize(nhgi);
4026         if (!nhgi->sum_norm_weight) {
4027                 /* No neigh of this group is connected so we just set
4028                  * the trap and let everthing flow through kernel.
4029                  */
4030                 err = 0;
4031                 goto set_trap;
4032         }
4033
4034         ecmp_size = nhgi->sum_norm_weight;
4035         err = mlxsw_sp_fix_adj_grp_size(mlxsw_sp, &ecmp_size);
4036         if (err)
4037                 /* No valid allocation size available. */
4038                 goto set_trap;
4039
4040         err = mlxsw_sp_kvdl_alloc(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
4041                                   ecmp_size, &adj_index);
4042         if (err) {
4043                 /* We ran out of KVD linear space, just set the
4044                  * trap and let everything flow through kernel.
4045                  */
4046                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to allocate KVD linear area for nexthop group.\n");
4047                 goto set_trap;
4048         }
4049         old_adj_index_valid = nhgi->adj_index_valid;
4050         old_adj_index = nhgi->adj_index;
4051         old_ecmp_size = nhgi->ecmp_size;
4052         nhgi->adj_index_valid = 1;
4053         nhgi->adj_index = adj_index;
4054         nhgi->ecmp_size = ecmp_size;
4055         mlxsw_sp_nexthop_group_rebalance(nhgi);
4056         err = mlxsw_sp_nexthop_group_update(mlxsw_sp, nhgi, true);
4057         if (err) {
4058                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
4059                 goto set_trap;
4060         }
4061
4062         mlxsw_sp_nexthop_group_offload_refresh(mlxsw_sp, nh_grp);
4063
4064         if (!old_adj_index_valid) {
4065                 /* The trap was set for fib entries, so we have to call
4066                  * fib entry update to unset it and use adjacency index.
4067                  */
4068                 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
4069                 if (err) {
4070                         dev_warn(mlxsw_sp->bus_info->dev, "Failed to add adjacency index to fib entries.\n");
4071                         goto set_trap;
4072                 }
4073                 return 0;
4074         }
4075
4076         err = mlxsw_sp_adj_index_mass_update(mlxsw_sp, nh_grp,
4077                                              old_adj_index, old_ecmp_size);
4078         mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
4079                            old_ecmp_size, old_adj_index);
4080         if (err) {
4081                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to mass-update adjacency index for nexthop group.\n");
4082                 goto set_trap;
4083         }
4084
4085         return 0;
4086
4087 set_trap:
4088         old_adj_index_valid = nhgi->adj_index_valid;
4089         nhgi->adj_index_valid = 0;
4090         for (i = 0; i < nhgi->count; i++) {
4091                 nh = &nhgi->nexthops[i];
4092                 nh->offloaded = 0;
4093         }
4094         err2 = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
4095         if (err2)
4096                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to set traps for fib entries.\n");
4097         mlxsw_sp_nexthop_group_offload_refresh(mlxsw_sp, nh_grp);
4098         if (old_adj_index_valid)
4099                 mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
4100                                    nhgi->ecmp_size, nhgi->adj_index);
4101         return err;
4102 }
4103
4104 static void __mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp_nexthop *nh,
4105                                             bool removing)
4106 {
4107         if (!removing) {
4108                 nh->action = MLXSW_SP_NEXTHOP_ACTION_FORWARD;
4109                 nh->should_offload = 1;
4110         } else if (nh->nhgi->is_resilient) {
4111                 nh->action = MLXSW_SP_NEXTHOP_ACTION_TRAP;
4112                 nh->should_offload = 1;
4113         } else {
4114                 nh->should_offload = 0;
4115         }
4116         nh->update = 1;
4117 }
4118
4119 static int
4120 mlxsw_sp_nexthop_dead_neigh_replace(struct mlxsw_sp *mlxsw_sp,
4121                                     struct mlxsw_sp_neigh_entry *neigh_entry)
4122 {
4123         struct neighbour *n, *old_n = neigh_entry->key.n;
4124         struct mlxsw_sp_nexthop *nh;
4125         struct net_device *dev;
4126         bool entry_connected;
4127         u8 nud_state, dead;
4128         int err;
4129
4130         nh = list_first_entry(&neigh_entry->nexthop_list,
4131                               struct mlxsw_sp_nexthop, neigh_list_node);
4132         dev = mlxsw_sp_nexthop_dev(nh);
4133
4134         n = neigh_lookup(nh->neigh_tbl, &nh->gw_addr, dev);
4135         if (!n) {
4136                 n = neigh_create(nh->neigh_tbl, &nh->gw_addr, dev);
4137                 if (IS_ERR(n))
4138                         return PTR_ERR(n);
4139                 neigh_event_send(n, NULL);
4140         }
4141
4142         mlxsw_sp_neigh_entry_remove(mlxsw_sp, neigh_entry);
4143         neigh_entry->key.n = n;
4144         err = mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry);
4145         if (err)
4146                 goto err_neigh_entry_insert;
4147
4148         read_lock_bh(&n->lock);
4149         nud_state = n->nud_state;
4150         dead = n->dead;
4151         read_unlock_bh(&n->lock);
4152         entry_connected = nud_state & NUD_VALID && !dead;
4153
4154         list_for_each_entry(nh, &neigh_entry->nexthop_list,
4155                             neigh_list_node) {
4156                 neigh_release(old_n);
4157                 neigh_clone(n);
4158                 __mlxsw_sp_nexthop_neigh_update(nh, !entry_connected);
4159                 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nhgi->nh_grp);
4160         }
4161
4162         neigh_release(n);
4163
4164         return 0;
4165
4166 err_neigh_entry_insert:
4167         neigh_entry->key.n = old_n;
4168         mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry);
4169         neigh_release(n);
4170         return err;
4171 }
4172
4173 static void
4174 mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
4175                               struct mlxsw_sp_neigh_entry *neigh_entry,
4176                               bool removing, bool dead)
4177 {
4178         struct mlxsw_sp_nexthop *nh;
4179
4180         if (list_empty(&neigh_entry->nexthop_list))
4181                 return;
4182
4183         if (dead) {
4184                 int err;
4185
4186                 err = mlxsw_sp_nexthop_dead_neigh_replace(mlxsw_sp,
4187                                                           neigh_entry);
4188                 if (err)
4189                         dev_err(mlxsw_sp->bus_info->dev, "Failed to replace dead neigh\n");
4190                 return;
4191         }
4192
4193         list_for_each_entry(nh, &neigh_entry->nexthop_list,
4194                             neigh_list_node) {
4195                 __mlxsw_sp_nexthop_neigh_update(nh, removing);
4196                 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nhgi->nh_grp);
4197         }
4198 }
4199
4200 static void mlxsw_sp_nexthop_crif_init(struct mlxsw_sp_nexthop *nh,
4201                                        struct mlxsw_sp_crif *crif)
4202 {
4203         if (nh->crif)
4204                 return;
4205
4206         nh->crif = crif;
4207         list_add(&nh->crif_list_node, &crif->nexthop_list);
4208 }
4209
4210 static void mlxsw_sp_nexthop_crif_fini(struct mlxsw_sp_nexthop *nh)
4211 {
4212         if (!nh->crif)
4213                 return;
4214
4215         list_del(&nh->crif_list_node);
4216         nh->crif = NULL;
4217 }
4218
4219 static int mlxsw_sp_nexthop_neigh_init(struct mlxsw_sp *mlxsw_sp,
4220                                        struct mlxsw_sp_nexthop *nh)
4221 {
4222         struct mlxsw_sp_neigh_entry *neigh_entry;
4223         struct net_device *dev;
4224         struct neighbour *n;
4225         u8 nud_state, dead;
4226         int err;
4227
4228         if (WARN_ON(!nh->crif->rif))
4229                 return 0;
4230
4231         if (!nh->nhgi->gateway || nh->neigh_entry)
4232                 return 0;
4233         dev = mlxsw_sp_nexthop_dev(nh);
4234
4235         /* Take a reference of neigh here ensuring that neigh would
4236          * not be destructed before the nexthop entry is finished.
4237          * The reference is taken either in neigh_lookup() or
4238          * in neigh_create() in case n is not found.
4239          */
4240         n = neigh_lookup(nh->neigh_tbl, &nh->gw_addr, dev);
4241         if (!n) {
4242                 n = neigh_create(nh->neigh_tbl, &nh->gw_addr, dev);
4243                 if (IS_ERR(n))
4244                         return PTR_ERR(n);
4245                 neigh_event_send(n, NULL);
4246         }
4247         neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
4248         if (!neigh_entry) {
4249                 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
4250                 if (IS_ERR(neigh_entry)) {
4251                         err = -EINVAL;
4252                         goto err_neigh_entry_create;
4253                 }
4254         }
4255
4256         /* If that is the first nexthop connected to that neigh, add to
4257          * nexthop_neighs_list
4258          */
4259         if (list_empty(&neigh_entry->nexthop_list))
4260                 list_add_tail(&neigh_entry->nexthop_neighs_list_node,
4261                               &mlxsw_sp->router->nexthop_neighs_list);
4262
4263         nh->neigh_entry = neigh_entry;
4264         list_add_tail(&nh->neigh_list_node, &neigh_entry->nexthop_list);
4265         read_lock_bh(&n->lock);
4266         nud_state = n->nud_state;
4267         dead = n->dead;
4268         read_unlock_bh(&n->lock);
4269         __mlxsw_sp_nexthop_neigh_update(nh, !(nud_state & NUD_VALID && !dead));
4270
4271         return 0;
4272
4273 err_neigh_entry_create:
4274         neigh_release(n);
4275         return err;
4276 }
4277
4278 static void mlxsw_sp_nexthop_neigh_fini(struct mlxsw_sp *mlxsw_sp,
4279                                         struct mlxsw_sp_nexthop *nh)
4280 {
4281         struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
4282         struct neighbour *n;
4283
4284         if (!neigh_entry)
4285                 return;
4286         n = neigh_entry->key.n;
4287
4288         __mlxsw_sp_nexthop_neigh_update(nh, true);
4289         list_del(&nh->neigh_list_node);
4290         nh->neigh_entry = NULL;
4291
4292         /* If that is the last nexthop connected to that neigh, remove from
4293          * nexthop_neighs_list
4294          */
4295         if (list_empty(&neigh_entry->nexthop_list))
4296                 list_del(&neigh_entry->nexthop_neighs_list_node);
4297
4298         if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
4299                 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
4300
4301         neigh_release(n);
4302 }
4303
4304 static bool mlxsw_sp_ipip_netdev_ul_up(struct net_device *ol_dev)
4305 {
4306         struct net_device *ul_dev;
4307         bool is_up;
4308
4309         rcu_read_lock();
4310         ul_dev = mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev);
4311         is_up = ul_dev ? (ul_dev->flags & IFF_UP) : true;
4312         rcu_read_unlock();
4313
4314         return is_up;
4315 }
4316
4317 static void mlxsw_sp_nexthop_ipip_init(struct mlxsw_sp *mlxsw_sp,
4318                                        struct mlxsw_sp_nexthop *nh,
4319                                        struct mlxsw_sp_ipip_entry *ipip_entry)
4320 {
4321         struct mlxsw_sp_crif *crif;
4322         bool removing;
4323
4324         if (!nh->nhgi->gateway || nh->ipip_entry)
4325                 return;
4326
4327         crif = mlxsw_sp_crif_lookup(mlxsw_sp->router, ipip_entry->ol_dev);
4328         if (WARN_ON(!crif))
4329                 return;
4330
4331         nh->ipip_entry = ipip_entry;
4332         removing = !mlxsw_sp_ipip_netdev_ul_up(ipip_entry->ol_dev);
4333         __mlxsw_sp_nexthop_neigh_update(nh, removing);
4334         mlxsw_sp_nexthop_crif_init(nh, crif);
4335 }
4336
4337 static void mlxsw_sp_nexthop_ipip_fini(struct mlxsw_sp *mlxsw_sp,
4338                                        struct mlxsw_sp_nexthop *nh)
4339 {
4340         struct mlxsw_sp_ipip_entry *ipip_entry = nh->ipip_entry;
4341
4342         if (!ipip_entry)
4343                 return;
4344
4345         __mlxsw_sp_nexthop_neigh_update(nh, true);
4346         nh->ipip_entry = NULL;
4347 }
4348
4349 static bool mlxsw_sp_nexthop4_ipip_type(const struct mlxsw_sp *mlxsw_sp,
4350                                         const struct fib_nh *fib_nh,
4351                                         enum mlxsw_sp_ipip_type *p_ipipt)
4352 {
4353         struct net_device *dev = fib_nh->fib_nh_dev;
4354
4355         return dev &&
4356                fib_nh->nh_parent->fib_type == RTN_UNICAST &&
4357                mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, p_ipipt);
4358 }
4359
4360 static int mlxsw_sp_nexthop_type_init(struct mlxsw_sp *mlxsw_sp,
4361                                       struct mlxsw_sp_nexthop *nh,
4362                                       const struct net_device *dev)
4363 {
4364         const struct mlxsw_sp_ipip_ops *ipip_ops;
4365         struct mlxsw_sp_ipip_entry *ipip_entry;
4366         struct mlxsw_sp_crif *crif;
4367         int err;
4368
4369         ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, dev);
4370         if (ipip_entry) {
4371                 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
4372                 if (ipip_ops->can_offload(mlxsw_sp, dev)) {
4373                         nh->type = MLXSW_SP_NEXTHOP_TYPE_IPIP;
4374                         mlxsw_sp_nexthop_ipip_init(mlxsw_sp, nh, ipip_entry);
4375                         return 0;
4376                 }
4377         }
4378
4379         nh->type = MLXSW_SP_NEXTHOP_TYPE_ETH;
4380         crif = mlxsw_sp_crif_lookup(mlxsw_sp->router, dev);
4381         if (!crif)
4382                 return 0;
4383
4384         mlxsw_sp_nexthop_crif_init(nh, crif);
4385
4386         if (!crif->rif)
4387                 return 0;
4388
4389         err = mlxsw_sp_nexthop_neigh_init(mlxsw_sp, nh);
4390         if (err)
4391                 goto err_neigh_init;
4392
4393         return 0;
4394
4395 err_neigh_init:
4396         mlxsw_sp_nexthop_crif_fini(nh);
4397         return err;
4398 }
4399
4400 static void mlxsw_sp_nexthop_type_rif_gone(struct mlxsw_sp *mlxsw_sp,
4401                                            struct mlxsw_sp_nexthop *nh)
4402 {
4403         switch (nh->type) {
4404         case MLXSW_SP_NEXTHOP_TYPE_ETH:
4405                 mlxsw_sp_nexthop_neigh_fini(mlxsw_sp, nh);
4406                 break;
4407         case MLXSW_SP_NEXTHOP_TYPE_IPIP:
4408                 mlxsw_sp_nexthop_ipip_fini(mlxsw_sp, nh);
4409                 break;
4410         }
4411 }
4412
4413 static void mlxsw_sp_nexthop_type_fini(struct mlxsw_sp *mlxsw_sp,
4414                                        struct mlxsw_sp_nexthop *nh)
4415 {
4416         mlxsw_sp_nexthop_type_rif_gone(mlxsw_sp, nh);
4417         mlxsw_sp_nexthop_crif_fini(nh);
4418 }
4419
4420 static int mlxsw_sp_nexthop4_init(struct mlxsw_sp *mlxsw_sp,
4421                                   struct mlxsw_sp_nexthop_group *nh_grp,
4422                                   struct mlxsw_sp_nexthop *nh,
4423                                   struct fib_nh *fib_nh)
4424 {
4425         struct net_device *dev = fib_nh->fib_nh_dev;
4426         struct in_device *in_dev;
4427         int err;
4428
4429         nh->nhgi = nh_grp->nhgi;
4430         nh->key.fib_nh = fib_nh;
4431 #ifdef CONFIG_IP_ROUTE_MULTIPATH
4432         nh->nh_weight = fib_nh->fib_nh_weight;
4433 #else
4434         nh->nh_weight = 1;
4435 #endif
4436         memcpy(&nh->gw_addr, &fib_nh->fib_nh_gw4, sizeof(fib_nh->fib_nh_gw4));
4437         nh->neigh_tbl = &arp_tbl;
4438         err = mlxsw_sp_nexthop_insert(mlxsw_sp, nh);
4439         if (err)
4440                 return err;
4441
4442         mlxsw_sp_nexthop_counter_alloc(mlxsw_sp, nh);
4443         list_add_tail(&nh->router_list_node, &mlxsw_sp->router->nexthop_list);
4444
4445         if (!dev)
4446                 return 0;
4447         nh->ifindex = dev->ifindex;
4448
4449         rcu_read_lock();
4450         in_dev = __in_dev_get_rcu(dev);
4451         if (in_dev && IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
4452             fib_nh->fib_nh_flags & RTNH_F_LINKDOWN) {
4453                 rcu_read_unlock();
4454                 return 0;
4455         }
4456         rcu_read_unlock();
4457
4458         err = mlxsw_sp_nexthop_type_init(mlxsw_sp, nh, dev);
4459         if (err)
4460                 goto err_nexthop_neigh_init;
4461
4462         return 0;
4463
4464 err_nexthop_neigh_init:
4465         list_del(&nh->router_list_node);
4466         mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
4467         mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
4468         return err;
4469 }
4470
4471 static void mlxsw_sp_nexthop4_fini(struct mlxsw_sp *mlxsw_sp,
4472                                    struct mlxsw_sp_nexthop *nh)
4473 {
4474         mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
4475         list_del(&nh->router_list_node);
4476         mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
4477         mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
4478 }
4479
4480 static void mlxsw_sp_nexthop4_event(struct mlxsw_sp *mlxsw_sp,
4481                                     unsigned long event, struct fib_nh *fib_nh)
4482 {
4483         struct mlxsw_sp_nexthop_key key;
4484         struct mlxsw_sp_nexthop *nh;
4485
4486         key.fib_nh = fib_nh;
4487         nh = mlxsw_sp_nexthop_lookup(mlxsw_sp, key);
4488         if (!nh)
4489                 return;
4490
4491         switch (event) {
4492         case FIB_EVENT_NH_ADD:
4493                 mlxsw_sp_nexthop_type_init(mlxsw_sp, nh, fib_nh->fib_nh_dev);
4494                 break;
4495         case FIB_EVENT_NH_DEL:
4496                 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
4497                 break;
4498         }
4499
4500         mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nhgi->nh_grp);
4501 }
4502
4503 static void mlxsw_sp_nexthop_rif_update(struct mlxsw_sp *mlxsw_sp,
4504                                         struct mlxsw_sp_rif *rif)
4505 {
4506         struct net_device *dev = mlxsw_sp_rif_dev(rif);
4507         struct mlxsw_sp_nexthop *nh;
4508         bool removing;
4509
4510         list_for_each_entry(nh, &rif->crif->nexthop_list, crif_list_node) {
4511                 switch (nh->type) {
4512                 case MLXSW_SP_NEXTHOP_TYPE_ETH:
4513                         removing = false;
4514                         break;
4515                 case MLXSW_SP_NEXTHOP_TYPE_IPIP:
4516                         removing = !mlxsw_sp_ipip_netdev_ul_up(dev);
4517                         break;
4518                 default:
4519                         WARN_ON(1);
4520                         continue;
4521                 }
4522
4523                 __mlxsw_sp_nexthop_neigh_update(nh, removing);
4524                 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nhgi->nh_grp);
4525         }
4526 }
4527
4528 static void mlxsw_sp_nexthop_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
4529                                            struct mlxsw_sp_rif *rif)
4530 {
4531         struct mlxsw_sp_nexthop *nh, *tmp;
4532
4533         list_for_each_entry_safe(nh, tmp, &rif->crif->nexthop_list,
4534                                  crif_list_node) {
4535                 mlxsw_sp_nexthop_type_rif_gone(mlxsw_sp, nh);
4536                 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nhgi->nh_grp);
4537         }
4538 }
4539
4540 static int mlxsw_sp_adj_trap_entry_init(struct mlxsw_sp *mlxsw_sp)
4541 {
4542         enum mlxsw_reg_ratr_trap_action trap_action;
4543         char ratr_pl[MLXSW_REG_RATR_LEN];
4544         int err;
4545
4546         err = mlxsw_sp_kvdl_alloc(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
4547                                   &mlxsw_sp->router->adj_trap_index);
4548         if (err)
4549                 return err;
4550
4551         trap_action = MLXSW_REG_RATR_TRAP_ACTION_TRAP;
4552         mlxsw_reg_ratr_pack(ratr_pl, MLXSW_REG_RATR_OP_WRITE_WRITE_ENTRY, true,
4553                             MLXSW_REG_RATR_TYPE_ETHERNET,
4554                             mlxsw_sp->router->adj_trap_index,
4555                             mlxsw_sp->router->lb_crif->rif->rif_index);
4556         mlxsw_reg_ratr_trap_action_set(ratr_pl, trap_action);
4557         mlxsw_reg_ratr_trap_id_set(ratr_pl, MLXSW_TRAP_ID_RTR_EGRESS0);
4558         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ratr), ratr_pl);
4559         if (err)
4560                 goto err_ratr_write;
4561
4562         return 0;
4563
4564 err_ratr_write:
4565         mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
4566                            mlxsw_sp->router->adj_trap_index);
4567         return err;
4568 }
4569
4570 static void mlxsw_sp_adj_trap_entry_fini(struct mlxsw_sp *mlxsw_sp)
4571 {
4572         mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
4573                            mlxsw_sp->router->adj_trap_index);
4574 }
4575
4576 static int mlxsw_sp_nexthop_group_inc(struct mlxsw_sp *mlxsw_sp)
4577 {
4578         int err;
4579
4580         if (refcount_inc_not_zero(&mlxsw_sp->router->num_groups))
4581                 return 0;
4582
4583         err = mlxsw_sp_adj_trap_entry_init(mlxsw_sp);
4584         if (err)
4585                 return err;
4586
4587         refcount_set(&mlxsw_sp->router->num_groups, 1);
4588
4589         return 0;
4590 }
4591
4592 static void mlxsw_sp_nexthop_group_dec(struct mlxsw_sp *mlxsw_sp)
4593 {
4594         if (!refcount_dec_and_test(&mlxsw_sp->router->num_groups))
4595                 return;
4596
4597         mlxsw_sp_adj_trap_entry_fini(mlxsw_sp);
4598 }
4599
4600 static void
4601 mlxsw_sp_nh_grp_activity_get(struct mlxsw_sp *mlxsw_sp,
4602                              const struct mlxsw_sp_nexthop_group *nh_grp,
4603                              unsigned long *activity)
4604 {
4605         char *ratrad_pl;
4606         int i, err;
4607
4608         ratrad_pl = kmalloc(MLXSW_REG_RATRAD_LEN, GFP_KERNEL);
4609         if (!ratrad_pl)
4610                 return;
4611
4612         mlxsw_reg_ratrad_pack(ratrad_pl, nh_grp->nhgi->adj_index,
4613                               nh_grp->nhgi->count);
4614         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ratrad), ratrad_pl);
4615         if (err)
4616                 goto out;
4617
4618         for (i = 0; i < nh_grp->nhgi->count; i++) {
4619                 if (!mlxsw_reg_ratrad_activity_vector_get(ratrad_pl, i))
4620                         continue;
4621                 bitmap_set(activity, i, 1);
4622         }
4623
4624 out:
4625         kfree(ratrad_pl);
4626 }
4627
4628 #define MLXSW_SP_NH_GRP_ACTIVITY_UPDATE_INTERVAL 1000 /* ms */
4629
4630 static void
4631 mlxsw_sp_nh_grp_activity_update(struct mlxsw_sp *mlxsw_sp,
4632                                 const struct mlxsw_sp_nexthop_group *nh_grp)
4633 {
4634         unsigned long *activity;
4635
4636         activity = bitmap_zalloc(nh_grp->nhgi->count, GFP_KERNEL);
4637         if (!activity)
4638                 return;
4639
4640         mlxsw_sp_nh_grp_activity_get(mlxsw_sp, nh_grp, activity);
4641         nexthop_res_grp_activity_update(mlxsw_sp_net(mlxsw_sp), nh_grp->obj.id,
4642                                         nh_grp->nhgi->count, activity);
4643
4644         bitmap_free(activity);
4645 }
4646
4647 static void
4648 mlxsw_sp_nh_grp_activity_work_schedule(struct mlxsw_sp *mlxsw_sp)
4649 {
4650         unsigned int interval = MLXSW_SP_NH_GRP_ACTIVITY_UPDATE_INTERVAL;
4651
4652         mlxsw_core_schedule_dw(&mlxsw_sp->router->nh_grp_activity_dw,
4653                                msecs_to_jiffies(interval));
4654 }
4655
4656 static void mlxsw_sp_nh_grp_activity_work(struct work_struct *work)
4657 {
4658         struct mlxsw_sp_nexthop_group_info *nhgi;
4659         struct mlxsw_sp_router *router;
4660         bool reschedule = false;
4661
4662         router = container_of(work, struct mlxsw_sp_router,
4663                               nh_grp_activity_dw.work);
4664
4665         mutex_lock(&router->lock);
4666
4667         list_for_each_entry(nhgi, &router->nh_res_grp_list, list) {
4668                 mlxsw_sp_nh_grp_activity_update(router->mlxsw_sp, nhgi->nh_grp);
4669                 reschedule = true;
4670         }
4671
4672         mutex_unlock(&router->lock);
4673
4674         if (!reschedule)
4675                 return;
4676         mlxsw_sp_nh_grp_activity_work_schedule(router->mlxsw_sp);
4677 }
4678
4679 static int
4680 mlxsw_sp_nexthop_obj_single_validate(struct mlxsw_sp *mlxsw_sp,
4681                                      const struct nh_notifier_single_info *nh,
4682                                      struct netlink_ext_ack *extack)
4683 {
4684         int err = -EINVAL;
4685
4686         if (nh->is_fdb)
4687                 NL_SET_ERR_MSG_MOD(extack, "FDB nexthops are not supported");
4688         else if (nh->has_encap)
4689                 NL_SET_ERR_MSG_MOD(extack, "Encapsulating nexthops are not supported");
4690         else
4691                 err = 0;
4692
4693         return err;
4694 }
4695
4696 static int
4697 mlxsw_sp_nexthop_obj_group_entry_validate(struct mlxsw_sp *mlxsw_sp,
4698                                           const struct nh_notifier_single_info *nh,
4699                                           struct netlink_ext_ack *extack)
4700 {
4701         int err;
4702
4703         err = mlxsw_sp_nexthop_obj_single_validate(mlxsw_sp, nh, extack);
4704         if (err)
4705                 return err;
4706
4707         /* Device only nexthops with an IPIP device are programmed as
4708          * encapsulating adjacency entries.
4709          */
4710         if (!nh->gw_family && !nh->is_reject &&
4711             !mlxsw_sp_netdev_ipip_type(mlxsw_sp, nh->dev, NULL)) {
4712                 NL_SET_ERR_MSG_MOD(extack, "Nexthop group entry does not have a gateway");
4713                 return -EINVAL;
4714         }
4715
4716         return 0;
4717 }
4718
4719 static int
4720 mlxsw_sp_nexthop_obj_group_validate(struct mlxsw_sp *mlxsw_sp,
4721                                     const struct nh_notifier_grp_info *nh_grp,
4722                                     struct netlink_ext_ack *extack)
4723 {
4724         int i;
4725
4726         if (nh_grp->is_fdb) {
4727                 NL_SET_ERR_MSG_MOD(extack, "FDB nexthop groups are not supported");
4728                 return -EINVAL;
4729         }
4730
4731         for (i = 0; i < nh_grp->num_nh; i++) {
4732                 const struct nh_notifier_single_info *nh;
4733                 int err;
4734
4735                 nh = &nh_grp->nh_entries[i].nh;
4736                 err = mlxsw_sp_nexthop_obj_group_entry_validate(mlxsw_sp, nh,
4737                                                                 extack);
4738                 if (err)
4739                         return err;
4740         }
4741
4742         return 0;
4743 }
4744
4745 static int
4746 mlxsw_sp_nexthop_obj_res_group_size_validate(struct mlxsw_sp *mlxsw_sp,
4747                                              const struct nh_notifier_res_table_info *nh_res_table,
4748                                              struct netlink_ext_ack *extack)
4749 {
4750         unsigned int alloc_size;
4751         bool valid_size = false;
4752         int err, i;
4753
4754         if (nh_res_table->num_nh_buckets < 32) {
4755                 NL_SET_ERR_MSG_MOD(extack, "Minimum number of buckets is 32");
4756                 return -EINVAL;
4757         }
4758
4759         for (i = 0; i < mlxsw_sp->router->adj_grp_size_ranges_count; i++) {
4760                 const struct mlxsw_sp_adj_grp_size_range *size_range;
4761
4762                 size_range = &mlxsw_sp->router->adj_grp_size_ranges[i];
4763
4764                 if (nh_res_table->num_nh_buckets >= size_range->start &&
4765                     nh_res_table->num_nh_buckets <= size_range->end) {
4766                         valid_size = true;
4767                         break;
4768                 }
4769         }
4770
4771         if (!valid_size) {
4772                 NL_SET_ERR_MSG_MOD(extack, "Invalid number of buckets");
4773                 return -EINVAL;
4774         }
4775
4776         err = mlxsw_sp_kvdl_alloc_count_query(mlxsw_sp,
4777                                               MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
4778                                               nh_res_table->num_nh_buckets,
4779                                               &alloc_size);
4780         if (err || nh_res_table->num_nh_buckets != alloc_size) {
4781                 NL_SET_ERR_MSG_MOD(extack, "Number of buckets does not fit allocation size of any KVDL partition");
4782                 return -EINVAL;
4783         }
4784
4785         return 0;
4786 }
4787
4788 static int
4789 mlxsw_sp_nexthop_obj_res_group_validate(struct mlxsw_sp *mlxsw_sp,
4790                                         const struct nh_notifier_res_table_info *nh_res_table,
4791                                         struct netlink_ext_ack *extack)
4792 {
4793         int err;
4794         u16 i;
4795
4796         err = mlxsw_sp_nexthop_obj_res_group_size_validate(mlxsw_sp,
4797                                                            nh_res_table,
4798                                                            extack);
4799         if (err)
4800                 return err;
4801
4802         for (i = 0; i < nh_res_table->num_nh_buckets; i++) {
4803                 const struct nh_notifier_single_info *nh;
4804                 int err;
4805
4806                 nh = &nh_res_table->nhs[i];
4807                 err = mlxsw_sp_nexthop_obj_group_entry_validate(mlxsw_sp, nh,
4808                                                                 extack);
4809                 if (err)
4810                         return err;
4811         }
4812
4813         return 0;
4814 }
4815
4816 static int mlxsw_sp_nexthop_obj_validate(struct mlxsw_sp *mlxsw_sp,
4817                                          unsigned long event,
4818                                          struct nh_notifier_info *info)
4819 {
4820         struct nh_notifier_single_info *nh;
4821
4822         if (event != NEXTHOP_EVENT_REPLACE &&
4823             event != NEXTHOP_EVENT_RES_TABLE_PRE_REPLACE &&
4824             event != NEXTHOP_EVENT_BUCKET_REPLACE)
4825                 return 0;
4826
4827         switch (info->type) {
4828         case NH_NOTIFIER_INFO_TYPE_SINGLE:
4829                 return mlxsw_sp_nexthop_obj_single_validate(mlxsw_sp, info->nh,
4830                                                             info->extack);
4831         case NH_NOTIFIER_INFO_TYPE_GRP:
4832                 return mlxsw_sp_nexthop_obj_group_validate(mlxsw_sp,
4833                                                            info->nh_grp,
4834                                                            info->extack);
4835         case NH_NOTIFIER_INFO_TYPE_RES_TABLE:
4836                 return mlxsw_sp_nexthop_obj_res_group_validate(mlxsw_sp,
4837                                                                info->nh_res_table,
4838                                                                info->extack);
4839         case NH_NOTIFIER_INFO_TYPE_RES_BUCKET:
4840                 nh = &info->nh_res_bucket->new_nh;
4841                 return mlxsw_sp_nexthop_obj_group_entry_validate(mlxsw_sp, nh,
4842                                                                  info->extack);
4843         default:
4844                 NL_SET_ERR_MSG_MOD(info->extack, "Unsupported nexthop type");
4845                 return -EOPNOTSUPP;
4846         }
4847 }
4848
4849 static bool mlxsw_sp_nexthop_obj_is_gateway(struct mlxsw_sp *mlxsw_sp,
4850                                             const struct nh_notifier_info *info)
4851 {
4852         const struct net_device *dev;
4853
4854         switch (info->type) {
4855         case NH_NOTIFIER_INFO_TYPE_SINGLE:
4856                 dev = info->nh->dev;
4857                 return info->nh->gw_family || info->nh->is_reject ||
4858                        mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, NULL);
4859         case NH_NOTIFIER_INFO_TYPE_GRP:
4860         case NH_NOTIFIER_INFO_TYPE_RES_TABLE:
4861                 /* Already validated earlier. */
4862                 return true;
4863         default:
4864                 return false;
4865         }
4866 }
4867
4868 static void mlxsw_sp_nexthop_obj_blackhole_init(struct mlxsw_sp *mlxsw_sp,
4869                                                 struct mlxsw_sp_nexthop *nh)
4870 {
4871         nh->action = MLXSW_SP_NEXTHOP_ACTION_DISCARD;
4872         nh->should_offload = 1;
4873         /* While nexthops that discard packets do not forward packets
4874          * via an egress RIF, they still need to be programmed using a
4875          * valid RIF, so use the loopback RIF created during init.
4876          */
4877         nh->crif = mlxsw_sp->router->lb_crif;
4878 }
4879
4880 static void mlxsw_sp_nexthop_obj_blackhole_fini(struct mlxsw_sp *mlxsw_sp,
4881                                                 struct mlxsw_sp_nexthop *nh)
4882 {
4883         nh->crif = NULL;
4884         nh->should_offload = 0;
4885 }
4886
4887 static int
4888 mlxsw_sp_nexthop_obj_init(struct mlxsw_sp *mlxsw_sp,
4889                           struct mlxsw_sp_nexthop_group *nh_grp,
4890                           struct mlxsw_sp_nexthop *nh,
4891                           struct nh_notifier_single_info *nh_obj, int weight)
4892 {
4893         struct net_device *dev = nh_obj->dev;
4894         int err;
4895
4896         nh->nhgi = nh_grp->nhgi;
4897         nh->nh_weight = weight;
4898
4899         switch (nh_obj->gw_family) {
4900         case AF_INET:
4901                 memcpy(&nh->gw_addr, &nh_obj->ipv4, sizeof(nh_obj->ipv4));
4902                 nh->neigh_tbl = &arp_tbl;
4903                 break;
4904         case AF_INET6:
4905                 memcpy(&nh->gw_addr, &nh_obj->ipv6, sizeof(nh_obj->ipv6));
4906 #if IS_ENABLED(CONFIG_IPV6)
4907                 nh->neigh_tbl = &nd_tbl;
4908 #endif
4909                 break;
4910         }
4911
4912         mlxsw_sp_nexthop_counter_alloc(mlxsw_sp, nh);
4913         list_add_tail(&nh->router_list_node, &mlxsw_sp->router->nexthop_list);
4914         nh->ifindex = dev->ifindex;
4915
4916         err = mlxsw_sp_nexthop_type_init(mlxsw_sp, nh, dev);
4917         if (err)
4918                 goto err_type_init;
4919
4920         if (nh_obj->is_reject)
4921                 mlxsw_sp_nexthop_obj_blackhole_init(mlxsw_sp, nh);
4922
4923         /* In a resilient nexthop group, all the nexthops must be written to
4924          * the adjacency table. Even if they do not have a valid neighbour or
4925          * RIF.
4926          */
4927         if (nh_grp->nhgi->is_resilient && !nh->should_offload) {
4928                 nh->action = MLXSW_SP_NEXTHOP_ACTION_TRAP;
4929                 nh->should_offload = 1;
4930         }
4931
4932         return 0;
4933
4934 err_type_init:
4935         list_del(&nh->router_list_node);
4936         mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
4937         return err;
4938 }
4939
4940 static void mlxsw_sp_nexthop_obj_fini(struct mlxsw_sp *mlxsw_sp,
4941                                       struct mlxsw_sp_nexthop *nh)
4942 {
4943         if (nh->action == MLXSW_SP_NEXTHOP_ACTION_DISCARD)
4944                 mlxsw_sp_nexthop_obj_blackhole_fini(mlxsw_sp, nh);
4945         mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
4946         list_del(&nh->router_list_node);
4947         mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
4948         nh->should_offload = 0;
4949 }
4950
4951 static int
4952 mlxsw_sp_nexthop_obj_group_info_init(struct mlxsw_sp *mlxsw_sp,
4953                                      struct mlxsw_sp_nexthop_group *nh_grp,
4954                                      struct nh_notifier_info *info)
4955 {
4956         struct mlxsw_sp_nexthop_group_info *nhgi;
4957         struct mlxsw_sp_nexthop *nh;
4958         bool is_resilient = false;
4959         unsigned int nhs;
4960         int err, i;
4961
4962         switch (info->type) {
4963         case NH_NOTIFIER_INFO_TYPE_SINGLE:
4964                 nhs = 1;
4965                 break;
4966         case NH_NOTIFIER_INFO_TYPE_GRP:
4967                 nhs = info->nh_grp->num_nh;
4968                 break;
4969         case NH_NOTIFIER_INFO_TYPE_RES_TABLE:
4970                 nhs = info->nh_res_table->num_nh_buckets;
4971                 is_resilient = true;
4972                 break;
4973         default:
4974                 return -EINVAL;
4975         }
4976
4977         nhgi = kzalloc(struct_size(nhgi, nexthops, nhs), GFP_KERNEL);
4978         if (!nhgi)
4979                 return -ENOMEM;
4980         nh_grp->nhgi = nhgi;
4981         nhgi->nh_grp = nh_grp;
4982         nhgi->gateway = mlxsw_sp_nexthop_obj_is_gateway(mlxsw_sp, info);
4983         nhgi->is_resilient = is_resilient;
4984         nhgi->count = nhs;
4985         for (i = 0; i < nhgi->count; i++) {
4986                 struct nh_notifier_single_info *nh_obj;
4987                 int weight;
4988
4989                 nh = &nhgi->nexthops[i];
4990                 switch (info->type) {
4991                 case NH_NOTIFIER_INFO_TYPE_SINGLE:
4992                         nh_obj = info->nh;
4993                         weight = 1;
4994                         break;
4995                 case NH_NOTIFIER_INFO_TYPE_GRP:
4996                         nh_obj = &info->nh_grp->nh_entries[i].nh;
4997                         weight = info->nh_grp->nh_entries[i].weight;
4998                         break;
4999                 case NH_NOTIFIER_INFO_TYPE_RES_TABLE:
5000                         nh_obj = &info->nh_res_table->nhs[i];
5001                         weight = 1;
5002                         break;
5003                 default:
5004                         err = -EINVAL;
5005                         goto err_nexthop_obj_init;
5006                 }
5007                 err = mlxsw_sp_nexthop_obj_init(mlxsw_sp, nh_grp, nh, nh_obj,
5008                                                 weight);
5009                 if (err)
5010                         goto err_nexthop_obj_init;
5011         }
5012         err = mlxsw_sp_nexthop_group_inc(mlxsw_sp);
5013         if (err)
5014                 goto err_group_inc;
5015         err = mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
5016         if (err) {
5017                 NL_SET_ERR_MSG_MOD(info->extack, "Failed to write adjacency entries to the device");
5018                 goto err_group_refresh;
5019         }
5020
5021         /* Add resilient nexthop groups to a list so that the activity of their
5022          * nexthop buckets will be periodically queried and cleared.
5023          */
5024         if (nhgi->is_resilient) {
5025                 if (list_empty(&mlxsw_sp->router->nh_res_grp_list))
5026                         mlxsw_sp_nh_grp_activity_work_schedule(mlxsw_sp);
5027                 list_add(&nhgi->list, &mlxsw_sp->router->nh_res_grp_list);
5028         }
5029
5030         return 0;
5031
5032 err_group_refresh:
5033         mlxsw_sp_nexthop_group_dec(mlxsw_sp);
5034 err_group_inc:
5035         i = nhgi->count;
5036 err_nexthop_obj_init:
5037         for (i--; i >= 0; i--) {
5038                 nh = &nhgi->nexthops[i];
5039                 mlxsw_sp_nexthop_obj_fini(mlxsw_sp, nh);
5040         }
5041         kfree(nhgi);
5042         return err;
5043 }
5044
5045 static void
5046 mlxsw_sp_nexthop_obj_group_info_fini(struct mlxsw_sp *mlxsw_sp,
5047                                      struct mlxsw_sp_nexthop_group *nh_grp)
5048 {
5049         struct mlxsw_sp_nexthop_group_info *nhgi = nh_grp->nhgi;
5050         struct mlxsw_sp_router *router = mlxsw_sp->router;
5051         int i;
5052
5053         if (nhgi->is_resilient) {
5054                 list_del(&nhgi->list);
5055                 if (list_empty(&mlxsw_sp->router->nh_res_grp_list))
5056                         cancel_delayed_work(&router->nh_grp_activity_dw);
5057         }
5058
5059         mlxsw_sp_nexthop_group_dec(mlxsw_sp);
5060         for (i = nhgi->count - 1; i >= 0; i--) {
5061                 struct mlxsw_sp_nexthop *nh = &nhgi->nexthops[i];
5062
5063                 mlxsw_sp_nexthop_obj_fini(mlxsw_sp, nh);
5064         }
5065         mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
5066         WARN_ON_ONCE(nhgi->adj_index_valid);
5067         kfree(nhgi);
5068 }
5069
5070 static struct mlxsw_sp_nexthop_group *
5071 mlxsw_sp_nexthop_obj_group_create(struct mlxsw_sp *mlxsw_sp,
5072                                   struct nh_notifier_info *info)
5073 {
5074         struct mlxsw_sp_nexthop_group *nh_grp;
5075         int err;
5076
5077         nh_grp = kzalloc(sizeof(*nh_grp), GFP_KERNEL);
5078         if (!nh_grp)
5079                 return ERR_PTR(-ENOMEM);
5080         INIT_LIST_HEAD(&nh_grp->vr_list);
5081         err = rhashtable_init(&nh_grp->vr_ht,
5082                               &mlxsw_sp_nexthop_group_vr_ht_params);
5083         if (err)
5084                 goto err_nexthop_group_vr_ht_init;
5085         INIT_LIST_HEAD(&nh_grp->fib_list);
5086         nh_grp->type = MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ;
5087         nh_grp->obj.id = info->id;
5088
5089         err = mlxsw_sp_nexthop_obj_group_info_init(mlxsw_sp, nh_grp, info);
5090         if (err)
5091                 goto err_nexthop_group_info_init;
5092
5093         nh_grp->can_destroy = false;
5094
5095         return nh_grp;
5096
5097 err_nexthop_group_info_init:
5098         rhashtable_destroy(&nh_grp->vr_ht);
5099 err_nexthop_group_vr_ht_init:
5100         kfree(nh_grp);
5101         return ERR_PTR(err);
5102 }
5103
5104 static void
5105 mlxsw_sp_nexthop_obj_group_destroy(struct mlxsw_sp *mlxsw_sp,
5106                                    struct mlxsw_sp_nexthop_group *nh_grp)
5107 {
5108         if (!nh_grp->can_destroy)
5109                 return;
5110         mlxsw_sp_nexthop_obj_group_info_fini(mlxsw_sp, nh_grp);
5111         WARN_ON_ONCE(!list_empty(&nh_grp->fib_list));
5112         WARN_ON_ONCE(!list_empty(&nh_grp->vr_list));
5113         rhashtable_destroy(&nh_grp->vr_ht);
5114         kfree(nh_grp);
5115 }
5116
5117 static struct mlxsw_sp_nexthop_group *
5118 mlxsw_sp_nexthop_obj_group_lookup(struct mlxsw_sp *mlxsw_sp, u32 id)
5119 {
5120         struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
5121
5122         cmp_arg.type = MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ;
5123         cmp_arg.id = id;
5124         return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
5125                                       &cmp_arg,
5126                                       mlxsw_sp_nexthop_group_ht_params);
5127 }
5128
5129 static int mlxsw_sp_nexthop_obj_group_add(struct mlxsw_sp *mlxsw_sp,
5130                                           struct mlxsw_sp_nexthop_group *nh_grp)
5131 {
5132         return mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
5133 }
5134
5135 static int
5136 mlxsw_sp_nexthop_obj_group_replace(struct mlxsw_sp *mlxsw_sp,
5137                                    struct mlxsw_sp_nexthop_group *nh_grp,
5138                                    struct mlxsw_sp_nexthop_group *old_nh_grp,
5139                                    struct netlink_ext_ack *extack)
5140 {
5141         struct mlxsw_sp_nexthop_group_info *old_nhgi = old_nh_grp->nhgi;
5142         struct mlxsw_sp_nexthop_group_info *new_nhgi = nh_grp->nhgi;
5143         int err;
5144
5145         old_nh_grp->nhgi = new_nhgi;
5146         new_nhgi->nh_grp = old_nh_grp;
5147         nh_grp->nhgi = old_nhgi;
5148         old_nhgi->nh_grp = nh_grp;
5149
5150         if (old_nhgi->adj_index_valid && new_nhgi->adj_index_valid) {
5151                 /* Both the old adjacency index and the new one are valid.
5152                  * Routes are currently using the old one. Tell the device to
5153                  * replace the old adjacency index with the new one.
5154                  */
5155                 err = mlxsw_sp_adj_index_mass_update(mlxsw_sp, old_nh_grp,
5156                                                      old_nhgi->adj_index,
5157                                                      old_nhgi->ecmp_size);
5158                 if (err) {
5159                         NL_SET_ERR_MSG_MOD(extack, "Failed to replace old adjacency index with new one");
5160                         goto err_out;
5161                 }
5162         } else if (old_nhgi->adj_index_valid && !new_nhgi->adj_index_valid) {
5163                 /* The old adjacency index is valid, while the new one is not.
5164                  * Iterate over all the routes using the group and change them
5165                  * to trap packets to the CPU.
5166                  */
5167                 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, old_nh_grp);
5168                 if (err) {
5169                         NL_SET_ERR_MSG_MOD(extack, "Failed to update routes to trap packets");
5170                         goto err_out;
5171                 }
5172         } else if (!old_nhgi->adj_index_valid && new_nhgi->adj_index_valid) {
5173                 /* The old adjacency index is invalid, while the new one is.
5174                  * Iterate over all the routes using the group and change them
5175                  * to forward packets using the new valid index.
5176                  */
5177                 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, old_nh_grp);
5178                 if (err) {
5179                         NL_SET_ERR_MSG_MOD(extack, "Failed to update routes to forward packets");
5180                         goto err_out;
5181                 }
5182         }
5183
5184         /* Make sure the flags are set / cleared based on the new nexthop group
5185          * information.
5186          */
5187         mlxsw_sp_nexthop_obj_group_offload_refresh(mlxsw_sp, old_nh_grp);
5188
5189         /* At this point 'nh_grp' is just a shell that is not used by anyone
5190          * and its nexthop group info is the old info that was just replaced
5191          * with the new one. Remove it.
5192          */
5193         nh_grp->can_destroy = true;
5194         mlxsw_sp_nexthop_obj_group_destroy(mlxsw_sp, nh_grp);
5195
5196         return 0;
5197
5198 err_out:
5199         old_nhgi->nh_grp = old_nh_grp;
5200         nh_grp->nhgi = new_nhgi;
5201         new_nhgi->nh_grp = nh_grp;
5202         old_nh_grp->nhgi = old_nhgi;
5203         return err;
5204 }
5205
5206 static int mlxsw_sp_nexthop_obj_new(struct mlxsw_sp *mlxsw_sp,
5207                                     struct nh_notifier_info *info)
5208 {
5209         struct mlxsw_sp_nexthop_group *nh_grp, *old_nh_grp;
5210         struct netlink_ext_ack *extack = info->extack;
5211         int err;
5212
5213         nh_grp = mlxsw_sp_nexthop_obj_group_create(mlxsw_sp, info);
5214         if (IS_ERR(nh_grp))
5215                 return PTR_ERR(nh_grp);
5216
5217         old_nh_grp = mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp, info->id);
5218         if (!old_nh_grp)
5219                 err = mlxsw_sp_nexthop_obj_group_add(mlxsw_sp, nh_grp);
5220         else
5221                 err = mlxsw_sp_nexthop_obj_group_replace(mlxsw_sp, nh_grp,
5222                                                          old_nh_grp, extack);
5223
5224         if (err) {
5225                 nh_grp->can_destroy = true;
5226                 mlxsw_sp_nexthop_obj_group_destroy(mlxsw_sp, nh_grp);
5227         }
5228
5229         return err;
5230 }
5231
5232 static void mlxsw_sp_nexthop_obj_del(struct mlxsw_sp *mlxsw_sp,
5233                                      struct nh_notifier_info *info)
5234 {
5235         struct mlxsw_sp_nexthop_group *nh_grp;
5236
5237         nh_grp = mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp, info->id);
5238         if (!nh_grp)
5239                 return;
5240
5241         nh_grp->can_destroy = true;
5242         mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
5243
5244         /* If the group still has routes using it, then defer the delete
5245          * operation until the last route using it is deleted.
5246          */
5247         if (!list_empty(&nh_grp->fib_list))
5248                 return;
5249         mlxsw_sp_nexthop_obj_group_destroy(mlxsw_sp, nh_grp);
5250 }
5251
5252 static int mlxsw_sp_nexthop_obj_bucket_query(struct mlxsw_sp *mlxsw_sp,
5253                                              u32 adj_index, char *ratr_pl)
5254 {
5255         MLXSW_REG_ZERO(ratr, ratr_pl);
5256         mlxsw_reg_ratr_op_set(ratr_pl, MLXSW_REG_RATR_OP_QUERY_READ);
5257         mlxsw_reg_ratr_adjacency_index_low_set(ratr_pl, adj_index);
5258         mlxsw_reg_ratr_adjacency_index_high_set(ratr_pl, adj_index >> 16);
5259
5260         return mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ratr), ratr_pl);
5261 }
5262
5263 static int mlxsw_sp_nexthop_obj_bucket_compare(char *ratr_pl, char *ratr_pl_new)
5264 {
5265         /* Clear the opcode and activity on both the old and new payload as
5266          * they are irrelevant for the comparison.
5267          */
5268         mlxsw_reg_ratr_op_set(ratr_pl, MLXSW_REG_RATR_OP_QUERY_READ);
5269         mlxsw_reg_ratr_a_set(ratr_pl, 0);
5270         mlxsw_reg_ratr_op_set(ratr_pl_new, MLXSW_REG_RATR_OP_QUERY_READ);
5271         mlxsw_reg_ratr_a_set(ratr_pl_new, 0);
5272
5273         /* If the contents of the adjacency entry are consistent with the
5274          * replacement request, then replacement was successful.
5275          */
5276         if (!memcmp(ratr_pl, ratr_pl_new, MLXSW_REG_RATR_LEN))
5277                 return 0;
5278
5279         return -EINVAL;
5280 }
5281
5282 static int
5283 mlxsw_sp_nexthop_obj_bucket_adj_update(struct mlxsw_sp *mlxsw_sp,
5284                                        struct mlxsw_sp_nexthop *nh,
5285                                        struct nh_notifier_info *info)
5286 {
5287         u16 bucket_index = info->nh_res_bucket->bucket_index;
5288         struct netlink_ext_ack *extack = info->extack;
5289         bool force = info->nh_res_bucket->force;
5290         char ratr_pl_new[MLXSW_REG_RATR_LEN];
5291         char ratr_pl[MLXSW_REG_RATR_LEN];
5292         u32 adj_index;
5293         int err;
5294
5295         /* No point in trying an atomic replacement if the idle timer interval
5296          * is smaller than the interval in which we query and clear activity.
5297          */
5298         if (!force && info->nh_res_bucket->idle_timer_ms <
5299             MLXSW_SP_NH_GRP_ACTIVITY_UPDATE_INTERVAL)
5300                 force = true;
5301
5302         adj_index = nh->nhgi->adj_index + bucket_index;
5303         err = mlxsw_sp_nexthop_update(mlxsw_sp, adj_index, nh, force, ratr_pl);
5304         if (err) {
5305                 NL_SET_ERR_MSG_MOD(extack, "Failed to overwrite nexthop bucket");
5306                 return err;
5307         }
5308
5309         if (!force) {
5310                 err = mlxsw_sp_nexthop_obj_bucket_query(mlxsw_sp, adj_index,
5311                                                         ratr_pl_new);
5312                 if (err) {
5313                         NL_SET_ERR_MSG_MOD(extack, "Failed to query nexthop bucket state after replacement. State might be inconsistent");
5314                         return err;
5315                 }
5316
5317                 err = mlxsw_sp_nexthop_obj_bucket_compare(ratr_pl, ratr_pl_new);
5318                 if (err) {
5319                         NL_SET_ERR_MSG_MOD(extack, "Nexthop bucket was not replaced because it was active during replacement");
5320                         return err;
5321                 }
5322         }
5323
5324         nh->update = 0;
5325         nh->offloaded = 1;
5326         mlxsw_sp_nexthop_bucket_offload_refresh(mlxsw_sp, nh, bucket_index);
5327
5328         return 0;
5329 }
5330
5331 static int mlxsw_sp_nexthop_obj_bucket_replace(struct mlxsw_sp *mlxsw_sp,
5332                                                struct nh_notifier_info *info)
5333 {
5334         u16 bucket_index = info->nh_res_bucket->bucket_index;
5335         struct netlink_ext_ack *extack = info->extack;
5336         struct mlxsw_sp_nexthop_group_info *nhgi;
5337         struct nh_notifier_single_info *nh_obj;
5338         struct mlxsw_sp_nexthop_group *nh_grp;
5339         struct mlxsw_sp_nexthop *nh;
5340         int err;
5341
5342         nh_grp = mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp, info->id);
5343         if (!nh_grp) {
5344                 NL_SET_ERR_MSG_MOD(extack, "Nexthop group was not found");
5345                 return -EINVAL;
5346         }
5347
5348         nhgi = nh_grp->nhgi;
5349
5350         if (bucket_index >= nhgi->count) {
5351                 NL_SET_ERR_MSG_MOD(extack, "Nexthop bucket index out of range");
5352                 return -EINVAL;
5353         }
5354
5355         nh = &nhgi->nexthops[bucket_index];
5356         mlxsw_sp_nexthop_obj_fini(mlxsw_sp, nh);
5357
5358         nh_obj = &info->nh_res_bucket->new_nh;
5359         err = mlxsw_sp_nexthop_obj_init(mlxsw_sp, nh_grp, nh, nh_obj, 1);
5360         if (err) {
5361                 NL_SET_ERR_MSG_MOD(extack, "Failed to initialize nexthop object for nexthop bucket replacement");
5362                 goto err_nexthop_obj_init;
5363         }
5364
5365         err = mlxsw_sp_nexthop_obj_bucket_adj_update(mlxsw_sp, nh, info);
5366         if (err)
5367                 goto err_nexthop_obj_bucket_adj_update;
5368
5369         return 0;
5370
5371 err_nexthop_obj_bucket_adj_update:
5372         mlxsw_sp_nexthop_obj_fini(mlxsw_sp, nh);
5373 err_nexthop_obj_init:
5374         nh_obj = &info->nh_res_bucket->old_nh;
5375         mlxsw_sp_nexthop_obj_init(mlxsw_sp, nh_grp, nh, nh_obj, 1);
5376         /* The old adjacency entry was not overwritten */
5377         nh->update = 0;
5378         nh->offloaded = 1;
5379         return err;
5380 }
5381
5382 static int mlxsw_sp_nexthop_obj_event(struct notifier_block *nb,
5383                                       unsigned long event, void *ptr)
5384 {
5385         struct nh_notifier_info *info = ptr;
5386         struct mlxsw_sp_router *router;
5387         int err = 0;
5388
5389         router = container_of(nb, struct mlxsw_sp_router, nexthop_nb);
5390         err = mlxsw_sp_nexthop_obj_validate(router->mlxsw_sp, event, info);
5391         if (err)
5392                 goto out;
5393
5394         mutex_lock(&router->lock);
5395
5396         switch (event) {
5397         case NEXTHOP_EVENT_REPLACE:
5398                 err = mlxsw_sp_nexthop_obj_new(router->mlxsw_sp, info);
5399                 break;
5400         case NEXTHOP_EVENT_DEL:
5401                 mlxsw_sp_nexthop_obj_del(router->mlxsw_sp, info);
5402                 break;
5403         case NEXTHOP_EVENT_BUCKET_REPLACE:
5404                 err = mlxsw_sp_nexthop_obj_bucket_replace(router->mlxsw_sp,
5405                                                           info);
5406                 break;
5407         default:
5408                 break;
5409         }
5410
5411         mutex_unlock(&router->lock);
5412
5413 out:
5414         return notifier_from_errno(err);
5415 }
5416
5417 static bool mlxsw_sp_fi_is_gateway(const struct mlxsw_sp *mlxsw_sp,
5418                                    struct fib_info *fi)
5419 {
5420         const struct fib_nh *nh = fib_info_nh(fi, 0);
5421
5422         return nh->fib_nh_gw_family ||
5423                mlxsw_sp_nexthop4_ipip_type(mlxsw_sp, nh, NULL);
5424 }
5425
5426 static int
5427 mlxsw_sp_nexthop4_group_info_init(struct mlxsw_sp *mlxsw_sp,
5428                                   struct mlxsw_sp_nexthop_group *nh_grp)
5429 {
5430         unsigned int nhs = fib_info_num_path(nh_grp->ipv4.fi);
5431         struct mlxsw_sp_nexthop_group_info *nhgi;
5432         struct mlxsw_sp_nexthop *nh;
5433         int err, i;
5434
5435         nhgi = kzalloc(struct_size(nhgi, nexthops, nhs), GFP_KERNEL);
5436         if (!nhgi)
5437                 return -ENOMEM;
5438         nh_grp->nhgi = nhgi;
5439         nhgi->nh_grp = nh_grp;
5440         nhgi->gateway = mlxsw_sp_fi_is_gateway(mlxsw_sp, nh_grp->ipv4.fi);
5441         nhgi->count = nhs;
5442         for (i = 0; i < nhgi->count; i++) {
5443                 struct fib_nh *fib_nh;
5444
5445                 nh = &nhgi->nexthops[i];
5446                 fib_nh = fib_info_nh(nh_grp->ipv4.fi, i);
5447                 err = mlxsw_sp_nexthop4_init(mlxsw_sp, nh_grp, nh, fib_nh);
5448                 if (err)
5449                         goto err_nexthop4_init;
5450         }
5451         err = mlxsw_sp_nexthop_group_inc(mlxsw_sp);
5452         if (err)
5453                 goto err_group_inc;
5454         err = mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
5455         if (err)
5456                 goto err_group_refresh;
5457
5458         return 0;
5459
5460 err_group_refresh:
5461         mlxsw_sp_nexthop_group_dec(mlxsw_sp);
5462 err_group_inc:
5463         i = nhgi->count;
5464 err_nexthop4_init:
5465         for (i--; i >= 0; i--) {
5466                 nh = &nhgi->nexthops[i];
5467                 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
5468         }
5469         kfree(nhgi);
5470         return err;
5471 }
5472
5473 static void
5474 mlxsw_sp_nexthop4_group_info_fini(struct mlxsw_sp *mlxsw_sp,
5475                                   struct mlxsw_sp_nexthop_group *nh_grp)
5476 {
5477         struct mlxsw_sp_nexthop_group_info *nhgi = nh_grp->nhgi;
5478         int i;
5479
5480         mlxsw_sp_nexthop_group_dec(mlxsw_sp);
5481         for (i = nhgi->count - 1; i >= 0; i--) {
5482                 struct mlxsw_sp_nexthop *nh = &nhgi->nexthops[i];
5483
5484                 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
5485         }
5486         mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
5487         WARN_ON_ONCE(nhgi->adj_index_valid);
5488         kfree(nhgi);
5489 }
5490
5491 static struct mlxsw_sp_nexthop_group *
5492 mlxsw_sp_nexthop4_group_create(struct mlxsw_sp *mlxsw_sp, struct fib_info *fi)
5493 {
5494         struct mlxsw_sp_nexthop_group *nh_grp;
5495         int err;
5496
5497         nh_grp = kzalloc(sizeof(*nh_grp), GFP_KERNEL);
5498         if (!nh_grp)
5499                 return ERR_PTR(-ENOMEM);
5500         INIT_LIST_HEAD(&nh_grp->vr_list);
5501         err = rhashtable_init(&nh_grp->vr_ht,
5502                               &mlxsw_sp_nexthop_group_vr_ht_params);
5503         if (err)
5504                 goto err_nexthop_group_vr_ht_init;
5505         INIT_LIST_HEAD(&nh_grp->fib_list);
5506         nh_grp->type = MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV4;
5507         nh_grp->ipv4.fi = fi;
5508         fib_info_hold(fi);
5509
5510         err = mlxsw_sp_nexthop4_group_info_init(mlxsw_sp, nh_grp);
5511         if (err)
5512                 goto err_nexthop_group_info_init;
5513
5514         err = mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
5515         if (err)
5516                 goto err_nexthop_group_insert;
5517
5518         nh_grp->can_destroy = true;
5519
5520         return nh_grp;
5521
5522 err_nexthop_group_insert:
5523         mlxsw_sp_nexthop4_group_info_fini(mlxsw_sp, nh_grp);
5524 err_nexthop_group_info_init:
5525         fib_info_put(fi);
5526         rhashtable_destroy(&nh_grp->vr_ht);
5527 err_nexthop_group_vr_ht_init:
5528         kfree(nh_grp);
5529         return ERR_PTR(err);
5530 }
5531
5532 static void
5533 mlxsw_sp_nexthop4_group_destroy(struct mlxsw_sp *mlxsw_sp,
5534                                 struct mlxsw_sp_nexthop_group *nh_grp)
5535 {
5536         if (!nh_grp->can_destroy)
5537                 return;
5538         mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
5539         mlxsw_sp_nexthop4_group_info_fini(mlxsw_sp, nh_grp);
5540         fib_info_put(nh_grp->ipv4.fi);
5541         WARN_ON_ONCE(!list_empty(&nh_grp->vr_list));
5542         rhashtable_destroy(&nh_grp->vr_ht);
5543         kfree(nh_grp);
5544 }
5545
5546 static int mlxsw_sp_nexthop4_group_get(struct mlxsw_sp *mlxsw_sp,
5547                                        struct mlxsw_sp_fib_entry *fib_entry,
5548                                        struct fib_info *fi)
5549 {
5550         struct mlxsw_sp_nexthop_group *nh_grp;
5551
5552         if (fi->nh) {
5553                 nh_grp = mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp,
5554                                                            fi->nh->id);
5555                 if (WARN_ON_ONCE(!nh_grp))
5556                         return -EINVAL;
5557                 goto out;
5558         }
5559
5560         nh_grp = mlxsw_sp_nexthop4_group_lookup(mlxsw_sp, fi);
5561         if (!nh_grp) {
5562                 nh_grp = mlxsw_sp_nexthop4_group_create(mlxsw_sp, fi);
5563                 if (IS_ERR(nh_grp))
5564                         return PTR_ERR(nh_grp);
5565         }
5566 out:
5567         list_add_tail(&fib_entry->nexthop_group_node, &nh_grp->fib_list);
5568         fib_entry->nh_group = nh_grp;
5569         return 0;
5570 }
5571
5572 static void mlxsw_sp_nexthop4_group_put(struct mlxsw_sp *mlxsw_sp,
5573                                         struct mlxsw_sp_fib_entry *fib_entry)
5574 {
5575         struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
5576
5577         list_del(&fib_entry->nexthop_group_node);
5578         if (!list_empty(&nh_grp->fib_list))
5579                 return;
5580
5581         if (nh_grp->type == MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ) {
5582                 mlxsw_sp_nexthop_obj_group_destroy(mlxsw_sp, nh_grp);
5583                 return;
5584         }
5585
5586         mlxsw_sp_nexthop4_group_destroy(mlxsw_sp, nh_grp);
5587 }
5588
5589 static bool
5590 mlxsw_sp_fib4_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
5591 {
5592         struct mlxsw_sp_fib4_entry *fib4_entry;
5593
5594         fib4_entry = container_of(fib_entry, struct mlxsw_sp_fib4_entry,
5595                                   common);
5596         return !fib4_entry->dscp;
5597 }
5598
5599 static bool
5600 mlxsw_sp_fib_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
5601 {
5602         struct mlxsw_sp_nexthop_group *nh_group = fib_entry->nh_group;
5603
5604         switch (fib_entry->fib_node->fib->proto) {
5605         case MLXSW_SP_L3_PROTO_IPV4:
5606                 if (!mlxsw_sp_fib4_entry_should_offload(fib_entry))
5607                         return false;
5608                 break;
5609         case MLXSW_SP_L3_PROTO_IPV6:
5610                 break;
5611         }
5612
5613         switch (fib_entry->type) {
5614         case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
5615                 return !!nh_group->nhgi->adj_index_valid;
5616         case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
5617                 return !!mlxsw_sp_nhgi_rif(nh_group->nhgi);
5618         case MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE:
5619         case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
5620         case MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP:
5621                 return true;
5622         default:
5623                 return false;
5624         }
5625 }
5626
5627 static struct mlxsw_sp_nexthop *
5628 mlxsw_sp_rt6_nexthop(struct mlxsw_sp_nexthop_group *nh_grp,
5629                      const struct mlxsw_sp_rt6 *mlxsw_sp_rt6)
5630 {
5631         int i;
5632
5633         for (i = 0; i < nh_grp->nhgi->count; i++) {
5634                 struct mlxsw_sp_nexthop *nh = &nh_grp->nhgi->nexthops[i];
5635                 struct net_device *dev = mlxsw_sp_nexthop_dev(nh);
5636                 struct fib6_info *rt = mlxsw_sp_rt6->rt;
5637
5638                 if (dev && dev == rt->fib6_nh->fib_nh_dev &&
5639                     ipv6_addr_equal((const struct in6_addr *) &nh->gw_addr,
5640                                     &rt->fib6_nh->fib_nh_gw6))
5641                         return nh;
5642         }
5643
5644         return NULL;
5645 }
5646
5647 static void
5648 mlxsw_sp_fib4_offload_failed_flag_set(struct mlxsw_sp *mlxsw_sp,
5649                                       struct fib_entry_notifier_info *fen_info)
5650 {
5651         u32 *p_dst = (u32 *) &fen_info->dst;
5652         struct fib_rt_info fri;
5653
5654         fri.fi = fen_info->fi;
5655         fri.tb_id = fen_info->tb_id;
5656         fri.dst = cpu_to_be32(*p_dst);
5657         fri.dst_len = fen_info->dst_len;
5658         fri.dscp = fen_info->dscp;
5659         fri.type = fen_info->type;
5660         fri.offload = false;
5661         fri.trap = false;
5662         fri.offload_failed = true;
5663         fib_alias_hw_flags_set(mlxsw_sp_net(mlxsw_sp), &fri);
5664 }
5665
5666 static void
5667 mlxsw_sp_fib4_entry_hw_flags_set(struct mlxsw_sp *mlxsw_sp,
5668                                  struct mlxsw_sp_fib_entry *fib_entry)
5669 {
5670         u32 *p_dst = (u32 *) fib_entry->fib_node->key.addr;
5671         int dst_len = fib_entry->fib_node->key.prefix_len;
5672         struct mlxsw_sp_fib4_entry *fib4_entry;
5673         struct fib_rt_info fri;
5674         bool should_offload;
5675
5676         should_offload = mlxsw_sp_fib_entry_should_offload(fib_entry);
5677         fib4_entry = container_of(fib_entry, struct mlxsw_sp_fib4_entry,
5678                                   common);
5679         fri.fi = fib4_entry->fi;
5680         fri.tb_id = fib4_entry->tb_id;
5681         fri.dst = cpu_to_be32(*p_dst);
5682         fri.dst_len = dst_len;
5683         fri.dscp = fib4_entry->dscp;
5684         fri.type = fib4_entry->type;
5685         fri.offload = should_offload;
5686         fri.trap = !should_offload;
5687         fri.offload_failed = false;
5688         fib_alias_hw_flags_set(mlxsw_sp_net(mlxsw_sp), &fri);
5689 }
5690
5691 static void
5692 mlxsw_sp_fib4_entry_hw_flags_clear(struct mlxsw_sp *mlxsw_sp,
5693                                    struct mlxsw_sp_fib_entry *fib_entry)
5694 {
5695         u32 *p_dst = (u32 *) fib_entry->fib_node->key.addr;
5696         int dst_len = fib_entry->fib_node->key.prefix_len;
5697         struct mlxsw_sp_fib4_entry *fib4_entry;
5698         struct fib_rt_info fri;
5699
5700         fib4_entry = container_of(fib_entry, struct mlxsw_sp_fib4_entry,
5701                                   common);
5702         fri.fi = fib4_entry->fi;
5703         fri.tb_id = fib4_entry->tb_id;
5704         fri.dst = cpu_to_be32(*p_dst);
5705         fri.dst_len = dst_len;
5706         fri.dscp = fib4_entry->dscp;
5707         fri.type = fib4_entry->type;
5708         fri.offload = false;
5709         fri.trap = false;
5710         fri.offload_failed = false;
5711         fib_alias_hw_flags_set(mlxsw_sp_net(mlxsw_sp), &fri);
5712 }
5713
5714 #if IS_ENABLED(CONFIG_IPV6)
5715 static void
5716 mlxsw_sp_fib6_offload_failed_flag_set(struct mlxsw_sp *mlxsw_sp,
5717                                       struct fib6_info **rt_arr,
5718                                       unsigned int nrt6)
5719 {
5720         int i;
5721
5722         /* In IPv6 a multipath route is represented using multiple routes, so
5723          * we need to set the flags on all of them.
5724          */
5725         for (i = 0; i < nrt6; i++)
5726                 fib6_info_hw_flags_set(mlxsw_sp_net(mlxsw_sp), rt_arr[i],
5727                                        false, false, true);
5728 }
5729 #else
5730 static void
5731 mlxsw_sp_fib6_offload_failed_flag_set(struct mlxsw_sp *mlxsw_sp,
5732                                       struct fib6_info **rt_arr,
5733                                       unsigned int nrt6)
5734 {
5735 }
5736 #endif
5737
5738 #if IS_ENABLED(CONFIG_IPV6)
5739 static void
5740 mlxsw_sp_fib6_entry_hw_flags_set(struct mlxsw_sp *mlxsw_sp,
5741                                  struct mlxsw_sp_fib_entry *fib_entry)
5742 {
5743         struct mlxsw_sp_fib6_entry *fib6_entry;
5744         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
5745         bool should_offload;
5746
5747         should_offload = mlxsw_sp_fib_entry_should_offload(fib_entry);
5748
5749         /* In IPv6 a multipath route is represented using multiple routes, so
5750          * we need to set the flags on all of them.
5751          */
5752         fib6_entry = container_of(fib_entry, struct mlxsw_sp_fib6_entry,
5753                                   common);
5754         list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list)
5755                 fib6_info_hw_flags_set(mlxsw_sp_net(mlxsw_sp), mlxsw_sp_rt6->rt,
5756                                        should_offload, !should_offload, false);
5757 }
5758 #else
5759 static void
5760 mlxsw_sp_fib6_entry_hw_flags_set(struct mlxsw_sp *mlxsw_sp,
5761                                  struct mlxsw_sp_fib_entry *fib_entry)
5762 {
5763 }
5764 #endif
5765
5766 #if IS_ENABLED(CONFIG_IPV6)
5767 static void
5768 mlxsw_sp_fib6_entry_hw_flags_clear(struct mlxsw_sp *mlxsw_sp,
5769                                    struct mlxsw_sp_fib_entry *fib_entry)
5770 {
5771         struct mlxsw_sp_fib6_entry *fib6_entry;
5772         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
5773
5774         fib6_entry = container_of(fib_entry, struct mlxsw_sp_fib6_entry,
5775                                   common);
5776         list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list)
5777                 fib6_info_hw_flags_set(mlxsw_sp_net(mlxsw_sp), mlxsw_sp_rt6->rt,
5778                                        false, false, false);
5779 }
5780 #else
5781 static void
5782 mlxsw_sp_fib6_entry_hw_flags_clear(struct mlxsw_sp *mlxsw_sp,
5783                                    struct mlxsw_sp_fib_entry *fib_entry)
5784 {
5785 }
5786 #endif
5787
5788 static void
5789 mlxsw_sp_fib_entry_hw_flags_set(struct mlxsw_sp *mlxsw_sp,
5790                                 struct mlxsw_sp_fib_entry *fib_entry)
5791 {
5792         switch (fib_entry->fib_node->fib->proto) {
5793         case MLXSW_SP_L3_PROTO_IPV4:
5794                 mlxsw_sp_fib4_entry_hw_flags_set(mlxsw_sp, fib_entry);
5795                 break;
5796         case MLXSW_SP_L3_PROTO_IPV6:
5797                 mlxsw_sp_fib6_entry_hw_flags_set(mlxsw_sp, fib_entry);
5798                 break;
5799         }
5800 }
5801
5802 static void
5803 mlxsw_sp_fib_entry_hw_flags_clear(struct mlxsw_sp *mlxsw_sp,
5804                                   struct mlxsw_sp_fib_entry *fib_entry)
5805 {
5806         switch (fib_entry->fib_node->fib->proto) {
5807         case MLXSW_SP_L3_PROTO_IPV4:
5808                 mlxsw_sp_fib4_entry_hw_flags_clear(mlxsw_sp, fib_entry);
5809                 break;
5810         case MLXSW_SP_L3_PROTO_IPV6:
5811                 mlxsw_sp_fib6_entry_hw_flags_clear(mlxsw_sp, fib_entry);
5812                 break;
5813         }
5814 }
5815
5816 static void
5817 mlxsw_sp_fib_entry_hw_flags_refresh(struct mlxsw_sp *mlxsw_sp,
5818                                     struct mlxsw_sp_fib_entry *fib_entry,
5819                                     enum mlxsw_reg_ralue_op op)
5820 {
5821         switch (op) {
5822         case MLXSW_REG_RALUE_OP_WRITE_WRITE:
5823                 mlxsw_sp_fib_entry_hw_flags_set(mlxsw_sp, fib_entry);
5824                 break;
5825         case MLXSW_REG_RALUE_OP_WRITE_DELETE:
5826                 mlxsw_sp_fib_entry_hw_flags_clear(mlxsw_sp, fib_entry);
5827                 break;
5828         default:
5829                 break;
5830         }
5831 }
5832
5833 static void
5834 mlxsw_sp_fib_entry_ralue_pack(char *ralue_pl,
5835                               const struct mlxsw_sp_fib_entry *fib_entry,
5836                               enum mlxsw_reg_ralue_op op)
5837 {
5838         struct mlxsw_sp_fib *fib = fib_entry->fib_node->fib;
5839         enum mlxsw_reg_ralxx_protocol proto;
5840         u32 *p_dip;
5841
5842         proto = (enum mlxsw_reg_ralxx_protocol) fib->proto;
5843
5844         switch (fib->proto) {
5845         case MLXSW_SP_L3_PROTO_IPV4:
5846                 p_dip = (u32 *) fib_entry->fib_node->key.addr;
5847                 mlxsw_reg_ralue_pack4(ralue_pl, proto, op, fib->vr->id,
5848                                       fib_entry->fib_node->key.prefix_len,
5849                                       *p_dip);
5850                 break;
5851         case MLXSW_SP_L3_PROTO_IPV6:
5852                 mlxsw_reg_ralue_pack6(ralue_pl, proto, op, fib->vr->id,
5853                                       fib_entry->fib_node->key.prefix_len,
5854                                       fib_entry->fib_node->key.addr);
5855                 break;
5856         }
5857 }
5858
5859 static int mlxsw_sp_fib_entry_op_remote(struct mlxsw_sp *mlxsw_sp,
5860                                         struct mlxsw_sp_fib_entry *fib_entry,
5861                                         enum mlxsw_reg_ralue_op op)
5862 {
5863         struct mlxsw_sp_nexthop_group *nh_group = fib_entry->nh_group;
5864         struct mlxsw_sp_nexthop_group_info *nhgi = nh_group->nhgi;
5865         char ralue_pl[MLXSW_REG_RALUE_LEN];
5866         enum mlxsw_reg_ralue_trap_action trap_action;
5867         u16 trap_id = 0;
5868         u32 adjacency_index = 0;
5869         u16 ecmp_size = 0;
5870
5871         /* In case the nexthop group adjacency index is valid, use it
5872          * with provided ECMP size. Otherwise, setup trap and pass
5873          * traffic to kernel.
5874          */
5875         if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
5876                 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
5877                 adjacency_index = nhgi->adj_index;
5878                 ecmp_size = nhgi->ecmp_size;
5879         } else if (!nhgi->adj_index_valid && nhgi->count &&
5880                    mlxsw_sp_nhgi_rif(nhgi)) {
5881                 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
5882                 adjacency_index = mlxsw_sp->router->adj_trap_index;
5883                 ecmp_size = 1;
5884         } else {
5885                 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
5886                 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
5887         }
5888
5889         mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
5890         mlxsw_reg_ralue_act_remote_pack(ralue_pl, trap_action, trap_id,
5891                                         adjacency_index, ecmp_size);
5892         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
5893 }
5894
5895 static int mlxsw_sp_fib_entry_op_local(struct mlxsw_sp *mlxsw_sp,
5896                                        struct mlxsw_sp_fib_entry *fib_entry,
5897                                        enum mlxsw_reg_ralue_op op)
5898 {
5899         struct mlxsw_sp_rif *rif = mlxsw_sp_nhgi_rif(fib_entry->nh_group->nhgi);
5900         enum mlxsw_reg_ralue_trap_action trap_action;
5901         char ralue_pl[MLXSW_REG_RALUE_LEN];
5902         u16 trap_id = 0;
5903         u16 rif_index = 0;
5904
5905         if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
5906                 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
5907                 rif_index = rif->rif_index;
5908         } else {
5909                 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
5910                 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
5911         }
5912
5913         mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
5914         mlxsw_reg_ralue_act_local_pack(ralue_pl, trap_action, trap_id,
5915                                        rif_index);
5916         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
5917 }
5918
5919 static int mlxsw_sp_fib_entry_op_trap(struct mlxsw_sp *mlxsw_sp,
5920                                       struct mlxsw_sp_fib_entry *fib_entry,
5921                                       enum mlxsw_reg_ralue_op op)
5922 {
5923         char ralue_pl[MLXSW_REG_RALUE_LEN];
5924
5925         mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
5926         mlxsw_reg_ralue_act_ip2me_pack(ralue_pl);
5927         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
5928 }
5929
5930 static int mlxsw_sp_fib_entry_op_blackhole(struct mlxsw_sp *mlxsw_sp,
5931                                            struct mlxsw_sp_fib_entry *fib_entry,
5932                                            enum mlxsw_reg_ralue_op op)
5933 {
5934         enum mlxsw_reg_ralue_trap_action trap_action;
5935         char ralue_pl[MLXSW_REG_RALUE_LEN];
5936
5937         trap_action = MLXSW_REG_RALUE_TRAP_ACTION_DISCARD_ERROR;
5938         mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
5939         mlxsw_reg_ralue_act_local_pack(ralue_pl, trap_action, 0, 0);
5940         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
5941 }
5942
5943 static int
5944 mlxsw_sp_fib_entry_op_unreachable(struct mlxsw_sp *mlxsw_sp,
5945                                   struct mlxsw_sp_fib_entry *fib_entry,
5946                                   enum mlxsw_reg_ralue_op op)
5947 {
5948         enum mlxsw_reg_ralue_trap_action trap_action;
5949         char ralue_pl[MLXSW_REG_RALUE_LEN];
5950         u16 trap_id;
5951
5952         trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
5953         trap_id = MLXSW_TRAP_ID_RTR_INGRESS1;
5954
5955         mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
5956         mlxsw_reg_ralue_act_local_pack(ralue_pl, trap_action, trap_id, 0);
5957         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
5958 }
5959
5960 static int
5961 mlxsw_sp_fib_entry_op_ipip_decap(struct mlxsw_sp *mlxsw_sp,
5962                                  struct mlxsw_sp_fib_entry *fib_entry,
5963                                  enum mlxsw_reg_ralue_op op)
5964 {
5965         struct mlxsw_sp_ipip_entry *ipip_entry = fib_entry->decap.ipip_entry;
5966         const struct mlxsw_sp_ipip_ops *ipip_ops;
5967         char ralue_pl[MLXSW_REG_RALUE_LEN];
5968         int err;
5969
5970         if (WARN_ON(!ipip_entry))
5971                 return -EINVAL;
5972
5973         ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
5974         err = ipip_ops->decap_config(mlxsw_sp, ipip_entry,
5975                                      fib_entry->decap.tunnel_index);
5976         if (err)
5977                 return err;
5978
5979         mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
5980         mlxsw_reg_ralue_act_ip2me_tun_pack(ralue_pl,
5981                                            fib_entry->decap.tunnel_index);
5982         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
5983 }
5984
5985 static int mlxsw_sp_fib_entry_op_nve_decap(struct mlxsw_sp *mlxsw_sp,
5986                                            struct mlxsw_sp_fib_entry *fib_entry,
5987                                            enum mlxsw_reg_ralue_op op)
5988 {
5989         char ralue_pl[MLXSW_REG_RALUE_LEN];
5990
5991         mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
5992         mlxsw_reg_ralue_act_ip2me_tun_pack(ralue_pl,
5993                                            fib_entry->decap.tunnel_index);
5994         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
5995 }
5996
5997 static int __mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
5998                                    struct mlxsw_sp_fib_entry *fib_entry,
5999                                    enum mlxsw_reg_ralue_op op)
6000 {
6001         switch (fib_entry->type) {
6002         case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
6003                 return mlxsw_sp_fib_entry_op_remote(mlxsw_sp, fib_entry, op);
6004         case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
6005                 return mlxsw_sp_fib_entry_op_local(mlxsw_sp, fib_entry, op);
6006         case MLXSW_SP_FIB_ENTRY_TYPE_TRAP:
6007                 return mlxsw_sp_fib_entry_op_trap(mlxsw_sp, fib_entry, op);
6008         case MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE:
6009                 return mlxsw_sp_fib_entry_op_blackhole(mlxsw_sp, fib_entry, op);
6010         case MLXSW_SP_FIB_ENTRY_TYPE_UNREACHABLE:
6011                 return mlxsw_sp_fib_entry_op_unreachable(mlxsw_sp, fib_entry,
6012                                                          op);
6013         case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
6014                 return mlxsw_sp_fib_entry_op_ipip_decap(mlxsw_sp,
6015                                                         fib_entry, op);
6016         case MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP:
6017                 return mlxsw_sp_fib_entry_op_nve_decap(mlxsw_sp, fib_entry, op);
6018         }
6019         return -EINVAL;
6020 }
6021
6022 static int mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
6023                                  struct mlxsw_sp_fib_entry *fib_entry,
6024                                  enum mlxsw_reg_ralue_op op)
6025 {
6026         int err = __mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry, op);
6027
6028         if (err)
6029                 return err;
6030
6031         mlxsw_sp_fib_entry_hw_flags_refresh(mlxsw_sp, fib_entry, op);
6032
6033         return err;
6034 }
6035
6036 static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
6037                                      struct mlxsw_sp_fib_entry *fib_entry)
6038 {
6039         return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
6040                                      MLXSW_REG_RALUE_OP_WRITE_WRITE);
6041 }
6042
6043 static int mlxsw_sp_fib_entry_del(struct mlxsw_sp *mlxsw_sp,
6044                                   struct mlxsw_sp_fib_entry *fib_entry)
6045 {
6046         return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
6047                                      MLXSW_REG_RALUE_OP_WRITE_DELETE);
6048 }
6049
6050 static int
6051 mlxsw_sp_fib4_entry_type_set(struct mlxsw_sp *mlxsw_sp,
6052                              const struct fib_entry_notifier_info *fen_info,
6053                              struct mlxsw_sp_fib_entry *fib_entry)
6054 {
6055         struct mlxsw_sp_nexthop_group_info *nhgi = fib_entry->nh_group->nhgi;
6056         union mlxsw_sp_l3addr dip = { .addr4 = htonl(fen_info->dst) };
6057         struct mlxsw_sp_router *router = mlxsw_sp->router;
6058         u32 tb_id = mlxsw_sp_fix_tb_id(fen_info->tb_id);
6059         int ifindex = nhgi->nexthops[0].ifindex;
6060         struct mlxsw_sp_ipip_entry *ipip_entry;
6061
6062         switch (fen_info->type) {
6063         case RTN_LOCAL:
6064                 ipip_entry = mlxsw_sp_ipip_entry_find_by_decap(mlxsw_sp, ifindex,
6065                                                                MLXSW_SP_L3_PROTO_IPV4, dip);
6066                 if (ipip_entry && ipip_entry->ol_dev->flags & IFF_UP) {
6067                         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
6068                         return mlxsw_sp_fib_entry_decap_init(mlxsw_sp,
6069                                                              fib_entry,
6070                                                              ipip_entry);
6071                 }
6072                 if (mlxsw_sp_router_nve_is_decap(mlxsw_sp, tb_id,
6073                                                  MLXSW_SP_L3_PROTO_IPV4,
6074                                                  &dip)) {
6075                         u32 tunnel_index;
6076
6077                         tunnel_index = router->nve_decap_config.tunnel_index;
6078                         fib_entry->decap.tunnel_index = tunnel_index;
6079                         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP;
6080                         return 0;
6081                 }
6082                 fallthrough;
6083         case RTN_BROADCAST:
6084                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
6085                 return 0;
6086         case RTN_BLACKHOLE:
6087                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE;
6088                 return 0;
6089         case RTN_UNREACHABLE:
6090         case RTN_PROHIBIT:
6091                 /* Packets hitting these routes need to be trapped, but
6092                  * can do so with a lower priority than packets directed
6093                  * at the host, so use action type local instead of trap.
6094                  */
6095                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_UNREACHABLE;
6096                 return 0;
6097         case RTN_UNICAST:
6098                 if (nhgi->gateway)
6099                         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE;
6100                 else
6101                         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
6102                 return 0;
6103         default:
6104                 return -EINVAL;
6105         }
6106 }
6107
6108 static void
6109 mlxsw_sp_fib_entry_type_unset(struct mlxsw_sp *mlxsw_sp,
6110                               struct mlxsw_sp_fib_entry *fib_entry)
6111 {
6112         switch (fib_entry->type) {
6113         case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
6114                 mlxsw_sp_fib_entry_decap_fini(mlxsw_sp, fib_entry);
6115                 break;
6116         default:
6117                 break;
6118         }
6119 }
6120
6121 static void
6122 mlxsw_sp_fib4_entry_type_unset(struct mlxsw_sp *mlxsw_sp,
6123                                struct mlxsw_sp_fib4_entry *fib4_entry)
6124 {
6125         mlxsw_sp_fib_entry_type_unset(mlxsw_sp, &fib4_entry->common);
6126 }
6127
6128 static struct mlxsw_sp_fib4_entry *
6129 mlxsw_sp_fib4_entry_create(struct mlxsw_sp *mlxsw_sp,
6130                            struct mlxsw_sp_fib_node *fib_node,
6131                            const struct fib_entry_notifier_info *fen_info)
6132 {
6133         struct mlxsw_sp_fib4_entry *fib4_entry;
6134         struct mlxsw_sp_fib_entry *fib_entry;
6135         int err;
6136
6137         fib4_entry = kzalloc(sizeof(*fib4_entry), GFP_KERNEL);
6138         if (!fib4_entry)
6139                 return ERR_PTR(-ENOMEM);
6140         fib_entry = &fib4_entry->common;
6141
6142         err = mlxsw_sp_nexthop4_group_get(mlxsw_sp, fib_entry, fen_info->fi);
6143         if (err)
6144                 goto err_nexthop4_group_get;
6145
6146         err = mlxsw_sp_nexthop_group_vr_link(fib_entry->nh_group,
6147                                              fib_node->fib);
6148         if (err)
6149                 goto err_nexthop_group_vr_link;
6150
6151         err = mlxsw_sp_fib4_entry_type_set(mlxsw_sp, fen_info, fib_entry);
6152         if (err)
6153                 goto err_fib4_entry_type_set;
6154
6155         fib4_entry->fi = fen_info->fi;
6156         fib_info_hold(fib4_entry->fi);
6157         fib4_entry->tb_id = fen_info->tb_id;
6158         fib4_entry->type = fen_info->type;
6159         fib4_entry->dscp = fen_info->dscp;
6160
6161         fib_entry->fib_node = fib_node;
6162
6163         return fib4_entry;
6164
6165 err_fib4_entry_type_set:
6166         mlxsw_sp_nexthop_group_vr_unlink(fib_entry->nh_group, fib_node->fib);
6167 err_nexthop_group_vr_link:
6168         mlxsw_sp_nexthop4_group_put(mlxsw_sp, &fib4_entry->common);
6169 err_nexthop4_group_get:
6170         kfree(fib4_entry);
6171         return ERR_PTR(err);
6172 }
6173
6174 static void mlxsw_sp_fib4_entry_destroy(struct mlxsw_sp *mlxsw_sp,
6175                                         struct mlxsw_sp_fib4_entry *fib4_entry)
6176 {
6177         struct mlxsw_sp_fib_node *fib_node = fib4_entry->common.fib_node;
6178
6179         fib_info_put(fib4_entry->fi);
6180         mlxsw_sp_fib4_entry_type_unset(mlxsw_sp, fib4_entry);
6181         mlxsw_sp_nexthop_group_vr_unlink(fib4_entry->common.nh_group,
6182                                          fib_node->fib);
6183         mlxsw_sp_nexthop4_group_put(mlxsw_sp, &fib4_entry->common);
6184         kfree(fib4_entry);
6185 }
6186
6187 static struct mlxsw_sp_fib4_entry *
6188 mlxsw_sp_fib4_entry_lookup(struct mlxsw_sp *mlxsw_sp,
6189                            const struct fib_entry_notifier_info *fen_info)
6190 {
6191         struct mlxsw_sp_fib4_entry *fib4_entry;
6192         struct mlxsw_sp_fib_node *fib_node;
6193         struct mlxsw_sp_fib *fib;
6194         struct mlxsw_sp_vr *vr;
6195
6196         vr = mlxsw_sp_vr_find(mlxsw_sp, fen_info->tb_id);
6197         if (!vr)
6198                 return NULL;
6199         fib = mlxsw_sp_vr_fib(vr, MLXSW_SP_L3_PROTO_IPV4);
6200
6201         fib_node = mlxsw_sp_fib_node_lookup(fib, &fen_info->dst,
6202                                             sizeof(fen_info->dst),
6203                                             fen_info->dst_len);
6204         if (!fib_node)
6205                 return NULL;
6206
6207         fib4_entry = container_of(fib_node->fib_entry,
6208                                   struct mlxsw_sp_fib4_entry, common);
6209         if (fib4_entry->tb_id == fen_info->tb_id &&
6210             fib4_entry->dscp == fen_info->dscp &&
6211             fib4_entry->type == fen_info->type &&
6212             fib4_entry->fi == fen_info->fi)
6213                 return fib4_entry;
6214
6215         return NULL;
6216 }
6217
6218 static const struct rhashtable_params mlxsw_sp_fib_ht_params = {
6219         .key_offset = offsetof(struct mlxsw_sp_fib_node, key),
6220         .head_offset = offsetof(struct mlxsw_sp_fib_node, ht_node),
6221         .key_len = sizeof(struct mlxsw_sp_fib_key),
6222         .automatic_shrinking = true,
6223 };
6224
6225 static int mlxsw_sp_fib_node_insert(struct mlxsw_sp_fib *fib,
6226                                     struct mlxsw_sp_fib_node *fib_node)
6227 {
6228         return rhashtable_insert_fast(&fib->ht, &fib_node->ht_node,
6229                                       mlxsw_sp_fib_ht_params);
6230 }
6231
6232 static void mlxsw_sp_fib_node_remove(struct mlxsw_sp_fib *fib,
6233                                      struct mlxsw_sp_fib_node *fib_node)
6234 {
6235         rhashtable_remove_fast(&fib->ht, &fib_node->ht_node,
6236                                mlxsw_sp_fib_ht_params);
6237 }
6238
6239 static struct mlxsw_sp_fib_node *
6240 mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
6241                          size_t addr_len, unsigned char prefix_len)
6242 {
6243         struct mlxsw_sp_fib_key key;
6244
6245         memset(&key, 0, sizeof(key));
6246         memcpy(key.addr, addr, addr_len);
6247         key.prefix_len = prefix_len;
6248         return rhashtable_lookup_fast(&fib->ht, &key, mlxsw_sp_fib_ht_params);
6249 }
6250
6251 static struct mlxsw_sp_fib_node *
6252 mlxsw_sp_fib_node_create(struct mlxsw_sp_fib *fib, const void *addr,
6253                          size_t addr_len, unsigned char prefix_len)
6254 {
6255         struct mlxsw_sp_fib_node *fib_node;
6256
6257         fib_node = kzalloc(sizeof(*fib_node), GFP_KERNEL);
6258         if (!fib_node)
6259                 return NULL;
6260
6261         list_add(&fib_node->list, &fib->node_list);
6262         memcpy(fib_node->key.addr, addr, addr_len);
6263         fib_node->key.prefix_len = prefix_len;
6264
6265         return fib_node;
6266 }
6267
6268 static void mlxsw_sp_fib_node_destroy(struct mlxsw_sp_fib_node *fib_node)
6269 {
6270         list_del(&fib_node->list);
6271         kfree(fib_node);
6272 }
6273
6274 static int mlxsw_sp_fib_lpm_tree_link(struct mlxsw_sp *mlxsw_sp,
6275                                       struct mlxsw_sp_fib_node *fib_node)
6276 {
6277         struct mlxsw_sp_prefix_usage req_prefix_usage;
6278         struct mlxsw_sp_fib *fib = fib_node->fib;
6279         struct mlxsw_sp_lpm_tree *lpm_tree;
6280         int err;
6281
6282         lpm_tree = mlxsw_sp->router->lpm.proto_trees[fib->proto];
6283         if (lpm_tree->prefix_ref_count[fib_node->key.prefix_len] != 0)
6284                 goto out;
6285
6286         mlxsw_sp_prefix_usage_cpy(&req_prefix_usage, &lpm_tree->prefix_usage);
6287         mlxsw_sp_prefix_usage_set(&req_prefix_usage, fib_node->key.prefix_len);
6288         lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
6289                                          fib->proto);
6290         if (IS_ERR(lpm_tree))
6291                 return PTR_ERR(lpm_tree);
6292
6293         err = mlxsw_sp_vrs_lpm_tree_replace(mlxsw_sp, fib, lpm_tree);
6294         if (err)
6295                 goto err_lpm_tree_replace;
6296
6297 out:
6298         lpm_tree->prefix_ref_count[fib_node->key.prefix_len]++;
6299         return 0;
6300
6301 err_lpm_tree_replace:
6302         mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
6303         return err;
6304 }
6305
6306 static void mlxsw_sp_fib_lpm_tree_unlink(struct mlxsw_sp *mlxsw_sp,
6307                                          struct mlxsw_sp_fib_node *fib_node)
6308 {
6309         struct mlxsw_sp_lpm_tree *lpm_tree = fib_node->fib->lpm_tree;
6310         struct mlxsw_sp_prefix_usage req_prefix_usage;
6311         struct mlxsw_sp_fib *fib = fib_node->fib;
6312         int err;
6313
6314         if (--lpm_tree->prefix_ref_count[fib_node->key.prefix_len] != 0)
6315                 return;
6316         /* Try to construct a new LPM tree from the current prefix usage
6317          * minus the unused one. If we fail, continue using the old one.
6318          */
6319         mlxsw_sp_prefix_usage_cpy(&req_prefix_usage, &lpm_tree->prefix_usage);
6320         mlxsw_sp_prefix_usage_clear(&req_prefix_usage,
6321                                     fib_node->key.prefix_len);
6322         lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
6323                                          fib->proto);
6324         if (IS_ERR(lpm_tree))
6325                 return;
6326
6327         err = mlxsw_sp_vrs_lpm_tree_replace(mlxsw_sp, fib, lpm_tree);
6328         if (err)
6329                 goto err_lpm_tree_replace;
6330
6331         return;
6332
6333 err_lpm_tree_replace:
6334         mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
6335 }
6336
6337 static int mlxsw_sp_fib_node_init(struct mlxsw_sp *mlxsw_sp,
6338                                   struct mlxsw_sp_fib_node *fib_node,
6339                                   struct mlxsw_sp_fib *fib)
6340 {
6341         int err;
6342
6343         err = mlxsw_sp_fib_node_insert(fib, fib_node);
6344         if (err)
6345                 return err;
6346         fib_node->fib = fib;
6347
6348         err = mlxsw_sp_fib_lpm_tree_link(mlxsw_sp, fib_node);
6349         if (err)
6350                 goto err_fib_lpm_tree_link;
6351
6352         return 0;
6353
6354 err_fib_lpm_tree_link:
6355         fib_node->fib = NULL;
6356         mlxsw_sp_fib_node_remove(fib, fib_node);
6357         return err;
6358 }
6359
6360 static void mlxsw_sp_fib_node_fini(struct mlxsw_sp *mlxsw_sp,
6361                                    struct mlxsw_sp_fib_node *fib_node)
6362 {
6363         struct mlxsw_sp_fib *fib = fib_node->fib;
6364
6365         mlxsw_sp_fib_lpm_tree_unlink(mlxsw_sp, fib_node);
6366         fib_node->fib = NULL;
6367         mlxsw_sp_fib_node_remove(fib, fib_node);
6368 }
6369
6370 static struct mlxsw_sp_fib_node *
6371 mlxsw_sp_fib_node_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id, const void *addr,
6372                       size_t addr_len, unsigned char prefix_len,
6373                       enum mlxsw_sp_l3proto proto)
6374 {
6375         struct mlxsw_sp_fib_node *fib_node;
6376         struct mlxsw_sp_fib *fib;
6377         struct mlxsw_sp_vr *vr;
6378         int err;
6379
6380         vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id, NULL);
6381         if (IS_ERR(vr))
6382                 return ERR_CAST(vr);
6383         fib = mlxsw_sp_vr_fib(vr, proto);
6384
6385         fib_node = mlxsw_sp_fib_node_lookup(fib, addr, addr_len, prefix_len);
6386         if (fib_node)
6387                 return fib_node;
6388
6389         fib_node = mlxsw_sp_fib_node_create(fib, addr, addr_len, prefix_len);
6390         if (!fib_node) {
6391                 err = -ENOMEM;
6392                 goto err_fib_node_create;
6393         }
6394
6395         err = mlxsw_sp_fib_node_init(mlxsw_sp, fib_node, fib);
6396         if (err)
6397                 goto err_fib_node_init;
6398
6399         return fib_node;
6400
6401 err_fib_node_init:
6402         mlxsw_sp_fib_node_destroy(fib_node);
6403 err_fib_node_create:
6404         mlxsw_sp_vr_put(mlxsw_sp, vr);
6405         return ERR_PTR(err);
6406 }
6407
6408 static void mlxsw_sp_fib_node_put(struct mlxsw_sp *mlxsw_sp,
6409                                   struct mlxsw_sp_fib_node *fib_node)
6410 {
6411         struct mlxsw_sp_vr *vr = fib_node->fib->vr;
6412
6413         if (fib_node->fib_entry)
6414                 return;
6415         mlxsw_sp_fib_node_fini(mlxsw_sp, fib_node);
6416         mlxsw_sp_fib_node_destroy(fib_node);
6417         mlxsw_sp_vr_put(mlxsw_sp, vr);
6418 }
6419
6420 static int mlxsw_sp_fib_node_entry_link(struct mlxsw_sp *mlxsw_sp,
6421                                         struct mlxsw_sp_fib_entry *fib_entry)
6422 {
6423         struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
6424         int err;
6425
6426         fib_node->fib_entry = fib_entry;
6427
6428         err = mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
6429         if (err)
6430                 goto err_fib_entry_update;
6431
6432         return 0;
6433
6434 err_fib_entry_update:
6435         fib_node->fib_entry = NULL;
6436         return err;
6437 }
6438
6439 static void
6440 mlxsw_sp_fib_node_entry_unlink(struct mlxsw_sp *mlxsw_sp,
6441                                struct mlxsw_sp_fib_entry *fib_entry)
6442 {
6443         struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
6444
6445         mlxsw_sp_fib_entry_del(mlxsw_sp, fib_entry);
6446         fib_node->fib_entry = NULL;
6447 }
6448
6449 static bool mlxsw_sp_fib4_allow_replace(struct mlxsw_sp_fib4_entry *fib4_entry)
6450 {
6451         struct mlxsw_sp_fib_node *fib_node = fib4_entry->common.fib_node;
6452         struct mlxsw_sp_fib4_entry *fib4_replaced;
6453
6454         if (!fib_node->fib_entry)
6455                 return true;
6456
6457         fib4_replaced = container_of(fib_node->fib_entry,
6458                                      struct mlxsw_sp_fib4_entry, common);
6459         if (fib4_entry->tb_id == RT_TABLE_MAIN &&
6460             fib4_replaced->tb_id == RT_TABLE_LOCAL)
6461                 return false;
6462
6463         return true;
6464 }
6465
6466 static int
6467 mlxsw_sp_router_fib4_replace(struct mlxsw_sp *mlxsw_sp,
6468                              const struct fib_entry_notifier_info *fen_info)
6469 {
6470         struct mlxsw_sp_fib4_entry *fib4_entry, *fib4_replaced;
6471         struct mlxsw_sp_fib_entry *replaced;
6472         struct mlxsw_sp_fib_node *fib_node;
6473         int err;
6474
6475         if (fen_info->fi->nh &&
6476             !mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp, fen_info->fi->nh->id))
6477                 return 0;
6478
6479         fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, fen_info->tb_id,
6480                                          &fen_info->dst, sizeof(fen_info->dst),
6481                                          fen_info->dst_len,
6482                                          MLXSW_SP_L3_PROTO_IPV4);
6483         if (IS_ERR(fib_node)) {
6484                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to get FIB node\n");
6485                 return PTR_ERR(fib_node);
6486         }
6487
6488         fib4_entry = mlxsw_sp_fib4_entry_create(mlxsw_sp, fib_node, fen_info);
6489         if (IS_ERR(fib4_entry)) {
6490                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to create FIB entry\n");
6491                 err = PTR_ERR(fib4_entry);
6492                 goto err_fib4_entry_create;
6493         }
6494
6495         if (!mlxsw_sp_fib4_allow_replace(fib4_entry)) {
6496                 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
6497                 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
6498                 return 0;
6499         }
6500
6501         replaced = fib_node->fib_entry;
6502         err = mlxsw_sp_fib_node_entry_link(mlxsw_sp, &fib4_entry->common);
6503         if (err) {
6504                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to link FIB entry to node\n");
6505                 goto err_fib_node_entry_link;
6506         }
6507
6508         /* Nothing to replace */
6509         if (!replaced)
6510                 return 0;
6511
6512         mlxsw_sp_fib_entry_hw_flags_clear(mlxsw_sp, replaced);
6513         fib4_replaced = container_of(replaced, struct mlxsw_sp_fib4_entry,
6514                                      common);
6515         mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_replaced);
6516
6517         return 0;
6518
6519 err_fib_node_entry_link:
6520         fib_node->fib_entry = replaced;
6521         mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
6522 err_fib4_entry_create:
6523         mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
6524         return err;
6525 }
6526
6527 static void mlxsw_sp_router_fib4_del(struct mlxsw_sp *mlxsw_sp,
6528                                      struct fib_entry_notifier_info *fen_info)
6529 {
6530         struct mlxsw_sp_fib4_entry *fib4_entry;
6531         struct mlxsw_sp_fib_node *fib_node;
6532
6533         fib4_entry = mlxsw_sp_fib4_entry_lookup(mlxsw_sp, fen_info);
6534         if (!fib4_entry)
6535                 return;
6536         fib_node = fib4_entry->common.fib_node;
6537
6538         mlxsw_sp_fib_node_entry_unlink(mlxsw_sp, &fib4_entry->common);
6539         mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
6540         mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
6541 }
6542
6543 static bool mlxsw_sp_fib6_rt_should_ignore(const struct fib6_info *rt)
6544 {
6545         /* Multicast routes aren't supported, so ignore them. Neighbour
6546          * Discovery packets are specifically trapped.
6547          */
6548         if (ipv6_addr_type(&rt->fib6_dst.addr) & IPV6_ADDR_MULTICAST)
6549                 return true;
6550
6551         /* Cloned routes are irrelevant in the forwarding path. */
6552         if (rt->fib6_flags & RTF_CACHE)
6553                 return true;
6554
6555         return false;
6556 }
6557
6558 static struct mlxsw_sp_rt6 *mlxsw_sp_rt6_create(struct fib6_info *rt)
6559 {
6560         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
6561
6562         mlxsw_sp_rt6 = kzalloc(sizeof(*mlxsw_sp_rt6), GFP_KERNEL);
6563         if (!mlxsw_sp_rt6)
6564                 return ERR_PTR(-ENOMEM);
6565
6566         /* In case of route replace, replaced route is deleted with
6567          * no notification. Take reference to prevent accessing freed
6568          * memory.
6569          */
6570         mlxsw_sp_rt6->rt = rt;
6571         fib6_info_hold(rt);
6572
6573         return mlxsw_sp_rt6;
6574 }
6575
6576 #if IS_ENABLED(CONFIG_IPV6)
6577 static void mlxsw_sp_rt6_release(struct fib6_info *rt)
6578 {
6579         fib6_info_release(rt);
6580 }
6581 #else
6582 static void mlxsw_sp_rt6_release(struct fib6_info *rt)
6583 {
6584 }
6585 #endif
6586
6587 static void mlxsw_sp_rt6_destroy(struct mlxsw_sp_rt6 *mlxsw_sp_rt6)
6588 {
6589         struct fib6_nh *fib6_nh = mlxsw_sp_rt6->rt->fib6_nh;
6590
6591         if (!mlxsw_sp_rt6->rt->nh)
6592                 fib6_nh->fib_nh_flags &= ~RTNH_F_OFFLOAD;
6593         mlxsw_sp_rt6_release(mlxsw_sp_rt6->rt);
6594         kfree(mlxsw_sp_rt6);
6595 }
6596
6597 static struct fib6_info *
6598 mlxsw_sp_fib6_entry_rt(const struct mlxsw_sp_fib6_entry *fib6_entry)
6599 {
6600         return list_first_entry(&fib6_entry->rt6_list, struct mlxsw_sp_rt6,
6601                                 list)->rt;
6602 }
6603
6604 static struct mlxsw_sp_rt6 *
6605 mlxsw_sp_fib6_entry_rt_find(const struct mlxsw_sp_fib6_entry *fib6_entry,
6606                             const struct fib6_info *rt)
6607 {
6608         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
6609
6610         list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
6611                 if (mlxsw_sp_rt6->rt == rt)
6612                         return mlxsw_sp_rt6;
6613         }
6614
6615         return NULL;
6616 }
6617
6618 static bool mlxsw_sp_nexthop6_ipip_type(const struct mlxsw_sp *mlxsw_sp,
6619                                         const struct fib6_info *rt,
6620                                         enum mlxsw_sp_ipip_type *ret)
6621 {
6622         return rt->fib6_nh->fib_nh_dev &&
6623                mlxsw_sp_netdev_ipip_type(mlxsw_sp, rt->fib6_nh->fib_nh_dev, ret);
6624 }
6625
6626 static int mlxsw_sp_nexthop6_init(struct mlxsw_sp *mlxsw_sp,
6627                                   struct mlxsw_sp_nexthop_group *nh_grp,
6628                                   struct mlxsw_sp_nexthop *nh,
6629                                   const struct fib6_info *rt)
6630 {
6631         struct net_device *dev = rt->fib6_nh->fib_nh_dev;
6632         int err;
6633
6634         nh->nhgi = nh_grp->nhgi;
6635         nh->nh_weight = rt->fib6_nh->fib_nh_weight;
6636         memcpy(&nh->gw_addr, &rt->fib6_nh->fib_nh_gw6, sizeof(nh->gw_addr));
6637 #if IS_ENABLED(CONFIG_IPV6)
6638         nh->neigh_tbl = &nd_tbl;
6639 #endif
6640         mlxsw_sp_nexthop_counter_alloc(mlxsw_sp, nh);
6641
6642         list_add_tail(&nh->router_list_node, &mlxsw_sp->router->nexthop_list);
6643
6644         if (!dev)
6645                 return 0;
6646         nh->ifindex = dev->ifindex;
6647
6648         err = mlxsw_sp_nexthop_type_init(mlxsw_sp, nh, dev);
6649         if (err)
6650                 goto err_nexthop_type_init;
6651
6652         return 0;
6653
6654 err_nexthop_type_init:
6655         list_del(&nh->router_list_node);
6656         mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
6657         return err;
6658 }
6659
6660 static void mlxsw_sp_nexthop6_fini(struct mlxsw_sp *mlxsw_sp,
6661                                    struct mlxsw_sp_nexthop *nh)
6662 {
6663         mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
6664         list_del(&nh->router_list_node);
6665         mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
6666 }
6667
6668 static bool mlxsw_sp_rt6_is_gateway(const struct mlxsw_sp *mlxsw_sp,
6669                                     const struct fib6_info *rt)
6670 {
6671         return rt->fib6_nh->fib_nh_gw_family ||
6672                mlxsw_sp_nexthop6_ipip_type(mlxsw_sp, rt, NULL);
6673 }
6674
6675 static int
6676 mlxsw_sp_nexthop6_group_info_init(struct mlxsw_sp *mlxsw_sp,
6677                                   struct mlxsw_sp_nexthop_group *nh_grp,
6678                                   struct mlxsw_sp_fib6_entry *fib6_entry)
6679 {
6680         struct mlxsw_sp_nexthop_group_info *nhgi;
6681         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
6682         struct mlxsw_sp_nexthop *nh;
6683         int err, i;
6684
6685         nhgi = kzalloc(struct_size(nhgi, nexthops, fib6_entry->nrt6),
6686                        GFP_KERNEL);
6687         if (!nhgi)
6688                 return -ENOMEM;
6689         nh_grp->nhgi = nhgi;
6690         nhgi->nh_grp = nh_grp;
6691         mlxsw_sp_rt6 = list_first_entry(&fib6_entry->rt6_list,
6692                                         struct mlxsw_sp_rt6, list);
6693         nhgi->gateway = mlxsw_sp_rt6_is_gateway(mlxsw_sp, mlxsw_sp_rt6->rt);
6694         nhgi->count = fib6_entry->nrt6;
6695         for (i = 0; i < nhgi->count; i++) {
6696                 struct fib6_info *rt = mlxsw_sp_rt6->rt;
6697
6698                 nh = &nhgi->nexthops[i];
6699                 err = mlxsw_sp_nexthop6_init(mlxsw_sp, nh_grp, nh, rt);
6700                 if (err)
6701                         goto err_nexthop6_init;
6702                 mlxsw_sp_rt6 = list_next_entry(mlxsw_sp_rt6, list);
6703         }
6704         nh_grp->nhgi = nhgi;
6705         err = mlxsw_sp_nexthop_group_inc(mlxsw_sp);
6706         if (err)
6707                 goto err_group_inc;
6708         err = mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
6709         if (err)
6710                 goto err_group_refresh;
6711
6712         return 0;
6713
6714 err_group_refresh:
6715         mlxsw_sp_nexthop_group_dec(mlxsw_sp);
6716 err_group_inc:
6717         i = nhgi->count;
6718 err_nexthop6_init:
6719         for (i--; i >= 0; i--) {
6720                 nh = &nhgi->nexthops[i];
6721                 mlxsw_sp_nexthop6_fini(mlxsw_sp, nh);
6722         }
6723         kfree(nhgi);
6724         return err;
6725 }
6726
6727 static void
6728 mlxsw_sp_nexthop6_group_info_fini(struct mlxsw_sp *mlxsw_sp,
6729                                   struct mlxsw_sp_nexthop_group *nh_grp)
6730 {
6731         struct mlxsw_sp_nexthop_group_info *nhgi = nh_grp->nhgi;
6732         int i;
6733
6734         mlxsw_sp_nexthop_group_dec(mlxsw_sp);
6735         for (i = nhgi->count - 1; i >= 0; i--) {
6736                 struct mlxsw_sp_nexthop *nh = &nhgi->nexthops[i];
6737
6738                 mlxsw_sp_nexthop6_fini(mlxsw_sp, nh);
6739         }
6740         mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
6741         WARN_ON_ONCE(nhgi->adj_index_valid);
6742         kfree(nhgi);
6743 }
6744
6745 static struct mlxsw_sp_nexthop_group *
6746 mlxsw_sp_nexthop6_group_create(struct mlxsw_sp *mlxsw_sp,
6747                                struct mlxsw_sp_fib6_entry *fib6_entry)
6748 {
6749         struct mlxsw_sp_nexthop_group *nh_grp;
6750         int err;
6751
6752         nh_grp = kzalloc(sizeof(*nh_grp), GFP_KERNEL);
6753         if (!nh_grp)
6754                 return ERR_PTR(-ENOMEM);
6755         INIT_LIST_HEAD(&nh_grp->vr_list);
6756         err = rhashtable_init(&nh_grp->vr_ht,
6757                               &mlxsw_sp_nexthop_group_vr_ht_params);
6758         if (err)
6759                 goto err_nexthop_group_vr_ht_init;
6760         INIT_LIST_HEAD(&nh_grp->fib_list);
6761         nh_grp->type = MLXSW_SP_NEXTHOP_GROUP_TYPE_IPV6;
6762
6763         err = mlxsw_sp_nexthop6_group_info_init(mlxsw_sp, nh_grp, fib6_entry);
6764         if (err)
6765                 goto err_nexthop_group_info_init;
6766
6767         err = mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
6768         if (err)
6769                 goto err_nexthop_group_insert;
6770
6771         nh_grp->can_destroy = true;
6772
6773         return nh_grp;
6774
6775 err_nexthop_group_insert:
6776         mlxsw_sp_nexthop6_group_info_fini(mlxsw_sp, nh_grp);
6777 err_nexthop_group_info_init:
6778         rhashtable_destroy(&nh_grp->vr_ht);
6779 err_nexthop_group_vr_ht_init:
6780         kfree(nh_grp);
6781         return ERR_PTR(err);
6782 }
6783
6784 static void
6785 mlxsw_sp_nexthop6_group_destroy(struct mlxsw_sp *mlxsw_sp,
6786                                 struct mlxsw_sp_nexthop_group *nh_grp)
6787 {
6788         if (!nh_grp->can_destroy)
6789                 return;
6790         mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
6791         mlxsw_sp_nexthop6_group_info_fini(mlxsw_sp, nh_grp);
6792         WARN_ON_ONCE(!list_empty(&nh_grp->vr_list));
6793         rhashtable_destroy(&nh_grp->vr_ht);
6794         kfree(nh_grp);
6795 }
6796
6797 static int mlxsw_sp_nexthop6_group_get(struct mlxsw_sp *mlxsw_sp,
6798                                        struct mlxsw_sp_fib6_entry *fib6_entry)
6799 {
6800         struct fib6_info *rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
6801         struct mlxsw_sp_nexthop_group *nh_grp;
6802
6803         if (rt->nh) {
6804                 nh_grp = mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp,
6805                                                            rt->nh->id);
6806                 if (WARN_ON_ONCE(!nh_grp))
6807                         return -EINVAL;
6808                 goto out;
6809         }
6810
6811         nh_grp = mlxsw_sp_nexthop6_group_lookup(mlxsw_sp, fib6_entry);
6812         if (!nh_grp) {
6813                 nh_grp = mlxsw_sp_nexthop6_group_create(mlxsw_sp, fib6_entry);
6814                 if (IS_ERR(nh_grp))
6815                         return PTR_ERR(nh_grp);
6816         }
6817
6818         /* The route and the nexthop are described by the same struct, so we
6819          * need to the update the nexthop offload indication for the new route.
6820          */
6821         __mlxsw_sp_nexthop6_group_offload_refresh(nh_grp, fib6_entry);
6822
6823 out:
6824         list_add_tail(&fib6_entry->common.nexthop_group_node,
6825                       &nh_grp->fib_list);
6826         fib6_entry->common.nh_group = nh_grp;
6827
6828         return 0;
6829 }
6830
6831 static void mlxsw_sp_nexthop6_group_put(struct mlxsw_sp *mlxsw_sp,
6832                                         struct mlxsw_sp_fib_entry *fib_entry)
6833 {
6834         struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
6835
6836         list_del(&fib_entry->nexthop_group_node);
6837         if (!list_empty(&nh_grp->fib_list))
6838                 return;
6839
6840         if (nh_grp->type == MLXSW_SP_NEXTHOP_GROUP_TYPE_OBJ) {
6841                 mlxsw_sp_nexthop_obj_group_destroy(mlxsw_sp, nh_grp);
6842                 return;
6843         }
6844
6845         mlxsw_sp_nexthop6_group_destroy(mlxsw_sp, nh_grp);
6846 }
6847
6848 static int
6849 mlxsw_sp_nexthop6_group_update(struct mlxsw_sp *mlxsw_sp,
6850                                struct mlxsw_sp_fib6_entry *fib6_entry)
6851 {
6852         struct mlxsw_sp_nexthop_group *old_nh_grp = fib6_entry->common.nh_group;
6853         struct mlxsw_sp_fib_node *fib_node = fib6_entry->common.fib_node;
6854         int err;
6855
6856         mlxsw_sp_nexthop_group_vr_unlink(old_nh_grp, fib_node->fib);
6857         fib6_entry->common.nh_group = NULL;
6858         list_del(&fib6_entry->common.nexthop_group_node);
6859
6860         err = mlxsw_sp_nexthop6_group_get(mlxsw_sp, fib6_entry);
6861         if (err)
6862                 goto err_nexthop6_group_get;
6863
6864         err = mlxsw_sp_nexthop_group_vr_link(fib6_entry->common.nh_group,
6865                                              fib_node->fib);
6866         if (err)
6867                 goto err_nexthop_group_vr_link;
6868
6869         /* In case this entry is offloaded, then the adjacency index
6870          * currently associated with it in the device's table is that
6871          * of the old group. Start using the new one instead.
6872          */
6873         err = mlxsw_sp_fib_entry_update(mlxsw_sp, &fib6_entry->common);
6874         if (err)
6875                 goto err_fib_entry_update;
6876
6877         if (list_empty(&old_nh_grp->fib_list))
6878                 mlxsw_sp_nexthop6_group_destroy(mlxsw_sp, old_nh_grp);
6879
6880         return 0;
6881
6882 err_fib_entry_update:
6883         mlxsw_sp_nexthop_group_vr_unlink(fib6_entry->common.nh_group,
6884                                          fib_node->fib);
6885 err_nexthop_group_vr_link:
6886         mlxsw_sp_nexthop6_group_put(mlxsw_sp, &fib6_entry->common);
6887 err_nexthop6_group_get:
6888         list_add_tail(&fib6_entry->common.nexthop_group_node,
6889                       &old_nh_grp->fib_list);
6890         fib6_entry->common.nh_group = old_nh_grp;
6891         mlxsw_sp_nexthop_group_vr_link(old_nh_grp, fib_node->fib);
6892         return err;
6893 }
6894
6895 static int
6896 mlxsw_sp_fib6_entry_nexthop_add(struct mlxsw_sp *mlxsw_sp,
6897                                 struct mlxsw_sp_fib6_entry *fib6_entry,
6898                                 struct fib6_info **rt_arr, unsigned int nrt6)
6899 {
6900         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
6901         int err, i;
6902
6903         for (i = 0; i < nrt6; i++) {
6904                 mlxsw_sp_rt6 = mlxsw_sp_rt6_create(rt_arr[i]);
6905                 if (IS_ERR(mlxsw_sp_rt6)) {
6906                         err = PTR_ERR(mlxsw_sp_rt6);
6907                         goto err_rt6_unwind;
6908                 }
6909
6910                 list_add_tail(&mlxsw_sp_rt6->list, &fib6_entry->rt6_list);
6911                 fib6_entry->nrt6++;
6912         }
6913
6914         err = mlxsw_sp_nexthop6_group_update(mlxsw_sp, fib6_entry);
6915         if (err)
6916                 goto err_rt6_unwind;
6917
6918         return 0;
6919
6920 err_rt6_unwind:
6921         for (; i > 0; i--) {
6922                 fib6_entry->nrt6--;
6923                 mlxsw_sp_rt6 = list_last_entry(&fib6_entry->rt6_list,
6924                                                struct mlxsw_sp_rt6, list);
6925                 list_del(&mlxsw_sp_rt6->list);
6926                 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
6927         }
6928         return err;
6929 }
6930
6931 static void
6932 mlxsw_sp_fib6_entry_nexthop_del(struct mlxsw_sp *mlxsw_sp,
6933                                 struct mlxsw_sp_fib6_entry *fib6_entry,
6934                                 struct fib6_info **rt_arr, unsigned int nrt6)
6935 {
6936         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
6937         int i;
6938
6939         for (i = 0; i < nrt6; i++) {
6940                 mlxsw_sp_rt6 = mlxsw_sp_fib6_entry_rt_find(fib6_entry,
6941                                                            rt_arr[i]);
6942                 if (WARN_ON_ONCE(!mlxsw_sp_rt6))
6943                         continue;
6944
6945                 fib6_entry->nrt6--;
6946                 list_del(&mlxsw_sp_rt6->list);
6947                 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
6948         }
6949
6950         mlxsw_sp_nexthop6_group_update(mlxsw_sp, fib6_entry);
6951 }
6952
6953 static int
6954 mlxsw_sp_fib6_entry_type_set_local(struct mlxsw_sp *mlxsw_sp,
6955                                    struct mlxsw_sp_fib_entry *fib_entry,
6956                                    const struct fib6_info *rt)
6957 {
6958         struct mlxsw_sp_nexthop_group_info *nhgi = fib_entry->nh_group->nhgi;
6959         union mlxsw_sp_l3addr dip = { .addr6 = rt->fib6_dst.addr };
6960         u32 tb_id = mlxsw_sp_fix_tb_id(rt->fib6_table->tb6_id);
6961         struct mlxsw_sp_router *router = mlxsw_sp->router;
6962         int ifindex = nhgi->nexthops[0].ifindex;
6963         struct mlxsw_sp_ipip_entry *ipip_entry;
6964
6965         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
6966         ipip_entry = mlxsw_sp_ipip_entry_find_by_decap(mlxsw_sp, ifindex,
6967                                                        MLXSW_SP_L3_PROTO_IPV6,
6968                                                        dip);
6969
6970         if (ipip_entry && ipip_entry->ol_dev->flags & IFF_UP) {
6971                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
6972                 return mlxsw_sp_fib_entry_decap_init(mlxsw_sp, fib_entry,
6973                                                      ipip_entry);
6974         }
6975         if (mlxsw_sp_router_nve_is_decap(mlxsw_sp, tb_id,
6976                                          MLXSW_SP_L3_PROTO_IPV6, &dip)) {
6977                 u32 tunnel_index;
6978
6979                 tunnel_index = router->nve_decap_config.tunnel_index;
6980                 fib_entry->decap.tunnel_index = tunnel_index;
6981                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP;
6982         }
6983
6984         return 0;
6985 }
6986
6987 static int mlxsw_sp_fib6_entry_type_set(struct mlxsw_sp *mlxsw_sp,
6988                                         struct mlxsw_sp_fib_entry *fib_entry,
6989                                         const struct fib6_info *rt)
6990 {
6991         if (rt->fib6_flags & RTF_LOCAL)
6992                 return mlxsw_sp_fib6_entry_type_set_local(mlxsw_sp, fib_entry,
6993                                                           rt);
6994         if (rt->fib6_flags & RTF_ANYCAST)
6995                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
6996         else if (rt->fib6_type == RTN_BLACKHOLE)
6997                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE;
6998         else if (rt->fib6_flags & RTF_REJECT)
6999                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_UNREACHABLE;
7000         else if (fib_entry->nh_group->nhgi->gateway)
7001                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE;
7002         else
7003                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
7004
7005         return 0;
7006 }
7007
7008 static void
7009 mlxsw_sp_fib6_entry_rt_destroy_all(struct mlxsw_sp_fib6_entry *fib6_entry)
7010 {
7011         struct mlxsw_sp_rt6 *mlxsw_sp_rt6, *tmp;
7012
7013         list_for_each_entry_safe(mlxsw_sp_rt6, tmp, &fib6_entry->rt6_list,
7014                                  list) {
7015                 fib6_entry->nrt6--;
7016                 list_del(&mlxsw_sp_rt6->list);
7017                 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
7018         }
7019 }
7020
7021 static struct mlxsw_sp_fib6_entry *
7022 mlxsw_sp_fib6_entry_create(struct mlxsw_sp *mlxsw_sp,
7023                            struct mlxsw_sp_fib_node *fib_node,
7024                            struct fib6_info **rt_arr, unsigned int nrt6)
7025 {
7026         struct mlxsw_sp_fib6_entry *fib6_entry;
7027         struct mlxsw_sp_fib_entry *fib_entry;
7028         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
7029         int err, i;
7030
7031         fib6_entry = kzalloc(sizeof(*fib6_entry), GFP_KERNEL);
7032         if (!fib6_entry)
7033                 return ERR_PTR(-ENOMEM);
7034         fib_entry = &fib6_entry->common;
7035
7036         INIT_LIST_HEAD(&fib6_entry->rt6_list);
7037
7038         for (i = 0; i < nrt6; i++) {
7039                 mlxsw_sp_rt6 = mlxsw_sp_rt6_create(rt_arr[i]);
7040                 if (IS_ERR(mlxsw_sp_rt6)) {
7041                         err = PTR_ERR(mlxsw_sp_rt6);
7042                         goto err_rt6_unwind;
7043                 }
7044                 list_add_tail(&mlxsw_sp_rt6->list, &fib6_entry->rt6_list);
7045                 fib6_entry->nrt6++;
7046         }
7047
7048         err = mlxsw_sp_nexthop6_group_get(mlxsw_sp, fib6_entry);
7049         if (err)
7050                 goto err_rt6_unwind;
7051
7052         err = mlxsw_sp_nexthop_group_vr_link(fib_entry->nh_group,
7053                                              fib_node->fib);
7054         if (err)
7055                 goto err_nexthop_group_vr_link;
7056
7057         err = mlxsw_sp_fib6_entry_type_set(mlxsw_sp, fib_entry, rt_arr[0]);
7058         if (err)
7059                 goto err_fib6_entry_type_set;
7060
7061         fib_entry->fib_node = fib_node;
7062
7063         return fib6_entry;
7064
7065 err_fib6_entry_type_set:
7066         mlxsw_sp_nexthop_group_vr_unlink(fib_entry->nh_group, fib_node->fib);
7067 err_nexthop_group_vr_link:
7068         mlxsw_sp_nexthop6_group_put(mlxsw_sp, fib_entry);
7069 err_rt6_unwind:
7070         for (; i > 0; i--) {
7071                 fib6_entry->nrt6--;
7072                 mlxsw_sp_rt6 = list_last_entry(&fib6_entry->rt6_list,
7073                                                struct mlxsw_sp_rt6, list);
7074                 list_del(&mlxsw_sp_rt6->list);
7075                 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
7076         }
7077         kfree(fib6_entry);
7078         return ERR_PTR(err);
7079 }
7080
7081 static void
7082 mlxsw_sp_fib6_entry_type_unset(struct mlxsw_sp *mlxsw_sp,
7083                                struct mlxsw_sp_fib6_entry *fib6_entry)
7084 {
7085         mlxsw_sp_fib_entry_type_unset(mlxsw_sp, &fib6_entry->common);
7086 }
7087
7088 static void mlxsw_sp_fib6_entry_destroy(struct mlxsw_sp *mlxsw_sp,
7089                                         struct mlxsw_sp_fib6_entry *fib6_entry)
7090 {
7091         struct mlxsw_sp_fib_node *fib_node = fib6_entry->common.fib_node;
7092
7093         mlxsw_sp_fib6_entry_type_unset(mlxsw_sp, fib6_entry);
7094         mlxsw_sp_nexthop_group_vr_unlink(fib6_entry->common.nh_group,
7095                                          fib_node->fib);
7096         mlxsw_sp_nexthop6_group_put(mlxsw_sp, &fib6_entry->common);
7097         mlxsw_sp_fib6_entry_rt_destroy_all(fib6_entry);
7098         WARN_ON(fib6_entry->nrt6);
7099         kfree(fib6_entry);
7100 }
7101
7102 static struct mlxsw_sp_fib6_entry *
7103 mlxsw_sp_fib6_entry_lookup(struct mlxsw_sp *mlxsw_sp,
7104                            const struct fib6_info *rt)
7105 {
7106         struct mlxsw_sp_fib6_entry *fib6_entry;
7107         struct mlxsw_sp_fib_node *fib_node;
7108         struct mlxsw_sp_fib *fib;
7109         struct fib6_info *cmp_rt;
7110         struct mlxsw_sp_vr *vr;
7111
7112         vr = mlxsw_sp_vr_find(mlxsw_sp, rt->fib6_table->tb6_id);
7113         if (!vr)
7114                 return NULL;
7115         fib = mlxsw_sp_vr_fib(vr, MLXSW_SP_L3_PROTO_IPV6);
7116
7117         fib_node = mlxsw_sp_fib_node_lookup(fib, &rt->fib6_dst.addr,
7118                                             sizeof(rt->fib6_dst.addr),
7119                                             rt->fib6_dst.plen);
7120         if (!fib_node)
7121                 return NULL;
7122
7123         fib6_entry = container_of(fib_node->fib_entry,
7124                                   struct mlxsw_sp_fib6_entry, common);
7125         cmp_rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
7126         if (rt->fib6_table->tb6_id == cmp_rt->fib6_table->tb6_id &&
7127             rt->fib6_metric == cmp_rt->fib6_metric &&
7128             mlxsw_sp_fib6_entry_rt_find(fib6_entry, rt))
7129                 return fib6_entry;
7130
7131         return NULL;
7132 }
7133
7134 static bool mlxsw_sp_fib6_allow_replace(struct mlxsw_sp_fib6_entry *fib6_entry)
7135 {
7136         struct mlxsw_sp_fib_node *fib_node = fib6_entry->common.fib_node;
7137         struct mlxsw_sp_fib6_entry *fib6_replaced;
7138         struct fib6_info *rt, *rt_replaced;
7139
7140         if (!fib_node->fib_entry)
7141                 return true;
7142
7143         fib6_replaced = container_of(fib_node->fib_entry,
7144                                      struct mlxsw_sp_fib6_entry,
7145                                      common);
7146         rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
7147         rt_replaced = mlxsw_sp_fib6_entry_rt(fib6_replaced);
7148         if (rt->fib6_table->tb6_id == RT_TABLE_MAIN &&
7149             rt_replaced->fib6_table->tb6_id == RT_TABLE_LOCAL)
7150                 return false;
7151
7152         return true;
7153 }
7154
7155 static int mlxsw_sp_router_fib6_replace(struct mlxsw_sp *mlxsw_sp,
7156                                         struct fib6_info **rt_arr,
7157                                         unsigned int nrt6)
7158 {
7159         struct mlxsw_sp_fib6_entry *fib6_entry, *fib6_replaced;
7160         struct mlxsw_sp_fib_entry *replaced;
7161         struct mlxsw_sp_fib_node *fib_node;
7162         struct fib6_info *rt = rt_arr[0];
7163         int err;
7164
7165         if (rt->fib6_src.plen)
7166                 return -EINVAL;
7167
7168         if (mlxsw_sp_fib6_rt_should_ignore(rt))
7169                 return 0;
7170
7171         if (rt->nh && !mlxsw_sp_nexthop_obj_group_lookup(mlxsw_sp, rt->nh->id))
7172                 return 0;
7173
7174         fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, rt->fib6_table->tb6_id,
7175                                          &rt->fib6_dst.addr,
7176                                          sizeof(rt->fib6_dst.addr),
7177                                          rt->fib6_dst.plen,
7178                                          MLXSW_SP_L3_PROTO_IPV6);
7179         if (IS_ERR(fib_node))
7180                 return PTR_ERR(fib_node);
7181
7182         fib6_entry = mlxsw_sp_fib6_entry_create(mlxsw_sp, fib_node, rt_arr,
7183                                                 nrt6);
7184         if (IS_ERR(fib6_entry)) {
7185                 err = PTR_ERR(fib6_entry);
7186                 goto err_fib6_entry_create;
7187         }
7188
7189         if (!mlxsw_sp_fib6_allow_replace(fib6_entry)) {
7190                 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
7191                 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7192                 return 0;
7193         }
7194
7195         replaced = fib_node->fib_entry;
7196         err = mlxsw_sp_fib_node_entry_link(mlxsw_sp, &fib6_entry->common);
7197         if (err)
7198                 goto err_fib_node_entry_link;
7199
7200         /* Nothing to replace */
7201         if (!replaced)
7202                 return 0;
7203
7204         mlxsw_sp_fib_entry_hw_flags_clear(mlxsw_sp, replaced);
7205         fib6_replaced = container_of(replaced, struct mlxsw_sp_fib6_entry,
7206                                      common);
7207         mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_replaced);
7208
7209         return 0;
7210
7211 err_fib_node_entry_link:
7212         fib_node->fib_entry = replaced;
7213         mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
7214 err_fib6_entry_create:
7215         mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7216         return err;
7217 }
7218
7219 static int mlxsw_sp_router_fib6_append(struct mlxsw_sp *mlxsw_sp,
7220                                        struct fib6_info **rt_arr,
7221                                        unsigned int nrt6)
7222 {
7223         struct mlxsw_sp_fib6_entry *fib6_entry;
7224         struct mlxsw_sp_fib_node *fib_node;
7225         struct fib6_info *rt = rt_arr[0];
7226         int err;
7227
7228         if (rt->fib6_src.plen)
7229                 return -EINVAL;
7230
7231         if (mlxsw_sp_fib6_rt_should_ignore(rt))
7232                 return 0;
7233
7234         fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, rt->fib6_table->tb6_id,
7235                                          &rt->fib6_dst.addr,
7236                                          sizeof(rt->fib6_dst.addr),
7237                                          rt->fib6_dst.plen,
7238                                          MLXSW_SP_L3_PROTO_IPV6);
7239         if (IS_ERR(fib_node))
7240                 return PTR_ERR(fib_node);
7241
7242         if (WARN_ON_ONCE(!fib_node->fib_entry)) {
7243                 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7244                 return -EINVAL;
7245         }
7246
7247         fib6_entry = container_of(fib_node->fib_entry,
7248                                   struct mlxsw_sp_fib6_entry, common);
7249         err = mlxsw_sp_fib6_entry_nexthop_add(mlxsw_sp, fib6_entry, rt_arr,
7250                                               nrt6);
7251         if (err)
7252                 goto err_fib6_entry_nexthop_add;
7253
7254         return 0;
7255
7256 err_fib6_entry_nexthop_add:
7257         mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7258         return err;
7259 }
7260
7261 static void mlxsw_sp_router_fib6_del(struct mlxsw_sp *mlxsw_sp,
7262                                      struct fib6_info **rt_arr,
7263                                      unsigned int nrt6)
7264 {
7265         struct mlxsw_sp_fib6_entry *fib6_entry;
7266         struct mlxsw_sp_fib_node *fib_node;
7267         struct fib6_info *rt = rt_arr[0];
7268
7269         if (mlxsw_sp_fib6_rt_should_ignore(rt))
7270                 return;
7271
7272         /* Multipath routes are first added to the FIB trie and only then
7273          * notified. If we vetoed the addition, we will get a delete
7274          * notification for a route we do not have. Therefore, do not warn if
7275          * route was not found.
7276          */
7277         fib6_entry = mlxsw_sp_fib6_entry_lookup(mlxsw_sp, rt);
7278         if (!fib6_entry)
7279                 return;
7280
7281         /* If not all the nexthops are deleted, then only reduce the nexthop
7282          * group.
7283          */
7284         if (nrt6 != fib6_entry->nrt6) {
7285                 mlxsw_sp_fib6_entry_nexthop_del(mlxsw_sp, fib6_entry, rt_arr,
7286                                                 nrt6);
7287                 return;
7288         }
7289
7290         fib_node = fib6_entry->common.fib_node;
7291
7292         mlxsw_sp_fib_node_entry_unlink(mlxsw_sp, &fib6_entry->common);
7293         mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
7294         mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7295 }
7296
7297 static struct mlxsw_sp_mr_table *
7298 mlxsw_sp_router_fibmr_family_to_table(struct mlxsw_sp_vr *vr, int family)
7299 {
7300         if (family == RTNL_FAMILY_IPMR)
7301                 return vr->mr_table[MLXSW_SP_L3_PROTO_IPV4];
7302         else
7303                 return vr->mr_table[MLXSW_SP_L3_PROTO_IPV6];
7304 }
7305
7306 static int mlxsw_sp_router_fibmr_add(struct mlxsw_sp *mlxsw_sp,
7307                                      struct mfc_entry_notifier_info *men_info,
7308                                      bool replace)
7309 {
7310         struct mlxsw_sp_mr_table *mrt;
7311         struct mlxsw_sp_vr *vr;
7312
7313         vr = mlxsw_sp_vr_get(mlxsw_sp, men_info->tb_id, NULL);
7314         if (IS_ERR(vr))
7315                 return PTR_ERR(vr);
7316
7317         mrt = mlxsw_sp_router_fibmr_family_to_table(vr, men_info->info.family);
7318         return mlxsw_sp_mr_route_add(mrt, men_info->mfc, replace);
7319 }
7320
7321 static void mlxsw_sp_router_fibmr_del(struct mlxsw_sp *mlxsw_sp,
7322                                       struct mfc_entry_notifier_info *men_info)
7323 {
7324         struct mlxsw_sp_mr_table *mrt;
7325         struct mlxsw_sp_vr *vr;
7326
7327         vr = mlxsw_sp_vr_find(mlxsw_sp, men_info->tb_id);
7328         if (WARN_ON(!vr))
7329                 return;
7330
7331         mrt = mlxsw_sp_router_fibmr_family_to_table(vr, men_info->info.family);
7332         mlxsw_sp_mr_route_del(mrt, men_info->mfc);
7333         mlxsw_sp_vr_put(mlxsw_sp, vr);
7334 }
7335
7336 static int
7337 mlxsw_sp_router_fibmr_vif_add(struct mlxsw_sp *mlxsw_sp,
7338                               struct vif_entry_notifier_info *ven_info)
7339 {
7340         struct mlxsw_sp_mr_table *mrt;
7341         struct mlxsw_sp_rif *rif;
7342         struct mlxsw_sp_vr *vr;
7343
7344         vr = mlxsw_sp_vr_get(mlxsw_sp, ven_info->tb_id, NULL);
7345         if (IS_ERR(vr))
7346                 return PTR_ERR(vr);
7347
7348         mrt = mlxsw_sp_router_fibmr_family_to_table(vr, ven_info->info.family);
7349         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, ven_info->dev);
7350         return mlxsw_sp_mr_vif_add(mrt, ven_info->dev,
7351                                    ven_info->vif_index,
7352                                    ven_info->vif_flags, rif);
7353 }
7354
7355 static void
7356 mlxsw_sp_router_fibmr_vif_del(struct mlxsw_sp *mlxsw_sp,
7357                               struct vif_entry_notifier_info *ven_info)
7358 {
7359         struct mlxsw_sp_mr_table *mrt;
7360         struct mlxsw_sp_vr *vr;
7361
7362         vr = mlxsw_sp_vr_find(mlxsw_sp, ven_info->tb_id);
7363         if (WARN_ON(!vr))
7364                 return;
7365
7366         mrt = mlxsw_sp_router_fibmr_family_to_table(vr, ven_info->info.family);
7367         mlxsw_sp_mr_vif_del(mrt, ven_info->vif_index);
7368         mlxsw_sp_vr_put(mlxsw_sp, vr);
7369 }
7370
7371 static void mlxsw_sp_fib4_node_flush(struct mlxsw_sp *mlxsw_sp,
7372                                      struct mlxsw_sp_fib_node *fib_node)
7373 {
7374         struct mlxsw_sp_fib4_entry *fib4_entry;
7375
7376         fib4_entry = container_of(fib_node->fib_entry,
7377                                   struct mlxsw_sp_fib4_entry, common);
7378         mlxsw_sp_fib_node_entry_unlink(mlxsw_sp, fib_node->fib_entry);
7379         mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
7380         mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7381 }
7382
7383 static void mlxsw_sp_fib6_node_flush(struct mlxsw_sp *mlxsw_sp,
7384                                      struct mlxsw_sp_fib_node *fib_node)
7385 {
7386         struct mlxsw_sp_fib6_entry *fib6_entry;
7387
7388         fib6_entry = container_of(fib_node->fib_entry,
7389                                   struct mlxsw_sp_fib6_entry, common);
7390         mlxsw_sp_fib_node_entry_unlink(mlxsw_sp, fib_node->fib_entry);
7391         mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
7392         mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
7393 }
7394
7395 static void mlxsw_sp_fib_node_flush(struct mlxsw_sp *mlxsw_sp,
7396                                     struct mlxsw_sp_fib_node *fib_node)
7397 {
7398         switch (fib_node->fib->proto) {
7399         case MLXSW_SP_L3_PROTO_IPV4:
7400                 mlxsw_sp_fib4_node_flush(mlxsw_sp, fib_node);
7401                 break;
7402         case MLXSW_SP_L3_PROTO_IPV6:
7403                 mlxsw_sp_fib6_node_flush(mlxsw_sp, fib_node);
7404                 break;
7405         }
7406 }
7407
7408 static void mlxsw_sp_vr_fib_flush(struct mlxsw_sp *mlxsw_sp,
7409                                   struct mlxsw_sp_vr *vr,
7410                                   enum mlxsw_sp_l3proto proto)
7411 {
7412         struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
7413         struct mlxsw_sp_fib_node *fib_node, *tmp;
7414
7415         list_for_each_entry_safe(fib_node, tmp, &fib->node_list, list) {
7416                 bool do_break = &tmp->list == &fib->node_list;
7417
7418                 mlxsw_sp_fib_node_flush(mlxsw_sp, fib_node);
7419                 if (do_break)
7420                         break;
7421         }
7422 }
7423
7424 static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp)
7425 {
7426         int max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
7427         int i, j;
7428
7429         for (i = 0; i < max_vrs; i++) {
7430                 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
7431
7432                 if (!mlxsw_sp_vr_is_used(vr))
7433                         continue;
7434
7435                 for (j = 0; j < MLXSW_SP_L3_PROTO_MAX; j++)
7436                         mlxsw_sp_mr_table_flush(vr->mr_table[j]);
7437                 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV4);
7438
7439                 /* If virtual router was only used for IPv4, then it's no
7440                  * longer used.
7441                  */
7442                 if (!mlxsw_sp_vr_is_used(vr))
7443                         continue;
7444                 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV6);
7445         }
7446 }
7447
7448 struct mlxsw_sp_fib6_event_work {
7449         struct fib6_info **rt_arr;
7450         unsigned int nrt6;
7451 };
7452
7453 struct mlxsw_sp_fib_event_work {
7454         struct work_struct work;
7455         union {
7456                 struct mlxsw_sp_fib6_event_work fib6_work;
7457                 struct fib_entry_notifier_info fen_info;
7458                 struct fib_rule_notifier_info fr_info;
7459                 struct fib_nh_notifier_info fnh_info;
7460                 struct mfc_entry_notifier_info men_info;
7461                 struct vif_entry_notifier_info ven_info;
7462         };
7463         struct mlxsw_sp *mlxsw_sp;
7464         unsigned long event;
7465 };
7466
7467 static int
7468 mlxsw_sp_router_fib6_work_init(struct mlxsw_sp_fib6_event_work *fib6_work,
7469                                struct fib6_entry_notifier_info *fen6_info)
7470 {
7471         struct fib6_info *rt = fen6_info->rt;
7472         struct fib6_info **rt_arr;
7473         struct fib6_info *iter;
7474         unsigned int nrt6;
7475         int i = 0;
7476
7477         nrt6 = fen6_info->nsiblings + 1;
7478
7479         rt_arr = kcalloc(nrt6, sizeof(struct fib6_info *), GFP_ATOMIC);
7480         if (!rt_arr)
7481                 return -ENOMEM;
7482
7483         fib6_work->rt_arr = rt_arr;
7484         fib6_work->nrt6 = nrt6;
7485
7486         rt_arr[0] = rt;
7487         fib6_info_hold(rt);
7488
7489         if (!fen6_info->nsiblings)
7490                 return 0;
7491
7492         list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings) {
7493                 if (i == fen6_info->nsiblings)
7494                         break;
7495
7496                 rt_arr[i + 1] = iter;
7497                 fib6_info_hold(iter);
7498                 i++;
7499         }
7500         WARN_ON_ONCE(i != fen6_info->nsiblings);
7501
7502         return 0;
7503 }
7504
7505 static void
7506 mlxsw_sp_router_fib6_work_fini(struct mlxsw_sp_fib6_event_work *fib6_work)
7507 {
7508         int i;
7509
7510         for (i = 0; i < fib6_work->nrt6; i++)
7511                 mlxsw_sp_rt6_release(fib6_work->rt_arr[i]);
7512         kfree(fib6_work->rt_arr);
7513 }
7514
7515 static void mlxsw_sp_router_fib4_event_work(struct work_struct *work)
7516 {
7517         struct mlxsw_sp_fib_event_work *fib_work =
7518                 container_of(work, struct mlxsw_sp_fib_event_work, work);
7519         struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
7520         int err;
7521
7522         mutex_lock(&mlxsw_sp->router->lock);
7523         mlxsw_sp_span_respin(mlxsw_sp);
7524
7525         switch (fib_work->event) {
7526         case FIB_EVENT_ENTRY_REPLACE:
7527                 err = mlxsw_sp_router_fib4_replace(mlxsw_sp,
7528                                                    &fib_work->fen_info);
7529                 if (err) {
7530                         dev_warn(mlxsw_sp->bus_info->dev, "FIB replace failed.\n");
7531                         mlxsw_sp_fib4_offload_failed_flag_set(mlxsw_sp,
7532                                                               &fib_work->fen_info);
7533                 }
7534                 fib_info_put(fib_work->fen_info.fi);
7535                 break;
7536         case FIB_EVENT_ENTRY_DEL:
7537                 mlxsw_sp_router_fib4_del(mlxsw_sp, &fib_work->fen_info);
7538                 fib_info_put(fib_work->fen_info.fi);
7539                 break;
7540         case FIB_EVENT_NH_ADD:
7541         case FIB_EVENT_NH_DEL:
7542                 mlxsw_sp_nexthop4_event(mlxsw_sp, fib_work->event,
7543                                         fib_work->fnh_info.fib_nh);
7544                 fib_info_put(fib_work->fnh_info.fib_nh->nh_parent);
7545                 break;
7546         }
7547         mutex_unlock(&mlxsw_sp->router->lock);
7548         kfree(fib_work);
7549 }
7550
7551 static void mlxsw_sp_router_fib6_event_work(struct work_struct *work)
7552 {
7553         struct mlxsw_sp_fib_event_work *fib_work =
7554                     container_of(work, struct mlxsw_sp_fib_event_work, work);
7555         struct mlxsw_sp_fib6_event_work *fib6_work = &fib_work->fib6_work;
7556         struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
7557         int err;
7558
7559         mutex_lock(&mlxsw_sp->router->lock);
7560         mlxsw_sp_span_respin(mlxsw_sp);
7561
7562         switch (fib_work->event) {
7563         case FIB_EVENT_ENTRY_REPLACE:
7564                 err = mlxsw_sp_router_fib6_replace(mlxsw_sp,
7565                                                    fib6_work->rt_arr,
7566                                                    fib6_work->nrt6);
7567                 if (err) {
7568                         dev_warn(mlxsw_sp->bus_info->dev, "FIB replace failed.\n");
7569                         mlxsw_sp_fib6_offload_failed_flag_set(mlxsw_sp,
7570                                                               fib6_work->rt_arr,
7571                                                               fib6_work->nrt6);
7572                 }
7573                 mlxsw_sp_router_fib6_work_fini(fib6_work);
7574                 break;
7575         case FIB_EVENT_ENTRY_APPEND:
7576                 err = mlxsw_sp_router_fib6_append(mlxsw_sp,
7577                                                   fib6_work->rt_arr,
7578                                                   fib6_work->nrt6);
7579                 if (err) {
7580                         dev_warn(mlxsw_sp->bus_info->dev, "FIB append failed.\n");
7581                         mlxsw_sp_fib6_offload_failed_flag_set(mlxsw_sp,
7582                                                               fib6_work->rt_arr,
7583                                                               fib6_work->nrt6);
7584                 }
7585                 mlxsw_sp_router_fib6_work_fini(fib6_work);
7586                 break;
7587         case FIB_EVENT_ENTRY_DEL:
7588                 mlxsw_sp_router_fib6_del(mlxsw_sp,
7589                                          fib6_work->rt_arr,
7590                                          fib6_work->nrt6);
7591                 mlxsw_sp_router_fib6_work_fini(fib6_work);
7592                 break;
7593         }
7594         mutex_unlock(&mlxsw_sp->router->lock);
7595         kfree(fib_work);
7596 }
7597
7598 static void mlxsw_sp_router_fibmr_event_work(struct work_struct *work)
7599 {
7600         struct mlxsw_sp_fib_event_work *fib_work =
7601                 container_of(work, struct mlxsw_sp_fib_event_work, work);
7602         struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
7603         bool replace;
7604         int err;
7605
7606         rtnl_lock();
7607         mutex_lock(&mlxsw_sp->router->lock);
7608         switch (fib_work->event) {
7609         case FIB_EVENT_ENTRY_REPLACE:
7610         case FIB_EVENT_ENTRY_ADD:
7611                 replace = fib_work->event == FIB_EVENT_ENTRY_REPLACE;
7612
7613                 err = mlxsw_sp_router_fibmr_add(mlxsw_sp, &fib_work->men_info,
7614                                                 replace);
7615                 if (err)
7616                         dev_warn(mlxsw_sp->bus_info->dev, "MR entry add failed.\n");
7617                 mr_cache_put(fib_work->men_info.mfc);
7618                 break;
7619         case FIB_EVENT_ENTRY_DEL:
7620                 mlxsw_sp_router_fibmr_del(mlxsw_sp, &fib_work->men_info);
7621                 mr_cache_put(fib_work->men_info.mfc);
7622                 break;
7623         case FIB_EVENT_VIF_ADD:
7624                 err = mlxsw_sp_router_fibmr_vif_add(mlxsw_sp,
7625                                                     &fib_work->ven_info);
7626                 if (err)
7627                         dev_warn(mlxsw_sp->bus_info->dev, "MR VIF add failed.\n");
7628                 dev_put(fib_work->ven_info.dev);
7629                 break;
7630         case FIB_EVENT_VIF_DEL:
7631                 mlxsw_sp_router_fibmr_vif_del(mlxsw_sp,
7632                                               &fib_work->ven_info);
7633                 dev_put(fib_work->ven_info.dev);
7634                 break;
7635         }
7636         mutex_unlock(&mlxsw_sp->router->lock);
7637         rtnl_unlock();
7638         kfree(fib_work);
7639 }
7640
7641 static void mlxsw_sp_router_fib4_event(struct mlxsw_sp_fib_event_work *fib_work,
7642                                        struct fib_notifier_info *info)
7643 {
7644         struct fib_entry_notifier_info *fen_info;
7645         struct fib_nh_notifier_info *fnh_info;
7646
7647         switch (fib_work->event) {
7648         case FIB_EVENT_ENTRY_REPLACE:
7649         case FIB_EVENT_ENTRY_DEL:
7650                 fen_info = container_of(info, struct fib_entry_notifier_info,
7651                                         info);
7652                 fib_work->fen_info = *fen_info;
7653                 /* Take reference on fib_info to prevent it from being
7654                  * freed while work is queued. Release it afterwards.
7655                  */
7656                 fib_info_hold(fib_work->fen_info.fi);
7657                 break;
7658         case FIB_EVENT_NH_ADD:
7659         case FIB_EVENT_NH_DEL:
7660                 fnh_info = container_of(info, struct fib_nh_notifier_info,
7661                                         info);
7662                 fib_work->fnh_info = *fnh_info;
7663                 fib_info_hold(fib_work->fnh_info.fib_nh->nh_parent);
7664                 break;
7665         }
7666 }
7667
7668 static int mlxsw_sp_router_fib6_event(struct mlxsw_sp_fib_event_work *fib_work,
7669                                       struct fib_notifier_info *info)
7670 {
7671         struct fib6_entry_notifier_info *fen6_info;
7672         int err;
7673
7674         switch (fib_work->event) {
7675         case FIB_EVENT_ENTRY_REPLACE:
7676         case FIB_EVENT_ENTRY_APPEND:
7677         case FIB_EVENT_ENTRY_DEL:
7678                 fen6_info = container_of(info, struct fib6_entry_notifier_info,
7679                                          info);
7680                 err = mlxsw_sp_router_fib6_work_init(&fib_work->fib6_work,
7681                                                      fen6_info);
7682                 if (err)
7683                         return err;
7684                 break;
7685         }
7686
7687         return 0;
7688 }
7689
7690 static void
7691 mlxsw_sp_router_fibmr_event(struct mlxsw_sp_fib_event_work *fib_work,
7692                             struct fib_notifier_info *info)
7693 {
7694         switch (fib_work->event) {
7695         case FIB_EVENT_ENTRY_REPLACE:
7696         case FIB_EVENT_ENTRY_ADD:
7697         case FIB_EVENT_ENTRY_DEL:
7698                 memcpy(&fib_work->men_info, info, sizeof(fib_work->men_info));
7699                 mr_cache_hold(fib_work->men_info.mfc);
7700                 break;
7701         case FIB_EVENT_VIF_ADD:
7702         case FIB_EVENT_VIF_DEL:
7703                 memcpy(&fib_work->ven_info, info, sizeof(fib_work->ven_info));
7704                 dev_hold(fib_work->ven_info.dev);
7705                 break;
7706         }
7707 }
7708
7709 static int mlxsw_sp_router_fib_rule_event(unsigned long event,
7710                                           struct fib_notifier_info *info,
7711                                           struct mlxsw_sp *mlxsw_sp)
7712 {
7713         struct netlink_ext_ack *extack = info->extack;
7714         struct fib_rule_notifier_info *fr_info;
7715         struct fib_rule *rule;
7716         int err = 0;
7717
7718         /* nothing to do at the moment */
7719         if (event == FIB_EVENT_RULE_DEL)
7720                 return 0;
7721
7722         fr_info = container_of(info, struct fib_rule_notifier_info, info);
7723         rule = fr_info->rule;
7724
7725         /* Rule only affects locally generated traffic */
7726         if (rule->iifindex == mlxsw_sp_net(mlxsw_sp)->loopback_dev->ifindex)
7727                 return 0;
7728
7729         switch (info->family) {
7730         case AF_INET:
7731                 if (!fib4_rule_default(rule) && !rule->l3mdev)
7732                         err = -EOPNOTSUPP;
7733                 break;
7734         case AF_INET6:
7735                 if (!fib6_rule_default(rule) && !rule->l3mdev)
7736                         err = -EOPNOTSUPP;
7737                 break;
7738         case RTNL_FAMILY_IPMR:
7739                 if (!ipmr_rule_default(rule) && !rule->l3mdev)
7740                         err = -EOPNOTSUPP;
7741                 break;
7742         case RTNL_FAMILY_IP6MR:
7743                 if (!ip6mr_rule_default(rule) && !rule->l3mdev)
7744                         err = -EOPNOTSUPP;
7745                 break;
7746         }
7747
7748         if (err < 0)
7749                 NL_SET_ERR_MSG_MOD(extack, "FIB rules not supported");
7750
7751         return err;
7752 }
7753
7754 /* Called with rcu_read_lock() */
7755 static int mlxsw_sp_router_fib_event(struct notifier_block *nb,
7756                                      unsigned long event, void *ptr)
7757 {
7758         struct mlxsw_sp_fib_event_work *fib_work;
7759         struct fib_notifier_info *info = ptr;
7760         struct mlxsw_sp_router *router;
7761         int err;
7762
7763         if ((info->family != AF_INET && info->family != AF_INET6 &&
7764              info->family != RTNL_FAMILY_IPMR &&
7765              info->family != RTNL_FAMILY_IP6MR))
7766                 return NOTIFY_DONE;
7767
7768         router = container_of(nb, struct mlxsw_sp_router, fib_nb);
7769
7770         switch (event) {
7771         case FIB_EVENT_RULE_ADD:
7772         case FIB_EVENT_RULE_DEL:
7773                 err = mlxsw_sp_router_fib_rule_event(event, info,
7774                                                      router->mlxsw_sp);
7775                 return notifier_from_errno(err);
7776         case FIB_EVENT_ENTRY_ADD:
7777         case FIB_EVENT_ENTRY_REPLACE:
7778         case FIB_EVENT_ENTRY_APPEND:
7779                 if (info->family == AF_INET) {
7780                         struct fib_entry_notifier_info *fen_info = ptr;
7781
7782                         if (fen_info->fi->fib_nh_is_v6) {
7783                                 NL_SET_ERR_MSG_MOD(info->extack, "IPv6 gateway with IPv4 route is not supported");
7784                                 return notifier_from_errno(-EINVAL);
7785                         }
7786                 }
7787                 break;
7788         }
7789
7790         fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC);
7791         if (!fib_work)
7792                 return NOTIFY_BAD;
7793
7794         fib_work->mlxsw_sp = router->mlxsw_sp;
7795         fib_work->event = event;
7796
7797         switch (info->family) {
7798         case AF_INET:
7799                 INIT_WORK(&fib_work->work, mlxsw_sp_router_fib4_event_work);
7800                 mlxsw_sp_router_fib4_event(fib_work, info);
7801                 break;
7802         case AF_INET6:
7803                 INIT_WORK(&fib_work->work, mlxsw_sp_router_fib6_event_work);
7804                 err = mlxsw_sp_router_fib6_event(fib_work, info);
7805                 if (err)
7806                         goto err_fib_event;
7807                 break;
7808         case RTNL_FAMILY_IP6MR:
7809         case RTNL_FAMILY_IPMR:
7810                 INIT_WORK(&fib_work->work, mlxsw_sp_router_fibmr_event_work);
7811                 mlxsw_sp_router_fibmr_event(fib_work, info);
7812                 break;
7813         }
7814
7815         mlxsw_core_schedule_work(&fib_work->work);
7816
7817         return NOTIFY_DONE;
7818
7819 err_fib_event:
7820         kfree(fib_work);
7821         return NOTIFY_BAD;
7822 }
7823
7824 static struct mlxsw_sp_rif *
7825 mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp,
7826                          const struct net_device *dev)
7827 {
7828         int max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
7829         int i;
7830
7831         for (i = 0; i < max_rifs; i++)
7832                 if (mlxsw_sp->router->rifs[i] &&
7833                     mlxsw_sp_rif_dev_is(mlxsw_sp->router->rifs[i], dev))
7834                         return mlxsw_sp->router->rifs[i];
7835
7836         return NULL;
7837 }
7838
7839 bool mlxsw_sp_rif_exists(struct mlxsw_sp *mlxsw_sp,
7840                          const struct net_device *dev)
7841 {
7842         struct mlxsw_sp_rif *rif;
7843
7844         mutex_lock(&mlxsw_sp->router->lock);
7845         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
7846         mutex_unlock(&mlxsw_sp->router->lock);
7847
7848         return rif;
7849 }
7850
7851 u16 mlxsw_sp_rif_vid(struct mlxsw_sp *mlxsw_sp, const struct net_device *dev)
7852 {
7853         struct mlxsw_sp_rif *rif;
7854         u16 vid = 0;
7855
7856         mutex_lock(&mlxsw_sp->router->lock);
7857         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
7858         if (!rif)
7859                 goto out;
7860
7861         /* We only return the VID for VLAN RIFs. Otherwise we return an
7862          * invalid value (0).
7863          */
7864         if (rif->ops->type != MLXSW_SP_RIF_TYPE_VLAN)
7865                 goto out;
7866
7867         vid = mlxsw_sp_fid_8021q_vid(rif->fid);
7868
7869 out:
7870         mutex_unlock(&mlxsw_sp->router->lock);
7871         return vid;
7872 }
7873
7874 static int mlxsw_sp_router_rif_disable(struct mlxsw_sp *mlxsw_sp, u16 rif)
7875 {
7876         char ritr_pl[MLXSW_REG_RITR_LEN];
7877         int err;
7878
7879         mlxsw_reg_ritr_rif_pack(ritr_pl, rif);
7880         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
7881         if (err)
7882                 return err;
7883
7884         mlxsw_reg_ritr_enable_set(ritr_pl, false);
7885         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
7886 }
7887
7888 static void mlxsw_sp_router_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
7889                                           struct mlxsw_sp_rif *rif)
7890 {
7891         /* Signal to nexthop cleanup that the RIF is going away. */
7892         rif->crif->rif = NULL;
7893
7894         mlxsw_sp_router_rif_disable(mlxsw_sp, rif->rif_index);
7895         mlxsw_sp_nexthop_rif_gone_sync(mlxsw_sp, rif);
7896         mlxsw_sp_neigh_rif_gone_sync(mlxsw_sp, rif);
7897 }
7898
7899 static bool __mlxsw_sp_dev_addr_list_empty(const struct net_device *dev)
7900 {
7901         struct inet6_dev *inet6_dev;
7902         struct in_device *idev;
7903
7904         idev = __in_dev_get_rcu(dev);
7905         if (idev && idev->ifa_list)
7906                 return false;
7907
7908         inet6_dev = __in6_dev_get(dev);
7909         if (inet6_dev && !list_empty(&inet6_dev->addr_list))
7910                 return false;
7911
7912         return true;
7913 }
7914
7915 static bool mlxsw_sp_dev_addr_list_empty(const struct net_device *dev)
7916 {
7917         bool addr_list_empty;
7918
7919         rcu_read_lock();
7920         addr_list_empty = __mlxsw_sp_dev_addr_list_empty(dev);
7921         rcu_read_unlock();
7922
7923         return addr_list_empty;
7924 }
7925
7926 static bool
7927 mlxsw_sp_rif_should_config(struct mlxsw_sp_rif *rif, struct net_device *dev,
7928                            unsigned long event)
7929 {
7930         bool addr_list_empty;
7931
7932         switch (event) {
7933         case NETDEV_UP:
7934                 return rif == NULL;
7935         case NETDEV_DOWN:
7936                 addr_list_empty = mlxsw_sp_dev_addr_list_empty(dev);
7937
7938                 /* macvlans do not have a RIF, but rather piggy back on the
7939                  * RIF of their lower device.
7940                  */
7941                 if (netif_is_macvlan(dev) && addr_list_empty)
7942                         return true;
7943
7944                 if (rif && addr_list_empty &&
7945                     !netif_is_l3_slave(mlxsw_sp_rif_dev(rif)))
7946                         return true;
7947                 /* It is possible we already removed the RIF ourselves
7948                  * if it was assigned to a netdev that is now a bridge
7949                  * or LAG slave.
7950                  */
7951                 return false;
7952         }
7953
7954         return false;
7955 }
7956
7957 static enum mlxsw_sp_rif_type
7958 mlxsw_sp_dev_rif_type(const struct mlxsw_sp *mlxsw_sp,
7959                       const struct net_device *dev)
7960 {
7961         enum mlxsw_sp_fid_type type;
7962
7963         if (mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, NULL))
7964                 return MLXSW_SP_RIF_TYPE_IPIP_LB;
7965
7966         /* Otherwise RIF type is derived from the type of the underlying FID. */
7967         if (is_vlan_dev(dev) && netif_is_bridge_master(vlan_dev_real_dev(dev)))
7968                 type = MLXSW_SP_FID_TYPE_8021Q;
7969         else if (netif_is_bridge_master(dev) && br_vlan_enabled(dev))
7970                 type = MLXSW_SP_FID_TYPE_8021Q;
7971         else if (netif_is_bridge_master(dev))
7972                 type = MLXSW_SP_FID_TYPE_8021D;
7973         else
7974                 type = MLXSW_SP_FID_TYPE_RFID;
7975
7976         return mlxsw_sp_fid_type_rif_type(mlxsw_sp, type);
7977 }
7978
7979 static int mlxsw_sp_rif_index_alloc(struct mlxsw_sp *mlxsw_sp, u16 *p_rif_index,
7980                                     u8 rif_entries)
7981 {
7982         *p_rif_index = gen_pool_alloc(mlxsw_sp->router->rifs_table,
7983                                       rif_entries);
7984         if (*p_rif_index == 0)
7985                 return -ENOBUFS;
7986         *p_rif_index -= MLXSW_SP_ROUTER_GENALLOC_OFFSET;
7987
7988         /* RIF indexes must be aligned to the allocation size. */
7989         WARN_ON_ONCE(*p_rif_index % rif_entries);
7990
7991         return 0;
7992 }
7993
7994 static void mlxsw_sp_rif_index_free(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
7995                                     u8 rif_entries)
7996 {
7997         gen_pool_free(mlxsw_sp->router->rifs_table,
7998                       MLXSW_SP_ROUTER_GENALLOC_OFFSET + rif_index, rif_entries);
7999 }
8000
8001 static struct mlxsw_sp_rif *mlxsw_sp_rif_alloc(size_t rif_size, u16 rif_index,
8002                                                u16 vr_id,
8003                                                struct mlxsw_sp_crif *crif)
8004 {
8005         struct net_device *l3_dev = crif ? crif->key.dev : NULL;
8006         struct mlxsw_sp_rif *rif;
8007
8008         rif = kzalloc(rif_size, GFP_KERNEL);
8009         if (!rif)
8010                 return NULL;
8011
8012         INIT_LIST_HEAD(&rif->neigh_list);
8013         if (l3_dev) {
8014                 ether_addr_copy(rif->addr, l3_dev->dev_addr);
8015                 rif->mtu = l3_dev->mtu;
8016         }
8017         rif->vr_id = vr_id;
8018         rif->rif_index = rif_index;
8019         if (crif) {
8020                 rif->crif = crif;
8021                 crif->rif = rif;
8022         }
8023
8024         return rif;
8025 }
8026
8027 static void mlxsw_sp_rif_free(struct mlxsw_sp_rif *rif)
8028 {
8029         WARN_ON(!list_empty(&rif->neigh_list));
8030
8031         if (rif->crif)
8032                 rif->crif->rif = NULL;
8033         kfree(rif);
8034 }
8035
8036 struct mlxsw_sp_rif *mlxsw_sp_rif_by_index(const struct mlxsw_sp *mlxsw_sp,
8037                                            u16 rif_index)
8038 {
8039         return mlxsw_sp->router->rifs[rif_index];
8040 }
8041
8042 u16 mlxsw_sp_rif_index(const struct mlxsw_sp_rif *rif)
8043 {
8044         return rif->rif_index;
8045 }
8046
8047 u16 mlxsw_sp_ipip_lb_rif_index(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
8048 {
8049         return lb_rif->common.rif_index;
8050 }
8051
8052 u16 mlxsw_sp_ipip_lb_ul_vr_id(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
8053 {
8054         struct net_device *dev = mlxsw_sp_rif_dev(&lb_rif->common);
8055         u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(dev);
8056         struct mlxsw_sp_vr *ul_vr;
8057
8058         ul_vr = mlxsw_sp_vr_get(lb_rif->common.mlxsw_sp, ul_tb_id, NULL);
8059         if (WARN_ON(IS_ERR(ul_vr)))
8060                 return 0;
8061
8062         return ul_vr->id;
8063 }
8064
8065 u16 mlxsw_sp_ipip_lb_ul_rif_id(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
8066 {
8067         return lb_rif->ul_rif_id;
8068 }
8069
8070 static bool
8071 mlxsw_sp_router_port_l3_stats_enabled(struct mlxsw_sp_rif *rif)
8072 {
8073         return mlxsw_sp_rif_counter_valid_get(rif,
8074                                               MLXSW_SP_RIF_COUNTER_EGRESS) &&
8075                mlxsw_sp_rif_counter_valid_get(rif,
8076                                               MLXSW_SP_RIF_COUNTER_INGRESS);
8077 }
8078
8079 static int
8080 mlxsw_sp_router_port_l3_stats_enable(struct mlxsw_sp_rif *rif)
8081 {
8082         int err;
8083
8084         err = mlxsw_sp_rif_counter_alloc(rif, MLXSW_SP_RIF_COUNTER_INGRESS);
8085         if (err)
8086                 return err;
8087
8088         /* Clear stale data. */
8089         err = mlxsw_sp_rif_counter_fetch_clear(rif,
8090                                                MLXSW_SP_RIF_COUNTER_INGRESS,
8091                                                NULL);
8092         if (err)
8093                 goto err_clear_ingress;
8094
8095         err = mlxsw_sp_rif_counter_alloc(rif, MLXSW_SP_RIF_COUNTER_EGRESS);
8096         if (err)
8097                 goto err_alloc_egress;
8098
8099         /* Clear stale data. */
8100         err = mlxsw_sp_rif_counter_fetch_clear(rif,
8101                                                MLXSW_SP_RIF_COUNTER_EGRESS,
8102                                                NULL);
8103         if (err)
8104                 goto err_clear_egress;
8105
8106         return 0;
8107
8108 err_clear_egress:
8109         mlxsw_sp_rif_counter_free(rif, MLXSW_SP_RIF_COUNTER_EGRESS);
8110 err_alloc_egress:
8111 err_clear_ingress:
8112         mlxsw_sp_rif_counter_free(rif, MLXSW_SP_RIF_COUNTER_INGRESS);
8113         return err;
8114 }
8115
8116 static void
8117 mlxsw_sp_router_port_l3_stats_disable(struct mlxsw_sp_rif *rif)
8118 {
8119         mlxsw_sp_rif_counter_free(rif, MLXSW_SP_RIF_COUNTER_EGRESS);
8120         mlxsw_sp_rif_counter_free(rif, MLXSW_SP_RIF_COUNTER_INGRESS);
8121 }
8122
8123 static void
8124 mlxsw_sp_router_port_l3_stats_report_used(struct mlxsw_sp_rif *rif,
8125                                           struct netdev_notifier_offload_xstats_info *info)
8126 {
8127         if (!mlxsw_sp_router_port_l3_stats_enabled(rif))
8128                 return;
8129         netdev_offload_xstats_report_used(info->report_used);
8130 }
8131
8132 static int
8133 mlxsw_sp_router_port_l3_stats_fetch(struct mlxsw_sp_rif *rif,
8134                                     struct rtnl_hw_stats64 *p_stats)
8135 {
8136         struct mlxsw_sp_rif_counter_set_basic ingress;
8137         struct mlxsw_sp_rif_counter_set_basic egress;
8138         int err;
8139
8140         err = mlxsw_sp_rif_counter_fetch_clear(rif,
8141                                                MLXSW_SP_RIF_COUNTER_INGRESS,
8142                                                &ingress);
8143         if (err)
8144                 return err;
8145
8146         err = mlxsw_sp_rif_counter_fetch_clear(rif,
8147                                                MLXSW_SP_RIF_COUNTER_EGRESS,
8148                                                &egress);
8149         if (err)
8150                 return err;
8151
8152 #define MLXSW_SP_ROUTER_ALL_GOOD(SET, SFX)              \
8153                 ((SET.good_unicast_ ## SFX) +           \
8154                  (SET.good_multicast_ ## SFX) +         \
8155                  (SET.good_broadcast_ ## SFX))
8156
8157         p_stats->rx_packets = MLXSW_SP_ROUTER_ALL_GOOD(ingress, packets);
8158         p_stats->tx_packets = MLXSW_SP_ROUTER_ALL_GOOD(egress, packets);
8159         p_stats->rx_bytes = MLXSW_SP_ROUTER_ALL_GOOD(ingress, bytes);
8160         p_stats->tx_bytes = MLXSW_SP_ROUTER_ALL_GOOD(egress, bytes);
8161         p_stats->rx_errors = ingress.error_packets;
8162         p_stats->tx_errors = egress.error_packets;
8163         p_stats->rx_dropped = ingress.discard_packets;
8164         p_stats->tx_dropped = egress.discard_packets;
8165         p_stats->multicast = ingress.good_multicast_packets +
8166                              ingress.good_broadcast_packets;
8167
8168 #undef MLXSW_SP_ROUTER_ALL_GOOD
8169
8170         return 0;
8171 }
8172
8173 static int
8174 mlxsw_sp_router_port_l3_stats_report_delta(struct mlxsw_sp_rif *rif,
8175                                            struct netdev_notifier_offload_xstats_info *info)
8176 {
8177         struct rtnl_hw_stats64 stats = {};
8178         int err;
8179
8180         if (!mlxsw_sp_router_port_l3_stats_enabled(rif))
8181                 return 0;
8182
8183         err = mlxsw_sp_router_port_l3_stats_fetch(rif, &stats);
8184         if (err)
8185                 return err;
8186
8187         netdev_offload_xstats_report_delta(info->report_delta, &stats);
8188         return 0;
8189 }
8190
8191 struct mlxsw_sp_router_hwstats_notify_work {
8192         struct work_struct work;
8193         struct net_device *dev;
8194 };
8195
8196 static void mlxsw_sp_router_hwstats_notify_work(struct work_struct *work)
8197 {
8198         struct mlxsw_sp_router_hwstats_notify_work *hws_work =
8199                 container_of(work, struct mlxsw_sp_router_hwstats_notify_work,
8200                              work);
8201
8202         rtnl_lock();
8203         rtnl_offload_xstats_notify(hws_work->dev);
8204         rtnl_unlock();
8205         dev_put(hws_work->dev);
8206         kfree(hws_work);
8207 }
8208
8209 static void
8210 mlxsw_sp_router_hwstats_notify_schedule(struct net_device *dev)
8211 {
8212         struct mlxsw_sp_router_hwstats_notify_work *hws_work;
8213
8214         /* To collect notification payload, the core ends up sending another
8215          * notifier block message, which would deadlock on the attempt to
8216          * acquire the router lock again. Just postpone the notification until
8217          * later.
8218          */
8219
8220         hws_work = kzalloc(sizeof(*hws_work), GFP_KERNEL);
8221         if (!hws_work)
8222                 return;
8223
8224         INIT_WORK(&hws_work->work, mlxsw_sp_router_hwstats_notify_work);
8225         dev_hold(dev);
8226         hws_work->dev = dev;
8227         mlxsw_core_schedule_work(&hws_work->work);
8228 }
8229
8230 int mlxsw_sp_rif_dev_ifindex(const struct mlxsw_sp_rif *rif)
8231 {
8232         return mlxsw_sp_rif_dev(rif)->ifindex;
8233 }
8234
8235 bool mlxsw_sp_rif_has_dev(const struct mlxsw_sp_rif *rif)
8236 {
8237         return !!mlxsw_sp_rif_dev(rif);
8238 }
8239
8240 bool mlxsw_sp_rif_dev_is(const struct mlxsw_sp_rif *rif,
8241                          const struct net_device *dev)
8242 {
8243         return mlxsw_sp_rif_dev(rif) == dev;
8244 }
8245
8246 static void mlxsw_sp_rif_push_l3_stats(struct mlxsw_sp_rif *rif)
8247 {
8248         struct rtnl_hw_stats64 stats = {};
8249
8250         if (!mlxsw_sp_router_port_l3_stats_fetch(rif, &stats))
8251                 netdev_offload_xstats_push_delta(mlxsw_sp_rif_dev(rif),
8252                                                  NETDEV_OFFLOAD_XSTATS_TYPE_L3,
8253                                                  &stats);
8254 }
8255
8256 static struct mlxsw_sp_rif *
8257 mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp,
8258                     const struct mlxsw_sp_rif_params *params,
8259                     struct netlink_ext_ack *extack)
8260 {
8261         u8 rif_entries = params->double_entry ? 2 : 1;
8262         u32 tb_id = l3mdev_fib_table(params->dev);
8263         const struct mlxsw_sp_rif_ops *ops;
8264         struct mlxsw_sp_fid *fid = NULL;
8265         enum mlxsw_sp_rif_type type;
8266         struct mlxsw_sp_crif *crif;
8267         struct mlxsw_sp_rif *rif;
8268         struct mlxsw_sp_vr *vr;
8269         u16 rif_index;
8270         int i, err;
8271
8272         type = mlxsw_sp_dev_rif_type(mlxsw_sp, params->dev);
8273         ops = mlxsw_sp->router->rif_ops_arr[type];
8274
8275         vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id ? : RT_TABLE_MAIN, extack);
8276         if (IS_ERR(vr))
8277                 return ERR_CAST(vr);
8278         vr->rif_count++;
8279
8280         err = mlxsw_sp_rif_index_alloc(mlxsw_sp, &rif_index, rif_entries);
8281         if (err) {
8282                 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported router interfaces");
8283                 goto err_rif_index_alloc;
8284         }
8285
8286         crif = mlxsw_sp_crif_lookup(mlxsw_sp->router, params->dev);
8287         if (WARN_ON(!crif)) {
8288                 err = -ENOENT;
8289                 goto err_crif_lookup;
8290         }
8291
8292         rif = mlxsw_sp_rif_alloc(ops->rif_size, rif_index, vr->id, crif);
8293         if (!rif) {
8294                 err = -ENOMEM;
8295                 goto err_rif_alloc;
8296         }
8297         dev_hold(params->dev);
8298         mlxsw_sp->router->rifs[rif_index] = rif;
8299         rif->mlxsw_sp = mlxsw_sp;
8300         rif->ops = ops;
8301         rif->rif_entries = rif_entries;
8302
8303         if (ops->fid_get) {
8304                 fid = ops->fid_get(rif, params, extack);
8305                 if (IS_ERR(fid)) {
8306                         err = PTR_ERR(fid);
8307                         goto err_fid_get;
8308                 }
8309                 rif->fid = fid;
8310         }
8311
8312         if (ops->setup)
8313                 ops->setup(rif, params);
8314
8315         err = ops->configure(rif, extack);
8316         if (err)
8317                 goto err_configure;
8318
8319         for (i = 0; i < MLXSW_SP_L3_PROTO_MAX; i++) {
8320                 err = mlxsw_sp_mr_rif_add(vr->mr_table[i], rif);
8321                 if (err)
8322                         goto err_mr_rif_add;
8323         }
8324
8325         if (netdev_offload_xstats_enabled(params->dev,
8326                                           NETDEV_OFFLOAD_XSTATS_TYPE_L3)) {
8327                 err = mlxsw_sp_router_port_l3_stats_enable(rif);
8328                 if (err)
8329                         goto err_stats_enable;
8330                 mlxsw_sp_router_hwstats_notify_schedule(params->dev);
8331         } else {
8332                 mlxsw_sp_rif_counters_alloc(rif);
8333         }
8334
8335         atomic_add(rif_entries, &mlxsw_sp->router->rifs_count);
8336         return rif;
8337
8338 err_stats_enable:
8339 err_mr_rif_add:
8340         for (i--; i >= 0; i--)
8341                 mlxsw_sp_mr_rif_del(vr->mr_table[i], rif);
8342         ops->deconfigure(rif);
8343 err_configure:
8344         if (fid)
8345                 mlxsw_sp_fid_put(fid);
8346 err_fid_get:
8347         mlxsw_sp->router->rifs[rif_index] = NULL;
8348         dev_put(params->dev);
8349         mlxsw_sp_rif_free(rif);
8350 err_rif_alloc:
8351 err_crif_lookup:
8352         mlxsw_sp_rif_index_free(mlxsw_sp, rif_index, rif_entries);
8353 err_rif_index_alloc:
8354         vr->rif_count--;
8355         mlxsw_sp_vr_put(mlxsw_sp, vr);
8356         return ERR_PTR(err);
8357 }
8358
8359 static void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif)
8360 {
8361         struct net_device *dev = mlxsw_sp_rif_dev(rif);
8362         const struct mlxsw_sp_rif_ops *ops = rif->ops;
8363         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
8364         struct mlxsw_sp_crif *crif = rif->crif;
8365         struct mlxsw_sp_fid *fid = rif->fid;
8366         u8 rif_entries = rif->rif_entries;
8367         u16 rif_index = rif->rif_index;
8368         struct mlxsw_sp_vr *vr;
8369         int i;
8370
8371         atomic_sub(rif_entries, &mlxsw_sp->router->rifs_count);
8372         mlxsw_sp_router_rif_gone_sync(mlxsw_sp, rif);
8373         vr = &mlxsw_sp->router->vrs[rif->vr_id];
8374
8375         if (netdev_offload_xstats_enabled(dev, NETDEV_OFFLOAD_XSTATS_TYPE_L3)) {
8376                 mlxsw_sp_rif_push_l3_stats(rif);
8377                 mlxsw_sp_router_port_l3_stats_disable(rif);
8378                 mlxsw_sp_router_hwstats_notify_schedule(dev);
8379         } else {
8380                 mlxsw_sp_rif_counters_free(rif);
8381         }
8382
8383         for (i = 0; i < MLXSW_SP_L3_PROTO_MAX; i++)
8384                 mlxsw_sp_mr_rif_del(vr->mr_table[i], rif);
8385         ops->deconfigure(rif);
8386         if (fid)
8387                 /* Loopback RIFs are not associated with a FID. */
8388                 mlxsw_sp_fid_put(fid);
8389         mlxsw_sp->router->rifs[rif->rif_index] = NULL;
8390         dev_put(dev);
8391         mlxsw_sp_rif_free(rif);
8392         mlxsw_sp_rif_index_free(mlxsw_sp, rif_index, rif_entries);
8393         vr->rif_count--;
8394         mlxsw_sp_vr_put(mlxsw_sp, vr);
8395
8396         if (crif->can_destroy)
8397                 mlxsw_sp_crif_free(crif);
8398 }
8399
8400 void mlxsw_sp_rif_destroy_by_dev(struct mlxsw_sp *mlxsw_sp,
8401                                  struct net_device *dev)
8402 {
8403         struct mlxsw_sp_rif *rif;
8404
8405         mutex_lock(&mlxsw_sp->router->lock);
8406         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
8407         if (!rif)
8408                 goto out;
8409         mlxsw_sp_rif_destroy(rif);
8410 out:
8411         mutex_unlock(&mlxsw_sp->router->lock);
8412 }
8413
8414 static void mlxsw_sp_rif_destroy_vlan_upper(struct mlxsw_sp *mlxsw_sp,
8415                                             struct net_device *br_dev,
8416                                             u16 vid)
8417 {
8418         struct net_device *upper_dev;
8419         struct mlxsw_sp_crif *crif;
8420
8421         rcu_read_lock();
8422         upper_dev = __vlan_find_dev_deep_rcu(br_dev, htons(ETH_P_8021Q), vid);
8423         rcu_read_unlock();
8424
8425         if (!upper_dev)
8426                 return;
8427
8428         crif = mlxsw_sp_crif_lookup(mlxsw_sp->router, upper_dev);
8429         if (!crif || !crif->rif)
8430                 return;
8431
8432         mlxsw_sp_rif_destroy(crif->rif);
8433 }
8434
8435 static int mlxsw_sp_inetaddr_bridge_event(struct mlxsw_sp *mlxsw_sp,
8436                                           struct net_device *l3_dev,
8437                                           int lower_pvid,
8438                                           unsigned long event,
8439                                           struct netlink_ext_ack *extack);
8440
8441 int mlxsw_sp_router_bridge_vlan_add(struct mlxsw_sp *mlxsw_sp,
8442                                     struct net_device *br_dev,
8443                                     u16 new_vid, bool is_pvid,
8444                                     struct netlink_ext_ack *extack)
8445 {
8446         struct mlxsw_sp_rif *old_rif;
8447         struct mlxsw_sp_rif *new_rif;
8448         struct net_device *upper_dev;
8449         u16 old_pvid = 0;
8450         u16 new_pvid;
8451         int err = 0;
8452
8453         mutex_lock(&mlxsw_sp->router->lock);
8454         old_rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, br_dev);
8455         if (old_rif) {
8456                 /* If the RIF on the bridge is not a VLAN RIF, we shouldn't have
8457                  * gotten a PVID notification.
8458                  */
8459                 if (WARN_ON(old_rif->ops->type != MLXSW_SP_RIF_TYPE_VLAN))
8460                         old_rif = NULL;
8461                 else
8462                         old_pvid = mlxsw_sp_fid_8021q_vid(old_rif->fid);
8463         }
8464
8465         if (is_pvid)
8466                 new_pvid = new_vid;
8467         else if (old_pvid == new_vid)
8468                 new_pvid = 0;
8469         else
8470                 goto out;
8471
8472         if (old_pvid == new_pvid)
8473                 goto out;
8474
8475         if (new_pvid) {
8476                 struct mlxsw_sp_rif_params params = {
8477                         .dev = br_dev,
8478                         .vid = new_pvid,
8479                 };
8480
8481                 /* If there is a VLAN upper with the same VID as the new PVID,
8482                  * kill its RIF, if there is one.
8483                  */
8484                 mlxsw_sp_rif_destroy_vlan_upper(mlxsw_sp, br_dev, new_pvid);
8485
8486                 if (mlxsw_sp_dev_addr_list_empty(br_dev))
8487                         goto out;
8488                 new_rif = mlxsw_sp_rif_create(mlxsw_sp, &params, extack);
8489                 if (IS_ERR(new_rif)) {
8490                         err = PTR_ERR(new_rif);
8491                         goto out;
8492                 }
8493
8494                 if (old_pvid)
8495                         mlxsw_sp_rif_migrate_destroy(mlxsw_sp, old_rif, new_rif,
8496                                                      true);
8497         } else {
8498                 mlxsw_sp_rif_destroy(old_rif);
8499         }
8500
8501         if (old_pvid) {
8502                 rcu_read_lock();
8503                 upper_dev = __vlan_find_dev_deep_rcu(br_dev, htons(ETH_P_8021Q),
8504                                                      old_pvid);
8505                 rcu_read_unlock();
8506                 if (upper_dev)
8507                         err = mlxsw_sp_inetaddr_bridge_event(mlxsw_sp,
8508                                                              upper_dev,
8509                                                              new_pvid,
8510                                                              NETDEV_UP, extack);
8511         }
8512
8513 out:
8514         mutex_unlock(&mlxsw_sp->router->lock);
8515         return err;
8516 }
8517
8518 static void
8519 mlxsw_sp_rif_subport_params_init(struct mlxsw_sp_rif_params *params,
8520                                  struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
8521 {
8522         struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
8523
8524         params->vid = mlxsw_sp_port_vlan->vid;
8525         params->lag = mlxsw_sp_port->lagged;
8526         if (params->lag)
8527                 params->lag_id = mlxsw_sp_port->lag_id;
8528         else
8529                 params->system_port = mlxsw_sp_port->local_port;
8530 }
8531
8532 static struct mlxsw_sp_rif_subport *
8533 mlxsw_sp_rif_subport_rif(const struct mlxsw_sp_rif *rif)
8534 {
8535         return container_of(rif, struct mlxsw_sp_rif_subport, common);
8536 }
8537
8538 static struct mlxsw_sp_rif *
8539 mlxsw_sp_rif_subport_get(struct mlxsw_sp *mlxsw_sp,
8540                          const struct mlxsw_sp_rif_params *params,
8541                          struct netlink_ext_ack *extack)
8542 {
8543         struct mlxsw_sp_rif_subport *rif_subport;
8544         struct mlxsw_sp_rif *rif;
8545
8546         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, params->dev);
8547         if (!rif)
8548                 return mlxsw_sp_rif_create(mlxsw_sp, params, extack);
8549
8550         rif_subport = mlxsw_sp_rif_subport_rif(rif);
8551         refcount_inc(&rif_subport->ref_count);
8552         return rif;
8553 }
8554
8555 static void mlxsw_sp_rif_subport_put(struct mlxsw_sp_rif *rif)
8556 {
8557         struct mlxsw_sp_rif_subport *rif_subport;
8558
8559         rif_subport = mlxsw_sp_rif_subport_rif(rif);
8560         if (!refcount_dec_and_test(&rif_subport->ref_count))
8561                 return;
8562
8563         mlxsw_sp_rif_destroy(rif);
8564 }
8565
8566 static int mlxsw_sp_rif_mac_profile_index_alloc(struct mlxsw_sp *mlxsw_sp,
8567                                                 struct mlxsw_sp_rif_mac_profile *profile,
8568                                                 struct netlink_ext_ack *extack)
8569 {
8570         u8 max_rif_mac_profiles = mlxsw_sp->router->max_rif_mac_profile;
8571         struct mlxsw_sp_router *router = mlxsw_sp->router;
8572         int id;
8573
8574         id = idr_alloc(&router->rif_mac_profiles_idr, profile, 0,
8575                        max_rif_mac_profiles, GFP_KERNEL);
8576
8577         if (id >= 0) {
8578                 profile->id = id;
8579                 return 0;
8580         }
8581
8582         if (id == -ENOSPC)
8583                 NL_SET_ERR_MSG_MOD(extack,
8584                                    "Exceeded number of supported router interface MAC profiles");
8585
8586         return id;
8587 }
8588
8589 static struct mlxsw_sp_rif_mac_profile *
8590 mlxsw_sp_rif_mac_profile_index_free(struct mlxsw_sp *mlxsw_sp, u8 mac_profile)
8591 {
8592         struct mlxsw_sp_rif_mac_profile *profile;
8593
8594         profile = idr_remove(&mlxsw_sp->router->rif_mac_profiles_idr,
8595                              mac_profile);
8596         WARN_ON(!profile);
8597         return profile;
8598 }
8599
8600 static struct mlxsw_sp_rif_mac_profile *
8601 mlxsw_sp_rif_mac_profile_alloc(const char *mac)
8602 {
8603         struct mlxsw_sp_rif_mac_profile *profile;
8604
8605         profile = kzalloc(sizeof(*profile), GFP_KERNEL);
8606         if (!profile)
8607                 return NULL;
8608
8609         ether_addr_copy(profile->mac_prefix, mac);
8610         refcount_set(&profile->ref_count, 1);
8611         return profile;
8612 }
8613
8614 static struct mlxsw_sp_rif_mac_profile *
8615 mlxsw_sp_rif_mac_profile_find(const struct mlxsw_sp *mlxsw_sp, const char *mac)
8616 {
8617         struct mlxsw_sp_router *router = mlxsw_sp->router;
8618         struct mlxsw_sp_rif_mac_profile *profile;
8619         int id;
8620
8621         idr_for_each_entry(&router->rif_mac_profiles_idr, profile, id) {
8622                 if (ether_addr_equal_masked(profile->mac_prefix, mac,
8623                                             mlxsw_sp->mac_mask))
8624                         return profile;
8625         }
8626
8627         return NULL;
8628 }
8629
8630 static u64 mlxsw_sp_rif_mac_profiles_occ_get(void *priv)
8631 {
8632         const struct mlxsw_sp *mlxsw_sp = priv;
8633
8634         return atomic_read(&mlxsw_sp->router->rif_mac_profiles_count);
8635 }
8636
8637 static u64 mlxsw_sp_rifs_occ_get(void *priv)
8638 {
8639         const struct mlxsw_sp *mlxsw_sp = priv;
8640
8641         return atomic_read(&mlxsw_sp->router->rifs_count);
8642 }
8643
8644 static struct mlxsw_sp_rif_mac_profile *
8645 mlxsw_sp_rif_mac_profile_create(struct mlxsw_sp *mlxsw_sp, const char *mac,
8646                                 struct netlink_ext_ack *extack)
8647 {
8648         struct mlxsw_sp_rif_mac_profile *profile;
8649         int err;
8650
8651         profile = mlxsw_sp_rif_mac_profile_alloc(mac);
8652         if (!profile)
8653                 return ERR_PTR(-ENOMEM);
8654
8655         err = mlxsw_sp_rif_mac_profile_index_alloc(mlxsw_sp, profile, extack);
8656         if (err)
8657                 goto profile_index_alloc_err;
8658
8659         atomic_inc(&mlxsw_sp->router->rif_mac_profiles_count);
8660         return profile;
8661
8662 profile_index_alloc_err:
8663         kfree(profile);
8664         return ERR_PTR(err);
8665 }
8666
8667 static void mlxsw_sp_rif_mac_profile_destroy(struct mlxsw_sp *mlxsw_sp,
8668                                              u8 mac_profile)
8669 {
8670         struct mlxsw_sp_rif_mac_profile *profile;
8671
8672         atomic_dec(&mlxsw_sp->router->rif_mac_profiles_count);
8673         profile = mlxsw_sp_rif_mac_profile_index_free(mlxsw_sp, mac_profile);
8674         kfree(profile);
8675 }
8676
8677 static int mlxsw_sp_rif_mac_profile_get(struct mlxsw_sp *mlxsw_sp,
8678                                         const char *mac, u8 *p_mac_profile,
8679                                         struct netlink_ext_ack *extack)
8680 {
8681         struct mlxsw_sp_rif_mac_profile *profile;
8682
8683         profile = mlxsw_sp_rif_mac_profile_find(mlxsw_sp, mac);
8684         if (profile) {
8685                 refcount_inc(&profile->ref_count);
8686                 goto out;
8687         }
8688
8689         profile = mlxsw_sp_rif_mac_profile_create(mlxsw_sp, mac, extack);
8690         if (IS_ERR(profile))
8691                 return PTR_ERR(profile);
8692
8693 out:
8694         *p_mac_profile = profile->id;
8695         return 0;
8696 }
8697
8698 static void mlxsw_sp_rif_mac_profile_put(struct mlxsw_sp *mlxsw_sp,
8699                                          u8 mac_profile)
8700 {
8701         struct mlxsw_sp_rif_mac_profile *profile;
8702
8703         profile = idr_find(&mlxsw_sp->router->rif_mac_profiles_idr,
8704                            mac_profile);
8705         if (WARN_ON(!profile))
8706                 return;
8707
8708         if (!refcount_dec_and_test(&profile->ref_count))
8709                 return;
8710
8711         mlxsw_sp_rif_mac_profile_destroy(mlxsw_sp, mac_profile);
8712 }
8713
8714 static bool mlxsw_sp_rif_mac_profile_is_shared(const struct mlxsw_sp_rif *rif)
8715 {
8716         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
8717         struct mlxsw_sp_rif_mac_profile *profile;
8718
8719         profile = idr_find(&mlxsw_sp->router->rif_mac_profiles_idr,
8720                            rif->mac_profile_id);
8721         if (WARN_ON(!profile))
8722                 return false;
8723
8724         return refcount_read(&profile->ref_count) > 1;
8725 }
8726
8727 static int mlxsw_sp_rif_mac_profile_edit(struct mlxsw_sp_rif *rif,
8728                                          const char *new_mac)
8729 {
8730         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
8731         struct mlxsw_sp_rif_mac_profile *profile;
8732
8733         profile = idr_find(&mlxsw_sp->router->rif_mac_profiles_idr,
8734                            rif->mac_profile_id);
8735         if (WARN_ON(!profile))
8736                 return -EINVAL;
8737
8738         ether_addr_copy(profile->mac_prefix, new_mac);
8739         return 0;
8740 }
8741
8742 static int
8743 mlxsw_sp_rif_mac_profile_replace(struct mlxsw_sp *mlxsw_sp,
8744                                  struct mlxsw_sp_rif *rif,
8745                                  const char *new_mac,
8746                                  struct netlink_ext_ack *extack)
8747 {
8748         u8 mac_profile;
8749         int err;
8750
8751         if (!mlxsw_sp_rif_mac_profile_is_shared(rif) &&
8752             !mlxsw_sp_rif_mac_profile_find(mlxsw_sp, new_mac))
8753                 return mlxsw_sp_rif_mac_profile_edit(rif, new_mac);
8754
8755         err = mlxsw_sp_rif_mac_profile_get(mlxsw_sp, new_mac,
8756                                            &mac_profile, extack);
8757         if (err)
8758                 return err;
8759
8760         mlxsw_sp_rif_mac_profile_put(mlxsw_sp, rif->mac_profile_id);
8761         rif->mac_profile_id = mac_profile;
8762         return 0;
8763 }
8764
8765 static int
8766 __mlxsw_sp_port_vlan_router_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
8767                                  struct net_device *l3_dev,
8768                                  struct netlink_ext_ack *extack)
8769 {
8770         struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
8771         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
8772         struct mlxsw_sp_rif_params params;
8773         u16 vid = mlxsw_sp_port_vlan->vid;
8774         struct mlxsw_sp_rif *rif;
8775         struct mlxsw_sp_fid *fid;
8776         int err;
8777
8778         params = (struct mlxsw_sp_rif_params) {
8779                 .dev = l3_dev,
8780                 .vid = vid,
8781         };
8782
8783         mlxsw_sp_rif_subport_params_init(&params, mlxsw_sp_port_vlan);
8784         rif = mlxsw_sp_rif_subport_get(mlxsw_sp, &params, extack);
8785         if (IS_ERR(rif))
8786                 return PTR_ERR(rif);
8787
8788         /* FID was already created, just take a reference */
8789         fid = rif->ops->fid_get(rif, &params, extack);
8790         err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid);
8791         if (err)
8792                 goto err_fid_port_vid_map;
8793
8794         err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
8795         if (err)
8796                 goto err_port_vid_learning_set;
8797
8798         err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid,
8799                                         BR_STATE_FORWARDING);
8800         if (err)
8801                 goto err_port_vid_stp_set;
8802
8803         mlxsw_sp_port_vlan->fid = fid;
8804
8805         return 0;
8806
8807 err_port_vid_stp_set:
8808         mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
8809 err_port_vid_learning_set:
8810         mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
8811 err_fid_port_vid_map:
8812         mlxsw_sp_fid_put(fid);
8813         mlxsw_sp_rif_subport_put(rif);
8814         return err;
8815 }
8816
8817 static void
8818 __mlxsw_sp_port_vlan_router_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
8819 {
8820         struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
8821         struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
8822         struct mlxsw_sp_rif *rif = mlxsw_sp_fid_rif(fid);
8823         u16 vid = mlxsw_sp_port_vlan->vid;
8824
8825         if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_RFID))
8826                 return;
8827
8828         mlxsw_sp_port_vlan->fid = NULL;
8829         mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_BLOCKING);
8830         mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
8831         mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
8832         mlxsw_sp_fid_put(fid);
8833         mlxsw_sp_rif_subport_put(rif);
8834 }
8835
8836 static int
8837 mlxsw_sp_port_vlan_router_join_existing(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
8838                                         struct net_device *l3_dev,
8839                                         struct netlink_ext_ack *extack)
8840 {
8841         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port_vlan->mlxsw_sp_port->mlxsw_sp;
8842
8843         lockdep_assert_held(&mlxsw_sp->router->lock);
8844
8845         if (!mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev))
8846                 return 0;
8847
8848         return __mlxsw_sp_port_vlan_router_join(mlxsw_sp_port_vlan, l3_dev,
8849                                                 extack);
8850 }
8851
8852 void
8853 mlxsw_sp_port_vlan_router_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
8854 {
8855         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port_vlan->mlxsw_sp_port->mlxsw_sp;
8856
8857         mutex_lock(&mlxsw_sp->router->lock);
8858         __mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
8859         mutex_unlock(&mlxsw_sp->router->lock);
8860 }
8861
8862 static int mlxsw_sp_inetaddr_port_vlan_event(struct net_device *l3_dev,
8863                                              struct net_device *port_dev,
8864                                              unsigned long event, u16 vid,
8865                                              struct netlink_ext_ack *extack)
8866 {
8867         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(port_dev);
8868         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
8869
8870         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
8871         if (WARN_ON(!mlxsw_sp_port_vlan))
8872                 return -EINVAL;
8873
8874         switch (event) {
8875         case NETDEV_UP:
8876                 return __mlxsw_sp_port_vlan_router_join(mlxsw_sp_port_vlan,
8877                                                         l3_dev, extack);
8878         case NETDEV_DOWN:
8879                 __mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
8880                 break;
8881         }
8882
8883         return 0;
8884 }
8885
8886 static int mlxsw_sp_inetaddr_port_event(struct net_device *port_dev,
8887                                         unsigned long event, bool nomaster,
8888                                         struct netlink_ext_ack *extack)
8889 {
8890         if (!nomaster && (netif_is_any_bridge_port(port_dev) ||
8891                           netif_is_lag_port(port_dev)))
8892                 return 0;
8893
8894         return mlxsw_sp_inetaddr_port_vlan_event(port_dev, port_dev, event,
8895                                                  MLXSW_SP_DEFAULT_VID, extack);
8896 }
8897
8898 static int __mlxsw_sp_inetaddr_lag_event(struct net_device *l3_dev,
8899                                          struct net_device *lag_dev,
8900                                          unsigned long event, u16 vid,
8901                                          struct netlink_ext_ack *extack)
8902 {
8903         struct net_device *port_dev;
8904         struct list_head *iter;
8905         int err;
8906
8907         netdev_for_each_lower_dev(lag_dev, port_dev, iter) {
8908                 if (mlxsw_sp_port_dev_check(port_dev)) {
8909                         err = mlxsw_sp_inetaddr_port_vlan_event(l3_dev,
8910                                                                 port_dev,
8911                                                                 event, vid,
8912                                                                 extack);
8913                         if (err)
8914                                 return err;
8915                 }
8916         }
8917
8918         return 0;
8919 }
8920
8921 static int mlxsw_sp_inetaddr_lag_event(struct net_device *lag_dev,
8922                                        unsigned long event, bool nomaster,
8923                                        struct netlink_ext_ack *extack)
8924 {
8925         if (!nomaster && netif_is_bridge_port(lag_dev))
8926                 return 0;
8927
8928         return __mlxsw_sp_inetaddr_lag_event(lag_dev, lag_dev, event,
8929                                              MLXSW_SP_DEFAULT_VID, extack);
8930 }
8931
8932 static int mlxsw_sp_inetaddr_bridge_event(struct mlxsw_sp *mlxsw_sp,
8933                                           struct net_device *l3_dev,
8934                                           int lower_pvid,
8935                                           unsigned long event,
8936                                           struct netlink_ext_ack *extack)
8937 {
8938         struct mlxsw_sp_rif_params params = {
8939                 .dev = l3_dev,
8940         };
8941         struct mlxsw_sp_rif *rif;
8942         int err;
8943
8944         switch (event) {
8945         case NETDEV_UP:
8946                 if (netif_is_bridge_master(l3_dev) && br_vlan_enabled(l3_dev)) {
8947                         u16 proto;
8948
8949                         br_vlan_get_proto(l3_dev, &proto);
8950                         if (proto == ETH_P_8021AD) {
8951                                 NL_SET_ERR_MSG_MOD(extack, "Adding an IP address to 802.1ad bridge is not supported");
8952                                 return -EOPNOTSUPP;
8953                         }
8954                         err = br_vlan_get_pvid(l3_dev, &params.vid);
8955                         if (err)
8956                                 return err;
8957                         if (!params.vid)
8958                                 return 0;
8959                 } else if (is_vlan_dev(l3_dev)) {
8960                         params.vid = vlan_dev_vlan_id(l3_dev);
8961
8962                         /* If the VID matches PVID of the bridge below, the
8963                          * bridge owns the RIF for this VLAN. Don't do anything.
8964                          */
8965                         if ((int)params.vid == lower_pvid)
8966                                 return 0;
8967                 }
8968
8969                 rif = mlxsw_sp_rif_create(mlxsw_sp, &params, extack);
8970                 if (IS_ERR(rif))
8971                         return PTR_ERR(rif);
8972                 break;
8973         case NETDEV_DOWN:
8974                 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
8975                 mlxsw_sp_rif_destroy(rif);
8976                 break;
8977         }
8978
8979         return 0;
8980 }
8981
8982 static int mlxsw_sp_inetaddr_vlan_event(struct mlxsw_sp *mlxsw_sp,
8983                                         struct net_device *vlan_dev,
8984                                         unsigned long event, bool nomaster,
8985                                         struct netlink_ext_ack *extack)
8986 {
8987         struct net_device *real_dev = vlan_dev_real_dev(vlan_dev);
8988         u16 vid = vlan_dev_vlan_id(vlan_dev);
8989         u16 lower_pvid;
8990         int err;
8991
8992         if (!nomaster && netif_is_bridge_port(vlan_dev))
8993                 return 0;
8994
8995         if (mlxsw_sp_port_dev_check(real_dev)) {
8996                 return mlxsw_sp_inetaddr_port_vlan_event(vlan_dev, real_dev,
8997                                                          event, vid, extack);
8998         } else if (netif_is_lag_master(real_dev)) {
8999                 return __mlxsw_sp_inetaddr_lag_event(vlan_dev, real_dev, event,
9000                                                      vid, extack);
9001         } else if (netif_is_bridge_master(real_dev) &&
9002                    br_vlan_enabled(real_dev)) {
9003                 err = br_vlan_get_pvid(real_dev, &lower_pvid);
9004                 if (err)
9005                         return err;
9006                 return mlxsw_sp_inetaddr_bridge_event(mlxsw_sp, vlan_dev,
9007                                                       lower_pvid, event,
9008                                                       extack);
9009         }
9010
9011         return 0;
9012 }
9013
9014 static bool mlxsw_sp_rif_macvlan_is_vrrp4(const u8 *mac)
9015 {
9016         u8 vrrp4[ETH_ALEN] = { 0x00, 0x00, 0x5e, 0x00, 0x01, 0x00 };
9017         u8 mask[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
9018
9019         return ether_addr_equal_masked(mac, vrrp4, mask);
9020 }
9021
9022 static bool mlxsw_sp_rif_macvlan_is_vrrp6(const u8 *mac)
9023 {
9024         u8 vrrp6[ETH_ALEN] = { 0x00, 0x00, 0x5e, 0x00, 0x02, 0x00 };
9025         u8 mask[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
9026
9027         return ether_addr_equal_masked(mac, vrrp6, mask);
9028 }
9029
9030 static int mlxsw_sp_rif_vrrp_op(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
9031                                 const u8 *mac, bool adding)
9032 {
9033         char ritr_pl[MLXSW_REG_RITR_LEN];
9034         u8 vrrp_id = adding ? mac[5] : 0;
9035         int err;
9036
9037         if (!mlxsw_sp_rif_macvlan_is_vrrp4(mac) &&
9038             !mlxsw_sp_rif_macvlan_is_vrrp6(mac))
9039                 return 0;
9040
9041         mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
9042         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
9043         if (err)
9044                 return err;
9045
9046         if (mlxsw_sp_rif_macvlan_is_vrrp4(mac))
9047                 mlxsw_reg_ritr_if_vrrp_id_ipv4_set(ritr_pl, vrrp_id);
9048         else
9049                 mlxsw_reg_ritr_if_vrrp_id_ipv6_set(ritr_pl, vrrp_id);
9050
9051         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
9052 }
9053
9054 static int mlxsw_sp_rif_macvlan_add(struct mlxsw_sp *mlxsw_sp,
9055                                     const struct net_device *macvlan_dev,
9056                                     struct netlink_ext_ack *extack)
9057 {
9058         struct macvlan_dev *vlan = netdev_priv(macvlan_dev);
9059         struct mlxsw_sp_rif *rif;
9060         int err;
9061
9062         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, vlan->lowerdev);
9063         if (!rif) {
9064                 NL_SET_ERR_MSG_MOD(extack, "macvlan is only supported on top of router interfaces");
9065                 return -EOPNOTSUPP;
9066         }
9067
9068         err = mlxsw_sp_rif_fdb_op(mlxsw_sp, macvlan_dev->dev_addr,
9069                                   mlxsw_sp_fid_index(rif->fid), true);
9070         if (err)
9071                 return err;
9072
9073         err = mlxsw_sp_rif_vrrp_op(mlxsw_sp, rif->rif_index,
9074                                    macvlan_dev->dev_addr, true);
9075         if (err)
9076                 goto err_rif_vrrp_add;
9077
9078         /* Make sure the bridge driver does not have this MAC pointing at
9079          * some other port.
9080          */
9081         if (rif->ops->fdb_del)
9082                 rif->ops->fdb_del(rif, macvlan_dev->dev_addr);
9083
9084         return 0;
9085
9086 err_rif_vrrp_add:
9087         mlxsw_sp_rif_fdb_op(mlxsw_sp, macvlan_dev->dev_addr,
9088                             mlxsw_sp_fid_index(rif->fid), false);
9089         return err;
9090 }
9091
9092 static void __mlxsw_sp_rif_macvlan_del(struct mlxsw_sp *mlxsw_sp,
9093                                        const struct net_device *macvlan_dev)
9094 {
9095         struct macvlan_dev *vlan = netdev_priv(macvlan_dev);
9096         struct mlxsw_sp_rif *rif;
9097
9098         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, vlan->lowerdev);
9099         /* If we do not have a RIF, then we already took care of
9100          * removing the macvlan's MAC during RIF deletion.
9101          */
9102         if (!rif)
9103                 return;
9104         mlxsw_sp_rif_vrrp_op(mlxsw_sp, rif->rif_index, macvlan_dev->dev_addr,
9105                              false);
9106         mlxsw_sp_rif_fdb_op(mlxsw_sp, macvlan_dev->dev_addr,
9107                             mlxsw_sp_fid_index(rif->fid), false);
9108 }
9109
9110 void mlxsw_sp_rif_macvlan_del(struct mlxsw_sp *mlxsw_sp,
9111                               const struct net_device *macvlan_dev)
9112 {
9113         mutex_lock(&mlxsw_sp->router->lock);
9114         __mlxsw_sp_rif_macvlan_del(mlxsw_sp, macvlan_dev);
9115         mutex_unlock(&mlxsw_sp->router->lock);
9116 }
9117
9118 static int mlxsw_sp_inetaddr_macvlan_event(struct mlxsw_sp *mlxsw_sp,
9119                                            struct net_device *macvlan_dev,
9120                                            unsigned long event,
9121                                            struct netlink_ext_ack *extack)
9122 {
9123         switch (event) {
9124         case NETDEV_UP:
9125                 return mlxsw_sp_rif_macvlan_add(mlxsw_sp, macvlan_dev, extack);
9126         case NETDEV_DOWN:
9127                 __mlxsw_sp_rif_macvlan_del(mlxsw_sp, macvlan_dev);
9128                 break;
9129         }
9130
9131         return 0;
9132 }
9133
9134 static int __mlxsw_sp_inetaddr_event(struct mlxsw_sp *mlxsw_sp,
9135                                      struct net_device *dev,
9136                                      unsigned long event, bool nomaster,
9137                                      struct netlink_ext_ack *extack)
9138 {
9139         if (mlxsw_sp_port_dev_check(dev))
9140                 return mlxsw_sp_inetaddr_port_event(dev, event, nomaster,
9141                                                     extack);
9142         else if (netif_is_lag_master(dev))
9143                 return mlxsw_sp_inetaddr_lag_event(dev, event, nomaster,
9144                                                    extack);
9145         else if (netif_is_bridge_master(dev))
9146                 return mlxsw_sp_inetaddr_bridge_event(mlxsw_sp, dev, -1, event,
9147                                                       extack);
9148         else if (is_vlan_dev(dev))
9149                 return mlxsw_sp_inetaddr_vlan_event(mlxsw_sp, dev, event,
9150                                                     nomaster, extack);
9151         else if (netif_is_macvlan(dev))
9152                 return mlxsw_sp_inetaddr_macvlan_event(mlxsw_sp, dev, event,
9153                                                        extack);
9154         else
9155                 return 0;
9156 }
9157
9158 static int mlxsw_sp_inetaddr_event(struct notifier_block *nb,
9159                                    unsigned long event, void *ptr)
9160 {
9161         struct in_ifaddr *ifa = (struct in_ifaddr *) ptr;
9162         struct net_device *dev = ifa->ifa_dev->dev;
9163         struct mlxsw_sp_router *router;
9164         struct mlxsw_sp_rif *rif;
9165         int err = 0;
9166
9167         /* NETDEV_UP event is handled by mlxsw_sp_inetaddr_valid_event */
9168         if (event == NETDEV_UP)
9169                 return NOTIFY_DONE;
9170
9171         router = container_of(nb, struct mlxsw_sp_router, inetaddr_nb);
9172         mutex_lock(&router->lock);
9173         rif = mlxsw_sp_rif_find_by_dev(router->mlxsw_sp, dev);
9174         if (!mlxsw_sp_rif_should_config(rif, dev, event))
9175                 goto out;
9176
9177         err = __mlxsw_sp_inetaddr_event(router->mlxsw_sp, dev, event, false,
9178                                         NULL);
9179 out:
9180         mutex_unlock(&router->lock);
9181         return notifier_from_errno(err);
9182 }
9183
9184 static int mlxsw_sp_inetaddr_valid_event(struct notifier_block *unused,
9185                                          unsigned long event, void *ptr)
9186 {
9187         struct in_validator_info *ivi = (struct in_validator_info *) ptr;
9188         struct net_device *dev = ivi->ivi_dev->dev;
9189         struct mlxsw_sp *mlxsw_sp;
9190         struct mlxsw_sp_rif *rif;
9191         int err = 0;
9192
9193         mlxsw_sp = mlxsw_sp_lower_get(dev);
9194         if (!mlxsw_sp)
9195                 return NOTIFY_DONE;
9196
9197         mutex_lock(&mlxsw_sp->router->lock);
9198         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
9199         if (!mlxsw_sp_rif_should_config(rif, dev, event))
9200                 goto out;
9201
9202         err = __mlxsw_sp_inetaddr_event(mlxsw_sp, dev, event, false,
9203                                         ivi->extack);
9204 out:
9205         mutex_unlock(&mlxsw_sp->router->lock);
9206         return notifier_from_errno(err);
9207 }
9208
9209 struct mlxsw_sp_inet6addr_event_work {
9210         struct work_struct work;
9211         struct mlxsw_sp *mlxsw_sp;
9212         struct net_device *dev;
9213         unsigned long event;
9214 };
9215
9216 static void mlxsw_sp_inet6addr_event_work(struct work_struct *work)
9217 {
9218         struct mlxsw_sp_inet6addr_event_work *inet6addr_work =
9219                 container_of(work, struct mlxsw_sp_inet6addr_event_work, work);
9220         struct mlxsw_sp *mlxsw_sp = inet6addr_work->mlxsw_sp;
9221         struct net_device *dev = inet6addr_work->dev;
9222         unsigned long event = inet6addr_work->event;
9223         struct mlxsw_sp_rif *rif;
9224
9225         rtnl_lock();
9226         mutex_lock(&mlxsw_sp->router->lock);
9227
9228         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
9229         if (!mlxsw_sp_rif_should_config(rif, dev, event))
9230                 goto out;
9231
9232         __mlxsw_sp_inetaddr_event(mlxsw_sp, dev, event, false, NULL);
9233 out:
9234         mutex_unlock(&mlxsw_sp->router->lock);
9235         rtnl_unlock();
9236         dev_put(dev);
9237         kfree(inet6addr_work);
9238 }
9239
9240 /* Called with rcu_read_lock() */
9241 static int mlxsw_sp_inet6addr_event(struct notifier_block *nb,
9242                                     unsigned long event, void *ptr)
9243 {
9244         struct inet6_ifaddr *if6 = (struct inet6_ifaddr *) ptr;
9245         struct mlxsw_sp_inet6addr_event_work *inet6addr_work;
9246         struct net_device *dev = if6->idev->dev;
9247         struct mlxsw_sp_router *router;
9248
9249         /* NETDEV_UP event is handled by mlxsw_sp_inet6addr_valid_event */
9250         if (event == NETDEV_UP)
9251                 return NOTIFY_DONE;
9252
9253         inet6addr_work = kzalloc(sizeof(*inet6addr_work), GFP_ATOMIC);
9254         if (!inet6addr_work)
9255                 return NOTIFY_BAD;
9256
9257         router = container_of(nb, struct mlxsw_sp_router, inet6addr_nb);
9258         INIT_WORK(&inet6addr_work->work, mlxsw_sp_inet6addr_event_work);
9259         inet6addr_work->mlxsw_sp = router->mlxsw_sp;
9260         inet6addr_work->dev = dev;
9261         inet6addr_work->event = event;
9262         dev_hold(dev);
9263         mlxsw_core_schedule_work(&inet6addr_work->work);
9264
9265         return NOTIFY_DONE;
9266 }
9267
9268 static int mlxsw_sp_inet6addr_valid_event(struct notifier_block *unused,
9269                                           unsigned long event, void *ptr)
9270 {
9271         struct in6_validator_info *i6vi = (struct in6_validator_info *) ptr;
9272         struct net_device *dev = i6vi->i6vi_dev->dev;
9273         struct mlxsw_sp *mlxsw_sp;
9274         struct mlxsw_sp_rif *rif;
9275         int err = 0;
9276
9277         mlxsw_sp = mlxsw_sp_lower_get(dev);
9278         if (!mlxsw_sp)
9279                 return NOTIFY_DONE;
9280
9281         mutex_lock(&mlxsw_sp->router->lock);
9282         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
9283         if (!mlxsw_sp_rif_should_config(rif, dev, event))
9284                 goto out;
9285
9286         err = __mlxsw_sp_inetaddr_event(mlxsw_sp, dev, event, false,
9287                                         i6vi->extack);
9288 out:
9289         mutex_unlock(&mlxsw_sp->router->lock);
9290         return notifier_from_errno(err);
9291 }
9292
9293 static int mlxsw_sp_rif_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
9294                              const char *mac, int mtu, u8 mac_profile)
9295 {
9296         char ritr_pl[MLXSW_REG_RITR_LEN];
9297         int err;
9298
9299         mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
9300         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
9301         if (err)
9302                 return err;
9303
9304         mlxsw_reg_ritr_mtu_set(ritr_pl, mtu);
9305         mlxsw_reg_ritr_if_mac_memcpy_to(ritr_pl, mac);
9306         mlxsw_reg_ritr_if_mac_profile_id_set(ritr_pl, mac_profile);
9307         mlxsw_reg_ritr_op_set(ritr_pl, MLXSW_REG_RITR_RIF_CREATE);
9308         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
9309 }
9310
9311 static int
9312 mlxsw_sp_router_port_change_event(struct mlxsw_sp *mlxsw_sp,
9313                                   struct mlxsw_sp_rif *rif,
9314                                   struct netlink_ext_ack *extack)
9315 {
9316         struct net_device *dev = mlxsw_sp_rif_dev(rif);
9317         u8 old_mac_profile;
9318         u16 fid_index;
9319         int err;
9320
9321         fid_index = mlxsw_sp_fid_index(rif->fid);
9322
9323         err = mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, false);
9324         if (err)
9325                 return err;
9326
9327         old_mac_profile = rif->mac_profile_id;
9328         err = mlxsw_sp_rif_mac_profile_replace(mlxsw_sp, rif, dev->dev_addr,
9329                                                extack);
9330         if (err)
9331                 goto err_rif_mac_profile_replace;
9332
9333         err = mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, dev->dev_addr,
9334                                 dev->mtu, rif->mac_profile_id);
9335         if (err)
9336                 goto err_rif_edit;
9337
9338         err = mlxsw_sp_rif_fdb_op(mlxsw_sp, dev->dev_addr, fid_index, true);
9339         if (err)
9340                 goto err_rif_fdb_op;
9341
9342         if (rif->mtu != dev->mtu) {
9343                 struct mlxsw_sp_vr *vr;
9344                 int i;
9345
9346                 /* The RIF is relevant only to its mr_table instance, as unlike
9347                  * unicast routing, in multicast routing a RIF cannot be shared
9348                  * between several multicast routing tables.
9349                  */
9350                 vr = &mlxsw_sp->router->vrs[rif->vr_id];
9351                 for (i = 0; i < MLXSW_SP_L3_PROTO_MAX; i++)
9352                         mlxsw_sp_mr_rif_mtu_update(vr->mr_table[i],
9353                                                    rif, dev->mtu);
9354         }
9355
9356         ether_addr_copy(rif->addr, dev->dev_addr);
9357         rif->mtu = dev->mtu;
9358
9359         netdev_dbg(dev, "Updated RIF=%d\n", rif->rif_index);
9360
9361         return 0;
9362
9363 err_rif_fdb_op:
9364         mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, rif->addr, rif->mtu,
9365                           old_mac_profile);
9366 err_rif_edit:
9367         mlxsw_sp_rif_mac_profile_replace(mlxsw_sp, rif, rif->addr, extack);
9368 err_rif_mac_profile_replace:
9369         mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, true);
9370         return err;
9371 }
9372
9373 static int mlxsw_sp_router_port_pre_changeaddr_event(struct mlxsw_sp_rif *rif,
9374                             struct netdev_notifier_pre_changeaddr_info *info)
9375 {
9376         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
9377         struct mlxsw_sp_rif_mac_profile *profile;
9378         struct netlink_ext_ack *extack;
9379         u8 max_rif_mac_profiles;
9380         u64 occ;
9381
9382         extack = netdev_notifier_info_to_extack(&info->info);
9383
9384         profile = mlxsw_sp_rif_mac_profile_find(mlxsw_sp, info->dev_addr);
9385         if (profile)
9386                 return 0;
9387
9388         max_rif_mac_profiles = mlxsw_sp->router->max_rif_mac_profile;
9389         occ = mlxsw_sp_rif_mac_profiles_occ_get(mlxsw_sp);
9390         if (occ < max_rif_mac_profiles)
9391                 return 0;
9392
9393         if (!mlxsw_sp_rif_mac_profile_is_shared(rif))
9394                 return 0;
9395
9396         NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported router interface MAC profiles");
9397         return -ENOBUFS;
9398 }
9399
9400 static bool mlxsw_sp_router_netdevice_interesting(struct mlxsw_sp *mlxsw_sp,
9401                                                   struct net_device *dev)
9402 {
9403         struct vlan_dev_priv *vlan;
9404
9405         if (netif_is_lag_master(dev) ||
9406             netif_is_bridge_master(dev) ||
9407             mlxsw_sp_port_dev_check(dev) ||
9408             mlxsw_sp_netdev_is_ipip_ol(mlxsw_sp, dev) ||
9409             netif_is_l3_master(dev))
9410                 return true;
9411
9412         if (!is_vlan_dev(dev))
9413                 return false;
9414
9415         vlan = vlan_dev_priv(dev);
9416         return netif_is_lag_master(vlan->real_dev) ||
9417                netif_is_bridge_master(vlan->real_dev) ||
9418                mlxsw_sp_port_dev_check(vlan->real_dev);
9419 }
9420
9421 static struct mlxsw_sp_crif *
9422 mlxsw_sp_crif_register(struct mlxsw_sp_router *router, struct net_device *dev)
9423 {
9424         struct mlxsw_sp_crif *crif;
9425         int err;
9426
9427         if (WARN_ON(mlxsw_sp_crif_lookup(router, dev)))
9428                 return NULL;
9429
9430         crif = mlxsw_sp_crif_alloc(dev);
9431         if (!crif)
9432                 return ERR_PTR(-ENOMEM);
9433
9434         err = mlxsw_sp_crif_insert(router, crif);
9435         if (err)
9436                 goto err_netdev_insert;
9437
9438         return crif;
9439
9440 err_netdev_insert:
9441         mlxsw_sp_crif_free(crif);
9442         return ERR_PTR(err);
9443 }
9444
9445 static void mlxsw_sp_crif_unregister(struct mlxsw_sp_router *router,
9446                                      struct mlxsw_sp_crif *crif)
9447 {
9448         struct mlxsw_sp_nexthop *nh, *tmp;
9449
9450         mlxsw_sp_crif_remove(router, crif);
9451
9452         list_for_each_entry_safe(nh, tmp, &crif->nexthop_list, crif_list_node)
9453                 mlxsw_sp_nexthop_type_fini(router->mlxsw_sp, nh);
9454
9455         if (crif->rif)
9456                 crif->can_destroy = true;
9457         else
9458                 mlxsw_sp_crif_free(crif);
9459 }
9460
9461 static int mlxsw_sp_netdevice_register(struct mlxsw_sp_router *router,
9462                                        struct net_device *dev)
9463 {
9464         struct mlxsw_sp_crif *crif;
9465
9466         if (!mlxsw_sp_router_netdevice_interesting(router->mlxsw_sp, dev))
9467                 return 0;
9468
9469         crif = mlxsw_sp_crif_register(router, dev);
9470         return PTR_ERR_OR_ZERO(crif);
9471 }
9472
9473 static void mlxsw_sp_netdevice_unregister(struct mlxsw_sp_router *router,
9474                                           struct net_device *dev)
9475 {
9476         struct mlxsw_sp_crif *crif;
9477
9478         if (!mlxsw_sp_router_netdevice_interesting(router->mlxsw_sp, dev))
9479                 return;
9480
9481         /* netdev_run_todo(), by way of netdev_wait_allrefs_any(), rebroadcasts
9482          * the NETDEV_UNREGISTER message, so we can get here twice. If that's
9483          * what happened, the netdevice state is NETREG_UNREGISTERED. In that
9484          * case, we expect to have collected the CRIF already, and warn if it
9485          * still exists. Otherwise we expect the CRIF to exist.
9486          */
9487         crif = mlxsw_sp_crif_lookup(router, dev);
9488         if (dev->reg_state == NETREG_UNREGISTERED) {
9489                 if (!WARN_ON(crif))
9490                         return;
9491         }
9492         if (WARN_ON(!crif))
9493                 return;
9494
9495         mlxsw_sp_crif_unregister(router, crif);
9496 }
9497
9498 static bool mlxsw_sp_is_offload_xstats_event(unsigned long event)
9499 {
9500         switch (event) {
9501         case NETDEV_OFFLOAD_XSTATS_ENABLE:
9502         case NETDEV_OFFLOAD_XSTATS_DISABLE:
9503         case NETDEV_OFFLOAD_XSTATS_REPORT_USED:
9504         case NETDEV_OFFLOAD_XSTATS_REPORT_DELTA:
9505                 return true;
9506         }
9507
9508         return false;
9509 }
9510
9511 static int
9512 mlxsw_sp_router_port_offload_xstats_cmd(struct mlxsw_sp_rif *rif,
9513                                         unsigned long event,
9514                                         struct netdev_notifier_offload_xstats_info *info)
9515 {
9516         switch (info->type) {
9517         case NETDEV_OFFLOAD_XSTATS_TYPE_L3:
9518                 break;
9519         default:
9520                 return 0;
9521         }
9522
9523         switch (event) {
9524         case NETDEV_OFFLOAD_XSTATS_ENABLE:
9525                 return mlxsw_sp_router_port_l3_stats_enable(rif);
9526         case NETDEV_OFFLOAD_XSTATS_DISABLE:
9527                 mlxsw_sp_router_port_l3_stats_disable(rif);
9528                 return 0;
9529         case NETDEV_OFFLOAD_XSTATS_REPORT_USED:
9530                 mlxsw_sp_router_port_l3_stats_report_used(rif, info);
9531                 return 0;
9532         case NETDEV_OFFLOAD_XSTATS_REPORT_DELTA:
9533                 return mlxsw_sp_router_port_l3_stats_report_delta(rif, info);
9534         }
9535
9536         WARN_ON_ONCE(1);
9537         return 0;
9538 }
9539
9540 static int
9541 mlxsw_sp_netdevice_offload_xstats_cmd(struct mlxsw_sp *mlxsw_sp,
9542                                       struct net_device *dev,
9543                                       unsigned long event,
9544                                       struct netdev_notifier_offload_xstats_info *info)
9545 {
9546         struct mlxsw_sp_rif *rif;
9547
9548         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
9549         if (!rif)
9550                 return 0;
9551
9552         return mlxsw_sp_router_port_offload_xstats_cmd(rif, event, info);
9553 }
9554
9555 static bool mlxsw_sp_is_router_event(unsigned long event)
9556 {
9557         switch (event) {
9558         case NETDEV_PRE_CHANGEADDR:
9559         case NETDEV_CHANGEADDR:
9560         case NETDEV_CHANGEMTU:
9561                 return true;
9562         default:
9563                 return false;
9564         }
9565 }
9566
9567 static int mlxsw_sp_netdevice_router_port_event(struct net_device *dev,
9568                                                 unsigned long event, void *ptr)
9569 {
9570         struct netlink_ext_ack *extack = netdev_notifier_info_to_extack(ptr);
9571         struct mlxsw_sp *mlxsw_sp;
9572         struct mlxsw_sp_rif *rif;
9573
9574         mlxsw_sp = mlxsw_sp_lower_get(dev);
9575         if (!mlxsw_sp)
9576                 return 0;
9577
9578         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
9579         if (!rif)
9580                 return 0;
9581
9582         switch (event) {
9583         case NETDEV_CHANGEMTU:
9584         case NETDEV_CHANGEADDR:
9585                 return mlxsw_sp_router_port_change_event(mlxsw_sp, rif, extack);
9586         case NETDEV_PRE_CHANGEADDR:
9587                 return mlxsw_sp_router_port_pre_changeaddr_event(rif, ptr);
9588         default:
9589                 WARN_ON_ONCE(1);
9590                 break;
9591         }
9592
9593         return 0;
9594 }
9595
9596 static int mlxsw_sp_port_vrf_join(struct mlxsw_sp *mlxsw_sp,
9597                                   struct net_device *l3_dev,
9598                                   struct netlink_ext_ack *extack)
9599 {
9600         struct mlxsw_sp_rif *rif;
9601
9602         /* If netdev is already associated with a RIF, then we need to
9603          * destroy it and create a new one with the new virtual router ID.
9604          */
9605         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
9606         if (rif)
9607                 __mlxsw_sp_inetaddr_event(mlxsw_sp, l3_dev, NETDEV_DOWN, false,
9608                                           extack);
9609
9610         return __mlxsw_sp_inetaddr_event(mlxsw_sp, l3_dev, NETDEV_UP, false,
9611                                          extack);
9612 }
9613
9614 static void mlxsw_sp_port_vrf_leave(struct mlxsw_sp *mlxsw_sp,
9615                                     struct net_device *l3_dev)
9616 {
9617         struct mlxsw_sp_rif *rif;
9618
9619         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
9620         if (!rif)
9621                 return;
9622         __mlxsw_sp_inetaddr_event(mlxsw_sp, l3_dev, NETDEV_DOWN, false, NULL);
9623 }
9624
9625 static bool mlxsw_sp_is_vrf_event(unsigned long event, void *ptr)
9626 {
9627         struct netdev_notifier_changeupper_info *info = ptr;
9628
9629         if (event != NETDEV_PRECHANGEUPPER && event != NETDEV_CHANGEUPPER)
9630                 return false;
9631         return netif_is_l3_master(info->upper_dev);
9632 }
9633
9634 static int
9635 mlxsw_sp_netdevice_vrf_event(struct net_device *l3_dev, unsigned long event,
9636                              struct netdev_notifier_changeupper_info *info)
9637 {
9638         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(l3_dev);
9639         int err = 0;
9640
9641         /* We do not create a RIF for a macvlan, but only use it to
9642          * direct more MAC addresses to the router.
9643          */
9644         if (!mlxsw_sp || netif_is_macvlan(l3_dev))
9645                 return 0;
9646
9647         switch (event) {
9648         case NETDEV_PRECHANGEUPPER:
9649                 break;
9650         case NETDEV_CHANGEUPPER:
9651                 if (info->linking) {
9652                         struct netlink_ext_ack *extack;
9653
9654                         extack = netdev_notifier_info_to_extack(&info->info);
9655                         err = mlxsw_sp_port_vrf_join(mlxsw_sp, l3_dev, extack);
9656                 } else {
9657                         mlxsw_sp_port_vrf_leave(mlxsw_sp, l3_dev);
9658                 }
9659                 break;
9660         }
9661
9662         return err;
9663 }
9664
9665 static int
9666 mlxsw_sp_port_vid_router_join_existing(struct mlxsw_sp_port *mlxsw_sp_port,
9667                                        u16 vid, struct net_device *dev,
9668                                        struct netlink_ext_ack *extack)
9669 {
9670         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
9671
9672         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port,
9673                                                             vid);
9674         if (WARN_ON(!mlxsw_sp_port_vlan))
9675                 return -EINVAL;
9676
9677         return mlxsw_sp_port_vlan_router_join_existing(mlxsw_sp_port_vlan,
9678                                                        dev, extack);
9679 }
9680
9681 static int __mlxsw_sp_router_port_join_lag(struct mlxsw_sp_port *mlxsw_sp_port,
9682                                            struct net_device *lag_dev,
9683                                            struct netlink_ext_ack *extack)
9684 {
9685         u16 default_vid = MLXSW_SP_DEFAULT_VID;
9686
9687         return mlxsw_sp_port_vid_router_join_existing(mlxsw_sp_port,
9688                                                       default_vid, lag_dev,
9689                                                       extack);
9690 }
9691
9692 int mlxsw_sp_router_port_join_lag(struct mlxsw_sp_port *mlxsw_sp_port,
9693                                   struct net_device *lag_dev,
9694                                   struct netlink_ext_ack *extack)
9695 {
9696         int err;
9697
9698         mutex_lock(&mlxsw_sp_port->mlxsw_sp->router->lock);
9699         err = __mlxsw_sp_router_port_join_lag(mlxsw_sp_port, lag_dev, extack);
9700         mutex_unlock(&mlxsw_sp_port->mlxsw_sp->router->lock);
9701
9702         return err;
9703 }
9704
9705 static int mlxsw_sp_router_netdevice_event(struct notifier_block *nb,
9706                                            unsigned long event, void *ptr)
9707 {
9708         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
9709         struct mlxsw_sp_router *router;
9710         struct mlxsw_sp *mlxsw_sp;
9711         int err = 0;
9712
9713         router = container_of(nb, struct mlxsw_sp_router, netdevice_nb);
9714         mlxsw_sp = router->mlxsw_sp;
9715
9716         mutex_lock(&mlxsw_sp->router->lock);
9717
9718         if (event == NETDEV_REGISTER) {
9719                 err = mlxsw_sp_netdevice_register(router, dev);
9720                 if (err)
9721                         /* No need to roll this back, UNREGISTER will collect it
9722                          * anyhow.
9723                          */
9724                         goto out;
9725         }
9726
9727         if (mlxsw_sp_is_offload_xstats_event(event))
9728                 err = mlxsw_sp_netdevice_offload_xstats_cmd(mlxsw_sp, dev,
9729                                                             event, ptr);
9730         else if (mlxsw_sp_netdev_is_ipip_ol(mlxsw_sp, dev))
9731                 err = mlxsw_sp_netdevice_ipip_ol_event(mlxsw_sp, dev,
9732                                                        event, ptr);
9733         else if (mlxsw_sp_netdev_is_ipip_ul(mlxsw_sp, dev))
9734                 err = mlxsw_sp_netdevice_ipip_ul_event(mlxsw_sp, dev,
9735                                                        event, ptr);
9736         else if (mlxsw_sp_is_router_event(event))
9737                 err = mlxsw_sp_netdevice_router_port_event(dev, event, ptr);
9738         else if (mlxsw_sp_is_vrf_event(event, ptr))
9739                 err = mlxsw_sp_netdevice_vrf_event(dev, event, ptr);
9740
9741         if (event == NETDEV_UNREGISTER)
9742                 mlxsw_sp_netdevice_unregister(router, dev);
9743
9744 out:
9745         mutex_unlock(&mlxsw_sp->router->lock);
9746
9747         return notifier_from_errno(err);
9748 }
9749
9750 static int __mlxsw_sp_rif_macvlan_flush(struct net_device *dev,
9751                                         struct netdev_nested_priv *priv)
9752 {
9753         struct mlxsw_sp_rif *rif = (struct mlxsw_sp_rif *)priv->data;
9754
9755         if (!netif_is_macvlan(dev))
9756                 return 0;
9757
9758         return mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
9759                                    mlxsw_sp_fid_index(rif->fid), false);
9760 }
9761
9762 static int mlxsw_sp_rif_macvlan_flush(struct mlxsw_sp_rif *rif)
9763 {
9764         struct net_device *dev = mlxsw_sp_rif_dev(rif);
9765         struct netdev_nested_priv priv = {
9766                 .data = (void *)rif,
9767         };
9768
9769         if (!netif_is_macvlan_port(dev))
9770                 return 0;
9771
9772         netdev_warn(dev, "Router interface is deleted. Upper macvlans will not work\n");
9773         return netdev_walk_all_upper_dev_rcu(dev,
9774                                              __mlxsw_sp_rif_macvlan_flush, &priv);
9775 }
9776
9777 static void mlxsw_sp_rif_subport_setup(struct mlxsw_sp_rif *rif,
9778                                        const struct mlxsw_sp_rif_params *params)
9779 {
9780         struct mlxsw_sp_rif_subport *rif_subport;
9781
9782         rif_subport = mlxsw_sp_rif_subport_rif(rif);
9783         refcount_set(&rif_subport->ref_count, 1);
9784         rif_subport->vid = params->vid;
9785         rif_subport->lag = params->lag;
9786         if (params->lag)
9787                 rif_subport->lag_id = params->lag_id;
9788         else
9789                 rif_subport->system_port = params->system_port;
9790 }
9791
9792 static int mlxsw_sp_rif_subport_op(struct mlxsw_sp_rif *rif, bool enable)
9793 {
9794         struct net_device *dev = mlxsw_sp_rif_dev(rif);
9795         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
9796         struct mlxsw_sp_rif_subport *rif_subport;
9797         char ritr_pl[MLXSW_REG_RITR_LEN];
9798         u16 efid;
9799
9800         rif_subport = mlxsw_sp_rif_subport_rif(rif);
9801         mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_SP_IF,
9802                             rif->rif_index, rif->vr_id, dev->mtu);
9803         mlxsw_reg_ritr_mac_pack(ritr_pl, dev->dev_addr);
9804         mlxsw_reg_ritr_if_mac_profile_id_set(ritr_pl, rif->mac_profile_id);
9805         efid = mlxsw_sp_fid_index(rif->fid);
9806         mlxsw_reg_ritr_sp_if_pack(ritr_pl, rif_subport->lag,
9807                                   rif_subport->lag ? rif_subport->lag_id :
9808                                                      rif_subport->system_port,
9809                                   efid, 0);
9810         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
9811 }
9812
9813 static int mlxsw_sp_rif_subport_configure(struct mlxsw_sp_rif *rif,
9814                                           struct netlink_ext_ack *extack)
9815 {
9816         struct net_device *dev = mlxsw_sp_rif_dev(rif);
9817         u8 mac_profile;
9818         int err;
9819
9820         err = mlxsw_sp_rif_mac_profile_get(rif->mlxsw_sp, rif->addr,
9821                                            &mac_profile, extack);
9822         if (err)
9823                 return err;
9824         rif->mac_profile_id = mac_profile;
9825
9826         err = mlxsw_sp_rif_subport_op(rif, true);
9827         if (err)
9828                 goto err_rif_subport_op;
9829
9830         err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
9831                                   mlxsw_sp_fid_index(rif->fid), true);
9832         if (err)
9833                 goto err_rif_fdb_op;
9834
9835         err = mlxsw_sp_fid_rif_set(rif->fid, rif);
9836         if (err)
9837                 goto err_fid_rif_set;
9838
9839         return 0;
9840
9841 err_fid_rif_set:
9842         mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
9843                             mlxsw_sp_fid_index(rif->fid), false);
9844 err_rif_fdb_op:
9845         mlxsw_sp_rif_subport_op(rif, false);
9846 err_rif_subport_op:
9847         mlxsw_sp_rif_mac_profile_put(rif->mlxsw_sp, mac_profile);
9848         return err;
9849 }
9850
9851 static void mlxsw_sp_rif_subport_deconfigure(struct mlxsw_sp_rif *rif)
9852 {
9853         struct net_device *dev = mlxsw_sp_rif_dev(rif);
9854         struct mlxsw_sp_fid *fid = rif->fid;
9855
9856         mlxsw_sp_fid_rif_unset(fid);
9857         mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
9858                             mlxsw_sp_fid_index(fid), false);
9859         mlxsw_sp_rif_macvlan_flush(rif);
9860         mlxsw_sp_rif_subport_op(rif, false);
9861         mlxsw_sp_rif_mac_profile_put(rif->mlxsw_sp, rif->mac_profile_id);
9862 }
9863
9864 static struct mlxsw_sp_fid *
9865 mlxsw_sp_rif_subport_fid_get(struct mlxsw_sp_rif *rif,
9866                              const struct mlxsw_sp_rif_params *params,
9867                              struct netlink_ext_ack *extack)
9868 {
9869         return mlxsw_sp_fid_rfid_get(rif->mlxsw_sp, rif->rif_index);
9870 }
9871
9872 static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_subport_ops = {
9873         .type                   = MLXSW_SP_RIF_TYPE_SUBPORT,
9874         .rif_size               = sizeof(struct mlxsw_sp_rif_subport),
9875         .setup                  = mlxsw_sp_rif_subport_setup,
9876         .configure              = mlxsw_sp_rif_subport_configure,
9877         .deconfigure            = mlxsw_sp_rif_subport_deconfigure,
9878         .fid_get                = mlxsw_sp_rif_subport_fid_get,
9879 };
9880
9881 static int mlxsw_sp_rif_fid_op(struct mlxsw_sp_rif *rif, u16 fid, bool enable)
9882 {
9883         enum mlxsw_reg_ritr_if_type type = MLXSW_REG_RITR_FID_IF;
9884         struct net_device *dev = mlxsw_sp_rif_dev(rif);
9885         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
9886         char ritr_pl[MLXSW_REG_RITR_LEN];
9887
9888         mlxsw_reg_ritr_pack(ritr_pl, enable, type, rif->rif_index, rif->vr_id,
9889                             dev->mtu);
9890         mlxsw_reg_ritr_mac_pack(ritr_pl, dev->dev_addr);
9891         mlxsw_reg_ritr_if_mac_profile_id_set(ritr_pl, rif->mac_profile_id);
9892         mlxsw_reg_ritr_fid_if_fid_set(ritr_pl, fid);
9893
9894         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
9895 }
9896
9897 u16 mlxsw_sp_router_port(const struct mlxsw_sp *mlxsw_sp)
9898 {
9899         return mlxsw_core_max_ports(mlxsw_sp->core) + 1;
9900 }
9901
9902 static int mlxsw_sp_rif_fid_configure(struct mlxsw_sp_rif *rif,
9903                                       struct netlink_ext_ack *extack)
9904 {
9905         struct net_device *dev = mlxsw_sp_rif_dev(rif);
9906         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
9907         u16 fid_index = mlxsw_sp_fid_index(rif->fid);
9908         u8 mac_profile;
9909         int err;
9910
9911         err = mlxsw_sp_rif_mac_profile_get(mlxsw_sp, rif->addr,
9912                                            &mac_profile, extack);
9913         if (err)
9914                 return err;
9915         rif->mac_profile_id = mac_profile;
9916
9917         err = mlxsw_sp_rif_fid_op(rif, fid_index, true);
9918         if (err)
9919                 goto err_rif_fid_op;
9920
9921         err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
9922                                      mlxsw_sp_router_port(mlxsw_sp), true);
9923         if (err)
9924                 goto err_fid_mc_flood_set;
9925
9926         err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
9927                                      mlxsw_sp_router_port(mlxsw_sp), true);
9928         if (err)
9929                 goto err_fid_bc_flood_set;
9930
9931         err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
9932                                   mlxsw_sp_fid_index(rif->fid), true);
9933         if (err)
9934                 goto err_rif_fdb_op;
9935
9936         err = mlxsw_sp_fid_rif_set(rif->fid, rif);
9937         if (err)
9938                 goto err_fid_rif_set;
9939
9940         return 0;
9941
9942 err_fid_rif_set:
9943         mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
9944                             mlxsw_sp_fid_index(rif->fid), false);
9945 err_rif_fdb_op:
9946         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
9947                                mlxsw_sp_router_port(mlxsw_sp), false);
9948 err_fid_bc_flood_set:
9949         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
9950                                mlxsw_sp_router_port(mlxsw_sp), false);
9951 err_fid_mc_flood_set:
9952         mlxsw_sp_rif_fid_op(rif, fid_index, false);
9953 err_rif_fid_op:
9954         mlxsw_sp_rif_mac_profile_put(mlxsw_sp, mac_profile);
9955         return err;
9956 }
9957
9958 static void mlxsw_sp_rif_fid_deconfigure(struct mlxsw_sp_rif *rif)
9959 {
9960         struct net_device *dev = mlxsw_sp_rif_dev(rif);
9961         u16 fid_index = mlxsw_sp_fid_index(rif->fid);
9962         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
9963         struct mlxsw_sp_fid *fid = rif->fid;
9964
9965         mlxsw_sp_fid_rif_unset(fid);
9966         mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
9967                             mlxsw_sp_fid_index(fid), false);
9968         mlxsw_sp_rif_macvlan_flush(rif);
9969         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
9970                                mlxsw_sp_router_port(mlxsw_sp), false);
9971         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
9972                                mlxsw_sp_router_port(mlxsw_sp), false);
9973         mlxsw_sp_rif_fid_op(rif, fid_index, false);
9974         mlxsw_sp_rif_mac_profile_put(rif->mlxsw_sp, rif->mac_profile_id);
9975 }
9976
9977 static struct mlxsw_sp_fid *
9978 mlxsw_sp_rif_fid_fid_get(struct mlxsw_sp_rif *rif,
9979                          const struct mlxsw_sp_rif_params *params,
9980                          struct netlink_ext_ack *extack)
9981 {
9982         int rif_ifindex = mlxsw_sp_rif_dev_ifindex(rif);
9983
9984         return mlxsw_sp_fid_8021d_get(rif->mlxsw_sp, rif_ifindex);
9985 }
9986
9987 static void mlxsw_sp_rif_fid_fdb_del(struct mlxsw_sp_rif *rif, const char *mac)
9988 {
9989         struct switchdev_notifier_fdb_info info = {};
9990         struct net_device *dev;
9991
9992         dev = br_fdb_find_port(mlxsw_sp_rif_dev(rif), mac, 0);
9993         if (!dev)
9994                 return;
9995
9996         info.addr = mac;
9997         info.vid = 0;
9998         call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE, dev, &info.info,
9999                                  NULL);
10000 }
10001
10002 static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_fid_ops = {
10003         .type                   = MLXSW_SP_RIF_TYPE_FID,
10004         .rif_size               = sizeof(struct mlxsw_sp_rif),
10005         .configure              = mlxsw_sp_rif_fid_configure,
10006         .deconfigure            = mlxsw_sp_rif_fid_deconfigure,
10007         .fid_get                = mlxsw_sp_rif_fid_fid_get,
10008         .fdb_del                = mlxsw_sp_rif_fid_fdb_del,
10009 };
10010
10011 static struct mlxsw_sp_fid *
10012 mlxsw_sp_rif_vlan_fid_get(struct mlxsw_sp_rif *rif,
10013                           const struct mlxsw_sp_rif_params *params,
10014                           struct netlink_ext_ack *extack)
10015 {
10016         struct net_device *dev = mlxsw_sp_rif_dev(rif);
10017         struct net_device *br_dev;
10018
10019         if (WARN_ON(!params->vid))
10020                 return ERR_PTR(-EINVAL);
10021
10022         if (is_vlan_dev(dev)) {
10023                 br_dev = vlan_dev_real_dev(dev);
10024                 if (WARN_ON(!netif_is_bridge_master(br_dev)))
10025                         return ERR_PTR(-EINVAL);
10026         }
10027
10028         return mlxsw_sp_fid_8021q_get(rif->mlxsw_sp, params->vid);
10029 }
10030
10031 static void mlxsw_sp_rif_vlan_fdb_del(struct mlxsw_sp_rif *rif, const char *mac)
10032 {
10033         struct net_device *rif_dev = mlxsw_sp_rif_dev(rif);
10034         struct switchdev_notifier_fdb_info info = {};
10035         u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
10036         struct net_device *br_dev;
10037         struct net_device *dev;
10038
10039         br_dev = is_vlan_dev(rif_dev) ? vlan_dev_real_dev(rif_dev) : rif_dev;
10040         dev = br_fdb_find_port(br_dev, mac, vid);
10041         if (!dev)
10042                 return;
10043
10044         info.addr = mac;
10045         info.vid = vid;
10046         call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE, dev, &info.info,
10047                                  NULL);
10048 }
10049
10050 static int mlxsw_sp_rif_vlan_op(struct mlxsw_sp_rif *rif, u16 vid, u16 efid,
10051                                 bool enable)
10052 {
10053         struct net_device *dev = mlxsw_sp_rif_dev(rif);
10054         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10055         char ritr_pl[MLXSW_REG_RITR_LEN];
10056
10057         mlxsw_reg_ritr_vlan_if_pack(ritr_pl, enable, rif->rif_index, rif->vr_id,
10058                                     dev->mtu, dev->dev_addr,
10059                                     rif->mac_profile_id, vid, efid);
10060
10061         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
10062 }
10063
10064 static int mlxsw_sp_rif_vlan_configure(struct mlxsw_sp_rif *rif, u16 efid,
10065                                        struct netlink_ext_ack *extack)
10066 {
10067         struct net_device *dev = mlxsw_sp_rif_dev(rif);
10068         u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
10069         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10070         u8 mac_profile;
10071         int err;
10072
10073         err = mlxsw_sp_rif_mac_profile_get(mlxsw_sp, rif->addr,
10074                                            &mac_profile, extack);
10075         if (err)
10076                 return err;
10077         rif->mac_profile_id = mac_profile;
10078
10079         err = mlxsw_sp_rif_vlan_op(rif, vid, efid, true);
10080         if (err)
10081                 goto err_rif_vlan_fid_op;
10082
10083         err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
10084                                      mlxsw_sp_router_port(mlxsw_sp), true);
10085         if (err)
10086                 goto err_fid_mc_flood_set;
10087
10088         err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
10089                                      mlxsw_sp_router_port(mlxsw_sp), true);
10090         if (err)
10091                 goto err_fid_bc_flood_set;
10092
10093         err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
10094                                   mlxsw_sp_fid_index(rif->fid), true);
10095         if (err)
10096                 goto err_rif_fdb_op;
10097
10098         err = mlxsw_sp_fid_rif_set(rif->fid, rif);
10099         if (err)
10100                 goto err_fid_rif_set;
10101
10102         return 0;
10103
10104 err_fid_rif_set:
10105         mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
10106                             mlxsw_sp_fid_index(rif->fid), false);
10107 err_rif_fdb_op:
10108         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
10109                                mlxsw_sp_router_port(mlxsw_sp), false);
10110 err_fid_bc_flood_set:
10111         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
10112                                mlxsw_sp_router_port(mlxsw_sp), false);
10113 err_fid_mc_flood_set:
10114         mlxsw_sp_rif_vlan_op(rif, vid, 0, false);
10115 err_rif_vlan_fid_op:
10116         mlxsw_sp_rif_mac_profile_put(mlxsw_sp, mac_profile);
10117         return err;
10118 }
10119
10120 static void mlxsw_sp_rif_vlan_deconfigure(struct mlxsw_sp_rif *rif)
10121 {
10122         struct net_device *dev = mlxsw_sp_rif_dev(rif);
10123         u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
10124         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10125
10126         mlxsw_sp_fid_rif_unset(rif->fid);
10127         mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
10128                             mlxsw_sp_fid_index(rif->fid), false);
10129         mlxsw_sp_rif_macvlan_flush(rif);
10130         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
10131                                mlxsw_sp_router_port(mlxsw_sp), false);
10132         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
10133                                mlxsw_sp_router_port(mlxsw_sp), false);
10134         mlxsw_sp_rif_vlan_op(rif, vid, 0, false);
10135         mlxsw_sp_rif_mac_profile_put(rif->mlxsw_sp, rif->mac_profile_id);
10136 }
10137
10138 static int mlxsw_sp1_rif_vlan_configure(struct mlxsw_sp_rif *rif,
10139                                         struct netlink_ext_ack *extack)
10140 {
10141         return mlxsw_sp_rif_vlan_configure(rif, 0, extack);
10142 }
10143
10144 static const struct mlxsw_sp_rif_ops mlxsw_sp1_rif_vlan_ops = {
10145         .type                   = MLXSW_SP_RIF_TYPE_VLAN,
10146         .rif_size               = sizeof(struct mlxsw_sp_rif),
10147         .configure              = mlxsw_sp1_rif_vlan_configure,
10148         .deconfigure            = mlxsw_sp_rif_vlan_deconfigure,
10149         .fid_get                = mlxsw_sp_rif_vlan_fid_get,
10150         .fdb_del                = mlxsw_sp_rif_vlan_fdb_del,
10151 };
10152
10153 static int mlxsw_sp2_rif_vlan_configure(struct mlxsw_sp_rif *rif,
10154                                         struct netlink_ext_ack *extack)
10155 {
10156         u16 efid = mlxsw_sp_fid_index(rif->fid);
10157
10158         return mlxsw_sp_rif_vlan_configure(rif, efid, extack);
10159 }
10160
10161 static const struct mlxsw_sp_rif_ops mlxsw_sp2_rif_vlan_ops = {
10162         .type                   = MLXSW_SP_RIF_TYPE_VLAN,
10163         .rif_size               = sizeof(struct mlxsw_sp_rif),
10164         .configure              = mlxsw_sp2_rif_vlan_configure,
10165         .deconfigure            = mlxsw_sp_rif_vlan_deconfigure,
10166         .fid_get                = mlxsw_sp_rif_vlan_fid_get,
10167         .fdb_del                = mlxsw_sp_rif_vlan_fdb_del,
10168 };
10169
10170 static struct mlxsw_sp_rif_ipip_lb *
10171 mlxsw_sp_rif_ipip_lb_rif(struct mlxsw_sp_rif *rif)
10172 {
10173         return container_of(rif, struct mlxsw_sp_rif_ipip_lb, common);
10174 }
10175
10176 static void
10177 mlxsw_sp_rif_ipip_lb_setup(struct mlxsw_sp_rif *rif,
10178                            const struct mlxsw_sp_rif_params *params)
10179 {
10180         struct mlxsw_sp_rif_params_ipip_lb *params_lb;
10181         struct mlxsw_sp_rif_ipip_lb *rif_lb;
10182
10183         params_lb = container_of(params, struct mlxsw_sp_rif_params_ipip_lb,
10184                                  common);
10185         rif_lb = mlxsw_sp_rif_ipip_lb_rif(rif);
10186         rif_lb->lb_config = params_lb->lb_config;
10187 }
10188
10189 static int
10190 mlxsw_sp1_rif_ipip_lb_configure(struct mlxsw_sp_rif *rif,
10191                                 struct netlink_ext_ack *extack)
10192 {
10193         struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
10194         struct net_device *dev = mlxsw_sp_rif_dev(rif);
10195         u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(dev);
10196         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10197         struct mlxsw_sp_vr *ul_vr;
10198         int err;
10199
10200         ul_vr = mlxsw_sp_vr_get(mlxsw_sp, ul_tb_id, extack);
10201         if (IS_ERR(ul_vr))
10202                 return PTR_ERR(ul_vr);
10203
10204         err = mlxsw_sp_rif_ipip_lb_op(lb_rif, ul_vr->id, 0, true);
10205         if (err)
10206                 goto err_loopback_op;
10207
10208         lb_rif->ul_vr_id = ul_vr->id;
10209         lb_rif->ul_rif_id = 0;
10210         ++ul_vr->rif_count;
10211         return 0;
10212
10213 err_loopback_op:
10214         mlxsw_sp_vr_put(mlxsw_sp, ul_vr);
10215         return err;
10216 }
10217
10218 static void mlxsw_sp1_rif_ipip_lb_deconfigure(struct mlxsw_sp_rif *rif)
10219 {
10220         struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
10221         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10222         struct mlxsw_sp_vr *ul_vr;
10223
10224         ul_vr = &mlxsw_sp->router->vrs[lb_rif->ul_vr_id];
10225         mlxsw_sp_rif_ipip_lb_op(lb_rif, ul_vr->id, 0, false);
10226
10227         --ul_vr->rif_count;
10228         mlxsw_sp_vr_put(mlxsw_sp, ul_vr);
10229 }
10230
10231 static const struct mlxsw_sp_rif_ops mlxsw_sp1_rif_ipip_lb_ops = {
10232         .type                   = MLXSW_SP_RIF_TYPE_IPIP_LB,
10233         .rif_size               = sizeof(struct mlxsw_sp_rif_ipip_lb),
10234         .setup                  = mlxsw_sp_rif_ipip_lb_setup,
10235         .configure              = mlxsw_sp1_rif_ipip_lb_configure,
10236         .deconfigure            = mlxsw_sp1_rif_ipip_lb_deconfigure,
10237 };
10238
10239 static const struct mlxsw_sp_rif_ops *mlxsw_sp1_rif_ops_arr[] = {
10240         [MLXSW_SP_RIF_TYPE_SUBPORT]     = &mlxsw_sp_rif_subport_ops,
10241         [MLXSW_SP_RIF_TYPE_VLAN]        = &mlxsw_sp1_rif_vlan_ops,
10242         [MLXSW_SP_RIF_TYPE_FID]         = &mlxsw_sp_rif_fid_ops,
10243         [MLXSW_SP_RIF_TYPE_IPIP_LB]     = &mlxsw_sp1_rif_ipip_lb_ops,
10244 };
10245
10246 static int
10247 mlxsw_sp_rif_ipip_lb_ul_rif_op(struct mlxsw_sp_rif *ul_rif, bool enable)
10248 {
10249         struct mlxsw_sp *mlxsw_sp = ul_rif->mlxsw_sp;
10250         char ritr_pl[MLXSW_REG_RITR_LEN];
10251
10252         mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_LOOPBACK_IF,
10253                             ul_rif->rif_index, ul_rif->vr_id, IP_MAX_MTU);
10254         mlxsw_reg_ritr_loopback_protocol_set(ritr_pl,
10255                                              MLXSW_REG_RITR_LOOPBACK_GENERIC);
10256
10257         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
10258 }
10259
10260 static struct mlxsw_sp_rif *
10261 mlxsw_sp_ul_rif_create(struct mlxsw_sp *mlxsw_sp, struct mlxsw_sp_vr *vr,
10262                        struct mlxsw_sp_crif *ul_crif,
10263                        struct netlink_ext_ack *extack)
10264 {
10265         struct mlxsw_sp_rif *ul_rif;
10266         u8 rif_entries = 1;
10267         u16 rif_index;
10268         int err;
10269
10270         err = mlxsw_sp_rif_index_alloc(mlxsw_sp, &rif_index, rif_entries);
10271         if (err) {
10272                 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported router interfaces");
10273                 return ERR_PTR(err);
10274         }
10275
10276         ul_rif = mlxsw_sp_rif_alloc(sizeof(*ul_rif), rif_index, vr->id,
10277                                     ul_crif);
10278         if (!ul_rif) {
10279                 err = -ENOMEM;
10280                 goto err_rif_alloc;
10281         }
10282
10283         mlxsw_sp->router->rifs[rif_index] = ul_rif;
10284         ul_rif->mlxsw_sp = mlxsw_sp;
10285         ul_rif->rif_entries = rif_entries;
10286         err = mlxsw_sp_rif_ipip_lb_ul_rif_op(ul_rif, true);
10287         if (err)
10288                 goto ul_rif_op_err;
10289
10290         atomic_add(rif_entries, &mlxsw_sp->router->rifs_count);
10291         return ul_rif;
10292
10293 ul_rif_op_err:
10294         mlxsw_sp->router->rifs[rif_index] = NULL;
10295         mlxsw_sp_rif_free(ul_rif);
10296 err_rif_alloc:
10297         mlxsw_sp_rif_index_free(mlxsw_sp, rif_index, rif_entries);
10298         return ERR_PTR(err);
10299 }
10300
10301 static void mlxsw_sp_ul_rif_destroy(struct mlxsw_sp_rif *ul_rif)
10302 {
10303         struct mlxsw_sp *mlxsw_sp = ul_rif->mlxsw_sp;
10304         u8 rif_entries = ul_rif->rif_entries;
10305         u16 rif_index = ul_rif->rif_index;
10306
10307         atomic_sub(rif_entries, &mlxsw_sp->router->rifs_count);
10308         mlxsw_sp_rif_ipip_lb_ul_rif_op(ul_rif, false);
10309         mlxsw_sp->router->rifs[ul_rif->rif_index] = NULL;
10310         mlxsw_sp_rif_free(ul_rif);
10311         mlxsw_sp_rif_index_free(mlxsw_sp, rif_index, rif_entries);
10312 }
10313
10314 static struct mlxsw_sp_rif *
10315 mlxsw_sp_ul_rif_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id,
10316                     struct mlxsw_sp_crif *ul_crif,
10317                     struct netlink_ext_ack *extack)
10318 {
10319         struct mlxsw_sp_vr *vr;
10320         int err;
10321
10322         vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id, extack);
10323         if (IS_ERR(vr))
10324                 return ERR_CAST(vr);
10325
10326         if (refcount_inc_not_zero(&vr->ul_rif_refcnt))
10327                 return vr->ul_rif;
10328
10329         vr->ul_rif = mlxsw_sp_ul_rif_create(mlxsw_sp, vr, ul_crif, extack);
10330         if (IS_ERR(vr->ul_rif)) {
10331                 err = PTR_ERR(vr->ul_rif);
10332                 goto err_ul_rif_create;
10333         }
10334
10335         vr->rif_count++;
10336         refcount_set(&vr->ul_rif_refcnt, 1);
10337
10338         return vr->ul_rif;
10339
10340 err_ul_rif_create:
10341         mlxsw_sp_vr_put(mlxsw_sp, vr);
10342         return ERR_PTR(err);
10343 }
10344
10345 static void mlxsw_sp_ul_rif_put(struct mlxsw_sp_rif *ul_rif)
10346 {
10347         struct mlxsw_sp *mlxsw_sp = ul_rif->mlxsw_sp;
10348         struct mlxsw_sp_vr *vr;
10349
10350         vr = &mlxsw_sp->router->vrs[ul_rif->vr_id];
10351
10352         if (!refcount_dec_and_test(&vr->ul_rif_refcnt))
10353                 return;
10354
10355         vr->rif_count--;
10356         mlxsw_sp_ul_rif_destroy(ul_rif);
10357         mlxsw_sp_vr_put(mlxsw_sp, vr);
10358 }
10359
10360 int mlxsw_sp_router_ul_rif_get(struct mlxsw_sp *mlxsw_sp, u32 ul_tb_id,
10361                                u16 *ul_rif_index)
10362 {
10363         struct mlxsw_sp_rif *ul_rif;
10364         int err = 0;
10365
10366         mutex_lock(&mlxsw_sp->router->lock);
10367         ul_rif = mlxsw_sp_ul_rif_get(mlxsw_sp, ul_tb_id, NULL, NULL);
10368         if (IS_ERR(ul_rif)) {
10369                 err = PTR_ERR(ul_rif);
10370                 goto out;
10371         }
10372         *ul_rif_index = ul_rif->rif_index;
10373 out:
10374         mutex_unlock(&mlxsw_sp->router->lock);
10375         return err;
10376 }
10377
10378 void mlxsw_sp_router_ul_rif_put(struct mlxsw_sp *mlxsw_sp, u16 ul_rif_index)
10379 {
10380         struct mlxsw_sp_rif *ul_rif;
10381
10382         mutex_lock(&mlxsw_sp->router->lock);
10383         ul_rif = mlxsw_sp->router->rifs[ul_rif_index];
10384         if (WARN_ON(!ul_rif))
10385                 goto out;
10386
10387         mlxsw_sp_ul_rif_put(ul_rif);
10388 out:
10389         mutex_unlock(&mlxsw_sp->router->lock);
10390 }
10391
10392 static int
10393 mlxsw_sp2_rif_ipip_lb_configure(struct mlxsw_sp_rif *rif,
10394                                 struct netlink_ext_ack *extack)
10395 {
10396         struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
10397         struct net_device *dev = mlxsw_sp_rif_dev(rif);
10398         u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(dev);
10399         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10400         struct mlxsw_sp_rif *ul_rif;
10401         int err;
10402
10403         ul_rif = mlxsw_sp_ul_rif_get(mlxsw_sp, ul_tb_id, NULL, extack);
10404         if (IS_ERR(ul_rif))
10405                 return PTR_ERR(ul_rif);
10406
10407         err = mlxsw_sp_rif_ipip_lb_op(lb_rif, 0, ul_rif->rif_index, true);
10408         if (err)
10409                 goto err_loopback_op;
10410
10411         lb_rif->ul_vr_id = 0;
10412         lb_rif->ul_rif_id = ul_rif->rif_index;
10413
10414         return 0;
10415
10416 err_loopback_op:
10417         mlxsw_sp_ul_rif_put(ul_rif);
10418         return err;
10419 }
10420
10421 static void mlxsw_sp2_rif_ipip_lb_deconfigure(struct mlxsw_sp_rif *rif)
10422 {
10423         struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
10424         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
10425         struct mlxsw_sp_rif *ul_rif;
10426
10427         ul_rif = mlxsw_sp_rif_by_index(mlxsw_sp, lb_rif->ul_rif_id);
10428         mlxsw_sp_rif_ipip_lb_op(lb_rif, 0, lb_rif->ul_rif_id, false);
10429         mlxsw_sp_ul_rif_put(ul_rif);
10430 }
10431
10432 static const struct mlxsw_sp_rif_ops mlxsw_sp2_rif_ipip_lb_ops = {
10433         .type                   = MLXSW_SP_RIF_TYPE_IPIP_LB,
10434         .rif_size               = sizeof(struct mlxsw_sp_rif_ipip_lb),
10435         .setup                  = mlxsw_sp_rif_ipip_lb_setup,
10436         .configure              = mlxsw_sp2_rif_ipip_lb_configure,
10437         .deconfigure            = mlxsw_sp2_rif_ipip_lb_deconfigure,
10438 };
10439
10440 static const struct mlxsw_sp_rif_ops *mlxsw_sp2_rif_ops_arr[] = {
10441         [MLXSW_SP_RIF_TYPE_SUBPORT]     = &mlxsw_sp_rif_subport_ops,
10442         [MLXSW_SP_RIF_TYPE_VLAN]        = &mlxsw_sp2_rif_vlan_ops,
10443         [MLXSW_SP_RIF_TYPE_FID]         = &mlxsw_sp_rif_fid_ops,
10444         [MLXSW_SP_RIF_TYPE_IPIP_LB]     = &mlxsw_sp2_rif_ipip_lb_ops,
10445 };
10446
10447 static int mlxsw_sp_rifs_table_init(struct mlxsw_sp *mlxsw_sp)
10448 {
10449         struct gen_pool *rifs_table;
10450         int err;
10451
10452         rifs_table = gen_pool_create(0, -1);
10453         if (!rifs_table)
10454                 return -ENOMEM;
10455
10456         gen_pool_set_algo(rifs_table, gen_pool_first_fit_order_align,
10457                           NULL);
10458
10459         err = gen_pool_add(rifs_table, MLXSW_SP_ROUTER_GENALLOC_OFFSET,
10460                            MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS), -1);
10461         if (err)
10462                 goto err_gen_pool_add;
10463
10464         mlxsw_sp->router->rifs_table = rifs_table;
10465
10466         return 0;
10467
10468 err_gen_pool_add:
10469         gen_pool_destroy(rifs_table);
10470         return err;
10471 }
10472
10473 static void mlxsw_sp_rifs_table_fini(struct mlxsw_sp *mlxsw_sp)
10474 {
10475         gen_pool_destroy(mlxsw_sp->router->rifs_table);
10476 }
10477
10478 static int mlxsw_sp_rifs_init(struct mlxsw_sp *mlxsw_sp)
10479 {
10480         u64 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
10481         struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
10482         struct mlxsw_core *core = mlxsw_sp->core;
10483         int err;
10484
10485         if (!MLXSW_CORE_RES_VALID(core, MAX_RIF_MAC_PROFILES))
10486                 return -EIO;
10487         mlxsw_sp->router->max_rif_mac_profile =
10488                 MLXSW_CORE_RES_GET(core, MAX_RIF_MAC_PROFILES);
10489
10490         mlxsw_sp->router->rifs = kcalloc(max_rifs,
10491                                          sizeof(struct mlxsw_sp_rif *),
10492                                          GFP_KERNEL);
10493         if (!mlxsw_sp->router->rifs)
10494                 return -ENOMEM;
10495
10496         err = mlxsw_sp_rifs_table_init(mlxsw_sp);
10497         if (err)
10498                 goto err_rifs_table_init;
10499
10500         idr_init(&mlxsw_sp->router->rif_mac_profiles_idr);
10501         atomic_set(&mlxsw_sp->router->rif_mac_profiles_count, 0);
10502         atomic_set(&mlxsw_sp->router->rifs_count, 0);
10503         devl_resource_occ_get_register(devlink,
10504                                        MLXSW_SP_RESOURCE_RIF_MAC_PROFILES,
10505                                        mlxsw_sp_rif_mac_profiles_occ_get,
10506                                        mlxsw_sp);
10507         devl_resource_occ_get_register(devlink,
10508                                        MLXSW_SP_RESOURCE_RIFS,
10509                                        mlxsw_sp_rifs_occ_get,
10510                                        mlxsw_sp);
10511
10512         return 0;
10513
10514 err_rifs_table_init:
10515         kfree(mlxsw_sp->router->rifs);
10516         return err;
10517 }
10518
10519 static void mlxsw_sp_rifs_fini(struct mlxsw_sp *mlxsw_sp)
10520 {
10521         int max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
10522         struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
10523         int i;
10524
10525         WARN_ON_ONCE(atomic_read(&mlxsw_sp->router->rifs_count));
10526         for (i = 0; i < max_rifs; i++)
10527                 WARN_ON_ONCE(mlxsw_sp->router->rifs[i]);
10528
10529         devl_resource_occ_get_unregister(devlink, MLXSW_SP_RESOURCE_RIFS);
10530         devl_resource_occ_get_unregister(devlink,
10531                                          MLXSW_SP_RESOURCE_RIF_MAC_PROFILES);
10532         WARN_ON(!idr_is_empty(&mlxsw_sp->router->rif_mac_profiles_idr));
10533         idr_destroy(&mlxsw_sp->router->rif_mac_profiles_idr);
10534         mlxsw_sp_rifs_table_fini(mlxsw_sp);
10535         kfree(mlxsw_sp->router->rifs);
10536 }
10537
10538 static int
10539 mlxsw_sp_ipip_config_tigcr(struct mlxsw_sp *mlxsw_sp)
10540 {
10541         char tigcr_pl[MLXSW_REG_TIGCR_LEN];
10542
10543         mlxsw_reg_tigcr_pack(tigcr_pl, true, 0);
10544         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(tigcr), tigcr_pl);
10545 }
10546
10547 static int mlxsw_sp_ipips_init(struct mlxsw_sp *mlxsw_sp)
10548 {
10549         int err;
10550
10551         INIT_LIST_HEAD(&mlxsw_sp->router->ipip_list);
10552
10553         err = mlxsw_sp_ipip_ecn_encap_init(mlxsw_sp);
10554         if (err)
10555                 return err;
10556         err = mlxsw_sp_ipip_ecn_decap_init(mlxsw_sp);
10557         if (err)
10558                 return err;
10559
10560         return mlxsw_sp_ipip_config_tigcr(mlxsw_sp);
10561 }
10562
10563 static int mlxsw_sp1_ipips_init(struct mlxsw_sp *mlxsw_sp)
10564 {
10565         mlxsw_sp->router->ipip_ops_arr = mlxsw_sp1_ipip_ops_arr;
10566         return mlxsw_sp_ipips_init(mlxsw_sp);
10567 }
10568
10569 static int mlxsw_sp2_ipips_init(struct mlxsw_sp *mlxsw_sp)
10570 {
10571         mlxsw_sp->router->ipip_ops_arr = mlxsw_sp2_ipip_ops_arr;
10572         return mlxsw_sp_ipips_init(mlxsw_sp);
10573 }
10574
10575 static void mlxsw_sp_ipips_fini(struct mlxsw_sp *mlxsw_sp)
10576 {
10577         WARN_ON(!list_empty(&mlxsw_sp->router->ipip_list));
10578 }
10579
10580 static void mlxsw_sp_router_fib_dump_flush(struct notifier_block *nb)
10581 {
10582         struct mlxsw_sp_router *router;
10583
10584         /* Flush pending FIB notifications and then flush the device's
10585          * table before requesting another dump. The FIB notification
10586          * block is unregistered, so no need to take RTNL.
10587          */
10588         mlxsw_core_flush_owq();
10589         router = container_of(nb, struct mlxsw_sp_router, fib_nb);
10590         mlxsw_sp_router_fib_flush(router->mlxsw_sp);
10591 }
10592
10593 #ifdef CONFIG_IP_ROUTE_MULTIPATH
10594 struct mlxsw_sp_mp_hash_config {
10595         DECLARE_BITMAP(headers, __MLXSW_REG_RECR2_HEADER_CNT);
10596         DECLARE_BITMAP(fields, __MLXSW_REG_RECR2_FIELD_CNT);
10597         DECLARE_BITMAP(inner_headers, __MLXSW_REG_RECR2_HEADER_CNT);
10598         DECLARE_BITMAP(inner_fields, __MLXSW_REG_RECR2_INNER_FIELD_CNT);
10599         bool inc_parsing_depth;
10600 };
10601
10602 #define MLXSW_SP_MP_HASH_HEADER_SET(_headers, _header) \
10603         bitmap_set(_headers, MLXSW_REG_RECR2_##_header, 1)
10604
10605 #define MLXSW_SP_MP_HASH_FIELD_SET(_fields, _field) \
10606         bitmap_set(_fields, MLXSW_REG_RECR2_##_field, 1)
10607
10608 #define MLXSW_SP_MP_HASH_FIELD_RANGE_SET(_fields, _field, _nr) \
10609         bitmap_set(_fields, MLXSW_REG_RECR2_##_field, _nr)
10610
10611 static void mlxsw_sp_mp_hash_inner_l3(struct mlxsw_sp_mp_hash_config *config)
10612 {
10613         unsigned long *inner_headers = config->inner_headers;
10614         unsigned long *inner_fields = config->inner_fields;
10615
10616         /* IPv4 inner */
10617         MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV4_EN_NOT_TCP_NOT_UDP);
10618         MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV4_EN_TCP_UDP);
10619         MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV4_SIP0, 4);
10620         MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV4_DIP0, 4);
10621         /* IPv6 inner */
10622         MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV6_EN_NOT_TCP_NOT_UDP);
10623         MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV6_EN_TCP_UDP);
10624         MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_SIP0_7);
10625         MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV6_SIP8, 8);
10626         MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_DIP0_7);
10627         MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV6_DIP8, 8);
10628         MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_NEXT_HEADER);
10629         MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_FLOW_LABEL);
10630 }
10631
10632 static void mlxsw_sp_mp4_hash_outer_addr(struct mlxsw_sp_mp_hash_config *config)
10633 {
10634         unsigned long *headers = config->headers;
10635         unsigned long *fields = config->fields;
10636
10637         MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV4_EN_NOT_TCP_NOT_UDP);
10638         MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV4_EN_TCP_UDP);
10639         MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV4_SIP0, 4);
10640         MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV4_DIP0, 4);
10641 }
10642
10643 static void
10644 mlxsw_sp_mp_hash_inner_custom(struct mlxsw_sp_mp_hash_config *config,
10645                               u32 hash_fields)
10646 {
10647         unsigned long *inner_headers = config->inner_headers;
10648         unsigned long *inner_fields = config->inner_fields;
10649
10650         /* IPv4 Inner */
10651         MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV4_EN_NOT_TCP_NOT_UDP);
10652         MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV4_EN_TCP_UDP);
10653         if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_SRC_IP)
10654                 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV4_SIP0, 4);
10655         if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_DST_IP)
10656                 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV4_DIP0, 4);
10657         if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_IP_PROTO)
10658                 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV4_PROTOCOL);
10659         /* IPv6 inner */
10660         MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV6_EN_NOT_TCP_NOT_UDP);
10661         MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, IPV6_EN_TCP_UDP);
10662         if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_SRC_IP) {
10663                 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_SIP0_7);
10664                 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV6_SIP8, 8);
10665         }
10666         if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_DST_IP) {
10667                 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_DIP0_7);
10668                 MLXSW_SP_MP_HASH_FIELD_RANGE_SET(inner_fields, INNER_IPV6_DIP8, 8);
10669         }
10670         if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_IP_PROTO)
10671                 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_NEXT_HEADER);
10672         if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_FLOWLABEL)
10673                 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_IPV6_FLOW_LABEL);
10674         /* L4 inner */
10675         MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, TCP_UDP_EN_IPV4);
10676         MLXSW_SP_MP_HASH_HEADER_SET(inner_headers, TCP_UDP_EN_IPV6);
10677         if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_SRC_PORT)
10678                 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_TCP_UDP_SPORT);
10679         if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_DST_PORT)
10680                 MLXSW_SP_MP_HASH_FIELD_SET(inner_fields, INNER_TCP_UDP_DPORT);
10681 }
10682
10683 static void mlxsw_sp_mp4_hash_init(struct mlxsw_sp *mlxsw_sp,
10684                                    struct mlxsw_sp_mp_hash_config *config)
10685 {
10686         struct net *net = mlxsw_sp_net(mlxsw_sp);
10687         unsigned long *headers = config->headers;
10688         unsigned long *fields = config->fields;
10689         u32 hash_fields;
10690
10691         switch (READ_ONCE(net->ipv4.sysctl_fib_multipath_hash_policy)) {
10692         case 0:
10693                 mlxsw_sp_mp4_hash_outer_addr(config);
10694                 break;
10695         case 1:
10696                 mlxsw_sp_mp4_hash_outer_addr(config);
10697                 MLXSW_SP_MP_HASH_HEADER_SET(headers, TCP_UDP_EN_IPV4);
10698                 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV4_PROTOCOL);
10699                 MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_SPORT);
10700                 MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_DPORT);
10701                 break;
10702         case 2:
10703                 /* Outer */
10704                 mlxsw_sp_mp4_hash_outer_addr(config);
10705                 /* Inner */
10706                 mlxsw_sp_mp_hash_inner_l3(config);
10707                 break;
10708         case 3:
10709                 hash_fields = READ_ONCE(net->ipv4.sysctl_fib_multipath_hash_fields);
10710                 /* Outer */
10711                 MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV4_EN_NOT_TCP_NOT_UDP);
10712                 MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV4_EN_TCP_UDP);
10713                 MLXSW_SP_MP_HASH_HEADER_SET(headers, TCP_UDP_EN_IPV4);
10714                 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_SRC_IP)
10715                         MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV4_SIP0, 4);
10716                 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_DST_IP)
10717                         MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV4_DIP0, 4);
10718                 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_IP_PROTO)
10719                         MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV4_PROTOCOL);
10720                 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_SRC_PORT)
10721                         MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_SPORT);
10722                 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_DST_PORT)
10723                         MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_DPORT);
10724                 /* Inner */
10725                 mlxsw_sp_mp_hash_inner_custom(config, hash_fields);
10726                 break;
10727         }
10728 }
10729
10730 static void mlxsw_sp_mp6_hash_outer_addr(struct mlxsw_sp_mp_hash_config *config)
10731 {
10732         unsigned long *headers = config->headers;
10733         unsigned long *fields = config->fields;
10734
10735         MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV6_EN_NOT_TCP_NOT_UDP);
10736         MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV6_EN_TCP_UDP);
10737         MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_SIP0_7);
10738         MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV6_SIP8, 8);
10739         MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_DIP0_7);
10740         MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV6_DIP8, 8);
10741 }
10742
10743 static void mlxsw_sp_mp6_hash_init(struct mlxsw_sp *mlxsw_sp,
10744                                    struct mlxsw_sp_mp_hash_config *config)
10745 {
10746         u32 hash_fields = ip6_multipath_hash_fields(mlxsw_sp_net(mlxsw_sp));
10747         unsigned long *headers = config->headers;
10748         unsigned long *fields = config->fields;
10749
10750         switch (ip6_multipath_hash_policy(mlxsw_sp_net(mlxsw_sp))) {
10751         case 0:
10752                 mlxsw_sp_mp6_hash_outer_addr(config);
10753                 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_NEXT_HEADER);
10754                 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_FLOW_LABEL);
10755                 break;
10756         case 1:
10757                 mlxsw_sp_mp6_hash_outer_addr(config);
10758                 MLXSW_SP_MP_HASH_HEADER_SET(headers, TCP_UDP_EN_IPV6);
10759                 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_NEXT_HEADER);
10760                 MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_SPORT);
10761                 MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_DPORT);
10762                 break;
10763         case 2:
10764                 /* Outer */
10765                 mlxsw_sp_mp6_hash_outer_addr(config);
10766                 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_NEXT_HEADER);
10767                 MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_FLOW_LABEL);
10768                 /* Inner */
10769                 mlxsw_sp_mp_hash_inner_l3(config);
10770                 config->inc_parsing_depth = true;
10771                 break;
10772         case 3:
10773                 /* Outer */
10774                 MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV6_EN_NOT_TCP_NOT_UDP);
10775                 MLXSW_SP_MP_HASH_HEADER_SET(headers, IPV6_EN_TCP_UDP);
10776                 MLXSW_SP_MP_HASH_HEADER_SET(headers, TCP_UDP_EN_IPV6);
10777                 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_SRC_IP) {
10778                         MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_SIP0_7);
10779                         MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV6_SIP8, 8);
10780                 }
10781                 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_DST_IP) {
10782                         MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_DIP0_7);
10783                         MLXSW_SP_MP_HASH_FIELD_RANGE_SET(fields, IPV6_DIP8, 8);
10784                 }
10785                 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_IP_PROTO)
10786                         MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_NEXT_HEADER);
10787                 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_FLOWLABEL)
10788                         MLXSW_SP_MP_HASH_FIELD_SET(fields, IPV6_FLOW_LABEL);
10789                 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_SRC_PORT)
10790                         MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_SPORT);
10791                 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_DST_PORT)
10792                         MLXSW_SP_MP_HASH_FIELD_SET(fields, TCP_UDP_DPORT);
10793                 /* Inner */
10794                 mlxsw_sp_mp_hash_inner_custom(config, hash_fields);
10795                 if (hash_fields & FIB_MULTIPATH_HASH_FIELD_INNER_MASK)
10796                         config->inc_parsing_depth = true;
10797                 break;
10798         }
10799 }
10800
10801 static int mlxsw_sp_mp_hash_parsing_depth_adjust(struct mlxsw_sp *mlxsw_sp,
10802                                                  bool old_inc_parsing_depth,
10803                                                  bool new_inc_parsing_depth)
10804 {
10805         int err;
10806
10807         if (!old_inc_parsing_depth && new_inc_parsing_depth) {
10808                 err = mlxsw_sp_parsing_depth_inc(mlxsw_sp);
10809                 if (err)
10810                         return err;
10811                 mlxsw_sp->router->inc_parsing_depth = true;
10812         } else if (old_inc_parsing_depth && !new_inc_parsing_depth) {
10813                 mlxsw_sp_parsing_depth_dec(mlxsw_sp);
10814                 mlxsw_sp->router->inc_parsing_depth = false;
10815         }
10816
10817         return 0;
10818 }
10819
10820 static int mlxsw_sp_mp_hash_init(struct mlxsw_sp *mlxsw_sp)
10821 {
10822         bool old_inc_parsing_depth, new_inc_parsing_depth;
10823         struct mlxsw_sp_mp_hash_config config = {};
10824         char recr2_pl[MLXSW_REG_RECR2_LEN];
10825         unsigned long bit;
10826         u32 seed;
10827         int err;
10828
10829         seed = jhash(mlxsw_sp->base_mac, sizeof(mlxsw_sp->base_mac), 0);
10830         mlxsw_reg_recr2_pack(recr2_pl, seed);
10831         mlxsw_sp_mp4_hash_init(mlxsw_sp, &config);
10832         mlxsw_sp_mp6_hash_init(mlxsw_sp, &config);
10833
10834         old_inc_parsing_depth = mlxsw_sp->router->inc_parsing_depth;
10835         new_inc_parsing_depth = config.inc_parsing_depth;
10836         err = mlxsw_sp_mp_hash_parsing_depth_adjust(mlxsw_sp,
10837                                                     old_inc_parsing_depth,
10838                                                     new_inc_parsing_depth);
10839         if (err)
10840                 return err;
10841
10842         for_each_set_bit(bit, config.headers, __MLXSW_REG_RECR2_HEADER_CNT)
10843                 mlxsw_reg_recr2_outer_header_enables_set(recr2_pl, bit, 1);
10844         for_each_set_bit(bit, config.fields, __MLXSW_REG_RECR2_FIELD_CNT)
10845                 mlxsw_reg_recr2_outer_header_fields_enable_set(recr2_pl, bit, 1);
10846         for_each_set_bit(bit, config.inner_headers, __MLXSW_REG_RECR2_HEADER_CNT)
10847                 mlxsw_reg_recr2_inner_header_enables_set(recr2_pl, bit, 1);
10848         for_each_set_bit(bit, config.inner_fields, __MLXSW_REG_RECR2_INNER_FIELD_CNT)
10849                 mlxsw_reg_recr2_inner_header_fields_enable_set(recr2_pl, bit, 1);
10850
10851         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(recr2), recr2_pl);
10852         if (err)
10853                 goto err_reg_write;
10854
10855         return 0;
10856
10857 err_reg_write:
10858         mlxsw_sp_mp_hash_parsing_depth_adjust(mlxsw_sp, new_inc_parsing_depth,
10859                                               old_inc_parsing_depth);
10860         return err;
10861 }
10862
10863 static void mlxsw_sp_mp_hash_fini(struct mlxsw_sp *mlxsw_sp)
10864 {
10865         bool old_inc_parsing_depth = mlxsw_sp->router->inc_parsing_depth;
10866
10867         mlxsw_sp_mp_hash_parsing_depth_adjust(mlxsw_sp, old_inc_parsing_depth,
10868                                               false);
10869 }
10870 #else
10871 static int mlxsw_sp_mp_hash_init(struct mlxsw_sp *mlxsw_sp)
10872 {
10873         return 0;
10874 }
10875
10876 static void mlxsw_sp_mp_hash_fini(struct mlxsw_sp *mlxsw_sp)
10877 {
10878 }
10879 #endif
10880
10881 static int mlxsw_sp_dscp_init(struct mlxsw_sp *mlxsw_sp)
10882 {
10883         char rdpm_pl[MLXSW_REG_RDPM_LEN];
10884         unsigned int i;
10885
10886         MLXSW_REG_ZERO(rdpm, rdpm_pl);
10887
10888         /* HW is determining switch priority based on DSCP-bits, but the
10889          * kernel is still doing that based on the ToS. Since there's a
10890          * mismatch in bits we need to make sure to translate the right
10891          * value ToS would observe, skipping the 2 least-significant ECN bits.
10892          */
10893         for (i = 0; i < MLXSW_REG_RDPM_DSCP_ENTRY_REC_MAX_COUNT; i++)
10894                 mlxsw_reg_rdpm_pack(rdpm_pl, i, rt_tos2priority(i << 2));
10895
10896         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rdpm), rdpm_pl);
10897 }
10898
10899 static int __mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp)
10900 {
10901         struct net *net = mlxsw_sp_net(mlxsw_sp);
10902         char rgcr_pl[MLXSW_REG_RGCR_LEN];
10903         u64 max_rifs;
10904         bool usp;
10905
10906         if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_RIFS))
10907                 return -EIO;
10908         max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
10909         usp = READ_ONCE(net->ipv4.sysctl_ip_fwd_update_priority);
10910
10911         mlxsw_reg_rgcr_pack(rgcr_pl, true, true);
10912         mlxsw_reg_rgcr_max_router_interfaces_set(rgcr_pl, max_rifs);
10913         mlxsw_reg_rgcr_usp_set(rgcr_pl, usp);
10914         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
10915 }
10916
10917 static void __mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
10918 {
10919         char rgcr_pl[MLXSW_REG_RGCR_LEN];
10920
10921         mlxsw_reg_rgcr_pack(rgcr_pl, false, false);
10922         mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
10923 }
10924
10925 static int mlxsw_sp_lb_rif_init(struct mlxsw_sp *mlxsw_sp,
10926                                 struct netlink_ext_ack *extack)
10927 {
10928         struct mlxsw_sp_router *router = mlxsw_sp->router;
10929         struct mlxsw_sp_rif *lb_rif;
10930         int err;
10931
10932         router->lb_crif = mlxsw_sp_crif_alloc(NULL);
10933         if (!router->lb_crif)
10934                 return -ENOMEM;
10935
10936         /* Create a generic loopback RIF associated with the main table
10937          * (default VRF). Any table can be used, but the main table exists
10938          * anyway, so we do not waste resources. Loopback RIFs are usually
10939          * created with a NULL CRIF, but this RIF is used as a fallback RIF
10940          * for blackhole nexthops, and nexthops expect to have a valid CRIF.
10941          */
10942         lb_rif = mlxsw_sp_ul_rif_get(mlxsw_sp, RT_TABLE_MAIN, router->lb_crif,
10943                                      extack);
10944         if (IS_ERR(lb_rif)) {
10945                 err = PTR_ERR(lb_rif);
10946                 goto err_ul_rif_get;
10947         }
10948
10949         return 0;
10950
10951 err_ul_rif_get:
10952         mlxsw_sp_crif_free(router->lb_crif);
10953         return err;
10954 }
10955
10956 static void mlxsw_sp_lb_rif_fini(struct mlxsw_sp *mlxsw_sp)
10957 {
10958         mlxsw_sp_ul_rif_put(mlxsw_sp->router->lb_crif->rif);
10959         mlxsw_sp_crif_free(mlxsw_sp->router->lb_crif);
10960 }
10961
10962 static int mlxsw_sp1_router_init(struct mlxsw_sp *mlxsw_sp)
10963 {
10964         size_t size_ranges_count = ARRAY_SIZE(mlxsw_sp1_adj_grp_size_ranges);
10965
10966         mlxsw_sp->router->rif_ops_arr = mlxsw_sp1_rif_ops_arr;
10967         mlxsw_sp->router->adj_grp_size_ranges = mlxsw_sp1_adj_grp_size_ranges;
10968         mlxsw_sp->router->adj_grp_size_ranges_count = size_ranges_count;
10969
10970         return 0;
10971 }
10972
10973 const struct mlxsw_sp_router_ops mlxsw_sp1_router_ops = {
10974         .init = mlxsw_sp1_router_init,
10975         .ipips_init = mlxsw_sp1_ipips_init,
10976 };
10977
10978 static int mlxsw_sp2_router_init(struct mlxsw_sp *mlxsw_sp)
10979 {
10980         size_t size_ranges_count = ARRAY_SIZE(mlxsw_sp2_adj_grp_size_ranges);
10981
10982         mlxsw_sp->router->rif_ops_arr = mlxsw_sp2_rif_ops_arr;
10983         mlxsw_sp->router->adj_grp_size_ranges = mlxsw_sp2_adj_grp_size_ranges;
10984         mlxsw_sp->router->adj_grp_size_ranges_count = size_ranges_count;
10985
10986         return 0;
10987 }
10988
10989 const struct mlxsw_sp_router_ops mlxsw_sp2_router_ops = {
10990         .init = mlxsw_sp2_router_init,
10991         .ipips_init = mlxsw_sp2_ipips_init,
10992 };
10993
10994 int mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp,
10995                          struct netlink_ext_ack *extack)
10996 {
10997         struct mlxsw_sp_router *router;
10998         struct notifier_block *nb;
10999         int err;
11000
11001         router = kzalloc(sizeof(*mlxsw_sp->router), GFP_KERNEL);
11002         if (!router)
11003                 return -ENOMEM;
11004         mutex_init(&router->lock);
11005         mlxsw_sp->router = router;
11006         router->mlxsw_sp = mlxsw_sp;
11007
11008         err = mlxsw_sp->router_ops->init(mlxsw_sp);
11009         if (err)
11010                 goto err_router_ops_init;
11011
11012         INIT_LIST_HEAD(&mlxsw_sp->router->nh_res_grp_list);
11013         INIT_DELAYED_WORK(&mlxsw_sp->router->nh_grp_activity_dw,
11014                           mlxsw_sp_nh_grp_activity_work);
11015         INIT_LIST_HEAD(&mlxsw_sp->router->nexthop_neighs_list);
11016         err = __mlxsw_sp_router_init(mlxsw_sp);
11017         if (err)
11018                 goto err_router_init;
11019
11020         err = mlxsw_sp->router_ops->ipips_init(mlxsw_sp);
11021         if (err)
11022                 goto err_ipips_init;
11023
11024         err = rhashtable_init(&mlxsw_sp->router->crif_ht,
11025                               &mlxsw_sp_crif_ht_params);
11026         if (err)
11027                 goto err_crif_ht_init;
11028
11029         err = mlxsw_sp_rifs_init(mlxsw_sp);
11030         if (err)
11031                 goto err_rifs_init;
11032
11033         err = rhashtable_init(&mlxsw_sp->router->nexthop_ht,
11034                               &mlxsw_sp_nexthop_ht_params);
11035         if (err)
11036                 goto err_nexthop_ht_init;
11037
11038         err = rhashtable_init(&mlxsw_sp->router->nexthop_group_ht,
11039                               &mlxsw_sp_nexthop_group_ht_params);
11040         if (err)
11041                 goto err_nexthop_group_ht_init;
11042
11043         INIT_LIST_HEAD(&mlxsw_sp->router->nexthop_list);
11044         err = mlxsw_sp_lpm_init(mlxsw_sp);
11045         if (err)
11046                 goto err_lpm_init;
11047
11048         err = mlxsw_sp_mr_init(mlxsw_sp, &mlxsw_sp_mr_tcam_ops);
11049         if (err)
11050                 goto err_mr_init;
11051
11052         err = mlxsw_sp_vrs_init(mlxsw_sp);
11053         if (err)
11054                 goto err_vrs_init;
11055
11056         err = mlxsw_sp_lb_rif_init(mlxsw_sp, extack);
11057         if (err)
11058                 goto err_lb_rif_init;
11059
11060         err = mlxsw_sp_neigh_init(mlxsw_sp);
11061         if (err)
11062                 goto err_neigh_init;
11063
11064         err = mlxsw_sp_mp_hash_init(mlxsw_sp);
11065         if (err)
11066                 goto err_mp_hash_init;
11067
11068         err = mlxsw_sp_dscp_init(mlxsw_sp);
11069         if (err)
11070                 goto err_dscp_init;
11071
11072         router->inetaddr_nb.notifier_call = mlxsw_sp_inetaddr_event;
11073         err = register_inetaddr_notifier(&router->inetaddr_nb);
11074         if (err)
11075                 goto err_register_inetaddr_notifier;
11076
11077         router->inet6addr_nb.notifier_call = mlxsw_sp_inet6addr_event;
11078         err = register_inet6addr_notifier(&router->inet6addr_nb);
11079         if (err)
11080                 goto err_register_inet6addr_notifier;
11081
11082         router->inetaddr_valid_nb.notifier_call = mlxsw_sp_inetaddr_valid_event;
11083         err = register_inetaddr_validator_notifier(&router->inetaddr_valid_nb);
11084         if (err)
11085                 goto err_register_inetaddr_valid_notifier;
11086
11087         nb = &router->inet6addr_valid_nb;
11088         nb->notifier_call = mlxsw_sp_inet6addr_valid_event;
11089         err = register_inet6addr_validator_notifier(nb);
11090         if (err)
11091                 goto err_register_inet6addr_valid_notifier;
11092
11093         mlxsw_sp->router->netevent_nb.notifier_call =
11094                 mlxsw_sp_router_netevent_event;
11095         err = register_netevent_notifier(&mlxsw_sp->router->netevent_nb);
11096         if (err)
11097                 goto err_register_netevent_notifier;
11098
11099         mlxsw_sp->router->nexthop_nb.notifier_call =
11100                 mlxsw_sp_nexthop_obj_event;
11101         err = register_nexthop_notifier(mlxsw_sp_net(mlxsw_sp),
11102                                         &mlxsw_sp->router->nexthop_nb,
11103                                         extack);
11104         if (err)
11105                 goto err_register_nexthop_notifier;
11106
11107         mlxsw_sp->router->fib_nb.notifier_call = mlxsw_sp_router_fib_event;
11108         err = register_fib_notifier(mlxsw_sp_net(mlxsw_sp),
11109                                     &mlxsw_sp->router->fib_nb,
11110                                     mlxsw_sp_router_fib_dump_flush, extack);
11111         if (err)
11112                 goto err_register_fib_notifier;
11113
11114         mlxsw_sp->router->netdevice_nb.notifier_call =
11115                 mlxsw_sp_router_netdevice_event;
11116         err = register_netdevice_notifier_net(mlxsw_sp_net(mlxsw_sp),
11117                                               &mlxsw_sp->router->netdevice_nb);
11118         if (err)
11119                 goto err_register_netdev_notifier;
11120
11121         return 0;
11122
11123 err_register_netdev_notifier:
11124         unregister_fib_notifier(mlxsw_sp_net(mlxsw_sp),
11125                                 &mlxsw_sp->router->fib_nb);
11126 err_register_fib_notifier:
11127         unregister_nexthop_notifier(mlxsw_sp_net(mlxsw_sp),
11128                                     &mlxsw_sp->router->nexthop_nb);
11129 err_register_nexthop_notifier:
11130         unregister_netevent_notifier(&mlxsw_sp->router->netevent_nb);
11131 err_register_netevent_notifier:
11132         unregister_inet6addr_validator_notifier(&router->inet6addr_valid_nb);
11133 err_register_inet6addr_valid_notifier:
11134         unregister_inetaddr_validator_notifier(&router->inetaddr_valid_nb);
11135 err_register_inetaddr_valid_notifier:
11136         unregister_inet6addr_notifier(&router->inet6addr_nb);
11137 err_register_inet6addr_notifier:
11138         unregister_inetaddr_notifier(&router->inetaddr_nb);
11139 err_register_inetaddr_notifier:
11140         mlxsw_core_flush_owq();
11141 err_dscp_init:
11142         mlxsw_sp_mp_hash_fini(mlxsw_sp);
11143 err_mp_hash_init:
11144         mlxsw_sp_neigh_fini(mlxsw_sp);
11145 err_neigh_init:
11146         mlxsw_sp_lb_rif_fini(mlxsw_sp);
11147 err_lb_rif_init:
11148         mlxsw_sp_vrs_fini(mlxsw_sp);
11149 err_vrs_init:
11150         mlxsw_sp_mr_fini(mlxsw_sp);
11151 err_mr_init:
11152         mlxsw_sp_lpm_fini(mlxsw_sp);
11153 err_lpm_init:
11154         rhashtable_destroy(&mlxsw_sp->router->nexthop_group_ht);
11155 err_nexthop_group_ht_init:
11156         rhashtable_destroy(&mlxsw_sp->router->nexthop_ht);
11157 err_nexthop_ht_init:
11158         mlxsw_sp_rifs_fini(mlxsw_sp);
11159 err_rifs_init:
11160         rhashtable_destroy(&mlxsw_sp->router->crif_ht);
11161 err_crif_ht_init:
11162         mlxsw_sp_ipips_fini(mlxsw_sp);
11163 err_ipips_init:
11164         __mlxsw_sp_router_fini(mlxsw_sp);
11165 err_router_init:
11166         cancel_delayed_work_sync(&mlxsw_sp->router->nh_grp_activity_dw);
11167 err_router_ops_init:
11168         mutex_destroy(&mlxsw_sp->router->lock);
11169         kfree(mlxsw_sp->router);
11170         return err;
11171 }
11172
11173 void mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
11174 {
11175         struct mlxsw_sp_router *router = mlxsw_sp->router;
11176
11177         unregister_netdevice_notifier_net(mlxsw_sp_net(mlxsw_sp),
11178                                           &router->netdevice_nb);
11179         unregister_fib_notifier(mlxsw_sp_net(mlxsw_sp), &router->fib_nb);
11180         unregister_nexthop_notifier(mlxsw_sp_net(mlxsw_sp),
11181                                     &router->nexthop_nb);
11182         unregister_netevent_notifier(&router->netevent_nb);
11183         unregister_inet6addr_validator_notifier(&router->inet6addr_valid_nb);
11184         unregister_inetaddr_validator_notifier(&router->inetaddr_valid_nb);
11185         unregister_inet6addr_notifier(&router->inet6addr_nb);
11186         unregister_inetaddr_notifier(&router->inetaddr_nb);
11187         mlxsw_core_flush_owq();
11188         mlxsw_sp_mp_hash_fini(mlxsw_sp);
11189         mlxsw_sp_neigh_fini(mlxsw_sp);
11190         mlxsw_sp_lb_rif_fini(mlxsw_sp);
11191         mlxsw_sp_vrs_fini(mlxsw_sp);
11192         mlxsw_sp_mr_fini(mlxsw_sp);
11193         mlxsw_sp_lpm_fini(mlxsw_sp);
11194         rhashtable_destroy(&router->nexthop_group_ht);
11195         rhashtable_destroy(&router->nexthop_ht);
11196         mlxsw_sp_rifs_fini(mlxsw_sp);
11197         rhashtable_destroy(&mlxsw_sp->router->crif_ht);
11198         mlxsw_sp_ipips_fini(mlxsw_sp);
11199         __mlxsw_sp_router_fini(mlxsw_sp);
11200         cancel_delayed_work_sync(&router->nh_grp_activity_dw);
11201         mutex_destroy(&router->lock);
11202         kfree(router);
11203 }