1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * net/dsa/user.c - user device handling 4 * Copyright (c) 2008-2009 Marvell Semiconductor 5 */ 6 7 #include <linux/list.h> 8 #include <linux/etherdevice.h> 9 #include <linux/netdevice.h> 10 #include <linux/phy.h> 11 #include <linux/phy_fixed.h> 12 #include <linux/phylink.h> 13 #include <linux/of_net.h> 14 #include <linux/of_mdio.h> 15 #include <linux/mdio.h> 16 #include <net/rtnetlink.h> 17 #include <net/pkt_cls.h> 18 #include <net/selftests.h> 19 #include <net/tc_act/tc_mirred.h> 20 #include <linux/if_bridge.h> 21 #include <linux/if_hsr.h> 22 #include <net/dcbnl.h> 23 #include <linux/netpoll.h> 24 #include <linux/string.h> 25 26 #include "conduit.h" 27 #include "dsa.h" 28 #include "netlink.h" 29 #include "port.h" 30 #include "switch.h" 31 #include "tag.h" 32 #include "user.h" 33 34 struct dsa_switchdev_event_work { 35 struct net_device *dev; 36 struct net_device *orig_dev; 37 struct work_struct work; 38 unsigned long event; 39 /* Specific for SWITCHDEV_FDB_ADD_TO_DEVICE and 40 * SWITCHDEV_FDB_DEL_TO_DEVICE 41 */ 42 unsigned char addr[ETH_ALEN]; 43 u16 vid; 44 bool host_addr; 45 }; 46 47 enum dsa_standalone_event { 48 DSA_UC_ADD, 49 DSA_UC_DEL, 50 DSA_MC_ADD, 51 DSA_MC_DEL, 52 }; 53 54 struct dsa_standalone_event_work { 55 struct work_struct work; 56 struct net_device *dev; 57 enum dsa_standalone_event event; 58 unsigned char addr[ETH_ALEN]; 59 u16 vid; 60 }; 61 62 struct dsa_host_vlan_rx_filtering_ctx { 63 struct net_device *dev; 64 const unsigned char *addr; 65 enum dsa_standalone_event event; 66 }; 67 68 static bool dsa_switch_supports_uc_filtering(struct dsa_switch *ds) 69 { 70 return ds->ops->port_fdb_add && ds->ops->port_fdb_del && 71 ds->fdb_isolation && !ds->vlan_filtering_is_global && 72 !ds->needs_standalone_vlan_filtering; 73 } 74 75 static bool dsa_switch_supports_mc_filtering(struct dsa_switch *ds) 76 { 77 return ds->ops->port_mdb_add && ds->ops->port_mdb_del && 78 ds->fdb_isolation && !ds->vlan_filtering_is_global && 79 !ds->needs_standalone_vlan_filtering; 80 } 81 82 static void dsa_user_standalone_event_work(struct work_struct *work) 83 { 84 struct dsa_standalone_event_work *standalone_work = 85 container_of(work, struct dsa_standalone_event_work, work); 86 const unsigned char *addr = standalone_work->addr; 87 struct net_device *dev = standalone_work->dev; 88 struct dsa_port *dp = dsa_user_to_port(dev); 89 struct switchdev_obj_port_mdb mdb; 90 struct dsa_switch *ds = dp->ds; 91 u16 vid = standalone_work->vid; 92 int err; 93 94 switch (standalone_work->event) { 95 case DSA_UC_ADD: 96 err = dsa_port_standalone_host_fdb_add(dp, addr, vid); 97 if (err) { 98 dev_err(ds->dev, 99 "port %d failed to add %pM vid %d to fdb: %d\n", 100 dp->index, addr, vid, err); 101 break; 102 } 103 break; 104 105 case DSA_UC_DEL: 106 err = dsa_port_standalone_host_fdb_del(dp, addr, vid); 107 if (err) { 108 dev_err(ds->dev, 109 "port %d failed to delete %pM vid %d from fdb: %d\n", 110 dp->index, addr, vid, err); 111 } 112 113 break; 114 case DSA_MC_ADD: 115 ether_addr_copy(mdb.addr, addr); 116 mdb.vid = vid; 117 118 err = dsa_port_standalone_host_mdb_add(dp, &mdb); 119 if (err) { 120 dev_err(ds->dev, 121 "port %d failed to add %pM vid %d to mdb: %d\n", 122 dp->index, addr, vid, err); 123 break; 124 } 125 break; 126 case DSA_MC_DEL: 127 ether_addr_copy(mdb.addr, addr); 128 mdb.vid = vid; 129 130 err = dsa_port_standalone_host_mdb_del(dp, &mdb); 131 if (err) { 132 dev_err(ds->dev, 133 "port %d failed to delete %pM vid %d from mdb: %d\n", 134 dp->index, addr, vid, err); 135 } 136 137 break; 138 } 139 140 kfree(standalone_work); 141 } 142 143 static int dsa_user_schedule_standalone_work(struct net_device *dev, 144 enum dsa_standalone_event event, 145 const unsigned char *addr, 146 u16 vid) 147 { 148 struct dsa_standalone_event_work *standalone_work; 149 150 standalone_work = kzalloc(sizeof(*standalone_work), GFP_ATOMIC); 151 if (!standalone_work) 152 return -ENOMEM; 153 154 INIT_WORK(&standalone_work->work, dsa_user_standalone_event_work); 155 standalone_work->event = event; 156 standalone_work->dev = dev; 157 158 ether_addr_copy(standalone_work->addr, addr); 159 standalone_work->vid = vid; 160 161 dsa_schedule_work(&standalone_work->work); 162 163 return 0; 164 } 165 166 static int dsa_user_host_vlan_rx_filtering(void *arg, int vid) 167 { 168 struct dsa_host_vlan_rx_filtering_ctx *ctx = arg; 169 170 return dsa_user_schedule_standalone_work(ctx->dev, ctx->event, 171 ctx->addr, vid); 172 } 173 174 static int dsa_user_vlan_for_each(struct net_device *dev, 175 int (*cb)(void *arg, int vid), void *arg) 176 { 177 struct dsa_port *dp = dsa_user_to_port(dev); 178 struct dsa_vlan *v; 179 int err; 180 181 lockdep_assert_held(&dev->addr_list_lock); 182 183 err = cb(arg, 0); 184 if (err) 185 return err; 186 187 list_for_each_entry(v, &dp->user_vlans, list) { 188 err = cb(arg, v->vid); 189 if (err) 190 return err; 191 } 192 193 return 0; 194 } 195 196 static int dsa_user_sync_uc(struct net_device *dev, 197 const unsigned char *addr) 198 { 199 struct net_device *conduit = dsa_user_to_conduit(dev); 200 struct dsa_port *dp = dsa_user_to_port(dev); 201 struct dsa_host_vlan_rx_filtering_ctx ctx = { 202 .dev = dev, 203 .addr = addr, 204 .event = DSA_UC_ADD, 205 }; 206 207 dev_uc_add(conduit, addr); 208 209 if (!dsa_switch_supports_uc_filtering(dp->ds)) 210 return 0; 211 212 return dsa_user_vlan_for_each(dev, dsa_user_host_vlan_rx_filtering, 213 &ctx); 214 } 215 216 static int dsa_user_unsync_uc(struct net_device *dev, 217 const unsigned char *addr) 218 { 219 struct net_device *conduit = dsa_user_to_conduit(dev); 220 struct dsa_port *dp = dsa_user_to_port(dev); 221 struct dsa_host_vlan_rx_filtering_ctx ctx = { 222 .dev = dev, 223 .addr = addr, 224 .event = DSA_UC_DEL, 225 }; 226 227 dev_uc_del(conduit, addr); 228 229 if (!dsa_switch_supports_uc_filtering(dp->ds)) 230 return 0; 231 232 return dsa_user_vlan_for_each(dev, dsa_user_host_vlan_rx_filtering, 233 &ctx); 234 } 235 236 static int dsa_user_sync_mc(struct net_device *dev, 237 const unsigned char *addr) 238 { 239 struct net_device *conduit = dsa_user_to_conduit(dev); 240 struct dsa_port *dp = dsa_user_to_port(dev); 241 struct dsa_host_vlan_rx_filtering_ctx ctx = { 242 .dev = dev, 243 .addr = addr, 244 .event = DSA_MC_ADD, 245 }; 246 247 dev_mc_add(conduit, addr); 248 249 if (!dsa_switch_supports_mc_filtering(dp->ds)) 250 return 0; 251 252 return dsa_user_vlan_for_each(dev, dsa_user_host_vlan_rx_filtering, 253 &ctx); 254 } 255 256 static int dsa_user_unsync_mc(struct net_device *dev, 257 const unsigned char *addr) 258 { 259 struct net_device *conduit = dsa_user_to_conduit(dev); 260 struct dsa_port *dp = dsa_user_to_port(dev); 261 struct dsa_host_vlan_rx_filtering_ctx ctx = { 262 .dev = dev, 263 .addr = addr, 264 .event = DSA_MC_DEL, 265 }; 266 267 dev_mc_del(conduit, addr); 268 269 if (!dsa_switch_supports_mc_filtering(dp->ds)) 270 return 0; 271 272 return dsa_user_vlan_for_each(dev, dsa_user_host_vlan_rx_filtering, 273 &ctx); 274 } 275 276 void dsa_user_sync_ha(struct net_device *dev) 277 { 278 struct dsa_port *dp = dsa_user_to_port(dev); 279 struct dsa_switch *ds = dp->ds; 280 struct netdev_hw_addr *ha; 281 282 netif_addr_lock_bh(dev); 283 284 netdev_for_each_synced_mc_addr(ha, dev) 285 dsa_user_sync_mc(dev, ha->addr); 286 287 netdev_for_each_synced_uc_addr(ha, dev) 288 dsa_user_sync_uc(dev, ha->addr); 289 290 netif_addr_unlock_bh(dev); 291 292 if (dsa_switch_supports_uc_filtering(ds) || 293 dsa_switch_supports_mc_filtering(ds)) 294 dsa_flush_workqueue(); 295 } 296 297 void dsa_user_unsync_ha(struct net_device *dev) 298 { 299 struct dsa_port *dp = dsa_user_to_port(dev); 300 struct dsa_switch *ds = dp->ds; 301 struct netdev_hw_addr *ha; 302 303 netif_addr_lock_bh(dev); 304 305 netdev_for_each_synced_uc_addr(ha, dev) 306 dsa_user_unsync_uc(dev, ha->addr); 307 308 netdev_for_each_synced_mc_addr(ha, dev) 309 dsa_user_unsync_mc(dev, ha->addr); 310 311 netif_addr_unlock_bh(dev); 312 313 if (dsa_switch_supports_uc_filtering(ds) || 314 dsa_switch_supports_mc_filtering(ds)) 315 dsa_flush_workqueue(); 316 } 317 318 /* user mii_bus handling ***************************************************/ 319 static int dsa_user_phy_read(struct mii_bus *bus, int addr, int reg) 320 { 321 struct dsa_switch *ds = bus->priv; 322 323 if (ds->phys_mii_mask & (1 << addr)) 324 return ds->ops->phy_read(ds, addr, reg); 325 326 return 0xffff; 327 } 328 329 static int dsa_user_phy_write(struct mii_bus *bus, int addr, int reg, u16 val) 330 { 331 struct dsa_switch *ds = bus->priv; 332 333 if (ds->phys_mii_mask & (1 << addr)) 334 return ds->ops->phy_write(ds, addr, reg, val); 335 336 return 0; 337 } 338 339 void dsa_user_mii_bus_init(struct dsa_switch *ds) 340 { 341 ds->user_mii_bus->priv = (void *)ds; 342 ds->user_mii_bus->name = "dsa user smi"; 343 ds->user_mii_bus->read = dsa_user_phy_read; 344 ds->user_mii_bus->write = dsa_user_phy_write; 345 snprintf(ds->user_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d.%d", 346 ds->dst->index, ds->index); 347 ds->user_mii_bus->parent = ds->dev; 348 ds->user_mii_bus->phy_mask = ~ds->phys_mii_mask; 349 } 350 351 352 /* user device handling ****************************************************/ 353 static int dsa_user_get_iflink(const struct net_device *dev) 354 { 355 return READ_ONCE(dsa_user_to_conduit(dev)->ifindex); 356 } 357 358 int dsa_user_host_uc_install(struct net_device *dev, const u8 *addr) 359 { 360 struct net_device *conduit = dsa_user_to_conduit(dev); 361 struct dsa_port *dp = dsa_user_to_port(dev); 362 struct dsa_switch *ds = dp->ds; 363 int err; 364 365 if (dsa_switch_supports_uc_filtering(ds)) { 366 err = dsa_port_standalone_host_fdb_add(dp, addr, 0); 367 if (err) 368 goto out; 369 } 370 371 if (!ether_addr_equal(addr, conduit->dev_addr)) { 372 err = dev_uc_add(conduit, addr); 373 if (err < 0) 374 goto del_host_addr; 375 } 376 377 return 0; 378 379 del_host_addr: 380 if (dsa_switch_supports_uc_filtering(ds)) 381 dsa_port_standalone_host_fdb_del(dp, addr, 0); 382 out: 383 return err; 384 } 385 386 void dsa_user_host_uc_uninstall(struct net_device *dev) 387 { 388 struct net_device *conduit = dsa_user_to_conduit(dev); 389 struct dsa_port *dp = dsa_user_to_port(dev); 390 struct dsa_switch *ds = dp->ds; 391 392 if (!ether_addr_equal(dev->dev_addr, conduit->dev_addr)) 393 dev_uc_del(conduit, dev->dev_addr); 394 395 if (dsa_switch_supports_uc_filtering(ds)) 396 dsa_port_standalone_host_fdb_del(dp, dev->dev_addr, 0); 397 } 398 399 static int dsa_user_open(struct net_device *dev) 400 { 401 struct net_device *conduit = dsa_user_to_conduit(dev); 402 struct dsa_port *dp = dsa_user_to_port(dev); 403 int err; 404 405 err = dev_open(conduit, NULL); 406 if (err < 0) { 407 netdev_err(dev, "failed to open conduit %s\n", conduit->name); 408 goto out; 409 } 410 411 err = dsa_user_host_uc_install(dev, dev->dev_addr); 412 if (err) 413 goto out; 414 415 err = dsa_port_enable_rt(dp, dev->phydev); 416 if (err) 417 goto out_del_host_uc; 418 419 return 0; 420 421 out_del_host_uc: 422 dsa_user_host_uc_uninstall(dev); 423 out: 424 return err; 425 } 426 427 static int dsa_user_close(struct net_device *dev) 428 { 429 struct dsa_port *dp = dsa_user_to_port(dev); 430 431 dsa_port_disable_rt(dp); 432 433 dsa_user_host_uc_uninstall(dev); 434 435 return 0; 436 } 437 438 static void dsa_user_manage_host_flood(struct net_device *dev) 439 { 440 bool mc = dev->flags & (IFF_PROMISC | IFF_ALLMULTI); 441 struct dsa_port *dp = dsa_user_to_port(dev); 442 bool uc = dev->flags & IFF_PROMISC; 443 444 dsa_port_set_host_flood(dp, uc, mc); 445 } 446 447 static void dsa_user_change_rx_flags(struct net_device *dev, int change) 448 { 449 struct net_device *conduit = dsa_user_to_conduit(dev); 450 struct dsa_port *dp = dsa_user_to_port(dev); 451 struct dsa_switch *ds = dp->ds; 452 453 if (change & IFF_ALLMULTI) 454 dev_set_allmulti(conduit, 455 dev->flags & IFF_ALLMULTI ? 1 : -1); 456 if (change & IFF_PROMISC) 457 dev_set_promiscuity(conduit, 458 dev->flags & IFF_PROMISC ? 1 : -1); 459 460 if (dsa_switch_supports_uc_filtering(ds) && 461 dsa_switch_supports_mc_filtering(ds)) 462 dsa_user_manage_host_flood(dev); 463 } 464 465 static void dsa_user_set_rx_mode(struct net_device *dev) 466 { 467 __dev_mc_sync(dev, dsa_user_sync_mc, dsa_user_unsync_mc); 468 __dev_uc_sync(dev, dsa_user_sync_uc, dsa_user_unsync_uc); 469 } 470 471 static int dsa_user_set_mac_address(struct net_device *dev, void *a) 472 { 473 struct dsa_port *dp = dsa_user_to_port(dev); 474 struct dsa_switch *ds = dp->ds; 475 struct sockaddr *addr = a; 476 int err; 477 478 if (!is_valid_ether_addr(addr->sa_data)) 479 return -EADDRNOTAVAIL; 480 481 if (ds->ops->port_set_mac_address) { 482 err = ds->ops->port_set_mac_address(ds, dp->index, 483 addr->sa_data); 484 if (err) 485 return err; 486 } 487 488 /* If the port is down, the address isn't synced yet to hardware or 489 * to the DSA conduit, so there is nothing to change. 490 */ 491 if (!(dev->flags & IFF_UP)) 492 goto out_change_dev_addr; 493 494 err = dsa_user_host_uc_install(dev, addr->sa_data); 495 if (err) 496 return err; 497 498 dsa_user_host_uc_uninstall(dev); 499 500 out_change_dev_addr: 501 eth_hw_addr_set(dev, addr->sa_data); 502 503 return 0; 504 } 505 506 struct dsa_user_dump_ctx { 507 struct net_device *dev; 508 struct sk_buff *skb; 509 struct netlink_callback *cb; 510 int idx; 511 }; 512 513 static int 514 dsa_user_port_fdb_do_dump(const unsigned char *addr, u16 vid, 515 bool is_static, void *data) 516 { 517 struct dsa_user_dump_ctx *dump = data; 518 struct ndo_fdb_dump_context *ctx = (void *)dump->cb->ctx; 519 u32 portid = NETLINK_CB(dump->cb->skb).portid; 520 u32 seq = dump->cb->nlh->nlmsg_seq; 521 struct nlmsghdr *nlh; 522 struct ndmsg *ndm; 523 524 if (dump->idx < ctx->fdb_idx) 525 goto skip; 526 527 nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH, 528 sizeof(*ndm), NLM_F_MULTI); 529 if (!nlh) 530 return -EMSGSIZE; 531 532 ndm = nlmsg_data(nlh); 533 ndm->ndm_family = AF_BRIDGE; 534 ndm->ndm_pad1 = 0; 535 ndm->ndm_pad2 = 0; 536 ndm->ndm_flags = NTF_SELF; 537 ndm->ndm_type = 0; 538 ndm->ndm_ifindex = dump->dev->ifindex; 539 ndm->ndm_state = is_static ? NUD_NOARP : NUD_REACHABLE; 540 541 if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, addr)) 542 goto nla_put_failure; 543 544 if (vid && nla_put_u16(dump->skb, NDA_VLAN, vid)) 545 goto nla_put_failure; 546 547 nlmsg_end(dump->skb, nlh); 548 549 skip: 550 dump->idx++; 551 return 0; 552 553 nla_put_failure: 554 nlmsg_cancel(dump->skb, nlh); 555 return -EMSGSIZE; 556 } 557 558 static int 559 dsa_user_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb, 560 struct net_device *dev, struct net_device *filter_dev, 561 int *idx) 562 { 563 struct dsa_port *dp = dsa_user_to_port(dev); 564 struct dsa_user_dump_ctx dump = { 565 .dev = dev, 566 .skb = skb, 567 .cb = cb, 568 .idx = *idx, 569 }; 570 int err; 571 572 err = dsa_port_fdb_dump(dp, dsa_user_port_fdb_do_dump, &dump); 573 *idx = dump.idx; 574 575 return err; 576 } 577 578 static int dsa_user_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 579 { 580 struct dsa_user_priv *p = netdev_priv(dev); 581 struct dsa_switch *ds = p->dp->ds; 582 int port = p->dp->index; 583 584 /* Pass through to switch driver if it supports timestamping */ 585 switch (cmd) { 586 case SIOCGHWTSTAMP: 587 if (ds->ops->port_hwtstamp_get) 588 return ds->ops->port_hwtstamp_get(ds, port, ifr); 589 break; 590 case SIOCSHWTSTAMP: 591 if (ds->ops->port_hwtstamp_set) 592 return ds->ops->port_hwtstamp_set(ds, port, ifr); 593 break; 594 } 595 596 return phylink_mii_ioctl(p->dp->pl, ifr, cmd); 597 } 598 599 static int dsa_user_port_attr_set(struct net_device *dev, const void *ctx, 600 const struct switchdev_attr *attr, 601 struct netlink_ext_ack *extack) 602 { 603 struct dsa_port *dp = dsa_user_to_port(dev); 604 int ret; 605 606 if (ctx && ctx != dp) 607 return 0; 608 609 switch (attr->id) { 610 case SWITCHDEV_ATTR_ID_PORT_STP_STATE: 611 if (!dsa_port_offloads_bridge_port(dp, attr->orig_dev)) 612 return -EOPNOTSUPP; 613 614 ret = dsa_port_set_state(dp, attr->u.stp_state, true); 615 break; 616 case SWITCHDEV_ATTR_ID_PORT_MST_STATE: 617 if (!dsa_port_offloads_bridge_port(dp, attr->orig_dev)) 618 return -EOPNOTSUPP; 619 620 ret = dsa_port_set_mst_state(dp, &attr->u.mst_state, extack); 621 break; 622 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING: 623 if (!dsa_port_offloads_bridge_dev(dp, attr->orig_dev)) 624 return -EOPNOTSUPP; 625 626 ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering, 627 extack); 628 break; 629 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME: 630 if (!dsa_port_offloads_bridge_dev(dp, attr->orig_dev)) 631 return -EOPNOTSUPP; 632 633 ret = dsa_port_ageing_time(dp, attr->u.ageing_time); 634 break; 635 case SWITCHDEV_ATTR_ID_BRIDGE_MST: 636 if (!dsa_port_offloads_bridge_dev(dp, attr->orig_dev)) 637 return -EOPNOTSUPP; 638 639 ret = dsa_port_mst_enable(dp, attr->u.mst, extack); 640 break; 641 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS: 642 if (!dsa_port_offloads_bridge_port(dp, attr->orig_dev)) 643 return -EOPNOTSUPP; 644 645 ret = dsa_port_pre_bridge_flags(dp, attr->u.brport_flags, 646 extack); 647 break; 648 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS: 649 if (!dsa_port_offloads_bridge_port(dp, attr->orig_dev)) 650 return -EOPNOTSUPP; 651 652 ret = dsa_port_bridge_flags(dp, attr->u.brport_flags, extack); 653 break; 654 case SWITCHDEV_ATTR_ID_VLAN_MSTI: 655 if (!dsa_port_offloads_bridge_dev(dp, attr->orig_dev)) 656 return -EOPNOTSUPP; 657 658 ret = dsa_port_vlan_msti(dp, &attr->u.vlan_msti); 659 break; 660 default: 661 ret = -EOPNOTSUPP; 662 break; 663 } 664 665 return ret; 666 } 667 668 /* Must be called under rcu_read_lock() */ 669 static int 670 dsa_user_vlan_check_for_8021q_uppers(struct net_device *user, 671 const struct switchdev_obj_port_vlan *vlan) 672 { 673 struct net_device *upper_dev; 674 struct list_head *iter; 675 676 netdev_for_each_upper_dev_rcu(user, upper_dev, iter) { 677 u16 vid; 678 679 if (!is_vlan_dev(upper_dev)) 680 continue; 681 682 vid = vlan_dev_vlan_id(upper_dev); 683 if (vid == vlan->vid) 684 return -EBUSY; 685 } 686 687 return 0; 688 } 689 690 static int dsa_user_vlan_add(struct net_device *dev, 691 const struct switchdev_obj *obj, 692 struct netlink_ext_ack *extack) 693 { 694 struct dsa_port *dp = dsa_user_to_port(dev); 695 struct switchdev_obj_port_vlan *vlan; 696 int err; 697 698 if (dsa_port_skip_vlan_configuration(dp)) { 699 NL_SET_ERR_MSG_MOD(extack, "skipping configuration of VLAN"); 700 return 0; 701 } 702 703 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj); 704 705 /* Deny adding a bridge VLAN when there is already an 802.1Q upper with 706 * the same VID. 707 */ 708 if (br_vlan_enabled(dsa_port_bridge_dev_get(dp))) { 709 rcu_read_lock(); 710 err = dsa_user_vlan_check_for_8021q_uppers(dev, vlan); 711 rcu_read_unlock(); 712 if (err) { 713 NL_SET_ERR_MSG_MOD(extack, 714 "Port already has a VLAN upper with this VID"); 715 return err; 716 } 717 } 718 719 return dsa_port_vlan_add(dp, vlan, extack); 720 } 721 722 /* Offload a VLAN installed on the bridge or on a foreign interface by 723 * installing it as a VLAN towards the CPU port. 724 */ 725 static int dsa_user_host_vlan_add(struct net_device *dev, 726 const struct switchdev_obj *obj, 727 struct netlink_ext_ack *extack) 728 { 729 struct dsa_port *dp = dsa_user_to_port(dev); 730 struct switchdev_obj_port_vlan vlan; 731 732 /* Do nothing if this is a software bridge */ 733 if (!dp->bridge) 734 return -EOPNOTSUPP; 735 736 if (dsa_port_skip_vlan_configuration(dp)) { 737 NL_SET_ERR_MSG_MOD(extack, "skipping configuration of VLAN"); 738 return 0; 739 } 740 741 vlan = *SWITCHDEV_OBJ_PORT_VLAN(obj); 742 743 /* Even though drivers often handle CPU membership in special ways, 744 * it doesn't make sense to program a PVID, so clear this flag. 745 */ 746 vlan.flags &= ~BRIDGE_VLAN_INFO_PVID; 747 748 return dsa_port_host_vlan_add(dp, &vlan, extack); 749 } 750 751 static int dsa_user_port_obj_add(struct net_device *dev, const void *ctx, 752 const struct switchdev_obj *obj, 753 struct netlink_ext_ack *extack) 754 { 755 struct dsa_port *dp = dsa_user_to_port(dev); 756 int err; 757 758 if (ctx && ctx != dp) 759 return 0; 760 761 switch (obj->id) { 762 case SWITCHDEV_OBJ_ID_PORT_MDB: 763 if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev)) 764 return -EOPNOTSUPP; 765 766 err = dsa_port_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj)); 767 break; 768 case SWITCHDEV_OBJ_ID_HOST_MDB: 769 if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev)) 770 return -EOPNOTSUPP; 771 772 err = dsa_port_bridge_host_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj)); 773 break; 774 case SWITCHDEV_OBJ_ID_PORT_VLAN: 775 if (dsa_port_offloads_bridge_port(dp, obj->orig_dev)) 776 err = dsa_user_vlan_add(dev, obj, extack); 777 else 778 err = dsa_user_host_vlan_add(dev, obj, extack); 779 break; 780 case SWITCHDEV_OBJ_ID_MRP: 781 if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev)) 782 return -EOPNOTSUPP; 783 784 err = dsa_port_mrp_add(dp, SWITCHDEV_OBJ_MRP(obj)); 785 break; 786 case SWITCHDEV_OBJ_ID_RING_ROLE_MRP: 787 if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev)) 788 return -EOPNOTSUPP; 789 790 err = dsa_port_mrp_add_ring_role(dp, 791 SWITCHDEV_OBJ_RING_ROLE_MRP(obj)); 792 break; 793 default: 794 err = -EOPNOTSUPP; 795 break; 796 } 797 798 return err; 799 } 800 801 static int dsa_user_vlan_del(struct net_device *dev, 802 const struct switchdev_obj *obj) 803 { 804 struct dsa_port *dp = dsa_user_to_port(dev); 805 struct switchdev_obj_port_vlan *vlan; 806 807 if (dsa_port_skip_vlan_configuration(dp)) 808 return 0; 809 810 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj); 811 812 return dsa_port_vlan_del(dp, vlan); 813 } 814 815 static int dsa_user_host_vlan_del(struct net_device *dev, 816 const struct switchdev_obj *obj) 817 { 818 struct dsa_port *dp = dsa_user_to_port(dev); 819 struct switchdev_obj_port_vlan *vlan; 820 821 /* Do nothing if this is a software bridge */ 822 if (!dp->bridge) 823 return -EOPNOTSUPP; 824 825 if (dsa_port_skip_vlan_configuration(dp)) 826 return 0; 827 828 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj); 829 830 return dsa_port_host_vlan_del(dp, vlan); 831 } 832 833 static int dsa_user_port_obj_del(struct net_device *dev, const void *ctx, 834 const struct switchdev_obj *obj) 835 { 836 struct dsa_port *dp = dsa_user_to_port(dev); 837 int err; 838 839 if (ctx && ctx != dp) 840 return 0; 841 842 switch (obj->id) { 843 case SWITCHDEV_OBJ_ID_PORT_MDB: 844 if (!dsa_port_offloads_bridge_port(dp, obj->orig_dev)) 845 return -EOPNOTSUPP; 846 847 err = dsa_port_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj)); 848 break; 849 case SWITCHDEV_OBJ_ID_HOST_MDB: 850 if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev)) 851 return -EOPNOTSUPP; 852 853 err = dsa_port_bridge_host_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj)); 854 break; 855 case SWITCHDEV_OBJ_ID_PORT_VLAN: 856 if (dsa_port_offloads_bridge_port(dp, obj->orig_dev)) 857 err = dsa_user_vlan_del(dev, obj); 858 else 859 err = dsa_user_host_vlan_del(dev, obj); 860 break; 861 case SWITCHDEV_OBJ_ID_MRP: 862 if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev)) 863 return -EOPNOTSUPP; 864 865 err = dsa_port_mrp_del(dp, SWITCHDEV_OBJ_MRP(obj)); 866 break; 867 case SWITCHDEV_OBJ_ID_RING_ROLE_MRP: 868 if (!dsa_port_offloads_bridge_dev(dp, obj->orig_dev)) 869 return -EOPNOTSUPP; 870 871 err = dsa_port_mrp_del_ring_role(dp, 872 SWITCHDEV_OBJ_RING_ROLE_MRP(obj)); 873 break; 874 default: 875 err = -EOPNOTSUPP; 876 break; 877 } 878 879 return err; 880 } 881 882 static netdev_tx_t dsa_user_netpoll_send_skb(struct net_device *dev, 883 struct sk_buff *skb) 884 { 885 #ifdef CONFIG_NET_POLL_CONTROLLER 886 struct dsa_user_priv *p = netdev_priv(dev); 887 888 return netpoll_send_skb(p->netpoll, skb); 889 #else 890 BUG(); 891 return NETDEV_TX_OK; 892 #endif 893 } 894 895 static void dsa_skb_tx_timestamp(struct dsa_user_priv *p, 896 struct sk_buff *skb) 897 { 898 struct dsa_switch *ds = p->dp->ds; 899 900 if (!(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) 901 return; 902 903 if (!ds->ops->port_txtstamp) 904 return; 905 906 ds->ops->port_txtstamp(ds, p->dp->index, skb); 907 } 908 909 netdev_tx_t dsa_enqueue_skb(struct sk_buff *skb, struct net_device *dev) 910 { 911 /* SKB for netpoll still need to be mangled with the protocol-specific 912 * tag to be successfully transmitted 913 */ 914 if (unlikely(netpoll_tx_running(dev))) 915 return dsa_user_netpoll_send_skb(dev, skb); 916 917 /* Queue the SKB for transmission on the parent interface, but 918 * do not modify its EtherType 919 */ 920 skb->dev = dsa_user_to_conduit(dev); 921 dev_queue_xmit(skb); 922 923 return NETDEV_TX_OK; 924 } 925 EXPORT_SYMBOL_GPL(dsa_enqueue_skb); 926 927 static netdev_tx_t dsa_user_xmit(struct sk_buff *skb, struct net_device *dev) 928 { 929 struct dsa_user_priv *p = netdev_priv(dev); 930 struct sk_buff *nskb; 931 932 dev_sw_netstats_tx_add(dev, 1, skb->len); 933 934 memset(skb->cb, 0, sizeof(skb->cb)); 935 936 /* Handle tx timestamp if any */ 937 dsa_skb_tx_timestamp(p, skb); 938 939 if (skb_ensure_writable_head_tail(skb, dev)) { 940 dev_kfree_skb_any(skb); 941 return NETDEV_TX_OK; 942 } 943 944 /* needed_tailroom should still be 'warm' in the cache line from 945 * skb_ensure_writable_head_tail(), which has also ensured that 946 * padding is safe. 947 */ 948 if (dev->needed_tailroom) 949 eth_skb_pad(skb); 950 951 /* Transmit function may have to reallocate the original SKB, 952 * in which case it must have freed it. Only free it here on error. 953 */ 954 nskb = p->xmit(skb, dev); 955 if (!nskb) { 956 kfree_skb(skb); 957 return NETDEV_TX_OK; 958 } 959 960 return dsa_enqueue_skb(nskb, dev); 961 } 962 963 /* ethtool operations *******************************************************/ 964 965 static void dsa_user_get_drvinfo(struct net_device *dev, 966 struct ethtool_drvinfo *drvinfo) 967 { 968 strscpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver)); 969 strscpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version)); 970 strscpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info)); 971 } 972 973 static int dsa_user_get_regs_len(struct net_device *dev) 974 { 975 struct dsa_port *dp = dsa_user_to_port(dev); 976 struct dsa_switch *ds = dp->ds; 977 978 if (ds->ops->get_regs_len) 979 return ds->ops->get_regs_len(ds, dp->index); 980 981 return -EOPNOTSUPP; 982 } 983 984 static void 985 dsa_user_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p) 986 { 987 struct dsa_port *dp = dsa_user_to_port(dev); 988 struct dsa_switch *ds = dp->ds; 989 990 if (ds->ops->get_regs) 991 ds->ops->get_regs(ds, dp->index, regs, _p); 992 } 993 994 static int dsa_user_nway_reset(struct net_device *dev) 995 { 996 struct dsa_port *dp = dsa_user_to_port(dev); 997 998 return phylink_ethtool_nway_reset(dp->pl); 999 } 1000 1001 static int dsa_user_get_eeprom_len(struct net_device *dev) 1002 { 1003 struct dsa_port *dp = dsa_user_to_port(dev); 1004 struct dsa_switch *ds = dp->ds; 1005 1006 if (ds->cd && ds->cd->eeprom_len) 1007 return ds->cd->eeprom_len; 1008 1009 if (ds->ops->get_eeprom_len) 1010 return ds->ops->get_eeprom_len(ds); 1011 1012 return 0; 1013 } 1014 1015 static int dsa_user_get_eeprom(struct net_device *dev, 1016 struct ethtool_eeprom *eeprom, u8 *data) 1017 { 1018 struct dsa_port *dp = dsa_user_to_port(dev); 1019 struct dsa_switch *ds = dp->ds; 1020 1021 if (ds->ops->get_eeprom) 1022 return ds->ops->get_eeprom(ds, eeprom, data); 1023 1024 return -EOPNOTSUPP; 1025 } 1026 1027 static int dsa_user_set_eeprom(struct net_device *dev, 1028 struct ethtool_eeprom *eeprom, u8 *data) 1029 { 1030 struct dsa_port *dp = dsa_user_to_port(dev); 1031 struct dsa_switch *ds = dp->ds; 1032 1033 if (ds->ops->set_eeprom) 1034 return ds->ops->set_eeprom(ds, eeprom, data); 1035 1036 return -EOPNOTSUPP; 1037 } 1038 1039 static void dsa_user_get_strings(struct net_device *dev, 1040 uint32_t stringset, uint8_t *data) 1041 { 1042 struct dsa_port *dp = dsa_user_to_port(dev); 1043 struct dsa_switch *ds = dp->ds; 1044 1045 if (stringset == ETH_SS_STATS) { 1046 ethtool_puts(&data, "tx_packets"); 1047 ethtool_puts(&data, "tx_bytes"); 1048 ethtool_puts(&data, "rx_packets"); 1049 ethtool_puts(&data, "rx_bytes"); 1050 if (ds->ops->get_strings) 1051 ds->ops->get_strings(ds, dp->index, stringset, data); 1052 } else if (stringset == ETH_SS_TEST) { 1053 net_selftest_get_strings(data); 1054 } 1055 1056 } 1057 1058 static void dsa_user_get_ethtool_stats(struct net_device *dev, 1059 struct ethtool_stats *stats, 1060 uint64_t *data) 1061 { 1062 struct dsa_port *dp = dsa_user_to_port(dev); 1063 struct dsa_switch *ds = dp->ds; 1064 struct pcpu_sw_netstats *s; 1065 unsigned int start; 1066 int i; 1067 1068 for_each_possible_cpu(i) { 1069 u64 tx_packets, tx_bytes, rx_packets, rx_bytes; 1070 1071 s = per_cpu_ptr(dev->tstats, i); 1072 do { 1073 start = u64_stats_fetch_begin(&s->syncp); 1074 tx_packets = u64_stats_read(&s->tx_packets); 1075 tx_bytes = u64_stats_read(&s->tx_bytes); 1076 rx_packets = u64_stats_read(&s->rx_packets); 1077 rx_bytes = u64_stats_read(&s->rx_bytes); 1078 } while (u64_stats_fetch_retry(&s->syncp, start)); 1079 data[0] += tx_packets; 1080 data[1] += tx_bytes; 1081 data[2] += rx_packets; 1082 data[3] += rx_bytes; 1083 } 1084 if (ds->ops->get_ethtool_stats) 1085 ds->ops->get_ethtool_stats(ds, dp->index, data + 4); 1086 } 1087 1088 static int dsa_user_get_sset_count(struct net_device *dev, int sset) 1089 { 1090 struct dsa_port *dp = dsa_user_to_port(dev); 1091 struct dsa_switch *ds = dp->ds; 1092 1093 if (sset == ETH_SS_STATS) { 1094 int count = 0; 1095 1096 if (ds->ops->get_sset_count) { 1097 count = ds->ops->get_sset_count(ds, dp->index, sset); 1098 if (count < 0) 1099 return count; 1100 } 1101 1102 return count + 4; 1103 } else if (sset == ETH_SS_TEST) { 1104 return net_selftest_get_count(); 1105 } 1106 1107 return -EOPNOTSUPP; 1108 } 1109 1110 static void dsa_user_get_eth_phy_stats(struct net_device *dev, 1111 struct ethtool_eth_phy_stats *phy_stats) 1112 { 1113 struct dsa_port *dp = dsa_user_to_port(dev); 1114 struct dsa_switch *ds = dp->ds; 1115 1116 if (ds->ops->get_eth_phy_stats) 1117 ds->ops->get_eth_phy_stats(ds, dp->index, phy_stats); 1118 } 1119 1120 static void dsa_user_get_eth_mac_stats(struct net_device *dev, 1121 struct ethtool_eth_mac_stats *mac_stats) 1122 { 1123 struct dsa_port *dp = dsa_user_to_port(dev); 1124 struct dsa_switch *ds = dp->ds; 1125 1126 if (ds->ops->get_eth_mac_stats) 1127 ds->ops->get_eth_mac_stats(ds, dp->index, mac_stats); 1128 } 1129 1130 static void 1131 dsa_user_get_eth_ctrl_stats(struct net_device *dev, 1132 struct ethtool_eth_ctrl_stats *ctrl_stats) 1133 { 1134 struct dsa_port *dp = dsa_user_to_port(dev); 1135 struct dsa_switch *ds = dp->ds; 1136 1137 if (ds->ops->get_eth_ctrl_stats) 1138 ds->ops->get_eth_ctrl_stats(ds, dp->index, ctrl_stats); 1139 } 1140 1141 static void 1142 dsa_user_get_rmon_stats(struct net_device *dev, 1143 struct ethtool_rmon_stats *rmon_stats, 1144 const struct ethtool_rmon_hist_range **ranges) 1145 { 1146 struct dsa_port *dp = dsa_user_to_port(dev); 1147 struct dsa_switch *ds = dp->ds; 1148 1149 if (ds->ops->get_rmon_stats) 1150 ds->ops->get_rmon_stats(ds, dp->index, rmon_stats, ranges); 1151 } 1152 1153 static void dsa_user_net_selftest(struct net_device *ndev, 1154 struct ethtool_test *etest, u64 *buf) 1155 { 1156 struct dsa_port *dp = dsa_user_to_port(ndev); 1157 struct dsa_switch *ds = dp->ds; 1158 1159 if (ds->ops->self_test) { 1160 ds->ops->self_test(ds, dp->index, etest, buf); 1161 return; 1162 } 1163 1164 net_selftest(ndev, etest, buf); 1165 } 1166 1167 static int dsa_user_get_mm(struct net_device *dev, 1168 struct ethtool_mm_state *state) 1169 { 1170 struct dsa_port *dp = dsa_user_to_port(dev); 1171 struct dsa_switch *ds = dp->ds; 1172 1173 if (!ds->ops->get_mm) 1174 return -EOPNOTSUPP; 1175 1176 return ds->ops->get_mm(ds, dp->index, state); 1177 } 1178 1179 static int dsa_user_set_mm(struct net_device *dev, struct ethtool_mm_cfg *cfg, 1180 struct netlink_ext_ack *extack) 1181 { 1182 struct dsa_port *dp = dsa_user_to_port(dev); 1183 struct dsa_switch *ds = dp->ds; 1184 1185 if (!ds->ops->set_mm) 1186 return -EOPNOTSUPP; 1187 1188 return ds->ops->set_mm(ds, dp->index, cfg, extack); 1189 } 1190 1191 static void dsa_user_get_mm_stats(struct net_device *dev, 1192 struct ethtool_mm_stats *stats) 1193 { 1194 struct dsa_port *dp = dsa_user_to_port(dev); 1195 struct dsa_switch *ds = dp->ds; 1196 1197 if (ds->ops->get_mm_stats) 1198 ds->ops->get_mm_stats(ds, dp->index, stats); 1199 } 1200 1201 static void dsa_user_get_wol(struct net_device *dev, struct ethtool_wolinfo *w) 1202 { 1203 struct dsa_port *dp = dsa_user_to_port(dev); 1204 struct dsa_switch *ds = dp->ds; 1205 1206 phylink_ethtool_get_wol(dp->pl, w); 1207 1208 if (ds->ops->get_wol) 1209 ds->ops->get_wol(ds, dp->index, w); 1210 } 1211 1212 static int dsa_user_set_wol(struct net_device *dev, struct ethtool_wolinfo *w) 1213 { 1214 struct dsa_port *dp = dsa_user_to_port(dev); 1215 struct dsa_switch *ds = dp->ds; 1216 int ret = -EOPNOTSUPP; 1217 1218 phylink_ethtool_set_wol(dp->pl, w); 1219 1220 if (ds->ops->set_wol) 1221 ret = ds->ops->set_wol(ds, dp->index, w); 1222 1223 return ret; 1224 } 1225 1226 static int dsa_user_set_eee(struct net_device *dev, struct ethtool_keee *e) 1227 { 1228 struct dsa_port *dp = dsa_user_to_port(dev); 1229 struct dsa_switch *ds = dp->ds; 1230 int ret; 1231 1232 /* Check whether the switch supports EEE */ 1233 if (!ds->ops->support_eee || !ds->ops->support_eee(ds, dp->index)) 1234 return -EOPNOTSUPP; 1235 1236 /* Port's PHY and MAC both need to be EEE capable */ 1237 if (!dev->phydev) 1238 return -ENODEV; 1239 1240 if (!ds->ops->set_mac_eee) 1241 return -EOPNOTSUPP; 1242 1243 ret = ds->ops->set_mac_eee(ds, dp->index, e); 1244 if (ret) 1245 return ret; 1246 1247 return phylink_ethtool_set_eee(dp->pl, e); 1248 } 1249 1250 static int dsa_user_get_eee(struct net_device *dev, struct ethtool_keee *e) 1251 { 1252 struct dsa_port *dp = dsa_user_to_port(dev); 1253 struct dsa_switch *ds = dp->ds; 1254 int ret; 1255 1256 /* Check whether the switch supports EEE */ 1257 if (!ds->ops->support_eee || !ds->ops->support_eee(ds, dp->index)) 1258 return -EOPNOTSUPP; 1259 1260 /* Port's PHY and MAC both need to be EEE capable */ 1261 if (!dev->phydev) 1262 return -ENODEV; 1263 1264 if (!ds->ops->get_mac_eee) 1265 return -EOPNOTSUPP; 1266 1267 ret = ds->ops->get_mac_eee(ds, dp->index, e); 1268 if (ret) 1269 return ret; 1270 1271 return phylink_ethtool_get_eee(dp->pl, e); 1272 } 1273 1274 static int dsa_user_get_link_ksettings(struct net_device *dev, 1275 struct ethtool_link_ksettings *cmd) 1276 { 1277 struct dsa_port *dp = dsa_user_to_port(dev); 1278 1279 return phylink_ethtool_ksettings_get(dp->pl, cmd); 1280 } 1281 1282 static int dsa_user_set_link_ksettings(struct net_device *dev, 1283 const struct ethtool_link_ksettings *cmd) 1284 { 1285 struct dsa_port *dp = dsa_user_to_port(dev); 1286 1287 return phylink_ethtool_ksettings_set(dp->pl, cmd); 1288 } 1289 1290 static void dsa_user_get_pause_stats(struct net_device *dev, 1291 struct ethtool_pause_stats *pause_stats) 1292 { 1293 struct dsa_port *dp = dsa_user_to_port(dev); 1294 struct dsa_switch *ds = dp->ds; 1295 1296 if (ds->ops->get_pause_stats) 1297 ds->ops->get_pause_stats(ds, dp->index, pause_stats); 1298 } 1299 1300 static void dsa_user_get_pauseparam(struct net_device *dev, 1301 struct ethtool_pauseparam *pause) 1302 { 1303 struct dsa_port *dp = dsa_user_to_port(dev); 1304 1305 phylink_ethtool_get_pauseparam(dp->pl, pause); 1306 } 1307 1308 static int dsa_user_set_pauseparam(struct net_device *dev, 1309 struct ethtool_pauseparam *pause) 1310 { 1311 struct dsa_port *dp = dsa_user_to_port(dev); 1312 1313 return phylink_ethtool_set_pauseparam(dp->pl, pause); 1314 } 1315 1316 #ifdef CONFIG_NET_POLL_CONTROLLER 1317 static int dsa_user_netpoll_setup(struct net_device *dev) 1318 { 1319 struct net_device *conduit = dsa_user_to_conduit(dev); 1320 struct dsa_user_priv *p = netdev_priv(dev); 1321 struct netpoll *netpoll; 1322 int err = 0; 1323 1324 netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL); 1325 if (!netpoll) 1326 return -ENOMEM; 1327 1328 err = __netpoll_setup(netpoll, conduit); 1329 if (err) { 1330 kfree(netpoll); 1331 goto out; 1332 } 1333 1334 p->netpoll = netpoll; 1335 out: 1336 return err; 1337 } 1338 1339 static void dsa_user_netpoll_cleanup(struct net_device *dev) 1340 { 1341 struct dsa_user_priv *p = netdev_priv(dev); 1342 struct netpoll *netpoll = p->netpoll; 1343 1344 if (!netpoll) 1345 return; 1346 1347 p->netpoll = NULL; 1348 1349 __netpoll_free(netpoll); 1350 } 1351 1352 static void dsa_user_poll_controller(struct net_device *dev) 1353 { 1354 } 1355 #endif 1356 1357 static struct dsa_mall_tc_entry * 1358 dsa_user_mall_tc_entry_find(struct net_device *dev, unsigned long cookie) 1359 { 1360 struct dsa_user_priv *p = netdev_priv(dev); 1361 struct dsa_mall_tc_entry *mall_tc_entry; 1362 1363 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list) 1364 if (mall_tc_entry->cookie == cookie) 1365 return mall_tc_entry; 1366 1367 return NULL; 1368 } 1369 1370 static int 1371 dsa_user_add_cls_matchall_mirred(struct net_device *dev, 1372 struct tc_cls_matchall_offload *cls, 1373 bool ingress, bool ingress_target) 1374 { 1375 struct netlink_ext_ack *extack = cls->common.extack; 1376 struct dsa_port *dp = dsa_user_to_port(dev); 1377 struct dsa_user_priv *p = netdev_priv(dev); 1378 struct dsa_mall_mirror_tc_entry *mirror; 1379 struct dsa_mall_tc_entry *mall_tc_entry; 1380 struct dsa_switch *ds = dp->ds; 1381 struct flow_action_entry *act; 1382 struct dsa_port *to_dp; 1383 int err; 1384 1385 if (cls->common.protocol != htons(ETH_P_ALL)) { 1386 NL_SET_ERR_MSG_MOD(extack, 1387 "Can only offload \"protocol all\" matchall filter"); 1388 return -EOPNOTSUPP; 1389 } 1390 1391 if (!ds->ops->port_mirror_add) { 1392 NL_SET_ERR_MSG_MOD(extack, 1393 "Switch does not support mirroring operation"); 1394 return -EOPNOTSUPP; 1395 } 1396 1397 if (!flow_action_basic_hw_stats_check(&cls->rule->action, extack)) 1398 return -EOPNOTSUPP; 1399 1400 act = &cls->rule->action.entries[0]; 1401 1402 if (!act->dev) 1403 return -EINVAL; 1404 1405 if (dsa_user_dev_check(act->dev)) { 1406 if (ingress_target) { 1407 /* We can only fulfill this using software assist */ 1408 if (cls->common.skip_sw) { 1409 NL_SET_ERR_MSG_MOD(extack, 1410 "Can only mirred to ingress of DSA user port if filter also runs in software"); 1411 return -EOPNOTSUPP; 1412 } 1413 to_dp = dp->cpu_dp; 1414 } else { 1415 to_dp = dsa_user_to_port(act->dev); 1416 } 1417 } else { 1418 /* Handle mirroring to foreign target ports as a mirror towards 1419 * the CPU. The software tc rule will take the packets from 1420 * there. 1421 */ 1422 if (cls->common.skip_sw) { 1423 NL_SET_ERR_MSG_MOD(extack, 1424 "Can only mirred to CPU if filter also runs in software"); 1425 return -EOPNOTSUPP; 1426 } 1427 to_dp = dp->cpu_dp; 1428 } 1429 1430 if (dp->ds != to_dp->ds) { 1431 NL_SET_ERR_MSG_MOD(extack, 1432 "Cross-chip mirroring not implemented"); 1433 return -EOPNOTSUPP; 1434 } 1435 1436 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL); 1437 if (!mall_tc_entry) 1438 return -ENOMEM; 1439 1440 mall_tc_entry->cookie = cls->cookie; 1441 mall_tc_entry->type = DSA_PORT_MALL_MIRROR; 1442 mirror = &mall_tc_entry->mirror; 1443 mirror->to_local_port = to_dp->index; 1444 mirror->ingress = ingress; 1445 1446 err = ds->ops->port_mirror_add(ds, dp->index, mirror, ingress, extack); 1447 if (err) { 1448 kfree(mall_tc_entry); 1449 return err; 1450 } 1451 1452 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list); 1453 1454 return err; 1455 } 1456 1457 static int 1458 dsa_user_add_cls_matchall_police(struct net_device *dev, 1459 struct tc_cls_matchall_offload *cls, 1460 bool ingress) 1461 { 1462 struct netlink_ext_ack *extack = cls->common.extack; 1463 struct dsa_port *dp = dsa_user_to_port(dev); 1464 struct dsa_user_priv *p = netdev_priv(dev); 1465 struct dsa_mall_policer_tc_entry *policer; 1466 struct dsa_mall_tc_entry *mall_tc_entry; 1467 struct dsa_switch *ds = dp->ds; 1468 struct flow_action_entry *act; 1469 int err; 1470 1471 if (!ds->ops->port_policer_add) { 1472 NL_SET_ERR_MSG_MOD(extack, 1473 "Policing offload not implemented"); 1474 return -EOPNOTSUPP; 1475 } 1476 1477 if (!ingress) { 1478 NL_SET_ERR_MSG_MOD(extack, 1479 "Only supported on ingress qdisc"); 1480 return -EOPNOTSUPP; 1481 } 1482 1483 if (!flow_action_basic_hw_stats_check(&cls->rule->action, extack)) 1484 return -EOPNOTSUPP; 1485 1486 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list) { 1487 if (mall_tc_entry->type == DSA_PORT_MALL_POLICER) { 1488 NL_SET_ERR_MSG_MOD(extack, 1489 "Only one port policer allowed"); 1490 return -EEXIST; 1491 } 1492 } 1493 1494 act = &cls->rule->action.entries[0]; 1495 1496 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL); 1497 if (!mall_tc_entry) 1498 return -ENOMEM; 1499 1500 mall_tc_entry->cookie = cls->cookie; 1501 mall_tc_entry->type = DSA_PORT_MALL_POLICER; 1502 policer = &mall_tc_entry->policer; 1503 policer->rate_bytes_per_sec = act->police.rate_bytes_ps; 1504 policer->burst = act->police.burst; 1505 1506 err = ds->ops->port_policer_add(ds, dp->index, policer); 1507 if (err) { 1508 kfree(mall_tc_entry); 1509 return err; 1510 } 1511 1512 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list); 1513 1514 return err; 1515 } 1516 1517 static int dsa_user_add_cls_matchall(struct net_device *dev, 1518 struct tc_cls_matchall_offload *cls, 1519 bool ingress) 1520 { 1521 const struct flow_action *action = &cls->rule->action; 1522 struct netlink_ext_ack *extack = cls->common.extack; 1523 1524 if (!flow_offload_has_one_action(action)) { 1525 NL_SET_ERR_MSG_MOD(extack, 1526 "Cannot offload matchall filter with more than one action"); 1527 return -EOPNOTSUPP; 1528 } 1529 1530 switch (action->entries[0].id) { 1531 case FLOW_ACTION_MIRRED: 1532 return dsa_user_add_cls_matchall_mirred(dev, cls, ingress, 1533 false); 1534 case FLOW_ACTION_MIRRED_INGRESS: 1535 return dsa_user_add_cls_matchall_mirred(dev, cls, ingress, 1536 true); 1537 case FLOW_ACTION_POLICE: 1538 return dsa_user_add_cls_matchall_police(dev, cls, ingress); 1539 default: 1540 NL_SET_ERR_MSG_MOD(extack, "Unknown action"); 1541 break; 1542 } 1543 1544 return -EOPNOTSUPP; 1545 } 1546 1547 static void dsa_user_del_cls_matchall(struct net_device *dev, 1548 struct tc_cls_matchall_offload *cls) 1549 { 1550 struct dsa_port *dp = dsa_user_to_port(dev); 1551 struct dsa_mall_tc_entry *mall_tc_entry; 1552 struct dsa_switch *ds = dp->ds; 1553 1554 mall_tc_entry = dsa_user_mall_tc_entry_find(dev, cls->cookie); 1555 if (!mall_tc_entry) 1556 return; 1557 1558 list_del(&mall_tc_entry->list); 1559 1560 switch (mall_tc_entry->type) { 1561 case DSA_PORT_MALL_MIRROR: 1562 if (ds->ops->port_mirror_del) 1563 ds->ops->port_mirror_del(ds, dp->index, 1564 &mall_tc_entry->mirror); 1565 break; 1566 case DSA_PORT_MALL_POLICER: 1567 if (ds->ops->port_policer_del) 1568 ds->ops->port_policer_del(ds, dp->index); 1569 break; 1570 default: 1571 WARN_ON(1); 1572 } 1573 1574 kfree(mall_tc_entry); 1575 } 1576 1577 static int dsa_user_setup_tc_cls_matchall(struct net_device *dev, 1578 struct tc_cls_matchall_offload *cls, 1579 bool ingress) 1580 { 1581 if (cls->common.chain_index) 1582 return -EOPNOTSUPP; 1583 1584 switch (cls->command) { 1585 case TC_CLSMATCHALL_REPLACE: 1586 return dsa_user_add_cls_matchall(dev, cls, ingress); 1587 case TC_CLSMATCHALL_DESTROY: 1588 dsa_user_del_cls_matchall(dev, cls); 1589 return 0; 1590 default: 1591 return -EOPNOTSUPP; 1592 } 1593 } 1594 1595 static int dsa_user_add_cls_flower(struct net_device *dev, 1596 struct flow_cls_offload *cls, 1597 bool ingress) 1598 { 1599 struct dsa_port *dp = dsa_user_to_port(dev); 1600 struct dsa_switch *ds = dp->ds; 1601 int port = dp->index; 1602 1603 if (!ds->ops->cls_flower_add) 1604 return -EOPNOTSUPP; 1605 1606 return ds->ops->cls_flower_add(ds, port, cls, ingress); 1607 } 1608 1609 static int dsa_user_del_cls_flower(struct net_device *dev, 1610 struct flow_cls_offload *cls, 1611 bool ingress) 1612 { 1613 struct dsa_port *dp = dsa_user_to_port(dev); 1614 struct dsa_switch *ds = dp->ds; 1615 int port = dp->index; 1616 1617 if (!ds->ops->cls_flower_del) 1618 return -EOPNOTSUPP; 1619 1620 return ds->ops->cls_flower_del(ds, port, cls, ingress); 1621 } 1622 1623 static int dsa_user_stats_cls_flower(struct net_device *dev, 1624 struct flow_cls_offload *cls, 1625 bool ingress) 1626 { 1627 struct dsa_port *dp = dsa_user_to_port(dev); 1628 struct dsa_switch *ds = dp->ds; 1629 int port = dp->index; 1630 1631 if (!ds->ops->cls_flower_stats) 1632 return -EOPNOTSUPP; 1633 1634 return ds->ops->cls_flower_stats(ds, port, cls, ingress); 1635 } 1636 1637 static int dsa_user_setup_tc_cls_flower(struct net_device *dev, 1638 struct flow_cls_offload *cls, 1639 bool ingress) 1640 { 1641 switch (cls->command) { 1642 case FLOW_CLS_REPLACE: 1643 return dsa_user_add_cls_flower(dev, cls, ingress); 1644 case FLOW_CLS_DESTROY: 1645 return dsa_user_del_cls_flower(dev, cls, ingress); 1646 case FLOW_CLS_STATS: 1647 return dsa_user_stats_cls_flower(dev, cls, ingress); 1648 default: 1649 return -EOPNOTSUPP; 1650 } 1651 } 1652 1653 static int dsa_user_setup_tc_block_cb(enum tc_setup_type type, void *type_data, 1654 void *cb_priv, bool ingress) 1655 { 1656 struct net_device *dev = cb_priv; 1657 1658 if (!tc_can_offload(dev)) 1659 return -EOPNOTSUPP; 1660 1661 switch (type) { 1662 case TC_SETUP_CLSMATCHALL: 1663 return dsa_user_setup_tc_cls_matchall(dev, type_data, ingress); 1664 case TC_SETUP_CLSFLOWER: 1665 return dsa_user_setup_tc_cls_flower(dev, type_data, ingress); 1666 default: 1667 return -EOPNOTSUPP; 1668 } 1669 } 1670 1671 static int dsa_user_setup_tc_block_cb_ig(enum tc_setup_type type, 1672 void *type_data, void *cb_priv) 1673 { 1674 return dsa_user_setup_tc_block_cb(type, type_data, cb_priv, true); 1675 } 1676 1677 static int dsa_user_setup_tc_block_cb_eg(enum tc_setup_type type, 1678 void *type_data, void *cb_priv) 1679 { 1680 return dsa_user_setup_tc_block_cb(type, type_data, cb_priv, false); 1681 } 1682 1683 static LIST_HEAD(dsa_user_block_cb_list); 1684 1685 static int dsa_user_setup_tc_block(struct net_device *dev, 1686 struct flow_block_offload *f) 1687 { 1688 struct flow_block_cb *block_cb; 1689 flow_setup_cb_t *cb; 1690 1691 if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS) 1692 cb = dsa_user_setup_tc_block_cb_ig; 1693 else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS) 1694 cb = dsa_user_setup_tc_block_cb_eg; 1695 else 1696 return -EOPNOTSUPP; 1697 1698 f->driver_block_list = &dsa_user_block_cb_list; 1699 1700 switch (f->command) { 1701 case FLOW_BLOCK_BIND: 1702 if (flow_block_cb_is_busy(cb, dev, &dsa_user_block_cb_list)) 1703 return -EBUSY; 1704 1705 block_cb = flow_block_cb_alloc(cb, dev, dev, NULL); 1706 if (IS_ERR(block_cb)) 1707 return PTR_ERR(block_cb); 1708 1709 flow_block_cb_add(block_cb, f); 1710 list_add_tail(&block_cb->driver_list, &dsa_user_block_cb_list); 1711 return 0; 1712 case FLOW_BLOCK_UNBIND: 1713 block_cb = flow_block_cb_lookup(f->block, cb, dev); 1714 if (!block_cb) 1715 return -ENOENT; 1716 1717 flow_block_cb_remove(block_cb, f); 1718 list_del(&block_cb->driver_list); 1719 return 0; 1720 default: 1721 return -EOPNOTSUPP; 1722 } 1723 } 1724 1725 static int dsa_user_setup_ft_block(struct dsa_switch *ds, int port, 1726 void *type_data) 1727 { 1728 struct net_device *conduit = dsa_port_to_conduit(dsa_to_port(ds, port)); 1729 1730 if (!conduit->netdev_ops->ndo_setup_tc) 1731 return -EOPNOTSUPP; 1732 1733 return conduit->netdev_ops->ndo_setup_tc(conduit, TC_SETUP_FT, type_data); 1734 } 1735 1736 static int dsa_user_setup_tc(struct net_device *dev, enum tc_setup_type type, 1737 void *type_data) 1738 { 1739 struct dsa_port *dp = dsa_user_to_port(dev); 1740 struct dsa_switch *ds = dp->ds; 1741 1742 switch (type) { 1743 case TC_SETUP_BLOCK: 1744 return dsa_user_setup_tc_block(dev, type_data); 1745 case TC_SETUP_FT: 1746 return dsa_user_setup_ft_block(ds, dp->index, type_data); 1747 default: 1748 break; 1749 } 1750 1751 if (!ds->ops->port_setup_tc) 1752 return -EOPNOTSUPP; 1753 1754 return ds->ops->port_setup_tc(ds, dp->index, type, type_data); 1755 } 1756 1757 static int dsa_user_get_rxnfc(struct net_device *dev, 1758 struct ethtool_rxnfc *nfc, u32 *rule_locs) 1759 { 1760 struct dsa_port *dp = dsa_user_to_port(dev); 1761 struct dsa_switch *ds = dp->ds; 1762 1763 if (!ds->ops->get_rxnfc) 1764 return -EOPNOTSUPP; 1765 1766 return ds->ops->get_rxnfc(ds, dp->index, nfc, rule_locs); 1767 } 1768 1769 static int dsa_user_set_rxnfc(struct net_device *dev, 1770 struct ethtool_rxnfc *nfc) 1771 { 1772 struct dsa_port *dp = dsa_user_to_port(dev); 1773 struct dsa_switch *ds = dp->ds; 1774 1775 if (!ds->ops->set_rxnfc) 1776 return -EOPNOTSUPP; 1777 1778 return ds->ops->set_rxnfc(ds, dp->index, nfc); 1779 } 1780 1781 static int dsa_user_get_ts_info(struct net_device *dev, 1782 struct kernel_ethtool_ts_info *ts) 1783 { 1784 struct dsa_user_priv *p = netdev_priv(dev); 1785 struct dsa_switch *ds = p->dp->ds; 1786 1787 if (!ds->ops->get_ts_info) 1788 return -EOPNOTSUPP; 1789 1790 return ds->ops->get_ts_info(ds, p->dp->index, ts); 1791 } 1792 1793 static int dsa_user_vlan_rx_add_vid(struct net_device *dev, __be16 proto, 1794 u16 vid) 1795 { 1796 struct dsa_port *dp = dsa_user_to_port(dev); 1797 struct switchdev_obj_port_vlan vlan = { 1798 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, 1799 .vid = vid, 1800 /* This API only allows programming tagged, non-PVID VIDs */ 1801 .flags = 0, 1802 }; 1803 struct netlink_ext_ack extack = {0}; 1804 struct dsa_switch *ds = dp->ds; 1805 struct netdev_hw_addr *ha; 1806 struct dsa_vlan *v; 1807 int ret; 1808 1809 /* User port... */ 1810 ret = dsa_port_vlan_add(dp, &vlan, &extack); 1811 if (ret) { 1812 if (extack._msg) 1813 netdev_err(dev, "%s\n", extack._msg); 1814 return ret; 1815 } 1816 1817 /* And CPU port... */ 1818 ret = dsa_port_host_vlan_add(dp, &vlan, &extack); 1819 if (ret) { 1820 if (extack._msg) 1821 netdev_err(dev, "CPU port %d: %s\n", dp->cpu_dp->index, 1822 extack._msg); 1823 return ret; 1824 } 1825 1826 if (!dsa_switch_supports_uc_filtering(ds) && 1827 !dsa_switch_supports_mc_filtering(ds)) 1828 return 0; 1829 1830 v = kzalloc(sizeof(*v), GFP_KERNEL); 1831 if (!v) { 1832 ret = -ENOMEM; 1833 goto rollback; 1834 } 1835 1836 netif_addr_lock_bh(dev); 1837 1838 v->vid = vid; 1839 list_add_tail(&v->list, &dp->user_vlans); 1840 1841 if (dsa_switch_supports_mc_filtering(ds)) { 1842 netdev_for_each_synced_mc_addr(ha, dev) { 1843 dsa_user_schedule_standalone_work(dev, DSA_MC_ADD, 1844 ha->addr, vid); 1845 } 1846 } 1847 1848 if (dsa_switch_supports_uc_filtering(ds)) { 1849 netdev_for_each_synced_uc_addr(ha, dev) { 1850 dsa_user_schedule_standalone_work(dev, DSA_UC_ADD, 1851 ha->addr, vid); 1852 } 1853 } 1854 1855 netif_addr_unlock_bh(dev); 1856 1857 dsa_flush_workqueue(); 1858 1859 return 0; 1860 1861 rollback: 1862 dsa_port_host_vlan_del(dp, &vlan); 1863 dsa_port_vlan_del(dp, &vlan); 1864 1865 return ret; 1866 } 1867 1868 static int dsa_user_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, 1869 u16 vid) 1870 { 1871 struct dsa_port *dp = dsa_user_to_port(dev); 1872 struct switchdev_obj_port_vlan vlan = { 1873 .vid = vid, 1874 /* This API only allows programming tagged, non-PVID VIDs */ 1875 .flags = 0, 1876 }; 1877 struct dsa_switch *ds = dp->ds; 1878 struct netdev_hw_addr *ha; 1879 struct dsa_vlan *v; 1880 int err; 1881 1882 err = dsa_port_vlan_del(dp, &vlan); 1883 if (err) 1884 return err; 1885 1886 err = dsa_port_host_vlan_del(dp, &vlan); 1887 if (err) 1888 return err; 1889 1890 if (!dsa_switch_supports_uc_filtering(ds) && 1891 !dsa_switch_supports_mc_filtering(ds)) 1892 return 0; 1893 1894 netif_addr_lock_bh(dev); 1895 1896 v = dsa_vlan_find(&dp->user_vlans, &vlan); 1897 if (!v) { 1898 netif_addr_unlock_bh(dev); 1899 return -ENOENT; 1900 } 1901 1902 list_del(&v->list); 1903 kfree(v); 1904 1905 if (dsa_switch_supports_mc_filtering(ds)) { 1906 netdev_for_each_synced_mc_addr(ha, dev) { 1907 dsa_user_schedule_standalone_work(dev, DSA_MC_DEL, 1908 ha->addr, vid); 1909 } 1910 } 1911 1912 if (dsa_switch_supports_uc_filtering(ds)) { 1913 netdev_for_each_synced_uc_addr(ha, dev) { 1914 dsa_user_schedule_standalone_work(dev, DSA_UC_DEL, 1915 ha->addr, vid); 1916 } 1917 } 1918 1919 netif_addr_unlock_bh(dev); 1920 1921 dsa_flush_workqueue(); 1922 1923 return 0; 1924 } 1925 1926 static int dsa_user_restore_vlan(struct net_device *vdev, int vid, void *arg) 1927 { 1928 __be16 proto = vdev ? vlan_dev_vlan_proto(vdev) : htons(ETH_P_8021Q); 1929 1930 return dsa_user_vlan_rx_add_vid(arg, proto, vid); 1931 } 1932 1933 static int dsa_user_clear_vlan(struct net_device *vdev, int vid, void *arg) 1934 { 1935 __be16 proto = vdev ? vlan_dev_vlan_proto(vdev) : htons(ETH_P_8021Q); 1936 1937 return dsa_user_vlan_rx_kill_vid(arg, proto, vid); 1938 } 1939 1940 /* Keep the VLAN RX filtering list in sync with the hardware only if VLAN 1941 * filtering is enabled. The baseline is that only ports that offload a 1942 * VLAN-aware bridge are VLAN-aware, and standalone ports are VLAN-unaware, 1943 * but there are exceptions for quirky hardware. 1944 * 1945 * If ds->vlan_filtering_is_global = true, then standalone ports which share 1946 * the same switch with other ports that offload a VLAN-aware bridge are also 1947 * inevitably VLAN-aware. 1948 * 1949 * To summarize, a DSA switch port offloads: 1950 * 1951 * - If standalone (this includes software bridge, software LAG): 1952 * - if ds->needs_standalone_vlan_filtering = true, OR if 1953 * (ds->vlan_filtering_is_global = true AND there are bridges spanning 1954 * this switch chip which have vlan_filtering=1) 1955 * - the 8021q upper VLANs 1956 * - else (standalone VLAN filtering is not needed, VLAN filtering is not 1957 * global, or it is, but no port is under a VLAN-aware bridge): 1958 * - no VLAN (any 8021q upper is a software VLAN) 1959 * 1960 * - If under a vlan_filtering=0 bridge which it offload: 1961 * - if ds->configure_vlan_while_not_filtering = true (default): 1962 * - the bridge VLANs. These VLANs are committed to hardware but inactive. 1963 * - else (deprecated): 1964 * - no VLAN. The bridge VLANs are not restored when VLAN awareness is 1965 * enabled, so this behavior is broken and discouraged. 1966 * 1967 * - If under a vlan_filtering=1 bridge which it offload: 1968 * - the bridge VLANs 1969 * - the 8021q upper VLANs 1970 */ 1971 int dsa_user_manage_vlan_filtering(struct net_device *user, 1972 bool vlan_filtering) 1973 { 1974 int err; 1975 1976 if (vlan_filtering) { 1977 user->features |= NETIF_F_HW_VLAN_CTAG_FILTER; 1978 1979 err = vlan_for_each(user, dsa_user_restore_vlan, user); 1980 if (err) { 1981 vlan_for_each(user, dsa_user_clear_vlan, user); 1982 user->features &= ~NETIF_F_HW_VLAN_CTAG_FILTER; 1983 return err; 1984 } 1985 } else { 1986 err = vlan_for_each(user, dsa_user_clear_vlan, user); 1987 if (err) 1988 return err; 1989 1990 user->features &= ~NETIF_F_HW_VLAN_CTAG_FILTER; 1991 } 1992 1993 return 0; 1994 } 1995 1996 struct dsa_hw_port { 1997 struct list_head list; 1998 struct net_device *dev; 1999 int old_mtu; 2000 }; 2001 2002 static int dsa_hw_port_list_set_mtu(struct list_head *hw_port_list, int mtu) 2003 { 2004 const struct dsa_hw_port *p; 2005 int err; 2006 2007 list_for_each_entry(p, hw_port_list, list) { 2008 if (p->dev->mtu == mtu) 2009 continue; 2010 2011 err = dev_set_mtu(p->dev, mtu); 2012 if (err) 2013 goto rollback; 2014 } 2015 2016 return 0; 2017 2018 rollback: 2019 list_for_each_entry_continue_reverse(p, hw_port_list, list) { 2020 if (p->dev->mtu == p->old_mtu) 2021 continue; 2022 2023 if (dev_set_mtu(p->dev, p->old_mtu)) 2024 netdev_err(p->dev, "Failed to restore MTU\n"); 2025 } 2026 2027 return err; 2028 } 2029 2030 static void dsa_hw_port_list_free(struct list_head *hw_port_list) 2031 { 2032 struct dsa_hw_port *p, *n; 2033 2034 list_for_each_entry_safe(p, n, hw_port_list, list) 2035 kfree(p); 2036 } 2037 2038 /* Make the hardware datapath to/from @dev limited to a common MTU */ 2039 static void dsa_bridge_mtu_normalization(struct dsa_port *dp) 2040 { 2041 struct list_head hw_port_list; 2042 struct dsa_switch_tree *dst; 2043 int min_mtu = ETH_MAX_MTU; 2044 struct dsa_port *other_dp; 2045 int err; 2046 2047 if (!dp->ds->mtu_enforcement_ingress) 2048 return; 2049 2050 if (!dp->bridge) 2051 return; 2052 2053 INIT_LIST_HEAD(&hw_port_list); 2054 2055 /* Populate the list of ports that are part of the same bridge 2056 * as the newly added/modified port 2057 */ 2058 list_for_each_entry(dst, &dsa_tree_list, list) { 2059 list_for_each_entry(other_dp, &dst->ports, list) { 2060 struct dsa_hw_port *hw_port; 2061 struct net_device *user; 2062 2063 if (other_dp->type != DSA_PORT_TYPE_USER) 2064 continue; 2065 2066 if (!dsa_port_bridge_same(dp, other_dp)) 2067 continue; 2068 2069 if (!other_dp->ds->mtu_enforcement_ingress) 2070 continue; 2071 2072 user = other_dp->user; 2073 2074 if (min_mtu > user->mtu) 2075 min_mtu = user->mtu; 2076 2077 hw_port = kzalloc(sizeof(*hw_port), GFP_KERNEL); 2078 if (!hw_port) 2079 goto out; 2080 2081 hw_port->dev = user; 2082 hw_port->old_mtu = user->mtu; 2083 2084 list_add(&hw_port->list, &hw_port_list); 2085 } 2086 } 2087 2088 /* Attempt to configure the entire hardware bridge to the newly added 2089 * interface's MTU first, regardless of whether the intention of the 2090 * user was to raise or lower it. 2091 */ 2092 err = dsa_hw_port_list_set_mtu(&hw_port_list, dp->user->mtu); 2093 if (!err) 2094 goto out; 2095 2096 /* Clearly that didn't work out so well, so just set the minimum MTU on 2097 * all hardware bridge ports now. If this fails too, then all ports will 2098 * still have their old MTU rolled back anyway. 2099 */ 2100 dsa_hw_port_list_set_mtu(&hw_port_list, min_mtu); 2101 2102 out: 2103 dsa_hw_port_list_free(&hw_port_list); 2104 } 2105 2106 int dsa_user_change_mtu(struct net_device *dev, int new_mtu) 2107 { 2108 struct net_device *conduit = dsa_user_to_conduit(dev); 2109 struct dsa_port *dp = dsa_user_to_port(dev); 2110 struct dsa_port *cpu_dp = dp->cpu_dp; 2111 struct dsa_switch *ds = dp->ds; 2112 struct dsa_port *other_dp; 2113 int largest_mtu = 0; 2114 int new_conduit_mtu; 2115 int old_conduit_mtu; 2116 int mtu_limit; 2117 int overhead; 2118 int cpu_mtu; 2119 int err; 2120 2121 if (!ds->ops->port_change_mtu) 2122 return -EOPNOTSUPP; 2123 2124 dsa_tree_for_each_user_port(other_dp, ds->dst) { 2125 int user_mtu; 2126 2127 /* During probe, this function will be called for each user 2128 * device, while not all of them have been allocated. That's 2129 * ok, it doesn't change what the maximum is, so ignore it. 2130 */ 2131 if (!other_dp->user) 2132 continue; 2133 2134 /* Pretend that we already applied the setting, which we 2135 * actually haven't (still haven't done all integrity checks) 2136 */ 2137 if (dp == other_dp) 2138 user_mtu = new_mtu; 2139 else 2140 user_mtu = other_dp->user->mtu; 2141 2142 if (largest_mtu < user_mtu) 2143 largest_mtu = user_mtu; 2144 } 2145 2146 overhead = dsa_tag_protocol_overhead(cpu_dp->tag_ops); 2147 mtu_limit = min_t(int, conduit->max_mtu, dev->max_mtu + overhead); 2148 old_conduit_mtu = conduit->mtu; 2149 new_conduit_mtu = largest_mtu + overhead; 2150 if (new_conduit_mtu > mtu_limit) 2151 return -ERANGE; 2152 2153 /* If the conduit MTU isn't over limit, there's no need to check the CPU 2154 * MTU, since that surely isn't either. 2155 */ 2156 cpu_mtu = largest_mtu; 2157 2158 /* Start applying stuff */ 2159 if (new_conduit_mtu != old_conduit_mtu) { 2160 err = dev_set_mtu(conduit, new_conduit_mtu); 2161 if (err < 0) 2162 goto out_conduit_failed; 2163 2164 /* We only need to propagate the MTU of the CPU port to 2165 * upstream switches, so emit a notifier which updates them. 2166 */ 2167 err = dsa_port_mtu_change(cpu_dp, cpu_mtu); 2168 if (err) 2169 goto out_cpu_failed; 2170 } 2171 2172 err = ds->ops->port_change_mtu(ds, dp->index, new_mtu); 2173 if (err) 2174 goto out_port_failed; 2175 2176 WRITE_ONCE(dev->mtu, new_mtu); 2177 2178 dsa_bridge_mtu_normalization(dp); 2179 2180 return 0; 2181 2182 out_port_failed: 2183 if (new_conduit_mtu != old_conduit_mtu) 2184 dsa_port_mtu_change(cpu_dp, old_conduit_mtu - overhead); 2185 out_cpu_failed: 2186 if (new_conduit_mtu != old_conduit_mtu) 2187 dev_set_mtu(conduit, old_conduit_mtu); 2188 out_conduit_failed: 2189 return err; 2190 } 2191 2192 static int __maybe_unused 2193 dsa_user_dcbnl_set_apptrust(struct net_device *dev, u8 *sel, int nsel) 2194 { 2195 struct dsa_port *dp = dsa_user_to_port(dev); 2196 struct dsa_switch *ds = dp->ds; 2197 int port = dp->index; 2198 2199 if (!ds->ops->port_set_apptrust) 2200 return -EOPNOTSUPP; 2201 2202 return ds->ops->port_set_apptrust(ds, port, sel, nsel); 2203 } 2204 2205 static int __maybe_unused 2206 dsa_user_dcbnl_get_apptrust(struct net_device *dev, u8 *sel, int *nsel) 2207 { 2208 struct dsa_port *dp = dsa_user_to_port(dev); 2209 struct dsa_switch *ds = dp->ds; 2210 int port = dp->index; 2211 2212 if (!ds->ops->port_get_apptrust) 2213 return -EOPNOTSUPP; 2214 2215 return ds->ops->port_get_apptrust(ds, port, sel, nsel); 2216 } 2217 2218 static int __maybe_unused 2219 dsa_user_dcbnl_set_default_prio(struct net_device *dev, struct dcb_app *app) 2220 { 2221 struct dsa_port *dp = dsa_user_to_port(dev); 2222 struct dsa_switch *ds = dp->ds; 2223 unsigned long mask, new_prio; 2224 int err, port = dp->index; 2225 2226 if (!ds->ops->port_set_default_prio) 2227 return -EOPNOTSUPP; 2228 2229 err = dcb_ieee_setapp(dev, app); 2230 if (err) 2231 return err; 2232 2233 mask = dcb_ieee_getapp_mask(dev, app); 2234 new_prio = __fls(mask); 2235 2236 err = ds->ops->port_set_default_prio(ds, port, new_prio); 2237 if (err) { 2238 dcb_ieee_delapp(dev, app); 2239 return err; 2240 } 2241 2242 return 0; 2243 } 2244 2245 /* Update the DSCP prio entries on all user ports of the switch in case 2246 * the switch supports global DSCP prio instead of per port DSCP prios. 2247 */ 2248 static int dsa_user_dcbnl_ieee_global_dscp_setdel(struct net_device *dev, 2249 struct dcb_app *app, bool del) 2250 { 2251 int (*setdel)(struct net_device *dev, struct dcb_app *app); 2252 struct dsa_port *dp = dsa_user_to_port(dev); 2253 struct dsa_switch *ds = dp->ds; 2254 struct dsa_port *other_dp; 2255 int err, restore_err; 2256 2257 if (del) 2258 setdel = dcb_ieee_delapp; 2259 else 2260 setdel = dcb_ieee_setapp; 2261 2262 dsa_switch_for_each_user_port(other_dp, ds) { 2263 struct net_device *user = other_dp->user; 2264 2265 if (!user || user == dev) 2266 continue; 2267 2268 err = setdel(user, app); 2269 if (err) 2270 goto err_try_to_restore; 2271 } 2272 2273 return 0; 2274 2275 err_try_to_restore: 2276 2277 /* Revert logic to restore previous state of app entries */ 2278 if (!del) 2279 setdel = dcb_ieee_delapp; 2280 else 2281 setdel = dcb_ieee_setapp; 2282 2283 dsa_switch_for_each_user_port_continue_reverse(other_dp, ds) { 2284 struct net_device *user = other_dp->user; 2285 2286 if (!user || user == dev) 2287 continue; 2288 2289 restore_err = setdel(user, app); 2290 if (restore_err) 2291 netdev_err(user, "Failed to restore DSCP prio entry configuration\n"); 2292 } 2293 2294 return err; 2295 } 2296 2297 static int __maybe_unused 2298 dsa_user_dcbnl_add_dscp_prio(struct net_device *dev, struct dcb_app *app) 2299 { 2300 struct dsa_port *dp = dsa_user_to_port(dev); 2301 struct dsa_switch *ds = dp->ds; 2302 unsigned long mask, new_prio; 2303 int err, port = dp->index; 2304 u8 dscp = app->protocol; 2305 2306 if (!ds->ops->port_add_dscp_prio) 2307 return -EOPNOTSUPP; 2308 2309 if (dscp >= 64) { 2310 netdev_err(dev, "DSCP APP entry with protocol value %u is invalid\n", 2311 dscp); 2312 return -EINVAL; 2313 } 2314 2315 err = dcb_ieee_setapp(dev, app); 2316 if (err) 2317 return err; 2318 2319 mask = dcb_ieee_getapp_mask(dev, app); 2320 new_prio = __fls(mask); 2321 2322 err = ds->ops->port_add_dscp_prio(ds, port, dscp, new_prio); 2323 if (err) { 2324 dcb_ieee_delapp(dev, app); 2325 return err; 2326 } 2327 2328 if (!ds->dscp_prio_mapping_is_global) 2329 return 0; 2330 2331 err = dsa_user_dcbnl_ieee_global_dscp_setdel(dev, app, false); 2332 if (err) { 2333 if (ds->ops->port_del_dscp_prio) 2334 ds->ops->port_del_dscp_prio(ds, port, dscp, new_prio); 2335 dcb_ieee_delapp(dev, app); 2336 return err; 2337 } 2338 2339 return 0; 2340 } 2341 2342 static int __maybe_unused dsa_user_dcbnl_ieee_setapp(struct net_device *dev, 2343 struct dcb_app *app) 2344 { 2345 switch (app->selector) { 2346 case IEEE_8021QAZ_APP_SEL_ETHERTYPE: 2347 switch (app->protocol) { 2348 case 0: 2349 return dsa_user_dcbnl_set_default_prio(dev, app); 2350 default: 2351 return -EOPNOTSUPP; 2352 } 2353 break; 2354 case IEEE_8021QAZ_APP_SEL_DSCP: 2355 return dsa_user_dcbnl_add_dscp_prio(dev, app); 2356 default: 2357 return -EOPNOTSUPP; 2358 } 2359 } 2360 2361 static int __maybe_unused 2362 dsa_user_dcbnl_del_default_prio(struct net_device *dev, struct dcb_app *app) 2363 { 2364 struct dsa_port *dp = dsa_user_to_port(dev); 2365 struct dsa_switch *ds = dp->ds; 2366 unsigned long mask, new_prio; 2367 int err, port = dp->index; 2368 2369 if (!ds->ops->port_set_default_prio) 2370 return -EOPNOTSUPP; 2371 2372 err = dcb_ieee_delapp(dev, app); 2373 if (err) 2374 return err; 2375 2376 mask = dcb_ieee_getapp_mask(dev, app); 2377 new_prio = mask ? __fls(mask) : 0; 2378 2379 err = ds->ops->port_set_default_prio(ds, port, new_prio); 2380 if (err) { 2381 dcb_ieee_setapp(dev, app); 2382 return err; 2383 } 2384 2385 return 0; 2386 } 2387 2388 static int __maybe_unused 2389 dsa_user_dcbnl_del_dscp_prio(struct net_device *dev, struct dcb_app *app) 2390 { 2391 struct dsa_port *dp = dsa_user_to_port(dev); 2392 struct dsa_switch *ds = dp->ds; 2393 int err, port = dp->index; 2394 u8 dscp = app->protocol; 2395 2396 if (!ds->ops->port_del_dscp_prio) 2397 return -EOPNOTSUPP; 2398 2399 err = dcb_ieee_delapp(dev, app); 2400 if (err) 2401 return err; 2402 2403 err = ds->ops->port_del_dscp_prio(ds, port, dscp, app->priority); 2404 if (err) { 2405 dcb_ieee_setapp(dev, app); 2406 return err; 2407 } 2408 2409 if (!ds->dscp_prio_mapping_is_global) 2410 return 0; 2411 2412 err = dsa_user_dcbnl_ieee_global_dscp_setdel(dev, app, true); 2413 if (err) { 2414 if (ds->ops->port_add_dscp_prio) 2415 ds->ops->port_add_dscp_prio(ds, port, dscp, 2416 app->priority); 2417 dcb_ieee_setapp(dev, app); 2418 return err; 2419 } 2420 2421 return 0; 2422 } 2423 2424 static int __maybe_unused dsa_user_dcbnl_ieee_delapp(struct net_device *dev, 2425 struct dcb_app *app) 2426 { 2427 switch (app->selector) { 2428 case IEEE_8021QAZ_APP_SEL_ETHERTYPE: 2429 switch (app->protocol) { 2430 case 0: 2431 return dsa_user_dcbnl_del_default_prio(dev, app); 2432 default: 2433 return -EOPNOTSUPP; 2434 } 2435 break; 2436 case IEEE_8021QAZ_APP_SEL_DSCP: 2437 return dsa_user_dcbnl_del_dscp_prio(dev, app); 2438 default: 2439 return -EOPNOTSUPP; 2440 } 2441 } 2442 2443 /* Pre-populate the DCB application priority table with the priorities 2444 * configured during switch setup, which we read from hardware here. 2445 */ 2446 static int dsa_user_dcbnl_init(struct net_device *dev) 2447 { 2448 struct dsa_port *dp = dsa_user_to_port(dev); 2449 struct dsa_switch *ds = dp->ds; 2450 int port = dp->index; 2451 int err; 2452 2453 if (ds->ops->port_get_default_prio) { 2454 int prio = ds->ops->port_get_default_prio(ds, port); 2455 struct dcb_app app = { 2456 .selector = IEEE_8021QAZ_APP_SEL_ETHERTYPE, 2457 .protocol = 0, 2458 .priority = prio, 2459 }; 2460 2461 if (prio < 0) 2462 return prio; 2463 2464 err = dcb_ieee_setapp(dev, &app); 2465 if (err) 2466 return err; 2467 } 2468 2469 if (ds->ops->port_get_dscp_prio) { 2470 int protocol; 2471 2472 for (protocol = 0; protocol < 64; protocol++) { 2473 struct dcb_app app = { 2474 .selector = IEEE_8021QAZ_APP_SEL_DSCP, 2475 .protocol = protocol, 2476 }; 2477 int prio; 2478 2479 prio = ds->ops->port_get_dscp_prio(ds, port, protocol); 2480 if (prio == -EOPNOTSUPP) 2481 continue; 2482 if (prio < 0) 2483 return prio; 2484 2485 app.priority = prio; 2486 2487 err = dcb_ieee_setapp(dev, &app); 2488 if (err) 2489 return err; 2490 } 2491 } 2492 2493 return 0; 2494 } 2495 2496 static const struct ethtool_ops dsa_user_ethtool_ops = { 2497 .get_drvinfo = dsa_user_get_drvinfo, 2498 .get_regs_len = dsa_user_get_regs_len, 2499 .get_regs = dsa_user_get_regs, 2500 .nway_reset = dsa_user_nway_reset, 2501 .get_link = ethtool_op_get_link, 2502 .get_eeprom_len = dsa_user_get_eeprom_len, 2503 .get_eeprom = dsa_user_get_eeprom, 2504 .set_eeprom = dsa_user_set_eeprom, 2505 .get_strings = dsa_user_get_strings, 2506 .get_ethtool_stats = dsa_user_get_ethtool_stats, 2507 .get_sset_count = dsa_user_get_sset_count, 2508 .get_eth_phy_stats = dsa_user_get_eth_phy_stats, 2509 .get_eth_mac_stats = dsa_user_get_eth_mac_stats, 2510 .get_eth_ctrl_stats = dsa_user_get_eth_ctrl_stats, 2511 .get_rmon_stats = dsa_user_get_rmon_stats, 2512 .set_wol = dsa_user_set_wol, 2513 .get_wol = dsa_user_get_wol, 2514 .set_eee = dsa_user_set_eee, 2515 .get_eee = dsa_user_get_eee, 2516 .get_link_ksettings = dsa_user_get_link_ksettings, 2517 .set_link_ksettings = dsa_user_set_link_ksettings, 2518 .get_pause_stats = dsa_user_get_pause_stats, 2519 .get_pauseparam = dsa_user_get_pauseparam, 2520 .set_pauseparam = dsa_user_set_pauseparam, 2521 .get_rxnfc = dsa_user_get_rxnfc, 2522 .set_rxnfc = dsa_user_set_rxnfc, 2523 .get_ts_info = dsa_user_get_ts_info, 2524 .self_test = dsa_user_net_selftest, 2525 .get_mm = dsa_user_get_mm, 2526 .set_mm = dsa_user_set_mm, 2527 .get_mm_stats = dsa_user_get_mm_stats, 2528 }; 2529 2530 static const struct dcbnl_rtnl_ops __maybe_unused dsa_user_dcbnl_ops = { 2531 .ieee_setapp = dsa_user_dcbnl_ieee_setapp, 2532 .ieee_delapp = dsa_user_dcbnl_ieee_delapp, 2533 .dcbnl_setapptrust = dsa_user_dcbnl_set_apptrust, 2534 .dcbnl_getapptrust = dsa_user_dcbnl_get_apptrust, 2535 }; 2536 2537 static void dsa_user_get_stats64(struct net_device *dev, 2538 struct rtnl_link_stats64 *s) 2539 { 2540 struct dsa_port *dp = dsa_user_to_port(dev); 2541 struct dsa_switch *ds = dp->ds; 2542 2543 if (ds->ops->get_stats64) 2544 ds->ops->get_stats64(ds, dp->index, s); 2545 else 2546 dev_get_tstats64(dev, s); 2547 } 2548 2549 static int dsa_user_fill_forward_path(struct net_device_path_ctx *ctx, 2550 struct net_device_path *path) 2551 { 2552 struct dsa_port *dp = dsa_user_to_port(ctx->dev); 2553 struct net_device *conduit = dsa_port_to_conduit(dp); 2554 struct dsa_port *cpu_dp = dp->cpu_dp; 2555 2556 path->dev = ctx->dev; 2557 path->type = DEV_PATH_DSA; 2558 path->dsa.proto = cpu_dp->tag_ops->proto; 2559 path->dsa.port = dp->index; 2560 ctx->dev = conduit; 2561 2562 return 0; 2563 } 2564 2565 static const struct net_device_ops dsa_user_netdev_ops = { 2566 .ndo_open = dsa_user_open, 2567 .ndo_stop = dsa_user_close, 2568 .ndo_start_xmit = dsa_user_xmit, 2569 .ndo_change_rx_flags = dsa_user_change_rx_flags, 2570 .ndo_set_rx_mode = dsa_user_set_rx_mode, 2571 .ndo_set_mac_address = dsa_user_set_mac_address, 2572 .ndo_fdb_dump = dsa_user_fdb_dump, 2573 .ndo_eth_ioctl = dsa_user_ioctl, 2574 .ndo_get_iflink = dsa_user_get_iflink, 2575 #ifdef CONFIG_NET_POLL_CONTROLLER 2576 .ndo_netpoll_setup = dsa_user_netpoll_setup, 2577 .ndo_netpoll_cleanup = dsa_user_netpoll_cleanup, 2578 .ndo_poll_controller = dsa_user_poll_controller, 2579 #endif 2580 .ndo_setup_tc = dsa_user_setup_tc, 2581 .ndo_get_stats64 = dsa_user_get_stats64, 2582 .ndo_vlan_rx_add_vid = dsa_user_vlan_rx_add_vid, 2583 .ndo_vlan_rx_kill_vid = dsa_user_vlan_rx_kill_vid, 2584 .ndo_change_mtu = dsa_user_change_mtu, 2585 .ndo_fill_forward_path = dsa_user_fill_forward_path, 2586 }; 2587 2588 static const struct device_type dsa_type = { 2589 .name = "dsa", 2590 }; 2591 2592 void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up) 2593 { 2594 const struct dsa_port *dp = dsa_to_port(ds, port); 2595 2596 if (dp->pl) 2597 phylink_mac_change(dp->pl, up); 2598 } 2599 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change); 2600 2601 static void dsa_user_phylink_fixed_state(struct phylink_config *config, 2602 struct phylink_link_state *state) 2603 { 2604 struct dsa_port *dp = dsa_phylink_to_port(config); 2605 struct dsa_switch *ds = dp->ds; 2606 2607 /* No need to check that this operation is valid, the callback would 2608 * not be called if it was not. 2609 */ 2610 ds->ops->phylink_fixed_state(ds, dp->index, state); 2611 } 2612 2613 /* user device setup *******************************************************/ 2614 static int dsa_user_phy_connect(struct net_device *user_dev, int addr, 2615 u32 flags) 2616 { 2617 struct dsa_port *dp = dsa_user_to_port(user_dev); 2618 struct dsa_switch *ds = dp->ds; 2619 2620 user_dev->phydev = mdiobus_get_phy(ds->user_mii_bus, addr); 2621 if (!user_dev->phydev) { 2622 netdev_err(user_dev, "no phy at %d\n", addr); 2623 return -ENODEV; 2624 } 2625 2626 user_dev->phydev->dev_flags |= flags; 2627 2628 return phylink_connect_phy(dp->pl, user_dev->phydev); 2629 } 2630 2631 static int dsa_user_phy_setup(struct net_device *user_dev) 2632 { 2633 struct dsa_port *dp = dsa_user_to_port(user_dev); 2634 struct device_node *port_dn = dp->dn; 2635 struct dsa_switch *ds = dp->ds; 2636 u32 phy_flags = 0; 2637 int ret; 2638 2639 dp->pl_config.dev = &user_dev->dev; 2640 dp->pl_config.type = PHYLINK_NETDEV; 2641 2642 /* The get_fixed_state callback takes precedence over polling the 2643 * link GPIO in PHYLINK (see phylink_get_fixed_state). Only set 2644 * this if the switch provides such a callback. 2645 */ 2646 if (ds->ops->phylink_fixed_state) { 2647 dp->pl_config.get_fixed_state = dsa_user_phylink_fixed_state; 2648 dp->pl_config.poll_fixed_state = true; 2649 } 2650 2651 ret = dsa_port_phylink_create(dp); 2652 if (ret) 2653 return ret; 2654 2655 if (ds->ops->get_phy_flags) 2656 phy_flags = ds->ops->get_phy_flags(ds, dp->index); 2657 2658 ret = phylink_of_phy_connect(dp->pl, port_dn, phy_flags); 2659 if (ret == -ENODEV && ds->user_mii_bus) { 2660 /* We could not connect to a designated PHY or SFP, so try to 2661 * use the switch internal MDIO bus instead 2662 */ 2663 ret = dsa_user_phy_connect(user_dev, dp->index, phy_flags); 2664 } 2665 if (ret) { 2666 netdev_err(user_dev, "failed to connect to PHY: %pe\n", 2667 ERR_PTR(ret)); 2668 dsa_port_phylink_destroy(dp); 2669 } 2670 2671 return ret; 2672 } 2673 2674 void dsa_user_setup_tagger(struct net_device *user) 2675 { 2676 struct dsa_port *dp = dsa_user_to_port(user); 2677 struct net_device *conduit = dsa_port_to_conduit(dp); 2678 struct dsa_user_priv *p = netdev_priv(user); 2679 const struct dsa_port *cpu_dp = dp->cpu_dp; 2680 const struct dsa_switch *ds = dp->ds; 2681 2682 user->needed_headroom = cpu_dp->tag_ops->needed_headroom; 2683 user->needed_tailroom = cpu_dp->tag_ops->needed_tailroom; 2684 /* Try to save one extra realloc later in the TX path (in the conduit) 2685 * by also inheriting the conduit's needed headroom and tailroom. 2686 * The 8021q driver also does this. 2687 */ 2688 user->needed_headroom += conduit->needed_headroom; 2689 user->needed_tailroom += conduit->needed_tailroom; 2690 2691 p->xmit = cpu_dp->tag_ops->xmit; 2692 2693 user->features = conduit->vlan_features | NETIF_F_HW_TC; 2694 user->hw_features |= NETIF_F_HW_TC; 2695 if (user->needed_tailroom) 2696 user->features &= ~(NETIF_F_SG | NETIF_F_FRAGLIST); 2697 if (ds->needs_standalone_vlan_filtering) 2698 user->features |= NETIF_F_HW_VLAN_CTAG_FILTER; 2699 2700 user->lltx = true; 2701 } 2702 2703 int dsa_user_suspend(struct net_device *user_dev) 2704 { 2705 struct dsa_port *dp = dsa_user_to_port(user_dev); 2706 2707 if (!netif_running(user_dev)) 2708 return 0; 2709 2710 netif_device_detach(user_dev); 2711 2712 rtnl_lock(); 2713 phylink_stop(dp->pl); 2714 rtnl_unlock(); 2715 2716 return 0; 2717 } 2718 2719 int dsa_user_resume(struct net_device *user_dev) 2720 { 2721 struct dsa_port *dp = dsa_user_to_port(user_dev); 2722 2723 if (!netif_running(user_dev)) 2724 return 0; 2725 2726 netif_device_attach(user_dev); 2727 2728 rtnl_lock(); 2729 phylink_start(dp->pl); 2730 rtnl_unlock(); 2731 2732 return 0; 2733 } 2734 2735 int dsa_user_create(struct dsa_port *port) 2736 { 2737 struct net_device *conduit = dsa_port_to_conduit(port); 2738 struct dsa_switch *ds = port->ds; 2739 struct net_device *user_dev; 2740 struct dsa_user_priv *p; 2741 const char *name; 2742 int assign_type; 2743 int ret; 2744 2745 if (!ds->num_tx_queues) 2746 ds->num_tx_queues = 1; 2747 2748 if (port->name) { 2749 name = port->name; 2750 assign_type = NET_NAME_PREDICTABLE; 2751 } else { 2752 name = "eth%d"; 2753 assign_type = NET_NAME_ENUM; 2754 } 2755 2756 user_dev = alloc_netdev_mqs(sizeof(struct dsa_user_priv), name, 2757 assign_type, ether_setup, 2758 ds->num_tx_queues, 1); 2759 if (user_dev == NULL) 2760 return -ENOMEM; 2761 2762 user_dev->rtnl_link_ops = &dsa_link_ops; 2763 user_dev->ethtool_ops = &dsa_user_ethtool_ops; 2764 #if IS_ENABLED(CONFIG_DCB) 2765 user_dev->dcbnl_ops = &dsa_user_dcbnl_ops; 2766 #endif 2767 if (!is_zero_ether_addr(port->mac)) 2768 eth_hw_addr_set(user_dev, port->mac); 2769 else 2770 eth_hw_addr_inherit(user_dev, conduit); 2771 user_dev->priv_flags |= IFF_NO_QUEUE; 2772 if (dsa_switch_supports_uc_filtering(ds)) 2773 user_dev->priv_flags |= IFF_UNICAST_FLT; 2774 user_dev->netdev_ops = &dsa_user_netdev_ops; 2775 if (ds->ops->port_max_mtu) 2776 user_dev->max_mtu = ds->ops->port_max_mtu(ds, port->index); 2777 SET_NETDEV_DEVTYPE(user_dev, &dsa_type); 2778 2779 SET_NETDEV_DEV(user_dev, port->ds->dev); 2780 SET_NETDEV_DEVLINK_PORT(user_dev, &port->devlink_port); 2781 user_dev->dev.of_node = port->dn; 2782 user_dev->vlan_features = conduit->vlan_features; 2783 2784 p = netdev_priv(user_dev); 2785 user_dev->pcpu_stat_type = NETDEV_PCPU_STAT_TSTATS; 2786 2787 ret = gro_cells_init(&p->gcells, user_dev); 2788 if (ret) 2789 goto out_free; 2790 2791 p->dp = port; 2792 INIT_LIST_HEAD(&p->mall_tc_list); 2793 port->user = user_dev; 2794 dsa_user_setup_tagger(user_dev); 2795 2796 netif_carrier_off(user_dev); 2797 2798 ret = dsa_user_phy_setup(user_dev); 2799 if (ret) { 2800 netdev_err(user_dev, 2801 "error %d setting up PHY for tree %d, switch %d, port %d\n", 2802 ret, ds->dst->index, ds->index, port->index); 2803 goto out_gcells; 2804 } 2805 2806 rtnl_lock(); 2807 2808 ret = dsa_user_change_mtu(user_dev, ETH_DATA_LEN); 2809 if (ret && ret != -EOPNOTSUPP) 2810 dev_warn(ds->dev, "nonfatal error %d setting MTU to %d on port %d\n", 2811 ret, ETH_DATA_LEN, port->index); 2812 2813 ret = register_netdevice(user_dev); 2814 if (ret) { 2815 netdev_err(conduit, "error %d registering interface %s\n", 2816 ret, user_dev->name); 2817 rtnl_unlock(); 2818 goto out_phy; 2819 } 2820 2821 if (IS_ENABLED(CONFIG_DCB)) { 2822 ret = dsa_user_dcbnl_init(user_dev); 2823 if (ret) { 2824 netdev_err(user_dev, 2825 "failed to initialize DCB: %pe\n", 2826 ERR_PTR(ret)); 2827 rtnl_unlock(); 2828 goto out_unregister; 2829 } 2830 } 2831 2832 ret = netdev_upper_dev_link(conduit, user_dev, NULL); 2833 2834 rtnl_unlock(); 2835 2836 if (ret) 2837 goto out_unregister; 2838 2839 return 0; 2840 2841 out_unregister: 2842 unregister_netdev(user_dev); 2843 out_phy: 2844 rtnl_lock(); 2845 phylink_disconnect_phy(p->dp->pl); 2846 rtnl_unlock(); 2847 dsa_port_phylink_destroy(p->dp); 2848 out_gcells: 2849 gro_cells_destroy(&p->gcells); 2850 out_free: 2851 free_netdev(user_dev); 2852 port->user = NULL; 2853 return ret; 2854 } 2855 2856 void dsa_user_destroy(struct net_device *user_dev) 2857 { 2858 struct net_device *conduit = dsa_user_to_conduit(user_dev); 2859 struct dsa_port *dp = dsa_user_to_port(user_dev); 2860 struct dsa_user_priv *p = netdev_priv(user_dev); 2861 2862 netif_carrier_off(user_dev); 2863 rtnl_lock(); 2864 netdev_upper_dev_unlink(conduit, user_dev); 2865 unregister_netdevice(user_dev); 2866 phylink_disconnect_phy(dp->pl); 2867 rtnl_unlock(); 2868 2869 dsa_port_phylink_destroy(dp); 2870 gro_cells_destroy(&p->gcells); 2871 free_netdev(user_dev); 2872 } 2873 2874 int dsa_user_change_conduit(struct net_device *dev, struct net_device *conduit, 2875 struct netlink_ext_ack *extack) 2876 { 2877 struct net_device *old_conduit = dsa_user_to_conduit(dev); 2878 struct dsa_port *dp = dsa_user_to_port(dev); 2879 struct dsa_switch *ds = dp->ds; 2880 struct net_device *upper; 2881 struct list_head *iter; 2882 int err; 2883 2884 if (conduit == old_conduit) 2885 return 0; 2886 2887 if (!ds->ops->port_change_conduit) { 2888 NL_SET_ERR_MSG_MOD(extack, 2889 "Driver does not support changing DSA conduit"); 2890 return -EOPNOTSUPP; 2891 } 2892 2893 if (!netdev_uses_dsa(conduit)) { 2894 NL_SET_ERR_MSG_MOD(extack, 2895 "Interface not eligible as DSA conduit"); 2896 return -EOPNOTSUPP; 2897 } 2898 2899 netdev_for_each_upper_dev_rcu(conduit, upper, iter) { 2900 if (dsa_user_dev_check(upper)) 2901 continue; 2902 if (netif_is_bridge_master(upper)) 2903 continue; 2904 NL_SET_ERR_MSG_MOD(extack, "Cannot join conduit with unknown uppers"); 2905 return -EOPNOTSUPP; 2906 } 2907 2908 /* Since we allow live-changing the DSA conduit, plus we auto-open the 2909 * DSA conduit when the user port opens => we need to ensure that the 2910 * new DSA conduit is open too. 2911 */ 2912 if (dev->flags & IFF_UP) { 2913 err = dev_open(conduit, extack); 2914 if (err) 2915 return err; 2916 } 2917 2918 netdev_upper_dev_unlink(old_conduit, dev); 2919 2920 err = netdev_upper_dev_link(conduit, dev, extack); 2921 if (err) 2922 goto out_revert_old_conduit_unlink; 2923 2924 err = dsa_port_change_conduit(dp, conduit, extack); 2925 if (err) 2926 goto out_revert_conduit_link; 2927 2928 /* Update the MTU of the new CPU port through cross-chip notifiers */ 2929 err = dsa_user_change_mtu(dev, dev->mtu); 2930 if (err && err != -EOPNOTSUPP) { 2931 netdev_warn(dev, 2932 "nonfatal error updating MTU with new conduit: %pe\n", 2933 ERR_PTR(err)); 2934 } 2935 2936 return 0; 2937 2938 out_revert_conduit_link: 2939 netdev_upper_dev_unlink(conduit, dev); 2940 out_revert_old_conduit_unlink: 2941 netdev_upper_dev_link(old_conduit, dev, NULL); 2942 return err; 2943 } 2944 2945 bool dsa_user_dev_check(const struct net_device *dev) 2946 { 2947 return dev->netdev_ops == &dsa_user_netdev_ops; 2948 } 2949 EXPORT_SYMBOL_GPL(dsa_user_dev_check); 2950 2951 static int dsa_user_changeupper(struct net_device *dev, 2952 struct netdev_notifier_changeupper_info *info) 2953 { 2954 struct netlink_ext_ack *extack; 2955 int err = NOTIFY_DONE; 2956 struct dsa_port *dp; 2957 2958 if (!dsa_user_dev_check(dev)) 2959 return err; 2960 2961 dp = dsa_user_to_port(dev); 2962 extack = netdev_notifier_info_to_extack(&info->info); 2963 2964 if (netif_is_bridge_master(info->upper_dev)) { 2965 if (info->linking) { 2966 err = dsa_port_bridge_join(dp, info->upper_dev, extack); 2967 if (!err) 2968 dsa_bridge_mtu_normalization(dp); 2969 if (err == -EOPNOTSUPP) { 2970 NL_SET_ERR_MSG_WEAK_MOD(extack, 2971 "Offloading not supported"); 2972 err = 0; 2973 } 2974 err = notifier_from_errno(err); 2975 } else { 2976 dsa_port_bridge_leave(dp, info->upper_dev); 2977 err = NOTIFY_OK; 2978 } 2979 } else if (netif_is_lag_master(info->upper_dev)) { 2980 if (info->linking) { 2981 err = dsa_port_lag_join(dp, info->upper_dev, 2982 info->upper_info, extack); 2983 if (err == -EOPNOTSUPP) { 2984 NL_SET_ERR_MSG_WEAK_MOD(extack, 2985 "Offloading not supported"); 2986 err = 0; 2987 } 2988 err = notifier_from_errno(err); 2989 } else { 2990 dsa_port_lag_leave(dp, info->upper_dev); 2991 err = NOTIFY_OK; 2992 } 2993 } else if (is_hsr_master(info->upper_dev)) { 2994 if (info->linking) { 2995 err = dsa_port_hsr_join(dp, info->upper_dev, extack); 2996 if (err == -EOPNOTSUPP) { 2997 NL_SET_ERR_MSG_WEAK_MOD(extack, 2998 "Offloading not supported"); 2999 err = 0; 3000 } 3001 err = notifier_from_errno(err); 3002 } else { 3003 dsa_port_hsr_leave(dp, info->upper_dev); 3004 err = NOTIFY_OK; 3005 } 3006 } 3007 3008 return err; 3009 } 3010 3011 static int dsa_user_prechangeupper(struct net_device *dev, 3012 struct netdev_notifier_changeupper_info *info) 3013 { 3014 struct dsa_port *dp; 3015 3016 if (!dsa_user_dev_check(dev)) 3017 return NOTIFY_DONE; 3018 3019 dp = dsa_user_to_port(dev); 3020 3021 if (netif_is_bridge_master(info->upper_dev) && !info->linking) 3022 dsa_port_pre_bridge_leave(dp, info->upper_dev); 3023 else if (netif_is_lag_master(info->upper_dev) && !info->linking) 3024 dsa_port_pre_lag_leave(dp, info->upper_dev); 3025 /* dsa_port_pre_hsr_leave is not yet necessary since hsr devices cannot 3026 * meaningfully placed under a bridge yet 3027 */ 3028 3029 return NOTIFY_DONE; 3030 } 3031 3032 static int 3033 dsa_user_lag_changeupper(struct net_device *dev, 3034 struct netdev_notifier_changeupper_info *info) 3035 { 3036 struct net_device *lower; 3037 struct list_head *iter; 3038 int err = NOTIFY_DONE; 3039 struct dsa_port *dp; 3040 3041 if (!netif_is_lag_master(dev)) 3042 return err; 3043 3044 netdev_for_each_lower_dev(dev, lower, iter) { 3045 if (!dsa_user_dev_check(lower)) 3046 continue; 3047 3048 dp = dsa_user_to_port(lower); 3049 if (!dp->lag) 3050 /* Software LAG */ 3051 continue; 3052 3053 err = dsa_user_changeupper(lower, info); 3054 if (notifier_to_errno(err)) 3055 break; 3056 } 3057 3058 return err; 3059 } 3060 3061 /* Same as dsa_user_lag_changeupper() except that it calls 3062 * dsa_user_prechangeupper() 3063 */ 3064 static int 3065 dsa_user_lag_prechangeupper(struct net_device *dev, 3066 struct netdev_notifier_changeupper_info *info) 3067 { 3068 struct net_device *lower; 3069 struct list_head *iter; 3070 int err = NOTIFY_DONE; 3071 struct dsa_port *dp; 3072 3073 if (!netif_is_lag_master(dev)) 3074 return err; 3075 3076 netdev_for_each_lower_dev(dev, lower, iter) { 3077 if (!dsa_user_dev_check(lower)) 3078 continue; 3079 3080 dp = dsa_user_to_port(lower); 3081 if (!dp->lag) 3082 /* Software LAG */ 3083 continue; 3084 3085 err = dsa_user_prechangeupper(lower, info); 3086 if (notifier_to_errno(err)) 3087 break; 3088 } 3089 3090 return err; 3091 } 3092 3093 static int 3094 dsa_prevent_bridging_8021q_upper(struct net_device *dev, 3095 struct netdev_notifier_changeupper_info *info) 3096 { 3097 struct netlink_ext_ack *ext_ack; 3098 struct net_device *user, *br; 3099 struct dsa_port *dp; 3100 3101 ext_ack = netdev_notifier_info_to_extack(&info->info); 3102 3103 if (!is_vlan_dev(dev)) 3104 return NOTIFY_DONE; 3105 3106 user = vlan_dev_real_dev(dev); 3107 if (!dsa_user_dev_check(user)) 3108 return NOTIFY_DONE; 3109 3110 dp = dsa_user_to_port(user); 3111 br = dsa_port_bridge_dev_get(dp); 3112 if (!br) 3113 return NOTIFY_DONE; 3114 3115 /* Deny enslaving a VLAN device into a VLAN-aware bridge */ 3116 if (br_vlan_enabled(br) && 3117 netif_is_bridge_master(info->upper_dev) && info->linking) { 3118 NL_SET_ERR_MSG_MOD(ext_ack, 3119 "Cannot make VLAN device join VLAN-aware bridge"); 3120 return notifier_from_errno(-EINVAL); 3121 } 3122 3123 return NOTIFY_DONE; 3124 } 3125 3126 static int 3127 dsa_user_check_8021q_upper(struct net_device *dev, 3128 struct netdev_notifier_changeupper_info *info) 3129 { 3130 struct dsa_port *dp = dsa_user_to_port(dev); 3131 struct net_device *br = dsa_port_bridge_dev_get(dp); 3132 struct bridge_vlan_info br_info; 3133 struct netlink_ext_ack *extack; 3134 int err = NOTIFY_DONE; 3135 u16 vid; 3136 3137 if (!br || !br_vlan_enabled(br)) 3138 return NOTIFY_DONE; 3139 3140 extack = netdev_notifier_info_to_extack(&info->info); 3141 vid = vlan_dev_vlan_id(info->upper_dev); 3142 3143 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the 3144 * device, respectively the VID is not found, returning 3145 * 0 means success, which is a failure for us here. 3146 */ 3147 err = br_vlan_get_info(br, vid, &br_info); 3148 if (err == 0) { 3149 NL_SET_ERR_MSG_MOD(extack, 3150 "This VLAN is already configured by the bridge"); 3151 return notifier_from_errno(-EBUSY); 3152 } 3153 3154 return NOTIFY_DONE; 3155 } 3156 3157 static int 3158 dsa_user_prechangeupper_sanity_check(struct net_device *dev, 3159 struct netdev_notifier_changeupper_info *info) 3160 { 3161 struct dsa_switch *ds; 3162 struct dsa_port *dp; 3163 int err; 3164 3165 if (!dsa_user_dev_check(dev)) 3166 return dsa_prevent_bridging_8021q_upper(dev, info); 3167 3168 dp = dsa_user_to_port(dev); 3169 ds = dp->ds; 3170 3171 if (ds->ops->port_prechangeupper) { 3172 err = ds->ops->port_prechangeupper(ds, dp->index, info); 3173 if (err) 3174 return notifier_from_errno(err); 3175 } 3176 3177 if (is_vlan_dev(info->upper_dev)) 3178 return dsa_user_check_8021q_upper(dev, info); 3179 3180 return NOTIFY_DONE; 3181 } 3182 3183 /* To be eligible as a DSA conduit, a LAG must have all lower interfaces be 3184 * eligible DSA conduits. Additionally, all LAG slaves must be DSA conduits of 3185 * switches in the same switch tree. 3186 */ 3187 static int dsa_lag_conduit_validate(struct net_device *lag_dev, 3188 struct netlink_ext_ack *extack) 3189 { 3190 struct net_device *lower1, *lower2; 3191 struct list_head *iter1, *iter2; 3192 3193 netdev_for_each_lower_dev(lag_dev, lower1, iter1) { 3194 netdev_for_each_lower_dev(lag_dev, lower2, iter2) { 3195 if (!netdev_uses_dsa(lower1) || 3196 !netdev_uses_dsa(lower2)) { 3197 NL_SET_ERR_MSG_MOD(extack, 3198 "All LAG ports must be eligible as DSA conduits"); 3199 return notifier_from_errno(-EINVAL); 3200 } 3201 3202 if (lower1 == lower2) 3203 continue; 3204 3205 if (!dsa_port_tree_same(lower1->dsa_ptr, 3206 lower2->dsa_ptr)) { 3207 NL_SET_ERR_MSG_MOD(extack, 3208 "LAG contains DSA conduits of disjoint switch trees"); 3209 return notifier_from_errno(-EINVAL); 3210 } 3211 } 3212 } 3213 3214 return NOTIFY_DONE; 3215 } 3216 3217 static int 3218 dsa_conduit_prechangeupper_sanity_check(struct net_device *conduit, 3219 struct netdev_notifier_changeupper_info *info) 3220 { 3221 struct netlink_ext_ack *extack = netdev_notifier_info_to_extack(&info->info); 3222 3223 if (!netdev_uses_dsa(conduit)) 3224 return NOTIFY_DONE; 3225 3226 if (!info->linking) 3227 return NOTIFY_DONE; 3228 3229 /* Allow DSA switch uppers */ 3230 if (dsa_user_dev_check(info->upper_dev)) 3231 return NOTIFY_DONE; 3232 3233 /* Allow bridge uppers of DSA conduits, subject to further 3234 * restrictions in dsa_bridge_prechangelower_sanity_check() 3235 */ 3236 if (netif_is_bridge_master(info->upper_dev)) 3237 return NOTIFY_DONE; 3238 3239 /* Allow LAG uppers, subject to further restrictions in 3240 * dsa_lag_conduit_prechangelower_sanity_check() 3241 */ 3242 if (netif_is_lag_master(info->upper_dev)) 3243 return dsa_lag_conduit_validate(info->upper_dev, extack); 3244 3245 NL_SET_ERR_MSG_MOD(extack, 3246 "DSA conduit cannot join unknown upper interfaces"); 3247 return notifier_from_errno(-EBUSY); 3248 } 3249 3250 static int 3251 dsa_lag_conduit_prechangelower_sanity_check(struct net_device *dev, 3252 struct netdev_notifier_changeupper_info *info) 3253 { 3254 struct netlink_ext_ack *extack = netdev_notifier_info_to_extack(&info->info); 3255 struct net_device *lag_dev = info->upper_dev; 3256 struct net_device *lower; 3257 struct list_head *iter; 3258 3259 if (!netdev_uses_dsa(lag_dev) || !netif_is_lag_master(lag_dev)) 3260 return NOTIFY_DONE; 3261 3262 if (!info->linking) 3263 return NOTIFY_DONE; 3264 3265 if (!netdev_uses_dsa(dev)) { 3266 NL_SET_ERR_MSG(extack, 3267 "Only DSA conduits can join a LAG DSA conduit"); 3268 return notifier_from_errno(-EINVAL); 3269 } 3270 3271 netdev_for_each_lower_dev(lag_dev, lower, iter) { 3272 if (!dsa_port_tree_same(dev->dsa_ptr, lower->dsa_ptr)) { 3273 NL_SET_ERR_MSG(extack, 3274 "Interface is DSA conduit for a different switch tree than this LAG"); 3275 return notifier_from_errno(-EINVAL); 3276 } 3277 3278 break; 3279 } 3280 3281 return NOTIFY_DONE; 3282 } 3283 3284 /* Don't allow bridging of DSA conduits, since the bridge layer rx_handler 3285 * prevents the DSA fake ethertype handler to be invoked, so we don't get the 3286 * chance to strip off and parse the DSA switch tag protocol header (the bridge 3287 * layer just returns RX_HANDLER_CONSUMED, stopping RX processing for these 3288 * frames). 3289 * The only case where that would not be an issue is when bridging can already 3290 * be offloaded, such as when the DSA conduit is itself a DSA or plain switchdev 3291 * port, and is bridged only with other ports from the same hardware device. 3292 */ 3293 static int 3294 dsa_bridge_prechangelower_sanity_check(struct net_device *new_lower, 3295 struct netdev_notifier_changeupper_info *info) 3296 { 3297 struct net_device *br = info->upper_dev; 3298 struct netlink_ext_ack *extack; 3299 struct net_device *lower; 3300 struct list_head *iter; 3301 3302 if (!netif_is_bridge_master(br)) 3303 return NOTIFY_DONE; 3304 3305 if (!info->linking) 3306 return NOTIFY_DONE; 3307 3308 extack = netdev_notifier_info_to_extack(&info->info); 3309 3310 netdev_for_each_lower_dev(br, lower, iter) { 3311 if (!netdev_uses_dsa(new_lower) && !netdev_uses_dsa(lower)) 3312 continue; 3313 3314 if (!netdev_port_same_parent_id(lower, new_lower)) { 3315 NL_SET_ERR_MSG(extack, 3316 "Cannot do software bridging with a DSA conduit"); 3317 return notifier_from_errno(-EINVAL); 3318 } 3319 } 3320 3321 return NOTIFY_DONE; 3322 } 3323 3324 static void dsa_tree_migrate_ports_from_lag_conduit(struct dsa_switch_tree *dst, 3325 struct net_device *lag_dev) 3326 { 3327 struct net_device *new_conduit = dsa_tree_find_first_conduit(dst); 3328 struct dsa_port *dp; 3329 int err; 3330 3331 dsa_tree_for_each_user_port(dp, dst) { 3332 if (dsa_port_to_conduit(dp) != lag_dev) 3333 continue; 3334 3335 err = dsa_user_change_conduit(dp->user, new_conduit, NULL); 3336 if (err) { 3337 netdev_err(dp->user, 3338 "failed to restore conduit to %s: %pe\n", 3339 new_conduit->name, ERR_PTR(err)); 3340 } 3341 } 3342 } 3343 3344 static int dsa_conduit_lag_join(struct net_device *conduit, 3345 struct net_device *lag_dev, 3346 struct netdev_lag_upper_info *uinfo, 3347 struct netlink_ext_ack *extack) 3348 { 3349 struct dsa_port *cpu_dp = conduit->dsa_ptr; 3350 struct dsa_switch_tree *dst = cpu_dp->dst; 3351 struct dsa_port *dp; 3352 int err; 3353 3354 err = dsa_conduit_lag_setup(lag_dev, cpu_dp, uinfo, extack); 3355 if (err) 3356 return err; 3357 3358 dsa_tree_for_each_user_port(dp, dst) { 3359 if (dsa_port_to_conduit(dp) != conduit) 3360 continue; 3361 3362 err = dsa_user_change_conduit(dp->user, lag_dev, extack); 3363 if (err) 3364 goto restore; 3365 } 3366 3367 return 0; 3368 3369 restore: 3370 dsa_tree_for_each_user_port_continue_reverse(dp, dst) { 3371 if (dsa_port_to_conduit(dp) != lag_dev) 3372 continue; 3373 3374 err = dsa_user_change_conduit(dp->user, conduit, NULL); 3375 if (err) { 3376 netdev_err(dp->user, 3377 "failed to restore conduit to %s: %pe\n", 3378 conduit->name, ERR_PTR(err)); 3379 } 3380 } 3381 3382 dsa_conduit_lag_teardown(lag_dev, conduit->dsa_ptr); 3383 3384 return err; 3385 } 3386 3387 static void dsa_conduit_lag_leave(struct net_device *conduit, 3388 struct net_device *lag_dev) 3389 { 3390 struct dsa_port *dp, *cpu_dp = lag_dev->dsa_ptr; 3391 struct dsa_switch_tree *dst = cpu_dp->dst; 3392 struct dsa_port *new_cpu_dp = NULL; 3393 struct net_device *lower; 3394 struct list_head *iter; 3395 3396 netdev_for_each_lower_dev(lag_dev, lower, iter) { 3397 if (netdev_uses_dsa(lower)) { 3398 new_cpu_dp = lower->dsa_ptr; 3399 break; 3400 } 3401 } 3402 3403 if (new_cpu_dp) { 3404 /* Update the CPU port of the user ports still under the LAG 3405 * so that dsa_port_to_conduit() continues to work properly 3406 */ 3407 dsa_tree_for_each_user_port(dp, dst) 3408 if (dsa_port_to_conduit(dp) == lag_dev) 3409 dp->cpu_dp = new_cpu_dp; 3410 3411 /* Update the index of the virtual CPU port to match the lowest 3412 * physical CPU port 3413 */ 3414 lag_dev->dsa_ptr = new_cpu_dp; 3415 wmb(); 3416 } else { 3417 /* If the LAG DSA conduit has no ports left, migrate back all 3418 * user ports to the first physical CPU port 3419 */ 3420 dsa_tree_migrate_ports_from_lag_conduit(dst, lag_dev); 3421 } 3422 3423 /* This DSA conduit has left its LAG in any case, so let 3424 * the CPU port leave the hardware LAG as well 3425 */ 3426 dsa_conduit_lag_teardown(lag_dev, conduit->dsa_ptr); 3427 } 3428 3429 static int dsa_conduit_changeupper(struct net_device *dev, 3430 struct netdev_notifier_changeupper_info *info) 3431 { 3432 struct netlink_ext_ack *extack; 3433 int err = NOTIFY_DONE; 3434 3435 if (!netdev_uses_dsa(dev)) 3436 return err; 3437 3438 extack = netdev_notifier_info_to_extack(&info->info); 3439 3440 if (netif_is_lag_master(info->upper_dev)) { 3441 if (info->linking) { 3442 err = dsa_conduit_lag_join(dev, info->upper_dev, 3443 info->upper_info, extack); 3444 err = notifier_from_errno(err); 3445 } else { 3446 dsa_conduit_lag_leave(dev, info->upper_dev); 3447 err = NOTIFY_OK; 3448 } 3449 } 3450 3451 return err; 3452 } 3453 3454 static int dsa_user_netdevice_event(struct notifier_block *nb, 3455 unsigned long event, void *ptr) 3456 { 3457 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 3458 3459 switch (event) { 3460 case NETDEV_PRECHANGEUPPER: { 3461 struct netdev_notifier_changeupper_info *info = ptr; 3462 int err; 3463 3464 err = dsa_user_prechangeupper_sanity_check(dev, info); 3465 if (notifier_to_errno(err)) 3466 return err; 3467 3468 err = dsa_conduit_prechangeupper_sanity_check(dev, info); 3469 if (notifier_to_errno(err)) 3470 return err; 3471 3472 err = dsa_lag_conduit_prechangelower_sanity_check(dev, info); 3473 if (notifier_to_errno(err)) 3474 return err; 3475 3476 err = dsa_bridge_prechangelower_sanity_check(dev, info); 3477 if (notifier_to_errno(err)) 3478 return err; 3479 3480 err = dsa_user_prechangeupper(dev, ptr); 3481 if (notifier_to_errno(err)) 3482 return err; 3483 3484 err = dsa_user_lag_prechangeupper(dev, ptr); 3485 if (notifier_to_errno(err)) 3486 return err; 3487 3488 break; 3489 } 3490 case NETDEV_CHANGEUPPER: { 3491 int err; 3492 3493 err = dsa_user_changeupper(dev, ptr); 3494 if (notifier_to_errno(err)) 3495 return err; 3496 3497 err = dsa_user_lag_changeupper(dev, ptr); 3498 if (notifier_to_errno(err)) 3499 return err; 3500 3501 err = dsa_conduit_changeupper(dev, ptr); 3502 if (notifier_to_errno(err)) 3503 return err; 3504 3505 break; 3506 } 3507 case NETDEV_CHANGELOWERSTATE: { 3508 struct netdev_notifier_changelowerstate_info *info = ptr; 3509 struct dsa_port *dp; 3510 int err = 0; 3511 3512 if (dsa_user_dev_check(dev)) { 3513 dp = dsa_user_to_port(dev); 3514 3515 err = dsa_port_lag_change(dp, info->lower_state_info); 3516 } 3517 3518 /* Mirror LAG port events on DSA conduits that are in 3519 * a LAG towards their respective switch CPU ports 3520 */ 3521 if (netdev_uses_dsa(dev)) { 3522 dp = dev->dsa_ptr; 3523 3524 err = dsa_port_lag_change(dp, info->lower_state_info); 3525 } 3526 3527 return notifier_from_errno(err); 3528 } 3529 case NETDEV_CHANGE: 3530 case NETDEV_UP: { 3531 /* Track state of conduit port. 3532 * DSA driver may require the conduit port (and indirectly 3533 * the tagger) to be available for some special operation. 3534 */ 3535 if (netdev_uses_dsa(dev)) { 3536 struct dsa_port *cpu_dp = dev->dsa_ptr; 3537 struct dsa_switch_tree *dst = cpu_dp->ds->dst; 3538 3539 /* Track when the conduit port is UP */ 3540 dsa_tree_conduit_oper_state_change(dst, dev, 3541 netif_oper_up(dev)); 3542 3543 /* Track when the conduit port is ready and can accept 3544 * packet. 3545 * NETDEV_UP event is not enough to flag a port as ready. 3546 * We also have to wait for linkwatch_do_dev to dev_activate 3547 * and emit a NETDEV_CHANGE event. 3548 * We check if a conduit port is ready by checking if the dev 3549 * have a qdisc assigned and is not noop. 3550 */ 3551 dsa_tree_conduit_admin_state_change(dst, dev, 3552 !qdisc_tx_is_noop(dev)); 3553 3554 return NOTIFY_OK; 3555 } 3556 3557 return NOTIFY_DONE; 3558 } 3559 case NETDEV_GOING_DOWN: { 3560 struct dsa_port *dp, *cpu_dp; 3561 struct dsa_switch_tree *dst; 3562 LIST_HEAD(close_list); 3563 3564 if (!netdev_uses_dsa(dev)) 3565 return NOTIFY_DONE; 3566 3567 cpu_dp = dev->dsa_ptr; 3568 dst = cpu_dp->ds->dst; 3569 3570 dsa_tree_conduit_admin_state_change(dst, dev, false); 3571 3572 list_for_each_entry(dp, &dst->ports, list) { 3573 if (!dsa_port_is_user(dp)) 3574 continue; 3575 3576 if (dp->cpu_dp != cpu_dp) 3577 continue; 3578 3579 list_add(&dp->user->close_list, &close_list); 3580 } 3581 3582 dev_close_many(&close_list, true); 3583 3584 return NOTIFY_OK; 3585 } 3586 default: 3587 break; 3588 } 3589 3590 return NOTIFY_DONE; 3591 } 3592 3593 static void 3594 dsa_fdb_offload_notify(struct dsa_switchdev_event_work *switchdev_work) 3595 { 3596 struct switchdev_notifier_fdb_info info = {}; 3597 3598 info.addr = switchdev_work->addr; 3599 info.vid = switchdev_work->vid; 3600 info.offloaded = true; 3601 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, 3602 switchdev_work->orig_dev, &info.info, NULL); 3603 } 3604 3605 static void dsa_user_switchdev_event_work(struct work_struct *work) 3606 { 3607 struct dsa_switchdev_event_work *switchdev_work = 3608 container_of(work, struct dsa_switchdev_event_work, work); 3609 const unsigned char *addr = switchdev_work->addr; 3610 struct net_device *dev = switchdev_work->dev; 3611 u16 vid = switchdev_work->vid; 3612 struct dsa_switch *ds; 3613 struct dsa_port *dp; 3614 int err; 3615 3616 dp = dsa_user_to_port(dev); 3617 ds = dp->ds; 3618 3619 switch (switchdev_work->event) { 3620 case SWITCHDEV_FDB_ADD_TO_DEVICE: 3621 if (switchdev_work->host_addr) 3622 err = dsa_port_bridge_host_fdb_add(dp, addr, vid); 3623 else if (dp->lag) 3624 err = dsa_port_lag_fdb_add(dp, addr, vid); 3625 else 3626 err = dsa_port_fdb_add(dp, addr, vid); 3627 if (err) { 3628 dev_err(ds->dev, 3629 "port %d failed to add %pM vid %d to fdb: %d\n", 3630 dp->index, addr, vid, err); 3631 break; 3632 } 3633 dsa_fdb_offload_notify(switchdev_work); 3634 break; 3635 3636 case SWITCHDEV_FDB_DEL_TO_DEVICE: 3637 if (switchdev_work->host_addr) 3638 err = dsa_port_bridge_host_fdb_del(dp, addr, vid); 3639 else if (dp->lag) 3640 err = dsa_port_lag_fdb_del(dp, addr, vid); 3641 else 3642 err = dsa_port_fdb_del(dp, addr, vid); 3643 if (err) { 3644 dev_err(ds->dev, 3645 "port %d failed to delete %pM vid %d from fdb: %d\n", 3646 dp->index, addr, vid, err); 3647 } 3648 3649 break; 3650 } 3651 3652 kfree(switchdev_work); 3653 } 3654 3655 static bool dsa_foreign_dev_check(const struct net_device *dev, 3656 const struct net_device *foreign_dev) 3657 { 3658 const struct dsa_port *dp = dsa_user_to_port(dev); 3659 struct dsa_switch_tree *dst = dp->ds->dst; 3660 3661 if (netif_is_bridge_master(foreign_dev)) 3662 return !dsa_tree_offloads_bridge_dev(dst, foreign_dev); 3663 3664 if (netif_is_bridge_port(foreign_dev)) 3665 return !dsa_tree_offloads_bridge_port(dst, foreign_dev); 3666 3667 /* Everything else is foreign */ 3668 return true; 3669 } 3670 3671 static int dsa_user_fdb_event(struct net_device *dev, 3672 struct net_device *orig_dev, 3673 unsigned long event, const void *ctx, 3674 const struct switchdev_notifier_fdb_info *fdb_info) 3675 { 3676 struct dsa_switchdev_event_work *switchdev_work; 3677 struct dsa_port *dp = dsa_user_to_port(dev); 3678 bool host_addr = fdb_info->is_local; 3679 struct dsa_switch *ds = dp->ds; 3680 3681 if (ctx && ctx != dp) 3682 return 0; 3683 3684 if (!dp->bridge) 3685 return 0; 3686 3687 if (switchdev_fdb_is_dynamically_learned(fdb_info)) { 3688 if (dsa_port_offloads_bridge_port(dp, orig_dev)) 3689 return 0; 3690 3691 /* FDB entries learned by the software bridge or by foreign 3692 * bridge ports should be installed as host addresses only if 3693 * the driver requests assisted learning. 3694 */ 3695 if (!ds->assisted_learning_on_cpu_port) 3696 return 0; 3697 } 3698 3699 /* Also treat FDB entries on foreign interfaces bridged with us as host 3700 * addresses. 3701 */ 3702 if (dsa_foreign_dev_check(dev, orig_dev)) 3703 host_addr = true; 3704 3705 /* Check early that we're not doing work in vain. 3706 * Host addresses on LAG ports still require regular FDB ops, 3707 * since the CPU port isn't in a LAG. 3708 */ 3709 if (dp->lag && !host_addr) { 3710 if (!ds->ops->lag_fdb_add || !ds->ops->lag_fdb_del) 3711 return -EOPNOTSUPP; 3712 } else { 3713 if (!ds->ops->port_fdb_add || !ds->ops->port_fdb_del) 3714 return -EOPNOTSUPP; 3715 } 3716 3717 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC); 3718 if (!switchdev_work) 3719 return -ENOMEM; 3720 3721 netdev_dbg(dev, "%s FDB entry towards %s, addr %pM vid %d%s\n", 3722 event == SWITCHDEV_FDB_ADD_TO_DEVICE ? "Adding" : "Deleting", 3723 orig_dev->name, fdb_info->addr, fdb_info->vid, 3724 host_addr ? " as host address" : ""); 3725 3726 INIT_WORK(&switchdev_work->work, dsa_user_switchdev_event_work); 3727 switchdev_work->event = event; 3728 switchdev_work->dev = dev; 3729 switchdev_work->orig_dev = orig_dev; 3730 3731 ether_addr_copy(switchdev_work->addr, fdb_info->addr); 3732 switchdev_work->vid = fdb_info->vid; 3733 switchdev_work->host_addr = host_addr; 3734 3735 dsa_schedule_work(&switchdev_work->work); 3736 3737 return 0; 3738 } 3739 3740 /* Called under rcu_read_lock() */ 3741 static int dsa_user_switchdev_event(struct notifier_block *unused, 3742 unsigned long event, void *ptr) 3743 { 3744 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 3745 int err; 3746 3747 switch (event) { 3748 case SWITCHDEV_PORT_ATTR_SET: 3749 err = switchdev_handle_port_attr_set(dev, ptr, 3750 dsa_user_dev_check, 3751 dsa_user_port_attr_set); 3752 return notifier_from_errno(err); 3753 case SWITCHDEV_FDB_ADD_TO_DEVICE: 3754 case SWITCHDEV_FDB_DEL_TO_DEVICE: 3755 err = switchdev_handle_fdb_event_to_device(dev, event, ptr, 3756 dsa_user_dev_check, 3757 dsa_foreign_dev_check, 3758 dsa_user_fdb_event); 3759 return notifier_from_errno(err); 3760 default: 3761 return NOTIFY_DONE; 3762 } 3763 3764 return NOTIFY_OK; 3765 } 3766 3767 static int dsa_user_switchdev_blocking_event(struct notifier_block *unused, 3768 unsigned long event, void *ptr) 3769 { 3770 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 3771 int err; 3772 3773 switch (event) { 3774 case SWITCHDEV_PORT_OBJ_ADD: 3775 err = switchdev_handle_port_obj_add_foreign(dev, ptr, 3776 dsa_user_dev_check, 3777 dsa_foreign_dev_check, 3778 dsa_user_port_obj_add); 3779 return notifier_from_errno(err); 3780 case SWITCHDEV_PORT_OBJ_DEL: 3781 err = switchdev_handle_port_obj_del_foreign(dev, ptr, 3782 dsa_user_dev_check, 3783 dsa_foreign_dev_check, 3784 dsa_user_port_obj_del); 3785 return notifier_from_errno(err); 3786 case SWITCHDEV_PORT_ATTR_SET: 3787 err = switchdev_handle_port_attr_set(dev, ptr, 3788 dsa_user_dev_check, 3789 dsa_user_port_attr_set); 3790 return notifier_from_errno(err); 3791 } 3792 3793 return NOTIFY_DONE; 3794 } 3795 3796 static struct notifier_block dsa_user_nb __read_mostly = { 3797 .notifier_call = dsa_user_netdevice_event, 3798 }; 3799 3800 struct notifier_block dsa_user_switchdev_notifier = { 3801 .notifier_call = dsa_user_switchdev_event, 3802 }; 3803 3804 struct notifier_block dsa_user_switchdev_blocking_notifier = { 3805 .notifier_call = dsa_user_switchdev_blocking_event, 3806 }; 3807 3808 int dsa_user_register_notifier(void) 3809 { 3810 struct notifier_block *nb; 3811 int err; 3812 3813 err = register_netdevice_notifier(&dsa_user_nb); 3814 if (err) 3815 return err; 3816 3817 err = register_switchdev_notifier(&dsa_user_switchdev_notifier); 3818 if (err) 3819 goto err_switchdev_nb; 3820 3821 nb = &dsa_user_switchdev_blocking_notifier; 3822 err = register_switchdev_blocking_notifier(nb); 3823 if (err) 3824 goto err_switchdev_blocking_nb; 3825 3826 return 0; 3827 3828 err_switchdev_blocking_nb: 3829 unregister_switchdev_notifier(&dsa_user_switchdev_notifier); 3830 err_switchdev_nb: 3831 unregister_netdevice_notifier(&dsa_user_nb); 3832 return err; 3833 } 3834 3835 void dsa_user_unregister_notifier(void) 3836 { 3837 struct notifier_block *nb; 3838 int err; 3839 3840 nb = &dsa_user_switchdev_blocking_notifier; 3841 err = unregister_switchdev_blocking_notifier(nb); 3842 if (err) 3843 pr_err("DSA: failed to unregister switchdev blocking notifier (%d)\n", err); 3844 3845 err = unregister_switchdev_notifier(&dsa_user_switchdev_notifier); 3846 if (err) 3847 pr_err("DSA: failed to unregister switchdev notifier (%d)\n", err); 3848 3849 err = unregister_netdevice_notifier(&dsa_user_nb); 3850 if (err) 3851 pr_err("DSA: failed to unregister user notifier (%d)\n", err); 3852 } 3853