--- old/usr/src/uts/common/io/usb/clients/hwarc/hwarc.c	Sun Apr 12 08:56:12 2015
+++ /dev/null	Sun Apr 12 08:54:51 2015
@@ -1,1613 +0,0 @@
-/*
- * CDDL HEADER START
- *
- * The contents of this file are subject to the terms of the
- * Common Development and Distribution License (the "License").
- * You may not use this file except in compliance with the License.
- *
- * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
- * or http://www.opensolaris.org/os/licensing.
- * See the License for the specific language governing permissions
- * and limitations under the License.
- *
- * When distributing Covered Code, include this CDDL HEADER in each
- * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
- * If applicable, add the following below this CDDL HEADER, with the
- * fields enclosed by brackets "[]" replaced with your own identifying
- * information: Portions Copyright [yyyy] [name of copyright owner]
- *
- * CDDL HEADER END
- */
-/*
- * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
- * Use is subject to license terms.
- */
-
-
-/*
- * UWB HWA Radio Controller driver.
- *
- *
- * The device has four states (refer to usbai.h):
- *	USB_DEV_ONLINE: In action or ready for action.
- *	USB_DEV_DISCONNECTED: Hotplug removed, or device not present/correct on
- *		resume (CPR).
- *	USB_DEV_SUSPENDED: Device has been suspended along with the system.
- *	USB_DEV_PWRED_DOWN: Device has been powered down.  (Note that this
- *		driver supports only two power states, powered down and
- *		full power.)
- *
- * In order to avoid race conditions between driver entry points,
- * access to the device is serialized.	Race conditions are an issue in
- * particular between disconnect event callbacks, detach, power, open
- * and data transfer callbacks.  The functions hwarc_serialize/release_access
- * are implemented for this purpose.
- *
- * Mutexes should never be held when making calls into USBA or when
- * sleeping.
- *
- * pm_busy_component and pm_idle_component mark the device as busy or idle to
- * the system.	These functions are paired, and are called only from code
- * bracketed by hwarc_serialize_access and hwarc_release_access.
- *
- */
-
-#define	USBDRV_MAJOR_VER	2
-#define	USBDRV_MINOR_VER	0
-
-#include <sys/strsun.h>
-#include <sys/usb/usba.h>
-#include <sys/usb/clients/hwarc/hwarc.h>
-
-
-
-uint_t		hwarc_errlevel		= 4;
-static uint_t	hwarc_errmask		= (uint_t)PRINT_MASK_ALL;
-static uint_t	hwarc_instance_debug 	= (uint_t)-1;
-
-static char	*name		= "hwarc";	/* Driver name, used all over */
-
-
-/* Function Prototypes */
-static int	hwarc_attach(dev_info_t *, ddi_attach_cmd_t);
-static int	hwarc_detach(dev_info_t *, ddi_detach_cmd_t);
-static int	hwarc_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
-static int	hwarc_cleanup(dev_info_t *, hwarc_state_t *);
-static int	hwarc_open(dev_t *, int, int, cred_t *);
-static int	hwarc_close(dev_t, int, int, cred_t *);
-static int 	hwarc_send_cmd(uwb_dev_handle_t, mblk_t *, uint16_t);
-static int	hwarc_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
-static int	hwarc_disconnect_callback(dev_info_t *);
-static int	hwarc_reconnect_callback(dev_info_t *);
-static void	hwarc_restore_device_state(dev_info_t *, hwarc_state_t *);
-static int	hwarc_cpr_suspend(dev_info_t *);
-static void	hwarc_cpr_resume(dev_info_t *);
-static int	hwarc_open_intr_pipe(hwarc_state_t *);
-static void	hwarc_close_intr_pipe(hwarc_state_t *);
-static void	hwarc_pm_busy_component(hwarc_state_t *);
-static void	hwarc_pm_idle_component(hwarc_state_t *);
-static int	hwarc_power(dev_info_t *, int, int);
-static int	hwarc_serialize_access(hwarc_state_t *, boolean_t);
-static void	hwarc_release_access(hwarc_state_t *);
-static int	hwarc_reset_device(hwarc_state_t *);
-static int	hwarc_init_phy(hwarc_state_t *);
-
-
-static int	hwarc_start_polling(hwarc_state_t *, usb_pipe_handle_t);
-
-
-_NOTE(SCHEME_PROTECTS_DATA("unique per call", usb_ctrl_req))
-_NOTE(SCHEME_PROTECTS_DATA("unique per call", usb_intr_req))
-_NOTE(SCHEME_PROTECTS_DATA("unique per call", buf))
-
-/* module loading stuff */
-struct cb_ops hwarc_cb_ops = {
-	hwarc_open,		/* open  */
-	hwarc_close,		/* close */
-	nodev,			/* strategy */
-	nulldev,		/* print */
-	nulldev,		/* dump */
-	nodev,			/* read */
-	nodev,			/* write */
-	hwarc_ioctl,		/* ioctl */
-	nulldev,		/* devmap */
-	nodev,			/* mmap */
-	nodev,			/* segmap */
-	nochpoll,		/* poll */
-	ddi_prop_op,		/* cb_prop_op */
-	NULL,			/* streamtab  */
-	D_MP
-};
-
-static struct dev_ops hwarc_ops = {
-	DEVO_REV,		/* devo_rev, */
-	0,			/* refcnt  */
-	hwarc_info,		/* info */
-	nulldev,		/* identify */
-	nulldev,		/* probe */
-	hwarc_attach,		/* attach */
-	hwarc_detach,		/* detach */
-	nodev,			/* reset */
-	&hwarc_cb_ops,		/* driver operations */
-	NULL,			/* bus operations */
-	hwarc_power,		/* power */
-	ddi_quiesce_not_needed, /* devo_quiesce */
-};
-
-static struct modldrv hwarc_modldrv =	{
-	&mod_driverops,
-	"USB HWA Radio Controller driver",
-	&hwarc_ops
-};
-
-static struct modlinkage modlinkage = {
-	MODREV_1,
-	&hwarc_modldrv,
-	NULL
-};
-
-/* Soft state structures */
-#define	HWARC_INITIAL_SOFT_SPACE	1
-static void *hwarc_statep;
-
-
-/* Module-wide initialization routine */
-int
-_init(void)
-{
-	int rval;
-
-	if ((rval = ddi_soft_state_init(&hwarc_statep,
-	    sizeof (hwarc_state_t), HWARC_INITIAL_SOFT_SPACE)) != 0) {
-
-		return (rval);
-	}
-
-	if ((rval = mod_install(&modlinkage)) != 0) {
-		ddi_soft_state_fini(&hwarc_statep);
-	}
-
-	return (rval);
-}
-
-
-/* Module-wide tear-down routine */
-int
-_fini(void)
-{
-	int rval;
-
-	if ((rval = mod_remove(&modlinkage)) != 0) {
-
-		return (rval);
-	}
-
-	ddi_soft_state_fini(&hwarc_statep);
-
-	return (rval);
-}
-
-
-int
-_info(struct modinfo *modinfop)
-{
-	return (mod_info(&modlinkage, modinfop));
-}
-
-
-/*
- * hwarc_info:
- *	Get minor number, soft state structure, etc.
- */
-/*ARGSUSED*/
-static int
-hwarc_info(dev_info_t *dip, ddi_info_cmd_t infocmd,
-			void *arg, void **result)
-{
-	hwarc_state_t	*hrcp;
-	int error = DDI_FAILURE;
-
-	switch (infocmd) {
-	case DDI_INFO_DEVT2DEVINFO:
-		*result = NULL;
-		if ((hrcp = ddi_get_soft_state(hwarc_statep,
-		    getminor((dev_t)arg))) != NULL) {
-			*result = hrcp->hrc_dip;
-		}
-		error = (*result)? DDI_SUCCESS:DDI_FAILURE;
-
-		break;
-	case DDI_INFO_DEVT2INSTANCE:
-		*result = (void *)(uintptr_t)getminor((dev_t)arg);
-		error = DDI_SUCCESS;
-		break;
-	default:
-		break;
-	}
-
-	return (error);
-}
-
-
-
-/*
- * hwarc_init_power_mgmt:
- *	Initialize power management and remote wakeup functionality.
- *	No mutex is necessary in this function as it's called only by attach.
- */
-static void
-hwarc_init_power_mgmt(hwarc_state_t *hrcp)
-{
-	hwarc_power_t	*hrcpm = NULL;
-	uint_t		pwr_states;
-
-	USB_DPRINTF_L4(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-	    "init_power_mgmt enter");
-
-	/* Put online before PM init as can get power managed afterward. */
-	hrcp->hrc_dev_state = USB_DEV_ONLINE;
-
-	/* Allocate the state structure */
-	hrcpm = kmem_zalloc(sizeof (hwarc_power_t), KM_SLEEP);
-
-	hrcpm->hrc_state 		= hrcp;
-	hrcpm->hrc_pm_capabilities 	= 0;
-	hrcpm->hrc_current_power 	= USB_DEV_OS_FULL_PWR;
-
-
-	if (usb_create_pm_components(hrcp->hrc_dip, &pwr_states) ==
-	    USB_SUCCESS) {
-		hrcpm->hrc_pwr_states 	= (uint8_t)pwr_states;
-
-		if (usb_handle_remote_wakeup(hrcp->hrc_dip,
-		    USB_REMOTE_WAKEUP_ENABLE) == USB_SUCCESS) {
-			hrcpm->hrc_wakeup_enabled = 1;
-		} else {
-			USB_DPRINTF_L2(PRINT_MASK_PM,
-			    hrcp->hrc_log_hdl, "hwarc_init_power_mgmt:"
-			    " remote wakeup not supported");
-		}
-
-	} else {
-		USB_DPRINTF_L2(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-		    "hwarc_init_power_mgmt:created PM components failed");
-	}
-	mutex_enter(&hrcp->hrc_mutex);
-	hrcp->hrc_pm = hrcpm;
-	hwarc_pm_busy_component(hrcp);
-	mutex_exit(&hrcp->hrc_mutex);
-
-	(void) pm_raise_power(
-	    hrcp->hrc_dip, 0, USB_DEV_OS_FULL_PWR);
-
-	USB_DPRINTF_L4(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-	    "hwarc_init_power_mgmt: end");
-}
-
-
-/*
- * hwarc_destroy_power_mgmt:
- *	Shut down and destroy power management and remote wakeup functionality.
- */
-static void
-hwarc_destroy_power_mgmt(hwarc_state_t *hrcp)
-{
-	hwarc_power_t	*pm;
-
-	USB_DPRINTF_L4(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-	    "destroy_power_mgmt enter");
-
-	mutex_enter(&hrcp->hrc_mutex);
-
-	if ((pm = hrcp->hrc_pm) == NULL) {
-		USB_DPRINTF_L3(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-		    "hwarc_destroy_power_mgmt:pm not supported");
-		goto done;
-	}
-
-	if (hrcp->hrc_dev_state == USB_DEV_DISCONNECTED) {
-		USB_DPRINTF_L3(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-		    "hwarc_destroy_power_mgmt:device disconnected");
-		goto done;
-	}
-
-	hwarc_pm_busy_component(hrcp);
-
-	mutex_exit(&hrcp->hrc_mutex);
-
-	if (pm->hrc_wakeup_enabled) {
-
-		/* First bring the device to full power */
-		(void) pm_raise_power(hrcp->hrc_dip, 0, USB_DEV_OS_FULL_PWR);
-		if (usb_handle_remote_wakeup(hrcp->hrc_dip,
-		    USB_REMOTE_WAKEUP_DISABLE) != USB_SUCCESS) {
-			USB_DPRINTF_L2(PRINT_MASK_PM,
-			    hrcp->hrc_log_hdl, "hwarc_destroy_power_mgmt: "
-			    "Error disabling rmt wakeup");
-		}
-
-	}
-
-	/*
-	 * Since remote wakeup is disabled now,
-	 * no one can raise power
-	 * and get to device once power is lowered here.
-	 */
-	(void) pm_lower_power(hrcp->hrc_dip, 0, USB_DEV_OS_PWR_OFF);
-
-	mutex_enter(&hrcp->hrc_mutex);
-
-	hwarc_pm_idle_component(hrcp);
-
-done:
-	if (pm) {
-		kmem_free(pm, sizeof (hwarc_power_t));
-
-		hrcp->hrc_pm = NULL;
-	}
-	mutex_exit(&hrcp->hrc_mutex);
-}
-
-
-static void
-hwarc_pm_busy_component(hwarc_state_t *hrcp)
-{
-	ASSERT(mutex_owned(&hrcp->hrc_mutex));
-
-	USB_DPRINTF_L4(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-	    "hwarc_pm_busy_component: enter");
-	if (hrcp->hrc_pm == NULL) {
-		USB_DPRINTF_L4(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-		    "hwarc_pm_busy_component: pm not supported, return");
-
-		return;
-	}
-
-	hrcp->hrc_pm->hrc_pm_busy++;
-
-	mutex_exit(&hrcp->hrc_mutex);
-	if (pm_busy_component(hrcp->hrc_dip, 0) !=
-	    DDI_SUCCESS) {
-		mutex_enter(&hrcp->hrc_mutex);
-		USB_DPRINTF_L3(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-		    "hwarc_pm_busy_component: pm busy fail, hrc_pm_busy=%d",
-		    hrcp->hrc_pm->hrc_pm_busy);
-
-		hrcp->hrc_pm->hrc_pm_busy--;
-		mutex_exit(&hrcp->hrc_mutex);
-	}
-	mutex_enter(&hrcp->hrc_mutex);
-
-	USB_DPRINTF_L4(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-	    "hwarc_pm_busy_component: exit");
-}
-
-
-static void
-hwarc_pm_idle_component(hwarc_state_t *hrcp)
-{
-	ASSERT(mutex_owned(&hrcp->hrc_mutex));
-	USB_DPRINTF_L4(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-	    "hwarc_pm_idle_component: enter");
-
-	if (hrcp->hrc_pm == NULL) {
-		USB_DPRINTF_L4(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-		    "hwarc_pm_idle_component: pm not supported");
-
-		return;
-	}
-
-	mutex_exit(&hrcp->hrc_mutex);
-	if (pm_idle_component(hrcp->hrc_dip, 0) == DDI_SUCCESS) {
-		mutex_enter(&hrcp->hrc_mutex);
-		ASSERT(hrcp->hrc_pm->hrc_pm_busy > 0);
-		hrcp->hrc_pm->hrc_pm_busy--;
-		mutex_exit(&hrcp->hrc_mutex);
-	}
-	mutex_enter(&hrcp->hrc_mutex);
-
-	USB_DPRINTF_L3(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-	    "hwarc_pm_idle_component: %d", hrcp->hrc_pm->hrc_pm_busy);
-
-}
-
-
-/*
- * hwarc_pwrlvl0:
- * Functions to handle power transition for OS levels 0 -> 3
- */
-static int
-hwarc_pwrlvl0(hwarc_state_t *hrcp)
-{
-	int rval;
-
-	USB_DPRINTF_L3(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-	    "hwarc_pwrlvl0, dev_state: %x", hrcp->hrc_dev_state);
-
-	switch (hrcp->hrc_dev_state) {
-		case USB_DEV_ONLINE:
-			/* Deny the powerdown request if the device is busy */
-			if (hrcp->hrc_pm->hrc_pm_busy != 0) {
-				USB_DPRINTF_L2(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-				    "hwarc_pwrlvl0: hrc_pm_busy");
-
-				return (USB_FAILURE);
-			}
-
-			/* Close the interrupt pipe */
-			mutex_exit(&hrcp->hrc_mutex);
-			hwarc_close_intr_pipe(hrcp);
-			mutex_enter(&hrcp->hrc_mutex);
-
-			/* Issue USB D3 command to the device here */
-			rval = usb_set_device_pwrlvl3(hrcp->hrc_dip);
-			ASSERT(rval == USB_SUCCESS);
-
-			hrcp->hrc_dev_state = USB_DEV_PWRED_DOWN;
-			hrcp->hrc_pm->hrc_current_power = USB_DEV_OS_PWR_OFF;
-
-		/* FALLTHRU */
-		case USB_DEV_DISCONNECTED:
-		case USB_DEV_SUSPENDED:
-
-			return (USB_SUCCESS);
-
-		case USB_DEV_PWRED_DOWN:
-		default:
-			USB_DPRINTF_L2(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-			    "hwarc_pwrlvl0: illegal dev state");
-
-			return (USB_FAILURE);
-	}
-}
-
-
-/*
- * hwarc_pwrlvl1:
- *	Functions to handle power transition to OS levels -> 2
- */
-static int
-hwarc_pwrlvl1(hwarc_state_t *hrcp)
-{
-	int	rval;
-
-	USB_DPRINTF_L4(PRINT_MASK_PM, hrcp->hrc_log_hdl, "hwarc_pwrlvl1");
-
-	/* Issue USB D2 command to the device here */
-	rval = usb_set_device_pwrlvl2(hrcp->hrc_dip);
-	ASSERT(rval == USB_SUCCESS);
-
-	return (USB_FAILURE);
-}
-
-
-/*
- * hwarc_pwrlvl2:
- *	Functions to handle power transition to OS levels -> 1
- */
-static int
-hwarc_pwrlvl2(hwarc_state_t *hrcp)
-{
-	int	rval;
-
-	USB_DPRINTF_L3(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-	    "hwarc_pwrlvl2, dev_stat=%d", hrcp->hrc_dev_state);
-
-	/* Issue USB D1 command to the device here */
-	rval = usb_set_device_pwrlvl1(hrcp->hrc_dip);
-	ASSERT(rval == USB_SUCCESS);
-
-	return (USB_FAILURE);
-}
-
-
-/*
- * hwarc_pwrlvl3:
- *	Functions to handle power transition to OS level -> 0
- */
-static int
-hwarc_pwrlvl3(hwarc_state_t *hrcp)
-{
-
-	USB_DPRINTF_L3(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-	    "hwarc_pwrlvl3, dev_stat=%d", hrcp->hrc_dev_state);
-
-	switch (hrcp->hrc_dev_state) {
-		case USB_DEV_PWRED_DOWN:
-			/* Issue USB D0 command to the device here */
-			(void) usb_set_device_pwrlvl0(hrcp->hrc_dip);
-
-			mutex_exit(&hrcp->hrc_mutex);
-			if (hwarc_open_intr_pipe(hrcp) != USB_SUCCESS) {
-				mutex_enter(&hrcp->hrc_mutex);
-
-				return (USB_FAILURE);
-			}
-			mutex_enter(&hrcp->hrc_mutex);
-
-			/* Todo: Reset device or not */
-			hrcp->hrc_dev_state 		= USB_DEV_ONLINE;
-			hrcp->hrc_pm->hrc_current_power = USB_DEV_OS_FULL_PWR;
-
-			/* FALLTHRU */
-		case USB_DEV_ONLINE:
-			/* we are already in full power */
-			/* FALLTHRU */
-		case USB_DEV_DISCONNECTED:
-		case USB_DEV_SUSPENDED:
-			/*
-			 * PM framework tries to put us in full power
-			 * during system shutdown. If we are disconnected/cpr'ed
-			 * return success anyways
-			 */
-
-			return (USB_SUCCESS);
-
-		default:
-			USB_DPRINTF_L2(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-			    "hwarc_pwrlvl3: illegal dev state");
-
-			return (USB_FAILURE);
-	}
-}
-
-/* Init dev inst */
-static void
-hwarc_init_devinst(dev_info_t *dip, hwarc_state_t *hrcp)
-{
-	char	*devinst;
-	int	devinstlen;
-
-	hrcp->hrc_dip	  = dip;
-	hrcp->hrc_log_hdl = usb_alloc_log_hdl(dip,
-	    "hwarc", &hwarc_errlevel,
-	    &hwarc_errmask, &hwarc_instance_debug, 0);
-
-	devinst = kmem_zalloc(USB_MAXSTRINGLEN, KM_SLEEP);
-	devinstlen = snprintf(devinst, USB_MAXSTRINGLEN, "%s%d: ",
-	    ddi_driver_name(dip), ddi_get_instance(dip));
-
-	hrcp->hrc_devinst = kmem_zalloc(devinstlen + 1, KM_SLEEP);
-	(void) strncpy(hrcp->hrc_devinst, devinst, devinstlen);
-
-	kmem_free(devinst, USB_MAXSTRINGLEN);
-}
-
-/* init endpoints */
-static int
-hwarc_init_ep(dev_info_t *dip, hwarc_state_t *hrcp)
-{
-	int status = USB_SUCCESS;
-	usb_ep_data_t	*ep_datap;
-	if ((status = usb_client_attach(dip, USBDRV_VERSION, 0)) !=
-	    USB_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "hwarc_init_ep: usb_client_attach failed"
-		    " error code = %d", status);
-		goto done;
-	}
-
-	if ((status = usb_get_dev_data(dip, &hrcp->hrc_reg, USB_PARSE_LVL_ALL,
-	    0)) != USB_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "hwarc_init_ep: usb_get_dev_data failed"
-		    "error code = %d", status);
-		goto done;
-	}
-	hrcp->hrc_if_descr =
-	    &hrcp->hrc_reg->dev_curr_cfg->cfg_if[hrcp->hrc_reg->dev_curr_if];
-	hrcp->hrc_default_ph = hrcp->hrc_reg->dev_default_ph;
-
-	/*
-	 * Get the descriptor for an intr pipe at alt 0 of current interface.
-	 * This will be used later to open the pipe.
-	 */
-	if ((ep_datap = usb_lookup_ep_data(dip, hrcp->hrc_reg,
-	    hrcp->hrc_reg->dev_curr_if, 0, 0,
-	    USB_EP_ATTR_INTR, USB_EP_DIR_IN)) == NULL) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "hwarc_init_ep: Error getting intr endpoint descriptor");
-		status = USB_FAILURE;
-		goto done;
-	}
-	hrcp->hrc_intr_ep_descr = ep_datap->ep_descr;
-
-done:
-
-	return (status);
-}
-/* init mutex */
-static void
-hwarc_init_mutex(hwarc_state_t *hrcp) {
-	mutex_init(&hrcp->hrc_mutex, NULL, MUTEX_DRIVER,
-	    hrcp->hrc_reg->dev_iblock_cookie);
-
-	cv_init(&hrcp->hrc_serial_cv, NULL, CV_DRIVER, NULL);
-	hrcp->hrc_serial_inuse = B_FALSE;
-
-	hrcp->hrc_locks_initialized = B_TRUE;
-}
-/*
- * hwarc_attach:
- *	Attach or resume.
- *
- *	For attach, initialize state and device, including:
- *		state variables, locks, device node
- *		device registration with system
- *		power management, hotplugging
- *	For resume, restore device and state
- */
-static int
-hwarc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
-{
-	int			instance = ddi_get_instance(dip);
-	hwarc_state_t		*hrcp = NULL;
-
-	switch (cmd) {
-		case DDI_ATTACH:
-			break;
-
-		case DDI_RESUME:
-			hwarc_cpr_resume(dip);
-			/*
-			 * Always return success to work around enumeration
-			 * failures.This works around an issue where devices
-			 * which are present before a suspend and absent upon
-			 * resume could cause a system panic on resume.
-			 */
-
-			return (DDI_SUCCESS);
-		default:
-			return (DDI_FAILURE);
-	}
-
-	if (ddi_soft_state_zalloc(hwarc_statep, instance) == DDI_SUCCESS) {
-		hrcp = ddi_get_soft_state(hwarc_statep, instance);
-	}
-	if (hrcp == NULL)  {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, NULL,
-		    "hwarc_attach: get soft state failed for instance %d",
-		    instance);
-
-		return (DDI_FAILURE);
-	}
-
-	(void) hwarc_init_devinst(dip, hrcp);
-
-	if (hwarc_init_ep(dip, hrcp) != USB_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "attach: Error init usb data");
-		goto fail;
-	}
-	hwarc_init_mutex(hrcp);
-
-	/* create minor node */
-	if (ddi_create_minor_node(dip, name, S_IFCHR, instance,
-	    NULL, 0) != DDI_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "attach: Error creating minor node");
-		goto fail;
-	}
-
-	/* initialize power management */
-	hwarc_init_power_mgmt(hrcp);
-
-	if (usb_register_hotplug_cbs(dip, hwarc_disconnect_callback,
-	    hwarc_reconnect_callback) != USB_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "attach: Error register hotplug cbs");
-
-		goto fail;
-	}
-
-	/* register this device to uwba */
-	uwb_dev_attach(dip, &hrcp->hrc_dev_hdl, 0, hwarc_send_cmd);
-
-	if (hwarc_open_intr_pipe(hrcp) != USB_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "attach: Error open intr pipe");
-
-		goto fail;
-	}
-
-	/* reset device */
-	if (hwarc_reset_device(hrcp) != USB_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "attach: Error reset deivce");
-		goto fail;
-	}
-	/* init phy capabilities */
-	if (hwarc_init_phy(hrcp) != USB_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "attach: Error get phy ie");
-
-		goto fail;
-	}
-	/* Report device */
-	ddi_report_dev(dip);
-
-	mutex_enter(&hrcp->hrc_mutex);
-	hwarc_pm_idle_component(hrcp);
-	mutex_exit(&hrcp->hrc_mutex);
-
-	return (DDI_SUCCESS);
-
-fail:
-	(void) hwarc_cleanup(dip, hrcp);
-
-	return (DDI_FAILURE);
-}
-
-
-/*
- * hwarc_detach:
- *	detach or suspend driver instance
- *
- * Note: in detach, only contention threads is from pm and disconnnect.
- */
-static int
-hwarc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
-{
-	int		rval	= USB_SUCCESS;
-	hwarc_state_t	*hrcp	=
-	    ddi_get_soft_state(hwarc_statep, ddi_get_instance(dip));
-
-	USB_DPRINTF_L3(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-	    "hwarc_detach: enter for detach, cmd = %d", cmd);
-
-
-	switch (cmd) {
-		case DDI_DETACH:
-
-			rval = hwarc_cleanup(dip, hrcp);
-
-			break;
-		case DDI_SUSPEND:
-
-			rval = hwarc_cpr_suspend(dip);
-		default:
-
-			break;
-	}
-
-	return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
-}
-
-
-/*
- * hwarc_cleanup:
- *	clean up the driver state for detach
- */
-static int
-hwarc_cleanup(dev_info_t *dip, hwarc_state_t *hrcp)
-{
-	USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl, "Cleanup: enter");
-
-	if (hrcp->hrc_locks_initialized) {
-
-		(void) uwb_stop_beacon(dip);
-		/* This must be done 1st to prevent more events from coming. */
-		usb_unregister_hotplug_cbs(dip);
-
-		hwarc_close_intr_pipe(hrcp);
-
-		/*
-		 * At this point, no new activity can be initiated. The driver
-		 * has disabled hotplug callbacks. The Solaris framework has
-		 * disabled new opens on a device being detached, and does not
-		 * allow detaching an open device.
-		 *
-		 * The following ensures that all driver activity has drained.
-		 */
-		mutex_enter(&hrcp->hrc_mutex);
-		(void) hwarc_serialize_access(hrcp, HWARC_SER_NOSIG);
-		hwarc_release_access(hrcp);
-		mutex_exit(&hrcp->hrc_mutex);
-
-		/* All device activity has died down. */
-		hwarc_destroy_power_mgmt(hrcp);
-
-		/* start dismantling */
-		ddi_remove_minor_node(dip, NULL);
-		cv_destroy(&hrcp->hrc_serial_cv);
-		mutex_destroy(&hrcp->hrc_mutex);
-	}
-
-	usb_client_detach(dip, hrcp->hrc_reg);
-
-	USB_DPRINTF_L4(PRINT_MASK_ATTA, hrcp->hrc_log_hdl, "Cleanup: end");
-
-	usb_free_log_hdl(hrcp->hrc_log_hdl);
-
-	uwb_dev_detach(hrcp->hrc_dev_hdl);
-
-	kmem_free(hrcp->hrc_devinst, strlen(hrcp->hrc_devinst) + 1);
-
-	ddi_soft_state_free(hwarc_statep, ddi_get_instance(dip));
-	ddi_prop_remove_all(dip);
-
-	return (USB_SUCCESS);
-}
-
-
-
-/*ARGSUSED*/
-static int
-hwarc_open(dev_t *devp, int flag, int otyp, cred_t *cred_p)
-{
-	hwarc_state_t	*hrcp = NULL;
-	int rval = 0;
-
-	hrcp = ddi_get_soft_state(hwarc_statep, getminor(*devp));
-
-	ASSERT(hrcp != NULL);
-
-	USB_DPRINTF_L4(PRINT_MASK_OPEN, hrcp->hrc_log_hdl, "hwarc_open: enter");
-
-	/*
-	 * Keep it simple: one client at a time.
-	 * Exclusive open only
-	 */
-	mutex_enter(&hrcp->hrc_mutex);
-	/* exclusive open */
-	if ((flag & FEXCL) && (hrcp->hrc_open_count > 0)) {
-		USB_DPRINTF_L2(PRINT_MASK_OPEN, hrcp->hrc_log_hdl,
-		    "hwarc_open failed, open count=%d", hrcp->hrc_open_count);
-		mutex_exit(&hrcp->hrc_mutex);
-
-		return (EBUSY);
-	}
-
-	if ((hrcp->hrc_dev_state == USB_DEV_DISCONNECTED) ||
-	    (hrcp->hrc_dev_state == USB_DEV_SUSPENDED)) {
-
-		USB_DPRINTF_L2(PRINT_MASK_OPEN, hrcp->hrc_log_hdl,
-		    "hwarc_open failed, dev_stat=%d", hrcp->hrc_dev_state);
-		mutex_exit(&hrcp->hrc_mutex);
-
-		return (EIO);
-	}
-
-	hrcp->hrc_open_count++;
-
-	USB_DPRINTF_L3(PRINT_MASK_OPEN, hrcp->hrc_log_hdl,
-	    "hwarc_open, open count=%d", hrcp->hrc_open_count);
-	if (hwarc_serialize_access(hrcp, HWARC_SER_SIG) == 0) {
-		hrcp->hrc_open_count--;
-		hwarc_release_access(hrcp);
-		mutex_exit(&hrcp->hrc_mutex);
-
-		return (EINTR);
-	}
-
-	hwarc_pm_busy_component(hrcp);
-
-	mutex_exit(&hrcp->hrc_mutex);
-	(void) pm_raise_power(hrcp->hrc_dip, 0, USB_DEV_OS_FULL_PWR);
-
-	mutex_enter(&hrcp->hrc_mutex);
-	/* Fail if device is no longer ready. */
-	if (hrcp->hrc_dev_state != USB_DEV_ONLINE) {
-		USB_DPRINTF_L2(PRINT_MASK_OPEN, hrcp->hrc_log_hdl,
-		    "hwarc_open failed, dev_stat=%d", hrcp->hrc_dev_state);
-		rval = EIO;
-	}
-	hwarc_release_access(hrcp);
-	/* Device specific initialization goes here. */
-	if (rval != 0) {
-		hrcp->hrc_open_count--;
-		hwarc_pm_idle_component(hrcp);
-	}
-	mutex_exit(&hrcp->hrc_mutex);
-
-	USB_DPRINTF_L4(PRINT_MASK_OPEN, hrcp->hrc_log_hdl, "hwarc_open: leave");
-
-	return (0);
-}
-
-
-/*ARGSUSED*/
-static int
-hwarc_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
-{
-	hwarc_state_t	*hrcp =
-	    ddi_get_soft_state(hwarc_statep, getminor(dev));
-
-	USB_DPRINTF_L4(PRINT_MASK_CLOSE, hrcp->hrc_log_hdl,
-	    "hwarc_close: enter");
-
-	mutex_enter(&hrcp->hrc_mutex);
-	(void) hwarc_serialize_access(hrcp, HWARC_SER_NOSIG);
-
-	hrcp->hrc_open_count--;
-	USB_DPRINTF_L3(PRINT_MASK_CLOSE, hrcp->hrc_log_hdl,
-	    "hwarc_close: open count=%d", hrcp->hrc_open_count);
-
-	hwarc_release_access(hrcp);
-	hwarc_pm_idle_component(hrcp);
-
-	mutex_exit(&hrcp->hrc_mutex);
-
-	USB_DPRINTF_L4(PRINT_MASK_CLOSE, hrcp->hrc_log_hdl,
-	    "hwarc_close: leave");
-
-	return (0);
-}
-
-/* Send cmd to hwarc device */
-int
-hwarc_send_cmd(uwb_dev_handle_t uwb_dev_hdl, mblk_t *data, uint16_t data_len)
-{
-	usb_cb_flags_t		cb_flags;
-	usb_cr_t		cr;
-	usb_ctrl_setup_t 	setup;
-	int 			rval;
-	hwarc_state_t		*hrcp = NULL;
-	dev_info_t 		*dip = uwb_get_dip(uwb_dev_hdl);
-
-	hrcp = ddi_get_soft_state(hwarc_statep, ddi_get_instance(dip));
-
-	ASSERT((hrcp != NULL) && (data != NULL));
-
-	setup.bmRequestType	= HWARC_SET_IF;
-	setup.bRequest 		= HWA_EXEC_RC_CMD;
-
-	setup.wValue		= 0;
-	setup.wIndex = hrcp->hrc_if_descr->if_alt->altif_descr.bInterfaceNumber;
-
-	setup.wLength		= data_len;
-	setup.attrs		= 0;
-
-	USB_DPRINTF_L3(PRINT_MASK_DEVCTRL, hrcp->hrc_log_hdl,
-	    "hwarc_send_cmd: wLength=%d, data[0], [1], [2], [3]=%d, %d, %d, %d",
-	    setup.wLength, data->b_rptr[0], data->b_rptr[1], data->b_rptr[2],
-	    data->b_rptr[3]);
-
-	if ((rval = usb_pipe_ctrl_xfer_wait(hrcp->hrc_default_ph, &setup,
-	    &data, &cr, &cb_flags, 0)) != USB_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_DEVCTRL, hrcp->hrc_log_hdl,
-		    "hwarc_send_cmd: fail, rval=%d, cr=%d, "
-		    "cb_flags=%x", rval, cr, cb_flags);
-
-	}
-
-	freemsg(data);
-
-	return (rval);
-}
-
-/* ioctl, call uwb ioctl  */
-/*ARGSUSED*/
-static int
-hwarc_ioctl(dev_t dev, int cmd, intptr_t arg,
-		int mode, cred_t *cred_p, int *rval_p)
-{
-	int		rv = 0;
-
-	hwarc_state_t	*hrcp =
-	    ddi_get_soft_state(hwarc_statep, getminor(dev));
-	if (hrcp == NULL) {
-
-		return (ENXIO);
-	}
-
-	if (drv_priv(cred_p) != 0) {
-		USB_DPRINTF_L3(PRINT_MASK_ALL, hrcp->hrc_log_hdl,
-		    "hwahc_wusb_ioctl: user must have SYS_DEVICE privilege,"
-		    "cmd=%x", cmd);
-
-		return (EPERM);
-	}
-
-
-
-	USB_DPRINTF_L4(PRINT_MASK_ALL, hrcp->hrc_log_hdl, "hwarc_ioctl: enter");
-
-	mutex_enter(&hrcp->hrc_mutex);
-	if (hrcp->hrc_dev_state != USB_DEV_ONLINE) {
-		USB_DPRINTF_L2(PRINT_MASK_ALL, hrcp->hrc_log_hdl,
-		    "ioctl: Device is not online,"
-		    " dev_stat=%d", hrcp->hrc_dev_state);
-		mutex_exit(&hrcp->hrc_mutex);
-
-		return (EFAULT);
-	}
-	mutex_exit(&hrcp->hrc_mutex);
-
-	rv = uwb_do_ioctl(hrcp->hrc_dev_hdl, cmd, arg, mode);
-
-	return (rv);
-}
-
-
-/*
- * hwarc_disconnect_callback:
- *	Called when device hotplug-removed.
- *		Close pipes. (This does not attempt to contact device.)
- *		Set state to DISCONNECTED
- */
-static int
-hwarc_disconnect_callback(dev_info_t *dip)
-{
-	hwarc_state_t	*hrcp =
-	    ddi_get_soft_state(hwarc_statep, ddi_get_instance(dip));
-
-	USB_DPRINTF_L4(PRINT_MASK_CB, hrcp->hrc_log_hdl, "disconnect: enter");
-
-	/* Disconnect the uwb device will stop beacon and save state */
-	(void) uwb_dev_disconnect(dip);
-	hwarc_close_intr_pipe(hrcp);
-
-	mutex_enter(&hrcp->hrc_mutex);
-	(void) hwarc_serialize_access(hrcp, HWARC_SER_NOSIG);
-
-	/*
-	 * Save any state of device or IO in progress required by
-	 * hwarc_restore_device_state for proper device "thawing" later.
-	 */
-	hrcp->hrc_dev_state = USB_DEV_DISCONNECTED;
-
-	hwarc_release_access(hrcp);
-	mutex_exit(&hrcp->hrc_mutex);
-
-	return (USB_SUCCESS);
-}
-
-
-/*
- * hwarc_reconnect_callback:
- *	Called with device hotplug-inserted
- *		Restore state
- */
-static int
-hwarc_reconnect_callback(dev_info_t *dip)
-{
-	int instance = ddi_get_instance(dip);
-	hwarc_state_t	*hrcp =
-	    ddi_get_soft_state(hwarc_statep, instance);
-
-	USB_DPRINTF_L4(PRINT_MASK_CB, hrcp->hrc_log_hdl, "reconnect: enter");
-
-	mutex_enter(&hrcp->hrc_mutex);
-	(void) hwarc_serialize_access(hrcp, HWARC_SER_NOSIG);
-	hwarc_restore_device_state(dip, hrcp);
-	hwarc_release_access(hrcp);
-	mutex_exit(&hrcp->hrc_mutex);
-
-	/* Reconnect the uwb device will restore uwb device state */
-	(void) uwb_dev_reconnect(dip);
-	return (USB_SUCCESS);
-}
-
-
-/*
- * hwarc_restore_device_state:
- *	Called during hotplug-reconnect and resume.
- *		reenable power management
- *		Verify the device is the same as before the disconnect/suspend.
- *		Restore device state
- *		Thaw any IO which was frozen.
- *		Quiesce device.  (Other routines will activate if thawed IO.)
- *		Set device online.
- *		Leave device disconnected if there are problems.
- */
-static void
-hwarc_restore_device_state(dev_info_t *dip, hwarc_state_t *hrcp)
-{
-
-	USB_DPRINTF_L4(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-	    "hwarc_restore_device_state: enter");
-
-	ASSERT(mutex_owned(&hrcp->hrc_mutex));
-
-	ASSERT((hrcp->hrc_dev_state == USB_DEV_DISCONNECTED) ||
-	    (hrcp->hrc_dev_state == USB_DEV_SUSPENDED));
-
-	hwarc_pm_busy_component(hrcp);
-
-	mutex_exit(&hrcp->hrc_mutex);
-
-	(void) pm_raise_power(hrcp->hrc_dip, 0, USB_DEV_OS_FULL_PWR);
-
-	if (usb_check_same_device(dip, hrcp->hrc_log_hdl, USB_LOG_L2,
-	    PRINT_MASK_ALL, USB_CHK_BASIC|USB_CHK_CFG, NULL) != USB_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "hwarc_restore_device_state: check same device failed");
-
-		goto fail;
-
-	}
-	if (hwarc_open_intr_pipe(hrcp) != USB_SUCCESS) {
-
-		goto fail;
-	}
-	mutex_enter(&hrcp->hrc_mutex);
-
-	hrcp->hrc_dev_state = USB_DEV_ONLINE;
-
-	if (hrcp->hrc_pm && hrcp->hrc_pm->hrc_wakeup_enabled) {
-
-		mutex_exit(&hrcp->hrc_mutex);
-		if (usb_handle_remote_wakeup(dip, USB_REMOTE_WAKEUP_ENABLE) !=
-		    USB_SUCCESS) {
-			USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-			    "hwarc_restore_device_state: "
-			    "fail to enable device remote wakeup");
-		}
-		mutex_enter(&hrcp->hrc_mutex);
-
-	}
-
-	hwarc_pm_idle_component(hrcp);
-
-	USB_DPRINTF_L3(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-	    "hwarc_restore_device_state: end");
-
-	return;
-
-fail:
-	/* change the device state from suspended to disconnected */
-	mutex_enter(&hrcp->hrc_mutex);
-	hrcp->hrc_dev_state = USB_DEV_DISCONNECTED;
-	hwarc_pm_idle_component(hrcp);
-}
-
-
-/*
- * hwarc_cpr_suspend:
- *	Clean up device.
- *	Wait for any IO to finish, then close pipes.
- *	Quiesce device.
- */
-static int
-hwarc_cpr_suspend(dev_info_t *dip)
-{
-	hwarc_state_t	*hrcp = ddi_get_soft_state(hwarc_statep,
-	    ddi_get_instance(dip));
-
-	USB_DPRINTF_L3(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-	    "hwarc_cpr_suspend, dev_stat=%d", hrcp->hrc_dev_state);
-
-	/* Disconnect the uwb device will stop beacon and save state */
-	(void) uwb_dev_disconnect(dip);
-
-	/* Serialize to prevent races with detach, open, device access. */
-	mutex_enter(&hrcp->hrc_mutex);
-	(void) hwarc_serialize_access(hrcp, HWARC_SER_NOSIG);
-
-	hwarc_pm_busy_component(hrcp);
-
-	/*
-	 * Set dev_state to suspended so other driver threads don't start any
-	 * new I/O.  In a real driver, there may be draining of requests done
-	 * afterwards, and we don't want the draining to compete with new
-	 * requests being queued.
-	 */
-
-	/* Don't suspend if the device is open. */
-	if (hrcp->hrc_open_count != 0) {
-		USB_DPRINTF_L3(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-		    "suspend: Device is open.  Can't suspend");
-
-		hwarc_release_access(hrcp);
-		hwarc_pm_idle_component(hrcp);
-		mutex_exit(&hrcp->hrc_mutex);
-
-		return (USB_FAILURE);
-	}
-
-	/* Access device here to clean it up. */
-	mutex_exit(&hrcp->hrc_mutex);
-	hwarc_close_intr_pipe(hrcp);
-	mutex_enter(&hrcp->hrc_mutex);
-
-	hrcp->hrc_dev_state = USB_DEV_SUSPENDED;
-
-	/*
-	 * Save any state of device required by hwarc_restore_device_state
-	 * for proper device "thawing" later.
-	 */
-	hwarc_release_access(hrcp);
-	hwarc_pm_idle_component(hrcp);
-	mutex_exit(&hrcp->hrc_mutex);
-
-	USB_DPRINTF_L3(PRINT_MASK_PM, hrcp->hrc_log_hdl, "suspend: success");
-
-	return (USB_SUCCESS);
-}
-
-
-/*
- * hwarc_cpr_resume:
- *
- *	hwarc_restore_device_state marks success by putting device back online
- */
-static void
-hwarc_cpr_resume(dev_info_t *dip)
-{
-	int		instance = ddi_get_instance(dip);
-	hwarc_state_t	*hrcp = ddi_get_soft_state(hwarc_statep,
-	    instance);
-
-	USB_DPRINTF_L3(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-	    "hwarc_cpr_resume, dev_stat=%d", hrcp->hrc_dev_state);
-
-	/*
-	 * NOTE: A pm_raise_power in hwarc_restore_device_state will bring
-	 * the power-up state of device into synch with the system.
-	 */
-	mutex_enter(&hrcp->hrc_mutex);
-	hwarc_restore_device_state(dip, hrcp);
-	mutex_exit(&hrcp->hrc_mutex);
-
-	/* Reconnect the uwb device will restore uwb device state */
-	(void) uwb_dev_reconnect(dip);
-}
-
-/*
- * pipe callbacks
- * --------------
- *
- * intr in callback for event receiving for hwarc device
- */
-/*ARGSUSED*/
-void
-hwarc_intr_cb(usb_pipe_handle_t pipe, usb_intr_req_t *req)
-{
-	hwarc_state_t *hrcp = (hwarc_state_t *)req->intr_client_private;
-	uwb_dev_handle_t uwb_dev_hd;
-	mblk_t	*data = req->intr_data;
-	int		data_len, parse_err;
-
-	uwb_dev_hd = hrcp->hrc_dev_hdl;
-	data_len = (data) ? MBLKL(data) : 0;
-
-	if (data_len == 0) {
-
-		return;
-	}
-
-	/*
-	 * Parse the event/notifications from the device, and cv_signal the
-	 * waiting cmd
-	 */
-	parse_err = uwb_parse_evt_notif((uint8_t *)data->b_rptr,
-	    data_len, uwb_dev_hd);
-	if (parse_err != UWB_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_CB, hrcp->hrc_log_hdl,
-		    "hwarc_intr_cb: parse failed, no cmd result or "
-		    "notifs delivered. parse_err= %d", parse_err);
-		if (data_len >= 5) {
-			USB_DPRINTF_L2(PRINT_MASK_CB, hrcp->hrc_log_hdl,
-			    "hwarc_intr_cb: erro evt len=%d"
-			    " evtcode=%d %d,evt_context=%d, result-code=%d",
-			    data_len, data->b_rptr[1], data->b_rptr[2],
-			    data->b_rptr[3], data->b_rptr[4]);
-		}
-	}
-
-	usb_free_intr_req(req);
-}
-
-/*
- * pipe callbacks
- * --------------
- *
- * intr in exception callback
- */
-void
-hwarc_intr_ex_cb(usb_pipe_handle_t pipe, usb_intr_req_t *req)
-{
-	hwarc_state_t *hrcp = (hwarc_state_t *)req->intr_client_private;
-	usb_cr_t	cr = req->intr_completion_reason;
-
-	USB_DPRINTF_L4(PRINT_MASK_CB, hrcp->hrc_log_hdl,
-	    "hwarc_intr_ex_cb: ph = 0x%p req = 0x%p  cr=%d flags=%x",
-	    (void *)pipe, (void *)req, cr, req->intr_cb_flags);
-
-	usb_free_intr_req(req);
-
-	/* restart polling */
-	if ((cr != USB_CR_PIPE_CLOSING) && (cr != USB_CR_STOPPED_POLLING) &&
-	    (cr != USB_CR_FLUSHED) && (cr != USB_CR_DEV_NOT_RESP) &&
-	    (cr != USB_CR_PIPE_RESET) &&
-	    (hrcp->hrc_dev_state == USB_DEV_ONLINE)) {
-		if (hwarc_start_polling(hrcp, hrcp->hrc_intr_ph) !=
-		    USB_SUCCESS) {
-			USB_DPRINTF_L2(PRINT_MASK_CB, hrcp->hrc_log_hdl,
-			    "hwarc_intr_ex_cb:"
-			    "Restart pollling failed.");
-		}
-	} else {
-		USB_DPRINTF_L2(PRINT_MASK_CB, hrcp->hrc_log_hdl,
-		    "hwarc_intr_ex_cb:"
-		    "get events failed: cr=%d", cr);
-	}
-}
-
-/*
- * start polling on the interrupt pipe for events
- */
-int
-hwarc_start_polling(hwarc_state_t *hrcp, usb_pipe_handle_t intr_ph)
-{
-	usb_intr_req_t	*br;
-	int		rval = USB_SUCCESS;
-
-	USB_DPRINTF_L3(PRINT_MASK_OPEN, hrcp->hrc_log_hdl,
-	    "hwarc_start_polling");
-
-	br = usb_alloc_intr_req(hrcp->hrc_dip, 0, USB_FLAGS_SLEEP);
-
-	if (!br) {
-		USB_DPRINTF_L2(PRINT_MASK_OPEN, hrcp->hrc_log_hdl,
-		    "hwarc_start_polling: alloc req failed.");
-
-		return (USB_FAILURE);
-	}
-	br->intr_attributes = USB_ATTRS_SHORT_XFER_OK | USB_ATTRS_AUTOCLEARING;
-	br->intr_len = hrcp->hrc_intr_ep_descr.wMaxPacketSize;
-	br->intr_client_private = (void *)hrcp;
-
-	br->intr_cb = hwarc_intr_cb;
-	br->intr_exc_cb = hwarc_intr_ex_cb;
-
-	rval = usb_pipe_intr_xfer(intr_ph, br, USB_FLAGS_SLEEP);
-
-	if (rval != USB_SUCCESS) {
-		usb_free_intr_req(br);
-
-		USB_DPRINTF_L2(PRINT_MASK_OPEN, hrcp->hrc_log_hdl,
-		    "hwarc_start_polling: failed (%d)", rval);
-	}
-
-	return (rval);
-}
-
-/*
- * hwarc_open_intr_pipe:
- *	Open any pipes other than default pipe.
- *	Mutex is assumed to be held.
- */
-static int
-hwarc_open_intr_pipe(hwarc_state_t *hrcp)
-{
-
-	int			rval = USB_SUCCESS;
-	usb_pipe_policy_t	pipe_policy;
-	usb_pipe_handle_t	pipe_handle;
-
-	USB_DPRINTF_L3(PRINT_MASK_ATTA, hrcp->hrc_log_hdl, "open_pipes enter");
-
-	bzero(&pipe_policy, sizeof (pipe_policy));
-
-	/*
-	 * Allow that pipes can support at least two asynchronous operations
-	 * going on simultaneously.  Operations include asynchronous callbacks,
-	 * resets, closures.
-	 */
-	pipe_policy.pp_max_async_reqs = 2;
-
-	if ((rval = usb_pipe_open(hrcp->hrc_dip,
-	    &hrcp->hrc_intr_ep_descr, &pipe_policy,
-	    USB_FLAGS_SLEEP, &pipe_handle)) != USB_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "hwarc_open_intr_pipe:Error opening intr pipe: status = %d",
-		    rval);
-		goto done;
-	}
-
-	mutex_enter(&hrcp->hrc_mutex);
-	hrcp->hrc_intr_ph = pipe_handle;
-	mutex_exit(&hrcp->hrc_mutex);
-
-	/*
-	 * At this point, polling could be started on the pipe by making an
-	 * asynchronous input request on the pipe.  Allocate a request by
-	 * calling usb_alloc_intr_req(9F) with a zero length, initialize
-	 * attributes with USB_ATTRS_SHORT_XFER_OK | USB_ATTRS_AUTOCLEARING,
-	 * initialize length to be packetsize of the endpoint, specify the
-	 * callbacks.  Pass this request to usb_pipe_intr_xfer to start polling.
-	 * Call usb_pipe_stop_intr_poling(9F) to stop polling.
-	 */
-	rval = hwarc_start_polling(hrcp, hrcp->hrc_intr_ph);
-	if (rval != USB_SUCCESS) {
-		hwarc_close_intr_pipe(hrcp);
-
-		USB_DPRINTF_L3(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "hwarc_open_intr_pipe: Error start "
-		    "polling intr pipe: rval = %d", rval);
-	}
-
-done:
-
-	return (rval);
-}
-
-
-/*
- * hwarc_close_intr_pipe:
- *	Close pipes. Mutex is assumed to be held.
- */
-static void
-hwarc_close_intr_pipe(hwarc_state_t *hrcp)
-{
-	usb_pipe_handle_t	pipe_handle = NULL;
-	USB_DPRINTF_L3(PRINT_MASK_ATTA, hrcp->hrc_log_hdl, "close_pipes enter");
-
-	mutex_enter(&hrcp->hrc_mutex);
-	if (!hrcp->hrc_intr_ph) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "hwarc intr pipe not exist");
-		mutex_exit(&hrcp->hrc_mutex);
-		return;
-	}
-
-	pipe_handle = hrcp->hrc_intr_ph;
-	hrcp->hrc_intr_ph = NULL;
-	mutex_exit(&hrcp->hrc_mutex);
-
-	/* Stop polling */
-	usb_pipe_stop_intr_polling(pipe_handle, USB_FLAGS_SLEEP);
-
-	/* Close Pipe */
-	usb_pipe_close(hrcp->hrc_dip, pipe_handle, USB_FLAGS_SLEEP, NULL, 0);
-}
-
-/*
- * hwarc_power :
- *	Power entry point, the workhorse behind pm_raise_power, pm_lower_power,
- *	usb_req_raise_power and usb_req_lower_power.
- */
-/*ARGSUSED*/
-static int
-hwarc_power(dev_info_t *dip, int comp, int level)
-{
-	hwarc_state_t	*hrcp;
-	int	rval = USB_FAILURE;
-
-	hrcp = ddi_get_soft_state(hwarc_statep, ddi_get_instance(dip));
-
-	USB_DPRINTF_L3(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-	    "hwarc_power: level = %d", level);
-
-	mutex_enter(&hrcp->hrc_mutex);
-
-	ASSERT(hrcp->hrc_pm != NULL);
-
-	(void) hwarc_serialize_access(hrcp, HWARC_SER_NOSIG);
-
-	/*
-	 * If we are disconnected/suspended, return success. Note that if we
-	 * return failure, bringing down the system will hang when
-	 * PM tries to power up all devices
-	 */
-	if ((hrcp->hrc_dev_state == USB_DEV_DISCONNECTED) ||
-	    (hrcp->hrc_dev_state == USB_DEV_SUSPENDED)) {
-
-		USB_DPRINTF_L3(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-		    "hwarc_power: disconnected/suspended "
-		    "dev_state=%d", hrcp->hrc_dev_state);
-		rval = USB_SUCCESS;
-
-		goto done;
-	}
-
-
-	/* Check if we are transitioning to a legal power level */
-	if (USB_DEV_PWRSTATE_OK(hrcp->hrc_pm->hrc_pwr_states, level)) {
-		USB_DPRINTF_L2(PRINT_MASK_PM, hrcp->hrc_log_hdl,
-		    "hwarc_power: illegal power level = %d "
-		    "pwr_states: %x", level, hrcp->hrc_pm->hrc_pwr_states);
-
-		goto done;
-	}
-
-	switch (level) {
-	case USB_DEV_OS_PWR_OFF :
-		rval = hwarc_pwrlvl0(hrcp);
-
-		break;
-	case USB_DEV_OS_PWR_1:
-		rval = hwarc_pwrlvl1(hrcp);
-
-		break;
-	case USB_DEV_OS_PWR_2:
-		rval = hwarc_pwrlvl2(hrcp);
-
-		break;
-	case USB_DEV_OS_FULL_PWR :
-		rval = hwarc_pwrlvl3(hrcp);
-
-		break;
-	}
-
-done:
-	hwarc_release_access(hrcp);
-	mutex_exit(&hrcp->hrc_mutex);
-
-	return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
-}
-
-
-/*
- * hwarc_serialize_access:
- *    Get the serial synchronization object before returning.
- *
- * Arguments:
- *    hrcp - Pointer to hwarc state structure
- *    waitsig - Set to:
- *	HWARC_SER_SIG - to wait such that a signal can interrupt
- *	HWARC_SER_NOSIG - to wait such that a signal cannot interrupt
- */
-static int
-hwarc_serialize_access(hwarc_state_t *hrcp, boolean_t waitsig)
-{
-	int rval = 1;
-
-	ASSERT(mutex_owned(&hrcp->hrc_mutex));
-
-	while (hrcp->hrc_serial_inuse) {
-		if (waitsig == HWARC_SER_SIG) {
-			rval = cv_wait_sig(&hrcp->hrc_serial_cv,
-			    &hrcp->hrc_mutex);
-		} else {
-			cv_wait(&hrcp->hrc_serial_cv,
-			    &hrcp->hrc_mutex);
-		}
-	}
-	hrcp->hrc_serial_inuse = B_TRUE;
-
-	return (rval);
-}
-
-
-/*
- * hwarc_release_access:
- *    Release the serial synchronization object.
- */
-static void
-hwarc_release_access(hwarc_state_t *hrcp)
-{
-	ASSERT(mutex_owned(&hrcp->hrc_mutex));
-	hrcp->hrc_serial_inuse = B_FALSE;
-	cv_broadcast(&hrcp->hrc_serial_cv);
-}
-
-
-/*
- * hwarc_reset_device:
- *	Reset the readio controller with uwb interfaces.
- *	if the device is different.  Can block.
- */
-static int
-hwarc_reset_device(hwarc_state_t *hrcp)
-{
-	if (uwb_reset_dev(hrcp->hrc_dip) != UWB_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "hwarc_reset_device: uwb_reset_dev failed");
-
-		return (USB_FAILURE);
-	}
-
-	return (USB_SUCCESS);
-}
-
-/*
- * hwarc_init_phy
- *	init the physical capabilities of the radio controller.
- *	the band groups and phy rates will be initialized in the
- *	uwb devices.
- */
-static int
-hwarc_init_phy(hwarc_state_t *hrcp)
-{
-	if (uwb_init_phy(hrcp->hrc_dip) != UWB_SUCCESS) {
-		USB_DPRINTF_L2(PRINT_MASK_ATTA, hrcp->hrc_log_hdl,
-		    "hwarc_init_phy: uwb_init_phy failed");
-
-		return (USB_FAILURE);
-	}
-
-	return (USB_SUCCESS);
-}
