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