blob: 76ce75bad91eb56e897012494a0bdbafde24b9a6 [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{
Ben Dooks838ea8e2008-06-12 19:00:34 +0100134 pr_debug("Registering sysdev class '%s'\n", cls->name);
135
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 INIT_LIST_HEAD(&cls->drivers);
Greg Kroah-Hartmanef79df22008-03-09 03:37:16 +0530137 memset(&cls->kset.kobj, 0x00, sizeof(struct kobject));
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600138 cls->kset.kobj.parent = &system_kset->kobj;
Greg Kroah-Hartman3514fac2007-10-16 10:11:44 -0600139 cls->kset.kobj.ktype = &ktype_sysdev_class;
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600140 cls->kset.kobj.kset = system_kset;
Kay Sieversaf5ca3f2007-12-20 02:09:39 +0100141 kobject_set_name(&cls->kset.kobj, cls->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 return kset_register(&cls->kset);
143}
144
Zhenwen Xu60530af2009-03-03 18:36:02 +0800145void sysdev_class_unregister(struct sysdev_class *cls)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146{
147 pr_debug("Unregistering sysdev class '%s'\n",
148 kobject_name(&cls->kset.kobj));
149 kset_unregister(&cls->kset);
150}
151
152EXPORT_SYMBOL_GPL(sysdev_class_register);
153EXPORT_SYMBOL_GPL(sysdev_class_unregister);
154
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700155static DEFINE_MUTEX(sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
157/**
158 * sysdev_driver_register - Register auxillary driver
Akinobu Mita44b760a2007-08-19 16:51:14 +0900159 * @cls: Device class driver belongs to.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 * @drv: Driver.
161 *
Akinobu Mita44b760a2007-08-19 16:51:14 +0900162 * @drv is inserted into @cls->drivers to be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 * called on each operation on devices of that class. The refcount
164 * of @cls is incremented.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 */
166
Akinobu Mita44b760a2007-08-19 16:51:14 +0900167int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
Akinobu Mita44b760a2007-08-19 16:51:14 +0900169 int err = 0;
170
Ben Dooksda009f32008-03-04 15:09:06 -0800171 if (!cls) {
Arjan van de Venf810a5c2008-07-25 19:45:39 -0700172 WARN(1, KERN_WARNING "sysdev: invalid class passed to "
Ben Dooksda009f32008-03-04 15:09:06 -0800173 "sysdev_driver_register!\n");
Ben Dooksda009f32008-03-04 15:09:06 -0800174 return -EINVAL;
175 }
176
177 /* Check whether this driver has already been added to a class. */
Arjan van de Venf810a5c2008-07-25 19:45:39 -0700178 if (drv->entry.next && !list_empty(&drv->entry))
179 WARN(1, KERN_WARNING "sysdev: class %s: driver (%p) has already"
Ben Dooksda009f32008-03-04 15:09:06 -0800180 " been registered to a class, something is wrong, but "
181 "will forge on!\n", cls->name, drv);
Ben Dooksda009f32008-03-04 15:09:06 -0800182
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700183 mutex_lock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 if (cls && kset_get(&cls->kset)) {
185 list_add_tail(&drv->entry, &cls->drivers);
186
187 /* If devices of this class already exist, tell the driver */
188 if (drv->add) {
189 struct sys_device *dev;
190 list_for_each_entry(dev, &cls->kset.list, kobj.entry)
191 drv->add(dev);
192 }
Akinobu Mita44b760a2007-08-19 16:51:14 +0900193 } else {
194 err = -EINVAL;
Arjan van de Venf810a5c2008-07-25 19:45:39 -0700195 WARN(1, KERN_ERR "%s: invalid device class\n", __func__);
Akinobu Mita44b760a2007-08-19 16:51:14 +0900196 }
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700197 mutex_unlock(&sysdev_drivers_lock);
Akinobu Mita44b760a2007-08-19 16:51:14 +0900198 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199}
200
201
202/**
203 * sysdev_driver_unregister - Remove an auxillary driver.
204 * @cls: Class driver belongs to.
205 * @drv: Driver.
206 */
Zhenwen Xu60530af2009-03-03 18:36:02 +0800207void sysdev_driver_unregister(struct sysdev_class *cls,
208 struct sysdev_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209{
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700210 mutex_lock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 list_del_init(&drv->entry);
212 if (cls) {
213 if (drv->remove) {
214 struct sys_device *dev;
215 list_for_each_entry(dev, &cls->kset.list, kobj.entry)
216 drv->remove(dev);
217 }
218 kset_put(&cls->kset);
219 }
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700220 mutex_unlock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221}
222
223EXPORT_SYMBOL_GPL(sysdev_driver_register);
224EXPORT_SYMBOL_GPL(sysdev_driver_unregister);
225
226
227
228/**
229 * sysdev_register - add a system device to the tree
230 * @sysdev: device in question
231 *
232 */
Zhenwen Xu60530af2009-03-03 18:36:02 +0800233int sysdev_register(struct sys_device *sysdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234{
235 int error;
Zhenwen Xu60530af2009-03-03 18:36:02 +0800236 struct sysdev_class *cls = sysdev->cls;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
238 if (!cls)
239 return -EINVAL;
240
Ben Dooks838ea8e2008-06-12 19:00:34 +0100241 pr_debug("Registering sys device of class '%s'\n",
242 kobject_name(&cls->kset.kobj));
Greg Kroah-Hartman61030bf2007-12-17 15:54:39 -0400243
Greg Kroah-Hartmanef79df22008-03-09 03:37:16 +0530244 /* initialize the kobject to 0, in case it had previously been used */
245 memset(&sysdev->kobj, 0x00, sizeof(struct kobject));
246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 /* Make sure the kset is set */
248 sysdev->kobj.kset = &cls->kset;
249
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 /* Register the object */
Greg Kroah-Hartman61030bf2007-12-17 15:54:39 -0400251 error = kobject_init_and_add(&sysdev->kobj, &ktype_sysdev, NULL,
252 "%s%d", kobject_name(&cls->kset.kobj),
253 sysdev->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
255 if (!error) {
Zhenwen Xu60530af2009-03-03 18:36:02 +0800256 struct sysdev_driver *drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
Ben Dooks838ea8e2008-06-12 19:00:34 +0100258 pr_debug("Registering sys device '%s'\n",
259 kobject_name(&sysdev->kobj));
260
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700261 mutex_lock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 /* Generic notification is implicit, because it's that
263 * code that should have called us.
264 */
265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 /* Notify class auxillary drivers */
267 list_for_each_entry(drv, &cls->drivers, entry) {
268 if (drv->add)
269 drv->add(sysdev);
270 }
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700271 mutex_unlock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 }
Ben Dooks838ea8e2008-06-12 19:00:34 +0100273
Greg Kroah-Hartman61030bf2007-12-17 15:54:39 -0400274 kobject_uevent(&sysdev->kobj, KOBJ_ADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 return error;
276}
277
Zhenwen Xu60530af2009-03-03 18:36:02 +0800278void sysdev_unregister(struct sys_device *sysdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
Zhenwen Xu60530af2009-03-03 18:36:02 +0800280 struct sysdev_driver *drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700282 mutex_lock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 list_for_each_entry(drv, &sysdev->cls->drivers, entry) {
284 if (drv->remove)
285 drv->remove(sysdev);
286 }
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700287 mutex_unlock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Greg Kroah-Hartmanc10997f2007-12-20 08:13:05 -0800289 kobject_put(&sysdev->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290}
291
292
293
294/**
295 * sysdev_shutdown - Shut down all system devices.
296 *
297 * Loop over each class of system devices, and the devices in each
298 * of those classes. For each device, we call the shutdown method for
Akinobu Mita44b760a2007-08-19 16:51:14 +0900299 * each driver registered for the device - the auxillaries,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 * and the class driver.
301 *
302 * Note: The list is iterated in reverse order, so that we shut down
303 * child devices before we shut down thier parents. The list ordering
304 * is guaranteed by virtue of the fact that child devices are registered
305 * after their parents.
306 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307void sysdev_shutdown(void)
308{
Zhenwen Xu60530af2009-03-03 18:36:02 +0800309 struct sysdev_class *cls;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
311 pr_debug("Shutting Down System Devices\n");
312
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700313 mutex_lock(&sysdev_drivers_lock);
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600314 list_for_each_entry_reverse(cls, &system_kset->list, kset.kobj.entry) {
Zhenwen Xu60530af2009-03-03 18:36:02 +0800315 struct sys_device *sysdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
317 pr_debug("Shutting down type '%s':\n",
318 kobject_name(&cls->kset.kobj));
319
320 list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
Zhenwen Xu60530af2009-03-03 18:36:02 +0800321 struct sysdev_driver *drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 pr_debug(" %s\n", kobject_name(&sysdev->kobj));
323
Akinobu Mita44b760a2007-08-19 16:51:14 +0900324 /* Call auxillary drivers first */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 list_for_each_entry(drv, &cls->drivers, entry) {
326 if (drv->shutdown)
327 drv->shutdown(sysdev);
328 }
329
330 /* Now call the generic one */
331 if (cls->shutdown)
332 cls->shutdown(sysdev);
333 }
334 }
Matthias Kaehlcke9f3f7762007-05-23 14:19:42 -0700335 mutex_unlock(&sysdev_drivers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336}
337
Shaohua Liceaeade2005-08-11 10:37:39 +0800338static void __sysdev_resume(struct sys_device *dev)
339{
340 struct sysdev_class *cls = dev->cls;
341 struct sysdev_driver *drv;
342
343 /* First, call the class-specific one */
344 if (cls->resume)
345 cls->resume(dev);
346
347 /* Call auxillary drivers next. */
348 list_for_each_entry(drv, &cls->drivers, entry) {
349 if (drv->resume)
350 drv->resume(dev);
351 }
Shaohua Liceaeade2005-08-11 10:37:39 +0800352}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
354/**
355 * sysdev_suspend - Suspend all system devices.
356 * @state: Power state to enter.
357 *
Qinghuang Feng65151362008-10-13 18:05:04 +0800358 * We perform an almost identical operation as sysdev_shutdown()
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 * above, though calling ->suspend() instead. Interrupts are disabled
360 * when this called. Devices are responsible for both saving state and
361 * quiescing or powering down the device.
362 *
363 * This is only called by the device PM core, so we let them handle
364 * all synchronization.
365 */
Pavel Machek438510f2005-04-16 15:25:24 -0700366int sysdev_suspend(pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367{
Zhenwen Xu60530af2009-03-03 18:36:02 +0800368 struct sysdev_class *cls;
Shaohua Liceaeade2005-08-11 10:37:39 +0800369 struct sys_device *sysdev, *err_dev;
370 struct sysdev_driver *drv, *err_drv;
371 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
Rafael J. Wysocki2ed8d2b2009-03-16 22:34:06 +0100373 pr_debug("Checking wake-up interrupts\n");
374
375 /* Return error code if there are any wake-up interrupts pending */
376 ret = check_wakeup_irqs();
377 if (ret)
378 return ret;
379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 pr_debug("Suspending System Devices\n");
381
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600382 list_for_each_entry_reverse(cls, &system_kset->list, kset.kobj.entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 pr_debug("Suspending type '%s':\n",
384 kobject_name(&cls->kset.kobj));
385
386 list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 pr_debug(" %s\n", kobject_name(&sysdev->kobj));
388
Akinobu Mita44b760a2007-08-19 16:51:14 +0900389 /* Call auxillary drivers first */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 list_for_each_entry(drv, &cls->drivers, entry) {
Shaohua Liceaeade2005-08-11 10:37:39 +0800391 if (drv->suspend) {
392 ret = drv->suspend(sysdev, state);
393 if (ret)
394 goto aux_driver;
395 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 }
397
398 /* Now call the generic one */
Shaohua Liceaeade2005-08-11 10:37:39 +0800399 if (cls->suspend) {
400 ret = cls->suspend(sysdev, state);
401 if (ret)
402 goto cls_driver;
403 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 }
405 }
406 return 0;
Shaohua Liceaeade2005-08-11 10:37:39 +0800407 /* resume current sysdev */
408cls_driver:
409 drv = NULL;
410 printk(KERN_ERR "Class suspend failed for %s\n",
411 kobject_name(&sysdev->kobj));
412
413aux_driver:
414 if (drv)
415 printk(KERN_ERR "Class driver suspend failed for %s\n",
416 kobject_name(&sysdev->kobj));
417 list_for_each_entry(err_drv, &cls->drivers, entry) {
418 if (err_drv == drv)
419 break;
420 if (err_drv->resume)
421 err_drv->resume(sysdev);
422 }
Shaohua Liceaeade2005-08-11 10:37:39 +0800423
Shaohua Liceaeade2005-08-11 10:37:39 +0800424 /* resume other sysdevs in current class */
425 list_for_each_entry(err_dev, &cls->kset.list, kobj.entry) {
426 if (err_dev == sysdev)
427 break;
428 pr_debug(" %s\n", kobject_name(&err_dev->kobj));
429 __sysdev_resume(err_dev);
430 }
431
432 /* resume other classes */
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600433 list_for_each_entry_continue(cls, &system_kset->list, kset.kobj.entry) {
Shaohua Liceaeade2005-08-11 10:37:39 +0800434 list_for_each_entry(err_dev, &cls->kset.list, kobj.entry) {
435 pr_debug(" %s\n", kobject_name(&err_dev->kobj));
436 __sysdev_resume(err_dev);
437 }
438 }
439 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440}
Ingo Molnar0f99fed2009-02-22 22:07:03 +0100441EXPORT_SYMBOL_GPL(sysdev_suspend);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
443/**
444 * sysdev_resume - Bring system devices back to life.
445 *
Qinghuang Feng65151362008-10-13 18:05:04 +0800446 * Similar to sysdev_suspend(), but we iterate the list forwards
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 * to guarantee that parent devices are resumed before their children.
448 *
449 * Note: Interrupts are disabled when called.
450 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451int sysdev_resume(void)
452{
Zhenwen Xu60530af2009-03-03 18:36:02 +0800453 struct sysdev_class *cls;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
455 pr_debug("Resuming System Devices\n");
456
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600457 list_for_each_entry(cls, &system_kset->list, kset.kobj.entry) {
Zhenwen Xu60530af2009-03-03 18:36:02 +0800458 struct sys_device *sysdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
460 pr_debug("Resuming type '%s':\n",
461 kobject_name(&cls->kset.kobj));
462
463 list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 pr_debug(" %s\n", kobject_name(&sysdev->kobj));
465
Shaohua Liceaeade2005-08-11 10:37:39 +0800466 __sysdev_resume(sysdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 }
468 }
469 return 0;
470}
Ingo Molnar0f99fed2009-02-22 22:07:03 +0100471EXPORT_SYMBOL_GPL(sysdev_resume);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
473int __init system_bus_init(void)
474{
Greg Kroah-Hartmanaade4042007-11-01 09:29:06 -0600475 system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj);
476 if (!system_kset)
477 return -ENOMEM;
478 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479}
480
481EXPORT_SYMBOL_GPL(sysdev_register);
482EXPORT_SYMBOL_GPL(sysdev_unregister);
Andi Kleen98007942008-07-01 18:48:42 +0200483
484#define to_ext_attr(x) container_of(x, struct sysdev_ext_attribute, attr)
485
486ssize_t sysdev_store_ulong(struct sys_device *sysdev,
487 struct sysdev_attribute *attr,
488 const char *buf, size_t size)
489{
490 struct sysdev_ext_attribute *ea = to_ext_attr(attr);
491 char *end;
492 unsigned long new = simple_strtoul(buf, &end, 0);
493 if (end == buf)
494 return -EINVAL;
495 *(unsigned long *)(ea->var) = new;
Andi Kleen4e318d72008-10-13 12:03:03 +0200496 /* Always return full write size even if we didn't consume all */
497 return size;
Andi Kleen98007942008-07-01 18:48:42 +0200498}
499EXPORT_SYMBOL_GPL(sysdev_store_ulong);
500
501ssize_t sysdev_show_ulong(struct sys_device *sysdev,
502 struct sysdev_attribute *attr,
503 char *buf)
504{
505 struct sysdev_ext_attribute *ea = to_ext_attr(attr);
506 return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
507}
508EXPORT_SYMBOL_GPL(sysdev_show_ulong);
509
510ssize_t sysdev_store_int(struct sys_device *sysdev,
511 struct sysdev_attribute *attr,
512 const char *buf, size_t size)
513{
514 struct sysdev_ext_attribute *ea = to_ext_attr(attr);
515 char *end;
516 long new = simple_strtol(buf, &end, 0);
517 if (end == buf || new > INT_MAX || new < INT_MIN)
518 return -EINVAL;
519 *(int *)(ea->var) = new;
Andi Kleen4e318d72008-10-13 12:03:03 +0200520 /* Always return full write size even if we didn't consume all */
521 return size;
Andi Kleen98007942008-07-01 18:48:42 +0200522}
523EXPORT_SYMBOL_GPL(sysdev_store_int);
524
525ssize_t sysdev_show_int(struct sys_device *sysdev,
526 struct sysdev_attribute *attr,
527 char *buf)
528{
529 struct sysdev_ext_attribute *ea = to_ext_attr(attr);
530 return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
531}
532EXPORT_SYMBOL_GPL(sysdev_show_int);
533