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