Return to vddc_ex.c CVS log

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

Annotation of cci/d/pits/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: extern struct DA VDDCBASE [];
                      6: extern int type, cont;
                      7: long v_err;
                      8: long format_flag = 0;
                      9: 
                     10: /*     Routine to exercise VDDC
                     11: */
                     12: vddc_ex()
                     13: {      register long unit, last_blk, nodr;
                     14:        format_flag = 0;
                     15:        for (nodr=unit=0;devpar[unit+type*5].nocyl;unit++) {
                     16:                if (devpar[unit+type*5].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:                                writes("\n\tWrite_Compare/Read/Compare test\n");
                     24:                                writes("\n");
                     25:                                        v_ex1(1,unit,last_blk); 
                     26:                                        v_ex1(2,unit,last_blk-1); 
                     27:                                        v_ex1(3,unit,last_blk-2); }
                     28:                        }
                     29:                }
                     30:        if (!nodr) {
                     31:                writes("\n\n...No drive available");
                     32:                return; }
                     33:        if (!v_err) writes("\nVDDC passed..\n");
                     34:                else  writes("\nVDDC failed..\n");
                     35: }
                     36: 
                     37: v_ex1(factor,sdev,blk)
                     38: long factor, blk;
                     39: int sdev;
                     40: {      register long ix, pat, *sptr, *dptr, loop;
                     41:        unsigned short *s, *d;
                     42: 
                     43:        pat = 0xababab00;       /* Pattern */
                     44:        sptr = &iob0;           /* Source buffer */
                     45:        dptr = &iob3;           /* Destination buffer */
                     46: 
                     47:        writes("Exercising block "); writed(blk); writes("\n");
                     48: for(v_err=loop=0;loop<200;loop++)
                     49:        {
                     50:        /* initialize pattern in source buffer */
                     51:        for (ix=0; ix<(BLKSIZ/4)*factor; ix++) { 
                     52:                sptr[ix] = pat + ix;    /* init. pattern in source buffer */
                     53:                dptr[ix] = 0;           /* Clear destination buffer */
                     54:                }
                     55:        /* Write 1 block of data */
                     56:        if (vddc_op(WR_COMP,sdev,blk,factor,&iob0)==0) {v_err=1;return(0);}
                     57: 
                     58:        /* Read 1 block of data */
                     59:        if (vddc_op(RD_DATA,sdev,blk,factor,&iob3)==0) {v_err=1;return(0);}
                     60:        s = (unsigned short *)&iob0;            /* Source buffer */
                     61:        d = (unsigned short *)&iob3;            /* Destination buffer */
                     62:        for (ix=0; ix<(BLKSIZ/2)*factor; ix++) {
                     63:                if (s[ix] != d[ix]) {
                     64:                        writes("\nCompare error: ");
                     65:                        writes("expected ");
                     66:                        writeh(s[ix] & 0xffff);
                     67:                        writes(" , actual "); writeh(d[ix] & 0xffff);
                     68:                        writes(", address "); writeh(&d[ix]);
                     69:                        v_err = 1;
                     70:                        }       
                     71:                }
                     72:        if (v_err) loop = 0;    /* If error then loop forever */
                     73:        }
                     74: }
                     75: 
                     76: 
                     77: /*     routine to probe VDDC disk 
                     78: */
                     79: v_probe(sdev)
                     80: int sdev;
                     81: {      register long *dptr, blk, inc;
                     82:        inc = 2000;
                     83:        blk = 0;
                     84:        writes("\n\n\tRead Block test\n");
                     85:        while (inc != 0) {
                     86:                for(blk += inc;;blk += inc) { /* Read 1 block of data */
                     87:                        if (vddc_op(RD_DATA,sdev,blk,1,&iob0)==0) 
                     88:                                { blk -= inc; break; }
                     89:                        }
                     90:                inc /= 2;
                     91:                }
                     92:        if (blk <= 0) {
                     93:                writes("\n...Cannot probe "); writes(devpar[sdev+type*5].name);
                     94:                writed(sdev);
                     95:                v_err = 1;
                     96:                return(0); }
                     97:        writes("\n"); writes(devpar[sdev+type*5].name); 
                     98:         writes(" unit "); writed(sdev); writes(" has ");
                     99:        writed((blk*1024)/1000); writes(" Kbytes.\n");
                    100:        return(blk);
                    101: 
                    102: }

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