jpgdriver.c

6410BSP3

        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeOpenCallerBuffer failed in IOCTL_JPG_GET_PHY_FRMBUF.\r\n")));
            return FALSE;
        }

        *((UINT *)pMarshalledOutBuf) = (UINT)JPG_DATA_BASE_ADDR + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE;
        printD("IOCTL_JPG_GET_PHY_FRMBUF : 0x%x\n", JPG_DATA_BASE_ADDR + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE);

        if(FAILED(CeCloseCallerBuffer(pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR)))
        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeCloseCallerBuffer failed in IOCTL_JPG_GET_PHY_FRMBUF.\r\n")));
            return FALSE;
        }

        break;

    case IOCTL_JPG_GET_THUMB_FRMBUF:
        printD("DD::IOCTL_JPG_GET_THUMB_FRMBUF\n");

        if(FAILED(CeOpenCallerBuffer(&pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR, FALSE)))
        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeOpenCallerBuffer failed in IOCTL_JPG_GET_THUMB_FRMBUF.\r\n")));
            return FALSE;
        }

#if    (_WIN32_WCE >= 600)
#ifdef E2E
{
            if(JPGRegCtx->frmUserThumbBuf == NULL){
                JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
                JPGRegCtx->frmUserThumbBuf = VirtualAllocEx(JPGRegCtx->callerProcess, NULL, JPG_FRAME_THUMB_BUF_SIZE, MEM_RESERVE, PAGE_NOACCESS);
                phyAddr = JPG_DATA_BASE_ADDR+ JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE+ JPG_FRAME_BUF_SIZE;
                result = VirtualCopyEx(JPGRegCtx->callerProcess,           // HANDLE hDstProc
                                     JPGRegCtx->frmUserThumbBuf,
                                     (HANDLE) GetCurrentProcessId(),     // HANDLE hSrcProc
                                                 (PVOID)(phyAddr >> 8),    
                                                  JPG_FRAME_THUMB_BUF_SIZE,
                                                  PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE);
                if (result == FALSE){
                    RETAILMSG(1, (L"DD::JPG VirtualCopyEx(frmUserThumbBuf) returns FALSE.\n"));
        *((UINT *)pMarshalledOutBuf) = NULL;
                    break;
                }
            }
            printD("DD::frmUserThumbBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->frmUserThumbBuf, JPGRegCtx->callerProcess);
     *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->frmUserThumbBuf;
}
#else
{
        JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
        JPGRegCtx->frmUserThumbBuf = (PBYTE) VirtualAllocCopyEx((HANDLE) GetCurrentProcessId(),        // HANDLE hSrcProc
            JPGRegCtx->callerProcess,    // HANDLE hDstProc
            (LPVOID)(JPGRegCtx->v_pJPGData_Buff+ JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE + JPG_FRAME_BUF_SIZE),
            JPG_FRAME_THUMB_BUF_SIZE,
            PAGE_READWRITE);
        if (JPGRegCtx->frmUserThumbBuf == NULL)
        {
            RETAILMSG(1, (TEXT("DD::JPG Memory Allocation Fail\r\n")));
            UnlockJPGMutex();
            return FALSE;
        }
        else
        {
            printD("DD::frmUserThumbBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->frmUserThumbBuf, JPGRegCtx->callerProcess);
            *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->frmUserThumbBuf;
        }
}
#endif 

#else
        *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->v_pJPGData_Buff+ JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE + JPG_FRAME_BUF_SIZE;
#endif

        if(FAILED(CeCloseCallerBuffer(pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR)))
        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeCloseCallerBuffer failed in IOCTL_JPG_GET_THUMB_FRMBUF.\r\n")));
            return FALSE;
        }

        break;

    case IOCTL_JPG_GET_RGBBUF:
        printD("DD::IOCTL_JPG_GET_RGBBUF\n");

        if(FAILED(CeOpenCallerBuffer(&pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR, FALSE)))
        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeOpenCallerBuffer failed in IOCTL_JPG_GET_RGBBUF.\r\n")));
            return FALSE;
        }

#if    (_WIN32_WCE >= 600)
#ifdef E2E
{
                if(JPGRegCtx->rgbBuf == NULL){
                JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
                JPGRegCtx->rgbBuf = VirtualAllocEx(JPGRegCtx->callerProcess, NULL, JPG_RGB_BUF_SIZE, MEM_RESERVE, PAGE_NOACCESS);
                phyAddr = JPG_DATA_BASE_ADDR+ JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE+ JPG_FRAME_BUF_SIZE+ JPG_FRAME_THUMB_BUF_SIZE;
                result = VirtualCopyEx(JPGRegCtx->callerProcess,           // HANDLE hDstProc
                                     JPGRegCtx->rgbBuf,
                                     (HANDLE) GetCurrentProcessId(),     // HANDLE hSrcProc
                                                 (PVOID)(phyAddr >> 8),    
                                                  JPG_RGB_BUF_SIZE,
                                                  PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE);
                if (result == FALSE){
                    RETAILMSG(1, (L"DD::JPG VirtualCopyEx(rgbBuf) returns FALSE.\n"));
        *((UINT *)pMarshalledOutBuf) = NULL;
                    break;
                }
                
            }
            printD("DD::rgbBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->rgbBuf, JPGRegCtx->callerProcess);
     *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->rgbBuf;
}
#else
{
        JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
        JPGRegCtx->rgbBuf = (PBYTE) VirtualAllocCopyEx( (HANDLE) GetCurrentProcessId(),        // HANDLE hSrcProc
            JPGRegCtx->callerProcess,    // HANDLE hDstProc
            (LPVOID)(JPGRegCtx->v_pJPGData_Buff+ JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE+ JPG_FRAME_BUF_SIZE + JPG_FRAME_THUMB_BUF_SIZE),
            JPG_RGB_BUF_SIZE,
            PAGE_READWRITE);
        if (JPGRegCtx->rgbBuf == NULL)
        {
            RETAILMSG(1, (TEXT("DD::JPG Memory Allocation Fail\r\n")));
            UnlockJPGMutex();
            return FALSE;
        }
        else
        {
            printD("DD::rgbBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->rgbBuf, JPGRegCtx->callerProcess);
            *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->rgbBuf;
        }
}
#endif

#else
        *((UINT *)pMarshalledOutBuf) = (UINT) JPGRegCtx->v_pJPGData_Buff+ JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE+ JPG_FRAME_BUF_SIZE + JPG_FRAME_THUMB_BUF_SIZE;
#endif

        if(FAILED(CeCloseCallerBuffer(pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR)))
        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeCloseCallerBuffer failed in IOCTL_JPG_GET_RGBBUF.\r\n")));
            return FALSE;
        }

        break;

    case IOCTL_JPG_GET_PHY_RGBBUF:
        if(FAILED(CeOpenCallerBuffer(&pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR, FALSE)))
        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeOpenCallerBuffer failed in IOCTL_JPG_GET_PHY_RGBBUF.\r\n")));
            return FALSE;
        }

        *((UINT *)pMarshalledOutBuf) = (UINT)JPG_DATA_BASE_ADDR + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE+ JPG_FRAME_BUF_SIZE + JPG_FRAME_THUMB_BUF_SIZE;

        printD("IOCTL_JPG_GET_PHY_RGBBUF : 0x%x\n", JPG_DATA_BASE_ADDR + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE + JPG_FRAME_BUF_SIZE + JPG_FRAME_THUMB_BUF_SIZE);

        if(FAILED(CeCloseCallerBuffer(pMarshalledOutBuf, pOutBuf, nOutBufSize, ARG_O_PTR)))
        {
            RETAILMSG(1, (TEXT("JPG_IOControl: CeCloseCallerBuffer failed in IOCTL_JPG_GET_PHY_RGBBUF.\r\n")));
            return FALSE;
        }

        break;

    default :
        RETAILMSG(1, (TEXT("DD::JPG Invalid IOControl\r\n")));
    }


    UnlockJPGMutex();
    return result;
}

/*----------------------------------------------------------------------------
*Function: JPG_Write

*Parameters:         dwContext        :
*Return Value:        True/False
*Implementation Notes: Initialize JPEG Hardware
-----------------------------------------------------------------------------*/
DWORD
JPG_Write(
    DWORD OpenHandle,
    LPCVOID pBuffer,
    DWORD dwNumBytes
    )
{
    printD("DD::JPEG_Write \n");
    return 1;
}

/*----------------------------------------------------------------------------
*Function: JPEG_PowerUp

*Parameters:         dwContext        :
*Return Value:        True/False
*Implementation Notes: Initialize JPEG Hardware
-----------------------------------------------------------------------------*/
void
JPG_PowerUp(
    DWORD InitHandle
    )
{
    printD("DD::JPEG_PowerUp \n");
}

/*----------------------------------------------------------------------------
*Function: JPEG_PowerDown

*Parameters:         dwContext        :
*Return Value:        True/False
*Implementation Notes: Initialize JPEG Hardware
-----------------------------------------------------------------------------*/
void
JPG_PowerDown(
    DWORD InitHandle
    )
{
    printD("DD::JPEG_PowerDown(instanceNo : %d \n", instanceNo);

    if(instanceNo > 0)
    {
        PowerChange = TRUE;
        Delay(MAX_PROCESSING_THRESHOLD);
    }

    JPGPowerControl(FALSE);
}

/*----------------------------------------------------------------------------
*Function: JPGPowerControl
*Implementation Notes: JPEG Power on/off
-----------------------------------------------------------------------------*/
static void
JPGPowerControl(
    BOOL bOnOff
    )
{
    DWORD dwIPIndex = PWR_IP_JPEG;
    DWORD dwBytes;
    static int isOn = 0;

    printD("DD::JPEG Power Control\n");
    
    // JPEG clock
    if (!bOnOff)
    {
        if(isOn == 1)
        {
            printD("JPEG powerOFF\n");
            isOn = 0;

            s6410PWR->HCLK_GATE &= ~(JPG_1BIT_MASK << JPG_HCLK_JPEG_BIT); // JPEG clock disable
            s6410PWR->SCLK_GATE &= ~(JPG_1BIT_MASK << JPG_SCLK_JPEG_BIT); // JPEG clock disable

            if ( !DeviceIoControl(hPwrControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
            {
                RETAILMSG(1, (TEXT("DD::JPG IOCTL_PWRCON_SET_POWER_OFF Failed\r\n")));
            }
        }
    }
    else
    {
        if(isOn == 0)
        {
            printD("JPEG powerON\n");
            isOn = 1;

            if ( !DeviceIoControl(hPwrControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
            {
                RETAILMSG(1, (TEXT("DD::JPG IOCTL_PWRCON_SET_POWER_ON Failed\r\n")));
            }

            s6410PWR->HCLK_GATE |= (JPG_1BIT_MASK << JPG_HCLK_JPEG_BIT); // JPEG clock enable
            s6410PWR->SCLK_GATE |= (JPG_1BIT_MASK << JPG_SCLK_JPEG_BIT); // JPEG clock enable
        }
    }
}


/*----------------------------------------------------------------------------
*Function: JPGSetClkDiv
*Implementation Notes: set JPG clock
-----------------------------------------------------------------------------*/
static BOOL
JPGSetClkDiv(
    int divider
    )
{
    if ((divider < 1) || (divider > 16))
    {
        RETAILMSG(1, (L"JPGSetClkDiv: JPG clock divider must be 1 ~ 16.\n\r"));
        return FALSE;
    }

    // S3C6410 JPEG clock ratio must be odd value.
    // If you want to set quater clock(1/4) to CLKJPG, you have to set 3(odd value) to JPEG_RATIO field.
    // As below calcuration, this function's parameter must be 4.
    s6410PWR->CLK_DIV0 = (s6410PWR->CLK_DIV0 & ~(JPG_4BIT_MASK << JPG_JPEG_RATIO_BIT)) | ((divider - 1) << JPG_JPEG_RATIO_BIT);

    return TRUE;
}

/*----------------------------------------------------------------------------
*Function: Delay
*Implementation Notes: delay during count milisecond
-----------------------------------------------------------------------------*/
static void
Delay(
    UINT32 count
    )
{
    volatile int i, j = 0;
    volatile static int loop = APLL_CLK/100000;

    for(;count > 0;count--)
        for(i=0;i < loop; i++)
        {
            j++;
        }
}

/*----------------------------------------------------------------------------
*Function: JPEG_DllMain

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

    return TRUE;
}