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