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/fwnode.h> 16 #include <linux/init.h> 17 #include <linux/module.h> 18 #include <linux/slab.h> 19 #include <linux/string.h> 20 #include <linux/kdev_t.h> 21 #include <linux/notifier.h> 22 #include <linux/of.h> 23 #include <linux/of_device.h> 24 #include <linux/genhd.h> 25 #include <linux/kallsyms.h> 26 #include <linux/mutex.h> 27 #include <linux/pm_runtime.h> 28 #include <linux/netdevice.h> 29 #include <linux/sysfs.h> 30 31 #include "base.h" 32 #include "power/power.h" 33 34 #ifdef CONFIG_SYSFS_DEPRECATED 35 #ifdef CONFIG_SYSFS_DEPRECATED_V2 36 long sysfs_deprecated = 1; 37 #else 38 long sysfs_deprecated = 0; 39 #endif 40 static int __init sysfs_deprecated_setup(char *arg) 41 { 42 return kstrtol(arg, 10, &sysfs_deprecated); 43 } 44 early_param("sysfs.deprecated", sysfs_deprecated_setup); 45 #endif 46 47 int (*platform_notify)(struct device *dev) = NULL; 48 int (*platform_notify_remove)(struct device *dev) = NULL; 49 static struct kobject *dev_kobj; 50 struct kobject *sysfs_dev_char_kobj; 51 struct kobject *sysfs_dev_block_kobj; 52 53 static DEFINE_MUTEX(device_hotplug_lock); 54 55 void lock_device_hotplug(void) 56 { 57 mutex_lock(&device_hotplug_lock); 58 } 59 60 void unlock_device_hotplug(void) 61 { 62 mutex_unlock(&device_hotplug_lock); 63 } 64 65 int lock_device_hotplug_sysfs(void) 66 { 67 if (mutex_trylock(&device_hotplug_lock)) 68 return 0; 69 70 /* Avoid busy looping (5 ms of sleep should do). */ 71 msleep(5); 72 return restart_syscall(); 73 } 74 75 #ifdef CONFIG_BLOCK 76 static inline int device_is_not_partition(struct device *dev) 77 { 78 return !(dev->type == &part_type); 79 } 80 #else 81 static inline int device_is_not_partition(struct device *dev) 82 { 83 return 1; 84 } 85 #endif 86 87 /** 88 * dev_driver_string - Return a device's driver name, if at all possible 89 * @dev: struct device to get the name of 90 * 91 * Will return the device's driver's name if it is bound to a device. If 92 * the device is not bound to a driver, it will return the name of the bus 93 * it is attached to. If it is not attached to a bus either, an empty 94 * string will be returned. 95 */ 96 const char *dev_driver_string(const struct device *dev) 97 { 98 struct device_driver *drv; 99 100 /* dev->driver can change to NULL underneath us because of unbinding, 101 * so be careful about accessing it. dev->bus and dev->class should 102 * never change once they are set, so they don't need special care. 103 */ 104 drv = ACCESS_ONCE(dev->driver); 105 return drv ? drv->name : 106 (dev->bus ? dev->bus->name : 107 (dev->class ? dev->class->name : "")); 108 } 109 EXPORT_SYMBOL(dev_driver_string); 110 111 #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 112 113 static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 114 char *buf) 115 { 116 struct device_attribute *dev_attr = to_dev_attr(attr); 117 struct device *dev = kobj_to_dev(kobj); 118 ssize_t ret = -EIO; 119 120 if (dev_attr->show) 121 ret = dev_attr->show(dev, dev_attr, buf); 122 if (ret >= (ssize_t)PAGE_SIZE) { 123 print_symbol("dev_attr_show: %s returned bad count\n", 124 (unsigned long)dev_attr->show); 125 } 126 return ret; 127 } 128 129 static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 130 const char *buf, size_t count) 131 { 132 struct device_attribute *dev_attr = to_dev_attr(attr); 133 struct device *dev = kobj_to_dev(kobj); 134 ssize_t ret = -EIO; 135 136 if (dev_attr->store) 137 ret = dev_attr->store(dev, dev_attr, buf, count); 138 return ret; 139 } 140 141 static const struct sysfs_ops dev_sysfs_ops = { 142 .show = dev_attr_show, 143 .store = dev_attr_store, 144 }; 145 146 #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 147 148 ssize_t device_store_ulong(struct device *dev, 149 struct device_attribute *attr, 150 const char *buf, size_t size) 151 { 152 struct dev_ext_attribute *ea = to_ext_attr(attr); 153 char *end; 154 unsigned long new = simple_strtoul(buf, &end, 0); 155 if (end == buf) 156 return -EINVAL; 157 *(unsigned long *)(ea->var) = new; 158 /* Always return full write size even if we didn't consume all */ 159 return size; 160 } 161 EXPORT_SYMBOL_GPL(device_store_ulong); 162 163 ssize_t device_show_ulong(struct device *dev, 164 struct device_attribute *attr, 165 char *buf) 166 { 167 struct dev_ext_attribute *ea = to_ext_attr(attr); 168 return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var)); 169 } 170 EXPORT_SYMBOL_GPL(device_show_ulong); 171 172 ssize_t device_store_int(struct device *dev, 173 struct device_attribute *attr, 174 const char *buf, size_t size) 175 { 176 struct dev_ext_attribute *ea = to_ext_attr(attr); 177 char *end; 178 long new = simple_strtol(buf, &end, 0); 179 if (end == buf || new > INT_MAX || new < INT_MIN) 180 return -EINVAL; 181 *(int *)(ea->var) = new; 182 /* Always return full write size even if we didn't consume all */ 183 return size; 184 } 185 EXPORT_SYMBOL_GPL(device_store_int); 186 187 ssize_t device_show_int(struct device *dev, 188 struct device_attribute *attr, 189 char *buf) 190 { 191 struct dev_ext_attribute *ea = to_ext_attr(attr); 192 193 return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var)); 194 } 195 EXPORT_SYMBOL_GPL(device_show_int); 196 197 ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 198 const char *buf, size_t size) 199 { 200 struct dev_ext_attribute *ea = to_ext_attr(attr); 201 202 if (strtobool(buf, ea->var) < 0) 203 return -EINVAL; 204 205 return size; 206 } 207 EXPORT_SYMBOL_GPL(device_store_bool); 208 209 ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 210 char *buf) 211 { 212 struct dev_ext_attribute *ea = to_ext_attr(attr); 213 214 return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var)); 215 } 216 EXPORT_SYMBOL_GPL(device_show_bool); 217 218 /** 219 * device_release - free device structure. 220 * @kobj: device's kobject. 221 * 222 * This is called once the reference count for the object 223 * reaches 0. We forward the call to the device's release 224 * method, which should handle actually freeing the structure. 225 */ 226 static void device_release(struct kobject *kobj) 227 { 228 struct device *dev = kobj_to_dev(kobj); 229 struct device_private *p = dev->p; 230 231 /* 232 * Some platform devices are driven without driver attached 233 * and managed resources may have been acquired. Make sure 234 * all resources are released. 235 * 236 * Drivers still can add resources into device after device 237 * is deleted but alive, so release devres here to avoid 238 * possible memory leak. 239 */ 240 devres_release_all(dev); 241 242 if (dev->release) 243 dev->release(dev); 244 else if (dev->type && dev->type->release) 245 dev->type->release(dev); 246 else if (dev->class && dev->class->dev_release) 247 dev->class->dev_release(dev); 248 else 249 WARN(1, KERN_ERR "Device '%s' does not have a release() " 250 "function, it is broken and must be fixed.\n", 251 dev_name(dev)); 252 kfree(p); 253 } 254 255 static const void *device_namespace(struct kobject *kobj) 256 { 257 struct device *dev = kobj_to_dev(kobj); 258 const void *ns = NULL; 259 260 if (dev->class && dev->class->ns_type) 261 ns = dev->class->namespace(dev); 262 263 return ns; 264 } 265 266 static struct kobj_type device_ktype = { 267 .release = device_release, 268 .sysfs_ops = &dev_sysfs_ops, 269 .namespace = device_namespace, 270 }; 271 272 273 static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 274 { 275 struct kobj_type *ktype = get_ktype(kobj); 276 277 if (ktype == &device_ktype) { 278 struct device *dev = kobj_to_dev(kobj); 279 if (dev->bus) 280 return 1; 281 if (dev->class) 282 return 1; 283 } 284 return 0; 285 } 286 287 static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 288 { 289 struct device *dev = kobj_to_dev(kobj); 290 291 if (dev->bus) 292 return dev->bus->name; 293 if (dev->class) 294 return dev->class->name; 295 return NULL; 296 } 297 298 static int dev_uevent(struct kset *kset, struct kobject *kobj, 299 struct kobj_uevent_env *env) 300 { 301 struct device *dev = kobj_to_dev(kobj); 302 int retval = 0; 303 304 /* add device node properties if present */ 305 if (MAJOR(dev->devt)) { 306 const char *tmp; 307 const char *name; 308 umode_t mode = 0; 309 kuid_t uid = GLOBAL_ROOT_UID; 310 kgid_t gid = GLOBAL_ROOT_GID; 311 312 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 313 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 314 name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 315 if (name) { 316 add_uevent_var(env, "DEVNAME=%s", name); 317 if (mode) 318 add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 319 if (!uid_eq(uid, GLOBAL_ROOT_UID)) 320 add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 321 if (!gid_eq(gid, GLOBAL_ROOT_GID)) 322 add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 323 kfree(tmp); 324 } 325 } 326 327 if (dev->type && dev->type->name) 328 add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 329 330 if (dev->driver) 331 add_uevent_var(env, "DRIVER=%s", dev->driver->name); 332 333 /* Add common DT information about the device */ 334 of_device_uevent(dev, env); 335 336 /* have the bus specific function add its stuff */ 337 if (dev->bus && dev->bus->uevent) { 338 retval = dev->bus->uevent(dev, env); 339 if (retval) 340 pr_debug("device: '%s': %s: bus uevent() returned %d\n", 341 dev_name(dev), __func__, retval); 342 } 343 344 /* have the class specific function add its stuff */ 345 if (dev->class && dev->class->dev_uevent) { 346 retval = dev->class->dev_uevent(dev, env); 347 if (retval) 348 pr_debug("device: '%s': %s: class uevent() " 349 "returned %d\n", dev_name(dev), 350 __func__, retval); 351 } 352 353 /* have the device type specific function add its stuff */ 354 if (dev->type && dev->type->uevent) { 355 retval = dev->type->uevent(dev, env); 356 if (retval) 357 pr_debug("device: '%s': %s: dev_type uevent() " 358 "returned %d\n", dev_name(dev), 359 __func__, retval); 360 } 361 362 return retval; 363 } 364 365 static const struct kset_uevent_ops device_uevent_ops = { 366 .filter = dev_uevent_filter, 367 .name = dev_uevent_name, 368 .uevent = dev_uevent, 369 }; 370 371 static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 372 char *buf) 373 { 374 struct kobject *top_kobj; 375 struct kset *kset; 376 struct kobj_uevent_env *env = NULL; 377 int i; 378 size_t count = 0; 379 int retval; 380 381 /* search the kset, the device belongs to */ 382 top_kobj = &dev->kobj; 383 while (!top_kobj->kset && top_kobj->parent) 384 top_kobj = top_kobj->parent; 385 if (!top_kobj->kset) 386 goto out; 387 388 kset = top_kobj->kset; 389 if (!kset->uevent_ops || !kset->uevent_ops->uevent) 390 goto out; 391 392 /* respect filter */ 393 if (kset->uevent_ops && kset->uevent_ops->filter) 394 if (!kset->uevent_ops->filter(kset, &dev->kobj)) 395 goto out; 396 397 env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 398 if (!env) 399 return -ENOMEM; 400 401 /* let the kset specific function add its keys */ 402 retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 403 if (retval) 404 goto out; 405 406 /* copy keys to file */ 407 for (i = 0; i < env->envp_idx; i++) 408 count += sprintf(&buf[count], "%s\n", env->envp[i]); 409 out: 410 kfree(env); 411 return count; 412 } 413 414 static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 415 const char *buf, size_t count) 416 { 417 enum kobject_action action; 418 419 if (kobject_action_type(buf, count, &action) == 0) 420 kobject_uevent(&dev->kobj, action); 421 else 422 dev_err(dev, "uevent: unknown action-string\n"); 423 return count; 424 } 425 static DEVICE_ATTR_RW(uevent); 426 427 static ssize_t online_show(struct device *dev, struct device_attribute *attr, 428 char *buf) 429 { 430 bool val; 431 432 device_lock(dev); 433 val = !dev->offline; 434 device_unlock(dev); 435 return sprintf(buf, "%u\n", val); 436 } 437 438 static ssize_t online_store(struct device *dev, struct device_attribute *attr, 439 const char *buf, size_t count) 440 { 441 bool val; 442 int ret; 443 444 ret = strtobool(buf, &val); 445 if (ret < 0) 446 return ret; 447 448 ret = lock_device_hotplug_sysfs(); 449 if (ret) 450 return ret; 451 452 ret = val ? device_online(dev) : device_offline(dev); 453 unlock_device_hotplug(); 454 return ret < 0 ? ret : count; 455 } 456 static DEVICE_ATTR_RW(online); 457 458 int device_add_groups(struct device *dev, const struct attribute_group **groups) 459 { 460 return sysfs_create_groups(&dev->kobj, groups); 461 } 462 463 void device_remove_groups(struct device *dev, 464 const struct attribute_group **groups) 465 { 466 sysfs_remove_groups(&dev->kobj, groups); 467 } 468 469 static int device_add_attrs(struct device *dev) 470 { 471 struct class *class = dev->class; 472 const struct device_type *type = dev->type; 473 int error; 474 475 if (class) { 476 error = device_add_groups(dev, class->dev_groups); 477 if (error) 478 return error; 479 } 480 481 if (type) { 482 error = device_add_groups(dev, type->groups); 483 if (error) 484 goto err_remove_class_groups; 485 } 486 487 error = device_add_groups(dev, dev->groups); 488 if (error) 489 goto err_remove_type_groups; 490 491 if (device_supports_offline(dev) && !dev->offline_disabled) { 492 error = device_create_file(dev, &dev_attr_online); 493 if (error) 494 goto err_remove_dev_groups; 495 } 496 497 return 0; 498 499 err_remove_dev_groups: 500 device_remove_groups(dev, dev->groups); 501 err_remove_type_groups: 502 if (type) 503 device_remove_groups(dev, type->groups); 504 err_remove_class_groups: 505 if (class) 506 device_remove_groups(dev, class->dev_groups); 507 508 return error; 509 } 510 511 static void device_remove_attrs(struct device *dev) 512 { 513 struct class *class = dev->class; 514 const struct device_type *type = dev->type; 515 516 device_remove_file(dev, &dev_attr_online); 517 device_remove_groups(dev, dev->groups); 518 519 if (type) 520 device_remove_groups(dev, type->groups); 521 522 if (class) 523 device_remove_groups(dev, class->dev_groups); 524 } 525 526 static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 527 char *buf) 528 { 529 return print_dev_t(buf, dev->devt); 530 } 531 static DEVICE_ATTR_RO(dev); 532 533 /* /sys/devices/ */ 534 struct kset *devices_kset; 535 536 /** 537 * device_create_file - create sysfs attribute file for device. 538 * @dev: device. 539 * @attr: device attribute descriptor. 540 */ 541 int device_create_file(struct device *dev, 542 const struct device_attribute *attr) 543 { 544 int error = 0; 545 546 if (dev) { 547 WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 548 "Attribute %s: write permission without 'store'\n", 549 attr->attr.name); 550 WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 551 "Attribute %s: read permission without 'show'\n", 552 attr->attr.name); 553 error = sysfs_create_file(&dev->kobj, &attr->attr); 554 } 555 556 return error; 557 } 558 EXPORT_SYMBOL_GPL(device_create_file); 559 560 /** 561 * device_remove_file - remove sysfs attribute file. 562 * @dev: device. 563 * @attr: device attribute descriptor. 564 */ 565 void device_remove_file(struct device *dev, 566 const struct device_attribute *attr) 567 { 568 if (dev) 569 sysfs_remove_file(&dev->kobj, &attr->attr); 570 } 571 EXPORT_SYMBOL_GPL(device_remove_file); 572 573 /** 574 * device_remove_file_self - remove sysfs attribute file from its own method. 575 * @dev: device. 576 * @attr: device attribute descriptor. 577 * 578 * See kernfs_remove_self() for details. 579 */ 580 bool device_remove_file_self(struct device *dev, 581 const struct device_attribute *attr) 582 { 583 if (dev) 584 return sysfs_remove_file_self(&dev->kobj, &attr->attr); 585 else 586 return false; 587 } 588 EXPORT_SYMBOL_GPL(device_remove_file_self); 589 590 /** 591 * device_create_bin_file - create sysfs binary attribute file for device. 592 * @dev: device. 593 * @attr: device binary attribute descriptor. 594 */ 595 int device_create_bin_file(struct device *dev, 596 const struct bin_attribute *attr) 597 { 598 int error = -EINVAL; 599 if (dev) 600 error = sysfs_create_bin_file(&dev->kobj, attr); 601 return error; 602 } 603 EXPORT_SYMBOL_GPL(device_create_bin_file); 604 605 /** 606 * device_remove_bin_file - remove sysfs binary attribute file 607 * @dev: device. 608 * @attr: device binary attribute descriptor. 609 */ 610 void device_remove_bin_file(struct device *dev, 611 const struct bin_attribute *attr) 612 { 613 if (dev) 614 sysfs_remove_bin_file(&dev->kobj, attr); 615 } 616 EXPORT_SYMBOL_GPL(device_remove_bin_file); 617 618 static void klist_children_get(struct klist_node *n) 619 { 620 struct device_private *p = to_device_private_parent(n); 621 struct device *dev = p->device; 622 623 get_device(dev); 624 } 625 626 static void klist_children_put(struct klist_node *n) 627 { 628 struct device_private *p = to_device_private_parent(n); 629 struct device *dev = p->device; 630 631 put_device(dev); 632 } 633 634 /** 635 * device_initialize - init device structure. 636 * @dev: device. 637 * 638 * This prepares the device for use by other layers by initializing 639 * its fields. 640 * It is the first half of device_register(), if called by 641 * that function, though it can also be called separately, so one 642 * may use @dev's fields. In particular, get_device()/put_device() 643 * may be used for reference counting of @dev after calling this 644 * function. 645 * 646 * All fields in @dev must be initialized by the caller to 0, except 647 * for those explicitly set to some other value. The simplest 648 * approach is to use kzalloc() to allocate the structure containing 649 * @dev. 650 * 651 * NOTE: Use put_device() to give up your reference instead of freeing 652 * @dev directly once you have called this function. 653 */ 654 void device_initialize(struct device *dev) 655 { 656 dev->kobj.kset = devices_kset; 657 kobject_init(&dev->kobj, &device_ktype); 658 INIT_LIST_HEAD(&dev->dma_pools); 659 mutex_init(&dev->mutex); 660 lockdep_set_novalidate_class(&dev->mutex); 661 spin_lock_init(&dev->devres_lock); 662 INIT_LIST_HEAD(&dev->devres_head); 663 device_pm_init(dev); 664 set_dev_node(dev, -1); 665 } 666 EXPORT_SYMBOL_GPL(device_initialize); 667 668 struct kobject *virtual_device_parent(struct device *dev) 669 { 670 static struct kobject *virtual_dir = NULL; 671 672 if (!virtual_dir) 673 virtual_dir = kobject_create_and_add("virtual", 674 &devices_kset->kobj); 675 676 return virtual_dir; 677 } 678 679 struct class_dir { 680 struct kobject kobj; 681 struct class *class; 682 }; 683 684 #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 685 686 static void class_dir_release(struct kobject *kobj) 687 { 688 struct class_dir *dir = to_class_dir(kobj); 689 kfree(dir); 690 } 691 692 static const 693 struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 694 { 695 struct class_dir *dir = to_class_dir(kobj); 696 return dir->class->ns_type; 697 } 698 699 static struct kobj_type class_dir_ktype = { 700 .release = class_dir_release, 701 .sysfs_ops = &kobj_sysfs_ops, 702 .child_ns_type = class_dir_child_ns_type 703 }; 704 705 static struct kobject * 706 class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 707 { 708 struct class_dir *dir; 709 int retval; 710 711 dir = kzalloc(sizeof(*dir), GFP_KERNEL); 712 if (!dir) 713 return NULL; 714 715 dir->class = class; 716 kobject_init(&dir->kobj, &class_dir_ktype); 717 718 dir->kobj.kset = &class->p->glue_dirs; 719 720 retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 721 if (retval < 0) { 722 kobject_put(&dir->kobj); 723 return NULL; 724 } 725 return &dir->kobj; 726 } 727 728 static DEFINE_MUTEX(gdp_mutex); 729 730 static struct kobject *get_device_parent(struct device *dev, 731 struct device *parent) 732 { 733 if (dev->class) { 734 struct kobject *kobj = NULL; 735 struct kobject *parent_kobj; 736 struct kobject *k; 737 738 #ifdef CONFIG_BLOCK 739 /* block disks show up in /sys/block */ 740 if (sysfs_deprecated && dev->class == &block_class) { 741 if (parent && parent->class == &block_class) 742 return &parent->kobj; 743 return &block_class.p->subsys.kobj; 744 } 745 #endif 746 747 /* 748 * If we have no parent, we live in "virtual". 749 * Class-devices with a non class-device as parent, live 750 * in a "glue" directory to prevent namespace collisions. 751 */ 752 if (parent == NULL) 753 parent_kobj = virtual_device_parent(dev); 754 else if (parent->class && !dev->class->ns_type) 755 return &parent->kobj; 756 else 757 parent_kobj = &parent->kobj; 758 759 mutex_lock(&gdp_mutex); 760 761 /* find our class-directory at the parent and reference it */ 762 spin_lock(&dev->class->p->glue_dirs.list_lock); 763 list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 764 if (k->parent == parent_kobj) { 765 kobj = kobject_get(k); 766 break; 767 } 768 spin_unlock(&dev->class->p->glue_dirs.list_lock); 769 if (kobj) { 770 mutex_unlock(&gdp_mutex); 771 return kobj; 772 } 773 774 /* or create a new class-directory at the parent device */ 775 k = class_dir_create_and_add(dev->class, parent_kobj); 776 /* do not emit an uevent for this simple "glue" directory */ 777 mutex_unlock(&gdp_mutex); 778 return k; 779 } 780 781 /* subsystems can specify a default root directory for their devices */ 782 if (!parent && dev->bus && dev->bus->dev_root) 783 return &dev->bus->dev_root->kobj; 784 785 if (parent) 786 return &parent->kobj; 787 return NULL; 788 } 789 790 static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 791 { 792 /* see if we live in a "glue" directory */ 793 if (!glue_dir || !dev->class || 794 glue_dir->kset != &dev->class->p->glue_dirs) 795 return; 796 797 mutex_lock(&gdp_mutex); 798 kobject_put(glue_dir); 799 mutex_unlock(&gdp_mutex); 800 } 801 802 static void cleanup_device_parent(struct device *dev) 803 { 804 cleanup_glue_dir(dev, dev->kobj.parent); 805 } 806 807 static int device_add_class_symlinks(struct device *dev) 808 { 809 struct device_node *of_node = dev_of_node(dev); 810 int error; 811 812 if (of_node) { 813 error = sysfs_create_link(&dev->kobj, &of_node->kobj,"of_node"); 814 if (error) 815 dev_warn(dev, "Error %d creating of_node link\n",error); 816 /* An error here doesn't warrant bringing down the device */ 817 } 818 819 if (!dev->class) 820 return 0; 821 822 error = sysfs_create_link(&dev->kobj, 823 &dev->class->p->subsys.kobj, 824 "subsystem"); 825 if (error) 826 goto out_devnode; 827 828 if (dev->parent && device_is_not_partition(dev)) { 829 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 830 "device"); 831 if (error) 832 goto out_subsys; 833 } 834 835 #ifdef CONFIG_BLOCK 836 /* /sys/block has directories and does not need symlinks */ 837 if (sysfs_deprecated && dev->class == &block_class) 838 return 0; 839 #endif 840 841 /* link in the class directory pointing to the device */ 842 error = sysfs_create_link(&dev->class->p->subsys.kobj, 843 &dev->kobj, dev_name(dev)); 844 if (error) 845 goto out_device; 846 847 return 0; 848 849 out_device: 850 sysfs_remove_link(&dev->kobj, "device"); 851 852 out_subsys: 853 sysfs_remove_link(&dev->kobj, "subsystem"); 854 out_devnode: 855 sysfs_remove_link(&dev->kobj, "of_node"); 856 return error; 857 } 858 859 static void device_remove_class_symlinks(struct device *dev) 860 { 861 if (dev_of_node(dev)) 862 sysfs_remove_link(&dev->kobj, "of_node"); 863 864 if (!dev->class) 865 return; 866 867 if (dev->parent && device_is_not_partition(dev)) 868 sysfs_remove_link(&dev->kobj, "device"); 869 sysfs_remove_link(&dev->kobj, "subsystem"); 870 #ifdef CONFIG_BLOCK 871 if (sysfs_deprecated && dev->class == &block_class) 872 return; 873 #endif 874 sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 875 } 876 877 /** 878 * dev_set_name - set a device name 879 * @dev: device 880 * @fmt: format string for the device's name 881 */ 882 int dev_set_name(struct device *dev, const char *fmt, ...) 883 { 884 va_list vargs; 885 int err; 886 887 va_start(vargs, fmt); 888 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 889 va_end(vargs); 890 return err; 891 } 892 EXPORT_SYMBOL_GPL(dev_set_name); 893 894 /** 895 * device_to_dev_kobj - select a /sys/dev/ directory for the device 896 * @dev: device 897 * 898 * By default we select char/ for new entries. Setting class->dev_obj 899 * to NULL prevents an entry from being created. class->dev_kobj must 900 * be set (or cleared) before any devices are registered to the class 901 * otherwise device_create_sys_dev_entry() and 902 * device_remove_sys_dev_entry() will disagree about the presence of 903 * the link. 904 */ 905 static struct kobject *device_to_dev_kobj(struct device *dev) 906 { 907 struct kobject *kobj; 908 909 if (dev->class) 910 kobj = dev->class->dev_kobj; 911 else 912 kobj = sysfs_dev_char_kobj; 913 914 return kobj; 915 } 916 917 static int device_create_sys_dev_entry(struct device *dev) 918 { 919 struct kobject *kobj = device_to_dev_kobj(dev); 920 int error = 0; 921 char devt_str[15]; 922 923 if (kobj) { 924 format_dev_t(devt_str, dev->devt); 925 error = sysfs_create_link(kobj, &dev->kobj, devt_str); 926 } 927 928 return error; 929 } 930 931 static void device_remove_sys_dev_entry(struct device *dev) 932 { 933 struct kobject *kobj = device_to_dev_kobj(dev); 934 char devt_str[15]; 935 936 if (kobj) { 937 format_dev_t(devt_str, dev->devt); 938 sysfs_remove_link(kobj, devt_str); 939 } 940 } 941 942 int device_private_init(struct device *dev) 943 { 944 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 945 if (!dev->p) 946 return -ENOMEM; 947 dev->p->device = dev; 948 klist_init(&dev->p->klist_children, klist_children_get, 949 klist_children_put); 950 INIT_LIST_HEAD(&dev->p->deferred_probe); 951 return 0; 952 } 953 954 /** 955 * device_add - add device to device hierarchy. 956 * @dev: device. 957 * 958 * This is part 2 of device_register(), though may be called 959 * separately _iff_ device_initialize() has been called separately. 960 * 961 * This adds @dev to the kobject hierarchy via kobject_add(), adds it 962 * to the global and sibling lists for the device, then 963 * adds it to the other relevant subsystems of the driver model. 964 * 965 * Do not call this routine or device_register() more than once for 966 * any device structure. The driver model core is not designed to work 967 * with devices that get unregistered and then spring back to life. 968 * (Among other things, it's very hard to guarantee that all references 969 * to the previous incarnation of @dev have been dropped.) Allocate 970 * and register a fresh new struct device instead. 971 * 972 * NOTE: _Never_ directly free @dev after calling this function, even 973 * if it returned an error! Always use put_device() to give up your 974 * reference instead. 975 */ 976 int device_add(struct device *dev) 977 { 978 struct device *parent = NULL; 979 struct kobject *kobj; 980 struct class_interface *class_intf; 981 int error = -EINVAL; 982 983 dev = get_device(dev); 984 if (!dev) 985 goto done; 986 987 if (!dev->p) { 988 error = device_private_init(dev); 989 if (error) 990 goto done; 991 } 992 993 /* 994 * for statically allocated devices, which should all be converted 995 * some day, we need to initialize the name. We prevent reading back 996 * the name, and force the use of dev_name() 997 */ 998 if (dev->init_name) { 999 dev_set_name(dev, "%s", dev->init_name); 1000 dev->init_name = NULL; 1001 } 1002 1003 /* subsystems can specify simple device enumeration */ 1004 if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 1005 dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 1006 1007 if (!dev_name(dev)) { 1008 error = -EINVAL; 1009 goto name_error; 1010 } 1011 1012 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1013 1014 parent = get_device(dev->parent); 1015 kobj = get_device_parent(dev, parent); 1016 if (kobj) 1017 dev->kobj.parent = kobj; 1018 1019 /* use parent numa_node */ 1020 if (parent) 1021 set_dev_node(dev, dev_to_node(parent)); 1022 1023 /* first, register with generic layer. */ 1024 /* we require the name to be set before, and pass NULL */ 1025 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 1026 if (error) 1027 goto Error; 1028 1029 /* notify platform of device entry */ 1030 if (platform_notify) 1031 platform_notify(dev); 1032 1033 error = device_create_file(dev, &dev_attr_uevent); 1034 if (error) 1035 goto attrError; 1036 1037 error = device_add_class_symlinks(dev); 1038 if (error) 1039 goto SymlinkError; 1040 error = device_add_attrs(dev); 1041 if (error) 1042 goto AttrsError; 1043 error = bus_add_device(dev); 1044 if (error) 1045 goto BusError; 1046 error = dpm_sysfs_add(dev); 1047 if (error) 1048 goto DPMError; 1049 device_pm_add(dev); 1050 1051 if (MAJOR(dev->devt)) { 1052 error = device_create_file(dev, &dev_attr_dev); 1053 if (error) 1054 goto DevAttrError; 1055 1056 error = device_create_sys_dev_entry(dev); 1057 if (error) 1058 goto SysEntryError; 1059 1060 devtmpfs_create_node(dev); 1061 } 1062 1063 /* Notify clients of device addition. This call must come 1064 * after dpm_sysfs_add() and before kobject_uevent(). 1065 */ 1066 if (dev->bus) 1067 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1068 BUS_NOTIFY_ADD_DEVICE, dev); 1069 1070 kobject_uevent(&dev->kobj, KOBJ_ADD); 1071 bus_probe_device(dev); 1072 if (parent) 1073 klist_add_tail(&dev->p->knode_parent, 1074 &parent->p->klist_children); 1075 1076 if (dev->class) { 1077 mutex_lock(&dev->class->p->mutex); 1078 /* tie the class to the device */ 1079 klist_add_tail(&dev->knode_class, 1080 &dev->class->p->klist_devices); 1081 1082 /* notify any interfaces that the device is here */ 1083 list_for_each_entry(class_intf, 1084 &dev->class->p->interfaces, node) 1085 if (class_intf->add_dev) 1086 class_intf->add_dev(dev, class_intf); 1087 mutex_unlock(&dev->class->p->mutex); 1088 } 1089 done: 1090 put_device(dev); 1091 return error; 1092 SysEntryError: 1093 if (MAJOR(dev->devt)) 1094 device_remove_file(dev, &dev_attr_dev); 1095 DevAttrError: 1096 device_pm_remove(dev); 1097 dpm_sysfs_remove(dev); 1098 DPMError: 1099 bus_remove_device(dev); 1100 BusError: 1101 device_remove_attrs(dev); 1102 AttrsError: 1103 device_remove_class_symlinks(dev); 1104 SymlinkError: 1105 device_remove_file(dev, &dev_attr_uevent); 1106 attrError: 1107 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 1108 kobject_del(&dev->kobj); 1109 Error: 1110 cleanup_device_parent(dev); 1111 put_device(parent); 1112 name_error: 1113 kfree(dev->p); 1114 dev->p = NULL; 1115 goto done; 1116 } 1117 EXPORT_SYMBOL_GPL(device_add); 1118 1119 /** 1120 * device_register - register a device with the system. 1121 * @dev: pointer to the device structure 1122 * 1123 * This happens in two clean steps - initialize the device 1124 * and add it to the system. The two steps can be called 1125 * separately, but this is the easiest and most common. 1126 * I.e. you should only call the two helpers separately if 1127 * have a clearly defined need to use and refcount the device 1128 * before it is added to the hierarchy. 1129 * 1130 * For more information, see the kerneldoc for device_initialize() 1131 * and device_add(). 1132 * 1133 * NOTE: _Never_ directly free @dev after calling this function, even 1134 * if it returned an error! Always use put_device() to give up the 1135 * reference initialized in this function instead. 1136 */ 1137 int device_register(struct device *dev) 1138 { 1139 device_initialize(dev); 1140 return device_add(dev); 1141 } 1142 EXPORT_SYMBOL_GPL(device_register); 1143 1144 /** 1145 * get_device - increment reference count for device. 1146 * @dev: device. 1147 * 1148 * This simply forwards the call to kobject_get(), though 1149 * we do take care to provide for the case that we get a NULL 1150 * pointer passed in. 1151 */ 1152 struct device *get_device(struct device *dev) 1153 { 1154 return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 1155 } 1156 EXPORT_SYMBOL_GPL(get_device); 1157 1158 /** 1159 * put_device - decrement reference count. 1160 * @dev: device in question. 1161 */ 1162 void put_device(struct device *dev) 1163 { 1164 /* might_sleep(); */ 1165 if (dev) 1166 kobject_put(&dev->kobj); 1167 } 1168 EXPORT_SYMBOL_GPL(put_device); 1169 1170 /** 1171 * device_del - delete device from system. 1172 * @dev: device. 1173 * 1174 * This is the first part of the device unregistration 1175 * sequence. This removes the device from the lists we control 1176 * from here, has it removed from the other driver model 1177 * subsystems it was added to in device_add(), and removes it 1178 * from the kobject hierarchy. 1179 * 1180 * NOTE: this should be called manually _iff_ device_add() was 1181 * also called manually. 1182 */ 1183 void device_del(struct device *dev) 1184 { 1185 struct device *parent = dev->parent; 1186 struct class_interface *class_intf; 1187 1188 /* Notify clients of device removal. This call must come 1189 * before dpm_sysfs_remove(). 1190 */ 1191 if (dev->bus) 1192 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1193 BUS_NOTIFY_DEL_DEVICE, dev); 1194 dpm_sysfs_remove(dev); 1195 if (parent) 1196 klist_del(&dev->p->knode_parent); 1197 if (MAJOR(dev->devt)) { 1198 devtmpfs_delete_node(dev); 1199 device_remove_sys_dev_entry(dev); 1200 device_remove_file(dev, &dev_attr_dev); 1201 } 1202 if (dev->class) { 1203 device_remove_class_symlinks(dev); 1204 1205 mutex_lock(&dev->class->p->mutex); 1206 /* notify any interfaces that the device is now gone */ 1207 list_for_each_entry(class_intf, 1208 &dev->class->p->interfaces, node) 1209 if (class_intf->remove_dev) 1210 class_intf->remove_dev(dev, class_intf); 1211 /* remove the device from the class list */ 1212 klist_del(&dev->knode_class); 1213 mutex_unlock(&dev->class->p->mutex); 1214 } 1215 device_remove_file(dev, &dev_attr_uevent); 1216 device_remove_attrs(dev); 1217 bus_remove_device(dev); 1218 device_pm_remove(dev); 1219 driver_deferred_probe_del(dev); 1220 1221 /* Notify the platform of the removal, in case they 1222 * need to do anything... 1223 */ 1224 if (platform_notify_remove) 1225 platform_notify_remove(dev); 1226 if (dev->bus) 1227 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1228 BUS_NOTIFY_REMOVED_DEVICE, dev); 1229 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 1230 cleanup_device_parent(dev); 1231 kobject_del(&dev->kobj); 1232 put_device(parent); 1233 } 1234 EXPORT_SYMBOL_GPL(device_del); 1235 1236 /** 1237 * device_unregister - unregister device from system. 1238 * @dev: device going away. 1239 * 1240 * We do this in two parts, like we do device_register(). First, 1241 * we remove it from all the subsystems with device_del(), then 1242 * we decrement the reference count via put_device(). If that 1243 * is the final reference count, the device will be cleaned up 1244 * via device_release() above. Otherwise, the structure will 1245 * stick around until the final reference to the device is dropped. 1246 */ 1247 void device_unregister(struct device *dev) 1248 { 1249 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1250 device_del(dev); 1251 put_device(dev); 1252 } 1253 EXPORT_SYMBOL_GPL(device_unregister); 1254 1255 static struct device *next_device(struct klist_iter *i) 1256 { 1257 struct klist_node *n = klist_next(i); 1258 struct device *dev = NULL; 1259 struct device_private *p; 1260 1261 if (n) { 1262 p = to_device_private_parent(n); 1263 dev = p->device; 1264 } 1265 return dev; 1266 } 1267 1268 /** 1269 * device_get_devnode - path of device node file 1270 * @dev: device 1271 * @mode: returned file access mode 1272 * @uid: returned file owner 1273 * @gid: returned file group 1274 * @tmp: possibly allocated string 1275 * 1276 * Return the relative path of a possible device node. 1277 * Non-default names may need to allocate a memory to compose 1278 * a name. This memory is returned in tmp and needs to be 1279 * freed by the caller. 1280 */ 1281 const char *device_get_devnode(struct device *dev, 1282 umode_t *mode, kuid_t *uid, kgid_t *gid, 1283 const char **tmp) 1284 { 1285 char *s; 1286 1287 *tmp = NULL; 1288 1289 /* the device type may provide a specific name */ 1290 if (dev->type && dev->type->devnode) 1291 *tmp = dev->type->devnode(dev, mode, uid, gid); 1292 if (*tmp) 1293 return *tmp; 1294 1295 /* the class may provide a specific name */ 1296 if (dev->class && dev->class->devnode) 1297 *tmp = dev->class->devnode(dev, mode); 1298 if (*tmp) 1299 return *tmp; 1300 1301 /* return name without allocation, tmp == NULL */ 1302 if (strchr(dev_name(dev), '!') == NULL) 1303 return dev_name(dev); 1304 1305 /* replace '!' in the name with '/' */ 1306 *tmp = kstrdup(dev_name(dev), GFP_KERNEL); 1307 if (!*tmp) 1308 return NULL; 1309 while ((s = strchr(*tmp, '!'))) 1310 s[0] = '/'; 1311 return *tmp; 1312 } 1313 1314 /** 1315 * device_for_each_child - device child iterator. 1316 * @parent: parent struct device. 1317 * @fn: function to be called for each device. 1318 * @data: data for the callback. 1319 * 1320 * Iterate over @parent's child devices, and call @fn for each, 1321 * passing it @data. 1322 * 1323 * We check the return of @fn each time. If it returns anything 1324 * other than 0, we break out and return that value. 1325 */ 1326 int device_for_each_child(struct device *parent, void *data, 1327 int (*fn)(struct device *dev, void *data)) 1328 { 1329 struct klist_iter i; 1330 struct device *child; 1331 int error = 0; 1332 1333 if (!parent->p) 1334 return 0; 1335 1336 klist_iter_init(&parent->p->klist_children, &i); 1337 while ((child = next_device(&i)) && !error) 1338 error = fn(child, data); 1339 klist_iter_exit(&i); 1340 return error; 1341 } 1342 EXPORT_SYMBOL_GPL(device_for_each_child); 1343 1344 /** 1345 * device_find_child - device iterator for locating a particular device. 1346 * @parent: parent struct device 1347 * @match: Callback function to check device 1348 * @data: Data to pass to match function 1349 * 1350 * This is similar to the device_for_each_child() function above, but it 1351 * returns a reference to a device that is 'found' for later use, as 1352 * determined by the @match callback. 1353 * 1354 * The callback should return 0 if the device doesn't match and non-zero 1355 * if it does. If the callback returns non-zero and a reference to the 1356 * current device can be obtained, this function will return to the caller 1357 * and not iterate over any more devices. 1358 * 1359 * NOTE: you will need to drop the reference with put_device() after use. 1360 */ 1361 struct device *device_find_child(struct device *parent, void *data, 1362 int (*match)(struct device *dev, void *data)) 1363 { 1364 struct klist_iter i; 1365 struct device *child; 1366 1367 if (!parent) 1368 return NULL; 1369 1370 klist_iter_init(&parent->p->klist_children, &i); 1371 while ((child = next_device(&i))) 1372 if (match(child, data) && get_device(child)) 1373 break; 1374 klist_iter_exit(&i); 1375 return child; 1376 } 1377 EXPORT_SYMBOL_GPL(device_find_child); 1378 1379 int __init devices_init(void) 1380 { 1381 devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 1382 if (!devices_kset) 1383 return -ENOMEM; 1384 dev_kobj = kobject_create_and_add("dev", NULL); 1385 if (!dev_kobj) 1386 goto dev_kobj_err; 1387 sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 1388 if (!sysfs_dev_block_kobj) 1389 goto block_kobj_err; 1390 sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 1391 if (!sysfs_dev_char_kobj) 1392 goto char_kobj_err; 1393 1394 return 0; 1395 1396 char_kobj_err: 1397 kobject_put(sysfs_dev_block_kobj); 1398 block_kobj_err: 1399 kobject_put(dev_kobj); 1400 dev_kobj_err: 1401 kset_unregister(devices_kset); 1402 return -ENOMEM; 1403 } 1404 1405 static int device_check_offline(struct device *dev, void *not_used) 1406 { 1407 int ret; 1408 1409 ret = device_for_each_child(dev, NULL, device_check_offline); 1410 if (ret) 1411 return ret; 1412 1413 return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 1414 } 1415 1416 /** 1417 * device_offline - Prepare the device for hot-removal. 1418 * @dev: Device to be put offline. 1419 * 1420 * Execute the device bus type's .offline() callback, if present, to prepare 1421 * the device for a subsequent hot-removal. If that succeeds, the device must 1422 * not be used until either it is removed or its bus type's .online() callback 1423 * is executed. 1424 * 1425 * Call under device_hotplug_lock. 1426 */ 1427 int device_offline(struct device *dev) 1428 { 1429 int ret; 1430 1431 if (dev->offline_disabled) 1432 return -EPERM; 1433 1434 ret = device_for_each_child(dev, NULL, device_check_offline); 1435 if (ret) 1436 return ret; 1437 1438 device_lock(dev); 1439 if (device_supports_offline(dev)) { 1440 if (dev->offline) { 1441 ret = 1; 1442 } else { 1443 ret = dev->bus->offline(dev); 1444 if (!ret) { 1445 kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 1446 dev->offline = true; 1447 } 1448 } 1449 } 1450 device_unlock(dev); 1451 1452 return ret; 1453 } 1454 1455 /** 1456 * device_online - Put the device back online after successful device_offline(). 1457 * @dev: Device to be put back online. 1458 * 1459 * If device_offline() has been successfully executed for @dev, but the device 1460 * has not been removed subsequently, execute its bus type's .online() callback 1461 * to indicate that the device can be used again. 1462 * 1463 * Call under device_hotplug_lock. 1464 */ 1465 int device_online(struct device *dev) 1466 { 1467 int ret = 0; 1468 1469 device_lock(dev); 1470 if (device_supports_offline(dev)) { 1471 if (dev->offline) { 1472 ret = dev->bus->online(dev); 1473 if (!ret) { 1474 kobject_uevent(&dev->kobj, KOBJ_ONLINE); 1475 dev->offline = false; 1476 } 1477 } else { 1478 ret = 1; 1479 } 1480 } 1481 device_unlock(dev); 1482 1483 return ret; 1484 } 1485 1486 struct root_device { 1487 struct device dev; 1488 struct module *owner; 1489 }; 1490 1491 static inline struct root_device *to_root_device(struct device *d) 1492 { 1493 return container_of(d, struct root_device, dev); 1494 } 1495 1496 static void root_device_release(struct device *dev) 1497 { 1498 kfree(to_root_device(dev)); 1499 } 1500 1501 /** 1502 * __root_device_register - allocate and register a root device 1503 * @name: root device name 1504 * @owner: owner module of the root device, usually THIS_MODULE 1505 * 1506 * This function allocates a root device and registers it 1507 * using device_register(). In order to free the returned 1508 * device, use root_device_unregister(). 1509 * 1510 * Root devices are dummy devices which allow other devices 1511 * to be grouped under /sys/devices. Use this function to 1512 * allocate a root device and then use it as the parent of 1513 * any device which should appear under /sys/devices/{name} 1514 * 1515 * The /sys/devices/{name} directory will also contain a 1516 * 'module' symlink which points to the @owner directory 1517 * in sysfs. 1518 * 1519 * Returns &struct device pointer on success, or ERR_PTR() on error. 1520 * 1521 * Note: You probably want to use root_device_register(). 1522 */ 1523 struct device *__root_device_register(const char *name, struct module *owner) 1524 { 1525 struct root_device *root; 1526 int err = -ENOMEM; 1527 1528 root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 1529 if (!root) 1530 return ERR_PTR(err); 1531 1532 err = dev_set_name(&root->dev, "%s", name); 1533 if (err) { 1534 kfree(root); 1535 return ERR_PTR(err); 1536 } 1537 1538 root->dev.release = root_device_release; 1539 1540 err = device_register(&root->dev); 1541 if (err) { 1542 put_device(&root->dev); 1543 return ERR_PTR(err); 1544 } 1545 1546 #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 1547 if (owner) { 1548 struct module_kobject *mk = &owner->mkobj; 1549 1550 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 1551 if (err) { 1552 device_unregister(&root->dev); 1553 return ERR_PTR(err); 1554 } 1555 root->owner = owner; 1556 } 1557 #endif 1558 1559 return &root->dev; 1560 } 1561 EXPORT_SYMBOL_GPL(__root_device_register); 1562 1563 /** 1564 * root_device_unregister - unregister and free a root device 1565 * @dev: device going away 1566 * 1567 * This function unregisters and cleans up a device that was created by 1568 * root_device_register(). 1569 */ 1570 void root_device_unregister(struct device *dev) 1571 { 1572 struct root_device *root = to_root_device(dev); 1573 1574 if (root->owner) 1575 sysfs_remove_link(&root->dev.kobj, "module"); 1576 1577 device_unregister(dev); 1578 } 1579 EXPORT_SYMBOL_GPL(root_device_unregister); 1580 1581 1582 static void device_create_release(struct device *dev) 1583 { 1584 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1585 kfree(dev); 1586 } 1587 1588 static struct device * 1589 device_create_groups_vargs(struct class *class, struct device *parent, 1590 dev_t devt, void *drvdata, 1591 const struct attribute_group **groups, 1592 const char *fmt, va_list args) 1593 { 1594 struct device *dev = NULL; 1595 int retval = -ENODEV; 1596 1597 if (class == NULL || IS_ERR(class)) 1598 goto error; 1599 1600 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1601 if (!dev) { 1602 retval = -ENOMEM; 1603 goto error; 1604 } 1605 1606 device_initialize(dev); 1607 dev->devt = devt; 1608 dev->class = class; 1609 dev->parent = parent; 1610 dev->groups = groups; 1611 dev->release = device_create_release; 1612 dev_set_drvdata(dev, drvdata); 1613 1614 retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 1615 if (retval) 1616 goto error; 1617 1618 retval = device_add(dev); 1619 if (retval) 1620 goto error; 1621 1622 return dev; 1623 1624 error: 1625 put_device(dev); 1626 return ERR_PTR(retval); 1627 } 1628 1629 /** 1630 * device_create_vargs - creates a device and registers it with sysfs 1631 * @class: pointer to the struct class that this device should be registered to 1632 * @parent: pointer to the parent struct device of this new device, if any 1633 * @devt: the dev_t for the char device to be added 1634 * @drvdata: the data to be added to the device for callbacks 1635 * @fmt: string for the device's name 1636 * @args: va_list for the device's name 1637 * 1638 * This function can be used by char device classes. A struct device 1639 * will be created in sysfs, registered to the specified class. 1640 * 1641 * A "dev" file will be created, showing the dev_t for the device, if 1642 * the dev_t is not 0,0. 1643 * If a pointer to a parent struct device is passed in, the newly created 1644 * struct device will be a child of that device in sysfs. 1645 * The pointer to the struct device will be returned from the call. 1646 * Any further sysfs files that might be required can be created using this 1647 * pointer. 1648 * 1649 * Returns &struct device pointer on success, or ERR_PTR() on error. 1650 * 1651 * Note: the struct class passed to this function must have previously 1652 * been created with a call to class_create(). 1653 */ 1654 struct device *device_create_vargs(struct class *class, struct device *parent, 1655 dev_t devt, void *drvdata, const char *fmt, 1656 va_list args) 1657 { 1658 return device_create_groups_vargs(class, parent, devt, drvdata, NULL, 1659 fmt, args); 1660 } 1661 EXPORT_SYMBOL_GPL(device_create_vargs); 1662 1663 /** 1664 * device_create - creates a device and registers it with sysfs 1665 * @class: pointer to the struct class that this device should be registered to 1666 * @parent: pointer to the parent struct device of this new device, if any 1667 * @devt: the dev_t for the char device to be added 1668 * @drvdata: the data to be added to the device for callbacks 1669 * @fmt: string for the device's name 1670 * 1671 * This function can be used by char device classes. A struct device 1672 * will be created in sysfs, registered to the specified class. 1673 * 1674 * A "dev" file will be created, showing the dev_t for the device, if 1675 * the dev_t is not 0,0. 1676 * If a pointer to a parent struct device is passed in, the newly created 1677 * struct device will be a child of that device in sysfs. 1678 * The pointer to the struct device will be returned from the call. 1679 * Any further sysfs files that might be required can be created using this 1680 * pointer. 1681 * 1682 * Returns &struct device pointer on success, or ERR_PTR() on error. 1683 * 1684 * Note: the struct class passed to this function must have previously 1685 * been created with a call to class_create(). 1686 */ 1687 struct device *device_create(struct class *class, struct device *parent, 1688 dev_t devt, void *drvdata, const char *fmt, ...) 1689 { 1690 va_list vargs; 1691 struct device *dev; 1692 1693 va_start(vargs, fmt); 1694 dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs); 1695 va_end(vargs); 1696 return dev; 1697 } 1698 EXPORT_SYMBOL_GPL(device_create); 1699 1700 /** 1701 * device_create_with_groups - creates a device and registers it with sysfs 1702 * @class: pointer to the struct class that this device should be registered to 1703 * @parent: pointer to the parent struct device of this new device, if any 1704 * @devt: the dev_t for the char device to be added 1705 * @drvdata: the data to be added to the device for callbacks 1706 * @groups: NULL-terminated list of attribute groups to be created 1707 * @fmt: string for the device's name 1708 * 1709 * This function can be used by char device classes. A struct device 1710 * will be created in sysfs, registered to the specified class. 1711 * Additional attributes specified in the groups parameter will also 1712 * be created automatically. 1713 * 1714 * A "dev" file will be created, showing the dev_t for the device, if 1715 * the dev_t is not 0,0. 1716 * If a pointer to a parent struct device is passed in, the newly created 1717 * struct device will be a child of that device in sysfs. 1718 * The pointer to the struct device will be returned from the call. 1719 * Any further sysfs files that might be required can be created using this 1720 * pointer. 1721 * 1722 * Returns &struct device pointer on success, or ERR_PTR() on error. 1723 * 1724 * Note: the struct class passed to this function must have previously 1725 * been created with a call to class_create(). 1726 */ 1727 struct device *device_create_with_groups(struct class *class, 1728 struct device *parent, dev_t devt, 1729 void *drvdata, 1730 const struct attribute_group **groups, 1731 const char *fmt, ...) 1732 { 1733 va_list vargs; 1734 struct device *dev; 1735 1736 va_start(vargs, fmt); 1737 dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 1738 fmt, vargs); 1739 va_end(vargs); 1740 return dev; 1741 } 1742 EXPORT_SYMBOL_GPL(device_create_with_groups); 1743 1744 static int __match_devt(struct device *dev, const void *data) 1745 { 1746 const dev_t *devt = data; 1747 1748 return dev->devt == *devt; 1749 } 1750 1751 /** 1752 * device_destroy - removes a device that was created with device_create() 1753 * @class: pointer to the struct class that this device was registered with 1754 * @devt: the dev_t of the device that was previously registered 1755 * 1756 * This call unregisters and cleans up a device that was created with a 1757 * call to device_create(). 1758 */ 1759 void device_destroy(struct class *class, dev_t devt) 1760 { 1761 struct device *dev; 1762 1763 dev = class_find_device(class, NULL, &devt, __match_devt); 1764 if (dev) { 1765 put_device(dev); 1766 device_unregister(dev); 1767 } 1768 } 1769 EXPORT_SYMBOL_GPL(device_destroy); 1770 1771 /** 1772 * device_rename - renames a device 1773 * @dev: the pointer to the struct device to be renamed 1774 * @new_name: the new name of the device 1775 * 1776 * It is the responsibility of the caller to provide mutual 1777 * exclusion between two different calls of device_rename 1778 * on the same device to ensure that new_name is valid and 1779 * won't conflict with other devices. 1780 * 1781 * Note: Don't call this function. Currently, the networking layer calls this 1782 * function, but that will change. The following text from Kay Sievers offers 1783 * some insight: 1784 * 1785 * Renaming devices is racy at many levels, symlinks and other stuff are not 1786 * replaced atomically, and you get a "move" uevent, but it's not easy to 1787 * connect the event to the old and new device. Device nodes are not renamed at 1788 * all, there isn't even support for that in the kernel now. 1789 * 1790 * In the meantime, during renaming, your target name might be taken by another 1791 * driver, creating conflicts. Or the old name is taken directly after you 1792 * renamed it -- then you get events for the same DEVPATH, before you even see 1793 * the "move" event. It's just a mess, and nothing new should ever rely on 1794 * kernel device renaming. Besides that, it's not even implemented now for 1795 * other things than (driver-core wise very simple) network devices. 1796 * 1797 * We are currently about to change network renaming in udev to completely 1798 * disallow renaming of devices in the same namespace as the kernel uses, 1799 * because we can't solve the problems properly, that arise with swapping names 1800 * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 1801 * be allowed to some other name than eth[0-9]*, for the aforementioned 1802 * reasons. 1803 * 1804 * Make up a "real" name in the driver before you register anything, or add 1805 * some other attributes for userspace to find the device, or use udev to add 1806 * symlinks -- but never rename kernel devices later, it's a complete mess. We 1807 * don't even want to get into that and try to implement the missing pieces in 1808 * the core. We really have other pieces to fix in the driver core mess. :) 1809 */ 1810 int device_rename(struct device *dev, const char *new_name) 1811 { 1812 struct kobject *kobj = &dev->kobj; 1813 char *old_device_name = NULL; 1814 int error; 1815 1816 dev = get_device(dev); 1817 if (!dev) 1818 return -EINVAL; 1819 1820 dev_dbg(dev, "renaming to %s\n", new_name); 1821 1822 old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 1823 if (!old_device_name) { 1824 error = -ENOMEM; 1825 goto out; 1826 } 1827 1828 if (dev->class) { 1829 error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 1830 kobj, old_device_name, 1831 new_name, kobject_namespace(kobj)); 1832 if (error) 1833 goto out; 1834 } 1835 1836 error = kobject_rename(kobj, new_name); 1837 if (error) 1838 goto out; 1839 1840 out: 1841 put_device(dev); 1842 1843 kfree(old_device_name); 1844 1845 return error; 1846 } 1847 EXPORT_SYMBOL_GPL(device_rename); 1848 1849 static int device_move_class_links(struct device *dev, 1850 struct device *old_parent, 1851 struct device *new_parent) 1852 { 1853 int error = 0; 1854 1855 if (old_parent) 1856 sysfs_remove_link(&dev->kobj, "device"); 1857 if (new_parent) 1858 error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 1859 "device"); 1860 return error; 1861 } 1862 1863 /** 1864 * device_move - moves a device to a new parent 1865 * @dev: the pointer to the struct device to be moved 1866 * @new_parent: the new parent of the device (can by NULL) 1867 * @dpm_order: how to reorder the dpm_list 1868 */ 1869 int device_move(struct device *dev, struct device *new_parent, 1870 enum dpm_order dpm_order) 1871 { 1872 int error; 1873 struct device *old_parent; 1874 struct kobject *new_parent_kobj; 1875 1876 dev = get_device(dev); 1877 if (!dev) 1878 return -EINVAL; 1879 1880 device_pm_lock(); 1881 new_parent = get_device(new_parent); 1882 new_parent_kobj = get_device_parent(dev, new_parent); 1883 1884 pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 1885 __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 1886 error = kobject_move(&dev->kobj, new_parent_kobj); 1887 if (error) { 1888 cleanup_glue_dir(dev, new_parent_kobj); 1889 put_device(new_parent); 1890 goto out; 1891 } 1892 old_parent = dev->parent; 1893 dev->parent = new_parent; 1894 if (old_parent) 1895 klist_remove(&dev->p->knode_parent); 1896 if (new_parent) { 1897 klist_add_tail(&dev->p->knode_parent, 1898 &new_parent->p->klist_children); 1899 set_dev_node(dev, dev_to_node(new_parent)); 1900 } 1901 1902 if (dev->class) { 1903 error = device_move_class_links(dev, old_parent, new_parent); 1904 if (error) { 1905 /* We ignore errors on cleanup since we're hosed anyway... */ 1906 device_move_class_links(dev, new_parent, old_parent); 1907 if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 1908 if (new_parent) 1909 klist_remove(&dev->p->knode_parent); 1910 dev->parent = old_parent; 1911 if (old_parent) { 1912 klist_add_tail(&dev->p->knode_parent, 1913 &old_parent->p->klist_children); 1914 set_dev_node(dev, dev_to_node(old_parent)); 1915 } 1916 } 1917 cleanup_glue_dir(dev, new_parent_kobj); 1918 put_device(new_parent); 1919 goto out; 1920 } 1921 } 1922 switch (dpm_order) { 1923 case DPM_ORDER_NONE: 1924 break; 1925 case DPM_ORDER_DEV_AFTER_PARENT: 1926 device_pm_move_after(dev, new_parent); 1927 break; 1928 case DPM_ORDER_PARENT_BEFORE_DEV: 1929 device_pm_move_before(new_parent, dev); 1930 break; 1931 case DPM_ORDER_DEV_LAST: 1932 device_pm_move_last(dev); 1933 break; 1934 } 1935 1936 put_device(old_parent); 1937 out: 1938 device_pm_unlock(); 1939 put_device(dev); 1940 return error; 1941 } 1942 EXPORT_SYMBOL_GPL(device_move); 1943 1944 /** 1945 * device_shutdown - call ->shutdown() on each device to shutdown. 1946 */ 1947 void device_shutdown(void) 1948 { 1949 struct device *dev, *parent; 1950 1951 spin_lock(&devices_kset->list_lock); 1952 /* 1953 * Walk the devices list backward, shutting down each in turn. 1954 * Beware that device unplug events may also start pulling 1955 * devices offline, even as the system is shutting down. 1956 */ 1957 while (!list_empty(&devices_kset->list)) { 1958 dev = list_entry(devices_kset->list.prev, struct device, 1959 kobj.entry); 1960 1961 /* 1962 * hold reference count of device's parent to 1963 * prevent it from being freed because parent's 1964 * lock is to be held 1965 */ 1966 parent = get_device(dev->parent); 1967 get_device(dev); 1968 /* 1969 * Make sure the device is off the kset list, in the 1970 * event that dev->*->shutdown() doesn't remove it. 1971 */ 1972 list_del_init(&dev->kobj.entry); 1973 spin_unlock(&devices_kset->list_lock); 1974 1975 /* hold lock to avoid race with probe/release */ 1976 if (parent) 1977 device_lock(parent); 1978 device_lock(dev); 1979 1980 /* Don't allow any more runtime suspends */ 1981 pm_runtime_get_noresume(dev); 1982 pm_runtime_barrier(dev); 1983 1984 if (dev->bus && dev->bus->shutdown) { 1985 if (initcall_debug) 1986 dev_info(dev, "shutdown\n"); 1987 dev->bus->shutdown(dev); 1988 } else if (dev->driver && dev->driver->shutdown) { 1989 if (initcall_debug) 1990 dev_info(dev, "shutdown\n"); 1991 dev->driver->shutdown(dev); 1992 } 1993 1994 device_unlock(dev); 1995 if (parent) 1996 device_unlock(parent); 1997 1998 put_device(dev); 1999 put_device(parent); 2000 2001 spin_lock(&devices_kset->list_lock); 2002 } 2003 spin_unlock(&devices_kset->list_lock); 2004 } 2005 2006 /* 2007 * Device logging functions 2008 */ 2009 2010 #ifdef CONFIG_PRINTK 2011 static int 2012 create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen) 2013 { 2014 const char *subsys; 2015 size_t pos = 0; 2016 2017 if (dev->class) 2018 subsys = dev->class->name; 2019 else if (dev->bus) 2020 subsys = dev->bus->name; 2021 else 2022 return 0; 2023 2024 pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys); 2025 if (pos >= hdrlen) 2026 goto overflow; 2027 2028 /* 2029 * Add device identifier DEVICE=: 2030 * b12:8 block dev_t 2031 * c127:3 char dev_t 2032 * n8 netdev ifindex 2033 * +sound:card0 subsystem:devname 2034 */ 2035 if (MAJOR(dev->devt)) { 2036 char c; 2037 2038 if (strcmp(subsys, "block") == 0) 2039 c = 'b'; 2040 else 2041 c = 'c'; 2042 pos++; 2043 pos += snprintf(hdr + pos, hdrlen - pos, 2044 "DEVICE=%c%u:%u", 2045 c, MAJOR(dev->devt), MINOR(dev->devt)); 2046 } else if (strcmp(subsys, "net") == 0) { 2047 struct net_device *net = to_net_dev(dev); 2048 2049 pos++; 2050 pos += snprintf(hdr + pos, hdrlen - pos, 2051 "DEVICE=n%u", net->ifindex); 2052 } else { 2053 pos++; 2054 pos += snprintf(hdr + pos, hdrlen - pos, 2055 "DEVICE=+%s:%s", subsys, dev_name(dev)); 2056 } 2057 2058 if (pos >= hdrlen) 2059 goto overflow; 2060 2061 return pos; 2062 2063 overflow: 2064 dev_WARN(dev, "device/subsystem name too long"); 2065 return 0; 2066 } 2067 2068 int dev_vprintk_emit(int level, const struct device *dev, 2069 const char *fmt, va_list args) 2070 { 2071 char hdr[128]; 2072 size_t hdrlen; 2073 2074 hdrlen = create_syslog_header(dev, hdr, sizeof(hdr)); 2075 2076 return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args); 2077 } 2078 EXPORT_SYMBOL(dev_vprintk_emit); 2079 2080 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 2081 { 2082 va_list args; 2083 int r; 2084 2085 va_start(args, fmt); 2086 2087 r = dev_vprintk_emit(level, dev, fmt, args); 2088 2089 va_end(args); 2090 2091 return r; 2092 } 2093 EXPORT_SYMBOL(dev_printk_emit); 2094 2095 static void __dev_printk(const char *level, const struct device *dev, 2096 struct va_format *vaf) 2097 { 2098 if (dev) 2099 dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 2100 dev_driver_string(dev), dev_name(dev), vaf); 2101 else 2102 printk("%s(NULL device *): %pV", level, vaf); 2103 } 2104 2105 void dev_printk(const char *level, const struct device *dev, 2106 const char *fmt, ...) 2107 { 2108 struct va_format vaf; 2109 va_list args; 2110 2111 va_start(args, fmt); 2112 2113 vaf.fmt = fmt; 2114 vaf.va = &args; 2115 2116 __dev_printk(level, dev, &vaf); 2117 2118 va_end(args); 2119 } 2120 EXPORT_SYMBOL(dev_printk); 2121 2122 #define define_dev_printk_level(func, kern_level) \ 2123 void func(const struct device *dev, const char *fmt, ...) \ 2124 { \ 2125 struct va_format vaf; \ 2126 va_list args; \ 2127 \ 2128 va_start(args, fmt); \ 2129 \ 2130 vaf.fmt = fmt; \ 2131 vaf.va = &args; \ 2132 \ 2133 __dev_printk(kern_level, dev, &vaf); \ 2134 \ 2135 va_end(args); \ 2136 } \ 2137 EXPORT_SYMBOL(func); 2138 2139 define_dev_printk_level(dev_emerg, KERN_EMERG); 2140 define_dev_printk_level(dev_alert, KERN_ALERT); 2141 define_dev_printk_level(dev_crit, KERN_CRIT); 2142 define_dev_printk_level(dev_err, KERN_ERR); 2143 define_dev_printk_level(dev_warn, KERN_WARNING); 2144 define_dev_printk_level(dev_notice, KERN_NOTICE); 2145 define_dev_printk_level(_dev_info, KERN_INFO); 2146 2147 #endif 2148 2149 static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 2150 { 2151 return fwnode && !IS_ERR(fwnode->secondary); 2152 } 2153 2154 /** 2155 * set_primary_fwnode - Change the primary firmware node of a given device. 2156 * @dev: Device to handle. 2157 * @fwnode: New primary firmware node of the device. 2158 * 2159 * Set the device's firmware node pointer to @fwnode, but if a secondary 2160 * firmware node of the device is present, preserve it. 2161 */ 2162 void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 2163 { 2164 if (fwnode) { 2165 struct fwnode_handle *fn = dev->fwnode; 2166 2167 if (fwnode_is_primary(fn)) 2168 fn = fn->secondary; 2169 2170 fwnode->secondary = fn; 2171 dev->fwnode = fwnode; 2172 } else { 2173 dev->fwnode = fwnode_is_primary(dev->fwnode) ? 2174 dev->fwnode->secondary : NULL; 2175 } 2176 } 2177 EXPORT_SYMBOL_GPL(set_primary_fwnode); 2178 2179 /** 2180 * set_secondary_fwnode - Change the secondary firmware node of a given device. 2181 * @dev: Device to handle. 2182 * @fwnode: New secondary firmware node of the device. 2183 * 2184 * If a primary firmware node of the device is present, set its secondary 2185 * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 2186 * @fwnode. 2187 */ 2188 void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 2189 { 2190 if (fwnode) 2191 fwnode->secondary = ERR_PTR(-ENODEV); 2192 2193 if (fwnode_is_primary(dev->fwnode)) 2194 dev->fwnode->secondary = fwnode; 2195 else 2196 dev->fwnode = fwnode; 2197 } 2198