Return to ut.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxstand

Annotation of 43BSDTahoe/sys/vaxstand/ut.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982, 1986, 1988 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:  *     @(#)ut.c        7.5 (Berkeley) 7/9/88
        !             7:  */
        !             8: 
        !             9: /*
        !            10:  * SI Model 9700 -- emulates TU45 on the UNIBUS
        !            11:  */
        !            12: 
        !            13: #include "param.h"
        !            14: #include "inode.h"
        !            15: #include "fs.h"
        !            16: 
        !            17: #include "../vax/pte.h"
        !            18: 
        !            19: #include "../vaxuba/ubareg.h"
        !            20: #include "../vaxuba/utreg.h"
        !            21: 
        !            22: #include "saio.h"
        !            23: #include "savax.h"
        !            24: 
        !            25: #define        MASKREG(reg)    ((reg)&0xffff)
        !            26: 
        !            27: #define        MAXCTLR         1               /* all addresses must be specified */
        !            28: u_short        utstd[MAXCTLR] = { 0172440 };   /* non-standard */
        !            29: 
        !            30: utopen(io)
        !            31:        register struct iob *io;
        !            32: {
        !            33:        register int skip;
        !            34: 
        !            35:        if ((u_int)io->i_adapt >= nuba)
        !            36:                return (EADAPT);
        !            37:        if ((u_int)io->i_ctlr >= MAXCTLR)
        !            38:                return (ECTLR);
        !            39:        if (badaddr((char *)ubamem(io->i_unit, utstd[io->i_ctlr]), sizeof(short)))
        !            40:                return (ENXIO);
        !            41:        utstrategy(io, UT_REW);
        !            42:        for (skip = io->i_part; skip--;)
        !            43:                utstrategy(io, UT_SFORWF);
        !            44:        return (0);
        !            45: }
        !            46: 
        !            47: utclose(io)
        !            48:        register struct iob *io;
        !            49: {
        !            50:        utstrategy(io, UT_REW);
        !            51: }
        !            52: 
        !            53: #define        UTWAIT(addr) { \
        !            54:        do \
        !            55:                word = addr->utcs1; \
        !            56:        while((word&UT_RDY) == 0); \
        !            57: }
        !            58: 
        !            59: utstrategy(io, func)
        !            60:        register struct iob *io;
        !            61: {
        !            62:        register struct utdevice *addr;
        !            63:        register u_short word;
        !            64:        register int errcnt;
        !            65:        int info, resid;
        !            66:        u_short dens;
        !            67: 
        !            68:        addr = (struct utdevice *)ubamem(io->i_unit, utstd[io->i_ctlr]);
        !            69:        dens = io->i_unit | PDP11FMT | UT_PE;
        !            70:        errcnt = 0;
        !            71: retry:
        !            72:        utquiet(addr);
        !            73:        addr->uttc = dens;
        !            74:        info = ubasetup(io, 1);
        !            75:        addr->utwc = -((io->i_cc+1) >> 1);
        !            76:        addr->utfc = -io->i_cc;
        !            77:        if (func == READ) {
        !            78:                addr->utba = info;
        !            79:                addr->utcs1 = UT_RCOM | ((info>>8) & 0x30) | UT_GO;
        !            80:        } else if (func == WRITE) {
        !            81:                addr->utba = info;
        !            82:                addr->utcs1 = UT_WCOM | ((info>>8) & 0x30) | UT_GO;
        !            83:        } else if (func == UT_SREV) {
        !            84:                addr->utcs1 = UT_SREV | UT_GO;
        !            85:                return (0);
        !            86:        } else
        !            87:                addr->utcs1 = func | UT_GO;
        !            88:        UTWAIT(addr);
        !            89:        ubafree(io, info);
        !            90:        word = addr->utds;
        !            91:        if (word&(UTDS_EOT|UTDS_TM)) {
        !            92:                addr->utcs1 = UT_CLEAR | UT_GO;
        !            93:                goto done;
        !            94:        }
        !            95:        if ((word&UTDS_ERR) || (addr->utcs1&UT_TRE)) {
        !            96:                printf("ut error: cs1=%b er=%b cs2=%b ds=%b",
        !            97:                  addr->utcs1, UT_BITS, addr->uter, UTER_BITS,
        !            98:                  addr->utcs2, UTCS2_BITS, word, UTDS_BITS);
        !            99:                if (errcnt++ == 10) {
        !           100:                        printf("ut: unrecovered error\n");
        !           101:                        return (-1);
        !           102:                }
        !           103:                if (addr->utcs1&UT_TRE)
        !           104:                        addr->utcs2 |= UTCS2_CLR;
        !           105:                addr->utcs1 = UT_CLEAR | UT_GO;
        !           106:                utstrategy(io, UT_SREV);
        !           107:                utquiet(addr);
        !           108:                if (func == WRITE) {
        !           109:                        addr->utcs1 = UT_ERASE | UT_GO;
        !           110:                        UTWAIT(addr);
        !           111:                }
        !           112:                goto retry;
        !           113:        }
        !           114:        if (errcnt)
        !           115:                printf("ut: recovered by retry\n");
        !           116: done:
        !           117:        if (func == READ) {
        !           118:                resid = 0;
        !           119:                if (io->i_cc > MASKREG(addr->utfc))
        !           120:                        resid = io->i_cc - MASKREG(addr->utfc);
        !           121:        } else
        !           122:                resid = MASKREG(-addr->utfc);
        !           123:        return (io->i_cc - resid);
        !           124: }
        !           125: 
        !           126: static
        !           127: utquiet(addr)
        !           128:        register struct utdevice *addr;
        !           129: {
        !           130:        register u_short word;
        !           131: 
        !           132:        UTWAIT(addr);
        !           133:        do
        !           134:                word = addr->utds;
        !           135:        while ((word&UTDS_DRY) == 0 && (word&UTDS_PIP));
        !           136: }

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