net/dsa/slave.c

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