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