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