/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * USBA: Solaris USB Architecture support
 *
 * functions that deal with allocation/free/data_xfers
 * for the  control/bulk/interrupt/isoch pipes:
 *	usb_alloc_ctrl_req()
 *	usb_free_ctrl_req()
 *	usb_pipe_ctrl_xfer()
 *	usb_pipe_sync_ctrl_xfer()
 *	usb_pipe_ctrl_xfer_wait()
 *
 *	usb_alloc_bulk_req()
 *	usb_free_bulk_req()
 *	usb_pipe_bulk_xfer()
 *	usb_pipe_bulk_transfer_size()
 *
 *	usb_alloc_intr_req()
 *	usb_free_intr_req()
 *	usb_pipe_intr_xfer()
 *	usb_pipe_stop_intr_polling()
 *
 *	usb_alloc_isoc_req()
 *	usb_free_isoc_req()
 *	usb_get_current_frame_number()
 *	usb_get_max_isoc_pkts()
 *	usb_pipe_isoc_xfer()
 *	usb_pipe_stop_isoc_polling()
 *
 * XXX to do:
 *	update return values where needed
 *	keep track of requests not freed
 *
 */
#define	USBA_FRAMEWORK
#include <sys/usb/usba/usba_impl.h>
#include <sys/usb/usba/hcdi_impl.h>
#include <sys/strsubr.h>

/* prototypes */
static int usba_flags_attr_check(usba_pipe_handle_data_t *,
			usb_req_attrs_t attrs, usb_flags_t);
static int _usba_check_req(usba_pipe_handle_data_t *, usb_opaque_t,
			usb_flags_t, uchar_t);

/*
 * usba_check_req:
 *	check pipe, request structure for validity
 *
 * Arguments:
 *	ph		- pipe handle pointer
 *	req		- opaque request pointer
 *	flags		- usb flags
 *
 * Returns:
 *	USB_SUCCESS		- valid request
 *	USB_INVALID_REQUEST	- request contains some invalid values
 *	USB_PIPE_ERROR		- pipe is in error state
 *	USB_INVALID_CONTEXT	- sleep in interrupt context
 *	USB_INVALID_PIPE	- zero pipe or wrong pipe
 */
static int
usba_check_req(usba_pipe_handle_data_t *ph_data, usb_opaque_t req,
		usb_flags_t flags, uchar_t pipe_type)
{
	int rval = _usba_check_req(ph_data, req, flags, pipe_type);

	if (rval != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_check_req: ph_data=0x%p req=0x%p flags=0%x rval=%d",
		    ph_data, req, flags, rval);
	}

	return (rval);
}


static int
_usba_check_req(usba_pipe_handle_data_t *ph_data, usb_opaque_t req,
		usb_flags_t flags, uchar_t pipe_type)
{
	usb_ctrl_req_t		*ctrl_req = (usb_ctrl_req_t *)req;
	usb_bulk_req_t		*bulk_req = (usb_bulk_req_t *)req;
	usb_intr_req_t		*intr_req = (usb_intr_req_t *)req;
	usb_isoc_req_t		*isoc_req = (usb_isoc_req_t *)req;
	usba_req_wrapper_t	*wrp = USBA_REQ2WRP(req);
	mblk_t			*data;
	usb_cr_t		*cr;
	usb_req_attrs_t		attrs;
	usb_opaque_t		cb, exc_cb;
	uint_t			timeout = 0;
	uchar_t			direction = ph_data->p_ep.bEndpointAddress &
							USB_EP_DIR_MASK;
	uchar_t			ep_attrs = ph_data->p_ep.bmAttributes &
							USB_EP_ATTR_MASK;
	int			n;

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_check_req: ph_data=0x%p req=0x%p flags=0x%x",
	    ph_data, req, flags);

	if (req == NULL) {

		return (USB_INVALID_ARGS);
	}

	/* set completion reason first so it specifies an error */
	switch (ep_attrs) {
	case USB_EP_ATTR_CONTROL:
		cr = &ctrl_req->ctrl_completion_reason;
		break;
	case USB_EP_ATTR_BULK:
		cr = &bulk_req->bulk_completion_reason;
		break;
	case USB_EP_ATTR_INTR:
		cr = &intr_req->intr_completion_reason;
		break;
	case USB_EP_ATTR_ISOCH:
		cr = &isoc_req->isoc_completion_reason;
		break;
	}

	*cr = USB_CR_UNSPECIFIED_ERR;

	if (servicing_interrupt() && (flags & USB_FLAGS_SLEEP)) {

		return (USB_INVALID_CONTEXT);
	}

	if (pipe_type != ep_attrs) {

		return (USB_INVALID_PIPE);
	}

	/* we must have usba_device and default ph to do autoclearing */
	ASSERT(ph_data->p_usba_device);

	if (ph_data->p_usba_device->usb_ph_list[0].usba_ph_data == NULL) {

		return (USB_INVALID_PIPE);
	}

	/* check if this is a valid request packet, ie. not freed */
	if (usba_check_in_list(&(ph_data->p_usba_device->usb_allocated),
	    &wrp->wr_allocated_list) != USB_SUCCESS) {

		return (USB_INVALID_REQUEST);
	}

	/* copy over some members for easy checking later */
	switch (ep_attrs) {
	case USB_EP_ATTR_CONTROL:
		ctrl_req->ctrl_cb_flags = USB_CB_NO_INFO;
		data = ctrl_req->ctrl_data;
		attrs = ctrl_req->ctrl_attributes;
		timeout = ctrl_req->ctrl_timeout;
		cb = (usb_opaque_t)ctrl_req->ctrl_cb;
		exc_cb = (usb_opaque_t)ctrl_req->ctrl_exc_cb;
		if (flags & USB_FLAGS_SLEEP) {
			flags |= USBA_WRP_FLAGS_WAIT;
		}
		/* force auto clearing on the default pipe */
		if (USBA_IS_DEFAULT_PIPE(ph_data)) {
			attrs |= USB_ATTRS_AUTOCLEARING;
		}
		break;
	case USB_EP_ATTR_BULK:
		bulk_req->bulk_cb_flags = USB_CB_NO_INFO;
		data = bulk_req->bulk_data;
		attrs = bulk_req->bulk_attributes;
		timeout = bulk_req->bulk_timeout;
		cb = (usb_opaque_t)bulk_req->bulk_cb;
		exc_cb = (usb_opaque_t)bulk_req->bulk_exc_cb;
		if (flags & USB_FLAGS_SLEEP) {
			flags |= USBA_WRP_FLAGS_WAIT;
		}
		break;
	case USB_EP_ATTR_INTR:
		intr_req->intr_cb_flags = USB_CB_NO_INFO;
		data = intr_req->intr_data;
		attrs = intr_req->intr_attributes;
		timeout = intr_req->intr_timeout;
		cb = (usb_opaque_t)intr_req->intr_cb;
		exc_cb = (usb_opaque_t)intr_req->intr_exc_cb;
		if ((flags & USB_FLAGS_SLEEP) &&
		    (attrs & USB_ATTRS_ONE_XFER)) {
			flags |= USBA_WRP_FLAGS_WAIT;
		}
		break;
	case USB_EP_ATTR_ISOCH:
		isoc_req->isoc_cb_flags = USB_CB_NO_INFO;
		data = isoc_req->isoc_data;
		attrs = isoc_req->isoc_attributes;
		cb = (usb_opaque_t)isoc_req->isoc_cb;
		exc_cb = (usb_opaque_t)isoc_req->isoc_exc_cb;
		break;
	}

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_check_req: attrs = 0x%x flags=0x%x", attrs, flags);

	/* check flags and attr combinations */
	if (usba_flags_attr_check(ph_data, attrs, flags) !=
	    USB_SUCCESS) {

		return (USB_INVALID_REQUEST);
	}

	/* if no sleep, there must be callback ptrs */
	if ((flags & USB_FLAGS_SLEEP) == 0) {
		if (cb == NULL || exc_cb == NULL) {

			return (USB_INVALID_REQUEST);
		}
	}

	switch (ep_attrs) {
	case USB_EP_ATTR_CONTROL:
		if (ctrl_req->ctrl_wLength && (data == NULL)) {

			return (USB_INVALID_REQUEST);
		}
		break;
	case USB_EP_ATTR_BULK:
		if ((bulk_req->bulk_len) && (data == NULL)) {

			return (USB_INVALID_REQUEST);
		}
		break;
	case USB_EP_ATTR_INTR:
		if (direction == USB_EP_DIR_OUT) {
			if (intr_req->intr_len && data == NULL) {

				return (USB_INVALID_REQUEST);
			}
		}

		if (direction == USB_EP_DIR_IN) {
			if (!(intr_req->intr_attributes & USB_ATTRS_ONE_XFER)) {
				if (cb == NULL || exc_cb == NULL) {

					return (USB_INVALID_REQUEST);
				}
			}
			if (data != NULL) {

				return (USB_INVALID_REQUEST);
			}
			if (!(intr_req->intr_attributes & USB_ATTRS_ONE_XFER) &&
			    (timeout > 0)) {

				return (USB_INVALID_REQUEST);
			}
		}
		break;
	case USB_EP_ATTR_ISOCH:
		if (direction == USB_EP_DIR_IN) {
			if (cb == NULL || exc_cb == NULL) {

				return (USB_INVALID_REQUEST);
			}

			if (isoc_req->isoc_pkts_length == 0) {

				return (USB_INVALID_REQUEST);
			}
		}

		if (data == NULL) {

			return (USB_INVALID_REQUEST);
		}

		/*
		 * Since ehci/ohci/uhci use (data->b_wptr - data->b_rptr) as
		 * real isoc_pkts_length, it should be checked.
		 */
		if (direction == USB_EP_DIR_OUT) {
			if ((data->b_wptr - data->b_rptr) <= 0) {

				return (USB_INVALID_REQUEST);
			}
		}

		/* special isoc checks */
		if ((isoc_req->isoc_pkts_count == 0) ||
		    (isoc_req->isoc_pkt_descr == NULL)) {

			return (USB_INVALID_REQUEST);
		}

		/* check attributes for conflicts, one must be specified */
		if (!((isoc_req->isoc_attributes &
		    USB_ATTRS_ISOC_START_FRAME) ||
		    (isoc_req->isoc_attributes & USB_ATTRS_ISOC_XFER_ASAP))) {

			return (USB_NO_FRAME_NUMBER);
		}

		/* both may not be specified */
		if ((isoc_req->isoc_attributes &
		    (USB_ATTRS_ISOC_START_FRAME | USB_ATTRS_ISOC_XFER_ASAP)) ==
		    (USB_ATTRS_ISOC_START_FRAME | USB_ATTRS_ISOC_XFER_ASAP)) {

			return (USB_NO_FRAME_NUMBER);
		}

		/* no start frame may be specified for ASAP attribute */
		if (((isoc_req->isoc_attributes & USB_ATTRS_ISOC_XFER_ASAP)) &&
		    isoc_req->isoc_frame_no) {

			return (USB_INVALID_REQUEST);
		}

		/* start frame must be specified for START FRAME attribute */
		if (((isoc_req->isoc_attributes &
		    USB_ATTRS_ISOC_START_FRAME)) &&
		    (isoc_req->isoc_frame_no == 0)) {

			return (USB_NO_FRAME_NUMBER);
		}

		/* each packet must have initialized pkt length */
		for (n = 0; n < isoc_req->isoc_pkts_count; n++) {
			if (isoc_req->isoc_pkt_descr[n].isoc_pkt_length == 0) {

				return (USB_INVALID_REQUEST);
			}
		}
		break;
	}

	/* save pipe_handle/attrs/timeout/usb_flags */
	wrp->wr_ph_data		= ph_data;
	wrp->wr_usb_flags	= flags;
	wrp->wr_attrs		= attrs;

	/* zero some fields in case the request is reused */
	wrp->wr_done		= B_FALSE;
	wrp->wr_cr		= USB_CR_OK;

	/* this request looks good */
	*cr = USB_CR_OK;

	return (USB_SUCCESS);
}


/*
 * Table of invalid flags and attributes values. See "usbai.h"
 * for a complete table on valid usb_req_attrs_t
 */
#define	X	((uint_t)(-1))
#define	OUT	USB_EP_DIR_OUT
#define	IN	USB_EP_DIR_IN

struct	flags_attr {
	uint_t		ep_dir;
	uint_t		ep_attr;
	uint_t		usb_flags;	/* usb_flags SLEEP or none */
	uint_t		attrs;
} usb_invalid_flags_attrs[] = {
{ OUT,	USB_EP_ATTR_BULK,	X,	USB_ATTRS_SHORT_XFER_OK },
{ OUT,	USB_EP_ATTR_INTR,	X,	USB_ATTRS_SHORT_XFER_OK },
{ OUT,	USB_EP_ATTR_ISOCH,	X,	USB_ATTRS_SHORT_XFER_OK },

{ X,	USB_EP_ATTR_CONTROL,	X,	USB_ATTRS_ISOC_START_FRAME },
{ X,	USB_EP_ATTR_BULK,	X,	USB_ATTRS_ISOC_START_FRAME },
{ X,	USB_EP_ATTR_INTR,	X,	USB_ATTRS_ISOC_START_FRAME },

{ X,	USB_EP_ATTR_CONTROL,	X,	USB_ATTRS_ISOC_XFER_ASAP },
{ X,	USB_EP_ATTR_INTR,	X,	USB_ATTRS_ISOC_XFER_ASAP },
{ OUT,	USB_EP_ATTR_INTR,	X,	USB_ATTRS_ONE_XFER },
{ X,	USB_EP_ATTR_BULK,	X,	USB_ATTRS_ISOC_XFER_ASAP },

{ X,	USB_EP_ATTR_CONTROL,	X,	USB_ATTRS_ONE_XFER },
{ X,	USB_EP_ATTR_BULK,	X,	USB_ATTRS_ONE_XFER },
{ X,	USB_EP_ATTR_ISOCH,	X,	USB_ATTRS_ONE_XFER },
};

#define	N_INVALID_FLAGS_ATTRS	(sizeof (usb_invalid_flags_attrs))/ \
					sizeof (struct flags_attr)

/*
 * function to check flags and attribute combinations for a particular pipe
 * Arguments:
 *	ph	- pipe handle pointer
 *	attrs	- attributes of the request
 *	flags	- usb_flags
 */
static int
usba_flags_attr_check(usba_pipe_handle_data_t *ph_data,
		usb_req_attrs_t attrs,
		usb_flags_t flags)
{
	uchar_t i;
	uchar_t	ep_dir = ph_data->p_ep.bEndpointAddress & USB_EP_DIR_MASK;
	uchar_t ep_attr = ph_data->p_ep.bmAttributes & USB_EP_ATTR_MASK;

	flags &= USB_FLAGS_SLEEP; /* ignore other flags */

	/*
	 * Do some attributes validation checks here.
	 */
	for (i = 0; i < N_INVALID_FLAGS_ATTRS; i++) {
		if (((ep_dir == usb_invalid_flags_attrs[i].ep_dir) ||
			(usb_invalid_flags_attrs[i].ep_dir == X)) &&
		    ((ep_attr == usb_invalid_flags_attrs[i].ep_attr) ||
			(usb_invalid_flags_attrs[i].ep_attr == X)) &&
		    ((flags & usb_invalid_flags_attrs[i].usb_flags) ||
			(usb_invalid_flags_attrs[i].usb_flags == X)) &&
		    ((attrs & usb_invalid_flags_attrs[i].attrs) ||
			(usb_invalid_flags_attrs[i].attrs == X))) {
			USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
			    "invalid (%d) : flags = 0x%x, attrs = 0x%x",
			    i, flags, attrs);

			return (USB_INVALID_REQUEST);
		}
	}

	return (USB_SUCCESS);
}


/*
 * usba_rval2cr:
 *	convert rval to meaningful completion reason
 * XXX extend completion reasons to get better mapping
 */
static struct {
	int	rval;
	usb_cr_t cr;
} rval2cr[] = {
	{USB_SUCCESS,		USB_CR_OK},
	{USB_FAILURE,		USB_CR_UNSPECIFIED_ERR},
	{USB_NO_RESOURCES,	USB_CR_NO_RESOURCES},
	{USB_NO_BANDWIDTH,	USB_CR_NO_RESOURCES},
	{USB_NOT_SUPPORTED,	USB_CR_UNSPECIFIED_ERR},
	{USB_PIPE_ERROR,	USB_CR_UNSPECIFIED_ERR},
	{USB_INVALID_PIPE,	USB_CR_UNSPECIFIED_ERR},
	{USB_NO_FRAME_NUMBER,	USB_CR_UNSPECIFIED_ERR},
	{USB_INVALID_START_FRAME, USB_CR_UNSPECIFIED_ERR},
	{USB_HC_HARDWARE_ERROR, USB_CR_UNSPECIFIED_ERR},
	{USB_INVALID_REQUEST,	USB_CR_UNSPECIFIED_ERR},
	{USB_INVALID_CONTEXT,	USB_CR_UNSPECIFIED_ERR},
	{USB_INVALID_VERSION,	USB_CR_UNSPECIFIED_ERR},
	{USB_INVALID_ARGS,	USB_CR_UNSPECIFIED_ERR},
	{USB_INVALID_PERM,	USB_CR_UNSPECIFIED_ERR},
	{USB_BUSY,		USB_CR_UNSPECIFIED_ERR},
	{0xffff,		0}
};

usb_cr_t
usba_rval2cr(int rval)
{
	int i;

	for (i = 0; rval2cr[i].rval != 0xffff; i++) {
		if (rval2cr[i].rval == rval) {

			return (rval2cr[i].cr);
		}
	}

	return (USB_CR_UNSPECIFIED_ERR);
}


/*
 * usba_start_next_req:
 *	Arguments:
 *	ph_data		- pointer to pipe handle
 *
 * Currently, only ctrl/bulk requests can be queued
 */
void
usba_start_next_req(usba_pipe_handle_data_t *ph_data)
{
	usb_ctrl_req_t		*ctrl_req;
	usb_bulk_req_t		*bulk_req;
	usba_req_wrapper_t	*wrp;
	uchar_t			ep_attrs = ph_data->p_ep.bmAttributes &
							USB_EP_ATTR_MASK;
	int			rval;
	usb_pipe_state_t	state;

	mutex_enter(&ph_data->p_mutex);
	switch (ep_attrs) {
	case USB_EP_ATTR_CONTROL:
	case USB_EP_ATTR_BULK:
		switch (usba_get_ph_state(ph_data)) {
		case USB_PIPE_STATE_IDLE:
		case USB_PIPE_STATE_CLOSING:

			break;

		default:
			mutex_exit(&ph_data->p_mutex);

			return;
		}

		break;
	case USB_EP_ATTR_ISOCH:
	case USB_EP_ATTR_INTR:
	default:
		mutex_exit(&ph_data->p_mutex);

		return;
	}

	while ((wrp = (usba_req_wrapper_t *)
	    usba_rm_first_pvt_from_list(&ph_data->p_queue)) != NULL) {

		/* only submit to HCD when idle/active */

		USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_start_next_req: ph_data=0x%p state=%d", ph_data,
		    usba_get_ph_state(ph_data));

		if (ep_attrs == USB_EP_ATTR_CONTROL) {
			ph_data->p_active_cntrl_req_wrp = (usb_opaque_t)wrp;
		}

		if ((state = usba_get_ph_state(ph_data)) ==
		    USB_PIPE_STATE_IDLE) {
			usba_pipe_new_state(ph_data, USB_PIPE_STATE_ACTIVE);

			USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
			    "starting req = 0x%p", USBA_WRP2CTRL_REQ(wrp));

			switch (ep_attrs) {
			case USB_EP_ATTR_CONTROL:
				mutex_exit(&ph_data->p_mutex);
				ctrl_req = USBA_WRP2CTRL_REQ(wrp);
				/* submit to hcd */
				rval = ph_data->p_usba_device->usb_hcdi_ops->
				    usba_hcdi_pipe_ctrl_xfer(ph_data,
				    ctrl_req, wrp->wr_usb_flags);
				mutex_enter(&ph_data->p_mutex);
				break;
			case USB_EP_ATTR_BULK:
				mutex_exit(&ph_data->p_mutex);
				bulk_req = USBA_WRP2BULK_REQ(wrp);
				/* submit to hcd */
				rval = ph_data->p_usba_device->usb_hcdi_ops->
				    usba_hcdi_pipe_bulk_xfer(ph_data,
				    bulk_req, wrp->wr_usb_flags);
				mutex_enter(&ph_data->p_mutex);
				break;
			default:
				/* there shouldn't be any requests */
				rval = USB_FAILURE;
				break;
			}

			if (rval != USB_SUCCESS) {
				mutex_exit(&ph_data->p_mutex);
				usba_do_req_exc_cb(wrp,
				    usba_rval2cr(rval),
				    USB_CB_SUBMIT_FAILED);
				mutex_enter(&ph_data->p_mutex);
			}
			/* we are done */
			break;

		} else {
			mutex_exit(&ph_data->p_mutex);
			switch (state) {
			case USB_PIPE_STATE_CLOSING:
				usba_do_req_exc_cb(wrp, USB_CR_PIPE_CLOSING, 0);
				break;
			case USB_PIPE_STATE_ERROR:
			default:
				usba_do_req_exc_cb(wrp, USB_CR_FLUSHED, 0);
				break;
			}
			mutex_enter(&ph_data->p_mutex);
		}
	}

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_start_next_req done: ph_data=0x%p state=%d", ph_data,
	    usba_get_ph_state(ph_data));

	mutex_exit(&ph_data->p_mutex);
}


/*
 * usba_req_wrapper_alloc:
 *	Allocate + Initialize a usba_req_wrapper_t
 *
 * Arguments:
 *	dip	-  dev_info_t of the client driver
 *	req_len	-  sizeof request
 *	flags	-
 *		USB_FLAGS_SLEEP    - Sleep if resources are not available
 *		no USB_FLAGS_SLEEP - Don't Sleep if resources are not available
 *
 * Return Values:
 *	pointer to usba_req_wrapper_t on success; NULL on failure.
 *
 */
static usba_req_wrapper_t *
usba_req_wrapper_alloc(dev_info_t	*dip,
			size_t		req_len,
			usb_flags_t	flags)
{
	int		kmflag;
	usba_device_t	*usba_device = usba_get_usba_device(dip);
	usba_req_wrapper_t *wrp;
	size_t		wr_length = sizeof (usba_req_wrapper_t) + req_len;
	ddi_iblock_cookie_t iblock_cookie =
		usba_hcdi_get_hcdi(usba_device->usb_root_hub_dip)->
		hcdi_iblock_cookie;

	if (servicing_interrupt() && (flags & USB_FLAGS_SLEEP)) {

		return (NULL);
	}

	kmflag = (flags & USB_FLAGS_SLEEP) ? KM_SLEEP : KM_NOSLEEP;

	/* Allocate the usb_{c/b/i/i}_req + usba_req_wrapper_t structure */
	if ((wrp = kmem_zalloc(wr_length, kmflag)) != NULL) {
		wrp->wr_length	= wr_length;
		wrp->wr_dip	= dip;
		wrp->wr_req = (usb_opaque_t)USBA_SETREQ_ADDR(wrp);
		cv_init(&wrp->wr_cv, NULL, CV_DRIVER, NULL);

		/* initialize mutex for the queue */
		usba_init_list(&wrp->wr_queue, (usb_opaque_t)wrp,
						iblock_cookie);
		usba_init_list(&wrp->wr_allocated_list, (usb_opaque_t)wrp,
						iblock_cookie);

		usba_add_to_list(&usba_device->usb_allocated,
		    &wrp->wr_allocated_list);

		USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_req_wrapper_alloc: wrp = 0x%p", wrp);
	}

	return (wrp);
}


/*
 * usba_req_wrapper_free:
 *	Frees a usba_req_wrapper_t. Get rid of lists if any.
 *
 * Arguments:
 *	wrp: request wrapper structure
 */
void
usba_req_wrapper_free(usba_req_wrapper_t *wrp)
{
	usba_device_t		*usba_device;
	usba_pipe_handle_data_t	*ph_data;

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_req_wrapper_free: wrp=0x%p", wrp);

	if (wrp) {
		/* remove from	queues */
		ph_data = USBA_WRP2PH_DATA(wrp);
		if (ph_data) {
			(void) usba_rm_from_list(&ph_data->p_queue,
							&wrp->wr_queue);
		}
		usba_device = usba_get_usba_device(wrp->wr_dip);
		if (usba_rm_from_list(&usba_device->usb_allocated,
		    &wrp->wr_allocated_list) != USB_SUCCESS) {
			cmn_err(CE_PANIC,
			    "usba_req_wrapper_free: data corruption");
		}
		usba_destroy_list(&wrp->wr_queue);
		usba_destroy_list(&wrp->wr_allocated_list);
		cv_destroy(&wrp->wr_cv);
		kmem_free(wrp, wrp->wr_length);
	}
}


/*
 * usba_check_intr_context
 *	Set USB_CB_INTR_CONTEXT callback flag if executing in interrupt context
 */
usb_cb_flags_t
usba_check_intr_context(usb_cb_flags_t cb_flags)
{
	if (servicing_interrupt() != 0) {
		cb_flags |= USB_CB_INTR_CONTEXT;
	}

	return (cb_flags);
}


/*
 * usba_req_normal_cb:
 *	perform normal callback depending on request type
 */
void
usba_req_normal_cb(usba_req_wrapper_t *req_wrp)
{
	usba_pipe_handle_data_t	*ph_data = req_wrp->wr_ph_data;
	usb_pipe_handle_t	pipe_handle;
	uint_t			direction = ph_data->p_ep.bEndpointAddress &
							USB_EP_DIR_MASK;
	usb_pipe_state_t	pipe_state;

	pipe_handle = usba_get_pipe_handle(ph_data);

	mutex_enter(&ph_data->p_mutex);
	ASSERT(ph_data->p_req_count >= 0);
	pipe_state = usba_get_ph_state(ph_data);

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_req_normal_cb: "
	    "ph_data=0x%p state=%d wrp=0x%p ref=%d req=%d",
	    ph_data, pipe_state, req_wrp, usba_get_ph_ref_count(ph_data),
	    ph_data->p_req_count);

	ASSERT((pipe_state == USB_PIPE_STATE_ACTIVE) ||
	    (pipe_state == USB_PIPE_STATE_CLOSING));

	/* set done to indicate that we will do callback or cv_signal */
	ASSERT(req_wrp->wr_done == B_FALSE);
	req_wrp->wr_done = B_TRUE;

	/* update the pipe state */
	switch (req_wrp->wr_ph_data->p_ep.bmAttributes &
	    USB_EP_ATTR_MASK) {
	case USB_EP_ATTR_CONTROL:
	case USB_EP_ATTR_BULK:
		usba_pipe_new_state(ph_data, USB_PIPE_STATE_IDLE);
		break;
	case USB_EP_ATTR_INTR:
		if ((direction == USB_EP_DIR_IN) &&
		    (USBA_WRP2INTR_REQ(req_wrp)->intr_attributes &
		    USB_ATTRS_ONE_XFER)) {
			usba_pipe_new_state(ph_data, USB_PIPE_STATE_IDLE);
		} else if ((direction == USB_EP_DIR_OUT) &&
		    (ph_data->p_req_count == 0)) {
			usba_pipe_new_state(ph_data, USB_PIPE_STATE_IDLE);
		}
		break;
	case USB_EP_ATTR_ISOCH:
		if ((ph_data->p_req_count == 0) &&
		    (direction == USB_EP_DIR_OUT)) {
			usba_pipe_new_state(ph_data, USB_PIPE_STATE_IDLE);
		}
		break;
	}


	/* now complete the request */
	if (req_wrp->wr_usb_flags & USBA_WRP_FLAGS_WAIT) {
		ph_data->p_active_cntrl_req_wrp = NULL;
		cv_signal(&req_wrp->wr_cv);
		mutex_exit(&ph_data->p_mutex);
	} else {
		mutex_exit(&ph_data->p_mutex);

		/* This sets USB_CB_INTR_CONTEXT as needed. */
		usba_req_set_cb_flags(req_wrp, USB_CB_NO_INFO);

		switch (req_wrp->wr_ph_data->p_ep.bmAttributes &
		    USB_EP_ATTR_MASK) {
		case USB_EP_ATTR_CONTROL:
			USBA_WRP2CTRL_REQ(req_wrp)->ctrl_cb(pipe_handle,
						USBA_WRP2CTRL_REQ(req_wrp));
			mutex_enter(&ph_data->p_mutex);
			ph_data->p_active_cntrl_req_wrp = NULL;
			mutex_exit(&ph_data->p_mutex);
			break;
		case USB_EP_ATTR_INTR:
			USBA_WRP2INTR_REQ(req_wrp)->intr_cb(pipe_handle,
						USBA_WRP2INTR_REQ(req_wrp));
			break;
		case USB_EP_ATTR_BULK:
			USBA_WRP2BULK_REQ(req_wrp)->bulk_cb(pipe_handle,
						USBA_WRP2BULK_REQ(req_wrp));
			break;
		case USB_EP_ATTR_ISOCH:
			USBA_WRP2ISOC_REQ(req_wrp)->isoc_cb(pipe_handle,
						USBA_WRP2ISOC_REQ(req_wrp));
			break;
		}
	}

	/* we are done with this request */
	mutex_enter(&ph_data->p_mutex);
	ph_data->p_req_count--;
	ASSERT(ph_data->p_req_count >= 0);
	mutex_exit(&ph_data->p_mutex);
}


/*
 * usba_req_exc_cb:
 *	perform exception cb depending on request type.
 *	ensure the completion reason is non zero
 */
void
usba_req_exc_cb(usba_req_wrapper_t *req_wrp, usb_cr_t cr,
    usb_cb_flags_t cb_flags)
{
	usba_pipe_handle_data_t *ph_data = req_wrp->wr_ph_data;
	usb_pipe_handle_t pipe_handle = usba_get_pipe_handle(ph_data);

	mutex_enter(&req_wrp->wr_ph_data->p_mutex);
	USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_req_exc_cb: %s%d: ph_data=0x%p (ep%x) state=%d wrp=0x%p "
	    "ref=%d reqcnt=%d cr=%d",
	    ddi_driver_name(req_wrp->wr_dip),
	    ddi_get_instance(req_wrp->wr_dip),
	    ph_data, ph_data->p_ep.bEndpointAddress,
	    usba_get_ph_state(ph_data), req_wrp, usba_get_ph_ref_count(ph_data),
	    ph_data->p_req_count, req_wrp->wr_cr);

	ASSERT(req_wrp->wr_ph_data->p_req_count >= 0);

	usba_req_set_cb_flags(req_wrp, cb_flags);

	/* if there was no CR set already, set it now */
	if (req_wrp->wr_cr == USB_CR_OK) {
		req_wrp->wr_cr = (cr != USB_CR_OK)  ?
				cr : USB_CR_UNSPECIFIED_ERR;
	}

	ASSERT(req_wrp->wr_done == B_FALSE);
	req_wrp->wr_done = B_TRUE;

	switch (req_wrp->wr_ph_data->p_ep.bmAttributes &
	    USB_EP_ATTR_MASK) {
	case USB_EP_ATTR_CONTROL:
		if (USBA_WRP2CTRL_REQ(req_wrp)->
		    ctrl_completion_reason == USB_CR_OK) {
			USBA_WRP2CTRL_REQ(req_wrp)->
			    ctrl_completion_reason = req_wrp->wr_cr;
		}
		break;
	case USB_EP_ATTR_INTR:
		if (USBA_WRP2INTR_REQ(req_wrp)->
		    intr_completion_reason == USB_CR_OK) {
			USBA_WRP2INTR_REQ(req_wrp)->
			    intr_completion_reason = req_wrp->wr_cr;
		}
		break;
	case USB_EP_ATTR_BULK:
		if (USBA_WRP2BULK_REQ(req_wrp)->
		    bulk_completion_reason == USB_CR_OK) {
			USBA_WRP2BULK_REQ(req_wrp)->
			    bulk_completion_reason = req_wrp->wr_cr;
		}
		break;
	case USB_EP_ATTR_ISOCH:
		if (USBA_WRP2ISOC_REQ(req_wrp)->
		    isoc_completion_reason == USB_CR_OK) {
			USBA_WRP2ISOC_REQ(req_wrp)->
			    isoc_completion_reason = req_wrp->wr_cr;
		}
		break;
	}

	if (req_wrp->wr_usb_flags & USBA_WRP_FLAGS_WAIT) {
		cv_signal(&req_wrp->wr_cv);
		if (ph_data->p_active_cntrl_req_wrp == (usb_opaque_t)req_wrp) {
			ph_data->p_active_cntrl_req_wrp = NULL;
		}
		mutex_exit(&ph_data->p_mutex);
	} else {
		mutex_exit(&ph_data->p_mutex);
		switch (req_wrp->wr_ph_data->p_ep.bmAttributes &
		    USB_EP_ATTR_MASK) {
		case USB_EP_ATTR_CONTROL:
			USBA_WRP2CTRL_REQ(req_wrp)->ctrl_exc_cb(pipe_handle,
						USBA_WRP2CTRL_REQ(req_wrp));
			mutex_enter(&ph_data->p_mutex);
			if (ph_data->p_active_cntrl_req_wrp ==
			    (usb_opaque_t)req_wrp) {
				ph_data->p_active_cntrl_req_wrp = NULL;
			}
			mutex_exit(&ph_data->p_mutex);
			break;
		case USB_EP_ATTR_INTR:
			USBA_WRP2INTR_REQ(req_wrp)->intr_exc_cb(pipe_handle,
						USBA_WRP2INTR_REQ(req_wrp));
			break;
		case USB_EP_ATTR_BULK:
			USBA_WRP2BULK_REQ(req_wrp)->bulk_exc_cb(pipe_handle,
						USBA_WRP2BULK_REQ(req_wrp));
			break;
		case USB_EP_ATTR_ISOCH:
			USBA_WRP2ISOC_REQ(req_wrp)->isoc_exc_cb(pipe_handle,
						USBA_WRP2ISOC_REQ(req_wrp));
			break;
		}
	}

	/* we are done with this request */
	mutex_enter(&ph_data->p_mutex);
	ph_data->p_req_count--;
	ASSERT(ph_data->p_req_count >= 0);
	mutex_exit(&ph_data->p_mutex);
}


/*
 * usba_do_req_exc_cb:
 *	called when flushing requests. rather than calling usba_req_exc_cb()
 *	directly, this function uses usba_hcdi_cb() which ensures callback
 *	order is preserved
 */
void
usba_do_req_exc_cb(usba_req_wrapper_t *req_wrp, usb_cr_t cr,
    usb_cb_flags_t cb_flags)
{
	req_wrp->wr_cb_flags |= cb_flags;
	usba_hcdi_cb(req_wrp->wr_ph_data, req_wrp->wr_req, cr);
}


/*
 * usba_req_set_cb_flags:
 * This function sets the request's callback flags to those stored in the
 * request wrapper ORed with those received as an argument.  Additionally
 * USB_CB_INTR_CONTEXT is set if called from interrupt context.
 *
 * NOTE: The xfer may have succeeded, which client driver can determine
 * by looking at usb_cr_t
 */
void
usba_req_set_cb_flags(usba_req_wrapper_t *req_wrp,
		usb_cb_flags_t cb_flags)
{
	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_req_set_cb_flags: wrp=0x%p cb-flags=0x%x",
	    req_wrp, cb_flags);

	cb_flags |= req_wrp->wr_cb_flags;
	cb_flags = usba_check_intr_context(cb_flags);

	/* do the callback under taskq context */
	switch (req_wrp->wr_ph_data->p_ep.bmAttributes &
	    USB_EP_ATTR_MASK) {
	case USB_EP_ATTR_CONTROL:
		USBA_WRP2CTRL_REQ(req_wrp)->ctrl_cb_flags |= cb_flags;
		break;
	case USB_EP_ATTR_INTR:
		USBA_WRP2INTR_REQ(req_wrp)->intr_cb_flags |= cb_flags;
		break;
	case USB_EP_ATTR_BULK:
		USBA_WRP2BULK_REQ(req_wrp)->bulk_cb_flags |= cb_flags;
		break;
	case USB_EP_ATTR_ISOCH:
		USBA_WRP2ISOC_REQ(req_wrp)->isoc_cb_flags |= cb_flags;
		break;
	}
}


/*
 * usba_pipe_sync_wait:
 *	wait for the request to finish.
 *	usba_hcdi_cb() does a cv_signal thru a soft intr
 *
 * Arguments:
 *	ph_data		- pointer to pipe handle data
 *	wrp		- pointer to usba_req_wrapper_structure.
 *
 * Return Values:
 *	USB_SUCCESS	- request successfully executed
 *	USB_FAILURE	- request failed
 */
static int
usba_pipe_sync_wait(usba_pipe_handle_data_t	*ph_data,
		usba_req_wrapper_t	*wrp)
{
	ASSERT(wrp->wr_usb_flags & USB_FLAGS_SLEEP);
	ASSERT(ph_data == wrp->wr_ph_data);

	mutex_enter(&ph_data->p_mutex);
	while (wrp->wr_done != B_TRUE) {
		cv_wait(&wrp->wr_cv, &ph_data->p_mutex);
	}

	mutex_exit(&ph_data->p_mutex);

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_pipe_sync_wait: ph_data=0x%p cr=0x%x", ph_data, wrp->wr_cr);

	/* XXX return something better than USB_FAILURE?? */

	return (wrp->wr_cr == USB_CR_OK ? USB_SUCCESS : USB_FAILURE);
}


/*
 * Allocate usb control request and a USB request wrapper
 *
 * Arguments:
 *	dip	- dev_info_t of the client driver
 *	len	- length of "data" for this control request
 *	flags:
 *		USB_FLAGS_SLEEP	- Sleep if resources are not available
 *		no USB_FLAGS_SLEEP - Don't Sleep if resources are not available
 *
 * Return Values:	usb_ctrl_req_t on success, NULL on failure
 */
usb_ctrl_req_t *
usb_alloc_ctrl_req(dev_info_t	*dip,
		size_t		len,
		usb_flags_t	flags)
{
	usb_ctrl_req_t	*ctrl_req = NULL;
	usba_req_wrapper_t	*wrp;

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_alloc_ctrl_req: dip=0x%p, wlen=0x%lx, flags=0x%x",
	    dip, len, flags);

	/* Allocate + Initialize the usba_req_wrapper_t structure */
	if (dip &&
	    ((wrp = usba_req_wrapper_alloc(dip, sizeof (*ctrl_req), flags)) !=
	    NULL)) {
		ctrl_req = USBA_WRP2CTRL_REQ(wrp);

		/* Allocate the usb_ctrl_req data mblk */
		if (len) {
			if (flags & USB_FLAGS_SLEEP) {
				ctrl_req->ctrl_data = allocb_wait(len, BPRI_LO,
							STR_NOSIG, NULL);
			} else	if ((ctrl_req->ctrl_data =
			    allocb(len, BPRI_HI)) == NULL) {
				usba_req_wrapper_free(wrp);
				ctrl_req = NULL;
			}
		}
	}

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_alloc_ctrl_req: ctrl_req = 0x%p", ctrl_req);

	return (ctrl_req);
}


/*
 * usb_free_ctrl_req:
 *	free USB control request + wrapper
 *
 * Arguments:
 *	req - pointer to usb_ctrl_req_t
 */
void
usb_free_ctrl_req(usb_ctrl_req_t *req)
{
	if (req) {
		USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usb_free_ctrl_req: req = 0x%p", req);

		if (req->ctrl_data) {
			freemsg(req->ctrl_data);
		}
		usba_req_wrapper_free(USBA_REQ2WRP(req));
	}
}


/*
 * Client driver calls this function to issue the control
 * request to the USBA
 *
 * Arguments:
 *	pipe_handle:  control pipe pipehandle (obtained via usb_pipe_open()
 *	req: control request
 *	usb_flags:
 *		USB_FLAGS_SLEEP - wait for the request to complete
 *
 * Return Values:
 *	USB_SUCCESS	- request successfully executed
 *	USB_FAILURE	- request failed
 */
int
usb_pipe_ctrl_xfer(usb_pipe_handle_t	pipe_handle,
		usb_ctrl_req_t		*req,
		usb_flags_t		usb_flags)
{
	int			rval;
	usba_req_wrapper_t	*wrp = USBA_REQ2WRP(req);
	usba_pipe_handle_data_t	*ph_data = usba_hold_ph_data(pipe_handle);
	usba_device_t		*usba_device;
	usb_flags_t		wrp_usb_flags;
	usb_pipe_state_t	pipe_state;

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_pipe_ctrl_xfer: req=0x%p, wrp=0x%p\n\t"
	    "setup = 0x%x 0x%x 0x%x 0x%x 0x%x uf=0x%x",
	    req, wrp, req->ctrl_bmRequestType, req->ctrl_bRequest,
	    req->ctrl_wValue, req->ctrl_wIndex, req->ctrl_wLength, usb_flags);

	if (ph_data == NULL) {

		return (USB_INVALID_PIPE);
	}

	mutex_enter(&ph_data->p_mutex);
	usba_device = ph_data->p_usba_device;

	if ((rval = usba_check_req(ph_data, (usb_opaque_t)req, usb_flags,
	    USB_EP_ATTR_CONTROL)) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "request rejected: rval=%d", rval);
		mutex_exit(&ph_data->p_mutex);

		usba_release_ph_data(ph_data->p_ph_impl);

		return (rval);
	}

	ASSERT(ph_data == wrp->wr_ph_data);

	/* we accepted the request, so increment the req count */
	ph_data->p_req_count++;

	wrp_usb_flags = wrp->wr_usb_flags;

	/* Get the current bulk pipe state */
	pipe_state = usba_get_ph_state(ph_data);

	/*
	 * if this is for the default pipe, and the pipe is in error,
	 * just queue the request. autoclearing will start this request
	 *
	 * if there is already an active request in the queue
	 * then just add this request to the queue.
	 */
	switch (pipe_state) {
	case USB_PIPE_STATE_IDLE:
		if (ph_data->p_queue.next ||
		    ph_data->p_active_cntrl_req_wrp) {
			USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
			    "usb_pipe_ctrl_xfer: queue request 0x%p", req);

			usba_add_to_list(&ph_data->p_queue, &wrp->wr_queue);
			rval = USB_SUCCESS;
			mutex_exit(&ph_data->p_mutex);
		} else {
			usba_pipe_new_state(ph_data, USB_PIPE_STATE_ACTIVE);
			ph_data->p_active_cntrl_req_wrp = (usb_opaque_t)wrp;
			mutex_exit(&ph_data->p_mutex);

			/* issue the request to HCD */
			rval = usba_device->usb_hcdi_ops->
			    usba_hcdi_pipe_ctrl_xfer(ph_data, req, usb_flags);
		}
		break;
	case USB_PIPE_STATE_ACTIVE:
		USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usb_pipe_ctrl_xfer: queue request 0x%p", req);

		usba_add_to_list(&ph_data->p_queue, &wrp->wr_queue);
		rval = USB_SUCCESS;
		mutex_exit(&ph_data->p_mutex);
		break;
	case USB_PIPE_STATE_ERROR:
		if (USBA_IS_DEFAULT_PIPE(ph_data)) {
			USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
			    "usb_pipe_ctrl_xfer: queue request 0x%p on "
			    "pending def pipe error", req);

			usba_add_to_list(&ph_data->p_queue, &wrp->wr_queue);
			rval = USB_SUCCESS;
		} else {
			USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
			    "usb_pipe_ctrl_xfer: pipe is in error state ");

			rval = USB_PIPE_ERROR;
		}
		mutex_exit(&ph_data->p_mutex);
		break;
	default:
		USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usb_pipe_ctrl_xfer: pipe state %d", pipe_state);

		rval = USB_PIPE_ERROR;
		mutex_exit(&ph_data->p_mutex);
		break;
	}

	/* if there has been a failure, decrement req count */
	if (rval != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usb_pipe_ctrl_xfer: hcd failed req 0x%p", req);

		if (req->ctrl_completion_reason == USB_CR_OK) {
			req->ctrl_completion_reason = usba_rval2cr(rval);
		}
		mutex_enter(&ph_data->p_mutex);
		ASSERT(wrp->wr_done == B_FALSE);
		ph_data->p_req_count--;
		ASSERT(ph_data->p_req_count >= 0);
		ph_data->p_active_cntrl_req_wrp = NULL;
		if ((ph_data->p_req_count == 0) &&
		    (usba_get_ph_state(ph_data) == USB_PIPE_STATE_ACTIVE)) {
			usba_pipe_new_state(ph_data, USB_PIPE_STATE_IDLE);
		}
		mutex_exit(&ph_data->p_mutex);

	/* if success and sleep specified, wait for completion */
	} else if (wrp_usb_flags & USBA_WRP_FLAGS_WAIT) {
		rval = usba_pipe_sync_wait(ph_data, wrp);
	}

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_pipe_ctrl_xfer: rval=0x%x", rval);

	usba_release_ph_data(ph_data->p_ph_impl);

	return (rval);
}


/*
 * usb_pipe_sync_ctrl_xfer():
 *	for simple synchronous control transactions this wrapper function
 *	will perform the allocation, xfer, and deallocation
 *	USB_ATTRS_AUTOCLEARING will be enabled
 *
 * Arguments:
 *	dip		- pointer to clients devinfo
 *	pipe_handle	- control pipe pipehandle (obtained via usb_pipe_open()
 *	bmRequestType	- characteristics of request
 *	bRequest	- specific request
 *	wValue		- varies according to request
 *	wIndex		- index or offset
 *	wLength		- number of bytes to xfer
 *	data		- pointer to pointer to data and may be NULL if
 *			  wLength is 0
 *	attrs		- required request attributes
 *	completion_reason - completion status
 *	cb_flags	- request completions flags
 *	flags		- none
 *
 * Return Values:
 *	USB_SUCCESS	- request successfully executed
 *	USB_*		- request failed
 *
 * Notes:
 * - in the case of failure, the client should check completion_reason and
 *	and cb_flags and determine further recovery action
 * - the client should check data and if non-zero, free the data on
 *	completion
 */
int
usb_pipe_sync_ctrl_xfer(dev_info_t *dip,
		usb_pipe_handle_t pipe_handle,
		uchar_t		bmRequestType,
		uchar_t		bRequest,
		uint16_t	wValue,
		uint16_t	wIndex,
		uint16_t	wLength,
		mblk_t		**data,
		usb_req_attrs_t	attributes,
		usb_cr_t	*completion_reason,
		usb_cb_flags_t	*cb_flags,
		usb_flags_t	flags)
{
	usba_pipe_handle_data_t	*ph_data;
	int			rval;
	usb_ctrl_req_t		*ctrl_req;
	size_t			length;
#ifdef DEBUG
#define	BUFSIZE	256
	char			*buf = kmem_alloc(BUFSIZE, KM_SLEEP);
#endif

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_pipe_sync_ctrl_xfer: ph=0x%p\n\t"
	    "setup = 0x%x 0x%x 0x%x 0x%x 0x%x uf = 0x%x", pipe_handle,
	    bmRequestType, bRequest, wValue, wIndex, wLength, flags);

	if ((ph_data = usba_hold_ph_data(pipe_handle)) == NULL) {
		rval = USB_INVALID_PIPE;

		goto done;
	}
	if (servicing_interrupt()) {
		rval = USB_INVALID_CONTEXT;

		goto done;
	}
	if (dip == NULL) {
		rval = USB_INVALID_ARGS;

		goto done;
	}

	length = ((data) && (*data)) ? 0: wLength;

	ctrl_req = usb_alloc_ctrl_req(dip,
	    length, flags | USB_FLAGS_SLEEP);

	/* Initialize the ctrl_req structure */
	ctrl_req->ctrl_bmRequestType	= bmRequestType;
	ctrl_req->ctrl_bRequest 	= bRequest;
	ctrl_req->ctrl_wValue		= wValue;
	ctrl_req->ctrl_wIndex		= wIndex;
	ctrl_req->ctrl_wLength		= wLength;
	ctrl_req->ctrl_data		= ctrl_req->ctrl_data ?
						ctrl_req->ctrl_data :
						((data) ? *data : NULL);
	ctrl_req->ctrl_timeout		= USB_PIPE_TIMEOUT;
	ctrl_req->ctrl_attributes	= attributes | USB_ATTRS_AUTOCLEARING;

	/* Issue control xfer to the HCD */
	rval = usb_pipe_ctrl_xfer(pipe_handle, ctrl_req,
	    flags | USB_FLAGS_SLEEP);

#ifdef DEBUG
	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "req=0x%p, cr=%s cb_flags=%s data=0x%p rval=%s",
	    ctrl_req, usb_str_cr(ctrl_req->ctrl_completion_reason),
	    usb_str_cb_flags(ctrl_req->ctrl_cb_flags, buf, BUFSIZE),
	    ctrl_req->ctrl_data, usb_str_rval(rval));
#endif

	/* copy back ctrl_req values */
	if (data) {
		*data			= ctrl_req->ctrl_data;
	}
	if (completion_reason) {
		*completion_reason	= ctrl_req->ctrl_completion_reason;
	}
	if (cb_flags) {
		*cb_flags		= ctrl_req->ctrl_cb_flags;
	}

	/* Free up the control request now */
	ctrl_req->ctrl_data = NULL; /* leave to client to free */
	usb_free_ctrl_req(ctrl_req);

done:
#ifdef DEBUG
	kmem_free(buf, BUFSIZE);
#endif
	if (ph_data) {
		usba_release_ph_data(ph_data->p_ph_impl);
	}

	return (rval);
}


/*
 * usb_pipe_ctrl_xfer_wait():
 *	Easy-to-use wrapper around usb_pipe_sync_ctrl_xfer.
 *
 * ARGUMENTS:
 *	pipe_handle	- control pipe pipehandle (obtained via usb_pipe_open())
 *	setup		- setup descriptor params, attributes
 *	data		- pointer to pointer to data and may be NULL when
 *			  wLength is 0
 *	completion_reason - completion status.
 *	cb_flags	- request completions flags.
 *	flags		- none.
 *
 * RETURN VALUES:
 *	USB_SUCCESS	- request successfully executed.
 *	USB_*		- failure
 */
int
usb_pipe_ctrl_xfer_wait(
		usb_pipe_handle_t	pipe_handle,
		usb_ctrl_setup_t	*setup,
		mblk_t			**data,
		usb_cr_t		*completion_reason,
		usb_cb_flags_t		*cb_flags,
		usb_flags_t		flags)
{
	return (usb_pipe_sync_ctrl_xfer(
				usba_get_dip(pipe_handle),
				pipe_handle,
				setup->bmRequestType,
				setup->bRequest,
				setup->wValue,
				setup->wIndex,
				setup->wLength,
				data,
				setup->attrs,
				completion_reason,
				cb_flags,
				flags));
}


/*
 * usb_alloc_bulk_req:
 *	Allocate a usb bulk request + usba_req_wrapper_t
 *
 * Arguments:
 *	dip	- dev_info_t of the client driver
 *	len	- length of "data" for this bulk request
 *	flags:
 *		USB_FLAGS_SLEEP    - Sleep if resources are not available
 *
 * Return Values:
 *	usb_bulk_req_t on success, NULL on failure
 */
usb_bulk_req_t *
usb_alloc_bulk_req(dev_info_t	*dip,
		size_t		len,
		usb_flags_t	flags)
{
	usb_bulk_req_t		*bulk_req = NULL;
	usba_req_wrapper_t	*wrp;

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_alloc_bulk_req: dip=0x%p wlen=0x%lx flags=0x%x",
	    dip, len, flags);

	/* Allocate + Initialize the usba_req_wrapper_t structure */
	if (dip &&
	    ((wrp = usba_req_wrapper_alloc(dip, sizeof (*bulk_req), flags)) !=
	    NULL)) {
		bulk_req = USBA_WRP2BULK_REQ(wrp);

		/* Allocate the usb_bulk_req data mblk */
		if (len) {
			if (flags & USB_FLAGS_SLEEP) {
				bulk_req->bulk_data = allocb_wait(len,
				    BPRI_LO, STR_NOSIG, NULL);
			} else	if ((bulk_req->bulk_data =
			    allocb(len, BPRI_HI)) == NULL) {
				usba_req_wrapper_free(wrp);
				bulk_req = NULL;
			}
		}

	}

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_alloc_bulk_req: bulk_req = 0x%p", bulk_req);

	return (bulk_req);
}


/*
 * usb_free_bulk_req:
 *	free USB bulk request + wrapper
 *
 * Arguments:
 *	req - pointer to usb_bulk_req_t
 */
void
usb_free_bulk_req(usb_bulk_req_t *req)
{
	if (req) {
		USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usb_free_bulk_req: req=0x%p", req);

		if (req->bulk_data) {
			freemsg(req->bulk_data);
		}
		usba_req_wrapper_free(USBA_REQ2WRP(req));
	}
}


/*
 * Client driver calls this function to issue the bulk xfer to the USBA
 *
 * Arguments:-
 *	pipe_handle - bulk pipe handle (obtained via usb_pipe_open()
 *	req	    - bulk data xfer request (IN or OUT)
 *	usb_flags   - USB_FLAGS_SLEEP - wait for the request to complete
 *
 * Return Values:
 *	USB_SUCCESS - success
 *	USB_FAILURE - unspecified failure
 */
int
usb_pipe_bulk_xfer(usb_pipe_handle_t	pipe_handle,
		usb_bulk_req_t		*req,
		usb_flags_t		usb_flags)
{
	int			rval;
	usba_req_wrapper_t	*wrp = USBA_REQ2WRP(req);
	usba_pipe_handle_data_t	*ph_data = usba_hold_ph_data(pipe_handle);
	usba_device_t		*usba_device;
	usb_flags_t		wrp_usb_flags;
	usb_pipe_state_t	pipe_state;

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_pipe_bulk_xfer: req=0x%p uf=0x%x", req, usb_flags);

	if (ph_data == NULL) {

		return (USB_INVALID_PIPE);
	}

	mutex_enter(&ph_data->p_mutex);
	usba_device = ph_data->p_usba_device;

	if ((rval = usba_check_req(ph_data, (usb_opaque_t)req, usb_flags,
	    USB_EP_ATTR_BULK)) != USB_SUCCESS) {
		mutex_exit(&ph_data->p_mutex);

		usba_release_ph_data(ph_data->p_ph_impl);

		return (rval);
	}

	/* we accepted the request */
	ph_data->p_req_count++;
	wrp_usb_flags = wrp->wr_usb_flags;

	/* Get the current bulk pipe state */
	pipe_state = usba_get_ph_state(ph_data);

	/*
	 * if there is already an active request in the queue
	 * then just add this request to the queue.
	 */
	switch (pipe_state) {
	case USB_PIPE_STATE_IDLE:
		if (ph_data->p_queue.next) {
			USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
			    "usb_pipe_bulk_xfer: queue request 0x%p", req);

			usba_add_to_list(&ph_data->p_queue, &wrp->wr_queue);
			rval = USB_SUCCESS;
			mutex_exit(&ph_data->p_mutex);
		} else {
			usba_pipe_new_state(ph_data, USB_PIPE_STATE_ACTIVE);
			mutex_exit(&ph_data->p_mutex);

			/* issue the request to HCD */
			rval = usba_device->usb_hcdi_ops->
			    usba_hcdi_pipe_bulk_xfer(ph_data, req, usb_flags);
		}
		break;
	case USB_PIPE_STATE_ACTIVE:
		USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usb_pipe_bulk_xfer: queue request 0x%p", req);

		usba_add_to_list(&ph_data->p_queue, &wrp->wr_queue);
		rval = USB_SUCCESS;
		mutex_exit(&ph_data->p_mutex);
		break;
	default:
		USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usb_pipe_bulk_xfer: pipe state %d", pipe_state);

		rval = USB_PIPE_ERROR;
		mutex_exit(&ph_data->p_mutex);
		break;
	}

	if (rval != USB_SUCCESS) {
		if (req->bulk_completion_reason == USB_CR_OK) {
			req->bulk_completion_reason = usba_rval2cr(rval);
		}
		mutex_enter(&ph_data->p_mutex);
		ASSERT(wrp->wr_done == B_FALSE);
		ph_data->p_req_count--;
		ASSERT(ph_data->p_req_count >= 0);
		if ((ph_data->p_req_count == 0) &&
		    (usba_get_ph_state(ph_data) == USB_PIPE_STATE_ACTIVE)) {
			usba_pipe_new_state(ph_data, USB_PIPE_STATE_IDLE);
		}
		mutex_exit(&ph_data->p_mutex);
	} else if (wrp_usb_flags & USBA_WRP_FLAGS_WAIT) {
		rval = usba_pipe_sync_wait(ph_data, wrp);
	}

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_pipe_bulk_xfer: rval=%d", rval);

	usba_release_ph_data(ph_data->p_ph_impl);

	return (rval);
}


/*
 * usb_pipe_bulk_transfer_size:
 *	- request HCD to return bulk max transfer data size
 *
 * Arguments:
 *	dip	- pointer to dev_info_t
 *	size	- pointer to bulk_transfer_size
 *
 * Return Values:
 *	USB_SUCCESS	- request successfully executed
 *	USB_FAILURE	- request failed
 */
int
usb_pipe_bulk_transfer_size(dev_info_t	*dip,
			size_t		*size)
{
	return (usb_pipe_get_max_bulk_transfer_size(dip, size));
}


int
usb_pipe_get_max_bulk_transfer_size(dev_info_t	*dip,
			size_t		*size)
{
	usba_device_t	*usba_device;

	if ((dip == NULL) || (size == NULL)) {

		return (USB_INVALID_ARGS);
	}
	usba_device = usba_get_usba_device(dip);

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_pipe_bulk_transfer_size: usba_device=0x%p", usba_device);

	if ((usba_device) &&
	    (usba_device->usb_hcdi_ops->usba_hcdi_bulk_transfer_size)) {

		return (usba_device->usb_hcdi_ops->
		    usba_hcdi_bulk_transfer_size(usba_device, size));
	} else {
		*size = 0;

		return (USB_FAILURE);
	}
}


/*
 * usb_alloc_intr_req:
 *	Allocate usb interrupt request
 *
 * Arguments:
 *	dip	- dev_info_t of the client driver
 *	len	- length of "data" for this interrupt request
 *	flags	-
 *		USB_FLAGS_SLEEP    - Sleep if resources are not available
 *
 * Return Values:
 *		usb_intr_req_t on success, NULL on failure
 */
usb_intr_req_t *
usb_alloc_intr_req(dev_info_t	*dip,
		size_t		len,
		usb_flags_t	flags)
{
	usb_intr_req_t	*intr_req = NULL;
	usba_req_wrapper_t	*wrp;

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_alloc_intr_req: dip=0x%p, len=0x%lx, flags=0x%x",
	    dip, len, flags);

	/* Allocate + Initialize the usba_req_wrapper_t structure */
	if ((dip &&
	    (wrp = usba_req_wrapper_alloc(dip, sizeof (*intr_req), flags)) !=
	    NULL)) {
		intr_req = (usb_intr_req_t *)USBA_WRP2INTR_REQ(wrp);

		/* Allocate the usb_intr_req data mblk */
		if (len) {
			if (flags & USB_FLAGS_SLEEP) {
				intr_req->intr_data = allocb_wait(len, BPRI_LO,
							STR_NOSIG, NULL);
			} else	if ((intr_req->intr_data =
			    allocb(len, BPRI_HI)) == NULL) {
				usba_req_wrapper_free(wrp);
				intr_req = NULL;
			}
		}
	}

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_alloc_intr_req: intr_req=0x%p", intr_req);

	return (intr_req);
}


/*
 * usba_hcdi_dup_intr_req:
 *	create duplicate of interrupt request
 *
 * Arguments:
 *	dip	- devinfo pointer
 *	reqp	- original requestp pointer
 *	len	- length of "data" for this interrupt request
 *	flags	-
 *		USB_FLAGS_SLEEP    - Sleep if resources are not available
 *
 * Return Values:
 *		usb_intr_req_t on success, NULL on failure
 */
usb_intr_req_t *
usba_hcdi_dup_intr_req(
		dev_info_t	*dip,
		usb_intr_req_t	*reqp,
		size_t		len,
		usb_flags_t	flags)
{
	usb_intr_req_t		*intr_reqp = NULL;
	usba_req_wrapper_t	*intr_wrp, *req_wrp;

	if (reqp == NULL) {

		return (NULL);
	}

	req_wrp	= USBA_REQ2WRP(reqp);

	if (((intr_reqp = usb_alloc_intr_req(dip, len, flags)) != NULL)) {
		intr_reqp->intr_client_private	= reqp->intr_client_private;
		intr_reqp->intr_timeout		= reqp->intr_timeout;
		intr_reqp->intr_attributes	= reqp->intr_attributes;
		intr_reqp->intr_len		= reqp->intr_len;
		intr_reqp->intr_cb		= reqp->intr_cb;
		intr_reqp->intr_exc_cb		= reqp->intr_exc_cb;

		intr_wrp		= USBA_REQ2WRP(intr_reqp);
		intr_wrp->wr_dip	= req_wrp->wr_dip;
		intr_wrp->wr_ph_data	= req_wrp->wr_ph_data;
		intr_wrp->wr_attrs	= req_wrp->wr_attrs;
		intr_wrp->wr_usb_flags	= req_wrp->wr_usb_flags;
	}

	return (intr_reqp);
}


/*
 * usb_free_intr_req:
 *	free USB intr request + wrapper
 *
 * Arguments:
 *	req - pointer to usb_intr_req_t
 */
void
usb_free_intr_req(usb_intr_req_t *req)
{
	if (req) {
		USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usb_free_intr_req: req = 0x%p", req);

		if (req->intr_data) {
			freemsg(req->intr_data);
		}

		usba_req_wrapper_free(USBA_REQ2WRP(req));
	}
}


/*
 * Client driver calls this function to issue the intr xfer to the USBA
 *
 * Arguments:-
 *	pipe_handle	- intr pipe handle (obtained via usb_pipe_open()
 *	req		- intr data xfer request (IN or OUT)
 *	flags		-
 *			   USB_FLAGS_SLEEP - wait for the request to complete
 * Return Values
 *	USB_SUCCESS	- success
 *	USB_FAILURE	- unspecified failure
 */
int
usb_pipe_intr_xfer(usb_pipe_handle_t	pipe_handle,
		usb_intr_req_t		*req,
		usb_flags_t		usb_flags)
{
	int			rval;
	usba_req_wrapper_t	*wrp = USBA_REQ2WRP(req);
	usba_ph_impl_t		*ph_impl = (usba_ph_impl_t *)pipe_handle;
	usba_pipe_handle_data_t	*ph_data = usba_hold_ph_data(pipe_handle);
	usba_device_t		*usba_device;
	uchar_t			direction;
	usb_flags_t		wrp_usb_flags;
	usb_pipe_state_t	pipe_state;

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_pipe_intr_req: req=0x%p uf=0x%x",
	    req, usb_flags);

	if (ph_data == NULL) {

		return (USB_INVALID_PIPE);
	}
	usba_device = ph_data->p_usba_device;
	direction = ph_data->p_ep.bEndpointAddress & USB_EP_DIR_MASK;

	mutex_enter(&ph_data->p_mutex);
	if ((rval = usba_check_req(ph_data, (usb_opaque_t)req, usb_flags,
	    USB_EP_ATTR_INTR)) != USB_SUCCESS) {
		mutex_exit(&ph_data->p_mutex);

		usba_release_ph_data(ph_data->p_ph_impl);

		return (rval);
	}

	/* Get the current interrupt pipe state */
	pipe_state = usba_get_ph_state(ph_data);

	switch (pipe_state) {
	case USB_PIPE_STATE_IDLE:
		/*
		 * if the pipe state is in middle of transition,
		 * i.e. stop polling is in progress, fail any
		 * attempt to do a start polling
		 */
		mutex_enter(&ph_impl->usba_ph_mutex);
		if (ph_impl->usba_ph_state_changing > 0) {
			mutex_exit(&ph_impl->usba_ph_mutex);

			mutex_exit(&ph_data->p_mutex);
			usba_release_ph_data(ph_data->p_ph_impl);

			USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
			    "usb_pipe_intr_req: fail request - "
			    "stop polling in progress");

			return (USB_FAILURE);
		} else {
			mutex_exit(&ph_impl->usba_ph_mutex);
			usba_pipe_new_state(ph_data, USB_PIPE_STATE_ACTIVE);
		}

		break;
	case USB_PIPE_STATE_ACTIVE:
		/*
		 * If this is interrupt IN pipe and if we are
		 * already polling, return failure.
		 */
		if (direction == USB_EP_DIR_IN) {
			USB_DPRINTF_L4(DPRINT_MASK_USBAI,
			    usbai_log_handle,
			    "usb_pipe_intr_req: already polling");

			mutex_exit(&ph_data->p_mutex);
			usba_release_ph_data(ph_data->p_ph_impl);

			return (USB_FAILURE);
		}

		break;
	default:
		USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usb_pipe_intr_req: pipe state %d", pipe_state);

		mutex_exit(&ph_data->p_mutex);
		usba_release_ph_data(ph_data->p_ph_impl);

		return (USB_PIPE_ERROR);
	}

	/* we accept the request */
	wrp_usb_flags = wrp->wr_usb_flags;
	ph_data->p_req_count++;

	mutex_exit(&ph_data->p_mutex);

	/* issue the request out */
	if ((rval = usba_device->usb_hcdi_ops->usba_hcdi_pipe_intr_xfer(ph_data,
	    req, usb_flags)) != USB_SUCCESS) {

		/* the request failed, decrement the ref_count */
		if (req->intr_completion_reason == USB_CR_OK) {
			req->intr_completion_reason = usba_rval2cr(rval);
		}
		mutex_enter(&ph_data->p_mutex);
		ASSERT(wrp->wr_done == B_FALSE);
		ph_data->p_req_count--;
		ASSERT(ph_data->p_req_count >= 0);
		if ((ph_data->p_req_count == 0) &&
		    (usba_get_ph_state(ph_data) == USB_PIPE_STATE_ACTIVE)) {
			usba_pipe_new_state(ph_data, USB_PIPE_STATE_IDLE);
		}
		mutex_exit(&ph_data->p_mutex);

	/* if sleep specified, wait for completion */
	} else if (wrp_usb_flags & USBA_WRP_FLAGS_WAIT) {
		rval = usba_pipe_sync_wait(ph_data, wrp);
	}

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_pipe_intr_req: rval=0x%x", rval);

	usba_release_ph_data(ph_data->p_ph_impl);

	return (rval);
}


/*
 * usba_pipe_sync_stop_intr_polling:
 *	- set up for sync transport, if necessary
 *	- request HCD to stop polling
 *	- wait for draining of all callbacks
 */
/*ARGSUSED*/
static int
usba_pipe_sync_stop_intr_polling(dev_info_t	*dip,
		usba_ph_impl_t		*ph_impl,
		usba_pipe_async_req_t	*request,
		usb_flags_t		flags)
{
	int rval;
	usba_pipe_handle_data_t *ph_data;
	usba_device_t	*usba_device;

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_pipe_sync_stop_intr_polling: flags=0x%x", flags);

	ph_data = usba_get_ph_data((usb_pipe_handle_t)ph_impl);
	if (ph_data == NULL) {
		usba_release_ph_data(ph_impl);
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_sync_stop_intr_polling: pipe closed");

		return (USB_INVALID_PIPE);
	}

	usba_device = ph_data->p_usba_device;

	mutex_enter(&ph_data->p_mutex);

	if (usba_get_ph_state(ph_data) == USB_PIPE_STATE_ERROR) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_sync_stop_intr_polling: pipe error");
		mutex_exit(&ph_data->p_mutex);

		usba_release_ph_data(ph_impl);

		return (USB_PIPE_ERROR);
	}

	if (usba_get_ph_state(ph_data) == USB_PIPE_STATE_IDLE) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_sync_stop_intr_polling: already idle");
		mutex_exit(&ph_data->p_mutex);

		usba_release_ph_data(ph_impl);

		return (USB_SUCCESS);
	}
	mutex_exit(&ph_data->p_mutex);

	mutex_enter(&ph_impl->usba_ph_mutex);
	ph_impl->usba_ph_state_changing++;
	mutex_exit(&ph_impl->usba_ph_mutex);

	flags |= USB_FLAGS_SLEEP;

	for (;;) {
		rval = usba_device->usb_hcdi_ops->
			usba_hcdi_pipe_stop_intr_polling(ph_data, flags);

		/*
		 * The host controller has stopped polling of the endpoint.
		 * Now, drain the callbacks if there are any on the callback
		 * queue.
		 */
		if (rval == USB_SUCCESS) {
			mutex_enter(&ph_data->p_mutex);

			/*
			 * there is a tiny window that the client driver
			 * may still have restarted the polling and we
			 * have to let the stop polling win)
			 */
			rval = usba_drain_cbs(ph_data, 0,
						USB_CR_STOPPED_POLLING);
			mutex_exit(&ph_data->p_mutex);
			if (rval != USB_SUCCESS) {

				continue;
			}
		}

		break;
	}

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_pipe_sync_stop_intr_polling: rval=0x%x", rval);

	mutex_enter(&ph_impl->usba_ph_mutex);
	ph_impl->usba_ph_state_changing--;
	mutex_exit(&ph_impl->usba_ph_mutex);

	usba_release_ph_data(ph_impl);

	return (rval);
}


/*
 * dummy callback function for stop polling
 */
static void
usba_dummy_callback(
	usb_pipe_handle_t ph,
	usb_opaque_t arg,
	int rval,
	usb_cb_flags_t flags)
{
	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_dummy_callback: "
	    "ph=0x%p rval=0x%x flags=0x%x cb_arg=0x%p",
	    ph, rval, flags, arg);
}


/*
 * usb_pipe_stop_intr_polling:
 *	stop polling for interrupt pipe IN data
 *	The HCD doesn't do a usba_hcdi_cb().
 *	It just returns success/failure
 * Arguments:
 *	pipe_handle	- pipe handle
 *	flags		-
 *			USB_FLAGS_SLEEP:	wait for completion
 */
void
usb_pipe_stop_intr_polling(usb_pipe_handle_t pipe_handle,
	usb_flags_t	flags)
{
	usba_pipe_handle_data_t *ph_data = usba_hold_ph_data(pipe_handle);

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_pipe_stop_intr_polling: flags=0x%x", flags);

	if (ph_data == NULL) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_stop_intr_polling: pipe closed");

		return;
	}

	if ((ph_data->p_ep.bmAttributes &
	    USB_EP_ATTR_MASK) != USB_EP_ATTR_INTR) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_stop_intr_polling: wrong pipe type");

		usba_release_ph_data(ph_data->p_ph_impl);

		return;
	}

	if ((ph_data->p_ep.bEndpointAddress & USB_EP_DIR_IN) == 0) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_stop_intr_polling: wrong pipe direction");

		usba_release_ph_data(ph_data->p_ph_impl);

		return;
	}

	if (servicing_interrupt() && (flags & USB_FLAGS_SLEEP)) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_stop_intr_polling: invalid context");

		usba_release_ph_data(ph_data->p_ph_impl);

		return;
	}

	(void) usba_pipe_setup_func_call(ph_data->p_dip,
	    usba_pipe_sync_stop_intr_polling,
	    (usba_ph_impl_t *)pipe_handle, (usb_opaque_t)flags,
	    flags, usba_dummy_callback, NULL);
}


/*
 * usb_alloc_isoc_req:
 *	- Allocate usb isochronous resources that includes usb isochronous
 *	  request and array of packet descriptor structures and wrapper.
 *
 * Arguments:
 *	dip		- dev_info_t of the client driver
 *	isoc_pkts_count - number of isoc_pkt_descr_t's
 *	len		- length of "data" for this isochronous request
 *	flags		-
 *		USB_FLAGS_SLEEP    - Sleep if resources are not available
 *		no USB_FLAGS_SLEEP - Don't Sleep if resources are not available
 *
 * Return Values:
 *	usb_isoc_req_t on success, NULL on failure
 */
/*ARGSUSED*/
usb_isoc_req_t *
usb_alloc_isoc_req(dev_info_t		*dip,
		uint_t			isoc_pkts_count,
		size_t			len,
		usb_flags_t		flags)
{
	usb_isoc_req_t		*isoc_req = NULL;
	usba_req_wrapper_t	*wrp;
	size_t			length = sizeof (*isoc_req) +
			(sizeof (usb_isoc_pkt_descr_t) * isoc_pkts_count);

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_alloc_isoc_req: dip=0x%p pkt_cnt=%d len=%lu flags=0x%x",
	    dip, isoc_pkts_count, len, flags);

	/* client needs to set isoc_pks_count */
	if (dip && isoc_pkts_count) {
		/* Allocate + Initialize the usba_req_wrapper_t structure */
		if ((wrp = usba_req_wrapper_alloc(dip, length, flags)) !=
		    NULL) {
			isoc_req = (usb_isoc_req_t *)USBA_WRP2ISOC_REQ(wrp);

			/* Allocate the usb_isoc_req data mblk */
			if (len) {
				if ((isoc_req->isoc_data =
				    allocb(len, BPRI_HI)) == NULL) {
					usba_req_wrapper_free(wrp);
					isoc_req = NULL;
				}
			}
		}
	}

	if (isoc_req) {
		isoc_req->isoc_pkt_descr = (usb_isoc_pkt_descr_t *)
		    (((intptr_t)isoc_req) + (sizeof (usb_isoc_req_t)));

		/* Initialize all the fields of usb isochronous request */
		isoc_req->isoc_pkts_count = isoc_pkts_count;
	}

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_alloc_isoc_req: isoc_req = 0x%p", isoc_req);

	return (isoc_req);
}


/*
 * usba_hcdi_dup_isoc_req:
 *	create duplicate of isoc request
 *
 * Arguments:
 *	dip	- devinfo pointer
 *	reqp	- original request pointer
 *	len	- length of "data" for this isoc request
 *	flags	-
 *		USB_FLAGS_SLEEP    - Sleep if resources are not available
 *
 * Return Values:
 *		usb_isoc_req_t on success, NULL on failure
 */
usb_isoc_req_t *
usba_hcdi_dup_isoc_req(
		dev_info_t	*dip,
		usb_isoc_req_t	*reqp,
		usb_flags_t	flags)
{
	usb_isoc_req_t		*isoc_reqp = NULL;
	usba_req_wrapper_t	*isoc_wrp, *req_wrp;
	ushort_t		count;
	ushort_t		isoc_pkts_count;
	size_t			length;

	if (reqp == NULL) {

		return (isoc_reqp);
	}

	isoc_pkts_count = reqp->isoc_pkts_count;

	/* calculate total data length required in original request */
	for (count = length = 0; count < isoc_pkts_count; count++) {
		length += reqp->isoc_pkt_descr[count].isoc_pkt_length;
	}

	req_wrp	= USBA_REQ2WRP(reqp);

	if (((isoc_reqp = usb_alloc_isoc_req(dip,
	    isoc_pkts_count, length, flags)) != NULL)) {
		isoc_reqp->isoc_frame_no	= reqp->isoc_frame_no;
		isoc_reqp->isoc_pkts_count	= reqp->isoc_pkts_count;
		isoc_reqp->isoc_pkts_length	= reqp->isoc_pkts_length;
		isoc_reqp->isoc_attributes	= reqp->isoc_attributes;
		isoc_reqp->isoc_client_private	= reqp->isoc_client_private;
		isoc_reqp->isoc_cb		= reqp->isoc_cb;
		isoc_reqp->isoc_exc_cb		= reqp->isoc_exc_cb;

		isoc_wrp		= USBA_REQ2WRP(isoc_reqp);
		isoc_wrp->wr_dip	= req_wrp->wr_dip;
		isoc_wrp->wr_ph_data	= req_wrp->wr_ph_data;
		isoc_wrp->wr_attrs	= req_wrp->wr_attrs;
		isoc_wrp->wr_usb_flags	= req_wrp->wr_usb_flags;

		for (count = 0; count < isoc_pkts_count; count++) {
			isoc_reqp->isoc_pkt_descr[count].isoc_pkt_length =
				reqp->isoc_pkt_descr[count].isoc_pkt_length;
		}
	}

	return (isoc_reqp);
}


/*
 * usb_free_isoc_req:
 *	- Deallocate usb isochronous resources that includes usb isochronous
 *	  request and array of packet descriptor strcutures.
 *
 * Arguments:
 *	req - pointer to usb_isoc_req_t
 */
void
usb_free_isoc_req(usb_isoc_req_t *req)
{
	if (req) {
		USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usb_free_isoc_req: req=0x%p", req);

		if (req->isoc_data) {
			freemsg(req->isoc_data);
		}

		usba_req_wrapper_free(USBA_REQ2WRP(req));
	}
}


/*
 * usb_get_current_frame_number:
 *	- request HCD to return current usb frame number
 *
 * Arguments:
 *	dip	- pointer to dev_info_t
 *
 * Return Values:
 *	current_frame_number	- request successfully executed
 *	0			- request failed
 */
usb_frame_number_t
usb_get_current_frame_number(dev_info_t	*dip)
{
	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_get_current_frame_number: dip=0x%p", dip);

	if (dip) {
		usba_device_t	*usba_device = usba_get_usba_device(dip);

		if (usba_device->usb_hcdi_ops->
		    usba_hcdi_get_current_frame_number) {

			return (usba_device->usb_hcdi_ops->
			    usba_hcdi_get_current_frame_number(usba_device));
		}
	}

	return (0);
}


/*
 * usb_get_max_isoc_pkts:
 *	- request HCD to return maximum isochronous packets per request
 *
 * Arguments:
 *	dip	- pointer to dev_info_t
 *
 * Return Values:
 *	isoc_pkt - request successfully executed
 *	0	 - request failed
 */
uint_t
usb_get_max_isoc_pkts(dev_info_t *dip)
{
	return (usb_get_max_pkts_per_isoc_request(dip));
}


uint_t
usb_get_max_pkts_per_isoc_request(dev_info_t *dip)
{
	if (dip) {
		usba_device_t	*usba_device = usba_get_usba_device(dip);

		USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usb_get_max_isoc_pkts: usba_device=0x%p", usba_device);

		if (usba_device->usb_hcdi_ops->usba_hcdi_get_max_isoc_pkts) {

			return (usba_device->usb_hcdi_ops->
			    usba_hcdi_get_max_isoc_pkts(usba_device));
		}
	}

	return (0);
}


/*
 * usb_pipe_isoc_xfer:
 *	- check for pipe stalled
 *	- request HCD to transport isoc data asynchronously
 *
 * Arguments:
 *	pipe_handle	- isoc pipe pipehandle (obtained via usb_pipe_open())
 *	req		- isochronous request
 *
 * Return Values:
 *	USB_SUCCESS	- request successfully executed
 *	USB_FAILURE	- request failed
 */
int
usb_pipe_isoc_xfer(usb_pipe_handle_t	pipe_handle,
		usb_isoc_req_t		*req,
		usb_flags_t		flags)
{
	int			rval;
	usba_req_wrapper_t	*wrp = USBA_REQ2WRP(req);
	usba_pipe_handle_data_t	*ph_data = usba_hold_ph_data(pipe_handle);
	usba_device_t		*usba_device;
	uchar_t			direction;
	usb_pipe_state_t	pipe_state;

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_pipe_isoc_xfer: flags=0x%x", flags);

	if (ph_data == NULL) {

		return (USB_INVALID_PIPE);
	}

	usba_device = ph_data->p_usba_device;
	direction = ph_data->p_ep.bEndpointAddress & USB_EP_DIR_MASK;

	mutex_enter(&ph_data->p_mutex);
	if ((rval = usba_check_req(ph_data, (usb_opaque_t)req, flags,
	    USB_EP_ATTR_ISOCH)) != USB_SUCCESS) {
		mutex_exit(&ph_data->p_mutex);

		usba_release_ph_data(ph_data->p_ph_impl);

		return (rval);
	}

	req->isoc_error_count = 0;

	/* Get the current isoch pipe state */
	pipe_state = usba_get_ph_state(ph_data);

	switch (pipe_state) {
	case USB_PIPE_STATE_IDLE:
		usba_pipe_new_state(ph_data, USB_PIPE_STATE_ACTIVE);
		break;
	case USB_PIPE_STATE_ACTIVE:
		if (direction == USB_EP_DIR_IN) {
			USB_DPRINTF_L4(DPRINT_MASK_USBAI,
			    usbai_log_handle,
			    "usb_pipe_isoc_req: already polling");

			mutex_exit(&ph_data->p_mutex);
			usba_release_ph_data(ph_data->p_ph_impl);

			return (USB_FAILURE);
		}
		break;
	default:
		USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usb_pipe_isoc_req: pipe state %d", pipe_state);

		mutex_exit(&ph_data->p_mutex);
		usba_release_ph_data(ph_data->p_ph_impl);

		return (USB_PIPE_ERROR);
	}

	/* we accept the request */
	ph_data->p_req_count++;
	mutex_exit(&ph_data->p_mutex);

	if ((rval = usba_device->usb_hcdi_ops->usba_hcdi_pipe_isoc_xfer(
	    ph_data, req, flags)) != USB_SUCCESS) {
		if (req->isoc_completion_reason == USB_CR_OK) {
			req->isoc_completion_reason = usba_rval2cr(rval);
		}
		mutex_enter(&ph_data->p_mutex);
		ASSERT(wrp->wr_done == B_FALSE);
		ph_data->p_req_count--;
		if ((ph_data->p_req_count == 0) &&
		    (usba_get_ph_state(ph_data) == USB_PIPE_STATE_ACTIVE)) {
			usba_pipe_new_state(ph_data, USB_PIPE_STATE_IDLE);
		}
		mutex_exit(&ph_data->p_mutex);
	}

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usb_pipe_isoc_req: rval=%x", rval);

	usba_release_ph_data(ph_data->p_ph_impl);

	return (rval);
}


/*
 * usba_pipe_sync_stop_isoc_polling:
 *	- set up for sync transport, if necessary
 *	- request HCD to stop polling
 *	- wait for draining of all callbacks
 *
 * Arguments:
 *	dip		- dev_info pointer
 *	pipe_handle	- pointer to pipe handle
 *	flags		- USB_FLAGS_SLEEP:	wait for completion
 */
/*ARGSUSED*/
static int
usba_pipe_sync_stop_isoc_polling(dev_info_t	*dip,
		usba_ph_impl_t		*ph_impl,
		usba_pipe_async_req_t	*request,
		usb_flags_t		flags)
{
	int rval;
	usba_pipe_handle_data_t *ph_data = usba_get_ph_data(
					(usb_pipe_handle_t)ph_impl);
	usba_device_t	*usba_device;

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_pipe_sync_stop_isoc_polling: uf=0x%x", flags);

	if (ph_data == NULL) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_stop_isoc_polling: pipe closed");

		return (USB_INVALID_PIPE);
	}

	usba_device = ph_data->p_usba_device;

	mutex_enter(&ph_data->p_mutex);

	if (usba_get_ph_state(ph_data) == USB_PIPE_STATE_ERROR) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_sync_stop_isoc_polling: pipe error");
		mutex_exit(&ph_data->p_mutex);

		usba_release_ph_data(ph_impl);

		return (USB_PIPE_ERROR);
	}

	if (usba_get_ph_state(ph_data) == USB_PIPE_STATE_IDLE) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_sync_stop_isoc_polling: already stopped");
		mutex_exit(&ph_data->p_mutex);

		usba_release_ph_data(ph_impl);

		return (USB_SUCCESS);
	}


	mutex_exit(&ph_data->p_mutex);

	flags |= USB_FLAGS_SLEEP;

	for (;;) {
		rval = usba_device->usb_hcdi_ops->
			usba_hcdi_pipe_stop_isoc_polling(ph_data, flags);

		/*
		 * The host controller has stopped polling of the endpoint.
		 * Now, drain the callbacks if there are any on the callback
		 * queue.
		 */
		if (rval == USB_SUCCESS) {
			mutex_enter(&ph_data->p_mutex);

			/*
			 * there is a tiny window that the client driver
			 * may still have restarted the polling and we
			 * let the stop polling win
			 */
			rval = usba_drain_cbs(ph_data, 0,
						USB_CR_STOPPED_POLLING);
			mutex_exit(&ph_data->p_mutex);
			if (rval != USB_SUCCESS) {

				continue;
			}
		}

		break;
	}

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_pipe_sync_stop_isoc_polling: rval=0x%x", rval);

	usba_release_ph_data(ph_impl);

	return (rval);
}


/*
 * usb_pipe_stop_isoc_polling:
 *	stop polling for isoc IN data
 *
 * Arguments:
 *	pipe_handle	- pipe handle
 *	flags		-
 *			USB_FLAGS_SLEEP:	wait for completion
 */
void
usb_pipe_stop_isoc_polling(usb_pipe_handle_t pipe_handle,
		usb_flags_t	flags)
{
	usba_pipe_handle_data_t *ph_data = usba_hold_ph_data(pipe_handle);

	USB_DPRINTF_L4(DPRINT_MASK_USBAI, usbai_log_handle,
	    "usba_pipe_stop_isoc_polling: uf=0x%x", flags);

	if (ph_data == NULL) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_stop_isoc_polling: pipe closed");

		return;
	}

	if ((ph_data->p_ep.bmAttributes & USB_EP_ATTR_MASK) !=
	    USB_EP_ATTR_ISOCH) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_stop_isoc_polling: wrong pipe type");

		usba_release_ph_data(ph_data->p_ph_impl);

		return;
	}
	if ((ph_data->p_ep.bEndpointAddress & USB_EP_DIR_IN) == 0) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_stop_isoc_polling: wrong pipe direction");

		usba_release_ph_data(ph_data->p_ph_impl);

		return;
	}

	if (servicing_interrupt() && (flags & USB_FLAGS_SLEEP)) {
		USB_DPRINTF_L2(DPRINT_MASK_USBAI, usbai_log_handle,
		    "usba_pipe_stop_intr_polling: invalid context");

		usba_release_ph_data(ph_data->p_ph_impl);

		return;
	}

	(void) usba_pipe_setup_func_call(ph_data->p_dip,
	    usba_pipe_sync_stop_isoc_polling,
	    (usba_ph_impl_t *)pipe_handle, (usb_opaque_t)flags,
	    flags, usba_dummy_callback, NULL);
}