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/phy.h> 14 #include <linux/phy_fixed.h> 15 #include <linux/of_net.h> 16 #include <linux/of_mdio.h> 17 #include "dsa_priv.h" 18 19 /* slave mii_bus handling ***************************************************/ 20 static int dsa_slave_phy_read(struct mii_bus *bus, int addr, int reg) 21 { 22 struct dsa_switch *ds = bus->priv; 23 24 if (ds->phys_mii_mask & (1 << addr)) 25 return ds->drv->phy_read(ds, addr, reg); 26 27 return 0xffff; 28 } 29 30 static int dsa_slave_phy_write(struct mii_bus *bus, int addr, int reg, u16 val) 31 { 32 struct dsa_switch *ds = bus->priv; 33 34 if (ds->phys_mii_mask & (1 << addr)) 35 return ds->drv->phy_write(ds, addr, reg, val); 36 37 return 0; 38 } 39 40 void dsa_slave_mii_bus_init(struct dsa_switch *ds) 41 { 42 ds->slave_mii_bus->priv = (void *)ds; 43 ds->slave_mii_bus->name = "dsa slave smi"; 44 ds->slave_mii_bus->read = dsa_slave_phy_read; 45 ds->slave_mii_bus->write = dsa_slave_phy_write; 46 snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d:%.2x", 47 ds->index, ds->pd->sw_addr); 48 ds->slave_mii_bus->parent = ds->master_dev; 49 ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask; 50 } 51 52 53 /* slave device handling ****************************************************/ 54 static int dsa_slave_init(struct net_device *dev) 55 { 56 struct dsa_slave_priv *p = netdev_priv(dev); 57 58 dev->iflink = p->parent->dst->master_netdev->ifindex; 59 60 return 0; 61 } 62 63 static int dsa_slave_open(struct net_device *dev) 64 { 65 struct dsa_slave_priv *p = netdev_priv(dev); 66 struct net_device *master = p->parent->dst->master_netdev; 67 struct dsa_switch *ds = p->parent; 68 int err; 69 70 if (!(master->flags & IFF_UP)) 71 return -ENETDOWN; 72 73 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) { 74 err = dev_uc_add(master, dev->dev_addr); 75 if (err < 0) 76 goto out; 77 } 78 79 if (dev->flags & IFF_ALLMULTI) { 80 err = dev_set_allmulti(master, 1); 81 if (err < 0) 82 goto del_unicast; 83 } 84 if (dev->flags & IFF_PROMISC) { 85 err = dev_set_promiscuity(master, 1); 86 if (err < 0) 87 goto clear_allmulti; 88 } 89 90 if (ds->drv->port_enable) { 91 err = ds->drv->port_enable(ds, p->port, p->phy); 92 if (err) 93 goto clear_promisc; 94 } 95 96 if (p->phy) 97 phy_start(p->phy); 98 99 return 0; 100 101 clear_promisc: 102 if (dev->flags & IFF_PROMISC) 103 dev_set_promiscuity(master, 0); 104 clear_allmulti: 105 if (dev->flags & IFF_ALLMULTI) 106 dev_set_allmulti(master, -1); 107 del_unicast: 108 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) 109 dev_uc_del(master, dev->dev_addr); 110 out: 111 return err; 112 } 113 114 static int dsa_slave_close(struct net_device *dev) 115 { 116 struct dsa_slave_priv *p = netdev_priv(dev); 117 struct net_device *master = p->parent->dst->master_netdev; 118 struct dsa_switch *ds = p->parent; 119 120 if (p->phy) 121 phy_stop(p->phy); 122 123 dev_mc_unsync(master, dev); 124 dev_uc_unsync(master, dev); 125 if (dev->flags & IFF_ALLMULTI) 126 dev_set_allmulti(master, -1); 127 if (dev->flags & IFF_PROMISC) 128 dev_set_promiscuity(master, -1); 129 130 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) 131 dev_uc_del(master, dev->dev_addr); 132 133 if (ds->drv->port_disable) 134 ds->drv->port_disable(ds, p->port, p->phy); 135 136 return 0; 137 } 138 139 static void dsa_slave_change_rx_flags(struct net_device *dev, int change) 140 { 141 struct dsa_slave_priv *p = netdev_priv(dev); 142 struct net_device *master = p->parent->dst->master_netdev; 143 144 if (change & IFF_ALLMULTI) 145 dev_set_allmulti(master, dev->flags & IFF_ALLMULTI ? 1 : -1); 146 if (change & IFF_PROMISC) 147 dev_set_promiscuity(master, dev->flags & IFF_PROMISC ? 1 : -1); 148 } 149 150 static void dsa_slave_set_rx_mode(struct net_device *dev) 151 { 152 struct dsa_slave_priv *p = netdev_priv(dev); 153 struct net_device *master = p->parent->dst->master_netdev; 154 155 dev_mc_sync(master, dev); 156 dev_uc_sync(master, dev); 157 } 158 159 static int dsa_slave_set_mac_address(struct net_device *dev, void *a) 160 { 161 struct dsa_slave_priv *p = netdev_priv(dev); 162 struct net_device *master = p->parent->dst->master_netdev; 163 struct sockaddr *addr = a; 164 int err; 165 166 if (!is_valid_ether_addr(addr->sa_data)) 167 return -EADDRNOTAVAIL; 168 169 if (!(dev->flags & IFF_UP)) 170 goto out; 171 172 if (!ether_addr_equal(addr->sa_data, master->dev_addr)) { 173 err = dev_uc_add(master, addr->sa_data); 174 if (err < 0) 175 return err; 176 } 177 178 if (!ether_addr_equal(dev->dev_addr, master->dev_addr)) 179 dev_uc_del(master, dev->dev_addr); 180 181 out: 182 ether_addr_copy(dev->dev_addr, addr->sa_data); 183 184 return 0; 185 } 186 187 static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 188 { 189 struct dsa_slave_priv *p = netdev_priv(dev); 190 191 if (p->phy != NULL) 192 return phy_mii_ioctl(p->phy, ifr, cmd); 193 194 return -EOPNOTSUPP; 195 } 196 197 static netdev_tx_t dsa_slave_xmit(struct sk_buff *skb, struct net_device *dev) 198 { 199 struct dsa_slave_priv *p = netdev_priv(dev); 200 201 return p->xmit(skb, dev); 202 } 203 204 static netdev_tx_t dsa_slave_notag_xmit(struct sk_buff *skb, 205 struct net_device *dev) 206 { 207 struct dsa_slave_priv *p = netdev_priv(dev); 208 209 skb->dev = p->parent->dst->master_netdev; 210 dev_queue_xmit(skb); 211 212 return NETDEV_TX_OK; 213 } 214 215 216 /* ethtool operations *******************************************************/ 217 static int 218 dsa_slave_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 219 { 220 struct dsa_slave_priv *p = netdev_priv(dev); 221 int err; 222 223 err = -EOPNOTSUPP; 224 if (p->phy != NULL) { 225 err = phy_read_status(p->phy); 226 if (err == 0) 227 err = phy_ethtool_gset(p->phy, cmd); 228 } 229 230 return err; 231 } 232 233 static int 234 dsa_slave_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) 235 { 236 struct dsa_slave_priv *p = netdev_priv(dev); 237 238 if (p->phy != NULL) 239 return phy_ethtool_sset(p->phy, cmd); 240 241 return -EOPNOTSUPP; 242 } 243 244 static void dsa_slave_get_drvinfo(struct net_device *dev, 245 struct ethtool_drvinfo *drvinfo) 246 { 247 strlcpy(drvinfo->driver, "dsa", sizeof(drvinfo->driver)); 248 strlcpy(drvinfo->version, dsa_driver_version, sizeof(drvinfo->version)); 249 strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version)); 250 strlcpy(drvinfo->bus_info, "platform", sizeof(drvinfo->bus_info)); 251 } 252 253 static int dsa_slave_get_regs_len(struct net_device *dev) 254 { 255 struct dsa_slave_priv *p = netdev_priv(dev); 256 struct dsa_switch *ds = p->parent; 257 258 if (ds->drv->get_regs_len) 259 return ds->drv->get_regs_len(ds, p->port); 260 261 return -EOPNOTSUPP; 262 } 263 264 static void 265 dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p) 266 { 267 struct dsa_slave_priv *p = netdev_priv(dev); 268 struct dsa_switch *ds = p->parent; 269 270 if (ds->drv->get_regs) 271 ds->drv->get_regs(ds, p->port, regs, _p); 272 } 273 274 static int dsa_slave_nway_reset(struct net_device *dev) 275 { 276 struct dsa_slave_priv *p = netdev_priv(dev); 277 278 if (p->phy != NULL) 279 return genphy_restart_aneg(p->phy); 280 281 return -EOPNOTSUPP; 282 } 283 284 static u32 dsa_slave_get_link(struct net_device *dev) 285 { 286 struct dsa_slave_priv *p = netdev_priv(dev); 287 288 if (p->phy != NULL) { 289 genphy_update_link(p->phy); 290 return p->phy->link; 291 } 292 293 return -EOPNOTSUPP; 294 } 295 296 static int dsa_slave_get_eeprom_len(struct net_device *dev) 297 { 298 struct dsa_slave_priv *p = netdev_priv(dev); 299 struct dsa_switch *ds = p->parent; 300 301 if (ds->pd->eeprom_len) 302 return ds->pd->eeprom_len; 303 304 if (ds->drv->get_eeprom_len) 305 return ds->drv->get_eeprom_len(ds); 306 307 return 0; 308 } 309 310 static int dsa_slave_get_eeprom(struct net_device *dev, 311 struct ethtool_eeprom *eeprom, u8 *data) 312 { 313 struct dsa_slave_priv *p = netdev_priv(dev); 314 struct dsa_switch *ds = p->parent; 315 316 if (ds->drv->get_eeprom) 317 return ds->drv->get_eeprom(ds, eeprom, data); 318 319 return -EOPNOTSUPP; 320 } 321 322 static int dsa_slave_set_eeprom(struct net_device *dev, 323 struct ethtool_eeprom *eeprom, u8 *data) 324 { 325 struct dsa_slave_priv *p = netdev_priv(dev); 326 struct dsa_switch *ds = p->parent; 327 328 if (ds->drv->set_eeprom) 329 return ds->drv->set_eeprom(ds, eeprom, data); 330 331 return -EOPNOTSUPP; 332 } 333 334 static void dsa_slave_get_strings(struct net_device *dev, 335 uint32_t stringset, uint8_t *data) 336 { 337 struct dsa_slave_priv *p = netdev_priv(dev); 338 struct dsa_switch *ds = p->parent; 339 340 if (stringset == ETH_SS_STATS) { 341 int len = ETH_GSTRING_LEN; 342 343 strncpy(data, "tx_packets", len); 344 strncpy(data + len, "tx_bytes", len); 345 strncpy(data + 2 * len, "rx_packets", len); 346 strncpy(data + 3 * len, "rx_bytes", len); 347 if (ds->drv->get_strings != NULL) 348 ds->drv->get_strings(ds, p->port, data + 4 * len); 349 } 350 } 351 352 static void dsa_slave_get_ethtool_stats(struct net_device *dev, 353 struct ethtool_stats *stats, 354 uint64_t *data) 355 { 356 struct dsa_slave_priv *p = netdev_priv(dev); 357 struct dsa_switch *ds = p->parent; 358 359 data[0] = p->dev->stats.tx_packets; 360 data[1] = p->dev->stats.tx_bytes; 361 data[2] = p->dev->stats.rx_packets; 362 data[3] = p->dev->stats.rx_bytes; 363 if (ds->drv->get_ethtool_stats != NULL) 364 ds->drv->get_ethtool_stats(ds, p->port, data + 4); 365 } 366 367 static int dsa_slave_get_sset_count(struct net_device *dev, int sset) 368 { 369 struct dsa_slave_priv *p = netdev_priv(dev); 370 struct dsa_switch *ds = p->parent; 371 372 if (sset == ETH_SS_STATS) { 373 int count; 374 375 count = 4; 376 if (ds->drv->get_sset_count != NULL) 377 count += ds->drv->get_sset_count(ds); 378 379 return count; 380 } 381 382 return -EOPNOTSUPP; 383 } 384 385 static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w) 386 { 387 struct dsa_slave_priv *p = netdev_priv(dev); 388 struct dsa_switch *ds = p->parent; 389 390 if (ds->drv->get_wol) 391 ds->drv->get_wol(ds, p->port, w); 392 } 393 394 static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w) 395 { 396 struct dsa_slave_priv *p = netdev_priv(dev); 397 struct dsa_switch *ds = p->parent; 398 int ret = -EOPNOTSUPP; 399 400 if (ds->drv->set_wol) 401 ret = ds->drv->set_wol(ds, p->port, w); 402 403 return ret; 404 } 405 406 static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e) 407 { 408 struct dsa_slave_priv *p = netdev_priv(dev); 409 struct dsa_switch *ds = p->parent; 410 int ret; 411 412 if (!ds->drv->set_eee) 413 return -EOPNOTSUPP; 414 415 ret = ds->drv->set_eee(ds, p->port, p->phy, e); 416 if (ret) 417 return ret; 418 419 if (p->phy) 420 ret = phy_ethtool_set_eee(p->phy, e); 421 422 return ret; 423 } 424 425 static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e) 426 { 427 struct dsa_slave_priv *p = netdev_priv(dev); 428 struct dsa_switch *ds = p->parent; 429 int ret; 430 431 if (!ds->drv->get_eee) 432 return -EOPNOTSUPP; 433 434 ret = ds->drv->get_eee(ds, p->port, e); 435 if (ret) 436 return ret; 437 438 if (p->phy) 439 ret = phy_ethtool_get_eee(p->phy, e); 440 441 return ret; 442 } 443 444 static const struct ethtool_ops dsa_slave_ethtool_ops = { 445 .get_settings = dsa_slave_get_settings, 446 .set_settings = dsa_slave_set_settings, 447 .get_drvinfo = dsa_slave_get_drvinfo, 448 .get_regs_len = dsa_slave_get_regs_len, 449 .get_regs = dsa_slave_get_regs, 450 .nway_reset = dsa_slave_nway_reset, 451 .get_link = dsa_slave_get_link, 452 .get_eeprom_len = dsa_slave_get_eeprom_len, 453 .get_eeprom = dsa_slave_get_eeprom, 454 .set_eeprom = dsa_slave_set_eeprom, 455 .get_strings = dsa_slave_get_strings, 456 .get_ethtool_stats = dsa_slave_get_ethtool_stats, 457 .get_sset_count = dsa_slave_get_sset_count, 458 .set_wol = dsa_slave_set_wol, 459 .get_wol = dsa_slave_get_wol, 460 .set_eee = dsa_slave_set_eee, 461 .get_eee = dsa_slave_get_eee, 462 }; 463 464 static const struct net_device_ops dsa_slave_netdev_ops = { 465 .ndo_init = dsa_slave_init, 466 .ndo_open = dsa_slave_open, 467 .ndo_stop = dsa_slave_close, 468 .ndo_start_xmit = dsa_slave_xmit, 469 .ndo_change_rx_flags = dsa_slave_change_rx_flags, 470 .ndo_set_rx_mode = dsa_slave_set_rx_mode, 471 .ndo_set_mac_address = dsa_slave_set_mac_address, 472 .ndo_do_ioctl = dsa_slave_ioctl, 473 }; 474 475 static void dsa_slave_adjust_link(struct net_device *dev) 476 { 477 struct dsa_slave_priv *p = netdev_priv(dev); 478 struct dsa_switch *ds = p->parent; 479 unsigned int status_changed = 0; 480 481 if (p->old_link != p->phy->link) { 482 status_changed = 1; 483 p->old_link = p->phy->link; 484 } 485 486 if (p->old_duplex != p->phy->duplex) { 487 status_changed = 1; 488 p->old_duplex = p->phy->duplex; 489 } 490 491 if (p->old_pause != p->phy->pause) { 492 status_changed = 1; 493 p->old_pause = p->phy->pause; 494 } 495 496 if (ds->drv->adjust_link && status_changed) 497 ds->drv->adjust_link(ds, p->port, p->phy); 498 499 if (status_changed) 500 phy_print_status(p->phy); 501 } 502 503 static int dsa_slave_fixed_link_update(struct net_device *dev, 504 struct fixed_phy_status *status) 505 { 506 struct dsa_slave_priv *p = netdev_priv(dev); 507 struct dsa_switch *ds = p->parent; 508 509 if (ds->drv->fixed_link_update) 510 ds->drv->fixed_link_update(ds, p->port, status); 511 512 return 0; 513 } 514 515 /* slave device setup *******************************************************/ 516 static int dsa_slave_phy_setup(struct dsa_slave_priv *p, 517 struct net_device *slave_dev) 518 { 519 struct dsa_switch *ds = p->parent; 520 struct dsa_chip_data *cd = ds->pd; 521 struct device_node *phy_dn, *port_dn; 522 bool phy_is_fixed = false; 523 u32 phy_flags = 0; 524 int mode, ret; 525 526 port_dn = cd->port_dn[p->port]; 527 mode = of_get_phy_mode(port_dn); 528 if (mode < 0) 529 mode = PHY_INTERFACE_MODE_NA; 530 p->phy_interface = mode; 531 532 phy_dn = of_parse_phandle(port_dn, "phy-handle", 0); 533 if (of_phy_is_fixed_link(port_dn)) { 534 /* In the case of a fixed PHY, the DT node associated 535 * to the fixed PHY is the Port DT node 536 */ 537 ret = of_phy_register_fixed_link(port_dn); 538 if (ret) { 539 netdev_err(slave_dev, "failed to register fixed PHY\n"); 540 return ret; 541 } 542 phy_is_fixed = true; 543 phy_dn = port_dn; 544 } 545 546 if (ds->drv->get_phy_flags) 547 phy_flags = ds->drv->get_phy_flags(ds, p->port); 548 549 if (phy_dn) 550 p->phy = of_phy_connect(slave_dev, phy_dn, 551 dsa_slave_adjust_link, phy_flags, 552 p->phy_interface); 553 554 if (p->phy && phy_is_fixed) 555 fixed_phy_set_link_update(p->phy, dsa_slave_fixed_link_update); 556 557 /* We could not connect to a designated PHY, so use the switch internal 558 * MDIO bus instead 559 */ 560 if (!p->phy) { 561 p->phy = ds->slave_mii_bus->phy_map[p->port]; 562 if (!p->phy) 563 return -ENODEV; 564 565 /* Use already configured phy mode */ 566 p->phy_interface = p->phy->interface; 567 phy_connect_direct(slave_dev, p->phy, dsa_slave_adjust_link, 568 p->phy_interface); 569 } else { 570 netdev_info(slave_dev, "attached PHY at address %d [%s]\n", 571 p->phy->addr, p->phy->drv->name); 572 } 573 574 return 0; 575 } 576 577 int dsa_slave_suspend(struct net_device *slave_dev) 578 { 579 struct dsa_slave_priv *p = netdev_priv(slave_dev); 580 581 netif_device_detach(slave_dev); 582 583 if (p->phy) { 584 phy_stop(p->phy); 585 p->old_pause = -1; 586 p->old_link = -1; 587 p->old_duplex = -1; 588 phy_suspend(p->phy); 589 } 590 591 return 0; 592 } 593 594 int dsa_slave_resume(struct net_device *slave_dev) 595 { 596 struct dsa_slave_priv *p = netdev_priv(slave_dev); 597 598 netif_device_attach(slave_dev); 599 600 if (p->phy) { 601 phy_resume(p->phy); 602 phy_start(p->phy); 603 } 604 605 return 0; 606 } 607 608 struct net_device * 609 dsa_slave_create(struct dsa_switch *ds, struct device *parent, 610 int port, char *name) 611 { 612 struct net_device *master = ds->dst->master_netdev; 613 struct net_device *slave_dev; 614 struct dsa_slave_priv *p; 615 int ret; 616 617 slave_dev = alloc_netdev(sizeof(struct dsa_slave_priv), name, 618 NET_NAME_UNKNOWN, ether_setup); 619 if (slave_dev == NULL) 620 return slave_dev; 621 622 slave_dev->features = master->vlan_features; 623 slave_dev->ethtool_ops = &dsa_slave_ethtool_ops; 624 eth_hw_addr_inherit(slave_dev, master); 625 slave_dev->tx_queue_len = 0; 626 slave_dev->netdev_ops = &dsa_slave_netdev_ops; 627 628 SET_NETDEV_DEV(slave_dev, parent); 629 slave_dev->dev.of_node = ds->pd->port_dn[port]; 630 slave_dev->vlan_features = master->vlan_features; 631 632 p = netdev_priv(slave_dev); 633 p->dev = slave_dev; 634 p->parent = ds; 635 p->port = port; 636 637 switch (ds->dst->tag_protocol) { 638 #ifdef CONFIG_NET_DSA_TAG_DSA 639 case DSA_TAG_PROTO_DSA: 640 p->xmit = dsa_netdev_ops.xmit; 641 break; 642 #endif 643 #ifdef CONFIG_NET_DSA_TAG_EDSA 644 case DSA_TAG_PROTO_EDSA: 645 p->xmit = edsa_netdev_ops.xmit; 646 break; 647 #endif 648 #ifdef CONFIG_NET_DSA_TAG_TRAILER 649 case DSA_TAG_PROTO_TRAILER: 650 p->xmit = trailer_netdev_ops.xmit; 651 break; 652 #endif 653 #ifdef CONFIG_NET_DSA_TAG_BRCM 654 case DSA_TAG_PROTO_BRCM: 655 p->xmit = brcm_netdev_ops.xmit; 656 break; 657 #endif 658 default: 659 p->xmit = dsa_slave_notag_xmit; 660 break; 661 } 662 663 p->old_pause = -1; 664 p->old_link = -1; 665 p->old_duplex = -1; 666 667 ret = dsa_slave_phy_setup(p, slave_dev); 668 if (ret) { 669 free_netdev(slave_dev); 670 return NULL; 671 } 672 673 ret = register_netdev(slave_dev); 674 if (ret) { 675 netdev_err(master, "error %d registering interface %s\n", 676 ret, slave_dev->name); 677 phy_disconnect(p->phy); 678 free_netdev(slave_dev); 679 return NULL; 680 } 681 682 netif_carrier_off(slave_dev); 683 684 return slave_dev; 685 } 686