1 /* 2 * net/dsa/slave.c - Slave device handling 3 * Copyright (c) 2008-2009 Marvell Semiconductor 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 */ 10 11 #include <linux/list.h> 12 #include <linux/etherdevice.h> 13 #include <linux/netdevice.h> 14 #include <linux/phy.h> 15 #include <linux/phy_fixed.h> 16 #include <linux/of_net.h> 17 #include <linux/of_mdio.h> 18 #include <linux/mdio.h> 19 #include <linux/list.h> 20 #include <net/rtnetlink.h> 21 #include <net/pkt_cls.h> 22 #include <net/tc_act/tc_mirred.h> 23 #include <linux/if_bridge.h> 24 #include <linux/netpoll.h> 25 26 #include "dsa_priv.h" 27 28 static bool dsa_slave_dev_check(struct net_device *dev); 29 30 /* slave mii_bus handling ***************************************************/ 31 static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg) 32 { 33 struct dsa_switch *ds = bus->priv; 34 35 if (ds->phys_mii_mask & (1 << addr)) 36 return ds->ops->phy_read(ds, addr, reg); 37 38 return 0xffff; 39 } 40 41 static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val) 42 { 43 struct dsa_switch *ds = bus->priv; 44 45 if (ds->phys_mii_mask & (1 << addr)) 46 return ds->ops->phy_write(ds, addr, reg, val); 47 48 return 0; 49 } 50 51 void dsa_slave_mii_bus_init(struct dsa_switch *ds) 52 { 53 ds->slave_mii_bus->priv = (void *)ds; 54 ds->slave_mii_bus->name = "dsa slave smi"; 55 ds->slave_mii_bus->read = dsa_slave_phy_read; 56 ds->slave_mii_bus->write = dsa_slave_phy_write; 57 snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d.%d", 58 ds->dst->tree, ds->index); 59 ds->slave_mii_bus->parent = ds->dev; 60 ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask; 61 } 62 63 64 /* slave device handling ****************************************************/ 65 static int dsa_slave_get_iflink(const struct net_device *dev) 66 { 67 struct dsa_slave_priv *p = netdev_priv(dev); 68 69 return dsa_master_netdev(p)->ifindex; 70 } 71 72 static int dsa_slave_open(struct net_device *dev) 73 { 74 struct dsa_slave_priv *p = netdev_priv(dev); 75 struct dsa_port *dp = p->dp; 76 struct net_device *master = dsa_master_netdev(p); 77 int err; 78 79 if (!(master->flags & IFF_UP)) 80 return -ENETDOWN; 81 82 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) { 83 err = dev_uc_add(master, dev->dev_addr); 84 if (err < 0) 85 goto out; 86 } 87 88 if (dev->flags & IFF_ALLMULTI) { 89 err = dev_set_allmulti(master, 1); 90 if (err < 0) 91 goto del_unicast; 92 } 93 if (dev->flags & IFF_PROMISC) { 94 err = dev_set_promiscuity(master, 1); 95 if (err < 0) 96 goto clear_allmulti; 97 } 98 99 err = dsa_port_enable(dp, dev->phydev); 100 if (err) 101 goto clear_promisc; 102 103 if (dev->phydev) 104 phy_start(dev->phydev); 105 106 return 0; 107 108 clear_promisc: 109 if (dev->flags & IFF_PROMISC) 110 dev_set_promiscuity(master, -1); 111 clear_allmulti: 112 if (dev->flags & IFF_ALLMULTI) 113 dev_set_allmulti(master, -1); 114 del_unicast: 115 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) 116 dev_uc_del(master, dev->dev_addr); 117 out: 118 return err; 119 } 120 121 static int dsa_slave_close(struct net_device *dev) 122 { 123 struct dsa_slave_priv *p = netdev_priv(dev); 124 struct net_device *master = dsa_master_netdev(p); 125 struct dsa_port *dp = p->dp; 126 127 if (dev->phydev) 128 phy_stop(dev->phydev); 129 130 dsa_port_disable(dp, dev->phydev); 131 132 dev_mc_unsync(master, dev); 133 dev_uc_unsync(master, dev); 134 if (dev->flags & IFF_ALLMULTI) 135 dev_set_allmulti(master, -1); 136 if (dev->flags & IFF_PROMISC) 137 dev_set_promiscuity(master, -1); 138 139 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) 140 dev_uc_del(master, dev->dev_addr); 141 142 return 0; 143 } 144 145 static void dsa_slave_change_rx_flags(struct net_device *dev, int change) 146 { 147 struct dsa_slave_priv *p = netdev_priv(dev); 148 struct net_device *master = dsa_master_netdev(p); 149 150 if (change & IFF_ALLMULTI) 151 dev_set_allmulti(master, dev->flags & IFF_ALLMULTI ? 1 : -1); 152 if (change & IFF_PROMISC) 153 dev_set_promiscuity(master, dev->flags & IFF_PROMISC ? 1 : -1); 154 } 155 156 static void dsa_slave_set_rx_mode(struct net_device *dev) 157 { 158 struct dsa_slave_priv *p = netdev_priv(dev); 159 struct net_device *master = dsa_master_netdev(p); 160 161 dev_mc_sync(master, dev); 162 dev_uc_sync(master, dev); 163 } 164 165 static int dsa_slave_set_mac_address(struct net_device *dev, void *a) 166 { 167 struct dsa_slave_priv *p = netdev_priv(dev); 168 struct net_device *master = dsa_master_netdev(p); 169 struct sockaddr *addr = a; 170 int err; 171 172 if (!is_valid_ether_addr(addr->sa_data)) 173 return -EADDRNOTAVAIL; 174 175 if (!(dev->flags & IFF_UP)) 176 goto out; 177 178 if (!ether_addr_equal(addr->sa_data, master->dev_addr)) { 179 err = dev_uc_add(master, addr->sa_data); 180 if (err < 0) 181 return err; 182 } 183 184 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) 185 dev_uc_del(master, dev->dev_addr); 186 187 out: 188 ether_addr_copy(dev->dev_addr, addr->sa_data); 189 190 return 0; 191 } 192 193 struct dsa_slave_dump_ctx { 194 struct net_device *dev; 195 struct sk_buff *skb; 196 struct netlink_callback *cb; 197 int idx; 198 }; 199 200 static int 201 dsa_slave_port_fdb_do_dump(const unsigned char *addr, u16 vid, 202 bool is_static, void *data) 203 { 204 struct dsa_slave_dump_ctx *dump = data; 205 u32 portid = NETLINK_CB(dump->cb->skb).portid; 206 u32 seq = dump->cb->nlh->nlmsg_seq; 207 struct nlmsghdr *nlh; 208 struct ndmsg *ndm; 209 210 if (dump->idx < dump->cb->args[2]) 211 goto skip; 212 213 nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH, 214 sizeof(*ndm), NLM_F_MULTI); 215 if (!nlh) 216 return -EMSGSIZE; 217 218 ndm = nlmsg_data(nlh); 219 ndm->ndm_family = AF_BRIDGE; 220 ndm->ndm_pad1 = 0; 221 ndm->ndm_pad2 = 0; 222 ndm->ndm_flags = NTF_SELF; 223 ndm->ndm_type = 0; 224 ndm->ndm_ifindex = dump->dev->ifindex; 225 ndm->ndm_state = is_static ? NUD_NOARP : NUD_REACHABLE; 226 227 if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, addr)) 228 goto nla_put_failure; 229 230 if (vid && nla_put_u16(dump->skb, NDA_VLAN, vid)) 231 goto nla_put_failure; 232 233 nlmsg_end(dump->skb, nlh); 234 235 skip: 236 dump->idx++; 237 return 0; 238 239 nla_put_failure: 240 nlmsg_cancel(dump->skb, nlh); 241 return -EMSGSIZE; 242 } 243 244 static int 245 dsa_slave_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb, 246 struct net_device *dev, struct net_device *filter_dev, 247 int *idx) 248 { 249 struct dsa_slave_dump_ctx dump = { 250 .dev = dev, 251 .skb = skb, 252 .cb = cb, 253 .idx = *idx, 254 }; 255 struct dsa_slave_priv *p = netdev_priv(dev); 256 struct dsa_port *dp = p->dp; 257 int err; 258 259 err = dsa_port_fdb_dump(dp, dsa_slave_port_fdb_do_dump, &dump); 260 *idx = dump.idx; 261 262 return err; 263 } 264 265 static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 266 { 267 if (!dev->phydev) 268 return -ENODEV; 269 270 return phy_mii_ioctl(dev->phydev, ifr, cmd); 271 } 272 273 static int dsa_slave_port_attr_set(struct net_device *dev, 274 const struct switchdev_attr *attr, 275 struct switchdev_trans *trans) 276 { 277 struct dsa_slave_priv *p = netdev_priv(dev); 278 struct dsa_port *dp = p->dp; 279 int ret; 280 281 switch (attr->id) { 282 case SWITCHDEV_ATTR_ID_PORT_STP_STATE: 283 ret = dsa_port_set_state(dp, attr->u.stp_state, trans); 284 break; 285 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING: 286 ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering, 287 trans); 288 break; 289 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME: 290 ret = dsa_port_ageing_time(dp, attr->u.ageing_time, trans); 291 break; 292 default: 293 ret = -EOPNOTSUPP; 294 break; 295 } 296 297 return ret; 298 } 299 300 static int dsa_slave_port_obj_add(struct net_device *dev, 301 const struct switchdev_obj *obj, 302 struct switchdev_trans *trans) 303 { 304 struct dsa_slave_priv *p = netdev_priv(dev); 305 struct dsa_port *dp = p->dp; 306 int err; 307 308 /* For the prepare phase, ensure the full set of changes is feasable in 309 * one go in order to signal a failure properly. If an operation is not 310 * supported, return -EOPNOTSUPP. 311 */ 312 313 switch (obj->id) { 314 case SWITCHDEV_OBJ_ID_PORT_MDB: 315 err = dsa_port_mdb_add(dp, SWITCHDEV_OBJ_PORT_MDB(obj), trans); 316 break; 317 case SWITCHDEV_OBJ_ID_PORT_VLAN: 318 err = dsa_port_vlan_add(dp, SWITCHDEV_OBJ_PORT_VLAN(obj), 319 trans); 320 break; 321 default: 322 err = -EOPNOTSUPP; 323 break; 324 } 325 326 return err; 327 } 328 329 static int dsa_slave_port_obj_del(struct net_device *dev, 330 const struct switchdev_obj *obj) 331 { 332 struct dsa_slave_priv *p = netdev_priv(dev); 333 struct dsa_port *dp = p->dp; 334 int err; 335 336 switch (obj->id) { 337 case SWITCHDEV_OBJ_ID_PORT_MDB: 338 err = dsa_port_mdb_del(dp, SWITCHDEV_OBJ_PORT_MDB(obj)); 339 break; 340 case SWITCHDEV_OBJ_ID_PORT_VLAN: 341 err = dsa_port_vlan_del(dp, SWITCHDEV_OBJ_PORT_VLAN(obj)); 342 break; 343 default: 344 err = -EOPNOTSUPP; 345 break; 346 } 347 348 return err; 349 } 350 351 static int dsa_slave_port_attr_get(struct net_device *dev, 352 struct switchdev_attr *attr) 353 { 354 struct dsa_slave_priv *p = netdev_priv(dev); 355 struct dsa_switch *ds = p->dp->ds; 356 357 switch (attr->id) { 358 case SWITCHDEV_ATTR_ID_PORT_PARENT_ID: 359 attr->u.ppid.id_len = sizeof(ds->index); 360 memcpy(&attr->u.ppid.id, &ds->index, attr->u.ppid.id_len); 361 break; 362 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS_SUPPORT: 363 attr->u.brport_flags_support = 0; 364 break; 365 default: 366 return -EOPNOTSUPP; 367 } 368 369 return 0; 370 } 371 372 static inline netdev_tx_t dsa_slave_netpoll_send_skb(struct net_device *dev, 373 struct sk_buff *skb) 374 { 375 #ifdef CONFIG_NET_POLL_CONTROLLER 376 struct dsa_slave_priv *p = netdev_priv(dev); 377 378 if (p->netpoll) 379 netpoll_send_skb(p->netpoll, skb); 380 #else 381 BUG(); 382 #endif 383 return NETDEV_TX_OK; 384 } 385 386 static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev) 387 { 388 struct dsa_slave_priv *p = netdev_priv(dev); 389 struct pcpu_sw_netstats *s; 390 struct sk_buff *nskb; 391 392 s = this_cpu_ptr(p->stats64); 393 u64_stats_update_begin(&s->syncp); 394 s->tx_packets++; 395 s->tx_bytes += skb->len; 396 u64_stats_update_end(&s->syncp); 397 398 /* Transmit function may have to reallocate the original SKB, 399 * in which case it must have freed it. Only free it here on error. 400 */ 401 nskb = p->xmit(skb, dev); 402 if (!nskb) { 403 kfree_skb(skb); 404 return NETDEV_TX_OK; 405 } 406 407 /* SKB for netpoll still need to be mangled with the protocol-specific 408 * tag to be successfully transmitted 409 */ 410 if (unlikely(netpoll_tx_running(dev))) 411 return dsa_slave_netpoll_send_skb(dev, nskb); 412 413 /* Queue the SKB for transmission on the parent interface, but 414 * do not modify its EtherType 415 */ 416 nskb->dev = dsa_master_netdev(p); 417 dev_queue_xmit(nskb); 418 419 return NETDEV_TX_OK; 420 } 421 422 /* ethtool operations *******************************************************/ 423 424 static void dsa_slave_get_drvinfo(struct net_device *dev, 425 struct ethtool_drvinfo *drvinfo) 426 { 427 strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver)); 428 strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version)); 429 strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info)); 430 } 431 432 static int dsa_slave_get_regs_len(struct net_device *dev) 433 { 434 struct dsa_slave_priv *p = netdev_priv(dev); 435 struct dsa_switch *ds = p->dp->ds; 436 437 if (ds->ops->get_regs_len) 438 return ds->ops->get_regs_len(ds, p->dp->index); 439 440 return -EOPNOTSUPP; 441 } 442 443 static void 444 dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p) 445 { 446 struct dsa_slave_priv *p = netdev_priv(dev); 447 struct dsa_switch *ds = p->dp->ds; 448 449 if (ds->ops->get_regs) 450 ds->ops->get_regs(ds, p->dp->index, regs, _p); 451 } 452 453 static u32 dsa_slave_get_link(struct net_device *dev) 454 { 455 if (!dev->phydev) 456 return -ENODEV; 457 458 genphy_update_link(dev->phydev); 459 460 return dev->phydev->link; 461 } 462 463 static int dsa_slave_get_eeprom_len(struct net_device *dev) 464 { 465 struct dsa_slave_priv *p = netdev_priv(dev); 466 struct dsa_switch *ds = p->dp->ds; 467 468 if (ds->cd && ds->cd->eeprom_len) 469 return ds->cd->eeprom_len; 470 471 if (ds->ops->get_eeprom_len) 472 return ds->ops->get_eeprom_len(ds); 473 474 return 0; 475 } 476 477 static int dsa_slave_get_eeprom(struct net_device *dev, 478 struct ethtool_eeprom *eeprom, u8 *data) 479 { 480 struct dsa_slave_priv *p = netdev_priv(dev); 481 struct dsa_switch *ds = p->dp->ds; 482 483 if (ds->ops->get_eeprom) 484 return ds->ops->get_eeprom(ds, eeprom, data); 485 486 return -EOPNOTSUPP; 487 } 488 489 static int dsa_slave_set_eeprom(struct net_device *dev, 490 struct ethtool_eeprom *eeprom, u8 *data) 491 { 492 struct dsa_slave_priv *p = netdev_priv(dev); 493 struct dsa_switch *ds = p->dp->ds; 494 495 if (ds->ops->set_eeprom) 496 return ds->ops->set_eeprom(ds, eeprom, data); 497 498 return -EOPNOTSUPP; 499 } 500 501 static void dsa_slave_get_strings(struct net_device *dev, 502 uint32_t stringset, uint8_t *data) 503 { 504 struct dsa_slave_priv *p = netdev_priv(dev); 505 struct dsa_switch *ds = p->dp->ds; 506 507 if (stringset == ETH_SS_STATS) { 508 int len = ETH_GSTRING_LEN; 509 510 strncpy(data, "tx_packets", len); 511 strncpy(data + len, "tx_bytes", len); 512 strncpy(data + 2 * len, "rx_packets", len); 513 strncpy(data + 3 * len, "rx_bytes", len); 514 if (ds->ops->get_strings) 515 ds->ops->get_strings(ds, p->dp->index, data + 4 * len); 516 } 517 } 518 519 static void dsa_slave_get_ethtool_stats(struct net_device *dev, 520 struct ethtool_stats *stats, 521 uint64_t *data) 522 { 523 struct dsa_slave_priv *p = netdev_priv(dev); 524 struct dsa_switch *ds = p->dp->ds; 525 struct pcpu_sw_netstats *s; 526 unsigned int start; 527 int i; 528 529 for_each_possible_cpu(i) { 530 u64 tx_packets, tx_bytes, rx_packets, rx_bytes; 531 532 s = per_cpu_ptr(p->stats64, i); 533 do { 534 start = u64_stats_fetch_begin_irq(&s->syncp); 535 tx_packets = s->tx_packets; 536 tx_bytes = s->tx_bytes; 537 rx_packets = s->rx_packets; 538 rx_bytes = s->rx_bytes; 539 } while (u64_stats_fetch_retry_irq(&s->syncp, start)); 540 data[0] += tx_packets; 541 data[1] += tx_bytes; 542 data[2] += rx_packets; 543 data[3] += rx_bytes; 544 } 545 if (ds->ops->get_ethtool_stats) 546 ds->ops->get_ethtool_stats(ds, p->dp->index, data + 4); 547 } 548 549 static int dsa_slave_get_sset_count(struct net_device *dev, int sset) 550 { 551 struct dsa_slave_priv *p = netdev_priv(dev); 552 struct dsa_switch *ds = p->dp->ds; 553 554 if (sset == ETH_SS_STATS) { 555 int count; 556 557 count = 4; 558 if (ds->ops->get_sset_count) 559 count += ds->ops->get_sset_count(ds); 560 561 return count; 562 } 563 564 return -EOPNOTSUPP; 565 } 566 567 static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w) 568 { 569 struct dsa_slave_priv *p = netdev_priv(dev); 570 struct dsa_switch *ds = p->dp->ds; 571 572 if (ds->ops->get_wol) 573 ds->ops->get_wol(ds, p->dp->index, w); 574 } 575 576 static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w) 577 { 578 struct dsa_slave_priv *p = netdev_priv(dev); 579 struct dsa_switch *ds = p->dp->ds; 580 int ret = -EOPNOTSUPP; 581 582 if (ds->ops->set_wol) 583 ret = ds->ops->set_wol(ds, p->dp->index, w); 584 585 return ret; 586 } 587 588 static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e) 589 { 590 struct dsa_slave_priv *p = netdev_priv(dev); 591 struct dsa_switch *ds = p->dp->ds; 592 int ret; 593 594 /* Port's PHY and MAC both need to be EEE capable */ 595 if (!dev->phydev) 596 return -ENODEV; 597 598 if (!ds->ops->set_mac_eee) 599 return -EOPNOTSUPP; 600 601 ret = ds->ops->set_mac_eee(ds, p->dp->index, e); 602 if (ret) 603 return ret; 604 605 if (e->eee_enabled) { 606 ret = phy_init_eee(dev->phydev, 0); 607 if (ret) 608 return ret; 609 } 610 611 return phy_ethtool_set_eee(dev->phydev, e); 612 } 613 614 static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e) 615 { 616 struct dsa_slave_priv *p = netdev_priv(dev); 617 struct dsa_switch *ds = p->dp->ds; 618 int ret; 619 620 /* Port's PHY and MAC both need to be EEE capable */ 621 if (!dev->phydev) 622 return -ENODEV; 623 624 if (!ds->ops->get_mac_eee) 625 return -EOPNOTSUPP; 626 627 ret = ds->ops->get_mac_eee(ds, p->dp->index, e); 628 if (ret) 629 return ret; 630 631 return phy_ethtool_get_eee(dev->phydev, e); 632 } 633 634 #ifdef CONFIG_NET_POLL_CONTROLLER 635 static int dsa_slave_netpoll_setup(struct net_device *dev, 636 struct netpoll_info *ni) 637 { 638 struct dsa_slave_priv *p = netdev_priv(dev); 639 struct net_device *master = dsa_master_netdev(p); 640 struct netpoll *netpoll; 641 int err = 0; 642 643 netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL); 644 if (!netpoll) 645 return -ENOMEM; 646 647 err = __netpoll_setup(netpoll, master); 648 if (err) { 649 kfree(netpoll); 650 goto out; 651 } 652 653 p->netpoll = netpoll; 654 out: 655 return err; 656 } 657 658 static void dsa_slave_netpoll_cleanup(struct net_device *dev) 659 { 660 struct dsa_slave_priv *p = netdev_priv(dev); 661 struct netpoll *netpoll = p->netpoll; 662 663 if (!netpoll) 664 return; 665 666 p->netpoll = NULL; 667 668 __netpoll_free_async(netpoll); 669 } 670 671 static void dsa_slave_poll_controller(struct net_device *dev) 672 { 673 } 674 #endif 675 676 static int dsa_slave_get_phys_port_name(struct net_device *dev, 677 char *name, size_t len) 678 { 679 struct dsa_slave_priv *p = netdev_priv(dev); 680 681 if (snprintf(name, len, "p%d", p->dp->index) >= len) 682 return -EINVAL; 683 684 return 0; 685 } 686 687 static struct dsa_mall_tc_entry * 688 dsa_slave_mall_tc_entry_find(struct net_device *dev, unsigned long cookie) 689 { 690 struct dsa_slave_priv *p = netdev_priv(dev); 691 struct dsa_mall_tc_entry *mall_tc_entry; 692 693 list_for_each_entry(mall_tc_entry, &p->mall_tc_list, list) 694 if (mall_tc_entry->cookie == cookie) 695 return mall_tc_entry; 696 697 return NULL; 698 } 699 700 static int dsa_slave_add_cls_matchall(struct net_device *dev, 701 struct tc_cls_matchall_offload *cls, 702 bool ingress) 703 { 704 struct dsa_slave_priv *p = netdev_priv(dev); 705 struct dsa_mall_tc_entry *mall_tc_entry; 706 __be16 protocol = cls->common.protocol; 707 struct dsa_switch *ds = p->dp->ds; 708 struct net *net = dev_net(dev); 709 struct dsa_slave_priv *to_p; 710 struct net_device *to_dev; 711 const struct tc_action *a; 712 int err = -EOPNOTSUPP; 713 LIST_HEAD(actions); 714 int ifindex; 715 716 if (!ds->ops->port_mirror_add) 717 return err; 718 719 if (!tcf_exts_has_one_action(cls->exts)) 720 return err; 721 722 tcf_exts_to_list(cls->exts, &actions); 723 a = list_first_entry(&actions, struct tc_action, list); 724 725 if (is_tcf_mirred_egress_mirror(a) && protocol == htons(ETH_P_ALL)) { 726 struct dsa_mall_mirror_tc_entry *mirror; 727 728 ifindex = tcf_mirred_ifindex(a); 729 to_dev = __dev_get_by_index(net, ifindex); 730 if (!to_dev) 731 return -EINVAL; 732 733 if (!dsa_slave_dev_check(to_dev)) 734 return -EOPNOTSUPP; 735 736 mall_tc_entry = kzalloc(sizeof(*mall_tc_entry), GFP_KERNEL); 737 if (!mall_tc_entry) 738 return -ENOMEM; 739 740 mall_tc_entry->cookie = cls->cookie; 741 mall_tc_entry->type = DSA_PORT_MALL_MIRROR; 742 mirror = &mall_tc_entry->mirror; 743 744 to_p = netdev_priv(to_dev); 745 746 mirror->to_local_port = to_p->dp->index; 747 mirror->ingress = ingress; 748 749 err = ds->ops->port_mirror_add(ds, p->dp->index, mirror, 750 ingress); 751 if (err) { 752 kfree(mall_tc_entry); 753 return err; 754 } 755 756 list_add_tail(&mall_tc_entry->list, &p->mall_tc_list); 757 } 758 759 return 0; 760 } 761 762 static void dsa_slave_del_cls_matchall(struct net_device *dev, 763 struct tc_cls_matchall_offload *cls) 764 { 765 struct dsa_slave_priv *p = netdev_priv(dev); 766 struct dsa_mall_tc_entry *mall_tc_entry; 767 struct dsa_switch *ds = p->dp->ds; 768 769 if (!ds->ops->port_mirror_del) 770 return; 771 772 mall_tc_entry = dsa_slave_mall_tc_entry_find(dev, cls->cookie); 773 if (!mall_tc_entry) 774 return; 775 776 list_del(&mall_tc_entry->list); 777 778 switch (mall_tc_entry->type) { 779 case DSA_PORT_MALL_MIRROR: 780 ds->ops->port_mirror_del(ds, p->dp->index, 781 &mall_tc_entry->mirror); 782 break; 783 default: 784 WARN_ON(1); 785 } 786 787 kfree(mall_tc_entry); 788 } 789 790 static int dsa_slave_setup_tc_cls_matchall(struct net_device *dev, 791 struct tc_cls_matchall_offload *cls) 792 { 793 bool ingress; 794 795 if (is_classid_clsact_ingress(cls->common.classid)) 796 ingress = true; 797 else if (is_classid_clsact_egress(cls->common.classid)) 798 ingress = false; 799 else 800 return -EOPNOTSUPP; 801 802 if (cls->common.chain_index) 803 return -EOPNOTSUPP; 804 805 switch (cls->command) { 806 case TC_CLSMATCHALL_REPLACE: 807 return dsa_slave_add_cls_matchall(dev, cls, ingress); 808 case TC_CLSMATCHALL_DESTROY: 809 dsa_slave_del_cls_matchall(dev, cls); 810 return 0; 811 default: 812 return -EOPNOTSUPP; 813 } 814 } 815 816 static int dsa_slave_setup_tc(struct net_device *dev, enum tc_setup_type type, 817 void *type_data) 818 { 819 switch (type) { 820 case TC_SETUP_CLSMATCHALL: 821 return dsa_slave_setup_tc_cls_matchall(dev, type_data); 822 default: 823 return -EOPNOTSUPP; 824 } 825 } 826 827 static void dsa_slave_get_stats64(struct net_device *dev, 828 struct rtnl_link_stats64 *stats) 829 { 830 struct dsa_slave_priv *p = netdev_priv(dev); 831 struct pcpu_sw_netstats *s; 832 unsigned int start; 833 int i; 834 835 netdev_stats_to_stats64(stats, &dev->stats); 836 for_each_possible_cpu(i) { 837 u64 tx_packets, tx_bytes, rx_packets, rx_bytes; 838 839 s = per_cpu_ptr(p->stats64, i); 840 do { 841 start = u64_stats_fetch_begin_irq(&s->syncp); 842 tx_packets = s->tx_packets; 843 tx_bytes = s->tx_bytes; 844 rx_packets = s->rx_packets; 845 rx_bytes = s->rx_bytes; 846 } while (u64_stats_fetch_retry_irq(&s->syncp, start)); 847 848 stats->tx_packets += tx_packets; 849 stats->tx_bytes += tx_bytes; 850 stats->rx_packets += rx_packets; 851 stats->rx_bytes += rx_bytes; 852 } 853 } 854 855 static int dsa_slave_get_rxnfc(struct net_device *dev, 856 struct ethtool_rxnfc *nfc, u32 *rule_locs) 857 { 858 struct dsa_slave_priv *p = netdev_priv(dev); 859 struct dsa_switch *ds = p->dp->ds; 860 861 if (!ds->ops->get_rxnfc) 862 return -EOPNOTSUPP; 863 864 return ds->ops->get_rxnfc(ds, p->dp->index, nfc, rule_locs); 865 } 866 867 static int dsa_slave_set_rxnfc(struct net_device *dev, 868 struct ethtool_rxnfc *nfc) 869 { 870 struct dsa_slave_priv *p = netdev_priv(dev); 871 struct dsa_switch *ds = p->dp->ds; 872 873 if (!ds->ops->set_rxnfc) 874 return -EOPNOTSUPP; 875 876 return ds->ops->set_rxnfc(ds, p->dp->index, nfc); 877 } 878 879 static const struct ethtool_ops dsa_slave_ethtool_ops = { 880 .get_drvinfo = dsa_slave_get_drvinfo, 881 .get_regs_len = dsa_slave_get_regs_len, 882 .get_regs = dsa_slave_get_regs, 883 .nway_reset = phy_ethtool_nway_reset, 884 .get_link = dsa_slave_get_link, 885 .get_eeprom_len = dsa_slave_get_eeprom_len, 886 .get_eeprom = dsa_slave_get_eeprom, 887 .set_eeprom = dsa_slave_set_eeprom, 888 .get_strings = dsa_slave_get_strings, 889 .get_ethtool_stats = dsa_slave_get_ethtool_stats, 890 .get_sset_count = dsa_slave_get_sset_count, 891 .set_wol = dsa_slave_set_wol, 892 .get_wol = dsa_slave_get_wol, 893 .set_eee = dsa_slave_set_eee, 894 .get_eee = dsa_slave_get_eee, 895 .get_link_ksettings = phy_ethtool_get_link_ksettings, 896 .set_link_ksettings = phy_ethtool_set_link_ksettings, 897 .get_rxnfc = dsa_slave_get_rxnfc, 898 .set_rxnfc = dsa_slave_set_rxnfc, 899 }; 900 901 static const struct net_device_ops dsa_slave_netdev_ops = { 902 .ndo_open = dsa_slave_open, 903 .ndo_stop = dsa_slave_close, 904 .ndo_start_xmit = dsa_slave_xmit, 905 .ndo_change_rx_flags = dsa_slave_change_rx_flags, 906 .ndo_set_rx_mode = dsa_slave_set_rx_mode, 907 .ndo_set_mac_address = dsa_slave_set_mac_address, 908 .ndo_fdb_add = dsa_legacy_fdb_add, 909 .ndo_fdb_del = dsa_legacy_fdb_del, 910 .ndo_fdb_dump = dsa_slave_fdb_dump, 911 .ndo_do_ioctl = dsa_slave_ioctl, 912 .ndo_get_iflink = dsa_slave_get_iflink, 913 #ifdef CONFIG_NET_POLL_CONTROLLER 914 .ndo_netpoll_setup = dsa_slave_netpoll_setup, 915 .ndo_netpoll_cleanup = dsa_slave_netpoll_cleanup, 916 .ndo_poll_controller = dsa_slave_poll_controller, 917 #endif 918 .ndo_get_phys_port_name = dsa_slave_get_phys_port_name, 919 .ndo_setup_tc = dsa_slave_setup_tc, 920 .ndo_get_stats64 = dsa_slave_get_stats64, 921 }; 922 923 static const struct switchdev_ops dsa_slave_switchdev_ops = { 924 .switchdev_port_attr_get = dsa_slave_port_attr_get, 925 .switchdev_port_attr_set = dsa_slave_port_attr_set, 926 .switchdev_port_obj_add = dsa_slave_port_obj_add, 927 .switchdev_port_obj_del = dsa_slave_port_obj_del, 928 }; 929 930 static struct device_type dsa_type = { 931 .name = "dsa", 932 }; 933 934 static void dsa_slave_adjust_link(struct net_device *dev) 935 { 936 struct dsa_slave_priv *p = netdev_priv(dev); 937 struct dsa_switch *ds = p->dp->ds; 938 unsigned int status_changed = 0; 939 940 if (p->old_link != dev->phydev->link) { 941 status_changed = 1; 942 p->old_link = dev->phydev->link; 943 } 944 945 if (p->old_duplex != dev->phydev->duplex) { 946 status_changed = 1; 947 p->old_duplex = dev->phydev->duplex; 948 } 949 950 if (p->old_pause != dev->phydev->pause) { 951 status_changed = 1; 952 p->old_pause = dev->phydev->pause; 953 } 954 955 if (ds->ops->adjust_link && status_changed) 956 ds->ops->adjust_link(ds, p->dp->index, dev->phydev); 957 958 if (status_changed) 959 phy_print_status(dev->phydev); 960 } 961 962 static int dsa_slave_fixed_link_update(struct net_device *dev, 963 struct fixed_phy_status *status) 964 { 965 struct dsa_slave_priv *p; 966 struct dsa_switch *ds; 967 968 if (dev) { 969 p = netdev_priv(dev); 970 ds = p->dp->ds; 971 if (ds->ops->fixed_link_update) 972 ds->ops->fixed_link_update(ds, p->dp->index, status); 973 } 974 975 return 0; 976 } 977 978 /* slave device setup *******************************************************/ 979 static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr) 980 { 981 struct dsa_slave_priv *p = netdev_priv(slave_dev); 982 struct dsa_switch *ds = p->dp->ds; 983 984 slave_dev->phydev = mdiobus_get_phy(ds->slave_mii_bus, addr); 985 if (!slave_dev->phydev) { 986 netdev_err(slave_dev, "no phy at %d\n", addr); 987 return -ENODEV; 988 } 989 990 /* Use already configured phy mode */ 991 if (p->phy_interface == PHY_INTERFACE_MODE_NA) 992 p->phy_interface = slave_dev->phydev->interface; 993 994 return phy_connect_direct(slave_dev, slave_dev->phydev, 995 dsa_slave_adjust_link, p->phy_interface); 996 } 997 998 static int dsa_slave_phy_setup(struct net_device *slave_dev) 999 { 1000 struct dsa_slave_priv *p = netdev_priv(slave_dev); 1001 struct dsa_switch *ds = p->dp->ds; 1002 struct device_node *phy_dn, *port_dn; 1003 bool phy_is_fixed = false; 1004 u32 phy_flags = 0; 1005 int mode, ret; 1006 1007 port_dn = p->dp->dn; 1008 mode = of_get_phy_mode(port_dn); 1009 if (mode < 0) 1010 mode = PHY_INTERFACE_MODE_NA; 1011 p->phy_interface = mode; 1012 1013 phy_dn = of_parse_phandle(port_dn, "phy-handle", 0); 1014 if (!phy_dn && of_phy_is_fixed_link(port_dn)) { 1015 /* In the case of a fixed PHY, the DT node associated 1016 * to the fixed PHY is the Port DT node 1017 */ 1018 ret = of_phy_register_fixed_link(port_dn); 1019 if (ret) { 1020 netdev_err(slave_dev, "failed to register fixed PHY: %d\n", ret); 1021 return ret; 1022 } 1023 phy_is_fixed = true; 1024 phy_dn = of_node_get(port_dn); 1025 } 1026 1027 if (ds->ops->get_phy_flags) 1028 phy_flags = ds->ops->get_phy_flags(ds, p->dp->index); 1029 1030 if (phy_dn) { 1031 int phy_id = of_mdio_parse_addr(&slave_dev->dev, phy_dn); 1032 1033 /* If this PHY address is part of phys_mii_mask, which means 1034 * that we need to divert reads and writes to/from it, then we 1035 * want to bind this device using the slave MII bus created by 1036 * DSA to make that happen. 1037 */ 1038 if (!phy_is_fixed && phy_id >= 0 && 1039 (ds->phys_mii_mask & (1 << phy_id))) { 1040 ret = dsa_slave_phy_connect(slave_dev, phy_id); 1041 if (ret) { 1042 netdev_err(slave_dev, "failed to connect to phy%d: %d\n", phy_id, ret); 1043 of_node_put(phy_dn); 1044 return ret; 1045 } 1046 } else { 1047 slave_dev->phydev = of_phy_connect(slave_dev, phy_dn, 1048 dsa_slave_adjust_link, 1049 phy_flags, 1050 p->phy_interface); 1051 } 1052 1053 of_node_put(phy_dn); 1054 } 1055 1056 if (slave_dev->phydev && phy_is_fixed) 1057 fixed_phy_set_link_update(slave_dev->phydev, 1058 dsa_slave_fixed_link_update); 1059 1060 /* We could not connect to a designated PHY, so use the switch internal 1061 * MDIO bus instead 1062 */ 1063 if (!slave_dev->phydev) { 1064 ret = dsa_slave_phy_connect(slave_dev, p->dp->index); 1065 if (ret) { 1066 netdev_err(slave_dev, "failed to connect to port %d: %d\n", 1067 p->dp->index, ret); 1068 if (phy_is_fixed) 1069 of_phy_deregister_fixed_link(port_dn); 1070 return ret; 1071 } 1072 } 1073 1074 phy_attached_info(slave_dev->phydev); 1075 1076 return 0; 1077 } 1078 1079 static struct lock_class_key dsa_slave_netdev_xmit_lock_key; 1080 static void dsa_slave_set_lockdep_class_one(struct net_device *dev, 1081 struct netdev_queue *txq, 1082 void *_unused) 1083 { 1084 lockdep_set_class(&txq->_xmit_lock, 1085 &dsa_slave_netdev_xmit_lock_key); 1086 } 1087 1088 int dsa_slave_suspend(struct net_device *slave_dev) 1089 { 1090 struct dsa_slave_priv *p = netdev_priv(slave_dev); 1091 1092 netif_device_detach(slave_dev); 1093 1094 if (slave_dev->phydev) { 1095 phy_stop(slave_dev->phydev); 1096 p->old_pause = -1; 1097 p->old_link = -1; 1098 p->old_duplex = -1; 1099 phy_suspend(slave_dev->phydev); 1100 } 1101 1102 return 0; 1103 } 1104 1105 int dsa_slave_resume(struct net_device *slave_dev) 1106 { 1107 netif_device_attach(slave_dev); 1108 1109 if (slave_dev->phydev) { 1110 phy_resume(slave_dev->phydev); 1111 phy_start(slave_dev->phydev); 1112 } 1113 1114 return 0; 1115 } 1116 1117 int dsa_slave_create(struct dsa_port *port, const char *name) 1118 { 1119 struct dsa_switch *ds = port->ds; 1120 struct net_device *master; 1121 struct net_device *slave_dev; 1122 struct dsa_slave_priv *p; 1123 struct dsa_port *cpu_dp; 1124 int ret; 1125 1126 cpu_dp = ds->dst->cpu_dp; 1127 master = cpu_dp->netdev; 1128 1129 if (!ds->num_tx_queues) 1130 ds->num_tx_queues = 1; 1131 1132 slave_dev = alloc_netdev_mqs(sizeof(struct dsa_slave_priv), name, 1133 NET_NAME_UNKNOWN, ether_setup, 1134 ds->num_tx_queues, 1); 1135 if (slave_dev == NULL) 1136 return -ENOMEM; 1137 1138 slave_dev->features = master->vlan_features | NETIF_F_HW_TC; 1139 slave_dev->hw_features |= NETIF_F_HW_TC; 1140 slave_dev->ethtool_ops = &dsa_slave_ethtool_ops; 1141 eth_hw_addr_inherit(slave_dev, master); 1142 slave_dev->priv_flags |= IFF_NO_QUEUE; 1143 slave_dev->netdev_ops = &dsa_slave_netdev_ops; 1144 slave_dev->switchdev_ops = &dsa_slave_switchdev_ops; 1145 slave_dev->min_mtu = 0; 1146 slave_dev->max_mtu = ETH_MAX_MTU; 1147 SET_NETDEV_DEVTYPE(slave_dev, &dsa_type); 1148 1149 netdev_for_each_tx_queue(slave_dev, dsa_slave_set_lockdep_class_one, 1150 NULL); 1151 1152 SET_NETDEV_DEV(slave_dev, port->ds->dev); 1153 slave_dev->dev.of_node = port->dn; 1154 slave_dev->vlan_features = master->vlan_features; 1155 1156 p = netdev_priv(slave_dev); 1157 p->stats64 = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); 1158 if (!p->stats64) { 1159 free_netdev(slave_dev); 1160 return -ENOMEM; 1161 } 1162 p->dp = port; 1163 INIT_LIST_HEAD(&p->mall_tc_list); 1164 p->xmit = cpu_dp->tag_ops->xmit; 1165 1166 p->old_pause = -1; 1167 p->old_link = -1; 1168 p->old_duplex = -1; 1169 1170 port->netdev = slave_dev; 1171 ret = register_netdev(slave_dev); 1172 if (ret) { 1173 netdev_err(master, "error %d registering interface %s\n", 1174 ret, slave_dev->name); 1175 port->netdev = NULL; 1176 free_percpu(p->stats64); 1177 free_netdev(slave_dev); 1178 return ret; 1179 } 1180 1181 netif_carrier_off(slave_dev); 1182 1183 ret = dsa_slave_phy_setup(slave_dev); 1184 if (ret) { 1185 netdev_err(master, "error %d setting up slave phy\n", ret); 1186 unregister_netdev(slave_dev); 1187 free_percpu(p->stats64); 1188 free_netdev(slave_dev); 1189 return ret; 1190 } 1191 1192 return 0; 1193 } 1194 1195 void dsa_slave_destroy(struct net_device *slave_dev) 1196 { 1197 struct dsa_slave_priv *p = netdev_priv(slave_dev); 1198 struct device_node *port_dn; 1199 1200 port_dn = p->dp->dn; 1201 1202 netif_carrier_off(slave_dev); 1203 if (slave_dev->phydev) { 1204 phy_disconnect(slave_dev->phydev); 1205 1206 if (of_phy_is_fixed_link(port_dn)) 1207 of_phy_deregister_fixed_link(port_dn); 1208 } 1209 unregister_netdev(slave_dev); 1210 free_percpu(p->stats64); 1211 free_netdev(slave_dev); 1212 } 1213 1214 static bool dsa_slave_dev_check(struct net_device *dev) 1215 { 1216 return dev->netdev_ops == &dsa_slave_netdev_ops; 1217 } 1218 1219 static int dsa_slave_changeupper(struct net_device *dev, 1220 struct netdev_notifier_changeupper_info *info) 1221 { 1222 struct dsa_slave_priv *p = netdev_priv(dev); 1223 struct dsa_port *dp = p->dp; 1224 int err = NOTIFY_DONE; 1225 1226 if (netif_is_bridge_master(info->upper_dev)) { 1227 if (info->linking) { 1228 err = dsa_port_bridge_join(dp, info->upper_dev); 1229 err = notifier_from_errno(err); 1230 } else { 1231 dsa_port_bridge_leave(dp, info->upper_dev); 1232 err = NOTIFY_OK; 1233 } 1234 } 1235 1236 return err; 1237 } 1238 1239 static int dsa_slave_netdevice_event(struct notifier_block *nb, 1240 unsigned long event, void *ptr) 1241 { 1242 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 1243 1244 if (!dsa_slave_dev_check(dev)) 1245 return NOTIFY_DONE; 1246 1247 if (event == NETDEV_CHANGEUPPER) 1248 return dsa_slave_changeupper(dev, ptr); 1249 1250 return NOTIFY_DONE; 1251 } 1252 1253 struct dsa_switchdev_event_work { 1254 struct work_struct work; 1255 struct switchdev_notifier_fdb_info fdb_info; 1256 struct net_device *dev; 1257 unsigned long event; 1258 }; 1259 1260 static void dsa_slave_switchdev_event_work(struct work_struct *work) 1261 { 1262 struct dsa_switchdev_event_work *switchdev_work = 1263 container_of(work, struct dsa_switchdev_event_work, work); 1264 struct net_device *dev = switchdev_work->dev; 1265 struct switchdev_notifier_fdb_info *fdb_info; 1266 struct dsa_slave_priv *p = netdev_priv(dev); 1267 int err; 1268 1269 rtnl_lock(); 1270 switch (switchdev_work->event) { 1271 case SWITCHDEV_FDB_ADD_TO_DEVICE: 1272 fdb_info = &switchdev_work->fdb_info; 1273 err = dsa_port_fdb_add(p->dp, fdb_info->addr, fdb_info->vid); 1274 if (err) { 1275 netdev_dbg(dev, "fdb add failed err=%d\n", err); 1276 break; 1277 } 1278 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, dev, 1279 &fdb_info->info); 1280 break; 1281 1282 case SWITCHDEV_FDB_DEL_TO_DEVICE: 1283 fdb_info = &switchdev_work->fdb_info; 1284 err = dsa_port_fdb_del(p->dp, fdb_info->addr, fdb_info->vid); 1285 if (err) { 1286 netdev_dbg(dev, "fdb del failed err=%d\n", err); 1287 dev_close(dev); 1288 } 1289 break; 1290 } 1291 rtnl_unlock(); 1292 1293 kfree(switchdev_work->fdb_info.addr); 1294 kfree(switchdev_work); 1295 dev_put(dev); 1296 } 1297 1298 static int 1299 dsa_slave_switchdev_fdb_work_init(struct dsa_switchdev_event_work * 1300 switchdev_work, 1301 const struct switchdev_notifier_fdb_info * 1302 fdb_info) 1303 { 1304 memcpy(&switchdev_work->fdb_info, fdb_info, 1305 sizeof(switchdev_work->fdb_info)); 1306 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC); 1307 if (!switchdev_work->fdb_info.addr) 1308 return -ENOMEM; 1309 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr, 1310 fdb_info->addr); 1311 return 0; 1312 } 1313 1314 /* Called under rcu_read_lock() */ 1315 static int dsa_slave_switchdev_event(struct notifier_block *unused, 1316 unsigned long event, void *ptr) 1317 { 1318 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 1319 struct dsa_switchdev_event_work *switchdev_work; 1320 1321 if (!dsa_slave_dev_check(dev)) 1322 return NOTIFY_DONE; 1323 1324 switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC); 1325 if (!switchdev_work) 1326 return NOTIFY_BAD; 1327 1328 INIT_WORK(&switchdev_work->work, 1329 dsa_slave_switchdev_event_work); 1330 switchdev_work->dev = dev; 1331 switchdev_work->event = event; 1332 1333 switch (event) { 1334 case SWITCHDEV_FDB_ADD_TO_DEVICE: /* fall through */ 1335 case SWITCHDEV_FDB_DEL_TO_DEVICE: 1336 if (dsa_slave_switchdev_fdb_work_init(switchdev_work, 1337 ptr)) 1338 goto err_fdb_work_init; 1339 dev_hold(dev); 1340 break; 1341 default: 1342 kfree(switchdev_work); 1343 return NOTIFY_DONE; 1344 } 1345 1346 dsa_schedule_work(&switchdev_work->work); 1347 return NOTIFY_OK; 1348 1349 err_fdb_work_init: 1350 kfree(switchdev_work); 1351 return NOTIFY_BAD; 1352 } 1353 1354 static struct notifier_block dsa_slave_nb __read_mostly = { 1355 .notifier_call = dsa_slave_netdevice_event, 1356 }; 1357 1358 static struct notifier_block dsa_slave_switchdev_notifier = { 1359 .notifier_call = dsa_slave_switchdev_event, 1360 }; 1361 1362 int dsa_slave_register_notifier(void) 1363 { 1364 int err; 1365 1366 err = register_netdevice_notifier(&dsa_slave_nb); 1367 if (err) 1368 return err; 1369 1370 err = register_switchdev_notifier(&dsa_slave_switchdev_notifier); 1371 if (err) 1372 goto err_switchdev_nb; 1373 1374 return 0; 1375 1376 err_switchdev_nb: 1377 unregister_netdevice_notifier(&dsa_slave_nb); 1378 return err; 1379 } 1380 1381 void dsa_slave_unregister_notifier(void) 1382 { 1383 int err; 1384 1385 err = unregister_switchdev_notifier(&dsa_slave_switchdev_notifier); 1386 if (err) 1387 pr_err("DSA: failed to unregister switchdev notifier (%d)\n", err); 1388 1389 err = unregister_netdevice_notifier(&dsa_slave_nb); 1390 if (err) 1391 pr_err("DSA: failed to unregister slave notifier (%d)\n", err); 1392 } 1393