blob: 79a9ae5238acc1b9fa06a2fed1ed70d2440a9416 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#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/slab.h>
21#include <linux/string.h>
Pavel Machek438510f2005-04-16 15:25:24 -070022#include <linux/pm.h>
Adrian Bunkf67d1152006-01-19 17:30:17 +010023#include <linux/device.h>
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -070024#include <linux/mutex.h>
Rafael J. Wysocki2ed8d2b2009-03-16 22:34:06 +010025#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
Adrian Bunkf67d1152006-01-19 17:30:17 +010027#include "base.h"
28
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#define to_sysdev(k) container_of(k, struct sys_device, kobj)
30#define to_sysdev_attr(a) container_of(a, struct sysdev_attribute, attr)
31
32
33static ssize_t
Zhenwen Xu60530af2009-03-03 18:36:02 +080034sysdev_show(struct kobject *kobj, struct attribute *attr, char *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -070035{
Zhenwen Xu60530af2009-03-03 18:36:02 +080036 struct sys_device *sysdev = to_sysdev(kobj);
37 struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39 if (sysdev_attr->show)
Andi Kleen4a0b2b42008-07-01 18:48:41 +020040 return sysdev_attr->show(sysdev, sysdev_attr, buffer);
Dmitry Torokhov4a0c20b2005-04-29 01:23:47 -050041 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042}
43
44
45static ssize_t
Zhenwen Xu60530af2009-03-03 18:36:02 +080046sysdev_store(struct kobject *kobj, struct attribute *attr,
47 const char *buffer, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -070048{
Zhenwen Xu60530af2009-03-03 18:36:02 +080049 struct sys_device *sysdev = to_sysdev(kobj);
50 struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
52 if (sysdev_attr->store)
Andi Kleen4a0b2b42008-07-01 18:48:41 +020053 return sysdev_attr->store(sysdev, sysdev_attr, buffer, count);
Dmitry Torokhov4a0c20b2005-04-29 01:23:47 -050054 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -070055}
56
57static struct sysfs_ops sysfs_ops = {
58 .show = sysdev_show,
59 .store = sysdev_store,
60};
61
62static struct kobj_type ktype_sysdev = {
63 .sysfs_ops = &sysfs_ops,
64};
65
66
Zhenwen Xu60530af2009-03-03 18:36:02 +080067int sysdev_create_file(struct sys_device *s, struct sysdev_attribute *a)
Linus Torvalds1da177e2005-04-16 15:20:36 -070068{
69 return sysfs_create_file(&s->kobj, &a->attr);
70}
71
72
Zhenwen Xu60530af2009-03-03 18:36:02 +080073void sysdev_remove_file(struct sys_device *s, struct sysdev_attribute *a)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074{
75 sysfs_remove_file(&s->kobj, &a->attr);
76}
77
78EXPORT_SYMBOL_GPL(sysdev_create_file);
79EXPORT_SYMBOL_GPL(sysdev_remove_file);
80
Shaohua Li670dd902006-05-08 13:45:57 +080081#define to_sysdev_class(k) container_of(k, struct sysdev_class, kset.kobj)
82#define to_sysdev_class_attr(a) container_of(a, \
83 struct sysdev_class_attribute, attr)
84
85static ssize_t sysdev_class_show(struct kobject *kobj, struct attribute *attr,
86 char *buffer)
87{
Zhenwen Xu60530af2009-03-03 18:36:02 +080088 struct sysdev_class *class = to_sysdev_class(kobj);
Shaohua Li670dd902006-05-08 13:45:57 +080089 struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
90
91 if (class_attr->show)
92 return class_attr->show(class, buffer);
93 return -EIO;
94}
95
96static ssize_t sysdev_class_store(struct kobject *kobj, struct attribute *attr,
97 const char *buffer, size_t count)
98{
Zhenwen Xu60530af2009-03-03 18:36:02 +080099 struct sysdev_class *class = to_sysdev_class(kobj);
100 struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
Shaohua Li670dd902006-05-08 13:45:57 +0800101
102 if (class_attr->store)
103 return class_attr->store(class, buffer, count);
104 return -EIO;
105}
106
107static struct sysfs_ops sysfs_class_ops = {
108 .show = sysdev_class_show,
109 .store = sysdev_class_store,
110};
111
112static struct kobj_type ktype_sysdev_class = {
113 .sysfs_ops = &sysfs_class_ops,
114};
115
116int sysdev_class_create_file(struct sysdev_class *c,
117 struct sysdev_class_attribute *a)
118{
119 return sysfs_create_file(&c->kset.kobj, &a->attr);
120}
121EXPORT_SYMBOL_GPL(sysdev_class_create_file);
122
123void sysdev_class_remove_file(struct sysdev_class *c,
124 struct sysdev_class_attribute *a)
125{
126 sysfs_remove_file(&c->kset.kobj, &a->attr);
127}
128EXPORT_SYMBOL_GPL(sysdev_class_remove_file);
129
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600130static struct kset *system_kset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
Zhenwen Xu60530af2009-03-03 18:36:02 +0800132int sysdev_class_register(struct sysdev_class *cls)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133{
Dave Young9227c472009-05-11 14:18:55 +0800134 int retval;
135
Ben Dooks838ea8e2008-06-12 19:00:34 +0100136 pr_debug("Registering sysdev class '%s'\n", cls->name);
137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 INIT_LIST_HEAD(&cls->drivers);
Greg Kroah-Hartmanef79df22008-03-09 03:37:16 +0530139 memset(&cls->kset.kobj, 0x00, sizeof(struct kobject));
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600140 cls->kset.kobj.parent = &system_kset->kobj;
Greg Kroah-Hartman3514fac2007-10-16 10:11:44 -0600141 cls->kset.kobj.ktype = &ktype_sysdev_class;
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600142 cls->kset.kobj.kset = system_kset;
Dave Young9227c472009-05-11 14:18:55 +0800143
Greg Kroah-Hartmanacc0e902009-06-02 15:39:55 -0700144 retval = kobject_set_name(&cls->kset.kobj, "%s", cls->name);
Dave Young9227c472009-05-11 14:18:55 +0800145 if (retval)
146 return retval;
147
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 return kset_register(&cls->kset);
149}
150
Zhenwen Xu60530af2009-03-03 18:36:02 +0800151void sysdev_class_unregister(struct sysdev_class *cls)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152{
153 pr_debug("Unregistering sysdev class '%s'\n",
154 kobject_name(&cls->kset.kobj));
155 kset_unregister(&cls->kset);
156}
157
158EXPORT_SYMBOL_GPL(sysdev_class_register);
159EXPORT_SYMBOL_GPL(sysdev_class_unregister);
160
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700161static DEFINE_MUTEX(sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
163/**
164 * sysdev_driver_register - Register auxillary driver
Akinobu Mita44b760a2007-08-19 16:51:14 +0900165 * @cls: Device class driver belongs to.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 * @drv: Driver.
167 *
Akinobu Mita44b760a2007-08-19 16:51:14 +0900168 * @drv is inserted into @cls->drivers to be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 * called on each operation on devices of that class. The refcount
170 * of @cls is incremented.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 */
172
Akinobu Mita44b760a2007-08-19 16:51:14 +0900173int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174{
Akinobu Mita44b760a2007-08-19 16:51:14 +0900175 int err = 0;
176
Ben Dooksda009f32008-03-04 15:09:06 -0800177 if (!cls) {
Arjan van de Venf810a5c2008-07-25 19:45:39 -0700178 WARN(1, KERN_WARNING "sysdev: invalid class passed to "
Ben Dooksda009f32008-03-04 15:09:06 -0800179 "sysdev_driver_register!\n");
Ben Dooksda009f32008-03-04 15:09:06 -0800180 return -EINVAL;
181 }
182
183 /* Check whether this driver has already been added to a class. */
Arjan van de Venf810a5c2008-07-25 19:45:39 -0700184 if (drv->entry.next && !list_empty(&drv->entry))
185 WARN(1, KERN_WARNING "sysdev: class %s: driver (%p) has already"
Ben Dooksda009f32008-03-04 15:09:06 -0800186 " been registered to a class, something is wrong, but "
187 "will forge on!\n", cls->name, drv);
Ben Dooksda009f32008-03-04 15:09:06 -0800188
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700189 mutex_lock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 if (cls && kset_get(&cls->kset)) {
191 list_add_tail(&drv->entry, &cls->drivers);
192
193 /* If devices of this class already exist, tell the driver */
194 if (drv->add) {
195 struct sys_device *dev;
196 list_for_each_entry(dev, &cls->kset.list, kobj.entry)
197 drv->add(dev);
198 }
Akinobu Mita44b760a2007-08-19 16:51:14 +0900199 } else {
200 err = -EINVAL;
Arjan van de Venf810a5c2008-07-25 19:45:39 -0700201 WARN(1, KERN_ERR "%s: invalid device class\n", __func__);
Akinobu Mita44b760a2007-08-19 16:51:14 +0900202 }
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700203 mutex_unlock(&sysdev_drivers_lock);
Akinobu Mita44b760a2007-08-19 16:51:14 +0900204 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205}
206
207
208/**
209 * sysdev_driver_unregister - Remove an auxillary driver.
210 * @cls: Class driver belongs to.
211 * @drv: Driver.
212 */
Zhenwen Xu60530af2009-03-03 18:36:02 +0800213void sysdev_driver_unregister(struct sysdev_class *cls,
214 struct sysdev_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215{
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700216 mutex_lock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 list_del_init(&drv->entry);
218 if (cls) {
219 if (drv->remove) {
220 struct sys_device *dev;
221 list_for_each_entry(dev, &cls->kset.list, kobj.entry)
222 drv->remove(dev);
223 }
224 kset_put(&cls->kset);
225 }
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700226 mutex_unlock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227}
228
229EXPORT_SYMBOL_GPL(sysdev_driver_register);
230EXPORT_SYMBOL_GPL(sysdev_driver_unregister);
231
232
233
234/**
235 * sysdev_register - add a system device to the tree
236 * @sysdev: device in question
237 *
238 */
Zhenwen Xu60530af2009-03-03 18:36:02 +0800239int sysdev_register(struct sys_device *sysdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
241 int error;
Zhenwen Xu60530af2009-03-03 18:36:02 +0800242 struct sysdev_class *cls = sysdev->cls;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244 if (!cls)
245 return -EINVAL;
246
Ben Dooks838ea8e2008-06-12 19:00:34 +0100247 pr_debug("Registering sys device of class '%s'\n",
248 kobject_name(&cls->kset.kobj));
Greg Kroah-Hartman61030bf2007-12-17 15:54:39 -0400249
Greg Kroah-Hartmanef79df22008-03-09 03:37:16 +0530250 /* initialize the kobject to 0, in case it had previously been used */
251 memset(&sysdev->kobj, 0x00, sizeof(struct kobject));
252
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 /* Make sure the kset is set */
254 sysdev->kobj.kset = &cls->kset;
255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 /* Register the object */
Greg Kroah-Hartman61030bf2007-12-17 15:54:39 -0400257 error = kobject_init_and_add(&sysdev->kobj, &ktype_sysdev, NULL,
258 "%s%d", kobject_name(&cls->kset.kobj),
259 sysdev->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
261 if (!error) {
Zhenwen Xu60530af2009-03-03 18:36:02 +0800262 struct sysdev_driver *drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
Ben Dooks838ea8e2008-06-12 19:00:34 +0100264 pr_debug("Registering sys device '%s'\n",
265 kobject_name(&sysdev->kobj));
266
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700267 mutex_lock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 /* Generic notification is implicit, because it's that
269 * code that should have called us.
270 */
271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 /* Notify class auxillary drivers */
273 list_for_each_entry(drv, &cls->drivers, entry) {
274 if (drv->add)
275 drv->add(sysdev);
276 }
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700277 mutex_unlock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 }
Ben Dooks838ea8e2008-06-12 19:00:34 +0100279
Greg Kroah-Hartman61030bf2007-12-17 15:54:39 -0400280 kobject_uevent(&sysdev->kobj, KOBJ_ADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 return error;
282}
283
Zhenwen Xu60530af2009-03-03 18:36:02 +0800284void sysdev_unregister(struct sys_device *sysdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285{
Zhenwen Xu60530af2009-03-03 18:36:02 +0800286 struct sysdev_driver *drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700288 mutex_lock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 list_for_each_entry(drv, &sysdev->cls->drivers, entry) {
290 if (drv->remove)
291 drv->remove(sysdev);
292 }
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700293 mutex_unlock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
Greg Kroah-Hartmanc10997f2007-12-20 08:13:05 -0800295 kobject_put(&sysdev->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296}
297
298
299
300/**
301 * sysdev_shutdown - Shut down all system devices.
302 *
303 * Loop over each class of system devices, and the devices in each
304 * of those classes. For each device, we call the shutdown method for
Akinobu Mita44b760a2007-08-19 16:51:14 +0900305 * each driver registered for the device - the auxillaries,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 * and the class driver.
307 *
308 * Note: The list is iterated in reverse order, so that we shut down
Uwe Kleine-Koenigee6921f2009-01-12 23:35:46 +0100309 * child devices before we shut down their parents. The list ordering
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 * is guaranteed by virtue of the fact that child devices are registered
311 * after their parents.
312 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313void sysdev_shutdown(void)
314{
Zhenwen Xu60530af2009-03-03 18:36:02 +0800315 struct sysdev_class *cls;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
317 pr_debug("Shutting Down System Devices\n");
318
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700319 mutex_lock(&sysdev_drivers_lock);
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600320 list_for_each_entry_reverse(cls, &system_kset->list, kset.kobj.entry) {
Zhenwen Xu60530af2009-03-03 18:36:02 +0800321 struct sys_device *sysdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
323 pr_debug("Shutting down type '%s':\n",
324 kobject_name(&cls->kset.kobj));
325
326 list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
Zhenwen Xu60530af2009-03-03 18:36:02 +0800327 struct sysdev_driver *drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 pr_debug(" %s\n", kobject_name(&sysdev->kobj));
329
Akinobu Mita44b760a2007-08-19 16:51:14 +0900330 /* Call auxillary drivers first */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 list_for_each_entry(drv, &cls->drivers, entry) {
332 if (drv->shutdown)
333 drv->shutdown(sysdev);
334 }
335
336 /* Now call the generic one */
337 if (cls->shutdown)
338 cls->shutdown(sysdev);
339 }
340 }
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700341 mutex_unlock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342}
343
Shaohua Liceaeade2005-08-11 10:37:39 +0800344static void __sysdev_resume(struct sys_device *dev)
345{
346 struct sysdev_class *cls = dev->cls;
347 struct sysdev_driver *drv;
348
349 /* First, call the class-specific one */
350 if (cls->resume)
351 cls->resume(dev);
Rafael J. Wysocki62b01242009-04-18 13:45:13 +0200352 WARN_ONCE(!irqs_disabled(),
353 "Interrupts enabled after %pF\n", cls->resume);
Shaohua Liceaeade2005-08-11 10:37:39 +0800354
355 /* Call auxillary drivers next. */
356 list_for_each_entry(drv, &cls->drivers, entry) {
357 if (drv->resume)
358 drv->resume(dev);
Rafael J. Wysocki62b01242009-04-18 13:45:13 +0200359 WARN_ONCE(!irqs_disabled(),
360 "Interrupts enabled after %pF\n", drv->resume);
Shaohua Liceaeade2005-08-11 10:37:39 +0800361 }
Shaohua Liceaeade2005-08-11 10:37:39 +0800362}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
364/**
365 * sysdev_suspend - Suspend all system devices.
366 * @state: Power state to enter.
367 *
Qinghuang Feng65151362008-10-13 18:05:04 +0800368 * We perform an almost identical operation as sysdev_shutdown()
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 * above, though calling ->suspend() instead. Interrupts are disabled
370 * when this called. Devices are responsible for both saving state and
371 * quiescing or powering down the device.
372 *
373 * This is only called by the device PM core, so we let them handle
374 * all synchronization.
375 */
Pavel Machek438510f2005-04-16 15:25:24 -0700376int sysdev_suspend(pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377{
Zhenwen Xu60530af2009-03-03 18:36:02 +0800378 struct sysdev_class *cls;
Shaohua Liceaeade2005-08-11 10:37:39 +0800379 struct sys_device *sysdev, *err_dev;
380 struct sysdev_driver *drv, *err_drv;
381 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
Rafael J. Wysocki2ed8d2b2009-03-16 22:34:06 +0100383 pr_debug("Checking wake-up interrupts\n");
384
385 /* Return error code if there are any wake-up interrupts pending */
386 ret = check_wakeup_irqs();
387 if (ret)
388 return ret;
389
Rafael J. Wysocki62b01242009-04-18 13:45:13 +0200390 WARN_ONCE(!irqs_disabled(),
391 "Interrupts enabled while suspending system devices\n");
392
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 pr_debug("Suspending System Devices\n");
394
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600395 list_for_each_entry_reverse(cls, &system_kset->list, kset.kobj.entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 pr_debug("Suspending type '%s':\n",
397 kobject_name(&cls->kset.kobj));
398
399 list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 pr_debug(" %s\n", kobject_name(&sysdev->kobj));
401
Akinobu Mita44b760a2007-08-19 16:51:14 +0900402 /* Call auxillary drivers first */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 list_for_each_entry(drv, &cls->drivers, entry) {
Shaohua Liceaeade2005-08-11 10:37:39 +0800404 if (drv->suspend) {
405 ret = drv->suspend(sysdev, state);
406 if (ret)
407 goto aux_driver;
408 }
Rafael J. Wysocki62b01242009-04-18 13:45:13 +0200409 WARN_ONCE(!irqs_disabled(),
410 "Interrupts enabled after %pF\n",
411 drv->suspend);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 }
413
414 /* Now call the generic one */
Shaohua Liceaeade2005-08-11 10:37:39 +0800415 if (cls->suspend) {
416 ret = cls->suspend(sysdev, state);
417 if (ret)
418 goto cls_driver;
Rafael J. Wysocki62b01242009-04-18 13:45:13 +0200419 WARN_ONCE(!irqs_disabled(),
420 "Interrupts enabled after %pF\n",
421 cls->suspend);
Shaohua Liceaeade2005-08-11 10:37:39 +0800422 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 }
424 }
425 return 0;
Shaohua Liceaeade2005-08-11 10:37:39 +0800426 /* resume current sysdev */
427cls_driver:
428 drv = NULL;
429 printk(KERN_ERR "Class suspend failed for %s\n",
430 kobject_name(&sysdev->kobj));
431
432aux_driver:
433 if (drv)
434 printk(KERN_ERR "Class driver suspend failed for %s\n",
435 kobject_name(&sysdev->kobj));
436 list_for_each_entry(err_drv, &cls->drivers, entry) {
437 if (err_drv == drv)
438 break;
439 if (err_drv->resume)
440 err_drv->resume(sysdev);
441 }
Shaohua Liceaeade2005-08-11 10:37:39 +0800442
Shaohua Liceaeade2005-08-11 10:37:39 +0800443 /* resume other sysdevs in current class */
444 list_for_each_entry(err_dev, &cls->kset.list, kobj.entry) {
445 if (err_dev == sysdev)
446 break;
447 pr_debug(" %s\n", kobject_name(&err_dev->kobj));
448 __sysdev_resume(err_dev);
449 }
450
451 /* resume other classes */
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600452 list_for_each_entry_continue(cls, &system_kset->list, kset.kobj.entry) {
Shaohua Liceaeade2005-08-11 10:37:39 +0800453 list_for_each_entry(err_dev, &cls->kset.list, kobj.entry) {
454 pr_debug(" %s\n", kobject_name(&err_dev->kobj));
455 __sysdev_resume(err_dev);
456 }
457 }
458 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459}
Ingo Molnar0f99fed2009-02-22 22:07:03 +0100460EXPORT_SYMBOL_GPL(sysdev_suspend);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
462/**
463 * sysdev_resume - Bring system devices back to life.
464 *
Qinghuang Feng65151362008-10-13 18:05:04 +0800465 * Similar to sysdev_suspend(), but we iterate the list forwards
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 * to guarantee that parent devices are resumed before their children.
467 *
468 * Note: Interrupts are disabled when called.
469 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470int sysdev_resume(void)
471{
Zhenwen Xu60530af2009-03-03 18:36:02 +0800472 struct sysdev_class *cls;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
Rafael J. Wysocki62b01242009-04-18 13:45:13 +0200474 WARN_ONCE(!irqs_disabled(),
475 "Interrupts enabled while resuming system devices\n");
476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 pr_debug("Resuming System Devices\n");
478
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600479 list_for_each_entry(cls, &system_kset->list, kset.kobj.entry) {
Zhenwen Xu60530af2009-03-03 18:36:02 +0800480 struct sys_device *sysdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
482 pr_debug("Resuming type '%s':\n",
483 kobject_name(&cls->kset.kobj));
484
485 list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 pr_debug(" %s\n", kobject_name(&sysdev->kobj));
487
Shaohua Liceaeade2005-08-11 10:37:39 +0800488 __sysdev_resume(sysdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 }
490 }
491 return 0;
492}
Ingo Molnar0f99fed2009-02-22 22:07:03 +0100493EXPORT_SYMBOL_GPL(sysdev_resume);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
495int __init system_bus_init(void)
496{
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600497 system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj);
498 if (!system_kset)
499 return -ENOMEM;
500 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501}
502
503EXPORT_SYMBOL_GPL(sysdev_register);
504EXPORT_SYMBOL_GPL(sysdev_unregister);
Andi Kleen98007942008-07-01 18:48:42 +0200505
506#define to_ext_attr(x) container_of(x, struct sysdev_ext_attribute, attr)
507
508ssize_t sysdev_store_ulong(struct sys_device *sysdev,
509 struct sysdev_attribute *attr,
510 const char *buf, size_t size)
511{
512 struct sysdev_ext_attribute *ea = to_ext_attr(attr);
513 char *end;
514 unsigned long new = simple_strtoul(buf, &end, 0);
515 if (end == buf)
516 return -EINVAL;
517 *(unsigned long *)(ea->var) = new;
Andi Kleen4e318d72008-10-13 12:03:03 +0200518 /* Always return full write size even if we didn't consume all */
519 return size;
Andi Kleen98007942008-07-01 18:48:42 +0200520}
521EXPORT_SYMBOL_GPL(sysdev_store_ulong);
522
523ssize_t sysdev_show_ulong(struct sys_device *sysdev,
524 struct sysdev_attribute *attr,
525 char *buf)
526{
527 struct sysdev_ext_attribute *ea = to_ext_attr(attr);
528 return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
529}
530EXPORT_SYMBOL_GPL(sysdev_show_ulong);
531
532ssize_t sysdev_store_int(struct sys_device *sysdev,
533 struct sysdev_attribute *attr,
534 const char *buf, size_t size)
535{
536 struct sysdev_ext_attribute *ea = to_ext_attr(attr);
537 char *end;
538 long new = simple_strtol(buf, &end, 0);
539 if (end == buf || new > INT_MAX || new < INT_MIN)
540 return -EINVAL;
541 *(int *)(ea->var) = new;
Andi Kleen4e318d72008-10-13 12:03:03 +0200542 /* Always return full write size even if we didn't consume all */
543 return size;
Andi Kleen98007942008-07-01 18:48:42 +0200544}
545EXPORT_SYMBOL_GPL(sysdev_store_int);
546
547ssize_t sysdev_show_int(struct sys_device *sysdev,
548 struct sysdev_attribute *attr,
549 char *buf)
550{
551 struct sysdev_ext_attribute *ea = to_ext_attr(attr);
552 return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
553}
554EXPORT_SYMBOL_GPL(sysdev_show_int);
555