home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ddkx86v5.zip / DDKX86 / SRC / DEV / DASD / CDROM / ATAPI / ATAPIOSM.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-04-14  |  30.3 KB  |  1,068 lines
  1. /*DDK*************************************************************************/
  2. /*                                                                           */
  3. /* COPYRIGHT    Copyright (C) 1995 IBM Corporation                           */
  4. /*                                                                           */
  5. /*    The following IBM OS/2 WARP source code is provided to you solely for  */
  6. /*    the purpose of assisting you in your development of OS/2 WARP device   */
  7. /*    drivers. You may use this code in accordance with the IBM License      */
  8. /*    Agreement provided in the IBM Device Driver Source Kit for OS/2. This  */
  9. /*    Copyright statement may not be removed.                                */
  10. /*                                                                           */
  11. /*****************************************************************************/
  12. /**************************************************************************
  13.  *
  14.  * SOURCE FILE NAME = ATAPIOSM.C
  15.  *
  16.  * DESCRIPTION : OUTER STATE MACHINE for ATAPI driver
  17.  *
  18.  *
  19.  *
  20.  * VERSION = 1.0
  21.  *
  22.  * DATE
  23.  *
  24.  * DESCRIPTION :
  25.  *
  26.  * Purpose:
  27.  *
  28.  *
  29. */
  30.  
  31. #define INCL_NOBASEAPI
  32. #define INCL_NOPMAPI
  33. #include "os2.h"
  34. #include "dos.h"
  35. #include "dskinit.h"
  36.  
  37. #include "iorb.h"
  38. #include "addcalls.h"
  39. #include "dhcalls.h"
  40.  
  41. #define INCL_INITRP_ONLY
  42. #include "reqpkt.h"
  43.  
  44. #include "scsi.h"
  45. #include "cdbscsi.h"
  46.  
  47. #include "atapicon.h"
  48. #include "atapireg.h"
  49. #include "atapityp.h"
  50. #include "atapiext.h"
  51. #include "atapipro.h"
  52.  
  53. /*
  54. ╔══════════════════════════════════╗
  55. ║                                  ║
  56. ║  StartOSM                        ║
  57. ║                                  ║
  58. ║  Outer State Machine Router      ║
  59. ║                                  ║
  60. ╚══════════════════════════════════╝
  61. */
  62. VOID FAR StartOSM ( NPACB npACB )
  63. {
  64.    DISABLE
  65.  
  66.    npACB->OSMUseCount++;
  67.  
  68.  
  69.    if ( npACB->OSMUseCount == 1 )
  70.    {
  71.       do
  72.       {
  73.          ENABLE
  74.          do
  75.          {
  76.             npACB->OSMFlags &= ~ACBOF_WAITSTATE;
  77.             switch ( npACB->OSMState )
  78.             {
  79.                case ACBOS_START_IORB:
  80.                   StartIORB( npACB );
  81.                   break;
  82.  
  83.                case ACBOS_ISM_COMPLETE :
  84.                   ISMComplete( npACB );
  85.                   break;
  86.  
  87.                case ACBOS_COMPLETE_IORB:
  88.                   CompleteIORB( npACB );
  89.                   break;
  90.  
  91.                case ACBOS_RESUME_COMPLETE:
  92.                   Resume_Complete( npACB );
  93.                   break;
  94.  
  95.                case ACBOS_SUSPEND_COMPLETE:
  96.                   Suspend_Complete( npACB );
  97.                   break;
  98.  
  99.                default:
  100.                   _asm { int 3 }
  101.                   break;
  102.             } /* endswitch */
  103.  
  104.          } while ( !(npACB->OSMFlags & ACBOF_WAITSTATE) ); /* enddo */
  105.  
  106.          DISABLE
  107.  
  108.       } while ( --npACB->OSMUseCount ); /* enddo */
  109.  
  110.    } /* endif */
  111.    ENABLE
  112. }
  113.  
  114. /*
  115. ╔══════════════════════════════════╗
  116. ║                                  ║
  117. ║                                  ║
  118. ║                                  ║
  119. ║                                  ║
  120. ║                                  ║
  121. ╚══════════════════════════════════╝
  122. */
  123. VOID NEAR StartIORB ( NPACB npACB )
  124. {
  125.    NPUCB   npUCB;
  126.    PIORB   pIORB      = npACB->pIORB;
  127.    USHORT  CmdError   = 0;
  128.    USHORT  Command    = 0;
  129.    USHORT  Modifier   = 0;
  130.  
  131.    if (pIORB)
  132.    {
  133.       Command    = pIORB->CommandCode;
  134.       Modifier   = pIORB->CommandModifier;
  135.       npACB->IORBError  = 0;
  136.       npACB->TimerFlags = 0;
  137.       npUCB             = (NPUCB) pIORB->UnitHandle;
  138.       if (!npUCB)
  139.       {
  140.          _asm INT 3
  141.       }
  142.       npACB->npUCB      = npUCB;
  143.       npACB->UnitId     = npACB->npUCB->UnitId;
  144.       npACB->ISMFlags    = 0;
  145.  
  146.       switch ( Command )
  147.       {
  148.          case IOCC_CONFIGURATION:
  149.  
  150.             switch ( Modifier )
  151.             {
  152.                case IOCM_GET_DEVICE_TABLE:
  153.                   GetDeviceTable( npACB );
  154.                   break;
  155.  
  156.                case IOCM_COMPLETE_INIT:
  157.                   CompleteInit( npACB );
  158.                   break;
  159.  
  160.                default:
  161.                   CmdError = 1;
  162.  
  163.             } /* endswitch */
  164.             break;
  165.  
  166.          case IOCC_UNIT_CONTROL:
  167.             switch ( Modifier )
  168.             {
  169.                case IOCM_ALLOCATE_UNIT:
  170.                   AllocateUnit( npACB );
  171.                   break;
  172.  
  173.                case IOCM_DEALLOCATE_UNIT:
  174.                   DeallocateUnit( npACB );
  175.                   break;
  176.  
  177.                case IOCM_CHANGE_UNITINFO:
  178.                   ChangeUnitInfo( npACB );
  179.                   break;
  180.  
  181.                default:
  182.                   CmdError = 1;
  183.  
  184.             } /* endswitch */
  185.             break;
  186.  
  187.          case IOCC_GEOMETRY:
  188.             switch ( Modifier )
  189.             {
  190.                case IOCM_GET_MEDIA_GEOMETRY:
  191.                   GetMediaGeometry( npACB );
  192.                   break;
  193.  
  194.                case IOCM_SET_MEDIA_GEOMETRY:   /* ┌───────────────────────┐ */
  195.                   CmdError = 1;                /* │ Command Not Supported │ */
  196.                   break;                       /* └───────────────────────┘ */
  197.  
  198.                case IOCM_GET_DEVICE_GEOMETRY:
  199.                   GetDeviceGeometry( npACB );
  200.                   break;
  201.  
  202.                case IOCM_SET_LOGICAL_GEOMETRY: /* ┌───────────────────────┐ */
  203.                   CmdError = 1;                /* │ Command Not Supported │ */
  204.                   break;                       /* └───────────────────────┘ */
  205.  
  206.                default:
  207.                   CmdError = 1;
  208.  
  209.             } /* endswitch */
  210.             break;
  211.  
  212.          case IOCC_EXECUTE_IO:
  213.             switch ( Modifier )
  214.             {
  215.                case IOCM_READ:
  216.                   IORBRead( npACB );
  217.                   break;
  218.  
  219.                case IOCM_READ_VERIFY:          /* ┌────────────────────────┐ */
  220.                case IOCM_READ_PREFETCH:        /* │ Commands Not Supported │ */
  221.                case IOCM_WRITE:                /* └────────────────────────┘ */
  222.                case IOCM_WRITE_VERIFY:
  223.                default:
  224.                   CmdError = 1;
  225.             }
  226.             break;
  227.  
  228.          case IOCC_FORMAT:   /* ┌────────────────────────────────────────────┐ */
  229.             CmdError = 1;    /* │ Format Commands are Not Supported for CDROM│ */
  230.             break;           /* └────────────────────────────────────────────┘ */
  231.  
  232.          case IOCC_UNIT_STATUS:
  233.             switch ( Modifier )
  234.             {
  235.                case IOCM_GET_UNIT_STATUS:
  236.                   GetUnitStatus( npACB );
  237.                   break;
  238.  
  239.                case IOCM_GET_CHANGELINE_STATE:  /* ┌────────────────────────┐ */
  240.                case IOCM_GET_MEDIA_SENSE:       /* │ Commands Not Supported │ */
  241.                   CmdError = 1;                 /* └────────────────────────┘ */
  242.                   break;
  243.  
  244.                case IOCM_GET_LOCK_STATUS:
  245.                   GetLockStatus( npACB );
  246.                   break;
  247.  
  248.                default:
  249.                   CmdError = 1;
  250.             }
  251.             break;
  252.  
  253.          case IOCC_DEVICE_CONTROL:
  254.             switch ( Modifier )
  255.             {
  256.                case IOCM_ABORT:
  257.                   Abort( npACB );
  258.                   break;
  259.  
  260.                case IOCM_RESET:
  261.                   Reset( npACB );
  262.                   break;
  263.  
  264.                case IOCM_SUSPEND:
  265.                   Suspend( npACB );
  266.                   break;
  267.  
  268.                case IOCM_RESUME:
  269.                   Resume( npACB );
  270.                   break;
  271.  
  272.                case IOCM_LOCK_MEDIA:
  273.                   LockMedia( npACB );
  274.                   break;
  275.  
  276.                case IOCM_UNLOCK_MEDIA:
  277.                   UnlockMedia( npACB );
  278.                   break;
  279.  
  280.                case IOCM_EJECT_MEDIA:
  281.                   EjectMedia( npACB );
  282.                   break;
  283.  
  284.                case IOCM_GET_QUEUE_STATUS:
  285.                   GetQueueStatus( npACB );
  286.                   break;
  287.  
  288.                default:
  289.                   CmdError = 1;
  290.  
  291.             } /* endswitch */
  292.             break;
  293.  
  294.          case IOCC_ADAPTER_PASSTHRU:
  295.             switch ( Modifier )
  296.             {
  297.                case IOCM_EXECUTE_ATA:    /* Continue on to Execute CDB */
  298.                   npACB->ISMFlags |= ACBIF_ATA_OPERATION;
  299.  
  300.                case IOCM_EXECUTE_CDB:
  301.                   SetUpXferData( npACB );
  302.                   Execute_CDB( npACB );
  303.                   break;
  304.                                          /* ┌───────────────────────┐ */
  305.                case IOCM_EXECUTE_SCB:    /* │ Command Not Supported │ */
  306.                                          /* └───────────────────────┘ */
  307.                default:
  308.                   CmdError = 1;
  309.  
  310.             } /* endswitch */
  311.             break;
  312.  
  313.          default:
  314.             CmdError = 1;
  315.  
  316.       } /* endswitch */
  317.       if ( CmdError )
  318.       {
  319.          npACB->IORBError = IOERR_CMD_NOT_SUPPORTED;
  320.          npACB->OSMState  = ACBOS_COMPLETE_IORB;
  321.          npACB->OSMFlags  &= ~ACBOF_WAITSTATE;
  322.       }
  323.    }
  324.    else
  325.    {
  326.       /* How did we get here? */
  327.       _asm { INT 3 }
  328.       npACB->OSMFlags |= ACBOF_WAITSTATE;
  329.    }
  330. }
  331.  
  332. /*
  333. ╔══════════════════════════════════╗
  334. ║                                  ║
  335. ║                                  ║
  336. ║                                  ║
  337. ║                                  ║
  338. ║                                  ║
  339. ╚══════════════════════════════════╝
  340. */
  341. VOID NEAR ISMComplete ( NPACB npACB )
  342. {
  343.    UCHAR                    i;
  344.    PSCSI_STATUS_BLOCK       pSCSISB;
  345.    PIORBH                   pIORB;
  346.    UCHAR                    ASC;
  347.    ULONG                    ppExternalSenseDataBuf;
  348.  
  349.    pIORB = npACB->pIORB;
  350.  
  351.    npACB->OSMFlags    &= ~ACBOF_WAITSTATE;
  352.  
  353.    /* is an internal request sense in progress */
  354.    if ( npACB->OSMFlags & ACBOF_SENSE_DATA_ACTIVE )
  355.    {
  356.       npACB->OSMFlags    &= ~ACBOF_SENSE_DATA_ACTIVE;
  357.       npACB->OSMReqFlags &= ~ACBR_SENSE_DATA;
  358.  
  359.       /*-------------------------------------------------------------------*/
  360.       /* if we are putting the sense data in the users buffer, make a copy */
  361.       /* so it can be examined with the debugger                           */
  362.       /*-------------------------------------------------------------------*/
  363.       if ( npACB->pIORB->RequestControl & IORB_REQ_STATUSBLOCK )
  364.       {
  365.          pSCSISB = MAKEP(SELECTOROF(npACB->pIORB),
  366.                                           (NPBYTE) npACB->pIORB->pStatusBlock);
  367.          memcopy( (PBYTE) &SenseDataBuf,
  368.                           MAKEP( SELECTOROF( pSCSISB ),
  369.                                  OFFSETOF  (pSCSISB->SenseData) ),
  370.                           SENSE_DATA_BYTES );
  371.       }
  372.  
  373.       if ( !(npACB->OSMReqFlags & ACBR_RESET))
  374.                  /* pass sense data back to caller if requested */
  375.       {
  376.          pSCSISB = MAKEP(SELECTOROF(npACB->pIORB),
  377.                                           (NPBYTE) npACB->pIORB->pStatusBlock);
  378.  
  379.          if ( npACB->pIORB->pStatusBlock)                           /*@VXXXXXX*/
  380.          {                                                          /*@VXXXXXX*/
  381.             if ( npACB->pIORB->RequestControl & IORB_REQ_STATUSBLOCK )
  382.                pSCSISB->Flags |= STATUS_SENSEDATA_VALID;
  383.  
  384.             ASC = pSCSISB->SenseData->AddSenseCode;
  385.  
  386.             if ( ASC > MaxAddSenseDataEntry )
  387.                npACB->pIORB->ErrorCode = IOERR_ADAPTER_REFER_TO_STATUS;
  388.             else
  389.                npACB->pIORB->ErrorCode = AddSenseDataMap[ASC];
  390.  
  391.             npACB->pIORB->Status    |=  IORB_STATUSBLOCK_AVAIL;     /*@VXXXXXX*/
  392.          }                                                          /*@VXXXXXX*/
  393.  
  394.          npACB->pIORB->Status    |= IORB_ERROR | IORB_DONE;         /*@VXXXXXX*/
  395.          npACB->OSMState  = ACBOS_COMPLETE_IORB;
  396.       }
  397.    }
  398.  
  399.    /* was a reset request successful */
  400.    else if ( npACB->OSMFlags & ACBOF_RESET_ACTIVE )
  401.    {
  402.  
  403.       npACB->npUCB->ReqFlags  &= ~UCBR_RESET;
  404.       npACB->ISMFlags         &= ~ACBIF_ATA_OPERATION;
  405.       npACB->OSMFlags         &= ~ACBOF_RESET_ACTIVE;
  406.  
  407.  
  408.       if ( BSYWAIT(npACB) ) /* successful reset */
  409.       {
  410.          npACB->OSMReqFlags      &= ~ACBR_RESET;
  411.          npACB->OSMState          = ACBOS_START_IORB;
  412.          npACB->IORBStatus        = 0;
  413.          npACB->IORBError         = 0;
  414.          npACB->pIORB->ErrorCode |= IOERR_DEVICE_RESET;
  415.       }
  416.       else
  417.       {
  418.          npACB->OSMState   = ACBOS_ISM_COMPLETE;
  419.       }
  420.  
  421.    }
  422.  
  423.    /* was there a request for reset */
  424.    else if ( npACB->OSMReqFlags & ACBR_RESET )
  425.    {
  426.       npACB->cResetRequests++;
  427.       cResets++;
  428.  
  429.       /* if over the reset limit, return error */
  430.       if ( npACB->cResetRequests > MAXRESETS )
  431.       {
  432.          npACB->OSMReqFlags &= ~ACBR_RESET;
  433.          pIORB->ErrorCode  = IOERR_DEVICE_NONSPECIFIC;
  434.          pIORB->Status    |= IORB_DONE | IORB_ERROR;
  435.  
  436.          npACB->OSMState   = ACBOS_COMPLETE_IORB;
  437.       }
  438.       /* issue reset request */
  439.       else
  440.       {
  441.          npACB->OSMFlags                       |= ACBOF_RESET_ACTIVE;
  442.          npACB->npUCB->ReqFlags                |= UCBR_RESET;
  443.          npACB->ISMFlags                       |= ACBIF_ATA_OPERATION;
  444.  
  445.          Execute_CDB( npACB );
  446.          npACB->OSMFlags  |= ACBOF_WAITSTATE;
  447.  
  448.       }
  449.    }
  450.  
  451.    /* was there a request for sense data */
  452.    else if ( npACB->OSMReqFlags & ACBR_SENSE_DATA )
  453.    {
  454.  
  455.       npACB->OSMFlags                       |= ACBOF_SENSE_DATA_ACTIVE;
  456.       npACB->npCmdIO                         = &npACB->InternalCmd;
  457.  
  458.       if ( npACB->pIORB->RequestControl & IORB_REQ_STATUSBLOCK )
  459.       {
  460.          pSCSISB = MAKEP(SELECTOROF(npACB->pIORB),
  461.                                           (NPBYTE) npACB->pIORB->pStatusBlock);
  462.  
  463.          npACB->npCmdIO->cXferBytesRemain    = pSCSISB->ReqSenseLen;
  464.          SenseDataSGList.XferBufLen          = pSCSISB->ReqSenseLen;
  465.          ppExternalSenseDataBuf = VirtToPhys ( (PBYTE) pSCSISB->SenseData );
  466.  
  467.          SenseDataSGList.ppXferBuf           = ppExternalSenseDataBuf;
  468.       }
  469.       else
  470.       {
  471.          npACB->npCmdIO->cXferBytesRemain    = SENSE_DATA_BYTES;
  472.          SenseDataSGList.XferBufLen          = SENSE_DATA_BYTES;
  473.          SenseDataSGList.ppXferBuf           = ppSenseDataBuf;
  474.       }
  475.  
  476.       npACB->npCmdIO->IOSGPtrs.cSGList       = 1;
  477.       npACB->npCmdIO->IOSGPtrs.pSGList       = &SenseDataSGList;
  478.       npACB->npCmdIO->IOSGPtrs.Mode          = PORT_TO_SGLIST;
  479.       npACB->npCmdIO->IOSGPtrs.iPortAddress  = npACB->IOPorts[FI_PDATA];
  480.       npACB->npCmdIO->IOSGPtrs.iSGList       = 0;
  481.       npACB->npCmdIO->IOSGPtrs.SGOffset      = 0;
  482.       npACB->npCmdIO->IOSGPtrs.iSGListStart  = 0;
  483.       npACB->npCmdIO->IOSGPtrs.SGOffsetStart = 0;
  484.       npACB->npCmdIO->cXferBytesComplete     = 0;
  485.       for ( i=0; i < SENSE_DATA_BYTES ; i++ )
  486.       {
  487.          npACB->npCmdIO->ATAPIPkt[i]  =  0;
  488.       }
  489.       npACB->npCmdIO->ATAPIPkt[0]  =  SCSI_REQUEST_SENSE;
  490.       npACB->npCmdIO->ATAPIPkt[4]  =  sizeof(SENSE_DATA);
  491.  
  492.       Execute_CDB( npACB );
  493.       npACB->OSMFlags  |= ACBOF_WAITSTATE;
  494.  
  495.    }
  496.    else
  497.    {
  498.       npACB->OSMState  = ACBOS_COMPLETE_IORB;
  499.    }
  500. }
  501.  
  502. /*
  503. ╔══════════════════════════════════╗
  504. ║                                  ║
  505. ║                                  ║
  506. ║                                  ║
  507. ║                                  ║
  508. ║                                  ║
  509. ╚══════════════════════════════════╝
  510. */
  511. VOID NEAR CompleteIORB ( NPACB npACB )
  512. {
  513.    PIORB    pIORB;
  514.    USHORT   ErrorCode = 0;
  515.    NPUCB    npUCB;
  516.  
  517.    pIORB     = npACB->pIORB;
  518.    npUCB     = npACB->npUCB;
  519.    ErrorCode = npACB->IORBError;
  520.  
  521.    if ( npACB->TimerFlags )
  522.    {
  523.       ErrorCode = IOERR_UNIT_NOT_READY;
  524.    }
  525.  
  526.    if ( ErrorCode )
  527.    {
  528.       pIORB->ErrorCode = ErrorCode;
  529.       pIORB->Status    |= IORB_ERROR;
  530.    }
  531.  
  532.    pIORB->Status |= IORB_DONE;
  533.  
  534.    npACB->pIORB = 0;
  535.  
  536.    if ( pIORB->RequestControl & IORB_ASYNC_POST )
  537.    {
  538.       if (( npACB->npUCB->Capabilities & UCBC_SPEC_REV_17B)     &&
  539.           ( npACB->npCmdIO->ATAPIPkt[0] == SCSI_MODE_SENSE_10 ) &&
  540.           (( npACB->npCmdIO->ATAPIPkt[2] & REV_17B_PAGE_CODE_MASK)
  541.                                    == REV_17B_PAGE_CAPABILITIES))
  542.       {
  543.          Convert_17B_to_ATAPI( npACB->npCmdIO->IOSGPtrs.pSGList->ppXferBuf );
  544.       }
  545.  
  546.       (*pIORB->NotifyAddress)(pIORB);
  547.    }
  548.  
  549.    DISABLE
  550.  
  551.    if (( npACB->ResourceFlags & ACBRF_SHARED     ) &&
  552.        ( npACB->ResourceFlags & ACBRF_CURR_OWNER ) )
  553. //     && InitComplete)
  554.    {
  555.       if ( npACB->pHeadIORB )          /* more stuff to do */
  556.       {
  557.  
  558.          if ( QueryOtherAdd( npACB ) ) /* other add has stuff in queue */
  559.          {
  560.             npACB->OSMState = ACBOS_RESUME_COMPLETE;
  561.             npACB->OSMFlags |= ACBOF_WAITSTATE;
  562.             npACB->ResourceFlags &= ~ACBRF_CURR_OWNER;
  563.             ENABLE
  564.             ResumeOtherAdd( npACB );
  565.          }
  566.          else                          /* other add has empty queue */
  567.          {
  568.             npACB->OSMState = ACBOS_START_IORB;
  569.             if ( NextIORB( npACB ) )
  570.             {
  571.                _asm int 3             /* we said above we had stuff to do
  572.                                          and now we don't ? */
  573.             }
  574.          }
  575.       }
  576.       else                            /* no more work to do */
  577.       {
  578.          npACB->OSMState = ACBOS_RESUME_COMPLETE;
  579.          npACB->OSMFlags |= ACBOF_WAITSTATE;
  580.          npACB->ResourceFlags &= ~ACBRF_CURR_OWNER;                  /*V@93531*/
  581.          ENABLE
  582.          ResumeOtherAdd( npACB );
  583.       }
  584.    }
  585.    else
  586.    {
  587.       npACB->OSMState = ACBOS_START_IORB;
  588.  
  589.       if ( NextIORB( npACB ) )  /* DISABLE is in NextIORB */
  590.       {
  591.          npACB->OSMFlags |= ACBOF_WAITSTATE;
  592.          npACB->OSMFlags &= ~ACBOF_SM_ACTIVE;
  593.       }
  594.    }
  595.    ENABLE
  596. }
  597.  
  598. VOID NEAR Resume_Complete( NPACB npACB )
  599. {
  600.    DISABLE
  601.    npACB->suspended = 1;
  602.    if ( NextIORB( npACB) )
  603.    {
  604.       npACB->OSMState = ACBOS_START_IORB;
  605.       npACB->OSMFlags &= ~ACBOF_SM_ACTIVE;
  606.       npACB->OSMFlags |= ACBOF_WAITSTATE;
  607.    }
  608.    else
  609.    {
  610.       npACB->OSMState = ACBOS_SUSPEND_COMPLETE;
  611.       npACB->OSMFlags |= ACBOF_WAITSTATE;
  612.       ENABLE
  613.  
  614.       SuspendOtherAdd( npACB );
  615.    }
  616. }
  617.  
  618. VOID NEAR Suspend_Complete( NPACB npACB )
  619. {
  620.    UCHAR Data;
  621.  
  622.    DISABLE
  623.    npACB->suspended = 0;
  624.    npACB->OSMState = ACBOS_START_IORB;
  625.    npACB->OSMFlags &= ~ACBOF_WAITSTATE;                              /*V@93531*/
  626.    npACB->ResourceFlags |= ACBRF_CURR_OWNER;                         /*V@93531*/
  627.    ENABLE
  628. }
  629.  
  630. /*
  631. ╔══════════════════════════════════╗
  632. ║                                  ║
  633. ║                                  ║
  634. ║                                  ║
  635. ║                                  ║
  636. ║                                  ║
  637. ╚══════════════════════════════════╝
  638. */
  639. USHORT FAR NextIORB( NPACB npACB )
  640. {
  641.    DISABLE
  642.    if ( npACB->pIORB = npACB->pHeadIORB )
  643.    {
  644.       if ( !(npACB->pHeadIORB = npACB->pIORB->pNxtIORB) )
  645.       {
  646.          npACB->pFootIORB = 0;
  647.       }
  648.    }
  649.  
  650.    return( (npACB->pIORB) ? 0 : 1);
  651.  
  652. }
  653.  
  654. /*
  655. ╔══════════════════════════════════════════════════════════════════════════════╗
  656. ║                        IOCC_CONFIGUARTION Functions                          ║
  657. ╚══════════════════════════════════════════════════════════════════════════════╝
  658.  
  659. ╔══════════════════════════════════╗
  660. ║                                  ║
  661. ║                                  ║
  662. ║                                  ║
  663. ║                                  ║
  664. ║                                  ║
  665. ╚══════════════════════════════════╝
  666. */
  667. VOID NEAR GetDeviceTable( NPACB npACB )
  668. {
  669.  
  670.    PIORB_CONFIGURATION pIORB = (PIORB_CONFIGURATION) npACB->pIORB;
  671.  
  672.    USHORT        RequiredLength;
  673.    USHORT        AdapterIndex;
  674.    USHORT        UnitIndex;
  675.    PADAPTERINFO  pADPT;
  676.    PUNITINFO     pUI0, pUI1;
  677.    PDEVICETABLE  pDT;
  678.    NPACB         npACBP;
  679.  
  680.    RequiredLength = sizeof(DEVICETABLE);
  681.  
  682.    if ( pIORB->DeviceTableLen < RequiredLength )
  683.    {
  684.       pIORB->iorbh.Status   |= IORB_ERROR;
  685.       pIORB->iorbh.ErrorCode = IOERR_CMD_SYNTAX;
  686.    }
  687.    else
  688.    {
  689.       pDT = pIORB->pDeviceTable;
  690.  
  691.       pDT->ADDLevelMajor = ADD_LEVEL_MAJOR;
  692.       pDT->ADDLevelMinor = ADD_LEVEL_MINOR;
  693.       pDT->ADDHandle     = ADDHandle;
  694.       pDT->TotalAdapters = 0;
  695.  
  696.    } /* end else */
  697.  
  698.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  699.  
  700. } /* GetDeviceTable */
  701.  
  702. /*
  703. ╔══════════════════════════════════╗
  704. ║                                  ║
  705. ║                                  ║
  706. ║                                  ║
  707. ║                                  ║
  708. ║                                  ║
  709. ╚══════════════════════════════════╝
  710. */
  711. VOID NEAR CompleteInit( NPACB npACB )
  712. {
  713.    InitComplete = 1;
  714.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  715. }
  716.  
  717. /*
  718. ╔══════════════════════════════════════════════════════════════════════════════╗
  719. ║                        IOCC_UNIT_CONTROL Functions                           ║
  720. ╚══════════════════════════════════════════════════════════════════════════════╝
  721.  
  722. ╔══════════════════════════════════╗
  723. ║                                  ║
  724. ║                                  ║
  725. ║                                  ║
  726. ║                                  ║
  727. ║                                  ║
  728. ╚══════════════════════════════════╝
  729. */
  730. VOID NEAR AllocateUnit( NPACB npACB )
  731. {
  732.    NPUCB     npUCB;
  733.  
  734.    npUCB = npACB->npUCB;
  735.  
  736.    if ( npUCB->Flags & UCBF_ALLOCATED )
  737.    {
  738.       npACB->IORBError = IOERR_UNIT_ALLOCATED;
  739.    }
  740.    else
  741.    {
  742.       npUCB->Flags |= UCBF_ALLOCATED;
  743.    }
  744.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  745. }
  746.  
  747. /*
  748. ╔══════════════════════════════════╗
  749. ║                                  ║
  750. ║                                  ║
  751. ║                                  ║
  752. ║                                  ║
  753. ║                                  ║
  754. ╚══════════════════════════════════╝
  755. */
  756. VOID NEAR DeallocateUnit( NPACB npACB )
  757. {
  758.    NPUCB      npUCB;
  759.  
  760.    npUCB = npACB->npUCB;
  761.  
  762.    if( !(npUCB->Flags & UCBF_ALLOCATED) )
  763.    {
  764.       npACB->IORBError = IOERR_UNIT_NOT_ALLOCATED;
  765.    }
  766.    else
  767.    {
  768.       npUCB->Flags &= ~UCBF_ALLOCATED;
  769.    }
  770.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  771. }
  772.  
  773. /*
  774. ╔══════════════════════════════════╗
  775. ║                                  ║
  776. ║                                  ║
  777. ║                                  ║
  778. ║                                  ║
  779. ║                                  ║
  780. ╚══════════════════════════════════╝
  781. */
  782. VOID NEAR ChangeUnitInfo( NPACB npACB )
  783. {
  784.    npACB->npUCB->pUnitInfo = ((PIORB_UNIT_CONTROL) npACB->pIORB)->pUnitInfo;
  785.    npACB->OSMState         = ACBOS_COMPLETE_IORB;
  786. }
  787.  
  788. /*
  789. ╔══════════════════════════════════════════════════════════════════════════════╗
  790. ║                          IOCC_GEOMETRY Functions                             ║
  791. ╚══════════════════════════════════════════════════════════════════════════════╝
  792. ╔══════════════════════════════════╗
  793. ║                                  ║
  794. ║                                  ║
  795. ║                                  ║
  796. ║                                  ║
  797. ║                                  ║
  798. ╚══════════════════════════════════╝
  799. */
  800. VOID NEAR GetMediaGeometry( NPACB npACB )
  801. {
  802.  
  803.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  804. }
  805.  
  806. /*
  807. ╔══════════════════════════════════╗
  808. ║                                  ║
  809. ║                                  ║
  810. ║                                  ║
  811. ║                                  ║
  812. ║                                  ║
  813. ╚══════════════════════════════════╝
  814. */
  815. VOID NEAR GetDeviceGeometry( NPACB npACB )
  816. {
  817.  
  818.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  819. }
  820.  
  821. /*
  822. ╔══════════════════════════════════════════════════════════════════════════════╗
  823. ║                         IOCC_EXECUTE_IO Functions                            ║
  824. ╚══════════════════════════════════════════════════════════════════════════════╝
  825. ╔══════════════════════════════════╗
  826. ║                                  ║
  827. ║                                  ║
  828. ║                                  ║
  829. ║                                  ║
  830. ║                                  ║
  831. ╚══════════════════════════════════╝
  832. */
  833. VOID NEAR IORBRead( NPACB npACB )
  834. {
  835.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  836.  
  837. }
  838.  
  839. /*
  840. ╔══════════════════════════════════════════════════════════════════════════════╗
  841. ║                        IOCC_UNIT_STATUS Functions                            ║
  842. ╚══════════════════════════════════════════════════════════════════════════════╝
  843. ╔══════════════════════════════════╗
  844. ║                                  ║
  845. ║                                  ║
  846. ║                                  ║
  847. ║                                  ║
  848. ║                                  ║
  849. ╚══════════════════════════════════╝
  850. */
  851. VOID NEAR GetUnitStatus( NPACB npACB )
  852. {
  853.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  854.  
  855. }
  856.  
  857. /*
  858. ╔══════════════════════════════════╗
  859. ║                                  ║
  860. ║                                  ║
  861. ║                                  ║
  862. ║                                  ║
  863. ║                                  ║
  864. ╚══════════════════════════════════╝
  865. */
  866. VOID NEAR GetLockStatus( NPACB npACB )
  867. {
  868.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  869.  
  870. }
  871.  
  872. /*
  873. ╔══════════════════════════════════════════════════════════════════════════════╗
  874. ║                       IOCC_DEVICE_CONTROL Functions                          ║
  875. ╚══════════════════════════════════════════════════════════════════════════════╝
  876. ╔══════════════════════════════════╗
  877. ║                                  ║
  878. ║                                  ║
  879. ║                                  ║
  880. ║                                  ║
  881. ║                                  ║
  882. ╚══════════════════════════════════╝
  883. */
  884. VOID NEAR Abort( NPACB npACB )
  885. {
  886.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  887.  
  888. }
  889.  
  890. /*
  891. ╔══════════════════════════════════╗
  892. ║                                  ║
  893. ║                                  ║
  894. ║                                  ║
  895. ║                                  ║
  896. ║                                  ║
  897. ╚══════════════════════════════════╝
  898. */
  899. VOID NEAR Reset( NPACB npACB )
  900. {
  901.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  902.  
  903. }
  904.  
  905. /*
  906. ╔══════════════════════════════════╗
  907. ║                                  ║
  908. ║                                  ║
  909. ║                                  ║
  910. ║                                  ║
  911. ║                                  ║
  912. ╚══════════════════════════════════╝
  913. */
  914. VOID NEAR Suspend( NPACB npACB )
  915. {
  916.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  917.  
  918. }
  919.  
  920. /*
  921. ╔══════════════════════════════════╗
  922. ║                                  ║
  923. ║                                  ║
  924. ║                                  ║
  925. ║                                  ║
  926. ║                                  ║
  927. ╚══════════════════════════════════╝
  928. */
  929. VOID NEAR Resume( NPACB npACB )
  930. {
  931.  
  932.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  933. }
  934.  
  935. /*
  936. ╔══════════════════════════════════╗
  937. ║                                  ║
  938. ║                                  ║
  939. ║                                  ║
  940. ║                                  ║
  941. ║                                  ║
  942. ╚══════════════════════════════════╝
  943. */
  944. VOID NEAR LockMedia( NPACB npACB )
  945. {
  946.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  947.  
  948. }
  949.  
  950. /*
  951. ╔══════════════════════════════════╗
  952. ║                                  ║
  953. ║                                  ║
  954. ║                                  ║
  955. ║                                  ║
  956. ║                                  ║
  957. ╚══════════════════════════════════╝
  958. */
  959. VOID NEAR UnlockMedia( NPACB npACB )
  960. {
  961.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  962.  
  963. }
  964.  
  965. /*
  966. ╔══════════════════════════════════╗
  967. ║                                  ║
  968. ║                                  ║
  969. ║                                  ║
  970. ║                                  ║
  971. ║                                  ║
  972. ╚══════════════════════════════════╝
  973. */
  974. VOID NEAR EjectMedia( NPACB npACB )
  975. {
  976.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  977.  
  978. }
  979.  
  980. /*
  981. ╔══════════════════════════════════╗
  982. ║                                  ║
  983. ║                                  ║
  984. ║                                  ║
  985. ║                                  ║
  986. ║                                  ║
  987. ╚══════════════════════════════════╝
  988. */
  989. VOID NEAR GetQueueStatus( NPACB npACB )
  990. {
  991.  
  992.    npACB->OSMState = ACBOS_COMPLETE_IORB;
  993. }
  994.  
  995. /*
  996. ╔══════════════════════════════════════════════════════════════════════════════╗
  997. ║                      IOCC_ADAPTER_PASSTHRU Functions                         ║
  998. ╚══════════════════════════════════════════════════════════════════════════════╝
  999. /*
  1000. ╔══════════════════════════════════╗
  1001. ║                                  ║
  1002. ║                                  ║
  1003. ║                                  ║
  1004. ║                                  ║
  1005. ║                                  ║
  1006. ╚══════════════════════════════════╝
  1007. */
  1008. VOID NEAR Execute_CDB ( NPACB npACB)
  1009. {
  1010.    npACB->OSMFlags |= ACBOF_WAITSTATE;
  1011.    npACB->OSMState = ACBOS_ISM_COMPLETE;
  1012.    StartOSMRequest( npACB );
  1013. }
  1014.  
  1015. VOID NEAR SetUpXferData( NPACB npACB )
  1016. {
  1017.    PIORB_ADAPTER_PASSTHRU pIORB;
  1018.    UCHAR                  i;
  1019.    ULONG                  cXferBytes;
  1020.    PSCATGATENTRY          pTempSGList;
  1021.  
  1022.    pIORB = (PIORB_ADAPTER_PASSTHRU) npACB->pIORB;
  1023.  
  1024.    for ( i=0 ; i < pIORB->ControllerCmdLen ; i++ )
  1025.    {
  1026.       npACB->npCmdIO->ATAPIPkt[i] = pIORB->pControllerCmd[i];
  1027.    }
  1028.  
  1029.    /*
  1030.    ┌───────────────────────────────────────┐
  1031.    │ determine number of bytes in s/g list │
  1032.    └───────────────────────────────────────┘
  1033.    */
  1034.  
  1035.    cXferBytes = 0;
  1036.    pTempSGList = pIORB->pSGList;
  1037.  
  1038.    for ( i=0; i < pIORB->cSGList ; i++, pTempSGList++)
  1039.    {
  1040.       cXferBytes += pTempSGList->XferBufLen;
  1041.    } /* endfor */
  1042.  
  1043.    npACB->npCmdIO->cXferBytesRemain   = cXferBytes;
  1044.    npACB->npCmdIO->cXferBytesComplete = 0;
  1045.                                        /* Clear SG Pointer Entries */
  1046.    setmem ( (PBYTE)  &npACB->npCmdIO->IOSGPtrs, 0, sizeof (ADD_XFER_IO) );
  1047.  
  1048.    if ( cXferBytes )                   /* Data area is allocated */
  1049.    {
  1050.       npACB->npCmdIO->IOSGPtrs.Mode          = PORT_TO_SGLIST;
  1051.       npACB->npCmdIO->IOSGPtrs.cSGList       = pIORB->cSGList;
  1052.       npACB->npCmdIO->IOSGPtrs.pSGList       = pIORB->pSGList;
  1053.       npACB->npCmdIO->IOSGPtrs.iPortAddress  = npACB->IOPorts[FI_PDATA];
  1054.       npACB->npCmdIO->IOSGPtrs.iSGList       = 0;
  1055.       npACB->npCmdIO->IOSGPtrs.SGOffset      = 0;
  1056.       npACB->npCmdIO->IOSGPtrs.iSGListStart  = 0;
  1057.       npACB->npCmdIO->IOSGPtrs.SGOffsetStart = 0;
  1058.    }
  1059.  
  1060.    if ( npACB->ISMFlags & ACBIF_ATA_OPERATION )
  1061.    {
  1062.       if ( npACB->npUCB->ReqFlags & UCBR_IDENTIFY )
  1063.       {
  1064.          npACB->npCmdIO->IOSGPtrs.Mode = PORT_TO_SGLIST;
  1065.       }
  1066.    }
  1067. }
  1068.