core.c revision 268863f43629ef88763400d0cae4a66c754a0d23
11da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 21da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * drivers/base/core.c - core driver model code (device registration, etc) 31da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 41da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Copyright (c) 2002-3 Patrick Mochel 51da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Copyright (c) 2002-3 Open Source Development Labs 664bb5d2c116478dba7501d2acf078ed74ba30c1fGreg Kroah-Hartman * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de> 764bb5d2c116478dba7501d2acf078ed74ba30c1fGreg Kroah-Hartman * Copyright (c) 2006 Novell, Inc. 81da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 91da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This file is released under the GPLv2 101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/device.h> 141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/err.h> 151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/init.h> 161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/module.h> 171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/slab.h> 181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/string.h> 1923681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman#include <linux/kdev_t.h> 20116af378201ef793424cd10508ccf18b06d8a021Benjamin Herrenschmidt#include <linux/notifier.h> 211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/genhd.h> 221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/kallsyms.h> 231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/mutex.h> 241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/async.h> 251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/pm_runtime.h> 261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include "base.h" 281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include "power/power.h" 291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef CONFIG_SYSFS_DEPRECATED 311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef CONFIG_SYSFS_DEPRECATED_V2 321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldslong sysfs_deprecated = 1; 331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 343e95637a48820ff8bedb33e6439def96ccff1de5Alan Sternlong sysfs_deprecated = 0; 353e95637a48820ff8bedb33e6439def96ccff1de5Alan Stern#endif 363e95637a48820ff8bedb33e6439def96ccff1de5Alan Sternstatic __init int sysfs_deprecated_setup(char *arg) 373e95637a48820ff8bedb33e6439def96ccff1de5Alan Stern{ 383e95637a48820ff8bedb33e6439def96ccff1de5Alan Stern return strict_strtol(arg, 10, &sysfs_deprecated); 393e95637a48820ff8bedb33e6439def96ccff1de5Alan Stern} 403e95637a48820ff8bedb33e6439def96ccff1de5Alan Sternearly_param("sysfs.deprecated", sysfs_deprecated_setup); 413e95637a48820ff8bedb33e6439def96ccff1de5Alan Stern#endif 423e95637a48820ff8bedb33e6439def96ccff1de5Alan Stern 433e95637a48820ff8bedb33e6439def96ccff1de5Alan Sternint (*platform_notify)(struct device *dev) = NULL; 443e95637a48820ff8bedb33e6439def96ccff1de5Alan Sternint (*platform_notify_remove)(struct device *dev) = NULL; 453e95637a48820ff8bedb33e6439def96ccff1de5Alan Sternstatic struct kobject *dev_kobj; 463e95637a48820ff8bedb33e6439def96ccff1de5Alan Sternstruct kobject *sysfs_dev_char_kobj; 473e95637a48820ff8bedb33e6439def96ccff1de5Alan Sternstruct kobject *sysfs_dev_block_kobj; 48310a922d4307ed38b37982a6f93b11fdf3b8dcb1Matthew Wilcox 493e95637a48820ff8bedb33e6439def96ccff1de5Alan Stern#ifdef CONFIG_BLOCK 501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline int device_is_not_partition(struct device *dev) 511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return !(dev->type == &part_type); 531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else 551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline int device_is_not_partition(struct device *dev) 561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 584a0c20bf8c0fe2116f8fd7d3da6122bf8a01f026Dmitry Torokhov} 591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6154b6f35c99974e99e64c05c2895718355123c55fYani Ioannou/** 621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * dev_driver_string - Return a device's driver name, if at all possible 631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @dev: struct device to get the name of 641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Will return the device's driver's name if it is bound to a device. If 661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the device is not bound to a device, it will return the name of the bus 671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * it is attached to. If it is not attached to a bus either, an empty 681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * string will be returned. 691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsconst char *dev_driver_string(const struct device *dev) 714a0c20bf8c0fe2116f8fd7d3da6122bf8a01f026Dmitry Torokhov{ 721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct device_driver *drv; 731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7454b6f35c99974e99e64c05c2895718355123c55fYani Ioannou /* dev->driver can change to NULL underneath us because of unbinding, 751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * so be careful about accessing it. dev->bus and dev->class should 761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * never change once they are set, so they don't need special care. 771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds drv = ACCESS_ONCE(dev->driver); 791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return drv ? drv->name : 801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (dev->bus ? dev->bus->name : 811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (dev->class ? dev->class->name : "")); 821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(dev_driver_string); 841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define to_dev(obj) container_of(obj, struct device, kobj) 861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char *buf) 901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct device *dev = to_dev(kobj); 931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ssize_t ret = -EIO; 941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (dev_attr->show) 961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ret = dev_attr->show(dev, dev_attr, buf); 971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ret >= (ssize_t)PAGE_SIZE) { 982620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman print_symbol("dev_attr_show: %s returned bad count\n", 992620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman (unsigned long)dev_attr->show); 1001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return ret; 1021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 1031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 1051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds const char *buf, size_t count) 1061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 1081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct device *dev = to_dev(kobj); 1091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ssize_t ret = -EIO; 1101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (dev_attr->store) 1121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ret = dev_attr->store(dev, dev_attr, buf, count); 1131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return ret; 114312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers} 1151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic const struct sysfs_ops dev_sysfs_ops = { 1171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .show = dev_attr_show, 1181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .store = dev_attr_store, 1191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 1201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 12223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 12323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartmanssize_t device_store_ulong(struct device *dev, 1241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct device_attribute *attr, 1251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds const char *buf, size_t size) 1261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct dev_ext_attribute *ea = to_ext_attr(attr); 128312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers char *end; 1291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long new = simple_strtoul(buf, &end, 0); 1301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (end == buf) 1311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -EINVAL; 13223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman *(unsigned long *)(ea->var) = new; 13323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman /* Always return full write size even if we didn't consume all */ 13423681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman return size; 13523681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman} 13623681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-HartmanEXPORT_SYMBOL_GPL(device_store_ulong); 1371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsssize_t device_show_ulong(struct device *dev, 139312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers struct device_attribute *attr, 1401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char *buf) 1411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct dev_ext_attribute *ea = to_ext_attr(attr); 1431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var)); 1441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 1451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL_GPL(device_show_ulong); 1461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14723681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartmanssize_t device_store_int(struct device *dev, 14823681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman struct device_attribute *attr, 14923681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman const char *buf, size_t size) 15023681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman{ 15123681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman struct dev_ext_attribute *ea = to_ext_attr(attr); 15223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman char *end; 15323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman long new = simple_strtol(buf, &end, 0); 15423681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman if (end == buf || new > INT_MAX || new < INT_MIN) 15523681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman return -EINVAL; 15623681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman *(int *)(ea->var) = new; 157a87cb2ac4a78c590583b52a3ed196adc6c25b6c9Kay Sievers /* Always return full write size even if we didn't consume all */ 158d81d9d6b9f7d0af7d4341951d48d296681878f7aKay Sievers return size; 1591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 160312c004d36ce6c739512bac83b452f4c20ab1f62Kay SieversEXPORT_SYMBOL_GPL(device_store_int); 161312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers 162312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sieversssize_t device_show_int(struct device *dev, 163a87cb2ac4a78c590583b52a3ed196adc6c25b6c9Kay Sievers struct device_attribute *attr, 1641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char *buf) 165d81d9d6b9f7d0af7d4341951d48d296681878f7aKay Sievers{ 166d81d9d6b9f7d0af7d4341951d48d296681878f7aKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 167d81d9d6b9f7d0af7d4341951d48d296681878f7aKay Sievers 168d81d9d6b9f7d0af7d4341951d48d296681878f7aKay Sievers return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var)); 169d81d9d6b9f7d0af7d4341951d48d296681878f7aKay Sievers} 170a87cb2ac4a78c590583b52a3ed196adc6c25b6c9Kay SieversEXPORT_SYMBOL_GPL(device_show_int); 171312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers 172312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers/** 173312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers * device_release - free device structure. 174a87cb2ac4a78c590583b52a3ed196adc6c25b6c9Kay Sievers * @kobj: device's kobject. 175d81d9d6b9f7d0af7d4341951d48d296681878f7aKay Sievers * 1761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This is called once the reference count for the object 1771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * reaches 0. We forward the call to the device's release 1781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * method, which should handle actually freeing the structure. 1791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 1801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void device_release(struct kobject *kobj) 1811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct device *dev = to_dev(kobj); 1831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct device_private *p = dev->p; 184312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers 1851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (dev->release) 186312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers dev->release(dev); 1871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (dev->type && dev->type->release) 188312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers dev->type->release(dev); 1891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else if (dev->class && dev->class->dev_release) 1901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev->class->dev_release(dev); 1911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 1921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds WARN(1, KERN_ERR "Device '%s' does not have a release() " 1932620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman "function, it is broken and must be fixed.\n", 1942620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman dev_name(dev)); 1952620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman kfree(p); 1962620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman} 1972620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman 1982620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartmanstatic const void *device_namespace(struct kobject *kobj) 1992620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman{ 2002620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman struct device *dev = to_dev(kobj); 2012620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman const void *ns = NULL; 2021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (dev->class && dev->class->ns_type) 2041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ns = dev->class->namespace(dev); 205312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers 206312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers return ns; 207312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers} 208312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers 2091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct kobj_type device_ktype = { 2101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .release = device_release, 211a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sievers .sysfs_ops = &dev_sysfs_ops, 212a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sievers .namespace = device_namespace, 213a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sievers}; 214312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers 215a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sievers 216a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sieversstatic int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 217a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sievers{ 218de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman struct kobj_type *ktype = get_ktype(kobj); 219de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman 220de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman if (ktype == &device_ktype) { 221de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman struct device *dev = to_dev(kobj); 222de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman if (dev->bus) 223de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman return 1; 224de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman if (dev->class) 225de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman return 1; 226de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman } 227de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman return 0; 228de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman} 229de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman 230de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartmanstatic const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 231de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman{ 232de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman struct device *dev = to_dev(kobj); 233de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman 234de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman if (dev->bus) 235de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman return dev->bus->name; 236de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman if (dev->class) 237de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman return dev->class->name; 238de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman return NULL; 239de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman} 240de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman 241de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartmanstatic int dev_uevent(struct kset *kset, struct kobject *kobj, 242de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman struct kobj_uevent_env *env) 243de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman{ 244de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman struct device *dev = to_dev(kobj); 245de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman int retval = 0; 246de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman 2472620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman /* add device node properties if present */ 2482620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman if (MAJOR(dev->devt)) { 2492620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman const char *tmp; 2502620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman const char *name; 2512620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman umode_t mode = 0; 2522620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman 2532620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 2542620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 2552620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman name = device_get_devnode(dev, &mode, &tmp); 2562620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman if (name) { 2572620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman add_uevent_var(env, "DEVNAME=%s", name); 2582620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman kfree(tmp); 2592620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman if (mode) 2602620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 2612620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman } 2622620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman } 2632620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman 2642620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman if (dev->type && dev->type->name) 2652620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 2662620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman 2672620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman if (dev->driver) 2682620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman add_uevent_var(env, "DRIVER=%s", dev->driver->name); 2692620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman 2702620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman /* have the bus specific function add its stuff */ 2712620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman if (dev->bus && dev->bus->uevent) { 2722620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman retval = dev->bus->uevent(dev, env); 2732620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman if (retval) 2742620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n", 2752620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman dev_name(dev), __func__, retval); 2762620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman } 2772620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman 2782620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman /* have the class specific function add its stuff */ 2792620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman if (dev->class && dev->class->dev_uevent) { 2802620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman retval = dev->class->dev_uevent(dev, env); 2812620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman if (retval) 2822620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() " 2832620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman "returned %d\n", dev_name(dev), 28423681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman __func__, retval); 28523681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman } 28623681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 28723681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman /* have the device type specific function add its stuff */ 28823681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman if (dev->type && dev->type->uevent) { 28923681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman retval = dev->type->uevent(dev, env); 2900863afb32b77fc89c7110b3d10fb048cb56bb1b5Martin Waitz if (retval) 2910863afb32b77fc89c7110b3d10fb048cb56bb1b5Martin Waitz pr_debug("device: '%s': %s: dev_type uevent() " 2921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "returned %d\n", dev_name(dev), 2931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __func__, retval); 294312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers } 2951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return retval; 2971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic const struct kset_uevent_ops device_uevent_ops = { 3001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .filter = dev_uevent_filter, 3011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .name = dev_uevent_name, 3021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .uevent = dev_uevent, 3031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 3041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic ssize_t show_uevent(struct device *dev, struct device_attribute *attr, 3061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds char *buf) 3071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 3081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct kobject *top_kobj; 3091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct kset *kset; 3101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct kobj_uevent_env *env = NULL; 3111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i; 3121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds size_t count = 0; 3131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int retval; 3141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* search the kset, the device belongs to */ 3161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds top_kobj = &dev->kobj; 3171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (!top_kobj->kset && top_kobj->parent) 3181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds top_kobj = top_kobj->parent; 3191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!top_kobj->kset) 3201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto out; 3211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kset = top_kobj->kset; 3231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!kset->uevent_ops || !kset->uevent_ops->uevent) 3241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto out; 3251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* respect filter */ 3272589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman if (kset->uevent_ops && kset->uevent_ops->filter) 3282589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman if (!kset->uevent_ops->filter(kset, &dev->kobj)) 3292589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman goto out; 3302589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman 3312589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 3322589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman if (!env) 3332589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman return -ENOMEM; 3342589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman 3352589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman /* let the kset specific function add its keys */ 3362589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 3372589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman if (retval) 3382589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman goto out; 3392589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman 3402589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman /* copy keys to file */ 3412589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman for (i = 0; i < env->envp_idx; i++) 3422589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman count += sprintf(&buf[count], "%s\n", env->envp[i]); 3432589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartmanout: 3442589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman kfree(env); 3452589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman return count; 3462589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman} 3472589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman 3482589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartmanstatic ssize_t store_uevent(struct device *dev, struct device_attribute *attr, 3492589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman const char *buf, size_t count) 3502589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman{ 3512589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman enum kobject_action action; 3522589f1887b0bf9f08ec3d7f3c5705ccb7c628076Greg Kroah-Hartman 35334bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley if (kobject_action_type(buf, count, &action) == 0) 35434bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley kobject_uevent(&dev->kobj, action); 35534bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley else 35634bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley dev_err(dev, "uevent: unknown action-string\n"); 35734bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley return count; 35834bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley} 35934bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley 36034bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomleystatic struct device_attribute uevent_attr = 36134bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley __ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent); 36234bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley 36334bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomleystatic int device_add_attributes(struct device *dev, 36434bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley struct device_attribute *attrs) 36534bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley{ 36634bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley int error = 0; 3671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i; 3681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (attrs) { 3701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; attr_name(attrs[i]); i++) { 3711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds error = device_create_file(dev, &attrs[i]); 3721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (error) 3731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 3741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (error) 3761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (--i >= 0) 3771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds device_remove_file(dev, &attrs[i]); 3781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return error; 3801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void device_remove_attributes(struct device *dev, 38334bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley struct device_attribute *attrs) 38434bb61f9ddabd7a7f909cbfb05592eb775f6662aJames Bottomley{ 3851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i; 38623681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 387af70316af182f4716cc5eec7e0d27fc731d164bdPatrick Mochel if (attrs) 3880ac85241ebc7bf6b86ab498960cc121d53ef69aeDavid Brownell for (i = 0; attr_name(attrs[i]); i++) 3891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds device_remove_file(dev, &attrs[i]); 3901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 39140fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman 392af9e0765362151b27372c14d9d6dc417184182d3Adrian Bunkstatic int device_add_bin_attributes(struct device *dev, 39340fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman struct bin_attribute *attrs) 39440fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman{ 39540fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman int error = 0; 39640fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman int i; 39740fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman 39840fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman if (attrs) { 39940fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman for (i = 0; attr_name(attrs[i]); i++) { 40040fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman error = device_create_bin_file(dev, &attrs[i]); 40140fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman if (error) 40240fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman break; 40340fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman } 404f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman if (error) 405f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman while (--i >= 0) 406f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman device_remove_bin_file(dev, &attrs[i]); 407f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman } 408f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman return error; 409f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman} 410f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman 411f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartmanstatic void device_remove_bin_attributes(struct device *dev, 412f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman struct bin_attribute *attrs) 413f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman{ 414f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman int i; 415f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman 416f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman if (attrs) 417f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman for (i = 0; attr_name(attrs[i]); i++) 418f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman device_remove_bin_file(dev, &attrs[i]); 419f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman} 420f0ee61a6cecd100301a60d99feb187776533b2a2Greg Kroah-Hartman 421af9e0765362151b27372c14d9d6dc417184182d3Adrian Bunkstatic int device_add_groups(struct device *dev, 42240fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman const struct attribute_group **groups) 42340fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman{ 42440fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman int error = 0; 42540fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman int i; 42640fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman 42740fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman if (groups) { 42840fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman for (i = 0; groups[i]; i++) { 42940fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman error = sysfs_create_group(&dev->kobj, groups[i]); 43040fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman if (error) { 43140fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman while (--i >= 0) 43240fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman sysfs_remove_group(&dev->kobj, 43340fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman groups[i]); 43440fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman break; 43540fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman } 43640fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman } 4371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 4381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return error; 4391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void device_remove_groups(struct device *dev, 4421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds const struct attribute_group **groups) 4431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i; 4451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (groups) 4471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for (i = 0; groups[i]; i++) 4481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sysfs_remove_group(&dev->kobj, groups[i]); 4491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 451e9a7d305faec364ba973d6c22c9b1e802ef79204Greg Kroah-Hartmanstatic int device_add_attrs(struct device *dev) 452c47ed219ba81632595e9f02e27318151fec16c9eGreg Kroah-Hartman{ 4531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct class *class = dev->class; 4541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds const struct device_type *type = dev->type; 4551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int error; 4561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (class) { 4581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds error = device_add_attributes(dev, class->dev_attrs); 45940fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman if (error) 460c205ef4880273d2de4ee5388d4e52227ff688cc4Greg Kroah-Hartman return error; 4611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds error = device_add_bin_attributes(dev, class->dev_bin_attrs); 4621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (error) 46340fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman goto err_remove_class_attrs; 46440fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman } 46540fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman 4661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (type) { 4671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds error = device_add_groups(dev, type->groups); 4681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (error) 46940fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman goto err_remove_class_bin_attrs; 47040fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman } 4711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 472a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sievers error = device_add_groups(dev, dev->groups); 473370226449ced358e52d198081120826ef52c166bBrian Walsh if (error) 474370226449ced358e52d198081120826ef52c166bBrian Walsh goto err_remove_type_groups; 475370226449ced358e52d198081120826ef52c166bBrian Walsh 476370226449ced358e52d198081120826ef52c166bBrian Walsh return 0; 477116af378201ef793424cd10508ccf18b06d8a021Benjamin Herrenschmidt 478116af378201ef793424cd10508ccf18b06d8a021Benjamin Herrenschmidt err_remove_type_groups: 479116af378201ef793424cd10508ccf18b06d8a021Benjamin Herrenschmidt if (type) 480116af378201ef793424cd10508ccf18b06d8a021Benjamin Herrenschmidt device_remove_groups(dev, type->groups); 481116af378201ef793424cd10508ccf18b06d8a021Benjamin Herrenschmidt err_remove_class_bin_attrs: 482a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sievers if (class) 483a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sievers device_remove_bin_attributes(dev, class->dev_bin_attrs); 484a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sievers err_remove_class_attrs: 485a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sievers if (class) 486a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sievers device_remove_attributes(dev, class->dev_attrs); 487a306eea40952e6365301e8a2f7d5ffa9c6a1921bCornelia Huck 488a306eea40952e6365301e8a2f7d5ffa9c6a1921bCornelia Huck return error; 489a306eea40952e6365301e8a2f7d5ffa9c6a1921bCornelia Huck} 490a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sievers 49123681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartmanstatic void device_remove_attrs(struct device *dev) 49223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman{ 49323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman struct class *class = dev->class; 49423681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman const struct device_type *type = dev->type; 49523681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 496a306eea40952e6365301e8a2f7d5ffa9c6a1921bCornelia Huck device_remove_groups(dev, dev->groups); 49723681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 49823681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman if (type) 49923681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman device_remove_groups(dev, type->groups); 50023681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 50123681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman if (class) { 50223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman device_remove_attributes(dev, class->dev_attrs); 50323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman device_remove_bin_attributes(dev, class->dev_bin_attrs); 50423681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman } 50523681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman} 506a306eea40952e6365301e8a2f7d5ffa9c6a1921bCornelia Huck 50723681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 50823681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartmanstatic ssize_t show_dev(struct device *dev, struct device_attribute *attr, 50923681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman char *buf) 51023681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman{ 51123681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman return print_dev_t(buf, dev->devt); 512b9d9c82b4d081feb464f62dfc786c8621d09ecd2Kay Sievers} 513b9d9c82b4d081feb464f62dfc786c8621d09ecd2Kay Sievers 514b9d9c82b4d081feb464f62dfc786c8621d09ecd2Kay Sieversstatic struct device_attribute devt_attr = 51540fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman __ATTR(dev, S_IRUGO, show_dev, NULL); 51640fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman 51740fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman/* /sys/devices/ */ 51840fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartmanstruct kset *devices_kset; 51940fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman 52099ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers/** 52164bb5d2c116478dba7501d2acf078ed74ba30c1fGreg Kroah-Hartman * device_create_file - create sysfs attribute file for device. 52264bb5d2c116478dba7501d2acf078ed74ba30c1fGreg Kroah-Hartman * @dev: device. 52364bb5d2c116478dba7501d2acf078ed74ba30c1fGreg Kroah-Hartman * @attr: device attribute descriptor. 52464bb5d2c116478dba7501d2acf078ed74ba30c1fGreg Kroah-Hartman */ 52564bb5d2c116478dba7501d2acf078ed74ba30c1fGreg Kroah-Hartmanint device_create_file(struct device *dev, 52699ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers const struct device_attribute *attr) 527b9d9c82b4d081feb464f62dfc786c8621d09ecd2Kay Sievers{ 52823681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman int error = 0; 5292620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman if (dev) 5302620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman error = sysfs_create_file(&dev->kobj, &attr->attr); 531de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman return error; 532de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman} 5331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 5351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * device_remove_file - remove sysfs attribute file. 5361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @dev: device. 53753877d06d53a412d901bb323f080296c363d8b51Kay Sievers * @attr: device attribute descriptor. 538f70fa6296c2ec8f541f0a9b406ccc2d9d127d639Alan Stern */ 539f70fa6296c2ec8f541f0a9b406ccc2d9d127d639Alan Sternvoid device_remove_file(struct device *dev, 5401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds const struct device_attribute *attr) 541d856f1e337782326c638c70c0b4df2b909350decJames Bottomley{ 5421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (dev) 5435d9fd169c9fbdaecdc430431e59bf94ff40b93d3Greg Kroah-Hartman sysfs_remove_file(&dev->kobj, &attr->attr); 5445d9fd169c9fbdaecdc430431e59bf94ff40b93d3Greg Kroah-Hartman} 545c47ed219ba81632595e9f02e27318151fec16c9eGreg Kroah-Hartman 5465d9fd169c9fbdaecdc430431e59bf94ff40b93d3Greg Kroah-Hartman/** 547c47ed219ba81632595e9f02e27318151fec16c9eGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device. 548c47ed219ba81632595e9f02e27318151fec16c9eGreg Kroah-Hartman * @dev: device. 549c47ed219ba81632595e9f02e27318151fec16c9eGreg Kroah-Hartman * @attr: device binary attribute descriptor. 550c47ed219ba81632595e9f02e27318151fec16c9eGreg Kroah-Hartman */ 551c47ed219ba81632595e9f02e27318151fec16c9eGreg Kroah-Hartmanint device_create_bin_file(struct device *dev, 5525d9fd169c9fbdaecdc430431e59bf94ff40b93d3Greg Kroah-Hartman const struct bin_attribute *attr) 5535d9fd169c9fbdaecdc430431e59bf94ff40b93d3Greg Kroah-Hartman{ 5541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int error = -EINVAL; 555e9a7d305faec364ba973d6c22c9b1e802ef79204Greg Kroah-Hartman if (dev) 5561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds error = sysfs_create_bin_file(&dev->kobj, attr); 5571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return error; 558f70fa6296c2ec8f541f0a9b406ccc2d9d127d639Alan Stern} 559f70fa6296c2ec8f541f0a9b406ccc2d9d127d639Alan SternEXPORT_SYMBOL_GPL(device_create_bin_file); 5601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 5621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * device_remove_bin_file - remove sysfs binary attribute file 563116af378201ef793424cd10508ccf18b06d8a021Benjamin Herrenschmidt * @dev: device. 564116af378201ef793424cd10508ccf18b06d8a021Benjamin Herrenschmidt * @attr: device binary attribute descriptor. 565116af378201ef793424cd10508ccf18b06d8a021Benjamin Herrenschmidt */ 566de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartmanvoid device_remove_bin_file(struct device *dev, 567de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman const struct bin_attribute *attr) 5682620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman{ 5692620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman if (dev) 57023681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr); 57123681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman} 57223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-HartmanEXPORT_SYMBOL_GPL(device_remove_bin_file); 57323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 574a306eea40952e6365301e8a2f7d5ffa9c6a1921bCornelia Huck/** 575a306eea40952e6365301e8a2f7d5ffa9c6a1921bCornelia Huck * device_schedule_callback_owner - helper to schedule a callback for a device 57623681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman * @dev: device. 577312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers * @func: callback function to invoke later. 5781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @owner: module owning the callback routine 5791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 5801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Attribute methods must not unregister themselves or their parent device 5811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * (which would amount to the same thing). Attempts to do so will deadlock, 5821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * since unregistration is mutually exclusive with driver callbacks. 5831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 5841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Instead methods can call this routine, which will attempt to allocate 5851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * and schedule a workqueue request to call back @func with @dev as its 5861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * argument in the workqueue's process context. @dev will be pinned until 5871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @func returns. 5881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 5891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This routine is usually called via the inline device_schedule_callback(), 5901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * which automatically sets @owner to THIS_MODULE. 5911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 5921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Returns 0 if the request was submitted, -ENOMEM if storage could not 5931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * be allocated, -ENODEV if a reference to @owner isn't available. 5941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 5951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * NOTE: This routine won't work if CONFIG_SYSFS isn't set! It uses an 5961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * underlying sysfs routine (since it is intended for use by attribute 5971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * methods), and if sysfs isn't available you'll get nothing but -ENOSYS. 5981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 5991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint device_schedule_callback_owner(struct device *dev, 6001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds void (*func)(struct device *), struct module *owner) 6011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 6021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return sysfs_schedule_callback(&dev->kobj, 6031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (void (*)(void *)) func, dev, owner); 6041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 6051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL_GPL(device_schedule_callback_owner); 6061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void klist_children_get(struct klist_node *n) 6081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 6091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct device_private *p = to_device_private_parent(n); 6101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct device *dev = p->device; 6111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds get_device(dev); 6131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 6141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void klist_children_put(struct klist_node *n) 6161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 6171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct device_private *p = to_device_private_parent(n); 6181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct device *dev = p->device; 6191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds put_device(dev); 6211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 6221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 6241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * device_initialize - init device structure. 6251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @dev: device. 6261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 6271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This prepares the device for use by other layers by initializing 6281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * its fields. 6291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * It is the first half of device_register(), if called by 6301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * that function, though it can also be called separately, so one 6311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * may use @dev's fields. In particular, get_device()/put_device() 6321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * may be used for reference counting of @dev after calling this 6331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * function. 6341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 6351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * All fields in @dev must be initialized by the caller to 0, except 6361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * for those explicitly set to some other value. The simplest 6371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * approach is to use kzalloc() to allocate the structure containing 6381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @dev. 6391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 6401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * NOTE: Use put_device() to give up your reference instead of freeing 6411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @dev directly once you have called this function. 6421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 6431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsvoid device_initialize(struct device *dev) 6441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 6451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev->kobj.kset = devices_kset; 6461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kobject_init(&dev->kobj, &device_ktype); 6471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools); 648c47ed219ba81632595e9f02e27318151fec16c9eGreg Kroah-Hartman mutex_init(&dev->mutex); 6491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds lockdep_set_novalidate_class(&dev->mutex); 6501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_init(&dev->devres_lock); 651d62c0f9fd2d3943a3eca85b490d86e1605000ccbPatrick Mochel INIT_LIST_HEAD(&dev->devres_head); 65282189b9807e05ea8d1f69de5bf92eaf244a0eb12Catalin Marinas device_pm_init(dev); 65323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman set_dev_node(dev, -1); 65482189b9807e05ea8d1f69de5bf92eaf244a0eb12Catalin Marinas} 65582189b9807e05ea8d1f69de5bf92eaf244a0eb12Catalin Marinas 656b9d9c82b4d081feb464f62dfc786c8621d09ecd2Kay Sieversstatic struct kobject *virtual_device_parent(struct device *dev) 657b9d9c82b4d081feb464f62dfc786c8621d09ecd2Kay Sievers{ 65840fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman static struct kobject *virtual_dir = NULL; 65940fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman 66040fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman if (!virtual_dir) 66140fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual", 66240fa54226f518a9bc97ed1d711c0016e416e3782Greg Kroah-Hartman &devices_kset->kobj); 66399ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers 66464bb5d2c116478dba7501d2acf078ed74ba30c1fGreg Kroah-Hartman return virtual_dir; 66599ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers} 66699ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers 66764bb5d2c116478dba7501d2acf078ed74ba30c1fGreg Kroah-Hartmanstruct class_dir { 66899ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers struct kobject kobj; 66999ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers struct class *class; 67064bb5d2c116478dba7501d2acf078ed74ba30c1fGreg Kroah-Hartman}; 67199ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers 67299ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers#define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 6735d9fd169c9fbdaecdc430431e59bf94ff40b93d3Greg Kroah-Hartman 674c47ed219ba81632595e9f02e27318151fec16c9eGreg Kroah-Hartmanstatic void class_dir_release(struct kobject *kobj) 675c47ed219ba81632595e9f02e27318151fec16c9eGreg Kroah-Hartman{ 676c47ed219ba81632595e9f02e27318151fec16c9eGreg Kroah-Hartman struct class_dir *dir = to_class_dir(kobj); 677c47ed219ba81632595e9f02e27318151fec16c9eGreg Kroah-Hartman kfree(dir); 678c47ed219ba81632595e9f02e27318151fec16c9eGreg Kroah-Hartman} 6795d9fd169c9fbdaecdc430431e59bf94ff40b93d3Greg Kroah-Hartman 6805d9fd169c9fbdaecdc430431e59bf94ff40b93d3Greg Kroah-Hartmanstatic const 681b9d9c82b4d081feb464f62dfc786c8621d09ecd2Kay Sieversstruct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 682a7fd67062efc5b0fc9a61368c607fa92d1d57f9eKay Sievers{ 683de0ff00d723fd821d372496e2c084805644aa5e1Greg Kroah-Hartman struct class_dir *dir = to_class_dir(kobj); 6842620efef7029bb040430f50f0fc148f2d5e002adGreg Kroah-Hartman return dir->class->ns_type; 685289535334646796fe41f199718e4a731f7411a92Benjamin Herrenschmidt} 6861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct kobj_type class_dir_ktype = { 6881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .release = class_dir_release, 6891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .sysfs_ops = &kobj_sysfs_ops, 6901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .child_ns_type = class_dir_child_ns_type 6911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 692116af378201ef793424cd10508ccf18b06d8a021Benjamin Herrenschmidt 693116af378201ef793424cd10508ccf18b06d8a021Benjamin Herrenschmidtstatic struct kobject * 694116af378201ef793424cd10508ccf18b06d8a021Benjamin Herrenschmidtclass_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 6951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 696312c004d36ce6c739512bac83b452f4c20ab1f62Kay Sievers struct class_dir *dir; 6971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int retval; 6981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dir = kzalloc(sizeof(*dir), GFP_KERNEL); 7001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!dir) 7011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 7021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dir->class = class; 7041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kobject_init(&dir->kobj, &class_dir_ktype); 7051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dir->kobj.kset = &class->p->glue_dirs; 7071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 7091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (retval < 0) { 7101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kobject_put(&dir->kobj); 7111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 7121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return &dir->kobj; 7141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct kobject *get_device_parent(struct device *dev, 7181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct device *parent) 7191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 7201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (dev->class) { 72136239577cfb6b9a7c111209536b54200b0252ebfPatrick Mochel static DEFINE_MUTEX(gdp_mutex); 72236239577cfb6b9a7c111209536b54200b0252ebfPatrick Mochel struct kobject *kobj = NULL; 72336239577cfb6b9a7c111209536b54200b0252ebfPatrick Mochel struct kobject *parent_kobj; 72436239577cfb6b9a7c111209536b54200b0252ebfPatrick Mochel struct kobject *k; 72536239577cfb6b9a7c111209536b54200b0252ebfPatrick Mochel 72636239577cfb6b9a7c111209536b54200b0252ebfPatrick Mochel#ifdef CONFIG_BLOCK 7271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* block disks show up in /sys/block */ 7281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sysfs_deprecated && dev->class == &block_class) { 729c41455fbac06712992da491844449775cf9a8c80Randy Dunlap if (parent && parent->class == &block_class) 7301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return &parent->kobj; 7311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return &block_class.p->subsys.kobj; 7321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 733c41455fbac06712992da491844449775cf9a8c80Randy Dunlap#endif 7341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* 7361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * If we have no parent, we live in "virtual". 7371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Class-devices with a non class-device as parent, live 7381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * in a "glue" directory to prevent namespace collisions. 73936239577cfb6b9a7c111209536b54200b0252ebfPatrick Mochel */ 7401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (parent == NULL) 7411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds parent_kobj = virtual_device_parent(dev); 74236239577cfb6b9a7c111209536b54200b0252ebfPatrick Mochel else if (parent->class && !dev->class->ns_type) 7431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return &parent->kobj; 7441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 7451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds parent_kobj = &parent->kobj; 74636239577cfb6b9a7c111209536b54200b0252ebfPatrick Mochel 74736239577cfb6b9a7c111209536b54200b0252ebfPatrick Mochel mutex_lock(&gdp_mutex); 74836239577cfb6b9a7c111209536b54200b0252ebfPatrick Mochel 74936239577cfb6b9a7c111209536b54200b0252ebfPatrick Mochel /* find our class-directory at the parent and reference it */ 7501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock(&dev->class->p->glue_dirs.list_lock); 7511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 7521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (k->parent == parent_kobj) { 7535ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck kobj = kobject_get(k); 7545ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck break; 7555ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck } 7565ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck spin_unlock(&dev->class->p->glue_dirs.list_lock); 7575ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck if (kobj) { 7585ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck mutex_unlock(&gdp_mutex); 7595ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck return kobj; 7605ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck } 7615ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck 7625ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck /* or create a new class-directory at the parent device */ 7635ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck k = class_dir_create_and_add(dev->class, parent_kobj); 7645ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck /* do not emit an uevent for this simple "glue" directory */ 7655ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck mutex_unlock(&gdp_mutex); 7665ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck return k; 7675ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck } 7685ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck 7695ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck /* subsystems can specify a default root directory for their devices */ 7705ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck if (!parent && dev->bus && dev->bus->dev_root) 7715ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck return &dev->bus->dev_root->kobj; 7725ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck 7735ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck if (parent) 7745ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck return &parent->kobj; 7755ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck return NULL; 7765ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck} 7775ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck 7785ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huckstatic void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 7795ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck{ 7805ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck /* see if we live in a "glue" directory */ 7815ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck if (!glue_dir || !dev->class || 7825ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck glue_dir->kset != &dev->class->p->glue_dirs) 7835ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck return; 7845ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck 7851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds kobject_put(glue_dir); 7861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void cleanup_device_parent(struct device *dev) 7891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 7901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cleanup_glue_dir(dev, dev->kobj.parent); 7915ab699810d46011ad2195c5916f3cbc684bfe3eeCornelia Huck} 7921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int device_add_class_symlinks(struct device *dev) 7941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 7951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int error; 7961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!dev->class) 7981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 7991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds error = sysfs_create_link(&dev->kobj, 8011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds &dev->class->p->subsys.kobj, 8021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "subsystem"); 8031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (error) 80423681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman goto out; 80523681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 80623681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) { 80723681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 80823681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman "device"); 80923681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman if (error) 81023681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman goto out_subsys; 81123681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman } 81223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 81323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman#ifdef CONFIG_BLOCK 81442734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar /* /sys/block has directories and does not need symlinks */ 81542734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar if (sysfs_deprecated && dev->class == &block_class) 81642734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar return 0; 81742734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar#endif 81842734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar 81942734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar /* link in the class directory pointing to the device */ 82042734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar error = sysfs_create_link(&dev->class->p->subsys.kobj, 82123681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman &dev->kobj, dev_name(dev)); 82223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman if (error) 82323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman goto out_device; 82442734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar 82542734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar return 0; 82642734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar 82742734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmarout_device: 82823681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 82923681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 83023681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartmanout_subsys: 83123681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "subsystem"); 83223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartmanout: 83323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman return error; 8345cbe5f8a5897470698222ac9924429056e57d84cGreg Kroah-Hartman} 83523681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 83623681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartmanstatic void device_remove_class_symlinks(struct device *dev) 83723681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman{ 83823681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman if (!dev->class) 83923681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman return; 84023681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 84123681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) 84223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 84323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "subsystem"); 84423681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman#ifdef CONFIG_BLOCK 84523681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman if (sysfs_deprecated && dev->class == &block_class) 84623681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman return; 84723681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman#endif 84823681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 84923681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman} 85023681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 85123681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman/** 85223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman * dev_set_name - set a device name 85323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman * @dev: device 85423681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman * @fmt: format string for the device's name 85523681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman */ 85623681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartmanint dev_set_name(struct device *dev, const char *fmt, ...) 85723681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman{ 85823681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman va_list vargs; 85923681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman int err; 86023681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 86123681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman va_start(vargs, fmt); 86223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 86323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman va_end(vargs); 86423681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman return err; 86523681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman} 86623681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-HartmanEXPORT_SYMBOL_GPL(dev_set_name); 86723681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 86823681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman/** 86923681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman * device_to_dev_kobj - select a /sys/dev/ directory for the device 87023681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman * @dev: device 87142734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar * 87242734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar * By default we select char/ for new entries. Setting class->dev_obj 87323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman * to NULL prevents an entry from being created. class->dev_kobj must 87442734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar * be set (or cleared) before any devices are registered to the class 87542734dafa43e453a8b6769a5ebd3a01ffc1fd116Henrik Kretzschmar * otherwise device_create_sys_dev_entry() and 87623681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman * device_remove_sys_dev_entry() will disagree about the the presence 87723681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman * of the link. 87823681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman */ 87923681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartmanstatic struct kobject *device_to_dev_kobj(struct device *dev) 88023681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman{ 88123681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman struct kobject *kobj; 88223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 88323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman if (dev->class) 88423681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman kobj = dev->class->dev_kobj; 88523681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman else 88623681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman kobj = sysfs_dev_char_kobj; 88723681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 88823681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman return kobj; 88923681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman} 89023681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman 8915d9fd169c9fbdaecdc430431e59bf94ff40b93d3Greg Kroah-Hartmanstatic int device_create_sys_dev_entry(struct device *dev) 89223681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman{ 89323681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman struct kobject *kobj = device_to_dev_kobj(dev); 89423681e479129854305da1da32f7f1eaf635ef22cGreg Kroah-Hartman int error = 0; 895a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman char devt_str[15]; 896a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman 897a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman if (kobj) { 898a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman format_dev_t(devt_str, dev->devt); 899a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman error = sysfs_create_link(kobj, &dev->kobj, devt_str); 900a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman } 901a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman 902a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman return error; 903a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman} 904a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman 905a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartmanstatic void device_remove_sys_dev_entry(struct device *dev) 906a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman{ 907a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman struct kobject *kobj = device_to_dev_kobj(dev); 908a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman char devt_str[15]; 909a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman 910a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman if (kobj) { 911a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman format_dev_t(devt_str, dev->devt); 912a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman sysfs_remove_link(kobj, devt_str); 913a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman } 91499ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers} 915a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman 916a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartmanint device_private_init(struct device *dev) 91799ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers{ 918a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 919a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman if (!dev->p) 920a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman return -ENOMEM; 921952ab431cd36c7ab573f685af8679c3677cbdc29Jesper Juhl dev->p->device = dev; 922952ab431cd36c7ab573f685af8679c3677cbdc29Jesper Juhl klist_init(&dev->p->klist_children, klist_children_get, 923952ab431cd36c7ab573f685af8679c3677cbdc29Jesper Juhl klist_children_put); 924952ab431cd36c7ab573f685af8679c3677cbdc29Jesper Juhl return 0; 925a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman} 926a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman 927a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman/** 928a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * device_add - add device to device hierarchy. 929a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * @dev: device. 930a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * 931a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * This is part 2 of device_register(), though may be called 93299ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers * separately _iff_ device_initialize() has been called separately. 933a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * 934a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * This adds @dev to the kobject hierarchy via kobject_add(), adds it 935a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * to the global and sibling lists for the device, then 936a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * adds it to the other relevant subsystems of the driver model. 937a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * 938a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * Do not call this routine or device_register() more than once for 939a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * any device structure. The driver model core is not designed to work 940a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * with devices that get unregistered and then spring back to life. 94199ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers * (Among other things, it's very hard to guarantee that all references 94299ef3ef8d5f2f5b5312627127ad63df27c0d0d05Kay Sievers * to the previous incarnation of @dev have been dropped.) Allocate 943a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * and register a fresh new struct device instead. 944a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * 945a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * NOTE: _Never_ directly free @dev after calling this function, even 946a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * if it returned an error! Always use put_device() to give up your 947a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman * reference instead. 948a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman */ 949a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartmanint device_add(struct device *dev) 950a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman{ 951a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman struct device *parent = NULL; 952a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman struct kobject *kobj; 953952ab431cd36c7ab573f685af8679c3677cbdc29Jesper Juhl struct class_interface *class_intf; 954952ab431cd36c7ab573f685af8679c3677cbdc29Jesper Juhl int error = -EINVAL; 955a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman 956a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman dev = get_device(dev); 957a2de48cace5d0993da6cfa28b276ae724dc3569bGreg Kroah-Hartman if (!dev) 9588a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck goto done; 9598a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 9608a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (!dev->p) { 9618a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck error = device_private_init(dev); 9628a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (error) 9638a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck goto done; 9648a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck } 9658a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 9668a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck /* 9678a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck * for statically allocated devices, which should all be converted 9688a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck * some day, we need to initialize the name. We prevent reading back 9698a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck * the name, and force the use of dev_name() 9708a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck */ 9718a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (dev->init_name) { 9728a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck dev_set_name(dev, "%s", dev->init_name); 9738a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck dev->init_name = NULL; 9748a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck } 9758a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 9768a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck /* subsystems can specify simple device enumeration */ 9778a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 9788a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 9798a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 9808a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (!dev_name(dev)) { 9818a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck error = -EINVAL; 9828a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck goto name_error; 9838a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck } 9848a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 9858a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 9868a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 9878a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck parent = get_device(dev->parent); 9888a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck kobj = get_device_parent(dev, parent); 9898a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (kobj) 9908a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck dev->kobj.parent = kobj; 9918a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 9928a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck /* use parent numa_node */ 9938a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (parent) 9948a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck set_dev_node(dev, dev_to_node(parent)); 9958a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 9968a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck /* first, register with generic layer. */ 9978a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck /* we require the name to be set before, and pass NULL */ 9988a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 9998a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (error) 10008a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck goto Error; 10018a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 10028a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck /* notify platform of device entry */ 10038a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (platform_notify) 10048a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck platform_notify(dev); 10058a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 10068a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck error = device_create_file(dev, &uevent_attr); 10078a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (error) 10088a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck goto attrError; 10098a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 10108a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (MAJOR(dev->devt)) { 10118a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck error = device_create_file(dev, &devt_attr); 10128a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (error) 10138a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck goto ueventattrError; 10148a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 10158a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck error = device_create_sys_dev_entry(dev); 10168a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (error) 10178a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck goto devtattrError; 10188a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 10198a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck devtmpfs_create_node(dev); 10208a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck } 10218a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 10228a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck error = device_add_class_symlinks(dev); 10238a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (error) 10248a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck goto SymlinkError; 10258a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck error = device_add_attrs(dev); 10268a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (error) 10278a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck goto AttrsError; 10288a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck error = bus_add_device(dev); 10298a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (error) 10308a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck goto BusError; 10318a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck error = dpm_sysfs_add(dev); 10328a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (error) 10338a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck goto DPMError; 10348a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck device_pm_add(dev); 10358a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 10368a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck /* Notify clients of device addition. This call must come 10378a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck * after dpm_sysfs_add() and before kobject_uevent(). 10388a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck */ 10398a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (dev->bus) 10408a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 10418a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck BUS_NOTIFY_ADD_DEVICE, dev); 10428a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 10438a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck kobject_uevent(&dev->kobj, KOBJ_ADD); 10448a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck bus_probe_device(dev); 10458a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (parent) 10468a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck klist_add_tail(&dev->p->knode_parent, 10478a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck &parent->p->klist_children); 10488a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck 10498a82472f86bf693b8e91ed56c9ca4f62fbbdcfa3Cornelia Huck if (dev->class) { 1050 mutex_lock(&dev->class->p->mutex); 1051 /* tie the class to the device */ 1052 klist_add_tail(&dev->knode_class, 1053 &dev->class->p->klist_devices); 1054 1055 /* notify any interfaces that the device is here */ 1056 list_for_each_entry(class_intf, 1057 &dev->class->p->interfaces, node) 1058 if (class_intf->add_dev) 1059 class_intf->add_dev(dev, class_intf); 1060 mutex_unlock(&dev->class->p->mutex); 1061 } 1062done: 1063 put_device(dev); 1064 return error; 1065 DPMError: 1066 bus_remove_device(dev); 1067 BusError: 1068 device_remove_attrs(dev); 1069 AttrsError: 1070 device_remove_class_symlinks(dev); 1071 SymlinkError: 1072 if (MAJOR(dev->devt)) 1073 devtmpfs_delete_node(dev); 1074 if (MAJOR(dev->devt)) 1075 device_remove_sys_dev_entry(dev); 1076 devtattrError: 1077 if (MAJOR(dev->devt)) 1078 device_remove_file(dev, &devt_attr); 1079 ueventattrError: 1080 device_remove_file(dev, &uevent_attr); 1081 attrError: 1082 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 1083 kobject_del(&dev->kobj); 1084 Error: 1085 cleanup_device_parent(dev); 1086 if (parent) 1087 put_device(parent); 1088name_error: 1089 kfree(dev->p); 1090 dev->p = NULL; 1091 goto done; 1092} 1093 1094/** 1095 * device_register - register a device with the system. 1096 * @dev: pointer to the device structure 1097 * 1098 * This happens in two clean steps - initialize the device 1099 * and add it to the system. The two steps can be called 1100 * separately, but this is the easiest and most common. 1101 * I.e. you should only call the two helpers separately if 1102 * have a clearly defined need to use and refcount the device 1103 * before it is added to the hierarchy. 1104 * 1105 * For more information, see the kerneldoc for device_initialize() 1106 * and device_add(). 1107 * 1108 * NOTE: _Never_ directly free @dev after calling this function, even 1109 * if it returned an error! Always use put_device() to give up the 1110 * reference initialized in this function instead. 1111 */ 1112int device_register(struct device *dev) 1113{ 1114 device_initialize(dev); 1115 return device_add(dev); 1116} 1117 1118/** 1119 * get_device - increment reference count for device. 1120 * @dev: device. 1121 * 1122 * This simply forwards the call to kobject_get(), though 1123 * we do take care to provide for the case that we get a NULL 1124 * pointer passed in. 1125 */ 1126struct device *get_device(struct device *dev) 1127{ 1128 return dev ? to_dev(kobject_get(&dev->kobj)) : NULL; 1129} 1130 1131/** 1132 * put_device - decrement reference count. 1133 * @dev: device in question. 1134 */ 1135void put_device(struct device *dev) 1136{ 1137 /* might_sleep(); */ 1138 if (dev) 1139 kobject_put(&dev->kobj); 1140} 1141 1142/** 1143 * device_del - delete device from system. 1144 * @dev: device. 1145 * 1146 * This is the first part of the device unregistration 1147 * sequence. This removes the device from the lists we control 1148 * from here, has it removed from the other driver model 1149 * subsystems it was added to in device_add(), and removes it 1150 * from the kobject hierarchy. 1151 * 1152 * NOTE: this should be called manually _iff_ device_add() was 1153 * also called manually. 1154 */ 1155void device_del(struct device *dev) 1156{ 1157 struct device *parent = dev->parent; 1158 struct class_interface *class_intf; 1159 1160 /* Notify clients of device removal. This call must come 1161 * before dpm_sysfs_remove(). 1162 */ 1163 if (dev->bus) 1164 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1165 BUS_NOTIFY_DEL_DEVICE, dev); 1166 device_pm_remove(dev); 1167 dpm_sysfs_remove(dev); 1168 if (parent) 1169 klist_del(&dev->p->knode_parent); 1170 if (MAJOR(dev->devt)) { 1171 devtmpfs_delete_node(dev); 1172 device_remove_sys_dev_entry(dev); 1173 device_remove_file(dev, &devt_attr); 1174 } 1175 if (dev->class) { 1176 device_remove_class_symlinks(dev); 1177 1178 mutex_lock(&dev->class->p->mutex); 1179 /* notify any interfaces that the device is now gone */ 1180 list_for_each_entry(class_intf, 1181 &dev->class->p->interfaces, node) 1182 if (class_intf->remove_dev) 1183 class_intf->remove_dev(dev, class_intf); 1184 /* remove the device from the class list */ 1185 klist_del(&dev->knode_class); 1186 mutex_unlock(&dev->class->p->mutex); 1187 } 1188 device_remove_file(dev, &uevent_attr); 1189 device_remove_attrs(dev); 1190 bus_remove_device(dev); 1191 1192 /* 1193 * Some platform devices are driven without driver attached 1194 * and managed resources may have been acquired. Make sure 1195 * all resources are released. 1196 */ 1197 devres_release_all(dev); 1198 1199 /* Notify the platform of the removal, in case they 1200 * need to do anything... 1201 */ 1202 if (platform_notify_remove) 1203 platform_notify_remove(dev); 1204 kobject_uevent(&dev->kobj, KOBJ_REMOVE); 1205 cleanup_device_parent(dev); 1206 kobject_del(&dev->kobj); 1207 put_device(parent); 1208} 1209 1210/** 1211 * device_unregister - unregister device from system. 1212 * @dev: device going away. 1213 * 1214 * We do this in two parts, like we do device_register(). First, 1215 * we remove it from all the subsystems with device_del(), then 1216 * we decrement the reference count via put_device(). If that 1217 * is the final reference count, the device will be cleaned up 1218 * via device_release() above. Otherwise, the structure will 1219 * stick around until the final reference to the device is dropped. 1220 */ 1221void device_unregister(struct device *dev) 1222{ 1223 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1224 device_del(dev); 1225 put_device(dev); 1226} 1227 1228static struct device *next_device(struct klist_iter *i) 1229{ 1230 struct klist_node *n = klist_next(i); 1231 struct device *dev = NULL; 1232 struct device_private *p; 1233 1234 if (n) { 1235 p = to_device_private_parent(n); 1236 dev = p->device; 1237 } 1238 return dev; 1239} 1240 1241/** 1242 * device_get_devnode - path of device node file 1243 * @dev: device 1244 * @mode: returned file access mode 1245 * @tmp: possibly allocated string 1246 * 1247 * Return the relative path of a possible device node. 1248 * Non-default names may need to allocate a memory to compose 1249 * a name. This memory is returned in tmp and needs to be 1250 * freed by the caller. 1251 */ 1252const char *device_get_devnode(struct device *dev, 1253 umode_t *mode, const char **tmp) 1254{ 1255 char *s; 1256 1257 *tmp = NULL; 1258 1259 /* the device type may provide a specific name */ 1260 if (dev->type && dev->type->devnode) 1261 *tmp = dev->type->devnode(dev, mode); 1262 if (*tmp) 1263 return *tmp; 1264 1265 /* the class may provide a specific name */ 1266 if (dev->class && dev->class->devnode) 1267 *tmp = dev->class->devnode(dev, mode); 1268 if (*tmp) 1269 return *tmp; 1270 1271 /* return name without allocation, tmp == NULL */ 1272 if (strchr(dev_name(dev), '!') == NULL) 1273 return dev_name(dev); 1274 1275 /* replace '!' in the name with '/' */ 1276 *tmp = kstrdup(dev_name(dev), GFP_KERNEL); 1277 if (!*tmp) 1278 return NULL; 1279 while ((s = strchr(*tmp, '!'))) 1280 s[0] = '/'; 1281 return *tmp; 1282} 1283 1284/** 1285 * device_for_each_child - device child iterator. 1286 * @parent: parent struct device. 1287 * @data: data for the callback. 1288 * @fn: function to be called for each device. 1289 * 1290 * Iterate over @parent's child devices, and call @fn for each, 1291 * passing it @data. 1292 * 1293 * We check the return of @fn each time. If it returns anything 1294 * other than 0, we break out and return that value. 1295 */ 1296int device_for_each_child(struct device *parent, void *data, 1297 int (*fn)(struct device *dev, void *data)) 1298{ 1299 struct klist_iter i; 1300 struct device *child; 1301 int error = 0; 1302 1303 if (!parent->p) 1304 return 0; 1305 1306 klist_iter_init(&parent->p->klist_children, &i); 1307 while ((child = next_device(&i)) && !error) 1308 error = fn(child, data); 1309 klist_iter_exit(&i); 1310 return error; 1311} 1312 1313/** 1314 * device_find_child - device iterator for locating a particular device. 1315 * @parent: parent struct device 1316 * @data: Data to pass to match function 1317 * @match: Callback function to check device 1318 * 1319 * This is similar to the device_for_each_child() function above, but it 1320 * returns a reference to a device that is 'found' for later use, as 1321 * determined by the @match callback. 1322 * 1323 * The callback should return 0 if the device doesn't match and non-zero 1324 * if it does. If the callback returns non-zero and a reference to the 1325 * current device can be obtained, this function will return to the caller 1326 * and not iterate over any more devices. 1327 */ 1328struct device *device_find_child(struct device *parent, void *data, 1329 int (*match)(struct device *dev, void *data)) 1330{ 1331 struct klist_iter i; 1332 struct device *child; 1333 1334 if (!parent) 1335 return NULL; 1336 1337 klist_iter_init(&parent->p->klist_children, &i); 1338 while ((child = next_device(&i))) 1339 if (match(child, data) && get_device(child)) 1340 break; 1341 klist_iter_exit(&i); 1342 return child; 1343} 1344 1345int __init devices_init(void) 1346{ 1347 devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 1348 if (!devices_kset) 1349 return -ENOMEM; 1350 dev_kobj = kobject_create_and_add("dev", NULL); 1351 if (!dev_kobj) 1352 goto dev_kobj_err; 1353 sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 1354 if (!sysfs_dev_block_kobj) 1355 goto block_kobj_err; 1356 sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 1357 if (!sysfs_dev_char_kobj) 1358 goto char_kobj_err; 1359 1360 return 0; 1361 1362 char_kobj_err: 1363 kobject_put(sysfs_dev_block_kobj); 1364 block_kobj_err: 1365 kobject_put(dev_kobj); 1366 dev_kobj_err: 1367 kset_unregister(devices_kset); 1368 return -ENOMEM; 1369} 1370 1371EXPORT_SYMBOL_GPL(device_for_each_child); 1372EXPORT_SYMBOL_GPL(device_find_child); 1373 1374EXPORT_SYMBOL_GPL(device_initialize); 1375EXPORT_SYMBOL_GPL(device_add); 1376EXPORT_SYMBOL_GPL(device_register); 1377 1378EXPORT_SYMBOL_GPL(device_del); 1379EXPORT_SYMBOL_GPL(device_unregister); 1380EXPORT_SYMBOL_GPL(get_device); 1381EXPORT_SYMBOL_GPL(put_device); 1382 1383EXPORT_SYMBOL_GPL(device_create_file); 1384EXPORT_SYMBOL_GPL(device_remove_file); 1385 1386struct root_device { 1387 struct device dev; 1388 struct module *owner; 1389}; 1390 1391inline struct root_device *to_root_device(struct device *d) 1392{ 1393 return container_of(d, struct root_device, dev); 1394} 1395 1396static void root_device_release(struct device *dev) 1397{ 1398 kfree(to_root_device(dev)); 1399} 1400 1401/** 1402 * __root_device_register - allocate and register a root device 1403 * @name: root device name 1404 * @owner: owner module of the root device, usually THIS_MODULE 1405 * 1406 * This function allocates a root device and registers it 1407 * using device_register(). In order to free the returned 1408 * device, use root_device_unregister(). 1409 * 1410 * Root devices are dummy devices which allow other devices 1411 * to be grouped under /sys/devices. Use this function to 1412 * allocate a root device and then use it as the parent of 1413 * any device which should appear under /sys/devices/{name} 1414 * 1415 * The /sys/devices/{name} directory will also contain a 1416 * 'module' symlink which points to the @owner directory 1417 * in sysfs. 1418 * 1419 * Returns &struct device pointer on success, or ERR_PTR() on error. 1420 * 1421 * Note: You probably want to use root_device_register(). 1422 */ 1423struct device *__root_device_register(const char *name, struct module *owner) 1424{ 1425 struct root_device *root; 1426 int err = -ENOMEM; 1427 1428 root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 1429 if (!root) 1430 return ERR_PTR(err); 1431 1432 err = dev_set_name(&root->dev, "%s", name); 1433 if (err) { 1434 kfree(root); 1435 return ERR_PTR(err); 1436 } 1437 1438 root->dev.release = root_device_release; 1439 1440 err = device_register(&root->dev); 1441 if (err) { 1442 put_device(&root->dev); 1443 return ERR_PTR(err); 1444 } 1445 1446#ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 1447 if (owner) { 1448 struct module_kobject *mk = &owner->mkobj; 1449 1450 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 1451 if (err) { 1452 device_unregister(&root->dev); 1453 return ERR_PTR(err); 1454 } 1455 root->owner = owner; 1456 } 1457#endif 1458 1459 return &root->dev; 1460} 1461EXPORT_SYMBOL_GPL(__root_device_register); 1462 1463/** 1464 * root_device_unregister - unregister and free a root device 1465 * @dev: device going away 1466 * 1467 * This function unregisters and cleans up a device that was created by 1468 * root_device_register(). 1469 */ 1470void root_device_unregister(struct device *dev) 1471{ 1472 struct root_device *root = to_root_device(dev); 1473 1474 if (root->owner) 1475 sysfs_remove_link(&root->dev.kobj, "module"); 1476 1477 device_unregister(dev); 1478} 1479EXPORT_SYMBOL_GPL(root_device_unregister); 1480 1481 1482static void device_create_release(struct device *dev) 1483{ 1484 pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1485 kfree(dev); 1486} 1487 1488/** 1489 * device_create_vargs - creates a device and registers it with sysfs 1490 * @class: pointer to the struct class that this device should be registered to 1491 * @parent: pointer to the parent struct device of this new device, if any 1492 * @devt: the dev_t for the char device to be added 1493 * @drvdata: the data to be added to the device for callbacks 1494 * @fmt: string for the device's name 1495 * @args: va_list for the device's name 1496 * 1497 * This function can be used by char device classes. A struct device 1498 * will be created in sysfs, registered to the specified class. 1499 * 1500 * A "dev" file will be created, showing the dev_t for the device, if 1501 * the dev_t is not 0,0. 1502 * If a pointer to a parent struct device is passed in, the newly created 1503 * struct device will be a child of that device in sysfs. 1504 * The pointer to the struct device will be returned from the call. 1505 * Any further sysfs files that might be required can be created using this 1506 * pointer. 1507 * 1508 * Returns &struct device pointer on success, or ERR_PTR() on error. 1509 * 1510 * Note: the struct class passed to this function must have previously 1511 * been created with a call to class_create(). 1512 */ 1513struct device *device_create_vargs(struct class *class, struct device *parent, 1514 dev_t devt, void *drvdata, const char *fmt, 1515 va_list args) 1516{ 1517 struct device *dev = NULL; 1518 int retval = -ENODEV; 1519 1520 if (class == NULL || IS_ERR(class)) 1521 goto error; 1522 1523 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1524 if (!dev) { 1525 retval = -ENOMEM; 1526 goto error; 1527 } 1528 1529 dev->devt = devt; 1530 dev->class = class; 1531 dev->parent = parent; 1532 dev->release = device_create_release; 1533 dev_set_drvdata(dev, drvdata); 1534 1535 retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 1536 if (retval) 1537 goto error; 1538 1539 retval = device_register(dev); 1540 if (retval) 1541 goto error; 1542 1543 return dev; 1544 1545error: 1546 put_device(dev); 1547 return ERR_PTR(retval); 1548} 1549EXPORT_SYMBOL_GPL(device_create_vargs); 1550 1551/** 1552 * device_create - creates a device and registers it with sysfs 1553 * @class: pointer to the struct class that this device should be registered to 1554 * @parent: pointer to the parent struct device of this new device, if any 1555 * @devt: the dev_t for the char device to be added 1556 * @drvdata: the data to be added to the device for callbacks 1557 * @fmt: string for the device's name 1558 * 1559 * This function can be used by char device classes. A struct device 1560 * will be created in sysfs, registered to the specified class. 1561 * 1562 * A "dev" file will be created, showing the dev_t for the device, if 1563 * the dev_t is not 0,0. 1564 * If a pointer to a parent struct device is passed in, the newly created 1565 * struct device will be a child of that device in sysfs. 1566 * The pointer to the struct device will be returned from the call. 1567 * Any further sysfs files that might be required can be created using this 1568 * pointer. 1569 * 1570 * Returns &struct device pointer on success, or ERR_PTR() on error. 1571 * 1572 * Note: the struct class passed to this function must have previously 1573 * been created with a call to class_create(). 1574 */ 1575struct device *device_create(struct class *class, struct device *parent, 1576 dev_t devt, void *drvdata, const char *fmt, ...) 1577{ 1578 va_list vargs; 1579 struct device *dev; 1580 1581 va_start(vargs, fmt); 1582 dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs); 1583 va_end(vargs); 1584 return dev; 1585} 1586EXPORT_SYMBOL_GPL(device_create); 1587 1588static int __match_devt(struct device *dev, void *data) 1589{ 1590 dev_t *devt = data; 1591 1592 return dev->devt == *devt; 1593} 1594 1595/** 1596 * device_destroy - removes a device that was created with device_create() 1597 * @class: pointer to the struct class that this device was registered with 1598 * @devt: the dev_t of the device that was previously registered 1599 * 1600 * This call unregisters and cleans up a device that was created with a 1601 * call to device_create(). 1602 */ 1603void device_destroy(struct class *class, dev_t devt) 1604{ 1605 struct device *dev; 1606 1607 dev = class_find_device(class, NULL, &devt, __match_devt); 1608 if (dev) { 1609 put_device(dev); 1610 device_unregister(dev); 1611 } 1612} 1613EXPORT_SYMBOL_GPL(device_destroy); 1614 1615/** 1616 * device_rename - renames a device 1617 * @dev: the pointer to the struct device to be renamed 1618 * @new_name: the new name of the device 1619 * 1620 * It is the responsibility of the caller to provide mutual 1621 * exclusion between two different calls of device_rename 1622 * on the same device to ensure that new_name is valid and 1623 * won't conflict with other devices. 1624 * 1625 * Note: Don't call this function. Currently, the networking layer calls this 1626 * function, but that will change. The following text from Kay Sievers offers 1627 * some insight: 1628 * 1629 * Renaming devices is racy at many levels, symlinks and other stuff are not 1630 * replaced atomically, and you get a "move" uevent, but it's not easy to 1631 * connect the event to the old and new device. Device nodes are not renamed at 1632 * all, there isn't even support for that in the kernel now. 1633 * 1634 * In the meantime, during renaming, your target name might be taken by another 1635 * driver, creating conflicts. Or the old name is taken directly after you 1636 * renamed it -- then you get events for the same DEVPATH, before you even see 1637 * the "move" event. It's just a mess, and nothing new should ever rely on 1638 * kernel device renaming. Besides that, it's not even implemented now for 1639 * other things than (driver-core wise very simple) network devices. 1640 * 1641 * We are currently about to change network renaming in udev to completely 1642 * disallow renaming of devices in the same namespace as the kernel uses, 1643 * because we can't solve the problems properly, that arise with swapping names 1644 * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 1645 * be allowed to some other name than eth[0-9]*, for the aforementioned 1646 * reasons. 1647 * 1648 * Make up a "real" name in the driver before you register anything, or add 1649 * some other attributes for userspace to find the device, or use udev to add 1650 * symlinks -- but never rename kernel devices later, it's a complete mess. We 1651 * don't even want to get into that and try to implement the missing pieces in 1652 * the core. We really have other pieces to fix in the driver core mess. :) 1653 */ 1654int device_rename(struct device *dev, const char *new_name) 1655{ 1656 char *old_class_name = NULL; 1657 char *new_class_name = NULL; 1658 char *old_device_name = NULL; 1659 int error; 1660 1661 dev = get_device(dev); 1662 if (!dev) 1663 return -EINVAL; 1664 1665 pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev), 1666 __func__, new_name); 1667 1668 old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 1669 if (!old_device_name) { 1670 error = -ENOMEM; 1671 goto out; 1672 } 1673 1674 if (dev->class) { 1675 error = sysfs_rename_link(&dev->class->p->subsys.kobj, 1676 &dev->kobj, old_device_name, new_name); 1677 if (error) 1678 goto out; 1679 } 1680 1681 error = kobject_rename(&dev->kobj, new_name); 1682 if (error) 1683 goto out; 1684 1685out: 1686 put_device(dev); 1687 1688 kfree(new_class_name); 1689 kfree(old_class_name); 1690 kfree(old_device_name); 1691 1692 return error; 1693} 1694EXPORT_SYMBOL_GPL(device_rename); 1695 1696static int device_move_class_links(struct device *dev, 1697 struct device *old_parent, 1698 struct device *new_parent) 1699{ 1700 int error = 0; 1701 1702 if (old_parent) 1703 sysfs_remove_link(&dev->kobj, "device"); 1704 if (new_parent) 1705 error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 1706 "device"); 1707 return error; 1708} 1709 1710/** 1711 * device_move - moves a device to a new parent 1712 * @dev: the pointer to the struct device to be moved 1713 * @new_parent: the new parent of the device (can by NULL) 1714 * @dpm_order: how to reorder the dpm_list 1715 */ 1716int device_move(struct device *dev, struct device *new_parent, 1717 enum dpm_order dpm_order) 1718{ 1719 int error; 1720 struct device *old_parent; 1721 struct kobject *new_parent_kobj; 1722 1723 dev = get_device(dev); 1724 if (!dev) 1725 return -EINVAL; 1726 1727 device_pm_lock(); 1728 new_parent = get_device(new_parent); 1729 new_parent_kobj = get_device_parent(dev, new_parent); 1730 1731 pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 1732 __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 1733 error = kobject_move(&dev->kobj, new_parent_kobj); 1734 if (error) { 1735 cleanup_glue_dir(dev, new_parent_kobj); 1736 put_device(new_parent); 1737 goto out; 1738 } 1739 old_parent = dev->parent; 1740 dev->parent = new_parent; 1741 if (old_parent) 1742 klist_remove(&dev->p->knode_parent); 1743 if (new_parent) { 1744 klist_add_tail(&dev->p->knode_parent, 1745 &new_parent->p->klist_children); 1746 set_dev_node(dev, dev_to_node(new_parent)); 1747 } 1748 1749 if (!dev->class) 1750 goto out_put; 1751 error = device_move_class_links(dev, old_parent, new_parent); 1752 if (error) { 1753 /* We ignore errors on cleanup since we're hosed anyway... */ 1754 device_move_class_links(dev, new_parent, old_parent); 1755 if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 1756 if (new_parent) 1757 klist_remove(&dev->p->knode_parent); 1758 dev->parent = old_parent; 1759 if (old_parent) { 1760 klist_add_tail(&dev->p->knode_parent, 1761 &old_parent->p->klist_children); 1762 set_dev_node(dev, dev_to_node(old_parent)); 1763 } 1764 } 1765 cleanup_glue_dir(dev, new_parent_kobj); 1766 put_device(new_parent); 1767 goto out; 1768 } 1769 switch (dpm_order) { 1770 case DPM_ORDER_NONE: 1771 break; 1772 case DPM_ORDER_DEV_AFTER_PARENT: 1773 device_pm_move_after(dev, new_parent); 1774 break; 1775 case DPM_ORDER_PARENT_BEFORE_DEV: 1776 device_pm_move_before(new_parent, dev); 1777 break; 1778 case DPM_ORDER_DEV_LAST: 1779 device_pm_move_last(dev); 1780 break; 1781 } 1782out_put: 1783 put_device(old_parent); 1784out: 1785 device_pm_unlock(); 1786 put_device(dev); 1787 return error; 1788} 1789EXPORT_SYMBOL_GPL(device_move); 1790 1791/** 1792 * device_shutdown - call ->shutdown() on each device to shutdown. 1793 */ 1794void device_shutdown(void) 1795{ 1796 struct device *dev; 1797 1798 spin_lock(&devices_kset->list_lock); 1799 /* 1800 * Walk the devices list backward, shutting down each in turn. 1801 * Beware that device unplug events may also start pulling 1802 * devices offline, even as the system is shutting down. 1803 */ 1804 while (!list_empty(&devices_kset->list)) { 1805 dev = list_entry(devices_kset->list.prev, struct device, 1806 kobj.entry); 1807 get_device(dev); 1808 /* 1809 * Make sure the device is off the kset list, in the 1810 * event that dev->*->shutdown() doesn't remove it. 1811 */ 1812 list_del_init(&dev->kobj.entry); 1813 spin_unlock(&devices_kset->list_lock); 1814 1815 /* Don't allow any more runtime suspends */ 1816 pm_runtime_get_noresume(dev); 1817 pm_runtime_barrier(dev); 1818 1819 if (dev->bus && dev->bus->shutdown) { 1820 dev_dbg(dev, "shutdown\n"); 1821 dev->bus->shutdown(dev); 1822 } else if (dev->driver && dev->driver->shutdown) { 1823 dev_dbg(dev, "shutdown\n"); 1824 dev->driver->shutdown(dev); 1825 } 1826 put_device(dev); 1827 1828 spin_lock(&devices_kset->list_lock); 1829 } 1830 spin_unlock(&devices_kset->list_lock); 1831 async_synchronize_full(); 1832} 1833 1834/* 1835 * Device logging functions 1836 */ 1837 1838#ifdef CONFIG_PRINTK 1839 1840int __dev_printk(const char *level, const struct device *dev, 1841 struct va_format *vaf) 1842{ 1843 if (!dev) 1844 return printk("%s(NULL device *): %pV", level, vaf); 1845 1846 return printk("%s%s %s: %pV", 1847 level, dev_driver_string(dev), dev_name(dev), vaf); 1848} 1849EXPORT_SYMBOL(__dev_printk); 1850 1851int dev_printk(const char *level, const struct device *dev, 1852 const char *fmt, ...) 1853{ 1854 struct va_format vaf; 1855 va_list args; 1856 int r; 1857 1858 va_start(args, fmt); 1859 1860 vaf.fmt = fmt; 1861 vaf.va = &args; 1862 1863 r = __dev_printk(level, dev, &vaf); 1864 va_end(args); 1865 1866 return r; 1867} 1868EXPORT_SYMBOL(dev_printk); 1869 1870#define define_dev_printk_level(func, kern_level) \ 1871int func(const struct device *dev, const char *fmt, ...) \ 1872{ \ 1873 struct va_format vaf; \ 1874 va_list args; \ 1875 int r; \ 1876 \ 1877 va_start(args, fmt); \ 1878 \ 1879 vaf.fmt = fmt; \ 1880 vaf.va = &args; \ 1881 \ 1882 r = __dev_printk(kern_level, dev, &vaf); \ 1883 va_end(args); \ 1884 \ 1885 return r; \ 1886} \ 1887EXPORT_SYMBOL(func); 1888 1889define_dev_printk_level(dev_emerg, KERN_EMERG); 1890define_dev_printk_level(dev_alert, KERN_ALERT); 1891define_dev_printk_level(dev_crit, KERN_CRIT); 1892define_dev_printk_level(dev_err, KERN_ERR); 1893define_dev_printk_level(dev_warn, KERN_WARNING); 1894define_dev_printk_level(dev_notice, KERN_NOTICE); 1895define_dev_printk_level(_dev_info, KERN_INFO); 1896 1897#endif 1898