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