class.c 14.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 * 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>
18
#include <linux/err.h>
T
Tim Schmielau 已提交
19
#include <linux/slab.h>
20
#include <linux/genhd.h>
21
#include <linux/mutex.h>
L
Linus Torvalds 已提交
22 23 24 25
#include "base.h"

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

26 27
static ssize_t class_attr_show(struct kobject *kobj, struct attribute *attr,
			       char *buf)
L
Linus Torvalds 已提交
28
{
29
	struct class_attribute *class_attr = to_class_attr(attr);
30
	struct subsys_private *cp = to_subsys_private(kobj);
31
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
32 33

	if (class_attr->show)
34
		ret = class_attr->show(cp->class, class_attr, buf);
L
Linus Torvalds 已提交
35 36 37
	return ret;
}

38 39
static ssize_t class_attr_store(struct kobject *kobj, struct attribute *attr,
				const char *buf, size_t count)
L
Linus Torvalds 已提交
40
{
41
	struct class_attribute *class_attr = to_class_attr(attr);
42
	struct subsys_private *cp = to_subsys_private(kobj);
43
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
44 45

	if (class_attr->store)
46
		ret = class_attr->store(cp->class, class_attr, buf, count);
L
Linus Torvalds 已提交
47 48 49
	return ret;
}

50
static void class_release(struct kobject *kobj)
L
Linus Torvalds 已提交
51
{
52
	struct subsys_private *cp = to_subsys_private(kobj);
53
	struct class *class = cp->class;
L
Linus Torvalds 已提交
54 55 56 57 58 59 60 61

	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);
62 63

	kfree(cp);
L
Linus Torvalds 已提交
64 65
}

66 67
static const struct kobj_ns_type_operations *class_child_ns_type(struct kobject *kobj)
{
68
	struct subsys_private *cp = to_subsys_private(kobj);
69 70 71 72 73
	struct class *class = cp->class;

	return class->ns_type;
}

74
static const struct sysfs_ops class_sysfs_ops = {
L
Linus Torvalds 已提交
75 76 77 78
	.show	= class_attr_show,
	.store	= class_attr_store,
};

79
static struct kobj_type class_ktype = {
L
Linus Torvalds 已提交
80 81
	.sysfs_ops	= &class_sysfs_ops,
	.release	= class_release,
82
	.child_ns_type	= class_child_ns_type,
L
Linus Torvalds 已提交
83 84
};

85
/* Hotplug events for classes go to the class subsys */
86
static struct kset *class_kset;
L
Linus Torvalds 已提交
87 88


89
int class_create_file(struct class *cls, const struct class_attribute *attr)
L
Linus Torvalds 已提交
90 91
{
	int error;
92
	if (cls)
93
		error = sysfs_create_file(&cls->p->subsys.kobj,
94
					  &attr->attr);
95
	else
L
Linus Torvalds 已提交
96 97 98 99
		error = -EINVAL;
	return error;
}

100
void class_remove_file(struct class *cls, const struct class_attribute *attr)
L
Linus Torvalds 已提交
101 102
{
	if (cls)
103
		sysfs_remove_file(&cls->p->subsys.kobj, &attr->attr);
L
Linus Torvalds 已提交
104 105
}

106
static struct class *class_get(struct class *cls)
L
Linus Torvalds 已提交
107 108
{
	if (cls)
109
		kset_get(&cls->p->subsys);
110
	return cls;
L
Linus Torvalds 已提交
111 112
}

113
static void class_put(struct class *cls)
L
Linus Torvalds 已提交
114
{
115
	if (cls)
116
		kset_put(&cls->p->subsys);
L
Linus Torvalds 已提交
117 118
}

119
static int add_class_attrs(struct class *cls)
L
Linus Torvalds 已提交
120 121 122 123 124 125
{
	int i;
	int error = 0;

	if (cls->class_attrs) {
		for (i = 0; attr_name(cls->class_attrs[i]); i++) {
126
			error = class_create_file(cls, &cls->class_attrs[i]);
L
Linus Torvalds 已提交
127
			if (error)
128
				goto error;
L
Linus Torvalds 已提交
129 130
		}
	}
131
done:
L
Linus Torvalds 已提交
132
	return error;
133
error:
L
Linus Torvalds 已提交
134
	while (--i >= 0)
135 136
		class_remove_file(cls, &cls->class_attrs[i]);
	goto done;
L
Linus Torvalds 已提交
137 138
}

139
static void remove_class_attrs(struct class *cls)
L
Linus Torvalds 已提交
140 141 142 143 144
{
	int i;

	if (cls->class_attrs) {
		for (i = 0; attr_name(cls->class_attrs[i]); i++)
145
			class_remove_file(cls, &cls->class_attrs[i]);
L
Linus Torvalds 已提交
146 147 148
	}
}

149 150 151 152 153 154 155 156 157 158 159 160 161 162
static void klist_class_dev_get(struct klist_node *n)
{
	struct device *dev = container_of(n, struct device, knode_class);

	get_device(dev);
}

static void klist_class_dev_put(struct klist_node *n)
{
	struct device *dev = container_of(n, struct device, knode_class);

	put_device(dev);
}

163
int __class_register(struct class *cls, struct lock_class_key *key)
L
Linus Torvalds 已提交
164
{
165
	struct subsys_private *cp;
L
Linus Torvalds 已提交
166 167 168 169
	int error;

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

170 171 172
	cp = kzalloc(sizeof(*cp), GFP_KERNEL);
	if (!cp)
		return -ENOMEM;
173
	klist_init(&cp->klist_devices, klist_class_dev_get, klist_class_dev_put);
174
	INIT_LIST_HEAD(&cp->class_interfaces);
175
	kset_init(&cp->glue_dirs);
176
	__mutex_init(&cp->class_mutex, "struct class mutex", key);
177
	error = kobject_set_name(&cp->subsys.kobj, "%s", cls->name);
178 179
	if (error) {
		kfree(cp);
L
Linus Torvalds 已提交
180
		return error;
181
	}
L
Linus Torvalds 已提交
182

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

187
#if defined(CONFIG_BLOCK)
188
	/* let the block class directory show up in the root of sysfs */
189
	if (!sysfs_deprecated || cls != &block_class)
190
		cp->subsys.kobj.kset = class_kset;
191
#else
192
	cp->subsys.kobj.kset = class_kset;
193
#endif
194
	cp->subsys.kobj.ktype = &class_ktype;
195 196
	cp->class = cls;
	cls->p = cp;
L
Linus Torvalds 已提交
197

198
	error = kset_register(&cp->subsys);
199 200 201
	if (error) {
		kfree(cp);
		return error;
L
Linus Torvalds 已提交
202
	}
203 204
	error = add_class_attrs(class_get(cls));
	class_put(cls);
L
Linus Torvalds 已提交
205 206
	return error;
}
207
EXPORT_SYMBOL_GPL(__class_register);
L
Linus Torvalds 已提交
208

209
void class_unregister(struct class *cls)
L
Linus Torvalds 已提交
210 211 212
{
	pr_debug("device class '%s': unregistering\n", cls->name);
	remove_class_attrs(cls);
213
	kset_unregister(&cls->p->subsys);
L
Linus Torvalds 已提交
214 215
}

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

222 223 224 225
/**
 * 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.
226
 * @key: the lock_class_key for this class; used by mutex lock debugging
227 228
 *
 * This is used to create a struct class pointer that can then be used
229
 * in calls to device_create().
230
 *
231 232
 * Returns &struct class pointer on success, or ERR_PTR() on error.
 *
233 234 235
 * Note, the pointer created here is to be destroyed when finished by
 * making a call to class_destroy().
 */
236 237
struct class *__class_create(struct module *owner, const char *name,
			     struct lock_class_key *key)
238 239 240 241
{
	struct class *cls;
	int retval;

242
	cls = kzalloc(sizeof(*cls), GFP_KERNEL);
243 244 245 246 247 248 249 250 251
	if (!cls) {
		retval = -ENOMEM;
		goto error;
	}

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

252
	retval = __class_register(cls, key);
253 254 255 256 257 258 259 260 261
	if (retval)
		goto error;

	return cls;

error:
	kfree(cls);
	return ERR_PTR(retval);
}
262
EXPORT_SYMBOL_GPL(__class_create);
263

264 265
/**
 * class_destroy - destroys a struct class structure
266
 * @cls: pointer to the struct class that is to be destroyed
267 268 269 270
 *
 * Note, the pointer to be destroyed must have been created with a call
 * to class_create().
 */
271 272 273 274 275 276 277
void class_destroy(struct class *cls)
{
	if ((cls == NULL) || (IS_ERR(cls)))
		return;

	class_unregister(cls);
}
L
Linus Torvalds 已提交
278

279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
/**
 * class_dev_iter_init - initialize class device iterator
 * @iter: class iterator to initialize
 * @class: the class we wanna iterate over
 * @start: the device to start iterating from, if any
 * @type: device_type of the devices to iterate over, NULL for all
 *
 * Initialize class iterator @iter such that it iterates over devices
 * of @class.  If @start is set, the list iteration will start there,
 * otherwise if it is NULL, the iteration starts at the beginning of
 * the list.
 */
void class_dev_iter_init(struct class_dev_iter *iter, struct class *class,
			 struct device *start, const struct device_type *type)
{
	struct klist_node *start_knode = NULL;

	if (start)
		start_knode = &start->knode_class;
298
	klist_iter_init_node(&class->p->klist_devices, &iter->ki, start_knode);
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
	iter->type = type;
}
EXPORT_SYMBOL_GPL(class_dev_iter_init);

/**
 * class_dev_iter_next - iterate to the next device
 * @iter: class iterator to proceed
 *
 * Proceed @iter to the next device and return it.  Returns NULL if
 * iteration is complete.
 *
 * The returned device is referenced and won't be released till
 * iterator is proceed to the next device or exited.  The caller is
 * free to do whatever it wants to do with the device including
 * calling back into class code.
 */
struct device *class_dev_iter_next(struct class_dev_iter *iter)
{
	struct klist_node *knode;
	struct device *dev;

	while (1) {
		knode = klist_next(&iter->ki);
		if (!knode)
			return NULL;
		dev = container_of(knode, struct device, knode_class);
		if (!iter->type || iter->type == dev->type)
			return dev;
	}
}
EXPORT_SYMBOL_GPL(class_dev_iter_next);

/**
 * class_dev_iter_exit - finish iteration
 * @iter: class iterator to finish
 *
 * Finish an iteration.  Always call this function after iteration is
 * complete whether the iteration ran till the end or not.
 */
void class_dev_iter_exit(struct class_dev_iter *iter)
{
	klist_iter_exit(&iter->ki);
}
EXPORT_SYMBOL_GPL(class_dev_iter_exit);

344 345 346
/**
 * class_for_each_device - device iterator
 * @class: the class we're iterating
347
 * @start: the device to start with in the list, if any.
348 349 350 351
 * @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,
352 353 354
 * 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.
355 356 357 358
 *
 * We check the return of @fn each time. If it returns anything
 * other than 0, we break out and return that value.
 *
359 360
 * @fn is allowed to do anything including calling back into class
 * code.  There's no locking restriction.
361
 */
362 363
int class_for_each_device(struct class *class, struct device *start,
			  void *data, int (*fn)(struct device *, void *))
364
{
365
	struct class_dev_iter iter;
366 367 368 369 370
	struct device *dev;
	int error = 0;

	if (!class)
		return -EINVAL;
371 372 373 374 375 376
	if (!class->p) {
		WARN(1, "%s called for class '%s' before it was initialized",
		     __func__, class->name);
		return -EINVAL;
	}

377 378
	class_dev_iter_init(&iter, class, start, NULL);
	while ((dev = class_dev_iter_next(&iter))) {
379
		error = fn(dev, data);
380 381 382
		if (error)
			break;
	}
383
	class_dev_iter_exit(&iter);
384 385 386 387 388 389 390 391

	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
392
 * @start: Device to begin with
393 394 395 396 397 398 399 400 401 402
 * @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.
403
 *
404 405
 * Note, you will need to drop the reference with put_device() after use.
 *
406 407
 * @fn is allowed to do anything including calling back into class
 * code.  There's no locking restriction.
408
 */
409 410 411
struct device *class_find_device(struct class *class, struct device *start,
				 void *data,
				 int (*match)(struct device *, void *))
412
{
413
	struct class_dev_iter iter;
414 415 416 417
	struct device *dev;

	if (!class)
		return NULL;
418 419 420 421 422
	if (!class->p) {
		WARN(1, "%s called for class '%s' before it was initialized",
		     __func__, class->name);
		return NULL;
	}
423

424 425
	class_dev_iter_init(&iter, class, start, NULL);
	while ((dev = class_dev_iter_next(&iter))) {
426
		if (match(dev, data)) {
427
			get_device(dev);
428
			break;
429
		}
430
	}
431
	class_dev_iter_exit(&iter);
432

433
	return dev;
434 435 436
}
EXPORT_SYMBOL_GPL(class_find_device);

L
Linus Torvalds 已提交
437 438 439
int class_interface_register(struct class_interface *class_intf)
{
	struct class *parent;
440
	struct class_dev_iter iter;
441
	struct device *dev;
L
Linus Torvalds 已提交
442 443 444 445 446 447 448 449

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

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

450
	mutex_lock(&parent->p->class_mutex);
451
	list_add_tail(&class_intf->node, &parent->p->class_interfaces);
452
	if (class_intf->add_dev) {
453 454
		class_dev_iter_init(&iter, parent, NULL, NULL);
		while ((dev = class_dev_iter_next(&iter)))
455
			class_intf->add_dev(dev, class_intf);
456
		class_dev_iter_exit(&iter);
457
	}
458
	mutex_unlock(&parent->p->class_mutex);
L
Linus Torvalds 已提交
459 460 461 462 463 464

	return 0;
}

void class_interface_unregister(struct class_interface *class_intf)
{
465
	struct class *parent = class_intf->class;
466
	struct class_dev_iter iter;
467
	struct device *dev;
L
Linus Torvalds 已提交
468 469 470 471

	if (!parent)
		return;

472
	mutex_lock(&parent->p->class_mutex);
L
Linus Torvalds 已提交
473
	list_del_init(&class_intf->node);
474
	if (class_intf->remove_dev) {
475 476
		class_dev_iter_init(&iter, parent, NULL, NULL);
		while ((dev = class_dev_iter_next(&iter)))
477
			class_intf->remove_dev(dev, class_intf);
478
		class_dev_iter_exit(&iter);
479
	}
480
	mutex_unlock(&parent->p->class_mutex);
L
Linus Torvalds 已提交
481 482 483 484

	class_put(parent);
}

485 486
ssize_t show_class_attr_string(struct class *class,
			       struct class_attribute *attr, char *buf)
487 488 489 490 491 492 493 494
{
	struct class_attribute_string *cs;
	cs = container_of(attr, struct class_attribute_string, attr);
	return snprintf(buf, PAGE_SIZE, "%s\n", cs->str);
}

EXPORT_SYMBOL_GPL(show_class_attr_string);

495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
struct class_compat {
	struct kobject *kobj;
};

/**
 * class_compat_register - register a compatibility class
 * @name: the name of the class
 *
 * Compatibility class are meant as a temporary user-space compatibility
 * workaround when converting a family of class devices to a bus devices.
 */
struct class_compat *class_compat_register(const char *name)
{
	struct class_compat *cls;

	cls = kmalloc(sizeof(struct class_compat), GFP_KERNEL);
	if (!cls)
		return NULL;
	cls->kobj = kobject_create_and_add(name, &class_kset->kobj);
	if (!cls->kobj) {
		kfree(cls);
		return NULL;
	}
	return cls;
}
EXPORT_SYMBOL_GPL(class_compat_register);

/**
 * class_compat_unregister - unregister a compatibility class
 * @cls: the class to unregister
 */
void class_compat_unregister(struct class_compat *cls)
{
	kobject_put(cls->kobj);
	kfree(cls);
}
EXPORT_SYMBOL_GPL(class_compat_unregister);

/**
 * class_compat_create_link - create a compatibility class device link to
 *			      a bus device
 * @cls: the compatibility class
 * @dev: the target bus device
 * @device_link: an optional device to which a "device" link should be created
 */
int class_compat_create_link(struct class_compat *cls, struct device *dev,
			     struct device *device_link)
{
	int error;

	error = sysfs_create_link(cls->kobj, &dev->kobj, dev_name(dev));
	if (error)
		return error;

	/*
	 * Optionally add a "device" link (typically to the parent), as a
	 * class device would have one and we want to provide as much
	 * backwards compatibility as possible.
	 */
	if (device_link) {
		error = sysfs_create_link(&dev->kobj, &device_link->kobj,
					  "device");
		if (error)
			sysfs_remove_link(cls->kobj, dev_name(dev));
	}

	return error;
}
EXPORT_SYMBOL_GPL(class_compat_create_link);

/**
 * class_compat_remove_link - remove a compatibility class device link to
 *			      a bus device
 * @cls: the compatibility class
 * @dev: the target bus device
 * @device_link: an optional device to which a "device" link was previously
 * 		 created
 */
void class_compat_remove_link(struct class_compat *cls, struct device *dev,
			      struct device *device_link)
{
	if (device_link)
		sysfs_remove_link(&dev->kobj, "device");
	sysfs_remove_link(cls->kobj, dev_name(dev));
}
EXPORT_SYMBOL_GPL(class_compat_remove_link);

L
Linus Torvalds 已提交
582 583
int __init classes_init(void)
{
584 585 586
	class_kset = kset_create_and_add("class", NULL, NULL);
	if (!class_kset)
		return -ENOMEM;
L
Linus Torvalds 已提交
587 588 589 590 591 592
	return 0;
}

EXPORT_SYMBOL_GPL(class_create_file);
EXPORT_SYMBOL_GPL(class_remove_file);
EXPORT_SYMBOL_GPL(class_unregister);
593
EXPORT_SYMBOL_GPL(class_destroy);
L
Linus Torvalds 已提交
594 595 596

EXPORT_SYMBOL_GPL(class_interface_register);
EXPORT_SYMBOL_GPL(class_interface_unregister);