fs453.cpp

IMX31开发板

	BOOL rc = FALSE;
    I2C_TRANSFER_BLOCK I2CXferBlock;
    I2C_PACKET I2CPacket;
    INT iResult;
    BYTE byOutData[5];        					// Transmit buffer
	INT i;

    byOutData[0] = reg;
	for(i = 1; i <= byteLen; i++){
		byOutData[i] = (BYTE)(0xFF & (*pValue >> (8 * (i-1))));
	}

    I2CPacket.wLen = byteLen + sizeof(reg);

    I2CPacket.byRW = I2C_RW_WRITE;
    I2CPacket.pbyBuf = (PBYTE)byOutData;
    I2CPacket.byAddr = FS453_I2C_SLAVE_ADDR;
    I2CPacket.lpiResult = &iResult;        		// if I2C encounters an error, it will write to *lpiResult.

    I2CXferBlock.pI2CPackets = &I2CPacket;
    I2CXferBlock.iNumPackets = 1;

    // Write register via I2C
    DeviceIoControl(m_hI2C,                     // file handle to the driver
                      I2C_IOCTL_TRANSFER,  		// I/O control code
                      (PBYTE) &I2CXferBlock,       // in buffer
                      sizeof(I2C_TRANSFER_BLOCK),  // in buffer size
                      NULL,                     // out buffer
                      0,                        // out buffer size
                      NULL,                     // number of bytes returned
                      NULL);					// ignored (=NULL)

	if(iResult == I2C_NO_ERROR)
	{
		rc = TRUE;
	}

	return rc;

}

#if (FS453_DEBUGWRITE ==1)
static BOOL m_fs453WriteRegisterTest(BYTE reg, DWORD * pValue, WORD byteLen)
{
	BOOL rc = FALSE;
    I2C_TRANSFER_BLOCK I2CXferBlock;
    I2C_PACKET I2CPacket;
    INT iResult;
    BYTE byOutData[5];        					// Transmit buffer
	INT i;
	DWORD r;

    byOutData[0] = reg;
	for(i = 1; i <= byteLen; i++){
		byOutData[i] = (BYTE)(0xFF & (*pValue >> (8 * (i-1))));
	}

    I2CPacket.wLen = byteLen + sizeof(reg);

    I2CPacket.byRW = I2C_RW_WRITE;
    I2CPacket.pbyBuf = (PBYTE)byOutData;
    I2CPacket.byAddr = FS453_I2C_SLAVE_ADDR;
    I2CPacket.lpiResult = &iResult;        		// if I2C encounters an error, it will write to *lpiResult.

    I2CXferBlock.pI2CPackets = &I2CPacket;
    I2CXferBlock.iNumPackets = 1;

    // Write register via I2C
    DeviceIoControl(m_hI2C,                     // file handle to the driver
                      I2C_IOCTL_TRANSFER,       // I/O control code
                      (PBYTE) &I2CXferBlock,       // in buffer
                      sizeof(I2C_TRANSFER_BLOCK),  // in buffer size
                      NULL,                     // out buffer
                      0,                        // out buffer size
                      NULL,                     // number of bytes returned
                      NULL);					// ignored (=NULL)

	if(iResult == I2C_NO_ERROR)
	{
		rc = TRUE;
	}
	r=0xFFFFFFFF;
	rc = m_fs453ReadRegister(reg,&r,byteLen);
	if(rc == FALSE){
		while(1);
	}
//	if(*pValue != r){
//		while(1);
//	}
	return rc;

}
#endif

//-----------------------------------------------------------------------------
//
//  Function: m_fs453ReadRegister
//
//  This function read data from the registers in FS453 via I2C control interface.
//
//  Parameters:
//      BYTE	reg - the address of FS453 internal register
//		DWORD*	pValue - data to read
//		WORD	byteLen - the byte to read
//
//  Returns:
//      Returns TRUE if successful, otherwise returns FALSE.
//
//-----------------------------------------------------------------------------
static BOOL m_fs453ReadRegister(BYTE reg, DWORD * pValue, WORD byteLen)
{
	BOOL rc = FALSE;
    I2C_TRANSFER_BLOCK I2CXferBlock;
    I2C_PACKET I2CPktArray[2];
    INT iResult;

    I2CPktArray[0].pbyBuf = (PBYTE) &reg;
    I2CPktArray[0].wLen = sizeof(reg); // let I2C know how much to transmit

    I2CPktArray[0].byRW = I2C_RW_WRITE;
    I2CPktArray[0].byAddr = FS453_I2C_SLAVE_ADDR;
    I2CPktArray[0].lpiResult = &iResult; // if I2C encounters an error, it will write to *lpiResult.


    I2CPktArray[1].pbyBuf = (PBYTE) pValue;
    I2CPktArray[1].wLen = byteLen; // let I2C know how much to receive

    I2CPktArray[1].byRW = I2C_RW_READ;
    I2CPktArray[1].byAddr = FS453_I2C_SLAVE_ADDR;
    I2CPktArray[1].lpiResult = &iResult; // if I2C encounters an error, it will write to *lpiResult.

    I2CXferBlock.pI2CPackets = I2CPktArray;
    I2CXferBlock.iNumPackets = 2;

    // Read register via I2C
    DeviceIoControl(m_hI2C,                          // file handle to the driver
                      I2C_IOCTL_TRANSFER,            // I/O control code
                      (PBYTE) &I2CXferBlock,         // in buffer
                      sizeof(I2C_TRANSFER_BLOCK),    // in buffer size
                      NULL,                          // out buffer
                      0,                             // out buffer size
                      NULL,                          // number of bytes returned
                      NULL);                         // ignored (=NULL)

	if(iResult == I2C_NO_ERROR)
	{
		* pValue &= ((1 << (8 << (byteLen - 1))) -1);
		rc = TRUE;
	}

	return rc;
}

//-----------------------------------------------------------------------------
//
//  Function: Fs453Init
//
//  This function opens control interface(I2C) to FS453.
//
//  Parameters:
//      None.
//
//  Returns:
//      Returns TRUE if successful, otherwise returns FALSE.
//
//-----------------------------------------------------------------------------
BOOL Fs453Init(void)
{
	BOOL   rc = FALSE;
	DWORD  data;

	// HW init

	// Open I2C, to communicate with FS453
	if(m_hI2C == NULL)
	{
		DWORD dwFrequency = FS453_I2C_SCLK_FREQ;	// I2C frequency
		BYTE bySelf = MX31_I2C_SLAVE_ADDR;      	// Self address value

		m_hI2C = CreateFile (FS453_CTRL_IF, 		// Pointer to the name of the port
							GENERIC_READ | GENERIC_WRITE,// Access (read-write) mode
							FILE_SHARE_READ | FILE_SHARE_WRITE,// Share mode
							NULL,         			// Pointer to the security attribute
							OPEN_EXISTING,  		// How to open the serial port
							FILE_FLAG_RANDOM_ACCESS,// Handle to port with attribute to
							NULL);					// Template file (ignored)
		if(m_hI2C == NULL || m_hI2C == INVALID_HANDLE_VALUE){
	        ERRORMSG(1, (_T("CreateFile:  CreateFile failed for i2c open, to control codec!\r\n")));
	        goto cleanUp;
		}

		// Set I2C frequency
		DeviceIoControl(m_hI2C,                 	// File handle to the driver
						I2C_IOCTL_SET_FREQUENCY,  	// I/O control code
					  	(PBYTE) &dwFrequency,   	// In buffer
						sizeof(dwFrequency),        // In buffer size
						NULL,                       // Out buffer
						0,                          // Out buffer size
						NULL,                       // Number of bytes returned
						NULL);                      // Ignored (=NULL)

		// Set I2C self address
		DeviceIoControl(m_hI2C,                 	// File handle to the driver
                      	I2C_IOCTL_SET_SELF_ADDR,  	// I/O control code
                      	(PBYTE) &bySelf,   			// In buffer
                      	sizeof(bySelf),          	// In buffer size
                      	NULL,                       // Out buffer
                      	0,                          // Out buffer size
                      	NULL,                       // Number of bytes returned
                      	NULL);                      // Ignored (=NULL)

	}

	//	Check if FS453 is available.

	rc = Fs453ReadRegister(FS453_ID, &data);
	if(rc != TRUE){
		goto cleanUp;
	}
	if(data != FS453_ID_NUMBER){
		goto cleanUp;
	}

	m_dwFs453CrVal = 0;

	rc = TRUE;

cleanUp:
	if(rc != TRUE) Fs453Deinit();

	return rc;
}

//-----------------------------------------------------------------------------
//
//  Function: m_fs453SwReset
//
//  This function makes sw reset to FS453.
//
//  Parameters:
//      None.
//
//  Returns:
//      Returns TRUE if successful, otherwise returns FALSE.
//
//-----------------------------------------------------------------------------
BOOL m_fs453SwReset(void)
{
	DWORD	data;
	BOOL rc = FALSE;

	data = ( m_dwFs453CrVal |
			CSP_BITFVAL(FS453_CR_SRESET, FS453_SET_ENABLE) );

	rc = Fs453WriteRegister(FS453_CR, &data);
	if(rc != TRUE){
		goto failed;
	}

	data &= ~CSP_BITFMASK(FS453_CR_SRESET);
	data |= CSP_BITFVAL(FS453_CR_SRESET, FS453_SET_DISABLE);

	rc = Fs453WriteRegister(FS453_CR, &data);
	if(rc != TRUE){
		goto failed;
	}

	return TRUE;
failed:
	return FALSE;
}

//-----------------------------------------------------------------------------
//
//  Function: m_fs453UpdatePLL
//
//  This function updates internal pll setting.
//
//  Parameters:
//      None.
//
//  Returns:
//      Returns TRUE if successful, otherwise returns FALSE.
//
//-----------------------------------------------------------------------------
BOOL m_fs453UpdatePLL(void)
{
	DWORD	data;
	BOOL rc = FALSE;

	data = ( m_dwFs453CrVal |
			CSP_BITFVAL(FS453_CR_NCO_EN, FS453_SET_ENABLE) );

	rc = Fs453WriteRegister(FS453_CR, &data);
	if(rc != TRUE){
		goto failed;
	}

	data &= ~CSP_BITFMASK(FS453_CR_NCO_EN);
	data |= CSP_BITFVAL(FS453_CR_NCO_EN, FS453_SET_DISABLE);

	rc = Fs453WriteRegister(FS453_CR, &data);
	if(rc != TRUE){
		goto failed;
	}

	return TRUE;
failed:
	return FALSE;
}

BOOL Fs453Configure(TVIN_COLOR color, TVOUT_MODE mode)
{
	BOOL 	rc = FALSE;
	DWORD	data;
	BOOL   bOutUnderscan = FS453_UNDERSCAN_TVIMAGE_BOOL;

	FS453PARAM * pFs453Param = m_Fs453Parameters[mode];

	// ------------------------------------------------------------------------
	// ------ Basic Init
	// ... Clear NCO_EN and SRESET
	if(mode == TVOUT_MODE_PAL){
		m_dwFs453CrVal = ( CSP_BITFVAL(FS453_CR_GCC_CK_LVL, FS453_CR_GCC_CK_LVL_LOW_VOL) |
						   CSP_BITFVAL(FS453_CR_PAL_NTSCIN, FS453_SET_ENABLE) );

	}else{
		m_dwFs453CrVal = ( CSP_BITFVAL(FS453_CR_GCC_CK_LVL, FS453_CR_GCC_CK_LVL_LOW_VOL) );

	}

	data = ( m_dwFs453CrVal  |
			CSP_BITFVAL(FS453_CR_NCO_EN, FS453_SET_DISABLE) |
			CSP_BITFVAL(FS453_CR_SRESET, FS453_SET_DISABLE));

	Fs453WriteRegister(FS453_CR, &data); //0x2000

	// ... QPR
	data = (CSP_BITFVAL(FS453_QPR_INITIATE, FS453_QPR_SET_INITIATE) |
			CSP_BITFVAL(FS453_QPR_QK_UIM, 	FS453_QPR_QK_UIM_NATIONAL) |
			CSP_BITFVAL(FS453_QPR_QK_OS, 	FS453_QPR_QK_OS_SDTV) |
			CSP_BITFVAL(FS453_QPR_QK_FF, 	FS453_SET_ENABLE) |			// Flicker Fileter
			CSP_BITFVAL(FS453_QPR_QK_OM, 	FS453_QPR_QK_OM_SVIDEO_COMPOSITE) |
			CSP_BITFVAL(FS453_QPR_QK_GMODE, FS453_QPR_QK_GMODE_VGA));

	if(mode == TVOUT_MODE_PAL)
	{
		data |= CSP_BITFVAL(FS453_QPR_QK_PN, FS453_QPR_QK_PN_PAL);
	}
	else
	{
		data |= CSP_BITFVAL(FS453_QPR_QK_PN, FS453_QPR_QK_PN_NTSC);

	}

	if(color == TVIN_COLOR_YCRCB)
	{
		data |= CSP_BITFVAL(FS453_QPR_QK_YC_IN, FS453_QPR_QK_YC_IN_YCRCB);
	}
	else
	{
		data |= CSP_BITFVAL(FS453_QPR_QK_YC_IN, FS453_QPR_QK_YC_IN_RGB);
	}

	if(bOutUnderscan)
	{
		// Underscan
		data |= CSP_BITFVAL(FS453_QPR_QK_UO, FS453_QPR_QK_UO_UNDERSCAN);
	}
	else
	{
		// Overscan
		data |= CSP_BITFVAL(FS453_QPR_QK_UO, FS453_QPR_QK_UO_OVERSCAN);
	}

	Fs453WriteRegister(FS453_QPR, &data); //0x9C40

    // ... PWR_MGNT - SDTV Clock On/ DAC output ON
	data = ( CSP_BITFVAL(FS453_PWR_MGNT_GTLIO_PD, 	FS453_SET_DISABLE) |
			 CSP_BITFVAL(FS453_PWR_MGNT_PLL_PD,		FS453_SET_DISABLE) |