/*
* 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;
}