cmmdriver.c

6410BSP3

        RETAILMSG(1, (TEXT("[CMM_IOControl] Invalid Input buffer or size\r\n")));
        return FALSE;
    }


    switch ( dwIoControlCode ) {

    case IOCTL_CODEC_MEM_ALLOC:
        if(FAILED(CeOpenCallerBuffer(&pDestMarshalledOut, pOutBuf, nOutBufSize, ARG_IO_PTR, TRUE)))
        {
            RETAILMSG(1, (TEXT("MFC_IOControl: CeOpenCallerBuffer failed in IOCTL_MFC_GET_LINE_BUF_ADDR.\r\n")));
            return FALSE;
        }
        
        printD("\n[%d][CMM_IOControl] IOCTL_CODEC_MEM_ALLOC\n", CodecMem->inst_no);

        allocParam = (CMM_ALLOC_PRAM_T *)pInBuf;
        printD("[IOCTL_CODEC_MEM_ALLOC] buffSize : %ld\n", allocParam->size);

    // Moon
    // For 4K align
    if((allocParam->size) & (0xFFF))
        allocParam->size = (allocParam->size & 0xFFFFF000) + 0x1000;    
    
        printD("[IOCTL_CODEC_MEM_ALLOC] buffSize : %ld\n", allocParam->size);

        if((node = GetCodecVirAddr(CodecMem->inst_no, allocParam)) == NULL){
            result = FALSE;
            break;
        }

        printD("[IOCTL_CODEC_MEM_ALLOC] node->u_addr : 0x%x\n", node->u_addr);
        printD("[IOCTL_CODEC_MEM_ALLOC] node->v_addr : 0x%x\n", node->v_addr);
        printD("[IOCTL_CODEC_MEM_ALLOC] node->size : %d\n", node->size);

#if    (_WIN32_WCE >= 600)
    #ifdef E2E_CMM
    {
        CodecMem->callerProcess = (HANDLE) GetDirectCallerProcessId();
        node->u_addr = (PBYTE) VirtualAllocEx(CodecMem->callerProcess, NULL, node->size, MEM_RESERVE ,PAGE_NOACCESS);       // HANDLE hSrcProc                                                        
        if (node->u_addr== FALSE)
        {
            RETAILMSG(1, (TEXT("DD:: error : %d \r\n"),GetLastError()));    
            RETAILMSG(1, (L"DD::CMM VirtualAllocEx(node->u_addr) returns FALSE.\n"));
            break;
        }        
        printD("[IOCTL_CODEC_MEM_ALLOC] node->u_addr : 0x%x\n", node->u_addr);
        printD("[IOCTL_CODEC_MEM_ALLOC] node->cached_p_addr : 0x%x\n", node->cached_p_addr);
        if (allocParam->cacheFlag)
        {
            result = VirtualCopyEx(CodecMem->callerProcess,         // HANDLE hDstProc
                                node->u_addr,
                                (HANDLE) GetCurrentProcessId(),     // HANDLE hSrcProc
                                (PVOID)(node->cached_p_addr >> 8),
                                node->size,
                                PAGE_PHYSICAL |PAGE_READWRITE );        
        }
        else
        {        
        result = VirtualCopyEx(CodecMem->callerProcess,             // HANDLE hDstProc
                                node->u_addr,
                                (HANDLE) GetCurrentProcessId(),     // HANDLE hSrcProc
                                (PVOID)((node->uncached_p_addr).LowPart >> 8),
                                node->size,
                                PAGE_PHYSICAL | PAGE_READWRITE |PAGE_NOCACHE );
        }
        if (result== FALSE)
        {
            RETAILMSG(1, (TEXT("DD:: error : %d \r\n"),GetLastError()));    
            RETAILMSG(1, (L"DD::CMM VirtualCopyEx(node->u_addr) returns FALSE.\n"));
            break;
       }
       printD("[IOCTL_CODEC_MEM_ALLOC] u_addr:0x%x  CallerProcessID : 0x%x\n",  node->u_addr, CodecMem->callerProcess);
       *((UINT *)pDestMarshalledOut) = (UINT) node->u_addr;
    }
    #else
    {
        CodecMem->callerProcess = (HANDLE) GetDirectCallerProcessId();
        node->u_addr = (PBYTE) VirtualAllocCopyEx((HANDLE) GetCurrentProcessId(),       // HANDLE hSrcProc                                                        
                                CodecMem->callerProcess,                                // HANDLE hDstProc
                                node->v_addr,
                                node->size,                
                                PAGE_READWRITE);
        printD("[IOCTL_CODEC_MEM_ALLOC] u_addr:0x%x  CallerProcessID : 0x%x\n",  node->u_addr, CodecMem->callerProcess);
        *((UINT *)pOutBuf) = (UINT) node->u_addr;
    }
    #endif
#else
        *((UINT *)pOutBuf) = (UINT) node->v_addr;
#endif

        if(FAILED(CeCloseCallerBuffer(pDestMarshalledOut, pOutBuf, nOutBufSize, ARG_IO_PTR)))
        {
            RETAILMSG(1, (TEXT("MFC_IOControl: CeCloseCallerBuffer failed in IOCTL_MFC_GET_LINE_BUF_ADDR.\r\n")));
            return FALSE;
        }
        
        break;

    case IOCTL_CODEC_MEM_FREE:
        printD("\n[%d][CMM_IOControl] IOCTL_CODEC_MEM_FREE\n", CodecMem->inst_no);
        u_addr = (UINT8 *)pInBuf;
        printD("[CMM_IOControl] free adder : 0x%x \n", u_addr);

        for(node = AllocMemHead; node != AllocMemTail; node = node->next)
#if    (_WIN32_WCE >= 600)    
            if(node->u_addr == u_addr)
#else
            if(node->v_addr == u_addr)
#endif
                break;

        if(node  == AllocMemTail)
        {
            RETAILMSG(1, (TEXT("[CMM_IOControl] invalid virtual address(0x%x)\r\n"), u_addr));
            result = FALSE;
            break;
        }
        // free alloc node
        ReleaseAllocMem(node, CodecMem);
        break;

    case IOCTL_CODEC_CACHE_INVALIDATE:
        printD("\n[CMM_IOControl] IOCTL_CODEC_CACHE_INVALIDATE\n");
        u_addr = (UINT8 *)pInBuf;
        printD("[CMM_IOControl] flush adder : 0x%x \n", u_addr);

        for(node = AllocMemHead; node != AllocMemTail; node = node->next)
#if    (_WIN32_WCE >= 600)    
            if(node->u_addr == u_addr)
#else
            if(node->v_addr == u_addr)
#endif    
                break;

        if(node  == AllocMemTail){
            RETAILMSG(1, (TEXT("[%d][CMM_IOControl] invalid virtual address(0x%x)\r\n"), CodecMem->inst_no, u_addr));
            result = FALSE;
            break;
        }

        InvalidateCacheRange((PBYTE) node->v_addr, 
            (PBYTE) node->v_addr + node->size);
        break;

    case IOCTL_CODEC_CACHE_CLEAN:
        printD("\n[CMM_IOControl] IOCTL_CODEC_CACHE_CLEAN\n");
        u_addr = (UINT8 *)pInBuf;
        printD("[CMM_IOControl] flush adder : 0x%x \n", u_addr);

        for(node = AllocMemHead; node != AllocMemTail; node = node->next)
#if    (_WIN32_WCE >= 600)    
            if(node->u_addr == u_addr)
#else
            if(node->v_addr == u_addr)
#endif    
                break;

        if(node  == AllocMemTail){
            RETAILMSG(1, (TEXT("[%d][CMM_IOControl] invalid virtual address(0x%x)\r\n"), CodecMem->inst_no, u_addr));
            result = FALSE;
            break;
        }

        CleanCacheRange((PBYTE) node->v_addr, 
            (PBYTE) node->v_addr + node->size);
        break;


        // IOCTL_CODEC_CACHE_FLUSH is same as IOCTL_CODEC_CACHE_CLEAN_INVALIDATE.
        // This is remained for backward capability
    case IOCTL_CODEC_CACHE_FLUSH: 
    case IOCTL_CODEC_CACHE_CLEAN_INVALIDATE:
        printD("\n[CMM_IOControl] IOCTL_CODEC_CACHE_CLEAN_INVALIDATE\n");
        u_addr = (UINT8 *)pInBuf;
        printD("[CMM_IOControl] flush adder : 0x%x \n", u_addr);

        for(node = AllocMemHead; node != AllocMemTail; node = node->next)
#if    (_WIN32_WCE >= 600)    
            if(node->u_addr == u_addr)
#else
            if(node->v_addr == u_addr)
#endif    
                break;

        if(node  == AllocMemTail){
            RETAILMSG(1, (TEXT("[%d][CMM_IOControl] invalid virtual address(0x%x)\r\n"), CodecMem->inst_no, u_addr));
            result = FALSE;
            break;
        }

        CleanInvalidateCacheRange((PBYTE) node->v_addr, 
            (PBYTE) node->v_addr + node->size);
        break;


    case IOCTL_CODEC_GET_PHY_ADDR:
        u_addr  = (UINT8 *)pInBuf;
        //printD("\n[CMM_IOControl] IOCTL_CODEC_GET_PHY_ADDR(0x%x)\n", u_addr);
        for(node = AllocMemHead; node != AllocMemTail; node = node->next)
#if    (_WIN32_WCE >= 600)    
            if(node->u_addr == u_addr)
#else
            if(node->v_addr == u_addr)
#endif    
                break;

        if(node  == AllocMemTail){
            RETAILMSG(1, (TEXT("[CMM_IOControl] invalid virtual address(0x%x)\r\n"), u_addr));
            result = FALSE;
            break;
        }

        if(FAILED(CeOpenCallerBuffer(&pDestMarshalledOut, pOutBuf, nOutBufSize, ARG_O_PTR, TRUE)))    {
            printD("[IOCTL_CODEC_GET_PHY_ADDR] Access check failed on output buffer\n");
            return FALSE;
        }

        *((UINT *)pDestMarshalledOut) = (UINT) node->cached_p_addr;

        //printD("\n[CMM_IOControl] p_addr (0x%x)\n", node->cached_p_addr);
        if(FAILED(CeCloseCallerBuffer(pDestMarshalledOut, pOutBuf, nOutBufSize, ARG_O_PTR)))    {
            printD("[IOCTL_CODEC_GET_PHY_ADDR] Access check failed on output buffer\n");
            return FALSE;
        }
        break;


    default : RETAILMSG(1, (TEXT("[CMM_IOControl] CMM Invalid IOControl\r\n")));
    }


    UnlockCMMMutex();
    return result;
}

/*----------------------------------------------------------------------------
*Function: CMM_DllMain

*Parameters:         DllInstance        :
                    Reason            : 
                    Reserved        :
*Return Value:        True/False
*Implementation Notes: Entry point for CMM.dll 
-----------------------------------------------------------------------------*/
BOOL WINAPI
CMM_DllMain(HINSTANCE DllInstance, DWORD Reason, LPVOID Reserved)
{
    switch(Reason) {
        case DLL_PROCESS_ATTACH:
            DEBUGREGISTER(DllInstance);
            break;
    }
    return TRUE;
}   

// insert node ahead of AllocMemHead
static void InsertNodeToAllocList(ALLOC_MEM_T *node, UINT8 inst_no)
{
    printD("[%d]InsertNodeToAllocList(p_addr : 0x%08x size:%ld cacheflag : %d)\n", inst_no, node->cached_p_addr, node->size, node->cacheFlag);
    node->next = AllocMemHead;
    node->prev = AllocMemHead->prev;
    AllocMemHead->prev->next = node;
    AllocMemHead->prev = node;
    AllocMemHead = node;
    printD("end InsertNodeToAllocList\n");
}

// insert node ahead of FreeMemHead
static void InsertNodeToFreeList(FREE_MEM_T *node,  UINT8 inst_no)
{
    printD("[%d]InsertNodeToFreeList(startAddr : 0x%08x size:%ld)\n", inst_no, node->startAddr, node->size);
    node->next = FreeMemHead;
    node->prev = FreeMemHead->prev;
    FreeMemHead->prev->next = node;
    FreeMemHead->prev = node;
    FreeMemHead = node;

    PrintList();
}

static void DeleteNodeFromAllocList(ALLOC_MEM_T *node, UINT8 inst_no)
{
    printD("[%d]DeleteNodeFromAllocList(p_addr : 0x%08x size:%ld cacheflag : %d)\n", inst_no, node->cached_p_addr, node->size, node->cacheFlag);
    __try
    {
        if(node == AllocMemTail){
            RETAILMSG(1, (TEXT("[CMM] DeleteNodeFromAllocList :: InValid node\n")));
            return;
        }

        if(node == AllocMemHead)
            AllocMemHead = node->next;

        node->prev->next = node->next;
        node->next->prev = node->prev;

        free(node);
    }
    __except(GetExceptionCode()==STATUS_ACCESS_VIOLATION ?
               EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
    {
        RETAILMSG( 1, ( _T("CMM DeleteNodeFromAllocList exception occurred\n")) );
    }

    PrintList();
}

static void DeleteNodeFromFreeList( FREE_MEM_T *node, UINT8 inst_no)
{
    printD("[%d]DeleteNodeFromFreeList(startAddr : 0x%08x size:%ld)\n", inst_no, node->startAddr, node->size);
    __try
    {
        if(node == FreeMemTail){
            RETAILMSG(1, (TEXT("[CMM] DeleteNodeFromFreeList :: InValid node\n")));
            return;
        }

        if(node == FreeMemHead)
            FreeMemHead = node->next;

        node->prev->next = node->next;
        node->next->prev = node->prev;