ACPI_STATUS AeInstallLateHandlers ( void) { ACPI_STATUS Status; UINT32 i; #if (!ACPI_REDUCED_HARDWARE) if (!AcpiGbl_ReducedHardware) { /* Install a user SCI handler */ Status = AeInstallSciHandler (); AE_CHECK_OK (AeInstallSciHandler, Status); /* 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; /* * We will install a handler for each EC device, directly under the EC * device definition. This is unlike the other handlers which we install * at the root node. Also install memory and I/O handlers at any PCI * devices. */ AeInstallDeviceHandlers (); /* * Install handlers for some of the "device driver" address spaces * such as SMBus, etc. */ for (i = 0; i < ACPI_ARRAY_LENGTH (SpaceIdList); i++) { /* Install handler at the root object */ Status = AcpiInstallAddressSpaceHandler (ACPI_ROOT_OBJECT, 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); }
void initializeExtendedSystem() { // Configure the ISA IRQs. // TODO: This is a hack. We assume that HPET will use legacy replacement // and that SCI is routed to IRQ 9. frigg::infoLogger() << "thor: Configuring ISA IRQs." << frigg::endLog; commitIrq(resolveIrq(0)); commitIrq(resolveIrq(1)); commitIrq(resolveIrq(4)); commitIrq(resolveIrq(9)); commitIrq(resolveIrq(12)); commitIrq(resolveIrq(14)); frigg::infoLogger() << "thor: Entering ACPI mode." << frigg::endLog; ACPICA_CHECK(AcpiEnableSubsystem(ACPI_FULL_INITIALIZATION)); ACPICA_CHECK(AcpiInstallFixedEventHandler(ACPI_EVENT_POWER_BUTTON, &handlePowerButton, nullptr)); ACPICA_CHECK(AcpiInstallGlobalEventHandler(&dispatchEvent, nullptr)); ACPICA_CHECK(AcpiInitializeObjects(ACPI_FULL_INITIALIZATION)); if(hasChild(ACPI_ROOT_OBJECT, "_PIC")) { frigg::infoLogger() << "thor: Invoking \\_PIC method" << frigg::endLog; evaluateWith1(getChild(ACPI_ROOT_OBJECT, "_PIC")); } bootOtherProcessors(); enumerateSystemBusses(); initializePmInterface(); frigg::infoLogger() << "thor: System configuration complete." << frigg::endLog; }
status_t install_fixed_event_handler(uint32 event, acpi_event_handler handler, void *data) { return AcpiInstallFixedEventHandler(event, (ACPI_EVENT_HANDLER)handler, data) == AE_OK ? B_OK : B_ERROR; }
ACPI_STATUS AeInstallLateHandlers ( void) { ACPI_STATUS Status; #if (!ACPI_REDUCED_HARDWARE) if (!AcpiGbl_ReducedHardware) { /* Install a user SCI handler */ Status = AeInstallSciHandler (); AE_CHECK_OK (AeInstallSciHandler, Status); /* 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; /* * We will install a handler for each EC device, directly under the EC * device definition. This is unlike the other handlers which we install * at the root node. Also install memory and I/O handlers at any PCI * devices. */ AeInstallDeviceHandlers (); /* * Install handlers for some of the "device driver" address spaces * such as SMBus, etc. */ AeInstallRegionHandlers (); return (AE_OK); }
ACPI_STATUS AcpiEvInitGlobalLockHandler ( void) { ACPI_STATUS Status; ACPI_FUNCTION_TRACE (EvInitGlobalLockHandler); /* If Hardware Reduced flag is set, there is no global lock */ if (AcpiGbl_ReducedHardware) { return_ACPI_STATUS (AE_OK); } /* Attempt installation of the global lock handler */ Status = AcpiInstallFixedEventHandler (ACPI_EVENT_GLOBAL, AcpiEvGlobalLockHandler, NULL); /* * If the global lock does not exist on this platform, the attempt to * enable GBL_STATUS will fail (the GBL_ENABLE bit will not stick). * Map to AE_OK, but mark global lock as not present. Any attempt to * actually use the global lock will be flagged with an error. */ AcpiGbl_GlobalLockPresent = FALSE; if (Status == AE_NO_HARDWARE_RESPONSE) { ACPI_ERROR ((AE_INFO, "No response from Global Lock hardware, disabling lock")); return_ACPI_STATUS (AE_OK); } Status = AcpiOsCreateLock (&AcpiGbl_GlobalLockPendingLock); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } AcpiGbl_GlobalLockPending = FALSE; AcpiGbl_GlobalLockPresent = TRUE; return_ACPI_STATUS (Status); }
static int acpi_button_attach(device_t dev) { struct acpi_prw_data prw; struct acpi_button_softc *sc; ACPI_STATUS status; int event; ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); sc = device_get_softc(dev); sc->button_dev = dev; sc->button_handle = acpi_get_handle(dev); event = (sc->button_type == ACPI_SLEEP_BUTTON) ? ACPI_EVENT_SLEEP_BUTTON : ACPI_EVENT_POWER_BUTTON; /* * Install the new handler. We could remove any fixed handlers added * from the FADT once we have a duplicate from the AML but some systems * only return events on one or the other so we have to keep both. */ if (sc->fixed) { AcpiClearEvent(event); status = AcpiInstallFixedEventHandler(event, acpi_button_fixed_handler, sc); } else { /* * If a system does not get lid events, it may make sense to change * the type to ACPI_ALL_NOTIFY. Some systems generate both a wake * and runtime notify in that case though. */ status = AcpiInstallNotifyHandler(sc->button_handle, ACPI_DEVICE_NOTIFY, acpi_button_notify_handler, sc); } if (ACPI_FAILURE(status)) { device_printf(sc->button_dev, "couldn't install notify handler - %s\n", AcpiFormatException(status)); return_VALUE (ENXIO); } /* Enable the GPE for wake/runtime */ acpi_wake_set_enable(dev, 1); if (acpi_parse_prw(sc->button_handle, &prw) == 0) AcpiEnableGpe(prw.gpe_handle, prw.gpe_bit); return_VALUE (0); }
ACPI_STATUS AcpiEvInitGlobalLockHandler ( void) { ACPI_STATUS Status; ACPI_FUNCTION_TRACE (EvInitGlobalLockHandler); Status = AcpiGetTableByIndex (ACPI_TABLE_INDEX_FACS, ACPI_CAST_INDIRECT_PTR (ACPI_TABLE_HEADER, &Facs)); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } AcpiGbl_GlobalLockPresent = TRUE; Status = AcpiInstallFixedEventHandler (ACPI_EVENT_GLOBAL, AcpiEvGlobalLockHandler, NULL); /* * If the global lock does not exist on this platform, the attempt * to enable GBL_STATUS will fail (the GBL_ENABLE bit will not stick) * Map to AE_OK, but mark global lock as not present. * Any attempt to actually use the global lock will be flagged * with an error. */ if (Status == AE_NO_HARDWARE_RESPONSE) { ACPI_ERROR ((AE_INFO, "No response from Global Lock hardware, disabling lock")); AcpiGbl_GlobalLockPresent = FALSE; Status = AE_OK; } return_ACPI_STATUS (Status); }
ACPI_STATUS AeInstallLateHandlers ( void) { ACPI_STATUS Status; ACPI_HANDLE Handle; Status = AcpiGetHandle (NULL, "\\_TZ.TZ1", &Handle); if (ACPI_SUCCESS (Status)) { 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)); } #if (!ACPI_REDUCED_HARDWARE) if (!AcpiGbl_ReducedHardware) { /* Install a user SCI handler */ Status = AeInstallSciHandler (); ACPI_CHECK_OK (AeInstallSciHandler, Status); /* Install some fixed event handlers */ Status = AcpiInstallFixedEventHandler ( ACPI_EVENT_GLOBAL, AeEventHandler, NULL); ACPI_CHECK_OK (AcpiInstallFixedEventHandler, Status); Status = AcpiInstallFixedEventHandler ( ACPI_EVENT_RTC, AeEventHandler, NULL); ACPI_CHECK_OK (AcpiInstallFixedEventHandler, Status); } #endif /* !ACPI_REDUCED_HARDWARE */ AeMyContext.Connection = NULL; AeMyContext.AccessLength = 0xA5; /* * We will install a handler for each EC device, directly under the EC * device definition. This is unlike the other handlers which we install * at the root node. Also install memory and I/O handlers at any PCI * devices. */ AeInstallDeviceHandlers (); /* * Install handlers for some of the "device driver" address spaces * such as SMBus, etc. */ AeInstallRegionHandlers (); return (AE_OK); }
ACPI_STATUS AtRemoveFixedEventHandlerCommon( UINT32 CheckAction, ACPI_STATUS ExpectedStatus) { ACPI_STATUS Status; UINT32 Event = ACPI_NUM_FIXED_EVENTS; ACPI_EVENT_HANDLER EventHandler; ACPI_OSXF OsxfNumAct; UINT32 i; Status = AtSubsystemInit( AAPITS_INI_DEF & ~AAPITS_INSTALL_HS, AAPITS_EN_FLAGS | ACPI_NO_HANDLER_INIT, AAPITS_OI_FLAGS, NULL); if (ACPI_FAILURE(Status)) { return (Status); } FixedEventHandlerCounter = 0; for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) { if (CheckAction == 5) { continue; } switch (i) { case 0: Event = ACPI_EVENT_PMTIMER; break; case 1: Event = ACPI_EVENT_GLOBAL; break; case 2: Event = ACPI_EVENT_POWER_BUTTON; break; case 3: Event = ACPI_EVENT_SLEEP_BUTTON; break; case 4: Event = ACPI_EVENT_RTC; break; default: TestErrors++; printf ("Test Error: the number of Fixed Events (%d) too big (should be 5)\n", ACPI_NUM_FIXED_EVENTS); return (AE_ERROR); } EventHandler = FixedEventHandlers[i]; FixedEventHandlerContext[i] = 0; Status = AcpiInstallFixedEventHandler(Event, EventHandler, &FixedEventHandlerContext[i]); if (ACPI_FAILURE(Status)) { AapiErrors++; printf ("Api Error: AcpiInstallFixedEventHandler(%d) returned %s\n", Event, AcpiFormatException(Status)); return (Status); } } for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) { switch (i) { case 0: Event = ACPI_EVENT_PMTIMER; break; case 1: Event = ACPI_EVENT_GLOBAL; break; case 2: Event = ACPI_EVENT_POWER_BUTTON; break; case 3: Event = ACPI_EVENT_SLEEP_BUTTON; break; case 4: Event = ACPI_EVENT_RTC; break; } EventHandler = FixedEventHandlers[i]; if (CheckAction == 1) { Event += ACPI_NUM_FIXED_EVENTS; } else if (CheckAction == 2) { EventHandler = NULL; } else if (CheckAction == 3) { /* * initiate the situation when fixed event * enable register can not be written */ Status = OsxfCtrlSet(OSXF_NUM(AcpiOsWritePort), 1, AtActD_OneTime, AtActRet_ERROR); if (ACPI_FAILURE(Status)) { TestErrors++; printf ("Test error: OsxfCtrlSet returned %s\n", AcpiFormatException(Status)); return (Status); } } else if (CheckAction == 4) { EventHandler = FixedEventHandlers[(i + 2) % ACPI_NUM_FIXED_EVENTS]; } Status = AcpiRemoveFixedEventHandler(Event, EventHandler); if (CheckAction == 3 && !(OsxfNumAct = OsxfCtrlGetActOsxf(OSXF_NUM(AcpiOsWritePort), 1))) { TestSkipped++; printf ("Test note: test action hasn't occur\n"); return (AE_ERROR); } TestPass++; if (Status != ExpectedStatus) { AapiErrors++; printf ("Api Error: AcpiRemoveFixedEventHandler(%d, 0x%p)" " returned %s, expected %s\n", Event, EventHandler, AcpiFormatException(Status), AcpiFormatException(ExpectedStatus)); if (Status != AE_OK) { return (Status); } else { return (AE_ERROR); } } } if (FixedEventHandlerCounter != 0) { AapiErrors++; printf ("Api Error: FixedEvent Handler invoked %d times\n", FixedEventHandlerCounter); return (AE_ERROR); } return (AtTerminateCtrlCheck(AE_OK, ALL_STAT)); }
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; };
void acpi_secondary_init(void) { ACPI_STATUS Status; ACPI_STATUS DisplayOneDevice (ACPI_HANDLE, UINT32, void *, void **); /* Complete the ACPICA initialization sequence */ Status = AcpiInitializeSubsystem (); if (ACPI_FAILURE (Status)) { DLOG_COM1 ("Failed to initialize ACPI.\n"); } Status = AcpiReallocateRootTable (); if (ACPI_FAILURE (Status)) { DLOG_COM1 ("Failed: AcpiReallocateRootTable %d.\n", Status); } Status = AcpiLoadTables (); if (ACPI_FAILURE (Status)) { DLOG_COM1 ("Failed: AcpiLoadTables.\n"); } Status = AcpiEnableSubsystem (ACPI_FULL_INITIALIZATION); if (ACPI_FAILURE (Status)) { DLOG_COM1 ("Failed: AcpiEnableSubsystem.\n"); } Status = AcpiInitializeObjects (ACPI_FULL_INITIALIZATION); if (ACPI_FAILURE (Status)) { DLOG_COM1 ("Failed: AcpiInitializeObjects.\n"); } /* Must enable IOAPIC before checking any PCI routing tables. */ acpi_enable_IOAPIC (); /* Install System Control Interrupt */ u8 vector = find_unused_vector (MINIMUM_VECTOR_PRIORITY); if (vector) { u64 flags = IOAPIC_DELIVERY_FIXED | IOAPIC_DESTINATION_LOGICAL; u8 gsi = acpi_sci_irq; /* SCI defaults to LEVEL/LOW in IO-APIC mode. */ if ((acpi_sci_flags & ACPI_MADT_POLARITY_MASK) == ACPI_MADT_POLARITY_ACTIVE_HIGH) flags |= IOAPIC_POLARITY_HIGH; else flags |= IOAPIC_POLARITY_LOW; if ((acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) == ACPI_MADT_TRIGGER_EDGE) flags |= IOAPIC_TRIGGER_EDGE; else flags |= IOAPIC_TRIGGER_LEVEL; if (IOAPIC_map_GSI (gsi, vector, 0x0100000000000000ULL | flags) != -1) { set_vector_handler (vector, acpi_irq_handler); DLOG ("ACPI: mapped GSI 0x%X to vector 0x%X (%s, %s)\n", gsi, vector, flags & IOAPIC_TRIGGER_LEVEL ? "level" : "edge", flags & IOAPIC_POLARITY_LOW ? "low" : "high"); } else DLOG ("ACPI: failed to map GSI\n"); } else DLOG ("ACPI: failed to find unused vector\n"); DLOG ("AcpiEnableEvent returned %d\n", AcpiEnableEvent (ACPI_EVENT_POWER_BUTTON, 0)); DLOG ("AcpiInstallFixedEventHandler returned %d\n", AcpiInstallFixedEventHandler (ACPI_EVENT_POWER_BUTTON, acpi_power_button, NULL)); DLOG ("AcpiInstallNotifyHandler returned %d\n", AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY, acpi_notify_handler, NULL)); DLOG ("AcpiInstallNotifyHandler returned %d\n", AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_DEVICE_NOTIFY, acpi_notify_handler, NULL)); extern u8 AcpiGbl_OsiData; AcpiGbl_OsiData=0; /* Walk the System Bus "\_SB_" and output info about each object * found. */ #if 0 ACPI_HANDLE SysBusHandle; AcpiGetHandle (ACPI_ROOT_OBJECT, ACPI_NS_SYSTEM_BUS, &SysBusHandle); AcpiWalkNamespace (ACPI_TYPE_ANY, SysBusHandle, INT_MAX, DisplayOneDevice, NULL, NULL); #else AcpiGetDevices (NULL, DisplayOneDevice, NULL, NULL); #endif }