class: rename "subsys" to "class_subsys" in internal class structure
[linux-2.6.git] / drivers / base / class.c
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
25 static ssize_t class_attr_show(struct kobject *kobj, struct attribute *attr,
26                                char *buf)
27 {
28         struct class_attribute *class_attr = to_class_attr(attr);
29         struct class_private *cp = to_class(kobj);
30         ssize_t ret = -EIO;
31
32         if (class_attr->show)
33                 ret = class_attr->show(cp->class, buf);
34         return ret;
35 }
36
37 static ssize_t class_attr_store(struct kobject *kobj, struct attribute *attr,
38                                 const char *buf, size_t count)
39 {
40         struct class_attribute *class_attr = to_class_attr(attr);
41         struct class_private *cp = to_class(kobj);
42         ssize_t ret = -EIO;
43
44         if (class_attr->store)
45                 ret = class_attr->store(cp->class, buf, count);
46         return ret;
47 }
48
49 static void class_release(struct kobject *kobj)
50 {
51         struct class_private *cp = to_class(kobj);
52         struct class *class = cp->class;
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 class_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->p->class_subsys.kobj,
82                                           &attr->attr);
83         else
84                 error = -EINVAL;
85         return error;
86 }
87
88 void class_remove_file(struct class *cls, const struct class_attribute *attr)
89 {
90         if (cls)
91                 sysfs_remove_file(&cls->p->class_subsys.kobj, &attr->attr);
92 }
93
94 static struct class *class_get(struct class *cls)
95 {
96         if (cls)
97                 kset_get(&cls->p->class_subsys);
98         return cls;
99 }
100
101 static void class_put(struct class *cls)
102 {
103         if (cls)
104                 kset_put(&cls->p->class_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         struct class_private *cp;
140         int error;
141
142         pr_debug("device class '%s': registering\n", cls->name);
143
144         cp = kzalloc(sizeof(*cp), GFP_KERNEL);
145         if (!cp)
146                 return -ENOMEM;
147         INIT_LIST_HEAD(&cp->class_devices);
148         INIT_LIST_HEAD(&cp->class_interfaces);
149         kset_init(&cp->class_dirs);
150         init_MUTEX(&cp->sem);
151         error = kobject_set_name(&cp->class_subsys.kobj, "%s", cls->name);
152         if (error) {
153                 kfree(cp);
154                 return error;
155         }
156
157         /* set the default /sys/dev directory for devices of this class */
158         if (!cls->dev_kobj)
159                 cls->dev_kobj = sysfs_dev_char_kobj;
160
161 #if defined(CONFIG_SYSFS_DEPRECATED) && defined(CONFIG_BLOCK)
162         /* let the block class directory show up in the root of sysfs */
163         if (cls != &block_class)
164                 cp->class_subsys.kobj.kset = class_kset;
165 #else
166         cp->class_subsys.kobj.kset = class_kset;
167 #endif
168         cp->class_subsys.kobj.ktype = &class_ktype;
169         cp->class = cls;
170         cls->p = cp;
171
172         error = kset_register(&cp->class_subsys);
173         if (error) {
174                 kfree(cp);
175                 return error;
176         }
177         error = add_class_attrs(class_get(cls));
178         class_put(cls);
179         return error;
180 }
181
182 void class_unregister(struct class *cls)
183 {
184         pr_debug("device class '%s': unregistering\n", cls->name);
185         remove_class_attrs(cls);
186         kset_unregister(&cls->p->class_subsys);
187 }
188
189 static void class_create_release(struct class *cls)
190 {
191         pr_debug("%s called for %s\n", __func__, cls->name);
192         kfree(cls);
193 }
194
195 /**
196  * class_create - create a struct class structure
197  * @owner: pointer to the module that is to "own" this struct class
198  * @name: pointer to a string for the name of this class.
199  *
200  * This is used to create a struct class pointer that can then be used
201  * in calls to device_create().
202  *
203  * Note, the pointer created here is to be destroyed when finished by
204  * making a call to class_destroy().
205  */
206 struct class *class_create(struct module *owner, const char *name)
207 {
208         struct class *cls;
209         int retval;
210
211         cls = kzalloc(sizeof(*cls), GFP_KERNEL);
212         if (!cls) {
213                 retval = -ENOMEM;
214                 goto error;
215         }
216
217         cls->name = name;
218         cls->owner = owner;
219         cls->class_release = class_create_release;
220
221         retval = class_register(cls);
222         if (retval)
223                 goto error;
224
225         return cls;
226
227 error:
228         kfree(cls);
229         return ERR_PTR(retval);
230 }
231
232 /**
233  * class_destroy - destroys a struct class structure
234  * @cls: pointer to the struct class that is to be destroyed
235  *
236  * Note, the pointer to be destroyed must have been created with a call
237  * to class_create().
238  */
239 void class_destroy(struct class *cls)
240 {
241         if ((cls == NULL) || (IS_ERR(cls)))
242                 return;
243
244         class_unregister(cls);
245 }
246
247 #ifdef CONFIG_SYSFS_DEPRECATED
248 char *make_class_name(const char *name, struct kobject *kobj)
249 {
250         char *class_name;
251         int size;
252
253         size = strlen(name) + strlen(kobject_name(kobj)) + 2;
254
255         class_name = kmalloc(size, GFP_KERNEL);
256         if (!class_name)
257                 return NULL;
258
259         strcpy(class_name, name);
260         strcat(class_name, ":");
261         strcat(class_name, kobject_name(kobj));
262         return class_name;
263 }
264 #endif
265
266 /**
267  * class_for_each_device - device iterator
268  * @class: the class we're iterating
269  * @start: the device to start with in the list, if any.
270  * @data: data for the callback
271  * @fn: function to be called for each device
272  *
273  * Iterate over @class's list of devices, and call @fn for each,
274  * passing it @data.  If @start is set, the list iteration will start
275  * there, otherwise if it is NULL, the iteration starts at the
276  * beginning of the list.
277  *
278  * We check the return of @fn each time. If it returns anything
279  * other than 0, we break out and return that value.
280  *
281  * Note, we hold class->sem in this function, so it can not be
282  * re-acquired in @fn, otherwise it will self-deadlocking. For
283  * example, calls to add or remove class members would be verboten.
284  */
285 int class_for_each_device(struct class *class, struct device *start,
286                           void *data, int (*fn)(struct device *, void *))
287 {
288         struct device *dev;
289         int error = 0;
290
291         if (!class)
292                 return -EINVAL;
293         down(&class->p->sem);
294         list_for_each_entry(dev, &class->p->class_devices, node) {
295                 if (start) {
296                         if (start == dev)
297                                 start = NULL;
298                         continue;
299                 }
300                 dev = get_device(dev);
301                 error = fn(dev, data);
302                 put_device(dev);
303                 if (error)
304                         break;
305         }
306         up(&class->p->sem);
307
308         return error;
309 }
310 EXPORT_SYMBOL_GPL(class_for_each_device);
311
312 /**
313  * class_find_device - device iterator for locating a particular device
314  * @class: the class we're iterating
315  * @start: Device to begin with
316  * @data: data for the match function
317  * @match: function to check device
318  *
319  * This is similar to the class_for_each_dev() function above, but it
320  * returns a reference to a device that is 'found' for later use, as
321  * determined by the @match callback.
322  *
323  * The callback should return 0 if the device doesn't match and non-zero
324  * if it does.  If the callback returns non-zero, this function will
325  * return to the caller and not iterate over any more devices.
326  *
327  * Note, you will need to drop the reference with put_device() after use.
328  *
329  * We hold class->sem in this function, so it can not be
330  * re-acquired in @match, otherwise it will self-deadlocking. For
331  * example, calls to add or remove class members would be verboten.
332  */
333 struct device *class_find_device(struct class *class, struct device *start,
334                                  void *data,
335                                  int (*match)(struct device *, void *))
336 {
337         struct device *dev;
338         int found = 0;
339
340         if (!class)
341                 return NULL;
342
343         down(&class->p->sem);
344         list_for_each_entry(dev, &class->p->class_devices, node) {
345                 if (start) {
346                         if (start == dev)
347                                 start = NULL;
348                         continue;
349                 }
350                 dev = get_device(dev);
351                 if (match(dev, data)) {
352                         found = 1;
353                         break;
354                 } else
355                         put_device(dev);
356         }
357         up(&class->p->sem);
358
359         return found ? dev : NULL;
360 }
361 EXPORT_SYMBOL_GPL(class_find_device);
362
363 int class_interface_register(struct class_interface *class_intf)
364 {
365         struct class *parent;
366         struct device *dev;
367
368         if (!class_intf || !class_intf->class)
369                 return -ENODEV;
370
371         parent = class_get(class_intf->class);
372         if (!parent)
373                 return -EINVAL;
374
375         down(&parent->p->sem);
376         list_add_tail(&class_intf->node, &parent->p->class_interfaces);
377         if (class_intf->add_dev) {
378                 list_for_each_entry(dev, &parent->p->class_devices, node)
379                         class_intf->add_dev(dev, class_intf);
380         }
381         up(&parent->p->sem);
382
383         return 0;
384 }
385
386 void class_interface_unregister(struct class_interface *class_intf)
387 {
388         struct class *parent = class_intf->class;
389         struct device *dev;
390
391         if (!parent)
392                 return;
393
394         down(&parent->p->sem);
395         list_del_init(&class_intf->node);
396         if (class_intf->remove_dev) {
397                 list_for_each_entry(dev, &parent->p->class_devices, node)
398                         class_intf->remove_dev(dev, class_intf);
399         }
400         up(&parent->p->sem);
401
402         class_put(parent);
403 }
404
405 int __init classes_init(void)
406 {
407         class_kset = kset_create_and_add("class", NULL, NULL);
408         if (!class_kset)
409                 return -ENOMEM;
410         return 0;
411 }
412
413 EXPORT_SYMBOL_GPL(class_create_file);
414 EXPORT_SYMBOL_GPL(class_remove_file);
415 EXPORT_SYMBOL_GPL(class_register);
416 EXPORT_SYMBOL_GPL(class_unregister);
417 EXPORT_SYMBOL_GPL(class_create);
418 EXPORT_SYMBOL_GPL(class_destroy);
419
420 EXPORT_SYMBOL_GPL(class_interface_register);
421 EXPORT_SYMBOL_GPL(class_interface_unregister);