blob: 20c4ea6eb50d0a8836e2f89af145fc88634c02ba [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#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>
gregkh@suse.dee9ba6362005-03-15 11:54:21 -080018#include <linux/err.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080019#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "base.h"
21
22#define to_class_attr(_attr) container_of(_attr, struct class_attribute, attr)
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -070023#define to_class(obj) container_of(obj, struct class, subsys.kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25static ssize_t
26class_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
27{
28 struct class_attribute * class_attr = to_class_attr(attr);
29 struct class * dc = to_class(kobj);
Dmitry Torokhov4a0c20b2005-04-29 01:23:47 -050030 ssize_t ret = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32 if (class_attr->show)
33 ret = class_attr->show(dc, buf);
34 return ret;
35}
36
37static ssize_t
38class_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);
Dmitry Torokhov4a0c20b2005-04-29 01:23:47 -050043 ssize_t ret = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45 if (class_attr->store)
46 ret = class_attr->store(dc, buf, count);
47 return ret;
48}
49
50static 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
63static struct sysfs_ops class_sysfs_ops = {
64 .show = class_attr_show,
65 .store = class_attr_store,
66};
67
68static struct kobj_type ktype_class = {
69 .sysfs_ops = &class_sysfs_ops,
70 .release = class_release,
71};
72
73/* Hotplug events for classes go to the class_obj subsys */
74static decl_subsys(class, &ktype_class, NULL);
75
76
77int class_create_file(struct class * cls, const struct class_attribute * attr)
78{
79 int error;
80 if (cls) {
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -070081 error = sysfs_create_file(&cls->subsys.kobj, &attr->attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 } else
83 error = -EINVAL;
84 return error;
85}
86
87void class_remove_file(struct class * cls, const struct class_attribute * attr)
88{
89 if (cls)
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -070090 sysfs_remove_file(&cls->subsys.kobj, &attr->attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091}
92
Greg Kroah-Hartman17407572006-05-02 16:59:59 +020093static struct class *class_get(struct class *cls)
Linus Torvalds1da177e2005-04-16 15:20:36 -070094{
95 if (cls)
96 return container_of(subsys_get(&cls->subsys), struct class, subsys);
97 return NULL;
98}
99
Greg Kroah-Hartman17407572006-05-02 16:59:59 +0200100static void class_put(struct class * cls)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700102 if (cls)
103 subsys_put(&cls->subsys);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104}
105
106
107static 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 Err;
117 }
118 }
119 Done:
120 return error;
121 Err:
122 while (--i >= 0)
123 class_remove_file(cls,&cls->class_attrs[i]);
124 goto Done;
125}
126
127static 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
137int 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);
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700144 INIT_LIST_HEAD(&cls->devices);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 INIT_LIST_HEAD(&cls->interfaces);
Kay Sievers86406242007-03-14 03:25:56 +0100146 kset_init(&cls->class_dirs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 init_MUTEX(&cls->sem);
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700148 error = kobject_set_name(&cls->subsys.kobj, "%s", cls->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 if (error)
150 return error;
151
152 subsys_set_kset(cls, class_subsys);
153
154 error = subsystem_register(&cls->subsys);
155 if (!error) {
156 error = add_class_attrs(class_get(cls));
157 class_put(cls);
158 }
159 return error;
160}
161
162void class_unregister(struct class * cls)
163{
164 pr_debug("device class '%s': unregistering\n", cls->name);
165 remove_class_attrs(cls);
166 subsystem_unregister(&cls->subsys);
167}
168
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800169static void class_create_release(struct class *cls)
170{
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700171 pr_debug("%s called for %s\n", __FUNCTION__, cls->name);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800172 kfree(cls);
173}
174
175static void class_device_create_release(struct class_device *class_dev)
176{
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700177 pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800178 kfree(class_dev);
179}
180
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700181/* needed to allow these devices to have parent class devices */
Kay Sievers312c0042005-11-16 09:00:00 +0100182static int class_device_create_uevent(struct class_device *class_dev,
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700183 char **envp, int num_envp,
184 char *buffer, int buffer_size)
185{
186 pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id);
187 return 0;
188}
189
gregkh@suse.de2fc68442005-03-23 10:02:56 -0800190/**
191 * class_create - create a struct class structure
192 * @owner: pointer to the module that is to "own" this struct class
193 * @name: pointer to a string for the name of this class.
194 *
195 * This is used to create a struct class pointer that can then be used
196 * in calls to class_device_create().
197 *
198 * Note, the pointer created here is to be destroyed when finished by
199 * making a call to class_destroy().
200 */
Miguel Ojeda Sandonisab7d7372006-09-13 15:34:05 +0200201struct class *class_create(struct module *owner, const char *name)
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800202{
203 struct class *cls;
204 int retval;
205
Jiri Slaby4aed0642005-09-13 01:25:01 -0700206 cls = kzalloc(sizeof(*cls), GFP_KERNEL);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800207 if (!cls) {
208 retval = -ENOMEM;
209 goto error;
210 }
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800211
212 cls->name = name;
213 cls->owner = owner;
214 cls->class_release = class_create_release;
215 cls->release = class_device_create_release;
216
217 retval = class_register(cls);
218 if (retval)
219 goto error;
220
221 return cls;
222
223error:
224 kfree(cls);
225 return ERR_PTR(retval);
226}
227
gregkh@suse.de2fc68442005-03-23 10:02:56 -0800228/**
229 * class_destroy - destroys a struct class structure
Rolf Eike Beer92a0f862006-09-29 01:59:13 -0700230 * @cls: pointer to the struct class that is to be destroyed
gregkh@suse.de2fc68442005-03-23 10:02:56 -0800231 *
232 * Note, the pointer to be destroyed must have been created with a call
233 * to class_create().
234 */
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800235void class_destroy(struct class *cls)
236{
237 if ((cls == NULL) || (IS_ERR(cls)))
238 return;
239
240 class_unregister(cls);
241}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
243/* Class Device Stuff */
244
245int class_device_create_file(struct class_device * class_dev,
246 const struct class_device_attribute * attr)
247{
248 int error = -EINVAL;
249 if (class_dev)
250 error = sysfs_create_file(&class_dev->kobj, &attr->attr);
251 return error;
252}
253
254void class_device_remove_file(struct class_device * class_dev,
255 const struct class_device_attribute * attr)
256{
257 if (class_dev)
258 sysfs_remove_file(&class_dev->kobj, &attr->attr);
259}
260
261int class_device_create_bin_file(struct class_device *class_dev,
262 struct bin_attribute *attr)
263{
264 int error = -EINVAL;
265 if (class_dev)
266 error = sysfs_create_bin_file(&class_dev->kobj, attr);
267 return error;
268}
269
270void class_device_remove_bin_file(struct class_device *class_dev,
271 struct bin_attribute *attr)
272{
273 if (class_dev)
274 sysfs_remove_bin_file(&class_dev->kobj, attr);
275}
276
277static ssize_t
278class_device_attr_show(struct kobject * kobj, struct attribute * attr,
279 char * buf)
280{
281 struct class_device_attribute * class_dev_attr = to_class_dev_attr(attr);
282 struct class_device * cd = to_class_dev(kobj);
283 ssize_t ret = 0;
284
285 if (class_dev_attr->show)
286 ret = class_dev_attr->show(cd, buf);
287 return ret;
288}
289
290static ssize_t
291class_device_attr_store(struct kobject * kobj, struct attribute * attr,
292 const char * buf, size_t count)
293{
294 struct class_device_attribute * class_dev_attr = to_class_dev_attr(attr);
295 struct class_device * cd = to_class_dev(kobj);
296 ssize_t ret = 0;
297
298 if (class_dev_attr->store)
299 ret = class_dev_attr->store(cd, buf, count);
300 return ret;
301}
302
303static struct sysfs_ops class_dev_sysfs_ops = {
304 .show = class_device_attr_show,
305 .store = class_device_attr_store,
306};
307
308static void class_dev_release(struct kobject * kobj)
309{
310 struct class_device *cd = to_class_dev(kobj);
311 struct class * cls = cd->class;
312
313 pr_debug("device class '%s': release.\n", cd->class_id);
314
Jesper Juhlfef6ec82005-08-17 22:06:34 +0200315 kfree(cd->devt_attr);
316 cd->devt_attr = NULL;
Maneesh Soni208f3d62005-08-16 15:15:48 -0700317
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700318 if (cd->release)
319 cd->release(cd);
320 else if (cls->release)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 cls->release(cd);
322 else {
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700323 printk(KERN_ERR "Class Device '%s' does not have a release() function, "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 "it is broken and must be fixed.\n",
325 cd->class_id);
326 WARN_ON(1);
327 }
328}
329
330static struct kobj_type ktype_class_device = {
331 .sysfs_ops = &class_dev_sysfs_ops,
332 .release = class_dev_release,
333};
334
Kay Sievers312c0042005-11-16 09:00:00 +0100335static int class_uevent_filter(struct kset *kset, struct kobject *kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336{
337 struct kobj_type *ktype = get_ktype(kobj);
338
339 if (ktype == &ktype_class_device) {
340 struct class_device *class_dev = to_class_dev(kobj);
341 if (class_dev->class)
342 return 1;
343 }
344 return 0;
345}
346
Kay Sievers312c0042005-11-16 09:00:00 +0100347static const char *class_uevent_name(struct kset *kset, struct kobject *kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348{
349 struct class_device *class_dev = to_class_dev(kobj);
350
351 return class_dev->class->name;
352}
353
Kay Sievers805fab42006-09-14 11:23:28 +0200354#ifdef CONFIG_SYSFS_DEPRECATED
355char *make_class_name(const char *name, struct kobject *kobj)
356{
357 char *class_name;
358 int size;
359
360 size = strlen(name) + strlen(kobject_name(kobj)) + 2;
361
362 class_name = kmalloc(size, GFP_KERNEL);
363 if (!class_name)
Cornelia Huckcb360bb2006-11-27 10:35:05 +0100364 return NULL;
Kay Sievers805fab42006-09-14 11:23:28 +0200365
366 strcpy(class_name, name);
367 strcat(class_name, ":");
368 strcat(class_name, kobject_name(kobj));
369 return class_name;
370}
371
372static int deprecated_class_uevent(char **envp, int num_envp, int *cur_index,
373 char *buffer, int buffer_size,
374 int *cur_len,
375 struct class_device *class_dev)
376{
377 struct device *dev = class_dev->dev;
378 char *path;
379
380 if (!dev)
381 return 0;
382
383 /* add device, backing this class device (deprecated) */
384 path = kobject_get_path(&dev->kobj, GFP_KERNEL);
385
386 add_uevent_var(envp, num_envp, cur_index, buffer, buffer_size,
387 cur_len, "PHYSDEVPATH=%s", path);
388 kfree(path);
389
390 if (dev->bus)
391 add_uevent_var(envp, num_envp, cur_index,
392 buffer, buffer_size, cur_len,
393 "PHYSDEVBUS=%s", dev->bus->name);
394
395 if (dev->driver)
396 add_uevent_var(envp, num_envp, cur_index,
397 buffer, buffer_size, cur_len,
398 "PHYSDEVDRIVER=%s", dev->driver->name);
399 return 0;
400}
401
402static int make_deprecated_class_device_links(struct class_device *class_dev)
403{
404 char *class_name;
405 int error;
406
407 if (!class_dev->dev)
408 return 0;
409
410 class_name = make_class_name(class_dev->class->name, &class_dev->kobj);
Cornelia Huckcb360bb2006-11-27 10:35:05 +0100411 if (class_name)
412 error = sysfs_create_link(&class_dev->dev->kobj,
413 &class_dev->kobj, class_name);
414 else
415 error = -ENOMEM;
Kay Sievers805fab42006-09-14 11:23:28 +0200416 kfree(class_name);
417 return error;
418}
419
420static void remove_deprecated_class_device_links(struct class_device *class_dev)
421{
422 char *class_name;
423
424 if (!class_dev->dev)
425 return;
426
427 class_name = make_class_name(class_dev->class->name, &class_dev->kobj);
Cornelia Huckcb360bb2006-11-27 10:35:05 +0100428 if (class_name)
429 sysfs_remove_link(&class_dev->dev->kobj, class_name);
Kay Sievers805fab42006-09-14 11:23:28 +0200430 kfree(class_name);
431}
432#else
433static inline int deprecated_class_uevent(char **envp, int num_envp,
434 int *cur_index, char *buffer,
435 int buffer_size, int *cur_len,
436 struct class_device *class_dev)
437{ return 0; }
438static inline int make_deprecated_class_device_links(struct class_device *cd)
439{ return 0; }
440static void remove_deprecated_class_device_links(struct class_device *cd)
441{ }
442#endif
443
Kay Sievers312c0042005-11-16 09:00:00 +0100444static int class_uevent(struct kset *kset, struct kobject *kobj, char **envp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 int num_envp, char *buffer, int buffer_size)
446{
447 struct class_device *class_dev = to_class_dev(kobj);
448 int i = 0;
449 int length = 0;
450 int retval = 0;
451
452 pr_debug("%s - name = %s\n", __FUNCTION__, class_dev->class_id);
453
Kay Sievers805fab42006-09-14 11:23:28 +0200454 deprecated_class_uevent(envp, num_envp, &i, buffer, buffer_size,
455 &length, class_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
457 if (MAJOR(class_dev->devt)) {
Kay Sievers312c0042005-11-16 09:00:00 +0100458 add_uevent_var(envp, num_envp, &i,
459 buffer, buffer_size, &length,
460 "MAJOR=%u", MAJOR(class_dev->devt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
Kay Sievers312c0042005-11-16 09:00:00 +0100462 add_uevent_var(envp, num_envp, &i,
463 buffer, buffer_size, &length,
464 "MINOR=%u", MINOR(class_dev->devt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 }
466
467 /* terminate, set to next free slot, shrink available space */
468 envp[i] = NULL;
469 envp = &envp[i];
470 num_envp -= i;
471 buffer = &buffer[length];
472 buffer_size -= length;
473
Kay Sievers312c0042005-11-16 09:00:00 +0100474 if (class_dev->uevent) {
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700475 /* have the class device specific function add its stuff */
Kay Sievers312c0042005-11-16 09:00:00 +0100476 retval = class_dev->uevent(class_dev, envp, num_envp,
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700477 buffer, buffer_size);
478 if (retval)
Kay Sievers312c0042005-11-16 09:00:00 +0100479 pr_debug("class_dev->uevent() returned %d\n", retval);
480 } else if (class_dev->class->uevent) {
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700481 /* have the class specific function add its stuff */
Kay Sievers312c0042005-11-16 09:00:00 +0100482 retval = class_dev->class->uevent(class_dev, envp, num_envp,
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700483 buffer, buffer_size);
484 if (retval)
Kay Sievers312c0042005-11-16 09:00:00 +0100485 pr_debug("class->uevent() returned %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 }
487
488 return retval;
489}
490
Kay Sievers312c0042005-11-16 09:00:00 +0100491static struct kset_uevent_ops class_uevent_ops = {
492 .filter = class_uevent_filter,
493 .name = class_uevent_name,
494 .uevent = class_uevent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495};
496
Kay Sievers312c0042005-11-16 09:00:00 +0100497static decl_subsys(class_obj, &ktype_class_device, &class_uevent_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
499
500static int class_device_add_attrs(struct class_device * cd)
501{
502 int i;
503 int error = 0;
504 struct class * cls = cd->class;
505
506 if (cls->class_dev_attrs) {
507 for (i = 0; attr_name(cls->class_dev_attrs[i]); i++) {
508 error = class_device_create_file(cd,
509 &cls->class_dev_attrs[i]);
510 if (error)
511 goto Err;
512 }
513 }
514 Done:
515 return error;
516 Err:
517 while (--i >= 0)
518 class_device_remove_file(cd,&cls->class_dev_attrs[i]);
519 goto Done;
520}
521
522static void class_device_remove_attrs(struct class_device * cd)
523{
524 int i;
525 struct class * cls = cd->class;
526
527 if (cls->class_dev_attrs) {
528 for (i = 0; attr_name(cls->class_dev_attrs[i]); i++)
529 class_device_remove_file(cd,&cls->class_dev_attrs[i]);
530 }
531}
532
Stephen Hemminger14982212006-05-06 17:55:11 -0700533static int class_device_add_groups(struct class_device * cd)
534{
535 int i;
536 int error = 0;
537
538 if (cd->groups) {
539 for (i = 0; cd->groups[i]; i++) {
540 error = sysfs_create_group(&cd->kobj, cd->groups[i]);
541 if (error) {
542 while (--i >= 0)
543 sysfs_remove_group(&cd->kobj, cd->groups[i]);
544 goto out;
545 }
546 }
547 }
548out:
549 return error;
550}
551
552static void class_device_remove_groups(struct class_device * cd)
553{
554 int i;
555 if (cd->groups) {
556 for (i = 0; cd->groups[i]; i++) {
557 sysfs_remove_group(&cd->kobj, cd->groups[i]);
558 }
559 }
560}
561
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562static ssize_t show_dev(struct class_device *class_dev, char *buf)
563{
564 return print_dev_t(buf, class_dev->devt);
565}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
Kay Sieversa7fd6702005-10-01 14:49:43 +0200567static ssize_t store_uevent(struct class_device *class_dev,
568 const char *buf, size_t count)
569{
Kay Sievers312c0042005-11-16 09:00:00 +0100570 kobject_uevent(&class_dev->kobj, KOBJ_ADD);
Kay Sieversa7fd6702005-10-01 14:49:43 +0200571 return count;
572}
573
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574void class_device_initialize(struct class_device *class_dev)
575{
576 kobj_set_kset_s(class_dev, class_obj_subsys);
577 kobject_init(&class_dev->kobj);
578 INIT_LIST_HEAD(&class_dev->node);
579}
580
581int class_device_add(struct class_device *class_dev)
582{
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700583 struct class *parent_class = NULL;
584 struct class_device *parent_class_dev = NULL;
585 struct class_interface *class_intf;
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700586 int error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
588 class_dev = class_device_get(class_dev);
589 if (!class_dev)
590 return -EINVAL;
591
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700592 if (!strlen(class_dev->class_id))
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700593 goto out1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700595 parent_class = class_get(class_dev->class);
596 if (!parent_class)
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700597 goto out1;
598
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700599 parent_class_dev = class_device_get(class_dev->parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
601 pr_debug("CLASS: registering class device: ID = '%s'\n",
602 class_dev->class_id);
603
604 /* first, register with generic layer. */
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700605 error = kobject_set_name(&class_dev->kobj, "%s", class_dev->class_id);
606 if (error)
607 goto out2;
608
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700609 if (parent_class_dev)
610 class_dev->kobj.parent = &parent_class_dev->kobj;
611 else
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700612 class_dev->kobj.parent = &parent_class->subsys.kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700614 error = kobject_add(&class_dev->kobj);
615 if (error)
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700616 goto out2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800618 /* add the needed attributes to this device */
Cornelia Huckf0e17612006-09-22 11:37:00 +0200619 error = sysfs_create_link(&class_dev->kobj,
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700620 &parent_class->subsys.kobj, "subsystem");
Cornelia Huckf0e17612006-09-22 11:37:00 +0200621 if (error)
622 goto out3;
Kay Sieversa7fd6702005-10-01 14:49:43 +0200623 class_dev->uevent_attr.attr.name = "uevent";
624 class_dev->uevent_attr.attr.mode = S_IWUSR;
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700625 class_dev->uevent_attr.attr.owner = parent_class->owner;
Kay Sieversa7fd6702005-10-01 14:49:43 +0200626 class_dev->uevent_attr.store = store_uevent;
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700627 error = class_device_create_file(class_dev, &class_dev->uevent_attr);
628 if (error)
629 goto out3;
Kay Sieversa7fd6702005-10-01 14:49:43 +0200630
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800631 if (MAJOR(class_dev->devt)) {
632 struct class_device_attribute *attr;
Jiri Slaby4aed0642005-09-13 01:25:01 -0700633 attr = kzalloc(sizeof(*attr), GFP_KERNEL);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800634 if (!attr) {
635 error = -ENOMEM;
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700636 goto out4;
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800637 }
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800638 attr->attr.name = "dev";
639 attr->attr.mode = S_IRUGO;
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700640 attr->attr.owner = parent_class->owner;
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800641 attr->show = show_dev;
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700642 error = class_device_create_file(class_dev, attr);
643 if (error) {
644 kfree(attr);
645 goto out4;
646 }
647
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800648 class_dev->devt_attr = attr;
649 }
650
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700651 error = class_device_add_attrs(class_dev);
652 if (error)
653 goto out5;
654
Dmitry Torokhov76d1ce02005-07-10 01:21:24 -0500655 if (class_dev->dev) {
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700656 error = sysfs_create_link(&class_dev->kobj,
657 &class_dev->dev->kobj, "device");
658 if (error)
659 goto out6;
Dmitry Torokhov76d1ce02005-07-10 01:21:24 -0500660 }
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800661
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700662 error = class_device_add_groups(class_dev);
663 if (error)
Kay Sievers805fab42006-09-14 11:23:28 +0200664 goto out7;
665
666 error = make_deprecated_class_device_links(class_dev);
667 if (error)
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700668 goto out8;
Stephen Hemminger14982212006-05-06 17:55:11 -0700669
Kay Sievers312c0042005-11-16 09:00:00 +0100670 kobject_uevent(&class_dev->kobj, KOBJ_ADD);
Dmitry Torokhovdbe90352005-09-15 02:01:37 -0500671
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800672 /* notify any interfaces this device is now here */
Jayachandran Ca1438892006-04-03 12:31:53 -0700673 down(&parent_class->sem);
674 list_add_tail(&class_dev->node, &parent_class->children);
675 list_for_each_entry(class_intf, &parent_class->interfaces, node) {
676 if (class_intf->add)
677 class_intf->add(class_dev, class_intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 }
Jayachandran Ca1438892006-04-03 12:31:53 -0700679 up(&parent_class->sem);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800680
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700681 goto out1;
682
683 out8:
Kay Sievers805fab42006-09-14 11:23:28 +0200684 class_device_remove_groups(class_dev);
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700685 out7:
686 if (class_dev->dev)
687 sysfs_remove_link(&class_dev->kobj, "device");
688 out6:
689 class_device_remove_attrs(class_dev);
690 out5:
691 if (class_dev->devt_attr)
692 class_device_remove_file(class_dev, class_dev->devt_attr);
693 out4:
694 class_device_remove_file(class_dev, &class_dev->uevent_attr);
695 out3:
696 kobject_del(&class_dev->kobj);
697 out2:
698 if(parent_class_dev)
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700699 class_device_put(parent_class_dev);
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700700 class_put(parent_class);
701 out1:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 class_device_put(class_dev);
703 return error;
704}
705
706int class_device_register(struct class_device *class_dev)
707{
708 class_device_initialize(class_dev);
709 return class_device_add(class_dev);
710}
711
gregkh@suse.de2fc68442005-03-23 10:02:56 -0800712/**
713 * class_device_create - creates a class device and registers it with sysfs
Rolf Eike Beer92a0f862006-09-29 01:59:13 -0700714 * @cls: pointer to the struct class that this device should be registered to.
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700715 * @parent: pointer to the parent struct class_device of this new device, if any.
Rolf Eike Beer92a0f862006-09-29 01:59:13 -0700716 * @devt: the dev_t for the char device to be added.
gregkh@suse.de2fc68442005-03-23 10:02:56 -0800717 * @device: a pointer to a struct device that is assiociated with this class device.
718 * @fmt: string for the class device's name
719 *
720 * This function can be used by char device classes. A struct
721 * class_device will be created in sysfs, registered to the specified
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700722 * class.
723 * A "dev" file will be created, showing the dev_t for the device, if
724 * the dev_t is not 0,0.
725 * If a pointer to a parent struct class_device is passed in, the newly
726 * created struct class_device will be a child of that device in sysfs.
727 * The pointer to the struct class_device will be returned from the
728 * call. Any further sysfs files that might be required can be created
729 * using this pointer.
gregkh@suse.de2fc68442005-03-23 10:02:56 -0800730 *
731 * Note: the struct class passed to this function must have previously
732 * been created with a call to class_create().
733 */
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700734struct class_device *class_device_create(struct class *cls,
735 struct class_device *parent,
736 dev_t devt,
Dmitry Torokhovddd5d352006-08-10 01:18:18 -0400737 struct device *device,
738 const char *fmt, ...)
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800739{
740 va_list args;
741 struct class_device *class_dev = NULL;
742 int retval = -ENODEV;
743
744 if (cls == NULL || IS_ERR(cls))
745 goto error;
746
Jiri Slaby4aed0642005-09-13 01:25:01 -0700747 class_dev = kzalloc(sizeof(*class_dev), GFP_KERNEL);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800748 if (!class_dev) {
749 retval = -ENOMEM;
750 goto error;
751 }
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800752
753 class_dev->devt = devt;
754 class_dev->dev = device;
755 class_dev->class = cls;
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700756 class_dev->parent = parent;
757 class_dev->release = class_device_create_release;
Kay Sievers312c0042005-11-16 09:00:00 +0100758 class_dev->uevent = class_device_create_uevent;
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800759
760 va_start(args, fmt);
761 vsnprintf(class_dev->class_id, BUS_ID_SIZE, fmt, args);
762 va_end(args);
763 retval = class_device_register(class_dev);
764 if (retval)
765 goto error;
766
767 return class_dev;
768
769error:
770 kfree(class_dev);
771 return ERR_PTR(retval);
772}
773
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774void class_device_del(struct class_device *class_dev)
775{
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700776 struct class *parent_class = class_dev->class;
777 struct class_device *parent_device = class_dev->parent;
778 struct class_interface *class_intf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700780 if (parent_class) {
781 down(&parent_class->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 list_del_init(&class_dev->node);
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700783 list_for_each_entry(class_intf, &parent_class->interfaces, node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 if (class_intf->remove)
Dmitry Torokhovd8539d82005-09-15 02:01:36 -0500785 class_intf->remove(class_dev, class_intf);
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700786 up(&parent_class->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 }
788
Dmitry Torokhov76d1ce02005-07-10 01:21:24 -0500789 if (class_dev->dev) {
Kay Sievers805fab42006-09-14 11:23:28 +0200790 remove_deprecated_class_device_links(class_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 sysfs_remove_link(&class_dev->kobj, "device");
Dmitry Torokhov76d1ce02005-07-10 01:21:24 -0500792 }
Kay Sieversb9d9c822006-06-15 15:31:56 +0200793 sysfs_remove_link(&class_dev->kobj, "subsystem");
Kay Sieversa7fd6702005-10-01 14:49:43 +0200794 class_device_remove_file(class_dev, &class_dev->uevent_attr);
Maneesh Soni208f3d62005-08-16 15:15:48 -0700795 if (class_dev->devt_attr)
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800796 class_device_remove_file(class_dev, class_dev->devt_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 class_device_remove_attrs(class_dev);
Stephen Hemminger14982212006-05-06 17:55:11 -0700798 class_device_remove_groups(class_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799
Kay Sievers312c0042005-11-16 09:00:00 +0100800 kobject_uevent(&class_dev->kobj, KOBJ_REMOVE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 kobject_del(&class_dev->kobj);
802
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700803 class_device_put(parent_device);
804 class_put(parent_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805}
806
807void class_device_unregister(struct class_device *class_dev)
808{
809 pr_debug("CLASS: Unregistering class device. ID = '%s'\n",
810 class_dev->class_id);
811 class_device_del(class_dev);
812 class_device_put(class_dev);
813}
814
gregkh@suse.de2fc68442005-03-23 10:02:56 -0800815/**
816 * class_device_destroy - removes a class device that was created with class_device_create()
817 * @cls: the pointer to the struct class that this device was registered * with.
Rolf Eike Beer92a0f862006-09-29 01:59:13 -0700818 * @devt: the dev_t of the device that was previously registered.
gregkh@suse.de2fc68442005-03-23 10:02:56 -0800819 *
820 * This call unregisters and cleans up a class device that was created with a
821 * call to class_device_create()
822 */
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800823void class_device_destroy(struct class *cls, dev_t devt)
824{
825 struct class_device *class_dev = NULL;
826 struct class_device *class_dev_tmp;
827
828 down(&cls->sem);
829 list_for_each_entry(class_dev_tmp, &cls->children, node) {
830 if (class_dev_tmp->devt == devt) {
831 class_dev = class_dev_tmp;
832 break;
833 }
834 }
835 up(&cls->sem);
836
837 if (class_dev)
838 class_device_unregister(class_dev);
839}
840
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841struct class_device * class_device_get(struct class_device *class_dev)
842{
843 if (class_dev)
844 return to_class_dev(kobject_get(&class_dev->kobj));
845 return NULL;
846}
847
848void class_device_put(struct class_device *class_dev)
849{
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700850 if (class_dev)
851 kobject_put(&class_dev->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852}
853
854
855int class_interface_register(struct class_interface *class_intf)
856{
857 struct class *parent;
858 struct class_device *class_dev;
Greg Kroah-Hartmanc47ed212006-09-13 15:34:05 +0200859 struct device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860
861 if (!class_intf || !class_intf->class)
862 return -ENODEV;
863
864 parent = class_get(class_intf->class);
865 if (!parent)
866 return -EINVAL;
867
868 down(&parent->sem);
869 list_add_tail(&class_intf->node, &parent->interfaces);
870 if (class_intf->add) {
871 list_for_each_entry(class_dev, &parent->children, node)
Dmitry Torokhovd8539d82005-09-15 02:01:36 -0500872 class_intf->add(class_dev, class_intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 }
Greg Kroah-Hartmanc47ed212006-09-13 15:34:05 +0200874 if (class_intf->add_dev) {
875 list_for_each_entry(dev, &parent->devices, node)
876 class_intf->add_dev(dev, class_intf);
877 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 up(&parent->sem);
879
880 return 0;
881}
882
883void class_interface_unregister(struct class_interface *class_intf)
884{
885 struct class * parent = class_intf->class;
886 struct class_device *class_dev;
Greg Kroah-Hartmanc47ed212006-09-13 15:34:05 +0200887 struct device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888
889 if (!parent)
890 return;
891
892 down(&parent->sem);
893 list_del_init(&class_intf->node);
894 if (class_intf->remove) {
895 list_for_each_entry(class_dev, &parent->children, node)
Dmitry Torokhovd8539d82005-09-15 02:01:36 -0500896 class_intf->remove(class_dev, class_intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 }
Greg Kroah-Hartmanc47ed212006-09-13 15:34:05 +0200898 if (class_intf->remove_dev) {
899 list_for_each_entry(dev, &parent->devices, node)
900 class_intf->remove_dev(dev, class_intf);
901 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 up(&parent->sem);
903
904 class_put(parent);
905}
906
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907int __init classes_init(void)
908{
909 int retval;
910
911 retval = subsystem_register(&class_subsys);
912 if (retval)
913 return retval;
914
915 /* ick, this is ugly, the things we go through to keep from showing up
916 * in sysfs... */
917 subsystem_init(&class_obj_subsys);
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700918 if (!class_obj_subsys.kobj.parent)
919 class_obj_subsys.kobj.parent = &class_obj_subsys.kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 return 0;
921}
922
923EXPORT_SYMBOL_GPL(class_create_file);
924EXPORT_SYMBOL_GPL(class_remove_file);
925EXPORT_SYMBOL_GPL(class_register);
926EXPORT_SYMBOL_GPL(class_unregister);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800927EXPORT_SYMBOL_GPL(class_create);
928EXPORT_SYMBOL_GPL(class_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
930EXPORT_SYMBOL_GPL(class_device_register);
931EXPORT_SYMBOL_GPL(class_device_unregister);
932EXPORT_SYMBOL_GPL(class_device_initialize);
933EXPORT_SYMBOL_GPL(class_device_add);
934EXPORT_SYMBOL_GPL(class_device_del);
935EXPORT_SYMBOL_GPL(class_device_get);
936EXPORT_SYMBOL_GPL(class_device_put);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800937EXPORT_SYMBOL_GPL(class_device_create);
938EXPORT_SYMBOL_GPL(class_device_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939EXPORT_SYMBOL_GPL(class_device_create_file);
940EXPORT_SYMBOL_GPL(class_device_remove_file);
941EXPORT_SYMBOL_GPL(class_device_create_bin_file);
942EXPORT_SYMBOL_GPL(class_device_remove_bin_file);
943
944EXPORT_SYMBOL_GPL(class_interface_register);
945EXPORT_SYMBOL_GPL(class_interface_unregister);