[net-next-2.6.git] / drivers / base / attribute_container.c

/*
 * attribute_container.c - implementation of a simple container for classes
 *
 * Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
 *
 * This file is licensed under GPLv2
 *
 * The basic idea here is to enable a device to be attached to an
 * aritrary numer of classes without having to allocate storage for them.
 * Instead, the contained classes select the devices they need to attach
 * to via a matching function.
 */

#include <linux/attribute_container.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/mutex.h>

#include "base.h"

/* This is a private structure used to tie the classdev and the
 * container .. it should never be visible outside this file */
struct internal_container {
	struct klist_node node;
	struct attribute_container *cont;
	struct device classdev;
};

static void internal_container_klist_get(struct klist_node *n)
{
	struct internal_container *ic =
		container_of(n, struct internal_container, node);
	get_device(&ic->classdev);
}

static void internal_container_klist_put(struct klist_node *n)
{
	struct internal_container *ic =
		container_of(n, struct internal_container, node);
	put_device(&ic->classdev);
}


/**
 * attribute_container_classdev_to_container - given a classdev, return the container
 *
 * @classdev: the class device created by attribute_container_add_device.
 *
 * Returns the container associated with this classdev.
 */
struct attribute_container *
attribute_container_classdev_to_container(struct device *classdev)
{
	struct internal_container *ic =
		container_of(classdev, struct internal_container, classdev);
	return ic->cont;
}
EXPORT_SYMBOL_GPL(attribute_container_classdev_to_container);

static LIST_HEAD(attribute_container_list);

static DEFINE_MUTEX(attribute_container_mutex);

/**
 * attribute_container_register - register an attribute container
 *
 * @cont: The container to register.  This must be allocated by the
 *        callee and should also be zeroed by it.
 */
int
attribute_container_register(struct attribute_container *cont)
{
	INIT_LIST_HEAD(&cont->node);
	klist_init(&cont->containers,internal_container_klist_get,
		   internal_container_klist_put);
		
	mutex_lock(&attribute_container_mutex);
	list_add_tail(&cont->node, &attribute_container_list);
	mutex_unlock(&attribute_container_mutex);

	return 0;
}
EXPORT_SYMBOL_GPL(attribute_container_register);

/**
 * attribute_container_unregister - remove a container registration
 *
 * @cont: previously registered container to remove
 */
int
attribute_container_unregister(struct attribute_container *cont)
{
	int retval = -EBUSY;
	mutex_lock(&attribute_container_mutex);
	spin_lock(&cont->containers.k_lock);
	if (!list_empty(&cont->containers.k_list))
		goto out;
	retval = 0;
	list_del(&cont->node);
 out:
	spin_unlock(&cont->containers.k_lock);
	mutex_unlock(&attribute_container_mutex);
	return retval;
		
}
EXPORT_SYMBOL_GPL(attribute_container_unregister);

/* private function used as class release */
static void attribute_container_release(struct device *classdev)
{
	struct internal_container *ic 
		= container_of(classdev, struct internal_container, classdev);
	struct device *dev = classdev->parent;

	kfree(ic);
	put_device(dev);
}

/**
 * attribute_container_add_device - see if any container is interested in dev
 *
 * @dev: device to add attributes to
 * @fn:	 function to trigger addition of class device.
 *
 * This function allocates storage for the class device(s) to be
 * attached to dev (one for each matching attribute_container).  If no
 * fn is provided, the code will simply register the class device via
 * device_add.  If a function is provided, it is expected to add
 * the class device at the appropriate time.  One of the things that
 * might be necessary is to allocate and initialise the classdev and
 * then add it a later time.  To do this, call this routine for
 * allocation and initialisation and then use
 * attribute_container_device_trigger() to call device_add() on
 * it.  Note: after this, the class device contains a reference to dev
 * which is not relinquished until the release of the classdev.
 */
void
attribute_container_add_device(struct device *dev,
			       int (*fn)(struct attribute_container *,
					 struct device *,
					 struct device *))
{
	struct attribute_container *cont;

	mutex_lock(&attribute_container_mutex);
	list_for_each_entry(cont, &attribute_container_list, node) {
		struct internal_container *ic;

		if (attribute_container_no_classdevs(cont))
			continue;

		if (!cont->match(cont, dev))
			continue;

		ic = kzalloc(sizeof(*ic), GFP_KERNEL);
		if (!ic) {
			dev_printk(KERN_ERR, dev, "failed to allocate class container\n");
			continue;
		}

		ic->cont = cont;
		device_initialize(&ic->classdev);
		ic->classdev.parent = get_device(dev);
		ic->classdev.class = cont->class;
		cont->class->dev_release = attribute_container_release;
		dev_set_name(&ic->classdev, dev_name(dev));
		if (fn)
			fn(cont, dev, &ic->classdev);
		else
			attribute_container_add_class_device(&ic->classdev);
		klist_add_tail(&ic->node, &cont->containers);
	}
	mutex_unlock(&attribute_container_mutex);
}

/* FIXME: can't break out of this unless klist_iter_exit is also
 * called before doing the break
 */
#define klist_for_each_entry(pos, head, member, iter) \
	for (klist_iter_init(head, iter); (pos = ({ \
		struct klist_node *n = klist_next(iter); \
		n ? container_of(n, typeof(*pos), member) : \
			({ klist_iter_exit(iter) ; NULL; }); \
	}) ) != NULL; )
			

/**
 * attribute_container_remove_device - make device eligible for removal.
 *
 * @dev:  The generic device
 * @fn:	  A function to call to remove the device
 *
 * This routine triggers device removal.  If fn is NULL, then it is
 * simply done via device_unregister (note that if something
 * still has a reference to the classdev, then the memory occupied
 * will not be freed until the classdev is released).  If you want a
 * two phase release: remove from visibility and then delete the
 * device, then you should use this routine with a fn that calls
 * device_del() and then use attribute_container_device_trigger()
 * to do the final put on the classdev.
 */
void
attribute_container_remove_device(struct device *dev,
				  void (*fn)(struct attribute_container *,
					     struct device *,
					     struct device *))
{
	struct attribute_container *cont;

	mutex_lock(&attribute_container_mutex);
	list_for_each_entry(cont, &attribute_container_list, node) {
		struct internal_container *ic;
		struct klist_iter iter;

		if (attribute_container_no_classdevs(cont))
			continue;

		if (!cont->match(cont, dev))
			continue;

		klist_for_each_entry(ic, &cont->containers, node, &iter) {
			if (dev != ic->classdev.parent)
				continue;
			klist_del(&ic->node);
			if (fn)
				fn(cont, dev, &ic->classdev);
			else {
				attribute_container_remove_attrs(&ic->classdev);
				device_unregister(&ic->classdev);
			}
		}
	}
	mutex_unlock(&attribute_container_mutex);
}

/**
 * attribute_container_device_trigger - execute a trigger for each matching classdev
 *
 * @dev:  The generic device to run the trigger for
 * @fn	  the function to execute for each classdev.
 *
 * This funcion is for executing a trigger when you need to know both
 * the container and the classdev.  If you only care about the
 * container, then use attribute_container_trigger() instead.
 */
void
attribute_container_device_trigger(struct device *dev, 
				   int (*fn)(struct attribute_container *,
					     struct device *,
					     struct device *))
{
	struct attribute_container *cont;

	mutex_lock(&attribute_container_mutex);
	list_for_each_entry(cont, &attribute_container_list, node) {
		struct internal_container *ic;
		struct klist_iter iter;

		if (!cont->match(cont, dev))
			continue;

		if (attribute_container_no_classdevs(cont)) {
			fn(cont, dev, NULL);
			continue;
		}

		klist_for_each_entry(ic, &cont->containers, node, &iter) {
			if (dev == ic->classdev.parent)
				fn(cont, dev, &ic->classdev);
		}
	}
	mutex_unlock(&attribute_container_mutex);
}

/**
 * attribute_container_trigger - trigger a function for each matching container
 *
 * @dev:  The generic device to activate the trigger for
 * @fn:	  the function to trigger
 *
 * This routine triggers a function that only needs to know the
 * matching containers (not the classdev) associated with a device.
 * It is more lightweight than attribute_container_device_trigger, so
 * should be used in preference unless the triggering function
 * actually needs to know the classdev.
 */
void
attribute_container_trigger(struct device *dev,
			    int (*fn)(struct attribute_container *,
				      struct device *))
{
	struct attribute_container *cont;

	mutex_lock(&attribute_container_mutex);
	list_for_each_entry(cont, &attribute_container_list, node) {
		if (cont->match(cont, dev))
			fn(cont, dev);
	}
	mutex_unlock(&attribute_container_mutex);
}

/**
 * attribute_container_add_attrs - add attributes
 *
 * @classdev: The class device
 *
 * This simply creates all the class device sysfs files from the
 * attributes listed in the container
 */
int
attribute_container_add_attrs(struct device *classdev)
{
	struct attribute_container *cont =
		attribute_container_classdev_to_container(classdev);
	struct device_attribute **attrs = cont->attrs;
	int i, error;

	BUG_ON(attrs && cont->grp);

	if (!attrs && !cont->grp)
		return 0;

	if (cont->grp)
		return sysfs_create_group(&classdev->kobj, cont->grp);

	for (i = 0; attrs[i]; i++) {
		sysfs_attr_init(&attrs[i]->attr);
		error = device_create_file(classdev, attrs[i]);
		if (error)
			return error;
	}

	return 0;
}

/**
 * attribute_container_add_class_device - same function as device_add
 *
 * @classdev:	the class device to add
 *
 * This performs essentially the same function as device_add except for
 * attribute containers, namely add the classdev to the system and then
 * create the attribute files
 */
int
attribute_container_add_class_device(struct device *classdev)
{
	int error = device_add(classdev);
	if (error)
		return error;
	return attribute_container_add_attrs(classdev);
}

/**
 * attribute_container_add_class_device_adapter - simple adapter for triggers
 *
 * This function is identical to attribute_container_add_class_device except
 * that it is designed to be called from the triggers
 */
int
attribute_container_add_class_device_adapter(struct attribute_container *cont,
					     struct device *dev,
					     struct device *classdev)
{
	return attribute_container_add_class_device(classdev);
}

/**
 * attribute_container_remove_attrs - remove any attribute files
 *
 * @classdev: The class device to remove the files from
 *
 */
void
attribute_container_remove_attrs(struct device *classdev)
{
	struct attribute_container *cont =
		attribute_container_classdev_to_container(classdev);
	struct device_attribute **attrs = cont->attrs;
	int i;

	if (!attrs && !cont->grp)
		return;

	if (cont->grp) {
		sysfs_remove_group(&classdev->kobj, cont->grp);
		return ;
	}

	for (i = 0; attrs[i]; i++)
		device_remove_file(classdev, attrs[i]);
}

/**
 * attribute_container_class_device_del - equivalent of class_device_del
 *
 * @classdev: the class device
 *
 * This function simply removes all the attribute files and then calls
 * device_del.
 */
void
attribute_container_class_device_del(struct device *classdev)
{
	attribute_container_remove_attrs(classdev);
	device_del(classdev);
}

/**
 * attribute_container_find_class_device - find the corresponding class_device
 *
 * @cont:	the container
 * @dev:	the generic device
 *
 * Looks up the device in the container's list of class devices and returns
 * the corresponding class_device.
 */
struct device *
attribute_container_find_class_device(struct attribute_container *cont,
				      struct device *dev)
{
	struct device *cdev = NULL;
	struct internal_container *ic;
	struct klist_iter iter;

	klist_for_each_entry(ic, &cont->containers, node, &iter) {
		if (ic->classdev.parent == dev) {
			cdev = &ic->classdev;
			/* FIXME: must exit iterator then break */
			klist_iter_exit(&iter);
			break;
		}
	}

	return cdev;
}
EXPORT_SYMBOL_GPL(attribute_container_find_class_device);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* attribute_container.c - implementation of a simple container for classes
	3	*
	4	* Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
	5	*
	6	* This file is licensed under GPLv2
	7	*
	8	* The basic idea here is to enable a device to be attached to an
	9	* aritrary numer of classes without having to allocate storage for them.
	10	* Instead, the contained classes select the devices they need to attach
	11	* to via a matching function.
	12	*/
	13
	14	#include <linux/attribute_container.h>
	15	#include <linux/init.h>
	16	#include <linux/device.h>
	17	#include <linux/kernel.h>
	18	#include <linux/slab.h>
	19	#include <linux/list.h>
	20	#include <linux/module.h>
f8916c11	21	#include <linux/mutex.h>
1da177e4	22
a1bdc7aa BD	23	#include "base.h"
a1bdc7aa BD	24
1da177e4 LT	25	/* This is a private structure used to tie the classdev and the
	26	* container .. it should never be visible outside this file */
	27	struct internal_container {
53c165e0	28	struct klist_node node;
1da177e4	29	struct attribute_container *cont;
ee959b00	30	struct device classdev;
1da177e4 LT	31	};
1da177e4 LT	32
caf39e87 LT	33	static void internal_container_klist_get(struct klist_node *n)
	34	{
	35	struct internal_container *ic =
	36	container_of(n, struct internal_container, node);
ee959b00	37	get_device(&ic->classdev);
caf39e87 LT	38	}
	39
	40	static void internal_container_klist_put(struct klist_node *n)
	41	{
	42	struct internal_container *ic =
	43	container_of(n, struct internal_container, node);
ee959b00	44	put_device(&ic->classdev);
caf39e87 LT	45	}
	46
	47
1da177e4 LT	48	/**
	49	* attribute_container_classdev_to_container - given a classdev, return the container
	50	*
	51	* @classdev: the class device created by attribute_container_add_device.
	52	*
	53	* Returns the container associated with this classdev.
	54	*/
	55	struct attribute_container *
ee959b00	56	attribute_container_classdev_to_container(struct device *classdev)
1da177e4 LT	57	{
	58	struct internal_container *ic =
	59	container_of(classdev, struct internal_container, classdev);
	60	return ic->cont;
	61	}
	62	EXPORT_SYMBOL_GPL(attribute_container_classdev_to_container);
	63
db1118a4	64	static LIST_HEAD(attribute_container_list);
1da177e4	65
61a2f59a	66	static DEFINE_MUTEX(attribute_container_mutex);
1da177e4 LT	67
	68	/**
	69	* attribute_container_register - register an attribute container
	70	*
	71	* @cont: The container to register. This must be allocated by the
	72	* callee and should also be zeroed by it.
	73	*/
	74	int
	75	attribute_container_register(struct attribute_container *cont)
	76	{
	77	INIT_LIST_HEAD(&cont->node);
caf39e87 LT	78	klist_init(&cont->containers,internal_container_klist_get,
caf39e87 LT	79	internal_container_klist_put);
1da177e4	80
61a2f59a	81	mutex_lock(&attribute_container_mutex);
1da177e4	82	list_add_tail(&cont->node, &attribute_container_list);
61a2f59a	83	mutex_unlock(&attribute_container_mutex);
1da177e4 LT	84
	85	return 0;
	86	}
	87	EXPORT_SYMBOL_GPL(attribute_container_register);
	88
	89	/**
	90	* attribute_container_unregister - remove a container registration
	91	*
	92	* @cont: previously registered container to remove
	93	*/
	94	int
	95	attribute_container_unregister(struct attribute_container *cont)
	96	{
	97	int retval = -EBUSY;
61a2f59a	98	mutex_lock(&attribute_container_mutex);
53c165e0 JB	99	spin_lock(&cont->containers.k_lock);
53c165e0 JB	100	if (!list_empty(&cont->containers.k_list))
1da177e4 LT	101	goto out;
	102	retval = 0;
	103	list_del(&cont->node);
	104	out:
53c165e0	105	spin_unlock(&cont->containers.k_lock);
61a2f59a	106	mutex_unlock(&attribute_container_mutex);
1da177e4 LT	107	return retval;
	108
	109	}
	110	EXPORT_SYMBOL_GPL(attribute_container_unregister);
	111
	112	/* private function used as class release */
ee959b00	113	static void attribute_container_release(struct device *classdev)
1da177e4 LT	114	{
	115	struct internal_container *ic
	116	= container_of(classdev, struct internal_container, classdev);
ee959b00	117	struct device *dev = classdev->parent;
1da177e4 LT	118
	119	kfree(ic);
	120	put_device(dev);
	121	}
	122
	123	/**
	124	* attribute_container_add_device - see if any container is interested in dev
	125	*
	126	* @dev: device to add attributes to
	127	* @fn: function to trigger addition of class device.
	128	*
	129	* This function allocates storage for the class device(s) to be
	130	* attached to dev (one for each matching attribute_container). If no
	131	* fn is provided, the code will simply register the class device via
ee959b00	132	* device_add. If a function is provided, it is expected to add
1da177e4 LT	133	* the class device at the appropriate time. One of the things that
	134	* might be necessary is to allocate and initialise the classdev and
	135	* then add it a later time. To do this, call this routine for
	136	* allocation and initialisation and then use
ee959b00	137	* attribute_container_device_trigger() to call device_add() on
1da177e4 LT	138	* it. Note: after this, the class device contains a reference to dev
	139	* which is not relinquished until the release of the classdev.
	140	*/
	141	void
	142	attribute_container_add_device(struct device *dev,
	143	int (fn)(struct attribute_container ,
	144	struct device *,
ee959b00	145	struct device *))
1da177e4 LT	146	{
	147	struct attribute_container *cont;
	148
61a2f59a	149	mutex_lock(&attribute_container_mutex);
1da177e4 LT	150	list_for_each_entry(cont, &attribute_container_list, node) {
	151	struct internal_container *ic;
	152
	153	if (attribute_container_no_classdevs(cont))
	154	continue;
	155
	156	if (!cont->match(cont, dev))
	157	continue;
4aed0644 JS	158
4aed0644 JS	159	ic = kzalloc(sizeof(*ic), GFP_KERNEL);
1da177e4 LT	160	if (!ic) {
	161	dev_printk(KERN_ERR, dev, "failed to allocate class container\n");
	162	continue;
	163	}
4aed0644	164
1da177e4	165	ic->cont = cont;
ee959b00 TJ	166	device_initialize(&ic->classdev);
ee959b00 TJ	167	ic->classdev.parent = get_device(dev);
1da177e4	168	ic->classdev.class = cont->class;
ee959b00	169	cont->class->dev_release = attribute_container_release;
1e0b2cf9	170	dev_set_name(&ic->classdev, dev_name(dev));
1da177e4 LT	171	if (fn)
	172	fn(cont, dev, &ic->classdev);
	173	else
	174	attribute_container_add_class_device(&ic->classdev);
53c165e0	175	klist_add_tail(&ic->node, &cont->containers);
1da177e4	176	}
61a2f59a	177	mutex_unlock(&attribute_container_mutex);
1da177e4 LT	178	}
1da177e4 LT	179
53c165e0 JB	180	/* FIXME: can't break out of this unless klist_iter_exit is also
	181	* called before doing the break
	182	*/
	183	#define klist_for_each_entry(pos, head, member, iter) \
	184	for (klist_iter_init(head, iter); (pos = ({ \
	185	struct klist_node *n = klist_next(iter); \
caf39e87 LT	186	n ? container_of(n, typeof(*pos), member) : \
caf39e87 LT	187	({ klist_iter_exit(iter) ; NULL; }); \
53c165e0 JB	188	}) ) != NULL; )
	189
	190
1da177e4 LT	191	/**
	192	* attribute_container_remove_device - make device eligible for removal.
	193	*
	194	* @dev: The generic device
	195	* @fn: A function to call to remove the device
	196	*
	197	* This routine triggers device removal. If fn is NULL, then it is
ee959b00	198	* simply done via device_unregister (note that if something
1da177e4 LT	199	* still has a reference to the classdev, then the memory occupied
	200	* will not be freed until the classdev is released). If you want a
	201	* two phase release: remove from visibility and then delete the
	202	* device, then you should use this routine with a fn that calls
ee959b00 TJ	203	* device_del() and then use attribute_container_device_trigger()
ee959b00 TJ	204	* to do the final put on the classdev.
1da177e4 LT	205	*/
	206	void
	207	attribute_container_remove_device(struct device *dev,
	208	void (fn)(struct attribute_container ,
	209	struct device *,
ee959b00	210	struct device *))
1da177e4 LT	211	{
	212	struct attribute_container *cont;
	213
61a2f59a	214	mutex_lock(&attribute_container_mutex);
1da177e4	215	list_for_each_entry(cont, &attribute_container_list, node) {
53c165e0 JB	216	struct internal_container *ic;
53c165e0 JB	217	struct klist_iter iter;
1da177e4 LT	218
	219	if (attribute_container_no_classdevs(cont))
	220	continue;
	221
	222	if (!cont->match(cont, dev))
	223	continue;
53c165e0 JB	224
53c165e0 JB	225	klist_for_each_entry(ic, &cont->containers, node, &iter) {
ee959b00	226	if (dev != ic->classdev.parent)
1da177e4	227	continue;
caf39e87	228	klist_del(&ic->node);
1da177e4 LT	229	if (fn)
	230	fn(cont, dev, &ic->classdev);
	231	else {
	232	attribute_container_remove_attrs(&ic->classdev);
ee959b00	233	device_unregister(&ic->classdev);
1da177e4 LT	234	}
	235	}
	236	}
61a2f59a	237	mutex_unlock(&attribute_container_mutex);
1da177e4	238	}
1da177e4 LT	239
	240	/**
	241	* attribute_container_device_trigger - execute a trigger for each matching classdev
	242	*
	243	* @dev: The generic device to run the trigger for
	244	* @fn the function to execute for each classdev.
	245	*
	246	* This funcion is for executing a trigger when you need to know both
	247	* the container and the classdev. If you only care about the
	248	* container, then use attribute_container_trigger() instead.
	249	*/
	250	void
	251	attribute_container_device_trigger(struct device *dev,
	252	int (fn)(struct attribute_container ,
	253	struct device *,
ee959b00	254	struct device *))
1da177e4 LT	255	{
	256	struct attribute_container *cont;
	257
61a2f59a	258	mutex_lock(&attribute_container_mutex);
1da177e4	259	list_for_each_entry(cont, &attribute_container_list, node) {
53c165e0 JB	260	struct internal_container *ic;
53c165e0 JB	261	struct klist_iter iter;
1da177e4 LT	262
	263	if (!cont->match(cont, dev))
	264	continue;
	265
ebd8bb76 JB	266	if (attribute_container_no_classdevs(cont)) {
	267	fn(cont, dev, NULL);
	268	continue;
	269	}
	270
53c165e0	271	klist_for_each_entry(ic, &cont->containers, node, &iter) {
ee959b00	272	if (dev == ic->classdev.parent)
1da177e4 LT	273	fn(cont, dev, &ic->classdev);
	274	}
	275	}
61a2f59a	276	mutex_unlock(&attribute_container_mutex);
1da177e4	277	}
1da177e4 LT	278
	279	/**
	280	* attribute_container_trigger - trigger a function for each matching container
	281	*
	282	* @dev: The generic device to activate the trigger for
	283	* @fn: the function to trigger
	284	*
	285	* This routine triggers a function that only needs to know the
	286	* matching containers (not the classdev) associated with a device.
	287	* It is more lightweight than attribute_container_device_trigger, so
	288	* should be used in preference unless the triggering function
	289	* actually needs to know the classdev.
	290	*/
	291	void
	292	attribute_container_trigger(struct device *dev,
	293	int (fn)(struct attribute_container ,
	294	struct device *))
	295	{
	296	struct attribute_container *cont;
	297
61a2f59a	298	mutex_lock(&attribute_container_mutex);
1da177e4 LT	299	list_for_each_entry(cont, &attribute_container_list, node) {
	300	if (cont->match(cont, dev))
	301	fn(cont, dev);
	302	}
61a2f59a	303	mutex_unlock(&attribute_container_mutex);
1da177e4	304	}
1da177e4 LT	305
	306	/**
	307	* attribute_container_add_attrs - add attributes
	308	*
	309	* @classdev: The class device
	310	*
	311	* This simply creates all the class device sysfs files from the
	312	* attributes listed in the container
	313	*/
	314	int
ee959b00	315	attribute_container_add_attrs(struct device *classdev)
1da177e4 LT	316	{
	317	struct attribute_container *cont =
	318	attribute_container_classdev_to_container(classdev);
ee959b00	319	struct device_attribute **attrs = cont->attrs;
1da177e4 LT	320	int i, error;
1da177e4 LT	321
fd110971 JB	322	BUG_ON(attrs && cont->grp);
	323
	324	if (!attrs && !cont->grp)
1da177e4 LT	325	return 0;
1da177e4 LT	326
fd110971 JB	327	if (cont->grp)
	328	return sysfs_create_group(&classdev->kobj, cont->grp);
	329
1da177e4	330	for (i = 0; attrs[i]; i++) {
ebd09ec9	331	sysfs_attr_init(&attrs[i]->attr);
ee959b00	332	error = device_create_file(classdev, attrs[i]);
1da177e4 LT	333	if (error)
	334	return error;
	335	}
	336
	337	return 0;
	338	}
1da177e4 LT	339
1da177e4 LT	340	/**
ee959b00	341	* attribute_container_add_class_device - same function as device_add
1da177e4 LT	342	*
	343	* @classdev: the class device to add
	344	*
ee959b00	345	* This performs essentially the same function as device_add except for
1da177e4 LT	346	* attribute containers, namely add the classdev to the system and then
	347	* create the attribute files
	348	*/
	349	int
ee959b00	350	attribute_container_add_class_device(struct device *classdev)
1da177e4	351	{
ee959b00	352	int error = device_add(classdev);
1da177e4 LT	353	if (error)
	354	return error;
	355	return attribute_container_add_attrs(classdev);
	356	}
1da177e4 LT	357
	358	/**
	359	* attribute_container_add_class_device_adapter - simple adapter for triggers
	360	*
	361	* This function is identical to attribute_container_add_class_device except
	362	* that it is designed to be called from the triggers
	363	*/
	364	int
	365	attribute_container_add_class_device_adapter(struct attribute_container *cont,
	366	struct device *dev,
ee959b00	367	struct device *classdev)
1da177e4 LT	368	{
	369	return attribute_container_add_class_device(classdev);
	370	}
1da177e4 LT	371
	372	/**
	373	* attribute_container_remove_attrs - remove any attribute files
	374	*
	375	* @classdev: The class device to remove the files from
	376	*
	377	*/
	378	void
ee959b00	379	attribute_container_remove_attrs(struct device *classdev)
1da177e4 LT	380	{
	381	struct attribute_container *cont =
	382	attribute_container_classdev_to_container(classdev);
ee959b00	383	struct device_attribute **attrs = cont->attrs;
1da177e4 LT	384	int i;
1da177e4 LT	385
fd110971	386	if (!attrs && !cont->grp)
1da177e4 LT	387	return;
1da177e4 LT	388
fd110971 JB	389	if (cont->grp) {
	390	sysfs_remove_group(&classdev->kobj, cont->grp);
	391	return ;
	392	}
	393
1da177e4	394	for (i = 0; attrs[i]; i++)
ee959b00	395	device_remove_file(classdev, attrs[i]);
1da177e4	396	}
1da177e4 LT	397
	398	/**
	399	* attribute_container_class_device_del - equivalent of class_device_del
	400	*
	401	* @classdev: the class device
	402	*
	403	* This function simply removes all the attribute files and then calls
ee959b00	404	* device_del.
1da177e4 LT	405	*/
1da177e4 LT	406	void
ee959b00	407	attribute_container_class_device_del(struct device *classdev)
1da177e4 LT	408	{
1da177e4 LT	409	attribute_container_remove_attrs(classdev);
ee959b00	410	device_del(classdev);
1da177e4	411	}
1da177e4	412
d0a7e574 JB	413	/**
	414	* attribute_container_find_class_device - find the corresponding class_device
	415	*
	416	* @cont: the container
	417	* @dev: the generic device
	418	*
	419	* Looks up the device in the container's list of class devices and returns
	420	* the corresponding class_device.
	421	*/
ee959b00	422	struct device *
d0a7e574 JB	423	attribute_container_find_class_device(struct attribute_container *cont,
	424	struct device *dev)
	425	{
ee959b00	426	struct device *cdev = NULL;
d0a7e574	427	struct internal_container *ic;
53c165e0	428	struct klist_iter iter;
d0a7e574	429
53c165e0	430	klist_for_each_entry(ic, &cont->containers, node, &iter) {
ee959b00	431	if (ic->classdev.parent == dev) {
d0a7e574	432	cdev = &ic->classdev;
53c165e0 JB	433	/* FIXME: must exit iterator then break */
53c165e0 JB	434	klist_iter_exit(&iter);
d0a7e574 JB	435	break;
	436	}
	437	}
d0a7e574 JB	438
	439	return cdev;
	440	}
	441	EXPORT_SYMBOL_GPL(attribute_container_find_class_device);