2 * class.c - basic device class management
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.
9 * This file is released under the GPLv2
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>
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)
27 class_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
29 struct class_attribute * class_attr = to_class_attr(attr);
30 struct class * dc = to_class(kobj);
34 ret = class_attr->show(dc, buf);
39 class_attr_store(struct kobject * kobj, struct attribute * attr,
40 const char * buf, size_t count)
42 struct class_attribute * class_attr = to_class_attr(attr);
43 struct class * dc = to_class(kobj);
46 if (class_attr->store)
47 ret = class_attr->store(dc, buf, count);
51 static void class_release(struct kobject * kobj)
53 struct class *class = to_class(kobj);
55 pr_debug("class '%s': release.\n", class->name);
57 if (class->class_release)
58 class->class_release(class);
60 pr_debug("class '%s' does not have a release() function, "
61 "be careful\n", class->name);
64 static struct sysfs_ops class_sysfs_ops = {
65 .show = class_attr_show,
66 .store = class_attr_store,
69 static struct kobj_type class_ktype = {
70 .sysfs_ops = &class_sysfs_ops,
71 .release = class_release,
74 /* Hotplug events for classes go to the class_obj subsys */
75 static struct kset *class_kset;
78 int class_create_file(struct class * cls, const struct class_attribute * attr)
82 error = sysfs_create_file(&cls->subsys.kobj, &attr->attr);
88 void class_remove_file(struct class * cls, const struct class_attribute * attr)
91 sysfs_remove_file(&cls->subsys.kobj, &attr->attr);
94 static struct class *class_get(struct class *cls)
97 return container_of(kset_get(&cls->subsys), struct class, subsys);
101 static void class_put(struct class * cls)
104 kset_put(&cls->subsys);
108 static int add_class_attrs(struct class * cls)
113 if (cls->class_attrs) {
114 for (i = 0; attr_name(cls->class_attrs[i]); i++) {
115 error = class_create_file(cls,&cls->class_attrs[i]);
124 class_remove_file(cls,&cls->class_attrs[i]);
128 static void remove_class_attrs(struct class * cls)
132 if (cls->class_attrs) {
133 for (i = 0; attr_name(cls->class_attrs[i]); i++)
134 class_remove_file(cls,&cls->class_attrs[i]);
138 int class_register(struct class * cls)
142 pr_debug("device class '%s': registering\n", cls->name);
144 INIT_LIST_HEAD(&cls->children);
145 INIT_LIST_HEAD(&cls->devices);
146 INIT_LIST_HEAD(&cls->interfaces);
147 kset_init(&cls->class_dirs);
148 init_MUTEX(&cls->sem);
149 error = kobject_set_name(&cls->subsys.kobj, "%s", cls->name);
153 #ifdef CONFIG_SYSFS_DEPRECATED
154 /* let the block class directory show up in the root of sysfs */
155 if (cls != &block_class)
156 cls->subsys.kobj.kset = class_kset;
158 cls->subsys.kobj.kset = class_kset;
160 cls->subsys.kobj.ktype = &class_ktype;
162 error = kset_register(&cls->subsys);
164 error = add_class_attrs(class_get(cls));
170 void class_unregister(struct class * cls)
172 pr_debug("device class '%s': unregistering\n", cls->name);
173 remove_class_attrs(cls);
174 kset_unregister(&cls->subsys);
177 static void class_create_release(struct class *cls)
179 pr_debug("%s called for %s\n", __FUNCTION__, cls->name);
183 static void class_device_create_release(struct class_device *class_dev)
185 pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id);
189 /* needed to allow these devices to have parent class devices */
190 static int class_device_create_uevent(struct class_device *class_dev,
191 struct kobj_uevent_env *env)
193 pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id);
198 * class_create - create a struct class structure
199 * @owner: pointer to the module that is to "own" this struct class
200 * @name: pointer to a string for the name of this class.
202 * This is used to create a struct class pointer that can then be used
203 * in calls to class_device_create().
205 * Note, the pointer created here is to be destroyed when finished by
206 * making a call to class_destroy().
208 struct class *class_create(struct module *owner, const char *name)
213 cls = kzalloc(sizeof(*cls), GFP_KERNEL);
221 cls->class_release = class_create_release;
222 cls->release = class_device_create_release;
224 retval = class_register(cls);
232 return ERR_PTR(retval);
236 * class_destroy - destroys a struct class structure
237 * @cls: pointer to the struct class that is to be destroyed
239 * Note, the pointer to be destroyed must have been created with a call
242 void class_destroy(struct class *cls)
244 if ((cls == NULL) || (IS_ERR(cls)))
247 class_unregister(cls);
250 /* Class Device Stuff */
252 int class_device_create_file(struct class_device * class_dev,
253 const struct class_device_attribute * attr)
257 error = sysfs_create_file(&class_dev->kobj, &attr->attr);
261 void class_device_remove_file(struct class_device * class_dev,
262 const struct class_device_attribute * attr)
265 sysfs_remove_file(&class_dev->kobj, &attr->attr);
268 int class_device_create_bin_file(struct class_device *class_dev,
269 struct bin_attribute *attr)
273 error = sysfs_create_bin_file(&class_dev->kobj, attr);
277 void class_device_remove_bin_file(struct class_device *class_dev,
278 struct bin_attribute *attr)
281 sysfs_remove_bin_file(&class_dev->kobj, attr);
285 class_device_attr_show(struct kobject * kobj, struct attribute * attr,
288 struct class_device_attribute * class_dev_attr = to_class_dev_attr(attr);
289 struct class_device * cd = to_class_dev(kobj);
292 if (class_dev_attr->show)
293 ret = class_dev_attr->show(cd, buf);
298 class_device_attr_store(struct kobject * kobj, struct attribute * attr,
299 const char * buf, size_t count)
301 struct class_device_attribute * class_dev_attr = to_class_dev_attr(attr);
302 struct class_device * cd = to_class_dev(kobj);
305 if (class_dev_attr->store)
306 ret = class_dev_attr->store(cd, buf, count);
310 static struct sysfs_ops class_dev_sysfs_ops = {
311 .show = class_device_attr_show,
312 .store = class_device_attr_store,
315 static void class_dev_release(struct kobject * kobj)
317 struct class_device *cd = to_class_dev(kobj);
318 struct class * cls = cd->class;
320 pr_debug("device class '%s': release.\n", cd->class_id);
324 else if (cls->release)
327 printk(KERN_ERR "Class Device '%s' does not have a release() function, "
328 "it is broken and must be fixed.\n",
334 static struct kobj_type class_device_ktype = {
335 .sysfs_ops = &class_dev_sysfs_ops,
336 .release = class_dev_release,
339 static int class_uevent_filter(struct kset *kset, struct kobject *kobj)
341 struct kobj_type *ktype = get_ktype(kobj);
343 if (ktype == &class_device_ktype) {
344 struct class_device *class_dev = to_class_dev(kobj);
345 if (class_dev->class)
351 static const char *class_uevent_name(struct kset *kset, struct kobject *kobj)
353 struct class_device *class_dev = to_class_dev(kobj);
355 return class_dev->class->name;
358 #ifdef CONFIG_SYSFS_DEPRECATED
359 char *make_class_name(const char *name, struct kobject *kobj)
364 size = strlen(name) + strlen(kobject_name(kobj)) + 2;
366 class_name = kmalloc(size, GFP_KERNEL);
370 strcpy(class_name, name);
371 strcat(class_name, ":");
372 strcat(class_name, kobject_name(kobj));
376 static int make_deprecated_class_device_links(struct class_device *class_dev)
384 class_name = make_class_name(class_dev->class->name, &class_dev->kobj);
386 error = sysfs_create_link(&class_dev->dev->kobj,
387 &class_dev->kobj, class_name);
394 static void remove_deprecated_class_device_links(struct class_device *class_dev)
401 class_name = make_class_name(class_dev->class->name, &class_dev->kobj);
403 sysfs_remove_link(&class_dev->dev->kobj, class_name);
407 static inline int make_deprecated_class_device_links(struct class_device *cd)
409 static void remove_deprecated_class_device_links(struct class_device *cd)
413 static int class_uevent(struct kset *kset, struct kobject *kobj,
414 struct kobj_uevent_env *env)
416 struct class_device *class_dev = to_class_dev(kobj);
417 struct device *dev = class_dev->dev;
420 pr_debug("%s - name = %s\n", __FUNCTION__, class_dev->class_id);
422 if (MAJOR(class_dev->devt)) {
423 add_uevent_var(env, "MAJOR=%u", MAJOR(class_dev->devt));
425 add_uevent_var(env, "MINOR=%u", MINOR(class_dev->devt));
429 const char *path = kobject_get_path(&dev->kobj, GFP_KERNEL);
431 add_uevent_var(env, "PHYSDEVPATH=%s", path);
436 add_uevent_var(env, "PHYSDEVBUS=%s", dev->bus->name);
439 add_uevent_var(env, "PHYSDEVDRIVER=%s", dev->driver->name);
442 if (class_dev->uevent) {
443 /* have the class device specific function add its stuff */
444 retval = class_dev->uevent(class_dev, env);
446 pr_debug("class_dev->uevent() returned %d\n", retval);
447 } else if (class_dev->class->uevent) {
448 /* have the class specific function add its stuff */
449 retval = class_dev->class->uevent(class_dev, env);
451 pr_debug("class->uevent() returned %d\n", retval);
457 static struct kset_uevent_ops class_uevent_ops = {
458 .filter = class_uevent_filter,
459 .name = class_uevent_name,
460 .uevent = class_uevent,
464 * DO NOT copy how this is created, kset_create_and_add() should be
465 * called, but this is a hold-over from the old-way and will be deleted
468 static struct kset class_obj_subsys = {
469 .uevent_ops = &class_uevent_ops,
472 static int class_device_add_attrs(struct class_device * cd)
476 struct class * cls = cd->class;
478 if (cls->class_dev_attrs) {
479 for (i = 0; attr_name(cls->class_dev_attrs[i]); i++) {
480 error = class_device_create_file(cd,
481 &cls->class_dev_attrs[i]);
490 class_device_remove_file(cd,&cls->class_dev_attrs[i]);
494 static void class_device_remove_attrs(struct class_device * cd)
497 struct class * cls = cd->class;
499 if (cls->class_dev_attrs) {
500 for (i = 0; attr_name(cls->class_dev_attrs[i]); i++)
501 class_device_remove_file(cd,&cls->class_dev_attrs[i]);
505 static int class_device_add_groups(struct class_device * cd)
511 for (i = 0; cd->groups[i]; i++) {
512 error = sysfs_create_group(&cd->kobj, cd->groups[i]);
515 sysfs_remove_group(&cd->kobj, cd->groups[i]);
524 static void class_device_remove_groups(struct class_device * cd)
528 for (i = 0; cd->groups[i]; i++) {
529 sysfs_remove_group(&cd->kobj, cd->groups[i]);
534 static ssize_t show_dev(struct class_device *class_dev, char *buf)
536 return print_dev_t(buf, class_dev->devt);
539 static struct class_device_attribute class_devt_attr =
540 __ATTR(dev, S_IRUGO, show_dev, NULL);
542 static ssize_t store_uevent(struct class_device *class_dev,
543 const char *buf, size_t count)
545 kobject_uevent(&class_dev->kobj, KOBJ_ADD);
549 static struct class_device_attribute class_uevent_attr =
550 __ATTR(uevent, S_IWUSR, NULL, store_uevent);
552 void class_device_initialize(struct class_device *class_dev)
554 class_dev->kobj.kset = &class_obj_subsys;
555 kobject_init(&class_dev->kobj, &class_device_ktype);
556 INIT_LIST_HEAD(&class_dev->node);
559 int class_device_add(struct class_device *class_dev)
561 struct class *parent_class = NULL;
562 struct class_device *parent_class_dev = NULL;
563 struct class_interface *class_intf;
566 class_dev = class_device_get(class_dev);
570 if (!strlen(class_dev->class_id))
573 parent_class = class_get(class_dev->class);
577 parent_class_dev = class_device_get(class_dev->parent);
579 pr_debug("CLASS: registering class device: ID = '%s'\n",
580 class_dev->class_id);
582 /* first, register with generic layer. */
583 if (parent_class_dev)
584 class_dev->kobj.parent = &parent_class_dev->kobj;
586 class_dev->kobj.parent = &parent_class->subsys.kobj;
588 error = kobject_add(&class_dev->kobj, class_dev->kobj.parent,
589 "%s", class_dev->class_id);
593 /* add the needed attributes to this device */
594 error = sysfs_create_link(&class_dev->kobj,
595 &parent_class->subsys.kobj, "subsystem");
599 error = class_device_create_file(class_dev, &class_uevent_attr);
603 if (MAJOR(class_dev->devt)) {
604 error = class_device_create_file(class_dev, &class_devt_attr);
609 error = class_device_add_attrs(class_dev);
613 if (class_dev->dev) {
614 error = sysfs_create_link(&class_dev->kobj,
615 &class_dev->dev->kobj, "device");
620 error = class_device_add_groups(class_dev);
624 error = make_deprecated_class_device_links(class_dev);
628 kobject_uevent(&class_dev->kobj, KOBJ_ADD);
630 /* notify any interfaces this device is now here */
631 down(&parent_class->sem);
632 list_add_tail(&class_dev->node, &parent_class->children);
633 list_for_each_entry(class_intf, &parent_class->interfaces, node) {
635 class_intf->add(class_dev, class_intf);
637 up(&parent_class->sem);
642 class_device_remove_groups(class_dev);
645 sysfs_remove_link(&class_dev->kobj, "device");
647 class_device_remove_attrs(class_dev);
649 if (MAJOR(class_dev->devt))
650 class_device_remove_file(class_dev, &class_devt_attr);
652 class_device_remove_file(class_dev, &class_uevent_attr);
654 kobject_del(&class_dev->kobj);
657 class_device_put(parent_class_dev);
658 class_put(parent_class);
660 class_device_put(class_dev);
664 int class_device_register(struct class_device *class_dev)
666 class_device_initialize(class_dev);
667 return class_device_add(class_dev);
671 * class_device_create - creates a class device and registers it with sysfs
672 * @cls: pointer to the struct class that this device should be registered to.
673 * @parent: pointer to the parent struct class_device of this new device, if any.
674 * @devt: the dev_t for the char device to be added.
675 * @device: a pointer to a struct device that is assiociated with this class device.
676 * @fmt: string for the class device's name
678 * This function can be used by char device classes. A struct
679 * class_device will be created in sysfs, registered to the specified
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.
689 * Note: the struct class passed to this function must have previously
690 * been created with a call to class_create().
692 struct class_device *class_device_create(struct class *cls,
693 struct class_device *parent,
695 struct device *device,
696 const char *fmt, ...)
699 struct class_device *class_dev = NULL;
700 int retval = -ENODEV;
702 if (cls == NULL || IS_ERR(cls))
705 class_dev = kzalloc(sizeof(*class_dev), GFP_KERNEL);
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;
719 vsnprintf(class_dev->class_id, BUS_ID_SIZE, fmt, args);
721 retval = class_device_register(class_dev);
729 return ERR_PTR(retval);
732 void class_device_del(struct class_device *class_dev)
734 struct class *parent_class = class_dev->class;
735 struct class_device *parent_device = class_dev->parent;
736 struct class_interface *class_intf;
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);
747 if (class_dev->dev) {
748 remove_deprecated_class_device_links(class_dev);
749 sysfs_remove_link(&class_dev->kobj, "device");
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);
758 kobject_uevent(&class_dev->kobj, KOBJ_REMOVE);
759 kobject_del(&class_dev->kobj);
761 class_device_put(parent_device);
762 class_put(parent_class);
765 void class_device_unregister(struct class_device *class_dev)
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);
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.
778 * This call unregisters and cleans up a class device that was created with a
779 * call to class_device_create()
781 void class_device_destroy(struct class *cls, dev_t devt)
783 struct class_device *class_dev = NULL;
784 struct class_device *class_dev_tmp;
787 list_for_each_entry(class_dev_tmp, &cls->children, node) {
788 if (class_dev_tmp->devt == devt) {
789 class_dev = class_dev_tmp;
796 class_device_unregister(class_dev);
799 struct class_device * class_device_get(struct class_device *class_dev)
802 return to_class_dev(kobject_get(&class_dev->kobj));
806 void class_device_put(struct class_device *class_dev)
809 kobject_put(&class_dev->kobj);
813 int class_interface_register(struct class_interface *class_intf)
815 struct class *parent;
816 struct class_device *class_dev;
819 if (!class_intf || !class_intf->class)
822 parent = class_get(class_intf->class);
827 list_add_tail(&class_intf->node, &parent->interfaces);
828 if (class_intf->add) {
829 list_for_each_entry(class_dev, &parent->children, node)
830 class_intf->add(class_dev, class_intf);
832 if (class_intf->add_dev) {
833 list_for_each_entry(dev, &parent->devices, node)
834 class_intf->add_dev(dev, class_intf);
841 void class_interface_unregister(struct class_interface *class_intf)
843 struct class * parent = class_intf->class;
844 struct class_device *class_dev;
851 list_del_init(&class_intf->node);
852 if (class_intf->remove) {
853 list_for_each_entry(class_dev, &parent->children, node)
854 class_intf->remove(class_dev, class_intf);
856 if (class_intf->remove_dev) {
857 list_for_each_entry(dev, &parent->devices, node)
858 class_intf->remove_dev(dev, class_intf);
865 int __init classes_init(void)
867 class_kset = kset_create_and_add("class", NULL, NULL);
871 /* ick, this is ugly, the things we go through to keep from showing up
873 kset_init(&class_obj_subsys);
874 kobject_set_name(&class_obj_subsys.kobj, "class_obj");
875 if (!class_obj_subsys.kobj.parent)
876 class_obj_subsys.kobj.parent = &class_obj_subsys.kobj;
880 EXPORT_SYMBOL_GPL(class_create_file);
881 EXPORT_SYMBOL_GPL(class_remove_file);
882 EXPORT_SYMBOL_GPL(class_register);
883 EXPORT_SYMBOL_GPL(class_unregister);
884 EXPORT_SYMBOL_GPL(class_create);
885 EXPORT_SYMBOL_GPL(class_destroy);
887 EXPORT_SYMBOL_GPL(class_device_register);
888 EXPORT_SYMBOL_GPL(class_device_unregister);
889 EXPORT_SYMBOL_GPL(class_device_initialize);
890 EXPORT_SYMBOL_GPL(class_device_add);
891 EXPORT_SYMBOL_GPL(class_device_del);
892 EXPORT_SYMBOL_GPL(class_device_get);
893 EXPORT_SYMBOL_GPL(class_device_put);
894 EXPORT_SYMBOL_GPL(class_device_create);
895 EXPORT_SYMBOL_GPL(class_device_destroy);
896 EXPORT_SYMBOL_GPL(class_device_create_file);
897 EXPORT_SYMBOL_GPL(class_device_remove_file);
898 EXPORT_SYMBOL_GPL(class_device_create_bin_file);
899 EXPORT_SYMBOL_GPL(class_device_remove_bin_file);
901 EXPORT_SYMBOL_GPL(class_interface_register);
902 EXPORT_SYMBOL_GPL(class_interface_unregister);