iokit/IOKit/ata/ata-device/ATAPublic.h

   1 /*
   2  * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22 /*
  23  *
  24  *      ATAPublic.h
  25  *
  26  */
  27
  28 #ifndef _ATAPUBLIC_H
  29 #define _ATAPUBLIC_H
  30
  31 typedef struct ATAIdentify
  32 {
  33     UInt16      generalConfiguration;
  34     UInt16      logicalCylinders;
  35     UInt16      reserved_1[1];
  36     UInt16      logicalHeads;
  37     UInt16      reserved_2[2];
  38     UInt16      logicalSectorsPerTrack;
  39     UInt16      reserved_3[3];
  40     char        serialNumber[20];
  41     UInt16      reserved_4[3];
  42     char        firmwareRevision[8];
  43     char        modelNumber[40];
  44     UInt16      multipleModeSectors;
  45     UInt16      reserved_5[1];
  46     UInt16      capabilities1;
  47     UInt16      capabilities2;
  48     UInt16      pioMode;
  49     UInt16      reserved_6[1];
  50     UInt16      validFields;
  51     UInt16      currentLogicalCylinders;
  52     UInt16      currentLogicalHeads;
  53     UInt16      currentLogicalSectorsPerTrack;
  54     UInt16      currentAddressableSectors[2];
  55     UInt16      currentMultipleModeSectors;
  56     UInt16      userAddressableSectors[2];
  57     UInt16      reserved_7[1];
  58     UInt16      dmaModes;
  59     UInt16      advancedPIOModes;
  60     UInt16      minDMACycleTime;
  61     UInt16      recDMACycleTime;
  62     UInt16      minPIOCycleTimeNoIORDY;
  63     UInt16      minPIOCyclcTimeIORDY;
  64     UInt16      reserved_8[2];
  65     UInt16      busReleaseLatency;
  66     UInt16      serviceLatency;
  67     UInt16      reserved_9[2];
  68     UInt16      queueDepth;
  69     UInt16      reserved_10[4];
  70     UInt16      versionMajor;
  71     UInt16      versionMinor;
  72     UInt16      commandSetsSupported1;
  73     UInt16      commandSetsSupported2;
  74     UInt16      commandSetsSupported3;
  75     UInt16      commandSetsEnabled1;
  76     UInt16      commandSetsEnabled2;
  77     UInt16      commandSetsDefault;
  78     UInt16      ultraDMAModes;
  79     UInt16      securityEraseTime;
  80     UInt16      securityEnhancedEraseTime;
  81     UInt16      currentAdvPowerMgtValue;
  82     UInt16      reserved_11[35];
  83     UInt16      removableMediaSupported;
  84     UInt16      securityStatus;
  85     UInt16      reserved_12[127];
  86 } ATAIdentify;
  87
  88
  89
  90 typedef struct ATAPIInquiry
  91 {
  92     unsigned char   devType;            /*      0 Device type,          */
  93     unsigned char   devTypeMod;         /*      1 Device type modifier  */
  94     unsigned char   version;            /*      2 ISO/ECMA/ANSI version */
  95     unsigned char   format;             /*      3 Response data format  */
  96     unsigned char   length;             /*      4 Additional Length     */
  97     unsigned char   reserved5;          /*      5 Reserved              */
  98     unsigned char   reserved6;          /*      6 Reserved              */
  99     unsigned char   flags;              /*      7 Capability flags      */
 100     unsigned char   vendorName[8];      /*      8-15 Vendor-specific    */
 101     unsigned char   productName[16];    /* 16-31 Product id             */
 102     unsigned char   productRevision[4]; /* 32-35 Product revision       */
 103     unsigned char   vendorSpecific[20]; /* 36-55 Vendor stuff           */
 104     unsigned char   moreReserved[40];   /* 56-95 Reserved               */
 105 } ATAInquiry;
 106
 107 /*
 108  * These are device type qualifiers. We need them to distinguish between "unknown"
 109  * and "missing" devices.
 110  */
 111 enum
 112 {
 113     kATAPIDevTypeQualifierConnected     = 0x00, /* Exists and is connected      */
 114     kATAPIDevTypeQualifierNotConnected  = 0x20, /* Logical unit exists  */
 115     kATAPIDevTypeQualifierReserved      = 0x40,
 116     kATAPIDevTypeQualifierMissing       = 0x60, /* No such logical unit */
 117     kATAPIDevTypeQualifierVendorSpecific = 0x80, /* Non-standardized    */
 118     kATAPIDevTypeQualifierMask          = 0xE0,
 119 };
 120
 121 enum ATAPIDevFlags
 122 {
 123     kATAPIDevCapRelAdr                  = 0x80,
 124     kATAPIDevCapWBus32                  = 0x40,
 125     kATAPIDevCapWBus16                  = 0x20,
 126     kATAPIDevCapSync                    = 0x10,
 127     kATAPIDevCapLinked                  = 0x08,
 128     kATAPIDevCapCmdQue                  = 0x02,
 129     kATAPIDevCapSftRe                   = 0x01,
 130 };
 131
 132 typedef struct ATAPISenseData
 133 {
 134     unsigned char   errorCode;              /*     0 Result validity    */
 135     unsigned char   segmentNumber;          /*     1 Segment number     */
 136     unsigned char   senseKey;               /*     2 Sense code, flags  */
 137     unsigned char   info[4];                /*   3-6 Sense-key specific */
 138     unsigned char   additionalSenseLength;  /*     7 Sense length info  */
 139     unsigned char   reservedForCopy[4];     /*  8-11 Sense-key specific */
 140     unsigned char   additionalSenseCode;    /*    12 What kind of error */
 141     unsigned char   additionalSenseQualifier; /*  13 More error info    */
 142     unsigned char   fruCode;                /*    14 Field replacable   */
 143     unsigned char   senseKeySpecific[2];    /* 15-16 Additional info    */
 144     unsigned char   additional[101];        /* 17-26 Additional info    */
 145 } ATASenseData;
 146
 147 /*
 148  * The high-bit of errorCode signals whether there is a logical
 149  * block. The low value signals whether there is a valid sense
 150  */
 151 enum ATAErrorCode
 152 {
 153     kATAPISenseHasLBN                   = 0x80, /* Logical block number set     */
 154     kATAPISenseInfoValid                = 0x70, /* Is sense key valid?          */
 155     kATAPISenseInfoMask                 = 0x70, /* Mask for sense info          */
 156     kATAPISenseCurrentErr               = 0x70, /* Error code (byte 0 & 0x7F    */
 157     kATAPISenseDeferredErr              = 0x71, /* Error code (byte 0 & 0x7F    */
 158 };
 159
 160 /*
 161  * These bits may be set in the sense key
 162  */
 163 enum ATAPISenseKeyMasks
 164 {
 165     kATAPISenseKeyMask                  = 0x0F,
 166     kATAPISenseILI                      = 0x20, /* Illegal logical Length       */
 167     kATAPISenseEOM                      = 0x40, /* End of media                 */
 168     kATAPISenseFileMark                 = 0x80, /* End of file mark             */
 169 };
 170 /*
 171  * ATA sense codes. (Returned after request sense).
 172  */
 173 enum ATAPISenseKeys
 174 {
 175     kATAPISenseNone                     = 0x00, /* No error                     */
 176     kATAPISenseRecoveredErr             = 0x01, /* Warning                      */
 177     kATAPISenseNotReady                 = 0x02, /* Device not ready             */
 178     kATAPISenseMediumErr                = 0x03, /* Device medium error          */
 179     kATAPISenseHardwareErr              = 0x04, /* Device hardware error        */
 180     kATAPISenseIllegalReq               = 0x05, /* Illegal request for dev.     */
 181     kATAPISenseUnitAtn                  = 0x06, /* Unit attention (not err)     */
 182     kATAPISenseDataProtect              = 0x07, /* Data protection              */
 183     kATAPISenseBlankCheck               = 0x08, /* Tape-specific error          */
 184     kATAPISenseVendorSpecific           = 0x09, /* Vendor-specific error        */
 185     kATAPISenseCopyAborted              = 0x0a, /* Copy request cancelled       */
 186     kATAPISenseAbortedCmd               = 0x0b, /* Initiator aborted cmd.       */
 187     kATAPISenseEqual                    = 0x0c, /* Comparison equal             */
 188     kATAPISenseVolumeOverflow           = 0x0d, /* Write past end mark          */
 189     kATAPISenseMiscompare               = 0x0e, /* Comparison failed            */
 190 };
 191
 192 enum ATAPIStatus
 193 {
 194     kATAPIStatusGood                    = 0x00,
 195     kATAPIStatusCheckCondition          = 0x02,
 196     kATAPIStatusConditionMet            = 0x04,
 197     kATAPIStatusBusy                    = 0x08,
 198     kATAPIStatusIntermediate            = 0x10,
 199     kATAPIStatusIntermediateMet         = 0x0a,
 200     kATAPIStatusReservationConfict      = 0x18,
 201     kATAPIStatusCommandTerminated       = 0x22,
 202     kATAPIStatusQueueFull               = 0x28,
 203 };
 204
 205
 206 enum ATAPIDevTypes
 207 {
 208     kATAPIDevTypeDirect         = 0,    /* Hard disk (not CD-ROM)       */
 209     kATAPIDevTypeSequential,            /* Magtape or DAT               */
 210     kATAPIDevTypePrinter,               /* Printer                      */
 211     kATAPIDevTypeProcessor,             /* Attached processor           */
 212     kATAPIDevTypeWorm,                  /* Write-once, read multiple    */
 213     kATAPIDevTypeCDROM,                 /* CD-ROM                       */
 214     kATAPIDevTypeScanner,               /* Scanner                      */
 215     kATAPIDevTypeOptical,               /* Optical disk                 */
 216     kATAPIDevTypeChanger,               /* Jukebox                      */
 217     kATAPIDevTypeComm,                  /* Communication link           */
 218     kATAPIDevTypeGraphicArts0A,
 219     kATAPIDevTypeGraphicArts0B,
 220     kATAPIDevTypeFirstReserved,         /* Reserved sequence start      */
 221     kATAPIDevTypeUnknownOrMissing = 0x1F,
 222     kATAPIDevTypeMask           = 0x1F,
 223 };
 224
 225
 226 /*
 227  * ATA command codes. Commands defined as ...6, ...10, ...12, are
 228  * six-byte, ten-byte, and twelve-byte variants of the indicated command.
 229  */
 230
 231 /*
 232  * These commands are supported for all devices.
 233  */
 234 enum ATAPICmds
 235 {
 236      kATAPICmdChangeDefinition          = 0x40,
 237      kATAPICmdCompare                   = 0x39,
 238      kATAPICmdCopy                      = 0x18,
 239      kATAPICmdCopyAndVerify             = 0x3a,
 240      kATAPICmdInquiry                   = 0x12,
 241      kATAPICmdLogSelect                 = 0x4c,
 242      kATAPICmdLogSense                  = 0x4d,
 243      kATAPICmdModeSelect12              = 0x55,
 244      kATAPICmdModeSelect6               = 0x15,
 245      kATAPICmdModeSense12               = 0x5a,
 246      kATAPICmdModeSense6                = 0x1a,
 247      kATAPICmdReadBuffer                = 0x3c,
 248      kATAPICmdRecvDiagResult            = 0x1c,
 249      kATAPICmdRequestSense              = 0x03,
 250      kATAPICmdSendDiagnostic            = 0x1d,
 251      kATAPICmdTestUnitReady             = 0x00,
 252      kATAPICmdWriteBuffer               = 0x3b,
 253
 254 /*
 255  * These commands are supported by direct-access devices only.
 256  */
 257      kATAPICmdFormatUnit                = 0x04,
 258      kATAPICmdLockUnlockCache           = 0x36,
 259      kATAPICmdPrefetch                  = 0x34,
 260      kATAPICmdPreventAllowRemoval       = 0x1e,
 261      kATAPICmdRead6                     = 0x08,
 262      kATAPICmdRead10                    = 0x28,
 263      kATAPICmdReadCapacity              = 0x25,
 264      kATAPICmdReadDefectData            = 0x37,
 265      kATAPICmdReadLong                  = 0x3e,
 266      kATAPICmdReassignBlocks            = 0x07,
 267      kATAPICmdRelease                   = 0x17,
 268      kATAPICmdReserve                   = 0x16,
 269      kATAPICmdRezeroUnit                = 0x01,
 270      kATAPICmdSearchDataEql             = 0x31,
 271      kATAPICmdSearchDataHigh            = 0x30,
 272      kATAPICmdSearchDataLow             = 0x32,
 273      kATAPICmdSeek6                     = 0x0b,
 274      kATAPICmdSeek10                    = 0x2b,
 275      kATAPICmdSetLimits                 = 0x33,
 276      kATAPICmdStartStopUnit             = 0x1b,
 277      kATAPICmdSynchronizeCache          = 0x35,
 278      kATAPICmdVerify                    = 0x2f,
 279      kATAPICmdWrite6                    = 0x0a,
 280      kATAPICmdWrite10                   = 0x2a,
 281      kATAPICmdWriteAndVerify            = 0x2e,
 282      kATAPICmdWriteLong                 = 0x3f,
 283      kATAPICmdWriteSame                 = 0x41,
 284
 285 /*
 286  * These commands are supported by sequential devices.
 287  */
 288      kATAPICmdRewind                    = 0x01,
 289      kATAPICmdWriteFilemarks            = 0x10,
 290      kATAPICmdSpace                     = 0x11,
 291      kATAPICmdLoadUnload                = 0x1B,
 292 /*
 293  * ANSI ATA-II for CD-ROM devices.
 294  */
 295      kATAPICmdReadCDTableOfContents     = 0x43,
 296 };
 297
 298
 299 enum ATARegs
 300 {
 301     /*
 302      * ATA Register ordinals
 303      */
 304     kATARegData                 = 0x00,
 305     kATARegFeatures             = 0x01,
 306     kATARegSectorCount          = 0x02,
 307     kATARegSectorNumber         = 0x03,
 308     kATARegCylinderLow          = 0x04,
 309     kATARegCylinderHigh         = 0x05,
 310     kATARegDriveHead            = 0x06,
 311     kATARegCommand              = 0x07,
 312
 313     kATARegError                = 0x01,
 314     kATARegStatus               = 0x07,
 315
 316     kATARegDeviceControl        = 0x08,
 317
 318     kATARegAltStatus            = 0x08,
 319
 320     /*
 321      * ATAPI Register ordinals
 322      */
 323     kATARegATAPIData            = 0x00,
 324     kATARegATAPIFeatures        = 0x01,
 325     kATARegATAPIIntReason       = 0x02,
 326     kATARegATAPIByteCountLow    = 0x04,
 327     kATARegATAPIByteCountHigh   = 0x05,
 328     kATARegATAPIDeviceSelect    = 0x06,
 329     kATARegATAPICommand         = 0x07,
 330
 331     kATARegATAPIError           = 0x01,
 332     kATARegATAPIStatus          = 0x07,
 333
 334     kATARegATAPIDeviceControl   = 0x08,
 335
 336     kATARegATAPIAlternateStatus = 0x08,
 337
 338     kMaxATARegs                 = 12,
 339 };
 340
 341 enum ATASectorCountQDMA
 342 {
 343     kATATagBit                  = 0x08,
 344 };
 345
 346
 347 enum ATAPIIntReason
 348 {
 349     kATAPIIntReasonCD           = 0x01,
 350     kATAPIIntReasonIO           = 0x02,
 351     kATAPIIntReasonREL          = 0x04,
 352     kATAPIIntReasonTagBit       = 0x08,
 353     kATAPIIntReasonTagMask      = 0xf8,
 354 };
 355
 356 enum ATACommand
 357 {
 358     kATAModeCHS                 = 0xa0,
 359     kATAModeLBA                 = 0xe0,
 360
 361     kATACommandSetFeatures      = 0xef,
 362
 363     kATACommandIdentify         = 0xec,
 364
 365     kATACommandReadSector       = 0x20,
 366
 367     kATACommandService          = 0xa2,
 368
 369     kATACommandATAPIReset       = 0x08,
 370     kATACommandATAPIPacket      = 0xa0,
 371     kATACommandATAPIIdentify    = 0xa1,
 372 };
 373
 374 enum ATAFeatures
 375 {
 376     kATAFeatureTransferMode             = 0x03,
 377         kATATransferModePIODefault      = 0x00,         // SectorCount settings (or'd w/Mode)
 378         kATATransferModePIOwFC          = 0x08,
 379         kATATransferModeDMA             = 0x20,
 380         kATATransferModeUltraDMA33      = 0x40,
 381         kATATransferModeMask            = 0x07,
 382 };
 383
 384
 385 enum ATAStatus
 386 {
 387     kATAStatusERR               = 0x01,
 388     kATAStatusIDX               = 0x02,
 389     kATAStatusECC               = 0x04,
 390     kATAStatusDRQ               = 0x08,
 391     kATAStatusSC                = 0x10,
 392     kATAStatusDF                = 0x20,
 393     kATAStatusDRDY              = 0x40,
 394     kATAStatusBSY               = 0x80,
 395
 396     kATAStatusSERV              = 0x10,
 397     kATAStatusREL               = 0x20,
 398
 399     kATAPIStatusCHK             = 0x01,
 400     kATAPIStatusDRQ             = 0x08,
 401     kATAPIStatusSERV            = 0x10,
 402     kATAPIStatusDMRD            = 0x20,
 403     kATAPIStatusDRDY            = 0x40,
 404     kATAPIStatusBSY             = 0x80,
 405 };
 406
 407 enum ATAError
 408 {
 409    kATAErrorNM                  = 0x02,
 410    kATAErrorABRT                = 0x04,
 411    kATAErrorMCR                 = 0x08,
 412    kATAErrorIDNF                = 0x10,
 413    kATAErrorMC                  = 0x20,
 414    kATAErrorWP                  = 0x40,
 415
 416    kATAPIErrorILI               = 0x01,
 417    kATAPIErrorEOM               = 0x02,
 418    kATAPIErrorABRT              = 0x04,
 419    kATAPIErrorSenseKeyBit       = 0x10,
 420    kATAPIErrorSenseKeyMask      = 0xf0,
 421 };
 422
 423 enum ATADeviceControl
 424 {
 425     kATADevControlnIEN          = 0x02,
 426     kATADevControlSRST          = 0x04,
 427 };
 428
 429 enum ATASignatures
 430 {
 431     kATASignatureSectorCount    = 0x01,
 432     kATASignatureSectorNumber   = 0x01,
 433     kATASignatureCylinderLow    = 0x00,
 434     kATASignatureCylinderHigh   = 0x00,
 435
 436     kATAPISignatureCylinderLow  = 0x14,
 437     kATAPISignatureCylinderHigh = 0xeb,
 438 };
 439
 440
 441 #endif