![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOMemoryCursor.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Kernel|
Return to IOMemoryCursor.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Kernel |
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: /* IOMemoryCursor.cpp created by wgulland on 1999-3-02 */
23:
24: #include <IOKit/assert.h>
25: #include <IOKit/IOLib.h>
26: #include <IOKit/IOMemoryCursor.h>
27: #include <IOKit/IOMemoryDescriptor.h>
28: #include <libkern/OSByteOrder.h>
29:
30: /**************************** class IOMemoryCursor ***************************/
31:
32: #undef super
33: #define super OSObject
34: OSDefineMetaClassAndStructors(IOMemoryCursor, OSObject)
35:
36: IOMemoryCursor *
37: IOMemoryCursor::withSpecification(SegmentFunction inSegFunc,
38: IOPhysicalLength inMaxSegmentSize,
39: IOPhysicalLength inMaxTransferSize,
40: IOPhysicalLength inAlignment)
41: {
42: IOMemoryCursor * me = new IOMemoryCursor;
43:
44: if (me && !me->initWithSpecification(inSegFunc,
45: inMaxSegmentSize,
46: inMaxTransferSize,
47: inAlignment))
48: {
49: me->release();
50: return 0;
51: }
52:
53: return me;
54: }
55:
56: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
57:
58: bool
59: IOMemoryCursor::initWithSpecification(SegmentFunction inSegFunc,
60: IOPhysicalLength inMaxSegmentSize,
61: IOPhysicalLength inMaxTransferSize,
62: IOPhysicalLength inAlignment)
63: {
64: if (!super::init())
65: return false;
66:
67: if (!inSegFunc)
68: return false;
69:
70: outSeg = inSegFunc;
71: maxSegmentSize = inMaxSegmentSize;
72: if (inMaxTransferSize)
73: maxTransferSize = inMaxTransferSize;
74: else
75: maxTransferSize = (IOPhysicalLength) -1;
76: alignMask = inAlignment - 1;
77: assert(alignMask == 0); // No alignment code yet!
78:
79: return true;
80: }
81:
82: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
83:
84: UInt32
85: IOMemoryCursor::genPhysicalSegments(IOMemoryDescriptor *inDescriptor,
86: IOPhysicalLength fromPosition,
87: void * inSegments,
88: UInt32 inMaxSegments,
89: UInt32 inMaxTransferSize,
90: IOByteCount *outTransferSize)
91: {
92: if (!inDescriptor)
93: return 0;
94:
95: if (!inMaxSegments)
96: return 0;
97:
98: if (!inMaxTransferSize)
99: inMaxTransferSize = maxTransferSize;
100:
101: /*
102: * Iterate over the packet, translating segments where allowed
103: *
104: * If we finished cleanly return number of segments found
105: * and update the position in the descriptor.
106: */
107: UInt curSegIndex = 0;
108: UInt curTransferSize = 0;
109: PhysicalSegment seg;
110:
111: while ((curSegIndex < inMaxSegments)
112: && (curTransferSize < inMaxTransferSize)
113: && (seg.location = inDescriptor->getPhysicalSegment(
114: fromPosition + curTransferSize, &seg.length)))
115: {
116: assert(seg.length);
117: seg.length = min(inMaxTransferSize-curTransferSize,
118: (min(seg.length, maxSegmentSize)));
119: (*outSeg)(seg, inSegments, curSegIndex++);
120: curTransferSize += seg.length;
121: }
122:
123: if (outTransferSize)
124: *outTransferSize = curTransferSize;
125:
126: return curSegIndex;
127: }
128:
129: /************************ class IONaturalMemoryCursor ************************/
130:
131: #undef super
132: #define super IOMemoryCursor
133: OSDefineMetaClassAndStructors(IONaturalMemoryCursor, IOMemoryCursor)
134:
135: void IONaturalMemoryCursor::outputSegment(PhysicalSegment segment,
136: void * outSegments,
137: UInt32 outSegmentIndex)
138: {
139: ((PhysicalSegment *) outSegments)[outSegmentIndex] = segment;
140: }
141:
142: IONaturalMemoryCursor *
143: IONaturalMemoryCursor::withSpecification(IOPhysicalLength inMaxSegmentSize,
144: IOPhysicalLength inMaxTransferSize,
145: IOPhysicalLength inAlignment)
146: {
147: IONaturalMemoryCursor *me = new IONaturalMemoryCursor;
148:
149: if (me && !me->initWithSpecification(inMaxSegmentSize,
150: inMaxTransferSize,
151: inAlignment))
152: {
153: me->release();
154: return 0;
155: }
156:
157: return me;
158: }
159:
160: bool
161: IONaturalMemoryCursor::initWithSpecification(IOPhysicalLength inMaxSegmentSize,
162: IOPhysicalLength inMaxTransferSize,
163: IOPhysicalLength inAlignment)
164: {
165: return super::initWithSpecification(&IONaturalMemoryCursor::outputSegment,
166: inMaxSegmentSize,
167: inMaxTransferSize,
168: inAlignment);
169: }
170:
171: /************************** class IOBigMemoryCursor **************************/
172:
173: #undef super
174: #define super IOMemoryCursor
175: OSDefineMetaClassAndStructors(IOBigMemoryCursor, IOMemoryCursor)
176:
177: void
178: IOBigMemoryCursor::outputSegment(PhysicalSegment inSegment,
179: void * inSegments,
180: UInt32 inSegmentIndex)
181: {
182: IOPhysicalAddress * segment;
183:
184: segment = &((PhysicalSegment *) inSegments)[inSegmentIndex].location;
185: OSWriteBigInt(segment, 0, inSegment.location);
186: OSWriteBigInt(segment, sizeof(IOPhysicalAddress), inSegment.length);
187: }
188:
189: IOBigMemoryCursor *
190: IOBigMemoryCursor::withSpecification(IOPhysicalLength inMaxSegmentSize,
191: IOPhysicalLength inMaxTransferSize,
192: IOPhysicalLength inAlignment)
193: {
194: IOBigMemoryCursor * me = new IOBigMemoryCursor;
195:
196: if (me && !me->initWithSpecification(inMaxSegmentSize,
197: inMaxTransferSize,
198: inAlignment))
199: {
200: me->release();
201: return 0;
202: }
203:
204: return me;
205: }
206:
207: bool
208: IOBigMemoryCursor::initWithSpecification(IOPhysicalLength inMaxSegmentSize,
209: IOPhysicalLength inMaxTransferSize,
210: IOPhysicalLength inAlignment)
211: {
212: return super::initWithSpecification(&IOBigMemoryCursor::outputSegment,
213: inMaxSegmentSize,
214: inMaxTransferSize,
215: inAlignment);
216: }
217:
218: /************************* class IOLittleMemoryCursor ************************/
219:
220: #undef super
221: #define super IOMemoryCursor
222: OSDefineMetaClassAndStructors(IOLittleMemoryCursor, IOMemoryCursor)
223:
224: void
225: IOLittleMemoryCursor::outputSegment(PhysicalSegment inSegment,
226: void * inSegments,
227: UInt32 inSegmentIndex)
228: {
229: IOPhysicalAddress * segment;
230:
231: segment = &((PhysicalSegment *) inSegments)[inSegmentIndex].location;
232: OSWriteLittleInt(segment, 0, inSegment.location);
233: OSWriteLittleInt(segment, sizeof(IOPhysicalAddress), inSegment.length);
234: }
235:
236: IOLittleMemoryCursor *
237: IOLittleMemoryCursor::withSpecification(IOPhysicalLength inMaxSegmentSize,
238: IOPhysicalLength inMaxTransferSize,
239: IOPhysicalLength inAlignment)
240: {
241: IOLittleMemoryCursor * me = new IOLittleMemoryCursor;
242:
243: if (me && !me->initWithSpecification(inMaxSegmentSize,
244: inMaxTransferSize,
245: inAlignment))
246: {
247: me->release();
248: return 0;
249: }
250:
251: return me;
252: }
253:
254: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
255:
256: bool
257: IOLittleMemoryCursor::initWithSpecification(IOPhysicalLength inMaxSegmentSize,
258: IOPhysicalLength inMaxTransferSize,
259: IOPhysicalLength inAlignment)
260: {
261: return super::initWithSpecification(&IOLittleMemoryCursor::outputSegment,
262: inMaxSegmentSize,
263: inMaxTransferSize,
264: inAlignment);
265: }
266:
267: /************************* class IODBDMAMemoryCursor *************************/
268:
269: #if defined(__ppc__)
270:
271: #include <IOKit/ppc/IODBDMA.h>
272:
273: #undef super
274: #define super IOMemoryCursor
275: OSDefineMetaClassAndStructors(IODBDMAMemoryCursor, IOMemoryCursor)
276:
277: void
278: IODBDMAMemoryCursor::outputSegment(PhysicalSegment inSegment,
279: void * inSegments,
280: UInt32 inSegmentIndex)
281: {
282: IODBDMADescriptor *segment;
283:
284: segment = &((IODBDMADescriptor *) inSegments)[inSegmentIndex];
285:
286: // Write location into address field
287: OSWriteSwapInt32((UInt32 *) segment, 4, inSegment.location);
288:
289: // Write count into 1st two bytes of operation field.
290: // DO NOT touch rest of operation field as it should contain a STOP command.
291: OSWriteSwapInt16((UInt16 *) segment, 0, inSegment.length);
292: }
293:
294: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
295:
296: IODBDMAMemoryCursor *
297: IODBDMAMemoryCursor::withSpecification(IOPhysicalLength inMaxSegmentSize,
298: IOPhysicalLength inMaxTransferSize,
299: IOPhysicalLength inAlignment)
300: {
301: IODBDMAMemoryCursor *me = new IODBDMAMemoryCursor;
302:
303: if (me && !me->initWithSpecification(inMaxSegmentSize,
304: inMaxTransferSize,
305: inAlignment))
306: {
307: me->release();
308: return 0;
309: }
310:
311: return me;
312: }
313:
314: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
315:
316: bool
317: IODBDMAMemoryCursor::initWithSpecification(IOPhysicalLength inMaxSegmentSize,
318: IOPhysicalLength inMaxTransferSize,
319: IOPhysicalLength inAlignment)
320: {
321: return super::initWithSpecification(&IODBDMAMemoryCursor::outputSegment,
322: inMaxSegmentSize,
323: inMaxTransferSize,
324: inAlignment);
325: }
326:
327: #endif /* defined(__ppc__) */
328:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.