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_ops *ops) 65 { 66 mutex_lock(&dsa_switch_drivers_mutex); 67 list_add_tail(&ops->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_ops *ops) 73 { 74 mutex_lock(&dsa_switch_drivers_mutex); 75 list_del_init(&ops->list); 76 mutex_unlock(&dsa_switch_drivers_mutex); 77 } 78 EXPORT_SYMBOL_GPL(unregister_switch_driver); 79 80 static struct dsa_switch_ops * 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_ops *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_ops *ops; 94 95 ops = list_entry(list, struct dsa_switch_ops, list); 96 97 name = ops->probe(parent, host_dev, sw_addr, priv); 98 if (name != NULL) { 99 ret = ops; 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->ops->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->ops->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->ops->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->ops->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_ops *ops = ds->ops; 188 umode_t mode = attr->mode; 189 190 if (index == 1) { 191 if (!ops->get_temp_limit) 192 mode = 0; 193 else if (!ops->set_temp_limit) 194 mode &= ~S_IWUSR; 195 } else if (index == 2 && !ops->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->ops->adjust_link) 232 ds->ops->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_ops *ops = ds->ops; 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 enum dsa_tag_protocol tag_protocol; 358 359 tag_protocol = ops->get_tag_protocol(ds); 360 dst->tag_ops = dsa_resolve_tag_protocol(tag_protocol); 361 if (IS_ERR(dst->tag_ops)) { 362 ret = PTR_ERR(dst->tag_ops); 363 goto out; 364 } 365 366 dst->rcv = dst->tag_ops->rcv; 367 } 368 369 memcpy(ds->rtable, cd->rtable, sizeof(ds->rtable)); 370 371 /* 372 * Do basic register setup. 373 */ 374 ret = ops->setup(ds); 375 if (ret < 0) 376 goto out; 377 378 ret = ops->set_addr(ds, dst->master_netdev->dev_addr); 379 if (ret < 0) 380 goto out; 381 382 if (!ds->slave_mii_bus && ops->phy_read) { 383 ds->slave_mii_bus = devm_mdiobus_alloc(parent); 384 if (!ds->slave_mii_bus) { 385 ret = -ENOMEM; 386 goto out; 387 } 388 dsa_slave_mii_bus_init(ds); 389 390 ret = mdiobus_register(ds->slave_mii_bus); 391 if (ret < 0) 392 goto out; 393 } 394 395 /* 396 * Create network devices for physical switch ports. 397 */ 398 for (i = 0; i < DSA_MAX_PORTS; i++) { 399 ds->ports[i].dn = cd->port_dn[i]; 400 401 if (!(ds->enabled_port_mask & (1 << i))) 402 continue; 403 404 ret = dsa_slave_create(ds, parent, i, cd->port_names[i]); 405 if (ret < 0) { 406 netdev_err(dst->master_netdev, "[%d]: can't create dsa slave device for port %d(%s): %d\n", 407 index, i, cd->port_names[i], ret); 408 ret = 0; 409 } 410 } 411 412 /* Perform configuration of the CPU and DSA ports */ 413 ret = dsa_cpu_dsa_setups(ds, parent); 414 if (ret < 0) { 415 netdev_err(dst->master_netdev, "[%d] : can't configure CPU and DSA ports\n", 416 index); 417 ret = 0; 418 } 419 420 ret = dsa_cpu_port_ethtool_setup(ds); 421 if (ret) 422 return ret; 423 424 #ifdef CONFIG_NET_DSA_HWMON 425 /* If the switch provides a temperature sensor, 426 * register with hardware monitoring subsystem. 427 * Treat registration error as non-fatal and ignore it. 428 */ 429 if (ops->get_temp) { 430 const char *netname = netdev_name(dst->master_netdev); 431 char hname[IFNAMSIZ + 1]; 432 int i, j; 433 434 /* Create valid hwmon 'name' attribute */ 435 for (i = j = 0; i < IFNAMSIZ && netname[i]; i++) { 436 if (isalnum(netname[i])) 437 hname[j++] = netname[i]; 438 } 439 hname[j] = '\0'; 440 scnprintf(ds->hwmon_name, sizeof(ds->hwmon_name), "%s_dsa%d", 441 hname, index); 442 ds->hwmon_dev = hwmon_device_register_with_groups(NULL, 443 ds->hwmon_name, ds, dsa_hwmon_groups); 444 if (IS_ERR(ds->hwmon_dev)) 445 ds->hwmon_dev = NULL; 446 } 447 #endif /* CONFIG_NET_DSA_HWMON */ 448 449 return ret; 450 451 out: 452 return ret; 453 } 454 455 static struct dsa_switch * 456 dsa_switch_setup(struct dsa_switch_tree *dst, int index, 457 struct device *parent, struct device *host_dev) 458 { 459 struct dsa_chip_data *cd = dst->pd->chip + index; 460 struct dsa_switch_ops *ops; 461 struct dsa_switch *ds; 462 int ret; 463 const char *name; 464 void *priv; 465 466 /* 467 * Probe for switch model. 468 */ 469 ops = dsa_switch_probe(parent, host_dev, cd->sw_addr, &name, &priv); 470 if (!ops) { 471 netdev_err(dst->master_netdev, "[%d]: could not detect attached switch\n", 472 index); 473 return ERR_PTR(-EINVAL); 474 } 475 netdev_info(dst->master_netdev, "[%d]: detected a %s switch\n", 476 index, name); 477 478 479 /* 480 * Allocate and initialise switch state. 481 */ 482 ds = devm_kzalloc(parent, sizeof(*ds), GFP_KERNEL); 483 if (ds == NULL) 484 return ERR_PTR(-ENOMEM); 485 486 ds->dst = dst; 487 ds->index = index; 488 ds->cd = cd; 489 ds->ops = ops; 490 ds->priv = priv; 491 ds->dev = parent; 492 493 ret = dsa_switch_setup_one(ds, parent); 494 if (ret) 495 return ERR_PTR(ret); 496 497 return ds; 498 } 499 500 void dsa_cpu_dsa_destroy(struct device_node *port_dn) 501 { 502 struct phy_device *phydev; 503 504 if (of_phy_is_fixed_link(port_dn)) { 505 phydev = of_phy_find_device(port_dn); 506 if (phydev) { 507 phy_device_free(phydev); 508 fixed_phy_unregister(phydev); 509 } 510 } 511 } 512 513 static void dsa_switch_destroy(struct dsa_switch *ds) 514 { 515 int port; 516 517 #ifdef CONFIG_NET_DSA_HWMON 518 if (ds->hwmon_dev) 519 hwmon_device_unregister(ds->hwmon_dev); 520 #endif 521 522 /* Destroy network devices for physical switch ports. */ 523 for (port = 0; port < DSA_MAX_PORTS; port++) { 524 if (!(ds->enabled_port_mask & (1 << port))) 525 continue; 526 527 if (!ds->ports[port].netdev) 528 continue; 529 530 dsa_slave_destroy(ds->ports[port].netdev); 531 } 532 533 /* Disable configuration of the CPU and DSA ports */ 534 for (port = 0; port < DSA_MAX_PORTS; port++) { 535 if (!(dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))) 536 continue; 537 dsa_cpu_dsa_destroy(ds->ports[port].dn); 538 539 /* Clearing a bit which is not set does no harm */ 540 ds->cpu_port_mask |= ~(1 << port); 541 ds->dsa_port_mask |= ~(1 << port); 542 } 543 544 if (ds->slave_mii_bus && ds->ops->phy_read) 545 mdiobus_unregister(ds->slave_mii_bus); 546 } 547 548 #ifdef CONFIG_PM_SLEEP 549 int dsa_switch_suspend(struct dsa_switch *ds) 550 { 551 int i, ret = 0; 552 553 /* Suspend slave network devices */ 554 for (i = 0; i < DSA_MAX_PORTS; i++) { 555 if (!dsa_is_port_initialized(ds, i)) 556 continue; 557 558 ret = dsa_slave_suspend(ds->ports[i].netdev); 559 if (ret) 560 return ret; 561 } 562 563 if (ds->ops->suspend) 564 ret = ds->ops->suspend(ds); 565 566 return ret; 567 } 568 EXPORT_SYMBOL_GPL(dsa_switch_suspend); 569 570 int dsa_switch_resume(struct dsa_switch *ds) 571 { 572 int i, ret = 0; 573 574 if (ds->ops->resume) 575 ret = ds->ops->resume(ds); 576 577 if (ret) 578 return ret; 579 580 /* Resume slave network devices */ 581 for (i = 0; i < DSA_MAX_PORTS; i++) { 582 if (!dsa_is_port_initialized(ds, i)) 583 continue; 584 585 ret = dsa_slave_resume(ds->ports[i].netdev); 586 if (ret) 587 return ret; 588 } 589 590 return 0; 591 } 592 EXPORT_SYMBOL_GPL(dsa_switch_resume); 593 #endif 594 595 /* platform driver init and cleanup *****************************************/ 596 static int dev_is_class(struct device *dev, void *class) 597 { 598 if (dev->class != NULL && !strcmp(dev->class->name, class)) 599 return 1; 600 601 return 0; 602 } 603 604 static struct device *dev_find_class(struct device *parent, char *class) 605 { 606 if (dev_is_class(parent, class)) { 607 get_device(parent); 608 return parent; 609 } 610 611 return device_find_child(parent, class, dev_is_class); 612 } 613 614 struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev) 615 { 616 struct device *d; 617 618 d = dev_find_class(dev, "mdio_bus"); 619 if (d != NULL) { 620 struct mii_bus *bus; 621 622 bus = to_mii_bus(d); 623 put_device(d); 624 625 return bus; 626 } 627 628 return NULL; 629 } 630 EXPORT_SYMBOL_GPL(dsa_host_dev_to_mii_bus); 631 632 static struct net_device *dev_to_net_device(struct device *dev) 633 { 634 struct device *d; 635 636 d = dev_find_class(dev, "net"); 637 if (d != NULL) { 638 struct net_device *nd; 639 640 nd = to_net_dev(d); 641 dev_hold(nd); 642 put_device(d); 643 644 return nd; 645 } 646 647 return NULL; 648 } 649 650 #ifdef CONFIG_OF 651 static int dsa_of_setup_routing_table(struct dsa_platform_data *pd, 652 struct dsa_chip_data *cd, 653 int chip_index, int port_index, 654 struct device_node *link) 655 { 656 const __be32 *reg; 657 int link_sw_addr; 658 struct device_node *parent_sw; 659 int len; 660 661 parent_sw = of_get_parent(link); 662 if (!parent_sw) 663 return -EINVAL; 664 665 reg = of_get_property(parent_sw, "reg", &len); 666 if (!reg || (len != sizeof(*reg) * 2)) 667 return -EINVAL; 668 669 /* 670 * Get the destination switch number from the second field of its 'reg' 671 * property, i.e. for "reg = <0x19 1>" sw_addr is '1'. 672 */ 673 link_sw_addr = be32_to_cpup(reg + 1); 674 675 if (link_sw_addr >= pd->nr_chips) 676 return -EINVAL; 677 678 cd->rtable[link_sw_addr] = port_index; 679 680 return 0; 681 } 682 683 static int dsa_of_probe_links(struct dsa_platform_data *pd, 684 struct dsa_chip_data *cd, 685 int chip_index, int port_index, 686 struct device_node *port, 687 const char *port_name) 688 { 689 struct device_node *link; 690 int link_index; 691 int ret; 692 693 for (link_index = 0;; link_index++) { 694 link = of_parse_phandle(port, "link", link_index); 695 if (!link) 696 break; 697 698 if (!strcmp(port_name, "dsa") && pd->nr_chips > 1) { 699 ret = dsa_of_setup_routing_table(pd, cd, chip_index, 700 port_index, link); 701 if (ret) 702 return ret; 703 } 704 } 705 return 0; 706 } 707 708 static void dsa_of_free_platform_data(struct dsa_platform_data *pd) 709 { 710 int i; 711 int port_index; 712 713 for (i = 0; i < pd->nr_chips; i++) { 714 port_index = 0; 715 while (port_index < DSA_MAX_PORTS) { 716 kfree(pd->chip[i].port_names[port_index]); 717 port_index++; 718 } 719 720 /* Drop our reference to the MDIO bus device */ 721 if (pd->chip[i].host_dev) 722 put_device(pd->chip[i].host_dev); 723 } 724 kfree(pd->chip); 725 } 726 727 static int dsa_of_probe(struct device *dev) 728 { 729 struct device_node *np = dev->of_node; 730 struct device_node *child, *mdio, *ethernet, *port; 731 struct mii_bus *mdio_bus, *mdio_bus_switch; 732 struct net_device *ethernet_dev; 733 struct dsa_platform_data *pd; 734 struct dsa_chip_data *cd; 735 const char *port_name; 736 int chip_index, port_index; 737 const unsigned int *sw_addr, *port_reg; 738 u32 eeprom_len; 739 int ret; 740 741 mdio = of_parse_phandle(np, "dsa,mii-bus", 0); 742 if (!mdio) 743 return -EINVAL; 744 745 mdio_bus = of_mdio_find_bus(mdio); 746 if (!mdio_bus) 747 return -EPROBE_DEFER; 748 749 ethernet = of_parse_phandle(np, "dsa,ethernet", 0); 750 if (!ethernet) { 751 ret = -EINVAL; 752 goto out_put_mdio; 753 } 754 755 ethernet_dev = of_find_net_device_by_node(ethernet); 756 if (!ethernet_dev) { 757 ret = -EPROBE_DEFER; 758 goto out_put_mdio; 759 } 760 761 pd = kzalloc(sizeof(*pd), GFP_KERNEL); 762 if (!pd) { 763 ret = -ENOMEM; 764 goto out_put_ethernet; 765 } 766 767 dev->platform_data = pd; 768 pd->of_netdev = ethernet_dev; 769 pd->nr_chips = of_get_available_child_count(np); 770 if (pd->nr_chips > DSA_MAX_SWITCHES) 771 pd->nr_chips = DSA_MAX_SWITCHES; 772 773 pd->chip = kcalloc(pd->nr_chips, sizeof(struct dsa_chip_data), 774 GFP_KERNEL); 775 if (!pd->chip) { 776 ret = -ENOMEM; 777 goto out_free; 778 } 779 780 chip_index = -1; 781 for_each_available_child_of_node(np, child) { 782 int i; 783 784 chip_index++; 785 cd = &pd->chip[chip_index]; 786 787 cd->of_node = child; 788 789 /* Initialize the routing table */ 790 for (i = 0; i < DSA_MAX_SWITCHES; ++i) 791 cd->rtable[i] = DSA_RTABLE_NONE; 792 793 /* When assigning the host device, increment its refcount */ 794 cd->host_dev = get_device(&mdio_bus->dev); 795 796 sw_addr = of_get_property(child, "reg", NULL); 797 if (!sw_addr) 798 continue; 799 800 cd->sw_addr = be32_to_cpup(sw_addr); 801 if (cd->sw_addr >= PHY_MAX_ADDR) 802 continue; 803 804 if (!of_property_read_u32(child, "eeprom-length", &eeprom_len)) 805 cd->eeprom_len = eeprom_len; 806 807 mdio = of_parse_phandle(child, "mii-bus", 0); 808 if (mdio) { 809 mdio_bus_switch = of_mdio_find_bus(mdio); 810 if (!mdio_bus_switch) { 811 ret = -EPROBE_DEFER; 812 goto out_free_chip; 813 } 814 815 /* Drop the mdio_bus device ref, replacing the host 816 * device with the mdio_bus_switch device, keeping 817 * the refcount from of_mdio_find_bus() above. 818 */ 819 put_device(cd->host_dev); 820 cd->host_dev = &mdio_bus_switch->dev; 821 } 822 823 for_each_available_child_of_node(child, port) { 824 port_reg = of_get_property(port, "reg", NULL); 825 if (!port_reg) 826 continue; 827 828 port_index = be32_to_cpup(port_reg); 829 if (port_index >= DSA_MAX_PORTS) 830 break; 831 832 port_name = of_get_property(port, "label", NULL); 833 if (!port_name) 834 continue; 835 836 cd->port_dn[port_index] = port; 837 838 cd->port_names[port_index] = kstrdup(port_name, 839 GFP_KERNEL); 840 if (!cd->port_names[port_index]) { 841 ret = -ENOMEM; 842 goto out_free_chip; 843 } 844 845 ret = dsa_of_probe_links(pd, cd, chip_index, 846 port_index, port, port_name); 847 if (ret) 848 goto out_free_chip; 849 850 } 851 } 852 853 /* The individual chips hold their own refcount on the mdio bus, 854 * so drop ours */ 855 put_device(&mdio_bus->dev); 856 857 return 0; 858 859 out_free_chip: 860 dsa_of_free_platform_data(pd); 861 out_free: 862 kfree(pd); 863 dev->platform_data = NULL; 864 out_put_ethernet: 865 put_device(ðernet_dev->dev); 866 out_put_mdio: 867 put_device(&mdio_bus->dev); 868 return ret; 869 } 870 871 static void dsa_of_remove(struct device *dev) 872 { 873 struct dsa_platform_data *pd = dev->platform_data; 874 875 if (!dev->of_node) 876 return; 877 878 dsa_of_free_platform_data(pd); 879 put_device(&pd->of_netdev->dev); 880 kfree(pd); 881 } 882 #else 883 static inline int dsa_of_probe(struct device *dev) 884 { 885 return 0; 886 } 887 888 static inline void dsa_of_remove(struct device *dev) 889 { 890 } 891 #endif 892 893 static int dsa_setup_dst(struct dsa_switch_tree *dst, struct net_device *dev, 894 struct device *parent, struct dsa_platform_data *pd) 895 { 896 int i; 897 unsigned configured = 0; 898 899 dst->pd = pd; 900 dst->master_netdev = dev; 901 dst->cpu_switch = -1; 902 dst->cpu_port = -1; 903 904 for (i = 0; i < pd->nr_chips; i++) { 905 struct dsa_switch *ds; 906 907 ds = dsa_switch_setup(dst, i, parent, pd->chip[i].host_dev); 908 if (IS_ERR(ds)) { 909 netdev_err(dev, "[%d]: couldn't create dsa switch instance (error %ld)\n", 910 i, PTR_ERR(ds)); 911 continue; 912 } 913 914 dst->ds[i] = ds; 915 916 ++configured; 917 } 918 919 /* 920 * If no switch was found, exit cleanly 921 */ 922 if (!configured) 923 return -EPROBE_DEFER; 924 925 /* 926 * If we use a tagging format that doesn't have an ethertype 927 * field, make sure that all packets from this point on get 928 * sent to the tag format's receive function. 929 */ 930 wmb(); 931 dev->dsa_ptr = (void *)dst; 932 933 return 0; 934 } 935 936 static int dsa_probe(struct platform_device *pdev) 937 { 938 struct dsa_platform_data *pd = pdev->dev.platform_data; 939 struct net_device *dev; 940 struct dsa_switch_tree *dst; 941 int ret; 942 943 pr_notice_once("Distributed Switch Architecture driver version %s\n", 944 dsa_driver_version); 945 946 if (pdev->dev.of_node) { 947 ret = dsa_of_probe(&pdev->dev); 948 if (ret) 949 return ret; 950 951 pd = pdev->dev.platform_data; 952 } 953 954 if (pd == NULL || (pd->netdev == NULL && pd->of_netdev == NULL)) 955 return -EINVAL; 956 957 if (pd->of_netdev) { 958 dev = pd->of_netdev; 959 dev_hold(dev); 960 } else { 961 dev = dev_to_net_device(pd->netdev); 962 } 963 if (dev == NULL) { 964 ret = -EPROBE_DEFER; 965 goto out; 966 } 967 968 if (dev->dsa_ptr != NULL) { 969 dev_put(dev); 970 ret = -EEXIST; 971 goto out; 972 } 973 974 dst = devm_kzalloc(&pdev->dev, sizeof(*dst), GFP_KERNEL); 975 if (dst == NULL) { 976 dev_put(dev); 977 ret = -ENOMEM; 978 goto out; 979 } 980 981 platform_set_drvdata(pdev, dst); 982 983 ret = dsa_setup_dst(dst, dev, &pdev->dev, pd); 984 if (ret) { 985 dev_put(dev); 986 goto out; 987 } 988 989 return 0; 990 991 out: 992 dsa_of_remove(&pdev->dev); 993 994 return ret; 995 } 996 997 static void dsa_remove_dst(struct dsa_switch_tree *dst) 998 { 999 int i; 1000 1001 dst->master_netdev->dsa_ptr = NULL; 1002 1003 /* If we used a tagging format that doesn't have an ethertype 1004 * field, make sure that all packets from this point get sent 1005 * without the tag and go through the regular receive path. 1006 */ 1007 wmb(); 1008 1009 for (i = 0; i < dst->pd->nr_chips; i++) { 1010 struct dsa_switch *ds = dst->ds[i]; 1011 1012 if (ds) 1013 dsa_switch_destroy(ds); 1014 } 1015 1016 dsa_cpu_port_ethtool_restore(dst->ds[0]); 1017 1018 dev_put(dst->master_netdev); 1019 } 1020 1021 static int dsa_remove(struct platform_device *pdev) 1022 { 1023 struct dsa_switch_tree *dst = platform_get_drvdata(pdev); 1024 1025 dsa_remove_dst(dst); 1026 dsa_of_remove(&pdev->dev); 1027 1028 return 0; 1029 } 1030 1031 static void dsa_shutdown(struct platform_device *pdev) 1032 { 1033 } 1034 1035 static int dsa_switch_rcv(struct sk_buff *skb, struct net_device *dev, 1036 struct packet_type *pt, struct net_device *orig_dev) 1037 { 1038 struct dsa_switch_tree *dst = dev->dsa_ptr; 1039 1040 if (unlikely(dst == NULL)) { 1041 kfree_skb(skb); 1042 return 0; 1043 } 1044 1045 return dst->rcv(skb, dev, pt, orig_dev); 1046 } 1047 1048 static struct packet_type dsa_pack_type __read_mostly = { 1049 .type = cpu_to_be16(ETH_P_XDSA), 1050 .func = dsa_switch_rcv, 1051 }; 1052 1053 static struct notifier_block dsa_netdevice_nb __read_mostly = { 1054 .notifier_call = dsa_slave_netdevice_event, 1055 }; 1056 1057 #ifdef CONFIG_PM_SLEEP 1058 static int dsa_suspend(struct device *d) 1059 { 1060 struct platform_device *pdev = to_platform_device(d); 1061 struct dsa_switch_tree *dst = platform_get_drvdata(pdev); 1062 int i, ret = 0; 1063 1064 for (i = 0; i < dst->pd->nr_chips; i++) { 1065 struct dsa_switch *ds = dst->ds[i]; 1066 1067 if (ds != NULL) 1068 ret = dsa_switch_suspend(ds); 1069 } 1070 1071 return ret; 1072 } 1073 1074 static int dsa_resume(struct device *d) 1075 { 1076 struct platform_device *pdev = to_platform_device(d); 1077 struct dsa_switch_tree *dst = platform_get_drvdata(pdev); 1078 int i, ret = 0; 1079 1080 for (i = 0; i < dst->pd->nr_chips; i++) { 1081 struct dsa_switch *ds = dst->ds[i]; 1082 1083 if (ds != NULL) 1084 ret = dsa_switch_resume(ds); 1085 } 1086 1087 return ret; 1088 } 1089 #endif 1090 1091 static SIMPLE_DEV_PM_OPS(dsa_pm_ops, dsa_suspend, dsa_resume); 1092 1093 static const struct of_device_id dsa_of_match_table[] = { 1094 { .compatible = "marvell,dsa", }, 1095 {} 1096 }; 1097 MODULE_DEVICE_TABLE(of, dsa_of_match_table); 1098 1099 static struct platform_driver dsa_driver = { 1100 .probe = dsa_probe, 1101 .remove = dsa_remove, 1102 .shutdown = dsa_shutdown, 1103 .driver = { 1104 .name = "dsa", 1105 .of_match_table = dsa_of_match_table, 1106 .pm = &dsa_pm_ops, 1107 }, 1108 }; 1109 1110 static int __init dsa_init_module(void) 1111 { 1112 int rc; 1113 1114 register_netdevice_notifier(&dsa_netdevice_nb); 1115 1116 rc = platform_driver_register(&dsa_driver); 1117 if (rc) 1118 return rc; 1119 1120 dev_add_pack(&dsa_pack_type); 1121 1122 return 0; 1123 } 1124 module_init(dsa_init_module); 1125 1126 static void __exit dsa_cleanup_module(void) 1127 { 1128 unregister_netdevice_notifier(&dsa_netdevice_nb); 1129 dev_remove_pack(&dsa_pack_type); 1130 platform_driver_unregister(&dsa_driver); 1131 } 1132 module_exit(dsa_cleanup_module); 1133 1134 MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>"); 1135 MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips"); 1136 MODULE_LICENSE("GPL"); 1137 MODULE_ALIAS("platform:dsa"); 1138