s3c6410_camera.cpp

6410BSP3

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this sample source code is subject to the terms of the Microsoft
// license agreement under which you licensed this sample source code. If
// you did not accept the terms of the license agreement, you are not
// authorized to use this sample source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the LICENSE.RTF on your install media or the root of your tools installation.
// THE SAMPLE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES OR INDEMNITIES.
//
//
// 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.

Module Name:    s3c6410_camera.cpp

Abstract:       Handle Camera device in Low level abstract

Functions:


Notes:


--*/

#include <bsp.h>
#include <types.h>
#include <string.h>
#include <stdio.h>
#include <tchar.h>
#include <pm.h>
#include "pmplatform.h"
#include <pmplatform.h>
#include "s3c6410_camera.h"
#include "Module.h"

// For Debug
#define CAM_MSG                0
#define CAM_INOUT            0
#define CAM_ERR                1
// Macros

// Definitions
//#define CAM_CLK_DIV            6
#define CAM_CLK_SOURCE            (S3C6410_HCLKx2)


// Register Control bit definition
// For CISRCFMT
#define CAM_MODE_ITU601_BIT             (1<<31)
// For CIGCTRL
#define CAM_EXTCAMERA_SWRESET_BIT       (1<<31)
#define CAM_EXTCAMERA_PROC_RESET_BIT    (1<<30)
#define CAM_CIGCTRL_RESERVED1           (1<<29)
#define CAM_CIGCTRL_EXTCAMERA_INPUT     (0<<27)
#define CAM_CIGCTRL_COLORBAR_TEST_PATTERN   (1<<27)
#define CAM_CIGCTRL_HORI_INCR_TEST_PATTERN  (2<<27)
#define CAM_CIGCTRL_VERT_INCR_TEST_PATTERN  (3<<27)

#define CAM_CODEC_SACLER_START_BIT            (1<<15)
#define CAM_PVIEW_SACLER_START_BIT            (1<<15)

#define CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT        (1<<31)
#define CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT        (1<<30)
#define CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT        (1<<29)

#define CAM_OFFSET_STEP                        (4)

// structures
typedef struct {
    UINT32    Width;
    UINT32    Height;
    int        Format;
    int     Size;
    int        FrameSize;
} BUFFER_DESC;

// Variables

// Pointer to camera driver instance which we will send back with callback functions
DWORD dwCameraDriverContext;

// Signals the application that the video or still image frame is available
PFNCAMHANDLEFRAME pfnCameraHandleVideoFrame = NULL;
PFNCAMHANDLEFRAME pfnCameraHandleStillFrame = NULL;
PFNCAMHANDLEFRAME pfnCameraHandlePreviewFrame = NULL;

volatile S3C6410_GPIO_REG *s6410IOP = NULL;
volatile S3C6410_CAMIF_REG    *s6410CAM = NULL;
//volatile S3C6410_INTR_REG    *s6410INT = NULL;
volatile S3C6410_SYSCON_REG *s6410PWR = NULL;

//mio
static BUFFER_DESC    Video_Buffer;
static BUFFER_DESC    Still_Buffer;
static BUFFER_DESC    Preview_Buffer;

static PHYSICAL_ADDRESS PhysPreviewAddr;
static PHYSICAL_ADDRESS PhysCodecAddr;

static PBYTE    pPreviewVirtAddr;
static PBYTE    pCodecVirtAddr;

static BYTE     PreviewOn=0;
static BYTE     CodecOn=0;
static BYTE     VideoOn=0;
static BYTE     StillOn=0;

static UINT32   PreviewFrameCnt=0;            // this is for skipping first 3 frames. Because first 3 frames are useless.
static UINT32   CodecFrameCnt=0;            // this is for skipping first 3 frames. Because first 3 frames are useless.

static INT32    g_iHorOffset1=0;
static INT32    g_iVerOffset1=0;
static INT32    g_iHorOffset2=0;
static INT32    g_iVerOffset2=0;
static UINT32   g_uCamIrqForCapture = IRQ_CAMIF_C;
static UINT32   g_uCamSysIntrForCapture = SYSINTR_UNDEFINED;
static UINT32   g_uCamIrqForPreview = IRQ_CAMIF_P;
static UINT32   g_uCamSysIntrForPreview = SYSINTR_UNDEFINED;

static HANDLE   hCaptureThread;
static BOOL     bCaptureThreadExit = FALSE;
static HANDLE   hCaptureEvent;
static HANDLE   hPreviewThread;
static BOOL     bPreviewThreadExit = FALSE;
static HANDLE   hPreviewEvent;

static HANDLE   hPwrControl;
// Functions

static BOOL     bPowerOn=TRUE;

static void CameraGpioInit();               
static void CameraInterfaceReset();     
static void CameraModuleReset();        
static void CameraSetClockDiv();        
static void CameraCaptureSourceSet();        // Set source registers

static void CameraSetCodecRegister(UINT32 width, UINT32 height, int Format);
static void CameraSetPreviewRegister(UINT32 width, UINT32 height, int Format);

static void CameraSetScaler(UINT32 width, UINT32 height, int path);
static void CalculateBurstSize(unsigned int hSize,unsigned int *mainBurstSize,unsigned int *remainedBurstSize);
static void CalculatePrescalerRatioShift(unsigned int SrcSize, unsigned int DstSize, unsigned int *ratio,unsigned int *shift);

static UINT32 CalculateBufferSize(UINT32 width, UINT32 height, int format);

static BOOL InitializeBuffer();
static BOOL DeinitializeBuffer();

static BOOL InterruptInitialize();

static DWORD WINAPI CameraCaptureThread(void);
static DWORD WINAPI CameraPreviewThread(void);

static void Delay(UINT32 count)
{
    volatile int i, j = 0;
    volatile static int loop = S3C6410_ACLK/100000;

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

int CameraInit(void *pData)
{
    PHYSICAL_ADDRESS    ioPhysicalBase = {0,0};
    RETAILMSG(CAM_INOUT,(TEXT("++%s\n"), __FUNCTION__));
    // 0. Map to Virtual Address

    // GPIO Virtual alloc
    ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_GPIO;
    s6410IOP = (S3C6410_GPIO_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_GPIO_REG), FALSE);
    if (s6410IOP == NULL)
    {
        goto CleanUp;
    }

    // Camera Virtual alloc
    ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_CAMIF;
    s6410CAM = (S3C6410_CAMIF_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_CAMIF_REG), FALSE);
    if (s6410CAM == NULL)
    {
        goto CleanUp;
    }

    // PWM clock Virtual alloc
    ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_SYSCON;
    s6410PWR = (S3C6410_SYSCON_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_SYSCON_REG), FALSE);
    if (s6410PWR == NULL)
    {
        goto CleanUp;
    }

    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(CAM_ERR, (TEXT("[CAM] CameraInit() : PWC0 Open Device Failed\r\n")));
        return FALSE;
    }

    ModuleInit();

    CameraSetClockDiv();

    // 1. Camera IO setup
    CameraGpioInit();    
    
    // 2. Camera Clock setup
    CameraClockOn(TRUE);

    // 3. camera module reset
    CameraModuleReset();    
    /*
    // Reserved Step
    // 4. Write Setting for Module using I2C
    if(!ModuleWriteBlock())
    {
        return FALSE;
    }    
    
    // 5. Camera i/f reset
    CameraInterfaceReset();

    // 6. Initialize I/F source register
    CameraCaptureSourceSet();
    */
    // 7. Camera Clock Off
    CameraClockOn(FALSE);  
        
    // 8. Allocation Buffer();
    if(!InitializeBuffer())
    {
        return FALSE;
    }

    // 9. Interrupt Initlaize();
    if(!InterruptInitialize())
    {
        return FALSE;
    }

    RETAILMSG(CAM_INOUT,(TEXT("--%s Succeeded\n"), __FUNCTION__));

    return TRUE;

CleanUp:
    RETAILMSG(1,(TEXT("%s : Failed, ioPhysicalBase(0x%x,0x%x)\r\n"), __FUNCTION__, ioPhysicalBase.LowPart, ioPhysicalBase.HighPart));
    return FALSE;
}

void CameraDeinit()
{
    RETAILMSG(CAM_INOUT,(TEXT("++++++++++++++++++CameraDeInit\n")));

    if(s6410IOP != NULL)
    {
        MmUnmapIoSpace((PVOID)s6410IOP, sizeof(S3C6410_GPIO_REG));
        s6410IOP = NULL;
    }
    if(s6410CAM != NULL)
    {
        MmUnmapIoSpace((PVOID)s6410CAM, sizeof(S3C6410_CAMIF_REG));
        s6410CAM = NULL;
    }
    if(s6410PWR != NULL)
    {
        MmUnmapIoSpace((PVOID)s6410PWR, sizeof(S3C6410_SYSCON_REG));
        s6410PWR = NULL;
    }

    ModuleDeinit();
    DeinitializeBuffer();

    
//    CloseHandle(hCaptureThread);
//    CloseHandle(hPreviewThread);
    bCaptureThreadExit = TRUE;
    SetEvent(hCaptureEvent);
    bPreviewThreadExit = TRUE;
    SetEvent(hPreviewEvent);
    CloseHandle(hCaptureEvent);
    CloseHandle(hPreviewEvent);
    RETAILMSG(CAM_INOUT,(TEXT("------------------CameraDeInit\n")));
}

void CameraGpioInit()        //    Initialize GPIO setting for Camera Interface
{
    s6410IOP->GPFPUD = (s6410IOP->GPFPUD & ~(0x3ffffff));         // CAM IO PullUpDown Disable setup except CAMRESET
    s6410IOP->GPFCON = (s6410IOP->GPFCON & ~(0x3ffffff)) | 0x2aaaaaa;
}

void CameraInterfaceReset()    // Reset Camera Inteface IP
{
    // This functin is used on power handler operation.
    // So, you should not use Kernel API functions as like as "Sleep()".

    MODULE_DESCRIPTOR value;

    ModuleGetFormat(value);
    //
    // Camera (FIMC2.0) I/F Reset
    //
    // Recommended Camera Interface reset sequence in S3C6410 User manual
    s6410CAM->CISRCFMT |= (CAM_MODE_ITU601_BIT);
    s6410CAM->CIGCTRL |= (CAM_EXTCAMERA_SWRESET_BIT);
    s6410CAM->CIGCTRL &= ~(CAM_EXTCAMERA_SWRESET_BIT);

    if(value.ITUXXX == CAM_ITU656)
    {
        s6410CAM->CISRCFMT &= ~(CAM_MODE_ITU601_BIT);
    }
}

void CameraModuleReset()        // Reset Camera Module
{
    MODULE_DESCRIPTOR value;

    ModuleGetFormat(value);

    if(value.HighRst)
    {
        s6410CAM->CIGCTRL |= (CAM_EXTCAMERA_PROC_RESET_BIT);
        // Don't modify this delay time
        Delay(100);
        s6410CAM->CIGCTRL &= ~(CAM_EXTCAMERA_PROC_RESET_BIT);
        // Wait for Camera module initialization
        Delay(1000);
    }
    else
    {
        s6410CAM->CIGCTRL &= ~(CAM_EXTCAMERA_PROC_RESET_BIT);
        // Wait for Camera module initialization
        Delay(100);

        s6410CAM->CIGCTRL |= (CAM_EXTCAMERA_PROC_RESET_BIT);
        // Don't modify this delay time
        Delay(1000);
    }
}

void CameraClockOn(BOOL bOnOff)
{
    DWORD dwIPIndex = PWR_IP_CAMIF;
    DWORD dwBytes;    
    static int isOn = 0;
    RETAILMSG(CAM_INOUT,(TEXT("++++++++++++++++++[CAM] CameraClockOn %d\n"),bOnOff));
    // Camera clock
    if (!bOnOff)
    {
        if(isOn == 1)
        {
            isOn = 0;
            s6410PWR->HCLK_GATE &= ~(1<<10); // Camera clock disable
            s6410PWR->SCLK_GATE &= ~(1<<2); // Camera clock disable        
            if ( !DeviceIoControl(hPwrControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
            {
                RETAILMSG(CAM_ERR,(TEXT("[CAM:ERR] CameraClockOn(%d) : IOCTL_PWRCON_SET_POWER_OFF Failed\r\n")));
            }            
            bPowerOn=FALSE;
        }
    }
    else 
    {
        if(isOn == 0)
        {
            isOn = 1;
            
            if ( !DeviceIoControl(hPwrControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
            {
                RETAILMSG(CAM_ERR,(TEXT("[CAM:ERR] CameraClockOn(%d) : IOCTL_PWRCON_SET_POWER_OFF Failed\r\n")));
            }        

            bPowerOn=TRUE;

            s6410PWR->HCLK_GATE |= (1<<10); // Camera clock enable
            s6410PWR->SCLK_GATE |= (1<<2); // Camera clock enable        
            Delay(1000);
        }
    }
    RETAILMSG(CAM_INOUT,(TEXT("------------------[CAM] CameraClockOn\n")));
}

void CameraCaptureSourceSet()        // Set source registers
{
    UINT32 WinOfsEn=0;
    RETAILMSG(CAM_INOUT,(TEXT("++++++++++++++++++CameraCaptureSourceSet\n")));
    MODULE_DESCRIPTOR value;

    ModuleGetFormat(value);

    s6410CAM->CIGCTRL = ((value.HighRst ? (0<<30) : (CAM_EXTCAMERA_PROC_RESET_BIT))) |
                        (CAM_CIGCTRL_RESERVED1) | (CAM_CIGCTRL_EXTCAMERA_INPUT) | 
                        (value.InvPCLK<<26)|
                        (value.InvVSYNC<<25)|(value.InvHREF<<24)|(0<<22)|(1<<21)|(1<<20); // inverse PCLK
    s6410CAM->CIWDOFST = (1<<30)|(0xf<<27)|(0xf<<12); // clear overflow
    s6410CAM->CIWDOFST = 0;

    if((value.SourceHOffset > 0) || (value.SourceVOffset > 0))
    {
        WinOfsEn=1;
    }
    s6410CAM->CIWDOFST = (WinOfsEn<<31)|(value.SourceHOffset <<16)|(value.SourceVOffset);
    s6410CAM->CIDOWSFT2 = (value.SourceHOffset <<16)|(value.SourceVOffset);

    //TODO:: Set Offset for scaler
    s6410CAM->CISRCFMT = (value.ITUXXX<<31)|(value.UVOffset<<30)|(0<<29)|
                            (value.SourceHSize<<16)|(value.Order422<<14)|(value.SourceVSize);

    RETAILMSG(CAM_MSG,(TEXT("s6410CAM->CISRCFMT=0x%08X\n"),s6410CAM->CISRCFMT));
    RETAILMSG(CAM_INOUT,(TEXT("------------------CameraCaptureSourceSet\n")));
}

int CameraPrepareBuffer(P_CAMERA_DMA_BUFFER_INFO pBufInfo, int BufferType)        // allocate DMA buffer
{
    int i,size;
    int sizeY,sizeC;

    RETAILMSG(CAM_INOUT,(TEXT("++++++++++++++++++CameraPrepareBuffer\n")));


    if(BufferType == VIDEO_CAPTURE_BUFFER)
    {
        size = CalculateBufferSize(Video_Buffer.Width, Video_Buffer.Height, Video_Buffer.Format);
        Video_Buffer.FrameSize = size;
        Video_Buffer.Size = size * MAX_HW_FRAMES;
        RETAILMSG(CAM_MSG,(TEXT("Video_Buffer.Width=%d Video_Buffer.Height=%d Video_Buffer.Size=%d  Video_Buffer.Format=%d\n"),Video_Buffer.Width, Video_Buffer.Height, Video_Buffer.Size, Video_Buffer.Format));

        if(Video_Buffer.Size > CAPTURE_BUFFER_SIZE)
        {
            RETAILMSG(CAM_ERR,(TEXT("Video size is larger than buffer size\n")));
            return FALSE;
        }

        for(i=0;i<MAX_HW_FRAMES;i++)
        {
            pBufInfo[i].VirtAddr = (DWORD)pCodecVirtAddr + size*i;
            pBufInfo[i].size = size;
            pBufInfo[i].pY = (DWORD*)((DWORD)(PhysCodecAddr.LowPart) + size*i);
        }

        if(OUTPUT_CODEC_YCBCR420 == Video_Buffer.Format)
        {