[deliverable/linux.git] / net / dsa / dsa.c

/*
 * net/dsa/dsa.c - Hardware switch handling
 * Copyright (c) 2008-2009 Marvell Semiconductor
 *
 * 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/netdevice.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <net/dsa.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 mii_bus *bus, 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(bus, 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 mii_bus *bus)
{
	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(bus, 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_mii_bus = bus;


	/*
	 * 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;
	}

	/*
	 * If the CPU connects to this switch, set the switch tree
	 * tagging protocol to the preferred tagging format of this
	 * switch.
	 */
	if (ds->dst->cpu_switch == index)
		ds->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)
{
}


/* 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);
}

static struct mii_bus *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;
}

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;
}

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;

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

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

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

	if (dev->dsa_ptr != NULL) {
		dev_put(dev);
		return -EEXIST;
	}

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

	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 mii_bus *bus;
		struct dsa_switch *ds;

		bus = dev_to_mii_bus(pd->chip[i].mii_bus);
		if (bus == NULL) {
			printk(KERN_ERR "%s[%d]: no mii bus found for "
				"dsa switch\n", dev->name, i);
			continue;
		}

		ds = dsa_switch_setup(dst, i, &pdev->dev, bus);
		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;
}

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);
	}

	return 0;
}

static void dsa_shutdown(struct platform_device *pdev)
{
}

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

static int __init dsa_init_module(void)
{
	int rc;

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

#ifdef CONFIG_NET_DSA_TAG_DSA
	dev_add_pack(&dsa_packet_type);
#endif
#ifdef CONFIG_NET_DSA_TAG_EDSA
	dev_add_pack(&edsa_packet_type);
#endif
#ifdef CONFIG_NET_DSA_TAG_TRAILER
	dev_add_pack(&trailer_packet_type);
#endif
	return 0;
}
module_init(dsa_init_module);

static void __exit dsa_cleanup_module(void)
{
#ifdef CONFIG_NET_DSA_TAG_TRAILER
	dev_remove_pack(&trailer_packet_type);
#endif
#ifdef CONFIG_NET_DSA_TAG_EDSA
	dev_remove_pack(&edsa_packet_type);
#endif
#ifdef CONFIG_NET_DSA_TAG_DSA
	dev_remove_pack(&dsa_packet_type);
#endif
	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
91da11f8 LB	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*/
	10
	11	#include <linux/list.h>
	12	#include <linux/netdevice.h>
	13	#include <linux/platform_device.h>
5a0e3ad6	14	#include <linux/slab.h>
3a9a231d	15	#include <linux/module.h>
91da11f8 LB	16	#include <net/dsa.h>
	17	#include "dsa_priv.h"
	18
	19	char dsa_driver_version[] = "0.1";
	20
	21
	22	/* switch driver registration ***********************************************/
	23	static DEFINE_MUTEX(dsa_switch_drivers_mutex);
	24	static LIST_HEAD(dsa_switch_drivers);
	25
	26	void register_switch_driver(struct dsa_switch_driver *drv)
	27	{
	28	mutex_lock(&dsa_switch_drivers_mutex);
	29	list_add_tail(&drv->list, &dsa_switch_drivers);
	30	mutex_unlock(&dsa_switch_drivers_mutex);
	31	}
ad293b8a	32	EXPORT_SYMBOL_GPL(register_switch_driver);
91da11f8 LB	33
	34	void unregister_switch_driver(struct dsa_switch_driver *drv)
	35	{
	36	mutex_lock(&dsa_switch_drivers_mutex);
	37	list_del_init(&drv->list);
	38	mutex_unlock(&dsa_switch_drivers_mutex);
	39	}
ad293b8a	40	EXPORT_SYMBOL_GPL(unregister_switch_driver);
91da11f8 LB	41
	42	static struct dsa_switch_driver *
	43	dsa_switch_probe(struct mii_bus bus, int sw_addr, char *_name)
	44	{
	45	struct dsa_switch_driver *ret;
	46	struct list_head *list;
	47	char *name;
	48
	49	ret = NULL;
	50	name = NULL;
	51
	52	mutex_lock(&dsa_switch_drivers_mutex);
	53	list_for_each(list, &dsa_switch_drivers) {
	54	struct dsa_switch_driver *drv;
	55
	56	drv = list_entry(list, struct dsa_switch_driver, list);
	57
	58	name = drv->probe(bus, sw_addr);
	59	if (name != NULL) {
	60	ret = drv;
	61	break;
	62	}
	63	}
	64	mutex_unlock(&dsa_switch_drivers_mutex);
	65
	66	*_name = name;
	67
	68	return ret;
	69	}
	70
	71
	72	/* basic switch operations **************************************************/
	73	static struct dsa_switch *
e84665c9 LB	74	dsa_switch_setup(struct dsa_switch_tree *dst, int index,
e84665c9 LB	75	struct device parent, struct mii_bus bus)
91da11f8	76	{
e84665c9 LB	77	struct dsa_chip_data *pd = dst->pd->chip + index;
e84665c9 LB	78	struct dsa_switch_driver *drv;
91da11f8 LB	79	struct dsa_switch *ds;
91da11f8 LB	80	int ret;
91da11f8 LB	81	char *name;
91da11f8 LB	82	int i;
f9bf5a2c	83	bool valid_name_found = false;
91da11f8 LB	84
	85	/*
	86	* Probe for switch model.
	87	*/
	88	drv = dsa_switch_probe(bus, pd->sw_addr, &name);
	89	if (drv == NULL) {
e84665c9 LB	90	printk(KERN_ERR "%s[%d]: could not detect attached switch\n",
e84665c9 LB	91	dst->master_netdev->name, index);
91da11f8 LB	92	return ERR_PTR(-EINVAL);
91da11f8 LB	93	}
e84665c9 LB	94	printk(KERN_INFO "%s[%d]: detected a %s switch\n",
e84665c9 LB	95	dst->master_netdev->name, index, name);
91da11f8 LB	96
	97
	98	/*
	99	* Allocate and initialise switch state.
	100	*/
	101	ds = kzalloc(sizeof(*ds) + drv->priv_size, GFP_KERNEL);
	102	if (ds == NULL)
	103	return ERR_PTR(-ENOMEM);
	104
e84665c9 LB	105	ds->dst = dst;
	106	ds->index = index;
	107	ds->pd = dst->pd->chip + index;
91da11f8	108	ds->drv = drv;
e84665c9	109	ds->master_mii_bus = bus;
91da11f8 LB	110
	111
	112	/*
	113	* Validate supplied switch configuration.
	114	*/
91da11f8 LB	115	for (i = 0; i < DSA_MAX_PORTS; i++) {
	116	char *name;
	117
	118	name = pd->port_names[i];
	119	if (name == NULL)
	120	continue;
	121
	122	if (!strcmp(name, "cpu")) {
e84665c9	123	if (dst->cpu_switch != -1) {
91da11f8 LB	124	printk(KERN_ERR "multiple cpu ports?!\n");
	125	ret = -EINVAL;
	126	goto out;
	127	}
e84665c9 LB	128	dst->cpu_switch = index;
	129	dst->cpu_port = i;
	130	} else if (!strcmp(name, "dsa")) {
	131	ds->dsa_port_mask \|= 1 << i;
91da11f8	132	} else {
e84665c9	133	ds->phys_port_mask \|= 1 << i;
91da11f8	134	}
f9bf5a2c	135	valid_name_found = true;
91da11f8 LB	136	}
91da11f8 LB	137
f9bf5a2c FF	138	if (!valid_name_found && i == DSA_MAX_PORTS) {
	139	ret = -EINVAL;
	140	goto out;
	141	}
91da11f8 LB	142
91da11f8 LB	143	/*
e84665c9 LB	144	* If the CPU connects to this switch, set the switch tree
	145	* tagging protocol to the preferred tagging format of this
	146	* switch.
91da11f8	147	*/
e84665c9 LB	148	if (ds->dst->cpu_switch == index)
e84665c9 LB	149	ds->dst->tag_protocol = drv->tag_protocol;
91da11f8 LB	150
	151
	152	/*
	153	* Do basic register setup.
	154	*/
	155	ret = drv->setup(ds);
	156	if (ret < 0)
	157	goto out;
	158
e84665c9	159	ret = drv->set_addr(ds, dst->master_netdev->dev_addr);
91da11f8 LB	160	if (ret < 0)
	161	goto out;
	162
	163	ds->slave_mii_bus = mdiobus_alloc();
	164	if (ds->slave_mii_bus == NULL) {
	165	ret = -ENOMEM;
	166	goto out;
	167	}
	168	dsa_slave_mii_bus_init(ds);
	169
	170	ret = mdiobus_register(ds->slave_mii_bus);
	171	if (ret < 0)
	172	goto out_free;
	173
	174
	175	/*
	176	* Create network devices for physical switch ports.
	177	*/
91da11f8 LB	178	for (i = 0; i < DSA_MAX_PORTS; i++) {
	179	struct net_device *slave_dev;
	180
e84665c9	181	if (!(ds->phys_port_mask & (1 << i)))
91da11f8 LB	182	continue;
	183
	184	slave_dev = dsa_slave_create(ds, parent, i, pd->port_names[i]);
	185	if (slave_dev == NULL) {
e84665c9 LB	186	printk(KERN_ERR "%s[%d]: can't create dsa "
	187	"slave device for port %d(%s)\n",
	188	dst->master_netdev->name,
	189	index, i, pd->port_names[i]);
91da11f8 LB	190	continue;
	191	}
	192
	193	ds->ports[i] = slave_dev;
	194	}
	195
	196	return ds;
	197
	198	out_free:
	199	mdiobus_free(ds->slave_mii_bus);
	200	out:
91da11f8 LB	201	kfree(ds);
	202	return ERR_PTR(ret);
	203	}
	204
	205	static void dsa_switch_destroy(struct dsa_switch *ds)
	206	{
	207	}
	208
	209
	210	/* link polling *************************************************************/
	211	static void dsa_link_poll_work(struct work_struct *ugly)
	212	{
e84665c9 LB	213	struct dsa_switch_tree *dst;
	214	int i;
	215
	216	dst = container_of(ugly, struct dsa_switch_tree, link_poll_work);
91da11f8	217
e84665c9 LB	218	for (i = 0; i < dst->pd->nr_chips; i++) {
e84665c9 LB	219	struct dsa_switch *ds = dst->ds[i];
91da11f8	220
e84665c9 LB	221	if (ds != NULL && ds->drv->poll_link != NULL)
	222	ds->drv->poll_link(ds);
	223	}
	224
	225	mod_timer(&dst->link_poll_timer, round_jiffies(jiffies + HZ));
91da11f8 LB	226	}
91da11f8 LB	227
e84665c9	228	static void dsa_link_poll_timer(unsigned long _dst)
91da11f8	229	{
e84665c9	230	struct dsa_switch_tree dst = (void )_dst;
91da11f8	231
e84665c9	232	schedule_work(&dst->link_poll_work);
91da11f8 LB	233	}
	234
	235
	236	/* platform driver init and cleanup *****************************************/
	237	static int dev_is_class(struct device dev, void class)
	238	{
	239	if (dev->class != NULL && !strcmp(dev->class->name, class))
	240	return 1;
	241
	242	return 0;
	243	}
	244
	245	static struct device dev_find_class(struct device parent, char *class)
	246	{
	247	if (dev_is_class(parent, class)) {
	248	get_device(parent);
	249	return parent;
	250	}
	251
	252	return device_find_child(parent, class, dev_is_class);
	253	}
	254
	255	static struct mii_bus dev_to_mii_bus(struct device dev)
	256	{
	257	struct device *d;
	258
	259	d = dev_find_class(dev, "mdio_bus");
	260	if (d != NULL) {
	261	struct mii_bus *bus;
	262
	263	bus = to_mii_bus(d);
	264	put_device(d);
	265
	266	return bus;
	267	}
	268
	269	return NULL;
	270	}
	271
	272	static struct net_device dev_to_net_device(struct device dev)
	273	{
	274	struct device *d;
	275
	276	d = dev_find_class(dev, "net");
	277	if (d != NULL) {
	278	struct net_device *nd;
	279
	280	nd = to_net_dev(d);
	281	dev_hold(nd);
	282	put_device(d);
	283
	284	return nd;
	285	}
	286
	287	return NULL;
	288	}
	289
	290	static int dsa_probe(struct platform_device *pdev)
	291	{
	292	static int dsa_version_printed;
	293	struct dsa_platform_data *pd = pdev->dev.platform_data;
	294	struct net_device *dev;
e84665c9 LB	295	struct dsa_switch_tree *dst;
e84665c9 LB	296	int i;
91da11f8 LB	297
	298	if (!dsa_version_printed++)
	299	printk(KERN_NOTICE "Distributed Switch Architecture "
	300	"driver version %s\n", dsa_driver_version);
	301
e84665c9	302	if (pd == NULL \|\| pd->netdev == NULL)
91da11f8 LB	303	return -EINVAL;
	304
	305	dev = dev_to_net_device(pd->netdev);
	306	if (dev == NULL)
	307	return -EINVAL;
	308
	309	if (dev->dsa_ptr != NULL) {
	310	dev_put(dev);
	311	return -EEXIST;
	312	}
	313
e84665c9 LB	314	dst = kzalloc(sizeof(*dst), GFP_KERNEL);
e84665c9 LB	315	if (dst == NULL) {
91da11f8	316	dev_put(dev);
e84665c9	317	return -ENOMEM;
91da11f8 LB	318	}
91da11f8 LB	319
e84665c9 LB	320	platform_set_drvdata(pdev, dst);
	321
	322	dst->pd = pd;
	323	dst->master_netdev = dev;
	324	dst->cpu_switch = -1;
	325	dst->cpu_port = -1;
	326
	327	for (i = 0; i < pd->nr_chips; i++) {
	328	struct mii_bus *bus;
	329	struct dsa_switch *ds;
	330
	331	bus = dev_to_mii_bus(pd->chip[i].mii_bus);
	332	if (bus == NULL) {
	333	printk(KERN_ERR "%s[%d]: no mii bus found for "
	334	"dsa switch\n", dev->name, i);
	335	continue;
	336	}
	337
	338	ds = dsa_switch_setup(dst, i, &pdev->dev, bus);
	339	if (IS_ERR(ds)) {
	340	printk(KERN_ERR "%s[%d]: couldn't create dsa switch "
	341	"instance (error %ld)\n", dev->name, i,
	342	PTR_ERR(ds));
	343	continue;
	344	}
	345
	346	dst->ds[i] = ds;
	347	if (ds->drv->poll_link != NULL)
	348	dst->link_poll_needed = 1;
91da11f8 LB	349	}
91da11f8 LB	350
e84665c9 LB	351	/*
	352	* If we use a tagging format that doesn't have an ethertype
	353	* field, make sure that all packets from this point on get
	354	* sent to the tag format's receive function.
	355	*/
	356	wmb();
	357	dev->dsa_ptr = (void *)dst;
	358
	359	if (dst->link_poll_needed) {
	360	INIT_WORK(&dst->link_poll_work, dsa_link_poll_work);
	361	init_timer(&dst->link_poll_timer);
	362	dst->link_poll_timer.data = (unsigned long)dst;
	363	dst->link_poll_timer.function = dsa_link_poll_timer;
	364	dst->link_poll_timer.expires = round_jiffies(jiffies + HZ);
	365	add_timer(&dst->link_poll_timer);
	366	}
91da11f8 LB	367
	368	return 0;
	369	}
	370
	371	static int dsa_remove(struct platform_device *pdev)
	372	{
e84665c9 LB	373	struct dsa_switch_tree *dst = platform_get_drvdata(pdev);
e84665c9 LB	374	int i;
91da11f8	375
e84665c9 LB	376	if (dst->link_poll_needed)
e84665c9 LB	377	del_timer_sync(&dst->link_poll_timer);
91da11f8	378
43829731	379	flush_work(&dst->link_poll_work);
91da11f8	380
e84665c9 LB	381	for (i = 0; i < dst->pd->nr_chips; i++) {
	382	struct dsa_switch *ds = dst->ds[i];
	383
	384	if (ds != NULL)
	385	dsa_switch_destroy(ds);
	386	}
91da11f8 LB	387
	388	return 0;
	389	}
	390
	391	static void dsa_shutdown(struct platform_device *pdev)
	392	{
	393	}
	394
	395	static struct platform_driver dsa_driver = {
	396	.probe = dsa_probe,
	397	.remove = dsa_remove,
	398	.shutdown = dsa_shutdown,
	399	.driver = {
	400	.name = "dsa",
	401	.owner = THIS_MODULE,
	402	},
	403	};
	404
	405	static int __init dsa_init_module(void)
	406	{
7df899c3 BH	407	int rc;
	408
	409	rc = platform_driver_register(&dsa_driver);
	410	if (rc)
	411	return rc;
	412
	413	#ifdef CONFIG_NET_DSA_TAG_DSA
	414	dev_add_pack(&dsa_packet_type);
	415	#endif
	416	#ifdef CONFIG_NET_DSA_TAG_EDSA
	417	dev_add_pack(&edsa_packet_type);
	418	#endif
	419	#ifdef CONFIG_NET_DSA_TAG_TRAILER
	420	dev_add_pack(&trailer_packet_type);
	421	#endif
	422	return 0;
91da11f8 LB	423	}
	424	module_init(dsa_init_module);
	425
	426	static void __exit dsa_cleanup_module(void)
	427	{
7df899c3 BH	428	#ifdef CONFIG_NET_DSA_TAG_TRAILER
	429	dev_remove_pack(&trailer_packet_type);
	430	#endif
	431	#ifdef CONFIG_NET_DSA_TAG_EDSA
	432	dev_remove_pack(&edsa_packet_type);
	433	#endif
	434	#ifdef CONFIG_NET_DSA_TAG_DSA
	435	dev_remove_pack(&dsa_packet_type);
	436	#endif
91da11f8 LB	437	platform_driver_unregister(&dsa_driver);
	438	}
	439	module_exit(dsa_cleanup_module);
	440
577d6a7c	441	MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>");
91da11f8 LB	442	MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
	443	MODULE_LICENSE("GPL");
	444	MODULE_ALIAS("platform:dsa");