HalpDmaCommitContiguousMapBuffers

_HALP_DMA_TRANSLATION_ENTRY *__stdcall HalpDmaCommitContiguousMapBuffers(
        _HALP_DMA_ADAPTER_OBJECT *Adapter,
        VOID *VirtualAddress,
        UINT64 PhysicalAddress,
        UINT64 NumberOfPages){
  __int64 v4; 
  _HALP_DMA_TRANSLATION_BUFFER *ContiguousTranslations; 
  UINT64 v8; 
  _HALP_DMA_TRANSLATION_ENTRY *result; 
  _HALP_DMA_TRANSLATION_ENTRY *v10; 
  _HALP_DMA_TRANSLATION_BUFFER *v11; 
  _HALP_DMA_TRANSLATION_ENTRY *v12; 
  unsigned __int8 IsMasterAdapter; 
  _HALP_DMA_TRANSLATION_ENTRY *v14; 
  UINT32 v15; 
  __int64 v16; 
  unsigned __int64 v17; 
  __int64 v18; 
  unsigned __int64 v19; 
  bool v20; 
  _HALP_DMA_TRANSLATION_BUFFER *Next; 
  unsigned __int8 DmaCanCross64K; 
  _DWORD StartingIndex[3]; 
  __int64 v24; 
  _HALP_DMA_TRANSLATION_ENTRY *v25; 
  _KLOCK_QUEUE_HANDLE LockHandle; 
  char v27; 
  int v29; 

  v29 = NumberOfPages;
  v4 = (unsigned int)NumberOfPages;
  memset(&LockHandle, 0, sizeof(LockHandle));
  ContiguousTranslations = Adapter->ContiguousTranslations;
  *(_QWORD *)&StartingIndex[1] = 0i64;
  v8 = (unsigned int)NumberOfPages;
  if( ContiguousTranslations
    && (Adapter->ContiguousTranslationEnd.Buffer != ContiguousTranslations || Adapter->ContiguousTranslationEnd.Offset) )
  {
    v8 = (unsigned int)(NumberOfPages + 1);
    v27 = 1;
  }
  else
  {
    v27 = 0;
  }
  if( !Adapter->DmaCanCross64K )
    v8 = (unsigned int)((((unsigned __int64)(unsigned int)NumberOfPages << 12) + PhysicalAddress - 1) >> 16)
       - (unsigned int)(PhysicalAddress >> 16)
       + (unsigned int)v8;
  result = HalpDmaGetTranslationEntries(Adapter, HalpDmaContiguousMapBuffer, v8);
  v25 = result;
  v10 = result;
  if( result )
  {
    StartingIndex[0] = HalpDmaTranslationEntryToIndex(
                         Adapter,
                         result,
                         (_HALP_DMA_TRANSLATION_BUFFER **)&StartingIndex[1]);
    if( (unsigned int)(((__int64)v10 - *(_QWORD *)(*(_QWORD *)&StartingIndex[1] + 16i64)) / 72) )
    {
      v12 = v10 - 1;
    }
    else
    {
      v11 = Adapter->ContiguousTranslations;
      if( v11 == *(_HALP_DMA_TRANSLATION_BUFFER **)&StartingIndex[1] )
      {
        v12 = 0i64;
      }
      else
      {
        if( v11 )
        {
          do
          {
            Next = v11->Next;
            if( v11->Next == *(_HALP_DMA_TRANSLATION_BUFFER **)&StartingIndex[1] )
              break;
            v11 = v11->Next;
          }
          while( Next );
        }
        v12 = &v11->Entries[v11->EntryCount - 1];
      }
    }
    IsMasterAdapter = Adapter->IsMasterAdapter;
    v14 = v10;
    DmaCanCross64K = Adapter->DmaCanCross64K;
    KeAcquireInStackQueuedSpinLock(&Adapter->SpinLock, &LockHandle);
    if( (_DWORD)v4 )
    {
      v15 = StartingIndex[0];
      v16 = IsMasterAdapter & 1;
      v24 = v4;
      v17 = (unsigned __int64)VirtualAddress;
      v18 = 4 * v16;
      do
      {
        if( v12 )
        {
          if( v12->PhysicalAddress + 4096 != PhysicalAddress
            || !DmaCanCross64K && ((PhysicalAddress ^ v12->PhysicalAddress) & 0xFFFFFFFFFFFF0000ui64) != 0 )
          {
            v14 = v14->Next;
            ++v15;
          }
          v18 = 4 * v16;
        }
        v14->PhysicalAddress = PhysicalAddress;
        if( v17 )
        {
          v19 = v17 | (__int64)v14->u.VirtualAddress & 0xFFF;
          v17 += 4096i64;
        }
        else
        {
          v19 = (unsigned __int64)v14->u.VirtualAddress;
        }
        v14->u.VirtualAddress = (void *)(v19 & 0xFFFFFFFFFFFFFFF0ui64 | IsMasterAdapter & 1 | v18 & 0xFFFFFFFFFFFFFFF7ui64);
        RtlClearBits(Adapter->ContiguousMapRegisters, v15, 1u);
        PhysicalAddress += 4096i64;
        v18 = 4 * v16;
        ++v15;
        v12 = v14;
        v20 = v24-- == 1;
        v14 = v14->Next;
      }
      while( !v20 );
      LODWORD(v4) = v29;
      v10 = v25;
    }
    if( v27 && v14 )
    {
      --Adapter->ContiguousTranslationEnd.Offset;
      memset(v14, 0i64, sizeof(_HALP_DMA_TRANSLATION_ENTRY));
    }
    if( IsMasterAdapter )
      LODWORD(Adapter[1].ScatterTranslations) += v4;
    KeReleaseInStackQueuedSpinLockFromDpcLevel(&LockHandle);
    __writecr8(LockHandle.OldIrql);
    return v10;
  }
  return result;
}

Referenced by: