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

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.