1 /******************************************************************************
3 * Module Name: evgpeblk - GPE block creation and initialization.
6 *****************************************************************************/
8 /******************************************************************************
12 * Some or all of this work - Copyright (c) 1999 - 2006, Intel Corp.
13 * All rights reserved.
17 * 2.1. This is your license from Intel Corp. under its intellectual property
18 * rights. You may have additional license terms from the party that provided
19 * you this software, covering your right to use that party's intellectual
22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23 * copy of the source code appearing in this file ("Covered Code") an
24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25 * base code distributed originally by Intel ("Original Intel Code") to copy,
26 * make derivatives, distribute, use and display any portion of the Covered
27 * Code in any form, with the right to sublicense such rights; and
29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30 * license (with the right to sublicense), under only those claims of Intel
31 * patents that are infringed by the Original Intel Code, to make, use, sell,
32 * offer to sell, and import the Covered Code and derivative works thereof
33 * solely to the minimum extent necessary to exercise the above copyright
34 * license, and in no event shall the patent license extend to any additions
35 * to or modifications of the Original Intel Code. No other license or right
36 * is granted directly or by implication, estoppel or otherwise;
38 * The above copyright and patent license is granted only if the following
43 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
44 * Redistribution of source code of any substantial portion of the Covered
45 * Code or modification with rights to further distribute source must include
46 * the above Copyright Notice, the above License, this list of Conditions,
47 * and the following Disclaimer and Export Compliance provision. In addition,
48 * Licensee must cause all Covered Code to which Licensee contributes to
49 * contain a file documenting the changes Licensee made to create that Covered
50 * Code and the date of any change. Licensee must include in that file the
51 * documentation of any changes made by any predecessor Licensee. Licensee
52 * must include a prominent statement that the modification is derived,
53 * directly or indirectly, from Original Intel Code.
55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56 * Redistribution of source code of any substantial portion of the Covered
57 * Code or modification without rights to further distribute source must
58 * include the following Disclaimer and Export Compliance provision in the
59 * documentation and/or other materials provided with distribution. In
60 * addition, Licensee may not authorize further sublicense of source of any
61 * portion of the Covered Code, and must include terms to the effect that the
62 * license from Licensee to its licensee is limited to the intellectual
63 * property embodied in the software Licensee provides to its licensee, and
64 * not to intellectual property embodied in modifications its licensee may
67 * 3.3. Redistribution of Executable. Redistribution in executable form of any
68 * substantial portion of the Covered Code or modification must reproduce the
69 * above Copyright Notice, and the following Disclaimer and Export Compliance
70 * provision in the documentation and/or other materials provided with the
73 * 3.4. Intel retains all right, title, and interest in and to the Original
76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
77 * Intel shall be used in advertising or otherwise to promote the sale, use or
78 * other dealings in products derived from or relating to the Covered Code
79 * without prior written authorization from Intel.
81 * 4. Disclaimer and Export Compliance
83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
100 * 4.3. Licensee shall not export, either directly or indirectly, any of this
101 * software or system incorporating such software without first obtaining any
102 * required license or other approval from the U. S. Department of Commerce or
103 * any other agency or department of the United States Government. In the
104 * event Licensee exports any such software from the United States or
105 * re-exports any such software from a foreign destination, Licensee shall
106 * ensure that the distribution and export/re-export of the software is in
107 * compliance with all laws, regulations, orders, or other restrictions of the
108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109 * any of its subsidiaries will export/re-export any technical data, process,
110 * software, or service, directly or indirectly, to any country for which the
111 * United States government or any agency thereof requires an export license,
112 * other governmental approval, or letter of assurance, without first obtaining
113 * such license, approval or letter.
115 *****************************************************************************/
118 #include "acevents.h"
119 #include "acnamesp.h"
121 #define _COMPONENT ACPI_EVENTS
122 ACPI_MODULE_NAME ("evgpeblk")
124 /* Local prototypes */
127 AcpiEvSaveMethodInfo (
128 ACPI_HANDLE ObjHandle
,
134 AcpiEvMatchPrwAndGpe (
135 ACPI_HANDLE ObjHandle
,
140 static ACPI_GPE_XRUPT_INFO
*
141 AcpiEvGetGpeXruptBlock (
142 UINT32 InterruptNumber
);
145 AcpiEvDeleteGpeXrupt (
146 ACPI_GPE_XRUPT_INFO
*GpeXrupt
);
149 AcpiEvInstallGpeBlock (
150 ACPI_GPE_BLOCK_INFO
*GpeBlock
,
151 UINT32 InterruptNumber
);
154 AcpiEvCreateGpeInfoBlocks (
155 ACPI_GPE_BLOCK_INFO
*GpeBlock
);
158 /*******************************************************************************
160 * FUNCTION: AcpiEvValidGpeEvent
162 * PARAMETERS: GpeEventInfo - Info for this GPE
164 * RETURN: TRUE if the GpeEvent is valid
166 * DESCRIPTION: Validate a GPE event. DO NOT CALL FROM INTERRUPT LEVEL.
167 * Should be called only when the GPE lists are semaphore locked
168 * and not subject to change.
170 ******************************************************************************/
173 AcpiEvValidGpeEvent (
174 ACPI_GPE_EVENT_INFO
*GpeEventInfo
)
176 ACPI_GPE_XRUPT_INFO
*GpeXruptBlock
;
177 ACPI_GPE_BLOCK_INFO
*GpeBlock
;
180 ACPI_FUNCTION_ENTRY ();
183 /* No need for spin lock since we are not changing any list elements */
185 /* Walk the GPE interrupt levels */
187 GpeXruptBlock
= AcpiGbl_GpeXruptListHead
;
188 while (GpeXruptBlock
)
190 GpeBlock
= GpeXruptBlock
->GpeBlockListHead
;
192 /* Walk the GPE blocks on this interrupt level */
196 if ((&GpeBlock
->EventInfo
[0] <= GpeEventInfo
) &&
197 (&GpeBlock
->EventInfo
[((ACPI_SIZE
) GpeBlock
->RegisterCount
) * 8] > GpeEventInfo
))
202 GpeBlock
= GpeBlock
->Next
;
205 GpeXruptBlock
= GpeXruptBlock
->Next
;
212 /*******************************************************************************
214 * FUNCTION: AcpiEvWalkGpeList
216 * PARAMETERS: GpeWalkCallback - Routine called for each GPE block
220 * DESCRIPTION: Walk the GPE lists.
222 ******************************************************************************/
226 ACPI_GPE_CALLBACK GpeWalkCallback
)
228 ACPI_GPE_BLOCK_INFO
*GpeBlock
;
229 ACPI_GPE_XRUPT_INFO
*GpeXruptInfo
;
230 ACPI_STATUS Status
= AE_OK
;
231 ACPI_CPU_FLAGS Flags
;
234 ACPI_FUNCTION_TRACE (EvWalkGpeList
);
237 Flags
= AcpiOsAcquireLock (AcpiGbl_GpeLock
);
239 /* Walk the interrupt level descriptor list */
241 GpeXruptInfo
= AcpiGbl_GpeXruptListHead
;
244 /* Walk all Gpe Blocks attached to this interrupt level */
246 GpeBlock
= GpeXruptInfo
->GpeBlockListHead
;
249 /* One callback per GPE block */
251 Status
= GpeWalkCallback (GpeXruptInfo
, GpeBlock
);
252 if (ACPI_FAILURE (Status
))
257 GpeBlock
= GpeBlock
->Next
;
260 GpeXruptInfo
= GpeXruptInfo
->Next
;
264 AcpiOsReleaseLock (AcpiGbl_GpeLock
, Flags
);
265 return_ACPI_STATUS (Status
);
269 /*******************************************************************************
271 * FUNCTION: AcpiEvDeleteGpeHandlers
273 * PARAMETERS: GpeXruptInfo - GPE Interrupt info
274 * GpeBlock - Gpe Block info
278 * DESCRIPTION: Delete all Handler objects found in the GPE data structs.
279 * Used only prior to termination.
281 ******************************************************************************/
284 AcpiEvDeleteGpeHandlers (
285 ACPI_GPE_XRUPT_INFO
*GpeXruptInfo
,
286 ACPI_GPE_BLOCK_INFO
*GpeBlock
)
288 ACPI_GPE_EVENT_INFO
*GpeEventInfo
;
293 ACPI_FUNCTION_TRACE (EvDeleteGpeHandlers
);
296 /* Examine each GPE Register within the block */
298 for (i
= 0; i
< GpeBlock
->RegisterCount
; i
++)
300 /* Now look at the individual GPEs in this byte register */
302 for (j
= 0; j
< ACPI_GPE_REGISTER_WIDTH
; j
++)
304 GpeEventInfo
= &GpeBlock
->EventInfo
[(i
* ACPI_GPE_REGISTER_WIDTH
) + j
];
306 if ((GpeEventInfo
->Flags
& ACPI_GPE_DISPATCH_MASK
) ==
307 ACPI_GPE_DISPATCH_HANDLER
)
309 ACPI_FREE (GpeEventInfo
->Dispatch
.Handler
);
310 GpeEventInfo
->Dispatch
.Handler
= NULL
;
311 GpeEventInfo
->Flags
&= ~ACPI_GPE_DISPATCH_MASK
;
316 return_ACPI_STATUS (AE_OK
);
320 /*******************************************************************************
322 * FUNCTION: AcpiEvSaveMethodInfo
324 * PARAMETERS: Callback from WalkNamespace
328 * DESCRIPTION: Called from AcpiWalkNamespace. Expects each object to be a
329 * control method under the _GPE portion of the namespace.
330 * Extract the name and GPE type from the object, saving this
331 * information for quick lookup during GPE dispatch
333 * The name of each GPE control method is of the form:
336 * L - means that the GPE is level triggered
337 * E - means that the GPE is edge triggered
338 * xx - is the GPE number [in HEX]
340 ******************************************************************************/
343 AcpiEvSaveMethodInfo (
344 ACPI_HANDLE ObjHandle
,
349 ACPI_GPE_BLOCK_INFO
*GpeBlock
= (void *) ObjDesc
;
350 ACPI_GPE_EVENT_INFO
*GpeEventInfo
;
352 char Name
[ACPI_NAME_SIZE
+ 1];
357 ACPI_FUNCTION_TRACE (EvSaveMethodInfo
);
361 * _Lxx and _Exx GPE method support
363 * 1) Extract the name from the object and convert to a string
366 Name
, &((ACPI_NAMESPACE_NODE
*) ObjHandle
)->Name
.Integer
);
367 Name
[ACPI_NAME_SIZE
] = 0;
370 * 2) Edge/Level determination is based on the 2nd character
373 * NOTE: Default GPE type is RUNTIME. May be changed later to WAKE
374 * if a _PRW object is found that points to this GPE.
379 Type
= ACPI_GPE_LEVEL_TRIGGERED
;
383 Type
= ACPI_GPE_EDGE_TRIGGERED
;
387 /* Unknown method type, just ignore it! */
389 ACPI_DEBUG_PRINT ((ACPI_DB_LOAD
,
390 "Ignoring unknown GPE method type: %s (name not of form _Lxx or _Exx)",
392 return_ACPI_STATUS (AE_OK
);
395 /* Convert the last two characters of the name to the GPE Number */
397 GpeNumber
= ACPI_STRTOUL (&Name
[2], NULL
, 16);
398 if (GpeNumber
== ACPI_UINT32_MAX
)
400 /* Conversion failed; invalid method, just ignore it */
402 ACPI_DEBUG_PRINT ((ACPI_DB_LOAD
,
403 "Could not extract GPE number from name: %s (name is not of form _Lxx or _Exx)",
405 return_ACPI_STATUS (AE_OK
);
408 /* Ensure that we have a valid GPE number for this GPE block */
410 if ((GpeNumber
< GpeBlock
->BlockBaseNumber
) ||
411 (GpeNumber
>= (GpeBlock
->BlockBaseNumber
+ (GpeBlock
->RegisterCount
* 8))))
414 * Not valid for this GPE block, just ignore it
415 * However, it may be valid for a different GPE block, since GPE0 and GPE1
416 * methods both appear under \_GPE.
418 return_ACPI_STATUS (AE_OK
);
422 * Now we can add this information to the GpeEventInfo block
423 * for use during dispatch of this GPE. Default type is RUNTIME, although
424 * this may change when the _PRW methods are executed later.
426 GpeEventInfo
= &GpeBlock
->EventInfo
[GpeNumber
- GpeBlock
->BlockBaseNumber
];
428 GpeEventInfo
->Flags
= (UINT8
)
429 (Type
| ACPI_GPE_DISPATCH_METHOD
| ACPI_GPE_TYPE_RUNTIME
);
431 GpeEventInfo
->Dispatch
.MethodNode
= (ACPI_NAMESPACE_NODE
*) ObjHandle
;
433 /* Update enable mask, but don't enable the HW GPE as of yet */
435 Status
= AcpiEvEnableGpe (GpeEventInfo
, FALSE
);
437 ACPI_DEBUG_PRINT ((ACPI_DB_LOAD
,
438 "Registered GPE method %s as GPE number 0x%.2X\n",
440 return_ACPI_STATUS (Status
);
444 /*******************************************************************************
446 * FUNCTION: AcpiEvMatchPrwAndGpe
448 * PARAMETERS: Callback from WalkNamespace
450 * RETURN: Status. NOTE: We ignore errors so that the _PRW walk is
451 * not aborted on a single _PRW failure.
453 * DESCRIPTION: Called from AcpiWalkNamespace. Expects each object to be a
454 * Device. Run the _PRW method. If present, extract the GPE
455 * number and mark the GPE as a WAKE GPE.
457 ******************************************************************************/
460 AcpiEvMatchPrwAndGpe (
461 ACPI_HANDLE ObjHandle
,
466 ACPI_GPE_WALK_INFO
*GpeInfo
= (void *) Info
;
467 ACPI_NAMESPACE_NODE
*GpeDevice
;
468 ACPI_GPE_BLOCK_INFO
*GpeBlock
;
469 ACPI_NAMESPACE_NODE
*TargetGpeDevice
;
470 ACPI_GPE_EVENT_INFO
*GpeEventInfo
;
471 ACPI_OPERAND_OBJECT
*PkgDesc
;
472 ACPI_OPERAND_OBJECT
*ObjDesc
;
477 ACPI_FUNCTION_TRACE (EvMatchPrwAndGpe
);
480 /* Check for a _PRW method under this device */
482 Status
= AcpiUtEvaluateObject (ObjHandle
, METHOD_NAME__PRW
,
483 ACPI_BTYPE_PACKAGE
, &PkgDesc
);
484 if (ACPI_FAILURE (Status
))
486 /* Ignore all errors from _PRW, we don't want to abort the subsystem */
488 return_ACPI_STATUS (AE_OK
);
491 /* The returned _PRW package must have at least two elements */
493 if (PkgDesc
->Package
.Count
< 2)
498 /* Extract pointers from the input context */
500 GpeDevice
= GpeInfo
->GpeDevice
;
501 GpeBlock
= GpeInfo
->GpeBlock
;
504 * The _PRW object must return a package, we are only interested
505 * in the first element
507 ObjDesc
= PkgDesc
->Package
.Elements
[0];
509 if (ACPI_GET_OBJECT_TYPE (ObjDesc
) == ACPI_TYPE_INTEGER
)
511 /* Use FADT-defined GPE device (from definition of _PRW) */
513 TargetGpeDevice
= AcpiGbl_FadtGpeDevice
;
515 /* Integer is the GPE number in the FADT described GPE blocks */
517 GpeNumber
= (UINT32
) ObjDesc
->Integer
.Value
;
519 else if (ACPI_GET_OBJECT_TYPE (ObjDesc
) == ACPI_TYPE_PACKAGE
)
521 /* Package contains a GPE reference and GPE number within a GPE block */
523 if ((ObjDesc
->Package
.Count
< 2) ||
524 (ACPI_GET_OBJECT_TYPE (ObjDesc
->Package
.Elements
[0]) != ACPI_TYPE_LOCAL_REFERENCE
) ||
525 (ACPI_GET_OBJECT_TYPE (ObjDesc
->Package
.Elements
[1]) != ACPI_TYPE_INTEGER
))
530 /* Get GPE block reference and decode */
532 TargetGpeDevice
= ObjDesc
->Package
.Elements
[0]->Reference
.Node
;
533 GpeNumber
= (UINT32
) ObjDesc
->Package
.Elements
[1]->Integer
.Value
;
537 /* Unknown type, just ignore it */
543 * Is this GPE within this block?
545 * TRUE iff these conditions are true:
546 * 1) The GPE devices match.
547 * 2) The GPE index(number) is within the range of the Gpe Block
548 * associated with the GPE device.
550 if ((GpeDevice
== TargetGpeDevice
) &&
551 (GpeNumber
>= GpeBlock
->BlockBaseNumber
) &&
552 (GpeNumber
< GpeBlock
->BlockBaseNumber
+ (GpeBlock
->RegisterCount
* 8)))
554 GpeEventInfo
= &GpeBlock
->EventInfo
[GpeNumber
- GpeBlock
->BlockBaseNumber
];
556 /* Mark GPE for WAKE-ONLY but WAKE_DISABLED */
558 GpeEventInfo
->Flags
&= ~(ACPI_GPE_WAKE_ENABLED
| ACPI_GPE_RUN_ENABLED
);
560 Status
= AcpiEvSetGpeType (GpeEventInfo
, ACPI_GPE_TYPE_WAKE
);
561 if (ACPI_FAILURE (Status
))
565 Status
= AcpiEvUpdateGpeEnableMasks (GpeEventInfo
, ACPI_GPE_DISABLE
);
569 AcpiUtRemoveReference (PkgDesc
);
570 return_ACPI_STATUS (AE_OK
);
574 /*******************************************************************************
576 * FUNCTION: AcpiEvGetGpeXruptBlock
578 * PARAMETERS: InterruptNumber - Interrupt for a GPE block
580 * RETURN: A GPE interrupt block
582 * DESCRIPTION: Get or Create a GPE interrupt block. There is one interrupt
583 * block per unique interrupt level used for GPEs.
584 * Should be called only when the GPE lists are semaphore locked
585 * and not subject to change.
587 ******************************************************************************/
589 static ACPI_GPE_XRUPT_INFO
*
590 AcpiEvGetGpeXruptBlock (
591 UINT32 InterruptNumber
)
593 ACPI_GPE_XRUPT_INFO
*NextGpeXrupt
;
594 ACPI_GPE_XRUPT_INFO
*GpeXrupt
;
596 ACPI_CPU_FLAGS Flags
;
599 ACPI_FUNCTION_TRACE (EvGetGpeXruptBlock
);
602 /* No need for lock since we are not changing any list elements here */
604 NextGpeXrupt
= AcpiGbl_GpeXruptListHead
;
607 if (NextGpeXrupt
->InterruptNumber
== InterruptNumber
)
609 return_PTR (NextGpeXrupt
);
612 NextGpeXrupt
= NextGpeXrupt
->Next
;
615 /* Not found, must allocate a new xrupt descriptor */
617 GpeXrupt
= ACPI_ALLOCATE_ZEROED (sizeof (ACPI_GPE_XRUPT_INFO
));
623 GpeXrupt
->InterruptNumber
= InterruptNumber
;
625 /* Install new interrupt descriptor with spin lock */
627 Flags
= AcpiOsAcquireLock (AcpiGbl_GpeLock
);
628 if (AcpiGbl_GpeXruptListHead
)
630 NextGpeXrupt
= AcpiGbl_GpeXruptListHead
;
631 while (NextGpeXrupt
->Next
)
633 NextGpeXrupt
= NextGpeXrupt
->Next
;
636 NextGpeXrupt
->Next
= GpeXrupt
;
637 GpeXrupt
->Previous
= NextGpeXrupt
;
641 AcpiGbl_GpeXruptListHead
= GpeXrupt
;
643 AcpiOsReleaseLock (AcpiGbl_GpeLock
, Flags
);
645 /* Install new interrupt handler if not SCI_INT */
647 if (InterruptNumber
!= AcpiGbl_FADT
.SciInterrupt
)
649 Status
= AcpiOsInstallInterruptHandler (InterruptNumber
,
650 AcpiEvGpeXruptHandler
, GpeXrupt
);
651 if (ACPI_FAILURE (Status
))
653 ACPI_ERROR ((AE_INFO
,
654 "Could not install GPE interrupt handler at level 0x%X",
660 return_PTR (GpeXrupt
);
664 /*******************************************************************************
666 * FUNCTION: AcpiEvDeleteGpeXrupt
668 * PARAMETERS: GpeXrupt - A GPE interrupt info block
672 * DESCRIPTION: Remove and free a GpeXrupt block. Remove an associated
673 * interrupt handler if not the SCI interrupt.
675 ******************************************************************************/
678 AcpiEvDeleteGpeXrupt (
679 ACPI_GPE_XRUPT_INFO
*GpeXrupt
)
682 ACPI_CPU_FLAGS Flags
;
685 ACPI_FUNCTION_TRACE (EvDeleteGpeXrupt
);
688 /* We never want to remove the SCI interrupt handler */
690 if (GpeXrupt
->InterruptNumber
== AcpiGbl_FADT
.SciInterrupt
)
692 GpeXrupt
->GpeBlockListHead
= NULL
;
693 return_ACPI_STATUS (AE_OK
);
696 /* Disable this interrupt */
698 Status
= AcpiOsRemoveInterruptHandler (
699 GpeXrupt
->InterruptNumber
, AcpiEvGpeXruptHandler
);
700 if (ACPI_FAILURE (Status
))
702 return_ACPI_STATUS (Status
);
705 /* Unlink the interrupt block with lock */
707 Flags
= AcpiOsAcquireLock (AcpiGbl_GpeLock
);
708 if (GpeXrupt
->Previous
)
710 GpeXrupt
->Previous
->Next
= GpeXrupt
->Next
;
715 GpeXrupt
->Next
->Previous
= GpeXrupt
->Previous
;
717 AcpiOsReleaseLock (AcpiGbl_GpeLock
, Flags
);
721 ACPI_FREE (GpeXrupt
);
722 return_ACPI_STATUS (AE_OK
);
726 /*******************************************************************************
728 * FUNCTION: AcpiEvInstallGpeBlock
730 * PARAMETERS: GpeBlock - New GPE block
731 * InterruptNumber - Xrupt to be associated with this GPE block
735 * DESCRIPTION: Install new GPE block with mutex support
737 ******************************************************************************/
740 AcpiEvInstallGpeBlock (
741 ACPI_GPE_BLOCK_INFO
*GpeBlock
,
742 UINT32 InterruptNumber
)
744 ACPI_GPE_BLOCK_INFO
*NextGpeBlock
;
745 ACPI_GPE_XRUPT_INFO
*GpeXruptBlock
;
747 ACPI_CPU_FLAGS Flags
;
750 ACPI_FUNCTION_TRACE (EvInstallGpeBlock
);
753 Status
= AcpiUtAcquireMutex (ACPI_MTX_EVENTS
);
754 if (ACPI_FAILURE (Status
))
756 return_ACPI_STATUS (Status
);
759 GpeXruptBlock
= AcpiEvGetGpeXruptBlock (InterruptNumber
);
762 Status
= AE_NO_MEMORY
;
766 /* Install the new block at the end of the list with lock */
768 Flags
= AcpiOsAcquireLock (AcpiGbl_GpeLock
);
769 if (GpeXruptBlock
->GpeBlockListHead
)
771 NextGpeBlock
= GpeXruptBlock
->GpeBlockListHead
;
772 while (NextGpeBlock
->Next
)
774 NextGpeBlock
= NextGpeBlock
->Next
;
777 NextGpeBlock
->Next
= GpeBlock
;
778 GpeBlock
->Previous
= NextGpeBlock
;
782 GpeXruptBlock
->GpeBlockListHead
= GpeBlock
;
785 GpeBlock
->XruptBlock
= GpeXruptBlock
;
786 AcpiOsReleaseLock (AcpiGbl_GpeLock
, Flags
);
790 Status
= AcpiUtReleaseMutex (ACPI_MTX_EVENTS
);
791 return_ACPI_STATUS (Status
);
795 /*******************************************************************************
797 * FUNCTION: AcpiEvDeleteGpeBlock
799 * PARAMETERS: GpeBlock - Existing GPE block
803 * DESCRIPTION: Remove a GPE block
805 ******************************************************************************/
808 AcpiEvDeleteGpeBlock (
809 ACPI_GPE_BLOCK_INFO
*GpeBlock
)
812 ACPI_CPU_FLAGS Flags
;
815 ACPI_FUNCTION_TRACE (EvInstallGpeBlock
);
818 Status
= AcpiUtAcquireMutex (ACPI_MTX_EVENTS
);
819 if (ACPI_FAILURE (Status
))
821 return_ACPI_STATUS (Status
);
824 /* Disable all GPEs in this block */
826 Status
= AcpiHwDisableGpeBlock (GpeBlock
->XruptBlock
, GpeBlock
);
828 if (!GpeBlock
->Previous
&& !GpeBlock
->Next
)
830 /* This is the last GpeBlock on this interrupt */
832 Status
= AcpiEvDeleteGpeXrupt (GpeBlock
->XruptBlock
);
833 if (ACPI_FAILURE (Status
))
840 /* Remove the block on this interrupt with lock */
842 Flags
= AcpiOsAcquireLock (AcpiGbl_GpeLock
);
843 if (GpeBlock
->Previous
)
845 GpeBlock
->Previous
->Next
= GpeBlock
->Next
;
849 GpeBlock
->XruptBlock
->GpeBlockListHead
= GpeBlock
->Next
;
854 GpeBlock
->Next
->Previous
= GpeBlock
->Previous
;
856 AcpiOsReleaseLock (AcpiGbl_GpeLock
, Flags
);
859 /* Free the GpeBlock */
861 ACPI_FREE (GpeBlock
->RegisterInfo
);
862 ACPI_FREE (GpeBlock
->EventInfo
);
863 ACPI_FREE (GpeBlock
);
866 Status
= AcpiUtReleaseMutex (ACPI_MTX_EVENTS
);
867 return_ACPI_STATUS (Status
);
871 /*******************************************************************************
873 * FUNCTION: AcpiEvCreateGpeInfoBlocks
875 * PARAMETERS: GpeBlock - New GPE block
879 * DESCRIPTION: Create the RegisterInfo and EventInfo blocks for this GPE block
881 ******************************************************************************/
884 AcpiEvCreateGpeInfoBlocks (
885 ACPI_GPE_BLOCK_INFO
*GpeBlock
)
887 ACPI_GPE_REGISTER_INFO
*GpeRegisterInfo
= NULL
;
888 ACPI_GPE_EVENT_INFO
*GpeEventInfo
= NULL
;
889 ACPI_GPE_EVENT_INFO
*ThisEvent
;
890 ACPI_GPE_REGISTER_INFO
*ThisRegister
;
896 ACPI_FUNCTION_TRACE (EvCreateGpeInfoBlocks
);
899 /* Allocate the GPE register information block */
901 GpeRegisterInfo
= ACPI_ALLOCATE_ZEROED (
902 (ACPI_SIZE
) GpeBlock
->RegisterCount
*
903 sizeof (ACPI_GPE_REGISTER_INFO
));
904 if (!GpeRegisterInfo
)
906 ACPI_ERROR ((AE_INFO
,
907 "Could not allocate the GpeRegisterInfo table"));
908 return_ACPI_STATUS (AE_NO_MEMORY
);
912 * Allocate the GPE EventInfo block. There are eight distinct GPEs
913 * per register. Initialization to zeros is sufficient.
915 GpeEventInfo
= ACPI_ALLOCATE_ZEROED (
916 ((ACPI_SIZE
) GpeBlock
->RegisterCount
*
917 ACPI_GPE_REGISTER_WIDTH
) *
918 sizeof (ACPI_GPE_EVENT_INFO
));
921 ACPI_ERROR ((AE_INFO
,
922 "Could not allocate the GpeEventInfo table"));
923 Status
= AE_NO_MEMORY
;
927 /* Save the new Info arrays in the GPE block */
929 GpeBlock
->RegisterInfo
= GpeRegisterInfo
;
930 GpeBlock
->EventInfo
= GpeEventInfo
;
933 * Initialize the GPE Register and Event structures. A goal of these
934 * tables is to hide the fact that there are two separate GPE register sets
935 * in a given GPE hardware block, the status registers occupy the first half,
936 * and the enable registers occupy the second half.
938 ThisRegister
= GpeRegisterInfo
;
939 ThisEvent
= GpeEventInfo
;
941 for (i
= 0; i
< GpeBlock
->RegisterCount
; i
++)
943 /* Init the RegisterInfo for this GPE register (8 GPEs) */
945 ThisRegister
->BaseGpeNumber
= (UINT8
) (GpeBlock
->BlockBaseNumber
+
946 (i
* ACPI_GPE_REGISTER_WIDTH
));
948 ACPI_STORE_ADDRESS (ThisRegister
->StatusAddress
.Address
,
949 (ACPI_GET_ADDRESS (GpeBlock
->BlockAddress
.Address
)
952 ACPI_STORE_ADDRESS (ThisRegister
->EnableAddress
.Address
,
953 (ACPI_GET_ADDRESS (GpeBlock
->BlockAddress
.Address
)
955 + GpeBlock
->RegisterCount
));
957 ThisRegister
->StatusAddress
.SpaceId
= GpeBlock
->BlockAddress
.SpaceId
;
958 ThisRegister
->EnableAddress
.SpaceId
= GpeBlock
->BlockAddress
.SpaceId
;
959 ThisRegister
->StatusAddress
.BitWidth
= ACPI_GPE_REGISTER_WIDTH
;
960 ThisRegister
->EnableAddress
.BitWidth
= ACPI_GPE_REGISTER_WIDTH
;
961 ThisRegister
->StatusAddress
.BitOffset
= ACPI_GPE_REGISTER_WIDTH
;
962 ThisRegister
->EnableAddress
.BitOffset
= ACPI_GPE_REGISTER_WIDTH
;
964 /* Init the EventInfo for each GPE within this register */
966 for (j
= 0; j
< ACPI_GPE_REGISTER_WIDTH
; j
++)
968 ThisEvent
->GpeNumber
= (UINT8
) (ThisRegister
->BaseGpeNumber
+ j
);
969 ThisEvent
->RegisterInfo
= ThisRegister
;
973 /* Disable all GPEs within this register */
975 Status
= AcpiHwLowLevelWrite (ACPI_GPE_REGISTER_WIDTH
, 0x00,
976 &ThisRegister
->EnableAddress
);
977 if (ACPI_FAILURE (Status
))
982 /* Clear any pending GPE events within this register */
984 Status
= AcpiHwLowLevelWrite (ACPI_GPE_REGISTER_WIDTH
, 0xFF,
985 &ThisRegister
->StatusAddress
);
986 if (ACPI_FAILURE (Status
))
994 return_ACPI_STATUS (AE_OK
);
1000 ACPI_FREE (GpeRegisterInfo
);
1004 ACPI_FREE (GpeEventInfo
);
1007 return_ACPI_STATUS (Status
);
1011 /*******************************************************************************
1013 * FUNCTION: AcpiEvCreateGpeBlock
1015 * PARAMETERS: GpeDevice - Handle to the parent GPE block
1016 * GpeBlockAddress - Address and SpaceID
1017 * RegisterCount - Number of GPE register pairs in the block
1018 * GpeBlockBaseNumber - Starting GPE number for the block
1019 * InterruptNumber - H/W interrupt for the block
1020 * ReturnGpeBlock - Where the new block descriptor is returned
1024 * DESCRIPTION: Create and Install a block of GPE registers. All GPEs within
1025 * the block are disabled at exit.
1026 * Note: Assumes namespace is locked.
1028 ******************************************************************************/
1031 AcpiEvCreateGpeBlock (
1032 ACPI_NAMESPACE_NODE
*GpeDevice
,
1033 ACPI_GENERIC_ADDRESS
*GpeBlockAddress
,
1034 UINT32 RegisterCount
,
1035 UINT8 GpeBlockBaseNumber
,
1036 UINT32 InterruptNumber
,
1037 ACPI_GPE_BLOCK_INFO
**ReturnGpeBlock
)
1040 ACPI_GPE_BLOCK_INFO
*GpeBlock
;
1043 ACPI_FUNCTION_TRACE (EvCreateGpeBlock
);
1048 return_ACPI_STATUS (AE_OK
);
1051 /* Allocate a new GPE block */
1053 GpeBlock
= ACPI_ALLOCATE_ZEROED (sizeof (ACPI_GPE_BLOCK_INFO
));
1056 return_ACPI_STATUS (AE_NO_MEMORY
);
1059 /* Initialize the new GPE block */
1061 GpeBlock
->Node
= GpeDevice
;
1062 GpeBlock
->RegisterCount
= RegisterCount
;
1063 GpeBlock
->BlockBaseNumber
= GpeBlockBaseNumber
;
1065 ACPI_MEMCPY (&GpeBlock
->BlockAddress
, GpeBlockAddress
,
1066 sizeof (ACPI_GENERIC_ADDRESS
));
1069 * Create the RegisterInfo and EventInfo sub-structures
1070 * Note: disables and clears all GPEs in the block
1072 Status
= AcpiEvCreateGpeInfoBlocks (GpeBlock
);
1073 if (ACPI_FAILURE (Status
))
1075 ACPI_FREE (GpeBlock
);
1076 return_ACPI_STATUS (Status
);
1079 /* Install the new block in the global lists */
1081 Status
= AcpiEvInstallGpeBlock (GpeBlock
, InterruptNumber
);
1082 if (ACPI_FAILURE (Status
))
1084 ACPI_FREE (GpeBlock
);
1085 return_ACPI_STATUS (Status
);
1088 /* Find all GPE methods (_Lxx, _Exx) for this block */
1090 Status
= AcpiNsWalkNamespace (ACPI_TYPE_METHOD
, GpeDevice
,
1091 ACPI_UINT32_MAX
, ACPI_NS_WALK_NO_UNLOCK
,
1092 AcpiEvSaveMethodInfo
, GpeBlock
, NULL
);
1094 /* Return the new block */
1098 (*ReturnGpeBlock
) = GpeBlock
;
1101 ACPI_DEBUG_PRINT ((ACPI_DB_INIT
,
1102 "GPE %02X to %02X [%4.4s] %u regs on int 0x%X\n",
1103 (UINT32
) GpeBlock
->BlockBaseNumber
,
1104 (UINT32
) (GpeBlock
->BlockBaseNumber
+
1105 ((GpeBlock
->RegisterCount
* ACPI_GPE_REGISTER_WIDTH
) -1)),
1106 GpeDevice
->Name
.Ascii
,
1107 GpeBlock
->RegisterCount
,
1110 return_ACPI_STATUS (AE_OK
);
1114 /*******************************************************************************
1116 * FUNCTION: AcpiEvInitializeGpeBlock
1118 * PARAMETERS: GpeDevice - Handle to the parent GPE block
1119 * GpeBlock - Gpe Block info
1123 * DESCRIPTION: Initialize and enable a GPE block. First find and run any
1124 * _PRT methods associated with the block, then enable the
1126 * Note: Assumes namespace is locked.
1128 ******************************************************************************/
1131 AcpiEvInitializeGpeBlock (
1132 ACPI_NAMESPACE_NODE
*GpeDevice
,
1133 ACPI_GPE_BLOCK_INFO
*GpeBlock
)
1136 ACPI_GPE_EVENT_INFO
*GpeEventInfo
;
1137 ACPI_GPE_WALK_INFO GpeInfo
;
1138 UINT32 WakeGpeCount
;
1139 UINT32 GpeEnabledCount
;
1144 ACPI_FUNCTION_TRACE (EvInitializeGpeBlock
);
1147 /* Ignore a null GPE block (e.g., if no GPE block 1 exists) */
1151 return_ACPI_STATUS (AE_OK
);
1155 * Runtime option: Should wake GPEs be enabled at runtime? The default
1156 * is no, they should only be enabled just as the machine goes to sleep.
1158 if (AcpiGbl_LeaveWakeGpesDisabled
)
1161 * Differentiate runtime vs wake GPEs, via the _PRW control methods.
1162 * Each GPE that has one or more _PRWs that reference it is by
1163 * definition a wake GPE and will not be enabled while the machine
1166 GpeInfo
.GpeBlock
= GpeBlock
;
1167 GpeInfo
.GpeDevice
= GpeDevice
;
1169 Status
= AcpiNsWalkNamespace (ACPI_TYPE_DEVICE
, ACPI_ROOT_OBJECT
,
1170 ACPI_UINT32_MAX
, ACPI_NS_WALK_UNLOCK
,
1171 AcpiEvMatchPrwAndGpe
, &GpeInfo
, NULL
);
1175 * Enable all GPEs in this block that have these attributes:
1176 * 1) are "runtime" or "run/wake" GPEs, and
1177 * 2) have a corresponding _Lxx or _Exx method
1179 * Any other GPEs within this block must be enabled via the AcpiEnableGpe()
1180 * external interface.
1183 GpeEnabledCount
= 0;
1185 for (i
= 0; i
< GpeBlock
->RegisterCount
; i
++)
1187 for (j
= 0; j
< 8; j
++)
1189 /* Get the info block for this particular GPE */
1191 GpeEventInfo
= &GpeBlock
->EventInfo
[(i
* ACPI_GPE_REGISTER_WIDTH
) + j
];
1193 if (((GpeEventInfo
->Flags
& ACPI_GPE_DISPATCH_MASK
) == ACPI_GPE_DISPATCH_METHOD
) &&
1194 (GpeEventInfo
->Flags
& ACPI_GPE_TYPE_RUNTIME
))
1199 if (GpeEventInfo
->Flags
& ACPI_GPE_TYPE_WAKE
)
1206 ACPI_DEBUG_PRINT ((ACPI_DB_INIT
,
1207 "Found %u Wake, Enabled %u Runtime GPEs in this block\n",
1208 WakeGpeCount
, GpeEnabledCount
));
1210 /* Enable all valid runtime GPEs found above */
1212 Status
= AcpiHwEnableRuntimeGpeBlock (NULL
, GpeBlock
);
1213 if (ACPI_FAILURE (Status
))
1215 ACPI_ERROR ((AE_INFO
, "Could not enable GPEs in GpeBlock %p",
1219 return_ACPI_STATUS (Status
);
1223 /*******************************************************************************
1225 * FUNCTION: AcpiEvGpeInitialize
1231 * DESCRIPTION: Initialize the GPE data structures
1233 ******************************************************************************/
1236 AcpiEvGpeInitialize (
1239 UINT32 RegisterCount0
= 0;
1240 UINT32 RegisterCount1
= 0;
1241 UINT32 GpeNumberMax
= 0;
1245 ACPI_FUNCTION_TRACE (EvGpeInitialize
);
1248 Status
= AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE
);
1249 if (ACPI_FAILURE (Status
))
1251 return_ACPI_STATUS (Status
);
1255 * Initialize the GPE Block(s) defined in the FADT
1257 * Why the GPE register block lengths are divided by 2: From the ACPI Spec,
1258 * section "General-Purpose Event Registers", we have:
1260 * "Each register block contains two registers of equal length
1261 * GPEx_STS and GPEx_EN (where x is 0 or 1). The length of the
1262 * GPE0_STS and GPE0_EN registers is equal to half the GPE0_LEN
1263 * The length of the GPE1_STS and GPE1_EN registers is equal to
1264 * half the GPE1_LEN. If a generic register block is not supported
1265 * then its respective block pointer and block length values in the
1266 * FADT table contain zeros. The GPE0_LEN and GPE1_LEN do not need
1267 * to be the same size."
1271 * Determine the maximum GPE number for this machine.
1273 * Note: both GPE0 and GPE1 are optional, and either can exist without
1276 * If EITHER the register length OR the block address are zero, then that
1277 * particular block is not supported.
1279 if (AcpiGbl_FADT
.Gpe0BlockLength
&&
1280 ACPI_GET_ADDRESS (AcpiGbl_FADT
.XGpe0Block
.Address
))
1282 /* GPE block 0 exists (has both length and address > 0) */
1284 RegisterCount0
= (UINT16
) (AcpiGbl_FADT
.Gpe0BlockLength
/ 2);
1286 GpeNumberMax
= (RegisterCount0
* ACPI_GPE_REGISTER_WIDTH
) - 1;
1288 /* Install GPE Block 0 */
1290 Status
= AcpiEvCreateGpeBlock (AcpiGbl_FadtGpeDevice
,
1291 &AcpiGbl_FADT
.XGpe0Block
, RegisterCount0
, 0,
1292 AcpiGbl_FADT
.SciInterrupt
, &AcpiGbl_GpeFadtBlocks
[0]);
1294 if (ACPI_FAILURE (Status
))
1296 ACPI_EXCEPTION ((AE_INFO
, Status
,
1297 "Could not create GPE Block 0"));
1301 if (AcpiGbl_FADT
.Gpe1BlockLength
&&
1302 ACPI_GET_ADDRESS (AcpiGbl_FADT
.XGpe1Block
.Address
))
1304 /* GPE block 1 exists (has both length and address > 0) */
1306 RegisterCount1
= (UINT16
) (AcpiGbl_FADT
.Gpe1BlockLength
/ 2);
1308 /* Check for GPE0/GPE1 overlap (if both banks exist) */
1310 if ((RegisterCount0
) &&
1311 (GpeNumberMax
>= AcpiGbl_FADT
.Gpe1Base
))
1313 ACPI_ERROR ((AE_INFO
,
1314 "GPE0 block (GPE 0 to %d) overlaps the GPE1 block (GPE %d to %d) - Ignoring GPE1",
1315 GpeNumberMax
, AcpiGbl_FADT
.Gpe1Base
,
1316 AcpiGbl_FADT
.Gpe1Base
+
1317 ((RegisterCount1
* ACPI_GPE_REGISTER_WIDTH
) - 1)));
1319 /* Ignore GPE1 block by setting the register count to zero */
1325 /* Install GPE Block 1 */
1327 Status
= AcpiEvCreateGpeBlock (AcpiGbl_FadtGpeDevice
,
1328 &AcpiGbl_FADT
.XGpe1Block
, RegisterCount1
,
1329 AcpiGbl_FADT
.Gpe1Base
,
1330 AcpiGbl_FADT
.SciInterrupt
, &AcpiGbl_GpeFadtBlocks
[1]);
1332 if (ACPI_FAILURE (Status
))
1334 ACPI_EXCEPTION ((AE_INFO
, Status
,
1335 "Could not create GPE Block 1"));
1339 * GPE0 and GPE1 do not have to be contiguous in the GPE number
1340 * space. However, GPE0 always starts at GPE number zero.
1342 GpeNumberMax
= AcpiGbl_FADT
.Gpe1Base
+
1343 ((RegisterCount1
* ACPI_GPE_REGISTER_WIDTH
) - 1);
1347 /* Exit if there are no GPE registers */
1349 if ((RegisterCount0
+ RegisterCount1
) == 0)
1351 /* GPEs are not required by ACPI, this is OK */
1353 ACPI_DEBUG_PRINT ((ACPI_DB_INIT
,
1354 "There are no GPE blocks defined in the FADT\n"));
1359 /* Check for Max GPE number out-of-range */
1361 if (GpeNumberMax
> ACPI_GPE_MAX
)
1363 ACPI_ERROR ((AE_INFO
,
1364 "Maximum GPE number from FADT is too large: 0x%X",
1366 Status
= AE_BAD_VALUE
;
1371 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE
);
1372 return_ACPI_STATUS (AE_OK
);