usr/src/sys/tahoe/stand/vd.c

/*      vd.c    7.5     86/12/19        */

/*
 * Stand alone driver for the VDDC controller
 *      TAHOE Version, Oct 1983.
 */
#include "../machine/mtpr.h"

#include "param.h"
#include "inode.h"
#include "fs.h"
#define VDGENDATA 1
#include "../tahoevba/vdreg.h"
#undef  VDGENDATA
#include "../tahoevba/vbaparam.h"
#include "saio.h"

#define NVD             4                       /* Max number of controllers */
#define VDUNIT(x)       (minor(x) & 0x3)
#define VDCTLR(x)       (minor(x) >> 2)

fmt_mdcb        mdcb;
fmt_dcb         dcb;

/*
 * Drive specific information.
 */
struct dkinfo {
        char    configured;
        fs_tab  info;
} dkinfo[NVD][16];

/*
 * Controller specific information.
 */
struct vdinfo {
        u_short vd_flags;
#define VDF_INIT        0x1             /* controller initialized */
#define VDF_BUSY        0x2             /* controller running */
        u_short vd_type;                /* smd or smde */
        char    *vd_name;
} vdinfo[NVD];

static char     junk[1024];

#define VDADDR(ctlr)    ((cdr *)vddcaddr[(ctlr)])

vdopen(io)
        register struct iob *io;
{
        register int ctlr = VDCTLR(io->i_unit), unit = VDUNIT(io->i_unit);
        struct vdinfo *vd;
        register int i, j;

        /* Make sure controller number is in range */
        if (ctlr >= NVD) {
                printf(
                    "dk%d: invalid controller (only configured for %d vd's)\n",
                    io->i_unit, NVD);
                _stop("");
        }
        /* check file system for validity */
        if ((unsigned)io->i_boff >= 8) {
                printf("dk%d: invalid partition number (%d)\n",
                    io->i_unit, io->i_boff);
                _stop("");
        }
        vd = &vdinfo[ctlr];
        if ((vd->vd_flags&VDF_INIT) == 0) {
                vdinit(io);     /* initialize controller/drive */
                vd->vd_flags |= VDF_INIT;
                for (j = 0; j < 16; j++)
                        dkinfo[ctlr][j].configured = 0;
        }
        if (!dkinfo[ctlr][unit].configured) {
                vdconfigure_drive(io);
                dkinfo[ctlr][unit].configured = 1;
        }
        io->i_boff = dkinfo[ctlr][unit].info.partition[io->i_boff].par_start;
}

vdinit(io)
        register struct iob *io;
{
        register int ctlr = VDCTLR(io->i_unit), unit = VDUNIT(io->i_unit);
        register cdr *ctlr_addr = VDADDR(ctlr);
        register struct vdinfo *vd = &vdinfo[ctlr];

        /* Check to see if controller is really there */
        if (badaddr(ctlr_addr, 2)) {
                printf("dk%d: vd%d csr doesn't respond\n", io->i_unit, ctlr);
                _stop("");
        }
        /* Probe further to find what kind of controller it is */
        ctlr_addr->cdr_reset = 0xffffffff;
        DELAY(1000000);
        if (ctlr_addr->cdr_reset != 0xffffffff) {
                vd->vd_type = SMDCTLR;
                vd->vd_name = "smd";
                DELAY(1000000);
        } else {
                vd->vd_type = SMD_ECTLR;
                vd->vd_name = "smde";
                ctlr_addr->cdr_reserved = 0x0;
                DELAY(3000000);
        }
        if (vd->vd_type == SMD_ECTLR) {
                ctlr_addr->cdr_csr =  0;
                ctlr_addr->mdcb_tcf = AM_ENPDA;
                ctlr_addr->dcb_tcf = AM_ENPDA;
                ctlr_addr->trail_tcf = AM_ENPDA;
                ctlr_addr->data_tcf = AM_ENPDA;
                ctlr_addr->cdr_ccf = CCF_STS | XMD_32BIT | BSZ_16WRD |
                    CCF_ENP | CCF_EPE /* | CCF_EDE */ | CCF_ECE | CCF_ERR;
        }
        if (vdnotrailer(io, INIT, 8) & HRDERR) {
                vdprint_error(io->i_unit, "init error",
                    dcb.operrsta, dcb.err_code);
                _stop("");
        }
        if (vdnotrailer(io, DIAG, 8) & HRDERR) {
                vdprint_error(io->i_unit, "diagnostic error",
                    dcb.operrsta, dcb.err_code);
                _stop("");
        }
}

vdconfigure_drive(io)
        register struct iob *io;
{
        register int ctlr = VDCTLR(io->i_unit), unit = VDUNIT(io->i_unit);
        register fs_tab *file_sys;
        register struct dkinfo *dk = &dkinfo[ctlr][unit];
        dskadr daddr;
        register int i;

        for (i = 0; i < nvddrv; i++) {
                dk->info = vdst[i];
                if (vdinfo[ctlr].vd_type == SMDCTLR)
                        if (dk->info.nsec != 32)
                                continue;
                vdconfigure(io, 0);
                daddr.cylinder = dk->info.ncyl - 2;
                daddr.track = dk->info.ntrak - 1;
                daddr.sector = dk->info.nsec - 1;
                io->i_ma = junk;
                io->i_cc = dk->info.secsize;
                if ((vdaccess(io, &daddr, RD) & HRDERR) == 0)
                        return;
        }
        printf("dk%d: unknown drive type\n", io->i_unit);
        _stop("");
}

vdstart_drive(io)
        register struct iob *io;
{
        register int ctlr = VDCTLR(io->i_unit), unit = VDUNIT(io->i_unit);
        int ounit = io->i_unit;

        io->i_unit &= ~3;
        if (vdnotrailer(io, VDSTART, 62) & HRDERR) {
                vdprint_error(io->i_unit, "start error",
                    dcb.operrsta, dcb.err_code);
                _stop("");
        }
        vdinfo[ctlr].vd_flags |= VDF_BUSY;
        io->i_unit = ounit;
        DELAY(62000000);
}

/*
 * This routine actually configures a particular drive.
 *
 * If the controller is an SMD/E controller then the number of sectors per
 * track is loaded into the appropriate register, otherwise it is left
 * alone because the old SMD controller requires a constant 32 sectors
 * per track for it's drives. (an error would be returned if the value is
 * loaded.)
 */
vdconfigure(io, pass)
        register struct iob *io;
        int pass;
{
        register int ctlr = VDCTLR(io->i_unit), unit = VDUNIT(io->i_unit);
        register cdr *ctlr_addr = VDADDR(ctlr);

        dcb.opcode = RSTCFG;            /* command */
        dcb.intflg = NOINT;
        dcb.nxtdcb = (fmt_dcb *)0;      /* end of chain */
        dcb.operrsta  = 0;
        dcb.devselect = (char)unit;
        dcb.trail.rstrail.ncyl = dkinfo[ctlr][unit].info.ncyl;
        dcb.trail.rstrail.nsurfaces = dkinfo[ctlr][unit].info.ntrak;
        if (vdinfo[ctlr].vd_type == SMD_ECTLR) {
                dcb.trailcnt = (char)5;
                dcb.trail.rstrail.nsectors = dkinfo[ctlr][unit].info.nsec;
                dcb.trail.rstrail.slip_sec = dkinfo[ctlr][unit].info.nslip;
                dcb.trail.rstrail.recovery = 0x18f;
        } else
                dcb.trailcnt = (char)2;
        mdcb.firstdcb = &dcb;
        mdcb.vddcstat = 0;
        VDDC_ATTENTION(ctlr_addr, &mdcb, vdinfo[ctlr].vd_type);
        if (!vdpoll(ctlr_addr,&dcb,10,vdinfo[ctlr].vd_type)) {
                if (pass == 0) {
                        VDDC_RESET(ctlr_addr, vdinfo[ctlr].vd_type);
                        vdconfigure(io, 1);
                } else
                        _stop(" during drive configuration.\n");
        }
        if (dcb.operrsta & HRDERR) {
                if (vdinfo[ctlr].vd_type == SMD_ECTLR &&
                    (ctlr_addr->cdr_status[io->i_unit] & STA_US) == 0) {
                        printf("dk%d: ", io->i_unit);
                        _stop("nonexistent drive");
                }
                if ((dcb.operrsta & (NOTCYLERR|DRVNRDY)) == 0) {
                        vdprint_error(io->i_unit, "configuration error",
                            dcb.operrsta, dcb.err_code);
                        _stop("");
                }
                if (pass == 0) {
                        vdstart_drive(io);
                        vdconfigure(io, 1);
                }
        }
}

/*
 * Strategy is called to do the actual I/O to the disk drives.
 *
 * Some simple checks are made to make sure we don't do anything rediculous,
 * If everything is sane then the request is issued.
 *
 * If no errors occured then the original byte count is returned,
 * otherwise -1 is returned to indicate an error occured.
 */
vdstrategy(io, func)
        register struct iob *io;
        register int func;
{
        dskadr daddr;
        register int ctlr = VDCTLR(io->i_unit), unit = VDUNIT(io->i_unit);
        register fs_tab *u_info = &dkinfo[ctlr][unit].info;
        register int op = (func == READ) ? RD : WD;
        register int blk;

        if (io->i_cc == 0 || io->i_cc > 65535) {
                printf("dk%d: invalid transfer size %d\n", io->i_unit,
                    io->i_cc);
                _stop("");
        }
        blk = io->i_bn * DEV_BSIZE / u_info->secsize;
        daddr.sector = blk % u_info->nsec;
        daddr.track = (blk / u_info->nsec) % u_info->ntrak;
        daddr.cylinder = (blk/u_info->nsec) / u_info->ntrak;
        if (vdaccess(io, &daddr, op) & HRDERR) {
                vdprint_error(io->i_unit, "i/o error", dcb.operrsta,
                    dcb.err_code);
                io->i_error = EIO;
                return (-1);
        }
        mtpr(PADC, 0);
        return (io->i_cc);
}

vdprint_error(unit, str, status, smde_status)
        int unit;
        char *str;
        u_long status;
        u_long smde_status;
{
        register struct vdstatus *sp;

        printf("dk%d: %s; status %b", unit, str, status, ERRBITS);
        if (smde_status)
                printf(", code %x", smde_status);
        printf("\n");
}

vdnotrailer(io, function, time)
        register struct iob *io;
        register int function, time;
{
        register int ctlr = VDCTLR(io->i_unit);
        register cdr *ctlr_addr = VDADDR(ctlr);

        dcb.opcode = function;          /* command */
        dcb.intflg = NOINT;
        dcb.nxtdcb = (fmt_dcb *)0;      /* end of chain */
        dcb.operrsta  = 0;
        dcb.devselect = (char)VDUNIT(io->i_unit);
        dcb.trailcnt = (char)0;
        mdcb.firstdcb = &dcb;
        mdcb.vddcstat = 0;
        VDDC_ATTENTION(ctlr_addr, &mdcb, vdinfo[ctlr].vd_type);
        if (!vdpoll(ctlr_addr, &dcb, time, vdinfo[ctlr].vd_type))
                _stop(" during initialization operation.\n");
        return dcb.operrsta;
}

vdaccess(io, daddr, func)
        register struct iob *io;
        dskadr *daddr;
        int func;
{
        register int ctlr = VDCTLR(io->i_unit);
        register cdr *ctlr_addr = VDADDR(ctlr);

        dcb.opcode = (short)func;       /* format sector command */
        dcb.intflg = NOINT;
        dcb.nxtdcb = (fmt_dcb *)0;      /* end of chain */
        dcb.operrsta  = 0;
        dcb.devselect = (char)VDUNIT(io->i_unit);
        dcb.trailcnt = (char)(sizeof(trrw) / 4);
        dcb.trail.rwtrail.memadr = io->i_ma;
        dcb.trail.rwtrail.wcount = ((io->i_cc + 1) / sizeof(short));
        dcb.trail.rwtrail.disk.cylinder = daddr->cylinder;
        dcb.trail.rwtrail.disk.track = daddr->track;
        dcb.trail.rwtrail.disk.sector = daddr->sector;
        mdcb.firstdcb = &dcb;
        mdcb.vddcstat = 0;
        VDDC_ATTENTION(ctlr_addr, &mdcb, vdinfo[ctlr].vd_type);
        if (!vdpoll(ctlr_addr, &dcb, 60, vdinfo[ctlr].vd_type))
                _stop(" during i/o operation.\n");
        return (dcb.operrsta);
}

/*
 * Dump the MDCB and DCB for diagnostic purposes.  This
 * routine is called whenever a fatal error is encountered.
 */
vdprintdcb(ptr)
        register long *ptr;
{
        register long i, trailer_count;

        printf("mdcb: %lx %lx %lx %lx\n", ptr[0], ptr[1], ptr[2], ptr[3]);
        if (ptr = (long *)*ptr) {
                printf("dcb:");
                trailer_count = ptr[3] & 0xff;
                for (i=0; i<7+trailer_count; i++) {
                        uncache(&ptr[i]);
                        printf("  %lx", ptr[i]);
                }
        }
        printf("\n");
        DELAY(5000000);
}

/*
 * Poll controller until operation completes
 * or timeout expires.
 */
vdpoll(addr, dcb, t, type)
        register cdr *addr;
        register fmt_dcb *dcb;
        register int t, type;
{

        t *= 1000;
        for (;;) {
                uncache(&dcb->operrsta);
                if (dcb->operrsta & (DCBCMP|DCBABT))
                        break;
                if (--t <= 0) {
                        printf("vd: controller timeout");
                        VDDC_ABORT(addr, type);
                        DELAY(30000);
                        uncache(&dcb->operrsta);
                        return (0);
                }
                DELAY(1000);
        }
        if (type == SMD_ECTLR) {
                for (;;) {
                        uncache(&addr->cdr_csr);
                        if ((addr->cdr_csr & CS_GO) == 0)
                                break;
                        DELAY(50);
                }
                DELAY(300);
                uncache(&dcb->err_code);
        }
        DELAY(200);
        uncache(&dcb->operrsta);
        return (1);
}