net/dsa/dsa.c - linux - Git at Google

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

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


 /* 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_sync(&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)
 {
 	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 <buytenh@wantstofly.org>");
 MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:dsa");
	/*
	* 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;

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


	/* 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_sync(&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)
	{
	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 <buytenh@wantstofly.org>");
	MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
	MODULE_LICENSE("GPL");
	MODULE_ALIAS("platform:dsa");