ATAPublic.h   [plain text]

/*
 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 *
 *	ATAPublic.h
 *
 */

#ifndef _ATAPUBLIC_H
#define _ATAPUBLIC_H

typedef struct ATAIdentify
{
    UInt16	generalConfiguration;
    UInt16	logicalCylinders;
    UInt16	reserved_1[1];
    UInt16	logicalHeads;
    UInt16	reserved_2[2];
    UInt16	logicalSectorsPerTrack;    
    UInt16	reserved_3[3];
    char	serialNumber[20];
    UInt16	reserved_4[3];
    char        firmwareRevision[8];
    char	modelNumber[40];
    UInt16	multipleModeSectors;
    UInt16	reserved_5[1];
    UInt16	capabilities1;
    UInt16	capabilities2;
    UInt16	pioMode;
    UInt16	reserved_6[1];
    UInt16	validFields;
    UInt16	currentLogicalCylinders;
    UInt16	currentLogicalHeads;
    UInt16	currentLogicalSectorsPerTrack;
    UInt16	currentAddressableSectors[2];
    UInt16	currentMultipleModeSectors;
    UInt16	userAddressableSectors[2];
    UInt16	reserved_7[1];
    UInt16	dmaModes;
    UInt16	advancedPIOModes;
    UInt16	minDMACycleTime;
    UInt16	recDMACycleTime;
    UInt16	minPIOCycleTimeNoIORDY;
    UInt16	minPIOCyclcTimeIORDY;
    UInt16	reserved_8[2];
    UInt16	busReleaseLatency;
    UInt16	serviceLatency;
    UInt16	reserved_9[2];
    UInt16	queueDepth;
    UInt16	reserved_10[4];
    UInt16	versionMajor;
    UInt16	versionMinor;
    UInt16	commandSetsSupported1;
    UInt16	commandSetsSupported2;
    UInt16	commandSetsSupported3;
    UInt16	commandSetsEnabled1;
    UInt16	commandSetsEnabled2;
    UInt16	commandSetsDefault;
    UInt16	ultraDMAModes;
    UInt16	securityEraseTime;
    UInt16	securityEnhancedEraseTime;
    UInt16	currentAdvPowerMgtValue;
    UInt16	reserved_11[35];
    UInt16	removableMediaSupported;
    UInt16	securityStatus;
    UInt16      reserved_12[127];
} ATAIdentify;



typedef struct ATAPIInquiry
{
    unsigned char   devType;		/*	0 Device type,		*/
    unsigned char   devTypeMod;		/*	1 Device type modifier	*/
    unsigned char   version;		/*	2 ISO/ECMA/ANSI version */
    unsigned char   format;		/*	3 Response data format	*/
    unsigned char   length;		/*	4 Additional Length	*/
    unsigned char   reserved5;		/*	5 Reserved		*/
    unsigned char   reserved6;		/*	6 Reserved		*/
    unsigned char   flags;		/*	7 Capability flags	*/
    unsigned char   vendorName[8];	/*	8-15 Vendor-specific	*/
    unsigned char   productName[16];	/* 16-31 Product id		*/
    unsigned char   productRevision[4];	/* 32-35 Product revision	*/
    unsigned char   vendorSpecific[20];	/* 36-55 Vendor stuff		*/
    unsigned char   moreReserved[40];	/* 56-95 Reserved		*/
} ATAInquiry;

/*
 * These are device type qualifiers. We need them to distinguish between "unknown"
 * and "missing" devices.
 */
enum 
{
    kATAPIDevTypeQualifierConnected  	= 0x00, /* Exists and is connected	*/
    kATAPIDevTypeQualifierNotConnected 	= 0x20, /* Logical unit exists	*/
    kATAPIDevTypeQualifierReserved   	= 0x40,
    kATAPIDevTypeQualifierMissing    	= 0x60, /* No such logical unit	*/
    kATAPIDevTypeQualifierVendorSpecific = 0x80, /* Non-standardized	*/
    kATAPIDevTypeQualifierMask	    	= 0xE0,
};

enum ATAPIDevFlags 
{
    kATAPIDevCapRelAdr			= 0x80,
    kATAPIDevCapWBus32			= 0x40,
    kATAPIDevCapWBus16			= 0x20,
    kATAPIDevCapSync			= 0x10,
    kATAPIDevCapLinked			= 0x08,
    kATAPIDevCapCmdQue			= 0x02,
    kATAPIDevCapSftRe			= 0x01,
};

typedef struct ATAPISenseData
{
    unsigned char   errorCode;		    /*     0 Result validity	*/
    unsigned char   segmentNumber;	    /*     1 Segment number	*/
    unsigned char   senseKey;		    /*     2 Sense code, flags	*/
    unsigned char   info[4];		    /*   3-6 Sense-key specific	*/
    unsigned char   additionalSenseLength;  /*     7 Sense length info	*/
    unsigned char   reservedForCopy[4];	    /*  8-11 Sense-key specific	*/
    unsigned char   additionalSenseCode;    /*    12 What kind of error	*/
    unsigned char   additionalSenseQualifier; /*  13 More error info	*/
    unsigned char   fruCode;		    /*    14 Field replacable	*/
    unsigned char   senseKeySpecific[2];    /* 15-16 Additional info	*/
    unsigned char   additional[101];	    /* 17-26 Additional info	*/
} ATASenseData;

/*
 * The high-bit of errorCode signals whether there is a logical
 * block. The low value signals whether there is a valid sense
 */
enum ATAErrorCode
{
    kATAPISenseHasLBN			= 0x80,	/* Logical block number set	*/
    kATAPISenseInfoValid	 	= 0x70,	/* Is sense key valid?		*/
    kATAPISenseInfoMask			= 0x70,	/* Mask for sense info		*/
    kATAPISenseCurrentErr		= 0x70,	/* Error code (byte 0 & 0x7F	*/
    kATAPISenseDeferredErr		= 0x71,	/* Error code (byte 0 & 0x7F	*/
};

/*
 * These bits may be set in the sense key
 */
enum ATAPISenseKeyMasks
{
    kATAPISenseKeyMask			= 0x0F,
    kATAPISenseILI			= 0x20,	/* Illegal logical Length	*/
    kATAPISenseEOM			= 0x40,	/* End of media			*/
    kATAPISenseFileMark			= 0x80,	/* End of file mark		*/
};
/*
 * ATA sense codes. (Returned after request sense).
 */
enum ATAPISenseKeys
{
    kATAPISenseNone			= 0x00,	/* No error			*/
    kATAPISenseRecoveredErr		= 0x01, /* Warning			*/
    kATAPISenseNotReady			= 0x02,	/* Device not ready		*/
    kATAPISenseMediumErr		= 0x03, /* Device medium error		*/
    kATAPISenseHardwareErr		= 0x04, /* Device hardware error	*/
    kATAPISenseIllegalReq		= 0x05, /* Illegal request for dev.	*/
    kATAPISenseUnitAtn			= 0x06,	/* Unit attention (not err)	*/
    kATAPISenseDataProtect		= 0x07, /* Data protection		*/
    kATAPISenseBlankCheck		= 0x08, /* Tape-specific error		*/
    kATAPISenseVendorSpecific 		= 0x09,	/* Vendor-specific error	*/
    kATAPISenseCopyAborted		= 0x0a, /* Copy request cancelled	*/
    kATAPISenseAbortedCmd		= 0x0b, /* Initiator aborted cmd.	*/
    kATAPISenseEqual			= 0x0c,	/* Comparison equal		*/
    kATAPISenseVolumeOverflow 		= 0x0d,	/* Write past end mark		*/
    kATAPISenseMiscompare		= 0x0e, /* Comparison failed		*/
};

enum ATAPIStatus
{
    kATAPIStatusGood			= 0x00,
    kATAPIStatusCheckCondition		= 0x02,
    kATAPIStatusConditionMet		= 0x04,
    kATAPIStatusBusy			= 0x08,
    kATAPIStatusIntermediate		= 0x10,
    kATAPIStatusIntermediateMet		= 0x0a,
    kATAPIStatusReservationConfict	= 0x18,
    kATAPIStatusCommandTerminated	= 0x22,
    kATAPIStatusQueueFull		= 0x28,
};


enum ATAPIDevTypes
{
    kATAPIDevTypeDirect		= 0,	/* Hard disk (not CD-ROM)	*/
    kATAPIDevTypeSequential,		/* Magtape or DAT		*/
    kATAPIDevTypePrinter,		/* Printer			*/
    kATAPIDevTypeProcessor,		/* Attached processor		*/
    kATAPIDevTypeWorm,			/* Write-once, read multiple	*/
    kATAPIDevTypeCDROM,			/* CD-ROM			*/
    kATAPIDevTypeScanner,		/* Scanner			*/
    kATAPIDevTypeOptical,		/* Optical disk			*/
    kATAPIDevTypeChanger,		/* Jukebox			*/
    kATAPIDevTypeComm,			/* Communication link		*/
    kATAPIDevTypeGraphicArts0A,
    kATAPIDevTypeGraphicArts0B,
    kATAPIDevTypeFirstReserved,		/* Reserved sequence start	*/
    kATAPIDevTypeUnknownOrMissing = 0x1F,
    kATAPIDevTypeMask		= 0x1F,
};


/*
 * ATA command codes. Commands defined as ...6, ...10, ...12, are
 * six-byte, ten-byte, and twelve-byte variants of the indicated command.
 */

/*
 * These commands are supported for all devices.
 */
enum ATAPICmds
{
     kATAPICmdChangeDefinition    	= 0x40,
     kATAPICmdCompare		    	= 0x39,
     kATAPICmdCopy		    	= 0x18,
     kATAPICmdCopyAndVerify	    	= 0x3a,
     kATAPICmdInquiry		    	= 0x12,
     kATAPICmdLogSelect	    		= 0x4c,
     kATAPICmdLogSense	    		= 0x4d,
     kATAPICmdModeSelect12	    	= 0x55,
     kATAPICmdModeSelect6	    	= 0x15,
     kATAPICmdModeSense12	    	= 0x5a,
     kATAPICmdModeSense6	    	= 0x1a,
     kATAPICmdReadBuffer	    	= 0x3c,
     kATAPICmdRecvDiagResult	    	= 0x1c,
     kATAPICmdRequestSense	    	= 0x03,
     kATAPICmdSendDiagnostic	    	= 0x1d,
     kATAPICmdTestUnitReady	    	= 0x00,
     kATAPICmdWriteBuffer	    	= 0x3b,

/*
 * These commands are supported by direct-access devices only.
 */
     kATAPICmdFormatUnit	    	= 0x04,
     kATAPICmdLockUnlockCache	   	= 0x36,
     kATAPICmdPrefetch	    	    	= 0x34,
     kATAPICmdPreventAllowRemoval  	= 0x1e,
     kATAPICmdRead6		    	= 0x08,
     kATAPICmdRead10		    	= 0x28,
     kATAPICmdReadCapacity	    	= 0x25,
     kATAPICmdReadDefectData	    	= 0x37,
     kATAPICmdReadLong	            	= 0x3e,
     kATAPICmdReassignBlocks	    	= 0x07,
     kATAPICmdRelease		    	= 0x17,
     kATAPICmdReserve		    	= 0x16,
     kATAPICmdRezeroUnit	    	= 0x01,
     kATAPICmdSearchDataEql	    	= 0x31,
     kATAPICmdSearchDataHigh	    	= 0x30,
     kATAPICmdSearchDataLow	    	= 0x32,
     kATAPICmdSeek6		    	= 0x0b,
     kATAPICmdSeek10		    	= 0x2b,
     kATAPICmdSetLimits	    		= 0x33,
     kATAPICmdStartStopUnit	    	= 0x1b,
     kATAPICmdSynchronizeCache     	= 0x35,
     kATAPICmdVerify		    	= 0x2f,
     kATAPICmdWrite6		    	= 0x0a,
     kATAPICmdWrite10		    	= 0x2a,
     kATAPICmdWriteAndVerify	    	= 0x2e,
     kATAPICmdWriteLong	    		= 0x3f,
     kATAPICmdWriteSame	    		= 0x41,

/*
 * These commands are supported by sequential devices.
 */
     kATAPICmdRewind		    	= 0x01,
     kATAPICmdWriteFilemarks	    	= 0x10,
     kATAPICmdSpace		    	= 0x11,
     kATAPICmdLoadUnload	    	= 0x1B,
/*
 * ANSI ATA-II for CD-ROM devices.
 */
     kATAPICmdReadCDTableOfContents	= 0x43,
};


enum ATARegs
{
    /*
     * ATA Register ordinals
     */
    kATARegData			= 0x00,		
    kATARegFeatures		= 0x01,		
    kATARegSectorCount		= 0x02,		
    kATARegSectorNumber		= 0x03,		
    kATARegCylinderLow		= 0x04,		
    kATARegCylinderHigh		= 0x05,
    kATARegDriveHead		= 0x06,
    kATARegCommand		= 0x07,

    kATARegError		= 0x01,
    kATARegStatus		= 0x07,

    kATARegDeviceControl	= 0x08,

    kATARegAltStatus		= 0x08,

    /*
     * ATAPI Register ordinals
     */
    kATARegATAPIData		= 0x00,
    kATARegATAPIFeatures	= 0x01,
    kATARegATAPIIntReason	= 0x02,
    kATARegATAPIByteCountLow	= 0x04,
    kATARegATAPIByteCountHigh	= 0x05,
    kATARegATAPIDeviceSelect	= 0x06,
    kATARegATAPICommand		= 0x07,

    kATARegATAPIError		= 0x01,
    kATARegATAPIStatus		= 0x07,

    kATARegATAPIDeviceControl	= 0x08,

    kATARegATAPIAlternateStatus	= 0x08,

    kMaxATARegs			= 12,
};

enum ATASectorCountQDMA
{
    kATATagBit			= 0x08,
};


enum ATAPIIntReason
{
    kATAPIIntReasonCD		= 0x01,
    kATAPIIntReasonIO		= 0x02,
    kATAPIIntReasonREL		= 0x04,
    kATAPIIntReasonTagBit	= 0x08,
    kATAPIIntReasonTagMask	= 0xf8,
};

enum ATACommand
{
    kATAModeCHS			= 0xa0, 
    kATAModeLBA			= 0xe0,
 
    kATACommandSetFeatures	= 0xef,

    kATACommandIdentify		= 0xec,

    kATACommandReadSector	= 0x20,

    kATACommandService		= 0xa2,

    kATACommandATAPIReset	= 0x08,
    kATACommandATAPIPacket	= 0xa0,
    kATACommandATAPIIdentify	= 0xa1,
};

enum ATAFeatures
{
    kATAFeatureTransferMode		= 0x03,	
        kATATransferModePIODefault	= 0x00,		// SectorCount settings (or'd w/Mode)	
        kATATransferModePIOwFC		= 0x08,		
        kATATransferModeDMA		= 0x20,
        kATATransferModeUltraDMA33	= 0x40,
        kATATransferModeMask		= 0x07,
};


enum ATAStatus
{
    kATAStatusERR		= 0x01,
    kATAStatusIDX		= 0x02,
    kATAStatusECC		= 0x04,
    kATAStatusDRQ		= 0x08,
    kATAStatusSC		= 0x10,
    kATAStatusDF		= 0x20,
    kATAStatusDRDY		= 0x40,
    kATAStatusBSY		= 0x80,

    kATAStatusSERV		= 0x10,
    kATAStatusREL		= 0x20,

    kATAPIStatusCHK		= 0x01,
    kATAPIStatusDRQ		= 0x08,
    kATAPIStatusSERV		= 0x10,
    kATAPIStatusDMRD		= 0x20,
    kATAPIStatusDRDY		= 0x40,
    kATAPIStatusBSY		= 0x80,
};

enum ATAError
{
   kATAErrorNM			= 0x02,
   kATAErrorABRT		= 0x04,
   kATAErrorMCR			= 0x08,
   kATAErrorIDNF		= 0x10,
   kATAErrorMC			= 0x20,
   kATAErrorWP			= 0x40,

   kATAPIErrorILI		= 0x01,
   kATAPIErrorEOM		= 0x02,
   kATAPIErrorABRT		= 0x04,
   kATAPIErrorSenseKeyBit	= 0x10,
   kATAPIErrorSenseKeyMask	= 0xf0,
};

enum ATADeviceControl
{
    kATADevControlnIEN		= 0x02,
    kATADevControlSRST		= 0x04,
};

enum ATASignatures
{
    kATASignatureSectorCount	= 0x01,
    kATASignatureSectorNumber	= 0x01,
    kATASignatureCylinderLow	= 0x00,
    kATASignatureCylinderHigh	= 0x00,

    kATAPISignatureCylinderLow	= 0x14,
    kATAPISignatureCylinderHigh = 0xeb,
};


#endif