FreeRTOS/Demo/CORTEX_M7_SAMV71_Xplained_AtmelStudio/libchip_samv7/source/isi.c

/* ----------------------------------------------------------------------------
 *         SAM Software Package License
 * ----------------------------------------------------------------------------
 * Copyright (c) 2013, Atmel Corporation
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the disclaimer below.
 *
 * Atmel's name may not be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
 * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * ----------------------------------------------------------------------------
 */


/*----------------------------------------------------------------------------
 *        Headers
 *----------------------------------------------------------------------------*/

#include "chip.h"

/*----------------------------------------------------------------------------
 *        Local functions
 *----------------------------------------------------------------------------*/
 
/**
 * \brief Workaround for ISI CFG2 register read.
 * \note The ISI_CFG2[31:27] can be written correctly, because the input writing 
 * data are assigned directly to the internal control bits as specified, 
 * the mismatch only happens in reading operation.
 * [31:28] are shift right 1 bit, so [31:27] can be read from [30:27].
 */
__STATIC_INLINE uint32_t _ISI_GetCFG2_Workaround(void)
{
	uint32_t wrongfield;
	wrongfield = ISI->ISI_CFG2 >> (ISI_CFG2_YCC_SWAP_Pos - 1);
	return (ISI->ISI_CFG2 & 0x07FFFFFF) | (wrongfield << ISI_CFG2_YCC_SWAP_Pos);
}

/*----------------------------------------------------------------------------
 *        Export functions
 *----------------------------------------------------------------------------*/

/**
 * \brief Enable ISI
 */
void ISI_Enable(void)
{
	ISI->ISI_CR |= ISI_CR_ISI_EN;
	while( (ISI->ISI_SR & ISI_CR_ISI_EN)!=ISI_CR_ISI_EN);
}

/**
 * \brief Enable ISI Dma channel
 * \param  channel to be enabled
 */
void ISI_DmaChannelEnable(uint32_t channel)
{
	ISI->ISI_DMA_CHER |= channel;
}

/**
 * \brief Disable ISI Dma channel
 * \param  channel to be disabled
 */
void ISI_DmaChannelDisable(uint32_t channel)
{
	ISI->ISI_DMA_CHDR |=channel;
}

/**
 * \brief Disable ISI
 */
void ISI_Disable(void)
{
	/* Write one to this field to disable the module */
	ISI->ISI_CR |= ISI_CR_ISI_DIS;
	/* Software must poll DIS_DONE field in the ISI_STATUS register to verify that the command
	has successfully completed.*/
	while( (ISI->ISI_SR & ISI_SR_DIS_DONE) != ISI_SR_DIS_DONE);
}


/**
 * \brief Enable ISI interrupt
 * \param  flag of interrupt to enable
 */
void ISI_EnableInterrupt(uint32_t flag)
{
	ISI->ISI_IER = flag;
}

/**
 * \brief Disable ISI interrupt
 * \param  flag of interrupt to disable
 */
void ISI_DisableInterrupt(uint32_t flag)
{
	ISI->ISI_IDR = flag;
}

/**
 * \brief Return ISI status register
 * \return Status of ISI register
 */
uint32_t ISI_StatusRegister(void)
{
	return(ISI->ISI_SR);
}

/**
 * \brief Enable Codec path for capture next frame
 */
void ISI_CodecPathFull(void)
{
	// The codec path is enabled and the next frame is captured.
	// Both codec and preview data-paths are working simultaneously
	ISI->ISI_CR |= ISI_CR_ISI_CDC;
	ISI->ISI_CFG1 |= ISI_CFG1_FULL;
}

/**
 * \brief Set frame rate
 * \param frame frame rate capture
 */
void ISI_SetFrameRate(uint32_t frame)
{
	if( frame > 7 ) {
		TRACE_ERROR("rate too big\n\r");
		frame = 7;
	}
	ISI->ISI_CFG1 |= ISI_CFG1_FRATE(frame);
}

/**
 * \brief Get the number of byte per pixels
 * \param bmpRgb BMP type can be YUV or RGB
 */
uint8_t ISI_BytesForOnePixel(uint8_t bmpRgb)
{
	uint8_t nbByte_Pixel;

	if (bmpRgb == RGB) {
		if ((_ISI_GetCFG2_Workaround() & ISI_CFG2_RGB_MODE) == ISI_CFG2_RGB_MODE){
			// RGB: 5:6:5 16bits/pixels
			nbByte_Pixel = 2;
		} else {
			// RGB: 8:8:8 24bits/pixels
			nbByte_Pixel = 3;
		}
	} else {
		// YUV: 2 pixels for 4 bytes
		nbByte_Pixel = 2;
	}
	return nbByte_Pixel;
}

/**
 * \brief Reset ISI
 */
void ISI_Reset(void)
{
	uint32_t timeout=0;

	// Resets the image sensor interface.
	// Finish capturing the current frame and then shut down the module.
	ISI->ISI_CR = ISI_CR_ISI_SRST | ISI_CR_ISI_DIS;
	// wait Software reset has completed successfully.
	while( (!(ISI->ISI_SR & ISI_SR_SRST))
			&& (timeout < 0x5000) ) {
		timeout++;
	}
	if( timeout == 0x5000 ) {
		TRACE_ERROR("ISI-Reset timeout\n\r");
	}
}


/**
 * \brief Set the windows blank
 * \param hBlank  pixel clock periods to wait before the beginning of a line.
 * \param vBlank  lines are skipped at the beginning of the frame.
 */
void ISI_SetBlank(uint8_t hBlank, uint8_t vBlank)
{
	ISI->ISI_CFG1 |= ISI_CFG1_SLD(hBlank) + ISI_CFG1_SFD(vBlank);
}


/**
 * \brief Set vertical and horizontal Size of the Image Sensor
 * \param hSize  Horizontal size of the Image sensor [0..2047].
 * \param vSize  Vertical size of the Image sensor [0..2047].
 */
void ISI_SetSensorSize(uint32_t hSize, uint32_t vSize)
{
	// IM_VSIZE: Vertical size of the Image sensor [0..2047]
	// Vertical size = IM_VSIZE + 1
	// IM_HSIZE: Horizontal size of the Image sensor [0..2047]
	// Horizontal size = IM_HSIZE + 1
	ISI->ISI_CFG2 = _ISI_GetCFG2_Workaround() | ISI_CFG2_IM_VSIZE(vSize - 1)
			| ISI_CFG2_IM_HSIZE(hSize - 1);
}

/**
 * \brief Defines RGB pattern when RGB_MODE is set to 1.
 * \param wRgbPixelMapping  RGB pattern
 */
void ISI_RgbPixelMapping(uint32_t wRgbPixelMapping)
{
	ISI->ISI_CFG2 = _ISI_GetCFG2_Workaround() & (~ISI_CFG2_RGB_CFG_Msk);
	if (wRgbPixelMapping != ISI_CFG2_RGB_CFG_DEFAULT)
		ISI->ISI_CFG2 = _ISI_GetCFG2_Workaround() | wRgbPixelMapping 
			| ISI_CFG2_RGB_MODE; 
	else 
		ISI->ISI_CFG2 = _ISI_GetCFG2_Workaround();
}

/**
 * \brief Enables RGB swap
 * \param swapMode  0: D7-R7, 1: D0-R7
 */
void ISI_RgbSwapMode(uint32_t swapMode)
{
	ISI->ISI_CFG2 = _ISI_GetCFG2_Workaround() & (~ISI_CFG2_RGB_SWAP);
	if(swapMode) ISI->ISI_CFG2 = _ISI_GetCFG2_Workaround() | ISI_CFG2_RGB_SWAP;
}
 
/**
 * \brief Defines YCrCb swap format.
 * \param wYuvSwapMode YUV Swap format
 */
void ISI_YCrCbFormat(uint32_t wYuvSwapMode)
{
	ISI->ISI_CFG2 = _ISI_GetCFG2_Workaround() & (~ISI_CFG2_YCC_SWAP_Msk);
	ISI->ISI_CFG2 = _ISI_GetCFG2_Workaround() | wYuvSwapMode;
}

/**
 * \brief Input image is assumed to be grayscale-coded.
 * \param wPixelFormat  0: 2 pixels per word, 1:1 pixel per word.
 */
void ISI_setGrayScaleMode(uint32_t wPixelFormat)
{
	ISI->ISI_CFG2 = _ISI_GetCFG2_Workaround() | ISI_CFG2_GRAYSCALE ;
	if(wPixelFormat) ISI->ISI_CFG2 = _ISI_GetCFG2_Workaround() | ISI_CFG2_GS_MODE;
	
}

/**
 * \brief Set data stream format.
 * \param wStreamMode  0: YUV input, 1: RGB 8:8:8/5:6:5 input
 */
void ISI_setInputStream(uint32_t wStreamMode)
{
	ISI->ISI_CFG2 = _ISI_GetCFG2_Workaround() & (~ISI_CFG2_COL_SPACE);
	if(wStreamMode) ISI->ISI_CFG2 = _ISI_GetCFG2_Workaround() | ISI_CFG2_COL_SPACE;
}

/**
 * \brief Set preview size.
 * \param hSize  Horizontal Preview size  (640 max only in RGB mode).
 * \param vSize  Vertical Preview size  (480 max only in RGB mode).
 */
void ISI_setPreviewSize(uint32_t hSize, uint32_t vSize)
{
	if (hSize > 640) hSize = 640;
	if (vSize > 480) vSize = 480;
	ISI->ISI_PSIZE = ISI_PSIZE_PREV_VSIZE(vSize - 1) | ISI_PSIZE_PREV_HSIZE(hSize - 1);
}

/**
 * \brief calculate scaler factor automatically.
 * \note The sensor size and preview size for LCD was configured before this setting.
 */
void ISI_calcScalerFactor(void)
{
	uint32_t hLcdSize, hSensorSize;
	uint32_t hRatio;
	hLcdSize = ((ISI->ISI_PSIZE & ISI_PSIZE_PREV_HSIZE_Msk) >> ISI_PSIZE_PREV_HSIZE_Pos) +1 ;
	hSensorSize = ((_ISI_GetCFG2_Workaround() & ISI_CFG2_IM_HSIZE_Msk ) 
			>> ISI_CFG2_IM_HSIZE_Pos) + 1;
	hRatio = 1600 * hSensorSize / hLcdSize;
	ISI->ISI_PDECF = (hRatio/100);
}

/**
 * \brief Configure DMA for preview path.
 * \param baseFrameBufDesc  Preview Descriptor Address.
 * \param dmaCtrl  DMA Preview Control.
 * \param frameBufferStartAddr  DMA Preview Base Address.
 */
void ISI_setDmaInPreviewPath(uint32_t baseFrameBufDesc, 
		uint32_t dmaCtrl, uint32_t frameBufferStartAddr)
{
	ISI->ISI_DMA_P_DSCR = baseFrameBufDesc;
	ISI->ISI_DMA_P_CTRL = dmaCtrl;
	ISI->ISI_DMA_P_ADDR = frameBufferStartAddr;
}

/**
 * \brief Configure DMA for Codec path.
 * \param baseFrameBufDesc  Preview Descriptor Address.
 * \param dmaCtrl  DMA Preview Control.
 * \param frameBufferStartAddr  DMA Preview Base Address.
 */
void ISI_setDmaInCodecPath(uint32_t baseFrameBufDesc, 
		uint32_t dmaCtrl, uint32_t frameBufferStartAddr)
{
	ISI->ISI_DMA_C_DSCR = baseFrameBufDesc;
	ISI->ISI_DMA_C_CTRL = dmaCtrl;
	ISI->ISI_DMA_C_ADDR = frameBufferStartAddr;
}
 
/**
 * \brief ISI set matrix for YUV to RGB color space for preview path.
 * \param yuv2rgb structure of YUV to RBG parameters.
 */
void ISI_SetMatrix4Yuv2Rgb (ISI_Y2R* yuv2rgb)
{
   ISI->ISI_Y2R_SET0 = ISI_Y2R_SET0_C0(yuv2rgb->C0)
					 | ISI_Y2R_SET0_C1(yuv2rgb->C1)
					 | ISI_Y2R_SET0_C2(yuv2rgb->C2)
					 | ISI_Y2R_SET0_C3(yuv2rgb->C3);
					 
   ISI->ISI_Y2R_SET1 = ISI_Y2R_SET1_C4(yuv2rgb->C4)
					 | ((yuv2rgb->Yoff == 1)? ISI_Y2R_SET1_Yoff: 0)
					 | ((yuv2rgb->Croff == 1)? ISI_Y2R_SET1_Croff: 0)
					 | ((yuv2rgb->Cboff == 1)? ISI_Y2R_SET1_Cboff: 0);
}

/**
 * \brief ISI set matrix for RGB to YUV color space for codec path.
 * \param rgb2yuv structure of RGB to YUV parameters.
 */
void ISI_SetMatrix4Rgb2Yuv (ISI_R2Y* rgb2yuv)
{
	ISI->ISI_R2Y_SET0 = ISI_R2Y_SET0_C0(rgb2yuv->C0) 
					  | ISI_R2Y_SET0_C1(rgb2yuv->C1)
					  | ISI_R2Y_SET0_C2(rgb2yuv->C2)
					  | ((rgb2yuv->Roff == 1)? ISI_R2Y_SET0_Roff: 0);
				 
	ISI->ISI_R2Y_SET1 = ISI_R2Y_SET1_C3(rgb2yuv->C3) 
					  | ISI_R2Y_SET1_C4(rgb2yuv->C4)
					  | ISI_R2Y_SET1_C5(rgb2yuv->C5)
					  | ((rgb2yuv->Goff == 1)? ISI_R2Y_SET1_Goff: 0);
				 
	ISI->ISI_R2Y_SET2 = ISI_R2Y_SET2_C6(rgb2yuv->C6) 
					  | ISI_R2Y_SET2_C7(rgb2yuv->C7)
					  | ISI_R2Y_SET2_C8(rgb2yuv->C8)
					  | ((rgb2yuv->Boff == 1)? ISI_R2Y_SET2_Boff: 0);
}