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