dda_previewer.c

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

                else /* memory is allocated successfully */
                {
                    DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
                    /* update port structure as well as channel structure at DDA
                     * layer */
                    prevOpenPortHandle->channelHandle
                        = (DDA_prevChannelHandle)prevOpenChannelHandle;
                    prevOpenPortHandle->channelHandle->portHandle
                        = prevOpenPortHandle;
                    /* call DDC_prevOpenHandle to open channel at DDC layer */
                    prevOpenDDCRetCode = DDC_prevOpenHandle(chanParams,
                        &(prevOpenPortHandle->channelHandle->ddcChannelHandle),
                        &ddaPrevInterruptMapRequired,
                        (Uint8*)(&ddaPrevInterruptMapInfo),
                        (ddcISRType*)(&prevCreateIsrFuncPtr));
                    /* if open DDC channel fails, raise an error */
                    if (DDC_PREV_SOK != prevOpenDDCRetCode)
                    {
                        /* free allocated memory as instance creation has been
                         * failed */
                        MEM_free(ddaPrevSegId, prevOpenChannelHandle,
                            sizeof(DDA_prevChannelObject));
                        prevOpenPortHandle->channelHandle = NULL;
                        prevOpenReturnCode
                            = DDA_DDCtoDDAErrorCode(prevOpenDDCRetCode);
                        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
                        DDA_PREVIEWER_DEBUG_PRINT("Wrong ret from");
                        DDA_PREVIEWER_DEBUG_PRINT(" OpenHandle\n");
                    }
                    else /* if DDC channel is open successfully */
                    {
                        DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
                        prevOpenReturnCode = PSP_SOK;
                        if (DDC_PREVIEWER_INTERRUPT_MAPPING_NEEDED
                            == ddaPrevInterruptMapRequired)
                        {
                            DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
                            /* call DDA_prevSetInterrupt, pass
                             * ddaPrevInterruptMapInfo it will map interrupt */
                            DDA_prevSetInterrupt(ddaPrevInterruptMapInfo,
                                (ECM_Fxn)prevCreateIsrFuncPtr);
                        }
                        DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
                        *chanHandle = (Ptr)(prevOpenPortHandle->channelHandle);
                    } /* end if PSP_SOK == ... for DDC_prevOpenHandle */
                } /* end if NULL neq prevOpenChannelHandle */
            } /* end if  DDA_PREVIEWER_DEVICE_DELETED eq ... */
        } /* end if ddaPrevPortObj neq prevOpenPortHandle  */
    }
    return prevOpenReturnCode;
}



/**
 * \brief  PSP_prevIoctl
 * It Control Channel of the previewer device.
 */
PSP_Result PSP_prevIoctl(PSP_Handle chanHandle,
    PSP_previewerControlCmd cmd,
    Ptr cmdArg)
{
    PSP_Result prevIoctlReturnCode = PSP_E_DRIVER_INIT;
    DDC_prevResult prevIoctlDDCRetCode = DDC_PREV_NOT_SUPPORTED;

    if ((NULL == chanHandle)
        || (ddaPrevPortObj.channelHandle != (DDA_prevChannelHandle)chanHandle))
    {
        prevIoctlReturnCode = PSP_E_INVAL_PARAM;
        DDA_PREVIEWER_DEBUG_PRINT("Invalid Parameter\n");
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {
        DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
        prevIoctlDDCRetCode = DDC_prevIoctl((DDC_prevChannelHandle)
            (((DDA_prevChannelHandle)chanHandle)->ddcChannelHandle),
            cmd, cmdArg);
        if (DDC_PREV_SOK != prevIoctlDDCRetCode)
        {
            prevIoctlReturnCode
                = DDA_DDCtoDDAErrorCode(prevIoctlDDCRetCode);
            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
            DDA_PREVIEWER_DEBUG_PRINT("Wrong ret from Ioctl\n");
        }
        else
        {
            DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
            prevIoctlReturnCode = PSP_SOK;
        }
    }
    return prevIoctlReturnCode;
}



/**
 * \brief  PSP_prevClose
 * It is used to close Channel of the previewer device.
 */
PSP_Result PSP_prevClose(PSP_Handle chanHandle)
{
    PSP_Result prevCloseReturnCode = PSP_E_DRIVER_INIT;
    DDC_prevResult prevCloseDDCRetCode = DDC_PREV_NOT_SUPPORTED;

    if ((NULL == chanHandle)
        || ((DDA_prevChannelHandle)chanHandle != ddaPrevPortObj.channelHandle))
    {
        prevCloseReturnCode = PSP_E_INVAL_PARAM;
        DDA_PREVIEWER_DEBUG_PRINT("Invalid Parameter\n");
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {
        DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
        /* close channel at DDC layer */
        prevCloseDDCRetCode = DDC_prevCloseHandle(
            (ddaPrevPortObj.channelHandle)->ddcChannelHandle);
        if (DDC_PREV_SOK != prevCloseDDCRetCode)
        {
            prevCloseReturnCode
                = DDA_DDCtoDDAErrorCode(prevCloseDDCRetCode);
            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
            DDA_PREVIEWER_DEBUG_PRINT("Wrong ret from CloseHandle\n");
        }
        else
        {
            DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
            if (DDC_PREVIEWER_INTERRUPT_MAPPING_NEEDED
                == ddaPrevInterruptMapRequired)
            {
                DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
                /* deactivate interrupt */
                DDA_prevUnsetInterrupt(ddaPrevInterruptMapInfo);
            }
            DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
            /* free allocated memory */
            MEM_free(ddaPrevSegId, ddaPrevPortObj.channelHandle,
                sizeof(DDA_prevChannelObject));
            ddaPrevPortObj.channelHandle = NULL;
            prevCloseReturnCode = PSP_SOK;
        }
    }
    return prevCloseReturnCode;
}



/**
 * \brief  PSP_prevDelete
 * It is used to delete a given previewer device at DDA layer.
 */
PSP_Result PSP_prevDelete(PSP_Handle devHandle)
{
    PSP_Result prevDeleteReturnCode = PSP_E_DRIVER_INIT;
    DDC_prevResult prevDeleteDDCRetCode = DDC_PREV_NOT_SUPPORTED;
    /* if passed port structure is different then global port structure,
     * raise an error */
    if ((NULL == devHandle)
        || ((DDA_prevPortHandle)devHandle  != (&ddaPrevPortObj)))
    {
        prevDeleteReturnCode = PSP_E_INVAL_PARAM;
        DDA_PREVIEWER_DEBUG_PRINT("Invalid Parameter\n");
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {
        DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
        /* device instance must be in created state and channel handle should
         * be null */
        if ((DDA_PREVIEWER_DEVICE_CREATED == ddaPrevPortObj.state)
            && (NULL == ddaPrevPortObj.channelHandle))
        {
            DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
            prevDeleteDDCRetCode = DDC_prevDeviceDelete(
                ddaPrevPortObj.ddcDeviceHandle);
            if (DDC_PREV_SOK != prevDeleteDDCRetCode)
            {
                prevDeleteReturnCode
                    = DDA_DDCtoDDAErrorCode(prevDeleteDDCRetCode);
                PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
                DDA_PREVIEWER_DEBUG_PRINT("Wrong ret from DeviceDelete\n");
            }
            else
            {
                DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
                ddaPrevPortObj.ddcDeviceHandle = NULL;
                ddaPrevPortObj.state = DDA_PREVIEWER_DEVICE_DELETED;
                prevDeleteReturnCode = PSP_SOK;
            }
        }
        else
        {
            prevDeleteReturnCode = PSP_E_INVAL_STATE;
            DDA_PREVIEWER_DEBUG_PRINT("Invalid State\n");
            PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
        }

    }
    return prevDeleteReturnCode;
}


/**
 * \brief  PSP_prevGetPSPHandle
 * It returns PSP handle of channel object.
 */
PSP_Result PSP_prevGetPSPHandle(PSP_Handle *chanHandle)
{
    PSP_Result prevGetPSPReturnCode = PSP_E_DRIVER_INIT;

    /* parameter validation */
    if (NULL == chanHandle)
    {
        prevGetPSPReturnCode = PSP_E_INVAL_PARAM;
        DDA_PREVIEWER_DEBUG_PRINT("Invalid Parameter\n");
        PREVIEWER_DEBUG_ERR_TRACE(__LINE__);
    }
    else
    {
        DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
        *chanHandle = (PSP_Handle)(ddaPrevPortObj.channelHandle);
        prevGetPSPReturnCode = PSP_SOK;
    }
    return prevGetPSPReturnCode;
}


/**
 * \brief  DDA_prevSetInterrupt
 * it is used to enable interrupt and mapped particular interrupt to
 * isrRoutine.
 */
static void DDA_prevSetInterrupt(Uint8 intNum, ECM_Fxn isrRoutine)
{
    ECM_Attrs prevSetIntrEcmAttrs = ECM_ATTRS;
    DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);

    /* Disabling the event */
    ECM_disableEvent((Uns)intNum);

    /* Mapping the eventid to the ECM Dispatch of the DSP/BIOS*/
    prevSetIntrEcmAttrs.unmask = 1u;
    ECM_dispatchPlug((Uns)intNum, isrRoutine, &prevSetIntrEcmAttrs);

    /* Enabling the event */
    ECM_enableEvent((Uns)intNum);

    C64_enableIER(HWI_EVT01_CMB_IRQ);

    DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);

    return;
}



/**
 * \brief  DDA_prevUnsetInterrupt
 * It is used to disable particular interrupt.
 */
static void DDA_prevUnsetInterrupt(Uint8 intNum)
{
    DDA_PREVIEWER_DEBUG_REG_TRACE(__LINE__);
    ECM_disableEvent((Uns)intNum);
    return;
}



/**
 * \brief DDA_DDCtoDDAErrorCode
 * It is used to map DDC error codes to PSP error codes.
 */
static PSP_Result DDA_DDCtoDDAErrorCode(DDC_prevResult ddcErrorCode)
{
    PSP_Result pspErrorCode = PSP_E_DRIVER_INIT;
    switch(ddcErrorCode)
    {
        case DDC_PREV_INVALID_STATE:
            pspErrorCode = PSP_E_INVAL_STATE;
            break;
        case DDC_PREV_INVALID_PARAM:
            pspErrorCode = PSP_E_INVAL_PARAM;
            break;
        case DDC_PREV_MEMORY_ERROR:
            pspErrorCode = PSP_E_NO_MEMORY;
            break;
        case DDC_PREV_RESOURCE_ERROR:
            pspErrorCode = PSP_E_RESOURCES;
            break;
        case DDC_PREV_OVERFLOW_ERROR:
            pspErrorCode = PSP_E_IO_CANCEL_FAIL;
            break;
        case DDC_PREV_NOT_SUPPORTED:
            pspErrorCode = PSP_E_NOT_SUPPORTED;
            break;
        default:
            pspErrorCode = PSP_E_DRIVER_INIT;
            break;
    }
    return pspErrorCode;
}