/* * device.h - generic, centralized driver model * * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org> * * 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>#include <linux/klist.h>#include <linux/list.h>#include <linux/compiler.h>#include <linux/types.h>#include <linux/module.h>#include <linux/pm.h>#include <asm/semaphore.h>#include <asm/atomic.h>#include <asm/device.h>#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_LENstruct device;struct device_driver;struct class;struct class_device;struct bus_type {	const char		* name;	struct subsystem	subsys;	struct kset		drivers;	struct kset		devices;	struct klist		klist_devices;	struct klist		klist_drivers;	struct blocking_notifier_head bus_notifier;	struct bus_attribute	* bus_attrs;	struct device_attribute	* dev_attrs;	struct driver_attribute	* drv_attrs;	int		(*match)(struct device * dev, struct device_driver * drv);	int		(*uevent)(struct device *dev, char **envp,				  int num_envp, char *buffer, int buffer_size);	int		(*probe)(struct device * dev);	int		(*remove)(struct device * dev);	void		(*shutdown)(struct device * dev);	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);};extern int __must_check bus_register(struct bus_type * bus);extern void bus_unregister(struct bus_type * bus);extern int __must_check bus_rescan_devices(struct bus_type * bus);/* iterator helpers for buses */int bus_for_each_dev(struct bus_type * bus, struct device * start, void * data,		     int (*fn)(struct device *, void *));struct device * bus_find_device(struct bus_type *bus, struct device *start,				void *data, int (*match)(struct device *, void *));int __must_check bus_for_each_drv(struct bus_type *bus,		struct device_driver *start, void *data,		int (*fn)(struct device_driver *, void *));/* * 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 *//* driverfs interface for exporting bus attributes */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 *);struct device_driver {	const char		* name;	struct bus_type		* bus;	struct completion	unloaded;	struct kobject		kobj;	struct klist		klist_devices;	struct klist_node	knode_bus;	struct module		* owner;	int	(*probe)	(struct device * dev);	int	(*remove)	(struct device * dev);	void	(*shutdown)	(struct device * dev);	int	(*suspend)	(struct device * dev, pm_message_t state);	int	(*resume)	(struct device * dev);	unsigned int multithread_probe:1;};extern int __must_check driver_register(struct device_driver * drv);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);extern int driver_probe_done(void);/* driverfs interface for exporting driver attributes */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)extern int __must_check driver_create_file(struct device_driver *,					struct driver_attribute *);extern void driver_remove_file(struct device_driver *, struct driver_attribute *);extern int __must_check driver_for_each_device(struct device_driver * drv,		struct device *start, void *data,		int (*fn)(struct device *, void *));struct device * driver_find_device(struct device_driver *drv,				   struct device *start, void *data,				   int (*match)(struct device *, void *));/* * device classes */struct class {	const char		* name;	struct module		* owner;	struct subsystem	subsys;	struct list_head	children;	struct list_head	devices;	struct list_head	interfaces;	struct semaphore	sem;	/* locks both the children and interfaces lists */	struct kobject		*virtual_dir;	struct class_attribute		* class_attrs;	struct class_device_attribute	* class_dev_attrs;	struct device_attribute		* dev_attrs;	int	(*uevent)(struct class_device *dev, char **envp,			   int num_envp, char *buffer, int buffer_size);	int	(*dev_uevent)(struct device *dev, char **envp, int num_envp,				char *buffer, int buffer_size);	void	(*release)(struct class_device *dev);	void	(*class_release)(struct class *class);	void	(*dev_release)(struct device *dev);	int	(*suspend)(struct device *, pm_message_t state);	int	(*resume)(struct device *);};extern int __must_check class_register(struct class *);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) extern int __must_check class_create_file(struct class *,					const struct class_attribute *);extern void class_remove_file(struct class *, const struct class_attribute *);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)extern int __must_check class_device_create_file(struct class_device *,				    const struct class_device_attribute *);/** * 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. * @groups: optional additional groups to be created * @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. * @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 * when you are nesting class_device structures. */struct class_device {	struct list_head	node;	struct kobject		kobj;	struct class		* class;	/* required */	dev_t			devt;		/* dev_t, creates the sysfs "dev" */	struct class_device_attribute *devt_attr;