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