FreeBSD/Linux Kernel Cross Reference
sys/iokit/Kernel/IOInterleavedMemoryDescriptor.cpp

     /*
      * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
      *
      * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
      * 
      * This file contains Original Code and/or Modifications of Original Code
      * as defined in and that are subject to the Apple Public Source License
      * Version 2.0 (the 'License'). You may not use this file except in
      * compliance with the License. The rights granted to you under the License
     * may not be used to create, or enable the creation or redistribution of,
     * unlawful or unlicensed copies of an Apple operating system, or to
     * circumvent, violate, or enable the circumvention or violation of, any
     * terms of an Apple operating system software license agreement.
     * 
     * Please obtain a copy of the License at
     * http://www.opensource.apple.com/apsl/ and read it before using this file.
     * 
     * The Original Code and all software distributed under the License are
     * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
     * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
     * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
     * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
     * Please see the License for the specific language governing rights and
     * limitations under the License.
     * 
     * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
     */
    
    #include <IOKit/IOLib.h>
    #include <IOKit/IOInterleavedMemoryDescriptor.h>
    
    #define super IOMemoryDescriptor
    OSDefineMetaClassAndStructors(IOInterleavedMemoryDescriptor, IOMemoryDescriptor)
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    bool IOInterleavedMemoryDescriptor::initWithAddress(
                                      void *      /* address       */ ,
                                      IOByteCount /* withLength    */ ,
                                      IODirection /* withDirection */ )
    {
        return false;
    }
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    bool IOInterleavedMemoryDescriptor::initWithAddress(
                                      vm_address_t /* address       */ ,
                                      IOByteCount  /* withLength    */ ,
                                      IODirection  /* withDirection */ ,
                                      task_t       /* withTask      */ )
    {
        return false;
    }
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    bool IOInterleavedMemoryDescriptor::initWithPhysicalAddress(
                                      IOPhysicalAddress /* address       */ ,
                                      IOByteCount       /* withLength    */ ,
                                      IODirection       /* withDirection */ )
    {
        return false;
    }
    
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    bool IOInterleavedMemoryDescriptor::initWithPhysicalRanges(
                                      IOPhysicalRange * /* ranges        */ ,
                                      UInt32            /* withCount     */ ,
                                      IODirection       /* withDirection */ ,
                                      bool              /* asReference   */ )
    {
        return false;
    }
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    bool IOInterleavedMemoryDescriptor::initWithRanges(
                                      IOVirtualRange * /* ranges        */ ,
                                      UInt32           /* withCount     */ ,
                                      IODirection      /* withDirection */ ,
                                      task_t           /* withTask      */ ,
                                      bool             /* asReference   */ )
    {
        return false;
    }
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    IOInterleavedMemoryDescriptor * IOInterleavedMemoryDescriptor::withCapacity(
                                      UInt32                capacity,
                                      IODirection           direction )
    {
        //
        // Create a new IOInterleavedMemoryDescriptor.  The "buffer" will be made up
        // of several memory descriptors, that are to be chained end-to-end to make up
        // a single memory descriptor.
       //
   
       IOInterleavedMemoryDescriptor * me = new IOInterleavedMemoryDescriptor;
   
       if ( me && !me->initWithCapacity(
                                     /* capacity  */ capacity,
                                     /* direction */ direction ))
       {
               me->release();
               me = 0;
       }
   
       return me;
   }
   
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   
   bool IOInterleavedMemoryDescriptor::initWithCapacity(
                                     UInt32                capacity,
                                     IODirection           direction )
   {
       //
       // Initialize an IOInterleavedMemoryDescriptor. The "buffer" will be made up
       // of several memory descriptors, that are to be chained end-to-end to make up
       // a single memory descriptor.
       //
   
       assert(capacity);
   
       // Ask our superclass' opinion.
       if ( super::init() == false )  return false;
       
       // Initialize our minimal state.
   
       _direction              = direction;
       _length                 = 0;
       _mappings               = 0;
       _tag                    = 0;
       _descriptorCount        = 0;
       _descriptors            = IONew(IOMemoryDescriptor *, capacity);
       _descriptorOffsets      = IONew(IOByteCount, capacity);
       _descriptorLengths      = IONew(IOByteCount, capacity);
   
       if ( (_descriptors == 0) || (_descriptorOffsets == 0) || (_descriptorLengths == 0) )
           return false;
   
       _descriptorCapacity     = capacity;
   
       return true;
   }
   
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   
   void IOInterleavedMemoryDescriptor::clearMemoryDescriptors( IODirection direction )
   {
       UInt32 index;
   
       for ( index = 0; index < _descriptorCount; index++ )
       {
           if ( _descriptorPrepared )
               _descriptors[index]->complete(_direction);
   
           _descriptors[index]->release();
           _descriptors[index] = 0;
   
           _descriptorOffsets[index] = 0;
           _descriptorLengths[index] = 0;
       }
   
       if ( direction != kIODirectionNone )
           _direction = direction;
   
       _descriptorCount = 0;
       _length = 0;
       _mappings = 0;
       _tag = 0;
   
   };
   
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   
   bool IOInterleavedMemoryDescriptor::setMemoryDescriptor(
                                                IOMemoryDescriptor * descriptor,
                                                IOByteCount offset,
                                                IOByteCount length )
   {
       if ( _descriptorPrepared || (_descriptorCount == _descriptorCapacity) )
           return false;
   
       if ( (offset + length) > descriptor->getLength() )
           return false;
   
   //    if ( descriptor->getDirection() != _direction )
   //        return false;
   
       descriptor->retain();
       _descriptors[_descriptorCount] = descriptor;
       _descriptorOffsets[_descriptorCount] = offset;
       _descriptorLengths[_descriptorCount] = length;
   
       _descriptorCount++;
   
       _length += length;
   
       return true;
   }
   
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   
   void IOInterleavedMemoryDescriptor::free()
   {
       //
       // Free all of this object's outstanding resources.
       //
   
       if ( _descriptors )
       {
           for ( unsigned index = 0; index < _descriptorCount; index++ ) 
               _descriptors[index]->release();
   
           if ( _descriptors != 0 )
               IODelete(_descriptors, IOMemoryDescriptor *, _descriptorCapacity);
   
           if ( _descriptorOffsets != 0 )
               IODelete(_descriptorOffsets, IOMemoryDescriptor *, _descriptorCapacity);
   
           if ( _descriptorLengths != 0 )
               IODelete(_descriptorLengths, IOMemoryDescriptor *, _descriptorCapacity);
       }
   
       super::free();
   }
   
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   
   IOReturn IOInterleavedMemoryDescriptor::prepare(IODirection forDirection)
   {
       //
       // Prepare the memory for an I/O transfer.
       //
       // This involves paging in the memory and wiring it down for the duration
       // of the transfer.  The complete() method finishes the processing of the
       // memory after the I/O transfer finishes.
       //
   
       unsigned index;
       IOReturn status = kIOReturnSuccess;
       IOReturn statusUndo;
   
       if ( forDirection == kIODirectionNone )
       {
           forDirection = _direction;
       }
   
       for ( index = 0; index < _descriptorCount; index++ ) 
       {
           status = _descriptors[index]->prepare(forDirection);
           if ( status != kIOReturnSuccess )  break;
       }
   
       if ( status != kIOReturnSuccess )
       {
           for ( unsigned indexUndo = 0; indexUndo < index; indexUndo++ )
           {
               statusUndo = _descriptors[index]->complete(forDirection);
               assert(statusUndo == kIOReturnSuccess);
           }
       }
   
       if ( status == kIOReturnSuccess ) _descriptorPrepared = true;
   
       return status;
   }
   
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   
   IOReturn IOInterleavedMemoryDescriptor::complete(IODirection forDirection)
   {
       //
       // Complete processing of the memory after an I/O transfer finishes.
       //
       // This method shouldn't be called unless a prepare() was previously issued;
       // the prepare() and complete() must occur in pairs, before and after an I/O
       // transfer.
       //
   
       IOReturn status;
       IOReturn statusFinal = kIOReturnSuccess;
   
       if ( forDirection == kIODirectionNone )
       {
           forDirection = _direction;
       }
   
       for ( unsigned index = 0; index < _descriptorCount; index++ ) 
       {
           status = _descriptors[index]->complete(forDirection);
           if ( status != kIOReturnSuccess )  statusFinal = status;
           assert(status == kIOReturnSuccess);
       }
   
       _descriptorPrepared = false;
   
       return statusFinal;
   }
   
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   
   addr64_t IOInterleavedMemoryDescriptor::getPhysicalSegment64( 
                                       IOByteCount   offset, IOByteCount * length )
   {
       //
       // This method returns the physical address of the byte at the given offset
       // into the memory,  and optionally the length of the physically contiguous
       // segment from that offset.
       //
   
       addr64_t pa;
   
       assert(offset <= _length);
   
       for ( unsigned index = 0; index < _descriptorCount; index++ ) 
       {
           if ( offset < _descriptorLengths[index] )
           {
               pa = _descriptors[index]->getPhysicalSegment64(_descriptorOffsets[index] + offset, length);
               if ((_descriptorLengths[index] - offset) < *length) *length = _descriptorLengths[index] - offset;
               return pa;
           }
           offset -= _descriptorLengths[index];
       }
   
       if ( length )  *length = 0;
   
       return 0;
   }
   
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   
   IOPhysicalAddress IOInterleavedMemoryDescriptor::getPhysicalSegment( 
                                       IOByteCount   offset, IOByteCount * length )
   {
       //
       // This method returns the physical address of the byte at the given offset
       // into the memory,  and optionally the length of the physically contiguous
       // segment from that offset.
       //
   
       IOPhysicalAddress pa;
   
       assert(offset <= _length);
   
       for ( unsigned index = 0; index < _descriptorCount; index++ ) 
       {
           if ( offset < _descriptorLengths[index] )
           {
               pa = _descriptors[index]->getPhysicalSegment(_descriptorOffsets[index] + offset, length);
               if ((_descriptorLengths[index] - offset) < *length) *length = _descriptorLengths[index] - offset;
               return pa;
           }
           offset -= _descriptorLengths[index];
       }
   
       if ( length )  *length = 0;
   
       return 0;
   }
   
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   
   IOPhysicalAddress IOInterleavedMemoryDescriptor::getSourceSegment(
                                                          IOByteCount   offset,
                                                          IOByteCount * length )
   {
       //
       // This method returns the physical address of the byte at the given offset
       // into the memory,  and optionally the length of the physically contiguous
       // segment from that offset.
       //
   
       IOPhysicalAddress pa;
   
       assert(offset <= _length);
   
       for ( unsigned index = 0; index < _descriptorCount; index++ ) 
       {
           if ( offset < _descriptorLengths[index] )
           {
               pa = _descriptors[index]->getSourceSegment(_descriptorOffsets[index] + offset, length);
               if ((_descriptorLengths[index] - offset) < *length) *length = _descriptorLengths[index] - offset;
               return pa;
           }
           offset -= _descriptorLengths[index];
       }
   
       if ( length )  *length = 0;
   
       return 0;
   }
   
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   
   void * IOInterleavedMemoryDescriptor::getVirtualSegment( IOByteCount   /* offset */ ,
                                                      IOByteCount * /* length */ )
   {
       return 0;
   }

Cache object: 881116eb1473cbfa58f7eb06c81d78a4