[linux-2.6-block.git] / net / dsa / dsa.c

/*
 * net/dsa/dsa.c - Hardware switch handling
 * Copyright (c) 2008-2009 Marvell Semiconductor
 * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <linux/list.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <net/dsa.h>
#include <linux/of.h>
#include <linux/of_mdio.h>
#include <linux/of_platform.h>
#include "dsa_priv.h"

char dsa_driver_version[] = "0.1";


/* switch driver registration ***********************************************/
static DEFINE_MUTEX(dsa_switch_drivers_mutex);
static LIST_HEAD(dsa_switch_drivers);

void register_switch_driver(struct dsa_switch_driver *drv)
{
	mutex_lock(&dsa_switch_drivers_mutex);
	list_add_tail(&drv->list, &dsa_switch_drivers);
	mutex_unlock(&dsa_switch_drivers_mutex);
}
EXPORT_SYMBOL_GPL(register_switch_driver);

void unregister_switch_driver(struct dsa_switch_driver *drv)
{
	mutex_lock(&dsa_switch_drivers_mutex);
	list_del_init(&drv->list);
	mutex_unlock(&dsa_switch_drivers_mutex);
}
EXPORT_SYMBOL_GPL(unregister_switch_driver);

static struct dsa_switch_driver *
dsa_switch_probe(struct device *host_dev, int sw_addr, char **_name)
{
	struct dsa_switch_driver *ret;
	struct list_head *list;
	char *name;

	ret = NULL;
	name = NULL;

	mutex_lock(&dsa_switch_drivers_mutex);
	list_for_each(list, &dsa_switch_drivers) {
		struct dsa_switch_driver *drv;

		drv = list_entry(list, struct dsa_switch_driver, list);

		name = drv->probe(host_dev, sw_addr);
		if (name != NULL) {
			ret = drv;
			break;
		}
	}
	mutex_unlock(&dsa_switch_drivers_mutex);

	*_name = name;

	return ret;
}


/* basic switch operations **************************************************/
static struct dsa_switch *
dsa_switch_setup(struct dsa_switch_tree *dst, int index,
		 struct device *parent, struct device *host_dev)
{
	struct dsa_chip_data *pd = dst->pd->chip + index;
	struct dsa_switch_driver *drv;
	struct dsa_switch *ds;
	int ret;
	char *name;
	int i;
	bool valid_name_found = false;

	/*
	 * Probe for switch model.
	 */
	drv = dsa_switch_probe(host_dev, pd->sw_addr, &name);
	if (drv == NULL) {
		printk(KERN_ERR "%s[%d]: could not detect attached switch\n",
		       dst->master_netdev->name, index);
		return ERR_PTR(-EINVAL);
	}
	printk(KERN_INFO "%s[%d]: detected a %s switch\n",
		dst->master_netdev->name, index, name);


	/*
	 * Allocate and initialise switch state.
	 */
	ds = kzalloc(sizeof(*ds) + drv->priv_size, GFP_KERNEL);
	if (ds == NULL)
		return ERR_PTR(-ENOMEM);

	ds->dst = dst;
	ds->index = index;
	ds->pd = dst->pd->chip + index;
	ds->drv = drv;
	ds->master_dev = host_dev;

	/*
	 * Validate supplied switch configuration.
	 */
	for (i = 0; i < DSA_MAX_PORTS; i++) {
		char *name;

		name = pd->port_names[i];
		if (name == NULL)
			continue;

		if (!strcmp(name, "cpu")) {
			if (dst->cpu_switch != -1) {
				printk(KERN_ERR "multiple cpu ports?!\n");
				ret = -EINVAL;
				goto out;
			}
			dst->cpu_switch = index;
			dst->cpu_port = i;
		} else if (!strcmp(name, "dsa")) {
			ds->dsa_port_mask |= 1 << i;
		} else {
			ds->phys_port_mask |= 1 << i;
		}
		valid_name_found = true;
	}

	if (!valid_name_found && i == DSA_MAX_PORTS) {
		ret = -EINVAL;
		goto out;
	}

	/* Make the built-in MII bus mask match the number of ports,
	 * switch drivers can override this later
	 */
	ds->phys_mii_mask = ds->phys_port_mask;

	/*
	 * If the CPU connects to this switch, set the switch tree
	 * tagging protocol to the preferred tagging format of this
	 * switch.
	 */
	if (dst->cpu_switch == index) {
		switch (drv->tag_protocol) {
#ifdef CONFIG_NET_DSA_TAG_DSA
		case DSA_TAG_PROTO_DSA:
			dst->rcv = dsa_netdev_ops.rcv;
			break;
#endif
#ifdef CONFIG_NET_DSA_TAG_EDSA
		case DSA_TAG_PROTO_EDSA:
			dst->rcv = edsa_netdev_ops.rcv;
			break;
#endif
#ifdef CONFIG_NET_DSA_TAG_TRAILER
		case DSA_TAG_PROTO_TRAILER:
			dst->rcv = trailer_netdev_ops.rcv;
			break;
#endif
#ifdef CONFIG_NET_DSA_TAG_BRCM
		case DSA_TAG_PROTO_BRCM:
			dst->rcv = brcm_netdev_ops.rcv;
			break;
#endif
		default:
			break;
		}

		dst->tag_protocol = drv->tag_protocol;
	}

	/*
	 * Do basic register setup.
	 */
	ret = drv->setup(ds);
	if (ret < 0)
		goto out;

	ret = drv->set_addr(ds, dst->master_netdev->dev_addr);
	if (ret < 0)
		goto out;

	ds->slave_mii_bus = mdiobus_alloc();
	if (ds->slave_mii_bus == NULL) {
		ret = -ENOMEM;
		goto out;
	}
	dsa_slave_mii_bus_init(ds);

	ret = mdiobus_register(ds->slave_mii_bus);
	if (ret < 0)
		goto out_free;


	/*
	 * Create network devices for physical switch ports.
	 */
	for (i = 0; i < DSA_MAX_PORTS; i++) {
		struct net_device *slave_dev;

		if (!(ds->phys_port_mask & (1 << i)))
			continue;

		slave_dev = dsa_slave_create(ds, parent, i, pd->port_names[i]);
		if (slave_dev == NULL) {
			printk(KERN_ERR "%s[%d]: can't create dsa "
			       "slave device for port %d(%s)\n",
			       dst->master_netdev->name,
			       index, i, pd->port_names[i]);
			continue;
		}

		ds->ports[i] = slave_dev;
	}

	return ds;

out_free:
	mdiobus_free(ds->slave_mii_bus);
out:
	kfree(ds);
	return ERR_PTR(ret);
}

static void dsa_switch_destroy(struct dsa_switch *ds)
{
}

#ifdef CONFIG_PM_SLEEP
static int dsa_switch_suspend(struct dsa_switch *ds)
{
	int i, ret = 0;

	/* Suspend slave network devices */
	for (i = 0; i < DSA_MAX_PORTS; i++) {
		if (!(ds->phys_port_mask & (1 << i)))
			continue;

		ret = dsa_slave_suspend(ds->ports[i]);
		if (ret)
			return ret;
	}

	if (ds->drv->suspend)
		ret = ds->drv->suspend(ds);

	return ret;
}

static int dsa_switch_resume(struct dsa_switch *ds)
{
	int i, ret = 0;

	if (ds->drv->resume)
		ret = ds->drv->resume(ds);

	if (ret)
		return ret;

	/* Resume slave network devices */
	for (i = 0; i < DSA_MAX_PORTS; i++) {
		if (!(ds->phys_port_mask & (1 << i)))
			continue;

		ret = dsa_slave_resume(ds->ports[i]);
		if (ret)
			return ret;
	}

	return 0;
}
#endif


/* link polling *************************************************************/
static void dsa_link_poll_work(struct work_struct *ugly)
{
	struct dsa_switch_tree *dst;
	int i;

	dst = container_of(ugly, struct dsa_switch_tree, link_poll_work);

	for (i = 0; i < dst->pd->nr_chips; i++) {
		struct dsa_switch *ds = dst->ds[i];

		if (ds != NULL && ds->drv->poll_link != NULL)
			ds->drv->poll_link(ds);
	}

	mod_timer(&dst->link_poll_timer, round_jiffies(jiffies + HZ));
}

static void dsa_link_poll_timer(unsigned long _dst)
{
	struct dsa_switch_tree *dst = (void *)_dst;

	schedule_work(&dst->link_poll_work);
}


/* platform driver init and cleanup *****************************************/
static int dev_is_class(struct device *dev, void *class)
{
	if (dev->class != NULL && !strcmp(dev->class->name, class))
		return 1;

	return 0;
}

static struct device *dev_find_class(struct device *parent, char *class)
{
	if (dev_is_class(parent, class)) {
		get_device(parent);
		return parent;
	}

	return device_find_child(parent, class, dev_is_class);
}

struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev)
{
	struct device *d;

	d = dev_find_class(dev, "mdio_bus");
	if (d != NULL) {
		struct mii_bus *bus;

		bus = to_mii_bus(d);
		put_device(d);

		return bus;
	}

	return NULL;
}
EXPORT_SYMBOL_GPL(dsa_host_dev_to_mii_bus);

static struct net_device *dev_to_net_device(struct device *dev)
{
	struct device *d;

	d = dev_find_class(dev, "net");
	if (d != NULL) {
		struct net_device *nd;

		nd = to_net_dev(d);
		dev_hold(nd);
		put_device(d);

		return nd;
	}

	return NULL;
}

#ifdef CONFIG_OF
static int dsa_of_setup_routing_table(struct dsa_platform_data *pd,
					struct dsa_chip_data *cd,
					int chip_index,
					struct device_node *link)
{
	int ret;
	const __be32 *reg;
	int link_port_addr;
	int link_sw_addr;
	struct device_node *parent_sw;
	int len;

	parent_sw = of_get_parent(link);
	if (!parent_sw)
		return -EINVAL;

	reg = of_get_property(parent_sw, "reg", &len);
	if (!reg || (len != sizeof(*reg) * 2))
		return -EINVAL;

	link_sw_addr = be32_to_cpup(reg + 1);

	if (link_sw_addr >= pd->nr_chips)
		return -EINVAL;

	/* First time routing table allocation */
	if (!cd->rtable) {
		cd->rtable = kmalloc(pd->nr_chips * sizeof(s8), GFP_KERNEL);
		if (!cd->rtable)
			return -ENOMEM;

		/* default to no valid uplink/downlink */
		memset(cd->rtable, -1, pd->nr_chips * sizeof(s8));
	}

	reg = of_get_property(link, "reg", NULL);
	if (!reg) {
		ret = -EINVAL;
		goto out;
	}

	link_port_addr = be32_to_cpup(reg);

	cd->rtable[link_sw_addr] = link_port_addr;

	return 0;
out:
	kfree(cd->rtable);
	return ret;
}

static void dsa_of_free_platform_data(struct dsa_platform_data *pd)
{
	int i;
	int port_index;

	for (i = 0; i < pd->nr_chips; i++) {
		port_index = 0;
		while (port_index < DSA_MAX_PORTS) {
			kfree(pd->chip[i].port_names[port_index]);
			port_index++;
		}
		kfree(pd->chip[i].rtable);
	}
	kfree(pd->chip);
}

static int dsa_of_probe(struct platform_device *pdev)
{
	struct device_node *np = pdev->dev.of_node;
	struct device_node *child, *mdio, *ethernet, *port, *link;
	struct mii_bus *mdio_bus;
	struct platform_device *ethernet_dev;
	struct dsa_platform_data *pd;
	struct dsa_chip_data *cd;
	const char *port_name;
	int chip_index, port_index;
	const unsigned int *sw_addr, *port_reg;
	int ret;

	mdio = of_parse_phandle(np, "dsa,mii-bus", 0);
	if (!mdio)
		return -EINVAL;

	mdio_bus = of_mdio_find_bus(mdio);
	if (!mdio_bus)
		return -EINVAL;

	ethernet = of_parse_phandle(np, "dsa,ethernet", 0);
	if (!ethernet)
		return -EINVAL;

	ethernet_dev = of_find_device_by_node(ethernet);
	if (!ethernet_dev)
		return -ENODEV;

	pd = kzalloc(sizeof(*pd), GFP_KERNEL);
	if (!pd)
		return -ENOMEM;

	pdev->dev.platform_data = pd;
	pd->netdev = &ethernet_dev->dev;
	pd->nr_chips = of_get_child_count(np);
	if (pd->nr_chips > DSA_MAX_SWITCHES)
		pd->nr_chips = DSA_MAX_SWITCHES;

	pd->chip = kzalloc(pd->nr_chips * sizeof(struct dsa_chip_data),
			GFP_KERNEL);
	if (!pd->chip) {
		ret = -ENOMEM;
		goto out_free;
	}

	chip_index = -1;
	for_each_available_child_of_node(np, child) {
		chip_index++;
		cd = &pd->chip[chip_index];

		cd->of_node = child;
		cd->host_dev = &mdio_bus->dev;

		sw_addr = of_get_property(child, "reg", NULL);
		if (!sw_addr)
			continue;

		cd->sw_addr = be32_to_cpup(sw_addr);
		if (cd->sw_addr > PHY_MAX_ADDR)
			continue;

		for_each_available_child_of_node(child, port) {
			port_reg = of_get_property(port, "reg", NULL);
			if (!port_reg)
				continue;

			port_index = be32_to_cpup(port_reg);

			port_name = of_get_property(port, "label", NULL);
			if (!port_name)
				continue;

			cd->port_dn[port_index] = port;

			cd->port_names[port_index] = kstrdup(port_name,
					GFP_KERNEL);
			if (!cd->port_names[port_index]) {
				ret = -ENOMEM;
				goto out_free_chip;
			}

			link = of_parse_phandle(port, "link", 0);

			if (!strcmp(port_name, "dsa") && link &&
					pd->nr_chips > 1) {
				ret = dsa_of_setup_routing_table(pd, cd,
						chip_index, link);
				if (ret)
					goto out_free_chip;
			}

			if (port_index == DSA_MAX_PORTS)
				break;
		}
	}

	return 0;

out_free_chip:
	dsa_of_free_platform_data(pd);
out_free:
	kfree(pd);
	pdev->dev.platform_data = NULL;
	return ret;
}

static void dsa_of_remove(struct platform_device *pdev)
{
	struct dsa_platform_data *pd = pdev->dev.platform_data;

	if (!pdev->dev.of_node)
		return;

	dsa_of_free_platform_data(pd);
	kfree(pd);
}
#else
static inline int dsa_of_probe(struct platform_device *pdev)
{
	return 0;
}

static inline void dsa_of_remove(struct platform_device *pdev)
{
}
#endif

static int dsa_probe(struct platform_device *pdev)
{
	static int dsa_version_printed;
	struct dsa_platform_data *pd = pdev->dev.platform_data;
	struct net_device *dev;
	struct dsa_switch_tree *dst;
	int i, ret;

	if (!dsa_version_printed++)
		printk(KERN_NOTICE "Distributed Switch Architecture "
			"driver version %s\n", dsa_driver_version);

	if (pdev->dev.of_node) {
		ret = dsa_of_probe(pdev);
		if (ret)
			return ret;

		pd = pdev->dev.platform_data;
	}

	if (pd == NULL || pd->netdev == NULL)
		return -EINVAL;

	dev = dev_to_net_device(pd->netdev);
	if (dev == NULL) {
		ret = -EINVAL;
		goto out;
	}

	if (dev->dsa_ptr != NULL) {
		dev_put(dev);
		ret = -EEXIST;
		goto out;
	}

	dst = kzalloc(sizeof(*dst), GFP_KERNEL);
	if (dst == NULL) {
		dev_put(dev);
		ret = -ENOMEM;
		goto out;
	}

	platform_set_drvdata(pdev, dst);

	dst->pd = pd;
	dst->master_netdev = dev;
	dst->cpu_switch = -1;
	dst->cpu_port = -1;

	for (i = 0; i < pd->nr_chips; i++) {
		struct dsa_switch *ds;

		ds = dsa_switch_setup(dst, i, &pdev->dev, pd->chip[i].host_dev);
		if (IS_ERR(ds)) {
			printk(KERN_ERR "%s[%d]: couldn't create dsa switch "
				"instance (error %ld)\n", dev->name, i,
				PTR_ERR(ds));
			continue;
		}

		dst->ds[i] = ds;
		if (ds->drv->poll_link != NULL)
			dst->link_poll_needed = 1;
	}

	/*
	 * If we use a tagging format that doesn't have an ethertype
	 * field, make sure that all packets from this point on get
	 * sent to the tag format's receive function.
	 */
	wmb();
	dev->dsa_ptr = (void *)dst;

	if (dst->link_poll_needed) {
		INIT_WORK(&dst->link_poll_work, dsa_link_poll_work);
		init_timer(&dst->link_poll_timer);
		dst->link_poll_timer.data = (unsigned long)dst;
		dst->link_poll_timer.function = dsa_link_poll_timer;
		dst->link_poll_timer.expires = round_jiffies(jiffies + HZ);
		add_timer(&dst->link_poll_timer);
	}

	return 0;

out:
	dsa_of_remove(pdev);

	return ret;
}

static int dsa_remove(struct platform_device *pdev)
{
	struct dsa_switch_tree *dst = platform_get_drvdata(pdev);
	int i;

	if (dst->link_poll_needed)
		del_timer_sync(&dst->link_poll_timer);

	flush_work(&dst->link_poll_work);

	for (i = 0; i < dst->pd->nr_chips; i++) {
		struct dsa_switch *ds = dst->ds[i];

		if (ds != NULL)
			dsa_switch_destroy(ds);
	}

	dsa_of_remove(pdev);

	return 0;
}

static void dsa_shutdown(struct platform_device *pdev)
{
}

static int dsa_switch_rcv(struct sk_buff *skb, struct net_device *dev,
			  struct packet_type *pt, struct net_device *orig_dev)
{
	struct dsa_switch_tree *dst = dev->dsa_ptr;

	if (unlikely(dst == NULL)) {
		kfree_skb(skb);
		return 0;
	}

	return dst->rcv(skb, dev, pt, orig_dev);
}

static struct packet_type dsa_pack_type __read_mostly = {
	.type	= cpu_to_be16(ETH_P_XDSA),
	.func	= dsa_switch_rcv,
};

#ifdef CONFIG_PM_SLEEP
static int dsa_suspend(struct device *d)
{
	struct platform_device *pdev = to_platform_device(d);
	struct dsa_switch_tree *dst = platform_get_drvdata(pdev);
	int i, ret = 0;

	for (i = 0; i < dst->pd->nr_chips; i++) {
		struct dsa_switch *ds = dst->ds[i];

		if (ds != NULL)
			ret = dsa_switch_suspend(ds);
	}

	return ret;
}

static int dsa_resume(struct device *d)
{
	struct platform_device *pdev = to_platform_device(d);
	struct dsa_switch_tree *dst = platform_get_drvdata(pdev);
	int i, ret = 0;

	for (i = 0; i < dst->pd->nr_chips; i++) {
		struct dsa_switch *ds = dst->ds[i];

		if (ds != NULL)
			ret = dsa_switch_resume(ds);
	}

	return ret;
}
#endif

static SIMPLE_DEV_PM_OPS(dsa_pm_ops, dsa_suspend, dsa_resume);

static const struct of_device_id dsa_of_match_table[] = {
	{ .compatible = "brcm,bcm7445-switch-v4.0" },
	{ .compatible = "marvell,dsa", },
	{}
};
MODULE_DEVICE_TABLE(of, dsa_of_match_table);

static struct platform_driver dsa_driver = {
	.probe		= dsa_probe,
	.remove		= dsa_remove,
	.shutdown	= dsa_shutdown,
	.driver = {
		.name	= "dsa",
		.owner	= THIS_MODULE,
		.of_match_table = dsa_of_match_table,
		.pm	= &dsa_pm_ops,
	},
};

static int __init dsa_init_module(void)
{
	int rc;

	rc = platform_driver_register(&dsa_driver);
	if (rc)
		return rc;

	dev_add_pack(&dsa_pack_type);

	return 0;
}
module_init(dsa_init_module);

static void __exit dsa_cleanup_module(void)
{
	dev_remove_pack(&dsa_pack_type);
	platform_driver_unregister(&dsa_driver);
}
module_exit(dsa_cleanup_module);

MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>");
MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:dsa");
Commit	Line	Data
91da11f8 LB	1	/*
91da11f8 LB	2	* net/dsa/dsa.c - Hardware switch handling
e84665c9	3	* Copyright (c) 2008-2009 Marvell Semiconductor
5e95329b	4	* Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
91da11f8 LB	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/list.h>
91da11f8	13	#include <linux/platform_device.h>
5a0e3ad6	14	#include <linux/slab.h>
3a9a231d	15	#include <linux/module.h>
91da11f8	16	#include <net/dsa.h>
5e95329b FF	17	#include <linux/of.h>
	18	#include <linux/of_mdio.h>
	19	#include <linux/of_platform.h>
91da11f8 LB	20	#include "dsa_priv.h"
	21
	22	char dsa_driver_version[] = "0.1";
	23
	24
	25	/* switch driver registration ***********************************************/
	26	static DEFINE_MUTEX(dsa_switch_drivers_mutex);
	27	static LIST_HEAD(dsa_switch_drivers);
	28
	29	void register_switch_driver(struct dsa_switch_driver *drv)
	30	{
	31	mutex_lock(&dsa_switch_drivers_mutex);
	32	list_add_tail(&drv->list, &dsa_switch_drivers);
	33	mutex_unlock(&dsa_switch_drivers_mutex);
	34	}
ad293b8a	35	EXPORT_SYMBOL_GPL(register_switch_driver);
91da11f8 LB	36
	37	void unregister_switch_driver(struct dsa_switch_driver *drv)
	38	{
	39	mutex_lock(&dsa_switch_drivers_mutex);
	40	list_del_init(&drv->list);
	41	mutex_unlock(&dsa_switch_drivers_mutex);
	42	}
ad293b8a	43	EXPORT_SYMBOL_GPL(unregister_switch_driver);
91da11f8 LB	44
91da11f8 LB	45	static struct dsa_switch_driver *
b4d2394d	46	dsa_switch_probe(struct device host_dev, int sw_addr, char *_name)
91da11f8 LB	47	{
	48	struct dsa_switch_driver *ret;
	49	struct list_head *list;
	50	char *name;
	51
	52	ret = NULL;
	53	name = NULL;
	54
	55	mutex_lock(&dsa_switch_drivers_mutex);
	56	list_for_each(list, &dsa_switch_drivers) {
	57	struct dsa_switch_driver *drv;
	58
	59	drv = list_entry(list, struct dsa_switch_driver, list);
	60
b4d2394d	61	name = drv->probe(host_dev, sw_addr);
91da11f8 LB	62	if (name != NULL) {
	63	ret = drv;
	64	break;
	65	}
	66	}
	67	mutex_unlock(&dsa_switch_drivers_mutex);
	68
	69	*_name = name;
	70
	71	return ret;
	72	}
	73
	74
	75	/* basic switch operations **************************************************/
	76	static struct dsa_switch *
e84665c9	77	dsa_switch_setup(struct dsa_switch_tree *dst, int index,
b4d2394d	78	struct device parent, struct device host_dev)
91da11f8	79	{
e84665c9 LB	80	struct dsa_chip_data *pd = dst->pd->chip + index;
e84665c9 LB	81	struct dsa_switch_driver *drv;
91da11f8 LB	82	struct dsa_switch *ds;
91da11f8 LB	83	int ret;
91da11f8 LB	84	char *name;
91da11f8 LB	85	int i;
f9bf5a2c	86	bool valid_name_found = false;
91da11f8 LB	87
	88	/*
	89	* Probe for switch model.
	90	*/
b4d2394d	91	drv = dsa_switch_probe(host_dev, pd->sw_addr, &name);
91da11f8	92	if (drv == NULL) {
e84665c9 LB	93	printk(KERN_ERR "%s[%d]: could not detect attached switch\n",
e84665c9 LB	94	dst->master_netdev->name, index);
91da11f8 LB	95	return ERR_PTR(-EINVAL);
91da11f8 LB	96	}
e84665c9 LB	97	printk(KERN_INFO "%s[%d]: detected a %s switch\n",
e84665c9 LB	98	dst->master_netdev->name, index, name);
91da11f8 LB	99
	100
	101	/*
	102	* Allocate and initialise switch state.
	103	*/
	104	ds = kzalloc(sizeof(*ds) + drv->priv_size, GFP_KERNEL);
	105	if (ds == NULL)
	106	return ERR_PTR(-ENOMEM);
	107
e84665c9 LB	108	ds->dst = dst;
	109	ds->index = index;
	110	ds->pd = dst->pd->chip + index;
91da11f8	111	ds->drv = drv;
b4d2394d	112	ds->master_dev = host_dev;
91da11f8 LB	113
	114	/*
	115	* Validate supplied switch configuration.
	116	*/
91da11f8 LB	117	for (i = 0; i < DSA_MAX_PORTS; i++) {
	118	char *name;
	119
	120	name = pd->port_names[i];
	121	if (name == NULL)
	122	continue;
	123
	124	if (!strcmp(name, "cpu")) {
e84665c9	125	if (dst->cpu_switch != -1) {
91da11f8 LB	126	printk(KERN_ERR "multiple cpu ports?!\n");
	127	ret = -EINVAL;
	128	goto out;
	129	}
e84665c9 LB	130	dst->cpu_switch = index;
	131	dst->cpu_port = i;
	132	} else if (!strcmp(name, "dsa")) {
	133	ds->dsa_port_mask \|= 1 << i;
91da11f8	134	} else {
e84665c9	135	ds->phys_port_mask \|= 1 << i;
91da11f8	136	}
f9bf5a2c	137	valid_name_found = true;
91da11f8 LB	138	}
91da11f8 LB	139
f9bf5a2c FF	140	if (!valid_name_found && i == DSA_MAX_PORTS) {
	141	ret = -EINVAL;
	142	goto out;
	143	}
91da11f8	144
0d8bcdd3 FF	145	/* Make the built-in MII bus mask match the number of ports,
	146	* switch drivers can override this later
	147	*/
	148	ds->phys_mii_mask = ds->phys_port_mask;
	149
91da11f8	150	/*
e84665c9 LB	151	* If the CPU connects to this switch, set the switch tree
	152	* tagging protocol to the preferred tagging format of this
	153	* switch.
91da11f8	154	*/
5075314e AD	155	if (dst->cpu_switch == index) {
	156	switch (drv->tag_protocol) {
	157	#ifdef CONFIG_NET_DSA_TAG_DSA
	158	case DSA_TAG_PROTO_DSA:
	159	dst->rcv = dsa_netdev_ops.rcv;
	160	break;
	161	#endif
	162	#ifdef CONFIG_NET_DSA_TAG_EDSA
	163	case DSA_TAG_PROTO_EDSA:
	164	dst->rcv = edsa_netdev_ops.rcv;
	165	break;
	166	#endif
	167	#ifdef CONFIG_NET_DSA_TAG_TRAILER
	168	case DSA_TAG_PROTO_TRAILER:
	169	dst->rcv = trailer_netdev_ops.rcv;
	170	break;
	171	#endif
	172	#ifdef CONFIG_NET_DSA_TAG_BRCM
	173	case DSA_TAG_PROTO_BRCM:
	174	dst->rcv = brcm_netdev_ops.rcv;
	175	break;
	176	#endif
	177	default:
	178	break;
	179	}
91da11f8	180
5075314e AD	181	dst->tag_protocol = drv->tag_protocol;
5075314e AD	182	}
91da11f8 LB	183
	184	/*
	185	* Do basic register setup.
	186	*/
	187	ret = drv->setup(ds);
	188	if (ret < 0)
	189	goto out;
	190
e84665c9	191	ret = drv->set_addr(ds, dst->master_netdev->dev_addr);
91da11f8 LB	192	if (ret < 0)
	193	goto out;
	194
	195	ds->slave_mii_bus = mdiobus_alloc();
	196	if (ds->slave_mii_bus == NULL) {
	197	ret = -ENOMEM;
	198	goto out;
	199	}
	200	dsa_slave_mii_bus_init(ds);
	201
	202	ret = mdiobus_register(ds->slave_mii_bus);
	203	if (ret < 0)
	204	goto out_free;
	205
	206
	207	/*
	208	* Create network devices for physical switch ports.
	209	*/
91da11f8 LB	210	for (i = 0; i < DSA_MAX_PORTS; i++) {
	211	struct net_device *slave_dev;
	212
e84665c9	213	if (!(ds->phys_port_mask & (1 << i)))
91da11f8 LB	214	continue;
	215
	216	slave_dev = dsa_slave_create(ds, parent, i, pd->port_names[i]);
	217	if (slave_dev == NULL) {
e84665c9 LB	218	printk(KERN_ERR "%s[%d]: can't create dsa "
	219	"slave device for port %d(%s)\n",
	220	dst->master_netdev->name,
	221	index, i, pd->port_names[i]);
91da11f8 LB	222	continue;
	223	}
	224
	225	ds->ports[i] = slave_dev;
	226	}
	227
	228	return ds;
	229
	230	out_free:
	231	mdiobus_free(ds->slave_mii_bus);
	232	out:
91da11f8 LB	233	kfree(ds);
	234	return ERR_PTR(ret);
	235	}
	236
	237	static void dsa_switch_destroy(struct dsa_switch *ds)
	238	{
	239	}
	240
e506d405	241	#ifdef CONFIG_PM_SLEEP
24462549 FF	242	static int dsa_switch_suspend(struct dsa_switch *ds)
	243	{
	244	int i, ret = 0;
	245
	246	/* Suspend slave network devices */
	247	for (i = 0; i < DSA_MAX_PORTS; i++) {
	248	if (!(ds->phys_port_mask & (1 << i)))
	249	continue;
	250
	251	ret = dsa_slave_suspend(ds->ports[i]);
	252	if (ret)
	253	return ret;
	254	}
	255
	256	if (ds->drv->suspend)
	257	ret = ds->drv->suspend(ds);
	258
	259	return ret;
	260	}
	261
	262	static int dsa_switch_resume(struct dsa_switch *ds)
	263	{
	264	int i, ret = 0;
	265
	266	if (ds->drv->resume)
	267	ret = ds->drv->resume(ds);
	268
	269	if (ret)
	270	return ret;
	271
	272	/* Resume slave network devices */
	273	for (i = 0; i < DSA_MAX_PORTS; i++) {
	274	if (!(ds->phys_port_mask & (1 << i)))
	275	continue;
	276
	277	ret = dsa_slave_resume(ds->ports[i]);
	278	if (ret)
	279	return ret;
	280	}
	281
	282	return 0;
	283	}
e506d405	284	#endif
24462549	285
91da11f8 LB	286
	287	/* link polling *************************************************************/
	288	static void dsa_link_poll_work(struct work_struct *ugly)
	289	{
e84665c9 LB	290	struct dsa_switch_tree *dst;
	291	int i;
	292
	293	dst = container_of(ugly, struct dsa_switch_tree, link_poll_work);
91da11f8	294
e84665c9 LB	295	for (i = 0; i < dst->pd->nr_chips; i++) {
e84665c9 LB	296	struct dsa_switch *ds = dst->ds[i];
91da11f8	297
e84665c9 LB	298	if (ds != NULL && ds->drv->poll_link != NULL)
	299	ds->drv->poll_link(ds);
	300	}
	301
	302	mod_timer(&dst->link_poll_timer, round_jiffies(jiffies + HZ));
91da11f8 LB	303	}
91da11f8 LB	304
e84665c9	305	static void dsa_link_poll_timer(unsigned long _dst)
91da11f8	306	{
e84665c9	307	struct dsa_switch_tree dst = (void )_dst;
91da11f8	308
e84665c9	309	schedule_work(&dst->link_poll_work);
91da11f8 LB	310	}
	311
	312
	313	/* platform driver init and cleanup *****************************************/
	314	static int dev_is_class(struct device dev, void class)
	315	{
	316	if (dev->class != NULL && !strcmp(dev->class->name, class))
	317	return 1;
	318
	319	return 0;
	320	}
	321
	322	static struct device dev_find_class(struct device parent, char *class)
	323	{
	324	if (dev_is_class(parent, class)) {
	325	get_device(parent);
	326	return parent;
	327	}
	328
	329	return device_find_child(parent, class, dev_is_class);
	330	}
	331
b4d2394d	332	struct mii_bus dsa_host_dev_to_mii_bus(struct device dev)
91da11f8 LB	333	{
	334	struct device *d;
	335
	336	d = dev_find_class(dev, "mdio_bus");
	337	if (d != NULL) {
	338	struct mii_bus *bus;
	339
	340	bus = to_mii_bus(d);
	341	put_device(d);
	342
	343	return bus;
	344	}
	345
	346	return NULL;
	347	}
b4d2394d	348	EXPORT_SYMBOL_GPL(dsa_host_dev_to_mii_bus);
91da11f8 LB	349
	350	static struct net_device dev_to_net_device(struct device dev)
	351	{
	352	struct device *d;
	353
	354	d = dev_find_class(dev, "net");
	355	if (d != NULL) {
	356	struct net_device *nd;
	357
	358	nd = to_net_dev(d);
	359	dev_hold(nd);
	360	put_device(d);
	361
	362	return nd;
	363	}
	364
	365	return NULL;
	366	}
	367
5e95329b FF	368	#ifdef CONFIG_OF
	369	static int dsa_of_setup_routing_table(struct dsa_platform_data *pd,
	370	struct dsa_chip_data *cd,
	371	int chip_index,
	372	struct device_node *link)
	373	{
	374	int ret;
	375	const __be32 *reg;
	376	int link_port_addr;
	377	int link_sw_addr;
	378	struct device_node *parent_sw;
	379	int len;
	380
	381	parent_sw = of_get_parent(link);
	382	if (!parent_sw)
	383	return -EINVAL;
	384
	385	reg = of_get_property(parent_sw, "reg", &len);
	386	if (!reg \|\| (len != sizeof(reg) 2))
	387	return -EINVAL;
	388
	389	link_sw_addr = be32_to_cpup(reg + 1);
	390
	391	if (link_sw_addr >= pd->nr_chips)
	392	return -EINVAL;
	393
	394	/* First time routing table allocation */
	395	if (!cd->rtable) {
	396	cd->rtable = kmalloc(pd->nr_chips * sizeof(s8), GFP_KERNEL);
	397	if (!cd->rtable)
	398	return -ENOMEM;
	399
	400	/* default to no valid uplink/downlink */
	401	memset(cd->rtable, -1, pd->nr_chips * sizeof(s8));
	402	}
	403
	404	reg = of_get_property(link, "reg", NULL);
	405	if (!reg) {
	406	ret = -EINVAL;
	407	goto out;
	408	}
	409
	410	link_port_addr = be32_to_cpup(reg);
	411
	412	cd->rtable[link_sw_addr] = link_port_addr;
	413
	414	return 0;
	415	out:
	416	kfree(cd->rtable);
	417	return ret;
	418	}
	419
21168245 FF	420	static void dsa_of_free_platform_data(struct dsa_platform_data *pd)
	421	{
	422	int i;
	423	int port_index;
	424
	425	for (i = 0; i < pd->nr_chips; i++) {
	426	port_index = 0;
5f64a7db	427	while (port_index < DSA_MAX_PORTS) {
1f74714f	428	kfree(pd->chip[i].port_names[port_index]);
5f64a7db FF	429	port_index++;
5f64a7db FF	430	}
21168245 FF	431	kfree(pd->chip[i].rtable);
	432	}
	433	kfree(pd->chip);
	434	}
	435
5e95329b FF	436	static int dsa_of_probe(struct platform_device *pdev)
	437	{
	438	struct device_node *np = pdev->dev.of_node;
	439	struct device_node child, mdio, ethernet, port, *link;
	440	struct mii_bus *mdio_bus;
	441	struct platform_device *ethernet_dev;
	442	struct dsa_platform_data *pd;
	443	struct dsa_chip_data *cd;
	444	const char *port_name;
	445	int chip_index, port_index;
	446	const unsigned int sw_addr, port_reg;
21168245	447	int ret;
5e95329b FF	448
	449	mdio = of_parse_phandle(np, "dsa,mii-bus", 0);
	450	if (!mdio)
	451	return -EINVAL;
	452
	453	mdio_bus = of_mdio_find_bus(mdio);
	454	if (!mdio_bus)
	455	return -EINVAL;
	456
	457	ethernet = of_parse_phandle(np, "dsa,ethernet", 0);
	458	if (!ethernet)
	459	return -EINVAL;
	460
	461	ethernet_dev = of_find_device_by_node(ethernet);
	462	if (!ethernet_dev)
	463	return -ENODEV;
	464
	465	pd = kzalloc(sizeof(*pd), GFP_KERNEL);
	466	if (!pd)
	467	return -ENOMEM;
	468
	469	pdev->dev.platform_data = pd;
	470	pd->netdev = &ethernet_dev->dev;
	471	pd->nr_chips = of_get_child_count(np);
	472	if (pd->nr_chips > DSA_MAX_SWITCHES)
	473	pd->nr_chips = DSA_MAX_SWITCHES;
	474
	475	pd->chip = kzalloc(pd->nr_chips * sizeof(struct dsa_chip_data),
	476	GFP_KERNEL);
	477	if (!pd->chip) {
	478	ret = -ENOMEM;
	479	goto out_free;
	480	}
	481
d1c0b471	482	chip_index = -1;
5e95329b	483	for_each_available_child_of_node(np, child) {
d1c0b471	484	chip_index++;
5e95329b FF	485	cd = &pd->chip[chip_index];
5e95329b FF	486
fa981d9a	487	cd->of_node = child;
c1f570a6	488	cd->host_dev = &mdio_bus->dev;
5e95329b FF	489
	490	sw_addr = of_get_property(child, "reg", NULL);
	491	if (!sw_addr)
	492	continue;
	493
	494	cd->sw_addr = be32_to_cpup(sw_addr);
	495	if (cd->sw_addr > PHY_MAX_ADDR)
	496	continue;
	497
	498	for_each_available_child_of_node(child, port) {
	499	port_reg = of_get_property(port, "reg", NULL);
	500	if (!port_reg)
	501	continue;
	502
	503	port_index = be32_to_cpup(port_reg);
	504
	505	port_name = of_get_property(port, "label", NULL);
	506	if (!port_name)
	507	continue;
	508
bd47497a FF	509	cd->port_dn[port_index] = port;
bd47497a FF	510
5e95329b FF	511	cd->port_names[port_index] = kstrdup(port_name,
	512	GFP_KERNEL);
	513	if (!cd->port_names[port_index]) {
	514	ret = -ENOMEM;
	515	goto out_free_chip;
	516	}
	517
	518	link = of_parse_phandle(port, "link", 0);
	519
	520	if (!strcmp(port_name, "dsa") && link &&
	521	pd->nr_chips > 1) {
	522	ret = dsa_of_setup_routing_table(pd, cd,
	523	chip_index, link);
	524	if (ret)
	525	goto out_free_chip;
	526	}
	527
	528	if (port_index == DSA_MAX_PORTS)
	529	break;
	530	}
	531	}
	532
	533	return 0;
	534
	535	out_free_chip:
21168245	536	dsa_of_free_platform_data(pd);
5e95329b FF	537	out_free:
	538	kfree(pd);
	539	pdev->dev.platform_data = NULL;
	540	return ret;
	541	}
	542
	543	static void dsa_of_remove(struct platform_device *pdev)
	544	{
	545	struct dsa_platform_data *pd = pdev->dev.platform_data;
5e95329b FF	546
	547	if (!pdev->dev.of_node)
	548	return;
	549
21168245	550	dsa_of_free_platform_data(pd);
5e95329b FF	551	kfree(pd);
	552	}
	553	#else
	554	static inline int dsa_of_probe(struct platform_device *pdev)
	555	{
	556	return 0;
	557	}
	558
	559	static inline void dsa_of_remove(struct platform_device *pdev)
	560	{
	561	}
	562	#endif
	563
91da11f8 LB	564	static int dsa_probe(struct platform_device *pdev)
	565	{
	566	static int dsa_version_printed;
	567	struct dsa_platform_data *pd = pdev->dev.platform_data;
	568	struct net_device *dev;
e84665c9	569	struct dsa_switch_tree *dst;
5e95329b	570	int i, ret;
91da11f8 LB	571
	572	if (!dsa_version_printed++)
	573	printk(KERN_NOTICE "Distributed Switch Architecture "
	574	"driver version %s\n", dsa_driver_version);
	575
5e95329b FF	576	if (pdev->dev.of_node) {
	577	ret = dsa_of_probe(pdev);
	578	if (ret)
	579	return ret;
	580
	581	pd = pdev->dev.platform_data;
	582	}
	583
e84665c9	584	if (pd == NULL \|\| pd->netdev == NULL)
91da11f8 LB	585	return -EINVAL;
	586
	587	dev = dev_to_net_device(pd->netdev);
5e95329b FF	588	if (dev == NULL) {
	589	ret = -EINVAL;
	590	goto out;
	591	}
91da11f8 LB	592
	593	if (dev->dsa_ptr != NULL) {
	594	dev_put(dev);
5e95329b FF	595	ret = -EEXIST;
5e95329b FF	596	goto out;
91da11f8 LB	597	}
91da11f8 LB	598
e84665c9 LB	599	dst = kzalloc(sizeof(*dst), GFP_KERNEL);
e84665c9 LB	600	if (dst == NULL) {
91da11f8	601	dev_put(dev);
5e95329b FF	602	ret = -ENOMEM;
5e95329b FF	603	goto out;
91da11f8 LB	604	}
91da11f8 LB	605
e84665c9 LB	606	platform_set_drvdata(pdev, dst);
	607
	608	dst->pd = pd;
	609	dst->master_netdev = dev;
	610	dst->cpu_switch = -1;
	611	dst->cpu_port = -1;
	612
	613	for (i = 0; i < pd->nr_chips; i++) {
e84665c9 LB	614	struct dsa_switch *ds;
e84665c9 LB	615
b4d2394d	616	ds = dsa_switch_setup(dst, i, &pdev->dev, pd->chip[i].host_dev);
e84665c9 LB	617	if (IS_ERR(ds)) {
	618	printk(KERN_ERR "%s[%d]: couldn't create dsa switch "
	619	"instance (error %ld)\n", dev->name, i,
	620	PTR_ERR(ds));
	621	continue;
	622	}
	623
	624	dst->ds[i] = ds;
	625	if (ds->drv->poll_link != NULL)
	626	dst->link_poll_needed = 1;
91da11f8 LB	627	}
91da11f8 LB	628
e84665c9 LB	629	/*
	630	* If we use a tagging format that doesn't have an ethertype
	631	* field, make sure that all packets from this point on get
	632	* sent to the tag format's receive function.
	633	*/
	634	wmb();
	635	dev->dsa_ptr = (void *)dst;
	636
	637	if (dst->link_poll_needed) {
	638	INIT_WORK(&dst->link_poll_work, dsa_link_poll_work);
	639	init_timer(&dst->link_poll_timer);
	640	dst->link_poll_timer.data = (unsigned long)dst;
	641	dst->link_poll_timer.function = dsa_link_poll_timer;
	642	dst->link_poll_timer.expires = round_jiffies(jiffies + HZ);
	643	add_timer(&dst->link_poll_timer);
	644	}
91da11f8 LB	645
91da11f8 LB	646	return 0;
5e95329b FF	647
	648	out:
	649	dsa_of_remove(pdev);
	650
	651	return ret;
91da11f8 LB	652	}
	653
	654	static int dsa_remove(struct platform_device *pdev)
	655	{
e84665c9 LB	656	struct dsa_switch_tree *dst = platform_get_drvdata(pdev);
e84665c9 LB	657	int i;
91da11f8	658
e84665c9 LB	659	if (dst->link_poll_needed)
e84665c9 LB	660	del_timer_sync(&dst->link_poll_timer);
91da11f8	661
43829731	662	flush_work(&dst->link_poll_work);
91da11f8	663
e84665c9 LB	664	for (i = 0; i < dst->pd->nr_chips; i++) {
	665	struct dsa_switch *ds = dst->ds[i];
	666
	667	if (ds != NULL)
	668	dsa_switch_destroy(ds);
	669	}
91da11f8	670
5e95329b FF	671	dsa_of_remove(pdev);
5e95329b FF	672
91da11f8 LB	673	return 0;
	674	}
	675
	676	static void dsa_shutdown(struct platform_device *pdev)
	677	{
	678	}
	679
3e8a72d1 FF	680	static int dsa_switch_rcv(struct sk_buff skb, struct net_device dev,
	681	struct packet_type pt, struct net_device orig_dev)
	682	{
	683	struct dsa_switch_tree *dst = dev->dsa_ptr;
	684
	685	if (unlikely(dst == NULL)) {
	686	kfree_skb(skb);
	687	return 0;
	688	}
	689
5075314e	690	return dst->rcv(skb, dev, pt, orig_dev);
3e8a72d1 FF	691	}
3e8a72d1 FF	692
61b7363f	693	static struct packet_type dsa_pack_type __read_mostly = {
3e8a72d1 FF	694	.type = cpu_to_be16(ETH_P_XDSA),
	695	.func = dsa_switch_rcv,
	696	};
	697
24462549 FF	698	#ifdef CONFIG_PM_SLEEP
	699	static int dsa_suspend(struct device *d)
	700	{
	701	struct platform_device *pdev = to_platform_device(d);
	702	struct dsa_switch_tree *dst = platform_get_drvdata(pdev);
	703	int i, ret = 0;
	704
	705	for (i = 0; i < dst->pd->nr_chips; i++) {
	706	struct dsa_switch *ds = dst->ds[i];
	707
	708	if (ds != NULL)
	709	ret = dsa_switch_suspend(ds);
	710	}
	711
	712	return ret;
	713	}
	714
	715	static int dsa_resume(struct device *d)
	716	{
	717	struct platform_device *pdev = to_platform_device(d);
	718	struct dsa_switch_tree *dst = platform_get_drvdata(pdev);
	719	int i, ret = 0;
	720
	721	for (i = 0; i < dst->pd->nr_chips; i++) {
	722	struct dsa_switch *ds = dst->ds[i];
	723
	724	if (ds != NULL)
	725	ret = dsa_switch_resume(ds);
	726	}
	727
	728	return ret;
	729	}
	730	#endif
	731
	732	static SIMPLE_DEV_PM_OPS(dsa_pm_ops, dsa_suspend, dsa_resume);
	733
5e95329b	734	static const struct of_device_id dsa_of_match_table[] = {
246d7f77	735	{ .compatible = "brcm,bcm7445-switch-v4.0" },
5e95329b FF	736	{ .compatible = "marvell,dsa", },
	737	{}
	738	};
	739	MODULE_DEVICE_TABLE(of, dsa_of_match_table);
	740
91da11f8 LB	741	static struct platform_driver dsa_driver = {
	742	.probe = dsa_probe,
	743	.remove = dsa_remove,
	744	.shutdown = dsa_shutdown,
	745	.driver = {
	746	.name = "dsa",
	747	.owner = THIS_MODULE,
5e95329b	748	.of_match_table = dsa_of_match_table,
24462549	749	.pm = &dsa_pm_ops,
91da11f8 LB	750	},
	751	};
	752
	753	static int __init dsa_init_module(void)
	754	{
7df899c3 BH	755	int rc;
	756
	757	rc = platform_driver_register(&dsa_driver);
	758	if (rc)
	759	return rc;
	760
3e8a72d1 FF	761	dev_add_pack(&dsa_pack_type);
3e8a72d1 FF	762
7df899c3	763	return 0;
91da11f8 LB	764	}
	765	module_init(dsa_init_module);
	766
	767	static void __exit dsa_cleanup_module(void)
	768	{
3e8a72d1	769	dev_remove_pack(&dsa_pack_type);
91da11f8 LB	770	platform_driver_unregister(&dsa_driver);
	771	}
	772	module_exit(dsa_cleanup_module);
	773
577d6a7c	774	MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>");
91da11f8 LB	775	MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
	776	MODULE_LICENSE("GPL");
	777	MODULE_ALIAS("platform:dsa");