[GitHub/LineageOS/android_kernel_samsung_universal7580.git] / include / linux / device.h

/*
 * device.h - generic, centralized driver model
 *
 * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
 * Copyright (c) 2004-2007 Greg Kroah-Hartman <gregkh@suse.de>
 *
 * 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 <linux/semaphore.h>
#include <asm/atomic.h>
#include <asm/device.h>

#define DEVICE_NAME_SIZE	50
/* DEVICE_NAME_HALF is really less than half to accommodate slop */
#define DEVICE_NAME_HALF	__stringify(20)
#define DEVICE_ID_SIZE		32
#define BUS_ID_SIZE		KOBJ_NAME_LEN


struct device;
struct device_driver;
struct driver_private;
struct class;
struct bus_type;
struct bus_type_private;

struct bus_attribute {
	struct attribute	attr;
	ssize_t (*show)(struct bus_type *bus, char *buf);
	ssize_t (*store)(struct bus_type *bus, 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 bus_type {
	const char		*name;
	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, struct kobj_uevent_env *env);
	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);

	struct bus_type_private *p;
};

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 *dev, void *data));
struct device *bus_find_device(struct bus_type *bus, struct device *start,
			       void *data,
			       int (*match)(struct device *dev, void *data));
struct device *bus_find_device_by_name(struct bus_type *bus,
				       struct device *start,
				       const char *name);

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 */

extern struct kset *bus_get_kset(struct bus_type *bus);
extern struct klist *bus_get_device_klist(struct bus_type *bus);

struct device_driver {
	const char		*name;
	struct bus_type		*bus;

	struct module		*owner;
	const char 		*mod_name;	/* used for built-in modules */

	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);
	struct attribute_group **groups;

	struct driver_private *p;
};


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);

/* sysfs interface for exporting driver attributes */

struct driver_attribute {
	struct attribute attr;
	ssize_t (*show)(struct device_driver *driver, char *buf);
	ssize_t (*store)(struct device_driver *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 *driver,
					   struct driver_attribute *attr);
extern void driver_remove_file(struct device_driver *driver,
			       struct driver_attribute *attr);

extern int __must_check driver_add_kobj(struct device_driver *drv,
					struct kobject *kobj,
					const char *fmt, ...);

extern int __must_check driver_for_each_device(struct device_driver *drv,
					       struct device *start,
					       void *data,
					       int (*fn)(struct device *dev,
							 void *));
struct device *driver_find_device(struct device_driver *drv,
				  struct device *start, void *data,
				  int (*match)(struct device *dev, void *data));

/*
 * device classes
 */
struct class {
	const char		*name;
	struct module		*owner;

	struct kset		subsys;
	struct list_head	children;
	struct list_head	devices;
	struct list_head	interfaces;
	struct kset		class_dirs;
	struct semaphore	sem; /* locks children, devices, interfaces */
	struct class_attribute		*class_attrs;
	struct device_attribute		*dev_attrs;

	int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);

	void (*class_release)(struct class *class);
	void (*dev_release)(struct device *dev);

	int (*suspend)(struct device *dev, pm_message_t state);
	int (*resume)(struct device *dev);
};

extern int __must_check class_register(struct class *class);
extern void class_unregister(struct class *class);
extern int class_for_each_device(struct class *class, void *data,
				 int (*fn)(struct device *dev, void *data));
extern struct device *class_find_device(struct class *class, void *data,
					int (*match)(struct device *, void *));

struct class_attribute {
	struct attribute attr;
	ssize_t (*show)(struct class *class, char *buf);
	ssize_t (*store)(struct class *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 *class,
					  const struct class_attribute *attr);
extern void class_remove_file(struct class *class,
			      const struct class_attribute *attr);

struct class_interface {
	struct list_head	node;
	struct class		*class;

	int (*add_dev)		(struct device *, struct class_interface *);
	void (*remove_dev)	(struct device *, struct class_interface *);
};

extern int __must_check class_interface_register(struct class_interface *);
extern void class_interface_unregister(struct class_interface *);

extern struct class *class_create(struct module *owner, const char *name);
extern void class_destroy(struct class *cls);

/*
 * The type of device, "struct device" is embedded in. A class
 * or bus can contain devices of different types
 * like "partitions" and "disks", "mouse" and "event".
 * This identifies the device type and carries type-specific
 * information, equivalent to the kobj_type of a kobject.
 * If "name" is specified, the uevent will contain it in
 * the DEVTYPE variable.
 */
struct device_type {
	const char *name;
	struct attribute_group **groups;
	int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
	void (*release)(struct device *dev);
	int (*suspend)(struct device *dev, pm_message_t state);
	int (*resume)(struct device *dev);
};

/* 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)

extern int __must_check device_create_file(struct device *device,
					   struct device_attribute *entry);
extern void device_remove_file(struct device *dev,
			       struct device_attribute *attr);
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);
extern int device_schedule_callback_owner(struct device *dev,
		void (*func)(struct device *dev), struct module *owner);

/* This is a macro to avoid include problems with THIS_MODULE */
#define device_schedule_callback(dev, func)			\
	device_schedule_callback_owner(dev, func, THIS_MODULE)

/* 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);

struct device_dma_parameters {
	/*
	 * a low level driver may set these to teach IOMMU code about
	 * sg limitations.
	 */
	unsigned int max_segment_size;
	unsigned long segment_boundary_mask;
};

struct device {
	struct klist		klist_children;
	struct klist_node	knode_parent;	/* node in sibling list */
	struct klist_node	knode_driver;
	struct klist_node	knode_bus;
	struct device		*parent;

	struct kobject kobj;
	char	bus_id[BUS_ID_SIZE];	/* position on parent bus */
	struct device_type	*type;
	unsigned		uevent_suppress:1;

	struct semaphore	sem;	/* semaphore to synchronize calls to
					 * its driver.
					 */

	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 */
	void		*platform_data;	/* Platform specific data, device
					   core doesn't touch it */
	struct dev_pm_info	power;

#ifdef CONFIG_NUMA
	int		numa_node;	/* NUMA node this device is close to */
#endif
	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 device_dma_parameters *dma_parms;

	struct list_head	dma_pools;	/* dma pools (if dma'ble) */

	struct dma_coherent_mem	*dma_mem; /* internal for coherent mem
					     override */
	/* arch specific additions */
	struct dev_archdata	archdata;

	spinlock_t		devres_lock;
	struct list_head	devres_head;

	struct list_head	node;
	struct class		*class;
	dev_t			devt;	/* dev_t, creates the sysfs "dev" */
	struct attribute_group	**groups;	/* optional groups */

	void	(*release)(struct device *dev);
};

/* Get the wakeup routines, which depend on struct device */
#include <linux/pm_wakeup.h>

#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

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;
}

static inline int device_is_registered(struct device *dev)
{
	return dev->kobj.state_in_sysfs;
}

void driver_init(void);

/*
 * High level routines for use by the bus drivers
 */
extern int __must_check device_register(struct device *dev);
extern void device_unregister(struct device *dev);
extern void device_initialize(struct device *dev);
extern int __must_check device_add(struct device *dev);
extern void device_del(struct device *dev);
extern int device_for_each_child(struct device *dev, void *data,
		     int (*fn)(struct device *dev, void *data));
extern struct device *device_find_child(struct device *dev, void *data,
				int (*match)(struct device *dev, void *data));
extern int device_rename(struct device *dev, char *new_name);
extern int device_move(struct device *dev, struct device *new_parent);

/*
 * Manual binding of a device to driver. See drivers/base/bus.c
 * for information on use.
 */
extern int __must_check device_bind_driver(struct device *dev);
extern void device_release_driver(struct device *dev);
extern int  __must_check device_attach(struct device *dev);
extern int __must_check driver_attach(struct device_driver *drv);
extern int __must_check device_reprobe(struct device *dev);

/*
 * Easy functions for dynamically creating devices on the fly
 */
extern struct device *device_create(struct class *cls, struct device *parent,
				    dev_t devt, const char *fmt, ...)
				    __attribute__((format(printf, 4, 5)));
extern void device_destroy(struct class *cls, dev_t devt);

/*
 * 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);


/* drivers/base/power/shutdown.c */
extern void device_shutdown(void);

/* drivers/base/sys.c */
extern void sysdev_shutdown(void);

/* debugging and troubleshooting/diagnostic helpers. */
extern const char *dev_driver_string(struct device *dev);
#define dev_printk(level, dev, format, arg...)	\
	printk(level "%s %s: " format , dev_driver_string(dev) , \
	       (dev)->bus_id , ## arg)

#define dev_emerg(dev, format, arg...)		\
	dev_printk(KERN_EMERG , dev , format , ## arg)
#define dev_alert(dev, format, arg...)		\
	dev_printk(KERN_ALERT , dev , format , ## arg)
#define dev_crit(dev, format, arg...)		\
	dev_printk(KERN_CRIT , dev , format , ## arg)
#define dev_err(dev, format, arg...)		\
	dev_printk(KERN_ERR , dev , format , ## arg)
#define dev_warn(dev, format, arg...)		\
	dev_printk(KERN_WARNING , dev , format , ## arg)
#define dev_notice(dev, format, arg...)		\
	dev_printk(KERN_NOTICE , dev , format , ## arg)
#define dev_info(dev, format, arg...)		\
	dev_printk(KERN_INFO , dev , format , ## arg)

#ifdef DEBUG
#define dev_dbg(dev, format, arg...)		\
	dev_printk(KERN_DEBUG , dev , format , ## arg)
#else
#define dev_dbg(dev, format, arg...)		\
	({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
#endif

#ifdef VERBOSE_DEBUG
#define dev_vdbg	dev_dbg
#else

#define dev_vdbg(dev, format, arg...)		\
	({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
#endif

/* 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_ */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* device.h - generic, centralized driver model
	3	*
	4	* Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
89790fd7	5	* Copyright (c) 2004-2007 Greg Kroah-Hartman <gregkh@suse.de>
1da177e4 LT	6	*
	7	* This file is released under the GPLv2
	8	*
	9	* See Documentation/driver-model/ for more information.
	10	*/
	11
	12	#ifndef _DEVICE_H_
	13	#define _DEVICE_H_
	14
1da177e4 LT	15	#include <linux/ioport.h>
1da177e4 LT	16	#include <linux/kobject.h>
465c7a3a	17	#include <linux/klist.h>
1da177e4	18	#include <linux/list.h>
4a7fb636	19	#include <linux/compiler.h>
1da177e4 LT	20	#include <linux/types.h>
	21	#include <linux/module.h>
	22	#include <linux/pm.h>
6188e10d	23	#include <linux/semaphore.h>
1da177e4	24	#include <asm/atomic.h>
c6dbaef2	25	#include <asm/device.h>
1da177e4 LT	26
1da177e4 LT	27	#define DEVICE_NAME_SIZE 50
d462943a GKH	28	/* DEVICE_NAME_HALF is really less than half to accommodate slop */
d462943a GKH	29	#define DEVICE_NAME_HALF __stringify(20)
1da177e4 LT	30	#define DEVICE_ID_SIZE 32
	31	#define BUS_ID_SIZE KOBJ_NAME_LEN
	32
	33
1da177e4 LT	34	struct device;
1da177e4 LT	35	struct device_driver;
e5dd1278	36	struct driver_private;
1da177e4	37	struct class;
b8c5cec2	38	struct bus_type;
c6f7e72a	39	struct bus_type_private;
b8c5cec2 KS	40
	41	struct bus_attribute {
	42	struct attribute attr;
d462943a GKH	43	ssize_t (show)(struct bus_type bus, char *buf);
d462943a GKH	44	ssize_t (store)(struct bus_type bus, const char *buf, size_t count);
b8c5cec2 KS	45	};
b8c5cec2 KS	46
d462943a GKH	47	#define BUS_ATTR(_name, _mode, _show, _store) \
d462943a GKH	48	struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
b8c5cec2 KS	49
	50	extern int __must_check bus_create_file(struct bus_type *,
	51	struct bus_attribute *);
	52	extern void bus_remove_file(struct bus_type , struct bus_attribute );
1da177e4 LT	53
1da177e4 LT	54	struct bus_type {
d462943a GKH	55	const char *name;
	56	struct bus_attribute *bus_attrs;
	57	struct device_attribute *dev_attrs;
	58	struct driver_attribute *drv_attrs;
	59
	60	int (match)(struct device dev, struct device_driver *drv);
	61	int (uevent)(struct device dev, struct kobj_uevent_env *env);
	62	int (probe)(struct device dev);
	63	int (remove)(struct device dev);
	64	void (shutdown)(struct device dev);
	65
	66	int (suspend)(struct device dev, pm_message_t state);
	67	int (suspend_late)(struct device dev, pm_message_t state);
	68	int (resume_early)(struct device dev);
	69	int (resume)(struct device dev);
b8c5cec2	70
c6f7e72a	71	struct bus_type_private *p;
1da177e4 LT	72	};
1da177e4 LT	73
d462943a GKH	74	extern int __must_check bus_register(struct bus_type *bus);
d462943a GKH	75	extern void bus_unregister(struct bus_type *bus);
1da177e4	76
d462943a	77	extern int __must_check bus_rescan_devices(struct bus_type *bus);
1da177e4	78
1da177e4 LT	79	/* iterator helpers for buses */
1da177e4 LT	80
d462943a GKH	81	int bus_for_each_dev(struct bus_type bus, struct device start, void *data,
	82	int (fn)(struct device dev, void *data));
	83	struct device bus_find_device(struct bus_type bus, struct device *start,
	84	void *data,
	85	int (match)(struct device dev, void *data));
1f9ffc04 GKH	86	struct device bus_find_device_by_name(struct bus_type bus,
	87	struct device *start,
	88	const char *name);
1da177e4	89
4a7fb636	90	int __must_check bus_for_each_drv(struct bus_type *bus,
d462943a GKH	91	struct device_driver start, void data,
d462943a GKH	92	int (fn)(struct device_driver , void *));
1da177e4	93
116af378 BH	94	/*
	95	* Bus notifiers: Get notified of addition/removal of devices
	96	* and binding/unbinding of drivers to devices.
	97	* In the long run, it should be a replacement for the platform
	98	* notify hooks.
	99	*/
	100	struct notifier_block;
	101
	102	extern int bus_register_notifier(struct bus_type *bus,
	103	struct notifier_block *nb);
	104	extern int bus_unregister_notifier(struct bus_type *bus,
	105	struct notifier_block *nb);
	106
	107	/* All 4 notifers below get called with the target struct device *
	108	* as an argument. Note that those functions are likely to be called
	109	* with the device semaphore held in the core, so be careful.
	110	*/
	111	#define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */
	112	#define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */
	113	#define BUS_NOTIFY_BOUND_DRIVER 0x00000003 /* driver bound to device */
	114	#define BUS_NOTIFY_UNBIND_DRIVER 0x00000004 /* driver about to be
	115	unbound */
	116
0fed80f7	117	extern struct kset bus_get_kset(struct bus_type bus);
b249072e	118	extern struct klist bus_get_device_klist(struct bus_type bus);
0fed80f7	119
1da177e4	120	struct device_driver {
e5dd1278 GKH	121	const char *name;
e5dd1278 GKH	122	struct bus_type *bus;
1da177e4	123
e5dd1278 GKH	124	struct module *owner;
e5dd1278 GKH	125	const char mod_name; / used for built-in modules */
1da177e4	126
d462943a GKH	127	int (probe) (struct device dev);
	128	int (remove) (struct device dev);
	129	void (shutdown) (struct device dev);
	130	int (suspend) (struct device dev, pm_message_t state);
	131	int (resume) (struct device dev);
57c74534	132	struct attribute_group **groups;
e5dd1278 GKH	133
e5dd1278 GKH	134	struct driver_private *p;
1da177e4 LT	135	};
	136
	137
d462943a GKH	138	extern int __must_check driver_register(struct device_driver *drv);
d462943a GKH	139	extern void driver_unregister(struct device_driver *drv);
1da177e4	140
d462943a GKH	141	extern struct device_driver get_driver(struct device_driver drv);
	142	extern void put_driver(struct device_driver *drv);
	143	extern struct device_driver driver_find(const char name,
	144	struct bus_type *bus);
d779249e	145	extern int driver_probe_done(void);
1da177e4	146
405ae7d3	147	/* sysfs interface for exporting driver attributes */
1da177e4 LT	148
1da177e4 LT	149	struct driver_attribute {
d462943a GKH	150	struct attribute attr;
	151	ssize_t (show)(struct device_driver driver, char *buf);
	152	ssize_t (store)(struct device_driver driver, const char *buf,
	153	size_t count);
1da177e4 LT	154	};
1da177e4 LT	155
d462943a GKH	156	#define DRIVER_ATTR(_name, _mode, _show, _store) \
	157	struct driver_attribute driver_attr_##_name = \
	158	__ATTR(_name, _mode, _show, _store)
1da177e4	159
d462943a GKH	160	extern int __must_check driver_create_file(struct device_driver *driver,
	161	struct driver_attribute *attr);
	162	extern void driver_remove_file(struct device_driver *driver,
	163	struct driver_attribute *attr);
1da177e4	164
cbe9c595 GKH	165	extern int __must_check driver_add_kobj(struct device_driver *drv,
	166	struct kobject *kobj,
	167	const char *fmt, ...);
	168
d462943a GKH	169	extern int __must_check driver_for_each_device(struct device_driver *drv,
	170	struct device *start,
	171	void *data,
	172	int (fn)(struct device dev,
	173	void *));
	174	struct device driver_find_device(struct device_driver drv,
	175	struct device start, void data,
	176	int (match)(struct device dev, void *data));
fae3cd00	177
1da177e4 LT	178	/*
	179	* device classes
	180	*/
	181	struct class {
d462943a GKH	182	const char *name;
d462943a GKH	183	struct module *owner;
1da177e4	184
823bccfc	185	struct kset subsys;
1da177e4	186	struct list_head children;
23681e47	187	struct list_head devices;
1da177e4	188	struct list_head interfaces;
86406245	189	struct kset class_dirs;
fd04897b	190	struct semaphore sem; /* locks children, devices, interfaces */
d462943a	191	struct class_attribute *class_attrs;
d462943a	192	struct device_attribute *dev_attrs;
1da177e4	193
d462943a	194	int (dev_uevent)(struct device dev, struct kobj_uevent_env *env);
1da177e4	195
d462943a GKH	196	void (class_release)(struct class class);
d462943a GKH	197	void (dev_release)(struct device dev);
7c8265f5	198
d462943a GKH	199	int (suspend)(struct device dev, pm_message_t state);
d462943a GKH	200	int (resume)(struct device dev);
1da177e4 LT	201	};
1da177e4 LT	202
d462943a GKH	203	extern int __must_check class_register(struct class *class);
d462943a GKH	204	extern void class_unregister(struct class *class);
fd04897b DY	205	extern int class_for_each_device(struct class class, void data,
	206	int (fn)(struct device dev, void *data));
	207	extern struct device class_find_device(struct class class, void *data,
	208	int (match)(struct device , void *));
1da177e4 LT	209
1da177e4 LT	210	struct class_attribute {
d462943a GKH	211	struct attribute attr;
	212	ssize_t (show)(struct class class, char *buf);
	213	ssize_t (store)(struct class class, const char *buf, size_t count);
1da177e4 LT	214	};
1da177e4 LT	215
d462943a GKH	216	#define CLASS_ATTR(_name, _mode, _show, _store) \
d462943a GKH	217	struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
1da177e4	218
d462943a GKH	219	extern int __must_check class_create_file(struct class *class,
	220	const struct class_attribute *attr);
	221	extern void class_remove_file(struct class *class,
	222	const struct class_attribute *attr);
1da177e4	223
1da177e4 LT	224	struct class_interface {
	225	struct list_head node;
	226	struct class *class;
	227
c47ed219 GKH	228	int (add_dev) (struct device , struct class_interface *);
c47ed219 GKH	229	void (remove_dev) (struct device , struct class_interface *);
1da177e4 LT	230	};
1da177e4 LT	231
4a7fb636	232	extern int __must_check class_interface_register(struct class_interface *);
1da177e4 LT	233	extern void class_interface_unregister(struct class_interface *);
1da177e4 LT	234
ab7d7371	235	extern struct class class_create(struct module owner, const char *name);
e9ba6365	236	extern void class_destroy(struct class *cls);
e9ba6365	237
414264f9 KS	238	/*
	239	* The type of device, "struct device" is embedded in. A class
	240	* or bus can contain devices of different types
	241	* like "partitions" and "disks", "mouse" and "event".
	242	* This identifies the device type and carries type-specific
	243	* information, equivalent to the kobj_type of a kobject.
	244	* If "name" is specified, the uevent will contain it in
	245	* the DEVTYPE variable.
	246	*/
f9f852df	247	struct device_type {
414264f9	248	const char *name;
621a1672	249	struct attribute_group **groups;
7eff2e7a	250	int (uevent)(struct device dev, struct kobj_uevent_env *env);
f9f852df	251	void (release)(struct device dev);
d462943a GKH	252	int (suspend)(struct device dev, pm_message_t state);
d462943a GKH	253	int (resume)(struct device dev);
f9f852df KS	254	};
f9f852df KS	255
a7fd6706 KS	256	/* interface for exporting device attributes */
	257	struct device_attribute {
	258	struct attribute attr;
	259	ssize_t (show)(struct device dev, struct device_attribute *attr,
	260	char *buf);
	261	ssize_t (store)(struct device dev, struct device_attribute *attr,
	262	const char *buf, size_t count);
	263	};
	264
d462943a GKH	265	#define DEVICE_ATTR(_name, _mode, _show, _store) \
d462943a GKH	266	struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
a7fd6706	267
4a7fb636	268	extern int __must_check device_create_file(struct device *device,
d462943a GKH	269	struct device_attribute *entry);
	270	extern void device_remove_file(struct device *dev,
	271	struct device_attribute *attr);
2589f188 GKH	272	extern int __must_check device_create_bin_file(struct device *dev,
	273	struct bin_attribute *attr);
	274	extern void device_remove_bin_file(struct device *dev,
	275	struct bin_attribute *attr);
523ded71	276	extern int device_schedule_callback_owner(struct device *dev,
d462943a	277	void (func)(struct device dev), struct module *owner);
523ded71 AS	278
	279	/* This is a macro to avoid include problems with THIS_MODULE */
	280	#define device_schedule_callback(dev, func) \
	281	device_schedule_callback_owner(dev, func, THIS_MODULE)
9ac7849e TH	282
	283	/* device resource management */
	284	typedef void (dr_release_t)(struct device dev, void *res);
	285	typedef int (dr_match_t)(struct device dev, void res, void match_data);
	286
	287	#ifdef CONFIG_DEBUG_DEVRES
d462943a	288	extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
9ac7849e TH	289	const char *name);
	290	#define devres_alloc(release, size, gfp) \
	291	__devres_alloc(release, size, gfp, #release)
	292	#else
d462943a	293	extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
9ac7849e TH	294	#endif
	295	extern void devres_free(void *res);
	296	extern void devres_add(struct device dev, void res);
d462943a	297	extern void devres_find(struct device dev, dr_release_t release,
9ac7849e	298	dr_match_t match, void *match_data);
d462943a GKH	299	extern void devres_get(struct device dev, void *new_res,
	300	dr_match_t match, void *match_data);
	301	extern void devres_remove(struct device dev, dr_release_t release,
	302	dr_match_t match, void *match_data);
9ac7849e TH	303	extern int devres_destroy(struct device *dev, dr_release_t release,
	304	dr_match_t match, void *match_data);
	305
	306	/* devres group */
	307	extern void * __must_check devres_open_group(struct device dev, void id,
	308	gfp_t gfp);
	309	extern void devres_close_group(struct device dev, void id);
	310	extern void devres_remove_group(struct device dev, void id);
	311	extern int devres_release_group(struct device dev, void id);
	312
	313	/* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
	314	extern void devm_kzalloc(struct device dev, size_t size, gfp_t gfp);
	315	extern void devm_kfree(struct device dev, void p);
	316
6b7b6510 FT	317	struct device_dma_parameters {
	318	/*
	319	* a low level driver may set these to teach IOMMU code about
	320	* sg limitations.
	321	*/
	322	unsigned int max_segment_size;
	323	unsigned long segment_boundary_mask;
	324	};
	325
1da177e4	326	struct device {
36239577	327	struct klist klist_children;
d462943a	328	struct klist_node knode_parent; /* node in sibling list */
94e7b1c5	329	struct klist_node knode_driver;
465c7a3a	330	struct klist_node knode_bus;
49a4ec18	331	struct device *parent;
1da177e4 LT	332
	333	struct kobject kobj;
	334	char bus_id[BUS_ID_SIZE]; /* position on parent bus */
f9f852df	335	struct device_type *type;
49a4ec18	336	unsigned uevent_suppress:1;
1da177e4	337
af70316a PM	338	struct semaphore sem; /* semaphore to synchronize calls to
	339	* its driver.
	340	*/
	341
d462943a	342	struct bus_type bus; / type of bus device is on */
1da177e4 LT	343	struct device_driver driver; / which driver has allocated this
	344	device */
	345	void driver_data; / data private to the driver */
4e10d12a DSL	346	void platform_data; / Platform specific data, device
4e10d12a DSL	347	core doesn't touch it */
1da177e4 LT	348	struct dev_pm_info power;
1da177e4 LT	349
87348136 CH	350	#ifdef CONFIG_NUMA
	351	int numa_node; /* NUMA node this device is close to */
	352	#endif
1da177e4 LT	353	u64 dma_mask; / dma mask (if dma'able device) */
	354	u64 coherent_dma_mask;/* Like dma_mask, but for
	355	alloc_coherent mappings as
	356	not all hardware supports
	357	64 bit addresses for consistent
	358	allocations such descriptors. */
	359
6b7b6510 FT	360	struct device_dma_parameters *dma_parms;
6b7b6510 FT	361
1da177e4 LT	362	struct list_head dma_pools; /* dma pools (if dma'ble) */
	363
	364	struct dma_coherent_mem dma_mem; / internal for coherent mem
	365	override */
c6dbaef2 BH	366	/* arch specific additions */
c6dbaef2 BH	367	struct dev_archdata archdata;
1da177e4	368
9ac7849e TH	369	spinlock_t devres_lock;
	370	struct list_head devres_head;
	371
23681e47	372	struct list_head node;
b7a3e813	373	struct class *class;
d462943a	374	dev_t devt; /* dev_t, creates the sysfs "dev" */
de0ff00d	375	struct attribute_group *groups; / optional groups */
23681e47	376
d462943a	377	void (release)(struct device dev);
1da177e4 LT	378	};
1da177e4 LT	379
9a3df1f7 AS	380	/* Get the wakeup routines, which depend on struct device */
	381	#include <linux/pm_wakeup.h>
	382
87348136 CH	383	#ifdef CONFIG_NUMA
	384	static inline int dev_to_node(struct device *dev)
	385	{
	386	return dev->numa_node;
	387	}
	388	static inline void set_dev_node(struct device *dev, int node)
	389	{
	390	dev->numa_node = node;
	391	}
	392	#else
	393	static inline int dev_to_node(struct device *dev)
	394	{
	395	return -1;
	396	}
	397	static inline void set_dev_node(struct device *dev, int node)
	398	{
	399	}
	400	#endif
	401
d462943a	402	static inline void dev_get_drvdata(struct device dev)
1da177e4 LT	403	{
	404	return dev->driver_data;
	405	}
	406
d462943a	407	static inline void dev_set_drvdata(struct device dev, void data)
1da177e4 LT	408	{
	409	dev->driver_data = data;
	410	}
	411
d305ef5d DR	412	static inline int device_is_registered(struct device *dev)
d305ef5d DR	413	{
3f62e570	414	return dev->kobj.state_in_sysfs;
d305ef5d DR	415	}
d305ef5d DR	416
1f21782e AB	417	void driver_init(void);
1f21782e AB	418
1da177e4 LT	419	/*
	420	* High level routines for use by the bus drivers
	421	*/
d462943a GKH	422	extern int __must_check device_register(struct device *dev);
	423	extern void device_unregister(struct device *dev);
	424	extern void device_initialize(struct device *dev);
	425	extern int __must_check device_add(struct device *dev);
	426	extern void device_del(struct device *dev);
	427	extern int device_for_each_child(struct device dev, void data,
	428	int (fn)(struct device dev, void *data));
	429	extern struct device device_find_child(struct device dev, void *data,
	430	int (match)(struct device dev, void *data));
a2de48ca	431	extern int device_rename(struct device dev, char new_name);
8a82472f	432	extern int device_move(struct device dev, struct device new_parent);
1da177e4 LT	433
	434	/*
	435	* Manual binding of a device to driver. See drivers/base/bus.c
	436	* for information on use.
	437	*/
f86db396	438	extern int __must_check device_bind_driver(struct device *dev);
d462943a GKH	439	extern void device_release_driver(struct device *dev);
d462943a GKH	440	extern int __must_check device_attach(struct device *dev);
f86db396 AM	441	extern int __must_check driver_attach(struct device_driver *drv);
f86db396 AM	442	extern int __must_check device_reprobe(struct device *dev);
1da177e4	443
23681e47 GKH	444	/*
	445	* Easy functions for dynamically creating devices on the fly
	446	*/
	447	extern struct device device_create(struct class cls, struct device *parent,
5cbe5f8a	448	dev_t devt, const char *fmt, ...)
d462943a	449	__attribute__((format(printf, 4, 5)));
23681e47	450	extern void device_destroy(struct class *cls, dev_t devt);
1da177e4	451
1da177e4 LT	452	/*
	453	* Platform "fixup" functions - allow the platform to have their say
	454	* about devices and actions that the general device layer doesn't
	455	* know about.
	456	*/
	457	/* Notify platform of device discovery */
d462943a	458	extern int (platform_notify)(struct device dev);
1da177e4	459
d462943a	460	extern int (platform_notify_remove)(struct device dev);
1da177e4 LT	461
	462
	463	/**
	464	* get_device - atomically increment the reference count for the device.
	465	*
	466	*/
d462943a GKH	467	extern struct device get_device(struct device dev);
d462943a GKH	468	extern void put_device(struct device *dev);
1da177e4 LT	469
1da177e4 LT	470
116f232b	471	/* drivers/base/power/shutdown.c */
1da177e4 LT	472	extern void device_shutdown(void);
1da177e4 LT	473
58b3b71d RW	474	/* drivers/base/sys.c */
	475	extern void sysdev_shutdown(void);
	476
1da177e4	477	/* debugging and troubleshooting/diagnostic helpers. */
3e95637a	478	extern const char dev_driver_string(struct device dev);
1da177e4	479	#define dev_printk(level, dev, format, arg...) \
d462943a GKH	480	printk(level "%s %s: " format , dev_driver_string(dev) , \
d462943a GKH	481	(dev)->bus_id , ## arg)
1da177e4	482
7b8712e5 EM	483	#define dev_emerg(dev, format, arg...) \
	484	dev_printk(KERN_EMERG , dev , format , ## arg)
	485	#define dev_alert(dev, format, arg...) \
	486	dev_printk(KERN_ALERT , dev , format , ## arg)
	487	#define dev_crit(dev, format, arg...) \
	488	dev_printk(KERN_CRIT , dev , format , ## arg)
	489	#define dev_err(dev, format, arg...) \
	490	dev_printk(KERN_ERR , dev , format , ## arg)
	491	#define dev_warn(dev, format, arg...) \
	492	dev_printk(KERN_WARNING , dev , format , ## arg)
	493	#define dev_notice(dev, format, arg...) \
	494	dev_printk(KERN_NOTICE , dev , format , ## arg)
	495	#define dev_info(dev, format, arg...) \
	496	dev_printk(KERN_INFO , dev , format , ## arg)
	497
1da177e4 LT	498	#ifdef DEBUG
	499	#define dev_dbg(dev, format, arg...) \
	500	dev_printk(KERN_DEBUG , dev , format , ## arg)
	501	#else
1429db83 JP	502	#define dev_dbg(dev, format, arg...) \
1429db83 JP	503	({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
1da177e4 LT	504	#endif
1da177e4 LT	505
aebdc3b4 DB	506	#ifdef VERBOSE_DEBUG
	507	#define dev_vdbg dev_dbg
	508	#else
1429db83 JP	509
	510	#define dev_vdbg(dev, format, arg...) \
	511	({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
aebdc3b4 DB	512	#endif
aebdc3b4 DB	513
1da177e4 LT	514	/* Create alias, so I can be autoloaded. */
	515	#define MODULE_ALIAS_CHARDEV(major,minor) \
	516	MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
	517	#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
	518	MODULE_ALIAS("char-major-" __stringify(major) "-*")
	519	#endif /* _DEVICE_H_ */