home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / linux / device.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  14.0 KB  |  438 lines
  1. /*
  2.  * device.h - generic, centralized driver model
  3.  *
  4.  * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
  5.  *
  6.  * This file is released under the GPLv2
  7.  *
  8.  * See Documentation/driver-model/ for more information.
  9.  */
  10.  
  11. #ifndef _DEVICE_H_
  12. #define _DEVICE_H_
  13.  
  14. #include <linux/ioport.h>
  15. #include <linux/kobject.h>
  16. #include <linux/klist.h>
  17. #include <linux/list.h>
  18. #include <linux/types.h>
  19. #include <linux/module.h>
  20. #include <linux/pm.h>
  21. #include <asm/semaphore.h>
  22. #include <asm/atomic.h>
  23.  
  24. #define DEVICE_NAME_SIZE    50
  25. #define DEVICE_NAME_HALF    __stringify(20)    /* Less than half to accommodate slop */
  26. #define DEVICE_ID_SIZE        32
  27. #define BUS_ID_SIZE        KOBJ_NAME_LEN
  28.  
  29.  
  30. struct device;
  31. struct device_driver;
  32. struct class;
  33. struct class_device;
  34.  
  35. struct bus_type {
  36.     const char        * name;
  37.  
  38.     struct subsystem    subsys;
  39.     struct kset        drivers;
  40.     struct kset        devices;
  41.     struct klist        klist_devices;
  42.     struct klist        klist_drivers;
  43.  
  44.     struct bus_attribute    * bus_attrs;
  45.     struct device_attribute    * dev_attrs;
  46.     struct driver_attribute    * drv_attrs;
  47.  
  48.     int        (*match)(struct device * dev, struct device_driver * drv);
  49.     int        (*uevent)(struct device *dev, char **envp,
  50.                   int num_envp, char *buffer, int buffer_size);
  51.     int        (*probe)(struct device * dev);
  52.     int        (*remove)(struct device * dev);
  53.     void        (*shutdown)(struct device * dev);
  54.     int        (*suspend)(struct device * dev, pm_message_t state);
  55.     int        (*resume)(struct device * dev);
  56. };
  57.  
  58. extern int bus_register(struct bus_type * bus);
  59. extern void bus_unregister(struct bus_type * bus);
  60.  
  61. extern void bus_rescan_devices(struct bus_type * bus);
  62.  
  63. extern struct bus_type * get_bus(struct bus_type * bus);
  64. extern void put_bus(struct bus_type * bus);
  65.  
  66. extern struct bus_type * find_bus(char * name);
  67.  
  68. /* iterator helpers for buses */
  69.  
  70. int bus_for_each_dev(struct bus_type * bus, struct device * start, void * data,
  71.              int (*fn)(struct device *, void *));
  72. struct device * bus_find_device(struct bus_type *bus, struct device *start,
  73.                 void *data, int (*match)(struct device *, void *));
  74.  
  75. int bus_for_each_drv(struct bus_type * bus, struct device_driver * start, 
  76.              void * data, int (*fn)(struct device_driver *, void *));
  77.  
  78.  
  79. /* driverfs interface for exporting bus attributes */
  80.  
  81. struct bus_attribute {
  82.     struct attribute    attr;
  83.     ssize_t (*show)(struct bus_type *, char * buf);
  84.     ssize_t (*store)(struct bus_type *, const char * buf, size_t count);
  85. };
  86.  
  87. #define BUS_ATTR(_name,_mode,_show,_store)    \
  88. struct bus_attribute bus_attr_##_name = __ATTR(_name,_mode,_show,_store)
  89.  
  90. extern int bus_create_file(struct bus_type *, struct bus_attribute *);
  91. extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
  92.  
  93. struct device_driver {
  94.     const char        * name;
  95.     struct bus_type        * bus;
  96.  
  97.     struct completion    unloaded;
  98.     struct kobject        kobj;
  99.     struct klist        klist_devices;
  100.     struct klist_node    knode_bus;
  101.  
  102.     struct module        * owner;
  103.  
  104.     int    (*probe)    (struct device * dev);
  105.     int    (*remove)    (struct device * dev);
  106.     void    (*shutdown)    (struct device * dev);
  107.     int    (*suspend)    (struct device * dev, pm_message_t state);
  108.     int    (*resume)    (struct device * dev);
  109. };
  110.  
  111.  
  112. extern int driver_register(struct device_driver * drv);
  113. extern void driver_unregister(struct device_driver * drv);
  114.  
  115. extern struct device_driver * get_driver(struct device_driver * drv);
  116. extern void put_driver(struct device_driver * drv);
  117. extern struct device_driver *driver_find(const char *name, struct bus_type *bus);
  118.  
  119.  
  120. /* driverfs interface for exporting driver attributes */
  121.  
  122. struct driver_attribute {
  123.     struct attribute    attr;
  124.     ssize_t (*show)(struct device_driver *, char * buf);
  125.     ssize_t (*store)(struct device_driver *, const char * buf, size_t count);
  126. };
  127.  
  128. #define DRIVER_ATTR(_name,_mode,_show,_store)    \
  129. struct driver_attribute driver_attr_##_name = __ATTR(_name,_mode,_show,_store)
  130.  
  131. extern int driver_create_file(struct device_driver *, struct driver_attribute *);
  132. extern void driver_remove_file(struct device_driver *, struct driver_attribute *);
  133.  
  134. extern int driver_for_each_device(struct device_driver * drv, struct device * start,
  135.                   void * data, int (*fn)(struct device *, void *));
  136. struct device * driver_find_device(struct device_driver *drv,
  137.                    struct device *start, void *data,
  138.                    int (*match)(struct device *, void *));
  139.  
  140.  
  141. /*
  142.  * device classes
  143.  */
  144. struct class {
  145.     const char        * name;
  146.     struct module        * owner;
  147.  
  148.     struct subsystem    subsys;
  149.     struct list_head    children;
  150.     struct list_head    interfaces;
  151.     struct semaphore    sem;    /* locks both the children and interfaces lists */
  152.  
  153.     struct class_attribute        * class_attrs;
  154.     struct class_device_attribute    * class_dev_attrs;
  155.  
  156.     int    (*uevent)(struct class_device *dev, char **envp,
  157.                int num_envp, char *buffer, int buffer_size);
  158.  
  159.     void    (*release)(struct class_device *dev);
  160.     void    (*class_release)(struct class *class);
  161. };
  162.  
  163. extern int class_register(struct class *);
  164. extern void class_unregister(struct class *);
  165.  
  166. extern struct class * class_get(struct class *);
  167. extern void class_put(struct class *);
  168.  
  169.  
  170. struct class_attribute {
  171.     struct attribute    attr;
  172.     ssize_t (*show)(struct class *, char * buf);
  173.     ssize_t (*store)(struct class *, const char * buf, size_t count);
  174. };
  175.  
  176. #define CLASS_ATTR(_name,_mode,_show,_store)            \
  177. struct class_attribute class_attr_##_name = __ATTR(_name,_mode,_show,_store) 
  178.  
  179. extern int class_create_file(struct class *, const struct class_attribute *);
  180. extern void class_remove_file(struct class *, const struct class_attribute *);
  181.  
  182. struct class_device_attribute {
  183.     struct attribute    attr;
  184.     ssize_t (*show)(struct class_device *, char * buf);
  185.     ssize_t (*store)(struct class_device *, const char * buf, size_t count);
  186. };
  187.  
  188. #define CLASS_DEVICE_ATTR(_name,_mode,_show,_store)        \
  189. struct class_device_attribute class_device_attr_##_name =     \
  190.     __ATTR(_name,_mode,_show,_store)
  191.  
  192. extern int class_device_create_file(struct class_device *,
  193.                     const struct class_device_attribute *);
  194.  
  195. /**
  196.  * struct class_device - class devices
  197.  * @class: pointer to the parent class for this class device.  This is required.
  198.  * @devt: for internal use by the driver core only.
  199.  * @node: for internal use by the driver core only.
  200.  * @kobj: for internal use by the driver core only.
  201.  * @devt_attr: for internal use by the driver core only.
  202.  * @groups: optional additional groups to be created
  203.  * @dev: if set, a symlink to the struct device is created in the sysfs
  204.  * directory for this struct class device.
  205.  * @class_data: pointer to whatever you want to store here for this struct
  206.  * class_device.  Use class_get_devdata() and class_set_devdata() to get and
  207.  * set this pointer.
  208.  * @parent: pointer to a struct class_device that is the parent of this struct
  209.  * class_device.  If NULL, this class_device will show up at the root of the
  210.  * struct class in sysfs (which is probably what you want to have happen.)
  211.  * @release: pointer to a release function for this struct class_device.  If
  212.  * set, this will be called instead of the class specific release function.
  213.  * Only use this if you want to override the default release function, like
  214.  * when you are nesting class_device structures.
  215.  * @uevent: pointer to a uevent function for this struct class_device.  If
  216.  * set, this will be called instead of the class specific uevent function.
  217.  * Only use this if you want to override the default uevent function, like
  218.  * when you are nesting class_device structures.
  219.  */
  220. struct class_device {
  221.     struct list_head    node;
  222.  
  223.     struct kobject        kobj;
  224.     struct class        * class;    /* required */
  225.     dev_t            devt;        /* dev_t, creates the sysfs "dev" */
  226.     struct class_device_attribute *devt_attr;
  227.     struct class_device_attribute uevent_attr;
  228.     struct device        * dev;        /* not necessary, but nice to have */
  229.     void            * class_data;    /* class-specific data */
  230.     struct class_device    *parent;    /* parent of this child device, if there is one */
  231.     struct attribute_group  ** groups;    /* optional groups */
  232.  
  233.     void    (*release)(struct class_device *dev);
  234.     int    (*uevent)(struct class_device *dev, char **envp,
  235.                int num_envp, char *buffer, int buffer_size);
  236.     char    class_id[BUS_ID_SIZE];    /* unique to this class */
  237. };
  238.  
  239. static inline void *
  240. class_get_devdata (struct class_device *dev)
  241. {
  242.     return dev->class_data;
  243. }
  244.  
  245. static inline void
  246. class_set_devdata (struct class_device *dev, void *data)
  247. {
  248.     dev->class_data = data;
  249. }
  250.  
  251.  
  252. extern int class_device_register(struct class_device *);
  253. extern void class_device_unregister(struct class_device *);
  254. extern void class_device_initialize(struct class_device *);
  255. extern int class_device_add(struct class_device *);
  256. extern void class_device_del(struct class_device *);
  257.  
  258. extern int class_device_rename(struct class_device *, char *);
  259.  
  260. extern struct class_device * class_device_get(struct class_device *);
  261. extern void class_device_put(struct class_device *);
  262.  
  263. extern void class_device_remove_file(struct class_device *, 
  264.                      const struct class_device_attribute *);
  265. extern int class_device_create_bin_file(struct class_device *,
  266.                     struct bin_attribute *);
  267. extern void class_device_remove_bin_file(struct class_device *,
  268.                      struct bin_attribute *);
  269.  
  270. struct class_interface {
  271.     struct list_head    node;
  272.     struct class        *class;
  273.  
  274.     int (*add)    (struct class_device *, struct class_interface *);
  275.     void (*remove)    (struct class_device *, struct class_interface *);
  276. };
  277.  
  278. extern int class_interface_register(struct class_interface *);
  279. extern void class_interface_unregister(struct class_interface *);
  280.  
  281. extern struct class *class_create(struct module *owner, char *name);
  282. extern void class_destroy(struct class *cls);
  283. extern struct class_device *class_device_create(struct class *cls,
  284.                         struct class_device *parent,
  285.                         dev_t devt,
  286.                         struct device *device,
  287.                         char *fmt, ...)
  288.                     __attribute__((format(printf,5,6)));
  289. extern void class_device_destroy(struct class *cls, dev_t devt);
  290.  
  291.  
  292. /* interface for exporting device attributes */
  293. struct device_attribute {
  294.     struct attribute    attr;
  295.     ssize_t (*show)(struct device *dev, struct device_attribute *attr,
  296.             char *buf);
  297.     ssize_t (*store)(struct device *dev, struct device_attribute *attr,
  298.              const char *buf, size_t count);
  299. };
  300.  
  301. #define DEVICE_ATTR(_name,_mode,_show,_store) \
  302. struct device_attribute dev_attr_##_name = __ATTR(_name,_mode,_show,_store)
  303.  
  304. extern int device_create_file(struct device *device, struct device_attribute * entry);
  305. extern void device_remove_file(struct device * dev, struct device_attribute * attr);
  306. struct device {
  307.     struct klist        klist_children;
  308.     struct klist_node    knode_parent;        /* node in sibling list */
  309.     struct klist_node    knode_driver;
  310.     struct klist_node    knode_bus;
  311.     struct device     * parent;
  312.  
  313.     struct kobject kobj;
  314.     char    bus_id[BUS_ID_SIZE];    /* position on parent bus */
  315.     struct device_attribute uevent_attr;
  316.  
  317.     struct semaphore    sem;    /* semaphore to synchronize calls to
  318.                      * its driver.
  319.                      */
  320.  
  321.     struct bus_type    * bus;        /* type of bus device is on */
  322.     struct device_driver *driver;    /* which driver has allocated this
  323.                        device */
  324.     void        *driver_data;    /* data private to the driver */
  325.     void        *platform_data;    /* Platform specific data, device
  326.                        core doesn't touch it */
  327.     void        *firmware_data; /* Firmware specific data (e.g. ACPI,
  328.                        BIOS data),reserved for device core*/
  329.     struct dev_pm_info    power;
  330.  
  331.     u64        *dma_mask;    /* dma mask (if dma'able device) */
  332.     u64        coherent_dma_mask;/* Like dma_mask, but for
  333.                          alloc_coherent mappings as
  334.                          not all hardware supports
  335.                          64 bit addresses for consistent
  336.                          allocations such descriptors. */
  337.  
  338.     struct list_head    dma_pools;    /* dma pools (if dma'ble) */
  339.  
  340.     struct dma_coherent_mem    *dma_mem; /* internal for coherent mem
  341.                          override */
  342.  
  343.     void    (*release)(struct device * dev);
  344. };
  345.  
  346. static inline void *
  347. dev_get_drvdata (struct device *dev)
  348. {
  349.     return dev->driver_data;
  350. }
  351.  
  352. static inline void
  353. dev_set_drvdata (struct device *dev, void *data)
  354. {
  355.     dev->driver_data = data;
  356. }
  357.  
  358. static inline int device_is_registered(struct device *dev)
  359. {
  360.     return klist_node_attached(&dev->knode_bus);
  361. }
  362.  
  363. /*
  364.  * High level routines for use by the bus drivers
  365.  */
  366. extern int device_register(struct device * dev);
  367. extern void device_unregister(struct device * dev);
  368. extern void device_initialize(struct device * dev);
  369. extern int device_add(struct device * dev);
  370. extern void device_del(struct device * dev);
  371. extern int device_for_each_child(struct device *, void *,
  372.              int (*fn)(struct device *, void *));
  373.  
  374. /*
  375.  * Manual binding of a device to driver. See drivers/base/bus.c
  376.  * for information on use.
  377.  */
  378. extern void device_bind_driver(struct device * dev);
  379. extern void device_release_driver(struct device * dev);
  380. extern int  device_attach(struct device * dev);
  381. extern void driver_attach(struct device_driver * drv);
  382. extern void device_reprobe(struct device *dev);
  383.  
  384.  
  385. /*
  386.  * Platform "fixup" functions - allow the platform to have their say
  387.  * about devices and actions that the general device layer doesn't
  388.  * know about.
  389.  */
  390. /* Notify platform of device discovery */
  391. extern int (*platform_notify)(struct device * dev);
  392.  
  393. extern int (*platform_notify_remove)(struct device * dev);
  394.  
  395.  
  396. /**
  397.  * get_device - atomically increment the reference count for the device.
  398.  *
  399.  */
  400. extern struct device * get_device(struct device * dev);
  401. extern void put_device(struct device * dev);
  402.  
  403.  
  404. /* drivers/base/power/shutdown.c */
  405. extern void device_shutdown(void);
  406.  
  407.  
  408. /* drivers/base/firmware.c */
  409. extern int firmware_register(struct subsystem *);
  410. extern void firmware_unregister(struct subsystem *);
  411.  
  412. /* debugging and troubleshooting/diagnostic helpers. */
  413. #define dev_printk(level, dev, format, arg...)    \
  414.     printk(level "%s %s: " format , (dev)->driver ? (dev)->driver->name : "" , (dev)->bus_id , ## arg)
  415.  
  416. #ifdef DEBUG
  417. #define dev_dbg(dev, format, arg...)        \
  418.     dev_printk(KERN_DEBUG , dev , format , ## arg)
  419. #else
  420. #define dev_dbg(dev, format, arg...) do { (void)(dev); } while (0)
  421. #endif
  422.  
  423. #define dev_err(dev, format, arg...)        \
  424.     dev_printk(KERN_ERR , dev , format , ## arg)
  425. #define dev_info(dev, format, arg...)        \
  426.     dev_printk(KERN_INFO , dev , format , ## arg)
  427. #define dev_warn(dev, format, arg...)        \
  428.     dev_printk(KERN_WARNING , dev , format , ## arg)
  429. #define dev_notice(dev, format, arg...)        \
  430.     dev_printk(KERN_NOTICE , dev , format , ## arg)
  431.  
  432. /* Create alias, so I can be autoloaded. */
  433. #define MODULE_ALIAS_CHARDEV(major,minor) \
  434.     MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
  435. #define MODULE_ALIAS_CHARDEV_MAJOR(major) \
  436.     MODULE_ALIAS("char-major-" __stringify(major) "-*")
  437. #endif /* _DEVICE_H_ */
  438.