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