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