diff options
Diffstat (limited to 'drivers/acpi/hardware/hwgpe.c')
-rw-r--r-- | drivers/acpi/hardware/hwgpe.c | 197 |
1 files changed, 82 insertions, 115 deletions
diff --git a/drivers/acpi/hardware/hwgpe.c b/drivers/acpi/hardware/hwgpe.c index 3536bbb990c3..5c8e5dfd024e 100644 --- a/drivers/acpi/hardware/hwgpe.c +++ b/drivers/acpi/hardware/hwgpe.c | |||
@@ -46,15 +46,12 @@ | |||
46 | #include <acpi/acevents.h> | 46 | #include <acpi/acevents.h> |
47 | 47 | ||
48 | #define _COMPONENT ACPI_HARDWARE | 48 | #define _COMPONENT ACPI_HARDWARE |
49 | ACPI_MODULE_NAME ("hwgpe") | 49 | ACPI_MODULE_NAME("hwgpe") |
50 | 50 | ||
51 | /* Local prototypes */ | 51 | /* Local prototypes */ |
52 | |||
53 | static acpi_status | 52 | static acpi_status |
54 | acpi_hw_enable_wakeup_gpe_block ( | 53 | acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info, |
55 | struct acpi_gpe_xrupt_info *gpe_xrupt_info, | 54 | struct acpi_gpe_block_info *gpe_block); |
56 | struct acpi_gpe_block_info *gpe_block); | ||
57 | |||
58 | 55 | ||
59 | /****************************************************************************** | 56 | /****************************************************************************** |
60 | * | 57 | * |
@@ -71,15 +68,12 @@ acpi_hw_enable_wakeup_gpe_block ( | |||
71 | ******************************************************************************/ | 68 | ******************************************************************************/ |
72 | 69 | ||
73 | acpi_status | 70 | acpi_status |
74 | acpi_hw_write_gpe_enable_reg ( | 71 | acpi_hw_write_gpe_enable_reg(struct acpi_gpe_event_info *gpe_event_info) |
75 | struct acpi_gpe_event_info *gpe_event_info) | ||
76 | { | 72 | { |
77 | struct acpi_gpe_register_info *gpe_register_info; | 73 | struct acpi_gpe_register_info *gpe_register_info; |
78 | acpi_status status; | 74 | acpi_status status; |
79 | |||
80 | |||
81 | ACPI_FUNCTION_ENTRY (); | ||
82 | 75 | ||
76 | ACPI_FUNCTION_ENTRY(); | ||
83 | 77 | ||
84 | /* Get the info block for the entire GPE register */ | 78 | /* Get the info block for the entire GPE register */ |
85 | 79 | ||
@@ -90,13 +84,12 @@ acpi_hw_write_gpe_enable_reg ( | |||
90 | 84 | ||
91 | /* Write the entire GPE (runtime) enable register */ | 85 | /* Write the entire GPE (runtime) enable register */ |
92 | 86 | ||
93 | status = acpi_hw_low_level_write (8, gpe_register_info->enable_for_run, | 87 | status = acpi_hw_low_level_write(8, gpe_register_info->enable_for_run, |
94 | &gpe_register_info->enable_address); | 88 | &gpe_register_info->enable_address); |
95 | 89 | ||
96 | return (status); | 90 | return (status); |
97 | } | 91 | } |
98 | 92 | ||
99 | |||
100 | /****************************************************************************** | 93 | /****************************************************************************** |
101 | * | 94 | * |
102 | * FUNCTION: acpi_hw_clear_gpe | 95 | * FUNCTION: acpi_hw_clear_gpe |
@@ -109,27 +102,23 @@ acpi_hw_write_gpe_enable_reg ( | |||
109 | * | 102 | * |
110 | ******************************************************************************/ | 103 | ******************************************************************************/ |
111 | 104 | ||
112 | acpi_status | 105 | acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info * gpe_event_info) |
113 | acpi_hw_clear_gpe ( | ||
114 | struct acpi_gpe_event_info *gpe_event_info) | ||
115 | { | 106 | { |
116 | acpi_status status; | 107 | acpi_status status; |
117 | |||
118 | |||
119 | ACPI_FUNCTION_ENTRY (); | ||
120 | 108 | ||
109 | ACPI_FUNCTION_ENTRY(); | ||
121 | 110 | ||
122 | /* | 111 | /* |
123 | * Write a one to the appropriate bit in the status register to | 112 | * Write a one to the appropriate bit in the status register to |
124 | * clear this GPE. | 113 | * clear this GPE. |
125 | */ | 114 | */ |
126 | status = acpi_hw_low_level_write (8, gpe_event_info->register_bit, | 115 | status = acpi_hw_low_level_write(8, gpe_event_info->register_bit, |
127 | &gpe_event_info->register_info->status_address); | 116 | &gpe_event_info->register_info-> |
117 | status_address); | ||
128 | 118 | ||
129 | return (status); | 119 | return (status); |
130 | } | 120 | } |
131 | 121 | ||
132 | |||
133 | /****************************************************************************** | 122 | /****************************************************************************** |
134 | * | 123 | * |
135 | * FUNCTION: acpi_hw_get_gpe_status | 124 | * FUNCTION: acpi_hw_get_gpe_status |
@@ -145,19 +134,16 @@ acpi_hw_clear_gpe ( | |||
145 | 134 | ||
146 | #ifdef ACPI_FUTURE_USAGE | 135 | #ifdef ACPI_FUTURE_USAGE |
147 | acpi_status | 136 | acpi_status |
148 | acpi_hw_get_gpe_status ( | 137 | acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info, |
149 | struct acpi_gpe_event_info *gpe_event_info, | 138 | acpi_event_status * event_status) |
150 | acpi_event_status *event_status) | ||
151 | { | 139 | { |
152 | u32 in_byte; | 140 | u32 in_byte; |
153 | u8 register_bit; | 141 | u8 register_bit; |
154 | struct acpi_gpe_register_info *gpe_register_info; | 142 | struct acpi_gpe_register_info *gpe_register_info; |
155 | acpi_status status; | 143 | acpi_status status; |
156 | acpi_event_status local_event_status = 0; | 144 | acpi_event_status local_event_status = 0; |
157 | |||
158 | |||
159 | ACPI_FUNCTION_ENTRY (); | ||
160 | 145 | ||
146 | ACPI_FUNCTION_ENTRY(); | ||
161 | 147 | ||
162 | if (!event_status) { | 148 | if (!event_status) { |
163 | return (AE_BAD_PARAMETER); | 149 | return (AE_BAD_PARAMETER); |
@@ -185,8 +171,10 @@ acpi_hw_get_gpe_status ( | |||
185 | 171 | ||
186 | /* GPE currently active (status bit == 1)? */ | 172 | /* GPE currently active (status bit == 1)? */ |
187 | 173 | ||
188 | status = acpi_hw_low_level_read (8, &in_byte, &gpe_register_info->status_address); | 174 | status = |
189 | if (ACPI_FAILURE (status)) { | 175 | acpi_hw_low_level_read(8, &in_byte, |
176 | &gpe_register_info->status_address); | ||
177 | if (ACPI_FAILURE(status)) { | ||
190 | goto unlock_and_exit; | 178 | goto unlock_and_exit; |
191 | } | 179 | } |
192 | 180 | ||
@@ -198,12 +186,10 @@ acpi_hw_get_gpe_status ( | |||
198 | 186 | ||
199 | (*event_status) = local_event_status; | 187 | (*event_status) = local_event_status; |
200 | 188 | ||
201 | 189 | unlock_and_exit: | |
202 | unlock_and_exit: | ||
203 | return (status); | 190 | return (status); |
204 | } | 191 | } |
205 | #endif /* ACPI_FUTURE_USAGE */ | 192 | #endif /* ACPI_FUTURE_USAGE */ |
206 | |||
207 | 193 | ||
208 | /****************************************************************************** | 194 | /****************************************************************************** |
209 | * | 195 | * |
@@ -219,22 +205,21 @@ unlock_and_exit: | |||
219 | ******************************************************************************/ | 205 | ******************************************************************************/ |
220 | 206 | ||
221 | acpi_status | 207 | acpi_status |
222 | acpi_hw_disable_gpe_block ( | 208 | acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info * gpe_xrupt_info, |
223 | struct acpi_gpe_xrupt_info *gpe_xrupt_info, | 209 | struct acpi_gpe_block_info * gpe_block) |
224 | struct acpi_gpe_block_info *gpe_block) | ||
225 | { | 210 | { |
226 | u32 i; | 211 | u32 i; |
227 | acpi_status status; | 212 | acpi_status status; |
228 | |||
229 | 213 | ||
230 | /* Examine each GPE Register within the block */ | 214 | /* Examine each GPE Register within the block */ |
231 | 215 | ||
232 | for (i = 0; i < gpe_block->register_count; i++) { | 216 | for (i = 0; i < gpe_block->register_count; i++) { |
233 | /* Disable all GPEs in this register */ | 217 | /* Disable all GPEs in this register */ |
234 | 218 | ||
235 | status = acpi_hw_low_level_write (8, 0x00, | 219 | status = acpi_hw_low_level_write(8, 0x00, |
236 | &gpe_block->register_info[i].enable_address); | 220 | &gpe_block->register_info[i]. |
237 | if (ACPI_FAILURE (status)) { | 221 | enable_address); |
222 | if (ACPI_FAILURE(status)) { | ||
238 | return (status); | 223 | return (status); |
239 | } | 224 | } |
240 | } | 225 | } |
@@ -242,7 +227,6 @@ acpi_hw_disable_gpe_block ( | |||
242 | return (AE_OK); | 227 | return (AE_OK); |
243 | } | 228 | } |
244 | 229 | ||
245 | |||
246 | /****************************************************************************** | 230 | /****************************************************************************** |
247 | * | 231 | * |
248 | * FUNCTION: acpi_hw_clear_gpe_block | 232 | * FUNCTION: acpi_hw_clear_gpe_block |
@@ -257,22 +241,21 @@ acpi_hw_disable_gpe_block ( | |||
257 | ******************************************************************************/ | 241 | ******************************************************************************/ |
258 | 242 | ||
259 | acpi_status | 243 | acpi_status |
260 | acpi_hw_clear_gpe_block ( | 244 | acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info * gpe_xrupt_info, |
261 | struct acpi_gpe_xrupt_info *gpe_xrupt_info, | 245 | struct acpi_gpe_block_info * gpe_block) |
262 | struct acpi_gpe_block_info *gpe_block) | ||
263 | { | 246 | { |
264 | u32 i; | 247 | u32 i; |
265 | acpi_status status; | 248 | acpi_status status; |
266 | |||
267 | 249 | ||
268 | /* Examine each GPE Register within the block */ | 250 | /* Examine each GPE Register within the block */ |
269 | 251 | ||
270 | for (i = 0; i < gpe_block->register_count; i++) { | 252 | for (i = 0; i < gpe_block->register_count; i++) { |
271 | /* Clear status on all GPEs in this register */ | 253 | /* Clear status on all GPEs in this register */ |
272 | 254 | ||
273 | status = acpi_hw_low_level_write (8, 0xFF, | 255 | status = acpi_hw_low_level_write(8, 0xFF, |
274 | &gpe_block->register_info[i].status_address); | 256 | &gpe_block->register_info[i]. |
275 | if (ACPI_FAILURE (status)) { | 257 | status_address); |
258 | if (ACPI_FAILURE(status)) { | ||
276 | return (status); | 259 | return (status); |
277 | } | 260 | } |
278 | } | 261 | } |
@@ -280,7 +263,6 @@ acpi_hw_clear_gpe_block ( | |||
280 | return (AE_OK); | 263 | return (AE_OK); |
281 | } | 264 | } |
282 | 265 | ||
283 | |||
284 | /****************************************************************************** | 266 | /****************************************************************************** |
285 | * | 267 | * |
286 | * FUNCTION: acpi_hw_enable_runtime_gpe_block | 268 | * FUNCTION: acpi_hw_enable_runtime_gpe_block |
@@ -296,13 +278,11 @@ acpi_hw_clear_gpe_block ( | |||
296 | ******************************************************************************/ | 278 | ******************************************************************************/ |
297 | 279 | ||
298 | acpi_status | 280 | acpi_status |
299 | acpi_hw_enable_runtime_gpe_block ( | 281 | acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info * gpe_xrupt_info, |
300 | struct acpi_gpe_xrupt_info *gpe_xrupt_info, | 282 | struct acpi_gpe_block_info * gpe_block) |
301 | struct acpi_gpe_block_info *gpe_block) | ||
302 | { | 283 | { |
303 | u32 i; | 284 | u32 i; |
304 | acpi_status status; | 285 | acpi_status status; |
305 | |||
306 | 286 | ||
307 | /* NOTE: assumes that all GPEs are currently disabled */ | 287 | /* NOTE: assumes that all GPEs are currently disabled */ |
308 | 288 | ||
@@ -315,9 +295,13 @@ acpi_hw_enable_runtime_gpe_block ( | |||
315 | 295 | ||
316 | /* Enable all "runtime" GPEs in this register */ | 296 | /* Enable all "runtime" GPEs in this register */ |
317 | 297 | ||
318 | status = acpi_hw_low_level_write (8, gpe_block->register_info[i].enable_for_run, | 298 | status = |
319 | &gpe_block->register_info[i].enable_address); | 299 | acpi_hw_low_level_write(8, |
320 | if (ACPI_FAILURE (status)) { | 300 | gpe_block->register_info[i]. |
301 | enable_for_run, | ||
302 | &gpe_block->register_info[i]. | ||
303 | enable_address); | ||
304 | if (ACPI_FAILURE(status)) { | ||
321 | return (status); | 305 | return (status); |
322 | } | 306 | } |
323 | } | 307 | } |
@@ -325,7 +309,6 @@ acpi_hw_enable_runtime_gpe_block ( | |||
325 | return (AE_OK); | 309 | return (AE_OK); |
326 | } | 310 | } |
327 | 311 | ||
328 | |||
329 | /****************************************************************************** | 312 | /****************************************************************************** |
330 | * | 313 | * |
331 | * FUNCTION: acpi_hw_enable_wakeup_gpe_block | 314 | * FUNCTION: acpi_hw_enable_wakeup_gpe_block |
@@ -341,13 +324,11 @@ acpi_hw_enable_runtime_gpe_block ( | |||
341 | ******************************************************************************/ | 324 | ******************************************************************************/ |
342 | 325 | ||
343 | static acpi_status | 326 | static acpi_status |
344 | acpi_hw_enable_wakeup_gpe_block ( | 327 | acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info, |
345 | struct acpi_gpe_xrupt_info *gpe_xrupt_info, | 328 | struct acpi_gpe_block_info *gpe_block) |
346 | struct acpi_gpe_block_info *gpe_block) | ||
347 | { | 329 | { |
348 | u32 i; | 330 | u32 i; |
349 | acpi_status status; | 331 | acpi_status status; |
350 | |||
351 | 332 | ||
352 | /* Examine each GPE Register within the block */ | 333 | /* Examine each GPE Register within the block */ |
353 | 334 | ||
@@ -358,10 +339,12 @@ acpi_hw_enable_wakeup_gpe_block ( | |||
358 | 339 | ||
359 | /* Enable all "wake" GPEs in this register */ | 340 | /* Enable all "wake" GPEs in this register */ |
360 | 341 | ||
361 | status = acpi_hw_low_level_write (8, | 342 | status = acpi_hw_low_level_write(8, |
362 | gpe_block->register_info[i].enable_for_wake, | 343 | gpe_block->register_info[i]. |
363 | &gpe_block->register_info[i].enable_address); | 344 | enable_for_wake, |
364 | if (ACPI_FAILURE (status)) { | 345 | &gpe_block->register_info[i]. |
346 | enable_address); | ||
347 | if (ACPI_FAILURE(status)) { | ||
365 | return (status); | 348 | return (status); |
366 | } | 349 | } |
367 | } | 350 | } |
@@ -369,7 +352,6 @@ acpi_hw_enable_wakeup_gpe_block ( | |||
369 | return (AE_OK); | 352 | return (AE_OK); |
370 | } | 353 | } |
371 | 354 | ||
372 | |||
373 | /****************************************************************************** | 355 | /****************************************************************************** |
374 | * | 356 | * |
375 | * FUNCTION: acpi_hw_disable_all_gpes | 357 | * FUNCTION: acpi_hw_disable_all_gpes |
@@ -382,22 +364,17 @@ acpi_hw_enable_wakeup_gpe_block ( | |||
382 | * | 364 | * |
383 | ******************************************************************************/ | 365 | ******************************************************************************/ |
384 | 366 | ||
385 | acpi_status | 367 | acpi_status acpi_hw_disable_all_gpes(void) |
386 | acpi_hw_disable_all_gpes ( | ||
387 | void) | ||
388 | { | 368 | { |
389 | acpi_status status; | 369 | acpi_status status; |
390 | |||
391 | 370 | ||
392 | ACPI_FUNCTION_TRACE ("hw_disable_all_gpes"); | 371 | ACPI_FUNCTION_TRACE("hw_disable_all_gpes"); |
393 | 372 | ||
394 | 373 | status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block); | |
395 | status = acpi_ev_walk_gpe_list (acpi_hw_disable_gpe_block); | 374 | status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block); |
396 | status = acpi_ev_walk_gpe_list (acpi_hw_clear_gpe_block); | 375 | return_ACPI_STATUS(status); |
397 | return_ACPI_STATUS (status); | ||
398 | } | 376 | } |
399 | 377 | ||
400 | |||
401 | /****************************************************************************** | 378 | /****************************************************************************** |
402 | * | 379 | * |
403 | * FUNCTION: acpi_hw_enable_all_runtime_gpes | 380 | * FUNCTION: acpi_hw_enable_all_runtime_gpes |
@@ -410,21 +387,16 @@ acpi_hw_disable_all_gpes ( | |||
410 | * | 387 | * |
411 | ******************************************************************************/ | 388 | ******************************************************************************/ |
412 | 389 | ||
413 | acpi_status | 390 | acpi_status acpi_hw_enable_all_runtime_gpes(void) |
414 | acpi_hw_enable_all_runtime_gpes ( | ||
415 | void) | ||
416 | { | 391 | { |
417 | acpi_status status; | 392 | acpi_status status; |
418 | |||
419 | 393 | ||
420 | ACPI_FUNCTION_TRACE ("hw_enable_all_runtime_gpes"); | 394 | ACPI_FUNCTION_TRACE("hw_enable_all_runtime_gpes"); |
421 | 395 | ||
422 | 396 | status = acpi_ev_walk_gpe_list(acpi_hw_enable_runtime_gpe_block); | |
423 | status = acpi_ev_walk_gpe_list (acpi_hw_enable_runtime_gpe_block); | 397 | return_ACPI_STATUS(status); |
424 | return_ACPI_STATUS (status); | ||
425 | } | 398 | } |
426 | 399 | ||
427 | |||
428 | /****************************************************************************** | 400 | /****************************************************************************** |
429 | * | 401 | * |
430 | * FUNCTION: acpi_hw_enable_all_wakeup_gpes | 402 | * FUNCTION: acpi_hw_enable_all_wakeup_gpes |
@@ -437,17 +409,12 @@ acpi_hw_enable_all_runtime_gpes ( | |||
437 | * | 409 | * |
438 | ******************************************************************************/ | 410 | ******************************************************************************/ |
439 | 411 | ||
440 | acpi_status | 412 | acpi_status acpi_hw_enable_all_wakeup_gpes(void) |
441 | acpi_hw_enable_all_wakeup_gpes ( | ||
442 | void) | ||
443 | { | 413 | { |
444 | acpi_status status; | 414 | acpi_status status; |
445 | |||
446 | 415 | ||
447 | ACPI_FUNCTION_TRACE ("hw_enable_all_wakeup_gpes"); | 416 | ACPI_FUNCTION_TRACE("hw_enable_all_wakeup_gpes"); |
448 | 417 | ||
449 | 418 | status = acpi_ev_walk_gpe_list(acpi_hw_enable_wakeup_gpe_block); | |
450 | status = acpi_ev_walk_gpe_list (acpi_hw_enable_wakeup_gpe_block); | 419 | return_ACPI_STATUS(status); |
451 | return_ACPI_STATUS (status); | ||
452 | } | 420 | } |
453 | |||