ACPI_STATUS
AcpiEnableSubsystem (
UINT32 Flags)
{
ACPI_STATUS Status = AE_OK;
ACPI_FUNCTION_TRACE (AcpiEnableSubsystem);
/*
* The early initialization phase is complete. The namespace is loaded,
* and we can now support address spaces other than Memory, I/O, and
* PCI_Config.
*/
AcpiGbl_EarlyInitialization = FALSE;
/*
* Install the default operation region handlers. These are the
* handlers that are defined by the ACPI specification to be
* "always accessible" -- namely, SystemMemory, SystemIO, and
* PCI_Config. This also means that no _REG methods need to be
* run for these address spaces. We need to have these handlers
* installed before any AML code can be executed, especially any
* module-level code (11/2015).
*/
if (!AcpiGbl_GroupModuleLevelCode)
{
Status = AcpiEvInstallRegionHandlers ();
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "During Region initialization"));
return_ACPI_STATUS (Status);
}
}
#if (!ACPI_REDUCED_HARDWARE)
/* Enable ACPI mode */
if (!(Flags & ACPI_NO_ACPI_ENABLE))
{
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Going into ACPI mode\n"));
AcpiGbl_OriginalMode = AcpiHwGetMode();
Status = AcpiEnable ();
if (ACPI_FAILURE (Status))
{
ACPI_WARNING ((AE_INFO, "AcpiEnable failed"));
return_ACPI_STATUS (Status);
}
}
/*
* Obtain a permanent mapping for the FACS. This is required for the
* Global Lock and the Firmware Waking Vector
*/
if (!(Flags & ACPI_NO_FACS_INIT))
{
Status = AcpiTbInitializeFacs ();
if (ACPI_FAILURE (Status))
{
ACPI_WARNING ((AE_INFO, "Could not map the FACS table"));
return_ACPI_STATUS (Status);
}
}
/*
* Initialize ACPI Event handling (Fixed and General Purpose)
*
* Note1: We must have the hardware and events initialized before we can
* execute any control methods safely. Any control method can require
* ACPI hardware support, so the hardware must be fully initialized before
* any method execution!
*
* Note2: Fixed events are initialized and enabled here. GPEs are
* initialized, but cannot be enabled until after the hardware is
* completely initialized (SCI and GlobalLock activated) and the various
* initialization control methods are run (_REG, _STA, _INI) on the
* entire namespace.
*/
if (!(Flags & ACPI_NO_EVENT_INIT))
{
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Initializing ACPI events\n"));
Status = AcpiEvInitializeEvents ();
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
/*
* Install the SCI handler and Global Lock handler. This completes the
* hardware initialization.
*/
if (!(Flags & ACPI_NO_HANDLER_INIT))
{
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Installing SCI/GL handlers\n"));
Status = AcpiEvInstallXruptHandlers ();
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
#endif /* !ACPI_REDUCED_HARDWARE */
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiEnableSubsystem (
UINT32 Flags)
{
ACPI_STATUS Status = AE_OK;
ACPI_FUNCTION_TRACE (AcpiEnableSubsystem);
#if (!ACPI_REDUCED_HARDWARE)
/* Enable ACPI mode */
if (!(Flags & ACPI_NO_ACPI_ENABLE))
{
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Going into ACPI mode\n"));
AcpiGbl_OriginalMode = AcpiHwGetMode();
Status = AcpiEnable ();
if (ACPI_FAILURE (Status))
{
ACPI_WARNING ((AE_INFO, "AcpiEnable failed"));
return_ACPI_STATUS (Status);
}
}
/*
* Obtain a permanent mapping for the FACS. This is required for the
* Global Lock and the Firmware Waking Vector
*/
Status = AcpiTbInitializeFacs ();
if (ACPI_FAILURE (Status))
{
ACPI_WARNING ((AE_INFO, "Could not map the FACS table"));
return_ACPI_STATUS (Status);
}
#endif /* !ACPI_REDUCED_HARDWARE */
/*
* Install the default OpRegion handlers. These are installed unless
* other handlers have already been installed via the
* InstallAddressSpaceHandler interface.
*/
if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
{
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Installing default address space handlers\n"));
Status = AcpiEvInstallRegionHandlers ();
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
#if (!ACPI_REDUCED_HARDWARE)
/*
* Initialize ACPI Event handling (Fixed and General Purpose)
*
* Note1: We must have the hardware and events initialized before we can
* execute any control methods safely. Any control method can require
* ACPI hardware support, so the hardware must be fully initialized before
* any method execution!
*
* Note2: Fixed events are initialized and enabled here. GPEs are
* initialized, but cannot be enabled until after the hardware is
* completely initialized (SCI and GlobalLock activated) and the various
* initialization control methods are run (_REG, _STA, _INI) on the
* entire namespace.
*/
if (!(Flags & ACPI_NO_EVENT_INIT))
{
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Initializing ACPI events\n"));
Status = AcpiEvInitializeEvents ();
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
/*
* Install the SCI handler and Global Lock handler. This completes the
* hardware initialization.
*/
if (!(Flags & ACPI_NO_HANDLER_INIT))
{
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Installing SCI/GL handlers\n"));
Status = AcpiEvInstallXruptHandlers ();
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
#endif /* !ACPI_REDUCED_HARDWARE */
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiInitializeSubsystem (
void)
{
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE (AcpiInitializeSubsystem);
AcpiGbl_StartupFlags = ACPI_SUBSYSTEM_INITIALIZE;
ACPI_DEBUG_EXEC (AcpiUtInitStackPtrTrace ());
/* Initialize the OS-Dependent layer */
Status = AcpiOsInitialize ();
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "During OSL initialization"));
return_ACPI_STATUS (Status);
}
/* Initialize all globals used by the subsystem */
Status = AcpiUtInitGlobals ();
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "During initialization of globals"));
return_ACPI_STATUS (Status);
}
/* Create the default mutex objects */
Status = AcpiUtMutexInitialize ();
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "During Global Mutex creation"));
return_ACPI_STATUS (Status);
}
/*
* Initialize the namespace manager and
* the root of the namespace tree
*/
Status = AcpiNsRootInitialize ();
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "During Namespace initialization"));
return_ACPI_STATUS (Status);
}
/* Initialize the global OSI interfaces list with the static names */
Status = AcpiUtInitializeInterfaces ();
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "During OSI interfaces initialization"));
return_ACPI_STATUS (Status);
}
if (!AcpiGbl_OverrideDefaultRegionHandlers)
{
/*
* Install the default operation region handlers. These are the
* handlers that are defined by the ACPI specification to be
* "always accessible" -- namely, SystemMemory, SystemIO, and
* PCI_Config. This also means that no _REG methods need to be
* run for these address spaces. We need to have these handlers
* installed before any AML code can be executed, especially any
* module-level code (11/2015).
*/
Status = AcpiEvInstallRegionHandlers ();
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "During Region initialization"));
return_ACPI_STATUS (Status);
}
}
return_ACPI_STATUS (AE_OK);
}
ACPI_STATUS
AcpiLoadTables (
void)
{
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE (AcpiLoadTables);
/*
* Install the default operation region handlers. These are the
* handlers that are defined by the ACPI specification to be
* "always accessible" -- namely, SystemMemory, SystemIO, and
* PCI_Config. This also means that no _REG methods need to be
* run for these address spaces. We need to have these handlers
* installed before any AML code can be executed, especially any
* module-level code (11/2015).
* Note that we allow OSPMs to install their own region handlers
* between AcpiInitializeSubsystem() and AcpiLoadTables() to use
* their customized default region handlers.
*/
Status = AcpiEvInstallRegionHandlers ();
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "During Region initialization"));
return_ACPI_STATUS (Status);
}
/* Load the namespace from the tables */
Status = AcpiTbLoadNamespace ();
/* Don't let single failures abort the load */
if (Status == AE_CTRL_TERMINATE)
{
Status = AE_OK;
}
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status,
"While loading namespace from ACPI tables"));
}
if (!AcpiGbl_GroupModuleLevelCode)
{
/*
* Initialize the objects that remain uninitialized. This
* runs the executable AML that may be part of the
* declaration of these objects:
* OperationRegions, BufferFields, Buffers, and Packages.
*/
Status = AcpiNsInitializeObjects ();
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
AcpiGbl_NamespaceInitialized = TRUE;
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiEnableSubsystem (
UINT32 Flags)
{
ACPI_STATUS Status = AE_OK;
ACPI_FUNCTION_TRACE (AcpiEnableSubsystem);
/* Enable ACPI mode */
if (!(Flags & ACPI_NO_ACPI_ENABLE))
{
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Going into ACPI mode\n"));
AcpiGbl_OriginalMode = AcpiHwGetMode();
Status = AcpiEnable ();
if (ACPI_FAILURE (Status))
{
ACPI_WARNING ((AE_INFO, "AcpiEnable failed"));
return_ACPI_STATUS (Status);
}
}
/*
* Install the default OpRegion handlers. These are installed unless
* other handlers have already been installed via the
* InstallAddressSpaceHandler interface.
*/
if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
{
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Installing default address space handlers\n"));
Status = AcpiEvInstallRegionHandlers ();
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
/*
* Initialize ACPI Event handling (Fixed and General Purpose)
*
* Note1: We must have the hardware and events initialized before we can
* execute any control methods safely. Any control method can require
* ACPI hardware support, so the hardware must be fully initialized before
* any method execution!
*
* Note2: Fixed events are initialized and enabled here. GPEs are
* initialized, but cannot be enabled until after the hardware is
* completely initialized (SCI and GlobalLock activated)
*/
if (!(Flags & ACPI_NO_EVENT_INIT))
{
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Initializing ACPI events\n"));
Status = AcpiEvInitializeEvents ();
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
/*
* Install the SCI handler and Global Lock handler. This completes the
* hardware initialization.
*/
if (!(Flags & ACPI_NO_HANDLER_INIT))
{
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Installing SCI/GL handlers\n"));
Status = AcpiEvInstallXruptHandlers ();
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
/*
* Complete the GPE initialization for the GPE blocks defined in the FADT
* (GPE block 0 and 1).
*
* Note1: This is where the _PRW methods are executed for the GPEs. These
* methods can only be executed after the SCI and Global Lock handlers are
* installed and initialized.
*
* Note2: Currently, there seems to be no need to run the _REG methods
* before execution of the _PRW methods and enabling of the GPEs.
*/
if (!(Flags & ACPI_NO_EVENT_INIT))
{
Status = AcpiEvInstallFadtGpes ();
if (ACPI_FAILURE (Status))
{
return (Status);
}
}
return_ACPI_STATUS (Status);
}
