![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOATAPIHDDrive.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOATAPIHDDrive|
Return to IOATAPIHDDrive.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOATAPIHDDrive |
1.1 root 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: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
24: *
25: * IOATAPIHDDrive.h - Generic ATAPI Direct-Access driver.
26: *
27: * HISTORY
28: * Sep 2, 1999 jliu - Ported from AppleATAPIDrive.
29: */
30:
31: #include <IOKit/assert.h>
32: #include <IOKit/storage/ata/IOATAPIHDDrive.h>
33: #include <IOKit/storage/ata/IOATAPIHDDriveNub.h>
34:
35: #define super IOATAHDDrive
36: OSDefineMetaClassAndStructors( IOATAPIHDDrive, IOATAHDDrive )
37:
38: // --------------------------------------------------------------------------
39: // Override the init() method in IOATAHDDrive.
40:
41: bool
42: IOATAPIHDDrive::init(OSDictionary * properties)
43: {
44: _mediaPresent = false;
45: _isRemovable = false;
46:
47: return (super::init(properties));
48: }
49:
50: // --------------------------------------------------------------------------
51: // Override probe() method inherited from IOATAHDDrive. We need to
52: // perform additional matching on ATAPI device type from the Inquiry data.
53:
54: IOService *
55: IOATAPIHDDrive::probe(IOService * provider, SInt32 * score)
56: {
57: UInt8 deviceType;
58:
59: // Our provider must be a IOATADevice nub, most likely created
60: // by an IOATAController instance.
61: //
62: IOATADevice * device = OSDynamicCast(IOATADevice, provider);
63: if (!device)
64: return 0; // IOATADevice nub not found.
65:
66: // Let superclass have a go at probe first.
67: //
68: if (!super::probe(provider, score))
69: return 0;
70:
71: // Perform ATAPI type matching, CD-ROM, Direct-Access, Tape, etc.
72: //
73: if (!device->getInquiryData(1, (ATAPIInquiry *) &deviceType) ||
74: !matchATAPIDeviceType(deviceType & 0x1f))
75: return 0;
76:
77: return this; // probe successful.
78: }
79:
80: // --------------------------------------------------------------------------
81: // Report as an ATAPI device.
82:
83: ATADeviceType
84: IOATAPIHDDrive::reportATADeviceType() const
85: {
86: return ataDeviceATAPI;
87: }
88:
89: // --------------------------------------------------------------------------
90: // Looks for an ATAPI device which is a direct-access device.
91:
92: bool
93: IOATAPIHDDrive::matchATAPIDeviceType(UInt8 type)
94: {
95: if (type == kIOATAPIDeviceTypeDirectAccess)
96: return true;
97: return false;
98: }
99:
100: // --------------------------------------------------------------------------
101: // Gather information about the ATAPI device nub.
102:
103: void
104: IOATAPIHDDrive::inspectDevice(IOService * provider)
105: {
106: OSString * string;
107: IOATADevice * ataDevice = OSDynamicCast(IOATADevice, provider);
108: if (!ataDevice)
109: return;
110:
111: // Fetch ATAPI device information from the nub.
112: //
113: string = OSDynamicCast(OSString,
114: ataDevice->getProperty(ATAPropertyVendorName));
115: if (string) {
116: strncpy(_vendor, string->getCStringNoCopy(), 8);
117: _vendor[8] = '\0';
118: }
119:
120: string = OSDynamicCast(OSString,
121: ataDevice->getProperty(ATAPropertyProductName));
122: if (string) {
123: strncpy(_product, string->getCStringNoCopy(), 16);
124: _product[16] = '\0';
125: }
126:
127: string = OSDynamicCast(OSString,
128: ataDevice->getProperty(ATAPropertyProductRevision));
129: if (string) {
130: strncpy(_revision, string->getCStringNoCopy(), 4);
131: _revision[4] = '\0';
132: }
133: }
134:
135: // --------------------------------------------------------------------------
136: // Handles read/write requests.
137:
138: IOReturn IOATAPIHDDrive::doAsyncReadWrite(IOMemoryDescriptor * buffer,
139: UInt32 block,
140: UInt32 nblks,
141: gdCompletionFunction action,
142: IOService * target,
143: void * param)
144: {
145: IOReturn ret;
146: IOATACommand * cmd = atapiCommandReadWrite(buffer, block, nblks);
147: if (!cmd)
148: return kIOReturnNoMemory;
149:
150: ret = getIOReturn(asyncExecute(cmd, target, action, param));
151:
152: cmd->release();
153:
154: return ret;
155: }
156:
157: // --------------------------------------------------------------------------
158: // Eject the media in the removable drive.
159:
160: IOReturn
161: IOATAPIHDDrive::doEjectMedia()
162: {
163: IOReturn ret;
164: IOATACommand * cmd = atapiCommandStartStopUnit(0, /* senseData */
165: false, /* start unit */
166: true, /* Load/Eject */
167: false); /* Immediate */
168:
169: if (!cmd)
170: return kIOReturnNoMemory;
171:
172: ret = getIOReturn(syncExecute(cmd));
173:
174: cmd->release();
175:
176: return ret;
177: }
178:
179: // --------------------------------------------------------------------------
180: // Format the media in the drive.
181:
182: IOReturn
183: IOATAPIHDDrive::doFormatMedia(UInt64 /* byteCapacity */)
184: {
185: return kIOReturnUnsupported;
186: }
187:
188: // --------------------------------------------------------------------------
189: // Lock/unlock the media in the removable drive.
190:
191: IOReturn
192: IOATAPIHDDrive::doLockUnlockMedia(bool doLock)
193: {
194: IOReturn ret;
195: IOATACommand * cmd = atapiCommandPreventAllowRemoval(doLock);
196: if (!cmd)
197: return kIOReturnNoMemory;
198:
199: ret = getIOReturn(syncExecute(cmd));
200:
201: cmd->release();
202:
203: return ret;
204: }
205:
206: // --------------------------------------------------------------------------
207: // Sync the write cache.
208:
209: IOReturn
210: IOATAPIHDDrive::doSynchronizeCache()
211: {
212: return kIOReturnSuccess;
213: }
214:
215: // --------------------------------------------------------------------------
216: // Start up the drive.
217:
218: IOReturn
219: IOATAPIHDDrive::doStart()
220: {
221: return doStartStop(true);
222: }
223:
224: // --------------------------------------------------------------------------
225: // Stop the drive.
226:
227: IOReturn
228: IOATAPIHDDrive::doStop()
229: {
230: return doStartStop(false);
231: }
232:
233: // --------------------------------------------------------------------------
234: // Issue a START/STOP Unit command.
235:
236: IOReturn
237: IOATAPIHDDrive::doStartStop(bool doStart)
238: {
239: IOReturn ret;
240: IOATACommand * cmd;
241:
242: cmd = atapiCommandStartStopUnit(0, /* senseData */
243: doStart, /* start unit */
244: false, /* Load/Eject */
245: false); /* Immediate operation */
246:
247: if (!cmd) return kIOReturnNoMemory;
248:
249: ret = getIOReturn(syncExecute(cmd));
250:
251: cmd->release();
252:
253: return ret;
254: }
255:
256: // --------------------------------------------------------------------------
257: // Return device identification strings
258:
259: char * IOATAPIHDDrive::getVendorString()
260: {
261: return _vendor;
262: }
263:
264: char * IOATAPIHDDrive::getProductString()
265: {
266: return _product;
267: }
268:
269: char * IOATAPIHDDrive::getRevisionString()
270: {
271: return _revision;
272: }
273:
274: char * IOATAPIHDDrive::getAdditionalDeviceInfoString()
275: {
276: return ("[ATAPI]");
277: }
278:
279: // --------------------------------------------------------------------------
280: // Report whether the media in the drive is ejectable.
281:
282: IOReturn
283: IOATAPIHDDrive::reportEjectability(bool * isEjectable)
284: {
285: *isEjectable = true; /* default: if it's removable, it's ejectable */
286: return kIOReturnSuccess;
287: }
288:
289: // --------------------------------------------------------------------------
290: // Report whether the drive can prevent user-initiated ejects by locking
291: // the media in the drive.
292:
293: IOReturn
294: IOATAPIHDDrive::reportLockability(bool * isLockable)
295: {
296: *isLockable = true; /* default: if it's removable, it's lockable */
297: return kIOReturnSuccess;
298: }
299:
300: // --------------------------------------------------------------------------
301: // Report our polling requirments.
302:
303: IOReturn
304: IOATAPIHDDrive::reportPollRequirements(bool * pollRequired,
305: bool * pollIsExpensive)
306: {
307: *pollIsExpensive = false;
308: *pollRequired = _isRemovable;
309: return kIOReturnSuccess;
310: }
311:
312: // --------------------------------------------------------------------------
313: // Report the current state of the media.
314:
315: IOReturn
316: IOATAPIHDDrive::reportMediaState(bool * mediaPresent,
317: bool * changed)
318: {
319: IOATACommand * cmd;
320: ATAResults results;
321: IOReturn ret = kIOReturnSuccess;
322: UInt8 senseData[18];
323: IOMemoryDescriptor * senseDesc;
324:
325: assert(mediaPresent && changed);
326:
327: senseDesc = IOMemoryDescriptor::withAddress(senseData,
328: sizeof(senseData),
329: kIODirectionIn);
330: if (!senseDesc)
331: return kIOReturnNoMemory;
332:
333: cmd = atapiCommandTestUnitReady(senseDesc);
334: if (!cmd)
335: return kIOReturnNoMemory;
336:
337: // Execute the Test Unit Ready command with no retries.
338: //
339: syncExecute(cmd, ATADefaultTimeout, 0);
340:
341: // Release the memory descriptor.
342: //
343: senseDesc->release();
344:
345: if (cmd->getResults(&results) == ataReturnNoError)
346: {
347: *mediaPresent = true;
348: *changed = (*mediaPresent != _mediaPresent);
349: _mediaPresent = true;
350: }
351: else
352: {
353: UInt8 errorCode = senseData[0];
354: UInt8 senseKey = senseData[2];
355:
356: #ifdef DEBUG_LOG
357: UInt8 senseCode = senseData[12];
358: UInt8 senseQualifier = senseData[13];
359:
360: IOLog("-- reportMediaState --\n");
361: IOLog("Error code: %02x\n", errorCode);
362: IOLog("Sense Key : %02x\n", senseKey);
363: IOLog("ASC : %02x\n", senseCode);
364: IOLog("ASCQ : %02x\n", senseQualifier);
365: #endif
366:
367: *mediaPresent = false;
368: *changed = (*mediaPresent != _mediaPresent);
369: _mediaPresent = false;
370:
371: // The error code field for ATAPI request sense should always
372: // be 0x70 or 0x71. Otherwise ignore the sense data.
373: //
374: if ((errorCode == 0x70) || (errorCode == 0x71))
375: {
376: switch (senseKey) {
377: case 5: /* Invalid ATAPI command */
378: ret = kIOReturnIOError;
379: break;
380:
381: case 2: /* Not ready */
382: break;
383:
384: default:
385: break;
386: }
387: }
388: }
389:
390: cmd->release();
391:
392: #if 0
393: IOLog("%s: media present %s, changed %s\n", getName(),
394: *mediaPresent ? "Y" : "N",
395: *changed ? "Y" : "N"
396: );
397: #endif
398:
399: #ifndef DISKPM
400: if (*changed && *mediaPresent)
401: doStart();
402: #endif
403:
404: return ret;
405: }
406:
407: // --------------------------------------------------------------------------
408: // Report media removability.
409:
410: IOReturn
411: IOATAPIHDDrive::reportRemovability(bool * isRemovable)
412: {
413: UInt8 inqBuf[2];
414:
415: *isRemovable = false;
416:
417: if (_ataDevice->getInquiryData(sizeof(inqBuf), (ATAPIInquiry *) inqBuf))
418: {
419: if (inqBuf[1] & 0x80)
420: *isRemovable = _isRemovable = true;
421: else
422: *isRemovable = _isRemovable = false;
423: }
424:
425: return kIOReturnSuccess;
426: }
427:
428: // --------------------------------------------------------------------------
429: // Report whether media is write-protected.
430:
431: IOReturn
432: IOATAPIHDDrive::reportWriteProtection(bool * isWriteProtected)
433: {
434: *isWriteProtected = false; // defaults to read-write
435: return kIOReturnSuccess;
436: }
437:
438: // --------------------------------------------------------------------------
439: // Instantiate an ATAPI specific subclass of IOHDDriveNub.
440:
441: IOService *
442: IOATAPIHDDrive::instantiateNub()
443: {
444: IOService * nub = new IOATAPIHDDriveNub;
445: return nub;
446: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.