ATA.h

Go to the documentation of this file.

 
#ifndef __ATA__
#define __ATA__
 
#ifndef __NAMEREGISTRY__
#include <NameRegistry.h>
#endif
 
#ifndef __CODEFRAGMENTS__
#include <CodeFragments.h>
#endif
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MIXEDMODE__
#include <MixedMode.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
  enum
  {
    kATATrap =
        0xAAF1,                
    kATAPBVers1 = 0x01,        
    kATAPBVers2 = 0x02,        
    kATAPBVers3 = 0x03,        
    kATADefaultBlockSize = 512 
  };
 
  enum
  {
    kFSMTrap = 0xAC,
    mDQEChanged = 1 
  };
 
  enum
  {
    bATABadBlock = 7,                           
    bATAUncorrectable = 6,                      
    bATAMediaChanged = 5,                       
    bATAIDNotFound = 4,                         
    bATAMediaChangeReq = 3,                     
    bATACommandAborted = 2,                     
    bATATrack0NotFound = 1,                     
    bATAAddressNotFound = 0,                    
    mATABadBlock = 1 << bATABadBlock,           
    mATAUncorrectable = 1 << bATAUncorrectable, 
    mATAMediaChanged =
        1 << bATAMediaChanged,            
    mATAIDNotFound = 1 << bATAIDNotFound, 
    mATAMediaChangeReq =
        1 << bATAMediaChangeReq,                   
    mATACommandAborted = 1 << bATACommandAborted,  
    mATATrack0NotFound = 1 << bATATrack0NotFound,  
    mATAAddressNotFound = 1 << bATAAddressNotFound 
  };
 
  enum
  {
    bATAPIuseDMA = 0, 
    mATAPIuseDMA = 1 << bATAPIuseDMA
  };
 
  enum
  {
    mATAHeadNumber = 0x0F,  
    mATASectorSize = 0xA0,  
    mATADriveSelect = 0x10, 
    mATALBASelect = 0x40    
  };
 
  enum
  {
    bATABusy = 7,                               
    bATADriveReady = 6,                         
    bATAWriteFault = 5,                         
    bATASeekComplete = 4,                       
    bATADataRequest = 3,                        
    bATADataCorrected = 2,                      
    bATAIndex = 1,                              
    bATAError = 0,                              
    mATABusy = 1 << bATABusy,                   
    mATADriveReady = 1 << bATADriveReady,       
    mATAWriteFault = 1 << bATAWriteFault,       
    mATASeekComplete = 1 << bATASeekComplete,   
    mATADataRequest = 1 << bATADataRequest,     
    mATADataCorrected = 1 << bATADataCorrected, 
    mATAIndex = 1 << bATAIndex,                 
    mATAError = 1 << bATAError                  
  };
 
  enum
  {
    bATADCROne = 3,                   
    bATADCRReset = 2,                 
    bATADCRnIntEnable = 1,            
    mATADCROne = 1 << bATADCROne,     
    mATADCRReset = 1 << bATADCRReset, 
    mATADCRnIntEnable =
        1 << bATADCRnIntEnable 
  };
 
  enum
  {
    kATAcmdWORetry = 0x01,          
    kATAcmdNOP = 0x0000,            
    kATAcmdRecal = 0x0010,          
    kATAcmdRead = 0x0020,           
    kATAcmdReadLong = 0x0022,       
    kATAcmdWrite = 0x0030,          
    kATAcmdWriteLong = 0x0032,      
    kATAcmdWriteVerify = 0x003C,    
    kATAcmdReadVerify = 0x0040,     
    kATAcmdFormatTrack = 0x0050,    
    kATAcmdSeek = 0x0070,           
    kATAcmdDiagnostic = 0x0090,     
    kATAcmdInitDrive = 0x0091,      
    kATAcmdReadMultiple = 0x00C4,   
    kATAcmdWriteMultiple = 0x00C5,  
    kATAcmdSetRWMultiple = 0x00C6,  
    kATAcmdReadDMA = 0x00C8,        
    kATAcmdWriteDMA = 0x00CA,       
    kATAcmdMCAcknowledge = 0x00DB,  
    kATAcmdDoorLock = 0x00DE,       
    kATAcmdDoorUnlock = 0x00DF,     
    kATAcmdStandbyImmed = 0x00E0,   
    kATAcmdIdleImmed = 0x00E1,      
    kATAcmdStandby = 0x00E2,        
    kATAcmdIdle = 0x00E3,           
    kATAcmdReadBuffer = 0x00E4,     
    kATAcmdCheckPowerMode = 0x00E5, 
    kATAcmdSleep = 0x00E6,          
    kATAcmdWriteBuffer = 0x00E8,    
    kATAcmdWriteSame = 0x00E9,      
    kATAcmdDriveIdentify = 0x00EC,  
    kATAcmdMediaEject = 0x00ED,     
    kATAcmdSetFeatures = 0x00EF     
  };
 
  enum
  {
    kATAEnableWriteCache = 0x02, 
    kATASetTransferMode = 0x03,  
    kATASetPIOMode = 0x08,       
    kATAEnableECC = 0x88,        
    kATAEnableRetry = 0x99,      
    kATAEnableReadAhead = 0xAA   
  };
 
  enum
  {
    kATABusIDMask = 0x000000FF,
    kATADeviceIDMask = 0x0000FF00,
    kATADeviceIDClippingMask = 0x0000FFFF,
    kMinBusID = 0x00000000,
    kMaxBusID = 0x000000FE
  };
 
  enum
  {
    kATAStartIterateDeviceID = 0xFFFF,
    kATAEndIterateDeviceID = 0xFF
  };
 
  struct ataTaskFile
  {
    UInt8 ataTFFeatures;  
    UInt8 ataTFCount;     
    UInt8 ataTFSector;    
    UInt8 ataTFReserved;  
    UInt16 ataTFCylinder; 
    UInt8 ataTFSDH;       
    UInt8 ataTFCommand;   
  };
  typedef struct ataTaskFile ataTaskFile;
  enum
  {
    kATAMgrNOP = 0x00,                 
    kATAMgrExecIO = 0x01,              
    kATAMgrBusInquiry = 0x03,          
    kATAMgrQRelease = 0x04,            
    kATAMgrAbort = 0x10,               
    kATAMgrBusReset = 0x11,            
    kATAMgrRegAccess = 0x12,           
    kATAMgrDriveIdentify = 0x13,       
    kATAMgrDriverLoad = 0x82,          
    kATAMgrDriveRegister = 0x85,       
    kATAMgrFindDriverRefnum = 0x86,    
    kATAMgrRemoveDriverRefnum = 0x87,  
    kATAMgrModifyEventMask = 0x88,     
    kATAMgrDriveEject = 0x89,          
    kATAMgrGetDrvConfiguration = 0x8A, 
    kATAMgrSetDrvConfiguration = 0x8B, 
    kATAMgrGetLocationIcon = 0x8C,     
    kATAMgrManagerInquiry = 0x90,      
    kATAMgrManagerInit = 0x91,         
    kATAMgrManagerShutdown = 0x92,     
    kATAMgrAddATABus = 0x93,           
    kATAMgrRemoveATABus = 0x94,        
    kATAMgrFindSpecialDriverRefnum =
        0x98, 
    kATAMgrNextAvailable = 0x99
  };
 
  enum
  {
    kATANotifyAllDriver = 0, 
    kATADriverLoader = 1,    
    kATAROMDriver = 2        
  };
 
  enum
  {
    bATAFlagUseConfigSpeed = 15,  
    bATAFlagByteSwap = 14,        
    bATAFlagIORead = 13,          
    bATAFlagIOWrite = 12,         
    bATAFlagImmediate = 11,       
    bATAFlagQLock = 10,           
    bATAFlagReserved1 = 9,        
    bATAFlagUseScatterGather = 8, 
    bATAFlagUseDMA = 7,           
    bATAFlagProtocolATAPI = 5,    
    bATAFlagReserved2 = 4,        
    bATAFlagTFRead = 3,           
    bATAFlagLEDEnable = 0,        
    mATAFlagUseConfigSpeed = 1 << bATAFlagUseConfigSpeed,
    mATAFlagByteSwap =
        1
        << bATAFlagByteSwap,                
    mATAFlagIORead = 1 << bATAFlagIORead,   
    mATAFlagIOWrite = 1 << bATAFlagIOWrite, 
    mATAFlagImmediate =
        1 << bATAFlagImmediate, 
    mATAFlagQLock =
        1 << bATAFlagQLock, 
    mATAFlagUseScatterGather =
        1 << bATAFlagUseScatterGather, 
    mATAFlagUseDMA = 1 << bATAFlagUseDMA,
    mATAFlagProtocolATAPI =
        1 << bATAFlagProtocolATAPI,            
    mATAFlagTFRead = 1 << bATAFlagTFRead,      
    mATAFlagLEDEnable = 1 << bATAFlagLEDEnable 
  };
 
  enum
  {
    bATAFlagScatterGather1 = bATAFlagReserved1,        
    bATAFlagScatterGather0 = bATAFlagUseScatterGather, 
    bATAFlagProtocol1 = bATAFlagProtocolATAPI,         
    bATAFlagProtocol0 = bATAFlagReserved2,             
    mATAFlagScatterGather1 = 1 << bATAFlagScatterGather1,
    mATAFlagScatterGather0 = mATAFlagUseScatterGather,
    mATAFlagScatterGathers = mATAFlagScatterGather1 + mATAFlagScatterGather0,
    mATAFlagProtocol1 = mATAFlagProtocolATAPI,
    mATAFlagProtocol0 = 1 << bATAFlagProtocol0,
    mATAFlagProtocols = mATAFlagProtocol1 + mATAFlagProtocol0
  };
 
  enum
  {
    kATAFnNOP = 0x00,            
    kATAFnExecIO = 0x01,         
    kATAFnBusInquiry = 0x02,     
    kATAFnQRelease = 0x03,       
    kATAFnCmd = 0x04,            
    kATAFnAbort = 0x05,          
    kATAFnBusReset = 0x06,       
    kATAFnRegAccess = 0x07,      
    kATAFnDriveIdentify = 0x08,  
    kATAPIFnExecIO = 0x09,       
    kATAPIFnCmd = 0x0A,          
    kATAFnGetDriveConfig = 0x0B, 
    kATAFnSetDriveConfig = 0x0C, 
    kATAFnKillIO = 0x0D          
  };
 
  enum
  {
    kATADeviceLightOff = 0x00, 
    kATADeviceLightOn = 0x01   
  };
 
  enum
  {
    kATADeviceUnlock = 0x00, 
    kATADeviceLock = 0x01    
  };
 
  enum
  {
    mATANoDMAOnBus = 0x80
  };
 
  typedef CALLBACK_API(void, ATACallbackProcPtr)(void *ataPB);
  typedef STACK_UPP_TYPE(ATACallbackProcPtr) ATACallbackUPP;
#if CALL_NOT_IN_CARBON
  ATACallbackUPP
  NewATACallbackUPP(ATACallbackProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppATACallbackProcInfo = 0x000000C0
  }; 
#ifdef __cplusplus
  inline ATACallbackUPP NewATACallbackUPP(ATACallbackProcPtr userRoutine)
  {
    return (ATACallbackUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppATACallbackProcInfo, GetCurrentArchitecture());
  }
#else
#define NewATACallbackUPP(userRoutine)                                     \
  (ATACallbackUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppATACallbackProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeATACallbackUPP(ATACallbackUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeATACallbackUPP(ATACallbackUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeATACallbackUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  InvokeATACallbackUPP(void *ataPB, ATACallbackUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeATACallbackUPP(void *ataPB, ATACallbackUPP userUPP)
  {
    CALL_ONE_PARAMETER_UPP(userUPP, uppATACallbackProcInfo, ataPB);
  }
#else
#define InvokeATACallbackUPP(ataPB, userUPP) \
  CALL_ONE_PARAMETER_UPP((userUPP), uppATACallbackProcInfo, (ataPB))
#endif
#endif
 
#endif 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewATACallbackProc(userRoutine) NewATACallbackUPP(userRoutine)
#define CallATACallbackProc(userRoutine, ataPB) \
  InvokeATACallbackUPP(ataPB, userRoutine)
#endif 
  struct ataDeviceID
  {
    UInt16 Reserved; 
    UInt8 devNum;    
    UInt8 busNum;    
  };
  typedef struct ataDeviceID ataDeviceID;
#define kATADevIDProperty "device_id"
  enum
  {
    kATADevIDPropertyNameLength =
        10,                   
    kATADevIDPropertySize = 4 
  };
 
  struct ATADataObject
  {
    UInt8 *ioBuf; 
    UInt32 Count; 
  };
  typedef struct ATADataObject ATADataObject;
  struct ATAResult
  {
    OSStatus ataResult;      
    SInt8 ataStatusRegister; 
    SInt8 ataErrorRegister;  
    UInt32 actualXferCount;  
    ataTaskFile *TaskFile;   
  };
  typedef struct ATAResult ATAResult;
  struct ATAPICmdPacket
  {
    SInt16 atapiPacketSize;     
    SInt16 atapiCommandByte[8]; 
  };
  typedef struct ATAPICmdPacket ATAPICmdPacket;
  struct ATADevInfo
  {
    UInt8 devType;
    SInt8 devID;
  };
  typedef struct ATADevInfo ATADevInfo;
  enum
  {
    kATAInvalidDeviceID = -1,
    kATADevice0DeviceID =
        0,                  
    kATADevice1DeviceID = 1 
  };
 
  struct ATAInitInfo
  {
    UInt32 busID;              
    ATADevInfo FirstDevice;    
    ATADevInfo SecondDevice;   
    RegEntryIDPtr aimRegEntry; 
    UInt32 refCon;             
  };
  typedef struct ATAInitInfo ATAInitInfo;
  struct ATADiagResult
  {
    UInt16 ataRegMask;      
    OSStatus ataResult;     
    UInt16 ataDataReg;      
    UInt8 ataTFFeatures;    
    UInt8 ataTFCount;       
    UInt8 ataTFSector;      
    UInt8 ataTFCylinderLo;  
    UInt8 ataTFCylinderHi;  
    UInt8 ataTFSDH;         
    UInt8 ataTFCommand;     
    UInt8 ataAltStatDevCnt; 
  };
  typedef struct ATADiagResult ATADiagResult;
  struct ATABusInfo
  {
    UInt8 ataPIOModes;        
    UInt8 ataSingleDMAModes;  
    UInt8 ataMultiDMAModes;   
    UInt8 ataUltraDMAModes;   
    UInt32 ataIOPBsize0;      
    UInt32 ataIOPBsize1;      
    SInt8 ataContrlType[16];  
    NumVersion ataHBAversion; 
    UInt32 reserved3;
  };
  typedef struct ATABusInfo ATABusInfo;
  enum
  {
    kATAConfigReserved = 5 
  };
 
  struct ATADevConfig
  {
    SInt32 ataConfigSetting; 
    UInt8 ataPIOSpeedMode; 
    UInt8 reserved;
    UInt16 atapcValid;            
    UInt16 ataRWMultipleCount;    
    UInt16 ataSectorsPerCylinder; 
    UInt16 ataHeads;              
    UInt16 ataSectorsPerTrack;    
    UInt16 ataSocketNumber;       
    UInt8 ataSocketType;          
    UInt8 ataDeviceType;          
    UInt8 atapcAccessMode;        
    UInt8 atapcVcc;               
    UInt8 atapcVpp1;              
    UInt8 atapcVpp2;              
    UInt8 atapcStatus;            
    UInt8 atapcPin;               
    UInt8 atapcCopy;              
    UInt8 atapcConfigIndex;       
    UInt8 ataSingleDMASpeed;      
    UInt8 ataMultiDMASpeed;       
    UInt16 ataPIOCycleTime;       
    UInt16 ataMultiCycleTime;     
    UInt8 ataUltraDMASpeed;       
    UInt8 reserved2;              
    UInt16 ataUltraCycleTime;     
    UInt16 Reserved1[5];          
  };
  typedef struct ATADevConfig ATADevConfig;
  struct ATAReqBlock
  {
    UInt32 connectionID;       
    UInt32 MsgID;              
    ATAResult *result;         
    ATADiagResult *DiagResult; 
    ATABusInfo *busInfo;       
    ATADevConfig *devConfig;   
    ATADataObject ioObject;    
    ataTaskFile ataPBTaskFile; 
    ATAPICmdPacket packetCBD;  
    Duration Timeout;          
    UInt32 BusID;              
    SInt8 DevID;               
    UInt8 ataFunctionCode;
    UInt32 AbortID;
    UInt32 ataPBLogicalBlockSize;
    UInt32 ataPBFlags;
    UInt32 reserved;
    struct ATAReqBlock *nextREQ; 
    OSStatus ataPBResult;
    UInt8 ataPBErrorRegister;
    UInt8 ataPBStatusRegister;
    UInt32 ataPBactualXferCount;
    UInt32 ataPBState;
    UInt32 ataPBSemaphores;
    UInt8 XferType;
    UInt8 ataModeType;  
    UInt8 ataPBIOSpeed; 
    UInt8 reserved2;
    UInt16 reserved3;
  };
  typedef struct ATAReqBlock ATAReqBlock;
  enum
  {
    kATAModeAbsolute = 2,
    kATAModeBitmap = 3 
  };
 
  enum
  {
    kATAPluginVersion = 0x00000001,
    kATAPluginCurrentVersion = kATAPluginVersion
  };
 
  enum
  {
    kServiceCategoryATA = FOUR_CHAR_CODE('ata-') 
  };
 
  struct ataPBHeader
  {
    struct ataPBHeader *ataPBLink;   
    UInt16 ataPBQType;               
    UInt8 ataPBVers;                 
    UInt8 ataPBReserved;             
    Ptr ataPBReserved2;              
    ATACallbackUPP ataPBCallbackPtr; 
    OSErr ataPBResult;               
    UInt8 ataPBFunctionCode;         
    UInt8 ataPBIOSpeed;              
    UInt16 ataPBFlags;               
    SInt16 ataPBReserved3;           
    UInt32 ataPBDeviceID;            
    UInt32 ataPBTimeOut;             
    Ptr ataPBClientPtr1;             
    Ptr ataPBClientPtr2;             
    UInt16 ataPBState;               
    UInt16 ataPBSemaphores;          
    SInt32 ataPBReserved4;           
  };
  typedef struct ataPBHeader ataPBHeader;
  struct IOBlock
  {
    UInt8 *ataPBBuffer;    
    UInt32 ataPBByteCount; 
  };
  typedef struct IOBlock IOBlock;
  struct ataIOPB
  {
    ataPBHeader *ataPBLink;          
    UInt16 ataPBQType;               
    UInt8 ataPBVers;                 
    UInt8 ataPBReserved;             
    Ptr ataPBReserved2;              
    ATACallbackUPP ataPBCallbackPtr; 
    OSErr ataPBResult;               
    UInt8 ataPBFunctionCode;         
    UInt8 ataPBIOSpeed;              
    UInt16 ataPBFlags;               
    SInt16 ataPBReserved3;           
    UInt32 ataPBDeviceID;            
    UInt32 ataPBTimeOut;             
    Ptr ataPBClientPtr1;             
    Ptr ataPBClientPtr2;             
    UInt16 ataPBState;               
    UInt16 ataPBSemaphores;          
    SInt32 ataPBReserved4;           
    SInt8 ataPBStatusRegister;       
    SInt8 ataPBErrorRegister;        
    SInt16 ataPBReserved5;           
    UInt32 ataPBLogicalBlockSize;    
    UInt8 *ataPBBuffer;              
    UInt32 ataPBByteCount;           
    UInt32 ataPBActualTxCount;       
    UInt32 ataPBReserved6;           
    ataTaskFile ataPBTaskFile;       
    ATAPICmdPacket *ataPBPacketPtr;  
    SInt16 ataPBReserved7[6];        
  };
  typedef struct ataIOPB ataIOPB;
  struct ataBusInquiry
  {
    ataPBHeader *ataPBLink;          
    UInt16 ataPBQType;               
    UInt8 ataPBVers;                 
    UInt8 ataPBReserved;             
    Ptr ataPBReserved2;              
    ATACallbackUPP ataPBCallbackPtr; 
    OSErr ataPBResult;               
    UInt8 ataPBFunctionCode;         
    UInt8 ataPBIOSpeed;              
    UInt16 ataPBFlags;               
    SInt16 ataPBReserved3;           
    UInt32 ataPBDeviceID;            
    UInt32 ataPBTimeOut;             
    Ptr ataPBClientPtr1;             
    Ptr ataPBClientPtr2;             
    UInt16 ataPBState;               
    UInt16 ataPBSemaphores;          
    SInt32 ataPBReserved4;           
    UInt16 ataEngineCount;           
    UInt16 ataReserved1;             
    UInt32 ataDataTypes;             
    UInt16 ataIOpbSize;              
    UInt16 ataMaxIOpbSize;           
    UInt32 ataFeatureFlags;          
    UInt8 ataVersionNum;             
    UInt8 ataHBAInquiry;             
    UInt16 ataReserved2;             
    UInt32 ataHBAPrivPtr;            
    UInt32 ataHBAPrivSize;           
    UInt32 ataAsyncFlags;            
    UInt8 ataPIOModes;               
    UInt8 ataUltraDMAModes;          
    UInt8 ataSingleDMAModes;         
    UInt8 ataMultiDMAModes;          
    UInt32 ataReserved4[4];          
    SInt8 ataReserved5[16];          
    SInt8 ataHBAVendor[16];          
    SInt8 ataContrlFamily[16];       
    SInt8 ataContrlType[16];         
    SInt8 ataXPTversion[4];          
    SInt8 ataReserved6[4];           
    NumVersion ataHBAversion;        
    UInt8 ataHBAslotType;            
    UInt8 ataHBAslotNum;             
    UInt16 ataReserved7;             
    UInt32 ataReserved8;             
  };
  typedef struct ataBusInquiry ataBusInquiry;
  struct ataMgrInquiry
  {
    ataPBHeader *ataPBLink;          
    UInt16 ataPBQType;               
    UInt8 ataPBVers;                 
    UInt8 ataPBReserved;             
    Ptr ataPBReserved2;              
    ATACallbackUPP ataPBCallbackPtr; 
    OSErr ataPBResult;               
    UInt8 ataPBFunctionCode;         
    UInt8 ataPBIOSpeed;              
    UInt16 ataPBFlags;               
    SInt16 ataPBReserved3;           
    UInt32 ataPBDeviceID;            
    UInt32 ataPBTimeOut;             
    Ptr ataPBClientPtr1;             
    Ptr ataPBClientPtr2;             
    UInt16 ataPBState;               
    UInt16 ataPBSemaphores;          
    SInt32 ataPBReserved4;           
    NumVersion ataMgrVersion;        
    UInt8 ataMgrPBVers;              
    UInt8 Reserved1;                 
    UInt16 ataBusCnt;                
    UInt16 ataDevCnt;                
    UInt8 ataPioModes;               
    UInt8 Reserved2;                 
    UInt16
        ataIOClkResolution;  
    UInt8 ataSingleDMAModes; 
    UInt8 ataMultiDMAModes;  
    SInt16 Reserved[16];     
  };
  typedef struct ataMgrInquiry ataMgrInquiry;
  struct ataAbort
  {
    ataPBHeader *ataPBLink;          
    UInt16 ataPBQType;               
    UInt8 ataPBVers;                 
    UInt8 ataPBReserved;             
    Ptr ataPBReserved2;              
    ATACallbackUPP ataPBCallbackPtr; 
    OSErr ataPBResult;               
    UInt8 ataPBFunctionCode;         
    UInt8 ataPBIOSpeed;              
    UInt16 ataPBFlags;               
    SInt16 ataPBReserved3;           
    UInt32 ataPBDeviceID;            
    UInt32 ataPBTimeOut;             
    Ptr ataPBClientPtr1;             
    Ptr ataPBClientPtr2;             
    UInt16 ataPBState;               
    UInt16 ataPBSemaphores;          
    SInt32 ataPBReserved4;           
    ataIOPB *ataAbortPB;             
    SInt16 Reserved[22];             
  };
  typedef struct ataAbort ataAbort;
  struct ATAEventRec
  {
    UInt16 ataEventCode;       
    UInt16 ataPhysicalID;      
    SInt32 ataDrvrContext;     
    UInt32 ataMarker;          
    UInt32 ataEventRecVersion; 
    UInt32 ataDeviceType;      
    UInt16 ataRefNum;          
  };
  typedef struct ATAEventRec ATAEventRec;
  typedef ATAEventRec *ATAEventRecPtr;
  typedef CALLBACK_API(SInt16, ATAClientProcPtr)(ATAEventRecPtr ataERPtr);
  typedef STACK_UPP_TYPE(ATAClientProcPtr) ATAClientUPP;
#if CALL_NOT_IN_CARBON
  ATAClientUPP
  NewATAClientUPP(ATAClientProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppATAClientProcInfo = 0x000000E0
  }; 
#ifdef __cplusplus
  inline ATAClientUPP NewATAClientUPP(ATAClientProcPtr userRoutine)
  {
    return (ATAClientUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppATAClientProcInfo, GetCurrentArchitecture());
  }
#else
#define NewATAClientUPP(userRoutine)   \
  (ATAClientUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppATAClientProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeATAClientUPP(ATAClientUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeATAClientUPP(ATAClientUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeATAClientUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  SInt16
  InvokeATAClientUPP(ATAEventRecPtr ataERPtr, ATAClientUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline SInt16 InvokeATAClientUPP(ATAEventRecPtr ataERPtr,
                                   ATAClientUPP userUPP)
  {
    return (SInt16)CALL_ONE_PARAMETER_UPP(userUPP, uppATAClientProcInfo,
                                          ataERPtr);
  }
#else
#define InvokeATAClientUPP(ataERPtr, userUPP) \
  (SInt16) CALL_ONE_PARAMETER_UPP((userUPP), uppATAClientProcInfo, (ataERPtr))
#endif
#endif
 
#endif 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewATAClientProc(userRoutine) NewATAClientUPP(userRoutine)
#define CallATAClientProc(userRoutine, ataERPtr) \
  InvokeATAClientUPP(ataERPtr, userRoutine)
#endif 
  struct ataDrvrRegister
  {
    ataPBHeader *ataPBLink;          
    UInt16 ataPBQType;               
    UInt8 ataPBVers;                 
    UInt8 ataPBReserved;             
    Ptr ataPBReserved2;              
    ATACallbackUPP ataPBCallbackPtr; 
    OSErr ataPBResult;               
    UInt8 ataPBFunctionCode;         
    UInt8 ataPBIOSpeed;              
    UInt16 ataPBFlags;               
    SInt16 ataPBReserved3;           
    UInt32 ataPBDeviceID;            
    UInt32 ataPBTimeOut;             
    Ptr ataPBClientPtr1;             
    Ptr ataPBClientPtr2;             
    UInt16 ataPBState;               
    UInt16 ataPBSemaphores;          
    SInt32 ataPBReserved4;           
    SInt16 ataDrvrRefNum;            
    UInt16 ataDrvrFlags;             
    UInt16 ataDeviceNextID;          
    SInt16 ataDrvrLoadPriv;          
    ATAClientUPP
        ataEventHandler;   
    SInt32 ataDrvrContext; 
    SInt32 ataEventMask;   
    SInt16 Reserved[14];   
  };
  typedef struct ataDrvrRegister ataDrvrRegister;
  struct ataModifyEventMask
  {
    ataPBHeader *ataPBLink;          
    UInt16 ataPBQType;               
    UInt8 ataPBVers;                 
    UInt8 ataPBReserved;             
    Ptr ataPBReserved2;              
    ATACallbackUPP ataPBCallbackPtr; 
    OSErr ataPBResult;               
    UInt8 ataPBFunctionCode;         
    UInt8 ataPBIOSpeed;              
    UInt16 ataPBFlags;               
    SInt16 ataPBReserved3;           
    UInt32 ataPBDeviceID;            
    UInt32 ataPBTimeOut;             
    Ptr ataPBClientPtr1;             
    Ptr ataPBClientPtr2;             
    UInt16 ataPBState;               
    UInt16 ataPBSemaphores;          
    SInt32 ataPBReserved4;           
    SInt32 ataModifiedEventMask;     
    SInt16 Reserved[22];             
  };
  typedef struct ataModifyEventMask ataModifyEventMask;
  enum
  {
    bATAAltSDevCValid =
        14,                   
    bATAStatusCmdValid = 7,   
    bATASDHValid = 6,         
    bATACylinderHiValid = 5,  
    bATACylinderLoValid = 4,  
    bATASectorNumValid = 3,   
    bATASectorCntValid = 2,   
    bATAErrFeaturesValid = 1, 
    bATADataValid = 0,        
    mATAAltSDevCValid =
        1 << bATAAltSDevCValid,                       
    mATAStatusCmdValid = 1 << bATAStatusCmdValid,     
    mATASDHValid = 1 << bATASDHValid,                 
    mATACylinderHiValid = 1 << bATACylinderHiValid,   
    mATACylinderLoValid = 1 << bATACylinderLoValid,   
    mATASectorNumValid = 1 << bATASectorNumValid,     
    mATASectorCntValid = 1 << bATASectorCntValid,     
    mATAErrFeaturesValid = 1 << bATAErrFeaturesValid, 
    mATADataValid = 1 << bATADataValid                
  };
 
  union ataRegValueUnion
  {
    UInt8 ataByteRegValue;  
    UInt16 ataWordRegValue; 
  };
  typedef union ataRegValueUnion ataRegValueUnion;
  struct ataRegAccess
  {
    ataPBHeader *ataPBLink;          
    UInt16 ataPBQType;               
    UInt8 ataPBVers;                 
    UInt8 ataPBReserved;             
    Ptr ataPBReserved2;              
    ATACallbackUPP ataPBCallbackPtr; 
    OSErr ataPBResult;               
    UInt8 ataPBFunctionCode;         
    UInt8 ataPBIOSpeed;              
    UInt16 ataPBFlags;               
    SInt16 ataPBReserved3;           
    UInt32 ataPBDeviceID;            
    UInt32 ataPBTimeOut;             
    Ptr ataPBClientPtr1;             
    Ptr ataPBClientPtr2;             
    UInt16 ataPBState;               
    UInt16 ataPBSemaphores;          
    SInt32 ataPBReserved4;           
    UInt16 ataRegSelect;             
    ataRegValueUnion ataRegValue;
    UInt16 ataRegMask; 
    ataTaskFile ataRegisterImage; 
    UInt8 ataAltSDevCReg;         
    UInt8 Reserved3;              
    SInt16 Reserved[16];          
  };
  typedef struct ataRegAccess ataRegAccess;
  struct ataIdentify
  {
    ataPBHeader *ataPBLink;          
    UInt16 ataPBQType;               
    UInt8 ataPBVers;                 
    UInt8 ataPBReserved;             
    Ptr ataPBReserved2;              
    ATACallbackUPP ataPBCallbackPtr; 
    OSErr ataPBResult;               
    UInt8 ataPBFunctionCode;         
    UInt8 ataPBIOSpeed;              
    UInt16 ataPBFlags;               
    SInt16 ataPBReserved3;           
    UInt32 ataPBDeviceID;            
    UInt32 ataPBTimeOut;             
    Ptr ataPBClientPtr1;             
    Ptr ataPBClientPtr2;             
    UInt16 ataPBState;               
    UInt16 ataPBSemaphores;          
    SInt32 ataPBReserved4;           
    UInt16 Reserved1[4];             
    UInt8 *ataPBBuffer;              
    UInt16 Reserved2[12];            
    SInt16 Reserved3[6];             
  };
  typedef struct ataIdentify ataIdentify;
  enum
  {
    ATAPIpacketDRQ_bit = 6,                  
    ATAPIpacketDRQ = 1 << ATAPIpacketDRQ_bit 
  };
 
  enum
  {
    bATApcAccessMode = 0,
    bATApcVcc = 1,
    bATApcVpp1 = 2,
    bATApcVpp2 = 3,
    bATApcStatus = 4,
    bATApcPin = 5,
    bATApcCopy = 6,
    bATApcConfigIndex = 7,
    bATApcLockUnlock = 15,
    mATApcAccessMode = 1 << bATApcAccessMode,
    mATApcVcc = 1 << bATApcVcc,
    mATApcVpp1 = 1 << bATApcVpp1,
    mATApcVpp2 = 1 << bATApcVpp2,
    mATApcStatus = 1 << bATApcStatus,
    mATApcPin = 1 << bATApcPin,
    mATApcCopy = 1 << bATApcCopy,
    mATApcConfigIndex = 1 << bATApcConfigIndex,
    mATApcLockUnlock = 1 << bATApcLockUnlock
  };
 
  enum
  {
    kATADeviceUnknown = 0x00, 
    kATADeviceATA = 0x01,     
    kATADeviceATAPI = 0x02,   
    kATADeviceReserved = 0x03 
  };
 
  enum
  {
    kATASocketInternal = 0x01, 
    kATASocketMB = 0x02,       
    kATASocketPCMCIA = 0x03    
  };
 
  struct ataDevConfiguration
  {
    ataPBHeader *ataPBLink;          
    UInt16 ataPBQType;               
    UInt8 ataPBVers;                 
    UInt8 ataPBReserved;             
    Ptr ataPBReserved2;              
    ATACallbackUPP ataPBCallbackPtr; 
    OSErr ataPBResult;               
    UInt8 ataPBFunctionCode;         
    UInt8 ataPBIOSpeed;              
    UInt16 ataPBFlags;               
    SInt16 ataPBReserved3;           
    UInt32 ataPBDeviceID;            
    UInt32 ataPBTimeOut;             
    Ptr ataPBClientPtr1;             
    Ptr ataPBClientPtr2;             
    UInt16 ataPBState;               
    UInt16 ataPBSemaphores;          
    SInt32 ataPBReserved4;           
    SInt32 ataConfigSetting;         
    UInt8 ataPIOSpeedMode; 
    UInt8 Reserved3;       
    UInt16 atapcValid;     
    UInt16 ataRWMultipleCount;    
    UInt16 ataSectorsPerCylinder; 
    UInt16 ataHeads;              
    UInt16 ataSectorsPerTrack;    
    UInt16 ataSocketNumber;       
    UInt8 ataSocketType;      
    UInt8 ataDeviceType;      
    UInt8 atapcAccessMode;    
    UInt8 atapcVcc;           
    UInt8 atapcVpp1;          
    UInt8 atapcVpp2;          
    UInt8 atapcStatus;        
    UInt8 atapcPin;           
    UInt8 atapcCopy;          
    UInt8 atapcConfigIndex;   
    UInt8 ataSingleDMASpeed;  
    UInt8 ataMultiDMASpeed;   
    UInt16 ataPIOCycleTime;   
    UInt16 ataMultiCycleTime; 
    UInt8 ataUltraDMASpeed;   
    UInt8 reserved2;          
    UInt16 ataUltraCycleTime; 
    UInt16 Reserved1[5];      
  };
  typedef struct ataDevConfiguration ataDevConfiguration;
  enum
  {
    kATALargeIconHFS = 0x0001,   
    kATALargeIconProDOS = 0x0081 
  };
 
  struct ataLocationData
  {
    ataPBHeader *ataPBLink;          
    UInt16 ataPBQType;               
    UInt8 ataPBVers;                 
    UInt8 ataPBReserved;             
    Ptr ataPBReserved2;              
    ATACallbackUPP ataPBCallbackPtr; 
    OSErr ataPBResult;               
    UInt8 ataPBFunctionCode;         
    UInt8 ataPBIOSpeed;              
    UInt16 ataPBFlags;               
    SInt16 ataPBReserved3;           
    UInt32 ataPBDeviceID;            
    UInt32 ataPBTimeOut;             
    Ptr ataPBClientPtr1;             
    Ptr ataPBClientPtr2;             
    UInt16 ataPBState;               
    UInt16 ataPBSemaphores;          
    SInt32 ataPBReserved4;           
    SInt16 ataIconType;              
    SInt16 ataIconReserved;          
    SInt8 *ataLocationIconPtr;       
    SInt8 *ataLocationStringPtr;     
    UInt16 Reserved1[18];            
  };
  typedef struct ataLocationData ataLocationData;
  enum
  {
    kATAddTypeMacOS = 0x0001 
  };
 
  struct ataAddATABus
  {
    ataPBHeader *ataPBLink;        
    UInt16 ataPBQType;             
    UInt8 ataPBVers;               
    UInt8 ataPBReserved;           
    Ptr ataPBReserved2;            
    ProcPtr ataPBCallbackPtr;      
    OSErr ataPBResult;             
    UInt8 ataPBFunctionCode;       
    UInt8 ataPBIOSpeed;            
    UInt16 ataPBFlags;             
    SInt16 ataPBReserved3;         
    UInt32 ataPBDeviceID;          
    UInt32 ataPBTimeOut;           
    Ptr ataPBClientPtr1;           
    Ptr ataPBClientPtr2;           
    UInt16 ataPBState;             
    UInt16 ataPBSemaphores;        
    SInt32 ataPBReserved4;         
    RegEntryIDPtr ataNameRegEntry; 
    CFragConnectionID connID;      
    UInt32 busID;                  
    UInt8 flags;                   
    UInt8 socketType;              
    Ptr iconData;                  
    Ptr stringData;                
  };
  typedef struct ataAddATABus ataAddATABus;
  struct ataRemoveATABus
  {
    ataPBHeader *ataPBLink;        
    UInt16 ataPBQType;             
    UInt8 ataPBVers;               
    UInt8 ataPBReserved;           
    Ptr ataPBReserved2;            
    ProcPtr ataPBCallbackPtr;      
    OSErr ataPBResult;             
    UInt8 ataPBFunctionCode;       
    UInt8 ataPBIOSpeed;            
    UInt16 ataPBFlags;             
    SInt16 ataPBReserved3;         
    UInt32 ataPBDeviceID;          
    UInt32 ataPBTimeOut;           
    Ptr ataPBClientPtr1;           
    Ptr ataPBClientPtr2;           
    UInt16 ataPBState;             
    UInt16 ataPBSemaphores;        
    SInt32 ataPBReserved4;         
    UInt32 busID;                  
    RegEntryIDPtr ataNameRegEntry; 
  };
  typedef struct ataRemoveATABus ataRemoveATABus;
  struct ataGeneric
  {
    ataPBHeader *ataPBLink;          
    UInt16 ataPBQType;               
    UInt8 ataPBVers;                 
    UInt8 ataPBReserved;             
    Ptr ataPBReserved2;              
    ATACallbackUPP ataPBCallbackPtr; 
    OSErr ataPBResult;               
    UInt8 ataPBFunctionCode;         
    UInt8 ataPBIOSpeed;              
    UInt16 ataPBFlags;               
    SInt16 ataPBReserved3;           
    UInt32 ataPBDeviceID;            
    UInt32 ataPBTimeOut;             
    Ptr ataPBClientPtr1;             
    Ptr ataPBClientPtr2;             
    UInt16 ataPBState;               
    UInt16 ataPBSemaphores;          
    SInt32 ataPBReserved4;           
    UInt16 Reserved[24];             
  };
  typedef struct ataGeneric ataGeneric;
  union ataPB
  {
    ataIOPB ataIOParamBlock;         
    ataBusInquiry ataBIParamBlock;   
    ataMgrInquiry ataMIParamBlock;   
    ataAbort ataAbortParamBlock;     
    ataDrvrRegister ataDRParamBlock; 
    ataModifyEventMask
        ataMEParamBlock;          
    ataRegAccess ataRAParamBlock; 
    ataIdentify ataDIParamBlock;  
    ataDevConfiguration
        ataDCParamBlock;             
    ataLocationData ataLDParamBlock; 
    ataGeneric ataGenericParamBlock; 
  };
  typedef union ataPB ataPB;
  enum
  {
    kATANullEvent = 0x00,      
    kATAOnlineEvent = 0x01,    
    kATAOfflineEvent = 0x02,   
    kATARemovedEvent = 0x03,   
    kATAResetEvent = 0x04,     
    kATAOfflineRequest = 0x05, 
    kATAEjectRequest = 0x06,   
    kATAUpdateEvent =
        0x07, 
    kATATaskTimeRequest =
        0x08,                 
    kATALoadDriverNow = 0x09, 
    kATAPIResetEvent = 0x0A,  
    bATANullEvent = 1 << kATANullEvent,           
    bATAOnlineEvent = 1 << kATAOnlineEvent,       
    bATAOfflineEvent = 1 << kATAOfflineEvent,     
    bATARemovedEvent = 1 << kATARemovedEvent,     
    bATAResetEvent = 1 << kATAResetEvent,         
    bATAOfflineRequest = 1 << kATAOfflineRequest, 
    bATAEjectRequest = 1 << kATAEjectRequest,     
    bATAUpdateEvent = 1 << kATAUpdateEvent,       
    bATAPIResetEvent = 1 << kATAPIResetEvent      
  };
 
  enum
  {
    kATAEventMarker =
        FOUR_CHAR_CODE('LOAD'),    
    kATAEventVersion1 = 0x00000001 
  };
 
  typedef CALLBACK_API(OSErr, ATADispatchProcPtr)(ataPB *pb);
  typedef STACK_UPP_TYPE(ATADispatchProcPtr) ATADispatchUPP;
#if CALL_NOT_IN_CARBON
  ATADispatchUPP
  NewATADispatchUPP(ATADispatchProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppATADispatchProcInfo = 0x000000E0
  }; 
#ifdef __cplusplus
  inline ATADispatchUPP NewATADispatchUPP(ATADispatchProcPtr userRoutine)
  {
    return (ATADispatchUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppATADispatchProcInfo, GetCurrentArchitecture());
  }
#else
#define NewATADispatchUPP(userRoutine)                                     \
  (ATADispatchUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppATADispatchProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeATADispatchUPP(ATADispatchUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeATADispatchUPP(ATADispatchUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeATADispatchUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  OSErr
  InvokeATADispatchUPP(ataPB *pb, ATADispatchUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSErr InvokeATADispatchUPP(ataPB *pb, ATADispatchUPP userUPP)
  {
    return (OSErr)CALL_ONE_PARAMETER_UPP(userUPP, uppATADispatchProcInfo, pb);
  }
#else
#define InvokeATADispatchUPP(pb, userUPP) \
  (OSErr) CALL_ONE_PARAMETER_UPP((userUPP), uppATADispatchProcInfo, (pb))
#endif
#endif
 
#endif 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewATADispatchProc(userRoutine) NewATADispatchUPP(userRoutine)
#define CallATADispatchProc(userRoutine, pb) \
  InvokeATADispatchUPP(pb, userRoutine)
#endif 
#if CALL_NOT_IN_CARBON
  SInt16
  ataManager(ataPB *pb);
 
#endif 
  typedef CALLBACK_API_C(OSStatus, ATAPluginInit)(ATAInitInfo *pb);
  typedef CALLBACK_API_C(OSStatus, ATAPluginClose)(UInt32 refCon,
                                                   RegEntryIDPtr aimRegEntry);
  typedef CALLBACK_API_C(void, ATAPluginAction)(UInt32 refCon, ATAReqBlock *pb);
  typedef CALLBACK_API_C(void, ATAPluginHandleBusEvent)(UInt32 refCon,
                                                        UInt32 aimData);
  typedef CALLBACK_API_C(Boolean, ATAPluginPoll)(UInt32 refCon,
                                                 UInt32 interruptLevel,
                                                 UInt32 *aimData);
  typedef CALLBACK_API_C(void, ATAPluginEjectDevice)(UInt32 refCon);
  typedef CALLBACK_API_C(void, ATAPluginDeviceLight)(UInt32 refCon,
                                                     UInt32 whichDevice,
                                                     UInt32 lightState);
  typedef CALLBACK_API_C(void, ATAPluginDeviceLock)(UInt32 refCon,
                                                    UInt32 whichDevice,
                                                    UInt32 lockState);
  typedef CALLBACK_API_C(void, ATAPluginSuspend)(UInt32 refCon);
  typedef CALLBACK_API_C(void, ATAPluginResume)(UInt32 refCon);
  struct ATAPluginHeader
  {
    NumVersion headerVersion;
    NumVersion dispatchVersion;
    UInt32 reservedA;
    UInt32 reservedB;
  };
  typedef struct ATAPluginHeader ATAPluginHeader;
  struct ATAPluginDispatchTable
  {
    ATAPluginHeader header;
    ATAPluginInit init;
    ATAPluginClose close;
    ATAPluginAction action;
    ATAPluginHandleBusEvent busEvent;
    ATAPluginPoll poll;
    ATAPluginEjectDevice eject;
    ATAPluginDeviceLight light;
    ATAPluginDeviceLock lock;
    ATAPluginSuspend suspend;
    ATAPluginResume resume;
  };
  typedef struct ATAPluginDispatchTable ATAPluginDispatchTable;
 
#if CALL_NOT_IN_CARBON
  void
  ATAFamIODone(ATAReqBlock *theReq, OSStatus result);
 
  void
  ATAFamBusEventForAIM(UInt32 busID, UInt32 busEvent);
 
  SInt16
  NativeATAMgr(ataPB *request);
 
#endif 
  enum
  {
    ATABaseErrCode = -9406,                
    ioPending = 1,                         
    AT_NRdyErr = ATABaseErrCode + 0x01,    
    AT_IDNFErr = ATABaseErrCode + 0x02,    
    AT_DMarkErr = ATABaseErrCode + 0x03,   
    AT_BadBlkErr = ATABaseErrCode + 0x04,  
    AT_CorDataErr = ATABaseErrCode + 0x05, 
    AT_UncDataErr = ATABaseErrCode + 0x06, 
    AT_SeekErr = ATABaseErrCode + 0x07,    
    AT_WrFltErr = ATABaseErrCode + 0x08,   
    AT_RecalErr = ATABaseErrCode + 0x09,   
    AT_AbortErr = ATABaseErrCode + 0x0A,   
    AT_MCErr = ATABaseErrCode + 0x0C,      
    ATAPICheckErr =
        ATABaseErrCode + 0x0D, 
    AT_UltraDMAiCRCErr =
        ATABaseErrCode + 0x0E, 
    DRVRCantAllocate = ATABaseErrCode +
                       0x1E, 
    NoATAMgr =
        ATABaseErrCode + 0x1F,           
    ATAInitFail = ATABaseErrCode + 0x20, 
    ATABufFail = ATABaseErrCode + 0x21,  
    ATADevUnsupported =
        ATABaseErrCode + 0x22, 
    ATAEjectDrvErr =
        ATABaseErrCode + 0x23, 
    ATAMgrNotInitialized =
        ATABaseErrCode + 0x2E, 
    ATAPBInvalid = ATABaseErrCode +
                   0x2F, 
    ATAFuncNotSupported =
        ATABaseErrCode + 0x30,       
    ATABusy = ATABaseErrCode + 0x31, 
    ATATransTimeOut =
        ATABaseErrCode + 0x32, 
    ATAReqInProg =
        ATABaseErrCode +
        0x33, 
    ATAUnknownState =
        ATABaseErrCode +
        0x34, 
    ATAQLocked =
        ATABaseErrCode +
        0x35, 
    ATAReqAborted =
        ATABaseErrCode +
        0x36, 
    ATAUnableToAbort =
        ATABaseErrCode +
        0x37, 
    ATAAbortedDueToRst =
        ATABaseErrCode +
        0x38,                              
    ATAPIPhaseErr = ATABaseErrCode + 0x39, 
    ATAPITxCntErr =
        ATABaseErrCode + 0x3A, 
    ATANoClientErr =
        ATABaseErrCode + 0x3B, 
    ATAInternalErr =
        ATABaseErrCode + 0x3C,            
    ATABusErr = ATABaseErrCode + 0x3D,    
    AT_NoAddrErr = ATABaseErrCode + 0x3E, 
    DriverLocked =
        ATABaseErrCode +
        0x3F, 
    CantHandleEvent =
        ATABaseErrCode +
        0x40, 
    ATAMgrMemoryErr =
        ATABaseErrCode + 0x41,            
    ATASDFailErr = ATABaseErrCode + 0x42, 
    ATAXferParamErr =
        ATABaseErrCode + 0x43, 
    ATAXferModeErr =
        ATABaseErrCode + 0x44, 
    ATAMgrConsistencyErr =
        ATABaseErrCode +
        0x45, 
    ATADmaXferErr =
        ATABaseErrCode + 0x46, 
    ATAInvalidDrvNum =
        ATABaseErrCode + 0x4E,            
    ATAMemoryErr = ATABaseErrCode + 0x4F, 
    ATANoDDMErr = ATABaseErrCode + 0x50,  
    ATANoDriverErr =
        ATABaseErrCode + 0x51 
  };
 
  enum
  {
    v1ATABaseErrCode = 0x0700,                 
    v1AT_NRdyErr = 0x01 - v1ATABaseErrCode,    
    v1AT_IDNFErr = 0x04 - v1ATABaseErrCode,    
    v1AT_DMarkErr = 0x05 - v1ATABaseErrCode,   
    v1AT_BadBlkErr = 0x06 - v1ATABaseErrCode,  
    v1AT_CorDataErr = 0x07 - v1ATABaseErrCode, 
    v1AT_UncDataErr = 0x08 - v1ATABaseErrCode, 
    v1AT_SeekErr = 0x09 - v1ATABaseErrCode,    
    v1AT_WrFltErr = 0x0A - v1ATABaseErrCode,   
    v1AT_RecalErr = 0x0B - v1ATABaseErrCode,   
    v1AT_AbortErr = 0x0C - v1ATABaseErrCode,   
    v1AT_NoAddrErr = 0x0D - v1ATABaseErrCode,  
    v1AT_MCErr = 0x0E - v1ATABaseErrCode,      
    v1DRVRCantAllocate = -(v1ATABaseErrCode + 1),      
    v1NoATAMgr = -(v1ATABaseErrCode + 2),              
    v1ATAInitFail = -(v1ATABaseErrCode + 3),           
    v1ATABufFail = -(v1ATABaseErrCode + 4),            
    v1ATADevUnsupported = -(v1ATABaseErrCode + 5),     
    v1ATAMgrNotInitialized = -(v1ATABaseErrCode + 10), 
    v1ATAPBInvalid = -(v1ATABaseErrCode + 11),         
    v1ATAFuncNotSupported = -(v1ATABaseErrCode + 12),  
    v1ATABusy = -(v1ATABaseErrCode + 13),              
    v1ATATransTimeOut = -(v1ATABaseErrCode + 14),      
    v1ATAReqInProg = -(v1ATABaseErrCode + 15),         
    v1ATAUnknownState = -(v1ATABaseErrCode + 16),      
    v1ATAQLocked = -(v1ATABaseErrCode + 17),           
    v1ATAReqAborted = -(v1ATABaseErrCode + 18),        
    v1ATAUnableToAbort = -(v1ATABaseErrCode + 19),     
    v1ATAAbortedDueToRst = -(v1ATABaseErrCode + 20)    
  };
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif