[net-next-2.6.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)
#define to_class(obj) container_of(obj, struct class, subsys.kobj)

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 *dc = to_class(kobj);
	ssize_t ret = -EIO;

	if (class_attr->show)
		ret = class_attr->show(dc, 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 *dc = to_class(kobj);
	ssize_t ret = -EIO;

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

static void class_release(struct kobject *kobj)
{
	struct class *class = to_class(kobj);

	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_obj 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->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->subsys.kobj, &attr->attr);
}

static struct class *class_get(struct class *cls)
{
	if (cls)
		return container_of(kset_get(&cls->subsys),
				    struct class, subsys);
	return NULL;
}

static void class_put(struct class *cls)
{
	if (cls)
		kset_put(&cls->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)
{
	int error;

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

	INIT_LIST_HEAD(&cls->devices);
	INIT_LIST_HEAD(&cls->interfaces);
	kset_init(&cls->class_dirs);
	init_MUTEX(&cls->sem);
	error = kobject_set_name(&cls->subsys.kobj, "%s", cls->name);
	if (error)
		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)
		cls->subsys.kobj.kset = class_kset;
#else
	cls->subsys.kobj.kset = class_kset;
#endif
	cls->subsys.kobj.ktype = &class_ktype;

	error = kset_register(&cls->subsys);
	if (!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->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->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->sem);
	list_for_each_entry(dev, &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->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->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->sem);
	list_for_each_entry(dev, &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->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->sem);
	list_add_tail(&class_intf->node, &parent->interfaces);
	if (class_intf->add_dev) {
		list_for_each_entry(dev, &parent->devices, node)
			class_intf->add_dev(dev, class_intf);
	}
	up(&parent->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->sem);
	list_del_init(&class_intf->node);
	if (class_intf->remove_dev) {
		list_for_each_entry(dev, &parent->devices, node)
			class_intf->remove_dev(dev, class_intf);
	}
	up(&parent->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)
823bccfc	24	#define to_class(obj) container_of(obj, struct class, subsys.kobj)
1da177e4	25
4a3ad20c GKH	26	static ssize_t class_attr_show(struct kobject kobj, struct attribute attr,
4a3ad20c GKH	27	char *buf)
1da177e4	28	{
4a3ad20c GKH	29	struct class_attribute *class_attr = to_class_attr(attr);
4a3ad20c GKH	30	struct class *dc = to_class(kobj);
4a0c20bf	31	ssize_t ret = -EIO;
1da177e4 LT	32
	33	if (class_attr->show)
	34	ret = class_attr->show(dc, buf);
	35	return ret;
	36	}
	37
4a3ad20c GKH	38	static ssize_t class_attr_store(struct kobject kobj, struct attribute attr,
4a3ad20c GKH	39	const char *buf, size_t count)
1da177e4	40	{
4a3ad20c GKH	41	struct class_attribute *class_attr = to_class_attr(attr);
4a3ad20c GKH	42	struct class *dc = to_class(kobj);
4a0c20bf	43	ssize_t ret = -EIO;
1da177e4 LT	44
	45	if (class_attr->store)
	46	ret = class_attr->store(dc, buf, count);
	47	return ret;
	48	}
	49
4a3ad20c	50	static void class_release(struct kobject *kobj)
1da177e4 LT	51	{
	52	struct class *class = to_class(kobj);
	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
	73	/* Hotplug events for classes go to the class_obj 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)
823bccfc	81	error = sysfs_create_file(&cls->subsys.kobj, &attr->attr);
4a3ad20c	82	else
1da177e4 LT	83	error = -EINVAL;
	84	return error;
	85	}
	86
4a3ad20c	87	void class_remove_file(struct class cls, const struct class_attribute attr)
1da177e4 LT	88	{
1da177e4 LT	89	if (cls)
823bccfc	90	sysfs_remove_file(&cls->subsys.kobj, &attr->attr);
1da177e4 LT	91	}
1da177e4 LT	92
1740757e	93	static struct class class_get(struct class cls)
1da177e4 LT	94	{
1da177e4 LT	95	if (cls)
4a3ad20c GKH	96	return container_of(kset_get(&cls->subsys),
4a3ad20c GKH	97	struct class, subsys);
1da177e4 LT	98	return NULL;
	99	}
	100
4a3ad20c	101	static void class_put(struct class *cls)
1da177e4	102	{
51d172d5	103	if (cls)
6e9d930d	104	kset_put(&cls->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 LT	138	{
	139	int error;
	140
	141	pr_debug("device class '%s': registering\n", cls->name);
	142
23681e47	143	INIT_LIST_HEAD(&cls->devices);
1da177e4	144	INIT_LIST_HEAD(&cls->interfaces);
86406245	145	kset_init(&cls->class_dirs);
1da177e4	146	init_MUTEX(&cls->sem);
823bccfc	147	error = kobject_set_name(&cls->subsys.kobj, "%s", cls->name);
1da177e4 LT	148	if (error)
	149	return error;
	150
e105b8bf DW	151	/* set the default /sys/dev directory for devices of this class */
	152	if (!cls->dev_kobj)
	153	cls->dev_kobj = sysfs_dev_char_kobj;
	154
4e886c29	155	#if defined(CONFIG_SYSFS_DEPRECATED) && defined(CONFIG_BLOCK)
edfaa7c3 KS	156	/* let the block class directory show up in the root of sysfs */
	157	if (cls != &block_class)
	158	cls->subsys.kobj.kset = class_kset;
	159	#else
443dbf90	160	cls->subsys.kobj.kset = class_kset;
edfaa7c3	161	#endif
3514faca	162	cls->subsys.kobj.ktype = &class_ktype;
1da177e4	163
2fb9113b	164	error = kset_register(&cls->subsys);
1da177e4 LT	165	if (!error) {
	166	error = add_class_attrs(class_get(cls));
	167	class_put(cls);
	168	}
	169	return error;
	170	}
	171
4a3ad20c	172	void class_unregister(struct class *cls)
1da177e4 LT	173	{
	174	pr_debug("device class '%s': unregistering\n", cls->name);
	175	remove_class_attrs(cls);
2fb9113b	176	kset_unregister(&cls->subsys);
1da177e4 LT	177	}
1da177e4 LT	178
e9ba6365 GKH	179	static void class_create_release(struct class *cls)
e9ba6365 GKH	180	{
2b3a302a	181	pr_debug("%s called for %s\n", __func__, cls->name);
e9ba6365 GKH	182	kfree(cls);
	183	}
	184
2fc68447 GKH	185	/**
	186	* class_create - create a struct class structure
	187	* @owner: pointer to the module that is to "own" this struct class
	188	* @name: pointer to a string for the name of this class.
	189	*
	190	* This is used to create a struct class pointer that can then be used
c3b19ff0	191	* in calls to device_create().
2fc68447 GKH	192	*
	193	* Note, the pointer created here is to be destroyed when finished by
	194	* making a call to class_destroy().
	195	*/
ab7d7371	196	struct class class_create(struct module owner, const char *name)
e9ba6365 GKH	197	{
	198	struct class *cls;
	199	int retval;
	200
4aed0644	201	cls = kzalloc(sizeof(*cls), GFP_KERNEL);
e9ba6365 GKH	202	if (!cls) {
	203	retval = -ENOMEM;
	204	goto error;
	205	}
e9ba6365 GKH	206
	207	cls->name = name;
	208	cls->owner = owner;
	209	cls->class_release = class_create_release;
e9ba6365 GKH	210
	211	retval = class_register(cls);
	212	if (retval)
	213	goto error;
	214
	215	return cls;
	216
	217	error:
	218	kfree(cls);
	219	return ERR_PTR(retval);
	220	}
	221
2fc68447 GKH	222	/**
2fc68447 GKH	223	* class_destroy - destroys a struct class structure
92a0f861	224	* @cls: pointer to the struct class that is to be destroyed
2fc68447 GKH	225	*
	226	* Note, the pointer to be destroyed must have been created with a call
	227	* to class_create().
	228	*/
e9ba6365 GKH	229	void class_destroy(struct class *cls)
	230	{
	231	if ((cls == NULL) \|\| (IS_ERR(cls)))
	232	return;
	233
	234	class_unregister(cls);
	235	}
1da177e4	236
805fab47 KS	237	#ifdef CONFIG_SYSFS_DEPRECATED
	238	char make_class_name(const char name, struct kobject *kobj)
	239	{
	240	char *class_name;
	241	int size;
	242
	243	size = strlen(name) + strlen(kobject_name(kobj)) + 2;
	244
	245	class_name = kmalloc(size, GFP_KERNEL);
	246	if (!class_name)
cb360bbf	247	return NULL;
805fab47 KS	248
	249	strcpy(class_name, name);
	250	strcat(class_name, ":");
	251	strcat(class_name, kobject_name(kobj));
	252	return class_name;
	253	}
805fab47 KS	254	#endif
805fab47 KS	255
fd04897b DY	256	/**
	257	* class_for_each_device - device iterator
	258	* @class: the class we're iterating
93562b53	259	* @start: the device to start with in the list, if any.
fd04897b DY	260	* @data: data for the callback
	261	* @fn: function to be called for each device
	262	*
	263	* Iterate over @class's list of devices, and call @fn for each,
93562b53 GKH	264	* passing it @data. If @start is set, the list iteration will start
	265	* there, otherwise if it is NULL, the iteration starts at the
	266	* beginning of the list.
fd04897b DY	267	*
	268	* We check the return of @fn each time. If it returns anything
	269	* other than 0, we break out and return that value.
	270	*
	271	* Note, we hold class->sem in this function, so it can not be
	272	* re-acquired in @fn, otherwise it will self-deadlocking. For
	273	* example, calls to add or remove class members would be verboten.
	274	*/
93562b53 GKH	275	int class_for_each_device(struct class class, struct device start,
93562b53 GKH	276	void data, int (fn)(struct device , void ))
fd04897b DY	277	{
	278	struct device *dev;
	279	int error = 0;
	280
	281	if (!class)
	282	return -EINVAL;
	283	down(&class->sem);
	284	list_for_each_entry(dev, &class->devices, node) {
93562b53 GKH	285	if (start) {
	286	if (start == dev)
	287	start = NULL;
	288	continue;
	289	}
fd04897b	290	dev = get_device(dev);
93562b53 GKH	291	error = fn(dev, data);
93562b53 GKH	292	put_device(dev);
fd04897b DY	293	if (error)
	294	break;
	295	}
	296	up(&class->sem);
	297
	298	return error;
	299	}
	300	EXPORT_SYMBOL_GPL(class_for_each_device);
	301
	302	/**
	303	* class_find_device - device iterator for locating a particular device
	304	* @class: the class we're iterating
695794ae	305	* @start: Device to begin with
fd04897b DY	306	* @data: data for the match function
	307	* @match: function to check device
	308	*
	309	* This is similar to the class_for_each_dev() function above, but it
	310	* returns a reference to a device that is 'found' for later use, as
	311	* determined by the @match callback.
	312	*
	313	* The callback should return 0 if the device doesn't match and non-zero
	314	* if it does. If the callback returns non-zero, this function will
	315	* return to the caller and not iterate over any more devices.
a63ca8f6	316	*
fd04897b DY	317	* Note, you will need to drop the reference with put_device() after use.
	318	*
	319	* We hold class->sem in this function, so it can not be
	320	* re-acquired in @match, otherwise it will self-deadlocking. For
	321	* example, calls to add or remove class members would be verboten.
	322	*/
695794ae GKH	323	struct device class_find_device(struct class class, struct device *start,
	324	void *data,
	325	int (match)(struct device , void *))
fd04897b DY	326	{
	327	struct device *dev;
	328	int found = 0;
	329
	330	if (!class)
	331	return NULL;
	332
	333	down(&class->sem);
	334	list_for_each_entry(dev, &class->devices, node) {
695794ae GKH	335	if (start) {
	336	if (start == dev)
	337	start = NULL;
	338	continue;
	339	}
fd04897b	340	dev = get_device(dev);
695794ae GKH	341	if (match(dev, data)) {
695794ae GKH	342	found = 1;
fd04897b	343	break;
695794ae GKH	344	} else
695794ae GKH	345	put_device(dev);
fd04897b DY	346	}
	347	up(&class->sem);
	348
	349	return found ? dev : NULL;
	350	}
	351	EXPORT_SYMBOL_GPL(class_find_device);
	352
1da177e4 LT	353	int class_interface_register(struct class_interface *class_intf)
	354	{
	355	struct class *parent;
c47ed219	356	struct device *dev;
1da177e4 LT	357
	358	if (!class_intf \|\| !class_intf->class)
	359	return -ENODEV;
	360
	361	parent = class_get(class_intf->class);
	362	if (!parent)
	363	return -EINVAL;
	364
	365	down(&parent->sem);
	366	list_add_tail(&class_intf->node, &parent->interfaces);
c47ed219 GKH	367	if (class_intf->add_dev) {
	368	list_for_each_entry(dev, &parent->devices, node)
	369	class_intf->add_dev(dev, class_intf);
	370	}
1da177e4 LT	371	up(&parent->sem);
	372
	373	return 0;
	374	}
	375
	376	void class_interface_unregister(struct class_interface *class_intf)
	377	{
4a3ad20c	378	struct class *parent = class_intf->class;
c47ed219	379	struct device *dev;
1da177e4 LT	380
	381	if (!parent)
	382	return;
	383
	384	down(&parent->sem);
	385	list_del_init(&class_intf->node);
c47ed219 GKH	386	if (class_intf->remove_dev) {
	387	list_for_each_entry(dev, &parent->devices, node)
	388	class_intf->remove_dev(dev, class_intf);
	389	}
1da177e4 LT	390	up(&parent->sem);
	391
	392	class_put(parent);
	393	}
	394
1da177e4 LT	395	int __init classes_init(void)
1da177e4 LT	396	{
443dbf90 GKH	397	class_kset = kset_create_and_add("class", NULL, NULL);
	398	if (!class_kset)
	399	return -ENOMEM;
1da177e4 LT	400	return 0;
	401	}
	402
	403	EXPORT_SYMBOL_GPL(class_create_file);
	404	EXPORT_SYMBOL_GPL(class_remove_file);
	405	EXPORT_SYMBOL_GPL(class_register);
	406	EXPORT_SYMBOL_GPL(class_unregister);
e9ba6365 GKH	407	EXPORT_SYMBOL_GPL(class_create);
e9ba6365 GKH	408	EXPORT_SYMBOL_GPL(class_destroy);
1da177e4	409
1da177e4 LT	410	EXPORT_SYMBOL_GPL(class_interface_register);
1da177e4 LT	411	EXPORT_SYMBOL_GPL(class_interface_unregister);