?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
arm/imx/gpio: add spinlock protection
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / acpi / acpica / evgpeblk.c
bloba439850a421c42d2a86b6f058b25f0a6089d70c8
1 /******************************************************************************
2 *
3 * Module Name: evgpeblk - GPE block creation and initialization.
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
50 ACPI_MODULE_NAME("evgpeblk")
51
52 /* Local prototypes */
53 static acpi_status
54 acpi_ev_save_method_info(acpi_handle obj_handle,
55 u32 level, void *obj_desc, void **return_value);
56
57 static acpi_status
58 acpi_ev_match_prw_and_gpe(acpi_handle obj_handle,
59 u32 level, void *info, void **return_value);
60
61 static struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32
62 interrupt_number);
63
64 static acpi_status
65 acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt);
66
67 static acpi_status
68 acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block,
69 u32 interrupt_number);
70
71 static acpi_status
72 acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block);
73
74 /*******************************************************************************
75 *
76 * FUNCTION: acpi_ev_valid_gpe_event
77 *
78 * PARAMETERS: gpe_event_info - Info for this GPE
79 *
80 * RETURN: TRUE if the gpe_event is valid
81 *
82 * DESCRIPTION: Validate a GPE event. DO NOT CALL FROM INTERRUPT LEVEL.
83 * Should be called only when the GPE lists are semaphore locked
84 * and not subject to change.
85 *
86 ******************************************************************************/
87
88 u8 acpi_ev_valid_gpe_event(struct acpi_gpe_event_info *gpe_event_info)
89 {
90 struct acpi_gpe_xrupt_info *gpe_xrupt_block;
91 struct acpi_gpe_block_info *gpe_block;
92
93 ACPI_FUNCTION_ENTRY();
94
95 /* No need for spin lock since we are not changing any list elements */
96
97 /* Walk the GPE interrupt levels */
98
99 gpe_xrupt_block = acpi_gbl_gpe_xrupt_list_head;
100 while (gpe_xrupt_block) {
101 gpe_block = gpe_xrupt_block->gpe_block_list_head;
102
103 /* Walk the GPE blocks on this interrupt level */
104
105 while (gpe_block) {
106 if ((&gpe_block->event_info[0] <= gpe_event_info) &&
107 (&gpe_block->event_info[((acpi_size)
108 gpe_block->
109 register_count) * 8] >
110 gpe_event_info)) {
111 return (TRUE);
112 }
113
114 gpe_block = gpe_block->next;
115 }
116
117 gpe_xrupt_block = gpe_xrupt_block->next;
118 }
119
120 return (FALSE);
121 }
122
123 /*******************************************************************************
124 *
125 * FUNCTION: acpi_ev_walk_gpe_list
126 *
127 * PARAMETERS: gpe_walk_callback - Routine called for each GPE block
128 * Context - Value passed to callback
129 *
130 * RETURN: Status
131 *
132 * DESCRIPTION: Walk the GPE lists.
133 *
134 ******************************************************************************/
135
136 acpi_status
137 acpi_ev_walk_gpe_list(acpi_gpe_callback gpe_walk_callback, void *context)
138 {
139 struct acpi_gpe_block_info *gpe_block;
140 struct acpi_gpe_xrupt_info *gpe_xrupt_info;
141 acpi_status status = AE_OK;
142 acpi_cpu_flags flags;
143
144 ACPI_FUNCTION_TRACE(ev_walk_gpe_list);
145
146 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
147
148 /* Walk the interrupt level descriptor list */
149
150 gpe_xrupt_info = acpi_gbl_gpe_xrupt_list_head;
151 while (gpe_xrupt_info) {
152
153 /* Walk all Gpe Blocks attached to this interrupt level */
154
155 gpe_block = gpe_xrupt_info->gpe_block_list_head;
156 while (gpe_block) {
157
158 /* One callback per GPE block */
159
160 status =
161 gpe_walk_callback(gpe_xrupt_info, gpe_block,
162 context);
163 if (ACPI_FAILURE(status)) {
164 if (status == AE_CTRL_END) { /* Callback abort */
165 status = AE_OK;
166 }
167 goto unlock_and_exit;
168 }
169
170 gpe_block = gpe_block->next;
171 }
172
173 gpe_xrupt_info = gpe_xrupt_info->next;
174 }
175
176 unlock_and_exit:
177 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
178 return_ACPI_STATUS(status);
179 }
180
181 /*******************************************************************************
182 *
183 * FUNCTION: acpi_ev_delete_gpe_handlers
184 *
185 * PARAMETERS: gpe_xrupt_info - GPE Interrupt info
186 * gpe_block - Gpe Block info
187 *
188 * RETURN: Status
189 *
190 * DESCRIPTION: Delete all Handler objects found in the GPE data structs.
191 * Used only prior to termination.
192 *
193 ******************************************************************************/
194
195 acpi_status
196 acpi_ev_delete_gpe_handlers(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
197 struct acpi_gpe_block_info *gpe_block,
198 void *context)
199 {
200 struct acpi_gpe_event_info *gpe_event_info;
201 u32 i;
202 u32 j;
203
204 ACPI_FUNCTION_TRACE(ev_delete_gpe_handlers);
205
206 /* Examine each GPE Register within the block */
207
208 for (i = 0; i < gpe_block->register_count; i++) {
209
210 /* Now look at the individual GPEs in this byte register */
211
212 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
213 gpe_event_info = &gpe_block->event_info[((acpi_size) i *
214 ACPI_GPE_REGISTER_WIDTH)
215 + j];
216
217 if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
218 ACPI_GPE_DISPATCH_HANDLER) {
219 ACPI_FREE(gpe_event_info->dispatch.handler);
220 gpe_event_info->dispatch.handler = NULL;
221 gpe_event_info->flags &=
222 ~ACPI_GPE_DISPATCH_MASK;
223 }
224 }
225 }
226
227 return_ACPI_STATUS(AE_OK);
228 }
229
230 /*******************************************************************************
231 *
232 * FUNCTION: acpi_ev_save_method_info
233 *
234 * PARAMETERS: Callback from walk_namespace
235 *
236 * RETURN: Status
237 *
238 * DESCRIPTION: Called from acpi_walk_namespace. Expects each object to be a
239 * control method under the _GPE portion of the namespace.
240 * Extract the name and GPE type from the object, saving this
241 * information for quick lookup during GPE dispatch
242 *
243 * The name of each GPE control method is of the form:
244 * "_Lxx" or "_Exx"
245 * Where:
246 * L - means that the GPE is level triggered
247 * E - means that the GPE is edge triggered
248 * xx - is the GPE number [in HEX]
249 *
250 ******************************************************************************/
251
252 static acpi_status
253 acpi_ev_save_method_info(acpi_handle obj_handle,
254 u32 level, void *obj_desc, void **return_value)
255 {
256 struct acpi_gpe_block_info *gpe_block = (void *)obj_desc;
257 struct acpi_gpe_event_info *gpe_event_info;
258 u32 gpe_number;
259 char name[ACPI_NAME_SIZE + 1];
260 u8 type;
261
262 ACPI_FUNCTION_TRACE(ev_save_method_info);
263
264 /*
265 * _Lxx and _Exx GPE method support
266 *
267 * 1) Extract the name from the object and convert to a string
268 */
269 ACPI_MOVE_32_TO_32(name,
270 &((struct acpi_namespace_node *)obj_handle)->name.
271 integer);
272 name[ACPI_NAME_SIZE] = 0;
273
274 /*
275 * 2) Edge/Level determination is based on the 2nd character
276 * of the method name
277 *
278 * NOTE: Default GPE type is RUNTIME. May be changed later to WAKE
279 * if a _PRW object is found that points to this GPE.
280 */
281 switch (name[1]) {
282 case 'L':
283 type = ACPI_GPE_LEVEL_TRIGGERED;
284 break;
285
286 case 'E':
287 type = ACPI_GPE_EDGE_TRIGGERED;
288 break;
289
290 default:
291 /* Unknown method type, just ignore it! */
292
293 ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
294 "Ignoring unknown GPE method type: %s "
295 "(name not of form _Lxx or _Exx)", name));
296 return_ACPI_STATUS(AE_OK);
297 }
298
299 /* Convert the last two characters of the name to the GPE Number */
300
301 gpe_number = ACPI_STRTOUL(&name[2], NULL, 16);
302 if (gpe_number == ACPI_UINT32_MAX) {
303
304 /* Conversion failed; invalid method, just ignore it */
305
306 ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
307 "Could not extract GPE number from name: %s "
308 "(name is not of form _Lxx or _Exx)", name));
309 return_ACPI_STATUS(AE_OK);
310 }
311
312 /* Ensure that we have a valid GPE number for this GPE block */
313
314 if ((gpe_number < gpe_block->block_base_number) ||
315 (gpe_number >= (gpe_block->block_base_number +
316 (gpe_block->register_count * 8)))) {
317 /*
318 * Not valid for this GPE block, just ignore it. However, it may be
319 * valid for a different GPE block, since GPE0 and GPE1 methods both
320 * appear under \_GPE.
321 */
322 return_ACPI_STATUS(AE_OK);
323 }
324
325 /*
326 * Now we can add this information to the gpe_event_info block for use
327 * during dispatch of this GPE.
328 */
329 gpe_event_info =
330 &gpe_block->event_info[gpe_number - gpe_block->block_base_number];
331
332 gpe_event_info->flags = (u8) (type | ACPI_GPE_DISPATCH_METHOD);
333
334 gpe_event_info->dispatch.method_node =
335 (struct acpi_namespace_node *)obj_handle;
336
337 ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
338 "Registered GPE method %s as GPE number 0x%.2X\n",
339 name, gpe_number));
340 return_ACPI_STATUS(AE_OK);
341 }
342
343 /*******************************************************************************
344 *
345 * FUNCTION: acpi_ev_match_prw_and_gpe
346 *
347 * PARAMETERS: Callback from walk_namespace
348 *
349 * RETURN: Status. NOTE: We ignore errors so that the _PRW walk is
350 * not aborted on a single _PRW failure.
351 *
352 * DESCRIPTION: Called from acpi_walk_namespace. Expects each object to be a
353 * Device. Run the _PRW method. If present, extract the GPE
354 * number and mark the GPE as a WAKE GPE.
355 *
356 ******************************************************************************/
357
358 static acpi_status
359 acpi_ev_match_prw_and_gpe(acpi_handle obj_handle,
360 u32 level, void *info, void **return_value)
361 {
362 struct acpi_gpe_walk_info *gpe_info = (void *)info;
363 struct acpi_namespace_node *gpe_device;
364 struct acpi_gpe_block_info *gpe_block;
365 struct acpi_namespace_node *target_gpe_device;
366 struct acpi_gpe_event_info *gpe_event_info;
367 union acpi_operand_object *pkg_desc;
368 union acpi_operand_object *obj_desc;
369 u32 gpe_number;
370 acpi_status status;
371
372 ACPI_FUNCTION_TRACE(ev_match_prw_and_gpe);
373
374 /* Check for a _PRW method under this device */
375
376 status = acpi_ut_evaluate_object(obj_handle, METHOD_NAME__PRW,
377 ACPI_BTYPE_PACKAGE, &pkg_desc);
378 if (ACPI_FAILURE(status)) {
379
380 /* Ignore all errors from _PRW, we don't want to abort the subsystem */
381
382 return_ACPI_STATUS(AE_OK);
383 }
384
385 /* The returned _PRW package must have at least two elements */
386
387 if (pkg_desc->package.count < 2) {
388 goto cleanup;
389 }
390
391 /* Extract pointers from the input context */
392
393 gpe_device = gpe_info->gpe_device;
394 gpe_block = gpe_info->gpe_block;
395
396 /*
397 * The _PRW object must return a package, we are only interested in the
398 * first element
399 */
400 obj_desc = pkg_desc->package.elements[0];
401
402 if (obj_desc->common.type == ACPI_TYPE_INTEGER) {
403
404 /* Use FADT-defined GPE device (from definition of _PRW) */
405
406 target_gpe_device = acpi_gbl_fadt_gpe_device;
407
408 /* Integer is the GPE number in the FADT described GPE blocks */
409
410 gpe_number = (u32) obj_desc->integer.value;
411 } else if (obj_desc->common.type == ACPI_TYPE_PACKAGE) {
412
413 /* Package contains a GPE reference and GPE number within a GPE block */
414
415 if ((obj_desc->package.count < 2) ||
416 ((obj_desc->package.elements[0])->common.type !=
417 ACPI_TYPE_LOCAL_REFERENCE) ||
418 ((obj_desc->package.elements[1])->common.type !=
419 ACPI_TYPE_INTEGER)) {
420 goto cleanup;
421 }
422
423 /* Get GPE block reference and decode */
424
425 target_gpe_device =
426 obj_desc->package.elements[0]->reference.node;
427 gpe_number = (u32) obj_desc->package.elements[1]->integer.value;
428 } else {
429 /* Unknown type, just ignore it */
430
431 goto cleanup;
432 }
433
434 /*
435 * Is this GPE within this block?
436 *
437 * TRUE if and only if these conditions are true:
438 * 1) The GPE devices match.
439 * 2) The GPE index(number) is within the range of the Gpe Block
440 * associated with the GPE device.
441 */
442 if ((gpe_device == target_gpe_device) &&
443 (gpe_number >= gpe_block->block_base_number) &&
444 (gpe_number < gpe_block->block_base_number +
445 (gpe_block->register_count * 8))) {
446 gpe_event_info = &gpe_block->event_info[gpe_number -
447 gpe_block->
448 block_base_number];
449
450 gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
451 }
452
453 cleanup:
454 acpi_ut_remove_reference(pkg_desc);
455 return_ACPI_STATUS(AE_OK);
456 }
457
458 /*******************************************************************************
459 *
460 * FUNCTION: acpi_ev_get_gpe_xrupt_block
461 *
462 * PARAMETERS: interrupt_number - Interrupt for a GPE block
463 *
464 * RETURN: A GPE interrupt block
465 *
466 * DESCRIPTION: Get or Create a GPE interrupt block. There is one interrupt
467 * block per unique interrupt level used for GPEs. Should be
468 * called only when the GPE lists are semaphore locked and not
469 * subject to change.
470 *
471 ******************************************************************************/
472
473 static struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32
474 interrupt_number)
475 {
476 struct acpi_gpe_xrupt_info *next_gpe_xrupt;
477 struct acpi_gpe_xrupt_info *gpe_xrupt;
478 acpi_status status;
479 acpi_cpu_flags flags;
480
481 ACPI_FUNCTION_TRACE(ev_get_gpe_xrupt_block);
482
483 /* No need for lock since we are not changing any list elements here */
484
485 next_gpe_xrupt = acpi_gbl_gpe_xrupt_list_head;
486 while (next_gpe_xrupt) {
487 if (next_gpe_xrupt->interrupt_number == interrupt_number) {
488 return_PTR(next_gpe_xrupt);
489 }
490
491 next_gpe_xrupt = next_gpe_xrupt->next;
492 }
493
494 /* Not found, must allocate a new xrupt descriptor */
495
496 gpe_xrupt = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_xrupt_info));
497 if (!gpe_xrupt) {
498 return_PTR(NULL);
499 }
500
501 gpe_xrupt->interrupt_number = interrupt_number;
502
503 /* Install new interrupt descriptor with spin lock */
504
505 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
506 if (acpi_gbl_gpe_xrupt_list_head) {
507 next_gpe_xrupt = acpi_gbl_gpe_xrupt_list_head;
508 while (next_gpe_xrupt->next) {
509 next_gpe_xrupt = next_gpe_xrupt->next;
510 }
511
512 next_gpe_xrupt->next = gpe_xrupt;
513 gpe_xrupt->previous = next_gpe_xrupt;
514 } else {
515 acpi_gbl_gpe_xrupt_list_head = gpe_xrupt;
516 }
517 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
518
519 /* Install new interrupt handler if not SCI_INT */
520
521 if (interrupt_number != acpi_gbl_FADT.sci_interrupt) {
522 status = acpi_os_install_interrupt_handler(interrupt_number,
523 acpi_ev_gpe_xrupt_handler,
524 gpe_xrupt);
525 if (ACPI_FAILURE(status)) {
526 ACPI_ERROR((AE_INFO,
527 "Could not install GPE interrupt handler at level 0x%X",
528 interrupt_number));
529 return_PTR(NULL);
530 }
531 }
532
533 return_PTR(gpe_xrupt);
534 }
535
536 /*******************************************************************************
537 *
538 * FUNCTION: acpi_ev_delete_gpe_xrupt
539 *
540 * PARAMETERS: gpe_xrupt - A GPE interrupt info block
541 *
542 * RETURN: Status
543 *
544 * DESCRIPTION: Remove and free a gpe_xrupt block. Remove an associated
545 * interrupt handler if not the SCI interrupt.
546 *
547 ******************************************************************************/
548
549 static acpi_status
550 acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt)
551 {
552 acpi_status status;
553 acpi_cpu_flags flags;
554
555 ACPI_FUNCTION_TRACE(ev_delete_gpe_xrupt);
556
557 /* We never want to remove the SCI interrupt handler */
558
559 if (gpe_xrupt->interrupt_number == acpi_gbl_FADT.sci_interrupt) {
560 gpe_xrupt->gpe_block_list_head = NULL;
561 return_ACPI_STATUS(AE_OK);
562 }
563
564 /* Disable this interrupt */
565
566 status =
567 acpi_os_remove_interrupt_handler(gpe_xrupt->interrupt_number,
568 acpi_ev_gpe_xrupt_handler);
569 if (ACPI_FAILURE(status)) {
570 return_ACPI_STATUS(status);
571 }
572
573 /* Unlink the interrupt block with lock */
574
575 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
576 if (gpe_xrupt->previous) {
577 gpe_xrupt->previous->next = gpe_xrupt->next;
578 } else {
579 /* No previous, update list head */
580
581 acpi_gbl_gpe_xrupt_list_head = gpe_xrupt->next;
582 }
583
584 if (gpe_xrupt->next) {
585 gpe_xrupt->next->previous = gpe_xrupt->previous;
586 }
587 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
588
589 /* Free the block */
590
591 ACPI_FREE(gpe_xrupt);
592 return_ACPI_STATUS(AE_OK);
593 }
594
595 /*******************************************************************************
596 *
597 * FUNCTION: acpi_ev_install_gpe_block
598 *
599 * PARAMETERS: gpe_block - New GPE block
600 * interrupt_number - Xrupt to be associated with this
601 * GPE block
602 *
603 * RETURN: Status
604 *
605 * DESCRIPTION: Install new GPE block with mutex support
606 *
607 ******************************************************************************/
608
609 static acpi_status
610 acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block,
611 u32 interrupt_number)
612 {
613 struct acpi_gpe_block_info *next_gpe_block;
614 struct acpi_gpe_xrupt_info *gpe_xrupt_block;
615 acpi_status status;
616 acpi_cpu_flags flags;
617
618 ACPI_FUNCTION_TRACE(ev_install_gpe_block);
619
620 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
621 if (ACPI_FAILURE(status)) {
622 return_ACPI_STATUS(status);
623 }
624
625 gpe_xrupt_block = acpi_ev_get_gpe_xrupt_block(interrupt_number);
626 if (!gpe_xrupt_block) {
627 status = AE_NO_MEMORY;
628 goto unlock_and_exit;
629 }
630
631 /* Install the new block at the end of the list with lock */
632
633 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
634 if (gpe_xrupt_block->gpe_block_list_head) {
635 next_gpe_block = gpe_xrupt_block->gpe_block_list_head;
636 while (next_gpe_block->next) {
637 next_gpe_block = next_gpe_block->next;
638 }
639
640 next_gpe_block->next = gpe_block;
641 gpe_block->previous = next_gpe_block;
642 } else {
643 gpe_xrupt_block->gpe_block_list_head = gpe_block;
644 }
645
646 gpe_block->xrupt_block = gpe_xrupt_block;
647 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
648
649 unlock_and_exit:
650 status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
651 return_ACPI_STATUS(status);
652 }
653
654 /*******************************************************************************
655 *
656 * FUNCTION: acpi_ev_delete_gpe_block
657 *
658 * PARAMETERS: gpe_block - Existing GPE block
659 *
660 * RETURN: Status
661 *
662 * DESCRIPTION: Remove a GPE block
663 *
664 ******************************************************************************/
665
666 acpi_status acpi_ev_delete_gpe_block(struct acpi_gpe_block_info *gpe_block)
667 {
668 acpi_status status;
669 acpi_cpu_flags flags;
670
671 ACPI_FUNCTION_TRACE(ev_install_gpe_block);
672
673 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
674 if (ACPI_FAILURE(status)) {
675 return_ACPI_STATUS(status);
676 }
677
678 /* Disable all GPEs in this block */
679
680 status =
681 acpi_hw_disable_gpe_block(gpe_block->xrupt_block, gpe_block, NULL);
682
683 if (!gpe_block->previous && !gpe_block->next) {
684
685 /* This is the last gpe_block on this interrupt */
686
687 status = acpi_ev_delete_gpe_xrupt(gpe_block->xrupt_block);
688 if (ACPI_FAILURE(status)) {
689 goto unlock_and_exit;
690 }
691 } else {
692 /* Remove the block on this interrupt with lock */
693
694 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
695 if (gpe_block->previous) {
696 gpe_block->previous->next = gpe_block->next;
697 } else {
698 gpe_block->xrupt_block->gpe_block_list_head =
699 gpe_block->next;
700 }
701
702 if (gpe_block->next) {
703 gpe_block->next->previous = gpe_block->previous;
704 }
705 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
706 }
707
708 acpi_current_gpe_count -=
709 gpe_block->register_count * ACPI_GPE_REGISTER_WIDTH;
710
711 /* Free the gpe_block */
712
713 ACPI_FREE(gpe_block->register_info);
714 ACPI_FREE(gpe_block->event_info);
715 ACPI_FREE(gpe_block);
716
717 unlock_and_exit:
718 status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
719 return_ACPI_STATUS(status);
720 }
721
722 /*******************************************************************************
723 *
724 * FUNCTION: acpi_ev_create_gpe_info_blocks
725 *
726 * PARAMETERS: gpe_block - New GPE block
727 *
728 * RETURN: Status
729 *
730 * DESCRIPTION: Create the register_info and event_info blocks for this GPE block
731 *
732 ******************************************************************************/
733
734 static acpi_status
735 acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block)
736 {
737 struct acpi_gpe_register_info *gpe_register_info = NULL;
738 struct acpi_gpe_event_info *gpe_event_info = NULL;
739 struct acpi_gpe_event_info *this_event;
740 struct acpi_gpe_register_info *this_register;
741 u32 i;
742 u32 j;
743 acpi_status status;
744
745 ACPI_FUNCTION_TRACE(ev_create_gpe_info_blocks);
746
747 /* Allocate the GPE register information block */
748
749 gpe_register_info = ACPI_ALLOCATE_ZEROED((acpi_size) gpe_block->
750 register_count *
751 sizeof(struct
752 acpi_gpe_register_info));
753 if (!gpe_register_info) {
754 ACPI_ERROR((AE_INFO,
755 "Could not allocate the GpeRegisterInfo table"));
756 return_ACPI_STATUS(AE_NO_MEMORY);
757 }
758
759 /*
760 * Allocate the GPE event_info block. There are eight distinct GPEs
761 * per register. Initialization to zeros is sufficient.
762 */
763 gpe_event_info = ACPI_ALLOCATE_ZEROED(((acpi_size) gpe_block->
764 register_count *
765 ACPI_GPE_REGISTER_WIDTH) *
766 sizeof(struct
767 acpi_gpe_event_info));
768 if (!gpe_event_info) {
769 ACPI_ERROR((AE_INFO,
770 "Could not allocate the GpeEventInfo table"));
771 status = AE_NO_MEMORY;
772 goto error_exit;
773 }
774
775 /* Save the new Info arrays in the GPE block */
776
777 gpe_block->register_info = gpe_register_info;
778 gpe_block->event_info = gpe_event_info;
779
780 /*
781 * Initialize the GPE Register and Event structures. A goal of these
782 * tables is to hide the fact that there are two separate GPE register
783 * sets in a given GPE hardware block, the status registers occupy the
784 * first half, and the enable registers occupy the second half.
785 */
786 this_register = gpe_register_info;
787 this_event = gpe_event_info;
788
789 for (i = 0; i < gpe_block->register_count; i++) {
790
791 /* Init the register_info for this GPE register (8 GPEs) */
792
793 this_register->base_gpe_number =
794 (u8) (gpe_block->block_base_number +
795 (i * ACPI_GPE_REGISTER_WIDTH));
796
797 this_register->status_address.address =
798 gpe_block->block_address.address + i;
799
800 this_register->enable_address.address =
801 gpe_block->block_address.address + i +
802 gpe_block->register_count;
803
804 this_register->status_address.space_id =
805 gpe_block->block_address.space_id;
806 this_register->enable_address.space_id =
807 gpe_block->block_address.space_id;
808 this_register->status_address.bit_width =
809 ACPI_GPE_REGISTER_WIDTH;
810 this_register->enable_address.bit_width =
811 ACPI_GPE_REGISTER_WIDTH;
812 this_register->status_address.bit_offset = 0;
813 this_register->enable_address.bit_offset = 0;
814
815 /* Init the event_info for each GPE within this register */
816
817 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
818 this_event->gpe_number =
819 (u8) (this_register->base_gpe_number + j);
820 this_event->register_info = this_register;
821 this_event++;
822 }
823
824 /* Disable all GPEs within this register */
825
826 status = acpi_hw_write(0x00, &this_register->enable_address);
827 if (ACPI_FAILURE(status)) {
828 goto error_exit;
829 }
830
831 /* Clear any pending GPE events within this register */
832
833 status = acpi_hw_write(0xFF, &this_register->status_address);
834 if (ACPI_FAILURE(status)) {
835 goto error_exit;
836 }
837
838 this_register++;
839 }
840
841 return_ACPI_STATUS(AE_OK);
842
843 error_exit:
844 if (gpe_register_info) {
845 ACPI_FREE(gpe_register_info);
846 }
847 if (gpe_event_info) {
848 ACPI_FREE(gpe_event_info);
849 }
850
851 return_ACPI_STATUS(status);
852 }
853
854 /*******************************************************************************
855 *
856 * FUNCTION: acpi_ev_create_gpe_block
857 *
858 * PARAMETERS: gpe_device - Handle to the parent GPE block
859 * gpe_block_address - Address and space_iD
860 * register_count - Number of GPE register pairs in the block
861 * gpe_block_base_number - Starting GPE number for the block
862 * interrupt_number - H/W interrupt for the block
863 * return_gpe_block - Where the new block descriptor is returned
864 *
865 * RETURN: Status
866 *
867 * DESCRIPTION: Create and Install a block of GPE registers. All GPEs within
868 * the block are disabled at exit.
869 * Note: Assumes namespace is locked.
870 *
871 ******************************************************************************/
872
873 acpi_status
874 acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
875 struct acpi_generic_address *gpe_block_address,
876 u32 register_count,
877 u8 gpe_block_base_number,
878 u32 interrupt_number,
879 struct acpi_gpe_block_info **return_gpe_block)
880 {
881 acpi_status status;
882 struct acpi_gpe_block_info *gpe_block;
883
884 ACPI_FUNCTION_TRACE(ev_create_gpe_block);
885
886 if (!register_count) {
887 return_ACPI_STATUS(AE_OK);
888 }
889
890 /* Allocate a new GPE block */
891
892 gpe_block = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_block_info));
893 if (!gpe_block) {
894 return_ACPI_STATUS(AE_NO_MEMORY);
895 }
896
897 /* Initialize the new GPE block */
898
899 gpe_block->node = gpe_device;
900 gpe_block->register_count = register_count;
901 gpe_block->block_base_number = gpe_block_base_number;
902
903 ACPI_MEMCPY(&gpe_block->block_address, gpe_block_address,
904 sizeof(struct acpi_generic_address));
905
906 /*
907 * Create the register_info and event_info sub-structures
908 * Note: disables and clears all GPEs in the block
909 */
910 status = acpi_ev_create_gpe_info_blocks(gpe_block);
911 if (ACPI_FAILURE(status)) {
912 ACPI_FREE(gpe_block);
913 return_ACPI_STATUS(status);
914 }
915
916 /* Install the new block in the global lists */
917
918 status = acpi_ev_install_gpe_block(gpe_block, interrupt_number);
919 if (ACPI_FAILURE(status)) {
920 ACPI_FREE(gpe_block);
921 return_ACPI_STATUS(status);
922 }
923
924 /* Find all GPE methods (_Lxx, _Exx) for this block */
925
926 status = acpi_ns_walk_namespace(ACPI_TYPE_METHOD, gpe_device,
927 ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK,
928 acpi_ev_save_method_info, NULL,
929 gpe_block, NULL);
930
931 /* Return the new block */
932
933 if (return_gpe_block) {
934 (*return_gpe_block) = gpe_block;
935 }
936
937 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
938 "GPE %02X to %02X [%4.4s] %u regs on int 0x%X\n",
939 (u32) gpe_block->block_base_number,
940 (u32) (gpe_block->block_base_number +
941 ((gpe_block->register_count *
942 ACPI_GPE_REGISTER_WIDTH) - 1)),
943 gpe_device->name.ascii, gpe_block->register_count,
944 interrupt_number));
945
946 /* Update global count of currently available GPEs */
947
948 acpi_current_gpe_count += register_count * ACPI_GPE_REGISTER_WIDTH;
949 return_ACPI_STATUS(AE_OK);
950 }
951
952 /*******************************************************************************
953 *
954 * FUNCTION: acpi_ev_initialize_gpe_block
955 *
956 * PARAMETERS: gpe_device - Handle to the parent GPE block
957 * gpe_block - Gpe Block info
958 *
959 * RETURN: Status
960 *
961 * DESCRIPTION: Initialize and enable a GPE block. First find and run any
962 * _PRT methods associated with the block, then enable the
963 * appropriate GPEs.
964 * Note: Assumes namespace is locked.
965 *
966 ******************************************************************************/
967
968 acpi_status
969 acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,
970 struct acpi_gpe_block_info *gpe_block)
971 {
972 struct acpi_gpe_event_info *gpe_event_info;
973 struct acpi_gpe_walk_info gpe_info;
974 u32 wake_gpe_count;
975 u32 gpe_enabled_count;
976 u32 i;
977 u32 j;
978
979 ACPI_FUNCTION_TRACE(ev_initialize_gpe_block);
980
981 /* Ignore a null GPE block (e.g., if no GPE block 1 exists) */
982
983 if (!gpe_block) {
984 return_ACPI_STATUS(AE_OK);
985 }
986
987 /*
988 * Runtime option: Should wake GPEs be enabled at runtime? The default
989 * is no, they should only be enabled just as the machine goes to sleep.
990 */
991 if (acpi_gbl_leave_wake_gpes_disabled) {
992 /*
993 * Differentiate runtime vs wake GPEs, via the _PRW control methods.
994 * Each GPE that has one or more _PRWs that reference it is by
995 * definition a wake GPE and will not be enabled while the machine
996 * is running.
997 */
998 gpe_info.gpe_block = gpe_block;
999 gpe_info.gpe_device = gpe_device;
1000
1001 acpi_ns_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
1002 ACPI_UINT32_MAX, ACPI_NS_WALK_UNLOCK,
1003 acpi_ev_match_prw_and_gpe, NULL,
1004 &gpe_info, NULL);
1005 }
1006
1007 /*
1008 * Enable all GPEs that have a corresponding method and aren't
1009 * capable of generating wakeups. Any other GPEs within this block
1010 * must be enabled via the acpi_enable_gpe() interface.
1011 */
1012 wake_gpe_count = 0;
1013 gpe_enabled_count = 0;
1014 if (gpe_device == acpi_gbl_fadt_gpe_device)
1015 gpe_device = NULL;
1016
1017 for (i = 0; i < gpe_block->register_count; i++) {
1018 for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
1019 acpi_status status;
1020 acpi_size gpe_index;
1021 int gpe_number;
1022
1023 /* Get the info block for this particular GPE */
1024 gpe_index = (acpi_size)i * ACPI_GPE_REGISTER_WIDTH + j;
1025 gpe_event_info = &gpe_block->event_info[gpe_index];
1026 gpe_number = gpe_index + gpe_block->block_base_number;
1027
1028 /*
1029 * If the GPE has already been enabled for runtime
1030 * signaling, make sure it remains enabled, but do not
1031 * increment its reference counter.
1032 */
1033 if (gpe_event_info->runtime_count) {
1034 acpi_set_gpe(gpe_device, gpe_number,
1035 ACPI_GPE_ENABLE);
1036 gpe_enabled_count++;
1037 continue;
1038 }
1039
1040 if (gpe_event_info->flags & ACPI_GPE_CAN_WAKE) {
1041 wake_gpe_count++;
1042 if (acpi_gbl_leave_wake_gpes_disabled)
1043 continue;
1044 }
1045
1046 if (!(gpe_event_info->flags & ACPI_GPE_DISPATCH_METHOD))
1047 continue;
1048
1049 status = acpi_enable_gpe(gpe_device, gpe_number,
1050 ACPI_GPE_TYPE_RUNTIME);
1051 if (ACPI_FAILURE(status))
1052 ACPI_ERROR((AE_INFO,
1053 "Failed to enable GPE %02X\n",
1054 gpe_number));
1055 else
1056 gpe_enabled_count++;
1057 }
1058 }
1059
1060 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
1061 "Found %u Wake, Enabled %u Runtime GPEs in this block\n",
1062 wake_gpe_count, gpe_enabled_count));
1063
1064 return_ACPI_STATUS(AE_OK);
1065 }
1066
1067 /*******************************************************************************
1068 *
1069 * FUNCTION: acpi_ev_gpe_initialize
1070 *
1071 * PARAMETERS: None
1072 *
1073 * RETURN: Status
1074 *
1075 * DESCRIPTION: Initialize the GPE data structures
1076 *
1077 ******************************************************************************/
1078
1079 acpi_status acpi_ev_gpe_initialize(void)
1080 {
1081 u32 register_count0 = 0;
1082 u32 register_count1 = 0;
1083 u32 gpe_number_max = 0;
1084 acpi_status status;
1085
1086 ACPI_FUNCTION_TRACE(ev_gpe_initialize);
1087
1088 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
1089 if (ACPI_FAILURE(status)) {
1090 return_ACPI_STATUS(status);
1091 }
1092
1093 /*
1094 * Initialize the GPE Block(s) defined in the FADT
1095 *
1096 * Why the GPE register block lengths are divided by 2: From the ACPI
1097 * Spec, section "General-Purpose Event Registers", we have:
1098 *
1099 * "Each register block contains two registers of equal length
1100 * GPEx_STS and GPEx_EN (where x is 0 or 1). The length of the
1101 * GPE0_STS and GPE0_EN registers is equal to half the GPE0_LEN
1102 * The length of the GPE1_STS and GPE1_EN registers is equal to
1103 * half the GPE1_LEN. If a generic register block is not supported
1104 * then its respective block pointer and block length values in the
1105 * FADT table contain zeros. The GPE0_LEN and GPE1_LEN do not need
1106 * to be the same size."
1107 */
1108
1109 /*
1110 * Determine the maximum GPE number for this machine.
1111 *
1112 * Note: both GPE0 and GPE1 are optional, and either can exist without
1113 * the other.
1114 *
1115 * If EITHER the register length OR the block address are zero, then that
1116 * particular block is not supported.
1117 */
1118 if (acpi_gbl_FADT.gpe0_block_length &&
1119 acpi_gbl_FADT.xgpe0_block.address) {
1120
1121 /* GPE block 0 exists (has both length and address > 0) */
1122
1123 register_count0 = (u16) (acpi_gbl_FADT.gpe0_block_length / 2);
1124
1125 gpe_number_max =
1126 (register_count0 * ACPI_GPE_REGISTER_WIDTH) - 1;
1127
1128 /* Install GPE Block 0 */
1129
1130 status = acpi_ev_create_gpe_block(acpi_gbl_fadt_gpe_device,
1131 &acpi_gbl_FADT.xgpe0_block,
1132 register_count0, 0,
1133 acpi_gbl_FADT.sci_interrupt,
1134 &acpi_gbl_gpe_fadt_blocks[0]);
1135
1136 if (ACPI_FAILURE(status)) {
1137 ACPI_EXCEPTION((AE_INFO, status,
1138 "Could not create GPE Block 0"));
1139 }
1140 }
1141
1142 if (acpi_gbl_FADT.gpe1_block_length &&
1143 acpi_gbl_FADT.xgpe1_block.address) {
1144
1145 /* GPE block 1 exists (has both length and address > 0) */
1146
1147 register_count1 = (u16) (acpi_gbl_FADT.gpe1_block_length / 2);
1148
1149 /* Check for GPE0/GPE1 overlap (if both banks exist) */
1150
1151 if ((register_count0) &&
1152 (gpe_number_max >= acpi_gbl_FADT.gpe1_base)) {
1153 ACPI_ERROR((AE_INFO,
1154 "GPE0 block (GPE 0 to %d) overlaps the GPE1 block "
1155 "(GPE %d to %d) - Ignoring GPE1",
1156 gpe_number_max, acpi_gbl_FADT.gpe1_base,
1157 acpi_gbl_FADT.gpe1_base +
1158 ((register_count1 *
1159 ACPI_GPE_REGISTER_WIDTH) - 1)));
1160
1161 /* Ignore GPE1 block by setting the register count to zero */
1162
1163 register_count1 = 0;
1164 } else {
1165 /* Install GPE Block 1 */
1166
1167 status =
1168 acpi_ev_create_gpe_block(acpi_gbl_fadt_gpe_device,
1169 &acpi_gbl_FADT.xgpe1_block,
1170 register_count1,
1171 acpi_gbl_FADT.gpe1_base,
1172 acpi_gbl_FADT.
1173 sci_interrupt,
1174 &acpi_gbl_gpe_fadt_blocks
1175 [1]);
1176
1177 if (ACPI_FAILURE(status)) {
1178 ACPI_EXCEPTION((AE_INFO, status,
1179 "Could not create GPE Block 1"));
1180 }
1181
1182 /*
1183 * GPE0 and GPE1 do not have to be contiguous in the GPE number
1184 * space. However, GPE0 always starts at GPE number zero.
1185 */
1186 gpe_number_max = acpi_gbl_FADT.gpe1_base +
1187 ((register_count1 * ACPI_GPE_REGISTER_WIDTH) - 1);
1188 }
1189 }
1190
1191 /* Exit if there are no GPE registers */
1192
1193 if ((register_count0 + register_count1) == 0) {
1194
1195 /* GPEs are not required by ACPI, this is OK */
1196
1197 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
1198 "There are no GPE blocks defined in the FADT\n"));
1199 status = AE_OK;
1200 goto cleanup;
1201 }
1202
1203 /* Check for Max GPE number out-of-range */
1204
1205 if (gpe_number_max > ACPI_GPE_MAX) {
1206 ACPI_ERROR((AE_INFO,
1207 "Maximum GPE number from FADT is too large: 0x%X",
1208 gpe_number_max));
1209 status = AE_BAD_VALUE;
1210 goto cleanup;
1211 }
1212
1213 cleanup:
1214 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
1215 return_ACPI_STATUS(AE_OK);
1216 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree