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