[deliverable/linux.git] / drivers / base / class.c

/*
 * class.c - basic device class management
 *
 * Copyright (c) 2002-3 Patrick Mochel
 * Copyright (c) 2002-3 Open Source Development Labs
 * Copyright (c) 2003-2004 Greg Kroah-Hartman
 * Copyright (c) 2003-2004 IBM Corp.
 *
 * This file is released under the GPLv2
 *
 */

#include <linux/device.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/kdev_t.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/genhd.h>
#include "base.h"

#define to_class_attr(_attr) container_of(_attr, struct class_attribute, attr)

static ssize_t class_attr_show(struct kobject *kobj, struct attribute *attr,
			       char *buf)
{
	struct class_attribute *class_attr = to_class_attr(attr);
	struct class_private *cp = to_class(kobj);
	ssize_t ret = -EIO;

	if (class_attr->show)
		ret = class_attr->show(cp->class, buf);
	return ret;
}

static ssize_t class_attr_store(struct kobject *kobj, struct attribute *attr,
				const char *buf, size_t count)
{
	struct class_attribute *class_attr = to_class_attr(attr);
	struct class_private *cp = to_class(kobj);
	ssize_t ret = -EIO;

	if (class_attr->store)
		ret = class_attr->store(cp->class, buf, count);
	return ret;
}

static void class_release(struct kobject *kobj)
{
	struct class_private *cp = to_class(kobj);
	struct class *class = cp->class;

	pr_debug("class '%s': release.\n", class->name);

	if (class->class_release)
		class->class_release(class);
	else
		pr_debug("class '%s' does not have a release() function, "
			 "be careful\n", class->name);
}

static struct sysfs_ops class_sysfs_ops = {
	.show	= class_attr_show,
	.store	= class_attr_store,
};

static struct kobj_type class_ktype = {
	.sysfs_ops	= &class_sysfs_ops,
	.release	= class_release,
};

/* Hotplug events for classes go to the class class_subsys */
static struct kset *class_kset;


int class_create_file(struct class *cls, const struct class_attribute *attr)
{
	int error;
	if (cls)
		error = sysfs_create_file(&cls->p->class_subsys.kobj,
					  &attr->attr);
	else
		error = -EINVAL;
	return error;
}

void class_remove_file(struct class *cls, const struct class_attribute *attr)
{
	if (cls)
		sysfs_remove_file(&cls->p->class_subsys.kobj, &attr->attr);
}

static struct class *class_get(struct class *cls)
{
	if (cls)
		kset_get(&cls->p->class_subsys);
	return cls;
}

static void class_put(struct class *cls)
{
	if (cls)
		kset_put(&cls->p->class_subsys);
}

static int add_class_attrs(struct class *cls)
{
	int i;
	int error = 0;

	if (cls->class_attrs) {
		for (i = 0; attr_name(cls->class_attrs[i]); i++) {
			error = class_create_file(cls, &cls->class_attrs[i]);
			if (error)
				goto error;
		}
	}
done:
	return error;
error:
	while (--i >= 0)
		class_remove_file(cls, &cls->class_attrs[i]);
	goto done;
}

static void remove_class_attrs(struct class *cls)
{
	int i;

	if (cls->class_attrs) {
		for (i = 0; attr_name(cls->class_attrs[i]); i++)
			class_remove_file(cls, &cls->class_attrs[i]);
	}
}

int class_register(struct class *cls)
{
	struct class_private *cp;
	int error;

	pr_debug("device class '%s': registering\n", cls->name);

	cp = kzalloc(sizeof(*cp), GFP_KERNEL);
	if (!cp)
		return -ENOMEM;
	INIT_LIST_HEAD(&cp->class_devices);
	INIT_LIST_HEAD(&cp->class_interfaces);
	kset_init(&cp->class_dirs);
	init_MUTEX(&cp->class_sem);
	error = kobject_set_name(&cp->class_subsys.kobj, "%s", cls->name);
	if (error) {
		kfree(cp);
		return error;
	}

	/* set the default /sys/dev directory for devices of this class */
	if (!cls->dev_kobj)
		cls->dev_kobj = sysfs_dev_char_kobj;

#if defined(CONFIG_SYSFS_DEPRECATED) && defined(CONFIG_BLOCK)
	/* let the block class directory show up in the root of sysfs */
	if (cls != &block_class)
		cp->class_subsys.kobj.kset = class_kset;
#else
	cp->class_subsys.kobj.kset = class_kset;
#endif
	cp->class_subsys.kobj.ktype = &class_ktype;
	cp->class = cls;
	cls->p = cp;

	error = kset_register(&cp->class_subsys);
	if (error) {
		kfree(cp);
		return error;
	}
	error = add_class_attrs(class_get(cls));
	class_put(cls);
	return error;
}

void class_unregister(struct class *cls)
{
	pr_debug("device class '%s': unregistering\n", cls->name);
	remove_class_attrs(cls);
	kset_unregister(&cls->p->class_subsys);
}

static void class_create_release(struct class *cls)
{
	pr_debug("%s called for %s\n", __func__, cls->name);
	kfree(cls);
}

/**
 * class_create - create a struct class structure
 * @owner: pointer to the module that is to "own" this struct class
 * @name: pointer to a string for the name of this class.
 *
 * This is used to create a struct class pointer that can then be used
 * in calls to device_create().
 *
 * Note, the pointer created here is to be destroyed when finished by
 * making a call to class_destroy().
 */
struct class *class_create(struct module *owner, const char *name)
{
	struct class *cls;
	int retval;

	cls = kzalloc(sizeof(*cls), GFP_KERNEL);
	if (!cls) {
		retval = -ENOMEM;
		goto error;
	}

	cls->name = name;
	cls->owner = owner;
	cls->class_release = class_create_release;

	retval = class_register(cls);
	if (retval)
		goto error;

	return cls;

error:
	kfree(cls);
	return ERR_PTR(retval);
}

/**
 * class_destroy - destroys a struct class structure
 * @cls: pointer to the struct class that is to be destroyed
 *
 * Note, the pointer to be destroyed must have been created with a call
 * to class_create().
 */
void class_destroy(struct class *cls)
{
	if ((cls == NULL) || (IS_ERR(cls)))
		return;

	class_unregister(cls);
}

#ifdef CONFIG_SYSFS_DEPRECATED
char *make_class_name(const char *name, struct kobject *kobj)
{
	char *class_name;
	int size;

	size = strlen(name) + strlen(kobject_name(kobj)) + 2;

	class_name = kmalloc(size, GFP_KERNEL);
	if (!class_name)
		return NULL;

	strcpy(class_name, name);
	strcat(class_name, ":");
	strcat(class_name, kobject_name(kobj));
	return class_name;
}
#endif

/**
 * class_for_each_device - device iterator
 * @class: the class we're iterating
 * @start: the device to start with in the list, if any.
 * @data: data for the callback
 * @fn: function to be called for each device
 *
 * Iterate over @class's list of devices, and call @fn for each,
 * passing it @data.  If @start is set, the list iteration will start
 * there, otherwise if it is NULL, the iteration starts at the
 * beginning of the list.
 *
 * We check the return of @fn each time. If it returns anything
 * other than 0, we break out and return that value.
 *
 * Note, we hold class->class_sem in this function, so it can not be
 * re-acquired in @fn, otherwise it will self-deadlocking. For
 * example, calls to add or remove class members would be verboten.
 */
int class_for_each_device(struct class *class, struct device *start,
			  void *data, int (*fn)(struct device *, void *))
{
	struct device *dev;
	int error = 0;

	if (!class)
		return -EINVAL;
	down(&class->p->class_sem);
	list_for_each_entry(dev, &class->p->class_devices, node) {
		if (start) {
			if (start == dev)
				start = NULL;
			continue;
		}
		dev = get_device(dev);
		error = fn(dev, data);
		put_device(dev);
		if (error)
			break;
	}
	up(&class->p->class_sem);

	return error;
}
EXPORT_SYMBOL_GPL(class_for_each_device);

/**
 * class_find_device - device iterator for locating a particular device
 * @class: the class we're iterating
 * @start: Device to begin with
 * @data: data for the match function
 * @match: function to check device
 *
 * This is similar to the class_for_each_dev() function above, but it
 * returns a reference to a device that is 'found' for later use, as
 * determined by the @match callback.
 *
 * The callback should return 0 if the device doesn't match and non-zero
 * if it does.  If the callback returns non-zero, this function will
 * return to the caller and not iterate over any more devices.
 *
 * Note, you will need to drop the reference with put_device() after use.
 *
 * We hold class->class_sem in this function, so it can not be
 * re-acquired in @match, otherwise it will self-deadlocking. For
 * example, calls to add or remove class members would be verboten.
 */
struct device *class_find_device(struct class *class, struct device *start,
				 void *data,
				 int (*match)(struct device *, void *))
{
	struct device *dev;
	int found = 0;

	if (!class)
		return NULL;

	down(&class->p->class_sem);
	list_for_each_entry(dev, &class->p->class_devices, node) {
		if (start) {
			if (start == dev)
				start = NULL;
			continue;
		}
		dev = get_device(dev);
		if (match(dev, data)) {
			found = 1;
			break;
		} else
			put_device(dev);
	}
	up(&class->p->class_sem);

	return found ? dev : NULL;
}
EXPORT_SYMBOL_GPL(class_find_device);

int class_interface_register(struct class_interface *class_intf)
{
	struct class *parent;
	struct device *dev;

	if (!class_intf || !class_intf->class)
		return -ENODEV;

	parent = class_get(class_intf->class);
	if (!parent)
		return -EINVAL;

	down(&parent->p->class_sem);
	list_add_tail(&class_intf->node, &parent->p->class_interfaces);
	if (class_intf->add_dev) {
		list_for_each_entry(dev, &parent->p->class_devices, node)
			class_intf->add_dev(dev, class_intf);
	}
	up(&parent->p->class_sem);

	return 0;
}

void class_interface_unregister(struct class_interface *class_intf)
{
	struct class *parent = class_intf->class;
	struct device *dev;

	if (!parent)
		return;

	down(&parent->p->class_sem);
	list_del_init(&class_intf->node);
	if (class_intf->remove_dev) {
		list_for_each_entry(dev, &parent->p->class_devices, node)
			class_intf->remove_dev(dev, class_intf);
	}
	up(&parent->p->class_sem);

	class_put(parent);
}

int __init classes_init(void)
{
	class_kset = kset_create_and_add("class", NULL, NULL);
	if (!class_kset)
		return -ENOMEM;
	return 0;
}

EXPORT_SYMBOL_GPL(class_create_file);
EXPORT_SYMBOL_GPL(class_remove_file);
EXPORT_SYMBOL_GPL(class_register);
EXPORT_SYMBOL_GPL(class_unregister);
EXPORT_SYMBOL_GPL(class_create);
EXPORT_SYMBOL_GPL(class_destroy);

EXPORT_SYMBOL_GPL(class_interface_register);
EXPORT_SYMBOL_GPL(class_interface_unregister);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* class.c - basic device class management
	3	*
	4	* Copyright (c) 2002-3 Patrick Mochel
	5	* Copyright (c) 2002-3 Open Source Development Labs
	6	* Copyright (c) 2003-2004 Greg Kroah-Hartman
	7	* Copyright (c) 2003-2004 IBM Corp.
	8	*
	9	* This file is released under the GPLv2
	10	*
	11	*/
	12
1da177e4 LT	13	#include <linux/device.h>
	14	#include <linux/module.h>
	15	#include <linux/init.h>
	16	#include <linux/string.h>
	17	#include <linux/kdev_t.h>
e9ba6365	18	#include <linux/err.h>
4e57b681	19	#include <linux/slab.h>
edfaa7c3	20	#include <linux/genhd.h>
1da177e4 LT	21	#include "base.h"
	22
	23	#define to_class_attr(_attr) container_of(_attr, struct class_attribute, attr)
1da177e4	24
4a3ad20c GKH	25	static ssize_t class_attr_show(struct kobject kobj, struct attribute attr,
4a3ad20c GKH	26	char *buf)
1da177e4	27	{
4a3ad20c	28	struct class_attribute *class_attr = to_class_attr(attr);
7c71448b	29	struct class_private *cp = to_class(kobj);
4a0c20bf	30	ssize_t ret = -EIO;
1da177e4 LT	31
1da177e4 LT	32	if (class_attr->show)
7c71448b	33	ret = class_attr->show(cp->class, buf);
1da177e4 LT	34	return ret;
	35	}
	36
4a3ad20c GKH	37	static ssize_t class_attr_store(struct kobject kobj, struct attribute attr,
4a3ad20c GKH	38	const char *buf, size_t count)
1da177e4	39	{
4a3ad20c	40	struct class_attribute *class_attr = to_class_attr(attr);
7c71448b	41	struct class_private *cp = to_class(kobj);
4a0c20bf	42	ssize_t ret = -EIO;
1da177e4 LT	43
1da177e4 LT	44	if (class_attr->store)
7c71448b	45	ret = class_attr->store(cp->class, buf, count);
1da177e4 LT	46	return ret;
	47	}
	48
4a3ad20c	49	static void class_release(struct kobject *kobj)
1da177e4	50	{
7c71448b GKH	51	struct class_private *cp = to_class(kobj);
7c71448b GKH	52	struct class *class = cp->class;
1da177e4 LT	53
	54	pr_debug("class '%s': release.\n", class->name);
	55
	56	if (class->class_release)
	57	class->class_release(class);
	58	else
	59	pr_debug("class '%s' does not have a release() function, "
	60	"be careful\n", class->name);
	61	}
	62
	63	static struct sysfs_ops class_sysfs_ops = {
	64	.show = class_attr_show,
	65	.store = class_attr_store,
	66	};
	67
adc56808	68	static struct kobj_type class_ktype = {
1da177e4 LT	69	.sysfs_ops = &class_sysfs_ops,
	70	.release = class_release,
	71	};
	72
1fbfee6c	73	/* Hotplug events for classes go to the class class_subsys */
443dbf90	74	static struct kset *class_kset;
1da177e4 LT	75
1da177e4 LT	76
4a3ad20c	77	int class_create_file(struct class cls, const struct class_attribute attr)
1da177e4 LT	78	{
1da177e4 LT	79	int error;
4a3ad20c	80	if (cls)
1fbfee6c GKH	81	error = sysfs_create_file(&cls->p->class_subsys.kobj,
1fbfee6c GKH	82	&attr->attr);
4a3ad20c	83	else
1da177e4 LT	84	error = -EINVAL;
	85	return error;
	86	}
	87
4a3ad20c	88	void class_remove_file(struct class cls, const struct class_attribute attr)
1da177e4 LT	89	{
1da177e4 LT	90	if (cls)
1fbfee6c	91	sysfs_remove_file(&cls->p->class_subsys.kobj, &attr->attr);
1da177e4 LT	92	}
1da177e4 LT	93
1740757e	94	static struct class class_get(struct class cls)
1da177e4 LT	95	{
1da177e4 LT	96	if (cls)
1fbfee6c	97	kset_get(&cls->p->class_subsys);
7c71448b	98	return cls;
1da177e4 LT	99	}
1da177e4 LT	100
4a3ad20c	101	static void class_put(struct class *cls)
1da177e4	102	{
51d172d5	103	if (cls)
1fbfee6c	104	kset_put(&cls->p->class_subsys);
1da177e4 LT	105	}
1da177e4 LT	106
4a3ad20c	107	static int add_class_attrs(struct class *cls)
1da177e4 LT	108	{
	109	int i;
	110	int error = 0;
	111
	112	if (cls->class_attrs) {
	113	for (i = 0; attr_name(cls->class_attrs[i]); i++) {
4a3ad20c	114	error = class_create_file(cls, &cls->class_attrs[i]);
1da177e4	115	if (error)
4a3ad20c	116	goto error;
1da177e4 LT	117	}
1da177e4 LT	118	}
4a3ad20c	119	done:
1da177e4	120	return error;
4a3ad20c	121	error:
1da177e4	122	while (--i >= 0)
4a3ad20c GKH	123	class_remove_file(cls, &cls->class_attrs[i]);
4a3ad20c GKH	124	goto done;
1da177e4 LT	125	}
1da177e4 LT	126
4a3ad20c	127	static void remove_class_attrs(struct class *cls)
1da177e4 LT	128	{
	129	int i;
	130
	131	if (cls->class_attrs) {
	132	for (i = 0; attr_name(cls->class_attrs[i]); i++)
4a3ad20c	133	class_remove_file(cls, &cls->class_attrs[i]);
1da177e4 LT	134	}
	135	}
	136
4a3ad20c	137	int class_register(struct class *cls)
1da177e4	138	{
7c71448b	139	struct class_private *cp;
1da177e4 LT	140	int error;
	141
	142	pr_debug("device class '%s': registering\n", cls->name);
	143
7c71448b GKH	144	cp = kzalloc(sizeof(*cp), GFP_KERNEL);
	145	if (!cp)
	146	return -ENOMEM;
97ae69fd	147	INIT_LIST_HEAD(&cp->class_devices);
184f1f77	148	INIT_LIST_HEAD(&cp->class_interfaces);
7c71448b	149	kset_init(&cp->class_dirs);
d9a01573	150	init_MUTEX(&cp->class_sem);
1fbfee6c	151	error = kobject_set_name(&cp->class_subsys.kobj, "%s", cls->name);
7c71448b GKH	152	if (error) {
7c71448b GKH	153	kfree(cp);
1da177e4	154	return error;
7c71448b	155	}
1da177e4	156
e105b8bf DW	157	/* set the default /sys/dev directory for devices of this class */
	158	if (!cls->dev_kobj)
	159	cls->dev_kobj = sysfs_dev_char_kobj;
	160
4e886c29	161	#if defined(CONFIG_SYSFS_DEPRECATED) && defined(CONFIG_BLOCK)
edfaa7c3 KS	162	/* let the block class directory show up in the root of sysfs */
edfaa7c3 KS	163	if (cls != &block_class)
1fbfee6c	164	cp->class_subsys.kobj.kset = class_kset;
edfaa7c3	165	#else
1fbfee6c	166	cp->class_subsys.kobj.kset = class_kset;
edfaa7c3	167	#endif
1fbfee6c	168	cp->class_subsys.kobj.ktype = &class_ktype;
7c71448b GKH	169	cp->class = cls;
7c71448b GKH	170	cls->p = cp;
1da177e4	171
1fbfee6c	172	error = kset_register(&cp->class_subsys);
7c71448b GKH	173	if (error) {
	174	kfree(cp);
	175	return error;
1da177e4	176	}
7c71448b GKH	177	error = add_class_attrs(class_get(cls));
7c71448b GKH	178	class_put(cls);
1da177e4 LT	179	return error;
	180	}
	181
4a3ad20c	182	void class_unregister(struct class *cls)
1da177e4 LT	183	{
	184	pr_debug("device class '%s': unregistering\n", cls->name);
	185	remove_class_attrs(cls);
1fbfee6c	186	kset_unregister(&cls->p->class_subsys);
1da177e4 LT	187	}
1da177e4 LT	188
e9ba6365	189	static void class_create_release(struct class *cls)
e9ba6365	190	{
2b3a302a	191	pr_debug("%s called for %s\n", __func__, cls->name);
e9ba6365	192	kfree(cls);
	193	}
	194
2fc68447	195	/**
	196	* class_create - create a struct class structure
	197	* @owner: pointer to the module that is to "own" this struct class
	198	* @name: pointer to a string for the name of this class.
	199	*
	200	* This is used to create a struct class pointer that can then be used
c3b19ff0	201	* in calls to device_create().
2fc68447	202	*
	203	* Note, the pointer created here is to be destroyed when finished by
	204	* making a call to class_destroy().
	205	*/
ab7d7371	206	struct class class_create(struct module owner, const char *name)
e9ba6365	207	{
	208	struct class *cls;
	209	int retval;
	210
4aed0644	211	cls = kzalloc(sizeof(*cls), GFP_KERNEL);
e9ba6365	212	if (!cls) {
	213	retval = -ENOMEM;
	214	goto error;
	215	}
e9ba6365	216
	217	cls->name = name;
	218	cls->owner = owner;
	219	cls->class_release = class_create_release;
e9ba6365	220
	221	retval = class_register(cls);
	222	if (retval)
	223	goto error;
	224
	225	return cls;
	226
	227	error:
	228	kfree(cls);
	229	return ERR_PTR(retval);
	230	}
	231
2fc68447	232	/**
2fc68447	233	* class_destroy - destroys a struct class structure
92a0f861	234	* @cls: pointer to the struct class that is to be destroyed
2fc68447	235	*
	236	* Note, the pointer to be destroyed must have been created with a call
	237	* to class_create().
	238	*/
e9ba6365	239	void class_destroy(struct class *cls)
	240	{
	241	if ((cls == NULL) \|\| (IS_ERR(cls)))
	242	return;
	243
	244	class_unregister(cls);
	245	}
1da177e4	246
805fab47 KS	247	#ifdef CONFIG_SYSFS_DEPRECATED
	248	char make_class_name(const char name, struct kobject *kobj)
	249	{
	250	char *class_name;
	251	int size;
	252
	253	size = strlen(name) + strlen(kobject_name(kobj)) + 2;
	254
	255	class_name = kmalloc(size, GFP_KERNEL);
	256	if (!class_name)
cb360bbf	257	return NULL;
805fab47 KS	258
	259	strcpy(class_name, name);
	260	strcat(class_name, ":");
	261	strcat(class_name, kobject_name(kobj));
	262	return class_name;
	263	}
805fab47 KS	264	#endif
805fab47 KS	265
fd04897b DY	266	/**
	267	* class_for_each_device - device iterator
	268	* @class: the class we're iterating
93562b53	269	* @start: the device to start with in the list, if any.
fd04897b DY	270	* @data: data for the callback
	271	* @fn: function to be called for each device
	272	*
	273	* Iterate over @class's list of devices, and call @fn for each,
93562b53 GKH	274	* passing it @data. If @start is set, the list iteration will start
	275	* there, otherwise if it is NULL, the iteration starts at the
	276	* beginning of the list.
fd04897b DY	277	*
	278	* We check the return of @fn each time. If it returns anything
	279	* other than 0, we break out and return that value.
	280	*
d9a01573	281	* Note, we hold class->class_sem in this function, so it can not be
fd04897b DY	282	* re-acquired in @fn, otherwise it will self-deadlocking. For
	283	* example, calls to add or remove class members would be verboten.
	284	*/
93562b53 GKH	285	int class_for_each_device(struct class class, struct device start,
93562b53 GKH	286	void data, int (fn)(struct device , void ))
fd04897b DY	287	{
	288	struct device *dev;
	289	int error = 0;
	290
	291	if (!class)
	292	return -EINVAL;
d9a01573	293	down(&class->p->class_sem);
97ae69fd	294	list_for_each_entry(dev, &class->p->class_devices, node) {
93562b53 GKH	295	if (start) {
	296	if (start == dev)
	297	start = NULL;
	298	continue;
	299	}
fd04897b	300	dev = get_device(dev);
93562b53 GKH	301	error = fn(dev, data);
93562b53 GKH	302	put_device(dev);
fd04897b DY	303	if (error)
	304	break;
	305	}
d9a01573	306	up(&class->p->class_sem);
fd04897b DY	307
	308	return error;
	309	}
	310	EXPORT_SYMBOL_GPL(class_for_each_device);
	311
	312	/**
	313	* class_find_device - device iterator for locating a particular device
	314	* @class: the class we're iterating
695794ae	315	* @start: Device to begin with
fd04897b DY	316	* @data: data for the match function
	317	* @match: function to check device
	318	*
	319	* This is similar to the class_for_each_dev() function above, but it
	320	* returns a reference to a device that is 'found' for later use, as
	321	* determined by the @match callback.
	322	*
	323	* The callback should return 0 if the device doesn't match and non-zero
	324	* if it does. If the callback returns non-zero, this function will
	325	* return to the caller and not iterate over any more devices.
a63ca8f6	326	*
fd04897b DY	327	* Note, you will need to drop the reference with put_device() after use.
fd04897b DY	328	*
d9a01573	329	* We hold class->class_sem in this function, so it can not be
fd04897b DY	330	* re-acquired in @match, otherwise it will self-deadlocking. For
	331	* example, calls to add or remove class members would be verboten.
	332	*/
695794ae GKH	333	struct device class_find_device(struct class class, struct device *start,
	334	void *data,
	335	int (match)(struct device , void *))
fd04897b DY	336	{
	337	struct device *dev;
	338	int found = 0;
	339
	340	if (!class)
	341	return NULL;
	342
d9a01573	343	down(&class->p->class_sem);
97ae69fd	344	list_for_each_entry(dev, &class->p->class_devices, node) {
695794ae GKH	345	if (start) {
	346	if (start == dev)
	347	start = NULL;
	348	continue;
	349	}
fd04897b	350	dev = get_device(dev);
695794ae GKH	351	if (match(dev, data)) {
695794ae GKH	352	found = 1;
fd04897b	353	break;
695794ae GKH	354	} else
695794ae GKH	355	put_device(dev);
fd04897b	356	}
d9a01573	357	up(&class->p->class_sem);
fd04897b DY	358
	359	return found ? dev : NULL;
	360	}
	361	EXPORT_SYMBOL_GPL(class_find_device);
	362
1da177e4 LT	363	int class_interface_register(struct class_interface *class_intf)
	364	{
	365	struct class *parent;
c47ed219	366	struct device *dev;
1da177e4 LT	367
	368	if (!class_intf \|\| !class_intf->class)
	369	return -ENODEV;
	370
	371	parent = class_get(class_intf->class);
	372	if (!parent)
	373	return -EINVAL;
	374
d9a01573	375	down(&parent->p->class_sem);
184f1f77	376	list_add_tail(&class_intf->node, &parent->p->class_interfaces);
c47ed219	377	if (class_intf->add_dev) {
97ae69fd	378	list_for_each_entry(dev, &parent->p->class_devices, node)
c47ed219 GKH	379	class_intf->add_dev(dev, class_intf);
c47ed219 GKH	380	}
d9a01573	381	up(&parent->p->class_sem);
1da177e4 LT	382
	383	return 0;
	384	}
	385
	386	void class_interface_unregister(struct class_interface *class_intf)
	387	{
4a3ad20c	388	struct class *parent = class_intf->class;
c47ed219	389	struct device *dev;
1da177e4 LT	390
	391	if (!parent)
	392	return;
	393
d9a01573	394	down(&parent->p->class_sem);
1da177e4	395	list_del_init(&class_intf->node);
c47ed219	396	if (class_intf->remove_dev) {
97ae69fd	397	list_for_each_entry(dev, &parent->p->class_devices, node)
c47ed219 GKH	398	class_intf->remove_dev(dev, class_intf);
c47ed219 GKH	399	}
d9a01573	400	up(&parent->p->class_sem);
1da177e4 LT	401
	402	class_put(parent);
	403	}
	404
1da177e4 LT	405	int __init classes_init(void)
1da177e4 LT	406	{
443dbf90 GKH	407	class_kset = kset_create_and_add("class", NULL, NULL);
	408	if (!class_kset)
	409	return -ENOMEM;
1da177e4 LT	410	return 0;
	411	}
	412
	413	EXPORT_SYMBOL_GPL(class_create_file);
	414	EXPORT_SYMBOL_GPL(class_remove_file);
	415	EXPORT_SYMBOL_GPL(class_register);
	416	EXPORT_SYMBOL_GPL(class_unregister);
e9ba6365	417	EXPORT_SYMBOL_GPL(class_create);
e9ba6365	418	EXPORT_SYMBOL_GPL(class_destroy);
1da177e4	419
1da177e4 LT	420	EXPORT_SYMBOL_GPL(class_interface_register);
1da177e4 LT	421	EXPORT_SYMBOL_GPL(class_interface_unregister);