]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - drivers/base/sys.c
driver core: sysdev: do not send KOBJ_ADD uevent if kobject_init_and_add fails
[mirror_ubuntu-jammy-kernel.git] / drivers / base / sys.c
CommitLineData
1da177e4
LT
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
1da177e4
LT
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/slab.h>
21#include <linux/string.h>
438510f6 22#include <linux/pm.h>
f67d115f 23#include <linux/device.h>
9f3f776b 24#include <linux/mutex.h>
2ed8d2b3 25#include <linux/interrupt.h>
1da177e4 26
f67d115f
AB
27#include "base.h"
28
1da177e4
LT
29#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
60530afe 34sysdev_show(struct kobject *kobj, struct attribute *attr, char *buffer)
1da177e4 35{
60530afe
ZX
36 struct sys_device *sysdev = to_sysdev(kobj);
37 struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
1da177e4
LT
38
39 if (sysdev_attr->show)
4a0b2b4d 40 return sysdev_attr->show(sysdev, sysdev_attr, buffer);
4a0c20bf 41 return -EIO;
1da177e4
LT
42}
43
44
45static ssize_t
60530afe
ZX
46sysdev_store(struct kobject *kobj, struct attribute *attr,
47 const char *buffer, size_t count)
1da177e4 48{
60530afe
ZX
49 struct sys_device *sysdev = to_sysdev(kobj);
50 struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
1da177e4
LT
51
52 if (sysdev_attr->store)
4a0b2b4d 53 return sysdev_attr->store(sysdev, sysdev_attr, buffer, count);
4a0c20bf 54 return -EIO;
1da177e4
LT
55}
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
60530afe 67int sysdev_create_file(struct sys_device *s, struct sysdev_attribute *a)
1da177e4
LT
68{
69 return sysfs_create_file(&s->kobj, &a->attr);
70}
71
72
60530afe 73void sysdev_remove_file(struct sys_device *s, struct sysdev_attribute *a)
1da177e4
LT
74{
75 sysfs_remove_file(&s->kobj, &a->attr);
76}
77
78EXPORT_SYMBOL_GPL(sysdev_create_file);
79EXPORT_SYMBOL_GPL(sysdev_remove_file);
80
670dd90d
SL
81#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{
60530afe 88 struct sysdev_class *class = to_sysdev_class(kobj);
670dd90d
SL
89 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{
60530afe
ZX
99 struct sysdev_class *class = to_sysdev_class(kobj);
100 struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
670dd90d
SL
101
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
aade4041 130static struct kset *system_kset;
1da177e4 131
60530afe 132int sysdev_class_register(struct sysdev_class *cls)
1da177e4 133{
9227c47b
DY
134 int retval;
135
838ea8e8
BD
136 pr_debug("Registering sysdev class '%s'\n", cls->name);
137
1da177e4 138 INIT_LIST_HEAD(&cls->drivers);
ef79df26 139 memset(&cls->kset.kobj, 0x00, sizeof(struct kobject));
aade4041 140 cls->kset.kobj.parent = &system_kset->kobj;
3514faca 141 cls->kset.kobj.ktype = &ktype_sysdev_class;
aade4041 142 cls->kset.kobj.kset = system_kset;
9227c47b 143
acc0e90f 144 retval = kobject_set_name(&cls->kset.kobj, "%s", cls->name);
9227c47b
DY
145 if (retval)
146 return retval;
147
1da177e4
LT
148 return kset_register(&cls->kset);
149}
150
60530afe 151void sysdev_class_unregister(struct sysdev_class *cls)
1da177e4
LT
152{
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
9f3f776b 161static DEFINE_MUTEX(sysdev_drivers_lock);
1da177e4
LT
162
163/**
164 * sysdev_driver_register - Register auxillary driver
44b760a8 165 * @cls: Device class driver belongs to.
1da177e4
LT
166 * @drv: Driver.
167 *
44b760a8 168 * @drv is inserted into @cls->drivers to be
1da177e4
LT
169 * called on each operation on devices of that class. The refcount
170 * of @cls is incremented.
1da177e4
LT
171 */
172
44b760a8 173int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
1da177e4 174{
44b760a8
AM
175 int err = 0;
176
da009f39 177 if (!cls) {
f810a5cf 178 WARN(1, KERN_WARNING "sysdev: invalid class passed to "
da009f39 179 "sysdev_driver_register!\n");
da009f39
BD
180 return -EINVAL;
181 }
182
183 /* Check whether this driver has already been added to a class. */
f810a5cf
AV
184 if (drv->entry.next && !list_empty(&drv->entry))
185 WARN(1, KERN_WARNING "sysdev: class %s: driver (%p) has already"
da009f39
BD
186 " been registered to a class, something is wrong, but "
187 "will forge on!\n", cls->name, drv);
da009f39 188
9f3f776b 189 mutex_lock(&sysdev_drivers_lock);
1da177e4
LT
190 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 }
44b760a8
AM
199 } else {
200 err = -EINVAL;
f810a5cf 201 WARN(1, KERN_ERR "%s: invalid device class\n", __func__);
44b760a8 202 }
9f3f776b 203 mutex_unlock(&sysdev_drivers_lock);
44b760a8 204 return err;
1da177e4
LT
205}
206
207
208/**
209 * sysdev_driver_unregister - Remove an auxillary driver.
210 * @cls: Class driver belongs to.
211 * @drv: Driver.
212 */
60530afe
ZX
213void sysdev_driver_unregister(struct sysdev_class *cls,
214 struct sysdev_driver *drv)
1da177e4 215{
9f3f776b 216 mutex_lock(&sysdev_drivers_lock);
1da177e4
LT
217 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 }
9f3f776b 226 mutex_unlock(&sysdev_drivers_lock);
1da177e4
LT
227}
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 */
60530afe 239int sysdev_register(struct sys_device *sysdev)
1da177e4
LT
240{
241 int error;
60530afe 242 struct sysdev_class *cls = sysdev->cls;
1da177e4
LT
243
244 if (!cls)
245 return -EINVAL;
246
838ea8e8
BD
247 pr_debug("Registering sys device of class '%s'\n",
248 kobject_name(&cls->kset.kobj));
61030bfb 249
ef79df26
GKH
250 /* initialize the kobject to 0, in case it had previously been used */
251 memset(&sysdev->kobj, 0x00, sizeof(struct kobject));
252
1da177e4
LT
253 /* Make sure the kset is set */
254 sysdev->kobj.kset = &cls->kset;
255
1da177e4 256 /* Register the object */
61030bfb
GKH
257 error = kobject_init_and_add(&sysdev->kobj, &ktype_sysdev, NULL,
258 "%s%d", kobject_name(&cls->kset.kobj),
259 sysdev->id);
1da177e4
LT
260
261 if (!error) {
60530afe 262 struct sysdev_driver *drv;
1da177e4 263
838ea8e8
BD
264 pr_debug("Registering sys device '%s'\n",
265 kobject_name(&sysdev->kobj));
266
9f3f776b 267 mutex_lock(&sysdev_drivers_lock);
1da177e4
LT
268 /* Generic notification is implicit, because it's that
269 * code that should have called us.
270 */
271
1da177e4
LT
272 /* Notify class auxillary drivers */
273 list_for_each_entry(drv, &cls->drivers, entry) {
274 if (drv->add)
275 drv->add(sysdev);
276 }
9f3f776b 277 mutex_unlock(&sysdev_drivers_lock);
79f0313b 278 kobject_uevent(&sysdev->kobj, KOBJ_ADD);
1da177e4 279 }
838ea8e8 280
1da177e4
LT
281 return error;
282}
283
60530afe 284void sysdev_unregister(struct sys_device *sysdev)
1da177e4 285{
60530afe 286 struct sysdev_driver *drv;
1da177e4 287
9f3f776b 288 mutex_lock(&sysdev_drivers_lock);
1da177e4
LT
289 list_for_each_entry(drv, &sysdev->cls->drivers, entry) {
290 if (drv->remove)
291 drv->remove(sysdev);
292 }
9f3f776b 293 mutex_unlock(&sysdev_drivers_lock);
1da177e4 294
c10997f6 295 kobject_put(&sysdev->kobj);
1da177e4
LT
296}
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
44b760a8 305 * each driver registered for the device - the auxillaries,
1da177e4
LT
306 * and the class driver.
307 *
308 * Note: The list is iterated in reverse order, so that we shut down
ee6921f7 309 * child devices before we shut down their parents. The list ordering
1da177e4
LT
310 * is guaranteed by virtue of the fact that child devices are registered
311 * after their parents.
312 */
1da177e4
LT
313void sysdev_shutdown(void)
314{
60530afe 315 struct sysdev_class *cls;
1da177e4
LT
316
317 pr_debug("Shutting Down System Devices\n");
318
9f3f776b 319 mutex_lock(&sysdev_drivers_lock);
aade4041 320 list_for_each_entry_reverse(cls, &system_kset->list, kset.kobj.entry) {
60530afe 321 struct sys_device *sysdev;
1da177e4
LT
322
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) {
60530afe 327 struct sysdev_driver *drv;
1da177e4
LT
328 pr_debug(" %s\n", kobject_name(&sysdev->kobj));
329
44b760a8 330 /* Call auxillary drivers first */
1da177e4
LT
331 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 }
9f3f776b 341 mutex_unlock(&sysdev_drivers_lock);
1da177e4
LT
342}
343
ceaeade1
SL
344static 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);
62b01247
RW
352 WARN_ONCE(!irqs_disabled(),
353 "Interrupts enabled after %pF\n", cls->resume);
ceaeade1
SL
354
355 /* Call auxillary drivers next. */
356 list_for_each_entry(drv, &cls->drivers, entry) {
357 if (drv->resume)
358 drv->resume(dev);
62b01247
RW
359 WARN_ONCE(!irqs_disabled(),
360 "Interrupts enabled after %pF\n", drv->resume);
ceaeade1 361 }
ceaeade1 362}
1da177e4
LT
363
364/**
365 * sysdev_suspend - Suspend all system devices.
366 * @state: Power state to enter.
367 *
65151365 368 * We perform an almost identical operation as sysdev_shutdown()
1da177e4
LT
369 * 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 */
438510f6 376int sysdev_suspend(pm_message_t state)
1da177e4 377{
60530afe 378 struct sysdev_class *cls;
ceaeade1
SL
379 struct sys_device *sysdev, *err_dev;
380 struct sysdev_driver *drv, *err_drv;
381 int ret;
1da177e4 382
2ed8d2b3
RW
383 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
62b01247
RW
390 WARN_ONCE(!irqs_disabled(),
391 "Interrupts enabled while suspending system devices\n");
392
1da177e4
LT
393 pr_debug("Suspending System Devices\n");
394
aade4041 395 list_for_each_entry_reverse(cls, &system_kset->list, kset.kobj.entry) {
1da177e4
LT
396 pr_debug("Suspending type '%s':\n",
397 kobject_name(&cls->kset.kobj));
398
399 list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
1da177e4
LT
400 pr_debug(" %s\n", kobject_name(&sysdev->kobj));
401
44b760a8 402 /* Call auxillary drivers first */
1da177e4 403 list_for_each_entry(drv, &cls->drivers, entry) {
ceaeade1
SL
404 if (drv->suspend) {
405 ret = drv->suspend(sysdev, state);
406 if (ret)
407 goto aux_driver;
408 }
62b01247
RW
409 WARN_ONCE(!irqs_disabled(),
410 "Interrupts enabled after %pF\n",
411 drv->suspend);
1da177e4
LT
412 }
413
414 /* Now call the generic one */
ceaeade1
SL
415 if (cls->suspend) {
416 ret = cls->suspend(sysdev, state);
417 if (ret)
418 goto cls_driver;
62b01247
RW
419 WARN_ONCE(!irqs_disabled(),
420 "Interrupts enabled after %pF\n",
421 cls->suspend);
ceaeade1 422 }
1da177e4
LT
423 }
424 }
425 return 0;
ceaeade1
SL
426 /* 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 }
ceaeade1 442
ceaeade1
SL
443 /* 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 */
aade4041 452 list_for_each_entry_continue(cls, &system_kset->list, kset.kobj.entry) {
ceaeade1
SL
453 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;
1da177e4 459}
0f99fed4 460EXPORT_SYMBOL_GPL(sysdev_suspend);
1da177e4
LT
461
462/**
463 * sysdev_resume - Bring system devices back to life.
464 *
65151365 465 * Similar to sysdev_suspend(), but we iterate the list forwards
1da177e4
LT
466 * to guarantee that parent devices are resumed before their children.
467 *
468 * Note: Interrupts are disabled when called.
469 */
1da177e4
LT
470int sysdev_resume(void)
471{
60530afe 472 struct sysdev_class *cls;
1da177e4 473
62b01247
RW
474 WARN_ONCE(!irqs_disabled(),
475 "Interrupts enabled while resuming system devices\n");
476
1da177e4
LT
477 pr_debug("Resuming System Devices\n");
478
aade4041 479 list_for_each_entry(cls, &system_kset->list, kset.kobj.entry) {
60530afe 480 struct sys_device *sysdev;
1da177e4
LT
481
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) {
1da177e4
LT
486 pr_debug(" %s\n", kobject_name(&sysdev->kobj));
487
ceaeade1 488 __sysdev_resume(sysdev);
1da177e4
LT
489 }
490 }
491 return 0;
492}
0f99fed4 493EXPORT_SYMBOL_GPL(sysdev_resume);
1da177e4
LT
494
495int __init system_bus_init(void)
496{
aade4041
GKH
497 system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj);
498 if (!system_kset)
499 return -ENOMEM;
500 return 0;
1da177e4
LT
501}
502
503EXPORT_SYMBOL_GPL(sysdev_register);
504EXPORT_SYMBOL_GPL(sysdev_unregister);
9800794a
AK
505
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;
4e318d7c
AK
518 /* Always return full write size even if we didn't consume all */
519 return size;
9800794a
AK
520}
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;
4e318d7c
AK
542 /* Always return full write size even if we didn't consume all */
543 return size;
9800794a
AK
544}
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