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 #ifdef CONFIG_GENERIC_MSI_IRQ 666 INIT_LIST_HEAD(&dev->msi_list); 667 #endif 668 } 669 EXPORT_SYMBOL_GPL(device_initialize); 670 671 struct kobject *virtual_device_parent(struct device *dev) 672 { 673 static struct kobject *virtual_dir = NULL; 674 675 if (!virtual_dir) 676 virtual_dir = kobject_create_and_add("virtual", 677 &devices_kset->kobj); 678 679 return virtual_dir; 680 } 681 682 struct class_dir { 683 struct kobject kobj; 684 struct class *class; 685 }; 686 687 #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 688 689 static void class_dir_release(struct kobject *kobj) 690 { 691 struct class_dir *dir = to_class_dir(kobj); 692 kfree(dir); 693 } 694 695 static const 696 struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 697 { 698 struct class_dir *dir = to_class_dir(kobj); 699 return dir->class->ns_type; 700 } 701 702 static struct kobj_type class_dir_ktype = { 703 .release = class_dir_release, 704 .sysfs_ops = &kobj_sysfs_ops, 705 .child_ns_type = class_dir_child_ns_type 706 }; 707 708 static struct kobject * 709 class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 710 { 711 struct class_dir *dir; 712 int retval; 713 714 dir = kzalloc(sizeof(*dir), GFP_KERNEL); 715 if (!dir) 716 return NULL; 717 718 dir->class = class; 719 kobject_init(&dir->kobj, &class_dir_ktype); 720 721 dir->kobj.kset = &class->p->glue_dirs; 722 723 retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 724 if (retval < 0) { 725 kobject_put(&dir->kobj); 726 return NULL; 727 } 728 return &dir->kobj; 729 } 730 731 static DEFINE_MUTEX(gdp_mutex); 732 733 static struct kobject *get_device_parent(struct device *dev, 734 struct device *parent) 735 { 736 if (dev->class) { 737 struct kobject *kobj = NULL; 738 struct kobject *parent_kobj; 739 struct kobject *k; 740 741 #ifdef CONFIG_BLOCK 742 /* block disks show up in /sys/block */ 743 if (sysfs_deprecated && dev->class == &block_class) { 744 if (parent && parent->class == &block_class) 745 return &parent->kobj; 746 return &block_class.p->subsys.kobj; 747 } 748 #endif 749 750 /* 751 * If we have no parent, we live in "virtual". 752 * Class-devices with a non class-device as parent, live 753 * in a "glue" directory to prevent namespace collisions. 754 */ 755 if (parent == NULL) 756 parent_kobj = virtual_device_parent(dev); 757 else if (parent->class && !dev->class->ns_type) 758 return &parent->kobj; 759 else 760 parent_kobj = &parent->kobj; 761 762 mutex_lock(&gdp_mutex); 763 764 /* find our class-directory at the parent and reference it */ 765 spin_lock(&dev->class->p->glue_dirs.list_lock); 766 list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 767 if (k->parent == parent_kobj) { 768 kobj = kobject_get(k); 769 break; 770 } 771 spin_unlock(&dev->class->p->glue_dirs.list_lock); 772 if (kobj) { 773 mutex_unlock(&gdp_mutex); 774 return kobj; 775 } 776 777 /* or create a new class-directory at the parent device */ 778 k = class_dir_create_and_add(dev->class, parent_kobj); 779 /* do not emit an uevent for this simple "glue" directory */ 780 mutex_unlock(&gdp_mutex); 781 return k; 782 } 783 784 /* subsystems can specify a default root directory for their devices */ 785 if (!parent && dev->bus && dev->bus->dev_root) 786 return &dev->bus->dev_root->kobj; 787 788 if (parent) 789 return &parent->kobj; 790 return NULL; 791 } 792 793 static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 794 { 795 /* see if we live in a "glue" directory */ 796 if (!glue_dir || !dev->class || 797 glue_dir->kset != &dev->class->p->glue_dirs) 798 return; 799 800 mutex_lock(&gdp_mutex); 801 kobject_put(glue_dir); 802 mutex_unlock(&gdp_mutex); 803 } 804 805 static void cleanup_device_parent(struct device *dev) 806 { 807 cleanup_glue_dir(dev, dev->kobj.parent); 808 } 809 810 static int device_add_class_symlinks(struct device *dev) 811 { 812 struct device_node *of_node = dev_of_node(dev); 813 int error; 814 815 if (of_node) { 816 error = sysfs_create_link(&dev->kobj, &of_node->kobj,"of_node"); 817 if (error) 818 dev_warn(dev, "Error %d creating of_node link\n",error); 819 /* An error here doesn't warrant bringing down the device */ 820 } 821 822 if (!dev->class) 823 return 0; 824 825 error = sysfs_create_link(&dev->kobj, 826 &dev->class->p->subsys.kobj, 827 "subsystem"); 828 if (error) 829 goto out_devnode; 830 831 if (dev->parent && device_is_not_partition(dev)) { 832 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 833 "device"); 834 if (error) 835 goto out_subsys; 836 } 837 838 #ifdef CONFIG_BLOCK 839 /* /sys/block has directories and does not need symlinks */ 840 if (sysfs_deprecated && dev->class == &block_class) 841 return 0; 842 #endif 843 844 /* link in the class directory pointing to the device */ 845 error = sysfs_create_link(&dev->class->p->subsys.kobj, 846 &dev->kobj, dev_name(dev)); 847 if (error) 848 goto out_device; 849 850 return 0; 851 852 out_device: 853 sysfs_remove_link(&dev->kobj, "device"); 854 855 out_subsys: 856 sysfs_remove_link(&dev->kobj, "subsystem"); 857 out_devnode: 858 sysfs_remove_link(&dev->kobj, "of_node"); 859 return error; 860 } 861 862 static void device_remove_class_symlinks(struct device *dev) 863 { 864 if (dev_of_node(dev)) 865 sysfs_remove_link(&dev->kobj, "of_node"); 866 867 if (!dev->class) 868 return; 869 870 if (dev->parent && device_is_not_partition(dev)) 871 sysfs_remove_link(&dev->kobj, "device"); 872 sysfs_remove_link(&dev->kobj, "subsystem"); 873 #ifdef CONFIG_BLOCK 874 if (sysfs_deprecated && dev->class == &block_class) 875 return; 876 #endif 877 sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 878 } 879 880 /** 881 * dev_set_name - set a device name 882 * @dev: device 883 * @fmt: format string for the device's name 884 */ 885 int dev_set_name(struct device *dev, const char *fmt, ...) 886 { 887 va_list vargs; 888 int err; 889 890 va_start(vargs, fmt); 891 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 892 va_end(vargs); 893 return err; 894 } 895 EXPORT_SYMBOL_GPL(dev_set_name); 896 897 /** 898 * device_to_dev_kobj - select a /sys/dev/ directory for the device 899 * @dev: device 900 * 901 * By default we select char/ for new entries. Setting class->dev_obj 902 * to NULL prevents an entry from being created. class->dev_kobj must 903 * be set (or cleared) before any devices are registered to the class 904 * otherwise device_create_sys_dev_entry() and 905 * device_remove_sys_dev_entry() will disagree about the presence of 906 * the link. 907 */ 908 static struct kobject *device_to_dev_kobj(struct device *dev) 909 { 910 struct kobject *kobj; 911 912 if (dev->class) 913 kobj = dev->class->dev_kobj; 914 else 915 kobj = sysfs_dev_char_kobj; 916 917 return kobj; 918 } 919 920 static int device_create_sys_dev_entry(struct device *dev) 921 { 922 struct kobject *kobj = device_to_dev_kobj(dev); 923 int error = 0; 924 char devt_str[15]; 925 926 if (kobj) { 927 format_dev_t(devt_str, dev->devt); 928 error = sysfs_create_link(kobj, &dev->kobj, devt_str); 929 } 930 931 return error; 932 } 933 934 static void device_remove_sys_dev_entry(struct device *dev) 935 { 936 struct kobject *kobj = device_to_dev_kobj(dev); 937 char devt_str[15]; 938 939 if (kobj) { 940 format_dev_t(devt_str, dev->devt); 941 sysfs_remove_link(kobj, devt_str); 942 } 943 } 944 945 int device_private_init(struct device *dev) 946 { 947 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 948 if (!dev->p) 949 return -ENOMEM; 950 dev->p->device = dev; 951 klist_init(&dev->p->klist_children, klist_children_get, 952 klist_children_put); 953 INIT_LIST_HEAD(&dev->p->deferred_probe); 954 return 0; 955 } 956 957 /** 958 * device_add - add device to device hierarchy. 959 * @dev: device. 960 * 961 * This is part 2 of device_register(), though may be called 962 * separately _iff_ device_initialize() has been called separately. 963 * 964 * This adds @dev to the kobject hierarchy via kobject_add(), adds it 965 * to the global and sibling lists for the device, then 966 * adds it to the other relevant subsystems of the driver model. 967 * 968 * Do not call this routine or device_register() more than once for 969 * any device structure. The driver model core is not designed to work 970 * with devices that get unregistered and then spring back to life. 971 * (Among other things, it's very hard to guarantee that all references 972 * to the previous incarnation of @dev have been dropped.) Allocate 973 * and register a fresh new struct device instead. 974 * 975 * NOTE: _Never_ directly free @dev after calling this function, even 976 * if it returned an error! Always use put_device() to give up your 977 * reference instead. 978 */ 979 int device_add(struct device *dev) 980 { 981 struct device *parent = NULL; 982 struct kobject *kobj; 983 struct class_interface *class_intf; 984 int error = -EINVAL; 985 986 dev = get_device(dev); 987 if (!dev) 988 goto done; 989 990 if (!dev->p) { 991 error = device_private_init(dev); 992 if (error) 993 goto done; 994 } 995 996 /* 997 * for statically allocated devices, which should all be converted 998 * some day, we need to initialize the name. We prevent reading back 999 * the name, and force the use of dev_name() 1000 */ 1001 if (dev->init_name) { 1002 dev_set_name(dev, "%s", dev->init_name); 1003 dev->init_name = NULL; 1004 } 1005 1006 /* subsystems can specify simple device enumeration */ 1007 if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 1008 dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 1009 1010 if (!dev_name(dev)) { 1011 error = -EINVAL; 1012 goto name_error; 1013 } 1014 1015 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1016 1017 parent = get_device(dev->parent); 1018 kobj = get_device_parent(dev, parent); 1019 if (kobj) 1020 dev->kobj.parent = kobj; 1021 1022 /* use parent numa_node */ 1023 if (parent) 1024 set_dev_node(dev, dev_to_node(parent)); 1025 1026 /* first, register with generic layer. */ 1027 /* we require the name to be set before, and pass NULL */ 1028 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 1029 if (error) 1030 goto Error; 1031 1032 /* notify platform of device entry */ 1033 if (platform_notify) 1034 platform_notify(dev); 1035 1036 error = device_create_file(dev, &dev_attr_uevent); 1037 if (error) 1038 goto attrError; 1039 1040 error = device_add_class_symlinks(dev); 1041 if (error) 1042 goto SymlinkError; 1043 error = device_add_attrs(dev); 1044 if (error) 1045 goto AttrsError; 1046 error = bus_add_device(dev); 1047 if (error) 1048 goto BusError; 1049 error = dpm_sysfs_add(dev); 1050 if (error) 1051 goto DPMError; 1052 device_pm_add(dev); 1053 1054 if (MAJOR(dev->devt)) { 1055 error = device_create_file(dev, &dev_attr_dev); 1056 if (error) 1057 goto DevAttrError; 1058 1059 error = device_create_sys_dev_entry(dev); 1060 if (error) 1061 goto SysEntryError; 1062 1063 devtmpfs_create_node(dev); 1064 } 1065 1066 /* Notify clients of device addition. This call must come 1067 * after dpm_sysfs_add() and before kobject_uevent(). 1068 */ 1069 if (dev->bus) 1070 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1071 BUS_NOTIFY_ADD_DEVICE, dev); 1072 1073 kobject_uevent(&dev->kobj, KOBJ_ADD); 1074 bus_probe_device(dev); 1075 if (parent) 1076 klist_add_tail(&dev->p->knode_parent, 1077 &parent->p->klist_children); 1078 1079 if (dev->class) { 1080 mutex_lock(&dev->class->p->mutex); 1081 /* tie the class to the device */ 1082 klist_add_tail(&dev->knode_class, 1083 &dev->class->p->klist_devices); 1084 1085 /* notify any interfaces that the device is here */ 1086 list_for_each_entry(class_intf, 1087 &dev->class->p->interfaces, node) 1088 if (class_intf->add_dev) 1089 class_intf->add_dev(dev, class_intf); 1090 mutex_unlock(&dev->class->p->mutex); 1091 } 1092 done: 1093 put_device(dev); 1094 return error; 1095 SysEntryError: 1096 if (MAJOR(dev->devt)) 1097 device_remove_file(dev, &dev_attr_dev); 1098 DevAttrError: 1099 device_pm_remove(dev); 1100 dpm_sysfs_remove(dev); 1101 DPMError: 1102 bus_remove_device(dev); 1103 BusError: 1104 device_remove_attrs(dev); 1105 AttrsError: 1106 device_remove_class_symlinks(dev); 1107 SymlinkError: 1108 device_remove_file(dev, &dev_attr_uevent); 1109 attrError: 1110 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 1111 kobject_del(&dev->kobj); 1112 Error: 1113 cleanup_device_parent(dev); 1114 put_device(parent); 1115 name_error: 1116 kfree(dev->p); 1117 dev->p = NULL; 1118 goto done; 1119 } 1120 EXPORT_SYMBOL_GPL(device_add); 1121 1122 /** 1123 * device_register - register a device with the system. 1124 * @dev: pointer to the device structure 1125 * 1126 * This happens in two clean steps - initialize the device 1127 * and add it to the system. The two steps can be called 1128 * separately, but this is the easiest and most common. 1129 * I.e. you should only call the two helpers separately if 1130 * have a clearly defined need to use and refcount the device 1131 * before it is added to the hierarchy. 1132 * 1133 * For more information, see the kerneldoc for device_initialize() 1134 * and device_add(). 1135 * 1136 * NOTE: _Never_ directly free @dev after calling this function, even 1137 * if it returned an error! Always use put_device() to give up the 1138 * reference initialized in this function instead. 1139 */ 1140 int device_register(struct device *dev) 1141 { 1142 device_initialize(dev); 1143 return device_add(dev); 1144 } 1145 EXPORT_SYMBOL_GPL(device_register); 1146 1147 /** 1148 * get_device - increment reference count for device. 1149 * @dev: device. 1150 * 1151 * This simply forwards the call to kobject_get(), though 1152 * we do take care to provide for the case that we get a NULL 1153 * pointer passed in. 1154 */ 1155 struct device *get_device(struct device *dev) 1156 { 1157 return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 1158 } 1159 EXPORT_SYMBOL_GPL(get_device); 1160 1161 /** 1162 * put_device - decrement reference count. 1163 * @dev: device in question. 1164 */ 1165 void put_device(struct device *dev) 1166 { 1167 /* might_sleep(); */ 1168 if (dev) 1169 kobject_put(&dev->kobj); 1170 } 1171 EXPORT_SYMBOL_GPL(put_device); 1172 1173 /** 1174 * device_del - delete device from system. 1175 * @dev: device. 1176 * 1177 * This is the first part of the device unregistration 1178 * sequence. This removes the device from the lists we control 1179 * from here, has it removed from the other driver model 1180 * subsystems it was added to in device_add(), and removes it 1181 * from the kobject hierarchy. 1182 * 1183 * NOTE: this should be called manually _iff_ device_add() was 1184 * also called manually. 1185 */ 1186 void device_del(struct device *dev) 1187 { 1188 struct device *parent = dev->parent; 1189 struct class_interface *class_intf; 1190 1191 /* Notify clients of device removal. This call must come 1192 * before dpm_sysfs_remove(). 1193 */ 1194 if (dev->bus) 1195 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1196 BUS_NOTIFY_DEL_DEVICE, dev); 1197 dpm_sysfs_remove(dev); 1198 if (parent) 1199 klist_del(&dev->p->knode_parent); 1200 if (MAJOR(dev->devt)) { 1201 devtmpfs_delete_node(dev); 1202 device_remove_sys_dev_entry(dev); 1203 device_remove_file(dev, &dev_attr_dev); 1204 } 1205 if (dev->class) { 1206 device_remove_class_symlinks(dev); 1207 1208 mutex_lock(&dev->class->p->mutex); 1209 /* notify any interfaces that the device is now gone */ 1210 list_for_each_entry(class_intf, 1211 &dev->class->p->interfaces, node) 1212 if (class_intf->remove_dev) 1213 class_intf->remove_dev(dev, class_intf); 1214 /* remove the device from the class list */ 1215 klist_del(&dev->knode_class); 1216 mutex_unlock(&dev->class->p->mutex); 1217 } 1218 device_remove_file(dev, &dev_attr_uevent); 1219 device_remove_attrs(dev); 1220 bus_remove_device(dev); 1221 device_pm_remove(dev); 1222 driver_deferred_probe_del(dev); 1223 1224 /* Notify the platform of the removal, in case they 1225 * need to do anything... 1226 */ 1227 if (platform_notify_remove) 1228 platform_notify_remove(dev); 1229 if (dev->bus) 1230 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1231 BUS_NOTIFY_REMOVED_DEVICE, dev); 1232 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 1233 cleanup_device_parent(dev); 1234 kobject_del(&dev->kobj); 1235 put_device(parent); 1236 } 1237 EXPORT_SYMBOL_GPL(device_del); 1238 1239 /** 1240 * device_unregister - unregister device from system. 1241 * @dev: device going away. 1242 * 1243 * We do this in two parts, like we do device_register(). First, 1244 * we remove it from all the subsystems with device_del(), then 1245 * we decrement the reference count via put_device(). If that 1246 * is the final reference count, the device will be cleaned up 1247 * via device_release() above. Otherwise, the structure will 1248 * stick around until the final reference to the device is dropped. 1249 */ 1250 void device_unregister(struct device *dev) 1251 { 1252 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1253 device_del(dev); 1254 put_device(dev); 1255 } 1256 EXPORT_SYMBOL_GPL(device_unregister); 1257 1258 static struct device *next_device(struct klist_iter *i) 1259 { 1260 struct klist_node *n = klist_next(i); 1261 struct device *dev = NULL; 1262 struct device_private *p; 1263 1264 if (n) { 1265 p = to_device_private_parent(n); 1266 dev = p->device; 1267 } 1268 return dev; 1269 } 1270 1271 /** 1272 * device_get_devnode - path of device node file 1273 * @dev: device 1274 * @mode: returned file access mode 1275 * @uid: returned file owner 1276 * @gid: returned file group 1277 * @tmp: possibly allocated string 1278 * 1279 * Return the relative path of a possible device node. 1280 * Non-default names may need to allocate a memory to compose 1281 * a name. This memory is returned in tmp and needs to be 1282 * freed by the caller. 1283 */ 1284 const char *device_get_devnode(struct device *dev, 1285 umode_t *mode, kuid_t *uid, kgid_t *gid, 1286 const char **tmp) 1287 { 1288 char *s; 1289 1290 *tmp = NULL; 1291 1292 /* the device type may provide a specific name */ 1293 if (dev->type && dev->type->devnode) 1294 *tmp = dev->type->devnode(dev, mode, uid, gid); 1295 if (*tmp) 1296 return *tmp; 1297 1298 /* the class may provide a specific name */ 1299 if (dev->class && dev->class->devnode) 1300 *tmp = dev->class->devnode(dev, mode); 1301 if (*tmp) 1302 return *tmp; 1303 1304 /* return name without allocation, tmp == NULL */ 1305 if (strchr(dev_name(dev), '!') == NULL) 1306 return dev_name(dev); 1307 1308 /* replace '!' in the name with '/' */ 1309 s = kstrdup(dev_name(dev), GFP_KERNEL); 1310 if (!s) 1311 return NULL; 1312 strreplace(s, '!', '/'); 1313 return *tmp = s; 1314 } 1315 1316 /** 1317 * device_for_each_child - device child iterator. 1318 * @parent: parent struct device. 1319 * @fn: function to be called for each device. 1320 * @data: data for the callback. 1321 * 1322 * Iterate over @parent's child devices, and call @fn for each, 1323 * passing it @data. 1324 * 1325 * We check the return of @fn each time. If it returns anything 1326 * other than 0, we break out and return that value. 1327 */ 1328 int device_for_each_child(struct device *parent, void *data, 1329 int (*fn)(struct device *dev, void *data)) 1330 { 1331 struct klist_iter i; 1332 struct device *child; 1333 int error = 0; 1334 1335 if (!parent->p) 1336 return 0; 1337 1338 klist_iter_init(&parent->p->klist_children, &i); 1339 while ((child = next_device(&i)) && !error) 1340 error = fn(child, data); 1341 klist_iter_exit(&i); 1342 return error; 1343 } 1344 EXPORT_SYMBOL_GPL(device_for_each_child); 1345 1346 /** 1347 * device_find_child - device iterator for locating a particular device. 1348 * @parent: parent struct device 1349 * @match: Callback function to check device 1350 * @data: Data to pass to match function 1351 * 1352 * This is similar to the device_for_each_child() function above, but it 1353 * returns a reference to a device that is 'found' for later use, as 1354 * determined by the @match callback. 1355 * 1356 * The callback should return 0 if the device doesn't match and non-zero 1357 * if it does. If the callback returns non-zero and a reference to the 1358 * current device can be obtained, this function will return to the caller 1359 * and not iterate over any more devices. 1360 * 1361 * NOTE: you will need to drop the reference with put_device() after use. 1362 */ 1363 struct device *device_find_child(struct device *parent, void *data, 1364 int (*match)(struct device *dev, void *data)) 1365 { 1366 struct klist_iter i; 1367 struct device *child; 1368 1369 if (!parent) 1370 return NULL; 1371 1372 klist_iter_init(&parent->p->klist_children, &i); 1373 while ((child = next_device(&i))) 1374 if (match(child, data) && get_device(child)) 1375 break; 1376 klist_iter_exit(&i); 1377 return child; 1378 } 1379 EXPORT_SYMBOL_GPL(device_find_child); 1380 1381 int __init devices_init(void) 1382 { 1383 devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 1384 if (!devices_kset) 1385 return -ENOMEM; 1386 dev_kobj = kobject_create_and_add("dev", NULL); 1387 if (!dev_kobj) 1388 goto dev_kobj_err; 1389 sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 1390 if (!sysfs_dev_block_kobj) 1391 goto block_kobj_err; 1392 sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 1393 if (!sysfs_dev_char_kobj) 1394 goto char_kobj_err; 1395 1396 return 0; 1397 1398 char_kobj_err: 1399 kobject_put(sysfs_dev_block_kobj); 1400 block_kobj_err: 1401 kobject_put(dev_kobj); 1402 dev_kobj_err: 1403 kset_unregister(devices_kset); 1404 return -ENOMEM; 1405 } 1406 1407 static int device_check_offline(struct device *dev, void *not_used) 1408 { 1409 int ret; 1410 1411 ret = device_for_each_child(dev, NULL, device_check_offline); 1412 if (ret) 1413 return ret; 1414 1415 return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 1416 } 1417 1418 /** 1419 * device_offline - Prepare the device for hot-removal. 1420 * @dev: Device to be put offline. 1421 * 1422 * Execute the device bus type's .offline() callback, if present, to prepare 1423 * the device for a subsequent hot-removal. If that succeeds, the device must 1424 * not be used until either it is removed or its bus type's .online() callback 1425 * is executed. 1426 * 1427 * Call under device_hotplug_lock. 1428 */ 1429 int device_offline(struct device *dev) 1430 { 1431 int ret; 1432 1433 if (dev->offline_disabled) 1434 return -EPERM; 1435 1436 ret = device_for_each_child(dev, NULL, device_check_offline); 1437 if (ret) 1438 return ret; 1439 1440 device_lock(dev); 1441 if (device_supports_offline(dev)) { 1442 if (dev->offline) { 1443 ret = 1; 1444 } else { 1445 ret = dev->bus->offline(dev); 1446 if (!ret) { 1447 kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 1448 dev->offline = true; 1449 } 1450 } 1451 } 1452 device_unlock(dev); 1453 1454 return ret; 1455 } 1456 1457 /** 1458 * device_online - Put the device back online after successful device_offline(). 1459 * @dev: Device to be put back online. 1460 * 1461 * If device_offline() has been successfully executed for @dev, but the device 1462 * has not been removed subsequently, execute its bus type's .online() callback 1463 * to indicate that the device can be used again. 1464 * 1465 * Call under device_hotplug_lock. 1466 */ 1467 int device_online(struct device *dev) 1468 { 1469 int ret = 0; 1470 1471 device_lock(dev); 1472 if (device_supports_offline(dev)) { 1473 if (dev->offline) { 1474 ret = dev->bus->online(dev); 1475 if (!ret) { 1476 kobject_uevent(&dev->kobj, KOBJ_ONLINE); 1477 dev->offline = false; 1478 } 1479 } else { 1480 ret = 1; 1481 } 1482 } 1483 device_unlock(dev); 1484 1485 return ret; 1486 } 1487 1488 struct root_device { 1489 struct device dev; 1490 struct module *owner; 1491 }; 1492 1493 static inline struct root_device *to_root_device(struct device *d) 1494 { 1495 return container_of(d, struct root_device, dev); 1496 } 1497 1498 static void root_device_release(struct device *dev) 1499 { 1500 kfree(to_root_device(dev)); 1501 } 1502 1503 /** 1504 * __root_device_register - allocate and register a root device 1505 * @name: root device name 1506 * @owner: owner module of the root device, usually THIS_MODULE 1507 * 1508 * This function allocates a root device and registers it 1509 * using device_register(). In order to free the returned 1510 * device, use root_device_unregister(). 1511 * 1512 * Root devices are dummy devices which allow other devices 1513 * to be grouped under /sys/devices. Use this function to 1514 * allocate a root device and then use it as the parent of 1515 * any device which should appear under /sys/devices/{name} 1516 * 1517 * The /sys/devices/{name} directory will also contain a 1518 * 'module' symlink which points to the @owner directory 1519 * in sysfs. 1520 * 1521 * Returns &struct device pointer on success, or ERR_PTR() on error. 1522 * 1523 * Note: You probably want to use root_device_register(). 1524 */ 1525 struct device *__root_device_register(const char *name, struct module *owner) 1526 { 1527 struct root_device *root; 1528 int err = -ENOMEM; 1529 1530 root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 1531 if (!root) 1532 return ERR_PTR(err); 1533 1534 err = dev_set_name(&root->dev, "%s", name); 1535 if (err) { 1536 kfree(root); 1537 return ERR_PTR(err); 1538 } 1539 1540 root->dev.release = root_device_release; 1541 1542 err = device_register(&root->dev); 1543 if (err) { 1544 put_device(&root->dev); 1545 return ERR_PTR(err); 1546 } 1547 1548 #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 1549 if (owner) { 1550 struct module_kobject *mk = &owner->mkobj; 1551 1552 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 1553 if (err) { 1554 device_unregister(&root->dev); 1555 return ERR_PTR(err); 1556 } 1557 root->owner = owner; 1558 } 1559 #endif 1560 1561 return &root->dev; 1562 } 1563 EXPORT_SYMBOL_GPL(__root_device_register); 1564 1565 /** 1566 * root_device_unregister - unregister and free a root device 1567 * @dev: device going away 1568 * 1569 * This function unregisters and cleans up a device that was created by 1570 * root_device_register(). 1571 */ 1572 void root_device_unregister(struct device *dev) 1573 { 1574 struct root_device *root = to_root_device(dev); 1575 1576 if (root->owner) 1577 sysfs_remove_link(&root->dev.kobj, "module"); 1578 1579 device_unregister(dev); 1580 } 1581 EXPORT_SYMBOL_GPL(root_device_unregister); 1582 1583 1584 static void device_create_release(struct device *dev) 1585 { 1586 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1587 kfree(dev); 1588 } 1589 1590 static struct device * 1591 device_create_groups_vargs(struct class *class, struct device *parent, 1592 dev_t devt, void *drvdata, 1593 const struct attribute_group **groups, 1594 const char *fmt, va_list args) 1595 { 1596 struct device *dev = NULL; 1597 int retval = -ENODEV; 1598 1599 if (class == NULL || IS_ERR(class)) 1600 goto error; 1601 1602 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1603 if (!dev) { 1604 retval = -ENOMEM; 1605 goto error; 1606 } 1607 1608 device_initialize(dev); 1609 dev->devt = devt; 1610 dev->class = class; 1611 dev->parent = parent; 1612 dev->groups = groups; 1613 dev->release = device_create_release; 1614 dev_set_drvdata(dev, drvdata); 1615 1616 retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 1617 if (retval) 1618 goto error; 1619 1620 retval = device_add(dev); 1621 if (retval) 1622 goto error; 1623 1624 return dev; 1625 1626 error: 1627 put_device(dev); 1628 return ERR_PTR(retval); 1629 } 1630 1631 /** 1632 * device_create_vargs - creates a device and registers it with sysfs 1633 * @class: pointer to the struct class that this device should be registered to 1634 * @parent: pointer to the parent struct device of this new device, if any 1635 * @devt: the dev_t for the char device to be added 1636 * @drvdata: the data to be added to the device for callbacks 1637 * @fmt: string for the device's name 1638 * @args: va_list for the device's name 1639 * 1640 * This function can be used by char device classes. A struct device 1641 * will be created in sysfs, registered to the specified class. 1642 * 1643 * A "dev" file will be created, showing the dev_t for the device, if 1644 * the dev_t is not 0,0. 1645 * If a pointer to a parent struct device is passed in, the newly created 1646 * struct device will be a child of that device in sysfs. 1647 * The pointer to the struct device will be returned from the call. 1648 * Any further sysfs files that might be required can be created using this 1649 * pointer. 1650 * 1651 * Returns &struct device pointer on success, or ERR_PTR() on error. 1652 * 1653 * Note: the struct class passed to this function must have previously 1654 * been created with a call to class_create(). 1655 */ 1656 struct device *device_create_vargs(struct class *class, struct device *parent, 1657 dev_t devt, void *drvdata, const char *fmt, 1658 va_list args) 1659 { 1660 return device_create_groups_vargs(class, parent, devt, drvdata, NULL, 1661 fmt, args); 1662 } 1663 EXPORT_SYMBOL_GPL(device_create_vargs); 1664 1665 /** 1666 * device_create - creates a device and registers it with sysfs 1667 * @class: pointer to the struct class that this device should be registered to 1668 * @parent: pointer to the parent struct device of this new device, if any 1669 * @devt: the dev_t for the char device to be added 1670 * @drvdata: the data to be added to the device for callbacks 1671 * @fmt: string for the device's name 1672 * 1673 * This function can be used by char device classes. A struct device 1674 * will be created in sysfs, registered to the specified class. 1675 * 1676 * A "dev" file will be created, showing the dev_t for the device, if 1677 * the dev_t is not 0,0. 1678 * If a pointer to a parent struct device is passed in, the newly created 1679 * struct device will be a child of that device in sysfs. 1680 * The pointer to the struct device will be returned from the call. 1681 * Any further sysfs files that might be required can be created using this 1682 * pointer. 1683 * 1684 * Returns &struct device pointer on success, or ERR_PTR() on error. 1685 * 1686 * Note: the struct class passed to this function must have previously 1687 * been created with a call to class_create(). 1688 */ 1689 struct device *device_create(struct class *class, struct device *parent, 1690 dev_t devt, void *drvdata, const char *fmt, ...) 1691 { 1692 va_list vargs; 1693 struct device *dev; 1694 1695 va_start(vargs, fmt); 1696 dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs); 1697 va_end(vargs); 1698 return dev; 1699 } 1700 EXPORT_SYMBOL_GPL(device_create); 1701 1702 /** 1703 * device_create_with_groups - creates a device and registers it with sysfs 1704 * @class: pointer to the struct class that this device should be registered to 1705 * @parent: pointer to the parent struct device of this new device, if any 1706 * @devt: the dev_t for the char device to be added 1707 * @drvdata: the data to be added to the device for callbacks 1708 * @groups: NULL-terminated list of attribute groups to be created 1709 * @fmt: string for the device's name 1710 * 1711 * This function can be used by char device classes. A struct device 1712 * will be created in sysfs, registered to the specified class. 1713 * Additional attributes specified in the groups parameter will also 1714 * be created automatically. 1715 * 1716 * A "dev" file will be created, showing the dev_t for the device, if 1717 * the dev_t is not 0,0. 1718 * If a pointer to a parent struct device is passed in, the newly created 1719 * struct device will be a child of that device in sysfs. 1720 * The pointer to the struct device will be returned from the call. 1721 * Any further sysfs files that might be required can be created using this 1722 * pointer. 1723 * 1724 * Returns &struct device pointer on success, or ERR_PTR() on error. 1725 * 1726 * Note: the struct class passed to this function must have previously 1727 * been created with a call to class_create(). 1728 */ 1729 struct device *device_create_with_groups(struct class *class, 1730 struct device *parent, dev_t devt, 1731 void *drvdata, 1732 const struct attribute_group **groups, 1733 const char *fmt, ...) 1734 { 1735 va_list vargs; 1736 struct device *dev; 1737 1738 va_start(vargs, fmt); 1739 dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 1740 fmt, vargs); 1741 va_end(vargs); 1742 return dev; 1743 } 1744 EXPORT_SYMBOL_GPL(device_create_with_groups); 1745 1746 static int __match_devt(struct device *dev, const void *data) 1747 { 1748 const dev_t *devt = data; 1749 1750 return dev->devt == *devt; 1751 } 1752 1753 /** 1754 * device_destroy - removes a device that was created with device_create() 1755 * @class: pointer to the struct class that this device was registered with 1756 * @devt: the dev_t of the device that was previously registered 1757 * 1758 * This call unregisters and cleans up a device that was created with a 1759 * call to device_create(). 1760 */ 1761 void device_destroy(struct class *class, dev_t devt) 1762 { 1763 struct device *dev; 1764 1765 dev = class_find_device(class, NULL, &devt, __match_devt); 1766 if (dev) { 1767 put_device(dev); 1768 device_unregister(dev); 1769 } 1770 } 1771 EXPORT_SYMBOL_GPL(device_destroy); 1772 1773 /** 1774 * device_rename - renames a device 1775 * @dev: the pointer to the struct device to be renamed 1776 * @new_name: the new name of the device 1777 * 1778 * It is the responsibility of the caller to provide mutual 1779 * exclusion between two different calls of device_rename 1780 * on the same device to ensure that new_name is valid and 1781 * won't conflict with other devices. 1782 * 1783 * Note: Don't call this function. Currently, the networking layer calls this 1784 * function, but that will change. The following text from Kay Sievers offers 1785 * some insight: 1786 * 1787 * Renaming devices is racy at many levels, symlinks and other stuff are not 1788 * replaced atomically, and you get a "move" uevent, but it's not easy to 1789 * connect the event to the old and new device. Device nodes are not renamed at 1790 * all, there isn't even support for that in the kernel now. 1791 * 1792 * In the meantime, during renaming, your target name might be taken by another 1793 * driver, creating conflicts. Or the old name is taken directly after you 1794 * renamed it -- then you get events for the same DEVPATH, before you even see 1795 * the "move" event. It's just a mess, and nothing new should ever rely on 1796 * kernel device renaming. Besides that, it's not even implemented now for 1797 * other things than (driver-core wise very simple) network devices. 1798 * 1799 * We are currently about to change network renaming in udev to completely 1800 * disallow renaming of devices in the same namespace as the kernel uses, 1801 * because we can't solve the problems properly, that arise with swapping names 1802 * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 1803 * be allowed to some other name than eth[0-9]*, for the aforementioned 1804 * reasons. 1805 * 1806 * Make up a "real" name in the driver before you register anything, or add 1807 * some other attributes for userspace to find the device, or use udev to add 1808 * symlinks -- but never rename kernel devices later, it's a complete mess. We 1809 * don't even want to get into that and try to implement the missing pieces in 1810 * the core. We really have other pieces to fix in the driver core mess. :) 1811 */ 1812 int device_rename(struct device *dev, const char *new_name) 1813 { 1814 struct kobject *kobj = &dev->kobj; 1815 char *old_device_name = NULL; 1816 int error; 1817 1818 dev = get_device(dev); 1819 if (!dev) 1820 return -EINVAL; 1821 1822 dev_dbg(dev, "renaming to %s\n", new_name); 1823 1824 old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 1825 if (!old_device_name) { 1826 error = -ENOMEM; 1827 goto out; 1828 } 1829 1830 if (dev->class) { 1831 error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 1832 kobj, old_device_name, 1833 new_name, kobject_namespace(kobj)); 1834 if (error) 1835 goto out; 1836 } 1837 1838 error = kobject_rename(kobj, new_name); 1839 if (error) 1840 goto out; 1841 1842 out: 1843 put_device(dev); 1844 1845 kfree(old_device_name); 1846 1847 return error; 1848 } 1849 EXPORT_SYMBOL_GPL(device_rename); 1850 1851 static int device_move_class_links(struct device *dev, 1852 struct device *old_parent, 1853 struct device *new_parent) 1854 { 1855 int error = 0; 1856 1857 if (old_parent) 1858 sysfs_remove_link(&dev->kobj, "device"); 1859 if (new_parent) 1860 error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 1861 "device"); 1862 return error; 1863 } 1864 1865 /** 1866 * device_move - moves a device to a new parent 1867 * @dev: the pointer to the struct device to be moved 1868 * @new_parent: the new parent of the device (can by NULL) 1869 * @dpm_order: how to reorder the dpm_list 1870 */ 1871 int device_move(struct device *dev, struct device *new_parent, 1872 enum dpm_order dpm_order) 1873 { 1874 int error; 1875 struct device *old_parent; 1876 struct kobject *new_parent_kobj; 1877 1878 dev = get_device(dev); 1879 if (!dev) 1880 return -EINVAL; 1881 1882 device_pm_lock(); 1883 new_parent = get_device(new_parent); 1884 new_parent_kobj = get_device_parent(dev, new_parent); 1885 1886 pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 1887 __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 1888 error = kobject_move(&dev->kobj, new_parent_kobj); 1889 if (error) { 1890 cleanup_glue_dir(dev, new_parent_kobj); 1891 put_device(new_parent); 1892 goto out; 1893 } 1894 old_parent = dev->parent; 1895 dev->parent = new_parent; 1896 if (old_parent) 1897 klist_remove(&dev->p->knode_parent); 1898 if (new_parent) { 1899 klist_add_tail(&dev->p->knode_parent, 1900 &new_parent->p->klist_children); 1901 set_dev_node(dev, dev_to_node(new_parent)); 1902 } 1903 1904 if (dev->class) { 1905 error = device_move_class_links(dev, old_parent, new_parent); 1906 if (error) { 1907 /* We ignore errors on cleanup since we're hosed anyway... */ 1908 device_move_class_links(dev, new_parent, old_parent); 1909 if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 1910 if (new_parent) 1911 klist_remove(&dev->p->knode_parent); 1912 dev->parent = old_parent; 1913 if (old_parent) { 1914 klist_add_tail(&dev->p->knode_parent, 1915 &old_parent->p->klist_children); 1916 set_dev_node(dev, dev_to_node(old_parent)); 1917 } 1918 } 1919 cleanup_glue_dir(dev, new_parent_kobj); 1920 put_device(new_parent); 1921 goto out; 1922 } 1923 } 1924 switch (dpm_order) { 1925 case DPM_ORDER_NONE: 1926 break; 1927 case DPM_ORDER_DEV_AFTER_PARENT: 1928 device_pm_move_after(dev, new_parent); 1929 break; 1930 case DPM_ORDER_PARENT_BEFORE_DEV: 1931 device_pm_move_before(new_parent, dev); 1932 break; 1933 case DPM_ORDER_DEV_LAST: 1934 device_pm_move_last(dev); 1935 break; 1936 } 1937 1938 put_device(old_parent); 1939 out: 1940 device_pm_unlock(); 1941 put_device(dev); 1942 return error; 1943 } 1944 EXPORT_SYMBOL_GPL(device_move); 1945 1946 /** 1947 * device_shutdown - call ->shutdown() on each device to shutdown. 1948 */ 1949 void device_shutdown(void) 1950 { 1951 struct device *dev, *parent; 1952 1953 spin_lock(&devices_kset->list_lock); 1954 /* 1955 * Walk the devices list backward, shutting down each in turn. 1956 * Beware that device unplug events may also start pulling 1957 * devices offline, even as the system is shutting down. 1958 */ 1959 while (!list_empty(&devices_kset->list)) { 1960 dev = list_entry(devices_kset->list.prev, struct device, 1961 kobj.entry); 1962 1963 /* 1964 * hold reference count of device's parent to 1965 * prevent it from being freed because parent's 1966 * lock is to be held 1967 */ 1968 parent = get_device(dev->parent); 1969 get_device(dev); 1970 /* 1971 * Make sure the device is off the kset list, in the 1972 * event that dev->*->shutdown() doesn't remove it. 1973 */ 1974 list_del_init(&dev->kobj.entry); 1975 spin_unlock(&devices_kset->list_lock); 1976 1977 /* hold lock to avoid race with probe/release */ 1978 if (parent) 1979 device_lock(parent); 1980 device_lock(dev); 1981 1982 /* Don't allow any more runtime suspends */ 1983 pm_runtime_get_noresume(dev); 1984 pm_runtime_barrier(dev); 1985 1986 if (dev->bus && dev->bus->shutdown) { 1987 if (initcall_debug) 1988 dev_info(dev, "shutdown\n"); 1989 dev->bus->shutdown(dev); 1990 } else if (dev->driver && dev->driver->shutdown) { 1991 if (initcall_debug) 1992 dev_info(dev, "shutdown\n"); 1993 dev->driver->shutdown(dev); 1994 } 1995 1996 device_unlock(dev); 1997 if (parent) 1998 device_unlock(parent); 1999 2000 put_device(dev); 2001 put_device(parent); 2002 2003 spin_lock(&devices_kset->list_lock); 2004 } 2005 spin_unlock(&devices_kset->list_lock); 2006 } 2007 2008 /* 2009 * Device logging functions 2010 */ 2011 2012 #ifdef CONFIG_PRINTK 2013 static int 2014 create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen) 2015 { 2016 const char *subsys; 2017 size_t pos = 0; 2018 2019 if (dev->class) 2020 subsys = dev->class->name; 2021 else if (dev->bus) 2022 subsys = dev->bus->name; 2023 else 2024 return 0; 2025 2026 pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys); 2027 if (pos >= hdrlen) 2028 goto overflow; 2029 2030 /* 2031 * Add device identifier DEVICE=: 2032 * b12:8 block dev_t 2033 * c127:3 char dev_t 2034 * n8 netdev ifindex 2035 * +sound:card0 subsystem:devname 2036 */ 2037 if (MAJOR(dev->devt)) { 2038 char c; 2039 2040 if (strcmp(subsys, "block") == 0) 2041 c = 'b'; 2042 else 2043 c = 'c'; 2044 pos++; 2045 pos += snprintf(hdr + pos, hdrlen - pos, 2046 "DEVICE=%c%u:%u", 2047 c, MAJOR(dev->devt), MINOR(dev->devt)); 2048 } else if (strcmp(subsys, "net") == 0) { 2049 struct net_device *net = to_net_dev(dev); 2050 2051 pos++; 2052 pos += snprintf(hdr + pos, hdrlen - pos, 2053 "DEVICE=n%u", net->ifindex); 2054 } else { 2055 pos++; 2056 pos += snprintf(hdr + pos, hdrlen - pos, 2057 "DEVICE=+%s:%s", subsys, dev_name(dev)); 2058 } 2059 2060 if (pos >= hdrlen) 2061 goto overflow; 2062 2063 return pos; 2064 2065 overflow: 2066 dev_WARN(dev, "device/subsystem name too long"); 2067 return 0; 2068 } 2069 2070 int dev_vprintk_emit(int level, const struct device *dev, 2071 const char *fmt, va_list args) 2072 { 2073 char hdr[128]; 2074 size_t hdrlen; 2075 2076 hdrlen = create_syslog_header(dev, hdr, sizeof(hdr)); 2077 2078 return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args); 2079 } 2080 EXPORT_SYMBOL(dev_vprintk_emit); 2081 2082 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 2083 { 2084 va_list args; 2085 int r; 2086 2087 va_start(args, fmt); 2088 2089 r = dev_vprintk_emit(level, dev, fmt, args); 2090 2091 va_end(args); 2092 2093 return r; 2094 } 2095 EXPORT_SYMBOL(dev_printk_emit); 2096 2097 static void __dev_printk(const char *level, const struct device *dev, 2098 struct va_format *vaf) 2099 { 2100 if (dev) 2101 dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 2102 dev_driver_string(dev), dev_name(dev), vaf); 2103 else 2104 printk("%s(NULL device *): %pV", level, vaf); 2105 } 2106 2107 void dev_printk(const char *level, const struct device *dev, 2108 const char *fmt, ...) 2109 { 2110 struct va_format vaf; 2111 va_list args; 2112 2113 va_start(args, fmt); 2114 2115 vaf.fmt = fmt; 2116 vaf.va = &args; 2117 2118 __dev_printk(level, dev, &vaf); 2119 2120 va_end(args); 2121 } 2122 EXPORT_SYMBOL(dev_printk); 2123 2124 #define define_dev_printk_level(func, kern_level) \ 2125 void func(const struct device *dev, const char *fmt, ...) \ 2126 { \ 2127 struct va_format vaf; \ 2128 va_list args; \ 2129 \ 2130 va_start(args, fmt); \ 2131 \ 2132 vaf.fmt = fmt; \ 2133 vaf.va = &args; \ 2134 \ 2135 __dev_printk(kern_level, dev, &vaf); \ 2136 \ 2137 va_end(args); \ 2138 } \ 2139 EXPORT_SYMBOL(func); 2140 2141 define_dev_printk_level(dev_emerg, KERN_EMERG); 2142 define_dev_printk_level(dev_alert, KERN_ALERT); 2143 define_dev_printk_level(dev_crit, KERN_CRIT); 2144 define_dev_printk_level(dev_err, KERN_ERR); 2145 define_dev_printk_level(dev_warn, KERN_WARNING); 2146 define_dev_printk_level(dev_notice, KERN_NOTICE); 2147 define_dev_printk_level(_dev_info, KERN_INFO); 2148 2149 #endif 2150 2151 static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 2152 { 2153 return fwnode && !IS_ERR(fwnode->secondary); 2154 } 2155 2156 /** 2157 * set_primary_fwnode - Change the primary firmware node of a given device. 2158 * @dev: Device to handle. 2159 * @fwnode: New primary firmware node of the device. 2160 * 2161 * Set the device's firmware node pointer to @fwnode, but if a secondary 2162 * firmware node of the device is present, preserve it. 2163 */ 2164 void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 2165 { 2166 if (fwnode) { 2167 struct fwnode_handle *fn = dev->fwnode; 2168 2169 if (fwnode_is_primary(fn)) 2170 fn = fn->secondary; 2171 2172 fwnode->secondary = fn; 2173 dev->fwnode = fwnode; 2174 } else { 2175 dev->fwnode = fwnode_is_primary(dev->fwnode) ? 2176 dev->fwnode->secondary : NULL; 2177 } 2178 } 2179 EXPORT_SYMBOL_GPL(set_primary_fwnode); 2180 2181 /** 2182 * set_secondary_fwnode - Change the secondary firmware node of a given device. 2183 * @dev: Device to handle. 2184 * @fwnode: New secondary firmware node of the device. 2185 * 2186 * If a primary firmware node of the device is present, set its secondary 2187 * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 2188 * @fwnode. 2189 */ 2190 void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 2191 { 2192 if (fwnode) 2193 fwnode->secondary = ERR_PTR(-ENODEV); 2194 2195 if (fwnode_is_primary(dev->fwnode)) 2196 dev->fwnode->secondary = fwnode; 2197 else 2198 dev->fwnode = fwnode; 2199 } 2200