Return to mpage.c CVS log

Up to [Research Unix] / researchv10dc / cmd / worm / scsi / wren

Annotation of researchv10dc/cmd/worm/scsi/wren/mpage.c, revision 1.1

1.1     ! root        1: #include       <stdio.h>
        !             2: #include       "../scsi.h"
        !             3: #include       "../scsish.h"
        !             4: #include       "../tcl.h"
        !             5: #include       "fns.h"
        !             6: #include       "wren.h"
        !             7: 
        !             8: int
        !             9: wr_mpage(int pcf, int page, Field **fields, char *err)
        !            10: {
        !            11:        struct scsi_cmd cmd;
        !            12:        struct scsi_return ret;
        !            13:        int ndata;
        !            14:        int m, msk;
        !            15:        Field *f, **fp;
        !            16:        static int mask[8] = { 0x0, 0x1, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F };
        !            17: 
        !            18:        set6(cmd, 0x1A, 0, (pcf<<6)|page, 0, 60, 0);
        !            19:        if(s_io(0, &cmd, 0, &ret, -72, err))
        !            20:                return(-1);
        !            21:        ndata = ret.nread;
        !            22:        if(((ret.data[12]&0x3F) != page) || (ret.data[13]+14!= ndata))
        !            23:                printf("pg=#%x(#%x) data=#%x(#%x)\n", ret.data[12], page, ret.data[13], ndata);
        !            24: 
        !            25:        printf("setting");
        !            26:        for(fp = fields; f = *fp; fp++)
        !            27:                printf(" %s '%s'=%d", ((*fp)->len==1)? "bit":"count", (*fp)->name, (*fp)->nval);
        !            28:        printf("; kill me if that's wrong\n");
        !            29:        fflush(stdout);
        !            30:        sleep(5);
        !            31:        for(fp = fields; f = *fp; fp++)
        !            32:                switch(f->len)
        !            33:                {
        !            34:                case 8:
        !            35:                        ret.data[f->byteoff+12] = f->nval;
        !            36:                        break;
        !            37:                case 16:
        !            38:                        ret.data[f->byteoff+11] = f->nval>>8;
        !            39:                        ret.data[f->byteoff+12] = f->nval;
        !            40:                        break;
        !            41:                case 1: case 2: case 3: case 4: case 5: case 6: case 7:
        !            42:                        msk = mask[f->len]<<f->bitoff;
        !            43:                        m = ret.data[f->byteoff+12]&~msk;
        !            44:                        ret.data[f->byteoff+12] = m|((f->nval<<f->bitoff) & msk);
        !            45:                        break;
        !            46:                default:
        !            47:                        printf("unknown size %d for field %s\n", f->len, f->name);
        !            48:                        return(-1);
        !            49:                }
        !            50:        memcpy(cmd.data, ret.data, ndata);
        !            51:        cmd.data[0] = cmd.data[2] = 0;
        !            52:        cmd.data[12] &= 0x3F;   /* clear out top two bits */
        !            53:        set6(cmd, 0x15, 0x11, 0, 0, ndata, 0);
        !            54:        if(s_io(0, &cmd, ndata, &ret, 0, err))
        !            55:                return(-1);
        !            56:        return(TCL_OK);
        !            57: }

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