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