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