Return to rk.c CVS log

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

Annotation of 42BSD/sys/stand/rk.c, revision 1.1.1.1

1.1       root        1: /*     rk.c    6.1     83/07/29        */
                      2: 
                      3: /*
                      4:  * RK611/RK07
                      5:  */
                      6: #include "../machine/pte.h"
                      7: 
                      8: #include "../h/param.h"
                      9: #include "../h/inode.h"
                     10: #include "../h/fs.h"
                     11: 
                     12: #include "../vaxuba/ubareg.h"
                     13: #include "../vaxuba/rkreg.h"
                     14: 
                     15: #include "saio.h"
                     16: #include "savax.h"
                     17: 
                     18: u_short        rkstd[] = { 0777440 };
                     19: short  rk_off[] = { 0, 241, 0, -1, -1, -1, 393, -1 };
                     20: 
                     21: rkopen(io)
                     22:        register struct iob *io;
                     23: {
                     24:        register struct rkdevice *rkaddr = (struct rkdevice *)ubamem(io->i_unit, rkstd[0]);
                     25: 
                     26:        if (rk_off[io->i_boff] == -1 ||
                     27:            io->i_boff < 0 || io->i_boff > 7)
                     28:                _stop("rk bad unit");
                     29:        io->i_boff = rk_off[io->i_boff] * NRKSECT*NRKTRK;
                     30:        rkaddr->rkcs2 = RKCS2_SCLR;
                     31:        rkwait(rkaddr);
                     32: }
                     33: 
                     34: rkstrategy(io, func)
                     35:        register struct iob *io;
                     36: {
                     37:        register struct rkdevice *rkaddr = (struct rkdevice *)ubamem(io->i_unit, rkstd[0]);
                     38:        int com;
                     39:        daddr_t bn;
                     40:        short dn, cn, sn, tn;
                     41:        int ubinfo, errcnt = 0;
                     42: 
                     43: retry:
                     44:        ubinfo = ubasetup(io, 1);
                     45:        bn = io->i_bn;
                     46:        dn = io->i_unit;
                     47:        cn = bn/(NRKSECT*NRKTRK);
                     48:        sn = bn%NRKSECT;
                     49:        tn = (bn / NRKSECT) % NRKTRK;
                     50:        rkaddr->rkcs2 = dn;
                     51:        rkaddr->rkcs1 = RK_CDT|RK_PACK|RK_GO;
                     52:        rkwait(rkaddr);
                     53:        rkaddr->rkcs1 = RK_CDT|RK_DCLR|RK_GO;
                     54:        rkwait(rkaddr);
                     55:        rkaddr->rkda = sn | (tn << 8);
                     56:        rkaddr->rkcyl = cn;
                     57:        rkaddr->rkba = ubinfo;
                     58:        rkaddr->rkwc = -(io->i_cc >> 1);
                     59:        com = RK_CDT|((ubinfo>>8)&0x300)|RK_GO;
                     60:        if (func == READ)
                     61:                com |= RK_READ;
                     62:        else
                     63:                com |= RK_WRITE;
                     64:        rkaddr->rkcs1 = com;
                     65:        rkwait(rkaddr);
                     66:        while ((rkaddr->rkds & RKDS_SVAL) == 0)
                     67:                ;
                     68:        ubafree(io, ubinfo);
                     69:        if (rkaddr->rkcs1 & RK_CERR) {
                     70:                printf("rk error: (cyl,trk,sec)=(%d,%d,%d) cs2=%b er=%b\n",
                     71:                    cn, tn, sn, rkaddr->rkcs2, RKCS2_BITS,
                     72:                    rkaddr->rker, RKER_BITS);
                     73:                rkaddr->rkcs1 = RK_CDT|RK_DCLR|RK_GO;
                     74:                rkwait(rkaddr);
                     75:                if (errcnt == 10) {
                     76:                        printf("rk: unrecovered error\n");
                     77:                        return (-1);
                     78:                }
                     79:                errcnt++;
                     80:                goto retry;
                     81:        }
                     82:        if (errcnt)
                     83:                printf("rk: recovered by retry\n");
                     84:        return (io->i_cc);
                     85: }
                     86: 
                     87: rkwait(rkaddr)
                     88:        register struct rkdevice *rkaddr;
                     89: {
                     90: 
                     91:        while ((rkaddr->rkcs1 & RK_CRDY) == 0)
                     92:                ;
                     93: }
                     94: 
                     95: /*ARGSUSED*/
                     96: rkioctl(io, cmd, arg)
                     97:        struct iob *io;
                     98:        int cmd;
                     99:        caddr_t arg;
                    100: {
                    101: 
                    102:        return (ECMD);
                    103: }

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