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