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

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.