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 /* Device links support. */ 48 49 #ifdef CONFIG_SRCU 50 static DEFINE_MUTEX(device_links_lock); 51 DEFINE_STATIC_SRCU(device_links_srcu); 52 53 static inline void device_links_write_lock(void) 54 { 55 mutex_lock(&device_links_lock); 56 } 57 58 static inline void device_links_write_unlock(void) 59 { 60 mutex_unlock(&device_links_lock); 61 } 62 63 int device_links_read_lock(void) 64 { 65 return srcu_read_lock(&device_links_srcu); 66 } 67 68 void device_links_read_unlock(int idx) 69 { 70 srcu_read_unlock(&device_links_srcu, idx); 71 } 72 #else /* !CONFIG_SRCU */ 73 static DECLARE_RWSEM(device_links_lock); 74 75 static inline void device_links_write_lock(void) 76 { 77 down_write(&device_links_lock); 78 } 79 80 static inline void device_links_write_unlock(void) 81 { 82 up_write(&device_links_lock); 83 } 84 85 int device_links_read_lock(void) 86 { 87 down_read(&device_links_lock); 88 return 0; 89 } 90 91 void device_links_read_unlock(int not_used) 92 { 93 up_read(&device_links_lock); 94 } 95 #endif /* !CONFIG_SRCU */ 96 97 /** 98 * device_is_dependent - Check if one device depends on another one 99 * @dev: Device to check dependencies for. 100 * @target: Device to check against. 101 * 102 * Check if @target depends on @dev or any device dependent on it (its child or 103 * its consumer etc). Return 1 if that is the case or 0 otherwise. 104 */ 105 static int device_is_dependent(struct device *dev, void *target) 106 { 107 struct device_link *link; 108 int ret; 109 110 if (WARN_ON(dev == target)) 111 return 1; 112 113 ret = device_for_each_child(dev, target, device_is_dependent); 114 if (ret) 115 return ret; 116 117 list_for_each_entry(link, &dev->links.consumers, s_node) { 118 if (WARN_ON(link->consumer == target)) 119 return 1; 120 121 ret = device_is_dependent(link->consumer, target); 122 if (ret) 123 break; 124 } 125 return ret; 126 } 127 128 static int device_reorder_to_tail(struct device *dev, void *not_used) 129 { 130 struct device_link *link; 131 132 /* 133 * Devices that have not been registered yet will be put to the ends 134 * of the lists during the registration, so skip them here. 135 */ 136 if (device_is_registered(dev)) 137 devices_kset_move_last(dev); 138 139 if (device_pm_initialized(dev)) 140 device_pm_move_last(dev); 141 142 device_for_each_child(dev, NULL, device_reorder_to_tail); 143 list_for_each_entry(link, &dev->links.consumers, s_node) 144 device_reorder_to_tail(link->consumer, NULL); 145 146 return 0; 147 } 148 149 /** 150 * device_link_add - Create a link between two devices. 151 * @consumer: Consumer end of the link. 152 * @supplier: Supplier end of the link. 153 * @flags: Link flags. 154 * 155 * The caller is responsible for the proper synchronization of the link creation 156 * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the 157 * runtime PM framework to take the link into account. Second, if the 158 * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will 159 * be forced into the active metastate and reference-counted upon the creation 160 * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be 161 * ignored. 162 * 163 * If the DL_FLAG_AUTOREMOVE is set, the link will be removed automatically 164 * when the consumer device driver unbinds from it. The combination of both 165 * DL_FLAG_AUTOREMOVE and DL_FLAG_STATELESS set is invalid and will cause NULL 166 * to be returned. 167 * 168 * A side effect of the link creation is re-ordering of dpm_list and the 169 * devices_kset list by moving the consumer device and all devices depending 170 * on it to the ends of these lists (that does not happen to devices that have 171 * not been registered when this function is called). 172 * 173 * The supplier device is required to be registered when this function is called 174 * and NULL will be returned if that is not the case. The consumer device need 175 * not be registered, however. 176 */ 177 struct device_link *device_link_add(struct device *consumer, 178 struct device *supplier, u32 flags) 179 { 180 struct device_link *link; 181 182 if (!consumer || !supplier || 183 ((flags & DL_FLAG_STATELESS) && (flags & DL_FLAG_AUTOREMOVE))) 184 return NULL; 185 186 device_links_write_lock(); 187 device_pm_lock(); 188 189 /* 190 * If the supplier has not been fully registered yet or there is a 191 * reverse dependency between the consumer and the supplier already in 192 * the graph, return NULL. 193 */ 194 if (!device_pm_initialized(supplier) 195 || device_is_dependent(consumer, supplier)) { 196 link = NULL; 197 goto out; 198 } 199 200 list_for_each_entry(link, &supplier->links.consumers, s_node) 201 if (link->consumer == consumer) 202 goto out; 203 204 link = kzalloc(sizeof(*link), GFP_KERNEL); 205 if (!link) 206 goto out; 207 208 if (flags & DL_FLAG_PM_RUNTIME) { 209 if (flags & DL_FLAG_RPM_ACTIVE) { 210 if (pm_runtime_get_sync(supplier) < 0) { 211 pm_runtime_put_noidle(supplier); 212 kfree(link); 213 link = NULL; 214 goto out; 215 } 216 link->rpm_active = true; 217 } 218 pm_runtime_new_link(consumer); 219 } 220 get_device(supplier); 221 link->supplier = supplier; 222 INIT_LIST_HEAD(&link->s_node); 223 get_device(consumer); 224 link->consumer = consumer; 225 INIT_LIST_HEAD(&link->c_node); 226 link->flags = flags; 227 228 /* Determine the initial link state. */ 229 if (flags & DL_FLAG_STATELESS) { 230 link->status = DL_STATE_NONE; 231 } else { 232 switch (supplier->links.status) { 233 case DL_DEV_DRIVER_BOUND: 234 switch (consumer->links.status) { 235 case DL_DEV_PROBING: 236 /* 237 * Balance the decrementation of the supplier's 238 * runtime PM usage counter after consumer probe 239 * in driver_probe_device(). 240 */ 241 if (flags & DL_FLAG_PM_RUNTIME) 242 pm_runtime_get_sync(supplier); 243 244 link->status = DL_STATE_CONSUMER_PROBE; 245 break; 246 case DL_DEV_DRIVER_BOUND: 247 link->status = DL_STATE_ACTIVE; 248 break; 249 default: 250 link->status = DL_STATE_AVAILABLE; 251 break; 252 } 253 break; 254 case DL_DEV_UNBINDING: 255 link->status = DL_STATE_SUPPLIER_UNBIND; 256 break; 257 default: 258 link->status = DL_STATE_DORMANT; 259 break; 260 } 261 } 262 263 /* 264 * Move the consumer and all of the devices depending on it to the end 265 * of dpm_list and the devices_kset list. 266 * 267 * It is necessary to hold dpm_list locked throughout all that or else 268 * we may end up suspending with a wrong ordering of it. 269 */ 270 device_reorder_to_tail(consumer, NULL); 271 272 list_add_tail_rcu(&link->s_node, &supplier->links.consumers); 273 list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 274 275 dev_info(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); 276 277 out: 278 device_pm_unlock(); 279 device_links_write_unlock(); 280 return link; 281 } 282 EXPORT_SYMBOL_GPL(device_link_add); 283 284 static void device_link_free(struct device_link *link) 285 { 286 put_device(link->consumer); 287 put_device(link->supplier); 288 kfree(link); 289 } 290 291 #ifdef CONFIG_SRCU 292 static void __device_link_free_srcu(struct rcu_head *rhead) 293 { 294 device_link_free(container_of(rhead, struct device_link, rcu_head)); 295 } 296 297 static void __device_link_del(struct device_link *link) 298 { 299 dev_info(link->consumer, "Dropping the link to %s\n", 300 dev_name(link->supplier)); 301 302 if (link->flags & DL_FLAG_PM_RUNTIME) 303 pm_runtime_drop_link(link->consumer); 304 305 list_del_rcu(&link->s_node); 306 list_del_rcu(&link->c_node); 307 call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu); 308 } 309 #else /* !CONFIG_SRCU */ 310 static void __device_link_del(struct device_link *link) 311 { 312 dev_info(link->consumer, "Dropping the link to %s\n", 313 dev_name(link->supplier)); 314 315 list_del(&link->s_node); 316 list_del(&link->c_node); 317 device_link_free(link); 318 } 319 #endif /* !CONFIG_SRCU */ 320 321 /** 322 * device_link_del - Delete a link between two devices. 323 * @link: Device link to delete. 324 * 325 * The caller must ensure proper synchronization of this function with runtime 326 * PM. 327 */ 328 void device_link_del(struct device_link *link) 329 { 330 device_links_write_lock(); 331 device_pm_lock(); 332 __device_link_del(link); 333 device_pm_unlock(); 334 device_links_write_unlock(); 335 } 336 EXPORT_SYMBOL_GPL(device_link_del); 337 338 static void device_links_missing_supplier(struct device *dev) 339 { 340 struct device_link *link; 341 342 list_for_each_entry(link, &dev->links.suppliers, c_node) 343 if (link->status == DL_STATE_CONSUMER_PROBE) 344 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 345 } 346 347 /** 348 * device_links_check_suppliers - Check presence of supplier drivers. 349 * @dev: Consumer device. 350 * 351 * Check links from this device to any suppliers. Walk the list of the device's 352 * links to suppliers and see if all of them are available. If not, simply 353 * return -EPROBE_DEFER. 354 * 355 * We need to guarantee that the supplier will not go away after the check has 356 * been positive here. It only can go away in __device_release_driver() and 357 * that function checks the device's links to consumers. This means we need to 358 * mark the link as "consumer probe in progress" to make the supplier removal 359 * wait for us to complete (or bad things may happen). 360 * 361 * Links with the DL_FLAG_STATELESS flag set are ignored. 362 */ 363 int device_links_check_suppliers(struct device *dev) 364 { 365 struct device_link *link; 366 int ret = 0; 367 368 device_links_write_lock(); 369 370 list_for_each_entry(link, &dev->links.suppliers, c_node) { 371 if (link->flags & DL_FLAG_STATELESS) 372 continue; 373 374 if (link->status != DL_STATE_AVAILABLE) { 375 device_links_missing_supplier(dev); 376 ret = -EPROBE_DEFER; 377 break; 378 } 379 WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 380 } 381 dev->links.status = DL_DEV_PROBING; 382 383 device_links_write_unlock(); 384 return ret; 385 } 386 387 /** 388 * device_links_driver_bound - Update device links after probing its driver. 389 * @dev: Device to update the links for. 390 * 391 * The probe has been successful, so update links from this device to any 392 * consumers by changing their status to "available". 393 * 394 * Also change the status of @dev's links to suppliers to "active". 395 * 396 * Links with the DL_FLAG_STATELESS flag set are ignored. 397 */ 398 void device_links_driver_bound(struct device *dev) 399 { 400 struct device_link *link; 401 402 device_links_write_lock(); 403 404 list_for_each_entry(link, &dev->links.consumers, s_node) { 405 if (link->flags & DL_FLAG_STATELESS) 406 continue; 407 408 WARN_ON(link->status != DL_STATE_DORMANT); 409 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 410 } 411 412 list_for_each_entry(link, &dev->links.suppliers, c_node) { 413 if (link->flags & DL_FLAG_STATELESS) 414 continue; 415 416 WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); 417 WRITE_ONCE(link->status, DL_STATE_ACTIVE); 418 } 419 420 dev->links.status = DL_DEV_DRIVER_BOUND; 421 422 device_links_write_unlock(); 423 } 424 425 /** 426 * __device_links_no_driver - Update links of a device without a driver. 427 * @dev: Device without a drvier. 428 * 429 * Delete all non-persistent links from this device to any suppliers. 430 * 431 * Persistent links stay around, but their status is changed to "available", 432 * unless they already are in the "supplier unbind in progress" state in which 433 * case they need not be updated. 434 * 435 * Links with the DL_FLAG_STATELESS flag set are ignored. 436 */ 437 static void __device_links_no_driver(struct device *dev) 438 { 439 struct device_link *link, *ln; 440 441 list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 442 if (link->flags & DL_FLAG_STATELESS) 443 continue; 444 445 if (link->flags & DL_FLAG_AUTOREMOVE) 446 __device_link_del(link); 447 else if (link->status != DL_STATE_SUPPLIER_UNBIND) 448 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 449 } 450 451 dev->links.status = DL_DEV_NO_DRIVER; 452 } 453 454 void device_links_no_driver(struct device *dev) 455 { 456 device_links_write_lock(); 457 __device_links_no_driver(dev); 458 device_links_write_unlock(); 459 } 460 461 /** 462 * device_links_driver_cleanup - Update links after driver removal. 463 * @dev: Device whose driver has just gone away. 464 * 465 * Update links to consumers for @dev by changing their status to "dormant" and 466 * invoke %__device_links_no_driver() to update links to suppliers for it as 467 * appropriate. 468 * 469 * Links with the DL_FLAG_STATELESS flag set are ignored. 470 */ 471 void device_links_driver_cleanup(struct device *dev) 472 { 473 struct device_link *link; 474 475 device_links_write_lock(); 476 477 list_for_each_entry(link, &dev->links.consumers, s_node) { 478 if (link->flags & DL_FLAG_STATELESS) 479 continue; 480 481 WARN_ON(link->flags & DL_FLAG_AUTOREMOVE); 482 WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); 483 WRITE_ONCE(link->status, DL_STATE_DORMANT); 484 } 485 486 __device_links_no_driver(dev); 487 488 device_links_write_unlock(); 489 } 490 491 /** 492 * device_links_busy - Check if there are any busy links to consumers. 493 * @dev: Device to check. 494 * 495 * Check each consumer of the device and return 'true' if its link's status 496 * is one of "consumer probe" or "active" (meaning that the given consumer is 497 * probing right now or its driver is present). Otherwise, change the link 498 * state to "supplier unbind" to prevent the consumer from being probed 499 * successfully going forward. 500 * 501 * Return 'false' if there are no probing or active consumers. 502 * 503 * Links with the DL_FLAG_STATELESS flag set are ignored. 504 */ 505 bool device_links_busy(struct device *dev) 506 { 507 struct device_link *link; 508 bool ret = false; 509 510 device_links_write_lock(); 511 512 list_for_each_entry(link, &dev->links.consumers, s_node) { 513 if (link->flags & DL_FLAG_STATELESS) 514 continue; 515 516 if (link->status == DL_STATE_CONSUMER_PROBE 517 || link->status == DL_STATE_ACTIVE) { 518 ret = true; 519 break; 520 } 521 WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 522 } 523 524 dev->links.status = DL_DEV_UNBINDING; 525 526 device_links_write_unlock(); 527 return ret; 528 } 529 530 /** 531 * device_links_unbind_consumers - Force unbind consumers of the given device. 532 * @dev: Device to unbind the consumers of. 533 * 534 * Walk the list of links to consumers for @dev and if any of them is in the 535 * "consumer probe" state, wait for all device probes in progress to complete 536 * and start over. 537 * 538 * If that's not the case, change the status of the link to "supplier unbind" 539 * and check if the link was in the "active" state. If so, force the consumer 540 * driver to unbind and start over (the consumer will not re-probe as we have 541 * changed the state of the link already). 542 * 543 * Links with the DL_FLAG_STATELESS flag set are ignored. 544 */ 545 void device_links_unbind_consumers(struct device *dev) 546 { 547 struct device_link *link; 548 549 start: 550 device_links_write_lock(); 551 552 list_for_each_entry(link, &dev->links.consumers, s_node) { 553 enum device_link_state status; 554 555 if (link->flags & DL_FLAG_STATELESS) 556 continue; 557 558 status = link->status; 559 if (status == DL_STATE_CONSUMER_PROBE) { 560 device_links_write_unlock(); 561 562 wait_for_device_probe(); 563 goto start; 564 } 565 WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 566 if (status == DL_STATE_ACTIVE) { 567 struct device *consumer = link->consumer; 568 569 get_device(consumer); 570 571 device_links_write_unlock(); 572 573 device_release_driver_internal(consumer, NULL, 574 consumer->parent); 575 put_device(consumer); 576 goto start; 577 } 578 } 579 580 device_links_write_unlock(); 581 } 582 583 /** 584 * device_links_purge - Delete existing links to other devices. 585 * @dev: Target device. 586 */ 587 static void device_links_purge(struct device *dev) 588 { 589 struct device_link *link, *ln; 590 591 /* 592 * Delete all of the remaining links from this device to any other 593 * devices (either consumers or suppliers). 594 */ 595 device_links_write_lock(); 596 597 list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 598 WARN_ON(link->status == DL_STATE_ACTIVE); 599 __device_link_del(link); 600 } 601 602 list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { 603 WARN_ON(link->status != DL_STATE_DORMANT && 604 link->status != DL_STATE_NONE); 605 __device_link_del(link); 606 } 607 608 device_links_write_unlock(); 609 } 610 611 /* Device links support end. */ 612 613 int (*platform_notify)(struct device *dev) = NULL; 614 int (*platform_notify_remove)(struct device *dev) = NULL; 615 static struct kobject *dev_kobj; 616 struct kobject *sysfs_dev_char_kobj; 617 struct kobject *sysfs_dev_block_kobj; 618 619 static DEFINE_MUTEX(device_hotplug_lock); 620 621 void lock_device_hotplug(void) 622 { 623 mutex_lock(&device_hotplug_lock); 624 } 625 626 void unlock_device_hotplug(void) 627 { 628 mutex_unlock(&device_hotplug_lock); 629 } 630 631 int lock_device_hotplug_sysfs(void) 632 { 633 if (mutex_trylock(&device_hotplug_lock)) 634 return 0; 635 636 /* Avoid busy looping (5 ms of sleep should do). */ 637 msleep(5); 638 return restart_syscall(); 639 } 640 641 #ifdef CONFIG_BLOCK 642 static inline int device_is_not_partition(struct device *dev) 643 { 644 return !(dev->type == &part_type); 645 } 646 #else 647 static inline int device_is_not_partition(struct device *dev) 648 { 649 return 1; 650 } 651 #endif 652 653 /** 654 * dev_driver_string - Return a device's driver name, if at all possible 655 * @dev: struct device to get the name of 656 * 657 * Will return the device's driver's name if it is bound to a device. If 658 * the device is not bound to a driver, it will return the name of the bus 659 * it is attached to. If it is not attached to a bus either, an empty 660 * string will be returned. 661 */ 662 const char *dev_driver_string(const struct device *dev) 663 { 664 struct device_driver *drv; 665 666 /* dev->driver can change to NULL underneath us because of unbinding, 667 * so be careful about accessing it. dev->bus and dev->class should 668 * never change once they are set, so they don't need special care. 669 */ 670 drv = ACCESS_ONCE(dev->driver); 671 return drv ? drv->name : 672 (dev->bus ? dev->bus->name : 673 (dev->class ? dev->class->name : "")); 674 } 675 EXPORT_SYMBOL(dev_driver_string); 676 677 #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 678 679 static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 680 char *buf) 681 { 682 struct device_attribute *dev_attr = to_dev_attr(attr); 683 struct device *dev = kobj_to_dev(kobj); 684 ssize_t ret = -EIO; 685 686 if (dev_attr->show) 687 ret = dev_attr->show(dev, dev_attr, buf); 688 if (ret >= (ssize_t)PAGE_SIZE) { 689 print_symbol("dev_attr_show: %s returned bad count\n", 690 (unsigned long)dev_attr->show); 691 } 692 return ret; 693 } 694 695 static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 696 const char *buf, size_t count) 697 { 698 struct device_attribute *dev_attr = to_dev_attr(attr); 699 struct device *dev = kobj_to_dev(kobj); 700 ssize_t ret = -EIO; 701 702 if (dev_attr->store) 703 ret = dev_attr->store(dev, dev_attr, buf, count); 704 return ret; 705 } 706 707 static const struct sysfs_ops dev_sysfs_ops = { 708 .show = dev_attr_show, 709 .store = dev_attr_store, 710 }; 711 712 #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 713 714 ssize_t device_store_ulong(struct device *dev, 715 struct device_attribute *attr, 716 const char *buf, size_t size) 717 { 718 struct dev_ext_attribute *ea = to_ext_attr(attr); 719 char *end; 720 unsigned long new = simple_strtoul(buf, &end, 0); 721 if (end == buf) 722 return -EINVAL; 723 *(unsigned long *)(ea->var) = new; 724 /* Always return full write size even if we didn't consume all */ 725 return size; 726 } 727 EXPORT_SYMBOL_GPL(device_store_ulong); 728 729 ssize_t device_show_ulong(struct device *dev, 730 struct device_attribute *attr, 731 char *buf) 732 { 733 struct dev_ext_attribute *ea = to_ext_attr(attr); 734 return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var)); 735 } 736 EXPORT_SYMBOL_GPL(device_show_ulong); 737 738 ssize_t device_store_int(struct device *dev, 739 struct device_attribute *attr, 740 const char *buf, size_t size) 741 { 742 struct dev_ext_attribute *ea = to_ext_attr(attr); 743 char *end; 744 long new = simple_strtol(buf, &end, 0); 745 if (end == buf || new > INT_MAX || new < INT_MIN) 746 return -EINVAL; 747 *(int *)(ea->var) = new; 748 /* Always return full write size even if we didn't consume all */ 749 return size; 750 } 751 EXPORT_SYMBOL_GPL(device_store_int); 752 753 ssize_t device_show_int(struct device *dev, 754 struct device_attribute *attr, 755 char *buf) 756 { 757 struct dev_ext_attribute *ea = to_ext_attr(attr); 758 759 return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var)); 760 } 761 EXPORT_SYMBOL_GPL(device_show_int); 762 763 ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 764 const char *buf, size_t size) 765 { 766 struct dev_ext_attribute *ea = to_ext_attr(attr); 767 768 if (strtobool(buf, ea->var) < 0) 769 return -EINVAL; 770 771 return size; 772 } 773 EXPORT_SYMBOL_GPL(device_store_bool); 774 775 ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 776 char *buf) 777 { 778 struct dev_ext_attribute *ea = to_ext_attr(attr); 779 780 return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var)); 781 } 782 EXPORT_SYMBOL_GPL(device_show_bool); 783 784 /** 785 * device_release - free device structure. 786 * @kobj: device's kobject. 787 * 788 * This is called once the reference count for the object 789 * reaches 0. We forward the call to the device's release 790 * method, which should handle actually freeing the structure. 791 */ 792 static void device_release(struct kobject *kobj) 793 { 794 struct device *dev = kobj_to_dev(kobj); 795 struct device_private *p = dev->p; 796 797 /* 798 * Some platform devices are driven without driver attached 799 * and managed resources may have been acquired. Make sure 800 * all resources are released. 801 * 802 * Drivers still can add resources into device after device 803 * is deleted but alive, so release devres here to avoid 804 * possible memory leak. 805 */ 806 devres_release_all(dev); 807 808 if (dev->release) 809 dev->release(dev); 810 else if (dev->type && dev->type->release) 811 dev->type->release(dev); 812 else if (dev->class && dev->class->dev_release) 813 dev->class->dev_release(dev); 814 else 815 WARN(1, KERN_ERR "Device '%s' does not have a release() " 816 "function, it is broken and must be fixed.\n", 817 dev_name(dev)); 818 kfree(p); 819 } 820 821 static const void *device_namespace(struct kobject *kobj) 822 { 823 struct device *dev = kobj_to_dev(kobj); 824 const void *ns = NULL; 825 826 if (dev->class && dev->class->ns_type) 827 ns = dev->class->namespace(dev); 828 829 return ns; 830 } 831 832 static struct kobj_type device_ktype = { 833 .release = device_release, 834 .sysfs_ops = &dev_sysfs_ops, 835 .namespace = device_namespace, 836 }; 837 838 839 static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 840 { 841 struct kobj_type *ktype = get_ktype(kobj); 842 843 if (ktype == &device_ktype) { 844 struct device *dev = kobj_to_dev(kobj); 845 if (dev->bus) 846 return 1; 847 if (dev->class) 848 return 1; 849 } 850 return 0; 851 } 852 853 static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 854 { 855 struct device *dev = kobj_to_dev(kobj); 856 857 if (dev->bus) 858 return dev->bus->name; 859 if (dev->class) 860 return dev->class->name; 861 return NULL; 862 } 863 864 static int dev_uevent(struct kset *kset, struct kobject *kobj, 865 struct kobj_uevent_env *env) 866 { 867 struct device *dev = kobj_to_dev(kobj); 868 int retval = 0; 869 870 /* add device node properties if present */ 871 if (MAJOR(dev->devt)) { 872 const char *tmp; 873 const char *name; 874 umode_t mode = 0; 875 kuid_t uid = GLOBAL_ROOT_UID; 876 kgid_t gid = GLOBAL_ROOT_GID; 877 878 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 879 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 880 name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 881 if (name) { 882 add_uevent_var(env, "DEVNAME=%s", name); 883 if (mode) 884 add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 885 if (!uid_eq(uid, GLOBAL_ROOT_UID)) 886 add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 887 if (!gid_eq(gid, GLOBAL_ROOT_GID)) 888 add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 889 kfree(tmp); 890 } 891 } 892 893 if (dev->type && dev->type->name) 894 add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 895 896 if (dev->driver) 897 add_uevent_var(env, "DRIVER=%s", dev->driver->name); 898 899 /* Add common DT information about the device */ 900 of_device_uevent(dev, env); 901 902 /* have the bus specific function add its stuff */ 903 if (dev->bus && dev->bus->uevent) { 904 retval = dev->bus->uevent(dev, env); 905 if (retval) 906 pr_debug("device: '%s': %s: bus uevent() returned %d\n", 907 dev_name(dev), __func__, retval); 908 } 909 910 /* have the class specific function add its stuff */ 911 if (dev->class && dev->class->dev_uevent) { 912 retval = dev->class->dev_uevent(dev, env); 913 if (retval) 914 pr_debug("device: '%s': %s: class uevent() " 915 "returned %d\n", dev_name(dev), 916 __func__, retval); 917 } 918 919 /* have the device type specific function add its stuff */ 920 if (dev->type && dev->type->uevent) { 921 retval = dev->type->uevent(dev, env); 922 if (retval) 923 pr_debug("device: '%s': %s: dev_type uevent() " 924 "returned %d\n", dev_name(dev), 925 __func__, retval); 926 } 927 928 return retval; 929 } 930 931 static const struct kset_uevent_ops device_uevent_ops = { 932 .filter = dev_uevent_filter, 933 .name = dev_uevent_name, 934 .uevent = dev_uevent, 935 }; 936 937 static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 938 char *buf) 939 { 940 struct kobject *top_kobj; 941 struct kset *kset; 942 struct kobj_uevent_env *env = NULL; 943 int i; 944 size_t count = 0; 945 int retval; 946 947 /* search the kset, the device belongs to */ 948 top_kobj = &dev->kobj; 949 while (!top_kobj->kset && top_kobj->parent) 950 top_kobj = top_kobj->parent; 951 if (!top_kobj->kset) 952 goto out; 953 954 kset = top_kobj->kset; 955 if (!kset->uevent_ops || !kset->uevent_ops->uevent) 956 goto out; 957 958 /* respect filter */ 959 if (kset->uevent_ops && kset->uevent_ops->filter) 960 if (!kset->uevent_ops->filter(kset, &dev->kobj)) 961 goto out; 962 963 env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 964 if (!env) 965 return -ENOMEM; 966 967 /* let the kset specific function add its keys */ 968 retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 969 if (retval) 970 goto out; 971 972 /* copy keys to file */ 973 for (i = 0; i < env->envp_idx; i++) 974 count += sprintf(&buf[count], "%s\n", env->envp[i]); 975 out: 976 kfree(env); 977 return count; 978 } 979 980 static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 981 const char *buf, size_t count) 982 { 983 enum kobject_action action; 984 985 if (kobject_action_type(buf, count, &action) == 0) 986 kobject_uevent(&dev->kobj, action); 987 else 988 dev_err(dev, "uevent: unknown action-string\n"); 989 return count; 990 } 991 static DEVICE_ATTR_RW(uevent); 992 993 static ssize_t online_show(struct device *dev, struct device_attribute *attr, 994 char *buf) 995 { 996 bool val; 997 998 device_lock(dev); 999 val = !dev->offline; 1000 device_unlock(dev); 1001 return sprintf(buf, "%u\n", val); 1002 } 1003 1004 static ssize_t online_store(struct device *dev, struct device_attribute *attr, 1005 const char *buf, size_t count) 1006 { 1007 bool val; 1008 int ret; 1009 1010 ret = strtobool(buf, &val); 1011 if (ret < 0) 1012 return ret; 1013 1014 ret = lock_device_hotplug_sysfs(); 1015 if (ret) 1016 return ret; 1017 1018 ret = val ? device_online(dev) : device_offline(dev); 1019 unlock_device_hotplug(); 1020 return ret < 0 ? ret : count; 1021 } 1022 static DEVICE_ATTR_RW(online); 1023 1024 int device_add_groups(struct device *dev, const struct attribute_group **groups) 1025 { 1026 return sysfs_create_groups(&dev->kobj, groups); 1027 } 1028 1029 void device_remove_groups(struct device *dev, 1030 const struct attribute_group **groups) 1031 { 1032 sysfs_remove_groups(&dev->kobj, groups); 1033 } 1034 1035 static int device_add_attrs(struct device *dev) 1036 { 1037 struct class *class = dev->class; 1038 const struct device_type *type = dev->type; 1039 int error; 1040 1041 if (class) { 1042 error = device_add_groups(dev, class->dev_groups); 1043 if (error) 1044 return error; 1045 } 1046 1047 if (type) { 1048 error = device_add_groups(dev, type->groups); 1049 if (error) 1050 goto err_remove_class_groups; 1051 } 1052 1053 error = device_add_groups(dev, dev->groups); 1054 if (error) 1055 goto err_remove_type_groups; 1056 1057 if (device_supports_offline(dev) && !dev->offline_disabled) { 1058 error = device_create_file(dev, &dev_attr_online); 1059 if (error) 1060 goto err_remove_dev_groups; 1061 } 1062 1063 error = device_create_file(dev, &dev_attr_deferred_probe); 1064 if (error) 1065 goto err_remove_online; 1066 1067 return 0; 1068 1069 err_remove_online: 1070 device_remove_file(dev, &dev_attr_online); 1071 err_remove_dev_groups: 1072 device_remove_groups(dev, dev->groups); 1073 err_remove_type_groups: 1074 if (type) 1075 device_remove_groups(dev, type->groups); 1076 err_remove_class_groups: 1077 if (class) 1078 device_remove_groups(dev, class->dev_groups); 1079 1080 return error; 1081 } 1082 1083 static void device_remove_attrs(struct device *dev) 1084 { 1085 struct class *class = dev->class; 1086 const struct device_type *type = dev->type; 1087 1088 device_remove_file(dev, &dev_attr_deferred_probe); 1089 device_remove_file(dev, &dev_attr_online); 1090 device_remove_groups(dev, dev->groups); 1091 1092 if (type) 1093 device_remove_groups(dev, type->groups); 1094 1095 if (class) 1096 device_remove_groups(dev, class->dev_groups); 1097 } 1098 1099 static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 1100 char *buf) 1101 { 1102 return print_dev_t(buf, dev->devt); 1103 } 1104 static DEVICE_ATTR_RO(dev); 1105 1106 /* /sys/devices/ */ 1107 struct kset *devices_kset; 1108 1109 /** 1110 * devices_kset_move_before - Move device in the devices_kset's list. 1111 * @deva: Device to move. 1112 * @devb: Device @deva should come before. 1113 */ 1114 static void devices_kset_move_before(struct device *deva, struct device *devb) 1115 { 1116 if (!devices_kset) 1117 return; 1118 pr_debug("devices_kset: Moving %s before %s\n", 1119 dev_name(deva), dev_name(devb)); 1120 spin_lock(&devices_kset->list_lock); 1121 list_move_tail(&deva->kobj.entry, &devb->kobj.entry); 1122 spin_unlock(&devices_kset->list_lock); 1123 } 1124 1125 /** 1126 * devices_kset_move_after - Move device in the devices_kset's list. 1127 * @deva: Device to move 1128 * @devb: Device @deva should come after. 1129 */ 1130 static void devices_kset_move_after(struct device *deva, struct device *devb) 1131 { 1132 if (!devices_kset) 1133 return; 1134 pr_debug("devices_kset: Moving %s after %s\n", 1135 dev_name(deva), dev_name(devb)); 1136 spin_lock(&devices_kset->list_lock); 1137 list_move(&deva->kobj.entry, &devb->kobj.entry); 1138 spin_unlock(&devices_kset->list_lock); 1139 } 1140 1141 /** 1142 * devices_kset_move_last - move the device to the end of devices_kset's list. 1143 * @dev: device to move 1144 */ 1145 void devices_kset_move_last(struct device *dev) 1146 { 1147 if (!devices_kset) 1148 return; 1149 pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev)); 1150 spin_lock(&devices_kset->list_lock); 1151 list_move_tail(&dev->kobj.entry, &devices_kset->list); 1152 spin_unlock(&devices_kset->list_lock); 1153 } 1154 1155 /** 1156 * device_create_file - create sysfs attribute file for device. 1157 * @dev: device. 1158 * @attr: device attribute descriptor. 1159 */ 1160 int device_create_file(struct device *dev, 1161 const struct device_attribute *attr) 1162 { 1163 int error = 0; 1164 1165 if (dev) { 1166 WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 1167 "Attribute %s: write permission without 'store'\n", 1168 attr->attr.name); 1169 WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 1170 "Attribute %s: read permission without 'show'\n", 1171 attr->attr.name); 1172 error = sysfs_create_file(&dev->kobj, &attr->attr); 1173 } 1174 1175 return error; 1176 } 1177 EXPORT_SYMBOL_GPL(device_create_file); 1178 1179 /** 1180 * device_remove_file - remove sysfs attribute file. 1181 * @dev: device. 1182 * @attr: device attribute descriptor. 1183 */ 1184 void device_remove_file(struct device *dev, 1185 const struct device_attribute *attr) 1186 { 1187 if (dev) 1188 sysfs_remove_file(&dev->kobj, &attr->attr); 1189 } 1190 EXPORT_SYMBOL_GPL(device_remove_file); 1191 1192 /** 1193 * device_remove_file_self - remove sysfs attribute file from its own method. 1194 * @dev: device. 1195 * @attr: device attribute descriptor. 1196 * 1197 * See kernfs_remove_self() for details. 1198 */ 1199 bool device_remove_file_self(struct device *dev, 1200 const struct device_attribute *attr) 1201 { 1202 if (dev) 1203 return sysfs_remove_file_self(&dev->kobj, &attr->attr); 1204 else 1205 return false; 1206 } 1207 EXPORT_SYMBOL_GPL(device_remove_file_self); 1208 1209 /** 1210 * device_create_bin_file - create sysfs binary attribute file for device. 1211 * @dev: device. 1212 * @attr: device binary attribute descriptor. 1213 */ 1214 int device_create_bin_file(struct device *dev, 1215 const struct bin_attribute *attr) 1216 { 1217 int error = -EINVAL; 1218 if (dev) 1219 error = sysfs_create_bin_file(&dev->kobj, attr); 1220 return error; 1221 } 1222 EXPORT_SYMBOL_GPL(device_create_bin_file); 1223 1224 /** 1225 * device_remove_bin_file - remove sysfs binary attribute file 1226 * @dev: device. 1227 * @attr: device binary attribute descriptor. 1228 */ 1229 void device_remove_bin_file(struct device *dev, 1230 const struct bin_attribute *attr) 1231 { 1232 if (dev) 1233 sysfs_remove_bin_file(&dev->kobj, attr); 1234 } 1235 EXPORT_SYMBOL_GPL(device_remove_bin_file); 1236 1237 static void klist_children_get(struct klist_node *n) 1238 { 1239 struct device_private *p = to_device_private_parent(n); 1240 struct device *dev = p->device; 1241 1242 get_device(dev); 1243 } 1244 1245 static void klist_children_put(struct klist_node *n) 1246 { 1247 struct device_private *p = to_device_private_parent(n); 1248 struct device *dev = p->device; 1249 1250 put_device(dev); 1251 } 1252 1253 /** 1254 * device_initialize - init device structure. 1255 * @dev: device. 1256 * 1257 * This prepares the device for use by other layers by initializing 1258 * its fields. 1259 * It is the first half of device_register(), if called by 1260 * that function, though it can also be called separately, so one 1261 * may use @dev's fields. In particular, get_device()/put_device() 1262 * may be used for reference counting of @dev after calling this 1263 * function. 1264 * 1265 * All fields in @dev must be initialized by the caller to 0, except 1266 * for those explicitly set to some other value. The simplest 1267 * approach is to use kzalloc() to allocate the structure containing 1268 * @dev. 1269 * 1270 * NOTE: Use put_device() to give up your reference instead of freeing 1271 * @dev directly once you have called this function. 1272 */ 1273 void device_initialize(struct device *dev) 1274 { 1275 dev->kobj.kset = devices_kset; 1276 kobject_init(&dev->kobj, &device_ktype); 1277 INIT_LIST_HEAD(&dev->dma_pools); 1278 mutex_init(&dev->mutex); 1279 lockdep_set_novalidate_class(&dev->mutex); 1280 spin_lock_init(&dev->devres_lock); 1281 INIT_LIST_HEAD(&dev->devres_head); 1282 device_pm_init(dev); 1283 set_dev_node(dev, -1); 1284 #ifdef CONFIG_GENERIC_MSI_IRQ 1285 INIT_LIST_HEAD(&dev->msi_list); 1286 #endif 1287 INIT_LIST_HEAD(&dev->links.consumers); 1288 INIT_LIST_HEAD(&dev->links.suppliers); 1289 dev->links.status = DL_DEV_NO_DRIVER; 1290 } 1291 EXPORT_SYMBOL_GPL(device_initialize); 1292 1293 struct kobject *virtual_device_parent(struct device *dev) 1294 { 1295 static struct kobject *virtual_dir = NULL; 1296 1297 if (!virtual_dir) 1298 virtual_dir = kobject_create_and_add("virtual", 1299 &devices_kset->kobj); 1300 1301 return virtual_dir; 1302 } 1303 1304 struct class_dir { 1305 struct kobject kobj; 1306 struct class *class; 1307 }; 1308 1309 #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 1310 1311 static void class_dir_release(struct kobject *kobj) 1312 { 1313 struct class_dir *dir = to_class_dir(kobj); 1314 kfree(dir); 1315 } 1316 1317 static const 1318 struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 1319 { 1320 struct class_dir *dir = to_class_dir(kobj); 1321 return dir->class->ns_type; 1322 } 1323 1324 static struct kobj_type class_dir_ktype = { 1325 .release = class_dir_release, 1326 .sysfs_ops = &kobj_sysfs_ops, 1327 .child_ns_type = class_dir_child_ns_type 1328 }; 1329 1330 static struct kobject * 1331 class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 1332 { 1333 struct class_dir *dir; 1334 int retval; 1335 1336 dir = kzalloc(sizeof(*dir), GFP_KERNEL); 1337 if (!dir) 1338 return NULL; 1339 1340 dir->class = class; 1341 kobject_init(&dir->kobj, &class_dir_ktype); 1342 1343 dir->kobj.kset = &class->p->glue_dirs; 1344 1345 retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 1346 if (retval < 0) { 1347 kobject_put(&dir->kobj); 1348 return NULL; 1349 } 1350 return &dir->kobj; 1351 } 1352 1353 static DEFINE_MUTEX(gdp_mutex); 1354 1355 static struct kobject *get_device_parent(struct device *dev, 1356 struct device *parent) 1357 { 1358 if (dev->class) { 1359 struct kobject *kobj = NULL; 1360 struct kobject *parent_kobj; 1361 struct kobject *k; 1362 1363 #ifdef CONFIG_BLOCK 1364 /* block disks show up in /sys/block */ 1365 if (sysfs_deprecated && dev->class == &block_class) { 1366 if (parent && parent->class == &block_class) 1367 return &parent->kobj; 1368 return &block_class.p->subsys.kobj; 1369 } 1370 #endif 1371 1372 /* 1373 * If we have no parent, we live in "virtual". 1374 * Class-devices with a non class-device as parent, live 1375 * in a "glue" directory to prevent namespace collisions. 1376 */ 1377 if (parent == NULL) 1378 parent_kobj = virtual_device_parent(dev); 1379 else if (parent->class && !dev->class->ns_type) 1380 return &parent->kobj; 1381 else 1382 parent_kobj = &parent->kobj; 1383 1384 mutex_lock(&gdp_mutex); 1385 1386 /* find our class-directory at the parent and reference it */ 1387 spin_lock(&dev->class->p->glue_dirs.list_lock); 1388 list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 1389 if (k->parent == parent_kobj) { 1390 kobj = kobject_get(k); 1391 break; 1392 } 1393 spin_unlock(&dev->class->p->glue_dirs.list_lock); 1394 if (kobj) { 1395 mutex_unlock(&gdp_mutex); 1396 return kobj; 1397 } 1398 1399 /* or create a new class-directory at the parent device */ 1400 k = class_dir_create_and_add(dev->class, parent_kobj); 1401 /* do not emit an uevent for this simple "glue" directory */ 1402 mutex_unlock(&gdp_mutex); 1403 return k; 1404 } 1405 1406 /* subsystems can specify a default root directory for their devices */ 1407 if (!parent && dev->bus && dev->bus->dev_root) 1408 return &dev->bus->dev_root->kobj; 1409 1410 if (parent) 1411 return &parent->kobj; 1412 return NULL; 1413 } 1414 1415 static inline bool live_in_glue_dir(struct kobject *kobj, 1416 struct device *dev) 1417 { 1418 if (!kobj || !dev->class || 1419 kobj->kset != &dev->class->p->glue_dirs) 1420 return false; 1421 return true; 1422 } 1423 1424 static inline struct kobject *get_glue_dir(struct device *dev) 1425 { 1426 return dev->kobj.parent; 1427 } 1428 1429 /* 1430 * make sure cleaning up dir as the last step, we need to make 1431 * sure .release handler of kobject is run with holding the 1432 * global lock 1433 */ 1434 static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 1435 { 1436 /* see if we live in a "glue" directory */ 1437 if (!live_in_glue_dir(glue_dir, dev)) 1438 return; 1439 1440 mutex_lock(&gdp_mutex); 1441 kobject_put(glue_dir); 1442 mutex_unlock(&gdp_mutex); 1443 } 1444 1445 static int device_add_class_symlinks(struct device *dev) 1446 { 1447 struct device_node *of_node = dev_of_node(dev); 1448 int error; 1449 1450 if (of_node) { 1451 error = sysfs_create_link(&dev->kobj, &of_node->kobj,"of_node"); 1452 if (error) 1453 dev_warn(dev, "Error %d creating of_node link\n",error); 1454 /* An error here doesn't warrant bringing down the device */ 1455 } 1456 1457 if (!dev->class) 1458 return 0; 1459 1460 error = sysfs_create_link(&dev->kobj, 1461 &dev->class->p->subsys.kobj, 1462 "subsystem"); 1463 if (error) 1464 goto out_devnode; 1465 1466 if (dev->parent && device_is_not_partition(dev)) { 1467 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 1468 "device"); 1469 if (error) 1470 goto out_subsys; 1471 } 1472 1473 #ifdef CONFIG_BLOCK 1474 /* /sys/block has directories and does not need symlinks */ 1475 if (sysfs_deprecated && dev->class == &block_class) 1476 return 0; 1477 #endif 1478 1479 /* link in the class directory pointing to the device */ 1480 error = sysfs_create_link(&dev->class->p->subsys.kobj, 1481 &dev->kobj, dev_name(dev)); 1482 if (error) 1483 goto out_device; 1484 1485 return 0; 1486 1487 out_device: 1488 sysfs_remove_link(&dev->kobj, "device"); 1489 1490 out_subsys: 1491 sysfs_remove_link(&dev->kobj, "subsystem"); 1492 out_devnode: 1493 sysfs_remove_link(&dev->kobj, "of_node"); 1494 return error; 1495 } 1496 1497 static void device_remove_class_symlinks(struct device *dev) 1498 { 1499 if (dev_of_node(dev)) 1500 sysfs_remove_link(&dev->kobj, "of_node"); 1501 1502 if (!dev->class) 1503 return; 1504 1505 if (dev->parent && device_is_not_partition(dev)) 1506 sysfs_remove_link(&dev->kobj, "device"); 1507 sysfs_remove_link(&dev->kobj, "subsystem"); 1508 #ifdef CONFIG_BLOCK 1509 if (sysfs_deprecated && dev->class == &block_class) 1510 return; 1511 #endif 1512 sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 1513 } 1514 1515 /** 1516 * dev_set_name - set a device name 1517 * @dev: device 1518 * @fmt: format string for the device's name 1519 */ 1520 int dev_set_name(struct device *dev, const char *fmt, ...) 1521 { 1522 va_list vargs; 1523 int err; 1524 1525 va_start(vargs, fmt); 1526 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 1527 va_end(vargs); 1528 return err; 1529 } 1530 EXPORT_SYMBOL_GPL(dev_set_name); 1531 1532 /** 1533 * device_to_dev_kobj - select a /sys/dev/ directory for the device 1534 * @dev: device 1535 * 1536 * By default we select char/ for new entries. Setting class->dev_obj 1537 * to NULL prevents an entry from being created. class->dev_kobj must 1538 * be set (or cleared) before any devices are registered to the class 1539 * otherwise device_create_sys_dev_entry() and 1540 * device_remove_sys_dev_entry() will disagree about the presence of 1541 * the link. 1542 */ 1543 static struct kobject *device_to_dev_kobj(struct device *dev) 1544 { 1545 struct kobject *kobj; 1546 1547 if (dev->class) 1548 kobj = dev->class->dev_kobj; 1549 else 1550 kobj = sysfs_dev_char_kobj; 1551 1552 return kobj; 1553 } 1554 1555 static int device_create_sys_dev_entry(struct device *dev) 1556 { 1557 struct kobject *kobj = device_to_dev_kobj(dev); 1558 int error = 0; 1559 char devt_str[15]; 1560 1561 if (kobj) { 1562 format_dev_t(devt_str, dev->devt); 1563 error = sysfs_create_link(kobj, &dev->kobj, devt_str); 1564 } 1565 1566 return error; 1567 } 1568 1569 static void device_remove_sys_dev_entry(struct device *dev) 1570 { 1571 struct kobject *kobj = device_to_dev_kobj(dev); 1572 char devt_str[15]; 1573 1574 if (kobj) { 1575 format_dev_t(devt_str, dev->devt); 1576 sysfs_remove_link(kobj, devt_str); 1577 } 1578 } 1579 1580 int device_private_init(struct device *dev) 1581 { 1582 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 1583 if (!dev->p) 1584 return -ENOMEM; 1585 dev->p->device = dev; 1586 klist_init(&dev->p->klist_children, klist_children_get, 1587 klist_children_put); 1588 INIT_LIST_HEAD(&dev->p->deferred_probe); 1589 return 0; 1590 } 1591 1592 /** 1593 * device_add - add device to device hierarchy. 1594 * @dev: device. 1595 * 1596 * This is part 2 of device_register(), though may be called 1597 * separately _iff_ device_initialize() has been called separately. 1598 * 1599 * This adds @dev to the kobject hierarchy via kobject_add(), adds it 1600 * to the global and sibling lists for the device, then 1601 * adds it to the other relevant subsystems of the driver model. 1602 * 1603 * Do not call this routine or device_register() more than once for 1604 * any device structure. The driver model core is not designed to work 1605 * with devices that get unregistered and then spring back to life. 1606 * (Among other things, it's very hard to guarantee that all references 1607 * to the previous incarnation of @dev have been dropped.) Allocate 1608 * and register a fresh new struct device instead. 1609 * 1610 * NOTE: _Never_ directly free @dev after calling this function, even 1611 * if it returned an error! Always use put_device() to give up your 1612 * reference instead. 1613 */ 1614 int device_add(struct device *dev) 1615 { 1616 struct device *parent = NULL; 1617 struct kobject *kobj; 1618 struct class_interface *class_intf; 1619 int error = -EINVAL; 1620 struct kobject *glue_dir = NULL; 1621 1622 dev = get_device(dev); 1623 if (!dev) 1624 goto done; 1625 1626 if (!dev->p) { 1627 error = device_private_init(dev); 1628 if (error) 1629 goto done; 1630 } 1631 1632 /* 1633 * for statically allocated devices, which should all be converted 1634 * some day, we need to initialize the name. We prevent reading back 1635 * the name, and force the use of dev_name() 1636 */ 1637 if (dev->init_name) { 1638 dev_set_name(dev, "%s", dev->init_name); 1639 dev->init_name = NULL; 1640 } 1641 1642 /* subsystems can specify simple device enumeration */ 1643 if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 1644 dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 1645 1646 if (!dev_name(dev)) { 1647 error = -EINVAL; 1648 goto name_error; 1649 } 1650 1651 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1652 1653 parent = get_device(dev->parent); 1654 kobj = get_device_parent(dev, parent); 1655 if (kobj) 1656 dev->kobj.parent = kobj; 1657 1658 /* use parent numa_node */ 1659 if (parent && (dev_to_node(dev) == NUMA_NO_NODE)) 1660 set_dev_node(dev, dev_to_node(parent)); 1661 1662 /* first, register with generic layer. */ 1663 /* we require the name to be set before, and pass NULL */ 1664 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 1665 if (error) { 1666 glue_dir = get_glue_dir(dev); 1667 goto Error; 1668 } 1669 1670 /* notify platform of device entry */ 1671 if (platform_notify) 1672 platform_notify(dev); 1673 1674 error = device_create_file(dev, &dev_attr_uevent); 1675 if (error) 1676 goto attrError; 1677 1678 error = device_add_class_symlinks(dev); 1679 if (error) 1680 goto SymlinkError; 1681 error = device_add_attrs(dev); 1682 if (error) 1683 goto AttrsError; 1684 error = bus_add_device(dev); 1685 if (error) 1686 goto BusError; 1687 error = dpm_sysfs_add(dev); 1688 if (error) 1689 goto DPMError; 1690 device_pm_add(dev); 1691 1692 if (MAJOR(dev->devt)) { 1693 error = device_create_file(dev, &dev_attr_dev); 1694 if (error) 1695 goto DevAttrError; 1696 1697 error = device_create_sys_dev_entry(dev); 1698 if (error) 1699 goto SysEntryError; 1700 1701 devtmpfs_create_node(dev); 1702 } 1703 1704 /* Notify clients of device addition. This call must come 1705 * after dpm_sysfs_add() and before kobject_uevent(). 1706 */ 1707 if (dev->bus) 1708 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1709 BUS_NOTIFY_ADD_DEVICE, dev); 1710 1711 kobject_uevent(&dev->kobj, KOBJ_ADD); 1712 bus_probe_device(dev); 1713 if (parent) 1714 klist_add_tail(&dev->p->knode_parent, 1715 &parent->p->klist_children); 1716 1717 if (dev->class) { 1718 mutex_lock(&dev->class->p->mutex); 1719 /* tie the class to the device */ 1720 klist_add_tail(&dev->knode_class, 1721 &dev->class->p->klist_devices); 1722 1723 /* notify any interfaces that the device is here */ 1724 list_for_each_entry(class_intf, 1725 &dev->class->p->interfaces, node) 1726 if (class_intf->add_dev) 1727 class_intf->add_dev(dev, class_intf); 1728 mutex_unlock(&dev->class->p->mutex); 1729 } 1730 done: 1731 put_device(dev); 1732 return error; 1733 SysEntryError: 1734 if (MAJOR(dev->devt)) 1735 device_remove_file(dev, &dev_attr_dev); 1736 DevAttrError: 1737 device_pm_remove(dev); 1738 dpm_sysfs_remove(dev); 1739 DPMError: 1740 bus_remove_device(dev); 1741 BusError: 1742 device_remove_attrs(dev); 1743 AttrsError: 1744 device_remove_class_symlinks(dev); 1745 SymlinkError: 1746 device_remove_file(dev, &dev_attr_uevent); 1747 attrError: 1748 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 1749 glue_dir = get_glue_dir(dev); 1750 kobject_del(&dev->kobj); 1751 Error: 1752 cleanup_glue_dir(dev, glue_dir); 1753 put_device(parent); 1754 name_error: 1755 kfree(dev->p); 1756 dev->p = NULL; 1757 goto done; 1758 } 1759 EXPORT_SYMBOL_GPL(device_add); 1760 1761 /** 1762 * device_register - register a device with the system. 1763 * @dev: pointer to the device structure 1764 * 1765 * This happens in two clean steps - initialize the device 1766 * and add it to the system. The two steps can be called 1767 * separately, but this is the easiest and most common. 1768 * I.e. you should only call the two helpers separately if 1769 * have a clearly defined need to use and refcount the device 1770 * before it is added to the hierarchy. 1771 * 1772 * For more information, see the kerneldoc for device_initialize() 1773 * and device_add(). 1774 * 1775 * NOTE: _Never_ directly free @dev after calling this function, even 1776 * if it returned an error! Always use put_device() to give up the 1777 * reference initialized in this function instead. 1778 */ 1779 int device_register(struct device *dev) 1780 { 1781 device_initialize(dev); 1782 return device_add(dev); 1783 } 1784 EXPORT_SYMBOL_GPL(device_register); 1785 1786 /** 1787 * get_device - increment reference count for device. 1788 * @dev: device. 1789 * 1790 * This simply forwards the call to kobject_get(), though 1791 * we do take care to provide for the case that we get a NULL 1792 * pointer passed in. 1793 */ 1794 struct device *get_device(struct device *dev) 1795 { 1796 return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 1797 } 1798 EXPORT_SYMBOL_GPL(get_device); 1799 1800 /** 1801 * put_device - decrement reference count. 1802 * @dev: device in question. 1803 */ 1804 void put_device(struct device *dev) 1805 { 1806 /* might_sleep(); */ 1807 if (dev) 1808 kobject_put(&dev->kobj); 1809 } 1810 EXPORT_SYMBOL_GPL(put_device); 1811 1812 /** 1813 * device_del - delete device from system. 1814 * @dev: device. 1815 * 1816 * This is the first part of the device unregistration 1817 * sequence. This removes the device from the lists we control 1818 * from here, has it removed from the other driver model 1819 * subsystems it was added to in device_add(), and removes it 1820 * from the kobject hierarchy. 1821 * 1822 * NOTE: this should be called manually _iff_ device_add() was 1823 * also called manually. 1824 */ 1825 void device_del(struct device *dev) 1826 { 1827 struct device *parent = dev->parent; 1828 struct kobject *glue_dir = NULL; 1829 struct class_interface *class_intf; 1830 1831 /* Notify clients of device removal. This call must come 1832 * before dpm_sysfs_remove(). 1833 */ 1834 if (dev->bus) 1835 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1836 BUS_NOTIFY_DEL_DEVICE, dev); 1837 1838 device_links_purge(dev); 1839 dpm_sysfs_remove(dev); 1840 if (parent) 1841 klist_del(&dev->p->knode_parent); 1842 if (MAJOR(dev->devt)) { 1843 devtmpfs_delete_node(dev); 1844 device_remove_sys_dev_entry(dev); 1845 device_remove_file(dev, &dev_attr_dev); 1846 } 1847 if (dev->class) { 1848 device_remove_class_symlinks(dev); 1849 1850 mutex_lock(&dev->class->p->mutex); 1851 /* notify any interfaces that the device is now gone */ 1852 list_for_each_entry(class_intf, 1853 &dev->class->p->interfaces, node) 1854 if (class_intf->remove_dev) 1855 class_intf->remove_dev(dev, class_intf); 1856 /* remove the device from the class list */ 1857 klist_del(&dev->knode_class); 1858 mutex_unlock(&dev->class->p->mutex); 1859 } 1860 device_remove_file(dev, &dev_attr_uevent); 1861 device_remove_attrs(dev); 1862 bus_remove_device(dev); 1863 device_pm_remove(dev); 1864 driver_deferred_probe_del(dev); 1865 device_remove_properties(dev); 1866 1867 /* Notify the platform of the removal, in case they 1868 * need to do anything... 1869 */ 1870 if (platform_notify_remove) 1871 platform_notify_remove(dev); 1872 if (dev->bus) 1873 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1874 BUS_NOTIFY_REMOVED_DEVICE, dev); 1875 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 1876 glue_dir = get_glue_dir(dev); 1877 kobject_del(&dev->kobj); 1878 cleanup_glue_dir(dev, glue_dir); 1879 put_device(parent); 1880 } 1881 EXPORT_SYMBOL_GPL(device_del); 1882 1883 /** 1884 * device_unregister - unregister device from system. 1885 * @dev: device going away. 1886 * 1887 * We do this in two parts, like we do device_register(). First, 1888 * we remove it from all the subsystems with device_del(), then 1889 * we decrement the reference count via put_device(). If that 1890 * is the final reference count, the device will be cleaned up 1891 * via device_release() above. Otherwise, the structure will 1892 * stick around until the final reference to the device is dropped. 1893 */ 1894 void device_unregister(struct device *dev) 1895 { 1896 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1897 device_del(dev); 1898 put_device(dev); 1899 } 1900 EXPORT_SYMBOL_GPL(device_unregister); 1901 1902 static struct device *prev_device(struct klist_iter *i) 1903 { 1904 struct klist_node *n = klist_prev(i); 1905 struct device *dev = NULL; 1906 struct device_private *p; 1907 1908 if (n) { 1909 p = to_device_private_parent(n); 1910 dev = p->device; 1911 } 1912 return dev; 1913 } 1914 1915 static struct device *next_device(struct klist_iter *i) 1916 { 1917 struct klist_node *n = klist_next(i); 1918 struct device *dev = NULL; 1919 struct device_private *p; 1920 1921 if (n) { 1922 p = to_device_private_parent(n); 1923 dev = p->device; 1924 } 1925 return dev; 1926 } 1927 1928 /** 1929 * device_get_devnode - path of device node file 1930 * @dev: device 1931 * @mode: returned file access mode 1932 * @uid: returned file owner 1933 * @gid: returned file group 1934 * @tmp: possibly allocated string 1935 * 1936 * Return the relative path of a possible device node. 1937 * Non-default names may need to allocate a memory to compose 1938 * a name. This memory is returned in tmp and needs to be 1939 * freed by the caller. 1940 */ 1941 const char *device_get_devnode(struct device *dev, 1942 umode_t *mode, kuid_t *uid, kgid_t *gid, 1943 const char **tmp) 1944 { 1945 char *s; 1946 1947 *tmp = NULL; 1948 1949 /* the device type may provide a specific name */ 1950 if (dev->type && dev->type->devnode) 1951 *tmp = dev->type->devnode(dev, mode, uid, gid); 1952 if (*tmp) 1953 return *tmp; 1954 1955 /* the class may provide a specific name */ 1956 if (dev->class && dev->class->devnode) 1957 *tmp = dev->class->devnode(dev, mode); 1958 if (*tmp) 1959 return *tmp; 1960 1961 /* return name without allocation, tmp == NULL */ 1962 if (strchr(dev_name(dev), '!') == NULL) 1963 return dev_name(dev); 1964 1965 /* replace '!' in the name with '/' */ 1966 s = kstrdup(dev_name(dev), GFP_KERNEL); 1967 if (!s) 1968 return NULL; 1969 strreplace(s, '!', '/'); 1970 return *tmp = s; 1971 } 1972 1973 /** 1974 * device_for_each_child - device child iterator. 1975 * @parent: parent struct device. 1976 * @fn: function to be called for each device. 1977 * @data: data for the callback. 1978 * 1979 * Iterate over @parent's child devices, and call @fn for each, 1980 * passing it @data. 1981 * 1982 * We check the return of @fn each time. If it returns anything 1983 * other than 0, we break out and return that value. 1984 */ 1985 int device_for_each_child(struct device *parent, void *data, 1986 int (*fn)(struct device *dev, void *data)) 1987 { 1988 struct klist_iter i; 1989 struct device *child; 1990 int error = 0; 1991 1992 if (!parent->p) 1993 return 0; 1994 1995 klist_iter_init(&parent->p->klist_children, &i); 1996 while ((child = next_device(&i)) && !error) 1997 error = fn(child, data); 1998 klist_iter_exit(&i); 1999 return error; 2000 } 2001 EXPORT_SYMBOL_GPL(device_for_each_child); 2002 2003 /** 2004 * device_for_each_child_reverse - device child iterator in reversed order. 2005 * @parent: parent struct device. 2006 * @fn: function to be called for each device. 2007 * @data: data for the callback. 2008 * 2009 * Iterate over @parent's child devices, and call @fn for each, 2010 * passing it @data. 2011 * 2012 * We check the return of @fn each time. If it returns anything 2013 * other than 0, we break out and return that value. 2014 */ 2015 int device_for_each_child_reverse(struct device *parent, void *data, 2016 int (*fn)(struct device *dev, void *data)) 2017 { 2018 struct klist_iter i; 2019 struct device *child; 2020 int error = 0; 2021 2022 if (!parent->p) 2023 return 0; 2024 2025 klist_iter_init(&parent->p->klist_children, &i); 2026 while ((child = prev_device(&i)) && !error) 2027 error = fn(child, data); 2028 klist_iter_exit(&i); 2029 return error; 2030 } 2031 EXPORT_SYMBOL_GPL(device_for_each_child_reverse); 2032 2033 /** 2034 * device_find_child - device iterator for locating a particular device. 2035 * @parent: parent struct device 2036 * @match: Callback function to check device 2037 * @data: Data to pass to match function 2038 * 2039 * This is similar to the device_for_each_child() function above, but it 2040 * returns a reference to a device that is 'found' for later use, as 2041 * determined by the @match callback. 2042 * 2043 * The callback should return 0 if the device doesn't match and non-zero 2044 * if it does. If the callback returns non-zero and a reference to the 2045 * current device can be obtained, this function will return to the caller 2046 * and not iterate over any more devices. 2047 * 2048 * NOTE: you will need to drop the reference with put_device() after use. 2049 */ 2050 struct device *device_find_child(struct device *parent, void *data, 2051 int (*match)(struct device *dev, void *data)) 2052 { 2053 struct klist_iter i; 2054 struct device *child; 2055 2056 if (!parent) 2057 return NULL; 2058 2059 klist_iter_init(&parent->p->klist_children, &i); 2060 while ((child = next_device(&i))) 2061 if (match(child, data) && get_device(child)) 2062 break; 2063 klist_iter_exit(&i); 2064 return child; 2065 } 2066 EXPORT_SYMBOL_GPL(device_find_child); 2067 2068 int __init devices_init(void) 2069 { 2070 devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 2071 if (!devices_kset) 2072 return -ENOMEM; 2073 dev_kobj = kobject_create_and_add("dev", NULL); 2074 if (!dev_kobj) 2075 goto dev_kobj_err; 2076 sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 2077 if (!sysfs_dev_block_kobj) 2078 goto block_kobj_err; 2079 sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 2080 if (!sysfs_dev_char_kobj) 2081 goto char_kobj_err; 2082 2083 return 0; 2084 2085 char_kobj_err: 2086 kobject_put(sysfs_dev_block_kobj); 2087 block_kobj_err: 2088 kobject_put(dev_kobj); 2089 dev_kobj_err: 2090 kset_unregister(devices_kset); 2091 return -ENOMEM; 2092 } 2093 2094 static int device_check_offline(struct device *dev, void *not_used) 2095 { 2096 int ret; 2097 2098 ret = device_for_each_child(dev, NULL, device_check_offline); 2099 if (ret) 2100 return ret; 2101 2102 return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 2103 } 2104 2105 /** 2106 * device_offline - Prepare the device for hot-removal. 2107 * @dev: Device to be put offline. 2108 * 2109 * Execute the device bus type's .offline() callback, if present, to prepare 2110 * the device for a subsequent hot-removal. If that succeeds, the device must 2111 * not be used until either it is removed or its bus type's .online() callback 2112 * is executed. 2113 * 2114 * Call under device_hotplug_lock. 2115 */ 2116 int device_offline(struct device *dev) 2117 { 2118 int ret; 2119 2120 if (dev->offline_disabled) 2121 return -EPERM; 2122 2123 ret = device_for_each_child(dev, NULL, device_check_offline); 2124 if (ret) 2125 return ret; 2126 2127 device_lock(dev); 2128 if (device_supports_offline(dev)) { 2129 if (dev->offline) { 2130 ret = 1; 2131 } else { 2132 ret = dev->bus->offline(dev); 2133 if (!ret) { 2134 kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 2135 dev->offline = true; 2136 } 2137 } 2138 } 2139 device_unlock(dev); 2140 2141 return ret; 2142 } 2143 2144 /** 2145 * device_online - Put the device back online after successful device_offline(). 2146 * @dev: Device to be put back online. 2147 * 2148 * If device_offline() has been successfully executed for @dev, but the device 2149 * has not been removed subsequently, execute its bus type's .online() callback 2150 * to indicate that the device can be used again. 2151 * 2152 * Call under device_hotplug_lock. 2153 */ 2154 int device_online(struct device *dev) 2155 { 2156 int ret = 0; 2157 2158 device_lock(dev); 2159 if (device_supports_offline(dev)) { 2160 if (dev->offline) { 2161 ret = dev->bus->online(dev); 2162 if (!ret) { 2163 kobject_uevent(&dev->kobj, KOBJ_ONLINE); 2164 dev->offline = false; 2165 } 2166 } else { 2167 ret = 1; 2168 } 2169 } 2170 device_unlock(dev); 2171 2172 return ret; 2173 } 2174 2175 struct root_device { 2176 struct device dev; 2177 struct module *owner; 2178 }; 2179 2180 static inline struct root_device *to_root_device(struct device *d) 2181 { 2182 return container_of(d, struct root_device, dev); 2183 } 2184 2185 static void root_device_release(struct device *dev) 2186 { 2187 kfree(to_root_device(dev)); 2188 } 2189 2190 /** 2191 * __root_device_register - allocate and register a root device 2192 * @name: root device name 2193 * @owner: owner module of the root device, usually THIS_MODULE 2194 * 2195 * This function allocates a root device and registers it 2196 * using device_register(). In order to free the returned 2197 * device, use root_device_unregister(). 2198 * 2199 * Root devices are dummy devices which allow other devices 2200 * to be grouped under /sys/devices. Use this function to 2201 * allocate a root device and then use it as the parent of 2202 * any device which should appear under /sys/devices/{name} 2203 * 2204 * The /sys/devices/{name} directory will also contain a 2205 * 'module' symlink which points to the @owner directory 2206 * in sysfs. 2207 * 2208 * Returns &struct device pointer on success, or ERR_PTR() on error. 2209 * 2210 * Note: You probably want to use root_device_register(). 2211 */ 2212 struct device *__root_device_register(const char *name, struct module *owner) 2213 { 2214 struct root_device *root; 2215 int err = -ENOMEM; 2216 2217 root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 2218 if (!root) 2219 return ERR_PTR(err); 2220 2221 err = dev_set_name(&root->dev, "%s", name); 2222 if (err) { 2223 kfree(root); 2224 return ERR_PTR(err); 2225 } 2226 2227 root->dev.release = root_device_release; 2228 2229 err = device_register(&root->dev); 2230 if (err) { 2231 put_device(&root->dev); 2232 return ERR_PTR(err); 2233 } 2234 2235 #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 2236 if (owner) { 2237 struct module_kobject *mk = &owner->mkobj; 2238 2239 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 2240 if (err) { 2241 device_unregister(&root->dev); 2242 return ERR_PTR(err); 2243 } 2244 root->owner = owner; 2245 } 2246 #endif 2247 2248 return &root->dev; 2249 } 2250 EXPORT_SYMBOL_GPL(__root_device_register); 2251 2252 /** 2253 * root_device_unregister - unregister and free a root device 2254 * @dev: device going away 2255 * 2256 * This function unregisters and cleans up a device that was created by 2257 * root_device_register(). 2258 */ 2259 void root_device_unregister(struct device *dev) 2260 { 2261 struct root_device *root = to_root_device(dev); 2262 2263 if (root->owner) 2264 sysfs_remove_link(&root->dev.kobj, "module"); 2265 2266 device_unregister(dev); 2267 } 2268 EXPORT_SYMBOL_GPL(root_device_unregister); 2269 2270 2271 static void device_create_release(struct device *dev) 2272 { 2273 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 2274 kfree(dev); 2275 } 2276 2277 static struct device * 2278 device_create_groups_vargs(struct class *class, struct device *parent, 2279 dev_t devt, void *drvdata, 2280 const struct attribute_group **groups, 2281 const char *fmt, va_list args) 2282 { 2283 struct device *dev = NULL; 2284 int retval = -ENODEV; 2285 2286 if (class == NULL || IS_ERR(class)) 2287 goto error; 2288 2289 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 2290 if (!dev) { 2291 retval = -ENOMEM; 2292 goto error; 2293 } 2294 2295 device_initialize(dev); 2296 dev->devt = devt; 2297 dev->class = class; 2298 dev->parent = parent; 2299 dev->groups = groups; 2300 dev->release = device_create_release; 2301 dev_set_drvdata(dev, drvdata); 2302 2303 retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 2304 if (retval) 2305 goto error; 2306 2307 retval = device_add(dev); 2308 if (retval) 2309 goto error; 2310 2311 return dev; 2312 2313 error: 2314 put_device(dev); 2315 return ERR_PTR(retval); 2316 } 2317 2318 /** 2319 * device_create_vargs - creates a device and registers it with sysfs 2320 * @class: pointer to the struct class that this device should be registered to 2321 * @parent: pointer to the parent struct device of this new device, if any 2322 * @devt: the dev_t for the char device to be added 2323 * @drvdata: the data to be added to the device for callbacks 2324 * @fmt: string for the device's name 2325 * @args: va_list for the device's name 2326 * 2327 * This function can be used by char device classes. A struct device 2328 * will be created in sysfs, registered to the specified class. 2329 * 2330 * A "dev" file will be created, showing the dev_t for the device, if 2331 * the dev_t is not 0,0. 2332 * If a pointer to a parent struct device is passed in, the newly created 2333 * struct device will be a child of that device in sysfs. 2334 * The pointer to the struct device will be returned from the call. 2335 * Any further sysfs files that might be required can be created using this 2336 * pointer. 2337 * 2338 * Returns &struct device pointer on success, or ERR_PTR() on error. 2339 * 2340 * Note: the struct class passed to this function must have previously 2341 * been created with a call to class_create(). 2342 */ 2343 struct device *device_create_vargs(struct class *class, struct device *parent, 2344 dev_t devt, void *drvdata, const char *fmt, 2345 va_list args) 2346 { 2347 return device_create_groups_vargs(class, parent, devt, drvdata, NULL, 2348 fmt, args); 2349 } 2350 EXPORT_SYMBOL_GPL(device_create_vargs); 2351 2352 /** 2353 * device_create - creates a device and registers it with sysfs 2354 * @class: pointer to the struct class that this device should be registered to 2355 * @parent: pointer to the parent struct device of this new device, if any 2356 * @devt: the dev_t for the char device to be added 2357 * @drvdata: the data to be added to the device for callbacks 2358 * @fmt: string for the device's name 2359 * 2360 * This function can be used by char device classes. A struct device 2361 * will be created in sysfs, registered to the specified class. 2362 * 2363 * A "dev" file will be created, showing the dev_t for the device, if 2364 * the dev_t is not 0,0. 2365 * If a pointer to a parent struct device is passed in, the newly created 2366 * struct device will be a child of that device in sysfs. 2367 * The pointer to the struct device will be returned from the call. 2368 * Any further sysfs files that might be required can be created using this 2369 * pointer. 2370 * 2371 * Returns &struct device pointer on success, or ERR_PTR() on error. 2372 * 2373 * Note: the struct class passed to this function must have previously 2374 * been created with a call to class_create(). 2375 */ 2376 struct device *device_create(struct class *class, struct device *parent, 2377 dev_t devt, void *drvdata, const char *fmt, ...) 2378 { 2379 va_list vargs; 2380 struct device *dev; 2381 2382 va_start(vargs, fmt); 2383 dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs); 2384 va_end(vargs); 2385 return dev; 2386 } 2387 EXPORT_SYMBOL_GPL(device_create); 2388 2389 /** 2390 * device_create_with_groups - creates a device and registers it with sysfs 2391 * @class: pointer to the struct class that this device should be registered to 2392 * @parent: pointer to the parent struct device of this new device, if any 2393 * @devt: the dev_t for the char device to be added 2394 * @drvdata: the data to be added to the device for callbacks 2395 * @groups: NULL-terminated list of attribute groups to be created 2396 * @fmt: string for the device's name 2397 * 2398 * This function can be used by char device classes. A struct device 2399 * will be created in sysfs, registered to the specified class. 2400 * Additional attributes specified in the groups parameter will also 2401 * be created automatically. 2402 * 2403 * A "dev" file will be created, showing the dev_t for the device, if 2404 * the dev_t is not 0,0. 2405 * If a pointer to a parent struct device is passed in, the newly created 2406 * struct device will be a child of that device in sysfs. 2407 * The pointer to the struct device will be returned from the call. 2408 * Any further sysfs files that might be required can be created using this 2409 * pointer. 2410 * 2411 * Returns &struct device pointer on success, or ERR_PTR() on error. 2412 * 2413 * Note: the struct class passed to this function must have previously 2414 * been created with a call to class_create(). 2415 */ 2416 struct device *device_create_with_groups(struct class *class, 2417 struct device *parent, dev_t devt, 2418 void *drvdata, 2419 const struct attribute_group **groups, 2420 const char *fmt, ...) 2421 { 2422 va_list vargs; 2423 struct device *dev; 2424 2425 va_start(vargs, fmt); 2426 dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 2427 fmt, vargs); 2428 va_end(vargs); 2429 return dev; 2430 } 2431 EXPORT_SYMBOL_GPL(device_create_with_groups); 2432 2433 static int __match_devt(struct device *dev, const void *data) 2434 { 2435 const dev_t *devt = data; 2436 2437 return dev->devt == *devt; 2438 } 2439 2440 /** 2441 * device_destroy - removes a device that was created with device_create() 2442 * @class: pointer to the struct class that this device was registered with 2443 * @devt: the dev_t of the device that was previously registered 2444 * 2445 * This call unregisters and cleans up a device that was created with a 2446 * call to device_create(). 2447 */ 2448 void device_destroy(struct class *class, dev_t devt) 2449 { 2450 struct device *dev; 2451 2452 dev = class_find_device(class, NULL, &devt, __match_devt); 2453 if (dev) { 2454 put_device(dev); 2455 device_unregister(dev); 2456 } 2457 } 2458 EXPORT_SYMBOL_GPL(device_destroy); 2459 2460 /** 2461 * device_rename - renames a device 2462 * @dev: the pointer to the struct device to be renamed 2463 * @new_name: the new name of the device 2464 * 2465 * It is the responsibility of the caller to provide mutual 2466 * exclusion between two different calls of device_rename 2467 * on the same device to ensure that new_name is valid and 2468 * won't conflict with other devices. 2469 * 2470 * Note: Don't call this function. Currently, the networking layer calls this 2471 * function, but that will change. The following text from Kay Sievers offers 2472 * some insight: 2473 * 2474 * Renaming devices is racy at many levels, symlinks and other stuff are not 2475 * replaced atomically, and you get a "move" uevent, but it's not easy to 2476 * connect the event to the old and new device. Device nodes are not renamed at 2477 * all, there isn't even support for that in the kernel now. 2478 * 2479 * In the meantime, during renaming, your target name might be taken by another 2480 * driver, creating conflicts. Or the old name is taken directly after you 2481 * renamed it -- then you get events for the same DEVPATH, before you even see 2482 * the "move" event. It's just a mess, and nothing new should ever rely on 2483 * kernel device renaming. Besides that, it's not even implemented now for 2484 * other things than (driver-core wise very simple) network devices. 2485 * 2486 * We are currently about to change network renaming in udev to completely 2487 * disallow renaming of devices in the same namespace as the kernel uses, 2488 * because we can't solve the problems properly, that arise with swapping names 2489 * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 2490 * be allowed to some other name than eth[0-9]*, for the aforementioned 2491 * reasons. 2492 * 2493 * Make up a "real" name in the driver before you register anything, or add 2494 * some other attributes for userspace to find the device, or use udev to add 2495 * symlinks -- but never rename kernel devices later, it's a complete mess. We 2496 * don't even want to get into that and try to implement the missing pieces in 2497 * the core. We really have other pieces to fix in the driver core mess. :) 2498 */ 2499 int device_rename(struct device *dev, const char *new_name) 2500 { 2501 struct kobject *kobj = &dev->kobj; 2502 char *old_device_name = NULL; 2503 int error; 2504 2505 dev = get_device(dev); 2506 if (!dev) 2507 return -EINVAL; 2508 2509 dev_dbg(dev, "renaming to %s\n", new_name); 2510 2511 old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 2512 if (!old_device_name) { 2513 error = -ENOMEM; 2514 goto out; 2515 } 2516 2517 if (dev->class) { 2518 error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 2519 kobj, old_device_name, 2520 new_name, kobject_namespace(kobj)); 2521 if (error) 2522 goto out; 2523 } 2524 2525 error = kobject_rename(kobj, new_name); 2526 if (error) 2527 goto out; 2528 2529 out: 2530 put_device(dev); 2531 2532 kfree(old_device_name); 2533 2534 return error; 2535 } 2536 EXPORT_SYMBOL_GPL(device_rename); 2537 2538 static int device_move_class_links(struct device *dev, 2539 struct device *old_parent, 2540 struct device *new_parent) 2541 { 2542 int error = 0; 2543 2544 if (old_parent) 2545 sysfs_remove_link(&dev->kobj, "device"); 2546 if (new_parent) 2547 error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 2548 "device"); 2549 return error; 2550 } 2551 2552 /** 2553 * device_move - moves a device to a new parent 2554 * @dev: the pointer to the struct device to be moved 2555 * @new_parent: the new parent of the device (can by NULL) 2556 * @dpm_order: how to reorder the dpm_list 2557 */ 2558 int device_move(struct device *dev, struct device *new_parent, 2559 enum dpm_order dpm_order) 2560 { 2561 int error; 2562 struct device *old_parent; 2563 struct kobject *new_parent_kobj; 2564 2565 dev = get_device(dev); 2566 if (!dev) 2567 return -EINVAL; 2568 2569 device_pm_lock(); 2570 new_parent = get_device(new_parent); 2571 new_parent_kobj = get_device_parent(dev, new_parent); 2572 2573 pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 2574 __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 2575 error = kobject_move(&dev->kobj, new_parent_kobj); 2576 if (error) { 2577 cleanup_glue_dir(dev, new_parent_kobj); 2578 put_device(new_parent); 2579 goto out; 2580 } 2581 old_parent = dev->parent; 2582 dev->parent = new_parent; 2583 if (old_parent) 2584 klist_remove(&dev->p->knode_parent); 2585 if (new_parent) { 2586 klist_add_tail(&dev->p->knode_parent, 2587 &new_parent->p->klist_children); 2588 set_dev_node(dev, dev_to_node(new_parent)); 2589 } 2590 2591 if (dev->class) { 2592 error = device_move_class_links(dev, old_parent, new_parent); 2593 if (error) { 2594 /* We ignore errors on cleanup since we're hosed anyway... */ 2595 device_move_class_links(dev, new_parent, old_parent); 2596 if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 2597 if (new_parent) 2598 klist_remove(&dev->p->knode_parent); 2599 dev->parent = old_parent; 2600 if (old_parent) { 2601 klist_add_tail(&dev->p->knode_parent, 2602 &old_parent->p->klist_children); 2603 set_dev_node(dev, dev_to_node(old_parent)); 2604 } 2605 } 2606 cleanup_glue_dir(dev, new_parent_kobj); 2607 put_device(new_parent); 2608 goto out; 2609 } 2610 } 2611 switch (dpm_order) { 2612 case DPM_ORDER_NONE: 2613 break; 2614 case DPM_ORDER_DEV_AFTER_PARENT: 2615 device_pm_move_after(dev, new_parent); 2616 devices_kset_move_after(dev, new_parent); 2617 break; 2618 case DPM_ORDER_PARENT_BEFORE_DEV: 2619 device_pm_move_before(new_parent, dev); 2620 devices_kset_move_before(new_parent, dev); 2621 break; 2622 case DPM_ORDER_DEV_LAST: 2623 device_pm_move_last(dev); 2624 devices_kset_move_last(dev); 2625 break; 2626 } 2627 2628 put_device(old_parent); 2629 out: 2630 device_pm_unlock(); 2631 put_device(dev); 2632 return error; 2633 } 2634 EXPORT_SYMBOL_GPL(device_move); 2635 2636 /** 2637 * device_shutdown - call ->shutdown() on each device to shutdown. 2638 */ 2639 void device_shutdown(void) 2640 { 2641 struct device *dev, *parent; 2642 2643 spin_lock(&devices_kset->list_lock); 2644 /* 2645 * Walk the devices list backward, shutting down each in turn. 2646 * Beware that device unplug events may also start pulling 2647 * devices offline, even as the system is shutting down. 2648 */ 2649 while (!list_empty(&devices_kset->list)) { 2650 dev = list_entry(devices_kset->list.prev, struct device, 2651 kobj.entry); 2652 2653 /* 2654 * hold reference count of device's parent to 2655 * prevent it from being freed because parent's 2656 * lock is to be held 2657 */ 2658 parent = get_device(dev->parent); 2659 get_device(dev); 2660 /* 2661 * Make sure the device is off the kset list, in the 2662 * event that dev->*->shutdown() doesn't remove it. 2663 */ 2664 list_del_init(&dev->kobj.entry); 2665 spin_unlock(&devices_kset->list_lock); 2666 2667 /* hold lock to avoid race with probe/release */ 2668 if (parent) 2669 device_lock(parent); 2670 device_lock(dev); 2671 2672 /* Don't allow any more runtime suspends */ 2673 pm_runtime_get_noresume(dev); 2674 pm_runtime_barrier(dev); 2675 2676 if (dev->bus && dev->bus->shutdown) { 2677 if (initcall_debug) 2678 dev_info(dev, "shutdown\n"); 2679 dev->bus->shutdown(dev); 2680 } else if (dev->driver && dev->driver->shutdown) { 2681 if (initcall_debug) 2682 dev_info(dev, "shutdown\n"); 2683 dev->driver->shutdown(dev); 2684 } 2685 2686 device_unlock(dev); 2687 if (parent) 2688 device_unlock(parent); 2689 2690 put_device(dev); 2691 put_device(parent); 2692 2693 spin_lock(&devices_kset->list_lock); 2694 } 2695 spin_unlock(&devices_kset->list_lock); 2696 } 2697 2698 /* 2699 * Device logging functions 2700 */ 2701 2702 #ifdef CONFIG_PRINTK 2703 static int 2704 create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen) 2705 { 2706 const char *subsys; 2707 size_t pos = 0; 2708 2709 if (dev->class) 2710 subsys = dev->class->name; 2711 else if (dev->bus) 2712 subsys = dev->bus->name; 2713 else 2714 return 0; 2715 2716 pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys); 2717 if (pos >= hdrlen) 2718 goto overflow; 2719 2720 /* 2721 * Add device identifier DEVICE=: 2722 * b12:8 block dev_t 2723 * c127:3 char dev_t 2724 * n8 netdev ifindex 2725 * +sound:card0 subsystem:devname 2726 */ 2727 if (MAJOR(dev->devt)) { 2728 char c; 2729 2730 if (strcmp(subsys, "block") == 0) 2731 c = 'b'; 2732 else 2733 c = 'c'; 2734 pos++; 2735 pos += snprintf(hdr + pos, hdrlen - pos, 2736 "DEVICE=%c%u:%u", 2737 c, MAJOR(dev->devt), MINOR(dev->devt)); 2738 } else if (strcmp(subsys, "net") == 0) { 2739 struct net_device *net = to_net_dev(dev); 2740 2741 pos++; 2742 pos += snprintf(hdr + pos, hdrlen - pos, 2743 "DEVICE=n%u", net->ifindex); 2744 } else { 2745 pos++; 2746 pos += snprintf(hdr + pos, hdrlen - pos, 2747 "DEVICE=+%s:%s", subsys, dev_name(dev)); 2748 } 2749 2750 if (pos >= hdrlen) 2751 goto overflow; 2752 2753 return pos; 2754 2755 overflow: 2756 dev_WARN(dev, "device/subsystem name too long"); 2757 return 0; 2758 } 2759 2760 int dev_vprintk_emit(int level, const struct device *dev, 2761 const char *fmt, va_list args) 2762 { 2763 char hdr[128]; 2764 size_t hdrlen; 2765 2766 hdrlen = create_syslog_header(dev, hdr, sizeof(hdr)); 2767 2768 return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args); 2769 } 2770 EXPORT_SYMBOL(dev_vprintk_emit); 2771 2772 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 2773 { 2774 va_list args; 2775 int r; 2776 2777 va_start(args, fmt); 2778 2779 r = dev_vprintk_emit(level, dev, fmt, args); 2780 2781 va_end(args); 2782 2783 return r; 2784 } 2785 EXPORT_SYMBOL(dev_printk_emit); 2786 2787 static void __dev_printk(const char *level, const struct device *dev, 2788 struct va_format *vaf) 2789 { 2790 if (dev) 2791 dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 2792 dev_driver_string(dev), dev_name(dev), vaf); 2793 else 2794 printk("%s(NULL device *): %pV", level, vaf); 2795 } 2796 2797 void dev_printk(const char *level, const struct device *dev, 2798 const char *fmt, ...) 2799 { 2800 struct va_format vaf; 2801 va_list args; 2802 2803 va_start(args, fmt); 2804 2805 vaf.fmt = fmt; 2806 vaf.va = &args; 2807 2808 __dev_printk(level, dev, &vaf); 2809 2810 va_end(args); 2811 } 2812 EXPORT_SYMBOL(dev_printk); 2813 2814 #define define_dev_printk_level(func, kern_level) \ 2815 void func(const struct device *dev, const char *fmt, ...) \ 2816 { \ 2817 struct va_format vaf; \ 2818 va_list args; \ 2819 \ 2820 va_start(args, fmt); \ 2821 \ 2822 vaf.fmt = fmt; \ 2823 vaf.va = &args; \ 2824 \ 2825 __dev_printk(kern_level, dev, &vaf); \ 2826 \ 2827 va_end(args); \ 2828 } \ 2829 EXPORT_SYMBOL(func); 2830 2831 define_dev_printk_level(dev_emerg, KERN_EMERG); 2832 define_dev_printk_level(dev_alert, KERN_ALERT); 2833 define_dev_printk_level(dev_crit, KERN_CRIT); 2834 define_dev_printk_level(dev_err, KERN_ERR); 2835 define_dev_printk_level(dev_warn, KERN_WARNING); 2836 define_dev_printk_level(dev_notice, KERN_NOTICE); 2837 define_dev_printk_level(_dev_info, KERN_INFO); 2838 2839 #endif 2840 2841 static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 2842 { 2843 return fwnode && !IS_ERR(fwnode->secondary); 2844 } 2845 2846 /** 2847 * set_primary_fwnode - Change the primary firmware node of a given device. 2848 * @dev: Device to handle. 2849 * @fwnode: New primary firmware node of the device. 2850 * 2851 * Set the device's firmware node pointer to @fwnode, but if a secondary 2852 * firmware node of the device is present, preserve it. 2853 */ 2854 void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 2855 { 2856 if (fwnode) { 2857 struct fwnode_handle *fn = dev->fwnode; 2858 2859 if (fwnode_is_primary(fn)) 2860 fn = fn->secondary; 2861 2862 if (fn) { 2863 WARN_ON(fwnode->secondary); 2864 fwnode->secondary = fn; 2865 } 2866 dev->fwnode = fwnode; 2867 } else { 2868 dev->fwnode = fwnode_is_primary(dev->fwnode) ? 2869 dev->fwnode->secondary : NULL; 2870 } 2871 } 2872 EXPORT_SYMBOL_GPL(set_primary_fwnode); 2873 2874 /** 2875 * set_secondary_fwnode - Change the secondary firmware node of a given device. 2876 * @dev: Device to handle. 2877 * @fwnode: New secondary firmware node of the device. 2878 * 2879 * If a primary firmware node of the device is present, set its secondary 2880 * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 2881 * @fwnode. 2882 */ 2883 void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 2884 { 2885 if (fwnode) 2886 fwnode->secondary = ERR_PTR(-ENODEV); 2887 2888 if (fwnode_is_primary(dev->fwnode)) 2889 dev->fwnode->secondary = fwnode; 2890 else 2891 dev->fwnode = fwnode; 2892 } 2893