Return to juke.c CVS log

Up to [Research Unix] / researchv10no / cmd / worm / scsi / sony

Annotation of researchv10no/cmd/worm/scsi/sony/juke.c, revision 1.1

1.1     ! root        1: #include       <stdio.h>
        !             2: #include       <stdlib.h>
        !             3: #include       "../scsi.h"
        !             4: #include       "../scsish.h"
        !             5: #include       "../tcl.h"
        !             6: #include       "fns.h"
        !             7: #include       "../generic/fns.h"
        !             8: #include       "../jukeface.h"
        !             9: #include       <scsi.h>
        !            10: 
        !            11: int
        !            12: j_config(Jukebox *j, char *err)
        !            13: {
        !            14:        struct scsi_cmd cmd;
        !            15:        struct scsi_return ret;
        !            16:        char buf[512];
        !            17: 
        !            18:        j->nshelves = 50;
        !            19:        j->nluns = 8;
        !            20:        set6(cmd, 0x12, 0, 0, 0, 44, 0);
        !            21:        if(s_io(0, &cmd, 0, &ret, 44, err))
        !            22:                return(-1);
        !            23:        switch(ret.data[37])
        !            24:        {
        !            25:        case 1:         j->ndrives = 1; break;
        !            26:        case 2: case 3: j->ndrives = 2; break;
        !            27:        default:        j->ndrives = 0; break;
        !            28:        }
        !            29:        j->luns = (struct lun *)malloc(j->nluns * sizeof(struct lun));
        !            30:        j->shelves = (char *)malloc(j->nshelves * sizeof(char));
        !            31:        j->names = (char **)malloc(j->nshelves * sizeof(char *));
        !            32: 
        !            33:        for(j->nworms = 0; j->nworms < j->nluns; j->nworms++){
        !            34:                sprintf(buf, "/dev/worm%d", j->nworms);
        !            35:                if(access(buf, 0) < 0)
        !            36:                        return(0);
        !            37:        }
        !            38:        return(0);
        !            39: }
        !            40: 
        !            41: extern j_drstatus(Jukebox *j, char *err)
        !            42: {
        !            43:        struct scsi_return ret;
        !            44:        int i;
        !            45:        char *where[8];
        !            46:        unsigned char *d;
        !            47: 
        !            48:        if(sony_istatus(&ret, err))
        !            49:                return(-1);
        !            50:        for(i = 0; i < 8; i++)
        !            51:                where[i] = "shelf";
        !            52:        d = &ret.data[100];
        !            53:        if(*d&0x80)
        !            54:                where[*d&7] = "upper";
        !            55:        d++;
        !            56:        if(*d&0x80)
        !            57:                where[*d&7] = "lower";
        !            58:        d = &ret.data[16];
        !            59:        for(i = 0; i < 8; i++, d += 4){
        !            60:                j->luns[i].spunup = (d[0]&1) != 0;
        !            61:                j->luns[i].desc = "shelf";
        !            62:                j->luns[i].shelf = -1;
        !            63:                j->luns[i].side = 0;
        !            64:                if(j->luns[i].occupied = (d[0]&0x40) != 0){
        !            65:                        if(d[1]&0x80){
        !            66:                                j->luns[i].desc = where[i];
        !            67:                                if(d[2]&0x80){
        !            68:                                        j->luns[i].shelf = (d[2]&0x7F)/2;
        !            69:                                        j->luns[i].side = d[2]&1;
        !            70:                                }
        !            71:                        } else {
        !            72:                                j->luns[i].shelf = (d[1]&0x7F)/2;
        !            73:                                j->luns[i].side = d[1]&1;
        !            74:                        }
        !            75:                        j->shelves[j->luns[i].shelf] = 1;
        !            76:                }
        !            77:        }
        !            78:        return(0);
        !            79: }
        !            80: 
        !            81: extern j_shstatus(Jukebox *j, char *err)
        !            82: {
        !            83:        struct scsi_return ret;
        !            84:        int i;
        !            85:        unsigned char *d;
        !            86: 
        !            87:        if(sony_istatus(&ret, err))
        !            88:                return(-1);
        !            89:        d = &ret.data[48];
        !            90:        for(i = 0; i < j->nshelves; i++)
        !            91:                j->shelves[i] = (d[i]&0x80) && (d[i]&0x40);
        !            92:        return(0);
        !            93: }
        !            94: 
        !            95: j_eject(int dr, char *err)
        !            96: {
        !            97:        struct scsi_cmd cmd;
        !            98:        struct scsi_return ret;
        !            99: 
        !           100:        set6(cmd, 0xC0, dr<<5, 0, 0, 0, 0);
        !           101:        return(s_io(0, &cmd, 0, &ret, 0, err));
        !           102: }
        !           103: 
        !           104: j_sh_to_dr(int sh, int side, int dr, char *err)
        !           105: {
        !           106:        struct scsi_cmd cmd;
        !           107:        struct scsi_return ret;
        !           108: 
        !           109:        set6(cmd, 0xD6, dr<<5, 0, (sh<<1)|side, 0, 0);
        !           110:        return(s_io(0, &cmd, 0, &ret, 0, err));
        !           111: }
        !           112: 
        !           113: j_dr_to_sh(int dr, int sh, int side, char *err)
        !           114: {
        !           115:        struct scsi_cmd cmd;
        !           116:        struct scsi_return ret;
        !           117: 
        !           118:        if(sh < 0)
        !           119:                set6(cmd, 0xD7, dr<<5, 0, 0, 0, 0);
        !           120:        else
        !           121:                set6(cmd, 0xD7, (dr<<5)|1, 0, (sh<<1)|side, 0, 0);
        !           122:        return(s_io(0, &cmd, 0, &ret, 0, err));
        !           123: }
        !           124: 
        !           125: j_start(int dr, char *err)
        !           126: {
        !           127:        struct scsi_cmd cmd;
        !           128:        struct scsi_return ret;
        !           129: 
        !           130:        set6(cmd, 0x1B, dr<<5, 0, 0, 1, 0);
        !           131:        if(s_io(0, &cmd, 0, &ret, 0, err))
        !           132:                return(-1);
        !           133:        return(0);
        !           134: }
        !           135: 
        !           136: j_stop(int dr, char *err)
        !           137: {
        !           138:        struct scsi_cmd cmd;
        !           139:        struct scsi_return ret;
        !           140: 
        !           141:        set6(cmd, 0x1B, dr<<5, 0, 0, 0, 0);
        !           142:        if(s_io(0, &cmd, 0, &ret, 0, err))
        !           143:                return(-1);
        !           144:        return(0);
        !           145: }
        !           146: extern j_read(int, unsigned long, char *, int, char *);
        !           147: extern j_write(int, unsigned long, char *, int, char *);
        !           148: extern j_capacity(int, unsigned long *, unsigned long *);
        !           149: 
        !           150: j_load_unloaded(int dr, char *err)
        !           151: {
        !           152:        /* this is wrong;
        !           153:                we should do a status every time to see ifthere are any temps
        !           154:        */
        !           155:        if(j_sh_to_dr(127, SIDEA, dr, err))
        !           156:                return(0);
        !           157:        else
        !           158:                return(1);
        !           159: }
        !           160: 
        !           161: void
        !           162: j_reset(void)
        !           163: {
        !           164:        struct scsi_cmd cmd;
        !           165:        struct scsi_return ret;
        !           166:        char err[1024];
        !           167: 
        !           168:        set6(cmd, 0, 0, 0, 0, 0, 0);
        !           169:        cmd.bus_id = s_id;
        !           170:        cmd.flags |= SCSI_RESET | SCSI_BRESET;
        !           171:        /* should probably test for some kind of error... */
        !           172:        ss_io(0, &cmd, 0, &ret, 0, err);
        !           173: }

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