xref: /onnv-gate/usr/src/uts/common/io/usb/hcd/ehci/ehci_hub.c (revision 12819:b9f8177eb4e2)

/*
 * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * EHCI Host Controller Driver (EHCI)
 *
 * The EHCI driver is a software driver which interfaces to the Universal
 * Serial Bus layer (USBA) and the Host Controller (HC). The interface to
 * the Host Controller is defined by the EHCI Host Controller Interface.
 *
 * This module contains the code for root hub related functions.
 *
 * NOTE:
 *
 * ONE_XFER is not supported on root hub interrupt polling
 */

#include <sys/usb/hcd/ehci/ehcid.h>
#include <sys/usb/hcd/ehci/ehci_util.h>
#include <sys/usb/usba/usba_types.h>

/* Static function prototypes */
static int	ehci_handle_set_clear_port_feature(
				ehci_state_t		*ehcip,
				uchar_t 		bRequest,
				uint16_t		wValue,
				uint16_t		port);
static void	ehci_handle_port_power(
				ehci_state_t		*ehcip,
				uint16_t		port,
				uint_t			on);
static void	ehci_handle_port_enable(
				ehci_state_t		*ehcip,
				uint16_t		port,
				uint_t			on);
static void	ehci_handle_clrchng_port_enable(
				ehci_state_t		*ehcip,
				uint16_t		port);
static void	ehci_handle_port_suspend(
				ehci_state_t		*ehcip,
				uint16_t		port,
				uint_t			on);
static void	ehci_handle_clrchng_port_suspend(
				ehci_state_t		*ehcip,
				uint16_t		port);
static void	ehci_handle_port_reset(
				ehci_state_t		*ehcip,
				uint16_t		port);
static void	ehci_root_hub_reset_occured(
				ehci_state_t		*ehcip);
static void	ehci_handle_complete_port_reset(
				ehci_state_t		*ehcip,
				uint16_t		port);
static void	ehci_handle_clear_port_connection(
				ehci_state_t		*ehcip,
				uint16_t		port);
static void	ehci_handle_clrchng_port_over_current(
				ehci_state_t		*ehcip,
				uint16_t		port);
static void	ehci_handle_get_port_status(
				ehci_state_t		*ehcip,
				uint16_t		port);
static void	ehci_handle_get_hub_descriptor(
				ehci_state_t		*ehcip);
static void	ehci_handle_get_hub_status(
				ehci_state_t		*ehcip);
static void	ehci_handle_get_device_status(
				ehci_state_t		*ehcip);
static uint_t	ehci_get_root_hub_port_status(
				ehci_state_t		*ehcip,
				uint16_t		port);
static int	ehci_is_port_owner(
				ehci_state_t		*ehcip,
				uint16_t		port);
static int	ehci_root_hub_allocate_intr_pipe_resource(
				ehci_state_t		*ehcip,
				usb_flags_t		flags);
static void	ehci_root_hub_intr_pipe_cleanup(
				ehci_state_t		*ehcip,
				usb_cr_t		completion_reason);
static void	ehci_handle_root_hub_status_change(void *arg);
static void	ehci_root_hub_hcdi_callback(
				usba_pipe_handle_data_t	*ph,
				usb_cr_t		completion_reason);


/*
 * ehci_init_root_hub:
 *
 * Initialize the root hub
 */
int
ehci_init_root_hub(ehci_state_t	*ehcip)
{
	usb_hub_descr_t		*root_hub_descr =
	    &ehcip->ehci_root_hub.rh_descr;
	uint_t			i, length, port_state;
	uint32_t		capability;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_init_root_hub:");

	/* Read the EHCI capability register */
	capability = Get_Cap(ehci_hcs_params);

	/*
	 * Build the Root hub descriptor by looking EHCI capability
	 * and operational registers.
	 */
	root_hub_descr->bDescriptorType = ROOT_HUB_DESCRIPTOR_TYPE;

	if ((capability & EHCI_HCS_NUM_PORTS) > EHCI_MAX_RH_PORTS) {

		USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_init_root_hub: Invalid no of root hub ports 0x%x",
		    capability & EHCI_HCS_NUM_PORTS);

		return (USB_FAILURE);
	}

	/* Obtain the number of downstream ports */
	root_hub_descr->bNbrPorts = capability & EHCI_HCS_NUM_PORTS;

	length = root_hub_descr->bNbrPorts / 8;

	if (length) {
		root_hub_descr->bDescLength = 7 + (2 * (length + 1));
	} else {
		root_hub_descr->bDescLength = ROOT_HUB_DESCRIPTOR_LENGTH;
	}

	/*
	 * Obtain the number of Classic or Companion USB 1.1 (OHCI/UHCI)
	 * Host Controllers information.
	 */
	ehcip->ehci_root_hub.rh_companion_controllers = (capability &
	    EHCI_HCS_NUM_COMP_CTRLS) >> EHCI_HCS_NUM_COMP_CTRL_SHIFT;

	/*
	 * Determine the Power Switching Mode
	 *
	 * EHCI Specification, root hub supports either no power switching
	 * individual port power switching. Also determine the Over-current
	 * Protection Mode.
	 */
	if (capability & EHCI_HCS_PORT_POWER_CONTROL) {
		/* Each port is powered individually */
		root_hub_descr-> wHubCharacteristics =
		    HUB_CHARS_INDIVIDUAL_PORT_POWER;

		/* Assume individual overcurrent reporting */
		root_hub_descr->wHubCharacteristics |=
		    HUB_CHARS_INDIV_OVER_CURRENT;

		/* Each port will start off in the POWERED_OFF mode */
		port_state = POWERED_OFF;
	} else {
		/* The ports are powered when the ctlr is powered */
		root_hub_descr->
		    wHubCharacteristics = HUB_CHARS_NO_POWER_SWITCHING;

		/* Assume no overcurrent reporting */
		root_hub_descr->wHubCharacteristics |=
		    HUB_CHARS_NO_OVER_CURRENT;

		port_state = DISCONNECTED;
	}

	/* Look at the port indicator information */
	if (capability & EHCI_HCS_PORT_INDICATOR) {
		root_hub_descr->wHubCharacteristics |= HUB_CHARS_PORT_INDICATOR;
	}

	/*
	 * Obtain the power on to power good time of the ports.
	 *
	 * Assume: Zero for this field.
	 */
	root_hub_descr->bPwrOn2PwrGood = 2;

	USB_DPRINTF_L3(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "Power on to power good %d", root_hub_descr->bPwrOn2PwrGood);

	/* Indicate if the device is removable */
	root_hub_descr->DeviceRemovable = 0;

	/* Set PortPowerControlMask to zero */
	root_hub_descr->PortPwrCtrlMask = 0;

	/* Set the state of each port and initialize the status */
	for (i = 0; i < root_hub_descr->bNbrPorts; i++) {

		/* Initilize state/status of each root hub port */
		ehcip->ehci_root_hub.rh_port_state[i] = port_state;
		ehcip->ehci_root_hub.rh_port_status[i] = 0;
	}

	return (USB_SUCCESS);
}


/*
 * ehci_load_root_hub_driver:
 *
 * Attach the root hub
 */
static usb_dev_descr_t ehci_root_hub_device_descriptor = {
	0x12,		/* bLength */
	0x01,		/* bDescriptorType, Device */
	0x200,		/* bcdUSB, v2.0 */
	0x09,		/* bDeviceClass */
	0x00,		/* bDeviceSubClass */
	0x01,		/* bDeviceProtocol */
	0x40,		/* bMaxPacketSize0 */
	0x00,		/* idVendor */
	0x00,		/* idProduct */
	0x00,		/* bcdDevice */
	0x00,		/* iManufacturer */
	0x00,		/* iProduct */
	0x00,		/* iSerialNumber */
	0x01		/* bNumConfigurations */
};

static uchar_t ehci_root_hub_config_descriptor[] = {
	/* One configuartion */
	0x09,		/* bLength */
	0x02,		/* bDescriptorType, Configuartion */
	0x19, 0x00,	/* wTotalLength */
	0x01,		/* bNumInterfaces */
	0x01,		/* bConfigurationValue */
	0x00,		/* iConfiguration */
	0x40,		/* bmAttributes */
	0x00,		/* MaxPower */

	/* One Interface */
	0x09,		/* bLength */
	0x04,		/* bDescriptorType, Interface */
	0x00,		/* bInterfaceNumber */
	0x00,		/* bAlternateSetting */
	0x01,		/* bNumEndpoints */
	0x09,		/* bInterfaceClass */
	0x01,		/* bInterfaceSubClass */
	0x00,		/* bInterfaceProtocol */
	0x00,		/* iInterface */

	/* One Endpoint (status change endpoint) */
	0x07,		/* bLength */
	0x05,		/* bDescriptorType, Endpoint */
	0x81,		/* bEndpointAddress */
	0x03,		/* bmAttributes */
	0x01, 0x00,	/* wMaxPacketSize, 1 +	(EHCI_MAX_RH_PORTS / 8) */
	0xff		/* bInterval */
};

int
ehci_load_root_hub_driver(ehci_state_t	*ehcip)
{
	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_load_root_hub_driver:");

	return (usba_hubdi_bind_root_hub(ehcip->ehci_dip,
	    ehci_root_hub_config_descriptor,
	    sizeof (ehci_root_hub_config_descriptor),
	    &ehci_root_hub_device_descriptor));
}


/*
 * ehci_unload_root_hub_driver:
 */
int
ehci_unload_root_hub_driver(ehci_state_t	*ehcip)
{
	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_unload_root_hub_driver:");

	return (usba_hubdi_unbind_root_hub(ehcip->ehci_dip));
}


/*
 * ehci_handle_root_hub_pipe_open:
 *
 * Handle opening of control and interrupt pipes on root hub.
 */
/* ARGSUSED */
int
ehci_handle_root_hub_pipe_open(
	usba_pipe_handle_data_t	*ph,
	usb_flags_t		usb_flags)
{
	ehci_state_t		*ehcip = ehci_obtain_state(
	    ph->p_usba_device->usb_root_hub_dip);
	usb_ep_descr_t		*eptd = &ph->p_ep;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_root_hub_pipe_open: Root hub pipe open");

	ASSERT(mutex_owned(&ehcip->ehci_int_mutex));

	switch (eptd->bmAttributes & USB_EP_ATTR_MASK) {
	case USB_EP_ATTR_CONTROL:
		/* Save control pipe handle */
		ehcip->ehci_root_hub.rh_ctrl_pipe_handle = ph;

		/* Set state of the root hub control pipe as idle */
		ehcip->ehci_root_hub.rh_ctrl_pipe_state = EHCI_PIPE_STATE_IDLE;

		ehcip->ehci_root_hub.rh_curr_ctrl_reqp = NULL;

		USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_pipe_open: Root hub control "
		    "pipe open succeeded");

		break;
	case USB_EP_ATTR_INTR:
		/* Save interrupt pipe handle */
		ehcip->ehci_root_hub.rh_intr_pipe_handle = ph;

		/* Set state of the root hub interrupt pipe as idle */
		ehcip->ehci_root_hub.rh_intr_pipe_state = EHCI_PIPE_STATE_IDLE;

		ehcip->ehci_root_hub.rh_client_intr_reqp = NULL;

		ehcip->ehci_root_hub.rh_curr_intr_reqp = NULL;

		USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_pipe_open: Root hub interrupt "
		    "pipe open succeeded");

		break;
	default:
		USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_pipe_open: Root hub pipe open"
		    "failed");

		return (USB_FAILURE);
	}

	ehcip->ehci_open_pipe_count++;

	return (USB_SUCCESS);
}


/*
 * ehci_handle_root_hub_pipe_close:
 *
 * Handle closing of control and interrupt pipes on root hub.
 */
/* ARGSUSED */
int
ehci_handle_root_hub_pipe_close(usba_pipe_handle_data_t	*ph)
{
	ehci_state_t		*ehcip = ehci_obtain_state(
	    ph->p_usba_device->usb_root_hub_dip);
	usb_ep_descr_t		*eptd = &ph->p_ep;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_root_hub_pipe_close: Root hub pipe close");

	ASSERT(mutex_owned(&ehcip->ehci_int_mutex));

	switch (eptd->bmAttributes & USB_EP_ATTR_MASK) {
	case USB_EP_ATTR_CONTROL:
		ASSERT(ehcip->ehci_root_hub.
		    rh_ctrl_pipe_state != EHCI_PIPE_STATE_CLOSE);

		/* Set state of the root hub control pipe as close */
		ehcip->ehci_root_hub.rh_ctrl_pipe_state = EHCI_PIPE_STATE_CLOSE;

		/* Set root hub control pipe handle to null */
		ehcip->ehci_root_hub.rh_ctrl_pipe_handle = NULL;

		USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_pipe_close: "
		    "Root hub control pipe close succeeded");
		break;
	case USB_EP_ATTR_INTR:
		ASSERT((eptd->bEndpointAddress & USB_EP_NUM_MASK) == 1);

		ASSERT(ehcip->ehci_root_hub.
		    rh_intr_pipe_state != EHCI_PIPE_STATE_CLOSE);

		/* Set state of the root hub interrupt pipe as close */
		ehcip->ehci_root_hub.rh_intr_pipe_state = EHCI_PIPE_STATE_CLOSE;

		/* Do interrupt pipe cleanup */
		ehci_root_hub_intr_pipe_cleanup(ehcip, USB_CR_PIPE_CLOSING);

		/* Set root hub interrupt pipe handle to null */
		ehcip->ehci_root_hub.rh_intr_pipe_handle = NULL;

		USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_pipe_close: "
		    "Root hub interrupt pipe close succeeded");

		break;
	default:
		USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_pipe_close: "
		    "Root hub pipe close failed");

		return (USB_FAILURE);
	}

	ehcip->ehci_open_pipe_count--;

	return (USB_SUCCESS);
}


/*
 * ehci_handle_root_hub_pipe_reset:
 *
 * Handle resetting of control and interrupt pipes on root hub.
 */
/* ARGSUSED */
int
ehci_handle_root_hub_pipe_reset(
	usba_pipe_handle_data_t	*ph,
	usb_flags_t		usb_flags)
{
	ehci_state_t		*ehcip = ehci_obtain_state(
	    ph->p_usba_device->usb_root_hub_dip);
	usb_ep_descr_t		*eptd = &ph->p_ep;
	int			error = USB_SUCCESS;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_root_hub_pipe_reset: Root hub pipe reset");

	mutex_enter(&ehcip->ehci_int_mutex);

	switch (eptd->bmAttributes & USB_EP_ATTR_MASK) {
	case USB_EP_ATTR_CONTROL:
		ehcip->ehci_root_hub.rh_ctrl_pipe_state = EHCI_PIPE_STATE_IDLE;

		USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_pipe_reset: Pipe reset"
		    "for the root hub control pipe successful");

		break;
	case USB_EP_ATTR_INTR:
		ASSERT((eptd->bEndpointAddress & USB_EP_NUM_MASK) == 1);

		if ((ehcip->ehci_root_hub.rh_client_intr_reqp) &&
		    (ehcip->ehci_root_hub.rh_intr_pipe_state !=
		    EHCI_PIPE_STATE_IDLE)) {

			ehcip->ehci_root_hub.
			    rh_intr_pipe_state = EHCI_PIPE_STATE_RESET;

			/* Do interrupt pipe cleanup */
			ehci_root_hub_intr_pipe_cleanup(
			    ehcip, USB_CR_PIPE_RESET);
		}

		ASSERT(ehcip->ehci_root_hub.
		    rh_intr_pipe_state == EHCI_PIPE_STATE_IDLE);

		USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_pipe_reset: "
		    "Pipe reset for root hub interrupt pipe successful");

		break;
	default:
		USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_pipe_reset: "
		    "Root hub pipe reset failed");

		error = USB_FAILURE;
		break;
	}

	mutex_exit(&ehcip->ehci_int_mutex);

	return (error);
}


/*
 * ehci_handle_root_hub_request:
 *
 * Intercept a root hub request. Handle the  root hub request through the
 * registers
 */
/* ARGSUSED */
int
ehci_handle_root_hub_request(
	ehci_state_t		*ehcip,
	usba_pipe_handle_data_t	*ph,
	usb_ctrl_req_t		*ctrl_reqp)
{
	uchar_t			bmRequestType = ctrl_reqp->ctrl_bmRequestType;
	uchar_t			bRequest = ctrl_reqp->ctrl_bRequest;
	uint16_t		wValue = ctrl_reqp->ctrl_wValue;
	uint16_t		wIndex = ctrl_reqp->ctrl_wIndex;
	uint16_t		wLength = ctrl_reqp->ctrl_wLength;
	mblk_t			*data = ctrl_reqp->ctrl_data;
	uint16_t		port = wIndex - 1;
	usb_cr_t		completion_reason;
	int			error = USB_SUCCESS;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_root_hub_request: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%p",
	    bmRequestType, bRequest, wValue, wIndex, wLength, (void *)data);

	mutex_enter(&ehcip->ehci_int_mutex);

	if (ehcip->ehci_root_hub.
	    rh_ctrl_pipe_state != EHCI_PIPE_STATE_IDLE) {

		USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_request: Pipe is not idle");

		mutex_exit(&ehcip->ehci_int_mutex);

		return (USB_FAILURE);
	}

	/* Save the current control request pointer */
	ehcip->ehci_root_hub.rh_curr_ctrl_reqp = ctrl_reqp;

	/* Set pipe state to active */
	ehcip->ehci_root_hub.rh_ctrl_pipe_state = EHCI_PIPE_STATE_ACTIVE;

	mutex_exit(&ehcip->ehci_int_mutex);

	switch (bmRequestType) {
	case HUB_GET_DEVICE_STATUS_TYPE:
		ehci_handle_get_device_status(ehcip);
		break;
	case HUB_HANDLE_PORT_FEATURE_TYPE:
		error = ehci_handle_set_clear_port_feature(ehcip,
		    bRequest, wValue, port);
		break;
	case HUB_GET_PORT_STATUS_TYPE:
		ehci_handle_get_port_status(ehcip, port);
		break;
	case HUB_CLASS_REQ_TYPE:
		switch (bRequest) {
		case USB_REQ_GET_STATUS:
			ehci_handle_get_hub_status(ehcip);
			break;
		case USB_REQ_GET_DESCR:
			ehci_handle_get_hub_descriptor(ehcip);
			break;
		default:
			USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
			    "ehci_handle_root_hub_request:"
			    "Unsupported request 0x%x", bRequest);

			error = USB_FAILURE;
			break;
		}
		break;
	default:
		USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_request: "
		    "Unsupported request 0x%x", bmRequestType);

		error = USB_FAILURE;
		break;
	}

	completion_reason = (error) ? USB_CR_NOT_SUPPORTED : USB_CR_OK;

	mutex_enter(&ehcip->ehci_int_mutex);
	ehci_root_hub_hcdi_callback(ph, completion_reason);
	mutex_exit(&ehcip->ehci_int_mutex);

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_root_hub_request: error = %d", error);

	return (USB_SUCCESS);
}


/*
 * ehci_handle_set_clear_port_feature:
 */
static int
ehci_handle_set_clear_port_feature(
	ehci_state_t		*ehcip,
	uchar_t 		bRequest,
	uint16_t		wValue,
	uint16_t		port)
{
	int			error = USB_SUCCESS;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_set_clear_port_feature: 0x%x 0x%x 0x%x",
	    bRequest, wValue, port);

	switch (bRequest) {
	case USB_REQ_SET_FEATURE:
		switch (wValue) {
		case CFS_PORT_ENABLE:
			ehci_handle_port_enable(ehcip, port, 1);
			break;
		case CFS_PORT_SUSPEND:
			ehci_handle_port_suspend(ehcip, port, 1);
			break;
		case CFS_PORT_RESET:
			ehci_handle_port_reset(ehcip, port);
			break;
		case CFS_PORT_POWER:
			ehci_handle_port_power(ehcip, port, 1);
			break;
		default:
			USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
			    "ehci_handle_set_clear_port_feature: "
			    "Unsupported request 0x%x 0x%x", bRequest, wValue);

			error = USB_FAILURE;
			break;
		}
		break;
	case USB_REQ_CLEAR_FEATURE:
		switch (wValue) {
		case CFS_PORT_ENABLE:
			ehci_handle_port_enable(ehcip, port, 0);
			break;
		case CFS_C_PORT_ENABLE:
			ehci_handle_clrchng_port_enable(ehcip, port);
			break;
		case CFS_PORT_SUSPEND:
			ehci_handle_port_suspend(ehcip, port, 0);
			break;
		case CFS_C_PORT_SUSPEND:
			ehci_handle_clrchng_port_suspend(ehcip, port);
			break;
		case CFS_C_PORT_RESET:
			ehci_handle_complete_port_reset(ehcip, port);
			break;
		case CFS_PORT_POWER:
			ehci_handle_port_power(ehcip, port, 0);
			break;
		case CFS_C_PORT_CONNECTION:
			ehci_handle_clear_port_connection(ehcip, port);
			break;
		case CFS_C_PORT_OVER_CURRENT:
			ehci_handle_clrchng_port_over_current(ehcip, port);
			break;
		default:
			USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
			    "ehci_handle_set_clear_port_feature: "
			    "Unsupported request 0x%x 0x%x", bRequest, wValue);

			error = USB_FAILURE;
			break;
		}
		break;
	default:
		USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_set_clear_port_feature: "
		    "Unsupported request 0x%x 0x%x", bRequest, wValue);

		error = USB_FAILURE;
		break;
	}

	return (error);
}


/*
 * ehci_handle_port_power:
 *
 * Turn on a root hub port.
 */
static void
ehci_handle_port_power(
	ehci_state_t		*ehcip,
	uint16_t		port,
	uint_t			on)
{
	uint_t			port_status;
	ehci_root_hub_t		*rh;

	mutex_enter(&ehcip->ehci_int_mutex);

	port_status = Get_OpReg(ehci_rh_port_status[port]) &
	    ~EHCI_RH_PORT_CLEAR_MASK;

	rh = &ehcip->ehci_root_hub;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_port_power: port = 0x%x status = 0x%x on = %d",
	    port, port_status, on);

	/* Check port is owned by ehci */
	if (ehci_is_port_owner(ehcip, port) != USB_SUCCESS) {
		mutex_exit(&ehcip->ehci_int_mutex);

		return;
	}

	if (on) {
		/* See if the port power is already on */
		if (!(port_status & EHCI_RH_PORT_POWER)) {
			/* Turn the port on */
			Set_OpReg(ehci_rh_port_status[port],
			    port_status | EHCI_RH_PORT_POWER);
		}

		rh->rh_port_status[port] = 0;
		rh->rh_port_state[port] = DISCONNECTED;
	} else {
		/* See if the port power is already OFF */
		if (port_status & EHCI_RH_PORT_POWER) {
			/* Turn-off the port */
			Set_OpReg(ehci_rh_port_status[port],
			    port_status & ~EHCI_RH_PORT_POWER);
		}

		rh->rh_port_status[port] = 0;
		rh->rh_port_state[port] = POWERED_OFF;
	}

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_port_power done: port = 0x%x status = 0x%x on = %d",
	    port, Get_OpReg(ehci_rh_port_status[port]), on);

	mutex_exit(&ehcip->ehci_int_mutex);
}


/*
 * ehci_handle_port_enable:
 *
 * Handle port enable request.
 */
static void
ehci_handle_port_enable(
	ehci_state_t		*ehcip,
	uint16_t		port,
	uint_t			on)
{
	uint_t			port_status;

	mutex_enter(&ehcip->ehci_int_mutex);

	port_status = Get_OpReg(ehci_rh_port_status[port]) &
	    ~EHCI_RH_PORT_CLEAR_MASK;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_port_enable: port = 0x%x, status = 0x%x",
	    port, port_status);

	/* Check port is owned by ehci */
	if (ehci_is_port_owner(ehcip, port) != USB_SUCCESS) {
		mutex_exit(&ehcip->ehci_int_mutex);

		return;
	}

	if (on) {
		/* See if the port enable is already on */
		if (!(port_status & EHCI_RH_PORT_ENABLE)) {
			/* Enable the port */
			Set_OpReg(ehci_rh_port_status[port],
			    port_status | EHCI_RH_PORT_ENABLE);
		}
	} else {
		/* See if the port enable is already off */
		if (port_status & EHCI_RH_PORT_ENABLE) {
			/* Disable the port */
			Set_OpReg(ehci_rh_port_status[port],
			    port_status & ~EHCI_RH_PORT_ENABLE);
		}
	}

	mutex_exit(&ehcip->ehci_int_mutex);
}


/*
 * ehci_handle_clrchng_port_enable:
 *
 * Handle clear port enable change bit.
 */
static void
ehci_handle_clrchng_port_enable(
	ehci_state_t		*ehcip,
	uint16_t		port)
{
	uint_t			port_status;

	mutex_enter(&ehcip->ehci_int_mutex);

	port_status = Get_OpReg(ehci_rh_port_status[port]) &
	    ~EHCI_RH_PORT_CLEAR_MASK;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_port_enable: port = 0x%x, status = 0x%x",
	    port, port_status);

	/* Check port is owned by ehci */
	if (ehci_is_port_owner(ehcip, port) != USB_SUCCESS) {
		mutex_exit(&ehcip->ehci_int_mutex);

		return;
	}

	/* Clear the PortEnableStatusChange Bit */
	Set_OpReg(ehci_rh_port_status[port],
	    port_status | EHCI_RH_PORT_ENABLE_CHANGE);

	mutex_exit(&ehcip->ehci_int_mutex);
}


/*
 * ehci_handle_port_suspend:
 *
 * Handle port suspend/resume request.
 */
static void
ehci_handle_port_suspend(
	ehci_state_t		*ehcip,
	uint16_t		port,
	uint_t			on)
{
	uint_t			port_status;

	mutex_enter(&ehcip->ehci_int_mutex);

	port_status = Get_OpReg(ehci_rh_port_status[port]) &
	    ~EHCI_RH_PORT_CLEAR_MASK;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_port_suspend: port = 0x%x, status = 0x%x",
	    port, port_status);

	/* Check port is owned by ehci */
	if (ehci_is_port_owner(ehcip, port) != USB_SUCCESS) {
		mutex_exit(&ehcip->ehci_int_mutex);

		return;
	}

	if (on) {
		/*
		 * Suspend port only if port is enabled and
		 * it is not already in suspend state.
		 */
		if ((port_status & EHCI_RH_PORT_ENABLE) &&
		    (!(port_status & EHCI_RH_PORT_SUSPEND))) {
			/* Suspend the port */
			Set_OpReg(ehci_rh_port_status[port],
			    port_status | EHCI_RH_PORT_SUSPEND);

			mutex_exit(&ehcip->ehci_int_mutex);

			/* Wait 10ms for port move to suspend state */
			delay(drv_usectohz(EHCI_PORT_SUSPEND_TIMEWAIT));

			return;
		}
	} else {
		/* Perform resume only if port is in suspend state */
		if (port_status & EHCI_RH_PORT_SUSPEND) {
			/* Resume the port */
			Set_OpReg(ehci_rh_port_status[port],
			    port_status | EHCI_RH_PORT_RESUME);
		}
	}

	mutex_exit(&ehcip->ehci_int_mutex);
}


/*
 * ehci_handle_clrchng_port_suspend:
 *
 * Handle port clear port suspend change bit.
 */
static void
ehci_handle_clrchng_port_suspend(
	ehci_state_t		*ehcip,
	uint16_t		port)
{
	uint_t			port_status;
	int			i;

	mutex_enter(&ehcip->ehci_int_mutex);

	port_status = Get_OpReg(ehci_rh_port_status[port]) &
	    ~EHCI_RH_PORT_CLEAR_MASK;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_clrchng_port_suspend: port = 0x%x, "
	    "status = 0x%x", port, port_status);

	/* Check port is owned by ehci */
	if (ehci_is_port_owner(ehcip, port) != USB_SUCCESS) {
		mutex_exit(&ehcip->ehci_int_mutex);

		return;
	}

	/* Return if port is not in resume state */
	if (!(port_status & EHCI_RH_PORT_RESUME)) {
		mutex_exit(&ehcip->ehci_int_mutex);

		return;
	}

	mutex_exit(&ehcip->ehci_int_mutex);

	/* Wait for 20ms to terminate resume */
	delay(drv_usectohz(EHCI_PORT_RESUME_TIMEWAIT));

	mutex_enter(&ehcip->ehci_int_mutex);

	Set_OpReg(ehci_rh_port_status[port],
	    port_status & ~EHCI_RH_PORT_RESUME);

	mutex_exit(&ehcip->ehci_int_mutex);

	/*
	 * Wait for port to return to high speed mode. It's necessary to poll
	 * for resume completion for some high-speed devices to work correctly.
	 */
	for (i = 0; i < EHCI_PORT_RESUME_RETRY_MAX; i++) {
		delay(drv_usectohz(EHCI_PORT_RESUME_COMP_TIMEWAIT));

		mutex_enter(&ehcip->ehci_int_mutex);
		port_status = Get_OpReg(ehci_rh_port_status[port]) &
		    ~EHCI_RH_PORT_CLEAR_MASK;
		mutex_exit(&ehcip->ehci_int_mutex);

		if (!(port_status & EHCI_RH_PORT_RESUME)) {
			break;
		}
	}
}


/*
 * ehci_handle_port_reset:
 *
 * Perform a port reset.
 */
static void
ehci_handle_port_reset(
	ehci_state_t		*ehcip,
	uint16_t		port)
{
	ehci_root_hub_t		*rh;
	uint_t			port_status;
	int			i;

	mutex_enter(&ehcip->ehci_int_mutex);

	/* Get the root hub structure */
	rh = &ehcip->ehci_root_hub;

	/* Get the port status information */
	port_status = Get_OpReg(ehci_rh_port_status[port]) &
	    ~EHCI_RH_PORT_CLEAR_MASK;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_port_reset: port = 0x%x status = 0x%x",
	    port, port_status);

	/* Check port is owned by ehci */
	if (ehci_is_port_owner(ehcip, port) != USB_SUCCESS) {
		mutex_exit(&ehcip->ehci_int_mutex);

		return;
	}

	if (port_status & EHCI_RH_PORT_LOW_SPEED) {
		/* Check for classic or companion host controllers */
		if (rh->rh_companion_controllers) {
			USB_DPRINTF_L3(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
			    "ehci_handle_port_reset: Low speed device "
			    "and handover this port to Companion controller");

			Set_OpReg(ehci_rh_port_status[port],
			    port_status | EHCI_RH_PORT_OWNER_CLASSIC);
		} else {
			USB_DPRINTF_L1(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
			    "Low speed device is not supported");
		}
	} else {
		Set_OpReg(ehci_rh_port_status[port],
		    ((port_status | EHCI_RH_PORT_RESET) &
		    ~EHCI_RH_PORT_ENABLE));

		mutex_exit(&ehcip->ehci_int_mutex);

		/* Wait 50ms for reset to complete */
		delay(drv_usectohz(EHCI_PORT_RESET_TIMEWAIT));

		mutex_enter(&ehcip->ehci_int_mutex);

		port_status = Get_OpReg(ehci_rh_port_status[port]) &
		    ~EHCI_RH_PORT_CLEAR_MASK;

		Set_OpReg(ehci_rh_port_status[port],
		    (port_status & ~EHCI_RH_PORT_RESET));

		mutex_exit(&ehcip->ehci_int_mutex);

		/*
		 * Wait for hardware to enable this port, if the connected
		 * usb device is high speed. It's necessary to poll for reset
		 * completion for some high-speed devices to recognized
		 * correctly.
		 */
		for (i = 0; i < EHCI_PORT_RESET_RETRY_MAX; i++) {
			delay(drv_usectohz(EHCI_PORT_RESET_COMP_TIMEWAIT));

			mutex_enter(&ehcip->ehci_int_mutex);
			port_status = Get_OpReg(ehci_rh_port_status[port]) &
			    ~EHCI_RH_PORT_CLEAR_MASK;
			mutex_exit(&ehcip->ehci_int_mutex);

			if (!(port_status & EHCI_RH_PORT_RESET)) {
				break;
			}
		}

		mutex_enter(&ehcip->ehci_int_mutex);

		port_status = Get_OpReg(ehci_rh_port_status[port]) &
		    ~EHCI_RH_PORT_CLEAR_MASK;

		/*
		 * If port is not enabled, connected device is a
		 * Full-speed usb device.
		 */
		if (!(port_status & EHCI_RH_PORT_ENABLE)) {
			/* Check for classic or companion host controllers */
			if (rh->rh_companion_controllers) {
				USB_DPRINTF_L3(PRINT_MASK_ROOT_HUB,
				    ehcip->ehci_log_hdl,
				    "ehci_handle_port_reset: Full speed device "
				    "and handover this port to Companion host "
				    "controller");

				Set_OpReg(ehci_rh_port_status[port],
				    port_status | EHCI_RH_PORT_OWNER_CLASSIC);
			} else {
				USB_DPRINTF_L1(PRINT_MASK_ROOT_HUB,
				    ehcip->ehci_log_hdl,
				    "Full speed device is not supported");
			}
		} else {
			USB_DPRINTF_L3(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
			    "ehci_handle_port_reset: High speed device ");

			port_status = Get_OpReg(ehci_rh_port_status[port]) &
			    ~EHCI_RH_PORT_CLEAR_MASK;

			/*
			 * Disable over-current, connect, and disconnect
			 * wakeup bits.
			 */
			Set_OpReg(ehci_rh_port_status[port], port_status &
			    ~(EHCI_RH_PORT_OVER_CURENT_ENABLE |
			    EHCI_RH_PORT_DISCONNECT_ENABLE |
			    EHCI_RH_PORT_CONNECT_ENABLE));

			/*
			 * The next function is only called if the interrupt
			 * pipe is polling and the USBA is ready to receive
			 * the data.
			 */
			ehcip->ehci_root_hub.
			    rh_intr_pending_status |= (1 << port);

			if (ehcip->ehci_root_hub.
			    rh_intr_pipe_state == EHCI_PIPE_STATE_ACTIVE) {

				ehci_root_hub_reset_occured(ehcip);
			}
		}
	}

	mutex_exit(&ehcip->ehci_int_mutex);
}


/*
 * ehci_root_hub_reset_occured:
 *
 * Inform the upper layer that reset has occured on the port. This is
 * required because the upper layer is expecting a an evernt immidiately
 * after doing reset. In case of OHCI, the controller gets an interrupt
 * for the change in the root hub status but in case of EHCI, we dont.
 * So, send a event to the upper layer as soon as we complete the reset.
 */
void
ehci_root_hub_reset_occured(
	ehci_state_t		*ehcip)
{
	usb_intr_req_t		*curr_intr_reqp =
	    ehcip->ehci_root_hub.rh_curr_intr_reqp;
	usb_port_mask_t		port_mask;
	usba_pipe_handle_data_t	*ph;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_root_hub_reset_occured: curr_intr_reqp = 0x%p data = 0x%p",
	    (void *)curr_intr_reqp, (void *)curr_intr_reqp->intr_data);

	/* Get the interrupt pipe handle */
	ph = ehcip->ehci_root_hub.rh_intr_pipe_handle;

	/* Get the pending status */
	port_mask = ehcip->ehci_root_hub.rh_intr_pending_status << 1;

	do {
		*curr_intr_reqp->intr_data->b_wptr++ = (uchar_t)port_mask;
		port_mask >>= 8;
	} while (port_mask != 0);

	ehci_root_hub_hcdi_callback(ph, USB_CR_OK);

	/* Reset pending status */
	ehcip->ehci_root_hub.rh_intr_pending_status = 0;

	/* If needed, allocate new interrupt request */
	if ((ehci_root_hub_allocate_intr_pipe_resource(
	    ehcip, 0)) != USB_SUCCESS) {

		/* Do interrupt pipe cleanup */
		ehci_root_hub_intr_pipe_cleanup(ehcip, USB_CR_NO_RESOURCES);
	}
}


/*
 * ehci_handle_complete_port_reset:
 *
 * Perform a port reset change.
 */
static void
ehci_handle_complete_port_reset(
	ehci_state_t		*ehcip,
	uint16_t		port)
{
	uint_t			port_status;

	mutex_enter(&ehcip->ehci_int_mutex);

	port_status = Get_OpReg(ehci_rh_port_status[port]) &
	    ~EHCI_RH_PORT_CLEAR_MASK;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_complete_port_reset: port = 0x%x status = 0x%x",
	    port, port_status);

	/* Check port is owned by ehci */
	if (ehci_is_port_owner(ehcip, port) != USB_SUCCESS) {
		mutex_exit(&ehcip->ehci_int_mutex);

		return;
	}

	if (port_status & EHCI_RH_PORT_RESET) {
		Set_OpReg(ehci_rh_port_status[port],
		    port_status & ~EHCI_RH_PORT_RESET);

	}

	mutex_exit(&ehcip->ehci_int_mutex);
}


/*
 * ehci_handle_clear_port_connection:
 *
 * Perform a clear port connection.
 */
static void
ehci_handle_clear_port_connection(
	ehci_state_t		*ehcip,
	uint16_t		port)
{
	uint_t			port_status;

	mutex_enter(&ehcip->ehci_int_mutex);

	port_status = Get_OpReg(ehci_rh_port_status[port]) &
	    ~EHCI_RH_PORT_CLEAR_MASK;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_clear_port_connection: port = 0x%x"
	    "status = 0x%x", port, port_status);

	Set_OpReg(ehci_rh_port_status[port],
	    port_status | EHCI_RH_PORT_CONNECT_STS_CHANGE);

	mutex_exit(&ehcip->ehci_int_mutex);
}


/*
 * ehci_handle_clrchng_port_over_current:
 *
 * Perform a clear port connection.
 */
static void
ehci_handle_clrchng_port_over_current(
	ehci_state_t		*ehcip,
	uint16_t		port)
{
	uint_t			port_status;

	mutex_enter(&ehcip->ehci_int_mutex);

	port_status = Get_OpReg(ehci_rh_port_status[port]) &
	    ~EHCI_RH_PORT_CLEAR_MASK;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_clrchng_port_over_current: port = 0x%x"
	    "status = 0x%x", port, port_status);

	Set_OpReg(ehci_rh_port_status[port],
	    port_status | EHCI_RH_PORT_OVER_CURR_CHANGE);

	mutex_exit(&ehcip->ehci_int_mutex);
}


/*
 * ehci_handle_get_port_status:
 *
 * Handle a get port status request.
 */
static void
ehci_handle_get_port_status(
	ehci_state_t		*ehcip,
	uint16_t		port)
{
	usb_ctrl_req_t		*ctrl_reqp;
	mblk_t			*message;
	uint_t			new_port_status = 0;
	uint_t			change_status = 0;
	uint_t			port_status;

	mutex_enter(&ehcip->ehci_int_mutex);

	ctrl_reqp = ehcip->ehci_root_hub.rh_curr_ctrl_reqp;

	/* Get the root hub port status information */
	port_status = ehci_get_root_hub_port_status(ehcip, port);

	new_port_status = port_status & PORT_STATUS_MASK;
	change_status = (port_status >> 16) & PORT_CHANGE_MASK;

	ehcip->ehci_root_hub.rh_port_status[port] = new_port_status;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_get_port_status: port = %d new status = 0x%x"
	    "change = 0x%x", port, new_port_status, change_status);

	message = ctrl_reqp->ctrl_data;

	ASSERT(message != NULL);

	*message->b_wptr++ = (uchar_t)new_port_status;
	*message->b_wptr++ = (uchar_t)(new_port_status >> 8);
	*message->b_wptr++ = (uchar_t)change_status;
	*message->b_wptr++ = (uchar_t)(change_status >> 8);

	/* Save the data in control request */
	ctrl_reqp->ctrl_data = message;

	mutex_exit(&ehcip->ehci_int_mutex);
}


/*
 * ehci_handle_get_hub_descriptor:
 */
static void
ehci_handle_get_hub_descriptor(
	ehci_state_t		*ehcip)
{
	usb_ctrl_req_t		*ctrl_reqp;
	mblk_t			*message;
	usb_hub_descr_t		*root_hub_descr;
	size_t			length;
	uchar_t			raw_descr[ROOT_HUB_DESCRIPTOR_LENGTH];

	mutex_enter(&ehcip->ehci_int_mutex);

	ctrl_reqp = ehcip->ehci_root_hub.rh_curr_ctrl_reqp;
	root_hub_descr = &ehcip->ehci_root_hub.rh_descr;
	length = ctrl_reqp->ctrl_wLength;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_get_hub_descriptor: Ctrl Req  = 0x%p",
	    (void *)ctrl_reqp);

	message = ctrl_reqp->ctrl_data;

	ASSERT(message != NULL);

	bzero(&raw_descr, ROOT_HUB_DESCRIPTOR_LENGTH);

	raw_descr[0] = root_hub_descr->bDescLength;
	raw_descr[1] = root_hub_descr->bDescriptorType;
	raw_descr[2] = root_hub_descr->bNbrPorts;
	raw_descr[3] = root_hub_descr->wHubCharacteristics & 0x00FF;
	raw_descr[4] = (root_hub_descr->wHubCharacteristics & 0xFF00) >> 8;
	raw_descr[5] = root_hub_descr->bPwrOn2PwrGood;
	raw_descr[6] = root_hub_descr->bHubContrCurrent;
	raw_descr[7] = root_hub_descr->DeviceRemovable;
	raw_descr[8] = root_hub_descr->PortPwrCtrlMask;

	bcopy(raw_descr, message->b_wptr, length);
	message->b_wptr += length;

	/* Save the data in control request */
	ctrl_reqp->ctrl_data = message;

	mutex_exit(&ehcip->ehci_int_mutex);
}


/*
 * ehci_handle_get_hub_status:
 *
 * Handle a get hub status request.
 */
static void
ehci_handle_get_hub_status(
	ehci_state_t		*ehcip)
{
	usb_ctrl_req_t		*ctrl_reqp;
	mblk_t			*message;
	uint_t			new_root_hub_status;

	mutex_enter(&ehcip->ehci_int_mutex);

	ctrl_reqp = ehcip->ehci_root_hub.rh_curr_ctrl_reqp;

	/*
	 * For EHCI, there is no overall hub status information.
	 * Only individual root hub port status information is
	 * available. So return zero for the root hub status
	 * request.
	 */
	new_root_hub_status = 0;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_get_hub_status: new root hub status = 0x%x",
	    new_root_hub_status);

	message = ctrl_reqp->ctrl_data;

	ASSERT(message != NULL);

	*message->b_wptr++ = (uchar_t)new_root_hub_status;
	*message->b_wptr++ = (uchar_t)(new_root_hub_status >> 8);
	*message->b_wptr++ = (uchar_t)(new_root_hub_status >> 16);
	*message->b_wptr++ = (uchar_t)(new_root_hub_status >> 24);

	/* Save the data in control request */
	ctrl_reqp->ctrl_data = message;

	mutex_exit(&ehcip->ehci_int_mutex);
}


/*
 * ehci_handle_get_device_status:
 *
 * Handle a get device status request.
 */
static void
ehci_handle_get_device_status(
	ehci_state_t		*ehcip)
{
	usb_ctrl_req_t		*ctrl_reqp;
	mblk_t			*message;
	uint16_t		dev_status;

	mutex_enter(&ehcip->ehci_int_mutex);

	ctrl_reqp = ehcip->ehci_root_hub.rh_curr_ctrl_reqp;

	/*
	 * For EHCI, there is no device status information.
	 * Simply return what is desired for the request.
	 */
	dev_status = USB_DEV_SLF_PWRD_STATUS;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_get_device_status: device status = 0x%x",
	    dev_status);

	message = ctrl_reqp->ctrl_data;

	ASSERT(message != NULL);

	*message->b_wptr++ = (uchar_t)dev_status;
	*message->b_wptr++ = (uchar_t)(dev_status >> 8);

	/* Save the data in control request */
	ctrl_reqp->ctrl_data = message;

	mutex_exit(&ehcip->ehci_int_mutex);
}


/*
 * ehci_handle_root_hub_pipe_start_intr_polling:
 *
 * Handle start polling on root hub interrupt pipe.
 */
/* ARGSUSED */
int
ehci_handle_root_hub_pipe_start_intr_polling(
	usba_pipe_handle_data_t	*ph,
	usb_intr_req_t		*client_intr_reqp,
	usb_flags_t		flags)
{
	ehci_state_t		*ehcip = ehci_obtain_state(
	    ph->p_usba_device->usb_root_hub_dip);
	usb_ep_descr_t		*eptd = &ph->p_ep;
	int			error = USB_SUCCESS;
	uint_t			pipe_state;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_root_hub_pipe_start_intr_polling: "
	    "Root hub pipe start polling");

	ASSERT(mutex_owned(&ehcip->ehci_int_mutex));

	ASSERT((eptd->bEndpointAddress & USB_EP_NUM_MASK) == 1);

	ASSERT((client_intr_reqp->intr_attributes & USB_ATTRS_ONE_XFER) == 0);

	pipe_state = ehcip->ehci_root_hub.rh_intr_pipe_state;

	switch (pipe_state) {
	case EHCI_PIPE_STATE_IDLE:
		ASSERT(ehcip->ehci_root_hub.rh_intr_pipe_timer_id == 0);

		/*
		 * Save the Original Client's Interrupt IN request
		 * information. We use this for final callback
		 */
		ASSERT(ehcip->ehci_root_hub.rh_client_intr_reqp == NULL);
		ehcip->ehci_root_hub.rh_client_intr_reqp = client_intr_reqp;

		error = ehci_root_hub_allocate_intr_pipe_resource(ehcip, flags);

		if (error != USB_SUCCESS) {
			/* Reset client interrupt request pointer */
			ehcip->ehci_root_hub.rh_client_intr_reqp = NULL;

			USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
			    "ehci_handle_root_hub_pipe_start_intr_polling: "
			    "No Resources");

			return (error);
		}

		/* Check whether we need to send the reset data up */
		if (ehcip->ehci_root_hub.rh_intr_pending_status) {
			ehci_root_hub_reset_occured(ehcip);
		}

		USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_pipe_start_intr_polling: "
		    "Start polling for root hub successful");

		break;
	case EHCI_PIPE_STATE_ACTIVE:
		USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_pipe_start_intr_polling: "
		    "Polling for root hub is already in progress");

		break;
	default:
		USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_root_hub_pipe_start_intr_polling: "
		    "Pipe is in error state 0x%x", pipe_state);

		error = USB_FAILURE;

		break;
	}

	return (error);
}


/*
 * ehci_handle_root_hub_pipe_stop_intr_polling:
 *
 * Handle stop polling on root hub intr pipe.
 */
/* ARGSUSED */
void
ehci_handle_root_hub_pipe_stop_intr_polling(
	usba_pipe_handle_data_t	*ph,
	usb_flags_t		flags)
{
	ehci_state_t		*ehcip = ehci_obtain_state(
	    ph->p_usba_device->usb_root_hub_dip);
	usb_ep_descr_t		*eptd = &ph->p_ep;

	ASSERT(mutex_owned(&ehcip->ehci_int_mutex));

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_root_hub_pipe_stop_intr_polling: "
	    "Root hub pipe stop polling");

	ASSERT((eptd->bEndpointAddress & USB_EP_NUM_MASK) == 1);

	if (ehcip->ehci_root_hub.rh_intr_pipe_state ==
	    EHCI_PIPE_STATE_ACTIVE) {

		ehcip->ehci_root_hub.rh_intr_pipe_state =
		    EHCI_PIPE_STATE_STOP_POLLING;

		/* Do interrupt pipe cleanup */
		ehci_root_hub_intr_pipe_cleanup(ehcip, USB_CR_STOPPED_POLLING);

		ASSERT(ehcip->ehci_root_hub.
		    rh_intr_pipe_state == EHCI_PIPE_STATE_IDLE);

		USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_hcdi_pipe_stop_intr_polling: Stop polling for root"
		    "hub successful");
	} else {
		USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB,
		    ehcip->ehci_log_hdl, "ehci_hcdi_pipe_stop_intr_polling: "
		    "Polling for root hub is already stopped");
	}
}


/*
 * ehci_get_root_hub_port_status:
 *
 * Construct root hub port status and change information
 */
static uint_t
ehci_get_root_hub_port_status(
	ehci_state_t		*ehcip,
	uint16_t		port)
{
	uint_t			new_port_status = 0;
	uint_t			change_status = 0;
	uint_t			port_status;

	ASSERT(mutex_owned(&ehcip->ehci_int_mutex));

	/* Read the current port status */
	port_status = Get_OpReg(ehci_rh_port_status[port]);

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_get_root_hub_port_status: port %d "
	    "port status = 0x%x", port, port_status);

	/*
	 * EHCI root hub port status and control register information
	 * format is different what Hub driver wants. So EHCI driver
	 * needs to contruct the proper root hub port status information.
	 *
	 * Send all port status information only if port is owned by EHCI
	 * host controller.
	 */
	if ((port_status & EHCI_RH_PORT_OWNER) == EHCI_RH_PORT_OWNER_EHCI) {

		/* First construct port change information */
		if (port_status & EHCI_RH_PORT_ENABLE_CHANGE) {
			change_status |= PORT_CHANGE_PESC;
		}

		if (port_status & EHCI_RH_PORT_RESUME) {
			change_status |= PORT_CHANGE_PSSC;
		}

		if (port_status & EHCI_RH_PORT_OVER_CURR_CHANGE) {
			change_status |= PORT_CHANGE_OCIC;
		}

		/* Now construct port status information */
		if (port_status & EHCI_RH_PORT_CONNECT_STATUS) {
			new_port_status |= PORT_STATUS_CCS;
		}

		if (port_status & EHCI_RH_PORT_ENABLE) {
			new_port_status |=
			    (PORT_STATUS_PES | PORT_STATUS_HSDA);
		}

		if (port_status & EHCI_RH_PORT_SUSPEND) {
			new_port_status |= PORT_STATUS_PSS;
		}

		if (port_status & EHCI_RH_PORT_OVER_CURR_ACTIVE) {
			new_port_status |= PORT_STATUS_POCI;
		}

		if (port_status & EHCI_RH_PORT_RESET) {
			new_port_status |= PORT_STATUS_PRS;
		}

		if (port_status & EHCI_RH_PORT_INDICATOR) {
			new_port_status |= PORT_STATUS_PIC;
		}
	}

	/*
	 * Send the following port status and change information
	 * even if port is not owned by EHCI.
	 *
	 * Additional port change information.
	 */
	if (port_status & EHCI_RH_PORT_CONNECT_STS_CHANGE) {
		change_status |= PORT_CHANGE_CSC;
	}

	/* Additional port status information */
	if (port_status & EHCI_RH_PORT_POWER) {
		new_port_status |= PORT_STATUS_PPS;
	}

	if ((!(port_status & EHCI_RH_PORT_ENABLE)) &&
	    (port_status & EHCI_RH_PORT_LOW_SPEED)) {
		new_port_status |= PORT_STATUS_LSDA;
	}

	/*
	 * Construct complete root hub port status and change information.
	 */
	port_status = ((change_status << 16) | new_port_status);

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_get_root_hub_port_status: port = %d new status = 0x%x "
	    "change status = 0x%x complete port status 0x%x", port,
	    new_port_status, change_status, port_status);

	return (port_status);
}


/*
 * ehci_is_port_owner:
 *
 * Check whether given port is owned by ehci.
 */
static int
ehci_is_port_owner(
	ehci_state_t		*ehcip,
	uint16_t		port)
{
	uint_t			port_status;

	ASSERT(mutex_owned(&ehcip->ehci_int_mutex));

	port_status = Get_OpReg(ehci_rh_port_status[port]) &
	    ~EHCI_RH_PORT_CLEAR_MASK;

	/*
	 * Don't perform anything if port is owned by classis host
	 * controller and return success.
	 */
	if ((port_status & EHCI_RH_PORT_OWNER) == EHCI_RH_PORT_OWNER_CLASSIC) {

		USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
		    "ehci_handle_set_clear_port_feature: "
		    "Port %d is owned by classic host controller", port);

		return (USB_FAILURE);
	}

	return (USB_SUCCESS);
}


/*
 * ehci_root_hub_allocate_intr_pipe_resource:
 *
 * Allocate interrupt requests and initialize them.
 */
static int
ehci_root_hub_allocate_intr_pipe_resource(
	ehci_state_t		*ehcip,
	usb_flags_t		flags)
{
	usba_pipe_handle_data_t	*ph;
	size_t			length;
	usb_intr_req_t		*curr_intr_reqp;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_root_hub_allocate_intr_pipe_resource");

	ASSERT(mutex_owned(&ehcip->ehci_int_mutex));

	/* Get the interrupt pipe handle */
	ph = ehcip->ehci_root_hub.rh_intr_pipe_handle;

	/* Get the current interrupt request pointer */
	curr_intr_reqp = ehcip->ehci_root_hub.rh_curr_intr_reqp;

	/*
	 * If current interrupt request pointer is null,
	 * allocate new interrupt request.
	 */
	if (curr_intr_reqp == NULL) {
		ASSERT(ehcip->ehci_root_hub.rh_client_intr_reqp);

		/* Get the length of interrupt transfer */
		length = ehcip->ehci_root_hub.
		    rh_client_intr_reqp->intr_len;

		curr_intr_reqp = usba_hcdi_dup_intr_req(ph->p_dip,
		    ehcip->ehci_root_hub.rh_client_intr_reqp,
		    length, flags);

		if (curr_intr_reqp == NULL) {

			USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
			    "ehci_root_hub_allocate_intr_pipe_resource:"
			    "Interrupt request structure allocation failed");

			return (USB_NO_RESOURCES);
		}

		ehcip->ehci_root_hub.rh_curr_intr_reqp = curr_intr_reqp;
		mutex_enter(&ph->p_mutex);
		ph->p_req_count++;
		mutex_exit(&ph->p_mutex);
	}

	/* Start the timer for the root hub interrupt pipe polling */
	if (ehcip->ehci_root_hub.rh_intr_pipe_timer_id == 0) {
		ehcip->ehci_root_hub.rh_intr_pipe_timer_id =
		    timeout(ehci_handle_root_hub_status_change,
		    (void *)ehcip, drv_usectohz(EHCI_RH_POLL_TIME));

		ehcip->ehci_root_hub.
		    rh_intr_pipe_state = EHCI_PIPE_STATE_ACTIVE;
	}

	return (USB_SUCCESS);
}


/*
 * ehci_root_hub_intr_pipe_cleanup:
 *
 * Deallocate all interrupt requests and do callback
 * the original client interrupt request.
 */
static void
ehci_root_hub_intr_pipe_cleanup(
	ehci_state_t		*ehcip,
	usb_cr_t		completion_reason)
{
	usb_intr_req_t		*curr_intr_reqp;
	usb_opaque_t		client_intr_reqp;
	timeout_id_t		timer_id;
	usba_pipe_handle_data_t	*ph;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_root_hub_intr_pipe_cleanup");

	ASSERT(mutex_owned(&ehcip->ehci_int_mutex));

	/* Get the interrupt pipe handle */
	ph = ehcip->ehci_root_hub.rh_intr_pipe_handle;

	/* Get the interrupt timerid */
	timer_id = ehcip->ehci_root_hub.rh_intr_pipe_timer_id;

	/* Stop the root hub interrupt timer */
	if (timer_id) {
		/* Reset the timer id to zero */
		ehcip->ehci_root_hub.rh_intr_pipe_timer_id = 0;

		mutex_exit(&ehcip->ehci_int_mutex);
		(void) untimeout(timer_id);
		mutex_enter(&ehcip->ehci_int_mutex);
	}

	/* Reset the current interrupt request pointer */
	curr_intr_reqp = ehcip->ehci_root_hub.rh_curr_intr_reqp;

	/* Deallocate uncompleted interrupt request */
	if (curr_intr_reqp) {
		ehcip->ehci_root_hub.rh_curr_intr_reqp = NULL;
		usb_free_intr_req(curr_intr_reqp);

		mutex_enter(&ph->p_mutex);
		ph->p_req_count--;
		mutex_exit(&ph->p_mutex);
	}

	client_intr_reqp = (usb_opaque_t)
	    ehcip->ehci_root_hub.rh_client_intr_reqp;

	/* Callback for original client interrupt request */
	if (client_intr_reqp) {
		ehci_root_hub_hcdi_callback(ph, completion_reason);
	}
}


/*
 * ehci_handle_root_hub_status_change:
 *
 * A root hub status change interrupt will occur any time there is a change
 * in the root hub status register or one of the port status registers.
 */
static void
ehci_handle_root_hub_status_change(void *arg)
{
	ehci_state_t		*ehcip = (ehci_state_t *)arg;
	usb_hub_descr_t		*root_hub_descr =
	    &ehcip->ehci_root_hub.rh_descr;
	usb_intr_req_t		*curr_intr_reqp;
	usb_port_mask_t		port_mask = 0;
	uint_t			new_port_status;
	uint_t			change_status;
	uint_t			port_status;
	mblk_t			*message;
	size_t			length;
	usb_ep_descr_t		*eptd;
	usba_pipe_handle_data_t	*ph;
	int			i;

	mutex_enter(&ehcip->ehci_int_mutex);

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_handle_root_hub_status_change: state = %d",
	    ehcip->ehci_root_hub.rh_intr_pipe_state);

#if defined(__x86)
	/*
	 * When ohci are attached in ferrari 4000, SMI will reset ehci
	 * registers. If ehci registers have been reset, we must re-initialize
	 * them. During booting, this function will be called 2~3 times. When
	 * this function is called 16 times, ohci drivers have been attached
	 * and stop checking the ehci registers.
	 */
	if (ehcip->ehci_polled_root_hub_count < 16) {

		if (Get_OpReg(ehci_config_flag) == 0) {

			USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB,
			    ehcip->ehci_log_hdl,
			    "ehci_handle_root_hub_status_change:"
			    " EHCI have been reset");

			/* Reinitialize the controller */
			if (ehci_init_ctlr(ehcip, EHCI_REINITIALIZATION) !=
			    DDI_SUCCESS) {
				mutex_exit(&ehcip->ehci_int_mutex);

				return;
			}
		}

		ehcip->ehci_polled_root_hub_count++;
	}
#endif	/* __x86 */

	/* Get the current interrupt request pointer */
	curr_intr_reqp = ehcip->ehci_root_hub.rh_curr_intr_reqp;

	ph = ehcip->ehci_root_hub.rh_intr_pipe_handle;

	/* Check whether timeout handler is valid */
	if (ehcip->ehci_root_hub.rh_intr_pipe_timer_id) {
		/* Check host controller is in operational state */
		if ((ehci_state_is_operational(ehcip)) != USB_SUCCESS) {
			/* Reset the timer id */
			ehcip->ehci_root_hub.rh_intr_pipe_timer_id = 0;

			/* Do interrupt pipe cleanup */
			ehci_root_hub_intr_pipe_cleanup(
			    ehcip, USB_CR_HC_HARDWARE_ERR);

			mutex_exit(&ehcip->ehci_int_mutex);

			return;
		}
	} else {
		mutex_exit(&ehcip->ehci_int_mutex);

		return;
	}

	eptd = &ehcip->ehci_root_hub.rh_intr_pipe_handle->p_ep;

	/* Check each port */
	for (i = 0; i < root_hub_descr->bNbrPorts; i++) {

		port_status = ehci_get_root_hub_port_status(ehcip, i);

		new_port_status = port_status & PORT_STATUS_MASK;
		change_status = (port_status >> 16) & PORT_CHANGE_MASK;

		/*
		 * If there is change in the port status then set the bit in the
		 * bitmap of changes and inform hub driver about these changes.
		 * Hub driver will take care of these changes.
		 */
		if (change_status) {

			/* See if a device was attached/detached */
			if (change_status & PORT_CHANGE_CSC) {
				/*
				 * Update the state depending on whether
				 * the port was attached or detached.
				 */
				if (new_port_status & PORT_STATUS_CCS) {
					ehcip->ehci_root_hub.
					    rh_port_state[i] = DISABLED;

					USB_DPRINTF_L3(PRINT_MASK_ROOT_HUB,
					    ehcip->ehci_log_hdl,
					    "Port %d connected", i+1);
				} else {
					ehcip->ehci_root_hub.
					    rh_port_state[i] = DISCONNECTED;

					USB_DPRINTF_L3(PRINT_MASK_ROOT_HUB,
					    ehcip->ehci_log_hdl,
					    "Port %d disconnected", i+1);
				}
			}

			/* See if port enable status changed */
			if (change_status & PORT_CHANGE_PESC) {
				/*
				 * Update the state depending on whether
				 * the port was enabled or disabled.
				 */
				if (new_port_status & PORT_STATUS_PES) {
					ehcip->ehci_root_hub.
					    rh_port_state[i] = ENABLED;

					USB_DPRINTF_L3(PRINT_MASK_ROOT_HUB,
					    ehcip->ehci_log_hdl,
					    "Port %d enabled", i+1);
				} else {
					ehcip->ehci_root_hub.
					    rh_port_state[i] = DISABLED;

					USB_DPRINTF_L3(PRINT_MASK_ROOT_HUB,
					    ehcip->ehci_log_hdl,
					    "Port %d disabled", i+1);
				}
			}

			port_mask |= 1 << (i + 1);

			/* Update the status */
			ehcip->ehci_root_hub.
			    rh_port_status[i] = new_port_status;
		}
	}

	if (ph && port_mask && curr_intr_reqp) {
		length = eptd->wMaxPacketSize;

		ASSERT(length != 0);

		/* Get the  message block */
		message = curr_intr_reqp->intr_data;

		ASSERT(message != NULL);

		do {
			/*
			 * check that the mblk is big enough when we
			 * are writing bytes into it
			 */
			if (message->b_wptr >= message->b_datap->db_lim) {

				USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB,
				    ehcip->ehci_log_hdl,
				    "ehci_handle_root_hub_status_change"
				    "mblk data overflow.");

				break;
			}
			*message->b_wptr++ = (uchar_t)port_mask;
			port_mask >>= 8;
		} while (port_mask != 0);

		ehci_root_hub_hcdi_callback(ph, USB_CR_OK);
	}

	/* Reset the timer id */
	ehcip->ehci_root_hub.rh_intr_pipe_timer_id = 0;

	if (ehcip->ehci_root_hub.rh_intr_pipe_state ==
	    EHCI_PIPE_STATE_ACTIVE) {
		/*
		 * If needed, allocate new interrupt request. Also
		 * start the timer for the root hub interrupt polling.
		 */
		if ((ehci_root_hub_allocate_intr_pipe_resource(
		    ehcip, 0)) != USB_SUCCESS) {

			USB_DPRINTF_L2(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
			    "ehci_handle_root_hub_status_change: No Resources");

			/* Do interrupt pipe cleanup */
			ehci_root_hub_intr_pipe_cleanup(
			    ehcip, USB_CR_NO_RESOURCES);
		}
	}

	mutex_exit(&ehcip->ehci_int_mutex);
}


/*
 * ehci_root_hub_hcdi_callback()
 *
 * Convenience wrapper around usba_hcdi_cb() for the root hub.
 */
static void
ehci_root_hub_hcdi_callback(
	usba_pipe_handle_data_t	*ph,
	usb_cr_t		completion_reason)
{
	ehci_state_t		*ehcip = ehci_obtain_state(
	    ph->p_usba_device->usb_root_hub_dip);
	uchar_t			attributes = ph->p_ep.bmAttributes &
	    USB_EP_ATTR_MASK;
	usb_opaque_t		curr_xfer_reqp;
	uint_t			pipe_state = 0;

	USB_DPRINTF_L4(PRINT_MASK_ROOT_HUB, ehcip->ehci_log_hdl,
	    "ehci_root_hub_hcdi_callback: ph = 0x%p, cr = 0x%x",
	    (void *)ph, completion_reason);

	ASSERT(mutex_owned(&ehcip->ehci_int_mutex));

	/* Set the pipe state as per completion reason */
	switch (completion_reason) {
	case USB_CR_OK:
		switch (attributes) {
		case USB_EP_ATTR_CONTROL:
			pipe_state = EHCI_PIPE_STATE_IDLE;
			break;
		case USB_EP_ATTR_INTR:
			pipe_state = ehcip->ehci_root_hub.
			    rh_intr_pipe_state;
			break;
		}
		break;
	case USB_CR_NO_RESOURCES:
	case USB_CR_NOT_SUPPORTED:
	case USB_CR_STOPPED_POLLING:
	case USB_CR_PIPE_RESET:
	case USB_CR_HC_HARDWARE_ERR:
		/* Set pipe state to idle */
		pipe_state = EHCI_PIPE_STATE_IDLE;
		break;
	case USB_CR_PIPE_CLOSING:
		break;
	default:
		/* Set pipe state to error */
		pipe_state = EHCI_PIPE_STATE_ERROR;
		break;
	}

	switch (attributes) {
	case USB_EP_ATTR_CONTROL:
		curr_xfer_reqp = (usb_opaque_t)
		    ehcip->ehci_root_hub.rh_curr_ctrl_reqp;

		ehcip->ehci_root_hub.rh_curr_ctrl_reqp = NULL;
		ehcip->ehci_root_hub.rh_ctrl_pipe_state = pipe_state;
		break;
	case USB_EP_ATTR_INTR:
		/* if curr_intr_reqp available then use this request */
		if (ehcip->ehci_root_hub.rh_curr_intr_reqp) {
			curr_xfer_reqp = (usb_opaque_t)ehcip->
			    ehci_root_hub.rh_curr_intr_reqp;

			ehcip->ehci_root_hub.rh_curr_intr_reqp = NULL;
		} else {
			/* no current request, use client's request */
			curr_xfer_reqp = (usb_opaque_t)
			    ehcip->ehci_root_hub.rh_client_intr_reqp;

			ehcip->ehci_root_hub.rh_client_intr_reqp = NULL;
		}
		ehcip->ehci_root_hub.rh_intr_pipe_state = pipe_state;
		break;
	}

	ASSERT(curr_xfer_reqp != NULL);

	mutex_exit(&ehcip->ehci_int_mutex);
	usba_hcdi_cb(ph, curr_xfer_reqp, completion_reason);
	mutex_enter(&ehcip->ehci_int_mutex);
}