acpi/acpidev/acpidev_util.c

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
/*
 * Copyright (c) 2009-2010, Intel Corporation.
 * All rights reserved.
 */

#include <sys/types.h>
#include <sys/cmn_err.h>
#include <sys/note.h>
#include <sys/sysmacros.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/acpi/acpi.h>
#include <sys/acpica.h>
#include <sys/acpidev.h>
#include <sys/acpidev_impl.h>
#include <util/sscanf.h>

/* Data structures used to extract the numeric unit address from string _UID. */
static acpidev_pseudo_uid_head_t acpidev_uid_heads[ACPIDEV_CLASS_ID_MAX];
static char *acpidev_uid_formats[] = {
	"%u",
};

static char *acpidev_unknown_object_name = "<unknown>";

int
acpidev_query_device_status(ACPI_HANDLE hdl)
{
	int status;

	ASSERT(hdl != NULL);
	if (hdl == NULL) {
		ACPIDEV_DEBUG(CE_WARN,
		    "!acpidev: hdl is NULL in acpidev_query_device_status().");
		return (0);
	}

	if (ACPI_FAILURE(acpica_eval_int(hdl, METHOD_NAME__STA, &status))) {
		/*
		 * Set the default value according to ACPI3.0b sec 6.3.7:
		 * If a device object (including the processor object) does
		 * not have an _STA object, then OSPM assumes that all of the
		 * above bits are set (in other words, the device is present,
		 * enabled, shown in the UI, and functioning).
		 */
		status = 0xF;
	}

	return (status);
}

boolean_t
acpidev_check_device_present(int status)
{
	/*
	 * According to ACPI3.0 Spec, if either the ACPI_STA_DEVICE_PRESENT bit
	 * or the ACPI_STA_DEVICE_FUNCTIONING bit is set, the device exists.
	 */
	if (status & (ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_FUNCTIONING)) {
		return (B_TRUE);
	}

	return (B_FALSE);
}

boolean_t
acpidev_check_device_enabled(int stat)
{
	/*
	 * According to ACPI3.0 Spec, if either the ACPI_STA_DEVICE_PRESENT bit
	 * or the ACPI_STA_DEVICE_FUNCTIONING bit is set, the device exists.
	 * Return true if device exists and has been enabled.
	 */
	if ((stat & (ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_FUNCTIONING)) &&
	    (stat & ACPI_STA_DEVICE_ENABLED)) {
		return (B_TRUE);
	}

	return (B_FALSE);
}

boolean_t
acpidev_match_device_id(ACPI_DEVICE_INFO *infop, char **ids, int count)
{
	int i, j;

	ASSERT(infop != NULL);
	ASSERT(ids != NULL || count == 0);
	/* Special case to match all devices if count is 0. */
	if (count == 0) {
		return (B_TRUE);
	} else if (infop == NULL || ids == NULL) {
		ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameters in "
		    "acpidev_match_device_id().");
		return (B_FALSE);
	}

	/* Match _HID first. */
	if (infop->Valid & ACPI_VALID_HID) {
		for (i = 0; i < count; i++) {
			if (strncmp(ids[i], infop->HardwareId.String,
			    infop->HardwareId.Length) == 0) {
				return (B_TRUE);
			}
		}
	}

	/* Match _CID next. */
	if (infop->Valid & ACPI_VALID_CID) {
		for (i = 0; i < count; i++) {
			for (j = 0; j < infop->CompatibleIdList.Count; j++) {
				if (strncmp(ids[i],
				    infop->CompatibleIdList.Ids[j].String,
				    infop->CompatibleIdList.Ids[j].Length)
				    == 0) {
					return (B_TRUE);
				}
			}
		}
	}

	return (B_FALSE);
}

struct acpidev_get_device_arg {
	boolean_t		skip_non_exist;
	int			id_count;
	char 			**device_ids;
	void			*user_arg;
	ACPI_WALK_CALLBACK	user_func;
};

static ACPI_STATUS
acpidev_get_device_callback(ACPI_HANDLE hdl, UINT32 level, void *arg,
    void **retval)
{
	ACPI_STATUS rc;
	ACPI_DEVICE_INFO *infop;
	struct acpidev_get_device_arg *argp;

	argp = (struct acpidev_get_device_arg *)arg;
	ASSERT(argp != NULL);
	ASSERT(hdl != NULL);

	/* Query object information. */
	rc = AcpiGetObjectInfo(hdl, &infop);
	if (ACPI_FAILURE(rc)) {
		cmn_err(CE_WARN, "!acpidev: failed to get ACPI object info "
		    "in acpidev_get_device_callback().");
		return (AE_CTRL_DEPTH);
	}

	/*
	 * Skip scanning of children if the device is neither PRESENT nor
	 * FUNCTIONING.
	 * Please refer to ACPI Spec3.0b Sec 6.3.1 and 6.5.1.
	 */
	if (argp->skip_non_exist && (infop->Valid & ACPI_VALID_STA) &&
	    !acpidev_check_device_present(infop->CurrentStatus)) {
		rc = AE_CTRL_DEPTH;
	/* Call user callback if matched. */
	} else if (acpidev_match_device_id(infop, argp->device_ids,
	    argp->id_count)) {
		rc = argp->user_func(hdl, level, argp->user_arg, retval);
	} else {
		rc = AE_OK;
	}

	/* Free ACPI object info buffer. */
	AcpiOsFree(infop);

	return (rc);
}

ACPI_STATUS
acpidev_get_device_by_id(ACPI_HANDLE hdl, char **ids, int count,
    int maxdepth, boolean_t skip_non_exist,
    ACPI_WALK_CALLBACK userfunc, void *userarg, void **retval)
{
	ACPI_STATUS rc;
	struct acpidev_get_device_arg arg;

	ASSERT(userfunc != NULL);
	if (hdl == NULL || userfunc == NULL || (ids == NULL && count != 0)) {
		ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameters "
		    "in acpidev_get_device_by_id().");
		return (AE_BAD_PARAMETER);
	}

	/* Enumerate all descendant objects. */
	arg.skip_non_exist = skip_non_exist;
	arg.device_ids = ids;
	arg.id_count = count;
	arg.user_arg = userarg;
	arg.user_func = userfunc;
	rc = AcpiWalkNamespace(ACPI_TYPE_DEVICE, hdl, maxdepth,
	    &acpidev_get_device_callback, NULL, &arg, retval);

	return (rc);
}

ACPI_STATUS
acpidev_walk_apic(ACPI_BUFFER *bufp, ACPI_HANDLE hdl, char *method,
    acpidev_apic_walker_t func, void *context)
{
	ACPI_STATUS rc;
	ssize_t len;
	ACPI_BUFFER buf;
	ACPI_OBJECT *obj;
	ACPI_SUBTABLE_HEADER *ap;
	ACPI_TABLE_MADT *mp = NULL;

	ASSERT(func != NULL);
	if (func == NULL) {
		ACPIDEV_DEBUG(CE_WARN,
		    "!acpidev: invalid parameters for acpidev_walk_apic().");
		return (AE_BAD_PARAMETER);
	}

	buf.Pointer = NULL;
	buf.Length = ACPI_ALLOCATE_BUFFER;

	/* A walk buffer was passed in if bufp isn't NULL. */
	if (bufp != NULL) {
		ap = (ACPI_SUBTABLE_HEADER *)(bufp->Pointer);
		len = bufp->Length;
	} else if (method != NULL) {
		/*
		 * Otherwise, if we have an evaluate method, we get the walk
		 * buffer from a successful invocation of
		 * AcpiEvaluateObjectTyped().
		 */
		ASSERT(hdl != NULL);
		rc = AcpiEvaluateObjectTyped(hdl, method, NULL, &buf,
		    ACPI_TYPE_BUFFER);
		if (ACPI_SUCCESS(rc)) {
			ASSERT(buf.Length >= sizeof (*obj));
			obj = buf.Pointer;
			ap = (ACPI_SUBTABLE_HEADER *)obj->Buffer.Pointer;
			len = obj->Buffer.Length;
		} else {
			if (rc != AE_NOT_FOUND)
				cmn_err(CE_WARN, "!acpidev: failed to evaluate "
				    "%s in acpidev_walk_apic().", method);
			return (rc);
		}
	} else {
		/* As a last resort, walk the MADT table. */
		rc = AcpiGetTable(ACPI_SIG_MADT, 1, (ACPI_TABLE_HEADER **)&mp);
		if (ACPI_FAILURE(rc)) {
			cmn_err(CE_WARN, "!acpidev: failed to get MADT table "
			    "in acpidev_walk_apic().");
			return (rc);
		}
		ap = (ACPI_SUBTABLE_HEADER *)(mp + 1);
		len = mp->Header.Length - sizeof (*mp);
	}

	ASSERT(len >= 0);
	for (rc = AE_OK; len > 0 && ACPI_SUCCESS(rc); len -= ap->Length,
	    ap = (ACPI_SUBTABLE_HEADER *)(((char *)ap) + ap->Length)) {
		ASSERT(len >= sizeof (ACPI_SUBTABLE_HEADER));
		if (len <= sizeof (ACPI_SUBTABLE_HEADER) ||
		    ap->Length <= sizeof (ACPI_SUBTABLE_HEADER) ||
		    len < ap->Length) {
			cmn_err(CE_WARN,
			    "!acpidev: invalid APIC entry in MADT/_MAT.");
			break;
		}
		rc = (*func)(ap, context);
	}

	if (buf.Pointer != NULL) {
		AcpiOsFree(buf.Pointer);
	}

	return (rc);
}

char *
acpidev_get_object_name(ACPI_HANDLE hdl)
{
	ACPI_BUFFER buf;
	char *objname = acpidev_unknown_object_name;

	buf.Length = ACPI_ALLOCATE_BUFFER;
	buf.Pointer = NULL;
	if (ACPI_SUCCESS(AcpiGetName(hdl, ACPI_FULL_PATHNAME, &buf))) {
		ASSERT(buf.Pointer != NULL);
		objname = (char *)buf.Pointer;
	}

	return (objname);
}

void
acpidev_free_object_name(char *objname)
{
	if (objname != acpidev_unknown_object_name && objname != NULL) {
		AcpiOsFree(objname);
	}
}

acpidev_walk_info_t *
acpidev_alloc_walk_info(acpidev_op_type_t op_type, int lvl, ACPI_HANDLE hdl,
    acpidev_class_list_t **listpp, acpidev_walk_info_t *pinfop)
{
	acpidev_walk_info_t *infop = NULL;
	acpidev_data_handle_t datap = NULL;

	ASSERT(0 <= lvl && lvl < ACPIDEV_MAX_ENUM_LEVELS);
	infop = kmem_zalloc(sizeof (*infop), KM_SLEEP);
	infop->awi_op_type = op_type;
	infop->awi_level = lvl;
	infop->awi_parent = pinfop;
	infop->awi_class_list = listpp;
	infop->awi_hdl = hdl;
	infop->awi_name = acpidev_get_object_name(hdl);

	/* Cache ACPI device information. */
	if (ACPI_FAILURE(AcpiGetObjectInfo(hdl, &infop->awi_info))) {
		cmn_err(CE_WARN, "!acpidev: failed to get object info for %s "
		    "in acpidev_alloc_walk_info().", infop->awi_name);
		acpidev_free_object_name(infop->awi_name);
		kmem_free(infop, sizeof (*infop));
		return (NULL);
	}

	/*
	 * Get or create an ACPI object data handle, which will be used to
	 * maintain object status information.
	 */
	if ((datap = acpidev_data_get_handle(hdl)) != NULL) {
		ASSERT(datap->aod_hdl == hdl);
		ASSERT(datap->aod_level == lvl);
	} else if ((datap = acpidev_data_create_handle(hdl)) != NULL) {
		datap->aod_level = lvl;
		datap->aod_hdl = hdl;
	} else {
		ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to create object "
		    "handle for %s in acpidev_alloc_walk_info().",
		    infop->awi_name);
		AcpiOsFree(infop->awi_info);
		acpidev_free_object_name(infop->awi_name);
		kmem_free(infop, sizeof (*infop));
		return (NULL);
	}
	infop->awi_data = datap;
	/* Sync DEVICE_CREATED flag. */
	if (datap->aod_iflag & ACPIDEV_ODF_DEVINFO_CREATED) {
		ASSERT(datap->aod_dip != NULL);
		ASSERT(datap->aod_class != NULL);
		infop->awi_dip = datap->aod_dip;
		infop->awi_flags |= ACPIDEV_WI_DEVICE_CREATED;
	}

	return (infop);
}

void
acpidev_free_walk_info(acpidev_walk_info_t *infop)
{
	/*
	 * The ACPI object data handle will only be released when the
	 * corresponding object is going to be destroyed.
	 */
	if (infop != NULL) {
		if (infop->awi_info != NULL) {
			AcpiOsFree(infop->awi_info);
		}
		if (infop->awi_name != NULL) {
			acpidev_free_object_name(infop->awi_name);
		}
		kmem_free(infop, sizeof (*infop));
	}
}

dev_info_t *
acpidev_walk_info_get_pdip(acpidev_walk_info_t *infop)
{
	while (infop != NULL) {
		if (infop->awi_dip != NULL) {
			return (infop->awi_dip);
		}
		infop = infop->awi_parent;
	}

	return (NULL);
}

/*
 * Called to release resources when the corresponding object is going
 * to be destroyed.
 */
static void
acpidev_free_object_handler(ACPI_HANDLE hdl, void *data)
{
	_NOTE(ARGUNUSED(hdl));

	acpidev_data_handle_t objhdl = data;

	if (objhdl->aod_class != NULL) {
		atomic_dec_32(&objhdl->aod_class->adc_refcnt);
		objhdl->aod_class = NULL;
	}
	kmem_free(objhdl, sizeof (acpidev_data_handle_t));
}

acpidev_data_handle_t
acpidev_data_get_handle(ACPI_HANDLE hdl)
{
	void *ptr;
	acpidev_data_handle_t objhdl = NULL;

	if (ACPI_SUCCESS(AcpiGetData(hdl, acpidev_free_object_handler, &ptr))) {
		objhdl = (acpidev_data_handle_t)ptr;
	}

	return (objhdl);
}

acpidev_data_handle_t
acpidev_data_create_handle(ACPI_HANDLE hdl)
{
	acpidev_data_handle_t objhdl;

	objhdl = kmem_zalloc(sizeof (*objhdl), KM_SLEEP);
	objhdl->aod_bdtype = ACPIDEV_INVALID_BOARD;
	objhdl->aod_bdnum = UINT32_MAX;
	objhdl->aod_portid = UINT32_MAX;
	objhdl->aod_class_id = ACPIDEV_CLASS_ID_INVALID;

	if (ACPI_FAILURE(AcpiAttachData(hdl, acpidev_free_object_handler,
	    (void *)objhdl))) {
		cmn_err(CE_WARN,
		    "!acpidev: failed to attach handle data to object.");
		kmem_free(objhdl, sizeof (*objhdl));
		return (NULL);
	}

	return (objhdl);
}

void
acpidev_data_destroy_handle(ACPI_HANDLE hdl)
{
	void *ptr;
	acpidev_data_handle_t objhdl = NULL;

	if (ACPI_SUCCESS(AcpiGetData(hdl, acpidev_free_object_handler, &ptr)) &&
	    ACPI_SUCCESS(AcpiDetachData(hdl, acpidev_free_object_handler))) {
		objhdl = ptr;
		if (objhdl->aod_class != NULL) {
			atomic_dec_32(&objhdl->aod_class->adc_refcnt);
			objhdl->aod_class = NULL;
		}
		kmem_free(ptr, sizeof (acpidev_data_handle_t));
	}
}

ACPI_HANDLE
acpidev_data_get_object(acpidev_data_handle_t hdl)
{
	ASSERT(hdl != NULL);
	return ((hdl != NULL) ? hdl->aod_hdl : NULL);
}

dev_info_t *
acpidev_data_get_devinfo(acpidev_data_handle_t hdl)
{
	ASSERT(hdl != NULL);
	if (hdl == NULL ||
	    (hdl->aod_iflag & ACPIDEV_ODF_DEVINFO_CREATED) == 0) {
		return (NULL);
	} else {
		ASSERT(hdl->aod_dip != NULL);
		return (hdl->aod_dip);
	}
}

int
acpidev_data_get_status(acpidev_data_handle_t hdl)
{
	ASSERT(hdl != NULL);
	if (hdl == NULL ||
	    (hdl->aod_iflag & ACPIDEV_ODF_STATUS_VALID) == 0) {
		return (0);
	} else {
		return (hdl->aod_status);
	}
}

void
acpidev_data_set_flag(acpidev_data_handle_t hdl, uint32_t flag)
{
	ASSERT(hdl != NULL);
	atomic_or_32(&hdl->aod_eflag, flag);
}

void
acpidev_data_clear_flag(acpidev_data_handle_t hdl, uint32_t flag)
{
	ASSERT(hdl != NULL);
	atomic_and_32(&hdl->aod_eflag, ~flag);
}

uint32_t
acpidev_data_get_flag(acpidev_data_handle_t hdl, uint32_t flag)
{
	ASSERT(hdl != NULL);
	return (hdl->aod_eflag & flag);
}

boolean_t
acpidev_data_dr_capable(acpidev_data_handle_t hdl)
{
	ASSERT(hdl != NULL);
	return (hdl->aod_iflag & ACPIDEV_ODF_HOTPLUG_CAPABLE);
}

boolean_t
acpidev_data_dr_ready(acpidev_data_handle_t hdl)
{
	ASSERT(hdl != NULL);
	return (hdl->aod_iflag & ACPIDEV_ODF_HOTPLUG_READY);
}

boolean_t
acpidev_data_dr_failed(acpidev_data_handle_t hdl)
{
	ASSERT(hdl != NULL);
	return (hdl->aod_iflag & ACPIDEV_ODF_HOTPLUG_FAILED);
}

static char *
acpidev_generate_pseudo_unitaddr(char *uid, acpidev_class_id_t cid,
    char *buf, size_t len)
{
	acpidev_pseudo_uid_t *up, **pp;

	ASSERT(len >= 64);
	ASSERT(cid >= 0 && cid < ACPIDEV_CLASS_ID_MAX);
	if (cid < 0 || cid >= ACPIDEV_CLASS_ID_MAX) {
		return (NULL);
	}

	mutex_enter(&acpidev_uid_heads[cid].apuh_lock);
	for (pp = &acpidev_uid_heads[cid].apuh_first; *pp != NULL;
	    pp = &(*pp)->apu_next) {
		if (strcmp(uid, (*pp)->apu_uid) == 0 &&
		    (*pp)->apu_cid == cid) {
			break;
		}
	}
	/* uid doesn't exist, create one and insert it into the list. */
	if (*pp == NULL) {
		up = kmem_zalloc(sizeof (*up), KM_SLEEP);
		up->apu_uid = ddi_strdup(uid, KM_SLEEP);
		up->apu_cid = cid;
		up->apu_nid = acpidev_uid_heads[cid].apuh_id++;
		*pp = up;
	}
	ASSERT(*pp != NULL);
	mutex_exit(&acpidev_uid_heads[cid].apuh_lock);

	/*
	 * Generate a special format unit address with three fields to
	 * guarantee uniqueness. Normal unit addresses for ACPI devices have
	 * either one or two fields.
	 */
	if (snprintf(buf, len, "%u,%u,0", (*pp)->apu_nid, cid) > len) {
		return (NULL);
	}

	return (buf);
}

static char *
acpidev_gen_unitaddr(char *uid, char *fmt, char *buf, size_t len)
{
	size_t i, cnt;
	uint_t id1, id2;

	ASSERT(len >= 64);
	if (fmt == NULL || strlen(fmt) == 0) {
		return (NULL);
	}

	/*
	 * Count '%' in format string to protect sscanf().
	 * Only support '%u' and '%x', and maximum 2 conversions.
	 */
	for (cnt = 0, i = 0; fmt[i] != 0 && cnt <= 2; i++) {
		if (fmt[i] != '%') {
			continue;
		} else if (fmt[i + 1] == 'u' || fmt[i + 1] == 'x') {
			/* Skip next character. */
			i++;
			cnt++;
		} else {
			/* Invalid conversion, stop walking. */
			cnt = SIZE_MAX;
		}
	}
	if (cnt != 1 && cnt != 2) {
		ACPIDEV_DEBUG(CE_WARN,
		    "!acpidev: invalid uid format string '%s'.", fmt);
		return (NULL);
	}

	/* Scan uid and generate unitaddr. */
	if (sscanf(uid, fmt, &id1, &id2) != cnt) {
		return (NULL);
	}
	/*
	 * Reverse the order of the two IDs to match the requirements of the
	 * hotplug driver.
	 */
	if (cnt == 2 && snprintf(buf, len, "%u,%u", id2, id1) >= len) {
		ACPIDEV_DEBUG(CE_WARN,
		    "!acpidev: generated unitaddr is too long.");
		return (NULL);
	} else if (cnt == 1 && snprintf(buf, len, "%u", id1) >= len) {
		ACPIDEV_DEBUG(CE_WARN,
		    "!acpidev: generated unitaddr is too long.");
		return (NULL);
	}

	return (buf);
}

char *
acpidev_generate_unitaddr(char *uid, char **fmts, size_t nfmt,
    char *buf, size_t len)
{
	size_t i;
	uint_t count = 0;
	ulong_t val;
	char **formats = NULL;
	char *rbuf = NULL;
	char *endp = NULL;

	ASSERT(len >= 64);

	/* Use _UID as unit address if it's a decimal integer. */
	if (ddi_strtoul(uid, &endp, 10, &val) == 0 &&
	    (endp == NULL || *endp == 0)) {
		if (snprintf(buf, len, "%s", uid) >= len) {
			return (NULL);
		} else {
			return (buf);
		}
	}

	/* First handle uid format strings from device property. */
	if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, ddi_root_node(),
	    DDI_PROP_DONTPASS,
	    ACPIDEV_PROP_NAME_UID_FORMAT, &formats, &count) == DDI_SUCCESS) {
		/* Walk through format strings and try to generate unitaddr. */
		for (i = 0; i < count && rbuf == NULL; i++) {
			rbuf = acpidev_gen_unitaddr(uid, formats[i], buf, len);
		}
		ddi_prop_free(formats);
	}

	/* Then handle embedded uid format strings. */
	if (fmts != NULL) {
		for (i = 0; i < nfmt && rbuf == NULL; i++) {
			rbuf = acpidev_gen_unitaddr(uid, fmts[i], buf, len);
		}
	}

	return (rbuf);
}

/*
 * The Solaris device "unit-address" property is composed of a comma-delimited
 * list of hexadecimal values. According to the ACPI spec, the ACPI _UID method
 * could return an integer or a string. If it returns an integer, it is used
 * as the unit-address as is. If _UID returns a string, we try to extract some
 * meaningful integers to compose the unit-address property. If we fail to
 * extract any integers, a pseudo-sequential number will be generated for the
 * unit-address.
 */
ACPI_STATUS
acpidev_set_unitaddr(acpidev_walk_info_t *infop, char **fmts, size_t nfmt,
    char *unitaddr)
{
	char unit[64];

	ASSERT(infop != NULL);
	ASSERT(infop->awi_dip != NULL);
	ASSERT(infop->awi_info != NULL);
	if (infop == NULL || infop->awi_dip == NULL ||
	    infop->awi_info == NULL) {
		ACPIDEV_DEBUG(CE_WARN,
		    "!acpidev: invalid parameters in acpidev_set_unitaddr().");
		return (AE_BAD_PARAMETER);
	}

	if (infop->awi_info->Valid & ACPI_VALID_UID) {
		if (ndi_prop_update_string(DDI_DEV_T_NONE, infop->awi_dip,
		    ACPIDEV_PROP_NAME_ACPI_UID,
		    infop->awi_info->UniqueId.String) != NDI_SUCCESS) {
			cmn_err(CE_WARN,
			    "!acpidev: failed to set UID property for %s.",
			    infop->awi_name);
			return (AE_ERROR);
		}
	}

	if (unitaddr == NULL && (infop->awi_info->Valid & ACPI_VALID_UID)) {
		/* Try to generate unit address from _UID. */
		if (fmts == NULL) {
			fmts = acpidev_uid_formats;
			nfmt = sizeof (acpidev_uid_formats) / sizeof (char *);
		}
		unitaddr = acpidev_generate_unitaddr(
		    infop->awi_info->UniqueId.String, fmts, nfmt,
		    unit, sizeof (unit));
		/* Generate pseudo sequential unit address. */
		if (unitaddr == NULL) {
			unitaddr = acpidev_generate_pseudo_unitaddr(
			    infop->awi_info->UniqueId.String,
			    infop->awi_class_curr->adc_class_id,
			    unit, sizeof (unit));
		}
		if (unitaddr == NULL) {
			cmn_err(CE_WARN, "!acpidev: failed to generate unit "
			    "address from %s.",
			    infop->awi_info->UniqueId.String);
			return (AE_ERROR);
		}
	}
	if (unitaddr == NULL) {
		/*
		 * Some ACPI objects may have no _UID method available, so we
		 * can't generate the "unit-address" property for them.
		 * On the other hand, it's legal to support such a device
		 * without a unit address, so return success here.
		 */
		return (AE_OK);
	}

	if (ndi_prop_update_string(DDI_DEV_T_NONE, infop->awi_dip,
	    ACPIDEV_PROP_NAME_UNIT_ADDR, unitaddr) != NDI_SUCCESS) {
		cmn_err(CE_WARN, "!acpidev: failed to set unitaddr for %s.",
		    infop->awi_name);
		return (AE_ERROR);
	}

	return (AE_OK);
}

ACPI_STATUS
acpidev_set_compatible(acpidev_walk_info_t *infop, char **compat, int acount)
{
	int count, i, j;
	char **compatible = NULL;
	ACPI_DEVICE_INFO *di;

	/*
	 * Generate compatible list for device based on:
	 *	* Device HID if available
	 *	* Device CIDs if available
	 *	* property array passed in
	 */
	ASSERT(infop != NULL);
	ASSERT(infop->awi_dip != NULL);
	ASSERT(infop->awi_info != NULL);
	ASSERT(compat != NULL || acount == 0);
	if (infop == NULL || infop->awi_dip == NULL ||
	    infop->awi_info == NULL || (compat == NULL && acount != 0)) {
		ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameters "
		    "in acpidev_set_compatible().");
		return (AE_BAD_PARAMETER);
	}

	/* Compute string count. */
	count = acount;
	di = infop->awi_info;
	if (di->Valid & ACPI_VALID_HID) {
		count++;
	}
	if (di->Valid & ACPI_VALID_CID) {
		count += di->CompatibleIdList.Count;
	}
	compatible = kmem_zalloc(sizeof (char *) * count, KM_SLEEP);

	/* Generate string array. */
	i = 0;
	if (di->Valid & ACPI_VALID_HID) {
		compatible[i++] = di->HardwareId.String;
	}
	if (di->Valid & ACPI_VALID_CID) {
		for (j = 0; j < di->CompatibleIdList.Count; j++) {
			compatible[i++] = di->CompatibleIdList.Ids[j].String;
		}
	}
	for (j = 0; j < acount; j++) {
		compatible[i++] = compat[j];
	}
	ASSERT(i == count);

	/* Set "compatible" property. */
	if (ndi_prop_update_string_array(DDI_DEV_T_NONE, infop->awi_dip,
	    OBP_COMPATIBLE, compatible, count) != NDI_SUCCESS) {
		cmn_err(CE_WARN, "!acpidev: failed to set compatible "
		    "property for %s in acpidev_set_compatible().",
		    infop->awi_name);
		kmem_free(compatible, count * sizeof (char *));
		return (AE_ERROR);
	}
	kmem_free(compatible, count * sizeof (char *));

	return (AE_OK);
}

/* Evaluate _OST method under object, which is used to support hotplug event. */
ACPI_STATUS
acpidev_eval_ost(ACPI_HANDLE hdl, uint32_t code, uint32_t status,
    char *bufp, size_t len)
{
	ACPI_STATUS rc;
	ACPI_OBJECT args[3];
	ACPI_OBJECT_LIST arglist;

	args[0].Type = ACPI_TYPE_INTEGER;
	args[0].Integer.Value = code;
	args[1].Type = ACPI_TYPE_INTEGER;
	args[1].Integer.Value = status;
	args[2].Type = ACPI_TYPE_BUFFER;
	args[2].Buffer.Pointer = (UINT8 *)bufp;
	args[2].Buffer.Length = (UINT32)len;
	if (bufp == NULL || len == 0) {
		arglist.Count = 2;
	} else {
		arglist.Count = 3;
	}
	arglist.Pointer = args;
	rc = AcpiEvaluateObject(hdl, ACPIDEV_METHOD_NAME_OST, &arglist, NULL);
	if (rc != AE_OK && rc != AE_NOT_FOUND) {
		ACPIDEV_DEBUG(CE_WARN,
		    "!acpidev: failed to evaluate _OST method, code 0x%x.", rc);
	}

	return (rc);
}

ACPI_STATUS
acpidev_eval_ej0(ACPI_HANDLE hdl)
{
	ACPI_STATUS rc;
	ACPI_OBJECT args[1];
	ACPI_OBJECT_LIST arglist;

	/*
	 * Quotation from ACPI spec 4.0 section 6.3.3.
	 * Arg0 An Integer containing a device ejection control
	 * 	0  Cancel a mark for ejection request (EJ0 will never be called
	 *	   with this value)
	 * 	1  Hot eject or mark for ejection
	 */
	args[0].Type = ACPI_TYPE_INTEGER;
	args[0].Integer.Value = 1;
	arglist.Count = 1;
	arglist.Pointer = args;
	rc = AcpiEvaluateObject(hdl, ACPIDEV_METHOD_NAME_EJ0, &arglist, NULL);
	if (rc != AE_OK) {
		ACPIDEV_DEBUG(CE_WARN,
		    "!acpidev: failed to evaluate _EJ0 method, code 0x%x.", rc);
	}

	return (rc);
}

ACPI_STATUS
acpidev_eval_pxm(ACPI_HANDLE hdl, uint32_t *idp)
{
	int pxmid;

	ASSERT(idp != NULL);

	/*
	 * Try to evaluate ACPI _PXM method to get proximity doamin id.
	 * Quotation from ACPI4.0:
	 * If the Local APIC ID / Local SAPIC ID / Local x2APIC ID of a
	 * dynamically added processor is not present in the System Resource
	 * Affinity Table (SRAT), a _PXM object must exist for the processor's
	 * device or one of its ancestors in the ACPI Namespace.
	 */
	while (hdl != NULL) {
		if (ACPI_SUCCESS(acpica_eval_int(hdl,
		    ACPIDEV_METHOD_NAME_PXM, &pxmid))) {
			*idp = (uint32_t)pxmid;
			return (AE_OK);
		}
		if (ACPI_FAILURE(AcpiGetParent(hdl, &hdl))) {
			break;
		}
	}

	return (AE_NOT_FOUND);
}