X-Git-Url: https://rtime.felk.cvut.cz/gitweb/l4.git/blobdiff_plain/35719fdd2ff27177690edb32843d32e092a006e3..5658d2ec9c1081516a8868259fa867926e25ab3f:/l4/pkg/acpica/lib-acpi/src/acpica/tools/acpiexec/aehandlers.c diff --git a/l4/pkg/acpica/lib-acpi/src/acpica/tools/acpiexec/aehandlers.c b/l4/pkg/acpica/lib-acpi/src/acpica/tools/acpiexec/aehandlers.c index ae57483c4..c3aadb160 100644 --- a/l4/pkg/acpica/lib-acpi/src/acpica/tools/acpiexec/aehandlers.c +++ b/l4/pkg/acpica/lib-acpi/src/acpica/tools/acpiexec/aehandlers.c @@ -8,13 +8,13 @@ * * 1. Copyright Notice * - * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp. + * Some or all of this work - Copyright (c) 1999 - 2012, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property - * rights. You may have additional license terms from the party that provided + * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * @@ -31,7 +31,7 @@ * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions - * to or modifications of the Original Intel Code. No other license or right + * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following @@ -43,11 +43,11 @@ * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, - * and the following Disclaimer and Export Compliance provision. In addition, + * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered - * Code and the date of any change. Licensee must include in that file the - * documentation of any changes made by any predecessor Licensee. Licensee + * Code and the date of any change. Licensee must include in that file the + * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * @@ -55,7 +55,7 @@ * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the - * documentation and/or other materials provided with distribution. In + * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual @@ -80,10 +80,10 @@ * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED - * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE - * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, - * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY - * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY + * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE + * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, + * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY + * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * @@ -92,14 +92,14 @@ * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL - * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS + * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or - * any other agency or department of the United States Government. In the + * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in @@ -120,19 +120,31 @@ /* Local prototypes */ -void -AeNotifyHandler ( +static void +AeNotifyHandler1 ( ACPI_HANDLE Device, UINT32 Value, void *Context); -void +static void +AeNotifyHandler2 ( + ACPI_HANDLE Device, + UINT32 Value, + void *Context); + +static void +AeCommonNotifyHandler ( + ACPI_HANDLE Device, + UINT32 Value, + UINT32 HandlerId); + +static void AeDeviceNotifyHandler ( ACPI_HANDLE Device, UINT32 Value, void *Context); -ACPI_STATUS +static ACPI_STATUS AeExceptionHandler ( ACPI_STATUS AmlStatus, ACPI_NAME Name, @@ -140,27 +152,84 @@ AeExceptionHandler ( UINT32 AmlOffset, void *Context); -ACPI_STATUS +static ACPI_STATUS AeTableHandler ( UINT32 Event, void *Table, void *Context); -ACPI_STATUS +static ACPI_STATUS AeRegionInit ( ACPI_HANDLE RegionHandle, UINT32 Function, void *HandlerContext, void **RegionContext); -void +static void AeAttachedDataHandler ( ACPI_HANDLE Object, void *Data); -UINT32 SigintCount = 0; -AE_DEBUG_REGIONS AeRegions; +static UINT32 +AeInterfaceHandler ( + ACPI_STRING InterfaceName, + UINT32 Supported); + +#if (!ACPI_REDUCED_HARDWARE) +static UINT32 +AeEventHandler ( + void *Context); + +static char *TableEvents[] = +{ + "LOAD", + "UNLOAD", + "UNKNOWN" +}; +#endif /* !ACPI_REDUCED_HARDWARE */ + +static UINT32 SigintCount = 0; +static AE_DEBUG_REGIONS AeRegions; +BOOLEAN AcpiGbl_DisplayRegionAccess = FALSE; + + +/* + * We will override some of the default region handlers, especially the + * SystemMemory handler, which must be implemented locally. Do not override + * the PCI_Config handler since we would like to exercise the default handler + * code. These handlers are installed "early" - before any _REG methods + * are executed - since they are special in the sense that tha ACPI spec + * declares that they must "always be available". Cannot override the + * DataTable region handler either -- needed for test execution. + */ +static ACPI_ADR_SPACE_TYPE DefaultSpaceIdList[] = +{ + ACPI_ADR_SPACE_SYSTEM_MEMORY, + ACPI_ADR_SPACE_SYSTEM_IO +}; + +/* + * We will install handlers for some of the various address space IDs. + * Test one user-defined address space (used by aslts.) + */ +#define ACPI_ADR_SPACE_USER_DEFINED1 0x80 +#define ACPI_ADR_SPACE_USER_DEFINED2 0xE4 + +static ACPI_ADR_SPACE_TYPE SpaceIdList[] = +{ + ACPI_ADR_SPACE_EC, + ACPI_ADR_SPACE_SMBUS, + ACPI_ADR_SPACE_GSBUS, + ACPI_ADR_SPACE_GPIO, + ACPI_ADR_SPACE_PCI_BAR_TARGET, + ACPI_ADR_SPACE_IPMI, + ACPI_ADR_SPACE_FIXED_HARDWARE, + ACPI_ADR_SPACE_USER_DEFINED1, + ACPI_ADR_SPACE_USER_DEFINED2 +}; + +static ACPI_CONNECTION_INFO AeMyContext; /****************************************************************************** * @@ -170,11 +239,11 @@ AE_DEBUG_REGIONS AeRegions; * * RETURN: none * - * DESCRIPTION: Control-C handler. Abort running control method if any. + * DESCRIPTION: Control-C handler. Abort running control method if any. * *****************************************************************************/ -void __cdecl +void ACPI_SYSTEM_XFACE AeCtrlCHandler ( int Sig) { @@ -182,7 +251,7 @@ AeCtrlCHandler ( signal (SIGINT, SIG_IGN); SigintCount++; - AcpiOsPrintf ("Caught a ctrl-c (#%d)\n\n", SigintCount); + AcpiOsPrintf ("Caught a ctrl-c (#%u)\n\n", SigintCount); if (AcpiGbl_MethodExecuting) { @@ -201,24 +270,51 @@ AeCtrlCHandler ( /****************************************************************************** * - * FUNCTION: AeNotifyHandler + * FUNCTION: AeNotifyHandler(s) * * PARAMETERS: Standard notify handler parameters * * RETURN: Status * - * DESCRIPTION: System notify handler for AcpiExec utility. Used by the ASL + * DESCRIPTION: Notify handlers for AcpiExec utility. Used by the ASL * test suite(s) to communicate errors and other information to - * this utility via the Notify() operator. + * this utility via the Notify() operator. Tests notify handling + * and multiple notify handler support. * *****************************************************************************/ -void -AeNotifyHandler ( - ACPI_HANDLE Device, - UINT32 Value, - void *Context) +static void +AeNotifyHandler1 ( + ACPI_HANDLE Device, + UINT32 Value, + void *Context) +{ + AeCommonNotifyHandler (Device, Value, 1); +} + +static void +AeNotifyHandler2 ( + ACPI_HANDLE Device, + UINT32 Value, + void *Context) +{ + AeCommonNotifyHandler (Device, Value, 2); +} + +static void +AeCommonNotifyHandler ( + ACPI_HANDLE Device, + UINT32 Value, + UINT32 HandlerId) { + char *Type; + + + Type = "Device"; + if (Value <= ACPI_MAX_SYS_NOTIFY) + { + Type = "System"; + } switch (Value) { @@ -252,18 +348,51 @@ AeNotifyHandler ( #endif default: - printf ("[AcpiExec] Received a System Notify on [%4.4s] %p Value 0x%2.2X (%s)\n", - AcpiUtGetNodeName (Device), Device, Value, + printf ("[AcpiExec] Handler %u: Received a %s Notify on [%4.4s] %p Value 0x%2.2X (%s)\n", + HandlerId, Type, AcpiUtGetNodeName (Device), Device, Value, AcpiUtGetNotifyName (Value)); if (AcpiGbl_DebugFile) { - AcpiOsPrintf ("[AcpiExec] Received a system notify, Value 0x%2.2X\n", Value); + AcpiOsPrintf ("[AcpiExec] Handler %u: Received a %s notify, Value 0x%2.2X\n", + HandlerId, Type, Value); } (void) AcpiEvaluateObject (Device, "_NOT", NULL, NULL); break; } +} + + +/****************************************************************************** + * + * FUNCTION: AeSystemNotifyHandler + * + * PARAMETERS: Standard notify handler parameters + * + * RETURN: Status + * + * DESCRIPTION: System notify handler for AcpiExec utility. Used by the ASL + * test suite(s) to communicate errors and other information to + * this utility via the Notify() operator. + * + *****************************************************************************/ + +static void +AeSystemNotifyHandler ( + ACPI_HANDLE Device, + UINT32 Value, + void *Context) +{ + + printf ("[AcpiExec] Global: Received a System Notify on [%4.4s] %p Value 0x%2.2X (%s)\n", + AcpiUtGetNodeName (Device), Device, Value, + AcpiUtGetNotifyName (Value)); + if (AcpiGbl_DebugFile) + { + AcpiOsPrintf ("[AcpiExec] Global: Received a System Notify, Value 0x%2.2X\n", Value); + } + (void) AcpiEvaluateObject (Device, "_NOT", NULL, NULL); } @@ -275,25 +404,25 @@ AeNotifyHandler ( * * RETURN: Status * - * DESCRIPTION: Device notify handler for AcpiExec utility. Used by the ASL + * DESCRIPTION: Device notify handler for AcpiExec utility. Used by the ASL * test suite(s) to communicate errors and other information to * this utility via the Notify() operator. * *****************************************************************************/ -void +static void AeDeviceNotifyHandler ( ACPI_HANDLE Device, UINT32 Value, void *Context) { - printf ("[AcpiExec] Received a Device Notify on [%4.4s] %p Value 0x%2.2X (%s)\n", + printf ("[AcpiExec] Global: Received a Device Notify on [%4.4s] %p Value 0x%2.2X (%s)\n", AcpiUtGetNodeName (Device), Device, Value, AcpiUtGetNotifyName (Value)); if (AcpiGbl_DebugFile) { - AcpiOsPrintf ("[AcpiExec] Received a device notify, Value 0x%2.2X\n", Value); + AcpiOsPrintf ("[AcpiExec] Global: Received a Device Notify, Value 0x%2.2X\n", Value); } (void) AcpiEvaluateObject (Device, "_NOT", NULL, NULL); @@ -312,7 +441,7 @@ AeDeviceNotifyHandler ( * *****************************************************************************/ -ACPI_STATUS +static ACPI_STATUS AeExceptionHandler ( ACPI_STATUS AmlStatus, ACPI_NAME Name, @@ -356,7 +485,7 @@ AeExceptionHandler ( Arg[1].String.Length = ACPI_STRLEN (Exception); Arg[2].Type = ACPI_TYPE_INTEGER; - Arg[2].Integer.Value = ACPI_TO_INTEGER (AcpiOsGetThreadId()); + Arg[2].Integer.Value = AcpiOsGetThreadId(); /* Setup return buffer */ @@ -411,29 +540,32 @@ AeExceptionHandler ( * *****************************************************************************/ -char *TableEvents[] = -{ - "LOAD", - "UNLOAD", - "UNKNOWN" -}; - -ACPI_STATUS +static ACPI_STATUS AeTableHandler ( UINT32 Event, void *Table, void *Context) { +#if (!ACPI_REDUCED_HARDWARE) + ACPI_STATUS Status; +#endif /* !ACPI_REDUCED_HARDWARE */ + if (Event > ACPI_NUM_TABLE_EVENTS) { Event = ACPI_NUM_TABLE_EVENTS; } - /* TBD: could dump entire table header, need a header dump routine */ +#if (!ACPI_REDUCED_HARDWARE) + /* Enable any GPEs associated with newly-loaded GPE methods */ + + Status = AcpiUpdateAllGpes (); + AE_CHECK_OK (AcpiUpdateAllGpes, Status); printf ("[AcpiExec] Table Event %s, [%4.4s] %p\n", TableEvents[Event], ((ACPI_TABLE_HEADER *) Table)->Signature, Table); +#endif /* !ACPI_REDUCED_HARDWARE */ + return (AE_OK); } @@ -442,16 +574,61 @@ AeTableHandler ( * * FUNCTION: AeGpeHandler * - * DESCRIPTION: GPE handler for acpiexec + * DESCRIPTION: Common GPE handler for acpiexec * *****************************************************************************/ UINT32 AeGpeHandler ( + ACPI_HANDLE GpeDevice, + UINT32 GpeNumber, void *Context) { - AcpiOsPrintf ("Received a GPE at handler\n"); - return (0); + ACPI_NAMESPACE_NODE *DeviceNode = (ACPI_NAMESPACE_NODE *) GpeDevice; + + + AcpiOsPrintf ("[AcpiExec] GPE Handler received GPE%02X (GPE block %4.4s)\n", + GpeNumber, GpeDevice ? DeviceNode->Name.Ascii : "FADT"); + + return (ACPI_REENABLE_GPE); +} + + +/****************************************************************************** + * + * FUNCTION: AeGlobalEventHandler + * + * DESCRIPTION: Global GPE/Fixed event handler + * + *****************************************************************************/ + +void +AeGlobalEventHandler ( + UINT32 Type, + ACPI_HANDLE Device, + UINT32 EventNumber, + void *Context) +{ + char *TypeName; + + + switch (Type) + { + case ACPI_EVENT_TYPE_GPE: + TypeName = "GPE"; + break; + + case ACPI_EVENT_TYPE_FIXED: + TypeName = "FixedEvent"; + break; + + default: + TypeName = "UNKNOWN"; + break; + } + + AcpiOsPrintf ("[AcpiExec] Global Event Handler received: Type %s Number %.2X Dev %p\n", + TypeName, EventNumber, Device); } @@ -464,7 +641,7 @@ AeGpeHandler ( * *****************************************************************************/ -void +static void AeAttachedDataHandler ( ACPI_HANDLE Object, void *Data) @@ -477,6 +654,48 @@ AeAttachedDataHandler ( } +/****************************************************************************** + * + * FUNCTION: AeInterfaceHandler + * + * DESCRIPTION: Handler for _OSI invocations + * + *****************************************************************************/ + +static UINT32 +AeInterfaceHandler ( + ACPI_STRING InterfaceName, + UINT32 Supported) +{ + ACPI_FUNCTION_NAME (AeInterfaceHandler); + + + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Received _OSI (\"%s\"), is %ssupported\n", + InterfaceName, Supported == 0 ? "not " : "")); + + return (Supported); +} + + +#if (!ACPI_REDUCED_HARDWARE) +/****************************************************************************** + * + * FUNCTION: AeEventHandler + * + * DESCRIPTION: Handler for Fixed Events + * + *****************************************************************************/ + +static UINT32 +AeEventHandler ( + void *Context) +{ + return (0); +} +#endif /* !ACPI_REDUCED_HARDWARE */ + + /****************************************************************************** * * FUNCTION: AeRegionInit @@ -489,7 +708,7 @@ AeAttachedDataHandler ( * *****************************************************************************/ -ACPI_STATUS +static ACPI_STATUS AeRegionInit ( ACPI_HANDLE RegionHandle, UINT32 Function, @@ -501,13 +720,13 @@ AeRegionInit ( */ *RegionContext = RegionHandle; - return AE_OK; + return (AE_OK); } /****************************************************************************** * - * FUNCTION: AeInstallHandlers + * FUNCTION: AeInstallLateHandlers * * PARAMETERS: None * @@ -517,11 +736,72 @@ AeRegionInit ( * *****************************************************************************/ -ACPI_ADR_SPACE_TYPE SpaceId[] = {0, 1, 2, 3, 4, 5, 6, 7, 0x80}; -#define AEXEC_NUM_REGIONS 9 +ACPI_STATUS +AeInstallLateHandlers ( + void) +{ + ACPI_STATUS Status; + UINT32 i; + + +#if (!ACPI_REDUCED_HARDWARE) + if (!AcpiGbl_ReducedHardware) + { + /* Install some fixed event handlers */ + + Status = AcpiInstallFixedEventHandler (ACPI_EVENT_GLOBAL, AeEventHandler, NULL); + AE_CHECK_OK (AcpiInstallFixedEventHandler, Status); + + Status = AcpiInstallFixedEventHandler (ACPI_EVENT_RTC, AeEventHandler, NULL); + AE_CHECK_OK (AcpiInstallFixedEventHandler, Status); + } +#endif /* !ACPI_REDUCED_HARDWARE */ + + AeMyContext.Connection = NULL; + AeMyContext.AccessLength = 0xA5; + + /* + * Install handlers for some of the "device driver" address spaces + * such as EC, SMBus, etc. + */ + for (i = 0; i < ACPI_ARRAY_LENGTH (SpaceIdList); i++) + { + /* Install handler at the root object */ + + Status = AcpiInstallAddressSpaceHandler (AcpiGbl_RootNode, + SpaceIdList[i], AeRegionHandler, + AeRegionInit, &AeMyContext); + if (ACPI_FAILURE (Status)) + { + ACPI_EXCEPTION ((AE_INFO, Status, + "Could not install an OpRegion handler for %s space(%u)", + AcpiUtGetRegionName((UINT8) SpaceIdList[i]), SpaceIdList[i])); + return (Status); + } + } + + return (AE_OK); +} + + +/****************************************************************************** + * + * FUNCTION: AeInstallEarlyHandlers + * + * PARAMETERS: None + * + * RETURN: Status + * + * DESCRIPTION: Install handlers for the AcpiExec utility. + * + * Notes: Don't install handler for PCI_Config, we want to use the + * default handler to exercise that code. + * + *****************************************************************************/ ACPI_STATUS -AeInstallHandlers (void) +AeInstallEarlyHandlers ( + void) { ACPI_STATUS Status; UINT32 i; @@ -531,6 +811,13 @@ AeInstallHandlers (void) ACPI_FUNCTION_ENTRY (); + Status = AcpiInstallInterfaceHandler (AeInterfaceHandler); + if (ACPI_FAILURE (Status)) + { + printf ("Could not install interface handler, %s\n", + AcpiFormatException (Status)); + } + Status = AcpiInstallTableHandler (AeTableHandler, NULL); if (ACPI_FAILURE (Status)) { @@ -545,18 +832,18 @@ AeInstallHandlers (void) AcpiFormatException (Status)); } - /* Install global notify handler */ + /* Install global notify handlers */ Status = AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY, - AeNotifyHandler, NULL); + AeSystemNotifyHandler, NULL); if (ACPI_FAILURE (Status)) { - printf ("Could not install a global notify handler, %s\n", + printf ("Could not install a global system notify handler, %s\n", AcpiFormatException (Status)); } Status = AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_DEVICE_NOTIFY, - AeDeviceNotifyHandler, NULL); + AeDeviceNotifyHandler, NULL); if (ACPI_FAILURE (Status)) { printf ("Could not install a global notify handler, %s\n", @@ -567,7 +854,7 @@ AeInstallHandlers (void) if (ACPI_SUCCESS (Status)) { Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY, - AeNotifyHandler, NULL); + AeNotifyHandler1, NULL); if (ACPI_FAILURE (Status)) { printf ("Could not install a notify handler, %s\n", @@ -575,7 +862,7 @@ AeInstallHandlers (void) } Status = AcpiRemoveNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY, - AeNotifyHandler); + AeNotifyHandler1); if (ACPI_FAILURE (Status)) { printf ("Could not remove a notify handler, %s\n", @@ -583,43 +870,99 @@ AeInstallHandlers (void) } Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY, - AeNotifyHandler, NULL); + AeNotifyHandler1, NULL); + AE_CHECK_OK (AcpiInstallNotifyHandler, Status); + Status = AcpiRemoveNotifyHandler (Handle, ACPI_ALL_NOTIFY, - AeNotifyHandler); + AeNotifyHandler1); + AE_CHECK_OK (AcpiRemoveNotifyHandler, Status); + +#if 0 Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY, - AeNotifyHandler, NULL); + AeNotifyHandler1, NULL); if (ACPI_FAILURE (Status)) { printf ("Could not install a notify handler, %s\n", AcpiFormatException (Status)); } +#endif + + /* Install two handlers for _SB_ */ + + Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY, + AeNotifyHandler1, ACPI_CAST_PTR (void, 0x01234567)); + + Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY, + AeNotifyHandler2, ACPI_CAST_PTR (void, 0x89ABCDEF)); + + /* Attempt duplicate handler installation, should fail */ + + Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY, + AeNotifyHandler1, ACPI_CAST_PTR (void, 0x77777777)); Status = AcpiAttachData (Handle, AeAttachedDataHandler, Handle); + AE_CHECK_OK (AcpiAttachData, Status); + Status = AcpiDetachData (Handle, AeAttachedDataHandler); + AE_CHECK_OK (AcpiDetachData, Status); + Status = AcpiAttachData (Handle, AeAttachedDataHandler, Handle); + AE_CHECK_OK (AcpiAttachData, Status); } else { printf ("No _SB_ found, %s\n", AcpiFormatException (Status)); } - /* Set a handler for all supported operation regions */ - for (i = 0; i < AEXEC_NUM_REGIONS; i++) + Status = AcpiGetHandle (NULL, "\\_TZ.TZ1", &Handle); + if (ACPI_SUCCESS (Status)) { - Status = AcpiRemoveAddressSpaceHandler (AcpiGbl_RootNode, - SpaceId[i], AeRegionHandler); + Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY, + AeNotifyHandler1, ACPI_CAST_PTR (void, 0x01234567)); + + Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY, + AeNotifyHandler2, ACPI_CAST_PTR (void, 0x89ABCDEF)); + + Status = AcpiRemoveNotifyHandler (Handle, ACPI_ALL_NOTIFY, + AeNotifyHandler1); + Status = AcpiRemoveNotifyHandler (Handle, ACPI_ALL_NOTIFY, + AeNotifyHandler2); + + Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY, + AeNotifyHandler2, ACPI_CAST_PTR (void, 0x89ABCDEF)); + + Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY, + AeNotifyHandler1, ACPI_CAST_PTR (void, 0x01234567)); + } + + Status = AcpiGetHandle (NULL, "\\_PR.CPU0", &Handle); + if (ACPI_SUCCESS (Status)) + { + Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY, + AeNotifyHandler1, ACPI_CAST_PTR (void, 0x01234567)); + + Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY, + AeNotifyHandler2, ACPI_CAST_PTR (void, 0x89ABCDEF)); + } + + /* + * Install handlers that will override the default handlers for some of + * the space IDs. + */ + for (i = 0; i < ACPI_ARRAY_LENGTH (DefaultSpaceIdList); i++) + { + /* Install handler at the root object */ - /* Install handler at the root object. - * TBD: all default handlers should be installed here! - */ Status = AcpiInstallAddressSpaceHandler (AcpiGbl_RootNode, - SpaceId[i], AeRegionHandler, AeRegionInit, NULL); + DefaultSpaceIdList[i], AeRegionHandler, + AeRegionInit, &AeMyContext); if (ACPI_FAILURE (Status)) { ACPI_EXCEPTION ((AE_INFO, Status, - "Could not install an OpRegion handler for %s space(%d)", - AcpiUtGetRegionName((UINT8) SpaceId[i]), SpaceId[i])); + "Could not install a default OpRegion handler for %s space(%u)", + AcpiUtGetRegionName ((UINT8) DefaultSpaceIdList[i]), + DefaultSpaceIdList[i])); return (Status); } } @@ -630,8 +973,7 @@ AeInstallHandlers (void) */ AeRegions.NumberOfRegions = 0; AeRegions.RegionList = NULL; - - return Status; + return (Status); } @@ -653,7 +995,7 @@ AeRegionHandler ( UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, - ACPI_INTEGER *Value, + UINT64 *Value, void *HandlerContext, void *RegionContext) { @@ -669,6 +1011,10 @@ AeRegionHandler ( UINT32 ByteWidth; UINT32 i; UINT8 SpaceId; + ACPI_CONNECTION_INFO *MyContext; + UINT32 Value1; + UINT32 Value2; + ACPI_RESOURCE *Resource; ACPI_FUNCTION_NAME (AeRegionHandler); @@ -678,11 +1024,33 @@ AeRegionHandler ( */ if (RegionObject->Region.Type != ACPI_TYPE_REGION) { - return AE_OK; + return (AE_OK); + } + + /* Check that we actually got back our context parameter */ + + if (HandlerContext != &AeMyContext) + { + printf ("Region handler received incorrect context %p, should be %p\n", + HandlerContext, &AeMyContext); } + MyContext = ACPI_CAST_PTR (ACPI_CONNECTION_INFO, HandlerContext); + /* - * Region support can be disabled with the -r option. + * Find the region's address space and length before searching + * the linked list. + */ + BaseAddress = RegionObject->Region.Address; + Length = (ACPI_SIZE) RegionObject->Region.Length; + SpaceId = RegionObject->Region.SpaceId; + + ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, "Operation Region request on %s at 0x%X\n", + AcpiUtGetRegionName (RegionObject->Region.SpaceId), + (UINT32) Address)); + + /* + * Region support can be disabled with the -do option. * We use this to support dynamically loaded tables where we pass a valid * address to the AML. */ @@ -698,32 +1066,52 @@ AeRegionHandler ( goto DoFunction; } - /* - * Find the region's address space and length before searching - * the linked list. - */ - BaseAddress = RegionObject->Region.Address; - Length = (ACPI_SIZE) RegionObject->Region.Length; - SpaceId = RegionObject->Region.SpaceId; - - ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, "Operation Region request on %s at 0x%X\n", - AcpiUtGetRegionName (RegionObject->Region.SpaceId), - (UINT32) Address)); - switch (SpaceId) { case ACPI_ADR_SPACE_SYSTEM_IO: /* * For I/O space, exercise the port validation + * Note: ReadPort currently always returns all ones, length=BitLength */ switch (Function & ACPI_IO_MASK) { case ACPI_READ: - Status = AcpiHwReadPort (Address, (UINT32 *) Value, BitWidth); + + if (BitWidth == 64) + { + /* Split the 64-bit request into two 32-bit requests */ + + Status = AcpiHwReadPort (Address, &Value1, 32); + AE_CHECK_OK (AcpiHwReadPort, Status); + Status = AcpiHwReadPort (Address+4, &Value2, 32); + AE_CHECK_OK (AcpiHwReadPort, Status); + + *Value = Value1 | ((UINT64) Value2 << 32); + } + else + { + Status = AcpiHwReadPort (Address, &Value1, BitWidth); + AE_CHECK_OK (AcpiHwReadPort, Status); + *Value = (UINT64) Value1; + } break; case ACPI_WRITE: - Status = AcpiHwWritePort (Address, (UINT32) *Value, BitWidth); + + if (BitWidth == 64) + { + /* Split the 64-bit request into two 32-bit requests */ + + Status = AcpiHwWritePort (Address, ACPI_LODWORD (*Value), 32); + AE_CHECK_OK (AcpiHwWritePort, Status); + Status = AcpiHwWritePort (Address+4, ACPI_HIDWORD (*Value), 32); + AE_CHECK_OK (AcpiHwWritePort, Status); + } + else + { + Status = AcpiHwWritePort (Address, (UINT32) *Value, BitWidth); + AE_CHECK_OK (AcpiHwWritePort, Status); + } break; default: @@ -739,8 +1127,12 @@ AeRegionHandler ( /* Now go ahead and simulate the hardware */ break; - + /* + * SMBus and GenericSerialBus support the various bidirectional + * protocols. + */ case ACPI_ADR_SPACE_SMBUS: + case ACPI_ADR_SPACE_GSBUS: /* ACPI 5.0 */ Length = 0; @@ -749,22 +1141,31 @@ AeRegionHandler ( case ACPI_READ: switch (Function >> 16) { - case AML_FIELD_ATTRIB_SMB_QUICK: - case AML_FIELD_ATTRIB_SMB_SEND_RCV: - case AML_FIELD_ATTRIB_SMB_BYTE: + case AML_FIELD_ATTRIB_QUICK: + case AML_FIELD_ATTRIB_SEND_RCV: + case AML_FIELD_ATTRIB_BYTE: Length = 1; break; - case AML_FIELD_ATTRIB_SMB_WORD: - case AML_FIELD_ATTRIB_SMB_WORD_CALL: + case AML_FIELD_ATTRIB_WORD: + case AML_FIELD_ATTRIB_WORD_CALL: Length = 2; break; - case AML_FIELD_ATTRIB_SMB_BLOCK: - case AML_FIELD_ATTRIB_SMB_BLOCK_CALL: + case AML_FIELD_ATTRIB_BLOCK: + case AML_FIELD_ATTRIB_BLOCK_CALL: Length = 32; break; + + case AML_FIELD_ATTRIB_MULTIBYTE: + case AML_FIELD_ATTRIB_RAW_BYTES: + case AML_FIELD_ATTRIB_RAW_PROCESS: + + /* (-2) for status/length */ + Length = MyContext->AccessLength - 2; + break; + default: break; } @@ -773,22 +1174,30 @@ AeRegionHandler ( case ACPI_WRITE: switch (Function >> 16) { - case AML_FIELD_ATTRIB_SMB_QUICK: - case AML_FIELD_ATTRIB_SMB_SEND_RCV: - case AML_FIELD_ATTRIB_SMB_BYTE: - case AML_FIELD_ATTRIB_SMB_WORD: - case AML_FIELD_ATTRIB_SMB_BLOCK: + case AML_FIELD_ATTRIB_QUICK: + case AML_FIELD_ATTRIB_SEND_RCV: + case AML_FIELD_ATTRIB_BYTE: + case AML_FIELD_ATTRIB_WORD: + case AML_FIELD_ATTRIB_BLOCK: Length = 0; break; - case AML_FIELD_ATTRIB_SMB_WORD_CALL: + case AML_FIELD_ATTRIB_WORD_CALL: Length = 2; break; - case AML_FIELD_ATTRIB_SMB_BLOCK_CALL: + case AML_FIELD_ATTRIB_BLOCK_CALL: Length = 32; break; + case AML_FIELD_ATTRIB_MULTIBYTE: + case AML_FIELD_ATTRIB_RAW_BYTES: + case AML_FIELD_ATTRIB_RAW_PROCESS: + + /* (-2) for status/length */ + Length = MyContext->AccessLength - 2; + break; + default: break; } @@ -798,6 +1207,31 @@ AeRegionHandler ( break; } + if (AcpiGbl_DisplayRegionAccess) + { + AcpiOsPrintf ("AcpiExec: %s " + "%s: Attr %X Addr %.4X BaseAddr %.4X Len %.2X Width %X BufLen %X", + AcpiUtGetRegionName (SpaceId), + (Function & ACPI_IO_MASK) ? "Write" : "Read ", + (UINT32) (Function >> 16), + (UINT32) Address, (UINT32) BaseAddress, + Length, BitWidth, Buffer[1]); + + /* GenericSerialBus has a Connection() parameter */ + + if (SpaceId == ACPI_ADR_SPACE_GSBUS) + { + Status = AcpiBufferToResource (MyContext->Connection, + MyContext->Length, &Resource); + + AcpiOsPrintf (" [AccLen %.2X Conn %p]", + MyContext->AccessLength, MyContext->Connection); + } + AcpiOsPrintf ("\n"); + } + + /* Setup the return buffer. Note: ASLTS depends on these fill values */ + for (i = 0; i < Length; i++) { Buffer[i+2] = (UINT8) (0xA0 + i); @@ -810,10 +1244,14 @@ AeRegionHandler ( case ACPI_ADR_SPACE_IPMI: /* ACPI 4.0 */ - AcpiOsPrintf ("AcpiExec: Received IPMI request: " - "Address %X BaseAddress %X Length %X Width %X BufferLength %u\n", - (UINT32) Address, (UINT32) BaseAddress, - Length, BitWidth, Buffer[1]); + if (AcpiGbl_DisplayRegionAccess) + { + AcpiOsPrintf ("AcpiExec: IPMI " + "%s: Attr %X Addr %.4X BaseAddr %.4X Len %.2X Width %X BufLen %X\n", + (Function & ACPI_IO_MASK) ? "Write" : "Read ", + (UINT32) (Function >> 16), (UINT32) Address, (UINT32) BaseAddress, + Length, BitWidth, Buffer[1]); + } /* * Regardless of a READ or WRITE, this handler is passed a 66-byte @@ -824,9 +1262,16 @@ AeRegionHandler ( Buffer[0] = 0; /* Status byte */ Buffer[1] = 64; /* Return buffer data length */ Buffer[2] = 0; /* Completion code */ - Buffer[3] = 0x34; /* Power measurement */ - Buffer[4] = 0x12; /* Power measurement */ - Buffer[65] = 0xEE; /* last buffer byte */ + Buffer[3] = 0; /* Reserved */ + + /* + * Fill the 66-byte buffer with the return data. + * Note: ASLTS depends on these fill values. + */ + for (i = 4; i < 66; i++) + { + Buffer[i] = (UINT8) (i); + } return (AE_OK); default: @@ -867,14 +1312,14 @@ AeRegionHandler ( RegionElement = AcpiOsAllocate (sizeof (AE_REGION)); if (!RegionElement) { - return AE_NO_MEMORY; + return (AE_NO_MEMORY); } RegionElement->Buffer = AcpiOsAllocate (Length); if (!RegionElement->Buffer) { AcpiOsFree (RegionElement); - return AE_NO_MEMORY; + return (AE_NO_MEMORY); } /* Initialize the region with the default fill value */ @@ -918,26 +1363,25 @@ AeRegionHandler ( * NOTE: RegionElement->Length is in bytes, therefore it we compare against * ByteWidth (see above) */ - if (((ACPI_INTEGER) Address + ByteWidth) > - ((ACPI_INTEGER)(RegionElement->Address) + RegionElement->Length)) + if (((UINT64) Address + ByteWidth) > + ((UINT64)(RegionElement->Address) + RegionElement->Length)) { ACPI_WARNING ((AE_INFO, - "Request on [%4.4s] is beyond region limit Req-%X+%X, Base=%X, Len-%X", + "Request on [%4.4s] is beyond region limit Req-0x%X+0x%X, Base=0x%X, Len-0x%X", (RegionObject->Region.Node)->Name.Ascii, (UINT32) Address, ByteWidth, (UINT32)(RegionElement->Address), RegionElement->Length)); - return AE_AML_REGION_LIMIT; + return (AE_AML_REGION_LIMIT); } /* * Get BufferValue to point to the "address" in the buffer */ BufferValue = ((UINT8 *) RegionElement->Buffer + - ((ACPI_INTEGER) Address - (ACPI_INTEGER) RegionElement->Address)); + ((UINT64) Address - (UINT64) RegionElement->Address)); DoFunction: - /* * Perform a read or write to the buffer space */ @@ -958,9 +1402,39 @@ DoFunction: break; default: - return AE_BAD_PARAMETER; + return (AE_BAD_PARAMETER); } - return AE_OK; -} + if (AcpiGbl_DisplayRegionAccess) + { + switch (SpaceId) + { + case ACPI_ADR_SPACE_SYSTEM_MEMORY: + + AcpiOsPrintf ("AcpiExec: SystemMemory " + "%s: Val %.8X Addr %.4X Width %X [REGION: BaseAddr %.4X Len %.2X]\n", + (Function & ACPI_IO_MASK) ? "Write" : "Read ", + (UINT32) *Value, (UINT32) Address, BitWidth, (UINT32) BaseAddress, Length); + break; + + case ACPI_ADR_SPACE_GPIO: /* ACPI 5.0 */ + + /* This space is required to always be ByteAcc */ + + Status = AcpiBufferToResource (MyContext->Connection, + MyContext->Length, &Resource); + AcpiOsPrintf ("AcpiExec: GeneralPurposeIo " + "%s: Val %.8X Addr %.4X BaseAddr %.4X Len %.2X Width %X AccLen %.2X Conn %p\n", + (Function & ACPI_IO_MASK) ? "Write" : "Read ", (UINT32) *Value, + (UINT32) Address, (UINT32) BaseAddress, Length, BitWidth, + MyContext->AccessLength, MyContext->Connection); + break; + + default: + break; + } + } + + return (AE_OK); +}