topical media & game development
lib-of-vs-libs-QTDevWin-CIncludes-ATA.h / h
/*
File: ATA.h
Contains: ATA (PC/AT Attachment) Interfaces
Version: Technology: System 7.5
Release: QuickTime 6.0.2
Copyright: (c) 1995-2001 by Apple Computer, Inc., all rights reserved
Bugs?: For bug reports, consult the following page on
the World Wide Web:
http://developer.apple.com/bugreporter/
*/
ifndef __ATA__
define __ATA__
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
/* This is the structure used for the AT Interface core routines below */
enum {
kATATrap = 0xAAF1, /* Manager trap number <This should be defined in Traps.h>*/
kATAPBVers1 = 0x01, /* parameter block version number 1*/
kATAPBVers2 = 0x02, /* parameter block version number for structures*/
kATAPBVers3 = 0x03, /* parameter block version for ATA times*/
kATADefaultBlockSize = 512 /* default block size*/
};
/* Used to determine the presence of traps*/
enum {
kFSMTrap = 0xAC,
mDQEChanged = 1 /* DQE has changed */
};
/* Task file definition ooo Error Register ooo*/
enum {
bATABadBlock = 7, /* bit number of bad block error bit*/
bATAUncorrectable = 6, /* bit number of uncorrectable error bit*/
bATAMediaChanged = 5, /* bit number of media changed indicator*/
bATAIDNotFound = 4, /* bit number of ID not found error bit*/
bATAMediaChangeReq = 3, /* bit number of media changed request*/
bATACommandAborted = 2, /* bit number of command abort bit*/
bATATrack0NotFound = 1, /* bit number of track not found*/
bATAAddressNotFound = 0, /* bit number of address mark not found*/
mATABadBlock = 1 << bATABadBlock, /* Bad Block Detected*/
mATAUncorrectable = 1 << bATAUncorrectable, /* Uncorrectable Data Error*/
mATAMediaChanged = 1 << bATAMediaChanged, /* Media Changed Indicator (for removable)*/
mATAIDNotFound = 1 << bATAIDNotFound, /* ID Not Found*/
mATAMediaChangeReq = 1 << bATAMediaChangeReq, /* Media Change Requested (NOT IMPLEMENTED)*/
mATACommandAborted = 1 << bATACommandAborted, /* Aborted Command*/
mATATrack0NotFound = 1 << bATATrack0NotFound, /* Track 0 Not Found*/
mATAAddressNotFound = 1 << bATAAddressNotFound /* Address Mark Not Found*/
};
/* Task file definition ooo Features register ooo*/
enum {
bATAPIuseDMA = 0, /* bit number of useDMA bit (ATAPI)*/
mATAPIuseDMA = 1 << bATAPIuseDMA
};
/* Task file definition ooo ataTFSDH Register ooo*/
enum {
mATAHeadNumber = 0x0F, /* Head Number (bits 0-3) */
mATASectorSize = 0xA0, /* bit 7=1; bit 5 = 01 (512 sector size) <DP4>*/
mATADriveSelect = 0x10, /* Drive (0 = master, 1 = slave) */
mATALBASelect = 0x40 /* LBA mode bit (0 = chs, 1 = LBA)*/
};
/* Task file definition ooo Status Register ooo*/
enum {
bATABusy = 7, /* bit number of BSY bit*/
bATADriveReady = 6, /* bit number of drive ready bit*/
bATAWriteFault = 5, /* bit number of write fault bit*/
bATASeekComplete = 4, /* bit number of seek complete bit*/
bATADataRequest = 3, /* bit number of data request bit*/
bATADataCorrected = 2, /* bit number of data corrected bit*/
bATAIndex = 1, /* bit number of index mark*/
bATAError = 0, /* bit number of error bit*/
mATABusy = 1 << bATABusy, /* Unit is busy*/
mATADriveReady = 1 << bATADriveReady, /* Unit is ready*/
mATAWriteFault = 1 << bATAWriteFault, /* Unit has a write fault condition*/
mATASeekComplete = 1 << bATASeekComplete, /* Unit seek complete*/
mATADataRequest = 1 << bATADataRequest, /* Unit data request*/
mATADataCorrected = 1 << bATADataCorrected, /* Data corrected*/
mATAIndex = 1 << bATAIndex, /* Index mark - NOT USED*/
mATAError = 1 << bATAError /* Error condition - see error register*/
};
/* Task file definition ooo Device Control Register ooo*/
enum {
bATADCROne = 3, /* bit number of always one bit*/
bATADCRReset = 2, /* bit number of reset bit*/
bATADCRnIntEnable = 1, /* bit number of interrupt disable*/
mATADCROne = 1 << bATADCROne, /* always one bit*/
mATADCRReset = 1 << bATADCRReset, /* Reset (1 = reset)*/
mATADCRnIntEnable = 1 << bATADCRnIntEnable /* Interrupt Disable(0 = enabled)*/
};
/* ATA Command Opcode definition*/
enum {
kATAcmdWORetry = 0x01, /* Without I/O retry option*/
kATAcmdNOP = 0x0000, /* NOP operation - media detect*/
kATAcmdRecal = 0x0010, /* Recalibrate command */
kATAcmdRead = 0x0020, /* Read command */
kATAcmdReadLong = 0x0022, /* Read Long command*/
kATAcmdWrite = 0x0030, /* Write command */
kATAcmdWriteLong = 0x0032, /* Write Long*/
kATAcmdWriteVerify = 0x003C, /* Write verify*/
kATAcmdReadVerify = 0x0040, /* Read Verify command */
kATAcmdFormatTrack = 0x0050, /* Format Track command */
kATAcmdSeek = 0x0070, /* Seek command */
kATAcmdDiagnostic = 0x0090, /* Drive Diagnostic command */
kATAcmdInitDrive = 0x0091, /* Init drive parameters command */
kATAcmdReadMultiple = 0x00C4, /* Read multiple*/
kATAcmdWriteMultiple = 0x00C5, /* Write multiple*/
kATAcmdSetRWMultiple = 0x00C6, /* Set Multiple for Read/Write Multiple*/
kATAcmdReadDMA = 0x00C8, /* Read DMA (with retries)*/
kATAcmdWriteDMA = 0x00CA, /* Write DMA (with retries)*/
kATAcmdMCAcknowledge = 0x00DB, /* Acknowledge media change - removable*/
kATAcmdDoorLock = 0x00DE, /* Door lock*/
kATAcmdDoorUnlock = 0x00DF, /* Door unlock*/
kATAcmdStandbyImmed = 0x00E0, /* Standby Immediate*/
kATAcmdIdleImmed = 0x00E1, /* Idle Immediate*/
kATAcmdStandby = 0x00E2, /* Standby*/
kATAcmdIdle = 0x00E3, /* Idle*/
kATAcmdReadBuffer = 0x00E4, /* Read sector buffer command */
kATAcmdCheckPowerMode = 0x00E5, /* Check power mode command <04/04/94>*/
kATAcmdSleep = 0x00E6, /* Sleep*/
kATAcmdWriteBuffer = 0x00E8, /* Write sector buffer command */
kATAcmdWriteSame = 0x00E9, /* Write same data to multiple sectors*/
kATAcmdDriveIdentify = 0x00EC, /* Identify Drive command */
kATAcmdMediaEject = 0x00ED, /* Media Eject*/
kATAcmdSetFeatures = 0x00EF /* Set Features*/
};
/* Set feature command opcodes*/
enum {
kATAEnableWriteCache = 0x02, /* Enable write cache*/
kATASetTransferMode = 0x03, /* Set transfer mode*/
kATASetPIOMode = 0x08, /* PIO Flow Control Tx Mode bit*/
kATAEnableECC = 0x88, /* ECC enable*/
kATAEnableRetry = 0x99, /* Retry enable*/
kATAEnableReadAhead = 0xAA /* Read look-ahead enable*/
};
/*
--------------------------------------------------------------------------------
enums for dealing with device IDs
*/
enum {
kATABusIDMask = 0x000000FF,
kATADeviceIDMask = 0x0000FF00,
kATADeviceIDClippingMask = 0x0000FFFF,
kMinBusID = 0x00000000,
kMaxBusID = 0x000000FE
};
enum {
kATAStartIterateDeviceID = 0xFFFF,
kATAEndIterateDeviceID = 0xFF
};
/*--------------------------------------------------------------------------------*/
/* Device Register Images (8 bytes) */
struct ataTaskFile {
UInt8 ataTFFeatures; /* <-> Error(R) or ataTFFeatures(W) register image */
UInt8 ataTFCount; /* <-> Sector count/remaining */
UInt8 ataTFSector; /* <-> Sector start/finish */
UInt8 ataTFReserved; /* reserved */
UInt16 ataTFCylinder; /* <-> ataTFCylinder (Big endian) */
UInt8 ataTFSDH; /* <-> ataTFSDH register image*/
UInt8 ataTFCommand; /* <-> Status(R) or Command(W) register image */
};
typedef struct ataTaskFile ataTaskFile;
/* ATA Manager Function Code Definition*/
enum {
kATAMgrNOP = 0x00, /* No Operation*/
kATAMgrExecIO = 0x01, /* Execute ATA I/O*/
kATAMgrBusInquiry = 0x03, /* Bus Inquiry*/
kATAMgrQRelease = 0x04, /* I/O Queue Release*/
kATAMgrAbort = 0x10, /* Abort command*/
kATAMgrBusReset = 0x11, /* Reset ATA bus*/
kATAMgrRegAccess = 0x12, /* Register Access*/
kATAMgrDriveIdentify = 0x13, /* Drive Identify <DP03/10/94>*/
kATAMgrDriverLoad = 0x82, /* Load driver from either Media, ROM, etc.*/
kATAMgrDriveRegister = 0x85, /* Register a driver <4/18/94>*/
kATAMgrFindDriverRefnum = 0x86, /* lookup a driver refnum <4/18/94>*/
kATAMgrRemoveDriverRefnum = 0x87, /* De-register a driver <4/18/94>*/
kATAMgrModifyEventMask = 0x88, /* Modify driver event mask*/
kATAMgrDriveEject = 0x89, /* Eject the drive <8/1/94>*/
kATAMgrGetDrvConfiguration = 0x8A, /* Get device configuration <8/6/94>*/
kATAMgrSetDrvConfiguration = 0x8B, /* Set device configuration <8/6/94>*/
kATAMgrGetLocationIcon = 0x8C, /* Get card location icon <SM4>*/
kATAMgrManagerInquiry = 0x90, /* Manager Inquiry*/
kATAMgrManagerInit = 0x91, /* Manager initialization*/
kATAMgrManagerShutdown = 0x92, /* Manager ShutDown*/
/* note: functions 0x93 to 0x97 are reserved*/
kATAMgrFindSpecialDriverRefnum = 0x98, /* lookup a driver refnum; driverloader,notify-all or ROM driver.*/
kATAMgrNextAvailable = 0x99
};
/* used in the ataDrvrFlags field for kATAMgrDriveRegister,kATAMgrRemoveDriverRefnum & kATAMgrFindSpecialDriverRefnum*/
enum {
kATANotifyAllDriver = 0, /* Notify-All driver*/
kATADriverLoader = 1, /* Driver loader driver */
kATAROMDriver = 2 /* ROM driver*/
};
/* 'ATAFlags' field of the PB header definition*/
enum {
bATAFlagUseConfigSpeed = 15, /* bit number of use default speed flag*/
bATAFlagByteSwap = 14, /* bit number of byte swap flag*/
bATAFlagIORead = 13, /* bit number of I/O read flag*/
bATAFlagIOWrite = 12, /* bit number of I/O write flag*/
bATAFlagImmediate = 11, /* bit number of immediate flag*/
bATAFlagQLock = 10, /* bit number of que lock on error*/
bATAFlagReserved1 = 9, /* reserved*/
bATAFlagUseScatterGather = 8, /* bit numbers of scatter gather*/
bATAFlagUseDMA = 7, /* bit number of use DMA flag*/
bATAFlagProtocolATAPI = 5, /* bit number of ATAPI protocol*/
bATAFlagReserved2 = 4, /* reserved*/
bATAFlagTFRead = 3, /* bit number of register update*/
bATAFlagLEDEnable = 0, /* bit number of LED enable*/
mATAFlagUseConfigSpeed = 1 << bATAFlagUseConfigSpeed,
mATAFlagByteSwap = 1 << bATAFlagByteSwap, /* Swap data bytes (read - after; write - before)*/
mATAFlagIORead = 1 << bATAFlagIORead, /* Read (in) operation*/
mATAFlagIOWrite = 1 << bATAFlagIOWrite, /* Write (out) operation*/
mATAFlagImmediate = 1 << bATAFlagImmediate, /* Head of Que; Immediate operation*/
mATAFlagQLock = 1 << bATAFlagQLock, /* Manager queue lock on error (freeze the queue)*/
mATAFlagUseScatterGather = 1 << bATAFlagUseScatterGather, /* Scatter gather enable*/
mATAFlagUseDMA = 1 << bATAFlagUseDMA,
mATAFlagProtocolATAPI = 1 << bATAFlagProtocolATAPI, /* ATAPI protocol indicator*/
mATAFlagTFRead = 1 << bATAFlagTFRead, /* update reg block request upon detection of an error*/
mATAFlagLEDEnable = 1 << bATAFlagLEDEnable /* socket LED enable*/
};
/* These are legacy ATAFlags definitions, which will go away in the future*/
enum {
bATAFlagScatterGather1 = bATAFlagReserved1, /* 9*/
bATAFlagScatterGather0 = bATAFlagUseScatterGather, /* 8*/
bATAFlagProtocol1 = bATAFlagProtocolATAPI, /* 5*/
bATAFlagProtocol0 = bATAFlagReserved2, /* 4*/
mATAFlagScatterGather1 = 1 << bATAFlagScatterGather1,
mATAFlagScatterGather0 = mATAFlagUseScatterGather,
mATAFlagScatterGathers = mATAFlagScatterGather1 + mATAFlagScatterGather0,
mATAFlagProtocol1 = mATAFlagProtocolATAPI,
mATAFlagProtocol0 = 1 << bATAFlagProtocol0,
mATAFlagProtocols = mATAFlagProtocol1 + mATAFlagProtocol0
};
typedef CALLBACK_API( void , ATACallbackProcPtr )(void *ataPB);
typedef STACK_UPP_TYPE(ATACallbackProcPtr) ATACallbackUPP;
if OPAQUE_UPP_TYPES
if CALL_NOT_IN_CARBON
EXTERN_API(ATACallbackUPP)
NewATACallbackUPP (ATACallbackProcPtr userRoutine);
EXTERN_API(void)
DisposeATACallbackUPP (ATACallbackUPP userUPP);
EXTERN_API(void)
InvokeATACallbackUPP (void * ataPB,
ATACallbackUPP userUPP);
endif /* CALL_NOT_IN_CARBON */
else
enum { uppATACallbackProcInfo = 0x000000C0 }; /* pascal no_return_value Func(4_bytes) */
#define NewATACallbackUPP(userRoutine) (ATACallbackUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppATACallbackProcInfo, GetCurrentArchitecture())
#define DisposeATACallbackUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define InvokeATACallbackUPP(ataPB, userUPP) CALL_ONE_PARAMETER_UPP((userUPP), uppATACallbackProcInfo, (ataPB))
endif
/* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
define NewATACallbackProc(userRoutine) NewATACallbackUPP(userRoutine)
define CallATACallbackProc(userRoutine, ataPB) InvokeATACallbackUPP(ataPB, userRoutine)
/*
structure which defines the ATA bus/device ID, part of the Device 0/1 Software Guide
see <http://developer.apple.com/techpubs/hardware/Developer_Notes/System_Software/ATA_Device_Zero_One.pdf>
p 19 : Although ataPBDeviceID remains defined as a 32-bit number, drivers and applications
can typecast it to the ataDeviceID structure to determine the bus number and device number
for a specific ATA or ATAPI device
*/
struct ataDeviceID {
UInt16 Reserved; /* The upperword is reserved (0)*/
UInt8 devNum; /* device number (0 or 1)*/
UInt8 busNum; /* bus number*/
};
typedef struct ataDeviceID ataDeviceID;
struct ataPBHeader {
/* Start of cloned common header ataPBHdr */
struct ataPBHeader * ataPBLink; /* a pointer to the next entry in the queue */
UInt16 ataPBQType; /* type byte for safety check*/
UInt8 ataPBVers; /* -->: parameter block version number*/
UInt8 ataPBReserved; /* Reserved */
Ptr ataPBReserved2; /* Reserved */
ATACallbackUPP ataPBCallbackPtr; /* -->: Completion Routine Pointer*/
OSErr ataPBResult; /* <--: Returned result */
UInt8 ataPBFunctionCode; /* -->: Manager Function Code */
UInt8 ataPBIOSpeed; /* -->: I/O Timing Class */
UInt16 ataPBFlags; /* -->: Various control options */
SInt16 ataPBReserved3; /* Reserved */
UInt32 ataPBDeviceID; /* -->: Device identifier (see ataDeviceID) */
UInt32 ataPBTimeOut; /* -->: Transaction timeout value in msec */
Ptr ataPBClientPtr1; /* Client's storage Ptr 1 */
Ptr ataPBClientPtr2; /* Client's storage Ptr 2 */
UInt16 ataPBState; /* Reserved for Manager; Initialize to 0 */
UInt16 ataPBSemaphores; /* Used internally by the manager*/
SInt32 ataPBReserved4; /* Reserved */
/* End of cloned common header ataPBHdr*/
};
typedef struct ataPBHeader ataPBHeader;
/* data request entry structure (16 bytes)*/
struct IOBlock {
UInt8 * ataPBBuffer; /* -->: Data buffer pointer*/
UInt32 ataPBByteCount; /* -->: Data transfer length in bytes*/
};
typedef struct IOBlock IOBlock;
/*
For ATAPI devices the ExtendedPB field is a pointer to the Command Packet
record which exists of an array of words structured as follows... <06/15/94>
*/
struct ATAPICmdPacket {
SInt16 atapiPacketSize; /* Size of command packet in bytes <06/15/94>*/
SInt16 atapiCommandByte[8]; /* The command packet itself <06/15/94>*/
};
typedef struct ATAPICmdPacket ATAPICmdPacket;
/* Manager parameter block structure (96 bytes)*/
struct ataIOPB {
/* Start of cloned common header ataPBHdr*/
ataPBHeader * ataPBLink; /* a pointer to the next entry in the queue */
UInt16 ataPBQType; /* type byte for safety check*/
UInt8 ataPBVers; /* -->: parameter block version number; Must be 0x01*/
UInt8 ataPBReserved; /* Reserved */
Ptr ataPBReserved2; /* Reserved */
ATACallbackUPP ataPBCallbackPtr; /* -->: Completion Routine Pointer*/
OSErr ataPBResult; /* <--: Returned result */
UInt8 ataPBFunctionCode; /* -->: Manager Function Code */
UInt8 ataPBIOSpeed; /* -->: I/O Timing Class */
UInt16 ataPBFlags; /* -->: Various control options */
SInt16 ataPBReserved3; /* Reserved */
UInt32 ataPBDeviceID; /* -->: Device identifier (see ataDeviceID) */
UInt32 ataPBTimeOut; /* -->: Transaction timeout value in msec */
Ptr ataPBClientPtr1; /* Client's storage Ptr 1 */
Ptr ataPBClientPtr2; /* Client's storage Ptr 2 */
UInt16 ataPBState; /* Reserved for Manager; Initialize to 0 */
UInt16 ataPBSemaphores; /* Used internally by the manager*/
SInt32 ataPBReserved4; /* Reserved */
/* End of cloned common header ataPBHdr*/
SInt8 ataPBStatusRegister; /* <--: Last ATA status image*/
SInt8 ataPBErrorRegister; /* <--: Last ATA error image-valid if lsb of Status set*/
SInt16 ataPBReserved5; /* Reserved*/
UInt32 ataPBLogicalBlockSize; /* -->: Blind transfer size per interrupt (Logical block size)*/
UInt8 * ataPBBuffer; /* -->: Data buffer pointer*/
UInt32 ataPBByteCount; /* -->: Data transfer length in bytes*/
UInt32 ataPBActualTxCount; /* <--: Actual transfer count*/
UInt32 ataPBReserved6; /* Reserved*/
ataTaskFile ataPBTaskFile; /* <->: Device register images*/
ATAPICmdPacket * ataPBPacketPtr; /* -->: ATAPI packet command block pointer (valid with ATAPI bit set)*/
SInt16 ataPBReserved7[6]; /* Reserved for future expansion*/
};
typedef struct ataIOPB ataIOPB;
/* Parameter block structure for bus and Manager inquiry command*/
/* Manager parameter block structure*/
struct ataBusInquiry {
/* Start of cloned common header ataPBHdr*/
ataPBHeader * ataPBLink; /* a pointer to the next entry in the queue */
UInt16 ataPBQType; /* type byte for safety check*/
UInt8 ataPBVers; /* -->: parameter block version number; Must be 0x01*/
UInt8 ataPBReserved; /* Reserved */
Ptr ataPBReserved2; /* Reserved */
ATACallbackUPP ataPBCallbackPtr; /* -->: Completion Routine Pointer*/
OSErr ataPBResult; /* <--: Returned result */
UInt8 ataPBFunctionCode; /* -->: Manager Function Code */
UInt8 ataPBIOSpeed; /* -->: I/O Timing Class */
UInt16 ataPBFlags; /* -->: Various control options */
SInt16 ataPBReserved3; /* Reserved */
UInt32 ataPBDeviceID; /* -->: Device identifier (see ataDeviceID) */
UInt32 ataPBTimeOut; /* -->: Transaction timeout value in msec */
Ptr ataPBClientPtr1; /* Client's storage Ptr 1 */
Ptr ataPBClientPtr2; /* Client's storage Ptr 2 */
UInt16 ataPBState; /* Reserved for Manager; Initialize to 0 */
UInt16 ataPBSemaphores; /* Used internally by the manager*/
SInt32 ataPBReserved4; /* Reserved */
/* End of cloned common header ataPBHdr*/
UInt16 ataEngineCount; /* <--: TBD; zero for now*/
UInt16 ataReserved1; /* Reserved*/
UInt32 ataDataTypes; /* <--: TBD; zero for now*/
UInt16 ataIOpbSize; /* <--: Size of ATA IO PB*/
UInt16 ataMaxIOpbSize; /* <--: TBD; zero for now*/
UInt32 ataFeatureFlags; /* <--: TBD*/
UInt8 ataVersionNum; /* <--: Version number for the HBA*/
UInt8 ataHBAInquiry; /* <--: TBD; zero for now*/
UInt16 ataReserved2; /* Reserved*/
UInt32 ataHBAPrivPtr; /* <--: Ptr to HBA private data area*/
UInt32 ataHBAPrivSize; /* <--: Size of HBA private data area*/
UInt32 ataAsyncFlags; /* <--: Event capability for callback*/
UInt8 ataPIOModes; /* <--: PIO modes supported (bit-significant)*/
UInt8 ataUltraDMAModes; /* <--: Ultra DMA modes supported (b-sig)*/
UInt8 ataSingleDMAModes; /* <--: Single Word DMA modes supported (b-sig) */
UInt8 ataMultiDMAModes; /* <--: Multiword DMA modes supported (b-sig)*/
UInt32 ataReserved4[4]; /* Reserved*/
SInt8 ataReserved5[16]; /* TBD*/
SInt8 ataHBAVendor[16]; /* <--: Vendor ID of the HBA*/
SInt8 ataContrlFamily[16]; /* <--: Family of ATA Controller*/
SInt8 ataContrlType[16]; /* <--: Model number of controller*/
SInt8 ataXPTversion[4]; /* <--: version number of XPT*/
SInt8 ataReserved6[4]; /* Reserved*/
NumVersion ataHBAversion; /* <--: version number of HBA*/
UInt8 ataHBAslotType; /* <--: type of slot*/
UInt8 ataHBAslotNum; /* <--: slot number of the HBA*/
UInt16 ataReserved7; /* Reserved*/
UInt32 ataReserved8; /* Reserved*/
};
typedef struct ataBusInquiry ataBusInquiry;
/* Manager parameter block structure*/
struct ataMgrInquiry {
/* Start of cloned common header ataPBHdr*/
ataPBHeader * ataPBLink; /* a pointer to the next entry in the queue */
UInt16 ataPBQType; /* type byte for safety check*/
UInt8 ataPBVers; /* -->: parameter block version number; Must be 0x01*/
UInt8 ataPBReserved; /* Reserved */
Ptr ataPBReserved2; /* Reserved */
ATACallbackUPP ataPBCallbackPtr; /* -->: Completion Routine Pointer*/
OSErr ataPBResult; /* <--: Returned result */
UInt8 ataPBFunctionCode; /* -->: Manager Function Code */
UInt8 ataPBIOSpeed; /* -->: I/O Timing Class */
UInt16 ataPBFlags; /* -->: Various control options */
SInt16 ataPBReserved3; /* Reserved */
UInt32 ataPBDeviceID; /* -->: Device identifier (see ataDeviceID) */
UInt32 ataPBTimeOut; /* -->: Transaction timeout value in msec */
Ptr ataPBClientPtr1; /* Client's storage Ptr 1 */
Ptr ataPBClientPtr2; /* Client's storage Ptr 2 */
UInt16 ataPBState; /* Reserved for Manager; Initialize to 0 */
UInt16 ataPBSemaphores; /* Used internally by the manager*/
SInt32 ataPBReserved4; /* Reserved */
/* End of cloned common header ataPBHdr*/
NumVersion ataMgrVersion; /* Manager Version information*/
UInt8 ataMgrPBVers; /* <--: Manager PB version number supported*/
UInt8 Reserved1; /* Reserved*/
UInt16 ataBusCnt; /* <--: Number of ATA buses in the system*/
UInt16 ataDevCnt; /* <--: Total number of ATA devices detected*/
UInt8 ataPioModes; /* <--: Maximum Programmed I/O speed mode supported*/
UInt8 Reserved2; /* Reserved*/
UInt16 ataIOClkResolution; /* <--: IO Clock resolution in nsec (Not supported)*/
UInt8 ataSingleDMAModes; /* <--: Single Word DMA modes supported */
UInt8 ataMultiDMAModes; /* <--: Multiword DMA modes supported*/
SInt16 Reserved[16]; /* Reserved for future expansion*/
};
typedef struct ataMgrInquiry ataMgrInquiry;
/* Parameter block structure for Abort command*/
/* Manager parameter block structure*/
struct ataAbort {
/* Start of cloned common header ataPBHdr*/
ataPBHeader * ataPBLink; /* a pointer to the next entry in the queue */
UInt16 ataPBQType; /* type byte for safety check*/
UInt8 ataPBVers; /* -->: parameter block version number; Must be 0x01*/
UInt8 ataPBReserved; /* Reserved */
Ptr ataPBReserved2; /* Reserved */
ATACallbackUPP ataPBCallbackPtr; /* -->: Completion Routine Pointer*/
OSErr ataPBResult; /* <--: Returned result */
UInt8 ataPBFunctionCode; /* -->: Manager Function Code */
UInt8 ataPBIOSpeed; /* -->: I/O Timing Class */
UInt16 ataPBFlags; /* -->: Various control options */
SInt16 ataPBReserved3; /* Reserved */
UInt32 ataPBDeviceID; /* -->: Device identifier (see ataDeviceID) */
UInt32 ataPBTimeOut; /* -->: Transaction timeout value in msec */
Ptr ataPBClientPtr1; /* Client's storage Ptr 1 */
Ptr ataPBClientPtr2; /* Client's storage Ptr 2 */
UInt16 ataPBState; /* Reserved for Manager; Initialize to 0 */
UInt16 ataPBSemaphores; /* Used internally by the manager*/
SInt32 ataPBReserved4; /* Reserved */
/* End of cloned common header ataPBHdr*/
ataIOPB * ataAbortPB; /* -->: Parameter block to be aborted*/
SInt16 Reserved[22]; /* Reserved for future expansion*/
};
typedef struct ataAbort ataAbort;
/* Manager parameter block structure*/
struct ATAEventRec {
UInt16 ataEventCode; /* --> ATA event code*/
UInt16 ataPhysicalID; /* --> Physical drive reference*/
SInt32 ataDrvrContext; /* Context pointer saved by driver*/
UInt32 ataMarker; /* Always 'LOAD'*/
UInt32 ataEventRecVersion; /* Version number of this data structure*/
UInt32 ataDeviceType; /* Device type on bus (valid for load driver only)*/
UInt16 ataRefNum; /* RefNum of driver (valid for remove driver only)*/
};
typedef struct ATAEventRec ATAEventRec;
typedef ATAEventRec * ATAEventRecPtr;
typedef CALLBACK_API( SInt16 , ATAClientProcPtr )(ATAEventRecPtr ataERPtr);
typedef STACK_UPP_TYPE(ATAClientProcPtr) ATAClientUPP;
if OPAQUE_UPP_TYPES
if CALL_NOT_IN_CARBON
EXTERN_API(ATAClientUPP)
NewATAClientUPP (ATAClientProcPtr userRoutine);
EXTERN_API(void)
DisposeATAClientUPP (ATAClientUPP userUPP);
EXTERN_API(SInt16)
InvokeATAClientUPP (ATAEventRecPtr ataERPtr,
ATAClientUPP userUPP);
endif /* CALL_NOT_IN_CARBON */
else
enum { uppATAClientProcInfo = 0x000000E0 }; /* pascal 2_bytes Func(4_bytes) */
#define NewATAClientUPP(userRoutine) (ATAClientUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppATAClientProcInfo, GetCurrentArchitecture())
#define DisposeATAClientUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define InvokeATAClientUPP(ataERPtr, userUPP) (SInt16)CALL_ONE_PARAMETER_UPP((userUPP), uppATAClientProcInfo, (ataERPtr))
endif
/* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
define NewATAClientProc(userRoutine) NewATAClientUPP(userRoutine)
define CallATAClientProc(userRoutine, ataERPtr) InvokeATAClientUPP(ataERPtr, userRoutine)
/* Parameter block structure for Driver Register command*/
/* Manager parameter block structure*/
struct ataDrvrRegister {
/* Start of cloned common header ataPBHdr*/
ataPBHeader * ataPBLink; /* a pointer to the next entry in the queue */
UInt16 ataPBQType; /* type byte for safety check*/
UInt8 ataPBVers; /* -->: parameter block version number; Must be 0x01*/
UInt8 ataPBReserved; /* Reserved */
Ptr ataPBReserved2; /* Reserved */
ATACallbackUPP ataPBCallbackPtr; /* -->: Completion Routine Pointer*/
OSErr ataPBResult; /* <--: Returned result */
UInt8 ataPBFunctionCode; /* -->: Manager Function Code */
UInt8 ataPBIOSpeed; /* -->: I/O Timing Class */
UInt16 ataPBFlags; /* -->: Various control options */
SInt16 ataPBReserved3; /* Reserved */
UInt32 ataPBDeviceID; /* -->: Device identifier (see ataDeviceID) */
UInt32 ataPBTimeOut; /* -->: Transaction timeout value in msec */
Ptr ataPBClientPtr1; /* Client's storage Ptr 1 */
Ptr ataPBClientPtr2; /* Client's storage Ptr 2 */
UInt16 ataPBState; /* Reserved for Manager; Initialize to 0 */
UInt16 ataPBSemaphores; /* Used internally by the manager*/
SInt32 ataPBReserved4; /* Reserved */
/* End of cloned common header ataPBHdr*/
SInt16 ataDrvrRefNum; /* <->: Driver reference number*/
UInt16 ataDrvrFlags; /* -->: 1 = loader driver if ataPBDeviceID = -1 {PB2}*/
UInt16 ataDeviceNextID; /* <--: used to specified the next drive ID*/
SInt16 ataDrvrLoadPriv; /* Driver loader private storage*/
ATAClientUPP ataEventHandler; /* <->: Pointer to ATA event callback routine {PB2}*/
SInt32 ataDrvrContext; /* <->: Context data saved by driver {PB2}*/
SInt32 ataEventMask; /* <->: Set to 1 for notification of event {PB2}*/
SInt16 Reserved[14]; /* Reserved for future expansion - from [21] {PB2}*/
};
typedef struct ataDrvrRegister ataDrvrRegister;
/* Parameter block structure for Modify driver event mask command*/
struct ataModifyEventMask {
/* Start of cloned common header ataPBHdr*/
ataPBHeader * ataPBLink; /* a pointer to the next entry in the queue */
UInt16 ataPBQType; /* type byte for safety check*/
UInt8 ataPBVers; /* -->: parameter block version number; Must be 0x01*/
UInt8 ataPBReserved; /* Reserved */
Ptr ataPBReserved2; /* Reserved */
ATACallbackUPP ataPBCallbackPtr; /* -->: Completion Routine Pointer*/
OSErr ataPBResult; /* <--: Returned result */
UInt8 ataPBFunctionCode; /* -->: Manager Function Code */
UInt8 ataPBIOSpeed; /* -->: I/O Timing Class */
UInt16 ataPBFlags; /* -->: Various control options */
SInt16 ataPBReserved3; /* Reserved */
UInt32 ataPBDeviceID; /* -->: Device identifier (see ataDeviceID) */
UInt32 ataPBTimeOut; /* -->: Transaction timeout value in msec */
Ptr ataPBClientPtr1; /* Client's storage Ptr 1 */
Ptr ataPBClientPtr2; /* Client's storage Ptr 2 */
UInt16 ataPBState; /* Reserved for Manager; Initialize to 0 */
UInt16 ataPBSemaphores; /* Used internally by the manager*/
SInt32 ataPBReserved4; /* Reserved */
/* End of cloned common header ataPBHdr*/
SInt32 ataModifiedEventMask; /* -->: new event mask value*/
SInt16 Reserved[22]; /* Reserved for future expansion*/
};
typedef struct ataModifyEventMask ataModifyEventMask;
/* 'ataRegMask' field of the ataRegAccess definition*/
enum {
bATAAltSDevCValid = 14, /* bit number of alternate status/device cntrl valid bit*/
bATAStatusCmdValid = 7, /* bit number of status/command valid bit*/
bATASDHValid = 6, /* bit number of ataTFSDH valid bit*/
bATACylinderHiValid = 5, /* bit number of cylinder high valid bit*/
bATACylinderLoValid = 4, /* bit number of cylinder low valid bit*/
bATASectorNumValid = 3, /* bit number of sector number valid bit*/
bATASectorCntValid = 2, /* bit number of sector count valid bit*/
bATAErrFeaturesValid = 1, /* bit number of error/features valid bit*/
bATADataValid = 0, /* bit number of data valid bit*/
mATAAltSDevCValid = 1 << bATAAltSDevCValid, /* alternate status/device control valid*/
mATAStatusCmdValid = 1 << bATAStatusCmdValid, /* status/command valid*/
mATASDHValid = 1 << bATASDHValid, /* ataTFSDH valid*/
mATACylinderHiValid = 1 << bATACylinderHiValid, /* cylinder high valid*/
mATACylinderLoValid = 1 << bATACylinderLoValid, /* cylinder low valid*/
mATASectorNumValid = 1 << bATASectorNumValid, /* sector number valid*/
mATASectorCntValid = 1 << bATASectorCntValid, /* sector count valid*/
mATAErrFeaturesValid = 1 << bATAErrFeaturesValid, /* error/features valid*/
mATADataValid = 1 << bATADataValid /* data valid*/
};
/* Parameter block structure for device register access command*/
union ataRegValueUnion {
UInt8 ataByteRegValue; /* <->: Byte register value read or to be written*/
UInt16 ataWordRegValue; /* <->: Word register value read or to be written*/
};
typedef union ataRegValueUnion ataRegValueUnion;
/* Manager parameter block structure*/
struct ataRegAccess {
/* Start of cloned common header ataPBHdr*/
ataPBHeader * ataPBLink; /* a pointer to the next entry in the queue */
UInt16 ataPBQType; /* type byte for safety check*/
UInt8 ataPBVers; /* -->: parameter block version number; Must be 0x01*/
UInt8 ataPBReserved; /* Reserved */
Ptr ataPBReserved2; /* Reserved */
ATACallbackUPP ataPBCallbackPtr; /* -->: Completion Routine Pointer*/
OSErr ataPBResult; /* <--: Returned result */
UInt8 ataPBFunctionCode; /* -->: Manager Function Code */
UInt8 ataPBIOSpeed; /* -->: I/O Timing Class */
UInt16 ataPBFlags; /* -->: Various control options */
SInt16 ataPBReserved3; /* Reserved */
UInt32 ataPBDeviceID; /* -->: Device identifier (see ataDeviceID) */
UInt32 ataPBTimeOut; /* -->: Transaction timeout value in msec */
Ptr ataPBClientPtr1; /* Client's storage Ptr 1 */
Ptr ataPBClientPtr2; /* Client's storage Ptr 2 */
UInt16 ataPBState; /* Reserved for Manager; Initialize to 0 */
UInt16 ataPBSemaphores; /* Used internally by the manager*/
SInt32 ataPBReserved4; /* Reserved */
/* End of cloned common header ataPBHdr*/
UInt16 ataRegSelect; /* -->: Device Register Selector*/
/* DataReg 0 */
/* ErrorReg(R) or FeaturesReg(W) 1*/
/* SecCntReg 2*/
/* SecNumReg 3*/
/* CylLoReg 4*/
/* CylHiReg 5*/
/* SDHReg 6*/
/* StatusReg(R) or CmdReg(W) 7*/
/* AltStatus(R) or DevCntr(W) 0E*/
ataRegValueUnion ataRegValue;
/* Following fields are valid only if ataRegSelect = 0xFFFF*/
UInt16 ataRegMask; /* -->: mask for register(s) to update*/
/* bit 0 : data register valid*/
/* bit 1 : error/feaures register valid*/
/* bit 2 : sector count register valid*/
/* bit 3 : sector number register valid*/
/* bit 4 : cylinder low register valid*/
/* bit 5 : cylinder high register valid*/
/* bit 6 : ataTFSDH register valid*/
/* bit 7 : status/command register valid*/
/* bits 8 - 13 : reserved (set to 0)*/
/* bit 14: alternate status / device control reg valid*/
/* bit 15: reserved (set to 0)*/
ataTaskFile ataRegisterImage; /* <->: register images*/
UInt8 ataAltSDevCReg; /* <->: Alternate status(R) or Device Control(W) register image*/
UInt8 Reserved3; /* Reserved*/
SInt16 Reserved[16]; /* Reserved for future expansion*/
};
typedef struct ataRegAccess ataRegAccess;
/* Manager parameter block structure <DP03/10/94>*/
struct ataIdentify {
/* Start of cloned common header ataPBHdr*/
ataPBHeader * ataPBLink; /* a pointer to the next entry in the queue */
UInt16 ataPBQType; /* type byte for safety check*/
UInt8 ataPBVers; /* -->: parameter block version number; Must be 0x01*/
UInt8 ataPBReserved; /* Reserved */
Ptr ataPBReserved2; /* Reserved */
ATACallbackUPP ataPBCallbackPtr; /* -->: Completion Routine Pointer*/
OSErr ataPBResult; /* <--: Returned result */
UInt8 ataPBFunctionCode; /* -->: Manager Function Code */
UInt8 ataPBIOSpeed; /* -->: I/O Timing Class */
UInt16 ataPBFlags; /* -->: Various control options */
SInt16 ataPBReserved3; /* Reserved */
UInt32 ataPBDeviceID; /* -->: Device identifier (see ataDeviceID) */
UInt32 ataPBTimeOut; /* -->: Transaction timeout value in msec */
Ptr ataPBClientPtr1; /* Client's storage Ptr 1 */
Ptr ataPBClientPtr2; /* Client's storage Ptr 2 */
UInt16 ataPBState; /* Reserved for Manager; Initialize to 0 */
UInt16 ataPBSemaphores; /* Used internally by the manager*/
SInt32 ataPBReserved4; /* Reserved */
/* End of cloned common header ataPBHdr*/
UInt16 Reserved1[4]; /* Reserved. These are used internally by the Manager*/
UInt8 * ataPBBuffer; /* Buffer for the identify data (512 bytes)*/
UInt16 Reserved2[12]; /* Used internally by the ATA Manager*/
SInt16 Reserved3[6]; /* Reserved for future expansion*/
};
typedef struct ataIdentify ataIdentify;
/* 'ataConfigSetting' field of the Get/Set Device Configuration definition <8/6/94>*/
enum {
ATAPIpacketDRQ_bit = 6, /* bit number of ATAPI command packet DRQ option*/
ATAPIpacketDRQ = 1 << ATAPIpacketDRQ_bit /* ATAPI command packet DRQ option*/
};
/* atapcValid field definition*/
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
};
/* Device physical type & socket type indicator definition*/
enum {
kATADeviceUnknown = 0x00, /* no device or type undetermined*/
kATADeviceATA = 0x01, /* traditional ATA protocol device <7/29/94>*/
kATADeviceATAPI = 0x02, /* ATAPI protocol device <7/29/94>*/
kATADeviceReserved = 0x03 /* reserved by Apple (was PCMCIA)*/
};
enum {
kATASocketInternal = 0x01, /* Internal ATA socket*/
kATASocketMB = 0x02, /* Media Bay socket*/
kATASocketPCMCIA = 0x03 /* PCMCIA socket*/
};
/* reserved words at the end of the devConfig structure*/
enum {
kATAConfigReserved = 5 /* number of reserved words at the end*/
};
/*
Get/Set Device Configuration parameter block structure <8/6/94>
Manager parameter block structure
*/
struct ataDevConfiguration {
/* Start of cloned common header ataPBHdr*/
ataPBHeader * ataPBLink; /* a pointer to the next entry in the queue */
UInt16 ataPBQType; /* type byte for safety check*/
UInt8 ataPBVers; /* -->: parameter block version number; Must be 0x01*/
UInt8 ataPBReserved; /* Reserved */
Ptr ataPBReserved2; /* Reserved */
ATACallbackUPP ataPBCallbackPtr; /* -->: Completion Routine Pointer*/
OSErr ataPBResult; /* <--: Returned result */
UInt8 ataPBFunctionCode; /* -->: Manager Function Code */
UInt8 ataPBIOSpeed; /* -->: I/O Timing Class */
UInt16 ataPBFlags; /* -->: Various control options */
SInt16 ataPBReserved3; /* Reserved */
UInt32 ataPBDeviceID; /* -->: Device identifier (see ataDeviceID) */
UInt32 ataPBTimeOut; /* -->: Transaction timeout value in msec */
Ptr ataPBClientPtr1; /* Client's storage Ptr 1 */
Ptr ataPBClientPtr2; /* Client's storage Ptr 2 */
UInt16 ataPBState; /* Reserved for Manager; Initialize to 0 */
UInt16 ataPBSemaphores; /* Used internally by the manager*/
SInt32 ataPBReserved4; /* Reserved */
/* End of cloned common header ataPBHdr*/
SInt32 ataConfigSetting; /* <->: Configuration setting*/
/* Bits 3 - 0: Reserved*/
/* Bit 4: Reserved (allowLBAAccess)*/
/* Bit 5: Reserved (allowRWMultiple)*/
/* Bit 6: ATAPIpacketDRQ*/
/* 1 = Check for Interrupt DRQ on ATAPI command packet DRQ*/
/* 0 = Default: Check only for the assertion of command packet DRQ*/
/* Bits 31 - 7: Reserved*/
UInt8 ataPIOSpeedMode; /* <->: Device access speed in PIO Mode*/
UInt8 Reserved3; /* Reserved to force word alignment*/
UInt16 atapcValid; /* <->: Set when pcXXX fields are valid (atapcAccessMode - atapcConfigIndex)*/
/* bit 0 - atapcAccessMode field valid, when set*/
/* bit 1 - atapcVcc field valid, when set*/
/* bit 2 - atapcVpp1 field valid, when set*/
/* bit 3 - atapcVpp2 field valid, when set*/
/* bit 4 - atapcStatus field valid, when set*/
/* bit 5 - atapcPin field valid, when set*/
/* bit 6 - atapcCopy field valid, when set*/
/* bit 7 - atapcConfigIndex field valid, when set*/
/* bits 14-8 - Reserved*/
/* bit 15 - device lock/unlock request (write only)*/
UInt16 ataRWMultipleCount; /* Reserved for future (not supported yet)*/
UInt16 ataSectorsPerCylinder; /* Reserved for future (not supported yet)*/
UInt16 ataHeads; /* Reserved for future (not supported yet)*/
UInt16 ataSectorsPerTrack; /* Reserved for future (not supported yet)*/
UInt16 ataSocketNumber; /* <--: Socket number used by the CardServices*/
/* 0xFF = socket number invalid (Not a CardServices device)*/
/* other = socket number of the device*/
UInt8 ataSocketType; /* <--: Specifies the socket type (get config only)*/
/* 00 = Unknown socket*/
/* 01 = Internal ATA bus*/
/* 02 = Media Bay*/
/* 03 = PCMCIA*/
UInt8 ataDeviceType; /* <--: Specifies the device type (get config only)*/
/* 00 = Unknown device*/
/* 01 = standard ATA device (HD)*/
/* 02 = ATAPI device*/
/* 03 = PCMCIA ATA device*/
UInt8 atapcAccessMode; /* <->: Access mode: Memory vs. I/O (PCMCIA only)*/
UInt8 atapcVcc; /* <->: Voltage in tenths of a volt (PCMCIA only)*/
UInt8 atapcVpp1; /* <->: Voltage in tenths of a volt (PCMCIA only)*/
UInt8 atapcVpp2; /* <->: Voltage in tenths of a volt (PCMCIA only)*/
UInt8 atapcStatus; /* <->: Card Status register setting (PCMCIA only)*/
UInt8 atapcPin; /* <->: Card Pin register setting (PCMCIA only)*/
UInt8 atapcCopy; /* <->: Card Socket/Copy register setting (PCMCIA only)*/
UInt8 atapcConfigIndex; /* <->: Card Option register setting (PCMCIA only)*/
UInt8 ataSingleDMASpeed; /* <->: Single Word DMA Timing Class*/
UInt8 ataMultiDMASpeed; /* <->: Multiple Word DMA Timing Class*/
UInt16 ataPIOCycleTime; /* <->:Cycle time for PIO mode*/
UInt16 ataMultiCycleTime; /* <->:Cycle time for Multiword DMA mode*/
UInt8 ataUltraDMASpeed; /* <-> Ultra DMA timing class*/
UInt8 reserved2; /* reserved*/
UInt16 ataUltraCycleTime; /* <-> Cycle time for Ultra DMA mode*/
UInt16 Reserved1[5]; /* Reserved for future*/
};
typedef struct ataDevConfiguration ataDevConfiguration;
/* Get Card Location Icon/Text <SM4>*/
enum {
kATALargeIconHFS = 0x0001, /* Large B&W icon with mask (HFS)*/
kATALargeIconProDOS = 0x0081 /* Large B&W icon with mask (ProDOS)*/
};
/* Manager parameter block structure*/
struct ataLocationData {
/* Start of cloned common header ataPBHdr*/
ataPBHeader * ataPBLink; /* a pointer to the next entry in the queue */
UInt16 ataPBQType; /* type byte for safety check*/
UInt8 ataPBVers; /* -->: parameter block version number; Must be 0x01*/
UInt8 ataPBReserved; /* Reserved */
Ptr ataPBReserved2; /* Reserved */
ATACallbackUPP ataPBCallbackPtr; /* -->: Completion Routine Pointer*/
OSErr ataPBResult; /* <--: Returned result */
UInt8 ataPBFunctionCode; /* -->: Manager Function Code */
UInt8 ataPBIOSpeed; /* -->: I/O Timing Class */
UInt16 ataPBFlags; /* -->: Various control options */
SInt16 ataPBReserved3; /* Reserved */
UInt32 ataPBDeviceID; /* -->: Device identifier (see ataDeviceID) */
UInt32 ataPBTimeOut; /* -->: Transaction timeout value in msec */
Ptr ataPBClientPtr1; /* Client's storage Ptr 1 */
Ptr ataPBClientPtr2; /* Client's storage Ptr 2 */
UInt16 ataPBState; /* Reserved for Manager; Initialize to 0 */
UInt16 ataPBSemaphores; /* Used internally by the manager*/
SInt32 ataPBReserved4; /* Reserved */
/* End of cloned common header ataPBHdr*/
SInt16 ataIconType; /* -->: icon type specifier*/
/* 1 = Large B&W icon with mask (256 bytes)*/
/* 0x81 = Same as 1, but ProDOS icon*/
SInt16 ataIconReserved; /* Reserved to be longword aligned*/
SInt8 * ataLocationIconPtr; /* -->: Icon Data buffer pointer*/
SInt8 * ataLocationStringPtr; /* -->: Icon String buffer pointer*/
UInt16 Reserved1[18]; /* Reserved for future*/
};
typedef struct ataLocationData ataLocationData;
/* ataOSType available*/
enum {
kATAddTypeMacOS = 0x0001 /* Blue Mac O/S ddType value*/
};
/* The parameter block definition for all other ATA Manager functions.*/
struct ataGeneric {
/* Start of cloned common header ataPBHdr*/
ataPBHeader * ataPBLink; /* a pointer to the next entry in the queue */
UInt16 ataPBQType; /* type byte for safety check*/
UInt8 ataPBVers; /* -->: parameter block version number; Must be 0x01*/
UInt8 ataPBReserved; /* Reserved */
Ptr ataPBReserved2; /* Reserved */
ATACallbackUPP ataPBCallbackPtr; /* -->: Completion Routine Pointer*/
OSErr ataPBResult; /* <--: Returned result */
UInt8 ataPBFunctionCode; /* -->: Manager Function Code */
UInt8 ataPBIOSpeed; /* -->: I/O Timing Class */
UInt16 ataPBFlags; /* -->: Various control options */
SInt16 ataPBReserved3; /* Reserved */
UInt32 ataPBDeviceID; /* -->: Device identifier (see ataDeviceID) */
UInt32 ataPBTimeOut; /* -->: Transaction timeout value in msec */
Ptr ataPBClientPtr1; /* Client's storage Ptr 1 */
Ptr ataPBClientPtr2; /* Client's storage Ptr 2 */
UInt16 ataPBState; /* Reserved for Manager; Initialize to 0 */
UInt16 ataPBSemaphores; /* Used internally by the manager*/
SInt32 ataPBReserved4; /* Reserved */
/* End of cloned common header ataPBHdr*/
UInt16 Reserved[24]; /* Reserved for future*/
};
typedef struct ataGeneric ataGeneric;
union ataPB {
ataIOPB ataIOParamBlock; /* parameter block for I/O*/
ataBusInquiry ataBIParamBlock; /* parameter block for bus inquiry*/
ataMgrInquiry ataMIParamBlock; /* parameter block for Manager inquiry*/
ataAbort ataAbortParamBlock; /* parameter block for abort*/
ataDrvrRegister ataDRParamBlock; /* parameter block for driver register*/
ataModifyEventMask ataMEParamBlock; /* parameter block for event mask modify*/
ataRegAccess ataRAParamBlock; /* parameter block for register access*/
ataIdentify ataDIParamBlock; /* parameter block for drive identify*/
ataDevConfiguration ataDCParamBlock; /* parameter block for device configuration*/
ataLocationData ataLDParamBlock; /* parameter block for location icon data*/
/*ataManagerInit ataInitParamBlock; // parameter block for Manager initialization*/
/*ataManagerShutDn ataSDParamBlock; // parameter block for Manager shutdown*/
/*ataDrvrLoad ataDLParamBlock; // parameter block for Driver loading*/
ataGeneric ataGenericParamBlock; /* parameter block for all other functions*/
};
typedef union ataPB ataPB;
/* The ATA Event codes...*/
enum {
kATANullEvent = 0x00, /* Just kidding -- nothing happened*/
kATAOnlineEvent = 0x01, /* An ATA device has come online*/
kATAOfflineEvent = 0x02, /* An ATA device has gone offline*/
kATARemovedEvent = 0x03, /* An ATA device has been removed from the bus*/
kATAResetEvent = 0x04, /* Someone gave a hard reset to the drive*/
kATAOfflineRequest = 0x05, /* Someone requesting to offline the drive*/
kATAEjectRequest = 0x06, /* Someone requesting to eject the drive*/
kATAUpdateEvent = 0x07, /* Potential configuration change reported by CardServices <SM4>*/
kATATaskTimeRequest = 0x08, /* The manager is requesting to be called at Task Time*/
kATALoadDriverNow = 0x09, /* Load the driver for the given bus immediately*/
kATAPIResetEvent = 0x0A, /* Someone gave a ATAPI reset to the drive*/
/* The following describes bit definitions in the eventMask field of ataDrvrRegister*/
bATANullEvent = 1 << kATANullEvent, /* null event bit*/
bATAOnlineEvent = 1 << kATAOnlineEvent, /* online event bit*/
bATAOfflineEvent = 1 << kATAOfflineEvent, /* offline event bit*/
bATARemovedEvent = 1 << kATARemovedEvent, /* removed event bit*/
bATAResetEvent = 1 << kATAResetEvent, /* ATA reset event bit*/
bATAOfflineRequest = 1 << kATAOfflineRequest, /* offline request event bit*/
bATAEjectRequest = 1 << kATAEjectRequest, /* eject request event bit*/
bATAUpdateEvent = 1 << kATAUpdateEvent, /* configuration update event bit*/
bATAPIResetEvent = 1 << kATAPIResetEvent /* ATAPI reset event bit*/
};
enum {
kATAEventMarker = FOUR_CHAR_CODE('LOAD'), /* Marker for the event data structure*/
kATAEventVersion1 = 0x00000001 /* Version 1 of the event structure*/
};
typedef CALLBACK_API( OSErr , ATADispatchProcPtr )(ataPB *pb);
typedef STACK_UPP_TYPE(ATADispatchProcPtr) ATADispatchUPP;
if OPAQUE_UPP_TYPES
if CALL_NOT_IN_CARBON
EXTERN_API(ATADispatchUPP)
NewATADispatchUPP (ATADispatchProcPtr userRoutine);
EXTERN_API(void)
DisposeATADispatchUPP (ATADispatchUPP userUPP);
EXTERN_API(OSErr)
InvokeATADispatchUPP (ataPB * pb,
ATADispatchUPP userUPP);
endif /* CALL_NOT_IN_CARBON */
else
enum { uppATADispatchProcInfo = 0x000000E0 }; /* pascal 2_bytes Func(4_bytes) */
#define NewATADispatchUPP(userRoutine) (ATADispatchUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppATADispatchProcInfo, GetCurrentArchitecture())
#define DisposeATADispatchUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define InvokeATADispatchUPP(pb, userUPP) (OSErr)CALL_ONE_PARAMETER_UPP((userUPP), uppATADispatchProcInfo, (pb))
endif
/* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
define NewATADispatchProc(userRoutine) NewATADispatchUPP(userRoutine)
define CallATADispatchProc(userRoutine, pb) InvokeATADispatchUPP(pb, userRoutine)
if CALL_NOT_IN_CARBON
EXTERN_API( SInt16 )
ataManager (ataPB * pb) ONEWORDINLINE(0xAAF1);
/* Device Error codes: 0xDB42 - 0xDB5F */
endif /* CALL_NOT_IN_CARBON */
enum {
ATABaseErrCode = -9406, /* Base error code - 0xDB42 */
ioPending = 1, /* Asynch I/O in progress status*/
AT_NRdyErr = ATABaseErrCode + 0x01, /* 0xDB43: Drive not Ready */
AT_IDNFErr = ATABaseErrCode + 0x02, /* 0xDB44: ID not found */
AT_DMarkErr = ATABaseErrCode + 0x03, /* 0xDB45: Data mark not found */
AT_BadBlkErr = ATABaseErrCode + 0x04, /* 0xDB46: Bad Block */
AT_CorDataErr = ATABaseErrCode + 0x05, /* 0xDB47: Data was corrected */
AT_UncDataErr = ATABaseErrCode + 0x06, /* 0xDB48: Data was not corrected */
AT_SeekErr = ATABaseErrCode + 0x07, /* 0xDB49: Seek error */
AT_WrFltErr = ATABaseErrCode + 0x08, /* 0xDB4A: Write fault */
AT_RecalErr = ATABaseErrCode + 0x09, /* 0xDB4B: Recalibrate failed */
AT_AbortErr = ATABaseErrCode + 0x0A, /* 0xDB4C: Command aborted by drive */
AT_MCErr = ATABaseErrCode + 0x0C, /* 0xDB4E: Media Changed error*/
ATAPICheckErr = ATABaseErrCode + 0x0D, /* 0xDB4F: ATAPI Check condition <06/15/94>*/
AT_UltraDMAiCRCErr = ATABaseErrCode + 0x0E, /* 0xDB50: CRC error during Ultra DMA xfer */
/* System error codes...Custom Driver Error Codes 0xDB60 - 0xDB6F*/
DRVRCantAllocate = ATABaseErrCode + 0x1E, /* 0xDB60: Allocation error during initialization*/
NoATAMgr = ATABaseErrCode + 0x1F, /* 0xDB61: MgrInquiry failed => No ATA Manager*/
ATAInitFail = ATABaseErrCode + 0x20, /* 0xDB62: Mgr Initialization failed*/
ATABufFail = ATABaseErrCode + 0x21, /* 0xDB63: Device buffer test failure*/
ATADevUnsupported = ATABaseErrCode + 0x22, /* 0xDB64: Device type not supported*/
ATAEjectDrvErr = ATABaseErrCode + 0x23, /* 0xDB65: Could not eject the drive*/
/* Manager Error Codes 0xDB70 - 0xDB8F*/
ATAMgrNotInitialized = ATABaseErrCode + 0x2E, /* 0xDB70: Mgr has not been initialized*/
ATAPBInvalid = ATABaseErrCode + 0x2F, /* 0xDB71: The bus base address couldn't be found*/
ATAFuncNotSupported = ATABaseErrCode + 0x30, /* 0xDB72: An unknown function code specified*/
ATABusy = ATABaseErrCode + 0x31, /* 0xDB73: Selected device is busy*/
ATATransTimeOut = ATABaseErrCode + 0x32, /* 0xDB74: Transaction timeout detected*/
ATAReqInProg = ATABaseErrCode + 0x33, /* 0xDB75: Channel busy; channel is processing another cmd*/
ATAUnknownState = ATABaseErrCode + 0x34, /* 0xDB76: Device status register reflects an unknown state*/
ATAQLocked = ATABaseErrCode + 0x35, /* 0xDB77: I/O Queue is locked due to previous I/O error.*/
ATAReqAborted = ATABaseErrCode + 0x36, /* 0xDB78: The I/O queue entry was aborted due to an abort req.*/
/* or due to Manager shutdown.*/
ATAUnableToAbort = ATABaseErrCode + 0x37, /* 0xDB79: The I/O queue entry could not be aborted.*/
ATAAbortedDueToRst = ATABaseErrCode + 0x38, /* 0xDB7A: Request aborted due to a device reset command.*/
ATAPIPhaseErr = ATABaseErrCode + 0x39, /* 0xDB7B: Unexpected phase - oooIS THIS VALID ERROR??? <06/15/94>*/
ATAPITxCntErr = ATABaseErrCode + 0x3A, /* 0xDB7C: Overrun/Underrun condition detected*/
ATANoClientErr = ATABaseErrCode + 0x3B, /* 0xDB7D: No client present to handle the event*/
ATAInternalErr = ATABaseErrCode + 0x3C, /* 0xDB7E: MagnumOpus returned an error*/
ATABusErr = ATABaseErrCode + 0x3D, /* 0xDB7F: Bus error detected on I/O */
AT_NoAddrErr = ATABaseErrCode + 0x3E, /* 0xDB80: Invalid AT base adress */
DriverLocked = ATABaseErrCode + 0x3F, /* 0xDB81: Current driver must be removed before adding another*/
CantHandleEvent = ATABaseErrCode + 0x40, /* 0xDB82: Particular event couldn't be handled (call others)*/
ATAMgrMemoryErr = ATABaseErrCode + 0x41, /* 0xDB83: Manager memory allocation error */
ATASDFailErr = ATABaseErrCode + 0x42, /* 0xDB84: Shutdown failure */
ATAXferParamErr = ATABaseErrCode + 0x43, /* 0xDB85: I/O xfer parameters inconsistent */
ATAXferModeErr = ATABaseErrCode + 0x44, /* 0xDB86: I/O xfer mode not supported */
ATAMgrConsistencyErr = ATABaseErrCode + 0x45, /* 0XDB87: Manager detected internal inconsistency. */
ATADmaXferErr = ATABaseErrCode + 0x46, /* 0XDB88: fatal error in DMA side of transfer */
/* Driver loader error Codes 0xDB90 - 0xDBA5*/
ATAInvalidDrvNum = ATABaseErrCode + 0x4E, /* 0xDB90: Invalid drive number from event*/
ATAMemoryErr = ATABaseErrCode + 0x4F, /* 0xDB91: Memory allocation error*/
ATANoDDMErr = ATABaseErrCode + 0x50, /* 0xDB92: No DDM found on media */
ATANoDriverErr = ATABaseErrCode + 0x51 /* 0xDB93: No driver found on the media */
};
/* ------------------------ Version 1 definition ------------------------------- */
enum {
v1ATABaseErrCode = 0x0700, /* This needs a home somewhere*/
v1AT_NRdyErr = 0x01 - v1ATABaseErrCode, /* 0xF901: -0x1DBE */
v1AT_IDNFErr = 0x04 - v1ATABaseErrCode, /* 0xF904: -0x1DC0 */
v1AT_DMarkErr = 0x05 - v1ATABaseErrCode, /* 0xF905: -0x1DC0 */
v1AT_BadBlkErr = 0x06 - v1ATABaseErrCode, /* 0xF906: -0x1DC0 */
v1AT_CorDataErr = 0x07 - v1ATABaseErrCode, /* 0xF907: -0x1DC0 */
v1AT_UncDataErr = 0x08 - v1ATABaseErrCode, /* 0xF908: -0x1DC0 */
v1AT_SeekErr = 0x09 - v1ATABaseErrCode, /* 0xF909: -0x1DC0 */
v1AT_WrFltErr = 0x0A - v1ATABaseErrCode, /* 0xF90A: -0x1DC0 */
v1AT_RecalErr = 0x0B - v1ATABaseErrCode, /* 0xF90B: -0x1DC0 */
v1AT_AbortErr = 0x0C - v1ATABaseErrCode, /* 0xF90C: -0x1DC0 */
v1AT_NoAddrErr = 0x0D - v1ATABaseErrCode, /* 0xF90D: -0x1D8D */
v1AT_MCErr = 0x0E - v1ATABaseErrCode, /* 0xF90E: -0x1DC0*/
/* System error codes...Custom Driver Error Codes*/
v1DRVRCantAllocate = -(v1ATABaseErrCode + 1), /* 0xF8FF: -0x1D9F*/
v1NoATAMgr = -(v1ATABaseErrCode + 2), /* 0xF8FE: -0x1D9D*/
v1ATAInitFail = -(v1ATABaseErrCode + 3), /* 0xF8FD: -0x1D9B*/
v1ATABufFail = -(v1ATABaseErrCode + 4), /* 0xF8FC: -0x1D99*/
v1ATADevUnsupported = -(v1ATABaseErrCode + 5), /* 0xF8FB: -0x1c97*/
/* Manager Error Codes*/
v1ATAMgrNotInitialized = -(v1ATABaseErrCode + 10), /* 0xF8F6: -0x1D86*/
v1ATAPBInvalid = -(v1ATABaseErrCode + 11), /* 0xF8F5: -0x1D84*/
v1ATAFuncNotSupported = -(v1ATABaseErrCode + 12), /* 0xF8F4: -0x1D82*/
v1ATABusy = -(v1ATABaseErrCode + 13), /* 0xF8F3: -0x1D80*/
v1ATATransTimeOut = -(v1ATABaseErrCode + 14), /* 0xF8F2: -0x1D7E*/
v1ATAReqInProg = -(v1ATABaseErrCode + 15), /* 0xF8F1: -0x1D7C*/
v1ATAUnknownState = -(v1ATABaseErrCode + 16), /* 0xF8F0: -0x1D7A*/
v1ATAQLocked = -(v1ATABaseErrCode + 17), /* 0xF8EF: -0x1D78*/
v1ATAReqAborted = -(v1ATABaseErrCode + 18), /* 0xF8EE: -0x1D76*/
v1ATAUnableToAbort = -(v1ATABaseErrCode + 19), /* 0xF8ED: -0x1D74*/
v1ATAAbortedDueToRst = -(v1ATABaseErrCode + 20) /* 0xF8EC: -0x1D72*/
};
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 /* __ATA__ */
(C) Æliens
04/09/2009
You may not copy or print any of this material without explicit permission of the author or the publisher.
In case of other copyright issues, contact the author.
