ACPI_STATUS
AeInstallTables (
void)
{
ACPI_STATUS Status;
ACPI_TABLE_HEADER Header;
ACPI_TABLE_HEADER *Table;
Status = AcpiInitializeTables (Tables, ACPI_MAX_INIT_TABLES, TRUE);
AE_CHECK_OK (AcpiInitializeTables, Status);
Status = AcpiReallocateRootTable ();
AE_CHECK_OK (AcpiReallocateRootTable, Status);
Status = AcpiLoadTables ();
AE_CHECK_OK (AcpiLoadTables, Status);
/*
* Test run-time control method installation. Do it twice to test code
* for an existing name.
*/
Status = AcpiInstallMethod (MethodCode);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s, Could not install method\n",
AcpiFormatException (Status));
}
Status = AcpiInstallMethod (MethodCode);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s, Could not install method\n",
AcpiFormatException (Status));
}
/* Test multiple table/UEFI support. First, get the headers */
Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 1, &Header);
AE_CHECK_OK (AcpiGetTableHeader, Status);
Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 2, &Header);
AE_CHECK_OK (AcpiGetTableHeader, Status);
Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 3, &Header);
AE_CHECK_STATUS (AcpiGetTableHeader, Status, AE_NOT_FOUND);
/* Now get the actual tables */
Status = AcpiGetTable (ACPI_SIG_UEFI, 1, &Table);
AE_CHECK_OK (AcpiGetTable, Status);
Status = AcpiGetTable (ACPI_SIG_UEFI, 2, &Table);
AE_CHECK_OK (AcpiGetTable, Status);
Status = AcpiGetTable (ACPI_SIG_UEFI, 3, &Table);
AE_CHECK_STATUS (AcpiGetTable, Status, AE_NOT_FOUND);
return (AE_OK);
}
int
_init(void)
{
int error = EBUSY;
int status;
extern int (*acpi_fp_setwake)();
extern kmutex_t cpu_map_lock;
mutex_init(&acpica_module_lock, NULL, MUTEX_DRIVER, NULL);
mutex_init(&cpu_map_lock, NULL, MUTEX_SPIN,
(ddi_iblock_cookie_t)ipltospl(DISP_LEVEL));
if ((error = mod_install(&modlinkage)) != 0) {
mutex_destroy(&acpica_module_lock);
goto load_error;
}
AcpiGbl_EnableInterpreterSlack = (acpica_enable_interpreter_slack != 0);
/* global ACPI CA initialization */
if (ACPI_FAILURE(status = AcpiInitializeSubsystem()))
cmn_err(CE_WARN, "!AcpiInitializeSubsystem failed: %d", status);
/* initialize table manager */
if (ACPI_FAILURE(status = AcpiInitializeTables(NULL, 0, 0)))
cmn_err(CE_WARN, "!AcpiInitializeTables failed: %d", status);
acpi_fp_setwake = acpica_ddi_setwake;
load_error:
return (error);
}
/* Early ACPI Table Access */
int acpitables_init(void)
{
kprintf("acpitables_init()\n");
ACPI_STATUS r;
ACPI_TABLE_HEADER *hdr;
if (ACPI_FAILURE(r = AcpiInitializeTables(NULL, 16, FALSE)))
panic("acpi: AcpiInitializeTables failed: %s", AcpiFormatException(r));
// Get the MADT
r = AcpiGetTable((char*)ACPI_SIG_MADT, 0, &hdr);
if (ACPI_FAILURE(r) && r != AE_NOT_FOUND)
panic("acpi: AcpiGetTable failed: %s", AcpiFormatException(r));
if (r == AE_OK)
hdr_madt = (ACPI_TABLE_MADT*)hdr;
// Get the SRAT
r = AcpiGetTable((char*)ACPI_SIG_SRAT, 0, &hdr);
if (ACPI_FAILURE(r) && r != AE_NOT_FOUND)
panic("acpi: AcpiGetTable failed: %s", AcpiFormatException(r));
if (r == AE_OK)
hdr_srat = (ACPI_TABLE_SRAT*)hdr;
// Get the DMAR (DMA remapping reporting table)
r = AcpiGetTable((char*)ACPI_SIG_DMAR, 0, &hdr);
if (ACPI_FAILURE(r) && r != AE_NOT_FOUND)
panic("acpi: AcpiGetTable failed: %s", AcpiFormatException(r));
if (r == AE_OK)
hdr_dmar = (ACPI_TABLE_DMAR*)hdr;
table_inited = 1;
return 0;
}
PRIVATE ACPI_STATUS init_acpica(void)
{
ACPI_STATUS status;
status = AcpiInitializeSubsystem();
if (ACPI_FAILURE(status))
return status;
status = AcpiInitializeTables(NULL, 16, FALSE);
if (ACPI_FAILURE(status))
return status;
status = AcpiLoadTables();
if (ACPI_FAILURE(status))
return status;
status = AcpiEnableSubsystem(0);
if (ACPI_FAILURE(status))
return status;
status = AcpiInitializeObjects(0);
if (ACPI_FAILURE(status))
return status;
set_machine_mode();
pci_scan_devices();
return AE_OK;
}
bool acpi_tables_init(void) {
ACPI_STATUS result = AcpiInitializeTables(_acpi_tables, ACPI_MAX_INIT_TABLES, TRUE);
if(ACPI_FAILURE(result)) {
acpi_perror("AcpiInitializeTables", result);
return false;
}
_acpi_tables_loaded = true;
return true;
}
ACPI_STATUS
AeInstallTables (
void)
{
ACPI_STATUS Status;
ACPI_TABLE_HEADER Header;
ACPI_TABLE_HEADER *Table;
UINT32 i;
Status = AcpiInitializeTables (NULL, ACPI_MAX_INIT_TABLES, TRUE);
ACPI_CHECK_OK (AcpiInitializeTables, Status);
if (AcpiGbl_LoadTestTables)
{
/* Test multiple table/UEFI support. First, get the headers */
Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 1, &Header);
ACPI_CHECK_OK (AcpiGetTableHeader, Status);
Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 2, &Header);
ACPI_CHECK_OK (AcpiGetTableHeader, Status);
Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 3, &Header);
ACPI_CHECK_STATUS (AcpiGetTableHeader, Status, AE_NOT_FOUND);
/* Now get the actual tables */
Status = AcpiGetTable (ACPI_SIG_UEFI, 1, &Table);
ACPI_CHECK_OK (AcpiGetTable, Status);
Status = AcpiGetTable (ACPI_SIG_UEFI, 2, &Table);
ACPI_CHECK_OK (AcpiGetTable, Status);
Status = AcpiGetTable (ACPI_SIG_UEFI, 3, &Table);
ACPI_CHECK_STATUS (AcpiGetTable, Status, AE_NOT_FOUND);
}
/* Check that we can get all of the ACPI tables */
for (i = 0; ; i++)
{
Status = AcpiGetTableByIndex (i, &Table);
if ((Status == AE_BAD_PARAMETER) || !Table)
{
break;
}
ACPI_CHECK_OK (AcpiGetTableByIndex, Status);
}
return (AE_OK);
}
/*
* This function would be called early in kernel initialization. After this
* is called, all ACPI tables are available to the host.
*/
ACPI_STATUS
InitializeAcpiTables (
void)
{
ACPI_STATUS Status;
/* Initialize the ACPICA Table Manager and get all ACPI tables */
Status = AcpiInitializeTables (TableArray, ACPI_MAX_INIT_TABLES, TRUE);
return (Status);
}
NTSTATUS
Bus_StartFdo (
PFDO_DEVICE_DATA FdoData,
PIRP Irp )
{
NTSTATUS status = STATUS_SUCCESS;
POWER_STATE powerState;
ACPI_STATUS AcpiStatus;
PAGED_CODE ();
FdoData->Common.DevicePowerState = PowerDeviceD0;
powerState.DeviceState = PowerDeviceD0;
PoSetPowerState ( FdoData->Common.Self, DevicePowerState, powerState );
SET_NEW_PNP_STATE(FdoData->Common, Started);
AcpiStatus = AcpiInitializeSubsystem();
if(ACPI_FAILURE(AcpiStatus)){
DPRINT1("Unable to AcpiInitializeSubsystem\n");
return STATUS_UNSUCCESSFUL;
}
AcpiStatus = AcpiInitializeTables(NULL, 16, 0);
if (ACPI_FAILURE(status)){
DPRINT1("Unable to AcpiInitializeSubsystem\n");
return STATUS_UNSUCCESSFUL;
}
AcpiStatus = AcpiLoadTables();
if(ACPI_FAILURE(AcpiStatus)){
DPRINT1("Unable to AcpiLoadTables\n");
AcpiTerminate();
return STATUS_UNSUCCESSFUL;
}
DPRINT("Acpi subsystem init\n");
/* Initialize ACPI bus manager */
AcpiStatus = acpi_init();
if (!ACPI_SUCCESS(AcpiStatus)) {
DPRINT1("acpi_init() failed with status 0x%X\n", AcpiStatus);
AcpiTerminate();
return STATUS_UNSUCCESSFUL;
}
status = ACPIEnumerateDevices(FdoData);
return status;
}
void
acpi_init()
{
ACPI_STATUS status;
status = AcpiInitializeTables(TableArray, ACPI_MAX_INIT_TABLES, FALSE);
LRT_Assert(status == AE_OK);
madt *madt_ptr;
status = AcpiGetTable("APIC", 0, (ACPI_TABLE_HEADER **)&madt_ptr);
LRT_Assert(status == AE_OK);
uint32_t size = madt_ptr->header.Length - sizeof(madt);
uint8_t *ptr = (uint8_t *)(madt_ptr + 1);
uint8_t ioapics = 0;
do {
if (*ptr == PROCESSOR_LOCAL_APIC) {
lapic_structure *ls = (lapic_structure *)ptr;
size -= ls->length;
ptr += ls->length;
//do nothing with the structure
} else if (*ptr == IO_APIC) {
ioapic_structure *is = (ioapic_structure *)ptr;
size -= is->length;
ptr += is->length;
init_ioapic((ioapic *)(uintptr_t)is->ioapic_address);
LRT_Assert(++ioapics < 2);
lrt_printf("found ioapic table\n");
} else if (*ptr == INTERRUPT_SOURCE_OVERRIDE) {
iso_structure *is = (iso_structure *)ptr;
size -= is->length;
ptr += is->length;
lrt_printf("IRQ %d is mapped to I/O APIC input %d\n", is->source,
is->global_system_interrupt);
} else {
//No definitions for other structures yet!
lrt_printf("Found MADT structed unimplimented: %d\n", *ptr);
LRT_Assert(0);
}
} while (size > 0);
}
ACPI_STATUS
AeInstallTables (
void)
{
ACPI_STATUS Status;
Status = AcpiInitializeTables (Tables, ACPI_MAX_INIT_TABLES, TRUE);
AE_CHECK_OK (AcpiInitializeTables, Status);
Status = AcpiReallocateRootTable ();
AE_CHECK_OK (AcpiReallocateRootTable, Status);
Status = AcpiLoadTables ();
AE_CHECK_OK (AcpiLoadTables, Status);
/*
* Test run-time control method installation. Do it twice to test code
* for an existing name.
*/
Status = AcpiInstallMethod (MethodCode);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s, Could not install method\n",
AcpiFormatException (Status));
}
Status = AcpiInstallMethod (MethodCode);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s, Could not install method\n",
AcpiFormatException (Status));
}
return (AE_OK);
}
void
main(int argc, char *argv[])
{
int set = -1, enable = -1;
int seg = 0, bus = 0, dev = 2, fn = 0, pin = 0;
ACPI_STATUS status;
int verbose = 0;
AcpiDbgLevel = 0;
ARGBEGIN{
case 'v':
AcpiDbgLevel = ACPI_LV_VERBOSITY1;
verbose++;
break;
case 's':
set = open("#P/irqmap", OWRITE);
if (set < 0)
sysfatal("%r");
break;
default:
sysfatal("usage: acpi/irq [-v] [-s]");
break;
}ARGEND;
status = AcpiInitializeSubsystem();
if (ACPI_FAILURE(status)) {
sysfatal("Error %d\n", status);
}
status = AcpiInitializeTables(NULL, 0, FALSE);
if (ACPI_FAILURE(status))
sysfatal("can't set up acpi tables: %d", status);
if (verbose)
print("init dables\n");
status = AcpiLoadTables();
if (ACPI_FAILURE(status))
sysfatal("Can't load ACPI tables: %d", status);
/* from acpi: */
/* If the Hardware Reduced flag is set, machine is always in acpi mode */
AcpiGbl_ReducedHardware = 1;
if (verbose)
print("LOADED TABLES.\n");
status = AcpiEnableSubsystem(0);
if (ACPI_FAILURE(status))
print("Probably does not matter: Can't enable ACPI subsystem");
if (verbose)
print("enabled subsystem.\n");
status = AcpiInitializeObjects(0);
if (ACPI_FAILURE(status))
sysfatal("Can't Initialize ACPI objects");
int picmode;
status = FindIOAPICs(&picmode);
if (picmode == 0)
sysfatal("PANIC: Can't handle picmode 0!");
ACPI_STATUS ExecuteOSI(int pic_mode);
if (verbose)
print("FindIOAPICs returns status %d picmode %d\n", status, picmode);
status = ExecuteOSI(picmode);
CHECK_STATUS("ExecuteOSI");
failed:
if (verbose)
print("inited objects.\n");
if (verbose)
AcpiDbgLevel |= ACPI_LV_VERBOSITY1 | ACPI_LV_FUNCTIONS;
status = AcpiInitializeDebugger();
if (ACPI_FAILURE(status)) {
sysfatal("Error %d\n", status);
}
int GetPRT();
status = GetPRT();
if (ACPI_FAILURE(status)) {
sysfatal("Error %d\n", status);
}
while (1) {
if (scanf("%x %x", &bus, &dev) < 0)
break;
ACPI_STATUS RouteIRQ(ACPI_PCI_ID* device, int pin, int* irq);
AcpiDbgLevel = 0;
ACPI_PCI_ID id = (ACPI_PCI_ID){seg, bus, dev, fn};
status = AcpiOsReadPciConfiguration (&id, 0x3d, &pin, 8);
if (!ACPI_SUCCESS(status)){
printf("Can't read pin for bus %d dev %d\n", bus, dev);
continue;
}
print("ROUTE {%d, %d, %d, %d}, pin %d\n", seg, bus, dev, fn, pin);
int irq;
status = RouteIRQ(&id, pin, &irq);
print("status %d, irq %d\n", status, irq);
AcpiDbgLevel = 0;
print("echo %d %d %d %d 0x%x > /dev/irqmap", seg, bus, dev, fn, irq);
//ACPI_STATUS PrintDevices(void);
//status = PrintDevices();
if (set > -1)
fprint(set, "%d %d %d %d 0x%x", seg, bus, dev, fn, irq);
}
/* we're done. Enable the IRQs we might have set up. */
enable = open("/dev/irqenable", OWRITE);
if (enable < 0)
sysfatal("/dev/irqenable: %r");
if (write(enable, "", 1) < 1)
sysfatal("Write irqenable: %r");
exits(0);
}
static status_t
acpi_std_ops(int32 op,...)
{
switch (op) {
case B_MODULE_INIT:
{
ACPI_OBJECT arg;
ACPI_OBJECT_LIST parameter;
void *settings;
bool acpiDisabled = false;
AcpiGbl_CopyDsdtLocally = true;
settings = load_driver_settings("kernel");
if (settings != NULL) {
acpiDisabled = !get_driver_boolean_parameter(settings, "acpi",
true, true);
unload_driver_settings(settings);
}
if (!acpiDisabled) {
// check if safemode settings disable ACPI
settings = load_driver_settings(B_SAFEMODE_DRIVER_SETTINGS);
if (settings != NULL) {
acpiDisabled = get_driver_boolean_parameter(settings,
B_SAFEMODE_DISABLE_ACPI, false, false);
unload_driver_settings(settings);
}
}
if (acpiDisabled) {
ERROR("ACPI disabled\n");
return ENOSYS;
}
if (gDPC->new_dpc_queue(&gDPCHandle, "acpi_task",
B_URGENT_DISPLAY_PRIORITY + 1) != B_OK) {
ERROR("failed to create os execution queue\n");
return B_ERROR;
}
#ifdef ACPI_DEBUG_OUTPUT
AcpiDbgLevel = ACPI_DEBUG_ALL | ACPI_LV_VERBOSE;
AcpiDbgLayer = ACPI_ALL_COMPONENTS;
#endif
if (checkAndLogFailure(AcpiInitializeSubsystem(),
"AcpiInitializeSubsystem failed"))
goto err;
if (checkAndLogFailure(AcpiInitializeTables(NULL, 0, TRUE),
"AcpiInitializeTables failed"))
goto err;
if (checkAndLogFailure(AcpiLoadTables(),
"AcpiLoadTables failed"))
goto err;
/* Install the default address space handlers. */
if (checkAndLogFailure(AcpiInstallAddressSpaceHandler(
ACPI_ROOT_OBJECT, ACPI_ADR_SPACE_SYSTEM_MEMORY,
ACPI_DEFAULT_HANDLER, NULL, NULL),
"Could not initialise SystemMemory handler:"))
goto err;
if (checkAndLogFailure(AcpiInstallAddressSpaceHandler(
ACPI_ROOT_OBJECT, ACPI_ADR_SPACE_SYSTEM_IO,
ACPI_DEFAULT_HANDLER, NULL, NULL),
"Could not initialise SystemIO handler:"))
goto err;
if (checkAndLogFailure(AcpiInstallAddressSpaceHandler(
ACPI_ROOT_OBJECT, ACPI_ADR_SPACE_PCI_CONFIG,
ACPI_DEFAULT_HANDLER, NULL, NULL),
"Could not initialise PciConfig handler:"))
goto err;
arg.Integer.Type = ACPI_TYPE_INTEGER;
arg.Integer.Value = apic_available() ? APIC_MODE : PIC_MODE;
parameter.Count = 1;
parameter.Pointer = &arg;
AcpiEvaluateObject(NULL, "\\_PIC", ¶meter, NULL);
if (checkAndLogFailure(AcpiEnableSubsystem(
ACPI_FULL_INITIALIZATION),
"AcpiEnableSubsystem failed"))
goto err;
if (checkAndLogFailure(AcpiInitializeObjects(
ACPI_FULL_INITIALIZATION),
"AcpiInitializeObjects failed"))
goto err;
//TODO: Walk namespace init ALL _PRW's
#ifdef ACPI_DEBUG_OUTPUT
checkAndLogFailure(
AcpiInstallGlobalEventHandler(globalGPEHandler, NULL),
"Failed to install global GPE-handler.");
checkAndLogFailure(AcpiInstallNotifyHandler(ACPI_ROOT_OBJECT,
ACPI_ALL_NOTIFY, globalNotifyHandler, NULL),
"Failed to install global Notify-handler.");
#endif
checkAndLogFailure(AcpiEnableAllRuntimeGpes(),
"Failed to enable all runtime Gpes");
checkAndLogFailure(AcpiUpdateAllGpes(),
"Failed to update all Gpes");
TRACE("ACPI initialized\n");
return B_OK;
err:
return B_ERROR;
}
case B_MODULE_UNINIT:
{
if (checkAndLogFailure(AcpiTerminate(),
"Could not bring system out of ACPI mode. Oh well."));
gDPC->delete_dpc_queue(gDPCHandle);
gDPCHandle = NULL;
break;
}
default:
return B_ERROR;
}
return B_OK;
}
static int
AnDumpEntireNamespace (
ACPI_NEW_TABLE_DESC *ListHead)
{
ACPI_STATUS Status;
ACPI_HANDLE Handle;
/*
* Build a local XSDT with all tables. Normally, here is where the
* RSDP search is performed to find the ACPI tables
*/
Status = AnBuildLocalTables (ListHead);
if (ACPI_FAILURE (Status))
{
return (-1);
}
/* Initialize table manager, get XSDT */
Status = AcpiInitializeTables (NULL, ACPI_MAX_INIT_TABLES, TRUE);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not initialize ACPI table manager, %s\n",
AcpiFormatException (Status));
return (-1);
}
/* Build the namespace from the tables */
Status = AcpiLoadTables ();
if (Status == AE_CTRL_TERMINATE)
{
/* At least one table load failed -- terminate with error */
return (-1);
}
if (ACPI_FAILURE (Status))
{
printf ("**** While creating namespace, %s\n",
AcpiFormatException (Status));
return (-1);
}
if (AcpiGbl_NsLoadOnly)
{
printf ("**** Namespace successfully loaded\n");
return (0);
}
/*
* NOTE:
* We don't need to do any further ACPICA initialization, since we don't
* have any hardware, nor is the interpreter configured.
*
* Namely, we don't need these calls:
* AcpiEnableSubsystem
* AcpiInitializeObjects
*/
/*
* Perform a namespace walk to dump the contents
*/
AcpiOsPrintf ("\nACPI Namespace:\n");
AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY,
ACPI_UINT32_MAX, ACPI_OWNER_ID_MAX, AcpiGbl_RootNode);
/* Example: get a handle to the _GPE scope */
Status = AcpiGetHandle (NULL, "\\_GPE", &Handle);
ACPI_CHECK_OK (AcpiGetHandle, Status);
AcDeleteTableList (ListHead);
return (0);
}
void kmain2()
{
kprintf("Initializing SDI... ");
sdInit();
kprintf("%$\x02" "Done%#\n");
initMount();
initSymtab();
kprintf("Initializing ACPICA...\n");
ACPI_STATUS status = AcpiInitializeSubsystem();
if (ACPI_FAILURE(status))
{
panic("AcpiInitializeSubsystem failed");
};
status = AcpiInitializeTables(NULL, 16, FALSE);
if (ACPI_FAILURE(status))
{
panic("AcpiInitializeTables failed");
};
status = AcpiLoadTables();
if (ACPI_FAILURE(status))
{
panic("AcpiLoadTables failed");
};
status = AcpiEnableSubsystem(ACPI_FULL_INITIALIZATION);
if (ACPI_FAILURE(status))
{
panic("AcpiEnableSubsystem failed");
};
status = AcpiInitializeObjects(ACPI_FULL_INITIALIZATION);
if (ACPI_FAILURE(status))
{
panic("AcpiInitializeObjects failed");
};
if (AcpiInstallFixedEventHandler(ACPI_EVENT_POWER_BUTTON, onPowerButton, NULL) != AE_OK)
{
panic("failed to register power button event");
};
pciInitACPI();
kprintf("Initializing the RTC... ");
initRTC();
kprintf("%$\x02" "Done%#\n");
kprintf("Initializing the network interface... ");
ipreasmInit();
initNetIf();
kprintf("%$\x02" "Done%#\n");
kprintf("Starting the spawn process... ");
MachineState state;
void *spawnStack = kmalloc(0x1000);
state.rip = (uint64_t) &spawnProc;
state.rsp = (uint64_t) spawnStack + 0x1000 - 16;
((uint64_t*)state.rsp)[0] = 0;
((uint64_t*)state.rsp)[1] = 0;
state.rdi = (uint64_t) spawnStack;
state.rbp = 0;
Regs regs;
regs.cs = 8;
regs.ds = 16;
regs.rflags = getFlagsRegister() | (1 << 9);
regs.ss = 0;
threadClone(®s, 0, &state);
// "Done" is displayed by the spawnProc() and that's our job done pretty much.
// Mark this thread as waiting so that it never wastes any CPU time.
getCurrentThread()->flags = THREAD_WAITING;
};
static int
process_acpi_tables (void)
{
extern uint32 mp_LAPIC_addr;
extern uint32 mp_num_IOAPICs;
extern uint32 mp_IOAPIC_addr;
extern mp_IOAPIC_info mp_IOAPICs[];
extern uint32 mp_num_overrides;
extern mp_int_override mp_overrides[];
ACPI_STATUS status;
status = AcpiInitializeTables (TableArray, ACPI_MAX_INIT_TABLES, FALSE);
if (status == AE_OK) {
ACPI_TABLE_MADT *madt;
ACPI_TABLE_FADT *fadt;
ACPI_TABLE_BOOT *boot;
ACPI_TABLE_ASF *asf;
ACPI_TABLE_MCFG *mcfg;
ACPI_TABLE_HPET *hpet;
ACPI_TABLE_TCPA *tcpa;
ACPI_TABLE_SRAT *srat;
ACPI_TABLE_DMAR *dmar;
if (AcpiGetTable (ACPI_SIG_FADT, 0, (ACPI_TABLE_HEADER **) & fadt) ==
AE_OK) {
/* Fixed ACPI Description Table */
DLOG_COM1 ("Bootflags: %s %s %s\n",
(fadt->BootFlags & ACPI_FADT_LEGACY_DEVICES) ?
"HAS_LEGACY_DEVICES" : "NO_LEGACY_DEVICES",
(fadt->BootFlags & ACPI_FADT_8042) ?
"HAS_KBD_8042" : "NO_KBD_8042",
(fadt->BootFlags & ACPI_FADT_NO_VGA) ?
"NO_VGA_PROBING" : "VGA_PROBING_OK");
DLOG_COM1 ("Flags=0x%X SCI_IRQ=0x%X Pm1aEvt=0x%p Pm1aCtl=0x%p\n",
fadt->Flags,
fadt->SciInterrupt,
fadt->Pm1aEventBlock,
fadt->Pm1aControlBlock);
DLOG_COM1 ("ResetReg=0x%llX ResetSpace=%d ResetVal=0x%X\n",
fadt->ResetRegister.Address, fadt->ResetRegister.SpaceId, fadt->ResetValue);
acpi_sci_irq = fadt->SciInterrupt;
} else {
DLOG_COM1 ("AcpiGetTable FADT: FAILED\n");
}
mp_ISA_bus_id = 0;
if (AcpiGetTable (ACPI_SIG_MADT, 0, (ACPI_TABLE_HEADER **) & madt) ==
AE_OK) {
/* Multiple APIC Description Table */
uint8 *ptr, *lim = (uint8 *) madt + madt->Header.Length;
DLOG_COM1 ("ACPI OEM: %.6s Compiler: %.4s LAPIC: %p Flags:%s\n",
madt->Header.OemId,
madt->Header.AslCompilerId,
madt->Address,
(madt->Flags & ACPI_MADT_PCAT_COMPAT) ? " PCAT_COMPAT" : "");
mp_LAPIC_addr = madt->Address;
ptr = (uint8 *) madt + sizeof (ACPI_TABLE_MADT);
while (ptr < lim) {
switch (((ACPI_SUBTABLE_HEADER *) ptr)->Type) {
case ACPI_MADT_TYPE_LOCAL_APIC:{
/* Processor entry */
ACPI_MADT_LOCAL_APIC *sub = (ACPI_MADT_LOCAL_APIC *) ptr;
DLOG_COM1 ("Processor: 0x%X APIC-ID: 0x%X %s",
sub->ProcessorId,
sub->Id,
sub->LapicFlags & 1 ? "(enabled)" : "(disabled)");
if (acpi_add_processor (sub)) {
DLOG_COM1 (" (booted)");
}
DLOG_COM1 ("\n");
break;
}
case ACPI_MADT_TYPE_IO_APIC:{
/* IO-APIC entry */
ACPI_MADT_IO_APIC *sub = (ACPI_MADT_IO_APIC *) ptr;
DLOG_COM1 ("IO-APIC ID: %X Address: %X IRQBase: %X\n",
sub->Id, sub->Address, sub->GlobalIrqBase);
if (mp_num_IOAPICs == MAX_IOAPICS)
panic ("Too many IO-APICs.");
mp_IOAPIC_addr = sub->Address;
mp_IOAPICs[mp_num_IOAPICs].id = sub->Id;
mp_IOAPICs[mp_num_IOAPICs].address = sub->Address;
mp_IOAPICs[mp_num_IOAPICs].startGSI = sub->GlobalIrqBase;
mp_IOAPICs[mp_num_IOAPICs].numGSIs = IOAPIC_num_entries();
mp_num_IOAPICs++;
break;
}
case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:{
/* Interrupt Override entry */
ACPI_MADT_INTERRUPT_OVERRIDE *sub =
(ACPI_MADT_INTERRUPT_OVERRIDE *) ptr;
DLOG_COM1 ("Int. Override: Bus: %X SourceIRQ: %X GlobalIRQ: %X Flags: %X\n",
sub->Bus, sub->SourceIrq, sub->GlobalIrq, sub->IntiFlags);
if (mp_num_overrides == MAX_INT_OVERRIDES)
panic ("Too many interrupt overrides.");
mp_overrides[mp_num_overrides].src_bus = sub->Bus;
mp_overrides[mp_num_overrides].src_IRQ = sub->SourceIrq;
mp_overrides[mp_num_overrides].dest_GSI = sub->GlobalIrq;
mp_num_overrides++;
/* (special case) SCI interrupt: it can be different in ACPI
* tables vs Intel MPS tables. */
if (sub->SourceIrq == acpi_sci_irq) {
acpi_sci_irq = sub->GlobalIrq;
acpi_sci_flags = sub->IntiFlags;
}
break;
}
default:
DLOG_COM1 ("MADT sub-entry: %X\n",
((ACPI_SUBTABLE_HEADER *) ptr)->Type);
break;
}
ptr += ((ACPI_SUBTABLE_HEADER *) ptr)->Length;
}
} else {
DLOG_COM1 ("AcpiGetTable MADT: FAILED\n");
return 0;
}
if (AcpiGetTable (ACPI_SIG_BOOT, 0, (ACPI_TABLE_HEADER **) & boot) ==
AE_OK) {
/* Simple Boot Information Table */
DLOG_COM1 ("BOOT: CmosIndex=0x%X\n", boot->CmosIndex);
}
if (AcpiGetTable (ACPI_SIG_TCPA, 0, (ACPI_TABLE_HEADER **) & tcpa) ==
AE_OK) {
/* Trusted Computing Platform Alliance table */
DLOG_COM1 ("TCPA: MaxLog=0x%X Addr: 0x%llX\n",
tcpa->MaxLogLength,
tcpa->LogAddress);
}
if (AcpiGetTable (ACPI_SIG_HPET, 0, (ACPI_TABLE_HEADER **) & hpet) ==
AE_OK) {
/* High Precision Event Timer table */
DLOG_COM1 ("HPET: ID: 0x%X Addr: 0x%p Seq#: 0x%X MinTick: 0x%X Flags: 0x%X\n",
hpet->Id,
hpet->Address,
(uint32) hpet->Sequence,
(uint32) hpet->MinimumTick, (uint32) hpet->Flags);
}
if (AcpiGetTable (ACPI_SIG_MCFG, 0, (ACPI_TABLE_HEADER **) & mcfg) ==
AE_OK) {
/* PCI Memory Mapped Configuration table */
DLOG_COM1 ("MCFG: Length: %d Reserved: 0x%llX\n",
mcfg->Header.Length,
mcfg->Reserved);
}
if (AcpiGetTable (ACPI_SIG_ASF, 0, (ACPI_TABLE_HEADER **) & asf) == AE_OK) {
/* Alert Standard Format table */
DLOG_COM1 ("ASF: Length: %d\n", mcfg->Header.Length);
}
if (AcpiGetTable (ACPI_SIG_SRAT, 0, (ACPI_TABLE_HEADER **) & srat) == AE_OK) {
/* System Resource Affinity Table */
DLOG_COM1 ("SRAT: Length: %d\n", srat->Header.Length);
acpi_parse_srat (srat);
}
if (AcpiGetTable (ACPI_SIG_DMAR, 0, (ACPI_TABLE_HEADER **) & dmar) == AE_OK) {
/* DMA Remapping */
DLOG_COM1 ("DMAR: Length: %d Flags: 0x%X Width: %d\n",
dmar->Header.Length,
dmar->Flags,
dmar->Width);
}
} else
return 0;
return mp_num_cpus;
}
static ACPI_STATUS InitializeFullAcpi (void)
{
ACPI_STATUS Status;
/* Initialize the ACPICA subsystem */
Status = AcpiInitializeSubsystem ();
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "While initializing ACPICA"));
return (Status);
}
/* Initialize the ACPICA Table Manager and get all ACPI tables */
Status = AcpiInitializeTables (NULL, 0, FALSE);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "While initializing Table Manager"));
return (Status);
}
/* Create the ACPI namespace from ACPI tables */
Status = AcpiLoadTables ();
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "While loading ACPI tables"));
return (Status);
}
/* Install local handlers */
Status = InstallHandlers ();
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "While installing handlers"));
return (Status);
}
/* Initialize the ACPI hardware */
Status = AcpiEnableSubsystem (ACPI_FULL_INITIALIZATION);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "While enabling ACPICA"));
return (Status);
}
/* Complete the ACPI namespace object initialization */
Status = AcpiInitializeObjects (ACPI_FULL_INITIALIZATION);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "While initializing ACPICA objects"));
return (Status);
}
return (AE_OK);
}
static int
NsDumpEntireNamespace (
char *AmlFilename)
{
ACPI_STATUS Status;
ACPI_TABLE_HEADER *Table = NULL;
UINT32 TableCount = 0;
AE_TABLE_DESC *TableDesc;
ACPI_HANDLE Handle;
/* Open the binary AML file and read the entire table */
Status = AcpiUtReadTableFromFile (AmlFilename, &Table);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not get input table %s, %s\n", AmlFilename,
AcpiFormatException (Status));
return (-1);
}
/* Table must be a DSDT. SSDTs are not currently supported */
if (!ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_DSDT))
{
printf ("**** Input table signature is [%4.4s], must be [DSDT]\n",
Table->Signature);
return (-1);
}
/*
* Allocate and link a table descriptor (allows for future expansion to
* multiple input files)
*/
TableDesc = AcpiOsAllocate (sizeof (AE_TABLE_DESC));
TableDesc->Table = Table;
TableDesc->Next = AeTableListHead;
AeTableListHead = TableDesc;
TableCount++;
/*
* Build a local XSDT with all tables. Normally, here is where the
* RSDP search is performed to find the ACPI tables
*/
Status = AeBuildLocalTables (TableCount, AeTableListHead);
if (ACPI_FAILURE (Status))
{
return (-1);
}
/* Initialize table manager, get XSDT */
Status = AcpiInitializeTables (Tables, ACPI_MAX_INIT_TABLES, TRUE);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not initialize ACPI table manager, %s\n",
AcpiFormatException (Status));
return (-1);
}
/* Reallocate root table to dynamic memory */
Status = AcpiReallocateRootTable ();
if (ACPI_FAILURE (Status))
{
printf ("**** Could not reallocate root table, %s\n",
AcpiFormatException (Status));
return (-1);
}
/* Load the ACPI namespace */
Status = AcpiLoadTables ();
if (ACPI_FAILURE (Status))
{
printf ("**** Could not load ACPI tables, %s\n",
AcpiFormatException (Status));
return (-1);
}
/*
* Enable ACPICA. These calls don't do much for this
* utility, since we only dump the namespace. There is no
* hardware or event manager code underneath.
*/
Status = AcpiEnableSubsystem (
ACPI_NO_ACPI_ENABLE |
ACPI_NO_ADDRESS_SPACE_INIT |
ACPI_NO_EVENT_INIT |
ACPI_NO_HANDLER_INIT);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not EnableSubsystem, %s\n",
AcpiFormatException (Status));
return (-1);
}
Status = AcpiInitializeObjects (
ACPI_NO_ADDRESS_SPACE_INIT |
ACPI_NO_DEVICE_INIT |
ACPI_NO_EVENT_INIT);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not InitializeObjects, %s\n",
AcpiFormatException (Status));
return (-1);
}
/*
* Perform a namespace walk to dump the contents
*/
AcpiOsPrintf ("\nACPI Namespace:\n");
AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, ACPI_UINT32_MAX,
ACPI_OWNER_ID_MAX, AcpiGbl_RootNode);
/* Example: get a handle to the _GPE scope */
Status = AcpiGetHandle (NULL, "\\_GPE", &Handle);
AE_CHECK_OK (AcpiGetHandle, Status);
return (0);
}
void initializeBasicSystem() {
ACPICA_CHECK(AcpiInitializeSubsystem());
ACPICA_CHECK(AcpiInitializeTables(nullptr, 16, FALSE));
ACPICA_CHECK(AcpiLoadTables());
frigg::infoLogger() << "thor: ACPICA initialized." << frigg::endLog;
dumpMadt();
ACPI_TABLE_HEADER *madt;
ACPICA_CHECK(AcpiGetTable(const_cast<char *>("APIC"), 0, &madt));
// Configure all interrupt controllers.
// TODO: This should be done during thor's initialization in order to avoid races.
frigg::infoLogger() << "thor: Configuring I/O APICs." << frigg::endLog;
size_t offset = sizeof(ACPI_TABLE_HEADER) + sizeof(MadtHeader);
while(offset < madt->Length) {
auto generic = (MadtGenericEntry *)((uint8_t *)madt + offset);
if(generic->type == 1) { // I/O APIC
auto entry = (MadtIoEntry *)generic;
assert(!entry->systemIntBase);
setupIoApic(entry->mmioAddress);
}
offset += generic->length;
}
// Determine IRQ override configuration.
for(int i = 0; i < 16; i++)
irqOverrides[i].initialize();
offset = sizeof(ACPI_TABLE_HEADER) + sizeof(MadtHeader);
while(offset < madt->Length) {
auto generic = (MadtGenericEntry *)((uint8_t *)madt + offset);
if(generic->type == 2) { // interrupt source override
auto entry = (MadtIntOverrideEntry *)generic;
// ACPI defines only ISA IRQ overrides.
assert(entry->bus == 0);
assert(entry->sourceIrq < 16);
IrqLine line;
line.gsi = entry->systemInt;
auto trigger = entry->flags & OverrideFlags::triggerMask;
auto polarity = entry->flags & OverrideFlags::polarityMask;
if(trigger == OverrideFlags::triggerDefault
&& polarity == OverrideFlags::polarityDefault) {
line.configuration.trigger = TriggerMode::edge;
line.configuration.polarity = Polarity::high;
}else{
assert(trigger != OverrideFlags::triggerDefault);
assert(polarity != OverrideFlags::polarityDefault);
switch(trigger) {
case OverrideFlags::triggerEdge:
line.configuration.trigger = TriggerMode::edge; break;
case OverrideFlags::triggerLevel:
line.configuration.trigger = TriggerMode::level; break;
default:
frigg::panicLogger() << "Illegal IRQ trigger mode in MADT" << frigg::endLog;
}
switch(polarity) {
case OverrideFlags::polarityHigh:
line.configuration.polarity = Polarity::high; break;
case OverrideFlags::polarityLow:
line.configuration.polarity = Polarity::low; break;
default:
frigg::panicLogger() << "Illegal IRQ polarity in MADT" << frigg::endLog;
}
}
assert(!(*irqOverrides[entry->sourceIrq]));
*irqOverrides[entry->sourceIrq] = line;
}
offset += generic->length;
}
// Initialize the HPET.
frigg::infoLogger() << "thor: Setting up HPET." << frigg::endLog;
ACPI_TABLE_HEADER *hpet_table;
ACPICA_CHECK(AcpiGetTable(const_cast<char *>("HPET"), 0, &hpet_table));
auto hpet_entry = (HpetEntry *)((uintptr_t)hpet_table + sizeof(ACPI_TABLE_HEADER));
assert(hpet_entry->address.SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY);
setupHpet(hpet_entry->address.Address);
}
