Return to idc.c CVS log

Up to [CSRG BSD Unix] / 43BSD / sys / stand

Annotation of 43BSD/sys/stand/idc.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982, 1986 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  *
        !             6:  *     @(#)idc.c       7.1 (Berkeley) 6/5/86
        !             7:  */
        !             8: 
        !             9: /*
        !            10:  * IDC (RB730)
        !            11:  */
        !            12: #include "../machine/pte.h"
        !            13: 
        !            14: #include "../h/param.h"
        !            15: #include "../h/inode.h"
        !            16: #include "../h/fs.h"
        !            17: 
        !            18: #include "../vaxuba/idcreg.h"
        !            19: #include "../vaxuba/ubareg.h"
        !            20: 
        !            21: #include "saio.h"
        !            22: #include "savax.h"
        !            23: 
        !            24: u_short        idcstd[] = { 0175606 };
        !            25: short  rb02_off[] = { 0, 400, 0, -1, -1, -1, -1, -1 };
        !            26: short  rb80_off[] = { 0, 37, 0, -1, -1, -1, 115, 305 };
        !            27: 
        !            28: int idc_type[4];
        !            29: 
        !            30: idcopen(io)
        !            31:        register struct iob *io;
        !            32: {
        !            33:        register struct idcdevice *idcaddr;
        !            34:        register int i;
        !            35: 
        !            36:        idcaddr = (struct idcdevice *)((caddr_t)ubauba(io->i_unit) + 0x200);
        !            37:        if (io->i_boff < 0 || io->i_boff > 7)
        !            38:                _stop("idc bad unit");
        !            39:        idcaddr->idcmpr = IDCGS_GETSTAT;
        !            40:        idcaddr->idccsr = IDC_GETSTAT|(io->i_unit<<8);
        !            41:        idcwait(idcaddr);
        !            42:        i = idcaddr->idcmpr;
        !            43:        idcaddr->idccsr = IDC_CRDY|(1<<(io->i_unit+16));
        !            44:        idcwait(idcaddr);
        !            45:        idcaddr->idccsr = (io->i_unit<<8)|IDC_RHDR;
        !            46:        idcwait(idcaddr);
        !            47:        if (idcaddr->idccsr & IDC_ERR) {
        !            48:                printf("idc error: idccsr %x\n", idcaddr->idccsr);
        !            49:                _stop("idc fatal error");
        !            50:        }
        !            51:        i = idcaddr->idcmpr;
        !            52:        i = idcaddr->idcmpr;
        !            53:        if (idcaddr->idccsr & IDC_R80) {
        !            54:                idc_type[io->i_unit] = 1;
        !            55:                io->i_boff = rb80_off[io->i_boff] * NRB80SECT * NRB80TRK;
        !            56:        } else {
        !            57:                idc_type[io->i_unit] = 0;
        !            58:                io->i_boff = rb02_off[io->i_boff] * NRB02SECT/2 * NRB02TRK;
        !            59:        }
        !            60:        if (io->i_boff < 0)
        !            61:                _stop("idc%d: bad unit type", io->i_unit);
        !            62: }
        !            63: 
        !            64: idcstrategy(io, func)
        !            65:        register struct iob *io;
        !            66: {
        !            67:        register struct idcdevice *idcaddr;
        !            68:        int com;
        !            69:        daddr_t bn;
        !            70:        short dn, cn, sn, tn;
        !            71:        short ccleft, thiscc = 0;
        !            72:        int ubinfo, errcnt = 0;
        !            73: 
        !            74:        idcaddr = (struct idcdevice *)((caddr_t)ubauba(io->i_unit) + 0x200);
        !            75:        ubinfo = ubasetup(io, 1);
        !            76:        bn = io->i_bn;
        !            77:        ccleft = io->i_cc;
        !            78: retry:
        !            79:        dn = io->i_unit;
        !            80:        if (idc_type[dn]) {
        !            81:                cn = bn/(NRB80SECT*NRB80TRK);
        !            82:                sn = bn%NRB80SECT;
        !            83:                tn = (bn / NRB80SECT) % NRB80TRK;
        !            84:                thiscc = (NRB80SECT - sn) * 512;
        !            85:        } else {
        !            86:                cn = 2*bn/(NRB02SECT*NRB02TRK);
        !            87:                sn = (2*bn)%NRB02SECT;
        !            88:                tn = (2*bn / NRB02SECT) % NRB02TRK;
        !            89:                thiscc = (NRB02SECT - sn) * 256;
        !            90:        }
        !            91:        thiscc = MIN(thiscc, ccleft);
        !            92:        ccleft -= thiscc;
        !            93:        idcaddr->idccsr = IDC_CRDY|IDC_SEEK|(dn<<8)|(1<<(dn+16));
        !            94:        idcaddr->idcdar = (cn<<16)|(tn<<8)|sn;
        !            95:        idcaddr->idccsr = IDC_SEEK|(dn<<8);
        !            96:        idcwait(idcaddr);
        !            97:        idcaddr->idccsr &= ~IDC_ATTN;
        !            98:        com = dn<<8;
        !            99:        if (func == READ)
        !           100:                com |= IDC_READ;
        !           101:        else
        !           102:                com |= IDC_WRITE;
        !           103:        idcaddr->idccsr = IDC_CRDY|com;
        !           104:        idcaddr->idcbar = ubinfo&0x3ffff;
        !           105:        idcaddr->idcbcr = -thiscc;
        !           106:        idcaddr->idcdar = (cn<<16)|(tn<<8)|sn;
        !           107:        idcaddr->idccsr = com;
        !           108:        idcwait(idcaddr);
        !           109:        if (idcaddr->idccsr & IDC_ERR) {
        !           110:                printf("idc%d error: (cyl,trk,sec)=(%d,%d,%d) csr=%b\n",
        !           111:                    dn, cn, tn, sn, idcaddr->idccsr, IDCCSR_BITS);
        !           112:                if (errcnt == 10) {
        !           113:                        printf("idc: unrecovered error\n");
        !           114:                        ubafree(io, ubinfo);
        !           115:                        return (-1);
        !           116:                }
        !           117:                errcnt++;
        !           118:                goto retry;
        !           119:        }
        !           120:        if (errcnt)
        !           121:                printf("idc: recovered by retry\n");
        !           122:        if (ccleft) {
        !           123:                bn += thiscc/NBPG;
        !           124:                ubinfo += thiscc;
        !           125:                goto retry;
        !           126:        }
        !           127:        ubafree(io, ubinfo);
        !           128:        return (io->i_cc);
        !           129: }
        !           130: 
        !           131: idcwait(idcaddr)
        !           132:        register struct idcdevice *idcaddr;
        !           133: {
        !           134:        register int i;
        !           135: 
        !           136:        while ((idcaddr->idccsr & (IDC_CRDY|IDC_DRDY)) != (IDC_CRDY|IDC_DRDY))
        !           137:                for (i = 10; i; i--)
        !           138:                        ;
        !           139: }
        !           140: 
        !           141: /*ARGSUSED*/
        !           142: idcioctl(io, cmd, arg)
        !           143:        struct iob *io;
        !           144:        int cmd;
        !           145:        caddr_t arg;
        !           146: {
        !           147: 
        !           148:        return (ECMD);
        !           149: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.