![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOSCSICDDriveNub.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 IOSCSICDDriveNub.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: #include <IOKit/IOMemoryDescriptor.h>
23: #include <IOKit/IOLib.h>
24: #include <IOKit/storage/scsi/IOSCSICDDriveNub.h>
25: #include <IOKit/storage/scsi/IOSCSICDDrive.h>
26:
27: #define super IOCDDriveNub
28: OSDefineMetaClassAndStructors(IOSCSICDDriveNub,IOCDDriveNub)
29:
30: bool
31: IOSCSICDDriveNub::attach(IOService * provider)
32: {
33: if (!super::attach(provider)) {
34: return(false);
35: }
36:
37: _provider = OSDynamicCast(IOSCSICDDrive,provider);
38: if (_provider == NULL) {
39: return(false);
40: } else {
41: return(true);
42: }
43: }
44:
45: IOReturn
46: IOSCSICDDriveNub::audioPlay(positioningType addressType,cdAddress address,
47: audioPlayMode mode)
48: {
49: return(_provider->audioPlay(addressType,address,mode));
50: }
51:
52: IOReturn
53: IOSCSICDDriveNub::audioPause(bool pause)
54: {
55: return(_provider->audioPause(pause));
56: }
57:
58: IOReturn
59: IOSCSICDDriveNub::audioScan(positioningType addressType,cdAddress address,
60: bool reverse)
61: {
62: return(_provider->audioScan(addressType,address,reverse));
63: }
64:
65: IOReturn
66: IOSCSICDDriveNub::audioTrackSearch(positioningType addressType,cdAddress address,
67: bool startPlay,audioPlayMode mode)
68: {
69: return(_provider->audioTrackSearch(addressType,address,startPlay,mode));
70: }
71:
72: IOReturn
73: IOSCSICDDriveNub::doAsyncReadWrite(IOMemoryDescriptor *buffer,
74: UInt32 block,UInt32 nblks,
75: gdCompletionFunction action,
76: IOService *target,void *param)
77: {
78: IOReturn result;
79: /// char *bp;
80: // int bytes;
81:
82: if (buffer->getDirection() == kIODirectionOut) {
83: return(kIOReturnNotWritable);
84: }
85:
86: // bp = (char *)buffer->getVirtualAddress();
87:
88: result = _provider->doAsyncReadWrite(buffer,block,nblks,action,target,param);
89:
90: // bytes = nblks * 2048;
91: // IOLog("--blk %04d, %04d blks (%04d bytes):\n",(int)block,(int)nblks,bytes);
92: /// dump(bp,32 /*bytes*/);
93: /// IOLog("\n");
94:
95: return(result);
96: }
97:
98: IOReturn
99: IOSCSICDDriveNub::doSyncReadWrite(IOMemoryDescriptor *buffer,UInt32 block,UInt32 nblks)
100: {
101: if (buffer->getDirection() == kIODirectionOut) {
102: return(kIOReturnNotWritable);
103: }
104:
105: return(_provider->doSyncReadWrite(buffer,block,nblks));
106: }
107:
108: #define isprint(c) (c > 0x20)
109:
110: void
111: IOSCSICDDriveNub::dump(char *buf,int count)
112: {
113: static char string[17] = "xxxxxxxxxxxxxxxx";
114:
115: short i;
116: char c;
117: char *cp;
118:
119: if (!count) return;
120:
121: i = 0;
122: cp = buf;
123: do {
124: c = *cp;
125: IOLog("%02x ",(c & 0xff));
126: c &= 0x7f;
127: string[i % 16] = (isprint(c) || (c == ' ')) ? c : '.';
128: if ((i % 16)==15)
129: IOLog("%s\n",string);
130: cp++; i++;
131: } while (--count);
132:
133: /* pad out for last line */
134: if (i % 16) { /* then a shortie left */
135: string[i % 16] = '\0';
136: while (i % 16) {
137: IOLog(" ");
138: i++;
139: }
140: IOLog("%s\n",string);
141: }
142: }
143:
144: IOReturn
145: IOSCSICDDriveNub::doEjectMedia(void)
146: {
147: return(_provider->doEjectMedia());
148: }
149:
150: IOReturn
151: IOSCSICDDriveNub::doLockUnlockMedia(bool doLock)
152: {
153: return(_provider->doLockUnlockMedia(doLock));
154: }
155:
156: IOReturn
157: IOSCSICDDriveNub::executeCdb(struct cdbParams *params)
158: {
159: return(_provider->executeCdb(params));
160: }
161:
162: IOReturn
163: IOSCSICDDriveNub::getAudioStatus(struct audioStatus *status)
164: {
165: return(_provider->getAudioStatus(status));
166: }
167:
168: char *
169: IOSCSICDDriveNub::getVendorString(void)
170: {
171: return(_provider->getVendorString());
172: }
173:
174: char *
175: IOSCSICDDriveNub::getProductString(void)
176: {
177: return(_provider->getProductString());
178: }
179:
180: char *
181: IOSCSICDDriveNub::getRevisionString(void)
182: {
183: return(_provider->getRevisionString());
184: }
185:
186: char *
187: IOSCSICDDriveNub::getAdditionalDeviceInfoString(void)
188: {
189: return(_provider->getAdditionalDeviceInfoString());
190: }
191:
192: IOReturn
193: IOSCSICDDriveNub::readAudioData(positioningType addressType,cdAddress address,
194: UInt8 blockCount,UInt8 *buffer)
195: {
196: return(_provider->readAudioData(addressType,address,blockCount,buffer));
197: }
198:
199: IOReturn
200: IOSCSICDDriveNub::readAudioSubcodes(positioningType addressType,cdAddress address,
201: UInt8 blockCount,UInt8 *buffer)
202: {
203: return(_provider->readAudioSubcodes(addressType,address,blockCount,buffer));
204: }
205:
206: IOReturn
207: IOSCSICDDriveNub::readAudioVolume(UInt8 *leftVolume,UInt8 *rightVolume)
208: {
209: return(_provider->readAudioVolume(leftVolume,rightVolume));
210: }
211:
212: IOReturn
213: IOSCSICDDriveNub::readAudioWithQSubcode(positioningType addressType,cdAddress address,
214: UInt8 blockCount,UInt8 *buffer)
215: {
216: return(_provider->readAudioWithQSubcode(addressType,address,blockCount,buffer));
217: }
218:
219: IOReturn
220: IOSCSICDDriveNub::readAudioWithAllSubcodes(positioningType addressType,cdAddress address,
221: UInt8 blockCount,UInt8 *buffer)
222: {
223: return(_provider->readAudioWithAllSubcodes(addressType,address,blockCount,buffer));
224: }
225:
226: IOReturn
227: IOSCSICDDriveNub::readHeader(UInt32 blockAddress,struct headerInfo *buffer)
228: {
229: return(_provider->readHeader(blockAddress,buffer));
230: }
231:
232: IOReturn
233: IOSCSICDDriveNub::readISRC(UInt32 track,UInt8 *buffer,bool *found)
234: {
235: return(_provider->readISRC(track,buffer,found));
236: }
237:
238: IOReturn
239: IOSCSICDDriveNub::readMCN(UInt8 *buffer,bool *found)
240: {
241: return(_provider->readMCN(buffer,found));
242: }
243:
244: IOReturn
245: IOSCSICDDriveNub::readQSubcodes(struct qSubcodeTocInfo *buffer,UInt32 bufSize)
246: {
247: return(_provider->readQSubcodes(buffer,bufSize));
248: }
249:
250: IOReturn
251: IOSCSICDDriveNub::readSubcodeBuffer(UInt8 *buffer,bool purge,UInt32 entryCount)
252: {
253: return(_provider->readSubcodeBuffer(buffer,purge,entryCount));
254: }
255:
256: IOReturn
257: IOSCSICDDriveNub::readTheQSubcode(struct qSubcode *buffer)
258: {
259: return(_provider->readTheQSubcode(buffer));
260: }
261:
262: IOReturn
263: IOSCSICDDriveNub::readTOC(struct rawToc *buffer,UInt32 length,tocFormat format)
264: {
265: return(_provider->readTOC(buffer,length,format));
266: }
267:
268: IOReturn
269: IOSCSICDDriveNub::reportBlockSize(UInt64 *blockSize)
270: {
271: return(_provider->reportBlockSize(blockSize));
272: }
273:
274: IOReturn
275: IOSCSICDDriveNub::reportEjectability(bool *isEjectable)
276: {
277: return(_provider->reportEjectability(isEjectable));
278: }
279:
280: IOReturn
281: IOSCSICDDriveNub::reportLockability(bool *isLockable)
282: {
283: return(_provider->reportLockability(isLockable));
284: }
285:
286: IOReturn
287: IOSCSICDDriveNub::reportPollRequirements(bool *pollIsRequired,bool *pollIsExpensive)
288: {
289: return(_provider-> reportPollRequirements(pollIsRequired,pollIsExpensive));
290: }
291:
292: IOReturn
293: IOSCSICDDriveNub::reportMaxReadTransfer (UInt64 blockSize,UInt64 *max)
294: {
295: return(_provider->reportMaxReadTransfer(blockSize,max));
296: }
297:
298: IOReturn
299: IOSCSICDDriveNub::reportMediaState(bool *mediaPresent,bool *changed)
300: {
301: return(_provider-> reportMediaState(mediaPresent,changed));
302: }
303:
304: IOReturn
305: IOSCSICDDriveNub::reportRemovability(bool *isRemovable)
306: {
307: return(_provider->reportRemovability(isRemovable));
308: }
309:
310: IOReturn
311: IOSCSICDDriveNub::reportMaxValidBlock(UInt64 *maxBlock)
312: {
313: return(_provider->reportMaxValidBlock(maxBlock));
314: }
315:
316: IOReturn
317: IOSCSICDDriveNub::setAudioStopAddress(positioningType addressType,cdAddress address)
318: {
319: return(_provider->setAudioStopAddress(addressType,address));
320: }
321:
322: IOReturn
323: IOSCSICDDriveNub::setVolume(UInt8 leftVolume,UInt8 rightVolume)
324: {
325: return(_provider->setVolume(leftVolume,rightVolume));
326: }
327:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.