home *** CD-ROM | disk | FTP | other *** search
/ Media Share 9 / MEDIASHARE_09.ISO / pascal / vdl020d.zip / VSALHIGH.DOC < prev    next >
Text File  |  1993-04-14  |  78KB  |  2,601 lines
  1. {
  2.  ════════════════════════════════════════════════════════════════════════════
  3.  
  4.  Visionix SCSI Abstraction Library High-level (VSALHIGH)
  5.  Copyright 1991,92,93 Visionix
  6.  ALL RIGHTS RESERVED
  7.  
  8.  ────────────────────────────────────────────────────────────────────────────
  9.  
  10.  Revision history in reverse chronological order:
  11.  
  12.  Initials  Date      Comment
  13.  ────────  ────────  ────────────────────────────────────────────────────────
  14.  
  15.  lpg       03/16/93  Added Source Documentation
  16.  
  17.  mep       02/11/93  Cleaned up code for beta release
  18.  
  19.  jrt       02/08/93  Sync with beta 0.12 release
  20.  
  21.  jrt       11/21/92  Sync with beta 0.08
  22.  
  23.  jrt       09/01/92  First logged revision.
  24.  
  25.  ════════════════════════════════════════════════════════════════════════════
  26.  
  27.  
  28.  INCOMPLETE FUNCTIONS
  29.  --------------------
  30.  
  31.  SAL_S2DasdSetLimits
  32.  SAL_S2DasdSearchData
  33.  
  34.  
  35. }
  36.  
  37. Unit VSALHIGH;
  38.  
  39.  
  40. Uses
  41.  
  42.   VTypes,
  43.   VSAL;
  44.  
  45.  
  46.  
  47. {------------------}
  48. { SCSI-2 Constants }
  49. {------------------}
  50.  
  51. Const
  52.  
  53.  
  54.   {----------------------------}
  55.   { Sense Data Flags and masks }
  56.   {----------------------------}
  57.  
  58.   RS_Valid           = $80;
  59.   RS_SenseKey        = $0F;
  60.   RS_IncorrectLength = $20;
  61.   RS_EOM             = $40;
  62.   RS_Filemark        = $80;
  63.  
  64.   RS_SKSV            = $80;
  65.  
  66.  
  67.   {------------------------------}
  68.   { Inquiry Data Flags and masks }
  69.   {------------------------------}
  70.  
  71.   INQ_PQPresent      = $00;
  72.   INQ_PQNotPresent   = $20;
  73.   INQ_PQReserved     = $40;
  74.   INQ_PQNotSupported = $60;
  75.  
  76.   INQ_Removable      = $80;
  77.  
  78.   INQ_ANSIVersion    = $07;
  79.   INQ_ECMAVersoin    = $38;
  80.   INQ_ISOVersion     = $C0;
  81.  
  82.   INQ_AENC           = $80;
  83.   INQ_TermIOP        = $40;
  84.  
  85.   INQ_ResDataFormat  = $0F;
  86.  
  87.   INQ_SoftReset      = $01;
  88.   INQ_CommandQueing  = $02;
  89.   INQ_Linked         = $08;
  90.   INQ_Synchronous    = $10;
  91.   INQ_WBus16         = $20;
  92.   INQ_WBus32         = $40;
  93.   INQ_RelAddressing  = $80;
  94.  
  95.  
  96.   {-------------------}
  97.   { SCSI Device Types }
  98.   {-------------------}
  99.  
  100.   DEV_DASD           = $00;
  101.   DEV_Sequential     = $01;
  102.   DEV_Printer        = $02;
  103.   DEV_Processor      = $03;
  104.   DEV_WORM           = $04;
  105.   DEV_CDROM          = $05;
  106.   DEV_Scanner        = $06;
  107.   DEV_Optical        = $07;
  108.   DEV_Changer        = $08;
  109.   DEV_Comm           = $09;
  110.   DEV_Unknown        = $1F;
  111.  
  112.  
  113.  
  114. {--------------}
  115. { SCSI-2 Types }
  116. {--------------}
  117.  
  118. Type
  119.  
  120.   T4Byte = Array[1..4] of BYTE;
  121.   T3Byte = Array[1..3] of BYTE;
  122.   T2Byte = Array[1..2] of BYTE;
  123.  
  124.   {--------------------}
  125.   { Request Sense Data }
  126.   {--------------------}
  127.  
  128. Type
  129.  
  130.   TReqSense = RECORD
  131.  
  132.     Error            : BYTE;
  133.     Segment          : BYTE;
  134.     SenseKey         : BYTE;
  135.     Information      : BYTE;
  136.     AddSenLen        : BYTE;
  137.     CommandInfo      : WORD;
  138.     AddSenseCode     : BYTE;
  139.     AddSenseQual     : BYTE;
  140.     FRUCode          : BYTE;
  141.     SenseSpec        : WORD;
  142.  
  143.   END;
  144.  
  145.  
  146.   PReqSense = ^TReqSense;
  147.  
  148.  
  149.   {--------------}
  150.   { Inquiry Data }
  151.   {--------------}
  152.  
  153. Type
  154.  
  155.   TInquiry = RECORD
  156.  
  157.     DevType          : BYTE;
  158.     DevModifier      : BYTE;
  159.     Version          : BYTE;
  160.     ResDataFormat    : BYTE;
  161.     AdditionalLen    : BYTE;
  162.     Reserved1        : BYTE;
  163.     Reserved2        : BYTE;
  164.     Flags            : BYTE;
  165.     Vendor           : Array[1..8 ] of CHAR;
  166.     Product          : Array[1..16] of CHAR;
  167.     ProductRev       : Array[1..4 ] of CHAR;
  168.  
  169.   END;
  170.  
  171.   PInquiry = ^TInquiry;
  172.  
  173.  
  174. {---------------------}
  175. { Direct Access Types }
  176. {---------------------}
  177.  
  178. Type
  179.  
  180.   TReadCapacity = RECORD
  181.  
  182.     LBA         : LONGINT;
  183.     BlockSize   : LONGINT;
  184.  
  185.   END;
  186.  
  187.  
  188.  
  189. {-------------------------}
  190. { Sequential Access Types }
  191. {-------------------------}
  192.  
  193. Type
  194.  
  195.   {-----------------------------}
  196.   { Read BlockLimits Data Types }
  197.   {-----------------------------}
  198.  
  199.   TSeqBlockLimits = RECORD
  200.  
  201.     Reserved         : BYTE;
  202.     MaxBlockLen      : T3Byte;
  203.     MinBlockLen      : WORD;
  204.  
  205.   END;
  206.  
  207.   PSeqBlockLimits = ^TSeqBlockLimits;
  208.  
  209.  
  210.  
  211.   {--------------------------}
  212.   { Read Position Data Types }
  213.   {--------------------------}
  214.  
  215.   TSeqPosition = RECORD
  216.  
  217.     Flags            : BYTE;
  218.     Partition        : BYTE;
  219.     Reserved1        : BYTE;
  220.     Reserved2        : BYTE;
  221.     FirstBlock       : WORD;
  222.     LastBlock        : WORD;
  223.     NumBlocksInBuff  : WORD;
  224.     NumBytesInBuff   : WORD;
  225.  
  226.   END;
  227.  
  228.   PSeqPosition = ^TSeqPosition;
  229.  
  230.  
  231.   {--------------}
  232.   { Mode Headers }
  233.   {--------------}
  234.  
  235.   TSeqMHeader6 = RECORD
  236.  
  237.     ModeDataLen      : BYTE;
  238.     MediumType       : BYTE;
  239.     DevParam         : BYTE;
  240.     BlockDescLen     : BYTE;
  241.  
  242.   END;
  243.  
  244.   PSeqMHeader6 = ^TSeqMHeader6;
  245.  
  246.  
  247.   TSeqMHeader10 = RECORD
  248.  
  249.     ModeDataLen      : WORD;
  250.     MediumType       : BYTE;
  251.     DevParam         : BYTE;
  252.     Reserved1        : BYTE;
  253.     Reserved2        : BYTE;
  254.     BlockDescLen     : WORD;
  255.  
  256.   END;
  257.  
  258.   PSeqMHeader10 = ^TSeqMHeader10;
  259.  
  260.   {---------------------------}
  261.   { Seq Mode Block Descriptor }
  262.   {---------------------------}
  263.  
  264.   TSeqMBlockDesc = RECORD
  265.  
  266.     DensityCode      : BYTE;
  267.     NumBlocks        : T3Byte;
  268.     Reserved         : BYTE;
  269.     BlockLen         : T3Byte;
  270.  
  271.   END;
  272.  
  273.   {------------------------------}
  274.   { Dev Config Mode Select Pager }
  275.   {------------------------------}
  276.  
  277.   TSeqMPageDevConfig = RECORD
  278.  
  279.     PageCode         : BYTE;
  280.     PageLen          : BYTE;
  281.     ActiveFormat     : BYTE;
  282.     ActivePartition  : BYTE;
  283.     WrBuffFullRatio  : BYTE;
  284.     RdBuffFullRation : BYTE;
  285.     WriteDelayTime   : WORD;
  286.     Flags1           : BYTE;
  287.     GapSize          : BYTE;
  288.     Flags2           : BYTE;
  289.     BuffSizeAtEW     : T3Byte;
  290.     Compression      : BYTE;
  291.     Reserved         : BYTE;
  292.  
  293.   END;
  294.  
  295.   PSeqMPageDevConfig = ^TSeqMPageDevConfig;
  296.  
  297.  
  298.   {------------------------}
  299.   { Medium Partitions Page }
  300.   {------------------------}
  301.  
  302.   TSeqMPageMediumPar = RECORD
  303.  
  304.     PageCode         : BYTE;
  305.     PageLen          : BYTE;
  306.     MaxAddPars       : BYTE;
  307.     AddParsDefined   : BYTE;
  308.     Flags            : BYTE;
  309.     MediumFormatRec  : BYTE;
  310.     Reserved1        : BYTE;
  311.     Reserved2        : BYTE;
  312.     ParSize          : Array[1..2] of WORD;
  313.  
  314.   END;
  315.  
  316.  
  317.   PSeqMPageMediumPar = ^TSeqMPageMediumPar;
  318.  
  319.   {--------------------------}
  320.   { Mode Error Recovery Page }
  321.   {--------------------------}
  322.  
  323.  
  324.   TSeqMPageErrRecovery = RECORD
  325.  
  326.     PageCode         : BYTE;
  327.     PageLen          : BYTE;
  328.     Flags            : BYTE;
  329.     ReadRetryCount   : BYTE;
  330.     Reserved1        : BYTE;
  331.     Reserved2        : BYTE;
  332.     Reserved3        : BYTE;
  333.     Reserved4        : BYTE;
  334.     WriteRetryCount  : BYTE;
  335.     REserved5        : BYTE;
  336.     Reserved6        : BYTE;
  337.     Reserved7        : BYTE;
  338.  
  339.   END;
  340.  
  341.   PSeqMPageErrRecovery = ^TSeqMPageErrRecovery;
  342.  
  343. {---------------}
  344. { Printer Types }
  345. {---------------}
  346.  
  347.   {----------------------------------------}
  348.   { Parallel Printer Interface Params Page }
  349.   {----------------------------------------}
  350.  
  351. Type
  352.  
  353.   TPrinterMPagePPIParams = RECORD
  354.  
  355.     PageCode          : BYTE;
  356.     ParamLen          : BYTE;
  357.     Flags             : BYTE;
  358.     Reserved          : BYTE;
  359.  
  360.   END;
  361.  
  362.   PPrinterMPagePPIParams = ^TPrinterMPagePPIParams;
  363.  
  364.   Const
  365.  
  366.  
  367.     prnMPagePPIParams = $03;
  368.  
  369.     prnAutoFeed       = $01;
  370.     prnVES            = $02;
  371.     prnVCBS           = $04;
  372.     prnVCBP           = $08;
  373.     prnPIPC           = $20;
  374.  
  375.     prnParityMask     = $C0;
  376.     prnParityShift    = 5;
  377.     prnParityNone     = $00;
  378.     prnParityEven     = $40;
  379.     PrnParityOdd      = $80;
  380.  
  381.  
  382.   {-------------------------------}
  383.   { Printer Options Mode Sel Page }
  384.   {-------------------------------}
  385.  
  386. Type
  387.  
  388.   TPrinterMPageOptions = RECORD
  389.  
  390.      PageCode         : BYTE;
  391.      ParamLen         : BYTE;
  392.      FontID           : BYTE;
  393.      Flags            : BYTE;
  394.      MaxLineLen       : WORD;
  395.      EVFUStartChar    : CHAR;
  396.      EVFUStopChar     : CHAR;
  397.      SlewOptions      : BYTE;
  398.      DataTermOptions  : BYTE;
  399.      Reserved1        : BYTE;
  400.      Reserved2        : BYTE;
  401.  
  402.   END;
  403.  
  404.   PPrinterMPageOptions = ^TPrinterMPageOptions;
  405.  
  406.   Const
  407.  
  408.     prnMPageOptions   = $05;
  409.  
  410.     prnAFC            = $01;
  411.     prnSCTE           = $02;
  412.  
  413.     prnSlewModeMask   = $30;
  414.     prnSlewModeShift  = 4;
  415.  
  416.     prnLineSlewMask   = $F0;
  417.     prnLineSlewShift  = 4;
  418.     prnFormSlewMask   = $0F;
  419.  
  420.     prnDataTermMask   = $F0;
  421.     prnDataTermShift  = 4;
  422.  
  423.  
  424.   {---------------------------------}
  425.   { Printer RS-232 Mode Select Page }
  426.   {---------------------------------}
  427.  
  428. Type
  429.  
  430.   TPrinterMPageRS232Params = RECORD
  431.  
  432.     PageCode          : BYTE;
  433.     ParamLen          : BYTE;
  434.     StopBitLen        : BYTE;
  435.     Flags1            : BYTE;
  436.     Flags2            : BYTE;
  437.     BPS               : T3BYTE;
  438.  
  439.   END;
  440.  
  441.   PPrinterMPageRS232Params = ^TPrinterMPageRS232Params;
  442.  
  443.   Const
  444.  
  445.     prnBPCMask        = $0F;
  446.  
  447.     prnPacingMask     = $0F;
  448.     prnPacingNone     = $00;
  449.     prnPacingXONOFF   = $01;
  450.     prnPacingETXACK   = $02;
  451.     prnPacingDTR      = $04;
  452.  
  453.     prn232ParityMask  = $E0;
  454.     prn232ParityShift = $6;
  455.     prn232ParityNone  = $00;
  456.     prn232ParityMark  = $20;
  457.     prn232ParitySpace = $40;
  458.     prn232ParityOdd   = $60;
  459.     prn232ParityEven  = $80;
  460.  
  461.  
  462.  
  463.  
  464. {------------------------------}
  465. { SCSI-2 All Device Functions. }
  466. {------------------------------}
  467.  
  468. {---------------------------------------------------------------------------}
  469.  
  470. Function  SAL_S2ChangeDefinition(   Handle      : THandle;
  471.                                     Bus         : BYTE;
  472.                                     Target      : BYTE;
  473.                                     Lun         : BYTE;
  474.                                     Flags       : BYTE;
  475.                                     Flags2      : BYTE;
  476.                                     Definition  : BYTE;
  477.                                     ParamSize   : LONGINT;
  478.                                     ParamBuff   : Pointer;
  479.                                     ReqSenSize  : LONGINT;
  480.                                     ReqSenBuff  : Pointer     ): TError;
  481.  
  482.   { Issues a CHANGE DEFINITION the specified device.             }
  483.  
  484.  
  485. {---------------------------------------------------------------------------}
  486.  
  487. Function  SAL_S2Inquiry(            Handle      : THandle;
  488.                                     Bus         : BYTE;
  489.                                     Target      : BYTE;
  490.                                     Lun         : BYTE;
  491.                                     Flags       : BYTE;
  492.                                     PageCode    : BYTE;
  493.                                     InqSize     : LONGINT;
  494.                                     InqBuff     : Pointer;
  495.                                     ReqSenSize  : LONGINT;
  496.                                     ReqSenBuff  : Pointer     ): TError;
  497.  
  498.   { Issues an INQUIRY to the specified device.                   }
  499.  
  500. Function  SAL_S2ModeSelect(         Handle      : THandle;
  501.                                     Bus         : BYTE;
  502.                                     Target      : BYTE;
  503.                                     Lun         : BYTE;
  504.                                     Flags       : BYTE;
  505.                                     ModeSelSize : LONGINT;
  506.                                     ModeSelBuff : Pointer;
  507.                                     ReqSenSize  : LONGINT;
  508.                                     ReqSenBuff  : Pointer     ): TError;
  509.  
  510.   { Issues a MODE SELECT to the specified device.                }
  511.  
  512.  
  513.  
  514. Function  SAL_S2ModeSense(          Handle      : THandle;
  515.                                     Bus         : BYTE;
  516.                                     Target      : BYTE;
  517.                                     Lun         : BYTE;
  518.                                     Flags       : BYTE;
  519.                                     Page        : BYTE;
  520.                                     PCF         : BYTE;
  521.                                     ModeSenSize : LONGINT;
  522.                                     ModeSenBuff : Pointer;
  523.                                     ReqSenSize  : LONGINT;
  524.                                     ReqSenBuff  : Pointer     ): TError;
  525.  
  526.   { Issues a MODE SENSE to the specified device.                 }
  527.  
  528.  
  529.  
  530.  
  531.  
  532.  
  533. Function  SAL_S2RequestSense(       Handle      : THandle;
  534.                                     Bus         : BYTE;
  535.                                     Target      : BYTE;
  536.                                     Lun         : BYTE;
  537.                                     Flags       : BYTE;
  538.                                     ReqSenSize  : LONGINT;
  539.                                     ReqSenBuff  : Pointer     ): TError;
  540.  
  541.  
  542.   { Issues a REQUEST SENSE to the specified device.              }
  543.  
  544.  
  545.  
  546.  
  547.  
  548.  
  549. Function  SAL_S2TestUnitReady(      Handle      : THandle;
  550.                                     Bus         : BYTE;
  551.                                     Target      : BYTE;
  552.                                     Lun         : BYTE;
  553.                                     Flags       : BYTE;
  554.                                     ReqSenSize  : LONGINT;
  555.                                     ReqSenBuff  : POINTER        ): TError;
  556.  
  557.   { Issues a TEST UNIT READY to the specified device.            }
  558.  
  559.  
  560.  
  561.  
  562. {--------------------------------------------------------------------------}
  563.  
  564.  
  565. {------------------------}
  566. { SCSI-2  DASD Functions }
  567. {------------------------}
  568.  
  569.  
  570. Function  SAL_S2DasdFormat(         Handle      : THandle;
  571.                                     Bus         : BYTE;
  572.                                     Target      : BYTE;
  573.                                     Lun         : BYTE;
  574.                                     Flags       : BYTE;
  575.                                     VendorSpec  : BYTE;
  576.                                     Interleave  : WORD;
  577.                                     DataSize    : LONGINT;
  578.                                     DataBuff    : POINTER;
  579.                                     ReqSenSize  : LONGINT;
  580.                                     ReqSenBuff  : POINTEr       ): TError;
  581.  
  582.   { Issues a DASD FORMAT to the specified device.                }
  583.  
  584.  
  585.  
  586.  
  587.  
  588. Function  SAL_S2DasdLockCache(      Handle      : THandle;
  589.                                     Bus         : BYTE;
  590.                                     Target      : BYTE;
  591.                                     Lun         : BYTE;
  592.                                     Flags       : BYTE;
  593.                                     StartBlock  : LONGINT;
  594.                                     NumBlocks   : LONGINT;
  595.                                     ReqSenSize  : LONGINT;
  596.                                     ReqSenBuff  : POINTER     ): TError;
  597.  
  598.   { Issues a LOCK/UNLOCK CACHE command                           }
  599.  
  600.  
  601.  
  602.  
  603.  
  604. Function  SAL_S2DasdPreFetch(       Handle      : THandle;
  605.                                     Bus         : BYTE;
  606.                                     Target      : BYTE;
  607.                                     Lun         : BYTE;
  608.                                     Flags       : BYTE;
  609.                                     StartBlock  : LONGINT;
  610.                                     NumBlocks   : LONGINT;
  611.                                     ReqSenSize  : LONGINT;
  612.                                     ReqSenBuff  : POINTER     ): TError;
  613.  
  614.   { Issues a PRE-FETCH command                                   }
  615.  
  616.  
  617.  
  618.  
  619.  
  620. Function  SAL_S2DasdLockMedia(      Handle      : THandle;
  621.                                     Bus         : BYTE;
  622.                                     Target      : BYTE;
  623.                                     Lun         : BYTE;
  624.                                     Flags       : BYTE;
  625.                                     ReqSenSize  : LONGINT;
  626.                                     ReqSenBuff  : POINTER     ): TError;
  627.  
  628. Function  SAL_S2DasdUnLockMedia(    Handle      : THandle;
  629.                                     Bus         : BYTE;
  630.                                     Target      : BYTE;
  631.                                     Lun         : BYTE;
  632.                                     Flags       : BYTE;
  633.                                     ReqSenSize  : LONGINT;
  634.                                     ReqSenBuff  : POINTER        ): TError;
  635.  
  636.   { These commands issue the PREVENT/ALLOW MEDIA REMOVAL command.}
  637.  
  638.  
  639.  
  640.  
  641. Function  SAL_S2DasdRead6(          Handle      : THandle;
  642.                                     Bus         : BYTE;
  643.                                     Target      : BYTE;
  644.                                     Lun         : BYTE;
  645.                                     Flags       : BYTE;
  646.                                     StartBlock  : LONGINT;
  647.                                     NumBlocks   : BYTE;
  648.                                     DataBuff    : POINTER;
  649.                                     ReqSenSize  : LONGINT;
  650.                                     ReqSenBuff  : POINTER        ): TError;
  651.  
  652.   { These commands issue the 6 byte READ command.                }
  653.  
  654.  
  655.  
  656.  
  657. Function  SAL_S2DasdRead(           Handle      : THandle;
  658.                                     Bus         : BYTE;
  659.                                     Target      : BYTE;
  660.                                     Lun         : BYTE;
  661.                                     Flags       : BYTE;
  662.                                     StartBlock  : LONGINT;
  663.                                     NumBlocks   : WORD;
  664.                                     DataBuff    : POINTER;
  665.                                     ReqSenSize  : LONGINT;
  666.                                     ReqSenBuff  : POINTER        ): TError;
  667.  
  668.   { These commands issue the 10 byte READ COMMAND.               }
  669.  
  670.  
  671.  
  672.  
  673.  
  674. Function  SAL_S2DasdReadCapacity(   Handle      : THandle;
  675.                                     Bus         : BYTE;
  676.                                     Target      : BYTE;
  677.                                     Lun         : BYTE;
  678.                                     Flags       : BYTE;
  679.                                     ReqSenSize  : LONGINT;
  680.                                     ReqSenBuff  : POINTER;
  681.                                 Var LBA         : LONGINT;
  682.                                 Var BlockSize   : LONGINT     ): TError;
  683.  
  684. Function  SAL_S2DasdXReadCapacity(  Handle      : THandle;
  685.                                     Bus         : BYTE;
  686.                                     Target      : BYTE;
  687.                                     Lun         : BYTE;
  688.                                     Flags       : BYTE;
  689.                                     LBA         : LONGINT;
  690.                                     Flags2      : BYTE;
  691.                                     ReqSenSize  : LONGINT;
  692.                                     ReqSenBuff  : POINTER;
  693.                                 Var RLBA        : LONGINT;
  694.                                 Var BlockSize   : LONGINT     ): TError;
  695.  
  696.  
  697.   { These commands issue the READ CAPACITY command.              }
  698.  
  699.  
  700.  
  701.  
  702. Function  SAL_S2DasdReadDefectData( Handle      : THandle;
  703.                                     Bus         : BYTE;
  704.                                     Target      : BYTE;
  705.                                     Lun         : BYTE;
  706.                                     Flags       : BYTE;
  707.                                     DfDataSize  : WORD;
  708.                                     DfDataBuff  : Pointer;
  709.                                     ReqSenSize  : LONGINT;
  710.                                     ReqSenBuff  : POINTER    ): TError;
  711.  
  712.   { Issues a READ DEFECT DATA command                            }
  713.  
  714.  
  715.  
  716.  
  717. Function  SAL_S2DasdReadLong(       Handle      : THandle;
  718.                                     Bus         : BYTE;
  719.                                     Target      : BYTE;
  720.                                     Lun         : BYTE;
  721.                                     Flags       : BYTE;
  722.                                     StartBlock  : LONGINT;
  723.                                     DataSize    : LONGINT;
  724.                                     DataBuff    : Pointer;
  725.                                     ReqSenSize  : LONGINT;
  726.                                     ReqSenBuff  : POINTER     ): TError;
  727.  
  728.   { This command issues the READ LONG command.                  }
  729.  
  730.  
  731.  
  732.  
  733.  
  734. Function  SAL_S2DasdReassignBlocks( Handle      : THandle;
  735.                                     Bus         : BYTE;
  736.                                     Target      : BYTE;
  737.                                     Lun         : BYTE;
  738.                                     Flags       : BYTE;
  739.                                     DataSize    : LONGINT;
  740.                                     DataBuff    : POINTER;
  741.                                     ReqSenSize  : LONGINT;
  742.                                     ReqSenBuff  : POINTER    ): TError;
  743.  
  744.   { This command issues the REASSIGN BLOCKS command.            }
  745.  
  746.  
  747.  
  748.  
  749.  
  750.  
  751. Function  SAL_S2DasdRelease(        Handle      : THandle;
  752.                                     Bus         : BYTE;
  753.                                     Target      : BYTE;
  754.                                     Lun         : BYTE;
  755.                                     Flags       : BYTE;
  756.                                     ReserveID   : BYTE;
  757.                                     ReqSenSize  : LONGINT;
  758.                                     ReqSenBuff  : POINTER        ): TError;
  759.  
  760.   { This command issues the RELEASE command.                    }
  761.  
  762.  
  763.  
  764.  
  765. Function  SAL_S2DasdReserve(        Handle      : THandle;
  766.                                     Bus         : BYTE;
  767.                                     Target      : BYTE;
  768.                                     Lun         : BYTE;
  769.                                     Flags       : BYTE;
  770.                                     ReserveID   : BYTE;
  771.                                     ExtentSize  : LONGINT;
  772.                                     ExtentBuff  : Pointer;
  773.                                     ReqSenSize  : LONGINT;
  774.                                     ReqSenBuff  : Pointer     ): TError;
  775.  
  776.   { This command issues the RESERVE command.                    }
  777.  
  778.  
  779.  
  780.  
  781.  
  782.  
  783. Function  SAL_S2DasdRezeroUnit(     Handle      : THandle;
  784.                                     Bus         : BYTE;
  785.                                     Target      : BYTE;
  786.                                     Lun         : BYTE;
  787.                                     Flags       : BYTE;
  788.                                     ReqSenSize  : LONGINT;
  789.                                     ReqSenBuff  : Pointer       ): TError;
  790.  
  791.   { This command issues the REZERO UNIT command.                }
  792.  
  793.  
  794.  
  795.  
  796. Function  SAL_S2DasdSearchData(     Handle      : THandle;
  797.                                     Bus         : BYTE;
  798.                                     Target      : BYTE;
  799.                                     Lun         : BYTE;
  800.                                     Flags       : BYTE;
  801.                                     LBA         : LONGINT;
  802.                                     NumBlocks   : WORD;
  803.                                     ParamSize   : LONGINT;
  804.                                     ParamBuff   : Pointer;
  805.                                     ReqSenSize  : LONGINT;
  806.                                     ReqSenBuff  : Pointer    ): TError;
  807.  
  808.   { This command issues the SEARCH DATA command.                }
  809.  
  810.  
  811.  
  812.  
  813.  
  814. Function  SAL_S2DasdSeek(           Handle      : THandle;
  815.                                     Bus         : BYTE;
  816.                                     Target      : BYTE;
  817.                                     Lun         : BYTE;
  818.                                     Flags       : BYTE;
  819.                                     LBA         : LONGINT;
  820.                                     ReqSenSize  : LONGINT;
  821.                                     ReqSenBuff  : Pointer    ): TError;
  822.  
  823.   { This command issues the SEEK command.                       }
  824.  
  825.  
  826.  
  827.  
  828.  
  829. Function  SAL_S2DasdSetLimits(      Handle      : THandle;
  830.                                     Bus         : BYTE;
  831.                                     Target      : BYTE;
  832.                                     Lun         : BYTE;
  833.                                     Flags       : BYTE;
  834.                                     StartBlock  : LONGINT;
  835.                                     NumBlocks   : WORD;
  836.                                     ReqSenSize  : LONGINT;
  837.                                     ReqSenBuff  : Pointer        ): TError;
  838.  
  839.   { These commands issue the SET LIMITS command.                }
  840.  
  841.  
  842.  
  843.  
  844.  
  845.  
  846.  
  847. Function  SAL_S2DasdStartStopUnit(  Handle      : THandle;
  848.                                     Bus         : BYTE;
  849.                                     Target      : BYTE;
  850.                                     Lun         : BYTE;
  851.                                     Flags       : BYTE;
  852.                                     Flags2      : BYTE;
  853.                                     ReqSenSize  : LONGINT;
  854.                                     ReqSenBuff  : Pointer      ): TError;
  855.  
  856.   { These commands issue the START/STOP UNIT COMMAND.            }
  857.  
  858.  
  859.  
  860.  
  861.  
  862. Function  SAL_S2DasdVerify(         Handle      : THandle;
  863.                                     Bus         : BYTE;
  864.                                     Target      : BYTE;
  865.                                     Lun         : BYTE;
  866.                                     Flags       : BYTE;
  867.                                     StartBlock  : LONGINT;
  868.                                     NumBlocks   : WORD;
  869.                                     DataBuff    : POINTER;
  870.                                     ReqSenSize  : LONGINT;
  871.                                     ReqSenBuff  : POINTER       ): TError;
  872.  
  873.   { These commands issue the SET LIMITS command.                }
  874.  
  875.  
  876.  
  877.  
  878.  
  879.  
  880.  
  881. Function  SAL_S2DasdWrite(          Handle      : THandle;
  882.                                     Bus         : BYTE;
  883.                                     Target      : BYTE;
  884.                                     Lun         : BYTE;
  885.                                     Flags       : BYTE;
  886.                                     StartBlock  : LONGINT;
  887.                                     NumBlocks   : WORD;
  888.                                     DataBuff    : POINTER;
  889.                                     ReqSenSize  : LONGINT;
  890.                                     ReqSenBuff  : POINTER      ): TError;
  891.  
  892.   { This command issues the DASD WRITE command.                 }
  893.  
  894.  
  895.  
  896.  
  897.  
  898.  
  899. Function  SAL_S2DasdWriteAndVerify( Handle      : THandle;
  900.                                     Bus         : BYTE;
  901.                                     Target      : BYTE;
  902.                                     Lun         : BYTE;
  903.                                     Flags       : BYTE;
  904.                                     StartBlock  : LONGINT;
  905.                                     NumBlocks   : WORD;
  906.                                     DataBuff    : POINTER;
  907.                                     ReqSenSize  : LONGINT;
  908.                                     ReqSenBuff  : POINTER      ): TError;
  909.  
  910.   { This command issues the DASD WRITE AND VERIFY command.      }
  911.  
  912.  
  913.  
  914.  
  915.  
  916. Function  SAL_S2DasdWriteLong(      Handle      : THandle;
  917.                                     Bus         : BYTE;
  918.                                     Target      : BYTE;
  919.                                     Lun         : BYTE;
  920.                                     Flags       : BYTE;
  921.                                     StartBlock  : LONGINT;
  922.                                     NumBlocks   : WORD;
  923.                                     DataBuff    : POINTER;
  924.                                     ReqSenSize  : LONGINT;
  925.                                     ReqSenBuff  : POINTER       ): TError;
  926.  
  927.   { This command issues the DASD WRITE LONG command.            }
  928.  
  929.  
  930.  
  931.  
  932. Function  SAL_S2DasdWriteSame(      Handle      : THandle;
  933.                                     Bus         : BYTE;
  934.                                     Target      : BYTE;
  935.                                     Lun         : BYTE;
  936.                                     Flags       : BYTE;
  937.                                     StartBlock  : LONGINT;
  938.                                     NumBlocks   : WORD;
  939.                                     DataBuff    : POINTER;
  940.                                     ReqSenSize  : LONGINT;
  941.                                     ReqSenBuff  : POINTER      ): TError;
  942.  
  943.   { This command issues the DASD WRITE SAME command.            }
  944.  
  945.  
  946.  
  947. (* *************************************
  948.    STARTING HERE - CODE COMMENTED OUT...
  949.    ************************************* *)
  950.  
  951.  
  952. (****
  953.  
  954. {────────────────────────────────────────────────────────────────────────────}
  955.  
  956. {--------------------------}
  957. { SCSI-2 Printer Functions }
  958. {--------------------------}
  959.  
  960. {────────────────────────────────────────────────────────────────────────────}
  961.  
  962. Function  SAL_S2PrinterFormat(      Handle      : THandle;
  963.                                     Bus         : BYTE;
  964.                                     Target      : BYTE;
  965.                                     Lun         : BYTE;
  966.                                     Flags       : BYTE;
  967.                                     DataSize    : LONGINT;
  968.                                     DataBuff    : Pointer;
  969.                                     ReqSenSize  : LONGINT;
  970.                                     ReqSenBuff  : POINTER     ): TError;
  971.  
  972.   { This command issues the PRINTER FORMAT command.            }
  973.  
  974.  
  975.  
  976.  
  977. Function  SAL_S2PrinterPrint(       Handle      : THandle;
  978.                                     Bus         : BYTE;
  979.                                     Target      : BYTE;
  980.                                     Lun         : BYTE;
  981.                                     Flags       : BYTE;
  982.                                     DataSize    : LONGINT;
  983.                                     DataBuff    : Pointer     ): TError;
  984.  
  985.   { This command issues the PRINTER PRINT  command.            }
  986.  
  987.  
  988. Function  SAL_S2PrinterRecoverData( Handle      : THandle;
  989.                                     Bus         : BYTE;
  990.                                     Target      : BYTE;
  991.                                     Lun         : BYTE;
  992.                                     Flags       : BYTE;
  993.                                     DataSize    : LONGINT;
  994.                                     DataBuff    : Pointer     ): TError;
  995.  
  996.   { This command issues the PRINTER RECOVER BUFFERED DATA      }
  997.  
  998.  
  999.  
  1000. Function  SAL_S2PrinterSlewPrint(   Handle      : THandle;
  1001.                                     Bus         : BYTE;
  1002.                                     Target      : BYTE;
  1003.                                     Lun         : BYTE;
  1004.                                     Flags       : BYTE;
  1005.                                     SlewVal     : BYTE;
  1006.                                     DataSize    : LONGINT;
  1007.                                     DataBuff    : Pointer     ): TError;
  1008.  
  1009.   { This command issues the PRINTER SLEW AND PRINT            }
  1010.  
  1011.  
  1012.  
  1013.  
  1014.  
  1015. Function  SAL_S2PrinterStopPrint(   Handle      : THandle;
  1016.                                     Bus         : BYTE;
  1017.                                     Target      : BYTE;
  1018.                                     Lun         : BYTE;
  1019.                                     Flags       : BYTE;
  1020.                                     VendorByte  : BYTE        ): TError;
  1021.  
  1022.   { This command issues the PRINTER STOP PRINT                }
  1023.  
  1024.  
  1025.  
  1026.  
  1027.  
  1028.  
  1029. Function  SAL_S2PrinterSyncBuffer(  Handle      : THandle;
  1030.                                     Bus         : BYTE;
  1031.                                     Target      : BYTE;
  1032.                                     Lun         : BYTE;
  1033.                                     Flags       : BYTE        ): TError;
  1034.  
  1035.   { This command issues the PRINTER SYNCHRONIZE BUFFER        }
  1036.  
  1037.  
  1038. {--------------------------------------------------------------------------}
  1039.  
  1040.  
  1041. {----------------------------}
  1042. { SCSI-2 Processor Functions }
  1043. {----------------------------}
  1044.  
  1045.  
  1046.  
  1047. Function  SAL_S2ProcSend(           Handle      : THandle;
  1048.                                     Bus         : BYTE;
  1049.                                     Target      : BYTE;
  1050.                                     Lun         : BYTE;
  1051.                                     Flags       : BYTE;
  1052.                                     DataSize    : LONGINT;
  1053.                                     DataBuff    : Pointer     ): TError;
  1054.  
  1055.   { This command issues the PROCESSOR SEND command            }
  1056.  
  1057.  
  1058.  
  1059.  
  1060.  
  1061.  
  1062. Function  SAL_S2ProcReceive(        Handle      : THandle;
  1063.                                     Bus         : BYTE;
  1064.                                     Target      : BYTE;
  1065.                                     Lun         : BYTE;
  1066.                                     Flags       : BYTE;
  1067.                                     DataSize    : LONGINT;
  1068.                                     DataBuff    : Pointer     ): TError;
  1069.  
  1070.   { This command issues the PROCESSOR RECEIVE command        }
  1071.  
  1072.  
  1073.  
  1074. {--------------------------------------------------------------------------}
  1075.  
  1076.  
  1077.  
  1078.  
  1079. Function  SAL_S2SeqErase(           Handle      : THandle;
  1080.                                     Bus         : BYTE;
  1081.                                     Target      : BYTE;
  1082.                                     Lun         : BYTE;
  1083.                                     Flags       : BYTE        ): TError;
  1084.  
  1085.   { This command issues the SEQUENTIAL ERASE command          }
  1086.  
  1087.  
  1088.  
  1089.  
  1090.  
  1091. Function  SAL_S2SeqLoadUnload(      Handle      : THandle;
  1092.                                     Bus         : BYTE;
  1093.                                     Target      : BYTE;
  1094.                                     Lun         : BYTE;
  1095.                                     Flags       : BYTE;
  1096.                                     Flags2      : BYTE        ): TError;
  1097.  
  1098.   { This command issues the SEQUENTIAL LOAD/UNLOAD command     }
  1099.  
  1100.  
  1101.  
  1102.  
  1103. Function  SAL_S2SeqLocate(          Handle      : THandle;
  1104.                                     Bus         : BYTE;
  1105.                                     Target      : BYTE;
  1106.                                     Lun         : BYTE;
  1107.                                     Flags       : BYTE;
  1108.                                     LBA         : LONGINT;
  1109.                                     Partition   : BYTE        ): TError;
  1110.  
  1111.   { This command issues the SEQUENTIAL LOCATE command          }
  1112.  
  1113.  
  1114.  
  1115.  
  1116.  
  1117. Function  SAL_S2SeqRead(            Handle      : THandle;
  1118.                                     Bus         : BYTE;
  1119.                                     Target      : BYTE;
  1120.                                     Lun         : BYTE;
  1121.                                     Flags       : BYTE;
  1122.                                     DataSize    : LONGINT;
  1123.                                     DataBuff    : Pointer     ): TError;
  1124.  
  1125.   { This command issues the SEQUENTIAL READcommand            }
  1126.  
  1127.  
  1128.  
  1129.  
  1130.  
  1131.  
  1132. Function  SAL_S2SeqReadBlockLimits( Handle      : THandle;
  1133.                                     Bus         : BYTE;
  1134.                                     Target      : BYTE;
  1135.                                     Lun         : BYTE;
  1136.                                     Flags       : BYTE;
  1137.                                     DataBuff    : Pointer     ): TError;
  1138.  
  1139.   { This command issues the SEQUENTIAL READ BLOCK LIMITS command  }
  1140.  
  1141.  
  1142.  
  1143.  
  1144.  
  1145. Function  SAL_S2SeqReadPosition(    Handle      : THandle;
  1146.                                     Bus         : BYTE;
  1147.                                     Target      : BYTE;
  1148.                                     Lun         : BYTE;
  1149.                                     Flags       : BYTE;
  1150.                                     DataBuff    : Pointer     ): TError;
  1151.  
  1152.   { This command issues the SEQUENTIAL READ POSITION command     }
  1153.  
  1154.  
  1155.  
  1156.  
  1157.  
  1158.  
  1159. Function  SAL_S2SeqReadReverse(     Handle      : THandle;
  1160.                                     Bus         : BYTE;
  1161.                                     Target      : BYTE;
  1162.                                     Lun         : BYTE;
  1163.                                     Flags       : BYTE;
  1164.                                     DataSize    : LONGINT;
  1165.                                     DataBuff    : Pointer     ): TError;
  1166.  
  1167.   { This command issues the SEQUENTIAL READ REVERSE command      }
  1168.  
  1169.  
  1170.  
  1171.  
  1172. Function  SAL_S2SeqRecoverData(     Handle      : THandle;
  1173.                                     Bus         : BYTE;
  1174.                                     Target      : BYTE;
  1175.                                     Lun         : BYTE;
  1176.                                     Flags       : BYTE;
  1177.                                     DataSize    : LONGINT;
  1178.                                     DataBuff    : Pointer     ): TError;
  1179.  
  1180.   { This command issues the SEQUENTIAL RECOVER BUFFERED DATA command          }
  1181.  
  1182.  
  1183.  
  1184.  
  1185.  
  1186. Function  SAL_S2SeqReleaseUnit(     Handle      : THandle;
  1187.                                     Bus         : BYTE;
  1188.                                     Target      : BYTE;
  1189.                                     Lun         : BYTE;
  1190.                                     Flags       : BYTE        ): TError;
  1191.  
  1192.   { This command issues the SEQUENTIAL RELEASE UNIT command          }
  1193.  
  1194.  
  1195.  
  1196.  
  1197. Function  SAL_S2SeqReserveUnit(     Handle      : THandle;
  1198.                                     Bus         : BYTE;
  1199.                                     Target      : BYTE;
  1200.                                     Lun         : BYTE;
  1201.                                     Flags       : BYTE        ): TError;
  1202.  
  1203.   { This command issues the SEQUENTIAL RESERVE UNIT command          }
  1204.  
  1205.  
  1206.  
  1207.  
  1208.  
  1209.  
  1210. Function  SAL_S2SeqRewind(          Handle      : THandle;
  1211.                                     Bus         : BYTE;
  1212.                                     Target      : BYTE;
  1213.                                     Lun         : BYTE;
  1214.                                     Flags       : BYTE        ): TError;
  1215.  
  1216.   { This command issues the SEQUENTIAL REWIND command          }
  1217.  
  1218.  
  1219.  
  1220.  
  1221. Function  SAL_S2SeqSpace(           Handle      : THandle;
  1222.                                     Bus         : BYTE;
  1223.                                     Target      : BYTE;
  1224.                                     Lun         : BYTE;
  1225.                                     Flags       : BYTE;
  1226.                                     Count       : LONGINT     ): TError;
  1227.  
  1228.   { This command issues the SEQUENTIAL SPACE command          }
  1229.  
  1230.  
  1231.  
  1232. Function  SAL_S2SeqVerify(          Handle      : THandle;
  1233.                                     Bus         : BYTE;
  1234.                                     Target      : BYTE;
  1235.                                     Lun         : BYTE;
  1236.                                     Flags       : BYTE;
  1237.                                     DataSize    : LONGINT;
  1238.                                     DataBuff    : Pointer     ): TError;
  1239.  
  1240.   { This command issues the SEQUENTIAL VERIFY command          }
  1241.  
  1242.  
  1243.  
  1244.  
  1245. Function  SAL_S2SeqWrite(           Handle      : THandle;
  1246.                                     Bus         : BYTE;
  1247.                                     Target      : BYTE;
  1248.                                     Lun         : BYTE;
  1249.                                     Flags       : BYTE;
  1250.                                     DataSize    : LONGINT;
  1251.                                     DataBuff    : Pointer     ): TError;
  1252.  
  1253.   { This command issues the SEQUENTIAL WRITE command          }
  1254.  
  1255.  
  1256.  
  1257.  
  1258. Function  SAL_S2SeqWriteFilemarks(  Handle      : THandle;
  1259.                                     Bus         : BYTE;
  1260.                                     Target      : BYTE;
  1261.                                     Lun         : BYTE;
  1262.                                     Flags       : BYTE;
  1263.                                     NumMarks    : LONGINT     ): TError;
  1264.  
  1265.   { This command issues the SEQUENTIAL ERASE command          }
  1266.  
  1267.  
  1268.  
  1269.  
  1270.  
  1271. {--------------------------------------------------------------------------}
  1272.  
  1273. {-------------------------}
  1274. { SCSI-2 CD-ROM Functions }
  1275. {-------------------------}
  1276.  
  1277.  
  1278.  
  1279.  
  1280. Function  SAL_S2CDPauseResume(         Bus         : BYTE;
  1281.                                     SubChannel  : BYTE;
  1282.                                     Target      : BYTE;
  1283.                                     Lun         : BYTE;
  1284.                                     Flags       : BYTE;
  1285.                                     Flags2      : BYTE        ): TError;
  1286.  
  1287.   { This command issues the CD-ROM PAUSE/RESUME command       }
  1288.  
  1289.  
  1290.  
  1291. Function  SAL_S2CDPlayAudio10(         Bus         : BYTE;
  1292.                                     SubChannel  : BYTE;
  1293.                                     Target      : BYTE;
  1294.                                     Lun         : BYTE;
  1295.                                     Flags       : BYTE;
  1296.                                     StartLBA    : LONGINT;
  1297.                                     DataSize    : LONGINT       ): TError;
  1298.  
  1299.   { This command issues the CD-ROM PLAY AUDIO 10 command       }
  1300.  
  1301.  
  1302.  
  1303. Function  SAL_S2CDPlayAudio12(         Bus         : BYTE;
  1304.                                     SubChannel  : BYTE;
  1305.                                     Target      : BYTE;
  1306.                                     Lun         : BYTE;
  1307.                                     Flags       : BYTE;
  1308.                                     StartLBA    : LONGINT;
  1309.                                     DataSize    : LONGINT     ): TError;
  1310.  
  1311.   { This command issues the CD-ROM PLAY AUDIO 12 command       }
  1312.  
  1313.  
  1314.  
  1315.  
  1316. Function  SAL_S2CDPlayAudioMSF(        Bus         : BYTE;
  1317.                                     SubChannel  : BYTE;
  1318.                                     Target      : BYTE;
  1319.                                     Lun         : BYTE;
  1320.                                     Flags       : BYTE;
  1321.                                     SM,SS,SF    : BYTE;
  1322.                                     EM,ES,EF    : BYTE        ): TError;
  1323.  
  1324.   { This command issues the CD-ROM PLAY AUDIO MSF command       }
  1325.  
  1326.  
  1327.  
  1328. Function  SAL_S2CDPlayAudioTrackIdx(   Bus         : BYTE;
  1329.                                     SubChannel  : BYTE;
  1330.                                     Target      : BYTE;
  1331.                                     Lun         : BYTE;
  1332.                                     Flags       : BYTE;
  1333.                                     ST,SI       : BYTE;
  1334.                                     ET,EI       : BYTE        ): TError;
  1335.  
  1336.   { This command issues the CD-ROM PLAY AUDIO TRACK INDEX       }
  1337.  
  1338.  
  1339.  
  1340. Function  SAL_S2CDPlayAudioTrackRel(   Bus         : BYTE;
  1341.                                     SubChannel  : BYTE;
  1342.                                     Target      : BYTE;
  1343.                                     Lun         : BYTE;
  1344.                                     Flags       : BYTE;
  1345.                                     TrackRelLBA : LONGINT;
  1346.                                     DataSize    : LONGINT     ): TError;
  1347.  
  1348.   { This command issues the CD-ROM PLAY AUDIO--TRACK RELATIVE ommand  }
  1349.  
  1350.  
  1351.  
  1352.  
  1353. Function  SAL_S2CDReadCapacity(        Bus         : BYTE;
  1354.                                     SubChannel  : BYTE;
  1355.                                     Target      : BYTE;
  1356.                                     Lun         : BYTE;
  1357.                                     Flags       : BYTE;
  1358.                                     LBA         : LONGINT;
  1359.                                     DataBuff    : Pointer     ): TError;
  1360.  
  1361.   { This command issues the CD-ROM READ CAPACITY command       }
  1362.  
  1363.  
  1364.  
  1365. Function  SAL_S2CDReadHeader(          Bus         : BYTE;
  1366.                                     SubChannel  : BYTE;
  1367.                                     Target      : BYTE;
  1368.                                     Lun         : BYTE;
  1369.                                     Flags       : BYTE;
  1370.                                     LBA         : LONGINT;
  1371.                                     DataSize    : LONGINT;
  1372.                                     DataBuff    : Pointer     ): TError;
  1373.  
  1374.   { This command issues the CD-ROM PAUSE/RESUME command       }
  1375.  
  1376.  
  1377.  
  1378. Function  SAL_S2CDReadSubChannel(      Bus         : BYTE;
  1379.                                     SubChannel  : BYTE;
  1380.                                     Target      : BYTE;
  1381.                                     Lun         : BYTE;
  1382.                                     Flags       : BYTE;
  1383.                                     Flags2      : BYTE;
  1384.                                     LBA         : LONGINT;
  1385.                                     DataSize    : LONGINT;
  1386.                                     DataBuff    : Pointer     ): TError;
  1387.  
  1388.   { This command issues the CD-ROM READ SUB-CHANNEL command   }
  1389.  
  1390.  
  1391.  
  1392. Function  SAL_S2CDReadTOC(             Bus         : BYTE;
  1393.                                     SubChannel  : BYTE;
  1394.                                     Target      : BYTE;
  1395.                                     Lun         : BYTE;
  1396.                                     Flags       : BYTE;
  1397.                                     StartTrack  : BYTE;
  1398.                                     DataSize    : LONGINT;
  1399.                                     DataBuff    : Pointer     ): TError;
  1400.  
  1401.   { This command issues the CD-ROM READ TOC command       }
  1402.  
  1403.  
  1404. {--------------------------------------------------------------------------}
  1405.  
  1406. {--------------------------}
  1407. { SCSI-2 Scanner Functions }
  1408. {--------------------------}
  1409.  
  1410.  
  1411.  
  1412.  
  1413.  
  1414.  
  1415.  
  1416.  
  1417.  
  1418.  
  1419.  
  1420.  
  1421.  
  1422.  
  1423.  
  1424.  
  1425.  
  1426.  
  1427.  
  1428.  
  1429.  
  1430.  
  1431.  
  1432.  
  1433. *********************** *)
  1434.  
  1435.  
  1436.  
  1437.  
  1438.  
  1439.  
  1440.  
  1441.  
  1442.  
  1443.  
  1444.  
  1445. ──────────────────────────────────────────────────────────────────────────────
  1446.  
  1447.  
  1448. [FUNCTION]
  1449.  
  1450. Function  SAL_S2ChangeDefinition(   Handle      : THandle;
  1451.                                     Bus         : BYTE;
  1452.                                     Target      : BYTE;
  1453.                                     Lun         : BYTE;
  1454.                                     Flags       : BYTE;
  1455.                                     Flags2      : BYTE;
  1456.                                     Definition  : BYTE;
  1457.                                     ParamSize   : LONGINT;
  1458.                                     ParamBuff   : Pointer;
  1459.                                     ReqSenSize  : LONGINT;
  1460.                                     ReqSenBuff  : Pointer    ): TError;
  1461.  
  1462. [PARAMETERS]
  1463.  
  1464. Handle      ?
  1465. Bus         Device Host Adapter Number
  1466. Target      Device Target ID
  1467. Lun         Device Logical Unit Number
  1468. Flags       ?
  1469. Flags2      ?
  1470. Definition  ?
  1471. ParamSize   Size of New Definition Data
  1472. ParamBuff   Pointer to New Definition Data
  1473. ReqSenSize  Size of Request Sense Buffer
  1474. ReqSenBuff  Pointer to Request Sense Buffer
  1475.  
  1476. [RETURNS]
  1477.  
  1478. [DESCRIPTION]
  1479.  
  1480. Issues a CHANGE DEFINITION the specified device.
  1481.  
  1482. [SEE-ALSO]
  1483.  
  1484. [EXAMPLE]
  1485.  
  1486.  
  1487. ──────────────────────────────────────────────────────────────────────────────
  1488.  
  1489.  
  1490. [FUNCTION]
  1491.  
  1492. Function  SAL_S2Inquiry(            Handle      : THandle;
  1493.                                     Bus         : BYTE;
  1494.                                     Target      : BYTE;
  1495.                                     Lun         : BYTE;
  1496.                                     Flags       : BYTE;
  1497.                                     PageCode    : BYTE;
  1498.                                     InqSize     : LONGINT;
  1499.                                     InqBuff     : Pointer;
  1500.                                     ReqSenSize  : LONGINT;
  1501.                                     ReqSenBuff  : Pointer   ): TError;
  1502.  
  1503. [PARAMETERS]
  1504.  
  1505. Handle      ?
  1506. Bus         Device Host Adapter Number
  1507. Target      Device Target ID
  1508. Lun         Device Logical Unit Number
  1509. Flags       ?
  1510. PageCode    Page Code
  1511. InqSize     Size of Inquiry Data Buffer
  1512. InqBuff     Pointer to Inquiry Data Buffer
  1513. ReqSenSize  Size of Request Sense Buffer
  1514. ReqSenBuff  Pointer to Request Sense Buffer
  1515.  
  1516. [RETURNS]
  1517.  
  1518. [DESCRIPTION]
  1519.  
  1520. Issues an INQUIRY to the specified device.
  1521.  
  1522. [SEE-ALSO]
  1523.  
  1524. [EXAMPLE]
  1525.  
  1526.  
  1527. ──────────────────────────────────────────────────────────────────────────────
  1528.  
  1529.  
  1530. [FUNCTION]
  1531.  
  1532. Function  SAL_S2ModeSelect(         Handle      : THandle;
  1533.                                     Bus         : BYTE;
  1534.                                     Target      : BYTE;
  1535.                                     Lun         : BYTE;
  1536.                                     Flags       : BYTE;
  1537.                                     ModeSelSize : LONGINT;
  1538.                                     ModeSelBuff : Pointer;
  1539.                                     ReqSenSize  : LONGINT;
  1540.                                     ReqSenBuff  : Pointer     ): TError;
  1541.  
  1542. [PARAMETERS]
  1543.  
  1544. Handle      ?
  1545. Bus         Device Host Adapter Number
  1546. Target      Device Target ID
  1547. Lun         Device Logical Unit Number
  1548. Flags       ?
  1549. ModeSelSize Size of Mode Select Buffer
  1550. ModeSelBuff Pointer to Mode Select Buffer
  1551. ReqSenSize  Size of Request Sense Buffer
  1552. ReqSenBuff  Pointer to Request Sense Buffer
  1553.  
  1554. [RETURNS]
  1555.  
  1556. [DESCRIPTION]
  1557.  
  1558. Issues a MODE SELECT to the specified device.
  1559.  
  1560. [SEE-ALSO]
  1561.  
  1562. [EXAMPLE]
  1563.  
  1564.  
  1565. ──────────────────────────────────────────────────────────────────────────────
  1566.  
  1567.  
  1568. [FUNCTION]
  1569.  
  1570. Function  SAL_S2ModeSense(          Handle      : THandle;
  1571.                                     Bus         : BYTE;
  1572.                                     Target      : BYTE;
  1573.                                     Lun         : BYTE;
  1574.                                     Flags       : BYTE;
  1575.                                     Page        : BYTE;
  1576.                                     PCF         : BYTE;
  1577.                                     ModeSenSize : LONGINT;
  1578.                                     ModeSenBuff : Pointer;
  1579.                                     ReqSenSize  : LONGINT;
  1580.                                     ReqSenBuff  : Pointer     ): TError;
  1581.  
  1582. [PARAMETERS]
  1583.  
  1584. Handle      ?
  1585. Bus         Device Host Adapter Number
  1586. Target      Device Target ID
  1587. Lun         Device Logical Unit Number
  1588. Flags       ?
  1589. Page        Request Page Number
  1590. PCF         Page Code Format Flag (1=Page Code Format,0=Not)
  1591. ModeSenSize Size of Mode Sense Buffer
  1592. ModeSenBuff Pointer to Mode Sense Buffer
  1593. ReqSenSize  Size of Request Sense Buffer
  1594. ReqSenBuff  Pointer to Request Sense Buffer
  1595.  
  1596. [RETURNS]
  1597.  
  1598. [DESCRIPTION]
  1599.  
  1600. Issues a MODE SENSE to the specified device.
  1601.  
  1602. [SEE-ALSO]
  1603.  
  1604. [EXAMPLE]
  1605.  
  1606.  
  1607. ──────────────────────────────────────────────────────────────────────────────
  1608.  
  1609.  
  1610. [FUNCTION]
  1611.  
  1612. Function  SAL_S2RequestSense(       Handle      : THandle;
  1613.                                     Bus         : BYTE;
  1614.                                     Target      : BYTE;
  1615.                                     Lun         : BYTE;
  1616.                                     Flags       : BYTE;
  1617.                                     ReqSenSize  : LONGINT;
  1618.                                     ReqSenBuff  : Pointer     ): TError;
  1619.  
  1620. [PARAMETERS]
  1621.  
  1622. Handle      ?
  1623. Bus         Device Host Adapter Number
  1624. Target      Device Target ID
  1625. Lun         Device Logical Unit Number
  1626. Flags       ?
  1627. ReqSenSize  Size of Request Sense Buffer
  1628. ReqSenBuff  Pointer to Request Sense Buffer
  1629.  
  1630. [RETURNS]
  1631.  
  1632. [DESCRIPTION]
  1633.  
  1634. Issues a REQUEST SENSE to the specified device.
  1635.  
  1636. [SEE-ALSO]
  1637.  
  1638. [EXAMPLE]
  1639.  
  1640.  
  1641. ──────────────────────────────────────────────────────────────────────────────
  1642.  
  1643.  
  1644. [FUNCTION]
  1645.  
  1646. Function  SAL_S2TestUnitReady(      Handle      : THandle;
  1647.                                     Bus         : BYTE;
  1648.                                     Target      : BYTE;
  1649.                                     Lun         : BYTE;
  1650.                                     Flags       : BYTE;
  1651.                                     ReqSenSize  : LONGINT;
  1652.                                     ReqSenBuff  : Pointer      ): TError;
  1653.  
  1654. [PARAMETERS]
  1655.  
  1656. Handle      ?
  1657. Bus         Device Host Adapter Number
  1658. Target      Device Target ID
  1659. Lun         Device Logical Unit Number
  1660. Flags       ?
  1661. ReqSenSize  Size of Request Sense Buffer
  1662. ReqSenBuff  Pointer to Request Sense Buffer
  1663.  
  1664. [RETURNS]
  1665.  
  1666. [DESCRIPTION]
  1667.  
  1668. Issues a TEST UNIT READY to the specified device.
  1669.  
  1670. [SEE-ALSO]
  1671.  
  1672. [EXAMPLE]
  1673.  
  1674.  
  1675. ──────────────────────────────────────────────────────────────────────────────
  1676.  
  1677.  
  1678. [FUNCTION]
  1679.  
  1680. Function  SAL_S2DasdFormat(         Handle      : THandle;
  1681.                                     Bus         : BYTE;
  1682.                                     Target      : BYTE;
  1683.                                     Lun         : BYTE;
  1684.                                     Flags       : BYTE;
  1685.                                     VendorSpec  : BYTE;
  1686.                                     Interleave  : WORD;
  1687.                                     DataSize    : LONGINT;
  1688.                                     DataBuff    : POINTER;
  1689.                                     ReqSenSize  : LONGINT;
  1690.                                     ReqSenBuff  : Pointer      ): TError;
  1691.  
  1692. [PARAMETERS]
  1693.  
  1694. Handle      ?
  1695. Bus         Device Host Adapter Number
  1696. Target      Device Target ID
  1697. Lun         Device Logical Unit Number
  1698. Flags       ?
  1699. VendorSpec  ?
  1700. Interleave  Desired Interleave
  1701. DataSize    Size of Format Information Data
  1702. DataBuff    Pointer to Format Infomation Data
  1703. ReqSenSize  Size of Request Sense Buffer
  1704. ReqSenBuff  Pointer to Request Sense Buffer
  1705.  
  1706. [RETURNS]
  1707.  
  1708. [DESCRIPTION]
  1709.  
  1710. Issues a DASD FORMAT to the specified device.
  1711.  
  1712. [SEE-ALSO]
  1713.  
  1714. [EXAMPLE]
  1715.  
  1716.  
  1717. ──────────────────────────────────────────────────────────────────────────────
  1718.  
  1719.  
  1720. [FUNCTION]
  1721.  
  1722. Function  SAL_S2DasdLockCache(      Handle      : THandle;
  1723.                                     Bus         : BYTE;
  1724.                                     Target      : BYTE;
  1725.                                     Lun         : BYTE;
  1726.                                     Flags       : BYTE;
  1727.                                     StartBlock  : LONGINT;
  1728.                                     NumBlocks   : LONGINT;
  1729.                                     ReqSenSize  : LONGINT;
  1730.                                     ReqSenBuff  : Pointer     ): TError;
  1731.  
  1732. [PARAMETERS]
  1733.  
  1734. Handle      ?
  1735. Bus         Device Host Adapter Number
  1736. Target      Device Target ID
  1737. Lun         Device Logical Unit Number
  1738. Flags       ?
  1739. StartBlock  Starting Block to Cache Lock
  1740. NumBlocks   Number of Blocks to Cache Lock
  1741. ReqSenSize  Size of Request Sense Buffer
  1742. ReqSenBuff  Pointer to Request Sense Buffer
  1743.  
  1744. [RETURNS]
  1745.  
  1746. [DESCRIPTION]
  1747.  
  1748. Issues a LOCK/UNLOCK CACHE command.
  1749.  
  1750. [SEE-ALSO]
  1751.  
  1752. [EXAMPLE]
  1753.  
  1754.  
  1755. ──────────────────────────────────────────────────────────────────────────────
  1756.  
  1757.  
  1758. [FUNCTION]
  1759.  
  1760. Function  SAL_S2DasdPreFetch(       Handle      : THandle;
  1761.                                     Bus         : BYTE;
  1762.                                     Target      : BYTE;
  1763.                                     Lun         : BYTE;
  1764.                                     Flags       : BYTE;
  1765.                                     StartBlock  : LONGINT;
  1766.                                     NumBlocks   : LONGINT;
  1767.                                     ReqSenSize  : LONGINT;
  1768.                                     ReqSenBuff  : Pointer      ): TError;
  1769.  
  1770. [PARAMETERS]
  1771.  
  1772. Handle      ?
  1773. Bus         Device Host Adapter Number
  1774. Target      Device Target ID
  1775. Lun         Device Logical Unit Number
  1776. Flags       ?
  1777. StartBlock  Starting Block to PreFetch
  1778. NumBlocks   Number of Blocks to PreFetch
  1779. ReqSenSize  Size of Request Sense Buffer
  1780. ReqSenBuff  Pointer to Request Sense Buffer
  1781.  
  1782. [RETURNS]
  1783.  
  1784. [DESCRIPTION]
  1785.  
  1786. Issues a PRE-FETCH command.
  1787.  
  1788. [SEE-ALSO]
  1789.  
  1790. [EXAMPLE]
  1791.  
  1792.  
  1793. ──────────────────────────────────────────────────────────────────────────────
  1794.  
  1795.  
  1796. [FUNCTION]
  1797.  
  1798. Function  SAL_S2DasdLockMedia(      Handle      : THandle;
  1799.                                     Bus         : BYTE;
  1800.                                     Target      : BYTE;
  1801.                                     Lun         : BYTE;
  1802.                                     Flags       : BYTE;
  1803.                                     ReqSenSize  : LONGINT;
  1804.                                     ReqSenBuff  : Pointer      ): TError;
  1805.  
  1806. [PARAMETERS]
  1807.  
  1808. Handle      ?
  1809. Bus         Device Host Adapter Number
  1810. Target      Device Target ID
  1811. Lun         Device Logical Unit Number
  1812. Flags       ?
  1813. ReqSenSize  Size of Request Sense Buffer
  1814. ReqSenBuff  Pointer to Request Sense Buffer
  1815.  
  1816. [RETURNS]
  1817.  
  1818. [DESCRIPTION]
  1819.  
  1820. [SEE-ALSO]
  1821.  
  1822. [EXAMPLE]
  1823.  
  1824.  
  1825. ──────────────────────────────────────────────────────────────────────────────
  1826.  
  1827.  
  1828. [FUNCTION]
  1829.  
  1830. Function  SAL_S2DasdUnLockMedia(    Handle      : THandle;
  1831.                                     Bus         : BYTE;
  1832.                                     Target      : BYTE;
  1833.                                     Lun         : BYTE;
  1834.                                     Flags       : BYTE;
  1835.                                     ReqSenSize  : LONGINT;
  1836.                                     ReqSenBuff  : Pointer       ): TError;
  1837.  
  1838. [PARAMETERS]
  1839.  
  1840. Handle      ?
  1841. Bus         Device Host Adapter Number
  1842. Target      Device Target ID
  1843. Lun         Device Logical Unit Number
  1844. Flags       ?
  1845. ReqSenSize  Size of Request Sense Buffer
  1846. ReqSenBuff  Pointer to Request Sense Buffer
  1847.  
  1848. [RETURNS]
  1849.  
  1850. [DESCRIPTION]
  1851.  
  1852. These commands issue the PREVENT/ALLOW MEDIA REMOVAL command.
  1853.  
  1854. [SEE-ALSO]
  1855.  
  1856. [EXAMPLE]
  1857.  
  1858.  
  1859. ──────────────────────────────────────────────────────────────────────────────
  1860.  
  1861.  
  1862. [FUNCTION]
  1863.  
  1864. Function  SAL_S2DasdRead6(          Handle      : THandle;
  1865.                                     Bus         : BYTE;
  1866.                                     Target      : BYTE;
  1867.                                     Lun         : BYTE;
  1868.                                     Flags       : BYTE;
  1869.                                     StartBlock  : LONGINT;
  1870.                                     NumBlocks   : BYTE;
  1871.                                     DataBuff    : POINTER;
  1872.                                     ReqSenSize  : LONGINT;
  1873.                                     ReqSenBuff  : POINTER    ): TError;
  1874.  
  1875. [PARAMETERS]
  1876.  
  1877. Handle      ?
  1878. Bus         Device Host Adapter Number
  1879. Target      Device Target ID
  1880. Lun         Device Logical Unit Number
  1881. Flags       ?
  1882. StartBlock  Starting Block to Read
  1883. NumBlocks   Number of Blocks to Read
  1884. DataBuff    Pointer to Read Data Buffer
  1885. ReqSenSize  Size of Request Sense Buffer
  1886. ReqSenBuff  Pointer to Request Sense Buffer
  1887.  
  1888. [RETURNS]
  1889.  
  1890. [DESCRIPTION]
  1891.  
  1892. These commands issue the 6 byte READ command.
  1893.  
  1894. [SEE-ALSO]
  1895.  
  1896. [EXAMPLE]
  1897.  
  1898.  
  1899. ──────────────────────────────────────────────────────────────────────────────
  1900.  
  1901.  
  1902. [FUNCTION]
  1903.  
  1904. Function  SAL_S2DasdRead(           Handle      : THandle;
  1905.                                     Bus         : BYTE;
  1906.                                     Target      : BYTE;
  1907.                                     Lun         : BYTE;
  1908.                                     Flags       : BYTE;
  1909.                                     StartBlock  : LONGINT;
  1910.                                     NumBlocks   : WORD;
  1911.                                     DataBuff    : POINTER;
  1912.                                     ReqSenSize  : LONGINT;
  1913.                                     ReqSenBuff  : POINTER        ): TError;
  1914.  
  1915. [PARAMETERS]
  1916.  
  1917. Handle      ?
  1918. Bus         Device Host Adapter Number
  1919. Target      Device Target ID
  1920. Lun         Device Logical Unit Number
  1921. Flags       ?
  1922. StartBlock  Starting Block to Read
  1923. NumBlocks   Number of Blocks to Read
  1924. DataBuff    Pointer to Read Data Buffer
  1925. ReqSenSize  Size of Request Sense Buffer
  1926. ReqSenBuff  Pointer to Request Sense Buffer
  1927.  
  1928. [RETURNS]
  1929.  
  1930. [DESCRIPTION]
  1931.  
  1932. These commands issue the 10 byte READ COMMAND.
  1933.  
  1934. [SEE-ALSO]
  1935.  
  1936. [EXAMPLE]
  1937.  
  1938.  
  1939. ──────────────────────────────────────────────────────────────────────────────
  1940.  
  1941.  
  1942. [FUNCTION]
  1943.  
  1944. Function  SAL_S2DasdReadCapacity(   Handle      : THandle;
  1945.                                     Bus         : BYTE;
  1946.                                     Target      : BYTE;
  1947.                                     Lun         : BYTE;
  1948.                                     Flags       : BYTE;
  1949.                                     ReqSenSize  : LONGINT;
  1950.                                     ReqSenBuff  : POINTER;
  1951.                                 Var LBA         : LONGINT;
  1952.                                 Var BlockSize   : LONGINT     ): TError;
  1953.  
  1954. [PARAMETERS]
  1955.  
  1956. Handle      ?
  1957. Bus         Device Host Adapter Number
  1958. Target      Device Target ID
  1959. Lun         Device Logical Unit Number
  1960. Flags       ?
  1961. ReqSenSize  Size of Request Sense Buffer
  1962. ReqSenBuff  Pointer to Request Sense Buffer
  1963. LBA         VAR Returned Last Block Address
  1964. BlockSize   VAR Returned Block Size
  1965.  
  1966. [RETURNS]
  1967.  
  1968. Function : ?
  1969. (VAR     : [LBA] Last Block Address)
  1970. (VAR     : [BlockSize] Block Size)
  1971.  
  1972. [DESCRIPTION]
  1973.  
  1974. [SEE-ALSO]
  1975.  
  1976. [EXAMPLE]
  1977.  
  1978.  
  1979. ──────────────────────────────────────────────────────────────────────────────
  1980.  
  1981.  
  1982. [FUNCTION]
  1983.  
  1984. Function  SAL_S2DasdXReadCapacity(  Handle      : THandle;
  1985.                                     Bus         : BYTE;
  1986.                                     Target      : BYTE;
  1987.                                     Lun         : BYTE;
  1988.                                     Flags       : BYTE;
  1989.                                     LBA         : LONGINT;
  1990.                                     Flags2      : BYTE;
  1991.                                     ReqSenSize  : LONGINT;
  1992.                                     ReqSenBuff  : POINTER;
  1993.                                 Var RLBA        : LONGINT;
  1994.                                 Var BlockSize   : LONGINT     ): TError;
  1995.  
  1996. [PARAMETERS]
  1997.  
  1998. Handle      ?
  1999. Bus         Device Host Adapter Number
  2000. Target      Device Target ID
  2001. Lun         Device Logical Unit Number
  2002. Flags       ?
  2003. LBA         ?
  2004. Flags2      ?
  2005. ReqSenSize  Size of Request Sense Buffer
  2006. ReqSenBuff  Pointer to Request Sense Buffer
  2007. RLBA        VAR Returned Last Block Address
  2008. BlockSize   VAR Returned Block Size
  2009.  
  2010. [RETURNS]
  2011.  
  2012. Function : ?
  2013. (VAR     : [RLBA] Last Block Address)
  2014. (VAR     : [BlockSize] Block Size)
  2015.  
  2016. [DESCRIPTION]
  2017.  
  2018. These commands issue the READ CAPACITY command.
  2019.  
  2020. [SEE-ALSO]
  2021.  
  2022. [EXAMPLE]
  2023.  
  2024.  
  2025. ──────────────────────────────────────────────────────────────────────────────
  2026.  
  2027.  
  2028. [FUNCTION]
  2029.  
  2030. Function  SAL_S2DasdReadDefectData( Handle      : THandle;
  2031.                                     Bus         : BYTE;
  2032.                                     Target      : BYTE;
  2033.                                     Lun         : BYTE;
  2034.                                     Flags       : BYTE;
  2035.                                     DfDataSize  : WORD;
  2036.                                     DfDataBuff  : Pointer;
  2037.                                     ReqSenSize  : LONGINT;
  2038.                                     ReqSenBuff  : POINTER     ): TError;
  2039.  
  2040. [PARAMETERS]
  2041.  
  2042. Handle      ?
  2043. Bus         Device Host Adapter Number
  2044. Target      Device Target ID
  2045. Lun         Device Logical Unit Number
  2046. Flags       ?
  2047. DfDataSize  Size of Defect List Data Buffer
  2048. DfDataBuff  Pointer to Defect List Data Buffer
  2049. ReqSenSize  Size of Request Sense Buffer
  2050. ReqSenBuff  Pointer to Request Sense Buffer
  2051.  
  2052. [RETURNS]
  2053.  
  2054. [DESCRIPTION]
  2055.  
  2056. Issues a READ DEFECT DATA command.
  2057.  
  2058. [SEE-ALSO]
  2059.  
  2060. [EXAMPLE]
  2061.  
  2062.  
  2063. ──────────────────────────────────────────────────────────────────────────────
  2064.  
  2065.  
  2066. [FUNCTION]
  2067.  
  2068. Function  SAL_S2DasdReadLong(       Handle      : THandle;
  2069.                                     Bus         : BYTE;
  2070.                                     Target      : BYTE;
  2071.                                     Lun         : BYTE;
  2072.                                     Flags       : BYTE;
  2073.                                     StartBlock  : LONGINT;
  2074.                                     DataSize    : LONGINT;
  2075.                                     DataBuff    : Pointer;
  2076.                                     ReqSenSize  : LONGINT;
  2077.                                     ReqSenBuff  : Pointer     ): TError;
  2078.  
  2079. [PARAMETERS]
  2080.  
  2081. Handle      ?
  2082. Bus         Device Host Adapter Number
  2083. Target      Device Target ID
  2084. Lun         Device Logical Unit Number
  2085. Flags       ?
  2086. StartBlock  Starting Block to Start Read
  2087. DataSize    Size of Read Data Buffer
  2088. DataBuff    Pointer to Read Data Buffer
  2089. ReqSenSize  Size of Request Sense Buffer
  2090. ReqSenBuff  Pointer to Request Sense Buffer
  2091.  
  2092. [RETURNS]
  2093.  
  2094. [DESCRIPTION]
  2095.  
  2096. This command issues the READ LONG command.
  2097.  
  2098. [SEE-ALSO]
  2099.  
  2100. [EXAMPLE]
  2101.  
  2102.  
  2103. ──────────────────────────────────────────────────────────────────────────────
  2104.  
  2105.  
  2106. [FUNCTION]
  2107.  
  2108. Function  SAL_S2DasdReassignBlocks( Handle      : THandle;
  2109.                                     Bus         : BYTE;
  2110.                                     Target      : BYTE;
  2111.                                     Lun         : BYTE;
  2112.                                     Flags       : BYTE;
  2113.                                     DataSize    : LONGINT;
  2114.                                     DataBuff    : POINTER;
  2115.                                     ReqSenSize  : LONGINT;
  2116.                                     ReqSenBuff  : POINTER       ): TError;
  2117.  
  2118. [PARAMETERS]
  2119.  
  2120. Handle      ?
  2121. Bus         Device Host Adapter
  2122. Target      Device Target ID
  2123. Lun         Device Logical Unit Number
  2124. Flags       ?
  2125. DataSize    Length of Block Reassign Data List
  2126. DataBuff    Pointer to Block Reassign Data List
  2127. ReqSenSize  Size of Request Sense Buffer
  2128. ReqSenBuff  Pointer to Request Sense Buffer
  2129.  
  2130. [RETURNS]
  2131.  
  2132. [DESCRIPTION]
  2133.  
  2134. This command issues the REASSIGN BLOCKS command.
  2135.  
  2136. [SEE-ALSO]
  2137.  
  2138. [EXAMPLE]
  2139.  
  2140.  
  2141. ──────────────────────────────────────────────────────────────────────────────
  2142.  
  2143.  
  2144. [FUNCTION]
  2145.  
  2146. Function  SAL_S2DasdRelease(        Handle      : THandle;
  2147.                                     Bus         : BYTE;
  2148.                                     Target      : BYTE;
  2149.                                     Lun         : BYTE;
  2150.                                     Flags       : BYTE;
  2151.                                     ReserveID   : BYTE;
  2152.                                     ReqSenSize  : LONGINT;
  2153.                                     ReqSenBuff  : Pointer      ): TError;
  2154.  
  2155. [PARAMETERS]
  2156.  
  2157. Handle      ?
  2158. Bus         Device Host Adapter Number
  2159. Target      Device Target ID
  2160. Lun         Device Logical Unit Number
  2161. Flags       ?
  2162. ReserveID   ?
  2163. ReqSenSize  Size of Request Sense Buffer
  2164. ReqSenBuff  Pointer to Request Sense Buffer
  2165.  
  2166. [RETURNS]
  2167.  
  2168. [DESCRIPTION]
  2169.  
  2170. This command issues the RELEASE command.
  2171.  
  2172. [SEE-ALSO]
  2173.  
  2174. [EXAMPLE]
  2175.  
  2176.  
  2177. ──────────────────────────────────────────────────────────────────────────────
  2178.  
  2179.  
  2180. [FUNCTION]
  2181.  
  2182. Function  SAL_S2DasdReserve(        Handle      : THandle;
  2183.                                     Bus         : BYTE;
  2184.                                     Target      : BYTE;
  2185.                                     Lun         : BYTE;
  2186.                                     Flags       : BYTE;
  2187.                                     ReserveID   : BYTE;
  2188.                                     ExtentSize  : LONGINT;
  2189.                                     ExtentBuff  : Pointer;
  2190.                                     ReqSenSize  : LONGINT;
  2191.                                     ReqSenBuff  : POINTER    ): TError;
  2192.  
  2193. [PARAMETERS]
  2194.  
  2195. Handle      ?
  2196. Bus         Device Host Adapter Number
  2197. Target      Device Target ID
  2198. Lun         Device Logical Unit Number
  2199. Flags       ?
  2200. ReserveID   ?
  2201. ExtentSize  Length of Reservation Extent Data
  2202. ExtentBuff  Pointer to Reservation Extent Data
  2203. ReqSenSize  Size of Request Sense Buffer
  2204. ReqSenBuff  Pointerto Request Sense Buffer
  2205.  
  2206. [RETURNS]
  2207.  
  2208. [DESCRIPTION]
  2209.  
  2210. This command issues the RESERVE command.
  2211.  
  2212. [SEE-ALSO]
  2213.  
  2214. [EXAMPLE]
  2215.  
  2216.  
  2217. ──────────────────────────────────────────────────────────────────────────────
  2218.  
  2219.  
  2220. [FUNCTION]
  2221.  
  2222. Function  SAL_S2DasdRezeroUnit(     Handle      : THandle;
  2223.                                     Bus         : BYTE;
  2224.                                     Target      : BYTE;
  2225.                                     Lun         : BYTE;
  2226.                                     Flags       : BYTE;
  2227.                                     ReqSenSize  : LONGINT;
  2228.                                     ReqSenBuff  : POINTER      ): TError;
  2229.  
  2230. [PARAMETERS]
  2231.  
  2232. Handle      ?
  2233. Bus         Device Host Adapter Number
  2234. Target      Device Target ID
  2235. Lun         Device Logical Unit Number
  2236. Flags       ?
  2237. ReqSenSize  Size of Request Sense Buffer
  2238. ReqSenBuff  Pointer to Request Sense Buffer
  2239.  
  2240. [RETURNS]
  2241.  
  2242. [DESCRIPTION]
  2243.  
  2244. This command issues the REZERO UNIT command.
  2245.  
  2246. [SEE-ALSO]
  2247.  
  2248. [EXAMPLE]
  2249.  
  2250.  
  2251. ──────────────────────────────────────────────────────────────────────────────
  2252.  
  2253.  
  2254. [FUNCTION]
  2255.  
  2256. Function  SAL_S2DasdSearchData(     Handle      : THandle;
  2257.                                     Bus         : BYTE;
  2258.                                     Target      : BYTE;
  2259.                                     Lun         : BYTE;
  2260.                                     Flags       : BYTE;
  2261.                                     LBA         : LONGINT;
  2262.                                     NumBlocks   : WORD;
  2263.                                     ParamSize   : LONGINT;
  2264.                                     ParamBuff   : Pointer;
  2265.                                     ReqSenSize  : LONGINT;
  2266.                                     ReqSenBuff  : Pointer    ): TError;
  2267.  
  2268. [PARAMETERS]
  2269.  
  2270. Handle      ?
  2271. Bus         Device Host Adapter Number
  2272. Target      Device Target ID
  2273. Lun         Device Logical Unit Number
  2274. Flags       ?
  2275. LBA         ?
  2276. NumBlocks   Number of Blocks to ?
  2277. ParamSize   Size of Search Data Buffer
  2278. ParamBuff   Pointer to Search Data Buffer
  2279. ReqSenSize  Size of Request Sense Buffer
  2280. ReqSenBuff  Pointer to Request Sense Buffer
  2281.  
  2282. [RETURNS]
  2283.  
  2284. [DESCRIPTION]
  2285.  
  2286. This command issues the SEARCH DATA command.
  2287.  
  2288. [SEE-ALSO]
  2289.  
  2290. [EXAMPLE]
  2291.  
  2292.  
  2293. ──────────────────────────────────────────────────────────────────────────────
  2294.  
  2295.  
  2296. [FUNCTION]
  2297.  
  2298. Function  SAL_S2DasdSeek(           Handle      : THandle;
  2299.                                     Bus         : BYTE;
  2300.                                     Target      : BYTE;
  2301.                                     Lun         : BYTE;
  2302.                                     Flags       : BYTE;
  2303.                                     LBA         : LONGINT;
  2304.                                     ReqSenSize  : LONGINT;
  2305.                                     ReqSenBuff  : POINTER    ): TError;
  2306.  
  2307. [PARAMETERS]
  2308.  
  2309. Handle      ?
  2310. Bus         Device Host Adapter Number
  2311. Target      Device Target ID
  2312. Lun         Device Logical Unit Number
  2313. Flags       ?
  2314. LBA         ?
  2315. ReqSenSize  Size of Request Sense Buffer
  2316. ReqSenBuff  Pointer to Request Sense Data
  2317.  
  2318. [RETURNS]
  2319.  
  2320. [DESCRIPTION]
  2321.  
  2322. This command issues the SEEK command.
  2323.  
  2324. [SEE-ALSO]
  2325.  
  2326. [EXAMPLE]
  2327.  
  2328.  
  2329. ──────────────────────────────────────────────────────────────────────────────
  2330.  
  2331.  
  2332. [FUNCTION]
  2333.  
  2334. Function  SAL_S2DasdSetLimits(      Handle      : THandle;
  2335.                                     Bus         : BYTE;
  2336.                                     Target      : BYTE;
  2337.                                     Lun         : BYTE;
  2338.                                     Flags       : BYTE;
  2339.                                     StartBlock  : LONGINT;
  2340.                                     NumBlocks   : WORD;
  2341.                                     ReqSenSize  : LONGINT;
  2342.                                     ReqSenBuff  : POINTER        ): TError;
  2343.  
  2344. [PARAMETERS]
  2345.  
  2346. Handle      ?
  2347. Bus         Device Host Adapter Number
  2348. Target      Device Target ID
  2349. Lun         Device Logical Unit Number
  2350. Flags       ?
  2351. StartBlock  Starting Block of Limit
  2352. NumBlocks   Number of Blocks to Set Limit On
  2353. ReqSenSize  Size of Request Sense Buffer
  2354. ReqSenBuff  Pointer to Request Sense Buffer
  2355.  
  2356. [RETURNS]
  2357.  
  2358. [DESCRIPTION]
  2359.  
  2360. These commands issue the SET LIMITS command.
  2361.  
  2362. [SEE-ALSO]
  2363.  
  2364. [EXAMPLE]
  2365.  
  2366.  
  2367. ──────────────────────────────────────────────────────────────────────────────
  2368.  
  2369.  
  2370. [FUNCTION]
  2371.  
  2372. Function  SAL_S2DasdStartStopUnit(  Handle      : THandle;
  2373.                                     Bus         : BYTE;
  2374.                                     Target      : BYTE;
  2375.                                     Lun         : BYTE;
  2376.                                     Flags       : BYTE;
  2377.                                     Flags2      : BYTE;
  2378.                                     ReqSenSize  : LONGINT;
  2379.                                     ReqSenBuff  : POINTER        ): TError;
  2380.  
  2381. [PARAMETERS]
  2382.  
  2383. Handle      ?
  2384. Bus         Device Host Adapter Number
  2385. Target      Device Target ID
  2386. Lun         Device Logical Unit Number
  2387. Flags       ?
  2388. Flags2      ?
  2389. ReqSenSize  Size of Request Sense Buffer
  2390. ReqSenBuff  Pointer to Request Sense Buffer
  2391.  
  2392. [RETURNS]
  2393.  
  2394. [DESCRIPTION]
  2395.  
  2396. These commands issue the START/STOP UNIT COMMAND.
  2397.  
  2398. [SEE-ALSO]
  2399.  
  2400. [EXAMPLE]
  2401.  
  2402.  
  2403. ──────────────────────────────────────────────────────────────────────────────
  2404.  
  2405.  
  2406. [FUNCTION]
  2407.  
  2408. Function  SAL_S2DasdVerify(         Handle      : THandle;
  2409.                                     Bus         : BYTE;
  2410.                                     Target      : BYTE;
  2411.                                     Lun         : BYTE;
  2412.                                     Flags       : BYTE;
  2413.                                     StartBlock  : LONGINT;
  2414.                                     NumBlocks   : WORD;
  2415.                                     DataBuff    : Pointer;
  2416.                                     ReqSenSize  : LONGINT;
  2417.                                     ReqSenBuff  : POINTER       ): TError;
  2418.  
  2419. [PARAMETERS]
  2420.  
  2421. Handle      ?
  2422. Bus         Device Host Adapter Number
  2423. Target      Device Target ID
  2424. Lun         Device Logical Unit Number
  2425. Flags       : BYTE;
  2426. StartBlock  Starting Block to
  2427. NumBlocks   Number of Blocks to Verify
  2428. DataBuff    Pointer to Verify Data Buffer
  2429. ReqSenSize  Size of Request Sense Buffer
  2430. ReqSenBuff  Pointer to Request Sense Buffer
  2431.  
  2432. [RETURNS]
  2433.  
  2434. [DESCRIPTION]
  2435.  
  2436. This command issues the DASD VERIFY command.
  2437.  
  2438. [SEE-ALSO]
  2439.  
  2440. [EXAMPLE]
  2441.  
  2442.  
  2443. ──────────────────────────────────────────────────────────────────────────────
  2444.  
  2445.  
  2446. [FUNCTION]
  2447.  
  2448. Function  SAL_S2DasdWrite(          Handle      : THandle;
  2449.                                     Bus         : BYTE;
  2450.                                     Target      : BYTE;
  2451.                                     Lun         : BYTE;
  2452.                                     Flags       : BYTE;
  2453.                                     StartBlock  : LONGINT;
  2454.                                     NumBlocks   : WORD;
  2455.                                     DataBuff    : POINTER;
  2456.                                     ReqSenSize  : LONGINT;
  2457.                                     ReqSenBuff  : POINTER      ): TError;
  2458. [PARAMETERS]
  2459.  
  2460. Handle      ?
  2461. Bus         Device Host Adapter Number
  2462. Target      Device Target ID
  2463. Lun         Device Logical Unit Number
  2464. Flags       ?
  2465. StartBlock  Starting Block to Write
  2466. NumBlocks   Number of Blocks to Write
  2467. DataBuff    Pointer to Write Buffer
  2468. ReqSenSize  Size of Request Sense Buffer
  2469. ReqSenBuff  Pointer to Request Sense Buffer
  2470.  
  2471. [RETURNS]
  2472.  
  2473. [DESCRIPTION]
  2474.  
  2475. This command issues the DASD WRITE command.
  2476.  
  2477. [SEE-ALSO]
  2478.  
  2479. [EXAMPLE]
  2480.  
  2481.  
  2482. ──────────────────────────────────────────────────────────────────────────────
  2483.  
  2484.  
  2485. [FUNCTION]
  2486.  
  2487. Function  SAL_S2DasdWriteAndVerify( Handle      : THandle;
  2488.                                     Bus         : BYTE;
  2489.                                     Target      : BYTE;
  2490.                                     Lun         : BYTE;
  2491.                                     Flags       : BYTE;
  2492.                                     StartBlock  : LONGINT;
  2493.                                     NumBlocks   : WORD;
  2494.                                     DataBuff    : POINTER;
  2495.                                     ReqSenSize  : LONGINT;
  2496.                                     ReqSenBuff  : POINTER     ): TError;
  2497.  
  2498. [PARAMETERS]
  2499.  
  2500. Handle      ?
  2501. Bus         Device Host Adapter Number
  2502. Target      Device Target ID
  2503. Lun         Device Logical Unit Number
  2504. Flags       ?
  2505. StartBlock  Starting Block to Write
  2506. NumBlocks   Number of Blocks to Write
  2507. DataBuff    Pointer to Write Buffer
  2508. ReqSenSize  Size of Request Sense Buffer
  2509. ReqSenBuff  Pointer to Request Sense Buffer
  2510.  
  2511. [RETURNS]
  2512.  
  2513. [DESCRIPTION]
  2514.  
  2515. This command issues the DASD WRITE AND VERIFY command.
  2516.  
  2517. [SEE-ALSO]
  2518.  
  2519. [EXAMPLE]
  2520.  
  2521.  
  2522. ──────────────────────────────────────────────────────────────────────────────
  2523.  
  2524.  
  2525. [FUNCTION]
  2526.  
  2527. Function  SAL_S2DasdWriteLong(      Handle      : THandle;
  2528.                                     Bus         : BYTE;
  2529.                                     Target      : BYTE;
  2530.                                     Lun         : BYTE;
  2531.                                     Flags       : BYTE;
  2532.                                     StartBlock  : LONGINT;
  2533.                                     NumBlocks   : WORD;
  2534.                                     DataBuff    : POINTER;
  2535.                                     ReqSenSize  : LONGINT;
  2536.                                     ReqSenBuff  : POINTER       ): TError;
  2537.  
  2538. [PARAMETERS]
  2539.  
  2540. Handle      ?
  2541. Bus         Device Host Adapter Number
  2542. Target      Device Target ID
  2543. Lun         Device Logical Unit Number
  2544. Flags       ?
  2545. StartBlock  Starting Block to Write
  2546. NumBlocks   Number of Blocks to Write
  2547. DataBuff    Pointer to Write Buffer
  2548. ReqSenSize  Size of Request Sense Buffer
  2549. ReqSenBuff  Pointer to Request Sense Buffer
  2550.  
  2551. [RETURNS]
  2552.  
  2553. [DESCRIPTION]
  2554.  
  2555. This command issues the DASD WRITE LONG command.
  2556.  
  2557. [SEE-ALSO]
  2558.  
  2559. [EXAMPLE]
  2560.  
  2561.  
  2562. ──────────────────────────────────────────────────────────────────────────────
  2563.  
  2564.  
  2565. [FUNCTION]
  2566.  
  2567. Function  SAL_S2DasdWriteSame(      Handle      : THandle;
  2568.                                     Bus         : BYTE;
  2569.                                     Target      : BYTE;
  2570.                                     Lun         : BYTE;
  2571.                                     Flags       : BYTE;
  2572.                                     StartBlock  : LONGINT;
  2573.                                     NumBlocks   : WORD;
  2574.                                     DataBuff    : POINTER;
  2575.                                     ReqSenSize  : LONGINT;
  2576.                                     ReqSenBuff  : POINTER    ): TError;
  2577.  
  2578. [PARAMETERS]
  2579.  
  2580. Handle      ?
  2581. Bus         Device Host Adapter Number
  2582. Target      Device Target ID
  2583. Lun         Device Logical Unit Number
  2584. Flags       ?
  2585. StartBlock  Starting Block to Write
  2586. NumBlocks   Number of Blocks to Write
  2587. DataBuff    Pointer to Write Buffer
  2588. ReqSenSize  Size of Request Sense Buffer
  2589. ReqSenBuff  Pointer to Request Sense Buffer
  2590.  
  2591. [RETURNS]
  2592.  
  2593. [DESCRIPTION]
  2594.  
  2595. This command issues the DASD WRITE SAME command.
  2596.  
  2597. [SEE-ALSO]
  2598.  
  2599. [EXAMPLE]
  2600.  
  2601.