fsl_dcic.h

/*
 * Copyright 2020-2022 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_DCIC_H_
#define _FSL_DCIC_H_
 
#include "fsl_common.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
#ifndef DCIC_REGION_COUNT
#define DCIC_REGION_COUNT DCIC_DCICRCS_COUNT
#endif
 
#define FSL_DCIC_DRIVER_VERSION (MAKE_VERSION(2, 0, 3))
 
#define DCIC_CRC32_POLYNOMIAL 0x04C11DB7UL
 
#define DCIC_CRC32_INIT_VALUE 0UL
 
#define DCIC_REGION_MISMATCH_STATUS(region) (1UL << (DCIC_DCICS_ROI_MATCH_STAT_SHIFT + (region)))
 
enum _DCIC_polarity_flags
{
    kDCIC_VsyncActiveHigh           = 0U, 
    kDCIC_HsyncActiveHigh           = 0U, 
    kDCIC_DataEnableActiveHigh      = 0U, 
    kDCIC_DriveDataOnFallingClkEdge = 0U, 
    kDCIC_VsyncActiveLow           = DCIC_DCICC_VSYNC_POL_MASK, 
    kDCIC_HsyncActiveLow           = DCIC_DCICC_HSYNC_POL_MASK, 
    kDCIC_DataEnableActiveLow      = DCIC_DCICC_DE_POL_MASK,    
    kDCIC_DriveDataOnRisingClkEdge = DCIC_DCICC_CLK_POL_MASK,   
};
 
enum _DCIC_status_flags
{
    kDCIC_FunctionalInterruptStatus = DCIC_DCICS_FI_STAT_MASK, 
    kDCIC_ErrorInterruptStatus      = DCIC_DCICS_EI_STAT_MASK, 
    kDCIC_Region0MismatchStatus     = DCIC_REGION_MISMATCH_STATUS(0U),  
    kDCIC_Region1MismatchStatus     = DCIC_REGION_MISMATCH_STATUS(1U),  
    kDCIC_Region2MismatchStatus     = DCIC_REGION_MISMATCH_STATUS(2U),  
    kDCIC_Region3MismatchStatus     = DCIC_REGION_MISMATCH_STATUS(3U),  
    kDCIC_Region4MismatchStatus     = DCIC_REGION_MISMATCH_STATUS(4U),  
    kDCIC_Region5MismatchStatus     = DCIC_REGION_MISMATCH_STATUS(5U),  
    kDCIC_Region6MismatchStatus     = DCIC_REGION_MISMATCH_STATUS(6U),  
    kDCIC_Region7MismatchStatus     = DCIC_REGION_MISMATCH_STATUS(7U),  
    kDCIC_Region8MismatchStatus     = DCIC_REGION_MISMATCH_STATUS(8U),  
    kDCIC_Region9MismatchStatus     = DCIC_REGION_MISMATCH_STATUS(9U),  
    kDCIC_Region10MismatchStatus    = DCIC_REGION_MISMATCH_STATUS(10U), 
    kDCIC_Region11MismatchStatus    = DCIC_REGION_MISMATCH_STATUS(11U), 
    kDCIC_Region12MismatchStatus    = DCIC_REGION_MISMATCH_STATUS(12U), 
    kDCIC_Region13MismatchStatus    = DCIC_REGION_MISMATCH_STATUS(13U), 
    kDCIC_Region14MismatchStatus    = DCIC_REGION_MISMATCH_STATUS(14U), 
    kDCIC_Region15MismatchStatus    = DCIC_REGION_MISMATCH_STATUS(15U), 
};
 
enum _dcic_interrupt_enable
{
    kDCIC_FunctionalInterruptEnable = DCIC_DCICIC_FI_MASK_MASK, 
    kDCIC_ErrorInterruptEnable      = DCIC_DCICIC_EI_MASK_MASK, 
};
 
typedef struct _dcic_config
{
    bool enableExternalSignal; 
    uint8_t polarityFlags;     
    uint32_t enableInterrupts; 
} dcic_config_t;
 
typedef struct _dcic_region_config
{
    bool lock;            
    uint16_t upperLeftX;  
    uint16_t upperLeftY;  
    uint16_t lowerRightX; 
    uint16_t lowerRightY; 
    uint32_t refCrc;      
} dcic_region_config_t;
 
#if defined(__cplusplus)
extern "C" {
#endif
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
void DCIC_Init(DCIC_Type *base, const dcic_config_t *config);
 
void DCIC_Deinit(DCIC_Type *base);
 
void DCIC_GetDefaultConfig(dcic_config_t *config);
 
static inline void DCIC_Enable(DCIC_Type *base, bool enable)
{
    if (enable)
    {
        base->DCICC |= DCIC_DCICC_IC_EN_MASK;
    }
    else
    {
        base->DCICC &= ~DCIC_DCICC_IC_EN_MASK;
    }
}
 
/* @} */
 
static inline uint32_t DCIC_GetStatusFlags(DCIC_Type *base)
{
    return base->DCICS;
}
 
static inline void DCIC_ClearStatusFlags(DCIC_Type *base, uint32_t mask)
{
    base->DCICS = (mask & (DCIC_DCICS_FI_STAT_MASK | DCIC_DCICS_ROI_MATCH_STAT_MASK));
}
 
/* @} */
 
static inline void DCIC_LockInterruptEnabledStatus(DCIC_Type *base)
{
    base->DCICIC |= DCIC_DCICIC_FREEZE_MASK_MASK;
}
 
static inline void DCIC_EnableInterrupts(DCIC_Type *base, uint32_t mask)
{
    base->DCICIC &= ~mask;
}
 
static inline void DCIC_DisableInterrupts(DCIC_Type *base, uint32_t mask)
{
    base->DCICIC |= mask;
}
 
/* @} */
 
void DCIC_EnableRegion(DCIC_Type *base, uint8_t regionIdx, const dcic_region_config_t *config);
 
static inline void DCIC_DisableRegion(DCIC_Type *base, uint8_t regionIdx)
{
    assert(regionIdx < DCIC_REGION_COUNT);
 
    if (regionIdx < DCIC_REGION_COUNT)
    {
        base->REGION[regionIdx].DCICRC &= ~DCIC_DCICRC_ROI_EN_MASK;
    }
}
 
static inline void DCIC_SetRegionRefCrc(DCIC_Type *base, uint8_t regionIdx, uint32_t crc)
{
    assert(regionIdx < DCIC_REGION_COUNT);
 
    if (regionIdx < DCIC_REGION_COUNT)
    {
        base->REGION[regionIdx].DCICRRS = crc;
    }
}
 
static inline uint32_t DCIC_GetRegionCalculatedCrc(DCIC_Type *base, uint8_t regionIdx)
{
    uint32_t localdcicrcs = 0U;
 
    assert(regionIdx < DCIC_REGION_COUNT);
 
    if (regionIdx < DCIC_REGION_COUNT)
    {
        localdcicrcs = base->REGION[regionIdx].DCICRCS;
    }
 
    return localdcicrcs;
}
 
/* @} */
 
static inline void DCIC_EnableMismatchExternalSignal(DCIC_Type *base, bool enable)
{
    if (enable)
    {
        base->DCICIC |= DCIC_DCICIC_EXT_SIG_EN_MASK;
    }
    else
    {
        base->DCICIC &= ~DCIC_DCICIC_EXT_SIG_EN_MASK;
    }
}
 
/* @} */
 
#if defined(__cplusplus)
}
#endif
#endif /* _FSL_DCIC_H_ */