projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mlxsw: spectrum: Add the multicast routing hardware logic
[linux-2.6-block.git] / drivers / net / ethernet / mellanox / mlxsw / spectrum_router.c
CommitLineData
464dce18
IS		 1/*
2 * drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c
6ddb7426 3 * Copyright (c) 2016-2017 Mellanox Technologies. All rights reserved.
464dce18
IS		 4 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
5 * Copyright (c) 2016 Ido Schimmel <idosch@mellanox.com>
c723c735 6 * Copyright (c) 2016 Yotam Gigi <yotamg@mellanox.com>
6ddb7426 7 * Copyright (c) 2017 Petr Machata <petrm@mellanox.com>
464dce18
IS		 8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the names of the copyright holders nor the names of its
18 * contributors may be used to endorse or promote products derived from
19 * this software without specific prior written permission.
20 *
21 * Alternatively, this software may be distributed under the terms of the
22 * GNU General Public License ("GPL") version 2 as published by the Free
23 * Software Foundation.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
26 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
29 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35 * POSSIBILITY OF SUCH DAMAGE.
36 */
37
38#include <linux/kernel.h>
39#include <linux/types.h>
5e9c16cc
JP		 40#include <linux/rhashtable.h>
41#include <linux/bitops.h>
42#include <linux/in6.h>
c723c735 43#include <linux/notifier.h>
df6dd79b 44#include <linux/inetdevice.h>
9db032bb 45#include <linux/netdevice.h>
03ea01e9 46#include <linux/if_bridge.h>
b5f3e0d4 47#include <linux/socket.h>
428b851f 48#include <linux/route.h>
c723c735 49#include <net/netevent.h>
6cf3c971
JP		 50#include <net/neighbour.h>
51#include <net/arp.h>
b45f64d1 52#include <net/ip_fib.h>
583419fd 53#include <net/ip6_fib.h>
5d7bfd14 54#include <net/fib_rules.h>
6ddb7426 55#include <net/ip_tunnels.h>
57837885 56#include <net/l3mdev.h>
5ea1237f 57#include <net/addrconf.h>
d5eb89cf
AS		 58#include <net/ndisc.h>
59#include <net/ipv6.h>
04b1d4e5 60#include <net/fib_notifier.h>
464dce18
IS		 61
62#include "spectrum.h"
63#include "core.h"
64#include "reg.h"
e0c0afd8
AS		 65#include "spectrum_cnt.h"
66#include "spectrum_dpipe.h"
38ebc0f4 67#include "spectrum_ipip.h"
e0c0afd8 68#include "spectrum_router.h"
464dce18 69
9011b677
IS		 70struct mlxsw_sp_vr;
71struct mlxsw_sp_lpm_tree;
e4f3c1c1 72struct mlxsw_sp_rif_ops;
9011b677
IS		 73
74struct mlxsw_sp_router {
75 struct mlxsw_sp *mlxsw_sp;
5f9efffb 76 struct mlxsw_sp_rif **rifs;
9011b677
IS		 77 struct mlxsw_sp_vr *vrs;
78 struct rhashtable neigh_ht;
79 struct rhashtable nexthop_group_ht;
80 struct rhashtable nexthop_ht;
dbe4598c 81 struct list_head nexthop_list;
9011b677
IS		 82 struct {
83 struct mlxsw_sp_lpm_tree *trees;
84 unsigned int tree_count;
85 } lpm;
86 struct {
87 struct delayed_work dw;
88 unsigned long interval; /* ms */
89 } neighs_update;
90 struct delayed_work nexthop_probe_dw;
91#define MLXSW_SP_UNRESOLVED_NH_PROBE_INTERVAL 5000 /* ms */
92 struct list_head nexthop_neighs_list;
1012b9ac 93 struct list_head ipip_list;
9011b677 94 bool aborted;
7e39d115 95 struct notifier_block fib_nb;
e4f3c1c1 96 const struct mlxsw_sp_rif_ops **rif_ops_arr;
38ebc0f4 97 const struct mlxsw_sp_ipip_ops **ipip_ops_arr;
9011b677
IS		 98};
99
4724ba56
IS		 100struct mlxsw_sp_rif {
101 struct list_head nexthop_list;
102 struct list_head neigh_list;
103 struct net_device *dev;
a1107487 104 struct mlxsw_sp_fid *fid;
4724ba56
IS		 105 unsigned char addr[ETH_ALEN];
106 int mtu;
bf95233e 107 u16 rif_index;
6913229e 108 u16 vr_id;
e4f3c1c1
IS		 109 const struct mlxsw_sp_rif_ops *ops;
110 struct mlxsw_sp *mlxsw_sp;
111
e0c0afd8
AS		 112 unsigned int counter_ingress;
113 bool counter_ingress_valid;
114 unsigned int counter_egress;
115 bool counter_egress_valid;
4724ba56
IS		 116};
117
e4f3c1c1
IS		 118struct mlxsw_sp_rif_params {
119 struct net_device *dev;
120 union {
121 u16 system_port;
122 u16 lag_id;
123 };
124 u16 vid;
125 bool lag;
126};
127
4d93ceeb
IS		 128struct mlxsw_sp_rif_subport {
129 struct mlxsw_sp_rif common;
130 union {
131 u16 system_port;
132 u16 lag_id;
133 };
134 u16 vid;
135 bool lag;
136};
137
6ddb7426
PM		 138struct mlxsw_sp_rif_ipip_lb {
139 struct mlxsw_sp_rif common;
140 struct mlxsw_sp_rif_ipip_lb_config lb_config;
141 u16 ul_vr_id; /* Reserved for Spectrum-2. */
142};
143
144struct mlxsw_sp_rif_params_ipip_lb {
145 struct mlxsw_sp_rif_params common;
146 struct mlxsw_sp_rif_ipip_lb_config lb_config;
147};
148
e4f3c1c1
IS		 149struct mlxsw_sp_rif_ops {
150 enum mlxsw_sp_rif_type type;
151 size_t rif_size;
152
153 void (*setup)(struct mlxsw_sp_rif *rif,
154 const struct mlxsw_sp_rif_params *params);
155 int (*configure)(struct mlxsw_sp_rif *rif);
156 void (*deconfigure)(struct mlxsw_sp_rif *rif);
157 struct mlxsw_sp_fid * (*fid_get)(struct mlxsw_sp_rif *rif);
158};
159
e0c0afd8
AS		 160static unsigned int *
161mlxsw_sp_rif_p_counter_get(struct mlxsw_sp_rif *rif,
162 enum mlxsw_sp_rif_counter_dir dir)
163{
164 switch (dir) {
165 case MLXSW_SP_RIF_COUNTER_EGRESS:
166 return &rif->counter_egress;
167 case MLXSW_SP_RIF_COUNTER_INGRESS:
168 return &rif->counter_ingress;
169 }
170 return NULL;
171}
172
173static bool
174mlxsw_sp_rif_counter_valid_get(struct mlxsw_sp_rif *rif,
175 enum mlxsw_sp_rif_counter_dir dir)
176{
177 switch (dir) {
178 case MLXSW_SP_RIF_COUNTER_EGRESS:
179 return rif->counter_egress_valid;
180 case MLXSW_SP_RIF_COUNTER_INGRESS:
181 return rif->counter_ingress_valid;
182 }
183 return false;
184}
185
186static void
187mlxsw_sp_rif_counter_valid_set(struct mlxsw_sp_rif *rif,
188 enum mlxsw_sp_rif_counter_dir dir,
189 bool valid)
190{
191 switch (dir) {
192 case MLXSW_SP_RIF_COUNTER_EGRESS:
193 rif->counter_egress_valid = valid;
194 break;
195 case MLXSW_SP_RIF_COUNTER_INGRESS:
196 rif->counter_ingress_valid = valid;
197 break;
198 }
199}
200
201static int mlxsw_sp_rif_counter_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
202 unsigned int counter_index, bool enable,
203 enum mlxsw_sp_rif_counter_dir dir)
204{
205 char ritr_pl[MLXSW_REG_RITR_LEN];
206 bool is_egress = false;
207 int err;
208
209 if (dir == MLXSW_SP_RIF_COUNTER_EGRESS)
210 is_egress = true;
211 mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
212 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
213 if (err)
214 return err;
215
216 mlxsw_reg_ritr_counter_pack(ritr_pl, counter_index, enable,
217 is_egress);
218 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
219}
220
221int mlxsw_sp_rif_counter_value_get(struct mlxsw_sp *mlxsw_sp,
222 struct mlxsw_sp_rif *rif,
223 enum mlxsw_sp_rif_counter_dir dir, u64 *cnt)
224{
225 char ricnt_pl[MLXSW_REG_RICNT_LEN];
226 unsigned int *p_counter_index;
227 bool valid;
228 int err;
229
230 valid = mlxsw_sp_rif_counter_valid_get(rif, dir);
231 if (!valid)
232 return -EINVAL;
233
234 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
235 if (!p_counter_index)
236 return -EINVAL;
237 mlxsw_reg_ricnt_pack(ricnt_pl, *p_counter_index,
238 MLXSW_REG_RICNT_OPCODE_NOP);
239 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
240 if (err)
241 return err;
242 *cnt = mlxsw_reg_ricnt_good_unicast_packets_get(ricnt_pl);
243 return 0;
244}
245
246static int mlxsw_sp_rif_counter_clear(struct mlxsw_sp *mlxsw_sp,
247 unsigned int counter_index)
248{
249 char ricnt_pl[MLXSW_REG_RICNT_LEN];
250
251 mlxsw_reg_ricnt_pack(ricnt_pl, counter_index,
252 MLXSW_REG_RICNT_OPCODE_CLEAR);
253 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
254}
255
256int mlxsw_sp_rif_counter_alloc(struct mlxsw_sp *mlxsw_sp,
257 struct mlxsw_sp_rif *rif,
258 enum mlxsw_sp_rif_counter_dir dir)
259{
260 unsigned int *p_counter_index;
261 int err;
262
263 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
264 if (!p_counter_index)
265 return -EINVAL;
266 err = mlxsw_sp_counter_alloc(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
267 p_counter_index);
268 if (err)
269 return err;
270
271 err = mlxsw_sp_rif_counter_clear(mlxsw_sp, *p_counter_index);
272 if (err)
273 goto err_counter_clear;
274
275 err = mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
276 *p_counter_index, true, dir);
277 if (err)
278 goto err_counter_edit;
279 mlxsw_sp_rif_counter_valid_set(rif, dir, true);
280 return 0;
281
282err_counter_edit:
283err_counter_clear:
284 mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
285 *p_counter_index);
286 return err;
287}
288
289void mlxsw_sp_rif_counter_free(struct mlxsw_sp *mlxsw_sp,
290 struct mlxsw_sp_rif *rif,
291 enum mlxsw_sp_rif_counter_dir dir)
292{
293 unsigned int *p_counter_index;
294
6b1206bb
AS		 295 if (!mlxsw_sp_rif_counter_valid_get(rif, dir))
296 return;
297
e0c0afd8
AS		 298 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
299 if (WARN_ON(!p_counter_index))
300 return;
301 mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
302 *p_counter_index, false, dir);
303 mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
304 *p_counter_index);
305 mlxsw_sp_rif_counter_valid_set(rif, dir, false);
306}
307
e4f3c1c1
IS		 308static void mlxsw_sp_rif_counters_alloc(struct mlxsw_sp_rif *rif)
309{
310 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
311 struct devlink *devlink;
312
313 devlink = priv_to_devlink(mlxsw_sp->core);
314 if (!devlink_dpipe_table_counter_enabled(devlink,
315 MLXSW_SP_DPIPE_TABLE_NAME_ERIF))
316 return;
317 mlxsw_sp_rif_counter_alloc(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS);
318}
319
320static void mlxsw_sp_rif_counters_free(struct mlxsw_sp_rif *rif)
321{
322 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
323
324 mlxsw_sp_rif_counter_free(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS);
325}
326
4724ba56
IS		 327static struct mlxsw_sp_rif *
328mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp,
329 const struct net_device *dev);
330
7dcc18ad 331#define MLXSW_SP_PREFIX_COUNT (sizeof(struct in6_addr) * BITS_PER_BYTE + 1)
9011b677
IS		 332
333struct mlxsw_sp_prefix_usage {
334 DECLARE_BITMAP(b, MLXSW_SP_PREFIX_COUNT);
335};
336
53342023
JP		 337#define mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) \
338 for_each_set_bit(prefix, (prefix_usage)->b, MLXSW_SP_PREFIX_COUNT)
339
340static bool
341mlxsw_sp_prefix_usage_eq(struct mlxsw_sp_prefix_usage *prefix_usage1,
342 struct mlxsw_sp_prefix_usage *prefix_usage2)
343{
344 return !memcmp(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
345}
346
6b75c480
JP		 347static bool
348mlxsw_sp_prefix_usage_none(struct mlxsw_sp_prefix_usage *prefix_usage)
349{
350 struct mlxsw_sp_prefix_usage prefix_usage_none = {{ 0 } };
351
352 return mlxsw_sp_prefix_usage_eq(prefix_usage, &prefix_usage_none);
353}
354
355static void
356mlxsw_sp_prefix_usage_cpy(struct mlxsw_sp_prefix_usage *prefix_usage1,
357 struct mlxsw_sp_prefix_usage *prefix_usage2)
358{
359 memcpy(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
360}
361
5e9c16cc
JP		 362static void
363mlxsw_sp_prefix_usage_set(struct mlxsw_sp_prefix_usage *prefix_usage,
364 unsigned char prefix_len)
365{
366 set_bit(prefix_len, prefix_usage->b);
367}
368
369static void
370mlxsw_sp_prefix_usage_clear(struct mlxsw_sp_prefix_usage *prefix_usage,
371 unsigned char prefix_len)
372{
373 clear_bit(prefix_len, prefix_usage->b);
374}
375
376struct mlxsw_sp_fib_key {
377 unsigned char addr[sizeof(struct in6_addr)];
378 unsigned char prefix_len;
379};
380
61c503f9
JP		 381enum mlxsw_sp_fib_entry_type {
382 MLXSW_SP_FIB_ENTRY_TYPE_REMOTE,
383 MLXSW_SP_FIB_ENTRY_TYPE_LOCAL,
384 MLXSW_SP_FIB_ENTRY_TYPE_TRAP,
4607f6d2
PM		 385
386 /* This is a special case of local delivery, where a packet should be
387 * decapsulated on reception. Note that there is no corresponding ENCAP,
388 * because that's a type of next hop, not of FIB entry. (There can be
389 * several next hops in a REMOTE entry, and some of them may be
390 * encapsulating entries.)
391 */
392 MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP,
61c503f9
JP		 393};
394
a7ff87ac 395struct mlxsw_sp_nexthop_group;
9011b677 396struct mlxsw_sp_fib;
a7ff87ac 397
9aecce1c
IS		 398struct mlxsw_sp_fib_node {
399 struct list_head entry_list;
b45f64d1 400 struct list_head list;
9aecce1c 401 struct rhash_head ht_node;
76610ebb 402 struct mlxsw_sp_fib *fib;
5e9c16cc 403 struct mlxsw_sp_fib_key key;
9aecce1c
IS		 404};
405
4607f6d2
PM		 406struct mlxsw_sp_fib_entry_decap {
407 struct mlxsw_sp_ipip_entry *ipip_entry;
408 u32 tunnel_index;
409};
410
9aecce1c
IS		 411struct mlxsw_sp_fib_entry {
412 struct list_head list;
413 struct mlxsw_sp_fib_node *fib_node;
61c503f9 414 enum mlxsw_sp_fib_entry_type type;
a7ff87ac
JP		 415 struct list_head nexthop_group_node;
416 struct mlxsw_sp_nexthop_group *nh_group;
4607f6d2 417 struct mlxsw_sp_fib_entry_decap decap; /* Valid for decap entries. */
5e9c16cc
JP		 418};
419
4f1c7f1f
IS		 420struct mlxsw_sp_fib4_entry {
421 struct mlxsw_sp_fib_entry common;
422 u32 tb_id;
423 u32 prio;
424 u8 tos;
425 u8 type;
426};
427
428b851f
IS		 428struct mlxsw_sp_fib6_entry {
429 struct mlxsw_sp_fib_entry common;
430 struct list_head rt6_list;
431 unsigned int nrt6;
432};
433
434struct mlxsw_sp_rt6 {
435 struct list_head list;
436 struct rt6_info *rt;
437};
438
9011b677
IS		 439struct mlxsw_sp_lpm_tree {
440 u8 id; /* tree ID */
441 unsigned int ref_count;
442 enum mlxsw_sp_l3proto proto;
443 struct mlxsw_sp_prefix_usage prefix_usage;
444};
445
5e9c16cc
JP		 446struct mlxsw_sp_fib {
447 struct rhashtable ht;
9aecce1c 448 struct list_head node_list;
76610ebb
IS		 449 struct mlxsw_sp_vr *vr;
450 struct mlxsw_sp_lpm_tree *lpm_tree;
5e9c16cc
JP		 451 unsigned long prefix_ref_count[MLXSW_SP_PREFIX_COUNT];
452 struct mlxsw_sp_prefix_usage prefix_usage;
76610ebb 453 enum mlxsw_sp_l3proto proto;
5e9c16cc
JP		 454};
455
9011b677
IS		 456struct mlxsw_sp_vr {
457 u16 id; /* virtual router ID */
458 u32 tb_id; /* kernel fib table id */
459 unsigned int rif_count;
460 struct mlxsw_sp_fib *fib4;
a3d9bc50 461 struct mlxsw_sp_fib *fib6;
9011b677
IS		 462};
463
9aecce1c 464static const struct rhashtable_params mlxsw_sp_fib_ht_params;
5e9c16cc 465
76610ebb
IS		 466static struct mlxsw_sp_fib *mlxsw_sp_fib_create(struct mlxsw_sp_vr *vr,
467 enum mlxsw_sp_l3proto proto)
5e9c16cc
JP		 468{
469 struct mlxsw_sp_fib *fib;
470 int err;
471
472 fib = kzalloc(sizeof(*fib), GFP_KERNEL);
473 if (!fib)
474 return ERR_PTR(-ENOMEM);
475 err = rhashtable_init(&fib->ht, &mlxsw_sp_fib_ht_params);
476 if (err)
477 goto err_rhashtable_init;
9aecce1c 478 INIT_LIST_HEAD(&fib->node_list);
76610ebb
IS		 479 fib->proto = proto;
480 fib->vr = vr;
5e9c16cc
JP		 481 return fib;
482
483err_rhashtable_init:
484 kfree(fib);
485 return ERR_PTR(err);
486}
487
488static void mlxsw_sp_fib_destroy(struct mlxsw_sp_fib *fib)
489{
9aecce1c 490 WARN_ON(!list_empty(&fib->node_list));
76610ebb 491 WARN_ON(fib->lpm_tree);
5e9c16cc
JP		 492 rhashtable_destroy(&fib->ht);
493 kfree(fib);
494}
495
53342023 496static struct mlxsw_sp_lpm_tree *
382dbb40 497mlxsw_sp_lpm_tree_find_unused(struct mlxsw_sp *mlxsw_sp)
53342023
JP		 498{
499 static struct mlxsw_sp_lpm_tree *lpm_tree;
500 int i;
501
9011b677
IS		 502 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
503 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
382dbb40
IS		 504 if (lpm_tree->ref_count == 0)
505 return lpm_tree;
53342023
JP		 506 }
507 return NULL;
508}
509
510static int mlxsw_sp_lpm_tree_alloc(struct mlxsw_sp *mlxsw_sp,
511 struct mlxsw_sp_lpm_tree *lpm_tree)
512{
513 char ralta_pl[MLXSW_REG_RALTA_LEN];
514
1a9234e6
IS		 515 mlxsw_reg_ralta_pack(ralta_pl, true,
516 (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
517 lpm_tree->id);
53342023
JP		 518 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
519}
520
cc702670
IS		 521static void mlxsw_sp_lpm_tree_free(struct mlxsw_sp *mlxsw_sp,
522 struct mlxsw_sp_lpm_tree *lpm_tree)
53342023
JP		 523{
524 char ralta_pl[MLXSW_REG_RALTA_LEN];
525
1a9234e6
IS		 526 mlxsw_reg_ralta_pack(ralta_pl, false,
527 (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
528 lpm_tree->id);
cc702670 529 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
53342023
JP		 530}
531
532static int
533mlxsw_sp_lpm_tree_left_struct_set(struct mlxsw_sp *mlxsw_sp,
534 struct mlxsw_sp_prefix_usage *prefix_usage,
535 struct mlxsw_sp_lpm_tree *lpm_tree)
536{
537 char ralst_pl[MLXSW_REG_RALST_LEN];
538 u8 root_bin = 0;
539 u8 prefix;
540 u8 last_prefix = MLXSW_REG_RALST_BIN_NO_CHILD;
541
542 mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage)
543 root_bin = prefix;
544
545 mlxsw_reg_ralst_pack(ralst_pl, root_bin, lpm_tree->id);
546 mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) {
547 if (prefix == 0)
548 continue;
549 mlxsw_reg_ralst_bin_pack(ralst_pl, prefix, last_prefix,
550 MLXSW_REG_RALST_BIN_NO_CHILD);
551 last_prefix = prefix;
552 }
553 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralst), ralst_pl);
554}
555
556static struct mlxsw_sp_lpm_tree *
557mlxsw_sp_lpm_tree_create(struct mlxsw_sp *mlxsw_sp,
558 struct mlxsw_sp_prefix_usage *prefix_usage,
382dbb40 559 enum mlxsw_sp_l3proto proto)
53342023
JP		 560{
561 struct mlxsw_sp_lpm_tree *lpm_tree;
562 int err;
563
382dbb40 564 lpm_tree = mlxsw_sp_lpm_tree_find_unused(mlxsw_sp);
53342023
JP		 565 if (!lpm_tree)
566 return ERR_PTR(-EBUSY);
567 lpm_tree->proto = proto;
568 err = mlxsw_sp_lpm_tree_alloc(mlxsw_sp, lpm_tree);
569 if (err)
570 return ERR_PTR(err);
571
572 err = mlxsw_sp_lpm_tree_left_struct_set(mlxsw_sp, prefix_usage,
573 lpm_tree);
574 if (err)
575 goto err_left_struct_set;
2083d367
JP		 576 memcpy(&lpm_tree->prefix_usage, prefix_usage,
577 sizeof(lpm_tree->prefix_usage));
53342023
JP		 578 return lpm_tree;
579
580err_left_struct_set:
581 mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
582 return ERR_PTR(err);
583}
584
cc702670
IS		 585static void mlxsw_sp_lpm_tree_destroy(struct mlxsw_sp *mlxsw_sp,
586 struct mlxsw_sp_lpm_tree *lpm_tree)
53342023 587{
cc702670 588 mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
53342023
JP		 589}
590
591static struct mlxsw_sp_lpm_tree *
592mlxsw_sp_lpm_tree_get(struct mlxsw_sp *mlxsw_sp,
593 struct mlxsw_sp_prefix_usage *prefix_usage,
382dbb40 594 enum mlxsw_sp_l3proto proto)
53342023
JP		 595{
596 struct mlxsw_sp_lpm_tree *lpm_tree;
597 int i;
598
9011b677
IS		 599 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
600 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
8b99becd
JP		 601 if (lpm_tree->ref_count != 0 &&
602 lpm_tree->proto == proto &&
53342023
JP		 603 mlxsw_sp_prefix_usage_eq(&lpm_tree->prefix_usage,
604 prefix_usage))
fc922bb0 605 return lpm_tree;
53342023 606 }
fc922bb0
IS		 607 return mlxsw_sp_lpm_tree_create(mlxsw_sp, prefix_usage, proto);
608}
53342023 609
fc922bb0
IS		 610static void mlxsw_sp_lpm_tree_hold(struct mlxsw_sp_lpm_tree *lpm_tree)
611{
53342023 612 lpm_tree->ref_count++;
53342023
JP		 613}
614
cc702670
IS		 615static void mlxsw_sp_lpm_tree_put(struct mlxsw_sp *mlxsw_sp,
616 struct mlxsw_sp_lpm_tree *lpm_tree)
53342023
JP		 617{
618 if (--lpm_tree->ref_count == 0)
cc702670 619 mlxsw_sp_lpm_tree_destroy(mlxsw_sp, lpm_tree);
53342023
JP		 620}
621
d7a60306 622#define MLXSW_SP_LPM_TREE_MIN 1 /* tree 0 is reserved */
8494ab06
IS		 623
624static int mlxsw_sp_lpm_init(struct mlxsw_sp *mlxsw_sp)
53342023
JP		 625{
626 struct mlxsw_sp_lpm_tree *lpm_tree;
8494ab06 627 u64 max_trees;
53342023
JP		 628 int i;
629
8494ab06
IS		 630 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_LPM_TREES))
631 return -EIO;
632
633 max_trees = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_LPM_TREES);
9011b677
IS		 634 mlxsw_sp->router->lpm.tree_count = max_trees - MLXSW_SP_LPM_TREE_MIN;
635 mlxsw_sp->router->lpm.trees = kcalloc(mlxsw_sp->router->lpm.tree_count,
8494ab06
IS		 636 sizeof(struct mlxsw_sp_lpm_tree),
637 GFP_KERNEL);
9011b677 638 if (!mlxsw_sp->router->lpm.trees)
8494ab06
IS		 639 return -ENOMEM;
640
9011b677
IS		 641 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
642 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
53342023
JP		 643 lpm_tree->id = i + MLXSW_SP_LPM_TREE_MIN;
644 }
8494ab06
IS		 645
646 return 0;
647}
648
649static void mlxsw_sp_lpm_fini(struct mlxsw_sp *mlxsw_sp)
650{
9011b677 651 kfree(mlxsw_sp->router->lpm.trees);
53342023
JP		 652}
653
76610ebb
IS		 654static bool mlxsw_sp_vr_is_used(const struct mlxsw_sp_vr *vr)
655{
a3d9bc50 656 return !!vr->fib4 || !!vr->fib6;
76610ebb
IS		 657}
658
6b75c480
JP		 659static struct mlxsw_sp_vr *mlxsw_sp_vr_find_unused(struct mlxsw_sp *mlxsw_sp)
660{
661 struct mlxsw_sp_vr *vr;
662 int i;
663
c1a38311 664 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
9011b677 665 vr = &mlxsw_sp->router->vrs[i];
76610ebb 666 if (!mlxsw_sp_vr_is_used(vr))
6b75c480
JP		 667 return vr;
668 }
669 return NULL;
670}
671
672static int mlxsw_sp_vr_lpm_tree_bind(struct mlxsw_sp *mlxsw_sp,
0adb214b 673 const struct mlxsw_sp_fib *fib, u8 tree_id)
6b75c480
JP		 674{
675 char raltb_pl[MLXSW_REG_RALTB_LEN];
676
76610ebb
IS		 677 mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
678 (enum mlxsw_reg_ralxx_protocol) fib->proto,
0adb214b 679 tree_id);
6b75c480
JP		 680 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
681}
682
683static int mlxsw_sp_vr_lpm_tree_unbind(struct mlxsw_sp *mlxsw_sp,
76610ebb 684 const struct mlxsw_sp_fib *fib)
6b75c480
JP		 685{
686 char raltb_pl[MLXSW_REG_RALTB_LEN];
687
688 /* Bind to tree 0 which is default */
76610ebb
IS		 689 mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
690 (enum mlxsw_reg_ralxx_protocol) fib->proto, 0);
6b75c480
JP		 691 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
692}
693
694static u32 mlxsw_sp_fix_tb_id(u32 tb_id)
695{
696 /* For our purpose, squash main and local table into one */
697 if (tb_id == RT_TABLE_LOCAL)
698 tb_id = RT_TABLE_MAIN;
699 return tb_id;
700}
701
702static struct mlxsw_sp_vr *mlxsw_sp_vr_find(struct mlxsw_sp *mlxsw_sp,
76610ebb 703 u32 tb_id)
6b75c480
JP		 704{
705 struct mlxsw_sp_vr *vr;
706 int i;
707
708 tb_id = mlxsw_sp_fix_tb_id(tb_id);
9497c042 709
c1a38311 710 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
9011b677 711 vr = &mlxsw_sp->router->vrs[i];
76610ebb 712 if (mlxsw_sp_vr_is_used(vr) && vr->tb_id == tb_id)
6b75c480
JP		 713 return vr;
714 }
715 return NULL;
716}
717
76610ebb
IS		 718static struct mlxsw_sp_fib *mlxsw_sp_vr_fib(const struct mlxsw_sp_vr *vr,
719 enum mlxsw_sp_l3proto proto)
720{
721 switch (proto) {
722 case MLXSW_SP_L3_PROTO_IPV4:
723 return vr->fib4;
724 case MLXSW_SP_L3_PROTO_IPV6:
a3d9bc50 725 return vr->fib6;
76610ebb
IS		 726 }
727 return NULL;
728}
729
6b75c480 730static struct mlxsw_sp_vr *mlxsw_sp_vr_create(struct mlxsw_sp *mlxsw_sp,
76610ebb 731 u32 tb_id)
6b75c480 732{
6b75c480 733 struct mlxsw_sp_vr *vr;
a3d9bc50 734 int err;
6b75c480
JP		 735
736 vr = mlxsw_sp_vr_find_unused(mlxsw_sp);
737 if (!vr)
738 return ERR_PTR(-EBUSY);
76610ebb
IS		 739 vr->fib4 = mlxsw_sp_fib_create(vr, MLXSW_SP_L3_PROTO_IPV4);
740 if (IS_ERR(vr->fib4))
741 return ERR_CAST(vr->fib4);
a3d9bc50
IS		 742 vr->fib6 = mlxsw_sp_fib_create(vr, MLXSW_SP_L3_PROTO_IPV6);
743 if (IS_ERR(vr->fib6)) {
744 err = PTR_ERR(vr->fib6);
745 goto err_fib6_create;
746 }
6b75c480 747 vr->tb_id = tb_id;
6b75c480 748 return vr;
a3d9bc50
IS		 749
750err_fib6_create:
751 mlxsw_sp_fib_destroy(vr->fib4);
752 vr->fib4 = NULL;
753 return ERR_PTR(err);
6b75c480
JP		 754}
755
76610ebb 756static void mlxsw_sp_vr_destroy(struct mlxsw_sp_vr *vr)
6b75c480 757{
a3d9bc50
IS		 758 mlxsw_sp_fib_destroy(vr->fib6);
759 vr->fib6 = NULL;
76610ebb
IS		 760 mlxsw_sp_fib_destroy(vr->fib4);
761 vr->fib4 = NULL;
6b75c480
JP		 762}
763
76610ebb 764static struct mlxsw_sp_vr *mlxsw_sp_vr_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id)
6b75c480
JP		 765{
766 struct mlxsw_sp_vr *vr;
6b75c480
JP		 767
768 tb_id = mlxsw_sp_fix_tb_id(tb_id);
76610ebb
IS		 769 vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id);
770 if (!vr)
771 vr = mlxsw_sp_vr_create(mlxsw_sp, tb_id);
6b75c480
JP		 772 return vr;
773}
774
76610ebb 775static void mlxsw_sp_vr_put(struct mlxsw_sp_vr *vr)
6b75c480 776{
a3d9bc50
IS		 777 if (!vr->rif_count && list_empty(&vr->fib4->node_list) &&
778 list_empty(&vr->fib6->node_list))
76610ebb 779 mlxsw_sp_vr_destroy(vr);
6b75c480
JP		 780}
781
fc922bb0
IS		 782static bool
783mlxsw_sp_vr_lpm_tree_should_replace(struct mlxsw_sp_vr *vr,
784 enum mlxsw_sp_l3proto proto, u8 tree_id)
785{
786 struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
787
788 if (!mlxsw_sp_vr_is_used(vr))
789 return false;
790 if (fib->lpm_tree && fib->lpm_tree->id == tree_id)
791 return true;
792 return false;
793}
794
795static int mlxsw_sp_vr_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp,
796 struct mlxsw_sp_fib *fib,
797 struct mlxsw_sp_lpm_tree *new_tree)
798{
799 struct mlxsw_sp_lpm_tree *old_tree = fib->lpm_tree;
800 int err;
801
802 err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, new_tree->id);
803 if (err)
804 return err;
805 fib->lpm_tree = new_tree;
806 mlxsw_sp_lpm_tree_hold(new_tree);
807 mlxsw_sp_lpm_tree_put(mlxsw_sp, old_tree);
808 return 0;
809}
810
811static int mlxsw_sp_vrs_lpm_tree_replace(struct mlxsw_sp *mlxsw_sp,
812 struct mlxsw_sp_fib *fib,
813 struct mlxsw_sp_lpm_tree *new_tree)
814{
815 struct mlxsw_sp_lpm_tree *old_tree = fib->lpm_tree;
816 enum mlxsw_sp_l3proto proto = fib->proto;
817 u8 old_id, new_id = new_tree->id;
818 struct mlxsw_sp_vr *vr;
819 int i, err;
820
821 if (!old_tree)
822 goto no_replace;
823 old_id = old_tree->id;
824
825 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
826 vr = &mlxsw_sp->router->vrs[i];
827 if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, old_id))
828 continue;
829 err = mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp,
830 mlxsw_sp_vr_fib(vr, proto),
831 new_tree);
832 if (err)
833 goto err_tree_replace;
834 }
835
836 return 0;
837
838err_tree_replace:
839 for (i--; i >= 0; i--) {
840 if (!mlxsw_sp_vr_lpm_tree_should_replace(vr, proto, new_id))
841 continue;
842 mlxsw_sp_vr_lpm_tree_replace(mlxsw_sp,
843 mlxsw_sp_vr_fib(vr, proto),
844 old_tree);
845 }
846 return err;
847
848no_replace:
849 err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib, new_tree->id);
850 if (err)
851 return err;
852 fib->lpm_tree = new_tree;
853 mlxsw_sp_lpm_tree_hold(new_tree);
854 return 0;
855}
856
857static void
858mlxsw_sp_vrs_prefixes(struct mlxsw_sp *mlxsw_sp,
859 enum mlxsw_sp_l3proto proto,
860 struct mlxsw_sp_prefix_usage *req_prefix_usage)
861{
862 int i;
863
864 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
865 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
866 struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
867 unsigned char prefix;
868
869 if (!mlxsw_sp_vr_is_used(vr))
870 continue;
871 mlxsw_sp_prefix_usage_for_each(prefix, &fib->prefix_usage)
872 mlxsw_sp_prefix_usage_set(req_prefix_usage, prefix);
873 }
874}
875
9497c042 876static int mlxsw_sp_vrs_init(struct mlxsw_sp *mlxsw_sp)
6b75c480
JP		 877{
878 struct mlxsw_sp_vr *vr;
c1a38311 879 u64 max_vrs;
6b75c480
JP		 880 int i;
881
c1a38311 882 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_VRS))
9497c042
NF		 883 return -EIO;
884
c1a38311 885 max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
9011b677
IS		 886 mlxsw_sp->router->vrs = kcalloc(max_vrs, sizeof(struct mlxsw_sp_vr),
887 GFP_KERNEL);
888 if (!mlxsw_sp->router->vrs)
9497c042
NF		 889 return -ENOMEM;
890
c1a38311 891 for (i = 0; i < max_vrs; i++) {
9011b677 892 vr = &mlxsw_sp->router->vrs[i];
6b75c480
JP		 893 vr->id = i;
894 }
9497c042
NF		 895
896 return 0;
897}
898
ac571de9
IS		 899static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp);
900
9497c042
NF		 901static void mlxsw_sp_vrs_fini(struct mlxsw_sp *mlxsw_sp)
902{
3057224e
IS		 903 /* At this stage we're guaranteed not to have new incoming
904 * FIB notifications and the work queue is free from FIBs
905 * sitting on top of mlxsw netdevs. However, we can still
906 * have other FIBs queued. Flush the queue before flushing
907 * the device's tables. No need for locks, as we're the only
908 * writer.
909 */
910 mlxsw_core_flush_owq();
ac571de9 911 mlxsw_sp_router_fib_flush(mlxsw_sp);
9011b677 912 kfree(mlxsw_sp->router->vrs);
6b75c480
JP		 913}
914
6ddb7426
PM		 915static struct net_device *
916__mlxsw_sp_ipip_netdev_ul_dev_get(const struct net_device *ol_dev)
917{
918 struct ip_tunnel *tun = netdev_priv(ol_dev);
919 struct net *net = dev_net(ol_dev);
920
921 return __dev_get_by_index(net, tun->parms.link);
922}
923
924static u32 mlxsw_sp_ipip_dev_ul_tb_id(const struct net_device *ol_dev)
925{
926 struct net_device *d = __mlxsw_sp_ipip_netdev_ul_dev_get(ol_dev);
927
928 if (d)
929 return l3mdev_fib_table(d) ? : RT_TABLE_MAIN;
930 else
931 return l3mdev_fib_table(ol_dev) ? : RT_TABLE_MAIN;
932}
933
1012b9ac
PM		 934static struct mlxsw_sp_rif *
935mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp,
936 const struct mlxsw_sp_rif_params *params);
937
938static struct mlxsw_sp_rif_ipip_lb *
939mlxsw_sp_ipip_ol_ipip_lb_create(struct mlxsw_sp *mlxsw_sp,
940 enum mlxsw_sp_ipip_type ipipt,
941 struct net_device *ol_dev)
942{
943 struct mlxsw_sp_rif_params_ipip_lb lb_params;
944 const struct mlxsw_sp_ipip_ops *ipip_ops;
945 struct mlxsw_sp_rif *rif;
946
947 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipipt];
948 lb_params = (struct mlxsw_sp_rif_params_ipip_lb) {
949 .common.dev = ol_dev,
950 .common.lag = false,
951 .lb_config = ipip_ops->ol_loopback_config(mlxsw_sp, ol_dev),
952 };
953
954 rif = mlxsw_sp_rif_create(mlxsw_sp, &lb_params.common);
955 if (IS_ERR(rif))
956 return ERR_CAST(rif);
957 return container_of(rif, struct mlxsw_sp_rif_ipip_lb, common);
958}
959
960static struct mlxsw_sp_ipip_entry *
961mlxsw_sp_ipip_entry_alloc(struct mlxsw_sp *mlxsw_sp,
962 enum mlxsw_sp_ipip_type ipipt,
963 struct net_device *ol_dev)
964{
965 struct mlxsw_sp_ipip_entry *ipip_entry;
966 struct mlxsw_sp_ipip_entry *ret = NULL;
967
968 ipip_entry = kzalloc(sizeof(*ipip_entry), GFP_KERNEL);
969 if (!ipip_entry)
970 return ERR_PTR(-ENOMEM);
971
972 ipip_entry->ol_lb = mlxsw_sp_ipip_ol_ipip_lb_create(mlxsw_sp, ipipt,
973 ol_dev);
974 if (IS_ERR(ipip_entry->ol_lb)) {
975 ret = ERR_CAST(ipip_entry->ol_lb);
976 goto err_ol_ipip_lb_create;
977 }
978
979 ipip_entry->ipipt = ipipt;
980 ipip_entry->ol_dev = ol_dev;
981
982 return ipip_entry;
983
984err_ol_ipip_lb_create:
985 kfree(ipip_entry);
986 return ret;
987}
988
989static void
990mlxsw_sp_ipip_entry_destroy(struct mlxsw_sp_ipip_entry *ipip_entry)
991{
992 WARN_ON(ipip_entry->ref_count > 0);
993 mlxsw_sp_rif_destroy(&ipip_entry->ol_lb->common);
994 kfree(ipip_entry);
995}
996
997static __be32
998mlxsw_sp_ipip_netdev_saddr4(const struct net_device *ol_dev)
999{
1000 struct ip_tunnel *tun = netdev_priv(ol_dev);
1001
1002 return tun->parms.iph.saddr;
1003}
1004
1005union mlxsw_sp_l3addr
1006mlxsw_sp_ipip_netdev_saddr(enum mlxsw_sp_l3proto proto,
1007 const struct net_device *ol_dev)
1008{
1009 switch (proto) {
1010 case MLXSW_SP_L3_PROTO_IPV4:
1011 return (union mlxsw_sp_l3addr) {
1012 .addr4 = mlxsw_sp_ipip_netdev_saddr4(ol_dev),
1013 };
1014 case MLXSW_SP_L3_PROTO_IPV6:
1015 break;
1016 };
1017
1018 WARN_ON(1);
1019 return (union mlxsw_sp_l3addr) {
1020 .addr4 = 0,
1021 };
1022}
1023
ee954d1a
PM		 1024__be32 mlxsw_sp_ipip_netdev_daddr4(const struct net_device *ol_dev)
1025{
1026 struct ip_tunnel *tun = netdev_priv(ol_dev);
1027
1028 return tun->parms.iph.daddr;
1029}
1030
1031union mlxsw_sp_l3addr
1032mlxsw_sp_ipip_netdev_daddr(enum mlxsw_sp_l3proto proto,
1033 const struct net_device *ol_dev)
1034{
1035 switch (proto) {
1036 case MLXSW_SP_L3_PROTO_IPV4:
1037 return (union mlxsw_sp_l3addr) {
1038 .addr4 = mlxsw_sp_ipip_netdev_daddr4(ol_dev),
1039 };
1040 case MLXSW_SP_L3_PROTO_IPV6:
1041 break;
1042 };
1043
1044 WARN_ON(1);
1045 return (union mlxsw_sp_l3addr) {
1046 .addr4 = 0,
1047 };
1048}
1049
1012b9ac
PM		 1050static bool mlxsw_sp_l3addr_eq(const union mlxsw_sp_l3addr *addr1,
1051 const union mlxsw_sp_l3addr *addr2)
1052{
1053 return !memcmp(addr1, addr2, sizeof(*addr1));
1054}
1055
1056static bool
1057mlxsw_sp_ipip_entry_saddr_matches(struct mlxsw_sp *mlxsw_sp,
1058 const enum mlxsw_sp_l3proto ul_proto,
1059 union mlxsw_sp_l3addr saddr,
1060 u32 ul_tb_id,
1061 struct mlxsw_sp_ipip_entry *ipip_entry)
1062{
1063 u32 tun_ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev);
1064 enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt;
1065 union mlxsw_sp_l3addr tun_saddr;
1066
1067 if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto)
1068 return false;
1069
1070 tun_saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ipip_entry->ol_dev);
1071 return tun_ul_tb_id == ul_tb_id &&
1072 mlxsw_sp_l3addr_eq(&tun_saddr, &saddr);
1073}
1074
4607f6d2
PM		 1075static int
1076mlxsw_sp_fib_entry_decap_init(struct mlxsw_sp *mlxsw_sp,
1077 struct mlxsw_sp_fib_entry *fib_entry,
1078 struct mlxsw_sp_ipip_entry *ipip_entry)
1079{
1080 u32 tunnel_index;
1081 int err;
1082
1083 err = mlxsw_sp_kvdl_alloc(mlxsw_sp, 1, &tunnel_index);
1084 if (err)
1085 return err;
1086
1087 ipip_entry->decap_fib_entry = fib_entry;
1088 fib_entry->decap.ipip_entry = ipip_entry;
1089 fib_entry->decap.tunnel_index = tunnel_index;
1090 return 0;
1091}
1092
1093static void mlxsw_sp_fib_entry_decap_fini(struct mlxsw_sp *mlxsw_sp,
1094 struct mlxsw_sp_fib_entry *fib_entry)
1095{
1096 /* Unlink this node from the IPIP entry that it's the decap entry of. */
1097 fib_entry->decap.ipip_entry->decap_fib_entry = NULL;
1098 fib_entry->decap.ipip_entry = NULL;
1099 mlxsw_sp_kvdl_free(mlxsw_sp, fib_entry->decap.tunnel_index);
1100}
1101
1cc38fb1
PM		 1102static struct mlxsw_sp_fib_node *
1103mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
1104 size_t addr_len, unsigned char prefix_len);
4607f6d2
PM		 1105static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
1106 struct mlxsw_sp_fib_entry *fib_entry);
1107
1108static void
1109mlxsw_sp_ipip_entry_demote_decap(struct mlxsw_sp *mlxsw_sp,
1110 struct mlxsw_sp_ipip_entry *ipip_entry)
1111{
1112 struct mlxsw_sp_fib_entry *fib_entry = ipip_entry->decap_fib_entry;
1113
1114 mlxsw_sp_fib_entry_decap_fini(mlxsw_sp, fib_entry);
1115 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
1116
1117 mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
1118}
1119
1cc38fb1
PM		 1120static void
1121mlxsw_sp_ipip_entry_promote_decap(struct mlxsw_sp *mlxsw_sp,
1122 struct mlxsw_sp_ipip_entry *ipip_entry,
1123 struct mlxsw_sp_fib_entry *decap_fib_entry)
1124{
1125 if (mlxsw_sp_fib_entry_decap_init(mlxsw_sp, decap_fib_entry,
1126 ipip_entry))
1127 return;
1128 decap_fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
1129
1130 if (mlxsw_sp_fib_entry_update(mlxsw_sp, decap_fib_entry))
1131 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1132}
1133
1134/* Given an IPIP entry, find the corresponding decap route. */
1135static struct mlxsw_sp_fib_entry *
1136mlxsw_sp_ipip_entry_find_decap(struct mlxsw_sp *mlxsw_sp,
1137 struct mlxsw_sp_ipip_entry *ipip_entry)
1138{
1139 static struct mlxsw_sp_fib_node *fib_node;
1140 const struct mlxsw_sp_ipip_ops *ipip_ops;
1141 struct mlxsw_sp_fib_entry *fib_entry;
1142 unsigned char saddr_prefix_len;
1143 union mlxsw_sp_l3addr saddr;
1144 struct mlxsw_sp_fib *ul_fib;
1145 struct mlxsw_sp_vr *ul_vr;
1146 const void *saddrp;
1147 size_t saddr_len;
1148 u32 ul_tb_id;
1149 u32 saddr4;
1150
1151 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
1152
1153 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ipip_entry->ol_dev);
1154 ul_vr = mlxsw_sp_vr_find(mlxsw_sp, ul_tb_id);
1155 if (!ul_vr)
1156 return NULL;
1157
1158 ul_fib = mlxsw_sp_vr_fib(ul_vr, ipip_ops->ul_proto);
1159 saddr = mlxsw_sp_ipip_netdev_saddr(ipip_ops->ul_proto,
1160 ipip_entry->ol_dev);
1161
1162 switch (ipip_ops->ul_proto) {
1163 case MLXSW_SP_L3_PROTO_IPV4:
1164 saddr4 = be32_to_cpu(saddr.addr4);
1165 saddrp = &saddr4;
1166 saddr_len = 4;
1167 saddr_prefix_len = 32;
1168 break;
1169 case MLXSW_SP_L3_PROTO_IPV6:
1170 WARN_ON(1);
1171 return NULL;
1172 }
1173
1174 fib_node = mlxsw_sp_fib_node_lookup(ul_fib, saddrp, saddr_len,
1175 saddr_prefix_len);
1176 if (!fib_node || list_empty(&fib_node->entry_list))
1177 return NULL;
1178
1179 fib_entry = list_first_entry(&fib_node->entry_list,
1180 struct mlxsw_sp_fib_entry, list);
1181 if (fib_entry->type != MLXSW_SP_FIB_ENTRY_TYPE_TRAP)
1182 return NULL;
1183
1184 return fib_entry;
1185}
1186
1012b9ac
PM		 1187static struct mlxsw_sp_ipip_entry *
1188mlxsw_sp_ipip_entry_get(struct mlxsw_sp *mlxsw_sp,
1189 enum mlxsw_sp_ipip_type ipipt,
1190 struct net_device *ol_dev)
1191{
1192 u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(ol_dev);
1193 struct mlxsw_sp_router *router = mlxsw_sp->router;
1cc38fb1 1194 struct mlxsw_sp_fib_entry *decap_fib_entry;
1012b9ac
PM		 1195 struct mlxsw_sp_ipip_entry *ipip_entry;
1196 enum mlxsw_sp_l3proto ul_proto;
1197 union mlxsw_sp_l3addr saddr;
1198
1199 list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list,
1200 ipip_list_node) {
1201 if (ipip_entry->ol_dev == ol_dev)
1202 goto inc_ref_count;
1203
1204 /* The configuration where several tunnels have the same local
1205 * address in the same underlay table needs special treatment in
1206 * the HW. That is currently not implemented in the driver.
1207 */
1208 ul_proto = router->ipip_ops_arr[ipip_entry->ipipt]->ul_proto;
1209 saddr = mlxsw_sp_ipip_netdev_saddr(ul_proto, ol_dev);
1210 if (mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, saddr,
1211 ul_tb_id, ipip_entry))
1212 return ERR_PTR(-EEXIST);
1213 }
1214
1215 ipip_entry = mlxsw_sp_ipip_entry_alloc(mlxsw_sp, ipipt, ol_dev);
1216 if (IS_ERR(ipip_entry))
1217 return ipip_entry;
1218
1cc38fb1
PM		 1219 decap_fib_entry = mlxsw_sp_ipip_entry_find_decap(mlxsw_sp, ipip_entry);
1220 if (decap_fib_entry)
1221 mlxsw_sp_ipip_entry_promote_decap(mlxsw_sp, ipip_entry,
1222 decap_fib_entry);
1223
1012b9ac
PM		 1224 list_add_tail(&ipip_entry->ipip_list_node,
1225 &mlxsw_sp->router->ipip_list);
1226
1227inc_ref_count:
1228 ++ipip_entry->ref_count;
1229 return ipip_entry;
1230}
1231
1232static void
1233mlxsw_sp_ipip_entry_put(struct mlxsw_sp *mlxsw_sp,
1234 struct mlxsw_sp_ipip_entry *ipip_entry)
1235{
1236 if (--ipip_entry->ref_count == 0) {
1237 list_del(&ipip_entry->ipip_list_node);
4607f6d2
PM		 1238 if (ipip_entry->decap_fib_entry)
1239 mlxsw_sp_ipip_entry_demote_decap(mlxsw_sp, ipip_entry);
1012b9ac
PM		 1240 mlxsw_sp_ipip_entry_destroy(ipip_entry);
1241 }
1242}
1243
4607f6d2
PM		 1244static bool
1245mlxsw_sp_ipip_entry_matches_decap(struct mlxsw_sp *mlxsw_sp,
1246 const struct net_device *ul_dev,
1247 enum mlxsw_sp_l3proto ul_proto,
1248 union mlxsw_sp_l3addr ul_dip,
1249 struct mlxsw_sp_ipip_entry *ipip_entry)
1250{
1251 u32 ul_tb_id = l3mdev_fib_table(ul_dev) ? : RT_TABLE_MAIN;
1252 enum mlxsw_sp_ipip_type ipipt = ipip_entry->ipipt;
1253 struct net_device *ipip_ul_dev;
1254
1255 if (mlxsw_sp->router->ipip_ops_arr[ipipt]->ul_proto != ul_proto)
1256 return false;
1257
1258 ipip_ul_dev = __mlxsw_sp_ipip_netdev_ul_dev_get(ipip_entry->ol_dev);
1259 return mlxsw_sp_ipip_entry_saddr_matches(mlxsw_sp, ul_proto, ul_dip,
1260 ul_tb_id, ipip_entry) &&
1261 (!ipip_ul_dev || ipip_ul_dev == ul_dev);
1262}
1263
1264/* Given decap parameters, find the corresponding IPIP entry. */
1265static struct mlxsw_sp_ipip_entry *
1266mlxsw_sp_ipip_entry_find_by_decap(struct mlxsw_sp *mlxsw_sp,
1267 const struct net_device *ul_dev,
1268 enum mlxsw_sp_l3proto ul_proto,
1269 union mlxsw_sp_l3addr ul_dip)
1270{
1271 struct mlxsw_sp_ipip_entry *ipip_entry;
1272
1273 list_for_each_entry(ipip_entry, &mlxsw_sp->router->ipip_list,
1274 ipip_list_node)
1275 if (mlxsw_sp_ipip_entry_matches_decap(mlxsw_sp, ul_dev,
1276 ul_proto, ul_dip,
1277 ipip_entry))
1278 return ipip_entry;
1279
1280 return NULL;
1281}
1282
6cf3c971 1283struct mlxsw_sp_neigh_key {
33b1341c 1284 struct neighbour *n;
6cf3c971
JP		 1285};
1286
1287struct mlxsw_sp_neigh_entry {
9665b745 1288 struct list_head rif_list_node;
6cf3c971
JP		 1289 struct rhash_head ht_node;
1290 struct mlxsw_sp_neigh_key key;
1291 u16 rif;
5c8802f1 1292 bool connected;
a6bf9e93 1293 unsigned char ha[ETH_ALEN];
a7ff87ac
JP		 1294 struct list_head nexthop_list; /* list of nexthops using
1295 * this neigh entry
1296 */
b2157149 1297 struct list_head nexthop_neighs_list_node;
7cfcbc75
AS		 1298 unsigned int counter_index;
1299 bool counter_valid;
6cf3c971
JP		 1300};
1301
1302static const struct rhashtable_params mlxsw_sp_neigh_ht_params = {
1303 .key_offset = offsetof(struct mlxsw_sp_neigh_entry, key),
1304 .head_offset = offsetof(struct mlxsw_sp_neigh_entry, ht_node),
1305 .key_len = sizeof(struct mlxsw_sp_neigh_key),
1306};
1307
f17cc84d
AS		 1308struct mlxsw_sp_neigh_entry *
1309mlxsw_sp_rif_neigh_next(struct mlxsw_sp_rif *rif,
1310 struct mlxsw_sp_neigh_entry *neigh_entry)
1311{
1312 if (!neigh_entry) {
1313 if (list_empty(&rif->neigh_list))
1314 return NULL;
1315 else
1316 return list_first_entry(&rif->neigh_list,
1317 typeof(*neigh_entry),
1318 rif_list_node);
1319 }
ec2437f4 1320 if (list_is_last(&neigh_entry->rif_list_node, &rif->neigh_list))
f17cc84d
AS		 1321 return NULL;
1322 return list_next_entry(neigh_entry, rif_list_node);
1323}
1324
1325int mlxsw_sp_neigh_entry_type(struct mlxsw_sp_neigh_entry *neigh_entry)
1326{
1327 return neigh_entry->key.n->tbl->family;
1328}
1329
1330unsigned char *
1331mlxsw_sp_neigh_entry_ha(struct mlxsw_sp_neigh_entry *neigh_entry)
1332{
1333 return neigh_entry->ha;
1334}
1335
1336u32 mlxsw_sp_neigh4_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry)
1337{
1338 struct neighbour *n;
1339
1340 n = neigh_entry->key.n;
1341 return ntohl(*((__be32 *) n->primary_key));
1342}
1343
0250768c
AS		 1344struct in6_addr *
1345mlxsw_sp_neigh6_entry_dip(struct mlxsw_sp_neigh_entry *neigh_entry)
1346{
1347 struct neighbour *n;
1348
1349 n = neigh_entry->key.n;
1350 return (struct in6_addr *) &n->primary_key;
1351}
1352
7cfcbc75
AS		 1353int mlxsw_sp_neigh_counter_get(struct mlxsw_sp *mlxsw_sp,
1354 struct mlxsw_sp_neigh_entry *neigh_entry,
1355 u64 *p_counter)
1356{
1357 if (!neigh_entry->counter_valid)
1358 return -EINVAL;
1359
1360 return mlxsw_sp_flow_counter_get(mlxsw_sp, neigh_entry->counter_index,
1361 p_counter, NULL);
1362}
1363
6cf3c971 1364static struct mlxsw_sp_neigh_entry *
5c8802f1
IS		 1365mlxsw_sp_neigh_entry_alloc(struct mlxsw_sp *mlxsw_sp, struct neighbour *n,
1366 u16 rif)
6cf3c971
JP		 1367{
1368 struct mlxsw_sp_neigh_entry *neigh_entry;
1369
5c8802f1 1370 neigh_entry = kzalloc(sizeof(*neigh_entry), GFP_KERNEL);
6cf3c971
JP		 1371 if (!neigh_entry)
1372 return NULL;
5c8802f1 1373
33b1341c 1374 neigh_entry->key.n = n;
6cf3c971 1375 neigh_entry->rif = rif;
a7ff87ac 1376 INIT_LIST_HEAD(&neigh_entry->nexthop_list);
5c8802f1 1377
6cf3c971
JP		 1378 return neigh_entry;
1379}
1380
5c8802f1 1381static void mlxsw_sp_neigh_entry_free(struct mlxsw_sp_neigh_entry *neigh_entry)
6cf3c971
JP		 1382{
1383 kfree(neigh_entry);
1384}
1385
5c8802f1
IS		 1386static int
1387mlxsw_sp_neigh_entry_insert(struct mlxsw_sp *mlxsw_sp,
1388 struct mlxsw_sp_neigh_entry *neigh_entry)
6cf3c971 1389{
9011b677 1390 return rhashtable_insert_fast(&mlxsw_sp->router->neigh_ht,
5c8802f1
IS		 1391 &neigh_entry->ht_node,
1392 mlxsw_sp_neigh_ht_params);
1393}
6cf3c971 1394
5c8802f1
IS		 1395static void
1396mlxsw_sp_neigh_entry_remove(struct mlxsw_sp *mlxsw_sp,
1397 struct mlxsw_sp_neigh_entry *neigh_entry)
1398{
9011b677 1399 rhashtable_remove_fast(&mlxsw_sp->router->neigh_ht,
5c8802f1
IS		 1400 &neigh_entry->ht_node,
1401 mlxsw_sp_neigh_ht_params);
6cf3c971
JP		 1402}
1403
7cfcbc75 1404static bool
1ed5574c
AS		 1405mlxsw_sp_neigh_counter_should_alloc(struct mlxsw_sp *mlxsw_sp,
1406 struct mlxsw_sp_neigh_entry *neigh_entry)
7cfcbc75
AS		 1407{
1408 struct devlink *devlink;
1ed5574c
AS		 1409 const char *table_name;
1410
1411 switch (mlxsw_sp_neigh_entry_type(neigh_entry)) {
1412 case AF_INET:
1413 table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST4;
1414 break;
1415 case AF_INET6:
1416 table_name = MLXSW_SP_DPIPE_TABLE_NAME_HOST6;
1417 break;
1418 default:
1419 WARN_ON(1);
1420 return false;
1421 }
7cfcbc75
AS		 1422
1423 devlink = priv_to_devlink(mlxsw_sp->core);
1ed5574c 1424 return devlink_dpipe_table_counter_enabled(devlink, table_name);
7cfcbc75
AS		 1425}
1426
1427static void
1428mlxsw_sp_neigh_counter_alloc(struct mlxsw_sp *mlxsw_sp,
1429 struct mlxsw_sp_neigh_entry *neigh_entry)
1430{
1ed5574c 1431 if (!mlxsw_sp_neigh_counter_should_alloc(mlxsw_sp, neigh_entry))
7cfcbc75
AS		 1432 return;
1433
1434 if (mlxsw_sp_flow_counter_alloc(mlxsw_sp, &neigh_entry->counter_index))
1435 return;
1436
1437 neigh_entry->counter_valid = true;
1438}
1439
1440static void
1441mlxsw_sp_neigh_counter_free(struct mlxsw_sp *mlxsw_sp,
1442 struct mlxsw_sp_neigh_entry *neigh_entry)
1443{
1444 if (!neigh_entry->counter_valid)
1445 return;
1446 mlxsw_sp_flow_counter_free(mlxsw_sp,
1447 neigh_entry->counter_index);
1448 neigh_entry->counter_valid = false;
1449}
1450
5c8802f1
IS		 1451static struct mlxsw_sp_neigh_entry *
1452mlxsw_sp_neigh_entry_create(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
6cf3c971 1453{
6cf3c971 1454 struct mlxsw_sp_neigh_entry *neigh_entry;
bf95233e 1455 struct mlxsw_sp_rif *rif;
6cf3c971
JP		 1456 int err;
1457
bf95233e
AS		 1458 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, n->dev);
1459 if (!rif)
5c8802f1 1460 return ERR_PTR(-EINVAL);
6cf3c971 1461
bf95233e 1462 neigh_entry = mlxsw_sp_neigh_entry_alloc(mlxsw_sp, n, rif->rif_index);
6cf3c971 1463 if (!neigh_entry)
5c8802f1
IS		 1464 return ERR_PTR(-ENOMEM);
1465
6cf3c971
JP		 1466 err = mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry);
1467 if (err)
1468 goto err_neigh_entry_insert;
5c8802f1 1469
7cfcbc75 1470 mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry);
bf95233e 1471 list_add(&neigh_entry->rif_list_node, &rif->neigh_list);
9665b745 1472
5c8802f1 1473 return neigh_entry;
6cf3c971
JP		 1474
1475err_neigh_entry_insert:
5c8802f1
IS		 1476 mlxsw_sp_neigh_entry_free(neigh_entry);
1477 return ERR_PTR(err);
6cf3c971
JP		 1478}
1479
5c8802f1
IS		 1480static void
1481mlxsw_sp_neigh_entry_destroy(struct mlxsw_sp *mlxsw_sp,
1482 struct mlxsw_sp_neigh_entry *neigh_entry)
6cf3c971 1483{
9665b745 1484 list_del(&neigh_entry->rif_list_node);
7cfcbc75 1485 mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry);
5c8802f1
IS		 1486 mlxsw_sp_neigh_entry_remove(mlxsw_sp, neigh_entry);
1487 mlxsw_sp_neigh_entry_free(neigh_entry);
1488}
6cf3c971 1489
5c8802f1
IS		 1490static struct mlxsw_sp_neigh_entry *
1491mlxsw_sp_neigh_entry_lookup(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
1492{
1493 struct mlxsw_sp_neigh_key key;
6cf3c971 1494
5c8802f1 1495 key.n = n;
9011b677 1496 return rhashtable_lookup_fast(&mlxsw_sp->router->neigh_ht,
5c8802f1 1497 &key, mlxsw_sp_neigh_ht_params);
6cf3c971
JP		 1498}
1499
c723c735
YG		 1500static void
1501mlxsw_sp_router_neighs_update_interval_init(struct mlxsw_sp *mlxsw_sp)
1502{
a6c9b5d1 1503 unsigned long interval;
c723c735 1504
b5f3e0d4 1505#if IS_ENABLED(CONFIG_IPV6)
a6c9b5d1
AS		 1506 interval = min_t(unsigned long,
1507 NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME),
1508 NEIGH_VAR(&nd_tbl.parms, DELAY_PROBE_TIME));
b5f3e0d4
IS		 1509#else
1510 interval = NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME);
1511#endif
9011b677 1512 mlxsw_sp->router->neighs_update.interval = jiffies_to_msecs(interval);
c723c735
YG		 1513}
1514
1515static void mlxsw_sp_router_neigh_ent_ipv4_process(struct mlxsw_sp *mlxsw_sp,
1516 char *rauhtd_pl,
1517 int ent_index)
1518{
1519 struct net_device *dev;
1520 struct neighbour *n;
1521 __be32 dipn;
1522 u32 dip;
1523 u16 rif;
1524
1525 mlxsw_reg_rauhtd_ent_ipv4_unpack(rauhtd_pl, ent_index, &rif, &dip);
1526
5f9efffb 1527 if (!mlxsw_sp->router->rifs[rif]) {
c723c735
YG		 1528 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
1529 return;
1530 }
1531
1532 dipn = htonl(dip);
5f9efffb 1533 dev = mlxsw_sp->router->rifs[rif]->dev;
c723c735
YG		 1534 n = neigh_lookup(&arp_tbl, &dipn, dev);
1535 if (!n) {
1536 netdev_err(dev, "Failed to find matching neighbour for IP=%pI4h\n",
1537 &dip);
1538 return;
1539 }
1540
1541 netdev_dbg(dev, "Updating neighbour with IP=%pI4h\n", &dip);
1542 neigh_event_send(n, NULL);
1543 neigh_release(n);
1544}
1545
df9a21f1 1546#if IS_ENABLED(CONFIG_IPV6)
60f040ca
AS		 1547static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
1548 char *rauhtd_pl,
1549 int rec_index)
1550{
1551 struct net_device *dev;
1552 struct neighbour *n;
1553 struct in6_addr dip;
1554 u16 rif;
1555
1556 mlxsw_reg_rauhtd_ent_ipv6_unpack(rauhtd_pl, rec_index, &rif,
1557 (char *) &dip);
1558
1559 if (!mlxsw_sp->router->rifs[rif]) {
1560 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
1561 return;
1562 }
1563
1564 dev = mlxsw_sp->router->rifs[rif]->dev;
1565 n = neigh_lookup(&nd_tbl, &dip, dev);
1566 if (!n) {
1567 netdev_err(dev, "Failed to find matching neighbour for IP=%pI6c\n",
1568 &dip);
1569 return;
1570 }
1571
1572 netdev_dbg(dev, "Updating neighbour with IP=%pI6c\n", &dip);
1573 neigh_event_send(n, NULL);
1574 neigh_release(n);
1575}
b5f3e0d4
IS		 1576#else
1577static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
1578 char *rauhtd_pl,
1579 int rec_index)
1580{
1581}
1582#endif
60f040ca 1583
c723c735
YG		 1584static void mlxsw_sp_router_neigh_rec_ipv4_process(struct mlxsw_sp *mlxsw_sp,
1585 char *rauhtd_pl,
1586 int rec_index)
1587{
1588 u8 num_entries;
1589 int i;
1590
1591 num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
1592 rec_index);
1593 /* Hardware starts counting at 0, so add 1. */
1594 num_entries++;
1595
1596 /* Each record consists of several neighbour entries. */
1597 for (i = 0; i < num_entries; i++) {
1598 int ent_index;
1599
1600 ent_index = rec_index * MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC + i;
1601 mlxsw_sp_router_neigh_ent_ipv4_process(mlxsw_sp, rauhtd_pl,
1602 ent_index);
1603 }
1604
1605}
1606
60f040ca
AS		 1607static void mlxsw_sp_router_neigh_rec_ipv6_process(struct mlxsw_sp *mlxsw_sp,
1608 char *rauhtd_pl,
1609 int rec_index)
1610{
1611 /* One record contains one entry. */
1612 mlxsw_sp_router_neigh_ent_ipv6_process(mlxsw_sp, rauhtd_pl,
1613 rec_index);
1614}
1615
c723c735
YG		 1616static void mlxsw_sp_router_neigh_rec_process(struct mlxsw_sp *mlxsw_sp,
1617 char *rauhtd_pl, int rec_index)
1618{
1619 switch (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, rec_index)) {
1620 case MLXSW_REG_RAUHTD_TYPE_IPV4:
1621 mlxsw_sp_router_neigh_rec_ipv4_process(mlxsw_sp, rauhtd_pl,
1622 rec_index);
1623 break;
1624 case MLXSW_REG_RAUHTD_TYPE_IPV6:
60f040ca
AS		 1625 mlxsw_sp_router_neigh_rec_ipv6_process(mlxsw_sp, rauhtd_pl,
1626 rec_index);
c723c735
YG		 1627 break;
1628 }
1629}
1630
42cdb338
AS		 1631static bool mlxsw_sp_router_rauhtd_is_full(char *rauhtd_pl)
1632{
1633 u8 num_rec, last_rec_index, num_entries;
1634
1635 num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
1636 last_rec_index = num_rec - 1;
1637
1638 if (num_rec < MLXSW_REG_RAUHTD_REC_MAX_NUM)
1639 return false;
1640 if (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, last_rec_index) ==
1641 MLXSW_REG_RAUHTD_TYPE_IPV6)
1642 return true;
1643
1644 num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
1645 last_rec_index);
1646 if (++num_entries == MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC)
1647 return true;
1648 return false;
1649}
1650
60f040ca
AS		 1651static int
1652__mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp,
1653 char *rauhtd_pl,
1654 enum mlxsw_reg_rauhtd_type type)
c723c735 1655{
60f040ca
AS		 1656 int i, num_rec;
1657 int err;
c723c735
YG		 1658
1659 /* Make sure the neighbour's netdev isn't removed in the
1660 * process.
1661 */
1662 rtnl_lock();
1663 do {
60f040ca 1664 mlxsw_reg_rauhtd_pack(rauhtd_pl, type);
c723c735
YG		 1665 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(rauhtd),
1666 rauhtd_pl);
1667 if (err) {
1668 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to dump neighbour talbe\n");
1669 break;
1670 }
1671 num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
1672 for (i = 0; i < num_rec; i++)
1673 mlxsw_sp_router_neigh_rec_process(mlxsw_sp, rauhtd_pl,
1674 i);
42cdb338 1675 } while (mlxsw_sp_router_rauhtd_is_full(rauhtd_pl));
c723c735
YG		 1676 rtnl_unlock();
1677
60f040ca
AS		 1678 return err;
1679}
1680
1681static int mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp)
1682{
1683 enum mlxsw_reg_rauhtd_type type;
1684 char *rauhtd_pl;
1685 int err;
1686
1687 rauhtd_pl = kmalloc(MLXSW_REG_RAUHTD_LEN, GFP_KERNEL);
1688 if (!rauhtd_pl)
1689 return -ENOMEM;
1690
1691 type = MLXSW_REG_RAUHTD_TYPE_IPV4;
1692 err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
1693 if (err)
1694 goto out;
1695
1696 type = MLXSW_REG_RAUHTD_TYPE_IPV6;
1697 err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
1698out:
c723c735 1699 kfree(rauhtd_pl);
b2157149
YG		 1700 return err;
1701}
1702
1703static void mlxsw_sp_router_neighs_update_nh(struct mlxsw_sp *mlxsw_sp)
1704{
1705 struct mlxsw_sp_neigh_entry *neigh_entry;
1706
1707 /* Take RTNL mutex here to prevent lists from changes */
1708 rtnl_lock();
9011b677 1709 list_for_each_entry(neigh_entry, &mlxsw_sp->router->nexthop_neighs_list,
8a0b7275 1710 nexthop_neighs_list_node)
b2157149
YG		 1711 /* If this neigh have nexthops, make the kernel think this neigh
1712 * is active regardless of the traffic.
1713 */
8a0b7275 1714 neigh_event_send(neigh_entry->key.n, NULL);
b2157149
YG		 1715 rtnl_unlock();
1716}
1717
1718static void
1719mlxsw_sp_router_neighs_update_work_schedule(struct mlxsw_sp *mlxsw_sp)
1720{
9011b677 1721 unsigned long interval = mlxsw_sp->router->neighs_update.interval;
b2157149 1722
9011b677 1723 mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw,
b2157149
YG		 1724 msecs_to_jiffies(interval));
1725}
1726
1727static void mlxsw_sp_router_neighs_update_work(struct work_struct *work)
1728{
9011b677 1729 struct mlxsw_sp_router *router;
b2157149
YG		 1730 int err;
1731
9011b677
IS		 1732 router = container_of(work, struct mlxsw_sp_router,
1733 neighs_update.dw.work);
1734 err = mlxsw_sp_router_neighs_update_rauhtd(router->mlxsw_sp);
b2157149 1735 if (err)
9011b677 1736 dev_err(router->mlxsw_sp->bus_info->dev, "Could not update kernel for neigh activity");
b2157149 1737
9011b677 1738 mlxsw_sp_router_neighs_update_nh(router->mlxsw_sp);
b2157149 1739
9011b677 1740 mlxsw_sp_router_neighs_update_work_schedule(router->mlxsw_sp);
c723c735
YG		 1741}
1742
0b2361d9
YG		 1743static void mlxsw_sp_router_probe_unresolved_nexthops(struct work_struct *work)
1744{
1745 struct mlxsw_sp_neigh_entry *neigh_entry;
9011b677 1746 struct mlxsw_sp_router *router;
0b2361d9 1747
9011b677
IS		 1748 router = container_of(work, struct mlxsw_sp_router,
1749 nexthop_probe_dw.work);
0b2361d9
YG		 1750 /* Iterate over nexthop neighbours, find those who are unresolved and
1751 * send arp on them. This solves the chicken-egg problem when
1752 * the nexthop wouldn't get offloaded until the neighbor is resolved
1753 * but it wouldn't get resolved ever in case traffic is flowing in HW
1754 * using different nexthop.
1755 *
1756 * Take RTNL mutex here to prevent lists from changes.
1757 */
1758 rtnl_lock();
9011b677 1759 list_for_each_entry(neigh_entry, &router->nexthop_neighs_list,
8a0b7275 1760 nexthop_neighs_list_node)
01b1aa35 1761 if (!neigh_entry->connected)
33b1341c 1762 neigh_event_send(neigh_entry->key.n, NULL);
0b2361d9
YG		 1763 rtnl_unlock();
1764
9011b677 1765 mlxsw_core_schedule_dw(&router->nexthop_probe_dw,
0b2361d9
YG		 1766 MLXSW_SP_UNRESOLVED_NH_PROBE_INTERVAL);
1767}
1768
a7ff87ac
JP		 1769static void
1770mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
1771 struct mlxsw_sp_neigh_entry *neigh_entry,
1772 bool removing);
1773
5c8802f1
IS		 1774static enum mlxsw_reg_rauht_op mlxsw_sp_rauht_op(bool adding)
1775{
1776 return adding ? MLXSW_REG_RAUHT_OP_WRITE_ADD :
1777 MLXSW_REG_RAUHT_OP_WRITE_DELETE;
1778}
1779
1780static void
1781mlxsw_sp_router_neigh_entry_op4(struct mlxsw_sp *mlxsw_sp,
1782 struct mlxsw_sp_neigh_entry *neigh_entry,
1783 enum mlxsw_reg_rauht_op op)
a6bf9e93 1784{
33b1341c 1785 struct neighbour *n = neigh_entry->key.n;
5c8802f1 1786 u32 dip = ntohl(*((__be32 *) n->primary_key));
a6bf9e93 1787 char rauht_pl[MLXSW_REG_RAUHT_LEN];
5c8802f1
IS		 1788
1789 mlxsw_reg_rauht_pack4(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
1790 dip);
7cfcbc75
AS		 1791 if (neigh_entry->counter_valid)
1792 mlxsw_reg_rauht_pack_counter(rauht_pl,
1793 neigh_entry->counter_index);
5c8802f1
IS		 1794 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
1795}
1796
d5eb89cf
AS		 1797static void
1798mlxsw_sp_router_neigh_entry_op6(struct mlxsw_sp *mlxsw_sp,
1799 struct mlxsw_sp_neigh_entry *neigh_entry,
1800 enum mlxsw_reg_rauht_op op)
1801{
1802 struct neighbour *n = neigh_entry->key.n;
1803 char rauht_pl[MLXSW_REG_RAUHT_LEN];
1804 const char *dip = n->primary_key;
1805
1806 mlxsw_reg_rauht_pack6(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
1807 dip);
7cfcbc75
AS		 1808 if (neigh_entry->counter_valid)
1809 mlxsw_reg_rauht_pack_counter(rauht_pl,
1810 neigh_entry->counter_index);
d5eb89cf
AS		 1811 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
1812}
1813
1d1056d8 1814bool mlxsw_sp_neigh_ipv6_ignore(struct mlxsw_sp_neigh_entry *neigh_entry)
d5eb89cf 1815{
1d1056d8
AS		 1816 struct neighbour *n = neigh_entry->key.n;
1817
d5eb89cf
AS		 1818 /* Packets with a link-local destination address are trapped
1819 * after LPM lookup and never reach the neighbour table, so
1820 * there is no need to program such neighbours to the device.
1821 */
1822 if (ipv6_addr_type((struct in6_addr *) &n->primary_key) &
1823 IPV6_ADDR_LINKLOCAL)
1824 return true;
1825 return false;
1826}
1827
5c8802f1
IS		 1828static void
1829mlxsw_sp_neigh_entry_update(struct mlxsw_sp *mlxsw_sp,
1830 struct mlxsw_sp_neigh_entry *neigh_entry,
1831 bool adding)
1832{
1833 if (!adding && !neigh_entry->connected)
1834 return;
1835 neigh_entry->connected = adding;
b5f3e0d4 1836 if (neigh_entry->key.n->tbl->family == AF_INET) {
5c8802f1
IS		 1837 mlxsw_sp_router_neigh_entry_op4(mlxsw_sp, neigh_entry,
1838 mlxsw_sp_rauht_op(adding));
b5f3e0d4 1839 } else if (neigh_entry->key.n->tbl->family == AF_INET6) {
1d1056d8 1840 if (mlxsw_sp_neigh_ipv6_ignore(neigh_entry))
d5eb89cf
AS		 1841 return;
1842 mlxsw_sp_router_neigh_entry_op6(mlxsw_sp, neigh_entry,
1843 mlxsw_sp_rauht_op(adding));
1844 } else {
5c8802f1 1845 WARN_ON_ONCE(1);
d5eb89cf 1846 }
5c8802f1
IS		 1847}
1848
a481d713
AS		 1849void
1850mlxsw_sp_neigh_entry_counter_update(struct mlxsw_sp *mlxsw_sp,
1851 struct mlxsw_sp_neigh_entry *neigh_entry,
1852 bool adding)
1853{
1854 if (adding)
1855 mlxsw_sp_neigh_counter_alloc(mlxsw_sp, neigh_entry);
1856 else
1857 mlxsw_sp_neigh_counter_free(mlxsw_sp, neigh_entry);
1858 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, true);
1859}
1860
5c8802f1
IS		 1861struct mlxsw_sp_neigh_event_work {
1862 struct work_struct work;
1863 struct mlxsw_sp *mlxsw_sp;
1864 struct neighbour *n;
1865};
1866
1867static void mlxsw_sp_router_neigh_event_work(struct work_struct *work)
1868{
1869 struct mlxsw_sp_neigh_event_work *neigh_work =
1870 container_of(work, struct mlxsw_sp_neigh_event_work, work);
1871 struct mlxsw_sp *mlxsw_sp = neigh_work->mlxsw_sp;
1872 struct mlxsw_sp_neigh_entry *neigh_entry;
1873 struct neighbour *n = neigh_work->n;
1874 unsigned char ha[ETH_ALEN];
a6bf9e93 1875 bool entry_connected;
93a87e5e 1876 u8 nud_state, dead;
a6bf9e93 1877
5c8802f1
IS		 1878 /* If these parameters are changed after we release the lock,
1879 * then we are guaranteed to receive another event letting us
1880 * know about it.
1881 */
a6bf9e93 1882 read_lock_bh(&n->lock);
5c8802f1 1883 memcpy(ha, n->ha, ETH_ALEN);
a6bf9e93 1884 nud_state = n->nud_state;
93a87e5e 1885 dead = n->dead;
a6bf9e93
YG		 1886 read_unlock_bh(&n->lock);
1887
5c8802f1 1888 rtnl_lock();
93a87e5e 1889 entry_connected = nud_state & NUD_VALID && !dead;
5c8802f1
IS		 1890 neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
1891 if (!entry_connected && !neigh_entry)
1892 goto out;
1893 if (!neigh_entry) {
1894 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
1895 if (IS_ERR(neigh_entry))
1896 goto out;
a6bf9e93
YG		 1897 }
1898
5c8802f1
IS		 1899 memcpy(neigh_entry->ha, ha, ETH_ALEN);
1900 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, entry_connected);
1901 mlxsw_sp_nexthop_neigh_update(mlxsw_sp, neigh_entry, !entry_connected);
1902
1903 if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
1904 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
1905
1906out:
1907 rtnl_unlock();
a6bf9e93 1908 neigh_release(n);
5c8802f1 1909 kfree(neigh_work);
a6bf9e93
YG		 1910}
1911
e7322638
JP		 1912int mlxsw_sp_router_netevent_event(struct notifier_block *unused,
1913 unsigned long event, void *ptr)
c723c735 1914{
5c8802f1 1915 struct mlxsw_sp_neigh_event_work *neigh_work;
c723c735
YG		 1916 struct mlxsw_sp_port *mlxsw_sp_port;
1917 struct mlxsw_sp *mlxsw_sp;
1918 unsigned long interval;
1919 struct neigh_parms *p;
a6bf9e93 1920 struct neighbour *n;
c723c735
YG		 1921
1922 switch (event) {
1923 case NETEVENT_DELAY_PROBE_TIME_UPDATE:
1924 p = ptr;
1925
1926 /* We don't care about changes in the default table. */
b5f3e0d4
IS		 1927 if (!p->dev || (p->tbl->family != AF_INET &&
1928 p->tbl->family != AF_INET6))
c723c735
YG		 1929 return NOTIFY_DONE;
1930
1931 /* We are in atomic context and can't take RTNL mutex,
1932 * so use RCU variant to walk the device chain.
1933 */
1934 mlxsw_sp_port = mlxsw_sp_port_lower_dev_hold(p->dev);
1935 if (!mlxsw_sp_port)
1936 return NOTIFY_DONE;
1937
1938 mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1939 interval = jiffies_to_msecs(NEIGH_VAR(p, DELAY_PROBE_TIME));
9011b677 1940 mlxsw_sp->router->neighs_update.interval = interval;
c723c735
YG		 1941
1942 mlxsw_sp_port_dev_put(mlxsw_sp_port);
1943 break;
a6bf9e93
YG		 1944 case NETEVENT_NEIGH_UPDATE:
1945 n = ptr;
a6bf9e93 1946
b5f3e0d4 1947 if (n->tbl->family != AF_INET && n->tbl->family != AF_INET6)
a6bf9e93
YG		 1948 return NOTIFY_DONE;
1949
5c8802f1 1950 mlxsw_sp_port = mlxsw_sp_port_lower_dev_hold(n->dev);
a6bf9e93
YG		 1951 if (!mlxsw_sp_port)
1952 return NOTIFY_DONE;
1953
5c8802f1
IS		 1954 neigh_work = kzalloc(sizeof(*neigh_work), GFP_ATOMIC);
1955 if (!neigh_work) {
a6bf9e93 1956 mlxsw_sp_port_dev_put(mlxsw_sp_port);
5c8802f1 1957 return NOTIFY_BAD;
a6bf9e93 1958 }
5c8802f1
IS		 1959
1960 INIT_WORK(&neigh_work->work, mlxsw_sp_router_neigh_event_work);
1961 neigh_work->mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1962 neigh_work->n = n;
a6bf9e93
YG		 1963
1964 /* Take a reference to ensure the neighbour won't be
1965 * destructed until we drop the reference in delayed
1966 * work.
1967 */
1968 neigh_clone(n);
5c8802f1
IS		 1969 mlxsw_core_schedule_work(&neigh_work->work);
1970 mlxsw_sp_port_dev_put(mlxsw_sp_port);
a6bf9e93 1971 break;
c723c735
YG		 1972 }
1973
1974 return NOTIFY_DONE;
1975}
1976
6cf3c971
JP		 1977static int mlxsw_sp_neigh_init(struct mlxsw_sp *mlxsw_sp)
1978{
c723c735
YG		 1979 int err;
1980
9011b677 1981 err = rhashtable_init(&mlxsw_sp->router->neigh_ht,
c723c735
YG		 1982 &mlxsw_sp_neigh_ht_params);
1983 if (err)
1984 return err;
1985
1986 /* Initialize the polling interval according to the default
1987 * table.
1988 */
1989 mlxsw_sp_router_neighs_update_interval_init(mlxsw_sp);
1990
0b2361d9 1991 /* Create the delayed works for the activity_update */
9011b677 1992 INIT_DELAYED_WORK(&mlxsw_sp->router->neighs_update.dw,
c723c735 1993 mlxsw_sp_router_neighs_update_work);
9011b677 1994 INIT_DELAYED_WORK(&mlxsw_sp->router->nexthop_probe_dw,
0b2361d9 1995 mlxsw_sp_router_probe_unresolved_nexthops);
9011b677
IS		 1996 mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw, 0);
1997 mlxsw_core_schedule_dw(&mlxsw_sp->router->nexthop_probe_dw, 0);
c723c735 1998 return 0;
6cf3c971
JP		 1999}
2000
2001static void mlxsw_sp_neigh_fini(struct mlxsw_sp *mlxsw_sp)
2002{
9011b677
IS		 2003 cancel_delayed_work_sync(&mlxsw_sp->router->neighs_update.dw);
2004 cancel_delayed_work_sync(&mlxsw_sp->router->nexthop_probe_dw);
2005 rhashtable_destroy(&mlxsw_sp->router->neigh_ht);
6cf3c971
JP		 2006}
2007
9665b745 2008static void mlxsw_sp_neigh_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
bf95233e 2009 struct mlxsw_sp_rif *rif)
9665b745
IS		 2010{
2011 struct mlxsw_sp_neigh_entry *neigh_entry, *tmp;
2012
bf95233e 2013 list_for_each_entry_safe(neigh_entry, tmp, &rif->neigh_list,
4a3c67a6
IS		 2014 rif_list_node) {
2015 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, false);
9665b745 2016 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
4a3c67a6 2017 }
9665b745
IS		 2018}
2019
35225e47
PM		 2020enum mlxsw_sp_nexthop_type {
2021 MLXSW_SP_NEXTHOP_TYPE_ETH,
1012b9ac 2022 MLXSW_SP_NEXTHOP_TYPE_IPIP,
35225e47
PM		 2023};
2024
c53b8e1b
IS		 2025struct mlxsw_sp_nexthop_key {
2026 struct fib_nh *fib_nh;
2027};
2028
a7ff87ac
JP		 2029struct mlxsw_sp_nexthop {
2030 struct list_head neigh_list_node; /* member of neigh entry list */
9665b745 2031 struct list_head rif_list_node;
dbe4598c 2032 struct list_head router_list_node;
a7ff87ac
JP		 2033 struct mlxsw_sp_nexthop_group *nh_grp; /* pointer back to the group
2034 * this belongs to
2035 */
c53b8e1b
IS		 2036 struct rhash_head ht_node;
2037 struct mlxsw_sp_nexthop_key key;
58adf2c4 2038 unsigned char gw_addr[sizeof(struct in6_addr)];
e6f3b379 2039 int ifindex;
bf95233e 2040 struct mlxsw_sp_rif *rif;
a7ff87ac
JP		 2041 u8 should_offload:1, /* set indicates this neigh is connected and
2042 * should be put to KVD linear area of this group.
2043 */
2044 offloaded:1, /* set in case the neigh is actually put into
2045 * KVD linear area of this group.
2046 */
2047 update:1; /* set indicates that MAC of this neigh should be
2048 * updated in HW
2049 */
35225e47
PM		 2050 enum mlxsw_sp_nexthop_type type;
2051 union {
2052 struct mlxsw_sp_neigh_entry *neigh_entry;
1012b9ac 2053 struct mlxsw_sp_ipip_entry *ipip_entry;
35225e47 2054 };
a5390278
AS		 2055 unsigned int counter_index;
2056 bool counter_valid;
a7ff87ac
JP		 2057};
2058
2059struct mlxsw_sp_nexthop_group {
ba31d366 2060 void *priv;
e9ad5e7d 2061 struct rhash_head ht_node;
a7ff87ac 2062 struct list_head fib_list; /* list of fib entries that use this group */
58adf2c4 2063 struct neigh_table *neigh_tbl;
b3e8d1eb
IS		 2064 u8 adj_index_valid:1,
2065 gateway:1; /* routes using the group use a gateway */
a7ff87ac
JP		 2066 u32 adj_index;
2067 u16 ecmp_size;
2068 u16 count;
2069 struct mlxsw_sp_nexthop nexthops[0];
bf95233e 2070#define nh_rif nexthops[0].rif
a7ff87ac
JP		 2071};
2072
427e652a
AS		 2073void mlxsw_sp_nexthop_counter_alloc(struct mlxsw_sp *mlxsw_sp,
2074 struct mlxsw_sp_nexthop *nh)
a5390278
AS		 2075{
2076 struct devlink *devlink;
2077
2078 devlink = priv_to_devlink(mlxsw_sp->core);
2079 if (!devlink_dpipe_table_counter_enabled(devlink,
2080 MLXSW_SP_DPIPE_TABLE_NAME_ADJ))
2081 return;
2082
2083 if (mlxsw_sp_flow_counter_alloc(mlxsw_sp, &nh->counter_index))
2084 return;
2085
2086 nh->counter_valid = true;
2087}
2088
427e652a
AS		 2089void mlxsw_sp_nexthop_counter_free(struct mlxsw_sp *mlxsw_sp,
2090 struct mlxsw_sp_nexthop *nh)
a5390278
AS		 2091{
2092 if (!nh->counter_valid)
2093 return;
2094 mlxsw_sp_flow_counter_free(mlxsw_sp, nh->counter_index);
2095 nh->counter_valid = false;
2096}
2097
2098int mlxsw_sp_nexthop_counter_get(struct mlxsw_sp *mlxsw_sp,
2099 struct mlxsw_sp_nexthop *nh, u64 *p_counter)
2100{
2101 if (!nh->counter_valid)
2102 return -EINVAL;
2103
2104 return mlxsw_sp_flow_counter_get(mlxsw_sp, nh->counter_index,
2105 p_counter, NULL);
2106}
2107
c556cd28
AS		 2108struct mlxsw_sp_nexthop *mlxsw_sp_nexthop_next(struct mlxsw_sp_router *router,
2109 struct mlxsw_sp_nexthop *nh)
2110{
2111 if (!nh) {
2112 if (list_empty(&router->nexthop_list))
2113 return NULL;
2114 else
2115 return list_first_entry(&router->nexthop_list,
2116 typeof(*nh), router_list_node);
2117 }
2118 if (list_is_last(&nh->router_list_node, &router->nexthop_list))
2119 return NULL;
2120 return list_next_entry(nh, router_list_node);
2121}
2122
2123bool mlxsw_sp_nexthop_offload(struct mlxsw_sp_nexthop *nh)
2124{
2125 return nh->offloaded;
2126}
2127
2128unsigned char *mlxsw_sp_nexthop_ha(struct mlxsw_sp_nexthop *nh)
2129{
2130 if (!nh->offloaded)
2131 return NULL;
2132 return nh->neigh_entry->ha;
2133}
2134
2135int mlxsw_sp_nexthop_indexes(struct mlxsw_sp_nexthop *nh, u32 *p_adj_index,
2136 u32 *p_adj_hash_index)
2137{
2138 struct mlxsw_sp_nexthop_group *nh_grp = nh->nh_grp;
2139 u32 adj_hash_index = 0;
2140 int i;
2141
2142 if (!nh->offloaded || !nh_grp->adj_index_valid)
2143 return -EINVAL;
2144
2145 *p_adj_index = nh_grp->adj_index;
2146
2147 for (i = 0; i < nh_grp->count; i++) {
2148 struct mlxsw_sp_nexthop *nh_iter = &nh_grp->nexthops[i];
2149
2150 if (nh_iter == nh)
2151 break;
2152 if (nh_iter->offloaded)
2153 adj_hash_index++;
2154 }
2155
2156 *p_adj_hash_index = adj_hash_index;
2157 return 0;
2158}
2159
2160struct mlxsw_sp_rif *mlxsw_sp_nexthop_rif(struct mlxsw_sp_nexthop *nh)
2161{
2162 return nh->rif;
2163}
2164
2165bool mlxsw_sp_nexthop_group_has_ipip(struct mlxsw_sp_nexthop *nh)
2166{
2167 struct mlxsw_sp_nexthop_group *nh_grp = nh->nh_grp;
2168 int i;
2169
2170 for (i = 0; i < nh_grp->count; i++) {
2171 struct mlxsw_sp_nexthop *nh_iter = &nh_grp->nexthops[i];
2172
2173 if (nh_iter->type == MLXSW_SP_NEXTHOP_TYPE_IPIP)
2174 return true;
2175 }
2176 return false;
2177}
2178
ba31d366
AS		 2179static struct fib_info *
2180mlxsw_sp_nexthop4_group_fi(const struct mlxsw_sp_nexthop_group *nh_grp)
2181{
2182 return nh_grp->priv;
2183}
2184
2185struct mlxsw_sp_nexthop_group_cmp_arg {
e6f3b379
AS		 2186 enum mlxsw_sp_l3proto proto;
2187 union {
2188 struct fib_info *fi;
2189 struct mlxsw_sp_fib6_entry *fib6_entry;
2190 };
ba31d366
AS		 2191};
2192
e6f3b379
AS		 2193static bool
2194mlxsw_sp_nexthop6_group_has_nexthop(const struct mlxsw_sp_nexthop_group *nh_grp,
2195 const struct in6_addr *gw, int ifindex)
2196{
2197 int i;
2198
2199 for (i = 0; i < nh_grp->count; i++) {
2200 const struct mlxsw_sp_nexthop *nh;
2201
2202 nh = &nh_grp->nexthops[i];
2203 if (nh->ifindex == ifindex &&
2204 ipv6_addr_equal(gw, (struct in6_addr *) nh->gw_addr))
2205 return true;
2206 }
2207
2208 return false;
2209}
2210
2211static bool
2212mlxsw_sp_nexthop6_group_cmp(const struct mlxsw_sp_nexthop_group *nh_grp,
2213 const struct mlxsw_sp_fib6_entry *fib6_entry)
2214{
2215 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
2216
2217 if (nh_grp->count != fib6_entry->nrt6)
2218 return false;
2219
2220 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
2221 struct in6_addr *gw;
2222 int ifindex;
2223
2224 ifindex = mlxsw_sp_rt6->rt->dst.dev->ifindex;
2225 gw = &mlxsw_sp_rt6->rt->rt6i_gateway;
2226 if (!mlxsw_sp_nexthop6_group_has_nexthop(nh_grp, gw, ifindex))
2227 return false;
2228 }
2229
2230 return true;
2231}
2232
ba31d366
AS		 2233static int
2234mlxsw_sp_nexthop_group_cmp(struct rhashtable_compare_arg *arg, const void *ptr)
2235{
2236 const struct mlxsw_sp_nexthop_group_cmp_arg *cmp_arg = arg->key;
2237 const struct mlxsw_sp_nexthop_group *nh_grp = ptr;
2238
e6f3b379
AS		 2239 switch (cmp_arg->proto) {
2240 case MLXSW_SP_L3_PROTO_IPV4:
2241 return cmp_arg->fi != mlxsw_sp_nexthop4_group_fi(nh_grp);
2242 case MLXSW_SP_L3_PROTO_IPV6:
2243 return !mlxsw_sp_nexthop6_group_cmp(nh_grp,
2244 cmp_arg->fib6_entry);
2245 default:
2246 WARN_ON(1);
2247 return 1;
2248 }
2249}
2250
2251static int
2252mlxsw_sp_nexthop_group_type(const struct mlxsw_sp_nexthop_group *nh_grp)
2253{
2254 return nh_grp->neigh_tbl->family;
ba31d366
AS		 2255}
2256
2257static u32 mlxsw_sp_nexthop_group_hash_obj(const void *data, u32 len, u32 seed)
2258{
2259 const struct mlxsw_sp_nexthop_group *nh_grp = data;
e6f3b379
AS		 2260 const struct mlxsw_sp_nexthop *nh;
2261 struct fib_info *fi;
2262 unsigned int val;
2263 int i;
ba31d366 2264
e6f3b379
AS		 2265 switch (mlxsw_sp_nexthop_group_type(nh_grp)) {
2266 case AF_INET:
2267 fi = mlxsw_sp_nexthop4_group_fi(nh_grp);
2268 return jhash(&fi, sizeof(fi), seed);
2269 case AF_INET6:
2270 val = nh_grp->count;
2271 for (i = 0; i < nh_grp->count; i++) {
2272 nh = &nh_grp->nexthops[i];
2273 val ^= nh->ifindex;
2274 }
2275 return jhash(&val, sizeof(val), seed);
2276 default:
2277 WARN_ON(1);
2278 return 0;
2279 }
2280}
2281
2282static u32
2283mlxsw_sp_nexthop6_group_hash(struct mlxsw_sp_fib6_entry *fib6_entry, u32 seed)
2284{
2285 unsigned int val = fib6_entry->nrt6;
2286 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
2287 struct net_device *dev;
2288
2289 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
2290 dev = mlxsw_sp_rt6->rt->dst.dev;
2291 val ^= dev->ifindex;
2292 }
2293
2294 return jhash(&val, sizeof(val), seed);
ba31d366
AS		 2295}
2296
2297static u32
2298mlxsw_sp_nexthop_group_hash(const void *data, u32 len, u32 seed)
2299{
2300 const struct mlxsw_sp_nexthop_group_cmp_arg *cmp_arg = data;
2301
e6f3b379
AS		 2302 switch (cmp_arg->proto) {
2303 case MLXSW_SP_L3_PROTO_IPV4:
2304 return jhash(&cmp_arg->fi, sizeof(cmp_arg->fi), seed);
2305 case MLXSW_SP_L3_PROTO_IPV6:
2306 return mlxsw_sp_nexthop6_group_hash(cmp_arg->fib6_entry, seed);
2307 default:
2308 WARN_ON(1);
2309 return 0;
2310 }
ba31d366
AS		 2311}
2312
e9ad5e7d 2313static const struct rhashtable_params mlxsw_sp_nexthop_group_ht_params = {
e9ad5e7d 2314 .head_offset = offsetof(struct mlxsw_sp_nexthop_group, ht_node),
ba31d366
AS		 2315 .hashfn = mlxsw_sp_nexthop_group_hash,
2316 .obj_hashfn = mlxsw_sp_nexthop_group_hash_obj,
2317 .obj_cmpfn = mlxsw_sp_nexthop_group_cmp,
e9ad5e7d
IS		 2318};
2319
2320static int mlxsw_sp_nexthop_group_insert(struct mlxsw_sp *mlxsw_sp,
2321 struct mlxsw_sp_nexthop_group *nh_grp)
2322{
e6f3b379
AS		 2323 if (mlxsw_sp_nexthop_group_type(nh_grp) == AF_INET6 &&
2324 !nh_grp->gateway)
2325 return 0;
2326
9011b677 2327 return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_group_ht,
e9ad5e7d
IS		 2328 &nh_grp->ht_node,
2329 mlxsw_sp_nexthop_group_ht_params);
2330}
2331
2332static void mlxsw_sp_nexthop_group_remove(struct mlxsw_sp *mlxsw_sp,
2333 struct mlxsw_sp_nexthop_group *nh_grp)
2334{
e6f3b379
AS		 2335 if (mlxsw_sp_nexthop_group_type(nh_grp) == AF_INET6 &&
2336 !nh_grp->gateway)
2337 return;
2338
9011b677 2339 rhashtable_remove_fast(&mlxsw_sp->router->nexthop_group_ht,
e9ad5e7d
IS		 2340 &nh_grp->ht_node,
2341 mlxsw_sp_nexthop_group_ht_params);
2342}
2343
2344static struct mlxsw_sp_nexthop_group *
ba31d366
AS		 2345mlxsw_sp_nexthop4_group_lookup(struct mlxsw_sp *mlxsw_sp,
2346 struct fib_info *fi)
e9ad5e7d 2347{
ba31d366
AS		 2348 struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
2349
e6f3b379 2350 cmp_arg.proto = MLXSW_SP_L3_PROTO_IPV4;
ba31d366
AS		 2351 cmp_arg.fi = fi;
2352 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
2353 &cmp_arg,
e9ad5e7d
IS		 2354 mlxsw_sp_nexthop_group_ht_params);
2355}
2356
e6f3b379
AS		 2357static struct mlxsw_sp_nexthop_group *
2358mlxsw_sp_nexthop6_group_lookup(struct mlxsw_sp *mlxsw_sp,
2359 struct mlxsw_sp_fib6_entry *fib6_entry)
2360{
2361 struct mlxsw_sp_nexthop_group_cmp_arg cmp_arg;
2362
2363 cmp_arg.proto = MLXSW_SP_L3_PROTO_IPV6;
2364 cmp_arg.fib6_entry = fib6_entry;
2365 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht,
2366 &cmp_arg,
2367 mlxsw_sp_nexthop_group_ht_params);
2368}
2369
c53b8e1b
IS		 2370static const struct rhashtable_params mlxsw_sp_nexthop_ht_params = {
2371 .key_offset = offsetof(struct mlxsw_sp_nexthop, key),
2372 .head_offset = offsetof(struct mlxsw_sp_nexthop, ht_node),
2373 .key_len = sizeof(struct mlxsw_sp_nexthop_key),
2374};
2375
2376static int mlxsw_sp_nexthop_insert(struct mlxsw_sp *mlxsw_sp,
2377 struct mlxsw_sp_nexthop *nh)
2378{
9011b677 2379 return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_ht,
c53b8e1b
IS		 2380 &nh->ht_node, mlxsw_sp_nexthop_ht_params);
2381}
2382
2383static void mlxsw_sp_nexthop_remove(struct mlxsw_sp *mlxsw_sp,
2384 struct mlxsw_sp_nexthop *nh)
2385{
9011b677 2386 rhashtable_remove_fast(&mlxsw_sp->router->nexthop_ht, &nh->ht_node,
c53b8e1b
IS		 2387 mlxsw_sp_nexthop_ht_params);
2388}
2389
ad178c8e
IS		 2390static struct mlxsw_sp_nexthop *
2391mlxsw_sp_nexthop_lookup(struct mlxsw_sp *mlxsw_sp,
2392 struct mlxsw_sp_nexthop_key key)
2393{
9011b677 2394 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_ht, &key,
ad178c8e
IS		 2395 mlxsw_sp_nexthop_ht_params);
2396}
2397
a7ff87ac 2398static int mlxsw_sp_adj_index_mass_update_vr(struct mlxsw_sp *mlxsw_sp,
76610ebb 2399 const struct mlxsw_sp_fib *fib,
a7ff87ac
JP		 2400 u32 adj_index, u16 ecmp_size,
2401 u32 new_adj_index,
2402 u16 new_ecmp_size)
2403{
2404 char raleu_pl[MLXSW_REG_RALEU_LEN];
2405
1a9234e6 2406 mlxsw_reg_raleu_pack(raleu_pl,
76610ebb
IS		 2407 (enum mlxsw_reg_ralxx_protocol) fib->proto,
2408 fib->vr->id, adj_index, ecmp_size, new_adj_index,
1a9234e6 2409 new_ecmp_size);
a7ff87ac
JP		 2410 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raleu), raleu_pl);
2411}
2412
2413static int mlxsw_sp_adj_index_mass_update(struct mlxsw_sp *mlxsw_sp,
2414 struct mlxsw_sp_nexthop_group *nh_grp,
2415 u32 old_adj_index, u16 old_ecmp_size)
2416{
2417 struct mlxsw_sp_fib_entry *fib_entry;
76610ebb 2418 struct mlxsw_sp_fib *fib = NULL;
a7ff87ac
JP		 2419 int err;
2420
2421 list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
76610ebb 2422 if (fib == fib_entry->fib_node->fib)
a7ff87ac 2423 continue;
76610ebb
IS		 2424 fib = fib_entry->fib_node->fib;
2425 err = mlxsw_sp_adj_index_mass_update_vr(mlxsw_sp, fib,
a7ff87ac
JP		 2426 old_adj_index,
2427 old_ecmp_size,
2428 nh_grp->adj_index,
2429 nh_grp->ecmp_size);
2430 if (err)
2431 return err;
2432 }
2433 return 0;
2434}
2435
427e652a
AS		 2436int mlxsw_sp_nexthop_update(struct mlxsw_sp *mlxsw_sp, u32 adj_index,
2437 struct mlxsw_sp_nexthop *nh)
a7ff87ac
JP		 2438{
2439 struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
2440 char ratr_pl[MLXSW_REG_RATR_LEN];
2441
2442 mlxsw_reg_ratr_pack(ratr_pl, MLXSW_REG_RATR_OP_WRITE_WRITE_ENTRY,
89e41982
PM		 2443 true, MLXSW_REG_RATR_TYPE_ETHERNET,
2444 adj_index, neigh_entry->rif);
a7ff87ac 2445 mlxsw_reg_ratr_eth_entry_pack(ratr_pl, neigh_entry->ha);
a5390278
AS		 2446 if (nh->counter_valid)
2447 mlxsw_reg_ratr_counter_pack(ratr_pl, nh->counter_index, true);
2448 else
2449 mlxsw_reg_ratr_counter_pack(ratr_pl, 0, false);
2450
a7ff87ac
JP		 2451 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ratr), ratr_pl);
2452}
2453
1012b9ac
PM		 2454static int mlxsw_sp_nexthop_ipip_update(struct mlxsw_sp *mlxsw_sp,
2455 u32 adj_index,
2456 struct mlxsw_sp_nexthop *nh)
2457{
2458 const struct mlxsw_sp_ipip_ops *ipip_ops;
2459
2460 ipip_ops = mlxsw_sp->router->ipip_ops_arr[nh->ipip_entry->ipipt];
2461 return ipip_ops->nexthop_update(mlxsw_sp, adj_index, nh->ipip_entry);
2462}
2463
a7ff87ac 2464static int
35225e47
PM		 2465mlxsw_sp_nexthop_group_update(struct mlxsw_sp *mlxsw_sp,
2466 struct mlxsw_sp_nexthop_group *nh_grp,
2467 bool reallocate)
a7ff87ac
JP		 2468{
2469 u32 adj_index = nh_grp->adj_index; /* base */
2470 struct mlxsw_sp_nexthop *nh;
2471 int i;
2472 int err;
2473
2474 for (i = 0; i < nh_grp->count; i++) {
2475 nh = &nh_grp->nexthops[i];
2476
2477 if (!nh->should_offload) {
2478 nh->offloaded = 0;
2479 continue;
2480 }
2481
a59b7e02 2482 if (nh->update || reallocate) {
35225e47
PM		 2483 switch (nh->type) {
2484 case MLXSW_SP_NEXTHOP_TYPE_ETH:
a5390278 2485 err = mlxsw_sp_nexthop_update
35225e47
PM		 2486 (mlxsw_sp, adj_index, nh);
2487 break;
1012b9ac
PM		 2488 case MLXSW_SP_NEXTHOP_TYPE_IPIP:
2489 err = mlxsw_sp_nexthop_ipip_update
2490 (mlxsw_sp, adj_index, nh);
2491 break;
35225e47 2492 }
a7ff87ac
JP		 2493 if (err)
2494 return err;
2495 nh->update = 0;
2496 nh->offloaded = 1;
2497 }
2498 adj_index++;
2499 }
2500 return 0;
2501}
2502
1819ae3d
IS		 2503static bool
2504mlxsw_sp_fib_node_entry_is_first(const struct mlxsw_sp_fib_node *fib_node,
2505 const struct mlxsw_sp_fib_entry *fib_entry);
2506
a7ff87ac
JP		 2507static int
2508mlxsw_sp_nexthop_fib_entries_update(struct mlxsw_sp *mlxsw_sp,
2509 struct mlxsw_sp_nexthop_group *nh_grp)
2510{
2511 struct mlxsw_sp_fib_entry *fib_entry;
2512 int err;
2513
2514 list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
1819ae3d
IS		 2515 if (!mlxsw_sp_fib_node_entry_is_first(fib_entry->fib_node,
2516 fib_entry))
2517 continue;
a7ff87ac
JP		 2518 err = mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
2519 if (err)
2520 return err;
2521 }
2522 return 0;
2523}
2524
77d964e6
IS		 2525static void
2526mlxsw_sp_fib_entry_offload_refresh(struct mlxsw_sp_fib_entry *fib_entry,
2527 enum mlxsw_reg_ralue_op op, int err);
2528
2529static void
2530mlxsw_sp_nexthop_fib_entries_refresh(struct mlxsw_sp_nexthop_group *nh_grp)
2531{
2532 enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_WRITE;
2533 struct mlxsw_sp_fib_entry *fib_entry;
2534
2535 list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
2536 if (!mlxsw_sp_fib_node_entry_is_first(fib_entry->fib_node,
2537 fib_entry))
2538 continue;
2539 mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, 0);
2540 }
2541}
2542
a7ff87ac
JP		 2543static void
2544mlxsw_sp_nexthop_group_refresh(struct mlxsw_sp *mlxsw_sp,
2545 struct mlxsw_sp_nexthop_group *nh_grp)
2546{
2547 struct mlxsw_sp_nexthop *nh;
2548 bool offload_change = false;
2549 u32 adj_index;
2550 u16 ecmp_size = 0;
2551 bool old_adj_index_valid;
2552 u32 old_adj_index;
2553 u16 old_ecmp_size;
a7ff87ac
JP		 2554 int i;
2555 int err;
2556
b3e8d1eb
IS		 2557 if (!nh_grp->gateway) {
2558 mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
2559 return;
2560 }
2561
a7ff87ac
JP		 2562 for (i = 0; i < nh_grp->count; i++) {
2563 nh = &nh_grp->nexthops[i];
2564
56b8a9ed 2565 if (nh->should_offload != nh->offloaded) {
a7ff87ac
JP		 2566 offload_change = true;
2567 if (nh->should_offload)
2568 nh->update = 1;
2569 }
2570 if (nh->should_offload)
2571 ecmp_size++;
2572 }
2573 if (!offload_change) {
2574 /* Nothing was added or removed, so no need to reallocate. Just
2575 * update MAC on existing adjacency indexes.
2576 */
35225e47 2577 err = mlxsw_sp_nexthop_group_update(mlxsw_sp, nh_grp, false);
a7ff87ac
JP		 2578 if (err) {
2579 dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
2580 goto set_trap;
2581 }
2582 return;
2583 }
2584 if (!ecmp_size)
2585 /* No neigh of this group is connected so we just set
2586 * the trap and let everthing flow through kernel.
2587 */
2588 goto set_trap;
2589
13124443
AS		 2590 err = mlxsw_sp_kvdl_alloc(mlxsw_sp, ecmp_size, &adj_index);
2591 if (err) {
a7ff87ac
JP		 2592 /* We ran out of KVD linear space, just set the
2593 * trap and let everything flow through kernel.
2594 */
2595 dev_warn(mlxsw_sp->bus_info->dev, "Failed to allocate KVD linear area for nexthop group.\n");
2596 goto set_trap;
2597 }
a7ff87ac
JP		 2598 old_adj_index_valid = nh_grp->adj_index_valid;
2599 old_adj_index = nh_grp->adj_index;
2600 old_ecmp_size = nh_grp->ecmp_size;
2601 nh_grp->adj_index_valid = 1;
2602 nh_grp->adj_index = adj_index;
2603 nh_grp->ecmp_size = ecmp_size;
35225e47 2604 err = mlxsw_sp_nexthop_group_update(mlxsw_sp, nh_grp, true);
a7ff87ac
JP		 2605 if (err) {
2606 dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
2607 goto set_trap;
2608 }
2609
2610 if (!old_adj_index_valid) {
2611 /* The trap was set for fib entries, so we have to call
2612 * fib entry update to unset it and use adjacency index.
2613 */
2614 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
2615 if (err) {
2616 dev_warn(mlxsw_sp->bus_info->dev, "Failed to add adjacency index to fib entries.\n");
2617 goto set_trap;
2618 }
2619 return;
2620 }
2621
2622 err = mlxsw_sp_adj_index_mass_update(mlxsw_sp, nh_grp,
2623 old_adj_index, old_ecmp_size);
2624 mlxsw_sp_kvdl_free(mlxsw_sp, old_adj_index);
2625 if (err) {
2626 dev_warn(mlxsw_sp->bus_info->dev, "Failed to mass-update adjacency index for nexthop group.\n");
2627 goto set_trap;
2628 }
77d964e6
IS		 2629
2630 /* Offload state within the group changed, so update the flags. */
2631 mlxsw_sp_nexthop_fib_entries_refresh(nh_grp);
2632
a7ff87ac
JP		 2633 return;
2634
2635set_trap:
2636 old_adj_index_valid = nh_grp->adj_index_valid;
2637 nh_grp->adj_index_valid = 0;
2638 for (i = 0; i < nh_grp->count; i++) {
2639 nh = &nh_grp->nexthops[i];
2640 nh->offloaded = 0;
2641 }
2642 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
2643 if (err)
2644 dev_warn(mlxsw_sp->bus_info->dev, "Failed to set traps for fib entries.\n");
2645 if (old_adj_index_valid)
2646 mlxsw_sp_kvdl_free(mlxsw_sp, nh_grp->adj_index);
2647}
2648
2649static void __mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp_nexthop *nh,
2650 bool removing)
2651{
213666a3 2652 if (!removing)
a7ff87ac 2653 nh->should_offload = 1;
213666a3 2654 else if (nh->offloaded)
a7ff87ac
JP		 2655 nh->should_offload = 0;
2656 nh->update = 1;
2657}
2658
2659static void
2660mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
2661 struct mlxsw_sp_neigh_entry *neigh_entry,
2662 bool removing)
2663{
2664 struct mlxsw_sp_nexthop *nh;
2665
a7ff87ac
JP		 2666 list_for_each_entry(nh, &neigh_entry->nexthop_list,
2667 neigh_list_node) {
2668 __mlxsw_sp_nexthop_neigh_update(nh, removing);
2669 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
2670 }
a7ff87ac
JP		 2671}
2672
9665b745 2673static void mlxsw_sp_nexthop_rif_init(struct mlxsw_sp_nexthop *nh,
bf95233e 2674 struct mlxsw_sp_rif *rif)
9665b745 2675{
bf95233e 2676 if (nh->rif)
9665b745
IS		 2677 return;
2678
bf95233e
AS		 2679 nh->rif = rif;
2680 list_add(&nh->rif_list_node, &rif->nexthop_list);
9665b745
IS		 2681}
2682
2683static void mlxsw_sp_nexthop_rif_fini(struct mlxsw_sp_nexthop *nh)
2684{
bf95233e 2685 if (!nh->rif)
9665b745
IS		 2686 return;
2687
2688 list_del(&nh->rif_list_node);
bf95233e 2689 nh->rif = NULL;
9665b745
IS		 2690}
2691
a8c97014
IS		 2692static int mlxsw_sp_nexthop_neigh_init(struct mlxsw_sp *mlxsw_sp,
2693 struct mlxsw_sp_nexthop *nh)
a7ff87ac
JP		 2694{
2695 struct mlxsw_sp_neigh_entry *neigh_entry;
a7ff87ac 2696 struct neighbour *n;
93a87e5e 2697 u8 nud_state, dead;
c53b8e1b
IS		 2698 int err;
2699
ad178c8e 2700 if (!nh->nh_grp->gateway || nh->neigh_entry)
b8399a1e
IS		 2701 return 0;
2702
33b1341c 2703 /* Take a reference of neigh here ensuring that neigh would
8de3c178 2704 * not be destructed before the nexthop entry is finished.
33b1341c 2705 * The reference is taken either in neigh_lookup() or
fd76d910 2706 * in neigh_create() in case n is not found.
33b1341c 2707 */
58adf2c4 2708 n = neigh_lookup(nh->nh_grp->neigh_tbl, &nh->gw_addr, nh->rif->dev);
33b1341c 2709 if (!n) {
58adf2c4
IS		 2710 n = neigh_create(nh->nh_grp->neigh_tbl, &nh->gw_addr,
2711 nh->rif->dev);
a8c97014
IS		 2712 if (IS_ERR(n))
2713 return PTR_ERR(n);
a7ff87ac 2714 neigh_event_send(n, NULL);
33b1341c
JP		 2715 }
2716 neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
2717 if (!neigh_entry) {
5c8802f1
IS		 2718 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
2719 if (IS_ERR(neigh_entry)) {
c53b8e1b
IS		 2720 err = -EINVAL;
2721 goto err_neigh_entry_create;
5c8802f1 2722 }
a7ff87ac 2723 }
b2157149
YG		 2724
2725 /* If that is the first nexthop connected to that neigh, add to
2726 * nexthop_neighs_list
2727 */
2728 if (list_empty(&neigh_entry->nexthop_list))
2729 list_add_tail(&neigh_entry->nexthop_neighs_list_node,
9011b677 2730 &mlxsw_sp->router->nexthop_neighs_list);
b2157149 2731
a7ff87ac
JP		 2732 nh->neigh_entry = neigh_entry;
2733 list_add_tail(&nh->neigh_list_node, &neigh_entry->nexthop_list);
2734 read_lock_bh(&n->lock);
2735 nud_state = n->nud_state;
93a87e5e 2736 dead = n->dead;
a7ff87ac 2737 read_unlock_bh(&n->lock);
93a87e5e 2738 __mlxsw_sp_nexthop_neigh_update(nh, !(nud_state & NUD_VALID && !dead));
a7ff87ac
JP		 2739
2740 return 0;
c53b8e1b
IS		 2741
2742err_neigh_entry_create:
2743 neigh_release(n);
c53b8e1b 2744 return err;
a7ff87ac
JP		 2745}
2746
a8c97014
IS		 2747static void mlxsw_sp_nexthop_neigh_fini(struct mlxsw_sp *mlxsw_sp,
2748 struct mlxsw_sp_nexthop *nh)
a7ff87ac
JP		 2749{
2750 struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
a8c97014 2751 struct neighbour *n;
a7ff87ac 2752
b8399a1e 2753 if (!neigh_entry)
a8c97014
IS		 2754 return;
2755 n = neigh_entry->key.n;
b8399a1e 2756
58312125 2757 __mlxsw_sp_nexthop_neigh_update(nh, true);
a7ff87ac 2758 list_del(&nh->neigh_list_node);
e58be79e 2759 nh->neigh_entry = NULL;
b2157149
YG		 2760
2761 /* If that is the last nexthop connected to that neigh, remove from
2762 * nexthop_neighs_list
2763 */
e58be79e
IS		 2764 if (list_empty(&neigh_entry->nexthop_list))
2765 list_del(&neigh_entry->nexthop_neighs_list_node);
b2157149 2766
5c8802f1
IS		 2767 if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
2768 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
2769
2770 neigh_release(n);
a8c97014 2771}
c53b8e1b 2772
6ddb7426
PM		 2773static bool mlxsw_sp_netdev_ipip_type(const struct mlxsw_sp *mlxsw_sp,
2774 const struct net_device *dev,
2775 enum mlxsw_sp_ipip_type *p_type)
2776{
2777 struct mlxsw_sp_router *router = mlxsw_sp->router;
2778 const struct mlxsw_sp_ipip_ops *ipip_ops;
2779 enum mlxsw_sp_ipip_type ipipt;
2780
2781 for (ipipt = 0; ipipt < MLXSW_SP_IPIP_TYPE_MAX; ++ipipt) {
2782 ipip_ops = router->ipip_ops_arr[ipipt];
2783 if (dev->type == ipip_ops->dev_type) {
2784 if (p_type)
2785 *p_type = ipipt;
2786 return true;
2787 }
2788 }
2789 return false;
2790}
2791
1012b9ac
PM		 2792static int mlxsw_sp_nexthop_ipip_init(struct mlxsw_sp *mlxsw_sp,
2793 enum mlxsw_sp_ipip_type ipipt,
2794 struct mlxsw_sp_nexthop *nh,
2795 struct net_device *ol_dev)
2796{
2797 if (!nh->nh_grp->gateway || nh->ipip_entry)
2798 return 0;
2799
2800 nh->ipip_entry = mlxsw_sp_ipip_entry_get(mlxsw_sp, ipipt, ol_dev);
2801 if (IS_ERR(nh->ipip_entry))
2802 return PTR_ERR(nh->ipip_entry);
2803
2804 __mlxsw_sp_nexthop_neigh_update(nh, false);
2805 return 0;
2806}
2807
2808static void mlxsw_sp_nexthop_ipip_fini(struct mlxsw_sp *mlxsw_sp,
2809 struct mlxsw_sp_nexthop *nh)
2810{
2811 struct mlxsw_sp_ipip_entry *ipip_entry = nh->ipip_entry;
2812
2813 if (!ipip_entry)
2814 return;
2815
2816 __mlxsw_sp_nexthop_neigh_update(nh, true);
2817 mlxsw_sp_ipip_entry_put(mlxsw_sp, ipip_entry);
2818 nh->ipip_entry = NULL;
2819}
2820
2821static bool mlxsw_sp_nexthop4_ipip_type(const struct mlxsw_sp *mlxsw_sp,
2822 const struct fib_nh *fib_nh,
2823 enum mlxsw_sp_ipip_type *p_ipipt)
2824{
2825 struct net_device *dev = fib_nh->nh_dev;
2826
2827 return dev &&
2828 fib_nh->nh_parent->fib_type == RTN_UNICAST &&
2829 mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, p_ipipt);
2830}
2831
35225e47
PM		 2832static void mlxsw_sp_nexthop_type_fini(struct mlxsw_sp *mlxsw_sp,
2833 struct mlxsw_sp_nexthop *nh)
2834{
2835 switch (nh->type) {
2836 case MLXSW_SP_NEXTHOP_TYPE_ETH:
2837 mlxsw_sp_nexthop_neigh_fini(mlxsw_sp, nh);
2838 mlxsw_sp_nexthop_rif_fini(nh);
2839 break;
1012b9ac
PM		 2840 case MLXSW_SP_NEXTHOP_TYPE_IPIP:
2841 mlxsw_sp_nexthop_ipip_fini(mlxsw_sp, nh);
2842 break;
35225e47
PM		 2843 }
2844}
2845
2846static int mlxsw_sp_nexthop4_type_init(struct mlxsw_sp *mlxsw_sp,
2847 struct mlxsw_sp_nexthop *nh,
2848 struct fib_nh *fib_nh)
2849{
1012b9ac 2850 struct mlxsw_sp_router *router = mlxsw_sp->router;
35225e47 2851 struct net_device *dev = fib_nh->nh_dev;
1012b9ac 2852 enum mlxsw_sp_ipip_type ipipt;
35225e47
PM		 2853 struct mlxsw_sp_rif *rif;
2854 int err;
2855
1012b9ac
PM		 2856 if (mlxsw_sp_nexthop4_ipip_type(mlxsw_sp, fib_nh, &ipipt) &&
2857 router->ipip_ops_arr[ipipt]->can_offload(mlxsw_sp, dev,
2858 MLXSW_SP_L3_PROTO_IPV4)) {
2859 nh->type = MLXSW_SP_NEXTHOP_TYPE_IPIP;
2860 return mlxsw_sp_nexthop_ipip_init(mlxsw_sp, ipipt, nh, dev);
2861 }
2862
35225e47
PM		 2863 nh->type = MLXSW_SP_NEXTHOP_TYPE_ETH;
2864 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
2865 if (!rif)
2866 return 0;
2867
2868 mlxsw_sp_nexthop_rif_init(nh, rif);
2869 err = mlxsw_sp_nexthop_neigh_init(mlxsw_sp, nh);
2870 if (err)
2871 goto err_neigh_init;
2872
2873 return 0;
2874
2875err_neigh_init:
2876 mlxsw_sp_nexthop_rif_fini(nh);
2877 return err;
2878}
2879
2880static void mlxsw_sp_nexthop4_type_fini(struct mlxsw_sp *mlxsw_sp,
2881 struct mlxsw_sp_nexthop *nh)
2882{
2883 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
2884}
2885
0e6ea2a4
IS		 2886static int mlxsw_sp_nexthop4_init(struct mlxsw_sp *mlxsw_sp,
2887 struct mlxsw_sp_nexthop_group *nh_grp,
2888 struct mlxsw_sp_nexthop *nh,
2889 struct fib_nh *fib_nh)
a8c97014
IS		 2890{
2891 struct net_device *dev = fib_nh->nh_dev;
df6dd79b 2892 struct in_device *in_dev;
a8c97014
IS		 2893 int err;
2894
2895 nh->nh_grp = nh_grp;
2896 nh->key.fib_nh = fib_nh;
58adf2c4 2897 memcpy(&nh->gw_addr, &fib_nh->nh_gw, sizeof(fib_nh->nh_gw));
a8c97014
IS		 2898 err = mlxsw_sp_nexthop_insert(mlxsw_sp, nh);
2899 if (err)
2900 return err;
2901
a5390278 2902 mlxsw_sp_nexthop_counter_alloc(mlxsw_sp, nh);
dbe4598c
AS		 2903 list_add_tail(&nh->router_list_node, &mlxsw_sp->router->nexthop_list);
2904
97989ee0
IS		 2905 if (!dev)
2906 return 0;
2907
df6dd79b
IS		 2908 in_dev = __in_dev_get_rtnl(dev);
2909 if (in_dev && IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
2910 fib_nh->nh_flags & RTNH_F_LINKDOWN)
2911 return 0;
2912
35225e47 2913 err = mlxsw_sp_nexthop4_type_init(mlxsw_sp, nh, fib_nh);
a8c97014
IS		 2914 if (err)
2915 goto err_nexthop_neigh_init;
2916
2917 return 0;
2918
2919err_nexthop_neigh_init:
2920 mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
2921 return err;
2922}
2923
0e6ea2a4
IS		 2924static void mlxsw_sp_nexthop4_fini(struct mlxsw_sp *mlxsw_sp,
2925 struct mlxsw_sp_nexthop *nh)
a8c97014 2926{
35225e47 2927 mlxsw_sp_nexthop4_type_fini(mlxsw_sp, nh);
dbe4598c 2928 list_del(&nh->router_list_node);
a5390278 2929 mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
c53b8e1b 2930 mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
a7ff87ac
JP		 2931}
2932
0e6ea2a4
IS		 2933static void mlxsw_sp_nexthop4_event(struct mlxsw_sp *mlxsw_sp,
2934 unsigned long event, struct fib_nh *fib_nh)
ad178c8e
IS		 2935{
2936 struct mlxsw_sp_nexthop_key key;
2937 struct mlxsw_sp_nexthop *nh;
ad178c8e 2938
9011b677 2939 if (mlxsw_sp->router->aborted)
ad178c8e
IS		 2940 return;
2941
2942 key.fib_nh = fib_nh;
2943 nh = mlxsw_sp_nexthop_lookup(mlxsw_sp, key);
2944 if (WARN_ON_ONCE(!nh))
2945 return;
2946
ad178c8e
IS		 2947 switch (event) {
2948 case FIB_EVENT_NH_ADD:
35225e47 2949 mlxsw_sp_nexthop4_type_init(mlxsw_sp, nh, fib_nh);
ad178c8e
IS		 2950 break;
2951 case FIB_EVENT_NH_DEL:
35225e47 2952 mlxsw_sp_nexthop4_type_fini(mlxsw_sp, nh);
ad178c8e
IS		 2953 break;
2954 }
2955
2956 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
2957}
2958
9665b745 2959static void mlxsw_sp_nexthop_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
bf95233e 2960 struct mlxsw_sp_rif *rif)
9665b745
IS		 2961{
2962 struct mlxsw_sp_nexthop *nh, *tmp;
2963
bf95233e 2964 list_for_each_entry_safe(nh, tmp, &rif->nexthop_list, rif_list_node) {
35225e47 2965 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
9665b745
IS		 2966 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
2967 }
2968}
2969
9b01451a
PM		 2970static bool mlxsw_sp_fi_is_gateway(const struct mlxsw_sp *mlxsw_sp,
2971 const struct fib_info *fi)
2972{
1012b9ac
PM		 2973 return fi->fib_nh->nh_scope == RT_SCOPE_LINK ||
2974 mlxsw_sp_nexthop4_ipip_type(mlxsw_sp, fi->fib_nh, NULL);
9b01451a
PM		 2975}
2976
a7ff87ac 2977static struct mlxsw_sp_nexthop_group *
0e6ea2a4 2978mlxsw_sp_nexthop4_group_create(struct mlxsw_sp *mlxsw_sp, struct fib_info *fi)
a7ff87ac
JP		 2979{
2980 struct mlxsw_sp_nexthop_group *nh_grp;
2981 struct mlxsw_sp_nexthop *nh;
2982 struct fib_nh *fib_nh;
2983 size_t alloc_size;
2984 int i;
2985 int err;
2986
2987 alloc_size = sizeof(*nh_grp) +
2988 fi->fib_nhs * sizeof(struct mlxsw_sp_nexthop);
2989 nh_grp = kzalloc(alloc_size, GFP_KERNEL);
2990 if (!nh_grp)
2991 return ERR_PTR(-ENOMEM);
ba31d366 2992 nh_grp->priv = fi;
a7ff87ac 2993 INIT_LIST_HEAD(&nh_grp->fib_list);
58adf2c4
IS		 2994 nh_grp->neigh_tbl = &arp_tbl;
2995
9b01451a 2996 nh_grp->gateway = mlxsw_sp_fi_is_gateway(mlxsw_sp, fi);
a7ff87ac 2997 nh_grp->count = fi->fib_nhs;
7387dbbc 2998 fib_info_hold(fi);
a7ff87ac
JP		 2999 for (i = 0; i < nh_grp->count; i++) {
3000 nh = &nh_grp->nexthops[i];
3001 fib_nh = &fi->fib_nh[i];
0e6ea2a4 3002 err = mlxsw_sp_nexthop4_init(mlxsw_sp, nh_grp, nh, fib_nh);
a7ff87ac 3003 if (err)
0e6ea2a4 3004 goto err_nexthop4_init;
a7ff87ac 3005 }
e9ad5e7d
IS		 3006 err = mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
3007 if (err)
3008 goto err_nexthop_group_insert;
a7ff87ac
JP		 3009 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
3010 return nh_grp;
3011
e9ad5e7d 3012err_nexthop_group_insert:
0e6ea2a4 3013err_nexthop4_init:
df6dd79b
IS		 3014 for (i--; i >= 0; i--) {
3015 nh = &nh_grp->nexthops[i];
0e6ea2a4 3016 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
df6dd79b 3017 }
ba31d366 3018 fib_info_put(fi);
a7ff87ac
JP		 3019 kfree(nh_grp);
3020 return ERR_PTR(err);
3021}
3022
3023static void
0e6ea2a4
IS		 3024mlxsw_sp_nexthop4_group_destroy(struct mlxsw_sp *mlxsw_sp,
3025 struct mlxsw_sp_nexthop_group *nh_grp)
a7ff87ac
JP		 3026{
3027 struct mlxsw_sp_nexthop *nh;
3028 int i;
3029
e9ad5e7d 3030 mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
a7ff87ac
JP		 3031 for (i = 0; i < nh_grp->count; i++) {
3032 nh = &nh_grp->nexthops[i];
0e6ea2a4 3033 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
a7ff87ac 3034 }
58312125
IS		 3035 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
3036 WARN_ON_ONCE(nh_grp->adj_index_valid);
ba31d366 3037 fib_info_put(mlxsw_sp_nexthop4_group_fi(nh_grp));
a7ff87ac
JP		 3038 kfree(nh_grp);
3039}
3040
0e6ea2a4
IS		 3041static int mlxsw_sp_nexthop4_group_get(struct mlxsw_sp *mlxsw_sp,
3042 struct mlxsw_sp_fib_entry *fib_entry,
3043 struct fib_info *fi)
a7ff87ac
JP		 3044{
3045 struct mlxsw_sp_nexthop_group *nh_grp;
3046
ba31d366 3047 nh_grp = mlxsw_sp_nexthop4_group_lookup(mlxsw_sp, fi);
a7ff87ac 3048 if (!nh_grp) {
0e6ea2a4 3049 nh_grp = mlxsw_sp_nexthop4_group_create(mlxsw_sp, fi);
a7ff87ac
JP		 3050 if (IS_ERR(nh_grp))
3051 return PTR_ERR(nh_grp);
3052 }
3053 list_add_tail(&fib_entry->nexthop_group_node, &nh_grp->fib_list);
3054 fib_entry->nh_group = nh_grp;
3055 return 0;
3056}
3057
0e6ea2a4
IS		 3058static void mlxsw_sp_nexthop4_group_put(struct mlxsw_sp *mlxsw_sp,
3059 struct mlxsw_sp_fib_entry *fib_entry)
a7ff87ac
JP		 3060{
3061 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
3062
3063 list_del(&fib_entry->nexthop_group_node);
3064 if (!list_empty(&nh_grp->fib_list))
3065 return;
0e6ea2a4 3066 mlxsw_sp_nexthop4_group_destroy(mlxsw_sp, nh_grp);
a7ff87ac
JP		 3067}
3068
4f1c7f1f
IS		 3069static bool
3070mlxsw_sp_fib4_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
3071{
3072 struct mlxsw_sp_fib4_entry *fib4_entry;
3073
3074 fib4_entry = container_of(fib_entry, struct mlxsw_sp_fib4_entry,
3075 common);
3076 return !fib4_entry->tos;
3077}
3078
013b20f9
IS		 3079static bool
3080mlxsw_sp_fib_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
3081{
3082 struct mlxsw_sp_nexthop_group *nh_group = fib_entry->nh_group;
3083
4f1c7f1f
IS		 3084 switch (fib_entry->fib_node->fib->proto) {
3085 case MLXSW_SP_L3_PROTO_IPV4:
3086 if (!mlxsw_sp_fib4_entry_should_offload(fib_entry))
3087 return false;
3088 break;
3089 case MLXSW_SP_L3_PROTO_IPV6:
3090 break;
3091 }
9aecce1c 3092
013b20f9
IS		 3093 switch (fib_entry->type) {
3094 case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
3095 return !!nh_group->adj_index_valid;
3096 case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
70ad3506 3097 return !!nh_group->nh_rif;
4607f6d2
PM		 3098 case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
3099 return true;
013b20f9
IS		 3100 default:
3101 return false;
3102 }
3103}
3104
428b851f
IS		 3105static struct mlxsw_sp_nexthop *
3106mlxsw_sp_rt6_nexthop(struct mlxsw_sp_nexthop_group *nh_grp,
3107 const struct mlxsw_sp_rt6 *mlxsw_sp_rt6)
3108{
3109 int i;
3110
3111 for (i = 0; i < nh_grp->count; i++) {
3112 struct mlxsw_sp_nexthop *nh = &nh_grp->nexthops[i];
3113 struct rt6_info *rt = mlxsw_sp_rt6->rt;
3114
3115 if (nh->rif && nh->rif->dev == rt->dst.dev &&
3116 ipv6_addr_equal((const struct in6_addr *) &nh->gw_addr,
3117 &rt->rt6i_gateway))
3118 return nh;
3119 continue;
3120 }
3121
3122 return NULL;
3123}
3124
3984d1a8
IS		 3125static void
3126mlxsw_sp_fib4_entry_offload_set(struct mlxsw_sp_fib_entry *fib_entry)
3127{
3128 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
3129 int i;
3130
4607f6d2
PM		 3131 if (fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_LOCAL ||
3132 fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP) {
3984d1a8
IS		 3133 nh_grp->nexthops->key.fib_nh->nh_flags |= RTNH_F_OFFLOAD;
3134 return;
3135 }
3136
3137 for (i = 0; i < nh_grp->count; i++) {
3138 struct mlxsw_sp_nexthop *nh = &nh_grp->nexthops[i];
3139
3140 if (nh->offloaded)
3141 nh->key.fib_nh->nh_flags |= RTNH_F_OFFLOAD;
3142 else
3143 nh->key.fib_nh->nh_flags &= ~RTNH_F_OFFLOAD;
3144 }
3145}
3146
3147static void
3148mlxsw_sp_fib4_entry_offload_unset(struct mlxsw_sp_fib_entry *fib_entry)
3149{
3150 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
3151 int i;
3152
3153 for (i = 0; i < nh_grp->count; i++) {
3154 struct mlxsw_sp_nexthop *nh = &nh_grp->nexthops[i];
3155
3156 nh->key.fib_nh->nh_flags &= ~RTNH_F_OFFLOAD;
3157 }
3158}
3159
428b851f
IS		 3160static void
3161mlxsw_sp_fib6_entry_offload_set(struct mlxsw_sp_fib_entry *fib_entry)
3162{
3163 struct mlxsw_sp_fib6_entry *fib6_entry;
3164 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3165
3166 fib6_entry = container_of(fib_entry, struct mlxsw_sp_fib6_entry,
3167 common);
3168
3169 if (fib_entry->type == MLXSW_SP_FIB_ENTRY_TYPE_LOCAL) {
3170 list_first_entry(&fib6_entry->rt6_list, struct mlxsw_sp_rt6,
fe400799 3171 list)->rt->rt6i_nh_flags |= RTNH_F_OFFLOAD;
428b851f
IS		 3172 return;
3173 }
3174
3175 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
3176 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
3177 struct mlxsw_sp_nexthop *nh;
3178
3179 nh = mlxsw_sp_rt6_nexthop(nh_grp, mlxsw_sp_rt6);
3180 if (nh && nh->offloaded)
fe400799 3181 mlxsw_sp_rt6->rt->rt6i_nh_flags |= RTNH_F_OFFLOAD;
428b851f 3182 else
fe400799 3183 mlxsw_sp_rt6->rt->rt6i_nh_flags &= ~RTNH_F_OFFLOAD;
428b851f
IS		 3184 }
3185}
3186
3187static void
3188mlxsw_sp_fib6_entry_offload_unset(struct mlxsw_sp_fib_entry *fib_entry)
3189{
3190 struct mlxsw_sp_fib6_entry *fib6_entry;
3191 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
3192
3193 fib6_entry = container_of(fib_entry, struct mlxsw_sp_fib6_entry,
3194 common);
3195 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
3196 struct rt6_info *rt = mlxsw_sp_rt6->rt;
3197
fe400799 3198 rt->rt6i_nh_flags &= ~RTNH_F_OFFLOAD;
428b851f
IS		 3199 }
3200}
3201
013b20f9
IS		 3202static void mlxsw_sp_fib_entry_offload_set(struct mlxsw_sp_fib_entry *fib_entry)
3203{
76610ebb 3204 switch (fib_entry->fib_node->fib->proto) {
013b20f9 3205 case MLXSW_SP_L3_PROTO_IPV4:
3984d1a8 3206 mlxsw_sp_fib4_entry_offload_set(fib_entry);
013b20f9
IS		 3207 break;
3208 case MLXSW_SP_L3_PROTO_IPV6:
428b851f
IS		 3209 mlxsw_sp_fib6_entry_offload_set(fib_entry);
3210 break;
013b20f9
IS		 3211 }
3212}
3213
3214static void
3215mlxsw_sp_fib_entry_offload_unset(struct mlxsw_sp_fib_entry *fib_entry)
3216{
76610ebb 3217 switch (fib_entry->fib_node->fib->proto) {
013b20f9 3218 case MLXSW_SP_L3_PROTO_IPV4:
3984d1a8 3219 mlxsw_sp_fib4_entry_offload_unset(fib_entry);
013b20f9
IS		 3220 break;
3221 case MLXSW_SP_L3_PROTO_IPV6:
428b851f
IS		 3222 mlxsw_sp_fib6_entry_offload_unset(fib_entry);
3223 break;
013b20f9 3224 }
013b20f9
IS		 3225}
3226
3227static void
3228mlxsw_sp_fib_entry_offload_refresh(struct mlxsw_sp_fib_entry *fib_entry,
3229 enum mlxsw_reg_ralue_op op, int err)
3230{
3231 switch (op) {
3232 case MLXSW_REG_RALUE_OP_WRITE_DELETE:
013b20f9
IS		 3233 return mlxsw_sp_fib_entry_offload_unset(fib_entry);
3234 case MLXSW_REG_RALUE_OP_WRITE_WRITE:
3235 if (err)
3236 return;
1353ee70 3237 if (mlxsw_sp_fib_entry_should_offload(fib_entry))
013b20f9 3238 mlxsw_sp_fib_entry_offload_set(fib_entry);
1353ee70 3239 else if (!mlxsw_sp_fib_entry_should_offload(fib_entry))
013b20f9
IS		 3240 mlxsw_sp_fib_entry_offload_unset(fib_entry);
3241 return;
3242 default:
3243 return;
3244 }
3245}
3246
9dbf4d76
IS		 3247static void
3248mlxsw_sp_fib_entry_ralue_pack(char *ralue_pl,
3249 const struct mlxsw_sp_fib_entry *fib_entry,
3250 enum mlxsw_reg_ralue_op op)
a7ff87ac 3251{
76610ebb 3252 struct mlxsw_sp_fib *fib = fib_entry->fib_node->fib;
9dbf4d76
IS		 3253 enum mlxsw_reg_ralxx_protocol proto;
3254 u32 *p_dip;
3255
3256 proto = (enum mlxsw_reg_ralxx_protocol) fib->proto;
3257
3258 switch (fib->proto) {
3259 case MLXSW_SP_L3_PROTO_IPV4:
3260 p_dip = (u32 *) fib_entry->fib_node->key.addr;
3261 mlxsw_reg_ralue_pack4(ralue_pl, proto, op, fib->vr->id,
3262 fib_entry->fib_node->key.prefix_len,
3263 *p_dip);
3264 break;
3265 case MLXSW_SP_L3_PROTO_IPV6:
3266 mlxsw_reg_ralue_pack6(ralue_pl, proto, op, fib->vr->id,
3267 fib_entry->fib_node->key.prefix_len,
3268 fib_entry->fib_node->key.addr);
3269 break;
3270 }
3271}
3272
3273static int mlxsw_sp_fib_entry_op_remote(struct mlxsw_sp *mlxsw_sp,
3274 struct mlxsw_sp_fib_entry *fib_entry,
3275 enum mlxsw_reg_ralue_op op)
3276{
3277 char ralue_pl[MLXSW_REG_RALUE_LEN];
a7ff87ac
JP		 3278 enum mlxsw_reg_ralue_trap_action trap_action;
3279 u16 trap_id = 0;
3280 u32 adjacency_index = 0;
3281 u16 ecmp_size = 0;
3282
3283 /* In case the nexthop group adjacency index is valid, use it
3284 * with provided ECMP size. Otherwise, setup trap and pass
3285 * traffic to kernel.
3286 */
4b411477 3287 if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
a7ff87ac
JP		 3288 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
3289 adjacency_index = fib_entry->nh_group->adj_index;
3290 ecmp_size = fib_entry->nh_group->ecmp_size;
3291 } else {
3292 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
3293 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
3294 }
3295
9dbf4d76 3296 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
a7ff87ac
JP		 3297 mlxsw_reg_ralue_act_remote_pack(ralue_pl, trap_action, trap_id,
3298 adjacency_index, ecmp_size);
3299 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
3300}
3301
9dbf4d76
IS		 3302static int mlxsw_sp_fib_entry_op_local(struct mlxsw_sp *mlxsw_sp,
3303 struct mlxsw_sp_fib_entry *fib_entry,
3304 enum mlxsw_reg_ralue_op op)
61c503f9 3305{
bf95233e 3306 struct mlxsw_sp_rif *rif = fib_entry->nh_group->nh_rif;
70ad3506 3307 enum mlxsw_reg_ralue_trap_action trap_action;
61c503f9 3308 char ralue_pl[MLXSW_REG_RALUE_LEN];
70ad3506 3309 u16 trap_id = 0;
bf95233e 3310 u16 rif_index = 0;
70ad3506
IS		 3311
3312 if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
3313 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
bf95233e 3314 rif_index = rif->rif_index;
70ad3506
IS		 3315 } else {
3316 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
3317 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
3318 }
61c503f9 3319
9dbf4d76 3320 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
bf95233e
AS		 3321 mlxsw_reg_ralue_act_local_pack(ralue_pl, trap_action, trap_id,
3322 rif_index);
61c503f9
JP		 3323 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
3324}
3325
9dbf4d76
IS		 3326static int mlxsw_sp_fib_entry_op_trap(struct mlxsw_sp *mlxsw_sp,
3327 struct mlxsw_sp_fib_entry *fib_entry,
3328 enum mlxsw_reg_ralue_op op)
61c503f9
JP		 3329{
3330 char ralue_pl[MLXSW_REG_RALUE_LEN];
61c503f9 3331
9dbf4d76 3332 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
61c503f9
JP		 3333 mlxsw_reg_ralue_act_ip2me_pack(ralue_pl);
3334 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
3335}
3336
4607f6d2
PM		 3337static int
3338mlxsw_sp_fib_entry_op_ipip_decap(struct mlxsw_sp *mlxsw_sp,
3339 struct mlxsw_sp_fib_entry *fib_entry,
3340 enum mlxsw_reg_ralue_op op)
3341{
3342 struct mlxsw_sp_ipip_entry *ipip_entry = fib_entry->decap.ipip_entry;
3343 const struct mlxsw_sp_ipip_ops *ipip_ops;
3344
3345 if (WARN_ON(!ipip_entry))
3346 return -EINVAL;
3347
3348 ipip_ops = mlxsw_sp->router->ipip_ops_arr[ipip_entry->ipipt];
3349 return ipip_ops->fib_entry_op(mlxsw_sp, ipip_entry, op,
3350 fib_entry->decap.tunnel_index);
3351}
3352
9dbf4d76
IS		 3353static int __mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
3354 struct mlxsw_sp_fib_entry *fib_entry,
3355 enum mlxsw_reg_ralue_op op)
61c503f9
JP		 3356{
3357 switch (fib_entry->type) {
3358 case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
9dbf4d76 3359 return mlxsw_sp_fib_entry_op_remote(mlxsw_sp, fib_entry, op);
61c503f9 3360 case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
9dbf4d76 3361 return mlxsw_sp_fib_entry_op_local(mlxsw_sp, fib_entry, op);
61c503f9 3362 case MLXSW_SP_FIB_ENTRY_TYPE_TRAP:
9dbf4d76 3363 return mlxsw_sp_fib_entry_op_trap(mlxsw_sp, fib_entry, op);
4607f6d2
PM		 3364 case MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP:
3365 return mlxsw_sp_fib_entry_op_ipip_decap(mlxsw_sp,
3366 fib_entry, op);
61c503f9
JP		 3367 }
3368 return -EINVAL;
3369}
3370
3371static int mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
3372 struct mlxsw_sp_fib_entry *fib_entry,
3373 enum mlxsw_reg_ralue_op op)
3374{
9dbf4d76 3375 int err = __mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry, op);
013b20f9 3376
013b20f9 3377 mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, err);
9dbf4d76 3378
013b20f9 3379 return err;
61c503f9
JP		 3380}
3381
3382static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
3383 struct mlxsw_sp_fib_entry *fib_entry)
3384{
7146da31
JP		 3385 return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
3386 MLXSW_REG_RALUE_OP_WRITE_WRITE);
61c503f9
JP		 3387}
3388
3389static int mlxsw_sp_fib_entry_del(struct mlxsw_sp *mlxsw_sp,
3390 struct mlxsw_sp_fib_entry *fib_entry)
3391{
3392 return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
3393 MLXSW_REG_RALUE_OP_WRITE_DELETE);
3394}
3395
61c503f9 3396static int
013b20f9
IS		 3397mlxsw_sp_fib4_entry_type_set(struct mlxsw_sp *mlxsw_sp,
3398 const struct fib_entry_notifier_info *fen_info,
3399 struct mlxsw_sp_fib_entry *fib_entry)
61c503f9 3400{
4607f6d2
PM		 3401 union mlxsw_sp_l3addr dip = { .addr4 = htonl(fen_info->dst) };
3402 struct net_device *dev = fen_info->fi->fib_dev;
3403 struct mlxsw_sp_ipip_entry *ipip_entry;
b45f64d1 3404 struct fib_info *fi = fen_info->fi;
61c503f9 3405
97989ee0 3406 switch (fen_info->type) {
97989ee0 3407 case RTN_LOCAL:
4607f6d2
PM		 3408 ipip_entry = mlxsw_sp_ipip_entry_find_by_decap(mlxsw_sp, dev,
3409 MLXSW_SP_L3_PROTO_IPV4, dip);
3410 if (ipip_entry) {
3411 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP;
3412 return mlxsw_sp_fib_entry_decap_init(mlxsw_sp,
3413 fib_entry,
3414 ipip_entry);
3415 }
3416 /* fall through */
3417 case RTN_BROADCAST:
61c503f9
JP		 3418 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
3419 return 0;
97989ee0
IS		 3420 case RTN_UNREACHABLE: /* fall through */
3421 case RTN_BLACKHOLE: /* fall through */
3422 case RTN_PROHIBIT:
3423 /* Packets hitting these routes need to be trapped, but
3424 * can do so with a lower priority than packets directed
3425 * at the host, so use action type local instead of trap.
3426 */
61c503f9 3427 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
97989ee0
IS		 3428 return 0;
3429 case RTN_UNICAST:
9b01451a 3430 if (mlxsw_sp_fi_is_gateway(mlxsw_sp, fi))
97989ee0 3431 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE;
9b01451a
PM		 3432 else
3433 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
97989ee0
IS		 3434 return 0;
3435 default:
3436 return -EINVAL;
3437 }
a7ff87ac
JP		 3438}
3439
4f1c7f1f 3440static struct mlxsw_sp_fib4_entry *
9aecce1c
IS		 3441mlxsw_sp_fib4_entry_create(struct mlxsw_sp *mlxsw_sp,
3442 struct mlxsw_sp_fib_node *fib_node,
3443 const struct fib_entry_notifier_info *fen_info)
61c503f9 3444{
4f1c7f1f 3445 struct mlxsw_sp_fib4_entry *fib4_entry;
61c503f9 3446 struct mlxsw_sp_fib_entry *fib_entry;
61c503f9
JP		 3447 int err;
3448
4f1c7f1f
IS		 3449 fib4_entry = kzalloc(sizeof(*fib4_entry), GFP_KERNEL);
3450 if (!fib4_entry)
3451 return ERR_PTR(-ENOMEM);
3452 fib_entry = &fib4_entry->common;
61c503f9 3453
013b20f9 3454 err = mlxsw_sp_fib4_entry_type_set(mlxsw_sp, fen_info, fib_entry);
61c503f9 3455 if (err)
013b20f9 3456 goto err_fib4_entry_type_set;
61c503f9 3457
0e6ea2a4 3458 err = mlxsw_sp_nexthop4_group_get(mlxsw_sp, fib_entry, fen_info->fi);
b8399a1e 3459 if (err)
0e6ea2a4 3460 goto err_nexthop4_group_get;
b8399a1e 3461
4f1c7f1f
IS		 3462 fib4_entry->prio = fen_info->fi->fib_priority;
3463 fib4_entry->tb_id = fen_info->tb_id;
3464 fib4_entry->type = fen_info->type;
3465 fib4_entry->tos = fen_info->tos;
9aecce1c
IS		 3466
3467 fib_entry->fib_node = fib_node;
3468
4f1c7f1f 3469 return fib4_entry;
5b004412 3470
0e6ea2a4 3471err_nexthop4_group_get:
013b20f9 3472err_fib4_entry_type_set:
4f1c7f1f 3473 kfree(fib4_entry);
5b004412
JP		 3474 return ERR_PTR(err);
3475}
3476
9aecce1c 3477static void mlxsw_sp_fib4_entry_destroy(struct mlxsw_sp *mlxsw_sp,
4f1c7f1f 3478 struct mlxsw_sp_fib4_entry *fib4_entry)
9aecce1c 3479{
0e6ea2a4 3480 mlxsw_sp_nexthop4_group_put(mlxsw_sp, &fib4_entry->common);
4f1c7f1f 3481 kfree(fib4_entry);
9aecce1c
IS		 3482}
3483
4f1c7f1f 3484static struct mlxsw_sp_fib4_entry *
9aecce1c
IS		 3485mlxsw_sp_fib4_entry_lookup(struct mlxsw_sp *mlxsw_sp,
3486 const struct fib_entry_notifier_info *fen_info)
5b004412 3487{
4f1c7f1f 3488 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 3489 struct mlxsw_sp_fib_node *fib_node;
160e22aa
IS		 3490 struct mlxsw_sp_fib *fib;
3491 struct mlxsw_sp_vr *vr;
3492
3493 vr = mlxsw_sp_vr_find(mlxsw_sp, fen_info->tb_id);
3494 if (!vr)
3495 return NULL;
3496 fib = mlxsw_sp_vr_fib(vr, MLXSW_SP_L3_PROTO_IPV4);
5b004412 3497
160e22aa
IS		 3498 fib_node = mlxsw_sp_fib_node_lookup(fib, &fen_info->dst,
3499 sizeof(fen_info->dst),
3500 fen_info->dst_len);
3501 if (!fib_node)
9aecce1c
IS		 3502 return NULL;
3503
4f1c7f1f
IS		 3504 list_for_each_entry(fib4_entry, &fib_node->entry_list, common.list) {
3505 if (fib4_entry->tb_id == fen_info->tb_id &&
3506 fib4_entry->tos == fen_info->tos &&
3507 fib4_entry->type == fen_info->type &&
ba31d366
AS		 3508 mlxsw_sp_nexthop4_group_fi(fib4_entry->common.nh_group) ==
3509 fen_info->fi) {
4f1c7f1f 3510 return fib4_entry;
9aecce1c
IS		 3511 }
3512 }
3513
3514 return NULL;
3515}
3516
3517static const struct rhashtable_params mlxsw_sp_fib_ht_params = {
3518 .key_offset = offsetof(struct mlxsw_sp_fib_node, key),
3519 .head_offset = offsetof(struct mlxsw_sp_fib_node, ht_node),
3520 .key_len = sizeof(struct mlxsw_sp_fib_key),
3521 .automatic_shrinking = true,
3522};
3523
3524static int mlxsw_sp_fib_node_insert(struct mlxsw_sp_fib *fib,
3525 struct mlxsw_sp_fib_node *fib_node)
3526{
3527 return rhashtable_insert_fast(&fib->ht, &fib_node->ht_node,
3528 mlxsw_sp_fib_ht_params);
3529}
3530
3531static void mlxsw_sp_fib_node_remove(struct mlxsw_sp_fib *fib,
3532 struct mlxsw_sp_fib_node *fib_node)
3533{
3534 rhashtable_remove_fast(&fib->ht, &fib_node->ht_node,
3535 mlxsw_sp_fib_ht_params);
3536}
3537
3538static struct mlxsw_sp_fib_node *
3539mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
3540 size_t addr_len, unsigned char prefix_len)
3541{
3542 struct mlxsw_sp_fib_key key;
3543
3544 memset(&key, 0, sizeof(key));
3545 memcpy(key.addr, addr, addr_len);
3546 key.prefix_len = prefix_len;
3547 return rhashtable_lookup_fast(&fib->ht, &key, mlxsw_sp_fib_ht_params);
3548}
3549
3550static struct mlxsw_sp_fib_node *
76610ebb 3551mlxsw_sp_fib_node_create(struct mlxsw_sp_fib *fib, const void *addr,
9aecce1c
IS		 3552 size_t addr_len, unsigned char prefix_len)
3553{
3554 struct mlxsw_sp_fib_node *fib_node;
3555
3556 fib_node = kzalloc(sizeof(*fib_node), GFP_KERNEL);
3557 if (!fib_node)
5b004412
JP		 3558 return NULL;
3559
9aecce1c 3560 INIT_LIST_HEAD(&fib_node->entry_list);
76610ebb 3561 list_add(&fib_node->list, &fib->node_list);
9aecce1c
IS		 3562 memcpy(fib_node->key.addr, addr, addr_len);
3563 fib_node->key.prefix_len = prefix_len;
9aecce1c
IS		 3564
3565 return fib_node;
3566}
3567
3568static void mlxsw_sp_fib_node_destroy(struct mlxsw_sp_fib_node *fib_node)
3569{
9aecce1c
IS		 3570 list_del(&fib_node->list);
3571 WARN_ON(!list_empty(&fib_node->entry_list));
3572 kfree(fib_node);
3573}
3574
3575static bool
3576mlxsw_sp_fib_node_entry_is_first(const struct mlxsw_sp_fib_node *fib_node,
3577 const struct mlxsw_sp_fib_entry *fib_entry)
3578{
3579 return list_first_entry(&fib_node->entry_list,
3580 struct mlxsw_sp_fib_entry, list) == fib_entry;
3581}
3582
fc922bb0
IS		 3583static int mlxsw_sp_fib_lpm_tree_link(struct mlxsw_sp *mlxsw_sp,
3584 struct mlxsw_sp_fib *fib,
3585 struct mlxsw_sp_fib_node *fib_node)
3586{
3587 struct mlxsw_sp_prefix_usage req_prefix_usage = {{ 0 } };
3588 struct mlxsw_sp_lpm_tree *lpm_tree;
3589 int err;
3590
3591 /* Since the tree is shared between all virtual routers we must
3592 * make sure it contains all the required prefix lengths. This
3593 * can be computed by either adding the new prefix length to the
3594 * existing prefix usage of a bound tree, or by aggregating the
3595 * prefix lengths across all virtual routers and adding the new
3596 * one as well.
3597 */
3598 if (fib->lpm_tree)
3599 mlxsw_sp_prefix_usage_cpy(&req_prefix_usage,
3600 &fib->lpm_tree->prefix_usage);
3601 else
3602 mlxsw_sp_vrs_prefixes(mlxsw_sp, fib->proto, &req_prefix_usage);
3603 mlxsw_sp_prefix_usage_set(&req_prefix_usage, fib_node->key.prefix_len);
3604
3605 lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
3606 fib->proto);
3607 if (IS_ERR(lpm_tree))
3608 return PTR_ERR(lpm_tree);
3609
3610 if (fib->lpm_tree && fib->lpm_tree->id == lpm_tree->id)
3611 return 0;
3612
3613 err = mlxsw_sp_vrs_lpm_tree_replace(mlxsw_sp, fib, lpm_tree);
3614 if (err)
3615 return err;
3616
3617 return 0;
3618}
3619
3620static void mlxsw_sp_fib_lpm_tree_unlink(struct mlxsw_sp *mlxsw_sp,
3621 struct mlxsw_sp_fib *fib)
3622{
3623 struct mlxsw_sp_prefix_usage req_prefix_usage = {{ 0 } };
3624 struct mlxsw_sp_lpm_tree *lpm_tree;
3625
3626 /* Aggregate prefix lengths across all virtual routers to make
3627 * sure we only have used prefix lengths in the LPM tree.
3628 */
3629 mlxsw_sp_vrs_prefixes(mlxsw_sp, fib->proto, &req_prefix_usage);
3630 lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
3631 fib->proto);
3632 if (IS_ERR(lpm_tree))
3633 goto err_tree_get;
3634 mlxsw_sp_vrs_lpm_tree_replace(mlxsw_sp, fib, lpm_tree);
3635
3636err_tree_get:
3637 if (!mlxsw_sp_prefix_usage_none(&fib->prefix_usage))
3638 return;
3639 mlxsw_sp_vr_lpm_tree_unbind(mlxsw_sp, fib);
3640 mlxsw_sp_lpm_tree_put(mlxsw_sp, fib->lpm_tree);
3641 fib->lpm_tree = NULL;
3642}
3643
9aecce1c
IS		 3644static void mlxsw_sp_fib_node_prefix_inc(struct mlxsw_sp_fib_node *fib_node)
3645{
3646 unsigned char prefix_len = fib_node->key.prefix_len;
76610ebb 3647 struct mlxsw_sp_fib *fib = fib_node->fib;
9aecce1c
IS		 3648
3649 if (fib->prefix_ref_count[prefix_len]++ == 0)
3650 mlxsw_sp_prefix_usage_set(&fib->prefix_usage, prefix_len);
3651}
3652
3653static void mlxsw_sp_fib_node_prefix_dec(struct mlxsw_sp_fib_node *fib_node)
3654{
3655 unsigned char prefix_len = fib_node->key.prefix_len;
76610ebb 3656 struct mlxsw_sp_fib *fib = fib_node->fib;
9aecce1c
IS		 3657
3658 if (--fib->prefix_ref_count[prefix_len] == 0)
3659 mlxsw_sp_prefix_usage_clear(&fib->prefix_usage, prefix_len);
5b004412
JP		 3660}
3661
76610ebb
IS		 3662static int mlxsw_sp_fib_node_init(struct mlxsw_sp *mlxsw_sp,
3663 struct mlxsw_sp_fib_node *fib_node,
3664 struct mlxsw_sp_fib *fib)
3665{
76610ebb
IS		 3666 int err;
3667
3668 err = mlxsw_sp_fib_node_insert(fib, fib_node);
3669 if (err)
3670 return err;
3671 fib_node->fib = fib;
3672
fc922bb0
IS		 3673 err = mlxsw_sp_fib_lpm_tree_link(mlxsw_sp, fib, fib_node);
3674 if (err)
3675 goto err_fib_lpm_tree_link;
76610ebb
IS		 3676
3677 mlxsw_sp_fib_node_prefix_inc(fib_node);
3678
3679 return 0;
3680
fc922bb0 3681err_fib_lpm_tree_link:
76610ebb
IS		 3682 fib_node->fib = NULL;
3683 mlxsw_sp_fib_node_remove(fib, fib_node);
3684 return err;
3685}
3686
3687static void mlxsw_sp_fib_node_fini(struct mlxsw_sp *mlxsw_sp,
3688 struct mlxsw_sp_fib_node *fib_node)
3689{
76610ebb
IS		 3690 struct mlxsw_sp_fib *fib = fib_node->fib;
3691
3692 mlxsw_sp_fib_node_prefix_dec(fib_node);
fc922bb0 3693 mlxsw_sp_fib_lpm_tree_unlink(mlxsw_sp, fib);
76610ebb
IS		 3694 fib_node->fib = NULL;
3695 mlxsw_sp_fib_node_remove(fib, fib_node);
3696}
3697
9aecce1c 3698static struct mlxsw_sp_fib_node *
731ea1ca
IS		 3699mlxsw_sp_fib_node_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id, const void *addr,
3700 size_t addr_len, unsigned char prefix_len,
3701 enum mlxsw_sp_l3proto proto)
5b004412 3702{
9aecce1c 3703 struct mlxsw_sp_fib_node *fib_node;
76610ebb 3704 struct mlxsw_sp_fib *fib;
9aecce1c
IS		 3705 struct mlxsw_sp_vr *vr;
3706 int err;
3707
731ea1ca 3708 vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id);
9aecce1c
IS		 3709 if (IS_ERR(vr))
3710 return ERR_CAST(vr);
731ea1ca 3711 fib = mlxsw_sp_vr_fib(vr, proto);
9aecce1c 3712
731ea1ca 3713 fib_node = mlxsw_sp_fib_node_lookup(fib, addr, addr_len, prefix_len);
9aecce1c
IS		 3714 if (fib_node)
3715 return fib_node;
5b004412 3716
731ea1ca 3717 fib_node = mlxsw_sp_fib_node_create(fib, addr, addr_len, prefix_len);
9aecce1c
IS		 3718 if (!fib_node) {
3719 err = -ENOMEM;
3720 goto err_fib_node_create;
5b004412 3721 }
9aecce1c 3722
76610ebb
IS		 3723 err = mlxsw_sp_fib_node_init(mlxsw_sp, fib_node, fib);
3724 if (err)
3725 goto err_fib_node_init;
3726
9aecce1c
IS		 3727 return fib_node;
3728
76610ebb
IS		 3729err_fib_node_init:
3730 mlxsw_sp_fib_node_destroy(fib_node);
9aecce1c 3731err_fib_node_create:
76610ebb 3732 mlxsw_sp_vr_put(vr);
9aecce1c 3733 return ERR_PTR(err);
5b004412
JP		 3734}
3735
731ea1ca
IS		 3736static void mlxsw_sp_fib_node_put(struct mlxsw_sp *mlxsw_sp,
3737 struct mlxsw_sp_fib_node *fib_node)
5b004412 3738{
76610ebb 3739 struct mlxsw_sp_vr *vr = fib_node->fib->vr;
5b004412 3740
9aecce1c
IS		 3741 if (!list_empty(&fib_node->entry_list))
3742 return;
76610ebb 3743 mlxsw_sp_fib_node_fini(mlxsw_sp, fib_node);
9aecce1c 3744 mlxsw_sp_fib_node_destroy(fib_node);
76610ebb 3745 mlxsw_sp_vr_put(vr);
61c503f9
JP		 3746}
3747
4f1c7f1f 3748static struct mlxsw_sp_fib4_entry *
9aecce1c 3749mlxsw_sp_fib4_node_entry_find(const struct mlxsw_sp_fib_node *fib_node,
4f1c7f1f 3750 const struct mlxsw_sp_fib4_entry *new4_entry)
61c503f9 3751{
4f1c7f1f 3752 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 3753
4f1c7f1f
IS		 3754 list_for_each_entry(fib4_entry, &fib_node->entry_list, common.list) {
3755 if (fib4_entry->tb_id > new4_entry->tb_id)
9aecce1c 3756 continue;
4f1c7f1f 3757 if (fib4_entry->tb_id != new4_entry->tb_id)
9aecce1c 3758 break;
4f1c7f1f 3759 if (fib4_entry->tos > new4_entry->tos)
9aecce1c 3760 continue;
4f1c7f1f
IS		 3761 if (fib4_entry->prio >= new4_entry->prio ||
3762 fib4_entry->tos < new4_entry->tos)
3763 return fib4_entry;
9aecce1c
IS		 3764 }
3765
3766 return NULL;
3767}
3768
4f1c7f1f
IS		 3769static int
3770mlxsw_sp_fib4_node_list_append(struct mlxsw_sp_fib4_entry *fib4_entry,
3771 struct mlxsw_sp_fib4_entry *new4_entry)
4283bce5
IS		 3772{
3773 struct mlxsw_sp_fib_node *fib_node;
3774
4f1c7f1f 3775 if (WARN_ON(!fib4_entry))
4283bce5
IS		 3776 return -EINVAL;
3777
4f1c7f1f
IS		 3778 fib_node = fib4_entry->common.fib_node;
3779 list_for_each_entry_from(fib4_entry, &fib_node->entry_list,
3780 common.list) {
3781 if (fib4_entry->tb_id != new4_entry->tb_id ||
3782 fib4_entry->tos != new4_entry->tos ||
3783 fib4_entry->prio != new4_entry->prio)
4283bce5
IS		 3784 break;
3785 }
3786
4f1c7f1f 3787 list_add_tail(&new4_entry->common.list, &fib4_entry->common.list);
4283bce5
IS		 3788 return 0;
3789}
3790
9aecce1c 3791static int
9efbee6f 3792mlxsw_sp_fib4_node_list_insert(struct mlxsw_sp_fib4_entry *new4_entry,
599cf8f9 3793 bool replace, bool append)
9aecce1c 3794{
9efbee6f 3795 struct mlxsw_sp_fib_node *fib_node = new4_entry->common.fib_node;
4f1c7f1f 3796 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 3797
4f1c7f1f 3798 fib4_entry = mlxsw_sp_fib4_node_entry_find(fib_node, new4_entry);
9aecce1c 3799
4283bce5 3800 if (append)
4f1c7f1f
IS		 3801 return mlxsw_sp_fib4_node_list_append(fib4_entry, new4_entry);
3802 if (replace && WARN_ON(!fib4_entry))
599cf8f9 3803 return -EINVAL;
4283bce5 3804
599cf8f9
IS		 3805 /* Insert new entry before replaced one, so that we can later
3806 * remove the second.
3807 */
4f1c7f1f
IS		 3808 if (fib4_entry) {
3809 list_add_tail(&new4_entry->common.list,
3810 &fib4_entry->common.list);
9aecce1c 3811 } else {
4f1c7f1f 3812 struct mlxsw_sp_fib4_entry *last;
9aecce1c 3813
4f1c7f1f
IS		 3814 list_for_each_entry(last, &fib_node->entry_list, common.list) {
3815 if (new4_entry->tb_id > last->tb_id)
9aecce1c 3816 break;
4f1c7f1f 3817 fib4_entry = last;
9aecce1c
IS		 3818 }
3819
4f1c7f1f
IS		 3820 if (fib4_entry)
3821 list_add(&new4_entry->common.list,
3822 &fib4_entry->common.list);
9aecce1c 3823 else
4f1c7f1f
IS		 3824 list_add(&new4_entry->common.list,
3825 &fib_node->entry_list);
9aecce1c
IS		 3826 }
3827
3828 return 0;
3829}
3830
3831static void
4f1c7f1f 3832mlxsw_sp_fib4_node_list_remove(struct mlxsw_sp_fib4_entry *fib4_entry)
9aecce1c 3833{
4f1c7f1f 3834 list_del(&fib4_entry->common.list);
9aecce1c
IS		 3835}
3836
80c238f9
IS		 3837static int mlxsw_sp_fib_node_entry_add(struct mlxsw_sp *mlxsw_sp,
3838 struct mlxsw_sp_fib_entry *fib_entry)
9aecce1c 3839{
9efbee6f
IS		 3840 struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
3841
9aecce1c
IS		 3842 if (!mlxsw_sp_fib_node_entry_is_first(fib_node, fib_entry))
3843 return 0;
3844
3845 /* To prevent packet loss, overwrite the previously offloaded
3846 * entry.
3847 */
3848 if (!list_is_singular(&fib_node->entry_list)) {
3849 enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_DELETE;
3850 struct mlxsw_sp_fib_entry *n = list_next_entry(fib_entry, list);
3851
3852 mlxsw_sp_fib_entry_offload_refresh(n, op, 0);
3853 }
3854
3855 return mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
3856}
3857
80c238f9
IS		 3858static void mlxsw_sp_fib_node_entry_del(struct mlxsw_sp *mlxsw_sp,
3859 struct mlxsw_sp_fib_entry *fib_entry)
9aecce1c 3860{
9efbee6f
IS		 3861 struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
3862
9aecce1c
IS		 3863 if (!mlxsw_sp_fib_node_entry_is_first(fib_node, fib_entry))
3864 return;
3865
3866 /* Promote the next entry by overwriting the deleted entry */
3867 if (!list_is_singular(&fib_node->entry_list)) {
3868 struct mlxsw_sp_fib_entry *n = list_next_entry(fib_entry, list);
3869 enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_DELETE;
3870
3871 mlxsw_sp_fib_entry_update(mlxsw_sp, n);
3872 mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, 0);
3873 return;
3874 }
3875
3876 mlxsw_sp_fib_entry_del(mlxsw_sp, fib_entry);
3877}
3878
3879static int mlxsw_sp_fib4_node_entry_link(struct mlxsw_sp *mlxsw_sp,
4f1c7f1f 3880 struct mlxsw_sp_fib4_entry *fib4_entry,
599cf8f9 3881 bool replace, bool append)
9aecce1c 3882{
9aecce1c
IS		 3883 int err;
3884
9efbee6f 3885 err = mlxsw_sp_fib4_node_list_insert(fib4_entry, replace, append);
9aecce1c
IS		 3886 if (err)
3887 return err;
3888
80c238f9 3889 err = mlxsw_sp_fib_node_entry_add(mlxsw_sp, &fib4_entry->common);
9aecce1c 3890 if (err)
80c238f9 3891 goto err_fib_node_entry_add;
9aecce1c 3892
9aecce1c
IS		 3893 return 0;
3894
80c238f9 3895err_fib_node_entry_add:
4f1c7f1f 3896 mlxsw_sp_fib4_node_list_remove(fib4_entry);
9aecce1c
IS		 3897 return err;
3898}
3899
3900static void
3901mlxsw_sp_fib4_node_entry_unlink(struct mlxsw_sp *mlxsw_sp,
4f1c7f1f 3902 struct mlxsw_sp_fib4_entry *fib4_entry)
9aecce1c 3903{
80c238f9 3904 mlxsw_sp_fib_node_entry_del(mlxsw_sp, &fib4_entry->common);
4f1c7f1f 3905 mlxsw_sp_fib4_node_list_remove(fib4_entry);
4607f6d2
PM		 3906
3907 if (fib4_entry->common.type == MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP)
3908 mlxsw_sp_fib_entry_decap_fini(mlxsw_sp, &fib4_entry->common);
9aecce1c
IS		 3909}
3910
599cf8f9 3911static void mlxsw_sp_fib4_entry_replace(struct mlxsw_sp *mlxsw_sp,
4f1c7f1f 3912 struct mlxsw_sp_fib4_entry *fib4_entry,
599cf8f9
IS		 3913 bool replace)
3914{
4f1c7f1f
IS		 3915 struct mlxsw_sp_fib_node *fib_node = fib4_entry->common.fib_node;
3916 struct mlxsw_sp_fib4_entry *replaced;
599cf8f9
IS		 3917
3918 if (!replace)
3919 return;
3920
3921 /* We inserted the new entry before replaced one */
4f1c7f1f 3922 replaced = list_next_entry(fib4_entry, common.list);
599cf8f9
IS		 3923
3924 mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, replaced);
3925 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, replaced);
731ea1ca 3926 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
599cf8f9
IS		 3927}
3928
9aecce1c
IS		 3929static int
3930mlxsw_sp_router_fib4_add(struct mlxsw_sp *mlxsw_sp,
4283bce5 3931 const struct fib_entry_notifier_info *fen_info,
599cf8f9 3932 bool replace, bool append)
9aecce1c 3933{
4f1c7f1f 3934 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 3935 struct mlxsw_sp_fib_node *fib_node;
61c503f9
JP		 3936 int err;
3937
9011b677 3938 if (mlxsw_sp->router->aborted)
b45f64d1
JP		 3939 return 0;
3940
731ea1ca
IS		 3941 fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, fen_info->tb_id,
3942 &fen_info->dst, sizeof(fen_info->dst),
3943 fen_info->dst_len,
3944 MLXSW_SP_L3_PROTO_IPV4);
9aecce1c
IS		 3945 if (IS_ERR(fib_node)) {
3946 dev_warn(mlxsw_sp->bus_info->dev, "Failed to get FIB node\n");
3947 return PTR_ERR(fib_node);
b45f64d1 3948 }
61c503f9 3949
4f1c7f1f
IS		 3950 fib4_entry = mlxsw_sp_fib4_entry_create(mlxsw_sp, fib_node, fen_info);
3951 if (IS_ERR(fib4_entry)) {
9aecce1c 3952 dev_warn(mlxsw_sp->bus_info->dev, "Failed to create FIB entry\n");
4f1c7f1f 3953 err = PTR_ERR(fib4_entry);
9aecce1c
IS		 3954 goto err_fib4_entry_create;
3955 }
5b004412 3956
4f1c7f1f 3957 err = mlxsw_sp_fib4_node_entry_link(mlxsw_sp, fib4_entry, replace,
599cf8f9 3958 append);
b45f64d1 3959 if (err) {
9aecce1c
IS		 3960 dev_warn(mlxsw_sp->bus_info->dev, "Failed to link FIB entry to node\n");
3961 goto err_fib4_node_entry_link;
b45f64d1 3962 }
9aecce1c 3963
4f1c7f1f 3964 mlxsw_sp_fib4_entry_replace(mlxsw_sp, fib4_entry, replace);
599cf8f9 3965
61c503f9
JP		 3966 return 0;
3967
9aecce1c 3968err_fib4_node_entry_link:
4f1c7f1f 3969 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
9aecce1c 3970err_fib4_entry_create:
731ea1ca 3971 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
61c503f9
JP		 3972 return err;
3973}
3974
37956d78
JP		 3975static void mlxsw_sp_router_fib4_del(struct mlxsw_sp *mlxsw_sp,
3976 struct fib_entry_notifier_info *fen_info)
61c503f9 3977{
4f1c7f1f 3978 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 3979 struct mlxsw_sp_fib_node *fib_node;
61c503f9 3980
9011b677 3981 if (mlxsw_sp->router->aborted)
37956d78 3982 return;
b45f64d1 3983
4f1c7f1f
IS		 3984 fib4_entry = mlxsw_sp_fib4_entry_lookup(mlxsw_sp, fen_info);
3985 if (WARN_ON(!fib4_entry))
37956d78 3986 return;
4f1c7f1f 3987 fib_node = fib4_entry->common.fib_node;
5b004412 3988
4f1c7f1f
IS		 3989 mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, fib4_entry);
3990 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
731ea1ca 3991 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
61c503f9 3992}
b45f64d1 3993
428b851f
IS		 3994static bool mlxsw_sp_fib6_rt_should_ignore(const struct rt6_info *rt)
3995{
3996 /* Packets with link-local destination IP arriving to the router
3997 * are trapped to the CPU, so no need to program specific routes
3998 * for them.
3999 */
4000 if (ipv6_addr_type(&rt->rt6i_dst.addr) & IPV6_ADDR_LINKLOCAL)
4001 return true;
4002
4003 /* Multicast routes aren't supported, so ignore them. Neighbour
4004 * Discovery packets are specifically trapped.
4005 */
4006 if (ipv6_addr_type(&rt->rt6i_dst.addr) & IPV6_ADDR_MULTICAST)
4007 return true;
4008
4009 /* Cloned routes are irrelevant in the forwarding path. */
4010 if (rt->rt6i_flags & RTF_CACHE)
4011 return true;
4012
4013 return false;
4014}
4015
4016static struct mlxsw_sp_rt6 *mlxsw_sp_rt6_create(struct rt6_info *rt)
4017{
4018 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4019
4020 mlxsw_sp_rt6 = kzalloc(sizeof(*mlxsw_sp_rt6), GFP_KERNEL);
4021 if (!mlxsw_sp_rt6)
4022 return ERR_PTR(-ENOMEM);
4023
4024 /* In case of route replace, replaced route is deleted with
4025 * no notification. Take reference to prevent accessing freed
4026 * memory.
4027 */
4028 mlxsw_sp_rt6->rt = rt;
4029 rt6_hold(rt);
4030
4031 return mlxsw_sp_rt6;
4032}
4033
4034#if IS_ENABLED(CONFIG_IPV6)
4035static void mlxsw_sp_rt6_release(struct rt6_info *rt)
4036{
4037 rt6_release(rt);
4038}
4039#else
4040static void mlxsw_sp_rt6_release(struct rt6_info *rt)
4041{
4042}
4043#endif
4044
4045static void mlxsw_sp_rt6_destroy(struct mlxsw_sp_rt6 *mlxsw_sp_rt6)
4046{
4047 mlxsw_sp_rt6_release(mlxsw_sp_rt6->rt);
4048 kfree(mlxsw_sp_rt6);
4049}
4050
4051static bool mlxsw_sp_fib6_rt_can_mp(const struct rt6_info *rt)
4052{
4053 /* RTF_CACHE routes are ignored */
4054 return (rt->rt6i_flags & (RTF_GATEWAY | RTF_ADDRCONF)) == RTF_GATEWAY;
4055}
4056
4057static struct rt6_info *
4058mlxsw_sp_fib6_entry_rt(const struct mlxsw_sp_fib6_entry *fib6_entry)
4059{
4060 return list_first_entry(&fib6_entry->rt6_list, struct mlxsw_sp_rt6,
4061 list)->rt;
4062}
4063
4064static struct mlxsw_sp_fib6_entry *
4065mlxsw_sp_fib6_node_mp_entry_find(const struct mlxsw_sp_fib_node *fib_node,
0a7fd1ac 4066 const struct rt6_info *nrt, bool replace)
428b851f
IS		 4067{
4068 struct mlxsw_sp_fib6_entry *fib6_entry;
4069
0a7fd1ac 4070 if (!mlxsw_sp_fib6_rt_can_mp(nrt) || replace)
428b851f
IS		 4071 return NULL;
4072
4073 list_for_each_entry(fib6_entry, &fib_node->entry_list, common.list) {
4074 struct rt6_info *rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
4075
4076 /* RT6_TABLE_LOCAL and RT6_TABLE_MAIN share the same
4077 * virtual router.
4078 */
4079 if (rt->rt6i_table->tb6_id > nrt->rt6i_table->tb6_id)
4080 continue;
4081 if (rt->rt6i_table->tb6_id != nrt->rt6i_table->tb6_id)
4082 break;
4083 if (rt->rt6i_metric < nrt->rt6i_metric)
4084 continue;
4085 if (rt->rt6i_metric == nrt->rt6i_metric &&
4086 mlxsw_sp_fib6_rt_can_mp(rt))
4087 return fib6_entry;
4088 if (rt->rt6i_metric > nrt->rt6i_metric)
4089 break;
4090 }
4091
4092 return NULL;
4093}
4094
4095static struct mlxsw_sp_rt6 *
4096mlxsw_sp_fib6_entry_rt_find(const struct mlxsw_sp_fib6_entry *fib6_entry,
4097 const struct rt6_info *rt)
4098{
4099 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4100
4101 list_for_each_entry(mlxsw_sp_rt6, &fib6_entry->rt6_list, list) {
4102 if (mlxsw_sp_rt6->rt == rt)
4103 return mlxsw_sp_rt6;
4104 }
4105
4106 return NULL;
4107}
4108
8f28a309
PM		 4109static bool mlxsw_sp_nexthop6_ipip_type(const struct mlxsw_sp *mlxsw_sp,
4110 const struct rt6_info *rt,
4111 enum mlxsw_sp_ipip_type *ret)
4112{
4113 return rt->dst.dev &&
4114 mlxsw_sp_netdev_ipip_type(mlxsw_sp, rt->dst.dev, ret);
4115}
4116
35225e47
PM		 4117static int mlxsw_sp_nexthop6_type_init(struct mlxsw_sp *mlxsw_sp,
4118 struct mlxsw_sp_nexthop_group *nh_grp,
4119 struct mlxsw_sp_nexthop *nh,
4120 const struct rt6_info *rt)
428b851f 4121{
8f28a309 4122 struct mlxsw_sp_router *router = mlxsw_sp->router;
428b851f 4123 struct net_device *dev = rt->dst.dev;
8f28a309 4124 enum mlxsw_sp_ipip_type ipipt;
428b851f
IS		 4125 struct mlxsw_sp_rif *rif;
4126 int err;
4127
8f28a309
PM		 4128 if (mlxsw_sp_nexthop6_ipip_type(mlxsw_sp, rt, &ipipt) &&
4129 router->ipip_ops_arr[ipipt]->can_offload(mlxsw_sp, dev,
4130 MLXSW_SP_L3_PROTO_IPV6)) {
4131 nh->type = MLXSW_SP_NEXTHOP_TYPE_IPIP;
4132 return mlxsw_sp_nexthop_ipip_init(mlxsw_sp, ipipt, nh, dev);
4133 }
4134
35225e47 4135 nh->type = MLXSW_SP_NEXTHOP_TYPE_ETH;
428b851f
IS		 4136 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
4137 if (!rif)
4138 return 0;
4139 mlxsw_sp_nexthop_rif_init(nh, rif);
4140
4141 err = mlxsw_sp_nexthop_neigh_init(mlxsw_sp, nh);
4142 if (err)
4143 goto err_nexthop_neigh_init;
4144
4145 return 0;
4146
4147err_nexthop_neigh_init:
4148 mlxsw_sp_nexthop_rif_fini(nh);
4149 return err;
4150}
4151
35225e47
PM		 4152static void mlxsw_sp_nexthop6_type_fini(struct mlxsw_sp *mlxsw_sp,
4153 struct mlxsw_sp_nexthop *nh)
4154{
4155 mlxsw_sp_nexthop_type_fini(mlxsw_sp, nh);
4156}
4157
4158static int mlxsw_sp_nexthop6_init(struct mlxsw_sp *mlxsw_sp,
4159 struct mlxsw_sp_nexthop_group *nh_grp,
4160 struct mlxsw_sp_nexthop *nh,
4161 const struct rt6_info *rt)
4162{
4163 struct net_device *dev = rt->dst.dev;
4164
4165 nh->nh_grp = nh_grp;
4166 memcpy(&nh->gw_addr, &rt->rt6i_gateway, sizeof(nh->gw_addr));
a5390278 4167 mlxsw_sp_nexthop_counter_alloc(mlxsw_sp, nh);
35225e47 4168
dbe4598c
AS		 4169 list_add_tail(&nh->router_list_node, &mlxsw_sp->router->nexthop_list);
4170
35225e47
PM		 4171 if (!dev)
4172 return 0;
4173 nh->ifindex = dev->ifindex;
4174
4175 return mlxsw_sp_nexthop6_type_init(mlxsw_sp, nh_grp, nh, rt);
4176}
4177
428b851f
IS		 4178static void mlxsw_sp_nexthop6_fini(struct mlxsw_sp *mlxsw_sp,
4179 struct mlxsw_sp_nexthop *nh)
4180{
35225e47 4181 mlxsw_sp_nexthop6_type_fini(mlxsw_sp, nh);
dbe4598c 4182 list_del(&nh->router_list_node);
a5390278 4183 mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
428b851f
IS		 4184}
4185
f6050ee6
PM		 4186static bool mlxsw_sp_rt6_is_gateway(const struct mlxsw_sp *mlxsw_sp,
4187 const struct rt6_info *rt)
4188{
8f28a309
PM		 4189 return rt->rt6i_flags & RTF_GATEWAY ||
4190 mlxsw_sp_nexthop6_ipip_type(mlxsw_sp, rt, NULL);
f6050ee6
PM		 4191}
4192
428b851f
IS		 4193static struct mlxsw_sp_nexthop_group *
4194mlxsw_sp_nexthop6_group_create(struct mlxsw_sp *mlxsw_sp,
4195 struct mlxsw_sp_fib6_entry *fib6_entry)
4196{
4197 struct mlxsw_sp_nexthop_group *nh_grp;
4198 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4199 struct mlxsw_sp_nexthop *nh;
4200 size_t alloc_size;
4201 int i = 0;
4202 int err;
4203
4204 alloc_size = sizeof(*nh_grp) +
4205 fib6_entry->nrt6 * sizeof(struct mlxsw_sp_nexthop);
4206 nh_grp = kzalloc(alloc_size, GFP_KERNEL);
4207 if (!nh_grp)
4208 return ERR_PTR(-ENOMEM);
4209 INIT_LIST_HEAD(&nh_grp->fib_list);
4210#if IS_ENABLED(CONFIG_IPV6)
4211 nh_grp->neigh_tbl = &nd_tbl;
4212#endif
4213 mlxsw_sp_rt6 = list_first_entry(&fib6_entry->rt6_list,
4214 struct mlxsw_sp_rt6, list);
f6050ee6 4215 nh_grp->gateway = mlxsw_sp_rt6_is_gateway(mlxsw_sp, mlxsw_sp_rt6->rt);
428b851f
IS		 4216 nh_grp->count = fib6_entry->nrt6;
4217 for (i = 0; i < nh_grp->count; i++) {
4218 struct rt6_info *rt = mlxsw_sp_rt6->rt;
4219
4220 nh = &nh_grp->nexthops[i];
4221 err = mlxsw_sp_nexthop6_init(mlxsw_sp, nh_grp, nh, rt);
4222 if (err)
4223 goto err_nexthop6_init;
4224 mlxsw_sp_rt6 = list_next_entry(mlxsw_sp_rt6, list);
4225 }
e6f3b379
AS		 4226
4227 err = mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
4228 if (err)
4229 goto err_nexthop_group_insert;
4230
428b851f
IS		 4231 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
4232 return nh_grp;
4233
e6f3b379 4234err_nexthop_group_insert:
428b851f
IS		 4235err_nexthop6_init:
4236 for (i--; i >= 0; i--) {
4237 nh = &nh_grp->nexthops[i];
4238 mlxsw_sp_nexthop6_fini(mlxsw_sp, nh);
4239 }
4240 kfree(nh_grp);
4241 return ERR_PTR(err);
4242}
4243
4244static void
4245mlxsw_sp_nexthop6_group_destroy(struct mlxsw_sp *mlxsw_sp,
4246 struct mlxsw_sp_nexthop_group *nh_grp)
4247{
4248 struct mlxsw_sp_nexthop *nh;
4249 int i = nh_grp->count;
4250
e6f3b379 4251 mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
428b851f
IS		 4252 for (i--; i >= 0; i--) {
4253 nh = &nh_grp->nexthops[i];
4254 mlxsw_sp_nexthop6_fini(mlxsw_sp, nh);
4255 }
4256 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
4257 WARN_ON(nh_grp->adj_index_valid);
4258 kfree(nh_grp);
4259}
4260
4261static int mlxsw_sp_nexthop6_group_get(struct mlxsw_sp *mlxsw_sp,
4262 struct mlxsw_sp_fib6_entry *fib6_entry)
4263{
4264 struct mlxsw_sp_nexthop_group *nh_grp;
4265
e6f3b379
AS		 4266 nh_grp = mlxsw_sp_nexthop6_group_lookup(mlxsw_sp, fib6_entry);
4267 if (!nh_grp) {
4268 nh_grp = mlxsw_sp_nexthop6_group_create(mlxsw_sp, fib6_entry);
4269 if (IS_ERR(nh_grp))
4270 return PTR_ERR(nh_grp);
4271 }
428b851f
IS		 4272
4273 list_add_tail(&fib6_entry->common.nexthop_group_node,
4274 &nh_grp->fib_list);
4275 fib6_entry->common.nh_group = nh_grp;
4276
4277 return 0;
4278}
4279
4280static void mlxsw_sp_nexthop6_group_put(struct mlxsw_sp *mlxsw_sp,
4281 struct mlxsw_sp_fib_entry *fib_entry)
4282{
4283 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
4284
4285 list_del(&fib_entry->nexthop_group_node);
4286 if (!list_empty(&nh_grp->fib_list))
4287 return;
4288 mlxsw_sp_nexthop6_group_destroy(mlxsw_sp, nh_grp);
4289}
4290
4291static int
4292mlxsw_sp_nexthop6_group_update(struct mlxsw_sp *mlxsw_sp,
4293 struct mlxsw_sp_fib6_entry *fib6_entry)
4294{
4295 struct mlxsw_sp_nexthop_group *old_nh_grp = fib6_entry->common.nh_group;
4296 int err;
4297
4298 fib6_entry->common.nh_group = NULL;
4299 list_del(&fib6_entry->common.nexthop_group_node);
4300
4301 err = mlxsw_sp_nexthop6_group_get(mlxsw_sp, fib6_entry);
4302 if (err)
4303 goto err_nexthop6_group_get;
4304
4305 /* In case this entry is offloaded, then the adjacency index
4306 * currently associated with it in the device's table is that
4307 * of the old group. Start using the new one instead.
4308 */
4309 err = mlxsw_sp_fib_node_entry_add(mlxsw_sp, &fib6_entry->common);
4310 if (err)
4311 goto err_fib_node_entry_add;
4312
4313 if (list_empty(&old_nh_grp->fib_list))
4314 mlxsw_sp_nexthop6_group_destroy(mlxsw_sp, old_nh_grp);
4315
4316 return 0;
4317
4318err_fib_node_entry_add:
4319 mlxsw_sp_nexthop6_group_put(mlxsw_sp, &fib6_entry->common);
4320err_nexthop6_group_get:
4321 list_add_tail(&fib6_entry->common.nexthop_group_node,
4322 &old_nh_grp->fib_list);
4323 fib6_entry->common.nh_group = old_nh_grp;
4324 return err;
4325}
4326
4327static int
4328mlxsw_sp_fib6_entry_nexthop_add(struct mlxsw_sp *mlxsw_sp,
4329 struct mlxsw_sp_fib6_entry *fib6_entry,
4330 struct rt6_info *rt)
4331{
4332 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4333 int err;
4334
4335 mlxsw_sp_rt6 = mlxsw_sp_rt6_create(rt);
4336 if (IS_ERR(mlxsw_sp_rt6))
4337 return PTR_ERR(mlxsw_sp_rt6);
4338
4339 list_add_tail(&mlxsw_sp_rt6->list, &fib6_entry->rt6_list);
4340 fib6_entry->nrt6++;
4341
4342 err = mlxsw_sp_nexthop6_group_update(mlxsw_sp, fib6_entry);
4343 if (err)
4344 goto err_nexthop6_group_update;
4345
4346 return 0;
4347
4348err_nexthop6_group_update:
4349 fib6_entry->nrt6--;
4350 list_del(&mlxsw_sp_rt6->list);
4351 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
4352 return err;
4353}
4354
4355static void
4356mlxsw_sp_fib6_entry_nexthop_del(struct mlxsw_sp *mlxsw_sp,
4357 struct mlxsw_sp_fib6_entry *fib6_entry,
4358 struct rt6_info *rt)
4359{
4360 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4361
4362 mlxsw_sp_rt6 = mlxsw_sp_fib6_entry_rt_find(fib6_entry, rt);
4363 if (WARN_ON(!mlxsw_sp_rt6))
4364 return;
4365
4366 fib6_entry->nrt6--;
4367 list_del(&mlxsw_sp_rt6->list);
4368 mlxsw_sp_nexthop6_group_update(mlxsw_sp, fib6_entry);
4369 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
4370}
4371
f6050ee6
PM		 4372static void mlxsw_sp_fib6_entry_type_set(struct mlxsw_sp *mlxsw_sp,
4373 struct mlxsw_sp_fib_entry *fib_entry,
428b851f
IS		 4374 const struct rt6_info *rt)
4375{
4376 /* Packets hitting RTF_REJECT routes need to be discarded by the
4377 * stack. We can rely on their destination device not having a
4378 * RIF (it's the loopback device) and can thus use action type
4379 * local, which will cause them to be trapped with a lower
4380 * priority than packets that need to be locally received.
4381 */
d3b6d377 4382 if (rt->rt6i_flags & (RTF_LOCAL | RTF_ANYCAST))
428b851f
IS		 4383 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
4384 else if (rt->rt6i_flags & RTF_REJECT)
4385 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
f6050ee6 4386 else if (mlxsw_sp_rt6_is_gateway(mlxsw_sp, rt))
428b851f
IS		 4387 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE;
4388 else
4389 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
4390}
4391
4392static void
4393mlxsw_sp_fib6_entry_rt_destroy_all(struct mlxsw_sp_fib6_entry *fib6_entry)
4394{
4395 struct mlxsw_sp_rt6 *mlxsw_sp_rt6, *tmp;
4396
4397 list_for_each_entry_safe(mlxsw_sp_rt6, tmp, &fib6_entry->rt6_list,
4398 list) {
4399 fib6_entry->nrt6--;
4400 list_del(&mlxsw_sp_rt6->list);
4401 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
4402 }
4403}
4404
4405static struct mlxsw_sp_fib6_entry *
4406mlxsw_sp_fib6_entry_create(struct mlxsw_sp *mlxsw_sp,
4407 struct mlxsw_sp_fib_node *fib_node,
4408 struct rt6_info *rt)
4409{
4410 struct mlxsw_sp_fib6_entry *fib6_entry;
4411 struct mlxsw_sp_fib_entry *fib_entry;
4412 struct mlxsw_sp_rt6 *mlxsw_sp_rt6;
4413 int err;
4414
4415 fib6_entry = kzalloc(sizeof(*fib6_entry), GFP_KERNEL);
4416 if (!fib6_entry)
4417 return ERR_PTR(-ENOMEM);
4418 fib_entry = &fib6_entry->common;
4419
4420 mlxsw_sp_rt6 = mlxsw_sp_rt6_create(rt);
4421 if (IS_ERR(mlxsw_sp_rt6)) {
4422 err = PTR_ERR(mlxsw_sp_rt6);
4423 goto err_rt6_create;
4424 }
4425
f6050ee6 4426 mlxsw_sp_fib6_entry_type_set(mlxsw_sp, fib_entry, mlxsw_sp_rt6->rt);
428b851f
IS		 4427
4428 INIT_LIST_HEAD(&fib6_entry->rt6_list);
4429 list_add_tail(&mlxsw_sp_rt6->list, &fib6_entry->rt6_list);
4430 fib6_entry->nrt6 = 1;
4431 err = mlxsw_sp_nexthop6_group_get(mlxsw_sp, fib6_entry);
4432 if (err)
4433 goto err_nexthop6_group_get;
4434
4435 fib_entry->fib_node = fib_node;
4436
4437 return fib6_entry;
4438
4439err_nexthop6_group_get:
4440 list_del(&mlxsw_sp_rt6->list);
4441 mlxsw_sp_rt6_destroy(mlxsw_sp_rt6);
4442err_rt6_create:
4443 kfree(fib6_entry);
4444 return ERR_PTR(err);
4445}
4446
4447static void mlxsw_sp_fib6_entry_destroy(struct mlxsw_sp *mlxsw_sp,
4448 struct mlxsw_sp_fib6_entry *fib6_entry)
4449{
4450 mlxsw_sp_nexthop6_group_put(mlxsw_sp, &fib6_entry->common);
4451 mlxsw_sp_fib6_entry_rt_destroy_all(fib6_entry);
4452 WARN_ON(fib6_entry->nrt6);
4453 kfree(fib6_entry);
4454}
4455
4456static struct mlxsw_sp_fib6_entry *
4457mlxsw_sp_fib6_node_entry_find(const struct mlxsw_sp_fib_node *fib_node,
0a7fd1ac 4458 const struct rt6_info *nrt, bool replace)
428b851f 4459{
0a7fd1ac 4460 struct mlxsw_sp_fib6_entry *fib6_entry, *fallback = NULL;
428b851f
IS		 4461
4462 list_for_each_entry(fib6_entry, &fib_node->entry_list, common.list) {
4463 struct rt6_info *rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
4464
4465 if (rt->rt6i_table->tb6_id > nrt->rt6i_table->tb6_id)
4466 continue;
4467 if (rt->rt6i_table->tb6_id != nrt->rt6i_table->tb6_id)
4468 break;
0a7fd1ac
IS		 4469 if (replace && rt->rt6i_metric == nrt->rt6i_metric) {
4470 if (mlxsw_sp_fib6_rt_can_mp(rt) ==
4471 mlxsw_sp_fib6_rt_can_mp(nrt))
4472 return fib6_entry;
4473 if (mlxsw_sp_fib6_rt_can_mp(nrt))
4474 fallback = fallback ?: fib6_entry;
4475 }
428b851f 4476 if (rt->rt6i_metric > nrt->rt6i_metric)
0a7fd1ac 4477 return fallback ?: fib6_entry;
428b851f
IS		 4478 }
4479
0a7fd1ac 4480 return fallback;
428b851f
IS		 4481}
4482
4483static int
0a7fd1ac
IS		 4484mlxsw_sp_fib6_node_list_insert(struct mlxsw_sp_fib6_entry *new6_entry,
4485 bool replace)
428b851f
IS		 4486{
4487 struct mlxsw_sp_fib_node *fib_node = new6_entry->common.fib_node;
4488 struct rt6_info *nrt = mlxsw_sp_fib6_entry_rt(new6_entry);
4489 struct mlxsw_sp_fib6_entry *fib6_entry;
4490
0a7fd1ac
IS		 4491 fib6_entry = mlxsw_sp_fib6_node_entry_find(fib_node, nrt, replace);
4492
4493 if (replace && WARN_ON(!fib6_entry))
4494 return -EINVAL;
428b851f
IS		 4495
4496 if (fib6_entry) {
4497 list_add_tail(&new6_entry->common.list,
4498 &fib6_entry->common.list);
4499 } else {
4500 struct mlxsw_sp_fib6_entry *last;
4501
4502 list_for_each_entry(last, &fib_node->entry_list, common.list) {
4503 struct rt6_info *rt = mlxsw_sp_fib6_entry_rt(last);
4504
4505 if (nrt->rt6i_table->tb6_id > rt->rt6i_table->tb6_id)
4506 break;
4507 fib6_entry = last;
4508 }
4509
4510 if (fib6_entry)
4511 list_add(&new6_entry->common.list,
4512 &fib6_entry->common.list);
4513 else
4514 list_add(&new6_entry->common.list,
4515 &fib_node->entry_list);
4516 }
4517
4518 return 0;
4519}
4520
4521static void
4522mlxsw_sp_fib6_node_list_remove(struct mlxsw_sp_fib6_entry *fib6_entry)
4523{
4524 list_del(&fib6_entry->common.list);
4525}
4526
4527static int mlxsw_sp_fib6_node_entry_link(struct mlxsw_sp *mlxsw_sp,
0a7fd1ac
IS		 4528 struct mlxsw_sp_fib6_entry *fib6_entry,
4529 bool replace)
428b851f
IS		 4530{
4531 int err;
4532
0a7fd1ac 4533 err = mlxsw_sp_fib6_node_list_insert(fib6_entry, replace);
428b851f
IS		 4534 if (err)
4535 return err;
4536
4537 err = mlxsw_sp_fib_node_entry_add(mlxsw_sp, &fib6_entry->common);
4538 if (err)
4539 goto err_fib_node_entry_add;
4540
4541 return 0;
4542
4543err_fib_node_entry_add:
4544 mlxsw_sp_fib6_node_list_remove(fib6_entry);
4545 return err;
4546}
4547
4548static void
4549mlxsw_sp_fib6_node_entry_unlink(struct mlxsw_sp *mlxsw_sp,
4550 struct mlxsw_sp_fib6_entry *fib6_entry)
4551{
4552 mlxsw_sp_fib_node_entry_del(mlxsw_sp, &fib6_entry->common);
4553 mlxsw_sp_fib6_node_list_remove(fib6_entry);
4554}
4555
4556static struct mlxsw_sp_fib6_entry *
4557mlxsw_sp_fib6_entry_lookup(struct mlxsw_sp *mlxsw_sp,
4558 const struct rt6_info *rt)
4559{
4560 struct mlxsw_sp_fib6_entry *fib6_entry;
4561 struct mlxsw_sp_fib_node *fib_node;
4562 struct mlxsw_sp_fib *fib;
4563 struct mlxsw_sp_vr *vr;
4564
4565 vr = mlxsw_sp_vr_find(mlxsw_sp, rt->rt6i_table->tb6_id);
4566 if (!vr)
4567 return NULL;
4568 fib = mlxsw_sp_vr_fib(vr, MLXSW_SP_L3_PROTO_IPV6);
4569
4570 fib_node = mlxsw_sp_fib_node_lookup(fib, &rt->rt6i_dst.addr,
4571 sizeof(rt->rt6i_dst.addr),
4572 rt->rt6i_dst.plen);
4573 if (!fib_node)
4574 return NULL;
4575
4576 list_for_each_entry(fib6_entry, &fib_node->entry_list, common.list) {
4577 struct rt6_info *iter_rt = mlxsw_sp_fib6_entry_rt(fib6_entry);
4578
4579 if (rt->rt6i_table->tb6_id == iter_rt->rt6i_table->tb6_id &&
4580 rt->rt6i_metric == iter_rt->rt6i_metric &&
4581 mlxsw_sp_fib6_entry_rt_find(fib6_entry, rt))
4582 return fib6_entry;
4583 }
4584
4585 return NULL;
4586}
4587
0a7fd1ac
IS		 4588static void mlxsw_sp_fib6_entry_replace(struct mlxsw_sp *mlxsw_sp,
4589 struct mlxsw_sp_fib6_entry *fib6_entry,
4590 bool replace)
4591{
4592 struct mlxsw_sp_fib_node *fib_node = fib6_entry->common.fib_node;
4593 struct mlxsw_sp_fib6_entry *replaced;
4594
4595 if (!replace)
4596 return;
4597
4598 replaced = list_next_entry(fib6_entry, common.list);
4599
4600 mlxsw_sp_fib6_node_entry_unlink(mlxsw_sp, replaced);
4601 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, replaced);
4602 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4603}
4604
428b851f 4605static int mlxsw_sp_router_fib6_add(struct mlxsw_sp *mlxsw_sp,
0a7fd1ac 4606 struct rt6_info *rt, bool replace)
428b851f
IS		 4607{
4608 struct mlxsw_sp_fib6_entry *fib6_entry;
4609 struct mlxsw_sp_fib_node *fib_node;
4610 int err;
4611
4612 if (mlxsw_sp->router->aborted)
4613 return 0;
4614
f36f5ac6
IS		 4615 if (rt->rt6i_src.plen)
4616 return -EINVAL;
4617
428b851f
IS		 4618 if (mlxsw_sp_fib6_rt_should_ignore(rt))
4619 return 0;
4620
4621 fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, rt->rt6i_table->tb6_id,
4622 &rt->rt6i_dst.addr,
4623 sizeof(rt->rt6i_dst.addr),
4624 rt->rt6i_dst.plen,
4625 MLXSW_SP_L3_PROTO_IPV6);
4626 if (IS_ERR(fib_node))
4627 return PTR_ERR(fib_node);
4628
4629 /* Before creating a new entry, try to append route to an existing
4630 * multipath entry.
4631 */
0a7fd1ac 4632 fib6_entry = mlxsw_sp_fib6_node_mp_entry_find(fib_node, rt, replace);
428b851f
IS		 4633 if (fib6_entry) {
4634 err = mlxsw_sp_fib6_entry_nexthop_add(mlxsw_sp, fib6_entry, rt);
4635 if (err)
4636 goto err_fib6_entry_nexthop_add;
4637 return 0;
4638 }
4639
4640 fib6_entry = mlxsw_sp_fib6_entry_create(mlxsw_sp, fib_node, rt);
4641 if (IS_ERR(fib6_entry)) {
4642 err = PTR_ERR(fib6_entry);
4643 goto err_fib6_entry_create;
4644 }
4645
0a7fd1ac 4646 err = mlxsw_sp_fib6_node_entry_link(mlxsw_sp, fib6_entry, replace);
428b851f
IS		 4647 if (err)
4648 goto err_fib6_node_entry_link;
4649
0a7fd1ac
IS		 4650 mlxsw_sp_fib6_entry_replace(mlxsw_sp, fib6_entry, replace);
4651
428b851f
IS		 4652 return 0;
4653
4654err_fib6_node_entry_link:
4655 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
4656err_fib6_entry_create:
4657err_fib6_entry_nexthop_add:
4658 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4659 return err;
4660}
4661
4662static void mlxsw_sp_router_fib6_del(struct mlxsw_sp *mlxsw_sp,
4663 struct rt6_info *rt)
4664{
4665 struct mlxsw_sp_fib6_entry *fib6_entry;
4666 struct mlxsw_sp_fib_node *fib_node;
4667
4668 if (mlxsw_sp->router->aborted)
4669 return;
4670
4671 if (mlxsw_sp_fib6_rt_should_ignore(rt))
4672 return;
4673
4674 fib6_entry = mlxsw_sp_fib6_entry_lookup(mlxsw_sp, rt);
4675 if (WARN_ON(!fib6_entry))
4676 return;
4677
4678 /* If route is part of a multipath entry, but not the last one
4679 * removed, then only reduce its nexthop group.
4680 */
4681 if (!list_is_singular(&fib6_entry->rt6_list)) {
4682 mlxsw_sp_fib6_entry_nexthop_del(mlxsw_sp, fib6_entry, rt);
4683 return;
4684 }
4685
4686 fib_node = fib6_entry->common.fib_node;
4687
4688 mlxsw_sp_fib6_node_entry_unlink(mlxsw_sp, fib6_entry);
4689 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
4690 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4691}
4692
bc65a8a4
IS		 4693static int __mlxsw_sp_router_set_abort_trap(struct mlxsw_sp *mlxsw_sp,
4694 enum mlxsw_reg_ralxx_protocol proto,
4695 u8 tree_id)
b45f64d1
JP		 4696{
4697 char ralta_pl[MLXSW_REG_RALTA_LEN];
4698 char ralst_pl[MLXSW_REG_RALST_LEN];
b5d90e6d 4699 int i, err;
b45f64d1 4700
bc65a8a4 4701 mlxsw_reg_ralta_pack(ralta_pl, true, proto, tree_id);
b45f64d1
JP		 4702 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
4703 if (err)
4704 return err;
4705
bc65a8a4 4706 mlxsw_reg_ralst_pack(ralst_pl, 0xff, tree_id);
b45f64d1
JP		 4707 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralst), ralst_pl);
4708 if (err)
4709 return err;
4710
b5d90e6d 4711 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
9011b677 4712 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
b5d90e6d
IS		 4713 char raltb_pl[MLXSW_REG_RALTB_LEN];
4714 char ralue_pl[MLXSW_REG_RALUE_LEN];
b45f64d1 4715
bc65a8a4 4716 mlxsw_reg_raltb_pack(raltb_pl, vr->id, proto, tree_id);
b5d90e6d
IS		 4717 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb),
4718 raltb_pl);
4719 if (err)
4720 return err;
4721
bc65a8a4
IS		 4722 mlxsw_reg_ralue_pack(ralue_pl, proto,
4723 MLXSW_REG_RALUE_OP_WRITE_WRITE, vr->id, 0);
b5d90e6d
IS		 4724 mlxsw_reg_ralue_act_ip2me_pack(ralue_pl);
4725 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue),
4726 ralue_pl);
4727 if (err)
4728 return err;
4729 }
4730
4731 return 0;
b45f64d1
JP		 4732}
4733
bc65a8a4
IS		 4734static int mlxsw_sp_router_set_abort_trap(struct mlxsw_sp *mlxsw_sp)
4735{
4736 enum mlxsw_reg_ralxx_protocol proto = MLXSW_REG_RALXX_PROTOCOL_IPV4;
4737 int err;
4738
4739 err = __mlxsw_sp_router_set_abort_trap(mlxsw_sp, proto,
4740 MLXSW_SP_LPM_TREE_MIN);
4741 if (err)
4742 return err;
4743
4744 proto = MLXSW_REG_RALXX_PROTOCOL_IPV6;
4745 return __mlxsw_sp_router_set_abort_trap(mlxsw_sp, proto,
4746 MLXSW_SP_LPM_TREE_MIN + 1);
4747}
4748
9aecce1c
IS		 4749static void mlxsw_sp_fib4_node_flush(struct mlxsw_sp *mlxsw_sp,
4750 struct mlxsw_sp_fib_node *fib_node)
4751{
4f1c7f1f 4752 struct mlxsw_sp_fib4_entry *fib4_entry, *tmp;
9aecce1c 4753
4f1c7f1f
IS		 4754 list_for_each_entry_safe(fib4_entry, tmp, &fib_node->entry_list,
4755 common.list) {
4756 bool do_break = &tmp->common.list == &fib_node->entry_list;
9aecce1c 4757
4f1c7f1f
IS		 4758 mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, fib4_entry);
4759 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
731ea1ca 4760 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
9aecce1c
IS		 4761 /* Break when entry list is empty and node was freed.
4762 * Otherwise, we'll access freed memory in the next
4763 * iteration.
4764 */
4765 if (do_break)
4766 break;
4767 }
4768}
4769
428b851f
IS		 4770static void mlxsw_sp_fib6_node_flush(struct mlxsw_sp *mlxsw_sp,
4771 struct mlxsw_sp_fib_node *fib_node)
4772{
4773 struct mlxsw_sp_fib6_entry *fib6_entry, *tmp;
4774
4775 list_for_each_entry_safe(fib6_entry, tmp, &fib_node->entry_list,
4776 common.list) {
4777 bool do_break = &tmp->common.list == &fib_node->entry_list;
4778
4779 mlxsw_sp_fib6_node_entry_unlink(mlxsw_sp, fib6_entry);
4780 mlxsw_sp_fib6_entry_destroy(mlxsw_sp, fib6_entry);
4781 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
4782 if (do_break)
4783 break;
4784 }
4785}
4786
9aecce1c
IS		 4787static void mlxsw_sp_fib_node_flush(struct mlxsw_sp *mlxsw_sp,
4788 struct mlxsw_sp_fib_node *fib_node)
4789{
76610ebb 4790 switch (fib_node->fib->proto) {
9aecce1c
IS		 4791 case MLXSW_SP_L3_PROTO_IPV4:
4792 mlxsw_sp_fib4_node_flush(mlxsw_sp, fib_node);
4793 break;
4794 case MLXSW_SP_L3_PROTO_IPV6:
428b851f 4795 mlxsw_sp_fib6_node_flush(mlxsw_sp, fib_node);
9aecce1c
IS		 4796 break;
4797 }
4798}
4799
76610ebb
IS		 4800static void mlxsw_sp_vr_fib_flush(struct mlxsw_sp *mlxsw_sp,
4801 struct mlxsw_sp_vr *vr,
4802 enum mlxsw_sp_l3proto proto)
b45f64d1 4803{
76610ebb 4804 struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
9aecce1c 4805 struct mlxsw_sp_fib_node *fib_node, *tmp;
76610ebb
IS		 4806
4807 list_for_each_entry_safe(fib_node, tmp, &fib->node_list, list) {
4808 bool do_break = &tmp->list == &fib->node_list;
4809
4810 mlxsw_sp_fib_node_flush(mlxsw_sp, fib_node);
4811 if (do_break)
4812 break;
4813 }
4814}
4815
4816static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp)
4817{
b45f64d1 4818 int i;
b45f64d1 4819
c1a38311 4820 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
9011b677 4821 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
ac571de9 4822
76610ebb 4823 if (!mlxsw_sp_vr_is_used(vr))
b45f64d1 4824 continue;
76610ebb 4825 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV4);
a3d9bc50
IS		 4826
4827 /* If virtual router was only used for IPv4, then it's no
4828 * longer used.
4829 */
4830 if (!mlxsw_sp_vr_is_used(vr))
4831 continue;
4832 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV6);
b45f64d1 4833 }
ac571de9
IS		 4834}
4835
bc65a8a4 4836static void mlxsw_sp_router_fib_abort(struct mlxsw_sp *mlxsw_sp)
ac571de9
IS		 4837{
4838 int err;
4839
9011b677 4840 if (mlxsw_sp->router->aborted)
d331d303
IS		 4841 return;
4842 dev_warn(mlxsw_sp->bus_info->dev, "FIB abort triggered. Note that FIB entries are no longer being offloaded to this device.\n");
ac571de9 4843 mlxsw_sp_router_fib_flush(mlxsw_sp);
9011b677 4844 mlxsw_sp->router->aborted = true;
b45f64d1
JP		 4845 err = mlxsw_sp_router_set_abort_trap(mlxsw_sp);
4846 if (err)
4847 dev_warn(mlxsw_sp->bus_info->dev, "Failed to set abort trap.\n");
4848}
4849
3057224e 4850struct mlxsw_sp_fib_event_work {
a0e4761d 4851 struct work_struct work;
ad178c8e 4852 union {
428b851f 4853 struct fib6_entry_notifier_info fen6_info;
ad178c8e 4854 struct fib_entry_notifier_info fen_info;
5d7bfd14 4855 struct fib_rule_notifier_info fr_info;
ad178c8e
IS		 4856 struct fib_nh_notifier_info fnh_info;
4857 };
3057224e
IS		 4858 struct mlxsw_sp *mlxsw_sp;
4859 unsigned long event;
4860};
4861
66a5763a 4862static void mlxsw_sp_router_fib4_event_work(struct work_struct *work)
b45f64d1 4863{
3057224e 4864 struct mlxsw_sp_fib_event_work *fib_work =
a0e4761d 4865 container_of(work, struct mlxsw_sp_fib_event_work, work);
3057224e 4866 struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
5d7bfd14 4867 struct fib_rule *rule;
599cf8f9 4868 bool replace, append;
b45f64d1
JP		 4869 int err;
4870
3057224e
IS		 4871 /* Protect internal structures from changes */
4872 rtnl_lock();
4873 switch (fib_work->event) {
599cf8f9 4874 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
4283bce5 4875 case FIB_EVENT_ENTRY_APPEND: /* fall through */
b45f64d1 4876 case FIB_EVENT_ENTRY_ADD:
599cf8f9 4877 replace = fib_work->event == FIB_EVENT_ENTRY_REPLACE;
4283bce5
IS		 4878 append = fib_work->event == FIB_EVENT_ENTRY_APPEND;
4879 err = mlxsw_sp_router_fib4_add(mlxsw_sp, &fib_work->fen_info,
599cf8f9 4880 replace, append);
b45f64d1 4881 if (err)
bc65a8a4 4882 mlxsw_sp_router_fib_abort(mlxsw_sp);
3057224e 4883 fib_info_put(fib_work->fen_info.fi);
b45f64d1
JP		 4884 break;
4885 case FIB_EVENT_ENTRY_DEL:
3057224e
IS		 4886 mlxsw_sp_router_fib4_del(mlxsw_sp, &fib_work->fen_info);
4887 fib_info_put(fib_work->fen_info.fi);
b45f64d1
JP		 4888 break;
4889 case FIB_EVENT_RULE_ADD: /* fall through */
4890 case FIB_EVENT_RULE_DEL:
5d7bfd14 4891 rule = fib_work->fr_info.rule;
c7f6e665 4892 if (!fib4_rule_default(rule) && !rule->l3mdev)
bc65a8a4 4893 mlxsw_sp_router_fib_abort(mlxsw_sp);
5d7bfd14 4894 fib_rule_put(rule);
b45f64d1 4895 break;
ad178c8e
IS		 4896 case FIB_EVENT_NH_ADD: /* fall through */
4897 case FIB_EVENT_NH_DEL:
0e6ea2a4
IS		 4898 mlxsw_sp_nexthop4_event(mlxsw_sp, fib_work->event,
4899 fib_work->fnh_info.fib_nh);
ad178c8e
IS		 4900 fib_info_put(fib_work->fnh_info.fib_nh->nh_parent);
4901 break;
b45f64d1 4902 }
3057224e
IS		 4903 rtnl_unlock();
4904 kfree(fib_work);
4905}
4906
66a5763a
IS		 4907static void mlxsw_sp_router_fib6_event_work(struct work_struct *work)
4908{
583419fd
IS		 4909 struct mlxsw_sp_fib_event_work *fib_work =
4910 container_of(work, struct mlxsw_sp_fib_event_work, work);
4911 struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
4912 struct fib_rule *rule;
0a7fd1ac 4913 bool replace;
428b851f 4914 int err;
583419fd
IS		 4915
4916 rtnl_lock();
4917 switch (fib_work->event) {
0a7fd1ac 4918 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
428b851f 4919 case FIB_EVENT_ENTRY_ADD:
0a7fd1ac 4920 replace = fib_work->event == FIB_EVENT_ENTRY_REPLACE;
428b851f 4921 err = mlxsw_sp_router_fib6_add(mlxsw_sp,
0a7fd1ac 4922 fib_work->fen6_info.rt, replace);
428b851f
IS		 4923 if (err)
4924 mlxsw_sp_router_fib_abort(mlxsw_sp);
4925 mlxsw_sp_rt6_release(fib_work->fen6_info.rt);
4926 break;
4927 case FIB_EVENT_ENTRY_DEL:
4928 mlxsw_sp_router_fib6_del(mlxsw_sp, fib_work->fen6_info.rt);
4929 mlxsw_sp_rt6_release(fib_work->fen6_info.rt);
4930 break;
583419fd
IS		 4931 case FIB_EVENT_RULE_ADD: /* fall through */
4932 case FIB_EVENT_RULE_DEL:
4933 rule = fib_work->fr_info.rule;
4934 if (!fib6_rule_default(rule) && !rule->l3mdev)
4935 mlxsw_sp_router_fib_abort(mlxsw_sp);
4936 fib_rule_put(rule);
4937 break;
4938 }
4939 rtnl_unlock();
4940 kfree(fib_work);
66a5763a
IS		 4941}
4942
4943static void mlxsw_sp_router_fib4_event(struct mlxsw_sp_fib_event_work *fib_work,
4944 struct fib_notifier_info *info)
4945{
4946 switch (fib_work->event) {
4947 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
4948 case FIB_EVENT_ENTRY_APPEND: /* fall through */
4949 case FIB_EVENT_ENTRY_ADD: /* fall through */
4950 case FIB_EVENT_ENTRY_DEL:
4951 memcpy(&fib_work->fen_info, info, sizeof(fib_work->fen_info));
4952 /* Take referece on fib_info to prevent it from being
4953 * freed while work is queued. Release it afterwards.
4954 */
4955 fib_info_hold(fib_work->fen_info.fi);
4956 break;
4957 case FIB_EVENT_RULE_ADD: /* fall through */
4958 case FIB_EVENT_RULE_DEL:
4959 memcpy(&fib_work->fr_info, info, sizeof(fib_work->fr_info));
4960 fib_rule_get(fib_work->fr_info.rule);
4961 break;
4962 case FIB_EVENT_NH_ADD: /* fall through */
4963 case FIB_EVENT_NH_DEL:
4964 memcpy(&fib_work->fnh_info, info, sizeof(fib_work->fnh_info));
4965 fib_info_hold(fib_work->fnh_info.fib_nh->nh_parent);
4966 break;
4967 }
4968}
4969
4970static void mlxsw_sp_router_fib6_event(struct mlxsw_sp_fib_event_work *fib_work,
4971 struct fib_notifier_info *info)
4972{
583419fd 4973 switch (fib_work->event) {
0a7fd1ac 4974 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
428b851f
IS		 4975 case FIB_EVENT_ENTRY_ADD: /* fall through */
4976 case FIB_EVENT_ENTRY_DEL:
4977 memcpy(&fib_work->fen6_info, info, sizeof(fib_work->fen6_info));
4978 rt6_hold(fib_work->fen6_info.rt);
4979 break;
583419fd
IS		 4980 case FIB_EVENT_RULE_ADD: /* fall through */
4981 case FIB_EVENT_RULE_DEL:
4982 memcpy(&fib_work->fr_info, info, sizeof(fib_work->fr_info));
4983 fib_rule_get(fib_work->fr_info.rule);
4984 break;
4985 }
66a5763a
IS		 4986}
4987
3057224e
IS		 4988/* Called with rcu_read_lock() */
4989static int mlxsw_sp_router_fib_event(struct notifier_block *nb,
4990 unsigned long event, void *ptr)
4991{
3057224e
IS		 4992 struct mlxsw_sp_fib_event_work *fib_work;
4993 struct fib_notifier_info *info = ptr;
7e39d115 4994 struct mlxsw_sp_router *router;
3057224e 4995
8e29f979
IS		 4996 if (!net_eq(info->net, &init_net) ||
4997 (info->family != AF_INET && info->family != AF_INET6))
3057224e
IS		 4998 return NOTIFY_DONE;
4999
5000 fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC);
5001 if (WARN_ON(!fib_work))
5002 return NOTIFY_BAD;
5003
7e39d115
IS		 5004 router = container_of(nb, struct mlxsw_sp_router, fib_nb);
5005 fib_work->mlxsw_sp = router->mlxsw_sp;
3057224e
IS		 5006 fib_work->event = event;
5007
66a5763a
IS		 5008 switch (info->family) {
5009 case AF_INET:
5010 INIT_WORK(&fib_work->work, mlxsw_sp_router_fib4_event_work);
5011 mlxsw_sp_router_fib4_event(fib_work, info);
3057224e 5012 break;
66a5763a
IS		 5013 case AF_INET6:
5014 INIT_WORK(&fib_work->work, mlxsw_sp_router_fib6_event_work);
5015 mlxsw_sp_router_fib6_event(fib_work, info);
ad178c8e 5016 break;
3057224e
IS		 5017 }
5018
a0e4761d 5019 mlxsw_core_schedule_work(&fib_work->work);
3057224e 5020
b45f64d1
JP		 5021 return NOTIFY_DONE;
5022}
5023
4724ba56
IS		 5024static struct mlxsw_sp_rif *
5025mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp,
5026 const struct net_device *dev)
5027{
5028 int i;
5029
5030 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++)
5f9efffb
IS		 5031 if (mlxsw_sp->router->rifs[i] &&
5032 mlxsw_sp->router->rifs[i]->dev == dev)
5033 return mlxsw_sp->router->rifs[i];
4724ba56
IS		 5034
5035 return NULL;
5036}
5037
5038static int mlxsw_sp_router_rif_disable(struct mlxsw_sp *mlxsw_sp, u16 rif)
5039{
5040 char ritr_pl[MLXSW_REG_RITR_LEN];
5041 int err;
5042
5043 mlxsw_reg_ritr_rif_pack(ritr_pl, rif);
5044 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5045 if (WARN_ON_ONCE(err))
5046 return err;
5047
5048 mlxsw_reg_ritr_enable_set(ritr_pl, false);
5049 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5050}
5051
5052static void mlxsw_sp_router_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
bf95233e 5053 struct mlxsw_sp_rif *rif)
4724ba56 5054{
bf95233e
AS		 5055 mlxsw_sp_router_rif_disable(mlxsw_sp, rif->rif_index);
5056 mlxsw_sp_nexthop_rif_gone_sync(mlxsw_sp, rif);
5057 mlxsw_sp_neigh_rif_gone_sync(mlxsw_sp, rif);
4724ba56
IS		 5058}
5059
5ea1237f
AS		 5060static bool
5061mlxsw_sp_rif_should_config(struct mlxsw_sp_rif *rif, struct net_device *dev,
5062 unsigned long event)
4724ba56 5063{
5ea1237f
AS		 5064 struct inet6_dev *inet6_dev;
5065 bool addr_list_empty = true;
5066 struct in_device *idev;
5067
4724ba56
IS		 5068 switch (event) {
5069 case NETDEV_UP:
f1b1f273 5070 return rif == NULL;
4724ba56 5071 case NETDEV_DOWN:
5ea1237f
AS		 5072 idev = __in_dev_get_rtnl(dev);
5073 if (idev && idev->ifa_list)
5074 addr_list_empty = false;
5075
5076 inet6_dev = __in6_dev_get(dev);
5077 if (addr_list_empty && inet6_dev &&
5078 !list_empty(&inet6_dev->addr_list))
5079 addr_list_empty = false;
5080
5081 if (rif && addr_list_empty &&
bf95233e 5082 !netif_is_l3_slave(rif->dev))
4724ba56
IS		 5083 return true;
5084 /* It is possible we already removed the RIF ourselves
5085 * if it was assigned to a netdev that is now a bridge
5086 * or LAG slave.
5087 */
5088 return false;
5089 }
5090
5091 return false;
5092}
5093
e4f3c1c1
IS		 5094static enum mlxsw_sp_rif_type
5095mlxsw_sp_dev_rif_type(const struct mlxsw_sp *mlxsw_sp,
5096 const struct net_device *dev)
5097{
5098 enum mlxsw_sp_fid_type type;
5099
6ddb7426
PM		 5100 if (mlxsw_sp_netdev_ipip_type(mlxsw_sp, dev, NULL))
5101 return MLXSW_SP_RIF_TYPE_IPIP_LB;
5102
5103 /* Otherwise RIF type is derived from the type of the underlying FID. */
e4f3c1c1
IS		 5104 if (is_vlan_dev(dev) && netif_is_bridge_master(vlan_dev_real_dev(dev)))
5105 type = MLXSW_SP_FID_TYPE_8021Q;
5106 else if (netif_is_bridge_master(dev) && br_vlan_enabled(dev))
5107 type = MLXSW_SP_FID_TYPE_8021Q;
5108 else if (netif_is_bridge_master(dev))
5109 type = MLXSW_SP_FID_TYPE_8021D;
5110 else
5111 type = MLXSW_SP_FID_TYPE_RFID;
5112
5113 return mlxsw_sp_fid_type_rif_type(mlxsw_sp, type);
5114}
5115
de5ed99e 5116static int mlxsw_sp_rif_index_alloc(struct mlxsw_sp *mlxsw_sp, u16 *p_rif_index)
4724ba56
IS		 5117{
5118 int i;
5119
de5ed99e
IS		 5120 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) {
5121 if (!mlxsw_sp->router->rifs[i]) {
5122 *p_rif_index = i;
5123 return 0;
5124 }
5125 }
4724ba56 5126
de5ed99e 5127 return -ENOBUFS;
4724ba56
IS		 5128}
5129
e4f3c1c1
IS		 5130static struct mlxsw_sp_rif *mlxsw_sp_rif_alloc(size_t rif_size, u16 rif_index,
5131 u16 vr_id,
5132 struct net_device *l3_dev)
4724ba56 5133{
bf95233e 5134 struct mlxsw_sp_rif *rif;
4724ba56 5135
e4f3c1c1 5136 rif = kzalloc(rif_size, GFP_KERNEL);
bf95233e 5137 if (!rif)
4724ba56
IS		 5138 return NULL;
5139
bf95233e
AS		 5140 INIT_LIST_HEAD(&rif->nexthop_list);
5141 INIT_LIST_HEAD(&rif->neigh_list);
5142 ether_addr_copy(rif->addr, l3_dev->dev_addr);
5143 rif->mtu = l3_dev->mtu;
5144 rif->vr_id = vr_id;
5145 rif->dev = l3_dev;
5146 rif->rif_index = rif_index;
4724ba56 5147
bf95233e 5148 return rif;
4724ba56
IS		 5149}
5150
5f9efffb
IS		 5151struct mlxsw_sp_rif *mlxsw_sp_rif_by_index(const struct mlxsw_sp *mlxsw_sp,
5152 u16 rif_index)
5153{
5154 return mlxsw_sp->router->rifs[rif_index];
5155}
5156
fd1b9d41
AS		 5157u16 mlxsw_sp_rif_index(const struct mlxsw_sp_rif *rif)
5158{
5159 return rif->rif_index;
5160}
5161
92107cfb
PM		 5162u16 mlxsw_sp_ipip_lb_rif_index(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
5163{
5164 return lb_rif->common.rif_index;
5165}
5166
5167u16 mlxsw_sp_ipip_lb_ul_vr_id(const struct mlxsw_sp_rif_ipip_lb *lb_rif)
5168{
5169 return lb_rif->ul_vr_id;
5170}
5171
fd1b9d41
AS		 5172int mlxsw_sp_rif_dev_ifindex(const struct mlxsw_sp_rif *rif)
5173{
5174 return rif->dev->ifindex;
5175}
5176
91e4d59a
YG		 5177const struct net_device *mlxsw_sp_rif_dev(const struct mlxsw_sp_rif *rif)
5178{
5179 return rif->dev;
5180}
5181
4724ba56 5182static struct mlxsw_sp_rif *
e4f3c1c1
IS		 5183mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp,
5184 const struct mlxsw_sp_rif_params *params)
4724ba56 5185{
e4f3c1c1
IS		 5186 u32 tb_id = l3mdev_fib_table(params->dev);
5187 const struct mlxsw_sp_rif_ops *ops;
010cadf9 5188 struct mlxsw_sp_fid *fid = NULL;
e4f3c1c1 5189 enum mlxsw_sp_rif_type type;
bf95233e 5190 struct mlxsw_sp_rif *rif;
a1107487
IS		 5191 struct mlxsw_sp_vr *vr;
5192 u16 rif_index;
4724ba56
IS		 5193 int err;
5194
e4f3c1c1
IS		 5195 type = mlxsw_sp_dev_rif_type(mlxsw_sp, params->dev);
5196 ops = mlxsw_sp->router->rif_ops_arr[type];
5197
c9ec53f0
IS		 5198 vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id ? : RT_TABLE_MAIN);
5199 if (IS_ERR(vr))
5200 return ERR_CAST(vr);
5201
de5ed99e
IS		 5202 err = mlxsw_sp_rif_index_alloc(mlxsw_sp, &rif_index);
5203 if (err)
5204 goto err_rif_index_alloc;
4724ba56 5205
e4f3c1c1 5206 rif = mlxsw_sp_rif_alloc(ops->rif_size, rif_index, vr->id, params->dev);
a13a594d
IS		 5207 if (!rif) {
5208 err = -ENOMEM;
5209 goto err_rif_alloc;
5210 }
e4f3c1c1
IS		 5211 rif->mlxsw_sp = mlxsw_sp;
5212 rif->ops = ops;
a13a594d 5213
010cadf9
PM		 5214 if (ops->fid_get) {
5215 fid = ops->fid_get(rif);
5216 if (IS_ERR(fid)) {
5217 err = PTR_ERR(fid);
5218 goto err_fid_get;
5219 }
5220 rif->fid = fid;
4d93ceeb
IS		 5221 }
5222
e4f3c1c1
IS		 5223 if (ops->setup)
5224 ops->setup(rif, params);
5225
5226 err = ops->configure(rif);
4724ba56 5227 if (err)
e4f3c1c1 5228 goto err_configure;
4724ba56 5229
e4f3c1c1 5230 mlxsw_sp_rif_counters_alloc(rif);
5f9efffb 5231 mlxsw_sp->router->rifs[rif_index] = rif;
6913229e 5232 vr->rif_count++;
4724ba56 5233
bf95233e 5234 return rif;
4724ba56 5235
e4f3c1c1 5236err_configure:
010cadf9
PM		 5237 if (fid)
5238 mlxsw_sp_fid_put(fid);
a1107487 5239err_fid_get:
e4f3c1c1
IS		 5240 kfree(rif);
5241err_rif_alloc:
de5ed99e 5242err_rif_index_alloc:
c9ec53f0 5243 mlxsw_sp_vr_put(vr);
4724ba56
IS		 5244 return ERR_PTR(err);
5245}
5246
e4f3c1c1 5247void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif)
4724ba56 5248{
e4f3c1c1
IS		 5249 const struct mlxsw_sp_rif_ops *ops = rif->ops;
5250 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
a1107487 5251 struct mlxsw_sp_fid *fid = rif->fid;
e4f3c1c1 5252 struct mlxsw_sp_vr *vr;
4724ba56 5253
bf95233e 5254 mlxsw_sp_router_rif_gone_sync(mlxsw_sp, rif);
e4f3c1c1 5255 vr = &mlxsw_sp->router->vrs[rif->vr_id];
e0c0afd8 5256
6913229e 5257 vr->rif_count--;
e4f3c1c1 5258 mlxsw_sp->router->rifs[rif->rif_index] = NULL;
e4f3c1c1 5259 mlxsw_sp_rif_counters_free(rif);
e4f3c1c1 5260 ops->deconfigure(rif);
010cadf9
PM		 5261 if (fid)
5262 /* Loopback RIFs are not associated with a FID. */
5263 mlxsw_sp_fid_put(fid);
e4f3c1c1 5264 kfree(rif);
c9ec53f0 5265 mlxsw_sp_vr_put(vr);
4724ba56
IS		 5266}
5267
e4f3c1c1
IS		 5268static void
5269mlxsw_sp_rif_subport_params_init(struct mlxsw_sp_rif_params *params,
5270 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
5271{
5272 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
5273
5274 params->vid = mlxsw_sp_port_vlan->vid;
5275 params->lag = mlxsw_sp_port->lagged;
5276 if (params->lag)
5277 params->lag_id = mlxsw_sp_port->lag_id;
5278 else
5279 params->system_port = mlxsw_sp_port->local_port;
5280}
5281
7cbecf24 5282static int
a1107487 5283mlxsw_sp_port_vlan_router_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
7cbecf24 5284 struct net_device *l3_dev)
4724ba56 5285{
7cbecf24 5286 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1b8f09a0 5287 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
7cbecf24 5288 u16 vid = mlxsw_sp_port_vlan->vid;
bf95233e 5289 struct mlxsw_sp_rif *rif;
a1107487 5290 struct mlxsw_sp_fid *fid;
03ea01e9 5291 int err;
4724ba56 5292
1b8f09a0 5293 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
bf95233e 5294 if (!rif) {
e4f3c1c1
IS		 5295 struct mlxsw_sp_rif_params params = {
5296 .dev = l3_dev,
5297 };
5298
5299 mlxsw_sp_rif_subport_params_init(&params, mlxsw_sp_port_vlan);
5300 rif = mlxsw_sp_rif_create(mlxsw_sp, &params);
bf95233e
AS		 5301 if (IS_ERR(rif))
5302 return PTR_ERR(rif);
4724ba56
IS		 5303 }
5304
a1107487 5305 /* FID was already created, just take a reference */
e4f3c1c1 5306 fid = rif->ops->fid_get(rif);
a1107487
IS		 5307 err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid);
5308 if (err)
5309 goto err_fid_port_vid_map;
5310
7cbecf24 5311 err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
03ea01e9
IS		 5312 if (err)
5313 goto err_port_vid_learning_set;
5314
7cbecf24 5315 err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid,
03ea01e9
IS		 5316 BR_STATE_FORWARDING);
5317 if (err)
5318 goto err_port_vid_stp_set;
5319
a1107487 5320 mlxsw_sp_port_vlan->fid = fid;
4724ba56 5321
4724ba56 5322 return 0;
03ea01e9
IS		 5323
5324err_port_vid_stp_set:
7cbecf24 5325 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
03ea01e9 5326err_port_vid_learning_set:
a1107487
IS		 5327 mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
5328err_fid_port_vid_map:
5329 mlxsw_sp_fid_put(fid);
03ea01e9 5330 return err;
4724ba56
IS		 5331}
5332
a1107487
IS		 5333void
5334mlxsw_sp_port_vlan_router_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
4724ba56 5335{
ce95e154 5336 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
7cbecf24 5337 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
ce95e154 5338 u16 vid = mlxsw_sp_port_vlan->vid;
ce95e154 5339
a1107487
IS		 5340 if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_RFID))
5341 return;
4aafc368 5342
a1107487 5343 mlxsw_sp_port_vlan->fid = NULL;
7cbecf24
IS		 5344 mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_BLOCKING);
5345 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
a1107487
IS		 5346 mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
5347 /* If router port holds the last reference on the rFID, then the
5348 * associated Sub-port RIF will be destroyed.
5349 */
5350 mlxsw_sp_fid_put(fid);
4724ba56
IS		 5351}
5352
7cbecf24
IS		 5353static int mlxsw_sp_inetaddr_port_vlan_event(struct net_device *l3_dev,
5354 struct net_device *port_dev,
5355 unsigned long event, u16 vid)
4724ba56
IS		 5356{
5357 struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(port_dev);
ce95e154 5358 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
4724ba56 5359
ce95e154 5360 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
7cbecf24
IS		 5361 if (WARN_ON(!mlxsw_sp_port_vlan))
5362 return -EINVAL;
4724ba56
IS		 5363
5364 switch (event) {
5365 case NETDEV_UP:
a1107487 5366 return mlxsw_sp_port_vlan_router_join(mlxsw_sp_port_vlan,
7cbecf24 5367 l3_dev);
4724ba56 5368 case NETDEV_DOWN:
a1107487 5369 mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
4724ba56
IS		 5370 break;
5371 }
5372
5373 return 0;
5374}
5375
5376static int mlxsw_sp_inetaddr_port_event(struct net_device *port_dev,
5377 unsigned long event)
5378{
2b94e58d
JP		 5379 if (netif_is_bridge_port(port_dev) ||
5380 netif_is_lag_port(port_dev) ||
5381 netif_is_ovs_port(port_dev))
4724ba56
IS		 5382 return 0;
5383
7cbecf24 5384 return mlxsw_sp_inetaddr_port_vlan_event(port_dev, port_dev, event, 1);
4724ba56
IS		 5385}
5386
5387static int __mlxsw_sp_inetaddr_lag_event(struct net_device *l3_dev,
5388 struct net_device *lag_dev,
5389 unsigned long event, u16 vid)
5390{
5391 struct net_device *port_dev;
5392 struct list_head *iter;
5393 int err;
5394
5395 netdev_for_each_lower_dev(lag_dev, port_dev, iter) {
5396 if (mlxsw_sp_port_dev_check(port_dev)) {
7cbecf24
IS		 5397 err = mlxsw_sp_inetaddr_port_vlan_event(l3_dev,
5398 port_dev,
5399 event, vid);
4724ba56
IS		 5400 if (err)
5401 return err;
5402 }
5403 }
5404
5405 return 0;
5406}
5407
5408static int mlxsw_sp_inetaddr_lag_event(struct net_device *lag_dev,
5409 unsigned long event)
5410{
5411 if (netif_is_bridge_port(lag_dev))
5412 return 0;
5413
5414 return __mlxsw_sp_inetaddr_lag_event(lag_dev, lag_dev, event, 1);
5415}
5416
4724ba56 5417static int mlxsw_sp_inetaddr_bridge_event(struct net_device *l3_dev,
4724ba56
IS		 5418 unsigned long event)
5419{
5420 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(l3_dev);
e4f3c1c1
IS		 5421 struct mlxsw_sp_rif_params params = {
5422 .dev = l3_dev,
5423 };
a1107487 5424 struct mlxsw_sp_rif *rif;
4724ba56
IS		 5425
5426 switch (event) {
5427 case NETDEV_UP:
e4f3c1c1
IS		 5428 rif = mlxsw_sp_rif_create(mlxsw_sp, &params);
5429 if (IS_ERR(rif))
5430 return PTR_ERR(rif);
5431 break;
4724ba56 5432 case NETDEV_DOWN:
a1107487 5433 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
e4f3c1c1 5434 mlxsw_sp_rif_destroy(rif);
4724ba56
IS		 5435 break;
5436 }
5437
5438 return 0;
5439}
5440
5441static int mlxsw_sp_inetaddr_vlan_event(struct net_device *vlan_dev,
5442 unsigned long event)
5443{
5444 struct net_device *real_dev = vlan_dev_real_dev(vlan_dev);
4724ba56
IS		 5445 u16 vid = vlan_dev_vlan_id(vlan_dev);
5446
6b27c8ad
IS		 5447 if (netif_is_bridge_port(vlan_dev))
5448 return 0;
5449
4724ba56 5450 if (mlxsw_sp_port_dev_check(real_dev))
7cbecf24
IS		 5451 return mlxsw_sp_inetaddr_port_vlan_event(vlan_dev, real_dev,
5452 event, vid);
4724ba56
IS		 5453 else if (netif_is_lag_master(real_dev))
5454 return __mlxsw_sp_inetaddr_lag_event(vlan_dev, real_dev, event,
5455 vid);
c57529e1 5456 else if (netif_is_bridge_master(real_dev) && br_vlan_enabled(real_dev))
a1107487 5457 return mlxsw_sp_inetaddr_bridge_event(vlan_dev, event);
4724ba56
IS		 5458
5459 return 0;
5460}
5461
b1e45526
IS		 5462static int __mlxsw_sp_inetaddr_event(struct net_device *dev,
5463 unsigned long event)
5464{
5465 if (mlxsw_sp_port_dev_check(dev))
5466 return mlxsw_sp_inetaddr_port_event(dev, event);
5467 else if (netif_is_lag_master(dev))
5468 return mlxsw_sp_inetaddr_lag_event(dev, event);
5469 else if (netif_is_bridge_master(dev))
a1107487 5470 return mlxsw_sp_inetaddr_bridge_event(dev, event);
b1e45526
IS		 5471 else if (is_vlan_dev(dev))
5472 return mlxsw_sp_inetaddr_vlan_event(dev, event);
5473 else
5474 return 0;
5475}
5476
4724ba56
IS		 5477int mlxsw_sp_inetaddr_event(struct notifier_block *unused,
5478 unsigned long event, void *ptr)
5479{
5480 struct in_ifaddr *ifa = (struct in_ifaddr *) ptr;
5481 struct net_device *dev = ifa->ifa_dev->dev;
5482 struct mlxsw_sp *mlxsw_sp;
bf95233e 5483 struct mlxsw_sp_rif *rif;
4724ba56
IS		 5484 int err = 0;
5485
5486 mlxsw_sp = mlxsw_sp_lower_get(dev);
5487 if (!mlxsw_sp)
5488 goto out;
5489
bf95233e 5490 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
5ea1237f 5491 if (!mlxsw_sp_rif_should_config(rif, dev, event))
4724ba56
IS		 5492 goto out;
5493
b1e45526 5494 err = __mlxsw_sp_inetaddr_event(dev, event);
4724ba56
IS		 5495out:
5496 return notifier_from_errno(err);
5497}
5498
5ea1237f
AS		 5499struct mlxsw_sp_inet6addr_event_work {
5500 struct work_struct work;
5501 struct net_device *dev;
5502 unsigned long event;
5503};
5504
5505static void mlxsw_sp_inet6addr_event_work(struct work_struct *work)
5506{
5507 struct mlxsw_sp_inet6addr_event_work *inet6addr_work =
5508 container_of(work, struct mlxsw_sp_inet6addr_event_work, work);
5509 struct net_device *dev = inet6addr_work->dev;
5510 unsigned long event = inet6addr_work->event;
5511 struct mlxsw_sp *mlxsw_sp;
5512 struct mlxsw_sp_rif *rif;
5513
5514 rtnl_lock();
5515 mlxsw_sp = mlxsw_sp_lower_get(dev);
5516 if (!mlxsw_sp)
5517 goto out;
5518
5519 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
5520 if (!mlxsw_sp_rif_should_config(rif, dev, event))
5521 goto out;
5522
5523 __mlxsw_sp_inetaddr_event(dev, event);
5524out:
5525 rtnl_unlock();
5526 dev_put(dev);
5527 kfree(inet6addr_work);
5528}
5529
5530/* Called with rcu_read_lock() */
5531int mlxsw_sp_inet6addr_event(struct notifier_block *unused,
5532 unsigned long event, void *ptr)
5533{
5534 struct inet6_ifaddr *if6 = (struct inet6_ifaddr *) ptr;
5535 struct mlxsw_sp_inet6addr_event_work *inet6addr_work;
5536 struct net_device *dev = if6->idev->dev;
5537
5538 if (!mlxsw_sp_port_dev_lower_find_rcu(dev))
5539 return NOTIFY_DONE;
5540
5541 inet6addr_work = kzalloc(sizeof(*inet6addr_work), GFP_ATOMIC);
5542 if (!inet6addr_work)
5543 return NOTIFY_BAD;
5544
5545 INIT_WORK(&inet6addr_work->work, mlxsw_sp_inet6addr_event_work);
5546 inet6addr_work->dev = dev;
5547 inet6addr_work->event = event;
5548 dev_hold(dev);
5549 mlxsw_core_schedule_work(&inet6addr_work->work);
5550
5551 return NOTIFY_DONE;
5552}
5553
bf95233e 5554static int mlxsw_sp_rif_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
4724ba56
IS		 5555 const char *mac, int mtu)
5556{
5557 char ritr_pl[MLXSW_REG_RITR_LEN];
5558 int err;
5559
bf95233e 5560 mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
4724ba56
IS		 5561 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5562 if (err)
5563 return err;
5564
5565 mlxsw_reg_ritr_mtu_set(ritr_pl, mtu);
5566 mlxsw_reg_ritr_if_mac_memcpy_to(ritr_pl, mac);
5567 mlxsw_reg_ritr_op_set(ritr_pl, MLXSW_REG_RITR_RIF_CREATE);
5568 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5569}
5570
5571int mlxsw_sp_netdevice_router_port_event(struct net_device *dev)
5572{
5573 struct mlxsw_sp *mlxsw_sp;
bf95233e 5574 struct mlxsw_sp_rif *rif;
a1107487 5575 u16 fid_index;
4724ba56
IS		 5576 int err;
5577
5578 mlxsw_sp = mlxsw_sp_lower_get(dev);
5579 if (!mlxsw_sp)
5580 return 0;
5581
bf95233e
AS		 5582 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
5583 if (!rif)
4724ba56 5584 return 0;
a1107487 5585 fid_index = mlxsw_sp_fid_index(rif->fid);
4724ba56 5586
a1107487 5587 err = mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, false);
4724ba56
IS		 5588 if (err)
5589 return err;
5590
bf95233e
AS		 5591 err = mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, dev->dev_addr,
5592 dev->mtu);
4724ba56
IS		 5593 if (err)
5594 goto err_rif_edit;
5595
a1107487 5596 err = mlxsw_sp_rif_fdb_op(mlxsw_sp, dev->dev_addr, fid_index, true);
4724ba56
IS		 5597 if (err)
5598 goto err_rif_fdb_op;
5599
bf95233e
AS		 5600 ether_addr_copy(rif->addr, dev->dev_addr);
5601 rif->mtu = dev->mtu;
4724ba56 5602
bf95233e 5603 netdev_dbg(dev, "Updated RIF=%d\n", rif->rif_index);
4724ba56
IS		 5604
5605 return 0;
5606
5607err_rif_fdb_op:
bf95233e 5608 mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, rif->addr, rif->mtu);
4724ba56 5609err_rif_edit:
a1107487 5610 mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, true);
4724ba56
IS		 5611 return err;
5612}
5613
b1e45526
IS		 5614static int mlxsw_sp_port_vrf_join(struct mlxsw_sp *mlxsw_sp,
5615 struct net_device *l3_dev)
7179eb5a 5616{
b1e45526 5617 struct mlxsw_sp_rif *rif;
7179eb5a 5618
b1e45526
IS		 5619 /* If netdev is already associated with a RIF, then we need to
5620 * destroy it and create a new one with the new virtual router ID.
7179eb5a 5621 */
b1e45526
IS		 5622 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
5623 if (rif)
5624 __mlxsw_sp_inetaddr_event(l3_dev, NETDEV_DOWN);
7179eb5a 5625
b1e45526 5626 return __mlxsw_sp_inetaddr_event(l3_dev, NETDEV_UP);
7179eb5a
IS		 5627}
5628
b1e45526
IS		 5629static void mlxsw_sp_port_vrf_leave(struct mlxsw_sp *mlxsw_sp,
5630 struct net_device *l3_dev)
7179eb5a 5631{
b1e45526 5632 struct mlxsw_sp_rif *rif;
7179eb5a 5633
b1e45526
IS		 5634 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
5635 if (!rif)
7179eb5a 5636 return;
b1e45526 5637 __mlxsw_sp_inetaddr_event(l3_dev, NETDEV_DOWN);
7179eb5a
IS		 5638}
5639
b1e45526
IS		 5640int mlxsw_sp_netdevice_vrf_event(struct net_device *l3_dev, unsigned long event,
5641 struct netdev_notifier_changeupper_info *info)
3d70e458 5642{
b1e45526
IS		 5643 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(l3_dev);
5644 int err = 0;
3d70e458 5645
b1e45526
IS		 5646 if (!mlxsw_sp)
5647 return 0;
3d70e458 5648
b1e45526
IS		 5649 switch (event) {
5650 case NETDEV_PRECHANGEUPPER:
5651 return 0;
5652 case NETDEV_CHANGEUPPER:
5653 if (info->linking)
5654 err = mlxsw_sp_port_vrf_join(mlxsw_sp, l3_dev);
5655 else
5656 mlxsw_sp_port_vrf_leave(mlxsw_sp, l3_dev);
5657 break;
5658 }
3d70e458 5659
b1e45526 5660 return err;
3d70e458
IS		 5661}
5662
e4f3c1c1
IS		 5663static struct mlxsw_sp_rif_subport *
5664mlxsw_sp_rif_subport_rif(const struct mlxsw_sp_rif *rif)
a1107487 5665{
e4f3c1c1
IS		 5666 return container_of(rif, struct mlxsw_sp_rif_subport, common);
5667}
5668
5669static void mlxsw_sp_rif_subport_setup(struct mlxsw_sp_rif *rif,
5670 const struct mlxsw_sp_rif_params *params)
5671{
5672 struct mlxsw_sp_rif_subport *rif_subport;
5673
5674 rif_subport = mlxsw_sp_rif_subport_rif(rif);
5675 rif_subport->vid = params->vid;
5676 rif_subport->lag = params->lag;
5677 if (params->lag)
5678 rif_subport->lag_id = params->lag_id;
a1107487 5679 else
e4f3c1c1
IS		 5680 rif_subport->system_port = params->system_port;
5681}
5682
5683static int mlxsw_sp_rif_subport_op(struct mlxsw_sp_rif *rif, bool enable)
5684{
5685 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5686 struct mlxsw_sp_rif_subport *rif_subport;
5687 char ritr_pl[MLXSW_REG_RITR_LEN];
5688
5689 rif_subport = mlxsw_sp_rif_subport_rif(rif);
5690 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_SP_IF,
9571e828
PM		 5691 rif->rif_index, rif->vr_id, rif->dev->mtu);
5692 mlxsw_reg_ritr_mac_pack(ritr_pl, rif->dev->dev_addr);
e4f3c1c1
IS		 5693 mlxsw_reg_ritr_sp_if_pack(ritr_pl, rif_subport->lag,
5694 rif_subport->lag ? rif_subport->lag_id :
5695 rif_subport->system_port,
5696 rif_subport->vid);
5697
5698 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5699}
5700
5701static int mlxsw_sp_rif_subport_configure(struct mlxsw_sp_rif *rif)
5702{
010cadf9
PM		 5703 int err;
5704
5705 err = mlxsw_sp_rif_subport_op(rif, true);
5706 if (err)
5707 return err;
5708
5709 err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5710 mlxsw_sp_fid_index(rif->fid), true);
5711 if (err)
5712 goto err_rif_fdb_op;
5713
5714 mlxsw_sp_fid_rif_set(rif->fid, rif);
5715 return 0;
5716
5717err_rif_fdb_op:
5718 mlxsw_sp_rif_subport_op(rif, false);
5719 return err;
a1107487
IS		 5720}
5721
e4f3c1c1
IS		 5722static void mlxsw_sp_rif_subport_deconfigure(struct mlxsw_sp_rif *rif)
5723{
010cadf9
PM		 5724 struct mlxsw_sp_fid *fid = rif->fid;
5725
5726 mlxsw_sp_fid_rif_set(fid, NULL);
5727 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5728 mlxsw_sp_fid_index(fid), false);
e4f3c1c1
IS		 5729 mlxsw_sp_rif_subport_op(rif, false);
5730}
5731
5732static struct mlxsw_sp_fid *
5733mlxsw_sp_rif_subport_fid_get(struct mlxsw_sp_rif *rif)
5734{
5735 return mlxsw_sp_fid_rfid_get(rif->mlxsw_sp, rif->rif_index);
5736}
5737
5738static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_subport_ops = {
5739 .type = MLXSW_SP_RIF_TYPE_SUBPORT,
5740 .rif_size = sizeof(struct mlxsw_sp_rif_subport),
5741 .setup = mlxsw_sp_rif_subport_setup,
5742 .configure = mlxsw_sp_rif_subport_configure,
5743 .deconfigure = mlxsw_sp_rif_subport_deconfigure,
5744 .fid_get = mlxsw_sp_rif_subport_fid_get,
5745};
5746
5747static int mlxsw_sp_rif_vlan_fid_op(struct mlxsw_sp_rif *rif,
5748 enum mlxsw_reg_ritr_if_type type,
5749 u16 vid_fid, bool enable)
5750{
5751 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5752 char ritr_pl[MLXSW_REG_RITR_LEN];
5753
5754 mlxsw_reg_ritr_pack(ritr_pl, enable, type, rif->rif_index, rif->vr_id,
9571e828
PM		 5755 rif->dev->mtu);
5756 mlxsw_reg_ritr_mac_pack(ritr_pl, rif->dev->dev_addr);
e4f3c1c1
IS		 5757 mlxsw_reg_ritr_fid_set(ritr_pl, type, vid_fid);
5758
5759 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5760}
5761
5762static u8 mlxsw_sp_router_port(const struct mlxsw_sp *mlxsw_sp)
5763{
5764 return mlxsw_core_max_ports(mlxsw_sp->core) + 1;
5765}
5766
5767static int mlxsw_sp_rif_vlan_configure(struct mlxsw_sp_rif *rif)
5768{
5769 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5770 u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
5771 int err;
5772
5773 err = mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, true);
5774 if (err)
5775 return err;
5776
0d284818
IS		 5777 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5778 mlxsw_sp_router_port(mlxsw_sp), true);
5779 if (err)
5780 goto err_fid_mc_flood_set;
5781
e4f3c1c1
IS		 5782 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5783 mlxsw_sp_router_port(mlxsw_sp), true);
5784 if (err)
5785 goto err_fid_bc_flood_set;
5786
010cadf9
PM		 5787 err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5788 mlxsw_sp_fid_index(rif->fid), true);
5789 if (err)
5790 goto err_rif_fdb_op;
5791
5792 mlxsw_sp_fid_rif_set(rif->fid, rif);
e4f3c1c1
IS		 5793 return 0;
5794
010cadf9
PM		 5795err_rif_fdb_op:
5796 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5797 mlxsw_sp_router_port(mlxsw_sp), false);
e4f3c1c1 5798err_fid_bc_flood_set:
0d284818
IS		 5799 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5800 mlxsw_sp_router_port(mlxsw_sp), false);
5801err_fid_mc_flood_set:
e4f3c1c1
IS		 5802 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, false);
5803 return err;
5804}
5805
5806static void mlxsw_sp_rif_vlan_deconfigure(struct mlxsw_sp_rif *rif)
5807{
e4f3c1c1 5808 u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
010cadf9
PM		 5809 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5810 struct mlxsw_sp_fid *fid = rif->fid;
e4f3c1c1 5811
010cadf9
PM		 5812 mlxsw_sp_fid_rif_set(fid, NULL);
5813 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5814 mlxsw_sp_fid_index(fid), false);
e4f3c1c1
IS		 5815 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5816 mlxsw_sp_router_port(mlxsw_sp), false);
0d284818
IS		 5817 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5818 mlxsw_sp_router_port(mlxsw_sp), false);
e4f3c1c1
IS		 5819 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, false);
5820}
5821
5822static struct mlxsw_sp_fid *
5823mlxsw_sp_rif_vlan_fid_get(struct mlxsw_sp_rif *rif)
5824{
5825 u16 vid = is_vlan_dev(rif->dev) ? vlan_dev_vlan_id(rif->dev) : 1;
5826
5827 return mlxsw_sp_fid_8021q_get(rif->mlxsw_sp, vid);
5828}
5829
5830static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_vlan_ops = {
5831 .type = MLXSW_SP_RIF_TYPE_VLAN,
5832 .rif_size = sizeof(struct mlxsw_sp_rif),
5833 .configure = mlxsw_sp_rif_vlan_configure,
5834 .deconfigure = mlxsw_sp_rif_vlan_deconfigure,
5835 .fid_get = mlxsw_sp_rif_vlan_fid_get,
5836};
5837
5838static int mlxsw_sp_rif_fid_configure(struct mlxsw_sp_rif *rif)
5839{
5840 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5841 u16 fid_index = mlxsw_sp_fid_index(rif->fid);
5842 int err;
5843
5844 err = mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index,
5845 true);
5846 if (err)
5847 return err;
5848
0d284818
IS		 5849 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5850 mlxsw_sp_router_port(mlxsw_sp), true);
5851 if (err)
5852 goto err_fid_mc_flood_set;
5853
e4f3c1c1
IS		 5854 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5855 mlxsw_sp_router_port(mlxsw_sp), true);
5856 if (err)
5857 goto err_fid_bc_flood_set;
5858
010cadf9
PM		 5859 err = mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5860 mlxsw_sp_fid_index(rif->fid), true);
5861 if (err)
5862 goto err_rif_fdb_op;
5863
5864 mlxsw_sp_fid_rif_set(rif->fid, rif);
e4f3c1c1
IS		 5865 return 0;
5866
010cadf9
PM		 5867err_rif_fdb_op:
5868 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5869 mlxsw_sp_router_port(mlxsw_sp), false);
e4f3c1c1 5870err_fid_bc_flood_set:
0d284818
IS		 5871 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5872 mlxsw_sp_router_port(mlxsw_sp), false);
5873err_fid_mc_flood_set:
e4f3c1c1
IS		 5874 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index, false);
5875 return err;
5876}
5877
5878static void mlxsw_sp_rif_fid_deconfigure(struct mlxsw_sp_rif *rif)
5879{
e4f3c1c1 5880 u16 fid_index = mlxsw_sp_fid_index(rif->fid);
010cadf9
PM		 5881 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5882 struct mlxsw_sp_fid *fid = rif->fid;
e4f3c1c1 5883
010cadf9
PM		 5884 mlxsw_sp_fid_rif_set(fid, NULL);
5885 mlxsw_sp_rif_fdb_op(rif->mlxsw_sp, rif->dev->dev_addr,
5886 mlxsw_sp_fid_index(fid), false);
e4f3c1c1
IS		 5887 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
5888 mlxsw_sp_router_port(mlxsw_sp), false);
0d284818
IS		 5889 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
5890 mlxsw_sp_router_port(mlxsw_sp), false);
e4f3c1c1
IS		 5891 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index, false);
5892}
5893
5894static struct mlxsw_sp_fid *
5895mlxsw_sp_rif_fid_fid_get(struct mlxsw_sp_rif *rif)
5896{
5897 return mlxsw_sp_fid_8021d_get(rif->mlxsw_sp, rif->dev->ifindex);
5898}
5899
5900static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_fid_ops = {
5901 .type = MLXSW_SP_RIF_TYPE_FID,
5902 .rif_size = sizeof(struct mlxsw_sp_rif),
5903 .configure = mlxsw_sp_rif_fid_configure,
5904 .deconfigure = mlxsw_sp_rif_fid_deconfigure,
5905 .fid_get = mlxsw_sp_rif_fid_fid_get,
5906};
5907
6ddb7426
PM		 5908static struct mlxsw_sp_rif_ipip_lb *
5909mlxsw_sp_rif_ipip_lb_rif(struct mlxsw_sp_rif *rif)
5910{
5911 return container_of(rif, struct mlxsw_sp_rif_ipip_lb, common);
5912}
5913
5914static void
5915mlxsw_sp_rif_ipip_lb_setup(struct mlxsw_sp_rif *rif,
5916 const struct mlxsw_sp_rif_params *params)
5917{
5918 struct mlxsw_sp_rif_params_ipip_lb *params_lb;
5919 struct mlxsw_sp_rif_ipip_lb *rif_lb;
5920
5921 params_lb = container_of(params, struct mlxsw_sp_rif_params_ipip_lb,
5922 common);
5923 rif_lb = mlxsw_sp_rif_ipip_lb_rif(rif);
5924 rif_lb->lb_config = params_lb->lb_config;
5925}
5926
5927static int
5928mlxsw_sp_rif_ipip_lb_op(struct mlxsw_sp_rif_ipip_lb *lb_rif,
5929 struct mlxsw_sp_vr *ul_vr, bool enable)
5930{
5931 struct mlxsw_sp_rif_ipip_lb_config lb_cf = lb_rif->lb_config;
5932 struct mlxsw_sp_rif *rif = &lb_rif->common;
5933 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5934 char ritr_pl[MLXSW_REG_RITR_LEN];
5935 u32 saddr4;
5936
5937 switch (lb_cf.ul_protocol) {
5938 case MLXSW_SP_L3_PROTO_IPV4:
5939 saddr4 = be32_to_cpu(lb_cf.saddr.addr4);
5940 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_LOOPBACK_IF,
5941 rif->rif_index, rif->vr_id, rif->dev->mtu);
5942 mlxsw_reg_ritr_loopback_ipip4_pack(ritr_pl, lb_cf.lb_ipipt,
5943 MLXSW_REG_RITR_LOOPBACK_IPIP_OPTIONS_GRE_KEY_PRESET,
5944 ul_vr->id, saddr4, lb_cf.okey);
5945 break;
5946
5947 case MLXSW_SP_L3_PROTO_IPV6:
5948 return -EAFNOSUPPORT;
5949 }
5950
5951 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
5952}
5953
5954static int
5955mlxsw_sp_rif_ipip_lb_configure(struct mlxsw_sp_rif *rif)
5956{
5957 struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
5958 u32 ul_tb_id = mlxsw_sp_ipip_dev_ul_tb_id(rif->dev);
5959 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5960 struct mlxsw_sp_vr *ul_vr;
5961 int err;
5962
5963 ul_vr = mlxsw_sp_vr_get(mlxsw_sp, ul_tb_id);
5964 if (IS_ERR(ul_vr))
5965 return PTR_ERR(ul_vr);
5966
5967 err = mlxsw_sp_rif_ipip_lb_op(lb_rif, ul_vr, true);
5968 if (err)
5969 goto err_loopback_op;
5970
5971 lb_rif->ul_vr_id = ul_vr->id;
5972 ++ul_vr->rif_count;
5973 return 0;
5974
5975err_loopback_op:
5976 mlxsw_sp_vr_put(ul_vr);
5977 return err;
5978}
5979
5980static void mlxsw_sp_rif_ipip_lb_deconfigure(struct mlxsw_sp_rif *rif)
5981{
5982 struct mlxsw_sp_rif_ipip_lb *lb_rif = mlxsw_sp_rif_ipip_lb_rif(rif);
5983 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
5984 struct mlxsw_sp_vr *ul_vr;
5985
5986 ul_vr = &mlxsw_sp->router->vrs[lb_rif->ul_vr_id];
5987 mlxsw_sp_rif_ipip_lb_op(lb_rif, ul_vr, false);
5988
5989 --ul_vr->rif_count;
5990 mlxsw_sp_vr_put(ul_vr);
5991}
5992
5993static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_ipip_lb_ops = {
5994 .type = MLXSW_SP_RIF_TYPE_IPIP_LB,
5995 .rif_size = sizeof(struct mlxsw_sp_rif_ipip_lb),
5996 .setup = mlxsw_sp_rif_ipip_lb_setup,
5997 .configure = mlxsw_sp_rif_ipip_lb_configure,
5998 .deconfigure = mlxsw_sp_rif_ipip_lb_deconfigure,
5999};
6000
e4f3c1c1
IS		 6001static const struct mlxsw_sp_rif_ops *mlxsw_sp_rif_ops_arr[] = {
6002 [MLXSW_SP_RIF_TYPE_SUBPORT] = &mlxsw_sp_rif_subport_ops,
6003 [MLXSW_SP_RIF_TYPE_VLAN] = &mlxsw_sp_rif_vlan_ops,
6004 [MLXSW_SP_RIF_TYPE_FID] = &mlxsw_sp_rif_fid_ops,
6ddb7426 6005 [MLXSW_SP_RIF_TYPE_IPIP_LB] = &mlxsw_sp_rif_ipip_lb_ops,
e4f3c1c1
IS		 6006};
6007
348b8fc3
IS		 6008static int mlxsw_sp_rifs_init(struct mlxsw_sp *mlxsw_sp)
6009{
6010 u64 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
6011
6012 mlxsw_sp->router->rifs = kcalloc(max_rifs,
6013 sizeof(struct mlxsw_sp_rif *),
6014 GFP_KERNEL);
6015 if (!mlxsw_sp->router->rifs)
6016 return -ENOMEM;
e4f3c1c1
IS		 6017
6018 mlxsw_sp->router->rif_ops_arr = mlxsw_sp_rif_ops_arr;
6019
348b8fc3
IS		 6020 return 0;
6021}
6022
6023static void mlxsw_sp_rifs_fini(struct mlxsw_sp *mlxsw_sp)
6024{
6025 int i;
6026
6027 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++)
6028 WARN_ON_ONCE(mlxsw_sp->router->rifs[i]);
6029
6030 kfree(mlxsw_sp->router->rifs);
6031}
6032
38ebc0f4
PM		 6033static int mlxsw_sp_ipips_init(struct mlxsw_sp *mlxsw_sp)
6034{
6035 mlxsw_sp->router->ipip_ops_arr = mlxsw_sp_ipip_ops_arr;
1012b9ac 6036 INIT_LIST_HEAD(&mlxsw_sp->router->ipip_list);
38ebc0f4
PM		 6037 return 0;
6038}
6039
6040static void mlxsw_sp_ipips_fini(struct mlxsw_sp *mlxsw_sp)
6041{
1012b9ac 6042 WARN_ON(!list_empty(&mlxsw_sp->router->ipip_list));
38ebc0f4
PM		 6043}
6044
c3852ef7
IS		 6045static void mlxsw_sp_router_fib_dump_flush(struct notifier_block *nb)
6046{
7e39d115 6047 struct mlxsw_sp_router *router;
c3852ef7
IS		 6048
6049 /* Flush pending FIB notifications and then flush the device's
6050 * table before requesting another dump. The FIB notification
6051 * block is unregistered, so no need to take RTNL.
6052 */
6053 mlxsw_core_flush_owq();
7e39d115
IS		 6054 router = container_of(nb, struct mlxsw_sp_router, fib_nb);
6055 mlxsw_sp_router_fib_flush(router->mlxsw_sp);
c3852ef7
IS		 6056}
6057
4724ba56
IS		 6058static int __mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp)
6059{
6060 char rgcr_pl[MLXSW_REG_RGCR_LEN];
6061 u64 max_rifs;
6062 int err;
6063
6064 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_RIFS))
6065 return -EIO;
4724ba56 6066 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
4724ba56 6067
e29237e7 6068 mlxsw_reg_rgcr_pack(rgcr_pl, true, true);
4724ba56
IS		 6069 mlxsw_reg_rgcr_max_router_interfaces_set(rgcr_pl, max_rifs);
6070 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
6071 if (err)
348b8fc3 6072 return err;
4724ba56 6073 return 0;
4724ba56
IS		 6074}
6075
6076static void __mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
6077{
6078 char rgcr_pl[MLXSW_REG_RGCR_LEN];
4724ba56 6079
e29237e7 6080 mlxsw_reg_rgcr_pack(rgcr_pl, false, false);
4724ba56 6081 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
4724ba56
IS		 6082}
6083
b45f64d1
JP		 6084int mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp)
6085{
9011b677 6086 struct mlxsw_sp_router *router;
b45f64d1
JP		 6087 int err;
6088
9011b677
IS		 6089 router = kzalloc(sizeof(*mlxsw_sp->router), GFP_KERNEL);
6090 if (!router)
6091 return -ENOMEM;
6092 mlxsw_sp->router = router;
6093 router->mlxsw_sp = mlxsw_sp;
6094
6095 INIT_LIST_HEAD(&mlxsw_sp->router->nexthop_neighs_list);
b45f64d1
JP		 6096 err = __mlxsw_sp_router_init(mlxsw_sp);
6097 if (err)
9011b677 6098 goto err_router_init;
b45f64d1 6099
348b8fc3
IS		 6100 err = mlxsw_sp_rifs_init(mlxsw_sp);
6101 if (err)
6102 goto err_rifs_init;
6103
38ebc0f4
PM		 6104 err = mlxsw_sp_ipips_init(mlxsw_sp);
6105 if (err)
6106 goto err_ipips_init;
6107
9011b677 6108 err = rhashtable_init(&mlxsw_sp->router->nexthop_ht,
c53b8e1b
IS		 6109 &mlxsw_sp_nexthop_ht_params);
6110 if (err)
6111 goto err_nexthop_ht_init;
6112
9011b677 6113 err = rhashtable_init(&mlxsw_sp->router->nexthop_group_ht,
e9ad5e7d
IS		 6114 &mlxsw_sp_nexthop_group_ht_params);
6115 if (err)
6116 goto err_nexthop_group_ht_init;
6117
dbe4598c 6118 INIT_LIST_HEAD(&mlxsw_sp->router->nexthop_list);
8494ab06
IS		 6119 err = mlxsw_sp_lpm_init(mlxsw_sp);
6120 if (err)
6121 goto err_lpm_init;
6122
b45f64d1
JP		 6123 err = mlxsw_sp_vrs_init(mlxsw_sp);
6124 if (err)
6125 goto err_vrs_init;
6126
8c9583a8 6127 err = mlxsw_sp_neigh_init(mlxsw_sp);
b45f64d1
JP		 6128 if (err)
6129 goto err_neigh_init;
6130
7e39d115
IS		 6131 mlxsw_sp->router->fib_nb.notifier_call = mlxsw_sp_router_fib_event;
6132 err = register_fib_notifier(&mlxsw_sp->router->fib_nb,
c3852ef7
IS		 6133 mlxsw_sp_router_fib_dump_flush);
6134 if (err)
6135 goto err_register_fib_notifier;
6136
b45f64d1
JP		 6137 return 0;
6138
c3852ef7
IS		 6139err_register_fib_notifier:
6140 mlxsw_sp_neigh_fini(mlxsw_sp);
b45f64d1
JP		 6141err_neigh_init:
6142 mlxsw_sp_vrs_fini(mlxsw_sp);
6143err_vrs_init:
8494ab06
IS		 6144 mlxsw_sp_lpm_fini(mlxsw_sp);
6145err_lpm_init:
9011b677 6146 rhashtable_destroy(&mlxsw_sp->router->nexthop_group_ht);
e9ad5e7d 6147err_nexthop_group_ht_init:
9011b677 6148 rhashtable_destroy(&mlxsw_sp->router->nexthop_ht);
c53b8e1b 6149err_nexthop_ht_init:
38ebc0f4
PM		 6150 mlxsw_sp_ipips_fini(mlxsw_sp);
6151err_ipips_init:
348b8fc3
IS		 6152 mlxsw_sp_rifs_fini(mlxsw_sp);
6153err_rifs_init:
b45f64d1 6154 __mlxsw_sp_router_fini(mlxsw_sp);
9011b677
IS		 6155err_router_init:
6156 kfree(mlxsw_sp->router);
b45f64d1
JP		 6157 return err;
6158}
6159
6160void mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
6161{
7e39d115 6162 unregister_fib_notifier(&mlxsw_sp->router->fib_nb);
b45f64d1
JP		 6163 mlxsw_sp_neigh_fini(mlxsw_sp);
6164 mlxsw_sp_vrs_fini(mlxsw_sp);
8494ab06 6165 mlxsw_sp_lpm_fini(mlxsw_sp);
9011b677
IS		 6166 rhashtable_destroy(&mlxsw_sp->router->nexthop_group_ht);
6167 rhashtable_destroy(&mlxsw_sp->router->nexthop_ht);
38ebc0f4 6168 mlxsw_sp_ipips_fini(mlxsw_sp);
348b8fc3 6169 mlxsw_sp_rifs_fini(mlxsw_sp);
b45f64d1 6170 __mlxsw_sp_router_fini(mlxsw_sp);
9011b677 6171 kfree(mlxsw_sp->router);
b45f64d1 6172}
Linux 6.x block layer and io_uring tree(s)