2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* device.h - generic, centralized driver model
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
|
2007-02-13 06:33:06 +00:00
|
|
|
* Copyright (c) 2004-2007 Greg Kroah-Hartman <gregkh@suse.de>
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
|
* This file is released under the GPLv2
|
|
|
|
|
*
|
|
|
|
|
* See Documentation/driver-model/ for more information.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef _DEVICE_H_
|
|
|
|
|
#define _DEVICE_H_
|
|
|
|
|
|
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
|
#include <linux/kobject.h>
|
2005-03-21 19:49:14 +00:00
|
|
|
#include <linux/klist.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/list.h>
|
2006-08-15 05:43:17 +00:00
|
|
|
#include <linux/compiler.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/types.h>
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/pm.h>
|
|
|
|
|
#include <asm/semaphore.h>
|
|
|
|
|
#include <asm/atomic.h>
|
2006-11-11 06:18:39 +00:00
|
|
|
#include <asm/device.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
#define DEVICE_NAME_SIZE 50
|
|
|
|
|
#define DEVICE_NAME_HALF __stringify(20) /* Less than half to accommodate slop */
|
|
|
|
|
#define DEVICE_ID_SIZE 32
|
|
|
|
|
#define BUS_ID_SIZE KOBJ_NAME_LEN
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct device;
|
|
|
|
|
struct device_driver;
|
|
|
|
|
struct class;
|
|
|
|
|
struct class_device;
|
Driver core: udev triggered device-<>driver binding
We get two per-bus sysfs files:
ls-l /sys/subsystem/usb
drwxr-xr-x 2 root root 0 2007-02-16 16:42 devices
drwxr-xr-x 7 root root 0 2007-02-16 14:55 drivers
-rw-r--r-- 1 root root 4096 2007-02-16 16:42 drivers_autoprobe
--w------- 1 root root 4096 2007-02-16 16:42 drivers_probe
The flag "drivers_autoprobe" controls the behavior of the bus to bind
devices by default, or just initialize the device and leave it alone.
The command "drivers_probe" accepts a bus_id and the bus tries to bind a
driver to this device.
Systems who want to control the driver binding with udev, switch off the
bus initiated probing:
echo 0 > /sys/subsystem/usb/drivers_autoprobe
echo 0 > /sys/subsystem/pcmcia/drivers_autoprobe
...
and initiate the probing with udev rules like:
ACTION=="add", SUBSYSTEM=="usb", ATTR{subsystem/drivers_probe}="$kernel"
ACTION=="add", SUBSYSTEM=="pcmcia", ATTR{subsystem/drivers_probe}="$kernel"
...
Custom driver binding can happen in earlier rules by something like:
ACTION=="add", SUBSYSTEM=="usb", \
ATTRS{idVendor}=="1234", ATTRS{idProduct}=="5678" \
ATTR{subsystem/drivers/<custom-driver>/bind}="$kernel"
This is intended to solve the modprobe.conf mess with "install-rules", custom
bind/unbind-scripts and all the weird things people invented over the years.
It should also provide the functionality "libusual" was supposed to do.
With udev, one can just write a udev rule to drive all USB-disks at the
third port of USB-hub by the "ub" driver, and everything else by
usb-storage. One can also instruct udev to bind different wireless
drivers to identical cards - just selected by the pcmcia slot-number, and
whatever ...
To use the mentioned rules, it needs udev version 106, to be able to
write ATTR{}="$kernel" to sysfs files.
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2007-02-16 16:33:36 +00:00
|
|
|
struct bus_type;
|
|
|
|
|
|
|
|
|
|
struct bus_attribute {
|
|
|
|
|
struct attribute attr;
|
|
|
|
|
ssize_t (*show)(struct bus_type *, char * buf);
|
|
|
|
|
ssize_t (*store)(struct bus_type *, const char * buf, size_t count);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define BUS_ATTR(_name,_mode,_show,_store) \
|
|
|
|
|
struct bus_attribute bus_attr_##_name = __ATTR(_name,_mode,_show,_store)
|
|
|
|
|
|
|
|
|
|
extern int __must_check bus_create_file(struct bus_type *,
|
|
|
|
|
struct bus_attribute *);
|
|
|
|
|
extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
struct bus_type {
|
2005-04-26 07:34:05 +00:00
|
|
|
const char * name;
|
Driver core: udev triggered device-<>driver binding
We get two per-bus sysfs files:
ls-l /sys/subsystem/usb
drwxr-xr-x 2 root root 0 2007-02-16 16:42 devices
drwxr-xr-x 7 root root 0 2007-02-16 14:55 drivers
-rw-r--r-- 1 root root 4096 2007-02-16 16:42 drivers_autoprobe
--w------- 1 root root 4096 2007-02-16 16:42 drivers_probe
The flag "drivers_autoprobe" controls the behavior of the bus to bind
devices by default, or just initialize the device and leave it alone.
The command "drivers_probe" accepts a bus_id and the bus tries to bind a
driver to this device.
Systems who want to control the driver binding with udev, switch off the
bus initiated probing:
echo 0 > /sys/subsystem/usb/drivers_autoprobe
echo 0 > /sys/subsystem/pcmcia/drivers_autoprobe
...
and initiate the probing with udev rules like:
ACTION=="add", SUBSYSTEM=="usb", ATTR{subsystem/drivers_probe}="$kernel"
ACTION=="add", SUBSYSTEM=="pcmcia", ATTR{subsystem/drivers_probe}="$kernel"
...
Custom driver binding can happen in earlier rules by something like:
ACTION=="add", SUBSYSTEM=="usb", \
ATTRS{idVendor}=="1234", ATTRS{idProduct}=="5678" \
ATTR{subsystem/drivers/<custom-driver>/bind}="$kernel"
This is intended to solve the modprobe.conf mess with "install-rules", custom
bind/unbind-scripts and all the weird things people invented over the years.
It should also provide the functionality "libusual" was supposed to do.
With udev, one can just write a udev rule to drive all USB-disks at the
third port of USB-hub by the "ub" driver, and everything else by
usb-storage. One can also instruct udev to bind different wireless
drivers to identical cards - just selected by the pcmcia slot-number, and
whatever ...
To use the mentioned rules, it needs udev version 106, to be able to
write ATTR{}="$kernel" to sysfs files.
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2007-02-16 16:33:36 +00:00
|
|
|
struct module * owner;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
struct subsystem subsys;
|
|
|
|
|
struct kset drivers;
|
|
|
|
|
struct kset devices;
|
2005-03-21 19:49:14 +00:00
|
|
|
struct klist klist_devices;
|
2005-03-21 20:00:18 +00:00
|
|
|
struct klist klist_drivers;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
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
|
|
|
struct blocking_notifier_head bus_notifier;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct bus_attribute * bus_attrs;
|
|
|
|
|
struct device_attribute * dev_attrs;
|
|
|
|
|
struct driver_attribute * drv_attrs;
|
Driver core: udev triggered device-<>driver binding
We get two per-bus sysfs files:
ls-l /sys/subsystem/usb
drwxr-xr-x 2 root root 0 2007-02-16 16:42 devices
drwxr-xr-x 7 root root 0 2007-02-16 14:55 drivers
-rw-r--r-- 1 root root 4096 2007-02-16 16:42 drivers_autoprobe
--w------- 1 root root 4096 2007-02-16 16:42 drivers_probe
The flag "drivers_autoprobe" controls the behavior of the bus to bind
devices by default, or just initialize the device and leave it alone.
The command "drivers_probe" accepts a bus_id and the bus tries to bind a
driver to this device.
Systems who want to control the driver binding with udev, switch off the
bus initiated probing:
echo 0 > /sys/subsystem/usb/drivers_autoprobe
echo 0 > /sys/subsystem/pcmcia/drivers_autoprobe
...
and initiate the probing with udev rules like:
ACTION=="add", SUBSYSTEM=="usb", ATTR{subsystem/drivers_probe}="$kernel"
ACTION=="add", SUBSYSTEM=="pcmcia", ATTR{subsystem/drivers_probe}="$kernel"
...
Custom driver binding can happen in earlier rules by something like:
ACTION=="add", SUBSYSTEM=="usb", \
ATTRS{idVendor}=="1234", ATTRS{idProduct}=="5678" \
ATTR{subsystem/drivers/<custom-driver>/bind}="$kernel"
This is intended to solve the modprobe.conf mess with "install-rules", custom
bind/unbind-scripts and all the weird things people invented over the years.
It should also provide the functionality "libusual" was supposed to do.
With udev, one can just write a udev rule to drive all USB-disks at the
third port of USB-hub by the "ub" driver, and everything else by
usb-storage. One can also instruct udev to bind different wireless
drivers to identical cards - just selected by the pcmcia slot-number, and
whatever ...
To use the mentioned rules, it needs udev version 106, to be able to
write ATTR{}="$kernel" to sysfs files.
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2007-02-16 16:33:36 +00:00
|
|
|
struct bus_attribute drivers_autoprobe_attr;
|
|
|
|
|
struct bus_attribute drivers_probe_attr;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
int (*match)(struct device * dev, struct device_driver * drv);
|
2005-11-16 08:00:00 +00:00
|
|
|
int (*uevent)(struct device *dev, char **envp,
|
|
|
|
|
int num_envp, char *buffer, int buffer_size);
|
2006-01-05 14:29:51 +00:00
|
|
|
int (*probe)(struct device * dev);
|
|
|
|
|
int (*remove)(struct device * dev);
|
|
|
|
|
void (*shutdown)(struct device * dev);
|
2006-06-24 21:50:29 +00:00
|
|
|
|
|
|
|
|
int (*suspend)(struct device * dev, pm_message_t state);
|
|
|
|
|
int (*suspend_late)(struct device * dev, pm_message_t state);
|
|
|
|
|
int (*resume_early)(struct device * dev);
|
|
|
|
|
int (*resume)(struct device * dev);
|
Driver core: udev triggered device-<>driver binding
We get two per-bus sysfs files:
ls-l /sys/subsystem/usb
drwxr-xr-x 2 root root 0 2007-02-16 16:42 devices
drwxr-xr-x 7 root root 0 2007-02-16 14:55 drivers
-rw-r--r-- 1 root root 4096 2007-02-16 16:42 drivers_autoprobe
--w------- 1 root root 4096 2007-02-16 16:42 drivers_probe
The flag "drivers_autoprobe" controls the behavior of the bus to bind
devices by default, or just initialize the device and leave it alone.
The command "drivers_probe" accepts a bus_id and the bus tries to bind a
driver to this device.
Systems who want to control the driver binding with udev, switch off the
bus initiated probing:
echo 0 > /sys/subsystem/usb/drivers_autoprobe
echo 0 > /sys/subsystem/pcmcia/drivers_autoprobe
...
and initiate the probing with udev rules like:
ACTION=="add", SUBSYSTEM=="usb", ATTR{subsystem/drivers_probe}="$kernel"
ACTION=="add", SUBSYSTEM=="pcmcia", ATTR{subsystem/drivers_probe}="$kernel"
...
Custom driver binding can happen in earlier rules by something like:
ACTION=="add", SUBSYSTEM=="usb", \
ATTRS{idVendor}=="1234", ATTRS{idProduct}=="5678" \
ATTR{subsystem/drivers/<custom-driver>/bind}="$kernel"
This is intended to solve the modprobe.conf mess with "install-rules", custom
bind/unbind-scripts and all the weird things people invented over the years.
It should also provide the functionality "libusual" was supposed to do.
With udev, one can just write a udev rule to drive all USB-disks at the
third port of USB-hub by the "ub" driver, and everything else by
usb-storage. One can also instruct udev to bind different wireless
drivers to identical cards - just selected by the pcmcia slot-number, and
whatever ...
To use the mentioned rules, it needs udev version 106, to be able to
write ATTR{}="$kernel" to sysfs files.
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2007-02-16 16:33:36 +00:00
|
|
|
|
|
|
|
|
unsigned int drivers_autoprobe:1;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check bus_register(struct bus_type * bus);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void bus_unregister(struct bus_type * bus);
|
|
|
|
|
|
2006-08-15 05:43:20 +00:00
|
|
|
extern int __must_check bus_rescan_devices(struct bus_type * bus);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* iterator helpers for buses */
|
|
|
|
|
|
|
|
|
|
int bus_for_each_dev(struct bus_type * bus, struct device * start, void * data,
|
|
|
|
|
int (*fn)(struct device *, void *));
|
2005-06-22 14:59:51 +00:00
|
|
|
struct device * bus_find_device(struct bus_type *bus, struct device *start,
|
|
|
|
|
void *data, int (*match)(struct device *, void *));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-08-15 05:43:17 +00:00
|
|
|
int __must_check bus_for_each_drv(struct bus_type *bus,
|
|
|
|
|
struct device_driver *start, void *data,
|
|
|
|
|
int (*fn)(struct device_driver *, void *));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
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
|
|
|
/*
|
|
|
|
|
* Bus notifiers: Get notified of addition/removal of devices
|
|
|
|
|
* and binding/unbinding of drivers to devices.
|
|
|
|
|
* In the long run, it should be a replacement for the platform
|
|
|
|
|
* notify hooks.
|
|
|
|
|
*/
|
|
|
|
|
struct notifier_block;
|
|
|
|
|
|
|
|
|
|
extern int bus_register_notifier(struct bus_type *bus,
|
|
|
|
|
struct notifier_block *nb);
|
|
|
|
|
extern int bus_unregister_notifier(struct bus_type *bus,
|
|
|
|
|
struct notifier_block *nb);
|
|
|
|
|
|
|
|
|
|
/* All 4 notifers below get called with the target struct device *
|
|
|
|
|
* as an argument. Note that those functions are likely to be called
|
|
|
|
|
* with the device semaphore held in the core, so be careful.
|
|
|
|
|
*/
|
|
|
|
|
#define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */
|
|
|
|
|
#define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */
|
|
|
|
|
#define BUS_NOTIFY_BOUND_DRIVER 0x00000003 /* driver bound to device */
|
|
|
|
|
#define BUS_NOTIFY_UNBIND_DRIVER 0x00000004 /* driver about to be
|
|
|
|
|
unbound */
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct device_driver {
|
2005-04-26 07:34:05 +00:00
|
|
|
const char * name;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct bus_type * bus;
|
|
|
|
|
|
|
|
|
|
struct completion unloaded;
|
|
|
|
|
struct kobject kobj;
|
2005-03-21 20:25:36 +00:00
|
|
|
struct klist klist_devices;
|
2005-03-21 20:00:18 +00:00
|
|
|
struct klist_node knode_bus;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-04-26 07:34:05 +00:00
|
|
|
struct module * owner;
|
2007-01-15 19:22:02 +00:00
|
|
|
const char * mod_name; /* used for built-in modules */
|
2007-04-02 06:49:48 +00:00
|
|
|
struct module_kobject * mkobj;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
int (*probe) (struct device * dev);
|
2005-04-26 07:34:05 +00:00
|
|
|
int (*remove) (struct device * dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
void (*shutdown) (struct device * dev);
|
2005-10-28 16:52:56 +00:00
|
|
|
int (*suspend) (struct device * dev, pm_message_t state);
|
|
|
|
|
int (*resume) (struct device * dev);
|
2006-07-18 17:59:59 +00:00
|
|
|
|
|
|
|
|
unsigned int multithread_probe:1;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check driver_register(struct device_driver * drv);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void driver_unregister(struct device_driver * drv);
|
|
|
|
|
|
|
|
|
|
extern struct device_driver * get_driver(struct device_driver * drv);
|
|
|
|
|
extern void put_driver(struct device_driver * drv);
|
|
|
|
|
extern struct device_driver *driver_find(const char *name, struct bus_type *bus);
|
2006-07-18 17:59:59 +00:00
|
|
|
extern int driver_probe_done(void);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-17 18:13:42 +00:00
|
|
|
/* sysfs interface for exporting driver attributes */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
struct driver_attribute {
|
|
|
|
|
struct attribute attr;
|
|
|
|
|
ssize_t (*show)(struct device_driver *, char * buf);
|
|
|
|
|
ssize_t (*store)(struct device_driver *, const char * buf, size_t count);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define DRIVER_ATTR(_name,_mode,_show,_store) \
|
|
|
|
|
struct driver_attribute driver_attr_##_name = __ATTR(_name,_mode,_show,_store)
|
|
|
|
|
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check driver_create_file(struct device_driver *,
|
|
|
|
|
struct driver_attribute *);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void driver_remove_file(struct device_driver *, struct driver_attribute *);
|
|
|
|
|
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check driver_for_each_device(struct device_driver * drv,
|
|
|
|
|
struct device *start, void *data,
|
|
|
|
|
int (*fn)(struct device *, void *));
|
2005-06-22 14:59:51 +00:00
|
|
|
struct device * driver_find_device(struct device_driver *drv,
|
|
|
|
|
struct device *start, void *data,
|
|
|
|
|
int (*match)(struct device *, void *));
|
2005-03-21 18:59:56 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* device classes
|
|
|
|
|
*/
|
|
|
|
|
struct class {
|
2005-04-26 07:34:05 +00:00
|
|
|
const char * name;
|
2005-03-15 19:54:21 +00:00
|
|
|
struct module * owner;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
struct subsystem subsys;
|
|
|
|
|
struct list_head children;
|
2006-06-14 19:14:34 +00:00
|
|
|
struct list_head devices;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct list_head interfaces;
|
2007-03-14 02:25:56 +00:00
|
|
|
struct kset class_dirs;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct semaphore sem; /* locks both the children and interfaces lists */
|
|
|
|
|
|
|
|
|
|
struct class_attribute * class_attrs;
|
|
|
|
|
struct class_device_attribute * class_dev_attrs;
|
2006-06-28 23:19:58 +00:00
|
|
|
struct device_attribute * dev_attrs;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-16 08:00:00 +00:00
|
|
|
int (*uevent)(struct class_device *dev, char **envp,
|
2005-04-16 22:20:36 +00:00
|
|
|
int num_envp, char *buffer, int buffer_size);
|
2006-06-28 23:19:58 +00:00
|
|
|
int (*dev_uevent)(struct device *dev, char **envp, int num_envp,
|
|
|
|
|
char *buffer, int buffer_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
void (*release)(struct class_device *dev);
|
|
|
|
|
void (*class_release)(struct class *class);
|
2006-06-28 23:19:58 +00:00
|
|
|
void (*dev_release)(struct device *dev);
|
2006-06-24 21:50:29 +00:00
|
|
|
|
|
|
|
|
int (*suspend)(struct device *, pm_message_t state);
|
|
|
|
|
int (*resume)(struct device *);
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check class_register(struct class *);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void class_unregister(struct class *);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct class_attribute {
|
|
|
|
|
struct attribute attr;
|
|
|
|
|
ssize_t (*show)(struct class *, char * buf);
|
|
|
|
|
ssize_t (*store)(struct class *, const char * buf, size_t count);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define CLASS_ATTR(_name,_mode,_show,_store) \
|
|
|
|
|
struct class_attribute class_attr_##_name = __ATTR(_name,_mode,_show,_store)
|
|
|
|
|
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check class_create_file(struct class *,
|
|
|
|
|
const struct class_attribute *);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void class_remove_file(struct class *, const struct class_attribute *);
|
|
|
|
|
|
2005-10-01 12:49:43 +00:00
|
|
|
struct class_device_attribute {
|
|
|
|
|
struct attribute attr;
|
|
|
|
|
ssize_t (*show)(struct class_device *, char * buf);
|
|
|
|
|
ssize_t (*store)(struct class_device *, const char * buf, size_t count);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define CLASS_DEVICE_ATTR(_name,_mode,_show,_store) \
|
|
|
|
|
struct class_device_attribute class_device_attr_##_name = \
|
|
|
|
|
__ATTR(_name,_mode,_show,_store)
|
|
|
|
|
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check class_device_create_file(struct class_device *,
|
2005-10-01 12:49:43 +00:00
|
|
|
const struct class_device_attribute *);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-28 05:25:43 +00:00
|
|
|
/**
|
|
|
|
|
* struct class_device - class devices
|
|
|
|
|
* @class: pointer to the parent class for this class device. This is required.
|
|
|
|
|
* @devt: for internal use by the driver core only.
|
|
|
|
|
* @node: for internal use by the driver core only.
|
|
|
|
|
* @kobj: for internal use by the driver core only.
|
|
|
|
|
* @devt_attr: for internal use by the driver core only.
|
2006-05-07 00:55:11 +00:00
|
|
|
* @groups: optional additional groups to be created
|
2005-10-28 05:25:43 +00:00
|
|
|
* @dev: if set, a symlink to the struct device is created in the sysfs
|
|
|
|
|
* directory for this struct class device.
|
|
|
|
|
* @class_data: pointer to whatever you want to store here for this struct
|
|
|
|
|
* class_device. Use class_get_devdata() and class_set_devdata() to get and
|
|
|
|
|
* set this pointer.
|
|
|
|
|
* @parent: pointer to a struct class_device that is the parent of this struct
|
|
|
|
|
* class_device. If NULL, this class_device will show up at the root of the
|
|
|
|
|
* struct class in sysfs (which is probably what you want to have happen.)
|
|
|
|
|
* @release: pointer to a release function for this struct class_device. If
|
|
|
|
|
* set, this will be called instead of the class specific release function.
|
|
|
|
|
* Only use this if you want to override the default release function, like
|
|
|
|
|
* when you are nesting class_device structures.
|
2005-11-16 08:00:00 +00:00
|
|
|
* @uevent: pointer to a uevent function for this struct class_device. If
|
|
|
|
|
* set, this will be called instead of the class specific uevent function.
|
|
|
|
|
* Only use this if you want to override the default uevent function, like
|
2005-10-28 05:25:43 +00:00
|
|
|
* when you are nesting class_device structures.
|
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
struct class_device {
|
|
|
|
|
struct list_head node;
|
|
|
|
|
|
|
|
|
|
struct kobject kobj;
|
|
|
|
|
struct class * class; /* required */
|
|
|
|
|
dev_t devt; /* dev_t, creates the sysfs "dev" */
|
2005-03-15 19:54:21 +00:00
|
|
|
struct class_device_attribute *devt_attr;
|
2005-10-01 12:49:43 +00:00
|
|
|
struct class_device_attribute uevent_attr;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct device * dev; /* not necessary, but nice to have */
|
|
|
|
|
void * class_data; /* class-specific data */
|
2005-10-28 05:25:43 +00:00
|
|
|
struct class_device *parent; /* parent of this child device, if there is one */
|
2006-05-07 00:55:11 +00:00
|
|
|
struct attribute_group ** groups; /* optional groups */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-28 05:25:43 +00:00
|
|
|
void (*release)(struct class_device *dev);
|
2005-11-16 08:00:00 +00:00
|
|
|
int (*uevent)(struct class_device *dev, char **envp,
|
2005-10-28 05:25:43 +00:00
|
|
|
int num_envp, char *buffer, int buffer_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
char class_id[BUS_ID_SIZE]; /* unique to this class */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline void *
|
|
|
|
|
class_get_devdata (struct class_device *dev)
|
|
|
|
|
{
|
|
|
|
|
return dev->class_data;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
class_set_devdata (struct class_device *dev, void *data)
|
|
|
|
|
{
|
|
|
|
|
dev->class_data = data;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check class_device_register(struct class_device *);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void class_device_unregister(struct class_device *);
|
|
|
|
|
extern void class_device_initialize(struct class_device *);
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check class_device_add(struct class_device *);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void class_device_del(struct class_device *);
|
|
|
|
|
|
|
|
|
|
extern struct class_device * class_device_get(struct class_device *);
|
|
|
|
|
extern void class_device_put(struct class_device *);
|
|
|
|
|
|
|
|
|
|
extern void class_device_remove_file(struct class_device *,
|
|
|
|
|
const struct class_device_attribute *);
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check class_device_create_bin_file(struct class_device *,
|
2005-04-16 22:20:36 +00:00
|
|
|
struct bin_attribute *);
|
|
|
|
|
extern void class_device_remove_bin_file(struct class_device *,
|
|
|
|
|
struct bin_attribute *);
|
|
|
|
|
|
|
|
|
|
struct class_interface {
|
|
|
|
|
struct list_head node;
|
|
|
|
|
struct class *class;
|
|
|
|
|
|
2005-09-15 07:01:36 +00:00
|
|
|
int (*add) (struct class_device *, struct class_interface *);
|
|
|
|
|
void (*remove) (struct class_device *, struct class_interface *);
|
2006-09-13 13:34:05 +00:00
|
|
|
int (*add_dev) (struct device *, struct class_interface *);
|
|
|
|
|
void (*remove_dev) (struct device *, struct class_interface *);
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check class_interface_register(struct class_interface *);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void class_interface_unregister(struct class_interface *);
|
|
|
|
|
|
2006-09-13 13:34:05 +00:00
|
|
|
extern struct class *class_create(struct module *owner, const char *name);
|
2005-03-15 19:54:21 +00:00
|
|
|
extern void class_destroy(struct class *cls);
|
2005-10-28 05:25:43 +00:00
|
|
|
extern struct class_device *class_device_create(struct class *cls,
|
|
|
|
|
struct class_device *parent,
|
|
|
|
|
dev_t devt,
|
|
|
|
|
struct device *device,
|
2006-08-10 05:18:18 +00:00
|
|
|
const char *fmt, ...)
|
2005-10-28 05:25:43 +00:00
|
|
|
__attribute__((format(printf,5,6)));
|
2005-03-15 19:54:21 +00:00
|
|
|
extern void class_device_destroy(struct class *cls, dev_t devt);
|
|
|
|
|
|
2006-10-07 19:54:55 +00:00
|
|
|
struct device_type {
|
2007-03-10 06:37:34 +00:00
|
|
|
struct attribute_group **groups;
|
2006-10-07 19:54:55 +00:00
|
|
|
int (*uevent)(struct device *dev, char **envp, int num_envp,
|
|
|
|
|
char *buffer, int buffer_size);
|
|
|
|
|
void (*release)(struct device *dev);
|
|
|
|
|
};
|
|
|
|
|
|
2005-10-01 12:49:43 +00:00
|
|
|
/* interface for exporting device attributes */
|
|
|
|
|
struct device_attribute {
|
|
|
|
|
struct attribute attr;
|
|
|
|
|
ssize_t (*show)(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
char *buf);
|
|
|
|
|
ssize_t (*store)(struct device *dev, struct device_attribute *attr,
|
|
|
|
|
const char *buf, size_t count);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define DEVICE_ATTR(_name,_mode,_show,_store) \
|
|
|
|
|
struct device_attribute dev_attr_##_name = __ATTR(_name,_mode,_show,_store)
|
|
|
|
|
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check device_create_file(struct device *device,
|
|
|
|
|
struct device_attribute * entry);
|
2005-10-01 12:49:43 +00:00
|
|
|
extern void device_remove_file(struct device * dev, struct device_attribute * attr);
|
2006-09-19 16:39:19 +00:00
|
|
|
extern int __must_check device_create_bin_file(struct device *dev,
|
|
|
|
|
struct bin_attribute *attr);
|
|
|
|
|
extern void device_remove_bin_file(struct device *dev,
|
|
|
|
|
struct bin_attribute *attr);
|
2007-03-15 19:50:34 +00:00
|
|
|
extern int device_schedule_callback(struct device *dev,
|
|
|
|
|
void (*func)(struct device *));
|
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
|
|
|
|
|
|
|
|
/* device resource management */
|
|
|
|
|
typedef void (*dr_release_t)(struct device *dev, void *res);
|
|
|
|
|
typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_DEVRES
|
|
|
|
|
extern void * __devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
|
|
|
|
|
const char *name);
|
|
|
|
|
#define devres_alloc(release, size, gfp) \
|
|
|
|
|
__devres_alloc(release, size, gfp, #release)
|
|
|
|
|
#else
|
|
|
|
|
extern void * devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
|
|
|
|
|
#endif
|
|
|
|
|
extern void devres_free(void *res);
|
|
|
|
|
extern void devres_add(struct device *dev, void *res);
|
|
|
|
|
extern void * devres_find(struct device *dev, dr_release_t release,
|
|
|
|
|
dr_match_t match, void *match_data);
|
|
|
|
|
extern void * devres_get(struct device *dev, void *new_res,
|
|
|
|
|
dr_match_t match, void *match_data);
|
|
|
|
|
extern void * devres_remove(struct device *dev, dr_release_t release,
|
|
|
|
|
dr_match_t match, void *match_data);
|
|
|
|
|
extern int devres_destroy(struct device *dev, dr_release_t release,
|
|
|
|
|
dr_match_t match, void *match_data);
|
|
|
|
|
|
|
|
|
|
/* devres group */
|
|
|
|
|
extern void * __must_check devres_open_group(struct device *dev, void *id,
|
|
|
|
|
gfp_t gfp);
|
|
|
|
|
extern void devres_close_group(struct device *dev, void *id);
|
|
|
|
|
extern void devres_remove_group(struct device *dev, void *id);
|
|
|
|
|
extern int devres_release_group(struct device *dev, void *id);
|
|
|
|
|
|
|
|
|
|
/* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
|
|
|
|
|
extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
|
|
|
|
|
extern void devm_kfree(struct device *dev, void *p);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct device {
|
2005-03-25 03:08:30 +00:00
|
|
|
struct klist klist_children;
|
|
|
|
|
struct klist_node knode_parent; /* node in sibling list */
|
2005-03-21 20:25:36 +00:00
|
|
|
struct klist_node knode_driver;
|
2005-03-21 19:49:14 +00:00
|
|
|
struct klist_node knode_bus;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct device * parent;
|
|
|
|
|
|
|
|
|
|
struct kobject kobj;
|
|
|
|
|
char bus_id[BUS_ID_SIZE]; /* position on parent bus */
|
2006-10-07 19:54:55 +00:00
|
|
|
struct device_type *type;
|
2006-09-18 20:22:34 +00:00
|
|
|
unsigned is_registered:1;
|
2005-10-01 12:49:43 +00:00
|
|
|
struct device_attribute uevent_attr;
|
2006-06-14 19:14:34 +00:00
|
|
|
struct device_attribute *devt_attr;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-03-21 18:41:04 +00:00
|
|
|
struct semaphore sem; /* semaphore to synchronize calls to
|
|
|
|
|
* its driver.
|
|
|
|
|
*/
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct bus_type * bus; /* type of bus device is on */
|
|
|
|
|
struct device_driver *driver; /* which driver has allocated this
|
|
|
|
|
device */
|
|
|
|
|
void *driver_data; /* data private to the driver */
|
2005-03-18 23:45:35 +00:00
|
|
|
void *platform_data; /* Platform specific data, device
|
|
|
|
|
core doesn't touch it */
|
2005-04-16 22:20:36 +00:00
|
|
|
struct dev_pm_info power;
|
|
|
|
|
|
2006-12-07 04:32:33 +00:00
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
|
int numa_node; /* NUMA node this device is close to */
|
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
u64 *dma_mask; /* dma mask (if dma'able device) */
|
|
|
|
|
u64 coherent_dma_mask;/* Like dma_mask, but for
|
|
|
|
|
alloc_coherent mappings as
|
|
|
|
|
not all hardware supports
|
|
|
|
|
64 bit addresses for consistent
|
|
|
|
|
allocations such descriptors. */
|
|
|
|
|
|
|
|
|
|
struct list_head dma_pools; /* dma pools (if dma'ble) */
|
|
|
|
|
|
|
|
|
|
struct dma_coherent_mem *dma_mem; /* internal for coherent mem
|
|
|
|
|
override */
|
2006-11-11 06:18:39 +00:00
|
|
|
/* arch specific additions */
|
|
|
|
|
struct dev_archdata archdata;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
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
|
|
|
spinlock_t devres_lock;
|
|
|
|
|
struct list_head devres_head;
|
|
|
|
|
|
2006-06-14 19:14:34 +00:00
|
|
|
/* class_device migration path */
|
|
|
|
|
struct list_head node;
|
2006-10-07 19:54:55 +00:00
|
|
|
struct class *class;
|
2006-06-14 19:14:34 +00:00
|
|
|
dev_t devt; /* dev_t, creates the sysfs "dev" */
|
2006-06-27 07:06:09 +00:00
|
|
|
struct attribute_group **groups; /* optional groups */
|
2006-10-07 19:54:55 +00:00
|
|
|
int uevent_suppress;
|
2006-06-14 19:14:34 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
void (*release)(struct device * dev);
|
|
|
|
|
};
|
|
|
|
|
|
2006-12-07 04:32:33 +00:00
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
|
static inline int dev_to_node(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return dev->numa_node;
|
|
|
|
|
}
|
|
|
|
|
static inline void set_dev_node(struct device *dev, int node)
|
|
|
|
|
{
|
|
|
|
|
dev->numa_node = node;
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
static inline int dev_to_node(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
static inline void set_dev_node(struct device *dev, int node)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static inline void *
|
|
|
|
|
dev_get_drvdata (struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return dev->driver_data;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
dev_set_drvdata (struct device *dev, void *data)
|
|
|
|
|
{
|
|
|
|
|
dev->driver_data = data;
|
|
|
|
|
}
|
|
|
|
|
|
2005-09-22 07:47:24 +00:00
|
|
|
static inline int device_is_registered(struct device *dev)
|
|
|
|
|
{
|
2006-09-18 20:22:34 +00:00
|
|
|
return dev->is_registered;
|
2005-09-22 07:47:24 +00:00
|
|
|
}
|
|
|
|
|
|
2006-12-19 21:01:28 +00:00
|
|
|
void driver_init(void);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* High level routines for use by the bus drivers
|
|
|
|
|
*/
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check device_register(struct device * dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void device_unregister(struct device * dev);
|
|
|
|
|
extern void device_initialize(struct device * dev);
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check device_add(struct device * dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void device_del(struct device * dev);
|
2006-10-22 14:57:18 +00:00
|
|
|
extern int device_for_each_child(struct device *, void *,
|
2005-04-16 22:20:36 +00:00
|
|
|
int (*fn)(struct device *, void *));
|
2006-11-16 14:42:07 +00:00
|
|
|
extern struct device *device_find_child(struct device *, void *data,
|
|
|
|
|
int (*match)(struct device *, void *));
|
2006-07-03 21:31:12 +00:00
|
|
|
extern int device_rename(struct device *dev, char *new_name);
|
2006-11-20 16:07:51 +00:00
|
|
|
extern int device_move(struct device *dev, struct device *new_parent);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Manual binding of a device to driver. See drivers/base/bus.c
|
|
|
|
|
* for information on use.
|
|
|
|
|
*/
|
2006-08-15 05:43:20 +00:00
|
|
|
extern int __must_check device_bind_driver(struct device *dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void device_release_driver(struct device * dev);
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check device_attach(struct device * dev);
|
2006-08-15 05:43:20 +00:00
|
|
|
extern int __must_check driver_attach(struct device_driver *drv);
|
|
|
|
|
extern int __must_check device_reprobe(struct device *dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-14 19:14:34 +00:00
|
|
|
/*
|
|
|
|
|
* Easy functions for dynamically creating devices on the fly
|
|
|
|
|
*/
|
|
|
|
|
extern struct device *device_create(struct class *cls, struct device *parent,
|
2006-08-10 05:19:19 +00:00
|
|
|
dev_t devt, const char *fmt, ...)
|
2006-06-14 19:14:34 +00:00
|
|
|
__attribute__((format(printf,4,5)));
|
|
|
|
|
extern void device_destroy(struct class *cls, dev_t devt);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Platform "fixup" functions - allow the platform to have their say
|
|
|
|
|
* about devices and actions that the general device layer doesn't
|
|
|
|
|
* know about.
|
|
|
|
|
*/
|
|
|
|
|
/* Notify platform of device discovery */
|
|
|
|
|
extern int (*platform_notify)(struct device * dev);
|
|
|
|
|
|
|
|
|
|
extern int (*platform_notify_remove)(struct device * dev);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* get_device - atomically increment the reference count for the device.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
extern struct device * get_device(struct device * dev);
|
|
|
|
|
extern void put_device(struct device * dev);
|
|
|
|
|
|
|
|
|
|
|
2006-03-21 23:58:53 +00:00
|
|
|
/* drivers/base/power/shutdown.c */
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void device_shutdown(void);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* drivers/base/firmware.c */
|
2006-08-15 05:43:17 +00:00
|
|
|
extern int __must_check firmware_register(struct subsystem *);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void firmware_unregister(struct subsystem *);
|
|
|
|
|
|
|
|
|
|
/* debugging and troubleshooting/diagnostic helpers. */
|
2006-06-16 21:10:48 +00:00
|
|
|
extern const char *dev_driver_string(struct device *dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
#define dev_printk(level, dev, format, arg...) \
|
2006-06-16 21:10:48 +00:00
|
|
|
printk(level "%s %s: " format , dev_driver_string(dev) , (dev)->bus_id , ## arg)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
#define dev_dbg(dev, format, arg...) \
|
|
|
|
|
dev_printk(KERN_DEBUG , dev , format , ## arg)
|
|
|
|
|
#else
|
|
|
|
|
#define dev_dbg(dev, format, arg...) do { (void)(dev); } while (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define dev_err(dev, format, arg...) \
|
|
|
|
|
dev_printk(KERN_ERR , dev , format , ## arg)
|
|
|
|
|
#define dev_info(dev, format, arg...) \
|
|
|
|
|
dev_printk(KERN_INFO , dev , format , ## arg)
|
|
|
|
|
#define dev_warn(dev, format, arg...) \
|
|
|
|
|
dev_printk(KERN_WARNING , dev , format , ## arg)
|
2006-02-24 10:05:45 +00:00
|
|
|
#define dev_notice(dev, format, arg...) \
|
|
|
|
|
dev_printk(KERN_NOTICE , dev , format , ## arg)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* Create alias, so I can be autoloaded. */
|
|
|
|
|
#define MODULE_ALIAS_CHARDEV(major,minor) \
|
|
|
|
|
MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
|
|
|
|
|
#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
|
|
|
|
|
MODULE_ALIAS("char-major-" __stringify(major) "-*")
|
|
|
|
|
#endif /* _DEVICE_H_ */
|