1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * net/dsa/slave.c - Slave 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/tc_act/tc_mirred.h> 19 #include <linux/if_bridge.h> 20 #include <linux/netpoll.h> 21 #include <linux/ptp_classify.h> 22 23 #include "dsa_priv.h" 24 25 /* slave mii_bus handling ***************************************************/ 26 static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg) 27 { 28 struct dsa_switch *ds = bus->priv; 29 30 if (ds->phys_mii_mask & (1 << addr)) 31 return ds->ops->phy_read(ds, addr, reg); 32 33 return 0xffff; 34 } 35 36 static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val) 37 { 38 struct dsa_switch *ds = bus->priv; 39 40 if (ds->phys_mii_mask & (1 << addr)) 41 return ds->ops->phy_write(ds, addr, reg, val); 42 43 return 0; 44 } 45 46 void dsa_slave_mii_bus_init(struct dsa_switch *ds) 47 { 48 ds->slave_mii_bus->priv = (void *)ds; 49 ds->slave_mii_bus->name = "dsa slave smi"; 50 ds->slave_mii_bus->read = dsa_slave_phy_read; 51 ds->slave_mii_bus->write = dsa_slave_phy_write; 52 snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d.%d", 53 ds->dst->index, ds->index); 54 ds->slave_mii_bus->parent = ds->dev; 55 ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask; 56 } 57 58 59 /* slave device handling ****************************************************/ 60 static int dsa_slave_get_iflink(const struct net_device *dev) 61 { 62 return dsa_slave_to_master(dev)->ifindex; 63 } 64 65 static int dsa_slave_open(struct net_device *dev) 66 { 67 struct net_device *master = dsa_slave_to_master(dev); 68 struct dsa_port *dp = dsa_slave_to_port(dev); 69 int err; 70 71 if (!(master->flags & IFF_UP)) 72 return -ENETDOWN; 73 74 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) { 75 err = dev_uc_add(master, dev->dev_addr); 76 if (err < 0) 77 goto out; 78 } 79 80 if (dev->flags & IFF_ALLMULTI) { 81 err = dev_set_allmulti(master, 1); 82 if (err < 0) 83 goto del_unicast; 84 } 85 if (dev->flags & IFF_PROMISC) { 86 err = dev_set_promiscuity(master, 1); 87 if (err < 0) 88 goto clear_allmulti; 89 } 90 91 err = dsa_port_enable_rt(dp, dev->phydev); 92 if (err) 93 goto clear_promisc; 94 95 return 0; 96 97 clear_promisc: 98 if (dev->flags & IFF_PROMISC) 99 dev_set_promiscuity(master, -1); 100 clear_allmulti: 101 if (dev->flags & IFF_ALLMULTI) 102 dev_set_allmulti(master, -1); 103 del_unicast: 104 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) 105 dev_uc_del(master, dev->dev_addr); 106 out: 107 return err; 108 } 109 110 static int dsa_slave_close(struct net_device *dev) 111 { 112 struct net_device *master = dsa_slave_to_master(dev); 113 struct dsa_port *dp = dsa_slave_to_port(dev); 114 115 dsa_port_disable_rt(dp); 116 117 dev_mc_unsync(master, dev); 118 dev_uc_unsync(master, dev); 119 if (dev->flags & IFF_ALLMULTI) 120 dev_set_allmulti(master, -1); 121 if (dev->flags & IFF_PROMISC) 122 dev_set_promiscuity(master, -1); 123 124 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) 125 dev_uc_del(master, dev->dev_addr); 126 127 return 0; 128 } 129 130 static void dsa_slave_change_rx_flags(struct net_device *dev, int change) 131 { 132 struct net_device *master = dsa_slave_to_master(dev); 133 if (dev->flags & IFF_UP) { 134 if (change & IFF_ALLMULTI) 135 dev_set_allmulti(master, 136 dev->flags & IFF_ALLMULTI ? 1 : -1); 137 if (change & IFF_PROMISC) 138 dev_set_promiscuity(master, 139 dev->flags & IFF_PROMISC ? 1 : -1); 140 } 141 } 142 143 static void dsa_slave_set_rx_mode(struct net_device *dev) 144 { 145 struct net_device *master = dsa_slave_to_master(dev); 146 147 dev_mc_sync(master, dev); 148 dev_uc_sync(master, dev); 149 } 150 151 static int dsa_slave_set_mac_address(struct net_device *dev, void *a) 152 { 153 struct net_device *master = dsa_slave_to_master(dev); 154 struct sockaddr *addr = a; 155 int err; 156 157 if (!is_valid_ether_addr(addr->sa_data)) 158 return -EADDRNOTAVAIL; 159 160 if (!(dev->flags & IFF_UP)) 161 goto out; 162 163 if (!ether_addr_equal(addr->sa_data, master->dev_addr)) { 164 err = dev_uc_add(master, addr->sa_data); 165 if (err < 0) 166 return err; 167 } 168 169 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) 170 dev_uc_del(master, dev->dev_addr); 171 172 out: 173 ether_addr_copy(dev->dev_addr, addr->sa_data); 174 175 return 0; 176 } 177 178 struct dsa_slave_dump_ctx { 179 struct net_device *dev; 180 struct sk_buff *skb; 181 struct netlink_callback *cb; 182 int idx; 183 }; 184 185 static int 186 dsa_slave_port_fdb_do_dump(const unsigned char *addr, u16 vid, 187 bool is_static, void *data) 188 { 189 struct dsa_slave_dump_ctx *dump = data; 190 u32 portid = NETLINK_CB(dump->cb->skb).portid; 191 u32 seq = dump->cb->nlh->nlmsg_seq; 192 struct nlmsghdr *nlh; 193 struct ndmsg *ndm; 194 195 if (dump->idx < dump->cb->args[2]) 196 goto skip; 197 198 nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH, 199 sizeof(*ndm), NLM_F_MULTI); 200 if (!nlh) 201 return -EMSGSIZE; 202 203 ndm = nlmsg_data(nlh); 204 ndm->ndm_family = AF_BRIDGE; 205 ndm->ndm_pad1 = 0; 206 ndm->ndm_pad2 = 0; 207 ndm->ndm_flags = NTF_SELF; 208 ndm->ndm_type = 0; 209 ndm->ndm_ifindex = dump->dev->ifindex; 210 ndm->ndm_state = is_static ? NUD_NOARP : NUD_REACHABLE; 211 212 if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, addr)) 213 goto nla_put_failure; 214 215 if (vid && nla_put_u16(dump->skb, NDA_VLAN, vid)) 216 goto nla_put_failure; 217 218 nlmsg_end(dump->skb, nlh); 219 220 skip: 221 dump->idx++; 222 return 0; 223 224 nla_put_failure: 225 nlmsg_cancel(dump->skb, nlh); 226 return -EMSGSIZE; 227 } 228 229 static int 230 dsa_slave_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb, 231 struct net_device *dev, struct net_device *filter_dev, 232 int *idx) 233 { 234 struct dsa_port *dp = dsa_slave_to_port(dev); 235 struct dsa_slave_dump_ctx dump = { 236 .dev = dev, 237 .skb = skb, 238 .cb = cb, 239 .idx = *idx, 240 }; 241 int err; 242 243 err = dsa_port_fdb_dump(dp, dsa_slave_port_fdb_do_dump, &dump); 244 *idx = dump.idx; 245 246 return err; 247 } 248 249 static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 250 { 251 struct dsa_slave_priv *p = netdev_priv(dev); 252 struct dsa_switch *ds = p->dp->ds; 253 int port = p->dp->index; 254 255 /* Pass through to switch driver if it supports timestamping */ 256 switch (cmd) { 257 case SIOCGHWTSTAMP: 258 if (ds->ops->port_hwtstamp_get) 259 return ds->ops->port_hwtstamp_get(ds, port, ifr); 260 break; 261 case SIOCSHWTSTAMP: 262 if (ds->ops->port_hwtstamp_set) 263 return ds->ops->port_hwtstamp_set(ds, port, ifr); 264 break; 265 } 266 267 return phylink_mii_ioctl(p->dp->pl, ifr, cmd); 268 } 269 270 static int dsa_slave_port_attr_set(struct net_device *dev, 271 const struct switchdev_attr *attr, 272 struct switchdev_trans *trans) 273 { 274 struct dsa_port *dp = dsa_slave_to_port(dev); 275 int ret; 276 277 switch (attr->id) { 278 case SWITCHDEV_ATTR_ID_PORT_STP_STATE: 279 ret = dsa_port_set_state(dp, attr->u.stp_state, trans); 280 break; 281 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING: 282 ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering, 283 trans); 284 break; 285 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME: 286 ret = dsa_port_ageing_time(dp, attr->u.ageing_time, trans); 287 break; 288 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS: 289 ret = dsa_port_pre_bridge_flags(dp, attr->u.brport_flags, 290 trans); 291 break; 292 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS: 293 ret = dsa_port_bridge_flags(dp, attr->u.brport_flags, trans); 294 break; 295 case SWITCHDEV_ATTR_ID_BRIDGE_MROUTER: 296 ret = dsa_port_mrouter(dp->cpu_dp, attr->u.mrouter, trans); 297 break; 298 default: 299 ret = -EOPNOTSUPP; 300 break; 301 } 302 303 return ret; 304 } 305 306 static int dsa_slave_vlan_add(struct net_device *dev, 307 const struct switchdev_obj *obj, 308 struct switchdev_trans *trans) 309 { 310 struct dsa_port *dp = dsa_slave_to_port(dev); 311 struct switchdev_obj_port_vlan vlan; 312 int err; 313 314 if (obj->orig_dev != dev) 315 return -EOPNOTSUPP; 316 317 if (dp->bridge_dev && !br_vlan_enabled(dp->bridge_dev)) 318 return 0; 319 320 vlan = *SWITCHDEV_OBJ_PORT_VLAN(obj); 321 322 err = dsa_port_vlan_add(dp, &vlan, trans); 323 if (err) 324 return err; 325 326 /* We need the dedicated CPU port to be a member of the VLAN as well. 327 * Even though drivers often handle CPU membership in special ways, 328 * it doesn't make sense to program a PVID, so clear this flag. 329 */ 330 vlan.flags &= ~BRIDGE_VLAN_INFO_PVID; 331 332 err = dsa_port_vlan_add(dp->cpu_dp, &vlan, trans); 333 if (err) 334 return err; 335 336 return 0; 337 } 338 339 static int dsa_slave_port_obj_add(struct net_device *dev, 340 const struct switchdev_obj *obj, 341 struct switchdev_trans *trans, 342 struct netlink_ext_ack *extack) 343 { 344 struct dsa_port *dp = dsa_slave_to_port(dev); 345 int err; 346 347 /* For the prepare phase, ensure the full set of changes is feasable in 348 * one go in order to signal a failure properly. If an operation is not 349 * supported, return -EOPNOTSUPP. 350 */ 351 352 switch (obj->id) { 353 case SWITCHDEV_OBJ_ID_PORT_MDB: 354 if (obj->orig_dev != dev) 355 return -EOPNOTSUPP; 356 err = dsa_port_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj), trans); 357 break; 358 case SWITCHDEV_OBJ_ID_HOST_MDB: 359 /* DSA can directly translate this to a normal MDB add, 360 * but on the CPU port. 361 */ 362 err = dsa_port_mdb_add(dp->cpu_dp, SWITCHDEV_OBJ_PORT_MDB(obj), 363 trans); 364 break; 365 case SWITCHDEV_OBJ_ID_PORT_VLAN: 366 err = dsa_slave_vlan_add(dev, obj, trans); 367 break; 368 default: 369 err = -EOPNOTSUPP; 370 break; 371 } 372 373 return err; 374 } 375 376 static int dsa_slave_vlan_del(struct net_device *dev, 377 const struct switchdev_obj *obj) 378 { 379 struct dsa_port *dp = dsa_slave_to_port(dev); 380 381 if (obj->orig_dev != dev) 382 return -EOPNOTSUPP; 383 384 if (dp->bridge_dev && !br_vlan_enabled(dp->bridge_dev)) 385 return 0; 386 387 /* Do not deprogram the CPU port as it may be shared with other user 388 * ports which can be members of this VLAN as well. 389 */ 390 return dsa_port_vlan_del(dp, SWITCHDEV_OBJ_PORT_VLAN(obj)); 391 } 392 393 static int dsa_slave_port_obj_del(struct net_device *dev, 394 const struct switchdev_obj *obj) 395 { 396 struct dsa_port *dp = dsa_slave_to_port(dev); 397 int err; 398 399 switch (obj->id) { 400 case SWITCHDEV_OBJ_ID_PORT_MDB: 401 if (obj->orig_dev != dev) 402 return -EOPNOTSUPP; 403 err = dsa_port_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj)); 404 break; 405 case SWITCHDEV_OBJ_ID_HOST_MDB: 406 /* DSA can directly translate this to a normal MDB add, 407 * but on the CPU port. 408 */ 409 err = dsa_port_mdb_del(dp->cpu_dp, SWITCHDEV_OBJ_PORT_MDB(obj)); 410 break; 411 case SWITCHDEV_OBJ_ID_PORT_VLAN: 412 err = dsa_slave_vlan_del(dev, obj); 413 break; 414 default: 415 err = -EOPNOTSUPP; 416 break; 417 } 418 419 return err; 420 } 421 422 static int dsa_slave_get_port_parent_id(struct net_device *dev, 423 struct netdev_phys_item_id *ppid) 424 { 425 struct dsa_port *dp = dsa_slave_to_port(dev); 426 struct dsa_switch *ds = dp->ds; 427 struct dsa_switch_tree *dst = ds->dst; 428 429 /* For non-legacy ports, devlink is used and it takes 430 * care of the name generation. This ndo implementation 431 * should be removed with legacy support. 432 */ 433 if (dp->ds->devlink) 434 return -EOPNOTSUPP; 435 436 ppid->id_len = sizeof(dst->index); 437 memcpy(&ppid->id, &dst->index, ppid->id_len); 438 439 return 0; 440 } 441 442 static inline netdev_tx_t dsa_slave_netpoll_send_skb(struct net_device *dev, 443 struct sk_buff *skb) 444 { 445 #ifdef CONFIG_NET_POLL_CONTROLLER 446 struct dsa_slave_priv *p = netdev_priv(dev); 447 448 if (p->netpoll) 449 netpoll_send_skb(p->netpoll, skb); 450 #else 451 BUG(); 452 #endif 453 return NETDEV_TX_OK; 454 } 455 456 static void dsa_skb_tx_timestamp(struct dsa_slave_priv *p, 457 struct sk_buff *skb) 458 { 459 struct dsa_switch *ds = p->dp->ds; 460 struct sk_buff *clone; 461 unsigned int type; 462 463 type = ptp_classify_raw(skb); 464 if (type == PTP_CLASS_NONE) 465 return; 466 467 if (!ds->ops->port_txtstamp) 468 return; 469 470 clone = skb_clone_sk(skb); 471 if (!clone) 472 return; 473 474 DSA_SKB_CB(skb)->clone = clone; 475 476 if (ds->ops->port_txtstamp(ds, p->dp->index, clone, type)) 477 return; 478 479 kfree_skb(clone); 480 } 481 482 netdev_tx_t dsa_enqueue_skb(struct sk_buff *skb, struct net_device *dev) 483 { 484 /* SKB for netpoll still need to be mangled with the protocol-specific 485 * tag to be successfully transmitted 486 */ 487 if (unlikely(netpoll_tx_running(dev))) 488 return dsa_slave_netpoll_send_skb(dev, skb); 489 490 /* Queue the SKB for transmission on the parent interface, but 491 * do not modify its EtherType 492 */ 493 skb->dev = dsa_slave_to_master(dev); 494 dev_queue_xmit(skb); 495 496 return NETDEV_TX_OK; 497 } 498 EXPORT_SYMBOL_GPL(dsa_enqueue_skb); 499 500 static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev) 501 { 502 struct dsa_slave_priv *p = netdev_priv(dev); 503 struct pcpu_sw_netstats *s; 504 struct sk_buff *nskb; 505 506 s = this_cpu_ptr(p->stats64); 507 u64_stats_update_begin(&s->syncp); 508 s->tx_packets++; 509 s->tx_bytes += skb->len; 510 u64_stats_update_end(&s->syncp); 511 512 DSA_SKB_CB(skb)->clone = NULL; 513 514 /* Identify PTP protocol packets, clone them, and pass them to the 515 * switch driver 516 */ 517 dsa_skb_tx_timestamp(p, skb); 518 519 /* Transmit function may have to reallocate the original SKB, 520 * in which case it must have freed it. Only free it here on error. 521 */ 522 nskb = p->xmit(skb, dev); 523 if (!nskb) { 524 kfree_skb(skb); 525 return NETDEV_TX_OK; 526 } 527 528 return dsa_enqueue_skb(nskb, dev); 529 } 530 531 /* ethtool operations *******************************************************/ 532 533 static void dsa_slave_get_drvinfo(struct net_device *dev, 534 struct ethtool_drvinfo *drvinfo) 535 { 536 strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver)); 537 strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version)); 538 strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info)); 539 } 540 541 static int dsa_slave_get_regs_len(struct net_device *dev) 542 { 543 struct dsa_port *dp = dsa_slave_to_port(dev); 544 struct dsa_switch *ds = dp->ds; 545 546 if (ds->ops->get_regs_len) 547 return ds->ops->get_regs_len(ds, dp->index); 548 549 return -EOPNOTSUPP; 550 } 551 552 static void 553 dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p) 554 { 555 struct dsa_port *dp = dsa_slave_to_port(dev); 556 struct dsa_switch *ds = dp->ds; 557 558 if (ds->ops->get_regs) 559 ds->ops->get_regs(ds, dp->index, regs, _p); 560 } 561 562 static int dsa_slave_nway_reset(struct net_device *dev) 563 { 564 struct dsa_port *dp = dsa_slave_to_port(dev); 565 566 return phylink_ethtool_nway_reset(dp->pl); 567 } 568 569 static int dsa_slave_get_eeprom_len(struct net_device *dev) 570 { 571 struct dsa_port *dp = dsa_slave_to_port(dev); 572 struct dsa_switch *ds = dp->ds; 573 574 if (ds->cd && ds->cd->eeprom_len) 575 return ds->cd->eeprom_len; 576 577 if (ds->ops->get_eeprom_len) 578 return ds->ops->get_eeprom_len(ds); 579 580 return 0; 581 } 582 583 static int dsa_slave_get_eeprom(struct net_device *dev, 584 struct ethtool_eeprom *eeprom, u8 *data) 585 { 586 struct dsa_port *dp = dsa_slave_to_port(dev); 587 struct dsa_switch *ds = dp->ds; 588 589 if (ds->ops->get_eeprom) 590 return ds->ops->get_eeprom(ds, eeprom, data); 591 592 return -EOPNOTSUPP; 593 } 594 595 static int dsa_slave_set_eeprom(struct net_device *dev, 596 struct ethtool_eeprom *eeprom, u8 *data) 597 { 598 struct dsa_port *dp = dsa_slave_to_port(dev); 599 struct dsa_switch *ds = dp->ds; 600 601 if (ds->ops->set_eeprom) 602 return ds->ops->set_eeprom(ds, eeprom, data); 603 604 return -EOPNOTSUPP; 605 } 606 607 static void dsa_slave_get_strings(struct net_device *dev, 608 uint32_t stringset, uint8_t *data) 609 { 610 struct dsa_port *dp = dsa_slave_to_port(dev); 611 struct dsa_switch *ds = dp->ds; 612 613 if (stringset == ETH_SS_STATS) { 614 int len = ETH_GSTRING_LEN; 615 616 strncpy(data, "tx_packets", len); 617 strncpy(data + len, "tx_bytes", len); 618 strncpy(data + 2 * len, "rx_packets", len); 619 strncpy(data + 3 * len, "rx_bytes", len); 620 if (ds->ops->get_strings) 621 ds->ops->get_strings(ds, dp->index, stringset, 622 data + 4 * len); 623 } 624 } 625 626 static void dsa_slave_get_ethtool_stats(struct net_device *dev, 627 struct ethtool_stats *stats, 628 uint64_t *data) 629 { 630 struct dsa_port *dp = dsa_slave_to_port(dev); 631 struct dsa_slave_priv *p = netdev_priv(dev); 632 struct dsa_switch *ds = dp->ds; 633 struct pcpu_sw_netstats *s; 634 unsigned int start; 635 int i; 636 637 for_each_possible_cpu(i) { 638 u64 tx_packets, tx_bytes, rx_packets, rx_bytes; 639 640 s = per_cpu_ptr(p->stats64, i); 641 do { 642 start = u64_stats_fetch_begin_irq(&s->syncp); 643 tx_packets = s->tx_packets; 644 tx_bytes = s->tx_bytes; 645 rx_packets = s->rx_packets; 646 rx_bytes = s->rx_bytes; 647 } while (u64_stats_fetch_retry_irq(&s->syncp, start)); 648 data[0] += tx_packets; 649 data[1] += tx_bytes; 650 data[2] += rx_packets; 651 data[3] += rx_bytes; 652 } 653 if (ds->ops->get_ethtool_stats) 654 ds->ops->get_ethtool_stats(ds, dp->index, data + 4); 655 } 656 657 static int dsa_slave_get_sset_count(struct net_device *dev, int sset) 658 { 659 struct dsa_port *dp = dsa_slave_to_port(dev); 660 struct dsa_switch *ds = dp->ds; 661 662 if (sset == ETH_SS_STATS) { 663 int count; 664 665 count = 4; 666 if (ds->ops->get_sset_count) 667 count += ds->ops->get_sset_count(ds, dp->index, sset); 668 669 return count; 670 } 671 672 return -EOPNOTSUPP; 673 } 674 675 static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w) 676 { 677 struct dsa_port *dp = dsa_slave_to_port(dev); 678 struct dsa_switch *ds = dp->ds; 679 680 phylink_ethtool_get_wol(dp->pl, w); 681 682 if (ds->ops->get_wol) 683 ds->ops->get_wol(ds, dp->index, w); 684 } 685 686 static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w) 687 { 688 struct dsa_port *dp = dsa_slave_to_port(dev); 689 struct dsa_switch *ds = dp->ds; 690 int ret = -EOPNOTSUPP; 691 692 phylink_ethtool_set_wol(dp->pl, w); 693 694 if (ds->ops->set_wol) 695 ret = ds->ops->set_wol(ds, dp->index, w); 696 697 return ret; 698 } 699 700 static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e) 701 { 702 struct dsa_port *dp = dsa_slave_to_port(dev); 703 struct dsa_switch *ds = dp->ds; 704 int ret; 705 706 /* Port's PHY and MAC both need to be EEE capable */ 707 if (!dev->phydev || !dp->pl) 708 return -ENODEV; 709 710 if (!ds->ops->set_mac_eee) 711 return -EOPNOTSUPP; 712 713 ret = ds->ops->set_mac_eee(ds, dp->index, e); 714 if (ret) 715 return ret; 716 717 return phylink_ethtool_set_eee(dp->pl, e); 718 } 719 720 static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e) 721 { 722 struct dsa_port *dp = dsa_slave_to_port(dev); 723 struct dsa_switch *ds = dp->ds; 724 int ret; 725 726 /* Port's PHY and MAC both need to be EEE capable */ 727 if (!dev->phydev || !dp->pl) 728 return -ENODEV; 729 730 if (!ds->ops->get_mac_eee) 731 return -EOPNOTSUPP; 732 733 ret = ds->ops->get_mac_eee(ds, dp->index, e); 734 if (ret) 735 return ret; 736 737 return phylink_ethtool_get_eee(dp->pl, e); 738 } 739 740 static int dsa_slave_get_link_ksettings(struct net_device *dev, 741 struct ethtool_link_ksettings *cmd) 742 { 743 struct dsa_port *dp = dsa_slave_to_port(dev); 744 745 return phylink_ethtool_ksettings_get(dp->pl, cmd); 746 } 747 748 static int dsa_slave_set_link_ksettings(struct net_device *dev, 749 const struct ethtool_link_ksettings *cmd) 750 { 751 struct dsa_port *dp = dsa_slave_to_port(dev); 752 753 return phylink_ethtool_ksettings_set(dp->pl, cmd); 754 } 755 756 static void dsa_slave_get_pauseparam(struct net_device *dev, 757 struct ethtool_pauseparam *pause) 758 { 759 struct dsa_port *dp = dsa_slave_to_port(dev); 760 761 phylink_ethtool_get_pauseparam(dp->pl, pause); 762 } 763 764 static int dsa_slave_set_pauseparam(struct net_device *dev, 765 struct ethtool_pauseparam *pause) 766 { 767 struct dsa_port *dp = dsa_slave_to_port(dev); 768 769 return phylink_ethtool_set_pauseparam(dp->pl, pause); 770 } 771 772 #ifdef CONFIG_NET_POLL_CONTROLLER 773 static int dsa_slave_netpoll_setup(struct net_device *dev, 774 struct netpoll_info *ni) 775 { 776 struct net_device *master = dsa_slave_to_master(dev); 777 struct dsa_slave_priv *p = netdev_priv(dev); 778 struct netpoll *netpoll; 779 int err = 0; 780 781 netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL); 782 if (!netpoll) 783 return -ENOMEM; 784 785 err = __netpoll_setup(netpoll, master); 786 if (err) { 787 kfree(netpoll); 788 goto out; 789 } 790 791 p->netpoll = netpoll; 792 out: 793 return err; 794 } 795 796 static void dsa_slave_netpoll_cleanup(struct net_device *dev) 797 { 798 struct dsa_slave_priv *p = netdev_priv(dev); 799 struct netpoll *netpoll = p->netpoll; 800 801 if (!netpoll) 802 return; 803 804 p->netpoll = NULL; 805 806 __netpoll_free(netpoll); 807 } 808 809 static void dsa_slave_poll_controller(struct net_device *dev) 810 { 811 } 812 #endif 813 814 static int dsa_slave_get_phys_port_name(struct net_device *dev, 815 char *name, size_t len) 816 { 817 struct dsa_port *dp = dsa_slave_to_port(dev); 818 819 /* For non-legacy ports, devlink is used and it takes 820 * care of the name generation. This ndo implementation 821 * should be removed with legacy support. 822 */ 823 if (dp->ds->devlink) 824 return -EOPNOTSUPP; 825 826 if (snprintf(name, len, "p%d", dp->index) >= len) 827 return -EINVAL; 828 829 return 0; 830 } 831 832 static struct dsa_mall_tc_entry * 833 dsa_slave_mall_tc_entry_find(struct net_device *dev, unsigned long cookie) 834 { 835 struct dsa_slave_priv *p = netdev_priv(dev); 836 struct dsa_mall_tc_entry *mall_tc_entry; 837 838 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list) 839 if (mall_tc_entry->cookie == cookie) 840 return mall_tc_entry; 841 842 return NULL; 843 } 844 845 static int 846 dsa_slave_add_cls_matchall_mirred(struct net_device *dev, 847 struct tc_cls_matchall_offload *cls, 848 bool ingress) 849 { 850 struct dsa_port *dp = dsa_slave_to_port(dev); 851 struct dsa_slave_priv *p = netdev_priv(dev); 852 struct dsa_mall_mirror_tc_entry *mirror; 853 struct dsa_mall_tc_entry *mall_tc_entry; 854 struct dsa_switch *ds = dp->ds; 855 struct flow_action_entry *act; 856 struct dsa_port *to_dp; 857 int err; 858 859 act = &cls->rule->action.entries[0]; 860 861 if (!ds->ops->port_mirror_add) 862 return err; 863 864 if (!act->dev) 865 return -EINVAL; 866 867 if (!flow_action_basic_hw_stats_check(&cls->rule->action, 868 cls->common.extack)) 869 return err; 870 871 act = &cls->rule->action.entries[0]; 872 873 if (!dsa_slave_dev_check(act->dev)) 874 return -EOPNOTSUPP; 875 876 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL); 877 if (!mall_tc_entry) 878 return -ENOMEM; 879 880 mall_tc_entry->cookie = cls->cookie; 881 mall_tc_entry->type = DSA_PORT_MALL_MIRROR; 882 mirror = &mall_tc_entry->mirror; 883 884 to_dp = dsa_slave_to_port(act->dev); 885 886 mirror->to_local_port = to_dp->index; 887 mirror->ingress = ingress; 888 889 err = ds->ops->port_mirror_add(ds, dp->index, mirror, ingress); 890 if (err) { 891 kfree(mall_tc_entry); 892 return err; 893 } 894 895 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list); 896 897 return err; 898 } 899 900 static int dsa_slave_add_cls_matchall(struct net_device *dev, 901 struct tc_cls_matchall_offload *cls, 902 bool ingress) 903 { 904 int err = -EOPNOTSUPP; 905 906 if (cls->common.protocol == htons(ETH_P_ALL) && 907 flow_offload_has_one_action(&cls->rule->action) && 908 cls->rule->action.entries[0].id == FLOW_ACTION_MIRRED) 909 err = dsa_slave_add_cls_matchall_mirred(dev, cls, ingress); 910 911 return err; 912 } 913 914 static void dsa_slave_del_cls_matchall(struct net_device *dev, 915 struct tc_cls_matchall_offload *cls) 916 { 917 struct dsa_port *dp = dsa_slave_to_port(dev); 918 struct dsa_mall_tc_entry *mall_tc_entry; 919 struct dsa_switch *ds = dp->ds; 920 921 if (!ds->ops->port_mirror_del) 922 return; 923 924 mall_tc_entry = dsa_slave_mall_tc_entry_find(dev, cls->cookie); 925 if (!mall_tc_entry) 926 return; 927 928 list_del(&mall_tc_entry->list); 929 930 switch (mall_tc_entry->type) { 931 case DSA_PORT_MALL_MIRROR: 932 ds->ops->port_mirror_del(ds, dp->index, &mall_tc_entry->mirror); 933 break; 934 default: 935 WARN_ON(1); 936 } 937 938 kfree(mall_tc_entry); 939 } 940 941 static int dsa_slave_setup_tc_cls_matchall(struct net_device *dev, 942 struct tc_cls_matchall_offload *cls, 943 bool ingress) 944 { 945 if (cls->common.chain_index) 946 return -EOPNOTSUPP; 947 948 switch (cls->command) { 949 case TC_CLSMATCHALL_REPLACE: 950 return dsa_slave_add_cls_matchall(dev, cls, ingress); 951 case TC_CLSMATCHALL_DESTROY: 952 dsa_slave_del_cls_matchall(dev, cls); 953 return 0; 954 default: 955 return -EOPNOTSUPP; 956 } 957 } 958 959 static int dsa_slave_add_cls_flower(struct net_device *dev, 960 struct flow_cls_offload *cls, 961 bool ingress) 962 { 963 struct dsa_port *dp = dsa_slave_to_port(dev); 964 struct dsa_switch *ds = dp->ds; 965 int port = dp->index; 966 967 if (!ds->ops->cls_flower_add) 968 return -EOPNOTSUPP; 969 970 return ds->ops->cls_flower_add(ds, port, cls, ingress); 971 } 972 973 static int dsa_slave_del_cls_flower(struct net_device *dev, 974 struct flow_cls_offload *cls, 975 bool ingress) 976 { 977 struct dsa_port *dp = dsa_slave_to_port(dev); 978 struct dsa_switch *ds = dp->ds; 979 int port = dp->index; 980 981 if (!ds->ops->cls_flower_del) 982 return -EOPNOTSUPP; 983 984 return ds->ops->cls_flower_del(ds, port, cls, ingress); 985 } 986 987 static int dsa_slave_stats_cls_flower(struct net_device *dev, 988 struct flow_cls_offload *cls, 989 bool ingress) 990 { 991 struct dsa_port *dp = dsa_slave_to_port(dev); 992 struct dsa_switch *ds = dp->ds; 993 int port = dp->index; 994 995 if (!ds->ops->cls_flower_stats) 996 return -EOPNOTSUPP; 997 998 return ds->ops->cls_flower_stats(ds, port, cls, ingress); 999 } 1000 1001 static int dsa_slave_setup_tc_cls_flower(struct net_device *dev, 1002 struct flow_cls_offload *cls, 1003 bool ingress) 1004 { 1005 switch (cls->command) { 1006 case FLOW_CLS_REPLACE: 1007 return dsa_slave_add_cls_flower(dev, cls, ingress); 1008 case FLOW_CLS_DESTROY: 1009 return dsa_slave_del_cls_flower(dev, cls, ingress); 1010 case FLOW_CLS_STATS: 1011 return dsa_slave_stats_cls_flower(dev, cls, ingress); 1012 default: 1013 return -EOPNOTSUPP; 1014 } 1015 } 1016 1017 static int dsa_slave_setup_tc_block_cb(enum tc_setup_type type, void *type_data, 1018 void *cb_priv, bool ingress) 1019 { 1020 struct net_device *dev = cb_priv; 1021 1022 if (!tc_can_offload(dev)) 1023 return -EOPNOTSUPP; 1024 1025 switch (type) { 1026 case TC_SETUP_CLSMATCHALL: 1027 return dsa_slave_setup_tc_cls_matchall(dev, type_data, ingress); 1028 case TC_SETUP_CLSFLOWER: 1029 return dsa_slave_setup_tc_cls_flower(dev, type_data, ingress); 1030 default: 1031 return -EOPNOTSUPP; 1032 } 1033 } 1034 1035 static int dsa_slave_setup_tc_block_cb_ig(enum tc_setup_type type, 1036 void *type_data, void *cb_priv) 1037 { 1038 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, true); 1039 } 1040 1041 static int dsa_slave_setup_tc_block_cb_eg(enum tc_setup_type type, 1042 void *type_data, void *cb_priv) 1043 { 1044 return dsa_slave_setup_tc_block_cb(type, type_data, cb_priv, false); 1045 } 1046 1047 static LIST_HEAD(dsa_slave_block_cb_list); 1048 1049 static int dsa_slave_setup_tc_block(struct net_device *dev, 1050 struct flow_block_offload *f) 1051 { 1052 struct flow_block_cb *block_cb; 1053 flow_setup_cb_t *cb; 1054 1055 if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS) 1056 cb = dsa_slave_setup_tc_block_cb_ig; 1057 else if (f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS) 1058 cb = dsa_slave_setup_tc_block_cb_eg; 1059 else 1060 return -EOPNOTSUPP; 1061 1062 f->driver_block_list = &dsa_slave_block_cb_list; 1063 1064 switch (f->command) { 1065 case FLOW_BLOCK_BIND: 1066 if (flow_block_cb_is_busy(cb, dev, &dsa_slave_block_cb_list)) 1067 return -EBUSY; 1068 1069 block_cb = flow_block_cb_alloc(cb, dev, dev, NULL); 1070 if (IS_ERR(block_cb)) 1071 return PTR_ERR(block_cb); 1072 1073 flow_block_cb_add(block_cb, f); 1074 list_add_tail(&block_cb->driver_list, &dsa_slave_block_cb_list); 1075 return 0; 1076 case FLOW_BLOCK_UNBIND: 1077 block_cb = flow_block_cb_lookup(f->block, cb, dev); 1078 if (!block_cb) 1079 return -ENOENT; 1080 1081 flow_block_cb_remove(block_cb, f); 1082 list_del(&block_cb->driver_list); 1083 return 0; 1084 default: 1085 return -EOPNOTSUPP; 1086 } 1087 } 1088 1089 static int dsa_slave_setup_tc(struct net_device *dev, enum tc_setup_type type, 1090 void *type_data) 1091 { 1092 struct dsa_port *dp = dsa_slave_to_port(dev); 1093 struct dsa_switch *ds = dp->ds; 1094 1095 if (type == TC_SETUP_BLOCK) 1096 return dsa_slave_setup_tc_block(dev, type_data); 1097 1098 if (!ds->ops->port_setup_tc) 1099 return -EOPNOTSUPP; 1100 1101 return ds->ops->port_setup_tc(ds, dp->index, type, type_data); 1102 } 1103 1104 static void dsa_slave_get_stats64(struct net_device *dev, 1105 struct rtnl_link_stats64 *stats) 1106 { 1107 struct dsa_slave_priv *p = netdev_priv(dev); 1108 struct pcpu_sw_netstats *s; 1109 unsigned int start; 1110 int i; 1111 1112 netdev_stats_to_stats64(stats, &dev->stats); 1113 for_each_possible_cpu(i) { 1114 u64 tx_packets, tx_bytes, rx_packets, rx_bytes; 1115 1116 s = per_cpu_ptr(p->stats64, i); 1117 do { 1118 start = u64_stats_fetch_begin_irq(&s->syncp); 1119 tx_packets = s->tx_packets; 1120 tx_bytes = s->tx_bytes; 1121 rx_packets = s->rx_packets; 1122 rx_bytes = s->rx_bytes; 1123 } while (u64_stats_fetch_retry_irq(&s->syncp, start)); 1124 1125 stats->tx_packets += tx_packets; 1126 stats->tx_bytes += tx_bytes; 1127 stats->rx_packets += rx_packets; 1128 stats->rx_bytes += rx_bytes; 1129 } 1130 } 1131 1132 static int dsa_slave_get_rxnfc(struct net_device *dev, 1133 struct ethtool_rxnfc *nfc, u32 *rule_locs) 1134 { 1135 struct dsa_port *dp = dsa_slave_to_port(dev); 1136 struct dsa_switch *ds = dp->ds; 1137 1138 if (!ds->ops->get_rxnfc) 1139 return -EOPNOTSUPP; 1140 1141 return ds->ops->get_rxnfc(ds, dp->index, nfc, rule_locs); 1142 } 1143 1144 static int dsa_slave_set_rxnfc(struct net_device *dev, 1145 struct ethtool_rxnfc *nfc) 1146 { 1147 struct dsa_port *dp = dsa_slave_to_port(dev); 1148 struct dsa_switch *ds = dp->ds; 1149 1150 if (!ds->ops->set_rxnfc) 1151 return -EOPNOTSUPP; 1152 1153 return ds->ops->set_rxnfc(ds, dp->index, nfc); 1154 } 1155 1156 static int dsa_slave_get_ts_info(struct net_device *dev, 1157 struct ethtool_ts_info *ts) 1158 { 1159 struct dsa_slave_priv *p = netdev_priv(dev); 1160 struct dsa_switch *ds = p->dp->ds; 1161 1162 if (!ds->ops->get_ts_info) 1163 return -EOPNOTSUPP; 1164 1165 return ds->ops->get_ts_info(ds, p->dp->index, ts); 1166 } 1167 1168 static int dsa_slave_vlan_rx_add_vid(struct net_device *dev, __be16 proto, 1169 u16 vid) 1170 { 1171 struct dsa_port *dp = dsa_slave_to_port(dev); 1172 struct bridge_vlan_info info; 1173 int ret; 1174 1175 /* Check for a possible bridge VLAN entry now since there is no 1176 * need to emulate the switchdev prepare + commit phase. 1177 */ 1178 if (dp->bridge_dev) { 1179 if (!br_vlan_enabled(dp->bridge_dev)) 1180 return 0; 1181 1182 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the 1183 * device, respectively the VID is not found, returning 1184 * 0 means success, which is a failure for us here. 1185 */ 1186 ret = br_vlan_get_info(dp->bridge_dev, vid, &info); 1187 if (ret == 0) 1188 return -EBUSY; 1189 } 1190 1191 ret = dsa_port_vid_add(dp, vid, 0); 1192 if (ret) 1193 return ret; 1194 1195 ret = dsa_port_vid_add(dp->cpu_dp, vid, 0); 1196 if (ret) 1197 return ret; 1198 1199 return 0; 1200 } 1201 1202 static int dsa_slave_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, 1203 u16 vid) 1204 { 1205 struct dsa_port *dp = dsa_slave_to_port(dev); 1206 struct bridge_vlan_info info; 1207 int ret; 1208 1209 /* Check for a possible bridge VLAN entry now since there is no 1210 * need to emulate the switchdev prepare + commit phase. 1211 */ 1212 if (dp->bridge_dev) { 1213 if (!br_vlan_enabled(dp->bridge_dev)) 1214 return 0; 1215 1216 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the 1217 * device, respectively the VID is not found, returning 1218 * 0 means success, which is a failure for us here. 1219 */ 1220 ret = br_vlan_get_info(dp->bridge_dev, vid, &info); 1221 if (ret == 0) 1222 return -EBUSY; 1223 } 1224 1225 /* Do not deprogram the CPU port as it may be shared with other user 1226 * ports which can be members of this VLAN as well. 1227 */ 1228 return dsa_port_vid_del(dp, vid); 1229 } 1230 1231 struct dsa_hw_port { 1232 struct list_head list; 1233 struct net_device *dev; 1234 int old_mtu; 1235 }; 1236 1237 static int dsa_hw_port_list_set_mtu(struct list_head *hw_port_list, int mtu) 1238 { 1239 const struct dsa_hw_port *p; 1240 int err; 1241 1242 list_for_each_entry(p, hw_port_list, list) { 1243 if (p->dev->mtu == mtu) 1244 continue; 1245 1246 err = dev_set_mtu(p->dev, mtu); 1247 if (err) 1248 goto rollback; 1249 } 1250 1251 return 0; 1252 1253 rollback: 1254 list_for_each_entry_continue_reverse(p, hw_port_list, list) { 1255 if (p->dev->mtu == p->old_mtu) 1256 continue; 1257 1258 if (dev_set_mtu(p->dev, p->old_mtu)) 1259 netdev_err(p->dev, "Failed to restore MTU\n"); 1260 } 1261 1262 return err; 1263 } 1264 1265 static void dsa_hw_port_list_free(struct list_head *hw_port_list) 1266 { 1267 struct dsa_hw_port *p, *n; 1268 1269 list_for_each_entry_safe(p, n, hw_port_list, list) 1270 kfree(p); 1271 } 1272 1273 /* Make the hardware datapath to/from @dev limited to a common MTU */ 1274 void dsa_bridge_mtu_normalization(struct dsa_port *dp) 1275 { 1276 struct list_head hw_port_list; 1277 struct dsa_switch_tree *dst; 1278 int min_mtu = ETH_MAX_MTU; 1279 struct dsa_port *other_dp; 1280 int err; 1281 1282 if (!dp->ds->mtu_enforcement_ingress) 1283 return; 1284 1285 if (!dp->bridge_dev) 1286 return; 1287 1288 INIT_LIST_HEAD(&hw_port_list); 1289 1290 /* Populate the list of ports that are part of the same bridge 1291 * as the newly added/modified port 1292 */ 1293 list_for_each_entry(dst, &dsa_tree_list, list) { 1294 list_for_each_entry(other_dp, &dst->ports, list) { 1295 struct dsa_hw_port *hw_port; 1296 struct net_device *slave; 1297 1298 if (other_dp->type != DSA_PORT_TYPE_USER) 1299 continue; 1300 1301 if (other_dp->bridge_dev != dp->bridge_dev) 1302 continue; 1303 1304 if (!other_dp->ds->mtu_enforcement_ingress) 1305 continue; 1306 1307 slave = other_dp->slave; 1308 1309 if (min_mtu > slave->mtu) 1310 min_mtu = slave->mtu; 1311 1312 hw_port = kzalloc(sizeof(*hw_port), GFP_KERNEL); 1313 if (!hw_port) 1314 goto out; 1315 1316 hw_port->dev = slave; 1317 hw_port->old_mtu = slave->mtu; 1318 1319 list_add(&hw_port->list, &hw_port_list); 1320 } 1321 } 1322 1323 /* Attempt to configure the entire hardware bridge to the newly added 1324 * interface's MTU first, regardless of whether the intention of the 1325 * user was to raise or lower it. 1326 */ 1327 err = dsa_hw_port_list_set_mtu(&hw_port_list, dp->slave->mtu); 1328 if (!err) 1329 goto out; 1330 1331 /* Clearly that didn't work out so well, so just set the minimum MTU on 1332 * all hardware bridge ports now. If this fails too, then all ports will 1333 * still have their old MTU rolled back anyway. 1334 */ 1335 dsa_hw_port_list_set_mtu(&hw_port_list, min_mtu); 1336 1337 out: 1338 dsa_hw_port_list_free(&hw_port_list); 1339 } 1340 1341 static int dsa_slave_change_mtu(struct net_device *dev, int new_mtu) 1342 { 1343 struct net_device *master = dsa_slave_to_master(dev); 1344 struct dsa_port *dp = dsa_slave_to_port(dev); 1345 struct dsa_slave_priv *p = netdev_priv(dev); 1346 struct dsa_switch *ds = p->dp->ds; 1347 struct dsa_port *cpu_dp; 1348 int port = p->dp->index; 1349 int largest_mtu = 0; 1350 int new_master_mtu; 1351 int old_master_mtu; 1352 int mtu_limit; 1353 int cpu_mtu; 1354 int err, i; 1355 1356 if (!ds->ops->port_change_mtu) 1357 return -EOPNOTSUPP; 1358 1359 for (i = 0; i < ds->num_ports; i++) { 1360 int slave_mtu; 1361 1362 if (!dsa_is_user_port(ds, i)) 1363 continue; 1364 1365 /* During probe, this function will be called for each slave 1366 * device, while not all of them have been allocated. That's 1367 * ok, it doesn't change what the maximum is, so ignore it. 1368 */ 1369 if (!dsa_to_port(ds, i)->slave) 1370 continue; 1371 1372 /* Pretend that we already applied the setting, which we 1373 * actually haven't (still haven't done all integrity checks) 1374 */ 1375 if (i == port) 1376 slave_mtu = new_mtu; 1377 else 1378 slave_mtu = dsa_to_port(ds, i)->slave->mtu; 1379 1380 if (largest_mtu < slave_mtu) 1381 largest_mtu = slave_mtu; 1382 } 1383 1384 cpu_dp = dsa_to_port(ds, port)->cpu_dp; 1385 1386 mtu_limit = min_t(int, master->max_mtu, dev->max_mtu); 1387 old_master_mtu = master->mtu; 1388 new_master_mtu = largest_mtu + cpu_dp->tag_ops->overhead; 1389 if (new_master_mtu > mtu_limit) 1390 return -ERANGE; 1391 1392 /* If the master MTU isn't over limit, there's no need to check the CPU 1393 * MTU, since that surely isn't either. 1394 */ 1395 cpu_mtu = largest_mtu; 1396 1397 /* Start applying stuff */ 1398 if (new_master_mtu != old_master_mtu) { 1399 err = dev_set_mtu(master, new_master_mtu); 1400 if (err < 0) 1401 goto out_master_failed; 1402 1403 /* We only need to propagate the MTU of the CPU port to 1404 * upstream switches. 1405 */ 1406 err = dsa_port_mtu_change(cpu_dp, cpu_mtu, true); 1407 if (err) 1408 goto out_cpu_failed; 1409 } 1410 1411 err = dsa_port_mtu_change(dp, new_mtu, false); 1412 if (err) 1413 goto out_port_failed; 1414 1415 dev->mtu = new_mtu; 1416 1417 dsa_bridge_mtu_normalization(dp); 1418 1419 return 0; 1420 1421 out_port_failed: 1422 if (new_master_mtu != old_master_mtu) 1423 dsa_port_mtu_change(cpu_dp, old_master_mtu - 1424 cpu_dp->tag_ops->overhead, 1425 true); 1426 out_cpu_failed: 1427 if (new_master_mtu != old_master_mtu) 1428 dev_set_mtu(master, old_master_mtu); 1429 out_master_failed: 1430 return err; 1431 } 1432 1433 static const struct ethtool_ops dsa_slave_ethtool_ops = { 1434 .get_drvinfo = dsa_slave_get_drvinfo, 1435 .get_regs_len = dsa_slave_get_regs_len, 1436 .get_regs = dsa_slave_get_regs, 1437 .nway_reset = dsa_slave_nway_reset, 1438 .get_link = ethtool_op_get_link, 1439 .get_eeprom_len = dsa_slave_get_eeprom_len, 1440 .get_eeprom = dsa_slave_get_eeprom, 1441 .set_eeprom = dsa_slave_set_eeprom, 1442 .get_strings = dsa_slave_get_strings, 1443 .get_ethtool_stats = dsa_slave_get_ethtool_stats, 1444 .get_sset_count = dsa_slave_get_sset_count, 1445 .set_wol = dsa_slave_set_wol, 1446 .get_wol = dsa_slave_get_wol, 1447 .set_eee = dsa_slave_set_eee, 1448 .get_eee = dsa_slave_get_eee, 1449 .get_link_ksettings = dsa_slave_get_link_ksettings, 1450 .set_link_ksettings = dsa_slave_set_link_ksettings, 1451 .get_pauseparam = dsa_slave_get_pauseparam, 1452 .set_pauseparam = dsa_slave_set_pauseparam, 1453 .get_rxnfc = dsa_slave_get_rxnfc, 1454 .set_rxnfc = dsa_slave_set_rxnfc, 1455 .get_ts_info = dsa_slave_get_ts_info, 1456 }; 1457 1458 /* legacy way, bypassing the bridge *****************************************/ 1459 int dsa_legacy_fdb_add(struct ndmsg *ndm, struct nlattr *tb[], 1460 struct net_device *dev, 1461 const unsigned char *addr, u16 vid, 1462 u16 flags, 1463 struct netlink_ext_ack *extack) 1464 { 1465 struct dsa_port *dp = dsa_slave_to_port(dev); 1466 1467 return dsa_port_fdb_add(dp, addr, vid); 1468 } 1469 1470 int dsa_legacy_fdb_del(struct ndmsg *ndm, struct nlattr *tb[], 1471 struct net_device *dev, 1472 const unsigned char *addr, u16 vid) 1473 { 1474 struct dsa_port *dp = dsa_slave_to_port(dev); 1475 1476 return dsa_port_fdb_del(dp, addr, vid); 1477 } 1478 1479 static struct devlink_port *dsa_slave_get_devlink_port(struct net_device *dev) 1480 { 1481 struct dsa_port *dp = dsa_slave_to_port(dev); 1482 1483 return dp->ds->devlink ? &dp->devlink_port : NULL; 1484 } 1485 1486 static const struct net_device_ops dsa_slave_netdev_ops = { 1487 .ndo_open = dsa_slave_open, 1488 .ndo_stop = dsa_slave_close, 1489 .ndo_start_xmit = dsa_slave_xmit, 1490 .ndo_change_rx_flags = dsa_slave_change_rx_flags, 1491 .ndo_set_rx_mode = dsa_slave_set_rx_mode, 1492 .ndo_set_mac_address = dsa_slave_set_mac_address, 1493 .ndo_fdb_add = dsa_legacy_fdb_add, 1494 .ndo_fdb_del = dsa_legacy_fdb_del, 1495 .ndo_fdb_dump = dsa_slave_fdb_dump, 1496 .ndo_do_ioctl = dsa_slave_ioctl, 1497 .ndo_get_iflink = dsa_slave_get_iflink, 1498 #ifdef CONFIG_NET_POLL_CONTROLLER 1499 .ndo_netpoll_setup = dsa_slave_netpoll_setup, 1500 .ndo_netpoll_cleanup = dsa_slave_netpoll_cleanup, 1501 .ndo_poll_controller = dsa_slave_poll_controller, 1502 #endif 1503 .ndo_get_phys_port_name = dsa_slave_get_phys_port_name, 1504 .ndo_setup_tc = dsa_slave_setup_tc, 1505 .ndo_get_stats64 = dsa_slave_get_stats64, 1506 .ndo_get_port_parent_id = dsa_slave_get_port_parent_id, 1507 .ndo_vlan_rx_add_vid = dsa_slave_vlan_rx_add_vid, 1508 .ndo_vlan_rx_kill_vid = dsa_slave_vlan_rx_kill_vid, 1509 .ndo_get_devlink_port = dsa_slave_get_devlink_port, 1510 .ndo_change_mtu = dsa_slave_change_mtu, 1511 }; 1512 1513 static struct device_type dsa_type = { 1514 .name = "dsa", 1515 }; 1516 1517 void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up) 1518 { 1519 const struct dsa_port *dp = dsa_to_port(ds, port); 1520 1521 phylink_mac_change(dp->pl, up); 1522 } 1523 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change); 1524 1525 static void dsa_slave_phylink_fixed_state(struct net_device *dev, 1526 struct phylink_link_state *state) 1527 { 1528 struct dsa_port *dp = dsa_slave_to_port(dev); 1529 struct dsa_switch *ds = dp->ds; 1530 1531 /* No need to check that this operation is valid, the callback would 1532 * not be called if it was not. 1533 */ 1534 ds->ops->phylink_fixed_state(ds, dp->index, state); 1535 } 1536 1537 /* slave device setup *******************************************************/ 1538 static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr) 1539 { 1540 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1541 struct dsa_switch *ds = dp->ds; 1542 1543 slave_dev->phydev = mdiobus_get_phy(ds->slave_mii_bus, addr); 1544 if (!slave_dev->phydev) { 1545 netdev_err(slave_dev, "no phy at %d\n", addr); 1546 return -ENODEV; 1547 } 1548 1549 return phylink_connect_phy(dp->pl, slave_dev->phydev); 1550 } 1551 1552 static int dsa_slave_phy_setup(struct net_device *slave_dev) 1553 { 1554 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1555 struct device_node *port_dn = dp->dn; 1556 struct dsa_switch *ds = dp->ds; 1557 phy_interface_t mode; 1558 u32 phy_flags = 0; 1559 int ret; 1560 1561 ret = of_get_phy_mode(port_dn, &mode); 1562 if (ret) 1563 mode = PHY_INTERFACE_MODE_NA; 1564 1565 dp->pl_config.dev = &slave_dev->dev; 1566 dp->pl_config.type = PHYLINK_NETDEV; 1567 1568 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn), mode, 1569 &dsa_port_phylink_mac_ops); 1570 if (IS_ERR(dp->pl)) { 1571 netdev_err(slave_dev, 1572 "error creating PHYLINK: %ld\n", PTR_ERR(dp->pl)); 1573 return PTR_ERR(dp->pl); 1574 } 1575 1576 /* Register only if the switch provides such a callback, since this 1577 * callback takes precedence over polling the link GPIO in PHYLINK 1578 * (see phylink_get_fixed_state). 1579 */ 1580 if (ds->ops->phylink_fixed_state) 1581 phylink_fixed_state_cb(dp->pl, dsa_slave_phylink_fixed_state); 1582 1583 if (ds->ops->get_phy_flags) 1584 phy_flags = ds->ops->get_phy_flags(ds, dp->index); 1585 1586 ret = phylink_of_phy_connect(dp->pl, port_dn, phy_flags); 1587 if (ret == -ENODEV && ds->slave_mii_bus) { 1588 /* We could not connect to a designated PHY or SFP, so try to 1589 * use the switch internal MDIO bus instead 1590 */ 1591 ret = dsa_slave_phy_connect(slave_dev, dp->index); 1592 if (ret) { 1593 netdev_err(slave_dev, 1594 "failed to connect to port %d: %d\n", 1595 dp->index, ret); 1596 phylink_destroy(dp->pl); 1597 return ret; 1598 } 1599 } 1600 1601 return ret; 1602 } 1603 1604 int dsa_slave_suspend(struct net_device *slave_dev) 1605 { 1606 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1607 1608 if (!netif_running(slave_dev)) 1609 return 0; 1610 1611 netif_device_detach(slave_dev); 1612 1613 rtnl_lock(); 1614 phylink_stop(dp->pl); 1615 rtnl_unlock(); 1616 1617 return 0; 1618 } 1619 1620 int dsa_slave_resume(struct net_device *slave_dev) 1621 { 1622 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1623 1624 if (!netif_running(slave_dev)) 1625 return 0; 1626 1627 netif_device_attach(slave_dev); 1628 1629 rtnl_lock(); 1630 phylink_start(dp->pl); 1631 rtnl_unlock(); 1632 1633 return 0; 1634 } 1635 1636 static void dsa_slave_notify(struct net_device *dev, unsigned long val) 1637 { 1638 struct net_device *master = dsa_slave_to_master(dev); 1639 struct dsa_port *dp = dsa_slave_to_port(dev); 1640 struct dsa_notifier_register_info rinfo = { 1641 .switch_number = dp->ds->index, 1642 .port_number = dp->index, 1643 .master = master, 1644 .info.dev = dev, 1645 }; 1646 1647 call_dsa_notifiers(val, dev, &rinfo.info); 1648 } 1649 1650 int dsa_slave_create(struct dsa_port *port) 1651 { 1652 const struct dsa_port *cpu_dp = port->cpu_dp; 1653 struct net_device *master = cpu_dp->master; 1654 struct dsa_switch *ds = port->ds; 1655 const char *name = port->name; 1656 struct net_device *slave_dev; 1657 struct dsa_slave_priv *p; 1658 int ret; 1659 1660 if (!ds->num_tx_queues) 1661 ds->num_tx_queues = 1; 1662 1663 slave_dev = alloc_netdev_mqs(sizeof(struct dsa_slave_priv), name, 1664 NET_NAME_UNKNOWN, ether_setup, 1665 ds->num_tx_queues, 1); 1666 if (slave_dev == NULL) 1667 return -ENOMEM; 1668 1669 slave_dev->features = master->vlan_features | NETIF_F_HW_TC; 1670 if (ds->ops->port_vlan_add && ds->ops->port_vlan_del) 1671 slave_dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER; 1672 slave_dev->hw_features |= NETIF_F_HW_TC; 1673 slave_dev->ethtool_ops = &dsa_slave_ethtool_ops; 1674 if (!IS_ERR_OR_NULL(port->mac)) 1675 ether_addr_copy(slave_dev->dev_addr, port->mac); 1676 else 1677 eth_hw_addr_inherit(slave_dev, master); 1678 slave_dev->priv_flags |= IFF_NO_QUEUE; 1679 slave_dev->netdev_ops = &dsa_slave_netdev_ops; 1680 slave_dev->min_mtu = 0; 1681 if (ds->ops->port_max_mtu) 1682 slave_dev->max_mtu = ds->ops->port_max_mtu(ds, port->index); 1683 else 1684 slave_dev->max_mtu = ETH_MAX_MTU; 1685 SET_NETDEV_DEVTYPE(slave_dev, &dsa_type); 1686 1687 SET_NETDEV_DEV(slave_dev, port->ds->dev); 1688 slave_dev->dev.of_node = port->dn; 1689 slave_dev->vlan_features = master->vlan_features; 1690 1691 p = netdev_priv(slave_dev); 1692 p->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); 1693 if (!p->stats64) { 1694 free_netdev(slave_dev); 1695 return -ENOMEM; 1696 } 1697 p->dp = port; 1698 INIT_LIST_HEAD(&p->mall_tc_list); 1699 p->xmit = cpu_dp->tag_ops->xmit; 1700 port->slave = slave_dev; 1701 1702 rtnl_lock(); 1703 ret = dsa_slave_change_mtu(slave_dev, ETH_DATA_LEN); 1704 rtnl_unlock(); 1705 if (ret && ret != -EOPNOTSUPP) { 1706 dev_err(ds->dev, "error %d setting MTU on port %d\n", 1707 ret, port->index); 1708 goto out_free; 1709 } 1710 1711 netif_carrier_off(slave_dev); 1712 1713 ret = dsa_slave_phy_setup(slave_dev); 1714 if (ret) { 1715 netdev_err(master, "error %d setting up slave phy\n", ret); 1716 goto out_free; 1717 } 1718 1719 dsa_slave_notify(slave_dev, DSA_PORT_REGISTER); 1720 1721 ret = register_netdev(slave_dev); 1722 if (ret) { 1723 netdev_err(master, "error %d registering interface %s\n", 1724 ret, slave_dev->name); 1725 goto out_phy; 1726 } 1727 1728 return 0; 1729 1730 out_phy: 1731 rtnl_lock(); 1732 phylink_disconnect_phy(p->dp->pl); 1733 rtnl_unlock(); 1734 phylink_destroy(p->dp->pl); 1735 out_free: 1736 free_percpu(p->stats64); 1737 free_netdev(slave_dev); 1738 port->slave = NULL; 1739 return ret; 1740 } 1741 1742 void dsa_slave_destroy(struct net_device *slave_dev) 1743 { 1744 struct dsa_port *dp = dsa_slave_to_port(slave_dev); 1745 struct dsa_slave_priv *p = netdev_priv(slave_dev); 1746 1747 netif_carrier_off(slave_dev); 1748 rtnl_lock(); 1749 phylink_disconnect_phy(dp->pl); 1750 rtnl_unlock(); 1751 1752 dsa_slave_notify(slave_dev, DSA_PORT_UNREGISTER); 1753 unregister_netdev(slave_dev); 1754 phylink_destroy(dp->pl); 1755 free_percpu(p->stats64); 1756 free_netdev(slave_dev); 1757 } 1758 1759 bool dsa_slave_dev_check(const struct net_device *dev) 1760 { 1761 return dev->netdev_ops == &dsa_slave_netdev_ops; 1762 } 1763 1764 static int dsa_slave_changeupper(struct net_device *dev, 1765 struct netdev_notifier_changeupper_info *info) 1766 { 1767 struct dsa_port *dp = dsa_slave_to_port(dev); 1768 int err = NOTIFY_DONE; 1769 1770 if (netif_is_bridge_master(info->upper_dev)) { 1771 if (info->linking) { 1772 err = dsa_port_bridge_join(dp, info->upper_dev); 1773 if (!err) 1774 dsa_bridge_mtu_normalization(dp); 1775 err = notifier_from_errno(err); 1776 } else { 1777 dsa_port_bridge_leave(dp, info->upper_dev); 1778 err = NOTIFY_OK; 1779 } 1780 } 1781 1782 return err; 1783 } 1784 1785 static int dsa_slave_upper_vlan_check(struct net_device *dev, 1786 struct netdev_notifier_changeupper_info * 1787 info) 1788 { 1789 struct netlink_ext_ack *ext_ack; 1790 struct net_device *slave; 1791 struct dsa_port *dp; 1792 1793 ext_ack = netdev_notifier_info_to_extack(&info->info); 1794 1795 if (!is_vlan_dev(dev)) 1796 return NOTIFY_DONE; 1797 1798 slave = vlan_dev_real_dev(dev); 1799 if (!dsa_slave_dev_check(slave)) 1800 return NOTIFY_DONE; 1801 1802 dp = dsa_slave_to_port(slave); 1803 if (!dp->bridge_dev) 1804 return NOTIFY_DONE; 1805 1806 /* Deny enslaving a VLAN device into a VLAN-aware bridge */ 1807 if (br_vlan_enabled(dp->bridge_dev) && 1808 netif_is_bridge_master(info->upper_dev) && info->linking) { 1809 NL_SET_ERR_MSG_MOD(ext_ack, 1810 "Cannot enslave VLAN device into VLAN aware bridge"); 1811 return notifier_from_errno(-EINVAL); 1812 } 1813 1814 return NOTIFY_DONE; 1815 } 1816 1817 static int dsa_slave_netdevice_event(struct notifier_block *nb, 1818 unsigned long event, void *ptr) 1819 { 1820 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 1821 1822 if (event == NETDEV_CHANGEUPPER) { 1823 if (!dsa_slave_dev_check(dev)) 1824 return dsa_slave_upper_vlan_check(dev, ptr); 1825 1826 return dsa_slave_changeupper(dev, ptr); 1827 } 1828 1829 return NOTIFY_DONE; 1830 } 1831 1832 struct dsa_switchdev_event_work { 1833 struct work_struct work; 1834 struct switchdev_notifier_fdb_info fdb_info; 1835 struct net_device *dev; 1836 unsigned long event; 1837 }; 1838 1839 static void dsa_slave_switchdev_event_work(struct work_struct *work) 1840 { 1841 struct dsa_switchdev_event_work *switchdev_work = 1842 container_of(work, struct dsa_switchdev_event_work, work); 1843 struct net_device *dev = switchdev_work->dev; 1844 struct switchdev_notifier_fdb_info *fdb_info; 1845 struct dsa_port *dp = dsa_slave_to_port(dev); 1846 int err; 1847 1848 rtnl_lock(); 1849 switch (switchdev_work->event) { 1850 case SWITCHDEV_FDB_ADD_TO_DEVICE: 1851 fdb_info = &switchdev_work->fdb_info; 1852 if (!fdb_info->added_by_user) 1853 break; 1854 1855 err = dsa_port_fdb_add(dp, fdb_info->addr, fdb_info->vid); 1856 if (err) { 1857 netdev_dbg(dev, "fdb add failed err=%d\n", err); 1858 break; 1859 } 1860 fdb_info->offloaded = true; 1861 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, dev, 1862 &fdb_info->info, NULL); 1863 break; 1864 1865 case SWITCHDEV_FDB_DEL_TO_DEVICE: 1866 fdb_info = &switchdev_work->fdb_info; 1867 if (!fdb_info->added_by_user) 1868 break; 1869 1870 err = dsa_port_fdb_del(dp, fdb_info->addr, fdb_info->vid); 1871 if (err) { 1872 netdev_dbg(dev, "fdb del failed err=%d\n", err); 1873 dev_close(dev); 1874 } 1875 break; 1876 } 1877 rtnl_unlock(); 1878 1879 kfree(switchdev_work->fdb_info.addr); 1880 kfree(switchdev_work); 1881 dev_put(dev); 1882 } 1883 1884 static int 1885 dsa_slave_switchdev_fdb_work_init(struct dsa_switchdev_event_work * 1886 switchdev_work, 1887 const struct switchdev_notifier_fdb_info * 1888 fdb_info) 1889 { 1890 memcpy(&switchdev_work->fdb_info, fdb_info, 1891 sizeof(switchdev_work->fdb_info)); 1892 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC); 1893 if (!switchdev_work->fdb_info.addr) 1894 return -ENOMEM; 1895 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr, 1896 fdb_info->addr); 1897 return 0; 1898 } 1899 1900 /* Called under rcu_read_lock() */ 1901 static int dsa_slave_switchdev_event(struct notifier_block *unused, 1902 unsigned long event, void *ptr) 1903 { 1904 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 1905 struct dsa_switchdev_event_work *switchdev_work; 1906 int err; 1907 1908 if (event == SWITCHDEV_PORT_ATTR_SET) { 1909 err = switchdev_handle_port_attr_set(dev, ptr, 1910 dsa_slave_dev_check, 1911 dsa_slave_port_attr_set); 1912 return notifier_from_errno(err); 1913 } 1914 1915 if (!dsa_slave_dev_check(dev)) 1916 return NOTIFY_DONE; 1917 1918 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC); 1919 if (!switchdev_work) 1920 return NOTIFY_BAD; 1921 1922 INIT_WORK(&switchdev_work->work, 1923 dsa_slave_switchdev_event_work); 1924 switchdev_work->dev = dev; 1925 switchdev_work->event = event; 1926 1927 switch (event) { 1928 case SWITCHDEV_FDB_ADD_TO_DEVICE: /* fall through */ 1929 case SWITCHDEV_FDB_DEL_TO_DEVICE: 1930 if (dsa_slave_switchdev_fdb_work_init(switchdev_work, ptr)) 1931 goto err_fdb_work_init; 1932 dev_hold(dev); 1933 break; 1934 default: 1935 kfree(switchdev_work); 1936 return NOTIFY_DONE; 1937 } 1938 1939 dsa_schedule_work(&switchdev_work->work); 1940 return NOTIFY_OK; 1941 1942 err_fdb_work_init: 1943 kfree(switchdev_work); 1944 return NOTIFY_BAD; 1945 } 1946 1947 static int dsa_slave_switchdev_blocking_event(struct notifier_block *unused, 1948 unsigned long event, void *ptr) 1949 { 1950 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 1951 int err; 1952 1953 switch (event) { 1954 case SWITCHDEV_PORT_OBJ_ADD: 1955 err = switchdev_handle_port_obj_add(dev, ptr, 1956 dsa_slave_dev_check, 1957 dsa_slave_port_obj_add); 1958 return notifier_from_errno(err); 1959 case SWITCHDEV_PORT_OBJ_DEL: 1960 err = switchdev_handle_port_obj_del(dev, ptr, 1961 dsa_slave_dev_check, 1962 dsa_slave_port_obj_del); 1963 return notifier_from_errno(err); 1964 case SWITCHDEV_PORT_ATTR_SET: 1965 err = switchdev_handle_port_attr_set(dev, ptr, 1966 dsa_slave_dev_check, 1967 dsa_slave_port_attr_set); 1968 return notifier_from_errno(err); 1969 } 1970 1971 return NOTIFY_DONE; 1972 } 1973 1974 static struct notifier_block dsa_slave_nb __read_mostly = { 1975 .notifier_call = dsa_slave_netdevice_event, 1976 }; 1977 1978 static struct notifier_block dsa_slave_switchdev_notifier = { 1979 .notifier_call = dsa_slave_switchdev_event, 1980 }; 1981 1982 static struct notifier_block dsa_slave_switchdev_blocking_notifier = { 1983 .notifier_call = dsa_slave_switchdev_blocking_event, 1984 }; 1985 1986 int dsa_slave_register_notifier(void) 1987 { 1988 struct notifier_block *nb; 1989 int err; 1990 1991 err = register_netdevice_notifier(&dsa_slave_nb); 1992 if (err) 1993 return err; 1994 1995 err = register_switchdev_notifier(&dsa_slave_switchdev_notifier); 1996 if (err) 1997 goto err_switchdev_nb; 1998 1999 nb = &dsa_slave_switchdev_blocking_notifier; 2000 err = register_switchdev_blocking_notifier(nb); 2001 if (err) 2002 goto err_switchdev_blocking_nb; 2003 2004 return 0; 2005 2006 err_switchdev_blocking_nb: 2007 unregister_switchdev_notifier(&dsa_slave_switchdev_notifier); 2008 err_switchdev_nb: 2009 unregister_netdevice_notifier(&dsa_slave_nb); 2010 return err; 2011 } 2012 2013 void dsa_slave_unregister_notifier(void) 2014 { 2015 struct notifier_block *nb; 2016 int err; 2017 2018 nb = &dsa_slave_switchdev_blocking_notifier; 2019 err = unregister_switchdev_blocking_notifier(nb); 2020 if (err) 2021 pr_err("DSA: failed to unregister switchdev blocking notifier (%d)\n", err); 2022 2023 err = unregister_switchdev_notifier(&dsa_slave_switchdev_notifier); 2024 if (err) 2025 pr_err("DSA: failed to unregister switchdev notifier (%d)\n", err); 2026 2027 err = unregister_netdevice_notifier(&dsa_slave_nb); 2028 if (err) 2029 pr_err("DSA: failed to unregister slave notifier (%d)\n", err); 2030 } 2031