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