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/list.h> 13 #include <linux/platform_device.h> 14 #include <linux/slab.h> 15 #include <linux/module.h> 16 #include <net/dsa.h> 17 #include <linux/of.h> 18 #include <linux/of_mdio.h> 19 #include <linux/of_platform.h> 20 #include "dsa_priv.h" 21 22 char dsa_driver_version[] = "0.1"; 23 24 25 /* switch driver registration ***********************************************/ 26 static DEFINE_MUTEX(dsa_switch_drivers_mutex); 27 static LIST_HEAD(dsa_switch_drivers); 28 29 void register_switch_driver(struct dsa_switch_driver *drv) 30 { 31 mutex_lock(&dsa_switch_drivers_mutex); 32 list_add_tail(&drv->list, &dsa_switch_drivers); 33 mutex_unlock(&dsa_switch_drivers_mutex); 34 } 35 EXPORT_SYMBOL_GPL(register_switch_driver); 36 37 void unregister_switch_driver(struct dsa_switch_driver *drv) 38 { 39 mutex_lock(&dsa_switch_drivers_mutex); 40 list_del_init(&drv->list); 41 mutex_unlock(&dsa_switch_drivers_mutex); 42 } 43 EXPORT_SYMBOL_GPL(unregister_switch_driver); 44 45 static struct dsa_switch_driver * 46 dsa_switch_probe(struct device *host_dev, int sw_addr, char **_name) 47 { 48 struct dsa_switch_driver *ret; 49 struct list_head *list; 50 char *name; 51 52 ret = NULL; 53 name = NULL; 54 55 mutex_lock(&dsa_switch_drivers_mutex); 56 list_for_each(list, &dsa_switch_drivers) { 57 struct dsa_switch_driver *drv; 58 59 drv = list_entry(list, struct dsa_switch_driver, list); 60 61 name = drv->probe(host_dev, sw_addr); 62 if (name != NULL) { 63 ret = drv; 64 break; 65 } 66 } 67 mutex_unlock(&dsa_switch_drivers_mutex); 68 69 *_name = name; 70 71 return ret; 72 } 73 74 75 /* basic switch operations **************************************************/ 76 static struct dsa_switch * 77 dsa_switch_setup(struct dsa_switch_tree *dst, int index, 78 struct device *parent, struct device *host_dev) 79 { 80 struct dsa_chip_data *pd = dst->pd->chip + index; 81 struct dsa_switch_driver *drv; 82 struct dsa_switch *ds; 83 int ret; 84 char *name; 85 int i; 86 bool valid_name_found = false; 87 88 /* 89 * Probe for switch model. 90 */ 91 drv = dsa_switch_probe(host_dev, pd->sw_addr, &name); 92 if (drv == NULL) { 93 printk(KERN_ERR "%s[%d]: could not detect attached switch\n", 94 dst->master_netdev->name, index); 95 return ERR_PTR(-EINVAL); 96 } 97 printk(KERN_INFO "%s[%d]: detected a %s switch\n", 98 dst->master_netdev->name, index, name); 99 100 101 /* 102 * Allocate and initialise switch state. 103 */ 104 ds = kzalloc(sizeof(*ds) + drv->priv_size, GFP_KERNEL); 105 if (ds == NULL) 106 return ERR_PTR(-ENOMEM); 107 108 ds->dst = dst; 109 ds->index = index; 110 ds->pd = dst->pd->chip + index; 111 ds->drv = drv; 112 ds->master_dev = host_dev; 113 114 /* 115 * Validate supplied switch configuration. 116 */ 117 for (i = 0; i < DSA_MAX_PORTS; i++) { 118 char *name; 119 120 name = pd->port_names[i]; 121 if (name == NULL) 122 continue; 123 124 if (!strcmp(name, "cpu")) { 125 if (dst->cpu_switch != -1) { 126 printk(KERN_ERR "multiple cpu ports?!\n"); 127 ret = -EINVAL; 128 goto out; 129 } 130 dst->cpu_switch = index; 131 dst->cpu_port = i; 132 } else if (!strcmp(name, "dsa")) { 133 ds->dsa_port_mask |= 1 << i; 134 } else { 135 ds->phys_port_mask |= 1 << i; 136 } 137 valid_name_found = true; 138 } 139 140 if (!valid_name_found && i == DSA_MAX_PORTS) { 141 ret = -EINVAL; 142 goto out; 143 } 144 145 /* Make the built-in MII bus mask match the number of ports, 146 * switch drivers can override this later 147 */ 148 ds->phys_mii_mask = ds->phys_port_mask; 149 150 /* 151 * If the CPU connects to this switch, set the switch tree 152 * tagging protocol to the preferred tagging format of this 153 * switch. 154 */ 155 if (dst->cpu_switch == index) { 156 switch (drv->tag_protocol) { 157 #ifdef CONFIG_NET_DSA_TAG_DSA 158 case DSA_TAG_PROTO_DSA: 159 dst->rcv = dsa_netdev_ops.rcv; 160 break; 161 #endif 162 #ifdef CONFIG_NET_DSA_TAG_EDSA 163 case DSA_TAG_PROTO_EDSA: 164 dst->rcv = edsa_netdev_ops.rcv; 165 break; 166 #endif 167 #ifdef CONFIG_NET_DSA_TAG_TRAILER 168 case DSA_TAG_PROTO_TRAILER: 169 dst->rcv = trailer_netdev_ops.rcv; 170 break; 171 #endif 172 #ifdef CONFIG_NET_DSA_TAG_BRCM 173 case DSA_TAG_PROTO_BRCM: 174 dst->rcv = brcm_netdev_ops.rcv; 175 break; 176 #endif 177 case DSA_TAG_PROTO_NONE: 178 break; 179 default: 180 ret = -ENOPROTOOPT; 181 goto out; 182 } 183 184 dst->tag_protocol = drv->tag_protocol; 185 } 186 187 /* 188 * Do basic register setup. 189 */ 190 ret = drv->setup(ds); 191 if (ret < 0) 192 goto out; 193 194 ret = drv->set_addr(ds, dst->master_netdev->dev_addr); 195 if (ret < 0) 196 goto out; 197 198 ds->slave_mii_bus = mdiobus_alloc(); 199 if (ds->slave_mii_bus == NULL) { 200 ret = -ENOMEM; 201 goto out; 202 } 203 dsa_slave_mii_bus_init(ds); 204 205 ret = mdiobus_register(ds->slave_mii_bus); 206 if (ret < 0) 207 goto out_free; 208 209 210 /* 211 * Create network devices for physical switch ports. 212 */ 213 for (i = 0; i < DSA_MAX_PORTS; i++) { 214 struct net_device *slave_dev; 215 216 if (!(ds->phys_port_mask & (1 << i))) 217 continue; 218 219 slave_dev = dsa_slave_create(ds, parent, i, pd->port_names[i]); 220 if (slave_dev == NULL) { 221 printk(KERN_ERR "%s[%d]: can't create dsa " 222 "slave device for port %d(%s)\n", 223 dst->master_netdev->name, 224 index, i, pd->port_names[i]); 225 continue; 226 } 227 228 ds->ports[i] = slave_dev; 229 } 230 231 return ds; 232 233 out_free: 234 mdiobus_free(ds->slave_mii_bus); 235 out: 236 kfree(ds); 237 return ERR_PTR(ret); 238 } 239 240 static void dsa_switch_destroy(struct dsa_switch *ds) 241 { 242 } 243 244 #ifdef CONFIG_PM_SLEEP 245 static int dsa_switch_suspend(struct dsa_switch *ds) 246 { 247 int i, ret = 0; 248 249 /* Suspend slave network devices */ 250 for (i = 0; i < DSA_MAX_PORTS; i++) { 251 if (!(ds->phys_port_mask & (1 << i))) 252 continue; 253 254 ret = dsa_slave_suspend(ds->ports[i]); 255 if (ret) 256 return ret; 257 } 258 259 if (ds->drv->suspend) 260 ret = ds->drv->suspend(ds); 261 262 return ret; 263 } 264 265 static int dsa_switch_resume(struct dsa_switch *ds) 266 { 267 int i, ret = 0; 268 269 if (ds->drv->resume) 270 ret = ds->drv->resume(ds); 271 272 if (ret) 273 return ret; 274 275 /* Resume slave network devices */ 276 for (i = 0; i < DSA_MAX_PORTS; i++) { 277 if (!(ds->phys_port_mask & (1 << i))) 278 continue; 279 280 ret = dsa_slave_resume(ds->ports[i]); 281 if (ret) 282 return ret; 283 } 284 285 return 0; 286 } 287 #endif 288 289 290 /* link polling *************************************************************/ 291 static void dsa_link_poll_work(struct work_struct *ugly) 292 { 293 struct dsa_switch_tree *dst; 294 int i; 295 296 dst = container_of(ugly, struct dsa_switch_tree, link_poll_work); 297 298 for (i = 0; i < dst->pd->nr_chips; i++) { 299 struct dsa_switch *ds = dst->ds[i]; 300 301 if (ds != NULL && ds->drv->poll_link != NULL) 302 ds->drv->poll_link(ds); 303 } 304 305 mod_timer(&dst->link_poll_timer, round_jiffies(jiffies + HZ)); 306 } 307 308 static void dsa_link_poll_timer(unsigned long _dst) 309 { 310 struct dsa_switch_tree *dst = (void *)_dst; 311 312 schedule_work(&dst->link_poll_work); 313 } 314 315 316 /* platform driver init and cleanup *****************************************/ 317 static int dev_is_class(struct device *dev, void *class) 318 { 319 if (dev->class != NULL && !strcmp(dev->class->name, class)) 320 return 1; 321 322 return 0; 323 } 324 325 static struct device *dev_find_class(struct device *parent, char *class) 326 { 327 if (dev_is_class(parent, class)) { 328 get_device(parent); 329 return parent; 330 } 331 332 return device_find_child(parent, class, dev_is_class); 333 } 334 335 struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev) 336 { 337 struct device *d; 338 339 d = dev_find_class(dev, "mdio_bus"); 340 if (d != NULL) { 341 struct mii_bus *bus; 342 343 bus = to_mii_bus(d); 344 put_device(d); 345 346 return bus; 347 } 348 349 return NULL; 350 } 351 EXPORT_SYMBOL_GPL(dsa_host_dev_to_mii_bus); 352 353 static struct net_device *dev_to_net_device(struct device *dev) 354 { 355 struct device *d; 356 357 d = dev_find_class(dev, "net"); 358 if (d != NULL) { 359 struct net_device *nd; 360 361 nd = to_net_dev(d); 362 dev_hold(nd); 363 put_device(d); 364 365 return nd; 366 } 367 368 return NULL; 369 } 370 371 #ifdef CONFIG_OF 372 static int dsa_of_setup_routing_table(struct dsa_platform_data *pd, 373 struct dsa_chip_data *cd, 374 int chip_index, 375 struct device_node *link) 376 { 377 int ret; 378 const __be32 *reg; 379 int link_port_addr; 380 int link_sw_addr; 381 struct device_node *parent_sw; 382 int len; 383 384 parent_sw = of_get_parent(link); 385 if (!parent_sw) 386 return -EINVAL; 387 388 reg = of_get_property(parent_sw, "reg", &len); 389 if (!reg || (len != sizeof(*reg) * 2)) 390 return -EINVAL; 391 392 link_sw_addr = be32_to_cpup(reg + 1); 393 394 if (link_sw_addr >= pd->nr_chips) 395 return -EINVAL; 396 397 /* First time routing table allocation */ 398 if (!cd->rtable) { 399 cd->rtable = kmalloc(pd->nr_chips * sizeof(s8), GFP_KERNEL); 400 if (!cd->rtable) 401 return -ENOMEM; 402 403 /* default to no valid uplink/downlink */ 404 memset(cd->rtable, -1, pd->nr_chips * sizeof(s8)); 405 } 406 407 reg = of_get_property(link, "reg", NULL); 408 if (!reg) { 409 ret = -EINVAL; 410 goto out; 411 } 412 413 link_port_addr = be32_to_cpup(reg); 414 415 cd->rtable[link_sw_addr] = link_port_addr; 416 417 return 0; 418 out: 419 kfree(cd->rtable); 420 return ret; 421 } 422 423 static void dsa_of_free_platform_data(struct dsa_platform_data *pd) 424 { 425 int i; 426 int port_index; 427 428 for (i = 0; i < pd->nr_chips; i++) { 429 port_index = 0; 430 while (port_index < DSA_MAX_PORTS) { 431 kfree(pd->chip[i].port_names[port_index]); 432 port_index++; 433 } 434 kfree(pd->chip[i].rtable); 435 } 436 kfree(pd->chip); 437 } 438 439 static int dsa_of_probe(struct platform_device *pdev) 440 { 441 struct device_node *np = pdev->dev.of_node; 442 struct device_node *child, *mdio, *ethernet, *port, *link; 443 struct mii_bus *mdio_bus; 444 struct platform_device *ethernet_dev; 445 struct dsa_platform_data *pd; 446 struct dsa_chip_data *cd; 447 const char *port_name; 448 int chip_index, port_index; 449 const unsigned int *sw_addr, *port_reg; 450 int ret; 451 452 mdio = of_parse_phandle(np, "dsa,mii-bus", 0); 453 if (!mdio) 454 return -EINVAL; 455 456 mdio_bus = of_mdio_find_bus(mdio); 457 if (!mdio_bus) 458 return -EINVAL; 459 460 ethernet = of_parse_phandle(np, "dsa,ethernet", 0); 461 if (!ethernet) 462 return -EINVAL; 463 464 ethernet_dev = of_find_device_by_node(ethernet); 465 if (!ethernet_dev) 466 return -ENODEV; 467 468 pd = kzalloc(sizeof(*pd), GFP_KERNEL); 469 if (!pd) 470 return -ENOMEM; 471 472 pdev->dev.platform_data = pd; 473 pd->netdev = ðernet_dev->dev; 474 pd->nr_chips = of_get_child_count(np); 475 if (pd->nr_chips > DSA_MAX_SWITCHES) 476 pd->nr_chips = DSA_MAX_SWITCHES; 477 478 pd->chip = kzalloc(pd->nr_chips * sizeof(struct dsa_chip_data), 479 GFP_KERNEL); 480 if (!pd->chip) { 481 ret = -ENOMEM; 482 goto out_free; 483 } 484 485 chip_index = -1; 486 for_each_available_child_of_node(np, child) { 487 chip_index++; 488 cd = &pd->chip[chip_index]; 489 490 cd->of_node = child; 491 cd->host_dev = &mdio_bus->dev; 492 493 sw_addr = of_get_property(child, "reg", NULL); 494 if (!sw_addr) 495 continue; 496 497 cd->sw_addr = be32_to_cpup(sw_addr); 498 if (cd->sw_addr > PHY_MAX_ADDR) 499 continue; 500 501 for_each_available_child_of_node(child, port) { 502 port_reg = of_get_property(port, "reg", NULL); 503 if (!port_reg) 504 continue; 505 506 port_index = be32_to_cpup(port_reg); 507 508 port_name = of_get_property(port, "label", NULL); 509 if (!port_name) 510 continue; 511 512 cd->port_dn[port_index] = port; 513 514 cd->port_names[port_index] = kstrdup(port_name, 515 GFP_KERNEL); 516 if (!cd->port_names[port_index]) { 517 ret = -ENOMEM; 518 goto out_free_chip; 519 } 520 521 link = of_parse_phandle(port, "link", 0); 522 523 if (!strcmp(port_name, "dsa") && link && 524 pd->nr_chips > 1) { 525 ret = dsa_of_setup_routing_table(pd, cd, 526 chip_index, link); 527 if (ret) 528 goto out_free_chip; 529 } 530 531 if (port_index == DSA_MAX_PORTS) 532 break; 533 } 534 } 535 536 return 0; 537 538 out_free_chip: 539 dsa_of_free_platform_data(pd); 540 out_free: 541 kfree(pd); 542 pdev->dev.platform_data = NULL; 543 return ret; 544 } 545 546 static void dsa_of_remove(struct platform_device *pdev) 547 { 548 struct dsa_platform_data *pd = pdev->dev.platform_data; 549 550 if (!pdev->dev.of_node) 551 return; 552 553 dsa_of_free_platform_data(pd); 554 kfree(pd); 555 } 556 #else 557 static inline int dsa_of_probe(struct platform_device *pdev) 558 { 559 return 0; 560 } 561 562 static inline void dsa_of_remove(struct platform_device *pdev) 563 { 564 } 565 #endif 566 567 static int dsa_probe(struct platform_device *pdev) 568 { 569 static int dsa_version_printed; 570 struct dsa_platform_data *pd = pdev->dev.platform_data; 571 struct net_device *dev; 572 struct dsa_switch_tree *dst; 573 int i, ret; 574 575 if (!dsa_version_printed++) 576 printk(KERN_NOTICE "Distributed Switch Architecture " 577 "driver version %s\n", dsa_driver_version); 578 579 if (pdev->dev.of_node) { 580 ret = dsa_of_probe(pdev); 581 if (ret) 582 return ret; 583 584 pd = pdev->dev.platform_data; 585 } 586 587 if (pd == NULL || pd->netdev == NULL) 588 return -EINVAL; 589 590 dev = dev_to_net_device(pd->netdev); 591 if (dev == NULL) { 592 ret = -EINVAL; 593 goto out; 594 } 595 596 if (dev->dsa_ptr != NULL) { 597 dev_put(dev); 598 ret = -EEXIST; 599 goto out; 600 } 601 602 dst = kzalloc(sizeof(*dst), GFP_KERNEL); 603 if (dst == NULL) { 604 dev_put(dev); 605 ret = -ENOMEM; 606 goto out; 607 } 608 609 platform_set_drvdata(pdev, dst); 610 611 dst->pd = pd; 612 dst->master_netdev = dev; 613 dst->cpu_switch = -1; 614 dst->cpu_port = -1; 615 616 for (i = 0; i < pd->nr_chips; i++) { 617 struct dsa_switch *ds; 618 619 ds = dsa_switch_setup(dst, i, &pdev->dev, pd->chip[i].host_dev); 620 if (IS_ERR(ds)) { 621 printk(KERN_ERR "%s[%d]: couldn't create dsa switch " 622 "instance (error %ld)\n", dev->name, i, 623 PTR_ERR(ds)); 624 continue; 625 } 626 627 dst->ds[i] = ds; 628 if (ds->drv->poll_link != NULL) 629 dst->link_poll_needed = 1; 630 } 631 632 /* 633 * If we use a tagging format that doesn't have an ethertype 634 * field, make sure that all packets from this point on get 635 * sent to the tag format's receive function. 636 */ 637 wmb(); 638 dev->dsa_ptr = (void *)dst; 639 640 if (dst->link_poll_needed) { 641 INIT_WORK(&dst->link_poll_work, dsa_link_poll_work); 642 init_timer(&dst->link_poll_timer); 643 dst->link_poll_timer.data = (unsigned long)dst; 644 dst->link_poll_timer.function = dsa_link_poll_timer; 645 dst->link_poll_timer.expires = round_jiffies(jiffies + HZ); 646 add_timer(&dst->link_poll_timer); 647 } 648 649 return 0; 650 651 out: 652 dsa_of_remove(pdev); 653 654 return ret; 655 } 656 657 static int dsa_remove(struct platform_device *pdev) 658 { 659 struct dsa_switch_tree *dst = platform_get_drvdata(pdev); 660 int i; 661 662 if (dst->link_poll_needed) 663 del_timer_sync(&dst->link_poll_timer); 664 665 flush_work(&dst->link_poll_work); 666 667 for (i = 0; i < dst->pd->nr_chips; i++) { 668 struct dsa_switch *ds = dst->ds[i]; 669 670 if (ds != NULL) 671 dsa_switch_destroy(ds); 672 } 673 674 dsa_of_remove(pdev); 675 676 return 0; 677 } 678 679 static void dsa_shutdown(struct platform_device *pdev) 680 { 681 } 682 683 static int dsa_switch_rcv(struct sk_buff *skb, struct net_device *dev, 684 struct packet_type *pt, struct net_device *orig_dev) 685 { 686 struct dsa_switch_tree *dst = dev->dsa_ptr; 687 688 if (unlikely(dst == NULL)) { 689 kfree_skb(skb); 690 return 0; 691 } 692 693 return dst->rcv(skb, dev, pt, orig_dev); 694 } 695 696 static struct packet_type dsa_pack_type __read_mostly = { 697 .type = cpu_to_be16(ETH_P_XDSA), 698 .func = dsa_switch_rcv, 699 }; 700 701 #ifdef CONFIG_PM_SLEEP 702 static int dsa_suspend(struct device *d) 703 { 704 struct platform_device *pdev = to_platform_device(d); 705 struct dsa_switch_tree *dst = platform_get_drvdata(pdev); 706 int i, ret = 0; 707 708 for (i = 0; i < dst->pd->nr_chips; i++) { 709 struct dsa_switch *ds = dst->ds[i]; 710 711 if (ds != NULL) 712 ret = dsa_switch_suspend(ds); 713 } 714 715 return ret; 716 } 717 718 static int dsa_resume(struct device *d) 719 { 720 struct platform_device *pdev = to_platform_device(d); 721 struct dsa_switch_tree *dst = platform_get_drvdata(pdev); 722 int i, ret = 0; 723 724 for (i = 0; i < dst->pd->nr_chips; i++) { 725 struct dsa_switch *ds = dst->ds[i]; 726 727 if (ds != NULL) 728 ret = dsa_switch_resume(ds); 729 } 730 731 return ret; 732 } 733 #endif 734 735 static SIMPLE_DEV_PM_OPS(dsa_pm_ops, dsa_suspend, dsa_resume); 736 737 static const struct of_device_id dsa_of_match_table[] = { 738 { .compatible = "brcm,bcm7445-switch-v4.0" }, 739 { .compatible = "marvell,dsa", }, 740 {} 741 }; 742 MODULE_DEVICE_TABLE(of, dsa_of_match_table); 743 744 static struct platform_driver dsa_driver = { 745 .probe = dsa_probe, 746 .remove = dsa_remove, 747 .shutdown = dsa_shutdown, 748 .driver = { 749 .name = "dsa", 750 .owner = THIS_MODULE, 751 .of_match_table = dsa_of_match_table, 752 .pm = &dsa_pm_ops, 753 }, 754 }; 755 756 static int __init dsa_init_module(void) 757 { 758 int rc; 759 760 rc = platform_driver_register(&dsa_driver); 761 if (rc) 762 return rc; 763 764 dev_add_pack(&dsa_pack_type); 765 766 return 0; 767 } 768 module_init(dsa_init_module); 769 770 static void __exit dsa_cleanup_module(void) 771 { 772 dev_remove_pack(&dsa_pack_type); 773 platform_driver_unregister(&dsa_driver); 774 } 775 module_exit(dsa_cleanup_module); 776 777 MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>"); 778 MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips"); 779 MODULE_LICENSE("GPL"); 780 MODULE_ALIAS("platform:dsa"); 781