![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOATAHDDriveNub.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOATAHDDrive|
Return to IOATAHDDriveNub.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOATAHDDrive |
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: * IOATAHDDriveNub.cpp
26: *
27: * This subclass implements a relay to a protocol and device-specific
28: * provider.
29: *
30: * HISTORY
31: * Aug 27, 1999 jliu - Created.
32: */
33:
34: #include <IOKit/IOLib.h>
35: #include <IOKit/storage/ata/IOATAHDDriveNub.h>
36: #include <IOKit/storage/ata/IOATAHDDrive.h>
37:
38: #define super IOHDDriveNub
39: OSDefineMetaClassAndStructors( IOATAHDDriveNub, IOHDDriveNub )
40:
41: // --------------------------------------------------------------------------
42: // attach to provider.
43:
44: bool IOATAHDDriveNub::attach(IOService * provider)
45: {
46: if (!super::attach(provider))
47: return false;
48:
49: _provider = OSDynamicCast(IOATAHDDrive, provider);
50: if (_provider == 0) {
51: IOLog("IOATAHDDriveNub: attach; wrong provider type!\n");
52: return false;
53: }
54:
55: return true;
56: }
57:
58: // --------------------------------------------------------------------------
59: // detach from provider.
60:
61: void IOATAHDDriveNub::detach(IOService * provider)
62: {
63: if (_provider == provider)
64: _provider = 0;
65:
66: super::detach(provider);
67: }
68:
69: // --------------------------------------------------------------------------
70: //
71:
72: IOReturn IOATAHDDriveNub::doAsyncReadWrite(IOMemoryDescriptor * buffer,
73: UInt32 block,
74: UInt32 nblks,
75: gdCompletionFunction action,
76: IOService * target,
77: void * param)
78: {
79: return (_provider->doAsyncReadWrite(buffer,
80: block,
81: nblks,
82: action,
83: target,
84: param));
85: }
86:
87: IOReturn IOATAHDDriveNub::doSyncReadWrite(IOMemoryDescriptor *buffer,
88: UInt32 block,UInt32 nblks)
89: {
90: return(kIOReturnUnsupported); //xxx must be implemented!
91: }
92:
93: // --------------------------------------------------------------------------
94: //
95:
96: IOReturn IOATAHDDriveNub::doEjectMedia()
97: {
98: return (_provider->doEjectMedia());
99: }
100:
101: // --------------------------------------------------------------------------
102: //
103:
104: IOReturn IOATAHDDriveNub::doFormatMedia(UInt64 byteCapacity)
105: {
106: return (_provider->doFormatMedia(byteCapacity));
107: }
108:
109: // --------------------------------------------------------------------------
110: //
111:
112: UInt32
113: IOATAHDDriveNub::doGetFormatCapacities(UInt64 * capacities,
114: UInt32 capacitiesMaxCount) const
115: {
116: return (_provider->doGetFormatCapacities(capacities, capacitiesMaxCount));
117: }
118:
119: // --------------------------------------------------------------------------
120: //
121:
122: IOReturn IOATAHDDriveNub::doLockUnlockMedia(bool doLock)
123: {
124: return (_provider->doLockUnlockMedia(doLock));
125: }
126:
127: // --------------------------------------------------------------------------
128: //
129:
130: // --------------------------------------------------------------------------
131: //
132:
133: IOReturn IOATAHDDriveNub::doSynchronizeCache()
134: {
135: return (_provider->doSynchronizeCache());
136: }
137:
138: IOReturn IOATAHDDriveNub::executeCdb(struct cdbParams *params)
139: {
140: return(kIOReturnUnsupported); // n/a for ATA; no cdb concept
141: }
142:
143: // --------------------------------------------------------------------------
144: //
145:
146: char * IOATAHDDriveNub::getVendorString()
147: {
148: return (_provider->getVendorString());
149: }
150:
151: // --------------------------------------------------------------------------
152: //
153:
154: char * IOATAHDDriveNub::getProductString()
155: {
156: return (_provider->getProductString());
157: }
158:
159: // --------------------------------------------------------------------------
160: //
161:
162: char * IOATAHDDriveNub::getRevisionString()
163: {
164: return (_provider->getRevisionString());
165: }
166:
167: // --------------------------------------------------------------------------
168: //
169:
170: char * IOATAHDDriveNub::getAdditionalDeviceInfoString()
171: {
172: return (_provider->getAdditionalDeviceInfoString());
173: }
174:
175: // --------------------------------------------------------------------------
176: //
177:
178: IOReturn IOATAHDDriveNub::reportBlockSize(UInt64 * blockSize)
179: {
180: return (_provider->reportBlockSize(blockSize));
181: }
182:
183: // --------------------------------------------------------------------------
184: //
185:
186: IOReturn IOATAHDDriveNub::reportEjectability(bool * isEjectable)
187: {
188: return (_provider->reportEjectability(isEjectable));
189: }
190:
191: // --------------------------------------------------------------------------
192: //
193:
194: IOReturn IOATAHDDriveNub::reportLockability(bool * isLockable)
195: {
196: return (_provider->reportLockability(isLockable));
197: }
198:
199: // --------------------------------------------------------------------------
200: //
201:
202: IOReturn IOATAHDDriveNub::reportPollRequirements(bool * pollIsRequired,
203: bool * pollIsExpensive)
204: {
205: return (_provider->reportPollRequirements(pollIsRequired,
206: pollIsExpensive));
207: }
208:
209: // --------------------------------------------------------------------------
210: //
211:
212: IOReturn IOATAHDDriveNub::reportMaxReadTransfer(UInt64 blockSize,
213: UInt64 * max)
214: {
215: return (_provider->reportMaxReadTransfer(blockSize, max));
216: }
217:
218: // --------------------------------------------------------------------------
219: //
220:
221: IOReturn IOATAHDDriveNub::reportMaxValidBlock(UInt64 * maxBlock)
222: {
223: return (_provider->reportMaxValidBlock(maxBlock));
224: }
225:
226: // --------------------------------------------------------------------------
227: //
228:
229: IOReturn IOATAHDDriveNub::reportMaxWriteTransfer(UInt64 blockSize,
230: UInt64 * max)
231: {
232: return (_provider->reportMaxWriteTransfer(blockSize, max));
233: }
234:
235: // --------------------------------------------------------------------------
236: //
237:
238: IOReturn IOATAHDDriveNub::reportMediaState(bool * mediaPresent,
239: bool * changed)
240: {
241: return (_provider->reportMediaState(mediaPresent,changed));
242: }
243:
244: // --------------------------------------------------------------------------
245: //
246:
247: IOReturn IOATAHDDriveNub::reportRemovability(bool * isRemovable)
248: {
249: return (_provider->reportRemovability(isRemovable));
250: }
251:
252: // --------------------------------------------------------------------------
253: //
254:
255: IOReturn IOATAHDDriveNub::reportWriteProtection(bool * isWriteProtected)
256: {
257: return (_provider->reportWriteProtection(isWriteProtected));
258: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.