1 /******************************************************************************
3 * Module Name: evgpeinit - System GPE initialization and update
5 *****************************************************************************/
7 /******************************************************************************
11 * Some or all of this work - Copyright (c) 1999 - 2014, Intel Corp.
12 * All rights reserved.
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
37 * The above copyright and patent license is granted only if the following
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
72 * 3.4. Intel retains all right, title, and interest in and to the Original
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
80 * 4. Disclaimer and Export Compliance
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
114 *****************************************************************************/
118 #include "accommon.h"
119 #include "acevents.h"
120 #include "acnamesp.h"
122 #define _COMPONENT ACPI_EVENTS
123 ACPI_MODULE_NAME ("evgpeinit")
125 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */
128 * Note: History of _PRW support in ACPICA
130 * Originally (2000 - 2010), the GPE initialization code performed a walk of
131 * the entire namespace to execute the _PRW methods and detect all GPEs
132 * capable of waking the system.
134 * As of 10/2010, the _PRW method execution has been removed since it is
135 * actually unnecessary. The host OS must in fact execute all _PRW methods
136 * in order to identify the device/power-resource dependencies. We now put
137 * the onus on the host OS to identify the wake GPEs as part of this process
138 * and to inform ACPICA of these GPEs via the AcpiSetupGpeForWake interface. This
139 * not only reduces the complexity of the ACPICA initialization code, but in
140 * some cases (on systems with very large namespaces) it should reduce the
141 * kernel boot time as well.
144 /*******************************************************************************
146 * FUNCTION: AcpiEvGpeInitialize
152 * DESCRIPTION: Initialize the GPE data structures and the FADT GPE 0/1 blocks
154 ******************************************************************************/
157 AcpiEvGpeInitialize (
160 UINT32 RegisterCount0
= 0;
161 UINT32 RegisterCount1
= 0;
162 UINT32 GpeNumberMax
= 0;
166 ACPI_FUNCTION_TRACE (EvGpeInitialize
);
169 ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT
,
170 "Initializing General Purpose Events (GPEs):\n"));
172 Status
= AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE
);
173 if (ACPI_FAILURE (Status
))
175 return_ACPI_STATUS (Status
);
179 * Initialize the GPE Block(s) defined in the FADT
181 * Why the GPE register block lengths are divided by 2: From the ACPI
182 * Spec, section "General-Purpose Event Registers", we have:
184 * "Each register block contains two registers of equal length
185 * GPEx_STS and GPEx_EN (where x is 0 or 1). The length of the
186 * GPE0_STS and GPE0_EN registers is equal to half the GPE0_LEN
187 * The length of the GPE1_STS and GPE1_EN registers is equal to
188 * half the GPE1_LEN. If a generic register block is not supported
189 * then its respective block pointer and block length values in the
190 * FADT table contain zeros. The GPE0_LEN and GPE1_LEN do not need
191 * to be the same size."
195 * Determine the maximum GPE number for this machine.
197 * Note: both GPE0 and GPE1 are optional, and either can exist without
200 * If EITHER the register length OR the block address are zero, then that
201 * particular block is not supported.
203 if (AcpiGbl_FADT
.Gpe0BlockLength
&&
204 AcpiGbl_FADT
.XGpe0Block
.Address
)
206 /* GPE block 0 exists (has both length and address > 0) */
208 RegisterCount0
= (UINT16
) (AcpiGbl_FADT
.Gpe0BlockLength
/ 2);
209 GpeNumberMax
= (RegisterCount0
* ACPI_GPE_REGISTER_WIDTH
) - 1;
211 /* Install GPE Block 0 */
213 Status
= AcpiEvCreateGpeBlock (AcpiGbl_FadtGpeDevice
,
214 &AcpiGbl_FADT
.XGpe0Block
, RegisterCount0
, 0,
215 AcpiGbl_FADT
.SciInterrupt
, &AcpiGbl_GpeFadtBlocks
[0]);
217 if (ACPI_FAILURE (Status
))
219 ACPI_EXCEPTION ((AE_INFO
, Status
,
220 "Could not create GPE Block 0"));
224 if (AcpiGbl_FADT
.Gpe1BlockLength
&&
225 AcpiGbl_FADT
.XGpe1Block
.Address
)
227 /* GPE block 1 exists (has both length and address > 0) */
229 RegisterCount1
= (UINT16
) (AcpiGbl_FADT
.Gpe1BlockLength
/ 2);
231 /* Check for GPE0/GPE1 overlap (if both banks exist) */
233 if ((RegisterCount0
) &&
234 (GpeNumberMax
>= AcpiGbl_FADT
.Gpe1Base
))
236 ACPI_ERROR ((AE_INFO
,
237 "GPE0 block (GPE 0 to %u) overlaps the GPE1 block "
238 "(GPE %u to %u) - Ignoring GPE1",
239 GpeNumberMax
, AcpiGbl_FADT
.Gpe1Base
,
240 AcpiGbl_FADT
.Gpe1Base
+
241 ((RegisterCount1
* ACPI_GPE_REGISTER_WIDTH
) - 1)));
243 /* Ignore GPE1 block by setting the register count to zero */
249 /* Install GPE Block 1 */
251 Status
= AcpiEvCreateGpeBlock (AcpiGbl_FadtGpeDevice
,
252 &AcpiGbl_FADT
.XGpe1Block
, RegisterCount1
,
253 AcpiGbl_FADT
.Gpe1Base
,
254 AcpiGbl_FADT
.SciInterrupt
, &AcpiGbl_GpeFadtBlocks
[1]);
256 if (ACPI_FAILURE (Status
))
258 ACPI_EXCEPTION ((AE_INFO
, Status
,
259 "Could not create GPE Block 1"));
263 * GPE0 and GPE1 do not have to be contiguous in the GPE number
264 * space. However, GPE0 always starts at GPE number zero.
266 GpeNumberMax
= AcpiGbl_FADT
.Gpe1Base
+
267 ((RegisterCount1
* ACPI_GPE_REGISTER_WIDTH
) - 1);
271 /* Exit if there are no GPE registers */
273 if ((RegisterCount0
+ RegisterCount1
) == 0)
275 /* GPEs are not required by ACPI, this is OK */
277 ACPI_DEBUG_PRINT ((ACPI_DB_INIT
,
278 "There are no GPE blocks defined in the FADT\n"));
285 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE
);
286 return_ACPI_STATUS (AE_OK
);
290 /*******************************************************************************
292 * FUNCTION: AcpiEvUpdateGpes
294 * PARAMETERS: TableOwnerId - ID of the newly-loaded ACPI table
298 * DESCRIPTION: Check for new GPE methods (_Lxx/_Exx) made available as a
299 * result of a Load() or LoadTable() operation. If new GPE
300 * methods have been installed, register the new methods.
302 ******************************************************************************/
306 ACPI_OWNER_ID TableOwnerId
)
308 ACPI_GPE_XRUPT_INFO
*GpeXruptInfo
;
309 ACPI_GPE_BLOCK_INFO
*GpeBlock
;
310 ACPI_GPE_WALK_INFO WalkInfo
;
311 ACPI_STATUS Status
= AE_OK
;
315 * Find any _Lxx/_Exx GPE methods that have just been loaded.
317 * Any GPEs that correspond to new _Lxx/_Exx methods are immediately
320 * Examine the namespace underneath each GpeDevice within the
323 Status
= AcpiUtAcquireMutex (ACPI_MTX_EVENTS
);
324 if (ACPI_FAILURE (Status
))
330 WalkInfo
.OwnerId
= TableOwnerId
;
331 WalkInfo
.ExecuteByOwnerId
= TRUE
;
333 /* Walk the interrupt level descriptor list */
335 GpeXruptInfo
= AcpiGbl_GpeXruptListHead
;
338 /* Walk all Gpe Blocks attached to this interrupt level */
340 GpeBlock
= GpeXruptInfo
->GpeBlockListHead
;
343 WalkInfo
.GpeBlock
= GpeBlock
;
344 WalkInfo
.GpeDevice
= GpeBlock
->Node
;
346 Status
= AcpiNsWalkNamespace (ACPI_TYPE_METHOD
,
347 WalkInfo
.GpeDevice
, ACPI_UINT32_MAX
,
348 ACPI_NS_WALK_NO_UNLOCK
, AcpiEvMatchGpeMethod
,
349 NULL
, &WalkInfo
, NULL
);
350 if (ACPI_FAILURE (Status
))
352 ACPI_EXCEPTION ((AE_INFO
, Status
,
353 "While decoding _Lxx/_Exx methods"));
356 GpeBlock
= GpeBlock
->Next
;
359 GpeXruptInfo
= GpeXruptInfo
->Next
;
364 ACPI_INFO ((AE_INFO
, "Enabled %u new GPEs", WalkInfo
.Count
));
367 (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS
);
372 /*******************************************************************************
374 * FUNCTION: AcpiEvMatchGpeMethod
376 * PARAMETERS: Callback from WalkNamespace
380 * DESCRIPTION: Called from AcpiWalkNamespace. Expects each object to be a
381 * control method under the _GPE portion of the namespace.
382 * Extract the name and GPE type from the object, saving this
383 * information for quick lookup during GPE dispatch. Allows a
384 * per-OwnerId evaluation if ExecuteByOwnerId is TRUE in the
385 * WalkInfo parameter block.
387 * The name of each GPE control method is of the form:
388 * "_Lxx" or "_Exx", where:
389 * L - means that the GPE is level triggered
390 * E - means that the GPE is edge triggered
391 * xx - is the GPE number [in HEX]
393 * If WalkInfo->ExecuteByOwnerId is TRUE, we only execute examine GPE methods
396 ******************************************************************************/
399 AcpiEvMatchGpeMethod (
400 ACPI_HANDLE ObjHandle
,
405 ACPI_NAMESPACE_NODE
*MethodNode
= ACPI_CAST_PTR (ACPI_NAMESPACE_NODE
, ObjHandle
);
406 ACPI_GPE_WALK_INFO
*WalkInfo
= ACPI_CAST_PTR (ACPI_GPE_WALK_INFO
, Context
);
407 ACPI_GPE_EVENT_INFO
*GpeEventInfo
;
409 char Name
[ACPI_NAME_SIZE
+ 1];
413 ACPI_FUNCTION_TRACE (EvMatchGpeMethod
);
416 /* Check if requested OwnerId matches this OwnerId */
418 if ((WalkInfo
->ExecuteByOwnerId
) &&
419 (MethodNode
->OwnerId
!= WalkInfo
->OwnerId
))
421 return_ACPI_STATUS (AE_OK
);
425 * Match and decode the _Lxx and _Exx GPE method names
427 * 1) Extract the method name and null terminate it
429 ACPI_MOVE_32_TO_32 (Name
, &MethodNode
->Name
.Integer
);
430 Name
[ACPI_NAME_SIZE
] = 0;
432 /* 2) Name must begin with an underscore */
436 return_ACPI_STATUS (AE_OK
); /* Ignore this method */
440 * 3) Edge/Level determination is based on the 2nd character
447 Type
= ACPI_GPE_LEVEL_TRIGGERED
;
452 Type
= ACPI_GPE_EDGE_TRIGGERED
;
457 /* Unknown method type, just ignore it */
459 ACPI_DEBUG_PRINT ((ACPI_DB_LOAD
,
460 "Ignoring unknown GPE method type: %s "
461 "(name not of form _Lxx or _Exx)", Name
));
462 return_ACPI_STATUS (AE_OK
);
465 /* 4) The last two characters of the name are the hex GPE Number */
467 GpeNumber
= ACPI_STRTOUL (&Name
[2], NULL
, 16);
468 if (GpeNumber
== ACPI_UINT32_MAX
)
470 /* Conversion failed; invalid method, just ignore it */
472 ACPI_DEBUG_PRINT ((ACPI_DB_LOAD
,
473 "Could not extract GPE number from name: %s "
474 "(name is not of form _Lxx or _Exx)", Name
));
475 return_ACPI_STATUS (AE_OK
);
478 /* Ensure that we have a valid GPE number for this GPE block */
480 GpeEventInfo
= AcpiEvLowGetGpeInfo (GpeNumber
, WalkInfo
->GpeBlock
);
484 * This GpeNumber is not valid for this GPE block, just ignore it.
485 * However, it may be valid for a different GPE block, since GPE0
486 * and GPE1 methods both appear under \_GPE.
488 return_ACPI_STATUS (AE_OK
);
491 if ((GpeEventInfo
->Flags
& ACPI_GPE_DISPATCH_MASK
) ==
492 ACPI_GPE_DISPATCH_HANDLER
)
494 /* If there is already a handler, ignore this GPE method */
496 return_ACPI_STATUS (AE_OK
);
499 if ((GpeEventInfo
->Flags
& ACPI_GPE_DISPATCH_MASK
) ==
500 ACPI_GPE_DISPATCH_METHOD
)
503 * If there is already a method, ignore this method. But check
504 * for a type mismatch (if both the _Lxx AND _Exx exist)
506 if (Type
!= (GpeEventInfo
->Flags
& ACPI_GPE_XRUPT_TYPE_MASK
))
508 ACPI_ERROR ((AE_INFO
,
509 "For GPE 0x%.2X, found both _L%2.2X and _E%2.2X methods",
510 GpeNumber
, GpeNumber
, GpeNumber
));
512 return_ACPI_STATUS (AE_OK
);
516 * Add the GPE information from above to the GpeEventInfo block for
517 * use during dispatch of this GPE.
519 GpeEventInfo
->Flags
&= ~(ACPI_GPE_DISPATCH_MASK
);
520 GpeEventInfo
->Flags
|= (UINT8
) (Type
| ACPI_GPE_DISPATCH_METHOD
);
521 GpeEventInfo
->Dispatch
.MethodNode
= MethodNode
;
523 ACPI_DEBUG_PRINT ((ACPI_DB_LOAD
,
524 "Registered GPE method %s as GPE number 0x%.2X\n",
526 return_ACPI_STATUS (AE_OK
);
529 #endif /* !ACPI_REDUCED_HARDWARE */