path: root/sys/arch/vax/mscp/mscp_subr.c

/*	$OpenBSD: mscp_subr.c,v 1.2 1997/05/29 00:05:03 niklas Exp $	*/
/*	$NetBSD: mscp_subr.c,v 1.6 1997/01/11 11:20:34 ragge Exp $	*/
/*
 * Copyright (c) 1996 Ludd, University of Lule}, Sweden.
 * Copyright (c) 1988 Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Chris Torek.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)mscp.c	7.5 (Berkeley) 12/16/90
 */

/*
 * MSCP generic driver routines
 */

#include <sys/param.h>
#include <sys/device.h>
#include <sys/buf.h>
#include <sys/systm.h>
#include <sys/proc.h>

#include <machine/sid.h>

#include <vax/mscp/mscp.h>
#include <vax/mscp/mscpreg.h>
#include <vax/mscp/mscpvar.h>

#include "ra.h"
#include "mt.h"

#define	b_forw	b_hash.le_next

int	mscp_match __P((struct device *, void *, void *));
void	mscp_attach __P((struct device *, struct device *, void *));
void    mscp_start __P((struct  mscp_softc *));
int	mscp_init __P((struct  mscp_softc *));
void	mscp_initds __P((struct mscp_softc *));
int	mscp_waitstep __P((struct mscp_softc *, int, int));

struct	cfattach mscpbus_ca = {
	sizeof(struct mscp_softc), mscp_match, mscp_attach
};

struct	cfdriver mscpbus_cd = {
	NULL, "mscpbus", DV_DULL
};

struct	mscp slavereply;

/*
 * This function is for delay during init. Some MSCP clone card (Dilog)
 * can't handle fast read from its registers, and therefore need
 * a delay between them.
 */

#define DELAYTEN 1000
int
mscp_waitstep(mi, mask, result)
	struct mscp_softc *mi;
	int mask, result;
{
	int	status = 1;

	if ((*mi->mi_sa & mask) != result) {
		volatile int count = 0;
		while ((*mi->mi_sa & mask) != result) {
			DELAY(10000);
			count += 1;
			if (count > DELAYTEN)
				break;
		}
		if (count > DELAYTEN)
			status = 0;
	}
	return status;
}

int
mscp_match(parent, match, aux)
	struct device *parent;
	void *match, *aux;
{
	struct	mscp_attach_args *ma = aux;

#if NRA
	if (ma->ma_type & MSCPBUS_DISK)
		return 1;
#endif
#if NMT
	if (ma->ma_type & MSCPBUS_TAPE)
		return 1;
#endif
	return 0;
};

void
mscp_attach(parent, self, aux)
	struct device *parent, *self;
	void *aux;
{
	struct	mscp_attach_args *ma = aux;
	struct	mscp_softc *mi = (void *)self;
	volatile struct	mscp *mp;
	volatile int i;
	int	timeout, next = 0;

	mi->mi_mc = ma->ma_mc;
	mi->mi_me = NULL;
	mi->mi_type = ma->ma_type;
	mi->mi_uuda = ma->ma_uuda;
	mi->mi_uda = ma->ma_uda;
	mi->mi_ip = ma->ma_ip;
	mi->mi_sa = ma->ma_sa;
	mi->mi_sw = ma->ma_sw;
	mi->mi_ivec = ma->ma_ivec;
	mi->mi_adapnr = ma->ma_adapnr;
	mi->mi_ctlrnr = ma->ma_ctlrnr;
	*ma->ma_softc = mi;
	/*
	 * Go out to init the bus, so that we can give commands
	 * to its devices.
	 */
        mi->mi_cmd.mri_size = NCMD;
        mi->mi_cmd.mri_desc = mi->mi_uda->mp_ca.ca_cmddsc;
        mi->mi_cmd.mri_ring = mi->mi_uda->mp_cmd;
        mi->mi_rsp.mri_size = NRSP;
        mi->mi_rsp.mri_desc = mi->mi_uda->mp_ca.ca_rspdsc;
        mi->mi_rsp.mri_ring = mi->mi_uda->mp_rsp;
	mi->mi_actf = (void *)&mi->mi_actf; /* Circular wait queue */
	mi->mi_actb = (void *)&mi->mi_actf;

	if (mscp_init(mi)) {
		printf("%s: can't init, controller hung\n",
		    mi->mi_dev.dv_xname);
		return;
	}

#if NRA
	if (ma->ma_type & MSCPBUS_DISK) {
		extern	struct mscp_device ra_device;

		mi->mi_me = &ra_device;
	}
#endif
#if NMT
	if (ma->ma_type & MSCPBUS_TAPE) {
		extern	struct mscp_device mt_device;

		mi->mi_me = &mt_device;
	}
#endif
	/*
	 * Go out and search for sub-units on this MSCP bus,
	 * and call config_found for each found.
	 */
findunit:
	mp = mscp_getcp(mi, MSCP_DONTWAIT);
	if (mp == NULL)
		panic("mscpattach: no packets");
	mp->mscp_opcode = M_OP_GETUNITST;
	mp->mscp_unit = next;
	mp->mscp_modifier = M_GUM_NEXTUNIT;
	*mp->mscp_addr |= MSCP_OWN | MSCP_INT;
	slavereply.mscp_opcode = 0;

	i = *mi->mi_ip;	 /* Kick off polling */
	mp = &slavereply;
	timeout = 1000;
	while (timeout-- > 0) {
		DELAY(10000);
		if (mp->mscp_opcode)
			goto gotit;
	}
	printf("%s: no response to Get Unit Status request\n",
	    mi->mi_dev.dv_xname);
	return;

gotit:	/*
	 * Got a slave response.  If the unit is there, use it.
	 */
	switch (mp->mscp_status & M_ST_MASK) {

	case M_ST_SUCCESS:      /* worked */
	case M_ST_AVAILABLE:    /* found another drive */
		break;          /* use it */

	case M_ST_OFFLINE:
		/*
		 * Figure out why it is off line.  It may be because
                 * it is nonexistent, or because it is spun down, or
                 * for some other reason.
                 */
                switch (mp->mscp_status & ~M_ST_MASK) {

                case M_OFFLINE_UNKNOWN:
                        /*
                         * No such drive, and there are none with
                         * higher unit numbers either, if we are
                         * using M_GUM_NEXTUNIT.
                         */
			mi->mi_ierr = 3;
                        return;

                case M_OFFLINE_UNMOUNTED:
                        /*
                         * The drive is not spun up.  Use it anyway.
                         *
                         * N.B.: this seems to be a common occurrance
                         * after a power failure.  The first attempt
                         * to bring it on line seems to spin it up
                         * (and thus takes several minutes).  Perhaps
                         * we should note here that the on-line may
                         * take longer than usual.
                         */
                        break;

                default:
                        /*
                         * In service, or something else equally unusable.
                         */
                        printf("%s: unit %d off line: ", mi->mi_dev.dv_xname,
                                mp->mscp_unit);
                        mscp_printevent((struct mscp *)mp);
			next++;
                        goto findunit;
                }
                break;

        default:
                printf("%s: unable to get unit status: ", mi->mi_dev.dv_xname);
                mscp_printevent((struct mscp *)mp);
                return;
        }

        /*
         * If we get a lower number, we have circulated around all
	 * devices and are finished, otherwise try to find next unit.
	 * We shouldn't ever get this, it's a workaround.
         */
        if (mp->mscp_unit < next)
                return;

	next = mp->mscp_unit + 1;
	goto findunit;
}


/*
 * The ctlr gets initialised, normally after boot but may also be 
 * done if the ctlr gets in an unknown state. Returns 1 if init
 * fails, 0 otherwise.
 */
int
mscp_init(mi)
	struct	mscp_softc *mi;
{
	struct	mscp *mp;
	volatile int i;
	int	status, count;
	unsigned int j = 0;

        /*
         * While we are thinking about it, reset the next command
         * and response indicies.
         */
	mi->mi_cmd.mri_next = 0;
	mi->mi_rsp.mri_next = 0;

	mi->mi_flags |= MSC_IGNOREINTR;

	if ((mi->mi_type & MSCPBUS_KDB) == 0)
		*mi->mi_ip = 0;	/* Kick off */

	status = mscp_waitstep(mi, MP_STEP1, MP_STEP1);/* Wait to it wakes up */
	if (status == 0)
		return 1; /* Init failed */
	if (*mi->mi_sa & MP_ERR) {
		(*mi->mi_mc->mc_saerror)(mi->mi_dev.dv_parent, 0);
		return 1;
	}

	/* step1 */
	*mi->mi_sw = MP_ERR | (NCMDL2 << 11) | (NRSPL2 << 8) |
	    MP_IE | (mi->mi_ivec >> 2);
	status = mscp_waitstep(mi, STEP1MASK, STEP1GOOD);
	if (status == 0) {
		(*mi->mi_mc->mc_saerror)(mi->mi_dev.dv_parent, 0);
		return 1;
	}

	/* step2 */
	*mi->mi_sw = (int)&mi->mi_uuda->mp_ca.ca_rspdsc[0] | 
	    (vax_cputype == VAX_780 || vax_cputype == VAX_8600 ? MP_PI : 0);
	status = mscp_waitstep(mi, STEP2MASK, STEP2GOOD(mi->mi_ivec >> 2));
        if (status == 0) {
                (*mi->mi_mc->mc_saerror)(mi->mi_dev.dv_parent, 0);
                return 1;
        }

	/* step3 */
	*mi->mi_sw = ((int)&mi->mi_uuda->mp_ca.ca_rspdsc[0]) >> 16;
	status = mscp_waitstep(mi, STEP3MASK, STEP3GOOD);
        if (status == 0) { 
                (*mi->mi_mc->mc_saerror)(mi->mi_dev.dv_parent, 0);
                return 1;
        }
	i = *mi->mi_sa & 0377;
	printf(": version %d model %d\n", i & 15, i >> 4);

#define	BURST 4	/* XXX */
	if (mi->mi_type & MSCPBUS_UDA) {
		*mi->mi_sw = MP_GO | (BURST - 1) << 2;
		printf("%s: DMA burst size set to %d\n", 
		    mi->mi_dev.dv_xname, BURST);
	}
	*mi->mi_sw = MP_GO;

	mscp_initds(mi);
	mi->mi_flags &= ~MSC_IGNOREINTR;

	/*
	 * Set up all necessary info in the bus softc struct, get a
	 * mscp packet and set characteristics for this controller.
	 */
	mi->mi_credits = MSCP_MINCREDITS + 1;
	mp = mscp_getcp(mi, MSCP_DONTWAIT);

	mi->mi_credits = 0;
	mp->mscp_opcode = M_OP_SETCTLRC;
	mp->mscp_unit = mp->mscp_modifier = mp->mscp_flags =
	    mp->mscp_sccc.sccc_version = mp->mscp_sccc.sccc_hosttimo = 
	    mp->mscp_sccc.sccc_time = mp->mscp_sccc.sccc_time1 =
	    mp->mscp_sccc.sccc_errlgfl = 0;
	mp->mscp_sccc.sccc_ctlrflags = M_CF_ATTN | M_CF_MISC | M_CF_THIS;
	*mp->mscp_addr |= MSCP_OWN | MSCP_INT;
	i = *mi->mi_ip;

        count = 0;
        while (count < DELAYTEN) {
                if (((volatile)mi->mi_flags & MSC_READY) != 0)
                        break;
		if ((j = *mi->mi_sa) & MP_ERR)
			goto out;
                DELAY(10000);
                count += 1;
        }
	if (count == DELAYTEN) {
out:
		printf("%s: couldn't set ctlr characteristics, sa=%x\n", 
		    mi->mi_dev.dv_xname, j);
		return 1;
	}
	return 0;
}

/*
 * Initialise the various data structures that control the mscp protocol.
 */
void
mscp_initds(mi)
	struct mscp_softc *mi;
{
	struct mscp_pack *uud = mi->mi_uuda;
	struct mscp_pack *ud = mi->mi_uda;
	struct mscp *mp;
	int i;

	for (i = 0, mp = ud->mp_rsp; i < NRSP; i++, mp++) {
		ud->mp_ca.ca_rspdsc[i] = MSCP_OWN | MSCP_INT |
		    (long)&uud->mp_rsp[i].mscp_cmdref;
		mp->mscp_addr = &ud->mp_ca.ca_rspdsc[i];
		mp->mscp_msglen = MSCP_MSGLEN;
	}
	for (i = 0, mp = ud->mp_cmd; i < NCMD; i++, mp++) {
		ud->mp_ca.ca_cmddsc[i] = MSCP_INT |
		    (long)&uud->mp_cmd[i].mscp_cmdref;
		mp->mscp_addr = &ud->mp_ca.ca_cmddsc[i];
		mp->mscp_msglen = MSCP_MSGLEN;
		if (mi->mi_type & MSCPBUS_TAPE)
			mp->mscp_vcid = 1;
	}
}

void
mscp_intr(mi)
	struct mscp_softc *mi;
{
	struct mscp_pack *ud = mi->mi_uda;

	if (mi->mi_flags & MSC_IGNOREINTR)
		return;
        /*
         * Check for response and command ring transitions.
         */
        if (ud->mp_ca.ca_rspint) {
                ud->mp_ca.ca_rspint = 0;
                mscp_dorsp(mi);
        }
        if (ud->mp_ca.ca_cmdint) {
                ud->mp_ca.ca_cmdint = 0;
                MSCP_DOCMD(mi);
        }

	/*
	 * If there are any not-yet-handled requeset, try them now.
	 * XXX - We handles them (erroneous) in last-in first-handled order.
	 * Must we fix this???
	 */
	while (mi->mi_w) {
		struct buf *bp = mi->mi_w;

		mi->mi_w = (void *)bp->b_actb;
		mscp_strategy(bp, (struct device *)mi);
		if (mi->mi_w == bp)
			break;
	}
}

int
mscp_print(aux, name)
	void *aux;
	const char *name;
{
	return UNCONF;
}

/*
 * common strategy routine for all types of MSCP devices.
 * bp is the current buf, dp is the drive queue.
 */
void
mscp_strategy(bp, usc)
	struct buf *bp;
	struct device *usc;
{
	struct	mscp_softc *mi = (void *)usc;
	struct	mscp *mp;
	int s = spl6();

	/*
	 * Ok; we are ready to try to start a xfer. Get a MSCP packet
	 * and try to start...
	 */
	if ((mp = mscp_getcp(mi, MSCP_DONTWAIT)) == NULL) {
		if (mi->mi_credits > MSCP_MINCREDITS)
			printf("%s: command ring too small\n",
			    mi->mi_dev.dv_parent->dv_xname);
		/*
		 * By some (strange) reason we didn't get a MSCP packet.
		 * Put it on queue and wait for free packets.
		 */
		(void *)bp->b_actb = mi->mi_w;
		mi->mi_w = bp;
		splx(s);
		return;
	}

	/*
	 * Set up the MSCP packet and ask the ctlr to start.
	 */
	mp->mscp_opcode = (bp->b_flags & B_READ) ? M_OP_READ : M_OP_WRITE;
	(*mi->mi_me->me_fillin)(bp, mp);
	(void *)bp->b_actb = mp; /* b_actb is unused, save mscp packet here */
	(*mi->mi_mc->mc_go)(mi->mi_dev.dv_parent, bp);
	splx(s);
}

void
mscp_dgo(mi, buffer, info, bp)
	struct mscp_softc *mi;
	long buffer, info;
	struct buf *bp;
{
	volatile int i;
	struct	mscp *mp;

        /*
         * Fill in the MSCP packet and move the buffer to the I/O wait queue.
         */
	mp = (void *)bp->b_actb;

	mp->mscp_seq.seq_buffer = buffer;

	_insque(&bp->b_actf, &mi->mi_actf);

	bp->b_resid = info;
	mp->mscp_cmdref = (long) bp;
	*mp->mscp_addr |= MSCP_OWN | MSCP_INT;

	i = *mi->mi_ip;
}

#ifdef DIAGNOSTIC
/*
 * Dump the entire contents of an MSCP packet in hex.  Mainly useful
 * for debugging....
 */
void
mscp_hexdump(mp)
	register struct mscp *mp;
{
	register long *p = (long *) mp;
	register int i = mp->mscp_msglen;

	if (i > 256)		/* sanity */
		i = 256;
	i /= sizeof (*p);	/* ASSUMES MULTIPLE OF sizeof(long) */
	while (--i >= 0)
		printf("0x%x ", (int)*p++);
	printf("\n");
}
#endif

/*
 * MSCP error reporting
 */

/*
 * Messages for the various subcodes.
 */
static char unknown_msg[] = "unknown subcode";

/*
 * Subcodes for Success (0)
 */
static char *succ_msgs[] = {
	"normal",		/* 0 */
	"spin down ignored",	/* 1 = Spin-Down Ignored */
	"still connected",	/* 2 = Still Connected */
	unknown_msg,
	"dup. unit #",		/* 4 = Duplicate Unit Number */
	unknown_msg,
	unknown_msg,
	unknown_msg,
	"already online",	/* 8 = Already Online */
	unknown_msg,
	unknown_msg,
	unknown_msg,
	unknown_msg,
	unknown_msg,
	unknown_msg,
	unknown_msg,
	"still online",		/* 16 = Still Online */
};

/*
 * Subcodes for Invalid Command (1)
 */
static char *icmd_msgs[] = {
	"invalid msg length",	/* 0 = Invalid Message Length */
};

/*
 * Subcodes for Command Aborted (2)
 */
/* none known */

/*
 * Subcodes for Unit Offline (3)
 */
static char *offl_msgs[] = {
	"unknown drive",	/* 0 = Unknown, or online to other ctlr */
	"not mounted",		/* 1 = Unmounted, or RUN/STOP at STOP */
	"inoperative",		/* 2 = Unit Inoperative */
	unknown_msg,
	"duplicate",		/* 4 = Duplicate Unit Number */
	unknown_msg,
	unknown_msg,
	unknown_msg,
	"in diagnosis",		/* 8 = Disabled by FS or diagnostic */
};

/*
 * Subcodes for Unit Available (4)
 */
/* none known */

/*
 * Subcodes for Media Format Error (5)
 */
static char *media_fmt_msgs[] = {
	"fct unread - edc",	/* 0 = FCT unreadable */
	"invalid sector header",/* 1 = Invalid Sector Header */
	"not 512 sectors",	/* 2 = Not 512 Byte Sectors */
	"not formatted",	/* 3 = Not Formatted */
	"fct ecc",		/* 4 = FCT ECC */
};

/*
 * Subcodes for Write Protected (6)
 * N.B.:  Code 6 subcodes are 7 bits higher than other subcodes
 * (i.e., bits 12-15).
 */
static char *wrprot_msgs[] = {
	unknown_msg,
	"software",		/* 1 = Software Write Protect */
	"hardware",		/* 2 = Hardware Write Protect */
};

/*
 * Subcodes for Compare Error (7)
 */
/* none known */

/*
 * Subcodes for Data Error (8)
 */
static char *data_msgs[] = {
	"forced error",		/* 0 = Forced Error (software) */
	unknown_msg,
	"header compare",	/* 2 = Header Compare Error */
	"sync timeout",		/* 3 = Sync Timeout Error */
	unknown_msg,
	unknown_msg,
	unknown_msg,
	"uncorrectable ecc",	/* 7 = Uncorrectable ECC */
	"1 symbol ecc",		/* 8 = 1 bit ECC */
	"2 symbol ecc",		/* 9 = 2 bit ECC */
	"3 symbol ecc",		/* 10 = 3 bit ECC */
	"4 symbol ecc",		/* 11 = 4 bit ECC */
	"5 symbol ecc",		/* 12 = 5 bit ECC */
	"6 symbol ecc",		/* 13 = 6 bit ECC */
	"7 symbol ecc",		/* 14 = 7 bit ECC */
	"8 symbol ecc",		/* 15 = 8 bit ECC */
};

/*
 * Subcodes for Host Buffer Access Error (9)
 */
static char *host_buffer_msgs[] = {
	unknown_msg,
	"odd xfer addr",	/* 1 = Odd Transfer Address */
	"odd xfer count",	/* 2 = Odd Transfer Count */
	"non-exist. memory",	/* 3 = Non-Existent Memory */
	"memory parity",	/* 4 = Memory Parity Error */
};

/*
 * Subcodes for Controller Error (10)
 */
static char *cntlr_msgs[] = {
	unknown_msg,
	"serdes overrun",	/* 1 = Serialiser/Deserialiser Overrun */
	"edc",			/* 2 = Error Detection Code? */
	"inconsistant internal data struct",/* 3 = Internal Error */
};

/*
 * Subcodes for Drive Error (11)
 */
static char *drive_msgs[] = {
	unknown_msg,
	"sdi command timeout",	/* 1 = SDI Command Timeout */
	"ctlr detected protocol",/* 2 = Controller Detected Protocol Error */
	"positioner",		/* 3 = Positioner Error */
	"lost rd/wr ready",	/* 4 = Lost R/W Ready Error */
	"drive clock dropout",	/* 5 = Lost Drive Clock */
	"lost recvr ready",	/* 6 = Lost Receiver Ready */
	"drive detected error",	/* 7 = Drive Error */
	"ctlr detected pulse or parity",/* 8 = Pulse or Parity Error */
};

/*
 * The following table correlates message codes with the
 * decoding strings.
 */
struct code_decode {
	char	*cdc_msg;
	int	cdc_nsubcodes;
	char	**cdc_submsgs;
} code_decode[] = {
#define	SC(m)	sizeof (m) / sizeof (m[0]), m
	{"success",			SC(succ_msgs)},
	{"invalid command",		SC(icmd_msgs)},
	{"command aborted",		0, 0},
	{"unit offline",		SC(offl_msgs)},
	{"unit available",		0, 0},
	{"media format error",		SC(media_fmt_msgs)},
	{"write protected",		SC(wrprot_msgs)},
	{"compare error",		0, 0},
	{"data error",			SC(data_msgs)},
	{"host buffer access error",	SC(host_buffer_msgs)},
	{"controller error",		SC(cntlr_msgs)},
	{"drive error",			SC(drive_msgs)},
#undef SC
};

/*
 * Print the decoded error event from an MSCP error datagram.
 */
void
mscp_printevent(mp)
	struct mscp *mp;
{
	register int event = mp->mscp_event;
	register struct code_decode *cdc;
	int c, sc;
	char *cm, *scm;

	/*
	 * The code is the lower six bits of the event number (aka
	 * status).  If that is 6 (write protect), the subcode is in
	 * bits 12-15; otherwise, it is in bits 5-11.
	 * I WONDER WHAT THE OTHER BITS ARE FOR.  IT SURE WOULD BE
	 * NICE IF DEC SOLD DOCUMENTATION FOR THEIR OWN CONTROLLERS.
	 */
	c = event & M_ST_MASK;
	sc = (c != 6 ? event >> 5 : event >> 12) & 0x7ff;
	if (c >= sizeof code_decode / sizeof code_decode[0])
		cm = "- unknown code", scm = "??";
	else {
		cdc = &code_decode[c];
		cm = cdc->cdc_msg;
		if (sc >= cdc->cdc_nsubcodes)
			scm = unknown_msg;
		else
			scm = cdc->cdc_submsgs[sc];
	}
	printf(" %s (%s) (code %d, subcode %d)\n", cm, scm, c, sc);
}

static char *codemsg[16] = {
	"lbn", "code 1", "code 2", "code 3",
	"code 4", "code 5", "rbn", "code 7",
	"code 8", "code 9", "code 10", "code 11",
	"code 12", "code 13", "code 14", "code 15"
};
/*
 * Print the code and logical block number for an error packet.
 * THIS IS PROBABLY PECULIAR TO DISK DRIVES.  IT SURE WOULD BE
 * NICE IF DEC SOLD DOCUMENTATION FOR THEIR OWN CONTROLLERS.
 */
int
mscp_decodeerror(name, mp, mi)
	char *name;
	register struct mscp *mp;
	struct mscp_softc *mi;
{
	int issoft;
	/* 
	 * We will get three sdi errors of type 11 after autoconfig
	 * is finished; depending of searching for non-existing units.
	 * How can we avoid this???
	 */
	if (((mp->mscp_event & M_ST_MASK) == 11) && (mi->mi_ierr++ < 3))
		return 1;
	/*
	 * For bad blocks, mp->mscp_erd.erd_hdr identifies a code and
	 * the logical block number.  Code 0 is a regular block; code 6
	 * is a replacement block.  The remaining codes are currently
	 * undefined.  The code is in the upper four bits of the header
	 * (bits 0-27 are the lbn).
	 */
	issoft = mp->mscp_flags & (M_LF_SUCC | M_LF_CONT);
#define BADCODE(h)	(codemsg[(unsigned)(h) >> 28])
#define BADLBN(h)	((h) & 0xfffffff)

	printf("%s: drive %d %s error datagram%s:", name, mp->mscp_unit,
		issoft ? "soft" : "hard",
		mp->mscp_flags & M_LF_CONT ? " (continuing)" : "");
	switch (mp->mscp_format & 0377) {

	case M_FM_CTLRERR:	/* controller error */
		break;

	case M_FM_BUSADDR:	/* host memory access error */
		printf(" memory addr 0x%x:", (int)mp->mscp_erd.erd_busaddr);
		break;

	case M_FM_DISKTRN:
		printf(" unit %d: level %d retry %d, %s %d:",
			mp->mscp_unit,
			mp->mscp_erd.erd_level, mp->mscp_erd.erd_retry,
			BADCODE(mp->mscp_erd.erd_hdr),
			(int)BADLBN(mp->mscp_erd.erd_hdr));
		break;

	case M_FM_SDI:
		printf(" unit %d: %s %d:", mp->mscp_unit,
			BADCODE(mp->mscp_erd.erd_hdr),
			(int)BADLBN(mp->mscp_erd.erd_hdr));
		break;

	case M_FM_SMLDSK:
		printf(" unit %d: small disk error, cyl %d:",
			mp->mscp_unit, mp->mscp_erd.erd_sdecyl);
		break;

	case M_FM_TAPETRN:
		printf(" unit %d: tape transfer error, grp 0x%x event 0%o:",
		    mp->mscp_unit, mp->mscp_erd.erd_sdecyl, mp->mscp_event);
		break;

	case M_FM_STIERR:
		printf(" unit %d: STI error, event 0%o:", mp->mscp_unit,
		    mp->mscp_event);
		break;

	default:
		printf(" unit %d: unknown error, format 0x%x:",
			mp->mscp_unit, mp->mscp_format);
	}
	mscp_printevent(mp);
	return 0;
#undef BADCODE
#undef BADLBN
}