2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* drivers/base/core.c - core driver model code (device registration, etc)
|
|
|
|
*
|
|
|
|
* Copyright (c) 2002-3 Patrick Mochel
|
|
|
|
* Copyright (c) 2002-3 Open Source Development Labs
|
2006-06-28 23:19:58 +00:00
|
|
|
* Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de>
|
|
|
|
* Copyright (c) 2006 Novell, Inc.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* This file is released under the GPLv2
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/string.h>
|
2006-06-14 19:14:34 +00:00
|
|
|
#include <linux/kdev_t.h>
|
Driver core: add notification of bus events
I finally did as you suggested and added the notifier to the struct
bus_type itself. There are still problems to be expected is something
attaches to a bus type where the code can hook in different struct
device sub-classes (which is imho a big bogosity but I won't even try to
argue that case now) but it will solve nicely a number of issues I've
had so far.
That also means that clients interested in registering for such
notifications have to do it before devices are added and after bus types
are registered. Fortunately, most bus types that matter for the various
usage scenarios I have in mind are registerd at postcore_initcall time,
which means I have a really nice spot at arch_initcall time to add my
notifiers.
There are 4 notifications provided. Device being added (before hooked to
the bus) and removed (failure of previous case or after being unhooked
from the bus), along with driver being bound to a device and about to be
unbound.
The usage I have for these are:
- The 2 first ones are used to maintain a struct device_ext that is
hooked to struct device.firmware_data. This structure contains for now a
pointer to the Open Firmware node related to the device (if any), the
NUMA node ID (for quick access to it) and the DMA operations pointers &
iommu table instance for DMA to/from this device. For bus types I own
(like IBM VIO or EBUS), I just maintain that structure directly from the
bus code when creating the devices. But for bus types managed by generic
code like PCI or platform (actually, of_platform which is a variation of
platform linked to Open Firmware device-tree), I need this notifier.
- The other two ones have a completely different usage scenario. I have
cases where multiple devices and their drivers depend on each other. For
example, the IBM EMAC network driver needs to attach to a MAL DMA engine
which is a separate device, and a PHY interface which is also a separate
device. They are all of_platform_device's (well, about to be with my
upcoming patches) but there is no say in what precise order the core
will "probe" them and instanciate the various modules. The solution I
found for that is to have the drivers for emac to use multithread_probe,
and wait for a driver to be bound to the target MAL and PHY control
devices (the device-tree contains reference to the MAL and PHY interface
nodes, which I can then match to of_platform_devices). Right now, I've
been polling, but with that notifier, I can more cleanly wait (with a
timeout of course).
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-10-25 03:44:59 +00:00
|
|
|
#include <linux/notifier.h>
|
2007-11-21 16:29:15 +00:00
|
|
|
#include <linux/genhd.h>
|
2008-03-04 23:09:07 +00:00
|
|
|
#include <linux/kallsyms.h>
|
2008-04-19 02:21:05 +00:00
|
|
|
#include <linux/semaphore.h>
|
2008-05-28 16:28:39 +00:00
|
|
|
#include <linux/mutex.h>
|
2009-05-12 20:37:57 +00:00
|
|
|
#include <linux/async.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include "base.h"
|
|
|
|
#include "power/power.h"
|
|
|
|
|
2008-01-25 06:50:12 +00:00
|
|
|
int (*platform_notify)(struct device *dev) = NULL;
|
|
|
|
int (*platform_notify_remove)(struct device *dev) = NULL;
|
2008-04-21 17:51:07 +00:00
|
|
|
static struct kobject *dev_kobj;
|
|
|
|
struct kobject *sysfs_dev_char_kobj;
|
|
|
|
struct kobject *sysfs_dev_block_kobj;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-01-27 20:12:43 +00:00
|
|
|
#ifdef CONFIG_BLOCK
|
|
|
|
static inline int device_is_not_partition(struct device *dev)
|
|
|
|
{
|
|
|
|
return !(dev->type == &part_type);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline int device_is_not_partition(struct device *dev)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-16 21:10:48 +00:00
|
|
|
/**
|
|
|
|
* dev_driver_string - Return a device's driver name, if at all possible
|
|
|
|
* @dev: struct device to get the name of
|
|
|
|
*
|
|
|
|
* Will return the device's driver's name if it is bound to a device. If
|
|
|
|
* the device is not bound to a device, it will return the name of the bus
|
|
|
|
* it is attached to. If it is not attached to a bus either, an empty
|
|
|
|
* string will be returned.
|
|
|
|
*/
|
2008-07-30 19:29:21 +00:00
|
|
|
const char *dev_driver_string(const struct device *dev)
|
2006-06-16 21:10:48 +00:00
|
|
|
{
|
2009-12-04 16:06:57 +00:00
|
|
|
struct device_driver *drv;
|
|
|
|
|
|
|
|
/* dev->driver can change to NULL underneath us because of unbinding,
|
|
|
|
* so be careful about accessing it. dev->bus and dev->class should
|
|
|
|
* never change once they are set, so they don't need special care.
|
|
|
|
*/
|
|
|
|
drv = ACCESS_ONCE(dev->driver);
|
|
|
|
return drv ? drv->name :
|
2007-03-09 15:33:10 +00:00
|
|
|
(dev->bus ? dev->bus->name :
|
|
|
|
(dev->class ? dev->class->name : ""));
|
2006-06-16 21:10:48 +00:00
|
|
|
}
|
2006-09-24 05:35:04 +00:00
|
|
|
EXPORT_SYMBOL(dev_driver_string);
|
2006-06-16 21:10:48 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define to_dev(obj) container_of(obj, struct device, kobj)
|
|
|
|
#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
|
|
|
|
|
2008-01-25 06:50:12 +00:00
|
|
|
static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
|
|
|
|
char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-01-25 06:50:12 +00:00
|
|
|
struct device_attribute *dev_attr = to_dev_attr(attr);
|
|
|
|
struct device *dev = to_dev(kobj);
|
2005-04-29 06:23:47 +00:00
|
|
|
ssize_t ret = -EIO;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (dev_attr->show)
|
2005-05-17 10:39:34 +00:00
|
|
|
ret = dev_attr->show(dev, dev_attr, buf);
|
2008-03-04 23:09:07 +00:00
|
|
|
if (ret >= (ssize_t)PAGE_SIZE) {
|
|
|
|
print_symbol("dev_attr_show: %s returned bad count\n",
|
|
|
|
(unsigned long)dev_attr->show);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-01-25 06:50:12 +00:00
|
|
|
static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-01-25 06:50:12 +00:00
|
|
|
struct device_attribute *dev_attr = to_dev_attr(attr);
|
|
|
|
struct device *dev = to_dev(kobj);
|
2005-04-29 06:23:47 +00:00
|
|
|
ssize_t ret = -EIO;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (dev_attr->store)
|
2005-05-17 10:39:34 +00:00
|
|
|
ret = dev_attr->store(dev, dev_attr, buf, count);
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-01-19 01:58:23 +00:00
|
|
|
static const struct sysfs_ops dev_sysfs_ops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.show = dev_attr_show,
|
|
|
|
.store = dev_attr_store,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* device_release - free device structure.
|
|
|
|
* @kobj: device's kobject.
|
|
|
|
*
|
|
|
|
* This is called once the reference count for the object
|
|
|
|
* reaches 0. We forward the call to the device's release
|
|
|
|
* method, which should handle actually freeing the structure.
|
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
static void device_release(struct kobject *kobj)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-01-25 06:50:12 +00:00
|
|
|
struct device *dev = to_dev(kobj);
|
2008-12-16 20:23:36 +00:00
|
|
|
struct device_private *p = dev->p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (dev->release)
|
|
|
|
dev->release(dev);
|
2006-10-07 19:54:55 +00:00
|
|
|
else if (dev->type && dev->type->release)
|
|
|
|
dev->type->release(dev);
|
2006-06-28 23:19:58 +00:00
|
|
|
else if (dev->class && dev->class->dev_release)
|
|
|
|
dev->class->dev_release(dev);
|
2008-07-26 02:45:39 +00:00
|
|
|
else
|
|
|
|
WARN(1, KERN_ERR "Device '%s' does not have a release() "
|
2008-01-25 06:50:12 +00:00
|
|
|
"function, it is broken and must be fixed.\n",
|
2008-10-30 00:36:48 +00:00
|
|
|
dev_name(dev));
|
2008-12-16 20:23:36 +00:00
|
|
|
kfree(p);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-10-11 16:47:49 +00:00
|
|
|
static struct kobj_type device_ktype = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.release = device_release,
|
|
|
|
.sysfs_ops = &dev_sysfs_ops,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-11-16 08:00:00 +00:00
|
|
|
static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct kobj_type *ktype = get_ktype(kobj);
|
|
|
|
|
2007-10-11 16:47:49 +00:00
|
|
|
if (ktype == &device_ktype) {
|
2005-04-16 22:20:36 +00:00
|
|
|
struct device *dev = to_dev(kobj);
|
|
|
|
if (dev->bus)
|
|
|
|
return 1;
|
2006-06-14 19:14:34 +00:00
|
|
|
if (dev->class)
|
|
|
|
return 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-16 08:00:00 +00:00
|
|
|
static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct device *dev = to_dev(kobj);
|
|
|
|
|
2006-06-14 19:14:34 +00:00
|
|
|
if (dev->bus)
|
|
|
|
return dev->bus->name;
|
|
|
|
if (dev->class)
|
|
|
|
return dev->class->name;
|
|
|
|
return NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-08-14 13:15:12 +00:00
|
|
|
static int dev_uevent(struct kset *kset, struct kobject *kobj,
|
|
|
|
struct kobj_uevent_env *env)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct device *dev = to_dev(kobj);
|
|
|
|
int retval = 0;
|
|
|
|
|
2009-04-30 13:23:42 +00:00
|
|
|
/* add device node properties if present */
|
2006-06-14 19:14:34 +00:00
|
|
|
if (MAJOR(dev->devt)) {
|
2009-04-30 13:23:42 +00:00
|
|
|
const char *tmp;
|
|
|
|
const char *name;
|
2009-09-18 21:01:12 +00:00
|
|
|
mode_t mode = 0;
|
2009-04-30 13:23:42 +00:00
|
|
|
|
2007-08-14 13:15:12 +00:00
|
|
|
add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
|
|
|
|
add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
|
2009-09-18 21:01:12 +00:00
|
|
|
name = device_get_devnode(dev, &mode, &tmp);
|
2009-04-30 13:23:42 +00:00
|
|
|
if (name) {
|
|
|
|
add_uevent_var(env, "DEVNAME=%s", name);
|
|
|
|
kfree(tmp);
|
2009-09-18 21:01:12 +00:00
|
|
|
if (mode)
|
|
|
|
add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
|
2009-04-30 13:23:42 +00:00
|
|
|
}
|
2006-06-14 19:14:34 +00:00
|
|
|
}
|
|
|
|
|
2007-03-12 20:08:57 +00:00
|
|
|
if (dev->type && dev->type->name)
|
2007-08-14 13:15:12 +00:00
|
|
|
add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
|
2007-03-12 20:08:57 +00:00
|
|
|
|
2006-10-07 19:54:55 +00:00
|
|
|
if (dev->driver)
|
2007-08-14 13:15:12 +00:00
|
|
|
add_uevent_var(env, "DRIVER=%s", dev->driver->name);
|
2006-10-07 19:54:55 +00:00
|
|
|
|
2006-09-14 09:23:28 +00:00
|
|
|
#ifdef CONFIG_SYSFS_DEPRECATED
|
2006-10-07 19:54:55 +00:00
|
|
|
if (dev->class) {
|
|
|
|
struct device *parent = dev->parent;
|
|
|
|
|
|
|
|
/* find first bus device in parent chain */
|
|
|
|
while (parent && !parent->bus)
|
|
|
|
parent = parent->parent;
|
|
|
|
if (parent && parent->bus) {
|
|
|
|
const char *path;
|
|
|
|
|
|
|
|
path = kobject_get_path(&parent->kobj, GFP_KERNEL);
|
2007-05-01 11:46:26 +00:00
|
|
|
if (path) {
|
2007-08-14 13:15:12 +00:00
|
|
|
add_uevent_var(env, "PHYSDEVPATH=%s", path);
|
2007-05-01 11:46:26 +00:00
|
|
|
kfree(path);
|
|
|
|
}
|
2006-10-07 19:54:55 +00:00
|
|
|
|
2007-08-14 13:15:12 +00:00
|
|
|
add_uevent_var(env, "PHYSDEVBUS=%s", parent->bus->name);
|
2006-10-07 19:54:55 +00:00
|
|
|
|
|
|
|
if (parent->driver)
|
2007-08-14 13:15:12 +00:00
|
|
|
add_uevent_var(env, "PHYSDEVDRIVER=%s",
|
|
|
|
parent->driver->name);
|
2006-10-07 19:54:55 +00:00
|
|
|
}
|
|
|
|
} else if (dev->bus) {
|
2007-08-14 13:15:12 +00:00
|
|
|
add_uevent_var(env, "PHYSDEVBUS=%s", dev->bus->name);
|
2006-10-07 19:54:55 +00:00
|
|
|
|
|
|
|
if (dev->driver)
|
2008-01-25 06:50:12 +00:00
|
|
|
add_uevent_var(env, "PHYSDEVDRIVER=%s",
|
|
|
|
dev->driver->name);
|
2006-08-13 04:17:09 +00:00
|
|
|
}
|
2006-10-07 19:54:55 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-08-14 13:15:12 +00:00
|
|
|
/* have the bus specific function add its stuff */
|
2005-11-16 08:00:00 +00:00
|
|
|
if (dev->bus && dev->bus->uevent) {
|
2007-08-14 13:15:12 +00:00
|
|
|
retval = dev->bus->uevent(dev, env);
|
2006-10-07 19:54:55 +00:00
|
|
|
if (retval)
|
2007-11-29 07:49:41 +00:00
|
|
|
pr_debug("device: '%s': %s: bus uevent() returned %d\n",
|
2008-10-30 00:36:48 +00:00
|
|
|
dev_name(dev), __func__, retval);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-08-14 13:15:12 +00:00
|
|
|
/* have the class specific function add its stuff */
|
2006-06-28 23:19:58 +00:00
|
|
|
if (dev->class && dev->class->dev_uevent) {
|
2007-08-14 13:15:12 +00:00
|
|
|
retval = dev->class->dev_uevent(dev, env);
|
2006-10-07 19:54:55 +00:00
|
|
|
if (retval)
|
2007-11-29 07:49:41 +00:00
|
|
|
pr_debug("device: '%s': %s: class uevent() "
|
2008-10-30 00:36:48 +00:00
|
|
|
"returned %d\n", dev_name(dev),
|
2008-03-05 00:41:05 +00:00
|
|
|
__func__, retval);
|
2006-10-07 19:54:55 +00:00
|
|
|
}
|
|
|
|
|
2007-08-14 13:15:12 +00:00
|
|
|
/* have the device type specific fuction add its stuff */
|
2006-10-07 19:54:55 +00:00
|
|
|
if (dev->type && dev->type->uevent) {
|
2007-08-14 13:15:12 +00:00
|
|
|
retval = dev->type->uevent(dev, env);
|
2006-10-07 19:54:55 +00:00
|
|
|
if (retval)
|
2007-11-29 07:49:41 +00:00
|
|
|
pr_debug("device: '%s': %s: dev_type uevent() "
|
2008-10-30 00:36:48 +00:00
|
|
|
"returned %d\n", dev_name(dev),
|
2008-03-05 00:41:05 +00:00
|
|
|
__func__, retval);
|
2006-06-28 23:19:58 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2009-12-31 13:52:51 +00:00
|
|
|
static const struct kset_uevent_ops device_uevent_ops = {
|
2005-11-16 08:00:00 +00:00
|
|
|
.filter = dev_uevent_filter,
|
|
|
|
.name = dev_uevent_name,
|
|
|
|
.uevent = dev_uevent,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-04-05 23:40:38 +00:00
|
|
|
static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct kobject *top_kobj;
|
|
|
|
struct kset *kset;
|
2007-08-14 13:15:12 +00:00
|
|
|
struct kobj_uevent_env *env = NULL;
|
2007-04-05 23:40:38 +00:00
|
|
|
int i;
|
|
|
|
size_t count = 0;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
/* search the kset, the device belongs to */
|
|
|
|
top_kobj = &dev->kobj;
|
2007-08-12 18:43:55 +00:00
|
|
|
while (!top_kobj->kset && top_kobj->parent)
|
|
|
|
top_kobj = top_kobj->parent;
|
2007-04-05 23:40:38 +00:00
|
|
|
if (!top_kobj->kset)
|
|
|
|
goto out;
|
2007-08-12 18:43:55 +00:00
|
|
|
|
2007-04-05 23:40:38 +00:00
|
|
|
kset = top_kobj->kset;
|
|
|
|
if (!kset->uevent_ops || !kset->uevent_ops->uevent)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* respect filter */
|
|
|
|
if (kset->uevent_ops && kset->uevent_ops->filter)
|
|
|
|
if (!kset->uevent_ops->filter(kset, &dev->kobj))
|
|
|
|
goto out;
|
|
|
|
|
2007-08-14 13:15:12 +00:00
|
|
|
env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
|
|
|
|
if (!env)
|
2007-05-02 12:14:11 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-04-05 23:40:38 +00:00
|
|
|
/* let the kset specific function add its keys */
|
2007-08-14 13:15:12 +00:00
|
|
|
retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
|
2007-04-05 23:40:38 +00:00
|
|
|
if (retval)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* copy keys to file */
|
2007-08-14 13:15:12 +00:00
|
|
|
for (i = 0; i < env->envp_idx; i++)
|
|
|
|
count += sprintf(&buf[count], "%s\n", env->envp[i]);
|
2007-04-05 23:40:38 +00:00
|
|
|
out:
|
2007-08-14 13:15:12 +00:00
|
|
|
kfree(env);
|
2007-04-05 23:40:38 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2005-10-01 12:49:43 +00:00
|
|
|
static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2007-07-08 20:29:26 +00:00
|
|
|
enum kobject_action action;
|
|
|
|
|
2010-01-14 21:54:37 +00:00
|
|
|
if (kobject_action_type(buf, count, &action) == 0)
|
2007-07-08 20:29:26 +00:00
|
|
|
kobject_uevent(&dev->kobj, action);
|
2010-01-14 21:54:37 +00:00
|
|
|
else
|
|
|
|
dev_err(dev, "uevent: unknown action-string\n");
|
2005-10-01 12:49:43 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2007-06-13 18:45:17 +00:00
|
|
|
static struct device_attribute uevent_attr =
|
|
|
|
__ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent);
|
|
|
|
|
2007-03-10 06:37:34 +00:00
|
|
|
static int device_add_attributes(struct device *dev,
|
|
|
|
struct device_attribute *attrs)
|
2006-06-27 07:06:09 +00:00
|
|
|
{
|
2007-03-10 06:37:34 +00:00
|
|
|
int error = 0;
|
2006-06-27 07:06:09 +00:00
|
|
|
int i;
|
2007-03-10 06:37:34 +00:00
|
|
|
|
|
|
|
if (attrs) {
|
|
|
|
for (i = 0; attr_name(attrs[i]); i++) {
|
|
|
|
error = device_create_file(dev, &attrs[i]);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (error)
|
|
|
|
while (--i >= 0)
|
|
|
|
device_remove_file(dev, &attrs[i]);
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void device_remove_attributes(struct device *dev,
|
|
|
|
struct device_attribute *attrs)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (attrs)
|
|
|
|
for (i = 0; attr_name(attrs[i]); i++)
|
|
|
|
device_remove_file(dev, &attrs[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int device_add_groups(struct device *dev,
|
2009-06-24 17:06:31 +00:00
|
|
|
const struct attribute_group **groups)
|
2007-03-10 06:37:34 +00:00
|
|
|
{
|
2006-06-27 07:06:09 +00:00
|
|
|
int error = 0;
|
2007-03-10 06:37:34 +00:00
|
|
|
int i;
|
2006-06-27 07:06:09 +00:00
|
|
|
|
2007-03-10 06:37:34 +00:00
|
|
|
if (groups) {
|
|
|
|
for (i = 0; groups[i]; i++) {
|
|
|
|
error = sysfs_create_group(&dev->kobj, groups[i]);
|
2006-06-27 07:06:09 +00:00
|
|
|
if (error) {
|
|
|
|
while (--i >= 0)
|
2008-01-25 06:50:12 +00:00
|
|
|
sysfs_remove_group(&dev->kobj,
|
|
|
|
groups[i]);
|
2007-03-10 06:37:34 +00:00
|
|
|
break;
|
2006-06-27 07:06:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-03-10 06:37:34 +00:00
|
|
|
static void device_remove_groups(struct device *dev,
|
2009-06-24 17:06:31 +00:00
|
|
|
const struct attribute_group **groups)
|
2006-06-27 07:06:09 +00:00
|
|
|
{
|
|
|
|
int i;
|
2007-03-10 06:37:34 +00:00
|
|
|
|
|
|
|
if (groups)
|
|
|
|
for (i = 0; groups[i]; i++)
|
|
|
|
sysfs_remove_group(&dev->kobj, groups[i]);
|
2006-06-27 07:06:09 +00:00
|
|
|
}
|
|
|
|
|
2006-06-28 23:19:58 +00:00
|
|
|
static int device_add_attrs(struct device *dev)
|
|
|
|
{
|
|
|
|
struct class *class = dev->class;
|
2006-10-07 19:54:55 +00:00
|
|
|
struct device_type *type = dev->type;
|
2007-03-10 06:37:34 +00:00
|
|
|
int error;
|
2006-06-28 23:19:58 +00:00
|
|
|
|
2007-03-10 06:37:34 +00:00
|
|
|
if (class) {
|
|
|
|
error = device_add_attributes(dev, class->dev_attrs);
|
2006-10-07 19:54:55 +00:00
|
|
|
if (error)
|
2007-03-10 06:37:34 +00:00
|
|
|
return error;
|
2006-06-28 23:19:58 +00:00
|
|
|
}
|
2006-10-07 19:54:55 +00:00
|
|
|
|
2007-03-10 06:37:34 +00:00
|
|
|
if (type) {
|
|
|
|
error = device_add_groups(dev, type->groups);
|
2006-10-07 19:54:55 +00:00
|
|
|
if (error)
|
2007-03-10 06:37:34 +00:00
|
|
|
goto err_remove_class_attrs;
|
2006-10-07 19:54:55 +00:00
|
|
|
}
|
|
|
|
|
2007-03-10 06:37:34 +00:00
|
|
|
error = device_add_groups(dev, dev->groups);
|
|
|
|
if (error)
|
|
|
|
goto err_remove_type_groups;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_remove_type_groups:
|
|
|
|
if (type)
|
|
|
|
device_remove_groups(dev, type->groups);
|
|
|
|
err_remove_class_attrs:
|
|
|
|
if (class)
|
|
|
|
device_remove_attributes(dev, class->dev_attrs);
|
|
|
|
|
2006-06-28 23:19:58 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void device_remove_attrs(struct device *dev)
|
|
|
|
{
|
|
|
|
struct class *class = dev->class;
|
2006-10-07 19:54:55 +00:00
|
|
|
struct device_type *type = dev->type;
|
2006-06-28 23:19:58 +00:00
|
|
|
|
2007-03-10 06:37:34 +00:00
|
|
|
device_remove_groups(dev, dev->groups);
|
2006-10-07 19:54:55 +00:00
|
|
|
|
2007-03-10 06:37:34 +00:00
|
|
|
if (type)
|
|
|
|
device_remove_groups(dev, type->groups);
|
|
|
|
|
|
|
|
if (class)
|
|
|
|
device_remove_attributes(dev, class->dev_attrs);
|
2006-06-28 23:19:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-14 19:14:34 +00:00
|
|
|
static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
return print_dev_t(buf, dev->devt);
|
|
|
|
}
|
|
|
|
|
2007-06-13 18:45:17 +00:00
|
|
|
static struct device_attribute devt_attr =
|
|
|
|
__ATTR(dev, S_IRUGO, show_dev, NULL);
|
|
|
|
|
2007-11-01 15:29:06 +00:00
|
|
|
/* kset to create /sys/devices/ */
|
|
|
|
struct kset *devices_kset;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* device_create_file - create sysfs attribute file for device.
|
|
|
|
* @dev: device.
|
|
|
|
* @attr: device attribute descriptor.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2009-12-18 13:34:19 +00:00
|
|
|
int device_create_file(struct device *dev,
|
|
|
|
const struct device_attribute *attr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int error = 0;
|
2008-01-31 09:39:38 +00:00
|
|
|
if (dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
error = sysfs_create_file(&dev->kobj, &attr->attr);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* device_remove_file - remove sysfs attribute file.
|
|
|
|
* @dev: device.
|
|
|
|
* @attr: device attribute descriptor.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2009-12-18 13:34:19 +00:00
|
|
|
void device_remove_file(struct device *dev,
|
|
|
|
const struct device_attribute *attr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-01-31 09:39:38 +00:00
|
|
|
if (dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
sysfs_remove_file(&dev->kobj, &attr->attr);
|
|
|
|
}
|
|
|
|
|
2006-09-19 16:39:19 +00:00
|
|
|
/**
|
|
|
|
* device_create_bin_file - create sysfs binary attribute file for device.
|
|
|
|
* @dev: device.
|
|
|
|
* @attr: device binary attribute descriptor.
|
|
|
|
*/
|
2009-12-18 13:34:20 +00:00
|
|
|
int device_create_bin_file(struct device *dev,
|
|
|
|
const struct bin_attribute *attr)
|
2006-09-19 16:39:19 +00:00
|
|
|
{
|
|
|
|
int error = -EINVAL;
|
|
|
|
if (dev)
|
|
|
|
error = sysfs_create_bin_file(&dev->kobj, attr);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(device_create_bin_file);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* device_remove_bin_file - remove sysfs binary attribute file
|
|
|
|
* @dev: device.
|
|
|
|
* @attr: device binary attribute descriptor.
|
|
|
|
*/
|
2009-12-18 13:34:20 +00:00
|
|
|
void device_remove_bin_file(struct device *dev,
|
|
|
|
const struct bin_attribute *attr)
|
2006-09-19 16:39:19 +00:00
|
|
|
{
|
|
|
|
if (dev)
|
|
|
|
sysfs_remove_bin_file(&dev->kobj, attr);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(device_remove_bin_file);
|
|
|
|
|
2007-03-15 19:50:34 +00:00
|
|
|
/**
|
2007-04-26 07:12:04 +00:00
|
|
|
* device_schedule_callback_owner - helper to schedule a callback for a device
|
2007-03-15 19:50:34 +00:00
|
|
|
* @dev: device.
|
|
|
|
* @func: callback function to invoke later.
|
2007-04-26 07:12:04 +00:00
|
|
|
* @owner: module owning the callback routine
|
2007-03-15 19:50:34 +00:00
|
|
|
*
|
|
|
|
* Attribute methods must not unregister themselves or their parent device
|
|
|
|
* (which would amount to the same thing). Attempts to do so will deadlock,
|
|
|
|
* since unregistration is mutually exclusive with driver callbacks.
|
|
|
|
*
|
|
|
|
* Instead methods can call this routine, which will attempt to allocate
|
|
|
|
* and schedule a workqueue request to call back @func with @dev as its
|
|
|
|
* argument in the workqueue's process context. @dev will be pinned until
|
|
|
|
* @func returns.
|
|
|
|
*
|
2007-04-26 07:12:04 +00:00
|
|
|
* This routine is usually called via the inline device_schedule_callback(),
|
|
|
|
* which automatically sets @owner to THIS_MODULE.
|
|
|
|
*
|
2007-03-15 19:50:34 +00:00
|
|
|
* Returns 0 if the request was submitted, -ENOMEM if storage could not
|
2007-04-26 07:12:04 +00:00
|
|
|
* be allocated, -ENODEV if a reference to @owner isn't available.
|
2007-03-15 19:50:34 +00:00
|
|
|
*
|
|
|
|
* NOTE: This routine won't work if CONFIG_SYSFS isn't set! It uses an
|
|
|
|
* underlying sysfs routine (since it is intended for use by attribute
|
|
|
|
* methods), and if sysfs isn't available you'll get nothing but -ENOSYS.
|
|
|
|
*/
|
2007-04-26 07:12:04 +00:00
|
|
|
int device_schedule_callback_owner(struct device *dev,
|
|
|
|
void (*func)(struct device *), struct module *owner)
|
2007-03-15 19:50:34 +00:00
|
|
|
{
|
|
|
|
return sysfs_schedule_callback(&dev->kobj,
|
2007-04-26 07:12:04 +00:00
|
|
|
(void (*)(void *)) func, dev, owner);
|
2007-03-15 19:50:34 +00:00
|
|
|
}
|
2007-04-26 07:12:04 +00:00
|
|
|
EXPORT_SYMBOL_GPL(device_schedule_callback_owner);
|
2007-03-15 19:50:34 +00:00
|
|
|
|
2005-09-06 23:56:51 +00:00
|
|
|
static void klist_children_get(struct klist_node *n)
|
|
|
|
{
|
2008-12-16 20:24:56 +00:00
|
|
|
struct device_private *p = to_device_private_parent(n);
|
|
|
|
struct device *dev = p->device;
|
2005-09-06 23:56:51 +00:00
|
|
|
|
|
|
|
get_device(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void klist_children_put(struct klist_node *n)
|
|
|
|
{
|
2008-12-16 20:24:56 +00:00
|
|
|
struct device_private *p = to_device_private_parent(n);
|
|
|
|
struct device *dev = p->device;
|
2005-09-06 23:56:51 +00:00
|
|
|
|
|
|
|
put_device(dev);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* device_initialize - init device structure.
|
|
|
|
* @dev: device.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-09-03 16:26:40 +00:00
|
|
|
* This prepares the device for use by other layers by initializing
|
|
|
|
* its fields.
|
2008-01-25 06:50:12 +00:00
|
|
|
* It is the first half of device_register(), if called by
|
2008-09-03 16:26:40 +00:00
|
|
|
* that function, though it can also be called separately, so one
|
|
|
|
* may use @dev's fields. In particular, get_device()/put_device()
|
|
|
|
* may be used for reference counting of @dev after calling this
|
|
|
|
* function.
|
|
|
|
*
|
|
|
|
* NOTE: Use put_device() to give up your reference instead of freeing
|
|
|
|
* @dev directly once you have called this function.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
void device_initialize(struct device *dev)
|
|
|
|
{
|
2007-11-01 15:29:06 +00:00
|
|
|
dev->kobj.kset = devices_kset;
|
2007-12-18 06:05:35 +00:00
|
|
|
kobject_init(&dev->kobj, &device_ktype);
|
2005-04-16 22:20:36 +00:00
|
|
|
INIT_LIST_HEAD(&dev->dma_pools);
|
2005-03-21 18:41:04 +00:00
|
|
|
init_MUTEX(&dev->sem);
|
devres: device resource management
Implement device resource management, in short, devres. A device
driver can allocate arbirary size of devres data which is associated
with a release function. On driver detach, release function is
invoked on the devres data, then, devres data is freed.
devreses are typed by associated release functions. Some devreses are
better represented by single instance of the type while others need
multiple instances sharing the same release function. Both usages are
supported.
devreses can be grouped using devres group such that a device driver
can easily release acquired resources halfway through initialization
or selectively release resources (e.g. resources for port 1 out of 4
ports).
This patch adds devres core including documentation and the following
managed interfaces.
* alloc/free : devm_kzalloc(), devm_kzfree()
* IO region : devm_request_region(), devm_release_region()
* IRQ : devm_request_irq(), devm_free_irq()
* DMA : dmam_alloc_coherent(), dmam_free_coherent(),
dmam_declare_coherent_memory(), dmam_pool_create(),
dmam_pool_destroy()
* PCI : pcim_enable_device(), pcim_pin_device(), pci_is_managed()
* iomap : devm_ioport_map(), devm_ioport_unmap(), devm_ioremap(),
devm_ioremap_nocache(), devm_iounmap(), pcim_iomap_table(),
pcim_iomap(), pcim_iounmap()
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-01-20 07:00:26 +00:00
|
|
|
spin_lock_init(&dev->devres_lock);
|
|
|
|
INIT_LIST_HEAD(&dev->devres_head);
|
2005-09-13 02:39:34 +00:00
|
|
|
device_init_wakeup(dev, 0);
|
2008-08-07 17:06:12 +00:00
|
|
|
device_pm_init(dev);
|
2006-12-07 04:32:33 +00:00
|
|
|
set_dev_node(dev, -1);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-10-23 23:37:58 +00:00
|
|
|
#ifdef CONFIG_SYSFS_DEPRECATED
|
2007-11-21 16:29:15 +00:00
|
|
|
static struct kobject *get_device_parent(struct device *dev,
|
|
|
|
struct device *parent)
|
2006-10-23 23:37:58 +00:00
|
|
|
{
|
2007-11-21 16:29:15 +00:00
|
|
|
/* class devices without a parent live in /sys/class/<classname>/ */
|
2007-10-07 16:22:21 +00:00
|
|
|
if (dev->class && (!parent || parent->class != dev->class))
|
2008-05-28 16:28:39 +00:00
|
|
|
return &dev->class->p->class_subsys.kobj;
|
2007-11-21 16:29:15 +00:00
|
|
|
/* all other devices keep their parent */
|
2006-10-23 23:37:58 +00:00
|
|
|
else if (parent)
|
2007-01-08 19:16:44 +00:00
|
|
|
return &parent->kobj;
|
2006-10-23 23:37:58 +00:00
|
|
|
|
2007-01-08 19:16:44 +00:00
|
|
|
return NULL;
|
2006-10-23 23:37:58 +00:00
|
|
|
}
|
2007-11-21 16:29:15 +00:00
|
|
|
|
|
|
|
static inline void cleanup_device_parent(struct device *dev) {}
|
2008-01-21 15:09:44 +00:00
|
|
|
static inline void cleanup_glue_dir(struct device *dev,
|
|
|
|
struct kobject *glue_dir) {}
|
2006-10-23 23:37:58 +00:00
|
|
|
#else
|
2007-03-14 02:25:56 +00:00
|
|
|
static struct kobject *virtual_device_parent(struct device *dev)
|
2006-10-23 17:40:54 +00:00
|
|
|
{
|
2007-03-14 02:25:56 +00:00
|
|
|
static struct kobject *virtual_dir = NULL;
|
2006-10-23 17:40:54 +00:00
|
|
|
|
2007-03-14 02:25:56 +00:00
|
|
|
if (!virtual_dir)
|
2007-11-06 06:24:43 +00:00
|
|
|
virtual_dir = kobject_create_and_add("virtual",
|
2007-11-01 15:29:06 +00:00
|
|
|
&devices_kset->kobj);
|
2006-10-23 17:40:54 +00:00
|
|
|
|
2007-03-14 02:25:56 +00:00
|
|
|
return virtual_dir;
|
2006-10-23 17:40:54 +00:00
|
|
|
}
|
|
|
|
|
2007-11-21 16:29:15 +00:00
|
|
|
static struct kobject *get_device_parent(struct device *dev,
|
|
|
|
struct device *parent)
|
2006-10-23 23:37:58 +00:00
|
|
|
{
|
2007-11-06 06:24:43 +00:00
|
|
|
int retval;
|
|
|
|
|
2007-03-14 02:25:56 +00:00
|
|
|
if (dev->class) {
|
2010-02-05 08:57:02 +00:00
|
|
|
static DEFINE_MUTEX(gdp_mutex);
|
2007-03-14 02:25:56 +00:00
|
|
|
struct kobject *kobj = NULL;
|
|
|
|
struct kobject *parent_kobj;
|
|
|
|
struct kobject *k;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have no parent, we live in "virtual".
|
2007-12-19 00:40:42 +00:00
|
|
|
* Class-devices with a non class-device as parent, live
|
|
|
|
* in a "glue" directory to prevent namespace collisions.
|
2007-03-14 02:25:56 +00:00
|
|
|
*/
|
|
|
|
if (parent == NULL)
|
|
|
|
parent_kobj = virtual_device_parent(dev);
|
|
|
|
else if (parent->class)
|
|
|
|
return &parent->kobj;
|
|
|
|
else
|
|
|
|
parent_kobj = &parent->kobj;
|
|
|
|
|
2010-02-05 08:57:02 +00:00
|
|
|
mutex_lock(&gdp_mutex);
|
|
|
|
|
2007-03-14 02:25:56 +00:00
|
|
|
/* find our class-directory at the parent and reference it */
|
2008-01-22 23:17:41 +00:00
|
|
|
spin_lock(&dev->class->p->class_dirs.list_lock);
|
|
|
|
list_for_each_entry(k, &dev->class->p->class_dirs.list, entry)
|
2007-03-14 02:25:56 +00:00
|
|
|
if (k->parent == parent_kobj) {
|
|
|
|
kobj = kobject_get(k);
|
|
|
|
break;
|
|
|
|
}
|
2008-01-22 23:17:41 +00:00
|
|
|
spin_unlock(&dev->class->p->class_dirs.list_lock);
|
2010-02-05 08:57:02 +00:00
|
|
|
if (kobj) {
|
|
|
|
mutex_unlock(&gdp_mutex);
|
2007-03-14 02:25:56 +00:00
|
|
|
return kobj;
|
2010-02-05 08:57:02 +00:00
|
|
|
}
|
2007-03-14 02:25:56 +00:00
|
|
|
|
|
|
|
/* or create a new class-directory at the parent device */
|
2007-11-06 06:24:43 +00:00
|
|
|
k = kobject_create();
|
2010-02-05 08:57:02 +00:00
|
|
|
if (!k) {
|
|
|
|
mutex_unlock(&gdp_mutex);
|
2007-11-06 06:24:43 +00:00
|
|
|
return NULL;
|
2010-02-05 08:57:02 +00:00
|
|
|
}
|
2008-01-22 23:17:41 +00:00
|
|
|
k->kset = &dev->class->p->class_dirs;
|
2007-12-18 06:05:35 +00:00
|
|
|
retval = kobject_add(k, parent_kobj, "%s", dev->class->name);
|
2007-11-06 06:24:43 +00:00
|
|
|
if (retval < 0) {
|
2010-02-05 08:57:02 +00:00
|
|
|
mutex_unlock(&gdp_mutex);
|
2007-11-06 06:24:43 +00:00
|
|
|
kobject_put(k);
|
|
|
|
return NULL;
|
|
|
|
}
|
2007-12-19 00:40:42 +00:00
|
|
|
/* do not emit an uevent for this simple "glue" directory */
|
2010-02-05 08:57:02 +00:00
|
|
|
mutex_unlock(&gdp_mutex);
|
2007-11-06 06:24:43 +00:00
|
|
|
return k;
|
2007-03-14 02:25:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (parent)
|
2007-01-08 19:16:44 +00:00
|
|
|
return &parent->kobj;
|
|
|
|
return NULL;
|
|
|
|
}
|
2007-11-21 16:29:15 +00:00
|
|
|
|
2008-01-21 15:09:44 +00:00
|
|
|
static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
|
2007-11-21 16:29:15 +00:00
|
|
|
{
|
2007-12-19 00:40:42 +00:00
|
|
|
/* see if we live in a "glue" directory */
|
2008-02-27 14:38:23 +00:00
|
|
|
if (!glue_dir || !dev->class ||
|
2008-01-22 23:17:41 +00:00
|
|
|
glue_dir->kset != &dev->class->p->class_dirs)
|
2007-11-21 16:29:15 +00:00
|
|
|
return;
|
|
|
|
|
2007-12-19 00:40:42 +00:00
|
|
|
kobject_put(glue_dir);
|
2007-11-21 16:29:15 +00:00
|
|
|
}
|
2008-01-21 15:09:44 +00:00
|
|
|
|
|
|
|
static void cleanup_device_parent(struct device *dev)
|
|
|
|
{
|
|
|
|
cleanup_glue_dir(dev, dev->kobj.parent);
|
|
|
|
}
|
2007-01-08 19:16:44 +00:00
|
|
|
#endif
|
2007-03-14 02:25:56 +00:00
|
|
|
|
2008-01-21 15:09:44 +00:00
|
|
|
static void setup_parent(struct device *dev, struct device *parent)
|
2007-01-08 19:16:44 +00:00
|
|
|
{
|
|
|
|
struct kobject *kobj;
|
|
|
|
kobj = get_device_parent(dev, parent);
|
|
|
|
if (kobj)
|
|
|
|
dev->kobj.parent = kobj;
|
2006-10-23 23:37:58 +00:00
|
|
|
}
|
|
|
|
|
2007-07-18 08:43:47 +00:00
|
|
|
static int device_add_class_symlinks(struct device *dev)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!dev->class)
|
|
|
|
return 0;
|
2007-11-21 16:29:15 +00:00
|
|
|
|
2008-05-28 16:28:39 +00:00
|
|
|
error = sysfs_create_link(&dev->kobj,
|
|
|
|
&dev->class->p->class_subsys.kobj,
|
2007-07-18 08:43:47 +00:00
|
|
|
"subsystem");
|
|
|
|
if (error)
|
|
|
|
goto out;
|
2007-11-21 16:29:15 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_SYSFS_DEPRECATED
|
|
|
|
/* stacked class devices need a symlink in the class directory */
|
2008-05-28 16:28:39 +00:00
|
|
|
if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
|
2008-01-27 20:12:43 +00:00
|
|
|
device_is_not_partition(dev)) {
|
2008-05-28 16:28:39 +00:00
|
|
|
error = sysfs_create_link(&dev->class->p->class_subsys.kobj,
|
2008-10-30 00:36:48 +00:00
|
|
|
&dev->kobj, dev_name(dev));
|
2007-07-18 08:43:47 +00:00
|
|
|
if (error)
|
|
|
|
goto out_subsys;
|
|
|
|
}
|
2007-11-21 16:29:15 +00:00
|
|
|
|
2008-01-27 20:12:43 +00:00
|
|
|
if (dev->parent && device_is_not_partition(dev)) {
|
2007-11-21 16:29:15 +00:00
|
|
|
struct device *parent = dev->parent;
|
|
|
|
char *class_name;
|
2007-09-19 05:46:50 +00:00
|
|
|
|
2007-11-21 16:29:15 +00:00
|
|
|
/*
|
|
|
|
* stacked class devices have the 'device' link
|
|
|
|
* pointing to the bus device instead of the parent
|
|
|
|
*/
|
|
|
|
while (parent->class && !parent->bus && parent->parent)
|
|
|
|
parent = parent->parent;
|
|
|
|
|
|
|
|
error = sysfs_create_link(&dev->kobj,
|
|
|
|
&parent->kobj,
|
2007-09-19 05:46:50 +00:00
|
|
|
"device");
|
|
|
|
if (error)
|
|
|
|
goto out_busid;
|
2007-11-21 16:29:15 +00:00
|
|
|
|
|
|
|
class_name = make_class_name(dev->class->name,
|
|
|
|
&dev->kobj);
|
|
|
|
if (class_name)
|
|
|
|
error = sysfs_create_link(&dev->parent->kobj,
|
|
|
|
&dev->kobj, class_name);
|
|
|
|
kfree(class_name);
|
|
|
|
if (error)
|
|
|
|
goto out_device;
|
2007-07-18 08:43:47 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_device:
|
2008-01-27 20:12:43 +00:00
|
|
|
if (dev->parent && device_is_not_partition(dev))
|
2007-07-18 08:43:47 +00:00
|
|
|
sysfs_remove_link(&dev->kobj, "device");
|
|
|
|
out_busid:
|
2008-05-28 16:28:39 +00:00
|
|
|
if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
|
2008-01-27 20:12:43 +00:00
|
|
|
device_is_not_partition(dev))
|
2008-05-28 16:28:39 +00:00
|
|
|
sysfs_remove_link(&dev->class->p->class_subsys.kobj,
|
2008-10-30 00:36:48 +00:00
|
|
|
dev_name(dev));
|
2007-11-21 16:29:15 +00:00
|
|
|
#else
|
|
|
|
/* link in the class directory pointing to the device */
|
2008-05-28 16:28:39 +00:00
|
|
|
error = sysfs_create_link(&dev->class->p->class_subsys.kobj,
|
2008-10-30 00:36:48 +00:00
|
|
|
&dev->kobj, dev_name(dev));
|
2007-11-21 16:29:15 +00:00
|
|
|
if (error)
|
|
|
|
goto out_subsys;
|
|
|
|
|
2008-01-27 20:12:43 +00:00
|
|
|
if (dev->parent && device_is_not_partition(dev)) {
|
2007-11-21 16:29:15 +00:00
|
|
|
error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
|
|
|
|
"device");
|
|
|
|
if (error)
|
|
|
|
goto out_busid;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_busid:
|
2008-10-30 00:36:48 +00:00
|
|
|
sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));
|
2007-11-21 16:29:15 +00:00
|
|
|
#endif
|
|
|
|
|
2007-07-18 08:43:47 +00:00
|
|
|
out_subsys:
|
|
|
|
sysfs_remove_link(&dev->kobj, "subsystem");
|
|
|
|
out:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void device_remove_class_symlinks(struct device *dev)
|
|
|
|
{
|
|
|
|
if (!dev->class)
|
|
|
|
return;
|
2007-11-21 16:29:15 +00:00
|
|
|
|
2007-07-18 08:43:47 +00:00
|
|
|
#ifdef CONFIG_SYSFS_DEPRECATED
|
2008-01-27 20:12:43 +00:00
|
|
|
if (dev->parent && device_is_not_partition(dev)) {
|
2007-07-18 08:43:47 +00:00
|
|
|
char *class_name;
|
|
|
|
|
|
|
|
class_name = make_class_name(dev->class->name, &dev->kobj);
|
|
|
|
if (class_name) {
|
|
|
|
sysfs_remove_link(&dev->parent->kobj, class_name);
|
|
|
|
kfree(class_name);
|
|
|
|
}
|
|
|
|
sysfs_remove_link(&dev->kobj, "device");
|
|
|
|
}
|
2007-11-21 16:29:15 +00:00
|
|
|
|
2008-05-28 16:28:39 +00:00
|
|
|
if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
|
2008-01-27 20:12:43 +00:00
|
|
|
device_is_not_partition(dev))
|
2008-05-28 16:28:39 +00:00
|
|
|
sysfs_remove_link(&dev->class->p->class_subsys.kobj,
|
2008-10-30 00:36:48 +00:00
|
|
|
dev_name(dev));
|
2007-11-21 16:29:15 +00:00
|
|
|
#else
|
2008-01-27 20:12:43 +00:00
|
|
|
if (dev->parent && device_is_not_partition(dev))
|
2007-11-21 16:29:15 +00:00
|
|
|
sysfs_remove_link(&dev->kobj, "device");
|
|
|
|
|
2008-10-30 00:36:48 +00:00
|
|
|
sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));
|
2007-11-21 16:29:15 +00:00
|
|
|
#endif
|
|
|
|
|
2007-07-18 08:43:47 +00:00
|
|
|
sysfs_remove_link(&dev->kobj, "subsystem");
|
|
|
|
}
|
|
|
|
|
2008-05-30 00:16:40 +00:00
|
|
|
/**
|
|
|
|
* dev_set_name - set a device name
|
|
|
|
* @dev: device
|
2008-06-05 04:40:43 +00:00
|
|
|
* @fmt: format string for the device's name
|
2008-05-30 00:16:40 +00:00
|
|
|
*/
|
|
|
|
int dev_set_name(struct device *dev, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list vargs;
|
2009-01-25 14:17:37 +00:00
|
|
|
int err;
|
2008-05-30 00:16:40 +00:00
|
|
|
|
|
|
|
va_start(vargs, fmt);
|
2009-01-25 14:17:37 +00:00
|
|
|
err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
|
2008-05-30 00:16:40 +00:00
|
|
|
va_end(vargs);
|
2009-01-25 14:17:37 +00:00
|
|
|
return err;
|
2008-05-30 00:16:40 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dev_set_name);
|
|
|
|
|
2008-04-21 17:51:07 +00:00
|
|
|
/**
|
|
|
|
* device_to_dev_kobj - select a /sys/dev/ directory for the device
|
|
|
|
* @dev: device
|
|
|
|
*
|
|
|
|
* By default we select char/ for new entries. Setting class->dev_obj
|
|
|
|
* to NULL prevents an entry from being created. class->dev_kobj must
|
|
|
|
* be set (or cleared) before any devices are registered to the class
|
|
|
|
* otherwise device_create_sys_dev_entry() and
|
|
|
|
* device_remove_sys_dev_entry() will disagree about the the presence
|
|
|
|
* of the link.
|
|
|
|
*/
|
|
|
|
static struct kobject *device_to_dev_kobj(struct device *dev)
|
|
|
|
{
|
|
|
|
struct kobject *kobj;
|
|
|
|
|
|
|
|
if (dev->class)
|
|
|
|
kobj = dev->class->dev_kobj;
|
|
|
|
else
|
|
|
|
kobj = sysfs_dev_char_kobj;
|
|
|
|
|
|
|
|
return kobj;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int device_create_sys_dev_entry(struct device *dev)
|
|
|
|
{
|
|
|
|
struct kobject *kobj = device_to_dev_kobj(dev);
|
|
|
|
int error = 0;
|
|
|
|
char devt_str[15];
|
|
|
|
|
|
|
|
if (kobj) {
|
|
|
|
format_dev_t(devt_str, dev->devt);
|
|
|
|
error = sysfs_create_link(kobj, &dev->kobj, devt_str);
|
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void device_remove_sys_dev_entry(struct device *dev)
|
|
|
|
{
|
|
|
|
struct kobject *kobj = device_to_dev_kobj(dev);
|
|
|
|
char devt_str[15];
|
|
|
|
|
|
|
|
if (kobj) {
|
|
|
|
format_dev_t(devt_str, dev->devt);
|
|
|
|
sysfs_remove_link(kobj, devt_str);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-11 21:16:57 +00:00
|
|
|
int device_private_init(struct device *dev)
|
|
|
|
{
|
|
|
|
dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
|
|
|
|
if (!dev->p)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->p->device = dev;
|
|
|
|
klist_init(&dev->p->klist_children, klist_children_get,
|
|
|
|
klist_children_put);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* device_add - add device to device hierarchy.
|
|
|
|
* @dev: device.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* This is part 2 of device_register(), though may be called
|
|
|
|
* separately _iff_ device_initialize() has been called separately.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-09-03 16:26:40 +00:00
|
|
|
* This adds @dev to the kobject hierarchy via kobject_add(), adds it
|
2008-01-25 06:50:12 +00:00
|
|
|
* to the global and sibling lists for the device, then
|
|
|
|
* adds it to the other relevant subsystems of the driver model.
|
2008-09-03 16:26:40 +00:00
|
|
|
*
|
|
|
|
* NOTE: _Never_ directly free @dev after calling this function, even
|
|
|
|
* if it returned an error! Always use put_device() to give up your
|
|
|
|
* reference instead.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
int device_add(struct device *dev)
|
|
|
|
{
|
|
|
|
struct device *parent = NULL;
|
2006-09-13 13:34:05 +00:00
|
|
|
struct class_interface *class_intf;
|
2008-05-30 17:45:12 +00:00
|
|
|
int error = -EINVAL;
|
2008-01-12 19:40:46 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
dev = get_device(dev);
|
2008-05-30 17:45:12 +00:00
|
|
|
if (!dev)
|
|
|
|
goto done;
|
|
|
|
|
2008-12-16 20:23:36 +00:00
|
|
|
if (!dev->p) {
|
2009-05-11 21:16:57 +00:00
|
|
|
error = device_private_init(dev);
|
|
|
|
if (error)
|
|
|
|
goto done;
|
2008-12-16 20:23:36 +00:00
|
|
|
}
|
|
|
|
|
2009-01-25 14:17:37 +00:00
|
|
|
/*
|
|
|
|
* for statically allocated devices, which should all be converted
|
|
|
|
* some day, we need to initialize the name. We prevent reading back
|
|
|
|
* the name, and force the use of dev_name()
|
|
|
|
*/
|
|
|
|
if (dev->init_name) {
|
2009-06-02 22:39:55 +00:00
|
|
|
dev_set_name(dev, "%s", dev->init_name);
|
2009-01-25 14:17:37 +00:00
|
|
|
dev->init_name = NULL;
|
|
|
|
}
|
2008-05-30 17:45:12 +00:00
|
|
|
|
2009-12-10 19:32:49 +00:00
|
|
|
if (!dev_name(dev)) {
|
|
|
|
error = -EINVAL;
|
2009-05-28 21:24:07 +00:00
|
|
|
goto name_error;
|
2009-12-10 19:32:49 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-10-30 00:36:48 +00:00
|
|
|
pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
|
2006-08-08 05:19:37 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
parent = get_device(dev->parent);
|
2008-01-21 15:09:44 +00:00
|
|
|
setup_parent(dev, parent);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-19 11:20:41 +00:00
|
|
|
/* use parent numa_node */
|
|
|
|
if (parent)
|
|
|
|
set_dev_node(dev, dev_to_node(parent));
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* first, register with generic layer. */
|
2009-04-18 22:05:45 +00:00
|
|
|
/* we require the name to be set before, and pass NULL */
|
|
|
|
error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
|
2006-10-23 23:37:58 +00:00
|
|
|
if (error)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto Error;
|
2005-10-01 12:49:43 +00:00
|
|
|
|
2006-08-15 05:43:19 +00:00
|
|
|
/* notify platform of device entry */
|
|
|
|
if (platform_notify)
|
|
|
|
platform_notify(dev);
|
|
|
|
|
2007-06-13 18:45:17 +00:00
|
|
|
error = device_create_file(dev, &uevent_attr);
|
2006-09-22 09:37:13 +00:00
|
|
|
if (error)
|
|
|
|
goto attrError;
|
2005-10-01 12:49:43 +00:00
|
|
|
|
2006-06-14 19:14:34 +00:00
|
|
|
if (MAJOR(dev->devt)) {
|
2007-06-13 18:45:17 +00:00
|
|
|
error = device_create_file(dev, &devt_attr);
|
|
|
|
if (error)
|
2006-09-22 09:37:13 +00:00
|
|
|
goto ueventattrError;
|
2008-04-21 17:51:07 +00:00
|
|
|
|
|
|
|
error = device_create_sys_dev_entry(dev);
|
|
|
|
if (error)
|
|
|
|
goto devtattrError;
|
Driver Core: devtmpfs - kernel-maintained tmpfs-based /dev
Devtmpfs lets the kernel create a tmpfs instance called devtmpfs
very early at kernel initialization, before any driver-core device
is registered. Every device with a major/minor will provide a
device node in devtmpfs.
Devtmpfs can be changed and altered by userspace at any time,
and in any way needed - just like today's udev-mounted tmpfs.
Unmodified udev versions will run just fine on top of it, and will
recognize an already existing kernel-created device node and use it.
The default node permissions are root:root 0600. Proper permissions
and user/group ownership, meaningful symlinks, all other policy still
needs to be applied by userspace.
If a node is created by devtmps, devtmpfs will remove the device node
when the device goes away. If the device node was created by
userspace, or the devtmpfs created node was replaced by userspace, it
will no longer be removed by devtmpfs.
If it is requested to auto-mount it, it makes init=/bin/sh work
without any further userspace support. /dev will be fully populated
and dynamic, and always reflect the current device state of the kernel.
With the commonly used dynamic device numbers, it solves the problem
where static devices nodes may point to the wrong devices.
It is intended to make the initial bootup logic simpler and more robust,
by de-coupling the creation of the inital environment, to reliably run
userspace processes, from a complex userspace bootstrap logic to provide
a working /dev.
Signed-off-by: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Jan Blunck <jblunck@suse.de>
Tested-By: Harald Hoyer <harald@redhat.com>
Tested-By: Scott James Remnant <scott@ubuntu.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-04-30 13:23:42 +00:00
|
|
|
|
|
|
|
devtmpfs_create_node(dev);
|
2006-06-14 19:14:34 +00:00
|
|
|
}
|
|
|
|
|
2007-07-18 08:43:47 +00:00
|
|
|
error = device_add_class_symlinks(dev);
|
|
|
|
if (error)
|
|
|
|
goto SymlinkError;
|
2007-07-09 18:39:18 +00:00
|
|
|
error = device_add_attrs(dev);
|
|
|
|
if (error)
|
2006-06-28 23:19:58 +00:00
|
|
|
goto AttrsError;
|
2007-07-09 18:39:18 +00:00
|
|
|
error = bus_add_device(dev);
|
|
|
|
if (error)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto BusError;
|
2008-08-07 17:06:12 +00:00
|
|
|
error = dpm_sysfs_add(dev);
|
2008-03-11 23:59:38 +00:00
|
|
|
if (error)
|
2008-08-07 17:06:12 +00:00
|
|
|
goto DPMError;
|
|
|
|
device_pm_add(dev);
|
2008-12-05 19:10:31 +00:00
|
|
|
|
|
|
|
/* Notify clients of device addition. This call must come
|
|
|
|
* after dpm_sysf_add() and before kobject_uevent().
|
|
|
|
*/
|
|
|
|
if (dev->bus)
|
|
|
|
blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
|
|
|
|
BUS_NOTIFY_ADD_DEVICE, dev);
|
|
|
|
|
2007-03-29 09:12:11 +00:00
|
|
|
kobject_uevent(&dev->kobj, KOBJ_ADD);
|
2009-07-30 19:27:18 +00:00
|
|
|
bus_probe_device(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (parent)
|
2008-12-16 20:24:56 +00:00
|
|
|
klist_add_tail(&dev->p->knode_parent,
|
|
|
|
&parent->p->klist_children);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-23 00:17:32 +00:00
|
|
|
if (dev->class) {
|
2008-05-28 16:28:39 +00:00
|
|
|
mutex_lock(&dev->class->p->class_mutex);
|
2006-09-13 13:34:05 +00:00
|
|
|
/* tie the class to the device */
|
2008-08-25 17:50:19 +00:00
|
|
|
klist_add_tail(&dev->knode_class,
|
|
|
|
&dev->class->p->class_devices);
|
2006-09-13 13:34:05 +00:00
|
|
|
|
|
|
|
/* notify any interfaces that the device is here */
|
2008-05-28 16:28:39 +00:00
|
|
|
list_for_each_entry(class_intf,
|
|
|
|
&dev->class->p->class_interfaces, node)
|
2006-09-13 13:34:05 +00:00
|
|
|
if (class_intf->add_dev)
|
|
|
|
class_intf->add_dev(dev, class_intf);
|
2008-05-28 16:28:39 +00:00
|
|
|
mutex_unlock(&dev->class->p->class_mutex);
|
2006-06-23 00:17:32 +00:00
|
|
|
}
|
2008-05-30 17:45:12 +00:00
|
|
|
done:
|
2005-04-16 22:20:36 +00:00
|
|
|
put_device(dev);
|
|
|
|
return error;
|
2008-08-07 17:06:12 +00:00
|
|
|
DPMError:
|
2008-03-11 23:59:38 +00:00
|
|
|
bus_remove_device(dev);
|
|
|
|
BusError:
|
2007-02-21 17:44:51 +00:00
|
|
|
device_remove_attrs(dev);
|
2006-06-28 23:19:58 +00:00
|
|
|
AttrsError:
|
2007-07-18 08:43:47 +00:00
|
|
|
device_remove_class_symlinks(dev);
|
|
|
|
SymlinkError:
|
2009-10-28 18:51:37 +00:00
|
|
|
if (MAJOR(dev->devt))
|
|
|
|
devtmpfs_delete_node(dev);
|
2008-04-21 17:51:07 +00:00
|
|
|
if (MAJOR(dev->devt))
|
|
|
|
device_remove_sys_dev_entry(dev);
|
|
|
|
devtattrError:
|
2007-06-13 18:45:17 +00:00
|
|
|
if (MAJOR(dev->devt))
|
|
|
|
device_remove_file(dev, &devt_attr);
|
2006-09-22 09:37:13 +00:00
|
|
|
ueventattrError:
|
2007-06-13 18:45:17 +00:00
|
|
|
device_remove_file(dev, &uevent_attr);
|
2006-06-14 19:14:34 +00:00
|
|
|
attrError:
|
2005-11-16 08:00:00 +00:00
|
|
|
kobject_uevent(&dev->kobj, KOBJ_REMOVE);
|
2005-04-16 22:20:36 +00:00
|
|
|
kobject_del(&dev->kobj);
|
|
|
|
Error:
|
2008-01-21 15:09:44 +00:00
|
|
|
cleanup_device_parent(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (parent)
|
|
|
|
put_device(parent);
|
2009-05-28 21:24:07 +00:00
|
|
|
name_error:
|
|
|
|
kfree(dev->p);
|
|
|
|
dev->p = NULL;
|
2008-05-30 17:45:12 +00:00
|
|
|
goto done;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* device_register - register a device with the system.
|
|
|
|
* @dev: pointer to the device structure
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* This happens in two clean steps - initialize the device
|
|
|
|
* and add it to the system. The two steps can be called
|
|
|
|
* separately, but this is the easiest and most common.
|
|
|
|
* I.e. you should only call the two helpers separately if
|
|
|
|
* have a clearly defined need to use and refcount the device
|
|
|
|
* before it is added to the hierarchy.
|
2008-09-03 16:26:40 +00:00
|
|
|
*
|
|
|
|
* NOTE: _Never_ directly free @dev after calling this function, even
|
|
|
|
* if it returned an error! Always use put_device() to give up the
|
|
|
|
* reference initialized in this function instead.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
int device_register(struct device *dev)
|
|
|
|
{
|
|
|
|
device_initialize(dev);
|
|
|
|
return device_add(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* get_device - increment reference count for device.
|
|
|
|
* @dev: device.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* This simply forwards the call to kobject_get(), though
|
|
|
|
* we do take care to provide for the case that we get a NULL
|
|
|
|
* pointer passed in.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
struct device *get_device(struct device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* put_device - decrement reference count.
|
|
|
|
* @dev: device in question.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
void put_device(struct device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-05-21 20:08:01 +00:00
|
|
|
/* might_sleep(); */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (dev)
|
|
|
|
kobject_put(&dev->kobj);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* device_del - delete device from system.
|
|
|
|
* @dev: device.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* This is the first part of the device unregistration
|
|
|
|
* sequence. This removes the device from the lists we control
|
|
|
|
* from here, has it removed from the other driver model
|
|
|
|
* subsystems it was added to in device_add(), and removes it
|
|
|
|
* from the kobject hierarchy.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* NOTE: this should be called manually _iff_ device_add() was
|
|
|
|
* also called manually.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
void device_del(struct device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-01-25 06:50:12 +00:00
|
|
|
struct device *parent = dev->parent;
|
2006-09-13 13:34:05 +00:00
|
|
|
struct class_interface *class_intf;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-05 19:10:31 +00:00
|
|
|
/* Notify clients of device removal. This call must come
|
|
|
|
* before dpm_sysfs_remove().
|
|
|
|
*/
|
|
|
|
if (dev->bus)
|
|
|
|
blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
|
|
|
|
BUS_NOTIFY_DEL_DEVICE, dev);
|
2008-01-12 19:40:46 +00:00
|
|
|
device_pm_remove(dev);
|
2008-08-07 17:06:12 +00:00
|
|
|
dpm_sysfs_remove(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (parent)
|
2008-12-16 20:24:56 +00:00
|
|
|
klist_del(&dev->p->knode_parent);
|
2008-04-21 17:51:07 +00:00
|
|
|
if (MAJOR(dev->devt)) {
|
Driver Core: devtmpfs - kernel-maintained tmpfs-based /dev
Devtmpfs lets the kernel create a tmpfs instance called devtmpfs
very early at kernel initialization, before any driver-core device
is registered. Every device with a major/minor will provide a
device node in devtmpfs.
Devtmpfs can be changed and altered by userspace at any time,
and in any way needed - just like today's udev-mounted tmpfs.
Unmodified udev versions will run just fine on top of it, and will
recognize an already existing kernel-created device node and use it.
The default node permissions are root:root 0600. Proper permissions
and user/group ownership, meaningful symlinks, all other policy still
needs to be applied by userspace.
If a node is created by devtmps, devtmpfs will remove the device node
when the device goes away. If the device node was created by
userspace, or the devtmpfs created node was replaced by userspace, it
will no longer be removed by devtmpfs.
If it is requested to auto-mount it, it makes init=/bin/sh work
without any further userspace support. /dev will be fully populated
and dynamic, and always reflect the current device state of the kernel.
With the commonly used dynamic device numbers, it solves the problem
where static devices nodes may point to the wrong devices.
It is intended to make the initial bootup logic simpler and more robust,
by de-coupling the creation of the inital environment, to reliably run
userspace processes, from a complex userspace bootstrap logic to provide
a working /dev.
Signed-off-by: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Jan Blunck <jblunck@suse.de>
Tested-By: Harald Hoyer <harald@redhat.com>
Tested-By: Scott James Remnant <scott@ubuntu.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-04-30 13:23:42 +00:00
|
|
|
devtmpfs_delete_node(dev);
|
2008-04-21 17:51:07 +00:00
|
|
|
device_remove_sys_dev_entry(dev);
|
2007-06-13 18:45:17 +00:00
|
|
|
device_remove_file(dev, &devt_attr);
|
2008-04-21 17:51:07 +00:00
|
|
|
}
|
2006-06-15 13:31:56 +00:00
|
|
|
if (dev->class) {
|
2007-11-21 16:29:15 +00:00
|
|
|
device_remove_class_symlinks(dev);
|
2006-09-14 09:23:28 +00:00
|
|
|
|
2008-05-28 16:28:39 +00:00
|
|
|
mutex_lock(&dev->class->p->class_mutex);
|
2006-09-13 13:34:05 +00:00
|
|
|
/* notify any interfaces that the device is now gone */
|
2008-05-28 16:28:39 +00:00
|
|
|
list_for_each_entry(class_intf,
|
|
|
|
&dev->class->p->class_interfaces, node)
|
2006-09-13 13:34:05 +00:00
|
|
|
if (class_intf->remove_dev)
|
|
|
|
class_intf->remove_dev(dev, class_intf);
|
|
|
|
/* remove the device from the class list */
|
2008-08-25 17:50:19 +00:00
|
|
|
klist_del(&dev->knode_class);
|
2008-05-28 16:28:39 +00:00
|
|
|
mutex_unlock(&dev->class->p->class_mutex);
|
2006-06-15 13:31:56 +00:00
|
|
|
}
|
2007-06-13 18:45:17 +00:00
|
|
|
device_remove_file(dev, &uevent_attr);
|
2006-06-28 23:19:58 +00:00
|
|
|
device_remove_attrs(dev);
|
2006-11-09 03:46:14 +00:00
|
|
|
bus_remove_device(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-03-09 10:34:19 +00:00
|
|
|
/*
|
|
|
|
* Some platform devices are driven without driver attached
|
|
|
|
* and managed resources may have been acquired. Make sure
|
|
|
|
* all resources are released.
|
|
|
|
*/
|
|
|
|
devres_release_all(dev);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Notify the platform of the removal, in case they
|
|
|
|
* need to do anything...
|
|
|
|
*/
|
|
|
|
if (platform_notify_remove)
|
|
|
|
platform_notify_remove(dev);
|
2005-11-16 08:00:00 +00:00
|
|
|
kobject_uevent(&dev->kobj, KOBJ_REMOVE);
|
2007-11-21 16:29:15 +00:00
|
|
|
cleanup_device_parent(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
kobject_del(&dev->kobj);
|
2007-11-21 16:29:15 +00:00
|
|
|
put_device(parent);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* device_unregister - unregister device from system.
|
|
|
|
* @dev: device going away.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* We do this in two parts, like we do device_register(). First,
|
|
|
|
* we remove it from all the subsystems with device_del(), then
|
|
|
|
* we decrement the reference count via put_device(). If that
|
|
|
|
* is the final reference count, the device will be cleaned up
|
|
|
|
* via device_release() above. Otherwise, the structure will
|
|
|
|
* stick around until the final reference to the device is dropped.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
void device_unregister(struct device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-10-30 00:36:48 +00:00
|
|
|
pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
|
2005-04-16 22:20:36 +00:00
|
|
|
device_del(dev);
|
|
|
|
put_device(dev);
|
|
|
|
}
|
|
|
|
|
2008-01-25 06:50:12 +00:00
|
|
|
static struct device *next_device(struct klist_iter *i)
|
2005-03-25 03:08:30 +00:00
|
|
|
{
|
2008-01-25 06:50:12 +00:00
|
|
|
struct klist_node *n = klist_next(i);
|
2008-12-16 20:24:56 +00:00
|
|
|
struct device *dev = NULL;
|
|
|
|
struct device_private *p;
|
|
|
|
|
|
|
|
if (n) {
|
|
|
|
p = to_device_private_parent(n);
|
|
|
|
dev = p->device;
|
|
|
|
}
|
|
|
|
return dev;
|
2005-03-25 03:08:30 +00:00
|
|
|
}
|
|
|
|
|
2009-04-30 13:23:42 +00:00
|
|
|
/**
|
2009-09-18 21:01:12 +00:00
|
|
|
* device_get_devnode - path of device node file
|
2009-04-30 13:23:42 +00:00
|
|
|
* @dev: device
|
2009-09-18 21:01:12 +00:00
|
|
|
* @mode: returned file access mode
|
2009-04-30 13:23:42 +00:00
|
|
|
* @tmp: possibly allocated string
|
|
|
|
*
|
|
|
|
* Return the relative path of a possible device node.
|
|
|
|
* Non-default names may need to allocate a memory to compose
|
|
|
|
* a name. This memory is returned in tmp and needs to be
|
|
|
|
* freed by the caller.
|
|
|
|
*/
|
2009-09-18 21:01:12 +00:00
|
|
|
const char *device_get_devnode(struct device *dev,
|
|
|
|
mode_t *mode, const char **tmp)
|
2009-04-30 13:23:42 +00:00
|
|
|
{
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
*tmp = NULL;
|
|
|
|
|
|
|
|
/* the device type may provide a specific name */
|
2009-09-18 21:01:12 +00:00
|
|
|
if (dev->type && dev->type->devnode)
|
|
|
|
*tmp = dev->type->devnode(dev, mode);
|
2009-04-30 13:23:42 +00:00
|
|
|
if (*tmp)
|
|
|
|
return *tmp;
|
|
|
|
|
|
|
|
/* the class may provide a specific name */
|
2009-09-18 21:01:12 +00:00
|
|
|
if (dev->class && dev->class->devnode)
|
|
|
|
*tmp = dev->class->devnode(dev, mode);
|
2009-04-30 13:23:42 +00:00
|
|
|
if (*tmp)
|
|
|
|
return *tmp;
|
|
|
|
|
|
|
|
/* return name without allocation, tmp == NULL */
|
|
|
|
if (strchr(dev_name(dev), '!') == NULL)
|
|
|
|
return dev_name(dev);
|
|
|
|
|
|
|
|
/* replace '!' in the name with '/' */
|
|
|
|
*tmp = kstrdup(dev_name(dev), GFP_KERNEL);
|
|
|
|
if (!*tmp)
|
|
|
|
return NULL;
|
|
|
|
while ((s = strchr(*tmp, '!')))
|
|
|
|
s[0] = '/';
|
|
|
|
return *tmp;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2008-01-25 06:50:12 +00:00
|
|
|
* device_for_each_child - device child iterator.
|
|
|
|
* @parent: parent struct device.
|
|
|
|
* @data: data for the callback.
|
|
|
|
* @fn: function to be called for each device.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* Iterate over @parent's child devices, and call @fn for each,
|
|
|
|
* passing it @data.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2008-01-25 06:50:12 +00:00
|
|
|
* We check the return of @fn each time. If it returns anything
|
|
|
|
* other than 0, we break out and return that value.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
int device_for_each_child(struct device *parent, void *data,
|
|
|
|
int (*fn)(struct device *dev, void *data))
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-03-25 03:08:30 +00:00
|
|
|
struct klist_iter i;
|
2008-01-25 06:50:12 +00:00
|
|
|
struct device *child;
|
2005-04-16 22:20:36 +00:00
|
|
|
int error = 0;
|
|
|
|
|
2009-04-15 23:00:12 +00:00
|
|
|
if (!parent->p)
|
|
|
|
return 0;
|
|
|
|
|
2008-12-16 20:24:56 +00:00
|
|
|
klist_iter_init(&parent->p->klist_children, &i);
|
2005-03-25 03:08:30 +00:00
|
|
|
while ((child = next_device(&i)) && !error)
|
|
|
|
error = fn(child, data);
|
|
|
|
klist_iter_exit(&i);
|
2005-04-16 22:20:36 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-11-16 14:42:07 +00:00
|
|
|
/**
|
|
|
|
* device_find_child - device iterator for locating a particular device.
|
|
|
|
* @parent: parent struct device
|
|
|
|
* @data: Data to pass to match function
|
|
|
|
* @match: Callback function to check device
|
|
|
|
*
|
|
|
|
* This is similar to the device_for_each_child() function above, but it
|
|
|
|
* returns a reference to a device that is 'found' for later use, as
|
|
|
|
* determined by the @match callback.
|
|
|
|
*
|
|
|
|
* The callback should return 0 if the device doesn't match and non-zero
|
|
|
|
* if it does. If the callback returns non-zero and a reference to the
|
|
|
|
* current device can be obtained, this function will return to the caller
|
|
|
|
* and not iterate over any more devices.
|
|
|
|
*/
|
2008-01-25 06:50:12 +00:00
|
|
|
struct device *device_find_child(struct device *parent, void *data,
|
|
|
|
int (*match)(struct device *dev, void *data))
|
2006-11-16 14:42:07 +00:00
|
|
|
{
|
|
|
|
struct klist_iter i;
|
|
|
|
struct device *child;
|
|
|
|
|
|
|
|
if (!parent)
|
|
|
|
return NULL;
|
|
|
|
|
2008-12-16 20:24:56 +00:00
|
|
|
klist_iter_init(&parent->p->klist_children, &i);
|
2006-11-16 14:42:07 +00:00
|
|
|
while ((child = next_device(&i)))
|
|
|
|
if (match(child, data) && get_device(child))
|
|
|
|
break;
|
|
|
|
klist_iter_exit(&i);
|
|
|
|
return child;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
int __init devices_init(void)
|
|
|
|
{
|
2007-11-01 15:29:06 +00:00
|
|
|
devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
|
|
|
|
if (!devices_kset)
|
|
|
|
return -ENOMEM;
|
2008-04-21 17:51:07 +00:00
|
|
|
dev_kobj = kobject_create_and_add("dev", NULL);
|
|
|
|
if (!dev_kobj)
|
|
|
|
goto dev_kobj_err;
|
|
|
|
sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
|
|
|
|
if (!sysfs_dev_block_kobj)
|
|
|
|
goto block_kobj_err;
|
|
|
|
sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
|
|
|
|
if (!sysfs_dev_char_kobj)
|
|
|
|
goto char_kobj_err;
|
|
|
|
|
2007-11-01 15:29:06 +00:00
|
|
|
return 0;
|
2008-04-21 17:51:07 +00:00
|
|
|
|
|
|
|
char_kobj_err:
|
|
|
|
kobject_put(sysfs_dev_block_kobj);
|
|
|
|
block_kobj_err:
|
|
|
|
kobject_put(dev_kobj);
|
|
|
|
dev_kobj_err:
|
|
|
|
kset_unregister(devices_kset);
|
|
|
|
return -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(device_for_each_child);
|
2006-11-16 14:42:07 +00:00
|
|
|
EXPORT_SYMBOL_GPL(device_find_child);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(device_initialize);
|
|
|
|
EXPORT_SYMBOL_GPL(device_add);
|
|
|
|
EXPORT_SYMBOL_GPL(device_register);
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(device_del);
|
|
|
|
EXPORT_SYMBOL_GPL(device_unregister);
|
|
|
|
EXPORT_SYMBOL_GPL(get_device);
|
|
|
|
EXPORT_SYMBOL_GPL(put_device);
|
|
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(device_create_file);
|
|
|
|
EXPORT_SYMBOL_GPL(device_remove_file);
|
2006-06-14 19:14:34 +00:00
|
|
|
|
2008-12-15 12:58:26 +00:00
|
|
|
struct root_device
|
|
|
|
{
|
|
|
|
struct device dev;
|
|
|
|
struct module *owner;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define to_root_device(dev) container_of(dev, struct root_device, dev)
|
|
|
|
|
|
|
|
static void root_device_release(struct device *dev)
|
|
|
|
{
|
|
|
|
kfree(to_root_device(dev));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __root_device_register - allocate and register a root device
|
|
|
|
* @name: root device name
|
|
|
|
* @owner: owner module of the root device, usually THIS_MODULE
|
|
|
|
*
|
|
|
|
* This function allocates a root device and registers it
|
|
|
|
* using device_register(). In order to free the returned
|
|
|
|
* device, use root_device_unregister().
|
|
|
|
*
|
|
|
|
* Root devices are dummy devices which allow other devices
|
|
|
|
* to be grouped under /sys/devices. Use this function to
|
|
|
|
* allocate a root device and then use it as the parent of
|
|
|
|
* any device which should appear under /sys/devices/{name}
|
|
|
|
*
|
|
|
|
* The /sys/devices/{name} directory will also contain a
|
|
|
|
* 'module' symlink which points to the @owner directory
|
|
|
|
* in sysfs.
|
|
|
|
*
|
|
|
|
* Note: You probably want to use root_device_register().
|
|
|
|
*/
|
|
|
|
struct device *__root_device_register(const char *name, struct module *owner)
|
|
|
|
{
|
|
|
|
struct root_device *root;
|
|
|
|
int err = -ENOMEM;
|
|
|
|
|
|
|
|
root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
|
|
|
|
if (!root)
|
|
|
|
return ERR_PTR(err);
|
|
|
|
|
2009-06-02 22:39:55 +00:00
|
|
|
err = dev_set_name(&root->dev, "%s", name);
|
2008-12-15 12:58:26 +00:00
|
|
|
if (err) {
|
|
|
|
kfree(root);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
|
|
|
root->dev.release = root_device_release;
|
|
|
|
|
|
|
|
err = device_register(&root->dev);
|
|
|
|
if (err) {
|
|
|
|
put_device(&root->dev);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_MODULE /* gotta find a "cleaner" way to do this */
|
|
|
|
if (owner) {
|
|
|
|
struct module_kobject *mk = &owner->mkobj;
|
|
|
|
|
|
|
|
err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
|
|
|
|
if (err) {
|
|
|
|
device_unregister(&root->dev);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
root->owner = owner;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return &root->dev;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(__root_device_register);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* root_device_unregister - unregister and free a root device
|
2009-01-21 00:29:13 +00:00
|
|
|
* @dev: device going away
|
2008-12-15 12:58:26 +00:00
|
|
|
*
|
|
|
|
* This function unregisters and cleans up a device that was created by
|
|
|
|
* root_device_register().
|
|
|
|
*/
|
|
|
|
void root_device_unregister(struct device *dev)
|
|
|
|
{
|
|
|
|
struct root_device *root = to_root_device(dev);
|
|
|
|
|
|
|
|
if (root->owner)
|
|
|
|
sysfs_remove_link(&root->dev.kobj, "module");
|
|
|
|
|
|
|
|
device_unregister(dev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(root_device_unregister);
|
|
|
|
|
2006-06-14 19:14:34 +00:00
|
|
|
|
|
|
|
static void device_create_release(struct device *dev)
|
|
|
|
{
|
2008-10-30 00:36:48 +00:00
|
|
|
pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
|
2006-06-14 19:14:34 +00:00
|
|
|
kfree(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-05-15 20:44:08 +00:00
|
|
|
* device_create_vargs - creates a device and registers it with sysfs
|
2006-07-04 22:53:19 +00:00
|
|
|
* @class: pointer to the struct class that this device should be registered to
|
|
|
|
* @parent: pointer to the parent struct device of this new device, if any
|
|
|
|
* @devt: the dev_t for the char device to be added
|
2008-05-15 20:44:08 +00:00
|
|
|
* @drvdata: the data to be added to the device for callbacks
|
2006-07-04 22:53:19 +00:00
|
|
|
* @fmt: string for the device's name
|
2008-05-15 20:44:08 +00:00
|
|
|
* @args: va_list for the device's name
|
2006-07-04 22:53:19 +00:00
|
|
|
*
|
|
|
|
* This function can be used by char device classes. A struct device
|
|
|
|
* will be created in sysfs, registered to the specified class.
|
2006-06-14 19:14:34 +00:00
|
|
|
*
|
|
|
|
* A "dev" file will be created, showing the dev_t for the device, if
|
|
|
|
* the dev_t is not 0,0.
|
2006-07-04 22:53:19 +00:00
|
|
|
* If a pointer to a parent struct device is passed in, the newly created
|
|
|
|
* struct device will be a child of that device in sysfs.
|
|
|
|
* The pointer to the struct device will be returned from the call.
|
|
|
|
* Any further sysfs files that might be required can be created using this
|
2006-06-14 19:14:34 +00:00
|
|
|
* pointer.
|
|
|
|
*
|
|
|
|
* Note: the struct class passed to this function must have previously
|
|
|
|
* been created with a call to class_create().
|
|
|
|
*/
|
2008-05-15 20:44:08 +00:00
|
|
|
struct device *device_create_vargs(struct class *class, struct device *parent,
|
|
|
|
dev_t devt, void *drvdata, const char *fmt,
|
|
|
|
va_list args)
|
2006-06-14 19:14:34 +00:00
|
|
|
{
|
|
|
|
struct device *dev = NULL;
|
|
|
|
int retval = -ENODEV;
|
|
|
|
|
|
|
|
if (class == NULL || IS_ERR(class))
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
|
|
|
|
if (!dev) {
|
|
|
|
retval = -ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->devt = devt;
|
|
|
|
dev->class = class;
|
|
|
|
dev->parent = parent;
|
|
|
|
dev->release = device_create_release;
|
2008-05-15 20:44:08 +00:00
|
|
|
dev_set_drvdata(dev, drvdata);
|
2006-06-14 19:14:34 +00:00
|
|
|
|
2009-01-25 14:17:37 +00:00
|
|
|
retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
|
|
|
|
if (retval)
|
|
|
|
goto error;
|
|
|
|
|
2006-06-14 19:14:34 +00:00
|
|
|
retval = device_register(dev);
|
|
|
|
if (retval)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
return dev;
|
|
|
|
|
|
|
|
error:
|
2008-09-03 16:26:41 +00:00
|
|
|
put_device(dev);
|
2006-06-14 19:14:34 +00:00
|
|
|
return ERR_PTR(retval);
|
|
|
|
}
|
2008-05-15 20:44:08 +00:00
|
|
|
EXPORT_SYMBOL_GPL(device_create_vargs);
|
|
|
|
|
|
|
|
/**
|
2008-07-22 03:03:34 +00:00
|
|
|
* device_create - creates a device and registers it with sysfs
|
2008-05-15 20:44:08 +00:00
|
|
|
* @class: pointer to the struct class that this device should be registered to
|
|
|
|
* @parent: pointer to the parent struct device of this new device, if any
|
|
|
|
* @devt: the dev_t for the char device to be added
|
|
|
|
* @drvdata: the data to be added to the device for callbacks
|
|
|
|
* @fmt: string for the device's name
|
|
|
|
*
|
|
|
|
* This function can be used by char device classes. A struct device
|
|
|
|
* will be created in sysfs, registered to the specified class.
|
|
|
|
*
|
|
|
|
* A "dev" file will be created, showing the dev_t for the device, if
|
|
|
|
* the dev_t is not 0,0.
|
|
|
|
* If a pointer to a parent struct device is passed in, the newly created
|
|
|
|
* struct device will be a child of that device in sysfs.
|
|
|
|
* The pointer to the struct device will be returned from the call.
|
|
|
|
* Any further sysfs files that might be required can be created using this
|
|
|
|
* pointer.
|
|
|
|
*
|
|
|
|
* Note: the struct class passed to this function must have previously
|
|
|
|
* been created with a call to class_create().
|
|
|
|
*/
|
2008-07-22 03:03:34 +00:00
|
|
|
struct device *device_create(struct class *class, struct device *parent,
|
|
|
|
dev_t devt, void *drvdata, const char *fmt, ...)
|
2008-05-15 20:44:08 +00:00
|
|
|
{
|
|
|
|
va_list vargs;
|
|
|
|
struct device *dev;
|
|
|
|
|
|
|
|
va_start(vargs, fmt);
|
|
|
|
dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
|
|
|
|
va_end(vargs);
|
|
|
|
return dev;
|
|
|
|
}
|
2008-07-22 03:03:34 +00:00
|
|
|
EXPORT_SYMBOL_GPL(device_create);
|
2008-05-15 20:44:08 +00:00
|
|
|
|
2008-01-28 08:56:11 +00:00
|
|
|
static int __match_devt(struct device *dev, void *data)
|
2006-06-14 19:14:34 +00:00
|
|
|
{
|
2008-01-28 08:56:11 +00:00
|
|
|
dev_t *devt = data;
|
2006-06-14 19:14:34 +00:00
|
|
|
|
2008-01-28 08:56:11 +00:00
|
|
|
return dev->devt == *devt;
|
2008-01-12 19:40:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* device_destroy - removes a device that was created with device_create()
|
|
|
|
* @class: pointer to the struct class that this device was registered with
|
|
|
|
* @devt: the dev_t of the device that was previously registered
|
|
|
|
*
|
|
|
|
* This call unregisters and cleans up a device that was created with a
|
|
|
|
* call to device_create().
|
|
|
|
*/
|
|
|
|
void device_destroy(struct class *class, dev_t devt)
|
|
|
|
{
|
|
|
|
struct device *dev;
|
2006-06-14 19:14:34 +00:00
|
|
|
|
2008-05-22 21:21:08 +00:00
|
|
|
dev = class_find_device(class, NULL, &devt, __match_devt);
|
2008-01-28 08:56:11 +00:00
|
|
|
if (dev) {
|
|
|
|
put_device(dev);
|
2006-06-14 19:14:34 +00:00
|
|
|
device_unregister(dev);
|
2008-01-28 08:56:11 +00:00
|
|
|
}
|
2006-06-14 19:14:34 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(device_destroy);
|
2006-07-03 21:31:12 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* device_rename - renames a device
|
|
|
|
* @dev: the pointer to the struct device to be renamed
|
|
|
|
* @new_name: the new name of the device
|
2008-05-08 21:41:00 +00:00
|
|
|
*
|
|
|
|
* It is the responsibility of the caller to provide mutual
|
|
|
|
* exclusion between two different calls of device_rename
|
|
|
|
* on the same device to ensure that new_name is valid and
|
|
|
|
* won't conflict with other devices.
|
2006-07-03 21:31:12 +00:00
|
|
|
*/
|
|
|
|
int device_rename(struct device *dev, char *new_name)
|
|
|
|
{
|
|
|
|
char *old_class_name = NULL;
|
|
|
|
char *new_class_name = NULL;
|
2007-07-18 08:43:47 +00:00
|
|
|
char *old_device_name = NULL;
|
2006-07-03 21:31:12 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
dev = get_device(dev);
|
|
|
|
if (!dev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-10-30 00:36:48 +00:00
|
|
|
pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev),
|
2008-03-05 00:41:05 +00:00
|
|
|
__func__, new_name);
|
2006-07-03 21:31:12 +00:00
|
|
|
|
2006-09-14 09:23:28 +00:00
|
|
|
#ifdef CONFIG_SYSFS_DEPRECATED
|
2006-07-03 21:31:12 +00:00
|
|
|
if ((dev->class) && (dev->parent))
|
|
|
|
old_class_name = make_class_name(dev->class->name, &dev->kobj);
|
2006-09-14 09:23:28 +00:00
|
|
|
#endif
|
2006-07-03 21:31:12 +00:00
|
|
|
|
2009-01-25 14:17:37 +00:00
|
|
|
old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
|
2007-07-18 08:43:47 +00:00
|
|
|
if (!old_device_name) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto out;
|
2006-07-03 21:31:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
error = kobject_rename(&dev->kobj, new_name);
|
2009-01-25 14:17:37 +00:00
|
|
|
if (error)
|
2007-07-18 08:43:47 +00:00
|
|
|
goto out;
|
2006-07-03 21:31:12 +00:00
|
|
|
|
2006-09-14 09:23:28 +00:00
|
|
|
#ifdef CONFIG_SYSFS_DEPRECATED
|
2006-07-03 21:31:12 +00:00
|
|
|
if (old_class_name) {
|
|
|
|
new_class_name = make_class_name(dev->class->name, &dev->kobj);
|
|
|
|
if (new_class_name) {
|
2010-02-13 03:22:26 +00:00
|
|
|
error = sysfs_rename_link(&dev->parent->kobj,
|
|
|
|
&dev->kobj,
|
|
|
|
old_class_name,
|
|
|
|
new_class_name);
|
2006-07-03 21:31:12 +00:00
|
|
|
}
|
|
|
|
}
|
2007-10-26 18:07:44 +00:00
|
|
|
#else
|
2006-07-03 21:31:12 +00:00
|
|
|
if (dev->class) {
|
2010-02-13 03:22:26 +00:00
|
|
|
error = sysfs_rename_link(&dev->class->p->class_subsys.kobj,
|
|
|
|
&dev->kobj, old_device_name, new_name);
|
2006-07-03 21:31:12 +00:00
|
|
|
}
|
2007-10-26 18:07:44 +00:00
|
|
|
#endif
|
|
|
|
|
2007-07-18 08:43:47 +00:00
|
|
|
out:
|
2006-07-03 21:31:12 +00:00
|
|
|
put_device(dev);
|
|
|
|
|
|
|
|
kfree(new_class_name);
|
2006-09-28 21:56:01 +00:00
|
|
|
kfree(old_class_name);
|
2007-07-18 08:43:47 +00:00
|
|
|
kfree(old_device_name);
|
2006-07-03 21:31:12 +00:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
2007-02-28 11:38:31 +00:00
|
|
|
EXPORT_SYMBOL_GPL(device_rename);
|
2006-11-20 16:07:51 +00:00
|
|
|
|
|
|
|
static int device_move_class_links(struct device *dev,
|
|
|
|
struct device *old_parent,
|
|
|
|
struct device *new_parent)
|
|
|
|
{
|
2007-03-06 20:55:53 +00:00
|
|
|
int error = 0;
|
2006-11-20 16:07:51 +00:00
|
|
|
#ifdef CONFIG_SYSFS_DEPRECATED
|
|
|
|
char *class_name;
|
|
|
|
|
|
|
|
class_name = make_class_name(dev->class->name, &dev->kobj);
|
|
|
|
if (!class_name) {
|
2006-11-27 09:35:05 +00:00
|
|
|
error = -ENOMEM;
|
2006-11-20 16:07:51 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (old_parent) {
|
|
|
|
sysfs_remove_link(&dev->kobj, "device");
|
|
|
|
sysfs_remove_link(&old_parent->kobj, class_name);
|
|
|
|
}
|
2007-01-08 19:16:44 +00:00
|
|
|
if (new_parent) {
|
|
|
|
error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
|
|
|
|
"device");
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
error = sysfs_create_link(&new_parent->kobj, &dev->kobj,
|
|
|
|
class_name);
|
|
|
|
if (error)
|
|
|
|
sysfs_remove_link(&dev->kobj, "device");
|
2008-01-25 06:50:12 +00:00
|
|
|
} else
|
2007-01-08 19:16:44 +00:00
|
|
|
error = 0;
|
2006-11-20 16:07:51 +00:00
|
|
|
out:
|
|
|
|
kfree(class_name);
|
|
|
|
return error;
|
|
|
|
#else
|
2007-03-06 20:55:53 +00:00
|
|
|
if (old_parent)
|
|
|
|
sysfs_remove_link(&dev->kobj, "device");
|
|
|
|
if (new_parent)
|
|
|
|
error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
|
|
|
|
"device");
|
|
|
|
return error;
|
2006-11-20 16:07:51 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* device_move - moves a device to a new parent
|
|
|
|
* @dev: the pointer to the struct device to be moved
|
2007-01-08 19:16:44 +00:00
|
|
|
* @new_parent: the new parent of the device (can by NULL)
|
2009-03-04 11:44:00 +00:00
|
|
|
* @dpm_order: how to reorder the dpm_list
|
2006-11-20 16:07:51 +00:00
|
|
|
*/
|
2009-03-04 11:44:00 +00:00
|
|
|
int device_move(struct device *dev, struct device *new_parent,
|
|
|
|
enum dpm_order dpm_order)
|
2006-11-20 16:07:51 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct device *old_parent;
|
2007-01-08 19:16:44 +00:00
|
|
|
struct kobject *new_parent_kobj;
|
2006-11-20 16:07:51 +00:00
|
|
|
|
|
|
|
dev = get_device(dev);
|
|
|
|
if (!dev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-03-04 11:44:00 +00:00
|
|
|
device_pm_lock();
|
2006-11-20 16:07:51 +00:00
|
|
|
new_parent = get_device(new_parent);
|
2008-01-25 06:50:12 +00:00
|
|
|
new_parent_kobj = get_device_parent(dev, new_parent);
|
2008-01-21 15:09:44 +00:00
|
|
|
|
2008-10-30 00:36:48 +00:00
|
|
|
pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
|
|
|
|
__func__, new_parent ? dev_name(new_parent) : "<NULL>");
|
2007-01-08 19:16:44 +00:00
|
|
|
error = kobject_move(&dev->kobj, new_parent_kobj);
|
2006-11-20 16:07:51 +00:00
|
|
|
if (error) {
|
2008-01-21 15:09:44 +00:00
|
|
|
cleanup_glue_dir(dev, new_parent_kobj);
|
2006-11-20 16:07:51 +00:00
|
|
|
put_device(new_parent);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
old_parent = dev->parent;
|
|
|
|
dev->parent = new_parent;
|
|
|
|
if (old_parent)
|
2008-12-16 20:24:56 +00:00
|
|
|
klist_remove(&dev->p->knode_parent);
|
2008-02-19 11:20:41 +00:00
|
|
|
if (new_parent) {
|
2008-12-16 20:24:56 +00:00
|
|
|
klist_add_tail(&dev->p->knode_parent,
|
|
|
|
&new_parent->p->klist_children);
|
2008-02-19 11:20:41 +00:00
|
|
|
set_dev_node(dev, dev_to_node(new_parent));
|
|
|
|
}
|
|
|
|
|
2006-11-20 16:07:51 +00:00
|
|
|
if (!dev->class)
|
|
|
|
goto out_put;
|
|
|
|
error = device_move_class_links(dev, old_parent, new_parent);
|
|
|
|
if (error) {
|
|
|
|
/* We ignore errors on cleanup since we're hosed anyway... */
|
|
|
|
device_move_class_links(dev, new_parent, old_parent);
|
|
|
|
if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
|
2007-01-08 19:16:44 +00:00
|
|
|
if (new_parent)
|
2008-12-16 20:24:56 +00:00
|
|
|
klist_remove(&dev->p->knode_parent);
|
2008-02-19 11:20:41 +00:00
|
|
|
dev->parent = old_parent;
|
|
|
|
if (old_parent) {
|
2008-12-16 20:24:56 +00:00
|
|
|
klist_add_tail(&dev->p->knode_parent,
|
|
|
|
&old_parent->p->klist_children);
|
2008-02-19 11:20:41 +00:00
|
|
|
set_dev_node(dev, dev_to_node(old_parent));
|
|
|
|
}
|
2006-11-20 16:07:51 +00:00
|
|
|
}
|
2008-01-21 15:09:44 +00:00
|
|
|
cleanup_glue_dir(dev, new_parent_kobj);
|
2006-11-20 16:07:51 +00:00
|
|
|
put_device(new_parent);
|
|
|
|
goto out;
|
|
|
|
}
|
2009-03-04 11:44:00 +00:00
|
|
|
switch (dpm_order) {
|
|
|
|
case DPM_ORDER_NONE:
|
|
|
|
break;
|
|
|
|
case DPM_ORDER_DEV_AFTER_PARENT:
|
|
|
|
device_pm_move_after(dev, new_parent);
|
|
|
|
break;
|
|
|
|
case DPM_ORDER_PARENT_BEFORE_DEV:
|
|
|
|
device_pm_move_before(new_parent, dev);
|
|
|
|
break;
|
|
|
|
case DPM_ORDER_DEV_LAST:
|
|
|
|
device_pm_move_last(dev);
|
|
|
|
break;
|
|
|
|
}
|
2006-11-20 16:07:51 +00:00
|
|
|
out_put:
|
|
|
|
put_device(old_parent);
|
|
|
|
out:
|
2009-03-04 11:44:00 +00:00
|
|
|
device_pm_unlock();
|
2006-11-20 16:07:51 +00:00
|
|
|
put_device(dev);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(device_move);
|
2007-11-27 06:11:55 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* device_shutdown - call ->shutdown() on each device to shutdown.
|
|
|
|
*/
|
|
|
|
void device_shutdown(void)
|
|
|
|
{
|
2008-01-25 06:50:12 +00:00
|
|
|
struct device *dev, *devn;
|
2007-11-27 06:11:55 +00:00
|
|
|
|
|
|
|
list_for_each_entry_safe_reverse(dev, devn, &devices_kset->list,
|
|
|
|
kobj.entry) {
|
|
|
|
if (dev->bus && dev->bus->shutdown) {
|
|
|
|
dev_dbg(dev, "shutdown\n");
|
|
|
|
dev->bus->shutdown(dev);
|
|
|
|
} else if (dev->driver && dev->driver->shutdown) {
|
|
|
|
dev_dbg(dev, "shutdown\n");
|
|
|
|
dev->driver->shutdown(dev);
|
|
|
|
}
|
|
|
|
}
|
2009-05-12 20:37:57 +00:00
|
|
|
async_synchronize_full();
|
2007-11-27 06:11:55 +00:00
|
|
|
}
|