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