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