自学教程：C++ ACPI_VPRINT函数代码示例

static ACPI_STATUSEcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data){    ACPI_STATUS	Status;    if (!EcIsLocked(sc))	ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),	    "EcRead called without EC lock!/n");    /*EcBurstEnable(EmbeddedController);*/    EC_SET_CSR(sc, EC_COMMAND_READ);    if (ACPI_FAILURE(Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY))) {	ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),	    "EcRead: Failed waiting for EC to process read command./n");	return(Status);    }    EC_SET_DATA(sc, Address);    if (ACPI_FAILURE(Status = EcWaitEventIntr(sc, EC_EVENT_OUTPUT_BUFFER_FULL))) {	ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),	    "EcRead: Failed waiting for EC to send data./n");	return(Status);    }    (*Data) = EC_GET_DATA(sc);    /*EcBurstDisable(EmbeddedController);*/    return(AE_OK);}    

static voidacpi_button_notify_pressed_for_sleep(void *arg){    struct acpi_button_softc	*sc;    struct acpi_softc		*acpi_sc;    ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);    sc = (struct acpi_button_softc *)arg;    acpi_sc = acpi_device_get_parent_softc(sc->button_dev);    if (acpi_sc == NULL) {	return_VOID;    }    switch (sc->button_type) {    case ACPI_POWER_BUTTON:	ACPI_VPRINT(sc->button_dev, acpi_sc, "power button pressed/n");	acpi_eventhandler_power_button_for_sleep((void *)acpi_sc);	break;    case ACPI_SLEEP_BUTTON:	ACPI_VPRINT(sc->button_dev, acpi_sc, "sleep button pressed/n");	acpi_eventhandler_sleep_button_for_sleep((void *)acpi_sc);	break;    default:	break;		/* unknown button type */    }    return_VOID;}

static voidacpi_button_notify_wakeup(void *arg){    struct acpi_button_softc	*sc;    struct acpi_softc		*acpi_sc;    ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);    sc = (struct acpi_button_softc *)arg;    acpi_sc = acpi_device_get_parent_softc(sc->button_dev);    if (acpi_sc == NULL)	return_VOID;    acpi_UserNotify("Button", sc->button_handle, sc->button_type);    switch (sc->button_type) {    case ACPI_POWER_BUTTON:	ACPI_VPRINT(sc->button_dev, acpi_sc, "wakeup by power button/n");	acpi_event_power_button_wake(acpi_sc);	break;    case ACPI_SLEEP_BUTTON:	ACPI_VPRINT(sc->button_dev, acpi_sc, "wakeup by sleep button/n");	acpi_event_sleep_button_wake(acpi_sc);	break;    default:	break;		/* unknown button type */    }}

intacpi_PkgGas(device_t dev, ACPI_OBJECT *res, int idx, int *rid,	    struct resource **dst){    ACPI_GENERIC_ADDRESS gas;    ACPI_OBJECT		*obj;    obj = &res->Package.Elements[idx];    if (obj == NULL || obj->Type != ACPI_TYPE_BUFFER ||	obj->Buffer.Length < sizeof(ACPI_GENERIC_ADDRESS) + 3) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "PkgGas error at %d/n", idx);	return (-1);    }    memcpy(&gas, obj->Buffer.Pointer + 3, sizeof(gas));    *dst = acpi_bus_alloc_gas(dev, rid, &gas);    if (*dst == NULL) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "PkgGas error at %d/n", idx);	return (-1);    }    return (0);}

static voidacpi_cmbat_get_bst(void *arg){    struct acpi_cmbat_softc *sc;    ACPI_STATUS	as;    ACPI_OBJECT	*res;    ACPI_HANDLE	h;    ACPI_BUFFER	bst_buffer;    device_t dev;    ACPI_SERIAL_ASSERT(cmbat);    dev = arg;    sc = device_get_softc(dev);    h = acpi_get_handle(dev);    bst_buffer.Pointer = NULL;    bst_buffer.Length = ACPI_ALLOCATE_BUFFER;    if (!acpi_cmbat_info_expired(&sc->bst_lastupdated))	goto end;    as = AcpiEvaluateObject(h, "_BST", NULL, &bst_buffer);    if (ACPI_FAILURE(as)) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "error fetching current battery status -- %s/n",		    AcpiFormatException(as));	goto end;    }    res = (ACPI_OBJECT *)bst_buffer.Pointer;    if (!ACPI_PKG_VALID(res, 4)) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "battery status corrupted/n");	goto end;    }    if (acpi_PkgInt32(res, 0, &sc->bst.state) != 0)	goto end;    if (acpi_PkgInt32(res, 1, &sc->bst.rate) != 0)	goto end;    if (acpi_PkgInt32(res, 2, &sc->bst.cap) != 0)	goto end;    if (acpi_PkgInt32(res, 3, &sc->bst.volt) != 0)	goto end;    acpi_cmbat_info_updated(&sc->bst_lastupdated);    /* XXX If all batteries are critical, perhaps we should suspend. */    if (sc->bst.state & ACPI_BATT_STAT_CRITICAL) {    	if ((sc->flags & ACPI_BATT_STAT_CRITICAL) == 0) {	    sc->flags |= ACPI_BATT_STAT_CRITICAL;	    device_printf(dev, "critically low charge!/n");	}    } else	sc->flags &= ~ACPI_BATT_STAT_CRITICAL;end:    if (bst_buffer.Pointer != NULL)	AcpiOsFree(bst_buffer.Pointer);}

static voidacpi_cmbat_get_bif(void *context){	device_t	dev;	struct acpi_cmbat_softc *sc;	ACPI_STATUS	as;	ACPI_OBJECT	*res, *tmp;	ACPI_HANDLE	h;	ACPI_BUFFER	bif_buffer;	dev = context;	sc = device_get_softc(dev);	h = acpi_get_handle(dev);	bif_buffer.Pointer = NULL;	if (!acpi_cmbat_info_expired(&sc->bif_lastupdated)) {		return;	}	if (sc->bif_updating) {		return;	}	sc->bif_updating = 1;	bif_buffer.Length = ACPI_ALLOCATE_BUFFER;	if (ACPI_FAILURE(as = AcpiEvaluateObject(h, "_BIF", NULL, &bif_buffer))) {		ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "error fetching current battery info -- %s/n",		    AcpiFormatException(as));		goto end;	}	res = (ACPI_OBJECT *)bif_buffer.Pointer;	if ((res == NULL) || (res->Type != ACPI_TYPE_PACKAGE) || (res->Package.Count != 13)) {		ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "battery info corrupted/n");		goto end;	}	PKG_GETINT(res, tmp,  0, sc->bif.unit, end);	PKG_GETINT(res, tmp,  1, sc->bif.dcap, end);	PKG_GETINT(res, tmp,  2, sc->bif.lfcap, end);	PKG_GETINT(res, tmp,  3, sc->bif.btech, end);	PKG_GETINT(res, tmp,  4, sc->bif.dvol, end);	PKG_GETINT(res, tmp,  5, sc->bif.wcap, end);	PKG_GETINT(res, tmp,  6, sc->bif.lcap, end);	PKG_GETINT(res, tmp,  7, sc->bif.gra1, end);	PKG_GETINT(res, tmp,  8, sc->bif.gra2, end);	PKG_GETSTR(res, tmp,  9, sc->bif.model, ACPI_CMBAT_MAXSTRLEN, end);	PKG_GETSTR(res, tmp, 10, sc->bif.serial, ACPI_CMBAT_MAXSTRLEN, end);	PKG_GETSTR(res, tmp, 11, sc->bif.type, ACPI_CMBAT_MAXSTRLEN, end);	PKG_GETSTR(res, tmp, 12, sc->bif.oeminfo, ACPI_CMBAT_MAXSTRLEN, end);	acpi_cmbat_info_updated(&sc->bif_lastupdated);end:	if (bif_buffer.Pointer != NULL)		AcpiOsFree(bif_buffer.Pointer);	sc->bif_updating = 0;}

static ACPI_STATUSEcTransaction(struct acpi_ec_softc *sc, EC_REQUEST *EcRequest){    ACPI_STATUS	Status;    /*     * Lock the EC     */    if (ACPI_FAILURE(Status = EcLock(sc)))	return(Status);    /*     * Perform the transaction.     */    switch (EcRequest->Command) {    case EC_COMMAND_READ:	Status = EcRead(sc, EcRequest->Address, &(EcRequest->Data));	break;    case EC_COMMAND_WRITE:	Status = EcWrite(sc, EcRequest->Address, &(EcRequest->Data));	break;    default:	Status = AE_SUPPORT;	break;    }    /*     * Unlock the EC     */    EcUnlock(sc);        /*     * Clear & Re-Enable the EC GPE:     * -----------------------------     * 'Consume' any EC GPE events that we generated while performing     * the transaction (e.g. IBF/OBF).	Clearing the GPE here shouldn't     * have an adverse affect on outstanding EC-SCI's, as the source     * (EC-SCI) will still be high and thus should trigger the GPE     * immediately after we re-enabling it.     */    if (sc->ec_pendquery){	if (ACPI_FAILURE(AcpiOsQueueForExecution(OSD_PRIORITY_HIGH,						 EcGpeQueryHandler, sc)))	    printf("Pend Query Queuing Failed/n");	sc->ec_pendquery = 0;    }    if (ACPI_FAILURE(AcpiClearEvent(sc->ec_gpebit, ACPI_EVENT_GPE)))	ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),	    "EcRequest: Unable to clear the EC GPE./n");    if (ACPI_FAILURE(AcpiEnableEvent(sc->ec_gpebit, ACPI_EVENT_GPE, 0)))	ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),	    "EcRequest: Unable to re-enable the EC GPE./n");    return(Status);}

static voidacpi_cmbat_init_battery(void *arg){    struct acpi_cmbat_softc *sc;    int		retry, valid;    device_t	dev;    dev = (device_t)arg;    sc = device_get_softc(dev);    ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		"battery initialization start/n");    /*     * Try repeatedly to get valid data from the battery.  Since the     * embedded controller isn't always ready just after boot, we may have     * to wait a while.     */    for (retry = 0; retry < ACPI_CMBAT_RETRY_MAX; retry++, AcpiOsSleep(10000)) {	/* batteries on DOCK can be ejected w/ DOCK during retrying */	if (!device_is_attached(dev))	    return;	if (!acpi_BatteryIsPresent(dev))	    continue;	/*	 * Only query the battery if this is the first try or the specific	 * type of info is still invalid.	 */	ACPI_SERIAL_BEGIN(cmbat);	if (retry == 0 || !acpi_battery_bst_valid(&sc->bst)) {	    timespecclear(&sc->bst_lastupdated);	    acpi_cmbat_get_bst(dev);	}	if (retry == 0 || !acpi_battery_bif_valid(&sc->bif))	    acpi_cmbat_get_bif(dev);	valid = acpi_battery_bst_valid(&sc->bst) &&	    acpi_battery_bif_valid(&sc->bif);	ACPI_SERIAL_END(cmbat);	if (valid)	    break;    }    if (retry == ACPI_CMBAT_RETRY_MAX) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "battery initialization failed, giving up/n");    } else {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "battery initialization done, tried %d times/n", retry + 1);    }}

static voidacpi_cmbat_init_battery(void *arg){	int		retry;	device_t	dev = (device_t)arg;	struct acpi_cmbat_softc *sc = device_get_softc(dev);#define ACPI_CMBAT_RETRY_MAX	6	if (sc->initializing) {		return;	}	sc->initializing = 1;	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "battery initialization start/n");	for (retry = 0; retry < ACPI_CMBAT_RETRY_MAX; retry++, AcpiOsSleep(10, 0)) {		sc->present = acpi_BatteryIsPresent(dev);		if (!sc->present) {			continue;		}		timespecclear(&sc->bst_lastupdated);		timespecclear(&sc->bif_lastupdated);		acpi_cmbat_get_bst(dev);		if (!acpi_cmbat_is_bst_valid(&sc->bst)) {			continue;		}		acpi_cmbat_get_bif(dev);		if (!acpi_cmbat_is_bif_valid(&sc->bif)) {			continue;		}		break;	}	if (retry == ACPI_CMBAT_RETRY_MAX)		ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),			    "battery initialization failed, giving up/n");	else		ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),			    "battery initialization done, tried %d times/n",			    retry+1);	sc->initializing = 0;}

static voidacpi_cmbat_get_bst(void *context){	device_t	dev;	struct acpi_cmbat_softc *sc;	ACPI_STATUS	as;	ACPI_OBJECT	*res, *tmp;	ACPI_HANDLE	h;	ACPI_BUFFER	bst_buffer;	dev = context;	sc = device_get_softc(dev);	h = acpi_get_handle(dev);	bst_buffer.Pointer = NULL;	if (!acpi_cmbat_info_expired(&sc->bst_lastupdated)) {		return;	}	if (sc->bst_updating) {		return;	}	sc->bst_updating = 1;	bst_buffer.Length = ACPI_ALLOCATE_BUFFER;	if (ACPI_FAILURE(as = AcpiEvaluateObject(h, "_BST", NULL, &bst_buffer))) {		ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "error fetching current battery status -- %s/n",		    AcpiFormatException(as));		goto end;	}	res = (ACPI_OBJECT *)bst_buffer.Pointer;	if ((res == NULL) || (res->Type != ACPI_TYPE_PACKAGE) || (res->Package.Count != 4)) {		ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "battery status corrupted/n");		goto end;	}	PKG_GETINT(res, tmp, 0, sc->bst.state, end);	PKG_GETINT(res, tmp, 1, sc->bst.rate, end);	PKG_GETINT(res, tmp, 2, sc->bst.cap, end);	PKG_GETINT(res, tmp, 3, sc->bst.volt, end);	acpi_cmbat_info_updated(&sc->bst_lastupdated);end:	if (bst_buffer.Pointer != NULL)		AcpiOsFree(bst_buffer.Pointer);	sc->bst_updating = 0;}

static voidacpi_lid_notify_status_changed(void *arg){    struct acpi_lid_softc	*sc;    struct acpi_softc		*acpi_sc;    ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);    sc = (struct acpi_lid_softc *)arg;    /*     * Evaluate _LID and check the return value, update lid status.     *	Zero:		The lid is closed     *	Non-zero:	The lid is open     */    if (ACPI_FAILURE(acpi_EvaluateInteger(sc->lid_handle, "_LID", &sc->lid_status)))	return_VOID;    acpi_sc = acpi_device_get_parent_softc(sc->lid_dev);    if (acpi_sc == NULL) {        return_VOID;    }    ACPI_VPRINT(sc->lid_dev, acpi_sc,	"Lid %s/n", sc->lid_status ? "opened" : "closed");    if (sc->lid_status == 0) {	EVENTHANDLER_INVOKE(acpi_sleep_event, acpi_sc->acpi_lid_switch_sx);    } else {	EVENTHANDLER_INVOKE(acpi_wakeup_event, acpi_sc->acpi_lid_switch_sx);    }    return_VOID;}

static ACPI_STATUSacpi_dock_eject_child(ACPI_HANDLE handle, UINT32 level, void *context,    void **status){	device_t	dock_dev, dev;	ACPI_HANDLE	dock_handle;	dock_dev = *(device_t *)context;	dock_handle = acpi_get_handle(dock_dev);	if (!acpi_dock_is_ejd_device(dock_handle, handle))		goto out;	ACPI_VPRINT(dock_dev, acpi_device_get_parent_softc(dock_dev),	    "ejecting device for %s/n", acpi_name(handle));	dev = acpi_get_device(handle);	if (dev != NULL && device_is_attached(dev)) {		mtx_lock(&Giant);		device_detach(dev);		mtx_unlock(&Giant);	}	acpi_SetInteger(handle, "_EJ0", 0);out:	return (AE_OK);}

static voidacpi_acad_get_status(void *context){    struct acpi_acad_softc *sc;    device_t	dev;    ACPI_HANDLE	h;    int		newstatus;    dev = context;    sc = device_get_softc(dev);    h = acpi_get_handle(dev);    newstatus = -1;    acpi_GetInteger(h, "_PSR", &newstatus);    /* If status is valid and has changed, notify the system. */    ACPI_SERIAL_BEGIN(acad);    if (newstatus != -1 && sc->status != newstatus) {	sc->status = newstatus;	power_profile_set_state(newstatus ? POWER_PROFILE_PERFORMANCE :	    POWER_PROFILE_ECONOMY);	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),	    "%s Line/n", newstatus ? "On" : "Off");	acpi_UserNotify("ACAD", h, newstatus);    }    ACPI_SERIAL_END(acad);}

static voidacpi_tz_notify_handler(ACPI_HANDLE h, UINT32 notify, void *context){    struct acpi_tz_softc	*sc = (struct acpi_tz_softc *)context;    ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);    switch (notify) {    case TZ_NOTIFY_TEMPERATURE:	/* Temperature change occurred */	acpi_tz_signal(sc, 0);	break;    case TZ_NOTIFY_DEVICES:    case TZ_NOTIFY_LEVELS:	/* Zone devices/setpoints changed */	acpi_tz_signal(sc, TZ_FLAG_GETSETTINGS);	break;    default:	ACPI_VPRINT(sc->tz_dev, acpi_device_get_parent_softc(sc->tz_dev),		    "unknown Notify event 0x%x/n", notify);	break;    }    acpi_UserNotify("Thermal", h, notify);    return_VOID;}

/* * System power profile may have changed; fetch and notify the * thermal zone accordingly. * * Since this can be called from an arbitrary eventhandler, it needs * to get the ACPI lock itself. */static voidacpi_tz_power_profile(void *arg){    ACPI_STATUS			status;    struct acpi_tz_softc	*sc = (struct acpi_tz_softc *)arg;    int				state;    state = power_profile_get_state();    if (state != POWER_PROFILE_PERFORMANCE && state != POWER_PROFILE_ECONOMY)	return;    /* check that we haven't decided there's no _SCP method */    if ((sc->tz_flags & TZ_FLAG_NO_SCP) == 0) {	/* Call _SCP to set the new profile */	status = acpi_SetInteger(sc->tz_handle, "_SCP",	    (state == POWER_PROFILE_PERFORMANCE) ? 0 : 1);	if (ACPI_FAILURE(status)) {	    if (status != AE_NOT_FOUND)		ACPI_VPRINT(sc->tz_dev,			    acpi_device_get_parent_softc(sc->tz_dev),			    "can't evaluate %s._SCP - %s/n",			    acpi_name(sc->tz_handle),			    AcpiFormatException(status));	    sc->tz_flags |= TZ_FLAG_NO_SCP;	} else {	    /* We have to re-evaluate the entire zone now */	    acpi_tz_signal(sc, TZ_FLAG_GETSETTINGS);	}    }}

/* * Get the current temperature. */static intacpi_tz_get_temperature(struct acpi_tz_softc *sc){    int		temp;    ACPI_STATUS	status;    ACPI_FUNCTION_NAME ("acpi_tz_get_temperature");    /* Evaluate the thermal zone's _TMP method. */    status = acpi_GetInteger(sc->tz_handle, acpi_tz_tmp_name, &temp);    if (ACPI_FAILURE(status)) {	ACPI_VPRINT(sc->tz_dev, acpi_device_get_parent_softc(sc->tz_dev),	    "error fetching current temperature -- %s/n",	     AcpiFormatException(status));	return (FALSE);    }    /* Check it for validity. */    acpi_tz_sanity(sc, &temp, acpi_tz_tmp_name);    if (temp == -1)	return (FALSE);    ACPI_DEBUG_PRINT((ACPI_DB_VALUES, "got %d.%dC/n", TZ_KELVTOC(temp)));    sc->tz_temperature = temp;    return (TRUE);}

/* * Given an object, verify that it's a reference to a device of some sort, * and try to switch it on. * * XXX replication of off/on function code is bad. */static voidacpi_tz_switch_cooler_on(ACPI_OBJECT *obj, void *arg){    struct acpi_tz_softc	*sc = (struct acpi_tz_softc *)arg;    ACPI_HANDLE			cooler;    ACPI_STATUS			status;    ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);    cooler = acpi_GetReference(NULL, obj);    if (cooler == NULL) {	ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "can't get handle/n"));	return_VOID;    }    ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "called to turn %s on/n",		     acpi_name(cooler)));    status = acpi_pwr_switch_consumer(cooler, ACPI_STATE_D0);    if (ACPI_FAILURE(status)) {	ACPI_VPRINT(sc->tz_dev, acpi_device_get_parent_softc(sc->tz_dev),		    "failed to activate %s - %s/n", acpi_name(cooler),		    AcpiFormatException(status));    }    return_VOID;}

intacpi_PkgStr(device_t dev, ACPI_OBJECT *res, int idx, void *dst, size_t size){    ACPI_OBJECT		*obj;    void		*ptr;    size_t		 length;    obj = &res->Package.Elements[idx];    if (obj == NULL) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "PkgStr NULL object at %d/n", idx);	return (-1);    }    bzero(dst, sizeof(dst));    switch (obj->Type) {    case ACPI_TYPE_STRING:	ptr = obj->String.Pointer;	length = obj->String.Length;	break;    case ACPI_TYPE_BUFFER:	ptr = obj->Buffer.Pointer;	length = obj->Buffer.Length;	break;    default:	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "PkgStr: invalid object type %d at %d/n", obj->Type, idx);	return (-1);    }    /* Make sure string will fit, including terminating NUL */    if (++length > size) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "PkgStr string too long (%zu bytes) at %d/n", length, idx);	return (-1);    }    strlcpy(dst, ptr, length);    return (0);}

static voidacpi_acad_init_acline(void *arg){    struct acpi_acad_softc *sc;    device_t	dev;    int		retry;    dev = (device_t)arg;    sc = device_get_softc(dev);    ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		"acline initialization start/n");    for (retry = 0; retry < ACPI_ACAD_RETRY_MAX; retry++) {	acpi_acad_get_status(dev);	if (sc->status != -1)	    break;	AcpiOsSleep(10000);    }    ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		"acline initialization done, tried %d times/n", retry + 1);}

intacpi_PkgInt(device_t dev, ACPI_OBJECT *res, int idx, ACPI_INTEGER *dst){    ACPI_OBJECT		*obj;    obj = &res->Package.Elements[idx];    if (obj == NULL || obj->Type != ACPI_TYPE_INTEGER) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "PkgInt error, pkg[%d] at %d %p/n",		    res->Package.Count, idx, obj);	return (-1);    }    *dst = obj->Integer.Value;    return (0);}

static intacpi_tz_cpufreq_restore(struct acpi_tz_softc *sc){    device_t dev;    int error;    if (!sc->tz_cooling_updated)	return (0);    if ((dev = devclass_get_device(devclass_find("cpufreq"), 0)) == NULL)	return (ENXIO);    ACPI_VPRINT(sc->tz_dev, acpi_device_get_parent_softc(sc->tz_dev),	"temperature %d.%dC: resuming previous clock speed (%d MHz)/n",	TZ_KELVTOC(sc->tz_temperature), sc->tz_cooling_saved_freq);    error = CPUFREQ_SET(dev, NULL, CPUFREQ_PRIO_KERN);    if (error == 0)	sc->tz_cooling_updated = FALSE;    return (error);}

static ACPI_STATUSEcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event){    EC_STATUS	EcStatus;    UINT32	i = 0;    if (!EcIsLocked(sc))	ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),	    "EcWaitEvent called without EC lock!/n");    /*     * Stall 1us:     * ----------     * Stall for 1 microsecond before reading the status register     * for the first time.  This allows the EC to set the IBF/OBF     * bit to its proper state.     *     * XXX it is not clear why we read the CSR twice.     */    AcpiOsStall(1);    EcStatus = EC_GET_CSR(sc);    /*     * Wait For Event:     * ---------------     * Poll the EC status register to detect completion of the last     * command.  Wait up to 10ms (in 10us chunks) for this to occur.     */    for (i = 0; i < 1000; i++) {	EcStatus = EC_GET_CSR(sc);        if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) &&            (EcStatus & EC_FLAG_OUTPUT_BUFFER))	    return(AE_OK);	if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) &&             !(EcStatus & EC_FLAG_INPUT_BUFFER))	    return(AE_OK);		AcpiOsStall(10);    }    return(AE_ERROR);}    

static voidacpi_dock_get_info(device_t dev){	struct acpi_dock_softc *sc;	ACPI_HANDLE	h;	sc = device_get_softc(dev);	h = acpi_get_handle(dev);	if (ACPI_FAILURE(acpi_GetInteger(h, "_STA", &sc->_sta)))		sc->_sta = ACPI_DOCK_STATUS_UNKNOWN;	if (ACPI_FAILURE(acpi_GetInteger(h, "_BDN", &sc->_bdn)))		sc->_bdn = ACPI_DOCK_STATUS_UNKNOWN;	if (ACPI_FAILURE(acpi_GetInteger(h, "_UID", &sc->_uid)))		sc->_uid = ACPI_DOCK_STATUS_UNKNOWN;	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "_STA: %04x, _BDN: %04x, _UID: %04x/n", sc->_sta,		    sc->_bdn, sc->_uid);}

static ACPI_STATUSacpi_dock_insert_child(ACPI_HANDLE handle, UINT32 level, void *context,    void **status){	device_t	dock_dev, dev;	ACPI_HANDLE	dock_handle;	dock_dev = (device_t)context;	dock_handle = acpi_get_handle(dock_dev);	if (!acpi_dock_is_ejd_device(dock_handle, handle))		goto out;	ACPI_VPRINT(dock_dev, acpi_device_get_parent_softc(dock_dev),		    "inserting device for %s/n", acpi_name(handle));#if 0	/*	 * If the system boot up w/o Docking, the devices under the dock	 * still un-initialized, also control methods such as _INI, _STA	 * are not executed.	 * Normal devices are initialized at booting by calling	 * AcpiInitializeObjects(), however the devices under the dock	 * need to be initialized here on the scheme of ACPICA.	 */	ACPI_INIT_WALK_INFO	Info;	AcpiNsWalkNamespace(ACPI_TYPE_ANY, handle,	    100, TRUE, AcpiNsInitOneDevice, &Info, NULL);#endif	dev = acpi_get_device(handle);	if (dev == NULL) {		device_printf(dock_dev, "error: %s has no associated device/n",		    acpi_name(handle));		goto out;	}	AcpiOsExecute(OSL_NOTIFY_HANDLER, acpi_dock_attach_later, dev);out:	return (AE_OK);}

static ACPI_STATUSEcQuery(struct acpi_ec_softc *sc, UINT8 *Data){    ACPI_STATUS	Status;    if (ACPI_FAILURE(Status = EcLock(sc)))	return(Status);    EC_SET_CSR(sc, EC_COMMAND_QUERY);    if (ACPI_SUCCESS(Status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL)))	*Data = EC_GET_DATA(sc);    EcUnlock(sc);    if (ACPI_FAILURE(Status))	ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),	    "timeout waiting for EC to respond to EC_COMMAND_QUERY/n");    return(Status);}    

/* * Wait for an event interrupt for a specific condition. */static ACPI_STATUSEcWaitEventIntr(struct acpi_ec_softc *sc, EC_EVENT Event){    EC_STATUS	EcStatus;    int		i;    ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Event);    /* XXX this should test whether interrupts are available some other way */    if (cold || acpi_ec_event_driven)	return_ACPI_STATUS(EcWaitEvent(sc, Event));    if (!EcIsLocked(sc))	ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),	    "EcWaitEventIntr called without EC lock!/n");    EcStatus = EC_GET_CSR(sc);    /* XXX waiting too long? */    for(i = 0; i < 10; i++){	/*	 * Check EC status against the desired event.	 */    	if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) &&	    (EcStatus & EC_FLAG_OUTPUT_BUFFER))	    return_ACPI_STATUS(AE_OK);      	if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) && 	    !(EcStatus & EC_FLAG_INPUT_BUFFER))	    return_ACPI_STATUS(AE_OK);		sc->ec_csrvalue = 0;	if (ACPI_MSLEEP(&sc->ec_csrvalue, &acpi_mutex, PZERO, "EcWait", 1) != EWOULDBLOCK){	    EcStatus = sc->ec_csrvalue;	}else{	    EcStatus = EC_GET_CSR(sc);	}    }    return_ACPI_STATUS(AE_ERROR);}

static voidacpi_dock_notify_handler(ACPI_HANDLE h, UINT32 notify, void *context){	device_t	dev;	dev = (device_t) context;	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "got notification %#x/n", notify);	ACPI_SERIAL_BEGIN(dock);	switch (notify) {	case ACPI_NOTIFY_BUS_CHECK:	case ACPI_NOTIFY_DEVICE_CHECK:		acpi_dock_device_check(dev);		break;	case ACPI_NOTIFY_EJECT_REQUEST:		acpi_dock_removal(dev);		break;	default:		device_printf(dev, "unknown notify %#x/n", notify);		break;	}	ACPI_SERIAL_END(dock);}

/* * Query each of the ACPI control methods that contain information we're * interested in. We check the return values from the control methods and * adjust any state variables if they should be adjusted. */static uint8_tacpi_fujitsu_update(struct acpi_fujitsu_softc *sc){	int changed;	struct acpi_softc *acpi_sc;	acpi_sc = acpi_device_get_parent_softc(sc->dev);	ACPI_SERIAL_ASSERT(fujitsu);	if(sc->gsif.exists)		changed = sc->gsif.value & acpi_fujitsu_method_get(sc,METHOD_GHKS);	else		changed = 0;	/* System Volume Level */	if(sc->gvol.exists) {		if (ACPI_FAILURE(acpi_GetInteger(sc->handle,		sc->gvol.name, &(sc->gvol.value)))) {			device_printf(sc->dev, "Couldn't query volume level/n");			return (FALSE);		}			if (changed & VOLUME_CHANGED) {			sc->bIsMuted =			(uint8_t)((sc->gvol.value & VOLUME_MUTE_BIT) != 0);				/* Clear the modification bit */			sc->gvol.value &= VOLUME_SETTING_BITS;				if (sc->bIsMuted) {				acpi_UserNotify("FUJITSU", sc->handle, FN_MUTE);				ACPI_VPRINT(sc->dev, acpi_sc, "Volume is now mute/n");			} else				ACPI_VPRINT(sc->dev, acpi_sc, "Volume is now %d/n",				sc->gvol.value);				acpi_UserNotify("FUJITSU", sc->handle, FN_VOLUME);		}	}	/* Internal mouse pointer (eraserhead) */	if(sc->gmou.exists) {		if (ACPI_FAILURE(acpi_GetInteger(sc->handle,		sc->gmou.name, &(sc->gmou.value)))) {			device_printf(sc->dev, "Couldn't query pointer state/n");			return (FALSE);		}			if (changed & MOUSE_CHANGED) {			sc->bIntPtrEnabled = (uint8_t)(sc->gmou.value & 0x1);				/* Clear the modification bit */			sc->gmou.value &= MOUSE_SETTING_BITS;						/* Set the value in case it is not hardware controlled */                        acpi_fujitsu_method_set(sc, METHOD_GMOU, sc->gmou.value);			acpi_UserNotify("FUJITSU", sc->handle, FN_POINTER_ENABLE);				ACPI_VPRINT(sc->dev, acpi_sc, "Internal pointer is now %s/n",			(sc->bIntPtrEnabled) ? "enabled" : "disabled");		}	}	/* Screen Brightness Level P8XXX */	if(sc->gbls.exists) {		if (ACPI_FAILURE(acpi_GetInteger(sc->handle,                sc->gbls.name, &(sc->gbls.value)))) {                        device_printf(sc->dev, "Couldn't query P8XXX brightness level/n");                        return (FALSE);                }		if (changed & BRIGHT_CHANGED) {			/* No state to record here. */			/* Clear the modification bit */			sc->gbls.value &= BRIGHTNESS_SETTING_BITS;			/* Set the value in case it is not hardware controlled */			acpi_fujitsu_method_set(sc, METHOD_GBLS, sc->gbls.value);			acpi_UserNotify("FUJITSU", sc->handle, FN_LCD_BRIGHTNESS);			ACPI_VPRINT(sc->dev, acpi_sc, "P8XXX Brightness level is now %d/n",			sc->gbls.value);                }	}	/* Screen Brightness Level */	if(sc->gbll.exists) {		if (ACPI_FAILURE(acpi_GetInteger(sc->handle,		sc->gbll.name, &(sc->gbll.value)))) {			device_printf(sc->dev, "Couldn't query brightness level/n");			return (FALSE);		}	//.........这里部分代码省略.........

static voidacpi_cmbat_get_bif(void *arg){    struct acpi_cmbat_softc *sc;    ACPI_STATUS	as;    ACPI_OBJECT	*res;    ACPI_HANDLE	h;    ACPI_BUFFER	bif_buffer;    device_t dev;    ACPI_SERIAL_ASSERT(cmbat);    dev = arg;    sc = device_get_softc(dev);    h = acpi_get_handle(dev);    bif_buffer.Pointer = NULL;    bif_buffer.Length = ACPI_ALLOCATE_BUFFER;    as = AcpiEvaluateObject(h, "_BIF", NULL, &bif_buffer);    if (ACPI_FAILURE(as)) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "error fetching current battery info -- %s/n",		    AcpiFormatException(as));	goto end;    }    res = (ACPI_OBJECT *)bif_buffer.Pointer;    if (!ACPI_PKG_VALID(res, 13)) {	ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),		    "battery info corrupted/n");	goto end;    }    if (acpi_PkgInt32(res, 0, &sc->bif.units) != 0)	goto end;    if (acpi_PkgInt32(res, 1, &sc->bif.dcap) != 0)	goto end;    if (acpi_PkgInt32(res, 2, &sc->bif.lfcap) != 0)	goto end;    if (acpi_PkgInt32(res, 3, &sc->bif.btech) != 0)	goto end;    if (acpi_PkgInt32(res, 4, &sc->bif.dvol) != 0)	goto end;    if (acpi_PkgInt32(res, 5, &sc->bif.wcap) != 0)	goto end;    if (acpi_PkgInt32(res, 6, &sc->bif.lcap) != 0)	goto end;    if (acpi_PkgInt32(res, 7, &sc->bif.gra1) != 0)	goto end;    if (acpi_PkgInt32(res, 8, &sc->bif.gra2) != 0)	goto end;    if (acpi_PkgStr(res,  9, sc->bif.model, ACPI_CMBAT_MAXSTRLEN) != 0)	goto end;    if (acpi_PkgStr(res, 10, sc->bif.serial, ACPI_CMBAT_MAXSTRLEN) != 0)	goto end;    if (acpi_PkgStr(res, 11, sc->bif.type, ACPI_CMBAT_MAXSTRLEN) != 0)	goto end;    if (acpi_PkgStr(res, 12, sc->bif.oeminfo, ACPI_CMBAT_MAXSTRLEN) != 0)	goto end;end:    if (bif_buffer.Pointer != NULL)	AcpiOsFree(bif_buffer.Pointer);}