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

ACPI_STATUSacpi_evaluate_integer (	ACPI_HANDLE		handle,	ACPI_STRING		pathname,	ACPI_OBJECT_LIST	*arguments,	unsigned long long		*data){	ACPI_STATUS             status = AE_OK;	ACPI_OBJECT	element;	ACPI_BUFFER	buffer = {sizeof(ACPI_OBJECT), &element};	ACPI_FUNCTION_TRACE("acpi_evaluate_integer");	if (!data)		return_ACPI_STATUS(AE_BAD_PARAMETER);	status = AcpiEvaluateObject(handle, pathname, arguments, &buffer);	if (ACPI_FAILURE(status)) {		acpi_util_eval_error(handle, pathname, status);		return_ACPI_STATUS(status);	}	if (element.Type != ACPI_TYPE_INTEGER) {		acpi_util_eval_error(handle, pathname, AE_BAD_DATA);		return_ACPI_STATUS(AE_BAD_DATA);	}	*data = element.Integer.Value;	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%lu]/n", *data));	return_ACPI_STATUS(AE_OK);}

/* * Run _EJ0 method to turn off power to the slot. */static ACPI_STATUSpciehpc_acpi_power_off_slot(pcie_hp_ctrl_t *ctrl_p){	int status = AE_OK;	pciehpc_acpi_t *acpi_p = ctrl_p->hc_misc_data;	int dev_state = 0;	pcie_hp_slot_t *slot_p = ctrl_p->hc_slots[0];	PCIE_DBG("turn OFF power to the slot #%d/n", slot_p->hs_phy_slot_num);	status = AcpiEvaluateObject(acpi_p->slot_dev_obj, "_EJ0", NULL, NULL);	/* get the state of the device (from _STA method) */	if (status == AE_OK) {		if (pciehpc_acpi_get_dev_state(acpi_p->slot_dev_obj,		    &dev_state) != AE_OK)			cmn_err(CE_WARN, "failed to get device status "			    "on slot #%d", slot_p->hs_phy_slot_num);	}	PCIE_DBG("(2)device state on slot #%d: 0x%x/n",	    slot_p->hs_phy_slot_num, dev_state);	pciehpc_get_slot_state(slot_p);	if (slot_p->hs_info.cn_state >= DDI_HP_CN_STATE_POWERED) {		cmn_err(CE_WARN, "failed to power OFF the slot #%d"		    "(dev_state 0x%x, ACPI_STATUS 0x%x)",		    slot_p->hs_phy_slot_num, dev_state, status);		return (AE_ERROR);	}	return (status);}

voidAcpiHwExecuteSleepMethod (    char                    *MethodPathname,    UINT32                  IntegerArgument){    ACPI_OBJECT_LIST        ArgList;    ACPI_OBJECT             Arg;    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE (HwExecuteSleepMethod);    /* One argument, IntegerArgument; No return value expected */    ArgList.Count = 1;    ArgList.Pointer = &Arg;    Arg.Type = ACPI_TYPE_INTEGER;    Arg.Integer.Value = (UINT64) IntegerArgument;    Status = AcpiEvaluateObject (NULL, MethodPathname, &ArgList, NULL);    if (ACPI_FAILURE (Status) && Status != AE_NOT_FOUND)    {        ACPI_EXCEPTION ((AE_INFO, Status, "While executing method %s",            MethodPathname));    }    return_VOID;}

uint64_t evaluate(ACPI_HANDLE handle) {	acpi::ScopedBuffer buffer;	ACPICA_CHECK(AcpiEvaluateObject(handle, nullptr, nullptr, buffer.get()));	auto object = reinterpret_cast<ACPI_OBJECT *>(buffer.data());	assert(object->Type == ACPI_TYPE_INTEGER);	return object->Integer.Value;}

static voidacpi_perf_identify(driver_t *driver, device_t parent){    ACPI_HANDLE handle;    device_t dev;    /* Make sure we're not being doubly invoked. */    if (device_find_child(parent, "acpi_perf", -1) != NULL)        return;    /* Get the handle for the Processor object and check for perf states. */    handle = acpi_get_handle(parent);    if (handle == NULL)        return;    if (ACPI_FAILURE(AcpiEvaluateObject(handle, "_PSS", NULL, NULL)))        return;    /*     * Add a child to every CPU that has the right methods.  In future     * versions of the ACPI spec, CPUs can have different settings.     * We probe this child now so that other devices that depend     * on it (i.e., for info about supported states) will see it.     */    if ((dev = BUS_ADD_CHILD(parent, 0, "acpi_perf", -1)) != NULL)        device_probe_and_attach(dev);    else        device_printf(parent, "add acpi_perf child failed/n");}

static ACPI_STATUSAcpiDbExecuteMethod (    ACPI_DB_METHOD_INFO     *Info,    ACPI_BUFFER             *ReturnObj){    ACPI_STATUS             Status;    ACPI_OBJECT_LIST        ParamObjects;    ACPI_OBJECT             Params[ACPI_METHOD_NUM_ARGS];    UINT32                  i;    if (AcpiGbl_DbOutputToFile && !AcpiDbgLevel)    {        AcpiOsPrintf ("Warning: debug output is not enabled!/n");    }    /* Are there arguments to the method? */    if (Info->Args && Info->Args[0])    {        for (i = 0; Info->Args[i] && i < ACPI_METHOD_NUM_ARGS; i++)        {            Params[i].Type          = ACPI_TYPE_INTEGER;            Params[i].Integer.Value = ACPI_STRTOUL (Info->Args[i], NULL, 16);        }        ParamObjects.Pointer = Params;        ParamObjects.Count   = i;    }    else    {        /* Setup default parameters */        Params[0].Type           = ACPI_TYPE_INTEGER;        Params[0].Integer.Value  = 0x01020304;        Params[1].Type           = ACPI_TYPE_STRING;        Params[1].String.Length  = 12;        Params[1].String.Pointer = "AML Debugger";        ParamObjects.Pointer     = Params;        ParamObjects.Count       = 2;    }    /* Prepare for a return object of arbitrary size */    ReturnObj->Pointer = AcpiGbl_DbBuffer;    ReturnObj->Length  = ACPI_DEBUG_BUFFER_SIZE;    /* Do the actual method execution */    AcpiGbl_MethodExecuting = TRUE;    Status = AcpiEvaluateObject (NULL,                Info->Pathname, &ParamObjects, ReturnObj);    AcpiGbl_CmSingleStep = FALSE;    AcpiGbl_MethodExecuting = FALSE;    return (Status);}

static voidasus_init(device_t self){	asus_softc_t *sc = device_private(self);	ACPI_STATUS rv;	ACPI_OBJECT param;	ACPI_OBJECT_LIST params;	ACPI_BUFFER ret;	ret.Pointer = NULL;	ret.Length = ACPI_ALLOCATE_BUFFER;	param.Type = ACPI_TYPE_INTEGER;	param.Integer.Value = 0x40;	/* disable ASL display switching */	params.Pointer = &param;	params.Count = 1;	rv = AcpiEvaluateObject(sc->sc_node->ad_handle, "INIT",	    &params, &ret);	if (ACPI_FAILURE(rv))		aprint_error_dev(self, "couldn't evaluate INIT: %s/n",		    AcpiFormatException(rv));	if (ret.Pointer)		AcpiOsFree(ret.Pointer);}

static ACPI_STATUSAcpiDbWriteToObject (    ACPI_NAMESPACE_NODE     *Node,    ACPI_OBJECT             *Value){    ACPI_OBJECT_LIST        ParamObjects;    ACPI_OBJECT             Params[2];    ACPI_STATUS             Status;    Params[0].Type = ACPI_TYPE_LOCAL_REFERENCE;    Params[0].Reference.ActualType = Node->Type;    Params[0].Reference.Handle = ACPI_CAST_PTR (ACPI_HANDLE, Node);    /* Copy the incoming user parameter */    ACPI_MEMCPY (&Params[1], Value, sizeof (ACPI_OBJECT));    ParamObjects.Count = 2;    ParamObjects.Pointer = Params;    AcpiGbl_MethodExecuting = TRUE;    Status = AcpiEvaluateObject (WriteHandle, NULL, &ParamObjects, NULL);    AcpiGbl_MethodExecuting = FALSE;    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("Could not write to object, %s",            AcpiFormatException (Status));    }    return (Status);}

static PyObject *bits_acpi_eval(PyObject *self, PyObject *args){    char *pathname;    PyObject *acpi_args_tuple;    ACPI_OBJECT_LIST acpi_args;    ACPI_BUFFER results = { .Length = ACPI_ALLOCATE_BUFFER, .Pointer = NULL };    PyObject *ret;    if (!PyArg_ParseTuple(args, "sO", &pathname, &acpi_args_tuple))        return NULL;    if (!acpi_objects_from_python(acpi_args_tuple, &acpi_args.Pointer, &acpi_args.Count))        return NULL;    if (acpica_init() != GRUB_ERR_NONE) {        free_acpi_objects(acpi_args.Pointer, acpi_args.Count);        return PyErr_Format(PyExc_RuntimeError, "ACPICA module failed to initialize.");    }    if (ACPI_FAILURE(AcpiEvaluateObject(NULL, pathname, &acpi_args, &results))) {        free_acpi_objects(acpi_args.Pointer, acpi_args.Count);        return Py_BuildValue("");    }    free_acpi_objects(acpi_args.Pointer, acpi_args.Count);    ret = acpi_object_to_python(results.Pointer);    ACPI_FREE(results.Pointer);    return Py_BuildValue("N", ret);}

static ACPI_STATUS ExecuteOSI(int pic_mode){    ACPI_STATUS             Status;    ACPI_OBJECT_LIST        ArgList;    ACPI_OBJECT             Arg[1];    ACPI_BUFFER             ReturnValue;    /* Setup input argument */    ArgList.Count = 1;    ArgList.Pointer = Arg;    Arg[0].Type = ACPI_TYPE_INTEGER;    Arg[0].Integer.Value = pic_mode;    /* Ask ACPICA to allocate space for the return object */    ReturnValue.Pointer = 0;    ReturnValue.Length = ACPI_ALLOCATE_BUFFER;    Status = AcpiEvaluateObject (NULL, "//_PIC", &ArgList, &ReturnValue);	FreeBuffer(&ReturnValue);	if (Status == AE_NOT_FOUND)	{		return AE_OK;	}    if (ACPI_FAILURE (Status))    {        ACPI_EXCEPTION ((AE_INFO, Status, "While executing _PIC"));        return Status;    }    return AE_OK;}

static ACPI_STATUSExecuteOSI (    char                    *OsiString,    UINT32                  ExpectedResult){    ACPI_STATUS             Status;    ACPI_OBJECT_LIST        ArgList;    ACPI_OBJECT             Arg[1];    ACPI_BUFFER             ReturnValue;    ACPI_OBJECT             *Obj;    /* Setup input argument */    ArgList.Count = 1;    ArgList.Pointer = Arg;    Arg[0].Type = ACPI_TYPE_STRING;    Arg[0].String.Pointer = OsiString;    Arg[0].String.Length = strlen (Arg[0].String.Pointer);    /* Ask ACPICA to allocate space for the return object */    ReturnValue.Length = ACPI_ALLOCATE_BUFFER;    Status = AcpiEvaluateObject (NULL, "//_OSI", &ArgList, &ReturnValue);    if (ACPI_FAILURE (Status))    {        AcpiOsPrintf ("Could not execute _OSI method, %s/n",            AcpiFormatException (Status));        return (Status);    }    if (ReturnValue.Length < sizeof (ACPI_OBJECT))    {        AcpiOsPrintf ("Return value from _OSI method too small, %.8X/n",            ReturnValue.Length);        return (AE_ERROR);    }    Obj = ReturnValue.Pointer;    if (Obj->Type != ACPI_TYPE_INTEGER)    {        AcpiOsPrintf ("Invalid return type from _OSI method, %.2X/n", Obj->Type);        return (AE_ERROR);    }    if (Obj->Integer.Value != ExpectedResult)    {        AcpiOsPrintf ("Invalid return value from _OSI, expected %.8X found %.8X/n",            ExpectedResult, (UINT32) Obj->Integer.Value);        return (AE_ERROR);    }    /* Reset the OSI data */    AcpiGbl_OsiData = 0;    return (AE_OK);}

/* Find dependent devices.  When their parent is removed, so are they. */static intacpi_dock_is_ejd_device(ACPI_HANDLE dock_handle, ACPI_HANDLE handle){	int		ret;	ACPI_STATUS	ret_status;	ACPI_BUFFER	ejd_buffer;	ACPI_OBJECT	*obj;	ret = 0;	ejd_buffer.Pointer = NULL;	ejd_buffer.Length = ACPI_ALLOCATE_BUFFER;	ret_status = AcpiEvaluateObject(handle, "_EJD", NULL, &ejd_buffer);	if (ACPI_FAILURE(ret_status))		goto out;	obj = (ACPI_OBJECT *)ejd_buffer.Pointer;	if (dock_handle == acpi_GetReference(NULL, obj))		ret = 1;out:	if (ejd_buffer.Pointer != NULL)		AcpiOsFree(ejd_buffer.Pointer);	return (ret);}

static intacpi_dock_execute_dck(device_t dev, int dock){	ACPI_HANDLE	h;	ACPI_OBJECT	argobj;	ACPI_OBJECT_LIST args;	ACPI_BUFFER	buf;	ACPI_OBJECT	retobj;	ACPI_STATUS	status;	h = acpi_get_handle(dev);	argobj.Type = ACPI_TYPE_INTEGER;	argobj.Integer.Value = dock;	args.Count = 1;	args.Pointer = &argobj;	buf.Pointer = &retobj;	buf.Length = sizeof(retobj);	status = AcpiEvaluateObject(h, "_DCK", &args, &buf);	/*	 * When _DCK is called with 0, OSPM will ignore the return value.	 */	if (dock == ACPI_DOCK_ISOLATE)		return (0);	/* If _DCK returned 1, the request succeeded. */	if (ACPI_SUCCESS(status) && retobj.Type == ACPI_TYPE_INTEGER &&	    retobj.Integer.Value == 1)		return (0);	return (-1);}

static voidExecuteOSI (void){    ACPI_STATUS             Status;    ACPI_OBJECT_LIST        ArgList;    ACPI_OBJECT             Arg[1];    ACPI_BUFFER             ReturnValue;    ACPI_OBJECT             *Object;    ACPI_INFO ((AE_INFO, "Executing _OSI reserved method"));    /* Setup input argument */    ArgList.Count = 1;    ArgList.Pointer = Arg;    Arg[0].Type = ACPI_TYPE_STRING;    Arg[0].String.Pointer = "Windows 2001";    Arg[0].String.Length = strlen (Arg[0].String.Pointer);    /* Ask ACPICA to allocate space for the return object */    ReturnValue.Length = ACPI_ALLOCATE_BUFFER;    Status = AcpiEvaluateObject (NULL, "//_OSI", &ArgList, &ReturnValue);    if (ACPI_FAILURE (Status))    {        ACPI_EXCEPTION ((AE_INFO, Status, "While executing _OSI"));        return;    }    /* Ensure that the return object is large enough */    if (ReturnValue.Length < sizeof (ACPI_OBJECT))    {        AcpiOsPrintf ("Return value from _OSI method too small, %.8X/n",            ReturnValue.Length);        goto ErrorExit;    }    /* Expect an integer return value from execution of _OSI */    Object = ReturnValue.Pointer;    if (Object->Type != ACPI_TYPE_INTEGER)    {        AcpiOsPrintf ("Invalid return type from _OSI, %.2X/n", Object->Type);    }    ACPI_INFO ((AE_INFO, "_OSI returned 0x%8.8X",        (UINT32) Object->Integer.Value));ErrorExit:    /* Free a buffer created via ACPI_ALLOCATE_BUFFER */    AcpiOsFree (ReturnValue.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 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 intacpi_cpu_probe(device_t dev){    int			   acpi_id, cpu_id;    ACPI_BUFFER		   buf;    ACPI_HANDLE		   handle;    ACPI_OBJECT		   *obj;    ACPI_STATUS		   status;    if (acpi_disabled("cpu") || acpi_get_type(dev) != ACPI_TYPE_PROCESSOR ||	    acpi_cpu_disabled)	return (ENXIO);    handle = acpi_get_handle(dev);    if (cpu_softc == NULL)	cpu_softc = malloc(sizeof(struct acpi_cpu_softc *) *	    (mp_maxid + 1), M_TEMP /* XXX */, M_WAITOK | M_ZERO);    /* Get our Processor object. */    buf.Pointer = NULL;    buf.Length = ACPI_ALLOCATE_BUFFER;    status = AcpiEvaluateObject(handle, NULL, NULL, &buf);    if (ACPI_FAILURE(status)) {	device_printf(dev, "probe failed to get Processor obj - %s/n",		      AcpiFormatException(status));	return (ENXIO);    }    obj = (ACPI_OBJECT *)buf.Pointer;    if (obj->Type != ACPI_TYPE_PROCESSOR) {	device_printf(dev, "Processor object has bad type %d/n", obj->Type);	AcpiOsFree(obj);	return (ENXIO);    }    /*     * Find the processor associated with our unit.  We could use the     * ProcId as a key, however, some boxes do not have the same values     * in their Processor object as the ProcId values in the MADT.     */    acpi_id = obj->Processor.ProcId;    AcpiOsFree(obj);    if (acpi_pcpu_get_id(dev, &acpi_id, &cpu_id) != 0)	return (ENXIO);    /*     * Check if we already probed this processor.  We scan the bus twice     * so it's possible we've already seen this one.     */    if (cpu_softc[cpu_id] != NULL)	return (ENXIO);    /* Mark this processor as in-use and save our derived id for attach. */    cpu_softc[cpu_id] = (void *)1;    acpi_set_private(dev, (void*)(intptr_t)cpu_id);    device_set_desc(dev, "ACPI CPU");    return (0);}

static intacpi_cst_attach(device_t dev){    ACPI_BUFFER		   buf;    ACPI_OBJECT		   *obj;    struct acpi_cst_softc *sc;    ACPI_STATUS		   status;    ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);    sc = device_get_softc(dev);    sc->cst_dev = dev;    sc->cst_parent = device_get_softc(device_get_parent(dev));    sc->cst_handle = acpi_get_handle(dev);    sc->cst_cpuid = acpi_get_magic(dev);    acpi_cst_softc[sc->cst_cpuid] = sc;    acpi_cst_smi_cmd = AcpiGbl_FADT.SmiCommand;    acpi_cst_ctrl = AcpiGbl_FADT.CstControl;    buf.Pointer = NULL;    buf.Length = ACPI_ALLOCATE_BUFFER;    status = AcpiEvaluateObject(sc->cst_handle, NULL, NULL, &buf);    if (ACPI_FAILURE(status)) {	device_printf(dev, "attach failed to get Processor obj - %s/n",		      AcpiFormatException(status));	acpi_cst_softc[sc->cst_cpuid] = NULL;	return (ENXIO);    }    obj = (ACPI_OBJECT *)buf.Pointer;    sc->cst_p_blk = obj->Processor.PblkAddress;    sc->cst_p_blk_len = obj->Processor.PblkLength;    AcpiOsFree(obj);    ACPI_DEBUG_PRINT((ACPI_DB_INFO, "cpu_cst%d: P_BLK at %#x/%d/n",		     device_get_unit(dev), sc->cst_p_blk, sc->cst_p_blk_len));    /*     * If this is the first cpu we attach, create and initialize the generic     * resources that will be used by all acpi cpu devices.     */    if (device_get_unit(dev) == 0) {	/* Assume we won't be using FADT for Cx states by default */	acpi_cst_use_fadt = FALSE;	/* Queue post cpu-probing task handler */	AcpiOsExecute(OSL_NOTIFY_HANDLER, acpi_cst_postattach, NULL);    }    /* Probe for Cx state support. */    acpi_cst_cx_probe(sc);    sc->cst_flags |= ACPI_CST_FLAG_ATTACHED;    return (0);}

/* * fujitsu_hk_eval_nary_integer: * *	Evaluate an object that takes as input an arbitrary (possible null) *	number of integer parameters.  If res is not NULL, then *res is filled *	with the result of the evaluation, and AE_NULL_OBJECT is returned if *	the evaluation produced no result. */static ACPI_STATUSfujitsu_hk_eval_nary_integer(ACPI_HANDLE handle, const char *path, const                             ACPI_INTEGER *args, uint8_t count, ACPI_INTEGER *res){    ACPI_OBJECT_LIST paramlist;    ACPI_OBJECT retobj, objpool[4], *argobjs;    ACPI_BUFFER buf;    ACPI_STATUS rv;    uint8_t i;    /* Require that (args == NULL) if and only if (count == 0). */    KASSERT((args != NULL || count == 0) && (args == NULL || count != 0));    /* The object pool should be large enough for our callers. */    KASSERT(count <= __arraycount(objpool));    if (handle == NULL)        handle = ACPI_ROOT_OBJECT;    /* Convert the given array args into an array of ACPI objects. */    argobjs = objpool;    for (i = 0; i < count; i++) {        argobjs[i].Type = ACPI_TYPE_INTEGER;        argobjs[i].Integer.Value = args[i];    }    paramlist.Count = count;    paramlist.Pointer = argobjs;    (void)memset(&retobj, 0, sizeof(retobj));    buf.Pointer = &retobj;    buf.Length = sizeof(retobj);    rv = AcpiEvaluateObject(handle, path, &paramlist, &buf);    if (ACPI_FAILURE(rv))        return rv;    /*     * If a return value is expected and desired (i.e. res != NULL),     * then copy the result into *res.     */    if (res != NULL) {        if (buf.Length == 0)            return AE_NULL_OBJECT;        if (retobj.Type != ACPI_TYPE_INTEGER)            return AE_TYPE;        *res = retobj.Integer.Value;    }    return AE_OK;}

void evaluateWith1(ACPI_HANDLE handle) {	ACPI_OBJECT args[1];	args[0].Integer.Type = ACPI_TYPE_INTEGER;	args[0].Integer.Value = 1;	ACPI_OBJECT_LIST list;	list.Count = 1;	list.Pointer = args;	ACPICA_CHECK(AcpiEvaluateObject(handle, nullptr, &list, nullptr));}

static intacpi_panasonic_attach(device_t dev){	struct acpi_panasonic_softc *sc;	struct acpi_softc *acpi_sc;	ACPI_STATUS status;	int i;	sc = device_get_softc(dev);	sc->dev = dev;	sc->handle = acpi_get_handle(dev);	acpi_sc = acpi_device_get_parent_softc(dev);	/* Build sysctl tree */	sysctl_ctx_init(&sc->sysctl_ctx);	sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,	    SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO,	    "panasonic", CTLFLAG_RD, 0, "");	for (i = 0; sysctl_table[i].name != NULL; i++) {		SYSCTL_ADD_PROC(&sc->sysctl_ctx,		    SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,		    sysctl_table[i].name,		    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,		    sc, i, acpi_panasonic_sysctl, "I", "");	}#if 0	/* Activate hotkeys */	status = AcpiEvaluateObject(sc->handle, "", NULL, NULL);	if (ACPI_FAILURE(status)) {		device_printf(dev, "enable FN keys failed/n");		sysctl_ctx_free(&sc->sysctl_ctx);		return (ENXIO);	}#endif	/* Handle notifies */	status = AcpiInstallNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY,	    acpi_panasonic_notify, sc);	if (ACPI_FAILURE(status)) {		device_printf(dev, "couldn't install notify handler - %s/n",		    AcpiFormatException(status));		sysctl_ctx_free(&sc->sysctl_ctx);		return (ENXIO);	}	/* Install power profile event handler */	sc->power_evh = EVENTHANDLER_REGISTER(power_profile_change,	    acpi_panasonic_power_profile, sc->handle, 0);	return (0);}

voidAeNotifyHandler (    ACPI_HANDLE                 Device,    UINT32                      Value,    void                        *Context){    switch (Value)    {#if 0    case 0:        printf ("[AcpiExec] Method Error 0x%X: Results not equal/n", Value);        if (AcpiGbl_DebugFile)        {            AcpiOsPrintf ("[AcpiExec] Method Error: Results not equal/n");        }        break;    case 1:        printf ("[AcpiExec] Method Error: Incorrect numeric result/n");        if (AcpiGbl_DebugFile)        {            AcpiOsPrintf ("[AcpiExec] Method Error: Incorrect numeric result/n");        }        break;    case 2:        printf ("[AcpiExec] Method Error: An operand was overwritten/n");        if (AcpiGbl_DebugFile)        {            AcpiOsPrintf ("[AcpiExec] Method Error: An operand was overwritten/n");        }        break;#endif    default:        printf ("[AcpiExec] Received a System Notify on [%4.4s] %p Value 0x%2.2X (%s)/n",            AcpiUtGetNodeName (Device), Device, Value,            AcpiUtGetNotifyName (Value));        if (AcpiGbl_DebugFile)        {            AcpiOsPrintf ("[AcpiExec] Received a system notify, Value 0x%2.2X/n", Value);        }        (void) AcpiEvaluateObject (Device, "_NOT", NULL, NULL);        break;    }}

status_tevaluate_method(acpi_handle handle, const char* method,                acpi_objects *args, acpi_data *returnValue){    ACPI_STATUS status;    status = AcpiEvaluateObject(handle, (ACPI_STRING)method,                                (ACPI_OBJECT_LIST*)args, (ACPI_BUFFER*)returnValue);    if (status == AE_BUFFER_OVERFLOW)        dprintf("evaluate_method: the passed buffer is too small!/n");    return status == AE_OK ? B_OK : B_ERROR;}

voidacpi_enable_IOAPIC (void){  ACPI_STATUS Status;  ACPI_OBJECT arg = { ACPI_TYPE_INTEGER };  ACPI_OBJECT_LIST arg_list = { 1, &arg };  arg.Integer.Value = 1;        /* IOAPIC */  Status = AcpiEvaluateObject (NULL, "//_PIC", &arg_list, NULL);  if (ACPI_FAILURE (Status) && Status != AE_NOT_FOUND) {    DLOG_COM1 ("unable to evaluate _PIC(1): %d/n", Status);  } else    DLOG_COM1 ("ACPI: IOAPIC mode enabled./n");}

static ACPI_STATUSthinkpad_mask_init(thinkpad_softc_t *sc, uint32_t mask){	ACPI_OBJECT param[2];	ACPI_OBJECT_LIST params;	ACPI_STATUS rv;	int i;	/* Update hotkey mask */	params.Count = 2;	params.Pointer = param;	param[0].Type = param[1].Type = ACPI_TYPE_INTEGER;	for (i = 0; i < 32; i++) {		param[0].Integer.Value = i + 1;		param[1].Integer.Value = (((1 << i) & mask) != 0);		rv = AcpiEvaluateObject(sc->sc_node->ad_handle, "MHKM",		    &params, NULL);		if (ACPI_FAILURE(rv))			return rv;	}	/* Enable hotkey events */	params.Count = 1;	param[0].Integer.Value = 1;	rv = AcpiEvaluateObject(sc->sc_node->ad_handle, "MHKC", &params, NULL);	if (ACPI_FAILURE(rv)) {		aprint_error_dev(sc->sc_dev, "couldn't enable hotkeys: %s/n",		    AcpiFormatException(rv));		return rv;	}	/* Claim ownership of brightness control */	param[0].Integer.Value = 0;	(void)AcpiEvaluateObject(sc->sc_node->ad_handle, "PWMS", &params, NULL);	return AE_OK;}

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 ACPI_STATUS find_pci_child_callback(ACPI_HANDLE object, uint32_t nesting_level,                                           void* context, void** out_value) {    ACPI_DEVICE_INFO* info;    ACPI_STATUS acpi_status = AcpiGetObjectInfo(object, &info);    if (acpi_status != AE_OK) {        zxlogf(TRACE, "bus-acpi: AcpiGetObjectInfo failed %d/n", acpi_status);        return acpi_status;    }    ACPI_FREE(info);    ACPI_OBJECT obj = {        .Type = ACPI_TYPE_INTEGER,    };    ACPI_BUFFER buffer = {        .Length = sizeof(obj),        .Pointer = &obj,    };    acpi_status = AcpiEvaluateObject(object, (char*)"_ADR", NULL, &buffer);    if (acpi_status != AE_OK) {        return AE_OK;    }    uint32_t addr = *(uint32_t*)context;    ACPI_HANDLE* out_handle = (ACPI_HANDLE*)out_value;    if (addr == obj.Integer.Value) {        *out_handle = object;        return AE_CTRL_TERMINATE;    } else {        return AE_OK;    }}static ACPI_STATUS pci_child_data_resources_callback(ACPI_RESOURCE* res, void* context) {    pci_child_auxdata_ctx_t* ctx = (pci_child_auxdata_ctx_t*)context;    auxdata_i2c_device_t* child = ctx->data + ctx->i;    if (res->Type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {        return AE_NOT_FOUND;    }    if (res->Data.I2cSerialBus.Type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {        return AE_NOT_FOUND;    }    ACPI_RESOURCE_I2C_SERIALBUS* i2c = &res->Data.I2cSerialBus;    child->bus_master = i2c->SlaveMode;    child->ten_bit = i2c->AccessMode;    child->address = i2c->SlaveAddress;    child->bus_speed = i2c->ConnectionSpeed;    return AE_CTRL_TERMINATE;}

static intacpi_cpu_probe(device_t dev){    int acpi_id, cpu_id;    ACPI_BUFFER buf;    ACPI_HANDLE handle;    ACPI_STATUS	status;    ACPI_OBJECT *obj;    if (acpi_disabled("cpu") || acpi_get_type(dev) != ACPI_TYPE_PROCESSOR)	return ENXIO;    handle = acpi_get_handle(dev);    /*     * Get our Processor object.     */    buf.Pointer = NULL;    buf.Length = ACPI_ALLOCATE_BUFFER;    status = AcpiEvaluateObject(handle, NULL, NULL, &buf);    if (ACPI_FAILURE(status)) {	device_printf(dev, "probe failed to get Processor obj - %s/n",		      AcpiFormatException(status));	return ENXIO;    }    obj = (ACPI_OBJECT *)buf.Pointer;    if (obj->Type != ACPI_TYPE_PROCESSOR) {	device_printf(dev, "Processor object has bad type %d/n", obj->Type);	AcpiOsFree(obj);	return ENXIO;    }    acpi_id = obj->Processor.ProcId;    AcpiOsFree(obj);    /*     * Find the processor associated with our unit.  We could use the     * ProcId as a key, however, some boxes do not have the same values     * in their Processor object as the ProcId values in the MADT.     */    if (acpi_cpu_get_id(device_get_unit(dev), &acpi_id, &cpu_id) != 0)	return ENXIO;    acpi_set_magic(dev, cpu_id);    device_set_desc(dev, "ACPI CPU");    return 0;}

static intacpi_dock_attach(device_t dev){	struct acpi_dock_softc *sc;	ACPI_HANDLE	h;	sc = device_get_softc(dev);	h = acpi_get_handle(dev);	if (sc == NULL || h == NULL)		return (ENXIO);	sc->status = ACPI_DOCK_STATUS_UNKNOWN;	AcpiEvaluateObject(h, "_INI", NULL, NULL);	ACPI_SERIAL_BEGIN(dock);	acpi_dock_device_check(dev);	/* Get the sysctl tree */	sc->sysctl_ctx = device_get_sysctl_ctx(dev);	sc->sysctl_tree = device_get_sysctl_tree(dev);	SYSCTL_ADD_INT(sc->sysctl_ctx,		SYSCTL_CHILDREN(sc->sysctl_tree),		OID_AUTO, "_sta", CTLFLAG_RD,		&sc->_sta, 0, "Dock _STA");	SYSCTL_ADD_INT(sc->sysctl_ctx,		SYSCTL_CHILDREN(sc->sysctl_tree),		OID_AUTO, "_bdn", CTLFLAG_RD,		&sc->_bdn, 0, "Dock _BDN");	SYSCTL_ADD_INT(sc->sysctl_ctx,		SYSCTL_CHILDREN(sc->sysctl_tree),		OID_AUTO, "_uid", CTLFLAG_RD,		&sc->_uid, 0, "Dock _UID");	SYSCTL_ADD_PROC(sc->sysctl_ctx,		SYSCTL_CHILDREN(sc->sysctl_tree),		OID_AUTO, "status",		CTLTYPE_INT|CTLFLAG_RW, dev, 0,		acpi_dock_status_sysctl, "I",		"Dock/Undock operation");	ACPI_SERIAL_END(dock);	AcpiInstallNotifyHandler(h, ACPI_ALL_NOTIFY,				 acpi_dock_notify_handler, dev);	return (0);}