/*
   * 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
  ",
  		       dst->master_netdev->name, index);

  		return ERR_PTR(-EINVAL);
  	}

  	printk(KERN_INFO "%s[%d]: detected a %s switch
  ",
  		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?!
  ");
  				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)
  ",
  			       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
  ", 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
  ", 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)
  ", 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)
  {

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