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