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 <net/netevent.h>
  21 #include <net/neighbour.h>
  22 #include <net/arp.h>
  23 #include <net/ip_fib.h>
  24 #include <net/ip6_fib.h>
  25 #include <net/nexthop.h>
  26 #include <net/fib_rules.h>
  27 #include <net/ip_tunnels.h>
  28 #include <net/l3mdev.h>
  29 #include <net/addrconf.h>
  30 #include <net/ndisc.h>
  31 #include <net/ipv6.h>
  32 #include <net/fib_notifier.h>
  33 #include <net/switchdev.h>
  34
  35 #include "spectrum.h"
  36 #include "core.h"
  37 #include "reg.h"
  38 #include "spectrum_cnt.h"
  39 #include "spectrum_dpipe.h"
  40 #include "spectrum_ipip.h"
  41 #include "spectrum_mr.h"
  42 #include "spectrum_mr_tcam.h"
  43 #include "spectrum_router.h"
  44 #include "spectrum_span.h"
  45
  46 struct mlxsw_sp_fib;
  47 struct mlxsw_sp_vr;
  48 struct mlxsw_sp_lpm_tree;
  49 struct mlxsw_sp_rif_ops;
  50
  51 struct mlxsw_sp_router {
  52         struct mlxsw_sp *mlxsw_sp;
  53         struct mlxsw_sp_rif **rifs;
  54         struct mlxsw_sp_vr *vrs;
  55         struct rhashtable neigh_ht;
  56         struct rhashtable nexthop_group_ht;
  57         struct rhashtable nexthop_ht;
  58         struct list_head nexthop_list;
  59         struct {
  60                 /* One tree for each protocol: IPv4 and IPv6 */
  61                 struct mlxsw_sp_lpm_tree *proto_trees[2];
  62                 struct mlxsw_sp_lpm_tree *trees;
  63                 unsigned int tree_count;
  64         } lpm;
  65         struct {
  66                 struct delayed_work dw;
  67                 unsigned long interval; /* ms */
  68         } neighs_update;
  69         struct delayed_work nexthop_probe_dw;
  70 #define MLXSW_SP_UNRESOLVED_NH_PROBE_INTERVAL 5000 /* ms */
  71         struct list_head nexthop_neighs_list;
  72         struct list_head ipip_list;
  73         bool aborted;
  74         struct notifier_block fib_nb;
  75         struct notifier_block netevent_nb;
  76         struct notifier_block inetaddr_nb;
  77         struct notifier_block inet6addr_nb;
  78         const struct mlxsw_sp_rif_ops **rif_ops_arr;
  79         const struct mlxsw_sp_ipip_ops **ipip_ops_arr;
  80         u32 adj_discard_index;
  81         bool adj_discard_index_valid;
  82 };
  83
  84 struct mlxsw_sp_rif {
  85         struct list_head nexthop_list;
  86         struct list_head neigh_list;
  87         struct net_device *dev; /* NULL for underlay RIF */
  88         struct mlxsw_sp_fid *fid;
  89         unsigned char addr[ETH_ALEN];
  90         int mtu;
  91         u16 rif_index;
  92         u16 vr_id;
  93         const struct mlxsw_sp_rif_ops *ops;
  94         struct mlxsw_sp *mlxsw_sp;
  95
  96         unsigned int counter_ingress;
  97         bool counter_ingress_valid;
  98         unsigned int counter_egress;
  99         bool counter_egress_valid;
 100 };
 101
 102 struct mlxsw_sp_rif_params {
 103         struct net_device *dev;
 104         union {
 105                 u16 system_port;
 106                 u16 lag_id;
 107         };
 108         u16 vid;
 109         bool lag;
 110 };
 111
 112 struct mlxsw_sp_rif_subport {
 113         struct mlxsw_sp_rif common;
 114         refcount_t ref_count;
 115         union {
 116                 u16 system_port;
 117                 u16 lag_id;
 118         };
 119         u16 vid;
 120         bool lag;
 121 };
 122
 123 struct mlxsw_sp_rif_ipip_lb {
 124         struct mlxsw_sp_rif common;
 125         struct mlxsw_sp_rif_ipip_lb_config lb_config;
 126         u16 ul_vr_id; /* Reserved for Spectrum-2. */
 127         u16 ul_rif_id; /* Reserved for Spectrum. */
 128 };
 129
 130 struct mlxsw_sp_rif_params_ipip_lb {
 131         struct mlxsw_sp_rif_params common;
 132         struct mlxsw_sp_rif_ipip_lb_config lb_config;
 133 };
 134
 135 struct mlxsw_sp_rif_ops {
 136         enum mlxsw_sp_rif_type type;
 137         size_t rif_size;
 138
 139         void (*setup)(struct mlxsw_sp_rif *rif,
 140                       const struct mlxsw_sp_rif_params *params);
 141         int (*configure)(struct mlxsw_sp_rif *rif);
 142         void (*deconfigure)(struct mlxsw_sp_rif *rif);
 143         struct mlxsw_sp_fid * (*fid_get)(struct mlxsw_sp_rif *rif,
 144                                          struct netlink_ext_ack *extack);
 145         void (*fdb_del)(struct mlxsw_sp_rif *rif, const char *mac);
 146 };
 147
 148 static void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif);
 149 static void mlxsw_sp_lpm_tree_hold(struct mlxsw_sp_lpm_tree *lpm_tree);
 150 static void mlxsw_sp_lpm_tree_put(struct mlxsw_sp *mlxsw_sp,
 151                                   struct mlxsw_sp_lpm_tree *lpm_tree);
 152 static int mlxsw_sp_vr_lpm_tree_bind(struct mlxsw_sp *mlxsw_sp,
 153                                      const struct mlxsw_sp_fib *fib,
 154                                      u8 tree_id);
 155 static int mlxsw_sp_vr_lpm_tree_unbind(struct mlxsw_sp *mlxsw_sp,
 156                                        const struct mlxsw_sp_fib *fib);
 157
 158 static unsigned int *
 159 mlxsw_sp_rif_p_counter_get(struct mlxsw_sp_rif *rif,
 160                            enum mlxsw_sp_rif_counter_dir dir)
 161 {
 162         switch (dir) {
 163         case MLXSW_SP_RIF_COUNTER_EGRESS:
 164                 return &rif->counter_egress;
 165         case MLXSW_SP_RIF_COUNTER_INGRESS:
 166                 return &rif->counter_ingress;
 167         }
 168         return NULL;
 169 }
 170
 171 static bool
 172 mlxsw_sp_rif_counter_valid_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_valid;
 178         case MLXSW_SP_RIF_COUNTER_INGRESS:
 179                 return rif->counter_ingress_valid;
 180         }
 181         return false;
 182 }
 183
 184 static void
 185 mlxsw_sp_rif_counter_valid_set(struct mlxsw_sp_rif *rif,
 186                                enum mlxsw_sp_rif_counter_dir dir,
 187                                bool valid)
 188 {
 189         switch (dir) {
 190         case MLXSW_SP_RIF_COUNTER_EGRESS:
 191                 rif->counter_egress_valid = valid;
 192                 break;
 193         case MLXSW_SP_RIF_COUNTER_INGRESS:
 194                 rif->counter_ingress_valid = valid;
 195                 break;
 196         }
 197 }
 198
 199 static int mlxsw_sp_rif_counter_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
 200                                      unsigned int counter_index, bool enable,
 201                                      enum mlxsw_sp_rif_counter_dir dir)
 202 {
 203         char ritr_pl[MLXSW_REG_RITR_LEN];
 204         bool is_egress = false;
 205         int err;
 206
 207         if (dir == MLXSW_SP_RIF_COUNTER_EGRESS)
 208                 is_egress = true;
 209         mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
 210         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
 211         if (err)
 212                 return err;
 213
 214         mlxsw_reg_ritr_counter_pack(ritr_pl, counter_index, enable,
 215                                     is_egress);
 216         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
 217 }
 218
 219 int mlxsw_sp_rif_counter_value_get(struct mlxsw_sp *mlxsw_sp,
 220                                    struct mlxsw_sp_rif *rif,
 221                                    enum mlxsw_sp_rif_counter_dir dir, u64 *cnt)
 222 {
 223         char ricnt_pl[MLXSW_REG_RICNT_LEN];
 224         unsigned int *p_counter_index;
 225         bool valid;
 226         int err;
 227
 228         valid = mlxsw_sp_rif_counter_valid_get(rif, dir);
 229         if (!valid)
 230                 return -EINVAL;
 231
 232         p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
 233         if (!p_counter_index)
 234                 return -EINVAL;
 235         mlxsw_reg_ricnt_pack(ricnt_pl, *p_counter_index,
 236                              MLXSW_REG_RICNT_OPCODE_NOP);
 237         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
 238         if (err)
 239                 return err;
 240         *cnt = mlxsw_reg_ricnt_good_unicast_packets_get(ricnt_pl);
 241         return 0;
 242 }
 243
 244 static int mlxsw_sp_rif_counter_clear(struct mlxsw_sp *mlxsw_sp,
 245                                       unsigned int counter_index)
 246 {
 247         char ricnt_pl[MLXSW_REG_RICNT_LEN];
 248
 249         mlxsw_reg_ricnt_pack(ricnt_pl, counter_index,
 250                              MLXSW_REG_RICNT_OPCODE_CLEAR);
 251         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
 252 }
 253
 254 int mlxsw_sp_rif_counter_alloc(struct mlxsw_sp *mlxsw_sp,
 255                                struct mlxsw_sp_rif *rif,
 256                                enum mlxsw_sp_rif_counter_dir dir)
 257 {
 258         unsigned int *p_counter_index;
 259         int err;
 260
 261         p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
 262         if (!p_counter_index)
 263                 return -EINVAL;
 264         err = mlxsw_sp_counter_alloc(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
 265                                      p_counter_index);
 266         if (err)
 267                 return err;
 268
 269         err = mlxsw_sp_rif_counter_clear(mlxsw_sp, *p_counter_index);
 270         if (err)
 271                 goto err_counter_clear;
 272
 273         err = mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
 274                                         *p_counter_index, true, dir);
 275         if (err)
 276                 goto err_counter_edit;
 277         mlxsw_sp_rif_counter_valid_set(rif, dir, true);
 278         return 0;
 279
 280 err_counter_edit:
 281 err_counter_clear:
 282         mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
 283                               *p_counter_index);
 284         return err;
 285 }
 286
 287 void mlxsw_sp_rif_counter_free(struct mlxsw_sp *mlxsw_sp,
 288                                struct mlxsw_sp_rif *rif,
 289                                enum mlxsw_sp_rif_counter_dir dir)
 290 {
 291         unsigned int *p_counter_index;
 292
 293         if (!mlxsw_sp_rif_counter_valid_get(rif, dir))
 294                 return;
 295
 296         p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
 297         if (WARN_ON(!p_counter_index))
 298                 return;
 299         mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
 300                                   *p_counter_index, false, dir);
 301         mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
 302                               *p_counter_index);
 303         mlxsw_sp_rif_counter_valid_set(rif, dir, false);
 304 }
 305
 306 static void mlxsw_sp_rif_counters_alloc(struct mlxsw_sp_rif *rif)
 307 {
 308         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
 309         struct devlink *devlink;
 310
 311         devlink = priv_to_devlink(mlxsw_sp->core);
 312         if (!devlink_dpipe_table_counter_enabled(devlink,
 313                                                  MLXSW_SP_DPIPE_TABLE_NAME_ERIF))
 314                 return;
 315         mlxsw_sp_rif_counter_alloc(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS);
 316 }
 317
 318 static void mlxsw_sp_rif_counters_free(struct mlxsw_sp_rif *rif)
 319 {
 320         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
 321
 322         mlxsw_sp_rif_counter_free(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS);
 323 }
 324
 325 #define MLXSW_SP_PREFIX_COUNT (sizeof(struct in6_addr) * BITS_PER_BYTE + 1)
 326
 327 struct mlxsw_sp_prefix_usage {
 328         DECLARE_BITMAP(b, MLXSW_SP_PREFIX_COUNT);
 329 };
 330
 331 #define mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) \
 332         for_each_set_bit(prefix, (prefix_usage)->b, MLXSW_SP_PREFIX_COUNT)
 333
 334 static bool
 335 mlxsw_sp_prefix_usage_eq(struct mlxsw_sp_prefix_usage *prefix_usage1,
 336                          struct mlxsw_sp_prefix_usage *prefix_usage2)
 337 {
 338         return !memcmp(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
 339 }
 340
 341 static void
 342 mlxsw_sp_prefix_usage_cpy(struct mlxsw_sp_prefix_usage *prefix_usage1,
 343                           struct mlxsw_sp_prefix_usage *prefix_usage2)
 344 {
 345         memcpy(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
 346 }
 347
 348 static void
 349 mlxsw_sp_prefix_usage_set(struct mlxsw_sp_prefix_usage *prefix_usage,
 350                           unsigned char prefix_len)
 351 {
 352         set_bit(prefix_len, prefix_usage->b);
 353 }
 354
 355 static void
 356 mlxsw_sp_prefix_usage_clear(struct mlxsw_sp_prefix_usage *prefix_usage,
 357                             unsigned char prefix_len)
 358 {
 359         clear_bit(prefix_len, prefix_usage->b);
 360 }
 361
 362 struct mlxsw_sp_fib_key {
 363         unsigned char addr[sizeof(struct in6_addr)];
 364         unsigned char prefix_len;
 365 };
 366
 367 enum mlxsw_sp_fib_entry_type {
 368         MLXSW_SP_FIB_ENTRY_TYPE_REMOTE,
 369         MLXSW_SP_FIB_ENTRY_TYPE_LOCAL,
 370         MLXSW_SP_FIB_ENTRY_TYPE_TRAP,
 371         MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE,
 372         MLXSW_SP_FIB_ENTRY_TYPE_UNREACHABLE,
 373
 374         /* This is a special case of local delivery, where a packet should be
 375          * decapsulated on reception. Note that there is no corresponding ENCAP,
 376          * because that's a type of next hop, not of FIB entry. (There can be
 377          * several next hops in a REMOTE entry, and some of them may be
 378          * encapsulating entries.)
 379          */
 380         MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP,
 381         MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP,
 382 };
 383
 384 struct mlxsw_sp_nexthop_group;
 385
 386 struct mlxsw_sp_fib_node {
 387         struct list_head entry_list;
 388         struct list_head list;
 389         struct rhash_head ht_node;
 390         struct mlxsw_sp_fib *fib;
 391         struct mlxsw_sp_fib_key key;
 392 };
 393
 394 struct mlxsw_sp_fib_entry_decap {
 395         struct mlxsw_sp_ipip_entry *ipip_entry;
 396         u32 tunnel_index;
 397 };
 398
 399 struct mlxsw_sp_fib_entry {
 400         struct list_head list;
 401         struct mlxsw_sp_fib_node *fib_node;
 402         enum mlxsw_sp_fib_entry_type type;
 403         struct list_head nexthop_group_node;
 404         struct mlxsw_sp_nexthop_group *nh_group;
 405         struct mlxsw_sp_fib_entry_decap decap; /* Valid for decap entries. */
 406 };
 407
 408 struct mlxsw_sp_fib4_entry {
 409         struct mlxsw_sp_fib_entry common;
 410         u32 tb_id;
 411         u32 prio;
 412         u8 tos;
 413         u8 type;
 414 };
 415
 416 struct mlxsw_sp_fib6_entry {
 417         struct mlxsw_sp_fib_entry common;
 418         struct list_head rt6_list;
 419         unsigned int nrt6;
 420 };
 421
 422 struct mlxsw_sp_rt6 {
 423         struct list_head list;
 424         struct fib6_info *rt;
 425 };
 426
 427 struct mlxsw_sp_lpm_tree {
 428         u8 id; /* tree ID */
 429         unsigned int ref_count;
 430         enum mlxsw_sp_l3proto proto;
 431         unsigned long prefix_ref_count[MLXSW_SP_PREFIX_COUNT];
 432         struct mlxsw_sp_prefix_usage prefix_usage;
 433 };
 434
 435 struct mlxsw_sp_fib {
 436         struct rhashtable ht;
 437         struct list_head node_list;
 438         struct mlxsw_sp_vr *vr;
 439         struct mlxsw_sp_lpm_tree *lpm_tree;
 440         enum mlxsw_sp_l3proto proto;
 441 };
 442
 443 struct mlxsw_sp_vr {
 444         u16 id; /* virtual router ID */
 445         u32 tb_id; /* kernel fib table id */
 446         unsigned int rif_count;
 447         struct mlxsw_sp_fib *fib4;
 448         struct mlxsw_sp_fib *fib6;
 449         struct mlxsw_sp_mr_table *mr_table[MLXSW_SP_L3_PROTO_MAX];
 450         struct mlxsw_sp_rif *ul_rif;
 451         refcount_t ul_rif_refcnt;
 452 };
 453
 454 static const struct rhashtable_params mlxsw_sp_fib_ht_params;
 455
 456 static struct mlxsw_sp_fib *mlxsw_sp_fib_create(struct mlxsw_sp *mlxsw_sp,
 457                                                 struct mlxsw_sp_vr *vr,
 458                                                 enum mlxsw_sp_l3proto proto)
 459 {
 460         struct mlxsw_sp_lpm_tree *lpm_tree;
 461         struct mlxsw_sp_fib *fib;
 462         int err;
 463
 464         lpm_tree = mlxsw_sp->router->lpm.proto_trees[proto];
 465         fib = kzalloc(sizeof(*fib), GFP_KERNEL);
 466         if (!fib)
 467                 return ERR_PTR(-ENOMEM);
 468         err = rhashtable_init(&fib->ht, &mlxsw_sp_fib_ht_params);
 469         if (err)
 470                 goto err_rhashtable_init;
 471         INIT_LIST_HEAD(&fib->node_list);
 472         fib->proto = proto;
 473         fib->vr = vr;
 474         fib->lpm_tree = lpm_tree;
 475         mlxsw_sp_lpm_tree_hold(lpm_tree);
 476         err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, lpm_tree->id);
 477         if (err)
 478                 goto err_lpm_tree_bind;
 479         return fib;
 480
 481 err_lpm_tree_bind:
 482         mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
 483 err_rhashtable_init:
 484         kfree(fib);
 485         return ERR_PTR(err);
 486 }
 487
 488 static void mlxsw_sp_fib_destroy(struct mlxsw_sp *mlxsw_sp,
 489                                  struct mlxsw_sp_fib *fib)
 490 {
 491         mlxsw_sp_vr_lpm_tree_unbind(mlxsw_sp, fib);
 492         mlxsw_sp_lpm_tree_put(mlxsw_sp, fib->lpm_tree);
 493         WARN_ON(!list_empty(&fib->node_list));
 494         rhashtable_destroy(&fib->ht);
 495         kfree(fib);
 496 }
 497
 498 static struct mlxsw_sp_lpm_tree *
 499 mlxsw_sp_lpm_tree_find_unused(struct mlxsw_sp *mlxsw_sp)
 500 {
 501         static struct mlxsw_sp_lpm_tree *lpm_tree;
 502         int i;
 503
 504         for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
 505                 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
 506                 if (lpm_tree->ref_count == 0)
 507                         return lpm_tree;
 508         }
 509         return NULL;
 510 }
 511
 512 static int mlxsw_sp_lpm_tree_alloc(struct mlxsw_sp *mlxsw_sp,
 513                                    struct mlxsw_sp_lpm_tree *lpm_tree)
 514 {
 515         char ralta_pl[MLXSW_REG_RALTA_LEN];
 516
 517         mlxsw_reg_ralta_pack(ralta_pl, true,
 518                              (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
 519                              lpm_tree->id);
 520         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
 521 }
 522
 523 static void mlxsw_sp_lpm_tree_free(struct mlxsw_sp *mlxsw_sp,
 524                                    struct mlxsw_sp_lpm_tree *lpm_tree)
 525 {
 526         char ralta_pl[MLXSW_REG_RALTA_LEN];
 527
 528         mlxsw_reg_ralta_pack(ralta_pl, false,
 529                              (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
 530                              lpm_tree->id);
 531         mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
 532 }
 533
 534 static int
 535 mlxsw_sp_lpm_tree_left_struct_set(struct mlxsw_sp *mlxsw_sp,
 536                                   struct mlxsw_sp_prefix_usage *prefix_usage,
 537                                   struct mlxsw_sp_lpm_tree *lpm_tree)
 538 {
 539         char ralst_pl[MLXSW_REG_RALST_LEN];
 540         u8 root_bin = 0;
 541         u8 prefix;
 542         u8 last_prefix = MLXSW_REG_RALST_BIN_NO_CHILD;
 543
 544         mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage)
 545                 root_bin = prefix;
 546
 547         mlxsw_reg_ralst_pack(ralst_pl, root_bin, lpm_tree->id);
 548         mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) {
 549                 if (prefix == 0)
 550                         continue;
 551                 mlxsw_reg_ralst_bin_pack(ralst_pl, prefix, last_prefix,
 552                                          MLXSW_REG_RALST_BIN_NO_CHILD);
 553                 last_prefix = prefix;
 554         }
 555         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralst), ralst_pl);
 556 }
 557
 558 static struct mlxsw_sp_lpm_tree *
 559 mlxsw_sp_lpm_tree_create(struct mlxsw_sp *mlxsw_sp,
 560                          struct mlxsw_sp_prefix_usage *prefix_usage,
 561                          enum mlxsw_sp_l3proto proto)
 562 {
 563         struct mlxsw_sp_lpm_tree *lpm_tree;
 564         int err;
 565
 566         lpm_tree = mlxsw_sp_lpm_tree_find_unused(mlxsw_sp);
 567         if (!lpm_tree)
 568                 return ERR_PTR(-EBUSY);
 569         lpm_tree->proto = proto;
 570         err = mlxsw_sp_lpm_tree_alloc(mlxsw_sp, lpm_tree);
 571         if (err)
 572                 return ERR_PTR(err);
 573
 574         err = mlxsw_sp_lpm_tree_left_struct_set(mlxsw_sp, prefix_usage,
 575                                                 lpm_tree);
 576         if (err)
 577                 goto err_left_struct_set;
 578         memcpy(&lpm_tree->prefix_usage, prefix_usage,
 579                sizeof(lpm_tree->prefix_usage));
 580         memset(&lpm_tree->prefix_ref_count, 0,
 581                sizeof(lpm_tree->prefix_ref_count));
 582         lpm_tree->ref_count = 1;
 583         return lpm_tree;
 584
 585 err_left_struct_set:
 586         mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
 587         return ERR_PTR(err);
 588 }
 589
 590 static void mlxsw_sp_lpm_tree_destroy(struct mlxsw_sp *mlxsw_sp,
 591                                       struct mlxsw_sp_lpm_tree *lpm_tree)
 592 {
 593         mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
 594 }
 595
 596 static struct mlxsw_sp_lpm_tree *
 597 mlxsw_sp_lpm_tree_get(struct mlxsw_sp *mlxsw_sp,
 598                       struct mlxsw_sp_prefix_usage *prefix_usage,
 599                       enum mlxsw_sp_l3proto proto)
 600 {
 601         struct mlxsw_sp_lpm_tree *lpm_tree;
 602         int i;
 603
 604         for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
 605                 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
 606                 if (lpm_tree->ref_count != 0 &&
 607                     lpm_tree->proto == proto &&
 608                     mlxsw_sp_prefix_usage_eq(&lpm_tree->prefix_usage,
 609                                              prefix_usage)) {
 610                         mlxsw_sp_lpm_tree_hold(lpm_tree);
 611                         return lpm_tree;
 612                 }
 613         }
 614         return mlxsw_sp_lpm_tree_create(mlxsw_sp, prefix_usage, proto);
 615 }
 616
 617 static void mlxsw_sp_lpm_tree_hold(struct mlxsw_sp_lpm_tree *lpm_tree)
 618 {
 619         lpm_tree->ref_count++;
 620 }
 621
 622 static void mlxsw_sp_lpm_tree_put(struct mlxsw_sp *mlxsw_sp,
 623                                   struct mlxsw_sp_lpm_tree *lpm_tree)
 624 {
 625         if (--lpm_tree->ref_count == 0)
 626                 mlxsw_sp_lpm_tree_destroy(mlxsw_sp, lpm_tree);
 627 }
 628
 629 #define MLXSW_SP_LPM_TREE_MIN 1 /* tree 0 is reserved */
 630
 631 static int mlxsw_sp_lpm_init(struct mlxsw_sp *mlxsw_sp)
 632 {
 633         struct mlxsw_sp_prefix_usage req_prefix_usage = {{ 0 } };
 634         struct mlxsw_sp_lpm_tree *lpm_tree;
 635         u64 max_trees;
 636         int err, i;
 637
 638         if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_LPM_TREES))
 639                 return -EIO;
 640
 641         max_trees = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_LPM_TREES);
 642         mlxsw_sp->router->lpm.tree_count = max_trees - MLXSW_SP_LPM_TREE_MIN;
 643         mlxsw_sp->router->lpm.trees = kcalloc(mlxsw_sp->router->lpm.tree_count,
 644                                              sizeof(struct mlxsw_sp_lpm_tree),
 645                                              GFP_KERNEL);
 646         if (!mlxsw_sp->router->lpm.trees)
 647                 return -ENOMEM;
 648
 649         for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
 650                 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
 651                 lpm_tree->id = i + MLXSW_SP_LPM_TREE_MIN;
 652         }
 653
 654         lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
 655                                          MLXSW_SP_L3_PROTO_IPV4);
 656         if (IS_ERR(lpm_tree)) {
 657                 err = PTR_ERR(lpm_tree);
 658                 goto err_ipv4_tree_get;
 659         }
 660         mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV4] = lpm_tree;
 661
 662         lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
 663                                          MLXSW_SP_L3_PROTO_IPV6);
 664         if (IS_ERR(lpm_tree)) {
 665                 err = PTR_ERR(lpm_tree);
 666                 goto err_ipv6_tree_get;
 667         }
 668         mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV6] = lpm_tree;
 669
 670         return 0;
 671
 672 err_ipv6_tree_get:
 673         lpm_tree = mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV4];
 674         mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
 675 err_ipv4_tree_get:
 676         kfree(mlxsw_sp->router->lpm.trees);
 677         return err;
 678 }
 679
 680 static void mlxsw_sp_lpm_fini(struct mlxsw_sp *mlxsw_sp)
 681 {
 682         struct mlxsw_sp_lpm_tree *lpm_tree;
 683
 684         lpm_tree = mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV6];
 685         mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
 686
 687         lpm_tree = mlxsw_sp->router->lpm.proto_trees[MLXSW_SP_L3_PROTO_IPV4];
 688         mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
 689
 690         kfree(mlxsw_sp->router->lpm.trees);
 691 }
 692
 693 static bool mlxsw_sp_vr_is_used(const struct mlxsw_sp_vr *vr)
 694 {
 695         return !!vr->fib4 || !!vr->fib6 ||
 696                !!vr->mr_table[MLXSW_SP_L3_PROTO_IPV4] ||
 697                !!vr->mr_table[MLXSW_SP_L3_PROTO_IPV6];
 698 }
 699
 700 static struct mlxsw_sp_vr *mlxsw_sp_vr_find_unused(struct mlxsw_sp *mlxsw_sp)
 701 {
 702         struct mlxsw_sp_vr *vr;
 703         int i;
 704
 705         for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
 706                 vr = &mlxsw_sp->router->vrs[i];
 707                 if (!mlxsw_sp_vr_is_used(vr))
 708                         return vr;
 709         }
 710         return NULL;
 711 }
 712
 713 static int mlxsw_sp_vr_lpm_tree_bind(struct mlxsw_sp *mlxsw_sp,
 714                                      const struct mlxsw_sp_fib *fib, u8 tree_id)
 715 {
 716         char raltb_pl[MLXSW_REG_RALTB_LEN];
 717
 718         mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
 719                              (enum mlxsw_reg_ralxx_protocol) fib->proto,
 720                              tree_id);
 721         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
 722 }
 723
 724 static int mlxsw_sp_vr_lpm_tree_unbind(struct mlxsw_sp *mlxsw_sp,
 725                                        const struct mlxsw_sp_fib *fib)
 726 {
 727         char raltb_pl[MLXSW_REG_RALTB_LEN];
 728
 729         /* Bind to tree 0 which is default */
 730         mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
 731                              (enum mlxsw_reg_ralxx_protocol) fib->proto, 0);
 732         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
 733 }
 734
 735 static u32 mlxsw_sp_fix_tb_id(u32 tb_id)
 736 {
 737         /* For our purpose, squash main, default and local tables into one */
 738         if (tb_id == RT_TABLE_LOCAL || tb_id == RT_TABLE_DEFAULT)
 739                 tb_id = RT_TABLE_MAIN;
 740         return tb_id;
 741 }
 742
 743 static struct mlxsw_sp_vr *mlxsw_sp_vr_find(struct mlxsw_sp *mlxsw_sp,
 744                                             u32 tb_id)
 745 {
 746         struct mlxsw_sp_vr *vr;
 747         int i;
 748
 749         tb_id = mlxsw_sp_fix_tb_id(tb_id);
 750
 751         for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
 752                 vr = &mlxsw_sp->router->vrs[i];
 753                 if (mlxsw_sp_vr_is_used(vr) && vr->tb_id == tb_id)
 754                         return vr;
 755         }
 756         return NULL;
 757 }
 758
 759 int mlxsw_sp_router_tb_id_vr_id(struct mlxsw_sp *mlxsw_sp, u32 tb_id,
 760                                 u16 *vr_id)
 761 {
 762         struct mlxsw_sp_vr *vr;
 763
 764         vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id);
 765         if (!vr)
 766                 return -ESRCH;
 767         *vr_id = vr->id;
 768
 769         return 0;
 770 }
 771
 772 static struct mlxsw_sp_fib *mlxsw_sp_vr_fib(const struct mlxsw_sp_vr *vr,
 773                                             enum mlxsw_sp_l3proto proto)
 774 {
 775         switch (proto) {
 776         case MLXSW_SP_L3_PROTO_IPV4:
 777                 return vr->fib4;
 778         case MLXSW_SP_L3_PROTO_IPV6:
 779                 return vr->fib6;
 780         }
 781         return NULL;
 782 }
 783
 784 static struct mlxsw_sp_vr *mlxsw_sp_vr_create(struct mlxsw_sp *mlxsw_sp,
 785                                               u32 tb_id,
 786                                               struct netlink_ext_ack *extack)
 787 {
 788         struct mlxsw_sp_mr_table *mr4_table, *mr6_table;
 789         struct mlxsw_sp_fib *fib4;
 790         struct mlxsw_sp_fib *fib6;
 791         struct mlxsw_sp_vr *vr;
 792         int err;
 793
 794         vr = mlxsw_sp_vr_find_unused(mlxsw_sp);
 795         if (!vr) {
 796                 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported virtual routers");
 797                 return ERR_PTR(-EBUSY);
 798         }
 799         fib4 = mlxsw_sp_fib_create(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV4);
 800         if (IS_ERR(fib4))
 801                 return ERR_CAST(fib4);
 802         fib6 = mlxsw_sp_fib_create(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV6);
 803         if (IS_ERR(fib6)) {
 804                 err = PTR_ERR(fib6);
 805                 goto err_fib6_create;
 806         }
 807         mr4_table = mlxsw_sp_mr_table_create(mlxsw_sp, vr->id,
 808                                              MLXSW_SP_L3_PROTO_IPV4);
 809         if (IS_ERR(mr4_table)) {
 810                 err = PTR_ERR(mr4_table);
 811                 goto err_mr4_table_create;
 812         }
 813         mr6_table = mlxsw_sp_mr_table_create(mlxsw_sp, vr->id,
 814                                              MLXSW_SP_L3_PROTO_IPV6);
 815         if (IS_ERR(mr6_table)) {
 816                 err = PTR_ERR(mr6_table);
 817                 goto err_mr6_table_create;
 818         }
 819
 820         vr->fib4 = fib4;
 821         vr->fib6 = fib6;
 822         vr->mr_table[MLXSW_SP_L3_PROTO_IPV4] = mr4_table;
 823         vr->mr_table[MLXSW_SP_L3_PROTO_IPV6] = mr6_table;
 824         vr->tb_id = tb_id;
 825         return vr;
 826
 827 err_mr6_table_create:
 828         mlxsw_sp_mr_table_destroy(mr4_table);
 829 err_mr4_table_create:
 830         mlxsw_sp_fib_destroy(mlxsw_sp, fib6);
 831 err_fib6_create:
 832         mlxsw_sp_fib_destroy(mlxsw_sp, fib4);
 833         return ERR_PTR(err);
 834 }
 835
 836 static void mlxsw_sp_vr_destroy(struct mlxsw_sp *mlxsw_sp,
 837                                 struct mlxsw_sp_vr *vr)
 838 {
 839         mlxsw_sp_mr_table_destroy(vr->mr_table[MLXSW_SP_L3_PROTO_IPV6]);
 840         vr->mr_table[MLXSW_SP_L3_PROTO_IPV6] = NULL;
 841         mlxsw_sp_mr_table_destroy(vr->mr_table[MLXSW_SP_L3_PROTO_IPV4]);
 842         vr->mr_table[MLXSW_SP_L3_PROTO_IPV4] = NULL;
 843         mlxsw_sp_fib_destroy(mlxsw_sp, vr->fib6);
 844         vr->fib6 = NULL;
 845         mlxsw_sp_fib_destroy(mlxsw_sp, vr->fib4);
 846         vr->fib4 = NULL;
 847 }
 848
 849 static struct mlxsw_sp_vr *mlxsw_sp_vr_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id,
 850                                            struct netlink_ext_ack *extack)
 851 {
 852         struct mlxsw_sp_vr *vr;
 853
 854         tb_id = mlxsw_sp_fix_tb_id(tb_id);
 855         vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id);
 856         if (!vr)
 857                 vr = mlxsw_sp_vr_create(mlxsw_sp, tb_id, extack);
 858         return vr;
 859 }
 860
 861 static void mlxsw_sp_vr_put(struct mlxsw_sp *mlxsw_sp, struct mlxsw_sp_vr *vr)
 862 {
 863         if (!vr->rif_count && list_empty(&vr->fib4->node_list) &&
 864             list_empty(&vr->fib6->node_list) &&
 865             mlxsw_sp_mr_table_empty(vr->mr_table[MLXSW_SP_L3_PROTO_IPV4]) &&
 866             mlxsw_sp_mr_table_empty(vr->mr_table[MLXSW_SP_L3_PROTO_IPV6]))
 867                 mlxsw_sp_vr_destroy(mlxsw_sp, vr);
 868 }
 869
 870 static bool
 871 mlxsw_sp_vr_lpm_tree_should_replace(struct mlxsw_sp_vr *vr,
 872                                     enum mlxsw_sp_l3proto proto, u8 tree_id)
 873 {
 874         struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
 875
 876         if (!mlxsw_sp_vr_is_used(vr))
 877                 return false;
 878         if (fib->lpm_tree->id == tree_id)
 879                 return true;
 880         return false;
 881 }
 882
 883 static int mlxsw_sp_vr_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp,
 884                                         struct mlxsw_sp_fib *fib,
 885                                         struct mlxsw_sp_lpm_tree *new_tree)
 886 {
 887         struct mlxsw_sp_lpm_tree *old_tree = fib->lpm_tree;
 888         int err;
 889
 890         fib->lpm_tree = new_tree;
 891         mlxsw_sp_lpm_tree_hold(new_tree);
 892         err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, new_tree->id);
 893         if (err)
 894                 goto err_tree_bind;
 895         mlxsw_sp_lpm_tree_put(mlxsw_sp, old_tree);
 896         return 0;
 897
 898 err_tree_bind:
 899         mlxsw_sp_lpm_tree_put(mlxsw_sp, new_tree);
 900         fib->lpm_tree = old_tree;
 901         return err;
 902 }
 903
 904 static int mlxsw_sp_vrs_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp,
 905                                          struct mlxsw_sp_fib *fib,
 906                                          struct mlxsw_sp_lpm_tree *new_tree)
 907 {
 908         enum mlxsw_sp_l3proto proto = fib->proto;
 909         struct mlxsw_sp_lpm_tree *old_tree;
 910         u8 old_id, new_id = new_tree->id;
 911         struct mlxsw_sp_vr *vr;
 912         int i, err;
 913
 914         old_tree = mlxsw_sp->router->lpm.proto_trees[proto];
 915         old_id = old_tree->id;
 916
 917         for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
 918                 vr = &mlxsw_sp->router->vrs[i];
 919                 if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, old_id))
 920                         continue;
 921                 err = mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp,
 922                                                    mlxsw_sp_vr_fib(vr, proto),
 923                                                    new_tree);
 924                 if (err)
 925                         goto err_tree_replace;
 926         }
 927
 928         memcpy(new_tree->prefix_ref_count, old_tree->prefix_ref_count,
 929                sizeof(new_tree->prefix_ref_count));
 930         mlxsw_sp->router->lpm.proto_trees[proto] = new_tree;
 931         mlxsw_sp_lpm_tree_put(mlxsw_sp, old_tree);
 932
 933         return 0;
 934
 935 err_tree_replace:
 936         for (i--; i >= 0; i--) {
 937                 if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, new_id))
 938                         continue;
 939                 mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp,
 940                                              mlxsw_sp_vr_fib(vr, proto),
 941                                              old_tree);
 942         }
 943         return err;
 944 }
 945
 946 static int mlxsw_sp_vrs_init(struct mlxsw_sp *mlxsw_sp)
 947 {
 948         struct mlxsw_sp_vr *vr;
 949         u64 max_vrs;
 950         int i;
 951
 952         if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_VRS))
 953                 return -EIO;
 954
 955         max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
 956         mlxsw_sp->router->vrs = kcalloc(max_vrs, sizeof(struct mlxsw_sp_vr),
 957                                         GFP_KERNEL);
 958         if (!mlxsw_sp->router->vrs)
 959                 return -ENOMEM;
 960
 961         for (i = 0; i < max_vrs; i++) {
 962                 vr = &mlxsw_sp->router->vrs[i];
 963                 vr->id = i;
 964         }
 965
 966         return 0;
 967 }
 968
 969 static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp);
 970
 971 static void mlxsw_sp_vrs_fini(struct mlxsw_sp *mlxsw_sp)
 972 {
 973         /* At this stage we're guaranteed not to have new incoming
 974          * FIB notifications and the work queue is free from FIBs
 975          * sitting on top of mlxsw netdevs. However, we can still
 976          * have other FIBs queued. Flush the queue before flushing
 977          * the device's tables. No need for locks, as we're the only
 978          * writer.
 979          */
 980         mlxsw_core_flush_owq();
 981         mlxsw_sp_router_fib_flush(mlxsw_sp);
 982         kfree(mlxsw_sp->router->vrs);
 983 }
 984
 985 static struct net_device *
 986 __mlxsw_sp_ipip_netdev_ul_dev_get(const struct net_device *ol_dev)
 987 {
 988         struct ip_tunnel *tun = netdev_priv(ol_dev);
 989         struct net *net = dev_net(ol_dev);
 990
 991         return __dev_get_by_index(net, tun->parms.link);
 992 }
 993
 994 u32 mlxsw_sp_ipip_dev_ul_tb_id(const struct net_device *ol_dev)
 995 {
 996         struct net_device *d = __mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev);
 997
 998         if (d)
 999                 return l3mdev_fib_table(d) ? : RT_TABLE_MAIN;
1000         else
1001                 return RT_TABLE_MAIN;
1002 }
1003
1004 static struct mlxsw_sp_rif *
1005 mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp,
1006                     const struct mlxsw_sp_rif_params *params,
1007                     struct netlink_ext_ack *extack);
1008
1009 static struct mlxsw_sp_rif_ipip_lb *
1010 mlxsw_sp_ipip_ol_ipip_lb_create(struct mlxsw_sp *mlxsw_sp,
1011                                 enum mlxsw_sp_ipip_type ipipt,
1012                                 struct net_device *ol_dev,
1013                                 struct netlink_ext_ack *extack)
1014 {
1015         struct mlxsw_sp_rif_params_ipip_lb lb_params;
1016         const struct mlxsw_sp_ipip_ops *ipip_ops;
1017         struct mlxsw_sp_rif *rif;
1018
1019         ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt];
1020         lb_params = (struct mlxsw_sp_rif_params_ipip_lb) {
1021                 .common.dev = ol_dev,
1022                 .common.lag = false,
1023                 .lb_config = ipip_ops->ol_loopback_config(mlxsw_sp, ol_dev),
1024         };
1025
1026         rif = mlxsw_sp_rif_create(mlxsw_sp, &lb_params.common, extack);
1027         if (IS_ERR(rif))
1028                 return ERR_CAST(rif);
1029         return container_of(rif, struct mlxsw_sp_rif_ipip_lb, common);
1030 }
1031
1032 static struct mlxsw_sp_ipip_entry *
1033 mlxsw_sp_ipip_entry_alloc(struct mlxsw_sp *mlxsw_sp,
1034                           enum mlxsw_sp_ipip_type ipipt,
1035                           struct net_device *ol_dev)
1036 {
1037         const struct mlxsw_sp_ipip_ops *ipip_ops;
1038         struct mlxsw_sp_ipip_entry *ipip_entry;
1039         struct mlxsw_sp_ipip_entry *ret = NULL;
1040
1041         ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt];
1042         ipip_entry = kzalloc(sizeof(*ipip_entry), GFP_KERNEL);
1043         if (!ipip_entry)
1044                 return ERR_PTR(-ENOMEM);
1045
1046         ipip_entry->ol_lb = mlxsw_sp_ipip_ol_ipip_lb_create(mlxsw_sp, ipipt,
1047                                                             ol_dev, NULL);
1048         if (IS_ERR(ipip_entry->ol_lb)) {
1049                 ret = ERR_CAST(ipip_entry->ol_lb);
1050                 goto err_ol_ipip_lb_create;
1051         }
1052
1053         ipip_entry->ipipt = ipipt;
1054         ipip_entry->ol_dev = ol_dev;
1055
1056         switch (ipip_ops->ul_proto) {
1057         case MLXSW_SP_L3_PROTO_IPV4:
1058                 ipip_entry->parms4 = mlxsw_sp_ipip_netdev_parms4(ol_dev);
1059                 break;
1060         case MLXSW_SP_L3_PROTO_IPV6:
1061                 WARN_ON(1);
1062                 break;
1063         }
1064
1065         return ipip_entry;
1066
1067 err_ol_ipip_lb_create:
1068         kfree(ipip_entry);
1069         return ret;
1070 }
1071
1072 static void
1073 mlxsw_sp_ipip_entry_dealloc(struct mlxsw_sp_ipip_entry *ipip_entry)
1074 {
1075         mlxsw_sp_rif_destroy(&ipip_entry->ol_lb->common);
1076         kfree(ipip_entry);
1077 }
1078
1079 static bool
1080 mlxsw_sp_ipip_entry_saddr_matches(struct mlxsw_sp *mlxsw_sp,
1081                                   const enum mlxsw_sp_l3proto ul_proto,
1082                                   union mlxsw_sp_l3addr saddr,
1083                                   u32 ul_tb_id,
1084                                   struct mlxsw_sp_ipip_entry *ipip_entry)
1085 {
1086         u32 tun_ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev);
1087         enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt;
1088         union mlxsw_sp_l3addr tun_saddr;
1089
1090         if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto)
1091                 return false;
1092
1093         tun_saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ipip_entry->ol_dev);
1094         return tun_ul_tb_id == ul_tb_id &&
1095                mlxsw_sp_l3addr_eq(&tun_saddr, &saddr);
1096 }
1097
1098 static int
1099 mlxsw_sp_fib_entry_decap_init(struct mlxsw_sp *mlxsw_sp,
1100                               struct mlxsw_sp_fib_entry *fib_entry,
1101                               struct mlxsw_sp_ipip_entry *ipip_entry)
1102 {
1103         u32 tunnel_index;
1104         int err;
1105
1106         err = mlxsw_sp_kvdl_alloc(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
1107                                   1, &tunnel_index);
1108         if (err)
1109                 return err;
1110
1111         ipip_entry->decap_fib_entry = fib_entry;
1112         fib_entry->decap.ipip_entry = ipip_entry;
1113         fib_entry->decap.tunnel_index = tunnel_index;
1114         return 0;
1115 }
1116
1117 static void mlxsw_sp_fib_entry_decap_fini(struct mlxsw_sp *mlxsw_sp,
1118                                           struct mlxsw_sp_fib_entry *fib_entry)
1119 {
1120         /* Unlink this node from the IPIP entry that it's the decap entry of. */
1121         fib_entry->decap.ipip_entry->decap_fib_entry = NULL;
1122         fib_entry->decap.ipip_entry = NULL;
1123         mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
1124                            1, fib_entry->decap.tunnel_index);
1125 }
1126
1127 static struct mlxsw_sp_fib_node *
1128 mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
1129                          size_t addr_len, unsigned char prefix_len);
1130 static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
1131                                      struct mlxsw_sp_fib_entry *fib_entry);
1132
1133 static void
1134 mlxsw_sp_ipip_entry_demote_decap(struct mlxsw_sp *mlxsw_sp,
1135                                  struct mlxsw_sp_ipip_entry *ipip_entry)
1136 {
1137         struct mlxsw_sp_fib_entry *fib_entry = ipip_entry->decap_fib_entry;
1138
1139         mlxsw_sp_fib_entry_decap_fini(mlxsw_sp, fib_entry);
1140         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
1141
1142         mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
1143 }
1144
1145 static void
1146 mlxsw_sp_ipip_entry_promote_decap(struct mlxsw_sp *mlxsw_sp,
1147                                   struct mlxsw_sp_ipip_entry *ipip_entry,
1148                                   struct mlxsw_sp_fib_entry *decap_fib_entry)
1149 {
1150         if (mlxsw_sp_fib_entry_decap_init(mlxsw_sp, decap_fib_entry,
1151                                           ipip_entry))
1152                 return;
1153         decap_fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
1154
1155         if (mlxsw_sp_fib_entry_update(mlxsw_sp, decap_fib_entry))
1156                 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1157 }
1158
1159 static struct mlxsw_sp_fib_entry *
1160 mlxsw_sp_router_ip2me_fib_entry_find(struct mlxsw_sp *mlxsw_sp, u32 tb_id,
1161                                      enum mlxsw_sp_l3proto proto,
1162                                      const union mlxsw_sp_l3addr *addr,
1163                                      enum mlxsw_sp_fib_entry_type type)
1164 {
1165         struct mlxsw_sp_fib_entry *fib_entry;
1166         struct mlxsw_sp_fib_node *fib_node;
1167         unsigned char addr_prefix_len;
1168         struct mlxsw_sp_fib *fib;
1169         struct mlxsw_sp_vr *vr;
1170         const void *addrp;
1171         size_t addr_len;
1172         u32 addr4;
1173
1174         vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id);
1175         if (!vr)
1176                 return NULL;
1177         fib = mlxsw_sp_vr_fib(vr, proto);
1178
1179         switch (proto) {
1180         case MLXSW_SP_L3_PROTO_IPV4:
1181                 addr4 = be32_to_cpu(addr->addr4);
1182                 addrp = &addr4;
1183                 addr_len = 4;
1184                 addr_prefix_len = 32;
1185                 break;
1186         case MLXSW_SP_L3_PROTO_IPV6: /* fall through */
1187         default:
1188                 WARN_ON(1);
1189                 return NULL;
1190         }
1191
1192         fib_node = mlxsw_sp_fib_node_lookup(fib, addrp, addr_len,
1193                                             addr_prefix_len);
1194         if (!fib_node || list_empty(&fib_node->entry_list))
1195                 return NULL;
1196
1197         fib_entry = list_first_entry(&fib_node->entry_list,
1198                                      struct mlxsw_sp_fib_entry, list);
1199         if (fib_entry->type != type)
1200                 return NULL;
1201
1202         return fib_entry;
1203 }
1204
1205 /* Given an IPIP entry, find the corresponding decap route. */
1206 static struct mlxsw_sp_fib_entry *
1207 mlxsw_sp_ipip_entry_find_decap(struct mlxsw_sp *mlxsw_sp,
1208                                struct mlxsw_sp_ipip_entry *ipip_entry)
1209 {
1210         static struct mlxsw_sp_fib_node *fib_node;
1211         const struct mlxsw_sp_ipip_ops *ipip_ops;
1212         struct mlxsw_sp_fib_entry *fib_entry;
1213         unsigned char saddr_prefix_len;
1214         union mlxsw_sp_l3addr saddr;
1215         struct mlxsw_sp_fib *ul_fib;
1216         struct mlxsw_sp_vr *ul_vr;
1217         const void *saddrp;
1218         size_t saddr_len;
1219         u32 ul_tb_id;
1220         u32 saddr4;
1221
1222         ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
1223
1224         ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev);
1225         ul_vr = mlxsw_sp_vr_find(mlxsw_sp, ul_tb_id);
1226         if (!ul_vr)
1227                 return NULL;
1228
1229         ul_fib = mlxsw_sp_vr_fib(ul_vr, ipip_ops->ul_proto);
1230         saddr = mlxsw_sp_ipip_netdev_saddr(ipip_ops->ul_proto,
1231                                            ipip_entry->ol_dev);
1232
1233         switch (ipip_ops->ul_proto) {
1234         case MLXSW_SP_L3_PROTO_IPV4:
1235                 saddr4 = be32_to_cpu(saddr.addr4);
1236                 saddrp = &saddr4;
1237                 saddr_len = 4;
1238                 saddr_prefix_len = 32;
1239                 break;
1240         case MLXSW_SP_L3_PROTO_IPV6:
1241                 WARN_ON(1);
1242                 return NULL;
1243         }
1244
1245         fib_node = mlxsw_sp_fib_node_lookup(ul_fib, saddrp, saddr_len,
1246                                             saddr_prefix_len);
1247         if (!fib_node || list_empty(&fib_node->entry_list))
1248                 return NULL;
1249
1250         fib_entry = list_first_entry(&fib_node->entry_list,
1251                                      struct mlxsw_sp_fib_entry, list);
1252         if (fib_entry->type != MLXSW_SP_FIB_ENTRY_TYPE_TRAP)
1253                 return NULL;
1254
1255         return fib_entry;
1256 }
1257
1258 static struct mlxsw_sp_ipip_entry *
1259 mlxsw_sp_ipip_entry_create(struct mlxsw_sp *mlxsw_sp,
1260                            enum mlxsw_sp_ipip_type ipipt,
1261                            struct net_device *ol_dev)
1262 {
1263         struct mlxsw_sp_ipip_entry *ipip_entry;
1264
1265         ipip_entry = mlxsw_sp_ipip_entry_alloc(mlxsw_sp, ipipt, ol_dev);
1266         if (IS_ERR(ipip_entry))
1267                 return ipip_entry;
1268
1269         list_add_tail(&ipip_entry->ipip_list_node,
1270                       &mlxsw_sp->router->ipip_list);
1271
1272         return ipip_entry;
1273 }
1274
1275 static void
1276 mlxsw_sp_ipip_entry_destroy(struct mlxsw_sp *mlxsw_sp,
1277                             struct mlxsw_sp_ipip_entry *ipip_entry)
1278 {
1279         list_del(&ipip_entry->ipip_list_node);
1280         mlxsw_sp_ipip_entry_dealloc(ipip_entry);
1281 }
1282
1283 static bool
1284 mlxsw_sp_ipip_entry_matches_decap(struct mlxsw_sp *mlxsw_sp,
1285                                   const struct net_device *ul_dev,
1286                                   enum mlxsw_sp_l3proto ul_proto,
1287                                   union mlxsw_sp_l3addr ul_dip,
1288                                   struct mlxsw_sp_ipip_entry *ipip_entry)
1289 {
1290         u32 ul_tb_id = l3mdev_fib_table(ul_dev) ? : RT_TABLE_MAIN;
1291         enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt;
1292
1293         if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto)
1294                 return false;
1295
1296         return mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, ul_dip,
1297                                                  ul_tb_id, ipip_entry);
1298 }
1299
1300 /* Given decap parameters, find the corresponding IPIP entry. */
1301 static struct mlxsw_sp_ipip_entry *
1302 mlxsw_sp_ipip_entry_find_by_decap(struct mlxsw_sp *mlxsw_sp,
1303                                   const struct net_device *ul_dev,
1304                                   enum mlxsw_sp_l3proto ul_proto,
1305                                   union mlxsw_sp_l3addr ul_dip)
1306 {
1307         struct mlxsw_sp_ipip_entry *ipip_entry;
1308
1309         list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list,
1310                             ipip_list_node)
1311                 if (mlxsw_sp_ipip_entry_matches_decap(mlxsw_sp, ul_dev,
1312                                                       ul_proto, ul_dip,
1313                                                       ipip_entry))
1314                         return ipip_entry;
1315
1316         return NULL;
1317 }
1318
1319 static bool mlxsw_sp_netdev_ipip_type(const struct mlxsw_sp *mlxsw_sp,
1320                                       const struct net_device *dev,
1321                                       enum mlxsw_sp_ipip_type *p_type)
1322 {
1323         struct mlxsw_sp_router *router = mlxsw_sp->router;
1324         const struct mlxsw_sp_ipip_ops *ipip_ops;
1325         enum mlxsw_sp_ipip_type ipipt;
1326
1327         for (ipipt = 0; ipipt < MLXSW_SP_IPIP_TYPE_MAX; ++ipipt) {
1328                 ipip_ops = router->ipip_ops_arr[ipipt];
1329                 if (dev->type == ipip_ops->dev_type) {
1330                         if (p_type)
1331                                 *p_type = ipipt;
1332                         return true;
1333                 }
1334         }
1335         return false;
1336 }
1337
1338 bool mlxsw_sp_netdev_is_ipip_ol(const struct mlxsw_sp *mlxsw_sp,
1339                                 const struct net_device *dev)
1340 {
1341         return mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, NULL);
1342 }
1343
1344 static struct mlxsw_sp_ipip_entry *
1345 mlxsw_sp_ipip_entry_find_by_ol_dev(struct mlxsw_sp *mlxsw_sp,
1346                                    const struct net_device *ol_dev)
1347 {
1348         struct mlxsw_sp_ipip_entry *ipip_entry;
1349
1350         list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list,
1351                             ipip_list_node)
1352                 if (ipip_entry->ol_dev == ol_dev)
1353                         return ipip_entry;
1354
1355         return NULL;
1356 }
1357
1358 static struct mlxsw_sp_ipip_entry *
1359 mlxsw_sp_ipip_entry_find_by_ul_dev(const struct mlxsw_sp *mlxsw_sp,
1360                                    const struct net_device *ul_dev,
1361                                    struct mlxsw_sp_ipip_entry *start)
1362 {
1363         struct mlxsw_sp_ipip_entry *ipip_entry;
1364
1365         ipip_entry = list_prepare_entry(start, &mlxsw_sp->router->ipip_list,
1366                                         ipip_list_node);
1367         list_for_each_entry_continue(ipip_entry, &mlxsw_sp->router->ipip_list,
1368                                      ipip_list_node) {
1369                 struct net_device *ipip_ul_dev =
1370                         __mlxsw_sp_ipip_netdev_ul_dev_get(ipip_entry->ol_dev);
1371
1372                 if (ipip_ul_dev == ul_dev)
1373                         return ipip_entry;
1374         }
1375
1376         return NULL;
1377 }
1378
1379 bool mlxsw_sp_netdev_is_ipip_ul(const struct mlxsw_sp *mlxsw_sp,
1380                                 const struct net_device *dev)
1381 {
1382         return mlxsw_sp_ipip_entry_find_by_ul_dev(mlxsw_sp, dev, NULL);
1383 }
1384
1385 static bool mlxsw_sp_netdevice_ipip_can_offload(struct mlxsw_sp *mlxsw_sp,
1386                                                 const struct net_device *ol_dev,
1387                                                 enum mlxsw_sp_ipip_type ipipt)
1388 {
1389         const struct mlxsw_sp_ipip_ops *ops
1390                 = mlxsw_sp->router->ipip_ops_arr[ipipt];
1391
1392         /* For deciding whether decap should be offloaded, we don't care about
1393          * overlay protocol, so ask whether either one is supported.
1394          */
1395         return ops->can_offload(mlxsw_sp, ol_dev, MLXSW_SP_L3_PROTO_IPV4) ||
1396                ops->can_offload(mlxsw_sp, ol_dev, MLXSW_SP_L3_PROTO_IPV6);
1397 }
1398
1399 static int mlxsw_sp_netdevice_ipip_ol_reg_event(struct mlxsw_sp *mlxsw_sp,
1400                                                 struct net_device *ol_dev)
1401 {
1402         struct mlxsw_sp_ipip_entry *ipip_entry;
1403         enum mlxsw_sp_l3proto ul_proto;
1404         enum mlxsw_sp_ipip_type ipipt;
1405         union mlxsw_sp_l3addr saddr;
1406         u32 ul_tb_id;
1407
1408         mlxsw_sp_netdev_ipip_type(mlxsw_sp, ol_dev, &ipipt);
1409         if (mlxsw_sp_netdevice_ipip_can_offload(mlxsw_sp, ol_dev, ipipt)) {
1410                 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ol_dev);
1411                 ul_proto = mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto;
1412                 saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ol_dev);
1413                 if (!mlxsw_sp_ipip_demote_tunnel_by_saddr(mlxsw_sp, ul_proto,
1414                                                           saddr, ul_tb_id,
1415                                                           NULL)) {
1416                         ipip_entry = mlxsw_sp_ipip_entry_create(mlxsw_sp, ipipt,
1417                                                                 ol_dev);
1418                         if (IS_ERR(ipip_entry))
1419                                 return PTR_ERR(ipip_entry);
1420                 }
1421         }
1422
1423         return 0;
1424 }
1425
1426 static void mlxsw_sp_netdevice_ipip_ol_unreg_event(struct mlxsw_sp *mlxsw_sp,
1427                                                    struct net_device *ol_dev)
1428 {
1429         struct mlxsw_sp_ipip_entry *ipip_entry;
1430
1431         ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1432         if (ipip_entry)
1433                 mlxsw_sp_ipip_entry_destroy(mlxsw_sp, ipip_entry);
1434 }
1435
1436 static void
1437 mlxsw_sp_ipip_entry_ol_up_event(struct mlxsw_sp *mlxsw_sp,
1438                                 struct mlxsw_sp_ipip_entry *ipip_entry)
1439 {
1440         struct mlxsw_sp_fib_entry *decap_fib_entry;
1441
1442         decap_fib_entry = mlxsw_sp_ipip_entry_find_decap(mlxsw_sp, ipip_entry);
1443         if (decap_fib_entry)
1444                 mlxsw_sp_ipip_entry_promote_decap(mlxsw_sp, ipip_entry,
1445                                                   decap_fib_entry);
1446 }
1447
1448 static int
1449 mlxsw_sp_rif_ipip_lb_op(struct mlxsw_sp_rif_ipip_lb *lb_rif, u16 ul_vr_id,
1450                         u16 ul_rif_id, bool enable)
1451 {
1452         struct mlxsw_sp_rif_ipip_lb_config lb_cf = lb_rif->lb_config;
1453         struct mlxsw_sp_rif *rif = &lb_rif->common;
1454         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
1455         char ritr_pl[MLXSW_REG_RITR_LEN];
1456         u32 saddr4;
1457
1458         switch (lb_cf.ul_protocol) {
1459         case MLXSW_SP_L3_PROTO_IPV4:
1460                 saddr4 = be32_to_cpu(lb_cf.saddr.addr4);
1461                 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_LOOPBACK_IF,
1462                                     rif->rif_index, rif->vr_id, rif->dev->mtu);
1463                 mlxsw_reg_ritr_loopback_ipip4_pack(ritr_pl, lb_cf.lb_ipipt,
1464                             MLXSW_REG_RITR_LOOPBACK_IPIP_OPTIONS_GRE_KEY_PRESET,
1465                             ul_vr_id, ul_rif_id, saddr4, lb_cf.okey);
1466                 break;
1467
1468         case MLXSW_SP_L3_PROTO_IPV6:
1469                 return -EAFNOSUPPORT;
1470         }
1471
1472         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
1473 }
1474
1475 static int mlxsw_sp_netdevice_ipip_ol_update_mtu(struct mlxsw_sp *mlxsw_sp,
1476                                                  struct net_device *ol_dev)
1477 {
1478         struct mlxsw_sp_ipip_entry *ipip_entry;
1479         struct mlxsw_sp_rif_ipip_lb *lb_rif;
1480         int err = 0;
1481
1482         ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1483         if (ipip_entry) {
1484                 lb_rif = ipip_entry->ol_lb;
1485                 err = mlxsw_sp_rif_ipip_lb_op(lb_rif, lb_rif->ul_vr_id,
1486                                               lb_rif->ul_rif_id, true);
1487                 if (err)
1488                         goto out;
1489                 lb_rif->common.mtu = ol_dev->mtu;
1490         }
1491
1492 out:
1493         return err;
1494 }
1495
1496 static void mlxsw_sp_netdevice_ipip_ol_up_event(struct mlxsw_sp *mlxsw_sp,
1497                                                 struct net_device *ol_dev)
1498 {
1499         struct mlxsw_sp_ipip_entry *ipip_entry;
1500
1501         ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1502         if (ipip_entry)
1503                 mlxsw_sp_ipip_entry_ol_up_event(mlxsw_sp, ipip_entry);
1504 }
1505
1506 static void
1507 mlxsw_sp_ipip_entry_ol_down_event(struct mlxsw_sp *mlxsw_sp,
1508                                   struct mlxsw_sp_ipip_entry *ipip_entry)
1509 {
1510         if (ipip_entry->decap_fib_entry)
1511                 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1512 }
1513
1514 static void mlxsw_sp_netdevice_ipip_ol_down_event(struct mlxsw_sp *mlxsw_sp,
1515                                                   struct net_device *ol_dev)
1516 {
1517         struct mlxsw_sp_ipip_entry *ipip_entry;
1518
1519         ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1520         if (ipip_entry)
1521                 mlxsw_sp_ipip_entry_ol_down_event(mlxsw_sp, ipip_entry);
1522 }
1523
1524 static void mlxsw_sp_nexthop_rif_migrate(struct mlxsw_sp *mlxsw_sp,
1525                                          struct mlxsw_sp_rif *old_rif,
1526                                          struct mlxsw_sp_rif *new_rif);
1527 static int
1528 mlxsw_sp_ipip_entry_ol_lb_update(struct mlxsw_sp *mlxsw_sp,
1529                                  struct mlxsw_sp_ipip_entry *ipip_entry,
1530                                  bool keep_encap,
1531                                  struct netlink_ext_ack *extack)
1532 {
1533         struct mlxsw_sp_rif_ipip_lb *old_lb_rif = ipip_entry->ol_lb;
1534         struct mlxsw_sp_rif_ipip_lb *new_lb_rif;
1535
1536         new_lb_rif = mlxsw_sp_ipip_ol_ipip_lb_create(mlxsw_sp,
1537                                                      ipip_entry->ipipt,
1538                                                      ipip_entry->ol_dev,
1539                                                      extack);
1540         if (IS_ERR(new_lb_rif))
1541                 return PTR_ERR(new_lb_rif);
1542         ipip_entry->ol_lb = new_lb_rif;
1543
1544         if (keep_encap)
1545                 mlxsw_sp_nexthop_rif_migrate(mlxsw_sp, &old_lb_rif->common,
1546                                              &new_lb_rif->common);
1547
1548         mlxsw_sp_rif_destroy(&old_lb_rif->common);
1549
1550         return 0;
1551 }
1552
1553 static void mlxsw_sp_nexthop_rif_update(struct mlxsw_sp *mlxsw_sp,
1554                                         struct mlxsw_sp_rif *rif);
1555
1556 /**
1557  * Update the offload related to an IPIP entry. This always updates decap, and
1558  * in addition to that it also:
1559  * @recreate_loopback: recreates the associated loopback RIF
1560  * @keep_encap: updates next hops that use the tunnel netdevice. This is only
1561  *              relevant when recreate_loopback is true.
1562  * @update_nexthops: updates next hops, keeping the current loopback RIF. This
1563  *                   is only relevant when recreate_loopback is false.
1564  */
1565 int __mlxsw_sp_ipip_entry_update_tunnel(struct mlxsw_sp *mlxsw_sp,
1566                                         struct mlxsw_sp_ipip_entry *ipip_entry,
1567                                         bool recreate_loopback,
1568                                         bool keep_encap,
1569                                         bool update_nexthops,
1570                                         struct netlink_ext_ack *extack)
1571 {
1572         int err;
1573
1574         /* RIFs can't be edited, so to update loopback, we need to destroy and
1575          * recreate it. That creates a window of opportunity where RALUE and
1576          * RATR registers end up referencing a RIF that's already gone. RATRs
1577          * are handled in mlxsw_sp_ipip_entry_ol_lb_update(), and to take care
1578          * of RALUE, demote the decap route back.
1579          */
1580         if (ipip_entry->decap_fib_entry)
1581                 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1582
1583         if (recreate_loopback) {
1584                 err = mlxsw_sp_ipip_entry_ol_lb_update(mlxsw_sp, ipip_entry,
1585                                                        keep_encap, extack);
1586                 if (err)
1587                         return err;
1588         } else if (update_nexthops) {
1589                 mlxsw_sp_nexthop_rif_update(mlxsw_sp,
1590                                             &ipip_entry->ol_lb->common);
1591         }
1592
1593         if (ipip_entry->ol_dev->flags & IFF_UP)
1594                 mlxsw_sp_ipip_entry_ol_up_event(mlxsw_sp, ipip_entry);
1595
1596         return 0;
1597 }
1598
1599 static int mlxsw_sp_netdevice_ipip_ol_vrf_event(struct mlxsw_sp *mlxsw_sp,
1600                                                 struct net_device *ol_dev,
1601                                                 struct netlink_ext_ack *extack)
1602 {
1603         struct mlxsw_sp_ipip_entry *ipip_entry =
1604                 mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1605
1606         if (!ipip_entry)
1607                 return 0;
1608
1609         return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry,
1610                                                    true, false, false, extack);
1611 }
1612
1613 static int
1614 mlxsw_sp_netdevice_ipip_ul_vrf_event(struct mlxsw_sp *mlxsw_sp,
1615                                      struct mlxsw_sp_ipip_entry *ipip_entry,
1616                                      struct net_device *ul_dev,
1617                                      struct netlink_ext_ack *extack)
1618 {
1619         return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry,
1620                                                    true, true, false, extack);
1621 }
1622
1623 static int
1624 mlxsw_sp_netdevice_ipip_ul_up_event(struct mlxsw_sp *mlxsw_sp,
1625                                     struct mlxsw_sp_ipip_entry *ipip_entry,
1626                                     struct net_device *ul_dev)
1627 {
1628         return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry,
1629                                                    false, false, true, NULL);
1630 }
1631
1632 static int
1633 mlxsw_sp_netdevice_ipip_ul_down_event(struct mlxsw_sp *mlxsw_sp,
1634                                       struct mlxsw_sp_ipip_entry *ipip_entry,
1635                                       struct net_device *ul_dev)
1636 {
1637         /* A down underlay device causes encapsulated packets to not be
1638          * forwarded, but decap still works. So refresh next hops without
1639          * touching anything else.
1640          */
1641         return __mlxsw_sp_ipip_entry_update_tunnel(mlxsw_sp, ipip_entry,
1642                                                    false, false, true, NULL);
1643 }
1644
1645 static int
1646 mlxsw_sp_netdevice_ipip_ol_change_event(struct mlxsw_sp *mlxsw_sp,
1647                                         struct net_device *ol_dev,
1648                                         struct netlink_ext_ack *extack)
1649 {
1650         const struct mlxsw_sp_ipip_ops *ipip_ops;
1651         struct mlxsw_sp_ipip_entry *ipip_entry;
1652         int err;
1653
1654         ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, ol_dev);
1655         if (!ipip_entry)
1656                 /* A change might make a tunnel eligible for offloading, but
1657                  * that is currently not implemented. What falls to slow path
1658                  * stays there.
1659                  */
1660                 return 0;
1661
1662         /* A change might make a tunnel not eligible for offloading. */
1663         if (!mlxsw_sp_netdevice_ipip_can_offload(mlxsw_sp, ol_dev,
1664                                                  ipip_entry->ipipt)) {
1665                 mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry);
1666                 return 0;
1667         }
1668
1669         ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
1670         err = ipip_ops->ol_netdev_change(mlxsw_sp, ipip_entry, extack);
1671         return err;
1672 }
1673
1674 void mlxsw_sp_ipip_entry_demote_tunnel(struct mlxsw_sp *mlxsw_sp,
1675                                        struct mlxsw_sp_ipip_entry *ipip_entry)
1676 {
1677         struct net_device *ol_dev = ipip_entry->ol_dev;
1678
1679         if (ol_dev->flags & IFF_UP)
1680                 mlxsw_sp_ipip_entry_ol_down_event(mlxsw_sp, ipip_entry);
1681         mlxsw_sp_ipip_entry_destroy(mlxsw_sp, ipip_entry);
1682 }
1683
1684 /* The configuration where several tunnels have the same local address in the
1685  * same underlay table needs special treatment in the HW. That is currently not
1686  * implemented in the driver. This function finds and demotes the first tunnel
1687  * with a given source address, except the one passed in in the argument
1688  * `except'.
1689  */
1690 bool
1691 mlxsw_sp_ipip_demote_tunnel_by_saddr(struct mlxsw_sp *mlxsw_sp,
1692                                      enum mlxsw_sp_l3proto ul_proto,
1693                                      union mlxsw_sp_l3addr saddr,
1694                                      u32 ul_tb_id,
1695                                      const struct mlxsw_sp_ipip_entry *except)
1696 {
1697         struct mlxsw_sp_ipip_entry *ipip_entry, *tmp;
1698
1699         list_for_each_entry_safe(ipip_entry, tmp, &mlxsw_sp->router->ipip_list,
1700                                  ipip_list_node) {
1701                 if (ipip_entry != except &&
1702                     mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, saddr,
1703                                                       ul_tb_id, ipip_entry)) {
1704                         mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry);
1705                         return true;
1706                 }
1707         }
1708
1709         return false;
1710 }
1711
1712 static void mlxsw_sp_ipip_demote_tunnel_by_ul_netdev(struct mlxsw_sp *mlxsw_sp,
1713                                                      struct net_device *ul_dev)
1714 {
1715         struct mlxsw_sp_ipip_entry *ipip_entry, *tmp;
1716
1717         list_for_each_entry_safe(ipip_entry, tmp, &mlxsw_sp->router->ipip_list,
1718                                  ipip_list_node) {
1719                 struct net_device *ipip_ul_dev =
1720                         __mlxsw_sp_ipip_netdev_ul_dev_get(ipip_entry->ol_dev);
1721
1722                 if (ipip_ul_dev == ul_dev)
1723                         mlxsw_sp_ipip_entry_demote_tunnel(mlxsw_sp, ipip_entry);
1724         }
1725 }
1726
1727 int mlxsw_sp_netdevice_ipip_ol_event(struct mlxsw_sp *mlxsw_sp,
1728                                      struct net_device *ol_dev,
1729                                      unsigned long event,
1730                                      struct netdev_notifier_info *info)
1731 {
1732         struct netdev_notifier_changeupper_info *chup;
1733         struct netlink_ext_ack *extack;
1734
1735         switch (event) {
1736         case NETDEV_REGISTER:
1737                 return mlxsw_sp_netdevice_ipip_ol_reg_event(mlxsw_sp, ol_dev);
1738         case NETDEV_UNREGISTER:
1739                 mlxsw_sp_netdevice_ipip_ol_unreg_event(mlxsw_sp, ol_dev);
1740                 return 0;
1741         case NETDEV_UP:
1742                 mlxsw_sp_netdevice_ipip_ol_up_event(mlxsw_sp, ol_dev);
1743                 return 0;
1744         case NETDEV_DOWN:
1745                 mlxsw_sp_netdevice_ipip_ol_down_event(mlxsw_sp, ol_dev);
1746                 return 0;
1747         case NETDEV_CHANGEUPPER:
1748                 chup = container_of(info, typeof(*chup), info);
1749                 extack = info->extack;
1750                 if (netif_is_l3_master(chup->upper_dev))
1751                         return mlxsw_sp_netdevice_ipip_ol_vrf_event(mlxsw_sp,
1752                                                                     ol_dev,
1753                                                                     extack);
1754                 return 0;
1755         case NETDEV_CHANGE:
1756                 extack = info->extack;
1757                 return mlxsw_sp_netdevice_ipip_ol_change_event(mlxsw_sp,
1758                                                                ol_dev, extack);
1759         case NETDEV_CHANGEMTU:
1760                 return mlxsw_sp_netdevice_ipip_ol_update_mtu(mlxsw_sp, ol_dev);
1761         }
1762         return 0;
1763 }
1764
1765 static int
1766 __mlxsw_sp_netdevice_ipip_ul_event(struct mlxsw_sp *mlxsw_sp,
1767                                    struct mlxsw_sp_ipip_entry *ipip_entry,
1768                                    struct net_device *ul_dev,
1769                                    unsigned long event,
1770                                    struct netdev_notifier_info *info)
1771 {
1772         struct netdev_notifier_changeupper_info *chup;
1773         struct netlink_ext_ack *extack;
1774
1775         switch (event) {
1776         case NETDEV_CHANGEUPPER:
1777                 chup = container_of(info, typeof(*chup), info);
1778                 extack = info->extack;
1779                 if (netif_is_l3_master(chup->upper_dev))
1780                         return mlxsw_sp_netdevice_ipip_ul_vrf_event(mlxsw_sp,
1781                                                                     ipip_entry,
1782                                                                     ul_dev,
1783                                                                     extack);
1784                 break;
1785
1786         case NETDEV_UP:
1787                 return mlxsw_sp_netdevice_ipip_ul_up_event(mlxsw_sp, ipip_entry,
1788                                                            ul_dev);
1789         case NETDEV_DOWN:
1790                 return mlxsw_sp_netdevice_ipip_ul_down_event(mlxsw_sp,
1791                                                              ipip_entry,
1792                                                              ul_dev);
1793         }
1794         return 0;
1795 }
1796
1797 int
1798 mlxsw_sp_netdevice_ipip_ul_event(struct mlxsw_sp *mlxsw_sp,
1799                                  struct net_device *ul_dev,
1800                                  unsigned long event,
1801                                  struct netdev_notifier_info *info)
1802 {
1803         struct mlxsw_sp_ipip_entry *ipip_entry = NULL;
1804         int err;
1805
1806         while ((ipip_entry = mlxsw_sp_ipip_entry_find_by_ul_dev(mlxsw_sp,
1807                                                                 ul_dev,
1808                                                                 ipip_entry))) {
1809                 err = __mlxsw_sp_netdevice_ipip_ul_event(mlxsw_sp, ipip_entry,
1810                                                          ul_dev, event, info);
1811                 if (err) {
1812                         mlxsw_sp_ipip_demote_tunnel_by_ul_netdev(mlxsw_sp,
1813                                                                  ul_dev);
1814                         return err;
1815                 }
1816         }
1817
1818         return 0;
1819 }
1820
1821 int mlxsw_sp_router_nve_promote_decap(struct mlxsw_sp *mlxsw_sp, u32 ul_tb_id,
1822                                       enum mlxsw_sp_l3proto ul_proto,
1823                                       const union mlxsw_sp_l3addr *ul_sip,
1824                                       u32 tunnel_index)
1825 {
1826         enum mlxsw_sp_fib_entry_type type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
1827         struct mlxsw_sp_fib_entry *fib_entry;
1828         int err;
1829
1830         /* It is valid to create a tunnel with a local IP and only later
1831          * assign this IP address to a local interface
1832          */
1833         fib_entry = mlxsw_sp_router_ip2me_fib_entry_find(mlxsw_sp, ul_tb_id,
1834                                                          ul_proto, ul_sip,
1835                                                          type);
1836         if (!fib_entry)
1837                 return 0;
1838
1839         fib_entry->decap.tunnel_index = tunnel_index;
1840         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP;
1841
1842         err = mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
1843         if (err)
1844                 goto err_fib_entry_update;
1845
1846         return 0;
1847
1848 err_fib_entry_update:
1849         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
1850         mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
1851         return err;
1852 }
1853
1854 void mlxsw_sp_router_nve_demote_decap(struct mlxsw_sp *mlxsw_sp, u32 ul_tb_id,
1855                                       enum mlxsw_sp_l3proto ul_proto,
1856                                       const union mlxsw_sp_l3addr *ul_sip)
1857 {
1858         enum mlxsw_sp_fib_entry_type type = MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP;
1859         struct mlxsw_sp_fib_entry *fib_entry;
1860
1861         fib_entry = mlxsw_sp_router_ip2me_fib_entry_find(mlxsw_sp, ul_tb_id,
1862                                                          ul_proto, ul_sip,
1863                                                          type);
1864         if (!fib_entry)
1865                 return;
1866
1867         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
1868         mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
1869 }
1870
1871 struct mlxsw_sp_neigh_key {
1872         struct neighbour *n;
1873 };
1874
1875 struct mlxsw_sp_neigh_entry {
1876         struct list_head rif_list_node;
1877         struct rhash_head ht_node;
1878         struct mlxsw_sp_neigh_key key;
1879         u16 rif;
1880         bool connected;
1881         unsigned char ha[ETH_ALEN];
1882         struct list_head nexthop_list; /* list of nexthops using
1883                                         * this neigh entry
1884                                         */
1885         struct list_head nexthop_neighs_list_node;
1886         unsigned int counter_index;
1887         bool counter_valid;
1888 };
1889
1890 static const struct rhashtable_params mlxsw_sp_neigh_ht_params = {
1891         .key_offset = offsetof(struct mlxsw_sp_neigh_entry, key),
1892         .head_offset = offsetof(struct mlxsw_sp_neigh_entry, ht_node),
1893         .key_len = sizeof(struct mlxsw_sp_neigh_key),
1894 };
1895
1896 struct mlxsw_sp_neigh_entry *
1897 mlxsw_sp_rif_neigh_next(struct mlxsw_sp_rif *rif,
1898                         struct mlxsw_sp_neigh_entry *neigh_entry)
1899 {
1900         if (!neigh_entry) {
1901                 if (list_empty(&rif->neigh_list))
1902                         return NULL;
1903                 else
1904                         return list_first_entry(&rif->neigh_list,
1905                                                 typeof(*neigh_entry),
1906                                                 rif_list_node);
1907         }
1908         if (list_is_last(&neigh_entry->rif_list_node, &rif->neigh_list))
1909                 return NULL;
1910         return list_next_entry(neigh_entry, rif_list_node);
1911 }
1912
1913 int mlxsw_sp_neigh_entry_type(struct mlxsw_sp_neigh_entry *neigh_entry)
1914 {
1915         return neigh_entry->key.n->tbl->family;
1916 }
1917
1918 unsigned char *
1919 mlxsw_sp_neigh_entry_ha(struct mlxsw_sp_neigh_entry *neigh_entry)
1920 {
1921         return neigh_entry->ha;
1922 }
1923
1924 u32 mlxsw_sp_neigh4_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry)
1925 {
1926         struct neighbour *n;
1927
1928         n = neigh_entry->key.n;
1929         return ntohl(*((__be32 *) n->primary_key));
1930 }
1931
1932 struct in6_addr *
1933 mlxsw_sp_neigh6_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry)
1934 {
1935         struct neighbour *n;
1936
1937         n = neigh_entry->key.n;
1938         return (struct in6_addr *) &n->primary_key;
1939 }
1940
1941 int mlxsw_sp_neigh_counter_get(struct mlxsw_sp *mlxsw_sp,
1942                                struct mlxsw_sp_neigh_entry *neigh_entry,
1943                                u64 *p_counter)
1944 {
1945         if (!neigh_entry->counter_valid)
1946                 return -EINVAL;
1947
1948         return mlxsw_sp_flow_counter_get(mlxsw_sp, neigh_entry->counter_index,
1949                                          p_counter, NULL);
1950 }
1951
1952 static struct mlxsw_sp_neigh_entry *
1953 mlxsw_sp_neigh_entry_alloc(struct mlxsw_sp *mlxsw_sp, struct neighbour *n,
1954                            u16 rif)
1955 {
1956         struct mlxsw_sp_neigh_entry *neigh_entry;
1957
1958         neigh_entry = kzalloc(sizeof(*neigh_entry), GFP_KERNEL);
1959         if (!neigh_entry)
1960                 return NULL;
1961
1962         neigh_entry->key.n = n;
1963         neigh_entry->rif = rif;
1964         INIT_LIST_HEAD(&neigh_entry->nexthop_list);
1965
1966         return neigh_entry;
1967 }
1968
1969 static void mlxsw_sp_neigh_entry_free(struct mlxsw_sp_neigh_entry *neigh_entry)
1970 {
1971         kfree(neigh_entry);
1972 }
1973
1974 static int
1975 mlxsw_sp_neigh_entry_insert(struct mlxsw_sp *mlxsw_sp,
1976                             struct mlxsw_sp_neigh_entry *neigh_entry)
1977 {
1978         return rhashtable_insert_fast(&mlxsw_sp->router->neigh_ht,
1979                                       &neigh_entry->ht_node,
1980                                       mlxsw_sp_neigh_ht_params);
1981 }
1982
1983 static void
1984 mlxsw_sp_neigh_entry_remove(struct mlxsw_sp *mlxsw_sp,
1985                             struct mlxsw_sp_neigh_entry *neigh_entry)
1986 {
1987         rhashtable_remove_fast(&mlxsw_sp->router->neigh_ht,
1988                                &neigh_entry->ht_node,
1989                                mlxsw_sp_neigh_ht_params);
1990 }
1991
1992 static bool
1993 mlxsw_sp_neigh_counter_should_alloc(struct mlxsw_sp *mlxsw_sp,
1994                                     struct mlxsw_sp_neigh_entry *neigh_entry)
1995 {
1996         struct devlink *devlink;
1997         const char *table_name;
1998
1999         switch (mlxsw_sp_neigh_entry_type(neigh_entry)) {
2000         case AF_INET:
2001                 table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST4;
2002                 break;
2003         case AF_INET6:
2004                 table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST6;
2005                 break;
2006         default:
2007                 WARN_ON(1);
2008                 return false;
2009         }
2010
2011         devlink = priv_to_devlink(mlxsw_sp->core);
2012         return devlink_dpipe_table_counter_enabled(devlink, table_name);
2013 }
2014
2015 static void
2016 mlxsw_sp_neigh_counter_alloc(struct mlxsw_sp *mlxsw_sp,
2017                              struct mlxsw_sp_neigh_entry *neigh_entry)
2018 {
2019         if (!mlxsw_sp_neigh_counter_should_alloc(mlxsw_sp, neigh_entry))
2020                 return;
2021
2022         if (mlxsw_sp_flow_counter_alloc(mlxsw_sp, &neigh_entry->counter_index))
2023                 return;
2024
2025         neigh_entry->counter_valid = true;
2026 }
2027
2028 static void
2029 mlxsw_sp_neigh_counter_free(struct mlxsw_sp *mlxsw_sp,
2030                             struct mlxsw_sp_neigh_entry *neigh_entry)
2031 {
2032         if (!neigh_entry->counter_valid)
2033                 return;
2034         mlxsw_sp_flow_counter_free(mlxsw_sp,
2035                                    neigh_entry->counter_index);
2036         neigh_entry->counter_valid = false;
2037 }
2038
2039 static struct mlxsw_sp_neigh_entry *
2040 mlxsw_sp_neigh_entry_create(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
2041 {
2042         struct mlxsw_sp_neigh_entry *neigh_entry;
2043         struct mlxsw_sp_rif *rif;
2044         int err;
2045
2046         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, n->dev);
2047         if (!rif)
2048                 return ERR_PTR(-EINVAL);
2049
2050         neigh_entry = mlxsw_sp_neigh_entry_alloc(mlxsw_sp, n, rif->rif_index);
2051         if (!neigh_entry)
2052                 return ERR_PTR(-ENOMEM);
2053
2054         err = mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry);
2055         if (err)
2056                 goto err_neigh_entry_insert;
2057
2058         mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry);
2059         list_add(&neigh_entry->rif_list_node, &rif->neigh_list);
2060
2061         return neigh_entry;
2062
2063 err_neigh_entry_insert:
2064         mlxsw_sp_neigh_entry_free(neigh_entry);
2065         return ERR_PTR(err);
2066 }
2067
2068 static void
2069 mlxsw_sp_neigh_entry_destroy(struct mlxsw_sp *mlxsw_sp,
2070                              struct mlxsw_sp_neigh_entry *neigh_entry)
2071 {
2072         list_del(&neigh_entry->rif_list_node);
2073         mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry);
2074         mlxsw_sp_neigh_entry_remove(mlxsw_sp, neigh_entry);
2075         mlxsw_sp_neigh_entry_free(neigh_entry);
2076 }
2077
2078 static struct mlxsw_sp_neigh_entry *
2079 mlxsw_sp_neigh_entry_lookup(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
2080 {
2081         struct mlxsw_sp_neigh_key key;
2082
2083         key.n = n;
2084         return rhashtable_lookup_fast(&mlxsw_sp->router->neigh_ht,
2085                                       &key, mlxsw_sp_neigh_ht_params);
2086 }
2087
2088 static void
2089 mlxsw_sp_router_neighs_update_interval_init(struct mlxsw_sp *mlxsw_sp)
2090 {
2091         unsigned long interval;
2092
2093 #if IS_ENABLED(CONFIG_IPV6)
2094         interval = min_t(unsigned long,
2095                          NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME),
2096                          NEIGH_VAR(&nd_tbl.parms, DELAY_PROBE_TIME));
2097 #else
2098         interval = NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME);
2099 #endif
2100         mlxsw_sp->router->neighs_update.interval = jiffies_to_msecs(interval);
2101 }
2102
2103 static void mlxsw_sp_router_neigh_ent_ipv4_process(struct mlxsw_sp *mlxsw_sp,
2104                                                    char *rauhtd_pl,
2105                                                    int ent_index)
2106 {
2107         struct net_device *dev;
2108         struct neighbour *n;
2109         __be32 dipn;
2110         u32 dip;
2111         u16 rif;
2112
2113         mlxsw_reg_rauhtd_ent_ipv4_unpack(rauhtd_pl, ent_index, &rif, &dip);
2114
2115         if (!mlxsw_sp->router->rifs[rif]) {
2116                 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
2117                 return;
2118         }
2119
2120         dipn = htonl(dip);
2121         dev = mlxsw_sp->router->rifs[rif]->dev;
2122         n = neigh_lookup(&arp_tbl, &dipn, dev);
2123         if (!n)
2124                 return;
2125
2126         netdev_dbg(dev, "Updating neighbour with IP=%pI4h\n", &dip);
2127         neigh_event_send(n, NULL);
2128         neigh_release(n);
2129 }
2130
2131 #if IS_ENABLED(CONFIG_IPV6)
2132 static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
2133                                                    char *rauhtd_pl,
2134                                                    int rec_index)
2135 {
2136         struct net_device *dev;
2137         struct neighbour *n;
2138         struct in6_addr dip;
2139         u16 rif;
2140
2141         mlxsw_reg_rauhtd_ent_ipv6_unpack(rauhtd_pl, rec_index, &rif,
2142                                          (char *) &dip);
2143
2144         if (!mlxsw_sp->router->rifs[rif]) {
2145                 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
2146                 return;
2147         }
2148
2149         dev = mlxsw_sp->router->rifs[rif]->dev;
2150         n = neigh_lookup(&nd_tbl, &dip, dev);
2151         if (!n)
2152                 return;
2153
2154         netdev_dbg(dev, "Updating neighbour with IP=%pI6c\n", &dip);
2155         neigh_event_send(n, NULL);
2156         neigh_release(n);
2157 }
2158 #else
2159 static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
2160                                                    char *rauhtd_pl,
2161                                                    int rec_index)
2162 {
2163 }
2164 #endif
2165
2166 static void mlxsw_sp_router_neigh_rec_ipv4_process(struct mlxsw_sp *mlxsw_sp,
2167                                                    char *rauhtd_pl,
2168                                                    int rec_index)
2169 {
2170         u8 num_entries;
2171         int i;
2172
2173         num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
2174                                                                 rec_index);
2175         /* Hardware starts counting at 0, so add 1. */
2176         num_entries++;
2177
2178         /* Each record consists of several neighbour entries. */
2179         for (i = 0; i < num_entries; i++) {
2180                 int ent_index;
2181
2182                 ent_index = rec_index * MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC + i;
2183                 mlxsw_sp_router_neigh_ent_ipv4_process(mlxsw_sp, rauhtd_pl,
2184                                                        ent_index);
2185         }
2186
2187 }
2188
2189 static void mlxsw_sp_router_neigh_rec_ipv6_process(struct mlxsw_sp *mlxsw_sp,
2190                                                    char *rauhtd_pl,
2191                                                    int rec_index)
2192 {
2193         /* One record contains one entry. */
2194         mlxsw_sp_router_neigh_ent_ipv6_process(mlxsw_sp, rauhtd_pl,
2195                                                rec_index);
2196 }
2197
2198 static void mlxsw_sp_router_neigh_rec_process(struct mlxsw_sp *mlxsw_sp,
2199                                               char *rauhtd_pl, int rec_index)
2200 {
2201         switch (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, rec_index)) {
2202         case MLXSW_REG_RAUHTD_TYPE_IPV4:
2203                 mlxsw_sp_router_neigh_rec_ipv4_process(mlxsw_sp, rauhtd_pl,
2204                                                        rec_index);
2205                 break;
2206         case MLXSW_REG_RAUHTD_TYPE_IPV6:
2207                 mlxsw_sp_router_neigh_rec_ipv6_process(mlxsw_sp, rauhtd_pl,
2208                                                        rec_index);
2209                 break;
2210         }
2211 }
2212
2213 static bool mlxsw_sp_router_rauhtd_is_full(char *rauhtd_pl)
2214 {
2215         u8 num_rec, last_rec_index, num_entries;
2216
2217         num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
2218         last_rec_index = num_rec - 1;
2219
2220         if (num_rec < MLXSW_REG_RAUHTD_REC_MAX_NUM)
2221                 return false;
2222         if (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, last_rec_index) ==
2223             MLXSW_REG_RAUHTD_TYPE_IPV6)
2224                 return true;
2225
2226         num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
2227                                                                 last_rec_index);
2228         if (++num_entries == MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC)
2229                 return true;
2230         return false;
2231 }
2232
2233 static int
2234 __mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp,
2235                                        char *rauhtd_pl,
2236                                        enum mlxsw_reg_rauhtd_type type)
2237 {
2238         int i, num_rec;
2239         int err;
2240
2241         /* Make sure the neighbour's netdev isn't removed in the
2242          * process.
2243          */
2244         rtnl_lock();
2245         do {
2246                 mlxsw_reg_rauhtd_pack(rauhtd_pl, type);
2247                 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(rauhtd),
2248                                       rauhtd_pl);
2249                 if (err) {
2250                         dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to dump neighbour table\n");
2251                         break;
2252                 }
2253                 num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
2254                 for (i = 0; i < num_rec; i++)
2255                         mlxsw_sp_router_neigh_rec_process(mlxsw_sp, rauhtd_pl,
2256                                                           i);
2257         } while (mlxsw_sp_router_rauhtd_is_full(rauhtd_pl));
2258         rtnl_unlock();
2259
2260         return err;
2261 }
2262
2263 static int mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp)
2264 {
2265         enum mlxsw_reg_rauhtd_type type;
2266         char *rauhtd_pl;
2267         int err;
2268
2269         rauhtd_pl = kmalloc(MLXSW_REG_RAUHTD_LEN, GFP_KERNEL);
2270         if (!rauhtd_pl)
2271                 return -ENOMEM;
2272
2273         type = MLXSW_REG_RAUHTD_TYPE_IPV4;
2274         err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
2275         if (err)
2276                 goto out;
2277
2278         type = MLXSW_REG_RAUHTD_TYPE_IPV6;
2279         err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
2280 out:
2281         kfree(rauhtd_pl);
2282         return err;
2283 }
2284
2285 static void mlxsw_sp_router_neighs_update_nh(struct mlxsw_sp *mlxsw_sp)
2286 {
2287         struct mlxsw_sp_neigh_entry *neigh_entry;
2288
2289         /* Take RTNL mutex here to prevent lists from changes */
2290         rtnl_lock();
2291         list_for_each_entry(neigh_entry, &mlxsw_sp->router->nexthop_neighs_list,
2292                             nexthop_neighs_list_node)
2293                 /* If this neigh have nexthops, make the kernel think this neigh
2294                  * is active regardless of the traffic.
2295                  */
2296                 neigh_event_send(neigh_entry->key.n, NULL);
2297         rtnl_unlock();
2298 }
2299
2300 static void
2301 mlxsw_sp_router_neighs_update_work_schedule(struct mlxsw_sp *mlxsw_sp)
2302 {
2303         unsigned long interval = mlxsw_sp->router->neighs_update.interval;
2304
2305         mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw,
2306                                msecs_to_jiffies(interval));
2307 }
2308
2309 static void mlxsw_sp_router_neighs_update_work(struct work_struct *work)
2310 {
2311         struct mlxsw_sp_router *router;
2312         int err;
2313
2314         router = container_of(work, struct mlxsw_sp_router,
2315                               neighs_update.dw.work);
2316         err = mlxsw_sp_router_neighs_update_rauhtd(router->mlxsw_sp);
2317         if (err)
2318                 dev_err(router->mlxsw_sp->bus_info->dev, "Could not update kernel for neigh activity");
2319
2320         mlxsw_sp_router_neighs_update_nh(router->mlxsw_sp);
2321
2322         mlxsw_sp_router_neighs_update_work_schedule(router->mlxsw_sp);
2323 }
2324
2325 static void mlxsw_sp_router_probe_unresolved_nexthops(struct work_struct *work)
2326 {
2327         struct mlxsw_sp_neigh_entry *neigh_entry;
2328         struct mlxsw_sp_router *router;
2329
2330         router = container_of(work, struct mlxsw_sp_router,
2331                               nexthop_probe_dw.work);
2332         /* Iterate over nexthop neighbours, find those who are unresolved and
2333          * send arp on them. This solves the chicken-egg problem when
2334          * the nexthop wouldn't get offloaded until the neighbor is resolved
2335          * but it wouldn't get resolved ever in case traffic is flowing in HW
2336          * using different nexthop.
2337          *
2338          * Take RTNL mutex here to prevent lists from changes.
2339          */
2340         rtnl_lock();
2341         list_for_each_entry(neigh_entry, &router->nexthop_neighs_list,
2342                             nexthop_neighs_list_node)
2343                 if (!neigh_entry->connected)
2344                         neigh_event_send(neigh_entry->key.n, NULL);
2345         rtnl_unlock();
2346
2347         mlxsw_core_schedule_dw(&router->nexthop_probe_dw,
2348                                MLXSW_SP_UNRESOLVED_NH_PROBE_INTERVAL);
2349 }
2350
2351 static void
2352 mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
2353                               struct mlxsw_sp_neigh_entry *neigh_entry,
2354                               bool removing, bool dead);
2355
2356 static enum mlxsw_reg_rauht_op mlxsw_sp_rauht_op(bool adding)
2357 {
2358         return adding ? MLXSW_REG_RAUHT_OP_WRITE_ADD :
2359                         MLXSW_REG_RAUHT_OP_WRITE_DELETE;
2360 }
2361
2362 static int
2363 mlxsw_sp_router_neigh_entry_op4(struct mlxsw_sp *mlxsw_sp,
2364                                 struct mlxsw_sp_neigh_entry *neigh_entry,
2365                                 enum mlxsw_reg_rauht_op op)
2366 {
2367         struct neighbour *n = neigh_entry->key.n;
2368         u32 dip = ntohl(*((__be32 *) n->primary_key));
2369         char rauht_pl[MLXSW_REG_RAUHT_LEN];
2370
2371         mlxsw_reg_rauht_pack4(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
2372                               dip);
2373         if (neigh_entry->counter_valid)
2374                 mlxsw_reg_rauht_pack_counter(rauht_pl,
2375                                              neigh_entry->counter_index);
2376         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
2377 }
2378
2379 static int
2380 mlxsw_sp_router_neigh_entry_op6(struct mlxsw_sp *mlxsw_sp,
2381                                 struct mlxsw_sp_neigh_entry *neigh_entry,
2382                                 enum mlxsw_reg_rauht_op op)
2383 {
2384         struct neighbour *n = neigh_entry->key.n;
2385         char rauht_pl[MLXSW_REG_RAUHT_LEN];
2386         const char *dip = n->primary_key;
2387
2388         mlxsw_reg_rauht_pack6(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
2389                               dip);
2390         if (neigh_entry->counter_valid)
2391                 mlxsw_reg_rauht_pack_counter(rauht_pl,
2392                                              neigh_entry->counter_index);
2393         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
2394 }
2395
2396 bool mlxsw_sp_neigh_ipv6_ignore(struct mlxsw_sp_neigh_entry *neigh_entry)
2397 {
2398         struct neighbour *n = neigh_entry->key.n;
2399
2400         /* Packets with a link-local destination address are trapped
2401          * after LPM lookup and never reach the neighbour table, so
2402          * there is no need to program such neighbours to the device.
2403          */
2404         if (ipv6_addr_type((struct in6_addr *) &n->primary_key) &
2405             IPV6_ADDR_LINKLOCAL)
2406                 return true;
2407         return false;
2408 }
2409
2410 static void
2411 mlxsw_sp_neigh_entry_update(struct mlxsw_sp *mlxsw_sp,
2412                             struct mlxsw_sp_neigh_entry *neigh_entry,
2413                             bool adding)
2414 {
2415         enum mlxsw_reg_rauht_op op = mlxsw_sp_rauht_op(adding);
2416         int err;
2417
2418         if (!adding && !neigh_entry->connected)
2419                 return;
2420         neigh_entry->connected = adding;
2421         if (neigh_entry->key.n->tbl->family == AF_INET) {
2422                 err = mlxsw_sp_router_neigh_entry_op4(mlxsw_sp, neigh_entry,
2423                                                       op);
2424                 if (err)
2425                         return;
2426         } else if (neigh_entry->key.n->tbl->family == AF_INET6) {
2427                 if (mlxsw_sp_neigh_ipv6_ignore(neigh_entry))
2428                         return;
2429                 err = mlxsw_sp_router_neigh_entry_op6(mlxsw_sp, neigh_entry,
2430                                                       op);
2431                 if (err)
2432                         return;
2433         } else {
2434                 WARN_ON_ONCE(1);
2435                 return;
2436         }
2437
2438         if (adding)
2439                 neigh_entry->key.n->flags |= NTF_OFFLOADED;
2440         else
2441                 neigh_entry->key.n->flags &= ~NTF_OFFLOADED;
2442 }
2443
2444 void
2445 mlxsw_sp_neigh_entry_counter_update(struct mlxsw_sp *mlxsw_sp,
2446                                     struct mlxsw_sp_neigh_entry *neigh_entry,
2447                                     bool adding)
2448 {
2449         if (adding)
2450                 mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry);
2451         else
2452                 mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry);
2453         mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, true);
2454 }
2455
2456 struct mlxsw_sp_netevent_work {
2457         struct work_struct work;
2458         struct mlxsw_sp *mlxsw_sp;
2459         struct neighbour *n;
2460 };
2461
2462 static void mlxsw_sp_router_neigh_event_work(struct work_struct *work)
2463 {
2464         struct mlxsw_sp_netevent_work *net_work =
2465                 container_of(work, struct mlxsw_sp_netevent_work, work);
2466         struct mlxsw_sp *mlxsw_sp = net_work->mlxsw_sp;
2467         struct mlxsw_sp_neigh_entry *neigh_entry;
2468         struct neighbour *n = net_work->n;
2469         unsigned char ha[ETH_ALEN];
2470         bool entry_connected;
2471         u8 nud_state, dead;
2472
2473         /* If these parameters are changed after we release the lock,
2474          * then we are guaranteed to receive another event letting us
2475          * know about it.
2476          */
2477         read_lock_bh(&n->lock);
2478         memcpy(ha, n->ha, ETH_ALEN);
2479         nud_state = n->nud_state;
2480         dead = n->dead;
2481         read_unlock_bh(&n->lock);
2482
2483         rtnl_lock();
2484         mlxsw_sp_span_respin(mlxsw_sp);
2485
2486         entry_connected = nud_state & NUD_VALID && !dead;
2487         neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
2488         if (!entry_connected && !neigh_entry)
2489                 goto out;
2490         if (!neigh_entry) {
2491                 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
2492                 if (IS_ERR(neigh_entry))
2493                         goto out;
2494         }
2495
2496         memcpy(neigh_entry->ha, ha, ETH_ALEN);
2497         mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, entry_connected);
2498         mlxsw_sp_nexthop_neigh_update(mlxsw_sp, neigh_entry, !entry_connected,
2499                                       dead);
2500
2501         if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
2502                 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
2503
2504 out:
2505         rtnl_unlock();
2506         neigh_release(n);
2507         kfree(net_work);
2508 }
2509
2510 static int mlxsw_sp_mp_hash_init(struct mlxsw_sp *mlxsw_sp);
2511
2512 static void mlxsw_sp_router_mp_hash_event_work(struct work_struct *work)
2513 {
2514         struct mlxsw_sp_netevent_work *net_work =
2515                 container_of(work, struct mlxsw_sp_netevent_work, work);
2516         struct mlxsw_sp *mlxsw_sp = net_work->mlxsw_sp;
2517
2518         mlxsw_sp_mp_hash_init(mlxsw_sp);
2519         kfree(net_work);
2520 }
2521
2522 static int __mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp);
2523
2524 static void mlxsw_sp_router_update_priority_work(struct work_struct *work)
2525 {
2526         struct mlxsw_sp_netevent_work *net_work =
2527                 container_of(work, struct mlxsw_sp_netevent_work, work);
2528         struct mlxsw_sp *mlxsw_sp = net_work->mlxsw_sp;
2529
2530         __mlxsw_sp_router_init(mlxsw_sp);
2531         kfree(net_work);
2532 }
2533
2534 static int mlxsw_sp_router_schedule_work(struct net *net,
2535                                          struct notifier_block *nb,
2536                                          void (*cb)(struct work_struct *))
2537 {
2538         struct mlxsw_sp_netevent_work *net_work;
2539         struct mlxsw_sp_router *router;
2540
2541         router = container_of(nb, struct mlxsw_sp_router, netevent_nb);
2542         if (!net_eq(net, mlxsw_sp_net(router->mlxsw_sp)))
2543                 return NOTIFY_DONE;
2544
2545         net_work = kzalloc(sizeof(*net_work), GFP_ATOMIC);
2546         if (!net_work)
2547                 return NOTIFY_BAD;
2548
2549         INIT_WORK(&net_work->work, cb);
2550         net_work->mlxsw_sp = router->mlxsw_sp;
2551         mlxsw_core_schedule_work(&net_work->work);
2552         return NOTIFY_DONE;
2553 }
2554
2555 static int mlxsw_sp_router_netevent_event(struct notifier_block *nb,
2556                                           unsigned long event, void *ptr)
2557 {
2558         struct mlxsw_sp_netevent_work *net_work;
2559         struct mlxsw_sp_port *mlxsw_sp_port;
2560         struct mlxsw_sp *mlxsw_sp;
2561         unsigned long interval;
2562         struct neigh_parms *p;
2563         struct neighbour *n;
2564
2565         switch (event) {
2566         case NETEVENT_DELAY_PROBE_TIME_UPDATE:
2567                 p = ptr;
2568
2569                 /* We don't care about changes in the default table. */
2570                 if (!p->dev || (p->tbl->family != AF_INET &&
2571                                 p->tbl->family != AF_INET6))
2572                         return NOTIFY_DONE;
2573
2574                 /* We are in atomic context and can't take RTNL mutex,
2575                  * so use RCU variant to walk the device chain.
2576                  */
2577                 mlxsw_sp_port = mlxsw_sp_port_lower_dev_hold(p->dev);
2578                 if (!mlxsw_sp_port)
2579                         return NOTIFY_DONE;
2580
2581                 mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2582                 interval = jiffies_to_msecs(NEIGH_VAR(p, DELAY_PROBE_TIME));
2583                 mlxsw_sp->router->neighs_update.interval = interval;
2584
2585                 mlxsw_sp_port_dev_put(mlxsw_sp_port);
2586                 break;
2587         case NETEVENT_NEIGH_UPDATE:
2588                 n = ptr;
2589
2590                 if (n->tbl->family != AF_INET && n->tbl->family != AF_INET6)
2591                         return NOTIFY_DONE;
2592
2593                 mlxsw_sp_port = mlxsw_sp_port_lower_dev_hold(n->dev);
2594                 if (!mlxsw_sp_port)
2595                         return NOTIFY_DONE;
2596
2597                 net_work = kzalloc(sizeof(*net_work), GFP_ATOMIC);
2598                 if (!net_work) {
2599                         mlxsw_sp_port_dev_put(mlxsw_sp_port);
2600                         return NOTIFY_BAD;
2601                 }
2602
2603                 INIT_WORK(&net_work->work, mlxsw_sp_router_neigh_event_work);
2604                 net_work->mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2605                 net_work->n = n;
2606
2607                 /* Take a reference to ensure the neighbour won't be
2608                  * destructed until we drop the reference in delayed
2609                  * work.
2610                  */
2611                 neigh_clone(n);
2612                 mlxsw_core_schedule_work(&net_work->work);
2613                 mlxsw_sp_port_dev_put(mlxsw_sp_port);
2614                 break;
2615         case NETEVENT_IPV4_MPATH_HASH_UPDATE:
2616         case NETEVENT_IPV6_MPATH_HASH_UPDATE:
2617                 return mlxsw_sp_router_schedule_work(ptr, nb,
2618                                 mlxsw_sp_router_mp_hash_event_work);
2619
2620         case NETEVENT_IPV4_FWD_UPDATE_PRIORITY_UPDATE:
2621                 return mlxsw_sp_router_schedule_work(ptr, nb,
2622                                 mlxsw_sp_router_update_priority_work);
2623         }
2624
2625         return NOTIFY_DONE;
2626 }
2627
2628 static int mlxsw_sp_neigh_init(struct mlxsw_sp *mlxsw_sp)
2629 {
2630         int err;
2631
2632         err = rhashtable_init(&mlxsw_sp->router->neigh_ht,
2633                               &mlxsw_sp_neigh_ht_params);
2634         if (err)
2635                 return err;
2636
2637         /* Initialize the polling interval according to the default
2638          * table.
2639          */
2640         mlxsw_sp_router_neighs_update_interval_init(mlxsw_sp);
2641
2642         /* Create the delayed works for the activity_update */
2643         INIT_DELAYED_WORK(&mlxsw_sp->router->neighs_update.dw,
2644                           mlxsw_sp_router_neighs_update_work);
2645         INIT_DELAYED_WORK(&mlxsw_sp->router->nexthop_probe_dw,
2646                           mlxsw_sp_router_probe_unresolved_nexthops);
2647         mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw, 0);
2648         mlxsw_core_schedule_dw(&mlxsw_sp->router->nexthop_probe_dw, 0);
2649         return 0;
2650 }
2651
2652 static void mlxsw_sp_neigh_fini(struct mlxsw_sp *mlxsw_sp)
2653 {
2654         cancel_delayed_work_sync(&mlxsw_sp->router->neighs_update.dw);
2655         cancel_delayed_work_sync(&mlxsw_sp->router->nexthop_probe_dw);
2656         rhashtable_destroy(&mlxsw_sp->router->neigh_ht);
2657 }
2658
2659 static void mlxsw_sp_neigh_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
2660                                          struct mlxsw_sp_rif *rif)
2661 {
2662         struct mlxsw_sp_neigh_entry *neigh_entry, *tmp;
2663
2664         list_for_each_entry_safe(neigh_entry, tmp, &rif->neigh_list,
2665                                  rif_list_node) {
2666                 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, false);
2667                 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
2668         }
2669 }
2670
2671 enum mlxsw_sp_nexthop_type {
2672         MLXSW_SP_NEXTHOP_TYPE_ETH,
2673         MLXSW_SP_NEXTHOP_TYPE_IPIP,
2674 };
2675
2676 struct mlxsw_sp_nexthop_key {
2677         struct fib_nh *fib_nh;
2678 };
2679
2680 struct mlxsw_sp_nexthop {
2681         struct list_head neigh_list_node; /* member of neigh entry list */
2682         struct list_head rif_list_node;
2683         struct list_head router_list_node;
2684         struct mlxsw_sp_nexthop_group *nh_grp; /* pointer back to the group
2685                                                 * this belongs to
2686                                                 */
2687         struct rhash_head ht_node;
2688         struct mlxsw_sp_nexthop_key key;
2689         unsigned char gw_addr[sizeof(struct in6_addr)];
2690         int ifindex;
2691         int nh_weight;
2692         int norm_nh_weight;
2693         int num_adj_entries;
2694         struct mlxsw_sp_rif *rif;
2695         u8 should_offload:1, /* set indicates this neigh is connected and
2696                               * should be put to KVD linear area of this group.
2697                               */
2698            offloaded:1, /* set in case the neigh is actually put into
2699                          * KVD linear area of this group.
2700                          */
2701            update:1; /* set indicates that MAC of this neigh should be
2702                       * updated in HW
2703                       */
2704         enum mlxsw_sp_nexthop_type type;
2705         union {
2706                 struct mlxsw_sp_neigh_entry *neigh_entry;
2707                 struct mlxsw_sp_ipip_entry *ipip_entry;
2708         };
2709         unsigned int counter_index;
2710         bool counter_valid;
2711 };
2712
2713 struct mlxsw_sp_nexthop_group {
2714         void *priv;
2715         struct rhash_head ht_node;
2716         struct list_head fib_list; /* list of fib entries that use this group */
2717         struct neigh_table *neigh_tbl;
2718         u8 adj_index_valid:1,
2719            gateway:1; /* routes using the group use a gateway */
2720         u32 adj_index;
2721         u16 ecmp_size;
2722         u16 count;
2723         int sum_norm_weight;
2724         struct mlxsw_sp_nexthop nexthops[0];
2725 #define nh_rif  nexthops[0].rif
2726 };
2727
2728 void mlxsw_sp_nexthop_counter_alloc(struct mlxsw_sp *mlxsw_sp,
2729                                     struct mlxsw_sp_nexthop *nh)
2730 {
2731         struct devlink *devlink;
2732
2733         devlink = priv_to_devlink(mlxsw_sp->core);
2734         if (!devlink_dpipe_table_counter_enabled(devlink,
2735                                                  MLXSW_SP_DPIPE_TABLE_NAME_ADJ))
2736                 return;
2737
2738         if (mlxsw_sp_flow_counter_alloc(mlxsw_sp, &nh->counter_index))
2739                 return;
2740
2741         nh->counter_valid = true;
2742 }
2743
2744 void mlxsw_sp_nexthop_counter_free(struct mlxsw_sp *mlxsw_sp,
2745                                    struct mlxsw_sp_nexthop *nh)
2746 {
2747         if (!nh->counter_valid)
2748                 return;
2749         mlxsw_sp_flow_counter_free(mlxsw_sp, nh->counter_index);
2750         nh->counter_valid = false;
2751 }
2752
2753 int mlxsw_sp_nexthop_counter_get(struct mlxsw_sp *mlxsw_sp,
2754                                  struct mlxsw_sp_nexthop *nh, u64 *p_counter)
2755 {
2756         if (!nh->counter_valid)
2757                 return -EINVAL;
2758
2759         return mlxsw_sp_flow_counter_get(mlxsw_sp, nh->counter_index,
2760                                          p_counter, NULL);
2761 }
2762
2763 struct mlxsw_sp_nexthop *mlxsw_sp_nexthop_next(struct mlxsw_sp_router *router,
2764                                                struct mlxsw_sp_nexthop *nh)
2765 {
2766         if (!nh) {
2767                 if (list_empty(&router->nexthop_list))
2768                         return NULL;
2769                 else
2770                         return list_first_entry(&router->nexthop_list,
2771                                                 typeof(*nh), router_list_node);
2772         }
2773         if (list_is_last(&nh->router_list_node, &router->nexthop_list))
2774                 return NULL;
2775         return list_next_entry(nh, router_list_node);
2776 }
2777
2778 bool mlxsw_sp_nexthop_offload(struct mlxsw_sp_nexthop *nh)
2779 {
2780         return nh->offloaded;
2781 }
2782
2783 unsigned char *mlxsw_sp_nexthop_ha(struct mlxsw_sp_nexthop *nh)
2784 {
2785         if (!nh->offloaded)
2786                 return NULL;
2787         return nh->neigh_entry->ha;
2788 }
2789
2790 int mlxsw_sp_nexthop_indexes(struct mlxsw_sp_nexthop *nh, u32 *p_adj_index,
2791                              u32 *p_adj_size, u32 *p_adj_hash_index)
2792 {
2793         struct mlxsw_sp_nexthop_group *nh_grp = nh->nh_grp;
2794         u32 adj_hash_index = 0;
2795         int i;
2796
2797         if (!nh->offloaded || !nh_grp->adj_index_valid)
2798                 return -EINVAL;
2799
2800         *p_adj_index = nh_grp->adj_index;
2801         *p_adj_size = nh_grp->ecmp_size;
2802
2803         for (i = 0; i < nh_grp->count; i++) {
2804                 struct mlxsw_sp_nexthop *nh_iter = &nh_grp->nexthops[i];
2805
2806                 if (nh_iter == nh)
2807                         break;
2808                 if (nh_iter->offloaded)
2809                         adj_hash_index += nh_iter->num_adj_entries;
2810         }
2811
2812         *p_adj_hash_index = adj_hash_index;
2813         return 0;
2814 }
2815
2816 struct mlxsw_sp_rif *mlxsw_sp_nexthop_rif(struct mlxsw_sp_nexthop *nh)
2817 {
2818         return nh->rif;
2819 }
2820
2821 bool mlxsw_sp_nexthop_group_has_ipip(struct mlxsw_sp_nexthop *nh)
2822 {
2823         struct mlxsw_sp_nexthop_group *nh_grp = nh->nh_grp;
2824         int i;
2825
2826         for (i = 0; i < nh_grp->count; i++) {
2827                 struct mlxsw_sp_nexthop *nh_iter = &nh_grp->nexthops[i];
2828
2829                 if (nh_iter->type == MLXSW_SP_NEXTHOP_TYPE_IPIP)
2830                         return true;
2831         }
2832         return false;
2833 }
2834
2835 static struct fib_info *
2836 mlxsw_sp_nexthop4_group_fi(const struct mlxsw_sp_nexthop_group *nh_grp)
2837 {
2838         return nh_grp->priv;
2839 }
2840
2841 struct mlxsw_sp_nexthop_group_cmp_arg {
2842         enum mlxsw_sp_l3proto proto;
2843         union {
2844                 struct fib_info *fi;
2845                 struct mlxsw_sp_fib6_entry *fib6_entry;
2846         };
2847 };
2848
2849 static bool
2850 mlxsw_sp_nexthop6_group_has_nexthop(const struct mlxsw_sp_nexthop_group *nh_grp,
2851                                     const struct in6_addr *gw, int ifindex,
2852                                     int weight)
2853 {
2854         int i;
2855
2856         for (i = 0; i < nh_grp->count; i++) {
2857                 const struct mlxsw_sp_nexthop *nh;
2858
2859                 nh = &nh_grp->nexthops[i];
2860                 if (nh->ifindex == ifindex && nh->nh_weight == weight &&
2861                     ipv6_addr_equal(gw, (struct in6_addr *) nh->gw_addr))
2862                         return true;
2863         }
2864
2865         return false;
2866 }
2867
2868 static bool
2869 mlxsw_sp_nexthop6_group_cmp(const struct mlxsw_sp_nexthop_group *nh_grp,
2870                             const struct mlxsw_sp_fib6_entry *fib6_entry)
2871 {
2872         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
2873
2874         if (nh_grp->count != fib6_entry->nrt6)
2875                 return false;
2876
2877         list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
2878                 struct fib6_nh *fib6_nh = mlxsw_sp_rt6->rt->fib6_nh;
2879                 struct in6_addr *gw;
2880                 int ifindex, weight;
2881
2882                 ifindex = fib6_nh->fib_nh_dev->ifindex;
2883                 weight = fib6_nh->fib_nh_weight;
2884                 gw = &fib6_nh->fib_nh_gw6;
2885                 if (!mlxsw_sp_nexthop6_group_has_nexthop(nh_grp, gw, ifindex,
2886                                                          weight))
2887                         return false;
2888         }
2889
2890         return true;
2891 }
2892
2893 static int
2894 mlxsw_sp_nexthop_group_cmp(struct rhashtable_compare_arg *arg, const void *ptr)
2895 {
2896         const struct mlxsw_sp_nexthop_group_cmp_arg *cmp_arg = arg->key;
2897         const struct mlxsw_sp_nexthop_group *nh_grp = ptr;
2898
2899         switch (cmp_arg->proto) {
2900         case MLXSW_SP_L3_PROTO_IPV4:
2901                 return cmp_arg->fi != mlxsw_sp_nexthop4_group_fi(nh_grp);
2902         case MLXSW_SP_L3_PROTO_IPV6:
2903                 return !mlxsw_sp_nexthop6_group_cmp(nh_grp,
2904                                                     cmp_arg->fib6_entry);
2905         default:
2906                 WARN_ON(1);
2907                 return 1;
2908         }
2909 }
2910
2911 static int
2912 mlxsw_sp_nexthop_group_type(const struct mlxsw_sp_nexthop_group *nh_grp)
2913 {
2914         return nh_grp->neigh_tbl->family;
2915 }
2916
2917 static u32 mlxsw_sp_nexthop_group_hash_obj(const void *data, u32 len, u32 seed)
2918 {
2919         const struct mlxsw_sp_nexthop_group *nh_grp = data;
2920         const struct mlxsw_sp_nexthop *nh;
2921         struct fib_info *fi;
2922         unsigned int val;
2923         int i;
2924
2925         switch (mlxsw_sp_nexthop_group_type(nh_grp)) {
2926         case AF_INET:
2927                 fi = mlxsw_sp_nexthop4_group_fi(nh_grp);
2928                 return jhash(&fi, sizeof(fi), seed);
2929         case AF_INET6:
2930                 val = nh_grp->count;
2931                 for (i = 0; i < nh_grp->count; i++) {
2932                         nh = &nh_grp->nexthops[i];
2933                         val ^= jhash(&nh->ifindex, sizeof(nh->ifindex), seed);
2934                 }
2935                 return jhash(&val, sizeof(val), seed);
2936         default:
2937                 WARN_ON(1);
2938                 return 0;
2939         }
2940 }
2941
2942 static u32
2943 mlxsw_sp_nexthop6_group_hash(struct mlxsw_sp_fib6_entry *fib6_entry, u32 seed)
2944 {
2945         unsigned int val = fib6_entry->nrt6;
2946         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
2947         struct net_device *dev;
2948
2949         list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
2950                 dev = mlxsw_sp_rt6->rt->fib6_nh->fib_nh_dev;
2951                 val ^= jhash(&dev->ifindex, sizeof(dev->ifindex), seed);
2952         }
2953
2954         return jhash(&val, sizeof(val), seed);
2955 }
2956
2957 static u32
2958 mlxsw_sp_nexthop_group_hash(const void *data, u32 len, u32 seed)
2959 {
2960         const struct mlxsw_sp_nexthop_group_cmp_arg *cmp_arg = data;
2961
2962         switch (cmp_arg->proto) {
2963         case MLXSW_SP_L3_PROTO_IPV4:
2964                 return jhash(&cmp_arg->fi, sizeof(cmp_arg->fi), seed);
2965         case MLXSW_SP_L3_PROTO_IPV6:
2966                 return mlxsw_sp_nexthop6_group_hash(cmp_arg->fib6_entry, seed);
2967         default:
2968                 WARN_ON(1);
2969                 return 0;
2970         }
2971 }
2972
2973 static const struct rhashtable_params mlxsw_sp_nexthop_group_ht_params = {
2974         .head_offset = offsetof(struct mlxsw_sp_nexthop_group, ht_node),
2975         .hashfn      = mlxsw_sp_nexthop_group_hash,
2976         .obj_hashfn  = mlxsw_sp_nexthop_group_hash_obj,
2977         .obj_cmpfn   = mlxsw_sp_nexthop_group_cmp,
2978 };
2979
2980 static int mlxsw_sp_nexthop_group_insert(struct mlxsw_sp *mlxsw_sp,
2981                                          struct mlxsw_sp_nexthop_group *nh_grp)
2982 {
2983         if (mlxsw_sp_nexthop_group_type(nh_grp) == AF_INET6 &&
2984             !nh_grp->gateway)
2985                 return 0;
2986
2987         return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_group_ht,
2988                                       &nh_grp->ht_node,
2989                                       mlxsw_sp_nexthop_group_ht_params);
2990 }
2991
2992 static void mlxsw_sp_nexthop_group_remove(struct mlxsw_sp *mlxsw_sp,
2993                                           struct mlxsw_sp_nexthop_group *nh_grp)
2994 {
2995         if (mlxsw_sp_nexthop_group_type(nh_grp) == AF_INET6 &&
2996             !nh_grp->gateway)
2997                 return;
2998
2999         rhashtable_remove_fast(&mlxsw_sp->router->nexthop_group_ht,
3000                                &nh_grp->ht_node,
3001                                mlxsw_sp_nexthop_group_ht_params);
3002 }
3003
3004 static struct mlxsw_sp_nexthop_group *
3005 mlxsw_sp_nexthop4_group_lookup(struct mlxsw_sp *mlxsw_sp,
3006                                struct fib_info *fi)
3007 {
3008         struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
3009
3010         cmp_arg.proto = MLXSW_SP_L3_PROTO_IPV4;
3011         cmp_arg.fi = fi;
3012         return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
3013                                       &cmp_arg,
3014                                       mlxsw_sp_nexthop_group_ht_params);
3015 }
3016
3017 static struct mlxsw_sp_nexthop_group *
3018 mlxsw_sp_nexthop6_group_lookup(struct mlxsw_sp *mlxsw_sp,
3019                                struct mlxsw_sp_fib6_entry *fib6_entry)
3020 {
3021         struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
3022
3023         cmp_arg.proto = MLXSW_SP_L3_PROTO_IPV6;
3024         cmp_arg.fib6_entry = fib6_entry;
3025         return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
3026                                       &cmp_arg,
3027                                       mlxsw_sp_nexthop_group_ht_params);
3028 }
3029
3030 static const struct rhashtable_params mlxsw_sp_nexthop_ht_params = {
3031         .key_offset = offsetof(struct mlxsw_sp_nexthop, key),
3032         .head_offset = offsetof(struct mlxsw_sp_nexthop, ht_node),
3033         .key_len = sizeof(struct mlxsw_sp_nexthop_key),
3034 };
3035
3036 static int mlxsw_sp_nexthop_insert(struct mlxsw_sp *mlxsw_sp,
3037                                    struct mlxsw_sp_nexthop *nh)
3038 {
3039         return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_ht,
3040                                       &nh->ht_node, mlxsw_sp_nexthop_ht_params);
3041 }
3042
3043 static void mlxsw_sp_nexthop_remove(struct mlxsw_sp *mlxsw_sp,
3044                                     struct mlxsw_sp_nexthop *nh)
3045 {
3046         rhashtable_remove_fast(&mlxsw_sp->router->nexthop_ht, &nh->ht_node,
3047                                mlxsw_sp_nexthop_ht_params);
3048 }
3049
3050 static struct mlxsw_sp_nexthop *
3051 mlxsw_sp_nexthop_lookup(struct mlxsw_sp *mlxsw_sp,
3052                         struct mlxsw_sp_nexthop_key key)
3053 {
3054         return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_ht, &key,
3055                                       mlxsw_sp_nexthop_ht_params);
3056 }
3057
3058 static int mlxsw_sp_adj_index_mass_update_vr(struct mlxsw_sp *mlxsw_sp,
3059                                              const struct mlxsw_sp_fib *fib,
3060                                              u32 adj_index, u16 ecmp_size,
3061                                              u32 new_adj_index,
3062                                              u16 new_ecmp_size)
3063 {
3064         char raleu_pl[MLXSW_REG_RALEU_LEN];
3065
3066         mlxsw_reg_raleu_pack(raleu_pl,
3067                              (enum mlxsw_reg_ralxx_protocol) fib->proto,
3068                              fib->vr->id, adj_index, ecmp_size, new_adj_index,
3069                              new_ecmp_size);
3070         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raleu), raleu_pl);
3071 }
3072
3073 static int mlxsw_sp_adj_index_mass_update(struct mlxsw_sp *mlxsw_sp,
3074                                           struct mlxsw_sp_nexthop_group *nh_grp,
3075                                           u32 old_adj_index, u16 old_ecmp_size)
3076 {
3077         struct mlxsw_sp_fib_entry *fib_entry;
3078         struct mlxsw_sp_fib *fib = NULL;
3079         int err;
3080
3081         list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
3082                 if (fib == fib_entry->fib_node->fib)
3083                         continue;
3084                 fib = fib_entry->fib_node->fib;
3085                 err = mlxsw_sp_adj_index_mass_update_vr(mlxsw_sp, fib,
3086                                                         old_adj_index,
3087                                                         old_ecmp_size,
3088                                                         nh_grp->adj_index,
3089                                                         nh_grp->ecmp_size);
3090                 if (err)
3091                         return err;
3092         }
3093         return 0;
3094 }
3095
3096 static int __mlxsw_sp_nexthop_update(struct mlxsw_sp *mlxsw_sp, u32 adj_index,
3097                                      struct mlxsw_sp_nexthop *nh)
3098 {
3099         struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
3100         char ratr_pl[MLXSW_REG_RATR_LEN];
3101
3102         mlxsw_reg_ratr_pack(ratr_pl, MLXSW_REG_RATR_OP_WRITE_WRITE_ENTRY,
3103                             true, MLXSW_REG_RATR_TYPE_ETHERNET,
3104                             adj_index, neigh_entry->rif);
3105         mlxsw_reg_ratr_eth_entry_pack(ratr_pl, neigh_entry->ha);
3106         if (nh->counter_valid)
3107                 mlxsw_reg_ratr_counter_pack(ratr_pl, nh->counter_index, true);
3108         else
3109                 mlxsw_reg_ratr_counter_pack(ratr_pl, 0, false);
3110
3111         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ratr), ratr_pl);
3112 }
3113
3114 int mlxsw_sp_nexthop_update(struct mlxsw_sp *mlxsw_sp, u32 adj_index,
3115                             struct mlxsw_sp_nexthop *nh)
3116 {
3117         int i;
3118
3119         for (i = 0; i < nh->num_adj_entries; i++) {
3120                 int err;
3121
3122                 err = __mlxsw_sp_nexthop_update(mlxsw_sp, adj_index + i, nh);
3123                 if (err)
3124                         return err;
3125         }
3126
3127         return 0;
3128 }
3129
3130 static int __mlxsw_sp_nexthop_ipip_update(struct mlxsw_sp *mlxsw_sp,
3131                                           u32 adj_index,
3132                                           struct mlxsw_sp_nexthop *nh)
3133 {
3134         const struct mlxsw_sp_ipip_ops *ipip_ops;
3135
3136         ipip_ops = mlxsw_sp->router->ipip_ops_arr[nh->ipip_entry->ipipt];
3137         return ipip_ops->nexthop_update(mlxsw_sp, adj_index, nh->ipip_entry);
3138 }
3139
3140 static int mlxsw_sp_nexthop_ipip_update(struct mlxsw_sp *mlxsw_sp,
3141                                         u32 adj_index,
3142                                         struct mlxsw_sp_nexthop *nh)
3143 {
3144         int i;
3145
3146         for (i = 0; i < nh->num_adj_entries; i++) {
3147                 int err;
3148
3149                 err = __mlxsw_sp_nexthop_ipip_update(mlxsw_sp, adj_index + i,
3150                                                      nh);
3151                 if (err)
3152                         return err;
3153         }
3154
3155         return 0;
3156 }
3157
3158 static int
3159 mlxsw_sp_nexthop_group_update(struct mlxsw_sp *mlxsw_sp,
3160                               struct mlxsw_sp_nexthop_group *nh_grp,
3161                               bool reallocate)
3162 {
3163         u32 adj_index = nh_grp->adj_index; /* base */
3164         struct mlxsw_sp_nexthop *nh;
3165         int i;
3166         int err;
3167
3168         for (i = 0; i < nh_grp->count; i++) {
3169                 nh = &nh_grp->nexthops[i];
3170
3171                 if (!nh->should_offload) {
3172                         nh->offloaded = 0;
3173                         continue;
3174                 }
3175
3176                 if (nh->update || reallocate) {
3177                         switch (nh->type) {
3178                         case MLXSW_SP_NEXTHOP_TYPE_ETH:
3179                                 err = mlxsw_sp_nexthop_update
3180                                             (mlxsw_sp, adj_index, nh);
3181                                 break;
3182                         case MLXSW_SP_NEXTHOP_TYPE_IPIP:
3183                                 err = mlxsw_sp_nexthop_ipip_update
3184                                             (mlxsw_sp, adj_index, nh);
3185                                 break;
3186                         }
3187                         if (err)
3188                                 return err;
3189                         nh->update = 0;
3190                         nh->offloaded = 1;
3191                 }
3192                 adj_index += nh->num_adj_entries;
3193         }
3194         return 0;
3195 }
3196
3197 static bool
3198 mlxsw_sp_fib_node_entry_is_first(const struct mlxsw_sp_fib_node *fib_node,
3199                                  const struct mlxsw_sp_fib_entry *fib_entry);
3200
3201 static int
3202 mlxsw_sp_nexthop_fib_entries_update(struct mlxsw_sp *mlxsw_sp,
3203                                     struct mlxsw_sp_nexthop_group *nh_grp)
3204 {
3205         struct mlxsw_sp_fib_entry *fib_entry;
3206         int err;
3207
3208         list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
3209                 if (!mlxsw_sp_fib_node_entry_is_first(fib_entry->fib_node,
3210                                                       fib_entry))
3211                         continue;
3212                 err = mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
3213                 if (err)
3214                         return err;
3215         }
3216         return 0;
3217 }
3218
3219 static void
3220 mlxsw_sp_fib_entry_offload_refresh(struct mlxsw_sp_fib_entry *fib_entry,
3221                                    enum mlxsw_reg_ralue_op op, int err);
3222
3223 static void
3224 mlxsw_sp_nexthop_fib_entries_refresh(struct mlxsw_sp_nexthop_group *nh_grp)
3225 {
3226         enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_WRITE;
3227         struct mlxsw_sp_fib_entry *fib_entry;
3228
3229         list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
3230                 if (!mlxsw_sp_fib_node_entry_is_first(fib_entry->fib_node,
3231                                                       fib_entry))
3232                         continue;
3233                 mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, 0);
3234         }
3235 }
3236
3237 static void mlxsw_sp_adj_grp_size_round_up(u16 *p_adj_grp_size)
3238 {
3239         /* Valid sizes for an adjacency group are:
3240          * 1-64, 512, 1024, 2048 and 4096.
3241          */
3242         if (*p_adj_grp_size <= 64)
3243                 return;
3244         else if (*p_adj_grp_size <= 512)
3245                 *p_adj_grp_size = 512;
3246         else if (*p_adj_grp_size <= 1024)
3247                 *p_adj_grp_size = 1024;
3248         else if (*p_adj_grp_size <= 2048)
3249                 *p_adj_grp_size = 2048;
3250         else
3251                 *p_adj_grp_size = 4096;
3252 }
3253
3254 static void mlxsw_sp_adj_grp_size_round_down(u16 *p_adj_grp_size,
3255                                              unsigned int alloc_size)
3256 {
3257         if (alloc_size >= 4096)
3258                 *p_adj_grp_size = 4096;
3259         else if (alloc_size >= 2048)
3260                 *p_adj_grp_size = 2048;
3261         else if (alloc_size >= 1024)
3262                 *p_adj_grp_size = 1024;
3263         else if (alloc_size >= 512)
3264                 *p_adj_grp_size = 512;
3265 }
3266
3267 static int mlxsw_sp_fix_adj_grp_size(struct mlxsw_sp *mlxsw_sp,
3268                                      u16 *p_adj_grp_size)
3269 {
3270         unsigned int alloc_size;
3271         int err;
3272
3273         /* Round up the requested group size to the next size supported
3274          * by the device and make sure the request can be satisfied.
3275          */
3276         mlxsw_sp_adj_grp_size_round_up(p_adj_grp_size);
3277         err = mlxsw_sp_kvdl_alloc_count_query(mlxsw_sp,
3278                                               MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
3279                                               *p_adj_grp_size, &alloc_size);
3280         if (err)
3281                 return err;
3282         /* It is possible the allocation results in more allocated
3283          * entries than requested. Try to use as much of them as
3284          * possible.
3285          */
3286         mlxsw_sp_adj_grp_size_round_down(p_adj_grp_size, alloc_size);
3287
3288         return 0;
3289 }
3290
3291 static void
3292 mlxsw_sp_nexthop_group_normalize(struct mlxsw_sp_nexthop_group *nh_grp)
3293 {
3294         int i, g = 0, sum_norm_weight = 0;
3295         struct mlxsw_sp_nexthop *nh;
3296
3297         for (i = 0; i < nh_grp->count; i++) {
3298                 nh = &nh_grp->nexthops[i];
3299
3300                 if (!nh->should_offload)
3301                         continue;
3302                 if (g > 0)
3303                         g = gcd(nh->nh_weight, g);
3304                 else
3305                         g = nh->nh_weight;
3306         }
3307
3308         for (i = 0; i < nh_grp->count; i++) {
3309                 nh = &nh_grp->nexthops[i];
3310
3311                 if (!nh->should_offload)
3312                         continue;
3313                 nh->norm_nh_weight = nh->nh_weight / g;
3314                 sum_norm_weight += nh->norm_nh_weight;
3315         }
3316
3317         nh_grp->sum_norm_weight = sum_norm_weight;
3318 }
3319
3320 static void
3321 mlxsw_sp_nexthop_group_rebalance(struct mlxsw_sp_nexthop_group *nh_grp)
3322 {
3323         int total = nh_grp->sum_norm_weight;
3324         u16 ecmp_size = nh_grp->ecmp_size;
3325         int i, weight = 0, lower_bound = 0;
3326
3327         for (i = 0; i < nh_grp->count; i++) {
3328                 struct mlxsw_sp_nexthop *nh = &nh_grp->nexthops[i];
3329                 int upper_bound;
3330
3331                 if (!nh->should_offload)
3332                         continue;
3333                 weight += nh->norm_nh_weight;
3334                 upper_bound = DIV_ROUND_CLOSEST(ecmp_size * weight, total);
3335                 nh->num_adj_entries = upper_bound - lower_bound;
3336                 lower_bound = upper_bound;
3337         }
3338 }
3339
3340 static void
3341 mlxsw_sp_nexthop_group_refresh(struct mlxsw_sp *mlxsw_sp,
3342                                struct mlxsw_sp_nexthop_group *nh_grp)
3343 {
3344         u16 ecmp_size, old_ecmp_size;
3345         struct mlxsw_sp_nexthop *nh;
3346         bool offload_change = false;
3347         u32 adj_index;
3348         bool old_adj_index_valid;
3349         u32 old_adj_index;
3350         int i;
3351         int err;
3352
3353         if (!nh_grp->gateway) {
3354                 mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
3355                 return;
3356         }
3357
3358         for (i = 0; i < nh_grp->count; i++) {
3359                 nh = &nh_grp->nexthops[i];
3360
3361                 if (nh->should_offload != nh->offloaded) {
3362                         offload_change = true;
3363                         if (nh->should_offload)
3364                                 nh->update = 1;
3365                 }
3366         }
3367         if (!offload_change) {
3368                 /* Nothing was added or removed, so no need to reallocate. Just
3369                  * update MAC on existing adjacency indexes.
3370                  */
3371                 err = mlxsw_sp_nexthop_group_update(mlxsw_sp, nh_grp, false);
3372                 if (err) {
3373                         dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
3374                         goto set_trap;
3375                 }
3376                 return;
3377         }
3378         mlxsw_sp_nexthop_group_normalize(nh_grp);
3379         if (!nh_grp->sum_norm_weight)
3380                 /* No neigh of this group is connected so we just set
3381                  * the trap and let everthing flow through kernel.
3382                  */
3383                 goto set_trap;
3384
3385         ecmp_size = nh_grp->sum_norm_weight;
3386         err = mlxsw_sp_fix_adj_grp_size(mlxsw_sp, &ecmp_size);
3387         if (err)
3388                 /* No valid allocation size available. */
3389                 goto set_trap;
3390
3391         err = mlxsw_sp_kvdl_alloc(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
3392                                   ecmp_size, &adj_index);
3393         if (err) {
3394                 /* We ran out of KVD linear space, just set the
3395                  * trap and let everything flow through kernel.
3396                  */
3397                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to allocate KVD linear area for nexthop group.\n");
3398                 goto set_trap;
3399         }
3400         old_adj_index_valid = nh_grp->adj_index_valid;
3401         old_adj_index = nh_grp->adj_index;
3402         old_ecmp_size = nh_grp->ecmp_size;
3403         nh_grp->adj_index_valid = 1;
3404         nh_grp->adj_index = adj_index;
3405         nh_grp->ecmp_size = ecmp_size;
3406         mlxsw_sp_nexthop_group_rebalance(nh_grp);
3407         err = mlxsw_sp_nexthop_group_update(mlxsw_sp, nh_grp, true);
3408         if (err) {
3409                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
3410                 goto set_trap;
3411         }
3412
3413         if (!old_adj_index_valid) {
3414                 /* The trap was set for fib entries, so we have to call
3415                  * fib entry update to unset it and use adjacency index.
3416                  */
3417                 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
3418                 if (err) {
3419                         dev_warn(mlxsw_sp->bus_info->dev, "Failed to add adjacency index to fib entries.\n");
3420                         goto set_trap;
3421                 }
3422                 return;
3423         }
3424
3425         err = mlxsw_sp_adj_index_mass_update(mlxsw_sp, nh_grp,
3426                                              old_adj_index, old_ecmp_size);
3427         mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
3428                            old_ecmp_size, old_adj_index);
3429         if (err) {
3430                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to mass-update adjacency index for nexthop group.\n");
3431                 goto set_trap;
3432         }
3433
3434         /* Offload state within the group changed, so update the flags. */
3435         mlxsw_sp_nexthop_fib_entries_refresh(nh_grp);
3436
3437         return;
3438
3439 set_trap:
3440         old_adj_index_valid = nh_grp->adj_index_valid;
3441         nh_grp->adj_index_valid = 0;
3442         for (i = 0; i < nh_grp->count; i++) {
3443                 nh = &nh_grp->nexthops[i];
3444                 nh->offloaded = 0;
3445         }
3446         err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
3447         if (err)
3448                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to set traps for fib entries.\n");
3449         if (old_adj_index_valid)
3450                 mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ,
3451                                    nh_grp->ecmp_size, nh_grp->adj_index);
3452 }
3453
3454 static void __mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp_nexthop *nh,
3455                                             bool removing)
3456 {
3457         if (!removing)
3458                 nh->should_offload = 1;
3459         else
3460                 nh->should_offload = 0;
3461         nh->update = 1;
3462 }
3463
3464 static int
3465 mlxsw_sp_nexthop_dead_neigh_replace(struct mlxsw_sp *mlxsw_sp,
3466                                     struct mlxsw_sp_neigh_entry *neigh_entry)
3467 {
3468         struct neighbour *n, *old_n = neigh_entry->key.n;
3469         struct mlxsw_sp_nexthop *nh;
3470         bool entry_connected;
3471         u8 nud_state, dead;
3472         int err;
3473
3474         nh = list_first_entry(&neigh_entry->nexthop_list,
3475                               struct mlxsw_sp_nexthop, neigh_list_node);
3476
3477         n = neigh_lookup(nh->nh_grp->neigh_tbl, &nh->gw_addr, nh->rif->dev);
3478         if (!n) {
3479                 n = neigh_create(nh->nh_grp->neigh_tbl, &nh->gw_addr,
3480                                  nh->rif->dev);
3481                 if (IS_ERR(n))
3482                         return PTR_ERR(n);
3483                 neigh_event_send(n, NULL);
3484         }
3485
3486         mlxsw_sp_neigh_entry_remove(mlxsw_sp, neigh_entry);
3487         neigh_entry->key.n = n;
3488         err = mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry);
3489         if (err)
3490                 goto err_neigh_entry_insert;
3491
3492         read_lock_bh(&n->lock);
3493         nud_state = n->nud_state;
3494         dead = n->dead;
3495         read_unlock_bh(&n->lock);
3496         entry_connected = nud_state & NUD_VALID && !dead;
3497
3498         list_for_each_entry(nh, &neigh_entry->nexthop_list,
3499                             neigh_list_node) {
3500                 neigh_release(old_n);
3501                 neigh_clone(n);
3502                 __mlxsw_sp_nexthop_neigh_update(nh, !entry_connected);
3503                 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
3504         }
3505
3506         neigh_release(n);
3507
3508         return 0;
3509
3510 err_neigh_entry_insert:
3511         neigh_entry->key.n = old_n;
3512         mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry);
3513         neigh_release(n);
3514         return err;
3515 }
3516
3517 static void
3518 mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
3519                               struct mlxsw_sp_neigh_entry *neigh_entry,
3520                               bool removing, bool dead)
3521 {
3522         struct mlxsw_sp_nexthop *nh;
3523
3524         if (list_empty(&neigh_entry->nexthop_list))
3525                 return;
3526
3527         if (dead) {
3528                 int err;
3529
3530                 err = mlxsw_sp_nexthop_dead_neigh_replace(mlxsw_sp,
3531                                                           neigh_entry);
3532                 if (err)
3533                         dev_err(mlxsw_sp->bus_info->dev, "Failed to replace dead neigh\n");
3534                 return;
3535         }
3536
3537         list_for_each_entry(nh, &neigh_entry->nexthop_list,
3538                             neigh_list_node) {
3539                 __mlxsw_sp_nexthop_neigh_update(nh, removing);
3540                 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
3541         }
3542 }
3543
3544 static void mlxsw_sp_nexthop_rif_init(struct mlxsw_sp_nexthop *nh,
3545                                       struct mlxsw_sp_rif *rif)
3546 {
3547         if (nh->rif)
3548                 return;
3549
3550         nh->rif = rif;
3551         list_add(&nh->rif_list_node, &rif->nexthop_list);
3552 }
3553
3554 static void mlxsw_sp_nexthop_rif_fini(struct mlxsw_sp_nexthop *nh)
3555 {
3556         if (!nh->rif)
3557                 return;
3558
3559         list_del(&nh->rif_list_node);
3560         nh->rif = NULL;
3561 }
3562
3563 static int mlxsw_sp_nexthop_neigh_init(struct mlxsw_sp *mlxsw_sp,
3564                                        struct mlxsw_sp_nexthop *nh)
3565 {
3566         struct mlxsw_sp_neigh_entry *neigh_entry;
3567         struct neighbour *n;
3568         u8 nud_state, dead;
3569         int err;
3570
3571         if (!nh->nh_grp->gateway || nh->neigh_entry)
3572                 return 0;
3573
3574         /* Take a reference of neigh here ensuring that neigh would
3575          * not be destructed before the nexthop entry is finished.
3576          * The reference is taken either in neigh_lookup() or
3577          * in neigh_create() in case n is not found.
3578          */
3579         n = neigh_lookup(nh->nh_grp->neigh_tbl, &nh->gw_addr, nh->rif->dev);
3580         if (!n) {
3581                 n = neigh_create(nh->nh_grp->neigh_tbl, &nh->gw_addr,
3582                                  nh->rif->dev);
3583                 if (IS_ERR(n))
3584                         return PTR_ERR(n);
3585                 neigh_event_send(n, NULL);
3586         }
3587         neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
3588         if (!neigh_entry) {
3589                 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
3590                 if (IS_ERR(neigh_entry)) {
3591                         err = -EINVAL;
3592                         goto err_neigh_entry_create;
3593                 }
3594         }
3595
3596         /* If that is the first nexthop connected to that neigh, add to
3597          * nexthop_neighs_list
3598          */
3599         if (list_empty(&neigh_entry->nexthop_list))
3600                 list_add_tail(&neigh_entry->nexthop_neighs_list_node,
3601                               &mlxsw_sp->router->nexthop_neighs_list);
3602
3603         nh->neigh_entry = neigh_entry;
3604         list_add_tail(&nh->neigh_list_node, &neigh_entry->nexthop_list);
3605         read_lock_bh(&n->lock);
3606         nud_state = n->nud_state;
3607         dead = n->dead;
3608         read_unlock_bh(&n->lock);
3609         __mlxsw_sp_nexthop_neigh_update(nh, !(nud_state & NUD_VALID && !dead));
3610
3611         return 0;
3612
3613 err_neigh_entry_create:
3614         neigh_release(n);
3615         return err;
3616 }
3617
3618 static void mlxsw_sp_nexthop_neigh_fini(struct mlxsw_sp *mlxsw_sp,
3619                                         struct mlxsw_sp_nexthop *nh)
3620 {
3621         struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
3622         struct neighbour *n;
3623
3624         if (!neigh_entry)
3625                 return;
3626         n = neigh_entry->key.n;
3627
3628         __mlxsw_sp_nexthop_neigh_update(nh, true);
3629         list_del(&nh->neigh_list_node);
3630         nh->neigh_entry = NULL;
3631
3632         /* If that is the last nexthop connected to that neigh, remove from
3633          * nexthop_neighs_list
3634          */
3635         if (list_empty(&neigh_entry->nexthop_list))
3636                 list_del(&neigh_entry->nexthop_neighs_list_node);
3637
3638         if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
3639                 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
3640
3641         neigh_release(n);
3642 }
3643
3644 static bool mlxsw_sp_ipip_netdev_ul_up(struct net_device *ol_dev)
3645 {
3646         struct net_device *ul_dev = __mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev);
3647
3648         return ul_dev ? (ul_dev->flags & IFF_UP) : true;
3649 }
3650
3651 static void mlxsw_sp_nexthop_ipip_init(struct mlxsw_sp *mlxsw_sp,
3652                                        struct mlxsw_sp_nexthop *nh,
3653                                        struct mlxsw_sp_ipip_entry *ipip_entry)
3654 {
3655         bool removing;
3656
3657         if (!nh->nh_grp->gateway || nh->ipip_entry)
3658                 return;
3659
3660         nh->ipip_entry = ipip_entry;
3661         removing = !mlxsw_sp_ipip_netdev_ul_up(ipip_entry->ol_dev);
3662         __mlxsw_sp_nexthop_neigh_update(nh, removing);
3663         mlxsw_sp_nexthop_rif_init(nh, &ipip_entry->ol_lb->common);
3664 }
3665
3666 static void mlxsw_sp_nexthop_ipip_fini(struct mlxsw_sp *mlxsw_sp,
3667                                        struct mlxsw_sp_nexthop *nh)
3668 {
3669         struct mlxsw_sp_ipip_entry *ipip_entry = nh->ipip_entry;
3670
3671         if (!ipip_entry)
3672                 return;
3673
3674         __mlxsw_sp_nexthop_neigh_update(nh, true);
3675         nh->ipip_entry = NULL;
3676 }
3677
3678 static bool mlxsw_sp_nexthop4_ipip_type(const struct mlxsw_sp *mlxsw_sp,
3679                                         const struct fib_nh *fib_nh,
3680                                         enum mlxsw_sp_ipip_type *p_ipipt)
3681 {
3682         struct net_device *dev = fib_nh->fib_nh_dev;
3683
3684         return dev &&
3685                fib_nh->nh_parent->fib_type == RTN_UNICAST &&
3686                mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, p_ipipt);
3687 }
3688
3689 static void mlxsw_sp_nexthop_type_fini(struct mlxsw_sp *mlxsw_sp,
3690                                        struct mlxsw_sp_nexthop *nh)
3691 {
3692         switch (nh->type) {
3693         case MLXSW_SP_NEXTHOP_TYPE_ETH:
3694                 mlxsw_sp_nexthop_neigh_fini(mlxsw_sp, nh);
3695                 mlxsw_sp_nexthop_rif_fini(nh);
3696                 break;
3697         case MLXSW_SP_NEXTHOP_TYPE_IPIP:
3698                 mlxsw_sp_nexthop_rif_fini(nh);
3699                 mlxsw_sp_nexthop_ipip_fini(mlxsw_sp, nh);
3700                 break;
3701         }
3702 }
3703
3704 static int mlxsw_sp_nexthop4_type_init(struct mlxsw_sp *mlxsw_sp,
3705                                        struct mlxsw_sp_nexthop *nh,
3706                                        struct fib_nh *fib_nh)
3707 {
3708         const struct mlxsw_sp_ipip_ops *ipip_ops;
3709         struct net_device *dev = fib_nh->fib_nh_dev;
3710         struct mlxsw_sp_ipip_entry *ipip_entry;
3711         struct mlxsw_sp_rif *rif;
3712         int err;
3713
3714         ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, dev);
3715         if (ipip_entry) {
3716                 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
3717                 if (ipip_ops->can_offload(mlxsw_sp, dev,
3718                                           MLXSW_SP_L3_PROTO_IPV4)) {
3719                         nh->type = MLXSW_SP_NEXTHOP_TYPE_IPIP;
3720                         mlxsw_sp_nexthop_ipip_init(mlxsw_sp, nh, ipip_entry);
3721                         return 0;
3722                 }
3723         }
3724
3725         nh->type = MLXSW_SP_NEXTHOP_TYPE_ETH;
3726         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
3727         if (!rif)
3728                 return 0;
3729
3730         mlxsw_sp_nexthop_rif_init(nh, rif);
3731         err = mlxsw_sp_nexthop_neigh_init(mlxsw_sp, nh);
3732         if (err)
3733                 goto err_neigh_init;
3734
3735         return 0;
3736
3737 err_neigh_init:
3738         mlxsw_sp_nexthop_rif_fini(nh);
3739         return err;
3740 }
3741
3742 static void mlxsw_sp_nexthop4_type_fini(struct mlxsw_sp *mlxsw_sp,
3743                                         struct mlxsw_sp_nexthop *nh)
3744 {
3745         mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
3746 }
3747
3748 static int mlxsw_sp_nexthop4_init(struct mlxsw_sp *mlxsw_sp,
3749                                   struct mlxsw_sp_nexthop_group *nh_grp,
3750                                   struct mlxsw_sp_nexthop *nh,
3751                                   struct fib_nh *fib_nh)
3752 {
3753         struct net_device *dev = fib_nh->fib_nh_dev;
3754         struct in_device *in_dev;
3755         int err;
3756
3757         nh->nh_grp = nh_grp;
3758         nh->key.fib_nh = fib_nh;
3759 #ifdef CONFIG_IP_ROUTE_MULTIPATH
3760         nh->nh_weight = fib_nh->fib_nh_weight;
3761 #else
3762         nh->nh_weight = 1;
3763 #endif
3764         memcpy(&nh->gw_addr, &fib_nh->fib_nh_gw4, sizeof(fib_nh->fib_nh_gw4));
3765         err = mlxsw_sp_nexthop_insert(mlxsw_sp, nh);
3766         if (err)
3767                 return err;
3768
3769         mlxsw_sp_nexthop_counter_alloc(mlxsw_sp, nh);
3770         list_add_tail(&nh->router_list_node, &mlxsw_sp->router->nexthop_list);
3771
3772         if (!dev)
3773                 return 0;
3774
3775         in_dev = __in_dev_get_rtnl(dev);
3776         if (in_dev && IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
3777             fib_nh->fib_nh_flags & RTNH_F_LINKDOWN)
3778                 return 0;
3779
3780         err = mlxsw_sp_nexthop4_type_init(mlxsw_sp, nh, fib_nh);
3781         if (err)
3782                 goto err_nexthop_neigh_init;
3783
3784         return 0;
3785
3786 err_nexthop_neigh_init:
3787         mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
3788         return err;
3789 }
3790
3791 static void mlxsw_sp_nexthop4_fini(struct mlxsw_sp *mlxsw_sp,
3792                                    struct mlxsw_sp_nexthop *nh)
3793 {
3794         mlxsw_sp_nexthop4_type_fini(mlxsw_sp, nh);
3795         list_del(&nh->router_list_node);
3796         mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
3797         mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
3798 }
3799
3800 static void mlxsw_sp_nexthop4_event(struct mlxsw_sp *mlxsw_sp,
3801                                     unsigned long event, struct fib_nh *fib_nh)
3802 {
3803         struct mlxsw_sp_nexthop_key key;
3804         struct mlxsw_sp_nexthop *nh;
3805
3806         if (mlxsw_sp->router->aborted)
3807                 return;
3808
3809         key.fib_nh = fib_nh;
3810         nh = mlxsw_sp_nexthop_lookup(mlxsw_sp, key);
3811         if (WARN_ON_ONCE(!nh))
3812                 return;
3813
3814         switch (event) {
3815         case FIB_EVENT_NH_ADD:
3816                 mlxsw_sp_nexthop4_type_init(mlxsw_sp, nh, fib_nh);
3817                 break;
3818         case FIB_EVENT_NH_DEL:
3819                 mlxsw_sp_nexthop4_type_fini(mlxsw_sp, nh);
3820                 break;
3821         }
3822
3823         mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
3824 }
3825
3826 static void mlxsw_sp_nexthop_rif_update(struct mlxsw_sp *mlxsw_sp,
3827                                         struct mlxsw_sp_rif *rif)
3828 {
3829         struct mlxsw_sp_nexthop *nh;
3830         bool removing;
3831
3832         list_for_each_entry(nh, &rif->nexthop_list, rif_list_node) {
3833                 switch (nh->type) {
3834                 case MLXSW_SP_NEXTHOP_TYPE_ETH:
3835                         removing = false;
3836                         break;
3837                 case MLXSW_SP_NEXTHOP_TYPE_IPIP:
3838                         removing = !mlxsw_sp_ipip_netdev_ul_up(rif->dev);
3839                         break;
3840                 default:
3841                         WARN_ON(1);
3842                         continue;
3843                 }
3844
3845                 __mlxsw_sp_nexthop_neigh_update(nh, removing);
3846                 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
3847         }
3848 }
3849
3850 static void mlxsw_sp_nexthop_rif_migrate(struct mlxsw_sp *mlxsw_sp,
3851                                          struct mlxsw_sp_rif *old_rif,
3852                                          struct mlxsw_sp_rif *new_rif)
3853 {
3854         struct mlxsw_sp_nexthop *nh;
3855
3856         list_splice_init(&old_rif->nexthop_list, &new_rif->nexthop_list);
3857         list_for_each_entry(nh, &new_rif->nexthop_list, rif_list_node)
3858                 nh->rif = new_rif;
3859         mlxsw_sp_nexthop_rif_update(mlxsw_sp, new_rif);
3860 }
3861
3862 static void mlxsw_sp_nexthop_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
3863                                            struct mlxsw_sp_rif *rif)
3864 {
3865         struct mlxsw_sp_nexthop *nh, *tmp;
3866
3867         list_for_each_entry_safe(nh, tmp, &rif->nexthop_list, rif_list_node) {
3868                 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
3869                 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
3870         }
3871 }
3872
3873 static bool mlxsw_sp_fi_is_gateway(const struct mlxsw_sp *mlxsw_sp,
3874                                    struct fib_info *fi)
3875 {
3876         const struct fib_nh *nh = fib_info_nh(fi, 0);
3877
3878         return nh->fib_nh_scope == RT_SCOPE_LINK ||
3879                mlxsw_sp_nexthop4_ipip_type(mlxsw_sp, nh, NULL);
3880 }
3881
3882 static struct mlxsw_sp_nexthop_group *
3883 mlxsw_sp_nexthop4_group_create(struct mlxsw_sp *mlxsw_sp, struct fib_info *fi)
3884 {
3885         unsigned int nhs = fib_info_num_path(fi);
3886         struct mlxsw_sp_nexthop_group *nh_grp;
3887         struct mlxsw_sp_nexthop *nh;
3888         struct fib_nh *fib_nh;
3889         int i;
3890         int err;
3891
3892         nh_grp = kzalloc(struct_size(nh_grp, nexthops, nhs), GFP_KERNEL);
3893         if (!nh_grp)
3894                 return ERR_PTR(-ENOMEM);
3895         nh_grp->priv = fi;
3896         INIT_LIST_HEAD(&nh_grp->fib_list);
3897         nh_grp->neigh_tbl = &arp_tbl;
3898
3899         nh_grp->gateway = mlxsw_sp_fi_is_gateway(mlxsw_sp, fi);
3900         nh_grp->count = nhs;
3901         fib_info_hold(fi);
3902         for (i = 0; i < nh_grp->count; i++) {
3903                 nh = &nh_grp->nexthops[i];
3904                 fib_nh = fib_info_nh(fi, i);
3905                 err = mlxsw_sp_nexthop4_init(mlxsw_sp, nh_grp, nh, fib_nh);
3906                 if (err)
3907                         goto err_nexthop4_init;
3908         }
3909         err = mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
3910         if (err)
3911                 goto err_nexthop_group_insert;
3912         mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
3913         return nh_grp;
3914
3915 err_nexthop_group_insert:
3916 err_nexthop4_init:
3917         for (i--; i >= 0; i--) {
3918                 nh = &nh_grp->nexthops[i];
3919                 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
3920         }
3921         fib_info_put(fi);
3922         kfree(nh_grp);
3923         return ERR_PTR(err);
3924 }
3925
3926 static void
3927 mlxsw_sp_nexthop4_group_destroy(struct mlxsw_sp *mlxsw_sp,
3928                                 struct mlxsw_sp_nexthop_group *nh_grp)
3929 {
3930         struct mlxsw_sp_nexthop *nh;
3931         int i;
3932
3933         mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
3934         for (i = 0; i < nh_grp->count; i++) {
3935                 nh = &nh_grp->nexthops[i];
3936                 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
3937         }
3938         mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
3939         WARN_ON_ONCE(nh_grp->adj_index_valid);
3940         fib_info_put(mlxsw_sp_nexthop4_group_fi(nh_grp));
3941         kfree(nh_grp);
3942 }
3943
3944 static int mlxsw_sp_nexthop4_group_get(struct mlxsw_sp *mlxsw_sp,
3945                                        struct mlxsw_sp_fib_entry *fib_entry,
3946                                        struct fib_info *fi)
3947 {
3948         struct mlxsw_sp_nexthop_group *nh_grp;
3949
3950         nh_grp = mlxsw_sp_nexthop4_group_lookup(mlxsw_sp, fi);
3951         if (!nh_grp) {
3952                 nh_grp = mlxsw_sp_nexthop4_group_create(mlxsw_sp, fi);
3953                 if (IS_ERR(nh_grp))
3954                         return PTR_ERR(nh_grp);
3955         }
3956         list_add_tail(&fib_entry->nexthop_group_node, &nh_grp->fib_list);
3957         fib_entry->nh_group = nh_grp;
3958         return 0;
3959 }
3960
3961 static void mlxsw_sp_nexthop4_group_put(struct mlxsw_sp *mlxsw_sp,
3962                                         struct mlxsw_sp_fib_entry *fib_entry)
3963 {
3964         struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
3965
3966         list_del(&fib_entry->nexthop_group_node);
3967         if (!list_empty(&nh_grp->fib_list))
3968                 return;
3969         mlxsw_sp_nexthop4_group_destroy(mlxsw_sp, nh_grp);
3970 }
3971
3972 static bool
3973 mlxsw_sp_fib4_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
3974 {
3975         struct mlxsw_sp_fib4_entry *fib4_entry;
3976
3977         fib4_entry = container_of(fib_entry, struct mlxsw_sp_fib4_entry,
3978                                   common);
3979         return !fib4_entry->tos;
3980 }
3981
3982 static bool
3983 mlxsw_sp_fib_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
3984 {
3985         struct mlxsw_sp_nexthop_group *nh_group = fib_entry->nh_group;
3986
3987         switch (fib_entry->fib_node->fib->proto) {
3988         case MLXSW_SP_L3_PROTO_IPV4:
3989                 if (!mlxsw_sp_fib4_entry_should_offload(fib_entry))
3990                         return false;
3991                 break;
3992         case MLXSW_SP_L3_PROTO_IPV6:
3993                 break;
3994         }
3995
3996         switch (fib_entry->type) {
3997         case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
3998                 return !!nh_group->adj_index_valid;
3999         case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
4000                 return !!nh_group->nh_rif;
4001         case MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE:
4002         case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
4003         case MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP:
4004                 return true;
4005         default:
4006                 return false;
4007         }
4008 }
4009
4010 static struct mlxsw_sp_nexthop *
4011 mlxsw_sp_rt6_nexthop(struct mlxsw_sp_nexthop_group *nh_grp,
4012                      const struct mlxsw_sp_rt6 *mlxsw_sp_rt6)
4013 {
4014         int i;
4015
4016         for (i = 0; i < nh_grp->count; i++) {
4017                 struct mlxsw_sp_nexthop *nh = &nh_grp->nexthops[i];
4018                 struct fib6_info *rt = mlxsw_sp_rt6->rt;
4019
4020                 if (nh->rif && nh->rif->dev == rt->fib6_nh->fib_nh_dev &&
4021                     ipv6_addr_equal((const struct in6_addr *) &nh->gw_addr,
4022                                     &rt->fib6_nh->fib_nh_gw6))
4023                         return nh;
4024                 continue;
4025         }
4026
4027         return NULL;
4028 }
4029
4030 static void
4031 mlxsw_sp_fib4_entry_offload_set(struct mlxsw_sp_fib_entry *fib_entry)
4032 {
4033         struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
4034         int i;
4035
4036         if (fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_LOCAL ||
4037             fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE ||
4038             fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP ||
4039             fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP) {
4040                 nh_grp->nexthops->key.fib_nh->fib_nh_flags |= RTNH_F_OFFLOAD;
4041                 return;
4042         }
4043
4044         for (i = 0; i < nh_grp->count; i++) {
4045                 struct mlxsw_sp_nexthop *nh = &nh_grp->nexthops[i];
4046
4047                 if (nh->offloaded)
4048                         nh->key.fib_nh->fib_nh_flags |= RTNH_F_OFFLOAD;
4049                 else
4050                         nh->key.fib_nh->fib_nh_flags &= ~RTNH_F_OFFLOAD;
4051         }
4052 }
4053
4054 static void
4055 mlxsw_sp_fib4_entry_offload_unset(struct mlxsw_sp_fib_entry *fib_entry)
4056 {
4057         struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
4058         int i;
4059
4060         if (!list_is_singular(&nh_grp->fib_list))
4061                 return;
4062
4063         for (i = 0; i < nh_grp->count; i++) {
4064                 struct mlxsw_sp_nexthop *nh = &nh_grp->nexthops[i];
4065
4066                 nh->key.fib_nh->fib_nh_flags &= ~RTNH_F_OFFLOAD;
4067         }
4068 }
4069
4070 static void
4071 mlxsw_sp_fib6_entry_offload_set(struct mlxsw_sp_fib_entry *fib_entry)
4072 {
4073         struct mlxsw_sp_fib6_entry *fib6_entry;
4074         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4075
4076         fib6_entry = container_of(fib_entry, struct mlxsw_sp_fib6_entry,
4077                                   common);
4078
4079         if (fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_LOCAL ||
4080             fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE) {
4081                 list_first_entry(&fib6_entry->rt6_list, struct mlxsw_sp_rt6,
4082                                  list)->rt->fib6_nh->fib_nh_flags |= RTNH_F_OFFLOAD;
4083                 return;
4084         }
4085
4086         list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
4087                 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
4088                 struct fib6_nh *fib6_nh = mlxsw_sp_rt6->rt->fib6_nh;
4089                 struct mlxsw_sp_nexthop *nh;
4090
4091                 nh = mlxsw_sp_rt6_nexthop(nh_grp, mlxsw_sp_rt6);
4092                 if (nh && nh->offloaded)
4093                         fib6_nh->fib_nh_flags |= RTNH_F_OFFLOAD;
4094                 else
4095                         fib6_nh->fib_nh_flags &= ~RTNH_F_OFFLOAD;
4096         }
4097 }
4098
4099 static void
4100 mlxsw_sp_fib6_entry_offload_unset(struct mlxsw_sp_fib_entry *fib_entry)
4101 {
4102         struct mlxsw_sp_fib6_entry *fib6_entry;
4103         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4104
4105         fib6_entry = container_of(fib_entry, struct mlxsw_sp_fib6_entry,
4106                                   common);
4107         list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
4108                 struct fib6_info *rt = mlxsw_sp_rt6->rt;
4109
4110                 rt->fib6_nh->fib_nh_flags &= ~RTNH_F_OFFLOAD;
4111         }
4112 }
4113
4114 static void mlxsw_sp_fib_entry_offload_set(struct mlxsw_sp_fib_entry *fib_entry)
4115 {
4116         switch (fib_entry->fib_node->fib->proto) {
4117         case MLXSW_SP_L3_PROTO_IPV4:
4118                 mlxsw_sp_fib4_entry_offload_set(fib_entry);
4119                 break;
4120         case MLXSW_SP_L3_PROTO_IPV6:
4121                 mlxsw_sp_fib6_entry_offload_set(fib_entry);
4122                 break;
4123         }
4124 }
4125
4126 static void
4127 mlxsw_sp_fib_entry_offload_unset(struct mlxsw_sp_fib_entry *fib_entry)
4128 {
4129         switch (fib_entry->fib_node->fib->proto) {
4130         case MLXSW_SP_L3_PROTO_IPV4:
4131                 mlxsw_sp_fib4_entry_offload_unset(fib_entry);
4132                 break;
4133         case MLXSW_SP_L3_PROTO_IPV6:
4134                 mlxsw_sp_fib6_entry_offload_unset(fib_entry);
4135                 break;
4136         }
4137 }
4138
4139 static void
4140 mlxsw_sp_fib_entry_offload_refresh(struct mlxsw_sp_fib_entry *fib_entry,
4141                                    enum mlxsw_reg_ralue_op op, int err)
4142 {
4143         switch (op) {
4144         case MLXSW_REG_RALUE_OP_WRITE_DELETE:
4145                 return mlxsw_sp_fib_entry_offload_unset(fib_entry);
4146         case MLXSW_REG_RALUE_OP_WRITE_WRITE:
4147                 if (err)
4148                         return;
4149                 if (mlxsw_sp_fib_entry_should_offload(fib_entry))
4150                         mlxsw_sp_fib_entry_offload_set(fib_entry);
4151                 else
4152                         mlxsw_sp_fib_entry_offload_unset(fib_entry);
4153                 return;
4154         default:
4155                 return;
4156         }
4157 }
4158
4159 static void
4160 mlxsw_sp_fib_entry_ralue_pack(char *ralue_pl,
4161                               const struct mlxsw_sp_fib_entry *fib_entry,
4162                               enum mlxsw_reg_ralue_op op)
4163 {
4164         struct mlxsw_sp_fib *fib = fib_entry->fib_node->fib;
4165         enum mlxsw_reg_ralxx_protocol proto;
4166         u32 *p_dip;
4167
4168         proto = (enum mlxsw_reg_ralxx_protocol) fib->proto;
4169
4170         switch (fib->proto) {
4171         case MLXSW_SP_L3_PROTO_IPV4:
4172                 p_dip = (u32 *) fib_entry->fib_node->key.addr;
4173                 mlxsw_reg_ralue_pack4(ralue_pl, proto, op, fib->vr->id,
4174                                       fib_entry->fib_node->key.prefix_len,
4175                                       *p_dip);
4176                 break;
4177         case MLXSW_SP_L3_PROTO_IPV6:
4178                 mlxsw_reg_ralue_pack6(ralue_pl, proto, op, fib->vr->id,
4179                                       fib_entry->fib_node->key.prefix_len,
4180                                       fib_entry->fib_node->key.addr);
4181                 break;
4182         }
4183 }
4184
4185 static int mlxsw_sp_adj_discard_write(struct mlxsw_sp *mlxsw_sp, u16 rif_index)
4186 {
4187         u32 adj_discard_index = mlxsw_sp->router->adj_discard_index;
4188         enum mlxsw_reg_ratr_trap_action trap_action;
4189         char ratr_pl[MLXSW_REG_RATR_LEN];
4190         int err;
4191
4192         if (mlxsw_sp->router->adj_discard_index_valid)
4193                 return 0;
4194
4195         err = mlxsw_sp_kvdl_alloc(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
4196                                   &mlxsw_sp->router->adj_discard_index);
4197         if (err)
4198                 return err;
4199
4200         trap_action = MLXSW_REG_RATR_TRAP_ACTION_DISCARD_ERRORS;
4201         mlxsw_reg_ratr_pack(ratr_pl, MLXSW_REG_RATR_OP_WRITE_WRITE_ENTRY, true,
4202                             MLXSW_REG_RATR_TYPE_ETHERNET, adj_discard_index,
4203                             rif_index);
4204         mlxsw_reg_ratr_trap_action_set(ratr_pl, trap_action);
4205         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ratr), ratr_pl);
4206         if (err)
4207                 goto err_ratr_write;
4208
4209         mlxsw_sp->router->adj_discard_index_valid = true;
4210
4211         return 0;
4212
4213 err_ratr_write:
4214         mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
4215                            mlxsw_sp->router->adj_discard_index);
4216         return err;
4217 }
4218
4219 static int mlxsw_sp_fib_entry_op_remote(struct mlxsw_sp *mlxsw_sp,
4220                                         struct mlxsw_sp_fib_entry *fib_entry,
4221                                         enum mlxsw_reg_ralue_op op)
4222 {
4223         struct mlxsw_sp_nexthop_group *nh_group = fib_entry->nh_group;
4224         char ralue_pl[MLXSW_REG_RALUE_LEN];
4225         enum mlxsw_reg_ralue_trap_action trap_action;
4226         u16 trap_id = 0;
4227         u32 adjacency_index = 0;
4228         u16 ecmp_size = 0;
4229         int err;
4230
4231         /* In case the nexthop group adjacency index is valid, use it
4232          * with provided ECMP size. Otherwise, setup trap and pass
4233          * traffic to kernel.
4234          */
4235         if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
4236                 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
4237                 adjacency_index = fib_entry->nh_group->adj_index;
4238                 ecmp_size = fib_entry->nh_group->ecmp_size;
4239         } else if (!nh_group->adj_index_valid && nh_group->count &&
4240                    nh_group->nh_rif) {
4241                 err = mlxsw_sp_adj_discard_write(mlxsw_sp,
4242                                                  nh_group->nh_rif->rif_index);
4243                 if (err)
4244                         return err;
4245                 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
4246                 adjacency_index = mlxsw_sp->router->adj_discard_index;
4247                 ecmp_size = 1;
4248         } else {
4249                 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
4250                 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
4251         }
4252
4253         mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
4254         mlxsw_reg_ralue_act_remote_pack(ralue_pl, trap_action, trap_id,
4255                                         adjacency_index, ecmp_size);
4256         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
4257 }
4258
4259 static int mlxsw_sp_fib_entry_op_local(struct mlxsw_sp *mlxsw_sp,
4260                                        struct mlxsw_sp_fib_entry *fib_entry,
4261                                        enum mlxsw_reg_ralue_op op)
4262 {
4263         struct mlxsw_sp_rif *rif = fib_entry->nh_group->nh_rif;
4264         enum mlxsw_reg_ralue_trap_action trap_action;
4265         char ralue_pl[MLXSW_REG_RALUE_LEN];
4266         u16 trap_id = 0;
4267         u16 rif_index = 0;
4268
4269         if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
4270                 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
4271                 rif_index = rif->rif_index;
4272         } else {
4273                 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
4274                 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
4275         }
4276
4277         mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
4278         mlxsw_reg_ralue_act_local_pack(ralue_pl, trap_action, trap_id,
4279                                        rif_index);
4280         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
4281 }
4282
4283 static int mlxsw_sp_fib_entry_op_trap(struct mlxsw_sp *mlxsw_sp,
4284                                       struct mlxsw_sp_fib_entry *fib_entry,
4285                                       enum mlxsw_reg_ralue_op op)
4286 {
4287         char ralue_pl[MLXSW_REG_RALUE_LEN];
4288
4289         mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
4290         mlxsw_reg_ralue_act_ip2me_pack(ralue_pl);
4291         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
4292 }
4293
4294 static int mlxsw_sp_fib_entry_op_blackhole(struct mlxsw_sp *mlxsw_sp,
4295                                            struct mlxsw_sp_fib_entry *fib_entry,
4296                                            enum mlxsw_reg_ralue_op op)
4297 {
4298         enum mlxsw_reg_ralue_trap_action trap_action;
4299         char ralue_pl[MLXSW_REG_RALUE_LEN];
4300
4301         trap_action = MLXSW_REG_RALUE_TRAP_ACTION_DISCARD_ERROR;
4302         mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
4303         mlxsw_reg_ralue_act_local_pack(ralue_pl, trap_action, 0, 0);
4304         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
4305 }
4306
4307 static int
4308 mlxsw_sp_fib_entry_op_unreachable(struct mlxsw_sp *mlxsw_sp,
4309                                   struct mlxsw_sp_fib_entry *fib_entry,
4310                                   enum mlxsw_reg_ralue_op op)
4311 {
4312         enum mlxsw_reg_ralue_trap_action trap_action;
4313         char ralue_pl[MLXSW_REG_RALUE_LEN];
4314         u16 trap_id;
4315
4316         trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
4317         trap_id = MLXSW_TRAP_ID_RTR_INGRESS1;
4318
4319         mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
4320         mlxsw_reg_ralue_act_local_pack(ralue_pl, trap_action, trap_id, 0);
4321         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
4322 }
4323
4324 static int
4325 mlxsw_sp_fib_entry_op_ipip_decap(struct mlxsw_sp *mlxsw_sp,
4326                                  struct mlxsw_sp_fib_entry *fib_entry,
4327                                  enum mlxsw_reg_ralue_op op)
4328 {
4329         struct mlxsw_sp_ipip_entry *ipip_entry = fib_entry->decap.ipip_entry;
4330         const struct mlxsw_sp_ipip_ops *ipip_ops;
4331
4332         if (WARN_ON(!ipip_entry))
4333                 return -EINVAL;
4334
4335         ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
4336         return ipip_ops->fib_entry_op(mlxsw_sp, ipip_entry, op,
4337                                       fib_entry->decap.tunnel_index);
4338 }
4339
4340 static int mlxsw_sp_fib_entry_op_nve_decap(struct mlxsw_sp *mlxsw_sp,
4341                                            struct mlxsw_sp_fib_entry *fib_entry,
4342                                            enum mlxsw_reg_ralue_op op)
4343 {
4344         char ralue_pl[MLXSW_REG_RALUE_LEN];
4345
4346         mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
4347         mlxsw_reg_ralue_act_ip2me_tun_pack(ralue_pl,
4348                                            fib_entry->decap.tunnel_index);
4349         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
4350 }
4351
4352 static int __mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
4353                                    struct mlxsw_sp_fib_entry *fib_entry,
4354                                    enum mlxsw_reg_ralue_op op)
4355 {
4356         switch (fib_entry->type) {
4357         case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
4358                 return mlxsw_sp_fib_entry_op_remote(mlxsw_sp, fib_entry, op);
4359         case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
4360                 return mlxsw_sp_fib_entry_op_local(mlxsw_sp, fib_entry, op);
4361         case MLXSW_SP_FIB_ENTRY_TYPE_TRAP:
4362                 return mlxsw_sp_fib_entry_op_trap(mlxsw_sp, fib_entry, op);
4363         case MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE:
4364                 return mlxsw_sp_fib_entry_op_blackhole(mlxsw_sp, fib_entry, op);
4365         case MLXSW_SP_FIB_ENTRY_TYPE_UNREACHABLE:
4366                 return mlxsw_sp_fib_entry_op_unreachable(mlxsw_sp, fib_entry,
4367                                                          op);
4368         case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
4369                 return mlxsw_sp_fib_entry_op_ipip_decap(mlxsw_sp,
4370                                                         fib_entry, op);
4371         case MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP:
4372                 return mlxsw_sp_fib_entry_op_nve_decap(mlxsw_sp, fib_entry, op);
4373         }
4374         return -EINVAL;
4375 }
4376
4377 static int mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
4378                                  struct mlxsw_sp_fib_entry *fib_entry,
4379                                  enum mlxsw_reg_ralue_op op)
4380 {
4381         int err = __mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry, op);
4382
4383         mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, err);
4384
4385         return err;
4386 }
4387
4388 static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
4389                                      struct mlxsw_sp_fib_entry *fib_entry)
4390 {
4391         return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
4392                                      MLXSW_REG_RALUE_OP_WRITE_WRITE);
4393 }
4394
4395 static int mlxsw_sp_fib_entry_del(struct mlxsw_sp *mlxsw_sp,
4396                                   struct mlxsw_sp_fib_entry *fib_entry)
4397 {
4398         return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
4399                                      MLXSW_REG_RALUE_OP_WRITE_DELETE);
4400 }
4401
4402 static int
4403 mlxsw_sp_fib4_entry_type_set(struct mlxsw_sp *mlxsw_sp,
4404                              const struct fib_entry_notifier_info *fen_info,
4405                              struct mlxsw_sp_fib_entry *fib_entry)
4406 {
4407         struct net_device *dev = fib_info_nh(fen_info->fi, 0)->fib_nh_dev;
4408         union mlxsw_sp_l3addr dip = { .addr4 = htonl(fen_info->dst) };
4409         u32 tb_id = mlxsw_sp_fix_tb_id(fen_info->tb_id);
4410         struct mlxsw_sp_ipip_entry *ipip_entry;
4411         struct fib_info *fi = fen_info->fi;
4412
4413         switch (fen_info->type) {
4414         case RTN_LOCAL:
4415                 ipip_entry = mlxsw_sp_ipip_entry_find_by_decap(mlxsw_sp, dev,
4416                                                  MLXSW_SP_L3_PROTO_IPV4, dip);
4417                 if (ipip_entry && ipip_entry->ol_dev->flags & IFF_UP) {
4418                         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
4419                         return mlxsw_sp_fib_entry_decap_init(mlxsw_sp,
4420                                                              fib_entry,
4421                                                              ipip_entry);
4422                 }
4423                 if (mlxsw_sp_nve_ipv4_route_is_decap(mlxsw_sp, tb_id,
4424                                                      dip.addr4)) {
4425                         u32 t_index;
4426
4427                         t_index = mlxsw_sp_nve_decap_tunnel_index_get(mlxsw_sp);
4428                         fib_entry->decap.tunnel_index = t_index;
4429                         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_NVE_DECAP;
4430                         return 0;
4431                 }
4432                 /* fall through */
4433         case RTN_BROADCAST:
4434                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
4435                 return 0;
4436         case RTN_BLACKHOLE:
4437                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE;
4438                 return 0;
4439         case RTN_UNREACHABLE: /* fall through */
4440         case RTN_PROHIBIT:
4441                 /* Packets hitting these routes need to be trapped, but
4442                  * can do so with a lower priority than packets directed
4443                  * at the host, so use action type local instead of trap.
4444                  */
4445                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_UNREACHABLE;
4446                 return 0;
4447         case RTN_UNICAST:
4448                 if (mlxsw_sp_fi_is_gateway(mlxsw_sp, fi))
4449                         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE;
4450                 else
4451                         fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
4452                 return 0;
4453         default:
4454                 return -EINVAL;
4455         }
4456 }
4457
4458 static struct mlxsw_sp_fib4_entry *
4459 mlxsw_sp_fib4_entry_create(struct mlxsw_sp *mlxsw_sp,
4460                            struct mlxsw_sp_fib_node *fib_node,
4461                            const struct fib_entry_notifier_info *fen_info)
4462 {
4463         struct mlxsw_sp_fib4_entry *fib4_entry;
4464         struct mlxsw_sp_fib_entry *fib_entry;
4465         int err;
4466
4467         fib4_entry = kzalloc(sizeof(*fib4_entry), GFP_KERNEL);
4468         if (!fib4_entry)
4469                 return ERR_PTR(-ENOMEM);
4470         fib_entry = &fib4_entry->common;
4471
4472         err = mlxsw_sp_fib4_entry_type_set(mlxsw_sp, fen_info, fib_entry);
4473         if (err)
4474                 goto err_fib4_entry_type_set;
4475
4476         err = mlxsw_sp_nexthop4_group_get(mlxsw_sp, fib_entry, fen_info->fi);
4477         if (err)
4478                 goto err_nexthop4_group_get;
4479
4480         fib4_entry->prio = fen_info->fi->fib_priority;
4481         fib4_entry->tb_id = fen_info->tb_id;
4482         fib4_entry->type = fen_info->type;
4483         fib4_entry->tos = fen_info->tos;
4484
4485         fib_entry->fib_node = fib_node;
4486
4487         return fib4_entry;
4488
4489 err_nexthop4_group_get:
4490 err_fib4_entry_type_set:
4491         kfree(fib4_entry);
4492         return ERR_PTR(err);
4493 }
4494
4495 static void mlxsw_sp_fib4_entry_destroy(struct mlxsw_sp *mlxsw_sp,
4496                                         struct mlxsw_sp_fib4_entry *fib4_entry)
4497 {
4498         mlxsw_sp_nexthop4_group_put(mlxsw_sp, &fib4_entry->common);
4499         kfree(fib4_entry);
4500 }
4501
4502 static struct mlxsw_sp_fib4_entry *
4503 mlxsw_sp_fib4_entry_lookup(struct mlxsw_sp *mlxsw_sp,
4504                            const struct fib_entry_notifier_info *fen_info)
4505 {
4506         struct mlxsw_sp_fib4_entry *fib4_entry;
4507         struct mlxsw_sp_fib_node *fib_node;
4508         struct mlxsw_sp_fib *fib;
4509         struct mlxsw_sp_vr *vr;
4510
4511         vr = mlxsw_sp_vr_find(mlxsw_sp, fen_info->tb_id);
4512         if (!vr)
4513                 return NULL;
4514         fib = mlxsw_sp_vr_fib(vr, MLXSW_SP_L3_PROTO_IPV4);
4515
4516         fib_node = mlxsw_sp_fib_node_lookup(fib, &fen_info->dst,
4517                                             sizeof(fen_info->dst),
4518                                             fen_info->dst_len);
4519         if (!fib_node)
4520                 return NULL;
4521
4522         list_for_each_entry(fib4_entry, &fib_node->entry_list, common.list) {
4523                 if (fib4_entry->tb_id == fen_info->tb_id &&
4524                     fib4_entry->tos == fen_info->tos &&
4525                     fib4_entry->type == fen_info->type &&
4526                     mlxsw_sp_nexthop4_group_fi(fib4_entry->common.nh_group) ==
4527                     fen_info->fi) {
4528                         return fib4_entry;
4529                 }
4530         }
4531
4532         return NULL;
4533 }
4534
4535 static const struct rhashtable_params mlxsw_sp_fib_ht_params = {
4536         .key_offset = offsetof(struct mlxsw_sp_fib_node, key),
4537         .head_offset = offsetof(struct mlxsw_sp_fib_node, ht_node),
4538         .key_len = sizeof(struct mlxsw_sp_fib_key),
4539         .automatic_shrinking = true,
4540 };
4541
4542 static int mlxsw_sp_fib_node_insert(struct mlxsw_sp_fib *fib,
4543                                     struct mlxsw_sp_fib_node *fib_node)
4544 {
4545         return rhashtable_insert_fast(&fib->ht, &fib_node->ht_node,
4546                                       mlxsw_sp_fib_ht_params);
4547 }
4548
4549 static void mlxsw_sp_fib_node_remove(struct mlxsw_sp_fib *fib,
4550                                      struct mlxsw_sp_fib_node *fib_node)
4551 {
4552         rhashtable_remove_fast(&fib->ht, &fib_node->ht_node,
4553                                mlxsw_sp_fib_ht_params);
4554 }
4555
4556 static struct mlxsw_sp_fib_node *
4557 mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
4558                          size_t addr_len, unsigned char prefix_len)
4559 {
4560         struct mlxsw_sp_fib_key key;
4561
4562         memset(&key, 0, sizeof(key));
4563         memcpy(key.addr, addr, addr_len);
4564         key.prefix_len = prefix_len;
4565         return rhashtable_lookup_fast(&fib->ht, &key, mlxsw_sp_fib_ht_params);
4566 }
4567
4568 static struct mlxsw_sp_fib_node *
4569 mlxsw_sp_fib_node_create(struct mlxsw_sp_fib *fib, const void *addr,
4570                          size_t addr_len, unsigned char prefix_len)
4571 {
4572         struct mlxsw_sp_fib_node *fib_node;
4573
4574         fib_node = kzalloc(sizeof(*fib_node), GFP_KERNEL);
4575         if (!fib_node)
4576                 return NULL;
4577
4578         INIT_LIST_HEAD(&fib_node->entry_list);
4579         list_add(&fib_node->list, &fib->node_list);
4580         memcpy(fib_node->key.addr, addr, addr_len);
4581         fib_node->key.prefix_len = prefix_len;
4582
4583         return fib_node;
4584 }
4585
4586 static void mlxsw_sp_fib_node_destroy(struct mlxsw_sp_fib_node *fib_node)
4587 {
4588         list_del(&fib_node->list);
4589         WARN_ON(!list_empty(&fib_node->entry_list));
4590         kfree(fib_node);
4591 }
4592
4593 static bool
4594 mlxsw_sp_fib_node_entry_is_first(const struct mlxsw_sp_fib_node *fib_node,
4595                                  const struct mlxsw_sp_fib_entry *fib_entry)
4596 {
4597         return list_first_entry(&fib_node->entry_list,
4598                                 struct mlxsw_sp_fib_entry, list) == fib_entry;
4599 }
4600
4601 static int mlxsw_sp_fib_lpm_tree_link(struct mlxsw_sp *mlxsw_sp,
4602                                       struct mlxsw_sp_fib_node *fib_node)
4603 {
4604         struct mlxsw_sp_prefix_usage req_prefix_usage;
4605         struct mlxsw_sp_fib *fib = fib_node->fib;
4606         struct mlxsw_sp_lpm_tree *lpm_tree;
4607         int err;
4608
4609         lpm_tree = mlxsw_sp->router->lpm.proto_trees[fib->proto];
4610         if (lpm_tree->prefix_ref_count[fib_node->key.prefix_len] != 0)
4611                 goto out;
4612
4613         mlxsw_sp_prefix_usage_cpy(&req_prefix_usage, &lpm_tree->prefix_usage);
4614         mlxsw_sp_prefix_usage_set(&req_prefix_usage, fib_node->key.prefix_len);
4615         lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
4616                                          fib->proto);
4617         if (IS_ERR(lpm_tree))
4618                 return PTR_ERR(lpm_tree);
4619
4620         err = mlxsw_sp_vrs_lpm_tree_replace(mlxsw_sp, fib, lpm_tree);
4621         if (err)
4622                 goto err_lpm_tree_replace;
4623
4624 out:
4625         lpm_tree->prefix_ref_count[fib_node->key.prefix_len]++;
4626         return 0;
4627
4628 err_lpm_tree_replace:
4629         mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
4630         return err;
4631 }
4632
4633 static void mlxsw_sp_fib_lpm_tree_unlink(struct mlxsw_sp *mlxsw_sp,
4634                                          struct mlxsw_sp_fib_node *fib_node)
4635 {
4636         struct mlxsw_sp_lpm_tree *lpm_tree = fib_node->fib->lpm_tree;
4637         struct mlxsw_sp_prefix_usage req_prefix_usage;
4638         struct mlxsw_sp_fib *fib = fib_node->fib;
4639         int err;
4640
4641         if (--lpm_tree->prefix_ref_count[fib_node->key.prefix_len] != 0)
4642                 return;
4643         /* Try to construct a new LPM tree from the current prefix usage
4644          * minus the unused one. If we fail, continue using the old one.
4645          */
4646         mlxsw_sp_prefix_usage_cpy(&req_prefix_usage, &lpm_tree->prefix_usage);
4647         mlxsw_sp_prefix_usage_clear(&req_prefix_usage,
4648                                     fib_node->key.prefix_len);
4649         lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
4650                                          fib->proto);
4651         if (IS_ERR(lpm_tree))
4652                 return;
4653
4654         err = mlxsw_sp_vrs_lpm_tree_replace(mlxsw_sp, fib, lpm_tree);
4655         if (err)
4656                 goto err_lpm_tree_replace;
4657
4658         return;
4659
4660 err_lpm_tree_replace:
4661         mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
4662 }
4663
4664 static int mlxsw_sp_fib_node_init(struct mlxsw_sp *mlxsw_sp,
4665                                   struct mlxsw_sp_fib_node *fib_node,
4666                                   struct mlxsw_sp_fib *fib)
4667 {
4668         int err;
4669
4670         err = mlxsw_sp_fib_node_insert(fib, fib_node);
4671         if (err)
4672                 return err;
4673         fib_node->fib = fib;
4674
4675         err = mlxsw_sp_fib_lpm_tree_link(mlxsw_sp, fib_node);
4676         if (err)
4677                 goto err_fib_lpm_tree_link;
4678
4679         return 0;
4680
4681 err_fib_lpm_tree_link:
4682         fib_node->fib = NULL;
4683         mlxsw_sp_fib_node_remove(fib, fib_node);
4684         return err;
4685 }
4686
4687 static void mlxsw_sp_fib_node_fini(struct mlxsw_sp *mlxsw_sp,
4688                                    struct mlxsw_sp_fib_node *fib_node)
4689 {
4690         struct mlxsw_sp_fib *fib = fib_node->fib;
4691
4692         mlxsw_sp_fib_lpm_tree_unlink(mlxsw_sp, fib_node);
4693         fib_node->fib = NULL;
4694         mlxsw_sp_fib_node_remove(fib, fib_node);
4695 }
4696
4697 static struct mlxsw_sp_fib_node *
4698 mlxsw_sp_fib_node_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id, const void *addr,
4699                       size_t addr_len, unsigned char prefix_len,
4700                       enum mlxsw_sp_l3proto proto)
4701 {
4702         struct mlxsw_sp_fib_node *fib_node;
4703         struct mlxsw_sp_fib *fib;
4704         struct mlxsw_sp_vr *vr;
4705         int err;
4706
4707         vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id, NULL);
4708         if (IS_ERR(vr))
4709                 return ERR_CAST(vr);
4710         fib = mlxsw_sp_vr_fib(vr, proto);
4711
4712         fib_node = mlxsw_sp_fib_node_lookup(fib, addr, addr_len, prefix_len);
4713         if (fib_node)
4714                 return fib_node;
4715
4716         fib_node = mlxsw_sp_fib_node_create(fib, addr, addr_len, prefix_len);
4717         if (!fib_node) {
4718                 err = -ENOMEM;
4719                 goto err_fib_node_create;
4720         }
4721
4722         err = mlxsw_sp_fib_node_init(mlxsw_sp, fib_node, fib);
4723         if (err)
4724                 goto err_fib_node_init;
4725
4726         return fib_node;
4727
4728 err_fib_node_init:
4729         mlxsw_sp_fib_node_destroy(fib_node);
4730 err_fib_node_create:
4731         mlxsw_sp_vr_put(mlxsw_sp, vr);
4732         return ERR_PTR(err);
4733 }
4734
4735 static void mlxsw_sp_fib_node_put(struct mlxsw_sp *mlxsw_sp,
4736                                   struct mlxsw_sp_fib_node *fib_node)
4737 {
4738         struct mlxsw_sp_vr *vr = fib_node->fib->vr;
4739
4740         if (!list_empty(&fib_node->entry_list))
4741                 return;
4742         mlxsw_sp_fib_node_fini(mlxsw_sp, fib_node);
4743         mlxsw_sp_fib_node_destroy(fib_node);
4744         mlxsw_sp_vr_put(mlxsw_sp, vr);
4745 }
4746
4747 static struct mlxsw_sp_fib4_entry *
4748 mlxsw_sp_fib4_node_entry_find(const struct mlxsw_sp_fib_node *fib_node,
4749                               const struct mlxsw_sp_fib4_entry *new4_entry)
4750 {
4751         struct mlxsw_sp_fib4_entry *fib4_entry;
4752
4753         list_for_each_entry(fib4_entry, &fib_node->entry_list, common.list) {
4754                 if (fib4_entry->tb_id > new4_entry->tb_id)
4755                         continue;
4756                 if (fib4_entry->tb_id != new4_entry->tb_id)
4757                         break;
4758                 if (fib4_entry->tos > new4_entry->tos)
4759                         continue;
4760                 if (fib4_entry->prio >= new4_entry->prio ||
4761                     fib4_entry->tos < new4_entry->tos)
4762                         return fib4_entry;
4763         }
4764
4765         return NULL;
4766 }
4767
4768 static int
4769 mlxsw_sp_fib4_node_list_append(struct mlxsw_sp_fib4_entry *fib4_entry,
4770                                struct mlxsw_sp_fib4_entry *new4_entry)
4771 {
4772         struct mlxsw_sp_fib_node *fib_node;
4773
4774         if (WARN_ON(!fib4_entry))
4775                 return -EINVAL;
4776
4777         fib_node = fib4_entry->common.fib_node;
4778         list_for_each_entry_from(fib4_entry, &fib_node->entry_list,
4779                                  common.list) {
4780                 if (fib4_entry->tb_id != new4_entry->tb_id ||
4781                     fib4_entry->tos != new4_entry->tos ||
4782                     fib4_entry->prio != new4_entry->prio)
4783                         break;
4784         }
4785
4786         list_add_tail(&new4_entry->common.list, &fib4_entry->common.list);
4787         return 0;
4788 }
4789
4790 static int
4791 mlxsw_sp_fib4_node_list_insert(struct mlxsw_sp_fib4_entry *new4_entry,
4792                                bool replace, bool append)
4793 {
4794         struct mlxsw_sp_fib_node *fib_node = new4_entry->common.fib_node;
4795         struct mlxsw_sp_fib4_entry *fib4_entry;
4796
4797         fib4_entry = mlxsw_sp_fib4_node_entry_find(fib_node, new4_entry);
4798
4799         if (append)
4800                 return mlxsw_sp_fib4_node_list_append(fib4_entry, new4_entry);
4801         if (replace && WARN_ON(!fib4_entry))
4802                 return -EINVAL;
4803
4804         /* Insert new entry before replaced one, so that we can later
4805          * remove the second.
4806          */
4807         if (fib4_entry) {
4808                 list_add_tail(&new4_entry->common.list,
4809                               &fib4_entry->common.list);
4810         } else {
4811                 struct mlxsw_sp_fib4_entry *last;
4812
4813                 list_for_each_entry(last, &fib_node->entry_list, common.list) {
4814                         if (new4_entry->tb_id > last->tb_id)
4815                                 break;
4816                         fib4_entry = last;
4817                 }
4818
4819                 if (fib4_entry)
4820                         list_add(&new4_entry->common.list,
4821                                  &fib4_entry->common.list);
4822                 else
4823                         list_add(&new4_entry->common.list,
4824                                  &fib_node->entry_list);
4825         }
4826
4827         return 0;
4828 }
4829
4830 static void
4831 mlxsw_sp_fib4_node_list_remove(struct mlxsw_sp_fib4_entry *fib4_entry)
4832 {
4833         list_del(&fib4_entry->common.list);
4834 }
4835
4836 static int mlxsw_sp_fib_node_entry_add(struct mlxsw_sp *mlxsw_sp,
4837                                        struct mlxsw_sp_fib_entry *fib_entry)
4838 {
4839         struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
4840
4841         if (!mlxsw_sp_fib_node_entry_is_first(fib_node, fib_entry))
4842                 return 0;
4843
4844         /* To prevent packet loss, overwrite the previously offloaded
4845          * entry.
4846          */
4847         if (!list_is_singular(&fib_node->entry_list)) {
4848                 enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_DELETE;
4849                 struct mlxsw_sp_fib_entry *n = list_next_entry(fib_entry, list);
4850
4851                 mlxsw_sp_fib_entry_offload_refresh(n, op, 0);
4852         }
4853
4854         return mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
4855 }
4856
4857 static void mlxsw_sp_fib_node_entry_del(struct mlxsw_sp *mlxsw_sp,
4858                                         struct mlxsw_sp_fib_entry *fib_entry)
4859 {
4860         struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
4861
4862         if (!mlxsw_sp_fib_node_entry_is_first(fib_node, fib_entry))
4863                 return;
4864
4865         /* Promote the next entry by overwriting the deleted entry */
4866         if (!list_is_singular(&fib_node->entry_list)) {
4867                 struct mlxsw_sp_fib_entry *n = list_next_entry(fib_entry, list);
4868                 enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_DELETE;
4869
4870                 mlxsw_sp_fib_entry_update(mlxsw_sp, n);
4871                 mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, 0);
4872                 return;
4873         }
4874
4875         mlxsw_sp_fib_entry_del(mlxsw_sp, fib_entry);
4876 }
4877
4878 static int mlxsw_sp_fib4_node_entry_link(struct mlxsw_sp *mlxsw_sp,
4879                                          struct mlxsw_sp_fib4_entry *fib4_entry,
4880                                          bool replace, bool append)
4881 {
4882         int err;
4883
4884         err = mlxsw_sp_fib4_node_list_insert(fib4_entry, replace, append);
4885         if (err)
4886                 return err;
4887
4888         err = mlxsw_sp_fib_node_entry_add(mlxsw_sp, &fib4_entry->common);
4889         if (err)
4890                 goto err_fib_node_entry_add;
4891
4892         return 0;
4893
4894 err_fib_node_entry_add:
4895         mlxsw_sp_fib4_node_list_remove(fib4_entry);
4896         return err;
4897 }
4898
4899 static void
4900 mlxsw_sp_fib4_node_entry_unlink(struct mlxsw_sp *mlxsw_sp,
4901                                 struct mlxsw_sp_fib4_entry *fib4_entry)
4902 {
4903         mlxsw_sp_fib_node_entry_del(mlxsw_sp, &fib4_entry->common);
4904         mlxsw_sp_fib4_node_list_remove(fib4_entry);
4905
4906         if (fib4_entry->common.type == MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP)
4907                 mlxsw_sp_fib_entry_decap_fini(mlxsw_sp, &fib4_entry->common);
4908 }
4909
4910 static void mlxsw_sp_fib4_entry_replace(struct mlxsw_sp *mlxsw_sp,
4911                                         struct mlxsw_sp_fib4_entry *fib4_entry,
4912                                         bool replace)
4913 {
4914         struct mlxsw_sp_fib_node *fib_node = fib4_entry->common.fib_node;
4915         struct mlxsw_sp_fib4_entry *replaced;
4916
4917         if (!replace)
4918                 return;
4919
4920         /* We inserted the new entry before replaced one */
4921         replaced = list_next_entry(fib4_entry, common.list);
4922
4923         mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, replaced);
4924         mlxsw_sp_fib4_entry_destroy(mlxsw_sp, replaced);
4925         mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4926 }
4927
4928 static int
4929 mlxsw_sp_router_fib4_add(struct mlxsw_sp *mlxsw_sp,
4930                          const struct fib_entry_notifier_info *fen_info,
4931                          bool replace, bool append)
4932 {
4933         struct mlxsw_sp_fib4_entry *fib4_entry;
4934         struct mlxsw_sp_fib_node *fib_node;
4935         int err;
4936
4937         if (mlxsw_sp->router->aborted)
4938                 return 0;
4939
4940         fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, fen_info->tb_id,
4941                                          &fen_info->dst, sizeof(fen_info->dst),
4942                                          fen_info->dst_len,
4943                                          MLXSW_SP_L3_PROTO_IPV4);
4944         if (IS_ERR(fib_node)) {
4945                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to get FIB node\n");
4946                 return PTR_ERR(fib_node);
4947         }
4948
4949         fib4_entry = mlxsw_sp_fib4_entry_create(mlxsw_sp, fib_node, fen_info);
4950         if (IS_ERR(fib4_entry)) {
4951                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to create FIB entry\n");
4952                 err = PTR_ERR(fib4_entry);
4953                 goto err_fib4_entry_create;
4954         }
4955
4956         err = mlxsw_sp_fib4_node_entry_link(mlxsw_sp, fib4_entry, replace,
4957                                             append);
4958         if (err) {
4959                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to link FIB entry to node\n");
4960                 goto err_fib4_node_entry_link;
4961         }
4962
4963         mlxsw_sp_fib4_entry_replace(mlxsw_sp, fib4_entry, replace);
4964
4965         return 0;
4966
4967 err_fib4_node_entry_link:
4968         mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
4969 err_fib4_entry_create:
4970         mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4971         return err;
4972 }
4973
4974 static void mlxsw_sp_router_fib4_del(struct mlxsw_sp *mlxsw_sp,
4975                                      struct fib_entry_notifier_info *fen_info)
4976 {
4977         struct mlxsw_sp_fib4_entry *fib4_entry;
4978         struct mlxsw_sp_fib_node *fib_node;
4979
4980         if (mlxsw_sp->router->aborted)
4981                 return;
4982
4983         fib4_entry = mlxsw_sp_fib4_entry_lookup(mlxsw_sp, fen_info);
4984         if (WARN_ON(!fib4_entry))
4985                 return;
4986         fib_node = fib4_entry->common.fib_node;
4987
4988         mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, fib4_entry);
4989         mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
4990         mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4991 }
4992
4993 static bool mlxsw_sp_fib6_rt_should_ignore(const struct fib6_info *rt)
4994 {
4995         /* Packets with link-local destination IP arriving to the router
4996          * are trapped to the CPU, so no need to program specific routes
4997          * for them.
4998          */
4999         if (ipv6_addr_type(&rt->fib6_dst.addr) & IPV6_ADDR_LINKLOCAL)
5000                 return true;
5001
5002         /* Multicast routes aren't supported, so ignore them. Neighbour
5003          * Discovery packets are specifically trapped.
5004          */
5005         if (ipv6_addr_type(&rt->fib6_dst.addr) & IPV6_ADDR_MULTICAST)
5006                 return true;
5007
5008         /* Cloned routes are irrelevant in the forwarding path. */
5009         if (rt->fib6_flags & RTF_CACHE)
5010                 return true;
5011
5012         return false;
5013 }
5014
5015 static struct mlxsw_sp_rt6 *mlxsw_sp_rt6_create(struct fib6_info *rt)
5016 {
5017         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
5018
5019         mlxsw_sp_rt6 = kzalloc(sizeof(*mlxsw_sp_rt6), GFP_KERNEL);
5020         if (!mlxsw_sp_rt6)
5021                 return ERR_PTR(-ENOMEM);
5022
5023         /* In case of route replace, replaced route is deleted with
5024          * no notification. Take reference to prevent accessing freed
5025          * memory.
5026          */
5027         mlxsw_sp_rt6->rt = rt;
5028         fib6_info_hold(rt);
5029
5030         return mlxsw_sp_rt6;
5031 }
5032
5033 #if IS_ENABLED(CONFIG_IPV6)
5034 static void mlxsw_sp_rt6_release(struct fib6_info *rt)
5035 {
5036         fib6_info_release(rt);
5037 }
5038 #else
5039 static void mlxsw_sp_rt6_release(struct fib6_info *rt)
5040 {
5041 }
5042 #endif
5043
5044 static void mlxsw_sp_rt6_destroy(struct mlxsw_sp_rt6 *mlxsw_sp_rt6)
5045 {
5046         mlxsw_sp_rt6_release(mlxsw_sp_rt6->rt);
5047         kfree(mlxsw_sp_rt6);
5048 }
5049
5050 static bool mlxsw_sp_fib6_rt_can_mp(const struct fib6_info *rt)
5051 {
5052         /* RTF_CACHE routes are ignored */
5053         return !(rt->fib6_flags & RTF_ADDRCONF) &&
5054                 rt->fib6_nh->fib_nh_gw_family;
5055 }
5056
5057 static struct fib6_info *
5058 mlxsw_sp_fib6_entry_rt(const struct mlxsw_sp_fib6_entry *fib6_entry)
5059 {
5060         return list_first_entry(&fib6_entry->rt6_list, struct mlxsw_sp_rt6,
5061                                 list)->rt;
5062 }
5063
5064 static struct mlxsw_sp_fib6_entry *
5065 mlxsw_sp_fib6_node_mp_entry_find(const struct mlxsw_sp_fib_node *fib_node,
5066                                  const struct fib6_info *nrt, bool replace)
5067 {
5068         struct mlxsw_sp_fib6_entry *fib6_entry;
5069
5070         if (!mlxsw_sp_fib6_rt_can_mp(nrt) || replace)
5071                 return NULL;
5072
5073         list_for_each_entry(fib6_entry, &fib_node->entry_list, common.list) {
5074                 struct fib6_info *rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
5075
5076                 /* RT6_TABLE_LOCAL and RT6_TABLE_MAIN share the same
5077                  * virtual router.
5078                  */
5079                 if (rt->fib6_table->tb6_id > nrt->fib6_table->tb6_id)
5080                         continue;
5081                 if (rt->fib6_table->tb6_id != nrt->fib6_table->tb6_id)
5082                         break;
5083                 if (rt->fib6_metric < nrt->fib6_metric)
5084                         continue;
5085                 if (rt->fib6_metric == nrt->fib6_metric &&
5086                     mlxsw_sp_fib6_rt_can_mp(rt))
5087                         return fib6_entry;
5088                 if (rt->fib6_metric > nrt->fib6_metric)
5089                         break;
5090         }
5091
5092         return NULL;
5093 }
5094
5095 static struct mlxsw_sp_rt6 *
5096 mlxsw_sp_fib6_entry_rt_find(const struct mlxsw_sp_fib6_entry *fib6_entry,
5097                             const struct fib6_info *rt)
5098 {
5099         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
5100
5101         list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
5102                 if (mlxsw_sp_rt6->rt == rt)
5103                         return mlxsw_sp_rt6;
5104         }
5105
5106         return NULL;
5107 }
5108
5109 static bool mlxsw_sp_nexthop6_ipip_type(const struct mlxsw_sp *mlxsw_sp,
5110                                         const struct fib6_info *rt,
5111                                         enum mlxsw_sp_ipip_type *ret)
5112 {
5113         return rt->fib6_nh->fib_nh_dev &&
5114                mlxsw_sp_netdev_ipip_type(mlxsw_sp, rt->fib6_nh->fib_nh_dev, ret);
5115 }
5116
5117 static int mlxsw_sp_nexthop6_type_init(struct mlxsw_sp *mlxsw_sp,
5118                                        struct mlxsw_sp_nexthop_group *nh_grp,
5119                                        struct mlxsw_sp_nexthop *nh,
5120                                        const struct fib6_info *rt)
5121 {
5122         const struct mlxsw_sp_ipip_ops *ipip_ops;
5123         struct mlxsw_sp_ipip_entry *ipip_entry;
5124         struct net_device *dev = rt->fib6_nh->fib_nh_dev;
5125         struct mlxsw_sp_rif *rif;
5126         int err;
5127
5128         ipip_entry = mlxsw_sp_ipip_entry_find_by_ol_dev(mlxsw_sp, dev);
5129         if (ipip_entry) {
5130                 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
5131                 if (ipip_ops->can_offload(mlxsw_sp, dev,
5132                                           MLXSW_SP_L3_PROTO_IPV6)) {
5133                         nh->type = MLXSW_SP_NEXTHOP_TYPE_IPIP;
5134                         mlxsw_sp_nexthop_ipip_init(mlxsw_sp, nh, ipip_entry);
5135                         return 0;
5136                 }
5137         }
5138
5139         nh->type = MLXSW_SP_NEXTHOP_TYPE_ETH;
5140         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
5141         if (!rif)
5142                 return 0;
5143         mlxsw_sp_nexthop_rif_init(nh, rif);
5144
5145         err = mlxsw_sp_nexthop_neigh_init(mlxsw_sp, nh);
5146         if (err)
5147                 goto err_nexthop_neigh_init;
5148
5149         return 0;
5150
5151 err_nexthop_neigh_init:
5152         mlxsw_sp_nexthop_rif_fini(nh);
5153         return err;
5154 }
5155
5156 static void mlxsw_sp_nexthop6_type_fini(struct mlxsw_sp *mlxsw_sp,
5157                                         struct mlxsw_sp_nexthop *nh)
5158 {
5159         mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
5160 }
5161
5162 static int mlxsw_sp_nexthop6_init(struct mlxsw_sp *mlxsw_sp,
5163                                   struct mlxsw_sp_nexthop_group *nh_grp,
5164                                   struct mlxsw_sp_nexthop *nh,
5165                                   const struct fib6_info *rt)
5166 {
5167         struct net_device *dev = rt->fib6_nh->fib_nh_dev;
5168
5169         nh->nh_grp = nh_grp;
5170         nh->nh_weight = rt->fib6_nh->fib_nh_weight;
5171         memcpy(&nh->gw_addr, &rt->fib6_nh->fib_nh_gw6, sizeof(nh->gw_addr));
5172         mlxsw_sp_nexthop_counter_alloc(mlxsw_sp, nh);
5173
5174         list_add_tail(&nh->router_list_node, &mlxsw_sp->router->nexthop_list);
5175
5176         if (!dev)
5177                 return 0;
5178         nh->ifindex = dev->ifindex;
5179
5180         return mlxsw_sp_nexthop6_type_init(mlxsw_sp, nh_grp, nh, rt);
5181 }
5182
5183 static void mlxsw_sp_nexthop6_fini(struct mlxsw_sp *mlxsw_sp,
5184                                    struct mlxsw_sp_nexthop *nh)
5185 {
5186         mlxsw_sp_nexthop6_type_fini(mlxsw_sp, nh);
5187         list_del(&nh->router_list_node);
5188         mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
5189 }
5190
5191 static bool mlxsw_sp_rt6_is_gateway(const struct mlxsw_sp *mlxsw_sp,
5192                                     const struct fib6_info *rt)
5193 {
5194         return rt->fib6_nh->fib_nh_gw_family ||
5195                mlxsw_sp_nexthop6_ipip_type(mlxsw_sp, rt, NULL);
5196 }
5197
5198 static struct mlxsw_sp_nexthop_group *
5199 mlxsw_sp_nexthop6_group_create(struct mlxsw_sp *mlxsw_sp,
5200                                struct mlxsw_sp_fib6_entry *fib6_entry)
5201 {
5202         struct mlxsw_sp_nexthop_group *nh_grp;
5203         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
5204         struct mlxsw_sp_nexthop *nh;
5205         int i = 0;
5206         int err;
5207
5208         nh_grp = kzalloc(struct_size(nh_grp, nexthops, fib6_entry->nrt6),
5209                          GFP_KERNEL);
5210         if (!nh_grp)
5211                 return ERR_PTR(-ENOMEM);
5212         INIT_LIST_HEAD(&nh_grp->fib_list);
5213 #if IS_ENABLED(CONFIG_IPV6)
5214         nh_grp->neigh_tbl = &nd_tbl;
5215 #endif
5216         mlxsw_sp_rt6 = list_first_entry(&fib6_entry->rt6_list,
5217                                         struct mlxsw_sp_rt6, list);
5218         nh_grp->gateway = mlxsw_sp_rt6_is_gateway(mlxsw_sp, mlxsw_sp_rt6->rt);
5219         nh_grp->count = fib6_entry->nrt6;
5220         for (i = 0; i < nh_grp->count; i++) {
5221                 struct fib6_info *rt = mlxsw_sp_rt6->rt;
5222
5223                 nh = &nh_grp->nexthops[i];
5224                 err = mlxsw_sp_nexthop6_init(mlxsw_sp, nh_grp, nh, rt);
5225                 if (err)
5226                         goto err_nexthop6_init;
5227                 mlxsw_sp_rt6 = list_next_entry(mlxsw_sp_rt6, list);
5228         }
5229
5230         err = mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
5231         if (err)
5232                 goto err_nexthop_group_insert;
5233
5234         mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
5235         return nh_grp;
5236
5237 err_nexthop_group_insert:
5238 err_nexthop6_init:
5239         for (i--; i >= 0; i--) {
5240                 nh = &nh_grp->nexthops[i];
5241                 mlxsw_sp_nexthop6_fini(mlxsw_sp, nh);
5242         }
5243         kfree(nh_grp);
5244         return ERR_PTR(err);
5245 }
5246
5247 static void
5248 mlxsw_sp_nexthop6_group_destroy(struct mlxsw_sp *mlxsw_sp,
5249                                 struct mlxsw_sp_nexthop_group *nh_grp)
5250 {
5251         struct mlxsw_sp_nexthop *nh;
5252         int i = nh_grp->count;
5253
5254         mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
5255         for (i--; i >= 0; i--) {
5256                 nh = &nh_grp->nexthops[i];
5257                 mlxsw_sp_nexthop6_fini(mlxsw_sp, nh);
5258         }
5259         mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
5260         WARN_ON(nh_grp->adj_index_valid);
5261         kfree(nh_grp);
5262 }
5263
5264 static int mlxsw_sp_nexthop6_group_get(struct mlxsw_sp *mlxsw_sp,
5265                                        struct mlxsw_sp_fib6_entry *fib6_entry)
5266 {
5267         struct mlxsw_sp_nexthop_group *nh_grp;
5268
5269         nh_grp = mlxsw_sp_nexthop6_group_lookup(mlxsw_sp, fib6_entry);
5270         if (!nh_grp) {
5271                 nh_grp = mlxsw_sp_nexthop6_group_create(mlxsw_sp, fib6_entry);
5272                 if (IS_ERR(nh_grp))
5273                         return PTR_ERR(nh_grp);
5274         }
5275
5276         list_add_tail(&fib6_entry->common.nexthop_group_node,
5277                       &nh_grp->fib_list);
5278         fib6_entry->common.nh_group = nh_grp;
5279
5280         return 0;
5281 }
5282
5283 static void mlxsw_sp_nexthop6_group_put(struct mlxsw_sp *mlxsw_sp,
5284                                         struct mlxsw_sp_fib_entry *fib_entry)
5285 {
5286         struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
5287
5288         list_del(&fib_entry->nexthop_group_node);
5289         if (!list_empty(&nh_grp->fib_list))
5290                 return;
5291         mlxsw_sp_nexthop6_group_destroy(mlxsw_sp, nh_grp);
5292 }
5293
5294 static int
5295 mlxsw_sp_nexthop6_group_update(struct mlxsw_sp *mlxsw_sp,
5296                                struct mlxsw_sp_fib6_entry *fib6_entry)
5297 {
5298         struct mlxsw_sp_nexthop_group *old_nh_grp = fib6_entry->common.nh_group;
5299         int err;
5300
5301         fib6_entry->common.nh_group = NULL;
5302         list_del(&fib6_entry->common.nexthop_group_node);
5303
5304         err = mlxsw_sp_nexthop6_group_get(mlxsw_sp, fib6_entry);
5305         if (err)
5306                 goto err_nexthop6_group_get;
5307
5308         /* In case this entry is offloaded, then the adjacency index
5309          * currently associated with it in the device's table is that
5310          * of the old group. Start using the new one instead.
5311          */
5312         err = mlxsw_sp_fib_node_entry_add(mlxsw_sp, &fib6_entry->common);
5313         if (err)
5314                 goto err_fib_node_entry_add;
5315
5316         if (list_empty(&old_nh_grp->fib_list))
5317                 mlxsw_sp_nexthop6_group_destroy(mlxsw_sp, old_nh_grp);
5318
5319         return 0;
5320
5321 err_fib_node_entry_add:
5322         mlxsw_sp_nexthop6_group_put(mlxsw_sp, &fib6_entry->common);
5323 err_nexthop6_group_get:
5324         list_add_tail(&fib6_entry->common.nexthop_group_node,
5325                       &old_nh_grp->fib_list);
5326         fib6_entry->common.nh_group = old_nh_grp;
5327         return err;
5328 }
5329
5330 static int
5331 mlxsw_sp_fib6_entry_nexthop_add(struct mlxsw_sp *mlxsw_sp,
5332                                 struct mlxsw_sp_fib6_entry *fib6_entry,
5333                                 struct fib6_info **rt_arr, unsigned int nrt6)
5334 {
5335         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
5336         int err, i;
5337
5338         for (i = 0; i < nrt6; i++) {
5339                 mlxsw_sp_rt6 = mlxsw_sp_rt6_create(rt_arr[i]);
5340                 if (IS_ERR(mlxsw_sp_rt6)) {
5341                         err = PTR_ERR(mlxsw_sp_rt6);
5342                         goto err_rt6_create;
5343                 }
5344
5345                 list_add_tail(&mlxsw_sp_rt6->list, &fib6_entry->rt6_list);
5346                 fib6_entry->nrt6++;
5347         }
5348
5349         err = mlxsw_sp_nexthop6_group_update(mlxsw_sp, fib6_entry);
5350         if (err)
5351                 goto err_nexthop6_group_update;
5352
5353         return 0;
5354
5355 err_nexthop6_group_update:
5356         i = nrt6;
5357 err_rt6_create:
5358         for (i--; i >= 0; i--) {
5359                 fib6_entry->nrt6--;
5360                 mlxsw_sp_rt6 = list_last_entry(&fib6_entry->rt6_list,
5361                                                struct mlxsw_sp_rt6, list);
5362                 list_del(&mlxsw_sp_rt6->list);
5363                 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
5364         }
5365         return err;
5366 }
5367
5368 static void
5369 mlxsw_sp_fib6_entry_nexthop_del(struct mlxsw_sp *mlxsw_sp,
5370                                 struct mlxsw_sp_fib6_entry *fib6_entry,
5371                                 struct fib6_info **rt_arr, unsigned int nrt6)
5372 {
5373         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
5374         int i;
5375
5376         for (i = 0; i < nrt6; i++) {
5377                 mlxsw_sp_rt6 = mlxsw_sp_fib6_entry_rt_find(fib6_entry,
5378                                                            rt_arr[i]);
5379                 if (WARN_ON_ONCE(!mlxsw_sp_rt6))
5380                         continue;
5381
5382                 fib6_entry->nrt6--;
5383                 list_del(&mlxsw_sp_rt6->list);
5384                 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
5385         }
5386
5387         mlxsw_sp_nexthop6_group_update(mlxsw_sp, fib6_entry);
5388 }
5389
5390 static void mlxsw_sp_fib6_entry_type_set(struct mlxsw_sp *mlxsw_sp,
5391                                          struct mlxsw_sp_fib_entry *fib_entry,
5392                                          const struct fib6_info *rt)
5393 {
5394         /* Packets hitting RTF_REJECT routes need to be discarded by the
5395          * stack. We can rely on their destination device not having a
5396          * RIF (it's the loopback device) and can thus use action type
5397          * local, which will cause them to be trapped with a lower
5398          * priority than packets that need to be locally received.
5399          */
5400         if (rt->fib6_flags & (RTF_LOCAL | RTF_ANYCAST))
5401                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
5402         else if (rt->fib6_type == RTN_BLACKHOLE)
5403                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_BLACKHOLE;
5404         else if (rt->fib6_flags & RTF_REJECT)
5405                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_UNREACHABLE;
5406         else if (mlxsw_sp_rt6_is_gateway(mlxsw_sp, rt))
5407                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE;
5408         else
5409                 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
5410 }
5411
5412 static void
5413 mlxsw_sp_fib6_entry_rt_destroy_all(struct mlxsw_sp_fib6_entry *fib6_entry)
5414 {
5415         struct mlxsw_sp_rt6 *mlxsw_sp_rt6, *tmp;
5416
5417         list_for_each_entry_safe(mlxsw_sp_rt6, tmp, &fib6_entry->rt6_list,
5418                                  list) {
5419                 fib6_entry->nrt6--;
5420                 list_del(&mlxsw_sp_rt6->list);
5421                 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
5422         }
5423 }
5424
5425 static struct mlxsw_sp_fib6_entry *
5426 mlxsw_sp_fib6_entry_create(struct mlxsw_sp *mlxsw_sp,
5427                            struct mlxsw_sp_fib_node *fib_node,
5428                            struct fib6_info **rt_arr, unsigned int nrt6)
5429 {
5430         struct mlxsw_sp_fib6_entry *fib6_entry;
5431         struct mlxsw_sp_fib_entry *fib_entry;
5432         struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
5433         int err, i;
5434
5435         fib6_entry = kzalloc(sizeof(*fib6_entry), GFP_KERNEL);
5436         if (!fib6_entry)
5437                 return ERR_PTR(-ENOMEM);
5438         fib_entry = &fib6_entry->common;
5439
5440         INIT_LIST_HEAD(&fib6_entry->rt6_list);
5441
5442         for (i = 0; i < nrt6; i++) {
5443                 mlxsw_sp_rt6 = mlxsw_sp_rt6_create(rt_arr[i]);
5444                 if (IS_ERR(mlxsw_sp_rt6)) {
5445                         err = PTR_ERR(mlxsw_sp_rt6);
5446                         goto err_rt6_create;
5447                 }
5448                 list_add_tail(&mlxsw_sp_rt6->list, &fib6_entry->rt6_list);
5449                 fib6_entry->nrt6++;
5450         }
5451
5452         mlxsw_sp_fib6_entry_type_set(mlxsw_sp, fib_entry, rt_arr[0]);
5453
5454         err = mlxsw_sp_nexthop6_group_get(mlxsw_sp, fib6_entry);
5455         if (err)
5456                 goto err_nexthop6_group_get;
5457
5458         fib_entry->fib_node = fib_node;
5459
5460         return fib6_entry;
5461
5462 err_nexthop6_group_get:
5463         i = nrt6;
5464 err_rt6_create:
5465         for (i--; i >= 0; i--) {
5466                 fib6_entry->nrt6--;
5467                 mlxsw_sp_rt6 = list_last_entry(&fib6_entry->rt6_list,
5468                                                struct mlxsw_sp_rt6, list);
5469                 list_del(&mlxsw_sp_rt6->list);
5470                 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
5471         }
5472         kfree(fib6_entry);
5473         return ERR_PTR(err);
5474 }
5475
5476 static void mlxsw_sp_fib6_entry_destroy(struct mlxsw_sp *mlxsw_sp,
5477                                         struct mlxsw_sp_fib6_entry *fib6_entry)
5478 {
5479         mlxsw_sp_nexthop6_group_put(mlxsw_sp, &fib6_entry->common);
5480         mlxsw_sp_fib6_entry_rt_destroy_all(fib6_entry);
5481         WARN_ON(fib6_entry->nrt6);
5482         kfree(fib6_entry);
5483 }
5484
5485 static struct mlxsw_sp_fib6_entry *
5486 mlxsw_sp_fib6_node_entry_find(const struct mlxsw_sp_fib_node *fib_node,
5487                               const struct fib6_info *nrt, bool replace)
5488 {
5489         struct mlxsw_sp_fib6_entry *fib6_entry, *fallback = NULL;
5490
5491         list_for_each_entry(fib6_entry, &fib_node->entry_list, common.list) {
5492                 struct fib6_info *rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
5493
5494                 if (rt->fib6_table->tb6_id > nrt->fib6_table->tb6_id)
5495                         continue;
5496                 if (rt->fib6_table->tb6_id != nrt->fib6_table->tb6_id)
5497                         break;
5498                 if (replace && rt->fib6_metric == nrt->fib6_metric) {
5499                         if (mlxsw_sp_fib6_rt_can_mp(rt) ==
5500                             mlxsw_sp_fib6_rt_can_mp(nrt))
5501                                 return fib6_entry;
5502                         if (mlxsw_sp_fib6_rt_can_mp(nrt))
5503                                 fallback = fallback ?: fib6_entry;
5504                 }
5505                 if (rt->fib6_metric > nrt->fib6_metric)
5506                         return fallback ?: fib6_entry;
5507         }
5508
5509         return fallback;
5510 }
5511
5512 static int
5513 mlxsw_sp_fib6_node_list_insert(struct mlxsw_sp_fib6_entry *new6_entry,
5514                                bool *p_replace)
5515 {
5516         struct mlxsw_sp_fib_node *fib_node = new6_entry->common.fib_node;
5517         struct fib6_info *nrt = mlxsw_sp_fib6_entry_rt(new6_entry);
5518         struct mlxsw_sp_fib6_entry *fib6_entry;
5519
5520         fib6_entry = mlxsw_sp_fib6_node_entry_find(fib_node, nrt, *p_replace);
5521
5522         if (*p_replace && !fib6_entry)
5523                 *p_replace = false;
5524
5525         if (fib6_entry) {
5526                 list_add_tail(&new6_entry->common.list,
5527                               &fib6_entry->common.list);
5528         } else {
5529                 struct mlxsw_sp_fib6_entry *last;
5530
5531                 list_for_each_entry(last, &fib_node->entry_list, common.list) {
5532                         struct fib6_info *rt = mlxsw_sp_fib6_entry_rt(last);
5533
5534                         if (nrt->fib6_table->tb6_id > rt->fib6_table->tb6_id)
5535                                 break;
5536                         fib6_entry = last;
5537                 }
5538
5539                 if (fib6_entry)
5540                         list_add(&new6_entry->common.list,
5541                                  &fib6_entry->common.list);
5542                 else
5543                         list_add(&new6_entry->common.list,
5544                                  &fib_node->entry_list);
5545         }
5546
5547         return 0;
5548 }
5549
5550 static void
5551 mlxsw_sp_fib6_node_list_remove(struct mlxsw_sp_fib6_entry *fib6_entry)
5552 {
5553         list_del(&fib6_entry->common.list);
5554 }
5555
5556 static int mlxsw_sp_fib6_node_entry_link(struct mlxsw_sp *mlxsw_sp,
5557                                          struct mlxsw_sp_fib6_entry *fib6_entry,
5558                                          bool *p_replace)
5559 {
5560         int err;
5561
5562         err = mlxsw_sp_fib6_node_list_insert(fib6_entry, p_replace);
5563         if (err)
5564                 return err;
5565
5566         err = mlxsw_sp_fib_node_entry_add(mlxsw_sp, &fib6_entry->common);
5567         if (err)
5568                 goto err_fib_node_entry_add;
5569
5570         return 0;
5571
5572 err_fib_node_entry_add:
5573         mlxsw_sp_fib6_node_list_remove(fib6_entry);
5574         return err;
5575 }
5576
5577 static void
5578 mlxsw_sp_fib6_node_entry_unlink(struct mlxsw_sp *mlxsw_sp,
5579                                 struct mlxsw_sp_fib6_entry *fib6_entry)
5580 {
5581         mlxsw_sp_fib_node_entry_del(mlxsw_sp, &fib6_entry->common);
5582         mlxsw_sp_fib6_node_list_remove(fib6_entry);
5583 }
5584
5585 static struct mlxsw_sp_fib6_entry *
5586 mlxsw_sp_fib6_entry_lookup(struct mlxsw_sp *mlxsw_sp,
5587                            const struct fib6_info *rt)
5588 {
5589         struct mlxsw_sp_fib6_entry *fib6_entry;
5590         struct mlxsw_sp_fib_node *fib_node;
5591         struct mlxsw_sp_fib *fib;
5592         struct mlxsw_sp_vr *vr;
5593
5594         vr = mlxsw_sp_vr_find(mlxsw_sp, rt->fib6_table->tb6_id);
5595         if (!vr)
5596                 return NULL;
5597         fib = mlxsw_sp_vr_fib(vr, MLXSW_SP_L3_PROTO_IPV6);
5598
5599         fib_node = mlxsw_sp_fib_node_lookup(fib, &rt->fib6_dst.addr,
5600                                             sizeof(rt->fib6_dst.addr),
5601                                             rt->fib6_dst.plen);
5602         if (!fib_node)
5603                 return NULL;
5604
5605         list_for_each_entry(fib6_entry, &fib_node->entry_list, common.list) {
5606                 struct fib6_info *iter_rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
5607
5608                 if (rt->fib6_table->tb6_id == iter_rt->fib6_table->tb6_id &&
5609                     rt->fib6_metric == iter_rt->fib6_metric &&
5610                     mlxsw_sp_fib6_entry_rt_find(fib6_entry, rt))
5611                         return fib6_entry;
5612         }
5613
5614         return NULL;
5615 }
5616
5617 static void mlxsw_sp_fib6_entry_replace(struct mlxsw_sp *mlxsw_sp,
5618                                         struct mlxsw_sp_fib6_entry *fib6_entry,
5619                                         bool replace)
5620 {
5621         struct mlxsw_sp_fib_node *fib_node = fib6_entry->common.fib_node;
5622         struct mlxsw_sp_fib6_entry *replaced;
5623
5624         if (!replace)
5625                 return;
5626
5627         replaced = list_next_entry(fib6_entry, common.list);
5628
5629         mlxsw_sp_fib6_node_entry_unlink(mlxsw_sp, replaced);
5630         mlxsw_sp_fib6_entry_destroy(mlxsw_sp, replaced);
5631         mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
5632 }
5633
5634 static int mlxsw_sp_router_fib6_add(struct mlxsw_sp *mlxsw_sp,
5635                                     struct fib6_info **rt_arr,
5636                                     unsigned int nrt6, bool replace)
5637 {
5638         struct mlxsw_sp_fib6_entry *fib6_entry;
5639         struct mlxsw_sp_fib_node *fib_node;
5640         struct fib6_info *rt = rt_arr[0];
5641         int err;
5642
5643         if (mlxsw_sp->router->aborted)
5644                 return 0;
5645
5646         if (rt->fib6_src.plen)
5647                 return -EINVAL;
5648
5649         if (mlxsw_sp_fib6_rt_should_ignore(rt))
5650                 return 0;
5651
5652         fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, rt->fib6_table->tb6_id,
5653                                          &rt->fib6_dst.addr,
5654                                          sizeof(rt->fib6_dst.addr),
5655                                          rt->fib6_dst.plen,
5656                                          MLXSW_SP_L3_PROTO_IPV6);
5657         if (IS_ERR(fib_node))
5658                 return PTR_ERR(fib_node);
5659
5660         /* Before creating a new entry, try to append route to an existing
5661          * multipath entry.
5662          */
5663         fib6_entry = mlxsw_sp_fib6_node_mp_entry_find(fib_node, rt, replace);
5664         if (fib6_entry) {
5665                 err = mlxsw_sp_fib6_entry_nexthop_add(mlxsw_sp, fib6_entry,
5666                                                       rt_arr, nrt6);
5667                 if (err)
5668                         goto err_fib6_entry_nexthop_add;
5669                 return 0;
5670         }
5671
5672         fib6_entry = mlxsw_sp_fib6_entry_create(mlxsw_sp, fib_node, rt_arr,
5673                                                 nrt6);
5674         if (IS_ERR(fib6_entry)) {
5675                 err = PTR_ERR(fib6_entry);
5676                 goto err_fib6_entry_create;
5677         }
5678
5679         err = mlxsw_sp_fib6_node_entry_link(mlxsw_sp, fib6_entry, &replace);
5680         if (err)
5681                 goto err_fib6_node_entry_link;
5682
5683         mlxsw_sp_fib6_entry_replace(mlxsw_sp, fib6_entry, replace);
5684
5685         return 0;
5686
5687 err_fib6_node_entry_link:
5688         mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
5689 err_fib6_entry_create:
5690 err_fib6_entry_nexthop_add:
5691         mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
5692         return err;
5693 }
5694
5695 static void mlxsw_sp_router_fib6_del(struct mlxsw_sp *mlxsw_sp,
5696                                      struct fib6_info **rt_arr,
5697                                      unsigned int nrt6)
5698 {
5699         struct mlxsw_sp_fib6_entry *fib6_entry;
5700         struct mlxsw_sp_fib_node *fib_node;
5701         struct fib6_info *rt = rt_arr[0];
5702
5703         if (mlxsw_sp->router->aborted)
5704                 return;
5705
5706         if (mlxsw_sp_fib6_rt_should_ignore(rt))
5707                 return;
5708
5709         fib6_entry = mlxsw_sp_fib6_entry_lookup(mlxsw_sp, rt);
5710         if (WARN_ON(!fib6_entry))
5711                 return;
5712
5713         /* If not all the nexthops are deleted, then only reduce the nexthop
5714          * group.
5715          */
5716         if (nrt6 != fib6_entry->nrt6) {
5717                 mlxsw_sp_fib6_entry_nexthop_del(mlxsw_sp, fib6_entry, rt_arr,
5718                                                 nrt6);
5719                 return;
5720         }
5721
5722         fib_node = fib6_entry->common.fib_node;
5723
5724         mlxsw_sp_fib6_node_entry_unlink(mlxsw_sp, fib6_entry);
5725         mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
5726         mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
5727 }
5728
5729 static int __mlxsw_sp_router_set_abort_trap(struct mlxsw_sp *mlxsw_sp,
5730                                             enum mlxsw_reg_ralxx_protocol proto,
5731                                             u8 tree_id)
5732 {
5733         char ralta_pl[MLXSW_REG_RALTA_LEN];
5734         char ralst_pl[MLXSW_REG_RALST_LEN];
5735         int i, err;
5736
5737         mlxsw_reg_ralta_pack(ralta_pl, true, proto, tree_id);
5738         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
5739         if (err)
5740                 return err;
5741
5742         mlxsw_reg_ralst_pack(ralst_pl, 0xff, tree_id);
5743         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralst), ralst_pl);
5744         if (err)
5745                 return err;
5746
5747         for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
5748                 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
5749                 char raltb_pl[MLXSW_REG_RALTB_LEN];
5750                 char ralue_pl[MLXSW_REG_RALUE_LEN];
5751
5752                 mlxsw_reg_raltb_pack(raltb_pl, vr->id, proto, tree_id);
5753                 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb),
5754                                       raltb_pl);
5755                 if (err)
5756                         return err;
5757
5758                 mlxsw_reg_ralue_pack(ralue_pl, proto,
5759                                      MLXSW_REG_RALUE_OP_WRITE_WRITE, vr->id, 0);
5760                 mlxsw_reg_ralue_act_ip2me_pack(ralue_pl);
5761                 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue),
5762                                       ralue_pl);
5763                 if (err)
5764                         return err;
5765         }
5766
5767         return 0;
5768 }
5769
5770 static struct mlxsw_sp_mr_table *
5771 mlxsw_sp_router_fibmr_family_to_table(struct mlxsw_sp_vr *vr, int family)
5772 {
5773         if (family == RTNL_FAMILY_IPMR)
5774                 return vr->mr_table[MLXSW_SP_L3_PROTO_IPV4];
5775         else
5776                 return vr->mr_table[MLXSW_SP_L3_PROTO_IPV6];
5777 }
5778
5779 static int mlxsw_sp_router_fibmr_add(struct mlxsw_sp *mlxsw_sp,
5780                                      struct mfc_entry_notifier_info *men_info,
5781                                      bool replace)
5782 {
5783         struct mlxsw_sp_mr_table *mrt;
5784         struct mlxsw_sp_vr *vr;
5785
5786         if (mlxsw_sp->router->aborted)
5787                 return 0;
5788
5789         vr = mlxsw_sp_vr_get(mlxsw_sp, men_info->tb_id, NULL);
5790         if (IS_ERR(vr))
5791                 return PTR_ERR(vr);
5792
5793         mrt = mlxsw_sp_router_fibmr_family_to_table(vr, men_info->info.family);
5794         return mlxsw_sp_mr_route_add(mrt, men_info->mfc, replace);
5795 }
5796
5797 static void mlxsw_sp_router_fibmr_del(struct mlxsw_sp *mlxsw_sp,
5798                                       struct mfc_entry_notifier_info *men_info)
5799 {
5800         struct mlxsw_sp_mr_table *mrt;
5801         struct mlxsw_sp_vr *vr;
5802
5803         if (mlxsw_sp->router->aborted)
5804                 return;
5805
5806         vr = mlxsw_sp_vr_find(mlxsw_sp, men_info->tb_id);
5807         if (WARN_ON(!vr))
5808                 return;
5809
5810         mrt = mlxsw_sp_router_fibmr_family_to_table(vr, men_info->info.family);
5811         mlxsw_sp_mr_route_del(mrt, men_info->mfc);
5812         mlxsw_sp_vr_put(mlxsw_sp, vr);
5813 }
5814
5815 static int
5816 mlxsw_sp_router_fibmr_vif_add(struct mlxsw_sp *mlxsw_sp,
5817                               struct vif_entry_notifier_info *ven_info)
5818 {
5819         struct mlxsw_sp_mr_table *mrt;
5820         struct mlxsw_sp_rif *rif;
5821         struct mlxsw_sp_vr *vr;
5822
5823         if (mlxsw_sp->router->aborted)
5824                 return 0;
5825
5826         vr = mlxsw_sp_vr_get(mlxsw_sp, ven_info->tb_id, NULL);
5827         if (IS_ERR(vr))
5828                 return PTR_ERR(vr);
5829
5830         mrt = mlxsw_sp_router_fibmr_family_to_table(vr, ven_info->info.family);
5831         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, ven_info->dev);
5832         return mlxsw_sp_mr_vif_add(mrt, ven_info->dev,
5833                                    ven_info->vif_index,
5834                                    ven_info->vif_flags, rif);
5835 }
5836
5837 static void
5838 mlxsw_sp_router_fibmr_vif_del(struct mlxsw_sp *mlxsw_sp,
5839                               struct vif_entry_notifier_info *ven_info)
5840 {
5841         struct mlxsw_sp_mr_table *mrt;
5842         struct mlxsw_sp_vr *vr;
5843
5844         if (mlxsw_sp->router->aborted)
5845                 return;
5846
5847         vr = mlxsw_sp_vr_find(mlxsw_sp, ven_info->tb_id);
5848         if (WARN_ON(!vr))
5849                 return;
5850
5851         mrt = mlxsw_sp_router_fibmr_family_to_table(vr, ven_info->info.family);
5852         mlxsw_sp_mr_vif_del(mrt, ven_info->vif_index);
5853         mlxsw_sp_vr_put(mlxsw_sp, vr);
5854 }
5855
5856 static int mlxsw_sp_router_set_abort_trap(struct mlxsw_sp *mlxsw_sp)
5857 {
5858         enum mlxsw_reg_ralxx_protocol proto = MLXSW_REG_RALXX_PROTOCOL_IPV4;
5859         int err;
5860
5861         err = __mlxsw_sp_router_set_abort_trap(mlxsw_sp, proto,
5862                                                MLXSW_SP_LPM_TREE_MIN);
5863         if (err)
5864                 return err;
5865
5866         /* The multicast router code does not need an abort trap as by default,
5867          * packets that don't match any routes are trapped to the CPU.
5868          */
5869
5870         proto = MLXSW_REG_RALXX_PROTOCOL_IPV6;
5871         return __mlxsw_sp_router_set_abort_trap(mlxsw_sp, proto,
5872                                                 MLXSW_SP_LPM_TREE_MIN + 1);
5873 }
5874
5875 static void mlxsw_sp_fib4_node_flush(struct mlxsw_sp *mlxsw_sp,
5876                                      struct mlxsw_sp_fib_node *fib_node)
5877 {
5878         struct mlxsw_sp_fib4_entry *fib4_entry, *tmp;
5879
5880         list_for_each_entry_safe(fib4_entry, tmp, &fib_node->entry_list,
5881                                  common.list) {
5882                 bool do_break = &tmp->common.list == &fib_node->entry_list;
5883
5884                 mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, fib4_entry);
5885                 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
5886                 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
5887                 /* Break when entry list is empty and node was freed.
5888                  * Otherwise, we'll access freed memory in the next
5889                  * iteration.
5890                  */
5891                 if (do_break)
5892                         break;
5893         }
5894 }
5895
5896 static void mlxsw_sp_fib6_node_flush(struct mlxsw_sp *mlxsw_sp,
5897                                      struct mlxsw_sp_fib_node *fib_node)
5898 {
5899         struct mlxsw_sp_fib6_entry *fib6_entry, *tmp;
5900
5901         list_for_each_entry_safe(fib6_entry, tmp, &fib_node->entry_list,
5902                                  common.list) {
5903                 bool do_break = &tmp->common.list == &fib_node->entry_list;
5904
5905                 mlxsw_sp_fib6_node_entry_unlink(mlxsw_sp, fib6_entry);
5906                 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
5907                 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
5908                 if (do_break)
5909                         break;
5910         }
5911 }
5912
5913 static void mlxsw_sp_fib_node_flush(struct mlxsw_sp *mlxsw_sp,
5914                                     struct mlxsw_sp_fib_node *fib_node)
5915 {
5916         switch (fib_node->fib->proto) {
5917         case MLXSW_SP_L3_PROTO_IPV4:
5918                 mlxsw_sp_fib4_node_flush(mlxsw_sp, fib_node);
5919                 break;
5920         case MLXSW_SP_L3_PROTO_IPV6:
5921                 mlxsw_sp_fib6_node_flush(mlxsw_sp, fib_node);
5922                 break;
5923         }
5924 }
5925
5926 static void mlxsw_sp_vr_fib_flush(struct mlxsw_sp *mlxsw_sp,
5927                                   struct mlxsw_sp_vr *vr,
5928                                   enum mlxsw_sp_l3proto proto)
5929 {
5930         struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
5931         struct mlxsw_sp_fib_node *fib_node, *tmp;
5932
5933         list_for_each_entry_safe(fib_node, tmp, &fib->node_list, list) {
5934                 bool do_break = &tmp->list == &fib->node_list;
5935
5936                 mlxsw_sp_fib_node_flush(mlxsw_sp, fib_node);
5937                 if (do_break)
5938                         break;
5939         }
5940 }
5941
5942 static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp)
5943 {
5944         int i, j;
5945
5946         for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
5947                 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
5948
5949                 if (!mlxsw_sp_vr_is_used(vr))
5950                         continue;
5951
5952                 for (j = 0; j < MLXSW_SP_L3_PROTO_MAX; j++)
5953                         mlxsw_sp_mr_table_flush(vr->mr_table[j]);
5954                 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV4);
5955
5956                 /* If virtual router was only used for IPv4, then it's no
5957                  * longer used.
5958                  */
5959                 if (!mlxsw_sp_vr_is_used(vr))
5960                         continue;
5961                 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV6);
5962         }
5963
5964         /* After flushing all the routes, it is not possible anyone is still
5965          * using the adjacency index that is discarding packets, so free it in
5966          * case it was allocated.
5967          */
5968         if (!mlxsw_sp->router->adj_discard_index_valid)
5969                 return;
5970         mlxsw_sp_kvdl_free(mlxsw_sp, MLXSW_SP_KVDL_ENTRY_TYPE_ADJ, 1,
5971                            mlxsw_sp->router->adj_discard_index);
5972         mlxsw_sp->router->adj_discard_index_valid = false;
5973 }
5974
5975 static void mlxsw_sp_router_fib_abort(struct mlxsw_sp *mlxsw_sp)
5976 {
5977         int err;
5978
5979         if (mlxsw_sp->router->aborted)
5980                 return;
5981         dev_warn(mlxsw_sp->bus_info->dev, "FIB abort triggered. Note that FIB entries are no longer being offloaded to this device.\n");
5982         mlxsw_sp_router_fib_flush(mlxsw_sp);
5983         mlxsw_sp->router->aborted = true;
5984         err = mlxsw_sp_router_set_abort_trap(mlxsw_sp);
5985         if (err)
5986                 dev_warn(mlxsw_sp->bus_info->dev, "Failed to set abort trap.\n");
5987 }
5988
5989 struct mlxsw_sp_fib6_event_work {
5990         struct fib6_info **rt_arr;
5991         unsigned int nrt6;
5992 };
5993
5994 struct mlxsw_sp_fib_event_work {
5995         struct work_struct work;
5996         union {
5997                 struct mlxsw_sp_fib6_event_work fib6_work;
5998                 struct fib_entry_notifier_info fen_info;
5999                 struct fib_rule_notifier_info fr_info;
6000                 struct fib_nh_notifier_info fnh_info;
6001                 struct mfc_entry_notifier_info men_info;
6002                 struct vif_entry_notifier_info ven_info;
6003         };
6004         struct mlxsw_sp *mlxsw_sp;
6005         unsigned long event;
6006 };
6007
6008 static int
6009 mlxsw_sp_router_fib6_work_init(struct mlxsw_sp_fib6_event_work *fib6_work,
6010                                struct fib6_entry_notifier_info *fen6_info)
6011 {
6012         struct fib6_info *rt = fen6_info->rt;
6013         struct fib6_info **rt_arr;
6014         struct fib6_info *iter;
6015         unsigned int nrt6;
6016         int i = 0;
6017
6018         nrt6 = fen6_info->nsiblings + 1;
6019
6020         rt_arr = kcalloc(nrt6, sizeof(struct fib6_info *), GFP_ATOMIC);
6021         if (!rt_arr)
6022                 return -ENOMEM;
6023
6024         fib6_work->rt_arr = rt_arr;
6025         fib6_work->nrt6 = nrt6;
6026
6027         rt_arr[0] = rt;
6028         fib6_info_hold(rt);
6029
6030         if (!fen6_info->nsiblings)
6031                 return 0;
6032
6033         list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings) {
6034                 if (i == fen6_info->nsiblings)
6035                         break;
6036
6037                 rt_arr[i + 1] = iter;
6038                 fib6_info_hold(iter);
6039                 i++;
6040         }
6041         WARN_ON_ONCE(i != fen6_info->nsiblings);
6042
6043         return 0;
6044 }
6045
6046 static void
6047 mlxsw_sp_router_fib6_work_fini(struct mlxsw_sp_fib6_event_work *fib6_work)
6048 {
6049         int i;
6050
6051         for (i = 0; i < fib6_work->nrt6; i++)
6052                 mlxsw_sp_rt6_release(fib6_work->rt_arr[i]);
6053         kfree(fib6_work->rt_arr);
6054 }
6055
6056 static void mlxsw_sp_router_fib4_event_work(struct work_struct *work)
6057 {
6058         struct mlxsw_sp_fib_event_work *fib_work =
6059                 container_of(work, struct mlxsw_sp_fib_event_work, work);
6060         struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
6061         bool replace, append;
6062         int err;
6063
6064         /* Protect internal structures from changes */
6065         rtnl_lock();
6066         mlxsw_sp_span_respin(mlxsw_sp);
6067
6068         switch (fib_work->event) {
6069         case FIB_EVENT_ENTRY_REPLACE: /* fall through */
6070         case FIB_EVENT_ENTRY_APPEND: /* fall through */
6071         case FIB_EVENT_ENTRY_ADD:
6072                 replace = fib_work->event == FIB_EVENT_ENTRY_REPLACE;
6073                 append = fib_work->event == FIB_EVENT_ENTRY_APPEND;
6074                 err = mlxsw_sp_router_fib4_add(mlxsw_sp, &fib_work->fen_info,
6075                                                replace, append);
6076                 if (err)
6077                         mlxsw_sp_router_fib_abort(mlxsw_sp);
6078                 fib_info_put(fib_work->fen_info.fi);
6079                 break;
6080         case FIB_EVENT_ENTRY_DEL:
6081                 mlxsw_sp_router_fib4_del(mlxsw_sp, &fib_work->fen_info);
6082                 fib_info_put(fib_work->fen_info.fi);
6083                 break;
6084         case FIB_EVENT_NH_ADD: /* fall through */
6085         case FIB_EVENT_NH_DEL:
6086                 mlxsw_sp_nexthop4_event(mlxsw_sp, fib_work->event,
6087                                         fib_work->fnh_info.fib_nh);
6088                 fib_info_put(fib_work->fnh_info.fib_nh->nh_parent);
6089                 break;
6090         }
6091         rtnl_unlock();
6092         kfree(fib_work);
6093 }
6094
6095 static void mlxsw_sp_router_fib6_event_work(struct work_struct *work)
6096 {
6097         struct mlxsw_sp_fib_event_work *fib_work =
6098                 container_of(work, struct mlxsw_sp_fib_event_work, work);
6099         struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
6100         bool replace;
6101         int err;
6102
6103         rtnl_lock();
6104         mlxsw_sp_span_respin(mlxsw_sp);
6105
6106         switch (fib_work->event) {
6107         case FIB_EVENT_ENTRY_REPLACE: /* fall through */
6108         case FIB_EVENT_ENTRY_ADD:
6109                 replace = fib_work->event == FIB_EVENT_ENTRY_REPLACE;
6110                 err = mlxsw_sp_router_fib6_add(mlxsw_sp,
6111                                                fib_work->fib6_work.rt_arr,
6112                                                fib_work->fib6_work.nrt6,
6113                                                replace);
6114                 if (err)
6115                         mlxsw_sp_router_fib_abort(mlxsw_sp);
6116                 mlxsw_sp_router_fib6_work_fini(&fib_work->fib6_work);
6117                 break;
6118         case FIB_EVENT_ENTRY_DEL:
6119                 mlxsw_sp_router_fib6_del(mlxsw_sp,
6120                                          fib_work->fib6_work.rt_arr,
6121                                          fib_work->fib6_work.nrt6);
6122                 mlxsw_sp_router_fib6_work_fini(&fib_work->fib6_work);
6123                 break;
6124         }
6125         rtnl_unlock();
6126         kfree(fib_work);
6127 }
6128
6129 static void mlxsw_sp_router_fibmr_event_work(struct work_struct *work)
6130 {
6131         struct mlxsw_sp_fib_event_work *fib_work =
6132                 container_of(work, struct mlxsw_sp_fib_event_work, work);
6133         struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
6134         bool replace;
6135         int err;
6136
6137         rtnl_lock();
6138         switch (fib_work->event) {
6139         case FIB_EVENT_ENTRY_REPLACE: /* fall through */
6140         case FIB_EVENT_ENTRY_ADD:
6141                 replace = fib_work->event == FIB_EVENT_ENTRY_REPLACE;
6142
6143                 err = mlxsw_sp_router_fibmr_add(mlxsw_sp, &fib_work->men_info,
6144                                                 replace);
6145                 if (err)
6146                         mlxsw_sp_router_fib_abort(mlxsw_sp);
6147                 mr_cache_put(fib_work->men_info.mfc);
6148                 break;
6149         case FIB_EVENT_ENTRY_DEL:
6150                 mlxsw_sp_router_fibmr_del(mlxsw_sp, &fib_work->men_info);
6151                 mr_cache_put(fib_work->men_info.mfc);
6152                 break;
6153         case FIB_EVENT_VIF_ADD:
6154                 err = mlxsw_sp_router_fibmr_vif_add(mlxsw_sp,
6155                                                     &fib_work->ven_info);
6156                 if (err)
6157                         mlxsw_sp_router_fib_abort(mlxsw_sp);
6158                 dev_put(fib_work->ven_info.dev);
6159                 break;
6160         case FIB_EVENT_VIF_DEL:
6161                 mlxsw_sp_router_fibmr_vif_del(mlxsw_sp,
6162                                               &fib_work->ven_info);
6163                 dev_put(fib_work->ven_info.dev);
6164                 break;
6165         }
6166         rtnl_unlock();
6167         kfree(fib_work);
6168 }
6169
6170 static void mlxsw_sp_router_fib4_event(struct mlxsw_sp_fib_event_work *fib_work,
6171                                        struct fib_notifier_info *info)
6172 {
6173         struct fib_entry_notifier_info *fen_info;
6174         struct fib_nh_notifier_info *fnh_info;
6175
6176         switch (fib_work->event) {
6177         case FIB_EVENT_ENTRY_REPLACE: /* fall through */
6178         case FIB_EVENT_ENTRY_APPEND: /* fall through */
6179         case FIB_EVENT_ENTRY_ADD: /* fall through */
6180         case FIB_EVENT_ENTRY_DEL:
6181                 fen_info = container_of(info, struct fib_entry_notifier_info,
6182                                         info);
6183                 fib_work->fen_info = *fen_info;
6184                 /* Take reference on fib_info to prevent it from being
6185                  * freed while work is queued. Release it afterwards.
6186                  */
6187                 fib_info_hold(fib_work->fen_info.fi);
6188                 break;
6189         case FIB_EVENT_NH_ADD: /* fall through */
6190         case FIB_EVENT_NH_DEL:
6191                 fnh_info = container_of(info, struct fib_nh_notifier_info,
6192                                         info);
6193                 fib_work->fnh_info = *fnh_info;
6194                 fib_info_hold(fib_work->fnh_info.fib_nh->nh_parent);
6195                 break;
6196         }
6197 }
6198
6199 static int mlxsw_sp_router_fib6_event(struct mlxsw_sp_fib_event_work *fib_work,
6200                                       struct fib_notifier_info *info)
6201 {
6202         struct fib6_entry_notifier_info *fen6_info;
6203         int err;
6204
6205         switch (fib_work->event) {
6206         case FIB_EVENT_ENTRY_REPLACE: /* fall through */
6207         case FIB_EVENT_ENTRY_ADD: /* fall through */
6208         case FIB_EVENT_ENTRY_DEL:
6209                 fen6_info = container_of(info, struct fib6_entry_notifier_info,
6210                                          info);
6211                 err = mlxsw_sp_router_fib6_work_init(&fib_work->fib6_work,
6212                                                      fen6_info);
6213                 if (err)
6214                         return err;
6215                 break;
6216         }
6217
6218         return 0;
6219 }
6220
6221 static void
6222 mlxsw_sp_router_fibmr_event(struct mlxsw_sp_fib_event_work *fib_work,
6223                             struct fib_notifier_info *info)
6224 {
6225         switch (fib_work->event) {
6226         case FIB_EVENT_ENTRY_REPLACE: /* fall through */
6227         case FIB_EVENT_ENTRY_ADD: /* fall through */
6228         case FIB_EVENT_ENTRY_DEL:
6229                 memcpy(&fib_work->men_info, info, sizeof(fib_work->men_info));
6230                 mr_cache_hold(fib_work->men_info.mfc);
6231                 break;
6232         case FIB_EVENT_VIF_ADD: /* fall through */
6233         case FIB_EVENT_VIF_DEL:
6234                 memcpy(&fib_work->ven_info, info, sizeof(fib_work->ven_info));
6235                 dev_hold(fib_work->ven_info.dev);
6236                 break;
6237         }
6238 }
6239
6240 static int mlxsw_sp_router_fib_rule_event(unsigned long event,
6241                                           struct fib_notifier_info *info,
6242                                           struct mlxsw_sp *mlxsw_sp)
6243 {
6244         struct netlink_ext_ack *extack = info->extack;
6245         struct fib_rule_notifier_info *fr_info;
6246         struct fib_rule *rule;
6247         int err = 0;
6248
6249         /* nothing to do at the moment */
6250         if (event == FIB_EVENT_RULE_DEL)
6251                 return 0;
6252
6253         if (mlxsw_sp->router->aborted)
6254                 return 0;
6255
6256         fr_info = container_of(info, struct fib_rule_notifier_info, info);
6257         rule = fr_info->rule;
6258
6259         /* Rule only affects locally generated traffic */
6260         if (rule->iifindex == mlxsw_sp_net(mlxsw_sp)->loopback_dev->ifindex)
6261                 return 0;
6262
6263         switch (info->family) {
6264         case AF_INET:
6265                 if (!fib4_rule_default(rule) && !rule->l3mdev)
6266                         err = -EOPNOTSUPP;
6267                 break;
6268         case AF_INET6:
6269                 if (!fib6_rule_default(rule) && !rule->l3mdev)
6270                         err = -EOPNOTSUPP;
6271                 break;
6272         case RTNL_FAMILY_IPMR:
6273                 if (!ipmr_rule_default(rule) && !rule->l3mdev)
6274                         err = -EOPNOTSUPP;
6275                 break;
6276         case RTNL_FAMILY_IP6MR:
6277                 if (!ip6mr_rule_default(rule) && !rule->l3mdev)
6278                         err = -EOPNOTSUPP;
6279                 break;
6280         }
6281
6282         if (err < 0)
6283                 NL_SET_ERR_MSG_MOD(extack, "FIB rules not supported");
6284
6285         return err;
6286 }
6287
6288 /* Called with rcu_read_lock() */
6289 static int mlxsw_sp_router_fib_event(struct notifier_block *nb,
6290                                      unsigned long event, void *ptr)
6291 {
6292         struct mlxsw_sp_fib_event_work *fib_work;
6293         struct fib_notifier_info *info = ptr;
6294         struct mlxsw_sp_router *router;
6295         int err;
6296
6297         if ((info->family != AF_INET && info->family != AF_INET6 &&
6298              info->family != RTNL_FAMILY_IPMR &&
6299              info->family != RTNL_FAMILY_IP6MR))
6300                 return NOTIFY_DONE;
6301
6302         router = container_of(nb, struct mlxsw_sp_router, fib_nb);
6303
6304         switch (event) {
6305         case FIB_EVENT_RULE_ADD: /* fall through */
6306         case FIB_EVENT_RULE_DEL:
6307                 err = mlxsw_sp_router_fib_rule_event(event, info,
6308                                                      router->mlxsw_sp);
6309                 return notifier_from_errno(err);
6310         case FIB_EVENT_ENTRY_ADD:
6311         case FIB_EVENT_ENTRY_REPLACE: /* fall through */
6312         case FIB_EVENT_ENTRY_APPEND:  /* fall through */
6313                 if (router->aborted) {
6314                         NL_SET_ERR_MSG_MOD(info->extack, "FIB offload was aborted. Not configuring route");
6315                         return notifier_from_errno(-EINVAL);
6316                 }
6317                 if (info->family == AF_INET) {
6318                         struct fib_entry_notifier_info *fen_info = ptr;
6319
6320                         if (fen_info->fi->fib_nh_is_v6) {
6321                                 NL_SET_ERR_MSG_MOD(info->extack, "IPv6 gateway with IPv4 route is not supported");
6322                                 return notifier_from_errno(-EINVAL);
6323                         }
6324                         if (fen_info->fi->nh) {
6325                                 NL_SET_ERR_MSG_MOD(info->extack, "IPv4 route with nexthop objects is not supported");
6326                                 return notifier_from_errno(-EINVAL);
6327                         }
6328                 } else if (info->family == AF_INET6) {
6329                         struct fib6_entry_notifier_info *fen6_info;
6330
6331                         fen6_info = container_of(info,
6332                                                  struct fib6_entry_notifier_info,
6333                                                  info);
6334                         if (fen6_info->rt->nh) {
6335                                 NL_SET_ERR_MSG_MOD(info->extack, "IPv6 route with nexthop objects is not supported");
6336                                 return notifier_from_errno(-EINVAL);
6337                         }
6338                 }
6339                 break;
6340         }
6341
6342         fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC);
6343         if (WARN_ON(!fib_work))
6344                 return NOTIFY_BAD;
6345
6346         fib_work->mlxsw_sp = router->mlxsw_sp;
6347         fib_work->event = event;
6348
6349         switch (info->family) {
6350         case AF_INET:
6351                 INIT_WORK(&fib_work->work, mlxsw_sp_router_fib4_event_work);
6352                 mlxsw_sp_router_fib4_event(fib_work, info);
6353                 break;
6354         case AF_INET6:
6355                 INIT_WORK(&fib_work->work, mlxsw_sp_router_fib6_event_work);
6356                 err = mlxsw_sp_router_fib6_event(fib_work, info);
6357                 if (err)
6358                         goto err_fib_event;
6359                 break;
6360         case RTNL_FAMILY_IP6MR:
6361         case RTNL_FAMILY_IPMR:
6362                 INIT_WORK(&fib_work->work, mlxsw_sp_router_fibmr_event_work);
6363                 mlxsw_sp_router_fibmr_event(fib_work, info);
6364                 break;
6365         }
6366
6367         mlxsw_core_schedule_work(&fib_work->work);
6368
6369         return NOTIFY_DONE;
6370
6371 err_fib_event:
6372         kfree(fib_work);
6373         return NOTIFY_BAD;
6374 }
6375
6376 struct mlxsw_sp_rif *
6377 mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp,
6378                          const struct net_device *dev)
6379 {
6380         int i;
6381
6382         for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++)
6383                 if (mlxsw_sp->router->rifs[i] &&
6384                     mlxsw_sp->router->rifs[i]->dev == dev)
6385                         return mlxsw_sp->router->rifs[i];
6386
6387         return NULL;
6388 }
6389
6390 static int mlxsw_sp_router_rif_disable(struct mlxsw_sp *mlxsw_sp, u16 rif)
6391 {
6392         char ritr_pl[MLXSW_REG_RITR_LEN];
6393         int err;
6394
6395         mlxsw_reg_ritr_rif_pack(ritr_pl, rif);
6396         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
6397         if (err)
6398                 return err;
6399
6400         mlxsw_reg_ritr_enable_set(ritr_pl, false);
6401         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
6402 }
6403
6404 static void mlxsw_sp_router_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
6405                                           struct mlxsw_sp_rif *rif)
6406 {
6407         mlxsw_sp_router_rif_disable(mlxsw_sp, rif->rif_index);
6408         mlxsw_sp_nexthop_rif_gone_sync(mlxsw_sp, rif);
6409         mlxsw_sp_neigh_rif_gone_sync(mlxsw_sp, rif);
6410 }
6411
6412 static bool
6413 mlxsw_sp_rif_should_config(struct mlxsw_sp_rif *rif, struct net_device *dev,
6414                            unsigned long event)
6415 {
6416         struct inet6_dev *inet6_dev;
6417         bool addr_list_empty = true;
6418         struct in_device *idev;
6419
6420         switch (event) {
6421         case NETDEV_UP:
6422                 return rif == NULL;
6423         case NETDEV_DOWN:
6424                 idev = __in_dev_get_rtnl(dev);
6425                 if (idev && idev->ifa_list)
6426                         addr_list_empty = false;
6427
6428                 inet6_dev = __in6_dev_get(dev);
6429                 if (addr_list_empty && inet6_dev &&
6430                     !list_empty(&inet6_dev->addr_list))
6431                         addr_list_empty = false;
6432
6433                 /* macvlans do not have a RIF, but rather piggy back on the
6434                  * RIF of their lower device.
6435                  */
6436                 if (netif_is_macvlan(dev) && addr_list_empty)
6437                         return true;
6438
6439                 if (rif && addr_list_empty &&
6440                     !netif_is_l3_slave(rif->dev))
6441                         return true;
6442                 /* It is possible we already removed the RIF ourselves
6443                  * if it was assigned to a netdev that is now a bridge
6444                  * or LAG slave.
6445                  */
6446                 return false;
6447         }
6448
6449         return false;
6450 }
6451
6452 static enum mlxsw_sp_rif_type
6453 mlxsw_sp_dev_rif_type(const struct mlxsw_sp *mlxsw_sp,
6454                       const struct net_device *dev)
6455 {
6456         enum mlxsw_sp_fid_type type;
6457
6458         if (mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, NULL))
6459                 return MLXSW_SP_RIF_TYPE_IPIP_LB;
6460
6461         /* Otherwise RIF type is derived from the type of the underlying FID. */
6462         if (is_vlan_dev(dev) && netif_is_bridge_master(vlan_dev_real_dev(dev)))
6463                 type = MLXSW_SP_FID_TYPE_8021Q;
6464         else if (netif_is_bridge_master(dev) && br_vlan_enabled(dev))
6465                 type = MLXSW_SP_FID_TYPE_8021Q;
6466         else if (netif_is_bridge_master(dev))
6467                 type = MLXSW_SP_FID_TYPE_8021D;
6468         else
6469                 type = MLXSW_SP_FID_TYPE_RFID;
6470
6471         return mlxsw_sp_fid_type_rif_type(mlxsw_sp, type);
6472 }
6473
6474 static int mlxsw_sp_rif_index_alloc(struct mlxsw_sp *mlxsw_sp, u16 *p_rif_index)
6475 {
6476         int i;
6477
6478         for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) {
6479                 if (!mlxsw_sp->router->rifs[i]) {
6480                         *p_rif_index = i;
6481                         return 0;
6482                 }
6483         }
6484
6485         return -ENOBUFS;
6486 }
6487
6488 static struct mlxsw_sp_rif *mlxsw_sp_rif_alloc(size_t rif_size, u16 rif_index,
6489                                                u16 vr_id,
6490                                                struct net_device *l3_dev)
6491 {
6492         struct mlxsw_sp_rif *rif;
6493
6494         rif = kzalloc(rif_size, GFP_KERNEL);
6495         if (!rif)
6496                 return NULL;
6497
6498         INIT_LIST_HEAD(&rif->nexthop_list);
6499         INIT_LIST_HEAD(&rif->neigh_list);
6500         if (l3_dev) {
6501                 ether_addr_copy(rif->addr, l3_dev->dev_addr);
6502                 rif->mtu = l3_dev->mtu;
6503                 rif->dev = l3_dev;
6504         }
6505         rif->vr_id = vr_id;
6506         rif->rif_index = rif_index;
6507
6508         return rif;
6509 }
6510
6511 struct mlxsw_sp_rif *mlxsw_sp_rif_by_index(const struct mlxsw_sp *mlxsw_sp,
6512                                            u16 rif_index)
6513 {
6514         return mlxsw_sp->router->rifs[rif_index];
6515 }
6516
6517 u16 mlxsw_sp_rif_index(const struct mlxsw_sp_rif *rif)
6518 {
6519         return rif->rif_index;
6520 }
6521
6522 u16 mlxsw_sp_ipip_lb_rif_index(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
6523 {
6524         return lb_rif->common.rif_index;
6525 }
6526
6527 u16 mlxsw_sp_ipip_lb_ul_vr_id(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
6528 {
6529         u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(lb_rif->common.dev);
6530         struct mlxsw_sp_vr *ul_vr;
6531
6532         ul_vr = mlxsw_sp_vr_get(lb_rif->common.mlxsw_sp, ul_tb_id, NULL);
6533         if (WARN_ON(IS_ERR(ul_vr)))
6534                 return 0;
6535
6536         return ul_vr->id;
6537 }
6538
6539 u16 mlxsw_sp_ipip_lb_ul_rif_id(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
6540 {
6541         return lb_rif->ul_rif_id;
6542 }
6543
6544 int mlxsw_sp_rif_dev_ifindex(const struct mlxsw_sp_rif *rif)
6545 {
6546         return rif->dev->ifindex;
6547 }
6548
6549 const struct net_device *mlxsw_sp_rif_dev(const struct mlxsw_sp_rif *rif)
6550 {
6551         return rif->dev;
6552 }
6553
6554 struct mlxsw_sp_fid *mlxsw_sp_rif_fid(const struct mlxsw_sp_rif *rif)
6555 {
6556         return rif->fid;
6557 }
6558
6559 static struct mlxsw_sp_rif *
6560 mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp,
6561                     const struct mlxsw_sp_rif_params *params,
6562                     struct netlink_ext_ack *extack)
6563 {
6564         u32 tb_id = l3mdev_fib_table(params->dev);
6565         const struct mlxsw_sp_rif_ops *ops;
6566         struct mlxsw_sp_fid *fid = NULL;
6567         enum mlxsw_sp_rif_type type;
6568         struct mlxsw_sp_rif *rif;
6569         struct mlxsw_sp_vr *vr;
6570         u16 rif_index;
6571         int i, err;
6572
6573         type = mlxsw_sp_dev_rif_type(mlxsw_sp, params->dev);
6574         ops = mlxsw_sp->rif_ops_arr[type];
6575
6576         vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id ? : RT_TABLE_MAIN, extack);
6577         if (IS_ERR(vr))
6578                 return ERR_CAST(vr);
6579         vr->rif_count++;
6580
6581         err = mlxsw_sp_rif_index_alloc(mlxsw_sp, &rif_index);
6582         if (err) {
6583                 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported router interfaces");
6584                 goto err_rif_index_alloc;
6585         }
6586
6587         rif = mlxsw_sp_rif_alloc(ops->rif_size, rif_index, vr->id, params->dev);
6588         if (!rif) {
6589                 err = -ENOMEM;
6590                 goto err_rif_alloc;
6591         }
6592         dev_hold(rif->dev);
6593         mlxsw_sp->router->rifs[rif_index] = rif;
6594         rif->mlxsw_sp = mlxsw_sp;
6595         rif->ops = ops;
6596
6597         if (ops->fid_get) {
6598                 fid = ops->fid_get(rif, extack);
6599                 if (IS_ERR(fid)) {
6600                         err = PTR_ERR(fid);
6601                         goto err_fid_get;
6602                 }
6603                 rif->fid = fid;
6604         }
6605
6606         if (ops->setup)
6607                 ops->setup(rif, params);
6608
6609         err = ops->configure(rif);
6610         if (err)
6611                 goto err_configure;
6612
6613         for (i = 0; i < MLXSW_SP_L3_PROTO_MAX; i++) {
6614                 err = mlxsw_sp_mr_rif_add(vr->mr_table[i], rif);
6615                 if (err)
6616                         goto err_mr_rif_add;
6617         }
6618
6619         mlxsw_sp_rif_counters_alloc(rif);
6620
6621         return rif;
6622
6623 err_mr_rif_add:
6624         for (i--; i >= 0; i--)
6625                 mlxsw_sp_mr_rif_del(vr->mr_table[i], rif);
6626         ops->deconfigure(rif);
6627 err_configure:
6628         if (fid)
6629                 mlxsw_sp_fid_put(fid);
6630 err_fid_get:
6631         mlxsw_sp->router->rifs[rif_index] = NULL;
6632         dev_put(rif->dev);
6633         kfree(rif);
6634 err_rif_alloc:
6635 err_rif_index_alloc:
6636         vr->rif_count--;
6637         mlxsw_sp_vr_put(mlxsw_sp, vr);
6638         return ERR_PTR(err);
6639 }
6640
6641 static void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif)
6642 {
6643         const struct mlxsw_sp_rif_ops *ops = rif->ops;
6644         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
6645         struct mlxsw_sp_fid *fid = rif->fid;
6646         struct mlxsw_sp_vr *vr;
6647         int i;
6648
6649         mlxsw_sp_router_rif_gone_sync(mlxsw_sp, rif);
6650         vr = &mlxsw_sp->router->vrs[rif->vr_id];
6651
6652         mlxsw_sp_rif_counters_free(rif);
6653         for (i = 0; i < MLXSW_SP_L3_PROTO_MAX; i++)
6654                 mlxsw_sp_mr_rif_del(vr->mr_table[i], rif);
6655         ops->deconfigure(rif);
6656         if (fid)
6657                 /* Loopback RIFs are not associated with a FID. */
6658                 mlxsw_sp_fid_put(fid);
6659         mlxsw_sp->router->rifs[rif->rif_index] = NULL;
6660         dev_put(rif->dev);
6661         kfree(rif);
6662         vr->rif_count--;
6663         mlxsw_sp_vr_put(mlxsw_sp, vr);
6664 }
6665
6666 void mlxsw_sp_rif_destroy_by_dev(struct mlxsw_sp *mlxsw_sp,
6667                                  struct net_device *dev)
6668 {
6669         struct mlxsw_sp_rif *rif;
6670
6671         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
6672         if (!rif)
6673                 return;
6674         mlxsw_sp_rif_destroy(rif);
6675 }
6676
6677 static void
6678 mlxsw_sp_rif_subport_params_init(struct mlxsw_sp_rif_params *params,
6679                                  struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
6680 {
6681         struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
6682
6683         params->vid = mlxsw_sp_port_vlan->vid;
6684         params->lag = mlxsw_sp_port->lagged;
6685         if (params->lag)
6686                 params->lag_id = mlxsw_sp_port->lag_id;
6687         else
6688                 params->system_port = mlxsw_sp_port->local_port;
6689 }
6690
6691 static struct mlxsw_sp_rif_subport *
6692 mlxsw_sp_rif_subport_rif(const struct mlxsw_sp_rif *rif)
6693 {
6694         return container_of(rif, struct mlxsw_sp_rif_subport, common);
6695 }
6696
6697 static struct mlxsw_sp_rif *
6698 mlxsw_sp_rif_subport_get(struct mlxsw_sp *mlxsw_sp,
6699                          const struct mlxsw_sp_rif_params *params,
6700                          struct netlink_ext_ack *extack)
6701 {
6702         struct mlxsw_sp_rif_subport *rif_subport;
6703         struct mlxsw_sp_rif *rif;
6704
6705         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, params->dev);
6706         if (!rif)
6707                 return mlxsw_sp_rif_create(mlxsw_sp, params, extack);
6708
6709         rif_subport = mlxsw_sp_rif_subport_rif(rif);
6710         refcount_inc(&rif_subport->ref_count);
6711         return rif;
6712 }
6713
6714 static void mlxsw_sp_rif_subport_put(struct mlxsw_sp_rif *rif)
6715 {
6716         struct mlxsw_sp_rif_subport *rif_subport;
6717
6718         rif_subport = mlxsw_sp_rif_subport_rif(rif);
6719         if (!refcount_dec_and_test(&rif_subport->ref_count))
6720                 return;
6721
6722         mlxsw_sp_rif_destroy(rif);
6723 }
6724
6725 static int
6726 mlxsw_sp_port_vlan_router_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
6727                                struct net_device *l3_dev,
6728                                struct netlink_ext_ack *extack)
6729 {
6730         struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
6731         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
6732         struct mlxsw_sp_rif_params params = {
6733                 .dev = l3_dev,
6734         };
6735         u16 vid = mlxsw_sp_port_vlan->vid;
6736         struct mlxsw_sp_rif *rif;
6737         struct mlxsw_sp_fid *fid;
6738         int err;
6739
6740         mlxsw_sp_rif_subport_params_init(&params, mlxsw_sp_port_vlan);
6741         rif = mlxsw_sp_rif_subport_get(mlxsw_sp, &params, extack);
6742         if (IS_ERR(rif))
6743                 return PTR_ERR(rif);
6744
6745         /* FID was already created, just take a reference */
6746         fid = rif->ops->fid_get(rif, extack);
6747         err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid);
6748         if (err)
6749                 goto err_fid_port_vid_map;
6750
6751         err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
6752         if (err)
6753                 goto err_port_vid_learning_set;
6754
6755         err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid,
6756                                         BR_STATE_FORWARDING);
6757         if (err)
6758                 goto err_port_vid_stp_set;
6759
6760         mlxsw_sp_port_vlan->fid = fid;
6761
6762         return 0;
6763
6764 err_port_vid_stp_set:
6765         mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
6766 err_port_vid_learning_set:
6767         mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
6768 err_fid_port_vid_map:
6769         mlxsw_sp_fid_put(fid);
6770         mlxsw_sp_rif_subport_put(rif);
6771         return err;
6772 }
6773
6774 void
6775 mlxsw_sp_port_vlan_router_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
6776 {
6777         struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
6778         struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
6779         struct mlxsw_sp_rif *rif = mlxsw_sp_fid_rif(fid);
6780         u16 vid = mlxsw_sp_port_vlan->vid;
6781
6782         if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_RFID))
6783                 return;
6784
6785         mlxsw_sp_port_vlan->fid = NULL;
6786         mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_BLOCKING);
6787         mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
6788         mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
6789         mlxsw_sp_fid_put(fid);
6790         mlxsw_sp_rif_subport_put(rif);
6791 }
6792
6793 static int mlxsw_sp_inetaddr_port_vlan_event(struct net_device *l3_dev,
6794                                              struct net_device *port_dev,
6795                                              unsigned long event, u16 vid,
6796                                              struct netlink_ext_ack *extack)
6797 {
6798         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(port_dev);
6799         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
6800
6801         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
6802         if (WARN_ON(!mlxsw_sp_port_vlan))
6803                 return -EINVAL;
6804
6805         switch (event) {
6806         case NETDEV_UP:
6807                 return mlxsw_sp_port_vlan_router_join(mlxsw_sp_port_vlan,
6808                                                       l3_dev, extack);
6809         case NETDEV_DOWN:
6810                 mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
6811                 break;
6812         }
6813
6814         return 0;
6815 }
6816
6817 static int mlxsw_sp_inetaddr_port_event(struct net_device *port_dev,
6818                                         unsigned long event,
6819                                         struct netlink_ext_ack *extack)
6820 {
6821         if (netif_is_bridge_port(port_dev) ||
6822             netif_is_lag_port(port_dev) ||
6823             netif_is_ovs_port(port_dev))
6824                 return 0;
6825
6826         return mlxsw_sp_inetaddr_port_vlan_event(port_dev, port_dev, event,
6827                                                  MLXSW_SP_DEFAULT_VID, extack);
6828 }
6829
6830 static int __mlxsw_sp_inetaddr_lag_event(struct net_device *l3_dev,
6831                                          struct net_device *lag_dev,
6832                                          unsigned long event, u16 vid,
6833                                          struct netlink_ext_ack *extack)
6834 {
6835         struct net_device *port_dev;
6836         struct list_head *iter;
6837         int err;
6838
6839         netdev_for_each_lower_dev(lag_dev, port_dev, iter) {
6840                 if (mlxsw_sp_port_dev_check(port_dev)) {
6841                         err = mlxsw_sp_inetaddr_port_vlan_event(l3_dev,
6842                                                                 port_dev,
6843                                                                 event, vid,
6844                                                                 extack);
6845                         if (err)
6846                                 return err;
6847                 }
6848         }
6849
6850         return 0;
6851 }
6852
6853 static int mlxsw_sp_inetaddr_lag_event(struct net_device *lag_dev,
6854                                        unsigned long event,
6855                                        struct netlink_ext_ack *extack)
6856 {
6857         if (netif_is_bridge_port(lag_dev))
6858                 return 0;
6859
6860         return __mlxsw_sp_inetaddr_lag_event(lag_dev, lag_dev, event,
6861                                              MLXSW_SP_DEFAULT_VID, extack);
6862 }
6863
6864 static int mlxsw_sp_inetaddr_bridge_event(struct mlxsw_sp *mlxsw_sp,
6865                                           struct net_device *l3_dev,
6866                                           unsigned long event,
6867                                           struct netlink_ext_ack *extack)
6868 {
6869         struct mlxsw_sp_rif_params params = {
6870                 .dev = l3_dev,
6871         };
6872         struct mlxsw_sp_rif *rif;
6873
6874         switch (event) {
6875         case NETDEV_UP:
6876                 rif = mlxsw_sp_rif_create(mlxsw_sp, &params, extack);
6877                 if (IS_ERR(rif))
6878                         return PTR_ERR(rif);
6879                 break;
6880         case NETDEV_DOWN:
6881                 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
6882                 mlxsw_sp_rif_destroy(rif);
6883                 break;
6884         }
6885
6886         return 0;
6887 }
6888
6889 static int mlxsw_sp_inetaddr_vlan_event(struct mlxsw_sp *mlxsw_sp,
6890                                         struct net_device *vlan_dev,
6891                                         unsigned long event,
6892                                         struct netlink_ext_ack *extack)
6893 {
6894         struct net_device *real_dev = vlan_dev_real_dev(vlan_dev);
6895         u16 vid = vlan_dev_vlan_id(vlan_dev);
6896
6897         if (netif_is_bridge_port(vlan_dev))
6898                 return 0;
6899
6900         if (mlxsw_sp_port_dev_check(real_dev))
6901                 return mlxsw_sp_inetaddr_port_vlan_event(vlan_dev, real_dev,
6902                                                          event, vid, extack);
6903         else if (netif_is_lag_master(real_dev))
6904                 return __mlxsw_sp_inetaddr_lag_event(vlan_dev, real_dev, event,
6905                                                      vid, extack);
6906         else if (netif_is_bridge_master(real_dev) && br_vlan_enabled(real_dev))
6907                 return mlxsw_sp_inetaddr_bridge_event(mlxsw_sp, vlan_dev, event,
6908                                                       extack);
6909
6910         return 0;
6911 }
6912
6913 static bool mlxsw_sp_rif_macvlan_is_vrrp4(const u8 *mac)
6914 {
6915         u8 vrrp4[ETH_ALEN] = { 0x00, 0x00, 0x5e, 0x00, 0x01, 0x00 };
6916         u8 mask[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
6917
6918         return ether_addr_equal_masked(mac, vrrp4, mask);
6919 }
6920
6921 static bool mlxsw_sp_rif_macvlan_is_vrrp6(const u8 *mac)
6922 {
6923         u8 vrrp6[ETH_ALEN] = { 0x00, 0x00, 0x5e, 0x00, 0x02, 0x00 };
6924         u8 mask[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
6925
6926         return ether_addr_equal_masked(mac, vrrp6, mask);
6927 }
6928
6929 static int mlxsw_sp_rif_vrrp_op(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
6930                                 const u8 *mac, bool adding)
6931 {
6932         char ritr_pl[MLXSW_REG_RITR_LEN];
6933         u8 vrrp_id = adding ? mac[5] : 0;
6934         int err;
6935
6936         if (!mlxsw_sp_rif_macvlan_is_vrrp4(mac) &&
6937             !mlxsw_sp_rif_macvlan_is_vrrp6(mac))
6938                 return 0;
6939
6940         mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
6941         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
6942         if (err)
6943                 return err;
6944
6945         if (mlxsw_sp_rif_macvlan_is_vrrp4(mac))
6946                 mlxsw_reg_ritr_if_vrrp_id_ipv4_set(ritr_pl, vrrp_id);
6947         else
6948                 mlxsw_reg_ritr_if_vrrp_id_ipv6_set(ritr_pl, vrrp_id);
6949
6950         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
6951 }
6952
6953 static int mlxsw_sp_rif_macvlan_add(struct mlxsw_sp *mlxsw_sp,
6954                                     const struct net_device *macvlan_dev,
6955                                     struct netlink_ext_ack *extack)
6956 {
6957         struct macvlan_dev *vlan = netdev_priv(macvlan_dev);
6958         struct mlxsw_sp_rif *rif;
6959         int err;
6960
6961         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, vlan->lowerdev);
6962         if (!rif) {
6963                 NL_SET_ERR_MSG_MOD(extack, "macvlan is only supported on top of router interfaces");
6964                 return -EOPNOTSUPP;
6965         }
6966
6967         err = mlxsw_sp_rif_fdb_op(mlxsw_sp, macvlan_dev->dev_addr,
6968                                   mlxsw_sp_fid_index(rif->fid), true);
6969         if (err)
6970                 return err;
6971
6972         err = mlxsw_sp_rif_vrrp_op(mlxsw_sp, rif->rif_index,
6973                                    macvlan_dev->dev_addr, true);
6974         if (err)
6975                 goto err_rif_vrrp_add;
6976
6977         /* Make sure the bridge driver does not have this MAC pointing at
6978          * some other port.
6979          */
6980         if (rif->ops->fdb_del)
6981                 rif->ops->fdb_del(rif, macvlan_dev->dev_addr);
6982
6983         return 0;
6984
6985 err_rif_vrrp_add:
6986         mlxsw_sp_rif_fdb_op(mlxsw_sp, macvlan_dev->dev_addr,
6987                             mlxsw_sp_fid_index(rif->fid), false);
6988         return err;
6989 }
6990
6991 void mlxsw_sp_rif_macvlan_del(struct mlxsw_sp *mlxsw_sp,
6992                               const struct net_device *macvlan_dev)
6993 {
6994         struct macvlan_dev *vlan = netdev_priv(macvlan_dev);
6995         struct mlxsw_sp_rif *rif;
6996
6997         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, vlan->lowerdev);
6998         /* If we do not have a RIF, then we already took care of
6999          * removing the macvlan's MAC during RIF deletion.
7000          */
7001         if (!rif)
7002                 return;
7003         mlxsw_sp_rif_vrrp_op(mlxsw_sp, rif->rif_index, macvlan_dev->dev_addr,
7004                              false);
7005         mlxsw_sp_rif_fdb_op(mlxsw_sp, macvlan_dev->dev_addr,
7006                             mlxsw_sp_fid_index(rif->fid), false);
7007 }
7008
7009 static int mlxsw_sp_inetaddr_macvlan_event(struct mlxsw_sp *mlxsw_sp,
7010                                            struct net_device *macvlan_dev,
7011                                            unsigned long event,
7012                                            struct netlink_ext_ack *extack)
7013 {
7014         switch (event) {
7015         case NETDEV_UP:
7016                 return mlxsw_sp_rif_macvlan_add(mlxsw_sp, macvlan_dev, extack);
7017         case NETDEV_DOWN:
7018                 mlxsw_sp_rif_macvlan_del(mlxsw_sp, macvlan_dev);
7019                 break;
7020         }
7021
7022         return 0;
7023 }
7024
7025 static int mlxsw_sp_router_port_check_rif_addr(struct mlxsw_sp *mlxsw_sp,
7026                                                struct net_device *dev,
7027                                                const unsigned char *dev_addr,
7028                                                struct netlink_ext_ack *extack)
7029 {
7030         struct mlxsw_sp_rif *rif;
7031         int i;
7032
7033         /* A RIF is not created for macvlan netdevs. Their MAC is used to
7034          * populate the FDB
7035          */
7036         if (netif_is_macvlan(dev) || netif_is_l3_master(dev))
7037                 return 0;
7038
7039         for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) {
7040                 rif = mlxsw_sp->router->rifs[i];
7041                 if (rif && rif->dev && rif->dev != dev &&
7042                     !ether_addr_equal_masked(rif->dev->dev_addr, dev_addr,
7043                                              mlxsw_sp->mac_mask)) {
7044                         NL_SET_ERR_MSG_MOD(extack, "All router interface MAC addresses must have the same prefix");
7045                         return -EINVAL;
7046                 }
7047         }
7048
7049         return 0;
7050 }
7051
7052 static int __mlxsw_sp_inetaddr_event(struct mlxsw_sp *mlxsw_sp,
7053                                      struct net_device *dev,
7054                                      unsigned long event,
7055                                      struct netlink_ext_ack *extack)
7056 {
7057         if (mlxsw_sp_port_dev_check(dev))
7058                 return mlxsw_sp_inetaddr_port_event(dev, event, extack);
7059         else if (netif_is_lag_master(dev))
7060                 return mlxsw_sp_inetaddr_lag_event(dev, event, extack);
7061         else if (netif_is_bridge_master(dev))
7062                 return mlxsw_sp_inetaddr_bridge_event(mlxsw_sp, dev, event,
7063                                                       extack);
7064         else if (is_vlan_dev(dev))
7065                 return mlxsw_sp_inetaddr_vlan_event(mlxsw_sp, dev, event,
7066                                                     extack);
7067         else if (netif_is_macvlan(dev))
7068                 return mlxsw_sp_inetaddr_macvlan_event(mlxsw_sp, dev, event,
7069                                                        extack);
7070         else
7071                 return 0;
7072 }
7073
7074 static int mlxsw_sp_inetaddr_event(struct notifier_block *nb,
7075                                    unsigned long event, void *ptr)
7076 {
7077         struct in_ifaddr *ifa = (struct in_ifaddr *) ptr;
7078         struct net_device *dev = ifa->ifa_dev->dev;
7079         struct mlxsw_sp_router *router;
7080         struct mlxsw_sp_rif *rif;
7081         int err = 0;
7082
7083         /* NETDEV_UP event is handled by mlxsw_sp_inetaddr_valid_event */
7084         if (event == NETDEV_UP)
7085                 goto out;
7086
7087         router = container_of(nb, struct mlxsw_sp_router, inetaddr_nb);
7088         rif = mlxsw_sp_rif_find_by_dev(router->mlxsw_sp, dev);
7089         if (!mlxsw_sp_rif_should_config(rif, dev, event))
7090                 goto out;
7091
7092         err = __mlxsw_sp_inetaddr_event(router->mlxsw_sp, dev, event, NULL);
7093 out:
7094         return notifier_from_errno(err);
7095 }
7096
7097 int mlxsw_sp_inetaddr_valid_event(struct notifier_block *unused,
7098                                   unsigned long event, void *ptr)
7099 {
7100         struct in_validator_info *ivi = (struct in_validator_info *) ptr;
7101         struct net_device *dev = ivi->ivi_dev->dev;
7102         struct mlxsw_sp *mlxsw_sp;
7103         struct mlxsw_sp_rif *rif;
7104         int err = 0;
7105
7106         mlxsw_sp = mlxsw_sp_lower_get(dev);
7107         if (!mlxsw_sp)
7108                 goto out;
7109
7110         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
7111         if (!mlxsw_sp_rif_should_config(rif, dev, event))
7112                 goto out;
7113
7114         err = mlxsw_sp_router_port_check_rif_addr(mlxsw_sp, dev, dev->dev_addr,
7115                                                   ivi->extack);
7116         if (err)
7117                 goto out;
7118
7119         err = __mlxsw_sp_inetaddr_event(mlxsw_sp, dev, event, ivi->extack);
7120 out:
7121         return notifier_from_errno(err);
7122 }
7123
7124 struct mlxsw_sp_inet6addr_event_work {
7125         struct work_struct work;
7126         struct mlxsw_sp *mlxsw_sp;
7127         struct net_device *dev;
7128         unsigned long event;
7129 };
7130
7131 static void mlxsw_sp_inet6addr_event_work(struct work_struct *work)
7132 {
7133         struct mlxsw_sp_inet6addr_event_work *inet6addr_work =
7134                 container_of(work, struct mlxsw_sp_inet6addr_event_work, work);
7135         struct mlxsw_sp *mlxsw_sp = inet6addr_work->mlxsw_sp;
7136         struct net_device *dev = inet6addr_work->dev;
7137         unsigned long event = inet6addr_work->event;
7138         struct mlxsw_sp_rif *rif;
7139
7140         rtnl_lock();
7141
7142         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
7143         if (!mlxsw_sp_rif_should_config(rif, dev, event))
7144                 goto out;
7145
7146         __mlxsw_sp_inetaddr_event(mlxsw_sp, dev, event, NULL);
7147 out:
7148         rtnl_unlock();
7149         dev_put(dev);
7150         kfree(inet6addr_work);
7151 }
7152
7153 /* Called with rcu_read_lock() */
7154 static int mlxsw_sp_inet6addr_event(struct notifier_block *nb,
7155                                     unsigned long event, void *ptr)
7156 {
7157         struct inet6_ifaddr *if6 = (struct inet6_ifaddr *) ptr;
7158         struct mlxsw_sp_inet6addr_event_work *inet6addr_work;
7159         struct net_device *dev = if6->idev->dev;
7160         struct mlxsw_sp_router *router;
7161
7162         /* NETDEV_UP event is handled by mlxsw_sp_inet6addr_valid_event */
7163         if (event == NETDEV_UP)
7164                 return NOTIFY_DONE;
7165
7166         inet6addr_work = kzalloc(sizeof(*inet6addr_work), GFP_ATOMIC);
7167         if (!inet6addr_work)
7168                 return NOTIFY_BAD;
7169
7170         router = container_of(nb, struct mlxsw_sp_router, inet6addr_nb);
7171         INIT_WORK(&inet6addr_work->work, mlxsw_sp_inet6addr_event_work);
7172         inet6addr_work->mlxsw_sp = router->mlxsw_sp;
7173         inet6addr_work->dev = dev;
7174         inet6addr_work->event = event;
7175         dev_hold(dev);
7176         mlxsw_core_schedule_work(&inet6addr_work->work);
7177
7178         return NOTIFY_DONE;
7179 }
7180
7181 int mlxsw_sp_inet6addr_valid_event(struct notifier_block *unused,
7182                                    unsigned long event, void *ptr)
7183 {
7184         struct in6_validator_info *i6vi = (struct in6_validator_info *) ptr;
7185         struct net_device *dev = i6vi->i6vi_dev->dev;
7186         struct mlxsw_sp *mlxsw_sp;
7187         struct mlxsw_sp_rif *rif;
7188         int err = 0;
7189
7190         mlxsw_sp = mlxsw_sp_lower_get(dev);
7191         if (!mlxsw_sp)
7192                 goto out;
7193
7194         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
7195         if (!mlxsw_sp_rif_should_config(rif, dev, event))
7196                 goto out;
7197
7198         err = mlxsw_sp_router_port_check_rif_addr(mlxsw_sp, dev, dev->dev_addr,
7199                                                   i6vi->extack);
7200         if (err)
7201                 goto out;
7202
7203         err = __mlxsw_sp_inetaddr_event(mlxsw_sp, dev, event, i6vi->extack);
7204 out:
7205         return notifier_from_errno(err);
7206 }
7207
7208 static int mlxsw_sp_rif_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
7209                              const char *mac, int mtu)
7210 {
7211         char ritr_pl[MLXSW_REG_RITR_LEN];
7212         int err;
7213
7214         mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
7215         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
7216         if (err)
7217                 return err;
7218
7219         mlxsw_reg_ritr_mtu_set(ritr_pl, mtu);
7220         mlxsw_reg_ritr_if_mac_memcpy_to(ritr_pl, mac);
7221         mlxsw_reg_ritr_op_set(ritr_pl, MLXSW_REG_RITR_RIF_CREATE);
7222         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
7223 }
7224
7225 static int
7226 mlxsw_sp_router_port_change_event(struct mlxsw_sp *mlxsw_sp,
7227                                   struct mlxsw_sp_rif *rif)
7228 {
7229         struct net_device *dev = rif->dev;
7230         u16 fid_index;
7231         int err;
7232
7233         fid_index = mlxsw_sp_fid_index(rif->fid);
7234
7235         err = mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, false);
7236         if (err)
7237                 return err;
7238
7239         err = mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, dev->dev_addr,
7240                                 dev->mtu);
7241         if (err)
7242                 goto err_rif_edit;
7243
7244         err = mlxsw_sp_rif_fdb_op(mlxsw_sp, dev->dev_addr, fid_index, true);
7245         if (err)
7246                 goto err_rif_fdb_op;
7247
7248         if (rif->mtu != dev->mtu) {
7249                 struct mlxsw_sp_vr *vr;
7250                 int i;
7251
7252                 /* The RIF is relevant only to its mr_table instance, as unlike
7253                  * unicast routing, in multicast routing a RIF cannot be shared
7254                  * between several multicast routing tables.
7255                  */
7256                 vr = &mlxsw_sp->router->vrs[rif->vr_id];
7257                 for (i = 0; i < MLXSW_SP_L3_PROTO_MAX; i++)
7258                         mlxsw_sp_mr_rif_mtu_update(vr->mr_table[i],
7259                                                    rif, dev->mtu);
7260         }
7261
7262         ether_addr_copy(rif->addr, dev->dev_addr);
7263         rif->mtu = dev->mtu;
7264
7265         netdev_dbg(dev, "Updated RIF=%d\n", rif->rif_index);
7266
7267         return 0;
7268
7269 err_rif_fdb_op:
7270         mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, rif->addr, rif->mtu);
7271 err_rif_edit:
7272         mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, true);
7273         return err;
7274 }
7275
7276 static int mlxsw_sp_router_port_pre_changeaddr_event(struct mlxsw_sp_rif *rif,
7277                             struct netdev_notifier_pre_changeaddr_info *info)
7278 {
7279         struct netlink_ext_ack *extack;
7280
7281         extack = netdev_notifier_info_to_extack(&info->info);
7282         return mlxsw_sp_router_port_check_rif_addr(rif->mlxsw_sp, rif->dev,
7283                                                    info->dev_addr, extack);
7284 }
7285
7286 int mlxsw_sp_netdevice_router_port_event(struct net_device *dev,
7287                                          unsigned long event, void *ptr)
7288 {
7289         struct mlxsw_sp *mlxsw_sp;
7290         struct mlxsw_sp_rif *rif;
7291
7292         mlxsw_sp = mlxsw_sp_lower_get(dev);
7293         if (!mlxsw_sp)
7294                 return 0;
7295
7296         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
7297         if (!rif)
7298                 return 0;
7299
7300         switch (event) {
7301         case NETDEV_CHANGEMTU: /* fall through */
7302         case NETDEV_CHANGEADDR:
7303                 return mlxsw_sp_router_port_change_event(mlxsw_sp, rif);
7304         case NETDEV_PRE_CHANGEADDR:
7305                 return mlxsw_sp_router_port_pre_changeaddr_event(rif, ptr);
7306         }
7307
7308         return 0;
7309 }
7310
7311 static int mlxsw_sp_port_vrf_join(struct mlxsw_sp *mlxsw_sp,
7312                                   struct net_device *l3_dev,
7313                                   struct netlink_ext_ack *extack)
7314 {
7315         struct mlxsw_sp_rif *rif;
7316
7317         /* If netdev is already associated with a RIF, then we need to
7318          * destroy it and create a new one with the new virtual router ID.
7319          */
7320         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
7321         if (rif)
7322                 __mlxsw_sp_inetaddr_event(mlxsw_sp, l3_dev, NETDEV_DOWN,
7323                                           extack);
7324
7325         return __mlxsw_sp_inetaddr_event(mlxsw_sp, l3_dev, NETDEV_UP, extack);
7326 }
7327
7328 static void mlxsw_sp_port_vrf_leave(struct mlxsw_sp *mlxsw_sp,
7329                                     struct net_device *l3_dev)
7330 {
7331         struct mlxsw_sp_rif *rif;
7332
7333         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
7334         if (!rif)
7335                 return;
7336         __mlxsw_sp_inetaddr_event(mlxsw_sp, l3_dev, NETDEV_DOWN, NULL);
7337 }
7338
7339 int mlxsw_sp_netdevice_vrf_event(struct net_device *l3_dev, unsigned long event,
7340                                  struct netdev_notifier_changeupper_info *info)
7341 {
7342         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(l3_dev);
7343         int err = 0;
7344
7345         /* We do not create a RIF for a macvlan, but only use it to
7346          * direct more MAC addresses to the router.
7347          */
7348         if (!mlxsw_sp || netif_is_macvlan(l3_dev))
7349                 return 0;
7350
7351         switch (event) {
7352         case NETDEV_PRECHANGEUPPER:
7353                 return 0;
7354         case NETDEV_CHANGEUPPER:
7355                 if (info->linking) {
7356                         struct netlink_ext_ack *extack;
7357
7358                         extack = netdev_notifier_info_to_extack(&info->info);
7359                         err = mlxsw_sp_port_vrf_join(mlxsw_sp, l3_dev, extack);
7360                 } else {
7361                         mlxsw_sp_port_vrf_leave(mlxsw_sp, l3_dev);
7362                 }
7363                 break;
7364         }
7365
7366         return err;
7367 }
7368
7369 static int __mlxsw_sp_rif_macvlan_flush(struct net_device *dev, void *data)
7370 {
7371         struct mlxsw_sp_rif *rif = data;
7372
7373         if (!netif_is_macvlan(dev))
7374                 return 0;
7375
7376         return mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, dev->dev_addr,
7377                                    mlxsw_sp_fid_index(rif->fid), false);
7378 }
7379
7380 static int mlxsw_sp_rif_macvlan_flush(struct mlxsw_sp_rif *rif)
7381 {
7382         if (!netif_is_macvlan_port(rif->dev))
7383                 return 0;
7384
7385         netdev_warn(rif->dev, "Router interface is deleted. Upper macvlans will not work\n");
7386         return netdev_walk_all_upper_dev_rcu(rif->dev,
7387                                              __mlxsw_sp_rif_macvlan_flush, rif);
7388 }
7389
7390 static void mlxsw_sp_rif_subport_setup(struct mlxsw_sp_rif *rif,
7391                                        const struct mlxsw_sp_rif_params *params)
7392 {
7393         struct mlxsw_sp_rif_subport *rif_subport;
7394
7395         rif_subport = mlxsw_sp_rif_subport_rif(rif);
7396         refcount_set(&rif_subport->ref_count, 1);
7397         rif_subport->vid = params->vid;
7398         rif_subport->lag = params->lag;
7399         if (params->lag)
7400                 rif_subport->lag_id = params->lag_id;
7401         else
7402                 rif_subport->system_port = params->system_port;
7403 }
7404
7405 static int mlxsw_sp_rif_subport_op(struct mlxsw_sp_rif *rif, bool enable)
7406 {
7407         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
7408         struct mlxsw_sp_rif_subport *rif_subport;
7409         char ritr_pl[MLXSW_REG_RITR_LEN];
7410
7411         rif_subport = mlxsw_sp_rif_subport_rif(rif);
7412         mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_SP_IF,
7413                             rif->rif_index, rif->vr_id, rif->dev->mtu);
7414         mlxsw_reg_ritr_mac_pack(ritr_pl, rif->dev->dev_addr);
7415         mlxsw_reg_ritr_sp_if_pack(ritr_pl, rif_subport->lag,
7416                                   rif_subport->lag ? rif_subport->lag_id :
7417                                                      rif_subport->system_port,
7418                                   rif_subport->vid);
7419
7420         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
7421 }
7422
7423 static int mlxsw_sp_rif_subport_configure(struct mlxsw_sp_rif *rif)
7424 {
7425         int err;
7426
7427         err = mlxsw_sp_rif_subport_op(rif, true);
7428         if (err)
7429                 return err;
7430
7431         err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
7432                                   mlxsw_sp_fid_index(rif->fid), true);
7433         if (err)
7434                 goto err_rif_fdb_op;
7435
7436         mlxsw_sp_fid_rif_set(rif->fid, rif);
7437         return 0;
7438
7439 err_rif_fdb_op:
7440         mlxsw_sp_rif_subport_op(rif, false);
7441         return err;
7442 }
7443
7444 static void mlxsw_sp_rif_subport_deconfigure(struct mlxsw_sp_rif *rif)
7445 {
7446         struct mlxsw_sp_fid *fid = rif->fid;
7447
7448         mlxsw_sp_fid_rif_set(fid, NULL);
7449         mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
7450                             mlxsw_sp_fid_index(fid), false);
7451         mlxsw_sp_rif_macvlan_flush(rif);
7452         mlxsw_sp_rif_subport_op(rif, false);
7453 }
7454
7455 static struct mlxsw_sp_fid *
7456 mlxsw_sp_rif_subport_fid_get(struct mlxsw_sp_rif *rif,
7457                              struct netlink_ext_ack *extack)
7458 {
7459         return mlxsw_sp_fid_rfid_get(rif->mlxsw_sp, rif->rif_index);
7460 }
7461
7462 static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_subport_ops = {
7463         .type                   = MLXSW_SP_RIF_TYPE_SUBPORT,
7464         .rif_size               = sizeof(struct mlxsw_sp_rif_subport),
7465         .setup                  = mlxsw_sp_rif_subport_setup,
7466         .configure              = mlxsw_sp_rif_subport_configure,
7467         .deconfigure            = mlxsw_sp_rif_subport_deconfigure,
7468         .fid_get                = mlxsw_sp_rif_subport_fid_get,
7469 };
7470
7471 static int mlxsw_sp_rif_vlan_fid_op(struct mlxsw_sp_rif *rif,
7472                                     enum mlxsw_reg_ritr_if_type type,
7473                                     u16 vid_fid, bool enable)
7474 {
7475         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
7476         char ritr_pl[MLXSW_REG_RITR_LEN];
7477
7478         mlxsw_reg_ritr_pack(ritr_pl, enable, type, rif->rif_index, rif->vr_id,
7479                             rif->dev->mtu);
7480         mlxsw_reg_ritr_mac_pack(ritr_pl, rif->dev->dev_addr);
7481         mlxsw_reg_ritr_fid_set(ritr_pl, type, vid_fid);
7482
7483         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
7484 }
7485
7486 u8 mlxsw_sp_router_port(const struct mlxsw_sp *mlxsw_sp)
7487 {
7488         return mlxsw_core_max_ports(mlxsw_sp->core) + 1;
7489 }
7490
7491 static int mlxsw_sp_rif_vlan_configure(struct mlxsw_sp_rif *rif)
7492 {
7493         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
7494         u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
7495         int err;
7496
7497         err = mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, true);
7498         if (err)
7499                 return err;
7500
7501         err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
7502                                      mlxsw_sp_router_port(mlxsw_sp), true);
7503         if (err)
7504                 goto err_fid_mc_flood_set;
7505
7506         err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
7507                                      mlxsw_sp_router_port(mlxsw_sp), true);
7508         if (err)
7509                 goto err_fid_bc_flood_set;
7510
7511         err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
7512                                   mlxsw_sp_fid_index(rif->fid), true);
7513         if (err)
7514                 goto err_rif_fdb_op;
7515
7516         mlxsw_sp_fid_rif_set(rif->fid, rif);
7517         return 0;
7518
7519 err_rif_fdb_op:
7520         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
7521                                mlxsw_sp_router_port(mlxsw_sp), false);
7522 err_fid_bc_flood_set:
7523         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
7524                                mlxsw_sp_router_port(mlxsw_sp), false);
7525 err_fid_mc_flood_set:
7526         mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, false);
7527         return err;
7528 }
7529
7530 static void mlxsw_sp_rif_vlan_deconfigure(struct mlxsw_sp_rif *rif)
7531 {
7532         u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
7533         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
7534         struct mlxsw_sp_fid *fid = rif->fid;
7535
7536         mlxsw_sp_fid_rif_set(fid, NULL);
7537         mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
7538                             mlxsw_sp_fid_index(fid), false);
7539         mlxsw_sp_rif_macvlan_flush(rif);
7540         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
7541                                mlxsw_sp_router_port(mlxsw_sp), false);
7542         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
7543                                mlxsw_sp_router_port(mlxsw_sp), false);
7544         mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, false);
7545 }
7546
7547 static struct mlxsw_sp_fid *
7548 mlxsw_sp_rif_vlan_fid_get(struct mlxsw_sp_rif *rif,
7549                           struct netlink_ext_ack *extack)
7550 {
7551         struct net_device *br_dev = rif->dev;
7552         u16 vid;
7553         int err;
7554
7555         if (is_vlan_dev(rif->dev)) {
7556                 vid = vlan_dev_vlan_id(rif->dev);
7557                 br_dev = vlan_dev_real_dev(rif->dev);
7558                 if (WARN_ON(!netif_is_bridge_master(br_dev)))
7559                         return ERR_PTR(-EINVAL);
7560         } else {
7561                 err = br_vlan_get_pvid(rif->dev, &vid);
7562                 if (err < 0 || !vid) {
7563                         NL_SET_ERR_MSG_MOD(extack, "Couldn't determine bridge PVID");
7564                         return ERR_PTR(-EINVAL);
7565                 }
7566         }
7567
7568         return mlxsw_sp_bridge_fid_get(rif->mlxsw_sp, br_dev, vid, extack);
7569 }
7570
7571 static void mlxsw_sp_rif_vlan_fdb_del(struct mlxsw_sp_rif *rif, const char *mac)
7572 {
7573         u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
7574         struct switchdev_notifier_fdb_info info;
7575         struct net_device *br_dev;
7576         struct net_device *dev;
7577
7578         br_dev = is_vlan_dev(rif->dev) ? vlan_dev_real_dev(rif->dev) : rif->dev;
7579         dev = br_fdb_find_port(br_dev, mac, vid);
7580         if (!dev)
7581                 return;
7582
7583         info.addr = mac;
7584         info.vid = vid;
7585         call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE, dev, &info.info,
7586                                  NULL);
7587 }
7588
7589 static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_vlan_ops = {
7590         .type                   = MLXSW_SP_RIF_TYPE_VLAN,
7591         .rif_size               = sizeof(struct mlxsw_sp_rif),
7592         .configure              = mlxsw_sp_rif_vlan_configure,
7593         .deconfigure            = mlxsw_sp_rif_vlan_deconfigure,
7594         .fid_get                = mlxsw_sp_rif_vlan_fid_get,
7595         .fdb_del                = mlxsw_sp_rif_vlan_fdb_del,
7596 };
7597
7598 static int mlxsw_sp_rif_fid_configure(struct mlxsw_sp_rif *rif)
7599 {
7600         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
7601         u16 fid_index = mlxsw_sp_fid_index(rif->fid);
7602         int err;
7603
7604         err = mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index,
7605                                        true);
7606         if (err)
7607                 return err;
7608
7609         err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
7610                                      mlxsw_sp_router_port(mlxsw_sp), true);
7611         if (err)
7612                 goto err_fid_mc_flood_set;
7613
7614         err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
7615                                      mlxsw_sp_router_port(mlxsw_sp), true);
7616         if (err)
7617                 goto err_fid_bc_flood_set;
7618
7619         err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
7620                                   mlxsw_sp_fid_index(rif->fid), true);
7621         if (err)
7622                 goto err_rif_fdb_op;
7623
7624         mlxsw_sp_fid_rif_set(rif->fid, rif);
7625         return 0;
7626
7627 err_rif_fdb_op:
7628         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
7629                                mlxsw_sp_router_port(mlxsw_sp), false);
7630 err_fid_bc_flood_set:
7631         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
7632                                mlxsw_sp_router_port(mlxsw_sp), false);
7633 err_fid_mc_flood_set:
7634         mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index, false);
7635         return err;
7636 }
7637
7638 static void mlxsw_sp_rif_fid_deconfigure(struct mlxsw_sp_rif *rif)
7639 {
7640         u16 fid_index = mlxsw_sp_fid_index(rif->fid);
7641         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
7642         struct mlxsw_sp_fid *fid = rif->fid;
7643
7644         mlxsw_sp_fid_rif_set(fid, NULL);
7645         mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
7646                             mlxsw_sp_fid_index(fid), false);
7647         mlxsw_sp_rif_macvlan_flush(rif);
7648         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
7649                                mlxsw_sp_router_port(mlxsw_sp), false);
7650         mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
7651                                mlxsw_sp_router_port(mlxsw_sp), false);
7652         mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index, false);
7653 }
7654
7655 static struct mlxsw_sp_fid *
7656 mlxsw_sp_rif_fid_fid_get(struct mlxsw_sp_rif *rif,
7657                          struct netlink_ext_ack *extack)
7658 {
7659         return mlxsw_sp_bridge_fid_get(rif->mlxsw_sp, rif->dev, 0, extack);
7660 }
7661
7662 static void mlxsw_sp_rif_fid_fdb_del(struct mlxsw_sp_rif *rif, const char *mac)
7663 {
7664         struct switchdev_notifier_fdb_info info;
7665         struct net_device *dev;
7666
7667         dev = br_fdb_find_port(rif->dev, mac, 0);
7668         if (!dev)
7669                 return;
7670
7671         info.addr = mac;
7672         info.vid = 0;
7673         call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE, dev, &info.info,
7674                                  NULL);
7675 }
7676
7677 static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_fid_ops = {
7678         .type                   = MLXSW_SP_RIF_TYPE_FID,
7679         .rif_size               = sizeof(struct mlxsw_sp_rif),
7680         .configure              = mlxsw_sp_rif_fid_configure,
7681         .deconfigure            = mlxsw_sp_rif_fid_deconfigure,
7682         .fid_get                = mlxsw_sp_rif_fid_fid_get,
7683         .fdb_del                = mlxsw_sp_rif_fid_fdb_del,
7684 };
7685
7686 static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_vlan_emu_ops = {
7687         .type                   = MLXSW_SP_RIF_TYPE_VLAN,
7688         .rif_size               = sizeof(struct mlxsw_sp_rif),
7689         .configure              = mlxsw_sp_rif_fid_configure,
7690         .deconfigure            = mlxsw_sp_rif_fid_deconfigure,
7691         .fid_get                = mlxsw_sp_rif_vlan_fid_get,
7692         .fdb_del                = mlxsw_sp_rif_vlan_fdb_del,
7693 };
7694
7695 static struct mlxsw_sp_rif_ipip_lb *
7696 mlxsw_sp_rif_ipip_lb_rif(struct mlxsw_sp_rif *rif)
7697 {
7698         return container_of(rif, struct mlxsw_sp_rif_ipip_lb, common);
7699 }
7700
7701 static void
7702 mlxsw_sp_rif_ipip_lb_setup(struct mlxsw_sp_rif *rif,
7703                            const struct mlxsw_sp_rif_params *params)
7704 {
7705         struct mlxsw_sp_rif_params_ipip_lb *params_lb;
7706         struct mlxsw_sp_rif_ipip_lb *rif_lb;
7707
7708         params_lb = container_of(params, struct mlxsw_sp_rif_params_ipip_lb,
7709                                  common);
7710         rif_lb = mlxsw_sp_rif_ipip_lb_rif(rif);
7711         rif_lb->lb_config = params_lb->lb_config;
7712 }
7713
7714 static int
7715 mlxsw_sp1_rif_ipip_lb_configure(struct mlxsw_sp_rif *rif)
7716 {
7717         struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
7718         u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(rif->dev);
7719         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
7720         struct mlxsw_sp_vr *ul_vr;
7721         int err;
7722
7723         ul_vr = mlxsw_sp_vr_get(mlxsw_sp, ul_tb_id, NULL);
7724         if (IS_ERR(ul_vr))
7725                 return PTR_ERR(ul_vr);
7726
7727         err = mlxsw_sp_rif_ipip_lb_op(lb_rif, ul_vr->id, 0, true);
7728         if (err)
7729                 goto err_loopback_op;
7730
7731         lb_rif->ul_vr_id = ul_vr->id;
7732         lb_rif->ul_rif_id = 0;
7733         ++ul_vr->rif_count;
7734         return 0;
7735
7736 err_loopback_op:
7737         mlxsw_sp_vr_put(mlxsw_sp, ul_vr);
7738         return err;
7739 }
7740
7741 static void mlxsw_sp1_rif_ipip_lb_deconfigure(struct mlxsw_sp_rif *rif)
7742 {
7743         struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
7744         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
7745         struct mlxsw_sp_vr *ul_vr;
7746
7747         ul_vr = &mlxsw_sp->router->vrs[lb_rif->ul_vr_id];
7748         mlxsw_sp_rif_ipip_lb_op(lb_rif, ul_vr->id, 0, false);
7749
7750         --ul_vr->rif_count;
7751         mlxsw_sp_vr_put(mlxsw_sp, ul_vr);
7752 }
7753
7754 static const struct mlxsw_sp_rif_ops mlxsw_sp1_rif_ipip_lb_ops = {
7755         .type                   = MLXSW_SP_RIF_TYPE_IPIP_LB,
7756         .rif_size               = sizeof(struct mlxsw_sp_rif_ipip_lb),
7757         .setup                  = mlxsw_sp_rif_ipip_lb_setup,
7758         .configure              = mlxsw_sp1_rif_ipip_lb_configure,
7759         .deconfigure            = mlxsw_sp1_rif_ipip_lb_deconfigure,
7760 };
7761
7762 const struct mlxsw_sp_rif_ops *mlxsw_sp1_rif_ops_arr[] = {
7763         [MLXSW_SP_RIF_TYPE_SUBPORT]     = &mlxsw_sp_rif_subport_ops,
7764         [MLXSW_SP_RIF_TYPE_VLAN]        = &mlxsw_sp_rif_vlan_emu_ops,
7765         [MLXSW_SP_RIF_TYPE_FID]         = &mlxsw_sp_rif_fid_ops,
7766         [MLXSW_SP_RIF_TYPE_IPIP_LB]     = &mlxsw_sp1_rif_ipip_lb_ops,
7767 };
7768
7769 static int
7770 mlxsw_sp_rif_ipip_lb_ul_rif_op(struct mlxsw_sp_rif *ul_rif, bool enable)
7771 {
7772         struct mlxsw_sp *mlxsw_sp = ul_rif->mlxsw_sp;
7773         char ritr_pl[MLXSW_REG_RITR_LEN];
7774
7775         mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_LOOPBACK_IF,
7776                             ul_rif->rif_index, ul_rif->vr_id, IP_MAX_MTU);
7777         mlxsw_reg_ritr_loopback_protocol_set(ritr_pl,
7778                                              MLXSW_REG_RITR_LOOPBACK_GENERIC);
7779
7780         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
7781 }
7782
7783 static struct mlxsw_sp_rif *
7784 mlxsw_sp_ul_rif_create(struct mlxsw_sp *mlxsw_sp, struct mlxsw_sp_vr *vr,
7785                        struct netlink_ext_ack *extack)
7786 {
7787         struct mlxsw_sp_rif *ul_rif;
7788         u16 rif_index;
7789         int err;
7790
7791         err = mlxsw_sp_rif_index_alloc(mlxsw_sp, &rif_index);
7792         if (err) {
7793                 NL_SET_ERR_MSG_MOD(extack, "Exceeded number of supported router interfaces");
7794                 return ERR_PTR(err);
7795         }
7796
7797         ul_rif = mlxsw_sp_rif_alloc(sizeof(*ul_rif), rif_index, vr->id, NULL);
7798         if (!ul_rif)
7799                 return ERR_PTR(-ENOMEM);
7800
7801         mlxsw_sp->router->rifs[rif_index] = ul_rif;
7802         ul_rif->mlxsw_sp = mlxsw_sp;
7803         err = mlxsw_sp_rif_ipip_lb_ul_rif_op(ul_rif, true);
7804         if (err)
7805                 goto ul_rif_op_err;
7806
7807         return ul_rif;
7808
7809 ul_rif_op_err:
7810         mlxsw_sp->router->rifs[rif_index] = NULL;
7811         kfree(ul_rif);
7812         return ERR_PTR(err);
7813 }
7814
7815 static void mlxsw_sp_ul_rif_destroy(struct mlxsw_sp_rif *ul_rif)
7816 {
7817         struct mlxsw_sp *mlxsw_sp = ul_rif->mlxsw_sp;
7818
7819         mlxsw_sp_rif_ipip_lb_ul_rif_op(ul_rif, false);
7820         mlxsw_sp->router->rifs[ul_rif->rif_index] = NULL;
7821         kfree(ul_rif);
7822 }
7823
7824 static struct mlxsw_sp_rif *
7825 mlxsw_sp_ul_rif_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id,
7826                     struct netlink_ext_ack *extack)
7827 {
7828         struct mlxsw_sp_vr *vr;
7829         int err;
7830
7831         vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id, extack);
7832         if (IS_ERR(vr))
7833                 return ERR_CAST(vr);
7834
7835         if (refcount_inc_not_zero(&vr->ul_rif_refcnt))
7836                 return vr->ul_rif;
7837
7838         vr->ul_rif = mlxsw_sp_ul_rif_create(mlxsw_sp, vr, extack);
7839         if (IS_ERR(vr->ul_rif)) {
7840                 err = PTR_ERR(vr->ul_rif);
7841                 goto err_ul_rif_create;
7842         }
7843
7844         vr->rif_count++;
7845         refcount_set(&vr->ul_rif_refcnt, 1);
7846
7847         return vr->ul_rif;
7848
7849 err_ul_rif_create:
7850         mlxsw_sp_vr_put(mlxsw_sp, vr);
7851         return ERR_PTR(err);
7852 }
7853
7854 static void mlxsw_sp_ul_rif_put(struct mlxsw_sp_rif *ul_rif)
7855 {
7856         struct mlxsw_sp *mlxsw_sp = ul_rif->mlxsw_sp;
7857         struct mlxsw_sp_vr *vr;
7858
7859         vr = &mlxsw_sp->router->vrs[ul_rif->vr_id];
7860
7861         if (!refcount_dec_and_test(&vr->ul_rif_refcnt))
7862                 return;
7863
7864         vr->rif_count--;
7865         mlxsw_sp_ul_rif_destroy(ul_rif);
7866         mlxsw_sp_vr_put(mlxsw_sp, vr);
7867 }
7868
7869 int mlxsw_sp_router_ul_rif_get(struct mlxsw_sp *mlxsw_sp, u32 ul_tb_id,
7870                                u16 *ul_rif_index)
7871 {
7872         struct mlxsw_sp_rif *ul_rif;
7873
7874         ASSERT_RTNL();
7875
7876         ul_rif = mlxsw_sp_ul_rif_get(mlxsw_sp, ul_tb_id, NULL);
7877         if (IS_ERR(ul_rif))
7878                 return PTR_ERR(ul_rif);
7879         *ul_rif_index = ul_rif->rif_index;
7880
7881         return 0;
7882 }
7883
7884 void mlxsw_sp_router_ul_rif_put(struct mlxsw_sp *mlxsw_sp, u16 ul_rif_index)
7885 {
7886         struct mlxsw_sp_rif *ul_rif;
7887
7888         ASSERT_RTNL();
7889
7890         ul_rif = mlxsw_sp->router->rifs[ul_rif_index];
7891         if (WARN_ON(!ul_rif))
7892                 return;
7893
7894         mlxsw_sp_ul_rif_put(ul_rif);
7895 }
7896
7897 static int
7898 mlxsw_sp2_rif_ipip_lb_configure(struct mlxsw_sp_rif *rif)
7899 {
7900         struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
7901         u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(rif->dev);
7902         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
7903         struct mlxsw_sp_rif *ul_rif;
7904         int err;
7905
7906         ul_rif = mlxsw_sp_ul_rif_get(mlxsw_sp, ul_tb_id, NULL);
7907         if (IS_ERR(ul_rif))
7908                 return PTR_ERR(ul_rif);
7909
7910         err = mlxsw_sp_rif_ipip_lb_op(lb_rif, 0, ul_rif->rif_index, true);
7911         if (err)
7912                 goto err_loopback_op;
7913
7914         lb_rif->ul_vr_id = 0;
7915         lb_rif->ul_rif_id = ul_rif->rif_index;
7916
7917         return 0;
7918
7919 err_loopback_op:
7920         mlxsw_sp_ul_rif_put(ul_rif);
7921         return err;
7922 }
7923
7924 static void mlxsw_sp2_rif_ipip_lb_deconfigure(struct mlxsw_sp_rif *rif)
7925 {
7926         struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
7927         struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
7928         struct mlxsw_sp_rif *ul_rif;
7929
7930         ul_rif = mlxsw_sp_rif_by_index(mlxsw_sp, lb_rif->ul_rif_id);
7931         mlxsw_sp_rif_ipip_lb_op(lb_rif, 0, lb_rif->ul_rif_id, false);
7932         mlxsw_sp_ul_rif_put(ul_rif);
7933 }
7934
7935 static const struct mlxsw_sp_rif_ops mlxsw_sp2_rif_ipip_lb_ops = {
7936         .type                   = MLXSW_SP_RIF_TYPE_IPIP_LB,
7937         .rif_size               = sizeof(struct mlxsw_sp_rif_ipip_lb),
7938         .setup                  = mlxsw_sp_rif_ipip_lb_setup,
7939         .configure              = mlxsw_sp2_rif_ipip_lb_configure,
7940         .deconfigure            = mlxsw_sp2_rif_ipip_lb_deconfigure,
7941 };
7942
7943 const struct mlxsw_sp_rif_ops *mlxsw_sp2_rif_ops_arr[] = {
7944         [MLXSW_SP_RIF_TYPE_SUBPORT]     = &mlxsw_sp_rif_subport_ops,
7945         [MLXSW_SP_RIF_TYPE_VLAN]        = &mlxsw_sp_rif_vlan_emu_ops,
7946         [MLXSW_SP_RIF_TYPE_FID]         = &mlxsw_sp_rif_fid_ops,
7947         [MLXSW_SP_RIF_TYPE_IPIP_LB]     = &mlxsw_sp2_rif_ipip_lb_ops,
7948 };
7949
7950 static int mlxsw_sp_rifs_init(struct mlxsw_sp *mlxsw_sp)
7951 {
7952         u64 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
7953
7954         mlxsw_sp->router->rifs = kcalloc(max_rifs,
7955                                          sizeof(struct mlxsw_sp_rif *),
7956                                          GFP_KERNEL);
7957         if (!mlxsw_sp->router->rifs)
7958                 return -ENOMEM;
7959
7960         return 0;
7961 }
7962
7963 static void mlxsw_sp_rifs_fini(struct mlxsw_sp *mlxsw_sp)
7964 {
7965         int i;
7966
7967         for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++)
7968                 WARN_ON_ONCE(mlxsw_sp->router->rifs[i]);
7969
7970         kfree(mlxsw_sp->router->rifs);
7971 }
7972
7973 static int
7974 mlxsw_sp_ipip_config_tigcr(struct mlxsw_sp *mlxsw_sp)
7975 {
7976         char tigcr_pl[MLXSW_REG_TIGCR_LEN];
7977
7978         mlxsw_reg_tigcr_pack(tigcr_pl, true, 0);
7979         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(tigcr), tigcr_pl);
7980 }
7981
7982 static int mlxsw_sp_ipips_init(struct mlxsw_sp *mlxsw_sp)
7983 {
7984         mlxsw_sp->router->ipip_ops_arr = mlxsw_sp_ipip_ops_arr;
7985         INIT_LIST_HEAD(&mlxsw_sp->router->ipip_list);
7986         return mlxsw_sp_ipip_config_tigcr(mlxsw_sp);
7987 }
7988
7989 static void mlxsw_sp_ipips_fini(struct mlxsw_sp *mlxsw_sp)
7990 {
7991         WARN_ON(!list_empty(&mlxsw_sp->router->ipip_list));
7992 }
7993
7994 static void mlxsw_sp_router_fib_dump_flush(struct notifier_block *nb)
7995 {
7996         struct mlxsw_sp_router *router;
7997
7998         /* Flush pending FIB notifications and then flush the device's
7999          * table before requesting another dump. The FIB notification
8000          * block is unregistered, so no need to take RTNL.
8001          */
8002         mlxsw_core_flush_owq();
8003         router = container_of(nb, struct mlxsw_sp_router, fib_nb);
8004         mlxsw_sp_router_fib_flush(router->mlxsw_sp);
8005 }
8006
8007 #ifdef CONFIG_IP_ROUTE_MULTIPATH
8008 static void mlxsw_sp_mp_hash_header_set(char *recr2_pl, int header)
8009 {
8010         mlxsw_reg_recr2_outer_header_enables_set(recr2_pl, header, true);
8011 }
8012
8013 static void mlxsw_sp_mp_hash_field_set(char *recr2_pl, int field)
8014 {
8015         mlxsw_reg_recr2_outer_header_fields_enable_set(recr2_pl, field, true);
8016 }
8017
8018 static void mlxsw_sp_mp4_hash_init(struct mlxsw_sp *mlxsw_sp, char *recr2_pl)
8019 {
8020         struct net *net = mlxsw_sp_net(mlxsw_sp);
8021         bool only_l3 = !net->ipv4.sysctl_fib_multipath_hash_policy;
8022
8023         mlxsw_sp_mp_hash_header_set(recr2_pl,
8024                                     MLXSW_REG_RECR2_IPV4_EN_NOT_TCP_NOT_UDP);
8025         mlxsw_sp_mp_hash_header_set(recr2_pl, MLXSW_REG_RECR2_IPV4_EN_TCP_UDP);
8026         mlxsw_reg_recr2_ipv4_sip_enable(recr2_pl);
8027         mlxsw_reg_recr2_ipv4_dip_enable(recr2_pl);
8028         if (only_l3)
8029                 return;
8030         mlxsw_sp_mp_hash_header_set(recr2_pl, MLXSW_REG_RECR2_TCP_UDP_EN_IPV4);
8031         mlxsw_sp_mp_hash_field_set(recr2_pl, MLXSW_REG_RECR2_IPV4_PROTOCOL);
8032         mlxsw_sp_mp_hash_field_set(recr2_pl, MLXSW_REG_RECR2_TCP_UDP_SPORT);
8033         mlxsw_sp_mp_hash_field_set(recr2_pl, MLXSW_REG_RECR2_TCP_UDP_DPORT);
8034 }
8035
8036 static void mlxsw_sp_mp6_hash_init(struct mlxsw_sp *mlxsw_sp, char *recr2_pl)
8037 {
8038         bool only_l3 = !ip6_multipath_hash_policy(mlxsw_sp_net(mlxsw_sp));
8039
8040         mlxsw_sp_mp_hash_header_set(recr2_pl,
8041                                     MLXSW_REG_RECR2_IPV6_EN_NOT_TCP_NOT_UDP);
8042         mlxsw_sp_mp_hash_header_set(recr2_pl, MLXSW_REG_RECR2_IPV6_EN_TCP_UDP);
8043         mlxsw_reg_recr2_ipv6_sip_enable(recr2_pl);
8044         mlxsw_reg_recr2_ipv6_dip_enable(recr2_pl);
8045         mlxsw_sp_mp_hash_field_set(recr2_pl, MLXSW_REG_RECR2_IPV6_NEXT_HEADER);
8046         if (only_l3) {
8047                 mlxsw_sp_mp_hash_field_set(recr2_pl,
8048                                            MLXSW_REG_RECR2_IPV6_FLOW_LABEL);
8049         } else {
8050                 mlxsw_sp_mp_hash_header_set(recr2_pl,
8051                                             MLXSW_REG_RECR2_TCP_UDP_EN_IPV6);
8052                 mlxsw_sp_mp_hash_field_set(recr2_pl,
8053                                            MLXSW_REG_RECR2_TCP_UDP_SPORT);
8054                 mlxsw_sp_mp_hash_field_set(recr2_pl,
8055                                            MLXSW_REG_RECR2_TCP_UDP_DPORT);
8056         }
8057 }
8058
8059 static int mlxsw_sp_mp_hash_init(struct mlxsw_sp *mlxsw_sp)
8060 {
8061         char recr2_pl[MLXSW_REG_RECR2_LEN];
8062         u32 seed;
8063
8064         seed = jhash(mlxsw_sp->base_mac, sizeof(mlxsw_sp->base_mac), 0);
8065         mlxsw_reg_recr2_pack(recr2_pl, seed);
8066         mlxsw_sp_mp4_hash_init(mlxsw_sp, recr2_pl);
8067         mlxsw_sp_mp6_hash_init(mlxsw_sp, recr2_pl);
8068
8069         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(recr2), recr2_pl);
8070 }
8071 #else
8072 static int mlxsw_sp_mp_hash_init(struct mlxsw_sp *mlxsw_sp)
8073 {
8074         return 0;
8075 }
8076 #endif
8077
8078 static int mlxsw_sp_dscp_init(struct mlxsw_sp *mlxsw_sp)
8079 {
8080         char rdpm_pl[MLXSW_REG_RDPM_LEN];
8081         unsigned int i;
8082
8083         MLXSW_REG_ZERO(rdpm, rdpm_pl);
8084
8085         /* HW is determining switch priority based on DSCP-bits, but the
8086          * kernel is still doing that based on the ToS. Since there's a
8087          * mismatch in bits we need to make sure to translate the right
8088          * value ToS would observe, skipping the 2 least-significant ECN bits.
8089          */
8090         for (i = 0; i < MLXSW_REG_RDPM_DSCP_ENTRY_REC_MAX_COUNT; i++)
8091                 mlxsw_reg_rdpm_pack(rdpm_pl, i, rt_tos2priority(i << 2));
8092
8093         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rdpm), rdpm_pl);
8094 }
8095
8096 static int __mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp)
8097 {
8098         struct net *net = mlxsw_sp_net(mlxsw_sp);
8099         bool usp = net->ipv4.sysctl_ip_fwd_update_priority;
8100         char rgcr_pl[MLXSW_REG_RGCR_LEN];
8101         u64 max_rifs;
8102         int err;
8103
8104         if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_RIFS))
8105                 return -EIO;
8106         max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
8107
8108         mlxsw_reg_rgcr_pack(rgcr_pl, true, true);
8109         mlxsw_reg_rgcr_max_router_interfaces_set(rgcr_pl, max_rifs);
8110         mlxsw_reg_rgcr_usp_set(rgcr_pl, usp);
8111         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
8112         if (err)
8113                 return err;
8114         return 0;
8115 }
8116
8117 static void __mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
8118 {
8119         char rgcr_pl[MLXSW_REG_RGCR_LEN];
8120
8121         mlxsw_reg_rgcr_pack(rgcr_pl, false, false);
8122         mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
8123 }
8124
8125 int mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp,
8126                          struct netlink_ext_ack *extack)
8127 {
8128         struct mlxsw_sp_router *router;
8129         int err;
8130
8131         router = kzalloc(sizeof(*mlxsw_sp->router), GFP_KERNEL);
8132         if (!router)
8133                 return -ENOMEM;
8134         mlxsw_sp->router = router;
8135         router->mlxsw_sp = mlxsw_sp;
8136
8137         router->inetaddr_nb.notifier_call = mlxsw_sp_inetaddr_event;
8138         err = register_inetaddr_notifier(&router->inetaddr_nb);
8139         if (err)
8140                 goto err_register_inetaddr_notifier;
8141
8142         router->inet6addr_nb.notifier_call = mlxsw_sp_inet6addr_event;
8143         err = register_inet6addr_notifier(&router->inet6addr_nb);
8144         if (err)
8145                 goto err_register_inet6addr_notifier;
8146
8147         INIT_LIST_HEAD(&mlxsw_sp->router->nexthop_neighs_list);
8148         err = __mlxsw_sp_router_init(mlxsw_sp);
8149         if (err)
8150                 goto err_router_init;
8151
8152         err = mlxsw_sp_rifs_init(mlxsw_sp);
8153         if (err)
8154                 goto err_rifs_init;
8155
8156         err = mlxsw_sp_ipips_init(mlxsw_sp);
8157         if (err)
8158                 goto err_ipips_init;
8159
8160         err = rhashtable_init(&mlxsw_sp->router->nexthop_ht,
8161                               &mlxsw_sp_nexthop_ht_params);
8162         if (err)
8163                 goto err_nexthop_ht_init;
8164
8165         err = rhashtable_init(&mlxsw_sp->router->nexthop_group_ht,
8166                               &mlxsw_sp_nexthop_group_ht_params);
8167         if (err)
8168                 goto err_nexthop_group_ht_init;
8169
8170         INIT_LIST_HEAD(&mlxsw_sp->router->nexthop_list);
8171         err = mlxsw_sp_lpm_init(mlxsw_sp);
8172         if (err)
8173                 goto err_lpm_init;
8174
8175         err = mlxsw_sp_mr_init(mlxsw_sp, &mlxsw_sp_mr_tcam_ops);
8176         if (err)
8177                 goto err_mr_init;
8178
8179         err = mlxsw_sp_vrs_init(mlxsw_sp);
8180         if (err)
8181                 goto err_vrs_init;
8182
8183         err = mlxsw_sp_neigh_init(mlxsw_sp);
8184         if (err)
8185                 goto err_neigh_init;
8186
8187         mlxsw_sp->router->netevent_nb.notifier_call =
8188                 mlxsw_sp_router_netevent_event;
8189         err = register_netevent_notifier(&mlxsw_sp->router->netevent_nb);
8190         if (err)
8191                 goto err_register_netevent_notifier;
8192
8193         err = mlxsw_sp_mp_hash_init(mlxsw_sp);
8194         if (err)
8195                 goto err_mp_hash_init;
8196
8197         err = mlxsw_sp_dscp_init(mlxsw_sp);
8198         if (err)
8199                 goto err_dscp_init;
8200
8201         mlxsw_sp->router->fib_nb.notifier_call = mlxsw_sp_router_fib_event;
8202         err = register_fib_notifier(mlxsw_sp_net(mlxsw_sp),
8203                                     &mlxsw_sp->router->fib_nb,
8204                                     mlxsw_sp_router_fib_dump_flush, extack);
8205         if (err)
8206                 goto err_register_fib_notifier;
8207
8208         return 0;
8209
8210 err_register_fib_notifier:
8211 err_dscp_init:
8212 err_mp_hash_init:
8213         unregister_netevent_notifier(&mlxsw_sp->router->netevent_nb);
8214 err_register_netevent_notifier:
8215         mlxsw_sp_neigh_fini(mlxsw_sp);
8216 err_neigh_init:
8217         mlxsw_sp_vrs_fini(mlxsw_sp);
8218 err_vrs_init:
8219         mlxsw_sp_mr_fini(mlxsw_sp);
8220 err_mr_init:
8221         mlxsw_sp_lpm_fini(mlxsw_sp);
8222 err_lpm_init:
8223         rhashtable_destroy(&mlxsw_sp->router->nexthop_group_ht);
8224 err_nexthop_group_ht_init:
8225         rhashtable_destroy(&mlxsw_sp->router->nexthop_ht);
8226 err_nexthop_ht_init:
8227         mlxsw_sp_ipips_fini(mlxsw_sp);
8228 err_ipips_init:
8229         mlxsw_sp_rifs_fini(mlxsw_sp);
8230 err_rifs_init:
8231         __mlxsw_sp_router_fini(mlxsw_sp);
8232 err_router_init:
8233         unregister_inet6addr_notifier(&router->inet6addr_nb);
8234 err_register_inet6addr_notifier:
8235         unregister_inetaddr_notifier(&router->inetaddr_nb);
8236 err_register_inetaddr_notifier:
8237         kfree(mlxsw_sp->router);
8238         return err;
8239 }
8240
8241 void mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
8242 {
8243         unregister_fib_notifier(mlxsw_sp_net(mlxsw_sp),
8244                                 &mlxsw_sp->router->fib_nb);
8245         unregister_netevent_notifier(&mlxsw_sp->router->netevent_nb);
8246         mlxsw_sp_neigh_fini(mlxsw_sp);
8247         mlxsw_sp_vrs_fini(mlxsw_sp);
8248         mlxsw_sp_mr_fini(mlxsw_sp);
8249         mlxsw_sp_lpm_fini(mlxsw_sp);
8250         rhashtable_destroy(&mlxsw_sp->router->nexthop_group_ht);
8251         rhashtable_destroy(&mlxsw_sp->router->nexthop_ht);
8252         mlxsw_sp_ipips_fini(mlxsw_sp);
8253         mlxsw_sp_rifs_fini(mlxsw_sp);
8254         __mlxsw_sp_router_fini(mlxsw_sp);
8255         unregister_inet6addr_notifier(&mlxsw_sp->router->inet6addr_nb);
8256         unregister_inetaddr_notifier(&mlxsw_sp->router->inetaddr_nb);
8257         kfree(mlxsw_sp->router);
8258 }