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