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

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

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;

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


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


/* hooks for ethertype-less tagging formats *********************************/
/*
 * The original DSA tag format and some other tag formats have no
 * ethertype, which means that we need to add a little hack to the
 * networking receive path to make sure that received frames get
 * the right ->protocol assigned to them when one of those tag
 * formats is in use.
 */
bool dsa_uses_dsa_tags(void *dsa_ptr)
{
	struct dsa_switch_tree *dst = dsa_ptr;

	return !!(dst->tag_protocol == htons(ETH_P_DSA));
}

bool dsa_uses_trailer_tags(void *dsa_ptr)
{
	struct dsa_switch_tree *dst = dsa_ptr;

	return !!(dst->tag_protocol == htons(ETH_P_TRAILER));
}


/* 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_scheduled_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)
{
	return platform_driver_register(&dsa_driver);
}
module_init(dsa_init_module);

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

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