blob: 304f90eb9b00df5188b3992236354885bd51a214 [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
Greg Kroah-Hartmanadc56802007-10-11 10:47:49 -060068static struct kobj_type class_ktype = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 .sysfs_ops = &class_sysfs_ops,
70 .release = class_release,
71};
72
73/* Hotplug events for classes go to the class_obj subsys */
Greg Kroah-Hartman443dbf92007-10-29 23:22:26 -050074static struct kset *class_kset;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
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)
Greg Kroah-Hartman1ef4cfa2007-09-12 15:06:57 -070096 return container_of(kset_get(&cls->subsys), struct class, subsys);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 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)
Greg Kroah-Hartman6e9d9302007-09-12 15:06:57 -0700103 kset_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
Greg Kroah-Hartman443dbf92007-10-29 23:22:26 -0500152 cls->subsys.kobj.kset = class_kset;
Greg Kroah-Hartman3514fac2007-10-16 10:11:44 -0600153 cls->subsys.kobj.ktype = &class_ktype;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155 error = subsystem_register(&cls->subsys);
156 if (!error) {
157 error = add_class_attrs(class_get(cls));
158 class_put(cls);
159 }
160 return error;
161}
162
163void class_unregister(struct class * cls)
164{
165 pr_debug("device class '%s': unregistering\n", cls->name);
166 remove_class_attrs(cls);
167 subsystem_unregister(&cls->subsys);
168}
169
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800170static void class_create_release(struct class *cls)
171{
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700172 pr_debug("%s called for %s\n", __FUNCTION__, cls->name);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800173 kfree(cls);
174}
175
176static void class_device_create_release(struct class_device *class_dev)
177{
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700178 pr_debug("%s called for %s\n", __FUNCTION__, class_dev->class_id);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800179 kfree(class_dev);
180}
181
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700182/* needed to allow these devices to have parent class devices */
Kay Sievers312c0042005-11-16 09:00:00 +0100183static int class_device_create_uevent(struct class_device *class_dev,
Kay Sievers7eff2e72007-08-14 15:15:12 +0200184 struct kobj_uevent_env *env)
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700185{
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
Greg Kroah-Hartmand919fd42007-10-31 12:51:29 -0700261int 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277static 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
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700315 if (cd->release)
316 cd->release(cd);
317 else if (cls->release)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 cls->release(cd);
319 else {
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700320 printk(KERN_ERR "Class Device '%s' does not have a release() function, "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 "it is broken and must be fixed.\n",
322 cd->class_id);
323 WARN_ON(1);
324 }
325}
326
Greg Kroah-Hartmanadc56802007-10-11 10:47:49 -0600327static struct kobj_type class_device_ktype = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 .sysfs_ops = &class_dev_sysfs_ops,
329 .release = class_dev_release,
330};
331
Kay Sievers312c0042005-11-16 09:00:00 +0100332static int class_uevent_filter(struct kset *kset, struct kobject *kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333{
334 struct kobj_type *ktype = get_ktype(kobj);
335
Greg Kroah-Hartmanadc56802007-10-11 10:47:49 -0600336 if (ktype == &class_device_ktype) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 struct class_device *class_dev = to_class_dev(kobj);
338 if (class_dev->class)
339 return 1;
340 }
341 return 0;
342}
343
Kay Sievers312c0042005-11-16 09:00:00 +0100344static const char *class_uevent_name(struct kset *kset, struct kobject *kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345{
346 struct class_device *class_dev = to_class_dev(kobj);
347
348 return class_dev->class->name;
349}
350
Kay Sievers805fab42006-09-14 11:23:28 +0200351#ifdef CONFIG_SYSFS_DEPRECATED
352char *make_class_name(const char *name, struct kobject *kobj)
353{
354 char *class_name;
355 int size;
356
357 size = strlen(name) + strlen(kobject_name(kobj)) + 2;
358
359 class_name = kmalloc(size, GFP_KERNEL);
360 if (!class_name)
Cornelia Huckcb360bb2006-11-27 10:35:05 +0100361 return NULL;
Kay Sievers805fab42006-09-14 11:23:28 +0200362
363 strcpy(class_name, name);
364 strcat(class_name, ":");
365 strcat(class_name, kobject_name(kobj));
366 return class_name;
367}
368
Kay Sievers805fab42006-09-14 11:23:28 +0200369static int make_deprecated_class_device_links(struct class_device *class_dev)
370{
371 char *class_name;
372 int error;
373
374 if (!class_dev->dev)
375 return 0;
376
377 class_name = make_class_name(class_dev->class->name, &class_dev->kobj);
Cornelia Huckcb360bb2006-11-27 10:35:05 +0100378 if (class_name)
379 error = sysfs_create_link(&class_dev->dev->kobj,
380 &class_dev->kobj, class_name);
381 else
382 error = -ENOMEM;
Kay Sievers805fab42006-09-14 11:23:28 +0200383 kfree(class_name);
384 return error;
385}
386
387static void remove_deprecated_class_device_links(struct class_device *class_dev)
388{
389 char *class_name;
390
391 if (!class_dev->dev)
392 return;
393
394 class_name = make_class_name(class_dev->class->name, &class_dev->kobj);
Cornelia Huckcb360bb2006-11-27 10:35:05 +0100395 if (class_name)
396 sysfs_remove_link(&class_dev->dev->kobj, class_name);
Kay Sievers805fab42006-09-14 11:23:28 +0200397 kfree(class_name);
398}
399#else
Kay Sievers805fab42006-09-14 11:23:28 +0200400static inline int make_deprecated_class_device_links(struct class_device *cd)
401{ return 0; }
402static void remove_deprecated_class_device_links(struct class_device *cd)
403{ }
404#endif
405
Kay Sievers7eff2e72007-08-14 15:15:12 +0200406static int class_uevent(struct kset *kset, struct kobject *kobj,
407 struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408{
409 struct class_device *class_dev = to_class_dev(kobj);
Kay Sievers2c7afd12007-05-01 13:46:26 +0200410 struct device *dev = class_dev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 int retval = 0;
412
413 pr_debug("%s - name = %s\n", __FUNCTION__, class_dev->class_id);
414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 if (MAJOR(class_dev->devt)) {
Kay Sievers7eff2e72007-08-14 15:15:12 +0200416 add_uevent_var(env, "MAJOR=%u", MAJOR(class_dev->devt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Kay Sievers7eff2e72007-08-14 15:15:12 +0200418 add_uevent_var(env, "MINOR=%u", MINOR(class_dev->devt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 }
420
Kay Sievers2c7afd12007-05-01 13:46:26 +0200421 if (dev) {
422 const char *path = kobject_get_path(&dev->kobj, GFP_KERNEL);
423 if (path) {
Kay Sievers7eff2e72007-08-14 15:15:12 +0200424 add_uevent_var(env, "PHYSDEVPATH=%s", path);
Kay Sievers2c7afd12007-05-01 13:46:26 +0200425 kfree(path);
426 }
427
428 if (dev->bus)
Kay Sievers7eff2e72007-08-14 15:15:12 +0200429 add_uevent_var(env, "PHYSDEVBUS=%s", dev->bus->name);
Kay Sievers2c7afd12007-05-01 13:46:26 +0200430
431 if (dev->driver)
Kay Sievers7eff2e72007-08-14 15:15:12 +0200432 add_uevent_var(env, "PHYSDEVDRIVER=%s", dev->driver->name);
Kay Sievers2c7afd12007-05-01 13:46:26 +0200433 }
434
Kay Sievers312c0042005-11-16 09:00:00 +0100435 if (class_dev->uevent) {
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700436 /* have the class device specific function add its stuff */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200437 retval = class_dev->uevent(class_dev, env);
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700438 if (retval)
Kay Sievers312c0042005-11-16 09:00:00 +0100439 pr_debug("class_dev->uevent() returned %d\n", retval);
440 } else if (class_dev->class->uevent) {
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700441 /* have the class specific function add its stuff */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200442 retval = class_dev->class->uevent(class_dev, env);
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700443 if (retval)
Kay Sievers312c0042005-11-16 09:00:00 +0100444 pr_debug("class->uevent() returned %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 }
446
447 return retval;
448}
449
Kay Sievers312c0042005-11-16 09:00:00 +0100450static struct kset_uevent_ops class_uevent_ops = {
451 .filter = class_uevent_filter,
452 .name = class_uevent_name,
453 .uevent = class_uevent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454};
455
Greg Kroah-Hartman5c03c7a2007-11-02 16:19:59 -0700456/*
457 * DO NOT copy how this is created, kset_create_and_add() should be
458 * called, but this is a hold-over from the old-way and will be deleted
459 * entirely soon.
460 */
461static struct kset class_obj_subsys = {
462 .kobj = { .k_name = "class_obj", },
463 .uevent_ops = &class_uevent_ops,
464};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
466static int class_device_add_attrs(struct class_device * cd)
467{
468 int i;
469 int error = 0;
470 struct class * cls = cd->class;
471
472 if (cls->class_dev_attrs) {
473 for (i = 0; attr_name(cls->class_dev_attrs[i]); i++) {
474 error = class_device_create_file(cd,
475 &cls->class_dev_attrs[i]);
476 if (error)
477 goto Err;
478 }
479 }
480 Done:
481 return error;
482 Err:
483 while (--i >= 0)
484 class_device_remove_file(cd,&cls->class_dev_attrs[i]);
485 goto Done;
486}
487
488static void class_device_remove_attrs(struct class_device * cd)
489{
490 int i;
491 struct class * cls = cd->class;
492
493 if (cls->class_dev_attrs) {
494 for (i = 0; attr_name(cls->class_dev_attrs[i]); i++)
495 class_device_remove_file(cd,&cls->class_dev_attrs[i]);
496 }
497}
498
Stephen Hemminger14982212006-05-06 17:55:11 -0700499static int class_device_add_groups(struct class_device * cd)
500{
501 int i;
502 int error = 0;
503
504 if (cd->groups) {
505 for (i = 0; cd->groups[i]; i++) {
506 error = sysfs_create_group(&cd->kobj, cd->groups[i]);
507 if (error) {
508 while (--i >= 0)
509 sysfs_remove_group(&cd->kobj, cd->groups[i]);
510 goto out;
511 }
512 }
513 }
514out:
515 return error;
516}
517
518static void class_device_remove_groups(struct class_device * cd)
519{
520 int i;
521 if (cd->groups) {
522 for (i = 0; cd->groups[i]; i++) {
523 sysfs_remove_group(&cd->kobj, cd->groups[i]);
524 }
525 }
526}
527
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528static ssize_t show_dev(struct class_device *class_dev, char *buf)
529{
530 return print_dev_t(buf, class_dev->devt);
531}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
Tejun Heoad6a1e12007-06-14 03:45:17 +0900533static struct class_device_attribute class_devt_attr =
534 __ATTR(dev, S_IRUGO, show_dev, NULL);
535
Kay Sieversa7fd6702005-10-01 14:49:43 +0200536static ssize_t store_uevent(struct class_device *class_dev,
537 const char *buf, size_t count)
538{
Kay Sievers312c0042005-11-16 09:00:00 +0100539 kobject_uevent(&class_dev->kobj, KOBJ_ADD);
Kay Sieversa7fd6702005-10-01 14:49:43 +0200540 return count;
541}
542
Tejun Heoad6a1e12007-06-14 03:45:17 +0900543static struct class_device_attribute class_uevent_attr =
544 __ATTR(uevent, S_IWUSR, NULL, store_uevent);
545
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546void class_device_initialize(struct class_device *class_dev)
547{
Greg Kroah-Hartman3514fac2007-10-16 10:11:44 -0600548 class_dev->kobj.kset = &class_obj_subsys;
549 class_dev->kobj.ktype = &class_device_ktype;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 kobject_init(&class_dev->kobj);
551 INIT_LIST_HEAD(&class_dev->node);
552}
553
554int class_device_add(struct class_device *class_dev)
555{
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700556 struct class *parent_class = NULL;
557 struct class_device *parent_class_dev = NULL;
558 struct class_interface *class_intf;
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700559 int error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560
561 class_dev = class_device_get(class_dev);
562 if (!class_dev)
563 return -EINVAL;
564
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700565 if (!strlen(class_dev->class_id))
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700566 goto out1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700568 parent_class = class_get(class_dev->class);
569 if (!parent_class)
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700570 goto out1;
571
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700572 parent_class_dev = class_device_get(class_dev->parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
574 pr_debug("CLASS: registering class device: ID = '%s'\n",
575 class_dev->class_id);
576
577 /* first, register with generic layer. */
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700578 error = kobject_set_name(&class_dev->kobj, "%s", class_dev->class_id);
579 if (error)
580 goto out2;
581
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700582 if (parent_class_dev)
583 class_dev->kobj.parent = &parent_class_dev->kobj;
584 else
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700585 class_dev->kobj.parent = &parent_class->subsys.kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700587 error = kobject_add(&class_dev->kobj);
588 if (error)
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700589 goto out2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800591 /* add the needed attributes to this device */
Cornelia Huckf0e17612006-09-22 11:37:00 +0200592 error = sysfs_create_link(&class_dev->kobj,
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700593 &parent_class->subsys.kobj, "subsystem");
Cornelia Huckf0e17612006-09-22 11:37:00 +0200594 if (error)
595 goto out3;
Tejun Heoad6a1e12007-06-14 03:45:17 +0900596
597 error = class_device_create_file(class_dev, &class_uevent_attr);
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700598 if (error)
599 goto out3;
Kay Sieversa7fd6702005-10-01 14:49:43 +0200600
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800601 if (MAJOR(class_dev->devt)) {
Tejun Heoad6a1e12007-06-14 03:45:17 +0900602 error = class_device_create_file(class_dev, &class_devt_attr);
603 if (error)
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700604 goto out4;
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800605 }
606
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700607 error = class_device_add_attrs(class_dev);
608 if (error)
609 goto out5;
610
Dmitry Torokhov76d1ce02005-07-10 01:21:24 -0500611 if (class_dev->dev) {
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700612 error = sysfs_create_link(&class_dev->kobj,
613 &class_dev->dev->kobj, "device");
614 if (error)
615 goto out6;
Dmitry Torokhov76d1ce02005-07-10 01:21:24 -0500616 }
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800617
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700618 error = class_device_add_groups(class_dev);
619 if (error)
Kay Sievers805fab42006-09-14 11:23:28 +0200620 goto out7;
621
622 error = make_deprecated_class_device_links(class_dev);
623 if (error)
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700624 goto out8;
Stephen Hemminger14982212006-05-06 17:55:11 -0700625
Kay Sievers312c0042005-11-16 09:00:00 +0100626 kobject_uevent(&class_dev->kobj, KOBJ_ADD);
Dmitry Torokhovdbe90352005-09-15 02:01:37 -0500627
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800628 /* notify any interfaces this device is now here */
Jayachandran Ca1438892006-04-03 12:31:53 -0700629 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 }
Jayachandran Ca1438892006-04-03 12:31:53 -0700635 up(&parent_class->sem);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800636
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700637 goto out1;
638
639 out8:
Kay Sievers805fab42006-09-14 11:23:28 +0200640 class_device_remove_groups(class_dev);
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700641 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:
Tejun Heoad6a1e12007-06-14 03:45:17 +0900647 if (MAJOR(class_dev->devt))
648 class_device_remove_file(class_dev, &class_devt_attr);
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700649 out4:
Tejun Heoad6a1e12007-06-14 03:45:17 +0900650 class_device_remove_file(class_dev, &class_uevent_attr);
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700651 out3:
652 kobject_del(&class_dev->kobj);
653 out2:
654 if(parent_class_dev)
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700655 class_device_put(parent_class_dev);
Stephen Hemmingerb7fe4a62006-04-26 09:53:14 -0700656 class_put(parent_class);
657 out1:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 class_device_put(class_dev);
659 return error;
660}
661
662int class_device_register(struct class_device *class_dev)
663{
664 class_device_initialize(class_dev);
665 return class_device_add(class_dev);
666}
667
gregkh@suse.de2fc68442005-03-23 10:02:56 -0800668/**
669 * class_device_create - creates a class device and registers it with sysfs
Rolf Eike Beer92a0f862006-09-29 01:59:13 -0700670 * @cls: pointer to the struct class that this device should be registered to.
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700671 * @parent: pointer to the parent struct class_device of this new device, if any.
Rolf Eike Beer92a0f862006-09-29 01:59:13 -0700672 * @devt: the dev_t for the char device to be added.
gregkh@suse.de2fc68442005-03-23 10:02:56 -0800673 * @device: a pointer to a struct device that is assiociated with this class device.
674 * @fmt: string for the class device's name
675 *
676 * This function can be used by char device classes. A struct
677 * class_device will be created in sysfs, registered to the specified
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700678 * class.
679 * A "dev" file will be created, showing the dev_t for the device, if
680 * the dev_t is not 0,0.
681 * If a pointer to a parent struct class_device is passed in, the newly
682 * created struct class_device will be a child of that device in sysfs.
683 * The pointer to the struct class_device will be returned from the
684 * call. Any further sysfs files that might be required can be created
685 * using this pointer.
gregkh@suse.de2fc68442005-03-23 10:02:56 -0800686 *
687 * Note: the struct class passed to this function must have previously
688 * been created with a call to class_create().
689 */
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700690struct class_device *class_device_create(struct class *cls,
691 struct class_device *parent,
692 dev_t devt,
Dmitry Torokhovddd5d352006-08-10 01:18:18 -0400693 struct device *device,
694 const char *fmt, ...)
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800695{
696 va_list args;
697 struct class_device *class_dev = NULL;
698 int retval = -ENODEV;
699
700 if (cls == NULL || IS_ERR(cls))
701 goto error;
702
Jiri Slaby4aed0642005-09-13 01:25:01 -0700703 class_dev = kzalloc(sizeof(*class_dev), GFP_KERNEL);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800704 if (!class_dev) {
705 retval = -ENOMEM;
706 goto error;
707 }
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800708
709 class_dev->devt = devt;
710 class_dev->dev = device;
711 class_dev->class = cls;
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700712 class_dev->parent = parent;
713 class_dev->release = class_device_create_release;
Kay Sievers312c0042005-11-16 09:00:00 +0100714 class_dev->uevent = class_device_create_uevent;
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800715
716 va_start(args, fmt);
717 vsnprintf(class_dev->class_id, BUS_ID_SIZE, fmt, args);
718 va_end(args);
719 retval = class_device_register(class_dev);
720 if (retval)
721 goto error;
722
723 return class_dev;
724
725error:
726 kfree(class_dev);
727 return ERR_PTR(retval);
728}
729
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730void class_device_del(struct class_device *class_dev)
731{
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700732 struct class *parent_class = class_dev->class;
733 struct class_device *parent_device = class_dev->parent;
734 struct class_interface *class_intf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700736 if (parent_class) {
737 down(&parent_class->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 list_del_init(&class_dev->node);
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700739 list_for_each_entry(class_intf, &parent_class->interfaces, node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 if (class_intf->remove)
Dmitry Torokhovd8539d82005-09-15 02:01:36 -0500741 class_intf->remove(class_dev, class_intf);
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700742 up(&parent_class->sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 }
744
Dmitry Torokhov76d1ce02005-07-10 01:21:24 -0500745 if (class_dev->dev) {
Kay Sievers805fab42006-09-14 11:23:28 +0200746 remove_deprecated_class_device_links(class_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 sysfs_remove_link(&class_dev->kobj, "device");
Dmitry Torokhov76d1ce02005-07-10 01:21:24 -0500748 }
Kay Sieversb9d9c822006-06-15 15:31:56 +0200749 sysfs_remove_link(&class_dev->kobj, "subsystem");
Tejun Heoad6a1e12007-06-14 03:45:17 +0900750 class_device_remove_file(class_dev, &class_uevent_attr);
751 if (MAJOR(class_dev->devt))
752 class_device_remove_file(class_dev, &class_devt_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 class_device_remove_attrs(class_dev);
Stephen Hemminger14982212006-05-06 17:55:11 -0700754 class_device_remove_groups(class_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
Kay Sievers312c0042005-11-16 09:00:00 +0100756 kobject_uevent(&class_dev->kobj, KOBJ_REMOVE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 kobject_del(&class_dev->kobj);
758
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700759 class_device_put(parent_device);
760 class_put(parent_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761}
762
763void class_device_unregister(struct class_device *class_dev)
764{
765 pr_debug("CLASS: Unregistering class device. ID = '%s'\n",
766 class_dev->class_id);
767 class_device_del(class_dev);
768 class_device_put(class_dev);
769}
770
gregkh@suse.de2fc68442005-03-23 10:02:56 -0800771/**
772 * class_device_destroy - removes a class device that was created with class_device_create()
773 * @cls: the pointer to the struct class that this device was registered * with.
Rolf Eike Beer92a0f862006-09-29 01:59:13 -0700774 * @devt: the dev_t of the device that was previously registered.
gregkh@suse.de2fc68442005-03-23 10:02:56 -0800775 *
776 * This call unregisters and cleans up a class device that was created with a
777 * call to class_device_create()
778 */
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800779void class_device_destroy(struct class *cls, dev_t devt)
780{
781 struct class_device *class_dev = NULL;
782 struct class_device *class_dev_tmp;
783
784 down(&cls->sem);
785 list_for_each_entry(class_dev_tmp, &cls->children, node) {
786 if (class_dev_tmp->devt == devt) {
787 class_dev = class_dev_tmp;
788 break;
789 }
790 }
791 up(&cls->sem);
792
793 if (class_dev)
794 class_device_unregister(class_dev);
795}
796
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797struct class_device * class_device_get(struct class_device *class_dev)
798{
799 if (class_dev)
800 return to_class_dev(kobject_get(&class_dev->kobj));
801 return NULL;
802}
803
804void class_device_put(struct class_device *class_dev)
805{
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700806 if (class_dev)
807 kobject_put(&class_dev->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808}
809
810
811int class_interface_register(struct class_interface *class_intf)
812{
813 struct class *parent;
814 struct class_device *class_dev;
Greg Kroah-Hartmanc47ed212006-09-13 15:34:05 +0200815 struct device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
817 if (!class_intf || !class_intf->class)
818 return -ENODEV;
819
820 parent = class_get(class_intf->class);
821 if (!parent)
822 return -EINVAL;
823
824 down(&parent->sem);
825 list_add_tail(&class_intf->node, &parent->interfaces);
826 if (class_intf->add) {
827 list_for_each_entry(class_dev, &parent->children, node)
Dmitry Torokhovd8539d82005-09-15 02:01:36 -0500828 class_intf->add(class_dev, class_intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 }
Greg Kroah-Hartmanc47ed212006-09-13 15:34:05 +0200830 if (class_intf->add_dev) {
831 list_for_each_entry(dev, &parent->devices, node)
832 class_intf->add_dev(dev, class_intf);
833 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 up(&parent->sem);
835
836 return 0;
837}
838
839void class_interface_unregister(struct class_interface *class_intf)
840{
841 struct class * parent = class_intf->class;
842 struct class_device *class_dev;
Greg Kroah-Hartmanc47ed212006-09-13 15:34:05 +0200843 struct device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
845 if (!parent)
846 return;
847
848 down(&parent->sem);
849 list_del_init(&class_intf->node);
850 if (class_intf->remove) {
851 list_for_each_entry(class_dev, &parent->children, node)
Dmitry Torokhovd8539d82005-09-15 02:01:36 -0500852 class_intf->remove(class_dev, class_intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 }
Greg Kroah-Hartmanc47ed212006-09-13 15:34:05 +0200854 if (class_intf->remove_dev) {
855 list_for_each_entry(dev, &parent->devices, node)
856 class_intf->remove_dev(dev, class_intf);
857 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 up(&parent->sem);
859
860 class_put(parent);
861}
862
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863int __init classes_init(void)
864{
Greg Kroah-Hartman443dbf92007-10-29 23:22:26 -0500865 class_kset = kset_create_and_add("class", NULL, NULL);
866 if (!class_kset)
867 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868
869 /* ick, this is ugly, the things we go through to keep from showing up
870 * in sysfs... */
Greg Kroah-Hartmane4bc1662007-09-26 11:12:00 -0700871 kset_init(&class_obj_subsys);
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700872 if (!class_obj_subsys.kobj.parent)
873 class_obj_subsys.kobj.parent = &class_obj_subsys.kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 return 0;
875}
876
877EXPORT_SYMBOL_GPL(class_create_file);
878EXPORT_SYMBOL_GPL(class_remove_file);
879EXPORT_SYMBOL_GPL(class_register);
880EXPORT_SYMBOL_GPL(class_unregister);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800881EXPORT_SYMBOL_GPL(class_create);
882EXPORT_SYMBOL_GPL(class_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883
884EXPORT_SYMBOL_GPL(class_device_register);
885EXPORT_SYMBOL_GPL(class_device_unregister);
886EXPORT_SYMBOL_GPL(class_device_initialize);
887EXPORT_SYMBOL_GPL(class_device_add);
888EXPORT_SYMBOL_GPL(class_device_del);
889EXPORT_SYMBOL_GPL(class_device_get);
890EXPORT_SYMBOL_GPL(class_device_put);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800891EXPORT_SYMBOL_GPL(class_device_create);
892EXPORT_SYMBOL_GPL(class_device_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893EXPORT_SYMBOL_GPL(class_device_create_file);
894EXPORT_SYMBOL_GPL(class_device_remove_file);
Greg Kroah-Hartmand919fd42007-10-31 12:51:29 -0700895EXPORT_SYMBOL_GPL(class_device_create_bin_file);
896EXPORT_SYMBOL_GPL(class_device_remove_bin_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897
898EXPORT_SYMBOL_GPL(class_interface_register);
899EXPORT_SYMBOL_GPL(class_interface_unregister);