aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--drivers/acpi/acpica/Makefile2
-rw-r--r--drivers/acpi/acpica/acevents.h21
-rw-r--r--drivers/acpi/acpica/acglobal.h7
-rw-r--r--drivers/acpi/acpica/achware.h2
-rw-r--r--drivers/acpi/acpica/aclocal.h13
-rw-r--r--drivers/acpi/acpica/evevent.c12
-rw-r--r--drivers/acpi/acpica/evgpe.c265
-rw-r--r--drivers/acpi/acpica/evgpeblk.c33
-rw-r--r--drivers/acpi/acpica/evgpeinit.c25
-rw-r--r--drivers/acpi/acpica/evgpeutil.c39
-rw-r--r--drivers/acpi/acpica/evxface.c77
-rw-r--r--drivers/acpi/acpica/evxfevnt.c600
-rw-r--r--drivers/acpi/acpica/evxfgpe.c669
-rw-r--r--drivers/acpi/acpica/hwgpe.c32
-rw-r--r--drivers/acpi/acpica/utglobal.c3
-rw-r--r--drivers/acpi/bus.c153
-rw-r--r--drivers/acpi/dock.c2
-rw-r--r--drivers/acpi/ec.c5
-rw-r--r--drivers/acpi/fan.c27
-rw-r--r--drivers/acpi/internal.h5
-rw-r--r--drivers/acpi/power.c90
-rw-r--r--drivers/acpi/scan.c33
-rw-r--r--drivers/acpi/sysfs.c19
-rw-r--r--drivers/acpi/thermal.c5
-rw-r--r--drivers/acpi/wakeup.c4
-rw-r--r--drivers/char/ipmi/ipmi_si_intf.c3
-rw-r--r--drivers/platform/x86/fujitsu-laptop.c4
-rw-r--r--include/acpi/acpi_bus.h5
-rw-r--r--include/acpi/acpixf.h20
-rw-r--r--include/acpi/actypes.h52
30 files changed, 1288 insertions, 939 deletions
diff --git a/drivers/acpi/acpica/Makefile b/drivers/acpi/acpica/Makefile
index a7e1d1aa4107..eec2eadd2431 100644
--- a/drivers/acpi/acpica/Makefile
+++ b/drivers/acpi/acpica/Makefile
@@ -14,7 +14,7 @@ acpi-y := dsfield.o dsmthdat.o dsopcode.o dswexec.o dswscope.o \
14 14
15acpi-y += evevent.o evregion.o evsci.o evxfevnt.o \ 15acpi-y += evevent.o evregion.o evsci.o evxfevnt.o \
16 evmisc.o evrgnini.o evxface.o evxfregn.o \ 16 evmisc.o evrgnini.o evxface.o evxfregn.o \
17 evgpe.o evgpeblk.o evgpeinit.o evgpeutil.o 17 evgpe.o evgpeblk.o evgpeinit.o evgpeutil.o evxfgpe.o
18 18
19acpi-y += exconfig.o exfield.o exnames.o exoparg6.o exresolv.o exstorob.o\ 19acpi-y += exconfig.o exfield.o exnames.o exoparg6.o exresolv.o exstorob.o\
20 exconvrt.o exfldio.o exoparg1.o exprep.o exresop.o exsystem.o\ 20 exconvrt.o exfldio.o exoparg1.o exprep.o exresop.o exsystem.o\
diff --git a/drivers/acpi/acpica/acevents.h b/drivers/acpi/acpica/acevents.h
index a6f99cc37a19..70e0b28801aa 100644
--- a/drivers/acpi/acpica/acevents.h
+++ b/drivers/acpi/acpica/acevents.h
@@ -51,8 +51,6 @@ acpi_status acpi_ev_initialize_events(void);
51 51
52acpi_status acpi_ev_install_xrupt_handlers(void); 52acpi_status acpi_ev_install_xrupt_handlers(void);
53 53
54acpi_status acpi_ev_install_fadt_gpes(void);
55
56u32 acpi_ev_fixed_event_detect(void); 54u32 acpi_ev_fixed_event_detect(void);
57 55
58/* 56/*
@@ -82,9 +80,9 @@ acpi_ev_update_gpe_enable_mask(struct acpi_gpe_event_info *gpe_event_info);
82 80
83acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info); 81acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info);
84 82
85acpi_status acpi_raw_enable_gpe(struct acpi_gpe_event_info *gpe_event_info); 83acpi_status acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info);
86 84
87acpi_status acpi_raw_disable_gpe(struct acpi_gpe_event_info *gpe_event_info); 85acpi_status acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_info);
88 86
89struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device, 87struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
90 u32 gpe_number); 88 u32 gpe_number);
@@ -93,6 +91,8 @@ struct acpi_gpe_event_info *acpi_ev_low_get_gpe_info(u32 gpe_number,
93 struct acpi_gpe_block_info 91 struct acpi_gpe_block_info
94 *gpe_block); 92 *gpe_block);
95 93
94acpi_status acpi_ev_finish_gpe(struct acpi_gpe_event_info *gpe_event_info);
95
96/* 96/*
97 * evgpeblk - Upper-level GPE block support 97 * evgpeblk - Upper-level GPE block support
98 */ 98 */
@@ -107,12 +107,13 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
107acpi_status 107acpi_status
108acpi_ev_initialize_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info, 108acpi_ev_initialize_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
109 struct acpi_gpe_block_info *gpe_block, 109 struct acpi_gpe_block_info *gpe_block,
110 void *ignored); 110 void *context);
111 111
112acpi_status acpi_ev_delete_gpe_block(struct acpi_gpe_block_info *gpe_block); 112acpi_status acpi_ev_delete_gpe_block(struct acpi_gpe_block_info *gpe_block);
113 113
114u32 114u32
115acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, 115acpi_ev_gpe_dispatch(struct acpi_namespace_node *gpe_device,
116 struct acpi_gpe_event_info *gpe_event_info,
116 u32 gpe_number); 117 u32 gpe_number);
117 118
118/* 119/*
@@ -126,10 +127,6 @@ acpi_status
126acpi_ev_match_gpe_method(acpi_handle obj_handle, 127acpi_ev_match_gpe_method(acpi_handle obj_handle,
127 u32 level, void *context, void **return_value); 128 u32 level, void *context, void **return_value);
128 129
129acpi_status
130acpi_ev_match_prw_and_gpe(acpi_handle obj_handle,
131 u32 level, void *context, void **return_value);
132
133/* 130/*
134 * evgpeutil - GPE utilities 131 * evgpeutil - GPE utilities
135 */ 132 */
@@ -138,6 +135,10 @@ acpi_ev_walk_gpe_list(acpi_gpe_callback gpe_walk_callback, void *context);
138 135
139u8 acpi_ev_valid_gpe_event(struct acpi_gpe_event_info *gpe_event_info); 136u8 acpi_ev_valid_gpe_event(struct acpi_gpe_event_info *gpe_event_info);
140 137
138acpi_status
139acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
140 struct acpi_gpe_block_info *gpe_block, void *context);
141
141struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32 interrupt_number); 142struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32 interrupt_number);
142 143
143acpi_status acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt); 144acpi_status acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt);
diff --git a/drivers/acpi/acpica/acglobal.h b/drivers/acpi/acpica/acglobal.h
index ad88fcae4eb9..9bb69c59bb12 100644
--- a/drivers/acpi/acpica/acglobal.h
+++ b/drivers/acpi/acpica/acglobal.h
@@ -146,6 +146,9 @@ u8 acpi_gbl_system_awake_and_running;
146 146
147extern u32 acpi_gbl_nesting_level; 147extern u32 acpi_gbl_nesting_level;
148 148
149ACPI_EXTERN u32 acpi_gpe_count;
150ACPI_EXTERN u32 acpi_fixed_event_count[ACPI_NUM_FIXED_EVENTS];
151
149/* Support for dynamic control method tracing mechanism */ 152/* Support for dynamic control method tracing mechanism */
150 153
151ACPI_EXTERN u32 acpi_gbl_original_dbg_level; 154ACPI_EXTERN u32 acpi_gbl_original_dbg_level;
@@ -370,7 +373,9 @@ ACPI_EXTERN struct acpi_fixed_event_handler
370ACPI_EXTERN struct acpi_gpe_xrupt_info *acpi_gbl_gpe_xrupt_list_head; 373ACPI_EXTERN struct acpi_gpe_xrupt_info *acpi_gbl_gpe_xrupt_list_head;
371ACPI_EXTERN struct acpi_gpe_block_info 374ACPI_EXTERN struct acpi_gpe_block_info
372*acpi_gbl_gpe_fadt_blocks[ACPI_MAX_GPE_BLOCKS]; 375*acpi_gbl_gpe_fadt_blocks[ACPI_MAX_GPE_BLOCKS];
373ACPI_EXTERN u8 acpi_all_gpes_initialized; 376ACPI_EXTERN u8 acpi_gbl_all_gpes_initialized;
377ACPI_EXTERN ACPI_GBL_EVENT_HANDLER acpi_gbl_global_event_handler;
378ACPI_EXTERN void *acpi_gbl_global_event_handler_context;
374 379
375/***************************************************************************** 380/*****************************************************************************
376 * 381 *
diff --git a/drivers/acpi/acpica/achware.h b/drivers/acpi/acpica/achware.h
index 167470ad2d21..258d628793ea 100644
--- a/drivers/acpi/acpica/achware.h
+++ b/drivers/acpi/acpica/achware.h
@@ -94,7 +94,7 @@ u32 acpi_hw_get_gpe_register_bit(struct acpi_gpe_event_info *gpe_event_info,
94 struct acpi_gpe_register_info *gpe_register_info); 94 struct acpi_gpe_register_info *gpe_register_info);
95 95
96acpi_status 96acpi_status
97acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u8 action); 97acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u32 action);
98 98
99acpi_status 99acpi_status
100acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info, 100acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
diff --git a/drivers/acpi/acpica/aclocal.h b/drivers/acpi/acpica/aclocal.h
index 2ceb0c05b2d7..74000f5b7dab 100644
--- a/drivers/acpi/acpica/aclocal.h
+++ b/drivers/acpi/acpica/aclocal.h
@@ -408,17 +408,18 @@ struct acpi_predefined_data {
408 408
409/* Dispatch info for each GPE -- either a method or handler, cannot be both */ 409/* Dispatch info for each GPE -- either a method or handler, cannot be both */
410 410
411struct acpi_handler_info { 411struct acpi_gpe_handler_info {
412 acpi_event_handler address; /* Address of handler, if any */ 412 acpi_gpe_handler address; /* Address of handler, if any */
413 void *context; /* Context to be passed to handler */ 413 void *context; /* Context to be passed to handler */
414 struct acpi_namespace_node *method_node; /* Method node for this GPE level (saved) */ 414 struct acpi_namespace_node *method_node; /* Method node for this GPE level (saved) */
415 u8 orig_flags; /* Original misc info about this GPE */ 415 u8 original_flags; /* Original (pre-handler) GPE info */
416 u8 orig_enabled; /* Set if the GPE was originally enabled */ 416 u8 originally_enabled; /* True if GPE was originally enabled */
417}; 417};
418 418
419union acpi_gpe_dispatch_info { 419union acpi_gpe_dispatch_info {
420 struct acpi_namespace_node *method_node; /* Method node for this GPE level */ 420 struct acpi_namespace_node *method_node; /* Method node for this GPE level */
421 struct acpi_handler_info *handler; 421 struct acpi_gpe_handler_info *handler; /* Installed GPE handler */
422 struct acpi_namespace_node *device_node; /* Parent _PRW device for implicit notify */
422}; 423};
423 424
424/* 425/*
@@ -458,7 +459,7 @@ struct acpi_gpe_block_info {
458 u32 register_count; /* Number of register pairs in block */ 459 u32 register_count; /* Number of register pairs in block */
459 u16 gpe_count; /* Number of individual GPEs in block */ 460 u16 gpe_count; /* Number of individual GPEs in block */
460 u8 block_base_number; /* Base GPE number for this block */ 461 u8 block_base_number; /* Base GPE number for this block */
461 u8 initialized; /* If set, the GPE block has been initialized */ 462 u8 initialized; /* TRUE if this block is initialized */
462}; 463};
463 464
464/* Information about GPE interrupt handlers, one per each interrupt level used for GPEs */ 465/* Information about GPE interrupt handlers, one per each interrupt level used for GPEs */
diff --git a/drivers/acpi/acpica/evevent.c b/drivers/acpi/acpica/evevent.c
index c61c3039c31a..e5e313c663a5 100644
--- a/drivers/acpi/acpica/evevent.c
+++ b/drivers/acpi/acpica/evevent.c
@@ -217,9 +217,17 @@ u32 acpi_ev_fixed_event_detect(void)
217 status_bit_mask) 217 status_bit_mask)
218 && (fixed_enable & acpi_gbl_fixed_event_info[i]. 218 && (fixed_enable & acpi_gbl_fixed_event_info[i].
219 enable_bit_mask)) { 219 enable_bit_mask)) {
220 /*
221 * Found an active (signalled) event. Invoke global event
222 * handler if present.
223 */
224 acpi_fixed_event_count[i]++;
225 if (acpi_gbl_global_event_handler) {
226 acpi_gbl_global_event_handler
227 (ACPI_EVENT_TYPE_FIXED, NULL, i,
228 acpi_gbl_global_event_handler_context);
229 }
220 230
221 /* Found an active (signalled) event */
222 acpi_os_fixed_event_count(i);
223 int_status |= acpi_ev_fixed_event_dispatch(i); 231 int_status |= acpi_ev_fixed_event_dispatch(i);
224 } 232 }
225 } 233 }
diff --git a/drivers/acpi/acpica/evgpe.c b/drivers/acpi/acpica/evgpe.c
index f226eac314db..7c339d34ab42 100644
--- a/drivers/acpi/acpica/evgpe.c
+++ b/drivers/acpi/acpica/evgpe.c
@@ -52,6 +52,8 @@ ACPI_MODULE_NAME("evgpe")
52/* Local prototypes */ 52/* Local prototypes */
53static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context); 53static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context);
54 54
55static void ACPI_SYSTEM_XFACE acpi_ev_asynch_enable_gpe(void *context);
56
55/******************************************************************************* 57/*******************************************************************************
56 * 58 *
57 * FUNCTION: acpi_ev_update_gpe_enable_mask 59 * FUNCTION: acpi_ev_update_gpe_enable_mask
@@ -102,7 +104,7 @@ acpi_ev_update_gpe_enable_mask(struct acpi_gpe_event_info *gpe_event_info)
102 * 104 *
103 * RETURN: Status 105 * RETURN: Status
104 * 106 *
105 * DESCRIPTION: Clear the given GPE from stale events and enable it. 107 * DESCRIPTION: Clear a GPE of stale events and enable it.
106 * 108 *
107 ******************************************************************************/ 109 ******************************************************************************/
108acpi_status 110acpi_status
@@ -113,12 +115,13 @@ acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
113 ACPI_FUNCTION_TRACE(ev_enable_gpe); 115 ACPI_FUNCTION_TRACE(ev_enable_gpe);
114 116
115 /* 117 /*
116 * We will only allow a GPE to be enabled if it has either an 118 * We will only allow a GPE to be enabled if it has either an associated
117 * associated method (_Lxx/_Exx) or a handler. Otherwise, the 119 * method (_Lxx/_Exx) or a handler, or is using the implicit notify
118 * GPE will be immediately disabled by acpi_ev_gpe_dispatch the 120 * feature. Otherwise, the GPE will be immediately disabled by
119 * first time it fires. 121 * acpi_ev_gpe_dispatch the first time it fires.
120 */ 122 */
121 if (!(gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)) { 123 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
124 ACPI_GPE_DISPATCH_NONE) {
122 return_ACPI_STATUS(AE_NO_HANDLER); 125 return_ACPI_STATUS(AE_NO_HANDLER);
123 } 126 }
124 127
@@ -137,9 +140,9 @@ acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
137 140
138/******************************************************************************* 141/*******************************************************************************
139 * 142 *
140 * FUNCTION: acpi_raw_enable_gpe 143 * FUNCTION: acpi_ev_add_gpe_reference
141 * 144 *
142 * PARAMETERS: gpe_event_info - GPE to enable 145 * PARAMETERS: gpe_event_info - Add a reference to this GPE
143 * 146 *
144 * RETURN: Status 147 * RETURN: Status
145 * 148 *
@@ -148,16 +151,21 @@ acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
148 * 151 *
149 ******************************************************************************/ 152 ******************************************************************************/
150 153
151acpi_status acpi_raw_enable_gpe(struct acpi_gpe_event_info *gpe_event_info) 154acpi_status acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
152{ 155{
153 acpi_status status = AE_OK; 156 acpi_status status = AE_OK;
154 157
158 ACPI_FUNCTION_TRACE(ev_add_gpe_reference);
159
155 if (gpe_event_info->runtime_count == ACPI_UINT8_MAX) { 160 if (gpe_event_info->runtime_count == ACPI_UINT8_MAX) {
156 return_ACPI_STATUS(AE_LIMIT); 161 return_ACPI_STATUS(AE_LIMIT);
157 } 162 }
158 163
159 gpe_event_info->runtime_count++; 164 gpe_event_info->runtime_count++;
160 if (gpe_event_info->runtime_count == 1) { 165 if (gpe_event_info->runtime_count == 1) {
166
167 /* Enable on first reference */
168
161 status = acpi_ev_update_gpe_enable_mask(gpe_event_info); 169 status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
162 if (ACPI_SUCCESS(status)) { 170 if (ACPI_SUCCESS(status)) {
163 status = acpi_ev_enable_gpe(gpe_event_info); 171 status = acpi_ev_enable_gpe(gpe_event_info);
@@ -173,9 +181,9 @@ acpi_status acpi_raw_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
173 181
174/******************************************************************************* 182/*******************************************************************************
175 * 183 *
176 * FUNCTION: acpi_raw_disable_gpe 184 * FUNCTION: acpi_ev_remove_gpe_reference
177 * 185 *
178 * PARAMETERS: gpe_event_info - GPE to disable 186 * PARAMETERS: gpe_event_info - Remove a reference to this GPE
179 * 187 *
180 * RETURN: Status 188 * RETURN: Status
181 * 189 *
@@ -184,16 +192,21 @@ acpi_status acpi_raw_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
184 * 192 *
185 ******************************************************************************/ 193 ******************************************************************************/
186 194
187acpi_status acpi_raw_disable_gpe(struct acpi_gpe_event_info *gpe_event_info) 195acpi_status acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
188{ 196{
189 acpi_status status = AE_OK; 197 acpi_status status = AE_OK;
190 198
199 ACPI_FUNCTION_TRACE(ev_remove_gpe_reference);
200
191 if (!gpe_event_info->runtime_count) { 201 if (!gpe_event_info->runtime_count) {
192 return_ACPI_STATUS(AE_LIMIT); 202 return_ACPI_STATUS(AE_LIMIT);
193 } 203 }
194 204
195 gpe_event_info->runtime_count--; 205 gpe_event_info->runtime_count--;
196 if (!gpe_event_info->runtime_count) { 206 if (!gpe_event_info->runtime_count) {
207
208 /* Disable on last reference */
209
197 status = acpi_ev_update_gpe_enable_mask(gpe_event_info); 210 status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
198 if (ACPI_SUCCESS(status)) { 211 if (ACPI_SUCCESS(status)) {
199 status = acpi_hw_low_set_gpe(gpe_event_info, 212 status = acpi_hw_low_set_gpe(gpe_event_info,
@@ -379,7 +392,7 @@ u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
379 } 392 }
380 393
381 ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS, 394 ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
382 "Read GPE Register at GPE%X: Status=%02X, Enable=%02X\n", 395 "Read GPE Register at GPE%02X: Status=%02X, Enable=%02X\n",
383 gpe_register_info->base_gpe_number, 396 gpe_register_info->base_gpe_number,
384 status_reg, enable_reg)); 397 status_reg, enable_reg));
385 398
@@ -405,7 +418,9 @@ u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
405 * or method. 418 * or method.
406 */ 419 */
407 int_status |= 420 int_status |=
408 acpi_ev_gpe_dispatch(&gpe_block-> 421 acpi_ev_gpe_dispatch(gpe_block->
422 node,
423 &gpe_block->
409 event_info[((acpi_size) i * ACPI_GPE_REGISTER_WIDTH) + j], j + gpe_register_info->base_gpe_number); 424 event_info[((acpi_size) i * ACPI_GPE_REGISTER_WIDTH) + j], j + gpe_register_info->base_gpe_number);
410 } 425 }
411 } 426 }
@@ -435,17 +450,25 @@ u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
435 * an interrupt handler. 450 * an interrupt handler.
436 * 451 *
437 ******************************************************************************/ 452 ******************************************************************************/
438static void acpi_ev_asynch_enable_gpe(void *context);
439 453
440static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context) 454static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
441{ 455{
442 struct acpi_gpe_event_info *gpe_event_info = (void *)context; 456 struct acpi_gpe_event_info *gpe_event_info = context;
443 acpi_status status; 457 acpi_status status;
444 struct acpi_gpe_event_info local_gpe_event_info; 458 struct acpi_gpe_event_info *local_gpe_event_info;
445 struct acpi_evaluate_info *info; 459 struct acpi_evaluate_info *info;
446 460
447 ACPI_FUNCTION_TRACE(ev_asynch_execute_gpe_method); 461 ACPI_FUNCTION_TRACE(ev_asynch_execute_gpe_method);
448 462
463 /* Allocate a local GPE block */
464
465 local_gpe_event_info =
466 ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_event_info));
467 if (!local_gpe_event_info) {
468 ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY, "while handling a GPE"));
469 return_VOID;
470 }
471
449 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 472 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
450 if (ACPI_FAILURE(status)) { 473 if (ACPI_FAILURE(status)) {
451 return_VOID; 474 return_VOID;
@@ -462,7 +485,7 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
462 * Take a snapshot of the GPE info for this level - we copy the info to 485 * Take a snapshot of the GPE info for this level - we copy the info to
463 * prevent a race condition with remove_handler/remove_block. 486 * prevent a race condition with remove_handler/remove_block.
464 */ 487 */
465 ACPI_MEMCPY(&local_gpe_event_info, gpe_event_info, 488 ACPI_MEMCPY(local_gpe_event_info, gpe_event_info,
466 sizeof(struct acpi_gpe_event_info)); 489 sizeof(struct acpi_gpe_event_info));
467 490
468 status = acpi_ut_release_mutex(ACPI_MTX_EVENTS); 491 status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
@@ -470,12 +493,26 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
470 return_VOID; 493 return_VOID;
471 } 494 }
472 495
473 /* 496 /* Do the correct dispatch - normal method or implicit notify */
474 * Must check for control method type dispatch one more time to avoid a 497
475 * race with ev_gpe_install_handler 498 switch (local_gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) {
476 */ 499 case ACPI_GPE_DISPATCH_NOTIFY:
477 if ((local_gpe_event_info.flags & ACPI_GPE_DISPATCH_MASK) == 500
478 ACPI_GPE_DISPATCH_METHOD) { 501 /*
502 * Implicit notify.
503 * Dispatch a DEVICE_WAKE notify to the appropriate handler.
504 * NOTE: the request is queued for execution after this method
505 * completes. The notify handlers are NOT invoked synchronously
506 * from this thread -- because handlers may in turn run other
507 * control methods.
508 */
509 status =
510 acpi_ev_queue_notify_request(local_gpe_event_info->dispatch.
511 device_node,
512 ACPI_NOTIFY_DEVICE_WAKE);
513 break;
514
515 case ACPI_GPE_DISPATCH_METHOD:
479 516
480 /* Allocate the evaluation information block */ 517 /* Allocate the evaluation information block */
481 518
@@ -488,7 +525,7 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
488 * control method that corresponds to this GPE 525 * control method that corresponds to this GPE
489 */ 526 */
490 info->prefix_node = 527 info->prefix_node =
491 local_gpe_event_info.dispatch.method_node; 528 local_gpe_event_info->dispatch.method_node;
492 info->flags = ACPI_IGNORE_RETURN_VALUE; 529 info->flags = ACPI_IGNORE_RETURN_VALUE;
493 530
494 status = acpi_ns_evaluate(info); 531 status = acpi_ns_evaluate(info);
@@ -499,46 +536,98 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
499 ACPI_EXCEPTION((AE_INFO, status, 536 ACPI_EXCEPTION((AE_INFO, status,
500 "while evaluating GPE method [%4.4s]", 537 "while evaluating GPE method [%4.4s]",
501 acpi_ut_get_node_name 538 acpi_ut_get_node_name
502 (local_gpe_event_info.dispatch. 539 (local_gpe_event_info->dispatch.
503 method_node))); 540 method_node)));
504 } 541 }
542
543 break;
544
545 default:
546 return_VOID; /* Should never happen */
505 } 547 }
548
506 /* Defer enabling of GPE until all notify handlers are done */ 549 /* Defer enabling of GPE until all notify handlers are done */
507 acpi_os_execute(OSL_NOTIFY_HANDLER, acpi_ev_asynch_enable_gpe, 550
508 gpe_event_info); 551 status = acpi_os_execute(OSL_NOTIFY_HANDLER,
552 acpi_ev_asynch_enable_gpe,
553 local_gpe_event_info);
554 if (ACPI_FAILURE(status)) {
555 ACPI_FREE(local_gpe_event_info);
556 }
509 return_VOID; 557 return_VOID;
510} 558}
511 559
512static void acpi_ev_asynch_enable_gpe(void *context) 560
561/*******************************************************************************
562 *
563 * FUNCTION: acpi_ev_asynch_enable_gpe
564 *
565 * PARAMETERS: Context (gpe_event_info) - Info for this GPE
566 * Callback from acpi_os_execute
567 *
568 * RETURN: None
569 *
570 * DESCRIPTION: Asynchronous clear/enable for GPE. This allows the GPE to
571 * complete (i.e., finish execution of Notify)
572 *
573 ******************************************************************************/
574
575static void ACPI_SYSTEM_XFACE acpi_ev_asynch_enable_gpe(void *context)
513{ 576{
514 struct acpi_gpe_event_info *gpe_event_info = context; 577 struct acpi_gpe_event_info *gpe_event_info = context;
578
579 (void)acpi_ev_finish_gpe(gpe_event_info);
580
581 ACPI_FREE(gpe_event_info);
582 return;
583}
584
585
586/*******************************************************************************
587 *
588 * FUNCTION: acpi_ev_finish_gpe
589 *
590 * PARAMETERS: gpe_event_info - Info for this GPE
591 *
592 * RETURN: Status
593 *
594 * DESCRIPTION: Clear/Enable a GPE. Common code that is used after execution
595 * of a GPE method or a synchronous or asynchronous GPE handler.
596 *
597 ******************************************************************************/
598
599acpi_status acpi_ev_finish_gpe(struct acpi_gpe_event_info *gpe_event_info)
600{
515 acpi_status status; 601 acpi_status status;
602
516 if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) == 603 if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
517 ACPI_GPE_LEVEL_TRIGGERED) { 604 ACPI_GPE_LEVEL_TRIGGERED) {
518 /* 605 /*
519 * GPE is level-triggered, we clear the GPE status bit after handling 606 * GPE is level-triggered, we clear the GPE status bit after
520 * the event. 607 * handling the event.
521 */ 608 */
522 status = acpi_hw_clear_gpe(gpe_event_info); 609 status = acpi_hw_clear_gpe(gpe_event_info);
523 if (ACPI_FAILURE(status)) { 610 if (ACPI_FAILURE(status)) {
524 return_VOID; 611 return (status);
525 } 612 }
526 } 613 }
527 614
528 /* 615 /*
529 * Enable this GPE, conditionally. This means that the GPE will only be 616 * Enable this GPE, conditionally. This means that the GPE will
530 * physically enabled if the enable_for_run bit is set in the event_info 617 * only be physically enabled if the enable_for_run bit is set
618 * in the event_info.
531 */ 619 */
532 (void)acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_COND_ENABLE); 620 (void)acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_CONDITIONAL_ENABLE);
533 621 return (AE_OK);
534 return_VOID;
535} 622}
536 623
624
537/******************************************************************************* 625/*******************************************************************************
538 * 626 *
539 * FUNCTION: acpi_ev_gpe_dispatch 627 * FUNCTION: acpi_ev_gpe_dispatch
540 * 628 *
541 * PARAMETERS: gpe_event_info - Info for this GPE 629 * PARAMETERS: gpe_device - Device node. NULL for GPE0/GPE1
630 * gpe_event_info - Info for this GPE
542 * gpe_number - Number relative to the parent GPE block 631 * gpe_number - Number relative to the parent GPE block
543 * 632 *
544 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED 633 * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
@@ -551,13 +640,22 @@ static void acpi_ev_asynch_enable_gpe(void *context)
551 ******************************************************************************/ 640 ******************************************************************************/
552 641
553u32 642u32
554acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number) 643acpi_ev_gpe_dispatch(struct acpi_namespace_node *gpe_device,
644 struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
555{ 645{
556 acpi_status status; 646 acpi_status status;
647 u32 return_value;
557 648
558 ACPI_FUNCTION_TRACE(ev_gpe_dispatch); 649 ACPI_FUNCTION_TRACE(ev_gpe_dispatch);
559 650
560 acpi_os_gpe_count(gpe_number); 651 /* Invoke global event handler if present */
652
653 acpi_gpe_count++;
654 if (acpi_gbl_global_event_handler) {
655 acpi_gbl_global_event_handler(ACPI_EVENT_TYPE_GPE, gpe_device,
656 gpe_number,
657 acpi_gbl_global_event_handler_context);
658 }
561 659
562 /* 660 /*
563 * If edge-triggered, clear the GPE status bit now. Note that 661 * If edge-triggered, clear the GPE status bit now. Note that
@@ -568,59 +666,55 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
568 status = acpi_hw_clear_gpe(gpe_event_info); 666 status = acpi_hw_clear_gpe(gpe_event_info);
569 if (ACPI_FAILURE(status)) { 667 if (ACPI_FAILURE(status)) {
570 ACPI_EXCEPTION((AE_INFO, status, 668 ACPI_EXCEPTION((AE_INFO, status,
571 "Unable to clear GPE[0x%2X]", 669 "Unable to clear GPE%02X", gpe_number));
572 gpe_number));
573 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED); 670 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
574 } 671 }
575 } 672 }
576 673
577 /* 674 /*
578 * Dispatch the GPE to either an installed handler, or the control method 675 * Always disable the GPE so that it does not keep firing before
579 * associated with this GPE (_Lxx or _Exx). If a handler exists, we invoke 676 * any asynchronous activity completes (either from the execution
580 * it and do not attempt to run the method. If there is neither a handler 677 * of a GPE method or an asynchronous GPE handler.)
581 * nor a method, we disable this GPE to prevent further such pointless 678 *
582 * events from firing. 679 * If there is no handler or method to run, just disable the
680 * GPE and leave it disabled permanently to prevent further such
681 * pointless events from firing.
682 */
683 status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_DISABLE);
684 if (ACPI_FAILURE(status)) {
685 ACPI_EXCEPTION((AE_INFO, status,
686 "Unable to disable GPE%02X", gpe_number));
687 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
688 }
689
690 /*
691 * Dispatch the GPE to either an installed handler or the control
692 * method associated with this GPE (_Lxx or _Exx). If a handler
693 * exists, we invoke it and do not attempt to run the method.
694 * If there is neither a handler nor a method, leave the GPE
695 * disabled.
583 */ 696 */
584 switch (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) { 697 switch (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) {
585 case ACPI_GPE_DISPATCH_HANDLER: 698 case ACPI_GPE_DISPATCH_HANDLER:
586 699
587 /* 700 /* Invoke the installed handler (at interrupt level) */
588 * Invoke the installed handler (at interrupt level)
589 * Ignore return status for now.
590 * TBD: leave GPE disabled on error?
591 */
592 (void)gpe_event_info->dispatch.handler->address(gpe_event_info->
593 dispatch.
594 handler->
595 context);
596 701
597 /* It is now safe to clear level-triggered events. */ 702 return_value =
703 gpe_event_info->dispatch.handler->address(gpe_device,
704 gpe_number,
705 gpe_event_info->
706 dispatch.handler->
707 context);
598 708
599 if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) == 709 /* If requested, clear (if level-triggered) and reenable the GPE */
600 ACPI_GPE_LEVEL_TRIGGERED) { 710
601 status = acpi_hw_clear_gpe(gpe_event_info); 711 if (return_value & ACPI_REENABLE_GPE) {
602 if (ACPI_FAILURE(status)) { 712 (void)acpi_ev_finish_gpe(gpe_event_info);
603 ACPI_EXCEPTION((AE_INFO, status,
604 "Unable to clear GPE[0x%2X]",
605 gpe_number));
606 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
607 }
608 } 713 }
609 break; 714 break;
610 715
611 case ACPI_GPE_DISPATCH_METHOD: 716 case ACPI_GPE_DISPATCH_METHOD:
612 717 case ACPI_GPE_DISPATCH_NOTIFY:
613 /*
614 * Disable the GPE, so it doesn't keep firing before the method has a
615 * chance to run (it runs asynchronously with interrupts enabled).
616 */
617 status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_DISABLE);
618 if (ACPI_FAILURE(status)) {
619 ACPI_EXCEPTION((AE_INFO, status,
620 "Unable to disable GPE[0x%2X]",
621 gpe_number));
622 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
623 }
624 718
625 /* 719 /*
626 * Execute the method associated with the GPE 720 * Execute the method associated with the GPE
@@ -631,7 +725,7 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
631 gpe_event_info); 725 gpe_event_info);
632 if (ACPI_FAILURE(status)) { 726 if (ACPI_FAILURE(status)) {
633 ACPI_EXCEPTION((AE_INFO, status, 727 ACPI_EXCEPTION((AE_INFO, status,
634 "Unable to queue handler for GPE[0x%2X] - event disabled", 728 "Unable to queue handler for GPE%2X - event disabled",
635 gpe_number)); 729 gpe_number));
636 } 730 }
637 break; 731 break;
@@ -644,20 +738,9 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
644 * a GPE to be enabled if it has no handler or method. 738 * a GPE to be enabled if it has no handler or method.
645 */ 739 */
646 ACPI_ERROR((AE_INFO, 740 ACPI_ERROR((AE_INFO,
647 "No handler or method for GPE[0x%2X], disabling event", 741 "No handler or method for GPE%02X, disabling event",
648 gpe_number)); 742 gpe_number));
649 743
650 /*
651 * Disable the GPE. The GPE will remain disabled a handler
652 * is installed or ACPICA is restarted.
653 */
654 status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_DISABLE);
655 if (ACPI_FAILURE(status)) {
656 ACPI_EXCEPTION((AE_INFO, status,
657 "Unable to disable GPE[0x%2X]",
658 gpe_number));
659 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
660 }
661 break; 744 break;
662 } 745 }
663 746
diff --git a/drivers/acpi/acpica/evgpeblk.c b/drivers/acpi/acpica/evgpeblk.c
index 020add3eee1c..9acb86958c09 100644
--- a/drivers/acpi/acpica/evgpeblk.c
+++ b/drivers/acpi/acpica/evgpeblk.c
@@ -361,9 +361,9 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
361 361
362 gpe_block->node = gpe_device; 362 gpe_block->node = gpe_device;
363 gpe_block->gpe_count = (u16)(register_count * ACPI_GPE_REGISTER_WIDTH); 363 gpe_block->gpe_count = (u16)(register_count * ACPI_GPE_REGISTER_WIDTH);
364 gpe_block->initialized = FALSE;
364 gpe_block->register_count = register_count; 365 gpe_block->register_count = register_count;
365 gpe_block->block_base_number = gpe_block_base_number; 366 gpe_block->block_base_number = gpe_block_base_number;
366 gpe_block->initialized = FALSE;
367 367
368 ACPI_MEMCPY(&gpe_block->block_address, gpe_block_address, 368 ACPI_MEMCPY(&gpe_block->block_address, gpe_block_address,
369 sizeof(struct acpi_generic_address)); 369 sizeof(struct acpi_generic_address));
@@ -386,7 +386,7 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
386 return_ACPI_STATUS(status); 386 return_ACPI_STATUS(status);
387 } 387 }
388 388
389 acpi_all_gpes_initialized = FALSE; 389 acpi_gbl_all_gpes_initialized = FALSE;
390 390
391 /* Find all GPE methods (_Lxx or_Exx) for this block */ 391 /* Find all GPE methods (_Lxx or_Exx) for this block */
392 392
@@ -423,14 +423,12 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
423 * 423 *
424 * FUNCTION: acpi_ev_initialize_gpe_block 424 * FUNCTION: acpi_ev_initialize_gpe_block
425 * 425 *
426 * PARAMETERS: gpe_device - Handle to the parent GPE block 426 * PARAMETERS: acpi_gpe_callback
427 * gpe_block - Gpe Block info
428 * 427 *
429 * RETURN: Status 428 * RETURN: Status
430 * 429 *
431 * DESCRIPTION: Initialize and enable a GPE block. First find and run any 430 * DESCRIPTION: Initialize and enable a GPE block. Enable GPEs that have
432 * _PRT methods associated with the block, then enable the 431 * associated methods.
433 * appropriate GPEs.
434 * Note: Assumes namespace is locked. 432 * Note: Assumes namespace is locked.
435 * 433 *
436 ******************************************************************************/ 434 ******************************************************************************/
@@ -450,8 +448,8 @@ acpi_ev_initialize_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
450 ACPI_FUNCTION_TRACE(ev_initialize_gpe_block); 448 ACPI_FUNCTION_TRACE(ev_initialize_gpe_block);
451 449
452 /* 450 /*
453 * Ignore a null GPE block (e.g., if no GPE block 1 exists) and 451 * Ignore a null GPE block (e.g., if no GPE block 1 exists), and
454 * GPE blocks that have been initialized already. 452 * any GPE blocks that have been initialized already.
455 */ 453 */
456 if (!gpe_block || gpe_block->initialized) { 454 if (!gpe_block || gpe_block->initialized) {
457 return_ACPI_STATUS(AE_OK); 455 return_ACPI_STATUS(AE_OK);
@@ -459,8 +457,8 @@ acpi_ev_initialize_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
459 457
460 /* 458 /*
461 * Enable all GPEs that have a corresponding method and have the 459 * Enable all GPEs that have a corresponding method and have the
462 * ACPI_GPE_CAN_WAKE flag unset. Any other GPEs within this block must 460 * ACPI_GPE_CAN_WAKE flag unset. Any other GPEs within this block
463 * be enabled via the acpi_enable_gpe() interface. 461 * must be enabled via the acpi_enable_gpe() interface.
464 */ 462 */
465 gpe_enabled_count = 0; 463 gpe_enabled_count = 0;
466 464
@@ -472,14 +470,19 @@ acpi_ev_initialize_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
472 gpe_index = (i * ACPI_GPE_REGISTER_WIDTH) + j; 470 gpe_index = (i * ACPI_GPE_REGISTER_WIDTH) + j;
473 gpe_event_info = &gpe_block->event_info[gpe_index]; 471 gpe_event_info = &gpe_block->event_info[gpe_index];
474 472
475 /* Ignore GPEs that have no corresponding _Lxx/_Exx method */ 473 /*
476 474 * Ignore GPEs that have no corresponding _Lxx/_Exx method
477 if (!(gpe_event_info->flags & ACPI_GPE_DISPATCH_METHOD) 475 * and GPEs that are used to wake the system
476 */
477 if (((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
478 ACPI_GPE_DISPATCH_NONE)
479 || ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)
480 == ACPI_GPE_DISPATCH_HANDLER)
478 || (gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) { 481 || (gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
479 continue; 482 continue;
480 } 483 }
481 484
482 status = acpi_raw_enable_gpe(gpe_event_info); 485 status = acpi_ev_add_gpe_reference(gpe_event_info);
483 if (ACPI_FAILURE(status)) { 486 if (ACPI_FAILURE(status)) {
484 ACPI_EXCEPTION((AE_INFO, status, 487 ACPI_EXCEPTION((AE_INFO, status,
485 "Could not enable GPE 0x%02X", 488 "Could not enable GPE 0x%02X",
diff --git a/drivers/acpi/acpica/evgpeinit.c b/drivers/acpi/acpica/evgpeinit.c
index 4c8dea513b66..c59dc2340593 100644
--- a/drivers/acpi/acpica/evgpeinit.c
+++ b/drivers/acpi/acpica/evgpeinit.c
@@ -45,11 +45,27 @@
45#include "accommon.h" 45#include "accommon.h"
46#include "acevents.h" 46#include "acevents.h"
47#include "acnamesp.h" 47#include "acnamesp.h"
48#include "acinterp.h"
49 48
50#define _COMPONENT ACPI_EVENTS 49#define _COMPONENT ACPI_EVENTS
51ACPI_MODULE_NAME("evgpeinit") 50ACPI_MODULE_NAME("evgpeinit")
52 51
52/*
53 * Note: History of _PRW support in ACPICA
54 *
55 * Originally (2000 - 2010), the GPE initialization code performed a walk of
56 * the entire namespace to execute the _PRW methods and detect all GPEs
57 * capable of waking the system.
58 *
59 * As of 10/2010, the _PRW method execution has been removed since it is
60 * actually unnecessary. The host OS must in fact execute all _PRW methods
61 * in order to identify the device/power-resource dependencies. We now put
62 * the onus on the host OS to identify the wake GPEs as part of this process
63 * and to inform ACPICA of these GPEs via the acpi_setup_gpe_for_wake interface. This
64 * not only reduces the complexity of the ACPICA initialization code, but in
65 * some cases (on systems with very large namespaces) it should reduce the
66 * kernel boot time as well.
67 */
68
53/******************************************************************************* 69/*******************************************************************************
54 * 70 *
55 * FUNCTION: acpi_ev_gpe_initialize 71 * FUNCTION: acpi_ev_gpe_initialize
@@ -222,7 +238,7 @@ void acpi_ev_update_gpes(acpi_owner_id table_owner_id)
222 acpi_status status = AE_OK; 238 acpi_status status = AE_OK;
223 239
224 /* 240 /*
225 * 2) Find any _Lxx/_Exx GPE methods that have just been loaded. 241 * Find any _Lxx/_Exx GPE methods that have just been loaded.
226 * 242 *
227 * Any GPEs that correspond to new _Lxx/_Exx methods are immediately 243 * Any GPEs that correspond to new _Lxx/_Exx methods are immediately
228 * enabled. 244 * enabled.
@@ -235,9 +251,9 @@ void acpi_ev_update_gpes(acpi_owner_id table_owner_id)
235 return; 251 return;
236 } 252 }
237 253
254 walk_info.count = 0;
238 walk_info.owner_id = table_owner_id; 255 walk_info.owner_id = table_owner_id;
239 walk_info.execute_by_owner_id = TRUE; 256 walk_info.execute_by_owner_id = TRUE;
240 walk_info.count = 0;
241 257
242 /* Walk the interrupt level descriptor list */ 258 /* Walk the interrupt level descriptor list */
243 259
@@ -298,7 +314,7 @@ void acpi_ev_update_gpes(acpi_owner_id table_owner_id)
298 * xx - is the GPE number [in HEX] 314 * xx - is the GPE number [in HEX]
299 * 315 *
300 * If walk_info->execute_by_owner_id is TRUE, we only execute examine GPE methods 316 * If walk_info->execute_by_owner_id is TRUE, we only execute examine GPE methods
301 * with that owner. 317 * with that owner.
302 * 318 *
303 ******************************************************************************/ 319 ******************************************************************************/
304 320
@@ -415,6 +431,7 @@ acpi_ev_match_gpe_method(acpi_handle obj_handle,
415 * Add the GPE information from above to the gpe_event_info block for 431 * Add the GPE information from above to the gpe_event_info block for
416 * use during dispatch of this GPE. 432 * use during dispatch of this GPE.
417 */ 433 */
434 gpe_event_info->flags &= ~(ACPI_GPE_DISPATCH_MASK);
418 gpe_event_info->flags |= (u8)(type | ACPI_GPE_DISPATCH_METHOD); 435 gpe_event_info->flags |= (u8)(type | ACPI_GPE_DISPATCH_METHOD);
419 gpe_event_info->dispatch.method_node = method_node; 436 gpe_event_info->dispatch.method_node = method_node;
420 437
diff --git a/drivers/acpi/acpica/evgpeutil.c b/drivers/acpi/acpica/evgpeutil.c
index 19a0e513ea48..10e477494dcf 100644
--- a/drivers/acpi/acpica/evgpeutil.c
+++ b/drivers/acpi/acpica/evgpeutil.c
@@ -154,6 +154,45 @@ u8 acpi_ev_valid_gpe_event(struct acpi_gpe_event_info *gpe_event_info)
154 154
155/******************************************************************************* 155/*******************************************************************************
156 * 156 *
157 * FUNCTION: acpi_ev_get_gpe_device
158 *
159 * PARAMETERS: GPE_WALK_CALLBACK
160 *
161 * RETURN: Status
162 *
163 * DESCRIPTION: Matches the input GPE index (0-current_gpe_count) with a GPE
164 * block device. NULL if the GPE is one of the FADT-defined GPEs.
165 *
166 ******************************************************************************/
167
168acpi_status
169acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
170 struct acpi_gpe_block_info *gpe_block, void *context)
171{
172 struct acpi_gpe_device_info *info = context;
173
174 /* Increment Index by the number of GPEs in this block */
175
176 info->next_block_base_index += gpe_block->gpe_count;
177
178 if (info->index < info->next_block_base_index) {
179 /*
180 * The GPE index is within this block, get the node. Leave the node
181 * NULL for the FADT-defined GPEs
182 */
183 if ((gpe_block->node)->type == ACPI_TYPE_DEVICE) {
184 info->gpe_device = gpe_block->node;
185 }
186
187 info->status = AE_OK;
188 return (AE_CTRL_END);
189 }
190
191 return (AE_OK);
192}
193
194/*******************************************************************************
195 *
157 * FUNCTION: acpi_ev_get_gpe_xrupt_block 196 * FUNCTION: acpi_ev_get_gpe_xrupt_block
158 * 197 *
159 * PARAMETERS: interrupt_number - Interrupt for a GPE block 198 * PARAMETERS: interrupt_number - Interrupt for a GPE block
diff --git a/drivers/acpi/acpica/evxface.c b/drivers/acpi/acpica/evxface.c
index 36af222cac65..1226689bdb1b 100644
--- a/drivers/acpi/acpica/evxface.c
+++ b/drivers/acpi/acpica/evxface.c
@@ -92,6 +92,57 @@ acpi_status acpi_install_exception_handler(acpi_exception_handler handler)
92 92
93ACPI_EXPORT_SYMBOL(acpi_install_exception_handler) 93ACPI_EXPORT_SYMBOL(acpi_install_exception_handler)
94#endif /* ACPI_FUTURE_USAGE */ 94#endif /* ACPI_FUTURE_USAGE */
95
96/*******************************************************************************
97 *
98 * FUNCTION: acpi_install_global_event_handler
99 *
100 * PARAMETERS: Handler - Pointer to the global event handler function
101 * Context - Value passed to the handler on each event
102 *
103 * RETURN: Status
104 *
105 * DESCRIPTION: Saves the pointer to the handler function. The global handler
106 * is invoked upon each incoming GPE and Fixed Event. It is
107 * invoked at interrupt level at the time of the event dispatch.
108 * Can be used to update event counters, etc.
109 *
110 ******************************************************************************/
111acpi_status
112acpi_install_global_event_handler(ACPI_GBL_EVENT_HANDLER handler, void *context)
113{
114 acpi_status status;
115
116 ACPI_FUNCTION_TRACE(acpi_install_global_event_handler);
117
118 /* Parameter validation */
119
120 if (!handler) {
121 return_ACPI_STATUS(AE_BAD_PARAMETER);
122 }
123
124 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
125 if (ACPI_FAILURE(status)) {
126 return_ACPI_STATUS(status);
127 }
128
129 /* Don't allow two handlers. */
130
131 if (acpi_gbl_global_event_handler) {
132 status = AE_ALREADY_EXISTS;
133 goto cleanup;
134 }
135
136 acpi_gbl_global_event_handler = handler;
137 acpi_gbl_global_event_handler_context = context;
138
139 cleanup:
140 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
141 return_ACPI_STATUS(status);
142}
143
144ACPI_EXPORT_SYMBOL(acpi_install_global_event_handler)
145
95/******************************************************************************* 146/*******************************************************************************
96 * 147 *
97 * FUNCTION: acpi_install_fixed_event_handler 148 * FUNCTION: acpi_install_fixed_event_handler
@@ -671,10 +722,10 @@ ACPI_EXPORT_SYMBOL(acpi_remove_notify_handler)
671acpi_status 722acpi_status
672acpi_install_gpe_handler(acpi_handle gpe_device, 723acpi_install_gpe_handler(acpi_handle gpe_device,
673 u32 gpe_number, 724 u32 gpe_number,
674 u32 type, acpi_event_handler address, void *context) 725 u32 type, acpi_gpe_handler address, void *context)
675{ 726{
676 struct acpi_gpe_event_info *gpe_event_info; 727 struct acpi_gpe_event_info *gpe_event_info;
677 struct acpi_handler_info *handler; 728 struct acpi_gpe_handler_info *handler;
678 acpi_status status; 729 acpi_status status;
679 acpi_cpu_flags flags; 730 acpi_cpu_flags flags;
680 731
@@ -693,7 +744,7 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
693 744
694 /* Allocate memory for the handler object */ 745 /* Allocate memory for the handler object */
695 746
696 handler = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_handler_info)); 747 handler = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_handler_info));
697 if (!handler) { 748 if (!handler) {
698 status = AE_NO_MEMORY; 749 status = AE_NO_MEMORY;
699 goto unlock_and_exit; 750 goto unlock_and_exit;
@@ -722,7 +773,7 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
722 handler->address = address; 773 handler->address = address;
723 handler->context = context; 774 handler->context = context;
724 handler->method_node = gpe_event_info->dispatch.method_node; 775 handler->method_node = gpe_event_info->dispatch.method_node;
725 handler->orig_flags = gpe_event_info->flags & 776 handler->original_flags = gpe_event_info->flags &
726 (ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK); 777 (ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
727 778
728 /* 779 /*
@@ -731,10 +782,10 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
731 * disabled now to avoid spurious execution of the handler. 782 * disabled now to avoid spurious execution of the handler.
732 */ 783 */
733 784
734 if ((handler->orig_flags & ACPI_GPE_DISPATCH_METHOD) 785 if ((handler->original_flags & ACPI_GPE_DISPATCH_METHOD)
735 && gpe_event_info->runtime_count) { 786 && gpe_event_info->runtime_count) {
736 handler->orig_enabled = 1; 787 handler->originally_enabled = 1;
737 (void)acpi_raw_disable_gpe(gpe_event_info); 788 (void)acpi_ev_remove_gpe_reference(gpe_event_info);
738 } 789 }
739 790
740 /* Install the handler */ 791 /* Install the handler */
@@ -777,10 +828,10 @@ ACPI_EXPORT_SYMBOL(acpi_install_gpe_handler)
777 ******************************************************************************/ 828 ******************************************************************************/
778acpi_status 829acpi_status
779acpi_remove_gpe_handler(acpi_handle gpe_device, 830acpi_remove_gpe_handler(acpi_handle gpe_device,
780 u32 gpe_number, acpi_event_handler address) 831 u32 gpe_number, acpi_gpe_handler address)
781{ 832{
782 struct acpi_gpe_event_info *gpe_event_info; 833 struct acpi_gpe_event_info *gpe_event_info;
783 struct acpi_handler_info *handler; 834 struct acpi_gpe_handler_info *handler;
784 acpi_status status; 835 acpi_status status;
785 acpi_cpu_flags flags; 836 acpi_cpu_flags flags;
786 837
@@ -835,7 +886,7 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
835 gpe_event_info->dispatch.method_node = handler->method_node; 886 gpe_event_info->dispatch.method_node = handler->method_node;
836 gpe_event_info->flags &= 887 gpe_event_info->flags &=
837 ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK); 888 ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
838 gpe_event_info->flags |= handler->orig_flags; 889 gpe_event_info->flags |= handler->original_flags;
839 890
840 /* 891 /*
841 * If the GPE was previously associated with a method and it was 892 * If the GPE was previously associated with a method and it was
@@ -843,9 +894,9 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
843 * post-initialization configuration. 894 * post-initialization configuration.
844 */ 895 */
845 896
846 if ((handler->orig_flags & ACPI_GPE_DISPATCH_METHOD) 897 if ((handler->original_flags & ACPI_GPE_DISPATCH_METHOD)
847 && handler->orig_enabled) 898 && handler->originally_enabled)
848 (void)acpi_raw_enable_gpe(gpe_event_info); 899 (void)acpi_ev_add_gpe_reference(gpe_event_info);
849 900
850 /* Now we can free the handler object */ 901 /* Now we can free the handler object */
851 902
diff --git a/drivers/acpi/acpica/evxfevnt.c b/drivers/acpi/acpica/evxfevnt.c
index a1dabe3fd8ae..90488c1e0f3d 100644
--- a/drivers/acpi/acpica/evxfevnt.c
+++ b/drivers/acpi/acpica/evxfevnt.c
@@ -43,18 +43,11 @@
43 43
44#include <acpi/acpi.h> 44#include <acpi/acpi.h>
45#include "accommon.h" 45#include "accommon.h"
46#include "acevents.h"
47#include "acnamesp.h"
48#include "actables.h" 46#include "actables.h"
49 47
50#define _COMPONENT ACPI_EVENTS 48#define _COMPONENT ACPI_EVENTS
51ACPI_MODULE_NAME("evxfevnt") 49ACPI_MODULE_NAME("evxfevnt")
52 50
53/* Local prototypes */
54static acpi_status
55acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
56 struct acpi_gpe_block_info *gpe_block, void *context);
57
58/******************************************************************************* 51/*******************************************************************************
59 * 52 *
60 * FUNCTION: acpi_enable 53 * FUNCTION: acpi_enable
@@ -213,185 +206,6 @@ ACPI_EXPORT_SYMBOL(acpi_enable_event)
213 206
214/******************************************************************************* 207/*******************************************************************************
215 * 208 *
216 * FUNCTION: acpi_gpe_wakeup
217 *
218 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
219 * gpe_number - GPE level within the GPE block
220 * Action - Enable or Disable
221 *
222 * RETURN: Status
223 *
224 * DESCRIPTION: Set or clear the GPE's wakeup enable mask bit.
225 *
226 ******************************************************************************/
227acpi_status acpi_gpe_wakeup(acpi_handle gpe_device, u32 gpe_number, u8 action)
228{
229 acpi_status status = AE_OK;
230 struct acpi_gpe_event_info *gpe_event_info;
231 struct acpi_gpe_register_info *gpe_register_info;
232 acpi_cpu_flags flags;
233 u32 register_bit;
234
235 ACPI_FUNCTION_TRACE(acpi_gpe_wakeup);
236
237 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
238
239 /* Ensure that we have a valid GPE number */
240
241 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
242 if (!gpe_event_info || !(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
243 status = AE_BAD_PARAMETER;
244 goto unlock_and_exit;
245 }
246
247 gpe_register_info = gpe_event_info->register_info;
248 if (!gpe_register_info) {
249 status = AE_NOT_EXIST;
250 goto unlock_and_exit;
251 }
252
253 register_bit =
254 acpi_hw_get_gpe_register_bit(gpe_event_info, gpe_register_info);
255
256 /* Perform the action */
257
258 switch (action) {
259 case ACPI_GPE_ENABLE:
260 ACPI_SET_BIT(gpe_register_info->enable_for_wake,
261 (u8)register_bit);
262 break;
263
264 case ACPI_GPE_DISABLE:
265 ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,
266 (u8)register_bit);
267 break;
268
269 default:
270 ACPI_ERROR((AE_INFO, "%u, Invalid action", action));
271 status = AE_BAD_PARAMETER;
272 break;
273 }
274
275unlock_and_exit:
276 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
277 return_ACPI_STATUS(status);
278}
279
280ACPI_EXPORT_SYMBOL(acpi_gpe_wakeup)
281
282/*******************************************************************************
283 *
284 * FUNCTION: acpi_enable_gpe
285 *
286 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
287 * gpe_number - GPE level within the GPE block
288 *
289 * RETURN: Status
290 *
291 * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
292 * hardware-enabled.
293 *
294 ******************************************************************************/
295acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
296{
297 acpi_status status = AE_BAD_PARAMETER;
298 struct acpi_gpe_event_info *gpe_event_info;
299 acpi_cpu_flags flags;
300
301 ACPI_FUNCTION_TRACE(acpi_enable_gpe);
302
303 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
304
305 /* Ensure that we have a valid GPE number */
306
307 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
308 if (gpe_event_info) {
309 status = acpi_raw_enable_gpe(gpe_event_info);
310 }
311
312 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
313 return_ACPI_STATUS(status);
314}
315ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
316
317/*******************************************************************************
318 *
319 * FUNCTION: acpi_disable_gpe
320 *
321 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
322 * gpe_number - GPE level within the GPE block
323 *
324 * RETURN: Status
325 *
326 * DESCRIPTION: Remove a reference to a GPE. When the last reference is
327 * removed, only then is the GPE disabled (for runtime GPEs), or
328 * the GPE mask bit disabled (for wake GPEs)
329 *
330 ******************************************************************************/
331acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
332{
333 acpi_status status = AE_BAD_PARAMETER;
334 struct acpi_gpe_event_info *gpe_event_info;
335 acpi_cpu_flags flags;
336
337 ACPI_FUNCTION_TRACE(acpi_disable_gpe);
338
339 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
340
341 /* Ensure that we have a valid GPE number */
342
343 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
344 if (gpe_event_info) {
345 status = acpi_raw_disable_gpe(gpe_event_info) ;
346 }
347
348 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
349 return_ACPI_STATUS(status);
350}
351ACPI_EXPORT_SYMBOL(acpi_disable_gpe)
352
353/*******************************************************************************
354 *
355 * FUNCTION: acpi_gpe_can_wake
356 *
357 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
358 * gpe_number - GPE level within the GPE block
359 *
360 * RETURN: Status
361 *
362 * DESCRIPTION: Set the ACPI_GPE_CAN_WAKE flag for the given GPE. If the GPE
363 * has a corresponding method and is currently enabled, disable it
364 * (GPEs with corresponding methods are enabled unconditionally
365 * during initialization, but GPEs that can wake up are expected
366 * to be initially disabled).
367 *
368 ******************************************************************************/
369acpi_status acpi_gpe_can_wake(acpi_handle gpe_device, u32 gpe_number)
370{
371 acpi_status status = AE_OK;
372 struct acpi_gpe_event_info *gpe_event_info;
373 acpi_cpu_flags flags;
374
375 ACPI_FUNCTION_TRACE(acpi_gpe_can_wake);
376
377 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
378
379 /* Ensure that we have a valid GPE number */
380
381 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
382 if (gpe_event_info) {
383 gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
384 } else {
385 status = AE_BAD_PARAMETER;
386 }
387
388 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
389 return_ACPI_STATUS(status);
390}
391ACPI_EXPORT_SYMBOL(acpi_gpe_can_wake)
392
393/*******************************************************************************
394 *
395 * FUNCTION: acpi_disable_event 209 * FUNCTION: acpi_disable_event
396 * 210 *
397 * PARAMETERS: Event - The fixed eventto be enabled 211 * PARAMETERS: Event - The fixed eventto be enabled
@@ -483,44 +297,6 @@ ACPI_EXPORT_SYMBOL(acpi_clear_event)
483 297
484/******************************************************************************* 298/*******************************************************************************
485 * 299 *
486 * FUNCTION: acpi_clear_gpe
487 *
488 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
489 * gpe_number - GPE level within the GPE block
490 *
491 * RETURN: Status
492 *
493 * DESCRIPTION: Clear an ACPI event (general purpose)
494 *
495 ******************************************************************************/
496acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number)
497{
498 acpi_status status = AE_OK;
499 struct acpi_gpe_event_info *gpe_event_info;
500 acpi_cpu_flags flags;
501
502 ACPI_FUNCTION_TRACE(acpi_clear_gpe);
503
504 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
505
506 /* Ensure that we have a valid GPE number */
507
508 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
509 if (!gpe_event_info) {
510 status = AE_BAD_PARAMETER;
511 goto unlock_and_exit;
512 }
513
514 status = acpi_hw_clear_gpe(gpe_event_info);
515
516 unlock_and_exit:
517 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
518 return_ACPI_STATUS(status);
519}
520
521ACPI_EXPORT_SYMBOL(acpi_clear_gpe)
522/*******************************************************************************
523 *
524 * FUNCTION: acpi_get_event_status 300 * FUNCTION: acpi_get_event_status
525 * 301 *
526 * PARAMETERS: Event - The fixed event 302 * PARAMETERS: Event - The fixed event
@@ -575,379 +351,3 @@ acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
575} 351}
576 352
577ACPI_EXPORT_SYMBOL(acpi_get_event_status) 353ACPI_EXPORT_SYMBOL(acpi_get_event_status)
578
579/*******************************************************************************
580 *
581 * FUNCTION: acpi_get_gpe_status
582 *
583 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
584 * gpe_number - GPE level within the GPE block
585 * event_status - Where the current status of the event will
586 * be returned
587 *
588 * RETURN: Status
589 *
590 * DESCRIPTION: Get status of an event (general purpose)
591 *
592 ******************************************************************************/
593acpi_status
594acpi_get_gpe_status(acpi_handle gpe_device,
595 u32 gpe_number, acpi_event_status *event_status)
596{
597 acpi_status status = AE_OK;
598 struct acpi_gpe_event_info *gpe_event_info;
599 acpi_cpu_flags flags;
600
601 ACPI_FUNCTION_TRACE(acpi_get_gpe_status);
602
603 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
604
605 /* Ensure that we have a valid GPE number */
606
607 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
608 if (!gpe_event_info) {
609 status = AE_BAD_PARAMETER;
610 goto unlock_and_exit;
611 }
612
613 /* Obtain status on the requested GPE number */
614
615 status = acpi_hw_get_gpe_status(gpe_event_info, event_status);
616
617 if (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)
618 *event_status |= ACPI_EVENT_FLAG_HANDLE;
619
620 unlock_and_exit:
621 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
622 return_ACPI_STATUS(status);
623}
624
625ACPI_EXPORT_SYMBOL(acpi_get_gpe_status)
626/*******************************************************************************
627 *
628 * FUNCTION: acpi_install_gpe_block
629 *
630 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device
631 * gpe_block_address - Address and space_iD
632 * register_count - Number of GPE register pairs in the block
633 * interrupt_number - H/W interrupt for the block
634 *
635 * RETURN: Status
636 *
637 * DESCRIPTION: Create and Install a block of GPE registers
638 *
639 ******************************************************************************/
640acpi_status
641acpi_install_gpe_block(acpi_handle gpe_device,
642 struct acpi_generic_address *gpe_block_address,
643 u32 register_count, u32 interrupt_number)
644{
645 acpi_status status = AE_OK;
646 union acpi_operand_object *obj_desc;
647 struct acpi_namespace_node *node;
648 struct acpi_gpe_block_info *gpe_block;
649
650 ACPI_FUNCTION_TRACE(acpi_install_gpe_block);
651
652 if ((!gpe_device) || (!gpe_block_address) || (!register_count)) {
653 return_ACPI_STATUS(AE_BAD_PARAMETER);
654 }
655
656 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
657 if (ACPI_FAILURE(status)) {
658 return (status);
659 }
660
661 node = acpi_ns_validate_handle(gpe_device);
662 if (!node) {
663 status = AE_BAD_PARAMETER;
664 goto unlock_and_exit;
665 }
666
667 /*
668 * For user-installed GPE Block Devices, the gpe_block_base_number
669 * is always zero
670 */
671 status =
672 acpi_ev_create_gpe_block(node, gpe_block_address, register_count, 0,
673 interrupt_number, &gpe_block);
674 if (ACPI_FAILURE(status)) {
675 goto unlock_and_exit;
676 }
677
678 /* Install block in the device_object attached to the node */
679
680 obj_desc = acpi_ns_get_attached_object(node);
681 if (!obj_desc) {
682
683 /*
684 * No object, create a new one (Device nodes do not always have
685 * an attached object)
686 */
687 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE);
688 if (!obj_desc) {
689 status = AE_NO_MEMORY;
690 goto unlock_and_exit;
691 }
692
693 status =
694 acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE);
695
696 /* Remove local reference to the object */
697
698 acpi_ut_remove_reference(obj_desc);
699
700 if (ACPI_FAILURE(status)) {
701 goto unlock_and_exit;
702 }
703 }
704
705 /* Now install the GPE block in the device_object */
706
707 obj_desc->device.gpe_block = gpe_block;
708
709 unlock_and_exit:
710 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
711 return_ACPI_STATUS(status);
712}
713
714ACPI_EXPORT_SYMBOL(acpi_install_gpe_block)
715
716/*******************************************************************************
717 *
718 * FUNCTION: acpi_remove_gpe_block
719 *
720 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device
721 *
722 * RETURN: Status
723 *
724 * DESCRIPTION: Remove a previously installed block of GPE registers
725 *
726 ******************************************************************************/
727acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
728{
729 union acpi_operand_object *obj_desc;
730 acpi_status status;
731 struct acpi_namespace_node *node;
732
733 ACPI_FUNCTION_TRACE(acpi_remove_gpe_block);
734
735 if (!gpe_device) {
736 return_ACPI_STATUS(AE_BAD_PARAMETER);
737 }
738
739 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
740 if (ACPI_FAILURE(status)) {
741 return (status);
742 }
743
744 node = acpi_ns_validate_handle(gpe_device);
745 if (!node) {
746 status = AE_BAD_PARAMETER;
747 goto unlock_and_exit;
748 }
749
750 /* Get the device_object attached to the node */
751
752 obj_desc = acpi_ns_get_attached_object(node);
753 if (!obj_desc || !obj_desc->device.gpe_block) {
754 return_ACPI_STATUS(AE_NULL_OBJECT);
755 }
756
757 /* Delete the GPE block (but not the device_object) */
758
759 status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block);
760 if (ACPI_SUCCESS(status)) {
761 obj_desc->device.gpe_block = NULL;
762 }
763
764 unlock_and_exit:
765 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
766 return_ACPI_STATUS(status);
767}
768
769ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)
770
771/*******************************************************************************
772 *
773 * FUNCTION: acpi_get_gpe_device
774 *
775 * PARAMETERS: Index - System GPE index (0-current_gpe_count)
776 * gpe_device - Where the parent GPE Device is returned
777 *
778 * RETURN: Status
779 *
780 * DESCRIPTION: Obtain the GPE device associated with the input index. A NULL
781 * gpe device indicates that the gpe number is contained in one of
782 * the FADT-defined gpe blocks. Otherwise, the GPE block device.
783 *
784 ******************************************************************************/
785acpi_status
786acpi_get_gpe_device(u32 index, acpi_handle *gpe_device)
787{
788 struct acpi_gpe_device_info info;
789 acpi_status status;
790
791 ACPI_FUNCTION_TRACE(acpi_get_gpe_device);
792
793 if (!gpe_device) {
794 return_ACPI_STATUS(AE_BAD_PARAMETER);
795 }
796
797 if (index >= acpi_current_gpe_count) {
798 return_ACPI_STATUS(AE_NOT_EXIST);
799 }
800
801 /* Setup and walk the GPE list */
802
803 info.index = index;
804 info.status = AE_NOT_EXIST;
805 info.gpe_device = NULL;
806 info.next_block_base_index = 0;
807
808 status = acpi_ev_walk_gpe_list(acpi_ev_get_gpe_device, &info);
809 if (ACPI_FAILURE(status)) {
810 return_ACPI_STATUS(status);
811 }
812
813 *gpe_device = info.gpe_device;
814 return_ACPI_STATUS(info.status);
815}
816
817ACPI_EXPORT_SYMBOL(acpi_get_gpe_device)
818
819/*******************************************************************************
820 *
821 * FUNCTION: acpi_ev_get_gpe_device
822 *
823 * PARAMETERS: GPE_WALK_CALLBACK
824 *
825 * RETURN: Status
826 *
827 * DESCRIPTION: Matches the input GPE index (0-current_gpe_count) with a GPE
828 * block device. NULL if the GPE is one of the FADT-defined GPEs.
829 *
830 ******************************************************************************/
831static acpi_status
832acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
833 struct acpi_gpe_block_info *gpe_block, void *context)
834{
835 struct acpi_gpe_device_info *info = context;
836
837 /* Increment Index by the number of GPEs in this block */
838
839 info->next_block_base_index += gpe_block->gpe_count;
840
841 if (info->index < info->next_block_base_index) {
842 /*
843 * The GPE index is within this block, get the node. Leave the node
844 * NULL for the FADT-defined GPEs
845 */
846 if ((gpe_block->node)->type == ACPI_TYPE_DEVICE) {
847 info->gpe_device = gpe_block->node;
848 }
849
850 info->status = AE_OK;
851 return (AE_CTRL_END);
852 }
853
854 return (AE_OK);
855}
856
857/******************************************************************************
858 *
859 * FUNCTION: acpi_disable_all_gpes
860 *
861 * PARAMETERS: None
862 *
863 * RETURN: Status
864 *
865 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
866 *
867 ******************************************************************************/
868
869acpi_status acpi_disable_all_gpes(void)
870{
871 acpi_status status;
872
873 ACPI_FUNCTION_TRACE(acpi_disable_all_gpes);
874
875 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
876 if (ACPI_FAILURE(status)) {
877 return_ACPI_STATUS(status);
878 }
879
880 status = acpi_hw_disable_all_gpes();
881 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
882
883 return_ACPI_STATUS(status);
884}
885
886/******************************************************************************
887 *
888 * FUNCTION: acpi_enable_all_runtime_gpes
889 *
890 * PARAMETERS: None
891 *
892 * RETURN: Status
893 *
894 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
895 *
896 ******************************************************************************/
897
898acpi_status acpi_enable_all_runtime_gpes(void)
899{
900 acpi_status status;
901
902 ACPI_FUNCTION_TRACE(acpi_enable_all_runtime_gpes);
903
904 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
905 if (ACPI_FAILURE(status)) {
906 return_ACPI_STATUS(status);
907 }
908
909 status = acpi_hw_enable_all_runtime_gpes();
910 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
911
912 return_ACPI_STATUS(status);
913}
914
915/******************************************************************************
916 *
917 * FUNCTION: acpi_update_gpes
918 *
919 * PARAMETERS: None
920 *
921 * RETURN: None
922 *
923 * DESCRIPTION: Enable all GPEs that have associated _Lxx or _Exx methods and
924 * are not pointed to by any device _PRW methods indicating that
925 * these GPEs are generally intended for system or device wakeup
926 * (such GPEs have to be enabled directly when the devices whose
927 * _PRW methods point to them are set up for wakeup signaling).
928 *
929 ******************************************************************************/
930
931acpi_status acpi_update_gpes(void)
932{
933 acpi_status status;
934
935 ACPI_FUNCTION_TRACE(acpi_update_gpes);
936
937 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
938 if (ACPI_FAILURE(status)) {
939 return_ACPI_STATUS(status);
940 } else if (acpi_all_gpes_initialized) {
941 goto unlock;
942 }
943
944 status = acpi_ev_walk_gpe_list(acpi_ev_initialize_gpe_block, NULL);
945 if (ACPI_SUCCESS(status)) {
946 acpi_all_gpes_initialized = TRUE;
947 }
948
949unlock:
950 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
951
952 return_ACPI_STATUS(status);
953}
diff --git a/drivers/acpi/acpica/evxfgpe.c b/drivers/acpi/acpica/evxfgpe.c
new file mode 100644
index 000000000000..416845bc9c1f
--- /dev/null
+++ b/drivers/acpi/acpica/evxfgpe.c
@@ -0,0 +1,669 @@
1/******************************************************************************
2 *
3 * Module Name: evxfgpe - External Interfaces for General Purpose Events (GPEs)
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2010, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44#include <acpi/acpi.h>
45#include "accommon.h"
46#include "acevents.h"
47#include "acnamesp.h"
48
49#define _COMPONENT ACPI_EVENTS
50ACPI_MODULE_NAME("evxfgpe")
51
52/******************************************************************************
53 *
54 * FUNCTION: acpi_update_all_gpes
55 *
56 * PARAMETERS: None
57 *
58 * RETURN: Status
59 *
60 * DESCRIPTION: Complete GPE initialization and enable all GPEs that have
61 * associated _Lxx or _Exx methods and are not pointed to by any
62 * device _PRW methods (this indicates that these GPEs are
63 * generally intended for system or device wakeup. Such GPEs
64 * have to be enabled directly when the devices whose _PRW
65 * methods point to them are set up for wakeup signaling.)
66 *
67 * NOTE: Should be called after any GPEs are added to the system. Primarily,
68 * after the system _PRW methods have been run, but also after a GPE Block
69 * Device has been added or if any new GPE methods have been added via a
70 * dynamic table load.
71 *
72 ******************************************************************************/
73
74acpi_status acpi_update_all_gpes(void)
75{
76 acpi_status status;
77
78 ACPI_FUNCTION_TRACE(acpi_update_all_gpes);
79
80 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
81 if (ACPI_FAILURE(status)) {
82 return_ACPI_STATUS(status);
83 }
84
85 if (acpi_gbl_all_gpes_initialized) {
86 goto unlock_and_exit;
87 }
88
89 status = acpi_ev_walk_gpe_list(acpi_ev_initialize_gpe_block, NULL);
90 if (ACPI_SUCCESS(status)) {
91 acpi_gbl_all_gpes_initialized = TRUE;
92 }
93
94unlock_and_exit:
95 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
96
97 return_ACPI_STATUS(status);
98}
99
100ACPI_EXPORT_SYMBOL(acpi_update_all_gpes)
101
102/*******************************************************************************
103 *
104 * FUNCTION: acpi_enable_gpe
105 *
106 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
107 * gpe_number - GPE level within the GPE block
108 *
109 * RETURN: Status
110 *
111 * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
112 * hardware-enabled.
113 *
114 ******************************************************************************/
115
116acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
117{
118 acpi_status status = AE_BAD_PARAMETER;
119 struct acpi_gpe_event_info *gpe_event_info;
120 acpi_cpu_flags flags;
121
122 ACPI_FUNCTION_TRACE(acpi_enable_gpe);
123
124 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
125
126 /* Ensure that we have a valid GPE number */
127
128 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
129 if (gpe_event_info) {
130 status = acpi_ev_add_gpe_reference(gpe_event_info);
131 }
132
133 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
134 return_ACPI_STATUS(status);
135}
136ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
137
138/*******************************************************************************
139 *
140 * FUNCTION: acpi_disable_gpe
141 *
142 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
143 * gpe_number - GPE level within the GPE block
144 *
145 * RETURN: Status
146 *
147 * DESCRIPTION: Remove a reference to a GPE. When the last reference is
148 * removed, only then is the GPE disabled (for runtime GPEs), or
149 * the GPE mask bit disabled (for wake GPEs)
150 *
151 ******************************************************************************/
152
153acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
154{
155 acpi_status status = AE_BAD_PARAMETER;
156 struct acpi_gpe_event_info *gpe_event_info;
157 acpi_cpu_flags flags;
158
159 ACPI_FUNCTION_TRACE(acpi_disable_gpe);
160
161 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
162
163 /* Ensure that we have a valid GPE number */
164
165 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
166 if (gpe_event_info) {
167 status = acpi_ev_remove_gpe_reference(gpe_event_info) ;
168 }
169
170 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
171 return_ACPI_STATUS(status);
172}
173ACPI_EXPORT_SYMBOL(acpi_disable_gpe)
174
175
176/*******************************************************************************
177 *
178 * FUNCTION: acpi_setup_gpe_for_wake
179 *
180 * PARAMETERS: wake_device - Device associated with the GPE (via _PRW)
181 * gpe_device - Parent GPE Device. NULL for GPE0/GPE1
182 * gpe_number - GPE level within the GPE block
183 *
184 * RETURN: Status
185 *
186 * DESCRIPTION: Mark a GPE as having the ability to wake the system. This
187 * interface is intended to be used as the host executes the
188 * _PRW methods (Power Resources for Wake) in the system tables.
189 * Each _PRW appears under a Device Object (The wake_device), and
190 * contains the info for the wake GPE associated with the
191 * wake_device.
192 *
193 ******************************************************************************/
194acpi_status
195acpi_setup_gpe_for_wake(acpi_handle wake_device,
196 acpi_handle gpe_device, u32 gpe_number)
197{
198 acpi_status status = AE_BAD_PARAMETER;
199 struct acpi_gpe_event_info *gpe_event_info;
200 struct acpi_namespace_node *device_node;
201 acpi_cpu_flags flags;
202
203 ACPI_FUNCTION_TRACE(acpi_setup_gpe_for_wake);
204
205 /* Parameter Validation */
206
207 if (!wake_device) {
208 /*
209 * By forcing wake_device to be valid, we automatically enable the
210 * implicit notify feature on all hosts.
211 */
212 return_ACPI_STATUS(AE_BAD_PARAMETER);
213 }
214
215 /* Validate wake_device is of type Device */
216
217 device_node = ACPI_CAST_PTR(struct acpi_namespace_node, wake_device);
218 if (device_node->type != ACPI_TYPE_DEVICE) {
219 return_ACPI_STATUS(AE_BAD_PARAMETER);
220 }
221
222 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
223
224 /* Ensure that we have a valid GPE number */
225
226 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
227 if (gpe_event_info) {
228 /*
229 * If there is no method or handler for this GPE, then the
230 * wake_device will be notified whenever this GPE fires (aka
231 * "implicit notify") Note: The GPE is assumed to be
232 * level-triggered (for windows compatibility).
233 */
234 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
235 ACPI_GPE_DISPATCH_NONE) {
236 gpe_event_info->flags =
237 (ACPI_GPE_DISPATCH_NOTIFY |
238 ACPI_GPE_LEVEL_TRIGGERED);
239 gpe_event_info->dispatch.device_node = device_node;
240 }
241
242 gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
243 status = AE_OK;
244 }
245
246 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
247 return_ACPI_STATUS(status);
248}
249ACPI_EXPORT_SYMBOL(acpi_setup_gpe_for_wake)
250
251/*******************************************************************************
252 *
253 * FUNCTION: acpi_set_gpe_wake_mask
254 *
255 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
256 * gpe_number - GPE level within the GPE block
257 * Action - Enable or Disable
258 *
259 * RETURN: Status
260 *
261 * DESCRIPTION: Set or clear the GPE's wakeup enable mask bit. The GPE must
262 * already be marked as a WAKE GPE.
263 *
264 ******************************************************************************/
265
266acpi_status acpi_set_gpe_wake_mask(acpi_handle gpe_device, u32 gpe_number, u8 action)
267{
268 acpi_status status = AE_OK;
269 struct acpi_gpe_event_info *gpe_event_info;
270 struct acpi_gpe_register_info *gpe_register_info;
271 acpi_cpu_flags flags;
272 u32 register_bit;
273
274 ACPI_FUNCTION_TRACE(acpi_set_gpe_wake_mask);
275
276 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
277
278 /*
279 * Ensure that we have a valid GPE number and that this GPE is in
280 * fact a wake GPE
281 */
282 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
283 if (!gpe_event_info) {
284 status = AE_BAD_PARAMETER;
285 goto unlock_and_exit;
286 }
287
288 if (!(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
289 status = AE_TYPE;
290 goto unlock_and_exit;
291 }
292
293 gpe_register_info = gpe_event_info->register_info;
294 if (!gpe_register_info) {
295 status = AE_NOT_EXIST;
296 goto unlock_and_exit;
297 }
298
299 register_bit =
300 acpi_hw_get_gpe_register_bit(gpe_event_info, gpe_register_info);
301
302 /* Perform the action */
303
304 switch (action) {
305 case ACPI_GPE_ENABLE:
306 ACPI_SET_BIT(gpe_register_info->enable_for_wake,
307 (u8)register_bit);
308 break;
309
310 case ACPI_GPE_DISABLE:
311 ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,
312 (u8)register_bit);
313 break;
314
315 default:
316 ACPI_ERROR((AE_INFO, "%u, Invalid action", action));
317 status = AE_BAD_PARAMETER;
318 break;
319 }
320
321unlock_and_exit:
322 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
323 return_ACPI_STATUS(status);
324}
325
326ACPI_EXPORT_SYMBOL(acpi_set_gpe_wake_mask)
327
328/*******************************************************************************
329 *
330 * FUNCTION: acpi_clear_gpe
331 *
332 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
333 * gpe_number - GPE level within the GPE block
334 *
335 * RETURN: Status
336 *
337 * DESCRIPTION: Clear an ACPI event (general purpose)
338 *
339 ******************************************************************************/
340acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number)
341{
342 acpi_status status = AE_OK;
343 struct acpi_gpe_event_info *gpe_event_info;
344 acpi_cpu_flags flags;
345
346 ACPI_FUNCTION_TRACE(acpi_clear_gpe);
347
348 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
349
350 /* Ensure that we have a valid GPE number */
351
352 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
353 if (!gpe_event_info) {
354 status = AE_BAD_PARAMETER;
355 goto unlock_and_exit;
356 }
357
358 status = acpi_hw_clear_gpe(gpe_event_info);
359
360 unlock_and_exit:
361 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
362 return_ACPI_STATUS(status);
363}
364
365ACPI_EXPORT_SYMBOL(acpi_clear_gpe)
366
367/*******************************************************************************
368 *
369 * FUNCTION: acpi_get_gpe_status
370 *
371 * PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
372 * gpe_number - GPE level within the GPE block
373 * event_status - Where the current status of the event will
374 * be returned
375 *
376 * RETURN: Status
377 *
378 * DESCRIPTION: Get the current status of a GPE (signalled/not_signalled)
379 *
380 ******************************************************************************/
381acpi_status
382acpi_get_gpe_status(acpi_handle gpe_device,
383 u32 gpe_number, acpi_event_status *event_status)
384{
385 acpi_status status = AE_OK;
386 struct acpi_gpe_event_info *gpe_event_info;
387 acpi_cpu_flags flags;
388
389 ACPI_FUNCTION_TRACE(acpi_get_gpe_status);
390
391 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
392
393 /* Ensure that we have a valid GPE number */
394
395 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
396 if (!gpe_event_info) {
397 status = AE_BAD_PARAMETER;
398 goto unlock_and_exit;
399 }
400
401 /* Obtain status on the requested GPE number */
402
403 status = acpi_hw_get_gpe_status(gpe_event_info, event_status);
404
405 if (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)
406 *event_status |= ACPI_EVENT_FLAG_HANDLE;
407
408 unlock_and_exit:
409 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
410 return_ACPI_STATUS(status);
411}
412
413ACPI_EXPORT_SYMBOL(acpi_get_gpe_status)
414
415/******************************************************************************
416 *
417 * FUNCTION: acpi_disable_all_gpes
418 *
419 * PARAMETERS: None
420 *
421 * RETURN: Status
422 *
423 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
424 *
425 ******************************************************************************/
426
427acpi_status acpi_disable_all_gpes(void)
428{
429 acpi_status status;
430
431 ACPI_FUNCTION_TRACE(acpi_disable_all_gpes);
432
433 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
434 if (ACPI_FAILURE(status)) {
435 return_ACPI_STATUS(status);
436 }
437
438 status = acpi_hw_disable_all_gpes();
439 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
440
441 return_ACPI_STATUS(status);
442}
443
444ACPI_EXPORT_SYMBOL(acpi_disable_all_gpes)
445
446/******************************************************************************
447 *
448 * FUNCTION: acpi_enable_all_runtime_gpes
449 *
450 * PARAMETERS: None
451 *
452 * RETURN: Status
453 *
454 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
455 *
456 ******************************************************************************/
457
458acpi_status acpi_enable_all_runtime_gpes(void)
459{
460 acpi_status status;
461
462 ACPI_FUNCTION_TRACE(acpi_enable_all_runtime_gpes);
463
464 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
465 if (ACPI_FAILURE(status)) {
466 return_ACPI_STATUS(status);
467 }
468
469 status = acpi_hw_enable_all_runtime_gpes();
470 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
471
472 return_ACPI_STATUS(status);
473}
474
475ACPI_EXPORT_SYMBOL(acpi_enable_all_runtime_gpes)
476
477/*******************************************************************************
478 *
479 * FUNCTION: acpi_install_gpe_block
480 *
481 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device
482 * gpe_block_address - Address and space_iD
483 * register_count - Number of GPE register pairs in the block
484 * interrupt_number - H/W interrupt for the block
485 *
486 * RETURN: Status
487 *
488 * DESCRIPTION: Create and Install a block of GPE registers. The GPEs are not
489 * enabled here.
490 *
491 ******************************************************************************/
492acpi_status
493acpi_install_gpe_block(acpi_handle gpe_device,
494 struct acpi_generic_address *gpe_block_address,
495 u32 register_count, u32 interrupt_number)
496{
497 acpi_status status;
498 union acpi_operand_object *obj_desc;
499 struct acpi_namespace_node *node;
500 struct acpi_gpe_block_info *gpe_block;
501
502 ACPI_FUNCTION_TRACE(acpi_install_gpe_block);
503
504 if ((!gpe_device) || (!gpe_block_address) || (!register_count)) {
505 return_ACPI_STATUS(AE_BAD_PARAMETER);
506 }
507
508 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
509 if (ACPI_FAILURE(status)) {
510 return (status);
511 }
512
513 node = acpi_ns_validate_handle(gpe_device);
514 if (!node) {
515 status = AE_BAD_PARAMETER;
516 goto unlock_and_exit;
517 }
518
519 /*
520 * For user-installed GPE Block Devices, the gpe_block_base_number
521 * is always zero
522 */
523 status =
524 acpi_ev_create_gpe_block(node, gpe_block_address, register_count, 0,
525 interrupt_number, &gpe_block);
526 if (ACPI_FAILURE(status)) {
527 goto unlock_and_exit;
528 }
529
530 /* Install block in the device_object attached to the node */
531
532 obj_desc = acpi_ns_get_attached_object(node);
533 if (!obj_desc) {
534
535 /*
536 * No object, create a new one (Device nodes do not always have
537 * an attached object)
538 */
539 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE);
540 if (!obj_desc) {
541 status = AE_NO_MEMORY;
542 goto unlock_and_exit;
543 }
544
545 status =
546 acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE);
547
548 /* Remove local reference to the object */
549
550 acpi_ut_remove_reference(obj_desc);
551
552 if (ACPI_FAILURE(status)) {
553 goto unlock_and_exit;
554 }
555 }
556
557 /* Now install the GPE block in the device_object */
558
559 obj_desc->device.gpe_block = gpe_block;
560
561 unlock_and_exit:
562 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
563 return_ACPI_STATUS(status);
564}
565
566ACPI_EXPORT_SYMBOL(acpi_install_gpe_block)
567
568/*******************************************************************************
569 *
570 * FUNCTION: acpi_remove_gpe_block
571 *
572 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device
573 *
574 * RETURN: Status
575 *
576 * DESCRIPTION: Remove a previously installed block of GPE registers
577 *
578 ******************************************************************************/
579acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
580{
581 union acpi_operand_object *obj_desc;
582 acpi_status status;
583 struct acpi_namespace_node *node;
584
585 ACPI_FUNCTION_TRACE(acpi_remove_gpe_block);
586
587 if (!gpe_device) {
588 return_ACPI_STATUS(AE_BAD_PARAMETER);
589 }
590
591 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
592 if (ACPI_FAILURE(status)) {
593 return (status);
594 }
595
596 node = acpi_ns_validate_handle(gpe_device);
597 if (!node) {
598 status = AE_BAD_PARAMETER;
599 goto unlock_and_exit;
600 }
601
602 /* Get the device_object attached to the node */
603
604 obj_desc = acpi_ns_get_attached_object(node);
605 if (!obj_desc || !obj_desc->device.gpe_block) {
606 return_ACPI_STATUS(AE_NULL_OBJECT);
607 }
608
609 /* Delete the GPE block (but not the device_object) */
610
611 status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block);
612 if (ACPI_SUCCESS(status)) {
613 obj_desc->device.gpe_block = NULL;
614 }
615
616 unlock_and_exit:
617 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
618 return_ACPI_STATUS(status);
619}
620
621ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)
622
623/*******************************************************************************
624 *
625 * FUNCTION: acpi_get_gpe_device
626 *
627 * PARAMETERS: Index - System GPE index (0-current_gpe_count)
628 * gpe_device - Where the parent GPE Device is returned
629 *
630 * RETURN: Status
631 *
632 * DESCRIPTION: Obtain the GPE device associated with the input index. A NULL
633 * gpe device indicates that the gpe number is contained in one of
634 * the FADT-defined gpe blocks. Otherwise, the GPE block device.
635 *
636 ******************************************************************************/
637acpi_status
638acpi_get_gpe_device(u32 index, acpi_handle *gpe_device)
639{
640 struct acpi_gpe_device_info info;
641 acpi_status status;
642
643 ACPI_FUNCTION_TRACE(acpi_get_gpe_device);
644
645 if (!gpe_device) {
646 return_ACPI_STATUS(AE_BAD_PARAMETER);
647 }
648
649 if (index >= acpi_current_gpe_count) {
650 return_ACPI_STATUS(AE_NOT_EXIST);
651 }
652
653 /* Setup and walk the GPE list */
654
655 info.index = index;
656 info.status = AE_NOT_EXIST;
657 info.gpe_device = NULL;
658 info.next_block_base_index = 0;
659
660 status = acpi_ev_walk_gpe_list(acpi_ev_get_gpe_device, &info);
661 if (ACPI_FAILURE(status)) {
662 return_ACPI_STATUS(status);
663 }
664
665 *gpe_device = ACPI_CAST_PTR(acpi_handle, info.gpe_device);
666 return_ACPI_STATUS(info.status);
667}
668
669ACPI_EXPORT_SYMBOL(acpi_get_gpe_device)
diff --git a/drivers/acpi/acpica/hwgpe.c b/drivers/acpi/acpica/hwgpe.c
index 14750db2a1b8..85c3cbd4304d 100644
--- a/drivers/acpi/acpica/hwgpe.c
+++ b/drivers/acpi/acpica/hwgpe.c
@@ -62,10 +62,10 @@ acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
62 * PARAMETERS: gpe_event_info - Info block for the GPE 62 * PARAMETERS: gpe_event_info - Info block for the GPE
63 * gpe_register_info - Info block for the GPE register 63 * gpe_register_info - Info block for the GPE register
64 * 64 *
65 * RETURN: Status 65 * RETURN: Register mask with a one in the GPE bit position
66 * 66 *
67 * DESCRIPTION: Compute GPE enable mask with one bit corresponding to the given 67 * DESCRIPTION: Compute the register mask for this GPE. One bit is set in the
68 * GPE set. 68 * correct position for the input GPE.
69 * 69 *
70 ******************************************************************************/ 70 ******************************************************************************/
71 71
@@ -85,12 +85,12 @@ u32 acpi_hw_get_gpe_register_bit(struct acpi_gpe_event_info *gpe_event_info,
85 * 85 *
86 * RETURN: Status 86 * RETURN: Status
87 * 87 *
88 * DESCRIPTION: Enable or disable a single GPE in its enable register. 88 * DESCRIPTION: Enable or disable a single GPE in the parent enable register.
89 * 89 *
90 ******************************************************************************/ 90 ******************************************************************************/
91 91
92acpi_status 92acpi_status
93acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u8 action) 93acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u32 action)
94{ 94{
95 struct acpi_gpe_register_info *gpe_register_info; 95 struct acpi_gpe_register_info *gpe_register_info;
96 acpi_status status; 96 acpi_status status;
@@ -113,14 +113,20 @@ acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u8 action)
113 return (status); 113 return (status);
114 } 114 }
115 115
116 /* Set ot clear just the bit that corresponds to this GPE */ 116 /* Set or clear just the bit that corresponds to this GPE */
117 117
118 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info, 118 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info,
119 gpe_register_info); 119 gpe_register_info);
120 switch (action) { 120 switch (action) {
121 case ACPI_GPE_COND_ENABLE: 121 case ACPI_GPE_CONDITIONAL_ENABLE:
122 if (!(register_bit & gpe_register_info->enable_for_run)) 122
123 /* Only enable if the enable_for_run bit is set */
124
125 if (!(register_bit & gpe_register_info->enable_for_run)) {
123 return (AE_BAD_PARAMETER); 126 return (AE_BAD_PARAMETER);
127 }
128
129 /*lint -fallthrough */
124 130
125 case ACPI_GPE_ENABLE: 131 case ACPI_GPE_ENABLE:
126 ACPI_SET_BIT(enable_mask, register_bit); 132 ACPI_SET_BIT(enable_mask, register_bit);
@@ -131,7 +137,7 @@ acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u8 action)
131 break; 137 break;
132 138
133 default: 139 default:
134 ACPI_ERROR((AE_INFO, "Invalid action\n")); 140 ACPI_ERROR((AE_INFO, "Invalid GPE Action, %u\n", action));
135 return (AE_BAD_PARAMETER); 141 return (AE_BAD_PARAMETER);
136 } 142 }
137 143
@@ -168,13 +174,13 @@ acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info * gpe_event_info)
168 return (AE_NOT_EXIST); 174 return (AE_NOT_EXIST);
169 } 175 }
170 176
171 register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info,
172 gpe_register_info);
173
174 /* 177 /*
175 * Write a one to the appropriate bit in the status register to 178 * Write a one to the appropriate bit in the status register to
176 * clear this GPE. 179 * clear this GPE.
177 */ 180 */
181 register_bit =
182 acpi_hw_get_gpe_register_bit(gpe_event_info, gpe_register_info);
183
178 status = acpi_hw_write(register_bit, 184 status = acpi_hw_write(register_bit,
179 &gpe_register_info->status_address); 185 &gpe_register_info->status_address);
180 186
@@ -201,8 +207,8 @@ acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info,
201 u32 in_byte; 207 u32 in_byte;
202 u32 register_bit; 208 u32 register_bit;
203 struct acpi_gpe_register_info *gpe_register_info; 209 struct acpi_gpe_register_info *gpe_register_info;
204 acpi_status status;
205 acpi_event_status local_event_status = 0; 210 acpi_event_status local_event_status = 0;
211 acpi_status status;
206 212
207 ACPI_FUNCTION_ENTRY(); 213 ACPI_FUNCTION_ENTRY();
208 214
diff --git a/drivers/acpi/acpica/utglobal.c b/drivers/acpi/acpica/utglobal.c
index e87bc6760be6..508537f884ac 100644
--- a/drivers/acpi/acpica/utglobal.c
+++ b/drivers/acpi/acpica/utglobal.c
@@ -768,7 +768,7 @@ acpi_status acpi_ut_init_globals(void)
768 acpi_gbl_gpe_fadt_blocks[0] = NULL; 768 acpi_gbl_gpe_fadt_blocks[0] = NULL;
769 acpi_gbl_gpe_fadt_blocks[1] = NULL; 769 acpi_gbl_gpe_fadt_blocks[1] = NULL;
770 acpi_current_gpe_count = 0; 770 acpi_current_gpe_count = 0;
771 acpi_all_gpes_initialized = FALSE; 771 acpi_gbl_all_gpes_initialized = FALSE;
772 772
773 /* Global handlers */ 773 /* Global handlers */
774 774
@@ -778,6 +778,7 @@ acpi_status acpi_ut_init_globals(void)
778 acpi_gbl_init_handler = NULL; 778 acpi_gbl_init_handler = NULL;
779 acpi_gbl_table_handler = NULL; 779 acpi_gbl_table_handler = NULL;
780 acpi_gbl_interface_handler = NULL; 780 acpi_gbl_interface_handler = NULL;
781 acpi_gbl_global_event_handler = NULL;
781 782
782 /* Global Lock support */ 783 /* Global Lock support */
783 784
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index d68bd61072bb..7ced61f39492 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -52,22 +52,6 @@ EXPORT_SYMBOL(acpi_root_dir);
52 52
53#define STRUCT_TO_INT(s) (*((int*)&s)) 53#define STRUCT_TO_INT(s) (*((int*)&s))
54 54
55static int set_power_nocheck(const struct dmi_system_id *id)
56{
57 printk(KERN_NOTICE PREFIX "%s detected - "
58 "disable power check in power transition\n", id->ident);
59 acpi_power_nocheck = 1;
60 return 0;
61}
62static struct dmi_system_id __cpuinitdata power_nocheck_dmi_table[] = {
63 {
64 set_power_nocheck, "HP Pavilion 05", {
65 DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
66 DMI_MATCH(DMI_SYS_VENDOR, "HP Pavilion 05"),
67 DMI_MATCH(DMI_PRODUCT_VERSION, "2001211RE101GLEND") }, NULL},
68 {},
69};
70
71 55
72#ifdef CONFIG_X86 56#ifdef CONFIG_X86
73static int set_copy_dsdt(const struct dmi_system_id *id) 57static int set_copy_dsdt(const struct dmi_system_id *id)
@@ -196,33 +180,24 @@ EXPORT_SYMBOL(acpi_bus_get_private_data);
196 Power Management 180 Power Management
197 -------------------------------------------------------------------------- */ 181 -------------------------------------------------------------------------- */
198 182
199int acpi_bus_get_power(acpi_handle handle, int *state) 183static int __acpi_bus_get_power(struct acpi_device *device, int *state)
200{ 184{
201 int result = 0; 185 int result = 0;
202 acpi_status status = 0; 186 acpi_status status = 0;
203 struct acpi_device *device = NULL;
204 unsigned long long psc = 0; 187 unsigned long long psc = 0;
205 188
206 189 if (!device || !state)
207 result = acpi_bus_get_device(handle, &device); 190 return -EINVAL;
208 if (result)
209 return result;
210 191
211 *state = ACPI_STATE_UNKNOWN; 192 *state = ACPI_STATE_UNKNOWN;
212 193
213 if (!device->flags.power_manageable) { 194 if (device->flags.power_manageable) {
214 /* TBD: Non-recursive algorithm for walking up hierarchy */
215 if (device->parent)
216 *state = device->parent->power.state;
217 else
218 *state = ACPI_STATE_D0;
219 } else {
220 /* 195 /*
221 * Get the device's power state either directly (via _PSC) or 196 * Get the device's power state either directly (via _PSC) or
222 * indirectly (via power resources). 197 * indirectly (via power resources).
223 */ 198 */
224 if (device->power.flags.power_resources) { 199 if (device->power.flags.power_resources) {
225 result = acpi_power_get_inferred_state(device); 200 result = acpi_power_get_inferred_state(device, state);
226 if (result) 201 if (result)
227 return result; 202 return result;
228 } else if (device->power.flags.explicit_get) { 203 } else if (device->power.flags.explicit_get) {
@@ -230,59 +205,33 @@ int acpi_bus_get_power(acpi_handle handle, int *state)
230 NULL, &psc); 205 NULL, &psc);
231 if (ACPI_FAILURE(status)) 206 if (ACPI_FAILURE(status))
232 return -ENODEV; 207 return -ENODEV;
233 device->power.state = (int)psc; 208 *state = (int)psc;
234 } 209 }
235 210 } else {
236 *state = device->power.state; 211 /* TBD: Non-recursive algorithm for walking up hierarchy. */
212 *state = device->parent ?
213 device->parent->power.state : ACPI_STATE_D0;
237 } 214 }
238 215
239 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n", 216 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n",
240 device->pnp.bus_id, device->power.state)); 217 device->pnp.bus_id, *state));
241 218
242 return 0; 219 return 0;
243} 220}
244 221
245EXPORT_SYMBOL(acpi_bus_get_power);
246 222
247int acpi_bus_set_power(acpi_handle handle, int state) 223static int __acpi_bus_set_power(struct acpi_device *device, int state)
248{ 224{
249 int result = 0; 225 int result = 0;
250 acpi_status status = AE_OK; 226 acpi_status status = AE_OK;
251 struct acpi_device *device = NULL;
252 char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' }; 227 char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };
253 228
254 229 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
255 result = acpi_bus_get_device(handle, &device);
256 if (result)
257 return result;
258
259 if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
260 return -EINVAL; 230 return -EINVAL;
261 231
262 /* Make sure this is a valid target state */ 232 /* Make sure this is a valid target state */
263 233
264 if (!device->flags.power_manageable) { 234 if (state == device->power.state) {
265 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device `[%s]' is not power manageable\n",
266 kobject_name(&device->dev.kobj)));
267 return -ENODEV;
268 }
269 /*
270 * Get device's current power state
271 */
272 if (!acpi_power_nocheck) {
273 /*
274 * Maybe the incorrect power state is returned on the bogus
275 * bios, which is different with the real power state.
276 * For example: the bios returns D0 state and the real power
277 * state is D3. OS expects to set the device to D0 state. In
278 * such case if OS uses the power state returned by the BIOS,
279 * the device can't be transisted to the correct power state.
280 * So if the acpi_power_nocheck is set, it is unnecessary to
281 * get the power state by calling acpi_bus_get_power.
282 */
283 acpi_bus_get_power(device->handle, &device->power.state);
284 }
285 if ((state == device->power.state) && !device->flags.force_power_state) {
286 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n", 235 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",
287 state)); 236 state));
288 return 0; 237 return 0;
@@ -351,8 +300,75 @@ int acpi_bus_set_power(acpi_handle handle, int state)
351 return result; 300 return result;
352} 301}
353 302
303
304int acpi_bus_set_power(acpi_handle handle, int state)
305{
306 struct acpi_device *device;
307 int result;
308
309 result = acpi_bus_get_device(handle, &device);
310 if (result)
311 return result;
312
313 if (!device->flags.power_manageable) {
314 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
315 "Device [%s] is not power manageable\n",
316 dev_name(&device->dev)));
317 return -ENODEV;
318 }
319
320 return __acpi_bus_set_power(device, state);
321}
354EXPORT_SYMBOL(acpi_bus_set_power); 322EXPORT_SYMBOL(acpi_bus_set_power);
355 323
324
325int acpi_bus_init_power(struct acpi_device *device)
326{
327 int state;
328 int result;
329
330 if (!device)
331 return -EINVAL;
332
333 device->power.state = ACPI_STATE_UNKNOWN;
334
335 result = __acpi_bus_get_power(device, &state);
336 if (result)
337 return result;
338
339 if (device->power.flags.power_resources)
340 result = acpi_power_on_resources(device, state);
341
342 if (!result)
343 device->power.state = state;
344
345 return result;
346}
347
348
349int acpi_bus_update_power(acpi_handle handle, int *state_p)
350{
351 struct acpi_device *device;
352 int state;
353 int result;
354
355 result = acpi_bus_get_device(handle, &device);
356 if (result)
357 return result;
358
359 result = __acpi_bus_get_power(device, &state);
360 if (result)
361 return result;
362
363 result = __acpi_bus_set_power(device, state);
364 if (!result && state_p)
365 *state_p = state;
366
367 return result;
368}
369EXPORT_SYMBOL_GPL(acpi_bus_update_power);
370
371
356bool acpi_bus_power_manageable(acpi_handle handle) 372bool acpi_bus_power_manageable(acpi_handle handle)
357{ 373{
358 struct acpi_device *device; 374 struct acpi_device *device;
@@ -1023,15 +1039,8 @@ static int __init acpi_init(void)
1023 if (acpi_disabled) 1039 if (acpi_disabled)
1024 return result; 1040 return result;
1025 1041
1026 /*
1027 * If the laptop falls into the DMI check table, the power state check
1028 * will be disabled in the course of device power transition.
1029 */
1030 dmi_check_system(power_nocheck_dmi_table);
1031
1032 acpi_scan_init(); 1042 acpi_scan_init();
1033 acpi_ec_init(); 1043 acpi_ec_init();
1034 acpi_power_init();
1035 acpi_debugfs_init(); 1044 acpi_debugfs_init();
1036 acpi_sleep_proc_init(); 1045 acpi_sleep_proc_init();
1037 acpi_wakeup_device_init(); 1046 acpi_wakeup_device_init();
diff --git a/drivers/acpi/dock.c b/drivers/acpi/dock.c
index 81514a4918cc..1864ad3cf895 100644
--- a/drivers/acpi/dock.c
+++ b/drivers/acpi/dock.c
@@ -725,7 +725,7 @@ static void dock_notify(acpi_handle handle, u32 event, void *data)
725 complete_dock(ds); 725 complete_dock(ds);
726 dock_event(ds, event, DOCK_EVENT); 726 dock_event(ds, event, DOCK_EVENT);
727 dock_lock(ds, 1); 727 dock_lock(ds, 1);
728 acpi_update_gpes(); 728 acpi_update_all_gpes();
729 break; 729 break;
730 } 730 }
731 if (dock_present(ds) || dock_in_progress(ds)) 731 if (dock_present(ds) || dock_in_progress(ds))
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 302b31ed31f1..fa848c4116a8 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -606,7 +606,8 @@ static int ec_check_sci(struct acpi_ec *ec, u8 state)
606 return 0; 606 return 0;
607} 607}
608 608
609static u32 acpi_ec_gpe_handler(void *data) 609static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
610 u32 gpe_number, void *data)
610{ 611{
611 struct acpi_ec *ec = data; 612 struct acpi_ec *ec = data;
612 613
@@ -618,7 +619,7 @@ static u32 acpi_ec_gpe_handler(void *data)
618 wake_up(&ec->wait); 619 wake_up(&ec->wait);
619 ec_check_sci(ec, acpi_ec_read_status(ec)); 620 ec_check_sci(ec, acpi_ec_read_status(ec));
620 } 621 }
621 return ACPI_INTERRUPT_HANDLED; 622 return ACPI_INTERRUPT_HANDLED | ACPI_REENABLE_GPE;
622} 623}
623 624
624/* -------------------------------------------------------------------------- 625/* --------------------------------------------------------------------------
diff --git a/drivers/acpi/fan.c b/drivers/acpi/fan.c
index 60049080c869..467479f07c1f 100644
--- a/drivers/acpi/fan.c
+++ b/drivers/acpi/fan.c
@@ -86,7 +86,7 @@ static int fan_get_cur_state(struct thermal_cooling_device *cdev, unsigned long
86 if (!device) 86 if (!device)
87 return -EINVAL; 87 return -EINVAL;
88 88
89 result = acpi_bus_get_power(device->handle, &acpi_state); 89 result = acpi_bus_update_power(device->handle, &acpi_state);
90 if (result) 90 if (result)
91 return result; 91 return result;
92 92
@@ -123,7 +123,6 @@ static struct thermal_cooling_device_ops fan_cooling_ops = {
123static int acpi_fan_add(struct acpi_device *device) 123static int acpi_fan_add(struct acpi_device *device)
124{ 124{
125 int result = 0; 125 int result = 0;
126 int state = 0;
127 struct thermal_cooling_device *cdev; 126 struct thermal_cooling_device *cdev;
128 127
129 if (!device) 128 if (!device)
@@ -132,16 +131,12 @@ static int acpi_fan_add(struct acpi_device *device)
132 strcpy(acpi_device_name(device), "Fan"); 131 strcpy(acpi_device_name(device), "Fan");
133 strcpy(acpi_device_class(device), ACPI_FAN_CLASS); 132 strcpy(acpi_device_class(device), ACPI_FAN_CLASS);
134 133
135 result = acpi_bus_get_power(device->handle, &state); 134 result = acpi_bus_update_power(device->handle, NULL);
136 if (result) { 135 if (result) {
137 printk(KERN_ERR PREFIX "Reading power state\n"); 136 printk(KERN_ERR PREFIX "Setting initial power state\n");
138 goto end; 137 goto end;
139 } 138 }
140 139
141 device->flags.force_power_state = 1;
142 acpi_bus_set_power(device->handle, state);
143 device->flags.force_power_state = 0;
144
145 cdev = thermal_cooling_device_register("Fan", device, 140 cdev = thermal_cooling_device_register("Fan", device,
146 &fan_cooling_ops); 141 &fan_cooling_ops);
147 if (IS_ERR(cdev)) { 142 if (IS_ERR(cdev)) {
@@ -200,22 +195,14 @@ static int acpi_fan_suspend(struct acpi_device *device, pm_message_t state)
200 195
201static int acpi_fan_resume(struct acpi_device *device) 196static int acpi_fan_resume(struct acpi_device *device)
202{ 197{
203 int result = 0; 198 int result;
204 int power_state = 0;
205 199
206 if (!device) 200 if (!device)
207 return -EINVAL; 201 return -EINVAL;
208 202
209 result = acpi_bus_get_power(device->handle, &power_state); 203 result = acpi_bus_update_power(device->handle, NULL);
210 if (result) { 204 if (result)
211 printk(KERN_ERR PREFIX 205 printk(KERN_ERR PREFIX "Error updating fan power state\n");
212 "Error reading fan power state\n");
213 return result;
214 }
215
216 device->flags.force_power_state = 1;
217 acpi_bus_set_power(device->handle, power_state);
218 device->flags.force_power_state = 0;
219 206
220 return result; 207 return result;
221} 208}
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index a212bfeddf8c..8df5d7061a45 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -41,9 +41,10 @@ static inline int acpi_debugfs_init(void) { return 0; }
41int acpi_power_init(void); 41int acpi_power_init(void);
42int acpi_device_sleep_wake(struct acpi_device *dev, 42int acpi_device_sleep_wake(struct acpi_device *dev,
43 int enable, int sleep_state, int dev_state); 43 int enable, int sleep_state, int dev_state);
44int acpi_power_get_inferred_state(struct acpi_device *device); 44int acpi_power_get_inferred_state(struct acpi_device *device, int *state);
45int acpi_power_on_resources(struct acpi_device *device, int state);
45int acpi_power_transition(struct acpi_device *device, int state); 46int acpi_power_transition(struct acpi_device *device, int state);
46extern int acpi_power_nocheck; 47int acpi_bus_init_power(struct acpi_device *device);
47 48
48int acpi_wakeup_device_init(void); 49int acpi_wakeup_device_init(void);
49void acpi_early_processor_set_pdc(void); 50void acpi_early_processor_set_pdc(void);
diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
index 4c9c2fb5d98f..0003f1009885 100644
--- a/drivers/acpi/power.c
+++ b/drivers/acpi/power.c
@@ -56,9 +56,6 @@ ACPI_MODULE_NAME("power");
56#define ACPI_POWER_RESOURCE_STATE_ON 0x01 56#define ACPI_POWER_RESOURCE_STATE_ON 0x01
57#define ACPI_POWER_RESOURCE_STATE_UNKNOWN 0xFF 57#define ACPI_POWER_RESOURCE_STATE_UNKNOWN 0xFF
58 58
59int acpi_power_nocheck;
60module_param_named(power_nocheck, acpi_power_nocheck, bool, 000);
61
62static int acpi_power_add(struct acpi_device *device); 59static int acpi_power_add(struct acpi_device *device);
63static int acpi_power_remove(struct acpi_device *device, int type); 60static int acpi_power_remove(struct acpi_device *device, int type);
64static int acpi_power_resume(struct acpi_device *device); 61static int acpi_power_resume(struct acpi_device *device);
@@ -266,6 +263,35 @@ static int acpi_power_off_device(acpi_handle handle)
266 return result; 263 return result;
267} 264}
268 265
266static void __acpi_power_off_list(struct acpi_handle_list *list, int num_res)
267{
268 int i;
269
270 for (i = num_res - 1; i >= 0 ; i--)
271 acpi_power_off_device(list->handles[i]);
272}
273
274static void acpi_power_off_list(struct acpi_handle_list *list)
275{
276 __acpi_power_off_list(list, list->count);
277}
278
279static int acpi_power_on_list(struct acpi_handle_list *list)
280{
281 int result = 0;
282 int i;
283
284 for (i = 0; i < list->count; i++) {
285 result = acpi_power_on(list->handles[i]);
286 if (result) {
287 __acpi_power_off_list(list, i);
288 break;
289 }
290 }
291
292 return result;
293}
294
269/** 295/**
270 * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in 296 * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in
271 * ACPI 3.0) _PSW (Power State Wake) 297 * ACPI 3.0) _PSW (Power State Wake)
@@ -423,19 +449,16 @@ int acpi_disable_wakeup_device_power(struct acpi_device *dev)
423 Device Power Management 449 Device Power Management
424 -------------------------------------------------------------------------- */ 450 -------------------------------------------------------------------------- */
425 451
426int acpi_power_get_inferred_state(struct acpi_device *device) 452int acpi_power_get_inferred_state(struct acpi_device *device, int *state)
427{ 453{
428 int result = 0; 454 int result = 0;
429 struct acpi_handle_list *list = NULL; 455 struct acpi_handle_list *list = NULL;
430 int list_state = 0; 456 int list_state = 0;
431 int i = 0; 457 int i = 0;
432 458
433 459 if (!device || !state)
434 if (!device)
435 return -EINVAL; 460 return -EINVAL;
436 461
437 device->power.state = ACPI_STATE_UNKNOWN;
438
439 /* 462 /*
440 * We know a device's inferred power state when all the resources 463 * We know a device's inferred power state when all the resources
441 * required for a given D-state are 'on'. 464 * required for a given D-state are 'on'.
@@ -450,22 +473,26 @@ int acpi_power_get_inferred_state(struct acpi_device *device)
450 return result; 473 return result;
451 474
452 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) { 475 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {
453 device->power.state = i; 476 *state = i;
454 return 0; 477 return 0;
455 } 478 }
456 } 479 }
457 480
458 device->power.state = ACPI_STATE_D3; 481 *state = ACPI_STATE_D3;
459
460 return 0; 482 return 0;
461} 483}
462 484
485int acpi_power_on_resources(struct acpi_device *device, int state)
486{
487 if (!device || state < ACPI_STATE_D0 || state > ACPI_STATE_D3)
488 return -EINVAL;
489
490 return acpi_power_on_list(&device->power.states[state].resources);
491}
492
463int acpi_power_transition(struct acpi_device *device, int state) 493int acpi_power_transition(struct acpi_device *device, int state)
464{ 494{
465 int result = 0; 495 int result;
466 struct acpi_handle_list *cl = NULL; /* Current Resources */
467 struct acpi_handle_list *tl = NULL; /* Target Resources */
468 int i = 0;
469 496
470 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3)) 497 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
471 return -EINVAL; 498 return -EINVAL;
@@ -477,37 +504,20 @@ int acpi_power_transition(struct acpi_device *device, int state)
477 || (device->power.state > ACPI_STATE_D3)) 504 || (device->power.state > ACPI_STATE_D3))
478 return -ENODEV; 505 return -ENODEV;
479 506
480 cl = &device->power.states[device->power.state].resources;
481 tl = &device->power.states[state].resources;
482
483 /* TBD: Resources must be ordered. */ 507 /* TBD: Resources must be ordered. */
484 508
485 /* 509 /*
486 * First we reference all power resources required in the target list 510 * First we reference all power resources required in the target list
487 * (e.g. so the device doesn't lose power while transitioning). 511 * (e.g. so the device doesn't lose power while transitioning). Then,
512 * we dereference all power resources used in the current list.
488 */ 513 */
489 for (i = 0; i < tl->count; i++) { 514 result = acpi_power_on_list(&device->power.states[state].resources);
490 result = acpi_power_on(tl->handles[i]); 515 if (!result)
491 if (result) 516 acpi_power_off_list(
492 goto end; 517 &device->power.states[device->power.state].resources);
493 }
494
495 /*
496 * Then we dereference all power resources used in the current list.
497 */
498 for (i = 0; i < cl->count; i++) {
499 result = acpi_power_off_device(cl->handles[i]);
500 if (result)
501 goto end;
502 }
503 518
504 end: 519 /* We shouldn't change the state unless the above operations succeed. */
505 if (result) 520 device->power.state = result ? ACPI_STATE_UNKNOWN : state;
506 device->power.state = ACPI_STATE_UNKNOWN;
507 else {
508 /* We shouldn't change the state till all above operations succeed */
509 device->power.state = state;
510 }
511 521
512 return result; 522 return result;
513} 523}
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index bf7acbff1f5f..64d4da0d6d52 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -778,7 +778,7 @@ acpi_bus_extract_wakeup_device_power_package(acpi_handle handle,
778 wakeup->resources.handles[i] = element->reference.handle; 778 wakeup->resources.handles[i] = element->reference.handle;
779 } 779 }
780 780
781 acpi_gpe_can_wake(wakeup->gpe_device, wakeup->gpe_number); 781 acpi_setup_gpe_for_wake(handle, wakeup->gpe_device, wakeup->gpe_number);
782 782
783 out: 783 out:
784 kfree(buffer.pointer); 784 kfree(buffer.pointer);
@@ -847,6 +847,8 @@ end:
847 return 0; 847 return 0;
848} 848}
849 849
850static void acpi_bus_add_power_resource(acpi_handle handle);
851
850static int acpi_bus_get_power_flags(struct acpi_device *device) 852static int acpi_bus_get_power_flags(struct acpi_device *device)
851{ 853{
852 acpi_status status = 0; 854 acpi_status status = 0;
@@ -875,8 +877,12 @@ static int acpi_bus_get_power_flags(struct acpi_device *device)
875 acpi_evaluate_reference(device->handle, object_name, NULL, 877 acpi_evaluate_reference(device->handle, object_name, NULL,
876 &ps->resources); 878 &ps->resources);
877 if (ps->resources.count) { 879 if (ps->resources.count) {
880 int j;
881
878 device->power.flags.power_resources = 1; 882 device->power.flags.power_resources = 1;
879 ps->flags.valid = 1; 883 ps->flags.valid = 1;
884 for (j = 0; j < ps->resources.count; j++)
885 acpi_bus_add_power_resource(ps->resources.handles[j]);
880 } 886 }
881 887
882 /* Evaluate "_PSx" to see if we can do explicit sets */ 888 /* Evaluate "_PSx" to see if we can do explicit sets */
@@ -901,10 +907,7 @@ static int acpi_bus_get_power_flags(struct acpi_device *device)
901 device->power.states[ACPI_STATE_D3].flags.valid = 1; 907 device->power.states[ACPI_STATE_D3].flags.valid = 1;
902 device->power.states[ACPI_STATE_D3].power = 0; 908 device->power.states[ACPI_STATE_D3].power = 0;
903 909
904 /* TBD: System wake support and resource requirements. */ 910 acpi_bus_init_power(device);
905
906 device->power.state = ACPI_STATE_UNKNOWN;
907 acpi_bus_get_power(device->handle, &(device->power.state));
908 911
909 return 0; 912 return 0;
910} 913}
@@ -1326,6 +1329,20 @@ end:
1326#define ACPI_STA_DEFAULT (ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | \ 1329#define ACPI_STA_DEFAULT (ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | \
1327 ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING) 1330 ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING)
1328 1331
1332static void acpi_bus_add_power_resource(acpi_handle handle)
1333{
1334 struct acpi_bus_ops ops = {
1335 .acpi_op_add = 1,
1336 .acpi_op_start = 1,
1337 };
1338 struct acpi_device *device = NULL;
1339
1340 acpi_bus_get_device(handle, &device);
1341 if (!device)
1342 acpi_add_single_object(&device, handle, ACPI_BUS_TYPE_POWER,
1343 ACPI_STA_DEFAULT, &ops);
1344}
1345
1329static int acpi_bus_type_and_status(acpi_handle handle, int *type, 1346static int acpi_bus_type_and_status(acpi_handle handle, int *type,
1330 unsigned long long *sta) 1347 unsigned long long *sta)
1331{ 1348{
@@ -1467,7 +1484,7 @@ int acpi_bus_start(struct acpi_device *device)
1467 1484
1468 result = acpi_bus_scan(device->handle, &ops, NULL); 1485 result = acpi_bus_scan(device->handle, &ops, NULL);
1469 1486
1470 acpi_update_gpes(); 1487 acpi_update_all_gpes();
1471 1488
1472 return result; 1489 return result;
1473} 1490}
@@ -1573,6 +1590,8 @@ int __init acpi_scan_init(void)
1573 printk(KERN_ERR PREFIX "Could not register bus type\n"); 1590 printk(KERN_ERR PREFIX "Could not register bus type\n");
1574 } 1591 }
1575 1592
1593 acpi_power_init();
1594
1576 /* 1595 /*
1577 * Enumerate devices in the ACPI namespace. 1596 * Enumerate devices in the ACPI namespace.
1578 */ 1597 */
@@ -1584,7 +1603,7 @@ int __init acpi_scan_init(void)
1584 if (result) 1603 if (result)
1585 acpi_device_unregister(acpi_root, ACPI_BUS_REMOVAL_NORMAL); 1604 acpi_device_unregister(acpi_root, ACPI_BUS_REMOVAL_NORMAL);
1586 else 1605 else
1587 acpi_update_gpes(); 1606 acpi_update_all_gpes();
1588 1607
1589 return result; 1608 return result;
1590} 1609}
diff --git a/drivers/acpi/sysfs.c b/drivers/acpi/sysfs.c
index f8588f81048a..61891e75583d 100644
--- a/drivers/acpi/sysfs.c
+++ b/drivers/acpi/sysfs.c
@@ -438,7 +438,7 @@ static void delete_gpe_attr_array(void)
438 return; 438 return;
439} 439}
440 440
441void acpi_os_gpe_count(u32 gpe_number) 441static void gpe_count(u32 gpe_number)
442{ 442{
443 acpi_gpe_count++; 443 acpi_gpe_count++;
444 444
@@ -454,7 +454,7 @@ void acpi_os_gpe_count(u32 gpe_number)
454 return; 454 return;
455} 455}
456 456
457void acpi_os_fixed_event_count(u32 event_number) 457static void fixed_event_count(u32 event_number)
458{ 458{
459 if (!all_counters) 459 if (!all_counters)
460 return; 460 return;
@@ -468,6 +468,16 @@ void acpi_os_fixed_event_count(u32 event_number)
468 return; 468 return;
469} 469}
470 470
471static void acpi_gbl_event_handler(u32 event_type, acpi_handle device,
472 u32 event_number, void *context)
473{
474 if (event_type == ACPI_EVENT_TYPE_GPE)
475 gpe_count(event_number);
476
477 if (event_type == ACPI_EVENT_TYPE_FIXED)
478 fixed_event_count(event_number);
479}
480
471static int get_status(u32 index, acpi_event_status *status, 481static int get_status(u32 index, acpi_event_status *status,
472 acpi_handle *handle) 482 acpi_handle *handle)
473{ 483{
@@ -601,6 +611,7 @@ end:
601 611
602void acpi_irq_stats_init(void) 612void acpi_irq_stats_init(void)
603{ 613{
614 acpi_status status;
604 int i; 615 int i;
605 616
606 if (all_counters) 617 if (all_counters)
@@ -619,6 +630,10 @@ void acpi_irq_stats_init(void)
619 if (all_counters == NULL) 630 if (all_counters == NULL)
620 goto fail; 631 goto fail;
621 632
633 status = acpi_install_global_event_handler(acpi_gbl_event_handler, NULL);
634 if (ACPI_FAILURE(status))
635 goto fail;
636
622 counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters), 637 counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters),
623 GFP_KERNEL); 638 GFP_KERNEL);
624 if (counter_attrs == NULL) 639 if (counter_attrs == NULL)
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index 5a27b0a31315..2607e17b520f 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -1059,8 +1059,9 @@ static int acpi_thermal_resume(struct acpi_device *device)
1059 break; 1059 break;
1060 tz->trips.active[i].flags.enabled = 1; 1060 tz->trips.active[i].flags.enabled = 1;
1061 for (j = 0; j < tz->trips.active[i].devices.count; j++) { 1061 for (j = 0; j < tz->trips.active[i].devices.count; j++) {
1062 result = acpi_bus_get_power(tz->trips.active[i].devices. 1062 result = acpi_bus_update_power(
1063 handles[j], &power_state); 1063 tz->trips.active[i].devices.handles[j],
1064 &power_state);
1064 if (result || (power_state != ACPI_STATE_D0)) { 1065 if (result || (power_state != ACPI_STATE_D0)) {
1065 tz->trips.active[i].flags.enabled = 0; 1066 tz->trips.active[i].flags.enabled = 0;
1066 break; 1067 break;
diff --git a/drivers/acpi/wakeup.c b/drivers/acpi/wakeup.c
index f252d0de9922..ed6501452507 100644
--- a/drivers/acpi/wakeup.c
+++ b/drivers/acpi/wakeup.c
@@ -46,7 +46,7 @@ void acpi_enable_wakeup_devices(u8 sleep_state)
46 acpi_enable_wakeup_device_power(dev, sleep_state); 46 acpi_enable_wakeup_device_power(dev, sleep_state);
47 47
48 /* The wake-up power should have been enabled already. */ 48 /* The wake-up power should have been enabled already. */
49 acpi_gpe_wakeup(dev->wakeup.gpe_device, dev->wakeup.gpe_number, 49 acpi_set_gpe_wake_mask(dev->wakeup.gpe_device, dev->wakeup.gpe_number,
50 ACPI_GPE_ENABLE); 50 ACPI_GPE_ENABLE);
51 } 51 }
52} 52}
@@ -69,7 +69,7 @@ void acpi_disable_wakeup_devices(u8 sleep_state)
69 || dev->wakeup.prepare_count)) 69 || dev->wakeup.prepare_count))
70 continue; 70 continue;
71 71
72 acpi_gpe_wakeup(dev->wakeup.gpe_device, dev->wakeup.gpe_number, 72 acpi_set_gpe_wake_mask(dev->wakeup.gpe_device, dev->wakeup.gpe_number,
73 ACPI_GPE_DISABLE); 73 ACPI_GPE_DISABLE);
74 74
75 if (device_may_wakeup(&dev->dev)) 75 if (device_may_wakeup(&dev->dev))
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 035da9e64a17..c4bacc6ec450 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -1928,7 +1928,8 @@ static void __devinit hardcode_find_bmc(void)
1928static int acpi_failure; 1928static int acpi_failure;
1929 1929
1930/* For GPE-type interrupts. */ 1930/* For GPE-type interrupts. */
1931static u32 ipmi_acpi_gpe(void *context) 1931static u32 ipmi_acpi_gpe(acpi_handle gpe_device,
1932 u32 gpe_number, void *context)
1932{ 1933{
1933 struct smi_info *smi_info = context; 1934 struct smi_info *smi_info = context;
1934 unsigned long flags; 1935 unsigned long flags;
diff --git a/drivers/platform/x86/fujitsu-laptop.c b/drivers/platform/x86/fujitsu-laptop.c
index f44cd2620ff9..cf6c47250c56 100644
--- a/drivers/platform/x86/fujitsu-laptop.c
+++ b/drivers/platform/x86/fujitsu-laptop.c
@@ -689,7 +689,7 @@ static int acpi_fujitsu_add(struct acpi_device *device)
689 if (error) 689 if (error)
690 goto err_free_input_dev; 690 goto err_free_input_dev;
691 691
692 result = acpi_bus_get_power(fujitsu->acpi_handle, &state); 692 result = acpi_bus_update_power(fujitsu->acpi_handle, &state);
693 if (result) { 693 if (result) {
694 printk(KERN_ERR "Error reading power state\n"); 694 printk(KERN_ERR "Error reading power state\n");
695 goto err_unregister_input_dev; 695 goto err_unregister_input_dev;
@@ -857,7 +857,7 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
857 if (error) 857 if (error)
858 goto err_free_input_dev; 858 goto err_free_input_dev;
859 859
860 result = acpi_bus_get_power(fujitsu_hotkey->acpi_handle, &state); 860 result = acpi_bus_update_power(fujitsu_hotkey->acpi_handle, &state);
861 if (result) { 861 if (result) {
862 printk(KERN_ERR "Error reading power state\n"); 862 printk(KERN_ERR "Error reading power state\n");
863 goto err_unregister_input_dev; 863 goto err_unregister_input_dev;
diff --git a/include/acpi/acpi_bus.h b/include/acpi/acpi_bus.h
index f2499f572109..20b05cd68663 100644
--- a/include/acpi/acpi_bus.h
+++ b/include/acpi/acpi_bus.h
@@ -149,8 +149,7 @@ struct acpi_device_flags {
149 u32 power_manageable:1; 149 u32 power_manageable:1;
150 u32 performance_manageable:1; 150 u32 performance_manageable:1;
151 u32 wake_capable:1; /* Wakeup(_PRW) supported? */ 151 u32 wake_capable:1; /* Wakeup(_PRW) supported? */
152 u32 force_power_state:1; 152 u32 reserved:23;
153 u32 reserved:22;
154}; 153};
155 154
156/* File System */ 155/* File System */
@@ -322,8 +321,8 @@ void acpi_bus_data_handler(acpi_handle handle, void *context);
322acpi_status acpi_bus_get_status_handle(acpi_handle handle, 321acpi_status acpi_bus_get_status_handle(acpi_handle handle,
323 unsigned long long *sta); 322 unsigned long long *sta);
324int acpi_bus_get_status(struct acpi_device *device); 323int acpi_bus_get_status(struct acpi_device *device);
325int acpi_bus_get_power(acpi_handle handle, int *state);
326int acpi_bus_set_power(acpi_handle handle, int state); 324int acpi_bus_set_power(acpi_handle handle, int state);
325int acpi_bus_update_power(acpi_handle handle, int *state_p);
327bool acpi_bus_power_manageable(acpi_handle handle); 326bool acpi_bus_power_manageable(acpi_handle handle);
328bool acpi_bus_can_wakeup(acpi_handle handle); 327bool acpi_bus_can_wakeup(acpi_handle handle);
329#ifdef CONFIG_ACPI_PROC_EVENT 328#ifdef CONFIG_ACPI_PROC_EVENT
diff --git a/include/acpi/acpixf.h b/include/acpi/acpixf.h
index 53b7cfd924a3..241b8a04c83c 100644
--- a/include/acpi/acpixf.h
+++ b/include/acpi/acpixf.h
@@ -47,7 +47,7 @@
47 47
48/* Current ACPICA subsystem version in YYYYMMDD format */ 48/* Current ACPICA subsystem version in YYYYMMDD format */
49 49
50#define ACPI_CA_VERSION 0x20101013 50#define ACPI_CA_VERSION 0x20101209
51 51
52#include "actypes.h" 52#include "actypes.h"
53#include "actbl.h" 53#include "actbl.h"
@@ -229,6 +229,10 @@ acpi_status
229acpi_install_initialization_handler(acpi_init_handler handler, u32 function); 229acpi_install_initialization_handler(acpi_init_handler handler, u32 function);
230 230
231acpi_status 231acpi_status
232acpi_install_global_event_handler(ACPI_GBL_EVENT_HANDLER handler,
233 void *context);
234
235acpi_status
232acpi_install_fixed_event_handler(u32 acpi_event, 236acpi_install_fixed_event_handler(u32 acpi_event,
233 acpi_event_handler handler, void *context); 237 acpi_event_handler handler, void *context);
234 238
@@ -258,11 +262,11 @@ acpi_remove_address_space_handler(acpi_handle device,
258acpi_status 262acpi_status
259acpi_install_gpe_handler(acpi_handle gpe_device, 263acpi_install_gpe_handler(acpi_handle gpe_device,
260 u32 gpe_number, 264 u32 gpe_number,
261 u32 type, acpi_event_handler address, void *context); 265 u32 type, acpi_gpe_handler address, void *context);
262 266
263acpi_status 267acpi_status
264acpi_remove_gpe_handler(acpi_handle gpe_device, 268acpi_remove_gpe_handler(acpi_handle gpe_device,
265 u32 gpe_number, acpi_event_handler address); 269 u32 gpe_number, acpi_gpe_handler address);
266 270
267#ifdef ACPI_FUTURE_USAGE 271#ifdef ACPI_FUTURE_USAGE
268acpi_status acpi_install_exception_handler(acpi_exception_handler handler); 272acpi_status acpi_install_exception_handler(acpi_exception_handler handler);
@@ -292,11 +296,13 @@ acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number);
292 296
293acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number); 297acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number);
294 298
295acpi_status acpi_gpe_can_wake(acpi_handle gpe_device, u32 gpe_number);
296
297acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number); 299acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number);
298 300
299acpi_status acpi_gpe_wakeup(acpi_handle gpe_device, u32 gpe_number, u8 action); 301acpi_status
302acpi_setup_gpe_for_wake(acpi_handle parent_device,
303 acpi_handle gpe_device, u32 gpe_number);
304
305acpi_status acpi_set_gpe_wake_mask(acpi_handle gpe_device, u32 gpe_number, u8 action);
300 306
301acpi_status 307acpi_status
302acpi_get_gpe_status(acpi_handle gpe_device, 308acpi_get_gpe_status(acpi_handle gpe_device,
@@ -315,7 +321,7 @@ acpi_install_gpe_block(acpi_handle gpe_device,
315 321
316acpi_status acpi_remove_gpe_block(acpi_handle gpe_device); 322acpi_status acpi_remove_gpe_block(acpi_handle gpe_device);
317 323
318acpi_status acpi_update_gpes(void); 324acpi_status acpi_update_all_gpes(void);
319 325
320/* 326/*
321 * Resource interfaces 327 * Resource interfaces
diff --git a/include/acpi/actypes.h b/include/acpi/actypes.h
index 2b134b691e34..939a431a6ab6 100644
--- a/include/acpi/actypes.h
+++ b/include/acpi/actypes.h
@@ -656,33 +656,34 @@ typedef u32 acpi_event_status;
656#define ACPI_GPE_MAX 0xFF 656#define ACPI_GPE_MAX 0xFF
657#define ACPI_NUM_GPE 256 657#define ACPI_NUM_GPE 256
658 658
659/* Actions for acpi_gpe_wakeup, acpi_hw_low_set_gpe */ 659/* Actions for acpi_set_gpe_wake_mask, acpi_hw_low_set_gpe */
660 660
661#define ACPI_GPE_ENABLE 0 661#define ACPI_GPE_ENABLE 0
662#define ACPI_GPE_DISABLE 1 662#define ACPI_GPE_DISABLE 1
663#define ACPI_GPE_COND_ENABLE 2 663#define ACPI_GPE_CONDITIONAL_ENABLE 2
664 664
665/* 665/*
666 * GPE info flags - Per GPE 666 * GPE info flags - Per GPE
667 * +-------+---+-+-+ 667 * +-------+-+-+---+
668 * | 7:4 |3:2|1|0| 668 * | 7:4 |3|2|1:0|
669 * +-------+---+-+-+ 669 * +-------+-+-+---+
670 * | | | | 670 * | | | |
671 * | | | +--- Interrupt type: edge or level triggered 671 * | | | +-- Type of dispatch:to method, handler, notify, or none
672 * | | +----- GPE can wake the system 672 * | | +----- Interrupt type: edge or level triggered
673 * | +-------- Type of dispatch:to method, handler, or none 673 * | +------- Is a Wake GPE
674 * +-------------- <Reserved> 674 * +------------ <Reserved>
675 */ 675 */
676#define ACPI_GPE_XRUPT_TYPE_MASK (u8) 0x01 676#define ACPI_GPE_DISPATCH_NONE (u8) 0x00
677#define ACPI_GPE_LEVEL_TRIGGERED (u8) 0x01 677#define ACPI_GPE_DISPATCH_METHOD (u8) 0x01
678#define ACPI_GPE_EDGE_TRIGGERED (u8) 0x00 678#define ACPI_GPE_DISPATCH_HANDLER (u8) 0x02
679#define ACPI_GPE_DISPATCH_NOTIFY (u8) 0x03
680#define ACPI_GPE_DISPATCH_MASK (u8) 0x03
679 681
680#define ACPI_GPE_CAN_WAKE (u8) 0x02 682#define ACPI_GPE_LEVEL_TRIGGERED (u8) 0x04
683#define ACPI_GPE_EDGE_TRIGGERED (u8) 0x00
684#define ACPI_GPE_XRUPT_TYPE_MASK (u8) 0x04
681 685
682#define ACPI_GPE_DISPATCH_MASK (u8) 0x0C 686#define ACPI_GPE_CAN_WAKE (u8) 0x08
683#define ACPI_GPE_DISPATCH_HANDLER (u8) 0x04
684#define ACPI_GPE_DISPATCH_METHOD (u8) 0x08
685#define ACPI_GPE_DISPATCH_NOT_USED (u8) 0x00
686 687
687/* 688/*
688 * Flags for GPE and Lock interfaces 689 * Flags for GPE and Lock interfaces
@@ -894,9 +895,20 @@ typedef void
894/* 895/*
895 * Various handlers and callback procedures 896 * Various handlers and callback procedures
896 */ 897 */
898typedef
899void (*ACPI_GBL_EVENT_HANDLER) (u32 event_type,
900 acpi_handle device,
901 u32 event_number, void *context);
902
903#define ACPI_EVENT_TYPE_GPE 0
904#define ACPI_EVENT_TYPE_FIXED 1
905
897typedef u32(*acpi_event_handler) (void *context); 906typedef u32(*acpi_event_handler) (void *context);
898 907
899typedef 908typedef
909u32 (*acpi_gpe_handler) (acpi_handle gpe_device, u32 gpe_number, void *context);
910
911typedef
900void (*acpi_notify_handler) (acpi_handle device, u32 value, void *context); 912void (*acpi_notify_handler) (acpi_handle device, u32 value, void *context);
901 913
902typedef 914typedef
@@ -951,6 +963,10 @@ u32 (*acpi_interface_handler) (acpi_string interface_name, u32 supported);
951#define ACPI_INTERRUPT_NOT_HANDLED 0x00 963#define ACPI_INTERRUPT_NOT_HANDLED 0x00
952#define ACPI_INTERRUPT_HANDLED 0x01 964#define ACPI_INTERRUPT_HANDLED 0x01
953 965
966/* GPE handler return values */
967
968#define ACPI_REENABLE_GPE 0x80
969
954/* Length of 32-bit EISAID values when converted back to a string */ 970/* Length of 32-bit EISAID values when converted back to a string */
955 971
956#define ACPI_EISAID_STRING_SIZE 8 /* Includes null terminator */ 972#define ACPI_EISAID_STRING_SIZE 8 /* Includes null terminator */
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-06 17:21:30 -0400