fs453.cpp

Microsoft WinCE 6.0 BSP FINAL release source code for use with the i.MX27ADS TO2 WCE600_FINAL_MX27_S

//------------------------------------------------------------------------------
//
//  Copyright (C) 2005-2006, Freescale Semiconductor, Inc. All Rights Reserved.
//  THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
//  AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT
//
//------------------------------------------------------------------------------
//
//  File:  fs453.cpp
//
//  Provides BSP-specific configuration routines for FS453 TVenc driver.
//
//------------------------------------------------------------------------------

#include "bsp.h"
#include "i2cbus.h"
#include "fs453.h"


#ifndef __cplusplus
extern "C" {
#endif
//-----------------------------------------------------------------------------
// External Functions


//-----------------------------------------------------------------------------
// External Variables

//-----------------------------------------------------------------------------
// Local Variables

DWORD m_dwFs453CrVal = 0; // fs453 CR register init value

FS453PARAM m_Fs453Parameters[TVOUT_MODE_MAX][FS453_PARAM_MAX] = 
{
  //FS453_TVOUT_MODE_ONTSC_IVGA_RGB565_26400KHZ // 720*480
  {
    1,//FS453_PARAM_PLL_NCONL = 0,
    0,//FS453_PARAM_PLL_NCONH,
    1,//FS453_PARAM_PLL_NCODL,
    0,//FS453_PARAM_PLL_NCODH,
    0x4117,//0x30F7,//FS453_PARAM_PLL_M,
    0x1d,//FS453_PARAM_PLL_N,
    0x09,//FS453_PARAM_PLL_P_IP,
    0x09,//FS453_PARAM_PLL_P_EP,  
    0x00,//FS453_PARAM_POSITION_HORIZ, 
    40,//FS453_PARAM_POSITION_VERTI,
    768,//FS453_PARAM_HACTIVE,
    789,//FS453_PARAM_SCALE_VERTI,
    0x00,//FS453_PARAM_SCALE_HORIZ_UPSCALE, 
    0x00,//FS453_PARAM_SCALE_HORIZ_DOWNSCALE,
    0,//FS453_PARAM_UNDERSCALE,
    0x0082,//FS453_PARAM_FIFO_LATENCY
  },
  //FS453_TVOUT_MODE_OPAL_IVGA_RGB565_26400KHZ // 720*576
  {
    0x01,//FS453_PARAM_PLL_NCONL = 0,
    0,//FS453_PARAM_PLL_NCONH,
    0x01,//FS453_PARAM_PLL_NCODL,
    0,//FS453_PARAM_PLL_NCODH,
    0x4117,//0x30F7,//FS453_PARAM_PLL_M,
    0x1d,//FS453_PARAM_PLL_N,
    0x09,//FS453_PARAM_PLL_P_IP,
    0x09,//FS453_PARAM_PLL_P_EP,
    0x0,//FS453_PARAM_POSITION_HORIZ, 
    0x0013,//FS453_PARAM_POSITION_VERTI,
    0x0300,//FS453_PARAM_HACTIVE,
    0x2008,//FS453_PARAM_SCALE_VERTI,
    0x00,//FS453_PARAM_SCALE_HORIZ_UPSCALE,
    0x00,//FS453_PARAM_SCALE_HORIZ_DOWNSCALE,
    0,//FS453_PARAM_UNDERSCALE,
    0x00A4,//FS453_PARAM_FIFO_LATENCY
  },
};

//-----------------------------------------------------------------------------
// Local Function
#define Fs453WriteRegister(addr, dat)   m_fs453WriteRegister((addr ## _ADDR),(dat),(addr ## _WID))
#define Fs453ReadRegister(addr, dat)    m_fs453ReadRegister((addr ## _ADDR),(dat),(addr ## _WID))

static BOOL m_fs453WriteRegister(BYTE reg, DWORD * pValue, WORD byteLen);
static BOOL m_fs453ReadRegister(BYTE reg, DWORD * pValue, WORD byteLen);
static BOOL m_fs453SwReset(void);
static BOOL m_fs453UpdatePLL(void);

//-----------------------------------------------------------------------------
//
//  Function: m_fs453WriteRegister
//
//  This function write data to the registers in FS453 via I2C control interface.
//
//  Parameters:
//      BYTE  reg - the address of FS453 internal register
//    DWORD*  pValue - data to write
//    WORD  byteLen - the byte to write
//
//  Returns:
//      Returns TRUE if successful, otherwise returns FALSE.
//
//-----------------------------------------------------------------------------
static BOOL m_fs453WriteRegister(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;

    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
    iResult = I2C_MACRO_TRANSFER(m_hI2C, &I2CXferBlock);

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

    return rc;
}

//-----------------------------------------------------------------------------
//
//  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
    iResult = I2C_MACRO_TRANSFER(m_hI2C, &I2CXferBlock);

    if(iResult == TRUE)
    {
        * 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;

    PHYSICAL_ADDRESS phyAddr;
	PCSP_GPIO_REGS g_pGPIO = NULL;
    phyAddr.QuadPart = CSP_BASE_REG_PA_GPIO;
    g_pGPIO = (PCSP_GPIO_REGS) MmMapIoSpace(phyAddr, sizeof(CSP_GPIO_REGS), FALSE);

	g_pGPIO->PORT[GPIO_PORT_A].GIUS |= 0x02000000;  //PA25 
    g_pGPIO->PORT[GPIO_PORT_A].DDIR |= 0x02000000;	// output port
	g_pGPIO->PORT[GPIO_PORT_A].OCR2 |= 0x000C0000;  // output data
	g_pGPIO->PORT[GPIO_PORT_A].DR &= ~0x02000000;	// Set RESET pin to LOW	to reset 
	Sleep(10);
	g_pGPIO->PORT[GPIO_PORT_A].DR |= 0x02000000;	// Set RESET pin to HIGH to normal


    // HW init
    // Open I2C, to communicate with FS453
    if(m_hI2C == NULL)
    {
        DWORD dwFrequency = FS453_I2C_SCLK_FREQ;  // I2C frequency
        BYTE bySelf = MX27_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;
        }

        // Initialize the device internal fields
        if (!I2C_MACRO_SET_FREQUENCY(m_hI2C, dwFrequency))
        {
            DEBUGMSG(1, (TEXT("%s: Set I2C frequency failed!\r\n"), __WFUNCTION__));
            goto cleanUp;
        }
        if (!I2C_MACRO_SET_SELF_ADDR(m_hI2C, bySelf))
        {
            DEBUGMSG(1, (TEXT("%s: Set I2C self address failed!\r\n"), __WFUNCTION__));
            goto cleanUp;
        }
    }

    //  Check if FS453 is available.
    Fs453ReadRegister(FS453_ID, &data);

    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);