ddc_previewer.c

the preview code includes auto focus, auto whitebalance. it is on TI DM6437 platform

/**
 *  \brief DDC_prevValidateOutputParams
 *
 *  It will validate output image parameters for previewer
 *
 *  \param  ddcChannelHandle     [IN]  channel handle
 *  \param  outBufSize           [IN] output buffer size as specified by
 *                                    applicaion
 *  \param  outBuf               [IN] output buffer address as specified by
 *                                    applicaion
 *  \return  success    DDC_PREV_SOK
 *           failure    DDC error
 */
static DDC_prevResult DDC_prevValidateOutputParams(
    DDC_prevChannelHandle ddcChannelHandle,
    Int32 outBufSize, Ptr outBuf
    );


/**
 *  \brief DDC_prevGetInfoForCCDC
 *
 *  It will get information related to CCDC
 *
 *  \param  ddcChannelHandle  [IN]  channel handle
 *  \param  prevInfo          [OUT] info struct required by CCDC
 *  \return  success    DDC_PREV_SOK
 *           failure    DDC error
 */
static DDC_prevResult DDC_prevGetInfoForCCDC(
    DDC_prevChannelHandle ddcChannelHandle,
    PSP_previewerGetInfoForCCDC *prevInfo
    );



/******************************************************************************
  Data-Structures
 ******************************************************************************/
/**
 * \brief previewer object of device structure at DDC layer
 */
DDC_prevDeviceObject ddcPrevDeviceObj = { DDC_PREV_UNINIT_ISR_NO, NULL, NULL };

/******************************************************************************
  Functions
 ******************************************************************************/



/**
 *  \brief DDC_prevDeviceCreate
 *  It creates a given previewer device at DDC layer.
 */
DDC_prevResult DDC_prevDeviceCreate(PSP_Handle *ddcDeviceHandle)
{
    DDC_prevResult devCreateReturnCode = DDC_PREV_NOT_SUPPORTED;
    PAL_Result devCreatePalReturnCode = PAL_OS_ERROR_NOT_SUPPORTED;

    /* parameter validation */
    if (NULL == ddcDeviceHandle)
    {
        devCreateReturnCode = DDC_PREV_INVALID_PARAM;
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {
        /* create a semaphore for ISR */
        devCreatePalReturnCode = PAL_osSemCreate("isrSem",
            DDC_PREV_INIT_ISR_SEM, NULL, &(ddcPrevDeviceObj.semIsr));
        if (PAL_SOK != devCreatePalReturnCode)
        {
            devCreateReturnCode = DDC_PREV_RESOURCE_ERROR;
            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
        }
        /* assign device object to passed ddcDeviceHandle */
        *(ddcDeviceHandle) = (Ptr)(&ddcPrevDeviceObj);
        devCreateReturnCode = DDC_prevPerformRegOverlaying();
    }
    return devCreateReturnCode;
}



/**
 *  \brief DDC_prevOpenHandle
 *  It opens Channel of the previewer device at DDC layer.
 */
DDC_prevResult DDC_prevOpenHandle(
    PSP_previewerChannelCreateMode *chanParams,
    PSP_Handle *ddcChannelHandle,
    Uint32 *interruptMapRequired,
    Uint8 *interruptMapInfo,
    ddcISRType *isrFunc
    )
{
    DDC_prevResult openHandleReturnCode = DDC_PREV_NOT_SUPPORTED;
    PAL_Result openHandlePalReturnCode = PAL_OS_ERROR_NOT_SUPPORTED;
    Ptr openHandleChannelHandle = NULL;
    CSL_Status openHandleCSLReturnCode = CSL_ESYS_FAIL;

    /* parameter validation */
    if (((NULL == chanParams) || (NULL == ddcChannelHandle))
        || (((NULL == interruptMapRequired) || (NULL == interruptMapInfo))
            || (NULL == isrFunc)))
    {
        openHandleReturnCode = DDC_PREV_INVALID_PARAM;
        DDC_PREVIEWER_DEBUG_PRINT("Invalid Param\n");
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {
        /* if source is SDRAM */
        if ((PSP_PREVIEWER_CHANNEL_SDRAM == (chanParams->chanSource).source)
            || (PSP_PREVIEWER_CHANNEL_CCDC == (chanParams->chanSource).source))
        {
            openHandlePalReturnCode = PAL_osMemAlloc(chanParams->segId,
                sizeof(DDC_prevChannelObject), 0, &openHandleChannelHandle);
            /* if system is failed to allocate memory */
            if ((PAL_SOK != openHandlePalReturnCode)
                || (NULL == openHandleChannelHandle))
            {
                openHandleReturnCode = DDC_PREV_MEMORY_ERROR;
                DDC_PREVIEWER_DEBUG_PRINT("Memory Error\n");
                PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
            }
            else
            {
                /* create a semaphore for channel */
                openHandlePalReturnCode = PAL_osSemCreate("channelSem",
                    DDC_PREV_INIT_CHANNEL_SEM, NULL,
                    &(((DDC_prevChannelHandle)openHandleChannelHandle)
                        ->channelSem));
                if (PAL_SOK != openHandlePalReturnCode)
                {
                    openHandleReturnCode = DDC_PREV_RESOURCE_ERROR;
                    DDC_PREVIEWER_DEBUG_PRINT("Resource Error\n");
                    PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
                    /* free allocated memory as semaphore creation has been
                     * failed */
                    PAL_osMemFree(chanParams->segId, openHandleChannelHandle,
                        sizeof(DDC_prevChannelObject));
                }
                else
                {
                    ((DDC_prevChannelHandle)openHandleChannelHandle)
                        ->configState = DDC_PREVIEWER_CHANNEL_NOT_CONFIGURED;
                    (((DDC_prevChannelHandle)openHandleChannelHandle)
                     ->channelMode).chanSource.source
                        = (chanParams->chanSource).source;
                    (((DDC_prevChannelHandle)openHandleChannelHandle)
                     ->channelMode).segId
                        = chanParams->segId;

                    /* assign channel object to passed ddcChannelHandle */
                    *(ddcChannelHandle) = openHandleChannelHandle;
                    ddcPrevDeviceObj.intNum = CSL_INTC_EVENTID_PRVUINT;
                    if (PSP_PREVIEWER_CHANNEL_SDRAM
                        == (chanParams->chanSource).source)
                    {
                        *interruptMapRequired
                            = DDC_PREVIEWER_INTERRUPT_MAPPING_NEEDED;
                        *interruptMapInfo = ddcPrevDeviceObj.intNum;
                        *isrFunc = &DDC_prevISR;
                    }
                    else
                    {
                        *interruptMapRequired
                            = DDC_PREVIEWER_INTERRUPT_MAPPING_NOT_NEEDED;
                    }
                    openHandleCSLReturnCode
                        = LLC_prevResetPreviewer(ddcPrevDeviceObj.regs);
                    if (CSL_SOK != openHandleCSLReturnCode)
                    {
                        openHandleReturnCode = DDC_PREV_E_FAIL;
                    }
                    else
                    {
                        openHandleReturnCode = DDC_PREV_SOK;
                    }
                }
            }
        }
        else
        {
            openHandleReturnCode = DDC_PREV_NOT_SUPPORTED;
            DDC_PREVIEWER_DEBUG_PRINT("Not supported\n");
            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
        }
    }
    return openHandleReturnCode;
}



/**
 *  \brief DDC_prevIoctl
 *  It controls Channel of the previewer device.
 */
DDC_prevResult DDC_prevIoctl(
    PSP_Handle ddcChannelHandle,
    PSP_previewerControlCmd cmd,
    Ptr cmdArg
    )
{
    DDC_prevResult ioctlReturnCode = DDC_PREV_NOT_SUPPORTED;
    DDC_prevChannelHandle ioctlChannelHandle = NULL;

    /* parameter validation */
    if ((((NULL == ddcChannelHandle) || (PSP_PREVIEWER_IOCTL_MIN >= cmd))
            ||((PSP_PREVIEWER_IOCTL_MAX) <= cmd)))
    {
        ioctlReturnCode = DDC_PREV_INVALID_PARAM;
        DDC_PREVIEWER_DEBUG_PRINT("Invalid Param\n");
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {
        ioctlChannelHandle = (DDC_prevChannelHandle)ddcChannelHandle;
        /* call corresponding function as per ioctl type */
        switch (cmd)
        {
            case PSP_PREVIEWER_IOCTL_SET_PARAMS:
                ioctlReturnCode = DDC_prevSetParameters(ioctlChannelHandle,
                    (PSP_previewerParams*)cmdArg);
                break;
            case PSP_PREVIEWER_IOCTL_GET_PARAMS:
                ioctlReturnCode = DDC_prevGetParameters(ioctlChannelHandle,
                    (PSP_previewerParams*)cmdArg);
                break;
            case PSP_PREVIEWER_IOCTL_GET_STATUS:
                ioctlReturnCode = DDC_prevGetStatus(ioctlChannelHandle,
                    (PSP_previewerStatus*)cmdArg);
                break;
            case PSP_PREVIEWER_IOCTL_GET_DARK_FRAME_STATUS:
                ioctlReturnCode = DDC_prevGetDarkFrameStatus(ioctlChannelHandle,
                    (PSP_previewerDarkFrameStatus*)cmdArg);
                break;
            case PSP_PREVIEWER_IOCTL_PREVIEW:
                ioctlReturnCode = DDC_prevPreview(ioctlChannelHandle,
                    (PSP_preview*)cmdArg);
                break;
            case PSP_PREVIEWER_IOCTL_GET_CROPSIZE:
                ioctlReturnCode = DDC_prevGetCropSize(ioctlChannelHandle,
                    (PSP_previewerCropSize*)cmdArg);
                break;
            case PSP_PREVIEWER_IOCTL_SET_EXP:
                ioctlReturnCode = DDC_prevSetReadReqExpand(ioctlChannelHandle,
                    (PSP_previewerReadReqExp*)cmdArg);
                break;
            case PSP_PREVIEWER_GET_INFO_FOR_CCDC:
                ioctlReturnCode = DDC_prevGetInfoForCCDC(ioctlChannelHandle,
                    (PSP_previewerGetInfoForCCDC*)cmdArg);
                break;
            case PSP_PREVIEWER_SET_DARK_FRAME_CAPTURE:
                ioctlReturnCode = DDC_prevSetDFC(ddcChannelHandle,
                    (PSP_previewerDarkFrameCapture*)cmdArg);
                break;
            case PSP_PREVIEWER_GET_DARK_FRAME_CAPTURE:
                ioctlReturnCode = DDC_prevGetDFC(ddcChannelHandle,
                    (PSP_previewerDarkFrameCapture*)cmdArg);
                break;
            default:
                ioctlReturnCode = DDC_PREV_NOT_SUPPORTED;
                break;
        }
    }

    return ioctlReturnCode;
}



/**
 *  \brief DDC_prevCloseHandle
 *  It closes Channel of the previewer device at DDC layer.
 */
DDC_prevResult DDC_prevCloseHandle(PSP_Handle ddcChannelHandle)
{
    DDC_prevResult closeHandleReturnCode = DDC_PREV_NOT_SUPPORTED;
    PAL_Result closeHandlePalReturnCode = PAL_OS_ERROR_NOT_SUPPORTED;

    /* parameter validation */
    if (NULL == ddcChannelHandle)
    {
        closeHandleReturnCode = DDC_PREV_INVALID_PARAM;
        DDC_PREVIEWER_DEBUG_PRINT("Invalid Param\n");
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {
        /* take channel semaphore so that other ioctl functions can not be
         * called */
        closeHandlePalReturnCode = PAL_osSemTake(((DDC_prevChannelHandle)
                ddcChannelHandle)->channelSem, PAL_OSSEM_NO_TIMEOUT);
        if (PAL_SOK != closeHandlePalReturnCode)
        {
            closeHandleReturnCode = DDC_PREV_INVALID_STATE;
            DDC_PREVIEWER_DEBUG_PRINT("Invalid State\n");
            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
        }
        else
        {
            ddcPrevDeviceObj.intNum = DDC_PREV_UNINIT_ISR_NO;
            /* delete the channel semaphore */
            closeHandlePalReturnCode = PAL_osSemDelete(
                ((DDC_prevChannelHandle)ddcChannelHandle)->channelSem);
            if (PAL_SOK != closeHandlePalReturnCode)
            {
                PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
                closeHandleReturnCode = DDC_PREV_RESOURCE_ERROR;
                DDC_PREVIEWER_DEBUG_PRINT("Resource Error\n");
            }
            else
            {
                /* free allocated memory */
                closeHandlePalReturnCode = PAL_osMemFree(
                    (((DDC_prevChannelHandle)ddcChannelHandle)
                     ->channelMode).segId,
                    ddcChannelHandle, sizeof(DDC_prevChannelObject));
                if (PAL_SOK != closeHandlePalReturnCode)
                {
                    PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
                    closeHandleReturnCode = DDC_PREV_MEMORY_ERROR;
                    DDC_PREVIEWER_DEBUG_PRINT("Memory Error\n");
                }
                else
                {