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 32static ssize_t 33sysdev_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 44static ssize_t 45sysdev_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 56static const struct sysfs_ops sysfs_ops = { 57 .show = sysdev_show, 58 .store = sysdev_store, 59}; 60 61static struct kobj_type ktype_sysdev = { 62 .sysfs_ops = &sysfs_ops, 63}; 64 65 66int sysdev_create_file(struct sys_device *s, struct sysdev_attribute *a) 67{ 68 return sysfs_create_file(&s->kobj, &a->attr); 69} 70 71 72void sysdev_remove_file(struct sys_device *s, struct sysdev_attribute *a) 73{ 74 sysfs_remove_file(&s->kobj, &a->attr); 75} 76 77EXPORT_SYMBOL_GPL(sysdev_create_file); 78EXPORT_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 84static 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 95static 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 106static const struct sysfs_ops sysfs_class_ops = { 107 .show = sysdev_class_show, 108 .store = sysdev_class_store, 109}; 110 111static struct kobj_type ktype_sysdev_class = { 112 .sysfs_ops = &sysfs_class_ops, 113}; 114 115int 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} 120EXPORT_SYMBOL_GPL(sysdev_class_create_file); 121 122void 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} 127EXPORT_SYMBOL_GPL(sysdev_class_remove_file); 128 129static struct kset *system_kset; 130 131int 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 154void 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 164EXPORT_SYMBOL_GPL(sysdev_class_register); 165EXPORT_SYMBOL_GPL(sysdev_class_unregister); 166 167static 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 179int 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 */ 219void 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 235EXPORT_SYMBOL_GPL(sysdev_driver_register); 236EXPORT_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 */ 245int 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 290void 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 */ 319void 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 350static 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 */ 382int 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 */ 433cls_driver: 434 drv = NULL; 435 printk(KERN_ERR "Class suspend failed for %s\n", 436 kobject_name(&sysdev->kobj)); 437 438aux_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} 466EXPORT_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 */ 476int 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} 499EXPORT_SYMBOL_GPL(sysdev_resume); 500 501int __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 509EXPORT_SYMBOL_GPL(sysdev_register); 510EXPORT_SYMBOL_GPL(sysdev_unregister); 511 512#define to_ext_attr(x) container_of(x, struct sysdev_ext_attribute, attr) 513 514ssize_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} 527EXPORT_SYMBOL_GPL(sysdev_store_ulong); 528 529ssize_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} 536EXPORT_SYMBOL_GPL(sysdev_show_ulong); 537 538ssize_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} 551EXPORT_SYMBOL_GPL(sysdev_store_int); 552 553ssize_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} 560EXPORT_SYMBOL_GPL(sysdev_show_int); 561