Return to scsi_rom.c CVS log

Up to [GnuMach] / Gnu-Mach / scsi

Annotation of Gnu-Mach/scsi/scsi_rom.c, revision 1.1

1.1     ! root        1: /* 
        !             2:  * Mach Operating System
        !             3:  * Copyright (c) 1991,1990 Carnegie Mellon University
        !             4:  * All Rights Reserved.
        !             5:  * 
        !             6:  * Permission to use, copy, modify and distribute this software and its
        !             7:  * documentation is hereby granted, provided that both the copyright
        !             8:  * notice and this permission notice appear in all copies of the
        !             9:  * software, derivative works or modified versions, and any portions
        !            10:  * thereof, and that both notices appear in supporting documentation.
        !            11:  * 
        !            12:  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
        !            13:  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
        !            14:  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
        !            15:  * 
        !            16:  * Carnegie Mellon requests users of this software to return to
        !            17:  * 
        !            18:  *  Software Distribution Coordinator  or  [email protected]
        !            19:  *  School of Computer Science
        !            20:  *  Carnegie Mellon University
        !            21:  *  Pittsburgh PA 15213-3890
        !            22:  * 
        !            23:  * any improvements or extensions that they make and grant Carnegie Mellon
        !            24:  * the rights to redistribute these changes.
        !            25:  */
        !            26: /*
        !            27:  *     File: scsi_rom.c
        !            28:  *     Author: Alessandro Forin, Carnegie Mellon University
        !            29:  *     Date:   10/90
        !            30:  *
        !            31:  *     Middle layer of the SCSI driver: SCSI protocol implementation
        !            32:  *
        !            33:  * This file contains code for SCSI commands for CD-ROM devices.
        !            34:  */
        !            35: 
        !            36: #include <mach/std_types.h>
        !            37: #include <scsi/compat_30.h>
        !            38: 
        !            39: #include <scsi/scsi.h>
        !            40: #include <scsi/scsi2.h>
        !            41: #include <scsi/scsi_defs.h>
        !            42: 
        !            43: #if  (NSCSI > 0)
        !            44: 
        !            45: char *sccdrom_name(
        !            46:        boolean_t        internal)
        !            47: {
        !            48:        return internal ? "rz" : "CD-ROM";
        !            49: }
        !            50: 
        !            51: int scsi_pause_resume(
        !            52:        target_info_t   *tgt,
        !            53:        boolean_t       stop_it,
        !            54:        io_req_t        ior)
        !            55: {
        !            56:        scsi_cmd_pausres_t      *cmd;
        !            57: 
        !            58:        cmd = (scsi_cmd_pausres_t*) (tgt->cmd_ptr);
        !            59:        cmd->scsi_cmd_code = SCSI_CMD_PAUSE_RESUME;
        !            60:        cmd->scsi_cmd_lun_and_relbit = 0;
        !            61:        cmd->scsi_cmd_lba1         = 0;
        !            62:        cmd->scsi_cmd_lba2         = 0;
        !            63:        cmd->scsi_cmd_lba3         = 0;
        !            64:        cmd->scsi_cmd_lba4         = 0;
        !            65:        cmd->scsi_cmd_xxx          = 0;
        !            66:        cmd->scsi_cmd_xfer_len_1    = 0;
        !            67:        cmd->scsi_cmd_pausres_res  = stop_it ? 0 : SCSI_CMD_PAUSRES_RESUME;
        !            68:        cmd->scsi_cmd_ctrl_byte = 0;    /* not linked */
        !            69:        
        !            70:        tgt->cur_cmd = SCSI_CMD_PAUSE_RESUME;
        !            71: 
        !            72:         scsi_go_and_wait(tgt, sizeof(*cmd), 0, ior);
        !            73: 
        !            74:         return tgt->done;
        !            75: }
        !            76: 
        !            77: scsi_play_audio(
        !            78:        target_info_t   *tgt,
        !            79:        unsigned int    start,
        !            80:        unsigned int    len,
        !            81:        boolean_t       relative_address,
        !            82:        io_req_t        ior)
        !            83: {
        !            84:        scsi_cmd_play_audio_t   *cmd;
        !            85: 
        !            86:        cmd = (scsi_cmd_play_audio_t*) (tgt->cmd_ptr);
        !            87:        cmd->scsi_cmd_code = SCSI_CMD_PLAY_AUDIO;
        !            88:        cmd->scsi_cmd_lun_and_relbit = relative_address ? SCSI_RELADR : 0;
        !            89:        cmd->scsi_cmd_lba1         = start >> 24;
        !            90:        cmd->scsi_cmd_lba2         = start >> 16;
        !            91:        cmd->scsi_cmd_lba3         = start >>  8;
        !            92:        cmd->scsi_cmd_lba4         = start >>  0;
        !            93:        cmd->scsi_cmd_xxx          = 0;
        !            94:        cmd->scsi_cmd_xfer_len_1    = len >> 8;
        !            95:        cmd->scsi_cmd_xfer_len_2    = len >> 0;
        !            96:        cmd->scsi_cmd_ctrl_byte = 0;    /* not linked */
        !            97:        
        !            98:        tgt->cur_cmd = SCSI_CMD_PLAY_AUDIO;
        !            99: 
        !           100:         scsi_go_and_wait(tgt, sizeof(*cmd), 0, ior);
        !           101: 
        !           102:         return tgt->done;
        !           103: }
        !           104: 
        !           105: scsi_play_audio_long(
        !           106:         target_info_t      *tgt,
        !           107:         unsigned int    start,
        !           108:         unsigned int    len,
        !           109:         boolean_t       relative_address,
        !           110:         io_req_t        ior)
        !           111: {
        !           112:         scsi_cmd_play_audio_l_t   *cmd;
        !           113: 
        !           114:         cmd = (scsi_cmd_play_audio_l_t*) (tgt->cmd_ptr);
        !           115:         cmd->scsi_cmd_code = SCSI_CMD_PLAY_AUDIO_LONG;
        !           116:         cmd->scsi_cmd_lun_and_relbit = relative_address ? SCSI_RELADR : 0;
        !           117:         cmd->scsi_cmd_lba1         = start >> 24;
        !           118:         cmd->scsi_cmd_lba2         = start >> 16;
        !           119:         cmd->scsi_cmd_lba3         = start >>  8;
        !           120:         cmd->scsi_cmd_lba4         = start >>  0;
        !           121:         cmd->scsi_cmd_xfer_len_1    = len >> 24;
        !           122:         cmd->scsi_cmd_xfer_len_2    = len >> 16;
        !           123:         cmd->scsi_cmd_xfer_len_3    = len >>  8;
        !           124:         cmd->scsi_cmd_xfer_len_4    = len >>  0;
        !           125:         cmd->scsi_cmd_xxx1        = 0;
        !           126:         cmd->scsi_cmd_ctrl_byte = 0;    /* not linked */
        !           127: 
        !           128:         tgt->cur_cmd = SCSI_CMD_PLAY_AUDIO_LONG;
        !           129: 
        !           130:         scsi_go_and_wait(tgt, sizeof(*cmd), 0, ior);
        !           131: 
        !           132:         return tgt->done;
        !           133: }
        !           134: 
        !           135: scsi_play_audio_msf(
        !           136:        target_info_t   *tgt,
        !           137:        int             sm,
        !           138:        int             ss,
        !           139:        int             sf,
        !           140:        int             em,
        !           141:        int             es,
        !           142:        int             ef,
        !           143:        io_req_t        ior)
        !           144: {
        !           145:        scsi_cmd_play_audio_msf_t       *cmd;
        !           146: 
        !           147:        cmd = (scsi_cmd_play_audio_msf_t*) (tgt->cmd_ptr);
        !           148:        cmd->scsi_cmd_code = SCSI_CMD_PLAY_AUDIO_MSF;
        !           149:        cmd->scsi_cmd_lun_and_relbit = 0;
        !           150:        cmd->scsi_cmd_lba1 = 0;
        !           151:        cmd->scsi_cmd_pamsf_startM = sm;
        !           152:        cmd->scsi_cmd_pamsf_startS = ss;
        !           153:        cmd->scsi_cmd_pamsf_startF = sf;
        !           154:        cmd->scsi_cmd_pamsf_endM = em;
        !           155:        cmd->scsi_cmd_pamsf_endS = es;
        !           156:        cmd->scsi_cmd_pamsf_endF = ef;
        !           157:        cmd->scsi_cmd_ctrl_byte = 0;    /* not linked */
        !           158:        
        !           159:        tgt->cur_cmd = SCSI_CMD_PLAY_AUDIO_MSF;
        !           160: 
        !           161:         scsi_go_and_wait(tgt, sizeof(*cmd), 0, ior);
        !           162: 
        !           163:         return tgt->done;
        !           164: }
        !           165: 
        !           166: scsi_play_audio_track_index(
        !           167:        target_info_t   *tgt,
        !           168:        int             st,
        !           169:        int             si,
        !           170:        int             et,
        !           171:        int             ei,
        !           172:        io_req_t        ior)
        !           173: {
        !           174:        scsi_cmd_play_audio_ti_t        *cmd;
        !           175: 
        !           176:        cmd = (scsi_cmd_play_audio_ti_t*) (tgt->cmd_ptr);
        !           177:        cmd->scsi_cmd_code = SCSI_CMD_PLAY_AUDIO_TI;
        !           178:        cmd->scsi_cmd_lun_and_relbit = 0;
        !           179:        cmd->scsi_cmd_lba1 = 0;
        !           180:        cmd->scsi_cmd_lba2 = 0;
        !           181:        cmd->scsi_cmd_pati_startT = st;
        !           182:        cmd->scsi_cmd_pati_startI = si;
        !           183:        cmd->scsi_cmd_xxx = 0;
        !           184:        cmd->scsi_cmd_pati_endT = et;
        !           185:        cmd->scsi_cmd_pati_endI = ei;
        !           186:        cmd->scsi_cmd_ctrl_byte = 0;    /* not linked */
        !           187:        
        !           188:        tgt->cur_cmd = SCSI_CMD_PLAY_AUDIO_TI;
        !           189: 
        !           190:         scsi_go_and_wait(tgt, sizeof(*cmd), 0, ior);
        !           191: 
        !           192:         return tgt->done;
        !           193: }
        !           194: 
        !           195: scsi_play_audio_track_relative(
        !           196:        target_info_t   *tgt,
        !           197:        unsigned int    lba,
        !           198:        int             st,
        !           199:        unsigned int    len,
        !           200:        io_req_t        ior)
        !           201: {
        !           202:        scsi_cmd_play_audio_tr_t        *cmd;
        !           203: 
        !           204:        cmd = (scsi_cmd_play_audio_tr_t*) (tgt->cmd_ptr);
        !           205:        cmd->scsi_cmd_code = SCSI_CMD_PLAY_AUDIO_TR;
        !           206:        cmd->scsi_cmd_lun_and_relbit = 0;
        !           207:        cmd->scsi_cmd_lba1         = lba >> 24;
        !           208:        cmd->scsi_cmd_lba2         = lba >> 16;
        !           209:        cmd->scsi_cmd_lba3         = lba >>  8;
        !           210:        cmd->scsi_cmd_lba4         = lba >>  0;
        !           211:        cmd->scsi_cmd_patr_startT  = st;
        !           212:        cmd->scsi_cmd_xfer_len_1    = len >> 8;
        !           213:        cmd->scsi_cmd_xfer_len_2    = len >> 0;
        !           214:        cmd->scsi_cmd_ctrl_byte = 0;    /* not linked */
        !           215:        
        !           216:        tgt->cur_cmd = SCSI_CMD_PLAY_AUDIO_TR;
        !           217: 
        !           218:         scsi_go_and_wait(tgt, sizeof(*cmd), 0, ior);
        !           219: 
        !           220:         return tgt->done;
        !           221: }
        !           222: 
        !           223: scsi_play_audio_track_relative_long(
        !           224:        target_info_t   *tgt,
        !           225:        unsigned int    lba,
        !           226:        int             st,
        !           227:        unsigned int    len,
        !           228:        io_req_t        ior)
        !           229: {
        !           230:        scsi_cmd_play_audio_tr_l_t      *cmd;
        !           231: 
        !           232:        cmd = (scsi_cmd_play_audio_tr_l_t*) (tgt->cmd_ptr);
        !           233:        cmd->scsi_cmd_code = SCSI_CMD_PLAY_AUDIO_TR_LONG;
        !           234:        cmd->scsi_cmd_lun_and_relbit = 0;
        !           235:        cmd->scsi_cmd_lba1         = lba >> 24;
        !           236:        cmd->scsi_cmd_lba2         = lba >> 16;
        !           237:        cmd->scsi_cmd_lba3         = lba >>  8;
        !           238:        cmd->scsi_cmd_lba4         = lba >>  0;
        !           239:        cmd->scsi_cmd_xfer_len_1    = len >> 24;
        !           240:        cmd->scsi_cmd_xfer_len_2    = len >> 16;
        !           241:        cmd->scsi_cmd_xfer_len_3    = len >>  8;
        !           242:        cmd->scsi_cmd_xfer_len_4    = len >>  0;
        !           243:        cmd->scsi_cmd_patrl_startT  = st;
        !           244:        cmd->scsi_cmd_ctrl_byte = 0;    /* not linked */
        !           245:        
        !           246:        tgt->cur_cmd = SCSI_CMD_PLAY_AUDIO_TR_LONG;
        !           247: 
        !           248:         scsi_go_and_wait(tgt, sizeof(*cmd), 0, ior);
        !           249: 
        !           250:         return tgt->done;
        !           251: }
        !           252: 
        !           253: scsi_read_header(
        !           254:        target_info_t   *tgt,
        !           255:        boolean_t       msf_format,
        !           256:        unsigned int    lba,
        !           257:        unsigned int    allocsize,
        !           258:        io_req_t        ior)
        !           259: {
        !           260:        scsi_cmd_read_header_t  *cmd;
        !           261: 
        !           262:        cmd = (scsi_cmd_read_header_t*) (tgt->cmd_ptr);
        !           263:        cmd->scsi_cmd_code = SCSI_CMD_READ_HEADER;
        !           264:        cmd->scsi_cmd_lun_and_relbit = msf_format ? SCSI_CMD_CD_MSF : 0;
        !           265:        cmd->scsi_cmd_lba1         = lba >> 24;
        !           266:        cmd->scsi_cmd_lba2         = lba >> 16;
        !           267:        cmd->scsi_cmd_lba3         = lba >>  8;
        !           268:        cmd->scsi_cmd_lba4         = lba >>  0;
        !           269:        cmd->scsi_cmd_xxx          = 0;
        !           270:        cmd->scsi_cmd_xfer_len_1    = allocsize >> 8;
        !           271:        cmd->scsi_cmd_xfer_len_2    = allocsize >> 0;
        !           272:        cmd->scsi_cmd_ctrl_byte = 0;    /* not linked */
        !           273:        
        !           274:        tgt->cur_cmd = SCSI_CMD_READ_HEADER;
        !           275: 
        !           276:         scsi_go_and_wait(tgt, sizeof(*cmd), allocsize, ior);
        !           277: 
        !           278:         return tgt->done;
        !           279: }
        !           280: 
        !           281: scsi_read_subchannel(
        !           282:        target_info_t   *tgt,
        !           283:        boolean_t       msf_format,
        !           284:        unsigned int    data_format,
        !           285:        unsigned int    trackno,
        !           286:        io_req_t        ior)
        !           287: {
        !           288:        scsi_cmd_read_subch_t   *cmd;
        !           289:        int                     allocsize;
        !           290: 
        !           291:        switch (data_format) {
        !           292:        case SCSI_CMD_RS_FMT_SUBQ:
        !           293:                allocsize = sizeof(cdrom_chan_data_t);
        !           294:                trackno = 0; break;
        !           295:        case SCSI_CMD_RS_FMT_CURPOS:
        !           296:                allocsize = sizeof(cdrom_chan_curpos_t);
        !           297:                trackno = 0; break;
        !           298:        case SCSI_CMD_RS_FMT_CATALOG:
        !           299:                allocsize = sizeof(cdrom_chan_catalog_t);
        !           300:                trackno = 0; break;
        !           301:        case SCSI_CMD_RS_FMT_ISRC:
        !           302:                allocsize = sizeof(cdrom_chan_isrc_t); break;
        !           303:        }
        !           304: 
        !           305:        cmd = (scsi_cmd_read_subch_t*) (tgt->cmd_ptr);
        !           306:        cmd->scsi_cmd_code = SCSI_CMD_READ_SUBCH;
        !           307:        cmd->scsi_cmd_lun_and_relbit = msf_format ? SCSI_CMD_CD_MSF : 0;
        !           308:        cmd->scsi_cmd_lba1         = SCSI_CMD_RS_SUBQ;
        !           309:        cmd->scsi_cmd_rs_format    = data_format;
        !           310:        cmd->scsi_cmd_lba3         = 0;
        !           311:        cmd->scsi_cmd_lba4         = 0;
        !           312:        cmd->scsi_cmd_rs_trackno   = trackno;
        !           313:        cmd->scsi_cmd_xfer_len_1    = allocsize >> 8;
        !           314:        cmd->scsi_cmd_xfer_len_2    = allocsize >> 0;
        !           315:        cmd->scsi_cmd_ctrl_byte = 0;    /* not linked */
        !           316:        
        !           317:        tgt->cur_cmd = SCSI_CMD_READ_SUBCH;
        !           318: 
        !           319:         scsi_go_and_wait(tgt, sizeof(*cmd), allocsize, ior);
        !           320: 
        !           321:         return tgt->done;
        !           322: }
        !           323: 
        !           324: scsi_read_toc(
        !           325:        target_info_t   *tgt,
        !           326:        boolean_t       msf_format,
        !           327:        int             trackno,
        !           328:        int             allocsize,
        !           329:        io_req_t        ior)
        !           330: {
        !           331:        scsi_cmd_read_toc_t     *cmd;
        !           332: 
        !           333:        cmd = (scsi_cmd_read_toc_t*) (tgt->cmd_ptr);
        !           334:        cmd->scsi_cmd_code = SCSI_CMD_READ_TOC;
        !           335:        cmd->scsi_cmd_lun_and_relbit = msf_format ? SCSI_CMD_CD_MSF : 0;
        !           336:        cmd->scsi_cmd_lba1         = 0;
        !           337:        cmd->scsi_cmd_lba2         = 0;
        !           338:        cmd->scsi_cmd_lba3         = 0;
        !           339:        cmd->scsi_cmd_lba4         = 0;
        !           340:        cmd->scsi_cmd_rtoc_startT  = trackno;
        !           341:        cmd->scsi_cmd_xfer_len_1    = allocsize >> 8;
        !           342:        cmd->scsi_cmd_xfer_len_2    = allocsize >> 0;
        !           343:        cmd->scsi_cmd_ctrl_byte = 0;    /* not linked */
        !           344:        
        !           345:        tgt->cur_cmd = SCSI_CMD_READ_TOC;
        !           346: 
        !           347:         scsi_go_and_wait(tgt, sizeof(*cmd), allocsize, ior);
        !           348: 
        !           349:         return tgt->done;
        !           350: }
        !           351: 
        !           352: /* move elsewhere ifworks */
        !           353: scsi2_mode_select(
        !           354:        target_info_t   *tgt,
        !           355:        boolean_t       save,
        !           356:        unsigned char   *page,
        !           357:        int             pagesize,
        !           358:        io_req_t        ior)
        !           359: {
        !           360:        scsi_cmd_mode_select_t  *cmd;
        !           361:        scsi2_mode_param_t      *parm;
        !           362: 
        !           363:        bzero(tgt->cmd_ptr, sizeof(*cmd) + sizeof(*parm));
        !           364:        cmd = (scsi_cmd_mode_select_t*) (tgt->cmd_ptr);
        !           365:        cmd->scsi_cmd_code = SCSI_CMD_MODE_SELECT;
        !           366:        cmd->scsi_cmd_lun_and_lba1 = SCSI_CMD_MSL_PF | (save ? SCSI_CMD_MSL_SP : 0);
        !           367:        cmd->scsi_cmd_xfer_len = pagesize;
        !           368: 
        !           369:        parm = (scsi2_mode_param_t*) (cmd + 1);
        !           370: 
        !           371:        bcopy(page, parm, pagesize);
        !           372: 
        !           373:        tgt->cur_cmd = SCSI_CMD_MODE_SELECT;
        !           374: 
        !           375:        scsi_go_and_wait(tgt, sizeof(*cmd) + pagesize, 0, ior);
        !           376: 
        !           377:        return tgt->done;
        !           378: }
        !           379: 
        !           380: /*
        !           381:  * obnoxious
        !           382:  */
        !           383: cdrom_vendor_specific(
        !           384:        target_info_t   *tgt,
        !           385:        scsi_command_group_2    *cmd,
        !           386:        unsigned char   *params,
        !           387:        int             paramlen,
        !           388:        int             retlen,
        !           389:        io_req_t        ior)
        !           390: {
        !           391:        bcopy(cmd, tgt->cmd_ptr, sizeof(*cmd));
        !           392:        if (paramlen)
        !           393:                bcopy(params, tgt->cmd_ptr + sizeof(*cmd), paramlen);
        !           394: 
        !           395:        tgt->cur_cmd = cmd->scsi_cmd_code;
        !           396: 
        !           397:        scsi_go_and_wait(tgt, sizeof(*cmd) + paramlen, retlen, ior);
        !           398: 
        !           399:        return tgt->done;
        !           400: }
        !           401: #endif  /* NSCSI > 0 */

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