1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Handling of a single switch chip, part of a switch fabric 4 * 5 * Copyright (c) 2017 Savoir-faire Linux Inc. 6 * Vivien Didelot <vivien.didelot@savoirfairelinux.com> 7 */ 8 9 #include <linux/if_bridge.h> 10 #include <linux/netdevice.h> 11 #include <linux/notifier.h> 12 #include <linux/if_vlan.h> 13 #include <net/switchdev.h> 14 15 #include "dsa_priv.h" 16 17 static unsigned int dsa_switch_fastest_ageing_time(struct dsa_switch *ds, 18 unsigned int ageing_time) 19 { 20 struct dsa_port *dp; 21 22 dsa_switch_for_each_port(dp, ds) 23 if (dp->ageing_time && dp->ageing_time < ageing_time) 24 ageing_time = dp->ageing_time; 25 26 return ageing_time; 27 } 28 29 static int dsa_switch_ageing_time(struct dsa_switch *ds, 30 struct dsa_notifier_ageing_time_info *info) 31 { 32 unsigned int ageing_time = info->ageing_time; 33 34 if (ds->ageing_time_min && ageing_time < ds->ageing_time_min) 35 return -ERANGE; 36 37 if (ds->ageing_time_max && ageing_time > ds->ageing_time_max) 38 return -ERANGE; 39 40 /* Program the fastest ageing time in case of multiple bridges */ 41 ageing_time = dsa_switch_fastest_ageing_time(ds, ageing_time); 42 43 if (ds->ops->set_ageing_time) 44 return ds->ops->set_ageing_time(ds, ageing_time); 45 46 return 0; 47 } 48 49 static bool dsa_port_mtu_match(struct dsa_port *dp, 50 struct dsa_notifier_mtu_info *info) 51 { 52 return dp == info->dp || dsa_port_is_dsa(dp) || dsa_port_is_cpu(dp); 53 } 54 55 static int dsa_switch_mtu(struct dsa_switch *ds, 56 struct dsa_notifier_mtu_info *info) 57 { 58 struct dsa_port *dp; 59 int ret; 60 61 if (!ds->ops->port_change_mtu) 62 return -EOPNOTSUPP; 63 64 dsa_switch_for_each_port(dp, ds) { 65 if (dsa_port_mtu_match(dp, info)) { 66 ret = ds->ops->port_change_mtu(ds, dp->index, 67 info->mtu); 68 if (ret) 69 return ret; 70 } 71 } 72 73 return 0; 74 } 75 76 static int dsa_switch_bridge_join(struct dsa_switch *ds, 77 struct dsa_notifier_bridge_info *info) 78 { 79 int err; 80 81 if (info->dp->ds == ds) { 82 if (!ds->ops->port_bridge_join) 83 return -EOPNOTSUPP; 84 85 err = ds->ops->port_bridge_join(ds, info->dp->index, 86 info->bridge, 87 &info->tx_fwd_offload, 88 info->extack); 89 if (err) 90 return err; 91 } 92 93 if (info->dp->ds != ds && ds->ops->crosschip_bridge_join) { 94 err = ds->ops->crosschip_bridge_join(ds, 95 info->dp->ds->dst->index, 96 info->dp->ds->index, 97 info->dp->index, 98 info->bridge, 99 info->extack); 100 if (err) 101 return err; 102 } 103 104 return 0; 105 } 106 107 static int dsa_switch_bridge_leave(struct dsa_switch *ds, 108 struct dsa_notifier_bridge_info *info) 109 { 110 if (info->dp->ds == ds && ds->ops->port_bridge_leave) 111 ds->ops->port_bridge_leave(ds, info->dp->index, info->bridge); 112 113 if (info->dp->ds != ds && ds->ops->crosschip_bridge_leave) 114 ds->ops->crosschip_bridge_leave(ds, info->dp->ds->dst->index, 115 info->dp->ds->index, 116 info->dp->index, 117 info->bridge); 118 119 return 0; 120 } 121 122 /* Matches for all upstream-facing ports (the CPU port and all upstream-facing 123 * DSA links) that sit between the targeted port on which the notifier was 124 * emitted and its dedicated CPU port. 125 */ 126 static bool dsa_port_host_address_match(struct dsa_port *dp, 127 const struct dsa_port *targeted_dp) 128 { 129 struct dsa_port *cpu_dp = targeted_dp->cpu_dp; 130 131 if (dsa_switch_is_upstream_of(dp->ds, targeted_dp->ds)) 132 return dp->index == dsa_towards_port(dp->ds, cpu_dp->ds->index, 133 cpu_dp->index); 134 135 return false; 136 } 137 138 static struct dsa_mac_addr *dsa_mac_addr_find(struct list_head *addr_list, 139 const unsigned char *addr, u16 vid, 140 struct dsa_db db) 141 { 142 struct dsa_mac_addr *a; 143 144 list_for_each_entry(a, addr_list, list) 145 if (ether_addr_equal(a->addr, addr) && a->vid == vid && 146 dsa_db_equal(&a->db, &db)) 147 return a; 148 149 return NULL; 150 } 151 152 static int dsa_port_do_mdb_add(struct dsa_port *dp, 153 const struct switchdev_obj_port_mdb *mdb, 154 struct dsa_db db) 155 { 156 struct dsa_switch *ds = dp->ds; 157 struct dsa_mac_addr *a; 158 int port = dp->index; 159 int err = 0; 160 161 /* No need to bother with refcounting for user ports */ 162 if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp))) 163 return ds->ops->port_mdb_add(ds, port, mdb, db); 164 165 mutex_lock(&dp->addr_lists_lock); 166 167 a = dsa_mac_addr_find(&dp->mdbs, mdb->addr, mdb->vid, db); 168 if (a) { 169 refcount_inc(&a->refcount); 170 goto out; 171 } 172 173 a = kzalloc(sizeof(*a), GFP_KERNEL); 174 if (!a) { 175 err = -ENOMEM; 176 goto out; 177 } 178 179 err = ds->ops->port_mdb_add(ds, port, mdb, db); 180 if (err) { 181 kfree(a); 182 goto out; 183 } 184 185 ether_addr_copy(a->addr, mdb->addr); 186 a->vid = mdb->vid; 187 a->db = db; 188 refcount_set(&a->refcount, 1); 189 list_add_tail(&a->list, &dp->mdbs); 190 191 out: 192 mutex_unlock(&dp->addr_lists_lock); 193 194 return err; 195 } 196 197 static int dsa_port_do_mdb_del(struct dsa_port *dp, 198 const struct switchdev_obj_port_mdb *mdb, 199 struct dsa_db db) 200 { 201 struct dsa_switch *ds = dp->ds; 202 struct dsa_mac_addr *a; 203 int port = dp->index; 204 int err = 0; 205 206 /* No need to bother with refcounting for user ports */ 207 if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp))) 208 return ds->ops->port_mdb_del(ds, port, mdb, db); 209 210 mutex_lock(&dp->addr_lists_lock); 211 212 a = dsa_mac_addr_find(&dp->mdbs, mdb->addr, mdb->vid, db); 213 if (!a) { 214 err = -ENOENT; 215 goto out; 216 } 217 218 if (!refcount_dec_and_test(&a->refcount)) 219 goto out; 220 221 err = ds->ops->port_mdb_del(ds, port, mdb, db); 222 if (err) { 223 refcount_set(&a->refcount, 1); 224 goto out; 225 } 226 227 list_del(&a->list); 228 kfree(a); 229 230 out: 231 mutex_unlock(&dp->addr_lists_lock); 232 233 return err; 234 } 235 236 static int dsa_port_do_fdb_add(struct dsa_port *dp, const unsigned char *addr, 237 u16 vid, struct dsa_db db) 238 { 239 struct dsa_switch *ds = dp->ds; 240 struct dsa_mac_addr *a; 241 int port = dp->index; 242 int err = 0; 243 244 /* No need to bother with refcounting for user ports */ 245 if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp))) 246 return ds->ops->port_fdb_add(ds, port, addr, vid, db); 247 248 mutex_lock(&dp->addr_lists_lock); 249 250 a = dsa_mac_addr_find(&dp->fdbs, addr, vid, db); 251 if (a) { 252 refcount_inc(&a->refcount); 253 goto out; 254 } 255 256 a = kzalloc(sizeof(*a), GFP_KERNEL); 257 if (!a) { 258 err = -ENOMEM; 259 goto out; 260 } 261 262 err = ds->ops->port_fdb_add(ds, port, addr, vid, db); 263 if (err) { 264 kfree(a); 265 goto out; 266 } 267 268 ether_addr_copy(a->addr, addr); 269 a->vid = vid; 270 a->db = db; 271 refcount_set(&a->refcount, 1); 272 list_add_tail(&a->list, &dp->fdbs); 273 274 out: 275 mutex_unlock(&dp->addr_lists_lock); 276 277 return err; 278 } 279 280 static int dsa_port_do_fdb_del(struct dsa_port *dp, const unsigned char *addr, 281 u16 vid, struct dsa_db db) 282 { 283 struct dsa_switch *ds = dp->ds; 284 struct dsa_mac_addr *a; 285 int port = dp->index; 286 int err = 0; 287 288 /* No need to bother with refcounting for user ports */ 289 if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp))) 290 return ds->ops->port_fdb_del(ds, port, addr, vid, db); 291 292 mutex_lock(&dp->addr_lists_lock); 293 294 a = dsa_mac_addr_find(&dp->fdbs, addr, vid, db); 295 if (!a) { 296 err = -ENOENT; 297 goto out; 298 } 299 300 if (!refcount_dec_and_test(&a->refcount)) 301 goto out; 302 303 err = ds->ops->port_fdb_del(ds, port, addr, vid, db); 304 if (err) { 305 refcount_set(&a->refcount, 1); 306 goto out; 307 } 308 309 list_del(&a->list); 310 kfree(a); 311 312 out: 313 mutex_unlock(&dp->addr_lists_lock); 314 315 return err; 316 } 317 318 static int dsa_switch_do_lag_fdb_add(struct dsa_switch *ds, struct dsa_lag *lag, 319 const unsigned char *addr, u16 vid, 320 struct dsa_db db) 321 { 322 struct dsa_mac_addr *a; 323 int err = 0; 324 325 mutex_lock(&lag->fdb_lock); 326 327 a = dsa_mac_addr_find(&lag->fdbs, addr, vid, db); 328 if (a) { 329 refcount_inc(&a->refcount); 330 goto out; 331 } 332 333 a = kzalloc(sizeof(*a), GFP_KERNEL); 334 if (!a) { 335 err = -ENOMEM; 336 goto out; 337 } 338 339 err = ds->ops->lag_fdb_add(ds, *lag, addr, vid, db); 340 if (err) { 341 kfree(a); 342 goto out; 343 } 344 345 ether_addr_copy(a->addr, addr); 346 a->vid = vid; 347 a->db = db; 348 refcount_set(&a->refcount, 1); 349 list_add_tail(&a->list, &lag->fdbs); 350 351 out: 352 mutex_unlock(&lag->fdb_lock); 353 354 return err; 355 } 356 357 static int dsa_switch_do_lag_fdb_del(struct dsa_switch *ds, struct dsa_lag *lag, 358 const unsigned char *addr, u16 vid, 359 struct dsa_db db) 360 { 361 struct dsa_mac_addr *a; 362 int err = 0; 363 364 mutex_lock(&lag->fdb_lock); 365 366 a = dsa_mac_addr_find(&lag->fdbs, addr, vid, db); 367 if (!a) { 368 err = -ENOENT; 369 goto out; 370 } 371 372 if (!refcount_dec_and_test(&a->refcount)) 373 goto out; 374 375 err = ds->ops->lag_fdb_del(ds, *lag, addr, vid, db); 376 if (err) { 377 refcount_set(&a->refcount, 1); 378 goto out; 379 } 380 381 list_del(&a->list); 382 kfree(a); 383 384 out: 385 mutex_unlock(&lag->fdb_lock); 386 387 return err; 388 } 389 390 static int dsa_switch_host_fdb_add(struct dsa_switch *ds, 391 struct dsa_notifier_fdb_info *info) 392 { 393 struct dsa_port *dp; 394 int err = 0; 395 396 if (!ds->ops->port_fdb_add) 397 return -EOPNOTSUPP; 398 399 dsa_switch_for_each_port(dp, ds) { 400 if (dsa_port_host_address_match(dp, info->dp)) { 401 err = dsa_port_do_fdb_add(dp, info->addr, info->vid, 402 info->db); 403 if (err) 404 break; 405 } 406 } 407 408 return err; 409 } 410 411 static int dsa_switch_host_fdb_del(struct dsa_switch *ds, 412 struct dsa_notifier_fdb_info *info) 413 { 414 struct dsa_port *dp; 415 int err = 0; 416 417 if (!ds->ops->port_fdb_del) 418 return -EOPNOTSUPP; 419 420 dsa_switch_for_each_port(dp, ds) { 421 if (dsa_port_host_address_match(dp, info->dp)) { 422 err = dsa_port_do_fdb_del(dp, info->addr, info->vid, 423 info->db); 424 if (err) 425 break; 426 } 427 } 428 429 return err; 430 } 431 432 static int dsa_switch_fdb_add(struct dsa_switch *ds, 433 struct dsa_notifier_fdb_info *info) 434 { 435 int port = dsa_towards_port(ds, info->dp->ds->index, info->dp->index); 436 struct dsa_port *dp = dsa_to_port(ds, port); 437 438 if (!ds->ops->port_fdb_add) 439 return -EOPNOTSUPP; 440 441 return dsa_port_do_fdb_add(dp, info->addr, info->vid, info->db); 442 } 443 444 static int dsa_switch_fdb_del(struct dsa_switch *ds, 445 struct dsa_notifier_fdb_info *info) 446 { 447 int port = dsa_towards_port(ds, info->dp->ds->index, info->dp->index); 448 struct dsa_port *dp = dsa_to_port(ds, port); 449 450 if (!ds->ops->port_fdb_del) 451 return -EOPNOTSUPP; 452 453 return dsa_port_do_fdb_del(dp, info->addr, info->vid, info->db); 454 } 455 456 static int dsa_switch_lag_fdb_add(struct dsa_switch *ds, 457 struct dsa_notifier_lag_fdb_info *info) 458 { 459 struct dsa_port *dp; 460 461 if (!ds->ops->lag_fdb_add) 462 return -EOPNOTSUPP; 463 464 /* Notify switch only if it has a port in this LAG */ 465 dsa_switch_for_each_port(dp, ds) 466 if (dsa_port_offloads_lag(dp, info->lag)) 467 return dsa_switch_do_lag_fdb_add(ds, info->lag, 468 info->addr, info->vid, 469 info->db); 470 471 return 0; 472 } 473 474 static int dsa_switch_lag_fdb_del(struct dsa_switch *ds, 475 struct dsa_notifier_lag_fdb_info *info) 476 { 477 struct dsa_port *dp; 478 479 if (!ds->ops->lag_fdb_del) 480 return -EOPNOTSUPP; 481 482 /* Notify switch only if it has a port in this LAG */ 483 dsa_switch_for_each_port(dp, ds) 484 if (dsa_port_offloads_lag(dp, info->lag)) 485 return dsa_switch_do_lag_fdb_del(ds, info->lag, 486 info->addr, info->vid, 487 info->db); 488 489 return 0; 490 } 491 492 static int dsa_switch_lag_change(struct dsa_switch *ds, 493 struct dsa_notifier_lag_info *info) 494 { 495 if (info->dp->ds == ds && ds->ops->port_lag_change) 496 return ds->ops->port_lag_change(ds, info->dp->index); 497 498 if (info->dp->ds != ds && ds->ops->crosschip_lag_change) 499 return ds->ops->crosschip_lag_change(ds, info->dp->ds->index, 500 info->dp->index); 501 502 return 0; 503 } 504 505 static int dsa_switch_lag_join(struct dsa_switch *ds, 506 struct dsa_notifier_lag_info *info) 507 { 508 if (info->dp->ds == ds && ds->ops->port_lag_join) 509 return ds->ops->port_lag_join(ds, info->dp->index, info->lag, 510 info->info); 511 512 if (info->dp->ds != ds && ds->ops->crosschip_lag_join) 513 return ds->ops->crosschip_lag_join(ds, info->dp->ds->index, 514 info->dp->index, info->lag, 515 info->info); 516 517 return -EOPNOTSUPP; 518 } 519 520 static int dsa_switch_lag_leave(struct dsa_switch *ds, 521 struct dsa_notifier_lag_info *info) 522 { 523 if (info->dp->ds == ds && ds->ops->port_lag_leave) 524 return ds->ops->port_lag_leave(ds, info->dp->index, info->lag); 525 526 if (info->dp->ds != ds && ds->ops->crosschip_lag_leave) 527 return ds->ops->crosschip_lag_leave(ds, info->dp->ds->index, 528 info->dp->index, info->lag); 529 530 return -EOPNOTSUPP; 531 } 532 533 static int dsa_switch_mdb_add(struct dsa_switch *ds, 534 struct dsa_notifier_mdb_info *info) 535 { 536 int port = dsa_towards_port(ds, info->dp->ds->index, info->dp->index); 537 struct dsa_port *dp = dsa_to_port(ds, port); 538 539 if (!ds->ops->port_mdb_add) 540 return -EOPNOTSUPP; 541 542 return dsa_port_do_mdb_add(dp, info->mdb, info->db); 543 } 544 545 static int dsa_switch_mdb_del(struct dsa_switch *ds, 546 struct dsa_notifier_mdb_info *info) 547 { 548 int port = dsa_towards_port(ds, info->dp->ds->index, info->dp->index); 549 struct dsa_port *dp = dsa_to_port(ds, port); 550 551 if (!ds->ops->port_mdb_del) 552 return -EOPNOTSUPP; 553 554 return dsa_port_do_mdb_del(dp, info->mdb, info->db); 555 } 556 557 static int dsa_switch_host_mdb_add(struct dsa_switch *ds, 558 struct dsa_notifier_mdb_info *info) 559 { 560 struct dsa_port *dp; 561 int err = 0; 562 563 if (!ds->ops->port_mdb_add) 564 return -EOPNOTSUPP; 565 566 dsa_switch_for_each_port(dp, ds) { 567 if (dsa_port_host_address_match(dp, info->dp)) { 568 err = dsa_port_do_mdb_add(dp, info->mdb, info->db); 569 if (err) 570 break; 571 } 572 } 573 574 return err; 575 } 576 577 static int dsa_switch_host_mdb_del(struct dsa_switch *ds, 578 struct dsa_notifier_mdb_info *info) 579 { 580 struct dsa_port *dp; 581 int err = 0; 582 583 if (!ds->ops->port_mdb_del) 584 return -EOPNOTSUPP; 585 586 dsa_switch_for_each_port(dp, ds) { 587 if (dsa_port_host_address_match(dp, info->dp)) { 588 err = dsa_port_do_mdb_del(dp, info->mdb, info->db); 589 if (err) 590 break; 591 } 592 } 593 594 return err; 595 } 596 597 /* Port VLANs match on the targeted port and on all DSA ports */ 598 static bool dsa_port_vlan_match(struct dsa_port *dp, 599 struct dsa_notifier_vlan_info *info) 600 { 601 return dsa_port_is_dsa(dp) || dp == info->dp; 602 } 603 604 /* Host VLANs match on the targeted port's CPU port, and on all DSA ports 605 * (upstream and downstream) of that switch and its upstream switches. 606 */ 607 static bool dsa_port_host_vlan_match(struct dsa_port *dp, 608 const struct dsa_port *targeted_dp) 609 { 610 struct dsa_port *cpu_dp = targeted_dp->cpu_dp; 611 612 if (dsa_switch_is_upstream_of(dp->ds, targeted_dp->ds)) 613 return dsa_port_is_dsa(dp) || dp == cpu_dp; 614 615 return false; 616 } 617 618 static struct dsa_vlan *dsa_vlan_find(struct list_head *vlan_list, 619 const struct switchdev_obj_port_vlan *vlan) 620 { 621 struct dsa_vlan *v; 622 623 list_for_each_entry(v, vlan_list, list) 624 if (v->vid == vlan->vid) 625 return v; 626 627 return NULL; 628 } 629 630 static int dsa_port_do_vlan_add(struct dsa_port *dp, 631 const struct switchdev_obj_port_vlan *vlan, 632 struct netlink_ext_ack *extack) 633 { 634 struct dsa_switch *ds = dp->ds; 635 int port = dp->index; 636 struct dsa_vlan *v; 637 int err = 0; 638 639 /* No need to bother with refcounting for user ports. */ 640 if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp))) 641 return ds->ops->port_vlan_add(ds, port, vlan, extack); 642 643 /* No need to propagate on shared ports the existing VLANs that were 644 * re-notified after just the flags have changed. This would cause a 645 * refcount bump which we need to avoid, since it unbalances the 646 * additions with the deletions. 647 */ 648 if (vlan->changed) 649 return 0; 650 651 mutex_lock(&dp->vlans_lock); 652 653 v = dsa_vlan_find(&dp->vlans, vlan); 654 if (v) { 655 refcount_inc(&v->refcount); 656 goto out; 657 } 658 659 v = kzalloc(sizeof(*v), GFP_KERNEL); 660 if (!v) { 661 err = -ENOMEM; 662 goto out; 663 } 664 665 err = ds->ops->port_vlan_add(ds, port, vlan, extack); 666 if (err) { 667 kfree(v); 668 goto out; 669 } 670 671 v->vid = vlan->vid; 672 refcount_set(&v->refcount, 1); 673 list_add_tail(&v->list, &dp->vlans); 674 675 out: 676 mutex_unlock(&dp->vlans_lock); 677 678 return err; 679 } 680 681 static int dsa_port_do_vlan_del(struct dsa_port *dp, 682 const struct switchdev_obj_port_vlan *vlan) 683 { 684 struct dsa_switch *ds = dp->ds; 685 int port = dp->index; 686 struct dsa_vlan *v; 687 int err = 0; 688 689 /* No need to bother with refcounting for user ports */ 690 if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp))) 691 return ds->ops->port_vlan_del(ds, port, vlan); 692 693 mutex_lock(&dp->vlans_lock); 694 695 v = dsa_vlan_find(&dp->vlans, vlan); 696 if (!v) { 697 err = -ENOENT; 698 goto out; 699 } 700 701 if (!refcount_dec_and_test(&v->refcount)) 702 goto out; 703 704 err = ds->ops->port_vlan_del(ds, port, vlan); 705 if (err) { 706 refcount_set(&v->refcount, 1); 707 goto out; 708 } 709 710 list_del(&v->list); 711 kfree(v); 712 713 out: 714 mutex_unlock(&dp->vlans_lock); 715 716 return err; 717 } 718 719 static int dsa_switch_vlan_add(struct dsa_switch *ds, 720 struct dsa_notifier_vlan_info *info) 721 { 722 struct dsa_port *dp; 723 int err; 724 725 if (!ds->ops->port_vlan_add) 726 return -EOPNOTSUPP; 727 728 dsa_switch_for_each_port(dp, ds) { 729 if (dsa_port_vlan_match(dp, info)) { 730 err = dsa_port_do_vlan_add(dp, info->vlan, 731 info->extack); 732 if (err) 733 return err; 734 } 735 } 736 737 return 0; 738 } 739 740 static int dsa_switch_vlan_del(struct dsa_switch *ds, 741 struct dsa_notifier_vlan_info *info) 742 { 743 struct dsa_port *dp; 744 int err; 745 746 if (!ds->ops->port_vlan_del) 747 return -EOPNOTSUPP; 748 749 dsa_switch_for_each_port(dp, ds) { 750 if (dsa_port_vlan_match(dp, info)) { 751 err = dsa_port_do_vlan_del(dp, info->vlan); 752 if (err) 753 return err; 754 } 755 } 756 757 return 0; 758 } 759 760 static int dsa_switch_host_vlan_add(struct dsa_switch *ds, 761 struct dsa_notifier_vlan_info *info) 762 { 763 struct dsa_port *dp; 764 int err; 765 766 if (!ds->ops->port_vlan_add) 767 return -EOPNOTSUPP; 768 769 dsa_switch_for_each_port(dp, ds) { 770 if (dsa_port_host_vlan_match(dp, info->dp)) { 771 err = dsa_port_do_vlan_add(dp, info->vlan, 772 info->extack); 773 if (err) 774 return err; 775 } 776 } 777 778 return 0; 779 } 780 781 static int dsa_switch_host_vlan_del(struct dsa_switch *ds, 782 struct dsa_notifier_vlan_info *info) 783 { 784 struct dsa_port *dp; 785 int err; 786 787 if (!ds->ops->port_vlan_del) 788 return -EOPNOTSUPP; 789 790 dsa_switch_for_each_port(dp, ds) { 791 if (dsa_port_host_vlan_match(dp, info->dp)) { 792 err = dsa_port_do_vlan_del(dp, info->vlan); 793 if (err) 794 return err; 795 } 796 } 797 798 return 0; 799 } 800 801 static int dsa_switch_change_tag_proto(struct dsa_switch *ds, 802 struct dsa_notifier_tag_proto_info *info) 803 { 804 const struct dsa_device_ops *tag_ops = info->tag_ops; 805 struct dsa_port *dp, *cpu_dp; 806 int err; 807 808 if (!ds->ops->change_tag_protocol) 809 return -EOPNOTSUPP; 810 811 ASSERT_RTNL(); 812 813 err = ds->ops->change_tag_protocol(ds, tag_ops->proto); 814 if (err) 815 return err; 816 817 dsa_switch_for_each_cpu_port(cpu_dp, ds) 818 dsa_port_set_tag_protocol(cpu_dp, tag_ops); 819 820 /* Now that changing the tag protocol can no longer fail, let's update 821 * the remaining bits which are "duplicated for faster access", and the 822 * bits that depend on the tagger, such as the MTU. 823 */ 824 dsa_switch_for_each_user_port(dp, ds) { 825 struct net_device *slave = dp->slave; 826 827 dsa_slave_setup_tagger(slave); 828 829 /* rtnl_mutex is held in dsa_tree_change_tag_proto */ 830 dsa_slave_change_mtu(slave, slave->mtu); 831 } 832 833 return 0; 834 } 835 836 /* We use the same cross-chip notifiers to inform both the tagger side, as well 837 * as the switch side, of connection and disconnection events. 838 * Since ds->tagger_data is owned by the tagger, it isn't a hard error if the 839 * switch side doesn't support connecting to this tagger, and therefore, the 840 * fact that we don't disconnect the tagger side doesn't constitute a memory 841 * leak: the tagger will still operate with persistent per-switch memory, just 842 * with the switch side unconnected to it. What does constitute a hard error is 843 * when the switch side supports connecting but fails. 844 */ 845 static int 846 dsa_switch_connect_tag_proto(struct dsa_switch *ds, 847 struct dsa_notifier_tag_proto_info *info) 848 { 849 const struct dsa_device_ops *tag_ops = info->tag_ops; 850 int err; 851 852 /* Notify the new tagger about the connection to this switch */ 853 if (tag_ops->connect) { 854 err = tag_ops->connect(ds); 855 if (err) 856 return err; 857 } 858 859 if (!ds->ops->connect_tag_protocol) 860 return -EOPNOTSUPP; 861 862 /* Notify the switch about the connection to the new tagger */ 863 err = ds->ops->connect_tag_protocol(ds, tag_ops->proto); 864 if (err) { 865 /* Revert the new tagger's connection to this tree */ 866 if (tag_ops->disconnect) 867 tag_ops->disconnect(ds); 868 return err; 869 } 870 871 return 0; 872 } 873 874 static int 875 dsa_switch_disconnect_tag_proto(struct dsa_switch *ds, 876 struct dsa_notifier_tag_proto_info *info) 877 { 878 const struct dsa_device_ops *tag_ops = info->tag_ops; 879 880 /* Notify the tagger about the disconnection from this switch */ 881 if (tag_ops->disconnect && ds->tagger_data) 882 tag_ops->disconnect(ds); 883 884 /* No need to notify the switch, since it shouldn't have any 885 * resources to tear down 886 */ 887 return 0; 888 } 889 890 static int 891 dsa_switch_master_state_change(struct dsa_switch *ds, 892 struct dsa_notifier_master_state_info *info) 893 { 894 if (!ds->ops->master_state_change) 895 return 0; 896 897 ds->ops->master_state_change(ds, info->master, info->operational); 898 899 return 0; 900 } 901 902 static int dsa_switch_event(struct notifier_block *nb, 903 unsigned long event, void *info) 904 { 905 struct dsa_switch *ds = container_of(nb, struct dsa_switch, nb); 906 int err; 907 908 switch (event) { 909 case DSA_NOTIFIER_AGEING_TIME: 910 err = dsa_switch_ageing_time(ds, info); 911 break; 912 case DSA_NOTIFIER_BRIDGE_JOIN: 913 err = dsa_switch_bridge_join(ds, info); 914 break; 915 case DSA_NOTIFIER_BRIDGE_LEAVE: 916 err = dsa_switch_bridge_leave(ds, info); 917 break; 918 case DSA_NOTIFIER_FDB_ADD: 919 err = dsa_switch_fdb_add(ds, info); 920 break; 921 case DSA_NOTIFIER_FDB_DEL: 922 err = dsa_switch_fdb_del(ds, info); 923 break; 924 case DSA_NOTIFIER_HOST_FDB_ADD: 925 err = dsa_switch_host_fdb_add(ds, info); 926 break; 927 case DSA_NOTIFIER_HOST_FDB_DEL: 928 err = dsa_switch_host_fdb_del(ds, info); 929 break; 930 case DSA_NOTIFIER_LAG_FDB_ADD: 931 err = dsa_switch_lag_fdb_add(ds, info); 932 break; 933 case DSA_NOTIFIER_LAG_FDB_DEL: 934 err = dsa_switch_lag_fdb_del(ds, info); 935 break; 936 case DSA_NOTIFIER_LAG_CHANGE: 937 err = dsa_switch_lag_change(ds, info); 938 break; 939 case DSA_NOTIFIER_LAG_JOIN: 940 err = dsa_switch_lag_join(ds, info); 941 break; 942 case DSA_NOTIFIER_LAG_LEAVE: 943 err = dsa_switch_lag_leave(ds, info); 944 break; 945 case DSA_NOTIFIER_MDB_ADD: 946 err = dsa_switch_mdb_add(ds, info); 947 break; 948 case DSA_NOTIFIER_MDB_DEL: 949 err = dsa_switch_mdb_del(ds, info); 950 break; 951 case DSA_NOTIFIER_HOST_MDB_ADD: 952 err = dsa_switch_host_mdb_add(ds, info); 953 break; 954 case DSA_NOTIFIER_HOST_MDB_DEL: 955 err = dsa_switch_host_mdb_del(ds, info); 956 break; 957 case DSA_NOTIFIER_VLAN_ADD: 958 err = dsa_switch_vlan_add(ds, info); 959 break; 960 case DSA_NOTIFIER_VLAN_DEL: 961 err = dsa_switch_vlan_del(ds, info); 962 break; 963 case DSA_NOTIFIER_HOST_VLAN_ADD: 964 err = dsa_switch_host_vlan_add(ds, info); 965 break; 966 case DSA_NOTIFIER_HOST_VLAN_DEL: 967 err = dsa_switch_host_vlan_del(ds, info); 968 break; 969 case DSA_NOTIFIER_MTU: 970 err = dsa_switch_mtu(ds, info); 971 break; 972 case DSA_NOTIFIER_TAG_PROTO: 973 err = dsa_switch_change_tag_proto(ds, info); 974 break; 975 case DSA_NOTIFIER_TAG_PROTO_CONNECT: 976 err = dsa_switch_connect_tag_proto(ds, info); 977 break; 978 case DSA_NOTIFIER_TAG_PROTO_DISCONNECT: 979 err = dsa_switch_disconnect_tag_proto(ds, info); 980 break; 981 case DSA_NOTIFIER_TAG_8021Q_VLAN_ADD: 982 err = dsa_switch_tag_8021q_vlan_add(ds, info); 983 break; 984 case DSA_NOTIFIER_TAG_8021Q_VLAN_DEL: 985 err = dsa_switch_tag_8021q_vlan_del(ds, info); 986 break; 987 case DSA_NOTIFIER_MASTER_STATE_CHANGE: 988 err = dsa_switch_master_state_change(ds, info); 989 break; 990 default: 991 err = -EOPNOTSUPP; 992 break; 993 } 994 995 if (err) 996 dev_dbg(ds->dev, "breaking chain for DSA event %lu (%d)\n", 997 event, err); 998 999 return notifier_from_errno(err); 1000 } 1001 1002 int dsa_switch_register_notifier(struct dsa_switch *ds) 1003 { 1004 ds->nb.notifier_call = dsa_switch_event; 1005 1006 return raw_notifier_chain_register(&ds->dst->nh, &ds->nb); 1007 } 1008 1009 void dsa_switch_unregister_notifier(struct dsa_switch *ds) 1010 { 1011 int err; 1012 1013 err = raw_notifier_chain_unregister(&ds->dst->nh, &ds->nb); 1014 if (err) 1015 dev_err(ds->dev, "failed to unregister notifier (%d)\n", err); 1016 } 1017