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