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