include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-2.6.git] / drivers / base / sys.c
1 /*
2  * sys.c - pseudo-bus for system 'devices' (cpus, PICs, timers, etc)
3  *
4  * Copyright (c) 2002-3 Patrick Mochel
5  *               2002-3 Open Source Development Lab
6  *
7  * This file is released under the GPLv2
8  *
9  * This exports a 'system' bus type.
10  * By default, a 'sys' bus gets added to the root of the system. There will
11  * always be core system devices. Devices can use sysdev_register() to
12  * add themselves as children of the system bus.
13  */
14
15 #include <linux/sysdev.h>
16 #include <linux/err.h>
17 #include <linux/module.h>
18 #include <linux/kernel.h>
19 #include <linux/init.h>
20 #include <linux/string.h>
21 #include <linux/pm.h>
22 #include <linux/device.h>
23 #include <linux/mutex.h>
24 #include <linux/interrupt.h>
25
26 #include "base.h"
27
28 #define to_sysdev(k) container_of(k, struct sys_device, kobj)
29 #define to_sysdev_attr(a) container_of(a, struct sysdev_attribute, attr)
30
31
32 static ssize_t
33 sysdev_show(struct kobject *kobj, struct attribute *attr, char *buffer)
34 {
35         struct sys_device *sysdev = to_sysdev(kobj);
36         struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
37
38         if (sysdev_attr->show)
39                 return sysdev_attr->show(sysdev, sysdev_attr, buffer);
40         return -EIO;
41 }
42
43
44 static ssize_t
45 sysdev_store(struct kobject *kobj, struct attribute *attr,
46              const char *buffer, size_t count)
47 {
48         struct sys_device *sysdev = to_sysdev(kobj);
49         struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
50
51         if (sysdev_attr->store)
52                 return sysdev_attr->store(sysdev, sysdev_attr, buffer, count);
53         return -EIO;
54 }
55
56 static const struct sysfs_ops sysfs_ops = {
57         .show   = sysdev_show,
58         .store  = sysdev_store,
59 };
60
61 static struct kobj_type ktype_sysdev = {
62         .sysfs_ops      = &sysfs_ops,
63 };
64
65
66 int sysdev_create_file(struct sys_device *s, struct sysdev_attribute *a)
67 {
68         return sysfs_create_file(&s->kobj, &a->attr);
69 }
70
71
72 void sysdev_remove_file(struct sys_device *s, struct sysdev_attribute *a)
73 {
74         sysfs_remove_file(&s->kobj, &a->attr);
75 }
76
77 EXPORT_SYMBOL_GPL(sysdev_create_file);
78 EXPORT_SYMBOL_GPL(sysdev_remove_file);
79
80 #define to_sysdev_class(k) container_of(k, struct sysdev_class, kset.kobj)
81 #define to_sysdev_class_attr(a) container_of(a, \
82         struct sysdev_class_attribute, attr)
83
84 static ssize_t sysdev_class_show(struct kobject *kobj, struct attribute *attr,
85                                  char *buffer)
86 {
87         struct sysdev_class *class = to_sysdev_class(kobj);
88         struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
89
90         if (class_attr->show)
91                 return class_attr->show(class, class_attr, buffer);
92         return -EIO;
93 }
94
95 static ssize_t sysdev_class_store(struct kobject *kobj, struct attribute *attr,
96                                   const char *buffer, size_t count)
97 {
98         struct sysdev_class *class = to_sysdev_class(kobj);
99         struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
100
101         if (class_attr->store)
102                 return class_attr->store(class, class_attr, buffer, count);
103         return -EIO;
104 }
105
106 static const struct sysfs_ops sysfs_class_ops = {
107         .show   = sysdev_class_show,
108         .store  = sysdev_class_store,
109 };
110
111 static struct kobj_type ktype_sysdev_class = {
112         .sysfs_ops      = &sysfs_class_ops,
113 };
114
115 int sysdev_class_create_file(struct sysdev_class *c,
116                              struct sysdev_class_attribute *a)
117 {
118         return sysfs_create_file(&c->kset.kobj, &a->attr);
119 }
120 EXPORT_SYMBOL_GPL(sysdev_class_create_file);
121
122 void sysdev_class_remove_file(struct sysdev_class *c,
123                               struct sysdev_class_attribute *a)
124 {
125         sysfs_remove_file(&c->kset.kobj, &a->attr);
126 }
127 EXPORT_SYMBOL_GPL(sysdev_class_remove_file);
128
129 static struct kset *system_kset;
130
131 int sysdev_class_register(struct sysdev_class *cls)
132 {
133         int retval;
134
135         pr_debug("Registering sysdev class '%s'\n", cls->name);
136
137         INIT_LIST_HEAD(&cls->drivers);
138         memset(&cls->kset.kobj, 0x00, sizeof(struct kobject));
139         cls->kset.kobj.parent = &system_kset->kobj;
140         cls->kset.kobj.ktype = &ktype_sysdev_class;
141         cls->kset.kobj.kset = system_kset;
142
143         retval = kobject_set_name(&cls->kset.kobj, "%s", cls->name);
144         if (retval)
145                 return retval;
146
147         retval = kset_register(&cls->kset);
148         if (!retval && cls->attrs)
149                 retval = sysfs_create_files(&cls->kset.kobj,
150                                             (const struct attribute **)cls->attrs);
151         return retval;
152 }
153
154 void sysdev_class_unregister(struct sysdev_class *cls)
155 {
156         pr_debug("Unregistering sysdev class '%s'\n",
157                  kobject_name(&cls->kset.kobj));
158         if (cls->attrs)
159                 sysfs_remove_files(&cls->kset.kobj,
160                                    (const struct attribute **)cls->attrs);
161         kset_unregister(&cls->kset);
162 }
163
164 EXPORT_SYMBOL_GPL(sysdev_class_register);
165 EXPORT_SYMBOL_GPL(sysdev_class_unregister);
166
167 static DEFINE_MUTEX(sysdev_drivers_lock);
168
169 /**
170  *      sysdev_driver_register - Register auxillary driver
171  *      @cls:   Device class driver belongs to.
172  *      @drv:   Driver.
173  *
174  *      @drv is inserted into @cls->drivers to be
175  *      called on each operation on devices of that class. The refcount
176  *      of @cls is incremented.
177  */
178
179 int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
180 {
181         int err = 0;
182
183         if (!cls) {
184                 WARN(1, KERN_WARNING "sysdev: invalid class passed to "
185                         "sysdev_driver_register!\n");
186                 return -EINVAL;
187         }
188
189         /* Check whether this driver has already been added to a class. */
190         if (drv->entry.next && !list_empty(&drv->entry))
191                 WARN(1, KERN_WARNING "sysdev: class %s: driver (%p) has already"
192                         " been registered to a class, something is wrong, but "
193                         "will forge on!\n", cls->name, drv);
194
195         mutex_lock(&sysdev_drivers_lock);
196         if (cls && kset_get(&cls->kset)) {
197                 list_add_tail(&drv->entry, &cls->drivers);
198
199                 /* If devices of this class already exist, tell the driver */
200                 if (drv->add) {
201                         struct sys_device *dev;
202                         list_for_each_entry(dev, &cls->kset.list, kobj.entry)
203                                 drv->add(dev);
204                 }
205         } else {
206                 err = -EINVAL;
207                 WARN(1, KERN_ERR "%s: invalid device class\n", __func__);
208         }
209         mutex_unlock(&sysdev_drivers_lock);
210         return err;
211 }
212
213
214 /**
215  *      sysdev_driver_unregister - Remove an auxillary driver.
216  *      @cls:   Class driver belongs to.
217  *      @drv:   Driver.
218  */
219 void sysdev_driver_unregister(struct sysdev_class *cls,
220                               struct sysdev_driver *drv)
221 {
222         mutex_lock(&sysdev_drivers_lock);
223         list_del_init(&drv->entry);
224         if (cls) {
225                 if (drv->remove) {
226                         struct sys_device *dev;
227                         list_for_each_entry(dev, &cls->kset.list, kobj.entry)
228                                 drv->remove(dev);
229                 }
230                 kset_put(&cls->kset);
231         }
232         mutex_unlock(&sysdev_drivers_lock);
233 }
234
235 EXPORT_SYMBOL_GPL(sysdev_driver_register);
236 EXPORT_SYMBOL_GPL(sysdev_driver_unregister);
237
238
239
240 /**
241  *      sysdev_register - add a system device to the tree
242  *      @sysdev:        device in question
243  *
244  */
245 int sysdev_register(struct sys_device *sysdev)
246 {
247         int error;
248         struct sysdev_class *cls = sysdev->cls;
249
250         if (!cls)
251                 return -EINVAL;
252
253         pr_debug("Registering sys device of class '%s'\n",
254                  kobject_name(&cls->kset.kobj));
255
256         /* initialize the kobject to 0, in case it had previously been used */
257         memset(&sysdev->kobj, 0x00, sizeof(struct kobject));
258
259         /* Make sure the kset is set */
260         sysdev->kobj.kset = &cls->kset;
261
262         /* Register the object */
263         error = kobject_init_and_add(&sysdev->kobj, &ktype_sysdev, NULL,
264                                      "%s%d", kobject_name(&cls->kset.kobj),
265                                      sysdev->id);
266
267         if (!error) {
268                 struct sysdev_driver *drv;
269
270                 pr_debug("Registering sys device '%s'\n",
271                          kobject_name(&sysdev->kobj));
272
273                 mutex_lock(&sysdev_drivers_lock);
274                 /* Generic notification is implicit, because it's that
275                  * code that should have called us.
276                  */
277
278                 /* Notify class auxillary drivers */
279                 list_for_each_entry(drv, &cls->drivers, entry) {
280                         if (drv->add)
281                                 drv->add(sysdev);
282                 }
283                 mutex_unlock(&sysdev_drivers_lock);
284                 kobject_uevent(&sysdev->kobj, KOBJ_ADD);
285         }
286
287         return error;
288 }
289
290 void sysdev_unregister(struct sys_device *sysdev)
291 {
292         struct sysdev_driver *drv;
293
294         mutex_lock(&sysdev_drivers_lock);
295         list_for_each_entry(drv, &sysdev->cls->drivers, entry) {
296                 if (drv->remove)
297                         drv->remove(sysdev);
298         }
299         mutex_unlock(&sysdev_drivers_lock);
300
301         kobject_put(&sysdev->kobj);
302 }
303
304
305
306 /**
307  *      sysdev_shutdown - Shut down all system devices.
308  *
309  *      Loop over each class of system devices, and the devices in each
310  *      of those classes. For each device, we call the shutdown method for
311  *      each driver registered for the device - the auxillaries,
312  *      and the class driver.
313  *
314  *      Note: The list is iterated in reverse order, so that we shut down
315  *      child devices before we shut down their parents. The list ordering
316  *      is guaranteed by virtue of the fact that child devices are registered
317  *      after their parents.
318  */
319 void sysdev_shutdown(void)
320 {
321         struct sysdev_class *cls;
322
323         pr_debug("Shutting Down System Devices\n");
324
325         mutex_lock(&sysdev_drivers_lock);
326         list_for_each_entry_reverse(cls, &system_kset->list, kset.kobj.entry) {
327                 struct sys_device *sysdev;
328
329                 pr_debug("Shutting down type '%s':\n",
330                          kobject_name(&cls->kset.kobj));
331
332                 list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
333                         struct sysdev_driver *drv;
334                         pr_debug(" %s\n", kobject_name(&sysdev->kobj));
335
336                         /* Call auxillary drivers first */
337                         list_for_each_entry(drv, &cls->drivers, entry) {
338                                 if (drv->shutdown)
339                                         drv->shutdown(sysdev);
340                         }
341
342                         /* Now call the generic one */
343                         if (cls->shutdown)
344                                 cls->shutdown(sysdev);
345                 }
346         }
347         mutex_unlock(&sysdev_drivers_lock);
348 }
349
350 static void __sysdev_resume(struct sys_device *dev)
351 {
352         struct sysdev_class *cls = dev->cls;
353         struct sysdev_driver *drv;
354
355         /* First, call the class-specific one */
356         if (cls->resume)
357                 cls->resume(dev);
358         WARN_ONCE(!irqs_disabled(),
359                 "Interrupts enabled after %pF\n", cls->resume);
360
361         /* Call auxillary drivers next. */
362         list_for_each_entry(drv, &cls->drivers, entry) {
363                 if (drv->resume)
364                         drv->resume(dev);
365                 WARN_ONCE(!irqs_disabled(),
366                         "Interrupts enabled after %pF\n", drv->resume);
367         }
368 }
369
370 /**
371  *      sysdev_suspend - Suspend all system devices.
372  *      @state:         Power state to enter.
373  *
374  *      We perform an almost identical operation as sysdev_shutdown()
375  *      above, though calling ->suspend() instead. Interrupts are disabled
376  *      when this called. Devices are responsible for both saving state and
377  *      quiescing or powering down the device.
378  *
379  *      This is only called by the device PM core, so we let them handle
380  *      all synchronization.
381  */
382 int sysdev_suspend(pm_message_t state)
383 {
384         struct sysdev_class *cls;
385         struct sys_device *sysdev, *err_dev;
386         struct sysdev_driver *drv, *err_drv;
387         int ret;
388
389         pr_debug("Checking wake-up interrupts\n");
390
391         /* Return error code if there are any wake-up interrupts pending */
392         ret = check_wakeup_irqs();
393         if (ret)
394                 return ret;
395
396         WARN_ONCE(!irqs_disabled(),
397                 "Interrupts enabled while suspending system devices\n");
398
399         pr_debug("Suspending System Devices\n");
400
401         list_for_each_entry_reverse(cls, &system_kset->list, kset.kobj.entry) {
402                 pr_debug("Suspending type '%s':\n",
403                          kobject_name(&cls->kset.kobj));
404
405                 list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
406                         pr_debug(" %s\n", kobject_name(&sysdev->kobj));
407
408                         /* Call auxillary drivers first */
409                         list_for_each_entry(drv, &cls->drivers, entry) {
410                                 if (drv->suspend) {
411                                         ret = drv->suspend(sysdev, state);
412                                         if (ret)
413                                                 goto aux_driver;
414                                 }
415                                 WARN_ONCE(!irqs_disabled(),
416                                         "Interrupts enabled after %pF\n",
417                                         drv->suspend);
418                         }
419
420                         /* Now call the generic one */
421                         if (cls->suspend) {
422                                 ret = cls->suspend(sysdev, state);
423                                 if (ret)
424                                         goto cls_driver;
425                                 WARN_ONCE(!irqs_disabled(),
426                                         "Interrupts enabled after %pF\n",
427                                         cls->suspend);
428                         }
429                 }
430         }
431         return 0;
432         /* resume current sysdev */
433 cls_driver:
434         drv = NULL;
435         printk(KERN_ERR "Class suspend failed for %s\n",
436                 kobject_name(&sysdev->kobj));
437
438 aux_driver:
439         if (drv)
440                 printk(KERN_ERR "Class driver suspend failed for %s\n",
441                                 kobject_name(&sysdev->kobj));
442         list_for_each_entry(err_drv, &cls->drivers, entry) {
443                 if (err_drv == drv)
444                         break;
445                 if (err_drv->resume)
446                         err_drv->resume(sysdev);
447         }
448
449         /* resume other sysdevs in current class */
450         list_for_each_entry(err_dev, &cls->kset.list, kobj.entry) {
451                 if (err_dev == sysdev)
452                         break;
453                 pr_debug(" %s\n", kobject_name(&err_dev->kobj));
454                 __sysdev_resume(err_dev);
455         }
456
457         /* resume other classes */
458         list_for_each_entry_continue(cls, &system_kset->list, kset.kobj.entry) {
459                 list_for_each_entry(err_dev, &cls->kset.list, kobj.entry) {
460                         pr_debug(" %s\n", kobject_name(&err_dev->kobj));
461                         __sysdev_resume(err_dev);
462                 }
463         }
464         return ret;
465 }
466 EXPORT_SYMBOL_GPL(sysdev_suspend);
467
468 /**
469  *      sysdev_resume - Bring system devices back to life.
470  *
471  *      Similar to sysdev_suspend(), but we iterate the list forwards
472  *      to guarantee that parent devices are resumed before their children.
473  *
474  *      Note: Interrupts are disabled when called.
475  */
476 int sysdev_resume(void)
477 {
478         struct sysdev_class *cls;
479
480         WARN_ONCE(!irqs_disabled(),
481                 "Interrupts enabled while resuming system devices\n");
482
483         pr_debug("Resuming System Devices\n");
484
485         list_for_each_entry(cls, &system_kset->list, kset.kobj.entry) {
486                 struct sys_device *sysdev;
487
488                 pr_debug("Resuming type '%s':\n",
489                          kobject_name(&cls->kset.kobj));
490
491                 list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
492                         pr_debug(" %s\n", kobject_name(&sysdev->kobj));
493
494                         __sysdev_resume(sysdev);
495                 }
496         }
497         return 0;
498 }
499 EXPORT_SYMBOL_GPL(sysdev_resume);
500
501 int __init system_bus_init(void)
502 {
503         system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj);
504         if (!system_kset)
505                 return -ENOMEM;
506         return 0;
507 }
508
509 EXPORT_SYMBOL_GPL(sysdev_register);
510 EXPORT_SYMBOL_GPL(sysdev_unregister);
511
512 #define to_ext_attr(x) container_of(x, struct sysdev_ext_attribute, attr)
513
514 ssize_t sysdev_store_ulong(struct sys_device *sysdev,
515                            struct sysdev_attribute *attr,
516                            const char *buf, size_t size)
517 {
518         struct sysdev_ext_attribute *ea = to_ext_attr(attr);
519         char *end;
520         unsigned long new = simple_strtoul(buf, &end, 0);
521         if (end == buf)
522                 return -EINVAL;
523         *(unsigned long *)(ea->var) = new;
524         /* Always return full write size even if we didn't consume all */
525         return size;
526 }
527 EXPORT_SYMBOL_GPL(sysdev_store_ulong);
528
529 ssize_t sysdev_show_ulong(struct sys_device *sysdev,
530                           struct sysdev_attribute *attr,
531                           char *buf)
532 {
533         struct sysdev_ext_attribute *ea = to_ext_attr(attr);
534         return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
535 }
536 EXPORT_SYMBOL_GPL(sysdev_show_ulong);
537
538 ssize_t sysdev_store_int(struct sys_device *sysdev,
539                            struct sysdev_attribute *attr,
540                            const char *buf, size_t size)
541 {
542         struct sysdev_ext_attribute *ea = to_ext_attr(attr);
543         char *end;
544         long new = simple_strtol(buf, &end, 0);
545         if (end == buf || new > INT_MAX || new < INT_MIN)
546                 return -EINVAL;
547         *(int *)(ea->var) = new;
548         /* Always return full write size even if we didn't consume all */
549         return size;
550 }
551 EXPORT_SYMBOL_GPL(sysdev_store_int);
552
553 ssize_t sysdev_show_int(struct sys_device *sysdev,
554                           struct sysdev_attribute *attr,
555                           char *buf)
556 {
557         struct sysdev_ext_attribute *ea = to_ext_attr(attr);
558         return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
559 }
560 EXPORT_SYMBOL_GPL(sysdev_show_int);
561