xref: /illumos-gate/usr/src/uts/common/io/usb/clients/usbser/usbser_keyspan/keyspan_dsd.c (revision e8ed0869)

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


/*
 *
 * DSD code for keyspan usb2serial adapters
 *
 */
#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/clients/usbser/usbser_dsdi.h>
#include <sys/usb/clients/usbser/usbser_keyspan/keyspan_var.h>
#include <sys/usb/clients/usbser/usbser_keyspan/keyspan_pipe.h>

#include <sys/usb/clients/usbser/usbser_keyspan/usa90msg.h>
#include <sys/usb/clients/usbser/usbser_keyspan/usa49msg.h>

/*
 * DSD operations which are filled in ds_ops structure.
 */
static int	keyspan_attach(ds_attach_info_t *);
static void	keyspan_detach(ds_hdl_t);
static int	keyspan_register_cb(ds_hdl_t, uint_t, ds_cb_t *);
static void	keyspan_unregister_cb(ds_hdl_t, uint_t);
static int	keyspan_open_port(ds_hdl_t, uint_t);
static int	keyspan_close_port(ds_hdl_t, uint_t);

/* power management */
static int	keyspan_usb_power(ds_hdl_t, int, int, int *);
static int	keyspan_suspend(ds_hdl_t);
static int	keyspan_resume(ds_hdl_t);

/* hotplug */
static int	keyspan_disconnect(ds_hdl_t);
static int	keyspan_reconnect(ds_hdl_t);

/* standard UART operations */
static int	keyspan_set_port_params(ds_hdl_t, uint_t, ds_port_params_t *);
static int	keyspan_set_modem_ctl(ds_hdl_t, uint_t, int, int);
static int	keyspan_get_modem_ctl(ds_hdl_t, uint_t, int, int *);
static int	keyspan_break_ctl(ds_hdl_t, uint_t, int);
static int	keyspan_loopback(ds_hdl_t, uint_t, int);

/* data xfer */
static int	keyspan_tx(ds_hdl_t, uint_t, mblk_t *);
static mblk_t	*keyspan_rx(ds_hdl_t, uint_t);
static void	keyspan_stop(ds_hdl_t, uint_t, int);
static void	keyspan_start(ds_hdl_t, uint_t, int);
static int	keyspan_fifo_flush(ds_hdl_t, uint_t, int);
static int	keyspan_fifo_drain(ds_hdl_t, uint_t, int);

/*
 * Sub-routines
 */

/* configuration routines */
static void	keyspan_free_soft_state(keyspan_state_t *);
static void	keyspan_init_sync_objs(keyspan_state_t *);
static void	keyspan_fini_sync_objs(keyspan_state_t *);
static int	keyspan_usb_register(keyspan_state_t *);
static void	keyspan_usb_unregister(keyspan_state_t *);
static int	keyspan_attach_dev(keyspan_state_t *);
static void	keyspan_attach_ports(keyspan_state_t *);
static void	keyspan_detach_ports(keyspan_state_t *);
static void	keyspan_init_port_params(keyspan_state_t *);
static void	keyspan_free_descr_tree(keyspan_state_t *);
static int	keyspan_register_events(keyspan_state_t *);
static void	keyspan_unregister_events(keyspan_state_t *);
static void	keyspan_set_dev_state_online(keyspan_state_t *);

/* hotplug */
static int	keyspan_restore_device_state(keyspan_state_t *);
static int	keyspan_restore_ports_state(keyspan_state_t *);

/* power management */
static int	keyspan_create_pm_components(keyspan_state_t *);
static void	keyspan_destroy_pm_components(keyspan_state_t *);
static int	keyspan_pm_set_busy(keyspan_state_t *);
static void	keyspan_pm_set_idle(keyspan_state_t *);
static int	keyspan_pwrlvl0(keyspan_state_t *);
static int	keyspan_pwrlvl1(keyspan_state_t *);
static int	keyspan_pwrlvl2(keyspan_state_t *);
static int	keyspan_pwrlvl3(keyspan_state_t *);

/* pipe operations */
static int	keyspan_attach_pipes(keyspan_state_t *);
static void	keyspan_detach_pipes(keyspan_state_t *);
static void	keyspan_disconnect_pipes(keyspan_state_t *);
static int	keyspan_reconnect_pipes(keyspan_state_t *);

/* data transfer routines */
static int	keyspan_wait_tx_drain(keyspan_port_t *, int);

/* misc */
static void	keyspan_default_port_params(keyspan_port_t *);
static void	keyspan_build_cmd_msg(keyspan_port_t *, ds_port_params_t *);
static void	keyspan_save_port_params(keyspan_port_t	*);

/*
 * Model specific functions.
 */

/* usa19hs specific functions */
static void	keyspan_build_cmd_msg_usa19hs(keyspan_port_t *,
    ds_port_params_t *);
static void	keyspan_default_port_params_usa19hs(keyspan_port_t *);
static void	keyspan_save_port_params_usa19hs(keyspan_port_t	*);


/* usa49 specific functions */
static void	keyspan_build_cmd_msg_usa49(keyspan_port_t *,
    ds_port_params_t *);
static void	keyspan_default_port_params_usa49(keyspan_port_t *);
static void	keyspan_save_port_params_usa49(keyspan_port_t	*);


/*
 * DSD ops structure
 */
ds_ops_t keyspan_ds_ops = {
	DS_OPS_VERSION,
	keyspan_attach,
	keyspan_detach,
	keyspan_register_cb,
	keyspan_unregister_cb,
	keyspan_open_port,
	keyspan_close_port,
	keyspan_usb_power,
	keyspan_suspend,
	keyspan_resume,
	keyspan_disconnect,
	keyspan_reconnect,
	keyspan_set_port_params,
	keyspan_set_modem_ctl,
	keyspan_get_modem_ctl,
	keyspan_break_ctl,
	keyspan_loopback,
	keyspan_tx,
	keyspan_rx,
	keyspan_stop,
	keyspan_start,
	keyspan_fifo_flush,
	keyspan_fifo_drain
};

/*
 *  For USA19HS baud speed, precalculated using the following algorithm:
 *
 *	speed = (uint16_t)(14769231L / baud);
 */
static uint16_t	keyspan_speedtab_usa19hs[] = {
	0x0,	/* B0 */
	0x481d,	/* B50 */
	0x3013,	/* B75 */
	0x20c7,	/* B110 */
	0x1ae8,	/* B134 */
	0x1809,	/* B150 */
	0x1207,	/* B200 */
	0xc04,	/* B300 */
	0x602,	/* B600 */
	0x301,	/* B1200 */
	0x200,	/* B1800 */
	0x180,	/* B2400 */
	0xc0,	/* B4800 */
	0x60,	/* B9600 */
	0x30,	/* B19200 */
	0x18,	/* B38400 */
	0x10,	/* B57600 */
	0xc,	/* B76800 */
	0x8,	/* B115200 */
	0x6,	/* B153600 */
	0x4,	/* B230400 */
};

/*
 *  For USA49WLC baud speed, precalculated.
 */
static uint16_t	keyspan_speedtab_usa49[] = {
	0x0,	/* B0 */
	0x7530,	/* B50 */
	0x4e20,	/* B75 */
	0x3544,	/* B110 */
	0x2bba,	/* B134 */
	0x2710,	/* B150 */
	0x1d4c,	/* B200 */
	0x1388,	/* B300 */
	0x9c4,	/* B600 */
	0x4e2,	/* B1200 */
	0x25e,	/* B1800 */
	0x271,	/* B2400 */
	0xfa,	/* B4800 */
	0x7d,	/* B9600 */
	0x19,	/* B19200 */
	0x27,	/* B38400 */
	0x1a,	/* B57600 */
	0xd,	/* B76800 */
	0xd,	/* B115200 */
	0x6,	/* B153600 */
	0x4,	/* B230400 */
};

/*
 *  For USA49WLC prescaler, precalculated.
 */
static uint8_t	keyspan_prescaler_49wlc[] = {
	0x0,	/* B0 */
	0x8,	/* B50 */
	0x8,	/* B75 */
	0x8,	/* B110 */
	0x8,	/* B134 */
	0x8,	/* B150 */
	0x8,	/* B200 */
	0x8,	/* B300 */
	0x8,	/* B600 */
	0x8,	/* B1200 */
	0xb,	/* B1800 */
	0x8,	/* B2400 */
	0xa,	/* B4800 */
	0xa,	/* B9600 */
	0x19,	/* B19200 */
	0x8,	/* B38400 */
	0x8,	/* B57600 */
	0xc,	/* B76800 */
	0x8,	/* B115200 */
	0xd,	/* B153600 */
	0xd,	/* B230400 */
};


/* convert baud code into baud rate */
static int keyspan_speed2baud[] = {
	0,	/* B0 */
	50,	/* B50 */
	75,	/* B75 */
	110,	/* B110 */
	134,	/* B134 */
	150,	/* B150 */
	200,	/* B200 */
	300,	/* B300 */
	600,	/* B600 */
	1200,	/* B1200 */
	1800,	/* B1800 */
	2400,	/* B2400 */
	4800,	/* B4800 */
	9600,	/* B9600 */
	19200,	/* B19200 */
	38400,	/* B38400 */
	57600,	/* B57600 */
	76800,	/* B76800 */
	115200,	/* B115200 */
	153600,	/* B153600 */
	230400,	/* B230400 */
};


/* debug support */
static uint_t	keyspan_errlevel = USB_LOG_L4;
static uint_t	keyspan_errmask = DPRINT_MASK_ALL;
static uint_t	keyspan_instance_debug = (uint_t)-1;

static int
keyspan_attach(ds_attach_info_t *aip)
{
	keyspan_state_t	*ksp;
	int	rval = USB_SUCCESS;

	ksp = (keyspan_state_t *)kmem_zalloc(sizeof (keyspan_state_t),
	    KM_SLEEP);
	ksp->ks_dip = aip->ai_dip;
	ksp->ks_usb_events = aip->ai_usb_events;
	*aip->ai_hdl = (ds_hdl_t)ksp;

	if (keyspan_usb_register(ksp) != USB_SUCCESS) {

		goto fail_register;
	}

	/* init mutex and semaphore */
	keyspan_init_sync_objs(ksp);

	/* get device specific parameters */
	if (keyspan_attach_dev(ksp) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh, "fail attach dev ");

		goto fail_attach_dev;
	}

	keyspan_attach_ports(ksp);

	switch (ksp->ks_dev_spec.id_product) {
	case KEYSPAN_USA19HS_PID:
	case KEYSPAN_USA49WLC_PID:
		rval = keyspan_init_pipes(ksp);

		break;

	case KEYSPAN_USA49WG_PID:
		rval = keyspan_init_pipes_usa49wg(ksp);

		break;

	default:
		USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh, "keyspan_attach:"
		    "the device's product id can't be recognized");

		return (USB_FAILURE);
	}

	if (rval != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
		    "keyspan_init_pipes: failed.");

		goto fail_init_pipes;
	}

	keyspan_init_port_params(ksp);
	keyspan_free_descr_tree(ksp);
	keyspan_set_dev_state_online(ksp);

	if (keyspan_create_pm_components(ksp) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
		    "keyspan_create_pm_components: failed.");

		goto fail_pm;
	}

	if (keyspan_register_events(ksp) != USB_SUCCESS) {

		goto fail_events;
	}

	/* open the global pipes */
	if (keyspan_attach_pipes(ksp) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
		    "keyspan_attach_pipes: failed.");

		goto fail_attach_pipes;
	}

	*aip->ai_port_cnt = ksp->ks_dev_spec.port_cnt;

	return (USB_SUCCESS);

fail_attach_pipes:
	keyspan_unregister_events(ksp);
fail_events:
	keyspan_destroy_pm_components(ksp);
fail_pm:
	keyspan_fini_pipes(ksp);
fail_init_pipes:
	keyspan_detach_ports(ksp);
fail_attach_dev:
	keyspan_fini_sync_objs(ksp);
	keyspan_usb_unregister(ksp);
fail_register:
	keyspan_free_soft_state(ksp);

	return (USB_FAILURE);
}


/*
 * ds_detach
 */
static void
keyspan_detach(ds_hdl_t hdl)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;

	keyspan_detach_pipes(ksp);
	keyspan_unregister_events(ksp);
	keyspan_destroy_pm_components(ksp);
	keyspan_fini_pipes(ksp);
	keyspan_detach_ports(ksp);
	keyspan_fini_sync_objs(ksp);
	keyspan_usb_unregister(ksp);
	keyspan_free_soft_state(ksp);
}

/*
 * ds_register_cb
 */
static int
keyspan_register_cb(ds_hdl_t hdl, uint_t port_num, ds_cb_t *cb)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp;

	if (port_num >= ksp->ks_dev_spec.port_cnt) {

		return (USB_FAILURE);
	}
	kp = &ksp->ks_ports[port_num];
	kp->kp_cb = *cb;

	return (USB_SUCCESS);
}

/*
 * ds_unregister_cb
 */
static void
keyspan_unregister_cb(ds_hdl_t hdl, uint_t port_num)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp;

	if (port_num < ksp->ks_dev_spec.port_cnt) {
		kp = &ksp->ks_ports[port_num];
		bzero(&kp->kp_cb, sizeof (kp->kp_cb));
	}
}

/*
 * initialize hardware serial port
 *
 * 'open_pipes' specifies whether to open USB pipes or not
 */
int
keyspan_open_hw_port(keyspan_port_t *kp, boolean_t open_pipes)
{
	int		rval;
	keyspan_state_t	*ksp = kp->kp_ksp;

	USB_DPRINTF_L4(DPRINT_OPEN, kp->kp_lh,
	    "keyspan_open_hw_port: [%d]", kp->kp_port_num);

	if (open_pipes) {

		/* open r/w pipes for this port */
		if ((rval = keyspan_open_port_pipes(kp)) != USB_SUCCESS) {

			return (rval);
		}
	}

	mutex_enter(&kp->kp_mutex);
	kp->kp_state = KEYSPAN_PORT_OPEN;
	mutex_exit(&kp->kp_mutex);

	switch (ksp->ks_dev_spec.id_product) {
	case KEYSPAN_USA19HS_PID:
	case KEYSPAN_USA49WLC_PID:
		if ((rval = keyspan_receive_data(&kp->kp_datain_pipe,
		    kp->kp_read_len, kp)) != USB_SUCCESS) {

				goto fail;
		}

		break;

	case KEYSPAN_USA49WG_PID:
		mutex_enter(&ksp->ks_mutex);
		/* open data in pipe the first time, start receiving data */
		if ((ksp->ks_datain_open_cnt == 1) && open_pipes) {
			mutex_exit(&ksp->ks_mutex);
			if ((rval = keyspan_receive_data(&kp->kp_datain_pipe,
			    kp->kp_read_len, kp)) != USB_SUCCESS) {

					goto fail;
			}
		/* the device is reconnected to host, restart receiving data */
		} else if ((ksp->ks_reconnect_flag) && (!open_pipes)) {
			mutex_exit(&ksp->ks_mutex);
			if ((rval = keyspan_receive_data(&kp->kp_datain_pipe,
			    kp->kp_read_len, kp)) != USB_SUCCESS) {

					goto fail;
			}
			mutex_enter(&ksp->ks_mutex);
			ksp->ks_reconnect_flag = 0;
			mutex_exit(&ksp->ks_mutex);

		} else {
			mutex_exit(&ksp->ks_mutex);
		}

		break;

	default:
		USB_DPRINTF_L2(DPRINT_OPEN, ksp->ks_lh, "keyspan_open_hw_port:"
		    "the device's product id can't be recognized");

		return (USB_FAILURE);
	}

	/* set the default port parameters and send cmd msg to enable port */
	mutex_enter(&kp->kp_mutex);
	keyspan_default_port_params(kp);
	mutex_exit(&kp->kp_mutex);

	(void) keyspan_send_cmd(kp);

	USB_DPRINTF_L4(DPRINT_OPEN, kp->kp_lh,
	    "keyspan_open_hw_port: [%d] finished", kp->kp_port_num);

	return (rval);

fail:

	mutex_enter(&kp->kp_mutex);
	kp->kp_state = KEYSPAN_PORT_CLOSED;
	mutex_exit(&kp->kp_mutex);

	if (open_pipes) {

		/* close all ports' data pipes */
		keyspan_close_port_pipes(kp);
	}

	USB_DPRINTF_L2(DPRINT_OPEN, kp->kp_lh,
	    "keyspan_open_hw_port: failed. This port can't be used.");

	return (rval);
}

/*
 * ds_open_port
 */
static int
keyspan_open_port(ds_hdl_t hdl, uint_t port_num)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp = &ksp->ks_ports[port_num];
	int		rval;

	if (port_num >= ksp->ks_dev_spec.port_cnt) {

		return (USB_FAILURE);
	}
	USB_DPRINTF_L4(DPRINT_OPEN, kp->kp_lh, "keyspan_open_port");

	mutex_enter(&ksp->ks_mutex);
	if (ksp->ks_dev_state == USB_DEV_DISCONNECTED) {
		mutex_exit(&ksp->ks_mutex);

		return (USB_FAILURE);
	}
	mutex_exit(&ksp->ks_mutex);

	if (keyspan_pm_set_busy(ksp) != USB_SUCCESS) {

		return (USB_FAILURE);
	}

	/*
	 * initialize state
	 */
	mutex_enter(&kp->kp_mutex);
	ASSERT(kp->kp_state == KEYSPAN_PORT_CLOSED);
	ASSERT((kp->kp_rx_mp == NULL) && (kp->kp_tx_mp == NULL));

	kp->kp_state = KEYSPAN_PORT_OPENING;
	kp->kp_flags = 0;
	mutex_exit(&kp->kp_mutex);

	/*
	 * initialize hardware serial port, B_TRUE means open pipes
	 */
	sema_p(&ksp->ks_pipes_sema);
	rval = keyspan_open_hw_port(kp, B_TRUE);
	if (rval != USB_SUCCESS) {
		keyspan_pm_set_idle(ksp);
	}
	sema_v(&ksp->ks_pipes_sema);

	return (rval);
}


/*
 * close hardware serial port
 */
void
keyspan_close_hw_port(keyspan_port_t *kp)
{
	keyspan_state_t	*ksp = kp->kp_ksp;

	ASSERT(!mutex_owned(&kp->kp_mutex));

	USB_DPRINTF_L4(DPRINT_CLOSE, kp->kp_lh,
	    "keyspan_close_hw_port");

	/*
	 * The bulk IN/OUT pipes might have got closed due to
	 * a device disconnect event. So its required to check the
	 * pipe handle and proceed if it is not NULL
	 */

	mutex_enter(&kp->kp_mutex);
	if ((kp->kp_datain_pipe.pipe_handle == NULL) &&
	    (kp->kp_dataout_pipe.pipe_handle == NULL)) {
		mutex_exit(&kp->kp_mutex);

		return;
	}

	switch (ksp->ks_dev_spec.id_product) {
	case KEYSPAN_USA19HS_PID:
		keyspan_build_cmd_msg_usa19hs(kp, NULL);
		kp->kp_ctrl_msg.usa19hs.portEnabled = 0;
		kp->kp_ctrl_msg.usa19hs.rxFlush = 0;
		kp->kp_ctrl_msg.usa19hs.txFlush = 0;
		kp->kp_ctrl_msg.usa19hs.returnStatus = 0;
		kp->kp_ctrl_msg.usa19hs.setRts = 1;
		kp->kp_ctrl_msg.usa19hs.rts = 0;
		kp->kp_ctrl_msg.usa19hs.setDtr = 1;
		kp->kp_ctrl_msg.usa19hs.dtr = 0;
		kp->kp_ctrl_msg.usa19hs.setTxFlowControl = 1;
		kp->kp_ctrl_msg.usa19hs.txFlowControl = 0;
		kp->kp_ctrl_msg.usa19hs.setRxFlowControl = 1;
		kp->kp_ctrl_msg.usa19hs.rxFlowControl = 0;
		kp->kp_ctrl_msg.usa19hs.rxForwardingTimeout = 0;
		kp->kp_ctrl_msg.usa19hs.rxForwardingLength = 0;

		break;


	case KEYSPAN_USA49WLC_PID:
	case KEYSPAN_USA49WG_PID:
		keyspan_build_cmd_msg_usa49(kp, NULL);
		kp->kp_ctrl_msg.usa49._txOn = 0;
		kp->kp_ctrl_msg.usa49._txOff = 1;
		kp->kp_ctrl_msg.usa49.txFlush = 0;
		kp->kp_ctrl_msg.usa49.txBreak = 0;
		kp->kp_ctrl_msg.usa49.rxOn = 0;
		kp->kp_ctrl_msg.usa49.rxOff = 1;
		kp->kp_ctrl_msg.usa49.rxFlush = 0;
		kp->kp_ctrl_msg.usa49.rxForward = 0;
		kp->kp_ctrl_msg.usa49.returnStatus = 0;
		kp->kp_ctrl_msg.usa49.resetDataToggle = 0;
		kp->kp_ctrl_msg.usa49.enablePort = 0;
		kp->kp_ctrl_msg.usa49.disablePort = 1;

		break;

	default:
		USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
		    "keyspan_close_hw_port:"
		    "the device's product id can't be recognized");
		mutex_exit(&kp->kp_mutex);

		return;
	}

	mutex_exit(&kp->kp_mutex);
	/* send close port cmd to this port */
	if (keyspan_send_cmd(kp) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_CTLOP, kp->kp_lh,
		    "keyspan_close_hw_port: closing hw port, send cmd FAILED");
	}

	/* blow away bulkin requests or pipe close will wait until timeout */
	switch (ksp->ks_dev_spec.id_product) {
		case KEYSPAN_USA19HS_PID:
		case KEYSPAN_USA49WLC_PID:
			usb_pipe_reset(ksp->ks_dip,
			    kp->kp_datain_pipe.pipe_handle,
			    USB_FLAGS_SLEEP, NULL, NULL);

			break;
		case KEYSPAN_USA49WG_PID:
			mutex_enter(&ksp->ks_mutex);
			/*
			 * if only this port is opened, shared data in pipe
			 * can be reset.
			 */
			if (ksp->ks_datain_open_cnt == 1) {
				mutex_exit(&ksp->ks_mutex);

				usb_pipe_reset(ksp->ks_dip,
				    kp->kp_datain_pipe.pipe_handle,
				    USB_FLAGS_SLEEP, NULL, NULL);
			} else {
				mutex_exit(&ksp->ks_mutex);
			}

			break;
		default:
			USB_DPRINTF_L2(DPRINT_CLOSE, kp->kp_lh,
			    "keyspan_close_hw_port: the device's"
			    " product id can't be recognized");
	}

	(void) keyspan_close_port_pipes(kp);
}

/*
 * ds_close_port
 */
static int
keyspan_close_port(ds_hdl_t hdl, uint_t port_num)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp = &ksp->ks_ports[port_num];

	if (port_num >= ksp->ks_dev_spec.port_cnt) {

		return (USB_FAILURE);
	}
	USB_DPRINTF_L4(DPRINT_CLOSE, kp->kp_lh, "keyspan_close_port");

	sema_p(&ksp->ks_pipes_sema);
	mutex_enter(&kp->kp_mutex);
	kp->kp_no_more_reads = B_TRUE;

	/* close hardware serial port */
	mutex_exit(&kp->kp_mutex);

	keyspan_close_hw_port(kp);
	mutex_enter(&kp->kp_mutex);

	/*
	 * free resources and finalize state
	 */
	if (kp->kp_rx_mp) {
		freemsg(kp->kp_rx_mp);
		kp->kp_rx_mp = NULL;
	}
	if (kp->kp_tx_mp) {
		freemsg(kp->kp_tx_mp);
		kp->kp_tx_mp = NULL;
	}

	kp->kp_no_more_reads = B_FALSE;
	kp->kp_state = KEYSPAN_PORT_CLOSED;
	mutex_exit(&kp->kp_mutex);

	keyspan_pm_set_idle(ksp);

	sema_v(&ksp->ks_pipes_sema);

	return (USB_SUCCESS);
}

/*
 * power management
 *
 * ds_usb_power
 */
/*ARGSUSED*/
static int
keyspan_usb_power(ds_hdl_t hdl, int comp, int level, int *new_state)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_pm_t	*pm = ksp->ks_pm;
	int		rval;

	USB_DPRINTF_L4(DPRINT_PM, ksp->ks_lh, "keyspan_usb_power");

	mutex_enter(&ksp->ks_mutex);

	/*
	 * 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, ksp->ks_lh, "keyspan_usb_power:"
		    "illegal power level %d, pwr_states=%x",
		    level, pm->pm_pwr_states);
		mutex_exit(&ksp->ks_mutex);

		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(&ksp->ks_mutex);

		return (USB_FAILURE);
	}

	switch (level) {
	case USB_DEV_OS_PWR_OFF:
		rval = keyspan_pwrlvl0(ksp);

		break;
	case USB_DEV_OS_PWR_1:
		rval = keyspan_pwrlvl1(ksp);

		break;
	case USB_DEV_OS_PWR_2:
		rval = keyspan_pwrlvl2(ksp);

		break;
	case USB_DEV_OS_FULL_PWR:
		rval = keyspan_pwrlvl3(ksp);
		/*
		 * 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))) {
			ksp->ks_dev_state = *new_state;
		}

		break;
	default:
		ASSERT(0);	/* cannot happen */
	}

	*new_state = ksp->ks_dev_state;
	mutex_exit(&ksp->ks_mutex);

	return (rval);
}


/*
 * ds_suspend
 */
static int
keyspan_suspend(ds_hdl_t hdl)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	int		state = USB_DEV_SUSPENDED;

	USB_DPRINTF_L4(DPRINT_PM, ksp->ks_lh, "keyspan_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(&ksp->ks_mutex);
	if (ksp->ks_dev_state != USB_DEV_PWRED_DOWN) {
		ksp->ks_dev_state = USB_DEV_SUSPENDED;
	}
	mutex_exit(&ksp->ks_mutex);

	keyspan_disconnect_pipes(ksp);

	return (state);
}


/*
 * ds_resume
 */
static int
keyspan_resume(ds_hdl_t hdl)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	int		current_state;
	int		rval;

	USB_DPRINTF_L4(DPRINT_PM, ksp->ks_lh, "keyspan_resume");

	mutex_enter(&ksp->ks_mutex);
	current_state = ksp->ks_dev_state;
	mutex_exit(&ksp->ks_mutex);

	if (current_state != USB_DEV_ONLINE) {
		rval = keyspan_restore_device_state(ksp);
	} else {
		rval = USB_SUCCESS;
	}

	return (rval);
}


/*
 * ds_disconnect
 */
static int
keyspan_disconnect(ds_hdl_t hdl)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	int		state = USB_DEV_DISCONNECTED;

	USB_DPRINTF_L4(DPRINT_HOTPLUG, ksp->ks_lh, "keyspan_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(&ksp->ks_mutex);
	if (ksp->ks_dev_state != USB_DEV_PWRED_DOWN) {
		ksp->ks_dev_state = USB_DEV_DISCONNECTED;
	}
	mutex_exit(&ksp->ks_mutex);

	keyspan_disconnect_pipes(ksp);

	return (state);
}


/*
 * ds_reconnect
 */
static int
keyspan_reconnect(ds_hdl_t hdl)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;

	USB_DPRINTF_L4(DPRINT_HOTPLUG, ksp->ks_lh, "keyspan_reconnect");

	return (keyspan_restore_device_state(ksp));
}

/*
 * ds_set_port_params
 */
static int
keyspan_set_port_params(ds_hdl_t hdl, uint_t port_num, ds_port_params_t *tp)
{
	int		cnt = tp->tp_cnt;
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp = &ksp->ks_ports[port_num];

	ASSERT(port_num < ksp->ks_dev_spec.port_cnt);
	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh,
	    "keyspan_set_port_params: port: %d params", cnt);

	if (cnt <= 0) {

		return (USB_SUCCESS);
	}

	mutex_enter(&kp->kp_mutex);
	ASSERT((kp->kp_state == KEYSPAN_PORT_OPENING) ||
	    (kp->kp_state == KEYSPAN_PORT_OPEN));
	keyspan_build_cmd_msg(kp, tp);
	mutex_exit(&kp->kp_mutex);

	if (keyspan_send_cmd(kp) != USB_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_send_cmd() FAILED");

			return (USB_FAILURE);
	}

	return (USB_SUCCESS);
}


/*
 * ds_set_modem_ctl
 */
static int
keyspan_set_modem_ctl(ds_hdl_t hdl, uint_t port_num, int mask, int val)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp = &ksp->ks_ports[port_num];

	ASSERT(port_num < ksp->ks_dev_spec.port_cnt);

	mutex_enter(&kp->kp_mutex);
	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh, "keyspan_set_modem_ctl: "
	    "mask=%x, val=%x", mask, val);

	keyspan_build_cmd_msg(kp, NULL);

	switch (ksp->ks_dev_spec.id_product) {
	case KEYSPAN_USA19HS_PID:
		if (mask & TIOCM_RTS) {

			kp->kp_ctrl_msg.usa19hs.setRts = 0x01;

			if (val & TIOCM_RTS) {
				kp->kp_ctrl_msg.usa19hs.rts = 0x1;
			} else {
				kp->kp_ctrl_msg.usa19hs.rts = 0x0;
			}

		} else {
			kp->kp_ctrl_msg.usa19hs.setRts = 0x0;
		}

		if (mask & TIOCM_DTR) {
			kp->kp_ctrl_msg.usa19hs.setDtr = 0x01;

			if (val & TIOCM_DTR) {
				kp->kp_ctrl_msg.usa19hs.dtr = 0x1;
			} else {
				kp->kp_ctrl_msg.usa19hs.dtr = 0x0;
			}

		} else {
			kp->kp_ctrl_msg.usa19hs.setDtr = 0x0;
		}

		break;


	case KEYSPAN_USA49WLC_PID:
	case KEYSPAN_USA49WG_PID:
		if (mask & TIOCM_RTS) {

			kp->kp_ctrl_msg.usa49.setRts = 0x1;

			if (val & TIOCM_RTS) {
				kp->kp_ctrl_msg.usa49.rts = 0x1;
			} else {
				kp->kp_ctrl_msg.usa49.rts = 0x0;
			}

		} else {
			kp->kp_ctrl_msg.usa49.setRts = 0x0;
		}

		if (mask & TIOCM_DTR) {
			kp->kp_ctrl_msg.usa49.setDtr = 0x1;

			if (val & TIOCM_DTR) {
				kp->kp_ctrl_msg.usa49.dtr = 0x1;
			} else {
				kp->kp_ctrl_msg.usa49.dtr = 0x0;
			}

		} else {
			kp->kp_ctrl_msg.usa49.setDtr = 0x0;
		}

		break;

	default:
		USB_DPRINTF_L2(DPRINT_CTLOP, kp->kp_lh,
		    "keyspan_get_modem_ctl:"
		    "the device's product id can't be recognized");
		mutex_exit(&kp->kp_mutex);

		return (USB_FAILURE);
	}

	mutex_exit(&kp->kp_mutex);

	if (keyspan_send_cmd(kp) != USB_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_send_cmd() FAILED");

			return (USB_FAILURE);
	}

	return (USB_SUCCESS);
}

/*
 * ds_get_modem_ctl
 */
static int
keyspan_get_modem_ctl(ds_hdl_t hdl, uint_t port_num, int mask, int *valp)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp = &ksp->ks_ports[port_num];
	int	val = 0;

	ASSERT(port_num < ksp->ks_dev_spec.port_cnt);

	mutex_enter(&kp->kp_mutex);

	/*
	 * rts and dtr are not in status_msg, but we can get it from
	 * status_flag since it represents what we set the device last time.
	 */
	if (kp->kp_status_flag & KEYSPAN_PORT_RTS) {
		val |= TIOCM_RTS;
	}
	if (kp->kp_status_flag & KEYSPAN_PORT_DTR) {
		val |= TIOCM_DTR;
	}

	/* usbser don't deal with TIOCM_RI status */
	switch (ksp->ks_dev_spec.id_product) {
	case KEYSPAN_USA19HS_PID:
		if (kp->kp_status_msg.usa19hs.dcd) {
			val |= TIOCM_CD;
		}
		if (kp->kp_status_msg.usa19hs.cts) {
			val |= TIOCM_CTS;
		}
		if (kp->kp_status_msg.usa19hs.dsr) {
			val |= TIOCM_DSR;
		}
		break;


	case KEYSPAN_USA49WLC_PID:
	case KEYSPAN_USA49WG_PID:
		if (kp->kp_status_msg.usa49.dcd) {
			val |= TIOCM_CD;
		}
		if (kp->kp_status_msg.usa49.cts) {
			val |= TIOCM_CTS;
		}
		if (kp->kp_status_msg.usa49.dsr) {
			val |= TIOCM_DSR;
		}
		break;

	default:
		USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
		    "keyspan_get_modem_ctl:"
		    "the device's product id can't be recognized");
		mutex_exit(&kp->kp_mutex);

		return (USB_FAILURE);
	}

	*valp = val & mask;

	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh, "keyspan_get_modem_ctl:"
	    "success. status_flag = %x, val=0%o",
	    kp->kp_status_flag, *valp);

	mutex_exit(&kp->kp_mutex);

	return (USB_SUCCESS);
}


/*
 * ds_break_ctl
 */
static int
keyspan_break_ctl(ds_hdl_t hdl, uint_t port_num, int ctl)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp = &ksp->ks_ports[port_num];
	int		is_break;
	int		rval = USB_SUCCESS;

	ASSERT(port_num < ksp->ks_dev_spec.port_cnt);
	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh,
	    "keyspan_break_ctl: ctl = %s", (ctl == DS_ON) ? "on" : "off");

	mutex_enter(&kp->kp_mutex);
	ASSERT(kp->kp_state == KEYSPAN_PORT_OPEN);
	ASSERT(ctl == DS_ON || ctl == DS_OFF);

	is_break = kp->kp_status_flag & KEYSPAN_PORT_TXBREAK;

	if ((ctl == DS_ON) && !is_break) {

		keyspan_build_cmd_msg(kp, NULL);

		switch (ksp->ks_dev_spec.id_product) {
		case KEYSPAN_USA19HS_PID:
			kp->kp_ctrl_msg.usa19hs.txBreak = 1;

			break;

		case KEYSPAN_USA49WLC_PID:
		case KEYSPAN_USA49WG_PID:
			kp->kp_ctrl_msg.usa49.txBreak = 1;

			break;

		default:
			mutex_exit(&kp->kp_mutex);
			USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
			    "keyspan_break_ctl:"
			    "the device's product id can't be recognized");

			return (USB_FAILURE);
		}

		mutex_exit(&kp->kp_mutex);
		rval = keyspan_send_cmd(kp);
		return (rval);
	}

	if ((ctl == DS_OFF) && is_break) {
		keyspan_build_cmd_msg(kp, NULL);

		switch (ksp->ks_dev_spec.id_product) {
		case KEYSPAN_USA19HS_PID:
			kp->kp_ctrl_msg.usa19hs.txBreak = 0;

			break;

		case KEYSPAN_USA49WLC_PID:
		case KEYSPAN_USA49WG_PID:
			kp->kp_ctrl_msg.usa49._txOn = 1;
			kp->kp_ctrl_msg.usa49.txBreak = 0;

			break;

		default:
			mutex_exit(&kp->kp_mutex);
			USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
			    "keyspan_break_ctl:"
			    "the device's product id can't be recognized");

			return (USB_FAILURE);
		}

		mutex_exit(&kp->kp_mutex);
		rval = keyspan_send_cmd(kp);
		if (rval == USB_SUCCESS) {
			mutex_enter(&kp->kp_mutex);

			/* resume transmit */
			keyspan_tx_start(kp, NULL);
			mutex_exit(&kp->kp_mutex);
		}

		return (rval);
	}

	mutex_exit(&kp->kp_mutex);
	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh,
	    "keyspan_break_ctl: not necessary to set break, is_break = %d",
	    is_break);

	return (rval);
}


/*
 * ds_loopback
 */
static int
keyspan_loopback(ds_hdl_t hdl, uint_t port_num, int ctl)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp = &ksp->ks_ports[port_num];
	int		is_loop;
	int		rval = USB_SUCCESS;

	ASSERT(port_num < ksp->ks_dev_spec.port_cnt);
	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh,
	    "keyspan_loopback: %s", (ctl == DS_ON) ? "on" : "off");

	mutex_enter(&kp->kp_mutex);
	ASSERT(kp->kp_state == KEYSPAN_PORT_OPEN);
	ASSERT(ctl == DS_ON || ctl == DS_OFF);

	/* check bit indicating internal loopback state */
	is_loop = kp->kp_status_flag & KEYSPAN_PORT_LOOPBACK;

	if ((ctl == DS_ON) && !is_loop) {

		keyspan_build_cmd_msg(kp, NULL);
		switch (ksp->ks_dev_spec.id_product) {
		case KEYSPAN_USA19HS_PID:
			kp->kp_ctrl_msg.usa19hs.loopbackMode = 0;

			break;

		case KEYSPAN_USA49WLC_PID:
		case KEYSPAN_USA49WG_PID:
			kp->kp_ctrl_msg.usa49.loopbackMode = 0;

			break;

		default:
			mutex_exit(&kp->kp_mutex);
			USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
			    "keyspan_loopback:"
			    "the device's product id can't be recognized");

			return (USB_FAILURE);
		}
		mutex_exit(&kp->kp_mutex);
		rval = keyspan_send_cmd(kp);
	} else if ((ctl == DS_OFF) && is_loop) {

		keyspan_build_cmd_msg(kp, NULL);
		switch (ksp->ks_dev_spec.id_product) {
		case KEYSPAN_USA19HS_PID:
			kp->kp_ctrl_msg.usa19hs.loopbackMode = 1;

			break;

		case KEYSPAN_USA49WLC_PID:
		case KEYSPAN_USA49WG_PID:
			kp->kp_ctrl_msg.usa49.loopbackMode = 1;

			break;

		default:
			mutex_exit(&kp->kp_mutex);
			USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
			    "keyspan_loopback:"
			    "the device's product id can't be recognized");

			return (USB_FAILURE);
		}
		mutex_exit(&kp->kp_mutex);
		rval = keyspan_send_cmd(kp);
	} else {
		mutex_exit(&kp->kp_mutex);
		USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh,
		    "keyspan_loopback: not necessary to set loopback,"
		    "is_loop = %d", is_loop);
	}

	return (rval);
}


/*
 * ds_tx
 */
static int
keyspan_tx(ds_hdl_t hdl, uint_t port_num, mblk_t *mp)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp = &ksp->ks_ports[port_num];
	int		xferd;

	ASSERT(port_num < ksp->ks_dev_spec.port_cnt);
	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh, "keyspan_tx");

	/*
	 * sanity checks
	 */
	if (mp == NULL) {
		USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh, "keyspan_tx: mp=NULL");

		return (USB_SUCCESS);
	}

	kp = &ksp->ks_ports[port_num];

	mutex_enter(&kp->kp_mutex);

	keyspan_put_tail(&kp->kp_tx_mp, mp);	/* add to the chain */

	keyspan_tx_start(kp, &xferd);		/* go! */

	mutex_exit(&kp->kp_mutex);

	return (USB_SUCCESS);
}


/*
 * ds_rx. the real data receiving is in keyspan_open_hw_port
 */
static mblk_t *
keyspan_rx(ds_hdl_t hdl, uint_t port_num)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp = &ksp->ks_ports[port_num];
	mblk_t		*mp;

	ASSERT(port_num < ksp->ks_dev_spec.port_cnt);
	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh, "keyspan_rx");

	mutex_enter(&kp->kp_mutex);
	mp = kp->kp_rx_mp;
	kp->kp_rx_mp = NULL;
	mutex_exit(&kp->kp_mutex);

	return (mp);
}


/*
 * ds_stop
 */
static void
keyspan_stop(ds_hdl_t hdl, uint_t port_num, int dir)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp = &ksp->ks_ports[port_num];

	ASSERT(port_num < ksp->ks_dev_spec.port_cnt);
	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh, "keyspan_stop");

	if (dir & DS_TX) {
		mutex_enter(&kp->kp_mutex);
		kp->kp_flags |= KEYSPAN_PORT_TX_STOPPED;
		mutex_exit(&kp->kp_mutex);
	}
}


/*
 * ds_start
 */
static void
keyspan_start(ds_hdl_t hdl, uint_t port_num, int dir)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp = &ksp->ks_ports[port_num];

	ASSERT(port_num < ksp->ks_dev_spec.port_cnt);
	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh, "keyspan_start");

	if (dir & DS_TX) {
		mutex_enter(&kp->kp_mutex);
		if (kp->kp_flags & KEYSPAN_PORT_TX_STOPPED) {
			kp->kp_flags &= ~KEYSPAN_PORT_TX_STOPPED;
			keyspan_tx_start(kp, NULL);
		}
		mutex_exit(&kp->kp_mutex);
	}
}


/*
 * ds_fifo_flush
 * send flush cmd and wait for completion, then turn off the flush.
 */
static int
keyspan_fifo_flush(ds_hdl_t hdl, uint_t port_num, int dir)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp = &ksp->ks_ports[port_num];

	ASSERT(port_num < ksp->ks_dev_spec.port_cnt);
	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh,
	    "keyspan_fifo_flush: dir=%x", dir);

	mutex_enter(&kp->kp_mutex);
	ASSERT(kp->kp_state == KEYSPAN_PORT_OPEN);

	/* discard the data in DSD buffers */
	if ((dir & DS_TX) && kp->kp_tx_mp) {
		freemsg(kp->kp_tx_mp);
		kp->kp_tx_mp = NULL;
	}
	if ((dir & DS_RX) && kp->kp_rx_mp) {
		freemsg(kp->kp_rx_mp);
		kp->kp_rx_mp = NULL;
	}

	mutex_exit(&kp->kp_mutex);

	return (USB_SUCCESS);
}

/*
 * ds_fifo_drain
 *
 * it is the caller's responsibility to cease submitting new tx data
 * while this function executes
 */
static int
keyspan_fifo_drain(ds_hdl_t hdl, uint_t port_num, int timeout)
{
	keyspan_state_t	*ksp = (keyspan_state_t *)hdl;
	keyspan_port_t	*kp = &ksp->ks_ports[port_num];
	int		rval = USB_SUCCESS;

	ASSERT(port_num < ksp->ks_dev_spec.port_cnt);
	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh,
	    "keyspan_fifo_drain, timeout = %d", timeout);

	mutex_enter(&kp->kp_mutex);
	ASSERT(kp->kp_state == KEYSPAN_PORT_OPEN);

	/* wait until local data drains */
	if (keyspan_wait_tx_drain(kp, 0) != USB_SUCCESS) {
		mutex_exit(&kp->kp_mutex);

		return (USB_FAILURE);
	}
	mutex_exit(&kp->kp_mutex);

	/* wait until hw fifo drains */
	delay(drv_usectohz(500*1000));

	return (rval);
}


/*
 * configuration routines
 * ----------------------
 *
 */

/*
 * free state structure
 */
static void
keyspan_free_soft_state(keyspan_state_t *ksp)
{
	kmem_free(ksp, sizeof (keyspan_state_t));
}


/*
 * register/unregister USBA client
 */
static int
keyspan_usb_register(keyspan_state_t *ksp)
{
	int	rval;

	rval = usb_client_attach(ksp->ks_dip, USBDRV_VERSION, 0);
	if (rval == USB_SUCCESS) {
		rval = usb_get_dev_data(ksp->ks_dip, &ksp->ks_dev_data,
		    USB_PARSE_LVL_IF, 0);
		if (rval == USB_SUCCESS) {
			ksp->ks_lh =
			    usb_alloc_log_hdl(ksp->ks_dip, "keyspan[*].",
			    &keyspan_errlevel, &keyspan_errmask,
			    &keyspan_instance_debug, 0);

			ksp->ks_def_pipe.pipe_handle =
			    ksp->ks_dev_data->dev_default_ph;
			ksp->ks_def_pipe.pipe_ksp = ksp;
			ksp->ks_def_pipe.pipe_lh = ksp->ks_lh;
		}
	}

	return (rval);
}


static void
keyspan_usb_unregister(keyspan_state_t *ksp)
{
	usb_free_log_hdl(ksp->ks_lh);
	ksp->ks_lh = NULL;
	usb_client_detach(ksp->ks_dip, ksp->ks_dev_data);
	ksp->ks_def_pipe.pipe_handle = NULL;
	ksp->ks_dev_data = NULL;
}


/*
 * init/fini soft state during attach
 */
static void
keyspan_init_sync_objs(keyspan_state_t *ksp)
{
	mutex_init(&ksp->ks_mutex, NULL, MUTEX_DRIVER,
	    ksp->ks_dev_data->dev_iblock_cookie);
	sema_init(&ksp->ks_pipes_sema, 1, NULL, SEMA_DRIVER, NULL);
}


static void
keyspan_fini_sync_objs(keyspan_state_t *ksp)
{
	mutex_destroy(&ksp->ks_mutex);
	sema_destroy(&ksp->ks_pipes_sema);
}


/*
 * device specific attributes
 */
static int
keyspan_attach_dev(keyspan_state_t *ksp)
{

	mutex_enter(&ksp->ks_mutex);
	switch (ksp->ks_dev_data->dev_descr->idProduct) {
	case KEYSPAN_USA19HS_PID:
		ksp->ks_dev_spec.id_product = KEYSPAN_USA19HS_PID;
		ksp->ks_dev_spec.port_cnt = 1;
		ksp->ks_dev_spec.ctrl_ep_addr = 0x02;
		ksp->ks_dev_spec.stat_ep_addr = 0x82;
		ksp->ks_dev_spec.dataout_ep_addr[0] = 0x01;
		ksp->ks_dev_spec.datain_ep_addr[0] = 0x81;

		break;

	case KEYSPAN_USA49WLC_PID:
		ksp->ks_dev_spec.id_product = KEYSPAN_USA49WLC_PID;
		ksp->ks_dev_spec.port_cnt = 4;
		ksp->ks_dev_spec.ctrl_ep_addr = 0x07;
		ksp->ks_dev_spec.stat_ep_addr = 0x87;
		ksp->ks_dev_spec.dataout_ep_addr[0] = 0x01;
		ksp->ks_dev_spec.dataout_ep_addr[1] = 0x02;
		ksp->ks_dev_spec.dataout_ep_addr[2] = 0x03;
		ksp->ks_dev_spec.dataout_ep_addr[3] = 0x04;
		ksp->ks_dev_spec.datain_ep_addr[0] = 0x81;
		ksp->ks_dev_spec.datain_ep_addr[1] = 0x82;
		ksp->ks_dev_spec.datain_ep_addr[2] = 0x83;
		ksp->ks_dev_spec.datain_ep_addr[3] = 0x84;

		break;

	case KEYSPAN_USA49WG_PID:
		ksp->ks_dev_spec.id_product = KEYSPAN_USA49WG_PID;
		ksp->ks_dev_spec.port_cnt = 4;
		ksp->ks_dev_spec.stat_ep_addr = 0x81;
		ksp->ks_dev_spec.dataout_ep_addr[0] = 0x01;
		ksp->ks_dev_spec.dataout_ep_addr[1] = 0x02;
		ksp->ks_dev_spec.dataout_ep_addr[2] = 0x04;
		ksp->ks_dev_spec.dataout_ep_addr[3] = 0x06;
		ksp->ks_dev_spec.datain_ep_addr[0] = 0x88;
		ksp->ks_dev_spec.datain_ep_addr[1] = 0x88;
		ksp->ks_dev_spec.datain_ep_addr[2] = 0x88;
		ksp->ks_dev_spec.datain_ep_addr[3] = 0x88;

		break;

	default:
		mutex_exit(&ksp->ks_mutex);
		USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
		    "keyspan_attach_dev:"
		    "the device's product id can't be recognized");

		return (USB_FAILURE);
	}

	mutex_exit(&ksp->ks_mutex);

	return (USB_SUCCESS);
}

/*
 * allocate and initialize per port resources.
 */
static void
keyspan_attach_ports(keyspan_state_t *ksp)
{
	int		i;
	keyspan_port_t	*kp;

	ksp->ks_ports = kmem_zalloc(ksp->ks_dev_spec.port_cnt *
	    sizeof (keyspan_port_t), KM_SLEEP);

	for (i = 0; i < ksp->ks_dev_spec.port_cnt; i++) {
		kp = &ksp->ks_ports[i];
		kp->kp_port_num = i;
		kp->kp_ksp = ksp;

		(void) sprintf(kp->kp_lh_name, "keyspan[%d].", i);
		kp->kp_lh = usb_alloc_log_hdl(ksp->ks_dip, kp->kp_lh_name,
		    &keyspan_errlevel, &keyspan_errmask,
		    &keyspan_instance_debug, 0);

		kp->kp_state = KEYSPAN_PORT_CLOSED;
		mutex_init(&kp->kp_mutex, NULL, MUTEX_DRIVER,
		    ksp->ks_dev_data->dev_iblock_cookie);
		cv_init(&kp->kp_tx_cv, NULL, CV_DRIVER, NULL);
	}
}


/*
 * free per port resources
 */
static void
keyspan_detach_ports(keyspan_state_t *ksp)
{
	int		i;
	keyspan_port_t	*kp;

	for (i = 0; i < ksp->ks_dev_spec.port_cnt; i++) {
		kp = &ksp->ks_ports[i];
		if (kp->kp_state != KEYSPAN_PORT_NOT_INIT) {
			ASSERT(kp->kp_state == KEYSPAN_PORT_CLOSED);

			mutex_destroy(&kp->kp_mutex);
			cv_destroy(&kp->kp_tx_cv);
			usb_free_log_hdl(kp->kp_lh);
		}
	}
	kmem_free(ksp->ks_ports,
	    ksp->ks_dev_spec.port_cnt * sizeof (keyspan_port_t));
}

static void
keyspan_init_port_params(keyspan_state_t *ksp)
{
	int		i;
	size_t		sz;
	uint_t		read_len;
	uint_t		write_len;

	/* the max data len of every bulk in req. */
	if (usb_pipe_get_max_bulk_transfer_size(ksp->ks_dip, &sz) ==
	    USB_SUCCESS) {
		if (ksp->ks_dev_spec.id_product == KEYSPAN_USA49WG_PID) {
			read_len = (uint_t)min(sz, KEYSPAN_BULKIN_MAX_LEN_49WG);
		} else {
			read_len = (uint_t)min(sz, KEYSPAN_BULKIN_MAX_LEN);
		}
	} else {
		if (ksp->ks_dev_spec.id_product == KEYSPAN_USA49WG_PID) {
			read_len = KEYSPAN_BULKIN_MAX_LEN_49WG;
		} else {
			read_len = KEYSPAN_BULKIN_MAX_LEN;
		}
	}

	for (i = 0; i < ksp->ks_dev_spec.port_cnt; i++) {
		ksp->ks_ports[i].kp_read_len = read_len;
		/* the max data len of every bulk out req. */
		switch (ksp->ks_dev_spec.id_product) {
		case KEYSPAN_USA19HS_PID:
			ksp->ks_ports[i].kp_write_len =
			    KEYSPAN_BULKOUT_MAX_LEN_19HS;

			break;
		case KEYSPAN_USA49WLC_PID:
			ksp->ks_ports[i].kp_write_len =
			    KEYSPAN_BULKOUT_MAX_LEN_49WLC;

			break;
		case KEYSPAN_USA49WG_PID:
			/*
			 * USA49WG port0 uses intr out pipe send data while
			 * other ports use bulk out pipes, so port0's max
			 * packet length for "bulk out" is different from other
			 * ports' while the same as USA49WLC.
			 */
			write_len = ((i == 0) ? KEYSPAN_BULKOUT_MAX_LEN_49WLC :
			    KEYSPAN_BULKOUT_MAX_LEN_49WG);
			ksp->ks_ports[i].kp_write_len = write_len;

			break;
		default:
			USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
			    "keyspan_init_port_params:"
			    "the device's product id can't be recognized");

			return;
		}
	}
}


/*
 * free descriptor tree
 */
static void
keyspan_free_descr_tree(keyspan_state_t *ksp)
{
	usb_free_descr_tree(ksp->ks_dip, ksp->ks_dev_data);

}


/*
 * register/unregister USB event callbacks
 */
static int
keyspan_register_events(keyspan_state_t *ksp)
{
	return (usb_register_event_cbs(ksp->ks_dip, ksp->ks_usb_events, 0));
}


static void
keyspan_unregister_events(keyspan_state_t *ksp)
{
	usb_unregister_event_cbs(ksp->ks_dip, ksp->ks_usb_events);
}


static void
keyspan_set_dev_state_online(keyspan_state_t *ksp)
{
	ksp->ks_dev_state = USB_DEV_ONLINE;
}

/*
 * send command to the port and save the params after its completion for
 * USA19HS and USA49WLC
 */
int
keyspan_send_cmd_usa49(keyspan_port_t *kp)
{
	keyspan_state_t	*ksp = kp->kp_ksp;
	mblk_t		*mp;
	int		rval = USB_SUCCESS;
	int	size;
	usb_bulk_req_t	*br;

	ASSERT(!mutex_owned(&kp->kp_mutex));
	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh, "keyspan_send_cmd_usa49");

	switch (ksp->ks_dev_spec.id_product) {
	case KEYSPAN_USA19HS_PID:
		size = sizeof (keyspan_usa19hs_port_ctrl_msg_t);

		break;


	case KEYSPAN_USA49WLC_PID:
		size = sizeof (keyspan_usa49_port_ctrl_msg_t);

		break;

	default:
		USB_DPRINTF_L2(DPRINT_CTLOP, ksp->ks_lh,
		    "keyspan_send_cmd_usa49:"
		    "the device's product id can't be recognized");
		return (USB_FAILURE);
	}

	if ((mp = allocb(size, BPRI_LO)) == NULL) {

		return (USB_FAILURE);
	}
	bcopy(&kp->kp_ctrl_msg, mp->b_rptr, size);

	br = usb_alloc_bulk_req(ksp->ks_dip, 0, USB_FLAGS_SLEEP);
	br->bulk_len = size;
	br->bulk_data = mp;
	br->bulk_timeout = KEYSPAN_BULK_TIMEOUT;
	br->bulk_client_private = (void *)kp;
	br->bulk_attributes = USB_ATTRS_AUTOCLEARING;

	rval = usb_pipe_bulk_xfer(ksp->ks_ctrlout_pipe.pipe_handle, br,
	    USB_FLAGS_SLEEP);
	if (rval == USB_SUCCESS) {
		mutex_enter(&kp->kp_mutex);
		keyspan_save_port_params(kp);
		mutex_exit(&kp->kp_mutex);
	} else {
		USB_DPRINTF_L2(DPRINT_CTLOP, kp->kp_lh, "keyspan_send_cmd_usa49"
		    ": failure, rval=%d", rval);
	}

	usb_free_bulk_req(br);

	return (rval);
}

/*
 * send command to the port and save the params after its completion for
 * USA_49WG only
 */
int
keyspan_send_cmd_usa49wg(keyspan_port_t *kp)
{
	keyspan_state_t	*ksp = kp->kp_ksp;
	mblk_t		*mp;
	int		rval = USB_SUCCESS;
	uint16_t		size = sizeof (keyspan_usa49_port_ctrl_msg_t);
	usb_cb_flags_t	cb_flags;
	usb_cr_t	cr;
	usb_ctrl_setup_t setup;

	ASSERT(!mutex_owned(&kp->kp_mutex));
	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh, "keyspan_send_cmd_usa49wg");

	if ((mp = allocb(size, BPRI_LO)) == NULL) {

		return (USB_FAILURE);
	}
	bcopy(&kp->kp_ctrl_msg, mp->b_rptr, size);

	setup.bmRequestType = USB_DEV_REQ_TYPE_VENDOR;
	setup.bRequest = KEYSPAN_SET_CONTROL_REQUEST;
	setup.wValue = 0;
	setup.wIndex = 0;
	setup.wLength = size;
	setup.attrs = 0;

	rval = usb_pipe_ctrl_xfer_wait(ksp->ks_def_pipe.pipe_handle, &setup,
	    &mp, &cr, &cb_flags, 0);

	if (rval == USB_SUCCESS) {
		mutex_enter(&kp->kp_mutex);
		keyspan_save_port_params(kp);
		mutex_exit(&kp->kp_mutex);
	} else {
		USB_DPRINTF_L2(DPRINT_CTLOP, kp->kp_lh,
		    "keyspan_send_cmd_usa49wg: failure, rval=%d", rval);
	}
	if (mp) {
		freemsg(mp);
	}

	return (rval);
}

/*
 * send command to the port and save the params after its completion
 */
int
keyspan_send_cmd(keyspan_port_t *kp)
{
	keyspan_state_t	*ksp = kp->kp_ksp;
	int		rval = USB_FAILURE;

	switch (ksp->ks_dev_spec.id_product) {
	case KEYSPAN_USA19HS_PID:
	case KEYSPAN_USA49WLC_PID:
		rval = keyspan_send_cmd_usa49(kp);

		break;
	case KEYSPAN_USA49WG_PID:
		rval = keyspan_send_cmd_usa49wg(kp);

		break;
	default:
		USB_DPRINTF_L2(DPRINT_CTLOP, kp->kp_lh,
		    "keyspan_send_cmd: "
		    "the device's product id can't be recognized");
	}

	if (rval != USB_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_send_cmd() FAILED");

			return (rval);
	}

	return (USB_SUCCESS);

}

/*
 * hotplug
 * -------
 *
 * restore device state after CPR resume or reconnect
 */
static int
keyspan_restore_device_state(keyspan_state_t *ksp)
{
	int	state;

	mutex_enter(&ksp->ks_mutex);
	state = ksp->ks_dev_state;
	mutex_exit(&ksp->ks_mutex);

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

		return (state);
	}

	if (usb_check_same_device(ksp->ks_dip, ksp->ks_lh, USB_LOG_L0,
	    DPRINT_MASK_ALL, USB_CHK_ALL, NULL) != USB_SUCCESS) {
		mutex_enter(&ksp->ks_mutex);
		state = ksp->ks_dev_state = USB_DEV_DISCONNECTED;
		mutex_exit(&ksp->ks_mutex);

		return (state);
	}

	if (state == USB_DEV_DISCONNECTED) {
		USB_DPRINTF_L0(DPRINT_HOTPLUG, ksp->ks_lh,
		    "device has been reconnected but data may have been lost");
	}

	if (keyspan_reconnect_pipes(ksp) != USB_SUCCESS) {

		return (state);
	}

	/*
	 * init device state
	 */
	mutex_enter(&ksp->ks_mutex);
	state = ksp->ks_dev_state = USB_DEV_ONLINE;
	ksp->ks_reconnect_flag = 1;
	mutex_exit(&ksp->ks_mutex);

	/*
	 * now restore each open port
	 */
	(void) keyspan_restore_ports_state(ksp);

	return (state);
}

/*
 * restore ports state after CPR resume or reconnect
 */
static int
keyspan_restore_ports_state(keyspan_state_t *ksp)
{
	keyspan_port_t	*kp;
	int		rval = USB_SUCCESS;
	int		err;
	int		i;

	for (i = 0; i < ksp->ks_dev_spec.port_cnt; i++) {
		kp = &ksp->ks_ports[i];
		/*
		 * only care about open ports
		 */
		mutex_enter(&kp->kp_mutex);
		if (kp->kp_state != KEYSPAN_PORT_OPEN) {
			mutex_exit(&kp->kp_mutex);
			continue;
		}
		mutex_exit(&kp->kp_mutex);

		sema_p(&ksp->ks_pipes_sema);
		/* open hardware serial port */
		err = keyspan_open_hw_port(kp, B_FALSE);
		sema_v(&ksp->ks_pipes_sema);
		if (err != USB_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_HOTPLUG, kp->kp_lh,
			    "keyspan_restore_ports_state: failed");
			rval = err;
		}
	}

	return (rval);
}


/*
 * power management
 * ----------------
 *
 *
 * create PM components
 */
static int
keyspan_create_pm_components(keyspan_state_t *ksp)
{
	dev_info_t	*dip = ksp->ks_dip;
	keyspan_pm_t	*pm;
	uint_t		pwr_states;

	pm = ksp->ks_pm = kmem_zalloc(sizeof (keyspan_pm_t), KM_SLEEP);
	pm->pm_cur_power = USB_DEV_OS_FULL_PWR;

	if (usb_create_pm_components(dip, &pwr_states) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_PM, ksp->ks_lh,
		    "keyspan_create_pm_components: failed");

		return (USB_SUCCESS);
	}

	pm->pm_wakeup_enabled = (usb_handle_remote_wakeup(dip,
	    USB_REMOTE_WAKEUP_ENABLE) == USB_SUCCESS);
	pm->pm_pwr_states = (uint8_t)pwr_states;

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

	return (USB_SUCCESS);
}


/*
 * destroy PM components
 */
static void
keyspan_destroy_pm_components(keyspan_state_t *ksp)
{
	keyspan_pm_t	*pm = ksp->ks_pm;
	dev_info_t	*dip = ksp->ks_dip;
	int		rval;

	if (ksp->ks_dev_state != USB_DEV_DISCONNECTED) {
		if (pm->pm_wakeup_enabled) {
			(void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);

			rval = usb_handle_remote_wakeup(dip,
			    USB_REMOTE_WAKEUP_DISABLE);
			if (rval != USB_SUCCESS) {
				USB_DPRINTF_L2(DPRINT_PM, ksp->ks_lh,
				    "keyspan_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 (keyspan_pm_t));
	ksp->ks_pm = NULL;
}


/*
 * mark device busy and raise power
 */
static int
keyspan_pm_set_busy(keyspan_state_t *ksp)
{
	keyspan_pm_t	*pm = ksp->ks_pm;
	dev_info_t	*dip = ksp->ks_dip;

	USB_DPRINTF_L4(DPRINT_PM, ksp->ks_lh, "keyspan_pm_set_busy");

	mutex_enter(&ksp->ks_mutex);
	/* if already marked busy, just increment the counter */
	if (pm->pm_busy_cnt++ > 0) {
		USB_DPRINTF_L3(DPRINT_PM, ksp->ks_lh, "keyspan_pm_set_busy:"
		    "already busy, busy_cnt = %d", pm->pm_busy_cnt);
		mutex_exit(&ksp->ks_mutex);

		return (USB_SUCCESS);
	}

	(void) pm_busy_component(dip, 0);

	if (pm->pm_cur_power == USB_DEV_OS_FULL_PWR) {
		mutex_exit(&ksp->ks_mutex);

		return (USB_SUCCESS);
	}

	/* need to raise power	*/
	pm->pm_raise_power = B_TRUE;
	mutex_exit(&ksp->ks_mutex);

	USB_DPRINTF_L3(DPRINT_PM, ksp->ks_lh,
	    "keyspan_pm_set_busy: raise power");
	(void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);

	mutex_enter(&ksp->ks_mutex);
	pm->pm_raise_power = B_FALSE;
	mutex_exit(&ksp->ks_mutex);

	return (USB_SUCCESS);
}


/*
 * mark device idle
 */
static void
keyspan_pm_set_idle(keyspan_state_t *ksp)
{
	keyspan_pm_t	*pm = ksp->ks_pm;
	dev_info_t	*dip = ksp->ks_dip;

	USB_DPRINTF_L4(DPRINT_PM, ksp->ks_lh, "keyspan_pm_set_idle");

	/*
	 * if more ports use the device, do not mark as yet
	 */
	mutex_enter(&ksp->ks_mutex);
	if (--pm->pm_busy_cnt > 0) {
		mutex_exit(&ksp->ks_mutex);

		return;
	}

	USB_DPRINTF_L4(DPRINT_PM, ksp->ks_lh, "keyspan_pm_set_idle: set idle");
	(void) pm_idle_component(dip, 0);

	mutex_exit(&ksp->ks_mutex);
}


/*
 * Functions to handle power transition for OS levels 0 -> 3
 */
static int
keyspan_pwrlvl0(keyspan_state_t *ksp)
{
	int	rval;
	keyspan_pipe_t *statin = &ksp->ks_statin_pipe;

	USB_DPRINTF_L4(DPRINT_PM, ksp->ks_lh, "keyspan_pwrlvl0");

	switch (ksp->ks_dev_state) {
	case USB_DEV_ONLINE:
		/* issue USB D3 command to the device */
		rval = usb_set_device_pwrlvl3(ksp->ks_dip);
		ASSERT(rval == USB_SUCCESS);

		if (ksp->ks_dev_spec.id_product == KEYSPAN_USA49WG_PID) {
			mutex_exit(&ksp->ks_mutex);
			usb_pipe_stop_intr_polling(statin->pipe_handle,
			    USB_FLAGS_SLEEP);
			mutex_enter(&ksp->ks_mutex);

			mutex_enter(&statin->pipe_mutex);
			statin->pipe_state = KEYSPAN_PIPE_CLOSED;
			mutex_exit(&statin->pipe_mutex);
		}
		ksp->ks_dev_state = USB_DEV_PWRED_DOWN;
		ksp->ks_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, ksp->ks_lh,
		    "keyspan_pwrlvl0: illegal device state");

		return (USB_FAILURE);
	}
}


static int
keyspan_pwrlvl1(keyspan_state_t *ksp)
{
	USB_DPRINTF_L4(DPRINT_PM, ksp->ks_lh, "keyspan_pwrlvl1");

	/* issue USB D2 command to the device */
	(void) usb_set_device_pwrlvl2(ksp->ks_dip);

	return (USB_FAILURE);
}


static int
keyspan_pwrlvl2(keyspan_state_t *ksp)
{
	USB_DPRINTF_L4(DPRINT_PM, ksp->ks_lh, "keyspan_pwrlvl2");

	/* issue USB D1 command to the device */
	(void) usb_set_device_pwrlvl1(ksp->ks_dip);

	return (USB_FAILURE);
}


static int
keyspan_pwrlvl3(keyspan_state_t *ksp)
{
	int	rval;

	USB_DPRINTF_L4(DPRINT_PM, ksp->ks_lh, "keyspan_pwrlvl3");

	switch (ksp->ks_dev_state) {
	case USB_DEV_PWRED_DOWN:
		/* Issue USB D0 command to the device here */
		rval = usb_set_device_pwrlvl0(ksp->ks_dip);
		ASSERT(rval == USB_SUCCESS);

		if (ksp->ks_dev_spec.id_product == KEYSPAN_USA49WG_PID) {
			mutex_exit(&ksp->ks_mutex);
			keyspan_pipe_start_polling(&ksp->ks_statin_pipe);
			mutex_enter(&ksp->ks_mutex);
		}

		ksp->ks_dev_state = USB_DEV_ONLINE;
		ksp->ks_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, ksp->ks_lh,
		    "keyspan_pwrlvl3: illegal device state");

		return (USB_FAILURE);
	}
}


/*
 * pipe operations
 * ---------------
 *
 * XXX keyspan seem to malfunction after the pipes are closed
 * and reopened again (does not respond to OPEN_PORT command).
 * so we open them once in attach
 */
static int
keyspan_attach_pipes(keyspan_state_t *ksp)
{
	return (keyspan_open_dev_pipes(ksp));
}

void
keyspan_detach_pipes(keyspan_state_t *ksp)
{

	/*
	 * Blow away status bulk in requests or
	 * pipe close will wait until timeout.
	 */
	if (ksp->ks_statin_pipe.pipe_handle) {
		usb_pipe_stop_intr_polling(ksp->ks_statin_pipe.pipe_handle,
		    USB_FLAGS_SLEEP);
	}

	/* Close the globle pipes */
	keyspan_close_dev_pipes(ksp);
}


/*
 * during device disconnect/suspend, close pipes if they are open.
 */
static void
keyspan_disconnect_pipes(keyspan_state_t *ksp)
{
	sema_p(&ksp->ks_pipes_sema);
	keyspan_close_pipes(ksp);
	sema_v(&ksp->ks_pipes_sema);
}


/*
 * during device reconnect/resume, reopen pipes if they were open.
 */
static int
keyspan_reconnect_pipes(keyspan_state_t *ksp)
{
	int	rval = USB_SUCCESS;

	sema_p(&ksp->ks_pipes_sema);
	rval = keyspan_reopen_pipes(ksp);
	sema_v(&ksp->ks_pipes_sema);

	return (rval);
}

/*
 * data transfer routines
 * ----------------------
 *
 *
 * start data transmit
 */
void
keyspan_tx_start(keyspan_port_t *kp, int *xferd)
{
	keyspan_state_t	*ksp = kp->kp_ksp;
	int		len;		/* # of bytes we can transmit */
	mblk_t		*data;		/* data to be transmitted */
	int		data_len = 0;	/* # of bytes in 'data' */
	int		tran_len;
	int		rval;
	int		status_len = 0;

	ASSERT(!mutex_owned(&ksp->ks_mutex));
	ASSERT(mutex_owned(&kp->kp_mutex));
	ASSERT(kp->kp_state != KEYSPAN_PORT_CLOSED);

	USB_DPRINTF_L4(DPRINT_OUT_PIPE, kp->kp_lh, "keyspan_tx_start");

	if (xferd) {
		*xferd = 0;
	}
	if ((kp->kp_flags & KEYSPAN_PORT_TX_STOPPED) ||
	    (kp->kp_tx_mp == NULL)) {

		return;
	}

	len = min(msgdsize(kp->kp_tx_mp), kp->kp_write_len);
	USB_DPRINTF_L4(DPRINT_OUT_PIPE, kp->kp_lh, "keyspan_tx_start:"
	    "len = %d, tx_mp_len = %d", len, (int)msgdsize(kp->kp_tx_mp));

	mutex_exit(&kp->kp_mutex);

	/*
	 * Some keyspan adapters, such as usa49wlc,
	 * need use the first byte as flag.
	 */
	switch (ksp->ks_dev_spec.id_product) {
	case KEYSPAN_USA19HS_PID:

		if ((data = allocb(len, BPRI_LO)) == NULL) {
			mutex_enter(&kp->kp_mutex);

			return;
		}
		mutex_enter(&kp->kp_mutex);

		/* copy at most 'len' bytes from mblk chain for transmission */
		data_len = keyspan_tx_copy_data(kp, data, len);
		if (data_len <= 0) {
			USB_DPRINTF_L3(DPRINT_OUT_PIPE, kp->kp_lh,
			    "keyspan_tx_start:keyspan_tx_copy_data copied"
			    " zero bytes");
		}

		break;

	case KEYSPAN_USA49WLC_PID:
	case KEYSPAN_USA49WG_PID:
		status_len = len / 64 + 1;
		if ((data = allocb(len + status_len, BPRI_LO)) == NULL) {
			mutex_enter(&kp->kp_mutex);

			return;
		}
		mutex_enter(&kp->kp_mutex);
		/*
		 * the data format is [status byte][63 data bytes][...][status]
		 * byte][up to 63 bytes] according to keyspan spec
		 */
		while (data_len < len) {
			/* Add status byte per 63 data bytes */
			*(data->b_wptr++) = 0;
			/* copy at most 63 bytes from mblk chain for trans */
			tran_len = keyspan_tx_copy_data(kp, data, 63);
			if (tran_len <= 0) {
				USB_DPRINTF_L3(DPRINT_OUT_PIPE, kp->kp_lh,
				    "keyspan_tx_start:keyspan_tx_copy_data"
				    " copied zero bytes");

				break;
			}
			data_len += tran_len;
		}

		break;
	default:

		mutex_enter(&kp->kp_mutex);
		USB_DPRINTF_L2(DPRINT_OUT_PIPE, ksp->ks_lh, "keyspan_tx_start:"
		    "the device's product id can't be recognized");

		return;
	}

	mutex_exit(&kp->kp_mutex);

	/*
	 * For USA-49WG, the port0 uses intr out pipe as data out pipe, while
	 * other ports use bulk out pipe.
	 */

	if ((kp->kp_port_num == 0) &&
	    (ksp->ks_dev_spec.id_product == KEYSPAN_USA49WG_PID)) {
		rval = keyspan_send_data_port0(&kp->kp_dataout_pipe, &data, kp);
	} else {
		rval = keyspan_send_data(&kp->kp_dataout_pipe, &data, kp);
	}
	mutex_enter(&kp->kp_mutex);

	/*
	 * if send failed, put data back
	 */
	if (rval != USB_SUCCESS) {
		ASSERT(data);
		keyspan_put_head(&kp->kp_tx_mp, data, kp);
	} else if (xferd) {
		*xferd = data_len;
	}

	USB_DPRINTF_L4(DPRINT_OUT_PIPE, kp->kp_lh, "keyspan_tx_start[%d]: over"
	    "(%d) rval=%d", kp->kp_port_num, data_len, rval);

}


/*
 * copy no more than 'len' bytes from mblk chain to transmit mblk 'data'.
 * return number of bytes copied
 */
int
keyspan_tx_copy_data(keyspan_port_t *kp, mblk_t *data, int len)
{
	mblk_t		*mp;	/* current msgblk */
	int		copylen; /* # of bytes to copy from 'mp' to 'data' */
	int		data_len = 0;

	ASSERT(mutex_owned(&kp->kp_mutex));

	if (msgdsize(kp->kp_tx_mp) == 0) {
		data->b_wptr = data->b_rptr;
		freeb(kp->kp_tx_mp);
		kp->kp_tx_mp = NULL;

		return (data_len);
	}

	while ((data_len < len) && kp->kp_tx_mp) {
		mp = kp->kp_tx_mp;
		copylen = min(MBLKL(mp), len - data_len);
		bcopy(mp->b_rptr, data->b_wptr, copylen);

		mp->b_rptr += copylen;
		data->b_wptr += copylen;
		data_len += copylen;

		if (MBLKL(mp) < 1) {
			kp->kp_tx_mp = unlinkb(mp);
			freeb(mp);
		} else {
			ASSERT(data_len == len);
		}
	}
	USB_DPRINTF_L3(DPRINT_OUT_DATA, kp->kp_lh, "keyspan_tx_copy_data:"
	    "copied data_len = %d", data_len);

	return (data_len);
}


/*
 * wait until local tx buffer drains.
 * 'timeout' is in seconds, zero means wait forever
 */
static int
keyspan_wait_tx_drain(keyspan_port_t *kp, int timeout)
{
	clock_t	until;
	int	over = 0;

	USB_DPRINTF_L4(DPRINT_OUT_DATA, kp->kp_lh, "keyspan_wait_tx_drain:"
	    "timeout = %d", timeout);
	until = ddi_get_lbolt() + drv_usectohz(1000000 * timeout);

	while (kp->kp_tx_mp && !over) {
		if (timeout > 0) {
			over = (cv_timedwait_sig(&kp->kp_tx_cv,
			    &kp->kp_mutex, until) <= 0);
		} else {
			over = (cv_wait_sig(&kp->kp_tx_cv, &kp->kp_mutex) == 0);
		}
	}

	return ((kp->kp_tx_mp == NULL) ? USB_SUCCESS : USB_FAILURE);
}

/*
 * returns 0 if device is not online, != 0 otherwise
 */
int
keyspan_dev_is_online(keyspan_state_t *ksp)
{
	int	rval;

	mutex_enter(&ksp->ks_mutex);
	rval = (ksp->ks_dev_state == USB_DEV_ONLINE);
	mutex_exit(&ksp->ks_mutex);

	return (rval);
}

/*
 * link a message block to tail of message
 * account for the case when message is null
 */
void
keyspan_put_tail(mblk_t **mpp, mblk_t *bp)
{
	if (*mpp) {
		linkb(*mpp, bp);
	} else {
		*mpp = bp;
	}
}

/*
 * put a message block at the head of the message
 * account for the case when message is null
 */
void
keyspan_put_head(mblk_t **mpp, mblk_t *bp, keyspan_port_t *kp)
{
	switch (kp->kp_ksp->ks_dev_spec.id_product) {
	case KEYSPAN_USA19HS_PID:
		if (*mpp) {
			linkb(bp, *mpp);
		}
		*mpp = bp;

		break;


	case KEYSPAN_USA49WLC_PID:
	case KEYSPAN_USA49WG_PID:

		/* get rid of the first byte of the msg data which is a flag */
		if (*mpp) {
			linkb(bp, *mpp);
		}
		bp->b_rptr = bp->b_datap->db_base + 1;
		*mpp = bp;

		break;

	default:
		USB_DPRINTF_L2(DPRINT_OUT_DATA, kp->kp_lh, "keyspan_put_head:"
		    "the device's product id can't be recognized");

		return;
	}

}

/*
 * Set the port parameters to default values
 */
static void
keyspan_default_port_params(keyspan_port_t *kp)
{
	keyspan_state_t	*ksp = kp->kp_ksp;

	ASSERT(mutex_owned(&kp->kp_mutex));

	switch (ksp->ks_dev_spec.id_product) {
	case KEYSPAN_USA19HS_PID:
		keyspan_default_port_params_usa19hs(kp);

		break;


	case KEYSPAN_USA49WLC_PID:
	case KEYSPAN_USA49WG_PID:
		keyspan_default_port_params_usa49(kp);

		break;

	default:
		USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
		    "keyspan_default_port_params:"
		    "the device's product id can't be recognized");
	}

	USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
	    "keyspan_default_port_params: setted.");
}

/*
 * Build the command message according to the params from usbser.
 * The message will then be sent to deivce by keyspan_send_cmd.
 */
static void
keyspan_build_cmd_msg(keyspan_port_t *kp, ds_port_params_t *tp)
{
	keyspan_state_t	*ksp = kp->kp_ksp;

	switch (ksp->ks_dev_spec.id_product) {
	case KEYSPAN_USA19HS_PID:
		keyspan_build_cmd_msg_usa19hs(kp, tp);

		break;


	case KEYSPAN_USA49WLC_PID:
	case KEYSPAN_USA49WG_PID:
		keyspan_build_cmd_msg_usa49(kp, tp);

		break;

	default:
		USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
		    "keyspan_build_cmd_msg:"
		    "the device's product id can't be recognized");
	}
}

/* save the port params after send cmd successfully */
static void
keyspan_save_port_params(keyspan_port_t	*kp)
{
	keyspan_state_t	*ksp = kp->kp_ksp;

	ASSERT(mutex_owned(&kp->kp_mutex));

	switch (ksp->ks_dev_spec.id_product) {
	case KEYSPAN_USA19HS_PID:
		keyspan_save_port_params_usa19hs(kp);

		break;


	case KEYSPAN_USA49WLC_PID:
	case KEYSPAN_USA49WG_PID:
		keyspan_save_port_params_usa49(kp);

		break;

	default:
		USB_DPRINTF_L2(DPRINT_ATTACH, ksp->ks_lh,
		    "keyspan_save_port_params:"
		    "the device's product id can't be recognized");
	}

	USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
	    "keyspan_save_port_params: baud = %x, lcr = %x,"
	    "status_flag = %x", kp->kp_baud, kp->kp_lcr, kp->kp_status_flag);

}

/* save the port params after send cmd successfully */
static void
keyspan_save_port_params_usa19hs(keyspan_port_t	*kp)
{
	keyspan_usa19hs_port_ctrl_msg_t	*ctrl_msg = &(kp->kp_ctrl_msg.usa19hs);

	ASSERT(mutex_owned(&kp->kp_mutex));

	if (ctrl_msg->setClocking) {
		kp->kp_baud = ctrl_msg->baudHi;
		kp->kp_baud = (kp->kp_baud << 8);
		kp->kp_baud |= ctrl_msg->baudLo;
	}
	if (ctrl_msg->setLcr) {
		kp->kp_lcr = ctrl_msg->lcr;
	}
	if (ctrl_msg->setRts) {
		if (ctrl_msg->rts) {
			kp->kp_status_flag |= KEYSPAN_PORT_RTS;
		} else {
			kp->kp_status_flag &= ~KEYSPAN_PORT_RTS;
		}
	}
	if (ctrl_msg->setDtr) {
		if (ctrl_msg->dtr) {
			kp->kp_status_flag |= KEYSPAN_PORT_DTR;
		} else {
			kp->kp_status_flag &= ~KEYSPAN_PORT_DTR;
		}
	}

	if (ctrl_msg->portEnabled) {
		kp->kp_status_flag |= KEYSPAN_PORT_ENABLE;
	} else {
		kp->kp_status_flag &= ~KEYSPAN_PORT_ENABLE;
	}

	USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
	    "keyspan_save_port_params: baud = %x, lcr = %x,"
	    "status_flag = %x", kp->kp_baud, kp->kp_lcr, kp->kp_status_flag);

}

/*
 * Set the port parameters to default values
 */
static void
keyspan_default_port_params_usa19hs(keyspan_port_t *kp)
{
	keyspan_usa19hs_port_ctrl_msg_t	*ctrl_msg = &(kp->kp_ctrl_msg.usa19hs);
	ASSERT(mutex_owned(&kp->kp_mutex));

	keyspan_build_cmd_msg(kp, NULL);

	ctrl_msg->setRts = 0x01;
	ctrl_msg->rts = 0x1;
	ctrl_msg->setDtr = 0x01;
	ctrl_msg->dtr = 0x1;

	ctrl_msg->setClocking = 1;
	ctrl_msg->setRxMode = 1;
	ctrl_msg->setTxMode = 1;

	/* set baud rate to 9600 */
	ctrl_msg->baudLo = keyspan_speedtab_usa19hs[13] & 0xff;
	ctrl_msg->baudHi = (keyspan_speedtab_usa19hs[13] >> 8) & 0xff;
	ctrl_msg->rxMode = RXMODE_BYHAND;
	ctrl_msg->txMode = TXMODE_BYHAND;

	ctrl_msg->lcr = 0x3;
	ctrl_msg->setLcr = 0x1;

	ctrl_msg->xonChar = CSTART;
	ctrl_msg->xoffChar = CSTOP;
	ctrl_msg->setTxFlowControl = 1;
	ctrl_msg->txFlowControl = TXFLOW_CTS;
	ctrl_msg->setRxFlowControl = 1;
	ctrl_msg->rxFlowControl = RXFLOW_RTS;
	ctrl_msg->rxFlush = 0;

}

/*
 * Build the command message according to the params from usbser.
 * The message will then be sent to deivce by keyspan_send_cmd.
 */
static void
keyspan_build_cmd_msg_usa19hs(keyspan_port_t *kp, ds_port_params_t *tp)
{
	int		cnt, i;
	uint_t		ui;
	ds_port_param_entry_t *pe;
	keyspan_usa19hs_port_ctrl_msg_t	*ctrl_msg = &(kp->kp_ctrl_msg.usa19hs);

	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh,
	    "keyspan_build_cmd_msg_usa19hs: tp = %p", (void *)tp);

	ASSERT(mutex_owned(&kp->kp_mutex));
	ASSERT(kp->kp_state == KEYSPAN_PORT_OPEN ||
	    kp->kp_state == KEYSPAN_PORT_OPENING);

	/* bzero all elements */
	bzero(ctrl_msg, sizeof (keyspan_usa19hs_port_ctrl_msg_t));

	/* it is usaually 16, according to Keyspan spec */
	ctrl_msg->rxForwardingLength = 16;
	/* from 1ms to 31ms, according to Keyspan spec. */
	ctrl_msg->rxForwardingTimeout = 16;

	ctrl_msg->portEnabled = 1;
	ctrl_msg->returnStatus = 1;

	if (tp == NULL) {

		return;
	}

	cnt = tp->tp_cnt;
	pe = tp->tp_entries;

	/* translate tp parameters into cmd_msg elements */
	for (i = 0; i < cnt; i++, pe++) {
		switch (pe->param) {
		case DS_PARAM_BAUD:
			ui = pe->val.ui;

			/*
			 * if we don't support this speed,
			 * then return failure.
			 */
			if ((ui >= NELEM(keyspan_speedtab_usa19hs)) ||
			    ((ui > 0) && (keyspan_speedtab_usa19hs[ui] == 0))) {

				USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
				    "keyspan_build_cmd_msg_usa19hs:"
				    " bad baud %d", ui);

				break;
			}

			/* if the same as the old rate, need not set the rate */
			if (kp->kp_baud == keyspan_speedtab_usa19hs[ui]) {

				USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
				    "keyspan_build_cmd_msg_usa19hs:"
				    " same as old baud setting, baud = %d",
				    keyspan_speed2baud[ui]);

				break;
			}
			ctrl_msg->setClocking = 1; /* enable the setting */
			ctrl_msg->setRxMode = 1;
			ctrl_msg->setTxMode = 1;

			ctrl_msg->baudLo = keyspan_speedtab_usa19hs[ui] & 0xff;
			ctrl_msg->baudHi = (keyspan_speedtab_usa19hs[ui] >> 8)
			    & 0xff;

			ctrl_msg->rxMode = RXMODE_BYHAND;
			ctrl_msg->txMode = TXMODE_BYHAND;

			USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa19hs: baud=%d",
			    keyspan_speed2baud[ui]);

			break;
		case DS_PARAM_PARITY:
			if (pe->val.ui & PARENB) {

				/*
				 * Since USA_PARITY_NONE == 0, it's not
				 * necessary to or it in here.
				 */
				if (pe->val.ui & PARODD) {
					ctrl_msg->lcr |= USA_PARITY_ODD;
				} else {
					ctrl_msg->lcr |= USA_PARITY_EVEN;
				}
			}
			USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa19hs: parity=%x,lcr = %x",
			    pe->val.ui, ctrl_msg->lcr);

			break;
		case DS_PARAM_STOPB:
			if (pe->val.ui & CSTOPB) {
				ctrl_msg->lcr |= STOPBITS_678_2;
			} else {

				/*
				 * STOPBITS_5678_1 equals zero,
				 * so it's not necessary to or it in.
				 */
				USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
				    "keyspan_build_cmd_msg_usa19hs:"
				    " STOPBITS_5678_1");
			}

			USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa19hs: stopb=%x, lcr = %x",
			    pe->val.ui, ctrl_msg->lcr);

			break;
		case DS_PARAM_CHARSZ:
			switch (pe->val.ui) {
			case CS5:

				/*
				 * USA_DATABITS_5 equals zero,
				 * not necessary to or it in.
				 */
				USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
				    "keyspan_build_cmd_msg_usa19hs:"
				    " USA_DATABITS_5");

				break;
			case CS6:
				ctrl_msg->lcr |= USA_DATABITS_6;

				break;
			case CS7:
				ctrl_msg->lcr |= USA_DATABITS_7;

				break;
			case CS8:
			default:
				/*
				 * The default value is USA_DATABITS_8. It is
				 * safe to set to the default one here.
				 */
				ctrl_msg->lcr |= USA_DATABITS_8;

				break;
			}

			USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa19hs: cs=%x, lcr = %x",
			    pe->val.ui, ctrl_msg->lcr);

			break;
		case DS_PARAM_XON_XOFF:
			ctrl_msg->xonChar = pe->val.uc[0]; /* init to CSTART */
			ctrl_msg->xoffChar = pe->val.uc[1]; /* init to CSTOP */

			USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa19hs: xonChar=%x, "
			    "xoffChar = %x", ctrl_msg->xonChar,
			    ctrl_msg->xoffChar);

			break;
		case DS_PARAM_FLOW_CTL:
			if (pe->val.ui & CTSXON) {
				ctrl_msg->txFlowControl = TXFLOW_CTS;
				ctrl_msg->setTxFlowControl = 1;
			} else {
				/* Clear the tx flow control setting */
				ctrl_msg->txFlowControl = 0;
				ctrl_msg->setTxFlowControl = 1;
			}
			if (pe->val.ui & RTSXOFF) {
				ctrl_msg->rxFlowControl = RXFLOW_RTS;
				ctrl_msg->setRxFlowControl = 1;
			} else {
				/* Clear the rx flow control setting */
				ctrl_msg->rxFlowControl = 0;
				ctrl_msg->setRxFlowControl = 1;
			}

			USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa19hs: txFlowControl = %x,"
			    "rxFlowControl = %x", ctrl_msg->txFlowControl,
			    ctrl_msg->rxFlowControl);

			break;
		default:
			USB_DPRINTF_L2(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa19hs: bad param %d",
			    pe->param);

			break;
		}

	}

	/*
	 * Enable the lcr settings only if they are different
	 * with the existing settings.
	 */
	ctrl_msg->setLcr =  (ctrl_msg->lcr == kp->kp_lcr) ? 0 : 1;

}


/*
 * Build the command message according to the params from usbser.
 * The message will then be sent to deivce by keyspan_send_cmd.
 */
static void
keyspan_build_cmd_msg_usa49(keyspan_port_t *kp, ds_port_params_t *tp)
{
	int		cnt, i;
	uint_t		ui;
	ds_port_param_entry_t *pe;
	keyspan_usa49_port_ctrl_msg_t	*ctrl_msg = &(kp->kp_ctrl_msg.usa49);

	USB_DPRINTF_L4(DPRINT_CTLOP, kp->kp_lh,
	    "keyspan_build_cmd_msg_usa49: tp = %p", (void *)tp);

	ASSERT(mutex_owned(&kp->kp_mutex));
	ASSERT(kp->kp_state == KEYSPAN_PORT_OPEN ||
	    kp->kp_state == KEYSPAN_PORT_OPENING);

	/* bzero all elements */
	bzero(ctrl_msg, sizeof (keyspan_usa49_port_ctrl_msg_t));

	ctrl_msg->portNumber = kp->kp_port_num;

	/* it is usaually 16, according to Keyspan spec */
	ctrl_msg->forwardingLength = 16;

	ctrl_msg->enablePort = 1;
	ctrl_msg->returnStatus = 1;

	if (tp == NULL) {

		return;
	}

	cnt = tp->tp_cnt;
	pe = tp->tp_entries;

	/* translate tp parameters into cmd_msg elements */
	for (i = 0; i < cnt; i++, pe++) {
		switch (pe->param) {
		case DS_PARAM_BAUD:
			ui = pe->val.ui;

			/*
			 * If we don't support this speed,
			 * then return failure.
			 */
			if ((ui >= NELEM(keyspan_speedtab_usa49)) ||
			    ((ui > 0) && (keyspan_speedtab_usa49[ui] == 0))) {

				USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
				    "keyspan_build_cmd_msg_usa49:"
				    " bad baud %d", ui);

				break;
			}

			/* if the same as the old rate, need not set the rate */
			if (kp->kp_baud == keyspan_speedtab_usa49[ui]) {

				USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
				    "keyspan_build_cmd_msg_usa49: "
				    "same as old baud setting, baud = %d",
				    keyspan_speed2baud[ui]);

				break;
			}
			ctrl_msg->setClocking = 0xff; /* enable the setting */
			ctrl_msg->baudLo = keyspan_speedtab_usa49[ui] & 0xff;
			ctrl_msg->baudHi = (keyspan_speedtab_usa49[ui] >> 8)
			    & 0xff;
			ctrl_msg->prescaler = keyspan_prescaler_49wlc[ui];

			USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa49: baud=%d",
			    keyspan_speed2baud[ui]);

			break;
		case DS_PARAM_PARITY:
			if (pe->val.ui & PARENB) {

				/*
				 * Since USA_PARITY_NONE == 0,
				 * it's not necessary to or it in here.
				 */
				if (pe->val.ui & PARODD) {
					ctrl_msg->lcr |= USA_PARITY_ODD;
				} else {
					ctrl_msg->lcr |= USA_PARITY_EVEN;
				}
			}
			USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa49: parity=%x, lcr = %x",
			    pe->val.ui, ctrl_msg->lcr);

			break;
		case DS_PARAM_STOPB:
			if (pe->val.ui & CSTOPB) {
				ctrl_msg->lcr |= STOPBITS_678_2;
			} else {

				/*
				 * STOPBITS_5678_1 equals zero,
				 * not necessary to or it in.
				 */
				USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
				    "keyspan_build_cmd_msg_usa49: "
				    "STOPBITS_5678_1");
			}

			USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa49: stopb=%x, lcr = %x",
			    pe->val.ui, ctrl_msg->lcr);

			break;
		case DS_PARAM_CHARSZ:
			switch (pe->val.ui) {
			case CS5:

				/*
				 * USA_DATABITS_5 equals zero,
				 * not necessary to or it in.
				 */
				USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
				    "keyspan_build_cmd_msg_usa49:"
				    " USA_DATABITS_5");

				break;
			case CS6:
				ctrl_msg->lcr |= USA_DATABITS_6;

				break;
			case CS7:
				ctrl_msg->lcr |= USA_DATABITS_7;

				break;
			case CS8:
			default:
				ctrl_msg->lcr |= USA_DATABITS_8;

				break;
			}

			USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa49: cs=%x, lcr = %x",
			    pe->val.ui, ctrl_msg->lcr);

			break;
		case DS_PARAM_XON_XOFF:
			ctrl_msg->xonChar = pe->val.uc[0]; /* init to CSTART */
			ctrl_msg->xoffChar = pe->val.uc[1]; /* init to CSTOP */

			USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa49: xonChar=%x, "
			    "xoffChar = %x", ctrl_msg->xonChar,
			    ctrl_msg->xoffChar);

			break;
		case DS_PARAM_FLOW_CTL:
			if (pe->val.ui & CTSXON) {
				ctrl_msg->ctsFlowControl = 1;
				ctrl_msg->setFlowControl = 1;
			} else {
				ctrl_msg->ctsFlowControl = 0;
				ctrl_msg->setFlowControl = 1;
			}
			if (pe->val.ui & RTSXOFF) {
				USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
				    "keyspan_build_cmd_msg_usa49: "
				    "pe->val.ui = %x, flow_ctl: RTSXOFF, "
				    "no hardware support", pe->val.ui);
			}

			USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa49: ctsFlowControl = %x,"
			    "dsrFlowControl = %x", ctrl_msg->ctsFlowControl,
			    ctrl_msg->dsrFlowControl);

			break;
		default:
			USB_DPRINTF_L2(DPRINT_CTLOP, kp->kp_lh,
			    "keyspan_build_cmd_msg_usa49: bad param %d",
			    pe->param);

			break;
		}
	}

	/*
	 * enable the lcr settings only if they are different
	 * with the existing settings.
	 */
	ctrl_msg->setLcr =  (ctrl_msg->lcr == kp->kp_lcr) ? 0 : 1;

}


/*
 * Set the port parameters to default values
 */
static void
keyspan_default_port_params_usa49(keyspan_port_t *kp)
{
	keyspan_usa49_port_ctrl_msg_t	*ctrl_msg = &(kp->kp_ctrl_msg.usa49);
	ASSERT(mutex_owned(&kp->kp_mutex));

	keyspan_build_cmd_msg(kp, NULL);

	ctrl_msg->setRts = 1;
	ctrl_msg->rts = 1;
	ctrl_msg->setDtr = 1;
	ctrl_msg->dtr = 1;

	ctrl_msg->_txOn = 1;
	ctrl_msg->_txOff = 0;
	ctrl_msg->txFlush = 0;
	ctrl_msg->txBreak = 0;
	ctrl_msg->rxOn = 1;
	ctrl_msg->rxOff = 0;
	ctrl_msg->rxFlush = 0;
	ctrl_msg->rxForward = 0;
	ctrl_msg->returnStatus = 1;
	ctrl_msg->resetDataToggle = 0;
	ctrl_msg->enablePort = 1;
	ctrl_msg->disablePort = 0;

	/* set baud rate to 9600 */
	ctrl_msg->setClocking = 1;
	ctrl_msg->baudLo = keyspan_speedtab_usa49[13] & 0xff;
	ctrl_msg->baudHi = (keyspan_speedtab_usa49[13] >> 8) & 0xff;
	ctrl_msg->prescaler = keyspan_prescaler_49wlc[13];

	ctrl_msg->lcr = 0x3;
	ctrl_msg->setLcr = 1;

	ctrl_msg->xonChar = CSTART;
	ctrl_msg->xoffChar = CSTOP;
	ctrl_msg->ctsFlowControl = 1;
	ctrl_msg->setFlowControl = 1;

}


/* save the port params after send cmd successfully */
static void
keyspan_save_port_params_usa49(keyspan_port_t	*kp)
{
	keyspan_usa49_port_ctrl_msg_t	*ctrl_msg = &(kp->kp_ctrl_msg.usa49);

	ASSERT(mutex_owned(&kp->kp_mutex));

	if (ctrl_msg->setClocking) {
		kp->kp_baud = ctrl_msg->baudHi;
		kp->kp_baud = (kp->kp_baud << 8);
		kp->kp_baud |= ctrl_msg->baudLo;
	}
	if (ctrl_msg->setLcr) {
		kp->kp_lcr = ctrl_msg->lcr;
	}
	if (ctrl_msg->setRts) {
		if (ctrl_msg->rts) {
			kp->kp_status_flag |= KEYSPAN_PORT_RTS;
		} else {
			kp->kp_status_flag &= ~KEYSPAN_PORT_RTS;
		}
	}
	if (ctrl_msg->setDtr) {
		if (ctrl_msg->dtr) {
			kp->kp_status_flag |= KEYSPAN_PORT_DTR;
		} else {
			kp->kp_status_flag &= ~KEYSPAN_PORT_DTR;
		}
	}

	if (ctrl_msg->enablePort) {
		kp->kp_status_flag |= KEYSPAN_PORT_ENABLE;
	} else {
		kp->kp_status_flag &= ~KEYSPAN_PORT_ENABLE;
	}

	/*
	 * There are no flags in status msg (49wlc) can indicate the
	 * break status, so we make use of ctrl_msg->txBreak here.
	 */
	if (ctrl_msg->txBreak) {
		kp->kp_status_flag |= KEYSPAN_PORT_TXBREAK;
	} else {
		kp->kp_status_flag &= ~KEYSPAN_PORT_TXBREAK;
	}

	USB_DPRINTF_L3(DPRINT_CTLOP, kp->kp_lh,
	    "keyspan_save_port_params: baud = %x, lcr = %x,"
	    "status_flag = %x", kp->kp_baud, kp->kp_lcr, kp->kp_status_flag);

}