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 NL_SET_ERR_MSG_MOD(extack, "VNI is already set on FID"); 2031 err = -EINVAL; 2032 goto err_vni_exists; 2033 } 2034 2035 err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, ¶ms, extack); 2036 if (err) 2037 goto err_nve_fid_enable; 2038 2039 /* The tunnel port does not hold a reference on the FID. Only 2040 * local ports and the router port 2041 */ 2042 mlxsw_sp_fid_put(fid); 2043 2044 return 0; 2045 2046 err_nve_fid_enable: 2047 err_vni_exists: 2048 mlxsw_sp_fid_put(fid); 2049 return err; 2050 } 2051 2052 static struct net_device * 2053 mlxsw_sp_bridge_8021q_vxlan_dev_find(struct net_device *br_dev, u16 vid) 2054 { 2055 struct net_device *dev; 2056 struct list_head *iter; 2057 2058 netdev_for_each_lower_dev(br_dev, dev, iter) { 2059 u16 pvid; 2060 int err; 2061 2062 if (!netif_is_vxlan(dev)) 2063 continue; 2064 2065 err = mlxsw_sp_vxlan_mapped_vid(dev, &pvid); 2066 if (err || pvid != vid) 2067 continue; 2068 2069 return dev; 2070 } 2071 2072 return NULL; 2073 } 2074 2075 static struct mlxsw_sp_fid * 2076 mlxsw_sp_bridge_8021q_fid_get(struct mlxsw_sp_bridge_device *bridge_device, 2077 u16 vid, struct netlink_ext_ack *extack) 2078 { 2079 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev); 2080 struct net_device *vxlan_dev; 2081 struct mlxsw_sp_fid *fid; 2082 int err; 2083 2084 fid = mlxsw_sp_fid_8021q_get(mlxsw_sp, vid); 2085 if (IS_ERR(fid)) 2086 return fid; 2087 2088 if (mlxsw_sp_fid_vni_is_set(fid)) 2089 return fid; 2090 2091 /* Find the VxLAN device that has the specified VLAN configured as 2092 * PVID and egress untagged. There can be at most one such device 2093 */ 2094 vxlan_dev = mlxsw_sp_bridge_8021q_vxlan_dev_find(bridge_device->dev, 2095 vid); 2096 if (!vxlan_dev) 2097 return fid; 2098 2099 if (!netif_running(vxlan_dev)) 2100 return fid; 2101 2102 err = mlxsw_sp_bridge_8021q_vxlan_join(bridge_device, vxlan_dev, vid, 2103 extack); 2104 if (err) 2105 goto err_vxlan_join; 2106 2107 return fid; 2108 2109 err_vxlan_join: 2110 mlxsw_sp_fid_put(fid); 2111 return ERR_PTR(err); 2112 } 2113 2114 static struct mlxsw_sp_fid * 2115 mlxsw_sp_bridge_8021q_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device, 2116 u16 vid) 2117 { 2118 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev); 2119 2120 return mlxsw_sp_fid_8021q_lookup(mlxsw_sp, vid); 2121 } 2122 2123 static u16 2124 mlxsw_sp_bridge_8021q_fid_vid(struct mlxsw_sp_bridge_device *bridge_device, 2125 const struct mlxsw_sp_fid *fid) 2126 { 2127 return mlxsw_sp_fid_8021q_vid(fid); 2128 } 2129 2130 static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021q_ops = { 2131 .port_join = mlxsw_sp_bridge_8021q_port_join, 2132 .port_leave = mlxsw_sp_bridge_8021q_port_leave, 2133 .vxlan_join = mlxsw_sp_bridge_8021q_vxlan_join, 2134 .fid_get = mlxsw_sp_bridge_8021q_fid_get, 2135 .fid_lookup = mlxsw_sp_bridge_8021q_fid_lookup, 2136 .fid_vid = mlxsw_sp_bridge_8021q_fid_vid, 2137 }; 2138 2139 static bool 2140 mlxsw_sp_port_is_br_member(const struct mlxsw_sp_port *mlxsw_sp_port, 2141 const struct net_device *br_dev) 2142 { 2143 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; 2144 2145 list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list, 2146 list) { 2147 if (mlxsw_sp_port_vlan->bridge_port && 2148 mlxsw_sp_port_vlan->bridge_port->bridge_device->dev == 2149 br_dev) 2150 return true; 2151 } 2152 2153 return false; 2154 } 2155 2156 static int 2157 mlxsw_sp_bridge_8021d_port_join(struct mlxsw_sp_bridge_device *bridge_device, 2158 struct mlxsw_sp_bridge_port *bridge_port, 2159 struct mlxsw_sp_port *mlxsw_sp_port, 2160 struct netlink_ext_ack *extack) 2161 { 2162 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; 2163 struct net_device *dev = bridge_port->dev; 2164 u16 vid; 2165 2166 vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID; 2167 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid); 2168 if (WARN_ON(!mlxsw_sp_port_vlan)) 2169 return -EINVAL; 2170 2171 if (mlxsw_sp_port_is_br_member(mlxsw_sp_port, bridge_device->dev)) { 2172 NL_SET_ERR_MSG_MOD(extack, "Can not bridge VLAN uppers of the same port"); 2173 return -EINVAL; 2174 } 2175 2176 /* Port is no longer usable as a router interface */ 2177 if (mlxsw_sp_port_vlan->fid) 2178 mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan); 2179 2180 return mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port, 2181 extack); 2182 } 2183 2184 static void 2185 mlxsw_sp_bridge_8021d_port_leave(struct mlxsw_sp_bridge_device *bridge_device, 2186 struct mlxsw_sp_bridge_port *bridge_port, 2187 struct mlxsw_sp_port *mlxsw_sp_port) 2188 { 2189 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; 2190 struct net_device *dev = bridge_port->dev; 2191 u16 vid; 2192 2193 vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID; 2194 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid); 2195 if (!mlxsw_sp_port_vlan || !mlxsw_sp_port_vlan->bridge_port) 2196 return; 2197 2198 mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan); 2199 } 2200 2201 static int 2202 mlxsw_sp_bridge_8021d_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device, 2203 const struct net_device *vxlan_dev, u16 vid, 2204 struct netlink_ext_ack *extack) 2205 { 2206 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev); 2207 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev); 2208 struct mlxsw_sp_nve_params params = { 2209 .type = MLXSW_SP_NVE_TYPE_VXLAN, 2210 .vni = vxlan->cfg.vni, 2211 .dev = vxlan_dev, 2212 }; 2213 struct mlxsw_sp_fid *fid; 2214 int err; 2215 2216 fid = mlxsw_sp_fid_8021d_lookup(mlxsw_sp, bridge_device->dev->ifindex); 2217 if (!fid) { 2218 NL_SET_ERR_MSG_MOD(extack, "Did not find a corresponding FID"); 2219 return -EINVAL; 2220 } 2221 2222 if (mlxsw_sp_fid_vni_is_set(fid)) { 2223 NL_SET_ERR_MSG_MOD(extack, "VNI is already set on FID"); 2224 err = -EINVAL; 2225 goto err_vni_exists; 2226 } 2227 2228 err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, ¶ms, extack); 2229 if (err) 2230 goto err_nve_fid_enable; 2231 2232 /* The tunnel port does not hold a reference on the FID. Only 2233 * local ports and the router port 2234 */ 2235 mlxsw_sp_fid_put(fid); 2236 2237 return 0; 2238 2239 err_nve_fid_enable: 2240 err_vni_exists: 2241 mlxsw_sp_fid_put(fid); 2242 return err; 2243 } 2244 2245 static struct mlxsw_sp_fid * 2246 mlxsw_sp_bridge_8021d_fid_get(struct mlxsw_sp_bridge_device *bridge_device, 2247 u16 vid, struct netlink_ext_ack *extack) 2248 { 2249 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev); 2250 struct net_device *vxlan_dev; 2251 struct mlxsw_sp_fid *fid; 2252 int err; 2253 2254 fid = mlxsw_sp_fid_8021d_get(mlxsw_sp, bridge_device->dev->ifindex); 2255 if (IS_ERR(fid)) 2256 return fid; 2257 2258 if (mlxsw_sp_fid_vni_is_set(fid)) 2259 return fid; 2260 2261 vxlan_dev = mlxsw_sp_bridge_vxlan_dev_find(bridge_device->dev); 2262 if (!vxlan_dev) 2263 return fid; 2264 2265 if (!netif_running(vxlan_dev)) 2266 return fid; 2267 2268 err = mlxsw_sp_bridge_8021d_vxlan_join(bridge_device, vxlan_dev, 0, 2269 extack); 2270 if (err) 2271 goto err_vxlan_join; 2272 2273 return fid; 2274 2275 err_vxlan_join: 2276 mlxsw_sp_fid_put(fid); 2277 return ERR_PTR(err); 2278 } 2279 2280 static struct mlxsw_sp_fid * 2281 mlxsw_sp_bridge_8021d_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device, 2282 u16 vid) 2283 { 2284 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev); 2285 2286 /* The only valid VLAN for a VLAN-unaware bridge is 0 */ 2287 if (vid) 2288 return NULL; 2289 2290 return mlxsw_sp_fid_8021d_lookup(mlxsw_sp, bridge_device->dev->ifindex); 2291 } 2292 2293 static u16 2294 mlxsw_sp_bridge_8021d_fid_vid(struct mlxsw_sp_bridge_device *bridge_device, 2295 const struct mlxsw_sp_fid *fid) 2296 { 2297 return 0; 2298 } 2299 2300 static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021d_ops = { 2301 .port_join = mlxsw_sp_bridge_8021d_port_join, 2302 .port_leave = mlxsw_sp_bridge_8021d_port_leave, 2303 .vxlan_join = mlxsw_sp_bridge_8021d_vxlan_join, 2304 .fid_get = mlxsw_sp_bridge_8021d_fid_get, 2305 .fid_lookup = mlxsw_sp_bridge_8021d_fid_lookup, 2306 .fid_vid = mlxsw_sp_bridge_8021d_fid_vid, 2307 }; 2308 2309 int mlxsw_sp_port_bridge_join(struct mlxsw_sp_port *mlxsw_sp_port, 2310 struct net_device *brport_dev, 2311 struct net_device *br_dev, 2312 struct netlink_ext_ack *extack) 2313 { 2314 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; 2315 struct mlxsw_sp_bridge_device *bridge_device; 2316 struct mlxsw_sp_bridge_port *bridge_port; 2317 int err; 2318 2319 bridge_port = mlxsw_sp_bridge_port_get(mlxsw_sp->bridge, brport_dev); 2320 if (IS_ERR(bridge_port)) 2321 return PTR_ERR(bridge_port); 2322 bridge_device = bridge_port->bridge_device; 2323 2324 err = bridge_device->ops->port_join(bridge_device, bridge_port, 2325 mlxsw_sp_port, extack); 2326 if (err) 2327 goto err_port_join; 2328 2329 return 0; 2330 2331 err_port_join: 2332 mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port); 2333 return err; 2334 } 2335 2336 void mlxsw_sp_port_bridge_leave(struct mlxsw_sp_port *mlxsw_sp_port, 2337 struct net_device *brport_dev, 2338 struct net_device *br_dev) 2339 { 2340 struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp; 2341 struct mlxsw_sp_bridge_device *bridge_device; 2342 struct mlxsw_sp_bridge_port *bridge_port; 2343 2344 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); 2345 if (!bridge_device) 2346 return; 2347 bridge_port = __mlxsw_sp_bridge_port_find(bridge_device, brport_dev); 2348 if (!bridge_port) 2349 return; 2350 2351 bridge_device->ops->port_leave(bridge_device, bridge_port, 2352 mlxsw_sp_port); 2353 mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port); 2354 } 2355 2356 int mlxsw_sp_bridge_vxlan_join(struct mlxsw_sp *mlxsw_sp, 2357 const struct net_device *br_dev, 2358 const struct net_device *vxlan_dev, u16 vid, 2359 struct netlink_ext_ack *extack) 2360 { 2361 struct mlxsw_sp_bridge_device *bridge_device; 2362 2363 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); 2364 if (WARN_ON(!bridge_device)) 2365 return -EINVAL; 2366 2367 return bridge_device->ops->vxlan_join(bridge_device, vxlan_dev, vid, 2368 extack); 2369 } 2370 2371 void mlxsw_sp_bridge_vxlan_leave(struct mlxsw_sp *mlxsw_sp, 2372 const struct net_device *vxlan_dev) 2373 { 2374 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev); 2375 struct mlxsw_sp_fid *fid; 2376 2377 /* If the VxLAN device is down, then the FID does not have a VNI */ 2378 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan->cfg.vni); 2379 if (!fid) 2380 return; 2381 2382 mlxsw_sp_nve_fid_disable(mlxsw_sp, fid); 2383 mlxsw_sp_fid_put(fid); 2384 } 2385 2386 struct mlxsw_sp_fid *mlxsw_sp_bridge_fid_get(struct mlxsw_sp *mlxsw_sp, 2387 const struct net_device *br_dev, 2388 u16 vid, 2389 struct netlink_ext_ack *extack) 2390 { 2391 struct mlxsw_sp_bridge_device *bridge_device; 2392 2393 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); 2394 if (WARN_ON(!bridge_device)) 2395 return ERR_PTR(-EINVAL); 2396 2397 return bridge_device->ops->fid_get(bridge_device, vid, extack); 2398 } 2399 2400 static void 2401 mlxsw_sp_switchdev_vxlan_addr_convert(const union vxlan_addr *vxlan_addr, 2402 enum mlxsw_sp_l3proto *proto, 2403 union mlxsw_sp_l3addr *addr) 2404 { 2405 if (vxlan_addr->sa.sa_family == AF_INET) { 2406 addr->addr4 = vxlan_addr->sin.sin_addr.s_addr; 2407 *proto = MLXSW_SP_L3_PROTO_IPV4; 2408 } else { 2409 addr->addr6 = vxlan_addr->sin6.sin6_addr; 2410 *proto = MLXSW_SP_L3_PROTO_IPV6; 2411 } 2412 } 2413 2414 static void 2415 mlxsw_sp_switchdev_addr_vxlan_convert(enum mlxsw_sp_l3proto proto, 2416 const union mlxsw_sp_l3addr *addr, 2417 union vxlan_addr *vxlan_addr) 2418 { 2419 switch (proto) { 2420 case MLXSW_SP_L3_PROTO_IPV4: 2421 vxlan_addr->sa.sa_family = AF_INET; 2422 vxlan_addr->sin.sin_addr.s_addr = addr->addr4; 2423 break; 2424 case MLXSW_SP_L3_PROTO_IPV6: 2425 vxlan_addr->sa.sa_family = AF_INET6; 2426 vxlan_addr->sin6.sin6_addr = addr->addr6; 2427 break; 2428 } 2429 } 2430 2431 static void mlxsw_sp_fdb_vxlan_call_notifiers(struct net_device *dev, 2432 const char *mac, 2433 enum mlxsw_sp_l3proto proto, 2434 union mlxsw_sp_l3addr *addr, 2435 __be32 vni, bool adding) 2436 { 2437 struct switchdev_notifier_vxlan_fdb_info info; 2438 struct vxlan_dev *vxlan = netdev_priv(dev); 2439 enum switchdev_notifier_type type; 2440 2441 type = adding ? SWITCHDEV_VXLAN_FDB_ADD_TO_BRIDGE : 2442 SWITCHDEV_VXLAN_FDB_DEL_TO_BRIDGE; 2443 mlxsw_sp_switchdev_addr_vxlan_convert(proto, addr, &info.remote_ip); 2444 info.remote_port = vxlan->cfg.dst_port; 2445 info.remote_vni = vni; 2446 info.remote_ifindex = 0; 2447 ether_addr_copy(info.eth_addr, mac); 2448 info.vni = vni; 2449 info.offloaded = adding; 2450 call_switchdev_notifiers(type, dev, &info.info, NULL); 2451 } 2452 2453 static void mlxsw_sp_fdb_nve_call_notifiers(struct net_device *dev, 2454 const char *mac, 2455 enum mlxsw_sp_l3proto proto, 2456 union mlxsw_sp_l3addr *addr, 2457 __be32 vni, 2458 bool adding) 2459 { 2460 if (netif_is_vxlan(dev)) 2461 mlxsw_sp_fdb_vxlan_call_notifiers(dev, mac, proto, addr, vni, 2462 adding); 2463 } 2464 2465 static void 2466 mlxsw_sp_fdb_call_notifiers(enum switchdev_notifier_type type, 2467 const char *mac, u16 vid, 2468 struct net_device *dev, bool offloaded) 2469 { 2470 struct switchdev_notifier_fdb_info info; 2471 2472 info.addr = mac; 2473 info.vid = vid; 2474 info.offloaded = offloaded; 2475 call_switchdev_notifiers(type, dev, &info.info, NULL); 2476 } 2477 2478 static void mlxsw_sp_fdb_notify_mac_process(struct mlxsw_sp *mlxsw_sp, 2479 char *sfn_pl, int rec_index, 2480 bool adding) 2481 { 2482 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; 2483 struct mlxsw_sp_bridge_device *bridge_device; 2484 struct mlxsw_sp_bridge_port *bridge_port; 2485 struct mlxsw_sp_port *mlxsw_sp_port; 2486 enum switchdev_notifier_type type; 2487 char mac[ETH_ALEN]; 2488 u8 local_port; 2489 u16 vid, fid; 2490 bool do_notification = true; 2491 int err; 2492 2493 mlxsw_reg_sfn_mac_unpack(sfn_pl, rec_index, mac, &fid, &local_port); 2494 mlxsw_sp_port = mlxsw_sp->ports[local_port]; 2495 if (!mlxsw_sp_port) { 2496 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect local port in FDB notification\n"); 2497 goto just_remove; 2498 } 2499 2500 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid); 2501 if (!mlxsw_sp_port_vlan) { 2502 netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n"); 2503 goto just_remove; 2504 } 2505 2506 bridge_port = mlxsw_sp_port_vlan->bridge_port; 2507 if (!bridge_port) { 2508 netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n"); 2509 goto just_remove; 2510 } 2511 2512 bridge_device = bridge_port->bridge_device; 2513 vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0; 2514 2515 do_fdb_op: 2516 err = mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid, 2517 adding, true); 2518 if (err) { 2519 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n"); 2520 return; 2521 } 2522 2523 if (!do_notification) 2524 return; 2525 type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE; 2526 mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding); 2527 2528 return; 2529 2530 just_remove: 2531 adding = false; 2532 do_notification = false; 2533 goto do_fdb_op; 2534 } 2535 2536 static void mlxsw_sp_fdb_notify_mac_lag_process(struct mlxsw_sp *mlxsw_sp, 2537 char *sfn_pl, int rec_index, 2538 bool adding) 2539 { 2540 struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan; 2541 struct mlxsw_sp_bridge_device *bridge_device; 2542 struct mlxsw_sp_bridge_port *bridge_port; 2543 struct mlxsw_sp_port *mlxsw_sp_port; 2544 enum switchdev_notifier_type type; 2545 char mac[ETH_ALEN]; 2546 u16 lag_vid = 0; 2547 u16 lag_id; 2548 u16 vid, fid; 2549 bool do_notification = true; 2550 int err; 2551 2552 mlxsw_reg_sfn_mac_lag_unpack(sfn_pl, rec_index, mac, &fid, &lag_id); 2553 mlxsw_sp_port = mlxsw_sp_lag_rep_port(mlxsw_sp, lag_id); 2554 if (!mlxsw_sp_port) { 2555 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Cannot find port representor for LAG\n"); 2556 goto just_remove; 2557 } 2558 2559 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid); 2560 if (!mlxsw_sp_port_vlan) { 2561 netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n"); 2562 goto just_remove; 2563 } 2564 2565 bridge_port = mlxsw_sp_port_vlan->bridge_port; 2566 if (!bridge_port) { 2567 netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n"); 2568 goto just_remove; 2569 } 2570 2571 bridge_device = bridge_port->bridge_device; 2572 vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0; 2573 lag_vid = mlxsw_sp_fid_lag_vid_valid(mlxsw_sp_port_vlan->fid) ? 2574 mlxsw_sp_port_vlan->vid : 0; 2575 2576 do_fdb_op: 2577 err = mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp, lag_id, mac, fid, lag_vid, 2578 adding, true); 2579 if (err) { 2580 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n"); 2581 return; 2582 } 2583 2584 if (!do_notification) 2585 return; 2586 type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE; 2587 mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding); 2588 2589 return; 2590 2591 just_remove: 2592 adding = false; 2593 do_notification = false; 2594 goto do_fdb_op; 2595 } 2596 2597 static int 2598 __mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp, 2599 const struct mlxsw_sp_fid *fid, 2600 bool adding, 2601 struct net_device **nve_dev, 2602 u16 *p_vid, __be32 *p_vni) 2603 { 2604 struct mlxsw_sp_bridge_device *bridge_device; 2605 struct net_device *br_dev, *dev; 2606 int nve_ifindex; 2607 int err; 2608 2609 err = mlxsw_sp_fid_nve_ifindex(fid, &nve_ifindex); 2610 if (err) 2611 return err; 2612 2613 err = mlxsw_sp_fid_vni(fid, p_vni); 2614 if (err) 2615 return err; 2616 2617 dev = __dev_get_by_index(&init_net, nve_ifindex); 2618 if (!dev) 2619 return -EINVAL; 2620 *nve_dev = dev; 2621 2622 if (!netif_running(dev)) 2623 return -EINVAL; 2624 2625 if (adding && !br_port_flag_is_set(dev, BR_LEARNING)) 2626 return -EINVAL; 2627 2628 if (adding && netif_is_vxlan(dev)) { 2629 struct vxlan_dev *vxlan = netdev_priv(dev); 2630 2631 if (!(vxlan->cfg.flags & VXLAN_F_LEARN)) 2632 return -EINVAL; 2633 } 2634 2635 br_dev = netdev_master_upper_dev_get(dev); 2636 if (!br_dev) 2637 return -EINVAL; 2638 2639 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); 2640 if (!bridge_device) 2641 return -EINVAL; 2642 2643 *p_vid = bridge_device->ops->fid_vid(bridge_device, fid); 2644 2645 return 0; 2646 } 2647 2648 static void mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp, 2649 char *sfn_pl, 2650 int rec_index, 2651 bool adding) 2652 { 2653 enum mlxsw_reg_sfn_uc_tunnel_protocol sfn_proto; 2654 enum switchdev_notifier_type type; 2655 struct net_device *nve_dev; 2656 union mlxsw_sp_l3addr addr; 2657 struct mlxsw_sp_fid *fid; 2658 char mac[ETH_ALEN]; 2659 u16 fid_index, vid; 2660 __be32 vni; 2661 u32 uip; 2662 int err; 2663 2664 mlxsw_reg_sfn_uc_tunnel_unpack(sfn_pl, rec_index, mac, &fid_index, 2665 &uip, &sfn_proto); 2666 2667 fid = mlxsw_sp_fid_lookup_by_index(mlxsw_sp, fid_index); 2668 if (!fid) 2669 goto err_fid_lookup; 2670 2671 err = mlxsw_sp_nve_learned_ip_resolve(mlxsw_sp, uip, 2672 (enum mlxsw_sp_l3proto) sfn_proto, 2673 &addr); 2674 if (err) 2675 goto err_ip_resolve; 2676 2677 err = __mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, fid, adding, 2678 &nve_dev, &vid, &vni); 2679 if (err) 2680 goto err_fdb_process; 2681 2682 err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index, 2683 (enum mlxsw_sp_l3proto) sfn_proto, 2684 &addr, adding, true); 2685 if (err) 2686 goto err_fdb_op; 2687 2688 mlxsw_sp_fdb_nve_call_notifiers(nve_dev, mac, 2689 (enum mlxsw_sp_l3proto) sfn_proto, 2690 &addr, vni, adding); 2691 2692 type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : 2693 SWITCHDEV_FDB_DEL_TO_BRIDGE; 2694 mlxsw_sp_fdb_call_notifiers(type, mac, vid, nve_dev, adding); 2695 2696 mlxsw_sp_fid_put(fid); 2697 2698 return; 2699 2700 err_fdb_op: 2701 err_fdb_process: 2702 err_ip_resolve: 2703 mlxsw_sp_fid_put(fid); 2704 err_fid_lookup: 2705 /* Remove an FDB entry in case we cannot process it. Otherwise the 2706 * device will keep sending the same notification over and over again. 2707 */ 2708 mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index, 2709 (enum mlxsw_sp_l3proto) sfn_proto, &addr, 2710 false, true); 2711 } 2712 2713 static void mlxsw_sp_fdb_notify_rec_process(struct mlxsw_sp *mlxsw_sp, 2714 char *sfn_pl, int rec_index) 2715 { 2716 switch (mlxsw_reg_sfn_rec_type_get(sfn_pl, rec_index)) { 2717 case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC: 2718 mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl, 2719 rec_index, true); 2720 break; 2721 case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC: 2722 mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl, 2723 rec_index, false); 2724 break; 2725 case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC_LAG: 2726 mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl, 2727 rec_index, true); 2728 break; 2729 case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC_LAG: 2730 mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl, 2731 rec_index, false); 2732 break; 2733 case MLXSW_REG_SFN_REC_TYPE_LEARNED_UNICAST_TUNNEL: 2734 mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl, 2735 rec_index, true); 2736 break; 2737 case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_UNICAST_TUNNEL: 2738 mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl, 2739 rec_index, false); 2740 break; 2741 } 2742 } 2743 2744 static void mlxsw_sp_fdb_notify_work_schedule(struct mlxsw_sp *mlxsw_sp) 2745 { 2746 struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge; 2747 2748 mlxsw_core_schedule_dw(&bridge->fdb_notify.dw, 2749 msecs_to_jiffies(bridge->fdb_notify.interval)); 2750 } 2751 2752 static void mlxsw_sp_fdb_notify_work(struct work_struct *work) 2753 { 2754 struct mlxsw_sp_bridge *bridge; 2755 struct mlxsw_sp *mlxsw_sp; 2756 char *sfn_pl; 2757 u8 num_rec; 2758 int i; 2759 int err; 2760 2761 sfn_pl = kmalloc(MLXSW_REG_SFN_LEN, GFP_KERNEL); 2762 if (!sfn_pl) 2763 return; 2764 2765 bridge = container_of(work, struct mlxsw_sp_bridge, fdb_notify.dw.work); 2766 mlxsw_sp = bridge->mlxsw_sp; 2767 2768 rtnl_lock(); 2769 mlxsw_reg_sfn_pack(sfn_pl); 2770 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(sfn), sfn_pl); 2771 if (err) { 2772 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to get FDB notifications\n"); 2773 goto out; 2774 } 2775 num_rec = mlxsw_reg_sfn_num_rec_get(sfn_pl); 2776 for (i = 0; i < num_rec; i++) 2777 mlxsw_sp_fdb_notify_rec_process(mlxsw_sp, sfn_pl, i); 2778 2779 out: 2780 rtnl_unlock(); 2781 kfree(sfn_pl); 2782 mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp); 2783 } 2784 2785 struct mlxsw_sp_switchdev_event_work { 2786 struct work_struct work; 2787 union { 2788 struct switchdev_notifier_fdb_info fdb_info; 2789 struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info; 2790 }; 2791 struct net_device *dev; 2792 unsigned long event; 2793 }; 2794 2795 static void 2796 mlxsw_sp_switchdev_bridge_vxlan_fdb_event(struct mlxsw_sp *mlxsw_sp, 2797 struct mlxsw_sp_switchdev_event_work * 2798 switchdev_work, 2799 struct mlxsw_sp_fid *fid, __be32 vni) 2800 { 2801 struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info; 2802 struct switchdev_notifier_fdb_info *fdb_info; 2803 struct net_device *dev = switchdev_work->dev; 2804 enum mlxsw_sp_l3proto proto; 2805 union mlxsw_sp_l3addr addr; 2806 int err; 2807 2808 fdb_info = &switchdev_work->fdb_info; 2809 err = vxlan_fdb_find_uc(dev, fdb_info->addr, vni, &vxlan_fdb_info); 2810 if (err) 2811 return; 2812 2813 mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info.remote_ip, 2814 &proto, &addr); 2815 2816 switch (switchdev_work->event) { 2817 case SWITCHDEV_FDB_ADD_TO_DEVICE: 2818 err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, 2819 vxlan_fdb_info.eth_addr, 2820 mlxsw_sp_fid_index(fid), 2821 proto, &addr, true, false); 2822 if (err) 2823 return; 2824 vxlan_fdb_info.offloaded = true; 2825 call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev, 2826 &vxlan_fdb_info.info, NULL); 2827 mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED, 2828 vxlan_fdb_info.eth_addr, 2829 fdb_info->vid, dev, true); 2830 break; 2831 case SWITCHDEV_FDB_DEL_TO_DEVICE: 2832 err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, 2833 vxlan_fdb_info.eth_addr, 2834 mlxsw_sp_fid_index(fid), 2835 proto, &addr, false, 2836 false); 2837 vxlan_fdb_info.offloaded = false; 2838 call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev, 2839 &vxlan_fdb_info.info, NULL); 2840 break; 2841 } 2842 } 2843 2844 static void 2845 mlxsw_sp_switchdev_bridge_nve_fdb_event(struct mlxsw_sp_switchdev_event_work * 2846 switchdev_work) 2847 { 2848 struct mlxsw_sp_bridge_device *bridge_device; 2849 struct net_device *dev = switchdev_work->dev; 2850 struct net_device *br_dev; 2851 struct mlxsw_sp *mlxsw_sp; 2852 struct mlxsw_sp_fid *fid; 2853 __be32 vni; 2854 int err; 2855 2856 if (switchdev_work->event != SWITCHDEV_FDB_ADD_TO_DEVICE && 2857 switchdev_work->event != SWITCHDEV_FDB_DEL_TO_DEVICE) 2858 return; 2859 2860 if (switchdev_work->event == SWITCHDEV_FDB_ADD_TO_DEVICE && 2861 !switchdev_work->fdb_info.added_by_user) 2862 return; 2863 2864 if (!netif_running(dev)) 2865 return; 2866 br_dev = netdev_master_upper_dev_get(dev); 2867 if (!br_dev) 2868 return; 2869 if (!netif_is_bridge_master(br_dev)) 2870 return; 2871 mlxsw_sp = mlxsw_sp_lower_get(br_dev); 2872 if (!mlxsw_sp) 2873 return; 2874 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); 2875 if (!bridge_device) 2876 return; 2877 2878 fid = bridge_device->ops->fid_lookup(bridge_device, 2879 switchdev_work->fdb_info.vid); 2880 if (!fid) 2881 return; 2882 2883 err = mlxsw_sp_fid_vni(fid, &vni); 2884 if (err) 2885 goto out; 2886 2887 mlxsw_sp_switchdev_bridge_vxlan_fdb_event(mlxsw_sp, switchdev_work, fid, 2888 vni); 2889 2890 out: 2891 mlxsw_sp_fid_put(fid); 2892 } 2893 2894 static void mlxsw_sp_switchdev_bridge_fdb_event_work(struct work_struct *work) 2895 { 2896 struct mlxsw_sp_switchdev_event_work *switchdev_work = 2897 container_of(work, struct mlxsw_sp_switchdev_event_work, work); 2898 struct net_device *dev = switchdev_work->dev; 2899 struct switchdev_notifier_fdb_info *fdb_info; 2900 struct mlxsw_sp_port *mlxsw_sp_port; 2901 int err; 2902 2903 rtnl_lock(); 2904 if (netif_is_vxlan(dev)) { 2905 mlxsw_sp_switchdev_bridge_nve_fdb_event(switchdev_work); 2906 goto out; 2907 } 2908 2909 mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(dev); 2910 if (!mlxsw_sp_port) 2911 goto out; 2912 2913 switch (switchdev_work->event) { 2914 case SWITCHDEV_FDB_ADD_TO_DEVICE: 2915 fdb_info = &switchdev_work->fdb_info; 2916 if (!fdb_info->added_by_user) 2917 break; 2918 err = mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, true); 2919 if (err) 2920 break; 2921 mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED, 2922 fdb_info->addr, 2923 fdb_info->vid, dev, true); 2924 break; 2925 case SWITCHDEV_FDB_DEL_TO_DEVICE: 2926 fdb_info = &switchdev_work->fdb_info; 2927 mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, false); 2928 break; 2929 case SWITCHDEV_FDB_ADD_TO_BRIDGE: /* fall through */ 2930 case SWITCHDEV_FDB_DEL_TO_BRIDGE: 2931 /* These events are only used to potentially update an existing 2932 * SPAN mirror. 2933 */ 2934 break; 2935 } 2936 2937 mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp); 2938 2939 out: 2940 rtnl_unlock(); 2941 kfree(switchdev_work->fdb_info.addr); 2942 kfree(switchdev_work); 2943 dev_put(dev); 2944 } 2945 2946 static void 2947 mlxsw_sp_switchdev_vxlan_fdb_add(struct mlxsw_sp *mlxsw_sp, 2948 struct mlxsw_sp_switchdev_event_work * 2949 switchdev_work) 2950 { 2951 struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info; 2952 struct mlxsw_sp_bridge_device *bridge_device; 2953 struct net_device *dev = switchdev_work->dev; 2954 u8 all_zeros_mac[ETH_ALEN] = { 0 }; 2955 enum mlxsw_sp_l3proto proto; 2956 union mlxsw_sp_l3addr addr; 2957 struct net_device *br_dev; 2958 struct mlxsw_sp_fid *fid; 2959 u16 vid; 2960 int err; 2961 2962 vxlan_fdb_info = &switchdev_work->vxlan_fdb_info; 2963 br_dev = netdev_master_upper_dev_get(dev); 2964 2965 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); 2966 if (!bridge_device) 2967 return; 2968 2969 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan_fdb_info->vni); 2970 if (!fid) 2971 return; 2972 2973 mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info->remote_ip, 2974 &proto, &addr); 2975 2976 if (ether_addr_equal(vxlan_fdb_info->eth_addr, all_zeros_mac)) { 2977 err = mlxsw_sp_nve_flood_ip_add(mlxsw_sp, fid, proto, &addr); 2978 if (err) { 2979 mlxsw_sp_fid_put(fid); 2980 return; 2981 } 2982 vxlan_fdb_info->offloaded = true; 2983 call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev, 2984 &vxlan_fdb_info->info, NULL); 2985 mlxsw_sp_fid_put(fid); 2986 return; 2987 } 2988 2989 /* The device has a single FDB table, whereas Linux has two - one 2990 * in the bridge driver and another in the VxLAN driver. We only 2991 * program an entry to the device if the MAC points to the VxLAN 2992 * device in the bridge's FDB table 2993 */ 2994 vid = bridge_device->ops->fid_vid(bridge_device, fid); 2995 if (br_fdb_find_port(br_dev, vxlan_fdb_info->eth_addr, vid) != dev) 2996 goto err_br_fdb_find; 2997 2998 err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, vxlan_fdb_info->eth_addr, 2999 mlxsw_sp_fid_index(fid), proto, 3000 &addr, true, false); 3001 if (err) 3002 goto err_fdb_tunnel_uc_op; 3003 vxlan_fdb_info->offloaded = true; 3004 call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev, 3005 &vxlan_fdb_info->info, NULL); 3006 mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED, 3007 vxlan_fdb_info->eth_addr, vid, dev, true); 3008 3009 mlxsw_sp_fid_put(fid); 3010 3011 return; 3012 3013 err_fdb_tunnel_uc_op: 3014 err_br_fdb_find: 3015 mlxsw_sp_fid_put(fid); 3016 } 3017 3018 static void 3019 mlxsw_sp_switchdev_vxlan_fdb_del(struct mlxsw_sp *mlxsw_sp, 3020 struct mlxsw_sp_switchdev_event_work * 3021 switchdev_work) 3022 { 3023 struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info; 3024 struct mlxsw_sp_bridge_device *bridge_device; 3025 struct net_device *dev = switchdev_work->dev; 3026 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 3027 u8 all_zeros_mac[ETH_ALEN] = { 0 }; 3028 enum mlxsw_sp_l3proto proto; 3029 union mlxsw_sp_l3addr addr; 3030 struct mlxsw_sp_fid *fid; 3031 u16 vid; 3032 3033 vxlan_fdb_info = &switchdev_work->vxlan_fdb_info; 3034 3035 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); 3036 if (!bridge_device) 3037 return; 3038 3039 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan_fdb_info->vni); 3040 if (!fid) 3041 return; 3042 3043 mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info->remote_ip, 3044 &proto, &addr); 3045 3046 if (ether_addr_equal(vxlan_fdb_info->eth_addr, all_zeros_mac)) { 3047 mlxsw_sp_nve_flood_ip_del(mlxsw_sp, fid, proto, &addr); 3048 mlxsw_sp_fid_put(fid); 3049 return; 3050 } 3051 3052 mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, vxlan_fdb_info->eth_addr, 3053 mlxsw_sp_fid_index(fid), proto, &addr, 3054 false, false); 3055 vid = bridge_device->ops->fid_vid(bridge_device, fid); 3056 mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED, 3057 vxlan_fdb_info->eth_addr, vid, dev, false); 3058 3059 mlxsw_sp_fid_put(fid); 3060 } 3061 3062 static void mlxsw_sp_switchdev_vxlan_fdb_event_work(struct work_struct *work) 3063 { 3064 struct mlxsw_sp_switchdev_event_work *switchdev_work = 3065 container_of(work, struct mlxsw_sp_switchdev_event_work, work); 3066 struct net_device *dev = switchdev_work->dev; 3067 struct mlxsw_sp *mlxsw_sp; 3068 struct net_device *br_dev; 3069 3070 rtnl_lock(); 3071 3072 if (!netif_running(dev)) 3073 goto out; 3074 br_dev = netdev_master_upper_dev_get(dev); 3075 if (!br_dev) 3076 goto out; 3077 if (!netif_is_bridge_master(br_dev)) 3078 goto out; 3079 mlxsw_sp = mlxsw_sp_lower_get(br_dev); 3080 if (!mlxsw_sp) 3081 goto out; 3082 3083 switch (switchdev_work->event) { 3084 case SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE: 3085 mlxsw_sp_switchdev_vxlan_fdb_add(mlxsw_sp, switchdev_work); 3086 break; 3087 case SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE: 3088 mlxsw_sp_switchdev_vxlan_fdb_del(mlxsw_sp, switchdev_work); 3089 break; 3090 } 3091 3092 out: 3093 rtnl_unlock(); 3094 kfree(switchdev_work); 3095 dev_put(dev); 3096 } 3097 3098 static int 3099 mlxsw_sp_switchdev_vxlan_work_prepare(struct mlxsw_sp_switchdev_event_work * 3100 switchdev_work, 3101 struct switchdev_notifier_info *info) 3102 { 3103 struct vxlan_dev *vxlan = netdev_priv(switchdev_work->dev); 3104 struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info; 3105 struct vxlan_config *cfg = &vxlan->cfg; 3106 struct netlink_ext_ack *extack; 3107 3108 extack = switchdev_notifier_info_to_extack(info); 3109 vxlan_fdb_info = container_of(info, 3110 struct switchdev_notifier_vxlan_fdb_info, 3111 info); 3112 3113 if (vxlan_fdb_info->remote_port != cfg->dst_port) { 3114 NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Non-default remote port is not supported"); 3115 return -EOPNOTSUPP; 3116 } 3117 if (vxlan_fdb_info->remote_vni != cfg->vni || 3118 vxlan_fdb_info->vni != cfg->vni) { 3119 NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Non-default VNI is not supported"); 3120 return -EOPNOTSUPP; 3121 } 3122 if (vxlan_fdb_info->remote_ifindex) { 3123 NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Local interface is not supported"); 3124 return -EOPNOTSUPP; 3125 } 3126 if (is_multicast_ether_addr(vxlan_fdb_info->eth_addr)) { 3127 NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Multicast MAC addresses not supported"); 3128 return -EOPNOTSUPP; 3129 } 3130 if (vxlan_addr_multicast(&vxlan_fdb_info->remote_ip)) { 3131 NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Multicast destination IP is not supported"); 3132 return -EOPNOTSUPP; 3133 } 3134 3135 switchdev_work->vxlan_fdb_info = *vxlan_fdb_info; 3136 3137 return 0; 3138 } 3139 3140 /* Called under rcu_read_lock() */ 3141 static int mlxsw_sp_switchdev_event(struct notifier_block *unused, 3142 unsigned long event, void *ptr) 3143 { 3144 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 3145 struct mlxsw_sp_switchdev_event_work *switchdev_work; 3146 struct switchdev_notifier_fdb_info *fdb_info; 3147 struct switchdev_notifier_info *info = ptr; 3148 struct net_device *br_dev; 3149 int err; 3150 3151 /* Tunnel devices are not our uppers, so check their master instead */ 3152 br_dev = netdev_master_upper_dev_get_rcu(dev); 3153 if (!br_dev) 3154 return NOTIFY_DONE; 3155 if (!netif_is_bridge_master(br_dev)) 3156 return NOTIFY_DONE; 3157 if (!mlxsw_sp_port_dev_lower_find_rcu(br_dev)) 3158 return NOTIFY_DONE; 3159 3160 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC); 3161 if (!switchdev_work) 3162 return NOTIFY_BAD; 3163 3164 switchdev_work->dev = dev; 3165 switchdev_work->event = event; 3166 3167 switch (event) { 3168 case SWITCHDEV_FDB_ADD_TO_DEVICE: /* fall through */ 3169 case SWITCHDEV_FDB_DEL_TO_DEVICE: /* fall through */ 3170 case SWITCHDEV_FDB_ADD_TO_BRIDGE: /* fall through */ 3171 case SWITCHDEV_FDB_DEL_TO_BRIDGE: 3172 fdb_info = container_of(info, 3173 struct switchdev_notifier_fdb_info, 3174 info); 3175 INIT_WORK(&switchdev_work->work, 3176 mlxsw_sp_switchdev_bridge_fdb_event_work); 3177 memcpy(&switchdev_work->fdb_info, ptr, 3178 sizeof(switchdev_work->fdb_info)); 3179 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC); 3180 if (!switchdev_work->fdb_info.addr) 3181 goto err_addr_alloc; 3182 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr, 3183 fdb_info->addr); 3184 /* Take a reference on the device. This can be either 3185 * upper device containig mlxsw_sp_port or just a 3186 * mlxsw_sp_port 3187 */ 3188 dev_hold(dev); 3189 break; 3190 case SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE: /* fall through */ 3191 case SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE: 3192 INIT_WORK(&switchdev_work->work, 3193 mlxsw_sp_switchdev_vxlan_fdb_event_work); 3194 err = mlxsw_sp_switchdev_vxlan_work_prepare(switchdev_work, 3195 info); 3196 if (err) 3197 goto err_vxlan_work_prepare; 3198 dev_hold(dev); 3199 break; 3200 default: 3201 kfree(switchdev_work); 3202 return NOTIFY_DONE; 3203 } 3204 3205 mlxsw_core_schedule_work(&switchdev_work->work); 3206 3207 return NOTIFY_DONE; 3208 3209 err_vxlan_work_prepare: 3210 err_addr_alloc: 3211 kfree(switchdev_work); 3212 return NOTIFY_BAD; 3213 } 3214 3215 struct notifier_block mlxsw_sp_switchdev_notifier = { 3216 .notifier_call = mlxsw_sp_switchdev_event, 3217 }; 3218 3219 static int 3220 mlxsw_sp_switchdev_vxlan_vlan_add(struct mlxsw_sp *mlxsw_sp, 3221 struct mlxsw_sp_bridge_device *bridge_device, 3222 const struct net_device *vxlan_dev, u16 vid, 3223 bool flag_untagged, bool flag_pvid, 3224 struct netlink_ext_ack *extack) 3225 { 3226 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev); 3227 __be32 vni = vxlan->cfg.vni; 3228 struct mlxsw_sp_fid *fid; 3229 u16 old_vid; 3230 int err; 3231 3232 /* We cannot have the same VLAN as PVID and egress untagged on multiple 3233 * VxLAN devices. Note that we get this notification before the VLAN is 3234 * actually added to the bridge's database, so it is not possible for 3235 * the lookup function to return 'vxlan_dev' 3236 */ 3237 if (flag_untagged && flag_pvid && 3238 mlxsw_sp_bridge_8021q_vxlan_dev_find(bridge_device->dev, vid)) { 3239 NL_SET_ERR_MSG_MOD(extack, "VLAN already mapped to a different VNI"); 3240 return -EINVAL; 3241 } 3242 3243 if (!netif_running(vxlan_dev)) 3244 return 0; 3245 3246 /* First case: FID is not associated with this VNI, but the new VLAN 3247 * is both PVID and egress untagged. Need to enable NVE on the FID, if 3248 * it exists 3249 */ 3250 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni); 3251 if (!fid) { 3252 if (!flag_untagged || !flag_pvid) 3253 return 0; 3254 return mlxsw_sp_bridge_8021q_vxlan_join(bridge_device, 3255 vxlan_dev, vid, extack); 3256 } 3257 3258 /* Second case: FID is associated with the VNI and the VLAN associated 3259 * with the FID is the same as the notified VLAN. This means the flags 3260 * (PVID / egress untagged) were toggled and that NVE should be 3261 * disabled on the FID 3262 */ 3263 old_vid = mlxsw_sp_fid_8021q_vid(fid); 3264 if (vid == old_vid) { 3265 if (WARN_ON(flag_untagged && flag_pvid)) { 3266 mlxsw_sp_fid_put(fid); 3267 return -EINVAL; 3268 } 3269 mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev); 3270 mlxsw_sp_fid_put(fid); 3271 return 0; 3272 } 3273 3274 /* Third case: A new VLAN was configured on the VxLAN device, but this 3275 * VLAN is not PVID, so there is nothing to do. 3276 */ 3277 if (!flag_pvid) { 3278 mlxsw_sp_fid_put(fid); 3279 return 0; 3280 } 3281 3282 /* Fourth case: Thew new VLAN is PVID, which means the VLAN currently 3283 * mapped to the VNI should be unmapped 3284 */ 3285 mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev); 3286 mlxsw_sp_fid_put(fid); 3287 3288 /* Fifth case: The new VLAN is also egress untagged, which means the 3289 * VLAN needs to be mapped to the VNI 3290 */ 3291 if (!flag_untagged) 3292 return 0; 3293 3294 err = mlxsw_sp_bridge_8021q_vxlan_join(bridge_device, vxlan_dev, vid, 3295 extack); 3296 if (err) 3297 goto err_vxlan_join; 3298 3299 return 0; 3300 3301 err_vxlan_join: 3302 mlxsw_sp_bridge_8021q_vxlan_join(bridge_device, vxlan_dev, old_vid, 3303 NULL); 3304 return err; 3305 } 3306 3307 static void 3308 mlxsw_sp_switchdev_vxlan_vlan_del(struct mlxsw_sp *mlxsw_sp, 3309 struct mlxsw_sp_bridge_device *bridge_device, 3310 const struct net_device *vxlan_dev, u16 vid) 3311 { 3312 struct vxlan_dev *vxlan = netdev_priv(vxlan_dev); 3313 __be32 vni = vxlan->cfg.vni; 3314 struct mlxsw_sp_fid *fid; 3315 3316 if (!netif_running(vxlan_dev)) 3317 return; 3318 3319 fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni); 3320 if (!fid) 3321 return; 3322 3323 /* A different VLAN than the one mapped to the VNI is deleted */ 3324 if (mlxsw_sp_fid_8021q_vid(fid) != vid) 3325 goto out; 3326 3327 mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev); 3328 3329 out: 3330 mlxsw_sp_fid_put(fid); 3331 } 3332 3333 static int 3334 mlxsw_sp_switchdev_vxlan_vlans_add(struct net_device *vxlan_dev, 3335 struct switchdev_notifier_port_obj_info * 3336 port_obj_info) 3337 { 3338 struct switchdev_obj_port_vlan *vlan = 3339 SWITCHDEV_OBJ_PORT_VLAN(port_obj_info->obj); 3340 bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED; 3341 bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID; 3342 struct switchdev_trans *trans = port_obj_info->trans; 3343 struct mlxsw_sp_bridge_device *bridge_device; 3344 struct netlink_ext_ack *extack; 3345 struct mlxsw_sp *mlxsw_sp; 3346 struct net_device *br_dev; 3347 u16 vid; 3348 3349 extack = switchdev_notifier_info_to_extack(&port_obj_info->info); 3350 br_dev = netdev_master_upper_dev_get(vxlan_dev); 3351 if (!br_dev) 3352 return 0; 3353 3354 mlxsw_sp = mlxsw_sp_lower_get(br_dev); 3355 if (!mlxsw_sp) 3356 return 0; 3357 3358 port_obj_info->handled = true; 3359 3360 if (switchdev_trans_ph_commit(trans)) 3361 return 0; 3362 3363 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); 3364 if (!bridge_device) 3365 return -EINVAL; 3366 3367 if (!bridge_device->vlan_enabled) 3368 return 0; 3369 3370 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) { 3371 int err; 3372 3373 err = mlxsw_sp_switchdev_vxlan_vlan_add(mlxsw_sp, bridge_device, 3374 vxlan_dev, vid, 3375 flag_untagged, 3376 flag_pvid, extack); 3377 if (err) 3378 return err; 3379 } 3380 3381 return 0; 3382 } 3383 3384 static void 3385 mlxsw_sp_switchdev_vxlan_vlans_del(struct net_device *vxlan_dev, 3386 struct switchdev_notifier_port_obj_info * 3387 port_obj_info) 3388 { 3389 struct switchdev_obj_port_vlan *vlan = 3390 SWITCHDEV_OBJ_PORT_VLAN(port_obj_info->obj); 3391 struct mlxsw_sp_bridge_device *bridge_device; 3392 struct mlxsw_sp *mlxsw_sp; 3393 struct net_device *br_dev; 3394 u16 vid; 3395 3396 br_dev = netdev_master_upper_dev_get(vxlan_dev); 3397 if (!br_dev) 3398 return; 3399 3400 mlxsw_sp = mlxsw_sp_lower_get(br_dev); 3401 if (!mlxsw_sp) 3402 return; 3403 3404 port_obj_info->handled = true; 3405 3406 bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev); 3407 if (!bridge_device) 3408 return; 3409 3410 if (!bridge_device->vlan_enabled) 3411 return; 3412 3413 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) 3414 mlxsw_sp_switchdev_vxlan_vlan_del(mlxsw_sp, bridge_device, 3415 vxlan_dev, vid); 3416 } 3417 3418 static int 3419 mlxsw_sp_switchdev_handle_vxlan_obj_add(struct net_device *vxlan_dev, 3420 struct switchdev_notifier_port_obj_info * 3421 port_obj_info) 3422 { 3423 int err = 0; 3424 3425 switch (port_obj_info->obj->id) { 3426 case SWITCHDEV_OBJ_ID_PORT_VLAN: 3427 err = mlxsw_sp_switchdev_vxlan_vlans_add(vxlan_dev, 3428 port_obj_info); 3429 break; 3430 default: 3431 break; 3432 } 3433 3434 return err; 3435 } 3436 3437 static void 3438 mlxsw_sp_switchdev_handle_vxlan_obj_del(struct net_device *vxlan_dev, 3439 struct switchdev_notifier_port_obj_info * 3440 port_obj_info) 3441 { 3442 switch (port_obj_info->obj->id) { 3443 case SWITCHDEV_OBJ_ID_PORT_VLAN: 3444 mlxsw_sp_switchdev_vxlan_vlans_del(vxlan_dev, port_obj_info); 3445 break; 3446 default: 3447 break; 3448 } 3449 } 3450 3451 static int mlxsw_sp_switchdev_blocking_event(struct notifier_block *unused, 3452 unsigned long event, void *ptr) 3453 { 3454 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 3455 int err = 0; 3456 3457 switch (event) { 3458 case SWITCHDEV_PORT_OBJ_ADD: 3459 if (netif_is_vxlan(dev)) 3460 err = mlxsw_sp_switchdev_handle_vxlan_obj_add(dev, ptr); 3461 else 3462 err = switchdev_handle_port_obj_add(dev, ptr, 3463 mlxsw_sp_port_dev_check, 3464 mlxsw_sp_port_obj_add); 3465 return notifier_from_errno(err); 3466 case SWITCHDEV_PORT_OBJ_DEL: 3467 if (netif_is_vxlan(dev)) 3468 mlxsw_sp_switchdev_handle_vxlan_obj_del(dev, ptr); 3469 else 3470 err = switchdev_handle_port_obj_del(dev, ptr, 3471 mlxsw_sp_port_dev_check, 3472 mlxsw_sp_port_obj_del); 3473 return notifier_from_errno(err); 3474 } 3475 3476 return NOTIFY_DONE; 3477 } 3478 3479 static struct notifier_block mlxsw_sp_switchdev_blocking_notifier = { 3480 .notifier_call = mlxsw_sp_switchdev_blocking_event, 3481 }; 3482 3483 u8 3484 mlxsw_sp_bridge_port_stp_state(struct mlxsw_sp_bridge_port *bridge_port) 3485 { 3486 return bridge_port->stp_state; 3487 } 3488 3489 static int mlxsw_sp_fdb_init(struct mlxsw_sp *mlxsw_sp) 3490 { 3491 struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge; 3492 struct notifier_block *nb; 3493 int err; 3494 3495 err = mlxsw_sp_ageing_set(mlxsw_sp, MLXSW_SP_DEFAULT_AGEING_TIME); 3496 if (err) { 3497 dev_err(mlxsw_sp->bus_info->dev, "Failed to set default ageing time\n"); 3498 return err; 3499 } 3500 3501 err = register_switchdev_notifier(&mlxsw_sp_switchdev_notifier); 3502 if (err) { 3503 dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev notifier\n"); 3504 return err; 3505 } 3506 3507 nb = &mlxsw_sp_switchdev_blocking_notifier; 3508 err = register_switchdev_blocking_notifier(nb); 3509 if (err) { 3510 dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev blocking notifier\n"); 3511 goto err_register_switchdev_blocking_notifier; 3512 } 3513 3514 INIT_DELAYED_WORK(&bridge->fdb_notify.dw, mlxsw_sp_fdb_notify_work); 3515 bridge->fdb_notify.interval = MLXSW_SP_DEFAULT_LEARNING_INTERVAL; 3516 mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp); 3517 return 0; 3518 3519 err_register_switchdev_blocking_notifier: 3520 unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier); 3521 return err; 3522 } 3523 3524 static void mlxsw_sp_fdb_fini(struct mlxsw_sp *mlxsw_sp) 3525 { 3526 struct notifier_block *nb; 3527 3528 cancel_delayed_work_sync(&mlxsw_sp->bridge->fdb_notify.dw); 3529 3530 nb = &mlxsw_sp_switchdev_blocking_notifier; 3531 unregister_switchdev_blocking_notifier(nb); 3532 3533 unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier); 3534 } 3535 3536 int mlxsw_sp_switchdev_init(struct mlxsw_sp *mlxsw_sp) 3537 { 3538 struct mlxsw_sp_bridge *bridge; 3539 3540 bridge = kzalloc(sizeof(*mlxsw_sp->bridge), GFP_KERNEL); 3541 if (!bridge) 3542 return -ENOMEM; 3543 mlxsw_sp->bridge = bridge; 3544 bridge->mlxsw_sp = mlxsw_sp; 3545 3546 INIT_LIST_HEAD(&mlxsw_sp->bridge->bridges_list); 3547 3548 bridge->bridge_8021q_ops = &mlxsw_sp_bridge_8021q_ops; 3549 bridge->bridge_8021d_ops = &mlxsw_sp_bridge_8021d_ops; 3550 3551 return mlxsw_sp_fdb_init(mlxsw_sp); 3552 } 3553 3554 void mlxsw_sp_switchdev_fini(struct mlxsw_sp *mlxsw_sp) 3555 { 3556 mlxsw_sp_fdb_fini(mlxsw_sp); 3557 WARN_ON(!list_empty(&mlxsw_sp->bridge->bridges_list)); 3558 kfree(mlxsw_sp->bridge); 3559 } 3560 3561 void mlxsw_sp_port_switchdev_init(struct mlxsw_sp_port *mlxsw_sp_port) 3562 { 3563 mlxsw_sp_port->dev->switchdev_ops = &mlxsw_sp_port_switchdev_ops; 3564 } 3565 3566 void mlxsw_sp_port_switchdev_fini(struct mlxsw_sp_port *mlxsw_sp_port) 3567 { 3568 } 3569