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 <net/rtnetlink.h>
  20 #include <net/switchdev.h>
  21 #include <linux/if_bridge.h>
  22 #include <linux/netpoll.h>
  23 #include "dsa_priv.h"
  24
  25 /* slave mii_bus handling ***************************************************/
  26 static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg)
  27 {
  28         struct dsa_switch *ds = bus->priv;
  29
  30         if (ds->phys_mii_mask & (1 << addr))
  31                 return ds->drv->phy_read(ds, addr, reg);
  32
  33         return 0xffff;
  34 }
  35
  36 static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val)
  37 {
  38         struct dsa_switch *ds = bus->priv;
  39
  40         if (ds->phys_mii_mask & (1 << addr))
  41                 return ds->drv->phy_write(ds, addr, reg, val);
  42
  43         return 0;
  44 }
  45
  46 void dsa_slave_mii_bus_init(struct dsa_switch *ds)
  47 {
  48         ds->slave_mii_bus->priv = (void *)ds;
  49         ds->slave_mii_bus->name = "dsa slave smi";
  50         ds->slave_mii_bus->read = dsa_slave_phy_read;
  51         ds->slave_mii_bus->write = dsa_slave_phy_write;
  52         snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d:%.2x",
  53                         ds->index, ds->pd->sw_addr);
  54         ds->slave_mii_bus->parent = ds->master_dev;
  55         ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask;
  56 }
  57
  58
  59 /* slave device handling ****************************************************/
  60 static int dsa_slave_get_iflink(const struct net_device *dev)
  61 {
  62         struct dsa_slave_priv *p = netdev_priv(dev);
  63
  64         return p->parent->dst->master_netdev->ifindex;
  65 }
  66
  67 static inline bool dsa_port_is_bridged(struct dsa_slave_priv *p)
  68 {
  69         return !!p->bridge_dev;
  70 }
  71
  72 static int dsa_slave_open(struct net_device *dev)
  73 {
  74         struct dsa_slave_priv *p = netdev_priv(dev);
  75         struct net_device *master = p->parent->dst->master_netdev;
  76         struct dsa_switch *ds = p->parent;
  77         u8 stp_state = dsa_port_is_bridged(p) ?
  78                         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->drv->port_enable) {
 102                 err = ds->drv->port_enable(ds, p->port, p->phy);
 103                 if (err)
 104                         goto clear_promisc;
 105         }
 106
 107         if (ds->drv->port_stp_update)
 108                 ds->drv->port_stp_update(ds, p->port, stp_state);
 109
 110         if (p->phy)
 111                 phy_start(p->phy);
 112
 113         return 0;
 114
 115 clear_promisc:
 116         if (dev->flags & IFF_PROMISC)
 117                 dev_set_promiscuity(master, -1);
 118 clear_allmulti:
 119         if (dev->flags & IFF_ALLMULTI)
 120                 dev_set_allmulti(master, -1);
 121 del_unicast:
 122         if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
 123                 dev_uc_del(master, dev->dev_addr);
 124 out:
 125         return err;
 126 }
 127
 128 static int dsa_slave_close(struct net_device *dev)
 129 {
 130         struct dsa_slave_priv *p = netdev_priv(dev);
 131         struct net_device *master = p->parent->dst->master_netdev;
 132         struct dsa_switch *ds = p->parent;
 133
 134         if (p->phy)
 135                 phy_stop(p->phy);
 136
 137         dev_mc_unsync(master, dev);
 138         dev_uc_unsync(master, dev);
 139         if (dev->flags & IFF_ALLMULTI)
 140                 dev_set_allmulti(master, -1);
 141         if (dev->flags & IFF_PROMISC)
 142                 dev_set_promiscuity(master, -1);
 143
 144         if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
 145                 dev_uc_del(master, dev->dev_addr);
 146
 147         if (ds->drv->port_disable)
 148                 ds->drv->port_disable(ds, p->port, p->phy);
 149
 150         if (ds->drv->port_stp_update)
 151                 ds->drv->port_stp_update(ds, p->port, BR_STATE_DISABLED);
 152
 153         return 0;
 154 }
 155
 156 static void dsa_slave_change_rx_flags(struct net_device *dev, int change)
 157 {
 158         struct dsa_slave_priv *p = netdev_priv(dev);
 159         struct net_device *master = p->parent->dst->master_netdev;
 160
 161         if (change & IFF_ALLMULTI)
 162                 dev_set_allmulti(master, dev->flags & IFF_ALLMULTI ? 1 : -1);
 163         if (change & IFF_PROMISC)
 164                 dev_set_promiscuity(master, dev->flags & IFF_PROMISC ? 1 : -1);
 165 }
 166
 167 static void dsa_slave_set_rx_mode(struct net_device *dev)
 168 {
 169         struct dsa_slave_priv *p = netdev_priv(dev);
 170         struct net_device *master = p->parent->dst->master_netdev;
 171
 172         dev_mc_sync(master, dev);
 173         dev_uc_sync(master, dev);
 174 }
 175
 176 static int dsa_slave_set_mac_address(struct net_device *dev, void *a)
 177 {
 178         struct dsa_slave_priv *p = netdev_priv(dev);
 179         struct net_device *master = p->parent->dst->master_netdev;
 180         struct sockaddr *addr = a;
 181         int err;
 182
 183         if (!is_valid_ether_addr(addr->sa_data))
 184                 return -EADDRNOTAVAIL;
 185
 186         if (!(dev->flags & IFF_UP))
 187                 goto out;
 188
 189         if (!ether_addr_equal(addr->sa_data, master->dev_addr)) {
 190                 err = dev_uc_add(master, addr->sa_data);
 191                 if (err < 0)
 192                         return err;
 193         }
 194
 195         if (!ether_addr_equal(dev->dev_addr, master->dev_addr))
 196                 dev_uc_del(master, dev->dev_addr);
 197
 198 out:
 199         ether_addr_copy(dev->dev_addr, addr->sa_data);
 200
 201         return 0;
 202 }
 203
 204 static int dsa_slave_port_vlan_add(struct net_device *dev,
 205                                    const struct switchdev_obj_port_vlan *vlan,
 206                                    struct switchdev_trans *trans)
 207 {
 208         struct dsa_slave_priv *p = netdev_priv(dev);
 209         struct dsa_switch *ds = p->parent;
 210         int err;
 211
 212         if (switchdev_trans_ph_prepare(trans)) {
 213                 if (!ds->drv->port_vlan_prepare || !ds->drv->port_vlan_add)
 214                         return -EOPNOTSUPP;
 215
 216                 err = ds->drv->port_vlan_prepare(ds, p->port, vlan, trans);
 217                 if (err)
 218                         return err;
 219         } else {
 220                 err = ds->drv->port_vlan_add(ds, p->port, vlan, trans);
 221                 if (err)
 222                         return err;
 223         }
 224
 225         return 0;
 226 }
 227
 228 static int dsa_slave_port_vlan_del(struct net_device *dev,
 229                                    const struct switchdev_obj_port_vlan *vlan)
 230 {
 231         struct dsa_slave_priv *p = netdev_priv(dev);
 232         struct dsa_switch *ds = p->parent;
 233
 234         if (!ds->drv->port_vlan_del)
 235                 return -EOPNOTSUPP;
 236
 237         return ds->drv->port_vlan_del(ds, p->port, vlan);
 238 }
 239
 240 static int dsa_slave_port_vlan_dump(struct net_device *dev,
 241                                     struct switchdev_obj_port_vlan *vlan,
 242                                     switchdev_obj_dump_cb_t *cb)
 243 {
 244         struct dsa_slave_priv *p = netdev_priv(dev);
 245         struct dsa_switch *ds = p->parent;
 246
 247         if (ds->drv->port_vlan_dump)
 248                 return ds->drv->port_vlan_dump(ds, p->port, vlan, cb);
 249
 250         return -EOPNOTSUPP;
 251 }
 252
 253 static int dsa_slave_port_fdb_add(struct net_device *dev,
 254                                   const struct switchdev_obj_port_fdb *fdb,
 255                                   struct switchdev_trans *trans)
 256 {
 257         struct dsa_slave_priv *p = netdev_priv(dev);
 258         struct dsa_switch *ds = p->parent;
 259         int ret;
 260
 261         if (!ds->drv->port_fdb_prepare || !ds->drv->port_fdb_add)
 262                 return -EOPNOTSUPP;
 263
 264         if (switchdev_trans_ph_prepare(trans))
 265                 ret = ds->drv->port_fdb_prepare(ds, p->port, fdb, trans);
 266         else
 267                 ret = ds->drv->port_fdb_add(ds, p->port, fdb, trans);
 268
 269         return ret;
 270 }
 271
 272 static int dsa_slave_port_fdb_del(struct net_device *dev,
 273                                   const struct switchdev_obj_port_fdb *fdb)
 274 {
 275         struct dsa_slave_priv *p = netdev_priv(dev);
 276         struct dsa_switch *ds = p->parent;
 277         int ret = -EOPNOTSUPP;
 278
 279         if (ds->drv->port_fdb_del)
 280                 ret = ds->drv->port_fdb_del(ds, p->port, fdb);
 281
 282         return ret;
 283 }
 284
 285 static int dsa_slave_port_fdb_dump(struct net_device *dev,
 286                                    struct switchdev_obj_port_fdb *fdb,
 287                                    switchdev_obj_dump_cb_t *cb)
 288 {
 289         struct dsa_slave_priv *p = netdev_priv(dev);
 290         struct dsa_switch *ds = p->parent;
 291
 292         if (ds->drv->port_fdb_dump)
 293                 return ds->drv->port_fdb_dump(ds, p->port, fdb, cb);
 294
 295         return -EOPNOTSUPP;
 296 }
 297
 298 static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 299 {
 300         struct dsa_slave_priv *p = netdev_priv(dev);
 301
 302         if (p->phy != NULL)
 303                 return phy_mii_ioctl(p->phy, ifr, cmd);
 304
 305         return -EOPNOTSUPP;
 306 }
 307
 308 static int dsa_slave_stp_update(struct net_device *dev, u8 state)
 309 {
 310         struct dsa_slave_priv *p = netdev_priv(dev);
 311         struct dsa_switch *ds = p->parent;
 312         int ret = -EOPNOTSUPP;
 313
 314         if (ds->drv->port_stp_update)
 315                 ret = ds->drv->port_stp_update(ds, p->port, state);
 316
 317         return ret;
 318 }
 319
 320 static int dsa_slave_port_attr_set(struct net_device *dev,
 321                                    const struct switchdev_attr *attr,
 322                                    struct switchdev_trans *trans)
 323 {
 324         struct dsa_slave_priv *p = netdev_priv(dev);
 325         struct dsa_switch *ds = p->parent;
 326         int ret;
 327
 328         switch (attr->id) {
 329         case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
 330                 if (switchdev_trans_ph_prepare(trans))
 331                         ret = ds->drv->port_stp_update ? 0 : -EOPNOTSUPP;
 332                 else
 333                         ret = ds->drv->port_stp_update(ds, p->port,
 334                                                        attr->u.stp_state);
 335                 break;
 336         default:
 337                 ret = -EOPNOTSUPP;
 338                 break;
 339         }
 340
 341         return ret;
 342 }
 343
 344 static int dsa_slave_port_obj_add(struct net_device *dev,
 345                                   const struct switchdev_obj *obj,
 346                                   struct switchdev_trans *trans)
 347 {
 348         int err;
 349
 350         /* For the prepare phase, ensure the full set of changes is feasable in
 351          * one go in order to signal a failure properly. If an operation is not
 352          * supported, return -EOPNOTSUPP.
 353          */
 354
 355         switch (obj->id) {
 356         case SWITCHDEV_OBJ_ID_PORT_FDB:
 357                 err = dsa_slave_port_fdb_add(dev,
 358                                              SWITCHDEV_OBJ_PORT_FDB(obj),
 359                                              trans);
 360                 break;
 361         case SWITCHDEV_OBJ_ID_PORT_VLAN:
 362                 err = dsa_slave_port_vlan_add(dev,
 363                                               SWITCHDEV_OBJ_PORT_VLAN(obj),
 364                                               trans);
 365                 break;
 366         default:
 367                 err = -EOPNOTSUPP;
 368                 break;
 369         }
 370
 371         return err;
 372 }
 373
 374 static int dsa_slave_port_obj_del(struct net_device *dev,
 375                                   const struct switchdev_obj *obj)
 376 {
 377         int err;
 378
 379         switch (obj->id) {
 380         case SWITCHDEV_OBJ_ID_PORT_FDB:
 381                 err = dsa_slave_port_fdb_del(dev,
 382                                              SWITCHDEV_OBJ_PORT_FDB(obj));
 383                 break;
 384         case SWITCHDEV_OBJ_ID_PORT_VLAN:
 385                 err = dsa_slave_port_vlan_del(dev,
 386                                               SWITCHDEV_OBJ_PORT_VLAN(obj));
 387                 break;
 388         default:
 389                 err = -EOPNOTSUPP;
 390                 break;
 391         }
 392
 393         return err;
 394 }
 395
 396 static int dsa_slave_port_obj_dump(struct net_device *dev,
 397                                    struct switchdev_obj *obj,
 398                                    switchdev_obj_dump_cb_t *cb)
 399 {
 400         int err;
 401
 402         switch (obj->id) {
 403         case SWITCHDEV_OBJ_ID_PORT_FDB:
 404                 err = dsa_slave_port_fdb_dump(dev,
 405                                               SWITCHDEV_OBJ_PORT_FDB(obj),
 406                                               cb);
 407                 break;
 408         case SWITCHDEV_OBJ_ID_PORT_VLAN:
 409                 err = dsa_slave_port_vlan_dump(dev,
 410                                                SWITCHDEV_OBJ_PORT_VLAN(obj),
 411                                                cb);
 412                 break;
 413         default:
 414                 err = -EOPNOTSUPP;
 415                 break;
 416         }
 417
 418         return err;
 419 }
 420
 421 static int dsa_slave_bridge_port_join(struct net_device *dev,
 422                                       struct net_device *br)
 423 {
 424         struct dsa_slave_priv *p = netdev_priv(dev);
 425         struct dsa_switch *ds = p->parent;
 426         int ret = -EOPNOTSUPP;
 427
 428         p->bridge_dev = br;
 429
 430         if (ds->drv->port_join_bridge)
 431                 ret = ds->drv->port_join_bridge(ds, p->port, br);
 432
 433         return ret;
 434 }
 435
 436 static int dsa_slave_bridge_port_leave(struct net_device *dev)
 437 {
 438         struct dsa_slave_priv *p = netdev_priv(dev);
 439         struct dsa_switch *ds = p->parent;
 440         int ret = -EOPNOTSUPP;
 441
 442
 443         if (ds->drv->port_leave_bridge)
 444                 ret = ds->drv->port_leave_bridge(ds, p->port);
 445
 446         p->bridge_dev = NULL;
 447
 448         /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
 449          * so allow it to be in BR_STATE_FORWARDING to be kept functional
 450          */
 451         dsa_slave_stp_update(dev, BR_STATE_FORWARDING);
 452
 453         return ret;
 454 }
 455
 456 static int dsa_slave_port_attr_get(struct net_device *dev,
 457                                    struct switchdev_attr *attr)
 458 {
 459         struct dsa_slave_priv *p = netdev_priv(dev);
 460         struct dsa_switch *ds = p->parent;
 461
 462         switch (attr->id) {
 463         case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
 464                 attr->u.ppid.id_len = sizeof(ds->index);
 465                 memcpy(&attr->u.ppid.id, &ds->index, attr->u.ppid.id_len);
 466                 break;
 467         default:
 468                 return -EOPNOTSUPP;
 469         }
 470
 471         return 0;
 472 }
 473
 474 static inline netdev_tx_t dsa_netpoll_send_skb(struct dsa_slave_priv *p,
 475                                                struct sk_buff *skb)
 476 {
 477 #ifdef CONFIG_NET_POLL_CONTROLLER
 478         if (p->netpoll)
 479                 netpoll_send_skb(p->netpoll, skb);
 480 #else
 481         BUG();
 482 #endif
 483         return NETDEV_TX_OK;
 484 }
 485
 486 static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev)
 487 {
 488         struct dsa_slave_priv *p = netdev_priv(dev);
 489         struct sk_buff *nskb;
 490
 491         dev->stats.tx_packets++;
 492         dev->stats.tx_bytes += skb->len;
 493
 494         /* Transmit function may have to reallocate the original SKB */
 495         nskb = p->xmit(skb, dev);
 496         if (!nskb)
 497                 return NETDEV_TX_OK;
 498
 499         /* SKB for netpoll still need to be mangled with the protocol-specific
 500          * tag to be successfully transmitted
 501          */
 502         if (unlikely(netpoll_tx_running(dev)))
 503                 return dsa_netpoll_send_skb(p, nskb);
 504
 505         /* Queue the SKB for transmission on the parent interface, but
 506          * do not modify its EtherType
 507          */
 508         nskb->dev = p->parent->dst->master_netdev;
 509         dev_queue_xmit(nskb);
 510
 511         return NETDEV_TX_OK;
 512 }
 513
 514 static struct sk_buff *dsa_slave_notag_xmit(struct sk_buff *skb,
 515                                             struct net_device *dev)
 516 {
 517         /* Just return the original SKB */
 518         return skb;
 519 }
 520
 521
 522 /* ethtool operations *******************************************************/
 523 static int
 524 dsa_slave_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 525 {
 526         struct dsa_slave_priv *p = netdev_priv(dev);
 527         int err;
 528
 529         err = -EOPNOTSUPP;
 530         if (p->phy != NULL) {
 531                 err = phy_read_status(p->phy);
 532                 if (err == 0)
 533                         err = phy_ethtool_gset(p->phy, cmd);
 534         }
 535
 536         return err;
 537 }
 538
 539 static int
 540 dsa_slave_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 541 {
 542         struct dsa_slave_priv *p = netdev_priv(dev);
 543
 544         if (p->phy != NULL)
 545                 return phy_ethtool_sset(p->phy, cmd);
 546
 547         return -EOPNOTSUPP;
 548 }
 549
 550 static void dsa_slave_get_drvinfo(struct net_device *dev,
 551                                   struct ethtool_drvinfo *drvinfo)
 552 {
 553         strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver));
 554         strlcpy(drvinfo->version, dsa_driver_version, sizeof(drvinfo->version));
 555         strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
 556         strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info));
 557 }
 558
 559 static int dsa_slave_get_regs_len(struct net_device *dev)
 560 {
 561         struct dsa_slave_priv *p = netdev_priv(dev);
 562         struct dsa_switch *ds = p->parent;
 563
 564         if (ds->drv->get_regs_len)
 565                 return ds->drv->get_regs_len(ds, p->port);
 566
 567         return -EOPNOTSUPP;
 568 }
 569
 570 static void
 571 dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p)
 572 {
 573         struct dsa_slave_priv *p = netdev_priv(dev);
 574         struct dsa_switch *ds = p->parent;
 575
 576         if (ds->drv->get_regs)
 577                 ds->drv->get_regs(ds, p->port, regs, _p);
 578 }
 579
 580 static int dsa_slave_nway_reset(struct net_device *dev)
 581 {
 582         struct dsa_slave_priv *p = netdev_priv(dev);
 583
 584         if (p->phy != NULL)
 585                 return genphy_restart_aneg(p->phy);
 586
 587         return -EOPNOTSUPP;
 588 }
 589
 590 static u32 dsa_slave_get_link(struct net_device *dev)
 591 {
 592         struct dsa_slave_priv *p = netdev_priv(dev);
 593
 594         if (p->phy != NULL) {
 595                 genphy_update_link(p->phy);
 596                 return p->phy->link;
 597         }
 598
 599         return -EOPNOTSUPP;
 600 }
 601
 602 static int dsa_slave_get_eeprom_len(struct net_device *dev)
 603 {
 604         struct dsa_slave_priv *p = netdev_priv(dev);
 605         struct dsa_switch *ds = p->parent;
 606
 607         if (ds->pd->eeprom_len)
 608                 return ds->pd->eeprom_len;
 609
 610         if (ds->drv->get_eeprom_len)
 611                 return ds->drv->get_eeprom_len(ds);
 612
 613         return 0;
 614 }
 615
 616 static int dsa_slave_get_eeprom(struct net_device *dev,
 617                                 struct ethtool_eeprom *eeprom, u8 *data)
 618 {
 619         struct dsa_slave_priv *p = netdev_priv(dev);
 620         struct dsa_switch *ds = p->parent;
 621
 622         if (ds->drv->get_eeprom)
 623                 return ds->drv->get_eeprom(ds, eeprom, data);
 624
 625         return -EOPNOTSUPP;
 626 }
 627
 628 static int dsa_slave_set_eeprom(struct net_device *dev,
 629                                 struct ethtool_eeprom *eeprom, u8 *data)
 630 {
 631         struct dsa_slave_priv *p = netdev_priv(dev);
 632         struct dsa_switch *ds = p->parent;
 633
 634         if (ds->drv->set_eeprom)
 635                 return ds->drv->set_eeprom(ds, eeprom, data);
 636
 637         return -EOPNOTSUPP;
 638 }
 639
 640 static void dsa_slave_get_strings(struct net_device *dev,
 641                                   uint32_t stringset, uint8_t *data)
 642 {
 643         struct dsa_slave_priv *p = netdev_priv(dev);
 644         struct dsa_switch *ds = p->parent;
 645
 646         if (stringset == ETH_SS_STATS) {
 647                 int len = ETH_GSTRING_LEN;
 648
 649                 strncpy(data, "tx_packets", len);
 650                 strncpy(data + len, "tx_bytes", len);
 651                 strncpy(data + 2 * len, "rx_packets", len);
 652                 strncpy(data + 3 * len, "rx_bytes", len);
 653                 if (ds->drv->get_strings != NULL)
 654                         ds->drv->get_strings(ds, p->port, data + 4 * len);
 655         }
 656 }
 657
 658 static void dsa_slave_get_ethtool_stats(struct net_device *dev,
 659                                         struct ethtool_stats *stats,
 660                                         uint64_t *data)
 661 {
 662         struct dsa_slave_priv *p = netdev_priv(dev);
 663         struct dsa_switch *ds = p->parent;
 664
 665         data[0] = p->dev->stats.tx_packets;
 666         data[1] = p->dev->stats.tx_bytes;
 667         data[2] = p->dev->stats.rx_packets;
 668         data[3] = p->dev->stats.rx_bytes;
 669         if (ds->drv->get_ethtool_stats != NULL)
 670                 ds->drv->get_ethtool_stats(ds, p->port, data + 4);
 671 }
 672
 673 static int dsa_slave_get_sset_count(struct net_device *dev, int sset)
 674 {
 675         struct dsa_slave_priv *p = netdev_priv(dev);
 676         struct dsa_switch *ds = p->parent;
 677
 678         if (sset == ETH_SS_STATS) {
 679                 int count;
 680
 681                 count = 4;
 682                 if (ds->drv->get_sset_count != NULL)
 683                         count += ds->drv->get_sset_count(ds);
 684
 685                 return count;
 686         }
 687
 688         return -EOPNOTSUPP;
 689 }
 690
 691 static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
 692 {
 693         struct dsa_slave_priv *p = netdev_priv(dev);
 694         struct dsa_switch *ds = p->parent;
 695
 696         if (ds->drv->get_wol)
 697                 ds->drv->get_wol(ds, p->port, w);
 698 }
 699
 700 static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
 701 {
 702         struct dsa_slave_priv *p = netdev_priv(dev);
 703         struct dsa_switch *ds = p->parent;
 704         int ret = -EOPNOTSUPP;
 705
 706         if (ds->drv->set_wol)
 707                 ret = ds->drv->set_wol(ds, p->port, w);
 708
 709         return ret;
 710 }
 711
 712 static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
 713 {
 714         struct dsa_slave_priv *p = netdev_priv(dev);
 715         struct dsa_switch *ds = p->parent;
 716         int ret;
 717
 718         if (!ds->drv->set_eee)
 719                 return -EOPNOTSUPP;
 720
 721         ret = ds->drv->set_eee(ds, p->port, p->phy, e);
 722         if (ret)
 723                 return ret;
 724
 725         if (p->phy)
 726                 ret = phy_ethtool_set_eee(p->phy, e);
 727
 728         return ret;
 729 }
 730
 731 static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
 732 {
 733         struct dsa_slave_priv *p = netdev_priv(dev);
 734         struct dsa_switch *ds = p->parent;
 735         int ret;
 736
 737         if (!ds->drv->get_eee)
 738                 return -EOPNOTSUPP;
 739
 740         ret = ds->drv->get_eee(ds, p->port, e);
 741         if (ret)
 742                 return ret;
 743
 744         if (p->phy)
 745                 ret = phy_ethtool_get_eee(p->phy, e);
 746
 747         return ret;
 748 }
 749
 750 #ifdef CONFIG_NET_POLL_CONTROLLER
 751 static int dsa_slave_netpoll_setup(struct net_device *dev,
 752                                    struct netpoll_info *ni)
 753 {
 754         struct dsa_slave_priv *p = netdev_priv(dev);
 755         struct dsa_switch *ds = p->parent;
 756         struct net_device *master = ds->dst->master_netdev;
 757         struct netpoll *netpoll;
 758         int err = 0;
 759
 760         netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
 761         if (!netpoll)
 762                 return -ENOMEM;
 763
 764         err = __netpoll_setup(netpoll, master);
 765         if (err) {
 766                 kfree(netpoll);
 767                 goto out;
 768         }
 769
 770         p->netpoll = netpoll;
 771 out:
 772         return err;
 773 }
 774
 775 static void dsa_slave_netpoll_cleanup(struct net_device *dev)
 776 {
 777         struct dsa_slave_priv *p = netdev_priv(dev);
 778         struct netpoll *netpoll = p->netpoll;
 779
 780         if (!netpoll)
 781                 return;
 782
 783         p->netpoll = NULL;
 784
 785         __netpoll_free_async(netpoll);
 786 }
 787
 788 static void dsa_slave_poll_controller(struct net_device *dev)
 789 {
 790 }
 791 #endif
 792
 793 static const struct ethtool_ops dsa_slave_ethtool_ops = {
 794         .get_settings           = dsa_slave_get_settings,
 795         .set_settings           = dsa_slave_set_settings,
 796         .get_drvinfo            = dsa_slave_get_drvinfo,
 797         .get_regs_len           = dsa_slave_get_regs_len,
 798         .get_regs               = dsa_slave_get_regs,
 799         .nway_reset             = dsa_slave_nway_reset,
 800         .get_link               = dsa_slave_get_link,
 801         .get_eeprom_len         = dsa_slave_get_eeprom_len,
 802         .get_eeprom             = dsa_slave_get_eeprom,
 803         .set_eeprom             = dsa_slave_set_eeprom,
 804         .get_strings            = dsa_slave_get_strings,
 805         .get_ethtool_stats      = dsa_slave_get_ethtool_stats,
 806         .get_sset_count         = dsa_slave_get_sset_count,
 807         .set_wol                = dsa_slave_set_wol,
 808         .get_wol                = dsa_slave_get_wol,
 809         .set_eee                = dsa_slave_set_eee,
 810         .get_eee                = dsa_slave_get_eee,
 811 };
 812
 813 static const struct net_device_ops dsa_slave_netdev_ops = {
 814         .ndo_open               = dsa_slave_open,
 815         .ndo_stop               = dsa_slave_close,
 816         .ndo_start_xmit         = dsa_slave_xmit,
 817         .ndo_change_rx_flags    = dsa_slave_change_rx_flags,
 818         .ndo_set_rx_mode        = dsa_slave_set_rx_mode,
 819         .ndo_set_mac_address    = dsa_slave_set_mac_address,
 820         .ndo_fdb_add            = switchdev_port_fdb_add,
 821         .ndo_fdb_del            = switchdev_port_fdb_del,
 822         .ndo_fdb_dump           = switchdev_port_fdb_dump,
 823         .ndo_do_ioctl           = dsa_slave_ioctl,
 824         .ndo_get_iflink         = dsa_slave_get_iflink,
 825 #ifdef CONFIG_NET_POLL_CONTROLLER
 826         .ndo_netpoll_setup      = dsa_slave_netpoll_setup,
 827         .ndo_netpoll_cleanup    = dsa_slave_netpoll_cleanup,
 828         .ndo_poll_controller    = dsa_slave_poll_controller,
 829 #endif
 830         .ndo_bridge_getlink     = switchdev_port_bridge_getlink,
 831         .ndo_bridge_setlink     = switchdev_port_bridge_setlink,
 832         .ndo_bridge_dellink     = switchdev_port_bridge_dellink,
 833 };
 834
 835 static const struct switchdev_ops dsa_slave_switchdev_ops = {
 836         .switchdev_port_attr_get        = dsa_slave_port_attr_get,
 837         .switchdev_port_attr_set        = dsa_slave_port_attr_set,
 838         .switchdev_port_obj_add         = dsa_slave_port_obj_add,
 839         .switchdev_port_obj_del         = dsa_slave_port_obj_del,
 840         .switchdev_port_obj_dump        = dsa_slave_port_obj_dump,
 841 };
 842
 843 static struct device_type dsa_type = {
 844         .name   = "dsa",
 845 };
 846
 847 static void dsa_slave_adjust_link(struct net_device *dev)
 848 {
 849         struct dsa_slave_priv *p = netdev_priv(dev);
 850         struct dsa_switch *ds = p->parent;
 851         unsigned int status_changed = 0;
 852
 853         if (p->old_link != p->phy->link) {
 854                 status_changed = 1;
 855                 p->old_link = p->phy->link;
 856         }
 857
 858         if (p->old_duplex != p->phy->duplex) {
 859                 status_changed = 1;
 860                 p->old_duplex = p->phy->duplex;
 861         }
 862
 863         if (p->old_pause != p->phy->pause) {
 864                 status_changed = 1;
 865                 p->old_pause = p->phy->pause;
 866         }
 867
 868         if (ds->drv->adjust_link && status_changed)
 869                 ds->drv->adjust_link(ds, p->port, p->phy);
 870
 871         if (status_changed)
 872                 phy_print_status(p->phy);
 873 }
 874
 875 static int dsa_slave_fixed_link_update(struct net_device *dev,
 876                                        struct fixed_phy_status *status)
 877 {
 878         struct dsa_slave_priv *p = netdev_priv(dev);
 879         struct dsa_switch *ds = p->parent;
 880
 881         if (ds->drv->fixed_link_update)
 882                 ds->drv->fixed_link_update(ds, p->port, status);
 883
 884         return 0;
 885 }
 886
 887 /* slave device setup *******************************************************/
 888 static int dsa_slave_phy_connect(struct dsa_slave_priv *p,
 889                                  struct net_device *slave_dev,
 890                                  int addr)
 891 {
 892         struct dsa_switch *ds = p->parent;
 893
 894         p->phy = mdiobus_get_phy(ds->slave_mii_bus, addr);
 895         if (!p->phy) {
 896                 netdev_err(slave_dev, "no phy at %d\n", addr);
 897                 return -ENODEV;
 898         }
 899
 900         /* Use already configured phy mode */
 901         if (p->phy_interface == PHY_INTERFACE_MODE_NA)
 902                 p->phy_interface = p->phy->interface;
 903         phy_connect_direct(slave_dev, p->phy, dsa_slave_adjust_link,
 904                            p->phy_interface);
 905
 906         return 0;
 907 }
 908
 909 static int dsa_slave_phy_setup(struct dsa_slave_priv *p,
 910                                 struct net_device *slave_dev)
 911 {
 912         struct dsa_switch *ds = p->parent;
 913         struct dsa_chip_data *cd = ds->pd;
 914         struct device_node *phy_dn, *port_dn;
 915         bool phy_is_fixed = false;
 916         u32 phy_flags = 0;
 917         int mode, ret;
 918
 919         port_dn = cd->port_dn[p->port];
 920         mode = of_get_phy_mode(port_dn);
 921         if (mode < 0)
 922                 mode = PHY_INTERFACE_MODE_NA;
 923         p->phy_interface = mode;
 924
 925         phy_dn = of_parse_phandle(port_dn, "phy-handle", 0);
 926         if (of_phy_is_fixed_link(port_dn)) {
 927                 /* In the case of a fixed PHY, the DT node associated
 928                  * to the fixed PHY is the Port DT node
 929                  */
 930                 ret = of_phy_register_fixed_link(port_dn);
 931                 if (ret) {
 932                         netdev_err(slave_dev, "failed to register fixed PHY: %d\n", ret);
 933                         return ret;
 934                 }
 935                 phy_is_fixed = true;
 936                 phy_dn = port_dn;
 937         }
 938
 939         if (ds->drv->get_phy_flags)
 940                 phy_flags = ds->drv->get_phy_flags(ds, p->port);
 941
 942         if (phy_dn) {
 943                 int phy_id = of_mdio_parse_addr(&slave_dev->dev, phy_dn);
 944
 945                 /* If this PHY address is part of phys_mii_mask, which means
 946                  * that we need to divert reads and writes to/from it, then we
 947                  * want to bind this device using the slave MII bus created by
 948                  * DSA to make that happen.
 949                  */
 950                 if (!phy_is_fixed && phy_id >= 0 &&
 951                     (ds->phys_mii_mask & (1 << phy_id))) {
 952                         ret = dsa_slave_phy_connect(p, slave_dev, phy_id);
 953                         if (ret) {
 954                                 netdev_err(slave_dev, "failed to connect to phy%d: %d\n", phy_id, ret);
 955                                 return ret;
 956                         }
 957                 } else {
 958                         p->phy = of_phy_connect(slave_dev, phy_dn,
 959                                                 dsa_slave_adjust_link,
 960                                                 phy_flags,
 961                                                 p->phy_interface);
 962                 }
 963         }
 964
 965         if (p->phy && phy_is_fixed)
 966                 fixed_phy_set_link_update(p->phy, dsa_slave_fixed_link_update);
 967
 968         /* We could not connect to a designated PHY, so use the switch internal
 969          * MDIO bus instead
 970          */
 971         if (!p->phy) {
 972                 ret = dsa_slave_phy_connect(p, slave_dev, p->port);
 973                 if (ret) {
 974                         netdev_err(slave_dev, "failed to connect to port %d: %d\n", p->port, ret);
 975                         return ret;
 976                 }
 977         }
 978
 979         phy_attached_info(p->phy);
 980
 981         return 0;
 982 }
 983
 984 static struct lock_class_key dsa_slave_netdev_xmit_lock_key;
 985 static void dsa_slave_set_lockdep_class_one(struct net_device *dev,
 986                                             struct netdev_queue *txq,
 987                                             void *_unused)
 988 {
 989         lockdep_set_class(&txq->_xmit_lock,
 990                           &dsa_slave_netdev_xmit_lock_key);
 991 }
 992
 993 int dsa_slave_suspend(struct net_device *slave_dev)
 994 {
 995         struct dsa_slave_priv *p = netdev_priv(slave_dev);
 996
 997         if (p->phy) {
 998                 phy_stop(p->phy);
 999                 p->old_pause = -1;
1000                 p->old_link = -1;
1001                 p->old_duplex = -1;
1002                 phy_suspend(p->phy);
1003         }
1004
1005         return 0;
1006 }
1007
1008 int dsa_slave_resume(struct net_device *slave_dev)
1009 {
1010         struct dsa_slave_priv *p = netdev_priv(slave_dev);
1011
1012         netif_device_attach(slave_dev);
1013
1014         if (p->phy) {
1015                 phy_resume(p->phy);
1016                 phy_start(p->phy);
1017         }
1018
1019         return 0;
1020 }
1021
1022 int dsa_slave_create(struct dsa_switch *ds, struct device *parent,
1023                      int port, char *name)
1024 {
1025         struct net_device *master = ds->dst->master_netdev;
1026         struct net_device *slave_dev;
1027         struct dsa_slave_priv *p;
1028         int ret;
1029
1030         slave_dev = alloc_netdev(sizeof(struct dsa_slave_priv), name,
1031                                  NET_NAME_UNKNOWN, ether_setup);
1032         if (slave_dev == NULL)
1033                 return -ENOMEM;
1034
1035         slave_dev->features = master->vlan_features;
1036         slave_dev->ethtool_ops = &dsa_slave_ethtool_ops;
1037         eth_hw_addr_inherit(slave_dev, master);
1038         slave_dev->priv_flags |= IFF_NO_QUEUE;
1039         slave_dev->netdev_ops = &dsa_slave_netdev_ops;
1040         slave_dev->switchdev_ops = &dsa_slave_switchdev_ops;
1041         SET_NETDEV_DEVTYPE(slave_dev, &dsa_type);
1042
1043         netdev_for_each_tx_queue(slave_dev, dsa_slave_set_lockdep_class_one,
1044                                  NULL);
1045
1046         SET_NETDEV_DEV(slave_dev, parent);
1047         slave_dev->dev.of_node = ds->pd->port_dn[port];
1048         slave_dev->vlan_features = master->vlan_features;
1049
1050         p = netdev_priv(slave_dev);
1051         p->dev = slave_dev;
1052         p->parent = ds;
1053         p->port = port;
1054
1055         switch (ds->dst->tag_protocol) {
1056 #ifdef CONFIG_NET_DSA_TAG_DSA
1057         case DSA_TAG_PROTO_DSA:
1058                 p->xmit = dsa_netdev_ops.xmit;
1059                 break;
1060 #endif
1061 #ifdef CONFIG_NET_DSA_TAG_EDSA
1062         case DSA_TAG_PROTO_EDSA:
1063                 p->xmit = edsa_netdev_ops.xmit;
1064                 break;
1065 #endif
1066 #ifdef CONFIG_NET_DSA_TAG_TRAILER
1067         case DSA_TAG_PROTO_TRAILER:
1068                 p->xmit = trailer_netdev_ops.xmit;
1069                 break;
1070 #endif
1071 #ifdef CONFIG_NET_DSA_TAG_BRCM
1072         case DSA_TAG_PROTO_BRCM:
1073                 p->xmit = brcm_netdev_ops.xmit;
1074                 break;
1075 #endif
1076         default:
1077                 p->xmit = dsa_slave_notag_xmit;
1078                 break;
1079         }
1080
1081         p->old_pause = -1;
1082         p->old_link = -1;
1083         p->old_duplex = -1;
1084
1085         ds->ports[port] = slave_dev;
1086         ret = register_netdev(slave_dev);
1087         if (ret) {
1088                 netdev_err(master, "error %d registering interface %s\n",
1089                            ret, slave_dev->name);
1090                 ds->ports[port] = NULL;
1091                 free_netdev(slave_dev);
1092                 return ret;
1093         }
1094
1095         netif_carrier_off(slave_dev);
1096
1097         ret = dsa_slave_phy_setup(p, slave_dev);
1098         if (ret) {
1099                 netdev_err(master, "error %d setting up slave phy\n", ret);
1100                 unregister_netdev(slave_dev);
1101                 free_netdev(slave_dev);
1102                 return ret;
1103         }
1104
1105         return 0;
1106 }
1107
1108 void dsa_slave_destroy(struct net_device *slave_dev)
1109 {
1110         struct dsa_slave_priv *p = netdev_priv(slave_dev);
1111
1112         netif_carrier_off(slave_dev);
1113         if (p->phy)
1114                 phy_disconnect(p->phy);
1115         unregister_netdev(slave_dev);
1116         free_netdev(slave_dev);
1117 }
1118
1119 static bool dsa_slave_dev_check(struct net_device *dev)
1120 {
1121         return dev->netdev_ops == &dsa_slave_netdev_ops;
1122 }
1123
1124 static int dsa_slave_master_changed(struct net_device *dev)
1125 {
1126         struct net_device *master = netdev_master_upper_dev_get(dev);
1127         struct dsa_slave_priv *p = netdev_priv(dev);
1128         int err = 0;
1129
1130         if (master && master->rtnl_link_ops &&
1131             !strcmp(master->rtnl_link_ops->kind, "bridge"))
1132                 err = dsa_slave_bridge_port_join(dev, master);
1133         else if (dsa_port_is_bridged(p))
1134                 err = dsa_slave_bridge_port_leave(dev);
1135
1136         return err;
1137 }
1138
1139 int dsa_slave_netdevice_event(struct notifier_block *unused,
1140                               unsigned long event, void *ptr)
1141 {
1142         struct net_device *dev;
1143         int err = 0;
1144
1145         switch (event) {
1146         case NETDEV_CHANGEUPPER:
1147                 dev = netdev_notifier_info_to_dev(ptr);
1148                 if (!dsa_slave_dev_check(dev))
1149                         goto out;
1150
1151                 err = dsa_slave_master_changed(dev);
1152                 if (err && err != -EOPNOTSUPP)
1153                         netdev_warn(dev, "failed to reflect master change\n");
1154
1155                 break;
1156         }
1157
1158 out:
1159         return NOTIFY_DONE;
1160 }