illumos gate

#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

# You may not use this file except in compliance with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

#

# Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.

#

#

# The default for payload-bearing actions in this package is to appear in the

# global zone only.  See the include file for greater detail, as well as

# information about overriding the defaults.

#

<include global_zone_only_component>

set name=pkg.fmri value=pkg:/driver/serial/uchcom@$(PKGVERS)

set name=pkg.description value="CH340/CH341 serial driver"

set name=pkg.summary value="UCHCOM"

set name=info.classification value=org.opensolaris.category.2008:Drivers/Ports

set name=variant.arch value=$(ARCH)

dir path=kernel group=sys

dir path=kernel/drv group=sys

dir path=kernel/drv/$(ARCH64) group=sys

dir path=usr/share/man

dir path=usr/share/man/man7d

driver name=usbftdi perms="* 0666 root sys" \

    alias=usb1a86,5523 \

    alias=usb1a86,7523

file path=kernel/drv/$(ARCH64)/uchcom group=sys

file path=usr/share/man/man7d/uchcom.7d

legacy pkg=SUNWuftdi desc="CH340/CH341 serial driver" \

    name="UCHCOM"

license cr_Sun license=cr_Sun

license lic_CDDL license=lic_CDDL

UCHCOM_OBJS += usbser_uchcom.o uchcom_dsd.o

$(OBJS_DIR)/%.o:		$(UTSBASE)/common/io/usb/clients/usbser/uchcom/%.c

	$(COMPILE.c) -o $@ $<

	$(CTFCONVERT_O)

$(LINTS_DIR)/%.ln:		$(UTSBASE)/common/io/usb/clients/usbser/uchcom/%.c

	@($(LHEAD) $(LINT.c) $< $(LTAIL))

/*

 * 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.

 */

/*

 * Copyright 2020 Jorge Schrauwen <sjorge@blackdot.be>

 */

/*

 * DSD code for WinChipHead CH341/340 adapter

 */

#include <sys/types.h>

#include <sys/param.h>

#include <sys/conf.h>

#include <sys/stream.h>

#include <sys/strsun.h>

#include <sys/termio.h>

#include <sys/termiox.h>

#include <sys/ddi.h>

#include <sys/sunddi.h>

#define	USBDRV_MAJOR_VER	2

#define	USBDRV_MINOR_VER	0

#include <sys/usb/usba.h>

#include <sys/usb/usba/usba_types.h>

#include <sys/usb/usba/usba_impl.h>

#include <sys/usb/clients/usbser/usbser_dsdi.h>

#include <sys/usb/clients/usbser/uchcom/uchcom_var.h>

#include <sys/usb/clients/usbser/uchcom/uchcom_reg.h>

#include <sys/usb/usbdevs.h>

#include <sys/cmn_err.h>

/*

 * DSD operations

 */

static int	uchcom_attach(ds_attach_info_t *);

static void	uchcom_detach(ds_hdl_t);

static int	uchcom_register_cb(ds_hdl_t, uint_t, ds_cb_t *);

static void	uchcom_unregister_cb(ds_hdl_t, uint_t);

static int	uchcom_open_port(ds_hdl_t, uint_t);

static int	uchcom_close_port(ds_hdl_t, uint_t);

/* power management */

static int	uchcom_usb_power(ds_hdl_t, int, int, int *);

static int	uchcom_suspend(ds_hdl_t);

static int	uchcom_resume(ds_hdl_t);

static int	uchcom_disconnect(ds_hdl_t);

static int	uchcom_reconnect(ds_hdl_t);

/* standard UART operations */

static int	uchcom_set_port_params(ds_hdl_t, uint_t, ds_port_params_t *);

static int	uchcom_set_modem_ctl(ds_hdl_t, uint_t, int, int);

static int	uchcom_get_modem_ctl(ds_hdl_t, uint_t, int, int *);

static int	uchcom_break_ctl(ds_hdl_t, uint_t, int);

/* data xfer */

static int	uchcom_tx(ds_hdl_t, uint_t, mblk_t *);

static mblk_t	*uchcom_rx(ds_hdl_t, uint_t);

static void	uchcom_stop(ds_hdl_t, uint_t, int);

static void	uchcom_start(ds_hdl_t, uint_t, int);

static int	uchcom_fifo_flush(ds_hdl_t, uint_t, int);

static int	uchcom_fifo_drain(ds_hdl_t, uint_t, int);

/* polled I/O support */

static usb_pipe_handle_t uchcom_out_pipe(ds_hdl_t, uint_t);

static usb_pipe_handle_t uchcom_in_pipe(ds_hdl_t, uint_t);

/*

 * Sub-routines

 */

/* configuration routines */

static void	uchcom_cleanup(uchcom_state_t *, int);

static int	uchcom_dev_attach(uchcom_state_t *);

static int	uchcom_open_hw_port(uchcom_state_t *);

/* hotplug */

static int	uchcom_restore_device_state(uchcom_state_t *);

static int	uchcom_restore_port_state(uchcom_state_t *);

/* power management */

static int	uchcom_create_pm_components(uchcom_state_t *);

static void	uchcom_destroy_pm_components(uchcom_state_t *);

static int	uchcom_pm_set_busy(uchcom_state_t *);

static void	uchcom_pm_set_idle(uchcom_state_t *);

static int	uchcom_pwrlvl0(uchcom_state_t *);

static int	uchcom_pwrlvl1(uchcom_state_t *);

static int	uchcom_pwrlvl2(uchcom_state_t *);

static int	uchcom_pwrlvl3(uchcom_state_t *);

/* pipe operations */

static int	uchcom_open_pipes(uchcom_state_t *);

static void	uchcom_close_pipes(uchcom_state_t *);

static void	uchcom_disconnect_pipes(uchcom_state_t *);

static int	uchcom_reconnect_pipes(uchcom_state_t *);

/* pipe callbacks */

static void	uchcom_bulkin_cb(usb_pipe_handle_t, usb_bulk_req_t *);

static void	uchcom_bulkout_cb(usb_pipe_handle_t, usb_bulk_req_t *);

/* data transfer routines */

static int	uchcom_rx_start(uchcom_state_t *);

static void	uchcom_tx_start(uchcom_state_t *, int *);

static int	uchcom_send_data(uchcom_state_t *, mblk_t *);

static int	uchcom_wait_tx_drain(uchcom_state_t *, int);

/* vendor-specific commands */

static int      uchcom_cmd_vendor_ctrl_write(uchcom_state_t *,

		    uint16_t, uint16_t, uint16_t);

static int	uchcom_cmd_vendor_ctrl_read(uchcom_state_t *,

		    uint16_t, uint16_t, uint16_t, void *, uint16_t);

static int	uchcom_cmd_vendor_reg_write(uchcom_state_t *,

		    uint8_t, uint8_t, uint8_t, uint8_t);

static int	uchcom_cmd_vendor_reg_read(uchcom_state_t *,

		    uint8_t, uint8_t *, uint8_t, uint8_t *);

static int	uchcom_cmd_vendor_get_version(uchcom_state_t *,

		    uint8_t *);

static int	uchcom_cmd_vendor_update_version(uchcom_state_t *);

static int	uchcom_cmd_vendor_get_status(uchcom_state_t *,

		    uint8_t *);

static void	uchcom_cmd_vendor_convert_status(uchcom_state_t *,

		    uint8_t);

static int	uchcom_cmd_vendor_update_status(uchcom_state_t *);

static int	uchcom_cmd_vendor_set_dtr_rts(uchcom_state_t *);

static int	uchcom_cmd_vendor_calc_divider_settings(uchcom_state_t *,

		    uint32_t);

static int	uchcom_cmd_vendor_set_baudrate(uchcom_state_t *,

		    uint32_t);

/* misc */

static void	uchcom_put_tail(mblk_t **, mblk_t *);

static void	uchcom_put_head(mblk_t **, mblk_t *);

/*

 * DSD ops structure

 */

ds_ops_t uchcom_ds_ops = {

	DS_OPS_VERSION,

	uchcom_attach,

	uchcom_detach,

	uchcom_register_cb,

	uchcom_unregister_cb,

	uchcom_open_port,

	uchcom_close_port,

	uchcom_usb_power,

	uchcom_suspend,

	uchcom_resume,

	uchcom_disconnect,

	uchcom_reconnect,

	uchcom_set_port_params,

	uchcom_set_modem_ctl,

	uchcom_get_modem_ctl,

	uchcom_break_ctl,

	NULL,			/* no loopback support */

	uchcom_tx,

	uchcom_rx,

	uchcom_stop,

	uchcom_start,

	uchcom_fifo_flush,

	uchcom_fifo_drain,

	uchcom_out_pipe,

	uchcom_in_pipe

};

/* debug support */

static uint_t	uchcom_errlevel = USB_LOG_L4;

static uint_t	uchcom_errmask = DPRINT_MASK_ALL;

static uint_t	uchcom_instance_debug = (uint_t)-1;

/*

 * ds_attach

 */

static int

uchcom_attach(ds_attach_info_t *aip)

{

	uchcom_state_t *uch;

	usb_dev_descr_t *dd;

	boolean_t recognized;

	uch = kmem_zalloc(sizeof (*uch), KM_SLEEP);

	uch->uch_dip = aip->ai_dip;

	uch->uch_usb_events = aip->ai_usb_events;

	*aip->ai_hdl = (ds_hdl_t)uch;

	/* only one port */

	*aip->ai_port_cnt = 1;

	if (usb_client_attach(uch->uch_dip, USBDRV_VERSION, 0) != USB_SUCCESS) {

		uchcom_cleanup(uch, 1);

		return (USB_FAILURE);

	}

	if (usb_get_dev_data(uch->uch_dip,

	    &uch->uch_dev_data, USB_PARSE_LVL_IF, 0) != USB_SUCCESS) {

		uchcom_cleanup(uch, 2);

		return (USB_FAILURE);

	}

	mutex_init(&uch->uch_lock, NULL, MUTEX_DRIVER,

	    uch->uch_dev_data->dev_iblock_cookie);

	cv_init(&uch->uch_tx_cv, NULL, CV_DRIVER, NULL);

	uch->uch_lh = usb_alloc_log_hdl(uch->uch_dip, "uchcom",

	    &uchcom_errlevel, &uchcom_errmask, &uchcom_instance_debug, 0);

	recognized = B_FALSE;

	dd = uch->uch_dev_data->dev_descr;

	if (dd->idVendor == UCHCOM_VENDOR) {

		switch (dd->idProduct) {

			case UCHCOM_CHIP_CH340:

				USB_DPRINTF_L3(DPRINT_ATTACH, uch->uch_lh,

				    "Chip Type: CH340");

				cmn_err(CE_NOTE, "Chip Type: CH340");

				recognized = B_TRUE;

				break;

			case UCHCOM_CHIP_CH341:

				USB_DPRINTF_L3(DPRINT_ATTACH, uch->uch_lh,

				    "Chip Type: CH341");

				cmn_err(CE_NOTE, "Chip Type: CH341");

				recognized = B_TRUE;

				recognized = B_TRUE;

				break;

		}

	}

	if (!recognized) {

		uchcom_cleanup(uch, 3);

		return (USB_FAILURE);

	}

	uch->uch_def_ph = uch->uch_dev_data->dev_default_ph;

	mutex_enter(&uch->uch_lock);

	uch->uch_dev_state = USB_DEV_ONLINE;

	uch->uch_port_state = UCHCOM_PORT_CLOSED;

	mutex_exit(&uch->uch_lock);

	if (uchcom_create_pm_components(uch) != USB_SUCCESS) {

		uchcom_cleanup(uch, 3);

		return (USB_FAILURE);

	}

	if (usb_register_event_cbs(uch->uch_dip,

	    uch->uch_usb_events, 0) != USB_SUCCESS) {

		uchcom_cleanup(uch, 4);

		return (USB_FAILURE);

	}

	if (uchcom_dev_attach(uch) != USB_SUCCESS) {

		uchcom_cleanup(uch, 5);

		return (USB_FAILURE);

	}

	if (uchcom_cmd_vendor_update_version(uch) != USB_SUCCESS) {

		uchcom_cleanup(uch, 6);

		return (USB_FAILURE);

	}

	return (USB_SUCCESS);

}

/*

 * ds_detach

 */

static void

uchcom_detach(ds_hdl_t hdl)

{

	uchcom_cleanup((uchcom_state_t *)hdl, UCHCOM_CLEANUP_LEVEL_MAX);

}

/*

 * ds_register_cb

 */

/*ARGSUSED*/

static int

uchcom_register_cb(ds_hdl_t hdl, uint_t portno, ds_cb_t *cb)

{

	uchcom_state_t *uch = (uchcom_state_t *)hdl;

	ASSERT(portno == 0);

	uch->uch_cb = *cb;

	return (USB_SUCCESS);

}

/*

 * ds_unregister_cb

 */

/*ARGSUSED*/

static void

uchcom_unregister_cb(ds_hdl_t hdl, uint_t portno)

{

	uchcom_state_t *uch = (uchcom_state_t *)hdl;

	ASSERT(portno == 0);

	bzero(&uch->uch_cb, sizeof (uch->uch_cb));

}

/*

 * ds_open_port

 */

/*ARGSUSED*/

static int

uchcom_open_port(ds_hdl_t hdl, uint_t portno)

{

	uchcom_state_t *uch = (uchcom_state_t *)hdl;

	int rval;

	USB_DPRINTF_L4(DPRINT_OPEN, uch->uch_lh, "uchcom_open_port %d", portno);

	mutex_enter(&uch->uch_lock);

	if (uch->uch_dev_state == USB_DEV_DISCONNECTED ||

	    uch->uch_port_state != UCHCOM_PORT_CLOSED) {

		mutex_exit(&uch->uch_lock);

		return (USB_FAILURE);

	}

	mutex_exit(&uch->uch_lock);

	if ((rval = uchcom_pm_set_busy(uch)) != USB_SUCCESS)

		return (rval);

	/* initialize hardware serial port */

	rval = uchcom_open_hw_port(uch);

	if (rval == USB_SUCCESS) {

		mutex_enter(&uch->uch_lock);

		/* start to receive data */

		if (uchcom_rx_start(uch) != USB_SUCCESS) {

			mutex_exit(&uch->uch_lock);

			return (USB_FAILURE);

		}

		uch->uch_port_state = UCHCOM_PORT_OPEN;

		mutex_exit(&uch->uch_lock);

	} else

		uchcom_pm_set_idle(uch);

	return (rval);

}

/*

 * ds_close_port

 */

/*ARGSUSED*/

static int

uchcom_close_port(ds_hdl_t hdl, uint_t portno)

{

	uchcom_state_t *uch = (uchcom_state_t *)hdl;

	USB_DPRINTF_L4(DPRINT_CLOSE, uch->uch_lh, "uchcom_close_port %d", portno);

	mutex_enter(&uch->uch_lock);

	/* free resources and finalize state */

	freemsg(uch->uch_rx_mp);

	uch->uch_rx_mp = NULL;

	freemsg(uch->uch_tx_mp);

	uch->uch_tx_mp = NULL;

	uch->uch_port_state = UCHCOM_PORT_CLOSED;

	mutex_exit(&uch->uch_lock);

	uchcom_pm_set_idle(uch);

	return (USB_SUCCESS);

}

/*

 * ds_usb_power

 */

/*ARGSUSED*/

static int

uchcom_usb_power(ds_hdl_t hdl, int comp, int level, int *new_state)

{

	uchcom_state_t	*uch = (uchcom_state_t *)hdl;

	uchcom_pm_t	*pm = uch->uch_pm;

	int		rval;

	USB_DPRINTF_L4(DPRINT_PM, uch->uch_lh, "uchcom_usb_power");

	if (!pm)

		return (USB_FAILURE);

	mutex_enter(&uch->uch_lock);

	/*

	 * check if we are transitioning to a legal power level

	 */

	if (USB_DEV_PWRSTATE_OK(pm->pm_pwr_states, level)) {

		USB_DPRINTF_L2(DPRINT_PM, uch->uch_lh, "uchcom_usb_power: "

		    "illegal power level %d, pwr_states=0x%x",

		    level, pm->pm_pwr_states);

		mutex_exit(&uch->uch_lock);

		return (USB_FAILURE);

	}

	/*

	 * if we are about to raise power and asked to lower power, fail

	 */

	if (pm->pm_raise_power && (level < (int)pm->pm_cur_power)) {

		mutex_exit(&uch->uch_lock);

		return (USB_FAILURE);

	}

	switch (level) {

	case USB_DEV_OS_PWR_OFF:

		rval = uchcom_pwrlvl0(uch);

		break;

	case USB_DEV_OS_PWR_1:

		rval = uchcom_pwrlvl1(uch);

		break;

	case USB_DEV_OS_PWR_2:

		rval = uchcom_pwrlvl2(uch);

		break;

	case USB_DEV_OS_FULL_PWR:

		rval = uchcom_pwrlvl3(uch);

		/*

		 * If usbser dev_state is DISCONNECTED or SUSPENDED, it shows

		 * that the usb serial device is disconnected/suspended while it

		 * is under power down state, now the device is powered up

		 * before it is reconnected/resumed. xxx_pwrlvl3() will set dev

		 * state to ONLINE, we need to set the dev state back to

		 * DISCONNECTED/SUSPENDED.

		 */

		if (rval == USB_SUCCESS &&

		    (*new_state == USB_DEV_DISCONNECTED ||

		    *new_state == USB_DEV_SUSPENDED))

			uch->uch_dev_state = *new_state;

		break;

	default:

		ASSERT(0);      /* cannot happen */

	}

	*new_state = uch->uch_dev_state;

	mutex_exit(&uch->uch_lock);

	return (rval);

}

/*

 * ds_suspend

 */

static int

uchcom_suspend(ds_hdl_t hdl)

{

	uchcom_state_t	*uch = (uchcom_state_t *)hdl;

	int		state = USB_DEV_SUSPENDED;

	USB_DPRINTF_L4(DPRINT_PM, uch->uch_lh, "uchcom_suspend");

	/*

	 * If the device is suspended while it is under PWRED_DOWN state, we

	 * need to keep the PWRED_DOWN state so that it could be powered up

	 * later. In the mean while, usbser dev state will be changed to

	 * SUSPENDED state.

	 */

	mutex_enter(&uch->uch_lock);

	if (uch->uch_dev_state != USB_DEV_PWRED_DOWN)

		uch->uch_dev_state = USB_DEV_SUSPENDED;

	mutex_exit(&uch->uch_lock);

	uchcom_disconnect_pipes(uch);

	return (state);

}

/*

 * ds_resume

 */

static int

uchcom_resume(ds_hdl_t hdl)

{

	uchcom_state_t	*uch = (uchcom_state_t *)hdl;

	int		current_state;

	USB_DPRINTF_L4(DPRINT_PM, uch->uch_lh, "uchcom_resume");

	mutex_enter(&uch->uch_lock);

	current_state = uch->uch_dev_state;

	mutex_exit(&uch->uch_lock);

	if (current_state == USB_DEV_ONLINE)

		return (USB_SUCCESS);

	return (uchcom_restore_device_state(uch));

}

/*

 * ds_disconnect

 */

static int

uchcom_disconnect(ds_hdl_t hdl)

{

	uchcom_state_t	*uch = (uchcom_state_t *)hdl;

	int		state = USB_DEV_DISCONNECTED;

	USB_DPRINTF_L4(DPRINT_HOTPLUG, uch->uch_lh, "uchcom_disconnect");

	/*

	 * If the device is disconnected while it is under PWRED_DOWN state, we

	 * need to keep the PWRED_DOWN state so that it could be powered up

	 * later. In the mean while, usbser dev state will be changed to

	 * DISCONNECTED state.

	 */

	mutex_enter(&uch->uch_lock);

	if (uch->uch_dev_state != USB_DEV_PWRED_DOWN)

		uch->uch_dev_state = USB_DEV_DISCONNECTED;

	mutex_exit(&uch->uch_lock);

	uchcom_disconnect_pipes(uch);

	return (state);

}

/*

 * ds_reconnect

 */

static int

uchcom_reconnect(ds_hdl_t hdl)

{

	uchcom_state_t *uch = (uchcom_state_t *)hdl;

	USB_DPRINTF_L4(DPRINT_HOTPLUG, uch->uch_lh, "uchcom_reconnect");

	return (uchcom_restore_device_state(uch));

}

/*

 * ds_set_port_params

 */

static int

uchcom_set_port_params(ds_hdl_t hdl, uint_t portno, ds_port_params_t *tp)

{

	uchcom_state_t		*uch = (uchcom_state_t *)hdl;

	int			rval;

	int			i;

	ds_port_param_entry_t	*pe;

	if (tp == NULL)

		return (USB_FAILURE);

	USB_DPRINTF_L4(DPRINT_CTLOP, uch->uch_lh, "uchcom_set_port_params");

	// clear configuration

	rval = uchcom_cmd_vendor_ctrl_write(uch, UCHCOM_REQ_RESET, 0, 0);

        if (rval != USB_SUCCESS) {

                USB_DPRINTF_L2(DPRINT_DEF_PIPE, uch->uch_lh,

                    "uchcom_set_port_params: failed to reset!");

                return (rval);

        }

	// configure

        for (i = 0, pe = tp->tp_entries; i < tp->tp_cnt; i++, pe++) {

                switch (pe->param) {

                case DS_PARAM_BAUD:

                        switch (pe->val.ui) {

                        case B300:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params br 300");

                                break;

                        case B600:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params br 600");

                                break;

                        case B1200:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params br 1200");

                                break;

                        case B2400:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params br 2400");

                                break;

                        case B4800:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params br 4800");

                                break;

                        case B9600:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params br 9400");

                                break;

                        case B19200:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params br 19200");

                                break;

                        case B38400:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params br 38400");

                                break;

                        case B57600:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params br 57600");

                                break;

                        case B115200:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params br 115200");

                                break;

                        case B230400:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params br 230400");

                                break;

                        case B460800:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params br 460800");

                                break;

                        case B921600:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params br 921600");

                                break;

                        default:

                                USB_DPRINTF_L3(DPRINT_CTLOP, uch->uch_lh,

                                    "uchcom_set_port_params: bad baud %d",

                                    pe->val.ui);

                                return (USB_FAILURE);

                        }

                        break;

                case DS_PARAM_PARITY:

                        if (pe->val.ui & PARENB) {

                                if (pe->val.ui & PARODD)

					cmn_err(CE_WARN, "XXX: uchcom_set_port_params par odd");

                                else

					cmn_err(CE_WARN, "XXX: uchcom_set_port_params par even");

                        } else {

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params par none");

                        }

                        break;

                case DS_PARAM_STOPB:

                        if (pe->val.ui & CSTOPB)

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params stop bits2");

                        else {

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params stop bits1");

                        }

                        break;

                case DS_PARAM_CHARSZ:

                        switch (pe->val.ui) {

                        case CS8:

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params csz cs8");

                                break;

                        default:

                                USB_DPRINTF_L3(DPRINT_CTLOP, uch->uch_lh,

                                    "uchcom_set_port_params: bad charsz");

                                return (USB_FAILURE);

                        }

                        break;

                case DS_PARAM_XON_XOFF:         /* Software flow control */

                        if ((pe->val.ui & IXON) || (pe->val.ui & IXOFF)) {

                                uint8_t xonc = pe->val.uc[0];

                                uint8_t xoffc = pe->val.uc[1];

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params soft flow ???");

                        }

                        break;

                case DS_PARAM_FLOW_CTL:         /* Hardware flow control */

                        if (pe->val.ui & (RTSXOFF | CTSXON)) {

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params hard flow RTS_CTS_HS");

                        }

                        if (pe->val.ui & DTRXOFF) {

				cmn_err(CE_WARN, "XXX: uchcom_set_port_params hard flow DTR_DSR_HS");

                        }

                        break;

                default:

                        USB_DPRINTF_L2(DPRINT_CTLOP, uch->uch_lh,

                            "uchcom_set_port_params: bad param %d", pe->param);

                        break;

                }

        }

	return (USB_SUCCESS);

}

/*

 * ds_set_modem_ctl

 */

static int

uchcom_set_modem_ctl(ds_hdl_t hdl, uint_t portno, int mask, int val)

{

	uchcom_state_t	*uch = (uchcom_state_t *)hdl;

	USB_DPRINTF_L4(DPRINT_CTLOP, uch->uch_lh, "uchcom_set_modem_ctl");

	// XXX: chip is weird and picky, figure out later

	cmn_err(CE_WARN, "XXX: uchcom_set_modem_ctl");

	return (USB_SUCCESS);

}

/*

 * ds_get_modem_ctl

 */

static int

uchcom_get_modem_ctl(ds_hdl_t hdl, uint_t portno, int mask, int *valp)

{

	uchcom_state_t	*uch = (uchcom_state_t *)hdl;

	USB_DPRINTF_L4(DPRINT_CTLOP, uch->uch_lh, "uchcom_get_modem_ctl");

	// XXX: chip is weird and picky, figure out later

	cmn_err(CE_WARN, "XXX: uchcom_get_modem_ctl");

	return (USB_SUCCESS);

}

/*

 * ds_break_ctl

 */

static int

uchcom_break_ctl(ds_hdl_t hdl, uint_t portno, int ctl)

{

	uchcom_state_t	*uch = (uchcom_state_t *)hdl;

	USB_DPRINTF_L4(DPRINT_CTLOP, uch->uch_lh, "uchcom_break_ctl");

	// XXX: chip is weird and picky, figure out later

	cmn_err(CE_WARN, "XXX: uchcom_break_ctl");

	return (USB_SUCCESS);

}

/*

 * ds_tx

 */

/*ARGSUSED*/

static int

uchcom_tx(ds_hdl_t hdl, uint_t portno, mblk_t *mp)

{

	uchcom_state_t *uch = (uchcom_state_t *)hdl;

	USB_DPRINTF_L4(DPRINT_CTLOP, uch->uch_lh, "uchcom_tx");

	ASSERT(mp != NULL && MBLKL(mp) >= 1);

	mutex_enter(&uch->uch_lock);

	uchcom_put_tail(&uch->uch_tx_mp, mp);      /* add to the chain */

	uchcom_tx_start(uch, NULL);

	mutex_exit(&uch->uch_lock);

	return (USB_SUCCESS);

}

/*

 * ds_rx

 */

/*ARGSUSED*/

static mblk_t *

uchcom_rx(ds_hdl_t hdl, uint_t portno)

{

	uchcom_state_t *uch = (uchcom_state_t *)hdl;

	mblk_t *mp;

	USB_DPRINTF_L4(DPRINT_CTLOP, uch->uch_lh, "uchcom_rx");

	mutex_enter(&uch->uch_lock);

	mp = uch->uch_rx_mp;

	uch->uch_rx_mp = NULL;

	mutex_exit(&uch->uch_lock);

	return (mp);

}

/*

 * ds_stop

 */

/*ARGSUSED*/

static void

uchcom_stop(ds_hdl_t hdl, uint_t portno, int dir)

{

	uchcom_state_t *uch = (uchcom_state_t *)hdl;

	USB_DPRINTF_L4(DPRINT_CTLOP, uch->uch_lh, "uchcom_stop");

	if (dir & DS_TX) {

		mutex_enter(&uch->uch_lock);

		uch->uch_port_flags |= UCHCOM_PORT_TX_STOPPED;

		mutex_exit(&uch->uch_lock);

	}

}

/*

 * ds_start

 */

/*ARGSUSED*/

static void

uchcom_start(ds_hdl_t hdl, uint_t portno, int dir)

{

	uchcom_state_t *uch = (uchcom_state_t *)hdl;

	USB_DPRINTF_L4(DPRINT_CTLOP, uch->uch_lh, "uchcom_start");

	if (dir & DS_TX) {

		mutex_enter(&uch->uch_lock);

		if (uch->uch_port_flags & UCHCOM_PORT_TX_STOPPED) {

			uch->uch_port_flags &= ~UCHCOM_PORT_TX_STOPPED;

			uchcom_tx_start(uch, NULL);

		}

		mutex_exit(&uch->uch_lock);

	}

}

/*

 * ds_fifo_flush

 */

/*ARGSUSED*/

static int

uchcom_fifo_flush(ds_hdl_t hdl, uint_t portno, int dir)

{

	uchcom_state_t *uch = (uchcom_state_t *)hdl;

	USB_DPRINTF_L4(DPRINT_CTLOP, uch->uch_lh,

	    "uchcom_fifo_flush: dir=0x%x", dir);

	mutex_enter(&uch->uch_lock);

	ASSERT(uch->uch_port_state == UCHCOM_PORT_OPEN);

	if (dir & DS_TX) {

		freemsg(uch->uch_tx_mp);

		uch->uch_tx_mp = NULL;

	}

	if (dir & DS_RX) {

		freemsg(uch->uch_rx_mp);

		uch->uch_rx_mp = NULL;

	}

	mutex_exit(&uch->uch_lock);

	return (USB_SUCCESS);

}

/*

 * ds_fifo_drain

 */

/*ARGSUSED*/

static int

uchcom_fifo_drain(ds_hdl_t hdl, uint_t portno, int timeout)

{

	uchcom_state_t *uch = (uchcom_state_t *)hdl;

	USB_DPRINTF_L4(DPRINT_CTLOP, uch->uch_lh, "uchcom_fifo_drain");

	mutex_enter(&uch->uch_lock);

	ASSERT(uch->uch_port_state == UCHCOM_PORT_OPEN);

	if (uchcom_wait_tx_drain(uch, 0) != USB_SUCCESS) {

		mutex_exit(&uch->uch_lock);

		return (USB_FAILURE);

	}

	mutex_exit(&uch->uch_lock);

	/* wait 500 ms until hw fifo drains */

	delay(drv_usectohz(500*1000));

	return (USB_SUCCESS);

}

/*ARGSUSED*/

static usb_pipe_handle_t

uchcom_out_pipe(ds_hdl_t hdl, uint_t port_num)

{

	uchcom_state_t	*uch = (uchcom_state_t *)hdl;

	return (uch->uch_bulkout_ph);

}

/*ARGSUSED*/

static usb_pipe_handle_t

uchcom_in_pipe(ds_hdl_t hdl, uint_t port_num)

{

	uchcom_state_t  *uch = (uchcom_state_t *)hdl;

	return (uch->uch_bulkin_ph);

}

/*

 * configuration clean up

 */

static void

uchcom_cleanup(uchcom_state_t *uch, int level)

{

	ASSERT(level > 0 && level <= UCHCOM_CLEANUP_LEVEL_MAX);

	switch (level) {

	default:

	case 6:

		uchcom_close_pipes(uch);

		/*FALLTHROUGH*/

	case 5:

		usb_unregister_event_cbs(uch->uch_dip, uch->uch_usb_events);

		/*FALLTHROUGH*/

	case 4:

		 uchcom_destroy_pm_components(uch);

		/*FALLTHROUGH*/

	case 3:

		mutex_destroy(&uch->uch_lock);

		cv_destroy(&uch->uch_tx_cv);

		usb_free_log_hdl(uch->uch_lh);

		uch->uch_lh = NULL;

		usb_free_descr_tree(uch->uch_dip, uch->uch_dev_data);

		uch->uch_def_ph = NULL;

		/*FALLTHROUGH*/

	case 2:

		usb_client_detach(uch->uch_dip, uch->uch_dev_data);

		/*FALLTHROUGH*/

	case 1:

		kmem_free(uch, sizeof (*uch));

		break;

	}

}

/*

 * device specific attach

 */

static int

uchcom_dev_attach(uchcom_state_t *uch)

{

	return (uchcom_open_pipes(uch));

}

static int

uchcom_open_hw_port(uchcom_state_t *uch)

{

	int rval;

	// initialize device with defaults

	rval = uchcom_cmd_vendor_ctrl_write(uch, UCHCOM_REQ_RESET,

	    UCHCOM_RESET_VALUE, UCHCOM_RESET_INDEX);

	if (rval != USB_SUCCESS) {

		USB_DPRINTF_L2(DPRINT_DEF_PIPE, uch->uch_lh,

		    "uchcom_open_hw_port: failed to reset!");

	}

	return (rval);

}

/*

 * restore device state after CPR resume or reconnect

 */

static int

uchcom_restore_device_state(uchcom_state_t *uch)

{

	int state;

	mutex_enter(&uch->uch_lock);

	state = uch->uch_dev_state;

	mutex_exit(&uch->uch_lock);

	if (state != USB_DEV_DISCONNECTED && state != USB_DEV_SUSPENDED)

		return (state);

	if (usb_check_same_device(uch->uch_dip, uch->uch_lh, USB_LOG_L0,

	    DPRINT_MASK_ALL, USB_CHK_ALL, NULL) != USB_SUCCESS) {

		mutex_enter(&uch->uch_lock);

		state = uch->uch_dev_state = USB_DEV_DISCONNECTED;

		mutex_exit(&uch->uch_lock);

		return (state);

	}

	if (state == USB_DEV_DISCONNECTED) {

		USB_DPRINTF_L0(DPRINT_HOTPLUG, uch->uch_lh,

		    "Device has been reconnected but data may have been lost");

	}

	if (uchcom_reconnect_pipes(uch) != USB_SUCCESS)

		return (state);

	/*

	 * init device state

	 */

	mutex_enter(&uch->uch_lock);

	state = uch->uch_dev_state = USB_DEV_ONLINE;

	mutex_exit(&uch->uch_lock);

	if ((uchcom_restore_port_state(uch) != USB_SUCCESS)) {

		USB_DPRINTF_L2(DPRINT_HOTPLUG, uch->uch_lh,

		    "uchcom_restore_device_state: failed");

	}

	return (state);

}

/*

 * restore ports state after CPR resume or reconnect

 */

static int

uchcom_restore_port_state(uchcom_state_t *uch)

{

	int rval;

	mutex_enter(&uch->uch_lock);

	if (uch->uch_port_state != UCHCOM_PORT_OPEN) {

		mutex_exit(&uch->uch_lock);

		return (USB_SUCCESS);

	}

	mutex_exit(&uch->uch_lock);

	/* open hardware serial port, restoring old settings */

	if ((rval = uchcom_open_hw_port(uch)) != USB_SUCCESS) {

		USB_DPRINTF_L2(DPRINT_HOTPLUG, uch->uch_lh,

		    "uchcom_restore_port_state: failed");

	}

	return (rval);

}

/*

 * create PM components

 */

static int

uchcom_create_pm_components(uchcom_state_t *uch)

{

	dev_info_t	*dip = uch->uch_dip;

	uchcom_pm_t	*pm;

	uint_t		pwr_states;

	if (usb_create_pm_components(dip, &pwr_states) != USB_SUCCESS) {

		USB_DPRINTF_L2(DPRINT_PM, uch->uch_lh,

		    "uchcom_create_pm_components: failed");

		return (USB_SUCCESS);

	}

	pm = uch->uch_pm = kmem_zalloc(sizeof (*pm), KM_SLEEP);

	pm->pm_pwr_states = (uint8_t)pwr_states;

	pm->pm_cur_power = USB_DEV_OS_FULL_PWR;

	pm->pm_wakeup_enabled = usb_handle_remote_wakeup(dip,

	    USB_REMOTE_WAKEUP_ENABLE) == USB_SUCCESS;

	(void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);

	return (USB_SUCCESS);

}

/*

 * destroy PM components

 */

static void

uchcom_destroy_pm_components(uchcom_state_t *uch)

{

	uchcom_pm_t *pm = uch->uch_pm;

	dev_info_t *dip = uch->uch_dip;

	int rval;

	if (!pm)

		return;

	if (uch->uch_dev_state != USB_DEV_DISCONNECTED) {

		if (pm->pm_wakeup_enabled) {

			rval = pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);

			if (rval != DDI_SUCCESS)

				USB_DPRINTF_L2(DPRINT_PM, uch->uch_lh,

				    "uchcom_destroy_pm_components: "

				    "raising power failed, rval=%d", rval);

			rval = usb_handle_remote_wakeup(dip,

			    USB_REMOTE_WAKEUP_DISABLE);

			if (rval != USB_SUCCESS)

				USB_DPRINTF_L2(DPRINT_PM, uch->uch_lh,

				    "uchcom_destroy_pm_components: disable "

				    "remote wakeup failed, rval=%d", rval);

		}

		(void) pm_lower_power(dip, 0, USB_DEV_OS_PWR_OFF);

	}

	kmem_free(pm, sizeof (*pm));

	uch->uch_pm = NULL;

}

/*

 * mark device busy and raise power

 */

static int

uchcom_pm_set_busy(uchcom_state_t *uch)

{

	uchcom_pm_t	*pm = uch->uch_pm;

	dev_info_t	*dip = uch->uch_dip;

	int		rval;

	USB_DPRINTF_L4(DPRINT_PM, uch->uch_lh, "uchcom_pm_set_busy");

	if (!pm)

		return (USB_SUCCESS);

	mutex_enter(&uch->uch_lock);

	/* if already marked busy, just increment the counter */

	if (pm->pm_busy_cnt++ > 0) {

		mutex_exit(&uch->uch_lock);

		return (USB_SUCCESS);

	}

	rval = pm_busy_component(dip, 0);

	ASSERT(rval == DDI_SUCCESS);

	if (pm->pm_cur_power == USB_DEV_OS_FULL_PWR) {

		mutex_exit(&uch->uch_lock);

		return (USB_SUCCESS);

	}

	/* need to raise power  */

	pm->pm_raise_power = B_TRUE;

	mutex_exit(&uch->uch_lock);

	rval = pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);

	if (rval != DDI_SUCCESS)

		USB_DPRINTF_L2(DPRINT_PM, uch->uch_lh, "raising power failed");

	mutex_enter(&uch->uch_lock);

	pm->pm_raise_power = B_FALSE;

	mutex_exit(&uch->uch_lock);

	return (USB_SUCCESS);

}

/*

 * mark device idle

 */

static void

uchcom_pm_set_idle(uchcom_state_t *uch)

{

	uchcom_pm_t     *pm = uch->uch_pm;

	dev_info_t      *dip = uch->uch_dip;

	USB_DPRINTF_L4(DPRINT_PM, uch->uch_lh, "uchcom_pm_set_idle");

	if (!pm)

		return;

	/*

	 * if more ports use the device, do not mark as yet

	 */

	mutex_enter(&uch->uch_lock);

	if (--pm->pm_busy_cnt > 0) {

		mutex_exit(&uch->uch_lock);

		return;

	}

	if (pm)

		(void) pm_idle_component(dip, 0);

	mutex_exit(&uch->uch_lock);

}

/*

 * Functions to handle power transition for OS levels 0 -> 3

 * The same level as OS state, different from USB state

 */

static int

uchcom_pwrlvl0(uchcom_state_t *uch)

{

	int     rval;

	USB_DPRINTF_L4(DPRINT_PM, uch->uch_lh, "uchcom_pwrlvl0");

	switch (uch->uch_dev_state) {

	case USB_DEV_ONLINE:

		/* issue USB D3 command to the device */

		rval = usb_set_device_pwrlvl3(uch->uch_dip);

		ASSERT(rval == USB_SUCCESS);

		uch->uch_dev_state = USB_DEV_PWRED_DOWN;

		uch->uch_pm->pm_cur_power = USB_DEV_OS_PWR_OFF;

		/* FALLTHRU */

	case USB_DEV_DISCONNECTED:

	case USB_DEV_SUSPENDED:

		/* allow a disconnect/cpr'ed device to go to lower power */

		return (USB_SUCCESS);

	case USB_DEV_PWRED_DOWN:

	default:

		USB_DPRINTF_L2(DPRINT_PM, uch->uch_lh,

		    "uchcom_pwrlvl0: illegal device state");

		return (USB_FAILURE);

	}

}

static int

uchcom_pwrlvl1(uchcom_state_t *uch)

{

	USB_DPRINTF_L4(DPRINT_PM, uch->uch_lh, "uchcom_pwrlvl1");

	/* issue USB D2 command to the device */

	(void) usb_set_device_pwrlvl2(uch->uch_dip);

	return (USB_FAILURE);

}

static int

uchcom_pwrlvl2(uchcom_state_t *uch)

{

	USB_DPRINTF_L4(DPRINT_PM, uch->uch_lh, "uchcom_pwrlvl2");

	/* issue USB D1 command to the device */

	(void) usb_set_device_pwrlvl1(uch->uch_dip);

	return (USB_FAILURE);

}

static int

uchcom_pwrlvl3(uchcom_state_t *uch)

{

	int     rval;

	USB_DPRINTF_L4(DPRINT_PM, uch->uch_lh, "uchcom_pwrlvl3");

	switch (uch->uch_dev_state) {

	case USB_DEV_PWRED_DOWN:

		/* Issue USB D0 command to the device here */

		rval = usb_set_device_pwrlvl0(uch->uch_dip);

		ASSERT(rval == USB_SUCCESS);

		uch->uch_dev_state = USB_DEV_ONLINE;

		uch->uch_pm->pm_cur_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:

		return (USB_SUCCESS);

	default:

		USB_DPRINTF_L2(DPRINT_PM, uch->uch_lh,

		    "uchcom_pwrlvl3: illegal device state");

		return (USB_FAILURE);

	}

}

/*

 * pipe operations

 */

static int

uchcom_open_pipes(uchcom_state_t *uch)

{

	int			ifc, alt;

	usb_pipe_policy_t	policy;

	usb_ep_data_t		*in_data, *out_data;

	size_t			max_xfer_sz;

	/* get ep data */

	ifc = uch->uch_dev_data->dev_curr_if;

	alt = 0;

	in_data = usb_lookup_ep_data(uch->uch_dip, uch->uch_dev_data, ifc, alt,

	    0, USB_EP_ATTR_BULK, USB_EP_DIR_IN);

	out_data = usb_lookup_ep_data(uch->uch_dip, uch->uch_dev_data, ifc, alt,

	    0, USB_EP_ATTR_BULK, USB_EP_DIR_OUT);

	if ((in_data == NULL) || (out_data == NULL)) {

		USB_DPRINTF_L2(DPRINT_ATTACH, uch->uch_lh,

		    "uchcom_open_pipes: can't get ep data");

		return (USB_FAILURE);

	}

        /*

         * Set buffer sizes. Default to UCHCOM_XFER_SZ_MAX.

         * Use wMaxPacketSize from endpoint descriptor if it is nonzero.

         * Cap at a max transfer size of host controller.

         */

        uch->uch_ibuf_sz = uch->uch_obuf_sz = UCHCOM_XFER_SZ_MAX;

        if (in_data->ep_descr.wMaxPacketSize)

                uch->uch_ibuf_sz = in_data->ep_descr.wMaxPacketSize;

        uch->uch_ibuf_sz = min(uch->uch_ibuf_sz, max_xfer_sz);

        if (out_data->ep_descr.wMaxPacketSize)

                uch->uch_obuf_sz = out_data->ep_descr.wMaxPacketSize;

        uch->uch_obuf_sz = min(uch->uch_obuf_sz, max_xfer_sz);

	/* open pipes */

	policy.pp_max_async_reqs = 2;

	if (usb_pipe_open(uch->uch_dip, &in_data->ep_descr, &policy,

	    USB_FLAGS_SLEEP, &uch->uch_bulkin_ph) != USB_SUCCESS) {

		return (USB_FAILURE);

	}

	if (usb_pipe_open(uch->uch_dip, &out_data->ep_descr, &policy,

	    USB_FLAGS_SLEEP, &uch->uch_bulkout_ph) != USB_SUCCESS) {

		usb_pipe_close(uch->uch_dip, uch->uch_bulkin_ph, USB_FLAGS_SLEEP,

		    NULL, NULL);

		return (USB_FAILURE);

	}

	mutex_enter(&uch->uch_lock);

	uch->uch_bulkin_state = UCHCOM_PIPE_IDLE;

	uch->uch_bulkout_state = UCHCOM_PIPE_IDLE;

	mutex_exit(&uch->uch_lock);

	return (USB_SUCCESS);

}

static void

uchcom_close_pipes(uchcom_state_t *uch)

{

	if (uch->uch_bulkin_ph)

		usb_pipe_close(uch->uch_dip, uch->uch_bulkin_ph,

		    USB_FLAGS_SLEEP, 0, 0);

	if (uch->uch_bulkout_ph)

		usb_pipe_close(uch->uch_dip, uch->uch_bulkout_ph,

		    USB_FLAGS_SLEEP, 0, 0);

	mutex_enter(&uch->uch_lock);

	uch->uch_bulkin_state = UCHCOM_PIPE_CLOSED;

	uch->uch_bulkout_state = UCHCOM_PIPE_CLOSED;

	mutex_exit(&uch->uch_lock);

}

static void

uchcom_disconnect_pipes(uchcom_state_t *uch)

{

	uchcom_close_pipes(uch);

}

static int

uchcom_reconnect_pipes(uchcom_state_t *uch)

{

	return (uchcom_open_pipes(uch));

}

/*

 * pipe callbacks bulk in common and exeception callback

 */

/*ARGSUSED*/

void

uchcom_bulkin_cb(usb_pipe_handle_t pipe, usb_bulk_req_t *req)

{

	uchcom_state_t 	*uch = (uchcom_state_t *)req->bulk_client_private;

	mblk_t		*data;

	int		data_len;

	data = req->bulk_data;

	data_len = (data) ? MBLKL(data) : 0;

	USB_DPRINTF_L4(DPRINT_IN_PIPE, uch->uch_lh, "uchcom_bulkin_cb: "

	    "cr=%d len=%d",

	    req->bulk_completion_reason,

	    data_len);

	/* save data and notify GSD */

	if ((uch->uch_port_state == UCHCOM_PORT_OPEN) && (data_len) &&

	    (req->bulk_completion_reason == USB_CR_OK)) {

		req->bulk_data = NULL;

		uchcom_put_tail(&uch->uch_rx_mp, data);

		if (uch->uch_cb.cb_rx) {

			uch->uch_cb.cb_rx(uch->uch_cb.cb_arg);

		}

	}

	usb_free_bulk_req(req);

	/* receive more */

	mutex_enter(&uch->uch_lock);

	uch->uch_bulkin_state = UCHCOM_PIPE_IDLE;

	if ((uch->uch_port_state == UCHCOM_PORT_OPEN) &&

	    (uch->uch_dev_state == USB_DEV_ONLINE)) {

		if (uchcom_rx_start(uch) != USB_SUCCESS) {

			USB_DPRINTF_L2(DPRINT_IN_PIPE, uch->uch_lh,

			    "uchcom_bulkin_cb: restart rx fail");

		}

	}

	mutex_exit(&uch->uch_lock);

}

/*