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

#include <sys/types.h>
#include <sys/atomic.h>
#include <sys/bitmap.h>
#include <sys/cmn_err.h>
#include <sys/note.h>
#include <sys/sunndi.h>
#include <sys/fastboot_impl.h>
#include <sys/sysevent.h>
#include <sys/sysevent/dr.h>
#include <sys/sysevent/eventdefs.h>
#include <sys/acpi/acpi.h>
#include <sys/acpica.h>
#include <sys/acpidev.h>
#include <sys/acpidev_dr.h>
#include <sys/acpinex.h>

int acpinex_event_support_remove = 0;

static volatile uint_t acpinex_dr_event_cnt = 0;
static ulong_t acpinex_object_type_mask[BT_BITOUL(ACPI_TYPE_NS_NODE_MAX + 1)];

/*
 * Generate DR_REQ event to syseventd.
 * Please refer to sys/sysevent/dr.h for message definition.
 */
static int
acpinex_event_generate_event(dev_info_t *dip, ACPI_HANDLE hdl, int req,
    int event, char *objname)
{
        int rv = 0;
        sysevent_id_t eid;
        sysevent_value_t evnt_val;
        sysevent_attr_list_t *evnt_attr_list = NULL;
        char *attach_pnt;
        char event_type[32];

        /* Add "attachment point" attribute. */
        attach_pnt = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
        if (ACPI_FAILURE(acpidev_dr_get_attachment_point(hdl,
            attach_pnt, MAXPATHLEN))) {
                cmn_err(CE_WARN,
                    "!acpinex: failed to generate AP name for %s.", objname);
                kmem_free(attach_pnt, MAXPATHLEN);
                return (-1);
        }
        ASSERT(attach_pnt[0] != '\0');
        evnt_val.value_type = SE_DATA_TYPE_STRING;
        evnt_val.value.sv_string = attach_pnt;
        rv = sysevent_add_attr(&evnt_attr_list, DR_AP_ID, &evnt_val, KM_SLEEP);
        if (rv != 0) {
                cmn_err(CE_WARN,
                    "!acpinex: failed to add attr [%s] for %s event.",
                    DR_AP_ID, EC_DR);
                kmem_free(attach_pnt, MAXPATHLEN);
                return (rv);
        }

        /* Add "request type" attribute. */
        evnt_val.value_type = SE_DATA_TYPE_STRING;
        evnt_val.value.sv_string = SE_REQ2STR(req);
        rv = sysevent_add_attr(&evnt_attr_list, DR_REQ_TYPE, &evnt_val,
            KM_SLEEP);
        if (rv != 0) {
                cmn_err(CE_WARN,
                    "!acpinex: failed to add attr [%s] for %s event.",
                    DR_REQ_TYPE, EC_DR);
                sysevent_free_attr(evnt_attr_list);
                kmem_free(attach_pnt, MAXPATHLEN);
                return (rv);
        }

        /* Add "acpi-event-type" attribute. */
        switch (event) {
        case ACPI_NOTIFY_BUS_CHECK:
                (void) snprintf(event_type, sizeof (event_type),
                    ACPIDEV_EVENT_TYPE_BUS_CHECK);
                break;
        case ACPI_NOTIFY_DEVICE_CHECK:
                (void) snprintf(event_type, sizeof (event_type),
                    ACPIDEV_EVENT_TYPE_DEVICE_CHECK);
                break;
        case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
                (void) snprintf(event_type, sizeof (event_type),
                    ACPIDEV_EVENT_TYPE_DEVICE_CHECK_LIGHT);
                break;
        case ACPI_NOTIFY_EJECT_REQUEST:
                (void) snprintf(event_type, sizeof (event_type),
                    ACPIDEV_EVENT_TYPE_EJECT_REQUEST);
                break;
        default:
                cmn_err(CE_WARN,
                    "!acpinex: unknown ACPI event type %d.", event);
                sysevent_free_attr(evnt_attr_list);
                kmem_free(attach_pnt, MAXPATHLEN);
                return (-1);
        }
        evnt_val.value_type = SE_DATA_TYPE_STRING;
        evnt_val.value.sv_string = event_type;
        rv = sysevent_add_attr(&evnt_attr_list, ACPIDEV_EVENT_TYPE_ATTR_NAME,
            &evnt_val, KM_SLEEP);
        if (rv != 0) {
                cmn_err(CE_WARN,
                    "!acpinex: failed to add attr [%s] for %s event.",
                    ACPIDEV_EVENT_TYPE_ATTR_NAME, EC_DR);
                sysevent_free_attr(evnt_attr_list);
                kmem_free(attach_pnt, MAXPATHLEN);
                return (rv);
        }

        rv = ddi_log_sysevent(dip, DDI_VENDOR_SUNW, EC_DR, ESC_DR_REQ,
            evnt_attr_list, &eid, KM_SLEEP);
        if (rv != DDI_SUCCESS) {
                cmn_err(CE_WARN,
                    "!acpinex: failed to log DR_REQ event for %s.", objname);
                rv = -1;
        }

        nvlist_free(evnt_attr_list);
        kmem_free(attach_pnt, MAXPATHLEN);

        return (rv);
}

/*
 * Event handler for ACPI EJECT_REQUEST notifications.
 * EJECT_REQUEST notifications should be generated on the device to be ejected,
 * so no need to scan subtree of it.
 * It also invokes ACPI _OST method to update event status if call_ost is true.
 */
static void
acpinex_event_handle_eject_request(ACPI_HANDLE hdl, acpinex_softstate_t *sp,
    boolean_t call_ost)
{
        int code;
        char *objname;

        ASSERT(hdl != NULL);
        objname = acpidev_get_object_name(hdl);

        ASSERT(sp != NULL);
        ASSERT(sp->ans_dip != NULL && sp->ans_hdl != NULL);
        if (sp == NULL || sp->ans_dip == NULL || sp->ans_hdl == NULL) {
                if (call_ost) {
                        (void) acpidev_eval_ost(hdl, ACPI_NOTIFY_EJECT_REQUEST,
                            ACPI_OST_STA_FAILURE, NULL, 0);
                }
                ACPINEX_DEBUG(CE_WARN,
                    "!acpinex: softstate data structure is invalid.");
                cmn_err(CE_WARN,
                    "!acpinex: failed to handle EJECT_REQUEST event from %s.",
                    objname);
                acpidev_free_object_name(objname);
                return;
        }

        if (acpinex_event_support_remove == 0) {
                cmn_err(CE_WARN,
                    "!acpinex: hot-removing of device %s is unsupported.",
                    objname);
                code = ACPI_OST_STA_EJECT_NOT_SUPPORT;
        } else if (acpinex_event_generate_event(sp->ans_dip, hdl,
            SE_OUTGOING_RES, ACPI_NOTIFY_EJECT_REQUEST, objname) != 0) {
                cmn_err(CE_WARN, "!acpinex: failed to generate ESC_DR_REQ "
                    "event for device eject request from %s.", objname);
                code = ACPI_OST_STA_FAILURE;
        } else {
                cmn_err(CE_NOTE, "!acpinex: generate ESC_DR_REQ event for "
                    "device eject request from %s.", objname);
                code = ACPI_OST_STA_EJECT_IN_PROGRESS;
        }
        if (call_ost) {
                (void) acpidev_eval_ost(hdl, ACPI_NOTIFY_EJECT_REQUEST,
                    code, NULL, 0);
        }

        acpidev_free_object_name(objname);
}

struct acpinex_event_check_arg {
        acpinex_softstate_t     *softstatep;
        int                     event_type;
        uint32_t                device_insert;
        uint32_t                device_remove;
        uint32_t                device_fail;
};

static ACPI_STATUS
acpinex_event_handle_check_one(ACPI_HANDLE hdl, UINT32 lvl, void *ctx,
    void **retval)
{
        _NOTE(ARGUNUSED(lvl, retval));

        char *objname;
        int status, psta, csta;
        acpidev_data_handle_t dhdl;
        struct acpinex_event_check_arg *argp;

        ASSERT(hdl != NULL);
        ASSERT(ctx != NULL);
        argp = (struct acpinex_event_check_arg *)ctx;

        dhdl = acpidev_data_get_handle(hdl);
        if (dhdl == NULL) {
                /* Skip subtree if failed to get the data handle. */
                ACPINEX_DEBUG(CE_NOTE,
                    "!acpinex: failed to get data associated with %p.", hdl);
                return (AE_CTRL_DEPTH);
        } else if (!acpidev_data_dr_capable(dhdl)) {
                return (AE_OK);
        }

        objname = acpidev_get_object_name(hdl);

        status = 0;
        /* Query previous device status. */
        psta = acpidev_data_get_status(dhdl);
        if (acpidev_check_device_enabled(psta)) {
                status |= 0x1;
        }
        /* Query current device status. */
        csta = acpidev_query_device_status(hdl);
        if (acpidev_check_device_enabled(csta)) {
                status |= 0x2;
        }

        switch (status) {
        case 0x0:
                /*FALLTHROUGH*/
        case 0x3:
                /* No status changes, keep on walking. */
                acpidev_free_object_name(objname);
                return (AE_OK);

        case 0x1:
                /* Surprising removal. */
                cmn_err(CE_WARN,
                    "!acpinex: device %s has been surprisingly removed.",
                    objname);
                if (argp->event_type == ACPI_NOTIFY_BUS_CHECK) {
                        /*
                         * According to ACPI spec, BUS_CHECK notification
                         * should be triggered for hot-adding events only.
                         */
                        ACPINEX_DEBUG(CE_WARN,
                            "!acpinex: device %s has been surprisingly removed "
                            "when handling BUS_CHECK event.", objname);
                }
                acpidev_free_object_name(objname);
                argp->device_remove++;
                return (AE_CTRL_DEPTH);

        case 0x2:
                /* Hot-adding. */
                ACPINEX_DEBUG(CE_NOTE,
                    "!acpinex: device %s has been inserted.", objname);
                argp->device_insert++;
                if (acpinex_event_generate_event(argp->softstatep->ans_dip, hdl,
                    SE_INCOMING_RES, argp->event_type, objname) != 0) {
                        cmn_err(CE_WARN,
                            "!acpinex: failed to generate ESC_DR_REQ event for "
                            "device insert request from %s.", objname);
                        argp->device_fail++;
                } else {
                        cmn_err(CE_NOTE, "!acpinex: generate ESC_DR_REQ event "
                            "for device insert request from %s.", objname);
                }
                acpidev_free_object_name(objname);
                return (AE_OK);

        default:
                ASSERT(0);
                break;
        }

        return (AE_ERROR);
}

/*
 * Event handler for BUS_CHECK/DEVICE_CHECK/DEVICE_CHECK_LIGHT notifications.
 * These events may be signaled on parent/ancestor of devices to be hot-added,
 * so need to scan ACPI namespace to figure out devices in question.
 * It also invokes ACPI _OST method to update event status if call_ost is true.
 */
static void
acpinex_event_handle_check_request(int event, ACPI_HANDLE hdl,
    acpinex_softstate_t *sp, boolean_t call_ost)
{
        ACPI_STATUS rv;
        int code;
        char *objname;
        struct acpinex_event_check_arg arg;

        ASSERT(hdl != NULL);
        objname = acpidev_get_object_name(hdl);

        ASSERT(sp != NULL);
        ASSERT(sp->ans_dip != NULL && sp->ans_hdl != NULL);
        if (sp == NULL || sp->ans_dip == NULL || sp->ans_hdl == NULL) {
                if (call_ost) {
                        (void) acpidev_eval_ost(hdl, event,
                            ACPI_OST_STA_FAILURE, NULL, 0);
                }
                ACPINEX_DEBUG(CE_WARN,
                    "!acpinex: softstate data structure is invalid.");
                cmn_err(CE_WARN, "!acpinex: failed to handle "
                    "BUS/DEVICE_CHECK event from %s.", objname);
                acpidev_free_object_name(objname);
                return;
        }

        bzero(&arg, sizeof (arg));
        arg.event_type = event;
        arg.softstatep = sp;
        rv = acpinex_event_handle_check_one(hdl, 0, &arg, NULL);
        if (ACPI_SUCCESS(rv)) {
                rv = AcpiWalkNamespace(ACPI_TYPE_DEVICE, hdl,
                    ACPIDEV_MAX_ENUM_LEVELS,
                    &acpinex_event_handle_check_one, NULL, &arg, NULL);
        }

        if (ACPI_FAILURE(rv)) {
                /* Failed to scan the ACPI namespace. */
                cmn_err(CE_WARN, "!acpinex: failed to handle event %d from %s.",
                    event, objname);
                code = ACPI_OST_STA_FAILURE;
        } else if (arg.device_remove != 0) {
                /* Surprising removal happened. */
                ACPINEX_DEBUG(CE_WARN,
                    "!acpinex: some devices have been surprisingly removed.");
                code = ACPI_OST_STA_NOT_SUPPORT;
        } else if (arg.device_fail != 0) {
                /* Failed to handle some devices. */
                ACPINEX_DEBUG(CE_WARN,
                    "!acpinex: failed to check status of some devices.");
                code = ACPI_OST_STA_FAILURE;
        } else if (arg.device_insert == 0) {
                /* No hot-added devices found. */
                cmn_err(CE_WARN,
                    "!acpinex: no hot-added devices under %s found.", objname);
                code = ACPI_OST_STA_FAILURE;
        } else {
                code = ACPI_OST_STA_INSERT_IN_PROGRESS;
        }
        if (call_ost) {
                (void) acpidev_eval_ost(hdl, event, code, NULL, 0);
        }

        acpidev_free_object_name(objname);
}

static void
acpinex_event_system_handler(ACPI_HANDLE hdl, UINT32 type, void *arg)
{
        acpinex_softstate_t *sp;

        ASSERT(hdl != NULL);
        ASSERT(arg != NULL);
        sp = (acpinex_softstate_t *)arg;

        acpidev_dr_lock_all();
        mutex_enter(&sp->ans_lock);

        switch (type) {
        case ACPI_NOTIFY_BUS_CHECK:
                /*
                 * Bus Check. This notification is performed on a device object
                 * to indicate to OSPM that it needs to perform the Plug and
                 * Play re-enumeration operation on the device tree starting
                 * from the point where it has been notified. OSPM will only
                 * perform this operation at boot, and when notified. It is
                 * the responsibility of the ACPI AML code to notify OSPM at
                 * any other times that this operation is required. The more
                 * accurately and closer to the actual device tree change the
                 * notification can be done, the more efficient the operating
                 * system response will be; however, it can also be an issue
                 * when a device change cannot be confirmed. For example, if
                 * the hardware cannot notice a device change for a particular
                 * location during a system sleeping state, it issues a Bus
                 * Check notification on wake to inform OSPM that it needs to
                 * check the configuration for a device change.
                 */
                /*FALLTHROUGH*/
        case ACPI_NOTIFY_DEVICE_CHECK:
                /*
                 * Device Check. Used to notify OSPM that the device either
                 * appeared or disappeared. If the device has appeared, OSPM
                 * will re-enumerate from the parent. If the device has
                 * disappeared, OSPM will invalidate the state of the device.
                 * OSPM may optimize out re-enumeration. If _DCK is present,
                 * then Notify(object,1) is assumed to indicate an undock
                 * request.
                 */
                /*FALLTHROUGH*/
        case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
                /*
                 * Device Check Light. Used to notify OSPM that the device
                 * either appeared or disappeared. If the device has appeared,
                 * OSPM will re-enumerate from the device itself, not the
                 * parent. If the device has disappeared, OSPM will invalidate
                 * the state of the device.
                 */
                atomic_inc_uint(&acpinex_dr_event_cnt);
                acpinex_event_handle_check_request(type, hdl, sp, B_TRUE);
                break;

        case ACPI_NOTIFY_EJECT_REQUEST:
                /*
                 * Eject Request. Used to notify OSPM that the device should
                 * be ejected, and that OSPM needs to perform the Plug and Play
                 * ejection operation. OSPM will run the _EJx method.
                 */
                atomic_inc_uint(&acpinex_dr_event_cnt);
                acpinex_event_handle_eject_request(hdl, sp, B_TRUE);
                break;

        default:
                ACPINEX_DEBUG(CE_NOTE,
                    "!acpinex: unhandled event(%d) on hdl %p under %s.",
                    type, hdl, sp->ans_path);
                (void) acpidev_eval_ost(hdl, type, ACPI_OST_STA_NOT_SUPPORT,
                    NULL, 0);
                break;
        }

        if (acpinex_dr_event_cnt != 0) {
                /*
                 * Disable fast reboot if a CPU/MEM/IOH hotplug event happens.
                 * Note: this is a temporary solution and will be revised when
                 * fast reboot can support CPU/MEM/IOH DR operations in the
                 * future.
                 *
                 * ACPI BIOS generates some static ACPI tables, such as MADT,
                 * SRAT and SLIT, to describe the system hardware configuration
                 * on power-on. When a CPU/MEM/IOH hotplug event happens, those
                 * static tables won't be updated and will become stale.
                 *
                 * If we reset the system by fast reboot, BIOS will have no
                 * chance to regenerate those staled static tables. Fast reboot
                 * can't tolerate such inconsistency between staled ACPI tables
                 * and real hardware configuration yet.
                 *
                 * A temporary solution is introduced to disable fast reboot if
                 * CPU/MEM/IOH hotplug event happens. This solution should be
                 * revised when fast reboot is enhanced to support CPU/MEM/IOH
                 * DR operations.
                 */
                fastreboot_disable(FBNS_HOTPLUG);
        }

        mutex_exit(&sp->ans_lock);
        acpidev_dr_unlock_all();
}

/*
 * Install event handler for ACPI system events.
 * Acpinex driver handles ACPI system events for its children,
 * device specific events will be handled by device drivers.
 * Return DDI_SUCCESS on success, and DDI_FAILURE on failure.
 */
static int
acpinex_event_install_handler(ACPI_HANDLE hdl, void *arg,
    ACPI_DEVICE_INFO *infop, acpidev_data_handle_t dhdl)
{
        ACPI_STATUS status;
        int rc = DDI_SUCCESS;

        ASSERT(hdl != NULL);
        ASSERT(dhdl != NULL);
        ASSERT(infop != NULL);

        /*
         * Check whether the event handler has already been installed on the
         * device object. With the introduction of ACPI Alias objects, which are
         * similar to symlinks in file systems, there may be multiple name
         * objects in the ACPI namespace pointing to the same underlying device
         * object. Those Alias objects need to be filtered out, otherwise
         * it will attempt to install the event handler multiple times on the
         * same device object which will fail.
         */
        if (acpidev_data_get_flag(dhdl, ACPIDEV_DATA_HANDLER_READY)) {
                return (DDI_SUCCESS);
        }
        status = AcpiInstallNotifyHandler(hdl, ACPI_SYSTEM_NOTIFY,
            acpinex_event_system_handler, arg);
        if (status == AE_OK || status == AE_ALREADY_EXISTS) {
                acpidev_data_set_flag(dhdl, ACPIDEV_DATA_HANDLER_READY);
        } else {
                char *objname;

                objname = acpidev_get_object_name(hdl);
                cmn_err(CE_WARN,
                    "!acpinex: failed to install system event handler for %s.",
                    objname);
                acpidev_free_object_name(objname);
                rc = DDI_FAILURE;
        }

        return (rc);
}

/*
 * Uninstall event handler for ACPI system events.
 * Return DDI_SUCCESS on success, and DDI_FAILURE on failure.
 */
static int
acpinex_event_uninstall_handler(ACPI_HANDLE hdl, ACPI_DEVICE_INFO *infop,
    acpidev_data_handle_t dhdl)
{
        ASSERT(hdl != NULL);
        ASSERT(dhdl != NULL);
        ASSERT(infop != NULL);

        if (!acpidev_data_get_flag(dhdl, ACPIDEV_DATA_HANDLER_READY)) {
                return (DDI_SUCCESS);
        }
        if (ACPI_SUCCESS(AcpiRemoveNotifyHandler(hdl, ACPI_SYSTEM_NOTIFY,
            acpinex_event_system_handler))) {
                acpidev_data_clear_flag(dhdl, ACPIDEV_DATA_HANDLER_READY);
        } else {
                char *objname;

                objname = acpidev_get_object_name(hdl);
                cmn_err(CE_WARN, "!acpinex: failed to uninstall system event "
                    "handler for %s.", objname);
                acpidev_free_object_name(objname);
                return (DDI_FAILURE);
        }

        return (DDI_SUCCESS);
}

/*
 * Install/uninstall ACPI system event handler for child objects of hdl.
 * Return DDI_SUCCESS on success, and DDI_FAILURE on failure.
 */
static int
acpinex_event_walk(boolean_t init, acpinex_softstate_t *sp, ACPI_HANDLE hdl)
{
        int rc;
        int retval = DDI_SUCCESS;
        dev_info_t *dip;
        ACPI_HANDLE child = NULL;
        ACPI_OBJECT_TYPE type;
        ACPI_DEVICE_INFO *infop;
        acpidev_data_handle_t dhdl;

        /* Walk all child objects. */
        ASSERT(hdl != NULL);
        while (ACPI_SUCCESS(AcpiGetNextObject(ACPI_TYPE_ANY, hdl, child,
            &child))) {
                /* Skip unwanted object types. */
                if (ACPI_FAILURE(AcpiGetType(child, &type)) ||
                    type > ACPI_TYPE_NS_NODE_MAX ||
                    BT_TEST(acpinex_object_type_mask, type) == 0) {
                        continue;
                }

                /* Get data associated with the object. Skip it if fails. */
                dhdl = acpidev_data_get_handle(child);
                if (dhdl == NULL) {
                        ACPINEX_DEBUG(CE_NOTE, "!acpinex: failed to get data "
                            "associated with %p, skip.", child);
                        continue;
                }

                /* Query ACPI object info for the object. */
                if (ACPI_FAILURE(AcpiGetObjectInfo(child, &infop))) {
                        cmn_err(CE_WARN,
                            "!acpidnex: failed to get object info for %p.",
                            child);
                        continue;
                }

                if (init) {
                        rc = acpinex_event_install_handler(child, sp, infop,
                            dhdl);
                        if (rc != DDI_SUCCESS) {
                                ACPINEX_DEBUG(CE_WARN, "!acpinex: failed to "
                                    "install handler for child %p of %s.",
                                    child, sp->ans_path);
                                retval = DDI_FAILURE;
                        /*
                         * Try to handle descendants if both of the
                         * following two conditions are true:
                         * 1) Device corresponding to the current object is
                         *    enabled. If the device is absent/disabled,
                         *    no notification should be generated from
                         *    descendant objects of it.
                         * 2) No Solaris device node has been created for the
                         *    current object yet. If the device node has been
                         *    created for the current object, notification
                         *    events from child objects should be handled by
                         *    the corresponding driver.
                         */
                        } else if (acpidev_check_device_enabled(
                            acpidev_data_get_status(dhdl)) &&
                            ACPI_FAILURE(acpica_get_devinfo(child, &dip))) {
                                rc = acpinex_event_walk(B_TRUE, sp, child);
                                if (rc != DDI_SUCCESS) {
                                        ACPINEX_DEBUG(CE_WARN,
                                            "!acpinex: failed to install "
                                            "handler for descendants of %s.",
                                            sp->ans_path);
                                        retval = DDI_FAILURE;
                                }
                        }
                } else {
                        rc = DDI_SUCCESS;
                        /* Uninstall handler for descendants if needed. */
                        if (ACPI_FAILURE(acpica_get_devinfo(child, &dip))) {
                                rc = acpinex_event_walk(B_FALSE, sp, child);
                        }
                        if (rc == DDI_SUCCESS) {
                                rc = acpinex_event_uninstall_handler(child,
                                    infop, dhdl);
                        }
                        /* Undo will be done by caller in case of failure. */
                        if (rc != DDI_SUCCESS) {
                                ACPINEX_DEBUG(CE_WARN, "!acpinex: failed to "
                                    "uninstall handler for descendants of %s.",
                                    sp->ans_path);
                                AcpiOsFree(infop);
                                retval = DDI_FAILURE;
                                break;
                        }
                }

                /* Release cached resources. */
                AcpiOsFree(infop);
        }

        return (retval);
}

int
acpinex_event_scan(acpinex_softstate_t *sp, boolean_t init)
{
        int rc;

        ASSERT(sp != NULL);
        ASSERT(sp->ans_hdl != NULL);
        ASSERT(sp->ans_dip != NULL);
        if (sp == NULL || sp->ans_hdl == NULL || sp->ans_dip == NULL) {
                ACPINEX_DEBUG(CE_WARN,
                    "!acpinex: invalid parameter to acpinex_event_scan().");
                return (DDI_FAILURE);
        }

        /* Lock current device node and walk all child device nodes of it. */
        mutex_enter(&sp->ans_lock);

        rc = acpinex_event_walk(init, sp, sp->ans_hdl);
        if (rc != DDI_SUCCESS) {
                if (init) {
                        ACPINEX_DEBUG(CE_WARN, "!acpinex: failed to "
                            "configure child objects of %s.", sp->ans_path);
                        rc = DDI_FAILURE;
                } else {
                        ACPINEX_DEBUG(CE_WARN, "!acpinex: failed to "
                            "unconfigure child objects of %s.", sp->ans_path);
                        /* Undo in case of errors */
                        (void) acpinex_event_walk(B_TRUE, sp, sp->ans_hdl);
                        rc = DDI_FAILURE;
                }
        }

        mutex_exit(&sp->ans_lock);

        return (rc);
}

void
acpinex_event_init(void)
{
        /*
         * According to ACPI specifications, notification is only supported on
         * Device, Processor and ThermalZone. Currently we only need to handle
         * Device and Processor objects.
         */
        BT_SET(acpinex_object_type_mask, ACPI_TYPE_PROCESSOR);
        BT_SET(acpinex_object_type_mask, ACPI_TYPE_DEVICE);
}

void
acpinex_event_fini(void)
{
        bzero(acpinex_object_type_mask, sizeof (acpinex_object_type_mask));
}