summaryrefslogtreecommitdiff
path: root/sys/dev/mscp
diff options
context:
space:
mode:
authorragge <ragge@NetBSD.org>1999-05-29 19:11:52 +0000
committerragge <ragge@NetBSD.org>1999-05-29 19:11:52 +0000
commitbf0ac446d2a60c7c76ea6e42fc4b60d47c9fab7f (patch)
treed01e36ce27e807eac89f2d0e519dd27e61eb7578 /sys/dev/mscp
parent29cdff1acd9aa06a295ff493e64f94651a3a31d7 (diff)
Copied from ../../arch/vax/mscp/mscp_subr.c,v
Diffstat (limited to 'sys/dev/mscp')
-rw-r--r--sys/dev/mscp/mscp_subr.c844
1 files changed, 844 insertions, 0 deletions
diff --git a/sys/dev/mscp/mscp_subr.c b/sys/dev/mscp/mscp_subr.c
new file mode 100644
index 00000000000..c7ea6db3dfd
--- /dev/null
+++ b/sys/dev/mscp/mscp_subr.c
@@ -0,0 +1,844 @@
+/* $NetBSD: mscp_subr.c,v 1.11 1999/05/29 19:11:52 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 *, struct cfdata *, 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 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;
+ struct cfdata *match;
+ void *aux;
+{
+ struct mscp_attach_args *ma = aux;
+
+#if NRA || NRX
+ 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 int)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;
+{
+ struct drive_attach_args *da = aux;
+ struct mscp *mp = da->da_mp;
+ int type = mp->mscp_guse.guse_mediaid;
+
+ if (name) {
+ printf("%c%c", MSCP_MID_CHAR(2, type), MSCP_MID_CHAR(1, type));
+ if (MSCP_MID_ECH(0, type))
+ printf("%c", MSCP_MID_CHAR(0, type));
+ printf("%d at %s drive %d", MSCP_MID_NUM(type), name,
+ mp->mscp_unit);
+ }
+ 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
+}