jpgdriver.c

6410BSP3

//
// Copyright (c) Samsung Electronics. Co. LTD.  All rights reserved.
//
/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

*/


#include "JPGDriver.h"
#include "JPGMem.h"
#include "JPGMisc.h"
#include "JPGOpr.h"
#include <s3c6410_syscon.h>
#include <s3c6410_base_regs.h>
#include <pmplatform.h>
#include <bsp_cfg.h>

#if (_WIN32_WCE >= 600)
#define E2E
#endif

HANDLE      hPwrControl;
S3C6410_SYSCON_REG *s6410PWR = NULL;
UINT8       instanceNo = 0;
BOOL        PowerChange = FALSE;

#if DEBUG
#define ZONE_INIT              DEBUGZONE(0)

DBGPARAM dpCurSettings =                            \
{                                                   \
    TEXT("JPEG_Driver"),                            \
    {                                               \
        TEXT("Init"),                 /* 0  */      \
    },                                              \
    (0x0001)                                        \
};
#endif

static void JPGPowerControl(BOOL bOnOff);
static void Delay(UINT32 count);
static BOOL JPGSetClkDiv(int divider);

/*----------------------------------------------------------------------------
*Function: JPG_Init

*Parameters:         dwContext        :
*Return Value:        True/False
*Implementation Notes: Initialize JPEG Hardware
-----------------------------------------------------------------------------*/
DWORD
JPG_Init(
    DWORD dwContext
    )
{
    S3C6410_JPG_CTX *JPGRegCtx;
    HANDLE            h_Mutex;
    DWORD            ret;

    printD("DD::JPG_Init\n");

    // PWM clock Virtual alloc
    s6410PWR = (S3C6410_SYSCON_REG *)Phy2VirAddr(S3C6410_BASE_REG_PA_SYSCON, sizeof(S3C6410_SYSCON_REG));
    if (s6410PWR == NULL)
    {
        RETAILMSG(1,(TEXT("DD:: For s6410PWR: MmMapIoSpace failed!\r\n")));
        return FALSE;;
    }

    hPwrControl = CreateFile( L"PWC0:", GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
    if (INVALID_HANDLE_VALUE == hPwrControl )
    {
        RETAILMSG(1, (TEXT("DD:: JPEG - PWC0 Open Device Failed\r\n")));
        FreeVirAddr(s6410PWR, sizeof(S3C6410_SYSCON_REG));
        return FALSE;
    }

    if(JPGSetClkDiv(JPG_CLOCK_DIVIDER_RATIO_QUARTER) == FALSE)
    {
        RETAILMSG(1, (TEXT("DD:: JPEG - Set Clock Divider Failed\r\n")));
        CloseHandle(hPwrControl);
        FreeVirAddr(s6410PWR, sizeof(S3C6410_SYSCON_REG));
        return FALSE;
    }

    // Mutex initialization
    h_Mutex = CreateJPGmutex();
    if (h_Mutex == NULL)
    {
        RETAILMSG(1, (TEXT("DD::JPG Mutex Initialize error : %d \r\n"),GetLastError()));
        CloseHandle(hPwrControl);
        FreeVirAddr(s6410PWR, sizeof(S3C6410_SYSCON_REG));
        return FALSE;
    }

    ret = LockJPGMutex();
    if(!ret)
    {
        RETAILMSG(1, (TEXT("DD::JPG Mutex Lock Fail\r\n")));
        DeleteJPGMutex();
        CloseHandle(hPwrControl);
        FreeVirAddr(s6410PWR, sizeof(S3C6410_SYSCON_REG));
        return FALSE;
    }

    // Register/Memory initialization
    JPGRegCtx = (S3C6410_JPG_CTX *)malloc(sizeof(S3C6410_JPG_CTX));
    if (!JPGRegCtx)
    {
        RETAILMSG(1, (TEXT("DD::JPG Memory Context Allocation Fail\r\n")));
        UnlockJPGMutex();
        DeleteJPGMutex();
        CloseHandle(hPwrControl);
        FreeVirAddr(s6410PWR, sizeof(S3C6410_SYSCON_REG));
        return FALSE;
    }
    memset(JPGRegCtx, 0x00, sizeof(S3C6410_JPG_CTX));

    if( !JPGMemMapping(JPGRegCtx) )
    {
        RETAILMSG(1, (TEXT("DD::JPEG-HOST-MEMORY Initialize error : %d \r\n"),GetLastError()));
        free(JPGRegCtx);
        UnlockJPGMutex();
        DeleteJPGMutex();
        CloseHandle(hPwrControl);
        FreeVirAddr(s6410PWR, sizeof(S3C6410_SYSCON_REG));
        return FALSE;
    }
    else
    {
        if(!JPGBuffMapping(JPGRegCtx))
        {
            RETAILMSG(1, (TEXT("DD::JPEG-DATA-MEMORY Initialize error : %d \r\n"),GetLastError()));
            JPGMemFree(JPGRegCtx);
            free(JPGRegCtx);
            UnlockJPGMutex();
            DeleteJPGMutex();
            CloseHandle(hPwrControl);
            FreeVirAddr(s6410PWR, sizeof(S3C6410_SYSCON_REG));
            return FALSE;
        }
    }

    instanceNo = 0;

    UnlockJPGMutex();
    return (DWORD)JPGRegCtx;
}


/*----------------------------------------------------------------------------
*Function: JPG_DeInit

*Parameters:         InitHandle        :
*Return Value:        True/False
*Implementation Notes: Deinitialize JPEG Hardware
-----------------------------------------------------------------------------*/
BOOL
JPG_Deinit(
    DWORD InitHandle
    )
{
    DWORD    ret;
    S3C6410_JPG_CTX *JPGRegCtx;

    printD("DD::JPG_Deinit\n");

    JPGRegCtx = (S3C6410_JPG_CTX *)InitHandle;
    if(!JPGRegCtx)
    {
        RETAILMSG(1, (TEXT("DD::JPG Invalid Input Handle\r\n")));
        return FALSE;
    }

    ret = LockJPGMutex();
    if(!ret)
    {
        RETAILMSG(1, (TEXT("DD::JPG Mutex Lock Fail\r\n")));
        return FALSE;
    }

    JPGBuffFree(JPGRegCtx);
    JPGMemFree(JPGRegCtx);
    free(JPGRegCtx);
    UnlockJPGMutex();

    DeleteJPGMutex();
    if (hPwrControl)
        CloseHandle(hPwrControl);
    if (s6410PWR)
        FreeVirAddr(s6410PWR, sizeof(S3C6410_SYSCON_REG));

    return TRUE;
}


/*----------------------------------------------------------------------------
*Function: JPG_Open

*Parameters:         InitHandle        :Handle to JPEG  context
                    dwAccess        :
                    dwShareMode        :File share mode of JPEG
*Return Value:        This function returns a handle that identifies the
                    open context of JPEG  to the calling application.
*Implementation Notes: Opens JPEG CODEC device for reading, writing, or both
-----------------------------------------------------------------------------*/
DWORD
JPG_Open(
    DWORD InitHandle,
    DWORD dwAccess,
    DWORD dwShareMode
    )
{
    S3C6410_JPG_CTX *JPGRegCtx;
    DWORD    ret;

    printD("DD::JPG_open \r\n");

    JPGPowerControl(TRUE);

    JPGRegCtx = (S3C6410_JPG_CTX *)InitHandle;
    if(!JPGRegCtx)
    {
        RETAILMSG(1, (TEXT("DD::JPG Invalid Input Handle\r\n")));
        return FALSE;
    }

    ret = LockJPGMutex();
    if(!ret)
    {
        RETAILMSG(1, (TEXT("DD::JPG Mutex Lock Fail\r\n")));
        return FALSE;
    }

    // check the number of instance
    if(instanceNo > MAX_INSTANCE_NUM)
    {
        RETAILMSG(1, (TEXT("DD::Instance Number error-JPEG is running\r\n")));
        UnlockJPGMutex();
        return FALSE;
    }

    instanceNo++;
    PowerChange = FALSE;

    printD("instanceNo : %d\n", instanceNo);

    UnlockJPGMutex();
    return (DWORD)JPGRegCtx;
}


/*----------------------------------------------------------------------------
*Function: JPG_Close

*Parameters:         OpenHandle        :
*Return Value:        True/False
*Implementation Notes: This function closes the device context identified by
                        OpenHandle
-----------------------------------------------------------------------------*/
BOOL
JPG_Close(
    DWORD OpenHandle
    )
{
    DWORD    ret;
    S3C6410_JPG_CTX *JPGRegCtx;
    BOOL    result = TRUE;

    printD("DD::JPG_Close\n");
    
    if(PowerChange == TRUE)
    {
        RETAILMSG(1, (TEXT("DD::Power state is changed after open\r\n")));
        return FALSE;
    }

    JPGRegCtx = (S3C6410_JPG_CTX *)OpenHandle;
    if(!JPGRegCtx)
    {
        RETAILMSG(1, (TEXT("DD::JPG Invalid Input Handle\r\n")));
        return FALSE;
    }

    ret = LockJPGMutex();
    if(!ret)
    {
        RETAILMSG(1, (TEXT("DD::JPG Mutex Lock Fail\r\n")));
        return FALSE;
    }
    
    if((--instanceNo) < 0)
        instanceNo = 0;

#if    (_WIN32_WCE >= 600)
#ifdef E2E
{
    printD("JPGRegCtx->callerProcess : 0x%x\n", JPGRegCtx->callerProcess);

    if(JPGRegCtx->strUserBuf != NULL){
        result= VirtualFreeEx(JPGRegCtx->callerProcess,    // HANDLE hProcess
                                  JPGRegCtx->strUserBuf,
                                  0, 
                                  MEM_RELEASE);

        if (result== FALSE)
            RETAILMSG(1, (L"DD::JPG VirtualFreeEx(strUserBuf) returns FALSE.\n"));
        JPGRegCtx->strUserBuf = NULL;
    }

    if(JPGRegCtx->strUserThumbBuf != NULL){
        printD("decommit strUserThumbBuf\n");
        result= VirtualFreeEx(JPGRegCtx->callerProcess,    // HANDLE hProcess
                                  JPGRegCtx->strUserThumbBuf,
                                  0, 
                                  MEM_RELEASE);
        if (result== FALSE)
            RETAILMSG(1, (L"DD::JPG  VirtualFreeEx(strUserThumbBuf) returns FALSE.\n"));
        JPGRegCtx->strUserThumbBuf = NULL;
    }

    if(JPGRegCtx->frmUserBuf != NULL){
        printD("decommit frmUserBuf\n");
        result= VirtualFreeEx(JPGRegCtx->callerProcess,    // HANDLE hProcess
                                  JPGRegCtx->frmUserBuf,
                                  0, 
                                  MEM_RELEASE);
        if (result== FALSE)
            RETAILMSG(1, (L"DD::JPG  VirtualFreeEx(STRM_BUF) returns FALSE.\n"));
        JPGRegCtx->frmUserBuf = NULL;
    }

    if(JPGRegCtx->frmUserThumbBuf != NULL){
        printD("decommit frmUserThumbBuf\n");
        result= VirtualFreeEx(JPGRegCtx->callerProcess,    // HANDLE hProcess
                                  JPGRegCtx->frmUserThumbBuf,
                                  0, 
                                  MEM_RELEASE);
        if (result== FALSE)
            RETAILMSG(1, (L"DD::JPG  VirtualFreeEx(frmUserThumbBuf) returns FALSE.\n"));
        JPGRegCtx->frmUserThumbBuf = NULL;
    }

    if(JPGRegCtx->rgbBuf != NULL){
        printD("decommit rgbBuf\n");
        result= VirtualFreeEx(JPGRegCtx->callerProcess,    // HANDLE hProcess
                                  JPGRegCtx->rgbBuf,
                                  0, 
                                  MEM_RELEASE);