[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
 * @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.
 *
 * 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, 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) {
		dev = get_device(dev);
		if (dev) {
			error = fn(dev, data);
			put_device(dev);
		} else
			error = -ENODEV;
		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
 * @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, 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) {
		dev = get_device(dev);
		if (dev) {
			if (match(dev, data)) {
				found = 1;
				break;
			} else
				put_device(dev);
		} else
			break;
	}
	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
	259	* @data: data for the callback
	260	* @fn: function to be called for each device
	261	*
	262	* Iterate over @class's list of devices, and call @fn for each,
	263	* passing it @data.
	264	*
	265	* We check the return of @fn each time. If it returns anything
	266	* other than 0, we break out and return that value.
	267	*
	268	* Note, we hold class->sem in this function, so it can not be
	269	* re-acquired in @fn, otherwise it will self-deadlocking. For
	270	* example, calls to add or remove class members would be verboten.
	271	*/
	272	int class_for_each_device(struct class class, void data,
	273	int (fn)(struct device , void *))
	274	{
	275	struct device *dev;
	276	int error = 0;
	277
	278	if (!class)
	279	return -EINVAL;
	280	down(&class->sem);
	281	list_for_each_entry(dev, &class->devices, node) {
	282	dev = get_device(dev);
	283	if (dev) {
	284	error = fn(dev, data);
	285	put_device(dev);
	286	} else
	287	error = -ENODEV;
	288	if (error)
	289	break;
	290	}
	291	up(&class->sem);
	292
	293	return error;
	294	}
	295	EXPORT_SYMBOL_GPL(class_for_each_device);
	296
	297	/**
	298	* class_find_device - device iterator for locating a particular device
	299	* @class: the class we're iterating
	300	* @data: data for the match function
	301	* @match: function to check device
	302	*
	303	* This is similar to the class_for_each_dev() function above, but it
	304	* returns a reference to a device that is 'found' for later use, as
	305	* determined by the @match callback.
	306	*
	307	* The callback should return 0 if the device doesn't match and non-zero
	308	* if it does. If the callback returns non-zero, this function will
	309	* return to the caller and not iterate over any more devices.
a63ca8f6	310	*
fd04897b DY	311	* Note, you will need to drop the reference with put_device() after use.
	312	*
	313	* We hold class->sem in this function, so it can not be
	314	* re-acquired in @match, otherwise it will self-deadlocking. For
	315	* example, calls to add or remove class members would be verboten.
	316	*/
	317	struct device class_find_device(struct class class, void *data,
	318	int (match)(struct device , void *))
	319	{
	320	struct device *dev;
	321	int found = 0;
	322
	323	if (!class)
	324	return NULL;
	325
	326	down(&class->sem);
	327	list_for_each_entry(dev, &class->devices, node) {
	328	dev = get_device(dev);
	329	if (dev) {
	330	if (match(dev, data)) {
	331	found = 1;
	332	break;
	333	} else
	334	put_device(dev);
	335	} else
	336	break;
	337	}
	338	up(&class->sem);
	339
	340	return found ? dev : NULL;
	341	}
	342	EXPORT_SYMBOL_GPL(class_find_device);
	343
1da177e4 LT	344	int class_interface_register(struct class_interface *class_intf)
	345	{
	346	struct class *parent;
c47ed219	347	struct device *dev;
1da177e4 LT	348
	349	if (!class_intf \|\| !class_intf->class)
	350	return -ENODEV;
	351
	352	parent = class_get(class_intf->class);
	353	if (!parent)
	354	return -EINVAL;
	355
	356	down(&parent->sem);
	357	list_add_tail(&class_intf->node, &parent->interfaces);
c47ed219 GKH	358	if (class_intf->add_dev) {
	359	list_for_each_entry(dev, &parent->devices, node)
	360	class_intf->add_dev(dev, class_intf);
	361	}
1da177e4 LT	362	up(&parent->sem);
	363
	364	return 0;
	365	}
	366
	367	void class_interface_unregister(struct class_interface *class_intf)
	368	{
4a3ad20c	369	struct class *parent = class_intf->class;
c47ed219	370	struct device *dev;
1da177e4 LT	371
	372	if (!parent)
	373	return;
	374
	375	down(&parent->sem);
	376	list_del_init(&class_intf->node);
c47ed219 GKH	377	if (class_intf->remove_dev) {
	378	list_for_each_entry(dev, &parent->devices, node)
	379	class_intf->remove_dev(dev, class_intf);
	380	}
1da177e4 LT	381	up(&parent->sem);
	382
	383	class_put(parent);
	384	}
	385
1da177e4 LT	386	int __init classes_init(void)
1da177e4 LT	387	{
443dbf90 GKH	388	class_kset = kset_create_and_add("class", NULL, NULL);
	389	if (!class_kset)
	390	return -ENOMEM;
1da177e4 LT	391	return 0;
	392	}
	393
	394	EXPORT_SYMBOL_GPL(class_create_file);
	395	EXPORT_SYMBOL_GPL(class_remove_file);
	396	EXPORT_SYMBOL_GPL(class_register);
	397	EXPORT_SYMBOL_GPL(class_unregister);
e9ba6365 GKH	398	EXPORT_SYMBOL_GPL(class_create);
e9ba6365 GKH	399	EXPORT_SYMBOL_GPL(class_destroy);
1da177e4	400
1da177e4 LT	401	EXPORT_SYMBOL_GPL(class_interface_register);
1da177e4 LT	402	EXPORT_SYMBOL_GPL(class_interface_unregister);