![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOATAPICDDrive.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOATAPICDDrive|
Return to IOATAPICDDrive.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOATAPICDDrive |
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: * IOATAPICDDrive.h - Generic ATAPI CD-ROM driver.
26: *
27: * HISTORY
28: * Sep 2, 1999 jliu - Ported from AppleATAPIDrive.
29: */
30:
31: #include <IOKit/assert.h>
32: #include <IOKit/storage/ata/IOATAPICDDrive.h>
33: #include <IOKit/storage/ata/IOATAPICDDriveNub.h>
34:
35: #define super IOATAPIHDDrive
36: OSDefineMetaClassAndStructors( IOATAPICDDrive, IOATAPIHDDrive )
37:
38: // --------------------------------------------------------------------------
39: // Looks for an ATAPI device which is a CD-ROM device.
40:
41: bool
42: IOATAPICDDrive::matchATAPIDeviceType(UInt8 type)
43: {
44: if (type == kIOATAPIDeviceTypeCDROM)
45: return true;
46: return false;
47: }
48:
49: // --------------------------------------------------------------------------
50: // Instantiate an ATAPI specific subclass of IOCDDriveNub.
51:
52: IOService *
53: IOATAPICDDrive::instantiateNub()
54: {
55: IOService * nub = new IOATAPICDDriveNub;
56: return nub;
57: }
58:
59: // --------------------------------------------------------------------------
60: // Report whether media is write-protected.
61:
62: IOReturn
63: IOATAPICDDrive::reportWriteProtection(bool * isWriteProtected)
64: {
65: *isWriteProtected = true;
66: return kIOReturnSuccess;
67: }
68:
69: // --------------------------------------------------------------------------
70: // Returns the device type.
71:
72: const char *
73: IOATAPICDDrive::getDeviceTypeName()
74: {
75: return kDeviceTypeCDROM;
76: }
77:
78: // --------------------------------------------------------------------------
79: // Read the Table of Contents.
80:
81: IOReturn
82: IOATAPICDDrive::readTOC(struct rawToc * buffer,
83: UInt32 length,
84: tocFormat format)
85: {
86: IOReturn ret;
87: IOATACommand * cmd;
88: IOMemoryDescriptor * tocDesc;
89:
90: assert(buffer);
91:
92: tocDesc = IOMemoryDescriptor::withAddress(buffer,
93: length,
94: kIODirectionIn);
95: if (!tocDesc)
96: return kIOReturnNoMemory;
97:
98: cmd = atapiCommandReadTOC(tocDesc, format, 0);
99: if (!cmd)
100: return kIOReturnNoMemory;
101:
102: // Execute the Read TOC command.
103: //
104: ret = getIOReturn(syncExecute(cmd));
105:
106: // Release the memory descriptor.
107: //
108: tocDesc->release();
109:
110: cmd->release();
111:
112: return ret;
113: }
114:
115: // --------------------------------------------------------------------------
116: // Start analog audio play
117:
118: IOReturn
119: IOATAPICDDrive::setAudioStopAddress (positioningType addressType,
120: cdAddress address)
121: {
122: if (addressType == kAbsoluteTime)
123: fMSFStopAddress = (UInt32)address;
124: if (addressType == kBlockAddress)
125: fLBAStopAddress = (UInt32)address;
126: return 0;
127: }
128:
129: IOReturn
130: IOATAPICDDrive::audioPlay(positioningType addressType,
131: cdAddress address,
132: audioPlayMode mode)
133: {
134: if (addressType == kBlockAddress) {
135: return playAudio((UInt32)address,0xfff);
136: }
137: if (addressType == kAbsoluteTime) {
138: return playAudioMSF((UInt32)address,(UInt32)fMSFStopAddress);
139: }
140: return 0;
141: }
142:
143: IOReturn
144: IOATAPICDDrive::playAudioMSF (UInt32 start_msf,
145: UInt32 end_msf)
146: {
147: IOATACommand * cmd;
148: IOReturn ret;
149:
150: // IOLog("IOATAPICDDrive::playAudioMSF %x %x\n",start_msf,end_msf);
151: cmd = atapiCommandPlayAudioMSF(start_msf, end_msf);
152: if (!cmd)
153: return kIOReturnNoMemory;
154:
155: // Execute the audio play command.
156: //
157: ret = getIOReturn(syncExecute(cmd));
158:
159: cmd->release();
160:
161: return ret;
162: }
163:
164: IOReturn
165: IOATAPICDDrive::playAudio (UInt32 start_lba,
166: UInt32 len_lba)
167: {
168: IOATACommand * cmd;
169: IOReturn ret;
170:
171: // IOLog("IOATAPICDDrive::playAudio\n");
172: cmd = atapiCommandPlayAudio(start_lba, len_lba);
173: if (!cmd)
174: return kIOReturnNoMemory;
175:
176: // Execute the audio play command.
177: //
178: ret = getIOReturn(syncExecute(cmd));
179:
180: cmd->release();
181:
182: return ret;
183: }
184:
185: IOReturn
186: IOATAPICDDrive::audioPause(bool pause)
187: {
188: IOATACommand * cmd;
189: IOReturn ret;
190:
191: // IOLog("IOATAPICDDrive::audioPause\n");
192: cmd = atapiCommandPauseResume(!pause);
193: if (!cmd)
194: return kIOReturnNoMemory;
195:
196: // Execute the audio pause/resume command.
197: //
198: ret = getIOReturn(syncExecute(cmd));
199:
200: cmd->release();
201:
202: return ret;
203: }
204:
205: IOReturn
206: IOATAPICDDrive::readAudioVolume(UInt8 * leftVolume, UInt8 * rightVolume)
207: {
208: UInt8 *audio_control;
209: IOReturn status = -1;
210:
211: audio_control = (UInt8 *)IOMalloc(144);
212: if (!audio_control) return kIOReturnNoMemory;
213:
214: status = readModeSense(audio_control,(UInt32)144,(UInt32)0xe);
215: *leftVolume = audio_control[21] & 0xff;
216: *rightVolume = audio_control[17] & 0xff;
217:
218: // IOLog("IOATAPICDDrive::readAudioVolume left0=%d right0=%d left1=%d right1=%d\n", *leftVolume,*rightVolume, audio_control[23],audio_control[19]);
219:
220: // IOLog("IOATAPICDDrive::readAudioVolume p0=%d p1=%d p2=%d p3=%d\n", audio_control[8],audio_control[10], audio_control[12],audio_control[14]);
221:
222: IOFree(audio_control,144);
223: return status;
224: }
225:
226: IOReturn
227: IOATAPICDDrive::setVolume(UInt8 leftVolume, UInt8 rightVolume)
228: {
229: UInt8 *audio_control;
230: IOReturn status = -1;
231: UInt32 len;
232:
233: // IOLog("IOATAPICDDrive::setVolume %d %d\n",leftVolume,rightVolume);
234:
235: // init
236: audio_control = (UInt8 *)IOMalloc(144);
237: if (!audio_control) return kIOReturnNoMemory;
238:
239: // get current values
240: status = readModeSense(audio_control,(UInt32)144,(UInt32)0xe);
241: len = (UInt32)audio_control[1] + 2;
242:
243: // set new values
244: // audio_control[ 9] = audio_control[11] = 0xff;
245: // audio_control[23] = audio_control[21] = leftVolume & 0xff;
246: audio_control[19] = audio_control[17] = rightVolume & 0xff;
247:
248: // get current values
249: status = writeModeSelect(audio_control,(UInt32)len,(UInt32)0xe);
250:
251: // cleanup and exit
252: IOFree(audio_control,144);
253: return status;
254: }
255:
256: IOReturn
257: IOATAPICDDrive::readModeSense(UInt8 * buffer, UInt32 length, UInt32 pageCode)
258: {
259: IOReturn ret;
260: IOATACommand * cmd;
261: IOMemoryDescriptor * senseDesc;
262:
263: assert(buffer);
264:
265: // IOLog("IOATAPICDDrive::readModeSense len=%d page=%d\n",length,pageCode);
266:
267: senseDesc = IOMemoryDescriptor::withAddress(buffer,
268: length,
269: kIODirectionIn);
270: if (!senseDesc)
271: return kIOReturnNoMemory;
272:
273: cmd = atapiCommandModeSense(senseDesc, pageCode);
274: if (!cmd)
275: return kIOReturnNoMemory;
276:
277: // Execute the Mode Sense command.
278: //
279: ret = getIOReturn(syncExecute(cmd));
280:
281: // Release the memory descriptor.
282: //
283: senseDesc->release();
284:
285: cmd->release();
286:
287: return ret;
288: }
289:
290: IOReturn
291: IOATAPICDDrive::writeModeSelect(UInt8 * buffer, UInt32 length, UInt32 pageCode)
292: {
293: IOReturn ret;
294: IOATACommand * cmd;
295: IOMemoryDescriptor * selectDesc;
296:
297: // IOLog("IOATAPICDDrive::writeModeSelect %d %d\n",length,pageCode);
298: assert(buffer);
299:
300: selectDesc = IOMemoryDescriptor::withAddress(buffer,
301: length,
302: kIODirectionOut);
303: if (!selectDesc)
304: return kIOReturnNoMemory;
305:
306: cmd = atapiCommandModeSelect(selectDesc, pageCode);
307: if (!cmd)
308: return kIOReturnNoMemory;
309:
310: // Execute the Mode Select command.
311: //
312: ret = getIOReturn(syncExecute(cmd));
313:
314: // Release the memory descriptor.
315: //
316: selectDesc->release();
317:
318: cmd->release();
319:
320: return ret;
321: }
322:
323: IOReturn
324: IOATAPICDDrive::readTheQSubcode(struct qSubcode *buffer)
325: {
326: UInt8 * channel_data;
327: UInt32 address;
328: IOReturn ret;
329:
330: // init
331: channel_data = (UInt8 *)IOMalloc(16);
332: if (!channel_data) return kIOReturnNoMemory;
333:
334: // get audio status
335: ret = readSubChannel(channel_data,16,0x01,0x00,true);
336:
337: // get current absolute address
338: address = ((channel_data[ 8] & 0xff) << 24) |
339: ((channel_data[ 9] & 0xff) << 16) |
340: ((channel_data[10] & 0xff) << 8) |
341: ((channel_data[11] & 0xff));
342: buffer->absAddress = (cdAddress)address;
343:
344: // get current track relative address
345: address = ((channel_data[12] & 0xff) << 24) |
346: ((channel_data[13] & 0xff) << 16) |
347: ((channel_data[14] & 0xff) << 8) |
348: ((channel_data[15] & 0xff));
349: buffer->relAddress = (cdAddress)address;
350:
351: // get type, track, index
352: buffer->type = channel_data[5] & 0x0f;
353: buffer->track = channel_data[6] & 0x0f;
354: buffer->index = channel_data[7] & 0x0f;
355:
356: // IOLog("IOATAPICDDrive::readTheQSubcode absAddr=0x%x relAddr=0x%xx\n", buffer->absAddress, buffer->relAddress);
357:
358: // cleanup
359: IOFree(channel_data,16);
360: return ret;
361: }
362:
363: IOReturn
364: IOATAPICDDrive::getAudioStatus(struct audioStatus *status)
365: {
366: UInt8 * channel_data;
367: UInt32 address;
368: IOReturn ret;
369:
370: // init
371: channel_data = (UInt8 *)IOMalloc(16);
372: if (!channel_data) return kIOReturnNoMemory;
373:
374: // get audio status
375: ret = readSubChannel(channel_data,16,0x01,0x00,true);
376:
377: // get current absolute address
378: address = ((channel_data[ 8] & 0xff) << 24) |
379: ((channel_data[ 9] & 0xff) << 16) |
380: ((channel_data[10] & 0xff) << 8) |
381: ((channel_data[11] & 0xff));
382: status->address = (cdAddress)address;
383:
384: // get current status
385: if ((channel_data[1] & 0xff) == 0x00) status->status = kUnknown;
386: if ((channel_data[1] & 0xff) == 0x11) status->status = kAudioPlayInProgress;
387: if ((channel_data[1] & 0xff) == 0x12) status->status = kHoldTrackMode;
388: if ((channel_data[1] & 0xff) == 0x13) status->status = kAudioPlayCompleted;
389: if ((channel_data[1] & 0xff) == 0x14) status->status = kError;
390: if ((channel_data[1] & 0xff) == 0x15) status->status = fStatus;
391: fStatus = status->status;
392:
393: // get current track type
394: status->type = channel_data[5] & 0x0f;
395:
396: // IOLog("IOATAPICDDrive::getAudioStatus addr=0x%x status=0x%x type=0x%x\n", status->address, status->status, status->type);
397:
398: // cleanup
399: IOFree(channel_data,16);
400: return ret;
401: }
402:
403: IOReturn
404: IOATAPICDDrive::readMCN(UInt8 * buffer, bool * found)
405: {
406: UInt8 * channel_data;
407: UInt32 address;
408: IOReturn ret;
409:
410: // init
411: channel_data = (UInt8 *)IOMalloc(24);
412: if (!channel_data) return kIOReturnNoMemory;
413:
414: // get audio status
415: ret = readSubChannel(channel_data,24,0x02,0x00,true);
416:
417: // check if found
418: *found = (channel_data[8] & 0x80 == 0x80);
419:
420: // copy the data
421: if (*found) {
422: bcopy(&channel_data[9],buffer,15);
423: }
424:
425: // IOLog("IOATAPICDDrive::readMCN found=%d\n",*found);
426:
427: // cleanup
428: IOFree(channel_data,24);
429: return ret;
430: }
431:
432: IOReturn
433: IOATAPICDDrive::readISRC(UInt32 track, UInt8 * buffer, bool * found)
434: {
435: UInt8 * channel_data;
436: UInt32 address;
437: IOReturn ret;
438:
439: // init
440: channel_data = (UInt8 *)IOMalloc(24);
441: if (!channel_data) return kIOReturnNoMemory;
442:
443: // get audio status
444: ret = readSubChannel(channel_data,24,0x03,track,true);
445:
446: // check if found
447: *found = (channel_data[8] & 0x80 == 0x80);
448:
449: // copy the data
450: if (*found) {
451: bcopy(&channel_data[9],buffer,15);
452: }
453:
454: // IOLog("IOATAPICDDrive::readISRC found=%d\n",*found);
455:
456: // cleanup
457: IOFree(channel_data,24);
458: return ret;
459: }
460:
461: IOReturn
462: IOATAPICDDrive::readHeader(UInt32 blockAddress,struct headerInfo *buffer)
463: {
464: UInt8 * header_data;
465: IOReturn ret;
466: IOATACommand * cmd;
467: IOMemoryDescriptor * readDesc;
468:
469: // init
470: header_data = (UInt8 *)IOMalloc(8);
471: if (!header_data) return kIOReturnNoMemory;
472:
473: // IOLog("IOATAPICDDrive::readHeader addr=0x%x\n",blockAddress);
474:
475: readDesc = IOMemoryDescriptor::withAddress(header_data,
476: 8,
477: kIODirectionIn);
478: if (!readDesc)
479: return kIOReturnNoMemory;
480:
481: cmd = atapiCommandReadHeader(readDesc, blockAddress);
482: if (!cmd)
483: return kIOReturnNoMemory;
484:
485: // Execute the Read Header command.
486: //
487: ret = getIOReturn(syncExecute(cmd));
488:
489: // Release the memory descriptor.
490: //
491: readDesc->release();
492: cmd->release();
493:
494: // save the data
495: buffer->address = ((header_data[4] & 0xff) << 24) |
496: ((header_data[5] & 0xff) << 16) |
497: ((header_data[6] & 0xff) << 8) |
498: ((header_data[7] & 0xff));
499: buffer->mode = header_data[0] & 0xff;
500:
501: IOFree(header_data,8);
502:
503: return ret;
504: }
505:
506: IOReturn
507: IOATAPICDDrive::readSubChannel(UInt8 * buffer,
508: UInt32 length,
509: UInt8 dataFormat,
510: UInt8 trackNumber,
511: bool subQ)
512: {
513: IOReturn ret;
514: IOATACommand * cmd;
515: IOMemoryDescriptor * readDesc;
516:
517: assert(buffer);
518:
519: // IOLog("IOATAPICDDrive::readSubChannel len=%d\n",length);
520:
521: readDesc = IOMemoryDescriptor::withAddress(buffer,
522: length,
523: kIODirectionIn);
524: if (!readDesc)
525: return kIOReturnNoMemory;
526:
527: cmd = atapiCommandReadSubChannel(readDesc, dataFormat, trackNumber, subQ);
528: if (!cmd)
529: return kIOReturnNoMemory;
530:
531: // Execute the Mode Sense command.
532: //
533: ret = getIOReturn(syncExecute(cmd));
534:
535: // Release the memory descriptor.
536: //
537: readDesc->release();
538:
539: cmd->release();
540:
541: return ret;
542: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.