version 1.101, 2007/02/19 22:31:05 |
version 1.101.16.22, 2007/10/28 17:20:43 |
Line 122 MALLOC_DECLARE(M_ACPI); |
|
Line 122 MALLOC_DECLARE(M_ACPI); |
|
static int acpi_dbgr = 0x00; |
static int acpi_dbgr = 0x00; |
#endif |
#endif |
|
|
|
static ACPI_TABLE_DESC acpi_initial_tables[128]; |
|
|
static int acpi_match(struct device *, struct cfdata *, void *); |
static int acpi_match(struct device *, struct cfdata *, void *); |
static void acpi_attach(struct device *, struct device *, void *); |
static void acpi_attach(struct device *, struct device *, void *); |
|
|
Line 203 acpi_probe(void) |
|
Line 205 acpi_probe(void) |
|
acpi_osd_debugger(); |
acpi_osd_debugger(); |
#endif |
#endif |
|
|
|
AcpiGbl_AllMethodsSerialized = FALSE; |
|
AcpiGbl_EnableInterpreterSlack = TRUE; |
|
|
rv = AcpiInitializeSubsystem(); |
rv = AcpiInitializeSubsystem(); |
if (ACPI_FAILURE(rv)) { |
if (ACPI_FAILURE(rv)) { |
printf("ACPI: unable to initialize ACPICA: %s\n", |
printf("ACPI: unable to initialize ACPICA: %s\n", |
Line 210 acpi_probe(void) |
|
Line 215 acpi_probe(void) |
|
return 0; |
return 0; |
} |
} |
|
|
|
rv = AcpiInitializeTables(acpi_initial_tables, 128, 0); |
|
if (ACPI_FAILURE(rv)) { |
|
printf("ACPI: unable to initialize ACPI tables: %s\n", |
|
AcpiFormatException(rv)); |
|
return 0; |
|
} |
|
|
|
rv = AcpiReallocateRootTable(); |
|
if (ACPI_FAILURE(rv)) { |
|
printf("ACPI: unable to reallocate root table: %s\n", |
|
AcpiFormatException(rv)); |
|
return 0; |
|
} |
|
|
#ifdef ACPI_DEBUGGER |
#ifdef ACPI_DEBUGGER |
if (acpi_dbgr & ACPI_DBGR_TABLES) |
if (acpi_dbgr & ACPI_DBGR_TABLES) |
acpi_osd_debugger(); |
acpi_osd_debugger(); |
Line 222 acpi_probe(void) |
|
Line 241 acpi_probe(void) |
|
return 0; |
return 0; |
} |
} |
|
|
|
#if notyet |
if (!acpi_force_load && (acpi_find_quirks() & ACPI_QUIRK_BROKEN)) { |
if (!acpi_force_load && (acpi_find_quirks() & ACPI_QUIRK_BROKEN)) { |
printf("ACPI: BIOS implementation in listed as broken:\n"); |
printf("ACPI: BIOS implementation in listed as broken:\n"); |
printf("ACPI: X/RSDT: OemId <%6.6s,%8.8s,%08x>, " |
printf("ACPI: X/RSDT: OemId <%6.6s,%8.8s,%08x>, " |
Line 235 acpi_probe(void) |
|
Line 254 acpi_probe(void) |
|
return 0; |
return 0; |
} |
} |
|
|
|
/* Install the default address space handlers. */ |
|
rv = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, |
|
ACPI_ADR_SPACE_SYSTEM_MEMORY, ACPI_DEFAULT_HANDLER, NULL, NULL); |
|
if (ACPI_FAILURE(rv)) { |
|
printf("ACPI: unable to initialise SystemMemory handler: %s\n", |
|
AcpiFormatException(rv)); |
|
return 0; |
|
} |
|
rv = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, |
|
ACPI_ADR_SPACE_SYSTEM_IO, ACPI_DEFAULT_HANDLER, NULL, NULL); |
|
if (ACPI_FAILURE(rv)) { |
|
printf("ACPI: unable to initialise SystemIO handler: %s\n", |
|
AcpiFormatException(rv)); |
|
return 0; |
|
} |
|
rv = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, |
|
ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL); |
|
if (ACPI_FAILURE(rv)) { |
|
printf("ACPI: unabled to initialise PciConfig handler: %s\n", |
|
AcpiFormatException(rv)); |
|
return 0; |
|
} |
|
#endif |
|
|
|
rv = AcpiEnableSubsystem(~(ACPI_NO_HARDWARE_INIT|ACPI_NO_ACPI_ENABLE)); |
|
if (ACPI_FAILURE(rv)) { |
|
printf("ACPI: unable to enable: %s\n", AcpiFormatException(rv)); |
|
return 0; |
|
} |
|
|
/* |
/* |
* Looks like we have ACPI! |
* Looks like we have ACPI! |
*/ |
*/ |
Line 257 acpi_check(device_t parent, const char * |
|
Line 306 acpi_check(device_t parent, const char * |
|
return (config_search_ia(acpi_submatch, parent, ifattr, NULL) != NULL); |
return (config_search_ia(acpi_submatch, parent, ifattr, NULL) != NULL); |
} |
} |
|
|
ACPI_STATUS |
ACPI_PHYSICAL_ADDRESS |
acpi_OsGetRootPointer(UINT32 Flags, ACPI_POINTER *PhysicalAddress) |
acpi_OsGetRootPointer(void) |
{ |
{ |
ACPI_STATUS rv; |
ACPI_PHYSICAL_ADDRESS PhysicalAddress; |
|
|
/* |
/* |
* IA-32: Use AcpiFindRootPointer() to locate the RSDP. |
* IA-32: Use AcpiFindRootPointer() to locate the RSDP. |
Line 271 acpi_OsGetRootPointer(UINT32 Flags, ACPI |
|
Line 320 acpi_OsGetRootPointer(UINT32 Flags, ACPI |
|
* ways to do it. |
* ways to do it. |
*/ |
*/ |
|
|
rv = acpi_md_OsGetRootPointer(Flags, PhysicalAddress); |
PhysicalAddress = acpi_md_OsGetRootPointer(); |
|
|
if (acpi_root_pointer == 0 && ACPI_SUCCESS(rv)) |
if (acpi_root_pointer == 0) |
acpi_root_pointer = |
acpi_root_pointer = PhysicalAddress; |
(uint64_t)PhysicalAddress->Pointer.Physical; |
|
|
|
return rv; |
return PhysicalAddress; |
} |
} |
|
|
/* |
/* |
Line 324 acpi_attach(struct device *parent, struc |
|
Line 372 acpi_attach(struct device *parent, struc |
|
aprint_verbose("%s: using Intel ACPI CA subsystem version %08x\n", |
aprint_verbose("%s: using Intel ACPI CA subsystem version %08x\n", |
sc->sc_dev.dv_xname, ACPI_CA_VERSION); |
sc->sc_dev.dv_xname, ACPI_CA_VERSION); |
|
|
|
#if 0 |
aprint_verbose("%s: X/RSDT: OemId <%6.6s,%8.8s,%08x>, AslId <%4.4s,%08x>\n", |
aprint_verbose("%s: X/RSDT: OemId <%6.6s,%8.8s,%08x>, AslId <%4.4s,%08x>\n", |
sc->sc_dev.dv_xname, |
sc->sc_dev.dv_xname, |
AcpiGbl_XSDT->OemId, AcpiGbl_XSDT->OemTableId, |
AcpiGbl_XSDT->OemId, AcpiGbl_XSDT->OemTableId, |
AcpiGbl_XSDT->OemRevision, |
AcpiGbl_XSDT->OemRevision, |
AcpiGbl_XSDT->AslCompilerId, AcpiGbl_XSDT->AslCompilerRevision); |
AcpiGbl_XSDT->AslCompilerId, AcpiGbl_XSDT->AslCompilerRevision); |
|
#endif |
|
|
sc->sc_quirks = acpi_find_quirks(); |
sc->sc_quirks = acpi_find_quirks(); |
|
|
Line 341 acpi_attach(struct device *parent, struc |
|
Line 391 acpi_attach(struct device *parent, struc |
|
acpi_softc = sc; |
acpi_softc = sc; |
|
|
/* |
/* |
|
* Register null power management handler |
|
*/ |
|
(void)pnp_register(self, pnp_generic_power); |
|
|
|
/* |
* Bring ACPI on-line. |
* Bring ACPI on-line. |
*/ |
*/ |
#ifdef ACPI_DEBUGGER |
#ifdef ACPI_DEBUGGER |
Line 348 acpi_attach(struct device *parent, struc |
|
Line 403 acpi_attach(struct device *parent, struc |
|
acpi_osd_debugger(); |
acpi_osd_debugger(); |
#endif |
#endif |
|
|
rv = AcpiEnableSubsystem(0); |
#define ACPI_ENABLE_PHASE1 \ |
|
(ACPI_NO_HANDLER_INIT | ACPI_NO_EVENT_INIT) |
|
#define ACPI_ENABLE_PHASE2 \ |
|
(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE | \ |
|
ACPI_NO_ADDRESS_SPACE_INIT) |
|
|
|
rv = AcpiEnableSubsystem(ACPI_ENABLE_PHASE1); |
|
if (ACPI_FAILURE(rv)) { |
|
aprint_error("%s: unable to enable ACPI: %s\n", |
|
sc->sc_dev.dv_xname, AcpiFormatException(rv)); |
|
return; |
|
} |
|
|
|
acpi_md_callback(); |
|
|
|
rv = AcpiEnableSubsystem(ACPI_ENABLE_PHASE2); |
if (ACPI_FAILURE(rv)) { |
if (ACPI_FAILURE(rv)) { |
aprint_error("%s: unable to enable ACPI: %s\n", |
aprint_error("%s: unable to enable ACPI: %s\n", |
sc->sc_dev.dv_xname, AcpiFormatException(rv)); |
sc->sc_dev.dv_xname, AcpiFormatException(rv)); |
Line 356 acpi_attach(struct device *parent, struc |
|
Line 426 acpi_attach(struct device *parent, struc |
|
} |
} |
|
|
/* early EC handler initialization if ECDT table is available */ |
/* early EC handler initialization if ECDT table is available */ |
#if NACPIEC > 0 |
config_found_ia(&sc->sc_dev, "acpiecdtbus", NULL, NULL); |
acpiec_early_attach(&sc->sc_dev); |
|
#endif |
|
|
|
rv = AcpiInitializeObjects(0); |
rv = AcpiInitializeObjects(ACPI_FULL_INITIALIZATION); |
if (ACPI_FAILURE(rv)) { |
if (ACPI_FAILURE(rv)) { |
aprint_error("%s: unable to initialize ACPI objects: %s\n", |
aprint_error("%s: unable to initialize ACPI objects: %s\n", |
sc->sc_dev.dv_xname, AcpiFormatException(rv)); |
sc->sc_dev.dv_xname, AcpiFormatException(rv)); |
Line 372 acpi_attach(struct device *parent, struc |
|
Line 440 acpi_attach(struct device *parent, struc |
|
sc->sc_sleepstate = ACPI_STATE_S0; |
sc->sc_sleepstate = ACPI_STATE_S0; |
|
|
/* Show SCI interrupt. */ |
/* Show SCI interrupt. */ |
if (AcpiGbl_FADT != NULL) |
aprint_verbose("%s: SCI interrupting at int %d\n", |
aprint_verbose("%s: SCI interrupting at int %d\n", |
sc->sc_dev.dv_xname, AcpiGbl_FADT.SciInterrupt); |
sc->sc_dev.dv_xname, AcpiGbl_FADT->SciInt); |
|
/* |
/* |
* Check for fixed-hardware features. |
* Check for fixed-hardware features. |
*/ |
*/ |
Line 388 acpi_attach(struct device *parent, struc |
|
Line 456 acpi_attach(struct device *parent, struc |
|
if (acpi_dbgr & ACPI_DBGR_PROBE) |
if (acpi_dbgr & ACPI_DBGR_PROBE) |
acpi_osd_debugger(); |
acpi_osd_debugger(); |
#endif |
#endif |
acpi_md_callback((struct device *)sc); |
|
acpi_build_tree(sc); |
acpi_build_tree(sc); |
|
|
if (acpi_root_pointer != 0 && acpi_node != CTL_EOL) { |
if (acpi_root_pointer != 0 && acpi_node != CTL_EOL) { |
Line 529 acpi_build_tree(struct acpi_softc *sc) |
|
Line 596 acpi_build_tree(struct acpi_softc *sc) |
|
(ACPI_STA_DEV_PRESENT|ACPI_STA_DEV_ENABLED| |
(ACPI_STA_DEV_PRESENT|ACPI_STA_DEV_ENABLED| |
ACPI_STA_DEV_OK)) |
ACPI_STA_DEV_OK)) |
continue; |
continue; |
|
|
/* |
|
* XXX Same problem as above... |
|
*/ |
|
if ((ad->ad_devinfo->Valid & ACPI_VALID_HID) |
|
== 0) |
|
continue; |
|
} |
} |
|
|
|
/* |
|
* XXX Same problem as above... |
|
* |
|
* Do this check only for devices, as e.g. |
|
* a Thermal Zone doesn't have a HID. |
|
*/ |
|
if (ad->ad_devinfo->Type == ACPI_TYPE_DEVICE && |
|
(ad->ad_devinfo->Valid & ACPI_VALID_HID) == 0) |
|
continue; |
|
|
ad->ad_device = config_found_ia(&sc->sc_dev, |
ad->ad_device = config_found_ia(&sc->sc_dev, |
"acpinodebus", &aa, acpi_print); |
"acpinodebus", &aa, acpi_print); |
} |
} |
Line 599 acpi_make_devnode(ACPI_HANDLE handle, UI |
|
Line 669 acpi_make_devnode(ACPI_HANDLE handle, UI |
|
ACPI_BUFFER buf; |
ACPI_BUFFER buf; |
ACPI_DEVICE_INFO *devinfo; |
ACPI_DEVICE_INFO *devinfo; |
ACPI_STATUS rv; |
ACPI_STATUS rv; |
|
ACPI_NAME_UNION *anu; |
|
int i, clear = 0; |
|
|
rv = AcpiGetType(handle, &type); |
rv = AcpiGetType(handle, &type); |
if (ACPI_SUCCESS(rv)) { |
if (ACPI_SUCCESS(rv)) { |
Line 641 acpi_make_devnode(ACPI_HANDLE handle, UI |
|
Line 713 acpi_make_devnode(ACPI_HANDLE handle, UI |
|
ad->ad_scope = as; |
ad->ad_scope = as; |
ad->ad_type = type; |
ad->ad_type = type; |
|
|
|
anu = (ACPI_NAME_UNION *)&devinfo->Name; |
|
ad->ad_name[4] = '\0'; |
|
for (i = 3, clear = 0; i >= 0; i--) { |
|
if (!clear && anu->Ascii[i] == '_') |
|
ad->ad_name[i] = '\0'; |
|
else { |
|
ad->ad_name[i] = anu->Ascii[i]; |
|
clear = 1; |
|
} |
|
} |
|
if (ad->ad_name[0] == '\0') |
|
ad->ad_name[0] = '_'; |
|
|
TAILQ_INSERT_TAIL(&as->as_devnodes, ad, ad_list); |
TAILQ_INSERT_TAIL(&as->as_devnodes, ad, ad_list); |
|
|
if ((ad->ad_devinfo->Valid & ACPI_VALID_HID) == 0) |
if (type == ACPI_TYPE_DEVICE && |
|
(ad->ad_devinfo->Valid & ACPI_VALID_HID) == 0) |
goto out; |
goto out; |
|
|
#ifdef ACPI_EXTRA_DEBUG |
#ifdef ACPI_EXTRA_DEBUG |
Line 684 acpi_print(void *aux, const char *pnp) |
|
Line 770 acpi_print(void *aux, const char *pnp) |
|
aa->aa_node->ad_devinfo->HardwareId.Value; |
aa->aa_node->ad_devinfo->HardwareId.Value; |
char *str; |
char *str; |
|
|
aprint_normal("%s ", pnpstr); |
aprint_normal("%s (%s) ", aa->aa_node->ad_name, |
|
pnpstr); |
rv = acpi_eval_string(aa->aa_node->ad_handle, |
rv = acpi_eval_string(aa->aa_node->ad_handle, |
"_STR", &str); |
"_STR", &str); |
if (ACPI_SUCCESS(rv)) { |
if (ACPI_SUCCESS(rv)) { |
Line 706 acpi_print(void *aux, const char *pnp) |
|
Line 793 acpi_print(void *aux, const char *pnp) |
|
} |
} |
|
|
#endif |
#endif |
} else { |
aprint_normal("at %s", pnp); |
aprint_normal("ACPI Object Type '%s' (0x%02x) ", |
} else if (aa->aa_node->ad_devinfo->Type != ACPI_TYPE_DEVICE) { |
AcpiUtGetTypeName(aa->aa_node->ad_devinfo->Type), |
aprint_normal("%s (ACPI Object Type '%s' " |
aa->aa_node->ad_devinfo->Type); |
"[0x%02x]) ", aa->aa_node->ad_name, |
} |
AcpiUtGetTypeName(aa->aa_node->ad_devinfo->Type), |
aprint_normal("at %s", pnp); |
aa->aa_node->ad_devinfo->Type); |
|
aprint_normal("at %s", pnp); |
|
} else |
|
return 0; |
} else { |
} else { |
|
aprint_normal(" (%s", aa->aa_node->ad_name); |
if (aa->aa_node->ad_devinfo->Valid & ACPI_VALID_HID) { |
if (aa->aa_node->ad_devinfo->Valid & ACPI_VALID_HID) { |
aprint_normal(" (%s", aa->aa_node->ad_devinfo->HardwareId.Value); |
aprint_normal(", %s", aa->aa_node->ad_devinfo->HardwareId.Value); |
if (aa->aa_node->ad_devinfo->Valid & ACPI_VALID_UID) { |
if (aa->aa_node->ad_devinfo->Valid & ACPI_VALID_UID) { |
const char *uid; |
const char *uid; |
|
|
Line 723 acpi_print(void *aux, const char *pnp) |
|
Line 814 acpi_print(void *aux, const char *pnp) |
|
uid = "<null>"; |
uid = "<null>"; |
aprint_normal("-%s", uid); |
aprint_normal("-%s", uid); |
} |
} |
aprint_normal(")"); |
|
} |
} |
|
aprint_normal(")"); |
} |
} |
|
|
return UNCONF; |
return UNCONF; |
Line 755 acpi_enable_fixed_events(struct acpi_sof |
|
Line 846 acpi_enable_fixed_events(struct acpi_sof |
|
* Check for fixed-hardware buttons. |
* Check for fixed-hardware buttons. |
*/ |
*/ |
|
|
if (AcpiGbl_FADT != NULL && AcpiGbl_FADT->PwrButton == 0) { |
if ((AcpiGbl_FADT.Flags & ACPI_FADT_POWER_BUTTON) == 0) { |
aprint_verbose("%s: fixed-feature power button present\n", |
aprint_verbose("%s: fixed-feature power button present\n", |
sc->sc_dev.dv_xname); |
sc->sc_dev.dv_xname); |
sc->sc_smpsw_power.smpsw_name = sc->sc_dev.dv_xname; |
sc->sc_smpsw_power.smpsw_name = sc->sc_dev.dv_xname; |
Line 776 acpi_enable_fixed_events(struct acpi_sof |
|
Line 867 acpi_enable_fixed_events(struct acpi_sof |
|
} |
} |
} |
} |
|
|
if (AcpiGbl_FADT != NULL && AcpiGbl_FADT->SleepButton == 0) { |
if ((AcpiGbl_FADT.Flags & ACPI_FADT_SLEEP_BUTTON) == 0) { |
aprint_verbose("%s: fixed-feature sleep button present\n", |
aprint_verbose("%s: fixed-feature sleep button present\n", |
sc->sc_dev.dv_xname); |
sc->sc_dev.dv_xname); |
sc->sc_smpsw_sleep.smpsw_name = sc->sc_dev.dv_xname; |
sc->sc_smpsw_sleep.smpsw_name = sc->sc_dev.dv_xname; |
Line 813 acpi_fixed_button_handler(void *context) |
|
Line 904 acpi_fixed_button_handler(void *context) |
|
printf("%s: fixed button handler\n", smpsw->smpsw_name); |
printf("%s: fixed button handler\n", smpsw->smpsw_name); |
#endif |
#endif |
|
|
rv = AcpiOsQueueForExecution(OSD_PRIORITY_LO, |
rv = AcpiOsExecute(OSL_NOTIFY_HANDLER, |
acpi_fixed_button_pressed, smpsw); |
acpi_fixed_button_pressed, smpsw); |
if (ACPI_FAILURE(rv)) |
if (ACPI_FAILURE(rv)) |
printf("%s: WARNING: unable to queue fixed button pressed " |
printf("%s: WARNING: unable to queue fixed button pressed " |
Line 1067 is_available_state(struct acpi_softc *sc |
|
Line 1158 is_available_state(struct acpi_softc *sc |
|
ACPI_STATUS |
ACPI_STATUS |
acpi_enter_sleep_state(struct acpi_softc *sc, int state) |
acpi_enter_sleep_state(struct acpi_softc *sc, int state) |
{ |
{ |
int s; |
int err; |
ACPI_STATUS ret = AE_OK; |
ACPI_STATUS ret = AE_OK; |
|
|
if (state == acpi_sleepstate) |
if (state == acpi_sleepstate) |
Line 1087 acpi_enter_sleep_state(struct acpi_softc |
|
Line 1178 acpi_enter_sleep_state(struct acpi_softc |
|
sc->sc_dev.dv_xname, state); |
sc->sc_dev.dv_xname, state); |
break; |
break; |
} |
} |
|
|
|
if (state != ACPI_STATE_S1) |
|
pnp_global_transition(PNP_STATE_D3); |
|
|
ret = AcpiEnterSleepStatePrep(state); |
ret = AcpiEnterSleepStatePrep(state); |
if (ACPI_FAILURE(ret)) { |
if (ACPI_FAILURE(ret)) { |
aprint_error("%s: failed preparing to sleep (%s)\n", |
aprint_error("%s: failed preparing to sleep (%s)\n", |
sc->sc_dev.dv_xname, AcpiFormatException(ret)); |
sc->sc_dev.dv_xname, AcpiFormatException(ret)); |
break; |
break; |
} |
} |
|
|
|
DELAY(1000000); |
acpi_sleepstate = state; |
acpi_sleepstate = state; |
if (state == ACPI_STATE_S1) { |
if (state == ACPI_STATE_S1) { |
/* just enter the state */ |
/* just enter the state */ |
acpi_md_OsDisableInterrupt(); |
acpi_md_OsDisableInterrupt(); |
AcpiEnterSleepState((UINT8)state); |
AcpiEnterSleepState((UINT8)state); |
|
AcpiLeaveSleepState((UINT8)state); |
} else { |
} else { |
/* XXX: powerhooks(9) framework is too poor to |
err = acpi_md_sleep(state); |
* support ACPI sleep state... |
if (state == ACPI_STATE_S4) |
*/ |
|
dopowerhooks(PWR_SOFTSUSPEND); |
|
s = splhigh(); |
|
dopowerhooks(PWR_SUSPEND); |
|
acpi_md_sleep(state); |
|
dopowerhooks(PWR_RESUME); |
|
splx(s); |
|
dopowerhooks(PWR_SOFTRESUME); |
|
if (state==ACPI_STATE_S4) |
|
AcpiEnable(); |
AcpiEnable(); |
|
AcpiLeaveSleepState((UINT8)state); |
|
pnp_global_transition(PNP_STATE_D0); |
} |
} |
AcpiLeaveSleepState((UINT8)state); |
|
break; |
break; |
case ACPI_STATE_S5: |
case ACPI_STATE_S5: |
ret = AcpiEnterSleepStatePrep(ACPI_STATE_S5); |
ret = AcpiEnterSleepStatePrep(ACPI_STATE_S5); |
Line 1121 acpi_enter_sleep_state(struct acpi_softc |
|
Line 1212 acpi_enter_sleep_state(struct acpi_softc |
|
sc->sc_dev.dv_xname, AcpiFormatException(ret)); |
sc->sc_dev.dv_xname, AcpiFormatException(ret)); |
break; |
break; |
} |
} |
|
DELAY(1000000); |
acpi_sleepstate = state; |
acpi_sleepstate = state; |
acpi_md_OsDisableInterrupt(); |
acpi_md_OsDisableInterrupt(); |
AcpiEnterSleepState(ACPI_STATE_S5); |
AcpiEnterSleepState(ACPI_STATE_S5); |
Line 1129 acpi_enter_sleep_state(struct acpi_softc |
|
Line 1221 acpi_enter_sleep_state(struct acpi_softc |
|
break; |
break; |
} |
} |
|
|
aprint_normal("%s: resuming\n", sc->sc_dev.dv_xname); |
|
acpi_sleepstate = ACPI_STATE_S0; |
acpi_sleepstate = ACPI_STATE_S0; |
return ret; |
return ret; |
} |
} |