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