1 files changed, 422 insertions, 202 deletions

diff --git a/include/acpi/acpi_bus.h b/include/acpi/acpi_bus.h
index 8d0e1290bc7..b5714580801 100644
--- a/include/acpi/acpi_bus.h
+++ b/include/acpi/acpi_bus.h
@@ -26,61 +26,82 @@
 #ifndef __ACPI_BUS_H__
 #define __ACPI_BUS_H__
 
-#include <linux/kobject.h>
-
-#include <acpi/acpi.h>
-
-#define PREFIX			"ACPI: "
+#include <linux/device.h>
 
 /* TBD: Make dynamic */
 #define ACPI_MAX_HANDLES	10
 struct acpi_handle_list {
-	u32			count;
-	acpi_handle		handles[ACPI_MAX_HANDLES];
+	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_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_evaluate_integer(acpi_handle handle,
+		      acpi_string pathname,
+		      struct acpi_object_list *arguments, unsigned long long *data);
 acpi_status
-acpi_evaluate_reference (
-	acpi_handle             handle,
-	acpi_string             pathname,
-	struct acpi_object_list *arguments,
-	struct acpi_handle_list *list);
-
+acpi_evaluate_reference(acpi_handle handle,
+			acpi_string pathname,
+			struct acpi_object_list *arguments,
+			struct acpi_handle_list *list);
+acpi_status
+acpi_evaluate_ost(acpi_handle handle, u32 source_event, u32 status_code,
+		  struct acpi_buffer *status_buf);
 
-#ifdef CONFIG_ACPI_BUS
+acpi_status
+acpi_get_physical_device_location(acpi_handle handle, struct acpi_pld_info **pld);
+
+bool acpi_has_method(acpi_handle handle, char *name);
+acpi_status acpi_execute_simple_method(acpi_handle handle, char *method,
+				       u64 arg);
+acpi_status acpi_evaluate_ej0(acpi_handle handle);
+acpi_status acpi_evaluate_lck(acpi_handle handle, int lock);
+bool acpi_ata_match(acpi_handle handle);
+bool acpi_bay_match(acpi_handle handle);
+bool acpi_dock_match(acpi_handle handle);
+
+bool acpi_check_dsm(acpi_handle handle, const u8 *uuid, int rev, u64 funcs);
+union acpi_object *acpi_evaluate_dsm(acpi_handle handle, const u8 *uuid,
+			int rev, int func, union acpi_object *argv4);
+
+static inline union acpi_object *
+acpi_evaluate_dsm_typed(acpi_handle handle, const u8 *uuid, int rev, int func,
+			union acpi_object *argv4, acpi_object_type type)
+{
+	union acpi_object *obj;
+
+	obj = acpi_evaluate_dsm(handle, uuid, rev, func, argv4);
+	if (obj && obj->type != type) {
+		ACPI_FREE(obj);
+		obj = NULL;
+	}
+
+	return obj;
+}
+
+#define	ACPI_INIT_DSM_ARGV4(cnt, eles)			\
+	{						\
+	  .package.type = ACPI_TYPE_PACKAGE,		\
+	  .package.count = (cnt),			\
+	  .package.elements = (eles)			\
+	}
+
+#ifdef CONFIG_ACPI
 
 #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
-};
+extern struct proc_dir_entry *acpi_root_dir;
 
 enum acpi_bus_device_type {
-	ACPI_BUS_TYPE_DEVICE	= 0,
+	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
@@ -89,61 +110,72 @@ enum acpi_bus_device_type {
 struct acpi_driver;
 struct acpi_device;
 
+/*
+ * ACPI Scan Handler
+ * -----------------
+ */
+
+struct acpi_hotplug_profile {
+	struct kobject kobj;
+	int (*scan_dependent)(struct acpi_device *adev);
+	bool enabled:1;
+	bool demand_offline:1;
+};
+
+static inline struct acpi_hotplug_profile *to_acpi_hotplug_profile(
+						struct kobject *kobj)
+{
+	return container_of(kobj, struct acpi_hotplug_profile, kobj);
+}
+
+struct acpi_scan_handler {
+	const struct acpi_device_id *ids;
+	struct list_head list_node;
+	bool (*match)(char *idstr, const struct acpi_device_id **matchid);
+	int (*attach)(struct acpi_device *dev, const struct acpi_device_id *id);
+	void (*detach)(struct acpi_device *dev);
+	void (*bind)(struct device *phys_dev);
+	void (*unbind)(struct device *phys_dev);
+	struct acpi_hotplug_profile hotplug;
+};
+
+/*
+ * ACPI Hotplug Context
+ * --------------------
+ */
+
+struct acpi_hotplug_context {
+	struct acpi_device *self;
+	int (*notify)(struct acpi_device *, u32);
+	void (*uevent)(struct acpi_device *, u32);
+	void (*fixup)(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;
-};
+typedef int (*acpi_op_add) (struct acpi_device * device);
+typedef int (*acpi_op_remove) (struct acpi_device * device);
+typedef void (*acpi_op_notify) (struct acpi_device * device, u32 event);
 
 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;
+	acpi_op_add add;
+	acpi_op_remove remove;
+	acpi_op_notify notify;
 };
 
+#define ACPI_DRIVER_ALL_NOTIFY_EVENTS	0x1	/* system AND device events */
+
 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;
+	char name[80];
+	char class[80];
+	const struct acpi_device_id *ids; /* Supported Hardware IDs */
+	unsigned int flags;
+	struct acpi_device_ops ops;
+	struct device_driver drv;
+	struct module *owner;
 };
 
 /*
@@ -154,165 +186,211 @@ struct acpi_driver {
 /* 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;
+	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;
+	u32 dynamic_status:1;
+	u32 removable:1;
+	u32 ejectable:1;
+	u32 power_manageable:1;
+	u32 match_driver:1;
+	u32 initialized:1;
+	u32 visited:1;
+	u32 no_hotplug:1;
+	u32 hotplug_notify:1;
+	u32 is_dock_station:1;
+	u32 reserved:22;
 };
 
-
 /* File System */
 
 struct acpi_device_dir {
-	struct proc_dir_entry	*entry;
+	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];
+typedef char acpi_bus_id[8];
+typedef unsigned long acpi_bus_address;
+typedef char acpi_device_name[40];
+typedef char acpi_device_class[20];
+
+struct acpi_hardware_id {
+	struct list_head list;
+	char *id;
+};
+
+struct acpi_pnp_type {
+	u32 hardware_id:1;
+	u32 bus_address:1;
+	u32 platform_id:1;
+	u32 reserved:29;
+};
 
 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;	         /*        "          */
+	acpi_bus_id bus_id;		/* Object name */
+	struct acpi_pnp_type type;	/* ID type */
+	acpi_bus_address bus_address;	/* _ADR */
+	char *unique_id;		/* _UID */
+	struct list_head ids;		/* _HID and _CIDs */
+	acpi_device_name device_name;	/* Driver-determined */
+	acpi_device_class device_class;	/*        "          */
+	union acpi_object *str_obj;	/* unicode string for _STR method */
+	unsigned long sun;		/* _SUN */
 };
 
 #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)
+const char *acpi_device_hid(struct acpi_device *device);
 #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;
+	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 ignore_parent:1;	/* Power is independent of parent power state */
+	u32 dsw_present:1;	/* _DSW present? */
+	u32 reserved:26;
 };
 
 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 */
+		u8 valid:1;
+		u8 os_accessible:1;
+		u8 explicit_set:1;	/* _PSx present? */
+		u8 reserved:6;
+	} flags;
+	int power;		/* % Power (compared to D0) */
+	int latency;		/* Dx->D0 time (microseconds) */
+	struct list_head resources;	/* Power resources referenced */
 };
 
 struct acpi_device_power {
-	int			state;		             /* Current state */
+	int state;		/* Current state */
 	struct acpi_device_power_flags flags;
-	struct acpi_device_power_state states[4];     /* Power states (D0-D3) */
+	struct acpi_device_power_state states[ACPI_D_STATE_COUNT];	/* Power states (D0-D3Cold) */
 };
 
-
 /* Performance Management */
 
 struct acpi_device_perf_flags {
-	u8			reserved:8;
+	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) */
+		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;
+	int state;
 	struct acpi_device_perf_flags flags;
-	int			state_count;
+	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 */
+	u8 valid:1;		/* Can successfully enable wakeup? */
+	u8 run_wake:1;		/* Run-Wake GPE devices */
+	u8 notifier_present:1;  /* Wake-up notify handler has been installed */
 };
 
-struct acpi_device_wakeup_state {
-	u8	enabled:1;
-	u8	active:1;
+struct acpi_device_wakeup {
+	acpi_handle gpe_device;
+	u64 gpe_number;
+	u64 sleep_state;
+	struct list_head resources;
+	struct acpi_device_wakeup_flags flags;
+	int prepare_count;
 };
 
-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;
+struct acpi_device_physical_node {
+	unsigned int node_id;
+	struct list_head node;
+	struct device *dev;
+	bool put_online:1;
 };
 
 /* 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;
+	int device_type;
+	acpi_handle handle;		/* no handle for fixed hardware */
+	struct acpi_device *parent;
+	struct list_head children;
+	struct list_head node;
+	struct list_head wakeup_list;
+	struct list_head del_list;
 	struct acpi_device_status status;
 	struct acpi_device_flags flags;
-	struct acpi_device_pnp	pnp;
+	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;
+	struct acpi_device_perf performance;
+	struct acpi_device_dir dir;
+	struct acpi_scan_handler *handler;
+	struct acpi_hotplug_context *hp;
+	struct acpi_driver *driver;
+	void *driver_data;
+	struct device dev;
+	unsigned int physical_node_count;
+	struct list_head physical_node_list;
+	struct mutex physical_node_lock;
+	void (*remove)(struct acpi_device *);
 };
 
-#define acpi_driver_data(d)	((d)->driver_data)
-
+static inline void *acpi_driver_data(struct acpi_device *d)
+{
+	return d->driver_data;
+}
+
+#define to_acpi_device(d)	container_of(d, struct acpi_device, dev)
+#define to_acpi_driver(d)	container_of(d, struct acpi_driver, drv)
+
+static inline void acpi_set_device_status(struct acpi_device *adev, u32 sta)
+{
+	*((u32 *)&adev->status) = sta;
+}
+
+static inline void acpi_set_hp_context(struct acpi_device *adev,
+				       struct acpi_hotplug_context *hp,
+				       int (*notify)(struct acpi_device *, u32),
+				       void (*uevent)(struct acpi_device *, u32),
+				       void (*fixup)(struct acpi_device *))
+{
+	hp->self = adev;
+	hp->notify = notify;
+	hp->uevent = uevent;
+	hp->fixup = fixup;
+	adev->hp = hp;
+}
+
+void acpi_initialize_hp_context(struct acpi_device *adev,
+				struct acpi_hotplug_context *hp,
+				int (*notify)(struct acpi_device *, u32),
+				void (*uevent)(struct acpi_device *, u32));
+
+/* acpi_device.dev.bus == &acpi_bus_type */
+extern struct bus_type acpi_bus_type;
 
 /*
  * Events
@@ -320,58 +398,200 @@ struct acpi_device {
  */
 
 struct acpi_bus_event {
-	struct list_head	node;
-	acpi_device_class	device_class;
-	acpi_bus_id		bus_id;
-	u32			type;
-	u32			data;
+	struct list_head node;
+	acpi_device_class device_class;
+	acpi_bus_id bus_id;
+	u32 type;
+	u32 data;
 };
 
-extern struct subsystem acpi_subsys;
+extern struct kobject *acpi_kobj;
+extern int acpi_bus_generate_netlink_event(const char*, const char*, u8, int);
+void acpi_bus_private_data_handler(acpi_handle, void *);
+int acpi_bus_get_private_data(acpi_handle, void **);
+int acpi_bus_attach_private_data(acpi_handle, void *);
+void acpi_bus_detach_private_data(acpi_handle);
+void acpi_bus_no_hotplug(acpi_handle handle);
+extern int acpi_notifier_call_chain(struct acpi_device *, u32, u32);
+extern int register_acpi_notifier(struct notifier_block *);
+extern int unregister_acpi_notifier(struct notifier_block *);
 
 /*
  * 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);
+struct acpi_device *acpi_bus_get_acpi_device(acpi_handle handle);
+void acpi_bus_put_acpi_device(struct acpi_device *adev);
+acpi_status acpi_bus_get_status_handle(acpi_handle handle,
+				       unsigned long long *sta);
+int acpi_bus_get_status(struct acpi_device *device);
+
+int acpi_bus_set_power(acpi_handle handle, int state);
+const char *acpi_power_state_string(int state);
+int acpi_device_get_power(struct acpi_device *device, int *state);
+int acpi_device_set_power(struct acpi_device *device, int state);
+int acpi_bus_init_power(struct acpi_device *device);
+int acpi_device_fix_up_power(struct acpi_device *device);
+int acpi_bus_update_power(acpi_handle handle, int *state_p);
+bool acpi_bus_power_manageable(acpi_handle handle);
+
+#ifdef CONFIG_PM
+bool acpi_bus_can_wakeup(acpi_handle handle);
+#else
+static inline bool acpi_bus_can_wakeup(acpi_handle handle) { return false; }
+#endif
+
+void acpi_scan_lock_acquire(void);
+void acpi_scan_lock_release(void);
+void acpi_lock_hp_context(void);
+void acpi_unlock_hp_context(void);
+int acpi_scan_add_handler(struct acpi_scan_handler *handler);
+int acpi_bus_register_driver(struct acpi_driver *driver);
+void acpi_bus_unregister_driver(struct acpi_driver *driver);
+int acpi_bus_scan(acpi_handle handle);
+void acpi_bus_trim(struct acpi_device *start);
+acpi_status acpi_bus_get_ejd(acpi_handle handle, acpi_handle * ejd);
+int acpi_match_device_ids(struct acpi_device *device,
+			  const struct acpi_device_id *ids);
 int acpi_create_dir(struct acpi_device *);
 void acpi_remove_dir(struct acpi_device *);
 
+static inline bool acpi_device_enumerated(struct acpi_device *adev)
+{
+	return adev && adev->flags.initialized && adev->flags.visited;
+}
+
+/**
+ * module_acpi_driver(acpi_driver) - Helper macro for registering an ACPI driver
+ * @__acpi_driver: acpi_driver struct
+ *
+ * Helper macro for ACPI drivers which do not do anything special in module
+ * init/exit. This eliminates a lot of boilerplate. Each module may only
+ * use this macro once, and calling it replaces module_init() and module_exit()
+ */
+#define module_acpi_driver(__acpi_driver) \
+	module_driver(__acpi_driver, acpi_bus_register_driver, \
+		      acpi_bus_unregister_driver)
 
 /*
  * 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 *);
+	struct list_head list;
+	const char *name;
+	bool (*match)(struct device *dev);
+	struct acpi_device * (*find_companion)(struct device *);
+	void (*setup)(struct device *);
+	void (*cleanup)(struct device *);
 };
 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);
+
+struct acpi_pci_root {
+	struct acpi_device * device;
+	struct pci_bus *bus;
+	u16 segment;
+	struct resource secondary;	/* downstream bus range */
+
+	u32 osc_support_set;	/* _OSC state of support bits */
+	u32 osc_control_set;	/* _OSC state of control bits */
+	phys_addr_t mcfg_addr;
+};
+
 /* 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*/
+struct acpi_device *acpi_find_child_device(struct acpi_device *parent,
+					   u64 address, bool check_children);
+int acpi_is_root_bridge(acpi_handle);
+struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle);
+
+int acpi_enable_wakeup_device_power(struct acpi_device *dev, int state);
+int acpi_disable_wakeup_device_power(struct acpi_device *dev);
+
+#ifdef CONFIG_PM
+acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
+				 acpi_notify_handler handler, void *context);
+acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
+				    acpi_notify_handler handler);
+int acpi_pm_device_sleep_state(struct device *, int *, int);
+#else
+static inline acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
+					       acpi_notify_handler handler,
+					       void *context)
+{
+	return AE_SUPPORT;
+}
+static inline acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
+						  acpi_notify_handler handler)
+{
+	return AE_SUPPORT;
+}
+static inline int acpi_pm_device_sleep_state(struct device *d, int *p, int m)
+{
+	if (p)
+		*p = ACPI_STATE_D0;
+
+	return (m >= ACPI_STATE_D0 && m <= ACPI_STATE_D3_COLD) ?
+		m : ACPI_STATE_D0;
+}
+#endif
+
+#ifdef CONFIG_PM_RUNTIME
+int __acpi_device_run_wake(struct acpi_device *, bool);
+int acpi_pm_device_run_wake(struct device *, bool);
+#else
+static inline int __acpi_device_run_wake(struct acpi_device *adev, bool en)
+{
+	return -ENODEV;
+}
+static inline int acpi_pm_device_run_wake(struct device *dev, bool enable)
+{
+	return -ENODEV;
+}
+#endif
+
+#ifdef CONFIG_PM_SLEEP
+int __acpi_device_sleep_wake(struct acpi_device *, u32, bool);
+int acpi_pm_device_sleep_wake(struct device *, bool);
+#else
+static inline int __acpi_device_sleep_wake(struct acpi_device *adev,
+					   u32 target_state, bool enable)
+{
+	return -ENODEV;
+}
+static inline int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
+{
+	return -ENODEV;
+}
+#endif
+
+#ifdef CONFIG_ACPI_SLEEP
+u32 acpi_target_system_state(void);
+#else
+static inline u32 acpi_target_system_state(void) { return ACPI_STATE_S0; }
+#endif
+
+static inline bool acpi_device_power_manageable(struct acpi_device *adev)
+{
+	return adev->flags.power_manageable;
+}
+
+static inline bool acpi_device_can_wakeup(struct acpi_device *adev)
+{
+	return adev->wakeup.flags.valid;
+}
+
+static inline bool acpi_device_can_poweroff(struct acpi_device *adev)
+{
+	return adev->power.states[ACPI_STATE_D3_COLD].flags.os_accessible;
+}
+
+#else	/* CONFIG_ACPI */
+
+static inline int register_acpi_bus_type(void *bus) { return 0; }
+static inline int unregister_acpi_bus_type(void *bus) { return 0; }
+
+#endif				/* CONFIG_ACPI */
 
 #endif /*__ACPI_BUS_H__*/