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 #ifdef CONFIG_NET_DSA_TAG_QCA 58 [DSA_TAG_PROTO_QCA] = &qca_netdev_ops, 59 #endif 60 [DSA_TAG_PROTO_NONE] = &none_ops, 61 }; 62 63 /* switch driver registration ***********************************************/ 64 static DEFINE_MUTEX(dsa_switch_drivers_mutex); 65 static LIST_HEAD(dsa_switch_drivers); 66 67 void register_switch_driver(struct dsa_switch_ops *ops) 68 { 69 mutex_lock(&dsa_switch_drivers_mutex); 70 list_add_tail(&ops->list, &dsa_switch_drivers); 71 mutex_unlock(&dsa_switch_drivers_mutex); 72 } 73 EXPORT_SYMBOL_GPL(register_switch_driver); 74 75 void unregister_switch_driver(struct dsa_switch_ops *ops) 76 { 77 mutex_lock(&dsa_switch_drivers_mutex); 78 list_del_init(&ops->list); 79 mutex_unlock(&dsa_switch_drivers_mutex); 80 } 81 EXPORT_SYMBOL_GPL(unregister_switch_driver); 82 83 static struct dsa_switch_ops * 84 dsa_switch_probe(struct device *parent, struct device *host_dev, int sw_addr, 85 const char **_name, void **priv) 86 { 87 struct dsa_switch_ops *ret; 88 struct list_head *list; 89 const char *name; 90 91 ret = NULL; 92 name = NULL; 93 94 mutex_lock(&dsa_switch_drivers_mutex); 95 list_for_each(list, &dsa_switch_drivers) { 96 struct dsa_switch_ops *ops; 97 98 ops = list_entry(list, struct dsa_switch_ops, list); 99 100 name = ops->probe(parent, host_dev, sw_addr, priv); 101 if (name != NULL) { 102 ret = ops; 103 break; 104 } 105 } 106 mutex_unlock(&dsa_switch_drivers_mutex); 107 108 *_name = name; 109 110 return ret; 111 } 112 113 /* hwmon support ************************************************************/ 114 115 #ifdef CONFIG_NET_DSA_HWMON 116 117 static ssize_t temp1_input_show(struct device *dev, 118 struct device_attribute *attr, char *buf) 119 { 120 struct dsa_switch *ds = dev_get_drvdata(dev); 121 int temp, ret; 122 123 ret = ds->ops->get_temp(ds, &temp); 124 if (ret < 0) 125 return ret; 126 127 return sprintf(buf, "%d\n", temp * 1000); 128 } 129 static DEVICE_ATTR_RO(temp1_input); 130 131 static ssize_t temp1_max_show(struct device *dev, 132 struct device_attribute *attr, char *buf) 133 { 134 struct dsa_switch *ds = dev_get_drvdata(dev); 135 int temp, ret; 136 137 ret = ds->ops->get_temp_limit(ds, &temp); 138 if (ret < 0) 139 return ret; 140 141 return sprintf(buf, "%d\n", temp * 1000); 142 } 143 144 static ssize_t temp1_max_store(struct device *dev, 145 struct device_attribute *attr, const char *buf, 146 size_t count) 147 { 148 struct dsa_switch *ds = dev_get_drvdata(dev); 149 int temp, ret; 150 151 ret = kstrtoint(buf, 0, &temp); 152 if (ret < 0) 153 return ret; 154 155 ret = ds->ops->set_temp_limit(ds, DIV_ROUND_CLOSEST(temp, 1000)); 156 if (ret < 0) 157 return ret; 158 159 return count; 160 } 161 static DEVICE_ATTR_RW(temp1_max); 162 163 static ssize_t temp1_max_alarm_show(struct device *dev, 164 struct device_attribute *attr, char *buf) 165 { 166 struct dsa_switch *ds = dev_get_drvdata(dev); 167 bool alarm; 168 int ret; 169 170 ret = ds->ops->get_temp_alarm(ds, &alarm); 171 if (ret < 0) 172 return ret; 173 174 return sprintf(buf, "%d\n", alarm); 175 } 176 static DEVICE_ATTR_RO(temp1_max_alarm); 177 178 static struct attribute *dsa_hwmon_attrs[] = { 179 &dev_attr_temp1_input.attr, /* 0 */ 180 &dev_attr_temp1_max.attr, /* 1 */ 181 &dev_attr_temp1_max_alarm.attr, /* 2 */ 182 NULL 183 }; 184 185 static umode_t dsa_hwmon_attrs_visible(struct kobject *kobj, 186 struct attribute *attr, int index) 187 { 188 struct device *dev = container_of(kobj, struct device, kobj); 189 struct dsa_switch *ds = dev_get_drvdata(dev); 190 struct dsa_switch_ops *ops = ds->ops; 191 umode_t mode = attr->mode; 192 193 if (index == 1) { 194 if (!ops->get_temp_limit) 195 mode = 0; 196 else if (!ops->set_temp_limit) 197 mode &= ~S_IWUSR; 198 } else if (index == 2 && !ops->get_temp_alarm) { 199 mode = 0; 200 } 201 return mode; 202 } 203 204 static const struct attribute_group dsa_hwmon_group = { 205 .attrs = dsa_hwmon_attrs, 206 .is_visible = dsa_hwmon_attrs_visible, 207 }; 208 __ATTRIBUTE_GROUPS(dsa_hwmon); 209 210 #endif /* CONFIG_NET_DSA_HWMON */ 211 212 /* basic switch operations **************************************************/ 213 int dsa_cpu_dsa_setup(struct dsa_switch *ds, struct device *dev, 214 struct device_node *port_dn, int port) 215 { 216 struct phy_device *phydev; 217 int ret, mode; 218 219 if (of_phy_is_fixed_link(port_dn)) { 220 ret = of_phy_register_fixed_link(port_dn); 221 if (ret) { 222 dev_err(dev, "failed to register fixed PHY\n"); 223 return ret; 224 } 225 phydev = of_phy_find_device(port_dn); 226 227 mode = of_get_phy_mode(port_dn); 228 if (mode < 0) 229 mode = PHY_INTERFACE_MODE_NA; 230 phydev->interface = mode; 231 232 genphy_config_init(phydev); 233 genphy_read_status(phydev); 234 if (ds->ops->adjust_link) 235 ds->ops->adjust_link(ds, port, phydev); 236 237 put_device(&phydev->mdio.dev); 238 } 239 240 return 0; 241 } 242 243 static int dsa_cpu_dsa_setups(struct dsa_switch *ds, struct device *dev) 244 { 245 struct device_node *port_dn; 246 int ret, port; 247 248 for (port = 0; port < DSA_MAX_PORTS; port++) { 249 if (!(dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))) 250 continue; 251 252 port_dn = ds->ports[port].dn; 253 ret = dsa_cpu_dsa_setup(ds, dev, port_dn, port); 254 if (ret) 255 return ret; 256 } 257 return 0; 258 } 259 260 const struct dsa_device_ops *dsa_resolve_tag_protocol(int tag_protocol) 261 { 262 const struct dsa_device_ops *ops; 263 264 if (tag_protocol >= DSA_TAG_LAST) 265 return ERR_PTR(-EINVAL); 266 ops = dsa_device_ops[tag_protocol]; 267 268 if (!ops) 269 return ERR_PTR(-ENOPROTOOPT); 270 271 return ops; 272 } 273 274 int dsa_cpu_port_ethtool_setup(struct dsa_switch *ds) 275 { 276 struct net_device *master; 277 struct ethtool_ops *cpu_ops; 278 279 master = ds->dst->master_netdev; 280 if (ds->master_netdev) 281 master = ds->master_netdev; 282 283 cpu_ops = devm_kzalloc(ds->dev, sizeof(*cpu_ops), GFP_KERNEL); 284 if (!cpu_ops) 285 return -ENOMEM; 286 287 memcpy(&ds->dst->master_ethtool_ops, master->ethtool_ops, 288 sizeof(struct ethtool_ops)); 289 ds->dst->master_orig_ethtool_ops = master->ethtool_ops; 290 memcpy(cpu_ops, &ds->dst->master_ethtool_ops, 291 sizeof(struct ethtool_ops)); 292 dsa_cpu_port_ethtool_init(cpu_ops); 293 master->ethtool_ops = cpu_ops; 294 295 return 0; 296 } 297 298 void dsa_cpu_port_ethtool_restore(struct dsa_switch *ds) 299 { 300 struct net_device *master; 301 302 master = ds->dst->master_netdev; 303 if (ds->master_netdev) 304 master = ds->master_netdev; 305 306 master->ethtool_ops = ds->dst->master_orig_ethtool_ops; 307 } 308 309 static int dsa_switch_setup_one(struct dsa_switch *ds, struct device *parent) 310 { 311 struct dsa_switch_ops *ops = ds->ops; 312 struct dsa_switch_tree *dst = ds->dst; 313 struct dsa_chip_data *cd = ds->cd; 314 bool valid_name_found = false; 315 int index = ds->index; 316 int i, ret; 317 318 /* 319 * Validate supplied switch configuration. 320 */ 321 for (i = 0; i < DSA_MAX_PORTS; i++) { 322 char *name; 323 324 name = cd->port_names[i]; 325 if (name == NULL) 326 continue; 327 328 if (!strcmp(name, "cpu")) { 329 if (dst->cpu_switch != -1) { 330 netdev_err(dst->master_netdev, 331 "multiple cpu ports?!\n"); 332 ret = -EINVAL; 333 goto out; 334 } 335 dst->cpu_switch = index; 336 dst->cpu_port = i; 337 ds->cpu_port_mask |= 1 << i; 338 } else if (!strcmp(name, "dsa")) { 339 ds->dsa_port_mask |= 1 << i; 340 } else { 341 ds->enabled_port_mask |= 1 << i; 342 } 343 valid_name_found = true; 344 } 345 346 if (!valid_name_found && i == DSA_MAX_PORTS) { 347 ret = -EINVAL; 348 goto out; 349 } 350 351 /* Make the built-in MII bus mask match the number of ports, 352 * switch drivers can override this later 353 */ 354 ds->phys_mii_mask = ds->enabled_port_mask; 355 356 /* 357 * If the CPU connects to this switch, set the switch tree 358 * tagging protocol to the preferred tagging format of this 359 * switch. 360 */ 361 if (dst->cpu_switch == index) { 362 enum dsa_tag_protocol tag_protocol; 363 364 tag_protocol = ops->get_tag_protocol(ds); 365 dst->tag_ops = dsa_resolve_tag_protocol(tag_protocol); 366 if (IS_ERR(dst->tag_ops)) { 367 ret = PTR_ERR(dst->tag_ops); 368 goto out; 369 } 370 371 dst->rcv = dst->tag_ops->rcv; 372 } 373 374 memcpy(ds->rtable, cd->rtable, sizeof(ds->rtable)); 375 376 /* 377 * Do basic register setup. 378 */ 379 ret = ops->setup(ds); 380 if (ret < 0) 381 goto out; 382 383 if (ops->set_addr) { 384 ret = ops->set_addr(ds, dst->master_netdev->dev_addr); 385 if (ret < 0) 386 goto out; 387 } 388 389 if (!ds->slave_mii_bus && ops->phy_read) { 390 ds->slave_mii_bus = devm_mdiobus_alloc(parent); 391 if (!ds->slave_mii_bus) { 392 ret = -ENOMEM; 393 goto out; 394 } 395 dsa_slave_mii_bus_init(ds); 396 397 ret = mdiobus_register(ds->slave_mii_bus); 398 if (ret < 0) 399 goto out; 400 } 401 402 /* 403 * Create network devices for physical switch ports. 404 */ 405 for (i = 0; i < DSA_MAX_PORTS; i++) { 406 ds->ports[i].dn = cd->port_dn[i]; 407 408 if (!(ds->enabled_port_mask & (1 << i))) 409 continue; 410 411 ret = dsa_slave_create(ds, parent, i, cd->port_names[i]); 412 if (ret < 0) { 413 netdev_err(dst->master_netdev, "[%d]: can't create dsa slave device for port %d(%s): %d\n", 414 index, i, cd->port_names[i], ret); 415 ret = 0; 416 } 417 } 418 419 /* Perform configuration of the CPU and DSA ports */ 420 ret = dsa_cpu_dsa_setups(ds, parent); 421 if (ret < 0) { 422 netdev_err(dst->master_netdev, "[%d] : can't configure CPU and DSA ports\n", 423 index); 424 ret = 0; 425 } 426 427 ret = dsa_cpu_port_ethtool_setup(ds); 428 if (ret) 429 return ret; 430 431 #ifdef CONFIG_NET_DSA_HWMON 432 /* If the switch provides a temperature sensor, 433 * register with hardware monitoring subsystem. 434 * Treat registration error as non-fatal and ignore it. 435 */ 436 if (ops->get_temp) { 437 const char *netname = netdev_name(dst->master_netdev); 438 char hname[IFNAMSIZ + 1]; 439 int i, j; 440 441 /* Create valid hwmon 'name' attribute */ 442 for (i = j = 0; i < IFNAMSIZ && netname[i]; i++) { 443 if (isalnum(netname[i])) 444 hname[j++] = netname[i]; 445 } 446 hname[j] = '\0'; 447 scnprintf(ds->hwmon_name, sizeof(ds->hwmon_name), "%s_dsa%d", 448 hname, index); 449 ds->hwmon_dev = hwmon_device_register_with_groups(NULL, 450 ds->hwmon_name, ds, dsa_hwmon_groups); 451 if (IS_ERR(ds->hwmon_dev)) 452 ds->hwmon_dev = NULL; 453 } 454 #endif /* CONFIG_NET_DSA_HWMON */ 455 456 return ret; 457 458 out: 459 return ret; 460 } 461 462 static struct dsa_switch * 463 dsa_switch_setup(struct dsa_switch_tree *dst, int index, 464 struct device *parent, struct device *host_dev) 465 { 466 struct dsa_chip_data *cd = dst->pd->chip + index; 467 struct dsa_switch_ops *ops; 468 struct dsa_switch *ds; 469 int ret; 470 const char *name; 471 void *priv; 472 473 /* 474 * Probe for switch model. 475 */ 476 ops = dsa_switch_probe(parent, host_dev, cd->sw_addr, &name, &priv); 477 if (!ops) { 478 netdev_err(dst->master_netdev, "[%d]: could not detect attached switch\n", 479 index); 480 return ERR_PTR(-EINVAL); 481 } 482 netdev_info(dst->master_netdev, "[%d]: detected a %s switch\n", 483 index, name); 484 485 486 /* 487 * Allocate and initialise switch state. 488 */ 489 ds = devm_kzalloc(parent, sizeof(*ds), GFP_KERNEL); 490 if (ds == NULL) 491 return ERR_PTR(-ENOMEM); 492 493 ds->dst = dst; 494 ds->index = index; 495 ds->cd = cd; 496 ds->ops = ops; 497 ds->priv = priv; 498 ds->dev = parent; 499 500 ret = dsa_switch_setup_one(ds, parent); 501 if (ret) 502 return ERR_PTR(ret); 503 504 return ds; 505 } 506 507 void dsa_cpu_dsa_destroy(struct device_node *port_dn) 508 { 509 if (of_phy_is_fixed_link(port_dn)) 510 of_phy_deregister_fixed_link(port_dn); 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