Commit | Line | Data |
---|---|---|
1c79356b A |
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 |