1 // SPDX-License-Identifier: GPL-2.0+ 2 3 #include <linux/if_bridge.h> 4 #include <net/switchdev.h> 5 6 #include "lan966x_main.h" 7 8 static struct notifier_block lan966x_netdevice_nb __read_mostly; 9 static struct notifier_block lan966x_switchdev_nb __read_mostly; 10 static struct notifier_block lan966x_switchdev_blocking_nb __read_mostly; 11 12 static void lan966x_port_set_mcast_ip_flood(struct lan966x_port *port, 13 u32 pgid_ip) 14 { 15 struct lan966x *lan966x = port->lan966x; 16 u32 flood_mask_ip; 17 18 flood_mask_ip = lan_rd(lan966x, ANA_PGID(pgid_ip)); 19 flood_mask_ip = ANA_PGID_PGID_GET(flood_mask_ip); 20 21 /* If mcast snooping is not enabled then use mcast flood mask 22 * to decide to enable multicast flooding or not. 23 */ 24 if (!port->mcast_ena) { 25 u32 flood_mask; 26 27 flood_mask = lan_rd(lan966x, ANA_PGID(PGID_MC)); 28 flood_mask = ANA_PGID_PGID_GET(flood_mask); 29 30 if (flood_mask & BIT(port->chip_port)) 31 flood_mask_ip |= BIT(port->chip_port); 32 else 33 flood_mask_ip &= ~BIT(port->chip_port); 34 } else { 35 flood_mask_ip &= ~BIT(port->chip_port); 36 } 37 38 lan_rmw(ANA_PGID_PGID_SET(flood_mask_ip), 39 ANA_PGID_PGID, 40 lan966x, ANA_PGID(pgid_ip)); 41 } 42 43 static void lan966x_port_set_mcast_flood(struct lan966x_port *port, 44 bool enabled) 45 { 46 u32 val = lan_rd(port->lan966x, ANA_PGID(PGID_MC)); 47 48 val = ANA_PGID_PGID_GET(val); 49 if (enabled) 50 val |= BIT(port->chip_port); 51 else 52 val &= ~BIT(port->chip_port); 53 54 lan_rmw(ANA_PGID_PGID_SET(val), 55 ANA_PGID_PGID, 56 port->lan966x, ANA_PGID(PGID_MC)); 57 58 if (!port->mcast_ena) { 59 lan966x_port_set_mcast_ip_flood(port, PGID_MCIPV4); 60 lan966x_port_set_mcast_ip_flood(port, PGID_MCIPV6); 61 } 62 } 63 64 static void lan966x_port_set_ucast_flood(struct lan966x_port *port, 65 bool enabled) 66 { 67 u32 val = lan_rd(port->lan966x, ANA_PGID(PGID_UC)); 68 69 val = ANA_PGID_PGID_GET(val); 70 if (enabled) 71 val |= BIT(port->chip_port); 72 else 73 val &= ~BIT(port->chip_port); 74 75 lan_rmw(ANA_PGID_PGID_SET(val), 76 ANA_PGID_PGID, 77 port->lan966x, ANA_PGID(PGID_UC)); 78 } 79 80 static void lan966x_port_set_bcast_flood(struct lan966x_port *port, 81 bool enabled) 82 { 83 u32 val = lan_rd(port->lan966x, ANA_PGID(PGID_BC)); 84 85 val = ANA_PGID_PGID_GET(val); 86 if (enabled) 87 val |= BIT(port->chip_port); 88 else 89 val &= ~BIT(port->chip_port); 90 91 lan_rmw(ANA_PGID_PGID_SET(val), 92 ANA_PGID_PGID, 93 port->lan966x, ANA_PGID(PGID_BC)); 94 } 95 96 static void lan966x_port_set_learning(struct lan966x_port *port, bool enabled) 97 { 98 lan_rmw(ANA_PORT_CFG_LEARN_ENA_SET(enabled), 99 ANA_PORT_CFG_LEARN_ENA, 100 port->lan966x, ANA_PORT_CFG(port->chip_port)); 101 102 port->learn_ena = enabled; 103 } 104 105 static void lan966x_port_bridge_flags(struct lan966x_port *port, 106 struct switchdev_brport_flags flags) 107 { 108 if (flags.mask & BR_MCAST_FLOOD) 109 lan966x_port_set_mcast_flood(port, 110 !!(flags.val & BR_MCAST_FLOOD)); 111 112 if (flags.mask & BR_FLOOD) 113 lan966x_port_set_ucast_flood(port, 114 !!(flags.val & BR_FLOOD)); 115 116 if (flags.mask & BR_BCAST_FLOOD) 117 lan966x_port_set_bcast_flood(port, 118 !!(flags.val & BR_BCAST_FLOOD)); 119 120 if (flags.mask & BR_LEARNING) 121 lan966x_port_set_learning(port, 122 !!(flags.val & BR_LEARNING)); 123 } 124 125 static int lan966x_port_pre_bridge_flags(struct lan966x_port *port, 126 struct switchdev_brport_flags flags) 127 { 128 if (flags.mask & ~(BR_MCAST_FLOOD | BR_FLOOD | BR_BCAST_FLOOD | 129 BR_LEARNING)) 130 return -EINVAL; 131 132 return 0; 133 } 134 135 static void lan966x_update_fwd_mask(struct lan966x *lan966x) 136 { 137 int i; 138 139 for (i = 0; i < lan966x->num_phys_ports; i++) { 140 struct lan966x_port *port = lan966x->ports[i]; 141 unsigned long mask = 0; 142 143 if (port && lan966x->bridge_fwd_mask & BIT(i)) 144 mask = lan966x->bridge_fwd_mask & ~BIT(i); 145 146 mask |= BIT(CPU_PORT); 147 148 lan_wr(ANA_PGID_PGID_SET(mask), 149 lan966x, ANA_PGID(PGID_SRC + i)); 150 } 151 } 152 153 static void lan966x_port_stp_state_set(struct lan966x_port *port, u8 state) 154 { 155 struct lan966x *lan966x = port->lan966x; 156 bool learn_ena = false; 157 158 if ((state == BR_STATE_FORWARDING || state == BR_STATE_LEARNING) && 159 port->learn_ena) 160 learn_ena = true; 161 162 if (state == BR_STATE_FORWARDING) 163 lan966x->bridge_fwd_mask |= BIT(port->chip_port); 164 else 165 lan966x->bridge_fwd_mask &= ~BIT(port->chip_port); 166 167 lan_rmw(ANA_PORT_CFG_LEARN_ENA_SET(learn_ena), 168 ANA_PORT_CFG_LEARN_ENA, 169 lan966x, ANA_PORT_CFG(port->chip_port)); 170 171 lan966x_update_fwd_mask(lan966x); 172 } 173 174 static void lan966x_port_ageing_set(struct lan966x_port *port, 175 unsigned long ageing_clock_t) 176 { 177 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t); 178 u32 ageing_time = jiffies_to_msecs(ageing_jiffies) / 1000; 179 180 lan966x_mac_set_ageing(port->lan966x, ageing_time); 181 } 182 183 static void lan966x_port_mc_set(struct lan966x_port *port, bool mcast_ena) 184 { 185 struct lan966x *lan966x = port->lan966x; 186 187 port->mcast_ena = mcast_ena; 188 if (mcast_ena) 189 lan966x_mdb_restore_entries(lan966x); 190 else 191 lan966x_mdb_clear_entries(lan966x); 192 193 lan_rmw(ANA_CPU_FWD_CFG_IGMP_REDIR_ENA_SET(mcast_ena) | 194 ANA_CPU_FWD_CFG_MLD_REDIR_ENA_SET(mcast_ena) | 195 ANA_CPU_FWD_CFG_IPMC_CTRL_COPY_ENA_SET(mcast_ena), 196 ANA_CPU_FWD_CFG_IGMP_REDIR_ENA | 197 ANA_CPU_FWD_CFG_MLD_REDIR_ENA | 198 ANA_CPU_FWD_CFG_IPMC_CTRL_COPY_ENA, 199 lan966x, ANA_CPU_FWD_CFG(port->chip_port)); 200 201 lan966x_port_set_mcast_ip_flood(port, PGID_MCIPV4); 202 lan966x_port_set_mcast_ip_flood(port, PGID_MCIPV6); 203 } 204 205 static int lan966x_port_attr_set(struct net_device *dev, const void *ctx, 206 const struct switchdev_attr *attr, 207 struct netlink_ext_ack *extack) 208 { 209 struct lan966x_port *port = netdev_priv(dev); 210 int err = 0; 211 212 if (ctx && ctx != port) 213 return 0; 214 215 switch (attr->id) { 216 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS: 217 lan966x_port_bridge_flags(port, attr->u.brport_flags); 218 break; 219 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS: 220 err = lan966x_port_pre_bridge_flags(port, attr->u.brport_flags); 221 break; 222 case SWITCHDEV_ATTR_ID_PORT_STP_STATE: 223 lan966x_port_stp_state_set(port, attr->u.stp_state); 224 break; 225 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME: 226 lan966x_port_ageing_set(port, attr->u.ageing_time); 227 break; 228 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING: 229 lan966x_vlan_port_set_vlan_aware(port, attr->u.vlan_filtering); 230 lan966x_vlan_port_apply(port); 231 break; 232 case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED: 233 lan966x_port_mc_set(port, !attr->u.mc_disabled); 234 break; 235 default: 236 err = -EOPNOTSUPP; 237 break; 238 } 239 240 return err; 241 } 242 243 static int lan966x_port_bridge_join(struct lan966x_port *port, 244 struct net_device *bridge, 245 struct netlink_ext_ack *extack) 246 { 247 struct switchdev_brport_flags flags = {0}; 248 struct lan966x *lan966x = port->lan966x; 249 struct net_device *dev = port->dev; 250 int err; 251 252 if (!lan966x->bridge_mask) { 253 lan966x->bridge = bridge; 254 } else { 255 if (lan966x->bridge != bridge) { 256 NL_SET_ERR_MSG_MOD(extack, "Not allow to add port to different bridge"); 257 return -ENODEV; 258 } 259 } 260 261 err = switchdev_bridge_port_offload(dev, dev, port, 262 &lan966x_switchdev_nb, 263 &lan966x_switchdev_blocking_nb, 264 false, extack); 265 if (err) 266 return err; 267 268 lan966x->bridge_mask |= BIT(port->chip_port); 269 270 flags.mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD; 271 flags.val = flags.mask; 272 lan966x_port_bridge_flags(port, flags); 273 274 return 0; 275 } 276 277 static void lan966x_port_bridge_leave(struct lan966x_port *port, 278 struct net_device *bridge) 279 { 280 struct switchdev_brport_flags flags = {0}; 281 struct lan966x *lan966x = port->lan966x; 282 283 flags.mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD; 284 flags.val = flags.mask & ~BR_LEARNING; 285 lan966x_port_bridge_flags(port, flags); 286 287 lan966x->bridge_mask &= ~BIT(port->chip_port); 288 289 if (!lan966x->bridge_mask) 290 lan966x->bridge = NULL; 291 292 /* Set the port back to host mode */ 293 lan966x_vlan_port_set_vlan_aware(port, false); 294 lan966x_vlan_port_set_vid(port, HOST_PVID, false, false); 295 lan966x_vlan_port_apply(port); 296 } 297 298 static int lan966x_port_changeupper(struct net_device *dev, 299 struct netdev_notifier_changeupper_info *info) 300 { 301 struct lan966x_port *port = netdev_priv(dev); 302 struct netlink_ext_ack *extack; 303 int err = 0; 304 305 extack = netdev_notifier_info_to_extack(&info->info); 306 307 if (netif_is_bridge_master(info->upper_dev)) { 308 if (info->linking) 309 err = lan966x_port_bridge_join(port, info->upper_dev, 310 extack); 311 else 312 lan966x_port_bridge_leave(port, info->upper_dev); 313 } 314 315 return err; 316 } 317 318 static int lan966x_port_prechangeupper(struct net_device *dev, 319 struct netdev_notifier_changeupper_info *info) 320 { 321 struct lan966x_port *port = netdev_priv(dev); 322 323 if (netif_is_bridge_master(info->upper_dev) && !info->linking) 324 switchdev_bridge_port_unoffload(port->dev, port, 325 NULL, NULL); 326 327 return NOTIFY_DONE; 328 } 329 330 static int lan966x_foreign_bridging_check(struct net_device *bridge, 331 struct netlink_ext_ack *extack) 332 { 333 struct lan966x *lan966x = NULL; 334 bool has_foreign = false; 335 struct net_device *dev; 336 struct list_head *iter; 337 338 if (!netif_is_bridge_master(bridge)) 339 return 0; 340 341 netdev_for_each_lower_dev(bridge, dev, iter) { 342 if (lan966x_netdevice_check(dev)) { 343 struct lan966x_port *port = netdev_priv(dev); 344 345 if (lan966x) { 346 /* Bridge already has at least one port of a 347 * lan966x switch inside it, check that it's 348 * the same instance of the driver. 349 */ 350 if (port->lan966x != lan966x) { 351 NL_SET_ERR_MSG_MOD(extack, 352 "Bridging between multiple lan966x switches disallowed"); 353 return -EINVAL; 354 } 355 } else { 356 /* This is the first lan966x port inside this 357 * bridge 358 */ 359 lan966x = port->lan966x; 360 } 361 } else { 362 has_foreign = true; 363 } 364 365 if (lan966x && has_foreign) { 366 NL_SET_ERR_MSG_MOD(extack, 367 "Bridging lan966x ports with foreign interfaces disallowed"); 368 return -EINVAL; 369 } 370 } 371 372 return 0; 373 } 374 375 static int lan966x_bridge_check(struct net_device *dev, 376 struct netdev_notifier_changeupper_info *info) 377 { 378 return lan966x_foreign_bridging_check(info->upper_dev, 379 info->info.extack); 380 } 381 382 static int lan966x_netdevice_port_event(struct net_device *dev, 383 struct notifier_block *nb, 384 unsigned long event, void *ptr) 385 { 386 int err = 0; 387 388 if (!lan966x_netdevice_check(dev)) { 389 if (event == NETDEV_CHANGEUPPER) 390 return lan966x_bridge_check(dev, ptr); 391 return 0; 392 } 393 394 switch (event) { 395 case NETDEV_PRECHANGEUPPER: 396 err = lan966x_port_prechangeupper(dev, ptr); 397 break; 398 case NETDEV_CHANGEUPPER: 399 err = lan966x_bridge_check(dev, ptr); 400 if (err) 401 return err; 402 403 err = lan966x_port_changeupper(dev, ptr); 404 break; 405 } 406 407 return err; 408 } 409 410 static int lan966x_netdevice_event(struct notifier_block *nb, 411 unsigned long event, void *ptr) 412 { 413 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 414 int ret; 415 416 ret = lan966x_netdevice_port_event(dev, nb, event, ptr); 417 418 return notifier_from_errno(ret); 419 } 420 421 /* We don't offload uppers such as LAG as bridge ports, so every device except 422 * the bridge itself is foreign. 423 */ 424 static bool lan966x_foreign_dev_check(const struct net_device *dev, 425 const struct net_device *foreign_dev) 426 { 427 struct lan966x_port *port = netdev_priv(dev); 428 struct lan966x *lan966x = port->lan966x; 429 430 if (netif_is_bridge_master(foreign_dev)) 431 if (lan966x->bridge == foreign_dev) 432 return false; 433 434 return true; 435 } 436 437 static int lan966x_switchdev_event(struct notifier_block *nb, 438 unsigned long event, void *ptr) 439 { 440 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 441 int err; 442 443 switch (event) { 444 case SWITCHDEV_PORT_ATTR_SET: 445 err = switchdev_handle_port_attr_set(dev, ptr, 446 lan966x_netdevice_check, 447 lan966x_port_attr_set); 448 return notifier_from_errno(err); 449 case SWITCHDEV_FDB_ADD_TO_DEVICE: 450 case SWITCHDEV_FDB_DEL_TO_DEVICE: 451 err = switchdev_handle_fdb_event_to_device(dev, event, ptr, 452 lan966x_netdevice_check, 453 lan966x_foreign_dev_check, 454 lan966x_handle_fdb); 455 return notifier_from_errno(err); 456 } 457 458 return NOTIFY_DONE; 459 } 460 461 static int lan966x_handle_port_vlan_add(struct lan966x_port *port, 462 const struct switchdev_obj *obj) 463 { 464 const struct switchdev_obj_port_vlan *v = SWITCHDEV_OBJ_PORT_VLAN(obj); 465 struct lan966x *lan966x = port->lan966x; 466 467 if (!netif_is_bridge_master(obj->orig_dev)) 468 lan966x_vlan_port_add_vlan(port, v->vid, 469 v->flags & BRIDGE_VLAN_INFO_PVID, 470 v->flags & BRIDGE_VLAN_INFO_UNTAGGED); 471 else 472 lan966x_vlan_cpu_add_vlan(lan966x, v->vid); 473 474 return 0; 475 } 476 477 static int lan966x_handle_port_obj_add(struct net_device *dev, const void *ctx, 478 const struct switchdev_obj *obj, 479 struct netlink_ext_ack *extack) 480 { 481 struct lan966x_port *port = netdev_priv(dev); 482 int err; 483 484 if (ctx && ctx != port) 485 return 0; 486 487 switch (obj->id) { 488 case SWITCHDEV_OBJ_ID_PORT_VLAN: 489 err = lan966x_handle_port_vlan_add(port, obj); 490 break; 491 case SWITCHDEV_OBJ_ID_PORT_MDB: 492 case SWITCHDEV_OBJ_ID_HOST_MDB: 493 err = lan966x_handle_port_mdb_add(port, obj); 494 break; 495 default: 496 err = -EOPNOTSUPP; 497 break; 498 } 499 500 return err; 501 } 502 503 static int lan966x_handle_port_vlan_del(struct lan966x_port *port, 504 const struct switchdev_obj *obj) 505 { 506 const struct switchdev_obj_port_vlan *v = SWITCHDEV_OBJ_PORT_VLAN(obj); 507 struct lan966x *lan966x = port->lan966x; 508 509 if (!netif_is_bridge_master(obj->orig_dev)) 510 lan966x_vlan_port_del_vlan(port, v->vid); 511 else 512 lan966x_vlan_cpu_del_vlan(lan966x, v->vid); 513 514 return 0; 515 } 516 517 static int lan966x_handle_port_obj_del(struct net_device *dev, const void *ctx, 518 const struct switchdev_obj *obj) 519 { 520 struct lan966x_port *port = netdev_priv(dev); 521 int err; 522 523 if (ctx && ctx != port) 524 return 0; 525 526 switch (obj->id) { 527 case SWITCHDEV_OBJ_ID_PORT_VLAN: 528 err = lan966x_handle_port_vlan_del(port, obj); 529 break; 530 case SWITCHDEV_OBJ_ID_PORT_MDB: 531 case SWITCHDEV_OBJ_ID_HOST_MDB: 532 err = lan966x_handle_port_mdb_del(port, obj); 533 break; 534 default: 535 err = -EOPNOTSUPP; 536 break; 537 } 538 539 return err; 540 } 541 542 static int lan966x_switchdev_blocking_event(struct notifier_block *nb, 543 unsigned long event, 544 void *ptr) 545 { 546 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 547 int err; 548 549 switch (event) { 550 case SWITCHDEV_PORT_OBJ_ADD: 551 err = switchdev_handle_port_obj_add(dev, ptr, 552 lan966x_netdevice_check, 553 lan966x_handle_port_obj_add); 554 return notifier_from_errno(err); 555 case SWITCHDEV_PORT_OBJ_DEL: 556 err = switchdev_handle_port_obj_del(dev, ptr, 557 lan966x_netdevice_check, 558 lan966x_handle_port_obj_del); 559 return notifier_from_errno(err); 560 case SWITCHDEV_PORT_ATTR_SET: 561 err = switchdev_handle_port_attr_set(dev, ptr, 562 lan966x_netdevice_check, 563 lan966x_port_attr_set); 564 return notifier_from_errno(err); 565 } 566 567 return NOTIFY_DONE; 568 } 569 570 static struct notifier_block lan966x_netdevice_nb __read_mostly = { 571 .notifier_call = lan966x_netdevice_event, 572 }; 573 574 static struct notifier_block lan966x_switchdev_nb __read_mostly = { 575 .notifier_call = lan966x_switchdev_event, 576 }; 577 578 static struct notifier_block lan966x_switchdev_blocking_nb __read_mostly = { 579 .notifier_call = lan966x_switchdev_blocking_event, 580 }; 581 582 void lan966x_register_notifier_blocks(void) 583 { 584 register_netdevice_notifier(&lan966x_netdevice_nb); 585 register_switchdev_notifier(&lan966x_switchdev_nb); 586 register_switchdev_blocking_notifier(&lan966x_switchdev_blocking_nb); 587 } 588 589 void lan966x_unregister_notifier_blocks(void) 590 { 591 unregister_switchdev_blocking_notifier(&lan966x_switchdev_blocking_nb); 592 unregister_switchdev_notifier(&lan966x_switchdev_nb); 593 unregister_netdevice_notifier(&lan966x_netdevice_nb); 594 } 595