/*
 * 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 (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2017 Joyent, Inc.
 */


/*
 * Human Interface Device driver (HID)
 *
 * The HID driver is a software driver which acts as a class
 * driver for USB human input devices like keyboard, mouse,
 * joystick etc and provides the class-specific interfaces
 * between these client driver modules and the Universal Serial
 * Bus Driver(USBA).
 *
 * NOTE: This driver is not DDI compliant in that it uses undocumented
 * functions for logging (USB_DPRINTF_L*, usb_alloc_log_hdl, usb_free_log_hdl).
 *
 * Undocumented functions may go away in a future Solaris OS release.
 *
 * Please see the DDK for sample code of these functions, and for the usbskel
 * skeleton template driver which contains scaled-down versions of these
 * functions written in a DDI-compliant way.
 */

#define USBDRV_MAJOR_VER        2
#define USBDRV_MINOR_VER        0

#include <sys/usb/usba.h>
#include <sys/usb/usba/genconsole.h>
#include <sys/usb/clients/hid/hid.h>
#include <sys/usb/clients/hid/hid_polled.h>
#include <sys/usb/clients/hidparser/hidparser.h>
#include <sys/usb/clients/hid/hidvar.h>
#include <sys/usb/clients/hid/hidminor.h>
#include <sys/usb/clients/hidparser/hid_parser_driver.h>
#include <sys/stropts.h>
#include <sys/sunddi.h>
#include <sys/stream.h>
#include <sys/strsun.h>

extern int ddi_create_internal_pathname(dev_info_t *, char *, int, minor_t);

/* Debugging support */
uint_t  hid_errmask     = (uint_t)PRINT_MASK_ALL;
uint_t  hid_errlevel    = USB_LOG_L4;
uint_t  hid_instance_debug = (uint_t)-1;

/* tunables */
int     hid_default_pipe_drain_timeout = HID_DEFAULT_PIPE_DRAIN_TIMEOUT;
int     hid_pm_mouse = 1; /* enable remote_wakeup for USB mouse/keyboard */

/* soft state structures */
#define HID_INITIAL_SOFT_SPACE  4
static void *hid_statep;

/* Callbacks */
static void hid_interrupt_pipe_callback(usb_pipe_handle_t,
                usb_intr_req_t *);
static void hid_default_pipe_callback(usb_pipe_handle_t, usb_ctrl_req_t *);
static void hid_interrupt_pipe_exception_callback(usb_pipe_handle_t,
                usb_intr_req_t *);
static void hid_default_pipe_exception_callback(usb_pipe_handle_t,
                usb_ctrl_req_t *);
static int hid_restore_state_event_callback(dev_info_t *);
static int hid_disconnect_event_callback(dev_info_t *);
static int hid_cpr_suspend(hid_state_t *hidp);
static void hid_cpr_resume(hid_state_t *hidp);
static void hid_power_change_callback(void *arg, int rval);

/* Supporting routines */
static size_t hid_parse_hid_descr(usb_hid_descr_t *, size_t,
                usb_alt_if_data_t *, usb_ep_data_t *);
static int hid_parse_hid_descr_failure(hid_state_t *);
static int hid_handle_report_descriptor(hid_state_t *, int);
static void hid_set_idle(hid_state_t *);
static void hid_set_protocol(hid_state_t *, int);
static void hid_detach_cleanup(dev_info_t *, hid_state_t *);

static int hid_start_intr_polling(hid_state_t *);
static void hid_close_intr_pipe(hid_state_t *);
static int hid_mctl_execute_cmd(queue_t *, int, hid_req_t *,
                mblk_t *);
static int hid_mctl_receive(queue_t *, mblk_t *);
static int hid_send_async_ctrl_request(hid_default_pipe_arg_t *, hid_req_t *,
                uchar_t, int, ushort_t);

static void hid_create_pm_components(dev_info_t *, hid_state_t *);
static int hid_is_pm_enabled(dev_info_t *);
static void hid_restore_device_state(dev_info_t *, hid_state_t *);
static void hid_save_device_state(hid_state_t *);

static void hid_qreply_merror(queue_t *, mblk_t *, uchar_t);
static mblk_t *hid_data2mblk(uchar_t *, int);
static void hid_flush(queue_t *);

static int hid_pwrlvl0(hid_state_t *);
static int hid_pwrlvl1(hid_state_t *);
static int hid_pwrlvl2(hid_state_t *);
static int hid_pwrlvl3(hid_state_t *);
static void hid_pm_busy_component(hid_state_t *);
static void hid_pm_idle_component(hid_state_t *);

static int hid_polled_read(hid_polled_handle_t, uchar_t **);
static int hid_polled_input_enter(hid_polled_handle_t);
static int hid_polled_input_exit(hid_polled_handle_t);
static int hid_polled_input_init(hid_state_t *);
static int hid_polled_input_fini(hid_state_t *);

/* Streams entry points */
static int      hid_open(queue_t *, dev_t *, int, int, cred_t *);
static int      hid_close(queue_t *, int, cred_t *);
static int      hid_wput(queue_t *, mblk_t *);
static int      hid_wsrv(queue_t *);

/* dev_ops entry points */
static int      hid_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int      hid_attach(dev_info_t *, ddi_attach_cmd_t);
static int      hid_detach(dev_info_t *, ddi_detach_cmd_t);
static int      hid_power(dev_info_t *, int, int);
/* These are to enable ugen support: */
static int      hid_chropen(dev_t *, int, int, cred_t *);
static int      hid_chrclose(dev_t, int, int, cred_t *);
static int      hid_read(dev_t, struct uio *, cred_t *);
static int      hid_write(dev_t, struct uio *, cred_t *);
static int      hid_poll(dev_t, short, int, short *, struct pollhead **);

/*
 * Warlock is not aware of the automatic locking mechanisms for
 * streams drivers.  The hid streams enter points are protected by
 * a per module perimeter.  If the locking in hid is a bottleneck
 * per queue pair or per queue locking may be used.  Since warlock
 * is not aware of the streams perimeters, these notes have been added.
 *
 * Note that the perimeters do not protect the driver from callbacks
 * happening while a streams entry point is executing.  So, the hid_mutex
 * has been created to protect the data.
 */
_NOTE(SCHEME_PROTECTS_DATA("unique per call", iocblk))
_NOTE(SCHEME_PROTECTS_DATA("unique per call", datab))
_NOTE(SCHEME_PROTECTS_DATA("unique per call", msgb))
_NOTE(SCHEME_PROTECTS_DATA("unique per call", queue))
_NOTE(SCHEME_PROTECTS_DATA("unique per call", usb_ctrl_req))
_NOTE(SCHEME_PROTECTS_DATA("unique per call", usb_intr_req))

/* module information */
static struct module_info hid_mod_info = {
        0x0ffff,                        /* module id number */
        "hid",                          /* module name */
        0,                              /* min packet size accepted */
        INFPSZ,                         /* max packet size accepted */
        512,                            /* hi-water mark */
        128                             /* lo-water mark */
};

/* read queue information structure */
static struct qinit rinit = {
        NULL,                           /* put procedure not needed */
        NULL,                           /* service procedure not needed */
        hid_open,                       /* called on startup */
        hid_close,                      /* called on finish */
        NULL,                           /* for future use */
        &hid_mod_info,                  /* module information structure */
        NULL                            /* module statistics structure */
};

/* write queue information structure */
static struct qinit winit = {
        hid_wput,                       /* put procedure */
        hid_wsrv,                       /* service procedure */
        NULL,                           /* open not used on write side */
        NULL,                           /* close not used on write side */
        NULL,                           /* for future use */
        &hid_mod_info,                  /* module information structure */
        NULL                            /* module statistics structure */
};

struct streamtab hid_streamtab = {
        &rinit,
        &winit,
        NULL,                   /* not a MUX */
        NULL                    /* not a MUX */
};

struct cb_ops hid_cb_ops = {
        hid_chropen,            /* open  */
        hid_chrclose,           /* close */
        nulldev,                /* strategy */
        nulldev,                /* print */
        nulldev,                /* dump */
        hid_read,               /* read */
        hid_write,              /* write */
        nulldev,                /* ioctl */
        nulldev,                /* devmap */
        nulldev,                /* mmap */
        nulldev,                /* segmap */
        hid_poll,               /* poll */
        ddi_prop_op,            /* cb_prop_op */
        &hid_streamtab,         /* streamtab  */
        D_MP | D_MTPERQ
};


static struct dev_ops hid_ops = {
        DEVO_REV,               /* devo_rev, */
        0,                      /* refcnt  */
        hid_info,               /* info */
        nulldev,                /* identify */
        nulldev,                /* probe */
        hid_attach,             /* attach */
        hid_detach,             /* detach */
        nodev,                  /* reset */
        &hid_cb_ops,            /* driver operations */
        NULL,                   /* bus operations */
        hid_power,              /* power */
        ddi_quiesce_not_needed,         /* quiesce */
};

static struct modldrv hidmodldrv =      {
        &mod_driverops,
        "USB HID Client Driver",
        &hid_ops                        /* driver ops */
};

static struct modlinkage modlinkage = {
        MODREV_1,
        &hidmodldrv,
        NULL,
};

static usb_event_t hid_events = {
        hid_disconnect_event_callback,
        hid_restore_state_event_callback,
        NULL,
        NULL,
};


int
_init(void)
{
        int rval;

        if (((rval = ddi_soft_state_init(&hid_statep, sizeof (hid_state_t),
            HID_INITIAL_SOFT_SPACE)) != 0)) {

                return (rval);
        }

        if ((rval = mod_install(&modlinkage)) != 0) {
                ddi_soft_state_fini(&hid_statep);
        }

        return (rval);
}


int
_fini(void)
{
        int rval;

        if ((rval = mod_remove(&modlinkage)) != 0) {

                return (rval);
        }

        ddi_soft_state_fini(&hid_statep);

        return (rval);
}


int
_info(struct modinfo *modinfop)
{
        return (mod_info(&modlinkage, modinfop));
}


/*
 * hid_info :
 *      Get minor number, soft state structure etc.
 */
/*ARGSUSED*/
static int
hid_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
        hid_state_t     *hidp = NULL;
        int             error = DDI_FAILURE;
        minor_t         minor = getminor((dev_t)arg);
        int             instance = HID_MINOR_TO_INSTANCE(minor);

        switch (infocmd) {
        case DDI_INFO_DEVT2DEVINFO:
                if ((hidp = ddi_get_soft_state(hid_statep, instance)) != NULL) {
                        *result = hidp->hid_dip;
                        if (*result != NULL) {
                                error = DDI_SUCCESS;
                        }
                } else
                        *result = NULL;
                break;
        case DDI_INFO_DEVT2INSTANCE:
                *result = (void *)(uintptr_t)instance;
                error = DDI_SUCCESS;
                break;
        default:
                break;
        }

        return (error);
}


/*
 * hid_attach :
 *      Gets called at the time of attach. Do allocation,
 *      and initialization of the software structure.
 *      Get all the descriptors, setup the
 *      report descriptor tree by calling hidparser
 *      function.
 */
static int
hid_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{

        int                     instance = ddi_get_instance(dip);
        int                     parse_hid_descr_error = 0;
        hid_state_t             *hidp = NULL;
        uint32_t                usage_page;
        uint32_t                usage;
        usb_client_dev_data_t   *dev_data;
        usb_alt_if_data_t       *altif_data;
        char                    minor_name[HID_MINOR_NAME_LEN];
        usb_ep_data_t           *ep_data;
        usb_ugen_info_t         usb_ugen_info;

        switch (cmd) {
                case DDI_ATTACH:
                        break;
                case DDI_RESUME:
                        hidp = ddi_get_soft_state(hid_statep, instance);
                        hid_cpr_resume(hidp);
                        return (DDI_SUCCESS);
                default:

                        return (DDI_FAILURE);
        }

        /*
         * Allocate softstate information and get softstate pointer
         */
        if (ddi_soft_state_zalloc(hid_statep, instance) == DDI_SUCCESS) {
                hidp = ddi_get_soft_state(hid_statep, instance);
        }
        if (hidp == NULL) {

                goto fail;
        }

        hidp->hid_log_handle = usb_alloc_log_hdl(dip, NULL, &hid_errlevel,
            &hid_errmask, &hid_instance_debug, 0);

        hidp->hid_instance = instance;
        hidp->hid_dip = dip;

        /*
         * Register with USBA. Just retrieve interface descriptor
         */
        if (usb_client_attach(dip, USBDRV_VERSION, 0) != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, hidp->hid_log_handle,
                    "hid_attach: client attach failed");

                goto fail;
        }

        if (usb_get_dev_data(dip, &dev_data, USB_PARSE_LVL_IF, 0) !=
            USB_SUCCESS) {

                USB_DPRINTF_L2(PRINT_MASK_ATTA, hidp->hid_log_handle,
                    "hid_attach: usb_get_dev_data() failed");

                goto fail;
        }

        /* initialize mutex */
        mutex_init(&hidp->hid_mutex, NULL, MUTEX_DRIVER,
            dev_data->dev_iblock_cookie);

        hidp->hid_attach_flags  |= HID_LOCK_INIT;

        /* get interface data for alternate 0 */
        altif_data = &dev_data->dev_curr_cfg->
            cfg_if[dev_data->dev_curr_if].if_alt[0];

        mutex_enter(&hidp->hid_mutex);
        hidp->hid_dev_data      = dev_data;
        hidp->hid_dev_descr     = dev_data->dev_descr;
        hidp->hid_interfaceno   = dev_data->dev_curr_if;
        hidp->hid_if_descr      = altif_data->altif_descr;
        /*
         * Make sure that the bInterfaceProtocol only has meaning to
         * Boot Interface Subclass.
         */
        if (hidp->hid_if_descr.bInterfaceSubClass != BOOT_INTERFACE)
                hidp->hid_if_descr.bInterfaceProtocol = NONE_PROTOCOL;
        mutex_exit(&hidp->hid_mutex);

        if ((ep_data = usb_lookup_ep_data(dip, dev_data,
            hidp->hid_interfaceno, 0, 0,
            (uint_t)USB_EP_ATTR_INTR, (uint_t)USB_EP_DIR_IN)) == NULL) {

                USB_DPRINTF_L2(PRINT_MASK_ATTA, hidp->hid_log_handle,
                    "no interrupt IN endpoint found");

                goto fail;
        }

        mutex_enter(&hidp->hid_mutex);
        if (usb_ep_xdescr_fill(USB_EP_XDESCR_CURRENT_VERSION, dip, ep_data,
            &hidp->hid_ep_intr_xdescr) != USB_SUCCESS) {
                mutex_exit(&hidp->hid_mutex);

                goto fail;
        }

        /*
         * Attempt to find the hid descriptor, it could be after interface
         * or after endpoint descriptors
         */
        if (hid_parse_hid_descr(&hidp->hid_hid_descr, USB_HID_DESCR_SIZE,
            altif_data, ep_data) != USB_HID_DESCR_SIZE) {
                /*
                 * If parsing of hid descriptor failed and
                 * the device is a keyboard or mouse, use predefined
                 * length and packet size.
                 */
                if (hid_parse_hid_descr_failure(hidp) == USB_FAILURE) {
                        mutex_exit(&hidp->hid_mutex);

                        goto fail;
                }

                /*
                 * hid descriptor was bad but since
                 * the device is a keyboard or mouse,
                 * we will use the default length
                 * and packet size.
                 */
                parse_hid_descr_error = HID_BAD_DESCR;
        } else {
                /* Parse hid descriptor successful */

                USB_DPRINTF_L3(PRINT_MASK_ATTA, hidp->hid_log_handle,
                    "Hid descriptor:\n\t"
                    "bLength = 0x%x bDescriptorType = 0x%x "
                    "bcdHID = 0x%x\n\t"
                    "bCountryCode = 0x%x bNumDescriptors = 0x%x\n\t"
                    "bReportDescriptorType = 0x%x\n\t"
                    "wReportDescriptorLength = 0x%x",
                    hidp->hid_hid_descr.bLength,
                    hidp->hid_hid_descr.bDescriptorType,
                    hidp->hid_hid_descr.bcdHID,
                    hidp->hid_hid_descr.bCountryCode,
                    hidp->hid_hid_descr.bNumDescriptors,
                    hidp->hid_hid_descr.bReportDescriptorType,
                    hidp->hid_hid_descr.wReportDescriptorLength);
        }

        /*
         * Save a copy of the default pipe for easy reference
         */
        hidp->hid_default_pipe = hidp->hid_dev_data->dev_default_ph;

        /* we copied the descriptors we need, free the dev_data */
        usb_free_dev_data(dip, dev_data);
        hidp->hid_dev_data = NULL;

        if (usb_owns_device(dip)) {
                /* Get a ugen handle. */
                bzero(&usb_ugen_info, sizeof (usb_ugen_info));

                usb_ugen_info.usb_ugen_flags = 0;
                usb_ugen_info.usb_ugen_minor_node_ugen_bits_mask =
                    (dev_t)HID_MINOR_UGEN_BITS_MASK;
                usb_ugen_info.usb_ugen_minor_node_instance_mask =
                    (dev_t)HID_MINOR_INSTANCE_MASK;
                hidp->hid_ugen_hdl = usb_ugen_get_hdl(dip, &usb_ugen_info);

                if (usb_ugen_attach(hidp->hid_ugen_hdl, cmd) !=
                    USB_SUCCESS) {
                        USB_DPRINTF_L2(PRINT_MASK_ATTA,
                            hidp->hid_log_handle,
                            "usb_ugen_attach failed");

                        usb_ugen_release_hdl(hidp->hid_ugen_hdl);
                        hidp->hid_ugen_hdl = NULL;
                }
        }

        /*
         * Don't get the report descriptor if parsing hid descriptor earlier
         * failed since device probably won't return valid report descriptor
         * either. Though parsing of hid descriptor failed, we have reached
         * this point because the device has been identified as a
         * keyboard or a mouse successfully and the default packet
         * size and layout(in case of keyboard only) will be used, so it
         * is ok to go ahead even if parsing of hid descriptor failed and
         * we will not try to get the report descriptor.
         */
        if (parse_hid_descr_error != HID_BAD_DESCR) {
                /*
                 * Sun mouse rev 105 is a bit slow in responding to this
                 * request and requires multiple retries
                 */
                int retry;

                /*
                 * Get and parse the report descriptor.
                 * Set the packet size if parsing is successful.
                 * Note that we start retry at 1 to have a delay
                 * in the first iteration.
                 */
                mutex_exit(&hidp->hid_mutex);
                for (retry = 1; retry < HID_RETRY; retry++) {
                        if (hid_handle_report_descriptor(hidp,
                            hidp->hid_interfaceno) == USB_SUCCESS) {
                                break;
                        }
                        delay(retry * drv_usectohz(1000));
                }
                if (retry >= HID_RETRY) {

                        goto fail;
                }
                mutex_enter(&hidp->hid_mutex);

                /*
                 * If packet size is zero, but the device is identified
                 * as a mouse or a keyboard, use predefined packet
                 * size.
                 */
                if (hidp->hid_packet_size == 0) {
                        if (hidp->hid_if_descr.bInterfaceProtocol ==
                            KEYBOARD_PROTOCOL) {
                                /* device is a keyboard */
                                hidp->hid_packet_size = USBKPSZ;
                        } else if (hidp->
                            hid_if_descr.bInterfaceProtocol ==
                            MOUSE_PROTOCOL) {
                                /* device is a mouse */
                                hidp->hid_packet_size = USBMSSZ;
                        } else {
                                USB_DPRINTF_L2(PRINT_MASK_ATTA,
                                    hidp->hid_log_handle,
                                    "Failed to find hid packet size");
                                mutex_exit(&hidp->hid_mutex);

                                goto fail;
                        }
                }
        }

        /*
         * initialize the pipe policy for the interrupt pipe.
         */
        hidp->hid_intr_pipe_policy.pp_max_async_reqs = 1;

        /*
         * Make a clas specific request to SET_IDLE
         * In this case send no reports if state has not changed.
         * See HID 7.2.4.
         */
        mutex_exit(&hidp->hid_mutex);
        hid_set_idle(hidp);

        /* always initialize to report protocol */
        hid_set_protocol(hidp, SET_REPORT_PROTOCOL);
        mutex_enter(&hidp->hid_mutex);

        /*
         * Create minor node based on information from the
         * descriptors
         */
        switch (hidp->hid_if_descr.bInterfaceProtocol) {
        case KEYBOARD_PROTOCOL:
                (void) strcpy(minor_name, "keyboard");

                break;
        case MOUSE_PROTOCOL:
                (void) strcpy(minor_name, "mouse");

                break;
        default:
                /*
                 * If the report descriptor has the GD mouse collection in
                 * its multiple collection, create a minor node and support it.
                 * It is used on some advanced keyboard/mouse set.
                 */
                if (hidparser_lookup_usage_collection(
                    hidp->hid_report_descr, HID_GENERIC_DESKTOP,
                    HID_GD_MOUSE) != HIDPARSER_FAILURE) {
                        (void) strcpy(minor_name, "mouse");

                        break;
                }

                if (hidparser_get_top_level_collection_usage(
                    hidp->hid_report_descr, &usage_page, &usage) !=
                    HIDPARSER_FAILURE) {
                        switch (usage_page) {
                        case HID_CONSUMER:
                                switch (usage) {
                                case HID_CONSUMER_CONTROL:
                                        (void) strcpy(minor_name,
                                            "consumer_control");

                                        break;
                                default:
                                        (void) sprintf(minor_name,
                                            "hid_%d_%d", usage_page, usage);

                                        break;
                                }

                                break;
                        case HID_GENERIC_DESKTOP:
                                switch (usage) {
                                case HID_GD_POINTER:
                                        (void) strcpy(minor_name,
                                            "pointer");

                                        break;
                                case HID_GD_MOUSE:
                                        (void) strcpy(minor_name,
                                            "mouse");

                                        break;
                                case HID_GD_KEYBOARD:
                                        (void) strcpy(minor_name,
                                            "keyboard");

                                        break;
                                default:
                                        (void) sprintf(minor_name,
                                            "hid_%d_%d", usage_page, usage);

                                        break;
                                }

                                break;
                        default:
                                (void) sprintf(minor_name,
                                    "hid_%d_%d", usage_page, usage);

                                break;
                        }
                } else {
                        USB_DPRINTF_L1(PRINT_MASK_ATTA, hidp->hid_log_handle,
                            "hid_attach: Unsupported HID device");
                        mutex_exit(&hidp->hid_mutex);

                        goto fail;
                }

                break;
        }

        mutex_exit(&hidp->hid_mutex);

        if ((ddi_create_minor_node(dip, minor_name, S_IFCHR,
            HID_CONSTRUCT_EXTERNAL_MINOR(instance),
            DDI_PSEUDO, 0)) != DDI_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, hidp->hid_log_handle,
                    "hid_attach: Could not create minor node");

                goto fail;
        }

        /* create internal path for virtual */
        if (strcmp(minor_name, "mouse") == 0) {
                if (ddi_create_internal_pathname(dip, "internal_mouse", S_IFCHR,
                    HID_CONSTRUCT_INTERNAL_MINOR(instance)) != DDI_SUCCESS) {

                        goto fail;
                }
        }

        if (strcmp(minor_name, "keyboard") == 0) {
                if (ddi_create_internal_pathname(dip, "internal_keyboard",
                    S_IFCHR, HID_CONSTRUCT_INTERNAL_MINOR(instance)) !=
                    DDI_SUCCESS) {

                        goto fail;
                }
        }

        mutex_enter(&hidp->hid_mutex);
        hidp->hid_attach_flags |= HID_MINOR_NODES;
        hidp->hid_dev_state = USB_DEV_ONLINE;
        mutex_exit(&hidp->hid_mutex);

        /* register for all events */
        if (usb_register_event_cbs(dip, &hid_events, 0) != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, hidp->hid_log_handle,
                    "usb_register_event_cbs failed");

                goto fail;
        }

        /* now create components to power manage this device */
        hid_create_pm_components(dip, hidp);
        hid_pm_busy_component(hidp);
        (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);
        hid_pm_idle_component(hidp);

        hidp->hid_internal_rq = hidp->hid_external_rq = NULL;
        hidp->hid_internal_flag = hidp->hid_external_flag = 0;
        hidp->hid_inuse_rq = NULL;

        /*
         * report device
         */
        ddi_report_dev(dip);

        USB_DPRINTF_L4(PRINT_MASK_ATTA, hidp->hid_log_handle,
            "hid_attach: End");

        return (DDI_SUCCESS);

fail:
        if (hidp) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, hidp->hid_log_handle,
                    "hid_attach: fail");
                hid_detach_cleanup(dip, hidp);
        }

        return (DDI_FAILURE);
}


/*
 * hid_detach :
 *      Gets called at the time of detach.
 */
static int
hid_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        int instance = ddi_get_instance(dip);
        hid_state_t     *hidp;
        int             rval = DDI_FAILURE;

        hidp = ddi_get_soft_state(hid_statep, instance);

        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle, "hid_detach");

        switch (cmd) {
        case DDI_DETACH:
                /*
                 * Undo what we did in client_attach, freeing resources
                 * and removing things we installed.  The system
                 * framework guarantees we are not active with this devinfo
                 * node in any other entry points at this time.
                 */
                hid_detach_cleanup(dip, hidp);

                return (DDI_SUCCESS);
        case DDI_SUSPEND:
                rval = hid_cpr_suspend(hidp);

                return (rval == USB_SUCCESS ? DDI_SUCCESS : DDI_FAILURE);
        default:
                break;
        }

        return (rval);
}

static int
hid_chropen(dev_t *devp, int flag, int sflag, cred_t *credp)
{
        int rval;
        minor_t minor = getminor(*devp);
        int instance;
        hid_state_t *hidp;

        instance = HID_MINOR_TO_INSTANCE(minor);

        hidp = ddi_get_soft_state(hid_statep, instance);
        if (hidp == NULL) {
                return (ENXIO);
        }

        if (!HID_IS_UGEN_OPEN(minor)) {
                return (ENXIO);
        }

        hid_pm_busy_component(hidp);
        (void) pm_raise_power(hidp->hid_dip, 0, USB_DEV_OS_FULL_PWR);

        mutex_enter(&hidp->hid_mutex);

        rval = usb_ugen_open(hidp->hid_ugen_hdl, devp, flag,
            sflag, credp);

        mutex_exit(&hidp->hid_mutex);

        if (rval != 0) {
                hid_pm_idle_component(hidp);
        }

        return (rval);
}

static int
hid_chrclose(dev_t dev, int flag, int otyp, cred_t *credp)
{
        int rval;
        minor_t minor = getminor(dev);
        int instance;
        hid_state_t *hidp;

        instance = HID_MINOR_TO_INSTANCE(minor);

        hidp = ddi_get_soft_state(hid_statep, instance);
        if (hidp == NULL) {
                return (ENXIO);
        }

        if (!HID_IS_UGEN_OPEN(minor)) {
                return (ENXIO);
        }

        mutex_enter(&hidp->hid_mutex);

        rval = usb_ugen_close(hidp->hid_ugen_hdl, dev, flag,
            otyp, credp);

        mutex_exit(&hidp->hid_mutex);

        if (rval == 0) {
                hid_pm_idle_component(hidp);
        }

        return (rval);
}

static int
hid_read(dev_t dev, struct uio *uiop, cred_t *credp)
{
        int rval;
        minor_t minor = getminor(dev);
        int instance;
        hid_state_t *hidp;

        instance = HID_MINOR_TO_INSTANCE(minor);

        hidp = ddi_get_soft_state(hid_statep, instance);
        if (hidp == NULL) {
                return (ENXIO);
        }

        if (!HID_IS_UGEN_OPEN(minor)) {
                return (ENXIO);
        }

        rval = usb_ugen_read(hidp->hid_ugen_hdl, dev, uiop, credp);

        return (rval);
}

static int
hid_write(dev_t dev, struct uio *uiop, cred_t *credp)
{
        int rval;
        minor_t minor = getminor(dev);
        int instance;
        hid_state_t *hidp;

        instance = HID_MINOR_TO_INSTANCE(minor);

        hidp = ddi_get_soft_state(hid_statep, instance);
        if (hidp == NULL) {
                return (ENXIO);
        }

        if (!HID_IS_UGEN_OPEN(minor)) {
                return (ENXIO);
        }

        rval = usb_ugen_write(hidp->hid_ugen_hdl, dev, uiop, credp);

        return (rval);
}

static int
hid_poll(dev_t dev, short events, int anyyet, short *reventsp,
    struct pollhead **phpp)
{
        int rval;
        minor_t minor = getminor(dev);
        int instance;
        hid_state_t *hidp;

        instance = HID_MINOR_TO_INSTANCE(minor);

        hidp = ddi_get_soft_state(hid_statep, instance);
        if (hidp == NULL) {
                return (ENXIO);
        }

        if (!HID_IS_UGEN_OPEN(minor)) {
                return (ENXIO);
        }

        rval = usb_ugen_poll(hidp->hid_ugen_hdl, dev, events, anyyet,
            reventsp, phpp);

        return (rval);
}

/*
 * hid_open :
 *      Open entry point: Opens the interrupt pipe.  Sets up queues.
 */
/*ARGSUSED*/
static int
hid_open(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *credp)
{
        int no_of_ep = 0;
        int rval;
        int instance;
        hid_state_t *hidp;
        minor_t minor = getminor(*devp);

        instance = HID_MINOR_TO_INSTANCE(minor);

        hidp = ddi_get_soft_state(hid_statep, instance);
        if (hidp == NULL) {
                return (ENXIO);
        }

        USB_DPRINTF_L4(PRINT_MASK_OPEN, hidp->hid_log_handle,
            "hid_open: Begin");

        /*
         * If this is a ugen device, return ENOSTR (no streams). This will
         * cause spec_open to try hid_chropen from our regular ops_cb instead
         * (and thus treat us as a plain character device).
         */
        if (HID_IS_UGEN_OPEN(minor)) {
                return (ENOSTR);
        }

        if (sflag) {
                /* clone open NOT supported here */
                return (ENXIO);
        }

        if (!(flag & FREAD)) {
                return (EIO);
        }

        mutex_enter(&hidp->hid_mutex);

        /*
         * This is a workaround:
         *      Currently, if we open an already disconnected device, and send
         *      a CONSOPENPOLL ioctl to it, the system will panic, please refer
         *      to the processing HID_OPEN_POLLED_INPUT ioctl in the routine
         *      hid_mctl_receive().
         *      The consconfig_dacf module need this interface to detect if the
         *      device is already disconnnected.
         */
        if (HID_IS_INTERNAL_OPEN(minor) &&
            (hidp->hid_dev_state == USB_DEV_DISCONNECTED)) {
                mutex_exit(&hidp->hid_mutex);
                return (ENODEV);
        }

        if (HID_IS_INTERNAL_OPEN(minor) &&
            (hidp->hid_internal_rq != NULL)) {
                ASSERT(hidp->hid_internal_rq == q);

                mutex_exit(&hidp->hid_mutex);
                return (0);
        }

        if ((!HID_IS_INTERNAL_OPEN(minor)) &&
            (hidp->hid_external_rq != NULL)) {
                ASSERT(hidp->hid_external_rq == q);

                mutex_exit(&hidp->hid_mutex);
                return (0);
        }

        mutex_exit(&hidp->hid_mutex);

        q->q_ptr = hidp;
        WR(q)->q_ptr = hidp;

        mutex_enter(&hidp->hid_mutex);
        if (hidp->hid_inuse_rq != NULL) {
                /* Pipe has already been setup */

                if (HID_IS_INTERNAL_OPEN(minor)) {
                        hidp->hid_internal_flag = HID_STREAMS_OPEN;
                        hidp->hid_inuse_rq = hidp->hid_internal_rq = q;
                } else {
                        hidp->hid_external_flag = HID_STREAMS_OPEN;
                        hidp->hid_inuse_rq = hidp->hid_external_rq = q;
                }

                mutex_exit(&hidp->hid_mutex);

                qprocson(q);

                return (0);
        }

        /* Pipe only needs to be opened once */
        hidp->hid_interrupt_pipe = NULL;
        no_of_ep = hidp->hid_if_descr.bNumEndpoints;
        mutex_exit(&hidp->hid_mutex);

        /* Check if interrupt endpoint exists */
        if (no_of_ep > 0) {
                /* Open the interrupt pipe */
                if (usb_pipe_xopen(hidp->hid_dip,
                    &hidp->hid_ep_intr_xdescr,
                    &hidp->hid_intr_pipe_policy, USB_FLAGS_SLEEP,
                    &hidp->hid_interrupt_pipe) !=
                    USB_SUCCESS) {

                        q->q_ptr = NULL;
                        WR(q)->q_ptr = NULL;
                        return (EIO);
                }
        }

        hid_pm_busy_component(hidp);
        (void) pm_raise_power(hidp->hid_dip, 0, USB_DEV_OS_FULL_PWR);

        mutex_enter(&hidp->hid_mutex);
        if (HID_IS_INTERNAL_OPEN(minor)) {
                hidp->hid_internal_flag = HID_STREAMS_OPEN;
                hidp->hid_inuse_rq = hidp->hid_internal_rq = q;
        } else {
                hidp->hid_external_flag = HID_STREAMS_OPEN;
                hidp->hid_inuse_rq = hidp->hid_external_rq = q;
        }

        mutex_exit(&hidp->hid_mutex);

        qprocson(q);

        mutex_enter(&hidp->hid_mutex);

        if ((rval = hid_start_intr_polling(hidp)) != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_OPEN, hidp->hid_log_handle,
                    "unable to start intr pipe polling. rval = %d", rval);

                if (HID_IS_INTERNAL_OPEN(minor))
                        hidp->hid_internal_flag = HID_STREAMS_DISMANTLING;
                else
                        hidp->hid_external_flag = HID_STREAMS_DISMANTLING;
                mutex_exit(&hidp->hid_mutex);

                usb_pipe_close(hidp->hid_dip, hidp->hid_interrupt_pipe,
                    USB_FLAGS_SLEEP, NULL, NULL);

                mutex_enter(&hidp->hid_mutex);
                hidp->hid_interrupt_pipe = NULL;
                mutex_exit(&hidp->hid_mutex);

                qprocsoff(q);

                mutex_enter(&hidp->hid_mutex);
                if (HID_IS_INTERNAL_OPEN(minor)) {
                        hidp->hid_internal_flag = 0;
                        hidp->hid_internal_rq = NULL;
                        if (hidp->hid_external_flag == HID_STREAMS_OPEN)
                                hidp->hid_inuse_rq = hidp->hid_external_rq;
                        else
                                hidp->hid_inuse_rq = NULL;
                } else {
                        hidp->hid_external_flag = 0;
                        hidp->hid_external_rq = NULL;
                        if (hidp->hid_internal_flag == HID_STREAMS_OPEN)
                                hidp->hid_inuse_rq = hidp->hid_internal_rq;
                        else
                                hidp->hid_inuse_rq = NULL;
                }
                mutex_exit(&hidp->hid_mutex);

                q->q_ptr = NULL;
                WR(q)->q_ptr = NULL;

                hid_pm_idle_component(hidp);

                return (EIO);
        }
        mutex_exit(&hidp->hid_mutex);

        USB_DPRINTF_L4(PRINT_MASK_OPEN, hidp->hid_log_handle, "hid_open: End");

        /*
         * Keyboard and mouse is Power managed by device activity.
         * All other devices go busy on open and idle on close.
         */
        switch (hidp->hid_pm->hid_pm_strategy) {
        case HID_PM_ACTIVITY:
                hid_pm_idle_component(hidp);

                break;
        default:

                break;
        }

        return (0);
}


/*
 * hid_close :
 *      Close entry point.
 */
/*ARGSUSED*/
static int
hid_close(queue_t *q, int flag, cred_t *credp)
{
        hid_state_t     *hidp = (hid_state_t *)q->q_ptr;
        queue_t         *wq;
        mblk_t          *mp;

        USB_DPRINTF_L4(PRINT_MASK_CLOSE, hidp->hid_log_handle, "hid_close:");

        mutex_enter(&hidp->hid_mutex);

        ASSERT((hidp->hid_internal_rq == q) ||
            (hidp->hid_external_rq == q));

        if (hidp->hid_internal_rq == q)
                hidp->hid_internal_flag = HID_STREAMS_DISMANTLING;
        else
                hidp->hid_external_flag = HID_STREAMS_DISMANTLING;

        mutex_exit(&hidp->hid_mutex);

        /*
         * In case there are any outstanding requests on
         * the default pipe, wait forever for them to complete.
         */
        (void) usb_pipe_drain_reqs(hidp->hid_dip,
            hidp->hid_default_pipe, 0, USB_FLAGS_SLEEP, NULL, 0);

        mutex_enter(&hidp->hid_mutex);
        wq = WR(q);
        /* drain any M_CTLS on the WQ */
        while (mp = getq(wq)) {
                hid_qreply_merror(wq, mp, EIO);
                mutex_exit(&hidp->hid_mutex);
                hid_pm_idle_component(hidp);
                mutex_enter(&hidp->hid_mutex);
        }
        mutex_exit(&hidp->hid_mutex);

        qprocsoff(q);

        q->q_ptr = NULL;
        wq->q_ptr = NULL;

        mutex_enter(&hidp->hid_mutex);

        if (hidp->hid_internal_rq == q) {
                hidp->hid_internal_rq = NULL;
                hidp->hid_internal_flag = 0;
                if (hidp->hid_inuse_rq == q) {
                        /* We are closing the active stream */
                        if (hidp->hid_external_flag == HID_STREAMS_OPEN)
                                hidp->hid_inuse_rq = hidp->hid_external_rq;
                        else
                                hidp->hid_inuse_rq = NULL;
                }
        } else {
                hidp->hid_external_rq = NULL;
                hidp->hid_external_flag = 0;
                if (hidp->hid_inuse_rq == q) {
                        /* We are closing the active stream */
                        if (hidp->hid_internal_flag == HID_STREAMS_OPEN)
                                hidp->hid_inuse_rq = hidp->hid_internal_rq;
                        else
                                hidp->hid_inuse_rq = NULL;
                }
        }

        if (hidp->hid_inuse_rq != NULL) {
                mutex_exit(&hidp->hid_mutex);
                return (0);
        }

        /* all queues are closed, close USB pipes */
        hid_close_intr_pipe(hidp);
        mutex_exit(&hidp->hid_mutex);

        /*
         * Devices other than keyboard/mouse go idle on close.
         */
        switch (hidp->hid_pm->hid_pm_strategy) {
        case HID_PM_ACTIVITY:

                break;
        default:
                hid_pm_idle_component(hidp);

                break;
        }
        USB_DPRINTF_L4(PRINT_MASK_CLOSE, hidp->hid_log_handle,
            "hid_close: End");

        return (0);
}


/*
 * hid_wput :
 *      write put routine for the hid module
 */
static int
hid_wput(queue_t *q, mblk_t *mp)
{
        hid_state_t     *hidp = (hid_state_t *)q->q_ptr;
        int             error = USB_SUCCESS;
        struct iocblk   *iocbp;
        mblk_t          *datap;
        int             direction;
        struct copyresp *crp;
        queue_t         *tmpq;
        int             flag;

        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_wput: Begin");

        /* See if the upper module is passing the right thing */
        ASSERT(mp != NULL);
        ASSERT(mp->b_datap != NULL);

        switch (mp->b_datap->db_type) {
        case M_FLUSH:  /* Canonical flush handling */
                if (*mp->b_rptr & FLUSHW) {
                        flushq(q, FLUSHDATA);
                }

                /* read queue not used so just send up */
                if (*mp->b_rptr & FLUSHR) {
                        *mp->b_rptr &= ~FLUSHW;
                        qreply(q, mp);
                } else {
                        freemsg(mp);
                }

                break;
        case M_IOCTL:
                iocbp = (struct iocblk *)mp->b_rptr;

                /* Only accept transparent ioctls */
                if (iocbp->ioc_count != TRANSPARENT) {
                        miocnak(q, mp, 0, EINVAL);
                        break;
                }

                switch (iocbp->ioc_cmd) {
                case HIDIOCKMGDIRECT:

                        mutex_enter(&hidp->hid_mutex);
                        ASSERT(hidp->hid_inuse_rq != NULL);
                        mutex_exit(&hidp->hid_mutex);

                        if ((datap = allocb(sizeof (int), BPRI_MED)) == NULL) {
                                miocnak(q, mp, 0, ENOMEM);
                                break;
                        }

                        mutex_enter(&hidp->hid_mutex);
                        if (hidp->hid_inuse_rq == hidp->hid_internal_rq) {
                                *(int *)datap->b_wptr = 0;
                                datap->b_wptr += sizeof (int);
                        } else {
                                ASSERT(hidp->hid_inuse_rq ==
                                    hidp->hid_external_rq);
                                *(int *)datap->b_wptr = 1;
                                datap->b_wptr += sizeof (int);
                        }
                        mutex_exit(&hidp->hid_mutex);

                        mcopyout(mp, NULL, sizeof (int), NULL, datap);
                        qreply(q, mp);
                        break;

                case HIDIOCKMSDIRECT:
                        mcopyin(mp, NULL, sizeof (int), NULL);
                        qreply(q, mp);
                        break;

                default:
                        miocnak(q, mp, 0, ENOTTY);
                }

                break;

        case M_IOCDATA:

                crp = (void *)mp->b_rptr;

                if (crp->cp_rval != 0) {
                        miocnak(q, mp, 0, EIO);
                        break;
                }

                switch (crp->cp_cmd) {
                case HIDIOCKMGDIRECT:
                        miocack(q, mp, 0, 0);
                        break;

                case HIDIOCKMSDIRECT:
                        direction = *(int *)mp->b_cont->b_rptr;

                        if ((direction != 0) && (direction != 1)) {
                                miocnak(q, mp, 0, EINVAL);
                                break;
                        }

                        mutex_enter(&hidp->hid_mutex);

                        if (direction == 0) {
                                /* The internal stream is made active */
                                flag = hidp->hid_internal_flag;
                                tmpq = hidp->hid_internal_rq;
                        } else {
                                /* The external stream is made active */
                                flag = hidp->hid_external_flag;
                                tmpq = hidp->hid_external_rq;
                        }

                        if (flag != HID_STREAMS_OPEN) {
                                mutex_exit(&hidp->hid_mutex);
                                miocnak(q, mp, 0, EIO);
                                break;
                        }

                        hidp->hid_inuse_rq = tmpq;

                        mutex_exit(&hidp->hid_mutex);
                        miocack(q, mp, 0, 0);
                        break;

                default:
                        miocnak(q, mp, 0, ENOTTY);
                        break;
                }

                break;

        case M_CTL:
                /* we are busy now */
                hid_pm_busy_component(hidp);

                if (q->q_first) {
                        (void) putq(q, mp);
                } else {
                        error = hid_mctl_receive(q, mp);
                        switch (error) {
                        case HID_ENQUEUE:
                                /*
                                 * put this mblk on the WQ for the wsrv to
                                 * process
                                 */
                                (void) putq(q, mp);

                                break;
                        case HID_INPROGRESS:
                                /* request has been queued to the device */

                                break;
                        case HID_SUCCESS:
                                /*
                                 * returned by M_CTLS that are processed
                                 * immediately
                                 */

                                /* FALLTHRU */
                        case HID_FAILURE:
                        default:
                                hid_pm_idle_component(hidp);
                                break;
                        }
                }
                break;
        default:
                hid_qreply_merror(q, mp, EINVAL);
                error = USB_FAILURE;
                break;
        }

        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_wput: End");

        return (DDI_SUCCESS);
}


/*
 * hid_wsrv :
 *      Write service routine for hid. When a message arrives through
 *      hid_wput(), it is kept in write queue to be serviced later.
 */
static int
hid_wsrv(queue_t *q)
{
        hid_state_t     *hidp = (hid_state_t *)q->q_ptr;
        int             error;
        mblk_t          *mp;

        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_wsrv: Begin");

        mutex_enter(&hidp->hid_mutex);
        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_wsrv: dev_state: %s",
            usb_str_dev_state(hidp->hid_dev_state));

        /*
         * raise power if we are powered down. It is OK to block here since
         * we have a separate thread to process this STREAM
         */
        if (hidp->hid_dev_state == USB_DEV_PWRED_DOWN) {
                mutex_exit(&hidp->hid_mutex);
                (void) pm_raise_power(hidp->hid_dip, 0, USB_DEV_OS_FULL_PWR);
                mutex_enter(&hidp->hid_mutex);
        }

        /*
         * continue servicing all the M_CTL's till the queue is empty
         * or the device gets disconnected or till a hid_close()
         */
        while ((hidp->hid_dev_state == USB_DEV_ONLINE) &&
            (HID_STREAMS_FLAG(q, hidp) != HID_STREAMS_DISMANTLING) &&
            ((mp = getq(q)) != NULL)) {

                /* Send a message down */
                mutex_exit(&hidp->hid_mutex);
                error = hid_mctl_receive(q, mp);
                switch (error) {
                case HID_ENQUEUE:
                        /* put this mblk back on q to preserve order */
                        (void) putbq(q, mp);

                        break;
                case HID_INPROGRESS:
                        /* request has been queued to the device */

                        break;
                case HID_SUCCESS:
                case HID_FAILURE:
                default:
                        hid_pm_idle_component(hidp);

                        break;
                }
                mutex_enter(&hidp->hid_mutex);
        }
        mutex_exit(&hidp->hid_mutex);
        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_wsrv: End");

        return (DDI_SUCCESS);
}


/*
 * hid_power:
 *      power entry point
 */
static int
hid_power(dev_info_t *dip, int comp, int level)
{
        int             instance = ddi_get_instance(dip);
        hid_state_t     *hidp;
        hid_power_t     *hidpm;
        int             retval;

        hidp = ddi_get_soft_state(hid_statep, instance);

        USB_DPRINTF_L3(PRINT_MASK_PM, hidp->hid_log_handle, "hid_power:"
            " hid_state: comp=%d level=%d", comp, level);

        /* check if we are transitioning to a legal power level */
        mutex_enter(&hidp->hid_mutex);
        hidpm = hidp->hid_pm;

        if (USB_DEV_PWRSTATE_OK(hidpm->hid_pwr_states, level)) {

                USB_DPRINTF_L2(PRINT_MASK_PM, hidp->hid_log_handle,
                    "hid_power: illegal level=%d hid_pwr_states=%d",
                    level, hidpm->hid_pwr_states);

                mutex_exit(&hidp->hid_mutex);

                return (DDI_FAILURE);
        }

        switch (level) {
        case USB_DEV_OS_PWR_OFF:
                retval = hid_pwrlvl0(hidp);
                break;
        case USB_DEV_OS_PWR_1:
                retval = hid_pwrlvl1(hidp);
                break;
        case USB_DEV_OS_PWR_2:
                retval = hid_pwrlvl2(hidp);
                break;
        case USB_DEV_OS_FULL_PWR:
                retval = hid_pwrlvl3(hidp);
                break;
        default:
                retval = USB_FAILURE;
                break;
        }

        mutex_exit(&hidp->hid_mutex);

        return ((retval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
}


/*
 * hid_interrupt_pipe_callback:
 *      Callback function for the hid intr pipe. This function is called by
 *      USBA when a buffer has been filled. This driver does not cook the data,
 *      it just sends the message up.
 */
static void
hid_interrupt_pipe_callback(usb_pipe_handle_t pipe, usb_intr_req_t *req)
{
        hid_state_t *hidp = (hid_state_t *)req->intr_client_private;
        queue_t *q;

        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_interrupt_pipe_callback: ph = 0x%p req = 0x%p",
            (void *)pipe, (void *)req);

        hid_pm_busy_component(hidp);

        mutex_enter(&hidp->hid_mutex);

        /*
         * If hid_close() is in progress, we shouldn't try accessing queue
         * Otherwise indicate that a putnext is going to happen, so
         * if close after this, that should wait for the putnext to finish.
         */
        if (HID_STREAMS_FLAG(hidp->hid_inuse_rq, hidp) ==
            HID_STREAMS_OPEN) {
                /*
                 * Check if data can be put to the next queue.
                 */
                if (!canputnext(hidp->hid_inuse_rq)) {
                        USB_DPRINTF_L2(PRINT_MASK_ALL, hidp->hid_log_handle,
                            "Buffer flushed when overflowed.");

                        /* Flush the queue above */
                        hid_flush(hidp->hid_inuse_rq);
                        mutex_exit(&hidp->hid_mutex);
                } else {
                        q = hidp->hid_inuse_rq;
                        mutex_exit(&hidp->hid_mutex);

                        /* Put data upstream */
                        putnext(q, req->intr_data);

                        /* usb_free_intr_req should not free data */
                        req->intr_data = NULL;
                }
        } else {
                mutex_exit(&hidp->hid_mutex);
        }

        /* free request and data */
        usb_free_intr_req(req);
        hid_pm_idle_component(hidp);
}


/*
 * hid_default_pipe_callback :
 *      Callback routine for the asynchronous control transfer
 *      Called from hid_send_async_ctrl_request() where we open
 *      the pipe in exclusive mode
 */
static void
hid_default_pipe_callback(usb_pipe_handle_t pipe, usb_ctrl_req_t *req)
{
        hid_default_pipe_arg_t *hid_default_pipe_arg =
            (hid_default_pipe_arg_t *)req->ctrl_client_private;
        queue_t         *wq = hid_default_pipe_arg->hid_default_pipe_arg_queue;
        queue_t         *rq = RD(wq);
        hid_state_t     *hidp = (hid_state_t *)rq->q_ptr;
        mblk_t          *mctl_mp;
        mblk_t          *data = NULL;

        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_default_pipe_callback: "
            "ph = 0x%p, req = 0x%p, data= 0x%p",
            (void *)pipe, (void *)req, (void *)data);

        ASSERT((req->ctrl_cb_flags & USB_CB_INTR_CONTEXT) == 0);

        if (req->ctrl_data) {
                data = req->ctrl_data;
                req->ctrl_data = NULL;
        }

        /*
         * Free the b_cont of the original message that was sent down.
         */
        mctl_mp = hid_default_pipe_arg->hid_default_pipe_arg_mblk;
        freemsg(mctl_mp->b_cont);

        /* chain the mblk received to the original & send it up */
        mctl_mp->b_cont = data;

        if (canputnext(rq)) {
                putnext(rq, mctl_mp);
        } else {
                freemsg(mctl_mp); /* avoid leak */
        }

        /*
         * Free the argument for the asynchronous callback
         */
        kmem_free(hid_default_pipe_arg, sizeof (hid_default_pipe_arg_t));

        /*
         * Free the control pipe request structure.
         */
        usb_free_ctrl_req(req);

        mutex_enter(&hidp->hid_mutex);
        hidp->hid_default_pipe_req--;
        ASSERT(hidp->hid_default_pipe_req >= 0);
        mutex_exit(&hidp->hid_mutex);

        hid_pm_idle_component(hidp);
        qenable(wq);
}


/*
 * hid_interrupt_pipe_exception_callback:
 *      Exception callback routine for interrupt pipe. If there is any data,
 *      destroy it. No threads are waiting for the exception callback.
 */
/*ARGSUSED*/
static void
hid_interrupt_pipe_exception_callback(usb_pipe_handle_t pipe,
    usb_intr_req_t *req)
{
        hid_state_t     *hidp = (hid_state_t *)req->intr_client_private;
        mblk_t          *data = req->intr_data;
        usb_cb_flags_t  flags = req->intr_cb_flags;
        int             rval;

        USB_DPRINTF_L2(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_interrupt_pipe_exception_callback: "
            "completion_reason = 0x%x, data = 0x%p, flag = 0x%x",
            req->intr_completion_reason, (void *)data, req->intr_cb_flags);

        ASSERT((req->intr_cb_flags & USB_CB_INTR_CONTEXT) == 0);

        if (((flags & USB_CB_FUNCTIONAL_STALL) != 0) &&
            ((flags & USB_CB_STALL_CLEARED) == 0)) {
                USB_DPRINTF_L2(PRINT_MASK_ALL,
                    hidp->hid_log_handle,
                    "hid_interrupt_pipe_exception_callback: "
                    "unable to clear stall.  flags = 0x%x",
                    req->intr_cb_flags);
        }

        mutex_enter(&hidp->hid_mutex);

        switch (req->intr_completion_reason) {
        case USB_CR_STOPPED_POLLING:
        case USB_CR_PIPE_CLOSING:
        default:

                break;
        case USB_CR_PIPE_RESET:
        case USB_CR_NO_RESOURCES:
                if ((hidp->hid_dev_state == USB_DEV_ONLINE) &&
                    ((rval = hid_start_intr_polling(hidp)) !=
                    USB_SUCCESS)) {
                        USB_DPRINTF_L2(PRINT_MASK_ALL, hidp->hid_log_handle,
                            "unable to restart interrupt poll. rval = %d",
                            rval);
                }

                break;
        }

        mutex_exit(&hidp->hid_mutex);

        usb_free_intr_req(req);
}


/*
 * hid_default_pipe_exception_callback:
 *      Exception callback routine for default pipe.
 */
/*ARGSUSED*/
static void
hid_default_pipe_exception_callback(usb_pipe_handle_t pipe,
    usb_ctrl_req_t *req)
{
        hid_default_pipe_arg_t *hid_default_pipe_arg =
            (hid_default_pipe_arg_t *)req->ctrl_client_private;
        queue_t         *wq = hid_default_pipe_arg->hid_default_pipe_arg_queue;
        queue_t         *rq = RD(wq);
        hid_state_t     *hidp = (hid_state_t *)rq->q_ptr;
        usb_cr_t        ctrl_completion_reason = req->ctrl_completion_reason;
        mblk_t          *mp, *data = NULL;

        USB_DPRINTF_L2(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_default_pipe_exception_callback: "
            "completion_reason = 0x%x, data = 0x%p, flag = 0x%x",
            ctrl_completion_reason, (void *)data, req->ctrl_cb_flags);

        ASSERT((req->ctrl_cb_flags & USB_CB_INTR_CONTEXT) == 0);

        mp = hid_default_pipe_arg->hid_default_pipe_arg_mblk;

        /*
         * Pass an error message up. Reuse existing mblk.
         */
        if (canputnext(rq)) {
                mp->b_datap->db_type = M_ERROR;
                mp->b_rptr = mp->b_datap->db_base;
                mp->b_wptr = mp->b_rptr + sizeof (char);
                *mp->b_rptr = EIO;
                putnext(rq, mp);
        } else {
                freemsg(mp);
        }

        kmem_free(hid_default_pipe_arg, sizeof (hid_default_pipe_arg_t));

        mutex_enter(&hidp->hid_mutex);
        hidp->hid_default_pipe_req--;
        ASSERT(hidp->hid_default_pipe_req >= 0);
        mutex_exit(&hidp->hid_mutex);

        qenable(wq);
        usb_free_ctrl_req(req);
        hid_pm_idle_component(hidp);
}


/*
 * event handling:
 *
 * hid_reconnect_event_callback:
 *      the device was disconnected but this instance not detached, probably
 *      because the device was busy
 *
 *      If the same device, continue with restoring state
 */
static int
hid_restore_state_event_callback(dev_info_t *dip)
{
        hid_state_t     *hidp = (hid_state_t *)ddi_get_soft_state(hid_statep,
            ddi_get_instance(dip));

        ASSERT(hidp != NULL);

        USB_DPRINTF_L3(PRINT_MASK_EVENTS, hidp->hid_log_handle,
            "hid_restore_state_event_callback: dip=0x%p", (void *)dip);

        hid_restore_device_state(dip, hidp);

        return (USB_SUCCESS);
}


/*
 * hid_cpr_suspend
 *      Fail suspend if we can't finish outstanding i/o activity.
 */
static int
hid_cpr_suspend(hid_state_t *hidp)
{
        int             rval, prev_state;
        int             retval = USB_FAILURE;

        USB_DPRINTF_L4(PRINT_MASK_EVENTS, hidp->hid_log_handle,
            "hid_cpr_suspend: dip=0x%p", (void *)hidp->hid_dip);

        mutex_enter(&hidp->hid_mutex);
        switch (hidp->hid_dev_state) {
        case USB_DEV_ONLINE:
        case USB_DEV_PWRED_DOWN:
                prev_state = hidp->hid_dev_state;
                hidp->hid_dev_state = USB_DEV_SUSPENDED;
                mutex_exit(&hidp->hid_mutex);

                /* drain all request outstanding on the default control pipe */
                rval = usb_pipe_drain_reqs(hidp->hid_dip,
                    hidp->hid_default_pipe, hid_default_pipe_drain_timeout,
                    USB_FLAGS_SLEEP, NULL, 0);

                /* fail checkpoint if we haven't finished the job yet */
                mutex_enter(&hidp->hid_mutex);
                if ((rval != USB_SUCCESS) || (hidp->hid_default_pipe_req > 0)) {
                        USB_DPRINTF_L2(PRINT_MASK_EVENTS, hidp->hid_log_handle,
                            "hid_cpr_suspend: "
                            "device busy - can't checkpoint");

                        /* fall back to previous state */
                        hidp->hid_dev_state = prev_state;
                } else {
                        retval = USB_SUCCESS;
                        hid_save_device_state(hidp);
                }

                break;
        case USB_DEV_DISCONNECTED:
                hidp->hid_dev_state = USB_DEV_SUSPENDED;
                hid_save_device_state(hidp);
                retval = USB_SUCCESS;
                break;
        case USB_DEV_SUSPENDED:
        default:
                USB_DPRINTF_L2(PRINT_MASK_EVENTS, hidp->hid_log_handle,
                    "hid_cpr_suspend: Illegal dev state: %d",
                    hidp->hid_dev_state);

                break;
        }
        mutex_exit(&hidp->hid_mutex);

        if ((retval == USB_SUCCESS) && hidp->hid_ugen_hdl != NULL) {
                retval = usb_ugen_detach(hidp->hid_ugen_hdl,
                    DDI_SUSPEND);
        }

        return (retval);
}


static void
hid_cpr_resume(hid_state_t *hidp)
{
        USB_DPRINTF_L4(PRINT_MASK_EVENTS, hidp->hid_log_handle,
            "hid_cpr_resume: dip=0x%p", (void *)hidp->hid_dip);

        hid_restore_device_state(hidp->hid_dip, hidp);

        if (hidp->hid_ugen_hdl != NULL) {
                (void) usb_ugen_attach(hidp->hid_ugen_hdl, DDI_RESUME);
        }
}


/*
 * hid_disconnect_event_callback:
 *      The device has been disconnected. We either wait for
 *      detach or a reconnect event. Close all pipes and timeouts.
 */
static int
hid_disconnect_event_callback(dev_info_t *dip)
{
        hid_state_t     *hidp;
        mblk_t          *mp;

        hidp = (hid_state_t *)ddi_get_soft_state(hid_statep,
            ddi_get_instance(dip));
        ASSERT(hidp != NULL);

        USB_DPRINTF_L4(PRINT_MASK_EVENTS, hidp->hid_log_handle,
            "hid_disconnect_event_callback: dip=0x%p", (void *)dip);

        mutex_enter(&hidp->hid_mutex);
        switch (hidp->hid_dev_state) {
        case USB_DEV_ONLINE:
        case USB_DEV_PWRED_DOWN:
                hidp->hid_dev_state = USB_DEV_DISCONNECTED;
                if (HID_IS_OPEN(hidp)) {

                        USB_DPRINTF_L2(PRINT_MASK_EVENTS, hidp->hid_log_handle,
                            "busy device has been disconnected");
                }
                hid_save_device_state(hidp);

                /*
                 * Notify applications about device removal, this only
                 * applies to an external (aka. physical) open. For an
                 * internal open, consconfig_dacf closes the queue.
                 */
                if (hidp->hid_external_flag == HID_STREAMS_OPEN) {
                        queue_t *q = hidp->hid_external_rq;
                        mutex_exit(&hidp->hid_mutex);
                        mp = allocb(sizeof (uchar_t), BPRI_HI);
                        if (mp != NULL) {
                                mp->b_datap->db_type = M_ERROR;
                                mp->b_rptr = mp->b_datap->db_base;
                                mp->b_wptr = mp->b_rptr + sizeof (char);
                                *mp->b_rptr = ENODEV;
                                putnext(q, mp);
                        }
                        mutex_enter(&hidp->hid_mutex);
                }

                break;
        case USB_DEV_SUSPENDED:
                /* we remain suspended */

                break;
        default:
                USB_DPRINTF_L2(PRINT_MASK_EVENTS, hidp->hid_log_handle,
                    "hid_disconnect_event_callback: Illegal dev state: %d",
                    hidp->hid_dev_state);

                break;
        }
        mutex_exit(&hidp->hid_mutex);

        return (USB_SUCCESS);
}


/*
 * hid_power_change_callback:
 *      Async callback function to notify pm_raise_power completion
 *      after hid_power entry point is called.
 */
static void
hid_power_change_callback(void *arg, int rval)
{
        hid_state_t     *hidp;
        queue_t         *wq;

        hidp = (hid_state_t *)arg;

        USB_DPRINTF_L4(PRINT_MASK_PM, hidp->hid_log_handle,
            "hid_power_change_callback - rval: %d", rval);

        mutex_enter(&hidp->hid_mutex);
        hidp->hid_pm->hid_raise_power = B_FALSE;

        if (hidp->hid_dev_state == USB_DEV_ONLINE) {
                wq = WR(hidp->hid_inuse_rq);
                mutex_exit(&hidp->hid_mutex);

                qenable(wq);

        } else {
                mutex_exit(&hidp->hid_mutex);
        }
}


/*
 * hid_parse_hid_descr:
 *      Parse the hid descriptor, check after interface and after
 *      endpoint descriptor
 */
static size_t
hid_parse_hid_descr(usb_hid_descr_t *ret_descr, size_t ret_buf_len,
    usb_alt_if_data_t *altif_data, usb_ep_data_t *ep_data)
{
        usb_cvs_data_t *cvs;
        int             which_cvs;

        for (which_cvs = 0; which_cvs < altif_data->altif_n_cvs; which_cvs++) {
                cvs = &altif_data->altif_cvs[which_cvs];
                if (cvs->cvs_buf == NULL) {
                        continue;
                }
                if (cvs->cvs_buf[1] == USB_DESCR_TYPE_HID) {
                        return (usb_parse_data("ccscccs",
                            cvs->cvs_buf, cvs->cvs_buf_len,
                            (void *)ret_descr,
                            (size_t)ret_buf_len));
                }
        }

        /* now try after endpoint */
        for (which_cvs = 0; which_cvs < ep_data->ep_n_cvs; which_cvs++) {
                cvs = &ep_data->ep_cvs[which_cvs];
                if (cvs->cvs_buf == NULL) {
                        continue;
                }
                if (cvs->cvs_buf[1] == USB_DESCR_TYPE_HID) {
                        return (usb_parse_data("ccscccs",
                            cvs->cvs_buf, cvs->cvs_buf_len,
                            (void *)ret_descr,
                            (size_t)ret_buf_len));
                }
        }

        return (USB_PARSE_ERROR);
}


/*
 * hid_parse_hid_descr_failure:
 *      If parsing of hid descriptor failed and the device is
 *      a keyboard or mouse, use predefined length and packet size.
 */
static int
hid_parse_hid_descr_failure(hid_state_t *hidp)
{
        /*
         * Parsing hid descriptor failed, probably because the
         * device did not return a valid hid descriptor. Check to
         * see if this is a keyboard or mouse. If so, use the
         * predefined hid descriptor length and packet size.
         * Otherwise, detach and return failure.
         */
        USB_DPRINTF_L1(PRINT_MASK_ATTA, hidp->hid_log_handle,
            "Parsing of hid descriptor failed");

        if (hidp->hid_if_descr.bInterfaceProtocol == KEYBOARD_PROTOCOL) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, hidp->hid_log_handle,
                    "Set hid descriptor length to predefined "
                    "USB_KB_HID_DESCR_LENGTH for keyboard.");

                /* device is a keyboard */
                hidp->hid_hid_descr.wReportDescriptorLength =
                    USB_KB_HID_DESCR_LENGTH;

                hidp->hid_packet_size = USBKPSZ;

        } else if (hidp->hid_if_descr.bInterfaceProtocol ==
            MOUSE_PROTOCOL) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, hidp->hid_log_handle,
                    "Set hid descriptor length to predefined "
                    "USB_MS_HID_DESCR_LENGTH for mouse.");

                /* device is a mouse */
                hidp->hid_hid_descr.wReportDescriptorLength =
                    USB_MS_HID_DESCR_LENGTH;

                hidp->hid_packet_size = USBMSSZ;
        } else {

                return (USB_FAILURE);
        }

        return (USB_SUCCESS);
}


/*
 * hid_handle_report_descriptor:
 *      Get the report descriptor, call hidparser routine to parse
 *      it and query the hidparser tree to get the packet size
 */
static int
hid_handle_report_descriptor(hid_state_t *hidp, int interface)
{
        usb_cr_t                completion_reason;
        usb_cb_flags_t          cb_flags;
        mblk_t                  *data = NULL;
        hidparser_packet_info_t hpack;
        int                     i;
        usb_ctrl_setup_t setup = {
            USB_DEV_REQ_DEV_TO_HOST |   /* bmRequestType */
            USB_DEV_REQ_RCPT_IF,
            USB_REQ_GET_DESCR,          /* bRequest */
            USB_CLASS_DESCR_TYPE_REPORT, /* wValue */
            0,                          /* wIndex: interface, fill in later */
            0,                          /* wLength, fill in later  */
            0                           /* attributes */
            };

        /*
         * Parsing hid desciptor was successful earlier.
         * Get Report Descriptor
         */
        setup.wIndex = (uint16_t)interface;
        setup.wLength = hidp->hid_hid_descr.wReportDescriptorLength;
        if (usb_pipe_ctrl_xfer_wait(hidp->hid_default_pipe,
            &setup,
            &data,                              /* data */
            &completion_reason, &cb_flags, 0) != USB_SUCCESS) {

                USB_DPRINTF_L2(PRINT_MASK_ATTA, hidp->hid_log_handle,
                    "Failed to receive the Report Descriptor");
                freemsg(data);

                return (USB_FAILURE);

        } else {
                int n =  hidp->hid_hid_descr.wReportDescriptorLength;

                ASSERT(data);

                /* Print the report descriptor */
                for (i = 0; i < n; i++) {
                        USB_DPRINTF_L3(PRINT_MASK_ATTA, hidp->hid_log_handle,
                            "Index = %d\tvalue =0x%x", i,
                            (int)(data->b_rptr[i]));
                }

                /* Get Report Descriptor was successful */
                if (hidparser_parse_report_descriptor(
                    data->b_rptr,
                    hidp->hid_hid_descr.wReportDescriptorLength,
                    &hidp->hid_hid_descr,
                    &hidp->hid_report_descr) == HIDPARSER_SUCCESS) {

                        /* find max intr-in xfer length */
                        hidparser_find_max_packet_size_from_report_descriptor(
                            hidp->hid_report_descr, &hpack);
                        /* round up to the nearest byte */
                        hidp->hid_packet_size = (hpack.max_packet_size + 7) / 8;

                        /* if report id is used, add more more byte for it */
                        if (hpack.report_id != HID_REPORT_ID_UNDEFINED) {
                                hidp->hid_packet_size++;
                        }
                } else {
                        USB_DPRINTF_L1(PRINT_MASK_ATTA, hidp->hid_log_handle,
                            "Invalid Report Descriptor");
                        freemsg(data);

                        return (USB_FAILURE);
                }

                freemsg(data);

                return (USB_SUCCESS);
        }
}


/*
 * hid_set_idle:
 *      Make a clas specific request to SET_IDLE.
 *      In this case send no reports if state has not changed.
 *      See HID 7.2.4.
 */
/*ARGSUSED*/
static void
hid_set_idle(hid_state_t *hidp)
{
        usb_cr_t        completion_reason;
        usb_cb_flags_t  cb_flags;
        usb_ctrl_setup_t setup = {
            USB_DEV_REQ_HOST_TO_DEV |   /* bmRequestType */
            USB_DEV_REQ_TYPE_CLASS |
            USB_DEV_REQ_RCPT_IF,
            SET_IDLE,                   /* bRequest */
            DURATION,                   /* wValue */
            0,                          /* wIndex: interface, fill in later */
            0,                          /* wLength */
            0                           /* attributes */
            };

        USB_DPRINTF_L4(PRINT_MASK_ATTA, hidp->hid_log_handle,
            "hid_set_idle: Begin");

        setup.wIndex = hidp->hid_if_descr.bInterfaceNumber;
        if (usb_pipe_ctrl_xfer_wait(
            hidp->hid_default_pipe,
            &setup,
            NULL,                       /* no data to send. */
            &completion_reason, &cb_flags, 0) != USB_SUCCESS) {

                USB_DPRINTF_L2(PRINT_MASK_ATTA, hidp->hid_log_handle,
                    "Failed while trying to set idle,"
                    "cr = %d, cb_flags = 0x%x\n",
                    completion_reason, cb_flags);
        }
        USB_DPRINTF_L4(PRINT_MASK_ATTA, hidp->hid_log_handle,
            "hid_set_idle: End");
}


/*
 * hid_set_protocol:
 *      Initialize the device to set the preferred protocol
 */
/*ARGSUSED*/
static void
hid_set_protocol(hid_state_t *hidp, int protocol)
{
        usb_cr_t        completion_reason;
        usb_cb_flags_t  cb_flags;
        usb_ctrl_setup_t setup;

        USB_DPRINTF_L4(PRINT_MASK_ATTA, hidp->hid_log_handle,
            "hid_set_protocol(%d): Begin", protocol);

        /* initialize the setup request */
        setup.bmRequestType = USB_DEV_REQ_HOST_TO_DEV |
            USB_DEV_REQ_TYPE_CLASS | USB_DEV_REQ_RCPT_IF;
        setup.bRequest = SET_PROTOCOL;
        setup.wValue = (uint16_t)protocol;
        setup.wIndex = hidp->hid_if_descr.bInterfaceNumber;
        setup.wLength = 0;
        setup.attrs = 0;
        if (usb_pipe_ctrl_xfer_wait(
            hidp->hid_default_pipe,     /* bmRequestType */
            &setup,
            NULL,                       /* no data to send */
            &completion_reason, &cb_flags, 0) != USB_SUCCESS) {
                /*
                 * Some devices fail to follow the specification
                 * and instead of STALLing, they continously
                 * NAK the SET_IDLE command. We need to reset
                 * the pipe then, so that ohci doesn't panic.
                 */
                USB_DPRINTF_L2(PRINT_MASK_ATTA, hidp->hid_log_handle,
                    "Failed while trying to set protocol:%d,"
                    "cr =  %d cb_flags = 0x%x\n",
                    completion_reason, cb_flags, protocol);
        }

        USB_DPRINTF_L4(PRINT_MASK_ATTA, hidp->hid_log_handle,
            "hid_set_protocol: End");
}


/*
 * hid_detach_cleanup:
 *      called by attach and detach for cleanup.
 */
static void
hid_detach_cleanup(dev_info_t *dip, hid_state_t *hidp)
{
        int     flags = hidp->hid_attach_flags;
        int     rval;
        hid_power_t     *hidpm;

        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_detach_cleanup: Begin");

        if ((hidp->hid_attach_flags & HID_LOCK_INIT) == 0) {

                goto done;
        }

        /*
         * Disable the event callbacks first, after this point, event
         * callbacks will never get called. Note we shouldn't hold
         * mutex while unregistering events because there may be a
         * competing event callback thread. Event callbacks are done
         * with ndi mutex held and this can cause a potential deadlock.
         */
        usb_unregister_event_cbs(dip, &hid_events);

        mutex_enter(&hidp->hid_mutex);

        hidpm = hidp->hid_pm;

        USB_DPRINTF_L2(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_detach_cleanup: hidpm=0x%p", (void *)hidpm);

        if (hidpm && (hidp->hid_dev_state != USB_DEV_DISCONNECTED)) {

                mutex_exit(&hidp->hid_mutex);
                hid_pm_busy_component(hidp);
                if (hid_is_pm_enabled(dip) == USB_SUCCESS) {

                        if (hidpm->hid_wakeup_enabled) {

                                /* First bring the device to full power */
                                (void) pm_raise_power(dip, 0,
                                    USB_DEV_OS_FULL_PWR);

                                /* Disable remote wakeup */
                                rval = usb_handle_remote_wakeup(dip,
                                    USB_REMOTE_WAKEUP_DISABLE);

                                if (rval != DDI_SUCCESS) {
                                        USB_DPRINTF_L2(PRINT_MASK_ALL,
                                            hidp->hid_log_handle,
                                            "hid_detach_cleanup: "
                                            "disble remote wakeup failed, "
                                            "rval= %d", rval);
                                }
                        }

                        (void) pm_lower_power(dip, 0, USB_DEV_OS_PWR_OFF);
                }
                hid_pm_idle_component(hidp);
                mutex_enter(&hidp->hid_mutex);
        }

        if (hidpm) {
                freemsg(hidpm->hid_pm_pwrup);
                kmem_free(hidpm, sizeof (hid_power_t));
                hidp->hid_pm = NULL;
        }

        if (hidp->hid_ugen_hdl != NULL) {
                rval = usb_ugen_detach(hidp->hid_ugen_hdl, DDI_DETACH);
                VERIFY0(rval);
                usb_ugen_release_hdl(hidp->hid_ugen_hdl);
        }

        mutex_exit(&hidp->hid_mutex);

        if (hidp->hid_report_descr != NULL) {
                (void) hidparser_free_report_descriptor_handle(
                    hidp->hid_report_descr);
        }

        if (flags & HID_MINOR_NODES) {
                ddi_remove_minor_node(dip, NULL);
        }

        mutex_destroy(&hidp->hid_mutex);

        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_detach_cleanup: End");

done:
        usb_client_detach(dip, hidp->hid_dev_data);
        usb_free_log_hdl(hidp->hid_log_handle);
        ddi_soft_state_free(hid_statep, hidp->hid_instance);

        ddi_prop_remove_all(dip);
}


/*
 * hid_start_intr_polling:
 *      Allocate an interrupt request structure, initialize,
 *      and start interrupt transfers.
 */
static int
hid_start_intr_polling(hid_state_t *hidp)
{
        usb_intr_req_t  *req;
        int rval = USB_SUCCESS;

        USB_DPRINTF_L4(PRINT_MASK_PM, hidp->hid_log_handle,
            "hid_start_intr_polling: "
            "dev_state=%s internal_str_flag=%d external_str_flag=%d ph=0x%p",
            usb_str_dev_state(hidp->hid_dev_state), hidp->hid_internal_flag,
            hidp->hid_external_flag, (void *)hidp->hid_interrupt_pipe);

        if (HID_IS_OPEN(hidp) && (hidp->hid_interrupt_pipe != NULL)) {
                /*
                 * initialize interrupt pipe request structure
                 */
                req = usb_alloc_intr_req(hidp->hid_dip, 0, USB_FLAGS_SLEEP);
                req->intr_client_private = (usb_opaque_t)hidp;
                req->intr_attributes = USB_ATTRS_SHORT_XFER_OK |
                    USB_ATTRS_AUTOCLEARING;
                req->intr_len = hidp->hid_packet_size;
                req->intr_cb = hid_interrupt_pipe_callback;
                req->intr_exc_cb = hid_interrupt_pipe_exception_callback;

                /*
                 * Start polling on the interrupt pipe.
                 */
                mutex_exit(&hidp->hid_mutex);

                if ((rval = usb_pipe_intr_xfer(hidp->hid_interrupt_pipe, req,
                    USB_FLAGS_SLEEP)) != USB_SUCCESS) {
                        USB_DPRINTF_L2(PRINT_MASK_PM, hidp->hid_log_handle,
                            "hid_start_intr_polling failed: rval = %d",
                            rval);
                        usb_free_intr_req(req);
                }

                mutex_enter(&hidp->hid_mutex);
        }

        USB_DPRINTF_L4(PRINT_MASK_PM, hidp->hid_log_handle,
            "hid_start_intr_polling: done, rval = %d", rval);

        return (rval);
}


/*
 * hid_close_intr_pipe:
 *      close the interrupt pipe after draining all callbacks
 */
static void
hid_close_intr_pipe(hid_state_t *hidp)
{
        USB_DPRINTF_L4(PRINT_MASK_CLOSE, hidp->hid_log_handle,
            "hid_close_intr_pipe: Begin");

        if (hidp->hid_interrupt_pipe) {
                /*
                 * Close the interrupt pipe
                 */
                mutex_exit(&hidp->hid_mutex);
                usb_pipe_close(hidp->hid_dip, hidp->hid_interrupt_pipe,
                    USB_FLAGS_SLEEP, NULL, NULL);
                mutex_enter(&hidp->hid_mutex);
                hidp->hid_interrupt_pipe = NULL;
        }
        USB_DPRINTF_L4(PRINT_MASK_CLOSE, hidp->hid_log_handle,
            "hid_close_intr_pipe: End");
}


/*
 * hid_mctl_receive:
 *      Handle M_CTL messages from upper stream.  If
 *      we don't understand the command, free message.
 */
static int
hid_mctl_receive(register queue_t *q, register mblk_t *mp)
{
        hid_state_t     *hidp = (hid_state_t *)q->q_ptr;
        struct iocblk   *iocp;
        int             error = HID_FAILURE;
        uchar_t         request_type;
        hid_req_t       *hid_req_data = NULL;
        hid_polled_input_callback_t hid_polled_input;
        hid_vid_pid_t   hid_vid_pid;

        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_mctl_receive");

        iocp = (struct iocblk *)mp->b_rptr;

        switch (iocp->ioc_cmd) {
        case HID_SET_REPORT:
                /* FALLTHRU */
        case HID_SET_IDLE:
                /* FALLTHRU */
        case HID_SET_PROTOCOL:
                request_type = USB_DEV_REQ_HOST_TO_DEV |
                    USB_DEV_REQ_RCPT_IF | USB_DEV_REQ_TYPE_CLASS;

                break;
        case HID_GET_REPORT:
                /* FALLTHRU */
        case HID_GET_IDLE:
                /* FALLTHRU */
        case HID_GET_PROTOCOL:
                request_type = USB_DEV_REQ_DEV_TO_HOST |
                    USB_DEV_REQ_RCPT_IF | USB_DEV_REQ_TYPE_CLASS;

                break;
        case HID_GET_PARSER_HANDLE:
                if (canputnext(RD(q))) {
                        freemsg(mp->b_cont);
                        mp->b_cont = hid_data2mblk(
                            (uchar_t *)&hidp->hid_report_descr,
                            sizeof (hidp->hid_report_descr));
                        if (mp->b_cont == NULL) {
                                /*
                                 * can't allocate mblk, indicate
                                 * that nothing is returned
                                 */
                                iocp->ioc_count = 0;
                        } else {
                                iocp->ioc_count =
                                    sizeof (hidp->hid_report_descr);
                        }
                        qreply(q, mp);

                        return (HID_SUCCESS);
                } else {

                        /* retry */
                        return (HID_ENQUEUE);
                }
        case HID_GET_VID_PID:
                if (canputnext(RD(q))) {
                        freemsg(mp->b_cont);

                        hid_vid_pid.VendorId =
                            hidp->hid_dev_descr->idVendor;
                        hid_vid_pid.ProductId =
                            hidp->hid_dev_descr->idProduct;

                        mp->b_cont = hid_data2mblk(
                            (uchar_t *)&hid_vid_pid, sizeof (hid_vid_pid_t));
                        if (mp->b_cont == NULL) {
                                /*
                                 * can't allocate mblk, indicate that nothing
                                 * is being returned.
                                 */
                                iocp->ioc_count = 0;
                        } else {
                                iocp->ioc_count =
                                    sizeof (hid_vid_pid_t);
                        }
                        qreply(q, mp);

                        return (HID_SUCCESS);
                } else {

                        /* retry */
                        return (HID_ENQUEUE);
                }
        case HID_OPEN_POLLED_INPUT:
                if (canputnext(RD(q))) {
                        freemsg(mp->b_cont);

                        /* Initialize the structure */
                        hid_polled_input.hid_polled_version =
                            HID_POLLED_INPUT_V0;
                        hid_polled_input.hid_polled_read = hid_polled_read;
                        hid_polled_input.hid_polled_input_enter =
                            hid_polled_input_enter;
                        hid_polled_input.hid_polled_input_exit =
                            hid_polled_input_exit;
                        hid_polled_input.hid_polled_input_handle =
                            (hid_polled_handle_t)hidp;

                        mp->b_cont = hid_data2mblk(
                            (uchar_t *)&hid_polled_input,
                            sizeof (hid_polled_input_callback_t));
                        if (mp->b_cont == NULL) {
                                /*
                                 * can't allocate mblk, indicate that nothing
                                 * is being returned.
                                 */
                                iocp->ioc_count = 0;
                        } else {
                                /* Call down into USBA */
                                (void) hid_polled_input_init(hidp);

                                iocp->ioc_count =
                                    sizeof (hid_polled_input_callback_t);
                        }
                        qreply(q, mp);

                        return (HID_SUCCESS);
                } else {

                        /* retry */
                        return (HID_ENQUEUE);
                }
        case HID_CLOSE_POLLED_INPUT:
                /* Call down into USBA */
                (void) hid_polled_input_fini(hidp);

                iocp->ioc_count = 0;
                qreply(q, mp);

                return (HID_SUCCESS);
        default:
                hid_qreply_merror(q, mp, EINVAL);

                return (HID_FAILURE);
        }

        /*
         * These (device executable) commands require a hid_req_t.
         * Make sure one is present
         */
        if (mp->b_cont == NULL) {
                hid_qreply_merror(q, mp, EINVAL);

                return (error);
        } else {
                hid_req_data = (hid_req_t *)mp->b_cont->b_rptr;
                if ((iocp->ioc_cmd == HID_SET_REPORT) &&
                    (hid_req_data->hid_req_wLength == 0)) {
                        hid_qreply_merror(q, mp, EINVAL);

                        return (error);
                }
        }

        /*
         * Check is version no. is correct. This
         * is coming from the user
         */
        if (hid_req_data->hid_req_version_no != HID_VERSION_V_0) {
                hid_qreply_merror(q, mp, EINVAL);

                return (error);
        }

        mutex_enter(&hidp->hid_mutex);
        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_mctl_receive: dev_state=%s",
            usb_str_dev_state(hidp->hid_dev_state));

        switch (hidp->hid_dev_state) {
        case USB_DEV_PWRED_DOWN:
                /*
                 * get the device full powered. We get a callback
                 * which enables the WQ and kicks off IO
                 */
                hidp->hid_dev_state = USB_DEV_HID_POWER_CHANGE;
                mutex_exit(&hidp->hid_mutex);
                if (usb_req_raise_power(hidp->hid_dip, 0,
                    USB_DEV_OS_FULL_PWR, hid_power_change_callback,
                    hidp, 0) != USB_SUCCESS) {
                        /* we retry raising power in wsrv */
                        mutex_enter(&hidp->hid_mutex);
                        hidp->hid_dev_state = USB_DEV_PWRED_DOWN;
                        mutex_exit(&hidp->hid_mutex);
                }
                error = HID_ENQUEUE;

                break;
        case USB_DEV_HID_POWER_CHANGE:
                mutex_exit(&hidp->hid_mutex);
                error = HID_ENQUEUE;

                break;
        case USB_DEV_ONLINE:
                if (HID_STREAMS_FLAG(q, hidp) != HID_STREAMS_DISMANTLING) {
                        /* Send a message down */
                        mutex_exit(&hidp->hid_mutex);
                        error = hid_mctl_execute_cmd(q, request_type,
                            hid_req_data, mp);
                        if (error == HID_FAILURE) {
                                hid_qreply_merror(q, mp, EIO);
                        }
                } else {
                        mutex_exit(&hidp->hid_mutex);
                        hid_qreply_merror(q, mp, EIO);
                }

                break;
        default:
                mutex_exit(&hidp->hid_mutex);
                hid_qreply_merror(q, mp, EIO);

                break;
        }

        return (error);
}


/*
 * hid_mctl_execute_cmd:
 *      Send the command to the device.
 */
static int
hid_mctl_execute_cmd(queue_t *q, int request_type, hid_req_t *hid_req_data,
    mblk_t *mp)
{
        int             request_index;
        struct iocblk   *iocp;
        hid_default_pipe_arg_t  *def_pipe_arg;
        hid_state_t     *hidp = (hid_state_t *)q->q_ptr;

        iocp = (struct iocblk *)mp->b_rptr;
        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_mctl_execute_cmd: iocp=0x%p", (void *)iocp);

        request_index = hidp->hid_if_descr.bInterfaceNumber;

        /*
         * Set up the argument to be passed back to hid
         * when the asynchronous control callback is
         * executed.
         */
        def_pipe_arg = kmem_zalloc(sizeof (hid_default_pipe_arg_t), 0);

        if (def_pipe_arg == NULL) {

                return (HID_FAILURE);
        }

        def_pipe_arg->hid_default_pipe_arg_queue = q;
        def_pipe_arg->hid_default_pipe_arg_mctlmsg.ioc_cmd = iocp->ioc_cmd;
        def_pipe_arg->hid_default_pipe_arg_mctlmsg.ioc_count = 0;
        def_pipe_arg->hid_default_pipe_arg_mblk = mp;

        /*
         * Send the command down to USBA through default
         * pipe.
         */
        if (hid_send_async_ctrl_request(def_pipe_arg, hid_req_data,
            request_type, iocp->ioc_cmd, request_index) != USB_SUCCESS) {

                kmem_free(def_pipe_arg, sizeof (hid_default_pipe_arg_t));

                return (HID_FAILURE);
        }

        return (HID_INPROGRESS);
}


/*
 * hid_send_async_ctrl_request:
 *      Send an asynchronous control request to USBA.  Since hid is a STREAMS
 *      driver, it is not allowed to wait in its entry points except for the
 *      open and close entry points.  Therefore, hid must use the asynchronous
 *      USBA calls.
 */
static int
hid_send_async_ctrl_request(hid_default_pipe_arg_t *hid_default_pipe_arg,
    hid_req_t *hid_request, uchar_t request_type, int request_request,
    ushort_t request_index)
{
        queue_t         *q = hid_default_pipe_arg->hid_default_pipe_arg_queue;
        hid_state_t     *hidp = (hid_state_t *)q->q_ptr;
        usb_ctrl_req_t  *ctrl_req;
        int             rval;
        size_t          length = 0;

        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_send_async_ctrl_request: "
            "rq_type=%d rq_rq=%d index=%d",
            request_type, request_request, request_index);

        mutex_enter(&hidp->hid_mutex);
        hidp->hid_default_pipe_req++;
        mutex_exit(&hidp->hid_mutex);

        /*
         * Note that ctrl_req->ctrl_data should be allocated by usba
         * only for IN requests. OUT request(e.g SET_REPORT) can have a
         * non-zero wLength value but ctrl_data would be allocated by
         * client for them.
         */
        if (hid_request->hid_req_wLength >= MAX_REPORT_DATA) {
                USB_DPRINTF_L2(PRINT_MASK_ALL, hidp->hid_log_handle,
                    "hid_req_wLength is exceeded");
                return (USB_FAILURE);
        }
        if ((request_type & USB_DEV_REQ_DIR_MASK) == USB_DEV_REQ_DEV_TO_HOST) {
                length = hid_request->hid_req_wLength;
        }

        if ((ctrl_req = usb_alloc_ctrl_req(hidp->hid_dip, length, 0)) == NULL) {
                USB_DPRINTF_L2(PRINT_MASK_ALL, hidp->hid_log_handle,
                    "unable to alloc ctrl req. async trans failed");
                mutex_enter(&hidp->hid_mutex);
                hidp->hid_default_pipe_req--;
                ASSERT(hidp->hid_default_pipe_req >= 0);
                mutex_exit(&hidp->hid_mutex);

                return (USB_FAILURE);
        }

        if ((request_type & USB_DEV_REQ_DIR_MASK) == USB_DEV_REQ_HOST_TO_DEV) {
                ASSERT((length == 0) && (ctrl_req->ctrl_data == NULL));
        }

        ctrl_req->ctrl_bmRequestType    = request_type;
        ctrl_req->ctrl_bRequest         = (uint8_t)request_request;
        ctrl_req->ctrl_wValue           = hid_request->hid_req_wValue;
        ctrl_req->ctrl_wIndex           = request_index;
        ctrl_req->ctrl_wLength          = hid_request->hid_req_wLength;
        /* host to device: create a msg from hid_req_data */
        if ((request_type & USB_DEV_REQ_DIR_MASK) == USB_DEV_REQ_HOST_TO_DEV) {
                mblk_t *pblk = allocb(hid_request->hid_req_wLength, BPRI_HI);
                if (pblk == NULL) {
                        usb_free_ctrl_req(ctrl_req);
                        return (USB_FAILURE);
                }
                bcopy(hid_request->hid_req_data, pblk->b_wptr,
                    hid_request->hid_req_wLength);
                pblk->b_wptr += hid_request->hid_req_wLength;
                ctrl_req->ctrl_data = pblk;
        }
        ctrl_req->ctrl_attributes       = USB_ATTRS_AUTOCLEARING;
        ctrl_req->ctrl_client_private   = (usb_opaque_t)hid_default_pipe_arg;
        ctrl_req->ctrl_cb               = hid_default_pipe_callback;
        ctrl_req->ctrl_exc_cb           = hid_default_pipe_exception_callback;

        if ((rval = usb_pipe_ctrl_xfer(hidp->hid_default_pipe,
            ctrl_req, 0)) != USB_SUCCESS) {
                mutex_enter(&hidp->hid_mutex);
                hidp->hid_default_pipe_req--;
                ASSERT(hidp->hid_default_pipe_req >= 0);
                mutex_exit(&hidp->hid_mutex);

                usb_free_ctrl_req(ctrl_req);
                USB_DPRINTF_L2(PRINT_MASK_ALL, hidp->hid_log_handle,
                    "usb_pipe_ctrl_xfer() failed. rval = %d", rval);

                return (USB_FAILURE);
        }

        return (USB_SUCCESS);
}

/*
 * hid_create_pm_components:
 *      Create the pm components required for power management.
 *      For keyboard/mouse, the components is created only if the device
 *      supports a remote wakeup.
 *      For other hid devices they are created unconditionally.
 */
static void
hid_create_pm_components(dev_info_t *dip, hid_state_t *hidp)
{
        hid_power_t     *hidpm;
        uint_t          pwr_states;

        USB_DPRINTF_L4(PRINT_MASK_PM, hidp->hid_log_handle,
            "hid_create_pm_components: Begin");

        /* Allocate the state structure */
        hidpm = kmem_zalloc(sizeof (hid_power_t), KM_SLEEP);
        hidp->hid_pm = hidpm;
        hidpm->hid_state = hidp;
        hidpm->hid_raise_power = B_FALSE;
        hidpm->hid_pm_capabilities = 0;
        hidpm->hid_current_power = USB_DEV_OS_FULL_PWR;

        switch (hidp->hid_if_descr.bInterfaceProtocol) {
        case KEYBOARD_PROTOCOL:
        case MOUSE_PROTOCOL:
                hidpm->hid_pm_strategy = HID_PM_ACTIVITY;
                if ((hid_is_pm_enabled(dip) == USB_SUCCESS) &&
                    (usb_handle_remote_wakeup(dip, USB_REMOTE_WAKEUP_ENABLE) ==
                    USB_SUCCESS)) {

                        USB_DPRINTF_L3(PRINT_MASK_PM, hidp->hid_log_handle,
                            "hid_create_pm_components: Remote Wakeup Enabled");

                        if (usb_create_pm_components(dip, &pwr_states) ==
                            USB_SUCCESS) {
                                hidpm->hid_wakeup_enabled = 1;
                                hidpm->hid_pwr_states = (uint8_t)pwr_states;
                        }
                }

                break;
        default:
                hidpm->hid_pm_strategy = HID_PM_OPEN_CLOSE;
                if ((hid_is_pm_enabled(dip) == USB_SUCCESS) &&
                    (usb_create_pm_components(dip, &pwr_states) ==
                    USB_SUCCESS)) {
                        hidpm->hid_wakeup_enabled = 0;
                        hidpm->hid_pwr_states = (uint8_t)pwr_states;
                }

                break;
        }

        USB_DPRINTF_L4(PRINT_MASK_PM, hidp->hid_log_handle,
            "hid_create_pm_components: END");
}


/*
 * hid_is_pm_enabled
 *      Check if the device is pm enabled. Always enable
 *      pm on the new SUN mouse
 */
static int
hid_is_pm_enabled(dev_info_t *dip)
{
        hid_state_t     *hidp = ddi_get_soft_state(hid_statep,
            ddi_get_instance(dip));

        if (strcmp(ddi_node_name(dip), "mouse") == 0) {
                /* check for overrides first */
                if (hid_pm_mouse ||
                    (ddi_prop_exists(DDI_DEV_T_ANY, dip,
                    (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
                    "hid-mouse-pm-enable") == 1)) {

                        return (USB_SUCCESS);
                }

                /*
                 * Always enable PM for 1.05 or greater SUN mouse
                 * hidp->hid_dev_descr won't be NULL.
                 */
                if ((hidp->hid_dev_descr->idVendor ==
                    HID_SUN_MOUSE_VENDOR_ID) &&
                    (hidp->hid_dev_descr->idProduct ==
                    HID_SUN_MOUSE_PROD_ID) &&
                    (hidp->hid_dev_descr->bcdDevice >=
                    HID_SUN_MOUSE_BCDDEVICE)) {

                        return (USB_SUCCESS);
                }
        } else {

                return (USB_SUCCESS);
        }

        return (USB_FAILURE);
}


/*
 * hid_save_device_state
 *      Save the current device/driver state.
 */
static void
hid_save_device_state(hid_state_t *hidp)
{
        struct iocblk   *mctlmsg;
        mblk_t          *mp;
        queue_t         *q;

        USB_DPRINTF_L4(PRINT_MASK_EVENTS, hidp->hid_log_handle,
            "hid_save_device_state");

        if (!(HID_IS_OPEN(hidp)))
                return;

        if (hidp->hid_internal_flag == HID_STREAMS_OPEN) {
                /*
                 * Send MCTLs up indicating that the device
                 * will loose its state
                 */
                q = hidp->hid_internal_rq;

                mutex_exit(&hidp->hid_mutex);
                if (canputnext(q)) {
                        mp = allocb(sizeof (struct iocblk), BPRI_HI);
                        if (mp != NULL) {
                                mp->b_datap->db_type = M_CTL;
                                mctlmsg = (struct iocblk *)
                                    mp->b_datap->db_base;
                                mctlmsg->ioc_cmd = HID_DISCONNECT_EVENT;
                                mctlmsg->ioc_count = 0;
                                putnext(q, mp);
                        }
                }
                mutex_enter(&hidp->hid_mutex);
        }

        if (hidp->hid_external_flag == HID_STREAMS_OPEN) {
                /*
                 * Send MCTLs up indicating that the device
                 * will loose its state
                 */
                q = hidp->hid_external_rq;

                mutex_exit(&hidp->hid_mutex);
                if (canputnext(q)) {
                        mp = allocb(sizeof (struct iocblk), BPRI_HI);
                        if (mp != NULL) {
                                mp->b_datap->db_type = M_CTL;
                                mctlmsg = (struct iocblk *)
                                    mp->b_datap->db_base;
                                mctlmsg->ioc_cmd = HID_DISCONNECT_EVENT;
                                mctlmsg->ioc_count = 0;
                                putnext(q, mp);
                        }
                }
                mutex_enter(&hidp->hid_mutex);
        }

        mutex_exit(&hidp->hid_mutex);
        /* stop polling on the intr pipe */
        usb_pipe_stop_intr_polling(hidp->hid_interrupt_pipe, USB_FLAGS_SLEEP);
        mutex_enter(&hidp->hid_mutex);
}


/*
 * hid_restore_device_state:
 *      Set original configuration of the device.
 *      Reopen intr pipe.
 *      Enable wrq - this starts new transactions on the control pipe.
 */
static void
hid_restore_device_state(dev_info_t *dip, hid_state_t *hidp)
{
        int             rval;
        hid_power_t     *hidpm;
        struct iocblk   *mctlmsg;
        mblk_t          *mp;
        queue_t         *q;

        hid_pm_busy_component(hidp);
        mutex_enter(&hidp->hid_mutex);

        USB_DPRINTF_L4(PRINT_MASK_ATTA, hidp->hid_log_handle,
            "hid_restore_device_state: %s",
            usb_str_dev_state(hidp->hid_dev_state));

        hidpm = hidp->hid_pm;
        mutex_exit(&hidp->hid_mutex);

        /* First bring the device to full power */
        (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);

        mutex_enter(&hidp->hid_mutex);
        if (hidp->hid_dev_state == USB_DEV_ONLINE) {
                /*
                 * We failed the checkpoint, there is no need to restore
                 * the device state
                 */
                mutex_exit(&hidp->hid_mutex);
                hid_pm_idle_component(hidp);

                return;
        }
        mutex_exit(&hidp->hid_mutex);


        /* Check if we are talking to the same device */
        if (usb_check_same_device(dip, hidp->hid_log_handle, USB_LOG_L2,
            PRINT_MASK_ALL, USB_CHK_BASIC|USB_CHK_CFG, NULL) != USB_SUCCESS) {

                /* change the device state from suspended to disconnected */
                mutex_enter(&hidp->hid_mutex);
                hidp->hid_dev_state = USB_DEV_DISCONNECTED;
                mutex_exit(&hidp->hid_mutex);
                hid_pm_idle_component(hidp);
                goto nodev;
        }

        hid_set_idle(hidp);
        hid_set_protocol(hidp, SET_REPORT_PROTOCOL);

        mutex_enter(&hidp->hid_mutex);
        /* if the device had remote wakeup earlier, enable it again */
        if (hidpm->hid_wakeup_enabled) {
                mutex_exit(&hidp->hid_mutex);

                if ((rval = usb_handle_remote_wakeup(hidp->hid_dip,
                    USB_REMOTE_WAKEUP_ENABLE)) != USB_SUCCESS) {
                        USB_DPRINTF_L2(PRINT_MASK_ATTA,
                            hidp->hid_log_handle,
                            "usb_handle_remote_wakeup failed (%d)", rval);
                }

                mutex_enter(&hidp->hid_mutex);
        }

        /*
         * restart polling on the interrupt pipe only if the device
         * was previously operational (open)
         */
        if (HID_IS_OPEN(hidp)) {
                if ((rval = hid_start_intr_polling(hidp)) != USB_SUCCESS) {
                        USB_DPRINTF_L3(PRINT_MASK_ATTA, hidp->hid_log_handle,
                            "hid_restore_device_state:"
                            "unable to restart intr pipe poll"
                            " rval = %d ", rval);
                        /*
                         * change the device state from
                         * suspended to disconnected
                         */
                        hidp->hid_dev_state = USB_DEV_DISCONNECTED;
                        mutex_exit(&hidp->hid_mutex);
                        hid_pm_idle_component(hidp);
                        goto nodev;
                }

                if (hidp->hid_dev_state == USB_DEV_DISCONNECTED) {
                        USB_DPRINTF_L2(PRINT_MASK_EVENTS, hidp->hid_log_handle,
                            "device is being re-connected");
                }

                /* set the device state ONLINE */
                hidp->hid_dev_state = USB_DEV_ONLINE;

                /* inform upstream modules that the device is back */
                if (hidp->hid_internal_flag == HID_STREAMS_OPEN) {
                        q = hidp->hid_internal_rq;

                        mutex_exit(&hidp->hid_mutex);
                        if (canputnext(q)) {
                                mp = allocb(sizeof (struct iocblk), BPRI_HI);
                                if (mp != NULL) {
                                        mp->b_datap->db_type = M_CTL;
                                        mctlmsg = (struct iocblk *)
                                            mp->b_datap->db_base;
                                        mctlmsg->ioc_cmd = HID_CONNECT_EVENT;
                                        mctlmsg->ioc_count = 0;
                                        putnext(q, mp);
                                }
                        }
                        /* enable write side q */
                        qenable(WR(q));
                        mutex_enter(&hidp->hid_mutex);
                }

                if (hidp->hid_external_flag == HID_STREAMS_OPEN) {
                        q = hidp->hid_external_rq;

                        mutex_exit(&hidp->hid_mutex);
                        if (canputnext(q)) {
                                mp = allocb(sizeof (struct iocblk), BPRI_HI);
                                if (mp != NULL) {
                                        mp->b_datap->db_type = M_CTL;
                                        mctlmsg = (struct iocblk *)
                                            mp->b_datap->db_base;
                                        mctlmsg->ioc_cmd = HID_CONNECT_EVENT;
                                        mctlmsg->ioc_count = 0;
                                        putnext(q, mp);
                                }
                        }
                        /* enable write side q */
                        qenable(WR(q));
                        mutex_enter(&hidp->hid_mutex);
                }
        } else {
                /* set the device state ONLINE */
                hidp->hid_dev_state = USB_DEV_ONLINE;
        }

        mutex_exit(&hidp->hid_mutex);
        hid_pm_idle_component(hidp);
        return;

nodev:
        /*
         * Notify applications about device removal. This only
         * applies to an external (aka. physical) open. Not sure how to
         * notify consconfig to close the internal minor node.
         */
        mutex_enter(&hidp->hid_mutex);

        if ((q = hidp->hid_external_rq) == NULL) {
                mutex_exit(&hidp->hid_mutex);
                return;
        }

        mutex_exit(&hidp->hid_mutex);
        mp = allocb(sizeof (uchar_t), BPRI_HI);
        if (mp != NULL) {
                mp->b_datap->db_type = M_ERROR;
                mp->b_rptr = mp->b_datap->db_base;
                mp->b_wptr = mp->b_rptr + sizeof (char);
                *mp->b_rptr = ENODEV;
                putnext(q, mp);
        }
}


/*
 * hid_qreply_merror:
 *      Pass an error message up.
 */
static void
hid_qreply_merror(queue_t *q, mblk_t *mp, uchar_t errval)
{
        mp->b_datap->db_type = M_ERROR;
        if (mp->b_cont) {
                freemsg(mp->b_cont);
                mp->b_cont = NULL;
        }
        mp->b_rptr = mp->b_datap->db_base;
        mp->b_wptr = mp->b_rptr + sizeof (char);
        *mp->b_rptr = errval;

        qreply(q, mp);
}


/*
 * hid_data2mblk:
 *      Form an mblk from the given data
 */
static mblk_t *
hid_data2mblk(uchar_t *buf, int len)
{
        mblk_t  *mp = NULL;

        if (len >= 0) {
                mp = allocb(len, BPRI_HI);
                if (mp) {
                        bcopy(buf, mp->b_datap->db_base, len);
                        mp->b_wptr += len;
                }
        }

        return (mp);
}


/*
 * hid_flush :
 *      Flush data already sent upstreams to client module.
 */
static void
hid_flush(queue_t *q)
{
        /*
         * Flush pending data already sent upstream
         */
        if ((q != NULL) && (q->q_next != NULL)) {
                (void) putnextctl1(q, M_FLUSH, FLUSHR);
        }
}


static void
hid_pm_busy_component(hid_state_t *hid_statep)
{
        ASSERT(!mutex_owned(&hid_statep->hid_mutex));

        if (hid_statep->hid_pm != NULL) {
                mutex_enter(&hid_statep->hid_mutex);
                hid_statep->hid_pm->hid_pm_busy++;

                USB_DPRINTF_L4(PRINT_MASK_PM, hid_statep->hid_log_handle,
                    "hid_pm_busy_component: %d",
                    hid_statep->hid_pm->hid_pm_busy);

                mutex_exit(&hid_statep->hid_mutex);
                if (pm_busy_component(hid_statep->hid_dip, 0) != DDI_SUCCESS) {
                        mutex_enter(&hid_statep->hid_mutex);
                        hid_statep->hid_pm->hid_pm_busy--;

                        USB_DPRINTF_L2(PRINT_MASK_PM,
                            hid_statep->hid_log_handle,
                            "hid_pm_busy_component failed: %d",
                            hid_statep->hid_pm->hid_pm_busy);

                        mutex_exit(&hid_statep->hid_mutex);
                }

        }
}


static void
hid_pm_idle_component(hid_state_t *hid_statep)
{
        ASSERT(!mutex_owned(&hid_statep->hid_mutex));

        if (hid_statep->hid_pm != NULL) {
                if (pm_idle_component(hid_statep->hid_dip, 0) == DDI_SUCCESS) {
                        mutex_enter(&hid_statep->hid_mutex);
                        ASSERT(hid_statep->hid_pm->hid_pm_busy > 0);
                        hid_statep->hid_pm->hid_pm_busy--;

                        USB_DPRINTF_L4(PRINT_MASK_PM,
                            hid_statep->hid_log_handle,
                            "hid_pm_idle_component: %d",
                            hid_statep->hid_pm->hid_pm_busy);

                        mutex_exit(&hid_statep->hid_mutex);
                }
        }
}


/*
 * hid_pwrlvl0:
 *      Functions to handle power transition for various levels
 *      These functions act as place holders to issue USB commands
 *      to the devices to change their power levels
 */
static int
hid_pwrlvl0(hid_state_t *hidp)
{
        hid_power_t     *hidpm;
        int             rval;
        struct iocblk   *mctlmsg;
        mblk_t          *mp_lowpwr, *mp_fullpwr;
        queue_t         *q;

        hidpm = hidp->hid_pm;

        switch (hidp->hid_dev_state) {
        case USB_DEV_ONLINE:
                /* Deny the powerdown request if the device is busy */
                if (hidpm->hid_pm_busy != 0) {

                        return (USB_FAILURE);
                }

                if (HID_IS_OPEN(hidp)) {
                        q = hidp->hid_inuse_rq;
                        mutex_exit(&hidp->hid_mutex);
                        if (canputnext(q)) {
                                /* try to preallocate mblks */
                                mp_lowpwr = allocb(
                                    (int)sizeof (struct iocblk), BPRI_HI);
                                mp_fullpwr = allocb(
                                    (int)sizeof (struct iocblk), BPRI_HI);
                                if ((mp_lowpwr != NULL) &&
                                    (mp_fullpwr != NULL)) {
                                        /* stop polling */
                                        usb_pipe_stop_intr_polling(
                                            hidp->hid_interrupt_pipe,
                                            USB_FLAGS_SLEEP);

                                        /*
                                         * Send an MCTL up indicating that
                                         * we are powering off
                                         */
                                        mp_lowpwr->b_datap->db_type = M_CTL;
                                        mctlmsg = (struct iocblk *)
                                            mp_lowpwr->b_datap->db_base;
                                        mctlmsg->ioc_cmd = HID_POWER_OFF;
                                        mctlmsg->ioc_count = 0;
                                        putnext(q, mp_lowpwr);

                                        /* save the full powr mblk */
                                        mutex_enter(&hidp->hid_mutex);
                                        hidpm->hid_pm_pwrup = mp_fullpwr;
                                } else {
                                        /*
                                         * Since we failed to allocate one
                                         * or more mblks, we fail attempt
                                         * to go into low power this time
                                         */
                                        freemsg(mp_lowpwr);
                                        freemsg(mp_fullpwr);
                                        mutex_enter(&hidp->hid_mutex);

                                        return (USB_FAILURE);
                                }
                        } else {
                                /*
                                 * Since we can't send an mblk up,
                                 * we fail this attempt to go to low power
                                 */
                                mutex_enter(&hidp->hid_mutex);

                                return (USB_FAILURE);
                        }
                }

                mutex_exit(&hidp->hid_mutex);
                /* Issue USB D3 command to the device here */
                rval = usb_set_device_pwrlvl3(hidp->hid_dip);
                ASSERT(rval == USB_SUCCESS);

                mutex_enter(&hidp->hid_mutex);
                hidp->hid_dev_state = USB_DEV_PWRED_DOWN;
                hidpm->hid_current_power = USB_DEV_OS_PWR_OFF;

                /* FALLTHRU */
        case USB_DEV_DISCONNECTED:
        case USB_DEV_SUSPENDED:
        case USB_DEV_PWRED_DOWN:
        default:
                break;
        }

        return (USB_SUCCESS);
}


/* ARGSUSED */
static int
hid_pwrlvl1(hid_state_t *hidp)
{
        int             rval;

        /* Issue USB D2 command to the device here */
        rval = usb_set_device_pwrlvl2(hidp->hid_dip);
        ASSERT(rval == USB_SUCCESS);

        return (USB_FAILURE);
}


/* ARGSUSED */
static int
hid_pwrlvl2(hid_state_t *hidp)
{
        int             rval;

        rval = usb_set_device_pwrlvl1(hidp->hid_dip);
        ASSERT(rval == USB_SUCCESS);

        return (USB_FAILURE);
}


static int
hid_pwrlvl3(hid_state_t *hidp)
{
        hid_power_t     *hidpm;
        int             rval;
        struct iocblk   *mctlmsg;
        mblk_t          *mp;
        queue_t         *q;

        hidpm = hidp->hid_pm;

        switch (hidp->hid_dev_state) {
        case USB_DEV_HID_POWER_CHANGE:
        case USB_DEV_PWRED_DOWN:
                /* Issue USB D0 command to the device here */
                rval = usb_set_device_pwrlvl0(hidp->hid_dip);
                ASSERT(rval == USB_SUCCESS);

                if (HID_IS_OPEN(hidp)) {
                        /* restart polling on intr pipe */
                        rval = hid_start_intr_polling(hidp);
                        if (rval != USB_SUCCESS) {
                                USB_DPRINTF_L2(PRINT_MASK_EVENTS,
                                    hidp->hid_log_handle,
                                    "unable to restart intr polling rval = %d",
                                    rval);

                                return (USB_FAILURE);
                        }

                        /* Send an MCTL up indicating device in full  power */
                        q = hidp->hid_inuse_rq;
                        mp = hidpm->hid_pm_pwrup;
                        hidpm->hid_pm_pwrup = NULL;
                        mutex_exit(&hidp->hid_mutex);
                        if (canputnext(q)) {
                                mp->b_datap->db_type = M_CTL;
                                mctlmsg = (struct iocblk *)
                                    mp->b_datap->db_base;
                                mctlmsg->ioc_cmd = HID_FULL_POWER;
                                mctlmsg->ioc_count = 0;
                                putnext(q, mp);
                        } else {
                                freemsg(mp);
                        }
                        mutex_enter(&hidp->hid_mutex);
                }

                hidp->hid_dev_state = USB_DEV_ONLINE;
                hidpm->hid_current_power = USB_DEV_OS_FULL_PWR;

                /* FALLTHRU */
        case USB_DEV_DISCONNECTED:
        case USB_DEV_SUSPENDED:
        case USB_DEV_ONLINE:

                return (USB_SUCCESS);
        default:
                USB_DPRINTF_L2(PRINT_MASK_EVENTS, hidp->hid_log_handle,
                    "hid_pwrlvl3: Improper State");

                return (USB_FAILURE);
        }
}


/*
 * hid_polled_input_init :
 *      This routine calls down to the lower layers to initialize any state
 *      information.  This routine initializes the lower layers for input.
 */
static int
hid_polled_input_init(hid_state_t *hidp)
{
        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_polled_input_init");

        /*
         * Call the lower layers to intialize any state information
         * that they will need to provide the polled characters.
         */
        if (usb_console_input_init(hidp->hid_dip, hidp->hid_interrupt_pipe,
            &hidp->hid_polled_raw_buf,
            &hidp->hid_polled_console_info) != USB_SUCCESS) {
                /*
                 * If for some reason the lower layers cannot initialized, then
                 * bail.
                 */
                (void) hid_polled_input_fini(hidp);

                return (USB_FAILURE);
        }

        return (USB_SUCCESS);
}


/*
 * hid_polled_input_fini:
 *      This routine is called when we are done using this device as an input
 *      device.
 */
static int
hid_polled_input_fini(hid_state_t *hidp)
{
        USB_DPRINTF_L4(PRINT_MASK_ALL, hidp->hid_log_handle,
            "hid_polled_input_fini");

        /*
         * Call the lower layers to free any state information
         * only if polled input has been initialised.
         */
        if ((hidp->hid_polled_console_info) &&
            (usb_console_input_fini(hidp->hid_polled_console_info) !=
            USB_SUCCESS)) {

                return (USB_FAILURE);
        }
        hidp->hid_polled_console_info = NULL;

        return (USB_SUCCESS);
}


/*
 * hid_polled_input_enter:
 *      This is the routine that is called in polled mode to save the USB
 *      state information before using the USB keyboard as an input device.
 *      This routine, and all of the routines that it calls, are responsible
 *      for saving any state information so that it can be restored when
 *      polling mode is over.
 */
static int
/* ARGSUSED */
hid_polled_input_enter(hid_polled_handle_t hid_polled_inputp)
{
        hid_state_t *hidp = (hid_state_t *)hid_polled_inputp;

        /*
         * Call the lower layers to tell them to save any state information.
         */
        (void) usb_console_input_enter(hidp->hid_polled_console_info);

        return (USB_SUCCESS);
}


/*
 * hid_polled_read :
 *      This is the routine that is called in polled mode when it wants to read
 *      a character.  We will call to the lower layers to see if there is any
 *      input data available.  If there is USB scancodes available, we will
 *      give them back.
 */
static int
hid_polled_read(hid_polled_handle_t hid_polled_input, uchar_t **buffer)
{
        hid_state_t *hidp = (hid_state_t *)hid_polled_input;
        uint_t                  num_bytes;

        /*
         * Call the lower layers to get the character from the controller.
         * The lower layers will return the number of characters that
         * were put in the raw buffer.  The address of the raw buffer
         * was passed down to the lower layers during hid_polled_init.
         */
        if (usb_console_read(hidp->hid_polled_console_info,
            &num_bytes) != USB_SUCCESS) {

                return (0);
        }

        _NOTE(NO_COMPETING_THREADS_NOW);

        *buffer = hidp->hid_polled_raw_buf;

        _NOTE(COMPETING_THREADS_NOW);

        /*
         * Return the number of characters that were copied into the
         * polled buffer.
         */
        return (num_bytes);
}


/*
 * hid_polled_input_exit :
 *      This is the routine that is called in polled mode  when it is giving up
 *      control of the USB keyboard.  This routine, and the lower layer routines
 *      that it calls, are responsible for restoring the controller state to the
 *      state it was in before polled mode.
 */
static int
hid_polled_input_exit(hid_polled_handle_t hid_polled_inputp)
{
        hid_state_t *hidp = (hid_state_t *)hid_polled_inputp;

        /*
         * Call the lower layers to restore any state information.
         */
        (void) usb_console_input_exit(hidp->hid_polled_console_info);

        return (0);
}