/*      $NetBSD: mscp_subr.c,v 1.49 2024/02/10 08:24:51 andvar Exp $    */
/*
 * 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. 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
 */

/*
 * Copyright (c) 1996 Ludd, University of Lule}, Sweden.
 *
 * 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/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: mscp_subr.c,v 1.49 2024/02/10 08:24:51 andvar Exp $");

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

#include <sys/bus.h>
#include <machine/sid.h>

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

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

#define b_forw  b_hash.le_next

int     mscp_match(device_t, cfdata_t, void *);
void    mscp_attach(device_t, device_t, void *);
void    mscp_start(struct mscp_softc *);
int     mscp_init(struct mscp_softc *);
void    mscp_initds(struct mscp_softc *);
int     mscp_waitstep(struct mscp_softc *, int, int);

CFATTACH_DECL_NEW(mscpbus, sizeof(struct mscp_softc),
    mscp_match, mscp_attach, NULL, NULL);

#define READ_SA         (bus_space_read_2(mi->mi_iot, mi->mi_sah, 0))
#define READ_IP         (bus_space_read_2(mi->mi_iot, mi->mi_iph, 0))
#define WRITE_IP(x)     bus_space_write_2(mi->mi_iot, mi->mi_iph, 0, (x))
#define WRITE_SW(x)     bus_space_write_2(mi->mi_iot, mi->mi_swh, 0, (x))

struct  mscp mscp_cold_reply;
int          mscp_cold_unit;

#define NITEMS          4

static inline void
mscp_free_workitems(struct mscp_softc *mi)
{
        struct mscp_work *mw;

        while (!SLIST_EMPTY(&mi->mi_freelist)) {
                mw = SLIST_FIRST(&mi->mi_freelist);
                SLIST_REMOVE_HEAD(&mi->mi_freelist, mw_list);
                kmem_free(mw, sizeof(*mw));
        }
}

/*
 * 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(struct mscp_softc *mi, int mask, int result)
{
        int     status = 1;

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

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

#if NRA || NRACD || 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(device_t parent, device_t self, void *aux)
{
        struct  mscp_attach_args *ma = aux;
        struct  mscp_softc *mi = device_private(self);
        struct mscp *mp2;
        volatile struct mscp *mp;
        volatile int i;
        int     timeout, error, unit;

        mi->mi_dev = self;
        mi->mi_mc = ma->ma_mc;
        mi->mi_me = NULL;
        mi->mi_type = ma->ma_type;
        mi->mi_uda = ma->ma_uda;
        mi->mi_dmat = ma->ma_dmat;
        mi->mi_dmam = ma->ma_dmam;
        mi->mi_iot = ma->ma_iot;
        mi->mi_iph = ma->ma_iph;
        mi->mi_sah = ma->ma_sah;
        mi->mi_swh = ma->ma_swh;
        mi->mi_ivec = ma->ma_ivec;
        mi->mi_adapnr = ma->ma_adapnr;
        mi->mi_ctlrnr = ma->ma_ctlrnr;
        *ma->ma_softc = mi;

        mutex_init(&mi->mi_mtx, MUTEX_DEFAULT, IPL_VM);
        SLIST_INIT(&mi->mi_freelist);

        error = workqueue_create(&mi->mi_wq, "mscp_wq", mscp_worker, NULL,
            PRI_NONE, IPL_VM, 0);
        if (error != 0) {
                aprint_error_dev(mi->mi_dev, "could not create workqueue");
                return;
        }

        /* Stick some items on the free list to be used in autoconf */
        for (i = 0; i < NITEMS; i++) {
                struct mscp_work *mw;

                mw = kmem_zalloc(sizeof(*mw), KM_SLEEP);
                SLIST_INSERT_HEAD(&mi->mi_freelist, mw, mw_list);
        }

        /*
         * 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;
        bufq_alloc(&mi->mi_resq, "fcfs", 0);

        if (mscp_init(mi)) {
                aprint_error_dev(mi->mi_dev, "can't init, controller hung\n");
                return;
        }
        for (i = 0; i < NCMD; i++) {
                mi->mi_mxiuse |= (1 << i);
                if (bus_dmamap_create(mi->mi_dmat, (64*1024), 16, (64*1024),
                    0, BUS_DMA_NOWAIT, &mi->mi_xi[i].mxi_dmam)) {
                        printf("Couldn't alloc dmamap %d\n", i);
                        return;
                }
        }


#if NRA || NRACD || NRX
        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.
         */
        for (unit = 0; unit <= MSCP_MAX_UNIT; ++unit) {
                mp = mscp_getcp(mi, MSCP_DONTWAIT);
                if (mp == NULL)
                        panic("mscpattach: no packets");
                mp->mscp_opcode = M_OP_GETUNITST;
                mp->mscp_unit = unit;
                mp->mscp_modifier = M_GUM_NEXTUNIT;
                *mp->mscp_addr |= MSCP_OWN | MSCP_INT;
                mscp_cold_reply.mscp_opcode = 0;
                mscp_cold_unit = mp->mscp_unit;

                i = bus_space_read_2(mi->mi_iot, mi->mi_iph, 0);
                mp = &mscp_cold_reply;
                timeout = 1000;

                while (!mp->mscp_opcode) {
                        if ( --timeout == 0) {
                                printf("%s: no Get Unit Status response\n",
                                    device_xname(mi->mi_dev));
                                return;
                        }
                        DELAY(10000);
                }

                /*
                 * Got a slave response.  If the unit is there, use it.
                 */

                /*
                 * If we get a lower number, we have circulated around all
                 * devices and are finished, otherwise try to find next unit.
                 */
                if (mp->mscp_unit < unit)
                        return;
                /*
                 * If a higher number, use it to skip non-present devices
                 */
                if (mp->mscp_unit > unit)
                        unit = mp->mscp_unit;

                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;
                                break; /* return */

                        case M_OFFLINE_UNMOUNTED:
                                /*
                                 * The drive is not spun up.  Use it anyway.
                                 *
                                 * N.B.: this seems to be a common occurrence
                                 * 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 unusable.
                                 */
                                printf("%s: unit %d off line: ",
                                    device_xname(mi->mi_dev), mp->mscp_unit);
                                mp2 = __UNVOLATILE(mp);
                                mscp_printevent(mp2);
                                break;
                        }
                        break;

                default:
                        aprint_error_dev(mi->mi_dev,
                            "unable to get unit status: ");
                        mscp_printevent(__UNVOLATILE(mp));
                        return;
                }
        }
}


/*
 * 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(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 indices.
         */
        mi->mi_cmd.mri_next = 0;
        mi->mi_rsp.mri_next = 0;

        mi->mi_flags |= MSC_IGNOREINTR;

        if ((mi->mi_type & MSCPBUS_KDB) == 0)
                WRITE_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 (READ_SA & MP_ERR) {
                (*mi->mi_mc->mc_saerror)(device_parent(mi->mi_dev), 0);
                return 1;
        }

        /* step1 */
        WRITE_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)(device_parent(mi->mi_dev), 0);
                return 1;
        }

        /* step2 */
        WRITE_SW(((mi->mi_dmam->dm_segs[0].ds_addr & 0xffff) +
            offsetof(struct mscp_pack, 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)(device_parent(mi->mi_dev), 0);
                return 1;
        }

        /* step3 */
        WRITE_SW((mi->mi_dmam->dm_segs[0].ds_addr >> 16));
        status = mscp_waitstep(mi, STEP3MASK, STEP3GOOD);
        if (status == 0) {
                (*mi->mi_mc->mc_saerror)(device_parent(mi->mi_dev), 0);
                return 1;
        }
        i = READ_SA & 0377;
        printf(": version %d model %d\n", i & 15, i >> 4);

#define BURST 4 /* XXX */
        if (mi->mi_type & MSCPBUS_UDA) {
                WRITE_SW(MP_GO | (BURST - 1) << 2);
                printf("%s: DMA burst size set to %d\n",
                    device_xname(mi->mi_dev), BURST);
        }
        WRITE_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;
        READ_IP;

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

/*
 * Initialise the various data structures that control the mscp protocol.
 */
void
mscp_initds(struct mscp_softc *mi)
{
        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 |
                    (mi->mi_dmam->dm_segs[0].ds_addr +
                    offsetof(struct mscp_pack, 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 |
                    (mi->mi_dmam->dm_segs[0].ds_addr +
                    offsetof(struct mscp_pack, 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;
        }
}

static  void mscp_kickaway(struct mscp_softc *);

void
mscp_intr(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 request, try them now.
         */
        if (bufq_peek(mi->mi_resq))
                mscp_kickaway(mi);
}

int
mscp_print(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) {
                aprint_normal("%c%c", MSCP_MID_CHAR(2, type),
                    MSCP_MID_CHAR(1, type));
                if (MSCP_MID_ECH(0, type))
                        aprint_normal("%c", MSCP_MID_CHAR(0, type));
                aprint_normal("%d at %s drive %d", MSCP_MID_NUM(type), name,
                    mp->mscp_unit);
        }
        return UNCONF;
}

/*
 * common strategy routine for all types of MSCP devices.
 */
void
mscp_strategy(struct buf *bp, device_t usc)
{
        struct  mscp_softc *mi = device_private(usc);
        int s = spluba();

        bufq_put(mi->mi_resq, bp);
        mscp_kickaway(mi);
        splx(s);
}


void
mscp_kickaway(struct mscp_softc *mi)
{
        struct buf *bp;
        struct  mscp *mp;
        int next;

        while ((bp = bufq_peek(mi->mi_resq)) != NULL) {
                /*
                 * 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",
                                    device_xname(device_parent(mi->mi_dev)));
                        /*
                         * By some (strange) reason we didn't get a MSCP packet.
                         * Just return and wait for free packets.
                         */
                        return;
                }

                if ((next = (ffs(mi->mi_mxiuse) - 1)) < 0)
                        panic("no mxi buffers");
                mi->mi_mxiuse &= ~(1 << next);
                if (mi->mi_xi[next].mxi_inuse)
                        panic("mxi inuse");
                /*
                 * 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;
                mp->mscp_cmdref = next;
                mi->mi_xi[next].mxi_bp = bp;
                mi->mi_xi[next].mxi_mp = mp;
                mi->mi_xi[next].mxi_inuse = 1;
                bp->b_resid = next;
                (*mi->mi_me->me_fillin)(bp, mp);
                (*mi->mi_mc->mc_go)(device_parent(mi->mi_dev),
                    &mi->mi_xi[next]);
                (void)bufq_get(mi->mi_resq);
        }
}

void
mscp_dgo(struct mscp_softc *mi, struct mscp_xi *mxi)
{
        struct  mscp *mp;

        /*
         * Fill in the MSCP packet and move the buffer to the I/O wait queue.
         */
        mp = mxi->mxi_mp;
        mp->mscp_seq.seq_buffer = mxi->mxi_dmam->dm_segs[0].ds_addr;

        *mp->mscp_addr |= MSCP_OWN | MSCP_INT;
        READ_IP;
}

#ifdef DIAGNOSTIC
/*
 * Dump the entire contents of an MSCP packet in hex.  Mainly useful
 * for debugging....
 */
void
mscp_hexdump(struct mscp *mp)
{
        long *p = (long *) mp;
        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 const 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 const char *icmd_msgs[] = {
        "invalid msg length",   /* 0 = Invalid Message Length */
};

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

/*
 * Subcodes for Unit Offline (3)
 */
static const 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 const 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 const 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 const 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 const 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 const char *cntlr_msgs[] = {
        unknown_msg,
        "serdes overrun",       /* 1 = Serialiser/Deserialiser Overrun */
        "edc",                  /* 2 = Error Detection Code? */
        "inconsistent internal data struct",/* 3 = Internal Error */
};

/*
 * Subcodes for Drive Error (11)
 */
static const 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 {
        const char      *cdc_msg;
        int     cdc_nsubcodes;
        const 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(struct mscp *mp)
{
        int event = mp->mscp_event;
        struct code_decode *cdc;
        int c, sc;
        const 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 const 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(const char *name, 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
}