1 /* 2 * net/dsa/dsa.c - Hardware switch handling 3 * Copyright (c) 2008-2009 Marvell Semiconductor 4 * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 */ 11 12 #include <linux/device.h> 13 #include <linux/list.h> 14 #include <linux/platform_device.h> 15 #include <linux/slab.h> 16 #include <linux/module.h> 17 #include <linux/of.h> 18 #include <linux/of_mdio.h> 19 #include <linux/of_platform.h> 20 #include <linux/of_net.h> 21 #include <linux/of_gpio.h> 22 #include <linux/netdevice.h> 23 #include <linux/sysfs.h> 24 #include <linux/phy_fixed.h> 25 #include <linux/gpio/consumer.h> 26 #include <net/dsa.h> 27 #include "dsa_priv.h" 28 29 static struct sk_buff *dsa_slave_notag_xmit(struct sk_buff *skb, 30 struct net_device *dev) 31 { 32 /* Just return the original SKB */ 33 return skb; 34 } 35 36 static const struct dsa_device_ops none_ops = { 37 .xmit = dsa_slave_notag_xmit, 38 .rcv = NULL, 39 }; 40 41 const struct dsa_device_ops *dsa_device_ops[DSA_TAG_LAST] = { 42 #ifdef CONFIG_NET_DSA_TAG_DSA 43 [DSA_TAG_PROTO_DSA] = &dsa_netdev_ops, 44 #endif 45 #ifdef CONFIG_NET_DSA_TAG_EDSA 46 [DSA_TAG_PROTO_EDSA] = &edsa_netdev_ops, 47 #endif 48 #ifdef CONFIG_NET_DSA_TAG_TRAILER 49 [DSA_TAG_PROTO_TRAILER] = &trailer_netdev_ops, 50 #endif 51 #ifdef CONFIG_NET_DSA_TAG_BRCM 52 [DSA_TAG_PROTO_BRCM] = &brcm_netdev_ops, 53 #endif 54 #ifdef CONFIG_NET_DSA_TAG_QCA 55 [DSA_TAG_PROTO_QCA] = &qca_netdev_ops, 56 #endif 57 [DSA_TAG_PROTO_NONE] = &none_ops, 58 }; 59 60 /* switch driver registration ***********************************************/ 61 static DEFINE_MUTEX(dsa_switch_drivers_mutex); 62 static LIST_HEAD(dsa_switch_drivers); 63 64 void register_switch_driver(struct dsa_switch_driver *drv) 65 { 66 mutex_lock(&dsa_switch_drivers_mutex); 67 list_add_tail(&drv->list, &dsa_switch_drivers); 68 mutex_unlock(&dsa_switch_drivers_mutex); 69 } 70 EXPORT_SYMBOL_GPL(register_switch_driver); 71 72 void unregister_switch_driver(struct dsa_switch_driver *drv) 73 { 74 mutex_lock(&dsa_switch_drivers_mutex); 75 list_del_init(&drv->list); 76 mutex_unlock(&dsa_switch_drivers_mutex); 77 } 78 EXPORT_SYMBOL_GPL(unregister_switch_driver); 79 80 static const struct dsa_switch_ops * 81 dsa_switch_probe(struct device *parent, struct device *host_dev, int sw_addr, 82 const char **_name, void **priv) 83 { 84 const struct dsa_switch_ops *ret; 85 struct list_head *list; 86 const char *name; 87 88 ret = NULL; 89 name = NULL; 90 91 mutex_lock(&dsa_switch_drivers_mutex); 92 list_for_each(list, &dsa_switch_drivers) { 93 const struct dsa_switch_ops *ops; 94 struct dsa_switch_driver *drv; 95 96 drv = list_entry(list, struct dsa_switch_driver, list); 97 ops = drv->ops; 98 99 name = ops->probe(parent, host_dev, sw_addr, priv); 100 if (name != NULL) { 101 ret = ops; 102 break; 103 } 104 } 105 mutex_unlock(&dsa_switch_drivers_mutex); 106 107 *_name = name; 108 109 return ret; 110 } 111 112 /* basic switch operations **************************************************/ 113 int dsa_cpu_dsa_setup(struct dsa_switch *ds, struct device *dev, 114 struct dsa_port *dport, int port) 115 { 116 struct device_node *port_dn = dport->dn; 117 struct phy_device *phydev; 118 int ret, mode; 119 120 if (of_phy_is_fixed_link(port_dn)) { 121 ret = of_phy_register_fixed_link(port_dn); 122 if (ret) { 123 dev_err(dev, "failed to register fixed PHY\n"); 124 return ret; 125 } 126 phydev = of_phy_find_device(port_dn); 127 128 mode = of_get_phy_mode(port_dn); 129 if (mode < 0) 130 mode = PHY_INTERFACE_MODE_NA; 131 phydev->interface = mode; 132 133 genphy_config_init(phydev); 134 genphy_read_status(phydev); 135 if (ds->ops->adjust_link) 136 ds->ops->adjust_link(ds, port, phydev); 137 138 put_device(&phydev->mdio.dev); 139 } 140 141 return 0; 142 } 143 144 static int dsa_cpu_dsa_setups(struct dsa_switch *ds, struct device *dev) 145 { 146 struct dsa_port *dport; 147 int ret, port; 148 149 for (port = 0; port < ds->num_ports; port++) { 150 if (!(dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))) 151 continue; 152 153 dport = &ds->ports[port]; 154 ret = dsa_cpu_dsa_setup(ds, dev, dport, port); 155 if (ret) 156 return ret; 157 } 158 return 0; 159 } 160 161 const struct dsa_device_ops *dsa_resolve_tag_protocol(int tag_protocol) 162 { 163 const struct dsa_device_ops *ops; 164 165 if (tag_protocol >= DSA_TAG_LAST) 166 return ERR_PTR(-EINVAL); 167 ops = dsa_device_ops[tag_protocol]; 168 169 if (!ops) 170 return ERR_PTR(-ENOPROTOOPT); 171 172 return ops; 173 } 174 175 int dsa_cpu_port_ethtool_setup(struct dsa_switch *ds) 176 { 177 struct net_device *master; 178 struct ethtool_ops *cpu_ops; 179 180 master = ds->dst->master_netdev; 181 if (ds->master_netdev) 182 master = ds->master_netdev; 183 184 cpu_ops = devm_kzalloc(ds->dev, sizeof(*cpu_ops), GFP_KERNEL); 185 if (!cpu_ops) 186 return -ENOMEM; 187 188 memcpy(&ds->dst->master_ethtool_ops, master->ethtool_ops, 189 sizeof(struct ethtool_ops)); 190 ds->dst->master_orig_ethtool_ops = master->ethtool_ops; 191 memcpy(cpu_ops, &ds->dst->master_ethtool_ops, 192 sizeof(struct ethtool_ops)); 193 dsa_cpu_port_ethtool_init(cpu_ops); 194 master->ethtool_ops = cpu_ops; 195 196 return 0; 197 } 198 199 void dsa_cpu_port_ethtool_restore(struct dsa_switch *ds) 200 { 201 struct net_device *master; 202 203 master = ds->dst->master_netdev; 204 if (ds->master_netdev) 205 master = ds->master_netdev; 206 207 master->ethtool_ops = ds->dst->master_orig_ethtool_ops; 208 } 209 210 static int dsa_switch_setup_one(struct dsa_switch *ds, struct device *parent) 211 { 212 const struct dsa_switch_ops *ops = ds->ops; 213 struct dsa_switch_tree *dst = ds->dst; 214 struct dsa_chip_data *cd = ds->cd; 215 bool valid_name_found = false; 216 int index = ds->index; 217 int i, ret; 218 219 /* 220 * Validate supplied switch configuration. 221 */ 222 for (i = 0; i < ds->num_ports; i++) { 223 char *name; 224 225 name = cd->port_names[i]; 226 if (name == NULL) 227 continue; 228 229 if (!strcmp(name, "cpu")) { 230 if (dst->cpu_switch) { 231 netdev_err(dst->master_netdev, 232 "multiple cpu ports?!\n"); 233 return -EINVAL; 234 } 235 dst->cpu_switch = ds; 236 dst->cpu_port = i; 237 ds->cpu_port_mask |= 1 << i; 238 } else if (!strcmp(name, "dsa")) { 239 ds->dsa_port_mask |= 1 << i; 240 } else { 241 ds->enabled_port_mask |= 1 << i; 242 } 243 valid_name_found = true; 244 } 245 246 if (!valid_name_found && i == ds->num_ports) 247 return -EINVAL; 248 249 /* Make the built-in MII bus mask match the number of ports, 250 * switch drivers can override this later 251 */ 252 ds->phys_mii_mask = ds->enabled_port_mask; 253 254 /* 255 * If the CPU connects to this switch, set the switch tree 256 * tagging protocol to the preferred tagging format of this 257 * switch. 258 */ 259 if (dst->cpu_switch == ds) { 260 enum dsa_tag_protocol tag_protocol; 261 262 tag_protocol = ops->get_tag_protocol(ds); 263 dst->tag_ops = dsa_resolve_tag_protocol(tag_protocol); 264 if (IS_ERR(dst->tag_ops)) 265 return PTR_ERR(dst->tag_ops); 266 267 dst->rcv = dst->tag_ops->rcv; 268 } 269 270 memcpy(ds->rtable, cd->rtable, sizeof(ds->rtable)); 271 272 /* 273 * Do basic register setup. 274 */ 275 ret = ops->setup(ds); 276 if (ret < 0) 277 return ret; 278 279 ret = dsa_switch_register_notifier(ds); 280 if (ret) 281 return ret; 282 283 if (ops->set_addr) { 284 ret = ops->set_addr(ds, dst->master_netdev->dev_addr); 285 if (ret < 0) 286 return ret; 287 } 288 289 if (!ds->slave_mii_bus && ops->phy_read) { 290 ds->slave_mii_bus = devm_mdiobus_alloc(parent); 291 if (!ds->slave_mii_bus) 292 return -ENOMEM; 293 dsa_slave_mii_bus_init(ds); 294 295 ret = mdiobus_register(ds->slave_mii_bus); 296 if (ret < 0) 297 return ret; 298 } 299 300 /* 301 * Create network devices for physical switch ports. 302 */ 303 for (i = 0; i < ds->num_ports; i++) { 304 ds->ports[i].dn = cd->port_dn[i]; 305 306 if (!(ds->enabled_port_mask & (1 << i))) 307 continue; 308 309 ret = dsa_slave_create(ds, parent, i, cd->port_names[i]); 310 if (ret < 0) 311 netdev_err(dst->master_netdev, "[%d]: can't create dsa slave device for port %d(%s): %d\n", 312 index, i, cd->port_names[i], ret); 313 } 314 315 /* Perform configuration of the CPU and DSA ports */ 316 ret = dsa_cpu_dsa_setups(ds, parent); 317 if (ret < 0) 318 netdev_err(dst->master_netdev, "[%d] : can't configure CPU and DSA ports\n", 319 index); 320 321 ret = dsa_cpu_port_ethtool_setup(ds); 322 if (ret) 323 return ret; 324 325 return 0; 326 } 327 328 static struct dsa_switch * 329 dsa_switch_setup(struct dsa_switch_tree *dst, int index, 330 struct device *parent, struct device *host_dev) 331 { 332 struct dsa_chip_data *cd = dst->pd->chip + index; 333 const struct dsa_switch_ops *ops; 334 struct dsa_switch *ds; 335 int ret; 336 const char *name; 337 void *priv; 338 339 /* 340 * Probe for switch model. 341 */ 342 ops = dsa_switch_probe(parent, host_dev, cd->sw_addr, &name, &priv); 343 if (!ops) { 344 netdev_err(dst->master_netdev, "[%d]: could not detect attached switch\n", 345 index); 346 return ERR_PTR(-EINVAL); 347 } 348 netdev_info(dst->master_netdev, "[%d]: detected a %s switch\n", 349 index, name); 350 351 352 /* 353 * Allocate and initialise switch state. 354 */ 355 ds = dsa_switch_alloc(parent, DSA_MAX_PORTS); 356 if (!ds) 357 return ERR_PTR(-ENOMEM); 358 359 ds->dst = dst; 360 ds->index = index; 361 ds->cd = cd; 362 ds->ops = ops; 363 ds->priv = priv; 364 365 ret = dsa_switch_setup_one(ds, parent); 366 if (ret) 367 return ERR_PTR(ret); 368 369 return ds; 370 } 371 372 void dsa_cpu_dsa_destroy(struct dsa_port *port) 373 { 374 struct device_node *port_dn = port->dn; 375 376 if (of_phy_is_fixed_link(port_dn)) 377 of_phy_deregister_fixed_link(port_dn); 378 } 379 380 static void dsa_switch_destroy(struct dsa_switch *ds) 381 { 382 int port; 383 384 /* Destroy network devices for physical switch ports. */ 385 for (port = 0; port < ds->num_ports; port++) { 386 if (!(ds->enabled_port_mask & (1 << port))) 387 continue; 388 389 if (!ds->ports[port].netdev) 390 continue; 391 392 dsa_slave_destroy(ds->ports[port].netdev); 393 } 394 395 /* Disable configuration of the CPU and DSA ports */ 396 for (port = 0; port < ds->num_ports; port++) { 397 if (!(dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))) 398 continue; 399 dsa_cpu_dsa_destroy(&ds->ports[port]); 400 401 /* Clearing a bit which is not set does no harm */ 402 ds->cpu_port_mask |= ~(1 << port); 403 ds->dsa_port_mask |= ~(1 << port); 404 } 405 406 if (ds->slave_mii_bus && ds->ops->phy_read) 407 mdiobus_unregister(ds->slave_mii_bus); 408 409 dsa_switch_unregister_notifier(ds); 410 } 411 412 #ifdef CONFIG_PM_SLEEP 413 int dsa_switch_suspend(struct dsa_switch *ds) 414 { 415 int i, ret = 0; 416 417 /* Suspend slave network devices */ 418 for (i = 0; i < ds->num_ports; i++) { 419 if (!dsa_is_port_initialized(ds, i)) 420 continue; 421 422 ret = dsa_slave_suspend(ds->ports[i].netdev); 423 if (ret) 424 return ret; 425 } 426 427 if (ds->ops->suspend) 428 ret = ds->ops->suspend(ds); 429 430 return ret; 431 } 432 EXPORT_SYMBOL_GPL(dsa_switch_suspend); 433 434 int dsa_switch_resume(struct dsa_switch *ds) 435 { 436 int i, ret = 0; 437 438 if (ds->ops->resume) 439 ret = ds->ops->resume(ds); 440 441 if (ret) 442 return ret; 443 444 /* Resume slave network devices */ 445 for (i = 0; i < ds->num_ports; i++) { 446 if (!dsa_is_port_initialized(ds, i)) 447 continue; 448 449 ret = dsa_slave_resume(ds->ports[i].netdev); 450 if (ret) 451 return ret; 452 } 453 454 return 0; 455 } 456 EXPORT_SYMBOL_GPL(dsa_switch_resume); 457 #endif 458 459 /* platform driver init and cleanup *****************************************/ 460 static int dev_is_class(struct device *dev, void *class) 461 { 462 if (dev->class != NULL && !strcmp(dev->class->name, class)) 463 return 1; 464 465 return 0; 466 } 467 468 static struct device *dev_find_class(struct device *parent, char *class) 469 { 470 if (dev_is_class(parent, class)) { 471 get_device(parent); 472 return parent; 473 } 474 475 return device_find_child(parent, class, dev_is_class); 476 } 477 478 struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev) 479 { 480 struct device *d; 481 482 d = dev_find_class(dev, "mdio_bus"); 483 if (d != NULL) { 484 struct mii_bus *bus; 485 486 bus = to_mii_bus(d); 487 put_device(d); 488 489 return bus; 490 } 491 492 return NULL; 493 } 494 EXPORT_SYMBOL_GPL(dsa_host_dev_to_mii_bus); 495 496 struct net_device *dsa_dev_to_net_device(struct device *dev) 497 { 498 struct device *d; 499 500 d = dev_find_class(dev, "net"); 501 if (d != NULL) { 502 struct net_device *nd; 503 504 nd = to_net_dev(d); 505 dev_hold(nd); 506 put_device(d); 507 508 return nd; 509 } 510 511 return NULL; 512 } 513 EXPORT_SYMBOL_GPL(dsa_dev_to_net_device); 514 515 #ifdef CONFIG_OF 516 static int dsa_of_setup_routing_table(struct dsa_platform_data *pd, 517 struct dsa_chip_data *cd, 518 int chip_index, int port_index, 519 struct device_node *link) 520 { 521 const __be32 *reg; 522 int link_sw_addr; 523 struct device_node *parent_sw; 524 int len; 525 526 parent_sw = of_get_parent(link); 527 if (!parent_sw) 528 return -EINVAL; 529 530 reg = of_get_property(parent_sw, "reg", &len); 531 if (!reg || (len != sizeof(*reg) * 2)) 532 return -EINVAL; 533 534 /* 535 * Get the destination switch number from the second field of its 'reg' 536 * property, i.e. for "reg = <0x19 1>" sw_addr is '1'. 537 */ 538 link_sw_addr = be32_to_cpup(reg + 1); 539 540 if (link_sw_addr >= pd->nr_chips) 541 return -EINVAL; 542 543 cd->rtable[link_sw_addr] = port_index; 544 545 return 0; 546 } 547 548 static int dsa_of_probe_links(struct dsa_platform_data *pd, 549 struct dsa_chip_data *cd, 550 int chip_index, int port_index, 551 struct device_node *port, 552 const char *port_name) 553 { 554 struct device_node *link; 555 int link_index; 556 int ret; 557 558 for (link_index = 0;; link_index++) { 559 link = of_parse_phandle(port, "link", link_index); 560 if (!link) 561 break; 562 563 if (!strcmp(port_name, "dsa") && pd->nr_chips > 1) { 564 ret = dsa_of_setup_routing_table(pd, cd, chip_index, 565 port_index, link); 566 if (ret) 567 return ret; 568 } 569 } 570 return 0; 571 } 572 573 static void dsa_of_free_platform_data(struct dsa_platform_data *pd) 574 { 575 int i; 576 int port_index; 577 578 for (i = 0; i < pd->nr_chips; i++) { 579 port_index = 0; 580 while (port_index < DSA_MAX_PORTS) { 581 kfree(pd->chip[i].port_names[port_index]); 582 port_index++; 583 } 584 585 /* Drop our reference to the MDIO bus device */ 586 if (pd->chip[i].host_dev) 587 put_device(pd->chip[i].host_dev); 588 } 589 kfree(pd->chip); 590 } 591 592 static int dsa_of_probe(struct device *dev) 593 { 594 struct device_node *np = dev->of_node; 595 struct device_node *child, *mdio, *ethernet, *port; 596 struct mii_bus *mdio_bus, *mdio_bus_switch; 597 struct net_device *ethernet_dev; 598 struct dsa_platform_data *pd; 599 struct dsa_chip_data *cd; 600 const char *port_name; 601 int chip_index, port_index; 602 const unsigned int *sw_addr, *port_reg; 603 u32 eeprom_len; 604 int ret; 605 606 mdio = of_parse_phandle(np, "dsa,mii-bus", 0); 607 if (!mdio) 608 return -EINVAL; 609 610 mdio_bus = of_mdio_find_bus(mdio); 611 if (!mdio_bus) 612 return -EPROBE_DEFER; 613 614 ethernet = of_parse_phandle(np, "dsa,ethernet", 0); 615 if (!ethernet) { 616 ret = -EINVAL; 617 goto out_put_mdio; 618 } 619 620 ethernet_dev = of_find_net_device_by_node(ethernet); 621 if (!ethernet_dev) { 622 ret = -EPROBE_DEFER; 623 goto out_put_mdio; 624 } 625 626 pd = kzalloc(sizeof(*pd), GFP_KERNEL); 627 if (!pd) { 628 ret = -ENOMEM; 629 goto out_put_ethernet; 630 } 631 632 dev->platform_data = pd; 633 pd->of_netdev = ethernet_dev; 634 pd->nr_chips = of_get_available_child_count(np); 635 if (pd->nr_chips > DSA_MAX_SWITCHES) 636 pd->nr_chips = DSA_MAX_SWITCHES; 637 638 pd->chip = kcalloc(pd->nr_chips, sizeof(struct dsa_chip_data), 639 GFP_KERNEL); 640 if (!pd->chip) { 641 ret = -ENOMEM; 642 goto out_free; 643 } 644 645 chip_index = -1; 646 for_each_available_child_of_node(np, child) { 647 int i; 648 649 chip_index++; 650 cd = &pd->chip[chip_index]; 651 652 cd->of_node = child; 653 654 /* Initialize the routing table */ 655 for (i = 0; i < DSA_MAX_SWITCHES; ++i) 656 cd->rtable[i] = DSA_RTABLE_NONE; 657 658 /* When assigning the host device, increment its refcount */ 659 cd->host_dev = get_device(&mdio_bus->dev); 660 661 sw_addr = of_get_property(child, "reg", NULL); 662 if (!sw_addr) 663 continue; 664 665 cd->sw_addr = be32_to_cpup(sw_addr); 666 if (cd->sw_addr >= PHY_MAX_ADDR) 667 continue; 668 669 if (!of_property_read_u32(child, "eeprom-length", &eeprom_len)) 670 cd->eeprom_len = eeprom_len; 671 672 mdio = of_parse_phandle(child, "mii-bus", 0); 673 if (mdio) { 674 mdio_bus_switch = of_mdio_find_bus(mdio); 675 if (!mdio_bus_switch) { 676 ret = -EPROBE_DEFER; 677 goto out_free_chip; 678 } 679 680 /* Drop the mdio_bus device ref, replacing the host 681 * device with the mdio_bus_switch device, keeping 682 * the refcount from of_mdio_find_bus() above. 683 */ 684 put_device(cd->host_dev); 685 cd->host_dev = &mdio_bus_switch->dev; 686 } 687 688 for_each_available_child_of_node(child, port) { 689 port_reg = of_get_property(port, "reg", NULL); 690 if (!port_reg) 691 continue; 692 693 port_index = be32_to_cpup(port_reg); 694 if (port_index >= DSA_MAX_PORTS) 695 break; 696 697 port_name = of_get_property(port, "label", NULL); 698 if (!port_name) 699 continue; 700 701 cd->port_dn[port_index] = port; 702 703 cd->port_names[port_index] = kstrdup(port_name, 704 GFP_KERNEL); 705 if (!cd->port_names[port_index]) { 706 ret = -ENOMEM; 707 goto out_free_chip; 708 } 709 710 ret = dsa_of_probe_links(pd, cd, chip_index, 711 port_index, port, port_name); 712 if (ret) 713 goto out_free_chip; 714 715 } 716 } 717 718 /* The individual chips hold their own refcount on the mdio bus, 719 * so drop ours */ 720 put_device(&mdio_bus->dev); 721 722 return 0; 723 724 out_free_chip: 725 dsa_of_free_platform_data(pd); 726 out_free: 727 kfree(pd); 728 dev->platform_data = NULL; 729 out_put_ethernet: 730 put_device(ðernet_dev->dev); 731 out_put_mdio: 732 put_device(&mdio_bus->dev); 733 return ret; 734 } 735 736 static void dsa_of_remove(struct device *dev) 737 { 738 struct dsa_platform_data *pd = dev->platform_data; 739 740 if (!dev->of_node) 741 return; 742 743 dsa_of_free_platform_data(pd); 744 put_device(&pd->of_netdev->dev); 745 kfree(pd); 746 } 747 #else 748 static inline int dsa_of_probe(struct device *dev) 749 { 750 return 0; 751 } 752 753 static inline void dsa_of_remove(struct device *dev) 754 { 755 } 756 #endif 757 758 static int dsa_setup_dst(struct dsa_switch_tree *dst, struct net_device *dev, 759 struct device *parent, struct dsa_platform_data *pd) 760 { 761 int i; 762 unsigned configured = 0; 763 764 dst->pd = pd; 765 dst->master_netdev = dev; 766 dst->cpu_port = -1; 767 768 for (i = 0; i < pd->nr_chips; i++) { 769 struct dsa_switch *ds; 770 771 ds = dsa_switch_setup(dst, i, parent, pd->chip[i].host_dev); 772 if (IS_ERR(ds)) { 773 netdev_err(dev, "[%d]: couldn't create dsa switch instance (error %ld)\n", 774 i, PTR_ERR(ds)); 775 continue; 776 } 777 778 dst->ds[i] = ds; 779 780 ++configured; 781 } 782 783 /* 784 * If no switch was found, exit cleanly 785 */ 786 if (!configured) 787 return -EPROBE_DEFER; 788 789 /* 790 * If we use a tagging format that doesn't have an ethertype 791 * field, make sure that all packets from this point on get 792 * sent to the tag format's receive function. 793 */ 794 wmb(); 795 dev->dsa_ptr = (void *)dst; 796 797 return 0; 798 } 799 800 static int dsa_probe(struct platform_device *pdev) 801 { 802 struct dsa_platform_data *pd = pdev->dev.platform_data; 803 struct net_device *dev; 804 struct dsa_switch_tree *dst; 805 int ret; 806 807 if (pdev->dev.of_node) { 808 ret = dsa_of_probe(&pdev->dev); 809 if (ret) 810 return ret; 811 812 pd = pdev->dev.platform_data; 813 } 814 815 if (pd == NULL || (pd->netdev == NULL && pd->of_netdev == NULL)) 816 return -EINVAL; 817 818 if (pd->of_netdev) { 819 dev = pd->of_netdev; 820 dev_hold(dev); 821 } else { 822 dev = dsa_dev_to_net_device(pd->netdev); 823 } 824 if (dev == NULL) { 825 ret = -EPROBE_DEFER; 826 goto out; 827 } 828 829 if (dev->dsa_ptr != NULL) { 830 dev_put(dev); 831 ret = -EEXIST; 832 goto out; 833 } 834 835 dst = devm_kzalloc(&pdev->dev, sizeof(*dst), GFP_KERNEL); 836 if (dst == NULL) { 837 dev_put(dev); 838 ret = -ENOMEM; 839 goto out; 840 } 841 842 platform_set_drvdata(pdev, dst); 843 844 ret = dsa_setup_dst(dst, dev, &pdev->dev, pd); 845 if (ret) { 846 dev_put(dev); 847 goto out; 848 } 849 850 return 0; 851 852 out: 853 dsa_of_remove(&pdev->dev); 854 855 return ret; 856 } 857 858 static void dsa_remove_dst(struct dsa_switch_tree *dst) 859 { 860 int i; 861 862 dst->master_netdev->dsa_ptr = NULL; 863 864 /* If we used a tagging format that doesn't have an ethertype 865 * field, make sure that all packets from this point get sent 866 * without the tag and go through the regular receive path. 867 */ 868 wmb(); 869 870 for (i = 0; i < dst->pd->nr_chips; i++) { 871 struct dsa_switch *ds = dst->ds[i]; 872 873 if (ds) 874 dsa_switch_destroy(ds); 875 } 876 877 dsa_cpu_port_ethtool_restore(dst->cpu_switch); 878 879 dev_put(dst->master_netdev); 880 } 881 882 static int dsa_remove(struct platform_device *pdev) 883 { 884 struct dsa_switch_tree *dst = platform_get_drvdata(pdev); 885 886 dsa_remove_dst(dst); 887 dsa_of_remove(&pdev->dev); 888 889 return 0; 890 } 891 892 static void dsa_shutdown(struct platform_device *pdev) 893 { 894 } 895 896 static int dsa_switch_rcv(struct sk_buff *skb, struct net_device *dev, 897 struct packet_type *pt, struct net_device *orig_dev) 898 { 899 struct dsa_switch_tree *dst = dev->dsa_ptr; 900 901 if (unlikely(dst == NULL)) { 902 kfree_skb(skb); 903 return 0; 904 } 905 906 return dst->rcv(skb, dev, pt, orig_dev); 907 } 908 909 static struct packet_type dsa_pack_type __read_mostly = { 910 .type = cpu_to_be16(ETH_P_XDSA), 911 .func = dsa_switch_rcv, 912 }; 913 914 #ifdef CONFIG_PM_SLEEP 915 static int dsa_suspend(struct device *d) 916 { 917 struct platform_device *pdev = to_platform_device(d); 918 struct dsa_switch_tree *dst = platform_get_drvdata(pdev); 919 int i, ret = 0; 920 921 for (i = 0; i < dst->pd->nr_chips; i++) { 922 struct dsa_switch *ds = dst->ds[i]; 923 924 if (ds != NULL) 925 ret = dsa_switch_suspend(ds); 926 } 927 928 return ret; 929 } 930 931 static int dsa_resume(struct device *d) 932 { 933 struct platform_device *pdev = to_platform_device(d); 934 struct dsa_switch_tree *dst = platform_get_drvdata(pdev); 935 int i, ret = 0; 936 937 for (i = 0; i < dst->pd->nr_chips; i++) { 938 struct dsa_switch *ds = dst->ds[i]; 939 940 if (ds != NULL) 941 ret = dsa_switch_resume(ds); 942 } 943 944 return ret; 945 } 946 #endif 947 948 static SIMPLE_DEV_PM_OPS(dsa_pm_ops, dsa_suspend, dsa_resume); 949 950 static const struct of_device_id dsa_of_match_table[] = { 951 { .compatible = "marvell,dsa", }, 952 {} 953 }; 954 MODULE_DEVICE_TABLE(of, dsa_of_match_table); 955 956 static struct platform_driver dsa_driver = { 957 .probe = dsa_probe, 958 .remove = dsa_remove, 959 .shutdown = dsa_shutdown, 960 .driver = { 961 .name = "dsa", 962 .of_match_table = dsa_of_match_table, 963 .pm = &dsa_pm_ops, 964 }, 965 }; 966 967 static int __init dsa_init_module(void) 968 { 969 int rc; 970 971 rc = dsa_slave_register_notifier(); 972 if (rc) 973 return rc; 974 975 rc = platform_driver_register(&dsa_driver); 976 if (rc) 977 return rc; 978 979 dev_add_pack(&dsa_pack_type); 980 981 return 0; 982 } 983 module_init(dsa_init_module); 984 985 static void __exit dsa_cleanup_module(void) 986 { 987 dsa_slave_unregister_notifier(); 988 dev_remove_pack(&dsa_pack_type); 989 platform_driver_unregister(&dsa_driver); 990 } 991 module_exit(dsa_cleanup_module); 992 993 MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>"); 994 MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips"); 995 MODULE_LICENSE("GPL"); 996 MODULE_ALIAS("platform:dsa"); 997