Return to vddc_ex.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / ioex

Annotation of cci/d/ioex/vddc_ex.c, revision 1.1

1.1     ! root        1: #include "vddc.h"
        !             2: 
        !             3: extern long Probe, iob0, iob1, iob2, iob3, iob4;
        !             4: extern struct DEVPAR devpar[];
        !             5: long v_err;
        !             6: long format_flag = 0;
        !             7: 
        !             8: /*     Routine to exercise VDDC
        !             9: */
        !            10: vddc_ex()
        !            11: {      register long unit, last_blk, nodr;
        !            12: 
        !            13:        writes("\n\t** VDDC test **\n");
        !            14:        format_flag = 0;
        !            15:        for (nodr=unit=0;devpar[unit].nocyl;unit++) {
        !            16:                if (devpar[unit].alive) {
        !            17:                        nodr++;
        !            18:                        if (format_flag) vddc_ctlr(FORMAT,unit);
        !            19:                        Probe = 1;
        !            20:                        last_blk = v_probe(unit);
        !            21:                        Probe = 0;
        !            22:                        if ( last_blk > 0) {
        !            23:                                v_ex1(1,unit,last_blk);
        !            24:                                v_ex1(2,unit,last_blk-2);
        !            25:                                v_ex1(3,unit,last_blk-3); }
        !            26:                        }
        !            27:                }
        !            28:        if (!nodr) {
        !            29:                writes("\nNo drive available...");
        !            30:                return; }
        !            31:        if (!v_err) writes("\nVDDC passed..\n");
        !            32:                else  writes("\nVDDC failed..\n");
        !            33: }
        !            34: 
        !            35: v_ex1(factor,sdev,blk)
        !            36: long factor, blk;
        !            37: char sdev;
        !            38: {      register long ix, pat, *sptr, *dptr, loop;
        !            39:        unsigned short *s, *d;
        !            40: 
        !            41: 
        !            42:        pat = 0xababab00;       /* Pattern */
        !            43:        sptr = &iob0;           /* Source buffer */
        !            44:        dptr = &iob3;           /* Destination buffer */
        !            45: 
        !            46: for(v_err=loop=0;loop<40;loop++)
        !            47:        {
        !            48:        /* initialize pattern in source buffer */
        !            49:        for (ix=0; ix<(BLKSIZ/4)*factor; ix++) { 
        !            50:                sptr[ix] = pat + ix;    /* init. pattern in source buffer */
        !            51:                dptr[ix] = 0;           /* Clear destination buffer */
        !            52:                }
        !            53:        /* Write 1 block of data */
        !            54:        if (vddc_op(WR_COMP,sdev,blk,factor,&iob0)==0) { v_err=1; return(0); }
        !            55: 
        !            56:        /* Read 1 block of data */
        !            57:        if (vddc_op(RD_DATA,sdev,blk,factor,&iob3)==0) { v_err=1; return(0); }
        !            58: 
        !            59:        s = (unsigned short *)&iob0;            /* Source buffer */
        !            60:        d = (unsigned short *)&iob3;            /* Destination buffer */
        !            61:        for (ix=0; ix<(BLKSIZ/2)*factor; ix++) {
        !            62:                if (s[ix] != d[ix]) {
        !            63:                        writes("\nExpected ");
        !            64:                        writeh(s[ix] & 0xffff);
        !            65:                        writes(" , actual "); writeh(d[ix] & 0xffff);
        !            66:                        writes(", address "); writeh(&d[ix]);
        !            67:                        v_err = 1;
        !            68:                        }       
        !            69:                }
        !            70:        if (v_err) loop = 0;    /* If error then loop forever */
        !            71:        }
        !            72: }
        !            73: 
        !            74: 
        !            75: /*     routine to probe VDDC disk 
        !            76: */
        !            77: v_probe(sdev)
        !            78: char sdev;
        !            79: {      register long *dptr, blk, inc;
        !            80: 
        !            81:        inc = 2000;
        !            82:        blk = 0;
        !            83:        while (inc != 0) {
        !            84:                for(blk += inc;;blk += inc) { /* Read 1 block of data */
        !            85:                        if (vddc_op(RD_DATA,sdev,blk,1,&iob0)==0) 
        !            86:                                { blk -= inc; break; }
        !            87:                        }
        !            88:                inc /= 2;
        !            89:                }
        !            90:        if (blk <= 0) {
        !            91:                writes("\nCannot probe "); writes(devpar[sdev].name);
        !            92:                return(0); }
        !            93:        writes("\n"); writes(devpar[sdev].name); writes(" has ");
        !            94:        writed((blk*1024)/1000); writes(" Kbytes.\n");
        !            95:        return(blk);
        !            96: 
        !            97: }

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