[deliverable/linux.git] / drivers / mtd / chips / chipreg.c

/*
 * $Id: chipreg.c,v 1.17 2004/11/16 18:29:00 dwmw2 Exp $
 *
 * Registration for chip drivers
 *
 */

#include <linux/kernel.h>
#include <linux/config.h>
#include <linux/module.h>
#include <linux/kmod.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/mtd/map.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/compatmac.h>

static DEFINE_SPINLOCK(chip_drvs_lock);
static LIST_HEAD(chip_drvs_list);

void register_mtd_chip_driver(struct mtd_chip_driver *drv)
{
	spin_lock(&chip_drvs_lock);
	list_add(&drv->list, &chip_drvs_list);
	spin_unlock(&chip_drvs_lock);
}

void unregister_mtd_chip_driver(struct mtd_chip_driver *drv)
{
	spin_lock(&chip_drvs_lock);
	list_del(&drv->list);
	spin_unlock(&chip_drvs_lock);
}

static struct mtd_chip_driver *get_mtd_chip_driver (const char *name)
{
	struct list_head *pos;
	struct mtd_chip_driver *ret = NULL, *this;

	spin_lock(&chip_drvs_lock);

	list_for_each(pos, &chip_drvs_list) {
		this = list_entry(pos, typeof(*this), list);
		
		if (!strcmp(this->name, name)) {
			ret = this;
			break;
		}
	}
	if (ret && !try_module_get(ret->module))
		ret = NULL;

	spin_unlock(&chip_drvs_lock);

	return ret;
}

	/* Hide all the horrid details, like some silly person taking
	   get_module_symbol() away from us, from the caller. */

struct mtd_info *do_map_probe(const char *name, struct map_info *map)
{
	struct mtd_chip_driver *drv;
	struct mtd_info *ret;

	drv = get_mtd_chip_driver(name);

	if (!drv && !request_module("%s", name))
		drv = get_mtd_chip_driver(name);

	if (!drv)
		return NULL;

	ret = drv->probe(map);

	/* We decrease the use count here. It may have been a 
	   probe-only module, which is no longer required from this
	   point, having given us a handle on (and increased the use
	   count of) the actual driver code.
	*/
	module_put(drv->module);

	if (ret)
		return ret;
	
	return NULL;
}
/*
 * Destroy an MTD device which was created for a map device.
 * Make sure the MTD device is already unregistered before calling this
 */
void map_destroy(struct mtd_info *mtd)
{
	struct map_info *map = mtd->priv;

	if (map->fldrv->destroy)
		map->fldrv->destroy(mtd);

	module_put(map->fldrv->module);

	kfree(mtd);
}

EXPORT_SYMBOL(register_mtd_chip_driver);
EXPORT_SYMBOL(unregister_mtd_chip_driver);
EXPORT_SYMBOL(do_map_probe);
EXPORT_SYMBOL(map_destroy);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
MODULE_DESCRIPTION("Core routines for registering and invoking MTD chip drivers");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* $Id: chipreg.c,v 1.17 2004/11/16 18:29:00 dwmw2 Exp $
	3	*
	4	* Registration for chip drivers
	5	*
	6	*/
	7
	8	#include <linux/kernel.h>
	9	#include <linux/config.h>
	10	#include <linux/module.h>
	11	#include <linux/kmod.h>
	12	#include <linux/spinlock.h>
	13	#include <linux/slab.h>
	14	#include <linux/mtd/map.h>
	15	#include <linux/mtd/mtd.h>
	16	#include <linux/mtd/compatmac.h>
	17
	18	static DEFINE_SPINLOCK(chip_drvs_lock);
	19	static LIST_HEAD(chip_drvs_list);
	20
	21	void register_mtd_chip_driver(struct mtd_chip_driver *drv)
	22	{
	23	spin_lock(&chip_drvs_lock);
	24	list_add(&drv->list, &chip_drvs_list);
	25	spin_unlock(&chip_drvs_lock);
	26	}
	27
	28	void unregister_mtd_chip_driver(struct mtd_chip_driver *drv)
	29	{
	30	spin_lock(&chip_drvs_lock);
	31	list_del(&drv->list);
	32	spin_unlock(&chip_drvs_lock);
	33	}
	34
	35	static struct mtd_chip_driver get_mtd_chip_driver (const char name)
	36	{
	37	struct list_head *pos;
	38	struct mtd_chip_driver ret = NULL, this;
	39
	40	spin_lock(&chip_drvs_lock);
	41
	42	list_for_each(pos, &chip_drvs_list) {
	43	this = list_entry(pos, typeof(*this), list);
	44
	45	if (!strcmp(this->name, name)) {
	46	ret = this;
	47	break;
	48	}
	49	}
	50	if (ret && !try_module_get(ret->module))
	51	ret = NULL;
	52
	53	spin_unlock(&chip_drvs_lock);
	54
	55	return ret;
	56	}
	57
	58	/* Hide all the horrid details, like some silly person taking
	59	get_module_symbol() away from us, from the caller. */
	60
	61	struct mtd_info do_map_probe(const char name, struct map_info *map)
	62	{
	63	struct mtd_chip_driver *drv;
	64	struct mtd_info *ret;
65
66	drv = get_mtd_chip_driver(name);
67
68	if (!drv && !request_module("%s", name))
69	drv = get_mtd_chip_driver(name);
70
71	if (!drv)
72	return NULL;
73
74	ret = drv->probe(map);
75
76	/* We decrease the use count here. It may have been a
77	probe-only module, which is no longer required from this
78	point, having given us a handle on (and increased the use
79	count of) the actual driver code.
80	*/
81	module_put(drv->module);
82
83	if (ret)
84	return ret;
85
86	return NULL;
87	}
88	/*
89	* Destroy an MTD device which was created for a map device.
90	* Make sure the MTD device is already unregistered before calling this
91	*/
92	void map_destroy(struct mtd_info *mtd)
93	{
94	struct map_info *map = mtd->priv;
95
96	if (map->fldrv->destroy)
97	map->fldrv->destroy(mtd);
98
99	module_put(map->fldrv->module);
100
101	kfree(mtd);
102	}
103
104	EXPORT_SYMBOL(register_mtd_chip_driver);
105	EXPORT_SYMBOL(unregister_mtd_chip_driver);
106	EXPORT_SYMBOL(do_map_probe);
107	EXPORT_SYMBOL(map_destroy);
108
109	MODULE_LICENSE("GPL");
110	MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
111	MODULE_DESCRIPTION("Core routines for registering and invoking MTD chip drivers");