xref: /openbmc/linux/drivers/base/class.c (revision 643d1f7f)
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 
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>
18 #include <linux/err.h>
19 #include <linux/slab.h>
20 #include <linux/genhd.h>
21 #include "base.h"
22 
23 #define to_class_attr(_attr) container_of(_attr, struct class_attribute, attr)
24 #define to_class(obj) container_of(obj, struct class, subsys.kobj)
25 
26 static ssize_t class_attr_show(struct kobject *kobj, struct attribute *attr,
27 			       char *buf)
28 {
29 	struct class_attribute *class_attr = to_class_attr(attr);
30 	struct class *dc = to_class(kobj);
31 	ssize_t ret = -EIO;
32 
33 	if (class_attr->show)
34 		ret = class_attr->show(dc, buf);
35 	return ret;
36 }
37 
38 static ssize_t class_attr_store(struct kobject *kobj, struct attribute *attr,
39 				const char *buf, size_t count)
40 {
41 	struct class_attribute *class_attr = to_class_attr(attr);
42 	struct class *dc = to_class(kobj);
43 	ssize_t ret = -EIO;
44 
45 	if (class_attr->store)
46 		ret = class_attr->store(dc, buf, count);
47 	return ret;
48 }
49 
50 static void class_release(struct kobject *kobj)
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 
68 static struct kobj_type class_ktype = {
69 	.sysfs_ops	= &class_sysfs_ops,
70 	.release	= class_release,
71 };
72 
73 /* Hotplug events for classes go to the class_obj subsys */
74 static struct kset *class_kset;
75 
76 
77 int class_create_file(struct class *cls, const struct class_attribute *attr)
78 {
79 	int error;
80 	if (cls)
81 		error = sysfs_create_file(&cls->subsys.kobj, &attr->attr);
82 	else
83 		error = -EINVAL;
84 	return error;
85 }
86 
87 void class_remove_file(struct class *cls, const struct class_attribute *attr)
88 {
89 	if (cls)
90 		sysfs_remove_file(&cls->subsys.kobj, &attr->attr);
91 }
92 
93 static struct class *class_get(struct class *cls)
94 {
95 	if (cls)
96 		return container_of(kset_get(&cls->subsys),
97 				    struct class, subsys);
98 	return NULL;
99 }
100 
101 static void class_put(struct class *cls)
102 {
103 	if (cls)
104 		kset_put(&cls->subsys);
105 }
106 
107 static int add_class_attrs(struct class *cls)
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++) {
114 			error = class_create_file(cls, &cls->class_attrs[i]);
115 			if (error)
116 				goto error;
117 		}
118 	}
119 done:
120 	return error;
121 error:
122 	while (--i >= 0)
123 		class_remove_file(cls, &cls->class_attrs[i]);
124 	goto done;
125 }
126 
127 static void remove_class_attrs(struct class *cls)
128 {
129 	int i;
130 
131 	if (cls->class_attrs) {
132 		for (i = 0; attr_name(cls->class_attrs[i]); i++)
133 			class_remove_file(cls, &cls->class_attrs[i]);
134 	}
135 }
136 
137 int class_register(struct class *cls)
138 {
139 	int error;
140 
141 	pr_debug("device class '%s': registering\n", cls->name);
142 
143 	INIT_LIST_HEAD(&cls->children);
144 	INIT_LIST_HEAD(&cls->devices);
145 	INIT_LIST_HEAD(&cls->interfaces);
146 	kset_init(&cls->class_dirs);
147 	init_MUTEX(&cls->sem);
148 	error = kobject_set_name(&cls->subsys.kobj, "%s", cls->name);
149 	if (error)
150 		return error;
151 
152 #if defined(CONFIG_SYSFS_DEPRECATED) && defined(CONFIG_BLOCK)
153 	/* let the block class directory show up in the root of sysfs */
154 	if (cls != &block_class)
155 		cls->subsys.kobj.kset = class_kset;
156 #else
157 	cls->subsys.kobj.kset = class_kset;
158 #endif
159 	cls->subsys.kobj.ktype = &class_ktype;
160 
161 	error = kset_register(&cls->subsys);
162 	if (!error) {
163 		error = add_class_attrs(class_get(cls));
164 		class_put(cls);
165 	}
166 	return error;
167 }
168 
169 void class_unregister(struct class *cls)
170 {
171 	pr_debug("device class '%s': unregistering\n", cls->name);
172 	remove_class_attrs(cls);
173 	kset_unregister(&cls->subsys);
174 }
175 
176 static void class_create_release(struct class *cls)
177 {
178 	pr_debug("%s called for %s\n", __FUNCTION__, cls->name);
179 	kfree(cls);
180 }
181 
182 static void class_device_create_release(struct class_device *class_dev)
183 {
184 	pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id);
185 	kfree(class_dev);
186 }
187 
188 /* needed to allow these devices to have parent class devices */
189 static int class_device_create_uevent(struct class_device *class_dev,
190 				      struct kobj_uevent_env *env)
191 {
192 	pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id);
193 	return 0;
194 }
195 
196 /**
197  * class_create - create a struct class structure
198  * @owner: pointer to the module that is to "own" this struct class
199  * @name: pointer to a string for the name of this class.
200  *
201  * This is used to create a struct class pointer that can then be used
202  * in calls to class_device_create().
203  *
204  * Note, the pointer created here is to be destroyed when finished by
205  * making a call to class_destroy().
206  */
207 struct class *class_create(struct module *owner, const char *name)
208 {
209 	struct class *cls;
210 	int retval;
211 
212 	cls = kzalloc(sizeof(*cls), GFP_KERNEL);
213 	if (!cls) {
214 		retval = -ENOMEM;
215 		goto error;
216 	}
217 
218 	cls->name = name;
219 	cls->owner = owner;
220 	cls->class_release = class_create_release;
221 	cls->release = class_device_create_release;
222 
223 	retval = class_register(cls);
224 	if (retval)
225 		goto error;
226 
227 	return cls;
228 
229 error:
230 	kfree(cls);
231 	return ERR_PTR(retval);
232 }
233 
234 /**
235  * class_destroy - destroys a struct class structure
236  * @cls: pointer to the struct class that is to be destroyed
237  *
238  * Note, the pointer to be destroyed must have been created with a call
239  * to class_create().
240  */
241 void class_destroy(struct class *cls)
242 {
243 	if ((cls == NULL) || (IS_ERR(cls)))
244 		return;
245 
246 	class_unregister(cls);
247 }
248 
249 /* Class Device Stuff */
250 
251 int class_device_create_file(struct class_device *class_dev,
252 			     const struct class_device_attribute *attr)
253 {
254 	int error = -EINVAL;
255 	if (class_dev)
256 		error = sysfs_create_file(&class_dev->kobj, &attr->attr);
257 	return error;
258 }
259 
260 void class_device_remove_file(struct class_device *class_dev,
261 			      const struct class_device_attribute *attr)
262 {
263 	if (class_dev)
264 		sysfs_remove_file(&class_dev->kobj, &attr->attr);
265 }
266 
267 int class_device_create_bin_file(struct class_device *class_dev,
268 				 struct bin_attribute *attr)
269 {
270 	int error = -EINVAL;
271 	if (class_dev)
272 		error = sysfs_create_bin_file(&class_dev->kobj, attr);
273 	return error;
274 }
275 
276 void class_device_remove_bin_file(struct class_device *class_dev,
277 				  struct bin_attribute *attr)
278 {
279 	if (class_dev)
280 		sysfs_remove_bin_file(&class_dev->kobj, attr);
281 }
282 
283 static ssize_t class_device_attr_show(struct kobject *kobj,
284 				      struct attribute *attr, char *buf)
285 {
286 	struct class_device_attribute *class_dev_attr = to_class_dev_attr(attr);
287 	struct class_device *cd = to_class_dev(kobj);
288 	ssize_t ret = 0;
289 
290 	if (class_dev_attr->show)
291 		ret = class_dev_attr->show(cd, buf);
292 	return ret;
293 }
294 
295 static ssize_t class_device_attr_store(struct kobject *kobj,
296 				       struct attribute *attr,
297 				       const char *buf, size_t count)
298 {
299 	struct class_device_attribute *class_dev_attr = to_class_dev_attr(attr);
300 	struct class_device *cd = to_class_dev(kobj);
301 	ssize_t ret = 0;
302 
303 	if (class_dev_attr->store)
304 		ret = class_dev_attr->store(cd, buf, count);
305 	return ret;
306 }
307 
308 static struct sysfs_ops class_dev_sysfs_ops = {
309 	.show	= class_device_attr_show,
310 	.store	= class_device_attr_store,
311 };
312 
313 static void class_dev_release(struct kobject *kobj)
314 {
315 	struct class_device *cd = to_class_dev(kobj);
316 	struct class *cls = cd->class;
317 
318 	pr_debug("device class '%s': release.\n", cd->class_id);
319 
320 	if (cd->release)
321 		cd->release(cd);
322 	else if (cls->release)
323 		cls->release(cd);
324 	else {
325 		printk(KERN_ERR "Class Device '%s' does not have a release() "
326 			"function, it is broken and must be fixed.\n",
327 			cd->class_id);
328 		WARN_ON(1);
329 	}
330 }
331 
332 static struct kobj_type class_device_ktype = {
333 	.sysfs_ops	= &class_dev_sysfs_ops,
334 	.release	= class_dev_release,
335 };
336 
337 static int class_uevent_filter(struct kset *kset, struct kobject *kobj)
338 {
339 	struct kobj_type *ktype = get_ktype(kobj);
340 
341 	if (ktype == &class_device_ktype) {
342 		struct class_device *class_dev = to_class_dev(kobj);
343 		if (class_dev->class)
344 			return 1;
345 	}
346 	return 0;
347 }
348 
349 static const char *class_uevent_name(struct kset *kset, struct kobject *kobj)
350 {
351 	struct class_device *class_dev = to_class_dev(kobj);
352 
353 	return class_dev->class->name;
354 }
355 
356 #ifdef CONFIG_SYSFS_DEPRECATED
357 char *make_class_name(const char *name, struct kobject *kobj)
358 {
359 	char *class_name;
360 	int size;
361 
362 	size = strlen(name) + strlen(kobject_name(kobj)) + 2;
363 
364 	class_name = kmalloc(size, GFP_KERNEL);
365 	if (!class_name)
366 		return NULL;
367 
368 	strcpy(class_name, name);
369 	strcat(class_name, ":");
370 	strcat(class_name, kobject_name(kobj));
371 	return class_name;
372 }
373 
374 static int make_deprecated_class_device_links(struct class_device *class_dev)
375 {
376 	char *class_name;
377 	int error;
378 
379 	if (!class_dev->dev)
380 		return 0;
381 
382 	class_name = make_class_name(class_dev->class->name, &class_dev->kobj);
383 	if (class_name)
384 		error = sysfs_create_link(&class_dev->dev->kobj,
385 					  &class_dev->kobj, class_name);
386 	else
387 		error = -ENOMEM;
388 	kfree(class_name);
389 	return error;
390 }
391 
392 static void remove_deprecated_class_device_links(struct class_device *class_dev)
393 {
394 	char *class_name;
395 
396 	if (!class_dev->dev)
397 		return;
398 
399 	class_name = make_class_name(class_dev->class->name, &class_dev->kobj);
400 	if (class_name)
401 		sysfs_remove_link(&class_dev->dev->kobj, class_name);
402 	kfree(class_name);
403 }
404 #else
405 static inline int make_deprecated_class_device_links(struct class_device *cd)
406 { return 0; }
407 static void remove_deprecated_class_device_links(struct class_device *cd)
408 { }
409 #endif
410 
411 static int class_uevent(struct kset *kset, struct kobject *kobj,
412 			struct kobj_uevent_env *env)
413 {
414 	struct class_device *class_dev = to_class_dev(kobj);
415 	struct device *dev = class_dev->dev;
416 	int retval = 0;
417 
418 	pr_debug("%s - name = %s\n", __FUNCTION__, class_dev->class_id);
419 
420 	if (MAJOR(class_dev->devt)) {
421 		add_uevent_var(env, "MAJOR=%u", MAJOR(class_dev->devt));
422 
423 		add_uevent_var(env, "MINOR=%u", MINOR(class_dev->devt));
424 	}
425 
426 	if (dev) {
427 		const char *path = kobject_get_path(&dev->kobj, GFP_KERNEL);
428 		if (path) {
429 			add_uevent_var(env, "PHYSDEVPATH=%s", path);
430 			kfree(path);
431 		}
432 
433 		if (dev->bus)
434 			add_uevent_var(env, "PHYSDEVBUS=%s", dev->bus->name);
435 
436 		if (dev->driver)
437 			add_uevent_var(env, "PHYSDEVDRIVER=%s",
438 				       dev->driver->name);
439 	}
440 
441 	if (class_dev->uevent) {
442 		/* have the class device specific function add its stuff */
443 		retval = class_dev->uevent(class_dev, env);
444 		if (retval)
445 			pr_debug("class_dev->uevent() returned %d\n", retval);
446 	} else if (class_dev->class->uevent) {
447 		/* have the class specific function add its stuff */
448 		retval = class_dev->class->uevent(class_dev, env);
449 		if (retval)
450 			pr_debug("class->uevent() returned %d\n", retval);
451 	}
452 
453 	return retval;
454 }
455 
456 static struct kset_uevent_ops class_uevent_ops = {
457 	.filter =	class_uevent_filter,
458 	.name =		class_uevent_name,
459 	.uevent =	class_uevent,
460 };
461 
462 /*
463  * DO NOT copy how this is created, kset_create_and_add() should be
464  * called, but this is a hold-over from the old-way and will be deleted
465  * entirely soon.
466  */
467 static struct kset class_obj_subsys = {
468 	.uevent_ops = &class_uevent_ops,
469 };
470 
471 static int class_device_add_attrs(struct class_device *cd)
472 {
473 	int i;
474 	int error = 0;
475 	struct class *cls = cd->class;
476 
477 	if (cls->class_dev_attrs) {
478 		for (i = 0; attr_name(cls->class_dev_attrs[i]); i++) {
479 			error = class_device_create_file(cd,
480 						&cls->class_dev_attrs[i]);
481 			if (error)
482 				goto err;
483 		}
484 	}
485 done:
486 	return error;
487 err:
488 	while (--i >= 0)
489 		class_device_remove_file(cd, &cls->class_dev_attrs[i]);
490 	goto done;
491 }
492 
493 static void class_device_remove_attrs(struct class_device *cd)
494 {
495 	int i;
496 	struct class *cls = cd->class;
497 
498 	if (cls->class_dev_attrs) {
499 		for (i = 0; attr_name(cls->class_dev_attrs[i]); i++)
500 			class_device_remove_file(cd, &cls->class_dev_attrs[i]);
501 	}
502 }
503 
504 static int class_device_add_groups(struct class_device *cd)
505 {
506 	int i;
507 	int error = 0;
508 
509 	if (cd->groups) {
510 		for (i = 0; cd->groups[i]; i++) {
511 			error = sysfs_create_group(&cd->kobj, cd->groups[i]);
512 			if (error) {
513 				while (--i >= 0)
514 					sysfs_remove_group(&cd->kobj,
515 							   cd->groups[i]);
516 				goto out;
517 			}
518 		}
519 	}
520 out:
521 	return error;
522 }
523 
524 static void class_device_remove_groups(struct class_device *cd)
525 {
526 	int i;
527 	if (cd->groups)
528 		for (i = 0; cd->groups[i]; i++)
529 			sysfs_remove_group(&cd->kobj, cd->groups[i]);
530 }
531 
532 static ssize_t show_dev(struct class_device *class_dev, char *buf)
533 {
534 	return print_dev_t(buf, class_dev->devt);
535 }
536 
537 static struct class_device_attribute class_devt_attr =
538 	__ATTR(dev, S_IRUGO, show_dev, NULL);
539 
540 static ssize_t store_uevent(struct class_device *class_dev,
541 			    const char *buf, size_t count)
542 {
543 	kobject_uevent(&class_dev->kobj, KOBJ_ADD);
544 	return count;
545 }
546 
547 static struct class_device_attribute class_uevent_attr =
548 	__ATTR(uevent, S_IWUSR, NULL, store_uevent);
549 
550 void class_device_initialize(struct class_device *class_dev)
551 {
552 	class_dev->kobj.kset = &class_obj_subsys;
553 	kobject_init(&class_dev->kobj, &class_device_ktype);
554 	INIT_LIST_HEAD(&class_dev->node);
555 }
556 
557 int class_device_add(struct class_device *class_dev)
558 {
559 	struct class *parent_class = NULL;
560 	struct class_device *parent_class_dev = NULL;
561 	struct class_interface *class_intf;
562 	int error = -EINVAL;
563 
564 	class_dev = class_device_get(class_dev);
565 	if (!class_dev)
566 		return -EINVAL;
567 
568 	if (!strlen(class_dev->class_id))
569 		goto out1;
570 
571 	parent_class = class_get(class_dev->class);
572 	if (!parent_class)
573 		goto out1;
574 
575 	parent_class_dev = class_device_get(class_dev->parent);
576 
577 	pr_debug("CLASS: registering class device: ID = '%s'\n",
578 		 class_dev->class_id);
579 
580 	/* first, register with generic layer. */
581 	if (parent_class_dev)
582 		class_dev->kobj.parent = &parent_class_dev->kobj;
583 	else
584 		class_dev->kobj.parent = &parent_class->subsys.kobj;
585 
586 	error = kobject_add(&class_dev->kobj, class_dev->kobj.parent,
587 			    "%s", class_dev->class_id);
588 	if (error)
589 		goto out2;
590 
591 	/* add the needed attributes to this device */
592 	error = sysfs_create_link(&class_dev->kobj,
593 				  &parent_class->subsys.kobj, "subsystem");
594 	if (error)
595 		goto out3;
596 
597 	error = class_device_create_file(class_dev, &class_uevent_attr);
598 	if (error)
599 		goto out3;
600 
601 	if (MAJOR(class_dev->devt)) {
602 		error = class_device_create_file(class_dev, &class_devt_attr);
603 		if (error)
604 			goto out4;
605 	}
606 
607 	error = class_device_add_attrs(class_dev);
608 	if (error)
609 		goto out5;
610 
611 	if (class_dev->dev) {
612 		error = sysfs_create_link(&class_dev->kobj,
613 					  &class_dev->dev->kobj, "device");
614 		if (error)
615 			goto out6;
616 	}
617 
618 	error = class_device_add_groups(class_dev);
619 	if (error)
620 		goto out7;
621 
622 	error = make_deprecated_class_device_links(class_dev);
623 	if (error)
624 		goto out8;
625 
626 	kobject_uevent(&class_dev->kobj, KOBJ_ADD);
627 
628 	/* notify any interfaces this device is now here */
629 	down(&parent_class->sem);
630 	list_add_tail(&class_dev->node, &parent_class->children);
631 	list_for_each_entry(class_intf, &parent_class->interfaces, node) {
632 		if (class_intf->add)
633 			class_intf->add(class_dev, class_intf);
634 	}
635 	up(&parent_class->sem);
636 
637 	goto out1;
638 
639  out8:
640 	class_device_remove_groups(class_dev);
641  out7:
642 	if (class_dev->dev)
643 		sysfs_remove_link(&class_dev->kobj, "device");
644  out6:
645 	class_device_remove_attrs(class_dev);
646  out5:
647 	if (MAJOR(class_dev->devt))
648 		class_device_remove_file(class_dev, &class_devt_attr);
649  out4:
650 	class_device_remove_file(class_dev, &class_uevent_attr);
651  out3:
652 	kobject_del(&class_dev->kobj);
653  out2:
654 	if (parent_class_dev)
655 		class_device_put(parent_class_dev);
656 	class_put(parent_class);
657  out1:
658 	class_device_put(class_dev);
659 	return error;
660 }
661 
662 int class_device_register(struct class_device *class_dev)
663 {
664 	class_device_initialize(class_dev);
665 	return class_device_add(class_dev);
666 }
667 
668 /**
669  * class_device_create - creates a class device and registers it with sysfs
670  * @cls: pointer to the struct class that this device should be registered to.
671  * @parent: pointer to the parent struct class_device of this new device, if
672  * any.
673  * @devt: the dev_t for the char device to be added.
674  * @device: a pointer to a struct device that is assiociated with this class
675  * device.
676  * @fmt: string for the class device's name
677  *
678  * This function can be used by char device classes.  A struct
679  * class_device will be created in sysfs, registered to the specified
680  * class.
681  * A "dev" file will be created, showing the dev_t for the device, if
682  * the dev_t is not 0,0.
683  * If a pointer to a parent struct class_device is passed in, the newly
684  * created struct class_device will be a child of that device in sysfs.
685  * The pointer to the struct class_device will be returned from the
686  * call.  Any further sysfs files that might be required can be created
687  * using this pointer.
688  *
689  * Note: the struct class passed to this function must have previously
690  * been created with a call to class_create().
691  */
692 struct class_device *class_device_create(struct class *cls,
693 					 struct class_device *parent,
694 					 dev_t devt,
695 					 struct device *device,
696 					 const char *fmt, ...)
697 {
698 	va_list args;
699 	struct class_device *class_dev = NULL;
700 	int retval = -ENODEV;
701 
702 	if (cls == NULL || IS_ERR(cls))
703 		goto error;
704 
705 	class_dev = kzalloc(sizeof(*class_dev), GFP_KERNEL);
706 	if (!class_dev) {
707 		retval = -ENOMEM;
708 		goto error;
709 	}
710 
711 	class_dev->devt = devt;
712 	class_dev->dev = device;
713 	class_dev->class = cls;
714 	class_dev->parent = parent;
715 	class_dev->release = class_device_create_release;
716 	class_dev->uevent = class_device_create_uevent;
717 
718 	va_start(args, fmt);
719 	vsnprintf(class_dev->class_id, BUS_ID_SIZE, fmt, args);
720 	va_end(args);
721 	retval = class_device_register(class_dev);
722 	if (retval)
723 		goto error;
724 
725 	return class_dev;
726 
727 error:
728 	kfree(class_dev);
729 	return ERR_PTR(retval);
730 }
731 
732 void class_device_del(struct class_device *class_dev)
733 {
734 	struct class *parent_class = class_dev->class;
735 	struct class_device *parent_device = class_dev->parent;
736 	struct class_interface *class_intf;
737 
738 	if (parent_class) {
739 		down(&parent_class->sem);
740 		list_del_init(&class_dev->node);
741 		list_for_each_entry(class_intf, &parent_class->interfaces, node)
742 			if (class_intf->remove)
743 				class_intf->remove(class_dev, class_intf);
744 		up(&parent_class->sem);
745 	}
746 
747 	if (class_dev->dev) {
748 		remove_deprecated_class_device_links(class_dev);
749 		sysfs_remove_link(&class_dev->kobj, "device");
750 	}
751 	sysfs_remove_link(&class_dev->kobj, "subsystem");
752 	class_device_remove_file(class_dev, &class_uevent_attr);
753 	if (MAJOR(class_dev->devt))
754 		class_device_remove_file(class_dev, &class_devt_attr);
755 	class_device_remove_attrs(class_dev);
756 	class_device_remove_groups(class_dev);
757 
758 	kobject_uevent(&class_dev->kobj, KOBJ_REMOVE);
759 	kobject_del(&class_dev->kobj);
760 
761 	class_device_put(parent_device);
762 	class_put(parent_class);
763 }
764 
765 void class_device_unregister(struct class_device *class_dev)
766 {
767 	pr_debug("CLASS: Unregistering class device. ID = '%s'\n",
768 		 class_dev->class_id);
769 	class_device_del(class_dev);
770 	class_device_put(class_dev);
771 }
772 
773 /**
774  * class_device_destroy - removes a class device that was created with class_device_create()
775  * @cls: the pointer to the struct class that this device was registered * with.
776  * @devt: the dev_t of the device that was previously registered.
777  *
778  * This call unregisters and cleans up a class device that was created with a
779  * call to class_device_create()
780  */
781 void class_device_destroy(struct class *cls, dev_t devt)
782 {
783 	struct class_device *class_dev = NULL;
784 	struct class_device *class_dev_tmp;
785 
786 	down(&cls->sem);
787 	list_for_each_entry(class_dev_tmp, &cls->children, node) {
788 		if (class_dev_tmp->devt == devt) {
789 			class_dev = class_dev_tmp;
790 			break;
791 		}
792 	}
793 	up(&cls->sem);
794 
795 	if (class_dev)
796 		class_device_unregister(class_dev);
797 }
798 
799 struct class_device *class_device_get(struct class_device *class_dev)
800 {
801 	if (class_dev)
802 		return to_class_dev(kobject_get(&class_dev->kobj));
803 	return NULL;
804 }
805 
806 void class_device_put(struct class_device *class_dev)
807 {
808 	if (class_dev)
809 		kobject_put(&class_dev->kobj);
810 }
811 
812 /**
813  * class_for_each_device - device iterator
814  * @class: the class we're iterating
815  * @data: data for the callback
816  * @fn: function to be called for each device
817  *
818  * Iterate over @class's list of devices, and call @fn for each,
819  * passing it @data.
820  *
821  * We check the return of @fn each time. If it returns anything
822  * other than 0, we break out and return that value.
823  *
824  * Note, we hold class->sem in this function, so it can not be
825  * re-acquired in @fn, otherwise it will self-deadlocking. For
826  * example, calls to add or remove class members would be verboten.
827  */
828 int class_for_each_device(struct class *class, void *data,
829 			   int (*fn)(struct device *, void *))
830 {
831 	struct device *dev;
832 	int error = 0;
833 
834 	if (!class)
835 		return -EINVAL;
836 	down(&class->sem);
837 	list_for_each_entry(dev, &class->devices, node) {
838 		dev = get_device(dev);
839 		if (dev) {
840 			error = fn(dev, data);
841 			put_device(dev);
842 		} else
843 			error = -ENODEV;
844 		if (error)
845 			break;
846 	}
847 	up(&class->sem);
848 
849 	return error;
850 }
851 EXPORT_SYMBOL_GPL(class_for_each_device);
852 
853 /**
854  * class_find_device - device iterator for locating a particular device
855  * @class: the class we're iterating
856  * @data: data for the match function
857  * @match: function to check device
858  *
859  * This is similar to the class_for_each_dev() function above, but it
860  * returns a reference to a device that is 'found' for later use, as
861  * determined by the @match callback.
862  *
863  * The callback should return 0 if the device doesn't match and non-zero
864  * if it does.  If the callback returns non-zero, this function will
865  * return to the caller and not iterate over any more devices.
866  *
867  * Note, you will need to drop the reference with put_device() after use.
868  *
869  * We hold class->sem in this function, so it can not be
870  * re-acquired in @match, otherwise it will self-deadlocking. For
871  * example, calls to add or remove class members would be verboten.
872  */
873 struct device *class_find_device(struct class *class, void *data,
874 				   int (*match)(struct device *, void *))
875 {
876 	struct device *dev;
877 	int found = 0;
878 
879 	if (!class)
880 		return NULL;
881 
882 	down(&class->sem);
883 	list_for_each_entry(dev, &class->devices, node) {
884 		dev = get_device(dev);
885 		if (dev) {
886 			if (match(dev, data)) {
887 				found = 1;
888 				break;
889 			} else
890 				put_device(dev);
891 		} else
892 			break;
893 	}
894 	up(&class->sem);
895 
896 	return found ? dev : NULL;
897 }
898 EXPORT_SYMBOL_GPL(class_find_device);
899 
900 /**
901  * class_find_child - device iterator for locating a particular class_device
902  * @class: the class we're iterating
903  * @data: data for the match function
904  * @match: function to check class_device
905  *
906  * This function returns a reference to a class_device that is 'found' for
907  * later use, as determined by the @match callback.
908  *
909  * The callback should return 0 if the class_device doesn't match and non-zero
910  * if it does.  If the callback returns non-zero, this function will
911  * return to the caller and not iterate over any more class_devices.
912  *
913  * Note, you will need to drop the reference with class_device_put() after use.
914  *
915  * We hold class->sem in this function, so it can not be
916  * re-acquired in @match, otherwise it will self-deadlocking. For
917  * example, calls to add or remove class members would be verboten.
918  */
919 struct class_device *class_find_child(struct class *class, void *data,
920 				   int (*match)(struct class_device *, void *))
921 {
922 	struct class_device *dev;
923 	int found = 0;
924 
925 	if (!class)
926 		return NULL;
927 
928 	down(&class->sem);
929 	list_for_each_entry(dev, &class->children, node) {
930 		dev = class_device_get(dev);
931 		if (dev) {
932 			if (match(dev, data)) {
933 				found = 1;
934 				break;
935 			} else
936 				class_device_put(dev);
937 		} else
938 			break;
939 	}
940 	up(&class->sem);
941 
942 	return found ? dev : NULL;
943 }
944 EXPORT_SYMBOL_GPL(class_find_child);
945 
946 int class_interface_register(struct class_interface *class_intf)
947 {
948 	struct class *parent;
949 	struct class_device *class_dev;
950 	struct device *dev;
951 
952 	if (!class_intf || !class_intf->class)
953 		return -ENODEV;
954 
955 	parent = class_get(class_intf->class);
956 	if (!parent)
957 		return -EINVAL;
958 
959 	down(&parent->sem);
960 	list_add_tail(&class_intf->node, &parent->interfaces);
961 	if (class_intf->add) {
962 		list_for_each_entry(class_dev, &parent->children, node)
963 			class_intf->add(class_dev, class_intf);
964 	}
965 	if (class_intf->add_dev) {
966 		list_for_each_entry(dev, &parent->devices, node)
967 			class_intf->add_dev(dev, class_intf);
968 	}
969 	up(&parent->sem);
970 
971 	return 0;
972 }
973 
974 void class_interface_unregister(struct class_interface *class_intf)
975 {
976 	struct class *parent = class_intf->class;
977 	struct class_device *class_dev;
978 	struct device *dev;
979 
980 	if (!parent)
981 		return;
982 
983 	down(&parent->sem);
984 	list_del_init(&class_intf->node);
985 	if (class_intf->remove) {
986 		list_for_each_entry(class_dev, &parent->children, node)
987 			class_intf->remove(class_dev, class_intf);
988 	}
989 	if (class_intf->remove_dev) {
990 		list_for_each_entry(dev, &parent->devices, node)
991 			class_intf->remove_dev(dev, class_intf);
992 	}
993 	up(&parent->sem);
994 
995 	class_put(parent);
996 }
997 
998 int __init classes_init(void)
999 {
1000 	class_kset = kset_create_and_add("class", NULL, NULL);
1001 	if (!class_kset)
1002 		return -ENOMEM;
1003 
1004 	/* ick, this is ugly, the things we go through to keep from showing up
1005 	 * in sysfs... */
1006 	kset_init(&class_obj_subsys);
1007 	kobject_set_name(&class_obj_subsys.kobj, "class_obj");
1008 	if (!class_obj_subsys.kobj.parent)
1009 		class_obj_subsys.kobj.parent = &class_obj_subsys.kobj;
1010 	return 0;
1011 }
1012 
1013 EXPORT_SYMBOL_GPL(class_create_file);
1014 EXPORT_SYMBOL_GPL(class_remove_file);
1015 EXPORT_SYMBOL_GPL(class_register);
1016 EXPORT_SYMBOL_GPL(class_unregister);
1017 EXPORT_SYMBOL_GPL(class_create);
1018 EXPORT_SYMBOL_GPL(class_destroy);
1019 
1020 EXPORT_SYMBOL_GPL(class_device_register);
1021 EXPORT_SYMBOL_GPL(class_device_unregister);
1022 EXPORT_SYMBOL_GPL(class_device_initialize);
1023 EXPORT_SYMBOL_GPL(class_device_add);
1024 EXPORT_SYMBOL_GPL(class_device_del);
1025 EXPORT_SYMBOL_GPL(class_device_get);
1026 EXPORT_SYMBOL_GPL(class_device_put);
1027 EXPORT_SYMBOL_GPL(class_device_create);
1028 EXPORT_SYMBOL_GPL(class_device_destroy);
1029 EXPORT_SYMBOL_GPL(class_device_create_file);
1030 EXPORT_SYMBOL_GPL(class_device_remove_file);
1031 EXPORT_SYMBOL_GPL(class_device_create_bin_file);
1032 EXPORT_SYMBOL_GPL(class_device_remove_bin_file);
1033 
1034 EXPORT_SYMBOL_GPL(class_interface_register);
1035 EXPORT_SYMBOL_GPL(class_interface_unregister);
1036