/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2011, Joyent, Inc. All rights reserved. * Copyright 2011 Nexenta Systems, Inc. All rights reserved. */ /* * Copyright (c) 2009, Intel Corporation. * All rights reserved. */ /* * Solaris x86 ACPI CA services */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* * */ static struct modlmisc modlmisc = { &mod_miscops, "ACPI interpreter", }; static struct modlinkage modlinkage = { MODREV_1, /* MODREV_1 manual */ (void *)&modlmisc, /* module linkage */ NULL, /* list terminator */ }; /* * Local prototypes */ struct parsed_prw { ACPI_HANDLE prw_gpeobj; int prw_gpebit; int prw_level; }; static void acpica_init_kstats(void); static ACPI_STATUS acpica_init_PRW( ACPI_HANDLE hdl, UINT32 lvl, void *ctxp, void **rvpp); static ACPI_STATUS acpica_parse_PRW( ACPI_BUFFER *prw_buf, struct parsed_prw *prw); /* * Local data */ static kmutex_t acpica_module_lock; static kstat_t *acpica_ksp; /* * State of acpica subsystem * After successful initialization, will be ACPICA_INITIALIZED */ int acpica_init_state = ACPICA_NOT_INITIALIZED; /* * Following are set by acpica_process_user_options() * * acpica_enable = FALSE prevents initialization of ACPI CA * completely * * acpi_init_level determines level of ACPI CA functionality * enabled in acpica_init() */ int acpica_enable; UINT32 acpi_init_level; /* * Non-zero enables lax behavior with respect to some * common ACPI BIOS issues; see ACPI CA documentation * Setting this to zero causes ACPI CA to enforce strict * compliance with ACPI specification */ int acpica_enable_interpreter_slack = 1; /* * For non-DEBUG builds, set the ACPI CA debug level to 0 * to quiet chatty BIOS output into /var/adm/messages * Field-patchable for diagnostic use. */ #ifdef DEBUG int acpica_muzzle_debug_output = 0; #else int acpica_muzzle_debug_output = 1; #endif /* * ACPI DDI hooks */ static int acpica_ddi_setwake(dev_info_t *dip, int level); 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); } int _info(struct modinfo *modinfop) { return (mod_info(&modlinkage, modinfop)); } int _fini(void) { /* * acpica module is never unloaded at run-time; there's always * a PSM depending on it, at the very least */ return (EBUSY); } /* * Install acpica-provided (default) address-space handlers * that may be needed before AcpiEnableSubsystem() runs. * See the comment in AcpiInstallAddressSpaceHandler(). * Default handlers for remaining address spaces are * installed later, in AcpiEnableSubsystem. */ static int acpica_install_handlers() { ACPI_STATUS rv = AE_OK; /* * Install ACPI CA default handlers */ if (AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, ACPI_ADR_SPACE_SYSTEM_MEMORY, ACPI_DEFAULT_HANDLER, NULL, NULL) != AE_OK) { cmn_err(CE_WARN, "!acpica: no default handler for" " system memory"); rv = AE_ERROR; } if (AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, ACPI_ADR_SPACE_SYSTEM_IO, ACPI_DEFAULT_HANDLER, NULL, NULL) != AE_OK) { cmn_err(CE_WARN, "!acpica: no default handler for" " system I/O"); rv = AE_ERROR; } if (AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL) != AE_OK) { cmn_err(CE_WARN, "!acpica: no default handler for" " PCI Config"); rv = AE_ERROR; } if (AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, ACPI_ADR_SPACE_DATA_TABLE, ACPI_DEFAULT_HANDLER, NULL, NULL) != AE_OK) { cmn_err(CE_WARN, "!acpica: no default handler for" " Data Table"); rv = AE_ERROR; } return (rv); } /* * Find the BIOS date, and return TRUE if supplied * date is same or later than the BIOS date, or FALSE * if the BIOS date can't be fetched for any reason */ static int acpica_check_bios_date(int yy, int mm, int dd) { char *datep; int bios_year, bios_month, bios_day; /* If firmware has no bios, skip the check */ if (ddi_prop_exists(DDI_DEV_T_ANY, ddi_root_node(), DDI_PROP_DONTPASS, "bios-free")) return (TRUE); /* * PC BIOSes contain a string in the form of * "mm/dd/yy" at absolute address 0xffff5, * where mm, dd and yy are all ASCII digits. * We map the string, pluck out the values, * and accept all BIOSes from 1 Jan 1999 on * as valid. */ if ((datep = (char *)AcpiOsMapMemory(0xffff5, 8)) == NULL) return (FALSE); /* year */ bios_year = ((int)(*(datep + 6) - '0') * 10) + (*(datep + 7) - '0'); /* month */ bios_month = ((int)(*datep - '0') * 10) + (*(datep + 1) - '0'); /* day */ bios_day = ((int)(*(datep + 3) - '0') * 10) + (*(datep + 4) - '0'); AcpiOsUnmapMemory((void *) datep, 8); if (bios_year < 0 || bios_year > 99 || bios_month < 0 || bios_month > 99 || bios_day < 0 || bios_day > 99) { /* non-digit chars in BIOS date */ return (FALSE); } /* * Adjust for 2-digit year; note to grand-children: * need a new scheme before 2080 rolls around */ bios_year += (bios_year >= 80 && bios_year <= 99) ? 1900 : 2000; if (bios_year < yy) return (FALSE); else if (bios_year > yy) return (TRUE); if (bios_month < mm) return (FALSE); else if (bios_month > mm) return (TRUE); if (bios_day < dd) return (FALSE); return (TRUE); } /* * Check for Metropolis systems with BIOSes older than 10/12/04 * return TRUE if BIOS requires legacy mode, FALSE otherwise */ static int acpica_metro_old_bios() { ACPI_TABLE_HEADER *fadt; /* get the FADT */ if (AcpiGetTable(ACPI_SIG_FADT, 1, (ACPI_TABLE_HEADER **)&fadt) != AE_OK) return (FALSE); /* compare OEM Table ID to "SUNmetro" - no match, return false */ if (strncmp("SUNmetro", fadt->OemTableId, 8)) return (FALSE); /* On a Metro - return FALSE if later than 10/12/04 */ return (!acpica_check_bios_date(2004, 10, 12)); } /* * Process acpi-user-options property if present */ static void acpica_process_user_options() { static int processed = 0; int acpi_user_options; char *acpi_prop; /* * return if acpi-user-options has already been processed */ if (processed) return; else processed = 1; /* converts acpi-user-options from type string to int, if any */ if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(), DDI_PROP_DONTPASS, "acpi-user-options", &acpi_prop) == DDI_PROP_SUCCESS) { long data; int ret; ret = ddi_strtol(acpi_prop, NULL, 0, &data); if (ret == 0) { e_ddi_prop_remove(DDI_DEV_T_NONE, ddi_root_node(), "acpi-user-options"); e_ddi_prop_update_int(DDI_DEV_T_NONE, ddi_root_node(), "acpi-user-options", data); } ddi_prop_free(acpi_prop); } /* * fetch the optional options property */ acpi_user_options = ddi_prop_get_int(DDI_DEV_T_ANY, ddi_root_node(), DDI_PROP_DONTPASS, "acpi-user-options", 0); /* * Note that 'off' has precedence over 'on' * Also note - all cases of ACPI_OUSER_MASK * provided here, no default: case is present */ switch (acpi_user_options & ACPI_OUSER_MASK) { case ACPI_OUSER_DFLT: acpica_enable = acpica_check_bios_date(1999, 1, 1); break; case ACPI_OUSER_ON: acpica_enable = TRUE; break; case ACPI_OUSER_OFF: case ACPI_OUSER_OFF | ACPI_OUSER_ON: acpica_enable = FALSE; break; } acpi_init_level = ACPI_FULL_INITIALIZATION; /* * special test here; may be generalized in the * future - test for a machines that are known to * work only in legacy mode, and set OUSER_LEGACY if * we're on one */ if (acpica_metro_old_bios()) acpi_user_options |= ACPI_OUSER_LEGACY; /* * If legacy mode is specified, set initialization * options to avoid entering ACPI mode and hooking SCI * - basically try to act like legacy acpi_intp */ if ((acpi_user_options & ACPI_OUSER_LEGACY) != 0) acpi_init_level |= (ACPI_NO_ACPI_ENABLE | ACPI_NO_HANDLER_INIT); /* * modify default ACPI CA debug output level for non-DEBUG builds * (to avoid BIOS debug chatter in /var/adm/messages) */ if (acpica_muzzle_debug_output) AcpiDbgLevel = 0; } /* * Initialize the CA subsystem if it hasn't been done already */ int acpica_init() { extern void acpica_find_ioapics(void); ACPI_STATUS status; /* * Make sure user options are processed, * then fail to initialize if ACPI CA has been * disabled */ acpica_process_user_options(); if (!acpica_enable) return (AE_ERROR); mutex_enter(&acpica_module_lock); if (acpica_init_state == ACPICA_INITIALIZED) { mutex_exit(&acpica_module_lock); return (AE_OK); } if (ACPI_FAILURE(status = AcpiLoadTables())) goto error; if (ACPI_FAILURE(status = acpica_install_handlers())) goto error; /* * Create ACPI-to-devinfo mapping now so _INI and _STA * methods can access PCI config space when needed */ scan_d2a_map(); if (ACPI_FAILURE(status = AcpiEnableSubsystem(acpi_init_level))) goto error; /* do after AcpiEnableSubsystem() so GPEs are initialized */ acpica_ec_init(); /* initialize EC if present */ /* This runs all device _STA and _INI methods. */ if (ACPI_FAILURE(status = AcpiInitializeObjects(0))) goto error; acpica_init_state = ACPICA_INITIALIZED; /* * [ACPI, sec. 4.4.1.1] * As of ACPICA version 20101217 (December 2010), the _PRW methods * (Power Resources for Wake) are no longer automatically executed * as part of the ACPICA initialization. The OS must do this. */ (void) AcpiWalkNamespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, UINT32_MAX, acpica_init_PRW, NULL, NULL, NULL); (void) AcpiUpdateAllGpes(); /* * If we are running on the Xen hypervisor as dom0 we need to * find the ioapics so we can prevent ACPI from trying to * access them. */ if (get_hwenv() == HW_XEN_PV && is_controldom()) acpica_find_ioapics(); acpica_init_kstats(); error: if (acpica_init_state != ACPICA_INITIALIZED) { cmn_err(CE_NOTE, "!failed to initialize ACPI services"); } /* * Set acpi-status to 13 if acpica has been initialized successfully. * This indicates that acpica is up and running. This variable name * and value were chosen in order to remain compatible with acpi_intp. */ e_ddi_prop_update_int(DDI_DEV_T_NONE, ddi_root_node(), "acpi-status", (ACPI_SUCCESS(status)) ? (ACPI_BOOT_INIT | ACPI_BOOT_ENABLE | ACPI_BOOT_BOOTCONF) : 0); /* Mark acpica subsystem as fully initialized. */ if (ACPI_SUCCESS(status) && acpi_init_level == ACPI_FULL_INITIALIZATION) { acpica_set_core_feature(ACPI_FEATURE_FULL_INIT); } mutex_exit(&acpica_module_lock); return (status); } /* * SCI handling */ ACPI_STATUS acpica_get_sci(int *sci_irq, iflag_t *sci_flags) { ACPI_SUBTABLE_HEADER *ap; ACPI_TABLE_MADT *mat; ACPI_MADT_INTERRUPT_OVERRIDE *mio; ACPI_TABLE_FADT *fadt; int madt_seen, madt_size; /* * Make sure user options are processed, * then return error if ACPI CA has been * disabled or system is not running in ACPI * and won't need/understand SCI */ acpica_process_user_options(); if ((!acpica_enable) || (acpi_init_level & ACPI_NO_ACPI_ENABLE)) return (AE_ERROR); /* * according to Intel ACPI developers, SCI * conforms to PCI bus conventions; level/low * unless otherwise directed by overrides. */ sci_flags->intr_el = INTR_EL_LEVEL; sci_flags->intr_po = INTR_PO_ACTIVE_LOW; sci_flags->bustype = BUS_PCI; /* we *do* conform to PCI */ /* get the SCI from the FADT */ if (AcpiGetTable(ACPI_SIG_FADT, 1, (ACPI_TABLE_HEADER **)&fadt) != AE_OK) return (AE_ERROR); *sci_irq = fadt->SciInterrupt; /* search for ISOs that modify it */ /* if we don't find a MADT, that's OK; no ISOs then */ if (AcpiGetTable(ACPI_SIG_MADT, 1, (ACPI_TABLE_HEADER **) &mat) != AE_OK) return (AE_OK); ap = (ACPI_SUBTABLE_HEADER *) (mat + 1); madt_size = mat->Header.Length; madt_seen = sizeof (*mat); while (madt_seen < madt_size) { switch (ap->Type) { case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: mio = (ACPI_MADT_INTERRUPT_OVERRIDE *) ap; if (mio->SourceIrq == *sci_irq) { *sci_irq = mio->GlobalIrq; sci_flags->intr_el = (mio->IntiFlags & ACPI_MADT_TRIGGER_MASK) >> 2; sci_flags->intr_po = mio->IntiFlags & ACPI_MADT_POLARITY_MASK; } break; } /* advance to next entry */ madt_seen += ap->Length; ap = (ACPI_SUBTABLE_HEADER *)(((char *)ap) + ap->Length); } /* * One more check; if ISO said "conform", revert to default */ if (sci_flags->intr_el == INTR_EL_CONFORM) sci_flags->intr_el = INTR_EL_LEVEL; if (sci_flags->intr_po == INTR_PO_CONFORM) sci_flags->intr_po = INTR_PO_ACTIVE_LOW; return (AE_OK); } /* * Call-back function used for _PRW initialization. For every * device node that has a _PRW method, evaluate, parse, and do * AcpiSetupGpeForWake(). */ static ACPI_STATUS acpica_init_PRW( ACPI_HANDLE devhdl, UINT32 depth, void *ctxp, void **rvpp) { ACPI_STATUS status; ACPI_BUFFER prw_buf; struct parsed_prw prw; prw_buf.Pointer = NULL; prw_buf.Length = ACPI_ALLOCATE_BUFFER; /* * Attempt to evaluate _PRW object. * If no valid object is found, return quietly, since not all * devices have _PRW objects. */ status = AcpiEvaluateObject(devhdl, "_PRW", NULL, &prw_buf); if (ACPI_FAILURE(status)) goto done; status = acpica_parse_PRW(&prw_buf, &prw); if (ACPI_FAILURE(status)) goto done; (void) AcpiSetupGpeForWake(devhdl, prw.prw_gpeobj, prw.prw_gpebit); done: if (prw_buf.Pointer != NULL) AcpiOsFree(prw_buf.Pointer); return (AE_OK); } /* * Sets ACPI wake state for device referenced by dip. * If level is S0 (0), disables wake event; otherwise, * enables wake event which will wake system from level. */ static int acpica_ddi_setwake(dev_info_t *dip, int level) { ACPI_STATUS status; ACPI_HANDLE devobj; ACPI_BUFFER prw_buf; ACPI_OBJECT_LIST arglist; ACPI_OBJECT args[3]; struct parsed_prw prw; int rv; /* * initialize these early so we can use a common * exit point below */ prw_buf.Pointer = NULL; prw_buf.Length = ACPI_ALLOCATE_BUFFER; rv = 0; /* * Attempt to get a handle to a corresponding ACPI object. * If no object is found, return quietly, since not all * devices have corresponding ACPI objects. */ status = acpica_get_handle(dip, &devobj); if (ACPI_FAILURE(status)) { char pathbuf[MAXPATHLEN]; ddi_pathname(dip, pathbuf); #ifdef DEBUG cmn_err(CE_NOTE, "!acpica_ddi_setwake: could not get" " handle for %s, %s:%d", pathbuf, ddi_driver_name(dip), ddi_get_instance(dip)); #endif goto done; } /* * ACPI3.0 7.2.1: only use the _PSW method if OSPM does not support * _DSW or if the _DSW method is not present. * * _DSW arguments: * args[0] - Enable/Disable * args[1] - Target system state * args[2] - Target device state */ arglist.Count = 3; arglist.Pointer = args; args[0].Type = ACPI_TYPE_INTEGER; args[0].Integer.Value = level ? 1 : 0; args[1].Type = ACPI_TYPE_INTEGER; args[1].Integer.Value = level; args[2].Type = ACPI_TYPE_INTEGER; args[2].Integer.Value = level; if (ACPI_FAILURE(status = AcpiEvaluateObject(devobj, "_DSW", &arglist, NULL))) { if (status == AE_NOT_FOUND) { arglist.Count = 1; args[0].Type = ACPI_TYPE_INTEGER; args[0].Integer.Value = level ? 1 : 0; if (ACPI_FAILURE(status = AcpiEvaluateObject(devobj, "_PSW", &arglist, NULL))) { if (status != AE_NOT_FOUND) { cmn_err(CE_NOTE, "!_PSW failure %d for device %s", status, ddi_driver_name(dip)); } } } else { cmn_err(CE_NOTE, "!_DSW failure %d for device %s", status, ddi_driver_name(dip)); } } /* * Attempt to evaluate _PRW object. * If no valid object is found, return quietly, since not all * devices have _PRW objects. */ status = AcpiEvaluateObject(devobj, "_PRW", NULL, &prw_buf); if (ACPI_FAILURE(status)) goto done; status = acpica_parse_PRW(&prw_buf, &prw); if (ACPI_FAILURE(status)) goto done; rv = -1; if (level == 0) { status = AcpiDisableGpe(prw.prw_gpeobj, prw.prw_gpebit); if (ACPI_FAILURE(status)) goto done; } else if (prw.prw_level >= level) { status = AcpiSetGpeWakeMask(prw.prw_gpeobj, prw.prw_gpebit, ACPI_GPE_ENABLE); if (ACPI_SUCCESS(status)) { status = AcpiEnableGpe(prw.prw_gpeobj, prw.prw_gpebit); if (ACPI_FAILURE(status)) goto done; } } rv = 0; done: if (prw_buf.Pointer != NULL) AcpiOsFree(prw_buf.Pointer); return (rv); } static ACPI_STATUS acpica_parse_PRW( ACPI_BUFFER *prw_buf, struct parsed_prw *p_prw) { ACPI_HANDLE gpeobj; ACPI_OBJECT *prw, *gpe; int gpebit, prw_level; if (prw_buf->Length == 0 || prw_buf->Pointer == NULL) return (AE_NULL_OBJECT); prw = prw_buf->Pointer; if (prw->Type != ACPI_TYPE_PACKAGE || prw->Package.Count < 2 || prw->Package.Elements[1].Type != ACPI_TYPE_INTEGER) return (AE_TYPE); /* fetch the lowest wake level from the _PRW */ prw_level = prw->Package.Elements[1].Integer.Value; /* * process the GPE description */ switch (prw->Package.Elements[0].Type) { case ACPI_TYPE_INTEGER: gpeobj = NULL; gpebit = prw->Package.Elements[0].Integer.Value; break; case ACPI_TYPE_PACKAGE: gpe = &prw->Package.Elements[0]; if (gpe->Package.Count != 2 || gpe->Package.Elements[1].Type != ACPI_TYPE_INTEGER) return (AE_TYPE); gpeobj = gpe->Package.Elements[0].Reference.Handle; gpebit = gpe->Package.Elements[1].Integer.Value; if (gpeobj == NULL) return (AE_NULL_OBJECT); break; default: return (AE_TYPE); } p_prw->prw_gpeobj = gpeobj; p_prw->prw_gpebit = gpebit; p_prw->prw_level = prw_level; return (AE_OK); } /* * kstat access to a limited set of ACPI propertis */ static void acpica_init_kstats() { ACPI_HANDLE s3handle; ACPI_STATUS status; ACPI_TABLE_FADT *fadt; kstat_named_t *knp; /* * Create a small set of named kstats; just return in the rare * case of a failure, * in which case, the kstats won't be present. */ if ((acpica_ksp = kstat_create("acpi", 0, "acpi", "misc", KSTAT_TYPE_NAMED, 2, 0)) == NULL) return; /* * initialize kstat 'S3' to reflect the presence of \_S3 in * the ACPI namespace (1 = present, 0 = not present) */ knp = acpica_ksp->ks_data; knp->value.l = (AcpiGetHandle(NULL, "\\_S3", &s3handle) == AE_OK); kstat_named_init(knp, "S3", KSTAT_DATA_LONG); knp++; /* advance to next named kstat */ /* * initialize kstat 'preferred_pm_profile' to the value * contained in the (always present) FADT */ status = AcpiGetTable(ACPI_SIG_FADT, 1, (ACPI_TABLE_HEADER **)&fadt); knp->value.l = (status == AE_OK) ? fadt->PreferredProfile : -1; kstat_named_init(knp, "preferred_pm_profile", KSTAT_DATA_LONG); /* * install the named kstats */ kstat_install(acpica_ksp); } /* * Attempt to save the current ACPI settings (_CRS) for the device * which corresponds to the supplied devinfo node. The settings are * saved as a property on the dip. If no ACPI object is found to be * associated with the devinfo node, no action is taken and no error * is reported. */ void acpica_ddi_save_resources(dev_info_t *dip) { ACPI_HANDLE devobj; ACPI_BUFFER resbuf; int ret; resbuf.Length = ACPI_ALLOCATE_BUFFER; if (ACPI_FAILURE(acpica_get_handle(dip, &devobj)) || ACPI_FAILURE(AcpiGetCurrentResources(devobj, &resbuf))) return; ret = ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP, "acpi-crs", resbuf.Pointer, resbuf.Length); ASSERT(ret == DDI_PROP_SUCCESS); AcpiOsFree(resbuf.Pointer); } /* * If the supplied devinfo node has an ACPI settings property attached, * restore them to the associated ACPI device using _SRS. The property * is deleted from the devinfo node afterward. */ void acpica_ddi_restore_resources(dev_info_t *dip) { ACPI_HANDLE devobj; ACPI_BUFFER resbuf; uchar_t *propdata; uint_t proplen; if (ACPI_FAILURE(acpica_get_handle(dip, &devobj))) return; if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "acpi-crs", &propdata, &proplen) != DDI_PROP_SUCCESS) return; resbuf.Pointer = propdata; resbuf.Length = proplen; (void) AcpiSetCurrentResources(devobj, &resbuf); ddi_prop_free(propdata); (void) ddi_prop_remove(DDI_DEV_T_NONE, dip, "acpi-crs"); } void acpi_reset_system(void) { ACPI_STATUS status; int ten; status = AcpiReset(); if (status == AE_OK) { /* * Wait up to 500 milliseconds for AcpiReset() to make its * way. */ ten = 50000; while (ten-- > 0) tenmicrosec(); } }