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#ifndef _IOMEMORYCURSOR_H 29#define _IOMEMORYCURSOR_H 30 31#include <libkern/c++/OSObject.h> 32#include <IOKit/IOTypes.h> 33 34class IOMemoryDescriptor; 35 36/**************************** class IOMemoryCursor ***************************/ 37 38/*! 39 @class IOMemoryCursor 40 @abstract A mechanism to convert memory references to physical addresses. 41 @discussion The IOMemoryCursor declares the super class that all 42specific memory cursors must inherit from, but a memory cursor can be created without a specific format subclass by just providing a segment function to the initializers. This class does the difficult stuff of dividing a memory descriptor into a physical scatter/gather list appropriate for the target hardware. 43<br><br> 44 A driver is expected to create a memory cursor and configure it to the limitations of its DMA hardware; for instance the memory cursor used by the FireWire SBP-2 protocol has a maximum physical segment size of 2^16 - 1 but the actual transfer size is unlimited. Thus it would create a cursor with a maxSegmentSize of 65535 and a maxTransfer size of UINT_MAX. It would also provide a SegmentFunction that can output a pagelist entry. 45<br><br> 46Below is the simplest example of a SegmentFunction:<br> 47void IONaturalMemoryCursor::outputSegment(PhysicalSegment segment,<br> 48 void * outSegments,<br> 49 UInt32 outSegmentIndex)<br> 50{<br> 51 ((PhysicalSegment *) outSegments)[outSegmentIndex] = segment;<br> 52} 53 54*/ 55class IOMemoryCursor : public OSObject 56{ 57 OSDeclareDefaultStructors(IOMemoryCursor) 58 59public: 60/*! 61 @typedef PhysicalSegment 62 @discussion A physical address/length pair. 63*/ 64 struct PhysicalSegment 65 { 66 IOPhysicalAddress location; 67 IOPhysicalLength length; 68 }; 69 70/*! @defined IOPhysicalSegment 71 @discussion Backward compatibility define for the old non-class scoped type definition. See IOMemoryCursor::PhysicalSegment 72*/ 73#define IOPhysicalSegment IOMemoryCursor::PhysicalSegment 74 75/*! 76 @typedef SegmentFunction 77 @discussion Pointer to a C function that outputs a single physical segment to an element in the array as defined by the segments and segmentIndex parameters. 78 @param segment The physical address and length that is next to be output. 79 @param segments Base of the output vector of DMA address length pairs. 80 @param segmentIndex Index to output 'segment' in the 'segments' array. 81*/ 82 typedef void (*SegmentFunction)(PhysicalSegment segment, 83 void * segments, 84 UInt32 segmentIndex); 85 86/*! @defined OutputSegmentFunc 87 @discussion Backward compatibility define for the old non-class scoped type definition. See IOMemoryCursor::SegmentFunction */ 88#define OutputSegmentFunc IOMemoryCursor::SegmentFunction 89 90protected: 91/*! @var outSeg The action method called when an event has been delivered */ 92 SegmentFunction outSeg; 93 94/*! @var maxSegmentSize Maximum size of one segment in a scatter/gather list */ 95 IOPhysicalLength maxSegmentSize; 96 97/*! @var maxTransferSize 98 Maximum size of a transfer that this memory cursor is allowed to generate */ 99 IOPhysicalLength maxTransferSize; 100 101/*! @var alignMask 102 Currently unused. Reserved for automated aligment restriction code. */ 103 IOPhysicalLength alignMask; 104 105public: 106/*! @function withSpecification 107 @abstract Creates and initializes an IOMemoryCursor in one operation. 108 @discussion Factory function to create and initialize an IOMemoryCursor in one operation. For more information, see IOMemoryCursor::initWithSpecification. 109 @param outSegFunc SegmentFunction to call to output one physical segment. 110 @param maxSegmentSize Maximum allowable size for one segment. Defaults to 0. 111 @param maxTransferSize Maximum size of an entire transfer. Defaults to 0 indicating no maximum. 112 @param alignment Alignment restrictions on output physical addresses. Not currently implemented. Defaults to single byte alignment. 113 @result Returns a new memory cursor if successfully created and initialized, 0 otherwise. 114*/ 115 static IOMemoryCursor * 116 withSpecification(SegmentFunction outSegFunc, 117 IOPhysicalLength maxSegmentSize = 0, 118 IOPhysicalLength maxTransferSize = 0, 119 IOPhysicalLength alignment = 1); 120 121/*! @function initWithSpecification 122 @abstract Primary initializer for the IOMemoryCursor class. 123 @param outSegFunc SegmentFunction to call to output one physical segment. 124 @param maxSegmentSize Maximum allowable size for one segment. Defaults to 0. 125 @param maxTransferSize Maximum size of an entire transfer. Defaults to 0 indicating no maximum. 126 @param alignment Alignment restrictions on output physical addresses. Not currently implemented. Defaults to single byte alignment. 127 @result Returns true if the inherited classes and this instance initialize 128successfully. 129*/ 130 virtual bool initWithSpecification(SegmentFunction outSegFunc, 131 IOPhysicalLength maxSegmentSize = 0, 132 IOPhysicalLength maxTransferSize = 0, 133 IOPhysicalLength alignment = 1); 134 135/*! @function genPhysicalSegments 136 @abstract Generates a physical scatter/gather list given a memory descriptor. 137 @discussion Generates a list of physical segments from the given memory descriptor, relative to the current position of the descriptor. 138 @param descriptor IOMemoryDescriptor that describes the data associated with an I/O request. 139 @param fromPosition Starting location of the I/O within a memory descriptor. 140 @param segments Void pointer to base of output physical scatter/gather list. Always passed directly onto the SegmentFunction without interpretation by the cursor. 141 @param maxSegments Maximum number of segments that can be written to segments array. 142 @param maxTransferSize Maximum transfer size is limited to that many bytes, otherwise it defaults to the maximum transfer size specified when the memory cursor was initialized. 143 @param transferSize Pointer to an IOByteCount variable that can contain the total size of the transfer being described. Defaults to 0 indicating that no transfer size need be returned. 144 @result If the descriptor is exhausted of memory, a zero is returned, otherwise the number of segments that were filled in is returned. 145*/ 146 virtual UInt32 genPhysicalSegments( 147 IOMemoryDescriptor *descriptor, 148 IOByteCount fromPosition, 149 void * segments, 150 UInt32 maxSegments, 151 UInt32 maxTransferSize = 0, 152 IOByteCount *transferSize = 0); 153}; 154 155/************************ class IONaturalMemoryCursor ************************/ 156 157 158/*! 159 @class IONaturalMemoryCursor 160 @abstract An IOMemoryCursor subclass that outputs a vector of PhysicalSegments in the natural byte orientation for the CPU. 161 @discussion The IONaturalMemoryCursor would be used when it is too difficult to safely describe a SegmentFunction that is more appropriate for your hardware. This cursor just outputs an array of PhysicalSegments. 162*/ 163class IONaturalMemoryCursor : public IOMemoryCursor 164{ 165 OSDeclareDefaultStructors(IONaturalMemoryCursor) 166 167public: 168/*! @function outputSegment 169 @abstract Outputs the given segment into the output segments array in natural byte order. 170 @param segment The physical address and length that is next to be output. 171 @param segments Base of the output vector of DMA address length pairs. 172 @param segmentIndex Index to output 'segment' in the 'segments' array. 173*/ 174 static void outputSegment(PhysicalSegment segment, 175 void * segments, 176 UInt32 segmentIndex); 177 178/*! @defined naturalOutputSegment 179 @discussion Backward compatibility define for the old global function definition. See IONaturalMemoryCursor::outputSegment. 180*/ 181#define naturalOutputSegment IONaturalMemoryCursor::outputSegment 182 183/*! @function withSpecification 184 @abstract Creates and initializes an IONaturalMemoryCursor in one operation. 185 @discussion Factory function to create and initialize an IONaturalMemoryCursor in one operation. For more information, see IONaturalMemoryCursor::initWithSpecification. 186 @param maxSegmentSize Maximum allowable size for one segment. Defaults to 0. 187 @param maxTransferSize Maximum size of an entire transfer. Defaults to 0 indicating no maximum. 188 @param alignment Alignment restrictions on output physical addresses. Not currently implemented. Defaults to single byte alignment. 189 @result Returns a new memory cursor if successfully created and initialized, 0 otherwise. 190*/ 191 static IONaturalMemoryCursor * 192 withSpecification(IOPhysicalLength maxSegmentSize, 193 IOPhysicalLength maxTransferSize, 194 IOPhysicalLength alignment = 1); 195 196/*! @function initWithSpecification 197 @abstract Primary initializer for the IONaturalMemoryCursor class. 198 @param maxSegmentSize Maximum allowable size for one segment. Defaults to 0. 199 @param maxTransferSize Maximum size of an entire transfer. Defaults to 0 indicating no maximum. 200 @param alignment Alignment restrictions on output physical addresses. Not currently implemented. Defaults to single byte alignment. 201 @result Returns true if the inherited classes and this instance initialize successfully. 202*/ 203 virtual bool initWithSpecification(IOPhysicalLength maxSegmentSize, 204 IOPhysicalLength maxTransferSize, 205 IOPhysicalLength alignment = 1); 206 207 208/*! @function getPhysicalSegments 209 @abstract Generates a CPU natural physical scatter/gather list given a memory descriptor. 210 @discussion Generates a list of physical segments from the given memory descriptor, relative to the current position of the descriptor. Wraps IOMemoryCursor::genPhysicalSegments. 211 @param descriptor IOMemoryDescriptor that describes the data associated with an I/O request. 212 @param fromPosition Starting location of the I/O within a memory descriptor. 213 @param segments Pointer to an array of IOMemoryCursor::PhysicalSegments for the output physical scatter/gather list. 214 @param maxSegments Maximum number of segments that can be written to segments array. 215 @param inMaxTransferSize Maximum transfer size is limited to that many bytes, otherwise it defaults to the maximum transfer size specified when the memory cursor was initialized. 216 @param transferSize Pointer to an IOByteCount variable that can contain the total size of the transfer being described. Defaults to 0 indicating that no transfer size need be returned. 217 @result If the descriptor is exhausted of memory, a zero is returned, otherwise the number of segments that were filled in is returned. 218*/ 219 virtual UInt32 getPhysicalSegments(IOMemoryDescriptor *descriptor, 220 IOByteCount fromPosition, 221 PhysicalSegment *segments, 222 UInt32 maxSegments, 223 UInt32 inMaxTransferSize = 0, 224 IOByteCount *transferSize = 0) 225 { 226 return genPhysicalSegments(descriptor, fromPosition, segments, 227 maxSegments, inMaxTransferSize, transferSize); 228 } 229}; 230 231/************************** class IOBigMemoryCursor **************************/ 232 233/*! 234 @class IOBigMemoryCursor 235 @abstract An IOMemoryCursor subclass that outputs a vector of PhysicalSegments in the big endian byte order. 236 @discussion The IOBigMemoryCursor would be used when the DMA hardware requires a big endian address and length pair. This cursor outputs an array of PhysicalSegments that are encoded in big-endian format. 237*/ 238class IOBigMemoryCursor : public IOMemoryCursor 239{ 240 OSDeclareDefaultStructors(IOBigMemoryCursor) 241 242public: 243/*! @function outputSegment 244 @abstract Outputs the given segment into the output segments array in big endian byte order. 245 @param segment The physical address and length that is next to be output. 246 @param segments Base of the output vector of DMA address length pairs. 247 @param segmentIndex Index to output 'segment' in the 'segments' array. 248*/ 249 static void outputSegment(PhysicalSegment segment, 250 void * segments, 251 UInt32 segmentIndex); 252 253/*! @defined bigOutputSegment 254 @discussion Backward compatibility define for the old global function definition. See IOBigMemoryCursor::outputSegment 255*/ 256#define bigOutputSegment IOBigMemoryCursor::outputSegment 257 258/*! @function withSpecification 259 @abstract Creates and initializes an IOBigMemoryCursor in one operation. 260 @discussion Factory function to create and initialize an IOBigMemoryCursor in one operation. See also IOBigMemoryCursor::initWithSpecification. 261 @param maxSegmentSize Maximum allowable size for one segment. Defaults to 0. 262 @param maxTransferSize Maximum size of an entire transfer. Defaults to 0 indicating no maximum. 263 @param alignment Alignment restrictions on output physical addresses. Not currently implemented. Defaults to single byte alignment. 264 @result Returns a new memory cursor if successfully created and initialized, 0 otherwise. 265*/ 266 static IOBigMemoryCursor * 267 withSpecification(IOPhysicalLength maxSegmentSize, 268 IOPhysicalLength maxTransferSize, 269 IOPhysicalLength alignment = 1); 270 271/*! @function initWithSpecification 272 @abstract Primary initializer for the IOBigMemoryCursor class. 273 @param maxSegmentSize Maximum allowable size for one segment. Defaults to 0. 274 @param maxTransferSize Maximum size of an entire transfer. Defaults to 0 indicating no maximum. 275 @param alignment Alignment restrictions on output physical addresses. Not currently implemented. Defaults to single byte alignment. 276 @result Returns true if the inherited classes and this instance initialize 277successfully. 278*/ 279 virtual bool initWithSpecification(IOPhysicalLength maxSegmentSize, 280 IOPhysicalLength maxTransferSize, 281 IOPhysicalLength alignment = 1); 282 283 284/*! @function getPhysicalSegments 285 @abstract Generates a big endian physical scatter/gather list given a memory descriptor. 286 @discussion Generates a list of physical segments from the given memory descriptor, relative to the current position of the descriptor. Wraps IOMemoryCursor::genPhysicalSegments. 287 @param descriptor IOMemoryDescriptor that describes the data associated with an I/O request. 288 @param fromPosition Starting location of the I/O within a memory descriptor. 289 @param segments Pointer to an array of IOMemoryCursor::PhysicalSegments for the output physical scatter/gather list. 290 @param maxSegments Maximum number of segments that can be written to segments array. 291 @param inMaxTransferSize Maximum transfer size is limited to that many bytes, otherwise it defaults to the maximum transfer size specified when the memory cursor was initialized. 292 @param transferSize Pointer to an IOByteCount variable that can contain the total size of the transfer being described. Defaults to 0 indicating that no transfer size need be returned. 293 @result If the descriptor is exhausted of memory, a zero is returned, otherwise the number of segments that were filled in is returned. 294*/ 295 virtual UInt32 getPhysicalSegments(IOMemoryDescriptor * descriptor, 296 IOByteCount fromPosition, 297 PhysicalSegment * segments, 298 UInt32 maxSegments, 299 UInt32 inMaxTransferSize = 0, 300 IOByteCount * transferSize = 0) 301 { 302 return genPhysicalSegments(descriptor, fromPosition, segments, 303 maxSegments, inMaxTransferSize, transferSize); 304 } 305}; 306 307/************************* class IOLittleMemoryCursor ************************/ 308 309/*! 310 @class IOLittleMemoryCursor 311 @abstract An IOMemoryCursor subclass that outputs a vector of PhysicalSegments in the little endian byte order. 312 @discussion The IOLittleMemoryCursor would be used when the DMA hardware requires a little endian address and length pair. This cursor outputs an array of PhysicalSegments that are encoded in little endian format. 313*/ 314class IOLittleMemoryCursor : public IOMemoryCursor 315{ 316 OSDeclareDefaultStructors(IOLittleMemoryCursor) 317 318public: 319/*! @function outputSegment 320 @abstract Outputs the given segment into the output segments array in little endian byte order. 321 @param segment The physical address and length that is next to be output. 322 @param segments Base of the output vector of DMA address length pairs. 323 @param segmentIndex Index to output 'segment' in the 'segments' array. 324*/ 325 static void outputSegment(PhysicalSegment segment, 326 void * segments, 327 UInt32 segmentIndex); 328 329/*! @defined littleOutputSegment 330 @discussion Backward compatibility define for the old global function definition. See also IOLittleMemoryCursor::outputSegment. */ 331#define littleOutputSegment IOLittleMemoryCursor::outputSegment 332 333/*! @function withSpecification 334 @abstract Creates and initializes an IOLittleMemoryCursor in one operation. 335 @discussion Factory function to create and initialize an IOLittleMemoryCursor in one operation. See also IOLittleMemoryCursor::initWithSpecification. 336 @param maxSegmentSize Maximum allowable size for one segment. Defaults to 0. 337 @param maxTransferSize Maximum size of an entire transfer. Defaults to 0 indicating no maximum. 338 @param alignment Alignment restrictions on output physical addresses. Not currently implemented. Defaults to single byte alignment. 339 @result Returns a new memory cursor if successfully created and initialized, 0 otherwise. 340*/ 341 static IOLittleMemoryCursor * 342 withSpecification(IOPhysicalLength maxSegmentSize, 343 IOPhysicalLength maxTransferSize, 344 IOPhysicalLength alignment = 1); 345 346/*! @function initWithSpecification 347 @abstract Primary initializer for the IOLittleMemoryCursor class. 348 @param maxSegmentSize Maximum allowable size for one segment. Defaults to 0. 349 @param maxTransferSize Maximum size of an entire transfer. Defaults to 0 indicating no maximum. 350 @param alignment Alignment restrictions on output physical addresses. Not currently implemented. Defaults to single byte alignment. 351 @result Returns true if the inherited classes and this instance initialize successfully. 352*/ 353 virtual bool initWithSpecification(IOPhysicalLength maxSegmentSize, 354 IOPhysicalLength maxTransferSize, 355 IOPhysicalLength alignment = 1); 356 357 358/*! @function getPhysicalSegments 359 @abstract Generates a little endian physical scatter/gather list given a memory descriptor. 360 @discussion Generates a list of physical segments from the given memory descriptor, relative to the current position of the descriptor. Wraps IOMemoryCursor::genPhysicalSegments. 361 @param descriptor IOMemoryDescriptor that describes the data associated with an I/O request. 362 @param fromPosition Starting location of the I/O within a memory descriptor. 363 @param segments Pointer to an array of IOMemoryCursor::PhysicalSegments for the output physical scatter/gather list. 364 @param maxSegments Maximum number of segments that can be written to segments array. 365 @param inMaxTransferSize Maximum transfer size is limited to that many bytes, otherwise it defaults to the maximum transfer size specified when the memory cursor was initialized. 366 @param transferSize Pointer to an IOByteCount variable that can contain the total size of the transfer being described. Defaults to 0 indicating that no transfer size need be returned. 367 @result If the descriptor is exhausted of memory, a zero is returned, otherwise the number of segments that were filled in is returned. 368*/ 369 virtual UInt32 getPhysicalSegments(IOMemoryDescriptor * descriptor, 370 IOByteCount fromPosition, 371 PhysicalSegment * segments, 372 UInt32 maxSegments, 373 UInt32 inMaxTransferSize = 0, 374 IOByteCount * transferSize = 0) 375 { 376 return genPhysicalSegments(descriptor, fromPosition, segments, 377 maxSegments, inMaxTransferSize, transferSize); 378 } 379}; 380 381/************************* class IODBDMAMemoryCursor *************************/ 382 383#if defined(__ppc__) 384 385struct IODBDMADescriptor; 386 387/*! 388 @class IODBDMAMemoryCursor 389 @abstract An IOMemoryCursor subclass that outputs a vector of DBDMA descriptors where the address and length are filled in. 390 @discussion The IODBDMAMemoryCursor would be used when the DBDMA hardware is available for the device for that will use an instance of this cursor. 391*/ 392class IODBDMAMemoryCursor : public IOMemoryCursor 393{ 394 OSDeclareDefaultStructors(IODBDMAMemoryCursor) 395 396public: 397/*! @function outputSegment 398 @abstract Outpust the given segment into the output segments array in address and length fields of an DBDMA descriptor. 399 @param segment The physical address and length that is next to be output. 400 @param segments Base of the output vector of DMA address length pairs. 401 @param segmentIndex Index to output 'segment' in the 'segments' array. 402*/ 403 static void outputSegment(PhysicalSegment segment, 404 void * segments, 405 UInt32 segmentIndex); 406 407/*! @defined dbdmaOutputSegment 408 @discussion Backward compatibility define for the old global function definition. See IODBDMAMemoryCursor::outputSegment. */ 409#define dbdmaOutputSegment IODBDMAMemoryCursor::outputSegment 410 411/*! @function withSpecification 412 @abstract Creates and initializes an IODBDMAMemoryCursor in one operation. 413 @discussion Factory function to create and initialize an IODBDMAMemoryCursor in one operation. See also IODBDMAMemoryCursor::initWithSpecification. 414 @param maxSegmentSize Maximum allowable size for one segment. Defaults to 0. 415 @param maxTransferSize Maximum size of an entire transfer. Defaults to 0 indicating no maximum. 416 @param alignment Alignment restrictions on output physical addresses. Not currently implemented. Defaults to single byte alignment. 417 @result Returns a new memory cursor if successfully created and initialized, 0 otherwise. 418*/ 419 static IODBDMAMemoryCursor * 420 withSpecification(IOPhysicalLength maxSegmentSize, 421 IOPhysicalLength maxTransferSize, 422 IOPhysicalLength alignment = 1); 423 424/*! @function initWithSpecification 425 @abstract Primary initializer for the IODBDMAMemoryCursor class. 426 @param maxSegmentSize Maximum allowable size for one segment. Defaults to 0. 427 @param maxTransferSize Maximum size of an entire transfer. Defaults to 0 indicating no maximum. 428 @param alignment Alignment restrictions on output physical addresses. Not currently implemented. Defaults to single byte alignment. 429 @result Returns true if the inherited classes and this instance initialize successfully. 430*/ 431 virtual bool initWithSpecification(IOPhysicalLength maxSegmentSize, 432 IOPhysicalLength maxTransferSize, 433 IOPhysicalLength alignment = 1); 434 435 436/*! @function getPhysicalSegments 437 @abstract Generates a DBDMA physical scatter/gather list given a memory descriptor. 438 @discussion Generates a list of DBDMA descriptors where the address and length fields are filled in appropriately. But the client is expected to fill in the rest of the DBDMA descriptor as is appropriate for their particular hardware. Wraps IOMemoryCursor::genPhysicalSegments. 439 @param descriptor IOMemoryDescriptor that describes the data associated with an I/O request. 440 @param fromPosition Starting location of the I/O within a memory descriptor. 441 @param segments Pointer to an array of DBDMA descriptors for the output physical scatter/gather list. Be warned no room is left for a preamble in the output array. 'segments' should point to the first memory description slot in a DBDMA command. 442 @param maxSegments Maximum number of segments that can be written to the DBDMA descriptor table. 443 @param inMaxTransferSize Maximum transfer size is limited to that many bytes, otherwise it defaults to the maximum transfer size specified when the memory cursor was initialized. 444 @param transferSize Pointer to an IOByteCount variable that can contain the total size of the transfer being described. Defaults to 0 indicating that no transfer size need be returned. 445 @result If the descriptor is exhausted of memory, a zero is returned, otherwise the number of segments that were filled in is returned. 446*/ 447 virtual UInt32 getPhysicalSegments(IOMemoryDescriptor * descriptor, 448 IOByteCount fromPosition, 449 IODBDMADescriptor * segments, 450 UInt32 maxSegments, 451 UInt32 inMaxTransferSize = 0, 452 IOByteCount * transferSize = 0) 453 { 454 return genPhysicalSegments(descriptor, fromPosition, segments, 455 maxSegments, inMaxTransferSize, transferSize); 456 } 457}; 458 459#endif /* defined(__ppc__) */ 460 461#endif /* !_IOMEMORYCURSOR_H */ 462 463