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