/*
 * 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 2016 Nexenta Systems, Inc.
 */
/*
 * Copyright (c) 2009-2010, Intel Corporation.
 * All rights reserved.
 */

/*
 * [Support of X2APIC]
 * According to the ACPI Spec, when using the X2APIC interrupt model, logical
 * processors with APIC ID values of 255 and greater are required to have a
 * Processor Device object and must convey the Processor's APIC information to
 * OSPM using the Processor Local X2APIC structure. Logical Processors with APIC
 * ID values less than 255 must use the Processor Local XAPIC structure to
 * convey their APIC information to OSPM.
 *
 * Some systems ignore that requirement of ACPI Spec and use Processor Local
 * X2APIC structures even for Logical Processors with APIC ID values less than
 * 255.
 */

#include <sys/types.h>
#include <sys/atomic.h>
#include <sys/bootconf.h>
#include <sys/cpuvar.h>
#include <sys/machsystm.h>
#include <sys/note.h>
#include <sys/psm_types.h>
#include <sys/x86_archext.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>

struct acpidev_cpu_map_item {
        uint32_t        proc_id;
        uint32_t        apic_id;
};

struct acpidev_cpu_MAT_arg {
        boolean_t       found;
        boolean_t       enabled;
        uint32_t        proc_id;
        uint32_t        apic_id;
};

static ACPI_STATUS acpidev_cpu_pre_probe(acpidev_walk_info_t *infop);
static ACPI_STATUS acpidev_cpu_post_probe(acpidev_walk_info_t *infop);
static ACPI_STATUS acpidev_cpu_probe(acpidev_walk_info_t *infop);
static acpidev_filter_result_t acpidev_cpu_filter(acpidev_walk_info_t *infop,
    char *devname, int maxlen);
static ACPI_STATUS acpidev_cpu_init(acpidev_walk_info_t *infop);
static void acpidev_cpu_fini(ACPI_HANDLE hdl, acpidev_data_handle_t dhdl,
    acpidev_class_t *clsp);

static acpidev_filter_result_t acpidev_cpu_filter_func(
    acpidev_walk_info_t *infop, ACPI_HANDLE hdl, acpidev_filter_rule_t *afrp,
    char *devname, int len);
static int acpidev_cpu_create_dip(cpu_t *, dev_info_t **);
static int acpidev_cpu_get_dip(cpu_t *, dev_info_t **);

/*
 * Default class driver for ACPI processor/CPU objects.
 */
acpidev_class_t acpidev_class_cpu = {
        0,                              /* adc_refcnt */
        ACPIDEV_CLASS_REV1,             /* adc_version */
        ACPIDEV_CLASS_ID_CPU,           /* adc_class_id */
        "ACPI CPU",                     /* adc_class_name */
        ACPIDEV_TYPE_CPU,               /* adc_dev_type */
        NULL,                           /* adc_private */
        acpidev_cpu_pre_probe,          /* adc_pre_probe */
        acpidev_cpu_post_probe,         /* adc_post_probe */
        acpidev_cpu_probe,              /* adc_probe */
        acpidev_cpu_filter,             /* adc_filter */
        acpidev_cpu_init,               /* adc_init */
        acpidev_cpu_fini,               /* adc_fini */
};

/*
 * List of class drivers which will be called in order when handling
 * children of ACPI cpu/processor objects.
 */
acpidev_class_list_t *acpidev_class_list_cpu = NULL;

/* Filter rule table for the first probe at boot time. */
static acpidev_filter_rule_t acpidev_cpu_filters[] = {
        {       /* Skip all processors under root node, should be there. */
                NULL,
                0,
                ACPIDEV_FILTER_SKIP,
                NULL,
                1,
                1,
                NULL,
                NULL,
        },
        {       /* Create and scan other processor objects */
                acpidev_cpu_filter_func,
                0,
                ACPIDEV_FILTER_DEFAULT,
                &acpidev_class_list_cpu,
                2,
                INT_MAX,
                NULL,
                ACPIDEV_NODE_NAME_CPU,
        }
};

/* ACPI/PNP hardware id for processor. */
static char *acpidev_processor_device_ids[] = {
        ACPIDEV_HID_CPU,
};

static char *acpidev_cpu_uid_formats[] = {
        "SCK%x-CPU%x",
};

static ACPI_HANDLE acpidev_cpu_map_hdl;
static uint32_t acpidev_cpu_map_count;
static struct acpidev_cpu_map_item *acpidev_cpu_map;

extern int (*psm_cpu_create_devinfo)(cpu_t *, dev_info_t **);
static int (*psm_cpu_create_devinfo_old)(cpu_t *, dev_info_t **);
extern int (*psm_cpu_get_devinfo)(cpu_t *, dev_info_t **);
static int (*psm_cpu_get_devinfo_old)(cpu_t *, dev_info_t **);

/* Count how many enabled CPUs are in the MADT table. */
static ACPI_STATUS
acpidev_cpu_count_MADT(ACPI_SUBTABLE_HEADER *ap, void *context)
{
        uint32_t *cntp;
        ACPI_MADT_LOCAL_APIC *mpa;
        ACPI_MADT_LOCAL_X2APIC *mpx2a;

        cntp = (uint32_t *)context;
        switch (ap->Type) {
        case ACPI_MADT_TYPE_LOCAL_APIC:
                mpa = (ACPI_MADT_LOCAL_APIC *)ap;
                if (mpa->LapicFlags & ACPI_MADT_ENABLED) {
                        ASSERT(mpa->Id != 255);
                        (*cntp)++;
                }
                break;

        case ACPI_MADT_TYPE_LOCAL_X2APIC:
                mpx2a = (ACPI_MADT_LOCAL_X2APIC *)ap;
                if ((mpx2a->LapicFlags & ACPI_MADT_ENABLED)) {
                        (*cntp)++;
                }
                break;

        default:
                break;
        }

        return (AE_OK);
}

/* Extract information from the enabled CPUs using the MADT table. */
static ACPI_STATUS
acpidev_cpu_parse_MADT(ACPI_SUBTABLE_HEADER *ap, void *context)
{
        uint32_t *cntp;
        ACPI_MADT_LOCAL_APIC *mpa;
        ACPI_MADT_LOCAL_X2APIC *mpx2a;

        cntp = (uint32_t *)context;
        switch (ap->Type) {
        case ACPI_MADT_TYPE_LOCAL_APIC:
                mpa = (ACPI_MADT_LOCAL_APIC *)ap;
                if (mpa->LapicFlags & ACPI_MADT_ENABLED) {
                        ASSERT(mpa->Id != 255);
                        ASSERT(*cntp < acpidev_cpu_map_count);
                        acpidev_cpu_map[*cntp].proc_id = mpa->ProcessorId;
                        acpidev_cpu_map[*cntp].apic_id = mpa->Id;
                        (*cntp)++;
                }
                break;

        case ACPI_MADT_TYPE_LOCAL_X2APIC:
                mpx2a = (ACPI_MADT_LOCAL_X2APIC *)ap;
                /* See comment at beginning about 255 limitation. */
                if (mpx2a->LocalApicId < 255) {
                        ACPIDEV_DEBUG(CE_WARN,
                            "!acpidev: encountered CPU with X2APIC Id < 255.");
                }
                if (mpx2a->LapicFlags & ACPI_MADT_ENABLED) {
                        ASSERT(*cntp < acpidev_cpu_map_count);
                        acpidev_cpu_map[*cntp].proc_id = mpx2a->Uid;
                        acpidev_cpu_map[*cntp].apic_id = mpx2a->LocalApicId;
                        (*cntp)++;
                }
                break;

        default:
                break;
        }

        return (AE_OK);
}

static ACPI_STATUS
acpidev_cpu_get_apicid(uint32_t procid, uint32_t *apicidp)
{
        uint32_t i;

        for (i = 0; i < acpidev_cpu_map_count; i++) {
                if (acpidev_cpu_map[i].proc_id == procid) {
                        *apicidp = acpidev_cpu_map[i].apic_id;
                        return (AE_OK);
                }
        }

        return (AE_NOT_FOUND);
}

/*
 * Extract information for enabled CPUs from the buffer returned
 * by the _MAT method.
 */
static ACPI_STATUS
acpidev_cpu_query_MAT(ACPI_SUBTABLE_HEADER *ap, void *context)
{
        ACPI_MADT_LOCAL_APIC *mpa;
        ACPI_MADT_LOCAL_X2APIC *mpx2a;
        struct acpidev_cpu_MAT_arg *rp;

        rp = (struct acpidev_cpu_MAT_arg *)context;
        switch (ap->Type) {
        case ACPI_MADT_TYPE_LOCAL_APIC:
                mpa = (ACPI_MADT_LOCAL_APIC *)ap;
                rp->found = B_TRUE;
                rp->proc_id = mpa->ProcessorId;
                rp->apic_id = mpa->Id;
                if (mpa->LapicFlags & ACPI_MADT_ENABLED) {
                        ASSERT(mpa->Id != 255);
                        rp->enabled = B_TRUE;
                } else {
                        rp->enabled = B_FALSE;
                }
                return (AE_CTRL_TERMINATE);

        case ACPI_MADT_TYPE_LOCAL_X2APIC:
                mpx2a = (ACPI_MADT_LOCAL_X2APIC *)ap;
                if (mpx2a->LocalApicId < 255) {
                        ACPIDEV_DEBUG(CE_WARN, "!acpidev: encountered CPU "
                            "with X2APIC Id < 255 in _MAT.");
                }
                rp->found = B_TRUE;
                rp->proc_id = mpx2a->Uid;
                rp->apic_id = mpx2a->LocalApicId;
                if (mpx2a->LapicFlags & ACPI_MADT_ENABLED) {
                        rp->enabled = B_TRUE;
                } else {
                        rp->enabled = B_FALSE;
                }
                return (AE_CTRL_TERMINATE);

        case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
                /* UNIMPLEMENTED */
                break;

        case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
                /* UNIMPLEMENTED */
                break;

        default:
                /*
                 * According to the ACPI Spec, the buffer returned by _MAT
                 * for a processor object should only contain Local APIC,
                 * Local SAPIC, and local APIC NMI entries.
                 * x2APIC Specification extends it to support Processor
                 * x2APIC and x2APIC NMI Structure.
                 */
                ACPIDEV_DEBUG(CE_NOTE,
                    "!acpidev: unknown APIC entry type %u in _MAT.", ap->Type);
                break;
        }

        return (AE_OK);
}

/*
 * Query ACPI processor ID by evaluating ACPI _MAT, _UID, and PROCESSOR
 * objects.
 */
static ACPI_STATUS
acpidev_cpu_get_procid(acpidev_walk_info_t *infop, uint32_t *idp)
{
        int id;
        ACPI_HANDLE hdl;
        struct acpidev_cpu_MAT_arg mat;

        if (infop->awi_info->Type != ACPI_TYPE_PROCESSOR &&
            infop->awi_info->Type != ACPI_TYPE_DEVICE) {
                ACPIDEV_DEBUG(CE_WARN,
                    "!acpidev: object %s is not PROCESSOR or DEVICE.",
                    infop->awi_name);
                return (AE_BAD_PARAMETER);
        }
        hdl = infop->awi_hdl;

        /*
         * First try to evaluate _MAT.
         * According to the ACPI Spec3.0b, it's legal for ACPI PROCESSOR objects
         * to have ACPI method objects.
         */
        bzero(&mat, sizeof (mat));
        (void) acpidev_walk_apic(NULL, hdl, ACPIDEV_METHOD_NAME_MAT,
            acpidev_cpu_query_MAT, &mat);
        if (mat.found) {
                *idp = mat.proc_id;
                return (AE_OK);
        }

        /* Then evalute PROCESSOR object. */
        if (infop->awi_info->Type == ACPI_TYPE_PROCESSOR) {
                ACPI_BUFFER rb;

                rb.Pointer = NULL;
                rb.Length = ACPI_ALLOCATE_BUFFER;
                if (ACPI_SUCCESS(AcpiEvaluateObjectTyped(hdl, NULL, NULL, &rb,
                    ACPI_TYPE_PROCESSOR))) {
                        *idp = ((ACPI_OBJECT *)rb.Pointer)->Processor.ProcId;
                        AcpiOsFree(rb.Pointer);
                        return (AE_OK);
                } else {
                        ACPIDEV_DEBUG(CE_WARN,
                            "!acpidev: failed to evaluate ACPI object %s.",
                            infop->awi_name);
                }
        }

        /*
         * Finally, try to evalute the _UID method.
         * According to the ACPI Spec3.0b, it's legal for ACPI PROCESSOR objects
         * to have ACPI method objects.
         * The CPU _UID method should return Processor Id as an integer on x86.
         */
        if (ACPI_SUCCESS(acpica_eval_int(hdl, METHOD_NAME__UID, &id))) {
                *idp = id;
                return (AE_OK);
        }

        return (AE_NOT_FOUND);
}

static ACPI_STATUS
acpidev_cpu_get_proximity_id(ACPI_HANDLE hdl, uint32_t apicid, uint32_t *pxmidp)
{
        int len, off;
        ACPI_SUBTABLE_HEADER *sp;
        ACPI_SRAT_CPU_AFFINITY *xp;
        ACPI_SRAT_X2APIC_CPU_AFFINITY *x2p;

        ASSERT(hdl != NULL);
        ASSERT(pxmidp != NULL);
        *pxmidp = UINT32_MAX;

        if (ACPI_SUCCESS(acpidev_eval_pxm(hdl, pxmidp))) {
                return (AE_OK);
        }
        if (acpidev_srat_tbl_ptr == NULL) {
                return (AE_NOT_FOUND);
        }

        /* Search the static ACPI SRAT table for proximity domain id. */
        sp = (ACPI_SUBTABLE_HEADER *)(acpidev_srat_tbl_ptr + 1);
        len = acpidev_srat_tbl_ptr->Header.Length;
        off = sizeof (*acpidev_srat_tbl_ptr);
        while (off < len) {
                switch (sp->Type) {
                case ACPI_SRAT_TYPE_CPU_AFFINITY:
                        xp = (ACPI_SRAT_CPU_AFFINITY *)sp;
                        if ((xp->Flags & ACPI_SRAT_CPU_ENABLED) &&
                            xp->ApicId == apicid) {
                                *pxmidp = xp->ProximityDomainLo;
                                *pxmidp |= xp->ProximityDomainHi[0] << 8;
                                *pxmidp |= xp->ProximityDomainHi[1] << 16;
                                *pxmidp |= xp->ProximityDomainHi[2] << 24;
                                return (AE_OK);
                        }
                        break;

                case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
                        x2p = (ACPI_SRAT_X2APIC_CPU_AFFINITY *)sp;
                        if ((x2p->Flags & ACPI_SRAT_CPU_ENABLED) &&
                            x2p->ApicId == apicid) {
                                *pxmidp = x2p->ProximityDomain;
                                return (AE_OK);
                        }
                        break;
                }
                off += sp->Length;
                sp = (ACPI_SUBTABLE_HEADER *)(((char *)sp) + sp->Length);
        }

        return (AE_NOT_FOUND);
}

static ACPI_STATUS
acpidev_cpu_pre_probe(acpidev_walk_info_t *infop)
{
        uint32_t count = 0;

        /* Parse and cache APIC info in MADT on the first probe at boot time. */
        ASSERT(infop != NULL);
        if (infop->awi_op_type == ACPIDEV_OP_BOOT_PROBE &&
            acpidev_cpu_map_hdl == NULL) {
                /* Parse CPU relative information in the ACPI MADT table. */
                (void) acpidev_walk_apic(NULL, NULL, NULL,
                    acpidev_cpu_count_MADT, &acpidev_cpu_map_count);
                acpidev_cpu_map = kmem_zalloc(sizeof (acpidev_cpu_map[0])
                    * acpidev_cpu_map_count, KM_SLEEP);
                (void) acpidev_walk_apic(NULL, NULL, NULL,
                    acpidev_cpu_parse_MADT, &count);
                ASSERT(count == acpidev_cpu_map_count);
                acpidev_cpu_map_hdl = infop->awi_hdl;

                /* Cache pointer to the ACPI SRAT table. */
                if (ACPI_FAILURE(AcpiGetTable(ACPI_SIG_SRAT, 1,
                    (ACPI_TABLE_HEADER **)&acpidev_srat_tbl_ptr))) {
                        acpidev_srat_tbl_ptr = NULL;
                }
        }

        return (AE_OK);
}

static ACPI_STATUS
acpidev_cpu_post_probe(acpidev_walk_info_t *infop)
{
        /* Free cached APIC info on the second probe at boot time. */
        ASSERT(infop != NULL);
        if (infop->awi_op_type == ACPIDEV_OP_BOOT_REPROBE &&
            acpidev_cpu_map_hdl != NULL &&
            infop->awi_hdl == acpidev_cpu_map_hdl) {
                if (acpidev_cpu_map != NULL && acpidev_cpu_map_count != 0) {
                        kmem_free(acpidev_cpu_map, sizeof (acpidev_cpu_map[0])
                            * acpidev_cpu_map_count);
                }
                acpidev_cpu_map = NULL;
                acpidev_cpu_map_count = 0;
                acpidev_cpu_map_hdl = NULL;

                /* replace psm_cpu_create_devinfo with local implementation. */
                psm_cpu_create_devinfo_old = psm_cpu_create_devinfo;
                psm_cpu_create_devinfo = acpidev_cpu_create_dip;
                psm_cpu_get_devinfo_old = psm_cpu_get_devinfo;
                psm_cpu_get_devinfo = acpidev_cpu_get_dip;
        }

        return (AE_OK);
}

static ACPI_STATUS
acpidev_cpu_probe(acpidev_walk_info_t *infop)
{
        ACPI_STATUS rc = AE_OK;
        int flags;

        ASSERT(infop != NULL);
        ASSERT(infop->awi_hdl != NULL);
        ASSERT(infop->awi_info != NULL);
        ASSERT(infop->awi_class_curr == &acpidev_class_cpu);
        if (infop->awi_info->Type != ACPI_TYPE_PROCESSOR &&
            (infop->awi_info->Type != ACPI_TYPE_DEVICE ||
            acpidev_match_device_id(infop->awi_info,
            ACPIDEV_ARRAY_PARAM(acpidev_processor_device_ids)) == 0)) {
                return (AE_OK);
        }

        flags = ACPIDEV_PROCESS_FLAG_SCAN;
        switch (infop->awi_op_type) {
        case  ACPIDEV_OP_BOOT_PROBE:
                /*
                 * Mark device as offline. It will be changed to online state
                 * when the corresponding CPU starts up.
                 */
                if (acpica_get_devcfg_feature(ACPI_DEVCFG_CPU)) {
                        flags |= ACPIDEV_PROCESS_FLAG_CREATE |
                            ACPIDEV_PROCESS_FLAG_OFFLINE;
                }
                break;

        case ACPIDEV_OP_BOOT_REPROBE:
                break;

        case ACPIDEV_OP_HOTPLUG_PROBE:
                if (acpica_get_devcfg_feature(ACPI_DEVCFG_CPU)) {
                        flags |= ACPIDEV_PROCESS_FLAG_CREATE |
                            ACPIDEV_PROCESS_FLAG_OFFLINE |
                            ACPIDEV_PROCESS_FLAG_SYNCSTATUS |
                            ACPIDEV_PROCESS_FLAG_HOLDBRANCH;
                }
                break;

        default:
                ACPIDEV_DEBUG(CE_WARN, "!acpidev: unknown operation type %u in "
                    "acpidev_cpu_probe().", infop->awi_op_type);
                rc = AE_BAD_PARAMETER;
                break;
        }

        if (rc == AE_OK) {
                rc = acpidev_process_object(infop, flags);
        }
        if (ACPI_FAILURE(rc) && rc != AE_NOT_EXIST && rc != AE_ALREADY_EXISTS) {
                cmn_err(CE_WARN,
                    "!acpidev: failed to process processor object %s.",
                    infop->awi_name);
        } else {
                rc = AE_OK;
        }

        return (rc);
}

static acpidev_filter_result_t
acpidev_cpu_filter_func(acpidev_walk_info_t *infop, ACPI_HANDLE hdl,
    acpidev_filter_rule_t *afrp, char *devname, int len)
{
        acpidev_filter_result_t res;

        ASSERT(afrp != NULL);
        if (infop->awi_op_type == ACPIDEV_OP_BOOT_PROBE ||
            infop->awi_op_type == ACPIDEV_OP_BOOT_REPROBE) {
                uint32_t procid;
                uint32_t apicid;

                if (acpidev_cpu_get_procid(infop, &procid) != 0) {
                        ACPIDEV_DEBUG(CE_WARN,
                            "!acpidev: failed to query processor id for %s.",
                            infop->awi_name);
                        return (ACPIDEV_FILTER_SKIP);
                } else if (acpidev_cpu_get_apicid(procid, &apicid) != 0) {
                        ACPIDEV_DEBUG(CE_WARN,
                            "!acpidev: failed to query apic id for %s.",
                            infop->awi_name);
                        return (ACPIDEV_FILTER_SKIP);
                }

                infop->awi_scratchpad[0] = procid;
                infop->awi_scratchpad[1] = apicid;
        } else if (infop->awi_op_type == ACPIDEV_OP_HOTPLUG_PROBE) {
                struct acpidev_cpu_MAT_arg mat;

                bzero(&mat, sizeof (mat));
                (void) acpidev_walk_apic(NULL, hdl, ACPIDEV_METHOD_NAME_MAT,
                    acpidev_cpu_query_MAT, &mat);
                if (!mat.found) {
                        cmn_err(CE_WARN,
                            "!acpidev: failed to walk apic resource for %s.",
                            infop->awi_name);
                        return (ACPIDEV_FILTER_SKIP);
                } else if (!mat.enabled) {
                        ACPIDEV_DEBUG(CE_NOTE,
                            "!acpidev: CPU %s has been disabled.",
                            infop->awi_name);
                        return (ACPIDEV_FILTER_SKIP);
                }
                /* Save processor id and APIC id in scratchpad memory. */
                infop->awi_scratchpad[0] = mat.proc_id;
                infop->awi_scratchpad[1] = mat.apic_id;
        }

        res = acpidev_filter_default(infop, hdl, afrp, devname, len);

        return (res);
}

static acpidev_filter_result_t
acpidev_cpu_filter(acpidev_walk_info_t *infop, char *devname, int maxlen)
{
        acpidev_filter_result_t res;

        ASSERT(infop != NULL);
        ASSERT(devname == NULL || maxlen >= ACPIDEV_MAX_NAMELEN);
        if (infop->awi_op_type == ACPIDEV_OP_BOOT_PROBE ||
            infop->awi_op_type == ACPIDEV_OP_BOOT_REPROBE ||
            infop->awi_op_type == ACPIDEV_OP_HOTPLUG_PROBE) {
                res = acpidev_filter_device(infop, infop->awi_hdl,
                    ACPIDEV_ARRAY_PARAM(acpidev_cpu_filters), devname, maxlen);
        } else {
                res = ACPIDEV_FILTER_FAILED;
        }

        return (res);
}

static ACPI_STATUS
acpidev_cpu_init(acpidev_walk_info_t *infop)
{
        int count;
        uint32_t pxmid;
        dev_info_t *dip;
        ACPI_HANDLE hdl;
        char unitaddr[64];
        char **compatpp;
        static char *compatible[] = {
                ACPIDEV_HID_PROCESSOR,
                ACPIDEV_TYPE_CPU,
                "cpu"
        };

        ASSERT(infop != NULL);
        dip = infop->awi_dip;
        hdl = infop->awi_hdl;

        /* Create "apic_id", "processor_id" and "proximity_id" properties. */
        if (ndi_prop_update_int(DDI_DEV_T_NONE, dip,
            ACPIDEV_PROP_NAME_PROCESSOR_ID, infop->awi_scratchpad[0]) !=
            NDI_SUCCESS) {
                cmn_err(CE_WARN,
                    "!acpidev: failed to set processor_id property for %s.",
                    infop->awi_name);
                return (AE_ERROR);
        }
        if (ndi_prop_update_int(DDI_DEV_T_NONE, dip,
            ACPIDEV_PROP_NAME_LOCALAPIC_ID, infop->awi_scratchpad[1]) !=
            NDI_SUCCESS) {
                cmn_err(CE_WARN,
                    "!acpidev: failed to set apic_id property for %s.",
                    infop->awi_name);
                return (AE_ERROR);
        }
        if (ACPI_SUCCESS(acpidev_cpu_get_proximity_id(infop->awi_hdl,
            infop->awi_scratchpad[1], &pxmid))) {
                if (ndi_prop_update_int(DDI_DEV_T_NONE, dip,
                    ACPIDEV_PROP_NAME_PROXIMITY_ID, pxmid) != NDI_SUCCESS) {
                        cmn_err(CE_WARN, "!acpidev: failed to set proximity id "
                            "property for %s.", infop->awi_name);
                        return (AE_ERROR);
                }
        }

        /* Set "compatible" property for CPU dip */
        count = sizeof (compatible) / sizeof (compatible[0]);
        if (infop->awi_info->Type == ACPI_TYPE_PROCESSOR) {
                compatpp = compatible;
        } else if (infop->awi_info->Type == ACPI_TYPE_DEVICE) {
                /*
                 * skip first item for pseudo processor HID.
                 * acpidev_set_compatible() will handle HID/CID for CPU device.
                 */
                compatpp = &compatible[1];
                count--;
        } else {
                return (AE_BAD_PARAMETER);
        }
        if (ACPI_FAILURE(acpidev_set_compatible(infop, compatpp, count))) {
                return (AE_ERROR);
        }

        /*
         * Set device unit-address property.
         * First try to generate meaningful unit address from _UID,
         * then use Processor Id if that fails.
         */
        if ((infop->awi_info->Valid & ACPI_VALID_UID) == 0 ||
            acpidev_generate_unitaddr(infop->awi_info->UniqueId.String,
            ACPIDEV_ARRAY_PARAM(acpidev_cpu_uid_formats),
            unitaddr, sizeof (unitaddr)) == NULL) {
                (void) snprintf(unitaddr, sizeof (unitaddr), "%u",
                    (uint32_t)infop->awi_scratchpad[0]);
        }
        if (ACPI_FAILURE(acpidev_set_unitaddr(infop, NULL, 0, unitaddr))) {
                return (AE_ERROR);
        }

        /*
         * Build binding information for CPUs.
         */
        if (infop->awi_op_type == ACPIDEV_OP_BOOT_PROBE ||
            infop->awi_op_type == ACPIDEV_OP_BOOT_REPROBE ||
            infop->awi_op_type == ACPIDEV_OP_HOTPLUG_PROBE) {
                if (ACPI_FAILURE(acpica_add_processor_to_map(
                    infop->awi_scratchpad[0], hdl, infop->awi_scratchpad[1]))) {
                        cmn_err(CE_WARN, "!acpidev: failed to bind processor "
                            "id/object handle for %s.", infop->awi_name);
                        return (AE_ERROR);
                }
        } else {
                ACPIDEV_DEBUG(CE_WARN,
                    "!acpidev: unknown operation type %u in acpidev_cpu_init.",
                    infop->awi_op_type);
                return (AE_BAD_PARAMETER);
        }

        return (AE_OK);
}

static void
acpidev_cpu_fini(ACPI_HANDLE hdl, acpidev_data_handle_t dhdl,
    acpidev_class_t *clsp)
{
        _NOTE(ARGUNUSED(clsp, dhdl));

        int rc;
        uint32_t procid;

        rc = acpica_get_procid_by_object(hdl, &procid);
        ASSERT(ACPI_SUCCESS(rc));
        if (ACPI_SUCCESS(rc)) {
                rc = acpica_remove_processor_from_map(procid);
                ASSERT(ACPI_SUCCESS(rc));
                if (ACPI_FAILURE(rc)) {
                        cmn_err(CE_WARN, "!acpidev: failed to remove "
                            "processor from ACPICA.");
                }
        }
}

/*
 * Lookup the dip for a CPU if ACPI CPU autoconfig is enabled.
 */
static int
acpidev_cpu_lookup_dip(cpu_t *cp, dev_info_t **dipp)
{
        uint32_t apicid;
        ACPI_HANDLE hdl;
        dev_info_t *dip = NULL;

        *dipp = NULL;
        if (acpica_get_devcfg_feature(ACPI_DEVCFG_CPU)) {
                apicid = cpuid_get_apicid(cp);
                if (acpica_get_cpu_object_by_cpuid(cp->cpu_id, &hdl) == 0 ||
                    (apicid != UINT32_MAX &&
                    acpica_get_cpu_object_by_apicid(apicid, &hdl) == 0)) {
                        ASSERT(hdl != NULL);
                        if (ACPI_SUCCESS(acpica_get_devinfo(hdl, &dip))) {
                                ASSERT(dip != NULL);
                                *dipp = dip;
                                return (PSM_SUCCESS);
                        }
                }
                ACPIDEV_DEBUG(CE_WARN,
                    "!acpidev: failed to lookup dip for cpu %d(%p).",
                    cp->cpu_id, (void *)cp);
        }

        return (PSM_FAILURE);
}

static int
acpidev_cpu_create_dip(cpu_t *cp, dev_info_t **dipp)
{
        if (acpidev_cpu_lookup_dip(cp, dipp) == PSM_SUCCESS) {
                ndi_hold_devi(*dipp);
                return (PSM_SUCCESS);
        }
        if (psm_cpu_create_devinfo_old != NULL) {
                return (psm_cpu_create_devinfo_old(cp, dipp));
        } else {
                return (PSM_FAILURE);
        }
}

static int
acpidev_cpu_get_dip(cpu_t *cp, dev_info_t **dipp)
{
        if (acpidev_cpu_lookup_dip(cp, dipp) == PSM_SUCCESS) {
                return (PSM_SUCCESS);
        }
        if (psm_cpu_get_devinfo_old != NULL) {
                return (psm_cpu_get_devinfo_old(cp, dipp));
        } else {
                return (PSM_FAILURE);
        }
}