freepascal.compiler/packages/univint/src/SCSI.pas

{
     File:       OSServices/SCSI.h
 
     Contains:   SCSI Family Interfaces.
 
     Version:    OSServices-352~2
 
     Copyright:  © 1986-2008 by Apple Computer, Inc., all rights reserved
 
     Bugs?:      For bug reports, consult the following page on
                 the World Wide Web:
 
                     http://bugs.freepascal.org
 
}
{      Pascal Translation Updated:  Jonas Maebe, <[email protected]>, October 2009 }
{
    Modified for use with Free Pascal
    Version 308
    Please report any bugs to <[email protected]>
}

{$ifc not defined MACOSALLINCLUDE or not MACOSALLINCLUDE}
{$mode macpas}
{$packenum 1}
{$macro on}
{$inline on}
{$calling mwpascal}

unit SCSI;
interface
{$setc UNIVERSAL_INTERFACES_VERSION := $0400}
{$setc GAP_INTERFACES_VERSION := $0308}

{$ifc not defined USE_CFSTR_CONSTANT_MACROS}
    {$setc USE_CFSTR_CONSTANT_MACROS := TRUE}
{$endc}

{$ifc defined CPUPOWERPC and defined CPUI386}
	{$error Conflicting initial definitions for CPUPOWERPC and CPUI386}
{$endc}
{$ifc defined FPC_BIG_ENDIAN and defined FPC_LITTLE_ENDIAN}
	{$error Conflicting initial definitions for FPC_BIG_ENDIAN and FPC_LITTLE_ENDIAN}
{$endc}

{$ifc not defined __ppc__ and defined CPUPOWERPC32}
	{$setc __ppc__ := 1}
{$elsec}
	{$setc __ppc__ := 0}
{$endc}
{$ifc not defined __ppc64__ and defined CPUPOWERPC64}
	{$setc __ppc64__ := 1}
{$elsec}
	{$setc __ppc64__ := 0}
{$endc}
{$ifc not defined __i386__ and defined CPUI386}
	{$setc __i386__ := 1}
{$elsec}
	{$setc __i386__ := 0}
{$endc}
{$ifc not defined __x86_64__ and defined CPUX86_64}
	{$setc __x86_64__ := 1}
{$elsec}
	{$setc __x86_64__ := 0}
{$endc}
{$ifc not defined __arm__ and defined CPUARM}
	{$setc __arm__ := 1}
{$elsec}
	{$setc __arm__ := 0}
{$endc}
{$ifc not defined __arm64__ and defined CPUAARCH64}
  {$setc __arm64__ := 1}
{$elsec}
  {$setc __arm64__ := 0}
{$endc}

{$ifc defined cpu64}
  {$setc __LP64__ := 1}
{$elsec}
  {$setc __LP64__ := 0}
{$endc}


{$ifc defined __ppc__ and __ppc__ and defined __i386__ and __i386__}
	{$error Conflicting definitions for __ppc__ and __i386__}
{$endc}

{$ifc defined __ppc__ and __ppc__}
	{$setc TARGET_CPU_PPC := TRUE}
	{$setc TARGET_CPU_PPC64 := FALSE}
	{$setc TARGET_CPU_X86 := FALSE}
	{$setc TARGET_CPU_X86_64 := FALSE}
	{$setc TARGET_CPU_ARM := FALSE}
	{$setc TARGET_CPU_ARM64 := FALSE}
	{$setc TARGET_OS_MAC := TRUE}
	{$setc TARGET_OS_IPHONE := FALSE}
	{$setc TARGET_IPHONE_SIMULATOR := FALSE}
	{$setc TARGET_OS_EMBEDDED := FALSE}
{$elifc defined __ppc64__ and __ppc64__}
	{$setc TARGET_CPU_PPC := FALSE}
	{$setc TARGET_CPU_PPC64 := TRUE}
	{$setc TARGET_CPU_X86 := FALSE}
	{$setc TARGET_CPU_X86_64 := FALSE}
	{$setc TARGET_CPU_ARM := FALSE}
	{$setc TARGET_CPU_ARM64 := FALSE}
	{$setc TARGET_OS_MAC := TRUE}
	{$setc TARGET_OS_IPHONE := FALSE}
	{$setc TARGET_IPHONE_SIMULATOR := FALSE}
	{$setc TARGET_OS_EMBEDDED := FALSE}
{$elifc defined __i386__ and __i386__}
	{$setc TARGET_CPU_PPC := FALSE}
	{$setc TARGET_CPU_PPC64 := FALSE}
	{$setc TARGET_CPU_X86 := TRUE}
	{$setc TARGET_CPU_X86_64 := FALSE}
	{$setc TARGET_CPU_ARM := FALSE}
	{$setc TARGET_CPU_ARM64 := FALSE}
{$ifc defined(iphonesim)}
 	{$setc TARGET_OS_MAC := FALSE}
	{$setc TARGET_OS_IPHONE := TRUE}
	{$setc TARGET_IPHONE_SIMULATOR := TRUE}
{$elsec}
	{$setc TARGET_OS_MAC := TRUE}
	{$setc TARGET_OS_IPHONE := FALSE}
	{$setc TARGET_IPHONE_SIMULATOR := FALSE}
{$endc}
	{$setc TARGET_OS_EMBEDDED := FALSE}
{$elifc defined __x86_64__ and __x86_64__}
	{$setc TARGET_CPU_PPC := FALSE}
	{$setc TARGET_CPU_PPC64 := FALSE}
	{$setc TARGET_CPU_X86 := FALSE}
	{$setc TARGET_CPU_X86_64 := TRUE}
	{$setc TARGET_CPU_ARM := FALSE}
	{$setc TARGET_CPU_ARM64 := FALSE}
{$ifc defined(iphonesim)}
 	{$setc TARGET_OS_MAC := FALSE}
	{$setc TARGET_OS_IPHONE := TRUE}
	{$setc TARGET_IPHONE_SIMULATOR := TRUE}
{$elsec}
	{$setc TARGET_OS_MAC := TRUE}
	{$setc TARGET_OS_IPHONE := FALSE}
	{$setc TARGET_IPHONE_SIMULATOR := FALSE}
{$endc}
	{$setc TARGET_OS_EMBEDDED := FALSE}
{$elifc defined __arm__ and __arm__}
	{$setc TARGET_CPU_PPC := FALSE}
	{$setc TARGET_CPU_PPC64 := FALSE}
	{$setc TARGET_CPU_X86 := FALSE}
	{$setc TARGET_CPU_X86_64 := FALSE}
	{$setc TARGET_CPU_ARM := TRUE}
	{$setc TARGET_CPU_ARM64 := FALSE}
	{ will require compiler define when/if other Apple devices with ARM cpus ship }
	{$setc TARGET_OS_MAC := FALSE}
	{$setc TARGET_OS_IPHONE := TRUE}
	{$setc TARGET_IPHONE_SIMULATOR := FALSE}
	{$setc TARGET_OS_EMBEDDED := TRUE}
{$elifc defined __arm64__ and __arm64__}
	{$setc TARGET_CPU_PPC := FALSE}
	{$setc TARGET_CPU_PPC64 := FALSE}
	{$setc TARGET_CPU_X86 := FALSE}
	{$setc TARGET_CPU_X86_64 := FALSE}
	{$setc TARGET_CPU_ARM := FALSE}
	{$setc TARGET_CPU_ARM64 := TRUE}
	{ will require compiler define when/if other Apple devices with ARM cpus ship }
	{$setc TARGET_OS_MAC := FALSE}
	{$setc TARGET_OS_IPHONE := TRUE}
	{$setc TARGET_IPHONE_SIMULATOR := FALSE}
	{$setc TARGET_OS_EMBEDDED := TRUE}
{$elsec}
	{$error __ppc__ nor __ppc64__ nor __i386__ nor __x86_64__ nor __arm__ nor __arm64__ is defined.}
{$endc}

{$ifc defined __LP64__ and __LP64__ }
  {$setc TARGET_CPU_64 := TRUE}
{$elsec}
  {$setc TARGET_CPU_64 := FALSE}
{$endc}

{$ifc defined FPC_BIG_ENDIAN}
	{$setc TARGET_RT_BIG_ENDIAN := TRUE}
	{$setc TARGET_RT_LITTLE_ENDIAN := FALSE}
{$elifc defined FPC_LITTLE_ENDIAN}
	{$setc TARGET_RT_BIG_ENDIAN := FALSE}
	{$setc TARGET_RT_LITTLE_ENDIAN := TRUE}
{$elsec}
	{$error Neither FPC_BIG_ENDIAN nor FPC_LITTLE_ENDIAN are defined.}
{$endc}
{$setc ACCESSOR_CALLS_ARE_FUNCTIONS := TRUE}
{$setc CALL_NOT_IN_CARBON := FALSE}
{$setc OLDROUTINENAMES := FALSE}
{$setc OPAQUE_TOOLBOX_STRUCTS := TRUE}
{$setc OPAQUE_UPP_TYPES := TRUE}
{$setc OTCARBONAPPLICATION := TRUE}
{$setc OTKERNEL := FALSE}
{$setc PM_USE_SESSION_APIS := TRUE}
{$setc TARGET_API_MAC_CARBON := TRUE}
{$setc TARGET_API_MAC_OS8 := FALSE}
{$setc TARGET_API_MAC_OSX := TRUE}
{$setc TARGET_CARBON := TRUE}
{$setc TARGET_CPU_68K := FALSE}
{$setc TARGET_CPU_MIPS := FALSE}
{$setc TARGET_CPU_SPARC := FALSE}
{$setc TARGET_OS_UNIX := FALSE}
{$setc TARGET_OS_WIN32 := FALSE}
{$setc TARGET_RT_MAC_68881 := FALSE}
{$setc TARGET_RT_MAC_CFM := FALSE}
{$setc TARGET_RT_MAC_MACHO := TRUE}
{$setc TYPED_FUNCTION_POINTERS := TRUE}
{$setc TYPE_BOOL := FALSE}
{$setc TYPE_EXTENDED := FALSE}
{$setc TYPE_LONGLONG := TRUE}
uses MacTypes,MixedMode,AppleDiskPartitions;
{$endc} {not MACOSALLINCLUDE}


{$ifc TARGET_OS_MAC and not TARGET_CPU_64}

{$ALIGN MAC68K}

{ TIB opcodes }
const
	scInc = 1;
	scNoInc = 2;
	scAdd = 3;
	scMove = 4;
	scLoop = 5;
	scNop = 6;
	scStop = 7;
	scComp = 8;

{ TIB instruction }
type
	SCSIInstrPtr = ^SCSIInstr;
	SCSIInstr = record
		scOpcode: UInt16;
		scParam1: SIGNEDLONG;
		scParam2: SIGNEDLONG;
	end;
{
 *  SCSIReset()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 }


{
 *  SCSIGet()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 }


{
 *  SCSISelect()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 }


{
 *  SCSICmd()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 }


{
 *  SCSIRead()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 }


{
 *  SCSIRBlind()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 }


{
 *  SCSIWrite()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 }


{
 *  SCSIWBlind()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 }


{
 *  SCSIComplete()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 }


{
 *  SCSIStat()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 }


{
 *  SCSISelAtn()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 }


{
 *  SCSIMsgIn()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 }


{
 *  SCSIMsgOut()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.1 and later
 }


const
	scsiVERSION = 43;


{
 * SCSI Completion routine callback for SCSIAction.
 }
type
	SCSICallbackProcPtr = procedure( scsiPB: UnivPtr );
	SCSICallbackUPP = SCSICallbackProcPtr;
{
 *  NewSCSICallbackUPP()
 *  
 *  Availability:
 *    Mac OS X:         in version 10.0 and later in CoreServices.framework
 *    CarbonLib:        in CarbonLib 1.3 and later
 *    Non-Carbon CFM:   available as macro/inline
 }
function NewSCSICallbackUPP( userRoutine: SCSICallbackProcPtr ): SCSICallbackUPP; external name '_NewSCSICallbackUPP';
(* AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_2 *)

{
 *  DisposeSCSICallbackUPP()
 *  
 *  Availability:
 *    Mac OS X:         in version 10.0 and later in CoreServices.framework
 *    CarbonLib:        in CarbonLib 1.3 and later
 *    Non-Carbon CFM:   available as macro/inline
 }
procedure DisposeSCSICallbackUPP( userUPP: SCSICallbackUPP ); external name '_DisposeSCSICallbackUPP';
(* AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_2 *)

{
 *  InvokeSCSICallbackUPP()
 *  
 *  Availability:
 *    Mac OS X:         in version 10.0 and later in CoreServices.framework
 *    CarbonLib:        in CarbonLib 1.3 and later
 *    Non-Carbon CFM:   available as macro/inline
 }
procedure InvokeSCSICallbackUPP( scsiPB: UnivPtr; userUPP: SCSICallbackUPP ); external name '_InvokeSCSICallbackUPP';
(* AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_2 *)

{ 
   SCSI Manager 4.3 function codes 
 }
const
	SCSINop = $00; { Execute nothing                          }
	SCSIExecIO = $01; { Execute the specified IO                  }
	SCSIBusInquiry = $03; { Get parameters for entire path of HBAs           }
	SCSIReleaseQ = $04; { Release the frozen SIM queue for particular LUN      }
	SCSIAbortCommand = $10; { Abort the selected Control Block             }
	SCSIResetBus = $11; { Reset the SCSI bus                         }
	SCSIResetDevice = $12; { Reset the SCSI device                      }
	SCSITerminateIO = $13;  { Terminate any pending IO                    }

const
	vendorUnique = $C0;  { 0xC0 thru 0xFF }


{ Allocation length defines for some of the fields }
const
	handshakeDataLength = 8;    { Handshake data length }
	maxCDBLength = 16;   { Space for the CDB bytes/pointer }
	vendorIDLength = 16;    { ASCII string len for Vendor ID  }

{ Define DeviceIdent structure }
type
	DeviceIdentPtr = ^DeviceIdent;
	DeviceIdent = record
		diReserved: UInt8;             { reserved           }
		bus: UInt8;                    { SCSI - Bus Number   }
		targetID: UInt8;               { SCSI - Target SCSI ID  }
		LUN: UInt8;                    { SCSI - LUN            }
	end;
{ Constants for the diReserved field of DeviceIdent }
{ used to distinguish whether the DeviceIdent holds }
{ information about a SCSI device (kBusTypeSCSI)    }
{ or an ATA device (kBusTypeATA).  The other        }
{ constants are pretty much deprecated.  Let me     }
{ know if you see any.                              }
const
	kBusTypeSCSI = 0;
	kBusTypeATA = 1;
	kBusTypePCMCIA = 2;
	kBusTypeMediaBay = 3;

{ If diReserved indicates that a DeviceIdent is     }
{ really for ATA, you can cast it to DeviceIdentATA }
{ to get at the important fields.                   }
type
	DeviceIdentATAPtr = ^DeviceIdentATA;
	DeviceIdentATA = record
		diReserved: UInt8;
		busNum: UInt8;
		devNum: UInt8;
		diReserved2: UInt8;
	end;


{ Command Descriptor Block structure }
type
	CDBPtr = ^CDB;
	CDB = record
		case SInt16 of
		0: (
			cdbPtr: BytePtr;                 { pointer to the CDB, or }
			);
		1: (
			cdbBytes: packed array [0..15] of UInt8;           { the actual CDB to send }
			);
	end;

	{ Scatter/gather list element (Deprecated for MacOS8) }

type
	SGRecordPtr = ^SGRecord;
	SGRecord = record
		SGAddr: Ptr;
		SGCount: UInt32;
	end;

	SCSIHdrPtr = ^SCSIHdr;
	SCSIHdr = record
		qLink: SCSIHdrPtr;								{  (internal use, must be nil on entry)    }
		scsiReserved1: SInt16;          { ->     reserved for input          }
		scsiPBLength: UInt16;           { -> Length of the entire PB        }
		scsiFunctionCode: UInt8;       { -> function selector           }
		scsiReserved2: UInt8;          { <-     reserved for output          }
		scsiResult: {volatile} OSErr;             { <- Returned result               }
		scsiDevice: DeviceIdent;             { -> Device Identifier (bus+target+lun)}
		scsiCompletion: SCSICallbackUPP;         { -> Callback on completion function     }
		scsiFlags: UInt32;              { -> assorted flags            }
		scsiDriverStorage: BytePtr;      { <> Ptr for driver private use   }
		scsiXPTprivate: Ptr;         { private field for use in XPT      }
		scsiReserved3: SIGNEDLONG;          { reserved                    }
	end;
type
	SCSI_PBPtr = ^SCSI_PB;
	SCSI_PB = record
		qLink: SCSIHdrPtr;                  { (internal use, must be nil on entry)   }
		scsiReserved1: SInt16;          { ->     reserved for input          }
		scsiPBLength: UInt16;           { -> Length of the entire PB        }
		scsiFunctionCode: UInt8;       { -> function selector           }
		scsiReserved2: UInt8;          { <-     reserved for output          }
		scsiResult: {volatile} OSErr;             { <- Returned result               }
		scsiDevice: DeviceIdent;             { -> Device Identifier (bus+target+lun)}
		scsiCompletion: SCSICallbackUPP;         { -> Callback on completion function     }
		scsiFlags: UInt32;              { -> assorted flags            }
		scsiDriverStorage: BytePtr;      { <> Ptr for driver private use   }
		scsiXPTprivate: Ptr;         { private field for use in XPT      }
		scsiReserved3: SIGNEDLONG;          { reserved                    }
	end;
type
	SCSI_IOPtr = ^SCSI_IO;
	SCSI_IO = record
		qLink: SCSIHdrPtr;                  { (internal use, must be nil on entry)   }
		scsiReserved1: SInt16;          { ->     reserved for input          }
		scsiPBLength: UInt16;           { -> Length of the entire PB        }
		scsiFunctionCode: UInt8;       { -> function selector           }
		scsiReserved2: UInt8;          { <-     reserved for output          }
		scsiResult: {volatile} OSErr;             { <- Returned result               }
		scsiDevice: DeviceIdent;             { -> Device Identifier (bus+target+lun)}
		scsiCompletion: SCSICallbackUPP;         { -> Callback on completion function     }
		scsiFlags: UInt32;              { -> assorted flags            }
		scsiDriverStorage: BytePtr;      { <> Ptr for driver private use   }
		scsiXPTprivate: Ptr;         { private field for use in XPT      }
		scsiReserved3: SIGNEDLONG;          { reserved                    }

		scsiResultFlags: UInt16;        { <- Flags which modify the scsiResult field     }
		scsiReserved3pt5: UInt16;       { -> Reserved                           }
		scsiDataPtr: BytePtr;            { -> Pointer to the data buffer or the S/G list      }
		scsiDataLength: UInt32;         { -> Data transfer length                   }
		scsiSensePtr: BytePtr;           { -> Ptr to autosense data buffer            }
		scsiSenseLength: UInt8;        { -> size of the autosense buffer              }
		scsiCDBLength: UInt8;          { -> Number of bytes for the CDB               }
		scsiSGListCount: UInt16;        { -> num of scatter gather list entries           }
		scsiReserved4: UInt32;          { <-     reserved for output                   }
		scsiSCSIstatus: UInt8;         { <- Returned scsi device status               }
		scsiSenseResidual: SInt8;      { <- Autosense residual length             }
		scsiReserved5: UInt16;          { <-     reserved for output                 }
		scsiDataResidual: SIGNEDLONG;       { <- Returned Transfer residual length          }
		scsiCDB: CDB;                { -> Actual CDB or pointer to CDB            }
		scsiTimeout: SIGNEDLONG;            { -> Timeout value (Time Mgr format) (CAM timeout) }
		scsiReserved5pt5: BytePtr;       { -> Reserved                           }
		scsiReserved5pt6: UInt16;       { -> Reserved                           }
		scsiIOFlags: UInt16;            { -> additional I/O flags                      }
		scsiTagAction: UInt8;          { -> What to do for tag queuing                }
		scsiReserved6: UInt8;          { ->     reserved for input                   }
		scsiReserved7: UInt16;          { ->     reserved for input                   }
		scsiSelectTimeout: UInt16;      { -> Select timeout value                 }
		scsiDataType: UInt8;           { -> Data description type (i.e. buffer, TIB, S/G)   }
		scsiTransferType: UInt8;       { -> Transfer type (i.e. Blind vs Polled)       }
		scsiReserved8: UInt32;          { ->     reserved for input                  }
		scsiReserved9: UInt32;          { ->     reserved for input                  }
		scsiHandshake: array [0..7] of UInt16;       { -> handshaking points (null term'd)    }
		scsiReserved10: UInt32;         { ->     reserved for input                  }
		scsiReserved11: UInt32;         { ->   reserved for input                   }
		scsiCommandLink: SCSI_IOPtr;								{ -> Ptr to the next PB in linked cmd chain      }
		scsiSIMpublics: packed array [0..7] of UInt8;      { ->     reserved for input to 3rd-party SIMs     }
		scsiAppleReserved6: packed array [0..7] of UInt8;  { -> reserved for input                     }

                                              { XPT layer privates (for old-API emulation) }

		scsiCurrentPhase: UInt16;       { <- phase upon completing old call            }
		scsiSelector: SInt16;           { -> selector specified in old calls            }
		scsiOldCallResult: OSErr;      { <- result of old call                     }
		scsiSCSImessage: UInt8;        { <- Returned scsi device message (for SCSIComplete)}
		XPTprivateFlags: UInt8;        { <> various flags                       }
		XPTextras: packed array [0..11] of UInt8;          {                              }
	end;

	SCSIExecIOPB						= SCSI_IO;
	SCSIExecIOPBPtr 					= ^SCSIExecIOPB;
	{	 Bus inquiry PB 	}
	SCSIBusInquiryPBPtr = ^SCSIBusInquiryPB;
	SCSIBusInquiryPB = record
		qLink: SCSIHdrPtr;                  { (internal use, must be nil on entry)   }
		scsiReserved1: SInt16;          { ->     reserved for input          }
		scsiPBLength: UInt16;           { -> Length of the entire PB        }
		scsiFunctionCode: UInt8;       { -> function selector           }
		scsiReserved2: UInt8;          { <-     reserved for output          }
		scsiResult: {volatile} OSErr;             { <- Returned result               }
		scsiDevice: DeviceIdent;             { -> Device Identifier (bus+target+lun)}
		scsiCompletion: SCSICallbackUPP;         { -> Callback on completion function     }
		scsiFlags: UInt32;              { -> assorted flags            }
		scsiDriverStorage: BytePtr;      { <> Ptr for driver private use   }
		scsiXPTprivate: Ptr;         { private field for use in XPT      }
		scsiReserved3: SIGNEDLONG;          { reserved                    }

		scsiEngineCount: UInt16;        { <- Number of engines on HBA                }
		scsiMaxTransferType: UInt16;    { <- Number of transfer types for this HBA      }

		scsiDataTypes: UInt32;          { <- which data types are supported by this SIM  }

		scsiIOpbSize: UInt16;           { <- Size of SCSI_IO PB for this SIM/HBA          }
		scsiMaxIOpbSize: UInt16;        { <- Size of max SCSI_IO PB for all SIM/HBAs        }

		scsiFeatureFlags: UInt32;       { <- Supported features flags field           }

		scsiVersionNumber: UInt8;      { <- Version number for the SIM/HBA           }
		scsiHBAInquiry: UInt8;         { <- Mimic of INQ byte 7 for the HBA           }
		scsiTargetModeFlags: UInt8;    { <- Flags for target mode support           }
		scsiScanFlags: UInt8;          { <- Scan related feature flags            }

		scsiSIMPrivatesPtr: UInt32;     { <- Ptr to SIM private data area              }
		scsiSIMPrivatesSize: UInt32;    { <- Size of SIM private data area           }
		scsiAsyncFlags: UInt32;         { <- Event cap. for Async Callback           }

		scsiHiBusID: UInt8;            { <- Highest path ID in the subsystem         }
		scsiInitiatorID: UInt8;        { <- ID of the HBA on the SCSI bus           }
		scsiBIReserved0: UInt16;        {                                  }

		scsiBIReserved1: UInt32;        { <-                                }
		scsiFlagsSupported: UInt32;     { <- which scsiFlags are supported           }

		scsiIOFlagsSupported: UInt16;   { <- which scsiIOFlags are supported           }
		scsiWeirdStuff: UInt16;         { <-                               }
		scsiMaxTarget: UInt16;          { <- maximum Target number supported           }
		scsiMaxLUN: UInt16;             { <- maximum Logical Unit number supported    }

		scsiSIMVendor: packed array [0..15] of char;			{ <- Vendor ID of SIM (or XPT if bus<FF)        }
		scsiHBAVendor: packed array [0..15] of char;			{ <- Vendor ID of the HBA                }
		scsiControllerFamily:	packed array [0..15] of char;			{ <- Family of SCSI Controller           }
		scsiControllerType: packed array [0..15] of char;			{ <- Specific Model of SCSI Controller used  }

		scsiXPTversion: packed array [0..3] of char;			{ <- version number of XPT              }
		scsiSIMversion: packed array [0..3] of char;			{ <- version number of SIM              }
		scsiHBAversion: packed array [0..3] of char;			{ <- version number of HBA              }

		scsiHBAslotType: UInt8;        { <- type of "slot" that this HBA is in       }
		scsiHBAslotNumber: UInt8;      { <- slot number of this HBA                  }
		scsiSIMsRsrcID: UInt16;         { <- resource ID of this SIM                  }

		scsiBIReserved3: UInt16;        { <-                               }
		scsiAdditionalLength: UInt16;   { <- additional BusInquiry PB len              }
	end;
{ Abort SIM Request PB }
type
	SCSIAbortCommandPBPtr = ^SCSIAbortCommandPB;
	SCSIAbortCommandPB = record
		qLink: SCSIHdrPtr;                  { (internal use, must be nil on entry)   }
		scsiReserved1: SInt16;          { ->     reserved for input          }
		scsiPBLength: UInt16;           { -> Length of the entire PB        }
		scsiFunctionCode: UInt8;       { -> function selector           }
		scsiReserved2: UInt8;          { <-     reserved for output          }
		scsiResult: {volatile} OSErr;             { <- Returned result               }
		scsiDevice: DeviceIdent;             { -> Device Identifier (bus+target+lun)}
		scsiCompletion: SCSICallbackUPP;         { -> Callback on completion function     }
		scsiFlags: UInt32;              { -> assorted flags            }
		scsiDriverStorage: BytePtr;      { <> Ptr for driver private use   }
		scsiXPTprivate: Ptr;         { private field for use in XPT      }
		scsiReserved3: SIGNEDLONG;          { reserved                    }
		scsiIOptr: SCSI_IOPtr;              { Pointer to the PB to abort        }
	end;
{ Terminate I/O Process Request PB }
type
	SCSITerminateIOPBPtr = ^SCSITerminateIOPB;
	SCSITerminateIOPB = record
		qLink: SCSIHdrPtr;                  { (internal use, must be nil on entry)   }
		scsiReserved1: SInt16;          { ->     reserved for input          }
		scsiPBLength: UInt16;           { -> Length of the entire PB        }
		scsiFunctionCode: UInt8;       { -> function selector           }
		scsiReserved2: UInt8;          { <-     reserved for output          }
		scsiResult: {volatile} OSErr;             { <- Returned result               }
		scsiDevice: DeviceIdent;             { -> Device Identifier (bus+target+lun)}
		scsiCompletion: SCSICallbackUPP;         { -> Callback on completion function     }
		scsiFlags: UInt32;              { -> assorted flags            }
		scsiDriverStorage: BytePtr;      { <> Ptr for driver private use   }
		scsiXPTprivate: Ptr;         { private field for use in XPT      }
		scsiReserved3: SIGNEDLONG;          { reserved                    }
		scsiIOptr: SCSI_IOPtr;              { Pointer to the PB to terminate        }
	end;
{ Reset SCSI Bus PB }
type
	SCSIResetBusPBPtr = ^SCSIResetBusPB;
	SCSIResetBusPB = record
		qLink: SCSIHdrPtr;                  { (internal use, must be nil on entry)   }
		scsiReserved1: SInt16;          { ->     reserved for input          }
		scsiPBLength: UInt16;           { -> Length of the entire PB        }
		scsiFunctionCode: UInt8;       { -> function selector           }
		scsiReserved2: UInt8;          { <-     reserved for output          }
		scsiResult: {volatile} OSErr;             { <- Returned result               }
		scsiDevice: DeviceIdent;             { -> Device Identifier (bus+target+lun)}
		scsiCompletion: SCSICallbackUPP;         { -> Callback on completion function     }
		scsiFlags: UInt32;              { -> assorted flags            }
		scsiDriverStorage: BytePtr;      { <> Ptr for driver private use   }
		scsiXPTprivate: Ptr;         { private field for use in XPT      }
		scsiReserved3: SIGNEDLONG;          { reserved                    }
	end;
{ Reset SCSI Device PB }
type
	SCSIResetDevicePBPtr = ^SCSIResetDevicePB;
	SCSIResetDevicePB = record
		qLink: SCSIHdrPtr;                  { (internal use, must be nil on entry)   }
		scsiReserved1: SInt16;          { ->     reserved for input          }
		scsiPBLength: UInt16;           { -> Length of the entire PB        }
		scsiFunctionCode: UInt8;       { -> function selector           }
		scsiReserved2: UInt8;          { <-     reserved for output          }
		scsiResult: {volatile} OSErr;             { <- Returned result               }
		scsiDevice: DeviceIdent;             { -> Device Identifier (bus+target+lun)}
		scsiCompletion: SCSICallbackUPP;         { -> Callback on completion function     }
		scsiFlags: UInt32;              { -> assorted flags            }
		scsiDriverStorage: BytePtr;      { <> Ptr for driver private use   }
		scsiXPTprivate: Ptr;         { private field for use in XPT      }
		scsiReserved3: SIGNEDLONG;          { reserved                    }
	end;
{ Release SIM Queue PB }
type
	SCSIReleaseQPBPtr = ^SCSIReleaseQPB;
	SCSIReleaseQPB = record
		qLink: SCSIHdrPtr;                  { (internal use, must be nil on entry)   }
		scsiReserved1: SInt16;          { ->     reserved for input          }
		scsiPBLength: UInt16;           { -> Length of the entire PB        }
		scsiFunctionCode: UInt8;       { -> function selector           }
		scsiReserved2: UInt8;          { <-     reserved for output          }
		scsiResult: {volatile} OSErr;             { <- Returned result               }
		scsiDevice: DeviceIdent;             { -> Device Identifier (bus+target+lun)}
		scsiCompletion: SCSICallbackUPP;         { -> Callback on completion function     }
		scsiFlags: UInt32;              { -> assorted flags            }
		scsiDriverStorage: BytePtr;      { <> Ptr for driver private use   }
		scsiXPTprivate: Ptr;         { private field for use in XPT      }
		scsiReserved3: SIGNEDLONG;          { reserved                    }
	end;
{ SCSI Get Virtual ID Info PB }
type
	SCSIGetVirtualIDInfoPBPtr = ^SCSIGetVirtualIDInfoPB;
	SCSIGetVirtualIDInfoPB = record
		qLink: SCSIHdrPtr;                  { (internal use, must be nil on entry)   }
		scsiReserved1: SInt16;          { ->     reserved for input          }
		scsiPBLength: UInt16;           { -> Length of the entire PB        }
		scsiFunctionCode: UInt8;       { -> function selector           }
		scsiReserved2: UInt8;          { <-     reserved for output          }
		scsiResult: {volatile} OSErr;             { <- Returned result               }
		scsiDevice: DeviceIdent;             { -> Device Identifier (bus+target+lun)}
		scsiCompletion: SCSICallbackUPP;         { -> Callback on completion function     }
		scsiFlags: UInt32;              { -> assorted flags            }
		scsiDriverStorage: Ptr;      { <> Ptr for driver private use   }
		scsiXPTprivate: Ptr;         { private field for use in XPT      }
		scsiReserved3: SIGNEDLONG;          { reserved                    }
		scsiOldCallID: UInt16;          { -> SCSI ID of device in question   }
		scsiExists: Boolean;             { <- true if device exists        }
		filler: SInt8;
	end;
{ Create/Lookup/Remove RefNum for Device PB }
type
	SCSIDriverPBPtr = ^SCSIDriverPB;
	SCSIDriverPB = record
		qLink: SCSIHdrPtr;                  { (internal use, must be nil on entry)   }
		scsiReserved1: SInt16;          { ->     reserved for input          }
		scsiPBLength: UInt16;           { -> Length of the entire PB        }
		scsiFunctionCode: UInt8;       { -> function selector           }
		scsiReserved2: UInt8;          { <-     reserved for output          }
		scsiResult: {volatile} OSErr;             { <- Returned result               }
		scsiDevice: DeviceIdent;             { -> Device Identifier (bus+target+lun)}
		scsiCompletion: SCSICallbackUPP;         { -> Callback on completion function     }
		scsiFlags: UInt32;              { -> assorted flags            }
		scsiDriverStorage: Ptr;      { <> Ptr for driver private use   }
		scsiXPTprivate: Ptr;         { private field for use in XPT      }
		scsiReserved3: SIGNEDLONG;          { reserved                    }
		scsiDriver: SInt16;             { -> DriverRefNum, For SetDriver, <- For GetNextDriver }
		scsiDriverFlags: UInt16;        { <> Details of driver/device       }
		scsiNextDevice: DeviceIdent;         { <- DeviceIdent of the NEXT Item in the list  }
	end;
{ Load Driver PB }
type
	SCSILoadDriverPBPtr = ^SCSILoadDriverPB;
	SCSILoadDriverPB = record
		qLink: SCSIHdrPtr;                  { (internal use, must be nil on entry)   }
		scsiReserved1: SInt16;          { ->     reserved for input          }
		scsiPBLength: UInt16;           { -> Length of the entire PB        }
		scsiFunctionCode: UInt8;       { -> function selector           }
		scsiReserved2: UInt8;          { <-     reserved for output          }
		scsiResult: {volatile} OSErr;             { <- Returned result               }
		scsiDevice: DeviceIdent;             { -> Device Identifier (bus+target+lun)}
		scsiCompletion: SCSICallbackUPP;         { -> Callback on completion function     }
		scsiFlags: UInt32;              { -> assorted flags            }
		scsiDriverStorage: Ptr;      { <> Ptr for driver private use   }
		scsiXPTprivate: Ptr;         { private field for use in XPT      }
		scsiReserved3: SIGNEDLONG;          { reserved                    }
		scsiLoadedRefNum: SInt16;       { <- SIM returns refnum of driver      }
		scsiDiskLoadFailed: Boolean;     { -> if true, indicates call after failure to load }
		filler: SInt8;
	end;

{ Defines for the scsiTransferType field }
const
	scsiTransferBlind = 0;
	scsiTransferPolled = 1;

const
	scsiErrorBase = -7936;

const
	scsiRequestInProgress = 1;    { 1   = PB request is in progress          }
                                        { Execution failed  00-2F }
	scsiRequestAborted = scsiErrorBase + 2; { -7934 = PB request aborted by the host        }
	scsiUnableToAbort = scsiErrorBase + 3; { -7933 = Unable to Abort PB request          }
	scsiNonZeroStatus = scsiErrorBase + 4; { -7932 = PB request completed with an err   }
	scsiUnused05 = scsiErrorBase + 5; { -7931 =                        }
	scsiUnused06 = scsiErrorBase + 6; { -7930 =                        }
	scsiUnused07 = scsiErrorBase + 7; { -7929 =                        }
	scsiUnused08 = scsiErrorBase + 8; { -7928 =                        }
	scsiUnableToTerminate = scsiErrorBase + 9; { -7927 = Unable to Terminate I/O PB req        }
	scsiSelectTimeout = scsiErrorBase + 10; { -7926 = Target selection timeout        }
	scsiCommandTimeout = scsiErrorBase + 11; { -7925 = Command timeout              }
	scsiIdentifyMessageRejected = scsiErrorBase + 12; { -7924 =                        }
	scsiMessageRejectReceived = scsiErrorBase + 13; { -7923 = Message reject received           }
	scsiSCSIBusReset = scsiErrorBase + 14; { -7922 = SCSI bus reset sent/received    }
	scsiParityError = scsiErrorBase + 15; { -7921 = Uncorrectable parity error occured     }
	scsiAutosenseFailed = scsiErrorBase + 16; { -7920 = Autosense: Request sense cmd fail  }
	scsiUnused11 = scsiErrorBase + 17; { -7919 =                        }
	scsiDataRunError = scsiErrorBase + 18; { -7918 = Data overrun/underrun error     }
	scsiUnexpectedBusFree = scsiErrorBase + 19; { -7917 = Unexpected BUS free              }
	scsiSequenceFailed = scsiErrorBase + 20; { -7916 = Target bus phase sequence failure  }
	scsiWrongDirection = scsiErrorBase + 21; { -7915 = Data phase was in wrong direction  }
	scsiUnused16 = scsiErrorBase + 22; { -7914 =                        }
	scsiBDRsent = scsiErrorBase + 23; { -7913 = A SCSI BDR msg was sent to target  }
	scsiTerminated = scsiErrorBase + 24; { -7912 = PB request terminated by the host  }
	scsiNoNexus = scsiErrorBase + 25; { -7911 = Nexus is not established        }
	scsiCDBReceived = scsiErrorBase + 26; { -7910 = The SCSI CDB has been received        }
                                        { Couldn't begin execution  30-3F }
	scsiTooManyBuses = scsiErrorBase + 48; { -7888 = Register failed because we're full }
	scsiBusy = scsiErrorBase + 49; { -7887 = SCSI subsystem is busy           }
	scsiProvideFail = scsiErrorBase + 50; { -7886 = Unable to provide requ. capability }
	scsiDeviceNotThere = scsiErrorBase + 51; { -7885 = SCSI device not installed/there    }
	scsiNoHBA = scsiErrorBase + 52; { -7884 = No HBA detected Error           }
	scsiDeviceConflict = scsiErrorBase + 53; { -7883 = sorry, max 1 refNum per DeviceIdent    }
	scsiNoSuchXref = scsiErrorBase + 54; { -7882 = no such RefNum xref              }
	scsiQLinkInvalid = scsiErrorBase + 55; { -7881 = pre-linked PBs not supported      }
                                        {   (The QLink field was nonzero)          }
                                        { Parameter errors  40-7F }
	scsiPBLengthError = scsiErrorBase + 64; { -7872 = (scsiPBLength is insuf'ct/invalid  }
	scsiFunctionNotAvailable = scsiErrorBase + 65; { -7871 = The requ. func is not available    }
	scsiRequestInvalid = scsiErrorBase + 66; { -7870 = PB request is invalid           }
	scsiBusInvalid = scsiErrorBase + 67; { -7869 = Bus ID supplied is invalid        }
	scsiTIDInvalid = scsiErrorBase + 68; { -7868 = Target ID supplied is invalid      }
	scsiLUNInvalid = scsiErrorBase + 69; { -7867 = LUN supplied is invalid         }
	scsiIDInvalid = scsiErrorBase + 70; { -7866 = The initiator ID is invalid     }
	scsiDataTypeInvalid = scsiErrorBase + 71; { -7865 = scsiDataType requested not supported }
	scsiTransferTypeInvalid = scsiErrorBase + 72; { -7864 = scsiTransferType field is too high     }
	scsiCDBLengthInvalid = scsiErrorBase + 73; { -7863 = scsiCDBLength field is too big        }

{ New errors for SCSI Family         }
const
	scsiUnused74 = scsiErrorBase + 74; { -7862 =                          }
	scsiUnused75 = scsiErrorBase + 75; { -7861 =                          }
	scsiBadDataLength = scsiErrorBase + 76; { -7860 = a zero data length in PB        }
	scsiPartialPrepared = scsiErrorBase + 77; { -7859 = could not do full prepare mem for I/O}
	scsiInvalidMsgType = scsiErrorBase + 78; { -7858 = Invalid message type (internal)       }
	scsiUnused79 = scsiErrorBase + 79; { -7857 =                              }
	scsiBadConnID = scsiErrorBase + 80; { -7856 = Bad Connection ID                }
	scsiUnused81 = scsiErrorBase + 81; { -7855 =                          }
	scsiIOInProgress = scsiErrorBase + 82; { -7854 = Can't close conn, IO in prog      }
	scsiTargetReserved = scsiErrorBase + 83; { -7853 = Target already reserved          }
	scsiUnused84 = scsiErrorBase + 84; { -7852 =                          }
	scsiUnused85 = scsiErrorBase + 85; { -7851 =                          }
	scsiBadConnType = scsiErrorBase + 86; { -7850 = Bad connection type              }
	scsiCannotLoadPlugin = scsiErrorBase + 87; { -7849 = No matching service category      }

{ +++ }
{
 * scsiFamilyInternalError and scsiPluginInternalError are intended to handle consistency check failures.
 * For example, if the family stores a record on a lookaside queue, but does not find that record
 * it can use this error to report this failure. SCSI Manager 4.3 uses dsIOCoreErr in a few places,
 * but this is probably not the best error. In general, internal errors should be reported as bugs.
 *
 * The following range of errors is provided for third-party (non-Apple) SCSI SIM and device driver vendors.
 * In general, they would be used for error conditions that are not covered by the standardized errors.
 * They should not normally be conveyed to normal applications, but might be used for communication between
 * a plug-in and a vendor-provided device driver (for example, to manage RAID hot-swapping).
 *
 * Note: I don't know how many SCSI errors are reserved in the error code architecture. Don't assume that
 * we'll actually get sixteen, but we should reserve at least one.
 }
const
	scsiFamilyInternalError = scsiErrorBase + 87; { -7849 = Internal consistency check failed  }
	scsiPluginInternalError = scsiErrorBase + 88; { -7848 = Internal consistency check failed  }
	scsiVendorSpecificErrorBase = scsiErrorBase + 128; { ??    = Start of third-party error range     }
	scsiVendorSpecificErrorCount = 16;    { Number of third-party errors             }

{ --- }
const
	scsiExecutionErrors = scsiErrorBase;
	scsiNotExecutedErrors = scsiTooManyBuses;
	scsiParameterErrors = scsiPBLengthError;

{ Defines for the scsiResultFlags field }
const
	scsiSIMQFrozen = $0001; { The SIM queue is frozen w/this err        }
	scsiAutosenseValid = $0002; { Autosense data valid for target         }
	scsiBusNotFree = $0004; { At time of callback, SCSI bus is not free  }

{ Defines for the bit numbers of the scsiFlags field in the PB header for the SCSIExecIO function }
const
	kbSCSIDisableAutosense = 29;   { Disable auto sense feature               }
	kbSCSIFlagReservedA = 28;   {                             }
	kbSCSIFlagReserved0 = 27;   {                             }
	kbSCSICDBLinked = 26;   { The PB contains a linked CDB             }
	kbSCSIQEnable = 25;   { Target queue actions are enabled          }
	kbSCSICDBIsPointer = 24;   { The CDB field contains a pointer          }
	kbSCSIFlagReserved1 = 23;   {                               }
	kbSCSIInitiateSyncData = 22;   { Attempt Sync data xfer and SDTR          }
	kbSCSIDisableSyncData = 21;   { Disable sync, go to async            }
	kbSCSISIMQHead = 20;   { Place PB at the head of SIM Q          }
	kbSCSISIMQFreeze = 19;   { Return the SIM Q to frozen state          }
	kbSCSISIMQNoFreeze = 18;   { Disallow SIM Q freezing                 }
	kbSCSIDoDisconnect = 17;   { Definitely do disconnect               }
	kbSCSIDontDisconnect = 16;   { Definitely don't disconnect              }
	kbSCSIDataReadyForDMA = 15;   { Data buffer(s) are ready for DMA          }
	kbSCSIFlagReserved3 = 14;   {                               }
	kbSCSIDataPhysical = 13;   { SG/Buffer data ptrs are physical          }
	kbSCSISensePhysical = 12;   { Autosense buffer ptr is physical          }
	kbSCSIFlagReserved5 = 11;   {                               }
	kbSCSIFlagReserved6 = 10;   {                               }
	kbSCSIFlagReserved7 = 9;    {                               }
	kbSCSIFlagReserved8 = 8;    {                               }
	kbSCSIDataBufferValid = 7;    { Data buffer valid                 }
	kbSCSIStatusBufferValid = 6;    { Status buffer valid                 }
	kbSCSIMessageBufferValid = 5;    { Message buffer valid                }
	kbSCSIFlagReserved9 = 4;     {                             }

{ Defines for the bit masks of the scsiFlags field }
const
	scsiDirectionMask = $C0000000; { Data direction mask                 }
	scsiDirectionNone = $C0000000; { Data direction (11: no data)          }
	scsiDirectionReserved = $00000000; { Data direction (00: reserved)       }
	scsiDirectionOut = $80000000; { Data direction (10: DATA OUT)       }
	scsiDirectionIn = $40000000; { Data direction (01: DATA IN)          }
	scsiDisableAutosense = $20000000; { Disable auto sense feature          }
	scsiFlagReservedA = $10000000; {                           }
	scsiFlagReserved0 = $08000000; {                           }
	scsiCDBLinked = $04000000; { The PB contains a linked CDB          }
	scsiQEnable = $02000000; { Target queue actions are enabled      }
	scsiCDBIsPointer = $01000000; { The CDB field contains a pointer      }
	scsiFlagReserved1 = $00800000; {                           }
	scsiInitiateSyncData = $00400000; { Attempt Sync data xfer and SDTR         }
	scsiDisableSyncData = $00200000; { Disable sync, go to async          }
	scsiSIMQHead = $00100000; { Place PB at the head of SIM Q       }
	scsiSIMQFreeze = $00080000; { Return the SIM Q to frozen state      }
	scsiSIMQNoFreeze = $00040000; { Disallow SIM Q freezing              }
	scsiDoDisconnect = $00020000; { Definitely do disconnect             }
	scsiDontDisconnect = $00010000; { Definitely don't disconnect          }
	scsiDataReadyForDMA = $00008000; { Data buffer(s) are ready for DMA      }
	scsiFlagReserved3 = $00004000; {  }
	scsiDataPhysical = $00002000; { SG/Buffer data ptrs are physical      }
	scsiSensePhysical = $00001000; { Autosense buffer ptr is physical      }
	scsiFlagReserved5 = $00000800; {                         }
	scsiFlagReserved6 = $00000400; {                           }
	scsiFlagReserved7 = $00000200; {                           }
	scsiFlagReserved8 = $00000100; {                           }

{ bit masks for the scsiIOFlags field in SCSIExecIOPB }
const
	scsiNoParityCheck = $0002; { disable parity checking                 }
	scsiDisableSelectWAtn = $0004; { disable select w/Atn                    }
	scsiSavePtrOnDisconnect = $0008; { do SaveDataPointer upon Disconnect msg          }
	scsiNoBucketIn = $0010; { donÕt bit bucket in during this I/O           }
	scsiNoBucketOut = $0020; { donÕt bit bucket out during this I/O        }
	scsiDisableWide = $0040; { disable wide transfer negotiation           }
	scsiInitiateWide = $0080; { initiate wide transfer negotiation           }
	scsiRenegotiateSense = $0100; { renegotiate sync/wide before issuing autosense     }
	scsiDisableDiscipline = $0200; { disable parameter checking on SCSIExecIO calls }
	scsiIOFlagReserved0080 = $0080; {                                }
	scsiIOFlagReserved8000 = $8000; {                                  }

{ Defines for the Bus Inquiry PB fields. }
{ scsiHBAInquiry field bits }
const
	scsiBusMDP = $80; { Supports Modify Data Pointer message               }
	scsiBusWide32 = $40; { Supports 32 bit wide SCSI                    }
	scsiBusWide16 = $20; { Supports 16 bit wide SCSI                    }
	scsiBusSDTR = $10; { Supports Sync Data Transfer Req message              }
	scsiBusLinkedCDB = $08; { Supports linked CDBs                         }
	scsiBusTagQ = $02; { Supports tag queue message                    }
	scsiBusSoftReset = $01;  { Supports soft reset                           }

{ Defines for the scsiDataType field }
const
	scsiDataBuffer = 0;    { single contiguous buffer supplied            }
	scsiDataTIB = 1;    { TIB supplied (ptr in scsiDataPtr)           }
	scsiDataSG = 2;    { scatter/gather list supplied             }
	scsiDataIOTable = 3;     {#(7/11/95) Prepared by Block Storage         }

{ scsiDataTypes field bits  }
{  bits 0->15 Apple-defined, 16->30 3rd-party unique, 31 = reserved }
const
	scsiBusDataTIB = 1 shl scsiDataTIB; { TIB supplied (ptr in scsiDataPtr)   }
	scsiBusDataBuffer = 1 shl scsiDataBuffer; { single contiguous buffer supplied      }
	scsiBusDataSG = 1 shl scsiDataSG; { scatter/gather list supplied        }
	scsiBusDataIOTable = 1 shl scsiDataIOTable; { (2/6/95) Prepare Memory for IO}
	scsiBusDataReserved = $80000000; {                            }

{ scsiScanFlags field bits }
const
	scsiBusScansDevices = $80; { Bus scans for and maintains device list         }
	scsiBusScansOnInit = $40; { Bus scans performed at power-up/reboot        }
	scsiBusLoadsROMDrivers = $20;  { may load ROM drivers to support targets       }

{ scsiFeatureFlags field bits }
const
	scsiBusLVD = $00000400; { HBA is Low Voltage Differential Bus         }
	scsiBusUltra3SCSI = $00000200; { HBA supports Ultra3 SCSI               }
	scsiBusUltra2SCSI = $00000100; { HBA supports Ultra2 SCSI               }
	scsiBusInternalExternalMask = $000000C0; { bus internal/external mask           }
	scsiBusInternalExternalUnknown = $00000000; { not known whether bus is inside or outside     }
	scsiBusInternalExternal = $000000C0; { bus goes inside and outside the box       }
	scsiBusInternal = $00000080; { bus goes inside the box                }
	scsiBusExternal = $00000040; { bus goes outside the box             }
	scsiBusCacheCoherentDMA = $00000020; { DMA is cache coherent                }
	scsiBusOldCallCapable = $00000010; { SIM is old call capable                }
	scsiBusUltraSCSI = $00000008; { HBA supports Ultra SCSI                 }
	scsiBusDifferential = $00000004; { Single Ended (0) or Differential (1)    }
	scsiBusFastSCSI = $00000002; { HBA supports fast SCSI                  }
	scsiBusDMAavailable = $00000001; { DMA is available                  }

{ scsiWeirdStuff field bits }
const
	scsiOddDisconnectUnsafeRead1 = $0001; { Disconnects on odd byte boundries are unsafe with DMA and/or blind reads }
	scsiOddDisconnectUnsafeWrite1 = $0002; { Disconnects on odd byte boundries are unsafe with DMA and/or blind writes }
	scsiBusErrorsUnsafe = $0004; { Non-handshaked delays or disconnects during blind transfers may cause a crash }
	scsiRequiresHandshake = $0008; { Non-handshaked delays or disconnects during blind transfers may cause data corruption }
	scsiTargetDrivenSDTRSafe = $0010; { Targets which initiate synchronous negotiations are supported }
	scsiOddCountForPhysicalUnsafe = $0020; { If using physical addrs all counts must be even, and disconnects must be on even boundries }
	scsiAbortCmdFixed = $0040; { Set if abort command is fixed to properly make callbacks }
	scsiMeshACKTimingFixed = $0080; { Set if bug allowing Mesh to release ACK prematurely is fixed }

{ scsiHBAslotType values }
const
	scsiMotherboardBus = $00; { A built in Apple supplied bus            }
	scsiNuBus = $01; { A SIM on a NuBus card                   }
	scsiPDSBus = $03; {    "  on a PDS card                    }
	scsiPCIBus = $04; {    "  on a PCI bus card                   }
	scsiPCMCIABus = $05; {    "  on a PCMCIA card                  }
	scsiFireWireBridgeBus = $06; {    "  connected through a FireWire bridge   }
	scsiUSBBus = $07;  {    "  connected on a USB bus               }

{ Defines for the scsiDriverFlags field (in SCSIDriverPB) }
const
	scsiDeviceSensitive = $0001; { Only driver should access this device          }
	scsiDeviceNoOldCallAccess = $0002; { no old call access to this device            }

{
 * SCSI bus status. These values are returned by the SCSI target in the status phase.
 * They are not related to Macintosh status values (except that values other than
 * scsiStatusGood will result in scsiResult set to scsiNonZeroStatus).
 }
const
	scsiStatGood = $00; { Good Status}
	scsiStatCheckCondition = $02; { Check Condition}
	scsiStatConditionMet = $04; { Condition Met}
	scsiStatBusy = $08; { Busy}
	scsiStatIntermediate = $10; { Intermediate}
	scsiStatIntermedMet = $14; { Intermediate - Condition Met}
	scsiStatResvConflict = $18; { Reservation conflict}
	scsiStatTerminated = $22; { Command terminated}
	scsiStatQFull = $28;  { Queue full}

{ SCSI messages}
const
	kCmdCompleteMsg = 0;
	kExtendedMsg = 1;    { 0x01}
	kSaveDataPointerMsg = 2;    { 0x02}
	kRestorePointersMsg = 3;    { 0x03}
	kDisconnectMsg = 4;    { 0x04}
	kInitiatorDetectedErrorMsg = 5;    { 0x05}
	kAbortMsg = 6;    { 0x06}
	kMsgRejectMsg = 7;    { 0x07}
	kNoOperationMsg = 8;    { 0x08}
	kMsgParityErrorMsg = 9;    { 0x09}
	kLinkedCmdCompleteMsg = 10;   { 0x0a}
	kLinkedCmdCompleteWithFlagMsg = 11;   { 0x0b}
	kBusDeviceResetMsg = 12;   { 0x0c}
	kAbortTagMsg = 13;   { 0x0d}
	kClearQueueMsg = 14;   { 0x0e}
	kInitiateRecoveryMsg = 15;   { 0x0f}
	kReleaseRecoveryMsg = 16;   { 0x10}
	kTerminateIOProcessMsg = 17;   { 0x11}
	kSimpleQueueTag = $20; { 0x20}
	kHeadOfQueueTagMsg = $21; { 0x21}
	kOrderedQueueTagMsg = $22; { 0x22}
	kIgnoreWideResidueMsg = $23;  { 0x23}


{$ifc not TARGET_CPU_64}
{
 *  SCSIAction()   *** DEPRECATED ***
 *  
 *  Deprecated:
 *    Use the SCSITaskUserClient API instead.
 *  
 *  Discussion:
 *    This routine is deprecated. It is exported and callable, but it
 *    is no longer being maintained.
 *  
 *  Availability:
 *    Mac OS X:         in version 10.0 and later in CoreServices.framework [32-bit only] but deprecated in 10.2
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Non-Carbon CFM:   in InterfaceLib 7.5 and later
 }
function SCSIAction( var parameterBlock: SCSI_PB ): OSErr; external name '_SCSIAction';
(* AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_2 *)


{$endc} {not TARGET_CPU_64}

{
 *  SCSIRegisterBus()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.5 and later
 }


{
 *  SCSIDeregisterBus()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.5 and later
 }


{
 *  SCSIReregisterBus()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.5 and later
 }


{
 *  SCSIKillXPT()
 *  
 *  Availability:
 *    Mac OS X:         not available
 *    CarbonLib:        not available
 *    Non-Carbon CFM:   in InterfaceLib 7.5 and later
 }


{$endc} {TARGET_OS_MAC and not TARGET_CPU_64}
{$ifc not defined MACOSALLINCLUDE or not MACOSALLINCLUDE}

end.
{$endc} {not MACOSALLINCLUDE}