libmain.cpp

6410BSP3

        Plat::printf("[FIMGDRV:0x%08x] ========================================\n", hOpenContext);        
        
    }        
    
}

extern "C" void DoFreePhysMem(DWORD hOpenContext, void* bufAddr)
{
    FIMG_CONTEXT* openHandle = (FIMG_CONTEXT*)hOpenContext;
    ALLOCMEM_ITEM* pHead = openHandle->allocated_list;        
    ALLOCMEM_ITEM *pItem, *pPrev = NULL;
    ALLOCMEM_POOL *pTemp;
    s3c_3d_mem_alloc*   pOutputBuf = (s3c_3d_mem_alloc*)bufAddr;    
    
    Plat::printf("[FIMGDRV:0x%08x] DoFreePhysMem 0x%x 0x%x %d\n", hOpenContext, pOutputBuf->phy_addr, pOutputBuf->vir_addr, pOutputBuf->size);
    Plat::printf("[FIMGDRV:0x%08x] Before Free, Block list for this context\n", hOpenContext);
    Plat::printf("[FIMGDRV:0x%08x] ========================================\n", hOpenContext);
    for(pItem=pHead;pItem != NULL; pItem=pItem->next) 
    {
        Plat::printf("[FIMGDRV:0x%08x] 0x%x 0x%x 0x%x is Allocated\n", hOpenContext, pItem->phyAddr, pItem->virAddrCP, pItem->virAddr);
    }    
    
    Plat::printf("[FIMGDRV:0x%08x] ========================================\n", hOpenContext);
    
    for(pItem=pHead,pPrev=NULL;pItem != NULL; pItem=pItem->next) 
    {
        if((unsigned int)pItem->phyAddr == pOutputBuf->phy_addr) break;
        pPrev = pItem;
    }
    
    if(pItem != NULL)    
    {
        if(pPrev != NULL) pPrev->next = pItem->next;    
        else if(pItem->next != NULL) openHandle->allocated_list = pItem->next;
        else openHandle->allocated_list = NULL;
        
    #if (_WIN32_WCE >= 600)   
        if(pItem->virAddrCP != NULL)
            VirtualFreeEx((HANDLE)GetDirectCallerProcessId(), (LPVOID)pItem->virAddrCP, 0,  MEM_RELEASE);
    #endif        
    
        pTemp = (ALLOCMEM_POOL *)pItem->memPool;
        pTemp->used = FALSE;
        pTemp->openHandle = 0;
        
        
        free(pItem);
    }
        
    
    pItem = 0;
            
}


extern "C" void RequestDepthBuffer(DWORD hOpenContext, void* bufAddr)
{
    FIMG_CONTEXT* openHandle = (FIMG_CONTEXT*)hOpenContext;
    s3c_3d_mem_alloc*   pOutputBuf = (s3c_3d_mem_alloc*)bufAddr;

    if(pDepthBuffer != NULL)
    {            
        pOutputBuf->size = pDepthBuffer->size;    
        pOutputBuf->phy_addr = (unsigned int)pDepthBuffer->phyAddr;

       
#if (_WIN32_WCE >= 600)      
        void*   pCPAddr;
        pCPAddr = VirtualAllocCopyEx((HANDLE)GetCurrentProcessId(),
                            (HANDLE)GetDirectCallerProcessId(),
                            (LPVOID)pDepthBuffer->virAddr,
                            pDepthBuffer->size,
                            PAGE_READWRITE | PAGE_NOCACHE );   
        pOutputBuf->vir_addr = (unsigned int)pCPAddr;                                              
#else
        pOutputBuf->vir_addr = (unsigned int)pDepthBuffer->virAddr;
#endif

        Plat::printf("[FIMGDRV:0x%08x] GetDepthBuffer 0x%x 0x%x 0x%x %d\n", hOpenContext, pOutputBuf->phy_addr, pOutputBuf->vir_addr, pDepthBuffer->virAddr, pOutputBuf->size);
    }
}

extern "C" void ReleaseDepthBuffer(DWORD hOpenContext, void* bufAddr)
{
    FIMG_CONTEXT* openHandle = (FIMG_CONTEXT*)hOpenContext;
    s3c_3d_mem_alloc*   pOutputBuf = (s3c_3d_mem_alloc*)bufAddr;      
    
#if (_WIN32_WCE >= 600)   
    if(pOutputBuf->vir_addr != NULL)
        VirtualFreeEx((HANDLE)GetDirectCallerProcessId(), (LPVOID)pOutputBuf->vir_addr, 0,  MEM_RELEASE);
#endif            
}

extern "C" void GetMemoryStatus(DWORD hOpenContext, int *outUsedMemory, int *outTotalMemory)
{
    ALLOCMEM_POOL *pTemp = pHeadOfMemoryPool;
    int usedMemory = 0, totalMemory = 0;            
    while(pTemp != NULL)
    {
        if(pTemp->used == TRUE) 
        {
            usedMemory += pTemp->size;
        }
        totalMemory += pTemp->size;
        
        pTemp = pTemp->next;
    }
     
    *outUsedMemory = usedMemory;
    *outTotalMemory = totalMemory;
}


extern "C"  void GetDMACODEAddress(UINT32 phyaddr, int size, int cacheEnable, BufferAddress* bufAddr)
{
#if 0
    PHYSICAL_ADDRESS    ioPhysicalBase = {0,0};
    ioPhysicalBase.LowPart = phyaddr;
    bufAddr->paddr = (PVOID)phyaddr;
    bufAddr->vaddr = (PVOID)MmMapIoSpace(ioPhysicalBase, size, cacheEnable);
    bufAddr->vaddrCP = (PVOID)VirtualAllocCopyEx((HANDLE)GetCurrentProcessId(),
                        (HANDLE)GetDirectCallerProcessId(),
                        bufAddr->vaddr,
                        size,
                        PAGE_READWRITE | PAGE_NOCACHE);
                        
#endif                       
}

extern "C"  void  FreeDMACODEAddress(BufferAddress* bufAddr, int size)
{
#if 0
    if(bufAddr->vaddrCP != NULL)
    {
        if(!VirtualFreeEx((HANDLE)GetDirectCallerProcessId(), (LPVOID)bufAddr->vaddrCP, 0,  MEM_RELEASE))
        {
            RETAILMSG(1,(TEXT("%s: VirtualFreeEx is failed\r\n"),_T(__FUNCTION__)));
        }
    }
    if(bufAddr->vaddr != NULL)
    {
        MmUnmapIoSpace(bufAddr->vaddr, size);
    }
#endif
}

extern "C" void GarbageCollect(DWORD hOpenContext)
{
    FIMG_CONTEXT* openHandle = (FIMG_CONTEXT*)hOpenContext;
    ALLOCMEM_ITEM* pHead = openHandle->allocated_list;        
    ALLOCMEM_ITEM *pItem, *pNext;
    ALLOCMEM_POOL *pTemp;
    
    Plat::printf("[FIMGDRV:0x%08x] Garbage Collect\n", hOpenContext);
        
    for(pItem=pHead;pItem != NULL; ) 
    {
        pNext = pItem->next;
        pTemp = (ALLOCMEM_POOL *)pItem->memPool;
        pTemp->used = FALSE;
        pTemp->openHandle = 0;
#if (_WIN32_WCE >= 600)      
        if(pItem->virAddrCP != NULL)
            VirtualFreeEx((HANDLE)GetDirectCallerProcessId(), (LPVOID)pItem->virAddrCP, 0,  MEM_RELEASE);
#endif

        Plat::printf("[FIMGDRV:0x%08x] Garbage Collect 0x%x 0x%x\n", hOpenContext, pTemp->phyAddr, pTemp->virAddr);

        free(pItem);
        pItem = 0;            
        
        pItem = pNext;
    }
}



BOOL AllocateMemoryList()
{
    void *virAddr, *phyAddr, *pSharedAddr;
    int i;
    ALLOCMEM_POOL *pTemp, *pPrev;
    HANDLE hMapping = NULL;
    BOOL retVal = TRUE; 
                
    MEMORYSTATUS mem_status;

    
    Plat::printf("[FIMGDRV] Alloc Block Num = %d  Alloc Block Size = 0x%x\n", g_blkNum, g_blkSize);
    
    
    GlobalMemoryStatus(&mem_status);
    Plat::printf("[FIMGDRV] alloc physmem = %d / %d\n", mem_status.dwAvailPhys, mem_status.dwTotalPhys );
    Plat::printf("[FIMGDRV] alloc virtmem = %d/%d\n", mem_status.dwAvailVirtual, mem_status.dwTotalVirtual );
  
    if(g_depthBufferSize > 0)
    {
        Plat::printf("[FIMGDRV] Only for Depthbuffer is allocated.\n");
        
        virAddr = AllocPhysMem(g_depthBufferSize, PAGE_READWRITE|PAGE_NOCACHE, 0, 0, (PULONG)&phyAddr);
        if(virAddr == NULL)
        {
            Plat::printf("[FIMGDRV] depth buffer allocated is fail\n");
            retVal = FALSE;
        }    
        else
        {
        
#if (_WIN32_WCE >= 600)   
            pSharedAddr = virAddr;
            {
#else
            hMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, g_depthBufferSize, NULL);      
            pSharedAddr = (void *)MapViewOfFile(hMapping, FILE_MAP_WRITE, 0, 0, 0);     
        
            if(!VirtualCopy (pSharedAddr, (LPVOID)((UINT32)phyAddr>>8), g_depthBufferSize, PAGE_NOCACHE|PAGE_READWRITE|PAGE_PHYSICAL))
            {
                Plat::printf("[FIMGDRV] depthbuffer alloccopy is fail\n");
            }
            else
            {
                VirtualFree (virAddr, 0, MEM_RELEASE);    // this will release the VM    
#endif        
                pDepthBuffer = (ALLOCMEM_POOL*) malloc(sizeof(ALLOCMEM_POOL));
                pDepthBuffer->phyAddr = phyAddr;
                pDepthBuffer->virAddr = pSharedAddr;
                pDepthBuffer->handle = hMapping;
                pDepthBuffer->used = FALSE;
                pDepthBuffer->next = NULL;
                pDepthBuffer->openHandle = 0;
                pDepthBuffer->size = g_depthBufferSize;
                Plat::printf("[FIMGDRV] depthbuffer is allocated on 0x%x 0x%x, size is %dBytes\n", pSharedAddr, phyAddr, g_depthBufferSize);
            }
        }   
    }
  
#if 0
  ///////////////////// Allocated from Camera.
  phyAddr = (void*)CAM_POOL_BASE;
  virAddr = (void*)VirtualAlloc(NULL, CAM_POOL_SIZE, MEM_RESERVE, PAGE_NOACCESS);
    VirtualCopy (virAddr, (LPVOID)((UINT32)phyAddr>>8), CAM_POOL_SIZE, PAGE_NOCACHE|PAGE_READWRITE|PAGE_PHYSICAL);

  while(((DWORD)phyAddr+ALLOCATESIZE) <= (CAM_POOL_BASE+CAM_POOL_SIZE))
  {
        pTemp = (ALLOCMEM_POOL*) malloc(sizeof(ALLOCMEM_POOL));
        pTemp->phyAddr = phyAddr;
        pTemp->virAddr = virAddr;
        pTemp->handle = NULL;
        pTemp->used = FALSE;
        pTemp->next = NULL;
        pTemp->openHandle = 0;
        pTemp->size = ALLOCATESIZE;
        
        if((DWORD)phyAddr == CAM_POOL_BASE)
        {
            pHeadOfMemoryPool = pTemp;
        }
        else
        {
            pPrev->next = pTemp;
        }
        pPrev = pTemp;
        
      phyAddr = (void*)((DWORD)phyAddr + ALLOCATESIZE);
      virAddr = (void*)((DWORD)virAddr + ALLOCATESIZE);        
  }
#endif  
  
  //////////////////// Allocated From AllocPhysMem.
    for(i=0;i<g_blkNum;i++)
    {
        virAddr = AllocPhysMem(g_blkSize, PAGE_READWRITE|PAGE_NOCACHE, 0, 0, (PULONG)&phyAddr);
        if(virAddr == NULL)
        {
            Plat::printf("[FIMGDRV] %d th allocated is fail\n", (i+1));
            retVal = FALSE;
            break;
        }    
        
#if (_WIN32_WCE >= 600)   
        pSharedAddr = virAddr;
#else
        hMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, g_blkSize, NULL);      
        
        pSharedAddr = (void *)MapViewOfFile(hMapping, FILE_MAP_WRITE, 0, 0, 0);     
        
        if(!VirtualCopy (pSharedAddr, (LPVOID)((UINT32)phyAddr>>8), g_blkSize, PAGE_NOCACHE|PAGE_READWRITE|PAGE_PHYSICAL))
        {
            Plat::printf("[FIMGDRV] %d th alloccopy is fail\n", (i+1));
            break;
        }
        
        VirtualFree (virAddr, 0, MEM_RELEASE);    // this will release the VM    
#endif        
        pTemp = (ALLOCMEM_POOL*) malloc(sizeof(ALLOCMEM_POOL));
        pTemp->phyAddr = phyAddr;
        pTemp->virAddr = pSharedAddr;
        pTemp->handle = hMapping;
        pTemp->used = FALSE;
        pTemp->next = NULL;
        pTemp->openHandle = 0;
        pTemp->size = g_blkSize;
        
        if(i == 0)
        {
            pHeadOfMemoryPool = pTemp;
        }
        else
        {
            pPrev->next = pTemp;
        }
        
        pPrev = pTemp;
    }
    
    GlobalMemoryStatus(&mem_status);
    Plat::printf("[FIMGDRV] alloc physmem = %d / %d\n", mem_status.dwAvailPhys, mem_status.dwTotalPhys );
    Plat::printf("[FIMGDRV] alloc virtmem = %d/%d\n", mem_status.dwAvailVirtual, mem_status.dwTotalVirtual);    
    
    
    pTemp = pHeadOfMemoryPool;
    while(pTemp != NULL)
    {
        Plat::printf("[FIMGDRV] Allocated Pool 0x%x 0x%x 0x%x\n", pTemp->virAddr, pTemp->phyAddr, pTemp->used);
        pTemp = pTemp->next;
    }
    
    
    return retVal;
 
}

extern "C" void FreeMemoryList(DWORD hOpenContext)
{
    HANDLE hMapping;
    ALLOCMEM_POOL *pTemp, *pNext;
    
    MEMORYSTATUS mem_status;
    
    Plat::printf("[FIMGDRV:0x%08x] Release Free Memroy List\n", hOpenContext);
  
    GlobalMemoryStatus(&mem_status);
    Plat::printf("[FIMGDRV] Before Release physmem = %d / %d\n", mem_status.dwAvailPhys, mem_status.dwTotalPhys );
    Plat::printf("[FIMGDRV] Before Release virtmem = %d/%d\n", mem_status.dwAvailVirtual, mem_status.dwTotalVirtual );
      
  
    
    if(pDepthBuffer != NULL)
    {
#if (_WIN32_WCE < 600)    
        hMapping = pDepthBuffer->handle;
    
        if (pDepthBuffer->virAddr != NULL)
        {
            UnmapViewOfFile((LPVOID)pDepthBuffer->virAddr);
        }

        if (hMapping != NULL)
        {
             CloseHandle(hMapping);
        }   
     
        free(pDepthBuffer);         
#endif        
        pDepthBuffer = NULL;
    }
    
    if(pHeadOfMemoryPool != NULL)
    {
#if (_WIN32_WCE < 600)  
        pTemp = pHeadOfMemoryPool;
        while(pTemp != NULL)
        {
            pNext = pTemp->next;
          
            hMapping = pTemp->handle;
    
            if (pTemp->virAddr != NULL)
            {
                UnmapViewOfFile((LPVOID)pTemp->virAddr);
            }

            if (hMapping != NULL)
            {
                 CloseHandle(hMapping);
            }   
     
            free(pTemp);
            pTemp = pNext;
        }         
#endif         
        pHeadOfMemoryPool = NULL;   
    }
    
    GlobalMemoryStatus(&mem_status);
    Plat::printf("[FIMGDRV] After Release physmem = %d / %d\n", mem_status.dwAvailPhys, mem_status.dwTotalPhys );
    Plat::printf("[FIMGDRV] After Release virtmem = %d/%d\n", mem_status.dwAvailVirtual, mem_status.dwTotalVirtual);    
}

extern "C" BOOL ReAllocMemoryList(DWORD hOpenContext)
{
    Plat::printf("[FIMGDRV:0x%08x] Re Allocate Memroy List\n", hOpenContext);
    
    if(pHeadOfMemoryPool != NULL || pDepthBuffer != NULL)
    {
        Plat::printf("[FIMGDRV:0x%08x] ReAllocateList Error! Already allocated\n", hOpenContext);
        return FALSE;
    }
    
    if(!ReadMemoryPoolFromRegistry(&g_blkNum, &g_blkSize, &g_depthBufferSize))
    {
        g_blkSize = ALLOCATESIZE;
        g_blkNum = ALLOCATENUM;
    }
    
    if(!AllocateMemoryList())
    {
        Plat::printf("[FIMGDRV:0x%08x] ReAllocateList Error!\n", hOpenContext);
        FreeMemoryList(hOpenContext);
        return FALSE;
    }
    return TRUE;
}

BOOL ReadMemoryPoolFromRegistry(int *pBlkNum, int *pBlkSize, int *pDepthBufferSize)
{
    HKEY  hKey = 0;
    DWORD dwType  = 0;
    DWORD dwSize  = sizeof ( DWORD );
    DWORD dwValue = -1;

    if( ERROR_SUCCESS != RegOpenKeyEx( HKEY_LOCAL_MACHINE, L"Drivers\\BuiltIn\\FIMG", 0, 0, &hKey ))
    {
        //mio
        return FALSE;
    }

    *pDepthBufferSize = 0;
    if( ERROR_SUCCESS == RegQueryValueEx( hKey, L"DepthBufSize", 0, &dwType, (BYTE *)&dwValue, &dwSize ) )
    {
        if(   ( REG_DWORD == dwType )
           && ( sizeof( DWORD ) == dwSize ))
        {
            *pDepthBufferSize = dwValue;
        }
    }

    if( ERROR_SUCCESS == RegQueryValueEx( hKey, L"AllocblkNum", 0, &dwType, (BYTE *)&dwValue, &dwSize ) )
    {
        if(   ( REG_DWORD == dwType )
           && ( sizeof( DWORD ) == dwSize ))
        {
            *pBlkNum = dwValue;
        }
        else return FALSE;
    }
    else return FALSE;
  
    
    if( ERROR_SUCCESS == RegQueryValueEx( hKey, L"AllocblkSize", 0, &dwType, (BYTE *)&dwValue, &dwSize ) )
    {
        if(   ( REG_DWORD == dwType )
           && ( sizeof( DWORD ) == dwSize ))
        {
            *pBlkSize = dwValue;
        }
        else return FALSE;
    }
    else return FALSE;
    
    return TRUE;
}