Here are some patches for the 3.3-rc1 tree.
It contains the removal of the sysdev code, now that all users of it are gone, as well as some sysfs bugfixes that have been reported by users. There are also some documentation updates here as well. -----BEGIN PGP SIGNATURE----- Version: GnuPG v2.0.18 (GNU/Linux) iEYEABECAAYFAk8jKW4ACgkQMUfUDdst+ynAUwCfVWwHJxpb4DSSMVZhGOnHMQrL ZjIAn00gPeSs5u8y1nPvFrFikbon4FDs =bzVy -----END PGP SIGNATURE----- Merge tag 'driver-core-3.3-rc1-bugfixes' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core Here are some patches for the 3.3-rc1 tree. It contains the removal of the sysdev code, now that all users of it are gone, as well as some sysfs bugfixes that have been reported by users. There are also some documentation updates here as well. * tag 'driver-core-3.3-rc1-bugfixes' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core: sysfs: Complain bitterly about attempts to remove files from nonexistent directories. stable: update documentation to ask for kernel version base/core.c:fix typo in comment in function device_add Documentation: devres: add allocation functions to list of supported calls Documentation update for the driver model core kernel-doc: fix new warnings in driver-core kernel-doc: fix new warnings in debugfs kernel-doc: fix new warnings in device.h driver core: remove drivers/base/sys.c and include/linux/sysdev.h
This commit is contained in:
Linus Torvalds
commit
0a96265754
|
|
@ -233,6 +233,10 @@ certainly invest a bit more effort into libata core layer).
|
|||
6. List of managed interfaces
|
||||
-----------------------------
|
||||
|
||||
MEM
|
||||
devm_kzalloc()
|
||||
devm_kfree()
|
||||
|
||||
IO region
|
||||
devm_request_region()
|
||||
devm_request_mem_region()
|
||||
|
|
|
|||
|
|
@ -25,7 +25,8 @@ Procedure for submitting patches to the -stable tree:
|
|||
|
||||
- Send the patch, after verifying that it follows the above rules, to
|
||||
stable@vger.kernel.org. You must note the upstream commit ID in the
|
||||
changelog of your submission.
|
||||
changelog of your submission, as well as the kernel version you wish
|
||||
it to be applied to.
|
||||
- To have the patch automatically included in the stable tree, add the tag
|
||||
Cc: stable@vger.kernel.org
|
||||
in the sign-off area. Once the patch is merged it will be applied to
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# Makefile for the Linux device tree
|
||||
|
||||
obj-y := core.o sys.o bus.o dd.o syscore.o \
|
||||
obj-y := core.o bus.o dd.o syscore.o \
|
||||
driver.o class.o platform.o \
|
||||
cpu.o firmware.o init.o map.o devres.o \
|
||||
attribute_container.o transport_class.o \
|
||||
|
|
|
|||
|
|
@ -632,6 +632,11 @@ static void klist_children_put(struct klist_node *n)
|
|||
* may be used for reference counting of @dev after calling this
|
||||
* function.
|
||||
*
|
||||
* All fields in @dev must be initialized by the caller to 0, except
|
||||
* for those explicitly set to some other value. The simplest
|
||||
* approach is to use kzalloc() to allocate the structure containing
|
||||
* @dev.
|
||||
*
|
||||
* NOTE: Use put_device() to give up your reference instead of freeing
|
||||
* @dev directly once you have called this function.
|
||||
*/
|
||||
|
|
@ -930,6 +935,13 @@ int device_private_init(struct device *dev)
|
|||
* to the global and sibling lists for the device, then
|
||||
* adds it to the other relevant subsystems of the driver model.
|
||||
*
|
||||
* Do not call this routine or device_register() more than once for
|
||||
* any device structure. The driver model core is not designed to work
|
||||
* with devices that get unregistered and then spring back to life.
|
||||
* (Among other things, it's very hard to guarantee that all references
|
||||
* to the previous incarnation of @dev have been dropped.) Allocate
|
||||
* and register a fresh new struct device instead.
|
||||
*
|
||||
* 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.
|
||||
|
|
@ -1022,7 +1034,7 @@ int device_add(struct device *dev)
|
|||
device_pm_add(dev);
|
||||
|
||||
/* Notify clients of device addition. This call must come
|
||||
* after dpm_sysf_add() and before kobject_uevent().
|
||||
* after dpm_sysfs_add() and before kobject_uevent().
|
||||
*/
|
||||
if (dev->bus)
|
||||
blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
|
||||
|
|
@ -1090,6 +1102,9 @@ name_error:
|
|||
* have a clearly defined need to use and refcount the device
|
||||
* before it is added to the hierarchy.
|
||||
*
|
||||
* For more information, see the kerneldoc for device_initialize()
|
||||
* and device_add().
|
||||
*
|
||||
* 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.
|
||||
|
|
|
|||
|
|
@ -1,383 +0,0 @@
|
|||
/*
|
||||
* sys.c - pseudo-bus for system 'devices' (cpus, PICs, timers, etc)
|
||||
*
|
||||
* Copyright (c) 2002-3 Patrick Mochel
|
||||
* 2002-3 Open Source Development Lab
|
||||
*
|
||||
* This file is released under the GPLv2
|
||||
*
|
||||
* This exports a 'system' bus type.
|
||||
* By default, a 'sys' bus gets added to the root of the system. There will
|
||||
* always be core system devices. Devices can use sysdev_register() to
|
||||
* add themselves as children of the system bus.
|
||||
*/
|
||||
|
||||
#include <linux/sysdev.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/pm.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/interrupt.h>
|
||||
|
||||
#include "base.h"
|
||||
|
||||
#define to_sysdev(k) container_of(k, struct sys_device, kobj)
|
||||
#define to_sysdev_attr(a) container_of(a, struct sysdev_attribute, attr)
|
||||
|
||||
|
||||
static ssize_t
|
||||
sysdev_show(struct kobject *kobj, struct attribute *attr, char *buffer)
|
||||
{
|
||||
struct sys_device *sysdev = to_sysdev(kobj);
|
||||
struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
|
||||
|
||||
if (sysdev_attr->show)
|
||||
return sysdev_attr->show(sysdev, sysdev_attr, buffer);
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
|
||||
static ssize_t
|
||||
sysdev_store(struct kobject *kobj, struct attribute *attr,
|
||||
const char *buffer, size_t count)
|
||||
{
|
||||
struct sys_device *sysdev = to_sysdev(kobj);
|
||||
struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
|
||||
|
||||
if (sysdev_attr->store)
|
||||
return sysdev_attr->store(sysdev, sysdev_attr, buffer, count);
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
static const struct sysfs_ops sysfs_ops = {
|
||||
.show = sysdev_show,
|
||||
.store = sysdev_store,
|
||||
};
|
||||
|
||||
static struct kobj_type ktype_sysdev = {
|
||||
.sysfs_ops = &sysfs_ops,
|
||||
};
|
||||
|
||||
|
||||
int sysdev_create_file(struct sys_device *s, struct sysdev_attribute *a)
|
||||
{
|
||||
return sysfs_create_file(&s->kobj, &a->attr);
|
||||
}
|
||||
|
||||
|
||||
void sysdev_remove_file(struct sys_device *s, struct sysdev_attribute *a)
|
||||
{
|
||||
sysfs_remove_file(&s->kobj, &a->attr);
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL_GPL(sysdev_create_file);
|
||||
EXPORT_SYMBOL_GPL(sysdev_remove_file);
|
||||
|
||||
#define to_sysdev_class(k) container_of(k, struct sysdev_class, kset.kobj)
|
||||
#define to_sysdev_class_attr(a) container_of(a, \
|
||||
struct sysdev_class_attribute, attr)
|
||||
|
||||
static ssize_t sysdev_class_show(struct kobject *kobj, struct attribute *attr,
|
||||
char *buffer)
|
||||
{
|
||||
struct sysdev_class *class = to_sysdev_class(kobj);
|
||||
struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
|
||||
|
||||
if (class_attr->show)
|
||||
return class_attr->show(class, class_attr, buffer);
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
static ssize_t sysdev_class_store(struct kobject *kobj, struct attribute *attr,
|
||||
const char *buffer, size_t count)
|
||||
{
|
||||
struct sysdev_class *class = to_sysdev_class(kobj);
|
||||
struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
|
||||
|
||||
if (class_attr->store)
|
||||
return class_attr->store(class, class_attr, buffer, count);
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
static const struct sysfs_ops sysfs_class_ops = {
|
||||
.show = sysdev_class_show,
|
||||
.store = sysdev_class_store,
|
||||
};
|
||||
|
||||
static struct kobj_type ktype_sysdev_class = {
|
||||
.sysfs_ops = &sysfs_class_ops,
|
||||
};
|
||||
|
||||
int sysdev_class_create_file(struct sysdev_class *c,
|
||||
struct sysdev_class_attribute *a)
|
||||
{
|
||||
return sysfs_create_file(&c->kset.kobj, &a->attr);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sysdev_class_create_file);
|
||||
|
||||
void sysdev_class_remove_file(struct sysdev_class *c,
|
||||
struct sysdev_class_attribute *a)
|
||||
{
|
||||
sysfs_remove_file(&c->kset.kobj, &a->attr);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sysdev_class_remove_file);
|
||||
|
||||
extern struct kset *system_kset;
|
||||
|
||||
int sysdev_class_register(struct sysdev_class *cls)
|
||||
{
|
||||
int retval;
|
||||
|
||||
pr_debug("Registering sysdev class '%s'\n", cls->name);
|
||||
|
||||
INIT_LIST_HEAD(&cls->drivers);
|
||||
memset(&cls->kset.kobj, 0x00, sizeof(struct kobject));
|
||||
cls->kset.kobj.parent = &system_kset->kobj;
|
||||
cls->kset.kobj.ktype = &ktype_sysdev_class;
|
||||
cls->kset.kobj.kset = system_kset;
|
||||
|
||||
retval = kobject_set_name(&cls->kset.kobj, "%s", cls->name);
|
||||
if (retval)
|
||||
return retval;
|
||||
|
||||
retval = kset_register(&cls->kset);
|
||||
if (!retval && cls->attrs)
|
||||
retval = sysfs_create_files(&cls->kset.kobj,
|
||||
(const struct attribute **)cls->attrs);
|
||||
return retval;
|
||||
}
|
||||
|
||||
void sysdev_class_unregister(struct sysdev_class *cls)
|
||||
{
|
||||
pr_debug("Unregistering sysdev class '%s'\n",
|
||||
kobject_name(&cls->kset.kobj));
|
||||
if (cls->attrs)
|
||||
sysfs_remove_files(&cls->kset.kobj,
|
||||
(const struct attribute **)cls->attrs);
|
||||
kset_unregister(&cls->kset);
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL_GPL(sysdev_class_register);
|
||||
EXPORT_SYMBOL_GPL(sysdev_class_unregister);
|
||||
|
||||
static DEFINE_MUTEX(sysdev_drivers_lock);
|
||||
|
||||
/*
|
||||
* @dev != NULL means that we're unwinding because some drv->add()
|
||||
* failed for some reason. You need to grab sysdev_drivers_lock before
|
||||
* calling this.
|
||||
*/
|
||||
static void __sysdev_driver_remove(struct sysdev_class *cls,
|
||||
struct sysdev_driver *drv,
|
||||
struct sys_device *from_dev)
|
||||
{
|
||||
struct sys_device *dev = from_dev;
|
||||
|
||||
list_del_init(&drv->entry);
|
||||
if (!cls)
|
||||
return;
|
||||
|
||||
if (!drv->remove)
|
||||
goto kset_put;
|
||||
|
||||
if (dev)
|
||||
list_for_each_entry_continue_reverse(dev, &cls->kset.list,
|
||||
kobj.entry)
|
||||
drv->remove(dev);
|
||||
else
|
||||
list_for_each_entry(dev, &cls->kset.list, kobj.entry)
|
||||
drv->remove(dev);
|
||||
|
||||
kset_put:
|
||||
kset_put(&cls->kset);
|
||||
}
|
||||
|
||||
/**
|
||||
* sysdev_driver_register - Register auxiliary driver
|
||||
* @cls: Device class driver belongs to.
|
||||
* @drv: Driver.
|
||||
*
|
||||
* @drv is inserted into @cls->drivers to be
|
||||
* called on each operation on devices of that class. The refcount
|
||||
* of @cls is incremented.
|
||||
*/
|
||||
int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
|
||||
{
|
||||
struct sys_device *dev = NULL;
|
||||
int err = 0;
|
||||
|
||||
if (!cls) {
|
||||
WARN(1, KERN_WARNING "sysdev: invalid class passed to %s!\n",
|
||||
__func__);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Check whether this driver has already been added to a class. */
|
||||
if (drv->entry.next && !list_empty(&drv->entry))
|
||||
WARN(1, KERN_WARNING "sysdev: class %s: driver (%p) has already"
|
||||
" been registered to a class, something is wrong, but "
|
||||
"will forge on!\n", cls->name, drv);
|
||||
|
||||
mutex_lock(&sysdev_drivers_lock);
|
||||
if (cls && kset_get(&cls->kset)) {
|
||||
list_add_tail(&drv->entry, &cls->drivers);
|
||||
|
||||
/* If devices of this class already exist, tell the driver */
|
||||
if (drv->add) {
|
||||
list_for_each_entry(dev, &cls->kset.list, kobj.entry) {
|
||||
err = drv->add(dev);
|
||||
if (err)
|
||||
goto unwind;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
err = -EINVAL;
|
||||
WARN(1, KERN_ERR "%s: invalid device class\n", __func__);
|
||||
}
|
||||
|
||||
goto unlock;
|
||||
|
||||
unwind:
|
||||
__sysdev_driver_remove(cls, drv, dev);
|
||||
|
||||
unlock:
|
||||
mutex_unlock(&sysdev_drivers_lock);
|
||||
return err;
|
||||
}
|
||||
|
||||
/**
|
||||
* sysdev_driver_unregister - Remove an auxiliary driver.
|
||||
* @cls: Class driver belongs to.
|
||||
* @drv: Driver.
|
||||
*/
|
||||
void sysdev_driver_unregister(struct sysdev_class *cls,
|
||||
struct sysdev_driver *drv)
|
||||
{
|
||||
mutex_lock(&sysdev_drivers_lock);
|
||||
__sysdev_driver_remove(cls, drv, NULL);
|
||||
mutex_unlock(&sysdev_drivers_lock);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sysdev_driver_register);
|
||||
EXPORT_SYMBOL_GPL(sysdev_driver_unregister);
|
||||
|
||||
/**
|
||||
* sysdev_register - add a system device to the tree
|
||||
* @sysdev: device in question
|
||||
*
|
||||
*/
|
||||
int sysdev_register(struct sys_device *sysdev)
|
||||
{
|
||||
int error;
|
||||
struct sysdev_class *cls = sysdev->cls;
|
||||
|
||||
if (!cls)
|
||||
return -EINVAL;
|
||||
|
||||
pr_debug("Registering sys device of class '%s'\n",
|
||||
kobject_name(&cls->kset.kobj));
|
||||
|
||||
/* initialize the kobject to 0, in case it had previously been used */
|
||||
memset(&sysdev->kobj, 0x00, sizeof(struct kobject));
|
||||
|
||||
/* Make sure the kset is set */
|
||||
sysdev->kobj.kset = &cls->kset;
|
||||
|
||||
/* Register the object */
|
||||
error = kobject_init_and_add(&sysdev->kobj, &ktype_sysdev, NULL,
|
||||
"%s%d", kobject_name(&cls->kset.kobj),
|
||||
sysdev->id);
|
||||
|
||||
if (!error) {
|
||||
struct sysdev_driver *drv;
|
||||
|
||||
pr_debug("Registering sys device '%s'\n",
|
||||
kobject_name(&sysdev->kobj));
|
||||
|
||||
mutex_lock(&sysdev_drivers_lock);
|
||||
/* Generic notification is implicit, because it's that
|
||||
* code that should have called us.
|
||||
*/
|
||||
|
||||
/* Notify class auxiliary drivers */
|
||||
list_for_each_entry(drv, &cls->drivers, entry) {
|
||||
if (drv->add)
|
||||
drv->add(sysdev);
|
||||
}
|
||||
mutex_unlock(&sysdev_drivers_lock);
|
||||
kobject_uevent(&sysdev->kobj, KOBJ_ADD);
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
void sysdev_unregister(struct sys_device *sysdev)
|
||||
{
|
||||
struct sysdev_driver *drv;
|
||||
|
||||
mutex_lock(&sysdev_drivers_lock);
|
||||
list_for_each_entry(drv, &sysdev->cls->drivers, entry) {
|
||||
if (drv->remove)
|
||||
drv->remove(sysdev);
|
||||
}
|
||||
mutex_unlock(&sysdev_drivers_lock);
|
||||
|
||||
kobject_put(&sysdev->kobj);
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL_GPL(sysdev_register);
|
||||
EXPORT_SYMBOL_GPL(sysdev_unregister);
|
||||
|
||||
#define to_ext_attr(x) container_of(x, struct sysdev_ext_attribute, attr)
|
||||
|
||||
ssize_t sysdev_store_ulong(struct sys_device *sysdev,
|
||||
struct sysdev_attribute *attr,
|
||||
const char *buf, size_t size)
|
||||
{
|
||||
struct sysdev_ext_attribute *ea = to_ext_attr(attr);
|
||||
char *end;
|
||||
unsigned long new = simple_strtoul(buf, &end, 0);
|
||||
if (end == buf)
|
||||
return -EINVAL;
|
||||
*(unsigned long *)(ea->var) = new;
|
||||
/* Always return full write size even if we didn't consume all */
|
||||
return size;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sysdev_store_ulong);
|
||||
|
||||
ssize_t sysdev_show_ulong(struct sys_device *sysdev,
|
||||
struct sysdev_attribute *attr,
|
||||
char *buf)
|
||||
{
|
||||
struct sysdev_ext_attribute *ea = to_ext_attr(attr);
|
||||
return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sysdev_show_ulong);
|
||||
|
||||
ssize_t sysdev_store_int(struct sys_device *sysdev,
|
||||
struct sysdev_attribute *attr,
|
||||
const char *buf, size_t size)
|
||||
{
|
||||
struct sysdev_ext_attribute *ea = to_ext_attr(attr);
|
||||
char *end;
|
||||
long new = simple_strtol(buf, &end, 0);
|
||||
if (end == buf || new > INT_MAX || new < INT_MIN)
|
||||
return -EINVAL;
|
||||
*(int *)(ea->var) = new;
|
||||
/* Always return full write size even if we didn't consume all */
|
||||
return size;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sysdev_store_int);
|
||||
|
||||
ssize_t sysdev_show_int(struct sys_device *sysdev,
|
||||
struct sysdev_attribute *attr,
|
||||
char *buf)
|
||||
{
|
||||
struct sysdev_ext_attribute *ea = to_ext_attr(attr);
|
||||
return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(sysdev_show_int);
|
||||
|
||||
|
|
@ -493,6 +493,12 @@ int sysfs_attr_ns(struct kobject *kobj, const struct attribute *attr,
|
|||
const void *ns = NULL;
|
||||
int err;
|
||||
|
||||
if (!dir_sd) {
|
||||
WARN(1, KERN_ERR "sysfs: kobject %s without dirent\n",
|
||||
kobject_name(kobj));
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
err = 0;
|
||||
if (!sysfs_ns_type(dir_sd))
|
||||
goto out;
|
||||
|
|
|
|||
|
|
@ -318,8 +318,11 @@ int sysfs_hash_and_remove(struct sysfs_dirent *dir_sd, const void *ns, const cha
|
|||
struct sysfs_addrm_cxt acxt;
|
||||
struct sysfs_dirent *sd;
|
||||
|
||||
if (!dir_sd)
|
||||
if (!dir_sd) {
|
||||
WARN(1, KERN_WARNING "sysfs: can not remove '%s', no directory\n",
|
||||
name);
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
sysfs_addrm_start(&acxt, dir_sd);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,164 +0,0 @@
|
|||
/**
|
||||
* System devices follow a slightly different driver model.
|
||||
* They don't need to do dynammic driver binding, can't be probed,
|
||||
* and don't reside on any type of peripheral bus.
|
||||
* So, we represent and treat them a little differently.
|
||||
*
|
||||
* We still have a notion of a driver for a system device, because we still
|
||||
* want to perform basic operations on these devices.
|
||||
*
|
||||
* We also support auxiliary drivers binding to devices of a certain class.
|
||||
*
|
||||
* This allows configurable drivers to register themselves for devices of
|
||||
* a certain type. And, it allows class definitions to reside in generic
|
||||
* code while arch-specific code can register specific drivers.
|
||||
*
|
||||
* Auxiliary drivers registered with a NULL cls are registered as drivers
|
||||
* for all system devices, and get notification calls for each device.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef _SYSDEV_H_
|
||||
#define _SYSDEV_H_
|
||||
|
||||
#include <linux/kobject.h>
|
||||
#include <linux/pm.h>
|
||||
|
||||
|
||||
struct sys_device;
|
||||
struct sysdev_class_attribute;
|
||||
|
||||
struct sysdev_class {
|
||||
const char *name;
|
||||
struct list_head drivers;
|
||||
struct sysdev_class_attribute **attrs;
|
||||
struct kset kset;
|
||||
};
|
||||
|
||||
struct sysdev_class_attribute {
|
||||
struct attribute attr;
|
||||
ssize_t (*show)(struct sysdev_class *, struct sysdev_class_attribute *,
|
||||
char *);
|
||||
ssize_t (*store)(struct sysdev_class *, struct sysdev_class_attribute *,
|
||||
const char *, size_t);
|
||||
};
|
||||
|
||||
#define _SYSDEV_CLASS_ATTR(_name,_mode,_show,_store) \
|
||||
{ \
|
||||
.attr = {.name = __stringify(_name), .mode = _mode }, \
|
||||
.show = _show, \
|
||||
.store = _store, \
|
||||
}
|
||||
|
||||
#define SYSDEV_CLASS_ATTR(_name,_mode,_show,_store) \
|
||||
struct sysdev_class_attribute attr_##_name = \
|
||||
_SYSDEV_CLASS_ATTR(_name,_mode,_show,_store)
|
||||
|
||||
|
||||
extern int sysdev_class_register(struct sysdev_class *);
|
||||
extern void sysdev_class_unregister(struct sysdev_class *);
|
||||
|
||||
extern int sysdev_class_create_file(struct sysdev_class *,
|
||||
struct sysdev_class_attribute *);
|
||||
extern void sysdev_class_remove_file(struct sysdev_class *,
|
||||
struct sysdev_class_attribute *);
|
||||
/**
|
||||
* Auxiliary system device drivers.
|
||||
*/
|
||||
|
||||
struct sysdev_driver {
|
||||
struct list_head entry;
|
||||
int (*add)(struct sys_device *);
|
||||
int (*remove)(struct sys_device *);
|
||||
};
|
||||
|
||||
|
||||
extern int sysdev_driver_register(struct sysdev_class *, struct sysdev_driver *);
|
||||
extern void sysdev_driver_unregister(struct sysdev_class *, struct sysdev_driver *);
|
||||
|
||||
|
||||
/**
|
||||
* sys_devices can be simplified a lot from regular devices, because they're
|
||||
* simply not as versatile.
|
||||
*/
|
||||
|
||||
struct sys_device {
|
||||
u32 id;
|
||||
struct sysdev_class * cls;
|
||||
struct kobject kobj;
|
||||
};
|
||||
|
||||
extern int sysdev_register(struct sys_device *);
|
||||
extern void sysdev_unregister(struct sys_device *);
|
||||
|
||||
|
||||
struct sysdev_attribute {
|
||||
struct attribute attr;
|
||||
ssize_t (*show)(struct sys_device *, struct sysdev_attribute *, char *);
|
||||
ssize_t (*store)(struct sys_device *, struct sysdev_attribute *,
|
||||
const char *, size_t);
|
||||
};
|
||||
|
||||
|
||||
#define _SYSDEV_ATTR(_name, _mode, _show, _store) \
|
||||
{ \
|
||||
.attr = { .name = __stringify(_name), .mode = _mode }, \
|
||||
.show = _show, \
|
||||
.store = _store, \
|
||||
}
|
||||
|
||||
#define SYSDEV_ATTR(_name, _mode, _show, _store) \
|
||||
struct sysdev_attribute attr_##_name = \
|
||||
_SYSDEV_ATTR(_name, _mode, _show, _store);
|
||||
|
||||
extern int sysdev_create_file(struct sys_device *, struct sysdev_attribute *);
|
||||
extern void sysdev_remove_file(struct sys_device *, struct sysdev_attribute *);
|
||||
|
||||
/* Create/remove NULL terminated attribute list */
|
||||
static inline int
|
||||
sysdev_create_files(struct sys_device *d, struct sysdev_attribute **a)
|
||||
{
|
||||
return sysfs_create_files(&d->kobj, (const struct attribute **)a);
|
||||
}
|
||||
|
||||
static inline void
|
||||
sysdev_remove_files(struct sys_device *d, struct sysdev_attribute **a)
|
||||
{
|
||||
return sysfs_remove_files(&d->kobj, (const struct attribute **)a);
|
||||
}
|
||||
|
||||
struct sysdev_ext_attribute {
|
||||
struct sysdev_attribute attr;
|
||||
void *var;
|
||||
};
|
||||
|
||||
/*
|
||||
* Support for simple variable sysdev attributes.
|
||||
* The pointer to the variable is stored in a sysdev_ext_attribute
|
||||
*/
|
||||
|
||||
/* Add more types as needed */
|
||||
|
||||
extern ssize_t sysdev_show_ulong(struct sys_device *, struct sysdev_attribute *,
|
||||
char *);
|
||||
extern ssize_t sysdev_store_ulong(struct sys_device *,
|
||||
struct sysdev_attribute *, const char *, size_t);
|
||||
extern ssize_t sysdev_show_int(struct sys_device *, struct sysdev_attribute *,
|
||||
char *);
|
||||
extern ssize_t sysdev_store_int(struct sys_device *,
|
||||
struct sysdev_attribute *, const char *, size_t);
|
||||
|
||||
#define _SYSDEV_ULONG_ATTR(_name, _mode, _var) \
|
||||
{ _SYSDEV_ATTR(_name, _mode, sysdev_show_ulong, sysdev_store_ulong), \
|
||||
&(_var) }
|
||||
#define SYSDEV_ULONG_ATTR(_name, _mode, _var) \
|
||||
struct sysdev_ext_attribute attr_##_name = \
|
||||
_SYSDEV_ULONG_ATTR(_name, _mode, _var);
|
||||
#define _SYSDEV_INT_ATTR(_name, _mode, _var) \
|
||||
{ _SYSDEV_ATTR(_name, _mode, sysdev_show_int, sysdev_store_int), \
|
||||
&(_var) }
|
||||
#define SYSDEV_INT_ATTR(_name, _mode, _var) \
|
||||
struct sysdev_ext_attribute attr_##_name = \
|
||||
_SYSDEV_INT_ATTR(_name, _mode, _var);
|
||||
|
||||
#endif /* _SYSDEV_H_ */
|
||||
Loading…
Reference in New Issue