home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cdrom.zip / DDK / BASE / SRC / DEV / DASD / CDROM / TOSHIBA / toiorb.c < prev    next >
C/C++ Source or Header  |  1996-06-18  |  23KB  |  890 lines
  1. /**************************************************************************
  2.  *
  3.  * SOURCE FILE NAME = TOIORB.C
  4.  *
  5.  * DESCRIPTIVE NAME = Toshiba IORB and CDB conversion routines
  6.  *
  7.  * Copyright : COPYRIGHT IBM CORPORATION, 1991, 1992
  8.  *             LICENSED MATERIAL - PROGRAM PROPERTY OF IBM
  9.  *             REFER TO COPYRIGHT INSTRUCTION FORM#G120-2083
  10.  *             RESTRICTED MATERIALS OF IBM
  11.  *             IBM CONFIDENTIAL
  12.  *
  13.  * VERSION = V2.0
  14.  *
  15.  * DATE
  16.  *
  17.  * DESCRIPTION
  18.  *
  19.  * FUNCTIONS   Filters SCSI-2 Command Descriptor Blocks and converts
  20.  *             them to the vendor unique Toshiba Command Descriptor
  21.  *             Blocks.
  22.  *
  23.  * ENTRY POINTS:
  24.  *
  25.  * DEPENDENCIES:
  26.  *
  27.  * NOTES
  28.  *
  29.  *
  30.  * STRUCTURES
  31.  *
  32.  * EXTERNAL REFERENCES
  33.  *
  34.  * EXTERNAL FUNCTIONS
  35.  *
  36.  * CHANGE ACTIVITY =
  37.  *  DATE      FLAG        APAR   CHANGE DESCRIPTION
  38.  *  --------  ----------  -----  --------------------------------------
  39.  *  mm/dd/yy  @Vr.mpppxx  xxxxx  xxxxxxx
  40.  ****************************************************************************/
  41.  
  42. #include <flthdr.h>
  43.  
  44. USHORT NotifyReadSubChannel (PIORB_CDB);
  45. USHORT NotifyReadTOC1 (PIORB_CDB);
  46. USHORT NotifyReadTOC2 (PIORB_CDB);
  47. USHORT NotifyPlayAudio (PIORB_CDB);
  48. USHORT NotifyResume (PIORB_CDB);
  49.  
  50.  
  51. /****************************************************************************
  52.  *
  53.  * FUNCTION NAME = Filter_Seek_6
  54.  *
  55.  * DESCRIPTION   = Filter SCSI-2 Seek (6) Command     (0x0B)
  56.  *
  57.  * INPUT         = pIORB           - pointer to IORB
  58.  *
  59.  * OUTPUT        =
  60.  *
  61.  * RETURN-NORMAL =
  62.  * RETURN-ERROR  =
  63.  *
  64.  ****************************************************************************/
  65.  
  66. USHORT Filter_Seek_6 (pIORB)
  67.  
  68. PIORB_CDB pIORB;
  69. {
  70.  
  71.    struct TOSH_CDB_AudioTrackSearch FAR *pCDB1;
  72.    struct CDB_Seek_6 FAR *pCDB2;
  73.  
  74.    pCDB1 = (struct TOSH_CDB_AudioTrackSearch FAR *) pIORB->apt.pControllerCmd;
  75.    pCDB2 = (struct CDB_Seek_6 FAR *) pCDB1;
  76.  
  77.    pIORB->apt.ControllerCmdLen = sizeof(struct TOSH_CDB_AudioTrackSearch);
  78.  
  79.    pCDB1->OpCode = TOSH_AUDIO_TRACK_SEARCH;
  80.  
  81.    pCDB1->search_address.hsg.byte_3 = pCDB2->LBA.usbytes.byte_1;
  82.    pCDB1->search_address.hsg.byte_2 = pCDB2->LBA.usbytes.byte_0;
  83.    pCDB1->search_address.hsg.byte_1 = pCDB2->LBA_msb;
  84.    pCDB1->search_address.hsg.byte_0 = 0;
  85.  
  86.    pCDB1->play = 0;                     /* Search, no play */
  87.    pCDB1->reserved_1 = 0;
  88.    pCDB1->reserved_2 = 0;
  89.    pCDB1->reserved_3 = 0;
  90.    pCDB1->reserved_4 = 0;
  91.    pCDB1->control = 0;
  92.  
  93.    return(CALL_ADD_AND_RET);
  94. }
  95.  
  96.  
  97. /****************************************************************************
  98.  *
  99.  * FUNCTION NAME = Filter_Seek_10
  100.  *
  101.  * DESCRIPTION   = Filter SCSI-2 Seek (10) Command    (0x2B)
  102.  *
  103.  * INPUT         = pIORB           - pointer to IORB
  104.  *
  105.  * OUTPUT        =
  106.  *
  107.  * RETURN-NORMAL =
  108.  * RETURN-ERROR  =
  109.  *
  110.  ****************************************************************************/
  111.  
  112. USHORT Filter_Seek_10 (pIORB)
  113.  
  114. PIORB_CDB pIORB;
  115. {
  116.  
  117.    struct TOSH_CDB_AudioTrackSearch FAR *pCDB1;
  118.    struct CDB_Seek_10 FAR *pCDB2;
  119.  
  120.    pCDB1 = (struct TOSH_CDB_AudioTrackSearch FAR *) pIORB->apt.pControllerCmd;
  121.    pCDB2 = (struct CDB_Seek_10 FAR *) pCDB1;
  122.  
  123.    pIORB->apt.ControllerCmdLen = sizeof(struct TOSH_CDB_AudioTrackSearch);
  124.  
  125.    pCDB1->OpCode = TOSH_AUDIO_TRACK_SEARCH;
  126.    pCDB1->play = 0;                     /* Search, no play */
  127.    pCDB1->reserved_1 = 0;
  128.    pCDB1->reserved_2 = 0;
  129.    pCDB1->reserved_3 = 0;
  130.    pCDB1->reserved_4 = 0;
  131.    pCDB1->control = 0;
  132.  
  133.    return(CALL_ADD_AND_RET);
  134. }
  135.  
  136.  
  137. /****************************************************************************
  138.  *
  139.  * FUNCTION NAME = Filter_ModeSelect
  140.  *
  141.  * DESCRIPTION   = Filter SCSI-2 Mode Select command
  142.  *
  143.  * INPUT         = pIORB           - pointer to IORB
  144.  *
  145.  * OUTPUT        =
  146.  *
  147.  * RETURN-NORMAL =
  148.  * RETURN-ERROR  =
  149.  *
  150.  ****************************************************************************/
  151.  
  152. USHORT Filter_ModeSelect (pIORB)
  153.  
  154. PIORB_CDB pIORB;
  155.  
  156. {
  157.    UCHAR  play_mode;
  158.    USHORT i, rc;
  159.  
  160.    struct TOSH_CDB_PlayAudio FAR *pCDB1;
  161.    struct CDB_ModeSelect FAR *pCDB2;
  162.    struct ModeSelectParmList FAR *pCDBData;
  163.    PIORB_FLTWORK pFilter_workspace;
  164.    NPUNITCB pUnitCB;
  165.  
  166.    BOOL   left_off  = FALSE,
  167.           right_off = FALSE;
  168.  
  169.    rc = CALL_ADD_AND_RET;
  170.  
  171.    pCDB1 = (struct TOSH_CDB_PlayAudio FAR *) pIORB->apt.pControllerCmd;
  172.    pCDB2 = (struct CDB_ModeSelect FAR *) pCDB1;
  173.    pCDBData = (struct ModeSelectParmList FAR *) &(pIORB->CDB_data);
  174.  
  175.    /*
  176.    ** Convert Mode Select - Audio Control Page to
  177.    **  a Toshiba Play Audio Command with play mode set.
  178.    */
  179.    if ( (pCDBData->ModeSelectHdr.block_descriptor_len == 0) &&
  180.         (pCDBData->Descriptors.audio_control.page_code == PAGE_AUDIO_CONTROL) )
  181.    {
  182.       pIORB->apt.ControllerCmdLen = sizeof(struct TOSH_CDB_PlayAudio);
  183.       pIORB->apt.cSGList =  0;
  184.       pIORB->apt.pSGList =  0;
  185.       pIORB->apt.ppSGLIST = 0;
  186.  
  187.  
  188.       if ( (pCDBData->Descriptors.audio_control.output0_select > 3) ||
  189.            (pCDBData->Descriptors.audio_control.output0_volume == PCS_MUTED) )
  190.  
  191.          left_off = TRUE;
  192.  
  193.       if ( (pCDBData->Descriptors.audio_control.output1_select > 3) ||
  194.            (pCDBData->Descriptors.audio_control.output1_volume == PCS_MUTED) )
  195.  
  196.          right_off = TRUE;
  197.  
  198.  
  199.       if (left_off & right_off)
  200.          play_mode = TOSH_PLAY_MUTE;
  201.       else if (left_off)
  202.          play_mode = TOSH_PLAY_RIGHT_CHANNEL;
  203.       else if (right_off)
  204.          play_mode = TOSH_PLAY_LEFT_CHANNEL;
  205.       else if (pCDBData->Descriptors.audio_control.output0_select ^
  206.                pCDBData->Descriptors.audio_control.output1_select)
  207.          play_mode = TOSH_PLAY_STEREO;
  208.       else if (pCDBData->Descriptors.audio_control.output0_select == 0)
  209.          play_mode = TOSH_PLAY_RIGHT_CHANNEL;
  210.       else
  211.          play_mode = TOSH_PLAY_LEFT_CHANNEL;
  212.  
  213.  
  214.       pCDB1->OpCode = TOSH_PLAY_AUDIO;
  215.       pCDB1->play_mode = play_mode;
  216.       pCDB1->reserved_1 = 0;
  217.  
  218.       for (i = 2; i < 9; i++)
  219.          *( (PBYTE) pCDB1+i) = 0;
  220.  
  221.       pCDB1->control = CONTROL_TYPE_PREVIOUS_ADDRESS;
  222.  
  223.       pFilter_workspace = (PIORB_FLTWORK) pIORB->filter_workspace;
  224.       pUnitCB = pFilter_workspace->pUnitCB;
  225.       pUnitCB->play_mode = play_mode;
  226.  
  227.  
  228.       /* If the drive is not currently playing, then dont issue play command */
  229.  
  230.       if (pFilter_workspace->input_parm_0 == 0)
  231.         rc = NOTIFY_CDM;
  232.  
  233.    }
  234.    return(rc);
  235. }
  236.  
  237.  
  238. /****************************************************************************
  239.  *
  240.  * FUNCTION NAME = Filter_StartStopUnit
  241.  *
  242.  * DESCRIPTION   = Filter SCSI-2 StartStopUnit CDB
  243.  *
  244.  * INPUT         = pIORB           - pointer to IORB
  245.  *
  246.  * OUTPUT        =
  247.  *
  248.  * RETURN-NORMAL =
  249.  * RETURN-ERROR  =
  250.  *
  251.  ****************************************************************************/
  252.  
  253. USHORT Filter_StartStopUnit (pIORB)
  254.  
  255. PIORB_CDB pIORB;
  256. {
  257.  
  258.    USHORT i, rc;
  259.    struct TOSH_CDB_Eject    FAR *pCDB1;
  260.    struct CDB_StartStopUnit FAR *pCDB2;
  261.  
  262.    pCDB1 = (struct TOSH_CDB_Eject    FAR *) pIORB->apt.pControllerCmd;
  263.    pCDB2 = (struct CDB_StartStopUnit FAR *) pCDB1;
  264.  
  265.    /* If Eject requested, then setup Eject command */
  266.  
  267.    if ( (pCDB2->LoEj) && !(pCDB2->start) )
  268.    {
  269.       pIORB->apt.ControllerCmdLen = sizeof(struct TOSH_CDB_Eject);
  270.  
  271.       pCDB1->OpCode = TOSH_EJECT;
  272.       pCDB1->reserved_1 = 0;
  273.  
  274.       for (i = 2; i < 10; i++)
  275.         *( (PBYTE) pCDB1+i) = 0;
  276.  
  277.       rc = CALL_ADD_AND_RET;
  278.    }
  279.    else
  280.       rc = NOTIFY_CDM_WITH_ERROR;
  281.  
  282.    return(rc);
  283. }
  284.  
  285.  
  286. /****************************************************************************
  287.  *
  288.  * FUNCTION NAME = Filter_ReadSubChannel
  289.  *
  290.  * DESCRIPTION   = Filter SCSI-2 Read Subchannel Data
  291.  *
  292.  * INPUT         = pIORB           - pointer to IORB
  293.  *
  294.  * OUTPUT        =
  295.  *
  296.  * RETURN-NORMAL =
  297.  * RETURN-ERROR  =
  298.  *
  299.  ****************************************************************************/
  300.  
  301. USHORT Filter_ReadSubChannel (pIORB)
  302.  
  303. PIORB_CDB pIORB;
  304. {
  305.  
  306.    USHORT i, rc;
  307.    struct TOSH_CDB_ReadQData FAR *pCDB1;
  308.    struct CDB_ReadSubChannel FAR *pCDB2;
  309.    PIORB_FLTWORK pFilter_workspace;
  310.  
  311.    pCDB1 = (struct TOSH_CDB_ReadQData FAR *) pIORB->apt.pControllerCmd;
  312.    pCDB2 = (struct CDB_ReadSubChannel FAR *) pCDB1;
  313.  
  314.    if (pCDB2->data_format == RSC_CURRENT_POSITION)
  315.    {
  316.       pIORB->apt.ControllerCmdLen = sizeof(struct TOSH_CDB_ReadQData);
  317.       pIORB->apt.pSGList->XferBufLen = sizeof(struct TOSH_SubQ_Channel_Data);
  318.  
  319.       pCDB1->OpCode = TOSH_READ_Q_DATA;
  320.       pCDB1->alloc_length = sizeof(struct TOSH_SubQ_Channel_Data);
  321.  
  322.       for (i = 2; i < 10; i++)
  323.         *( (PBYTE) pCDB1+i) = 0;
  324.  
  325.       pFilter_workspace = (PIORB_FLTWORK) pIORB->filter_workspace;
  326.       pFilter_workspace->completion_address = NotifyReadSubChannel;
  327.  
  328.       rc = CALL_ADD_AND_NOTIFY_FILTER;
  329.    }
  330.    else
  331.       rc = NOTIFY_CDM_WITH_ERROR;
  332.  
  333.    return(rc);
  334. }
  335.  
  336.  
  337. /****************************************************************************
  338.  *
  339.  * FUNCTION NAME = NotifyReadSubChannel
  340.  *
  341.  * DESCRIPTION   = Notification processing for ReadSubChannel
  342.  *
  343.  * INPUT         = pIORB           - pointer to IORB
  344.  *
  345.  * OUTPUT        =
  346.  *
  347.  * RETURN-NORMAL =
  348.  * RETURN-ERROR  =
  349.  *
  350.  ****************************************************************************/
  351.  
  352. USHORT NotifyReadSubChannel (pIORB)
  353.  
  354. PIORB_CDB pIORB;
  355. {
  356.    UCHAR status, control, track_number, index;
  357.  
  358.    struct TOSH_SubQ_Channel_Data FAR *pCDBData1;
  359.    struct SubChannel_Position    FAR *pCDBData2;
  360.  
  361.    pCDBData1 = (struct TOSH_SubQ_Channel_Data FAR *) &pIORB->CDB_data;
  362.    pCDBData2 = (struct SubChannel_Position FAR *) pCDBData1;
  363.  
  364.    /* Convert the play status byte to SCSI-2 */
  365.  
  366.    switch(pCDBData1->playback_status)
  367.    {
  368.       case  TOSH_PLAY_IN_PROGRESS:
  369.         status = AS_PLAY_IN_PROGRESS;
  370.         break;
  371.  
  372.       case  TOSH_PLAY_STILL:
  373.         status = AS_PLAY_PAUSED;
  374.         break;
  375.  
  376.       case  TOSH_PLAY_PAUSED:
  377.         status = AS_PLAY_PAUSED;
  378.         break;
  379.  
  380.       case  TOSH_PLAY_COMPLETE:
  381.         status = AS_PLAY_COMPLETE;
  382.         break;
  383.  
  384.       default:
  385.         status = AS_NO_STATUS;
  386.         break;
  387.    }
  388.  
  389.    control = pCDBData1->control;
  390.    track_number = BCDtoBinary(pCDBData1->track_number);
  391.    index = BCDtoBinary(pCDBData1->point);
  392.  
  393.    pCDBData2->rel_address.redbook.frame = BCDtoBinary(pCDBData1->frame);
  394.    pCDBData2->rel_address.redbook.sec   = BCDtoBinary(pCDBData1->sec);
  395.    pCDBData2->rel_address.redbook.min   = BCDtoBinary(pCDBData1->min);
  396.    pCDBData2->rel_address.redbook.zero  = 0;
  397.  
  398.    pCDBData2->abs_address.redbook.frame = BCDtoBinary(pCDBData1->aframe);
  399.    pCDBData2->abs_address.redbook.sec   = BCDtoBinary(pCDBData1->asec);
  400.    pCDBData2->abs_address.redbook.min   = BCDtoBinary(pCDBData1->amin);
  401.    pCDBData2->abs_address.redbook.zero  = 0;
  402.  
  403.  
  404.    pCDBData2->sub_channel_hdr.reserved_1 = 0;
  405.    pCDBData2->sub_channel_hdr.audio_status = status;
  406.    pCDBData2->sub_channel_hdr.data_length.usbytes.byte_0 = 0;
  407.    pCDBData2->sub_channel_hdr.data_length.usbytes.byte_1 =
  408.                             sizeof(struct SubChannel_Position) -
  409.                             sizeof(struct SubChannel_Hdr);
  410.  
  411.    pCDBData2->data_format_code = 1;
  412.    pCDBData2->control = control;
  413.    pCDBData2->ADR = ADR_CURRENT_POSITION;
  414.    pCDBData2->track_number = track_number;
  415.    pCDBData2->index_number = index;
  416.  
  417.    return(NOTIFY_CDM);
  418. }
  419.  
  420.  
  421. /****************************************************************************
  422.  *
  423.  * FUNCTION NAME = Filter_ReadTOC
  424.  *
  425.  * DESCRIPTION   = Filter SCSI-2 Read TOC command
  426.  *
  427.  * INPUT         = pIORB           - pointer to IORB
  428.  *
  429.  * OUTPUT        =
  430.  *
  431.  * RETURN-NORMAL =
  432.  * RETURN-ERROR  =
  433.  *
  434.  ****************************************************************************/
  435.  
  436. USHORT Filter_ReadTOC (pIORB)
  437.  
  438. PIORB_CDB pIORB;
  439. {
  440.    USHORT i;
  441.    struct TOSH_CDB_ReadDiskInfo FAR *pCDB1;
  442.    struct CDB_ReadTOC FAR *pCDB2;
  443.    struct ReadTOC_Data FAR *pCDBData2;
  444.    PIORB_FLTWORK pFilter_workspace;
  445.  
  446.    pCDB1 = (struct TOSH_CDB_ReadDiskInfo FAR *) pIORB->apt.pControllerCmd;
  447.    pCDB2 = (struct CDB_ReadTOC FAR *) pCDB1;
  448.    pCDBData2 = (struct ReadTOC_Data FAR *) pIORB->CDB_data;
  449.  
  450.    pIORB->apt.ControllerCmdLen = sizeof(struct TOSH_CDB_ReadDiskInfo);
  451.    pIORB->apt.pSGList->XferBufLen = 4;
  452.  
  453.    pCDB1->OpCode = TOSH_READ_DISK_INFO;
  454.  
  455.    pCDBData2->toc_descriptor[0].track_num = pCDB2->starting_track;
  456.  
  457.    /* See if getting TOC info for lead out track */
  458.  
  459.    if (pCDB2->starting_track == 0xAA)
  460.    {
  461.       pCDB1->type = TOSH_LEADOUT_INFO;
  462.       pCDB1->track_number = 0;
  463.    }
  464.    else
  465.    {
  466.       /* Getting info for a specific track */
  467.  
  468.       pCDB1->type = TOSH_TRACK_INFO;
  469.       pCDB1->track_number = BinarytoBCD(pCDB2->starting_track);
  470.    }
  471.  
  472.    pCDB1->reserved_1 = 0;
  473.  
  474.    for (i = 3; i < 10; i++)
  475.      *( (PBYTE) pCDB1+i) = 0;
  476.  
  477.    pFilter_workspace = (PIORB_FLTWORK) pIORB->filter_workspace;
  478.    pFilter_workspace->completion_address = NotifyReadTOC1;
  479.  
  480.    return(CALL_ADD_AND_NOTIFY_FILTER);
  481. }
  482.  
  483.  
  484. /****************************************************************************
  485.  *
  486.  * FUNCTION NAME = NotifyReadTOC1
  487.  *
  488.  * DESCRIPTION   = Notification processing for Read TOC command
  489.  *
  490.  * INPUT         = pIORB           - pointer to IORB
  491.  *
  492.  * OUTPUT        =
  493.  *
  494.  * RETURN-NORMAL =
  495.  * RETURN-ERROR  =
  496.  *
  497.  ****************************************************************************/
  498.  
  499. USHORT  NotifyReadTOC1 (pIORB)
  500.  
  501. PIORB_CDB pIORB;
  502.  
  503. {
  504.    union TOSH_ReadDiskInfo_Data FAR *pCDBData1;
  505.    struct ReadTOC_Data FAR *pCDBData2;
  506.    struct TOSH_CDB_ReadDiskInfo FAR *pCDB1;
  507.    PIORB_FLTWORK pFilter_workspace;
  508.  
  509.    pCDBData1 = (union TOSH_ReadDiskInfo_Data FAR *) pIORB->CDB_data;
  510.    pCDBData2 = (struct ReadTOC_Data FAR *) pCDBData1;
  511.    pCDB1 = (struct TOSH_CDB_ReadDiskInfo FAR *) &(pIORB->CDB);
  512.  
  513.    pCDBData2->toc_descriptor[0].abs_address.redbook.min   =
  514.                                         BCDtoBinary(pCDBData1->track.amin);
  515.    pCDBData2->toc_descriptor[0].abs_address.redbook.sec =
  516.                                         BCDtoBinary(pCDBData1->track.asec);
  517.    pCDBData2->toc_descriptor[0].abs_address.redbook.frame =
  518.                                         BCDtoBinary(pCDBData1->track.aframe);
  519.    pCDBData2->toc_descriptor[0].abs_address.redbook.zero = 0;
  520.  
  521.    pCDBData2->toc_descriptor[0].ADR = ADR_CURRENT_POSITION;
  522.  
  523. /*
  524. ** if (pCDBData1->track.control == TOSH_AUDIO_TRACK)
  525. **    pCDBData2->toc_descriptor[0].control = 0;
  526. ** else
  527. **    pCDBData2->toc_descriptor[0].control = QCTL_DATA_TRACK;
  528. */
  529.       pCDBData2->toc_descriptor[0].control = pCDBData1->track.control;
  530.  
  531.  
  532.    /* Issue Read Disk Info again to get the min-max track values */
  533.  
  534.    pCDB1->type = TOSH_MINMAX_INFO;
  535.  
  536.    pFilter_workspace = (PIORB_FLTWORK) pIORB->filter_workspace;
  537.    pFilter_workspace->completion_address = NotifyReadTOC2;
  538.  
  539.    return(CALL_ADD_AND_NOTIFY_FILTER);
  540. }
  541.  
  542.  
  543. /****************************************************************************
  544.  *
  545.  * FUNCTION NAME = NotifyReadTOC2
  546.  *
  547.  * DESCRIPTION   = Notification processing for Read TOC command
  548.  *
  549.  * INPUT         = pIORB           - pointer to IORB
  550.  *
  551.  * OUTPUT        =
  552.  *
  553.  * RETURN-NORMAL =
  554.  * RETURN-ERROR  =
  555.  *
  556.  ****************************************************************************/
  557.  
  558. USHORT NotifyReadTOC2 (pIORB)
  559.  
  560. PIORB_CDB pIORB;
  561. {
  562.    union TOSH_ReadDiskInfo_Data FAR *pCDBData1;
  563.    struct ReadTOC_Data FAR *pCDBData2;
  564.  
  565.    pCDBData1 = (union TOSH_ReadDiskInfo_Data FAR *) pIORB->CDB_data;
  566.    pCDBData2 = (struct ReadTOC_Data FAR *) pIORB->CDB_data;
  567.  
  568.    pCDBData2->toc_hdr.first_track=BCDtoBinary(pCDBData1->track_number.minimum);
  569.    pCDBData2->toc_hdr.last_track =BCDtoBinary(pCDBData1->track_number.maximum);
  570.  
  571.    pCDBData2->toc_hdr.toc_datalength.usbytes.byte_0 = 0;
  572.    pCDBData2->toc_hdr.toc_datalength.usbytes.byte_1 =
  573.                                 sizeof(struct ReadTOC_Data) - 2;
  574.    pCDBData2->toc_descriptor[0].reserved_1 = 0;
  575.    pCDBData2->toc_descriptor[0].reserved_3 = 0;
  576.  
  577.    return (NOTIFY_CDM);
  578. }
  579.  
  580.  
  581. /****************************************************************************
  582.  *
  583.  * FUNCTION NAME = Filter_ReadHeader
  584.  *
  585.  * DESCRIPTION   = Filter SCSI-2 Read Header command
  586.  *
  587.  * INPUT         = pIORB           - pointer to IORB
  588.  *
  589.  * OUTPUT        =
  590.  *
  591.  * RETURN-NORMAL =
  592.  * RETURN-ERROR  =
  593.  *
  594.  ****************************************************************************/
  595.  
  596. USHORT Filter_ReadHeader (pIORB)
  597.  
  598. PIORB_CDB pIORB;
  599.  
  600. {
  601.    USHORT   i;
  602.  
  603.    struct CDB_ReadHeader   FAR *pCDB1;
  604.    struct ReadHeader_Data  FAR *pCDBData1;
  605.  
  606.    pCDB1 = (struct CDB_ReadHeader FAR *) pIORB->apt.pControllerCmd;
  607.    pCDBData1 = (struct ReadHeader_Data FAR *) pIORB->CDB_data;
  608.  
  609.    pCDBData1->cdrom_data_mode = 1;
  610.  
  611.    for (i=1;i<8;i++)
  612.       *((PBYTE) pCDB1+i) = 0;
  613.  
  614.    return NOTIFY_CDM;
  615.  
  616. }
  617.  
  618.  
  619. /****************************************************************************
  620.  *
  621.  * FUNCTION NAME = Filter_PlayAudio_MSF
  622.  *
  623.  * DESCRIPTION   = Filter SCSI-2 Play Audio command
  624.  *                 Converts SCSI-2 Play Audio MSF command to a Toshiba Audio
  625.  *                 Track Search command followed by a Play Audio command.
  626.  *
  627.  * INPUT         = pIORB           - pointer to IORB
  628.  *
  629.  * OUTPUT        =
  630.  *
  631.  * RETURN-NORMAL =
  632.  * RETURN-ERROR  =
  633.  *
  634.  ****************************************************************************/
  635.  
  636. USHORT Filter_PlayAudio_MSF (pIORB)
  637.  
  638. PIORB_CDB pIORB;
  639.  
  640. {
  641.    struct TOSH_CDB_AudioTrackSearch FAR *pCDB1;
  642.    struct CDB_PlayAudio_MSF FAR *pCDB2;
  643.  
  644.    PIORB_FLTWORK pFilter_workspace;
  645.    NPUNITCB pUnitCB;
  646.  
  647.    pCDB1 = (struct TOSH_CDB_AudioTrackSearch FAR *) pIORB->apt.pControllerCmd;
  648.    pCDB2 = (struct CDB_PlayAudio_MSF FAR *) pCDB1;
  649.  
  650.    pFilter_workspace = (PIORB_FLTWORK) pIORB->filter_workspace;
  651.    pUnitCB = pFilter_workspace->pUnitCB;
  652.  
  653.  
  654.    pIORB->apt.ControllerCmdLen = sizeof(struct TOSH_CDB_AudioTrackSearch);
  655.  
  656.    pCDB1->OpCode = TOSH_AUDIO_TRACK_SEARCH;
  657.  
  658.    pCDB1->play = 0;
  659.  
  660.    pCDB1->search_address.msf0.min   = BinarytoBCD(pCDB2->starting_M);
  661.    pCDB1->search_address.msf0.sec   = BinarytoBCD(pCDB2->starting_S);
  662.    pCDB1->search_address.msf0.frame = BinarytoBCD(pCDB2->starting_F);
  663.    pCDB1->search_address.msf0.zero  = 0;
  664.  
  665.    pFilter_workspace->end_play_address.msf0.min = BinarytoBCD(pCDB2->ending_M);
  666.    pFilter_workspace->end_play_address.msf0.sec = BinarytoBCD(pCDB2->ending_S);
  667.    pFilter_workspace->end_play_address.msf0.frame=BinarytoBCD(pCDB2->ending_F);
  668.    pFilter_workspace->end_play_address.msf0.zero = 0;
  669.  
  670.    pCDB1->reserved_1 = 0;
  671.    pCDB1->reserved_2 = 0;
  672.    pCDB1->reserved_3 = 0;
  673.    pCDB1->reserved_4 = 0;
  674.  
  675.    pCDB1->control = CONTROL_TYPE_ATIME;
  676.  
  677.    pFilter_workspace->completion_address = NotifyPlayAudio;
  678.  
  679.    return (CALL_ADD_AND_NOTIFY_FILTER);
  680. }
  681.  
  682.  
  683. /****************************************************************************
  684.  *
  685.  * FUNCTION NAME = NotifyPlayAudio
  686.  *
  687.  * DESCRIPTION   = Notification processing for Play Audio Command
  688.  *
  689.  * INPUT         = pIORB           - pointer to IORB
  690.  *
  691.  * OUTPUT        =
  692.  *
  693.  * RETURN-NORMAL =
  694.  * RETURN-ERROR  =
  695.  *
  696.  ****************************************************************************/
  697.  
  698. USHORT NotifyPlayAudio (pIORB)
  699.  
  700. PIORB_CDB pIORB;
  701.  
  702. {
  703.    struct TOSH_CDB_PlayAudio FAR *pCDB1;
  704.    PIORB_FLTWORK pFilter_workspace;
  705.    NPUNITCB pUnitCB;
  706.  
  707.    pCDB1 = (struct TOSH_CDB_PlayAudio FAR *) pIORB->apt.pControllerCmd;
  708.    pFilter_workspace = (PIORB_FLTWORK) pIORB->filter_workspace;
  709.    pUnitCB = pFilter_workspace->pUnitCB;
  710.  
  711.    pIORB->apt.ControllerCmdLen = sizeof(struct TOSH_CDB_PlayAudio);
  712.  
  713.    pCDB1->OpCode = TOSH_PLAY_AUDIO;
  714.  
  715.    pCDB1->play_mode = pUnitCB->play_mode;
  716.    pCDB1->reserved_1 = 0;
  717.  
  718.    pCDB1->completion_address = pFilter_workspace->end_play_address;
  719.  
  720.    pCDB1->control = CONTROL_TYPE_ATIME;
  721.  
  722.    return(CALL_ADD_AND_NOTIFY_CDM);
  723. }
  724.  
  725.  
  726. /****************************************************************************
  727.  *
  728.  * FUNCTION NAME = Filter_Pause_Resume
  729.  *
  730.  * DESCRIPTION   = Filter SCSI-2 PauseResume CDB
  731.  *
  732.  * INPUT         = pIORB           - pointer to IORB
  733.  *
  734.  * OUTPUT        =
  735.  *
  736.  * RETURN-NORMAL =
  737.  * RETURN-ERROR  =
  738.  *
  739.  ****************************************************************************/
  740.  
  741. USHORT Filter_Pause_Resume (pIORB)
  742.  
  743. PIORB_CDB pIORB;
  744. {
  745.  
  746.    USHORT i;
  747.    struct TOSH_CDB_Still  FAR *pCDB1;
  748.    struct CDB_PauseResume FAR *pCDB2;
  749.    struct TOSH_CDB_AudioTrackSearch FAR *pCDB1a;
  750.    PIORB_FLTWORK pFilter_workspace;
  751.    NPUNITCB pUnitCB;
  752.  
  753.    pCDB1 =  (struct TOSH_CDB_Still  FAR *) &(pIORB->CDB);
  754.    pCDB2 =  (struct CDB_PauseResume FAR *) &(pIORB->CDB);
  755.    pCDB1a = (struct TOSH_CDB_AudioTrackSearch FAR *) &(pIORB->CDB);
  756.  
  757.  
  758.    /* If Resume requested, then issue Audio Search followed by Play command */
  759.  
  760.    if (pCDB2->resume)
  761.    {
  762.       pIORB->apt.ControllerCmdLen = sizeof(struct TOSH_CDB_AudioTrackSearch);
  763.  
  764.       pCDB1a->OpCode = TOSH_AUDIO_TRACK_SEARCH;
  765.  
  766.       pCDB1a->play = 0;
  767.  
  768.       pFilter_workspace = (PIORB_FLTWORK) pIORB->filter_workspace;
  769.       pUnitCB = pFilter_workspace->pUnitCB;
  770.  
  771. /*    pCDB1a->search_address.dword = pUnitCB->last_start_location.dword; */
  772.  
  773.       pCDB1a->reserved_1 = 0;
  774.       pCDB1a->reserved_2 = 0;
  775.       pCDB1a->reserved_3 = 0;
  776.       pCDB1a->reserved_4 = 0;
  777.  
  778.       pCDB1a->control = CONTROL_TYPE_ATIME;
  779.  
  780.       pFilter_workspace->completion_address = NotifyResume;
  781.  
  782.       return(CALL_ADD_AND_NOTIFY_FILTER);
  783.    }
  784.    else
  785.    {
  786.       /* Convert SCSI-2 Pause to Toshiba Still command */
  787.  
  788.       pIORB->apt.ControllerCmdLen = sizeof(struct TOSH_CDB_Still);
  789.  
  790.       pCDB1->OpCode = TOSH_STILL;
  791.  
  792.       for (i = 2; i < 10; i++)
  793.         *( (PBYTE) pCDB1+i) = 0;
  794.  
  795.       return(CALL_ADD_AND_RET);
  796.    }
  797. }
  798.  
  799.  
  800. /****************************************************************************
  801.  *
  802.  * FUNCTION NAME = NotifyResume
  803.  *
  804.  * DESCRIPTION   = Notification processing for Resume command
  805.  *
  806.  * INPUT         = pIORB           - pointer to IORB
  807.  *
  808.  * OUTPUT        =
  809.  *
  810.  * RETURN-NORMAL =
  811.  * RETURN-ERROR  =
  812.  *
  813.  ****************************************************************************/
  814.  
  815. USHORT NotifyResume (pIORB)
  816.  
  817. PIORB_CDB pIORB;
  818.  
  819. {
  820.    struct TOSH_CDB_PlayAudio FAR *pCDB1;
  821.    PIORB_FLTWORK pFilter_workspace;
  822.    NPUNITCB pUnitCB;
  823.  
  824.    pCDB1 = (struct TOSH_CDB_PlayAudio FAR *) pIORB->apt.pControllerCmd;
  825.  
  826.    pIORB->apt.ControllerCmdLen = sizeof(struct TOSH_CDB_PlayAudio);
  827.  
  828.    pCDB1->OpCode = TOSH_PLAY_AUDIO;
  829.  
  830.    pCDB1->play_mode = TOSH_PLAY_PREVIOUS_MODE;
  831.    pCDB1->reserved_1 = 0;
  832.  
  833.    pFilter_workspace = (PIORB_FLTWORK) pIORB->filter_workspace;
  834.    pUnitCB = pFilter_workspace->pUnitCB;
  835.  
  836. /* pCDB1->completion_address.dword = pUnitCB->last_end_location.dword;  */
  837.  
  838.    return(CALL_ADD_AND_NOTIFY_CDM);
  839. }
  840.  
  841.  
  842. /****************************************************************************
  843.  *
  844.  * FUNCTION NAME = Filter_PreventAllowRemoval
  845.  *
  846.  * DESCRIPTION   =
  847.  *
  848.  * INPUT         = pIORB           - pointer to IORB
  849.  *
  850.  * OUTPUT        =
  851.  *
  852.  * RETURN-NORMAL =
  853.  * RETURN-ERROR  =
  854.  *
  855.  ****************************************************************************/
  856.  
  857. USHORT Filter_PreventAllowRemoval (pIORB)
  858.  
  859. PIORB_CDB pIORB;
  860. {
  861.  
  862.    return(CALL_ADD_AND_RET);
  863.  
  864. }
  865.  
  866.  
  867. /****************************************************************************
  868.  *
  869.  * FUNCTION NAME = Filter_Read_6
  870.  *
  871.  * DESCRIPTION   = Filter Read (6)
  872.  *
  873.  * INPUT         = pIORB           - pointer to IORB
  874.  *
  875.  * OUTPUT        =
  876.  *
  877.  * RETURN-NORMAL =
  878.  * RETURN-ERROR  =
  879.  *
  880.  ****************************************************************************/
  881.  
  882. USHORT Filter_Read_6 (pIORB)
  883.  
  884. PIORB_CDB pIORB;
  885. {
  886.  
  887.    return(CALL_ADD_AND_RET);
  888.  
  889. }
  890.