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