]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
switchdev: Add extack argument to call_switchdev_notifiers()
[mirror_ubuntu-hirsute-kernel.git] / drivers / net / ethernet / mellanox / mlxsw / spectrum_switchdev.c
1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /* Copyright (c) 2015-2018 Mellanox Technologies. All rights reserved */
3
4 #include <linux/kernel.h>
5 #include <linux/types.h>
6 #include <linux/netdevice.h>
7 #include <linux/etherdevice.h>
8 #include <linux/slab.h>
9 #include <linux/device.h>
10 #include <linux/skbuff.h>
11 #include <linux/if_vlan.h>
12 #include <linux/if_bridge.h>
13 #include <linux/workqueue.h>
14 #include <linux/jiffies.h>
15 #include <linux/rtnetlink.h>
16 #include <linux/netlink.h>
17 #include <net/switchdev.h>
18 #include <net/vxlan.h>
19
20 #include "spectrum_span.h"
21 #include "spectrum_switchdev.h"
22 #include "spectrum.h"
23 #include "core.h"
24 #include "reg.h"
25
26 struct mlxsw_sp_bridge_ops;
27
28 struct mlxsw_sp_bridge {
29 struct mlxsw_sp *mlxsw_sp;
30 struct {
31 struct delayed_work dw;
32 #define MLXSW_SP_DEFAULT_LEARNING_INTERVAL 100
33 unsigned int interval; /* ms */
34 } fdb_notify;
35 #define MLXSW_SP_MIN_AGEING_TIME 10
36 #define MLXSW_SP_MAX_AGEING_TIME 1000000
37 #define MLXSW_SP_DEFAULT_AGEING_TIME 300
38 u32 ageing_time;
39 bool vlan_enabled_exists;
40 struct list_head bridges_list;
41 DECLARE_BITMAP(mids_bitmap, MLXSW_SP_MID_MAX);
42 const struct mlxsw_sp_bridge_ops *bridge_8021q_ops;
43 const struct mlxsw_sp_bridge_ops *bridge_8021d_ops;
44 };
45
46 struct mlxsw_sp_bridge_device {
47 struct net_device *dev;
48 struct list_head list;
49 struct list_head ports_list;
50 struct list_head mids_list;
51 u8 vlan_enabled:1,
52 multicast_enabled:1,
53 mrouter:1;
54 const struct mlxsw_sp_bridge_ops *ops;
55 };
56
57 struct mlxsw_sp_bridge_port {
58 struct net_device *dev;
59 struct mlxsw_sp_bridge_device *bridge_device;
60 struct list_head list;
61 struct list_head vlans_list;
62 unsigned int ref_count;
63 u8 stp_state;
64 unsigned long flags;
65 bool mrouter;
66 bool lagged;
67 union {
68 u16 lag_id;
69 u16 system_port;
70 };
71 };
72
73 struct mlxsw_sp_bridge_vlan {
74 struct list_head list;
75 struct list_head port_vlan_list;
76 u16 vid;
77 };
78
79 struct mlxsw_sp_bridge_ops {
80 int (*port_join)(struct mlxsw_sp_bridge_device *bridge_device,
81 struct mlxsw_sp_bridge_port *bridge_port,
82 struct mlxsw_sp_port *mlxsw_sp_port,
83 struct netlink_ext_ack *extack);
84 void (*port_leave)(struct mlxsw_sp_bridge_device *bridge_device,
85 struct mlxsw_sp_bridge_port *bridge_port,
86 struct mlxsw_sp_port *mlxsw_sp_port);
87 int (*vxlan_join)(struct mlxsw_sp_bridge_device *bridge_device,
88 const struct net_device *vxlan_dev, u16 vid,
89 struct netlink_ext_ack *extack);
90 struct mlxsw_sp_fid *
91 (*fid_get)(struct mlxsw_sp_bridge_device *bridge_device,
92 u16 vid, struct netlink_ext_ack *extack);
93 struct mlxsw_sp_fid *
94 (*fid_lookup)(struct mlxsw_sp_bridge_device *bridge_device,
95 u16 vid);
96 u16 (*fid_vid)(struct mlxsw_sp_bridge_device *bridge_device,
97 const struct mlxsw_sp_fid *fid);
98 };
99
100 static int
101 mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp,
102 struct mlxsw_sp_bridge_port *bridge_port,
103 u16 fid_index);
104
105 static void
106 mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port,
107 struct mlxsw_sp_bridge_port *bridge_port);
108
109 static void
110 mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp_port *mlxsw_sp_port,
111 struct mlxsw_sp_bridge_device
112 *bridge_device);
113
114 static void
115 mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port,
116 struct mlxsw_sp_bridge_port *bridge_port,
117 bool add);
118
119 static struct mlxsw_sp_bridge_device *
120 mlxsw_sp_bridge_device_find(const struct mlxsw_sp_bridge *bridge,
121 const struct net_device *br_dev)
122 {
123 struct mlxsw_sp_bridge_device *bridge_device;
124
125 list_for_each_entry(bridge_device, &bridge->bridges_list, list)
126 if (bridge_device->dev == br_dev)
127 return bridge_device;
128
129 return NULL;
130 }
131
132 bool mlxsw_sp_bridge_device_is_offloaded(const struct mlxsw_sp *mlxsw_sp,
133 const struct net_device *br_dev)
134 {
135 return !!mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
136 }
137
138 static int mlxsw_sp_bridge_device_upper_rif_destroy(struct net_device *dev,
139 void *data)
140 {
141 struct mlxsw_sp *mlxsw_sp = data;
142
143 mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev);
144 return 0;
145 }
146
147 static void mlxsw_sp_bridge_device_rifs_destroy(struct mlxsw_sp *mlxsw_sp,
148 struct net_device *dev)
149 {
150 mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev);
151 netdev_walk_all_upper_dev_rcu(dev,
152 mlxsw_sp_bridge_device_upper_rif_destroy,
153 mlxsw_sp);
154 }
155
156 static struct mlxsw_sp_bridge_device *
157 mlxsw_sp_bridge_device_create(struct mlxsw_sp_bridge *bridge,
158 struct net_device *br_dev)
159 {
160 struct device *dev = bridge->mlxsw_sp->bus_info->dev;
161 struct mlxsw_sp_bridge_device *bridge_device;
162 bool vlan_enabled = br_vlan_enabled(br_dev);
163
164 if (vlan_enabled && bridge->vlan_enabled_exists) {
165 dev_err(dev, "Only one VLAN-aware bridge is supported\n");
166 return ERR_PTR(-EINVAL);
167 }
168
169 bridge_device = kzalloc(sizeof(*bridge_device), GFP_KERNEL);
170 if (!bridge_device)
171 return ERR_PTR(-ENOMEM);
172
173 bridge_device->dev = br_dev;
174 bridge_device->vlan_enabled = vlan_enabled;
175 bridge_device->multicast_enabled = br_multicast_enabled(br_dev);
176 bridge_device->mrouter = br_multicast_router(br_dev);
177 INIT_LIST_HEAD(&bridge_device->ports_list);
178 if (vlan_enabled) {
179 bridge->vlan_enabled_exists = true;
180 bridge_device->ops = bridge->bridge_8021q_ops;
181 } else {
182 bridge_device->ops = bridge->bridge_8021d_ops;
183 }
184 INIT_LIST_HEAD(&bridge_device->mids_list);
185 list_add(&bridge_device->list, &bridge->bridges_list);
186
187 return bridge_device;
188 }
189
190 static void
191 mlxsw_sp_bridge_device_destroy(struct mlxsw_sp_bridge *bridge,
192 struct mlxsw_sp_bridge_device *bridge_device)
193 {
194 mlxsw_sp_bridge_device_rifs_destroy(bridge->mlxsw_sp,
195 bridge_device->dev);
196 list_del(&bridge_device->list);
197 if (bridge_device->vlan_enabled)
198 bridge->vlan_enabled_exists = false;
199 WARN_ON(!list_empty(&bridge_device->ports_list));
200 WARN_ON(!list_empty(&bridge_device->mids_list));
201 kfree(bridge_device);
202 }
203
204 static struct mlxsw_sp_bridge_device *
205 mlxsw_sp_bridge_device_get(struct mlxsw_sp_bridge *bridge,
206 struct net_device *br_dev)
207 {
208 struct mlxsw_sp_bridge_device *bridge_device;
209
210 bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev);
211 if (bridge_device)
212 return bridge_device;
213
214 return mlxsw_sp_bridge_device_create(bridge, br_dev);
215 }
216
217 static void
218 mlxsw_sp_bridge_device_put(struct mlxsw_sp_bridge *bridge,
219 struct mlxsw_sp_bridge_device *bridge_device)
220 {
221 if (list_empty(&bridge_device->ports_list))
222 mlxsw_sp_bridge_device_destroy(bridge, bridge_device);
223 }
224
225 static struct mlxsw_sp_bridge_port *
226 __mlxsw_sp_bridge_port_find(const struct mlxsw_sp_bridge_device *bridge_device,
227 const struct net_device *brport_dev)
228 {
229 struct mlxsw_sp_bridge_port *bridge_port;
230
231 list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
232 if (bridge_port->dev == brport_dev)
233 return bridge_port;
234 }
235
236 return NULL;
237 }
238
239 struct mlxsw_sp_bridge_port *
240 mlxsw_sp_bridge_port_find(struct mlxsw_sp_bridge *bridge,
241 struct net_device *brport_dev)
242 {
243 struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev);
244 struct mlxsw_sp_bridge_device *bridge_device;
245
246 if (!br_dev)
247 return NULL;
248
249 bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev);
250 if (!bridge_device)
251 return NULL;
252
253 return __mlxsw_sp_bridge_port_find(bridge_device, brport_dev);
254 }
255
256 static struct mlxsw_sp_bridge_port *
257 mlxsw_sp_bridge_port_create(struct mlxsw_sp_bridge_device *bridge_device,
258 struct net_device *brport_dev)
259 {
260 struct mlxsw_sp_bridge_port *bridge_port;
261 struct mlxsw_sp_port *mlxsw_sp_port;
262
263 bridge_port = kzalloc(sizeof(*bridge_port), GFP_KERNEL);
264 if (!bridge_port)
265 return NULL;
266
267 mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(brport_dev);
268 bridge_port->lagged = mlxsw_sp_port->lagged;
269 if (bridge_port->lagged)
270 bridge_port->lag_id = mlxsw_sp_port->lag_id;
271 else
272 bridge_port->system_port = mlxsw_sp_port->local_port;
273 bridge_port->dev = brport_dev;
274 bridge_port->bridge_device = bridge_device;
275 bridge_port->stp_state = BR_STATE_DISABLED;
276 bridge_port->flags = BR_LEARNING | BR_FLOOD | BR_LEARNING_SYNC |
277 BR_MCAST_FLOOD;
278 INIT_LIST_HEAD(&bridge_port->vlans_list);
279 list_add(&bridge_port->list, &bridge_device->ports_list);
280 bridge_port->ref_count = 1;
281
282 return bridge_port;
283 }
284
285 static void
286 mlxsw_sp_bridge_port_destroy(struct mlxsw_sp_bridge_port *bridge_port)
287 {
288 list_del(&bridge_port->list);
289 WARN_ON(!list_empty(&bridge_port->vlans_list));
290 kfree(bridge_port);
291 }
292
293 static struct mlxsw_sp_bridge_port *
294 mlxsw_sp_bridge_port_get(struct mlxsw_sp_bridge *bridge,
295 struct net_device *brport_dev)
296 {
297 struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev);
298 struct mlxsw_sp_bridge_device *bridge_device;
299 struct mlxsw_sp_bridge_port *bridge_port;
300 int err;
301
302 bridge_port = mlxsw_sp_bridge_port_find(bridge, brport_dev);
303 if (bridge_port) {
304 bridge_port->ref_count++;
305 return bridge_port;
306 }
307
308 bridge_device = mlxsw_sp_bridge_device_get(bridge, br_dev);
309 if (IS_ERR(bridge_device))
310 return ERR_CAST(bridge_device);
311
312 bridge_port = mlxsw_sp_bridge_port_create(bridge_device, brport_dev);
313 if (!bridge_port) {
314 err = -ENOMEM;
315 goto err_bridge_port_create;
316 }
317
318 return bridge_port;
319
320 err_bridge_port_create:
321 mlxsw_sp_bridge_device_put(bridge, bridge_device);
322 return ERR_PTR(err);
323 }
324
325 static void mlxsw_sp_bridge_port_put(struct mlxsw_sp_bridge *bridge,
326 struct mlxsw_sp_bridge_port *bridge_port)
327 {
328 struct mlxsw_sp_bridge_device *bridge_device;
329
330 if (--bridge_port->ref_count != 0)
331 return;
332 bridge_device = bridge_port->bridge_device;
333 mlxsw_sp_bridge_port_destroy(bridge_port);
334 mlxsw_sp_bridge_device_put(bridge, bridge_device);
335 }
336
337 static struct mlxsw_sp_port_vlan *
338 mlxsw_sp_port_vlan_find_by_bridge(struct mlxsw_sp_port *mlxsw_sp_port,
339 const struct mlxsw_sp_bridge_device *
340 bridge_device,
341 u16 vid)
342 {
343 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
344
345 list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
346 list) {
347 if (!mlxsw_sp_port_vlan->bridge_port)
348 continue;
349 if (mlxsw_sp_port_vlan->bridge_port->bridge_device !=
350 bridge_device)
351 continue;
352 if (bridge_device->vlan_enabled &&
353 mlxsw_sp_port_vlan->vid != vid)
354 continue;
355 return mlxsw_sp_port_vlan;
356 }
357
358 return NULL;
359 }
360
361 static struct mlxsw_sp_port_vlan*
362 mlxsw_sp_port_vlan_find_by_fid(struct mlxsw_sp_port *mlxsw_sp_port,
363 u16 fid_index)
364 {
365 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
366
367 list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
368 list) {
369 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
370
371 if (fid && mlxsw_sp_fid_index(fid) == fid_index)
372 return mlxsw_sp_port_vlan;
373 }
374
375 return NULL;
376 }
377
378 static struct mlxsw_sp_bridge_vlan *
379 mlxsw_sp_bridge_vlan_find(const struct mlxsw_sp_bridge_port *bridge_port,
380 u16 vid)
381 {
382 struct mlxsw_sp_bridge_vlan *bridge_vlan;
383
384 list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
385 if (bridge_vlan->vid == vid)
386 return bridge_vlan;
387 }
388
389 return NULL;
390 }
391
392 static struct mlxsw_sp_bridge_vlan *
393 mlxsw_sp_bridge_vlan_create(struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
394 {
395 struct mlxsw_sp_bridge_vlan *bridge_vlan;
396
397 bridge_vlan = kzalloc(sizeof(*bridge_vlan), GFP_KERNEL);
398 if (!bridge_vlan)
399 return NULL;
400
401 INIT_LIST_HEAD(&bridge_vlan->port_vlan_list);
402 bridge_vlan->vid = vid;
403 list_add(&bridge_vlan->list, &bridge_port->vlans_list);
404
405 return bridge_vlan;
406 }
407
408 static void
409 mlxsw_sp_bridge_vlan_destroy(struct mlxsw_sp_bridge_vlan *bridge_vlan)
410 {
411 list_del(&bridge_vlan->list);
412 WARN_ON(!list_empty(&bridge_vlan->port_vlan_list));
413 kfree(bridge_vlan);
414 }
415
416 static struct mlxsw_sp_bridge_vlan *
417 mlxsw_sp_bridge_vlan_get(struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
418 {
419 struct mlxsw_sp_bridge_vlan *bridge_vlan;
420
421 bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid);
422 if (bridge_vlan)
423 return bridge_vlan;
424
425 return mlxsw_sp_bridge_vlan_create(bridge_port, vid);
426 }
427
428 static void mlxsw_sp_bridge_vlan_put(struct mlxsw_sp_bridge_vlan *bridge_vlan)
429 {
430 if (list_empty(&bridge_vlan->port_vlan_list))
431 mlxsw_sp_bridge_vlan_destroy(bridge_vlan);
432 }
433
434 static void mlxsw_sp_port_bridge_flags_get(struct mlxsw_sp_bridge *bridge,
435 struct net_device *dev,
436 unsigned long *brport_flags)
437 {
438 struct mlxsw_sp_bridge_port *bridge_port;
439
440 bridge_port = mlxsw_sp_bridge_port_find(bridge, dev);
441 if (WARN_ON(!bridge_port))
442 return;
443
444 memcpy(brport_flags, &bridge_port->flags, sizeof(*brport_flags));
445 }
446
447 static int mlxsw_sp_port_attr_get(struct net_device *dev,
448 struct switchdev_attr *attr)
449 {
450 struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
451 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
452
453 switch (attr->id) {
454 case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
455 attr->u.ppid.id_len = sizeof(mlxsw_sp->base_mac);
456 memcpy(&attr->u.ppid.id, &mlxsw_sp->base_mac,
457 attr->u.ppid.id_len);
458 break;
459 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
460 mlxsw_sp_port_bridge_flags_get(mlxsw_sp->bridge, attr->orig_dev,
461 &attr->u.brport_flags);
462 break;
463 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS_SUPPORT:
464 attr->u.brport_flags_support = BR_LEARNING | BR_FLOOD |
465 BR_MCAST_FLOOD;
466 break;
467 default:
468 return -EOPNOTSUPP;
469 }
470
471 return 0;
472 }
473
474 static int
475 mlxsw_sp_port_bridge_vlan_stp_set(struct mlxsw_sp_port *mlxsw_sp_port,
476 struct mlxsw_sp_bridge_vlan *bridge_vlan,
477 u8 state)
478 {
479 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
480
481 list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
482 bridge_vlan_node) {
483 if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
484 continue;
485 return mlxsw_sp_port_vid_stp_set(mlxsw_sp_port,
486 bridge_vlan->vid, state);
487 }
488
489 return 0;
490 }
491
492 static int mlxsw_sp_port_attr_stp_state_set(struct mlxsw_sp_port *mlxsw_sp_port,
493 struct switchdev_trans *trans,
494 struct net_device *orig_dev,
495 u8 state)
496 {
497 struct mlxsw_sp_bridge_port *bridge_port;
498 struct mlxsw_sp_bridge_vlan *bridge_vlan;
499 int err;
500
501 if (switchdev_trans_ph_prepare(trans))
502 return 0;
503
504 /* It's possible we failed to enslave the port, yet this
505 * operation is executed due to it being deferred.
506 */
507 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
508 orig_dev);
509 if (!bridge_port)
510 return 0;
511
512 list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
513 err = mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port,
514 bridge_vlan, state);
515 if (err)
516 goto err_port_bridge_vlan_stp_set;
517 }
518
519 bridge_port->stp_state = state;
520
521 return 0;
522
523 err_port_bridge_vlan_stp_set:
524 list_for_each_entry_continue_reverse(bridge_vlan,
525 &bridge_port->vlans_list, list)
526 mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port, bridge_vlan,
527 bridge_port->stp_state);
528 return err;
529 }
530
531 static int
532 mlxsw_sp_port_bridge_vlan_flood_set(struct mlxsw_sp_port *mlxsw_sp_port,
533 struct mlxsw_sp_bridge_vlan *bridge_vlan,
534 enum mlxsw_sp_flood_type packet_type,
535 bool member)
536 {
537 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
538
539 list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
540 bridge_vlan_node) {
541 if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
542 continue;
543 return mlxsw_sp_fid_flood_set(mlxsw_sp_port_vlan->fid,
544 packet_type,
545 mlxsw_sp_port->local_port,
546 member);
547 }
548
549 return 0;
550 }
551
552 static int
553 mlxsw_sp_bridge_port_flood_table_set(struct mlxsw_sp_port *mlxsw_sp_port,
554 struct mlxsw_sp_bridge_port *bridge_port,
555 enum mlxsw_sp_flood_type packet_type,
556 bool member)
557 {
558 struct mlxsw_sp_bridge_vlan *bridge_vlan;
559 int err;
560
561 list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
562 err = mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port,
563 bridge_vlan,
564 packet_type,
565 member);
566 if (err)
567 goto err_port_bridge_vlan_flood_set;
568 }
569
570 return 0;
571
572 err_port_bridge_vlan_flood_set:
573 list_for_each_entry_continue_reverse(bridge_vlan,
574 &bridge_port->vlans_list, list)
575 mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port, bridge_vlan,
576 packet_type, !member);
577 return err;
578 }
579
580 static int
581 mlxsw_sp_port_bridge_vlan_learning_set(struct mlxsw_sp_port *mlxsw_sp_port,
582 struct mlxsw_sp_bridge_vlan *bridge_vlan,
583 bool set)
584 {
585 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
586 u16 vid = bridge_vlan->vid;
587
588 list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
589 bridge_vlan_node) {
590 if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
591 continue;
592 return mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, set);
593 }
594
595 return 0;
596 }
597
598 static int
599 mlxsw_sp_bridge_port_learning_set(struct mlxsw_sp_port *mlxsw_sp_port,
600 struct mlxsw_sp_bridge_port *bridge_port,
601 bool set)
602 {
603 struct mlxsw_sp_bridge_vlan *bridge_vlan;
604 int err;
605
606 list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
607 err = mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port,
608 bridge_vlan, set);
609 if (err)
610 goto err_port_bridge_vlan_learning_set;
611 }
612
613 return 0;
614
615 err_port_bridge_vlan_learning_set:
616 list_for_each_entry_continue_reverse(bridge_vlan,
617 &bridge_port->vlans_list, list)
618 mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port,
619 bridge_vlan, !set);
620 return err;
621 }
622
623 static int mlxsw_sp_port_attr_br_flags_set(struct mlxsw_sp_port *mlxsw_sp_port,
624 struct switchdev_trans *trans,
625 struct net_device *orig_dev,
626 unsigned long brport_flags)
627 {
628 struct mlxsw_sp_bridge_port *bridge_port;
629 int err;
630
631 if (switchdev_trans_ph_prepare(trans))
632 return 0;
633
634 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
635 orig_dev);
636 if (!bridge_port)
637 return 0;
638
639 err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, bridge_port,
640 MLXSW_SP_FLOOD_TYPE_UC,
641 brport_flags & BR_FLOOD);
642 if (err)
643 return err;
644
645 err = mlxsw_sp_bridge_port_learning_set(mlxsw_sp_port, bridge_port,
646 brport_flags & BR_LEARNING);
647 if (err)
648 return err;
649
650 if (bridge_port->bridge_device->multicast_enabled)
651 goto out;
652
653 err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, bridge_port,
654 MLXSW_SP_FLOOD_TYPE_MC,
655 brport_flags &
656 BR_MCAST_FLOOD);
657 if (err)
658 return err;
659
660 out:
661 memcpy(&bridge_port->flags, &brport_flags, sizeof(brport_flags));
662 return 0;
663 }
664
665 static int mlxsw_sp_ageing_set(struct mlxsw_sp *mlxsw_sp, u32 ageing_time)
666 {
667 char sfdat_pl[MLXSW_REG_SFDAT_LEN];
668 int err;
669
670 mlxsw_reg_sfdat_pack(sfdat_pl, ageing_time);
671 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdat), sfdat_pl);
672 if (err)
673 return err;
674 mlxsw_sp->bridge->ageing_time = ageing_time;
675 return 0;
676 }
677
678 static int mlxsw_sp_port_attr_br_ageing_set(struct mlxsw_sp_port *mlxsw_sp_port,
679 struct switchdev_trans *trans,
680 unsigned long ageing_clock_t)
681 {
682 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
683 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);
684 u32 ageing_time = jiffies_to_msecs(ageing_jiffies) / 1000;
685
686 if (switchdev_trans_ph_prepare(trans)) {
687 if (ageing_time < MLXSW_SP_MIN_AGEING_TIME ||
688 ageing_time > MLXSW_SP_MAX_AGEING_TIME)
689 return -ERANGE;
690 else
691 return 0;
692 }
693
694 return mlxsw_sp_ageing_set(mlxsw_sp, ageing_time);
695 }
696
697 static int mlxsw_sp_port_attr_br_vlan_set(struct mlxsw_sp_port *mlxsw_sp_port,
698 struct switchdev_trans *trans,
699 struct net_device *orig_dev,
700 bool vlan_enabled)
701 {
702 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
703 struct mlxsw_sp_bridge_device *bridge_device;
704
705 if (!switchdev_trans_ph_prepare(trans))
706 return 0;
707
708 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
709 if (WARN_ON(!bridge_device))
710 return -EINVAL;
711
712 if (bridge_device->vlan_enabled == vlan_enabled)
713 return 0;
714
715 netdev_err(bridge_device->dev, "VLAN filtering can't be changed for existing bridge\n");
716 return -EINVAL;
717 }
718
719 static int mlxsw_sp_port_attr_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port,
720 struct switchdev_trans *trans,
721 struct net_device *orig_dev,
722 bool is_port_mrouter)
723 {
724 struct mlxsw_sp_bridge_port *bridge_port;
725 int err;
726
727 if (switchdev_trans_ph_prepare(trans))
728 return 0;
729
730 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
731 orig_dev);
732 if (!bridge_port)
733 return 0;
734
735 if (!bridge_port->bridge_device->multicast_enabled)
736 goto out;
737
738 err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, bridge_port,
739 MLXSW_SP_FLOOD_TYPE_MC,
740 is_port_mrouter);
741 if (err)
742 return err;
743
744 mlxsw_sp_port_mrouter_update_mdb(mlxsw_sp_port, bridge_port,
745 is_port_mrouter);
746 out:
747 bridge_port->mrouter = is_port_mrouter;
748 return 0;
749 }
750
751 static bool mlxsw_sp_mc_flood(const struct mlxsw_sp_bridge_port *bridge_port)
752 {
753 const struct mlxsw_sp_bridge_device *bridge_device;
754
755 bridge_device = bridge_port->bridge_device;
756 return bridge_device->multicast_enabled ? bridge_port->mrouter :
757 bridge_port->flags & BR_MCAST_FLOOD;
758 }
759
760 static int mlxsw_sp_port_mc_disabled_set(struct mlxsw_sp_port *mlxsw_sp_port,
761 struct switchdev_trans *trans,
762 struct net_device *orig_dev,
763 bool mc_disabled)
764 {
765 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
766 struct mlxsw_sp_bridge_device *bridge_device;
767 struct mlxsw_sp_bridge_port *bridge_port;
768 int err;
769
770 if (switchdev_trans_ph_prepare(trans))
771 return 0;
772
773 /* It's possible we failed to enslave the port, yet this
774 * operation is executed due to it being deferred.
775 */
776 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
777 if (!bridge_device)
778 return 0;
779
780 if (bridge_device->multicast_enabled != !mc_disabled) {
781 bridge_device->multicast_enabled = !mc_disabled;
782 mlxsw_sp_bridge_mdb_mc_enable_sync(mlxsw_sp_port,
783 bridge_device);
784 }
785
786 list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
787 enum mlxsw_sp_flood_type packet_type = MLXSW_SP_FLOOD_TYPE_MC;
788 bool member = mlxsw_sp_mc_flood(bridge_port);
789
790 err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port,
791 bridge_port,
792 packet_type, member);
793 if (err)
794 return err;
795 }
796
797 bridge_device->multicast_enabled = !mc_disabled;
798
799 return 0;
800 }
801
802 static int mlxsw_sp_smid_router_port_set(struct mlxsw_sp *mlxsw_sp,
803 u16 mid_idx, bool add)
804 {
805 char *smid_pl;
806 int err;
807
808 smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
809 if (!smid_pl)
810 return -ENOMEM;
811
812 mlxsw_reg_smid_pack(smid_pl, mid_idx,
813 mlxsw_sp_router_port(mlxsw_sp), add);
814 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
815 kfree(smid_pl);
816 return err;
817 }
818
819 static void
820 mlxsw_sp_bridge_mrouter_update_mdb(struct mlxsw_sp *mlxsw_sp,
821 struct mlxsw_sp_bridge_device *bridge_device,
822 bool add)
823 {
824 struct mlxsw_sp_mid *mid;
825
826 list_for_each_entry(mid, &bridge_device->mids_list, list)
827 mlxsw_sp_smid_router_port_set(mlxsw_sp, mid->mid, add);
828 }
829
830 static int
831 mlxsw_sp_port_attr_br_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port,
832 struct switchdev_trans *trans,
833 struct net_device *orig_dev,
834 bool is_mrouter)
835 {
836 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
837 struct mlxsw_sp_bridge_device *bridge_device;
838
839 if (switchdev_trans_ph_prepare(trans))
840 return 0;
841
842 /* It's possible we failed to enslave the port, yet this
843 * operation is executed due to it being deferred.
844 */
845 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
846 if (!bridge_device)
847 return 0;
848
849 if (bridge_device->mrouter != is_mrouter)
850 mlxsw_sp_bridge_mrouter_update_mdb(mlxsw_sp, bridge_device,
851 is_mrouter);
852 bridge_device->mrouter = is_mrouter;
853 return 0;
854 }
855
856 static int mlxsw_sp_port_attr_set(struct net_device *dev,
857 const struct switchdev_attr *attr,
858 struct switchdev_trans *trans)
859 {
860 struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
861 int err;
862
863 switch (attr->id) {
864 case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
865 err = mlxsw_sp_port_attr_stp_state_set(mlxsw_sp_port, trans,
866 attr->orig_dev,
867 attr->u.stp_state);
868 break;
869 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
870 err = mlxsw_sp_port_attr_br_flags_set(mlxsw_sp_port, trans,
871 attr->orig_dev,
872 attr->u.brport_flags);
873 break;
874 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
875 err = mlxsw_sp_port_attr_br_ageing_set(mlxsw_sp_port, trans,
876 attr->u.ageing_time);
877 break;
878 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
879 err = mlxsw_sp_port_attr_br_vlan_set(mlxsw_sp_port, trans,
880 attr->orig_dev,
881 attr->u.vlan_filtering);
882 break;
883 case SWITCHDEV_ATTR_ID_PORT_MROUTER:
884 err = mlxsw_sp_port_attr_mrouter_set(mlxsw_sp_port, trans,
885 attr->orig_dev,
886 attr->u.mrouter);
887 break;
888 case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
889 err = mlxsw_sp_port_mc_disabled_set(mlxsw_sp_port, trans,
890 attr->orig_dev,
891 attr->u.mc_disabled);
892 break;
893 case SWITCHDEV_ATTR_ID_BRIDGE_MROUTER:
894 err = mlxsw_sp_port_attr_br_mrouter_set(mlxsw_sp_port, trans,
895 attr->orig_dev,
896 attr->u.mrouter);
897 break;
898 default:
899 err = -EOPNOTSUPP;
900 break;
901 }
902
903 if (switchdev_trans_ph_commit(trans))
904 mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
905
906 return err;
907 }
908
909 static int
910 mlxsw_sp_port_vlan_fid_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
911 struct mlxsw_sp_bridge_port *bridge_port,
912 struct netlink_ext_ack *extack)
913 {
914 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
915 struct mlxsw_sp_bridge_device *bridge_device;
916 u8 local_port = mlxsw_sp_port->local_port;
917 u16 vid = mlxsw_sp_port_vlan->vid;
918 struct mlxsw_sp_fid *fid;
919 int err;
920
921 bridge_device = bridge_port->bridge_device;
922 fid = bridge_device->ops->fid_get(bridge_device, vid, extack);
923 if (IS_ERR(fid))
924 return PTR_ERR(fid);
925
926 err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port,
927 bridge_port->flags & BR_FLOOD);
928 if (err)
929 goto err_fid_uc_flood_set;
930
931 err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port,
932 mlxsw_sp_mc_flood(bridge_port));
933 if (err)
934 goto err_fid_mc_flood_set;
935
936 err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port,
937 true);
938 if (err)
939 goto err_fid_bc_flood_set;
940
941 err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid);
942 if (err)
943 goto err_fid_port_vid_map;
944
945 mlxsw_sp_port_vlan->fid = fid;
946
947 return 0;
948
949 err_fid_port_vid_map:
950 mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false);
951 err_fid_bc_flood_set:
952 mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false);
953 err_fid_mc_flood_set:
954 mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false);
955 err_fid_uc_flood_set:
956 mlxsw_sp_fid_put(fid);
957 return err;
958 }
959
960 static void
961 mlxsw_sp_port_vlan_fid_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
962 {
963 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
964 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
965 u8 local_port = mlxsw_sp_port->local_port;
966 u16 vid = mlxsw_sp_port_vlan->vid;
967
968 mlxsw_sp_port_vlan->fid = NULL;
969 mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
970 mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false);
971 mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false);
972 mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false);
973 mlxsw_sp_fid_put(fid);
974 }
975
976 static u16
977 mlxsw_sp_port_pvid_determine(const struct mlxsw_sp_port *mlxsw_sp_port,
978 u16 vid, bool is_pvid)
979 {
980 if (is_pvid)
981 return vid;
982 else if (mlxsw_sp_port->pvid == vid)
983 return 0; /* Dis-allow untagged packets */
984 else
985 return mlxsw_sp_port->pvid;
986 }
987
988 static int
989 mlxsw_sp_port_vlan_bridge_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
990 struct mlxsw_sp_bridge_port *bridge_port,
991 struct netlink_ext_ack *extack)
992 {
993 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
994 struct mlxsw_sp_bridge_vlan *bridge_vlan;
995 u16 vid = mlxsw_sp_port_vlan->vid;
996 int err;
997
998 /* No need to continue if only VLAN flags were changed */
999 if (mlxsw_sp_port_vlan->bridge_port)
1000 return 0;
1001
1002 err = mlxsw_sp_port_vlan_fid_join(mlxsw_sp_port_vlan, bridge_port,
1003 extack);
1004 if (err)
1005 return err;
1006
1007 err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid,
1008 bridge_port->flags & BR_LEARNING);
1009 if (err)
1010 goto err_port_vid_learning_set;
1011
1012 err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid,
1013 bridge_port->stp_state);
1014 if (err)
1015 goto err_port_vid_stp_set;
1016
1017 bridge_vlan = mlxsw_sp_bridge_vlan_get(bridge_port, vid);
1018 if (!bridge_vlan) {
1019 err = -ENOMEM;
1020 goto err_bridge_vlan_get;
1021 }
1022
1023 list_add(&mlxsw_sp_port_vlan->bridge_vlan_node,
1024 &bridge_vlan->port_vlan_list);
1025
1026 mlxsw_sp_bridge_port_get(mlxsw_sp_port->mlxsw_sp->bridge,
1027 bridge_port->dev);
1028 mlxsw_sp_port_vlan->bridge_port = bridge_port;
1029
1030 return 0;
1031
1032 err_bridge_vlan_get:
1033 mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED);
1034 err_port_vid_stp_set:
1035 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
1036 err_port_vid_learning_set:
1037 mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan);
1038 return err;
1039 }
1040
1041 void
1042 mlxsw_sp_port_vlan_bridge_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
1043 {
1044 struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1045 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
1046 struct mlxsw_sp_bridge_vlan *bridge_vlan;
1047 struct mlxsw_sp_bridge_port *bridge_port;
1048 u16 vid = mlxsw_sp_port_vlan->vid;
1049 bool last_port, last_vlan;
1050
1051 if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021Q &&
1052 mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021D))
1053 return;
1054
1055 bridge_port = mlxsw_sp_port_vlan->bridge_port;
1056 last_vlan = list_is_singular(&bridge_port->vlans_list);
1057 bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid);
1058 last_port = list_is_singular(&bridge_vlan->port_vlan_list);
1059
1060 list_del(&mlxsw_sp_port_vlan->bridge_vlan_node);
1061 mlxsw_sp_bridge_vlan_put(bridge_vlan);
1062 mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED);
1063 mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
1064 if (last_port)
1065 mlxsw_sp_bridge_port_fdb_flush(mlxsw_sp_port->mlxsw_sp,
1066 bridge_port,
1067 mlxsw_sp_fid_index(fid));
1068 if (last_vlan)
1069 mlxsw_sp_bridge_port_mdb_flush(mlxsw_sp_port, bridge_port);
1070
1071 mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan);
1072
1073 mlxsw_sp_bridge_port_put(mlxsw_sp_port->mlxsw_sp->bridge, bridge_port);
1074 mlxsw_sp_port_vlan->bridge_port = NULL;
1075 }
1076
1077 static int
1078 mlxsw_sp_bridge_port_vlan_add(struct mlxsw_sp_port *mlxsw_sp_port,
1079 struct mlxsw_sp_bridge_port *bridge_port,
1080 u16 vid, bool is_untagged, bool is_pvid,
1081 struct netlink_ext_ack *extack)
1082 {
1083 u16 pvid = mlxsw_sp_port_pvid_determine(mlxsw_sp_port, vid, is_pvid);
1084 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1085 u16 old_pvid = mlxsw_sp_port->pvid;
1086 int err;
1087
1088 /* The only valid scenario in which a port-vlan already exists, is if
1089 * the VLAN flags were changed and the port-vlan is associated with the
1090 * correct bridge port
1091 */
1092 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
1093 if (mlxsw_sp_port_vlan &&
1094 mlxsw_sp_port_vlan->bridge_port != bridge_port)
1095 return -EEXIST;
1096
1097 if (!mlxsw_sp_port_vlan) {
1098 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_create(mlxsw_sp_port,
1099 vid);
1100 if (IS_ERR(mlxsw_sp_port_vlan))
1101 return PTR_ERR(mlxsw_sp_port_vlan);
1102 }
1103
1104 err = mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, true,
1105 is_untagged);
1106 if (err)
1107 goto err_port_vlan_set;
1108
1109 err = mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid);
1110 if (err)
1111 goto err_port_pvid_set;
1112
1113 err = mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port,
1114 extack);
1115 if (err)
1116 goto err_port_vlan_bridge_join;
1117
1118 return 0;
1119
1120 err_port_vlan_bridge_join:
1121 mlxsw_sp_port_pvid_set(mlxsw_sp_port, old_pvid);
1122 err_port_pvid_set:
1123 mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false);
1124 err_port_vlan_set:
1125 mlxsw_sp_port_vlan_destroy(mlxsw_sp_port_vlan);
1126 return err;
1127 }
1128
1129 static int
1130 mlxsw_sp_br_ban_rif_pvid_change(struct mlxsw_sp *mlxsw_sp,
1131 const struct net_device *br_dev,
1132 const struct switchdev_obj_port_vlan *vlan)
1133 {
1134 struct mlxsw_sp_rif *rif;
1135 struct mlxsw_sp_fid *fid;
1136 u16 pvid;
1137 u16 vid;
1138
1139 rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, br_dev);
1140 if (!rif)
1141 return 0;
1142 fid = mlxsw_sp_rif_fid(rif);
1143 pvid = mlxsw_sp_fid_8021q_vid(fid);
1144
1145 for (vid = vlan->vid_begin; vid <= vlan->vid_end; ++vid) {
1146 if (vlan->flags & BRIDGE_VLAN_INFO_PVID) {
1147 if (vid != pvid) {
1148 netdev_err(br_dev, "Can't change PVID, it's used by router interface\n");
1149 return -EBUSY;
1150 }
1151 } else {
1152 if (vid == pvid) {
1153 netdev_err(br_dev, "Can't remove PVID, it's used by router interface\n");
1154 return -EBUSY;
1155 }
1156 }
1157 }
1158
1159 return 0;
1160 }
1161
1162 static int mlxsw_sp_port_vlans_add(struct mlxsw_sp_port *mlxsw_sp_port,
1163 const struct switchdev_obj_port_vlan *vlan,
1164 struct switchdev_trans *trans,
1165 struct netlink_ext_ack *extack)
1166 {
1167 bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
1168 bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
1169 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1170 struct net_device *orig_dev = vlan->obj.orig_dev;
1171 struct mlxsw_sp_bridge_port *bridge_port;
1172 u16 vid;
1173
1174 if (netif_is_bridge_master(orig_dev)) {
1175 int err = 0;
1176
1177 if ((vlan->flags & BRIDGE_VLAN_INFO_BRENTRY) &&
1178 br_vlan_enabled(orig_dev) &&
1179 switchdev_trans_ph_prepare(trans))
1180 err = mlxsw_sp_br_ban_rif_pvid_change(mlxsw_sp,
1181 orig_dev, vlan);
1182 if (!err)
1183 err = -EOPNOTSUPP;
1184 return err;
1185 }
1186
1187 if (switchdev_trans_ph_commit(trans))
1188 return 0;
1189
1190 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1191 if (WARN_ON(!bridge_port))
1192 return -EINVAL;
1193
1194 if (!bridge_port->bridge_device->vlan_enabled)
1195 return 0;
1196
1197 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
1198 int err;
1199
1200 err = mlxsw_sp_bridge_port_vlan_add(mlxsw_sp_port, bridge_port,
1201 vid, flag_untagged,
1202 flag_pvid, extack);
1203 if (err)
1204 return err;
1205 }
1206
1207 return 0;
1208 }
1209
1210 static enum mlxsw_reg_sfdf_flush_type mlxsw_sp_fdb_flush_type(bool lagged)
1211 {
1212 return lagged ? MLXSW_REG_SFDF_FLUSH_PER_LAG_AND_FID :
1213 MLXSW_REG_SFDF_FLUSH_PER_PORT_AND_FID;
1214 }
1215
1216 static int
1217 mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp,
1218 struct mlxsw_sp_bridge_port *bridge_port,
1219 u16 fid_index)
1220 {
1221 bool lagged = bridge_port->lagged;
1222 char sfdf_pl[MLXSW_REG_SFDF_LEN];
1223 u16 system_port;
1224
1225 system_port = lagged ? bridge_port->lag_id : bridge_port->system_port;
1226 mlxsw_reg_sfdf_pack(sfdf_pl, mlxsw_sp_fdb_flush_type(lagged));
1227 mlxsw_reg_sfdf_fid_set(sfdf_pl, fid_index);
1228 mlxsw_reg_sfdf_port_fid_system_port_set(sfdf_pl, system_port);
1229
1230 return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdf), sfdf_pl);
1231 }
1232
1233 static enum mlxsw_reg_sfd_rec_policy mlxsw_sp_sfd_rec_policy(bool dynamic)
1234 {
1235 return dynamic ? MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_INGRESS :
1236 MLXSW_REG_SFD_REC_POLICY_STATIC_ENTRY;
1237 }
1238
1239 static enum mlxsw_reg_sfd_op mlxsw_sp_sfd_op(bool adding)
1240 {
1241 return adding ? MLXSW_REG_SFD_OP_WRITE_EDIT :
1242 MLXSW_REG_SFD_OP_WRITE_REMOVE;
1243 }
1244
1245 static int mlxsw_sp_port_fdb_tunnel_uc_op(struct mlxsw_sp *mlxsw_sp,
1246 const char *mac, u16 fid,
1247 enum mlxsw_sp_l3proto proto,
1248 const union mlxsw_sp_l3addr *addr,
1249 bool adding, bool dynamic)
1250 {
1251 enum mlxsw_reg_sfd_uc_tunnel_protocol sfd_proto;
1252 char *sfd_pl;
1253 u8 num_rec;
1254 u32 uip;
1255 int err;
1256
1257 switch (proto) {
1258 case MLXSW_SP_L3_PROTO_IPV4:
1259 uip = be32_to_cpu(addr->addr4);
1260 sfd_proto = MLXSW_REG_SFD_UC_TUNNEL_PROTOCOL_IPV4;
1261 break;
1262 case MLXSW_SP_L3_PROTO_IPV6: /* fall through */
1263 default:
1264 WARN_ON(1);
1265 return -EOPNOTSUPP;
1266 }
1267
1268 sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1269 if (!sfd_pl)
1270 return -ENOMEM;
1271
1272 mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1273 mlxsw_reg_sfd_uc_tunnel_pack(sfd_pl, 0,
1274 mlxsw_sp_sfd_rec_policy(dynamic), mac, fid,
1275 MLXSW_REG_SFD_REC_ACTION_NOP, uip,
1276 sfd_proto);
1277 num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1278 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1279 if (err)
1280 goto out;
1281
1282 if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1283 err = -EBUSY;
1284
1285 out:
1286 kfree(sfd_pl);
1287 return err;
1288 }
1289
1290 static int __mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port,
1291 const char *mac, u16 fid, bool adding,
1292 enum mlxsw_reg_sfd_rec_action action,
1293 bool dynamic)
1294 {
1295 char *sfd_pl;
1296 u8 num_rec;
1297 int err;
1298
1299 sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1300 if (!sfd_pl)
1301 return -ENOMEM;
1302
1303 mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1304 mlxsw_reg_sfd_uc_pack(sfd_pl, 0, mlxsw_sp_sfd_rec_policy(dynamic),
1305 mac, fid, action, local_port);
1306 num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1307 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1308 if (err)
1309 goto out;
1310
1311 if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1312 err = -EBUSY;
1313
1314 out:
1315 kfree(sfd_pl);
1316 return err;
1317 }
1318
1319 static int mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port,
1320 const char *mac, u16 fid, bool adding,
1321 bool dynamic)
1322 {
1323 return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid, adding,
1324 MLXSW_REG_SFD_REC_ACTION_NOP, dynamic);
1325 }
1326
1327 int mlxsw_sp_rif_fdb_op(struct mlxsw_sp *mlxsw_sp, const char *mac, u16 fid,
1328 bool adding)
1329 {
1330 return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, 0, mac, fid, adding,
1331 MLXSW_REG_SFD_REC_ACTION_FORWARD_IP_ROUTER,
1332 false);
1333 }
1334
1335 static int mlxsw_sp_port_fdb_uc_lag_op(struct mlxsw_sp *mlxsw_sp, u16 lag_id,
1336 const char *mac, u16 fid, u16 lag_vid,
1337 bool adding, bool dynamic)
1338 {
1339 char *sfd_pl;
1340 u8 num_rec;
1341 int err;
1342
1343 sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1344 if (!sfd_pl)
1345 return -ENOMEM;
1346
1347 mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1348 mlxsw_reg_sfd_uc_lag_pack(sfd_pl, 0, mlxsw_sp_sfd_rec_policy(dynamic),
1349 mac, fid, MLXSW_REG_SFD_REC_ACTION_NOP,
1350 lag_vid, lag_id);
1351 num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1352 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1353 if (err)
1354 goto out;
1355
1356 if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1357 err = -EBUSY;
1358
1359 out:
1360 kfree(sfd_pl);
1361 return err;
1362 }
1363
1364 static int
1365 mlxsw_sp_port_fdb_set(struct mlxsw_sp_port *mlxsw_sp_port,
1366 struct switchdev_notifier_fdb_info *fdb_info, bool adding)
1367 {
1368 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1369 struct net_device *orig_dev = fdb_info->info.dev;
1370 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1371 struct mlxsw_sp_bridge_device *bridge_device;
1372 struct mlxsw_sp_bridge_port *bridge_port;
1373 u16 fid_index, vid;
1374
1375 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1376 if (!bridge_port)
1377 return -EINVAL;
1378
1379 bridge_device = bridge_port->bridge_device;
1380 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
1381 bridge_device,
1382 fdb_info->vid);
1383 if (!mlxsw_sp_port_vlan)
1384 return 0;
1385
1386 fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
1387 vid = mlxsw_sp_port_vlan->vid;
1388
1389 if (!bridge_port->lagged)
1390 return mlxsw_sp_port_fdb_uc_op(mlxsw_sp,
1391 bridge_port->system_port,
1392 fdb_info->addr, fid_index,
1393 adding, false);
1394 else
1395 return mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp,
1396 bridge_port->lag_id,
1397 fdb_info->addr, fid_index,
1398 vid, adding, false);
1399 }
1400
1401 static int mlxsw_sp_port_mdb_op(struct mlxsw_sp *mlxsw_sp, const char *addr,
1402 u16 fid, u16 mid_idx, bool adding)
1403 {
1404 char *sfd_pl;
1405 u8 num_rec;
1406 int err;
1407
1408 sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1409 if (!sfd_pl)
1410 return -ENOMEM;
1411
1412 mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1413 mlxsw_reg_sfd_mc_pack(sfd_pl, 0, addr, fid,
1414 MLXSW_REG_SFD_REC_ACTION_NOP, mid_idx);
1415 num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1416 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1417 if (err)
1418 goto out;
1419
1420 if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1421 err = -EBUSY;
1422
1423 out:
1424 kfree(sfd_pl);
1425 return err;
1426 }
1427
1428 static int mlxsw_sp_port_smid_full_entry(struct mlxsw_sp *mlxsw_sp, u16 mid_idx,
1429 long *ports_bitmap,
1430 bool set_router_port)
1431 {
1432 char *smid_pl;
1433 int err, i;
1434
1435 smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
1436 if (!smid_pl)
1437 return -ENOMEM;
1438
1439 mlxsw_reg_smid_pack(smid_pl, mid_idx, 0, false);
1440 for (i = 1; i < mlxsw_core_max_ports(mlxsw_sp->core); i++) {
1441 if (mlxsw_sp->ports[i])
1442 mlxsw_reg_smid_port_mask_set(smid_pl, i, 1);
1443 }
1444
1445 mlxsw_reg_smid_port_mask_set(smid_pl,
1446 mlxsw_sp_router_port(mlxsw_sp), 1);
1447
1448 for_each_set_bit(i, ports_bitmap, mlxsw_core_max_ports(mlxsw_sp->core))
1449 mlxsw_reg_smid_port_set(smid_pl, i, 1);
1450
1451 mlxsw_reg_smid_port_set(smid_pl, mlxsw_sp_router_port(mlxsw_sp),
1452 set_router_port);
1453
1454 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
1455 kfree(smid_pl);
1456 return err;
1457 }
1458
1459 static int mlxsw_sp_port_smid_set(struct mlxsw_sp_port *mlxsw_sp_port,
1460 u16 mid_idx, bool add)
1461 {
1462 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1463 char *smid_pl;
1464 int err;
1465
1466 smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
1467 if (!smid_pl)
1468 return -ENOMEM;
1469
1470 mlxsw_reg_smid_pack(smid_pl, mid_idx, mlxsw_sp_port->local_port, add);
1471 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
1472 kfree(smid_pl);
1473 return err;
1474 }
1475
1476 static struct
1477 mlxsw_sp_mid *__mlxsw_sp_mc_get(struct mlxsw_sp_bridge_device *bridge_device,
1478 const unsigned char *addr,
1479 u16 fid)
1480 {
1481 struct mlxsw_sp_mid *mid;
1482
1483 list_for_each_entry(mid, &bridge_device->mids_list, list) {
1484 if (ether_addr_equal(mid->addr, addr) && mid->fid == fid)
1485 return mid;
1486 }
1487 return NULL;
1488 }
1489
1490 static void
1491 mlxsw_sp_bridge_port_get_ports_bitmap(struct mlxsw_sp *mlxsw_sp,
1492 struct mlxsw_sp_bridge_port *bridge_port,
1493 unsigned long *ports_bitmap)
1494 {
1495 struct mlxsw_sp_port *mlxsw_sp_port;
1496 u64 max_lag_members, i;
1497 int lag_id;
1498
1499 if (!bridge_port->lagged) {
1500 set_bit(bridge_port->system_port, ports_bitmap);
1501 } else {
1502 max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core,
1503 MAX_LAG_MEMBERS);
1504 lag_id = bridge_port->lag_id;
1505 for (i = 0; i < max_lag_members; i++) {
1506 mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp,
1507 lag_id, i);
1508 if (mlxsw_sp_port)
1509 set_bit(mlxsw_sp_port->local_port,
1510 ports_bitmap);
1511 }
1512 }
1513 }
1514
1515 static void
1516 mlxsw_sp_mc_get_mrouters_bitmap(unsigned long *flood_bitmap,
1517 struct mlxsw_sp_bridge_device *bridge_device,
1518 struct mlxsw_sp *mlxsw_sp)
1519 {
1520 struct mlxsw_sp_bridge_port *bridge_port;
1521
1522 list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
1523 if (bridge_port->mrouter) {
1524 mlxsw_sp_bridge_port_get_ports_bitmap(mlxsw_sp,
1525 bridge_port,
1526 flood_bitmap);
1527 }
1528 }
1529 }
1530
1531 static bool
1532 mlxsw_sp_mc_write_mdb_entry(struct mlxsw_sp *mlxsw_sp,
1533 struct mlxsw_sp_mid *mid,
1534 struct mlxsw_sp_bridge_device *bridge_device)
1535 {
1536 long *flood_bitmap;
1537 int num_of_ports;
1538 int alloc_size;
1539 u16 mid_idx;
1540 int err;
1541
1542 mid_idx = find_first_zero_bit(mlxsw_sp->bridge->mids_bitmap,
1543 MLXSW_SP_MID_MAX);
1544 if (mid_idx == MLXSW_SP_MID_MAX)
1545 return false;
1546
1547 num_of_ports = mlxsw_core_max_ports(mlxsw_sp->core);
1548 alloc_size = sizeof(long) * BITS_TO_LONGS(num_of_ports);
1549 flood_bitmap = kzalloc(alloc_size, GFP_KERNEL);
1550 if (!flood_bitmap)
1551 return false;
1552
1553 bitmap_copy(flood_bitmap, mid->ports_in_mid, num_of_ports);
1554 mlxsw_sp_mc_get_mrouters_bitmap(flood_bitmap, bridge_device, mlxsw_sp);
1555
1556 mid->mid = mid_idx;
1557 err = mlxsw_sp_port_smid_full_entry(mlxsw_sp, mid_idx, flood_bitmap,
1558 bridge_device->mrouter);
1559 kfree(flood_bitmap);
1560 if (err)
1561 return false;
1562
1563 err = mlxsw_sp_port_mdb_op(mlxsw_sp, mid->addr, mid->fid, mid_idx,
1564 true);
1565 if (err)
1566 return false;
1567
1568 set_bit(mid_idx, mlxsw_sp->bridge->mids_bitmap);
1569 mid->in_hw = true;
1570 return true;
1571 }
1572
1573 static int mlxsw_sp_mc_remove_mdb_entry(struct mlxsw_sp *mlxsw_sp,
1574 struct mlxsw_sp_mid *mid)
1575 {
1576 if (!mid->in_hw)
1577 return 0;
1578
1579 clear_bit(mid->mid, mlxsw_sp->bridge->mids_bitmap);
1580 mid->in_hw = false;
1581 return mlxsw_sp_port_mdb_op(mlxsw_sp, mid->addr, mid->fid, mid->mid,
1582 false);
1583 }
1584
1585 static struct
1586 mlxsw_sp_mid *__mlxsw_sp_mc_alloc(struct mlxsw_sp *mlxsw_sp,
1587 struct mlxsw_sp_bridge_device *bridge_device,
1588 const unsigned char *addr,
1589 u16 fid)
1590 {
1591 struct mlxsw_sp_mid *mid;
1592 size_t alloc_size;
1593
1594 mid = kzalloc(sizeof(*mid), GFP_KERNEL);
1595 if (!mid)
1596 return NULL;
1597
1598 alloc_size = sizeof(unsigned long) *
1599 BITS_TO_LONGS(mlxsw_core_max_ports(mlxsw_sp->core));
1600
1601 mid->ports_in_mid = kzalloc(alloc_size, GFP_KERNEL);
1602 if (!mid->ports_in_mid)
1603 goto err_ports_in_mid_alloc;
1604
1605 ether_addr_copy(mid->addr, addr);
1606 mid->fid = fid;
1607 mid->in_hw = false;
1608
1609 if (!bridge_device->multicast_enabled)
1610 goto out;
1611
1612 if (!mlxsw_sp_mc_write_mdb_entry(mlxsw_sp, mid, bridge_device))
1613 goto err_write_mdb_entry;
1614
1615 out:
1616 list_add_tail(&mid->list, &bridge_device->mids_list);
1617 return mid;
1618
1619 err_write_mdb_entry:
1620 kfree(mid->ports_in_mid);
1621 err_ports_in_mid_alloc:
1622 kfree(mid);
1623 return NULL;
1624 }
1625
1626 static int mlxsw_sp_port_remove_from_mid(struct mlxsw_sp_port *mlxsw_sp_port,
1627 struct mlxsw_sp_mid *mid)
1628 {
1629 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1630 int err = 0;
1631
1632 clear_bit(mlxsw_sp_port->local_port, mid->ports_in_mid);
1633 if (bitmap_empty(mid->ports_in_mid,
1634 mlxsw_core_max_ports(mlxsw_sp->core))) {
1635 err = mlxsw_sp_mc_remove_mdb_entry(mlxsw_sp, mid);
1636 list_del(&mid->list);
1637 kfree(mid->ports_in_mid);
1638 kfree(mid);
1639 }
1640 return err;
1641 }
1642
1643 static int mlxsw_sp_port_mdb_add(struct mlxsw_sp_port *mlxsw_sp_port,
1644 const struct switchdev_obj_port_mdb *mdb,
1645 struct switchdev_trans *trans)
1646 {
1647 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1648 struct net_device *orig_dev = mdb->obj.orig_dev;
1649 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1650 struct net_device *dev = mlxsw_sp_port->dev;
1651 struct mlxsw_sp_bridge_device *bridge_device;
1652 struct mlxsw_sp_bridge_port *bridge_port;
1653 struct mlxsw_sp_mid *mid;
1654 u16 fid_index;
1655 int err = 0;
1656
1657 if (switchdev_trans_ph_prepare(trans))
1658 return 0;
1659
1660 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1661 if (!bridge_port)
1662 return 0;
1663
1664 bridge_device = bridge_port->bridge_device;
1665 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
1666 bridge_device,
1667 mdb->vid);
1668 if (!mlxsw_sp_port_vlan)
1669 return 0;
1670
1671 fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
1672
1673 mid = __mlxsw_sp_mc_get(bridge_device, mdb->addr, fid_index);
1674 if (!mid) {
1675 mid = __mlxsw_sp_mc_alloc(mlxsw_sp, bridge_device, mdb->addr,
1676 fid_index);
1677 if (!mid) {
1678 netdev_err(dev, "Unable to allocate MC group\n");
1679 return -ENOMEM;
1680 }
1681 }
1682 set_bit(mlxsw_sp_port->local_port, mid->ports_in_mid);
1683
1684 if (!bridge_device->multicast_enabled)
1685 return 0;
1686
1687 if (bridge_port->mrouter)
1688 return 0;
1689
1690 err = mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, true);
1691 if (err) {
1692 netdev_err(dev, "Unable to set SMID\n");
1693 goto err_out;
1694 }
1695
1696 return 0;
1697
1698 err_out:
1699 mlxsw_sp_port_remove_from_mid(mlxsw_sp_port, mid);
1700 return err;
1701 }
1702
1703 static void
1704 mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp_port *mlxsw_sp_port,
1705 struct mlxsw_sp_bridge_device
1706 *bridge_device)
1707 {
1708 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1709 struct mlxsw_sp_mid *mid;
1710 bool mc_enabled;
1711
1712 mc_enabled = bridge_device->multicast_enabled;
1713
1714 list_for_each_entry(mid, &bridge_device->mids_list, list) {
1715 if (mc_enabled)
1716 mlxsw_sp_mc_write_mdb_entry(mlxsw_sp, mid,
1717 bridge_device);
1718 else
1719 mlxsw_sp_mc_remove_mdb_entry(mlxsw_sp, mid);
1720 }
1721 }
1722
1723 static void
1724 mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port,
1725 struct mlxsw_sp_bridge_port *bridge_port,
1726 bool add)
1727 {
1728 struct mlxsw_sp_bridge_device *bridge_device;
1729 struct mlxsw_sp_mid *mid;
1730
1731 bridge_device = bridge_port->bridge_device;
1732
1733 list_for_each_entry(mid, &bridge_device->mids_list, list) {
1734 if (!test_bit(mlxsw_sp_port->local_port, mid->ports_in_mid))
1735 mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, add);
1736 }
1737 }
1738
1739 struct mlxsw_sp_span_respin_work {
1740 struct work_struct work;
1741 struct mlxsw_sp *mlxsw_sp;
1742 };
1743
1744 static void mlxsw_sp_span_respin_work(struct work_struct *work)
1745 {
1746 struct mlxsw_sp_span_respin_work *respin_work =
1747 container_of(work, struct mlxsw_sp_span_respin_work, work);
1748
1749 rtnl_lock();
1750 mlxsw_sp_span_respin(respin_work->mlxsw_sp);
1751 rtnl_unlock();
1752 kfree(respin_work);
1753 }
1754
1755 static void mlxsw_sp_span_respin_schedule(struct mlxsw_sp *mlxsw_sp)
1756 {
1757 struct mlxsw_sp_span_respin_work *respin_work;
1758
1759 respin_work = kzalloc(sizeof(*respin_work), GFP_ATOMIC);
1760 if (!respin_work)
1761 return;
1762
1763 INIT_WORK(&respin_work->work, mlxsw_sp_span_respin_work);
1764 respin_work->mlxsw_sp = mlxsw_sp;
1765
1766 mlxsw_core_schedule_work(&respin_work->work);
1767 }
1768
1769 static int mlxsw_sp_port_obj_add(struct net_device *dev,
1770 const struct switchdev_obj *obj,
1771 struct switchdev_trans *trans,
1772 struct netlink_ext_ack *extack)
1773 {
1774 struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
1775 const struct switchdev_obj_port_vlan *vlan;
1776 int err = 0;
1777
1778 switch (obj->id) {
1779 case SWITCHDEV_OBJ_ID_PORT_VLAN:
1780 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
1781 err = mlxsw_sp_port_vlans_add(mlxsw_sp_port, vlan, trans,
1782 extack);
1783
1784 if (switchdev_trans_ph_prepare(trans)) {
1785 /* The event is emitted before the changes are actually
1786 * applied to the bridge. Therefore schedule the respin
1787 * call for later, so that the respin logic sees the
1788 * updated bridge state.
1789 */
1790 mlxsw_sp_span_respin_schedule(mlxsw_sp_port->mlxsw_sp);
1791 }
1792 break;
1793 case SWITCHDEV_OBJ_ID_PORT_MDB:
1794 err = mlxsw_sp_port_mdb_add(mlxsw_sp_port,
1795 SWITCHDEV_OBJ_PORT_MDB(obj),
1796 trans);
1797 break;
1798 default:
1799 err = -EOPNOTSUPP;
1800 break;
1801 }
1802
1803 return err;
1804 }
1805
1806 static void
1807 mlxsw_sp_bridge_port_vlan_del(struct mlxsw_sp_port *mlxsw_sp_port,
1808 struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
1809 {
1810 u16 pvid = mlxsw_sp_port->pvid == vid ? 0 : mlxsw_sp_port->pvid;
1811 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1812
1813 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
1814 if (WARN_ON(!mlxsw_sp_port_vlan))
1815 return;
1816
1817 mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan);
1818 mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid);
1819 mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false);
1820 mlxsw_sp_port_vlan_destroy(mlxsw_sp_port_vlan);
1821 }
1822
1823 static int mlxsw_sp_port_vlans_del(struct mlxsw_sp_port *mlxsw_sp_port,
1824 const struct switchdev_obj_port_vlan *vlan)
1825 {
1826 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1827 struct net_device *orig_dev = vlan->obj.orig_dev;
1828 struct mlxsw_sp_bridge_port *bridge_port;
1829 u16 vid;
1830
1831 if (netif_is_bridge_master(orig_dev))
1832 return -EOPNOTSUPP;
1833
1834 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1835 if (WARN_ON(!bridge_port))
1836 return -EINVAL;
1837
1838 if (!bridge_port->bridge_device->vlan_enabled)
1839 return 0;
1840
1841 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++)
1842 mlxsw_sp_bridge_port_vlan_del(mlxsw_sp_port, bridge_port, vid);
1843
1844 return 0;
1845 }
1846
1847 static int
1848 __mlxsw_sp_port_mdb_del(struct mlxsw_sp_port *mlxsw_sp_port,
1849 struct mlxsw_sp_bridge_port *bridge_port,
1850 struct mlxsw_sp_mid *mid)
1851 {
1852 struct net_device *dev = mlxsw_sp_port->dev;
1853 int err;
1854
1855 if (bridge_port->bridge_device->multicast_enabled &&
1856 !bridge_port->mrouter) {
1857 err = mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, false);
1858 if (err)
1859 netdev_err(dev, "Unable to remove port from SMID\n");
1860 }
1861
1862 err = mlxsw_sp_port_remove_from_mid(mlxsw_sp_port, mid);
1863 if (err)
1864 netdev_err(dev, "Unable to remove MC SFD\n");
1865
1866 return err;
1867 }
1868
1869 static int mlxsw_sp_port_mdb_del(struct mlxsw_sp_port *mlxsw_sp_port,
1870 const struct switchdev_obj_port_mdb *mdb)
1871 {
1872 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1873 struct net_device *orig_dev = mdb->obj.orig_dev;
1874 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1875 struct mlxsw_sp_bridge_device *bridge_device;
1876 struct net_device *dev = mlxsw_sp_port->dev;
1877 struct mlxsw_sp_bridge_port *bridge_port;
1878 struct mlxsw_sp_mid *mid;
1879 u16 fid_index;
1880
1881 bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1882 if (!bridge_port)
1883 return 0;
1884
1885 bridge_device = bridge_port->bridge_device;
1886 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
1887 bridge_device,
1888 mdb->vid);
1889 if (!mlxsw_sp_port_vlan)
1890 return 0;
1891
1892 fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
1893
1894 mid = __mlxsw_sp_mc_get(bridge_device, mdb->addr, fid_index);
1895 if (!mid) {
1896 netdev_err(dev, "Unable to remove port from MC DB\n");
1897 return -EINVAL;
1898 }
1899
1900 return __mlxsw_sp_port_mdb_del(mlxsw_sp_port, bridge_port, mid);
1901 }
1902
1903 static void
1904 mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port,
1905 struct mlxsw_sp_bridge_port *bridge_port)
1906 {
1907 struct mlxsw_sp_bridge_device *bridge_device;
1908 struct mlxsw_sp_mid *mid, *tmp;
1909
1910 bridge_device = bridge_port->bridge_device;
1911
1912 list_for_each_entry_safe(mid, tmp, &bridge_device->mids_list, list) {
1913 if (test_bit(mlxsw_sp_port->local_port, mid->ports_in_mid)) {
1914 __mlxsw_sp_port_mdb_del(mlxsw_sp_port, bridge_port,
1915 mid);
1916 } else if (bridge_device->multicast_enabled &&
1917 bridge_port->mrouter) {
1918 mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, false);
1919 }
1920 }
1921 }
1922
1923 static int mlxsw_sp_port_obj_del(struct net_device *dev,
1924 const struct switchdev_obj *obj)
1925 {
1926 struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
1927 int err = 0;
1928
1929 switch (obj->id) {
1930 case SWITCHDEV_OBJ_ID_PORT_VLAN:
1931 err = mlxsw_sp_port_vlans_del(mlxsw_sp_port,
1932 SWITCHDEV_OBJ_PORT_VLAN(obj));
1933 break;
1934 case SWITCHDEV_OBJ_ID_PORT_MDB:
1935 err = mlxsw_sp_port_mdb_del(mlxsw_sp_port,
1936 SWITCHDEV_OBJ_PORT_MDB(obj));
1937 break;
1938 default:
1939 err = -EOPNOTSUPP;
1940 break;
1941 }
1942
1943 mlxsw_sp_span_respin_schedule(mlxsw_sp_port->mlxsw_sp);
1944
1945 return err;
1946 }
1947
1948 static struct mlxsw_sp_port *mlxsw_sp_lag_rep_port(struct mlxsw_sp *mlxsw_sp,
1949 u16 lag_id)
1950 {
1951 struct mlxsw_sp_port *mlxsw_sp_port;
1952 u64 max_lag_members;
1953 int i;
1954
1955 max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core,
1956 MAX_LAG_MEMBERS);
1957 for (i = 0; i < max_lag_members; i++) {
1958 mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp, lag_id, i);
1959 if (mlxsw_sp_port)
1960 return mlxsw_sp_port;
1961 }
1962 return NULL;
1963 }
1964
1965 static const struct switchdev_ops mlxsw_sp_port_switchdev_ops = {
1966 .switchdev_port_attr_get = mlxsw_sp_port_attr_get,
1967 .switchdev_port_attr_set = mlxsw_sp_port_attr_set,
1968 };
1969
1970 static int
1971 mlxsw_sp_bridge_8021q_port_join(struct mlxsw_sp_bridge_device *bridge_device,
1972 struct mlxsw_sp_bridge_port *bridge_port,
1973 struct mlxsw_sp_port *mlxsw_sp_port,
1974 struct netlink_ext_ack *extack)
1975 {
1976 if (is_vlan_dev(bridge_port->dev)) {
1977 NL_SET_ERR_MSG_MOD(extack, "Can not enslave a VLAN device to a VLAN-aware bridge");
1978 return -EINVAL;
1979 }
1980
1981 /* Port is no longer usable as a router interface */
1982 if (mlxsw_sp_port->default_vlan->fid)
1983 mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port->default_vlan);
1984
1985 return 0;
1986 }
1987
1988 static void
1989 mlxsw_sp_bridge_8021q_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
1990 struct mlxsw_sp_bridge_port *bridge_port,
1991 struct mlxsw_sp_port *mlxsw_sp_port)
1992 {
1993 /* Make sure untagged frames are allowed to ingress */
1994 mlxsw_sp_port_pvid_set(mlxsw_sp_port, MLXSW_SP_DEFAULT_VID);
1995 }
1996
1997 static int
1998 mlxsw_sp_bridge_8021q_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
1999 const struct net_device *vxlan_dev, u16 vid,
2000 struct netlink_ext_ack *extack)
2001 {
2002 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2003 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
2004 struct mlxsw_sp_nve_params params = {
2005 .type = MLXSW_SP_NVE_TYPE_VXLAN,
2006 .vni = vxlan->cfg.vni,
2007 .dev = vxlan_dev,
2008 };
2009 struct mlxsw_sp_fid *fid;
2010 int err;
2011
2012 /* If the VLAN is 0, we need to find the VLAN that is configured as
2013 * PVID and egress untagged on the bridge port of the VxLAN device.
2014 * It is possible no such VLAN exists
2015 */
2016 if (!vid) {
2017 err = mlxsw_sp_vxlan_mapped_vid(vxlan_dev, &vid);
2018 if (err || !vid)
2019 return err;
2020 }
2021
2022 /* If no other port is member in the VLAN, then the FID does not exist.
2023 * NVE will be enabled on the FID once a port joins the VLAN
2024 */
2025 fid = mlxsw_sp_fid_8021q_lookup(mlxsw_sp, vid);
2026 if (!fid)
2027 return 0;
2028
2029 if (mlxsw_sp_fid_vni_is_set(fid)) {
2030 err = -EINVAL;
2031 goto err_vni_exists;
2032 }
2033
2034 err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, &params, extack);
2035 if (err)
2036 goto err_nve_fid_enable;
2037
2038 /* The tunnel port does not hold a reference on the FID. Only
2039 * local ports and the router port
2040 */
2041 mlxsw_sp_fid_put(fid);
2042
2043 return 0;
2044
2045 err_nve_fid_enable:
2046 err_vni_exists:
2047 mlxsw_sp_fid_put(fid);
2048 return err;
2049 }
2050
2051 static struct net_device *
2052 mlxsw_sp_bridge_8021q_vxlan_dev_find(struct net_device *br_dev, u16 vid)
2053 {
2054 struct net_device *dev;
2055 struct list_head *iter;
2056
2057 netdev_for_each_lower_dev(br_dev, dev, iter) {
2058 u16 pvid;
2059 int err;
2060
2061 if (!netif_is_vxlan(dev))
2062 continue;
2063
2064 err = mlxsw_sp_vxlan_mapped_vid(dev, &pvid);
2065 if (err || pvid != vid)
2066 continue;
2067
2068 return dev;
2069 }
2070
2071 return NULL;
2072 }
2073
2074 static struct mlxsw_sp_fid *
2075 mlxsw_sp_bridge_8021q_fid_get(struct mlxsw_sp_bridge_device *bridge_device,
2076 u16 vid, struct netlink_ext_ack *extack)
2077 {
2078 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2079 struct net_device *vxlan_dev;
2080 struct mlxsw_sp_fid *fid;
2081 int err;
2082
2083 fid = mlxsw_sp_fid_8021q_get(mlxsw_sp, vid);
2084 if (IS_ERR(fid))
2085 return fid;
2086
2087 if (mlxsw_sp_fid_vni_is_set(fid))
2088 return fid;
2089
2090 /* Find the VxLAN device that has the specified VLAN configured as
2091 * PVID and egress untagged. There can be at most one such device
2092 */
2093 vxlan_dev = mlxsw_sp_bridge_8021q_vxlan_dev_find(bridge_device->dev,
2094 vid);
2095 if (!vxlan_dev)
2096 return fid;
2097
2098 if (!netif_running(vxlan_dev))
2099 return fid;
2100
2101 err = mlxsw_sp_bridge_8021q_vxlan_join(bridge_device, vxlan_dev, vid,
2102 extack);
2103 if (err)
2104 goto err_vxlan_join;
2105
2106 return fid;
2107
2108 err_vxlan_join:
2109 mlxsw_sp_fid_put(fid);
2110 return ERR_PTR(err);
2111 }
2112
2113 static struct mlxsw_sp_fid *
2114 mlxsw_sp_bridge_8021q_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device,
2115 u16 vid)
2116 {
2117 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2118
2119 return mlxsw_sp_fid_8021q_lookup(mlxsw_sp, vid);
2120 }
2121
2122 static u16
2123 mlxsw_sp_bridge_8021q_fid_vid(struct mlxsw_sp_bridge_device *bridge_device,
2124 const struct mlxsw_sp_fid *fid)
2125 {
2126 return mlxsw_sp_fid_8021q_vid(fid);
2127 }
2128
2129 static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021q_ops = {
2130 .port_join = mlxsw_sp_bridge_8021q_port_join,
2131 .port_leave = mlxsw_sp_bridge_8021q_port_leave,
2132 .vxlan_join = mlxsw_sp_bridge_8021q_vxlan_join,
2133 .fid_get = mlxsw_sp_bridge_8021q_fid_get,
2134 .fid_lookup = mlxsw_sp_bridge_8021q_fid_lookup,
2135 .fid_vid = mlxsw_sp_bridge_8021q_fid_vid,
2136 };
2137
2138 static bool
2139 mlxsw_sp_port_is_br_member(const struct mlxsw_sp_port *mlxsw_sp_port,
2140 const struct net_device *br_dev)
2141 {
2142 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2143
2144 list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
2145 list) {
2146 if (mlxsw_sp_port_vlan->bridge_port &&
2147 mlxsw_sp_port_vlan->bridge_port->bridge_device->dev ==
2148 br_dev)
2149 return true;
2150 }
2151
2152 return false;
2153 }
2154
2155 static int
2156 mlxsw_sp_bridge_8021d_port_join(struct mlxsw_sp_bridge_device *bridge_device,
2157 struct mlxsw_sp_bridge_port *bridge_port,
2158 struct mlxsw_sp_port *mlxsw_sp_port,
2159 struct netlink_ext_ack *extack)
2160 {
2161 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2162 struct net_device *dev = bridge_port->dev;
2163 u16 vid;
2164
2165 vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID;
2166 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
2167 if (WARN_ON(!mlxsw_sp_port_vlan))
2168 return -EINVAL;
2169
2170 if (mlxsw_sp_port_is_br_member(mlxsw_sp_port, bridge_device->dev)) {
2171 NL_SET_ERR_MSG_MOD(extack, "Can not bridge VLAN uppers of the same port");
2172 return -EINVAL;
2173 }
2174
2175 /* Port is no longer usable as a router interface */
2176 if (mlxsw_sp_port_vlan->fid)
2177 mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
2178
2179 return mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port,
2180 extack);
2181 }
2182
2183 static void
2184 mlxsw_sp_bridge_8021d_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
2185 struct mlxsw_sp_bridge_port *bridge_port,
2186 struct mlxsw_sp_port *mlxsw_sp_port)
2187 {
2188 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2189 struct net_device *dev = bridge_port->dev;
2190 u16 vid;
2191
2192 vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID;
2193 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
2194 if (!mlxsw_sp_port_vlan || !mlxsw_sp_port_vlan->bridge_port)
2195 return;
2196
2197 mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan);
2198 }
2199
2200 static int
2201 mlxsw_sp_bridge_8021d_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
2202 const struct net_device *vxlan_dev, u16 vid,
2203 struct netlink_ext_ack *extack)
2204 {
2205 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2206 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
2207 struct mlxsw_sp_nve_params params = {
2208 .type = MLXSW_SP_NVE_TYPE_VXLAN,
2209 .vni = vxlan->cfg.vni,
2210 .dev = vxlan_dev,
2211 };
2212 struct mlxsw_sp_fid *fid;
2213 int err;
2214
2215 fid = mlxsw_sp_fid_8021d_lookup(mlxsw_sp, bridge_device->dev->ifindex);
2216 if (!fid)
2217 return -EINVAL;
2218
2219 if (mlxsw_sp_fid_vni_is_set(fid)) {
2220 err = -EINVAL;
2221 goto err_vni_exists;
2222 }
2223
2224 err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, &params, extack);
2225 if (err)
2226 goto err_nve_fid_enable;
2227
2228 /* The tunnel port does not hold a reference on the FID. Only
2229 * local ports and the router port
2230 */
2231 mlxsw_sp_fid_put(fid);
2232
2233 return 0;
2234
2235 err_nve_fid_enable:
2236 err_vni_exists:
2237 mlxsw_sp_fid_put(fid);
2238 return err;
2239 }
2240
2241 static struct mlxsw_sp_fid *
2242 mlxsw_sp_bridge_8021d_fid_get(struct mlxsw_sp_bridge_device *bridge_device,
2243 u16 vid, struct netlink_ext_ack *extack)
2244 {
2245 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2246 struct net_device *vxlan_dev;
2247 struct mlxsw_sp_fid *fid;
2248 int err;
2249
2250 fid = mlxsw_sp_fid_8021d_get(mlxsw_sp, bridge_device->dev->ifindex);
2251 if (IS_ERR(fid))
2252 return fid;
2253
2254 if (mlxsw_sp_fid_vni_is_set(fid))
2255 return fid;
2256
2257 vxlan_dev = mlxsw_sp_bridge_vxlan_dev_find(bridge_device->dev);
2258 if (!vxlan_dev)
2259 return fid;
2260
2261 if (!netif_running(vxlan_dev))
2262 return fid;
2263
2264 err = mlxsw_sp_bridge_8021d_vxlan_join(bridge_device, vxlan_dev, 0,
2265 extack);
2266 if (err)
2267 goto err_vxlan_join;
2268
2269 return fid;
2270
2271 err_vxlan_join:
2272 mlxsw_sp_fid_put(fid);
2273 return ERR_PTR(err);
2274 }
2275
2276 static struct mlxsw_sp_fid *
2277 mlxsw_sp_bridge_8021d_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device,
2278 u16 vid)
2279 {
2280 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2281
2282 /* The only valid VLAN for a VLAN-unaware bridge is 0 */
2283 if (vid)
2284 return NULL;
2285
2286 return mlxsw_sp_fid_8021d_lookup(mlxsw_sp, bridge_device->dev->ifindex);
2287 }
2288
2289 static u16
2290 mlxsw_sp_bridge_8021d_fid_vid(struct mlxsw_sp_bridge_device *bridge_device,
2291 const struct mlxsw_sp_fid *fid)
2292 {
2293 return 0;
2294 }
2295
2296 static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021d_ops = {
2297 .port_join = mlxsw_sp_bridge_8021d_port_join,
2298 .port_leave = mlxsw_sp_bridge_8021d_port_leave,
2299 .vxlan_join = mlxsw_sp_bridge_8021d_vxlan_join,
2300 .fid_get = mlxsw_sp_bridge_8021d_fid_get,
2301 .fid_lookup = mlxsw_sp_bridge_8021d_fid_lookup,
2302 .fid_vid = mlxsw_sp_bridge_8021d_fid_vid,
2303 };
2304
2305 int mlxsw_sp_port_bridge_join(struct mlxsw_sp_port *mlxsw_sp_port,
2306 struct net_device *brport_dev,
2307 struct net_device *br_dev,
2308 struct netlink_ext_ack *extack)
2309 {
2310 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2311 struct mlxsw_sp_bridge_device *bridge_device;
2312 struct mlxsw_sp_bridge_port *bridge_port;
2313 int err;
2314
2315 bridge_port = mlxsw_sp_bridge_port_get(mlxsw_sp->bridge, brport_dev);
2316 if (IS_ERR(bridge_port))
2317 return PTR_ERR(bridge_port);
2318 bridge_device = bridge_port->bridge_device;
2319
2320 err = bridge_device->ops->port_join(bridge_device, bridge_port,
2321 mlxsw_sp_port, extack);
2322 if (err)
2323 goto err_port_join;
2324
2325 return 0;
2326
2327 err_port_join:
2328 mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port);
2329 return err;
2330 }
2331
2332 void mlxsw_sp_port_bridge_leave(struct mlxsw_sp_port *mlxsw_sp_port,
2333 struct net_device *brport_dev,
2334 struct net_device *br_dev)
2335 {
2336 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2337 struct mlxsw_sp_bridge_device *bridge_device;
2338 struct mlxsw_sp_bridge_port *bridge_port;
2339
2340 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2341 if (!bridge_device)
2342 return;
2343 bridge_port = __mlxsw_sp_bridge_port_find(bridge_device, brport_dev);
2344 if (!bridge_port)
2345 return;
2346
2347 bridge_device->ops->port_leave(bridge_device, bridge_port,
2348 mlxsw_sp_port);
2349 mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port);
2350 }
2351
2352 int mlxsw_sp_bridge_vxlan_join(struct mlxsw_sp *mlxsw_sp,
2353 const struct net_device *br_dev,
2354 const struct net_device *vxlan_dev, u16 vid,
2355 struct netlink_ext_ack *extack)
2356 {
2357 struct mlxsw_sp_bridge_device *bridge_device;
2358
2359 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2360 if (WARN_ON(!bridge_device))
2361 return -EINVAL;
2362
2363 return bridge_device->ops->vxlan_join(bridge_device, vxlan_dev, vid,
2364 extack);
2365 }
2366
2367 void mlxsw_sp_bridge_vxlan_leave(struct mlxsw_sp *mlxsw_sp,
2368 const struct net_device *vxlan_dev)
2369 {
2370 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
2371 struct mlxsw_sp_fid *fid;
2372
2373 /* If the VxLAN device is down, then the FID does not have a VNI */
2374 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan->cfg.vni);
2375 if (!fid)
2376 return;
2377
2378 mlxsw_sp_nve_fid_disable(mlxsw_sp, fid);
2379 mlxsw_sp_fid_put(fid);
2380 }
2381
2382 struct mlxsw_sp_fid *mlxsw_sp_bridge_fid_get(struct mlxsw_sp *mlxsw_sp,
2383 const struct net_device *br_dev,
2384 u16 vid,
2385 struct netlink_ext_ack *extack)
2386 {
2387 struct mlxsw_sp_bridge_device *bridge_device;
2388
2389 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2390 if (WARN_ON(!bridge_device))
2391 return ERR_PTR(-EINVAL);
2392
2393 return bridge_device->ops->fid_get(bridge_device, vid, extack);
2394 }
2395
2396 static void
2397 mlxsw_sp_switchdev_vxlan_addr_convert(const union vxlan_addr *vxlan_addr,
2398 enum mlxsw_sp_l3proto *proto,
2399 union mlxsw_sp_l3addr *addr)
2400 {
2401 if (vxlan_addr->sa.sa_family == AF_INET) {
2402 addr->addr4 = vxlan_addr->sin.sin_addr.s_addr;
2403 *proto = MLXSW_SP_L3_PROTO_IPV4;
2404 } else {
2405 addr->addr6 = vxlan_addr->sin6.sin6_addr;
2406 *proto = MLXSW_SP_L3_PROTO_IPV6;
2407 }
2408 }
2409
2410 static void
2411 mlxsw_sp_switchdev_addr_vxlan_convert(enum mlxsw_sp_l3proto proto,
2412 const union mlxsw_sp_l3addr *addr,
2413 union vxlan_addr *vxlan_addr)
2414 {
2415 switch (proto) {
2416 case MLXSW_SP_L3_PROTO_IPV4:
2417 vxlan_addr->sa.sa_family = AF_INET;
2418 vxlan_addr->sin.sin_addr.s_addr = addr->addr4;
2419 break;
2420 case MLXSW_SP_L3_PROTO_IPV6:
2421 vxlan_addr->sa.sa_family = AF_INET6;
2422 vxlan_addr->sin6.sin6_addr = addr->addr6;
2423 break;
2424 }
2425 }
2426
2427 static void mlxsw_sp_fdb_vxlan_call_notifiers(struct net_device *dev,
2428 const char *mac,
2429 enum mlxsw_sp_l3proto proto,
2430 union mlxsw_sp_l3addr *addr,
2431 __be32 vni, bool adding)
2432 {
2433 struct switchdev_notifier_vxlan_fdb_info info;
2434 struct vxlan_dev *vxlan = netdev_priv(dev);
2435 enum switchdev_notifier_type type;
2436
2437 type = adding ? SWITCHDEV_VXLAN_FDB_ADD_TO_BRIDGE :
2438 SWITCHDEV_VXLAN_FDB_DEL_TO_BRIDGE;
2439 mlxsw_sp_switchdev_addr_vxlan_convert(proto, addr, &info.remote_ip);
2440 info.remote_port = vxlan->cfg.dst_port;
2441 info.remote_vni = vni;
2442 info.remote_ifindex = 0;
2443 ether_addr_copy(info.eth_addr, mac);
2444 info.vni = vni;
2445 info.offloaded = adding;
2446 call_switchdev_notifiers(type, dev, &info.info, NULL);
2447 }
2448
2449 static void mlxsw_sp_fdb_nve_call_notifiers(struct net_device *dev,
2450 const char *mac,
2451 enum mlxsw_sp_l3proto proto,
2452 union mlxsw_sp_l3addr *addr,
2453 __be32 vni,
2454 bool adding)
2455 {
2456 if (netif_is_vxlan(dev))
2457 mlxsw_sp_fdb_vxlan_call_notifiers(dev, mac, proto, addr, vni,
2458 adding);
2459 }
2460
2461 static void
2462 mlxsw_sp_fdb_call_notifiers(enum switchdev_notifier_type type,
2463 const char *mac, u16 vid,
2464 struct net_device *dev, bool offloaded)
2465 {
2466 struct switchdev_notifier_fdb_info info;
2467
2468 info.addr = mac;
2469 info.vid = vid;
2470 info.offloaded = offloaded;
2471 call_switchdev_notifiers(type, dev, &info.info, NULL);
2472 }
2473
2474 static void mlxsw_sp_fdb_notify_mac_process(struct mlxsw_sp *mlxsw_sp,
2475 char *sfn_pl, int rec_index,
2476 bool adding)
2477 {
2478 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2479 struct mlxsw_sp_bridge_device *bridge_device;
2480 struct mlxsw_sp_bridge_port *bridge_port;
2481 struct mlxsw_sp_port *mlxsw_sp_port;
2482 enum switchdev_notifier_type type;
2483 char mac[ETH_ALEN];
2484 u8 local_port;
2485 u16 vid, fid;
2486 bool do_notification = true;
2487 int err;
2488
2489 mlxsw_reg_sfn_mac_unpack(sfn_pl, rec_index, mac, &fid, &local_port);
2490 mlxsw_sp_port = mlxsw_sp->ports[local_port];
2491 if (!mlxsw_sp_port) {
2492 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect local port in FDB notification\n");
2493 goto just_remove;
2494 }
2495
2496 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid);
2497 if (!mlxsw_sp_port_vlan) {
2498 netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n");
2499 goto just_remove;
2500 }
2501
2502 bridge_port = mlxsw_sp_port_vlan->bridge_port;
2503 if (!bridge_port) {
2504 netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n");
2505 goto just_remove;
2506 }
2507
2508 bridge_device = bridge_port->bridge_device;
2509 vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0;
2510
2511 do_fdb_op:
2512 err = mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid,
2513 adding, true);
2514 if (err) {
2515 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n");
2516 return;
2517 }
2518
2519 if (!do_notification)
2520 return;
2521 type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE;
2522 mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding);
2523
2524 return;
2525
2526 just_remove:
2527 adding = false;
2528 do_notification = false;
2529 goto do_fdb_op;
2530 }
2531
2532 static void mlxsw_sp_fdb_notify_mac_lag_process(struct mlxsw_sp *mlxsw_sp,
2533 char *sfn_pl, int rec_index,
2534 bool adding)
2535 {
2536 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2537 struct mlxsw_sp_bridge_device *bridge_device;
2538 struct mlxsw_sp_bridge_port *bridge_port;
2539 struct mlxsw_sp_port *mlxsw_sp_port;
2540 enum switchdev_notifier_type type;
2541 char mac[ETH_ALEN];
2542 u16 lag_vid = 0;
2543 u16 lag_id;
2544 u16 vid, fid;
2545 bool do_notification = true;
2546 int err;
2547
2548 mlxsw_reg_sfn_mac_lag_unpack(sfn_pl, rec_index, mac, &fid, &lag_id);
2549 mlxsw_sp_port = mlxsw_sp_lag_rep_port(mlxsw_sp, lag_id);
2550 if (!mlxsw_sp_port) {
2551 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Cannot find port representor for LAG\n");
2552 goto just_remove;
2553 }
2554
2555 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid);
2556 if (!mlxsw_sp_port_vlan) {
2557 netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n");
2558 goto just_remove;
2559 }
2560
2561 bridge_port = mlxsw_sp_port_vlan->bridge_port;
2562 if (!bridge_port) {
2563 netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n");
2564 goto just_remove;
2565 }
2566
2567 bridge_device = bridge_port->bridge_device;
2568 vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0;
2569 lag_vid = mlxsw_sp_fid_lag_vid_valid(mlxsw_sp_port_vlan->fid) ?
2570 mlxsw_sp_port_vlan->vid : 0;
2571
2572 do_fdb_op:
2573 err = mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp, lag_id, mac, fid, lag_vid,
2574 adding, true);
2575 if (err) {
2576 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n");
2577 return;
2578 }
2579
2580 if (!do_notification)
2581 return;
2582 type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE;
2583 mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding);
2584
2585 return;
2586
2587 just_remove:
2588 adding = false;
2589 do_notification = false;
2590 goto do_fdb_op;
2591 }
2592
2593 static int
2594 __mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp,
2595 const struct mlxsw_sp_fid *fid,
2596 bool adding,
2597 struct net_device **nve_dev,
2598 u16 *p_vid, __be32 *p_vni)
2599 {
2600 struct mlxsw_sp_bridge_device *bridge_device;
2601 struct net_device *br_dev, *dev;
2602 int nve_ifindex;
2603 int err;
2604
2605 err = mlxsw_sp_fid_nve_ifindex(fid, &nve_ifindex);
2606 if (err)
2607 return err;
2608
2609 err = mlxsw_sp_fid_vni(fid, p_vni);
2610 if (err)
2611 return err;
2612
2613 dev = __dev_get_by_index(&init_net, nve_ifindex);
2614 if (!dev)
2615 return -EINVAL;
2616 *nve_dev = dev;
2617
2618 if (!netif_running(dev))
2619 return -EINVAL;
2620
2621 if (adding && !br_port_flag_is_set(dev, BR_LEARNING))
2622 return -EINVAL;
2623
2624 if (adding && netif_is_vxlan(dev)) {
2625 struct vxlan_dev *vxlan = netdev_priv(dev);
2626
2627 if (!(vxlan->cfg.flags & VXLAN_F_LEARN))
2628 return -EINVAL;
2629 }
2630
2631 br_dev = netdev_master_upper_dev_get(dev);
2632 if (!br_dev)
2633 return -EINVAL;
2634
2635 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2636 if (!bridge_device)
2637 return -EINVAL;
2638
2639 *p_vid = bridge_device->ops->fid_vid(bridge_device, fid);
2640
2641 return 0;
2642 }
2643
2644 static void mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp,
2645 char *sfn_pl,
2646 int rec_index,
2647 bool adding)
2648 {
2649 enum mlxsw_reg_sfn_uc_tunnel_protocol sfn_proto;
2650 enum switchdev_notifier_type type;
2651 struct net_device *nve_dev;
2652 union mlxsw_sp_l3addr addr;
2653 struct mlxsw_sp_fid *fid;
2654 char mac[ETH_ALEN];
2655 u16 fid_index, vid;
2656 __be32 vni;
2657 u32 uip;
2658 int err;
2659
2660 mlxsw_reg_sfn_uc_tunnel_unpack(sfn_pl, rec_index, mac, &fid_index,
2661 &uip, &sfn_proto);
2662
2663 fid = mlxsw_sp_fid_lookup_by_index(mlxsw_sp, fid_index);
2664 if (!fid)
2665 goto err_fid_lookup;
2666
2667 err = mlxsw_sp_nve_learned_ip_resolve(mlxsw_sp, uip,
2668 (enum mlxsw_sp_l3proto) sfn_proto,
2669 &addr);
2670 if (err)
2671 goto err_ip_resolve;
2672
2673 err = __mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, fid, adding,
2674 &nve_dev, &vid, &vni);
2675 if (err)
2676 goto err_fdb_process;
2677
2678 err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index,
2679 (enum mlxsw_sp_l3proto) sfn_proto,
2680 &addr, adding, true);
2681 if (err)
2682 goto err_fdb_op;
2683
2684 mlxsw_sp_fdb_nve_call_notifiers(nve_dev, mac,
2685 (enum mlxsw_sp_l3proto) sfn_proto,
2686 &addr, vni, adding);
2687
2688 type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE :
2689 SWITCHDEV_FDB_DEL_TO_BRIDGE;
2690 mlxsw_sp_fdb_call_notifiers(type, mac, vid, nve_dev, adding);
2691
2692 mlxsw_sp_fid_put(fid);
2693
2694 return;
2695
2696 err_fdb_op:
2697 err_fdb_process:
2698 err_ip_resolve:
2699 mlxsw_sp_fid_put(fid);
2700 err_fid_lookup:
2701 /* Remove an FDB entry in case we cannot process it. Otherwise the
2702 * device will keep sending the same notification over and over again.
2703 */
2704 mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index,
2705 (enum mlxsw_sp_l3proto) sfn_proto, &addr,
2706 false, true);
2707 }
2708
2709 static void mlxsw_sp_fdb_notify_rec_process(struct mlxsw_sp *mlxsw_sp,
2710 char *sfn_pl, int rec_index)
2711 {
2712 switch (mlxsw_reg_sfn_rec_type_get(sfn_pl, rec_index)) {
2713 case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC:
2714 mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
2715 rec_index, true);
2716 break;
2717 case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC:
2718 mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
2719 rec_index, false);
2720 break;
2721 case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC_LAG:
2722 mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl,
2723 rec_index, true);
2724 break;
2725 case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC_LAG:
2726 mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl,
2727 rec_index, false);
2728 break;
2729 case MLXSW_REG_SFN_REC_TYPE_LEARNED_UNICAST_TUNNEL:
2730 mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl,
2731 rec_index, true);
2732 break;
2733 case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_UNICAST_TUNNEL:
2734 mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl,
2735 rec_index, false);
2736 break;
2737 }
2738 }
2739
2740 static void mlxsw_sp_fdb_notify_work_schedule(struct mlxsw_sp *mlxsw_sp)
2741 {
2742 struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge;
2743
2744 mlxsw_core_schedule_dw(&bridge->fdb_notify.dw,
2745 msecs_to_jiffies(bridge->fdb_notify.interval));
2746 }
2747
2748 static void mlxsw_sp_fdb_notify_work(struct work_struct *work)
2749 {
2750 struct mlxsw_sp_bridge *bridge;
2751 struct mlxsw_sp *mlxsw_sp;
2752 char *sfn_pl;
2753 u8 num_rec;
2754 int i;
2755 int err;
2756
2757 sfn_pl = kmalloc(MLXSW_REG_SFN_LEN, GFP_KERNEL);
2758 if (!sfn_pl)
2759 return;
2760
2761 bridge = container_of(work, struct mlxsw_sp_bridge, fdb_notify.dw.work);
2762 mlxsw_sp = bridge->mlxsw_sp;
2763
2764 rtnl_lock();
2765 mlxsw_reg_sfn_pack(sfn_pl);
2766 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(sfn), sfn_pl);
2767 if (err) {
2768 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to get FDB notifications\n");
2769 goto out;
2770 }
2771 num_rec = mlxsw_reg_sfn_num_rec_get(sfn_pl);
2772 for (i = 0; i < num_rec; i++)
2773 mlxsw_sp_fdb_notify_rec_process(mlxsw_sp, sfn_pl, i);
2774
2775 out:
2776 rtnl_unlock();
2777 kfree(sfn_pl);
2778 mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp);
2779 }
2780
2781 struct mlxsw_sp_switchdev_event_work {
2782 struct work_struct work;
2783 union {
2784 struct switchdev_notifier_fdb_info fdb_info;
2785 struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info;
2786 };
2787 struct net_device *dev;
2788 unsigned long event;
2789 };
2790
2791 static void
2792 mlxsw_sp_switchdev_bridge_vxlan_fdb_event(struct mlxsw_sp *mlxsw_sp,
2793 struct mlxsw_sp_switchdev_event_work *
2794 switchdev_work,
2795 struct mlxsw_sp_fid *fid, __be32 vni)
2796 {
2797 struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info;
2798 struct switchdev_notifier_fdb_info *fdb_info;
2799 struct net_device *dev = switchdev_work->dev;
2800 enum mlxsw_sp_l3proto proto;
2801 union mlxsw_sp_l3addr addr;
2802 int err;
2803
2804 fdb_info = &switchdev_work->fdb_info;
2805 err = vxlan_fdb_find_uc(dev, fdb_info->addr, vni, &vxlan_fdb_info);
2806 if (err)
2807 return;
2808
2809 mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info.remote_ip,
2810 &proto, &addr);
2811
2812 switch (switchdev_work->event) {
2813 case SWITCHDEV_FDB_ADD_TO_DEVICE:
2814 err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp,
2815 vxlan_fdb_info.eth_addr,
2816 mlxsw_sp_fid_index(fid),
2817 proto, &addr, true, false);
2818 if (err)
2819 return;
2820 vxlan_fdb_info.offloaded = true;
2821 call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
2822 &vxlan_fdb_info.info, NULL);
2823 mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
2824 vxlan_fdb_info.eth_addr,
2825 fdb_info->vid, dev, true);
2826 break;
2827 case SWITCHDEV_FDB_DEL_TO_DEVICE:
2828 err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp,
2829 vxlan_fdb_info.eth_addr,
2830 mlxsw_sp_fid_index(fid),
2831 proto, &addr, false,
2832 false);
2833 vxlan_fdb_info.offloaded = false;
2834 call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
2835 &vxlan_fdb_info.info, NULL);
2836 break;
2837 }
2838 }
2839
2840 static void
2841 mlxsw_sp_switchdev_bridge_nve_fdb_event(struct mlxsw_sp_switchdev_event_work *
2842 switchdev_work)
2843 {
2844 struct mlxsw_sp_bridge_device *bridge_device;
2845 struct net_device *dev = switchdev_work->dev;
2846 struct net_device *br_dev;
2847 struct mlxsw_sp *mlxsw_sp;
2848 struct mlxsw_sp_fid *fid;
2849 __be32 vni;
2850 int err;
2851
2852 if (switchdev_work->event != SWITCHDEV_FDB_ADD_TO_DEVICE &&
2853 switchdev_work->event != SWITCHDEV_FDB_DEL_TO_DEVICE)
2854 return;
2855
2856 if (switchdev_work->event == SWITCHDEV_FDB_ADD_TO_DEVICE &&
2857 !switchdev_work->fdb_info.added_by_user)
2858 return;
2859
2860 if (!netif_running(dev))
2861 return;
2862 br_dev = netdev_master_upper_dev_get(dev);
2863 if (!br_dev)
2864 return;
2865 if (!netif_is_bridge_master(br_dev))
2866 return;
2867 mlxsw_sp = mlxsw_sp_lower_get(br_dev);
2868 if (!mlxsw_sp)
2869 return;
2870 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2871 if (!bridge_device)
2872 return;
2873
2874 fid = bridge_device->ops->fid_lookup(bridge_device,
2875 switchdev_work->fdb_info.vid);
2876 if (!fid)
2877 return;
2878
2879 err = mlxsw_sp_fid_vni(fid, &vni);
2880 if (err)
2881 goto out;
2882
2883 mlxsw_sp_switchdev_bridge_vxlan_fdb_event(mlxsw_sp, switchdev_work, fid,
2884 vni);
2885
2886 out:
2887 mlxsw_sp_fid_put(fid);
2888 }
2889
2890 static void mlxsw_sp_switchdev_bridge_fdb_event_work(struct work_struct *work)
2891 {
2892 struct mlxsw_sp_switchdev_event_work *switchdev_work =
2893 container_of(work, struct mlxsw_sp_switchdev_event_work, work);
2894 struct net_device *dev = switchdev_work->dev;
2895 struct switchdev_notifier_fdb_info *fdb_info;
2896 struct mlxsw_sp_port *mlxsw_sp_port;
2897 int err;
2898
2899 rtnl_lock();
2900 if (netif_is_vxlan(dev)) {
2901 mlxsw_sp_switchdev_bridge_nve_fdb_event(switchdev_work);
2902 goto out;
2903 }
2904
2905 mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(dev);
2906 if (!mlxsw_sp_port)
2907 goto out;
2908
2909 switch (switchdev_work->event) {
2910 case SWITCHDEV_FDB_ADD_TO_DEVICE:
2911 fdb_info = &switchdev_work->fdb_info;
2912 if (!fdb_info->added_by_user)
2913 break;
2914 err = mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, true);
2915 if (err)
2916 break;
2917 mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
2918 fdb_info->addr,
2919 fdb_info->vid, dev, true);
2920 break;
2921 case SWITCHDEV_FDB_DEL_TO_DEVICE:
2922 fdb_info = &switchdev_work->fdb_info;
2923 mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, false);
2924 break;
2925 case SWITCHDEV_FDB_ADD_TO_BRIDGE: /* fall through */
2926 case SWITCHDEV_FDB_DEL_TO_BRIDGE:
2927 /* These events are only used to potentially update an existing
2928 * SPAN mirror.
2929 */
2930 break;
2931 }
2932
2933 mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
2934
2935 out:
2936 rtnl_unlock();
2937 kfree(switchdev_work->fdb_info.addr);
2938 kfree(switchdev_work);
2939 dev_put(dev);
2940 }
2941
2942 static void
2943 mlxsw_sp_switchdev_vxlan_fdb_add(struct mlxsw_sp *mlxsw_sp,
2944 struct mlxsw_sp_switchdev_event_work *
2945 switchdev_work)
2946 {
2947 struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info;
2948 struct mlxsw_sp_bridge_device *bridge_device;
2949 struct net_device *dev = switchdev_work->dev;
2950 u8 all_zeros_mac[ETH_ALEN] = { 0 };
2951 enum mlxsw_sp_l3proto proto;
2952 union mlxsw_sp_l3addr addr;
2953 struct net_device *br_dev;
2954 struct mlxsw_sp_fid *fid;
2955 u16 vid;
2956 int err;
2957
2958 vxlan_fdb_info = &switchdev_work->vxlan_fdb_info;
2959 br_dev = netdev_master_upper_dev_get(dev);
2960
2961 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2962 if (!bridge_device)
2963 return;
2964
2965 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan_fdb_info->vni);
2966 if (!fid)
2967 return;
2968
2969 mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info->remote_ip,
2970 &proto, &addr);
2971
2972 if (ether_addr_equal(vxlan_fdb_info->eth_addr, all_zeros_mac)) {
2973 err = mlxsw_sp_nve_flood_ip_add(mlxsw_sp, fid, proto, &addr);
2974 if (err) {
2975 mlxsw_sp_fid_put(fid);
2976 return;
2977 }
2978 vxlan_fdb_info->offloaded = true;
2979 call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
2980 &vxlan_fdb_info->info, NULL);
2981 mlxsw_sp_fid_put(fid);
2982 return;
2983 }
2984
2985 /* The device has a single FDB table, whereas Linux has two - one
2986 * in the bridge driver and another in the VxLAN driver. We only
2987 * program an entry to the device if the MAC points to the VxLAN
2988 * device in the bridge's FDB table
2989 */
2990 vid = bridge_device->ops->fid_vid(bridge_device, fid);
2991 if (br_fdb_find_port(br_dev, vxlan_fdb_info->eth_addr, vid) != dev)
2992 goto err_br_fdb_find;
2993
2994 err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, vxlan_fdb_info->eth_addr,
2995 mlxsw_sp_fid_index(fid), proto,
2996 &addr, true, false);
2997 if (err)
2998 goto err_fdb_tunnel_uc_op;
2999 vxlan_fdb_info->offloaded = true;
3000 call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
3001 &vxlan_fdb_info->info, NULL);
3002 mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
3003 vxlan_fdb_info->eth_addr, vid, dev, true);
3004
3005 mlxsw_sp_fid_put(fid);
3006
3007 return;
3008
3009 err_fdb_tunnel_uc_op:
3010 err_br_fdb_find:
3011 mlxsw_sp_fid_put(fid);
3012 }
3013
3014 static void
3015 mlxsw_sp_switchdev_vxlan_fdb_del(struct mlxsw_sp *mlxsw_sp,
3016 struct mlxsw_sp_switchdev_event_work *
3017 switchdev_work)
3018 {
3019 struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info;
3020 struct mlxsw_sp_bridge_device *bridge_device;
3021 struct net_device *dev = switchdev_work->dev;
3022 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
3023 u8 all_zeros_mac[ETH_ALEN] = { 0 };
3024 enum mlxsw_sp_l3proto proto;
3025 union mlxsw_sp_l3addr addr;
3026 struct mlxsw_sp_fid *fid;
3027 u16 vid;
3028
3029 vxlan_fdb_info = &switchdev_work->vxlan_fdb_info;
3030
3031 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3032 if (!bridge_device)
3033 return;
3034
3035 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan_fdb_info->vni);
3036 if (!fid)
3037 return;
3038
3039 mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info->remote_ip,
3040 &proto, &addr);
3041
3042 if (ether_addr_equal(vxlan_fdb_info->eth_addr, all_zeros_mac)) {
3043 mlxsw_sp_nve_flood_ip_del(mlxsw_sp, fid, proto, &addr);
3044 mlxsw_sp_fid_put(fid);
3045 return;
3046 }
3047
3048 mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, vxlan_fdb_info->eth_addr,
3049 mlxsw_sp_fid_index(fid), proto, &addr,
3050 false, false);
3051 vid = bridge_device->ops->fid_vid(bridge_device, fid);
3052 mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
3053 vxlan_fdb_info->eth_addr, vid, dev, false);
3054
3055 mlxsw_sp_fid_put(fid);
3056 }
3057
3058 static void mlxsw_sp_switchdev_vxlan_fdb_event_work(struct work_struct *work)
3059 {
3060 struct mlxsw_sp_switchdev_event_work *switchdev_work =
3061 container_of(work, struct mlxsw_sp_switchdev_event_work, work);
3062 struct net_device *dev = switchdev_work->dev;
3063 struct mlxsw_sp *mlxsw_sp;
3064 struct net_device *br_dev;
3065
3066 rtnl_lock();
3067
3068 if (!netif_running(dev))
3069 goto out;
3070 br_dev = netdev_master_upper_dev_get(dev);
3071 if (!br_dev)
3072 goto out;
3073 if (!netif_is_bridge_master(br_dev))
3074 goto out;
3075 mlxsw_sp = mlxsw_sp_lower_get(br_dev);
3076 if (!mlxsw_sp)
3077 goto out;
3078
3079 switch (switchdev_work->event) {
3080 case SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE:
3081 mlxsw_sp_switchdev_vxlan_fdb_add(mlxsw_sp, switchdev_work);
3082 break;
3083 case SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE:
3084 mlxsw_sp_switchdev_vxlan_fdb_del(mlxsw_sp, switchdev_work);
3085 break;
3086 }
3087
3088 out:
3089 rtnl_unlock();
3090 kfree(switchdev_work);
3091 dev_put(dev);
3092 }
3093
3094 static int
3095 mlxsw_sp_switchdev_vxlan_work_prepare(struct mlxsw_sp_switchdev_event_work *
3096 switchdev_work,
3097 struct switchdev_notifier_info *info)
3098 {
3099 struct vxlan_dev *vxlan = netdev_priv(switchdev_work->dev);
3100 struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info;
3101 struct vxlan_config *cfg = &vxlan->cfg;
3102
3103 vxlan_fdb_info = container_of(info,
3104 struct switchdev_notifier_vxlan_fdb_info,
3105 info);
3106
3107 if (vxlan_fdb_info->remote_port != cfg->dst_port)
3108 return -EOPNOTSUPP;
3109 if (vxlan_fdb_info->remote_vni != cfg->vni)
3110 return -EOPNOTSUPP;
3111 if (vxlan_fdb_info->vni != cfg->vni)
3112 return -EOPNOTSUPP;
3113 if (vxlan_fdb_info->remote_ifindex)
3114 return -EOPNOTSUPP;
3115 if (is_multicast_ether_addr(vxlan_fdb_info->eth_addr))
3116 return -EOPNOTSUPP;
3117 if (vxlan_addr_multicast(&vxlan_fdb_info->remote_ip))
3118 return -EOPNOTSUPP;
3119
3120 switchdev_work->vxlan_fdb_info = *vxlan_fdb_info;
3121
3122 return 0;
3123 }
3124
3125 /* Called under rcu_read_lock() */
3126 static int mlxsw_sp_switchdev_event(struct notifier_block *unused,
3127 unsigned long event, void *ptr)
3128 {
3129 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
3130 struct mlxsw_sp_switchdev_event_work *switchdev_work;
3131 struct switchdev_notifier_fdb_info *fdb_info;
3132 struct switchdev_notifier_info *info = ptr;
3133 struct net_device *br_dev;
3134 int err;
3135
3136 /* Tunnel devices are not our uppers, so check their master instead */
3137 br_dev = netdev_master_upper_dev_get_rcu(dev);
3138 if (!br_dev)
3139 return NOTIFY_DONE;
3140 if (!netif_is_bridge_master(br_dev))
3141 return NOTIFY_DONE;
3142 if (!mlxsw_sp_port_dev_lower_find_rcu(br_dev))
3143 return NOTIFY_DONE;
3144
3145 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
3146 if (!switchdev_work)
3147 return NOTIFY_BAD;
3148
3149 switchdev_work->dev = dev;
3150 switchdev_work->event = event;
3151
3152 switch (event) {
3153 case SWITCHDEV_FDB_ADD_TO_DEVICE: /* fall through */
3154 case SWITCHDEV_FDB_DEL_TO_DEVICE: /* fall through */
3155 case SWITCHDEV_FDB_ADD_TO_BRIDGE: /* fall through */
3156 case SWITCHDEV_FDB_DEL_TO_BRIDGE:
3157 fdb_info = container_of(info,
3158 struct switchdev_notifier_fdb_info,
3159 info);
3160 INIT_WORK(&switchdev_work->work,
3161 mlxsw_sp_switchdev_bridge_fdb_event_work);
3162 memcpy(&switchdev_work->fdb_info, ptr,
3163 sizeof(switchdev_work->fdb_info));
3164 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
3165 if (!switchdev_work->fdb_info.addr)
3166 goto err_addr_alloc;
3167 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
3168 fdb_info->addr);
3169 /* Take a reference on the device. This can be either
3170 * upper device containig mlxsw_sp_port or just a
3171 * mlxsw_sp_port
3172 */
3173 dev_hold(dev);
3174 break;
3175 case SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE: /* fall through */
3176 case SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE:
3177 INIT_WORK(&switchdev_work->work,
3178 mlxsw_sp_switchdev_vxlan_fdb_event_work);
3179 err = mlxsw_sp_switchdev_vxlan_work_prepare(switchdev_work,
3180 info);
3181 if (err)
3182 goto err_vxlan_work_prepare;
3183 dev_hold(dev);
3184 break;
3185 default:
3186 kfree(switchdev_work);
3187 return NOTIFY_DONE;
3188 }
3189
3190 mlxsw_core_schedule_work(&switchdev_work->work);
3191
3192 return NOTIFY_DONE;
3193
3194 err_vxlan_work_prepare:
3195 err_addr_alloc:
3196 kfree(switchdev_work);
3197 return NOTIFY_BAD;
3198 }
3199
3200 struct notifier_block mlxsw_sp_switchdev_notifier = {
3201 .notifier_call = mlxsw_sp_switchdev_event,
3202 };
3203
3204 static int
3205 mlxsw_sp_switchdev_vxlan_vlan_add(struct mlxsw_sp *mlxsw_sp,
3206 struct mlxsw_sp_bridge_device *bridge_device,
3207 const struct net_device *vxlan_dev, u16 vid,
3208 bool flag_untagged, bool flag_pvid,
3209 struct netlink_ext_ack *extack)
3210 {
3211 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
3212 __be32 vni = vxlan->cfg.vni;
3213 struct mlxsw_sp_fid *fid;
3214 u16 old_vid;
3215 int err;
3216
3217 /* We cannot have the same VLAN as PVID and egress untagged on multiple
3218 * VxLAN devices. Note that we get this notification before the VLAN is
3219 * actually added to the bridge's database, so it is not possible for
3220 * the lookup function to return 'vxlan_dev'
3221 */
3222 if (flag_untagged && flag_pvid &&
3223 mlxsw_sp_bridge_8021q_vxlan_dev_find(bridge_device->dev, vid))
3224 return -EINVAL;
3225
3226 if (!netif_running(vxlan_dev))
3227 return 0;
3228
3229 /* First case: FID is not associated with this VNI, but the new VLAN
3230 * is both PVID and egress untagged. Need to enable NVE on the FID, if
3231 * it exists
3232 */
3233 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni);
3234 if (!fid) {
3235 if (!flag_untagged || !flag_pvid)
3236 return 0;
3237 return mlxsw_sp_bridge_8021q_vxlan_join(bridge_device,
3238 vxlan_dev, vid, extack);
3239 }
3240
3241 /* Second case: FID is associated with the VNI and the VLAN associated
3242 * with the FID is the same as the notified VLAN. This means the flags
3243 * (PVID / egress untagged) were toggled and that NVE should be
3244 * disabled on the FID
3245 */
3246 old_vid = mlxsw_sp_fid_8021q_vid(fid);
3247 if (vid == old_vid) {
3248 if (WARN_ON(flag_untagged && flag_pvid)) {
3249 mlxsw_sp_fid_put(fid);
3250 return -EINVAL;
3251 }
3252 mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev);
3253 mlxsw_sp_fid_put(fid);
3254 return 0;
3255 }
3256
3257 /* Third case: A new VLAN was configured on the VxLAN device, but this
3258 * VLAN is not PVID, so there is nothing to do.
3259 */
3260 if (!flag_pvid) {
3261 mlxsw_sp_fid_put(fid);
3262 return 0;
3263 }
3264
3265 /* Fourth case: Thew new VLAN is PVID, which means the VLAN currently
3266 * mapped to the VNI should be unmapped
3267 */
3268 mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev);
3269 mlxsw_sp_fid_put(fid);
3270
3271 /* Fifth case: The new VLAN is also egress untagged, which means the
3272 * VLAN needs to be mapped to the VNI
3273 */
3274 if (!flag_untagged)
3275 return 0;
3276
3277 err = mlxsw_sp_bridge_8021q_vxlan_join(bridge_device, vxlan_dev, vid,
3278 extack);
3279 if (err)
3280 goto err_vxlan_join;
3281
3282 return 0;
3283
3284 err_vxlan_join:
3285 mlxsw_sp_bridge_8021q_vxlan_join(bridge_device, vxlan_dev, old_vid,
3286 NULL);
3287 return err;
3288 }
3289
3290 static void
3291 mlxsw_sp_switchdev_vxlan_vlan_del(struct mlxsw_sp *mlxsw_sp,
3292 struct mlxsw_sp_bridge_device *bridge_device,
3293 const struct net_device *vxlan_dev, u16 vid)
3294 {
3295 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
3296 __be32 vni = vxlan->cfg.vni;
3297 struct mlxsw_sp_fid *fid;
3298
3299 if (!netif_running(vxlan_dev))
3300 return;
3301
3302 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni);
3303 if (!fid)
3304 return;
3305
3306 /* A different VLAN than the one mapped to the VNI is deleted */
3307 if (mlxsw_sp_fid_8021q_vid(fid) != vid)
3308 goto out;
3309
3310 mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev);
3311
3312 out:
3313 mlxsw_sp_fid_put(fid);
3314 }
3315
3316 static int
3317 mlxsw_sp_switchdev_vxlan_vlans_add(struct net_device *vxlan_dev,
3318 struct switchdev_notifier_port_obj_info *
3319 port_obj_info)
3320 {
3321 struct switchdev_obj_port_vlan *vlan =
3322 SWITCHDEV_OBJ_PORT_VLAN(port_obj_info->obj);
3323 bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
3324 bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
3325 struct switchdev_trans *trans = port_obj_info->trans;
3326 struct mlxsw_sp_bridge_device *bridge_device;
3327 struct netlink_ext_ack *extack;
3328 struct mlxsw_sp *mlxsw_sp;
3329 struct net_device *br_dev;
3330 u16 vid;
3331
3332 extack = switchdev_notifier_info_to_extack(&port_obj_info->info);
3333 br_dev = netdev_master_upper_dev_get(vxlan_dev);
3334 if (!br_dev)
3335 return 0;
3336
3337 mlxsw_sp = mlxsw_sp_lower_get(br_dev);
3338 if (!mlxsw_sp)
3339 return 0;
3340
3341 port_obj_info->handled = true;
3342
3343 if (switchdev_trans_ph_commit(trans))
3344 return 0;
3345
3346 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3347 if (!bridge_device)
3348 return -EINVAL;
3349
3350 if (!bridge_device->vlan_enabled)
3351 return 0;
3352
3353 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
3354 int err;
3355
3356 err = mlxsw_sp_switchdev_vxlan_vlan_add(mlxsw_sp, bridge_device,
3357 vxlan_dev, vid,
3358 flag_untagged,
3359 flag_pvid, extack);
3360 if (err)
3361 return err;
3362 }
3363
3364 return 0;
3365 }
3366
3367 static void
3368 mlxsw_sp_switchdev_vxlan_vlans_del(struct net_device *vxlan_dev,
3369 struct switchdev_notifier_port_obj_info *
3370 port_obj_info)
3371 {
3372 struct switchdev_obj_port_vlan *vlan =
3373 SWITCHDEV_OBJ_PORT_VLAN(port_obj_info->obj);
3374 struct mlxsw_sp_bridge_device *bridge_device;
3375 struct mlxsw_sp *mlxsw_sp;
3376 struct net_device *br_dev;
3377 u16 vid;
3378
3379 br_dev = netdev_master_upper_dev_get(vxlan_dev);
3380 if (!br_dev)
3381 return;
3382
3383 mlxsw_sp = mlxsw_sp_lower_get(br_dev);
3384 if (!mlxsw_sp)
3385 return;
3386
3387 port_obj_info->handled = true;
3388
3389 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3390 if (!bridge_device)
3391 return;
3392
3393 if (!bridge_device->vlan_enabled)
3394 return;
3395
3396 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++)
3397 mlxsw_sp_switchdev_vxlan_vlan_del(mlxsw_sp, bridge_device,
3398 vxlan_dev, vid);
3399 }
3400
3401 static int
3402 mlxsw_sp_switchdev_handle_vxlan_obj_add(struct net_device *vxlan_dev,
3403 struct switchdev_notifier_port_obj_info *
3404 port_obj_info)
3405 {
3406 int err = 0;
3407
3408 switch (port_obj_info->obj->id) {
3409 case SWITCHDEV_OBJ_ID_PORT_VLAN:
3410 err = mlxsw_sp_switchdev_vxlan_vlans_add(vxlan_dev,
3411 port_obj_info);
3412 break;
3413 default:
3414 break;
3415 }
3416
3417 return err;
3418 }
3419
3420 static void
3421 mlxsw_sp_switchdev_handle_vxlan_obj_del(struct net_device *vxlan_dev,
3422 struct switchdev_notifier_port_obj_info *
3423 port_obj_info)
3424 {
3425 switch (port_obj_info->obj->id) {
3426 case SWITCHDEV_OBJ_ID_PORT_VLAN:
3427 mlxsw_sp_switchdev_vxlan_vlans_del(vxlan_dev, port_obj_info);
3428 break;
3429 default:
3430 break;
3431 }
3432 }
3433
3434 static int mlxsw_sp_switchdev_blocking_event(struct notifier_block *unused,
3435 unsigned long event, void *ptr)
3436 {
3437 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
3438 int err = 0;
3439
3440 switch (event) {
3441 case SWITCHDEV_PORT_OBJ_ADD:
3442 if (netif_is_vxlan(dev))
3443 err = mlxsw_sp_switchdev_handle_vxlan_obj_add(dev, ptr);
3444 else
3445 err = switchdev_handle_port_obj_add(dev, ptr,
3446 mlxsw_sp_port_dev_check,
3447 mlxsw_sp_port_obj_add);
3448 return notifier_from_errno(err);
3449 case SWITCHDEV_PORT_OBJ_DEL:
3450 if (netif_is_vxlan(dev))
3451 mlxsw_sp_switchdev_handle_vxlan_obj_del(dev, ptr);
3452 else
3453 err = switchdev_handle_port_obj_del(dev, ptr,
3454 mlxsw_sp_port_dev_check,
3455 mlxsw_sp_port_obj_del);
3456 return notifier_from_errno(err);
3457 }
3458
3459 return NOTIFY_DONE;
3460 }
3461
3462 static struct notifier_block mlxsw_sp_switchdev_blocking_notifier = {
3463 .notifier_call = mlxsw_sp_switchdev_blocking_event,
3464 };
3465
3466 u8
3467 mlxsw_sp_bridge_port_stp_state(struct mlxsw_sp_bridge_port *bridge_port)
3468 {
3469 return bridge_port->stp_state;
3470 }
3471
3472 static int mlxsw_sp_fdb_init(struct mlxsw_sp *mlxsw_sp)
3473 {
3474 struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge;
3475 struct notifier_block *nb;
3476 int err;
3477
3478 err = mlxsw_sp_ageing_set(mlxsw_sp, MLXSW_SP_DEFAULT_AGEING_TIME);
3479 if (err) {
3480 dev_err(mlxsw_sp->bus_info->dev, "Failed to set default ageing time\n");
3481 return err;
3482 }
3483
3484 err = register_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
3485 if (err) {
3486 dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev notifier\n");
3487 return err;
3488 }
3489
3490 nb = &mlxsw_sp_switchdev_blocking_notifier;
3491 err = register_switchdev_blocking_notifier(nb);
3492 if (err) {
3493 dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev blocking notifier\n");
3494 goto err_register_switchdev_blocking_notifier;
3495 }
3496
3497 INIT_DELAYED_WORK(&bridge->fdb_notify.dw, mlxsw_sp_fdb_notify_work);
3498 bridge->fdb_notify.interval = MLXSW_SP_DEFAULT_LEARNING_INTERVAL;
3499 mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp);
3500 return 0;
3501
3502 err_register_switchdev_blocking_notifier:
3503 unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
3504 return err;
3505 }
3506
3507 static void mlxsw_sp_fdb_fini(struct mlxsw_sp *mlxsw_sp)
3508 {
3509 struct notifier_block *nb;
3510
3511 cancel_delayed_work_sync(&mlxsw_sp->bridge->fdb_notify.dw);
3512
3513 nb = &mlxsw_sp_switchdev_blocking_notifier;
3514 unregister_switchdev_blocking_notifier(nb);
3515
3516 unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
3517 }
3518
3519 int mlxsw_sp_switchdev_init(struct mlxsw_sp *mlxsw_sp)
3520 {
3521 struct mlxsw_sp_bridge *bridge;
3522
3523 bridge = kzalloc(sizeof(*mlxsw_sp->bridge), GFP_KERNEL);
3524 if (!bridge)
3525 return -ENOMEM;
3526 mlxsw_sp->bridge = bridge;
3527 bridge->mlxsw_sp = mlxsw_sp;
3528
3529 INIT_LIST_HEAD(&mlxsw_sp->bridge->bridges_list);
3530
3531 bridge->bridge_8021q_ops = &mlxsw_sp_bridge_8021q_ops;
3532 bridge->bridge_8021d_ops = &mlxsw_sp_bridge_8021d_ops;
3533
3534 return mlxsw_sp_fdb_init(mlxsw_sp);
3535 }
3536
3537 void mlxsw_sp_switchdev_fini(struct mlxsw_sp *mlxsw_sp)
3538 {
3539 mlxsw_sp_fdb_fini(mlxsw_sp);
3540 WARN_ON(!list_empty(&mlxsw_sp->bridge->bridges_list));
3541 kfree(mlxsw_sp->bridge);
3542 }
3543
3544 void mlxsw_sp_port_switchdev_init(struct mlxsw_sp_port *mlxsw_sp_port)
3545 {
3546 mlxsw_sp_port->dev->switchdev_ops = &mlxsw_sp_port_switchdev_ops;
3547 }
3548
3549 void mlxsw_sp_port_switchdev_fini(struct mlxsw_sp_port *mlxsw_sp_port)
3550 {
3551 }
Ubuntu Hirsute Linux kernel mirror