void AcpiHwClearGpe ( UINT32 GpeNumber) { UINT32 RegisterIndex; UINT32 BitMask; FUNCTION_ENTRY (); /* * Translate GPE number to index into global registers array. */ RegisterIndex = AcpiGbl_GpeValid[GpeNumber]; /* * Figure out the bit offset for this GPE within the target register. */ BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)]; /* * Write a one to the appropriate bit in the status register to * clear this GPE. */ AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].StatusAddr, BitMask, 8); }
static void acpi_cpu_startup_cx(struct acpi_cpu_softc *sc) { acpi_cpu_cx_list(sc); SYSCTL_ADD_STRING(&sc->cpu_sysctl_ctx, SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)), OID_AUTO, "cx_supported", CTLFLAG_RD, sc->cpu_cx_supported, 0, "Cx/microsecond values for supported Cx states"); SYSCTL_ADD_PROC(&sc->cpu_sysctl_ctx, SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)), OID_AUTO, "cx_lowest", CTLTYPE_STRING | CTLFLAG_RW, (void *)sc, 0, acpi_cpu_cx_lowest_sysctl, "A", "lowest Cx sleep state to use"); SYSCTL_ADD_PROC(&sc->cpu_sysctl_ctx, SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)), OID_AUTO, "cx_usage", CTLTYPE_STRING | CTLFLAG_RD, (void *)sc, 0, acpi_cpu_usage_sysctl, "A", "percent usage for each Cx state"); #ifdef notyet /* Signal platform that we can handle _CST notification. */ if (!cpu_cx_generic && cpu_cst_cnt != 0) { ACPI_LOCK(acpi); AcpiOsWritePort(cpu_smi_cmd, cpu_cst_cnt, 8); ACPI_UNLOCK(acpi); } #endif }
void AcpiHwDisableGpe ( UINT32 GpeNumber) { UINT32 InByte; UINT32 RegisterIndex; UINT32 BitMask; FUNCTION_ENTRY (); /* * Translate GPE number to index into global registers array. */ RegisterIndex = AcpiGbl_GpeValid[GpeNumber]; /* * Figure out the bit offset for this GPE within the target register. */ BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)]; /* * Read the current value of the register, clear the appropriate bit, * and write out the new register value to disable the GPE. */ InByte = 0; AcpiOsReadPort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr, &InByte, 8); AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr, (InByte & ~BitMask), 8); }
static uint8_t thinkpad_brightness_read(thinkpad_softc_t *sc) { uint32_t val = 0; AcpiOsWritePort(IO_RTC, 0x6c, 8); AcpiOsReadPort(IO_RTC + 1, &val, 8); return val & 7; }
static void acpi_cst_startup(struct acpi_cst_softc *sc) { struct acpi_cpu_softc *cpu = sc->cst_parent; int i, bm_rld_done = 0; for (i = 0; i < sc->cst_cx_count; ++i) { struct acpi_cst_cx *cx = &sc->cst_cx_states[i]; int error; /* If there are C3(+) states, always enable bus master wakeup */ if (cx->type >= ACPI_STATE_C3 && !bm_rld_done && (acpi_cst_quirks & ACPI_CST_QUIRK_NO_BM) == 0) { acpi_cst_c3_bm_rld(sc); bm_rld_done = 1; } /* Redo the Cx setup, since quirks have been changed */ error = acpi_cst_cx_setup(cx); if (error) panic("C%d startup setup failed: %d", i + 1, error); } acpi_cst_support_list(sc); SYSCTL_ADD_STRING(&cpu->pcpu_sysctl_ctx, SYSCTL_CHILDREN(cpu->pcpu_sysctl_tree), OID_AUTO, "cx_supported", CTLFLAG_RD, sc->cst_cx_supported, 0, "Cx/microsecond values for supported Cx states"); SYSCTL_ADD_PROC(&cpu->pcpu_sysctl_ctx, SYSCTL_CHILDREN(cpu->pcpu_sysctl_tree), OID_AUTO, "cx_lowest", CTLTYPE_STRING | CTLFLAG_RW, (void *)sc, 0, acpi_cst_lowest_sysctl, "A", "requested lowest Cx sleep state"); SYSCTL_ADD_PROC(&cpu->pcpu_sysctl_ctx, SYSCTL_CHILDREN(cpu->pcpu_sysctl_tree), OID_AUTO, "cx_lowest_use", CTLTYPE_STRING | CTLFLAG_RD, (void *)sc, 0, acpi_cst_lowest_use_sysctl, "A", "lowest Cx sleep state to use"); SYSCTL_ADD_PROC(&cpu->pcpu_sysctl_ctx, SYSCTL_CHILDREN(cpu->pcpu_sysctl_tree), OID_AUTO, "cx_usage", CTLTYPE_STRING | CTLFLAG_RD, (void *)sc, 0, acpi_cst_usage_sysctl, "A", "percent usage for each Cx state"); #ifdef notyet /* Signal platform that we can handle _CST notification. */ if (!acpi_cst_use_fadt && acpi_cst_ctrl != 0) { ACPI_LOCK(acpi); AcpiOsWritePort(acpi_cst_smi_cmd, acpi_cst_ctrl, 8); ACPI_UNLOCK(acpi); } #endif }
static ACPI_STATUS enter_s4_with_bios(void) { ACPI_OBJECT_LIST ArgList; ACPI_OBJECT Arg; u_long ef; UINT32 ret; ACPI_STATUS status; /* run the _PTS and _GTS methods */ ACPI_MEMSET(&ArgList, 0, sizeof(ArgList)); ArgList.Count = 1; ArgList.Pointer = &Arg; ACPI_MEMSET(&Arg, 0, sizeof(Arg)); Arg.Type = ACPI_TYPE_INTEGER; Arg.Integer.Value = ACPI_STATE_S4; AcpiEvaluateObject(NULL, "\\_PTS", &ArgList, NULL); AcpiEvaluateObject(NULL, "\\_GTS", &ArgList, NULL); /* clear wake status */ AcpiSetRegister(ACPI_BITREG_WAKE_STATUS, 1, ACPI_MTX_LOCK); ef = read_eflags(); disable_intr(); AcpiHwDisableNonWakeupGpes(); /* flush caches */ ACPI_FLUSH_CPU_CACHE(); /* * write the value to command port and wait until we enter sleep state */ do { AcpiOsStall(1000000); AcpiOsWritePort(AcpiGbl_FADT->SmiCmd, AcpiGbl_FADT->S4BiosReq, 8); status = AcpiGetRegister(ACPI_BITREG_WAKE_STATUS, &ret, ACPI_MTX_LOCK); if (ACPI_FAILURE(status)) break; } while (!ret); AcpiHwEnableNonWakeupGpes(); write_eflags(ef); return (AE_OK); }
static void acpi_px_startup(void *arg) { /* Signal to the platform that we are taking over CPU control. */ if (AcpiGbl_FADT.PstateControl == 0) return; ACPI_LOCK(acpi); AcpiOsWritePort(AcpiGbl_FADT.SmiCommand, AcpiGbl_FADT.PstateControl, 8); ACPI_UNLOCK(acpi); }
static void acpicpu_cstate_cst_bios(void) { const uint8_t val = AcpiGbl_FADT.CstControl; const uint32_t addr = AcpiGbl_FADT.SmiCommand; if (addr == 0 || val == 0) return; (void)AcpiOsWritePort(addr, val, 8); }
ACPI_STATUS AcpiHwWritePort ( ACPI_IO_ADDRESS Address, UINT32 Value, UINT32 Width) { ACPI_STATUS Status; UINT32 i; /* Truncate address to 16 bits if requested */ if (AcpiGbl_TruncateIoAddresses) { Address &= ACPI_UINT16_MAX; } /* Validate the entire request and perform the I/O */ Status = AcpiHwValidateIoRequest (Address, Width); if (ACPI_SUCCESS (Status)) { Status = AcpiOsWritePort (Address, Value, Width); return (Status); } if (Status != AE_AML_ILLEGAL_ADDRESS) { return (Status); } /* * There has been a protection violation within the request. Fall * back to byte granularity port I/O and ignore the failing bytes. * This provides Windows compatibility. */ for (i = 0; i < Width; i += 8) { /* Validate and write one byte */ if (AcpiHwValidateIoRequest (Address, 8) == AE_OK) { Status = AcpiOsWritePort (Address, (Value >> i) & 0xFF, 8); if (ACPI_FAILURE (Status)) { return (Status); } } Address++; }
ACPI_STATUS AcpiExSystemIoSpaceHandler ( UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, ACPI_INTEGER *Value, void *HandlerContext, void *RegionContext) { ACPI_STATUS Status = AE_OK; UINT32 Value32; ACPI_FUNCTION_TRACE (ExSystemIoSpaceHandler); ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "System-IO (width %d) R/W %d Address=%8.8X%8.8X\n", BitWidth, Function, ACPI_FORMAT_NATIVE_UINT (Address))); /* Decode the function parameter */ switch (Function) { case ACPI_READ: Status = AcpiOsReadPort ((ACPI_IO_ADDRESS) Address, &Value32, BitWidth); *Value = Value32; break; case ACPI_WRITE: Status = AcpiOsWritePort ((ACPI_IO_ADDRESS) Address, (UINT32) *Value, BitWidth); break; default: Status = AE_BAD_PARAMETER; break; } return_ACPI_STATUS (Status); }
ACPI_STATUS AcpiHwSetMode ( UINT32 Mode) { ACPI_STATUS Status; UINT32 Retry; ACPI_FUNCTION_TRACE (HwSetMode); /* * ACPI 2.0 clarified that if SMI_CMD in FADT is zero, * system does not support mode transition. */ if (!AcpiGbl_FADT.SmiCommand) { ACPI_ERROR ((AE_INFO, "No SMI_CMD in FADT, mode transition failed")); return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE); } /* * ACPI 2.0 clarified the meaning of ACPI_ENABLE and ACPI_DISABLE * in FADT: If it is zero, enabling or disabling is not supported. * As old systems may have used zero for mode transition, * we make sure both the numbers are zero to determine these * transitions are not supported. */ if (!AcpiGbl_FADT.AcpiEnable && !AcpiGbl_FADT.AcpiDisable) { ACPI_ERROR ((AE_INFO, "No ACPI mode transition supported in this system (enable/disable both zero)")); return_ACPI_STATUS (AE_OK); } switch (Mode) { case ACPI_SYS_MODE_ACPI: /* BIOS should have disabled ALL fixed and GP events */ Status = AcpiOsWritePort (AcpiGbl_FADT.SmiCommand, (UINT32) AcpiGbl_FADT.AcpiEnable, 8); ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Attempting to enable ACPI mode\n")); break; case ACPI_SYS_MODE_LEGACY: /* * BIOS should clear all fixed status bits and restore fixed event * enable bits to default */ Status = AcpiOsWritePort (AcpiGbl_FADT.SmiCommand, (UINT32) AcpiGbl_FADT.AcpiDisable, 8); ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Attempting to enable Legacy (non-ACPI) mode\n")); break; default: return_ACPI_STATUS (AE_BAD_PARAMETER); } if (ACPI_FAILURE (Status)) { ACPI_EXCEPTION ((AE_INFO, Status, "Could not write ACPI mode change")); return_ACPI_STATUS (Status); } /* * Some hardware takes a LONG time to switch modes. Give them 3 sec to * do so, but allow faster systems to proceed more quickly. */ Retry = 3000; while (Retry) { if (AcpiHwGetMode() == Mode) { ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Mode %X successfully enabled\n", Mode)); return_ACPI_STATUS (AE_OK); } AcpiOsStall(1000); Retry--; } ACPI_ERROR ((AE_INFO, "Hardware did not change modes")); return_ACPI_STATUS (AE_NO_HARDWARE_RESPONSE); }