[linux-2.6-block.git] / include / acpi / acpi_bus.h

/*
 *  acpi_bus.h - ACPI Bus Driver ($Revision: 22 $)
 *
 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or (at
 *  your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#ifndef __ACPI_BUS_H__
#define __ACPI_BUS_H__

#include <linux/kobject.h>

#include <acpi/acpi.h>

#define PREFIX			"ACPI: "

/* TBD: Make dynamic */
#define ACPI_MAX_HANDLES	10
struct acpi_handle_list {
	u32			count;
	acpi_handle		handles[ACPI_MAX_HANDLES];
};


/* acpi_utils.h */
acpi_status
acpi_extract_package (
	union acpi_object       *package,
	struct acpi_buffer      *format,
	struct acpi_buffer      *buffer);
acpi_status
acpi_evaluate_integer (
	acpi_handle             handle,
	acpi_string             pathname,
	struct acpi_object_list *arguments,
	unsigned long           *data);
acpi_status
acpi_evaluate_reference (
	acpi_handle             handle,
	acpi_string             pathname,
	struct acpi_object_list *arguments,
	struct acpi_handle_list *list);


#ifdef CONFIG_ACPI_BUS

#include <linux/proc_fs.h>

#define ACPI_BUS_FILE_ROOT	"acpi"
extern struct proc_dir_entry	*acpi_root_dir;
extern FADT_DESCRIPTOR		acpi_fadt;

enum acpi_bus_removal_type {
	ACPI_BUS_REMOVAL_NORMAL	= 0,
	ACPI_BUS_REMOVAL_EJECT,
	ACPI_BUS_REMOVAL_SUPRISE,
	ACPI_BUS_REMOVAL_TYPE_COUNT
};

enum acpi_bus_device_type {
	ACPI_BUS_TYPE_DEVICE	= 0,
	ACPI_BUS_TYPE_POWER,
	ACPI_BUS_TYPE_PROCESSOR,
	ACPI_BUS_TYPE_THERMAL,
	ACPI_BUS_TYPE_SYSTEM,
	ACPI_BUS_TYPE_POWER_BUTTON,
	ACPI_BUS_TYPE_SLEEP_BUTTON,
	ACPI_BUS_DEVICE_TYPE_COUNT
};

struct acpi_driver;
struct acpi_device;


/*
 * ACPI Driver
 * -----------
 */

typedef int (*acpi_op_add)	(struct acpi_device *device);
typedef int (*acpi_op_remove)	(struct acpi_device *device, int type);
typedef int (*acpi_op_lock)	(struct acpi_device *device, int type);
typedef int (*acpi_op_start)	(struct acpi_device *device);
typedef int (*acpi_op_stop)	(struct acpi_device *device, int type);
typedef int (*acpi_op_suspend)	(struct acpi_device *device, int state);
typedef int (*acpi_op_resume)	(struct acpi_device *device, int state);
typedef int (*acpi_op_scan)	(struct acpi_device *device);
typedef int (*acpi_op_bind)	(struct acpi_device *device);
typedef int (*acpi_op_unbind)	(struct acpi_device *device);
typedef int (*acpi_op_match)	(struct acpi_device *device,
				 struct acpi_driver *driver);

struct acpi_bus_ops {
	u32 			acpi_op_add:1;
	u32			acpi_op_remove:1;
	u32			acpi_op_lock:1;
	u32			acpi_op_start:1;
	u32			acpi_op_stop:1;
	u32			acpi_op_suspend:1;
	u32			acpi_op_resume:1;
	u32			acpi_op_scan:1;
	u32			acpi_op_bind:1;
	u32			acpi_op_unbind:1;
	u32			acpi_op_match:1;
	u32			reserved:21;
};

struct acpi_device_ops {
	acpi_op_add		add;
	acpi_op_remove		remove;
	acpi_op_lock		lock;
	acpi_op_start		start;
	acpi_op_stop		stop;
	acpi_op_suspend		suspend;
	acpi_op_resume		resume;
	acpi_op_scan		scan;
	acpi_op_bind		bind;
	acpi_op_unbind		unbind;
	acpi_op_match		match;
};

struct acpi_driver {
	struct list_head	node;
	char			name[80];
	char			class[80];
	atomic_t		references;
	char			*ids;		/* Supported Hardware IDs */
	struct acpi_device_ops	ops;
};

/*
 * ACPI Device
 * -----------
 */

/* Status (_STA) */

struct acpi_device_status {
	u32			present:1;
	u32			enabled:1;
	u32			show_in_ui:1;
	u32			functional:1;
	u32			battery_present:1;
	u32			reserved:27;
};


/* Flags */

struct acpi_device_flags {
	u32			dynamic_status:1;
	u32			hardware_id:1;
	u32			compatible_ids:1;
	u32			bus_address:1;
	u32			unique_id:1;
	u32			removable:1;
	u32			ejectable:1;
	u32			lockable:1;
	u32			suprise_removal_ok:1;
	u32			power_manageable:1;
	u32			performance_manageable:1;
	u32			wake_capable:1; /* Wakeup(_PRW) supported? */
	u32			reserved:20;
};


/* File System */

struct acpi_device_dir {
	struct proc_dir_entry	*entry;
};

#define acpi_device_dir(d)	((d)->dir.entry)


/* Plug and Play */

typedef char			acpi_bus_id[5];
typedef unsigned long		acpi_bus_address;
typedef char			acpi_hardware_id[9];
typedef char			acpi_unique_id[9];
typedef char			acpi_device_name[40];
typedef char			acpi_device_class[20];

struct acpi_device_pnp {
	acpi_bus_id		bus_id;		               /* Object name */
	acpi_bus_address	bus_address;	                      /* _ADR */
	acpi_hardware_id	hardware_id;	                      /* _HID */
	struct acpi_compatible_id_list *cid_list;		     /* _CIDs */
	acpi_unique_id		unique_id;	                      /* _UID */
	acpi_device_name	device_name;	         /* Driver-determined */
	acpi_device_class	device_class;	         /*        "          */
};

#define acpi_device_bid(d)	((d)->pnp.bus_id)
#define acpi_device_adr(d)	((d)->pnp.bus_address)
#define acpi_device_hid(d)	((d)->pnp.hardware_id)
#define acpi_device_uid(d)	((d)->pnp.unique_id)
#define acpi_device_name(d)	((d)->pnp.device_name)
#define acpi_device_class(d)	((d)->pnp.device_class)


/* Power Management */

struct acpi_device_power_flags {
	u32			explicit_get:1;		     /* _PSC present? */
	u32			power_resources:1;	   /* Power resources */
	u32			inrush_current:1;	  /* Serialize Dx->D0 */
	u32			power_removed:1;	   /* Optimize Dx->D0 */
	u32			reserved:28;
};

struct acpi_device_power_state {
	struct {
		u8			valid:1;	
		u8			explicit_set:1;	     /* _PSx present? */
		u8			reserved:6;
	}			flags;
	int			power;		  /* % Power (compared to D0) */
	int			latency;	/* Dx->D0 time (microseconds) */
	struct acpi_handle_list	resources;	/* Power resources referenced */
};

struct acpi_device_power {
	int			state;		             /* Current state */
	struct acpi_device_power_flags flags;
	struct acpi_device_power_state states[4];     /* Power states (D0-D3) */
};


/* Performance Management */

struct acpi_device_perf_flags {
	u8			reserved:8;
};

struct acpi_device_perf_state {
	struct {
		u8			valid:1;	
		u8			reserved:7;
	}			flags;
	u8			power;		  /* % Power (compared to P0) */
	u8			performance;	  /* % Performance (    "   ) */
	int			latency;	/* Px->P0 time (microseconds) */
};

struct acpi_device_perf {
	int			state;
	struct acpi_device_perf_flags flags;
	int			state_count;
	struct acpi_device_perf_state *states;
};

/* Wakeup Management */
struct acpi_device_wakeup_flags {
	u8	valid:1; /* Can successfully enable wakeup? */
	u8	run_wake:1; /* Run-Wake GPE devices */
};

struct acpi_device_wakeup_state {
	u8	enabled:1;
	u8	active:1;
};

struct acpi_device_wakeup {
	acpi_handle		gpe_device;
	acpi_integer		gpe_number;;
	acpi_integer		sleep_state;
	struct acpi_handle_list	resources;
	struct acpi_device_wakeup_state	state;
	struct acpi_device_wakeup_flags	flags;
};

/* Device */

struct acpi_device {
	acpi_handle		handle;
	struct acpi_device	*parent;
	struct list_head	children;
	struct list_head	node;
	struct list_head	wakeup_list;
	struct list_head	g_list;
	struct acpi_device_status status;
	struct acpi_device_flags flags;
	struct acpi_device_pnp	pnp;
	struct acpi_device_power power;
	struct acpi_device_wakeup wakeup;
	struct acpi_device_perf	performance;
	struct acpi_device_dir	dir;
	struct acpi_device_ops	ops;
	struct acpi_driver	*driver;
	void			*driver_data;
	struct kobject		kobj;
};

#define acpi_driver_data(d)	((d)->driver_data)


/*
 * Events
 * ------
 */

struct acpi_bus_event {
	struct list_head	node;
	acpi_device_class	device_class;
	acpi_bus_id		bus_id;
	u32			type;
	u32			data;
};

extern struct subsystem acpi_subsys;

/*
 * External Functions
 */

int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device);
void acpi_bus_data_handler(acpi_handle handle, u32 function, void *context);
int acpi_bus_get_status (struct acpi_device *device);
int acpi_bus_get_power (acpi_handle handle, int *state);
int acpi_bus_set_power (acpi_handle handle, int state);
int acpi_bus_generate_event (struct acpi_device *device, u8 type, int data);
int acpi_bus_receive_event (struct acpi_bus_event *event);
int acpi_bus_register_driver (struct acpi_driver *driver);
int acpi_bus_unregister_driver (struct acpi_driver *driver);
int acpi_bus_add (struct acpi_device **child, struct acpi_device *parent,
		acpi_handle handle, int type);
int acpi_bus_start (struct acpi_device *device);


int acpi_match_ids (struct acpi_device	*device, char	*ids);
int acpi_create_dir(struct acpi_device *);
void acpi_remove_dir(struct acpi_device *);


/*
 * Bind physical devices with ACPI devices
 */
#include <linux/device.h>
struct acpi_bus_type {
	struct list_head	list;
	struct bus_type		*bus;
	/* For general devices under the bus*/
	int (*find_device)(struct device *, acpi_handle*);
	/* For bridges, such as PCI root bridge, IDE controller */
	int (*find_bridge)(struct device *, acpi_handle *);
};
int register_acpi_bus_type(struct acpi_bus_type *);
int unregister_acpi_bus_type(struct acpi_bus_type *);
struct device *acpi_get_physical_device(acpi_handle);
/* helper */
acpi_handle acpi_get_child(acpi_handle, acpi_integer);
acpi_handle acpi_get_pci_rootbridge_handle(unsigned int, unsigned int);
#define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)((dev)->firmware_data))

#endif /*CONFIG_ACPI_BUS*/

#endif /*__ACPI_BUS_H__*/
Commit	Line	Data
1da177e4 LT	1	/*
	2	* acpi_bus.h - ACPI Bus Driver ($Revision: 22 $)
	3	*
	4	* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
	5	* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
	6	*
	7	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or (at
	12	* your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful, but
	15	* WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; if not, write to the Free Software Foundation, Inc.,
	21	* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
	22	*
	23	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	24	*/
	25
	26	#ifndef __ACPI_BUS_H__
	27	#define __ACPI_BUS_H__
	28
	29	#include <linux/kobject.h>
	30
	31	#include <acpi/acpi.h>
	32
	33	#define PREFIX "ACPI: "
	34
	35	/* TBD: Make dynamic */
	36	#define ACPI_MAX_HANDLES 10
	37	struct acpi_handle_list {
	38	u32 count;
	39	acpi_handle handles[ACPI_MAX_HANDLES];
	40	};
	41
	42
	43	/* acpi_utils.h */
	44	acpi_status
	45	acpi_extract_package (
	46	union acpi_object *package,
	47	struct acpi_buffer *format,
	48	struct acpi_buffer *buffer);
	49	acpi_status
	50	acpi_evaluate_integer (
	51	acpi_handle handle,
	52	acpi_string pathname,
	53	struct acpi_object_list *arguments,
	54	unsigned long *data);
	55	acpi_status
	56	acpi_evaluate_reference (
	57	acpi_handle handle,
	58	acpi_string pathname,
	59	struct acpi_object_list *arguments,
	60	struct acpi_handle_list *list);
	61
	62
	63	#ifdef CONFIG_ACPI_BUS
	64
65	#include <linux/proc_fs.h>
66
67	#define ACPI_BUS_FILE_ROOT "acpi"
68	extern struct proc_dir_entry *acpi_root_dir;
69	extern FADT_DESCRIPTOR acpi_fadt;
70
71	enum acpi_bus_removal_type {
72	ACPI_BUS_REMOVAL_NORMAL = 0,
73	ACPI_BUS_REMOVAL_EJECT,
74	ACPI_BUS_REMOVAL_SUPRISE,
75	ACPI_BUS_REMOVAL_TYPE_COUNT
76	};
77
78	enum acpi_bus_device_type {
79	ACPI_BUS_TYPE_DEVICE = 0,
80	ACPI_BUS_TYPE_POWER,
81	ACPI_BUS_TYPE_PROCESSOR,
82	ACPI_BUS_TYPE_THERMAL,
83	ACPI_BUS_TYPE_SYSTEM,
84	ACPI_BUS_TYPE_POWER_BUTTON,
85	ACPI_BUS_TYPE_SLEEP_BUTTON,
86	ACPI_BUS_DEVICE_TYPE_COUNT
87	};
88
89	struct acpi_driver;
90	struct acpi_device;
91
92
93	/*
94	* ACPI Driver
95	* -----------
96	*/
97
98	typedef int (acpi_op_add) (struct acpi_device device);
99	typedef int (acpi_op_remove) (struct acpi_device device, int type);
100	typedef int (acpi_op_lock) (struct acpi_device device, int type);
101	typedef int (acpi_op_start) (struct acpi_device device);
102	typedef int (acpi_op_stop) (struct acpi_device device, int type);
103	typedef int (acpi_op_suspend) (struct acpi_device device, int state);
104	typedef int (acpi_op_resume) (struct acpi_device device, int state);
105	typedef int (acpi_op_scan) (struct acpi_device device);
106	typedef int (acpi_op_bind) (struct acpi_device device);
107	typedef int (acpi_op_unbind) (struct acpi_device device);
108	typedef int (acpi_op_match) (struct acpi_device device,
109	struct acpi_driver *driver);
110
3fb02738 RS	111	struct acpi_bus_ops {
	112	u32 acpi_op_add:1;
	113	u32 acpi_op_remove:1;
	114	u32 acpi_op_lock:1;
	115	u32 acpi_op_start:1;
	116	u32 acpi_op_stop:1;
	117	u32 acpi_op_suspend:1;
	118	u32 acpi_op_resume:1;
	119	u32 acpi_op_scan:1;
	120	u32 acpi_op_bind:1;
	121	u32 acpi_op_unbind:1;
	122	u32 acpi_op_match:1;
	123	u32 reserved:21;
	124	};
	125
1da177e4 LT	126	struct acpi_device_ops {
	127	acpi_op_add add;
	128	acpi_op_remove remove;
	129	acpi_op_lock lock;
	130	acpi_op_start start;
	131	acpi_op_stop stop;
	132	acpi_op_suspend suspend;
	133	acpi_op_resume resume;
	134	acpi_op_scan scan;
	135	acpi_op_bind bind;
	136	acpi_op_unbind unbind;
	137	acpi_op_match match;
	138	};
	139
	140	struct acpi_driver {
	141	struct list_head node;
	142	char name[80];
	143	char class[80];
	144	atomic_t references;
	145	char ids; / Supported Hardware IDs */
	146	struct acpi_device_ops ops;
	147	};
	148
	149	/*
	150	* ACPI Device
	151	* -----------
	152	*/
	153
	154	/* Status (_STA) */
	155
	156	struct acpi_device_status {
	157	u32 present:1;
	158	u32 enabled:1;
	159	u32 show_in_ui:1;
	160	u32 functional:1;
	161	u32 battery_present:1;
	162	u32 reserved:27;
	163	};
	164
	165
	166	/* Flags */
	167
	168	struct acpi_device_flags {
	169	u32 dynamic_status:1;
	170	u32 hardware_id:1;
	171	u32 compatible_ids:1;
	172	u32 bus_address:1;
	173	u32 unique_id:1;
	174	u32 removable:1;
	175	u32 ejectable:1;
	176	u32 lockable:1;
	177	u32 suprise_removal_ok:1;
	178	u32 power_manageable:1;
	179	u32 performance_manageable:1;
	180	u32 wake_capable:1; /* Wakeup(_PRW) supported? */
	181	u32 reserved:20;
	182	};
	183
	184
	185	/* File System */
	186
	187	struct acpi_device_dir {
	188	struct proc_dir_entry *entry;
	189	};
190
191	#define acpi_device_dir(d) ((d)->dir.entry)
192
193
194	/* Plug and Play */
195
196	typedef char acpi_bus_id[5];
197	typedef unsigned long acpi_bus_address;
198	typedef char acpi_hardware_id[9];
199	typedef char acpi_unique_id[9];
200	typedef char acpi_device_name[40];
201	typedef char acpi_device_class[20];
202
203	struct acpi_device_pnp {
204	acpi_bus_id bus_id; /* Object name */
205	acpi_bus_address bus_address; /* _ADR */
206	acpi_hardware_id hardware_id; /* _HID */
207	struct acpi_compatible_id_list cid_list; / _CIDs */
208	acpi_unique_id unique_id; /* _UID */
209	acpi_device_name device_name; /* Driver-determined */
210	acpi_device_class device_class; /* " */
211	};
212
213	#define acpi_device_bid(d) ((d)->pnp.bus_id)
214	#define acpi_device_adr(d) ((d)->pnp.bus_address)
215	#define acpi_device_hid(d) ((d)->pnp.hardware_id)
216	#define acpi_device_uid(d) ((d)->pnp.unique_id)
217	#define acpi_device_name(d) ((d)->pnp.device_name)
218	#define acpi_device_class(d) ((d)->pnp.device_class)
219
220
221	/* Power Management */
222
223	struct acpi_device_power_flags {
224	u32 explicit_get:1; /* _PSC present? */
225	u32 power_resources:1; /* Power resources */
226	u32 inrush_current:1; /* Serialize Dx->D0 */
227	u32 power_removed:1; /* Optimize Dx->D0 */
228	u32 reserved:28;
229	};
230
231	struct acpi_device_power_state {
232	struct {
233	u8 valid:1;
234	u8 explicit_set:1; /* _PSx present? */
235	u8 reserved:6;
236	} flags;
237	int power; /* % Power (compared to D0) */
238	int latency; /* Dx->D0 time (microseconds) */
239	struct acpi_handle_list resources; /* Power resources referenced */
240	};
241
242	struct acpi_device_power {
243	int state; /* Current state */
244	struct acpi_device_power_flags flags;
245	struct acpi_device_power_state states[4]; /* Power states (D0-D3) */
246	};
247
248
249	/* Performance Management */
250
251	struct acpi_device_perf_flags {
252	u8 reserved:8;
253	};
254
255	struct acpi_device_perf_state {
256	struct {
257	u8 valid:1;
258	u8 reserved:7;
259	} flags;
260	u8 power; /* % Power (compared to P0) */
261	u8 performance; /* % Performance ( " ) */
262	int latency; /* Px->P0 time (microseconds) */
263	};
264
265	struct acpi_device_perf {
266	int state;
267	struct acpi_device_perf_flags flags;
268	int state_count;
269	struct acpi_device_perf_state *states;
270	};
271
272	/* Wakeup Management */
273	struct acpi_device_wakeup_flags {
274	u8 valid:1; /* Can successfully enable wakeup? */
275	u8 run_wake:1; /* Run-Wake GPE devices */
276	};
277
278	struct acpi_device_wakeup_state {
279	u8 enabled:1;
280	u8 active:1;
281	};
282
283	struct acpi_device_wakeup {
284	acpi_handle gpe_device;
285	acpi_integer gpe_number;;
286	acpi_integer sleep_state;
287	struct acpi_handle_list resources;
288	struct acpi_device_wakeup_state state;
289	struct acpi_device_wakeup_flags flags;
290	};
291
292	/* Device */
293
294	struct acpi_device {
295	acpi_handle handle;
296	struct acpi_device *parent;
297	struct list_head children;
298	struct list_head node;
299	struct list_head wakeup_list;
300	struct list_head g_list;
301	struct acpi_device_status status;
302	struct acpi_device_flags flags;
303	struct acpi_device_pnp pnp;
304	struct acpi_device_power power;
305	struct acpi_device_wakeup wakeup;
306	struct acpi_device_perf performance;
307	struct acpi_device_dir dir;
308	struct acpi_device_ops ops;
309	struct acpi_driver *driver;
310	void *driver_data;
311	struct kobject kobj;
312	};
313
314	#define acpi_driver_data(d) ((d)->driver_data)
315
316
317	/*
318	* Events
319	* ------
320	*/
321
322	struct acpi_bus_event {
323	struct list_head node;
324	acpi_device_class device_class;
325	acpi_bus_id bus_id;
326	u32 type;
327	u32 data;
328	};
329
330	extern struct subsystem acpi_subsys;
331
332	/*
333	* External Functions
334	*/
335
336	int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device);
337	void acpi_bus_data_handler(acpi_handle handle, u32 function, void *context);
338	int acpi_bus_get_status (struct acpi_device *device);
339	int acpi_bus_get_power (acpi_handle handle, int *state);
340	int acpi_bus_set_power (acpi_handle handle, int state);
341	int acpi_bus_generate_event (struct acpi_device *device, u8 type, int data);
342	int acpi_bus_receive_event (struct acpi_bus_event *event);
343	int acpi_bus_register_driver (struct acpi_driver *driver);
344	int acpi_bus_unregister_driver (struct acpi_driver *driver);
1da177e4 LT	345	int acpi_bus_add (struct acpi_device *child, struct acpi_device parent,
1da177e4 LT	346	acpi_handle handle, int type);
3fb02738	347	int acpi_bus_start (struct acpi_device *device);
1da177e4 LT	348
	349
	350	int acpi_match_ids (struct acpi_device device, char ids);
	351	int acpi_create_dir(struct acpi_device *);
	352	void acpi_remove_dir(struct acpi_device *);
	353
4e10d12a DSL	354
	355	/*
	356	* Bind physical devices with ACPI devices
	357	*/
	358	#include <linux/device.h>
	359	struct acpi_bus_type {
	360	struct list_head list;
	361	struct bus_type *bus;
	362	/* For general devices under the bus*/
	363	int (find_device)(struct device , acpi_handle*);
	364	/* For bridges, such as PCI root bridge, IDE controller */
	365	int (find_bridge)(struct device , acpi_handle *);
	366	};
	367	int register_acpi_bus_type(struct acpi_bus_type *);
	368	int unregister_acpi_bus_type(struct acpi_bus_type *);
	369	struct device *acpi_get_physical_device(acpi_handle);
	370	/* helper */
	371	acpi_handle acpi_get_child(acpi_handle, acpi_integer);
	372	acpi_handle acpi_get_pci_rootbridge_handle(unsigned int, unsigned int);
	373	#define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)((dev)->firmware_data))
	374
1da177e4 LT	375	#endif /CONFIG_ACPI_BUS/
	376
	377	#endif /__ACPI_BUS_H__/