1 /* 2 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28 29 #include <IOKit/IOLib.h> 30 #include <IOKit/IOInterleavedMemoryDescriptor.h> 31 32 #define super IOMemoryDescriptor 33 OSDefineMetaClassAndStructors(IOInterleavedMemoryDescriptor, IOMemoryDescriptor) 34 35 IOInterleavedMemoryDescriptor * IOInterleavedMemoryDescriptor::withCapacity( 36 IOByteCount capacity, 37 IODirection direction ) 38 { 39 // 40 // Create a new IOInterleavedMemoryDescriptor. The "buffer" will be made up 41 // of several memory descriptors, that are to be chained end-to-end to make up 42 // a single memory descriptor. 43 // 44 45 IOInterleavedMemoryDescriptor * me = new IOInterleavedMemoryDescriptor; 46 47 if ( me && !me->initWithCapacity( 48 /* capacity */ capacity, 49 /* direction */ direction )) 50 { 51 me->release(); 52 me = 0; 53 } 54 55 return me; 56 } 57 58 bool IOInterleavedMemoryDescriptor::initWithCapacity( 59 IOByteCount capacity, 60 IODirection direction ) 61 { 62 // 63 // Initialize an IOInterleavedMemoryDescriptor. The "buffer" will be made up 64 // of several memory descriptors, that are to be chained end-to-end to make up 65 // a single memory descriptor. 66 // 67 68 assert(capacity); 69 70 // Ask our superclass' opinion. 71 if ( super::init() == false ) return false; 72 73 // Initialize our minimal state. 74 75 _flags = direction; 76 #ifndef __LP64__ 77 _direction = (IODirection) (_flags & kIOMemoryDirectionMask); 78 #endif /* !__LP64__ */ 79 _length = 0; 80 _mappings = 0; 81 _tag = 0; 82 _descriptorCount = 0; 83 _descriptors = IONew(IOMemoryDescriptor *, capacity); 84 _descriptorOffsets = IONew(IOByteCount, capacity); 85 _descriptorLengths = IONew(IOByteCount, capacity); 86 87 if ( (_descriptors == 0) || (_descriptorOffsets == 0) || (_descriptorLengths == 0) ) 88 return false; 89 90 _descriptorCapacity = capacity; 91 92 return true; 93 } 94 95 void IOInterleavedMemoryDescriptor::clearMemoryDescriptors( IODirection direction ) 96 { 97 UInt32 index; 98 99 for ( index = 0; index < _descriptorCount; index++ ) 100 { 101 if ( _descriptorPrepared ) 102 _descriptors[index]->complete(getDirection()); 103 104 _descriptors[index]->release(); 105 _descriptors[index] = 0; 106 107 _descriptorOffsets[index] = 0; 108 _descriptorLengths[index] = 0; 109 } 110 111 if ( direction != kIODirectionNone ) 112 { 113 _flags = (_flags & ~kIOMemoryDirectionMask) | direction; 114 #ifndef __LP64__ 115 _direction = (IODirection) (_flags & kIOMemoryDirectionMask); 116 #endif /* !__LP64__ */ 117 } 118 119 _descriptorCount = 0; 120 _length = 0; 121 _mappings = 0; 122 _tag = 0; 123 124 }; 125 126 bool IOInterleavedMemoryDescriptor::setMemoryDescriptor( 127 IOMemoryDescriptor * descriptor, 128 IOByteCount offset, 129 IOByteCount length ) 130 { 131 if ( _descriptorPrepared || (_descriptorCount == _descriptorCapacity) ) 132 return false; 133 134 if ( (offset + length) > descriptor->getLength() ) 135 return false; 136 137 // if ( descriptor->getDirection() != getDirection() ) 138 // return false; 139 140 descriptor->retain(); 141 _descriptors[_descriptorCount] = descriptor; 142 _descriptorOffsets[_descriptorCount] = offset; 143 _descriptorLengths[_descriptorCount] = length; 144 145 _descriptorCount++; 146 147 _length += length; 148 149 return true; 150 } 151 152 void IOInterleavedMemoryDescriptor::free() 153 { 154 // 155 // Free all of this object's outstanding resources. 156 // 157 158 if ( _descriptors ) 159 { 160 for ( unsigned index = 0; index < _descriptorCount; index++ ) 161 _descriptors[index]->release(); 162 163 if ( _descriptors != 0 ) 164 IODelete(_descriptors, IOMemoryDescriptor *, _descriptorCapacity); 165 166 if ( _descriptorOffsets != 0 ) 167 IODelete(_descriptorOffsets, IOMemoryDescriptor *, _descriptorCapacity); 168 169 if ( _descriptorLengths != 0 ) 170 IODelete(_descriptorLengths, IOMemoryDescriptor *, _descriptorCapacity); 171 } 172 173 super::free(); 174 } 175 176 IOReturn IOInterleavedMemoryDescriptor::prepare(IODirection forDirection) 177 { 178 // 179 // Prepare the memory for an I/O transfer. 180 // 181 // This involves paging in the memory and wiring it down for the duration 182 // of the transfer. The complete() method finishes the processing of the 183 // memory after the I/O transfer finishes. 184 // 185 186 unsigned index; 187 IOReturn status = kIOReturnSuccess; 188 IOReturn statusUndo; 189 190 if ( forDirection == kIODirectionNone ) 191 { 192 forDirection = getDirection(); 193 } 194 195 for ( index = 0; index < _descriptorCount; index++ ) 196 { 197 status = _descriptors[index]->prepare(forDirection); 198 if ( status != kIOReturnSuccess ) break; 199 } 200 201 if ( status != kIOReturnSuccess ) 202 { 203 for ( unsigned indexUndo = 0; indexUndo < index; indexUndo++ ) 204 { 205 statusUndo = _descriptors[index]->complete(forDirection); 206 assert(statusUndo == kIOReturnSuccess); 207 } 208 } 209 210 if ( status == kIOReturnSuccess ) _descriptorPrepared = true; 211 212 return status; 213 } 214 215 IOReturn IOInterleavedMemoryDescriptor::complete(IODirection forDirection) 216 { 217 // 218 // Complete processing of the memory after an I/O transfer finishes. 219 // 220 // This method shouldn't be called unless a prepare() was previously issued; 221 // the prepare() and complete() must occur in pairs, before and after an I/O 222 // transfer. 223 // 224 225 IOReturn status; 226 IOReturn statusFinal = kIOReturnSuccess; 227 228 if ( forDirection == kIODirectionNone ) 229 { 230 forDirection = getDirection(); 231 } 232 233 for ( unsigned index = 0; index < _descriptorCount; index++ ) 234 { 235 status = _descriptors[index]->complete(forDirection); 236 if ( status != kIOReturnSuccess ) statusFinal = status; 237 assert(status == kIOReturnSuccess); 238 } 239 240 _descriptorPrepared = false; 241 242 return statusFinal; 243 } 244 245 addr64_t IOInterleavedMemoryDescriptor::getPhysicalSegment( 246 IOByteCount offset, 247 IOByteCount * length, 248 IOOptionBits options ) 249 { 250 // 251 // This method returns the physical address of the byte at the given offset 252 // into the memory, and optionally the length of the physically contiguous 253 // segment from that offset. 254 // 255 256 addr64_t pa; 257 258 assert(offset <= _length); 259 260 for ( unsigned index = 0; index < _descriptorCount; index++ ) 261 { 262 if ( offset < _descriptorLengths[index] ) 263 { 264 pa = _descriptors[index]->getPhysicalSegment(_descriptorOffsets[index] + offset, length, options); 265 if ((_descriptorLengths[index] - offset) < *length) *length = _descriptorLengths[index] - offset; 266 return pa; 267 } 268 offset -= _descriptorLengths[index]; 269 } 270 271 if ( length ) *length = 0; 272 273 return 0; 274 } 275