![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOSCSICDDrive.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOSCSICDDrive|
Return to IOSCSICDDrive.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOSCSICDDrive |
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: #include <IOKit/IOLib.h>
24: #include <IOKit/IOReturn.h>
25: #include <IOKit/IOMemoryDescriptor.h>
26: #include <IOKit/scsi/IOSCSIDeviceInterface.h>
27: #include <IOKit/storage/scsi/IOSCSICDDrive.h>
28: #include <IOKit/storage/scsi/IOSCSICDDriveNub.h>
29:
30: /* Device types that we intend to handle. */
31:
32: const UInt8 DT_CDROM = 0x05; /* CD-ROM */
33:
34: #define super IOSCSIHDDrive
35: OSDefineMetaClassAndStructors(IOSCSICDDrive,IOSCSIHDDrive)
36:
37: IOReturn
38: IOSCSICDDrive::audioPlay(positioningType addressType,cdAddress address,audioPlayMode mode)
39: {
40: return(doAudioPlayCommand(addressType,address,
41: _audioStopAddress.type,_audioStopAddress.address));
42: }
43:
44: IOReturn
45: IOSCSICDDrive::audioPause(bool pause)
46: {
47: //xxxx
48: return(kIOReturnUnsupported);
49: }
50:
51: IOReturn
52: IOSCSICDDrive::audioScan(positioningType addressType,cdAddress address,bool reverse)
53: {
54: struct context *cx;
55: struct IOAudioScancdb *c;
56: IOSCSICommand *req;
57: SCSICDBInfo scsiCDB;
58: IOReturn result;
59:
60: cx = allocateContext();
61: if (cx == NULL) {
62: return(kIOReturnNoMemory);
63: }
64:
65: req = cx->scsireq;
66:
67: bzero( &scsiCDB, sizeof(scsiCDB) );
68:
69: c = (struct IOAudioScancdb *)&scsiCDB.cdb;
70:
71: c->opcode = SOP_AUDIOSCAN;
72: c->lunbits = 0;
73: if (!reverse) {
74: c->lunbits |= IOAudioScancdb::kForward;
75: }
76:
77: switch (addressType) {
78:
79: case kBlockAddress :
80: c->start3 = address >> 24;
81: c->start2 = address >> 16;
82: c->start1 = address >> 8;
83: c->start0 = address & 0xff;
84: c->ctlbyte = IOAudioScancdb::kType_lba;
85: break;
86:
87: case kAbsoluteTime :
88: c->start3 = address >> 24;
89: c->start2 = address >> 16;
90: c->start1 = address >> 8;
91: c->start0 = address & 0xff;
92: c->ctlbyte = IOAudioScancdb::kType_msf;
93: break;
94:
95: case kTrackNumber :
96: c->start3 = 0;
97: c->start2 = 0;
98: c->start1 = 0;
99: c->start0 = address & 0xff;
100: c->ctlbyte = IOAudioScancdb::kType_track;
101: break;
102:
103: default :
104: deleteContext(cx);
105: return(kIOReturnBadArgument);
106: };
107:
108: scsiCDB.cdbLength = 6;
109: scsiCDB.cdbFlags = 0;
110: req->setCDB( &scsiCDB );
111: req->setPointers(cx->senseDataDesc, 255, false, true);
112: req->setPointers( cx->memory, 0, false );
113: req->setTimeout(1 * 1000);
114:
115: result = simpleSynchIO(cx);
116:
117: deleteContext(cx);
118:
119: return(result);
120: }
121:
122: IOReturn
123: IOSCSICDDrive::audioTrackSearch(positioningType addressType,cdAddress address,
124: bool startPlay,audioPlayMode mode)
125: {
126: IOReturn result;
127: UInt32 lba;
128:
129: result = convertMSFToLba(&lba,address);
130: if (result != kIOReturnSuccess) {
131: return(result);
132: }
133:
134: result = seek(lba);
135: if (result != kIOReturnSuccess) {
136: return(result);
137: }
138:
139: if (startPlay) {
140: return(audioPlay(addressType,address,mode));
141: } else {
142: return(result);
143: }
144: }
145:
146: IOReturn
147: IOSCSICDDrive::convertMSFToLba(UInt32 *lba,cdAddress address)
148: {
149: //xxx wrong! incoming msf values are bcd!
150: *lba = ((address >> 16) * 75 * 60) + /* min */
151: ((address >> 8) * 75) + /* sec */
152: (address & 0xff); /* frames */
153:
154: return(kIOReturnSuccess);
155: }
156:
157: bool
158: IOSCSICDDrive::deviceTypeMatches(UInt8 inqBuf[],UInt32 inqLen)
159: {
160: if ((inqBuf[0] & 0x1f) == DT_CDROM) {
161: // IOLog("%s[IOSCSICDDrive]::deviceTypeMatches, returning TRUE\n",getName());
162: return(true);
163: } else {
164: // IOLog("%s[IOSCSICDDrive]::deviceTypeMatches, returning FALSE\n",getName());
165: return(false); /* we don't handle other devices */
166: }
167: }
168:
169: IOReturn
170: IOSCSICDDrive::doAudioPlayCommand(positioningType startType,cdAddress startAddress,
171: positioningType endType,cdAddress endAddress)
172: {
173: struct context *cx;
174: struct IOAudioPlaycdb *c;
175: struct IOAudioPlayMSFcdb *p;
176: IOSCSICommand *req;
177: SCSICDBInfo scsiCDB;
178: IOReturn result;
179: UInt32 length;
180:
181: /* Can we return an error here, or must we ensure that start and stop are always
182: * locally converted to the same units before we use them?
183: */
184: if (startType != endType) {
185: return(kIOReturnBadArgument);
186: }
187:
188: if (startType != kAbsoluteTime || startType != kBlockAddress) {
189: return(kIOReturnBadArgument);
190: }
191:
192: cx = allocateContext();
193: if (cx == NULL) {
194: return(kIOReturnNoMemory);
195: }
196:
197: req = cx->scsireq;
198:
199: bzero( &scsiCDB, sizeof(scsiCDB) );
200:
201: if (startType == kBlockAddress) { /* use PlayAudio command */
202: c = (struct IOAudioPlaycdb *)scsiCDB.cdb;
203:
204: c->opcode = SOP_PLAYAUDIO;
205: c->lunbits = 0;
206: c->lba_3 = startAddress >> 24;
207: c->lba_2 = startAddress >> 16;
208: c->lba_1 = startAddress >> 8;
209: c->lba_0 = startAddress & 0xff;
210: c->reserved1 = 0;
211: length = endAddress - startAddress;
212: c->len_hi = length >> 8;
213: c->len_lo = length & 0xff;
214: c->ctlbyte = 0;
215:
216: } else { /* absolute time: use PlayAudioMSF */
217:
218: p = (struct IOAudioPlayMSFcdb *)scsiCDB.cdb;
219:
220: p->opcode = SOP_PLAYAUDIOMSF;
221: p->lunbits = 0;
222: p->reserved1 = 0;
223: p->start_m = startAddress >> 16;
224: p->start_s = startAddress >> 8;
225: p->start_f = startAddress & 0xff;
226: p->end_m = endAddress >> 16;
227: p->end_s = endAddress >> 8;
228: p->end_f = endAddress & 0xff;
229: p->ctlbyte = 0;
230: }
231:
232: scsiCDB.cdbLength = 10;
233: req->setCDB( &scsiCDB );
234: req->setPointers(cx->senseDataDesc, 255, false, true);
235:
236: req->setPointers( cx->memory, 0, false );
237: req->setTimeout( 1000 );
238:
239: result = simpleSynchIO(cx);
240:
241: deleteContext(cx);
242:
243: return(result);
244: }
245:
246: IOReturn
247: IOSCSICDDrive::getAudioStatus(struct audioStatus *status)
248: {
249: const UInt8 qBufLen = 16;
250: IOReturn result;
251: UInt8 *tempBuf;
252:
253: /* Get a buffer for the returned data: */
254:
255: result = allocateTempBuffer(&tempBuf,qBufLen);
256: if (result != kIOReturnSuccess) {
257: return(kIOReturnNoMemory);
258: }
259:
260: result = readSubchannel(tempBuf,qBufLen,0,IORSCcdb::kCurrentPosition);
261:
262: if ((result == kIOReturnSuccess) && ((tempBuf[5] & 0xf0) == 0x10)) { /* we got the data */
263: status->playMode = _audioPlayMode;
264: status->type = (trackType)(tempBuf[5] & 0xff);
265: status->address = tempBuf[ 9] << 16 |
266: tempBuf[10] << 8 |
267: tempBuf[11];
268: switch (tempBuf[1]) { /* convert audio status */
269:
270:
271: case 0x11:
272: status->status = kAudioPlayInProgress;
273: break;
274:
275: case 0x12:
276: status->status = kHoldTrackMode;
277: break;
278:
279: case 0x13:
280: status->status = kAudioPlayCompleted;
281: break;
282:
283: case 0x14:
284: status->status = kError;
285: break;
286:
287: case 0x15:
288: status->status = kAudioPlayNotRequested;
289: break;
290:
291: case 0x00:
292: default:
293: status->status = kUnknown;
294: break;
295: }
296: }
297: deleteTempBuffer(tempBuf,qBufLen);
298:
299: return(result);
300: }
301:
302: const char *
303: IOSCSICDDrive::getDeviceTypeName(void)
304: {
305: return(kDeviceTypeCDROM);
306: }
307:
308: bool
309: IOSCSICDDrive::init(OSDictionary * properties)
310: {
311: initAudioModes();
312:
313: _audioStopAddress.address = 0L;
314: _audioStopAddress.type = kBlockAddress;
315:
316: return(super::init(properties));
317: }
318:
319: void
320: IOSCSICDDrive::initAudioModes(void)
321: {
322: _audioPlayMode = stereo;
323: _leftVolume = 0xff;
324: _leftPortChannel = playModeToDriveBits(_audioPlayMode,kLeft);
325: _rightVolume = 0xff;
326: _rightPortChannel = playModeToDriveBits(_audioPlayMode,kRight);
327: }
328:
329: IOService *
330: IOSCSICDDrive::instantiateNub(void)
331: {
332: IOService *nub;
333:
334: /* Instantiate a generic CDROM nub so a generic driver can match above us. */
335:
336: nub = new IOSCSICDDriveNub;
337: return(nub);
338: }
339:
340: void
341: IOSCSICDDrive::mediaGone(void)
342: {
343: }
344:
345: /* Convert the audioPlayMode signal routing bits to the drive's bits. */
346:
347: UInt8
348: IOSCSICDDrive::playModeToDriveBits(audioPlayMode mode,channel chan)
349: {
350: UInt8 bits;
351: int shift;
352:
353: bits = 0;
354:
355: switch (chan) {
356:
357: case kLeft : shift = shift_Left_Channel; break;
358: case kRight : shift = shift_Right_Channel; break;
359:
360: default : return(bits);
361: }
362:
363: if (mode & (signal_Left << shift)) {
364: bits |= drive_left_signal;
365: }
366: if (mode & (signal_Right << shift)) {
367: bits |= drive_right_signal;
368: }
369:
370: return(bits);
371: }
372:
373: IOReturn
374: IOSCSICDDrive::readAudioData(positioningType addressType,cdAddress address,
375: UInt8 blockCount,UInt8 *buffer)
376: {
377: /* what about buffer vs. IOMemoryDescriptor? */
378:
379: //xxxx
380: return(kIOReturnUnsupported);
381: }
382:
383: IOReturn
384: IOSCSICDDrive::readAudioSubcodes(positioningType addressType,cdAddress address,
385: UInt8 blockCount,UInt8 *buffer)
386: {
387: /* what about buffer vs. IOMemoryDescriptor? */
388:
389: // xxxx
390: return(kIOReturnUnsupported);
391: }
392:
393: IOReturn
394: IOSCSICDDrive::readAudioVolume(UInt8 *leftVolume,UInt8 *rightVolume)
395: {
396: /* Return the cached values. */
397:
398: *leftVolume = _leftVolume;
399: *rightVolume = _rightVolume;
400:
401: return(kIOReturnSuccess);
402: }
403:
404: IOReturn
405: IOSCSICDDrive::readAudioWithQSubcode(positioningType addressType,cdAddress address,
406: UInt8 blockCount,UInt8 *buffer)
407: {
408: /* what about buffer vs. IOMemoryDescriptor? */
409:
410: //xxxx
411: return(kIOReturnUnsupported);
412: }
413:
414: IOReturn
415: IOSCSICDDrive::readAudioWithAllSubcodes(positioningType addressType,cdAddress address,
416: UInt8 blockCount,UInt8 *buffer)
417: {
418: /* what about buffer vs. IOMemoryDescriptor? */
419:
420: //xxxx
421: return(kIOReturnUnsupported);
422: }
423:
424: IOReturn
425: IOSCSICDDrive::readHeader(UInt32 blockAddress,struct headerInfo *buffer)
426: {
427: const UInt8 hdrBufLen = 24;
428: struct context *cx;
429: struct IOReadHeadercdb *c;
430: IOSCSICommand *req;
431: SCSICDBInfo scsiCDB;
432: IOReturn result;
433: UInt8 *tempBuf;
434:
435: bzero(buffer,sizeof(struct headerInfo));
436:
437: /* Get a buffer for the returned data: */
438:
439: result = allocateTempBuffer(&tempBuf,hdrBufLen);
440: if (result != kIOReturnSuccess) {
441: return(kIOReturnNoMemory);
442: }
443:
444: cx = allocateContext();
445: if (cx == NULL) {
446: return(kIOReturnNoMemory);
447: }
448:
449: req = cx->scsireq;
450:
451: bzero( &scsiCDB, sizeof(scsiCDB) );
452:
453: c = (struct IOReadHeadercdb *)scsiCDB.cdb;
454:
455: c->opcode = SOP_READHEADER;
456: c->lunbits = 0;
457: c->lunbits |= IOReadHeadercdb::kMSF; /* return results in M:S:F format */
458: c->lba_3 = blockAddress >> 24;
459: c->lba_2 = blockAddress >> 18;
460: c->lba_1 = blockAddress >> 8;
461: c->lba_0 = blockAddress & 0xff;
462: c->reserved1 = 0;
463: c->len_hi = 0;
464: c->len_lo = hdrBufLen;
465: c->ctlbyte = 0;
466:
467: scsiCDB.cdbLength = 10;
468: req->setCDB( &scsiCDB );
469: req->setPointers(cx->senseDataDesc, 255, false, true);
470:
471: cx->memory = IOMemoryDescriptor::withAddress((void *)tempBuf,
472: hdrBufLen,
473: kIODirectionIn);
474: req->setPointers( cx->memory, hdrBufLen, false );
475:
476: req->setTimeout( 1000 );
477:
478: result = simpleSynchIO(cx);
479:
480: deleteContext(cx);
481:
482: if (result == kIOReturnSuccess) { /* return the header info */
483: buffer->mode = (dataMode)(tempBuf[0]);
484: buffer->address = tempBuf[4] << 24 ||
485: tempBuf[5] << 16 ||
486: tempBuf[6] << 8 ||
487: tempBuf[7];
488: }
489:
490: deleteTempBuffer(tempBuf,hdrBufLen);
491:
492: return(result);
493: }
494:
495: IOReturn
496: IOSCSICDDrive::readISRC(UInt32 track,UInt8 *buffer,bool *found)
497: {
498: return(readISRCMCN(IORSCcdb::kISRC,track,buffer,found));
499: }
500:
501: /* Since the ISRC and MCN are the same size and behave the same, we use common code. */
502: IOReturn
503: IOSCSICDDrive::readISRCMCN(UInt8 dataformat,UInt32 track,UInt8 *buffer,bool *found)
504: {
505: const UInt8 mcnISRCBufLen = 24;
506: IOReturn result;
507: UInt8 *tempBuf;
508:
509: *found = false; /* assume no ISRC/MCN will be found */
510: bzero(buffer,mcnISRCBufLen);
511:
512: /* Get a buffer for the returned data: */
513:
514: result = allocateTempBuffer(&tempBuf,mcnISRCBufLen);
515: if (result != kIOReturnSuccess) {
516: return(kIOReturnNoMemory);
517: }
518:
519: result = readSubchannel(tempBuf,mcnISRCBufLen,track,dataformat);
520:
521: if ((result == kIOReturnSuccess) && (tempBuf[8] & 0x80)) { /* return the ISRC/MCN */
522: bcopy(buffer,&tempBuf[9],15);
523: *found = true;
524: }
525:
526: deleteTempBuffer(tempBuf,mcnISRCBufLen);
527:
528: return(result);
529: }
530:
531: IOReturn
532: IOSCSICDDrive::readMCN(UInt8 *buffer,bool *found)
533: {
534: return(readISRCMCN(IORSCcdb::kMCN,0,buffer,found)); /* any track will do */
535: }
536:
537:
538: IOReturn
539: IOSCSICDDrive::readQSubcodes(struct qSubcodeTocInfo *buffer,UInt32 bufSize)
540: {
541: /* what about buffer vs. IOMemoryDescriptor? */
542:
543: //xxxx
544: return(kIOReturnUnsupported);
545: }
546:
547: IOReturn
548: IOSCSICDDrive::readSubcodeBuffer(UInt8 *buffer,bool purge,UInt32 entryCount)
549: {
550: /* what about buffer vs. IOMemoryDescriptor? */
551:
552: //xxxx
553: return(kIOReturnUnsupported);
554: }
555:
556: IOReturn
557: IOSCSICDDrive::readSubchannel(UInt8 *buffer,UInt32 length,UInt8 track,UInt8 dataFormat)
558: {
559: struct context *cx;
560: struct IORSCcdb *c;
561: IOSCSICommand *req;
562: SCSICDBInfo scsiCDB;
563: IOReturn result;
564:
565: cx = allocateContext();
566: if (cx == NULL) {
567: return(kIOReturnNoMemory);
568: }
569:
570: req = cx->scsireq;
571:
572: bzero( &scsiCDB, sizeof(scsiCDB) );
573:
574: bzero(buffer,length);
575:
576: c = (struct IORSCcdb *)(scsiCDB.cdb);
577:
578: c->opcode = SOP_READSUBCHANNEL;
579: c->lunbits = 0;
580: c->lunbits |= IORSCcdb::kMSF;
581: c->subq = IORSCcdb::kSubq;
582: c->dataformat = dataFormat;
583: c->track = track; /* any valid track will do */
584: c->reserved1 = 0;
585: c->reserved2 = 0;
586: c->len_hi = length >> 8;
587: c->len_lo = length & 0xff;
588: c->ctlbyte = 0;
589:
590: scsiCDB.cdbLength = 10;
591: req->setCDB( &scsiCDB );
592: req->setPointers(cx->senseDataDesc, 255, false, true);
593:
594: cx->memory = IOMemoryDescriptor::withAddress((void *)buffer,
595: length,
596: kIODirectionIn);
597: req->setPointers( cx->memory, length, false );
598:
599: req->setTimeout( 1000 );
600:
601: result = simpleSynchIO(cx);
602:
603: deleteContext(cx);
604:
605: return(result);
606: }
607:
608: IOReturn
609: IOSCSICDDrive::readTheQSubcode(struct qSubcode *buffer)
610: {
611: const UInt8 qBufLen = 16;
612: IOReturn result;
613: UInt8 *tempBuf;
614:
615: bzero(buffer,sizeof(struct qSubcode));
616:
617: /* Get a buffer for the returned data: */
618:
619: result = allocateTempBuffer(&tempBuf,qBufLen);
620: if (result != kIOReturnSuccess) {
621: return(kIOReturnNoMemory);
622: }
623:
624: result = readSubchannel(tempBuf,qBufLen,0, IORSCcdb::kCurrentPosition);
625:
626: if ((result == kIOReturnSuccess) && ((tempBuf[5] & 0xf0) == 0x10)) { /* we got the data */
627: buffer->type = (trackType)(tempBuf[ 5] & 0x0f);
628: buffer->track = tempBuf[ 6];
629: buffer->index = tempBuf[ 7];
630: buffer->absAddress = tempBuf[ 9] << 16 |
631: tempBuf[10] << 8 |
632: tempBuf[11];
633: buffer->relAddress = tempBuf[13] << 16 |
634: tempBuf[14] << 8 |
635: tempBuf[15];
636: }
637:
638: deleteTempBuffer(tempBuf,qBufLen);
639:
640: return(result);
641: }
642:
643: IOReturn
644: IOSCSICDDrive::readTOC(struct rawToc *buffer,UInt32 length,tocFormat format)
645: {
646: struct context *cx;
647: struct IOReadToccdb *c;
648: IOSCSICommand *req;
649: SCSICDBInfo scsiCDB;
650: IOReturn result;
651:
652: cx = allocateContext();
653: if (cx == NULL) {
654: return(kIOReturnNoMemory);
655: }
656:
657: req = cx->scsireq;
658:
659: bzero( &scsiCDB, sizeof(scsiCDB) );
660:
661: c = (struct IOReadToccdb *)scsiCDB.cdb;
662:
663: c->opcode = SOP_READTOC;
664: c->lunbits = 0;
665: if (format == ktocSCSI2MSF) {
666: c->lunbits |= IOReadToccdb::kMSF;
667: }
668: c->reserved1 = 0;
669: c->reserved2 = 0;
670: c->reserved3 = 0;
671: c->reserved4 = 0;
672: c->len_hi = length >> 8;
673: c->len_lo = length & 0xff;
674: c->ctlbyte = 0;
675:
676: switch (format) {
677: case ktocSCSI2MSF :
678: case ktocSCSI2LBA :
679: c->ctlbyte |= IOReadToccdb::kSCSI2;
680: break;
681:
682: case ktocSessionInfo :
683: c->ctlbyte |= IOReadToccdb::kSessionInfo;
684: break;
685:
686: case ktocQLeadin :
687: c->ctlbyte |= IOReadToccdb::kQLeadIn;
688: break;
689: }
690:
691: scsiCDB.cdbLength = 10;
692: req->setCDB( &scsiCDB );
693: req->setPointers(cx->senseDataDesc, 255, false, true);
694:
695: cx->memory = IOMemoryDescriptor::withAddress((void *)buffer,
696: length,
697: kIODirectionIn);
698: req->setPointers( cx->memory, length, false );
699:
700: req->setTimeout( 1000 );
701:
702: result = simpleSynchIO(cx);
703:
704: if ( result == kIOReturnUnderrun ) result = kIOReturnSuccess;
705:
706: deleteContext(cx);
707:
708: return(result);
709: }
710:
711: /* We track media changes so we can:
712: * - set default audio playMode and volume
713: */
714:
715: IOReturn
716: IOSCSICDDrive::reportMediaState(bool *mediaPresent,bool *changed)
717: {
718: IOReturn result;
719: IOReturn internalResult;
720:
721: result = super::reportMediaState(mediaPresent,changed);
722:
723: /**
724: IOLog("%s[IOSCSICDDrive]::reportMediaState; result=%s, changed = %s, present = %s\n",
725: getName(),stringFromReturn(result),*changed ? "Y" : "N", *mediaPresent ? "Y" : "N");
726: **/
727:
728: if ((result == kIOReturnSuccess) && *changed) { /* the media state changed */
729: if (*mediaPresent) { /* new media inserted */
730: internalResult = setDefaultAudioModes();
731: } else { /* media went away */
732: mediaGone();
733: }
734: }
735:
736: /* We don't return the result of our internal operations. But since they
737: * indicate a problem, we probably should report some kind of problem,
738: * or maybe just ignore the media change.
739: */
740:
741: return(result);
742: }
743:
744: IOReturn
745: IOSCSICDDrive::seek(UInt32 lba)
746: {
747: struct context *cx;
748: struct IOSeekcdb *c;
749: IOSCSICommand *req;
750: SCSICDBInfo scsiCDB;
751: IOReturn result;
752:
753: cx = allocateContext();
754: if (cx == NULL) {
755: return(kIOReturnNoMemory);
756: }
757:
758: req = cx->scsireq;
759:
760: bzero( &scsiCDB, sizeof(scsiCDB) );
761:
762: c = (struct IOSeekcdb *)(scsiCDB.cdb);
763:
764: c->opcode = SOP_SEEK;
765: c->lunbits = 0;
766: c->lba_3 = lba >> 24;
767: c->lba_2 = lba >> 16;
768: c->lba_1 = lba >> 8;
769: c->lba_0 = lba & 0xff;
770: c->reserved1 = 0;
771: c->reserved2 = 0;
772: c->reserved3 = 0;
773: c->ctlbyte = 0;
774:
775: scsiCDB.cdbLength = 10;
776: req->setCDB( &scsiCDB );
777: req->setPointers(cx->senseDataDesc, 255, false, true);
778:
779: req->setPointers( cx->memory, 0, false );
780:
781: req->setTimeout( 5000 );
782:
783: result = simpleSynchIO(cx);
784:
785: deleteContext(cx);
786:
787: return(result);
788: }
789:
790: IOReturn
791: IOSCSICDDrive::setAudioStopAddress(positioningType addressType,cdAddress address)
792: {
793: /* We have to stash the stop address locally, because the client often sets
794: * the stop address before providing the start address. We can't send the
795: * stop address to the drive without a valid start address, because the pickup
796: * could be currently over a data track, which would return an error.
797: */
798:
799: _audioStopAddress.type = addressType;
800: _audioStopAddress.address = address;
801:
802: /* If the address is for block=0, we must stop any audio play in progress. */
803:
804: if (addressType == kBlockAddress && address == 0L) { /* stop play */
805: return(doAudioPlayCommand(kAbsoluteTime,0xffffff,kAbsoluteTime,0));
806: } else { /* set new stop addr */
807: return(doAudioPlayCommand(kAbsoluteTime,0xffffff,addressType,address));
808: }
809: }
810:
811: IOReturn
812: IOSCSICDDrive::setDefaultAudioModes(void)
813: {
814: initAudioModes();
815: return(setVolume(_leftVolume,_rightVolume));
816: }
817:
818: struct audioPage {
819: UInt8 pagecode;
820: UInt8 paramlen;
821: UInt8 immed;
822: UInt8 reserved[5];
823: UInt8 leftportchannel;
824: UInt8 leftvolume;
825: UInt8 rightportchannel;
826: UInt8 rightvolume;
827: UInt8 port2channel;
828: UInt8 port2volume;
829: UInt8 port3channel;
830: UInt8 port3volume;
831: };
832:
833: IOReturn
834: IOSCSICDDrive::setVolume(UInt8 leftVolume,UInt8 rightVolume)
835: {
836: struct context *cx;
837: struct IOModeSelectcdb *c;
838: IOSCSICommand *req;
839: SCSICDBInfo scsiCDB;
840: IOReturn result;
841: struct audioPage *page;
842:
843: cx = allocateContext();
844: if (cx == NULL) {
845: return(kIOReturnNoMemory);
846: }
847:
848: req = cx->scsireq;
849:
850: bzero( &scsiCDB, sizeof(scsiCDB) );
851:
852: /* Set up a Mode Select for page 0x0e. We set volume and audioPlay mode. */
853:
854: result = allocateTempBuffer((UInt8 **)(&page),sizeof(struct audioPage));
855: if (result != kIOReturnSuccess) {
856: deleteContext(cx);
857: return(kIOReturnNoMemory);
858: }
859:
860: bzero(page,sizeof(struct audioPage)),
861: page->pagecode = 0x0e;
862: page->paramlen = 0x0e;
863:
864: page->leftportchannel = playModeToDriveBits(_audioPlayMode,kLeft);
865: page->leftvolume = leftVolume;
866: page->rightportchannel = playModeToDriveBits(_audioPlayMode,kRight);
867: page->rightvolume = rightVolume;
868:
869: c = (struct IOModeSelectcdb *)(scsiCDB.cdb);
870:
871: c->opcode = SOP_MODESELECT;
872: c->lunbits = 0;
873: c->reserved1 = 0;
874: c->reserved2 = 0;
875: c->paramlen = sizeof(struct audioPage);
876: c->ctlbyte = 0;
877:
878: // IOLog("%s[IOSCSICDDrive::setVolume\n",getName());
879:
880: scsiCDB.cdbLength = 6;
881: req->setCDB( &scsiCDB );
882: req->setPointers(cx->senseDataDesc, 255, false, true);
883:
884: cx->memory = IOMemoryDescriptor::withAddress((void *)page,
885: c->paramlen,
886: kIODirectionOut);
887: req->setPointers( cx->memory, c->paramlen, true );
888:
889: req->setTimeout( 1000 );
890:
891: result = simpleSynchIO(cx);
892:
893: deleteTempBuffer((UInt8 *)page,sizeof(struct audioPage));
894: deleteContext(cx);
895:
896: if (result == kIOReturnSuccess) { /* only remember settings if they worked */
897: _leftVolume = leftVolume;
898: _rightVolume = rightVolume;
899: }
900:
901: return(result);
902: }
903:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.