attribute_container.c 12.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * 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>
21
#include <linux/mutex.h>
Linus Torvalds's avatar
Linus Torvalds committed
22

23 24
#include "base.h"

Linus Torvalds's avatar
Linus Torvalds committed
25 26 27
/* This is a private structure used to tie the classdev and the
 * container .. it should never be visible outside this file */
struct internal_container {
28
	struct klist_node node;
Linus Torvalds's avatar
Linus Torvalds committed
29 30 31 32
	struct attribute_container *cont;
	struct class_device classdev;
};

33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
static void internal_container_klist_get(struct klist_node *n)
{
	struct internal_container *ic =
		container_of(n, struct internal_container, node);
	class_device_get(&ic->classdev);
}

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


Linus Torvalds's avatar
Linus Torvalds committed
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
/**
 * 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 class_device *classdev)
{
	struct internal_container *ic =
		container_of(classdev, struct internal_container, classdev);
	return ic->cont;
}
EXPORT_SYMBOL_GPL(attribute_container_classdev_to_container);

64
static LIST_HEAD(attribute_container_list);
Linus Torvalds's avatar
Linus Torvalds committed
65

66
static DEFINE_MUTEX(attribute_container_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
67 68 69 70 71 72 73 74 75 76 77

/**
 * 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);
78 79
	klist_init(&cont->containers,internal_container_klist_get,
		   internal_container_klist_put);
Linus Torvalds's avatar
Linus Torvalds committed
80
		
81
	mutex_lock(&attribute_container_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
82
	list_add_tail(&cont->node, &attribute_container_list);
83
	mutex_unlock(&attribute_container_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
84 85 86 87 88 89 90 91 92 93 94 95 96 97

	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;
98
	mutex_lock(&attribute_container_mutex);
99 100
	spin_lock(&cont->containers.k_lock);
	if (!list_empty(&cont->containers.k_list))
Linus Torvalds's avatar
Linus Torvalds committed
101 102 103 104
		goto out;
	retval = 0;
	list_del(&cont->node);
 out:
105
	spin_unlock(&cont->containers.k_lock);
106
	mutex_unlock(&attribute_container_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
	return retval;
		
}
EXPORT_SYMBOL_GPL(attribute_container_unregister);

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

	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
 * class_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 class_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 class_device *))
{
	struct attribute_container *cont;

149
	mutex_lock(&attribute_container_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
150 151 152 153 154 155 156 157
	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;
158 159

		ic = kzalloc(sizeof(*ic), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
160 161 162 163
		if (!ic) {
			dev_printk(KERN_ERR, dev, "failed to allocate class container\n");
			continue;
		}
164

Linus Torvalds's avatar
Linus Torvalds committed
165 166 167 168 169 170 171 172 173 174
		ic->cont = cont;
		class_device_initialize(&ic->classdev);
		ic->classdev.dev = get_device(dev);
		ic->classdev.class = cont->class;
		cont->class->release = attribute_container_release;
		strcpy(ic->classdev.class_id, dev->bus_id);
		if (fn)
			fn(cont, dev, &ic->classdev);
		else
			attribute_container_add_class_device(&ic->classdev);
175
		klist_add_tail(&ic->node, &cont->containers);
Linus Torvalds's avatar
Linus Torvalds committed
176
	}
177
	mutex_unlock(&attribute_container_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
178 179
}

180 181 182 183 184 185
/* 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); \
186 187
		n ? container_of(n, typeof(*pos), member) : \
			({ klist_iter_exit(iter) ; NULL; }); \
188 189 190
	}) ) != NULL; )
			

Linus Torvalds's avatar
Linus Torvalds committed
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
/**
 * 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 class_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
 * class_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 class_device *))
{
	struct attribute_container *cont;

215
	mutex_lock(&attribute_container_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
216
	list_for_each_entry(cont, &attribute_container_list, node) {
217 218
		struct internal_container *ic;
		struct klist_iter iter;
Linus Torvalds's avatar
Linus Torvalds committed
219 220 221 222 223 224

		if (attribute_container_no_classdevs(cont))
			continue;

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

		klist_for_each_entry(ic, &cont->containers, node, &iter) {
Linus Torvalds's avatar
Linus Torvalds committed
227 228
			if (dev != ic->classdev.dev)
				continue;
229
			klist_del(&ic->node);
Linus Torvalds's avatar
Linus Torvalds committed
230 231 232 233 234 235 236 237
			if (fn)
				fn(cont, dev, &ic->classdev);
			else {
				attribute_container_remove_attrs(&ic->classdev);
				class_device_unregister(&ic->classdev);
			}
		}
	}
238
	mutex_unlock(&attribute_container_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
}

/**
 * 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 class_device *))
{
	struct attribute_container *cont;

259
	mutex_lock(&attribute_container_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
260
	list_for_each_entry(cont, &attribute_container_list, node) {
261 262
		struct internal_container *ic;
		struct klist_iter iter;
Linus Torvalds's avatar
Linus Torvalds committed
263 264 265 266

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

267 268 269 270 271
		if (attribute_container_no_classdevs(cont)) {
			fn(cont, dev, NULL);
			continue;
		}

272
		klist_for_each_entry(ic, &cont->containers, node, &iter) {
Linus Torvalds's avatar
Linus Torvalds committed
273 274 275 276
			if (dev == ic->classdev.dev)
				fn(cont, dev, &ic->classdev);
		}
	}
277
	mutex_unlock(&attribute_container_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
}

/**
 * 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;

299
	mutex_lock(&attribute_container_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
300 301 302 303
	list_for_each_entry(cont, &attribute_container_list, node) {
		if (cont->match(cont, dev))
			fn(cont, dev);
	}
304
	mutex_unlock(&attribute_container_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
}

/**
 * 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 class_device *classdev)
{
	struct attribute_container *cont =
		attribute_container_classdev_to_container(classdev);
	struct class_device_attribute **attrs =	cont->attrs;
	int i, error;

323 324 325
	BUG_ON(attrs && cont->grp);

	if (!attrs && !cont->grp)
Linus Torvalds's avatar
Linus Torvalds committed
326 327
		return 0;

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

Linus Torvalds's avatar
Linus Torvalds committed
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
	for (i = 0; attrs[i]; i++) {
		error = class_device_create_file(classdev, attrs[i]);
		if (error)
			return error;
	}

	return 0;
}

/**
 * attribute_container_add_class_device - same function as class_device_add
 *
 * @classdev:	the class device to add
 *
 * This performs essentially the same function as class_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 class_device *classdev)
{
	int error = class_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 class_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 class_device *classdev)
{
	struct attribute_container *cont =
		attribute_container_classdev_to_container(classdev);
	struct class_device_attribute **attrs =	cont->attrs;
	int i;

386
	if (!attrs && !cont->grp)
Linus Torvalds's avatar
Linus Torvalds committed
387 388
		return;

389 390 391 392 393
	if (cont->grp) {
		sysfs_remove_group(&classdev->kobj, cont->grp);
		return ;
	}

Linus Torvalds's avatar
Linus Torvalds committed
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
	for (i = 0; attrs[i]; i++)
		class_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
 * class_device_del.
 */
void
attribute_container_class_device_del(struct class_device *classdev)
{
	attribute_container_remove_attrs(classdev);
	class_device_del(classdev);
}

413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
/**
 * 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 class_device *
attribute_container_find_class_device(struct attribute_container *cont,
				      struct device *dev)
{
	struct class_device *cdev = NULL;
	struct internal_container *ic;
428
	struct klist_iter iter;
429

430
	klist_for_each_entry(ic, &cont->containers, node, &iter) {
431 432
		if (ic->classdev.dev == dev) {
			cdev = &ic->classdev;
433 434
			/* FIXME: must exit iterator then break */
			klist_iter_exit(&iter);
435 436 437 438 439 440 441
			break;
		}
	}

	return cdev;
}
EXPORT_SYMBOL_GPL(attribute_container_find_class_device);