sun4u/io/rmc_comm_dp.c

/*
 * 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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * implementation of the transport layer protocol (known as librsc protocol):
 *
 */

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

/*
 *  Header files
 */

#include <sys/conf.h>
#include <sys/cyclic.h>
#include <sys/membar.h>
#include <sys/modctl.h>
#include <sys/strlog.h>
#include <sys/sunddi.h>
#include <sys/ddi.h>
#include <sys/types.h>
#include <sys/rmc_comm_dp.h>
#include <sys/rmc_comm_dp_boot.h>
#include <sys/rmc_comm_drvintf.h>
#include <sys/rmc_comm.h>

#ifdef DEBUG_ERROR_INJECTION

#define	ERRI_RX_SEQ_NUMBER	1
#define	ERRI_ACK_MSG		2
#define	ERRI_CRC_HEADER		3
#define	ERRI_CRC_MSG		4
#define	ERRI_SEND_CTL_STACK	5
#define	ERRI_SEND_CTL_START	6

#define	ERRI_CTL_RX_SEQ_NUMBER	7
#define	ERRI_CTL_CRC_HEADER	8

int	erri_test_number = 0;
int	erri_test_intrvl = 0;
int	erri_test_repeat = 0;
int	erri_test_count = 0;

int erri_test_simulate_srec_sec(struct rmc_comm_state *, char *, int);

#endif


/* static functions */

static void dp_link_setup_tohandler(void *);
static void dp_delay_ack_tohandler(void *);
static uint8_t *dp_get_buffer(struct rmc_comm_state *, uint8_t);
static void dp_release_buffer(struct rmc_comm_state *, uint8_t);
static void dp_init_buffers(struct rmc_comm_state *);
static void dp_got_full_hdr(struct rmc_comm_state *, dp_packet_t *);
static void dp_got_bp_msg(struct rmc_comm_state *, dp_packet_t *);
static void dp_got_full_msg(struct rmc_comm_state *, dp_packet_t *);
static void dp_tx_handle_ack(struct rmc_comm_state *, uint16_t);
static void dp_tx_handle_nak(struct rmc_comm_state *, uint16_t);
static void dp_send_packet(struct rmc_comm_state *, uchar_t *);
static void dp_enable_data_link(struct rmc_comm_state *);
static int dp_get_msglen(struct rmc_comm_state *, uint8_t *);
static uint16_t dp_calc_crc16(uint8_t *, int);
void dp_wake_up_waiter(struct rmc_comm_state *, uint8_t);
void dp_reset(struct rmc_comm_state *, uint8_t, boolean_t, boolean_t);

/*
 * utilities...
 */

/*
 *  init rx/tx buffer pool
 */
static void
dp_init_buffers(struct rmc_comm_state *rcs)
{
	int i;
	dp_buffer_t *dbuf = rcs->dp_state.dp_buffers;

	for (i = 0; i < DP_BUFFER_COUNT; i++)
		dbuf[i].in_use = 0;
}

/*
 *  get tx/rx buffer
 */
static uint8_t *
dp_get_buffer(struct rmc_comm_state *rcs, uint8_t type)
{
	dp_buffer_t *dbuf = rcs->dp_state.dp_buffers;

	ASSERT(MUTEX_HELD(rcs->dp_state.dp_mutex));

	if ((type != DP_TX_BUFFER && type != DP_RX_BUFFER) ||
		dbuf[type].in_use) {

		DPRINTF(rcs, DMEM,
			(CE_CONT, "get buffer err. type=%d, in_use=%d\n",
			type, dbuf[type].in_use));

		return (NULL);
	}

	DPRINTF(rcs, DMEM, (CE_CONT, "get buffer type=%d\n", type));

	dbuf[type].in_use = 1;

	return (dbuf[type].buf);
}

/*
 * release tx/rx buffer
 */
static void
dp_release_buffer(struct rmc_comm_state *rcs, uint8_t type)
{
	dp_buffer_t *dbuf = rcs->dp_state.dp_buffers;

	ASSERT(MUTEX_HELD(rcs->dp_state.dp_mutex));

	if (type != DP_TX_BUFFER && type != DP_RX_BUFFER) {
		DPRINTF(rcs, DMEM,
			(CE_CONT, "free buffer err. type=%d, in_use=%d\n",
			type, dbuf[type].in_use));
		return;
	}
	DPRINTF(rcs, DMEM, (CE_CONT, "free buffer type=%d\n", type));

	dbuf[type].in_use = 0;
}

/*
 * setup data link timeout handler
 * (called without having the dp_mutex)
 */
static void
dp_link_setup_tohandler(void *arg)
{
	struct rmc_comm_state *rcs = (struct rmc_comm_state *)arg;
	rmc_comm_dp_state_t *dps = &rcs->dp_state;

	DPRINTF(rcs, DPRO, (CE_CONT, "t/o setup data link\n"));

	/*
	 * check if timer has actually been cancelled
	 */
	mutex_enter(dps->dp_mutex);
	if (dps->timer_link_setup != (timeout_id_t)0) {

		/*
		 * send CTL:start to the remote side to set up the data link
		 */
		(void) rmc_comm_dp_ctlsend(rcs, DP_CTL_START);

		dps->timer_link_setup = timeout(dp_link_setup_tohandler,
		    (void *) rcs, drv_usectohz(RETRY_DP_SETUP * 1000));
	}
	mutex_exit(dps->dp_mutex);
}

/*
 * delay acknowledgment of a received message timeout handler
 * (called without having the dp_mutex)
 */
static void
dp_delay_ack_tohandler(void *arg)
{
	struct rmc_comm_state *rcs = (struct rmc_comm_state *)arg;
	rmc_comm_dp_state_t *dps = &rcs->dp_state;

#ifdef DEBUG_ERROR_INJECTION

	if (erri_test_number == ERRI_ACK_MSG &&
	    erri_test_repeat >= 0 &&
	    erri_test_count++ > 0 && !(erri_test_count % erri_test_intrvl)) {

		/*
		 * DON'T ACK THE MESSAGE - BE SILENT!
		 */

		if (erri_test_repeat == 0)
			erri_test_repeat--; /* will not repeat the test */

		dps->timer_delay_ack = (timeout_id_t)0;
		return;
	}

#endif

	/*
	 * check if timer has actually been cancelled
	 */
	mutex_enter(dps->dp_mutex);
	if (dps->timer_delay_ack != (timeout_id_t)0) {
		/*
		 * ACK the message
		 */
		(void) rmc_comm_dp_ctlsend(rcs, DP_CTL_ACK);
		dps->timer_delay_ack = (timeout_id_t)0;
	}
	mutex_exit(dps->dp_mutex);
}

/*
 * Enable data link protocol:
 *  stop data link setup timer
 *  set data_link_ok flag
 * (must already have the dp_mutex)
 */
static void
dp_enable_data_link(struct rmc_comm_state *rcs)
{
	rmc_comm_dp_state_t	*dps = &rcs->dp_state;
	timeout_id_t		 timer_id;

	ASSERT(MUTEX_HELD(dps->dp_mutex));

	dps->data_link_ok = 1;

	timer_id = dps->timer_link_setup;
	dps->timer_link_setup = (timeout_id_t)0;
	if (timer_id != (timeout_id_t)0) {

		mutex_exit(dps->dp_mutex);
		(void) untimeout(timer_id);
		mutex_enter(dps->dp_mutex);
	}
}

/*
 * CRC calculation routine.
 */
static uint16_t
dp_calc_crc16(uint8_t *buf, int len)
{
	extern uint16_t crctab16[];
	uint16_t crc;

	crc = 0;
	while (len--) {
		crc = (crc >> 8) ^ crctab16[(crc ^ *buf++) & 0xFF];
	}
	return (crc);
}

/*
 * Reset the data protocol
 * (dp_mutex must be held)
 */
void
dp_reset(struct rmc_comm_state *rcs, uint8_t rx_seqid,
    boolean_t flush_tx, boolean_t restart_data_link)
{
	rmc_comm_dp_state_t *dps = &rcs->dp_state;

	ASSERT(MUTEX_HELD(dps->dp_mutex));

	DPRINTF(rcs, DPRO, (CE_CONT,
	    "reset proto: rxsid=%d, flushtx=%d, restartdp=%d\n",
	    rx_seqid, flush_tx, restart_data_link));

	DPRINTF(rcs, DGEN, (CE_CONT,
	    "stats: reset=%d nak=%d start=%d stack=%d retries=%d crcerr=%d\n",
	    dps->reset_cnt, dps->nak_cnt, dps->start_cnt, dps->stack_cnt,
	    dps->retries_cnt, dps->crcerr_cnt));

	dps->last_rx_seqid = rx_seqid;
	dps->reset_cnt++;

	/*
	 * Flush pending tx message.
	 */
	if (flush_tx) {
		dps->last_tx_seqid = INITIAL_SEQID;
		dps->last_rx_ack = rx_seqid;

		/*
		 * if there is any pending request/response session
		 * then just abort it.
		 */
		dp_wake_up_waiter(rcs, MSG_ERROR);
	}

	/*
	 * restart data link, but only if the data link set up timer is
	 * not already running.
	 */
	if (restart_data_link && dps->timer_link_setup == (timeout_id_t)0) {

		dps->data_link_ok = 0;

		/*
		 * set up the data protocol link
		 */
		(void) rmc_comm_dp_ctlsend(rcs, DP_CTL_START);
		dps->timer_link_setup = timeout(dp_link_setup_tohandler,
		    (void *)rcs, drv_usectohz(RETRY_DP_SETUP * 1000));
	}
}

/*
 * Handles acknowledgment of a message previously sent OR a heartbeat command
 * (CTL_RESPOND).
 */
static void
dp_tx_handle_ack(struct rmc_comm_state *rcs, uint16_t rxnum)
{
	rmc_comm_dp_state_t	*dps = &rcs->dp_state;
	dp_req_resp_t		*drr = &dps->req_resp;

	ASSERT(MUTEX_HELD(dps->dp_mutex));

	DPRINTF(rcs, DPRO, (CE_CONT, "handle ACK, rxnum=%03d\n", rxnum));

	dps->last_rx_ack = rxnum;
	if ((drr->flags & MSG_SENT) == 0) {
		/*
		 * no pending messages, so nothing to do
		 */
		return;
	}

	if (rxnum == dps->last_tx_seqid) {
		/*
		 * message was sent and acknowledged successfully
		 * set flag and signal the waiting task if it is not
		 * expecting a reply back
		 */
		drr->flags |= MSG_ACKED;
		if (drr->response.msg_type == DP_NULL_MSG) {
			dp_wake_up_waiter(rcs, MSG_ACKED);
		}
	}
}

/*
 * Handles NAK
 */
static void
dp_tx_handle_nak(struct rmc_comm_state *rcs, uint16_t rxnum)
{
	rmc_comm_dp_state_t	*dps = &rcs->dp_state;
	dp_req_resp_t		*drr = &dps->req_resp;

	ASSERT(MUTEX_HELD(dps->dp_mutex));

	DPRINTF(rcs, DPRO, (CE_CONT, "handle NAK, rxnum=%03d\n", rxnum));

	if ((drr->flags & MSG_SENT) == 0) {
		/*
		 * no pending messages, so nothing to do
		 */
		return;
	}

	/*
	 * since one message per time can be sent, it is assumed that the
	 * message being NAKed is just the one that has been sent.
	 */
	dps->nak_cnt++;

	dp_wake_up_waiter(rcs, MSG_NAKED);
}

/*
 * Got a full header. Check header CRC and get the length of the packet
 */
static void
dp_got_full_hdr(struct rmc_comm_state *rcs, dp_packet_t *pkt)
{
	/*
	 * Got the full header.  Call up to the logical layer to see
	 * how big of a buffer I need for this message.  If the size
	 * is < sizeof (dp_msg_t), then there is something wrong with
	 * this message - drop it.  If the size is equal, then hand it
	 * up right now. If the size is too big - drop it. otherwise we must
	 * receive the body of the message.
	 */

	pkt->full_length = dp_get_msglen(rcs, pkt->buf);

	DPRINTF(rcs, DPKT, (CE_CONT, "got header msglen=%d\n",
	    pkt->full_length));

	if ((pkt->full_length < 0) ||
	    (pkt->full_length < sizeof (dp_header_t)) ||
	    (pkt->full_length > DP_BUFFER_SIZE)) {
		/*
		 * not a valid message: either message too big or too small
		 */
		dp_release_buffer(rcs, DP_RX_BUFFER);
		pkt->buf = NULL;

		pkt->rx_state = WAITING_FOR_SYNC;

	} else if (pkt->full_length == sizeof (dp_header_t)) {
		/*
		 * process message: it is basically a control message
		 * (no data being carried)
		 */
		rmc_comm_dp_mrecv(rcs, pkt->buf);

		dp_release_buffer(rcs, DP_RX_BUFFER);
		pkt->buf = NULL;

		pkt->rx_state = WAITING_FOR_SYNC;
	} else {
		pkt->rx_state = RECEIVING_BODY;
	}
}

/*
 * Got a BP (boot prom) message. Usually, BP messages are received when
 * the firmware goes into boot monitor mode (where only BP protocol is used).
 * This just happens during firmware download. There should not be any other
 * case where a BP message is received.
 */
static void
dp_got_bp_msg(struct rmc_comm_state *rcs, dp_packet_t *pkt)
{
	bp_msg_t		*msgp = (bp_msg_t *)pkt->buf;
	rmc_comm_dp_state_t	*dps = &rcs->dp_state;
	dp_req_resp_t		*drr = &dps->req_resp;
	int			datalen = sizeof (bp_msg_t);

	ASSERT(MUTEX_HELD(dps->dp_mutex));

	/*
	 * ignore BP message, if it is not expected
	 */
	if ((drr->flags & MSG_SENT_BP) != 0) {

		DPRINTF(rcs, DPRO, (CE_CONT, "got bp msg: %02x %02x %02x\n",
		    msgp->cmd, msgp->dat1, msgp->dat2));

		/*
		 * A boot prom (BP) msg has been sent. Here is the
		 * 'expected' reply
		 */

		/*
		 * check that the recv buffer is big enough (just in case).
		 */
		if (datalen <= drr->response.msg_bufsiz) {
			bcopy(pkt->buf, drr->response.msg_buf, datalen);
			drr->response.msg_msglen = datalen;
			dp_wake_up_waiter(rcs, MSG_RXED_BP);
		} else {
			drr->response.msg_msglen = -1;
			dp_wake_up_waiter(rcs, MSG_RXED_BP);
		}
	}

	/* Return the buffer to the pool and wait for the next msg. */
	dp_release_buffer(rcs, DP_RX_BUFFER);
	pkt->buf = NULL;
	pkt->rx_state = WAITING_FOR_SYNC;
}

/*
 * Got a complete message, check CRC and pass it on to the upper layer (message
 * processing)
 */
static void
dp_got_full_msg(struct rmc_comm_state *rcs, dp_packet_t *pkt)
{
	uint16_t	 crc;
	int		 msglen;

	DPRINTF(rcs, DPKT, (CE_CONT, "got full msg\n"));

	/*
	 * check message CRC
	 */

	msglen = pkt->full_length - sizeof (dp_header_t) - sizeof (crc);

	bcopy(pkt->buf + (pkt->full_length - sizeof (crc)), &crc, sizeof (crc));

	if (crc == dp_calc_crc16(pkt->buf + sizeof (dp_header_t), msglen)) {
		/*
		 * CRC is ok, process this message
		 */
		DPRINTF(rcs, DPKT, (CE_CONT, "got 'good' msg\n"));

		rmc_comm_dp_mrecv(rcs, pkt->buf);
	} else {
		DPRINTF(rcs, DPKT, (CE_CONT, "CRC error (msg)\n"));
		rcs->dp_state.crcerr_cnt++;
	}

	dp_release_buffer(rcs, DP_RX_BUFFER);
	pkt->buf = NULL;

	pkt->rx_state = WAITING_FOR_SYNC;
}

/*
 * Check the checksum of the header & return the length field.  If the
 * checksum check fails, then return -1.
 */
static int
dp_get_msglen(struct rmc_comm_state *rcs, uint8_t *buf)
{
	dp_header_t 	*dp_msgp;
	uint16_t	 crc;

	dp_msgp = (dp_header_t *)buf;

	crc = dp_calc_crc16(buf + sizeof (dp_msgp->pad), sizeof (dp_header_t) -
	    sizeof (dp_msgp->crc) - sizeof (dp_msgp->pad));

	if (dp_msgp->crc == crc) {
		return (dp_msgp->length + sizeof (dp_msgp->pad));
	} else {
		DPRINTF(rcs, DPKT, (CE_CONT, "CRC error (header)\n"));
		rcs->dp_state.crcerr_cnt++;
		return (-1);
	}
}

/*
 * to send a protocol packet to the remote side. it handles escaping SYNC
 * and ESC chars
 */
static void
dp_send_packet(struct rmc_comm_state *rcs, uchar_t *buf)
{
	char syncbuf[2];
	dp_header_t *dp_msgp = (dp_header_t *)buf;
	int total, cur;

	/* First, send out two SYNC characters. */
	syncbuf[0] = syncbuf[1] = (char)SYNC_CHAR;
	rmc_comm_serdev_send(rcs, syncbuf, 2);

	total = dp_msgp->length;
	buf = buf + sizeof (dp_msgp->pad);

	while (total > 0) {
		cur = 0;

		/* Count up characters that don't need ESC'ing. */
		while ((cur < total) &&
		    (buf[cur] != ESC_CHAR) &&
		    (buf[cur] != SYNC_CHAR)) {
			cur++;
		}

		/* Send characters that don't need escaping, if any. */
		if (cur > 0) {
			rmc_comm_serdev_send(rcs, (char *)buf, cur);
			total -= cur;
			buf += cur;
		}

		/*
		 * If total > 0 at this point, we need to send an
		 * ESC'd character.  Send as many as there are.
		 */
		while ((total > 0) &&
		    ((*buf == SYNC_CHAR) || (*buf == ESC_CHAR))) {
			syncbuf[0] = (char)ESC_CHAR;
			syncbuf[1] = *buf;
			rmc_comm_serdev_send(rcs, syncbuf, 2);
			buf++;
			total--;
		}
	}
}

/*
 * to wake a thread waiting for a reply/ACK/error status for a request/response
 * session.
 */
void
dp_wake_up_waiter(struct rmc_comm_state *rcs, uint8_t flags)
{
	dp_req_resp_t *drr = &rcs->dp_state.req_resp;

	ASSERT(MUTEX_HELD(rcs->dp_state.dp_mutex));

	DPRINTF(rcs, DGEN, (CE_CONT, "wake up? %x, set %x\n",
	    (drr->flags & (MSG_SENT | MSG_SENT_BP)) != 0, flags));

	if ((drr->flags & (MSG_SENT | MSG_SENT_BP)) != 0) {
		drr->flags |= flags;
		cv_signal(drr->cv_wait_reply);
	}
}

/*
 * initialization of the data protocol (called from the attach routine)
 */
void
rmc_comm_dp_init(struct rmc_comm_state *rcs)
{
	rmc_comm_dp_state_t *dps = &rcs->dp_state;
	dp_packet_t *pkt = &dps->dp_packet;

	DPRINTF(rcs, DGEN, (CE_CONT, "rmc_comm_dp_init\n"));

	/*
	 * initialize data structure:
	 */
	bzero((void *) dps, sizeof (rmc_comm_dp_state_t));

	/*
	 * initialize packet receive handler state
	 */

	pkt->rx_state = WAITING_FOR_SYNC;

	/*
	 * cv variables initialization
	 * (dp_mutex has been already created during the serial device
	 * initialization)
	 */
	cv_init(dps->cv_ok_to_send, NULL, CV_DRIVER, NULL);
	cv_init(dps->req_resp.cv_wait_reply, NULL, CV_DRIVER, NULL);

	mutex_enter(dps->dp_mutex);

	dp_init_buffers(rcs);

	/*
	 * initialize the data protocol (reset sequence numbers, etc.)
	 */
	dps->last_tx_seqid = INITIAL_SEQID;
	dps->last_rx_seqid = dps->last_rx_ack = INITIAL_SEQID;

	/*
	 * start timer to 'delay' the set up of the data protocol link
	 */
	dps->timer_link_setup = timeout(dp_link_setup_tohandler,
	    (void *)rcs, drv_usectohz(DELAY_DP_SETUP * 1000));

	mutex_exit(dps->dp_mutex);

#ifdef DEBUG_ERROR_INJECTION

	erri_test_number = ddi_prop_get_int(DDI_DEV_T_ANY, rcs->dip,
	    DDI_PROP_DONTPASS, "test-no", 0);
	erri_test_intrvl = ddi_prop_get_int(DDI_DEV_T_ANY, rcs->dip,
	    DDI_PROP_DONTPASS, "test-interval", 0);
	erri_test_repeat = ddi_prop_get_int(DDI_DEV_T_ANY, rcs->dip,
	    DDI_PROP_DONTPASS, "test-repeat", 0);

	erri_test_count = 0;


	cmn_err(CE_CONT, "error injection test: no=%d, intrvl=%d, rep=%d\n",
	    erri_test_number, erri_test_intrvl, erri_test_repeat);
#endif

}

/*
 * termination of the data protocol (called from the detach routine)
 */
void
rmc_comm_dp_fini(struct rmc_comm_state *rcs)
{
	rmc_comm_dp_state_t *dps = &rcs->dp_state;
	timeout_id_t	 tid_delay_ack;
	timeout_id_t	 tid_link_setup;

	DPRINTF(rcs, DGEN, (CE_CONT,
	    "stats: reset=%d nak=%d start=%d stack=%d retries=%d crcerr=%d\n",
	    dps->reset_cnt, dps->nak_cnt, dps->start_cnt, dps->stack_cnt,
	    dps->retries_cnt, dps->crcerr_cnt));

	/*
	 * if any timer is running, must be terminated here!
	 */
	mutex_enter(dps->dp_mutex);
	tid_delay_ack = dps->timer_link_setup;
	tid_link_setup = dps->timer_delay_ack;
	dps->timer_link_setup = (timeout_id_t)0;
	dps->timer_delay_ack = (timeout_id_t)0;
	mutex_exit(dps->dp_mutex);

	if (tid_delay_ack)
		(void) untimeout(tid_delay_ack);

	if (tid_link_setup)
		(void) untimeout(tid_link_setup);

	/*
	 * cv variables termination
	 */
	cv_destroy(dps->cv_ok_to_send);
	cv_destroy(dps->req_resp.cv_wait_reply);
}

/*
 * This is the low-level receiver handler. It's job is to find a complete
 * message from the incoming data stream, and once it finds one to pass it
 * on to the upper layer (message processing).
 * (it must have the dp_mutex)
 */
void
rmc_comm_dp_drecv(struct rmc_comm_state *rcs, uint8_t *buf, int buflen)
{
	rmc_comm_dp_state_t 	*dps = &rcs->dp_state;
	dp_packet_t 		*pkt = &dps->dp_packet;
	uint8_t			 quit;
	int			 count;
	int			 max;

	ASSERT(MUTEX_HELD(dps->dp_mutex));

	pkt->inbuf = buf;
	pkt->inbuflen = buflen;

	DPRINTF(rcs, DPKT, (CE_CONT, "drecv len=%d\n", buflen));

	while (pkt->inbuflen > 0) {
		switch (pkt->rx_state) {

		case WAITING_FOR_SYNC:
			while ((pkt->inbuflen > 0) &&
			    (*pkt->inbuf != SYNC_CHAR) &&
			    (*pkt->inbuf != ESC_CHAR)) {

				DPRINTF(rcs, DPKT,
				    (CE_CONT, "not SYNC: %02x\n",
				    (uchar_t)(*pkt->inbuf)));

				pkt->inbuf++;
				pkt->inbuflen--;
			}

			if (pkt->inbuflen > 0) {
				if (*pkt->inbuf == SYNC_CHAR)
					pkt->rx_state = WAITING_FOR_HDR;
				else if (*pkt->inbuf == ESC_CHAR)
					pkt->rx_state = WAITING_FOR_SYNC_ESC;
			}
			break;

		case WAITING_FOR_SYNC_ESC:
			pkt->inbuf++;
			pkt->inbuflen--;
			pkt->rx_state = WAITING_FOR_SYNC;
			break;

		case WAITING_FOR_HDR:
			while ((pkt->inbuflen > 0) &&
			    (*pkt->inbuf == SYNC_CHAR)) {
				pkt->inbuf++;
				pkt->inbuflen--;
			}

			if (pkt->inbuflen <= 0)
				break;

			if (*pkt->inbuf == ESC_CHAR) {
				/*
				 * ESC as first char of header?
				 * Impossible - start over!
				 */
				pkt->rx_state = WAITING_FOR_SYNC;
				pkt->inbuf++;
				pkt->inbuflen--;
				break;
			}

			/* Get a buffer for this message. */
			pkt->buf = dp_get_buffer(rcs, DP_RX_BUFFER);
			if (pkt->buf == NULL) {
				/* Out of buffers - drop this msg. */
				pkt->rx_state = WAITING_FOR_SYNC;
				break;
			}
			DPRINTF(rcs, DPKT, (CE_CONT, "drecv first char %x\n",
			    (uchar_t)*pkt->inbuf));

			pkt->buf[1] = *pkt->inbuf;
			pkt->bufpos = 2;
			pkt->rx_state = RECEIVING_HDR;

			pkt->inbuf++;
			pkt->inbuflen--;
			break;

		case RECEIVING_HDR:
			quit = 0;
			while ((pkt->inbuflen > 0) &&
			    (*pkt->inbuf != SYNC_CHAR) &&
			    (*pkt->inbuf != ESC_CHAR)) {
				pkt->buf[pkt->bufpos++] = *pkt->inbuf;
				pkt->inbuf++;
				pkt->inbuflen--;
				if (pkt->bufpos >= sizeof (dp_header_t)) {
					dp_got_full_hdr(rcs, pkt);
					quit = 1;
					break;
				} else if ((pkt->bufpos >= sizeof (bp_msg_t)) &&
				    (IS_BOOT_MSG(pkt->buf[1]))) {
					dp_got_bp_msg(rcs, pkt);
					quit = 1;
					break;
				}
			}

			if (quit)
				break;

			if (pkt->inbuflen > 0) {
				/* Must have gotten an ESC_CHAR or SYNC_CHAR. */
				if (*pkt->inbuf == SYNC_CHAR) {

					DPRINTF(rcs, DPKT,
						(CE_CONT, "drecv sync in hdr, "
						"bufpos=%d\n", pkt->bufpos));

					dp_release_buffer(rcs, DP_RX_BUFFER);
					pkt->buf = NULL;
					pkt->rx_state = WAITING_FOR_HDR;
				} else {
					pkt->rx_state = RECEIVING_HDR_ESC;
				}
				pkt->inbuf++;
				pkt->inbuflen--;
			}
			break;

		case RECEIVING_HDR_ESC:
			pkt->buf[pkt->bufpos++] = *pkt->inbuf;
			pkt->inbuf++;
			pkt->inbuflen--;
			if (pkt->bufpos >= sizeof (dp_header_t)) {
				dp_got_full_hdr(rcs, pkt);
			} else if ((pkt->bufpos >= sizeof (bp_msg_t)) &&
			    (IS_BOOT_MSG(pkt->buf[1]))) {
				dp_got_bp_msg(rcs, pkt);
			} else {
				pkt->rx_state = RECEIVING_HDR;
			}
			break;

		case RECEIVING_BODY:
			max = pkt->full_length - pkt->bufpos;
			if (max > pkt->inbuflen)
				max = pkt->inbuflen;

			for (count = 0; count < max; count++)
				if ((pkt->inbuf[count] == SYNC_CHAR) ||
				    (pkt->inbuf[count] == ESC_CHAR))
					break;

			if (count > 0) {
				bcopy(pkt->inbuf, pkt->buf + pkt->bufpos,
				    count);
				pkt->inbuf += count;
				pkt->inbuflen -= count;
				pkt->bufpos += count;

				if (pkt->bufpos >= pkt->full_length) {
					dp_got_full_msg(rcs, pkt);
					break;
				}
			}

			if (count < max) {
				/* Must have gotten an ESC_CHAR or SYNC_CHAR. */
				if (*pkt->inbuf == SYNC_CHAR) {
					dp_release_buffer(rcs, DP_RX_BUFFER);
					pkt->buf = NULL;
					pkt->rx_state = WAITING_FOR_HDR;
				} else {
					pkt->rx_state = RECEIVING_BODY_ESC;
				}
				pkt->inbuf++;
				pkt->inbuflen--;
			}
			break;

		case RECEIVING_BODY_ESC:
			pkt->buf[pkt->bufpos] = *pkt->inbuf;
			pkt->inbuf++;
			pkt->inbuflen--;
			pkt->bufpos++;
			if (pkt->bufpos >= pkt->full_length) {
				dp_got_full_msg(rcs, pkt);
			} else {
				pkt->rx_state = RECEIVING_BODY;
			}
			break;
		}
	}
}

/*
 * Handle an incoming message. CRCs have been already checked so message
 * is good. check if sequence numbers are ok.
 * Handles: control message, asynchronous notification, reply to requests
 * and notify the leaf driver of those events.
 * (it must have the dp_mutex)
 */
void
rmc_comm_dp_mrecv(struct rmc_comm_state *rcs, uint8_t *buf)
{
	rmc_comm_dp_state_t *dps = &rcs->dp_state;
	dp_header_t *dp_msgp;
	uint8_t *datap;
	int datalen;
	dp_msg_intr_t *dmi = &dps->msg_intr;
	dp_req_resp_t *drr = &dps->req_resp;

	ASSERT(MUTEX_HELD(dps->dp_mutex));

	dp_msgp = (dp_header_t *)buf;

	datalen = dp_msgp->length -
	    (sizeof (dp_header_t) - sizeof (dp_msgp->pad));

	if (datalen > 0) {
		datalen = datalen - sizeof (uint16_t); /* don't count msg CRC */
		datap = buf + sizeof (dp_header_t);
	} else {
		datap = NULL;
	}

	DPRINTF(rcs, DPRO, (CE_CONT,
	    "[t%03dr%03d] mrecv msgtype: %02x, len=%d\n",
	    dp_msgp->txnum, dp_msgp->rxnum, dp_msgp->type, datalen));

	/*
	 * Handle control messages first
	 */
	if (IS_UNNUMBERED_MSG(dp_msgp->type)) {
		switch (dp_msgp->type) {
		case DP_CTL_START:
			/*
			 * CTL:start
			 * Re-init protocol processing.
			 * Enable data link
			 * Stop data link setup timer if running
			 */
			DPRINTF(rcs, DPRO, (CE_CONT, "mrecv data link ok\n"));

			dp_reset(rcs, dp_msgp->txnum, 1, 0);

			dp_wake_up_waiter(rcs, 0);

			/* Send CTL:stack message. */
			(void) rmc_comm_dp_ctlsend(rcs, DP_CTL_STACK);

			dps->start_cnt++;

			dp_enable_data_link(rcs);

			break;

		case DP_CTL_STACK:
			/*
			 * CTL:stack
			 * Enable data link
			 * Stop data link setup timer if running
			 */
			DPRINTF(rcs, DPRO, (CE_CONT, "mrecv data link ok\n"));

			dp_reset(rcs, dp_msgp->txnum, 0, 0);

			dp_wake_up_waiter(rcs, 0);

			dps->stack_cnt++;

			dp_enable_data_link(rcs);
			break;

		case DP_CTL_RESPOND:
			/*
			 * CTL:respond (heartbeat)
			 * Send a CTL:ack.
			 */
			if (dps->data_link_ok) {
				(void) rmc_comm_dp_ctlsend(rcs, DP_CTL_ACK);
			}
			break;

		case DP_CTL_ACK:
			/*
			 * CTL:ack
			 * Call a transmit-side routine to handle it.
			 */
			dp_tx_handle_ack(rcs, dp_msgp->rxnum);
			break;

		case DP_CTL_NAK:
			/*
			 * CTL:nak
			 * Call a transmit-side routine to handle it.
			 */
			dp_tx_handle_nak(rcs, dp_msgp->rxnum);
			break;

		default:
			/* Drop message. */
			DPRINTF(rcs, DPRO,
			    (CE_CONT, "mrecv unknown ctrlmsg\n"));
			break;
		}
		return;
	}

	/*
	 * Before processing the received message (NUMBERED), check that the
	 * data link protocol is up. If not, ignore this message
	 */
	if (!dps->data_link_ok) {
		DPRINTF(rcs, DPRO, (CE_CONT, "mrecv drop msg: no data link\n"));
		return;
	}

	/*
	 * we received a message (NUMBERED) and data link is ok.
	 * First, instead of ACKing this message now, we delay it. The reason
	 * why is that a message can be sent (from this side) in the meantime
	 * and it can ACK the received message (it will spare us to send
	 * the ACK message across the wire).
	 */

	/*
	 * Handle acknowledgements even if this is a duplicate message.
	 */
	if (dps->timer_delay_ack == (timeout_id_t)0) {
		dps->timer_delay_ack = timeout(dp_delay_ack_tohandler,
		    (void *) rcs, drv_usectohz(TX_RETRY_TIME/2 * 1000));
		DPRINTF(rcs, DGEN, (CE_CONT, "mrecv start ack t/o %p\n",
		    dps->timer_delay_ack));
	}
	dp_tx_handle_ack(rcs, dp_msgp->rxnum);

	if (dp_msgp->txnum != NEXT_SEQID(dps->last_rx_seqid)) {
		/* Duplicate message - free it up & return. */
		DPRINTF(rcs, DPRO, (CE_CONT, "mrecv dup msg txnum=%03d\n",
		    dp_msgp->txnum));
		return;
	}
	dps->last_rx_seqid = dp_msgp->txnum;

#ifdef DEBUG_ERROR_INJECTION

	if ((erri_test_number == ERRI_SEND_CTL_STACK ||
	    erri_test_number == ERRI_SEND_CTL_START) &&
	    erri_test_repeat >= 0 &&
	    erri_test_count++ > 0 && !(erri_test_count % erri_test_intrvl)) {

		if (erri_test_number == ERRI_SEND_CTL_STACK) {
			(void) rmc_comm_dp_ctlsend(rcs, DP_CTL_STACK);

		} else if (erri_test_number == ERRI_SEND_CTL_START) {
			(void) rmc_comm_dp_ctlsend(rcs, DP_CTL_START);

		}
		if (erri_test_repeat == 0)
			erri_test_repeat--; /* will not repeat the test */
	}

#endif

	/*
	 * At this point, we know this is a good message.  We've
	 * checked checksums, message types, and sequence id's.
	 */

	/*
	 * First, check if a driver has register for this message
	 * Second, check if this message is a reply to a request
	 * Third, check to see if ALOM is telling us it doesn't
	 * know about the command code.
	 */

	if (dmi->intr_handler != NULL &&
	    dmi->intr_msg_type == dp_msgp->type) {

		rmc_comm_msg_t 	*msgi = (rmc_comm_msg_t *)dmi->intr_arg;

		DPRINTF(rcs, DPRO, (CE_CONT,
		    "mrecv process async msg len=%d, max=%d\n",
		    datalen, msgi->msg_len));
		/*
		 * process asynchronous notification only if the registered
		 * driver is not currently processing any other notification
		 */
		mutex_enter(dmi->intr_lock);
		if (dmi->intr_state == NULL ||
		    (dmi->intr_state != NULL &&
		    *(dmi->intr_state) == RMC_COMM_INTR_IDLE)) {
			/*
			 * check that the buffer is big enough. do not want to
			 * cross boundaries here..
			 */
			if (datalen <= msgi->msg_len) {
				bcopy(datap, msgi->msg_buf, datalen);
				msgi->msg_bytes = datalen;

			} else {
				msgi->msg_bytes = -1;
			}
			/*
			 * trigger soft intr. in any case.
			 * if message is too big, at least, the leaf driver
			 * will be notified (bytes returned will be -1)
			 */
			ddi_trigger_softintr(dmi->intr_id);
		}
		mutex_exit(dmi->intr_lock);

	} else if ((drr->flags & MSG_SENT) != 0 &&
	    drr->response.msg_type == dp_msgp->type) {

		DPRINTF(rcs, DPRO, (CE_CONT,
		    "mrecv process reply len=%d, max=%d\n",
		    datalen, drr->response.msg_bufsiz));

		/*
		 * check that the recv buffer is big enough.
		 */
		if (datalen <= drr->response.msg_bufsiz) {
			bcopy(datap, drr->response.msg_buf, datalen);
			drr->response.msg_msglen = datalen;
			dp_wake_up_waiter(rcs, MSG_REPLY_RXED);
		} else {
			drr->response.msg_msglen = -1;
			dp_wake_up_waiter(rcs, MSG_REPLY_RXED);
		}
	} else if (dp_msgp->type == DP_INVCMD &&
	    (drr->flags & MSG_SENT) != 0 &&
	    ((dp_invcmd_t *)datap)->inv_type == drr->request.msg_type) {
		drr->error_status = RCEINVCMD;
		dp_wake_up_waiter(rcs, MSG_ERROR);
	}
}

/*
 * to send a control message (unnumbered message)
 * (it must have the dp_mutex)
 */
int
rmc_comm_dp_ctlsend(struct rmc_comm_state *rcs, uint8_t type)
{
	dp_message_t ctlmsg;
	int err = RCNOERR;

	ctlmsg.msg_type = type;
	ctlmsg.msg_buf = NULL;
	ctlmsg.msg_msglen = 0;

	err = rmc_comm_dp_msend(rcs, &ctlmsg);

	return (err);
}

/*
 * to send data to the remote party.
 *
 * NUMBERED messages carry payload data of variable size. A buffer is allocated
 * dynamically for the trasmission of data. NUMBERED message trasmission
 * data status is stored in the dp_state request_response data structure.
 * This because: data sent must be acknowledged, trasmission can be re-tried,
 * upper layer has to know the state/result of the trasmission. Upper layer has
 * to: initialize the data struct, send data (this function), read result,
 * clean up the data struct.
 *
 * UNUMBERED data are just only control command which do not carry any payload
 * A local buffer is used (ctlbuf) instead. UNNUMBERED message are transient
 * data which is sent once and not re-tried. It does not use the
 * request_response data structure
 *
 * (it must have the dp_mutex)
 */
int
rmc_comm_dp_msend(struct rmc_comm_state *rcs, dp_message_t *req)
{
	rmc_comm_dp_state_t 	*dps = &rcs->dp_state;
	dp_req_resp_t		*drr = &dps->req_resp;
	dp_message_t		*pkt;
	dp_header_t		*dp_msgp;
	dp_message_t		 ctl;
	dp_header_t		 ctlbuf;
	uint16_t		 data_crc;
	timeout_id_t		 timer_delay_ack = 0;
	char			 first_time = 0;

	ASSERT(MUTEX_HELD(dps->dp_mutex));

	DPRINTF(rcs, DPRO, (CE_CONT, "msend msgtype=%02x\n", req->msg_type));

	if (IS_NUMBERED_MSG(req->msg_type)) {
		/*
		 * if there was an error, just return the error.
		 * Otherwise if the message was already acknowledged
		 * (NUMBERED message) then, there is no need to (re)send it.
		 * just wait for an expected reply (hence, do not return an
		 * error)
		 */
		if ((drr->flags & MSG_ERROR) != 0) {

			DPRINTF(rcs, DPRO, (CE_CONT,
			    "msg send error flag=%02x\n", drr->flags));
			return (RCEGENERIC);

		} else if ((drr->flags & MSG_ACKED) != 0) {

			DPRINTF(rcs, DPRO, (CE_CONT,
			    "msg already ACKed flag=%02x\n", drr->flags));
			return (RCNOERR);

		} else if ((drr->flags & MSG_SENT) == 0) {

			first_time = 1;
		}

		/*
		 * everything is ok. Now check that the data protocol is up
		 * and running: messages cannot be sent if the link is down.
		 */
		if (!dps->data_link_ok) {
			DPRINTF(rcs, DPRO, (CE_CONT,
			    "msend: can't send msg - no data link\n"));

			/*
			 * do not return error, since it can be retried
			 * later (hoping that the data link will come
			 * up, in the meantime)
			 */
			return (RCNOERR);

		}
	} else {
		first_time = 1;
	}

	/*
	 * if the message has never been sent (and, hence, it is the first
	 * time), then prepare the protocol packet: allocate a buffer,
	 * create the message header, copy the message body into the buffer and
	 * calculate CRCs
	 */
	if (first_time) {

		if (IS_NUMBERED_MSG(req->msg_type)) {

			drr->retries_left = TX_RETRIES;

			/*
			 * Check length of the message.
			 */
			if (req->msg_msglen > DP_MAX_MSGLEN) {
				DPRINTF(rcs, DPRO,
				    (CE_CONT, "msend err: msg too big\n"));
				return (RCEINVARG);
			}

			pkt = &drr->request;

			/*
			 * check that the message buffer is not already
			 * in use (race condition). If so, return error
			 */
			if (pkt->msg_buf != NULL) {
				DPRINTF(rcs, DPRO, (CE_CONT,
				    "msend err: buf already in use\n"));
				return (RCENOMEM);
			}

			/*
			 * allocate a buffer for the protocol packet
			 */
			if ((pkt->msg_buf = dp_get_buffer(rcs,
			    DP_TX_BUFFER)) == NULL) {
				DPRINTF(rcs, DPRO, (CE_CONT,
				    "msend err: no mem\n"));
				return (RCENOMEM);
			}
			pkt->msg_bufsiz = DP_BUFFER_SIZE;

			/*
			 * increment tx sequence number if sending a NUMBERED
			 * message
			 */
			dps->last_tx_seqid = NEXT_SEQID(dps->last_tx_seqid);
		} else {
			/*
			 * UNUMBERED messages (or control messages) do not
			 * carry any data and, hence, have a 'small' fixed size
			 * (the size of the header). In this case,
			 * a 'local' buffer (ctlbuf) is used.
			 */
			pkt = &ctl;
			pkt->msg_buf = (uint8_t *)&ctlbuf;
			pkt->msg_bufsiz = sizeof (dp_header_t);
		}

#ifdef DEBUG_ERROR_INJECTION

		if (((erri_test_number == ERRI_RX_SEQ_NUMBER &&
		    IS_NUMBERED_MSG(req->msg_type)) ||
		    (erri_test_number == ERRI_CTL_RX_SEQ_NUMBER &&
		    IS_UNNUMBERED_MSG(req->msg_type))) &&
		    erri_test_repeat >= 0 &&
		    erri_test_count++ > 0 &&
		    !(erri_test_count % erri_test_intrvl)) {

			dps->last_rx_seqid--;

			if (erri_test_repeat == 0)
				erri_test_repeat--; /* will not repeat it */
		}
#endif

		/*
		 * create the protocol packet
		 */
		pkt->msg_type = req->msg_type;

		/*
		 * length of the packet (including pad bytes)
		 */
		pkt->msg_msglen = req->msg_msglen + sizeof (dp_header_t);

		/*
		 * message header:
		 *  set the message type
		 *  set the length of the message (excluding pad bytes)
		 *  set tx/rx sequence numbers
		 *  calculate CRC
		 */
		dp_msgp = (dp_header_t *)pkt->msg_buf;
		dp_msgp->type = pkt->msg_type;

		if (req->msg_msglen == 0)
			dp_msgp->length = pkt->msg_msglen -
			    sizeof (dp_msgp->pad);
		else
			dp_msgp->length = sizeof (data_crc) +
			    pkt->msg_msglen - sizeof (dp_msgp->pad);

		dp_msgp->txnum = dps->last_tx_seqid;
		dp_msgp->rxnum = dps->last_rx_seqid;

		dp_msgp->crc = dp_calc_crc16(pkt->msg_buf +
		    sizeof (dp_msgp->pad), sizeof (dp_header_t) -
		    sizeof (dp_msgp->crc) - sizeof (dp_msgp->pad));

#ifdef DEBUG_ERROR_INJECTION

		if (((erri_test_number == ERRI_CRC_HEADER &&
		    IS_NUMBERED_MSG(pkt->msg_type)) ||
		    (erri_test_number == ERRI_CTL_CRC_HEADER &&
		    IS_UNNUMBERED_MSG(pkt->msg_type))) &&
		    erri_test_repeat >= 0 &&
		    erri_test_count++ > 0 &&
		    !(erri_test_count % erri_test_intrvl)) {

			dp_msgp->crc = dp_msgp->crc/2;
			if (erri_test_repeat == 0)
				erri_test_repeat--; /* will not repeat it */
		}
#endif

		/*
		 * copy message body (if present) into the buffer
		 * and calculate message CRC
		 */
		if (req->msg_msglen > 0) {
			bcopy(req->msg_buf, pkt->msg_buf + sizeof (dp_header_t),
			    req->msg_msglen);
			data_crc = dp_calc_crc16(pkt->msg_buf +
			    sizeof (dp_header_t),
			    req->msg_msglen);

#ifdef DEBUG_ERROR_INJECTION

			if (erri_test_number == ERRI_CRC_MSG &&
			    erri_test_repeat >= 0 &&
			    erri_test_count++ > 0 &&
			    !(erri_test_count % erri_test_intrvl)) {

				data_crc = data_crc/2;
				if (erri_test_repeat == 0)
					erri_test_repeat--;
			}
#endif
			bcopy((void *) &data_crc,
			    pkt->msg_buf + (sizeof (dp_header_t) +
			    req->msg_msglen),
			    sizeof (data_crc));
		}
	} else {
		/*
		 * message has already been sent (and packetized).
		 * get the message packet from the request/response
		 * data structure
		 */
		pkt = &drr->request;
		dp_msgp = (dp_header_t *)pkt->msg_buf;
		dps->retries_cnt++;
	}

	/*
	 *  NUMBERED messages
	 */
	if (IS_NUMBERED_MSG(pkt->msg_type)) {

		/*
		 * check that we have not exceeded the maximum number of
		 * retries
		 */
		if (drr->retries_left-- <= 0) {

			drr->flags |= MSG_ERROR; /* set error flag */

			/*
			 * restart the data protocol link
			 */
			dp_reset(rcs, INITIAL_SEQID, 0, 1);

			return (RCEMAXRETRIES);
		}

		if (dps->timer_delay_ack != (timeout_id_t)0) {
			/*
			 * Cancel any pending acknowledgements - we're
			 * going to send a message which will include
			 * an acknowledgement.
			 */
			timer_delay_ack = dps->timer_delay_ack;

			/*
			 * the timer is actually removed at the end of this
			 * function since I need to release the dp_mutex.
			 * Instead I clear the timer variable so that the
			 * timeout callback will not do any processing in the
			 * meantime.
			 */
			dps->timer_delay_ack = 0;
		}

		drr->flags |= MSG_SENT;
	}

	/*
	 * set rx sequence number (as we might have received a message in the
	 * meantime). tx sequence number to be the same (we can only send one
	 * message per time)
	 */
	if (dp_msgp->rxnum != dps->last_rx_seqid) {

		dp_msgp->rxnum = dps->last_rx_seqid;

		/*
		 * re-calculate CRC (header)
		 */
		dp_msgp->crc = dp_calc_crc16(pkt->msg_buf +
		    sizeof (dp_msgp->pad), sizeof (dp_header_t) -
		    sizeof (dp_msgp->crc) - sizeof (dp_msgp->pad));
	}

	DPRINTF(rcs, DPRO, (CE_CONT, "[t%03dr%03d] msend msgtype=%02x\n",
	    dp_msgp->txnum, dp_msgp->rxnum, dp_msgp->type));

	/*
	 * send this message
	 */

	dp_send_packet(rcs, pkt->msg_buf);

	/*
	 * remove delay ack timer (if any is running)
	 * Note that the dp_mutex must be released before calling
	 * untimeout. Otherwise we may have a deadlock situation.
	 */
	if (timer_delay_ack != 0) {
		DPRINTF(rcs, DGEN, (CE_CONT, "msend remove ack timer %p\n",
		    timer_delay_ack));
		mutex_exit(dps->dp_mutex);
		(void) untimeout(timer_delay_ack);
		mutex_enter(dps->dp_mutex);
	}

	return (RCNOERR);
}

/*
 * to send a boot protocol message
 * (this is to support the firmware download feature)
 */
void
rmc_comm_bp_msend(struct rmc_comm_state *rcs, bp_msg_t *bp_msg)
{
	char syncbuf[2];

	ASSERT(MUTEX_HELD(rcs->dp_state.dp_mutex));

	DPRINTF(rcs, DPRO, (CE_CONT, "send bp msg: %02x %02x %02x\n",
	    bp_msg->cmd, bp_msg->dat1, bp_msg->dat2));

	rcs->dp_state.req_resp.flags |= MSG_SENT_BP;

	/* First, send out two SYNC characters. */
	syncbuf[0] = syncbuf[1] = (char)SYNC_CHAR;
	rmc_comm_serdev_send(rcs, syncbuf, 2);

	/* Next, send the BP message. */
	rmc_comm_serdev_send(rcs, (char *)&bp_msg->cmd,
	    sizeof (bp_msg_t) - sizeof (bp_msg->pad));
}

/*
 * to send a fw s-record
 * (this is to support the firmware download feature)
 */
void
rmc_comm_bp_srecsend(struct rmc_comm_state *rcs, char *buf, int buflen)
{
	ASSERT(MUTEX_HELD(rcs->dp_state.dp_mutex));

	rcs->dp_state.req_resp.flags |= MSG_SENT_BP;

	rmc_comm_serdev_send(rcs, buf, buflen);
}

/*
 * clean up a request/response session
 * (it must have the dp_mutex)
 */

void
rmc_comm_dp_mcleanup(struct rmc_comm_state *rcs)
{
	rmc_comm_dp_state_t *dps = &rcs->dp_state;
	dp_req_resp_t *drr = &dps->req_resp;
	dp_message_t *req = &drr->request;
	dp_message_t *resp = &drr->response;

	ASSERT(MUTEX_HELD(dps->dp_mutex));

	DPRINTF(rcs, DGEN, (CE_CONT, "msg cleanup\n"));

	/*
	 * 'release' memory
	 * memory is only 'dynamically allocated for NUMBERED messages
	 */
	if (req->msg_buf != NULL)
		dp_release_buffer(rcs, DP_TX_BUFFER);

	drr->flags = 0;
	drr->error_status = 0;

	req->msg_type = DP_NULL_MSG;
	req->msg_buf = NULL;
	req->msg_msglen = 0;
	req->msg_bufsiz = 0;
	resp->msg_type = DP_NULL_MSG;
	resp->msg_buf = NULL;
	resp->msg_msglen = 0;
	resp->msg_bufsiz = 0;
}