1 /* 2 * drivers/base/core.c - core driver model code (device registration, etc) 3 * 4 * Copyright (c) 2002-3 Patrick Mochel 5 * Copyright (c) 2002-3 Open Source Development Labs 6 * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de> 7 * Copyright (c) 2006 Novell, Inc. 8 * 9 * This file is released under the GPLv2 10 * 11 */ 12 13 #include <linux/device.h> 14 #include <linux/err.h> 15 #include <linux/init.h> 16 #include <linux/module.h> 17 #include <linux/slab.h> 18 #include <linux/string.h> 19 #include <linux/kdev_t.h> 20 #include <linux/notifier.h> 21 #include <linux/genhd.h> 22 #include <linux/kallsyms.h> 23 #include <linux/semaphore.h> 24 #include <linux/mutex.h> 25 26 #include "base.h" 27 #include "power/power.h" 28 29 int (*platform_notify)(struct device *dev) = NULL; 30 int (*platform_notify_remove)(struct device *dev) = NULL; 31 static struct kobject *dev_kobj; 32 struct kobject *sysfs_dev_char_kobj; 33 struct kobject *sysfs_dev_block_kobj; 34 35 #ifdef CONFIG_BLOCK 36 static inline int device_is_not_partition(struct device *dev) 37 { 38 return !(dev->type == &part_type); 39 } 40 #else 41 static inline int device_is_not_partition(struct device *dev) 42 { 43 return 1; 44 } 45 #endif 46 47 /** 48 * dev_driver_string - Return a device's driver name, if at all possible 49 * @dev: struct device to get the name of 50 * 51 * Will return the device's driver's name if it is bound to a device. If 52 * the device is not bound to a device, it will return the name of the bus 53 * it is attached to. If it is not attached to a bus either, an empty 54 * string will be returned. 55 */ 56 const char *dev_driver_string(const struct device *dev) 57 { 58 return dev->driver ? dev->driver->name : 59 (dev->bus ? dev->bus->name : 60 (dev->class ? dev->class->name : "")); 61 } 62 EXPORT_SYMBOL(dev_driver_string); 63 64 #define to_dev(obj) container_of(obj, struct device, kobj) 65 #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 66 67 static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 68 char *buf) 69 { 70 struct device_attribute *dev_attr = to_dev_attr(attr); 71 struct device *dev = to_dev(kobj); 72 ssize_t ret = -EIO; 73 74 if (dev_attr->show) 75 ret = dev_attr->show(dev, dev_attr, buf); 76 if (ret >= (ssize_t)PAGE_SIZE) { 77 print_symbol("dev_attr_show: %s returned bad count\n", 78 (unsigned long)dev_attr->show); 79 } 80 return ret; 81 } 82 83 static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 84 const char *buf, size_t count) 85 { 86 struct device_attribute *dev_attr = to_dev_attr(attr); 87 struct device *dev = to_dev(kobj); 88 ssize_t ret = -EIO; 89 90 if (dev_attr->store) 91 ret = dev_attr->store(dev, dev_attr, buf, count); 92 return ret; 93 } 94 95 static struct sysfs_ops dev_sysfs_ops = { 96 .show = dev_attr_show, 97 .store = dev_attr_store, 98 }; 99 100 101 /** 102 * device_release - free device structure. 103 * @kobj: device's kobject. 104 * 105 * This is called once the reference count for the object 106 * reaches 0. We forward the call to the device's release 107 * method, which should handle actually freeing the structure. 108 */ 109 static void device_release(struct kobject *kobj) 110 { 111 struct device *dev = to_dev(kobj); 112 113 if (dev->release) 114 dev->release(dev); 115 else if (dev->type && dev->type->release) 116 dev->type->release(dev); 117 else if (dev->class && dev->class->dev_release) 118 dev->class->dev_release(dev); 119 else 120 WARN(1, KERN_ERR "Device '%s' does not have a release() " 121 "function, it is broken and must be fixed.\n", 122 dev_name(dev)); 123 } 124 125 static struct kobj_type device_ktype = { 126 .release = device_release, 127 .sysfs_ops = &dev_sysfs_ops, 128 }; 129 130 131 static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 132 { 133 struct kobj_type *ktype = get_ktype(kobj); 134 135 if (ktype == &device_ktype) { 136 struct device *dev = to_dev(kobj); 137 if (dev->uevent_suppress) 138 return 0; 139 if (dev->bus) 140 return 1; 141 if (dev->class) 142 return 1; 143 } 144 return 0; 145 } 146 147 static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 148 { 149 struct device *dev = to_dev(kobj); 150 151 if (dev->bus) 152 return dev->bus->name; 153 if (dev->class) 154 return dev->class->name; 155 return NULL; 156 } 157 158 static int dev_uevent(struct kset *kset, struct kobject *kobj, 159 struct kobj_uevent_env *env) 160 { 161 struct device *dev = to_dev(kobj); 162 int retval = 0; 163 164 /* add the major/minor if present */ 165 if (MAJOR(dev->devt)) { 166 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 167 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 168 } 169 170 if (dev->type && dev->type->name) 171 add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 172 173 if (dev->driver) 174 add_uevent_var(env, "DRIVER=%s", dev->driver->name); 175 176 #ifdef CONFIG_SYSFS_DEPRECATED 177 if (dev->class) { 178 struct device *parent = dev->parent; 179 180 /* find first bus device in parent chain */ 181 while (parent && !parent->bus) 182 parent = parent->parent; 183 if (parent && parent->bus) { 184 const char *path; 185 186 path = kobject_get_path(&parent->kobj, GFP_KERNEL); 187 if (path) { 188 add_uevent_var(env, "PHYSDEVPATH=%s", path); 189 kfree(path); 190 } 191 192 add_uevent_var(env, "PHYSDEVBUS=%s", parent->bus->name); 193 194 if (parent->driver) 195 add_uevent_var(env, "PHYSDEVDRIVER=%s", 196 parent->driver->name); 197 } 198 } else if (dev->bus) { 199 add_uevent_var(env, "PHYSDEVBUS=%s", dev->bus->name); 200 201 if (dev->driver) 202 add_uevent_var(env, "PHYSDEVDRIVER=%s", 203 dev->driver->name); 204 } 205 #endif 206 207 /* have the bus specific function add its stuff */ 208 if (dev->bus && dev->bus->uevent) { 209 retval = dev->bus->uevent(dev, env); 210 if (retval) 211 pr_debug("device: '%s': %s: bus uevent() returned %d\n", 212 dev_name(dev), __func__, retval); 213 } 214 215 /* have the class specific function add its stuff */ 216 if (dev->class && dev->class->dev_uevent) { 217 retval = dev->class->dev_uevent(dev, env); 218 if (retval) 219 pr_debug("device: '%s': %s: class uevent() " 220 "returned %d\n", dev_name(dev), 221 __func__, retval); 222 } 223 224 /* have the device type specific fuction add its stuff */ 225 if (dev->type && dev->type->uevent) { 226 retval = dev->type->uevent(dev, env); 227 if (retval) 228 pr_debug("device: '%s': %s: dev_type uevent() " 229 "returned %d\n", dev_name(dev), 230 __func__, retval); 231 } 232 233 return retval; 234 } 235 236 static struct kset_uevent_ops device_uevent_ops = { 237 .filter = dev_uevent_filter, 238 .name = dev_uevent_name, 239 .uevent = dev_uevent, 240 }; 241 242 static ssize_t show_uevent(struct device *dev, struct device_attribute *attr, 243 char *buf) 244 { 245 struct kobject *top_kobj; 246 struct kset *kset; 247 struct kobj_uevent_env *env = NULL; 248 int i; 249 size_t count = 0; 250 int retval; 251 252 /* search the kset, the device belongs to */ 253 top_kobj = &dev->kobj; 254 while (!top_kobj->kset && top_kobj->parent) 255 top_kobj = top_kobj->parent; 256 if (!top_kobj->kset) 257 goto out; 258 259 kset = top_kobj->kset; 260 if (!kset->uevent_ops || !kset->uevent_ops->uevent) 261 goto out; 262 263 /* respect filter */ 264 if (kset->uevent_ops && kset->uevent_ops->filter) 265 if (!kset->uevent_ops->filter(kset, &dev->kobj)) 266 goto out; 267 268 env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 269 if (!env) 270 return -ENOMEM; 271 272 /* let the kset specific function add its keys */ 273 retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 274 if (retval) 275 goto out; 276 277 /* copy keys to file */ 278 for (i = 0; i < env->envp_idx; i++) 279 count += sprintf(&buf[count], "%s\n", env->envp[i]); 280 out: 281 kfree(env); 282 return count; 283 } 284 285 static ssize_t store_uevent(struct device *dev, struct device_attribute *attr, 286 const char *buf, size_t count) 287 { 288 enum kobject_action action; 289 290 if (kobject_action_type(buf, count, &action) == 0) { 291 kobject_uevent(&dev->kobj, action); 292 goto out; 293 } 294 295 dev_err(dev, "uevent: unsupported action-string; this will " 296 "be ignored in a future kernel version\n"); 297 kobject_uevent(&dev->kobj, KOBJ_ADD); 298 out: 299 return count; 300 } 301 302 static struct device_attribute uevent_attr = 303 __ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent); 304 305 static int device_add_attributes(struct device *dev, 306 struct device_attribute *attrs) 307 { 308 int error = 0; 309 int i; 310 311 if (attrs) { 312 for (i = 0; attr_name(attrs[i]); i++) { 313 error = device_create_file(dev, &attrs[i]); 314 if (error) 315 break; 316 } 317 if (error) 318 while (--i >= 0) 319 device_remove_file(dev, &attrs[i]); 320 } 321 return error; 322 } 323 324 static void device_remove_attributes(struct device *dev, 325 struct device_attribute *attrs) 326 { 327 int i; 328 329 if (attrs) 330 for (i = 0; attr_name(attrs[i]); i++) 331 device_remove_file(dev, &attrs[i]); 332 } 333 334 static int device_add_groups(struct device *dev, 335 struct attribute_group **groups) 336 { 337 int error = 0; 338 int i; 339 340 if (groups) { 341 for (i = 0; groups[i]; i++) { 342 error = sysfs_create_group(&dev->kobj, groups[i]); 343 if (error) { 344 while (--i >= 0) 345 sysfs_remove_group(&dev->kobj, 346 groups[i]); 347 break; 348 } 349 } 350 } 351 return error; 352 } 353 354 static void device_remove_groups(struct device *dev, 355 struct attribute_group **groups) 356 { 357 int i; 358 359 if (groups) 360 for (i = 0; groups[i]; i++) 361 sysfs_remove_group(&dev->kobj, groups[i]); 362 } 363 364 static int device_add_attrs(struct device *dev) 365 { 366 struct class *class = dev->class; 367 struct device_type *type = dev->type; 368 int error; 369 370 if (class) { 371 error = device_add_attributes(dev, class->dev_attrs); 372 if (error) 373 return error; 374 } 375 376 if (type) { 377 error = device_add_groups(dev, type->groups); 378 if (error) 379 goto err_remove_class_attrs; 380 } 381 382 error = device_add_groups(dev, dev->groups); 383 if (error) 384 goto err_remove_type_groups; 385 386 return 0; 387 388 err_remove_type_groups: 389 if (type) 390 device_remove_groups(dev, type->groups); 391 err_remove_class_attrs: 392 if (class) 393 device_remove_attributes(dev, class->dev_attrs); 394 395 return error; 396 } 397 398 static void device_remove_attrs(struct device *dev) 399 { 400 struct class *class = dev->class; 401 struct device_type *type = dev->type; 402 403 device_remove_groups(dev, dev->groups); 404 405 if (type) 406 device_remove_groups(dev, type->groups); 407 408 if (class) 409 device_remove_attributes(dev, class->dev_attrs); 410 } 411 412 413 static ssize_t show_dev(struct device *dev, struct device_attribute *attr, 414 char *buf) 415 { 416 return print_dev_t(buf, dev->devt); 417 } 418 419 static struct device_attribute devt_attr = 420 __ATTR(dev, S_IRUGO, show_dev, NULL); 421 422 /* kset to create /sys/devices/ */ 423 struct kset *devices_kset; 424 425 /** 426 * device_create_file - create sysfs attribute file for device. 427 * @dev: device. 428 * @attr: device attribute descriptor. 429 */ 430 int device_create_file(struct device *dev, struct device_attribute *attr) 431 { 432 int error = 0; 433 if (dev) 434 error = sysfs_create_file(&dev->kobj, &attr->attr); 435 return error; 436 } 437 438 /** 439 * device_remove_file - remove sysfs attribute file. 440 * @dev: device. 441 * @attr: device attribute descriptor. 442 */ 443 void device_remove_file(struct device *dev, struct device_attribute *attr) 444 { 445 if (dev) 446 sysfs_remove_file(&dev->kobj, &attr->attr); 447 } 448 449 /** 450 * device_create_bin_file - create sysfs binary attribute file for device. 451 * @dev: device. 452 * @attr: device binary attribute descriptor. 453 */ 454 int device_create_bin_file(struct device *dev, struct bin_attribute *attr) 455 { 456 int error = -EINVAL; 457 if (dev) 458 error = sysfs_create_bin_file(&dev->kobj, attr); 459 return error; 460 } 461 EXPORT_SYMBOL_GPL(device_create_bin_file); 462 463 /** 464 * device_remove_bin_file - remove sysfs binary attribute file 465 * @dev: device. 466 * @attr: device binary attribute descriptor. 467 */ 468 void device_remove_bin_file(struct device *dev, struct bin_attribute *attr) 469 { 470 if (dev) 471 sysfs_remove_bin_file(&dev->kobj, attr); 472 } 473 EXPORT_SYMBOL_GPL(device_remove_bin_file); 474 475 /** 476 * device_schedule_callback_owner - helper to schedule a callback for a device 477 * @dev: device. 478 * @func: callback function to invoke later. 479 * @owner: module owning the callback routine 480 * 481 * Attribute methods must not unregister themselves or their parent device 482 * (which would amount to the same thing). Attempts to do so will deadlock, 483 * since unregistration is mutually exclusive with driver callbacks. 484 * 485 * Instead methods can call this routine, which will attempt to allocate 486 * and schedule a workqueue request to call back @func with @dev as its 487 * argument in the workqueue's process context. @dev will be pinned until 488 * @func returns. 489 * 490 * This routine is usually called via the inline device_schedule_callback(), 491 * which automatically sets @owner to THIS_MODULE. 492 * 493 * Returns 0 if the request was submitted, -ENOMEM if storage could not 494 * be allocated, -ENODEV if a reference to @owner isn't available. 495 * 496 * NOTE: This routine won't work if CONFIG_SYSFS isn't set! It uses an 497 * underlying sysfs routine (since it is intended for use by attribute 498 * methods), and if sysfs isn't available you'll get nothing but -ENOSYS. 499 */ 500 int device_schedule_callback_owner(struct device *dev, 501 void (*func)(struct device *), struct module *owner) 502 { 503 return sysfs_schedule_callback(&dev->kobj, 504 (void (*)(void *)) func, dev, owner); 505 } 506 EXPORT_SYMBOL_GPL(device_schedule_callback_owner); 507 508 static void klist_children_get(struct klist_node *n) 509 { 510 struct device *dev = container_of(n, struct device, knode_parent); 511 512 get_device(dev); 513 } 514 515 static void klist_children_put(struct klist_node *n) 516 { 517 struct device *dev = container_of(n, struct device, knode_parent); 518 519 put_device(dev); 520 } 521 522 /** 523 * device_initialize - init device structure. 524 * @dev: device. 525 * 526 * This prepares the device for use by other layers by initializing 527 * its fields. 528 * It is the first half of device_register(), if called by 529 * that function, though it can also be called separately, so one 530 * may use @dev's fields. In particular, get_device()/put_device() 531 * may be used for reference counting of @dev after calling this 532 * function. 533 * 534 * NOTE: Use put_device() to give up your reference instead of freeing 535 * @dev directly once you have called this function. 536 */ 537 void device_initialize(struct device *dev) 538 { 539 dev->kobj.kset = devices_kset; 540 kobject_init(&dev->kobj, &device_ktype); 541 klist_init(&dev->klist_children, klist_children_get, 542 klist_children_put); 543 INIT_LIST_HEAD(&dev->dma_pools); 544 init_MUTEX(&dev->sem); 545 spin_lock_init(&dev->devres_lock); 546 INIT_LIST_HEAD(&dev->devres_head); 547 device_init_wakeup(dev, 0); 548 device_pm_init(dev); 549 set_dev_node(dev, -1); 550 } 551 552 #ifdef CONFIG_SYSFS_DEPRECATED 553 static struct kobject *get_device_parent(struct device *dev, 554 struct device *parent) 555 { 556 /* class devices without a parent live in /sys/class/<classname>/ */ 557 if (dev->class && (!parent || parent->class != dev->class)) 558 return &dev->class->p->class_subsys.kobj; 559 /* all other devices keep their parent */ 560 else if (parent) 561 return &parent->kobj; 562 563 return NULL; 564 } 565 566 static inline void cleanup_device_parent(struct device *dev) {} 567 static inline void cleanup_glue_dir(struct device *dev, 568 struct kobject *glue_dir) {} 569 #else 570 static struct kobject *virtual_device_parent(struct device *dev) 571 { 572 static struct kobject *virtual_dir = NULL; 573 574 if (!virtual_dir) 575 virtual_dir = kobject_create_and_add("virtual", 576 &devices_kset->kobj); 577 578 return virtual_dir; 579 } 580 581 static struct kobject *get_device_parent(struct device *dev, 582 struct device *parent) 583 { 584 int retval; 585 586 if (dev->class) { 587 struct kobject *kobj = NULL; 588 struct kobject *parent_kobj; 589 struct kobject *k; 590 591 /* 592 * If we have no parent, we live in "virtual". 593 * Class-devices with a non class-device as parent, live 594 * in a "glue" directory to prevent namespace collisions. 595 */ 596 if (parent == NULL) 597 parent_kobj = virtual_device_parent(dev); 598 else if (parent->class) 599 return &parent->kobj; 600 else 601 parent_kobj = &parent->kobj; 602 603 /* find our class-directory at the parent and reference it */ 604 spin_lock(&dev->class->p->class_dirs.list_lock); 605 list_for_each_entry(k, &dev->class->p->class_dirs.list, entry) 606 if (k->parent == parent_kobj) { 607 kobj = kobject_get(k); 608 break; 609 } 610 spin_unlock(&dev->class->p->class_dirs.list_lock); 611 if (kobj) 612 return kobj; 613 614 /* or create a new class-directory at the parent device */ 615 k = kobject_create(); 616 if (!k) 617 return NULL; 618 k->kset = &dev->class->p->class_dirs; 619 retval = kobject_add(k, parent_kobj, "%s", dev->class->name); 620 if (retval < 0) { 621 kobject_put(k); 622 return NULL; 623 } 624 /* do not emit an uevent for this simple "glue" directory */ 625 return k; 626 } 627 628 if (parent) 629 return &parent->kobj; 630 return NULL; 631 } 632 633 static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 634 { 635 /* see if we live in a "glue" directory */ 636 if (!glue_dir || !dev->class || 637 glue_dir->kset != &dev->class->p->class_dirs) 638 return; 639 640 kobject_put(glue_dir); 641 } 642 643 static void cleanup_device_parent(struct device *dev) 644 { 645 cleanup_glue_dir(dev, dev->kobj.parent); 646 } 647 #endif 648 649 static void setup_parent(struct device *dev, struct device *parent) 650 { 651 struct kobject *kobj; 652 kobj = get_device_parent(dev, parent); 653 if (kobj) 654 dev->kobj.parent = kobj; 655 } 656 657 static int device_add_class_symlinks(struct device *dev) 658 { 659 int error; 660 661 if (!dev->class) 662 return 0; 663 664 error = sysfs_create_link(&dev->kobj, 665 &dev->class->p->class_subsys.kobj, 666 "subsystem"); 667 if (error) 668 goto out; 669 670 #ifdef CONFIG_SYSFS_DEPRECATED 671 /* stacked class devices need a symlink in the class directory */ 672 if (dev->kobj.parent != &dev->class->p->class_subsys.kobj && 673 device_is_not_partition(dev)) { 674 error = sysfs_create_link(&dev->class->p->class_subsys.kobj, 675 &dev->kobj, dev_name(dev)); 676 if (error) 677 goto out_subsys; 678 } 679 680 if (dev->parent && device_is_not_partition(dev)) { 681 struct device *parent = dev->parent; 682 char *class_name; 683 684 /* 685 * stacked class devices have the 'device' link 686 * pointing to the bus device instead of the parent 687 */ 688 while (parent->class && !parent->bus && parent->parent) 689 parent = parent->parent; 690 691 error = sysfs_create_link(&dev->kobj, 692 &parent->kobj, 693 "device"); 694 if (error) 695 goto out_busid; 696 697 class_name = make_class_name(dev->class->name, 698 &dev->kobj); 699 if (class_name) 700 error = sysfs_create_link(&dev->parent->kobj, 701 &dev->kobj, class_name); 702 kfree(class_name); 703 if (error) 704 goto out_device; 705 } 706 return 0; 707 708 out_device: 709 if (dev->parent && device_is_not_partition(dev)) 710 sysfs_remove_link(&dev->kobj, "device"); 711 out_busid: 712 if (dev->kobj.parent != &dev->class->p->class_subsys.kobj && 713 device_is_not_partition(dev)) 714 sysfs_remove_link(&dev->class->p->class_subsys.kobj, 715 dev_name(dev)); 716 #else 717 /* link in the class directory pointing to the device */ 718 error = sysfs_create_link(&dev->class->p->class_subsys.kobj, 719 &dev->kobj, dev_name(dev)); 720 if (error) 721 goto out_subsys; 722 723 if (dev->parent && device_is_not_partition(dev)) { 724 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 725 "device"); 726 if (error) 727 goto out_busid; 728 } 729 return 0; 730 731 out_busid: 732 sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev)); 733 #endif 734 735 out_subsys: 736 sysfs_remove_link(&dev->kobj, "subsystem"); 737 out: 738 return error; 739 } 740 741 static void device_remove_class_symlinks(struct device *dev) 742 { 743 if (!dev->class) 744 return; 745 746 #ifdef CONFIG_SYSFS_DEPRECATED 747 if (dev->parent && device_is_not_partition(dev)) { 748 char *class_name; 749 750 class_name = make_class_name(dev->class->name, &dev->kobj); 751 if (class_name) { 752 sysfs_remove_link(&dev->parent->kobj, class_name); 753 kfree(class_name); 754 } 755 sysfs_remove_link(&dev->kobj, "device"); 756 } 757 758 if (dev->kobj.parent != &dev->class->p->class_subsys.kobj && 759 device_is_not_partition(dev)) 760 sysfs_remove_link(&dev->class->p->class_subsys.kobj, 761 dev_name(dev)); 762 #else 763 if (dev->parent && device_is_not_partition(dev)) 764 sysfs_remove_link(&dev->kobj, "device"); 765 766 sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev)); 767 #endif 768 769 sysfs_remove_link(&dev->kobj, "subsystem"); 770 } 771 772 /** 773 * dev_set_name - set a device name 774 * @dev: device 775 * @fmt: format string for the device's name 776 */ 777 int dev_set_name(struct device *dev, const char *fmt, ...) 778 { 779 va_list vargs; 780 char *s; 781 782 va_start(vargs, fmt); 783 vsnprintf(dev->bus_id, sizeof(dev->bus_id), fmt, vargs); 784 va_end(vargs); 785 786 /* ewww... some of these buggers have / in the name... */ 787 while ((s = strchr(dev->bus_id, '/'))) 788 *s = '!'; 789 790 return 0; 791 } 792 EXPORT_SYMBOL_GPL(dev_set_name); 793 794 /** 795 * device_to_dev_kobj - select a /sys/dev/ directory for the device 796 * @dev: device 797 * 798 * By default we select char/ for new entries. Setting class->dev_obj 799 * to NULL prevents an entry from being created. class->dev_kobj must 800 * be set (or cleared) before any devices are registered to the class 801 * otherwise device_create_sys_dev_entry() and 802 * device_remove_sys_dev_entry() will disagree about the the presence 803 * of the link. 804 */ 805 static struct kobject *device_to_dev_kobj(struct device *dev) 806 { 807 struct kobject *kobj; 808 809 if (dev->class) 810 kobj = dev->class->dev_kobj; 811 else 812 kobj = sysfs_dev_char_kobj; 813 814 return kobj; 815 } 816 817 static int device_create_sys_dev_entry(struct device *dev) 818 { 819 struct kobject *kobj = device_to_dev_kobj(dev); 820 int error = 0; 821 char devt_str[15]; 822 823 if (kobj) { 824 format_dev_t(devt_str, dev->devt); 825 error = sysfs_create_link(kobj, &dev->kobj, devt_str); 826 } 827 828 return error; 829 } 830 831 static void device_remove_sys_dev_entry(struct device *dev) 832 { 833 struct kobject *kobj = device_to_dev_kobj(dev); 834 char devt_str[15]; 835 836 if (kobj) { 837 format_dev_t(devt_str, dev->devt); 838 sysfs_remove_link(kobj, devt_str); 839 } 840 } 841 842 /** 843 * device_add - add device to device hierarchy. 844 * @dev: device. 845 * 846 * This is part 2 of device_register(), though may be called 847 * separately _iff_ device_initialize() has been called separately. 848 * 849 * This adds @dev to the kobject hierarchy via kobject_add(), adds it 850 * to the global and sibling lists for the device, then 851 * adds it to the other relevant subsystems of the driver model. 852 * 853 * NOTE: _Never_ directly free @dev after calling this function, even 854 * if it returned an error! Always use put_device() to give up your 855 * reference instead. 856 */ 857 int device_add(struct device *dev) 858 { 859 struct device *parent = NULL; 860 struct class_interface *class_intf; 861 int error = -EINVAL; 862 863 dev = get_device(dev); 864 if (!dev) 865 goto done; 866 867 /* Temporarily support init_name if it is set. 868 * It will override bus_id for now */ 869 if (dev->init_name) 870 dev_set_name(dev, "%s", dev->init_name); 871 872 if (!strlen(dev->bus_id)) 873 goto done; 874 875 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 876 877 parent = get_device(dev->parent); 878 setup_parent(dev, parent); 879 880 /* use parent numa_node */ 881 if (parent) 882 set_dev_node(dev, dev_to_node(parent)); 883 884 /* first, register with generic layer. */ 885 error = kobject_add(&dev->kobj, dev->kobj.parent, "%s", dev_name(dev)); 886 if (error) 887 goto Error; 888 889 /* notify platform of device entry */ 890 if (platform_notify) 891 platform_notify(dev); 892 893 error = device_create_file(dev, &uevent_attr); 894 if (error) 895 goto attrError; 896 897 if (MAJOR(dev->devt)) { 898 error = device_create_file(dev, &devt_attr); 899 if (error) 900 goto ueventattrError; 901 902 error = device_create_sys_dev_entry(dev); 903 if (error) 904 goto devtattrError; 905 } 906 907 error = device_add_class_symlinks(dev); 908 if (error) 909 goto SymlinkError; 910 error = device_add_attrs(dev); 911 if (error) 912 goto AttrsError; 913 error = bus_add_device(dev); 914 if (error) 915 goto BusError; 916 error = dpm_sysfs_add(dev); 917 if (error) 918 goto DPMError; 919 device_pm_add(dev); 920 921 /* Notify clients of device addition. This call must come 922 * after dpm_sysf_add() and before kobject_uevent(). 923 */ 924 if (dev->bus) 925 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 926 BUS_NOTIFY_ADD_DEVICE, dev); 927 928 kobject_uevent(&dev->kobj, KOBJ_ADD); 929 bus_attach_device(dev); 930 if (parent) 931 klist_add_tail(&dev->knode_parent, &parent->klist_children); 932 933 if (dev->class) { 934 mutex_lock(&dev->class->p->class_mutex); 935 /* tie the class to the device */ 936 klist_add_tail(&dev->knode_class, 937 &dev->class->p->class_devices); 938 939 /* notify any interfaces that the device is here */ 940 list_for_each_entry(class_intf, 941 &dev->class->p->class_interfaces, node) 942 if (class_intf->add_dev) 943 class_intf->add_dev(dev, class_intf); 944 mutex_unlock(&dev->class->p->class_mutex); 945 } 946 done: 947 put_device(dev); 948 return error; 949 DPMError: 950 bus_remove_device(dev); 951 BusError: 952 device_remove_attrs(dev); 953 AttrsError: 954 device_remove_class_symlinks(dev); 955 SymlinkError: 956 if (MAJOR(dev->devt)) 957 device_remove_sys_dev_entry(dev); 958 devtattrError: 959 if (MAJOR(dev->devt)) 960 device_remove_file(dev, &devt_attr); 961 ueventattrError: 962 device_remove_file(dev, &uevent_attr); 963 attrError: 964 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 965 kobject_del(&dev->kobj); 966 Error: 967 cleanup_device_parent(dev); 968 if (parent) 969 put_device(parent); 970 goto done; 971 } 972 973 /** 974 * device_register - register a device with the system. 975 * @dev: pointer to the device structure 976 * 977 * This happens in two clean steps - initialize the device 978 * and add it to the system. The two steps can be called 979 * separately, but this is the easiest and most common. 980 * I.e. you should only call the two helpers separately if 981 * have a clearly defined need to use and refcount the device 982 * before it is added to the hierarchy. 983 * 984 * NOTE: _Never_ directly free @dev after calling this function, even 985 * if it returned an error! Always use put_device() to give up the 986 * reference initialized in this function instead. 987 */ 988 int device_register(struct device *dev) 989 { 990 device_initialize(dev); 991 return device_add(dev); 992 } 993 994 /** 995 * get_device - increment reference count for device. 996 * @dev: device. 997 * 998 * This simply forwards the call to kobject_get(), though 999 * we do take care to provide for the case that we get a NULL 1000 * pointer passed in. 1001 */ 1002 struct device *get_device(struct device *dev) 1003 { 1004 return dev ? to_dev(kobject_get(&dev->kobj)) : NULL; 1005 } 1006 1007 /** 1008 * put_device - decrement reference count. 1009 * @dev: device in question. 1010 */ 1011 void put_device(struct device *dev) 1012 { 1013 /* might_sleep(); */ 1014 if (dev) 1015 kobject_put(&dev->kobj); 1016 } 1017 1018 /** 1019 * device_del - delete device from system. 1020 * @dev: device. 1021 * 1022 * This is the first part of the device unregistration 1023 * sequence. This removes the device from the lists we control 1024 * from here, has it removed from the other driver model 1025 * subsystems it was added to in device_add(), and removes it 1026 * from the kobject hierarchy. 1027 * 1028 * NOTE: this should be called manually _iff_ device_add() was 1029 * also called manually. 1030 */ 1031 void device_del(struct device *dev) 1032 { 1033 struct device *parent = dev->parent; 1034 struct class_interface *class_intf; 1035 1036 /* Notify clients of device removal. This call must come 1037 * before dpm_sysfs_remove(). 1038 */ 1039 if (dev->bus) 1040 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1041 BUS_NOTIFY_DEL_DEVICE, dev); 1042 device_pm_remove(dev); 1043 dpm_sysfs_remove(dev); 1044 if (parent) 1045 klist_del(&dev->knode_parent); 1046 if (MAJOR(dev->devt)) { 1047 device_remove_sys_dev_entry(dev); 1048 device_remove_file(dev, &devt_attr); 1049 } 1050 if (dev->class) { 1051 device_remove_class_symlinks(dev); 1052 1053 mutex_lock(&dev->class->p->class_mutex); 1054 /* notify any interfaces that the device is now gone */ 1055 list_for_each_entry(class_intf, 1056 &dev->class->p->class_interfaces, node) 1057 if (class_intf->remove_dev) 1058 class_intf->remove_dev(dev, class_intf); 1059 /* remove the device from the class list */ 1060 klist_del(&dev->knode_class); 1061 mutex_unlock(&dev->class->p->class_mutex); 1062 } 1063 device_remove_file(dev, &uevent_attr); 1064 device_remove_attrs(dev); 1065 bus_remove_device(dev); 1066 1067 /* 1068 * Some platform devices are driven without driver attached 1069 * and managed resources may have been acquired. Make sure 1070 * all resources are released. 1071 */ 1072 devres_release_all(dev); 1073 1074 /* Notify the platform of the removal, in case they 1075 * need to do anything... 1076 */ 1077 if (platform_notify_remove) 1078 platform_notify_remove(dev); 1079 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 1080 cleanup_device_parent(dev); 1081 kobject_del(&dev->kobj); 1082 put_device(parent); 1083 } 1084 1085 /** 1086 * device_unregister - unregister device from system. 1087 * @dev: device going away. 1088 * 1089 * We do this in two parts, like we do device_register(). First, 1090 * we remove it from all the subsystems with device_del(), then 1091 * we decrement the reference count via put_device(). If that 1092 * is the final reference count, the device will be cleaned up 1093 * via device_release() above. Otherwise, the structure will 1094 * stick around until the final reference to the device is dropped. 1095 */ 1096 void device_unregister(struct device *dev) 1097 { 1098 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1099 device_del(dev); 1100 put_device(dev); 1101 } 1102 1103 static struct device *next_device(struct klist_iter *i) 1104 { 1105 struct klist_node *n = klist_next(i); 1106 return n ? container_of(n, struct device, knode_parent) : NULL; 1107 } 1108 1109 /** 1110 * device_for_each_child - device child iterator. 1111 * @parent: parent struct device. 1112 * @data: data for the callback. 1113 * @fn: function to be called for each device. 1114 * 1115 * Iterate over @parent's child devices, and call @fn for each, 1116 * passing it @data. 1117 * 1118 * We check the return of @fn each time. If it returns anything 1119 * other than 0, we break out and return that value. 1120 */ 1121 int device_for_each_child(struct device *parent, void *data, 1122 int (*fn)(struct device *dev, void *data)) 1123 { 1124 struct klist_iter i; 1125 struct device *child; 1126 int error = 0; 1127 1128 klist_iter_init(&parent->klist_children, &i); 1129 while ((child = next_device(&i)) && !error) 1130 error = fn(child, data); 1131 klist_iter_exit(&i); 1132 return error; 1133 } 1134 1135 /** 1136 * device_find_child - device iterator for locating a particular device. 1137 * @parent: parent struct device 1138 * @data: Data to pass to match function 1139 * @match: Callback function to check device 1140 * 1141 * This is similar to the device_for_each_child() function above, but it 1142 * returns a reference to a device that is 'found' for later use, as 1143 * determined by the @match callback. 1144 * 1145 * The callback should return 0 if the device doesn't match and non-zero 1146 * if it does. If the callback returns non-zero and a reference to the 1147 * current device can be obtained, this function will return to the caller 1148 * and not iterate over any more devices. 1149 */ 1150 struct device *device_find_child(struct device *parent, void *data, 1151 int (*match)(struct device *dev, void *data)) 1152 { 1153 struct klist_iter i; 1154 struct device *child; 1155 1156 if (!parent) 1157 return NULL; 1158 1159 klist_iter_init(&parent->klist_children, &i); 1160 while ((child = next_device(&i))) 1161 if (match(child, data) && get_device(child)) 1162 break; 1163 klist_iter_exit(&i); 1164 return child; 1165 } 1166 1167 int __init devices_init(void) 1168 { 1169 devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 1170 if (!devices_kset) 1171 return -ENOMEM; 1172 dev_kobj = kobject_create_and_add("dev", NULL); 1173 if (!dev_kobj) 1174 goto dev_kobj_err; 1175 sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 1176 if (!sysfs_dev_block_kobj) 1177 goto block_kobj_err; 1178 sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 1179 if (!sysfs_dev_char_kobj) 1180 goto char_kobj_err; 1181 1182 return 0; 1183 1184 char_kobj_err: 1185 kobject_put(sysfs_dev_block_kobj); 1186 block_kobj_err: 1187 kobject_put(dev_kobj); 1188 dev_kobj_err: 1189 kset_unregister(devices_kset); 1190 return -ENOMEM; 1191 } 1192 1193 EXPORT_SYMBOL_GPL(device_for_each_child); 1194 EXPORT_SYMBOL_GPL(device_find_child); 1195 1196 EXPORT_SYMBOL_GPL(device_initialize); 1197 EXPORT_SYMBOL_GPL(device_add); 1198 EXPORT_SYMBOL_GPL(device_register); 1199 1200 EXPORT_SYMBOL_GPL(device_del); 1201 EXPORT_SYMBOL_GPL(device_unregister); 1202 EXPORT_SYMBOL_GPL(get_device); 1203 EXPORT_SYMBOL_GPL(put_device); 1204 1205 EXPORT_SYMBOL_GPL(device_create_file); 1206 EXPORT_SYMBOL_GPL(device_remove_file); 1207 1208 struct root_device 1209 { 1210 struct device dev; 1211 struct module *owner; 1212 }; 1213 1214 #define to_root_device(dev) container_of(dev, struct root_device, dev) 1215 1216 static void root_device_release(struct device *dev) 1217 { 1218 kfree(to_root_device(dev)); 1219 } 1220 1221 /** 1222 * __root_device_register - allocate and register a root device 1223 * @name: root device name 1224 * @owner: owner module of the root device, usually THIS_MODULE 1225 * 1226 * This function allocates a root device and registers it 1227 * using device_register(). In order to free the returned 1228 * device, use root_device_unregister(). 1229 * 1230 * Root devices are dummy devices which allow other devices 1231 * to be grouped under /sys/devices. Use this function to 1232 * allocate a root device and then use it as the parent of 1233 * any device which should appear under /sys/devices/{name} 1234 * 1235 * The /sys/devices/{name} directory will also contain a 1236 * 'module' symlink which points to the @owner directory 1237 * in sysfs. 1238 * 1239 * Note: You probably want to use root_device_register(). 1240 */ 1241 struct device *__root_device_register(const char *name, struct module *owner) 1242 { 1243 struct root_device *root; 1244 int err = -ENOMEM; 1245 1246 root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 1247 if (!root) 1248 return ERR_PTR(err); 1249 1250 err = dev_set_name(&root->dev, name); 1251 if (err) { 1252 kfree(root); 1253 return ERR_PTR(err); 1254 } 1255 1256 root->dev.release = root_device_release; 1257 1258 err = device_register(&root->dev); 1259 if (err) { 1260 put_device(&root->dev); 1261 return ERR_PTR(err); 1262 } 1263 1264 #ifdef CONFIG_MODULE /* gotta find a "cleaner" way to do this */ 1265 if (owner) { 1266 struct module_kobject *mk = &owner->mkobj; 1267 1268 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 1269 if (err) { 1270 device_unregister(&root->dev); 1271 return ERR_PTR(err); 1272 } 1273 root->owner = owner; 1274 } 1275 #endif 1276 1277 return &root->dev; 1278 } 1279 EXPORT_SYMBOL_GPL(__root_device_register); 1280 1281 /** 1282 * root_device_unregister - unregister and free a root device 1283 * @dev: device going away 1284 * 1285 * This function unregisters and cleans up a device that was created by 1286 * root_device_register(). 1287 */ 1288 void root_device_unregister(struct device *dev) 1289 { 1290 struct root_device *root = to_root_device(dev); 1291 1292 if (root->owner) 1293 sysfs_remove_link(&root->dev.kobj, "module"); 1294 1295 device_unregister(dev); 1296 } 1297 EXPORT_SYMBOL_GPL(root_device_unregister); 1298 1299 1300 static void device_create_release(struct device *dev) 1301 { 1302 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1303 kfree(dev); 1304 } 1305 1306 /** 1307 * device_create_vargs - creates a device and registers it with sysfs 1308 * @class: pointer to the struct class that this device should be registered to 1309 * @parent: pointer to the parent struct device of this new device, if any 1310 * @devt: the dev_t for the char device to be added 1311 * @drvdata: the data to be added to the device for callbacks 1312 * @fmt: string for the device's name 1313 * @args: va_list for the device's name 1314 * 1315 * This function can be used by char device classes. A struct device 1316 * will be created in sysfs, registered to the specified class. 1317 * 1318 * A "dev" file will be created, showing the dev_t for the device, if 1319 * the dev_t is not 0,0. 1320 * If a pointer to a parent struct device is passed in, the newly created 1321 * struct device will be a child of that device in sysfs. 1322 * The pointer to the struct device will be returned from the call. 1323 * Any further sysfs files that might be required can be created using this 1324 * pointer. 1325 * 1326 * Note: the struct class passed to this function must have previously 1327 * been created with a call to class_create(). 1328 */ 1329 struct device *device_create_vargs(struct class *class, struct device *parent, 1330 dev_t devt, void *drvdata, const char *fmt, 1331 va_list args) 1332 { 1333 struct device *dev = NULL; 1334 int retval = -ENODEV; 1335 1336 if (class == NULL || IS_ERR(class)) 1337 goto error; 1338 1339 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1340 if (!dev) { 1341 retval = -ENOMEM; 1342 goto error; 1343 } 1344 1345 dev->devt = devt; 1346 dev->class = class; 1347 dev->parent = parent; 1348 dev->release = device_create_release; 1349 dev_set_drvdata(dev, drvdata); 1350 1351 vsnprintf(dev->bus_id, BUS_ID_SIZE, fmt, args); 1352 retval = device_register(dev); 1353 if (retval) 1354 goto error; 1355 1356 return dev; 1357 1358 error: 1359 put_device(dev); 1360 return ERR_PTR(retval); 1361 } 1362 EXPORT_SYMBOL_GPL(device_create_vargs); 1363 1364 /** 1365 * device_create - creates a device and registers it with sysfs 1366 * @class: pointer to the struct class that this device should be registered to 1367 * @parent: pointer to the parent struct device of this new device, if any 1368 * @devt: the dev_t for the char device to be added 1369 * @drvdata: the data to be added to the device for callbacks 1370 * @fmt: string for the device's name 1371 * 1372 * This function can be used by char device classes. A struct device 1373 * will be created in sysfs, registered to the specified class. 1374 * 1375 * A "dev" file will be created, showing the dev_t for the device, if 1376 * the dev_t is not 0,0. 1377 * If a pointer to a parent struct device is passed in, the newly created 1378 * struct device will be a child of that device in sysfs. 1379 * The pointer to the struct device will be returned from the call. 1380 * Any further sysfs files that might be required can be created using this 1381 * pointer. 1382 * 1383 * Note: the struct class passed to this function must have previously 1384 * been created with a call to class_create(). 1385 */ 1386 struct device *device_create(struct class *class, struct device *parent, 1387 dev_t devt, void *drvdata, const char *fmt, ...) 1388 { 1389 va_list vargs; 1390 struct device *dev; 1391 1392 va_start(vargs, fmt); 1393 dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs); 1394 va_end(vargs); 1395 return dev; 1396 } 1397 EXPORT_SYMBOL_GPL(device_create); 1398 1399 static int __match_devt(struct device *dev, void *data) 1400 { 1401 dev_t *devt = data; 1402 1403 return dev->devt == *devt; 1404 } 1405 1406 /** 1407 * device_destroy - removes a device that was created with device_create() 1408 * @class: pointer to the struct class that this device was registered with 1409 * @devt: the dev_t of the device that was previously registered 1410 * 1411 * This call unregisters and cleans up a device that was created with a 1412 * call to device_create(). 1413 */ 1414 void device_destroy(struct class *class, dev_t devt) 1415 { 1416 struct device *dev; 1417 1418 dev = class_find_device(class, NULL, &devt, __match_devt); 1419 if (dev) { 1420 put_device(dev); 1421 device_unregister(dev); 1422 } 1423 } 1424 EXPORT_SYMBOL_GPL(device_destroy); 1425 1426 /** 1427 * device_rename - renames a device 1428 * @dev: the pointer to the struct device to be renamed 1429 * @new_name: the new name of the device 1430 * 1431 * It is the responsibility of the caller to provide mutual 1432 * exclusion between two different calls of device_rename 1433 * on the same device to ensure that new_name is valid and 1434 * won't conflict with other devices. 1435 */ 1436 int device_rename(struct device *dev, char *new_name) 1437 { 1438 char *old_class_name = NULL; 1439 char *new_class_name = NULL; 1440 char *old_device_name = NULL; 1441 int error; 1442 1443 dev = get_device(dev); 1444 if (!dev) 1445 return -EINVAL; 1446 1447 pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev), 1448 __func__, new_name); 1449 1450 #ifdef CONFIG_SYSFS_DEPRECATED 1451 if ((dev->class) && (dev->parent)) 1452 old_class_name = make_class_name(dev->class->name, &dev->kobj); 1453 #endif 1454 1455 old_device_name = kmalloc(BUS_ID_SIZE, GFP_KERNEL); 1456 if (!old_device_name) { 1457 error = -ENOMEM; 1458 goto out; 1459 } 1460 strlcpy(old_device_name, dev->bus_id, BUS_ID_SIZE); 1461 strlcpy(dev->bus_id, new_name, BUS_ID_SIZE); 1462 1463 error = kobject_rename(&dev->kobj, new_name); 1464 if (error) { 1465 strlcpy(dev->bus_id, old_device_name, BUS_ID_SIZE); 1466 goto out; 1467 } 1468 1469 #ifdef CONFIG_SYSFS_DEPRECATED 1470 if (old_class_name) { 1471 new_class_name = make_class_name(dev->class->name, &dev->kobj); 1472 if (new_class_name) { 1473 error = sysfs_create_link_nowarn(&dev->parent->kobj, 1474 &dev->kobj, 1475 new_class_name); 1476 if (error) 1477 goto out; 1478 sysfs_remove_link(&dev->parent->kobj, old_class_name); 1479 } 1480 } 1481 #else 1482 if (dev->class) { 1483 error = sysfs_create_link_nowarn(&dev->class->p->class_subsys.kobj, 1484 &dev->kobj, dev_name(dev)); 1485 if (error) 1486 goto out; 1487 sysfs_remove_link(&dev->class->p->class_subsys.kobj, 1488 old_device_name); 1489 } 1490 #endif 1491 1492 out: 1493 put_device(dev); 1494 1495 kfree(new_class_name); 1496 kfree(old_class_name); 1497 kfree(old_device_name); 1498 1499 return error; 1500 } 1501 EXPORT_SYMBOL_GPL(device_rename); 1502 1503 static int device_move_class_links(struct device *dev, 1504 struct device *old_parent, 1505 struct device *new_parent) 1506 { 1507 int error = 0; 1508 #ifdef CONFIG_SYSFS_DEPRECATED 1509 char *class_name; 1510 1511 class_name = make_class_name(dev->class->name, &dev->kobj); 1512 if (!class_name) { 1513 error = -ENOMEM; 1514 goto out; 1515 } 1516 if (old_parent) { 1517 sysfs_remove_link(&dev->kobj, "device"); 1518 sysfs_remove_link(&old_parent->kobj, class_name); 1519 } 1520 if (new_parent) { 1521 error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 1522 "device"); 1523 if (error) 1524 goto out; 1525 error = sysfs_create_link(&new_parent->kobj, &dev->kobj, 1526 class_name); 1527 if (error) 1528 sysfs_remove_link(&dev->kobj, "device"); 1529 } else 1530 error = 0; 1531 out: 1532 kfree(class_name); 1533 return error; 1534 #else 1535 if (old_parent) 1536 sysfs_remove_link(&dev->kobj, "device"); 1537 if (new_parent) 1538 error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 1539 "device"); 1540 return error; 1541 #endif 1542 } 1543 1544 /** 1545 * device_move - moves a device to a new parent 1546 * @dev: the pointer to the struct device to be moved 1547 * @new_parent: the new parent of the device (can by NULL) 1548 */ 1549 int device_move(struct device *dev, struct device *new_parent) 1550 { 1551 int error; 1552 struct device *old_parent; 1553 struct kobject *new_parent_kobj; 1554 1555 dev = get_device(dev); 1556 if (!dev) 1557 return -EINVAL; 1558 1559 new_parent = get_device(new_parent); 1560 new_parent_kobj = get_device_parent(dev, new_parent); 1561 1562 pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 1563 __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 1564 error = kobject_move(&dev->kobj, new_parent_kobj); 1565 if (error) { 1566 cleanup_glue_dir(dev, new_parent_kobj); 1567 put_device(new_parent); 1568 goto out; 1569 } 1570 old_parent = dev->parent; 1571 dev->parent = new_parent; 1572 if (old_parent) 1573 klist_remove(&dev->knode_parent); 1574 if (new_parent) { 1575 klist_add_tail(&dev->knode_parent, &new_parent->klist_children); 1576 set_dev_node(dev, dev_to_node(new_parent)); 1577 } 1578 1579 if (!dev->class) 1580 goto out_put; 1581 error = device_move_class_links(dev, old_parent, new_parent); 1582 if (error) { 1583 /* We ignore errors on cleanup since we're hosed anyway... */ 1584 device_move_class_links(dev, new_parent, old_parent); 1585 if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 1586 if (new_parent) 1587 klist_remove(&dev->knode_parent); 1588 dev->parent = old_parent; 1589 if (old_parent) { 1590 klist_add_tail(&dev->knode_parent, 1591 &old_parent->klist_children); 1592 set_dev_node(dev, dev_to_node(old_parent)); 1593 } 1594 } 1595 cleanup_glue_dir(dev, new_parent_kobj); 1596 put_device(new_parent); 1597 goto out; 1598 } 1599 out_put: 1600 put_device(old_parent); 1601 out: 1602 put_device(dev); 1603 return error; 1604 } 1605 EXPORT_SYMBOL_GPL(device_move); 1606 1607 /** 1608 * device_shutdown - call ->shutdown() on each device to shutdown. 1609 */ 1610 void device_shutdown(void) 1611 { 1612 struct device *dev, *devn; 1613 1614 list_for_each_entry_safe_reverse(dev, devn, &devices_kset->list, 1615 kobj.entry) { 1616 if (dev->bus && dev->bus->shutdown) { 1617 dev_dbg(dev, "shutdown\n"); 1618 dev->bus->shutdown(dev); 1619 } else if (dev->driver && dev->driver->shutdown) { 1620 dev_dbg(dev, "shutdown\n"); 1621 dev->driver->shutdown(dev); 1622 } 1623 } 1624 kobject_put(sysfs_dev_char_kobj); 1625 kobject_put(sysfs_dev_block_kobj); 1626 kobject_put(dev_kobj); 1627 } 1628