]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mlxsw: spectrum_router: Simplify a piece of code
[mirror_ubuntu-bionic-kernel.git] / drivers / net / ethernet / mellanox / mlxsw / spectrum_router.c
CommitLineData
464dce18
IS		 1/*
2 * drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c
3 * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
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>
464dce18
IS		 7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the names of the copyright holders nor the names of its
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
19 *
20 * Alternatively, this software may be distributed under the terms of the
21 * GNU General Public License ("GPL") version 2 as published by the Free
22 * Software Foundation.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
35 */
36
37#include <linux/kernel.h>
38#include <linux/types.h>
5e9c16cc
JP		 39#include <linux/rhashtable.h>
40#include <linux/bitops.h>
41#include <linux/in6.h>
c723c735 42#include <linux/notifier.h>
df6dd79b 43#include <linux/inetdevice.h>
9db032bb 44#include <linux/netdevice.h>
03ea01e9 45#include <linux/if_bridge.h>
b5f3e0d4 46#include <linux/socket.h>
c723c735 47#include <net/netevent.h>
6cf3c971
JP		 48#include <net/neighbour.h>
49#include <net/arp.h>
b45f64d1 50#include <net/ip_fib.h>
5d7bfd14 51#include <net/fib_rules.h>
57837885 52#include <net/l3mdev.h>
5ea1237f 53#include <net/addrconf.h>
d5eb89cf
AS		 54#include <net/ndisc.h>
55#include <net/ipv6.h>
464dce18
IS		 56
57#include "spectrum.h"
58#include "core.h"
59#include "reg.h"
e0c0afd8
AS		 60#include "spectrum_cnt.h"
61#include "spectrum_dpipe.h"
62#include "spectrum_router.h"
464dce18 63
9011b677
IS		 64struct mlxsw_sp_vr;
65struct mlxsw_sp_lpm_tree;
e4f3c1c1 66struct mlxsw_sp_rif_ops;
9011b677
IS		 67
68struct mlxsw_sp_router {
69 struct mlxsw_sp *mlxsw_sp;
5f9efffb 70 struct mlxsw_sp_rif **rifs;
9011b677
IS		 71 struct mlxsw_sp_vr *vrs;
72 struct rhashtable neigh_ht;
73 struct rhashtable nexthop_group_ht;
74 struct rhashtable nexthop_ht;
75 struct {
76 struct mlxsw_sp_lpm_tree *trees;
77 unsigned int tree_count;
78 } lpm;
79 struct {
80 struct delayed_work dw;
81 unsigned long interval; /* ms */
82 } neighs_update;
83 struct delayed_work nexthop_probe_dw;
84#define MLXSW_SP_UNRESOLVED_NH_PROBE_INTERVAL 5000 /* ms */
85 struct list_head nexthop_neighs_list;
86 bool aborted;
7e39d115 87 struct notifier_block fib_nb;
e4f3c1c1 88 const struct mlxsw_sp_rif_ops **rif_ops_arr;
9011b677
IS		 89};
90
4724ba56
IS		 91struct mlxsw_sp_rif {
92 struct list_head nexthop_list;
93 struct list_head neigh_list;
94 struct net_device *dev;
a1107487 95 struct mlxsw_sp_fid *fid;
4724ba56
IS		 96 unsigned char addr[ETH_ALEN];
97 int mtu;
bf95233e 98 u16 rif_index;
6913229e 99 u16 vr_id;
e4f3c1c1
IS		 100 const struct mlxsw_sp_rif_ops *ops;
101 struct mlxsw_sp *mlxsw_sp;
102
e0c0afd8
AS		 103 unsigned int counter_ingress;
104 bool counter_ingress_valid;
105 unsigned int counter_egress;
106 bool counter_egress_valid;
4724ba56
IS		 107};
108
e4f3c1c1
IS		 109struct mlxsw_sp_rif_params {
110 struct net_device *dev;
111 union {
112 u16 system_port;
113 u16 lag_id;
114 };
115 u16 vid;
116 bool lag;
117};
118
4d93ceeb
IS		 119struct mlxsw_sp_rif_subport {
120 struct mlxsw_sp_rif common;
121 union {
122 u16 system_port;
123 u16 lag_id;
124 };
125 u16 vid;
126 bool lag;
127};
128
e4f3c1c1
IS		 129struct mlxsw_sp_rif_ops {
130 enum mlxsw_sp_rif_type type;
131 size_t rif_size;
132
133 void (*setup)(struct mlxsw_sp_rif *rif,
134 const struct mlxsw_sp_rif_params *params);
135 int (*configure)(struct mlxsw_sp_rif *rif);
136 void (*deconfigure)(struct mlxsw_sp_rif *rif);
137 struct mlxsw_sp_fid * (*fid_get)(struct mlxsw_sp_rif *rif);
138};
139
e0c0afd8
AS		 140static unsigned int *
141mlxsw_sp_rif_p_counter_get(struct mlxsw_sp_rif *rif,
142 enum mlxsw_sp_rif_counter_dir dir)
143{
144 switch (dir) {
145 case MLXSW_SP_RIF_COUNTER_EGRESS:
146 return &rif->counter_egress;
147 case MLXSW_SP_RIF_COUNTER_INGRESS:
148 return &rif->counter_ingress;
149 }
150 return NULL;
151}
152
153static bool
154mlxsw_sp_rif_counter_valid_get(struct mlxsw_sp_rif *rif,
155 enum mlxsw_sp_rif_counter_dir dir)
156{
157 switch (dir) {
158 case MLXSW_SP_RIF_COUNTER_EGRESS:
159 return rif->counter_egress_valid;
160 case MLXSW_SP_RIF_COUNTER_INGRESS:
161 return rif->counter_ingress_valid;
162 }
163 return false;
164}
165
166static void
167mlxsw_sp_rif_counter_valid_set(struct mlxsw_sp_rif *rif,
168 enum mlxsw_sp_rif_counter_dir dir,
169 bool valid)
170{
171 switch (dir) {
172 case MLXSW_SP_RIF_COUNTER_EGRESS:
173 rif->counter_egress_valid = valid;
174 break;
175 case MLXSW_SP_RIF_COUNTER_INGRESS:
176 rif->counter_ingress_valid = valid;
177 break;
178 }
179}
180
181static int mlxsw_sp_rif_counter_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
182 unsigned int counter_index, bool enable,
183 enum mlxsw_sp_rif_counter_dir dir)
184{
185 char ritr_pl[MLXSW_REG_RITR_LEN];
186 bool is_egress = false;
187 int err;
188
189 if (dir == MLXSW_SP_RIF_COUNTER_EGRESS)
190 is_egress = true;
191 mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
192 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
193 if (err)
194 return err;
195
196 mlxsw_reg_ritr_counter_pack(ritr_pl, counter_index, enable,
197 is_egress);
198 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
199}
200
201int mlxsw_sp_rif_counter_value_get(struct mlxsw_sp *mlxsw_sp,
202 struct mlxsw_sp_rif *rif,
203 enum mlxsw_sp_rif_counter_dir dir, u64 *cnt)
204{
205 char ricnt_pl[MLXSW_REG_RICNT_LEN];
206 unsigned int *p_counter_index;
207 bool valid;
208 int err;
209
210 valid = mlxsw_sp_rif_counter_valid_get(rif, dir);
211 if (!valid)
212 return -EINVAL;
213
214 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
215 if (!p_counter_index)
216 return -EINVAL;
217 mlxsw_reg_ricnt_pack(ricnt_pl, *p_counter_index,
218 MLXSW_REG_RICNT_OPCODE_NOP);
219 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
220 if (err)
221 return err;
222 *cnt = mlxsw_reg_ricnt_good_unicast_packets_get(ricnt_pl);
223 return 0;
224}
225
226static int mlxsw_sp_rif_counter_clear(struct mlxsw_sp *mlxsw_sp,
227 unsigned int counter_index)
228{
229 char ricnt_pl[MLXSW_REG_RICNT_LEN];
230
231 mlxsw_reg_ricnt_pack(ricnt_pl, counter_index,
232 MLXSW_REG_RICNT_OPCODE_CLEAR);
233 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ricnt), ricnt_pl);
234}
235
236int mlxsw_sp_rif_counter_alloc(struct mlxsw_sp *mlxsw_sp,
237 struct mlxsw_sp_rif *rif,
238 enum mlxsw_sp_rif_counter_dir dir)
239{
240 unsigned int *p_counter_index;
241 int err;
242
243 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
244 if (!p_counter_index)
245 return -EINVAL;
246 err = mlxsw_sp_counter_alloc(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
247 p_counter_index);
248 if (err)
249 return err;
250
251 err = mlxsw_sp_rif_counter_clear(mlxsw_sp, *p_counter_index);
252 if (err)
253 goto err_counter_clear;
254
255 err = mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
256 *p_counter_index, true, dir);
257 if (err)
258 goto err_counter_edit;
259 mlxsw_sp_rif_counter_valid_set(rif, dir, true);
260 return 0;
261
262err_counter_edit:
263err_counter_clear:
264 mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
265 *p_counter_index);
266 return err;
267}
268
269void mlxsw_sp_rif_counter_free(struct mlxsw_sp *mlxsw_sp,
270 struct mlxsw_sp_rif *rif,
271 enum mlxsw_sp_rif_counter_dir dir)
272{
273 unsigned int *p_counter_index;
274
6b1206bb
AS		 275 if (!mlxsw_sp_rif_counter_valid_get(rif, dir))
276 return;
277
e0c0afd8
AS		 278 p_counter_index = mlxsw_sp_rif_p_counter_get(rif, dir);
279 if (WARN_ON(!p_counter_index))
280 return;
281 mlxsw_sp_rif_counter_edit(mlxsw_sp, rif->rif_index,
282 *p_counter_index, false, dir);
283 mlxsw_sp_counter_free(mlxsw_sp, MLXSW_SP_COUNTER_SUB_POOL_RIF,
284 *p_counter_index);
285 mlxsw_sp_rif_counter_valid_set(rif, dir, false);
286}
287
e4f3c1c1
IS		 288static void mlxsw_sp_rif_counters_alloc(struct mlxsw_sp_rif *rif)
289{
290 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
291 struct devlink *devlink;
292
293 devlink = priv_to_devlink(mlxsw_sp->core);
294 if (!devlink_dpipe_table_counter_enabled(devlink,
295 MLXSW_SP_DPIPE_TABLE_NAME_ERIF))
296 return;
297 mlxsw_sp_rif_counter_alloc(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS);
298}
299
300static void mlxsw_sp_rif_counters_free(struct mlxsw_sp_rif *rif)
301{
302 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
303
304 mlxsw_sp_rif_counter_free(mlxsw_sp, rif, MLXSW_SP_RIF_COUNTER_EGRESS);
305}
306
4724ba56
IS		 307static struct mlxsw_sp_rif *
308mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp,
309 const struct net_device *dev);
310
7dcc18ad 311#define MLXSW_SP_PREFIX_COUNT (sizeof(struct in6_addr) * BITS_PER_BYTE + 1)
9011b677
IS		 312
313struct mlxsw_sp_prefix_usage {
314 DECLARE_BITMAP(b, MLXSW_SP_PREFIX_COUNT);
315};
316
53342023
JP		 317#define mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) \
318 for_each_set_bit(prefix, (prefix_usage)->b, MLXSW_SP_PREFIX_COUNT)
319
6b75c480
JP		 320static bool
321mlxsw_sp_prefix_usage_subset(struct mlxsw_sp_prefix_usage *prefix_usage1,
322 struct mlxsw_sp_prefix_usage *prefix_usage2)
323{
324 unsigned char prefix;
325
326 mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage1) {
327 if (!test_bit(prefix, prefix_usage2->b))
328 return false;
329 }
330 return true;
331}
332
53342023
JP		 333static bool
334mlxsw_sp_prefix_usage_eq(struct mlxsw_sp_prefix_usage *prefix_usage1,
335 struct mlxsw_sp_prefix_usage *prefix_usage2)
336{
337 return !memcmp(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
338}
339
6b75c480
JP		 340static bool
341mlxsw_sp_prefix_usage_none(struct mlxsw_sp_prefix_usage *prefix_usage)
342{
343 struct mlxsw_sp_prefix_usage prefix_usage_none = {{ 0 } };
344
345 return mlxsw_sp_prefix_usage_eq(prefix_usage, &prefix_usage_none);
346}
347
348static void
349mlxsw_sp_prefix_usage_cpy(struct mlxsw_sp_prefix_usage *prefix_usage1,
350 struct mlxsw_sp_prefix_usage *prefix_usage2)
351{
352 memcpy(prefix_usage1, prefix_usage2, sizeof(*prefix_usage1));
353}
354
5e9c16cc
JP		 355static void
356mlxsw_sp_prefix_usage_set(struct mlxsw_sp_prefix_usage *prefix_usage,
357 unsigned char prefix_len)
358{
359 set_bit(prefix_len, prefix_usage->b);
360}
361
362static void
363mlxsw_sp_prefix_usage_clear(struct mlxsw_sp_prefix_usage *prefix_usage,
364 unsigned char prefix_len)
365{
366 clear_bit(prefix_len, prefix_usage->b);
367}
368
369struct mlxsw_sp_fib_key {
370 unsigned char addr[sizeof(struct in6_addr)];
371 unsigned char prefix_len;
372};
373
61c503f9
JP		 374enum mlxsw_sp_fib_entry_type {
375 MLXSW_SP_FIB_ENTRY_TYPE_REMOTE,
376 MLXSW_SP_FIB_ENTRY_TYPE_LOCAL,
377 MLXSW_SP_FIB_ENTRY_TYPE_TRAP,
378};
379
a7ff87ac 380struct mlxsw_sp_nexthop_group;
9011b677 381struct mlxsw_sp_fib;
a7ff87ac 382
9aecce1c
IS		 383struct mlxsw_sp_fib_node {
384 struct list_head entry_list;
b45f64d1 385 struct list_head list;
9aecce1c 386 struct rhash_head ht_node;
76610ebb 387 struct mlxsw_sp_fib *fib;
5e9c16cc 388 struct mlxsw_sp_fib_key key;
9aecce1c
IS		 389};
390
9aecce1c
IS		 391struct mlxsw_sp_fib_entry {
392 struct list_head list;
393 struct mlxsw_sp_fib_node *fib_node;
61c503f9 394 enum mlxsw_sp_fib_entry_type type;
a7ff87ac
JP		 395 struct list_head nexthop_group_node;
396 struct mlxsw_sp_nexthop_group *nh_group;
013b20f9 397 bool offloaded;
5e9c16cc
JP		 398};
399
4f1c7f1f
IS		 400struct mlxsw_sp_fib4_entry {
401 struct mlxsw_sp_fib_entry common;
402 u32 tb_id;
403 u32 prio;
404 u8 tos;
405 u8 type;
406};
407
9011b677
IS		 408enum mlxsw_sp_l3proto {
409 MLXSW_SP_L3_PROTO_IPV4,
410 MLXSW_SP_L3_PROTO_IPV6,
411};
412
413struct mlxsw_sp_lpm_tree {
414 u8 id; /* tree ID */
415 unsigned int ref_count;
416 enum mlxsw_sp_l3proto proto;
417 struct mlxsw_sp_prefix_usage prefix_usage;
418};
419
5e9c16cc
JP		 420struct mlxsw_sp_fib {
421 struct rhashtable ht;
9aecce1c 422 struct list_head node_list;
76610ebb
IS		 423 struct mlxsw_sp_vr *vr;
424 struct mlxsw_sp_lpm_tree *lpm_tree;
5e9c16cc
JP		 425 unsigned long prefix_ref_count[MLXSW_SP_PREFIX_COUNT];
426 struct mlxsw_sp_prefix_usage prefix_usage;
76610ebb 427 enum mlxsw_sp_l3proto proto;
5e9c16cc
JP		 428};
429
9011b677
IS		 430struct mlxsw_sp_vr {
431 u16 id; /* virtual router ID */
432 u32 tb_id; /* kernel fib table id */
433 unsigned int rif_count;
434 struct mlxsw_sp_fib *fib4;
a3d9bc50 435 struct mlxsw_sp_fib *fib6;
9011b677
IS		 436};
437
9aecce1c 438static const struct rhashtable_params mlxsw_sp_fib_ht_params;
5e9c16cc 439
76610ebb
IS		 440static struct mlxsw_sp_fib *mlxsw_sp_fib_create(struct mlxsw_sp_vr *vr,
441 enum mlxsw_sp_l3proto proto)
5e9c16cc
JP		 442{
443 struct mlxsw_sp_fib *fib;
444 int err;
445
446 fib = kzalloc(sizeof(*fib), GFP_KERNEL);
447 if (!fib)
448 return ERR_PTR(-ENOMEM);
449 err = rhashtable_init(&fib->ht, &mlxsw_sp_fib_ht_params);
450 if (err)
451 goto err_rhashtable_init;
9aecce1c 452 INIT_LIST_HEAD(&fib->node_list);
76610ebb
IS		 453 fib->proto = proto;
454 fib->vr = vr;
5e9c16cc
JP		 455 return fib;
456
457err_rhashtable_init:
458 kfree(fib);
459 return ERR_PTR(err);
460}
461
462static void mlxsw_sp_fib_destroy(struct mlxsw_sp_fib *fib)
463{
9aecce1c 464 WARN_ON(!list_empty(&fib->node_list));
76610ebb 465 WARN_ON(fib->lpm_tree);
5e9c16cc
JP		 466 rhashtable_destroy(&fib->ht);
467 kfree(fib);
468}
469
53342023 470static struct mlxsw_sp_lpm_tree *
382dbb40 471mlxsw_sp_lpm_tree_find_unused(struct mlxsw_sp *mlxsw_sp)
53342023
JP		 472{
473 static struct mlxsw_sp_lpm_tree *lpm_tree;
474 int i;
475
9011b677
IS		 476 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
477 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
382dbb40
IS		 478 if (lpm_tree->ref_count == 0)
479 return lpm_tree;
53342023
JP		 480 }
481 return NULL;
482}
483
484static int mlxsw_sp_lpm_tree_alloc(struct mlxsw_sp *mlxsw_sp,
485 struct mlxsw_sp_lpm_tree *lpm_tree)
486{
487 char ralta_pl[MLXSW_REG_RALTA_LEN];
488
1a9234e6
IS		 489 mlxsw_reg_ralta_pack(ralta_pl, true,
490 (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
491 lpm_tree->id);
53342023
JP		 492 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
493}
494
495static int mlxsw_sp_lpm_tree_free(struct mlxsw_sp *mlxsw_sp,
496 struct mlxsw_sp_lpm_tree *lpm_tree)
497{
498 char ralta_pl[MLXSW_REG_RALTA_LEN];
499
1a9234e6
IS		 500 mlxsw_reg_ralta_pack(ralta_pl, false,
501 (enum mlxsw_reg_ralxx_protocol) lpm_tree->proto,
502 lpm_tree->id);
53342023
JP		 503 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
504}
505
506static int
507mlxsw_sp_lpm_tree_left_struct_set(struct mlxsw_sp *mlxsw_sp,
508 struct mlxsw_sp_prefix_usage *prefix_usage,
509 struct mlxsw_sp_lpm_tree *lpm_tree)
510{
511 char ralst_pl[MLXSW_REG_RALST_LEN];
512 u8 root_bin = 0;
513 u8 prefix;
514 u8 last_prefix = MLXSW_REG_RALST_BIN_NO_CHILD;
515
516 mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage)
517 root_bin = prefix;
518
519 mlxsw_reg_ralst_pack(ralst_pl, root_bin, lpm_tree->id);
520 mlxsw_sp_prefix_usage_for_each(prefix, prefix_usage) {
521 if (prefix == 0)
522 continue;
523 mlxsw_reg_ralst_bin_pack(ralst_pl, prefix, last_prefix,
524 MLXSW_REG_RALST_BIN_NO_CHILD);
525 last_prefix = prefix;
526 }
527 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralst), ralst_pl);
528}
529
530static struct mlxsw_sp_lpm_tree *
531mlxsw_sp_lpm_tree_create(struct mlxsw_sp *mlxsw_sp,
532 struct mlxsw_sp_prefix_usage *prefix_usage,
382dbb40 533 enum mlxsw_sp_l3proto proto)
53342023
JP		 534{
535 struct mlxsw_sp_lpm_tree *lpm_tree;
536 int err;
537
382dbb40 538 lpm_tree = mlxsw_sp_lpm_tree_find_unused(mlxsw_sp);
53342023
JP		 539 if (!lpm_tree)
540 return ERR_PTR(-EBUSY);
541 lpm_tree->proto = proto;
542 err = mlxsw_sp_lpm_tree_alloc(mlxsw_sp, lpm_tree);
543 if (err)
544 return ERR_PTR(err);
545
546 err = mlxsw_sp_lpm_tree_left_struct_set(mlxsw_sp, prefix_usage,
547 lpm_tree);
548 if (err)
549 goto err_left_struct_set;
2083d367
JP		 550 memcpy(&lpm_tree->prefix_usage, prefix_usage,
551 sizeof(lpm_tree->prefix_usage));
53342023
JP		 552 return lpm_tree;
553
554err_left_struct_set:
555 mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
556 return ERR_PTR(err);
557}
558
559static int mlxsw_sp_lpm_tree_destroy(struct mlxsw_sp *mlxsw_sp,
560 struct mlxsw_sp_lpm_tree *lpm_tree)
561{
562 return mlxsw_sp_lpm_tree_free(mlxsw_sp, lpm_tree);
563}
564
565static struct mlxsw_sp_lpm_tree *
566mlxsw_sp_lpm_tree_get(struct mlxsw_sp *mlxsw_sp,
567 struct mlxsw_sp_prefix_usage *prefix_usage,
382dbb40 568 enum mlxsw_sp_l3proto proto)
53342023
JP		 569{
570 struct mlxsw_sp_lpm_tree *lpm_tree;
571 int i;
572
9011b677
IS		 573 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
574 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
8b99becd
JP		 575 if (lpm_tree->ref_count != 0 &&
576 lpm_tree->proto == proto &&
53342023
JP		 577 mlxsw_sp_prefix_usage_eq(&lpm_tree->prefix_usage,
578 prefix_usage))
579 goto inc_ref_count;
580 }
581 lpm_tree = mlxsw_sp_lpm_tree_create(mlxsw_sp, prefix_usage,
382dbb40 582 proto);
53342023
JP		 583 if (IS_ERR(lpm_tree))
584 return lpm_tree;
585
586inc_ref_count:
587 lpm_tree->ref_count++;
588 return lpm_tree;
589}
590
591static int mlxsw_sp_lpm_tree_put(struct mlxsw_sp *mlxsw_sp,
592 struct mlxsw_sp_lpm_tree *lpm_tree)
593{
594 if (--lpm_tree->ref_count == 0)
595 return mlxsw_sp_lpm_tree_destroy(mlxsw_sp, lpm_tree);
596 return 0;
597}
598
d7a60306 599#define MLXSW_SP_LPM_TREE_MIN 1 /* tree 0 is reserved */
8494ab06
IS		 600
601static int mlxsw_sp_lpm_init(struct mlxsw_sp *mlxsw_sp)
53342023
JP		 602{
603 struct mlxsw_sp_lpm_tree *lpm_tree;
8494ab06 604 u64 max_trees;
53342023
JP		 605 int i;
606
8494ab06
IS		 607 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_LPM_TREES))
608 return -EIO;
609
610 max_trees = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_LPM_TREES);
9011b677
IS		 611 mlxsw_sp->router->lpm.tree_count = max_trees - MLXSW_SP_LPM_TREE_MIN;
612 mlxsw_sp->router->lpm.trees = kcalloc(mlxsw_sp->router->lpm.tree_count,
8494ab06
IS		 613 sizeof(struct mlxsw_sp_lpm_tree),
614 GFP_KERNEL);
9011b677 615 if (!mlxsw_sp->router->lpm.trees)
8494ab06
IS		 616 return -ENOMEM;
617
9011b677
IS		 618 for (i = 0; i < mlxsw_sp->router->lpm.tree_count; i++) {
619 lpm_tree = &mlxsw_sp->router->lpm.trees[i];
53342023
JP		 620 lpm_tree->id = i + MLXSW_SP_LPM_TREE_MIN;
621 }
8494ab06
IS		 622
623 return 0;
624}
625
626static void mlxsw_sp_lpm_fini(struct mlxsw_sp *mlxsw_sp)
627{
9011b677 628 kfree(mlxsw_sp->router->lpm.trees);
53342023
JP		 629}
630
76610ebb
IS		 631static bool mlxsw_sp_vr_is_used(const struct mlxsw_sp_vr *vr)
632{
a3d9bc50 633 return !!vr->fib4 || !!vr->fib6;
76610ebb
IS		 634}
635
6b75c480
JP		 636static struct mlxsw_sp_vr *mlxsw_sp_vr_find_unused(struct mlxsw_sp *mlxsw_sp)
637{
638 struct mlxsw_sp_vr *vr;
639 int i;
640
c1a38311 641 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
9011b677 642 vr = &mlxsw_sp->router->vrs[i];
76610ebb 643 if (!mlxsw_sp_vr_is_used(vr))
6b75c480
JP		 644 return vr;
645 }
646 return NULL;
647}
648
649static int mlxsw_sp_vr_lpm_tree_bind(struct mlxsw_sp *mlxsw_sp,
76610ebb 650 const struct mlxsw_sp_fib *fib)
6b75c480
JP		 651{
652 char raltb_pl[MLXSW_REG_RALTB_LEN];
653
76610ebb
IS		 654 mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
655 (enum mlxsw_reg_ralxx_protocol) fib->proto,
656 fib->lpm_tree->id);
6b75c480
JP		 657 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
658}
659
660static int mlxsw_sp_vr_lpm_tree_unbind(struct mlxsw_sp *mlxsw_sp,
76610ebb 661 const struct mlxsw_sp_fib *fib)
6b75c480
JP		 662{
663 char raltb_pl[MLXSW_REG_RALTB_LEN];
664
665 /* Bind to tree 0 which is default */
76610ebb
IS		 666 mlxsw_reg_raltb_pack(raltb_pl, fib->vr->id,
667 (enum mlxsw_reg_ralxx_protocol) fib->proto, 0);
6b75c480
JP		 668 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb), raltb_pl);
669}
670
671static u32 mlxsw_sp_fix_tb_id(u32 tb_id)
672{
673 /* For our purpose, squash main and local table into one */
674 if (tb_id == RT_TABLE_LOCAL)
675 tb_id = RT_TABLE_MAIN;
676 return tb_id;
677}
678
679static struct mlxsw_sp_vr *mlxsw_sp_vr_find(struct mlxsw_sp *mlxsw_sp,
76610ebb 680 u32 tb_id)
6b75c480
JP		 681{
682 struct mlxsw_sp_vr *vr;
683 int i;
684
685 tb_id = mlxsw_sp_fix_tb_id(tb_id);
9497c042 686
c1a38311 687 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
9011b677 688 vr = &mlxsw_sp->router->vrs[i];
76610ebb 689 if (mlxsw_sp_vr_is_used(vr) && vr->tb_id == tb_id)
6b75c480
JP		 690 return vr;
691 }
692 return NULL;
693}
694
76610ebb
IS		 695static struct mlxsw_sp_fib *mlxsw_sp_vr_fib(const struct mlxsw_sp_vr *vr,
696 enum mlxsw_sp_l3proto proto)
697{
698 switch (proto) {
699 case MLXSW_SP_L3_PROTO_IPV4:
700 return vr->fib4;
701 case MLXSW_SP_L3_PROTO_IPV6:
a3d9bc50 702 return vr->fib6;
76610ebb
IS		 703 }
704 return NULL;
705}
706
6b75c480 707static struct mlxsw_sp_vr *mlxsw_sp_vr_create(struct mlxsw_sp *mlxsw_sp,
76610ebb 708 u32 tb_id)
6b75c480 709{
6b75c480 710 struct mlxsw_sp_vr *vr;
a3d9bc50 711 int err;
6b75c480
JP		 712
713 vr = mlxsw_sp_vr_find_unused(mlxsw_sp);
714 if (!vr)
715 return ERR_PTR(-EBUSY);
76610ebb
IS		 716 vr->fib4 = mlxsw_sp_fib_create(vr, MLXSW_SP_L3_PROTO_IPV4);
717 if (IS_ERR(vr->fib4))
718 return ERR_CAST(vr->fib4);
a3d9bc50
IS		 719 vr->fib6 = mlxsw_sp_fib_create(vr, MLXSW_SP_L3_PROTO_IPV6);
720 if (IS_ERR(vr->fib6)) {
721 err = PTR_ERR(vr->fib6);
722 goto err_fib6_create;
723 }
6b75c480 724 vr->tb_id = tb_id;
6b75c480 725 return vr;
a3d9bc50
IS		 726
727err_fib6_create:
728 mlxsw_sp_fib_destroy(vr->fib4);
729 vr->fib4 = NULL;
730 return ERR_PTR(err);
6b75c480
JP		 731}
732
76610ebb 733static void mlxsw_sp_vr_destroy(struct mlxsw_sp_vr *vr)
6b75c480 734{
a3d9bc50
IS		 735 mlxsw_sp_fib_destroy(vr->fib6);
736 vr->fib6 = NULL;
76610ebb
IS		 737 mlxsw_sp_fib_destroy(vr->fib4);
738 vr->fib4 = NULL;
6b75c480
JP		 739}
740
741static int
76610ebb 742mlxsw_sp_vr_lpm_tree_check(struct mlxsw_sp *mlxsw_sp, struct mlxsw_sp_fib *fib,
6b75c480
JP		 743 struct mlxsw_sp_prefix_usage *req_prefix_usage)
744{
76610ebb 745 struct mlxsw_sp_lpm_tree *lpm_tree = fib->lpm_tree;
f7df4923
IS		 746 struct mlxsw_sp_lpm_tree *new_tree;
747 int err;
6b75c480 748
f7df4923 749 if (mlxsw_sp_prefix_usage_eq(req_prefix_usage, &lpm_tree->prefix_usage))
6b75c480
JP		 750 return 0;
751
f7df4923 752 new_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, req_prefix_usage,
76610ebb 753 fib->proto);
f7df4923 754 if (IS_ERR(new_tree)) {
6b75c480
JP		 755 /* We failed to get a tree according to the required
756 * prefix usage. However, the current tree might be still good
757 * for us if our requirement is subset of the prefixes used
758 * in the tree.
759 */
760 if (mlxsw_sp_prefix_usage_subset(req_prefix_usage,
f7df4923 761 &lpm_tree->prefix_usage))
6b75c480 762 return 0;
f7df4923 763 return PTR_ERR(new_tree);
6b75c480
JP		 764 }
765
f7df4923 766 /* Prevent packet loss by overwriting existing binding */
76610ebb
IS		 767 fib->lpm_tree = new_tree;
768 err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib);
f7df4923
IS		 769 if (err)
770 goto err_tree_bind;
771 mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
772
773 return 0;
774
775err_tree_bind:
76610ebb 776 fib->lpm_tree = lpm_tree;
f7df4923
IS		 777 mlxsw_sp_lpm_tree_put(mlxsw_sp, new_tree);
778 return err;
6b75c480
JP		 779}
780
76610ebb 781static struct mlxsw_sp_vr *mlxsw_sp_vr_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id)
6b75c480
JP		 782{
783 struct mlxsw_sp_vr *vr;
6b75c480
JP		 784
785 tb_id = mlxsw_sp_fix_tb_id(tb_id);
76610ebb
IS		 786 vr = mlxsw_sp_vr_find(mlxsw_sp, tb_id);
787 if (!vr)
788 vr = mlxsw_sp_vr_create(mlxsw_sp, tb_id);
6b75c480
JP		 789 return vr;
790}
791
76610ebb 792static void mlxsw_sp_vr_put(struct mlxsw_sp_vr *vr)
6b75c480 793{
a3d9bc50
IS		 794 if (!vr->rif_count && list_empty(&vr->fib4->node_list) &&
795 list_empty(&vr->fib6->node_list))
76610ebb 796 mlxsw_sp_vr_destroy(vr);
6b75c480
JP		 797}
798
9497c042 799static int mlxsw_sp_vrs_init(struct mlxsw_sp *mlxsw_sp)
6b75c480
JP		 800{
801 struct mlxsw_sp_vr *vr;
c1a38311 802 u64 max_vrs;
6b75c480
JP		 803 int i;
804
c1a38311 805 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_VRS))
9497c042
NF		 806 return -EIO;
807
c1a38311 808 max_vrs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS);
9011b677
IS		 809 mlxsw_sp->router->vrs = kcalloc(max_vrs, sizeof(struct mlxsw_sp_vr),
810 GFP_KERNEL);
811 if (!mlxsw_sp->router->vrs)
9497c042
NF		 812 return -ENOMEM;
813
c1a38311 814 for (i = 0; i < max_vrs; i++) {
9011b677 815 vr = &mlxsw_sp->router->vrs[i];
6b75c480
JP		 816 vr->id = i;
817 }
9497c042
NF		 818
819 return 0;
820}
821
ac571de9
IS		 822static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp);
823
9497c042
NF		 824static void mlxsw_sp_vrs_fini(struct mlxsw_sp *mlxsw_sp)
825{
3057224e
IS		 826 /* At this stage we're guaranteed not to have new incoming
827 * FIB notifications and the work queue is free from FIBs
828 * sitting on top of mlxsw netdevs. However, we can still
829 * have other FIBs queued. Flush the queue before flushing
830 * the device's tables. No need for locks, as we're the only
831 * writer.
832 */
833 mlxsw_core_flush_owq();
ac571de9 834 mlxsw_sp_router_fib_flush(mlxsw_sp);
9011b677 835 kfree(mlxsw_sp->router->vrs);
6b75c480
JP		 836}
837
6cf3c971 838struct mlxsw_sp_neigh_key {
33b1341c 839 struct neighbour *n;
6cf3c971
JP		 840};
841
842struct mlxsw_sp_neigh_entry {
9665b745 843 struct list_head rif_list_node;
6cf3c971
JP		 844 struct rhash_head ht_node;
845 struct mlxsw_sp_neigh_key key;
846 u16 rif;
5c8802f1 847 bool connected;
a6bf9e93 848 unsigned char ha[ETH_ALEN];
a7ff87ac
JP		 849 struct list_head nexthop_list; /* list of nexthops using
850 * this neigh entry
851 */
b2157149 852 struct list_head nexthop_neighs_list_node;
6cf3c971
JP		 853};
854
855static const struct rhashtable_params mlxsw_sp_neigh_ht_params = {
856 .key_offset = offsetof(struct mlxsw_sp_neigh_entry, key),
857 .head_offset = offsetof(struct mlxsw_sp_neigh_entry, ht_node),
858 .key_len = sizeof(struct mlxsw_sp_neigh_key),
859};
860
6cf3c971 861static struct mlxsw_sp_neigh_entry *
5c8802f1
IS		 862mlxsw_sp_neigh_entry_alloc(struct mlxsw_sp *mlxsw_sp, struct neighbour *n,
863 u16 rif)
6cf3c971
JP		 864{
865 struct mlxsw_sp_neigh_entry *neigh_entry;
866
5c8802f1 867 neigh_entry = kzalloc(sizeof(*neigh_entry), GFP_KERNEL);
6cf3c971
JP		 868 if (!neigh_entry)
869 return NULL;
5c8802f1 870
33b1341c 871 neigh_entry->key.n = n;
6cf3c971 872 neigh_entry->rif = rif;
a7ff87ac 873 INIT_LIST_HEAD(&neigh_entry->nexthop_list);
5c8802f1 874
6cf3c971
JP		 875 return neigh_entry;
876}
877
5c8802f1 878static void mlxsw_sp_neigh_entry_free(struct mlxsw_sp_neigh_entry *neigh_entry)
6cf3c971
JP		 879{
880 kfree(neigh_entry);
881}
882
5c8802f1
IS		 883static int
884mlxsw_sp_neigh_entry_insert(struct mlxsw_sp *mlxsw_sp,
885 struct mlxsw_sp_neigh_entry *neigh_entry)
6cf3c971 886{
9011b677 887 return rhashtable_insert_fast(&mlxsw_sp->router->neigh_ht,
5c8802f1
IS		 888 &neigh_entry->ht_node,
889 mlxsw_sp_neigh_ht_params);
890}
6cf3c971 891
5c8802f1
IS		 892static void
893mlxsw_sp_neigh_entry_remove(struct mlxsw_sp *mlxsw_sp,
894 struct mlxsw_sp_neigh_entry *neigh_entry)
895{
9011b677 896 rhashtable_remove_fast(&mlxsw_sp->router->neigh_ht,
5c8802f1
IS		 897 &neigh_entry->ht_node,
898 mlxsw_sp_neigh_ht_params);
6cf3c971
JP		 899}
900
5c8802f1
IS		 901static struct mlxsw_sp_neigh_entry *
902mlxsw_sp_neigh_entry_create(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
6cf3c971 903{
6cf3c971 904 struct mlxsw_sp_neigh_entry *neigh_entry;
bf95233e 905 struct mlxsw_sp_rif *rif;
6cf3c971
JP		 906 int err;
907
bf95233e
AS		 908 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, n->dev);
909 if (!rif)
5c8802f1 910 return ERR_PTR(-EINVAL);
6cf3c971 911
bf95233e 912 neigh_entry = mlxsw_sp_neigh_entry_alloc(mlxsw_sp, n, rif->rif_index);
6cf3c971 913 if (!neigh_entry)
5c8802f1
IS		 914 return ERR_PTR(-ENOMEM);
915
6cf3c971
JP		 916 err = mlxsw_sp_neigh_entry_insert(mlxsw_sp, neigh_entry);
917 if (err)
918 goto err_neigh_entry_insert;
5c8802f1 919
bf95233e 920 list_add(&neigh_entry->rif_list_node, &rif->neigh_list);
9665b745 921
5c8802f1 922 return neigh_entry;
6cf3c971
JP		 923
924err_neigh_entry_insert:
5c8802f1
IS		 925 mlxsw_sp_neigh_entry_free(neigh_entry);
926 return ERR_PTR(err);
6cf3c971
JP		 927}
928
5c8802f1
IS		 929static void
930mlxsw_sp_neigh_entry_destroy(struct mlxsw_sp *mlxsw_sp,
931 struct mlxsw_sp_neigh_entry *neigh_entry)
6cf3c971 932{
9665b745 933 list_del(&neigh_entry->rif_list_node);
5c8802f1
IS		 934 mlxsw_sp_neigh_entry_remove(mlxsw_sp, neigh_entry);
935 mlxsw_sp_neigh_entry_free(neigh_entry);
936}
6cf3c971 937
5c8802f1
IS		 938static struct mlxsw_sp_neigh_entry *
939mlxsw_sp_neigh_entry_lookup(struct mlxsw_sp *mlxsw_sp, struct neighbour *n)
940{
941 struct mlxsw_sp_neigh_key key;
6cf3c971 942
5c8802f1 943 key.n = n;
9011b677 944 return rhashtable_lookup_fast(&mlxsw_sp->router->neigh_ht,
5c8802f1 945 &key, mlxsw_sp_neigh_ht_params);
6cf3c971
JP		 946}
947
c723c735
YG		 948static void
949mlxsw_sp_router_neighs_update_interval_init(struct mlxsw_sp *mlxsw_sp)
950{
a6c9b5d1 951 unsigned long interval;
c723c735 952
b5f3e0d4 953#if IS_ENABLED(CONFIG_IPV6)
a6c9b5d1
AS		 954 interval = min_t(unsigned long,
955 NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME),
956 NEIGH_VAR(&nd_tbl.parms, DELAY_PROBE_TIME));
b5f3e0d4
IS		 957#else
958 interval = NEIGH_VAR(&arp_tbl.parms, DELAY_PROBE_TIME);
959#endif
9011b677 960 mlxsw_sp->router->neighs_update.interval = jiffies_to_msecs(interval);
c723c735
YG		 961}
962
963static void mlxsw_sp_router_neigh_ent_ipv4_process(struct mlxsw_sp *mlxsw_sp,
964 char *rauhtd_pl,
965 int ent_index)
966{
967 struct net_device *dev;
968 struct neighbour *n;
969 __be32 dipn;
970 u32 dip;
971 u16 rif;
972
973 mlxsw_reg_rauhtd_ent_ipv4_unpack(rauhtd_pl, ent_index, &rif, &dip);
974
5f9efffb 975 if (!mlxsw_sp->router->rifs[rif]) {
c723c735
YG		 976 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
977 return;
978 }
979
980 dipn = htonl(dip);
5f9efffb 981 dev = mlxsw_sp->router->rifs[rif]->dev;
c723c735
YG		 982 n = neigh_lookup(&arp_tbl, &dipn, dev);
983 if (!n) {
984 netdev_err(dev, "Failed to find matching neighbour for IP=%pI4h\n",
985 &dip);
986 return;
987 }
988
989 netdev_dbg(dev, "Updating neighbour with IP=%pI4h\n", &dip);
990 neigh_event_send(n, NULL);
991 neigh_release(n);
992}
993
b5f3e0d4 994#if IS_ENABLED(IPV6)
60f040ca
AS		 995static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
996 char *rauhtd_pl,
997 int rec_index)
998{
999 struct net_device *dev;
1000 struct neighbour *n;
1001 struct in6_addr dip;
1002 u16 rif;
1003
1004 mlxsw_reg_rauhtd_ent_ipv6_unpack(rauhtd_pl, rec_index, &rif,
1005 (char *) &dip);
1006
1007 if (!mlxsw_sp->router->rifs[rif]) {
1008 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect RIF in neighbour entry\n");
1009 return;
1010 }
1011
1012 dev = mlxsw_sp->router->rifs[rif]->dev;
1013 n = neigh_lookup(&nd_tbl, &dip, dev);
1014 if (!n) {
1015 netdev_err(dev, "Failed to find matching neighbour for IP=%pI6c\n",
1016 &dip);
1017 return;
1018 }
1019
1020 netdev_dbg(dev, "Updating neighbour with IP=%pI6c\n", &dip);
1021 neigh_event_send(n, NULL);
1022 neigh_release(n);
1023}
b5f3e0d4
IS		 1024#else
1025static void mlxsw_sp_router_neigh_ent_ipv6_process(struct mlxsw_sp *mlxsw_sp,
1026 char *rauhtd_pl,
1027 int rec_index)
1028{
1029}
1030#endif
60f040ca 1031
c723c735
YG		 1032static void mlxsw_sp_router_neigh_rec_ipv4_process(struct mlxsw_sp *mlxsw_sp,
1033 char *rauhtd_pl,
1034 int rec_index)
1035{
1036 u8 num_entries;
1037 int i;
1038
1039 num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
1040 rec_index);
1041 /* Hardware starts counting at 0, so add 1. */
1042 num_entries++;
1043
1044 /* Each record consists of several neighbour entries. */
1045 for (i = 0; i < num_entries; i++) {
1046 int ent_index;
1047
1048 ent_index = rec_index * MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC + i;
1049 mlxsw_sp_router_neigh_ent_ipv4_process(mlxsw_sp, rauhtd_pl,
1050 ent_index);
1051 }
1052
1053}
1054
60f040ca
AS		 1055static void mlxsw_sp_router_neigh_rec_ipv6_process(struct mlxsw_sp *mlxsw_sp,
1056 char *rauhtd_pl,
1057 int rec_index)
1058{
1059 /* One record contains one entry. */
1060 mlxsw_sp_router_neigh_ent_ipv6_process(mlxsw_sp, rauhtd_pl,
1061 rec_index);
1062}
1063
c723c735
YG		 1064static void mlxsw_sp_router_neigh_rec_process(struct mlxsw_sp *mlxsw_sp,
1065 char *rauhtd_pl, int rec_index)
1066{
1067 switch (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, rec_index)) {
1068 case MLXSW_REG_RAUHTD_TYPE_IPV4:
1069 mlxsw_sp_router_neigh_rec_ipv4_process(mlxsw_sp, rauhtd_pl,
1070 rec_index);
1071 break;
1072 case MLXSW_REG_RAUHTD_TYPE_IPV6:
60f040ca
AS		 1073 mlxsw_sp_router_neigh_rec_ipv6_process(mlxsw_sp, rauhtd_pl,
1074 rec_index);
c723c735
YG		 1075 break;
1076 }
1077}
1078
42cdb338
AS		 1079static bool mlxsw_sp_router_rauhtd_is_full(char *rauhtd_pl)
1080{
1081 u8 num_rec, last_rec_index, num_entries;
1082
1083 num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
1084 last_rec_index = num_rec - 1;
1085
1086 if (num_rec < MLXSW_REG_RAUHTD_REC_MAX_NUM)
1087 return false;
1088 if (mlxsw_reg_rauhtd_rec_type_get(rauhtd_pl, last_rec_index) ==
1089 MLXSW_REG_RAUHTD_TYPE_IPV6)
1090 return true;
1091
1092 num_entries = mlxsw_reg_rauhtd_ipv4_rec_num_entries_get(rauhtd_pl,
1093 last_rec_index);
1094 if (++num_entries == MLXSW_REG_RAUHTD_IPV4_ENT_PER_REC)
1095 return true;
1096 return false;
1097}
1098
60f040ca
AS		 1099static int
1100__mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp,
1101 char *rauhtd_pl,
1102 enum mlxsw_reg_rauhtd_type type)
c723c735 1103{
60f040ca
AS		 1104 int i, num_rec;
1105 int err;
c723c735
YG		 1106
1107 /* Make sure the neighbour's netdev isn't removed in the
1108 * process.
1109 */
1110 rtnl_lock();
1111 do {
60f040ca 1112 mlxsw_reg_rauhtd_pack(rauhtd_pl, type);
c723c735
YG		 1113 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(rauhtd),
1114 rauhtd_pl);
1115 if (err) {
1116 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to dump neighbour talbe\n");
1117 break;
1118 }
1119 num_rec = mlxsw_reg_rauhtd_num_rec_get(rauhtd_pl);
1120 for (i = 0; i < num_rec; i++)
1121 mlxsw_sp_router_neigh_rec_process(mlxsw_sp, rauhtd_pl,
1122 i);
42cdb338 1123 } while (mlxsw_sp_router_rauhtd_is_full(rauhtd_pl));
c723c735
YG		 1124 rtnl_unlock();
1125
60f040ca
AS		 1126 return err;
1127}
1128
1129static int mlxsw_sp_router_neighs_update_rauhtd(struct mlxsw_sp *mlxsw_sp)
1130{
1131 enum mlxsw_reg_rauhtd_type type;
1132 char *rauhtd_pl;
1133 int err;
1134
1135 rauhtd_pl = kmalloc(MLXSW_REG_RAUHTD_LEN, GFP_KERNEL);
1136 if (!rauhtd_pl)
1137 return -ENOMEM;
1138
1139 type = MLXSW_REG_RAUHTD_TYPE_IPV4;
1140 err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
1141 if (err)
1142 goto out;
1143
1144 type = MLXSW_REG_RAUHTD_TYPE_IPV6;
1145 err = __mlxsw_sp_router_neighs_update_rauhtd(mlxsw_sp, rauhtd_pl, type);
1146out:
c723c735 1147 kfree(rauhtd_pl);
b2157149
YG		 1148 return err;
1149}
1150
1151static void mlxsw_sp_router_neighs_update_nh(struct mlxsw_sp *mlxsw_sp)
1152{
1153 struct mlxsw_sp_neigh_entry *neigh_entry;
1154
1155 /* Take RTNL mutex here to prevent lists from changes */
1156 rtnl_lock();
9011b677 1157 list_for_each_entry(neigh_entry, &mlxsw_sp->router->nexthop_neighs_list,
8a0b7275 1158 nexthop_neighs_list_node)
b2157149
YG		 1159 /* If this neigh have nexthops, make the kernel think this neigh
1160 * is active regardless of the traffic.
1161 */
8a0b7275 1162 neigh_event_send(neigh_entry->key.n, NULL);
b2157149
YG		 1163 rtnl_unlock();
1164}
1165
1166static void
1167mlxsw_sp_router_neighs_update_work_schedule(struct mlxsw_sp *mlxsw_sp)
1168{
9011b677 1169 unsigned long interval = mlxsw_sp->router->neighs_update.interval;
b2157149 1170
9011b677 1171 mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw,
b2157149
YG		 1172 msecs_to_jiffies(interval));
1173}
1174
1175static void mlxsw_sp_router_neighs_update_work(struct work_struct *work)
1176{
9011b677 1177 struct mlxsw_sp_router *router;
b2157149
YG		 1178 int err;
1179
9011b677
IS		 1180 router = container_of(work, struct mlxsw_sp_router,
1181 neighs_update.dw.work);
1182 err = mlxsw_sp_router_neighs_update_rauhtd(router->mlxsw_sp);
b2157149 1183 if (err)
9011b677 1184 dev_err(router->mlxsw_sp->bus_info->dev, "Could not update kernel for neigh activity");
b2157149 1185
9011b677 1186 mlxsw_sp_router_neighs_update_nh(router->mlxsw_sp);
b2157149 1187
9011b677 1188 mlxsw_sp_router_neighs_update_work_schedule(router->mlxsw_sp);
c723c735
YG		 1189}
1190
0b2361d9
YG		 1191static void mlxsw_sp_router_probe_unresolved_nexthops(struct work_struct *work)
1192{
1193 struct mlxsw_sp_neigh_entry *neigh_entry;
9011b677 1194 struct mlxsw_sp_router *router;
0b2361d9 1195
9011b677
IS		 1196 router = container_of(work, struct mlxsw_sp_router,
1197 nexthop_probe_dw.work);
0b2361d9
YG		 1198 /* Iterate over nexthop neighbours, find those who are unresolved and
1199 * send arp on them. This solves the chicken-egg problem when
1200 * the nexthop wouldn't get offloaded until the neighbor is resolved
1201 * but it wouldn't get resolved ever in case traffic is flowing in HW
1202 * using different nexthop.
1203 *
1204 * Take RTNL mutex here to prevent lists from changes.
1205 */
1206 rtnl_lock();
9011b677 1207 list_for_each_entry(neigh_entry, &router->nexthop_neighs_list,
8a0b7275 1208 nexthop_neighs_list_node)
01b1aa35 1209 if (!neigh_entry->connected)
33b1341c 1210 neigh_event_send(neigh_entry->key.n, NULL);
0b2361d9
YG		 1211 rtnl_unlock();
1212
9011b677 1213 mlxsw_core_schedule_dw(&router->nexthop_probe_dw,
0b2361d9
YG		 1214 MLXSW_SP_UNRESOLVED_NH_PROBE_INTERVAL);
1215}
1216
a7ff87ac
JP		 1217static void
1218mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
1219 struct mlxsw_sp_neigh_entry *neigh_entry,
1220 bool removing);
1221
5c8802f1
IS		 1222static enum mlxsw_reg_rauht_op mlxsw_sp_rauht_op(bool adding)
1223{
1224 return adding ? MLXSW_REG_RAUHT_OP_WRITE_ADD :
1225 MLXSW_REG_RAUHT_OP_WRITE_DELETE;
1226}
1227
1228static void
1229mlxsw_sp_router_neigh_entry_op4(struct mlxsw_sp *mlxsw_sp,
1230 struct mlxsw_sp_neigh_entry *neigh_entry,
1231 enum mlxsw_reg_rauht_op op)
a6bf9e93 1232{
33b1341c 1233 struct neighbour *n = neigh_entry->key.n;
5c8802f1 1234 u32 dip = ntohl(*((__be32 *) n->primary_key));
a6bf9e93 1235 char rauht_pl[MLXSW_REG_RAUHT_LEN];
5c8802f1
IS		 1236
1237 mlxsw_reg_rauht_pack4(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
1238 dip);
1239 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
1240}
1241
d5eb89cf
AS		 1242static void
1243mlxsw_sp_router_neigh_entry_op6(struct mlxsw_sp *mlxsw_sp,
1244 struct mlxsw_sp_neigh_entry *neigh_entry,
1245 enum mlxsw_reg_rauht_op op)
1246{
1247 struct neighbour *n = neigh_entry->key.n;
1248 char rauht_pl[MLXSW_REG_RAUHT_LEN];
1249 const char *dip = n->primary_key;
1250
1251 mlxsw_reg_rauht_pack6(rauht_pl, op, neigh_entry->rif, neigh_entry->ha,
1252 dip);
1253 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rauht), rauht_pl);
1254}
1255
1256static bool mlxsw_sp_neigh_ipv6_ignore(struct neighbour *n)
1257{
1258 /* Packets with a link-local destination address are trapped
1259 * after LPM lookup and never reach the neighbour table, so
1260 * there is no need to program such neighbours to the device.
1261 */
1262 if (ipv6_addr_type((struct in6_addr *) &n->primary_key) &
1263 IPV6_ADDR_LINKLOCAL)
1264 return true;
1265 return false;
1266}
1267
5c8802f1
IS		 1268static void
1269mlxsw_sp_neigh_entry_update(struct mlxsw_sp *mlxsw_sp,
1270 struct mlxsw_sp_neigh_entry *neigh_entry,
1271 bool adding)
1272{
1273 if (!adding && !neigh_entry->connected)
1274 return;
1275 neigh_entry->connected = adding;
b5f3e0d4 1276 if (neigh_entry->key.n->tbl->family == AF_INET) {
5c8802f1
IS		 1277 mlxsw_sp_router_neigh_entry_op4(mlxsw_sp, neigh_entry,
1278 mlxsw_sp_rauht_op(adding));
b5f3e0d4 1279 } else if (neigh_entry->key.n->tbl->family == AF_INET6) {
d5eb89cf
AS		 1280 if (mlxsw_sp_neigh_ipv6_ignore(neigh_entry->key.n))
1281 return;
1282 mlxsw_sp_router_neigh_entry_op6(mlxsw_sp, neigh_entry,
1283 mlxsw_sp_rauht_op(adding));
1284 } else {
5c8802f1 1285 WARN_ON_ONCE(1);
d5eb89cf 1286 }
5c8802f1
IS		 1287}
1288
1289struct mlxsw_sp_neigh_event_work {
1290 struct work_struct work;
1291 struct mlxsw_sp *mlxsw_sp;
1292 struct neighbour *n;
1293};
1294
1295static void mlxsw_sp_router_neigh_event_work(struct work_struct *work)
1296{
1297 struct mlxsw_sp_neigh_event_work *neigh_work =
1298 container_of(work, struct mlxsw_sp_neigh_event_work, work);
1299 struct mlxsw_sp *mlxsw_sp = neigh_work->mlxsw_sp;
1300 struct mlxsw_sp_neigh_entry *neigh_entry;
1301 struct neighbour *n = neigh_work->n;
1302 unsigned char ha[ETH_ALEN];
a6bf9e93 1303 bool entry_connected;
93a87e5e 1304 u8 nud_state, dead;
a6bf9e93 1305
5c8802f1
IS		 1306 /* If these parameters are changed after we release the lock,
1307 * then we are guaranteed to receive another event letting us
1308 * know about it.
1309 */
a6bf9e93 1310 read_lock_bh(&n->lock);
5c8802f1 1311 memcpy(ha, n->ha, ETH_ALEN);
a6bf9e93 1312 nud_state = n->nud_state;
93a87e5e 1313 dead = n->dead;
a6bf9e93
YG		 1314 read_unlock_bh(&n->lock);
1315
5c8802f1 1316 rtnl_lock();
93a87e5e 1317 entry_connected = nud_state & NUD_VALID && !dead;
5c8802f1
IS		 1318 neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
1319 if (!entry_connected && !neigh_entry)
1320 goto out;
1321 if (!neigh_entry) {
1322 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
1323 if (IS_ERR(neigh_entry))
1324 goto out;
a6bf9e93
YG		 1325 }
1326
5c8802f1
IS		 1327 memcpy(neigh_entry->ha, ha, ETH_ALEN);
1328 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, entry_connected);
1329 mlxsw_sp_nexthop_neigh_update(mlxsw_sp, neigh_entry, !entry_connected);
1330
1331 if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
1332 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
1333
1334out:
1335 rtnl_unlock();
a6bf9e93 1336 neigh_release(n);
5c8802f1 1337 kfree(neigh_work);
a6bf9e93
YG		 1338}
1339
e7322638
JP		 1340int mlxsw_sp_router_netevent_event(struct notifier_block *unused,
1341 unsigned long event, void *ptr)
c723c735 1342{
5c8802f1 1343 struct mlxsw_sp_neigh_event_work *neigh_work;
c723c735
YG		 1344 struct mlxsw_sp_port *mlxsw_sp_port;
1345 struct mlxsw_sp *mlxsw_sp;
1346 unsigned long interval;
1347 struct neigh_parms *p;
a6bf9e93 1348 struct neighbour *n;
c723c735
YG		 1349
1350 switch (event) {
1351 case NETEVENT_DELAY_PROBE_TIME_UPDATE:
1352 p = ptr;
1353
1354 /* We don't care about changes in the default table. */
b5f3e0d4
IS		 1355 if (!p->dev || (p->tbl->family != AF_INET &&
1356 p->tbl->family != AF_INET6))
c723c735
YG		 1357 return NOTIFY_DONE;
1358
1359 /* We are in atomic context and can't take RTNL mutex,
1360 * so use RCU variant to walk the device chain.
1361 */
1362 mlxsw_sp_port = mlxsw_sp_port_lower_dev_hold(p->dev);
1363 if (!mlxsw_sp_port)
1364 return NOTIFY_DONE;
1365
1366 mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1367 interval = jiffies_to_msecs(NEIGH_VAR(p, DELAY_PROBE_TIME));
9011b677 1368 mlxsw_sp->router->neighs_update.interval = interval;
c723c735
YG		 1369
1370 mlxsw_sp_port_dev_put(mlxsw_sp_port);
1371 break;
a6bf9e93
YG		 1372 case NETEVENT_NEIGH_UPDATE:
1373 n = ptr;
a6bf9e93 1374
b5f3e0d4 1375 if (n->tbl->family != AF_INET && n->tbl->family != AF_INET6)
a6bf9e93
YG		 1376 return NOTIFY_DONE;
1377
5c8802f1 1378 mlxsw_sp_port = mlxsw_sp_port_lower_dev_hold(n->dev);
a6bf9e93
YG		 1379 if (!mlxsw_sp_port)
1380 return NOTIFY_DONE;
1381
5c8802f1
IS		 1382 neigh_work = kzalloc(sizeof(*neigh_work), GFP_ATOMIC);
1383 if (!neigh_work) {
a6bf9e93 1384 mlxsw_sp_port_dev_put(mlxsw_sp_port);
5c8802f1 1385 return NOTIFY_BAD;
a6bf9e93 1386 }
5c8802f1
IS		 1387
1388 INIT_WORK(&neigh_work->work, mlxsw_sp_router_neigh_event_work);
1389 neigh_work->mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1390 neigh_work->n = n;
a6bf9e93
YG		 1391
1392 /* Take a reference to ensure the neighbour won't be
1393 * destructed until we drop the reference in delayed
1394 * work.
1395 */
1396 neigh_clone(n);
5c8802f1
IS		 1397 mlxsw_core_schedule_work(&neigh_work->work);
1398 mlxsw_sp_port_dev_put(mlxsw_sp_port);
a6bf9e93 1399 break;
c723c735
YG		 1400 }
1401
1402 return NOTIFY_DONE;
1403}
1404
6cf3c971
JP		 1405static int mlxsw_sp_neigh_init(struct mlxsw_sp *mlxsw_sp)
1406{
c723c735
YG		 1407 int err;
1408
9011b677 1409 err = rhashtable_init(&mlxsw_sp->router->neigh_ht,
c723c735
YG		 1410 &mlxsw_sp_neigh_ht_params);
1411 if (err)
1412 return err;
1413
1414 /* Initialize the polling interval according to the default
1415 * table.
1416 */
1417 mlxsw_sp_router_neighs_update_interval_init(mlxsw_sp);
1418
0b2361d9 1419 /* Create the delayed works for the activity_update */
9011b677 1420 INIT_DELAYED_WORK(&mlxsw_sp->router->neighs_update.dw,
c723c735 1421 mlxsw_sp_router_neighs_update_work);
9011b677 1422 INIT_DELAYED_WORK(&mlxsw_sp->router->nexthop_probe_dw,
0b2361d9 1423 mlxsw_sp_router_probe_unresolved_nexthops);
9011b677
IS		 1424 mlxsw_core_schedule_dw(&mlxsw_sp->router->neighs_update.dw, 0);
1425 mlxsw_core_schedule_dw(&mlxsw_sp->router->nexthop_probe_dw, 0);
c723c735 1426 return 0;
6cf3c971
JP		 1427}
1428
1429static void mlxsw_sp_neigh_fini(struct mlxsw_sp *mlxsw_sp)
1430{
9011b677
IS		 1431 cancel_delayed_work_sync(&mlxsw_sp->router->neighs_update.dw);
1432 cancel_delayed_work_sync(&mlxsw_sp->router->nexthop_probe_dw);
1433 rhashtable_destroy(&mlxsw_sp->router->neigh_ht);
6cf3c971
JP		 1434}
1435
9665b745 1436static void mlxsw_sp_neigh_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
bf95233e 1437 struct mlxsw_sp_rif *rif)
9665b745
IS		 1438{
1439 struct mlxsw_sp_neigh_entry *neigh_entry, *tmp;
1440
bf95233e 1441 list_for_each_entry_safe(neigh_entry, tmp, &rif->neigh_list,
4a3c67a6
IS		 1442 rif_list_node) {
1443 mlxsw_sp_neigh_entry_update(mlxsw_sp, neigh_entry, false);
9665b745 1444 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
4a3c67a6 1445 }
9665b745
IS		 1446}
1447
c53b8e1b
IS		 1448struct mlxsw_sp_nexthop_key {
1449 struct fib_nh *fib_nh;
1450};
1451
a7ff87ac
JP		 1452struct mlxsw_sp_nexthop {
1453 struct list_head neigh_list_node; /* member of neigh entry list */
9665b745 1454 struct list_head rif_list_node;
a7ff87ac
JP		 1455 struct mlxsw_sp_nexthop_group *nh_grp; /* pointer back to the group
1456 * this belongs to
1457 */
c53b8e1b
IS		 1458 struct rhash_head ht_node;
1459 struct mlxsw_sp_nexthop_key key;
58adf2c4 1460 unsigned char gw_addr[sizeof(struct in6_addr)];
bf95233e 1461 struct mlxsw_sp_rif *rif;
a7ff87ac
JP		 1462 u8 should_offload:1, /* set indicates this neigh is connected and
1463 * should be put to KVD linear area of this group.
1464 */
1465 offloaded:1, /* set in case the neigh is actually put into
1466 * KVD linear area of this group.
1467 */
1468 update:1; /* set indicates that MAC of this neigh should be
1469 * updated in HW
1470 */
1471 struct mlxsw_sp_neigh_entry *neigh_entry;
1472};
1473
e9ad5e7d
IS		 1474struct mlxsw_sp_nexthop_group_key {
1475 struct fib_info *fi;
1476};
1477
a7ff87ac 1478struct mlxsw_sp_nexthop_group {
e9ad5e7d 1479 struct rhash_head ht_node;
a7ff87ac 1480 struct list_head fib_list; /* list of fib entries that use this group */
58adf2c4 1481 struct neigh_table *neigh_tbl;
e9ad5e7d 1482 struct mlxsw_sp_nexthop_group_key key;
b3e8d1eb
IS		 1483 u8 adj_index_valid:1,
1484 gateway:1; /* routes using the group use a gateway */
a7ff87ac
JP		 1485 u32 adj_index;
1486 u16 ecmp_size;
1487 u16 count;
1488 struct mlxsw_sp_nexthop nexthops[0];
bf95233e 1489#define nh_rif nexthops[0].rif
a7ff87ac
JP		 1490};
1491
e9ad5e7d
IS		 1492static const struct rhashtable_params mlxsw_sp_nexthop_group_ht_params = {
1493 .key_offset = offsetof(struct mlxsw_sp_nexthop_group, key),
1494 .head_offset = offsetof(struct mlxsw_sp_nexthop_group, ht_node),
1495 .key_len = sizeof(struct mlxsw_sp_nexthop_group_key),
1496};
1497
1498static int mlxsw_sp_nexthop_group_insert(struct mlxsw_sp *mlxsw_sp,
1499 struct mlxsw_sp_nexthop_group *nh_grp)
1500{
9011b677 1501 return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_group_ht,
e9ad5e7d
IS		 1502 &nh_grp->ht_node,
1503 mlxsw_sp_nexthop_group_ht_params);
1504}
1505
1506static void mlxsw_sp_nexthop_group_remove(struct mlxsw_sp *mlxsw_sp,
1507 struct mlxsw_sp_nexthop_group *nh_grp)
1508{
9011b677 1509 rhashtable_remove_fast(&mlxsw_sp->router->nexthop_group_ht,
e9ad5e7d
IS		 1510 &nh_grp->ht_node,
1511 mlxsw_sp_nexthop_group_ht_params);
1512}
1513
1514static struct mlxsw_sp_nexthop_group *
1515mlxsw_sp_nexthop_group_lookup(struct mlxsw_sp *mlxsw_sp,
1516 struct mlxsw_sp_nexthop_group_key key)
1517{
9011b677 1518 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_group_ht, &key,
e9ad5e7d
IS		 1519 mlxsw_sp_nexthop_group_ht_params);
1520}
1521
c53b8e1b
IS		 1522static const struct rhashtable_params mlxsw_sp_nexthop_ht_params = {
1523 .key_offset = offsetof(struct mlxsw_sp_nexthop, key),
1524 .head_offset = offsetof(struct mlxsw_sp_nexthop, ht_node),
1525 .key_len = sizeof(struct mlxsw_sp_nexthop_key),
1526};
1527
1528static int mlxsw_sp_nexthop_insert(struct mlxsw_sp *mlxsw_sp,
1529 struct mlxsw_sp_nexthop *nh)
1530{
9011b677 1531 return rhashtable_insert_fast(&mlxsw_sp->router->nexthop_ht,
c53b8e1b
IS		 1532 &nh->ht_node, mlxsw_sp_nexthop_ht_params);
1533}
1534
1535static void mlxsw_sp_nexthop_remove(struct mlxsw_sp *mlxsw_sp,
1536 struct mlxsw_sp_nexthop *nh)
1537{
9011b677 1538 rhashtable_remove_fast(&mlxsw_sp->router->nexthop_ht, &nh->ht_node,
c53b8e1b
IS		 1539 mlxsw_sp_nexthop_ht_params);
1540}
1541
ad178c8e
IS		 1542static struct mlxsw_sp_nexthop *
1543mlxsw_sp_nexthop_lookup(struct mlxsw_sp *mlxsw_sp,
1544 struct mlxsw_sp_nexthop_key key)
1545{
9011b677 1546 return rhashtable_lookup_fast(&mlxsw_sp->router->nexthop_ht, &key,
ad178c8e
IS		 1547 mlxsw_sp_nexthop_ht_params);
1548}
1549
a7ff87ac 1550static int mlxsw_sp_adj_index_mass_update_vr(struct mlxsw_sp *mlxsw_sp,
76610ebb 1551 const struct mlxsw_sp_fib *fib,
a7ff87ac
JP		 1552 u32 adj_index, u16 ecmp_size,
1553 u32 new_adj_index,
1554 u16 new_ecmp_size)
1555{
1556 char raleu_pl[MLXSW_REG_RALEU_LEN];
1557
1a9234e6 1558 mlxsw_reg_raleu_pack(raleu_pl,
76610ebb
IS		 1559 (enum mlxsw_reg_ralxx_protocol) fib->proto,
1560 fib->vr->id, adj_index, ecmp_size, new_adj_index,
1a9234e6 1561 new_ecmp_size);
a7ff87ac
JP		 1562 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raleu), raleu_pl);
1563}
1564
1565static int mlxsw_sp_adj_index_mass_update(struct mlxsw_sp *mlxsw_sp,
1566 struct mlxsw_sp_nexthop_group *nh_grp,
1567 u32 old_adj_index, u16 old_ecmp_size)
1568{
1569 struct mlxsw_sp_fib_entry *fib_entry;
76610ebb 1570 struct mlxsw_sp_fib *fib = NULL;
a7ff87ac
JP		 1571 int err;
1572
1573 list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
76610ebb 1574 if (fib == fib_entry->fib_node->fib)
a7ff87ac 1575 continue;
76610ebb
IS		 1576 fib = fib_entry->fib_node->fib;
1577 err = mlxsw_sp_adj_index_mass_update_vr(mlxsw_sp, fib,
a7ff87ac
JP		 1578 old_adj_index,
1579 old_ecmp_size,
1580 nh_grp->adj_index,
1581 nh_grp->ecmp_size);
1582 if (err)
1583 return err;
1584 }
1585 return 0;
1586}
1587
1588static int mlxsw_sp_nexthop_mac_update(struct mlxsw_sp *mlxsw_sp, u32 adj_index,
1589 struct mlxsw_sp_nexthop *nh)
1590{
1591 struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
1592 char ratr_pl[MLXSW_REG_RATR_LEN];
1593
1594 mlxsw_reg_ratr_pack(ratr_pl, MLXSW_REG_RATR_OP_WRITE_WRITE_ENTRY,
1595 true, adj_index, neigh_entry->rif);
1596 mlxsw_reg_ratr_eth_entry_pack(ratr_pl, neigh_entry->ha);
1597 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ratr), ratr_pl);
1598}
1599
1600static int
1601mlxsw_sp_nexthop_group_mac_update(struct mlxsw_sp *mlxsw_sp,
a59b7e02
IS		 1602 struct mlxsw_sp_nexthop_group *nh_grp,
1603 bool reallocate)
a7ff87ac
JP		 1604{
1605 u32 adj_index = nh_grp->adj_index; /* base */
1606 struct mlxsw_sp_nexthop *nh;
1607 int i;
1608 int err;
1609
1610 for (i = 0; i < nh_grp->count; i++) {
1611 nh = &nh_grp->nexthops[i];
1612
1613 if (!nh->should_offload) {
1614 nh->offloaded = 0;
1615 continue;
1616 }
1617
a59b7e02 1618 if (nh->update || reallocate) {
a7ff87ac
JP		 1619 err = mlxsw_sp_nexthop_mac_update(mlxsw_sp,
1620 adj_index, nh);
1621 if (err)
1622 return err;
1623 nh->update = 0;
1624 nh->offloaded = 1;
1625 }
1626 adj_index++;
1627 }
1628 return 0;
1629}
1630
1631static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
1632 struct mlxsw_sp_fib_entry *fib_entry);
1633
1634static int
1635mlxsw_sp_nexthop_fib_entries_update(struct mlxsw_sp *mlxsw_sp,
1636 struct mlxsw_sp_nexthop_group *nh_grp)
1637{
1638 struct mlxsw_sp_fib_entry *fib_entry;
1639 int err;
1640
1641 list_for_each_entry(fib_entry, &nh_grp->fib_list, nexthop_group_node) {
1642 err = mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
1643 if (err)
1644 return err;
1645 }
1646 return 0;
1647}
1648
1649static void
1650mlxsw_sp_nexthop_group_refresh(struct mlxsw_sp *mlxsw_sp,
1651 struct mlxsw_sp_nexthop_group *nh_grp)
1652{
1653 struct mlxsw_sp_nexthop *nh;
1654 bool offload_change = false;
1655 u32 adj_index;
1656 u16 ecmp_size = 0;
1657 bool old_adj_index_valid;
1658 u32 old_adj_index;
1659 u16 old_ecmp_size;
a7ff87ac
JP		 1660 int i;
1661 int err;
1662
b3e8d1eb
IS		 1663 if (!nh_grp->gateway) {
1664 mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
1665 return;
1666 }
1667
a7ff87ac
JP		 1668 for (i = 0; i < nh_grp->count; i++) {
1669 nh = &nh_grp->nexthops[i];
1670
1671 if (nh->should_offload ^ nh->offloaded) {
1672 offload_change = true;
1673 if (nh->should_offload)
1674 nh->update = 1;
1675 }
1676 if (nh->should_offload)
1677 ecmp_size++;
1678 }
1679 if (!offload_change) {
1680 /* Nothing was added or removed, so no need to reallocate. Just
1681 * update MAC on existing adjacency indexes.
1682 */
a59b7e02
IS		 1683 err = mlxsw_sp_nexthop_group_mac_update(mlxsw_sp, nh_grp,
1684 false);
a7ff87ac
JP		 1685 if (err) {
1686 dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
1687 goto set_trap;
1688 }
1689 return;
1690 }
1691 if (!ecmp_size)
1692 /* No neigh of this group is connected so we just set
1693 * the trap and let everthing flow through kernel.
1694 */
1695 goto set_trap;
1696
13124443
AS		 1697 err = mlxsw_sp_kvdl_alloc(mlxsw_sp, ecmp_size, &adj_index);
1698 if (err) {
a7ff87ac
JP		 1699 /* We ran out of KVD linear space, just set the
1700 * trap and let everything flow through kernel.
1701 */
1702 dev_warn(mlxsw_sp->bus_info->dev, "Failed to allocate KVD linear area for nexthop group.\n");
1703 goto set_trap;
1704 }
a7ff87ac
JP		 1705 old_adj_index_valid = nh_grp->adj_index_valid;
1706 old_adj_index = nh_grp->adj_index;
1707 old_ecmp_size = nh_grp->ecmp_size;
1708 nh_grp->adj_index_valid = 1;
1709 nh_grp->adj_index = adj_index;
1710 nh_grp->ecmp_size = ecmp_size;
a59b7e02 1711 err = mlxsw_sp_nexthop_group_mac_update(mlxsw_sp, nh_grp, true);
a7ff87ac
JP		 1712 if (err) {
1713 dev_warn(mlxsw_sp->bus_info->dev, "Failed to update neigh MAC in adjacency table.\n");
1714 goto set_trap;
1715 }
1716
1717 if (!old_adj_index_valid) {
1718 /* The trap was set for fib entries, so we have to call
1719 * fib entry update to unset it and use adjacency index.
1720 */
1721 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
1722 if (err) {
1723 dev_warn(mlxsw_sp->bus_info->dev, "Failed to add adjacency index to fib entries.\n");
1724 goto set_trap;
1725 }
1726 return;
1727 }
1728
1729 err = mlxsw_sp_adj_index_mass_update(mlxsw_sp, nh_grp,
1730 old_adj_index, old_ecmp_size);
1731 mlxsw_sp_kvdl_free(mlxsw_sp, old_adj_index);
1732 if (err) {
1733 dev_warn(mlxsw_sp->bus_info->dev, "Failed to mass-update adjacency index for nexthop group.\n");
1734 goto set_trap;
1735 }
1736 return;
1737
1738set_trap:
1739 old_adj_index_valid = nh_grp->adj_index_valid;
1740 nh_grp->adj_index_valid = 0;
1741 for (i = 0; i < nh_grp->count; i++) {
1742 nh = &nh_grp->nexthops[i];
1743 nh->offloaded = 0;
1744 }
1745 err = mlxsw_sp_nexthop_fib_entries_update(mlxsw_sp, nh_grp);
1746 if (err)
1747 dev_warn(mlxsw_sp->bus_info->dev, "Failed to set traps for fib entries.\n");
1748 if (old_adj_index_valid)
1749 mlxsw_sp_kvdl_free(mlxsw_sp, nh_grp->adj_index);
1750}
1751
1752static void __mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp_nexthop *nh,
1753 bool removing)
1754{
1755 if (!removing && !nh->should_offload)
1756 nh->should_offload = 1;
1757 else if (removing && nh->offloaded)
1758 nh->should_offload = 0;
1759 nh->update = 1;
1760}
1761
1762static void
1763mlxsw_sp_nexthop_neigh_update(struct mlxsw_sp *mlxsw_sp,
1764 struct mlxsw_sp_neigh_entry *neigh_entry,
1765 bool removing)
1766{
1767 struct mlxsw_sp_nexthop *nh;
1768
a7ff87ac
JP		 1769 list_for_each_entry(nh, &neigh_entry->nexthop_list,
1770 neigh_list_node) {
1771 __mlxsw_sp_nexthop_neigh_update(nh, removing);
1772 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
1773 }
a7ff87ac
JP		 1774}
1775
9665b745 1776static void mlxsw_sp_nexthop_rif_init(struct mlxsw_sp_nexthop *nh,
bf95233e 1777 struct mlxsw_sp_rif *rif)
9665b745 1778{
bf95233e 1779 if (nh->rif)
9665b745
IS		 1780 return;
1781
bf95233e
AS		 1782 nh->rif = rif;
1783 list_add(&nh->rif_list_node, &rif->nexthop_list);
9665b745
IS		 1784}
1785
1786static void mlxsw_sp_nexthop_rif_fini(struct mlxsw_sp_nexthop *nh)
1787{
bf95233e 1788 if (!nh->rif)
9665b745
IS		 1789 return;
1790
1791 list_del(&nh->rif_list_node);
bf95233e 1792 nh->rif = NULL;
9665b745
IS		 1793}
1794
a8c97014
IS		 1795static int mlxsw_sp_nexthop_neigh_init(struct mlxsw_sp *mlxsw_sp,
1796 struct mlxsw_sp_nexthop *nh)
a7ff87ac
JP		 1797{
1798 struct mlxsw_sp_neigh_entry *neigh_entry;
a7ff87ac 1799 struct neighbour *n;
93a87e5e 1800 u8 nud_state, dead;
c53b8e1b
IS		 1801 int err;
1802
ad178c8e 1803 if (!nh->nh_grp->gateway || nh->neigh_entry)
b8399a1e
IS		 1804 return 0;
1805
33b1341c 1806 /* Take a reference of neigh here ensuring that neigh would
8de3c178 1807 * not be destructed before the nexthop entry is finished.
33b1341c 1808 * The reference is taken either in neigh_lookup() or
fd76d910 1809 * in neigh_create() in case n is not found.
33b1341c 1810 */
58adf2c4 1811 n = neigh_lookup(nh->nh_grp->neigh_tbl, &nh->gw_addr, nh->rif->dev);
33b1341c 1812 if (!n) {
58adf2c4
IS		 1813 n = neigh_create(nh->nh_grp->neigh_tbl, &nh->gw_addr,
1814 nh->rif->dev);
a8c97014
IS		 1815 if (IS_ERR(n))
1816 return PTR_ERR(n);
a7ff87ac 1817 neigh_event_send(n, NULL);
33b1341c
JP		 1818 }
1819 neigh_entry = mlxsw_sp_neigh_entry_lookup(mlxsw_sp, n);
1820 if (!neigh_entry) {
5c8802f1
IS		 1821 neigh_entry = mlxsw_sp_neigh_entry_create(mlxsw_sp, n);
1822 if (IS_ERR(neigh_entry)) {
c53b8e1b
IS		 1823 err = -EINVAL;
1824 goto err_neigh_entry_create;
5c8802f1 1825 }
a7ff87ac 1826 }
b2157149
YG		 1827
1828 /* If that is the first nexthop connected to that neigh, add to
1829 * nexthop_neighs_list
1830 */
1831 if (list_empty(&neigh_entry->nexthop_list))
1832 list_add_tail(&neigh_entry->nexthop_neighs_list_node,
9011b677 1833 &mlxsw_sp->router->nexthop_neighs_list);
b2157149 1834
a7ff87ac
JP		 1835 nh->neigh_entry = neigh_entry;
1836 list_add_tail(&nh->neigh_list_node, &neigh_entry->nexthop_list);
1837 read_lock_bh(&n->lock);
1838 nud_state = n->nud_state;
93a87e5e 1839 dead = n->dead;
a7ff87ac 1840 read_unlock_bh(&n->lock);
93a87e5e 1841 __mlxsw_sp_nexthop_neigh_update(nh, !(nud_state & NUD_VALID && !dead));
a7ff87ac
JP		 1842
1843 return 0;
c53b8e1b
IS		 1844
1845err_neigh_entry_create:
1846 neigh_release(n);
c53b8e1b 1847 return err;
a7ff87ac
JP		 1848}
1849
a8c97014
IS		 1850static void mlxsw_sp_nexthop_neigh_fini(struct mlxsw_sp *mlxsw_sp,
1851 struct mlxsw_sp_nexthop *nh)
a7ff87ac
JP		 1852{
1853 struct mlxsw_sp_neigh_entry *neigh_entry = nh->neigh_entry;
a8c97014 1854 struct neighbour *n;
a7ff87ac 1855
b8399a1e 1856 if (!neigh_entry)
a8c97014
IS		 1857 return;
1858 n = neigh_entry->key.n;
b8399a1e 1859
58312125 1860 __mlxsw_sp_nexthop_neigh_update(nh, true);
a7ff87ac 1861 list_del(&nh->neigh_list_node);
e58be79e 1862 nh->neigh_entry = NULL;
b2157149
YG		 1863
1864 /* If that is the last nexthop connected to that neigh, remove from
1865 * nexthop_neighs_list
1866 */
e58be79e
IS		 1867 if (list_empty(&neigh_entry->nexthop_list))
1868 list_del(&neigh_entry->nexthop_neighs_list_node);
b2157149 1869
5c8802f1
IS		 1870 if (!neigh_entry->connected && list_empty(&neigh_entry->nexthop_list))
1871 mlxsw_sp_neigh_entry_destroy(mlxsw_sp, neigh_entry);
1872
1873 neigh_release(n);
a8c97014 1874}
c53b8e1b 1875
0e6ea2a4
IS		 1876static int mlxsw_sp_nexthop4_init(struct mlxsw_sp *mlxsw_sp,
1877 struct mlxsw_sp_nexthop_group *nh_grp,
1878 struct mlxsw_sp_nexthop *nh,
1879 struct fib_nh *fib_nh)
a8c97014
IS		 1880{
1881 struct net_device *dev = fib_nh->nh_dev;
df6dd79b 1882 struct in_device *in_dev;
bf95233e 1883 struct mlxsw_sp_rif *rif;
a8c97014
IS		 1884 int err;
1885
1886 nh->nh_grp = nh_grp;
1887 nh->key.fib_nh = fib_nh;
58adf2c4 1888 memcpy(&nh->gw_addr, &fib_nh->nh_gw, sizeof(fib_nh->nh_gw));
a8c97014
IS		 1889 err = mlxsw_sp_nexthop_insert(mlxsw_sp, nh);
1890 if (err)
1891 return err;
1892
97989ee0
IS		 1893 if (!dev)
1894 return 0;
1895
df6dd79b
IS		 1896 in_dev = __in_dev_get_rtnl(dev);
1897 if (in_dev && IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) &&
1898 fib_nh->nh_flags & RTNH_F_LINKDOWN)
1899 return 0;
1900
bf95233e
AS		 1901 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
1902 if (!rif)
a8c97014 1903 return 0;
bf95233e 1904 mlxsw_sp_nexthop_rif_init(nh, rif);
a8c97014
IS		 1905
1906 err = mlxsw_sp_nexthop_neigh_init(mlxsw_sp, nh);
1907 if (err)
1908 goto err_nexthop_neigh_init;
1909
1910 return 0;
1911
1912err_nexthop_neigh_init:
a4e75b76 1913 mlxsw_sp_nexthop_rif_fini(nh);
a8c97014
IS		 1914 mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
1915 return err;
1916}
1917
0e6ea2a4
IS		 1918static void mlxsw_sp_nexthop4_fini(struct mlxsw_sp *mlxsw_sp,
1919 struct mlxsw_sp_nexthop *nh)
a8c97014
IS		 1920{
1921 mlxsw_sp_nexthop_neigh_fini(mlxsw_sp, nh);
9665b745 1922 mlxsw_sp_nexthop_rif_fini(nh);
c53b8e1b 1923 mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
a7ff87ac
JP		 1924}
1925
0e6ea2a4
IS		 1926static void mlxsw_sp_nexthop4_event(struct mlxsw_sp *mlxsw_sp,
1927 unsigned long event, struct fib_nh *fib_nh)
ad178c8e
IS		 1928{
1929 struct mlxsw_sp_nexthop_key key;
1930 struct mlxsw_sp_nexthop *nh;
bf95233e 1931 struct mlxsw_sp_rif *rif;
ad178c8e 1932
9011b677 1933 if (mlxsw_sp->router->aborted)
ad178c8e
IS		 1934 return;
1935
1936 key.fib_nh = fib_nh;
1937 nh = mlxsw_sp_nexthop_lookup(mlxsw_sp, key);
1938 if (WARN_ON_ONCE(!nh))
1939 return;
1940
bf95233e
AS		 1941 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, fib_nh->nh_dev);
1942 if (!rif)
ad178c8e
IS		 1943 return;
1944
1945 switch (event) {
1946 case FIB_EVENT_NH_ADD:
bf95233e 1947 mlxsw_sp_nexthop_rif_init(nh, rif);
ad178c8e
IS		 1948 mlxsw_sp_nexthop_neigh_init(mlxsw_sp, nh);
1949 break;
1950 case FIB_EVENT_NH_DEL:
1951 mlxsw_sp_nexthop_neigh_fini(mlxsw_sp, nh);
9665b745 1952 mlxsw_sp_nexthop_rif_fini(nh);
ad178c8e
IS		 1953 break;
1954 }
1955
1956 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
1957}
1958
9665b745 1959static void mlxsw_sp_nexthop_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
bf95233e 1960 struct mlxsw_sp_rif *rif)
9665b745
IS		 1961{
1962 struct mlxsw_sp_nexthop *nh, *tmp;
1963
bf95233e 1964 list_for_each_entry_safe(nh, tmp, &rif->nexthop_list, rif_list_node) {
9665b745
IS		 1965 mlxsw_sp_nexthop_neigh_fini(mlxsw_sp, nh);
1966 mlxsw_sp_nexthop_rif_fini(nh);
1967 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh->nh_grp);
1968 }
1969}
1970
a7ff87ac 1971static struct mlxsw_sp_nexthop_group *
0e6ea2a4 1972mlxsw_sp_nexthop4_group_create(struct mlxsw_sp *mlxsw_sp, struct fib_info *fi)
a7ff87ac
JP		 1973{
1974 struct mlxsw_sp_nexthop_group *nh_grp;
1975 struct mlxsw_sp_nexthop *nh;
1976 struct fib_nh *fib_nh;
1977 size_t alloc_size;
1978 int i;
1979 int err;
1980
1981 alloc_size = sizeof(*nh_grp) +
1982 fi->fib_nhs * sizeof(struct mlxsw_sp_nexthop);
1983 nh_grp = kzalloc(alloc_size, GFP_KERNEL);
1984 if (!nh_grp)
1985 return ERR_PTR(-ENOMEM);
1986 INIT_LIST_HEAD(&nh_grp->fib_list);
58adf2c4
IS		 1987 nh_grp->neigh_tbl = &arp_tbl;
1988
b3e8d1eb 1989 nh_grp->gateway = fi->fib_nh->nh_scope == RT_SCOPE_LINK;
a7ff87ac 1990 nh_grp->count = fi->fib_nhs;
e9ad5e7d 1991 nh_grp->key.fi = fi;
7387dbbc 1992 fib_info_hold(fi);
a7ff87ac
JP		 1993 for (i = 0; i < nh_grp->count; i++) {
1994 nh = &nh_grp->nexthops[i];
1995 fib_nh = &fi->fib_nh[i];
0e6ea2a4 1996 err = mlxsw_sp_nexthop4_init(mlxsw_sp, nh_grp, nh, fib_nh);
a7ff87ac 1997 if (err)
0e6ea2a4 1998 goto err_nexthop4_init;
a7ff87ac 1999 }
e9ad5e7d
IS		 2000 err = mlxsw_sp_nexthop_group_insert(mlxsw_sp, nh_grp);
2001 if (err)
2002 goto err_nexthop_group_insert;
a7ff87ac
JP		 2003 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
2004 return nh_grp;
2005
e9ad5e7d 2006err_nexthop_group_insert:
0e6ea2a4 2007err_nexthop4_init:
df6dd79b
IS		 2008 for (i--; i >= 0; i--) {
2009 nh = &nh_grp->nexthops[i];
0e6ea2a4 2010 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
df6dd79b 2011 }
7387dbbc 2012 fib_info_put(nh_grp->key.fi);
a7ff87ac
JP		 2013 kfree(nh_grp);
2014 return ERR_PTR(err);
2015}
2016
2017static void
0e6ea2a4
IS		 2018mlxsw_sp_nexthop4_group_destroy(struct mlxsw_sp *mlxsw_sp,
2019 struct mlxsw_sp_nexthop_group *nh_grp)
a7ff87ac
JP		 2020{
2021 struct mlxsw_sp_nexthop *nh;
2022 int i;
2023
e9ad5e7d 2024 mlxsw_sp_nexthop_group_remove(mlxsw_sp, nh_grp);
a7ff87ac
JP		 2025 for (i = 0; i < nh_grp->count; i++) {
2026 nh = &nh_grp->nexthops[i];
0e6ea2a4 2027 mlxsw_sp_nexthop4_fini(mlxsw_sp, nh);
a7ff87ac 2028 }
58312125
IS		 2029 mlxsw_sp_nexthop_group_refresh(mlxsw_sp, nh_grp);
2030 WARN_ON_ONCE(nh_grp->adj_index_valid);
7387dbbc 2031 fib_info_put(nh_grp->key.fi);
a7ff87ac
JP		 2032 kfree(nh_grp);
2033}
2034
0e6ea2a4
IS		 2035static int mlxsw_sp_nexthop4_group_get(struct mlxsw_sp *mlxsw_sp,
2036 struct mlxsw_sp_fib_entry *fib_entry,
2037 struct fib_info *fi)
a7ff87ac 2038{
e9ad5e7d 2039 struct mlxsw_sp_nexthop_group_key key;
a7ff87ac
JP		 2040 struct mlxsw_sp_nexthop_group *nh_grp;
2041
e9ad5e7d
IS		 2042 key.fi = fi;
2043 nh_grp = mlxsw_sp_nexthop_group_lookup(mlxsw_sp, key);
a7ff87ac 2044 if (!nh_grp) {
0e6ea2a4 2045 nh_grp = mlxsw_sp_nexthop4_group_create(mlxsw_sp, fi);
a7ff87ac
JP		 2046 if (IS_ERR(nh_grp))
2047 return PTR_ERR(nh_grp);
2048 }
2049 list_add_tail(&fib_entry->nexthop_group_node, &nh_grp->fib_list);
2050 fib_entry->nh_group = nh_grp;
2051 return 0;
2052}
2053
0e6ea2a4
IS		 2054static void mlxsw_sp_nexthop4_group_put(struct mlxsw_sp *mlxsw_sp,
2055 struct mlxsw_sp_fib_entry *fib_entry)
a7ff87ac
JP		 2056{
2057 struct mlxsw_sp_nexthop_group *nh_grp = fib_entry->nh_group;
2058
2059 list_del(&fib_entry->nexthop_group_node);
2060 if (!list_empty(&nh_grp->fib_list))
2061 return;
0e6ea2a4 2062 mlxsw_sp_nexthop4_group_destroy(mlxsw_sp, nh_grp);
a7ff87ac
JP		 2063}
2064
4f1c7f1f
IS		 2065static bool
2066mlxsw_sp_fib4_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
2067{
2068 struct mlxsw_sp_fib4_entry *fib4_entry;
2069
2070 fib4_entry = container_of(fib_entry, struct mlxsw_sp_fib4_entry,
2071 common);
2072 return !fib4_entry->tos;
2073}
2074
013b20f9
IS		 2075static bool
2076mlxsw_sp_fib_entry_should_offload(const struct mlxsw_sp_fib_entry *fib_entry)
2077{
2078 struct mlxsw_sp_nexthop_group *nh_group = fib_entry->nh_group;
2079
4f1c7f1f
IS		 2080 switch (fib_entry->fib_node->fib->proto) {
2081 case MLXSW_SP_L3_PROTO_IPV4:
2082 if (!mlxsw_sp_fib4_entry_should_offload(fib_entry))
2083 return false;
2084 break;
2085 case MLXSW_SP_L3_PROTO_IPV6:
2086 break;
2087 }
9aecce1c 2088
013b20f9
IS		 2089 switch (fib_entry->type) {
2090 case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
2091 return !!nh_group->adj_index_valid;
2092 case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
70ad3506 2093 return !!nh_group->nh_rif;
013b20f9
IS		 2094 default:
2095 return false;
2096 }
2097}
2098
2099static void mlxsw_sp_fib_entry_offload_set(struct mlxsw_sp_fib_entry *fib_entry)
2100{
2101 fib_entry->offloaded = true;
2102
76610ebb 2103 switch (fib_entry->fib_node->fib->proto) {
013b20f9
IS		 2104 case MLXSW_SP_L3_PROTO_IPV4:
2105 fib_info_offload_inc(fib_entry->nh_group->key.fi);
2106 break;
2107 case MLXSW_SP_L3_PROTO_IPV6:
2108 WARN_ON_ONCE(1);
2109 }
2110}
2111
2112static void
2113mlxsw_sp_fib_entry_offload_unset(struct mlxsw_sp_fib_entry *fib_entry)
2114{
76610ebb 2115 switch (fib_entry->fib_node->fib->proto) {
013b20f9
IS		 2116 case MLXSW_SP_L3_PROTO_IPV4:
2117 fib_info_offload_dec(fib_entry->nh_group->key.fi);
2118 break;
2119 case MLXSW_SP_L3_PROTO_IPV6:
2120 WARN_ON_ONCE(1);
2121 }
2122
2123 fib_entry->offloaded = false;
2124}
2125
2126static void
2127mlxsw_sp_fib_entry_offload_refresh(struct mlxsw_sp_fib_entry *fib_entry,
2128 enum mlxsw_reg_ralue_op op, int err)
2129{
2130 switch (op) {
2131 case MLXSW_REG_RALUE_OP_WRITE_DELETE:
2132 if (!fib_entry->offloaded)
2133 return;
2134 return mlxsw_sp_fib_entry_offload_unset(fib_entry);
2135 case MLXSW_REG_RALUE_OP_WRITE_WRITE:
2136 if (err)
2137 return;
2138 if (mlxsw_sp_fib_entry_should_offload(fib_entry) &&
2139 !fib_entry->offloaded)
2140 mlxsw_sp_fib_entry_offload_set(fib_entry);
2141 else if (!mlxsw_sp_fib_entry_should_offload(fib_entry) &&
2142 fib_entry->offloaded)
2143 mlxsw_sp_fib_entry_offload_unset(fib_entry);
2144 return;
2145 default:
2146 return;
2147 }
2148}
2149
9dbf4d76
IS		 2150static void
2151mlxsw_sp_fib_entry_ralue_pack(char *ralue_pl,
2152 const struct mlxsw_sp_fib_entry *fib_entry,
2153 enum mlxsw_reg_ralue_op op)
a7ff87ac 2154{
76610ebb 2155 struct mlxsw_sp_fib *fib = fib_entry->fib_node->fib;
9dbf4d76
IS		 2156 enum mlxsw_reg_ralxx_protocol proto;
2157 u32 *p_dip;
2158
2159 proto = (enum mlxsw_reg_ralxx_protocol) fib->proto;
2160
2161 switch (fib->proto) {
2162 case MLXSW_SP_L3_PROTO_IPV4:
2163 p_dip = (u32 *) fib_entry->fib_node->key.addr;
2164 mlxsw_reg_ralue_pack4(ralue_pl, proto, op, fib->vr->id,
2165 fib_entry->fib_node->key.prefix_len,
2166 *p_dip);
2167 break;
2168 case MLXSW_SP_L3_PROTO_IPV6:
2169 mlxsw_reg_ralue_pack6(ralue_pl, proto, op, fib->vr->id,
2170 fib_entry->fib_node->key.prefix_len,
2171 fib_entry->fib_node->key.addr);
2172 break;
2173 }
2174}
2175
2176static int mlxsw_sp_fib_entry_op_remote(struct mlxsw_sp *mlxsw_sp,
2177 struct mlxsw_sp_fib_entry *fib_entry,
2178 enum mlxsw_reg_ralue_op op)
2179{
2180 char ralue_pl[MLXSW_REG_RALUE_LEN];
a7ff87ac
JP		 2181 enum mlxsw_reg_ralue_trap_action trap_action;
2182 u16 trap_id = 0;
2183 u32 adjacency_index = 0;
2184 u16 ecmp_size = 0;
2185
2186 /* In case the nexthop group adjacency index is valid, use it
2187 * with provided ECMP size. Otherwise, setup trap and pass
2188 * traffic to kernel.
2189 */
4b411477 2190 if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
a7ff87ac
JP		 2191 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
2192 adjacency_index = fib_entry->nh_group->adj_index;
2193 ecmp_size = fib_entry->nh_group->ecmp_size;
2194 } else {
2195 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
2196 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
2197 }
2198
9dbf4d76 2199 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
a7ff87ac
JP		 2200 mlxsw_reg_ralue_act_remote_pack(ralue_pl, trap_action, trap_id,
2201 adjacency_index, ecmp_size);
2202 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
2203}
2204
9dbf4d76
IS		 2205static int mlxsw_sp_fib_entry_op_local(struct mlxsw_sp *mlxsw_sp,
2206 struct mlxsw_sp_fib_entry *fib_entry,
2207 enum mlxsw_reg_ralue_op op)
61c503f9 2208{
bf95233e 2209 struct mlxsw_sp_rif *rif = fib_entry->nh_group->nh_rif;
70ad3506 2210 enum mlxsw_reg_ralue_trap_action trap_action;
61c503f9 2211 char ralue_pl[MLXSW_REG_RALUE_LEN];
70ad3506 2212 u16 trap_id = 0;
bf95233e 2213 u16 rif_index = 0;
70ad3506
IS		 2214
2215 if (mlxsw_sp_fib_entry_should_offload(fib_entry)) {
2216 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_NOP;
bf95233e 2217 rif_index = rif->rif_index;
70ad3506
IS		 2218 } else {
2219 trap_action = MLXSW_REG_RALUE_TRAP_ACTION_TRAP;
2220 trap_id = MLXSW_TRAP_ID_RTR_INGRESS0;
2221 }
61c503f9 2222
9dbf4d76 2223 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
bf95233e
AS		 2224 mlxsw_reg_ralue_act_local_pack(ralue_pl, trap_action, trap_id,
2225 rif_index);
61c503f9
JP		 2226 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
2227}
2228
9dbf4d76
IS		 2229static int mlxsw_sp_fib_entry_op_trap(struct mlxsw_sp *mlxsw_sp,
2230 struct mlxsw_sp_fib_entry *fib_entry,
2231 enum mlxsw_reg_ralue_op op)
61c503f9
JP		 2232{
2233 char ralue_pl[MLXSW_REG_RALUE_LEN];
61c503f9 2234
9dbf4d76 2235 mlxsw_sp_fib_entry_ralue_pack(ralue_pl, fib_entry, op);
61c503f9
JP		 2236 mlxsw_reg_ralue_act_ip2me_pack(ralue_pl);
2237 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue), ralue_pl);
2238}
2239
9dbf4d76
IS		 2240static int __mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
2241 struct mlxsw_sp_fib_entry *fib_entry,
2242 enum mlxsw_reg_ralue_op op)
61c503f9
JP		 2243{
2244 switch (fib_entry->type) {
2245 case MLXSW_SP_FIB_ENTRY_TYPE_REMOTE:
9dbf4d76 2246 return mlxsw_sp_fib_entry_op_remote(mlxsw_sp, fib_entry, op);
61c503f9 2247 case MLXSW_SP_FIB_ENTRY_TYPE_LOCAL:
9dbf4d76 2248 return mlxsw_sp_fib_entry_op_local(mlxsw_sp, fib_entry, op);
61c503f9 2249 case MLXSW_SP_FIB_ENTRY_TYPE_TRAP:
9dbf4d76 2250 return mlxsw_sp_fib_entry_op_trap(mlxsw_sp, fib_entry, op);
61c503f9
JP		 2251 }
2252 return -EINVAL;
2253}
2254
2255static int mlxsw_sp_fib_entry_op(struct mlxsw_sp *mlxsw_sp,
2256 struct mlxsw_sp_fib_entry *fib_entry,
2257 enum mlxsw_reg_ralue_op op)
2258{
9dbf4d76 2259 int err = __mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry, op);
013b20f9 2260
013b20f9 2261 mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, err);
9dbf4d76 2262
013b20f9 2263 return err;
61c503f9
JP		 2264}
2265
2266static int mlxsw_sp_fib_entry_update(struct mlxsw_sp *mlxsw_sp,
2267 struct mlxsw_sp_fib_entry *fib_entry)
2268{
7146da31
JP		 2269 return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
2270 MLXSW_REG_RALUE_OP_WRITE_WRITE);
61c503f9
JP		 2271}
2272
2273static int mlxsw_sp_fib_entry_del(struct mlxsw_sp *mlxsw_sp,
2274 struct mlxsw_sp_fib_entry *fib_entry)
2275{
2276 return mlxsw_sp_fib_entry_op(mlxsw_sp, fib_entry,
2277 MLXSW_REG_RALUE_OP_WRITE_DELETE);
2278}
2279
61c503f9 2280static int
013b20f9
IS		 2281mlxsw_sp_fib4_entry_type_set(struct mlxsw_sp *mlxsw_sp,
2282 const struct fib_entry_notifier_info *fen_info,
2283 struct mlxsw_sp_fib_entry *fib_entry)
61c503f9 2284{
b45f64d1 2285 struct fib_info *fi = fen_info->fi;
61c503f9 2286
97989ee0
IS		 2287 switch (fen_info->type) {
2288 case RTN_BROADCAST: /* fall through */
2289 case RTN_LOCAL:
61c503f9
JP		 2290 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP;
2291 return 0;
97989ee0
IS		 2292 case RTN_UNREACHABLE: /* fall through */
2293 case RTN_BLACKHOLE: /* fall through */
2294 case RTN_PROHIBIT:
2295 /* Packets hitting these routes need to be trapped, but
2296 * can do so with a lower priority than packets directed
2297 * at the host, so use action type local instead of trap.
2298 */
61c503f9 2299 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
97989ee0
IS		 2300 return 0;
2301 case RTN_UNICAST:
2302 if (fi->fib_nh->nh_scope != RT_SCOPE_LINK)
2303 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL;
2304 else
2305 fib_entry->type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE;
2306 return 0;
2307 default:
2308 return -EINVAL;
2309 }
a7ff87ac
JP		 2310}
2311
4f1c7f1f 2312static struct mlxsw_sp_fib4_entry *
9aecce1c
IS		 2313mlxsw_sp_fib4_entry_create(struct mlxsw_sp *mlxsw_sp,
2314 struct mlxsw_sp_fib_node *fib_node,
2315 const struct fib_entry_notifier_info *fen_info)
61c503f9 2316{
4f1c7f1f 2317 struct mlxsw_sp_fib4_entry *fib4_entry;
61c503f9 2318 struct mlxsw_sp_fib_entry *fib_entry;
61c503f9
JP		 2319 int err;
2320
4f1c7f1f
IS		 2321 fib4_entry = kzalloc(sizeof(*fib4_entry), GFP_KERNEL);
2322 if (!fib4_entry)
2323 return ERR_PTR(-ENOMEM);
2324 fib_entry = &fib4_entry->common;
61c503f9 2325
013b20f9 2326 err = mlxsw_sp_fib4_entry_type_set(mlxsw_sp, fen_info, fib_entry);
61c503f9 2327 if (err)
013b20f9 2328 goto err_fib4_entry_type_set;
61c503f9 2329
0e6ea2a4 2330 err = mlxsw_sp_nexthop4_group_get(mlxsw_sp, fib_entry, fen_info->fi);
b8399a1e 2331 if (err)
0e6ea2a4 2332 goto err_nexthop4_group_get;
b8399a1e 2333
4f1c7f1f
IS		 2334 fib4_entry->prio = fen_info->fi->fib_priority;
2335 fib4_entry->tb_id = fen_info->tb_id;
2336 fib4_entry->type = fen_info->type;
2337 fib4_entry->tos = fen_info->tos;
9aecce1c
IS		 2338
2339 fib_entry->fib_node = fib_node;
2340
4f1c7f1f 2341 return fib4_entry;
5b004412 2342
0e6ea2a4 2343err_nexthop4_group_get:
013b20f9 2344err_fib4_entry_type_set:
4f1c7f1f 2345 kfree(fib4_entry);
5b004412
JP		 2346 return ERR_PTR(err);
2347}
2348
9aecce1c 2349static void mlxsw_sp_fib4_entry_destroy(struct mlxsw_sp *mlxsw_sp,
4f1c7f1f 2350 struct mlxsw_sp_fib4_entry *fib4_entry)
9aecce1c 2351{
0e6ea2a4 2352 mlxsw_sp_nexthop4_group_put(mlxsw_sp, &fib4_entry->common);
4f1c7f1f 2353 kfree(fib4_entry);
9aecce1c
IS		 2354}
2355
2356static struct mlxsw_sp_fib_node *
160e22aa
IS		 2357mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
2358 size_t addr_len, unsigned char prefix_len);
9aecce1c 2359
4f1c7f1f 2360static struct mlxsw_sp_fib4_entry *
9aecce1c
IS		 2361mlxsw_sp_fib4_entry_lookup(struct mlxsw_sp *mlxsw_sp,
2362 const struct fib_entry_notifier_info *fen_info)
5b004412 2363{
4f1c7f1f 2364 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 2365 struct mlxsw_sp_fib_node *fib_node;
160e22aa
IS		 2366 struct mlxsw_sp_fib *fib;
2367 struct mlxsw_sp_vr *vr;
2368
2369 vr = mlxsw_sp_vr_find(mlxsw_sp, fen_info->tb_id);
2370 if (!vr)
2371 return NULL;
2372 fib = mlxsw_sp_vr_fib(vr, MLXSW_SP_L3_PROTO_IPV4);
5b004412 2373
160e22aa
IS		 2374 fib_node = mlxsw_sp_fib_node_lookup(fib, &fen_info->dst,
2375 sizeof(fen_info->dst),
2376 fen_info->dst_len);
2377 if (!fib_node)
9aecce1c
IS		 2378 return NULL;
2379
4f1c7f1f
IS		 2380 list_for_each_entry(fib4_entry, &fib_node->entry_list, common.list) {
2381 if (fib4_entry->tb_id == fen_info->tb_id &&
2382 fib4_entry->tos == fen_info->tos &&
2383 fib4_entry->type == fen_info->type &&
2384 fib4_entry->common.nh_group->key.fi == fen_info->fi) {
2385 return fib4_entry;
9aecce1c
IS		 2386 }
2387 }
2388
2389 return NULL;
2390}
2391
2392static const struct rhashtable_params mlxsw_sp_fib_ht_params = {
2393 .key_offset = offsetof(struct mlxsw_sp_fib_node, key),
2394 .head_offset = offsetof(struct mlxsw_sp_fib_node, ht_node),
2395 .key_len = sizeof(struct mlxsw_sp_fib_key),
2396 .automatic_shrinking = true,
2397};
2398
2399static int mlxsw_sp_fib_node_insert(struct mlxsw_sp_fib *fib,
2400 struct mlxsw_sp_fib_node *fib_node)
2401{
2402 return rhashtable_insert_fast(&fib->ht, &fib_node->ht_node,
2403 mlxsw_sp_fib_ht_params);
2404}
2405
2406static void mlxsw_sp_fib_node_remove(struct mlxsw_sp_fib *fib,
2407 struct mlxsw_sp_fib_node *fib_node)
2408{
2409 rhashtable_remove_fast(&fib->ht, &fib_node->ht_node,
2410 mlxsw_sp_fib_ht_params);
2411}
2412
2413static struct mlxsw_sp_fib_node *
2414mlxsw_sp_fib_node_lookup(struct mlxsw_sp_fib *fib, const void *addr,
2415 size_t addr_len, unsigned char prefix_len)
2416{
2417 struct mlxsw_sp_fib_key key;
2418
2419 memset(&key, 0, sizeof(key));
2420 memcpy(key.addr, addr, addr_len);
2421 key.prefix_len = prefix_len;
2422 return rhashtable_lookup_fast(&fib->ht, &key, mlxsw_sp_fib_ht_params);
2423}
2424
2425static struct mlxsw_sp_fib_node *
76610ebb 2426mlxsw_sp_fib_node_create(struct mlxsw_sp_fib *fib, const void *addr,
9aecce1c
IS		 2427 size_t addr_len, unsigned char prefix_len)
2428{
2429 struct mlxsw_sp_fib_node *fib_node;
2430
2431 fib_node = kzalloc(sizeof(*fib_node), GFP_KERNEL);
2432 if (!fib_node)
5b004412
JP		 2433 return NULL;
2434
9aecce1c 2435 INIT_LIST_HEAD(&fib_node->entry_list);
76610ebb 2436 list_add(&fib_node->list, &fib->node_list);
9aecce1c
IS		 2437 memcpy(fib_node->key.addr, addr, addr_len);
2438 fib_node->key.prefix_len = prefix_len;
9aecce1c
IS		 2439
2440 return fib_node;
2441}
2442
2443static void mlxsw_sp_fib_node_destroy(struct mlxsw_sp_fib_node *fib_node)
2444{
9aecce1c
IS		 2445 list_del(&fib_node->list);
2446 WARN_ON(!list_empty(&fib_node->entry_list));
2447 kfree(fib_node);
2448}
2449
2450static bool
2451mlxsw_sp_fib_node_entry_is_first(const struct mlxsw_sp_fib_node *fib_node,
2452 const struct mlxsw_sp_fib_entry *fib_entry)
2453{
2454 return list_first_entry(&fib_node->entry_list,
2455 struct mlxsw_sp_fib_entry, list) == fib_entry;
2456}
2457
2458static void mlxsw_sp_fib_node_prefix_inc(struct mlxsw_sp_fib_node *fib_node)
2459{
2460 unsigned char prefix_len = fib_node->key.prefix_len;
76610ebb 2461 struct mlxsw_sp_fib *fib = fib_node->fib;
9aecce1c
IS		 2462
2463 if (fib->prefix_ref_count[prefix_len]++ == 0)
2464 mlxsw_sp_prefix_usage_set(&fib->prefix_usage, prefix_len);
2465}
2466
2467static void mlxsw_sp_fib_node_prefix_dec(struct mlxsw_sp_fib_node *fib_node)
2468{
2469 unsigned char prefix_len = fib_node->key.prefix_len;
76610ebb 2470 struct mlxsw_sp_fib *fib = fib_node->fib;
9aecce1c
IS		 2471
2472 if (--fib->prefix_ref_count[prefix_len] == 0)
2473 mlxsw_sp_prefix_usage_clear(&fib->prefix_usage, prefix_len);
5b004412
JP		 2474}
2475
76610ebb
IS		 2476static int mlxsw_sp_fib_node_init(struct mlxsw_sp *mlxsw_sp,
2477 struct mlxsw_sp_fib_node *fib_node,
2478 struct mlxsw_sp_fib *fib)
2479{
2480 struct mlxsw_sp_prefix_usage req_prefix_usage;
2481 struct mlxsw_sp_lpm_tree *lpm_tree;
2482 int err;
2483
2484 err = mlxsw_sp_fib_node_insert(fib, fib_node);
2485 if (err)
2486 return err;
2487 fib_node->fib = fib;
2488
2489 mlxsw_sp_prefix_usage_cpy(&req_prefix_usage, &fib->prefix_usage);
2490 mlxsw_sp_prefix_usage_set(&req_prefix_usage, fib_node->key.prefix_len);
2491
2492 if (!mlxsw_sp_prefix_usage_none(&fib->prefix_usage)) {
2493 err = mlxsw_sp_vr_lpm_tree_check(mlxsw_sp, fib,
2494 &req_prefix_usage);
2495 if (err)
2496 goto err_tree_check;
2497 } else {
2498 lpm_tree = mlxsw_sp_lpm_tree_get(mlxsw_sp, &req_prefix_usage,
2499 fib->proto);
2500 if (IS_ERR(lpm_tree))
2501 return PTR_ERR(lpm_tree);
2502 fib->lpm_tree = lpm_tree;
2503 err = mlxsw_sp_vr_lpm_tree_bind(mlxsw_sp, fib);
2504 if (err)
2505 goto err_tree_bind;
2506 }
2507
2508 mlxsw_sp_fib_node_prefix_inc(fib_node);
2509
2510 return 0;
2511
2512err_tree_bind:
2513 fib->lpm_tree = NULL;
2514 mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
2515err_tree_check:
2516 fib_node->fib = NULL;
2517 mlxsw_sp_fib_node_remove(fib, fib_node);
2518 return err;
2519}
2520
2521static void mlxsw_sp_fib_node_fini(struct mlxsw_sp *mlxsw_sp,
2522 struct mlxsw_sp_fib_node *fib_node)
2523{
2524 struct mlxsw_sp_lpm_tree *lpm_tree = fib_node->fib->lpm_tree;
2525 struct mlxsw_sp_fib *fib = fib_node->fib;
2526
2527 mlxsw_sp_fib_node_prefix_dec(fib_node);
2528
2529 if (mlxsw_sp_prefix_usage_none(&fib->prefix_usage)) {
2530 mlxsw_sp_vr_lpm_tree_unbind(mlxsw_sp, fib);
2531 fib->lpm_tree = NULL;
2532 mlxsw_sp_lpm_tree_put(mlxsw_sp, lpm_tree);
2533 } else {
2534 mlxsw_sp_vr_lpm_tree_check(mlxsw_sp, fib, &fib->prefix_usage);
2535 }
2536
2537 fib_node->fib = NULL;
2538 mlxsw_sp_fib_node_remove(fib, fib_node);
2539}
2540
9aecce1c 2541static struct mlxsw_sp_fib_node *
731ea1ca
IS		 2542mlxsw_sp_fib_node_get(struct mlxsw_sp *mlxsw_sp, u32 tb_id, const void *addr,
2543 size_t addr_len, unsigned char prefix_len,
2544 enum mlxsw_sp_l3proto proto)
5b004412 2545{
9aecce1c 2546 struct mlxsw_sp_fib_node *fib_node;
76610ebb 2547 struct mlxsw_sp_fib *fib;
9aecce1c
IS		 2548 struct mlxsw_sp_vr *vr;
2549 int err;
2550
731ea1ca 2551 vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id);
9aecce1c
IS		 2552 if (IS_ERR(vr))
2553 return ERR_CAST(vr);
731ea1ca 2554 fib = mlxsw_sp_vr_fib(vr, proto);
9aecce1c 2555
731ea1ca 2556 fib_node = mlxsw_sp_fib_node_lookup(fib, addr, addr_len, prefix_len);
9aecce1c
IS		 2557 if (fib_node)
2558 return fib_node;
5b004412 2559
731ea1ca 2560 fib_node = mlxsw_sp_fib_node_create(fib, addr, addr_len, prefix_len);
9aecce1c
IS		 2561 if (!fib_node) {
2562 err = -ENOMEM;
2563 goto err_fib_node_create;
5b004412 2564 }
9aecce1c 2565
76610ebb
IS		 2566 err = mlxsw_sp_fib_node_init(mlxsw_sp, fib_node, fib);
2567 if (err)
2568 goto err_fib_node_init;
2569
9aecce1c
IS		 2570 return fib_node;
2571
76610ebb
IS		 2572err_fib_node_init:
2573 mlxsw_sp_fib_node_destroy(fib_node);
9aecce1c 2574err_fib_node_create:
76610ebb 2575 mlxsw_sp_vr_put(vr);
9aecce1c 2576 return ERR_PTR(err);
5b004412
JP		 2577}
2578
731ea1ca
IS		 2579static void mlxsw_sp_fib_node_put(struct mlxsw_sp *mlxsw_sp,
2580 struct mlxsw_sp_fib_node *fib_node)
5b004412 2581{
76610ebb 2582 struct mlxsw_sp_vr *vr = fib_node->fib->vr;
5b004412 2583
9aecce1c
IS		 2584 if (!list_empty(&fib_node->entry_list))
2585 return;
76610ebb 2586 mlxsw_sp_fib_node_fini(mlxsw_sp, fib_node);
9aecce1c 2587 mlxsw_sp_fib_node_destroy(fib_node);
76610ebb 2588 mlxsw_sp_vr_put(vr);
61c503f9
JP		 2589}
2590
4f1c7f1f 2591static struct mlxsw_sp_fib4_entry *
9aecce1c 2592mlxsw_sp_fib4_node_entry_find(const struct mlxsw_sp_fib_node *fib_node,
4f1c7f1f 2593 const struct mlxsw_sp_fib4_entry *new4_entry)
61c503f9 2594{
4f1c7f1f 2595 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 2596
4f1c7f1f
IS		 2597 list_for_each_entry(fib4_entry, &fib_node->entry_list, common.list) {
2598 if (fib4_entry->tb_id > new4_entry->tb_id)
9aecce1c 2599 continue;
4f1c7f1f 2600 if (fib4_entry->tb_id != new4_entry->tb_id)
9aecce1c 2601 break;
4f1c7f1f 2602 if (fib4_entry->tos > new4_entry->tos)
9aecce1c 2603 continue;
4f1c7f1f
IS		 2604 if (fib4_entry->prio >= new4_entry->prio ||
2605 fib4_entry->tos < new4_entry->tos)
2606 return fib4_entry;
9aecce1c
IS		 2607 }
2608
2609 return NULL;
2610}
2611
4f1c7f1f
IS		 2612static int
2613mlxsw_sp_fib4_node_list_append(struct mlxsw_sp_fib4_entry *fib4_entry,
2614 struct mlxsw_sp_fib4_entry *new4_entry)
4283bce5
IS		 2615{
2616 struct mlxsw_sp_fib_node *fib_node;
2617
4f1c7f1f 2618 if (WARN_ON(!fib4_entry))
4283bce5
IS		 2619 return -EINVAL;
2620
4f1c7f1f
IS		 2621 fib_node = fib4_entry->common.fib_node;
2622 list_for_each_entry_from(fib4_entry, &fib_node->entry_list,
2623 common.list) {
2624 if (fib4_entry->tb_id != new4_entry->tb_id ||
2625 fib4_entry->tos != new4_entry->tos ||
2626 fib4_entry->prio != new4_entry->prio)
4283bce5
IS		 2627 break;
2628 }
2629
4f1c7f1f 2630 list_add_tail(&new4_entry->common.list, &fib4_entry->common.list);
4283bce5
IS		 2631 return 0;
2632}
2633
9aecce1c 2634static int
9efbee6f 2635mlxsw_sp_fib4_node_list_insert(struct mlxsw_sp_fib4_entry *new4_entry,
599cf8f9 2636 bool replace, bool append)
9aecce1c 2637{
9efbee6f 2638 struct mlxsw_sp_fib_node *fib_node = new4_entry->common.fib_node;
4f1c7f1f 2639 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 2640
4f1c7f1f 2641 fib4_entry = mlxsw_sp_fib4_node_entry_find(fib_node, new4_entry);
9aecce1c 2642
4283bce5 2643 if (append)
4f1c7f1f
IS		 2644 return mlxsw_sp_fib4_node_list_append(fib4_entry, new4_entry);
2645 if (replace && WARN_ON(!fib4_entry))
599cf8f9 2646 return -EINVAL;
4283bce5 2647
599cf8f9
IS		 2648 /* Insert new entry before replaced one, so that we can later
2649 * remove the second.
2650 */
4f1c7f1f
IS		 2651 if (fib4_entry) {
2652 list_add_tail(&new4_entry->common.list,
2653 &fib4_entry->common.list);
9aecce1c 2654 } else {
4f1c7f1f 2655 struct mlxsw_sp_fib4_entry *last;
9aecce1c 2656
4f1c7f1f
IS		 2657 list_for_each_entry(last, &fib_node->entry_list, common.list) {
2658 if (new4_entry->tb_id > last->tb_id)
9aecce1c 2659 break;
4f1c7f1f 2660 fib4_entry = last;
9aecce1c
IS		 2661 }
2662
4f1c7f1f
IS		 2663 if (fib4_entry)
2664 list_add(&new4_entry->common.list,
2665 &fib4_entry->common.list);
9aecce1c 2666 else
4f1c7f1f
IS		 2667 list_add(&new4_entry->common.list,
2668 &fib_node->entry_list);
9aecce1c
IS		 2669 }
2670
2671 return 0;
2672}
2673
2674static void
4f1c7f1f 2675mlxsw_sp_fib4_node_list_remove(struct mlxsw_sp_fib4_entry *fib4_entry)
9aecce1c 2676{
4f1c7f1f 2677 list_del(&fib4_entry->common.list);
9aecce1c
IS		 2678}
2679
80c238f9
IS		 2680static int mlxsw_sp_fib_node_entry_add(struct mlxsw_sp *mlxsw_sp,
2681 struct mlxsw_sp_fib_entry *fib_entry)
9aecce1c 2682{
9efbee6f
IS		 2683 struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
2684
9aecce1c
IS		 2685 if (!mlxsw_sp_fib_node_entry_is_first(fib_node, fib_entry))
2686 return 0;
2687
2688 /* To prevent packet loss, overwrite the previously offloaded
2689 * entry.
2690 */
2691 if (!list_is_singular(&fib_node->entry_list)) {
2692 enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_DELETE;
2693 struct mlxsw_sp_fib_entry *n = list_next_entry(fib_entry, list);
2694
2695 mlxsw_sp_fib_entry_offload_refresh(n, op, 0);
2696 }
2697
2698 return mlxsw_sp_fib_entry_update(mlxsw_sp, fib_entry);
2699}
2700
80c238f9
IS		 2701static void mlxsw_sp_fib_node_entry_del(struct mlxsw_sp *mlxsw_sp,
2702 struct mlxsw_sp_fib_entry *fib_entry)
9aecce1c 2703{
9efbee6f
IS		 2704 struct mlxsw_sp_fib_node *fib_node = fib_entry->fib_node;
2705
9aecce1c
IS		 2706 if (!mlxsw_sp_fib_node_entry_is_first(fib_node, fib_entry))
2707 return;
2708
2709 /* Promote the next entry by overwriting the deleted entry */
2710 if (!list_is_singular(&fib_node->entry_list)) {
2711 struct mlxsw_sp_fib_entry *n = list_next_entry(fib_entry, list);
2712 enum mlxsw_reg_ralue_op op = MLXSW_REG_RALUE_OP_WRITE_DELETE;
2713
2714 mlxsw_sp_fib_entry_update(mlxsw_sp, n);
2715 mlxsw_sp_fib_entry_offload_refresh(fib_entry, op, 0);
2716 return;
2717 }
2718
2719 mlxsw_sp_fib_entry_del(mlxsw_sp, fib_entry);
2720}
2721
2722static int mlxsw_sp_fib4_node_entry_link(struct mlxsw_sp *mlxsw_sp,
4f1c7f1f 2723 struct mlxsw_sp_fib4_entry *fib4_entry,
599cf8f9 2724 bool replace, bool append)
9aecce1c 2725{
9aecce1c
IS		 2726 int err;
2727
9efbee6f 2728 err = mlxsw_sp_fib4_node_list_insert(fib4_entry, replace, append);
9aecce1c
IS		 2729 if (err)
2730 return err;
2731
80c238f9 2732 err = mlxsw_sp_fib_node_entry_add(mlxsw_sp, &fib4_entry->common);
9aecce1c 2733 if (err)
80c238f9 2734 goto err_fib_node_entry_add;
9aecce1c 2735
9aecce1c
IS		 2736 return 0;
2737
80c238f9 2738err_fib_node_entry_add:
4f1c7f1f 2739 mlxsw_sp_fib4_node_list_remove(fib4_entry);
9aecce1c
IS		 2740 return err;
2741}
2742
2743static void
2744mlxsw_sp_fib4_node_entry_unlink(struct mlxsw_sp *mlxsw_sp,
4f1c7f1f 2745 struct mlxsw_sp_fib4_entry *fib4_entry)
9aecce1c 2746{
80c238f9 2747 mlxsw_sp_fib_node_entry_del(mlxsw_sp, &fib4_entry->common);
4f1c7f1f 2748 mlxsw_sp_fib4_node_list_remove(fib4_entry);
9aecce1c
IS		 2749}
2750
599cf8f9 2751static void mlxsw_sp_fib4_entry_replace(struct mlxsw_sp *mlxsw_sp,
4f1c7f1f 2752 struct mlxsw_sp_fib4_entry *fib4_entry,
599cf8f9
IS		 2753 bool replace)
2754{
4f1c7f1f
IS		 2755 struct mlxsw_sp_fib_node *fib_node = fib4_entry->common.fib_node;
2756 struct mlxsw_sp_fib4_entry *replaced;
599cf8f9
IS		 2757
2758 if (!replace)
2759 return;
2760
2761 /* We inserted the new entry before replaced one */
4f1c7f1f 2762 replaced = list_next_entry(fib4_entry, common.list);
599cf8f9
IS		 2763
2764 mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, replaced);
2765 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, replaced);
731ea1ca 2766 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
599cf8f9
IS		 2767}
2768
9aecce1c
IS		 2769static int
2770mlxsw_sp_router_fib4_add(struct mlxsw_sp *mlxsw_sp,
4283bce5 2771 const struct fib_entry_notifier_info *fen_info,
599cf8f9 2772 bool replace, bool append)
9aecce1c 2773{
4f1c7f1f 2774 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 2775 struct mlxsw_sp_fib_node *fib_node;
61c503f9
JP		 2776 int err;
2777
9011b677 2778 if (mlxsw_sp->router->aborted)
b45f64d1
JP		 2779 return 0;
2780
731ea1ca
IS		 2781 fib_node = mlxsw_sp_fib_node_get(mlxsw_sp, fen_info->tb_id,
2782 &fen_info->dst, sizeof(fen_info->dst),
2783 fen_info->dst_len,
2784 MLXSW_SP_L3_PROTO_IPV4);
9aecce1c
IS		 2785 if (IS_ERR(fib_node)) {
2786 dev_warn(mlxsw_sp->bus_info->dev, "Failed to get FIB node\n");
2787 return PTR_ERR(fib_node);
b45f64d1 2788 }
61c503f9 2789
4f1c7f1f
IS		 2790 fib4_entry = mlxsw_sp_fib4_entry_create(mlxsw_sp, fib_node, fen_info);
2791 if (IS_ERR(fib4_entry)) {
9aecce1c 2792 dev_warn(mlxsw_sp->bus_info->dev, "Failed to create FIB entry\n");
4f1c7f1f 2793 err = PTR_ERR(fib4_entry);
9aecce1c
IS		 2794 goto err_fib4_entry_create;
2795 }
5b004412 2796
4f1c7f1f 2797 err = mlxsw_sp_fib4_node_entry_link(mlxsw_sp, fib4_entry, replace,
599cf8f9 2798 append);
b45f64d1 2799 if (err) {
9aecce1c
IS		 2800 dev_warn(mlxsw_sp->bus_info->dev, "Failed to link FIB entry to node\n");
2801 goto err_fib4_node_entry_link;
b45f64d1 2802 }
9aecce1c 2803
4f1c7f1f 2804 mlxsw_sp_fib4_entry_replace(mlxsw_sp, fib4_entry, replace);
599cf8f9 2805
61c503f9
JP		 2806 return 0;
2807
9aecce1c 2808err_fib4_node_entry_link:
4f1c7f1f 2809 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
9aecce1c 2810err_fib4_entry_create:
731ea1ca 2811 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
61c503f9
JP		 2812 return err;
2813}
2814
37956d78
JP		 2815static void mlxsw_sp_router_fib4_del(struct mlxsw_sp *mlxsw_sp,
2816 struct fib_entry_notifier_info *fen_info)
61c503f9 2817{
4f1c7f1f 2818 struct mlxsw_sp_fib4_entry *fib4_entry;
9aecce1c 2819 struct mlxsw_sp_fib_node *fib_node;
61c503f9 2820
9011b677 2821 if (mlxsw_sp->router->aborted)
37956d78 2822 return;
b45f64d1 2823
4f1c7f1f
IS		 2824 fib4_entry = mlxsw_sp_fib4_entry_lookup(mlxsw_sp, fen_info);
2825 if (WARN_ON(!fib4_entry))
37956d78 2826 return;
4f1c7f1f 2827 fib_node = fib4_entry->common.fib_node;
5b004412 2828
4f1c7f1f
IS		 2829 mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, fib4_entry);
2830 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
731ea1ca 2831 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
61c503f9 2832}
b45f64d1 2833
bc65a8a4
IS		 2834static int __mlxsw_sp_router_set_abort_trap(struct mlxsw_sp *mlxsw_sp,
2835 enum mlxsw_reg_ralxx_protocol proto,
2836 u8 tree_id)
b45f64d1
JP		 2837{
2838 char ralta_pl[MLXSW_REG_RALTA_LEN];
2839 char ralst_pl[MLXSW_REG_RALST_LEN];
b5d90e6d 2840 int i, err;
b45f64d1 2841
bc65a8a4 2842 mlxsw_reg_ralta_pack(ralta_pl, true, proto, tree_id);
b45f64d1
JP		 2843 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralta), ralta_pl);
2844 if (err)
2845 return err;
2846
bc65a8a4 2847 mlxsw_reg_ralst_pack(ralst_pl, 0xff, tree_id);
b45f64d1
JP		 2848 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralst), ralst_pl);
2849 if (err)
2850 return err;
2851
b5d90e6d 2852 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
9011b677 2853 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
b5d90e6d
IS		 2854 char raltb_pl[MLXSW_REG_RALTB_LEN];
2855 char ralue_pl[MLXSW_REG_RALUE_LEN];
b45f64d1 2856
b5d90e6d
IS		 2857 if (!mlxsw_sp_vr_is_used(vr))
2858 continue;
2859
bc65a8a4 2860 mlxsw_reg_raltb_pack(raltb_pl, vr->id, proto, tree_id);
b5d90e6d
IS		 2861 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(raltb),
2862 raltb_pl);
2863 if (err)
2864 return err;
2865
bc65a8a4
IS		 2866 mlxsw_reg_ralue_pack(ralue_pl, proto,
2867 MLXSW_REG_RALUE_OP_WRITE_WRITE, vr->id, 0);
b5d90e6d
IS		 2868 mlxsw_reg_ralue_act_ip2me_pack(ralue_pl);
2869 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ralue),
2870 ralue_pl);
2871 if (err)
2872 return err;
2873 }
2874
2875 return 0;
b45f64d1
JP		 2876}
2877
bc65a8a4
IS		 2878static int mlxsw_sp_router_set_abort_trap(struct mlxsw_sp *mlxsw_sp)
2879{
2880 enum mlxsw_reg_ralxx_protocol proto = MLXSW_REG_RALXX_PROTOCOL_IPV4;
2881 int err;
2882
2883 err = __mlxsw_sp_router_set_abort_trap(mlxsw_sp, proto,
2884 MLXSW_SP_LPM_TREE_MIN);
2885 if (err)
2886 return err;
2887
2888 proto = MLXSW_REG_RALXX_PROTOCOL_IPV6;
2889 return __mlxsw_sp_router_set_abort_trap(mlxsw_sp, proto,
2890 MLXSW_SP_LPM_TREE_MIN + 1);
2891}
2892
9aecce1c
IS		 2893static void mlxsw_sp_fib4_node_flush(struct mlxsw_sp *mlxsw_sp,
2894 struct mlxsw_sp_fib_node *fib_node)
2895{
4f1c7f1f 2896 struct mlxsw_sp_fib4_entry *fib4_entry, *tmp;
9aecce1c 2897
4f1c7f1f
IS		 2898 list_for_each_entry_safe(fib4_entry, tmp, &fib_node->entry_list,
2899 common.list) {
2900 bool do_break = &tmp->common.list == &fib_node->entry_list;
9aecce1c 2901
4f1c7f1f
IS		 2902 mlxsw_sp_fib4_node_entry_unlink(mlxsw_sp, fib4_entry);
2903 mlxsw_sp_fib4_entry_destroy(mlxsw_sp, fib4_entry);
731ea1ca 2904 mlxsw_sp_fib_node_put(mlxsw_sp, fib_node);
9aecce1c
IS		 2905 /* Break when entry list is empty and node was freed.
2906 * Otherwise, we'll access freed memory in the next
2907 * iteration.
2908 */
2909 if (do_break)
2910 break;
2911 }
2912}
2913
2914static void mlxsw_sp_fib_node_flush(struct mlxsw_sp *mlxsw_sp,
2915 struct mlxsw_sp_fib_node *fib_node)
2916{
76610ebb 2917 switch (fib_node->fib->proto) {
9aecce1c
IS		 2918 case MLXSW_SP_L3_PROTO_IPV4:
2919 mlxsw_sp_fib4_node_flush(mlxsw_sp, fib_node);
2920 break;
2921 case MLXSW_SP_L3_PROTO_IPV6:
2922 WARN_ON_ONCE(1);
2923 break;
2924 }
2925}
2926
76610ebb
IS		 2927static void mlxsw_sp_vr_fib_flush(struct mlxsw_sp *mlxsw_sp,
2928 struct mlxsw_sp_vr *vr,
2929 enum mlxsw_sp_l3proto proto)
b45f64d1 2930{
76610ebb 2931 struct mlxsw_sp_fib *fib = mlxsw_sp_vr_fib(vr, proto);
9aecce1c 2932 struct mlxsw_sp_fib_node *fib_node, *tmp;
76610ebb
IS		 2933
2934 list_for_each_entry_safe(fib_node, tmp, &fib->node_list, list) {
2935 bool do_break = &tmp->list == &fib->node_list;
2936
2937 mlxsw_sp_fib_node_flush(mlxsw_sp, fib_node);
2938 if (do_break)
2939 break;
2940 }
2941}
2942
2943static void mlxsw_sp_router_fib_flush(struct mlxsw_sp *mlxsw_sp)
2944{
b45f64d1 2945 int i;
b45f64d1 2946
c1a38311 2947 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_VRS); i++) {
9011b677 2948 struct mlxsw_sp_vr *vr = &mlxsw_sp->router->vrs[i];
ac571de9 2949
76610ebb 2950 if (!mlxsw_sp_vr_is_used(vr))
b45f64d1 2951 continue;
76610ebb 2952 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV4);
a3d9bc50
IS		 2953
2954 /* If virtual router was only used for IPv4, then it's no
2955 * longer used.
2956 */
2957 if (!mlxsw_sp_vr_is_used(vr))
2958 continue;
2959 mlxsw_sp_vr_fib_flush(mlxsw_sp, vr, MLXSW_SP_L3_PROTO_IPV6);
b45f64d1 2960 }
ac571de9
IS		 2961}
2962
bc65a8a4 2963static void mlxsw_sp_router_fib_abort(struct mlxsw_sp *mlxsw_sp)
ac571de9
IS		 2964{
2965 int err;
2966
9011b677 2967 if (mlxsw_sp->router->aborted)
d331d303
IS		 2968 return;
2969 dev_warn(mlxsw_sp->bus_info->dev, "FIB abort triggered. Note that FIB entries are no longer being offloaded to this device.\n");
ac571de9 2970 mlxsw_sp_router_fib_flush(mlxsw_sp);
9011b677 2971 mlxsw_sp->router->aborted = true;
b45f64d1
JP		 2972 err = mlxsw_sp_router_set_abort_trap(mlxsw_sp);
2973 if (err)
2974 dev_warn(mlxsw_sp->bus_info->dev, "Failed to set abort trap.\n");
2975}
2976
3057224e 2977struct mlxsw_sp_fib_event_work {
a0e4761d 2978 struct work_struct work;
ad178c8e
IS		 2979 union {
2980 struct fib_entry_notifier_info fen_info;
5d7bfd14 2981 struct fib_rule_notifier_info fr_info;
ad178c8e
IS		 2982 struct fib_nh_notifier_info fnh_info;
2983 };
3057224e
IS		 2984 struct mlxsw_sp *mlxsw_sp;
2985 unsigned long event;
2986};
2987
2988static void mlxsw_sp_router_fib_event_work(struct work_struct *work)
b45f64d1 2989{
3057224e 2990 struct mlxsw_sp_fib_event_work *fib_work =
a0e4761d 2991 container_of(work, struct mlxsw_sp_fib_event_work, work);
3057224e 2992 struct mlxsw_sp *mlxsw_sp = fib_work->mlxsw_sp;
5d7bfd14 2993 struct fib_rule *rule;
599cf8f9 2994 bool replace, append;
b45f64d1
JP		 2995 int err;
2996
3057224e
IS		 2997 /* Protect internal structures from changes */
2998 rtnl_lock();
2999 switch (fib_work->event) {
599cf8f9 3000 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
4283bce5 3001 case FIB_EVENT_ENTRY_APPEND: /* fall through */
b45f64d1 3002 case FIB_EVENT_ENTRY_ADD:
599cf8f9 3003 replace = fib_work->event == FIB_EVENT_ENTRY_REPLACE;
4283bce5
IS		 3004 append = fib_work->event == FIB_EVENT_ENTRY_APPEND;
3005 err = mlxsw_sp_router_fib4_add(mlxsw_sp, &fib_work->fen_info,
599cf8f9 3006 replace, append);
b45f64d1 3007 if (err)
bc65a8a4 3008 mlxsw_sp_router_fib_abort(mlxsw_sp);
3057224e 3009 fib_info_put(fib_work->fen_info.fi);
b45f64d1
JP		 3010 break;
3011 case FIB_EVENT_ENTRY_DEL:
3057224e
IS		 3012 mlxsw_sp_router_fib4_del(mlxsw_sp, &fib_work->fen_info);
3013 fib_info_put(fib_work->fen_info.fi);
b45f64d1
JP		 3014 break;
3015 case FIB_EVENT_RULE_ADD: /* fall through */
3016 case FIB_EVENT_RULE_DEL:
5d7bfd14 3017 rule = fib_work->fr_info.rule;
c7f6e665 3018 if (!fib4_rule_default(rule) && !rule->l3mdev)
bc65a8a4 3019 mlxsw_sp_router_fib_abort(mlxsw_sp);
5d7bfd14 3020 fib_rule_put(rule);
b45f64d1 3021 break;
ad178c8e
IS		 3022 case FIB_EVENT_NH_ADD: /* fall through */
3023 case FIB_EVENT_NH_DEL:
0e6ea2a4
IS		 3024 mlxsw_sp_nexthop4_event(mlxsw_sp, fib_work->event,
3025 fib_work->fnh_info.fib_nh);
ad178c8e
IS		 3026 fib_info_put(fib_work->fnh_info.fib_nh->nh_parent);
3027 break;
b45f64d1 3028 }
3057224e
IS		 3029 rtnl_unlock();
3030 kfree(fib_work);
3031}
3032
3033/* Called with rcu_read_lock() */
3034static int mlxsw_sp_router_fib_event(struct notifier_block *nb,
3035 unsigned long event, void *ptr)
3036{
3057224e
IS		 3037 struct mlxsw_sp_fib_event_work *fib_work;
3038 struct fib_notifier_info *info = ptr;
7e39d115 3039 struct mlxsw_sp_router *router;
3057224e
IS		 3040
3041 if (!net_eq(info->net, &init_net))
3042 return NOTIFY_DONE;
3043
3044 fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC);
3045 if (WARN_ON(!fib_work))
3046 return NOTIFY_BAD;
3047
a0e4761d 3048 INIT_WORK(&fib_work->work, mlxsw_sp_router_fib_event_work);
7e39d115
IS		 3049 router = container_of(nb, struct mlxsw_sp_router, fib_nb);
3050 fib_work->mlxsw_sp = router->mlxsw_sp;
3057224e
IS		 3051 fib_work->event = event;
3052
3053 switch (event) {
599cf8f9 3054 case FIB_EVENT_ENTRY_REPLACE: /* fall through */
4283bce5 3055 case FIB_EVENT_ENTRY_APPEND: /* fall through */
3057224e
IS		 3056 case FIB_EVENT_ENTRY_ADD: /* fall through */
3057 case FIB_EVENT_ENTRY_DEL:
3058 memcpy(&fib_work->fen_info, ptr, sizeof(fib_work->fen_info));
3059 /* Take referece on fib_info to prevent it from being
3060 * freed while work is queued. Release it afterwards.
3061 */
3062 fib_info_hold(fib_work->fen_info.fi);
3063 break;
5d7bfd14
IS		 3064 case FIB_EVENT_RULE_ADD: /* fall through */
3065 case FIB_EVENT_RULE_DEL:
3066 memcpy(&fib_work->fr_info, ptr, sizeof(fib_work->fr_info));
3067 fib_rule_get(fib_work->fr_info.rule);
3068 break;
ad178c8e
IS		 3069 case FIB_EVENT_NH_ADD: /* fall through */
3070 case FIB_EVENT_NH_DEL:
3071 memcpy(&fib_work->fnh_info, ptr, sizeof(fib_work->fnh_info));
3072 fib_info_hold(fib_work->fnh_info.fib_nh->nh_parent);
3073 break;
3057224e
IS		 3074 }
3075
a0e4761d 3076 mlxsw_core_schedule_work(&fib_work->work);
3057224e 3077
b45f64d1
JP		 3078 return NOTIFY_DONE;
3079}
3080
4724ba56
IS		 3081static struct mlxsw_sp_rif *
3082mlxsw_sp_rif_find_by_dev(const struct mlxsw_sp *mlxsw_sp,
3083 const struct net_device *dev)
3084{
3085 int i;
3086
3087 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++)
5f9efffb
IS		 3088 if (mlxsw_sp->router->rifs[i] &&
3089 mlxsw_sp->router->rifs[i]->dev == dev)
3090 return mlxsw_sp->router->rifs[i];
4724ba56
IS		 3091
3092 return NULL;
3093}
3094
3095static int mlxsw_sp_router_rif_disable(struct mlxsw_sp *mlxsw_sp, u16 rif)
3096{
3097 char ritr_pl[MLXSW_REG_RITR_LEN];
3098 int err;
3099
3100 mlxsw_reg_ritr_rif_pack(ritr_pl, rif);
3101 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
3102 if (WARN_ON_ONCE(err))
3103 return err;
3104
3105 mlxsw_reg_ritr_enable_set(ritr_pl, false);
3106 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
3107}
3108
3109static void mlxsw_sp_router_rif_gone_sync(struct mlxsw_sp *mlxsw_sp,
bf95233e 3110 struct mlxsw_sp_rif *rif)
4724ba56 3111{
bf95233e
AS		 3112 mlxsw_sp_router_rif_disable(mlxsw_sp, rif->rif_index);
3113 mlxsw_sp_nexthop_rif_gone_sync(mlxsw_sp, rif);
3114 mlxsw_sp_neigh_rif_gone_sync(mlxsw_sp, rif);
4724ba56
IS		 3115}
3116
5ea1237f
AS		 3117static bool
3118mlxsw_sp_rif_should_config(struct mlxsw_sp_rif *rif, struct net_device *dev,
3119 unsigned long event)
4724ba56 3120{
5ea1237f
AS		 3121 struct inet6_dev *inet6_dev;
3122 bool addr_list_empty = true;
3123 struct in_device *idev;
3124
4724ba56
IS		 3125 switch (event) {
3126 case NETDEV_UP:
f1b1f273 3127 return rif == NULL;
4724ba56 3128 case NETDEV_DOWN:
5ea1237f
AS		 3129 idev = __in_dev_get_rtnl(dev);
3130 if (idev && idev->ifa_list)
3131 addr_list_empty = false;
3132
3133 inet6_dev = __in6_dev_get(dev);
3134 if (addr_list_empty && inet6_dev &&
3135 !list_empty(&inet6_dev->addr_list))
3136 addr_list_empty = false;
3137
3138 if (rif && addr_list_empty &&
bf95233e 3139 !netif_is_l3_slave(rif->dev))
4724ba56
IS		 3140 return true;
3141 /* It is possible we already removed the RIF ourselves
3142 * if it was assigned to a netdev that is now a bridge
3143 * or LAG slave.
3144 */
3145 return false;
3146 }
3147
3148 return false;
3149}
3150
e4f3c1c1
IS		 3151static enum mlxsw_sp_rif_type
3152mlxsw_sp_dev_rif_type(const struct mlxsw_sp *mlxsw_sp,
3153 const struct net_device *dev)
3154{
3155 enum mlxsw_sp_fid_type type;
3156
3157 /* RIF type is derived from the type of the underlying FID */
3158 if (is_vlan_dev(dev) && netif_is_bridge_master(vlan_dev_real_dev(dev)))
3159 type = MLXSW_SP_FID_TYPE_8021Q;
3160 else if (netif_is_bridge_master(dev) && br_vlan_enabled(dev))
3161 type = MLXSW_SP_FID_TYPE_8021Q;
3162 else if (netif_is_bridge_master(dev))
3163 type = MLXSW_SP_FID_TYPE_8021D;
3164 else
3165 type = MLXSW_SP_FID_TYPE_RFID;
3166
3167 return mlxsw_sp_fid_type_rif_type(mlxsw_sp, type);
3168}
3169
de5ed99e 3170static int mlxsw_sp_rif_index_alloc(struct mlxsw_sp *mlxsw_sp, u16 *p_rif_index)
4724ba56
IS		 3171{
3172 int i;
3173
de5ed99e
IS		 3174 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) {
3175 if (!mlxsw_sp->router->rifs[i]) {
3176 *p_rif_index = i;
3177 return 0;
3178 }
3179 }
4724ba56 3180
de5ed99e 3181 return -ENOBUFS;
4724ba56
IS		 3182}
3183
e4f3c1c1
IS		 3184static struct mlxsw_sp_rif *mlxsw_sp_rif_alloc(size_t rif_size, u16 rif_index,
3185 u16 vr_id,
3186 struct net_device *l3_dev)
4724ba56 3187{
bf95233e 3188 struct mlxsw_sp_rif *rif;
4724ba56 3189
e4f3c1c1 3190 rif = kzalloc(rif_size, GFP_KERNEL);
bf95233e 3191 if (!rif)
4724ba56
IS		 3192 return NULL;
3193
bf95233e
AS		 3194 INIT_LIST_HEAD(&rif->nexthop_list);
3195 INIT_LIST_HEAD(&rif->neigh_list);
3196 ether_addr_copy(rif->addr, l3_dev->dev_addr);
3197 rif->mtu = l3_dev->mtu;
3198 rif->vr_id = vr_id;
3199 rif->dev = l3_dev;
3200 rif->rif_index = rif_index;
4724ba56 3201
bf95233e 3202 return rif;
4724ba56
IS		 3203}
3204
5f9efffb
IS		 3205struct mlxsw_sp_rif *mlxsw_sp_rif_by_index(const struct mlxsw_sp *mlxsw_sp,
3206 u16 rif_index)
3207{
3208 return mlxsw_sp->router->rifs[rif_index];
3209}
3210
fd1b9d41
AS		 3211u16 mlxsw_sp_rif_index(const struct mlxsw_sp_rif *rif)
3212{
3213 return rif->rif_index;
3214}
3215
3216int mlxsw_sp_rif_dev_ifindex(const struct mlxsw_sp_rif *rif)
3217{
3218 return rif->dev->ifindex;
3219}
3220
4724ba56 3221static struct mlxsw_sp_rif *
e4f3c1c1
IS		 3222mlxsw_sp_rif_create(struct mlxsw_sp *mlxsw_sp,
3223 const struct mlxsw_sp_rif_params *params)
4724ba56 3224{
e4f3c1c1
IS		 3225 u32 tb_id = l3mdev_fib_table(params->dev);
3226 const struct mlxsw_sp_rif_ops *ops;
3227 enum mlxsw_sp_rif_type type;
bf95233e 3228 struct mlxsw_sp_rif *rif;
a1107487
IS		 3229 struct mlxsw_sp_fid *fid;
3230 struct mlxsw_sp_vr *vr;
3231 u16 rif_index;
4724ba56
IS		 3232 int err;
3233
e4f3c1c1
IS		 3234 type = mlxsw_sp_dev_rif_type(mlxsw_sp, params->dev);
3235 ops = mlxsw_sp->router->rif_ops_arr[type];
3236
c9ec53f0
IS		 3237 vr = mlxsw_sp_vr_get(mlxsw_sp, tb_id ? : RT_TABLE_MAIN);
3238 if (IS_ERR(vr))
3239 return ERR_CAST(vr);
3240
de5ed99e
IS		 3241 err = mlxsw_sp_rif_index_alloc(mlxsw_sp, &rif_index);
3242 if (err)
3243 goto err_rif_index_alloc;
4724ba56 3244
e4f3c1c1 3245 rif = mlxsw_sp_rif_alloc(ops->rif_size, rif_index, vr->id, params->dev);
a13a594d
IS		 3246 if (!rif) {
3247 err = -ENOMEM;
3248 goto err_rif_alloc;
3249 }
e4f3c1c1
IS		 3250 rif->mlxsw_sp = mlxsw_sp;
3251 rif->ops = ops;
a13a594d 3252
e4f3c1c1
IS		 3253 fid = ops->fid_get(rif);
3254 if (IS_ERR(fid)) {
3255 err = PTR_ERR(fid);
3256 goto err_fid_get;
4d93ceeb 3257 }
e4f3c1c1 3258 rif->fid = fid;
4d93ceeb 3259
e4f3c1c1
IS		 3260 if (ops->setup)
3261 ops->setup(rif, params);
3262
3263 err = ops->configure(rif);
4724ba56 3264 if (err)
e4f3c1c1 3265 goto err_configure;
4724ba56 3266
e4f3c1c1 3267 err = mlxsw_sp_rif_fdb_op(mlxsw_sp, params->dev->dev_addr,
a1107487 3268 mlxsw_sp_fid_index(fid), true);
4724ba56
IS		 3269 if (err)
3270 goto err_rif_fdb_op;
3271
e4f3c1c1 3272 mlxsw_sp_rif_counters_alloc(rif);
a1107487 3273 mlxsw_sp_fid_rif_set(fid, rif);
5f9efffb 3274 mlxsw_sp->router->rifs[rif_index] = rif;
6913229e 3275 vr->rif_count++;
4724ba56 3276
bf95233e 3277 return rif;
4724ba56 3278
4724ba56 3279err_rif_fdb_op:
e4f3c1c1
IS		 3280 ops->deconfigure(rif);
3281err_configure:
a1107487
IS		 3282 mlxsw_sp_fid_put(fid);
3283err_fid_get:
e4f3c1c1
IS		 3284 kfree(rif);
3285err_rif_alloc:
de5ed99e 3286err_rif_index_alloc:
c9ec53f0 3287 mlxsw_sp_vr_put(vr);
4724ba56
IS		 3288 return ERR_PTR(err);
3289}
3290
e4f3c1c1 3291void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif)
4724ba56 3292{
e4f3c1c1
IS		 3293 const struct mlxsw_sp_rif_ops *ops = rif->ops;
3294 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
a1107487 3295 struct mlxsw_sp_fid *fid = rif->fid;
e4f3c1c1 3296 struct mlxsw_sp_vr *vr;
4724ba56 3297
bf95233e 3298 mlxsw_sp_router_rif_gone_sync(mlxsw_sp, rif);
e4f3c1c1 3299 vr = &mlxsw_sp->router->vrs[rif->vr_id];
e0c0afd8 3300
6913229e 3301 vr->rif_count--;
e4f3c1c1 3302 mlxsw_sp->router->rifs[rif->rif_index] = NULL;
a1107487 3303 mlxsw_sp_fid_rif_set(fid, NULL);
e4f3c1c1
IS		 3304 mlxsw_sp_rif_counters_free(rif);
3305 mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->dev->dev_addr,
3306 mlxsw_sp_fid_index(fid), false);
3307 ops->deconfigure(rif);
a1107487 3308 mlxsw_sp_fid_put(fid);
e4f3c1c1 3309 kfree(rif);
c9ec53f0 3310 mlxsw_sp_vr_put(vr);
4724ba56
IS		 3311}
3312
e4f3c1c1
IS		 3313static void
3314mlxsw_sp_rif_subport_params_init(struct mlxsw_sp_rif_params *params,
3315 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
3316{
3317 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
3318
3319 params->vid = mlxsw_sp_port_vlan->vid;
3320 params->lag = mlxsw_sp_port->lagged;
3321 if (params->lag)
3322 params->lag_id = mlxsw_sp_port->lag_id;
3323 else
3324 params->system_port = mlxsw_sp_port->local_port;
3325}
3326
7cbecf24 3327static int
a1107487 3328mlxsw_sp_port_vlan_router_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
7cbecf24 3329 struct net_device *l3_dev)
4724ba56 3330{
7cbecf24 3331 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1b8f09a0 3332 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
7cbecf24 3333 u16 vid = mlxsw_sp_port_vlan->vid;
bf95233e 3334 struct mlxsw_sp_rif *rif;
a1107487 3335 struct mlxsw_sp_fid *fid;
03ea01e9 3336 int err;
4724ba56 3337
1b8f09a0 3338 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
bf95233e 3339 if (!rif) {
e4f3c1c1
IS		 3340 struct mlxsw_sp_rif_params params = {
3341 .dev = l3_dev,
3342 };
3343
3344 mlxsw_sp_rif_subport_params_init(&params, mlxsw_sp_port_vlan);
3345 rif = mlxsw_sp_rif_create(mlxsw_sp, &params);
bf95233e
AS		 3346 if (IS_ERR(rif))
3347 return PTR_ERR(rif);
4724ba56
IS		 3348 }
3349
a1107487 3350 /* FID was already created, just take a reference */
e4f3c1c1 3351 fid = rif->ops->fid_get(rif);
a1107487
IS		 3352 err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid);
3353 if (err)
3354 goto err_fid_port_vid_map;
3355
7cbecf24 3356 err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
03ea01e9
IS		 3357 if (err)
3358 goto err_port_vid_learning_set;
3359
7cbecf24 3360 err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid,
03ea01e9
IS		 3361 BR_STATE_FORWARDING);
3362 if (err)
3363 goto err_port_vid_stp_set;
3364
a1107487 3365 mlxsw_sp_port_vlan->fid = fid;
4724ba56 3366
4724ba56 3367 return 0;
03ea01e9
IS		 3368
3369err_port_vid_stp_set:
7cbecf24 3370 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
03ea01e9 3371err_port_vid_learning_set:
a1107487
IS		 3372 mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
3373err_fid_port_vid_map:
3374 mlxsw_sp_fid_put(fid);
03ea01e9 3375 return err;
4724ba56
IS		 3376}
3377
a1107487
IS		 3378void
3379mlxsw_sp_port_vlan_router_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
4724ba56 3380{
ce95e154 3381 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
7cbecf24 3382 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
ce95e154 3383 u16 vid = mlxsw_sp_port_vlan->vid;
ce95e154 3384
a1107487
IS		 3385 if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_RFID))
3386 return;
4aafc368 3387
a1107487 3388 mlxsw_sp_port_vlan->fid = NULL;
7cbecf24
IS		 3389 mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_BLOCKING);
3390 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, true);
a1107487
IS		 3391 mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
3392 /* If router port holds the last reference on the rFID, then the
3393 * associated Sub-port RIF will be destroyed.
3394 */
3395 mlxsw_sp_fid_put(fid);
4724ba56
IS		 3396}
3397
7cbecf24
IS		 3398static int mlxsw_sp_inetaddr_port_vlan_event(struct net_device *l3_dev,
3399 struct net_device *port_dev,
3400 unsigned long event, u16 vid)
4724ba56
IS		 3401{
3402 struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(port_dev);
ce95e154 3403 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
4724ba56 3404
ce95e154 3405 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
7cbecf24
IS		 3406 if (WARN_ON(!mlxsw_sp_port_vlan))
3407 return -EINVAL;
4724ba56
IS		 3408
3409 switch (event) {
3410 case NETDEV_UP:
a1107487 3411 return mlxsw_sp_port_vlan_router_join(mlxsw_sp_port_vlan,
7cbecf24 3412 l3_dev);
4724ba56 3413 case NETDEV_DOWN:
a1107487 3414 mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
4724ba56
IS		 3415 break;
3416 }
3417
3418 return 0;
3419}
3420
3421static int mlxsw_sp_inetaddr_port_event(struct net_device *port_dev,
3422 unsigned long event)
3423{
2b94e58d
JP		 3424 if (netif_is_bridge_port(port_dev) ||
3425 netif_is_lag_port(port_dev) ||
3426 netif_is_ovs_port(port_dev))
4724ba56
IS		 3427 return 0;
3428
7cbecf24 3429 return mlxsw_sp_inetaddr_port_vlan_event(port_dev, port_dev, event, 1);
4724ba56
IS		 3430}
3431
3432static int __mlxsw_sp_inetaddr_lag_event(struct net_device *l3_dev,
3433 struct net_device *lag_dev,
3434 unsigned long event, u16 vid)
3435{
3436 struct net_device *port_dev;
3437 struct list_head *iter;
3438 int err;
3439
3440 netdev_for_each_lower_dev(lag_dev, port_dev, iter) {
3441 if (mlxsw_sp_port_dev_check(port_dev)) {
7cbecf24
IS		 3442 err = mlxsw_sp_inetaddr_port_vlan_event(l3_dev,
3443 port_dev,
3444 event, vid);
4724ba56
IS		 3445 if (err)
3446 return err;
3447 }
3448 }
3449
3450 return 0;
3451}
3452
3453static int mlxsw_sp_inetaddr_lag_event(struct net_device *lag_dev,
3454 unsigned long event)
3455{
3456 if (netif_is_bridge_port(lag_dev))
3457 return 0;
3458
3459 return __mlxsw_sp_inetaddr_lag_event(lag_dev, lag_dev, event, 1);
3460}
3461
4724ba56 3462static int mlxsw_sp_inetaddr_bridge_event(struct net_device *l3_dev,
4724ba56
IS		 3463 unsigned long event)
3464{
3465 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(l3_dev);
e4f3c1c1
IS		 3466 struct mlxsw_sp_rif_params params = {
3467 .dev = l3_dev,
3468 };
a1107487 3469 struct mlxsw_sp_rif *rif;
4724ba56
IS		 3470
3471 switch (event) {
3472 case NETDEV_UP:
e4f3c1c1
IS		 3473 rif = mlxsw_sp_rif_create(mlxsw_sp, &params);
3474 if (IS_ERR(rif))
3475 return PTR_ERR(rif);
3476 break;
4724ba56 3477 case NETDEV_DOWN:
a1107487 3478 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
e4f3c1c1 3479 mlxsw_sp_rif_destroy(rif);
4724ba56
IS		 3480 break;
3481 }
3482
3483 return 0;
3484}
3485
3486static int mlxsw_sp_inetaddr_vlan_event(struct net_device *vlan_dev,
3487 unsigned long event)
3488{
3489 struct net_device *real_dev = vlan_dev_real_dev(vlan_dev);
4724ba56
IS		 3490 u16 vid = vlan_dev_vlan_id(vlan_dev);
3491
6b27c8ad
IS		 3492 if (netif_is_bridge_port(vlan_dev))
3493 return 0;
3494
4724ba56 3495 if (mlxsw_sp_port_dev_check(real_dev))
7cbecf24
IS		 3496 return mlxsw_sp_inetaddr_port_vlan_event(vlan_dev, real_dev,
3497 event, vid);
4724ba56
IS		 3498 else if (netif_is_lag_master(real_dev))
3499 return __mlxsw_sp_inetaddr_lag_event(vlan_dev, real_dev, event,
3500 vid);
c57529e1 3501 else if (netif_is_bridge_master(real_dev) && br_vlan_enabled(real_dev))
a1107487 3502 return mlxsw_sp_inetaddr_bridge_event(vlan_dev, event);
4724ba56
IS		 3503
3504 return 0;
3505}
3506
b1e45526
IS		 3507static int __mlxsw_sp_inetaddr_event(struct net_device *dev,
3508 unsigned long event)
3509{
3510 if (mlxsw_sp_port_dev_check(dev))
3511 return mlxsw_sp_inetaddr_port_event(dev, event);
3512 else if (netif_is_lag_master(dev))
3513 return mlxsw_sp_inetaddr_lag_event(dev, event);
3514 else if (netif_is_bridge_master(dev))
a1107487 3515 return mlxsw_sp_inetaddr_bridge_event(dev, event);
b1e45526
IS		 3516 else if (is_vlan_dev(dev))
3517 return mlxsw_sp_inetaddr_vlan_event(dev, event);
3518 else
3519 return 0;
3520}
3521
4724ba56
IS		 3522int mlxsw_sp_inetaddr_event(struct notifier_block *unused,
3523 unsigned long event, void *ptr)
3524{
3525 struct in_ifaddr *ifa = (struct in_ifaddr *) ptr;
3526 struct net_device *dev = ifa->ifa_dev->dev;
3527 struct mlxsw_sp *mlxsw_sp;
bf95233e 3528 struct mlxsw_sp_rif *rif;
4724ba56
IS		 3529 int err = 0;
3530
3531 mlxsw_sp = mlxsw_sp_lower_get(dev);
3532 if (!mlxsw_sp)
3533 goto out;
3534
bf95233e 3535 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
5ea1237f 3536 if (!mlxsw_sp_rif_should_config(rif, dev, event))
4724ba56
IS		 3537 goto out;
3538
b1e45526 3539 err = __mlxsw_sp_inetaddr_event(dev, event);
4724ba56
IS		 3540out:
3541 return notifier_from_errno(err);
3542}
3543
5ea1237f
AS		 3544struct mlxsw_sp_inet6addr_event_work {
3545 struct work_struct work;
3546 struct net_device *dev;
3547 unsigned long event;
3548};
3549
3550static void mlxsw_sp_inet6addr_event_work(struct work_struct *work)
3551{
3552 struct mlxsw_sp_inet6addr_event_work *inet6addr_work =
3553 container_of(work, struct mlxsw_sp_inet6addr_event_work, work);
3554 struct net_device *dev = inet6addr_work->dev;
3555 unsigned long event = inet6addr_work->event;
3556 struct mlxsw_sp *mlxsw_sp;
3557 struct mlxsw_sp_rif *rif;
3558
3559 rtnl_lock();
3560 mlxsw_sp = mlxsw_sp_lower_get(dev);
3561 if (!mlxsw_sp)
3562 goto out;
3563
3564 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
3565 if (!mlxsw_sp_rif_should_config(rif, dev, event))
3566 goto out;
3567
3568 __mlxsw_sp_inetaddr_event(dev, event);
3569out:
3570 rtnl_unlock();
3571 dev_put(dev);
3572 kfree(inet6addr_work);
3573}
3574
3575/* Called with rcu_read_lock() */
3576int mlxsw_sp_inet6addr_event(struct notifier_block *unused,
3577 unsigned long event, void *ptr)
3578{
3579 struct inet6_ifaddr *if6 = (struct inet6_ifaddr *) ptr;
3580 struct mlxsw_sp_inet6addr_event_work *inet6addr_work;
3581 struct net_device *dev = if6->idev->dev;
3582
3583 if (!mlxsw_sp_port_dev_lower_find_rcu(dev))
3584 return NOTIFY_DONE;
3585
3586 inet6addr_work = kzalloc(sizeof(*inet6addr_work), GFP_ATOMIC);
3587 if (!inet6addr_work)
3588 return NOTIFY_BAD;
3589
3590 INIT_WORK(&inet6addr_work->work, mlxsw_sp_inet6addr_event_work);
3591 inet6addr_work->dev = dev;
3592 inet6addr_work->event = event;
3593 dev_hold(dev);
3594 mlxsw_core_schedule_work(&inet6addr_work->work);
3595
3596 return NOTIFY_DONE;
3597}
3598
bf95233e 3599static int mlxsw_sp_rif_edit(struct mlxsw_sp *mlxsw_sp, u16 rif_index,
4724ba56
IS		 3600 const char *mac, int mtu)
3601{
3602 char ritr_pl[MLXSW_REG_RITR_LEN];
3603 int err;
3604
bf95233e 3605 mlxsw_reg_ritr_rif_pack(ritr_pl, rif_index);
4724ba56
IS		 3606 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
3607 if (err)
3608 return err;
3609
3610 mlxsw_reg_ritr_mtu_set(ritr_pl, mtu);
3611 mlxsw_reg_ritr_if_mac_memcpy_to(ritr_pl, mac);
3612 mlxsw_reg_ritr_op_set(ritr_pl, MLXSW_REG_RITR_RIF_CREATE);
3613 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
3614}
3615
3616int mlxsw_sp_netdevice_router_port_event(struct net_device *dev)
3617{
3618 struct mlxsw_sp *mlxsw_sp;
bf95233e 3619 struct mlxsw_sp_rif *rif;
a1107487 3620 u16 fid_index;
4724ba56
IS		 3621 int err;
3622
3623 mlxsw_sp = mlxsw_sp_lower_get(dev);
3624 if (!mlxsw_sp)
3625 return 0;
3626
bf95233e
AS		 3627 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
3628 if (!rif)
4724ba56 3629 return 0;
a1107487 3630 fid_index = mlxsw_sp_fid_index(rif->fid);
4724ba56 3631
a1107487 3632 err = mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, false);
4724ba56
IS		 3633 if (err)
3634 return err;
3635
bf95233e
AS		 3636 err = mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, dev->dev_addr,
3637 dev->mtu);
4724ba56
IS		 3638 if (err)
3639 goto err_rif_edit;
3640
a1107487 3641 err = mlxsw_sp_rif_fdb_op(mlxsw_sp, dev->dev_addr, fid_index, true);
4724ba56
IS		 3642 if (err)
3643 goto err_rif_fdb_op;
3644
bf95233e
AS		 3645 ether_addr_copy(rif->addr, dev->dev_addr);
3646 rif->mtu = dev->mtu;
4724ba56 3647
bf95233e 3648 netdev_dbg(dev, "Updated RIF=%d\n", rif->rif_index);
4724ba56
IS		 3649
3650 return 0;
3651
3652err_rif_fdb_op:
bf95233e 3653 mlxsw_sp_rif_edit(mlxsw_sp, rif->rif_index, rif->addr, rif->mtu);
4724ba56 3654err_rif_edit:
a1107487 3655 mlxsw_sp_rif_fdb_op(mlxsw_sp, rif->addr, fid_index, true);
4724ba56
IS		 3656 return err;
3657}
3658
b1e45526
IS		 3659static int mlxsw_sp_port_vrf_join(struct mlxsw_sp *mlxsw_sp,
3660 struct net_device *l3_dev)
7179eb5a 3661{
b1e45526 3662 struct mlxsw_sp_rif *rif;
7179eb5a 3663
b1e45526
IS		 3664 /* If netdev is already associated with a RIF, then we need to
3665 * destroy it and create a new one with the new virtual router ID.
7179eb5a 3666 */
b1e45526
IS		 3667 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
3668 if (rif)
3669 __mlxsw_sp_inetaddr_event(l3_dev, NETDEV_DOWN);
7179eb5a 3670
b1e45526 3671 return __mlxsw_sp_inetaddr_event(l3_dev, NETDEV_UP);
7179eb5a
IS		 3672}
3673
b1e45526
IS		 3674static void mlxsw_sp_port_vrf_leave(struct mlxsw_sp *mlxsw_sp,
3675 struct net_device *l3_dev)
7179eb5a 3676{
b1e45526 3677 struct mlxsw_sp_rif *rif;
7179eb5a 3678
b1e45526
IS		 3679 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, l3_dev);
3680 if (!rif)
7179eb5a 3681 return;
b1e45526 3682 __mlxsw_sp_inetaddr_event(l3_dev, NETDEV_DOWN);
7179eb5a
IS		 3683}
3684
b1e45526
IS		 3685int mlxsw_sp_netdevice_vrf_event(struct net_device *l3_dev, unsigned long event,
3686 struct netdev_notifier_changeupper_info *info)
3d70e458 3687{
b1e45526
IS		 3688 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(l3_dev);
3689 int err = 0;
3d70e458 3690
b1e45526
IS		 3691 if (!mlxsw_sp)
3692 return 0;
3d70e458 3693
b1e45526
IS		 3694 switch (event) {
3695 case NETDEV_PRECHANGEUPPER:
3696 return 0;
3697 case NETDEV_CHANGEUPPER:
3698 if (info->linking)
3699 err = mlxsw_sp_port_vrf_join(mlxsw_sp, l3_dev);
3700 else
3701 mlxsw_sp_port_vrf_leave(mlxsw_sp, l3_dev);
3702 break;
3703 }
3d70e458 3704
b1e45526 3705 return err;
3d70e458
IS		 3706}
3707
e4f3c1c1
IS		 3708static struct mlxsw_sp_rif_subport *
3709mlxsw_sp_rif_subport_rif(const struct mlxsw_sp_rif *rif)
a1107487 3710{
e4f3c1c1
IS		 3711 return container_of(rif, struct mlxsw_sp_rif_subport, common);
3712}
3713
3714static void mlxsw_sp_rif_subport_setup(struct mlxsw_sp_rif *rif,
3715 const struct mlxsw_sp_rif_params *params)
3716{
3717 struct mlxsw_sp_rif_subport *rif_subport;
3718
3719 rif_subport = mlxsw_sp_rif_subport_rif(rif);
3720 rif_subport->vid = params->vid;
3721 rif_subport->lag = params->lag;
3722 if (params->lag)
3723 rif_subport->lag_id = params->lag_id;
a1107487 3724 else
e4f3c1c1
IS		 3725 rif_subport->system_port = params->system_port;
3726}
3727
3728static int mlxsw_sp_rif_subport_op(struct mlxsw_sp_rif *rif, bool enable)
3729{
3730 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
3731 struct mlxsw_sp_rif_subport *rif_subport;
3732 char ritr_pl[MLXSW_REG_RITR_LEN];
3733
3734 rif_subport = mlxsw_sp_rif_subport_rif(rif);
3735 mlxsw_reg_ritr_pack(ritr_pl, enable, MLXSW_REG_RITR_SP_IF,
3736 rif->rif_index, rif->vr_id, rif->dev->mtu,
3737 rif->dev->dev_addr);
3738 mlxsw_reg_ritr_sp_if_pack(ritr_pl, rif_subport->lag,
3739 rif_subport->lag ? rif_subport->lag_id :
3740 rif_subport->system_port,
3741 rif_subport->vid);
3742
3743 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
3744}
3745
3746static int mlxsw_sp_rif_subport_configure(struct mlxsw_sp_rif *rif)
3747{
3748 return mlxsw_sp_rif_subport_op(rif, true);
a1107487
IS		 3749}
3750
e4f3c1c1
IS		 3751static void mlxsw_sp_rif_subport_deconfigure(struct mlxsw_sp_rif *rif)
3752{
3753 mlxsw_sp_rif_subport_op(rif, false);
3754}
3755
3756static struct mlxsw_sp_fid *
3757mlxsw_sp_rif_subport_fid_get(struct mlxsw_sp_rif *rif)
3758{
3759 return mlxsw_sp_fid_rfid_get(rif->mlxsw_sp, rif->rif_index);
3760}
3761
3762static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_subport_ops = {
3763 .type = MLXSW_SP_RIF_TYPE_SUBPORT,
3764 .rif_size = sizeof(struct mlxsw_sp_rif_subport),
3765 .setup = mlxsw_sp_rif_subport_setup,
3766 .configure = mlxsw_sp_rif_subport_configure,
3767 .deconfigure = mlxsw_sp_rif_subport_deconfigure,
3768 .fid_get = mlxsw_sp_rif_subport_fid_get,
3769};
3770
3771static int mlxsw_sp_rif_vlan_fid_op(struct mlxsw_sp_rif *rif,
3772 enum mlxsw_reg_ritr_if_type type,
3773 u16 vid_fid, bool enable)
3774{
3775 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
3776 char ritr_pl[MLXSW_REG_RITR_LEN];
3777
3778 mlxsw_reg_ritr_pack(ritr_pl, enable, type, rif->rif_index, rif->vr_id,
3779 rif->dev->mtu, rif->dev->dev_addr);
3780 mlxsw_reg_ritr_fid_set(ritr_pl, type, vid_fid);
3781
3782 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ritr), ritr_pl);
3783}
3784
3785static u8 mlxsw_sp_router_port(const struct mlxsw_sp *mlxsw_sp)
3786{
3787 return mlxsw_core_max_ports(mlxsw_sp->core) + 1;
3788}
3789
3790static int mlxsw_sp_rif_vlan_configure(struct mlxsw_sp_rif *rif)
3791{
3792 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
3793 u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
3794 int err;
3795
3796 err = mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, true);
3797 if (err)
3798 return err;
3799
0d284818
IS		 3800 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
3801 mlxsw_sp_router_port(mlxsw_sp), true);
3802 if (err)
3803 goto err_fid_mc_flood_set;
3804
e4f3c1c1
IS		 3805 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
3806 mlxsw_sp_router_port(mlxsw_sp), true);
3807 if (err)
3808 goto err_fid_bc_flood_set;
3809
3810 return 0;
3811
3812err_fid_bc_flood_set:
0d284818
IS		 3813 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
3814 mlxsw_sp_router_port(mlxsw_sp), false);
3815err_fid_mc_flood_set:
e4f3c1c1
IS		 3816 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, false);
3817 return err;
3818}
3819
3820static void mlxsw_sp_rif_vlan_deconfigure(struct mlxsw_sp_rif *rif)
3821{
3822 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
3823 u16 vid = mlxsw_sp_fid_8021q_vid(rif->fid);
3824
3825 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
3826 mlxsw_sp_router_port(mlxsw_sp), false);
0d284818
IS		 3827 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
3828 mlxsw_sp_router_port(mlxsw_sp), false);
e4f3c1c1
IS		 3829 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_VLAN_IF, vid, false);
3830}
3831
3832static struct mlxsw_sp_fid *
3833mlxsw_sp_rif_vlan_fid_get(struct mlxsw_sp_rif *rif)
3834{
3835 u16 vid = is_vlan_dev(rif->dev) ? vlan_dev_vlan_id(rif->dev) : 1;
3836
3837 return mlxsw_sp_fid_8021q_get(rif->mlxsw_sp, vid);
3838}
3839
3840static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_vlan_ops = {
3841 .type = MLXSW_SP_RIF_TYPE_VLAN,
3842 .rif_size = sizeof(struct mlxsw_sp_rif),
3843 .configure = mlxsw_sp_rif_vlan_configure,
3844 .deconfigure = mlxsw_sp_rif_vlan_deconfigure,
3845 .fid_get = mlxsw_sp_rif_vlan_fid_get,
3846};
3847
3848static int mlxsw_sp_rif_fid_configure(struct mlxsw_sp_rif *rif)
3849{
3850 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
3851 u16 fid_index = mlxsw_sp_fid_index(rif->fid);
3852 int err;
3853
3854 err = mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index,
3855 true);
3856 if (err)
3857 return err;
3858
0d284818
IS		 3859 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
3860 mlxsw_sp_router_port(mlxsw_sp), true);
3861 if (err)
3862 goto err_fid_mc_flood_set;
3863
e4f3c1c1
IS		 3864 err = mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
3865 mlxsw_sp_router_port(mlxsw_sp), true);
3866 if (err)
3867 goto err_fid_bc_flood_set;
3868
3869 return 0;
3870
3871err_fid_bc_flood_set:
0d284818
IS		 3872 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
3873 mlxsw_sp_router_port(mlxsw_sp), false);
3874err_fid_mc_flood_set:
e4f3c1c1
IS		 3875 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index, false);
3876 return err;
3877}
3878
3879static void mlxsw_sp_rif_fid_deconfigure(struct mlxsw_sp_rif *rif)
3880{
3881 struct mlxsw_sp *mlxsw_sp = rif->mlxsw_sp;
3882 u16 fid_index = mlxsw_sp_fid_index(rif->fid);
3883
3884 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_BC,
3885 mlxsw_sp_router_port(mlxsw_sp), false);
0d284818
IS		 3886 mlxsw_sp_fid_flood_set(rif->fid, MLXSW_SP_FLOOD_TYPE_MC,
3887 mlxsw_sp_router_port(mlxsw_sp), false);
e4f3c1c1
IS		 3888 mlxsw_sp_rif_vlan_fid_op(rif, MLXSW_REG_RITR_FID_IF, fid_index, false);
3889}
3890
3891static struct mlxsw_sp_fid *
3892mlxsw_sp_rif_fid_fid_get(struct mlxsw_sp_rif *rif)
3893{
3894 return mlxsw_sp_fid_8021d_get(rif->mlxsw_sp, rif->dev->ifindex);
3895}
3896
3897static const struct mlxsw_sp_rif_ops mlxsw_sp_rif_fid_ops = {
3898 .type = MLXSW_SP_RIF_TYPE_FID,
3899 .rif_size = sizeof(struct mlxsw_sp_rif),
3900 .configure = mlxsw_sp_rif_fid_configure,
3901 .deconfigure = mlxsw_sp_rif_fid_deconfigure,
3902 .fid_get = mlxsw_sp_rif_fid_fid_get,
3903};
3904
3905static const struct mlxsw_sp_rif_ops *mlxsw_sp_rif_ops_arr[] = {
3906 [MLXSW_SP_RIF_TYPE_SUBPORT] = &mlxsw_sp_rif_subport_ops,
3907 [MLXSW_SP_RIF_TYPE_VLAN] = &mlxsw_sp_rif_vlan_ops,
3908 [MLXSW_SP_RIF_TYPE_FID] = &mlxsw_sp_rif_fid_ops,
3909};
3910
348b8fc3
IS		 3911static int mlxsw_sp_rifs_init(struct mlxsw_sp *mlxsw_sp)
3912{
3913 u64 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
3914
3915 mlxsw_sp->router->rifs = kcalloc(max_rifs,
3916 sizeof(struct mlxsw_sp_rif *),
3917 GFP_KERNEL);
3918 if (!mlxsw_sp->router->rifs)
3919 return -ENOMEM;
e4f3c1c1
IS		 3920
3921 mlxsw_sp->router->rif_ops_arr = mlxsw_sp_rif_ops_arr;
3922
348b8fc3
IS		 3923 return 0;
3924}
3925
3926static void mlxsw_sp_rifs_fini(struct mlxsw_sp *mlxsw_sp)
3927{
3928 int i;
3929
3930 for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++)
3931 WARN_ON_ONCE(mlxsw_sp->router->rifs[i]);
3932
3933 kfree(mlxsw_sp->router->rifs);
3934}
3935
c3852ef7
IS		 3936static void mlxsw_sp_router_fib_dump_flush(struct notifier_block *nb)
3937{
7e39d115 3938 struct mlxsw_sp_router *router;
c3852ef7
IS		 3939
3940 /* Flush pending FIB notifications and then flush the device's
3941 * table before requesting another dump. The FIB notification
3942 * block is unregistered, so no need to take RTNL.
3943 */
3944 mlxsw_core_flush_owq();
7e39d115
IS		 3945 router = container_of(nb, struct mlxsw_sp_router, fib_nb);
3946 mlxsw_sp_router_fib_flush(router->mlxsw_sp);
c3852ef7
IS		 3947}
3948
4724ba56
IS		 3949static int __mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp)
3950{
3951 char rgcr_pl[MLXSW_REG_RGCR_LEN];
3952 u64 max_rifs;
3953 int err;
3954
3955 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_RIFS))
3956 return -EIO;
4724ba56 3957 max_rifs = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
4724ba56 3958
e29237e7 3959 mlxsw_reg_rgcr_pack(rgcr_pl, true, true);
4724ba56
IS		 3960 mlxsw_reg_rgcr_max_router_interfaces_set(rgcr_pl, max_rifs);
3961 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
3962 if (err)
348b8fc3 3963 return err;
4724ba56 3964 return 0;
4724ba56
IS		 3965}
3966
3967static void __mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
3968{
3969 char rgcr_pl[MLXSW_REG_RGCR_LEN];
4724ba56 3970
e29237e7 3971 mlxsw_reg_rgcr_pack(rgcr_pl, false, false);
4724ba56 3972 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(rgcr), rgcr_pl);
4724ba56
IS		 3973}
3974
b45f64d1
JP		 3975int mlxsw_sp_router_init(struct mlxsw_sp *mlxsw_sp)
3976{
9011b677 3977 struct mlxsw_sp_router *router;
b45f64d1
JP		 3978 int err;
3979
9011b677
IS		 3980 router = kzalloc(sizeof(*mlxsw_sp->router), GFP_KERNEL);
3981 if (!router)
3982 return -ENOMEM;
3983 mlxsw_sp->router = router;
3984 router->mlxsw_sp = mlxsw_sp;
3985
3986 INIT_LIST_HEAD(&mlxsw_sp->router->nexthop_neighs_list);
b45f64d1
JP		 3987 err = __mlxsw_sp_router_init(mlxsw_sp);
3988 if (err)
9011b677 3989 goto err_router_init;
b45f64d1 3990
348b8fc3
IS		 3991 err = mlxsw_sp_rifs_init(mlxsw_sp);
3992 if (err)
3993 goto err_rifs_init;
3994
9011b677 3995 err = rhashtable_init(&mlxsw_sp->router->nexthop_ht,
c53b8e1b
IS		 3996 &mlxsw_sp_nexthop_ht_params);
3997 if (err)
3998 goto err_nexthop_ht_init;
3999
9011b677 4000 err = rhashtable_init(&mlxsw_sp->router->nexthop_group_ht,
e9ad5e7d
IS		 4001 &mlxsw_sp_nexthop_group_ht_params);
4002 if (err)
4003 goto err_nexthop_group_ht_init;
4004
8494ab06
IS		 4005 err = mlxsw_sp_lpm_init(mlxsw_sp);
4006 if (err)
4007 goto err_lpm_init;
4008
b45f64d1
JP		 4009 err = mlxsw_sp_vrs_init(mlxsw_sp);
4010 if (err)
4011 goto err_vrs_init;
4012
8c9583a8 4013 err = mlxsw_sp_neigh_init(mlxsw_sp);
b45f64d1
JP		 4014 if (err)
4015 goto err_neigh_init;
4016
7e39d115
IS		 4017 mlxsw_sp->router->fib_nb.notifier_call = mlxsw_sp_router_fib_event;
4018 err = register_fib_notifier(&mlxsw_sp->router->fib_nb,
c3852ef7
IS		 4019 mlxsw_sp_router_fib_dump_flush);
4020 if (err)
4021 goto err_register_fib_notifier;
4022
b45f64d1
JP		 4023 return 0;
4024
c3852ef7
IS		 4025err_register_fib_notifier:
4026 mlxsw_sp_neigh_fini(mlxsw_sp);
b45f64d1
JP		 4027err_neigh_init:
4028 mlxsw_sp_vrs_fini(mlxsw_sp);
4029err_vrs_init:
8494ab06
IS		 4030 mlxsw_sp_lpm_fini(mlxsw_sp);
4031err_lpm_init:
9011b677 4032 rhashtable_destroy(&mlxsw_sp->router->nexthop_group_ht);
e9ad5e7d 4033err_nexthop_group_ht_init:
9011b677 4034 rhashtable_destroy(&mlxsw_sp->router->nexthop_ht);
c53b8e1b 4035err_nexthop_ht_init:
348b8fc3
IS		 4036 mlxsw_sp_rifs_fini(mlxsw_sp);
4037err_rifs_init:
b45f64d1 4038 __mlxsw_sp_router_fini(mlxsw_sp);
9011b677
IS		 4039err_router_init:
4040 kfree(mlxsw_sp->router);
b45f64d1
JP		 4041 return err;
4042}
4043
4044void mlxsw_sp_router_fini(struct mlxsw_sp *mlxsw_sp)
4045{
7e39d115 4046 unregister_fib_notifier(&mlxsw_sp->router->fib_nb);
b45f64d1
JP		 4047 mlxsw_sp_neigh_fini(mlxsw_sp);
4048 mlxsw_sp_vrs_fini(mlxsw_sp);
8494ab06 4049 mlxsw_sp_lpm_fini(mlxsw_sp);
9011b677
IS		 4050 rhashtable_destroy(&mlxsw_sp->router->nexthop_group_ht);
4051 rhashtable_destroy(&mlxsw_sp->router->nexthop_ht);
348b8fc3 4052 mlxsw_sp_rifs_fini(mlxsw_sp);
b45f64d1 4053 __mlxsw_sp_router_fini(mlxsw_sp);
9011b677 4054 kfree(mlxsw_sp->router);
b45f64d1 4055}
ubuntu-bionic-kernel mirror