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