philips_dtv_ttr.c

用于TM1300/PNX1300系列DSP（主要用于视频处理）的设备库的源码

    return Result;
}

static void ttrWriteUartRegister(unitSelect_t portID, Int addr,UInt8 data)
{
    UInt8*  pCommPtr;

    if (portID == unit0)
        pCommPtr = (UInt8*) Uart_COMM1_IOBASE_ADDR;
    else
        pCommPtr = (UInt8*) Uart_COMM2_IOBASE_ADDR;
        
    *(pCommPtr + (addr*4) ) = data;
}

static UInt32           boardID;
static Bool             flashInitialized = False;
volatile static UInt32 *flashBaseAddress = (UInt32 *) DTV_TTR_FLASH_BASE_ADDRESS;

static tmLibdevErr_t ttrFlashInit(void)
{
    flashInitialized = True;
    return TMLIBDEV_OK;
}

static tmLibdevErr_t ttrFlashReadWord(UInt32 address, UInt32 * data)
{
    tmAssert(data, FLASH_ERR_NULL_POINTER);
    tmAssert(flashInitialized, FLASH_ERR_NOT_INITIALIZED);
    
    *data = flashBaseAddress[address];
    return TMLIBDEV_OK;
}

static tmLibdevErr_t ttrFlashWriteWord(UInt32 address, UInt32 data)
{
    UInt32        i = 0;

    tmAssert(flashInitialized, FLASH_ERR_NOT_INITIALIZED);

    flashBaseAddress[0x5555]  = 0xAAAAAAAA;
    flashBaseAddress[0x2AAA]  = 0x55555555;
    flashBaseAddress[0x5555]  = 0xA0A0A0A0;
    flashBaseAddress[address] = data;

    while (flashBaseAddress[address] != data)
    {
        if (i++ > 1000000)
        {
           return FLASH_ERR_WRITE;
        }
    }
    return TMLIBDEV_OK;
}

static tmLibdevErr_t ttrFlashReadBlock(UInt32 address, UInt32 * data, UInt32 numberOfWords)
{
    Int i;
    
    tmAssert(flashInitialized, FLASH_ERR_NOT_INITIALIZED);

    for (i = 0; i < numberOfWords; i++)
    {
        data[i] = flashBaseAddress[address + i];
    }

    return TMLIBDEV_OK;
}

static tmLibdevErr_t ttrFlashWriteBlock(UInt32 address, UInt32 * data, UInt32 numberOfWords)
{
    UInt32        i = 0, j;

    tmAssert(flashInitialized, FLASH_ERR_NOT_INITIALIZED);

    for (j = 0; j < numberOfWords; j++)
    {
        flashBaseAddress[0x5555]  = 0xAAAAAAAA;
        flashBaseAddress[0x2AAA]  = 0x55555555;
        flashBaseAddress[0x5555]  = 0xA0A0A0A0;
        flashBaseAddress[address + j] = data[j];

        while (flashBaseAddress[address + j] != data[j])
        {
            if (i++ > 1000000)
            {
               return FLASH_ERR_WRITE;
            }
        }
        
        i = 0;
    }
    return TMLIBDEV_OK;
}

static tmLibdevErr_t ttrFlashEraseSector(UInt32 sector)
{
    UInt32        i = 0;
    UInt32        sectorSize = DTV_TTR_FLASH_SECTOR_SIZE;

    tmAssert(flashInitialized, FLASH_ERR_NOT_INITIALIZED);

    flashBaseAddress[0x5555] = 0xAAAAAAAA;
    flashBaseAddress[0x2AAA] = 0x55555555;
    flashBaseAddress[0x5555] = 0x80808080;
    flashBaseAddress[0x5555] = 0xAAAAAAAA;
    flashBaseAddress[0x2AAA] = 0x55555555;
    flashBaseAddress[sector * sectorSize] = 0x30303030;

    while (flashBaseAddress[sector * sectorSize] != 0xffffffff)
    {
        if (i++ > 20000000)
            return FLASH_ERR_ERASE_TIMEOUT;
        microsleep(1);
    }

    return TMLIBDEV_OK;
}

static tmLibdevErr_t ttrFlashEraseAll(void)
{
    UInt32        i = 0;

    tmAssert(flashInitialized, FLASH_ERR_NOT_INITIALIZED);

    flashBaseAddress[0x5555] = 0xAAAAAAAA;
    flashBaseAddress[0x2AAA] = 0x55555555;
    flashBaseAddress[0x5555] = 0x80808080;
    flashBaseAddress[0x5555] = 0xAAAAAAAA;
    flashBaseAddress[0x2AAA] = 0x55555555;
    flashBaseAddress[0x5555] = 0x10101010;
 
    while (flashBaseAddress[0] != 0xffffffff)
    {
        if (i++ > 200000000)
            return FLASH_ERR_ERASE_TIMEOUT;
        microsleep(1);
    }

    return TMLIBDEV_OK;
}

static tmLibdevErr_t boardVOInit(pboardVOParam_t param)
{
    pprocCapabilities_t procCap;
    
    TRY(procGetCapabilities(&procCap));
    
    voSetFREQUENCY__CHECK(param->ddsFrequency);
    voSetPLL_S__CHECK(1);
    voSetPLL_T__CHECK(1);
    voSetCLKOUT__CHECK(1);
    voSetSYNC_MASTER__CHECK(1);

    switch (param->videoStandard)
    {
    case vasNTSC:
        voSetCLKOUT__CHECK(0);
        voSetSYNC_MASTER__CHECK(0);

        /* TM1100 specific code (ifdef tm1100 removed) */
        if (procCap->deviceID == PROC_DEVICE_TM1100)
        {
            MMIO(EVO_SLVDLY) = 2200 - 10; /* genlock delay  */
            MMIO(EVO_CTL) = 0x10000041; /* genlock enable */
        }
        voSupport960x540p();
        break;
    case vas960x540p: /* 1080i overlay for DTV */
        voSetIO1_POS__CHECK(1);
        voSetIO2_POS__CHECK(1);
        voSetCLKOUT__CHECK(0);
        voSetSYNC_MASTER__CHECK(0);

        /* TM1100 specific code (ifdef tm1100 removed) */
        if (procCap->deviceID != PROC_DEVICE_TM1000)
        {
            MMIO(EVO_SLVDLY) = 2200 - 10; /* genlock delay  */
            MMIO(EVO_CTL) = 0x10000041; /* genlock enable */
        }
        voSupport960x540p();
        break;
    default:
        return VO_ERR_INVALID_ENCODER_INIT;
    }
    
    return TMLIBDEV_OK;
}

/******************** dtv_board_init *******************************
 *  The dtv board comes up with peripherals reset.
 *  This function takes the board out of reset and leaves
 *  it in a good state.
 */
static tmLibdevErr_t
dtv_ttr_board_init(void)
{
    pprocCapabilities_t procCap;
    pc16552DParams_t    p;
    
    TRY(procGetCapabilities(&procCap));

    MMIO(SSI_CTL) = 0x00040000;     /* V34IO2 goes high to stay on hook! */
    
    /* IIC expander
       address 0x40
                for TTR:                    for TR:
       bit 0    reserve                     reserve
       bit 1    FE_RESET                    FE_RESET - front end reset
       bit 2    audio mode 1                audio mode 1
       bit 3    audio mode 2                audio mode 2
       bit 4    input mode for color key    input mode for color key
       bit 5    audio mode 3                audio mode 3
       bit 6    audio mode 4                audio mode 4
       bit 7    audio mode 5                audio mode 5
    */
    TRY(iicWriteReg(TTR_IIC_EXPANDER_ADDRESS, -1, 0xFD));    /* lower FE_RESET */
    TRY(iicWriteReg(TTR_IIC_EXPANDER_ADDRESS, -1, 0xFF));    /* raise reset */


    /* L3 IIC expander:
     address: 0x44
     bit 0  Dout L3 mode
     bit 1  Dout L3 clock
     bit 2  Dout L3 data
     bit 3  Dout L3 strobe
     bit 4  Din L3 mode
     bit 5  Din L3 clock
     bit 6  Din L3 data
     bit 7  Din L3 strobe
    */
    TRY(iicWriteReg(TTR_L3_IIC_EXPANDER_ADDRESS, -1, 0xFF));

    /* The video in mux and reset IIC expander:
       address: 0x46
             TTR:                               TR:
       Bit 0 secondary PCI reset (low active)   SPCI_RESET whole sytem reset
       Bit 1 reserved                           VDMUX_RST  color key/mux clear control
       Bit 2 reserved                           reserved
       Bit 3 reserved                           reserved
       Bits 4 and 5 27MHZ_MUX1/0        
       Bit 6 MUX_SEL1 (video in mux select)
       Bit 7 MUX_SEL0 (video in mux select)
       MUX_SEL1 MUX_SEL0     TTR:               TR:
          0        0:        VSB                VSB
          0        1:        saa7111a           saa7111a (EVIP)
          1        0:        not used           EchoStar input (if R1080 is stuffed)
          1        1:        not used           EchoStar input (if R1080 is stuffed)
     */
    /* The clock mux (27MHZ_MUX) is set to use the audio in clock. This only affects TTR or
       TR boards where this clock is hardwarewise connected to the ST7000. */
    TRY(iicWriteReg(TTR_VIDMUX_IIC_EXPANDER_ADDRESS, -1, 0x1F));

    /* Don't want TriMedia to drive VO clock and sync since st7000
     * is also doing it. Without this, we have lift 3 pins on TriMedia
     * in the DTV reference board 1 and C1_1 board
     */
 
    MMIO(VO_CTL) = 0x32400000;  /* The hardware default value after reset */

    /* initialize UART */
    p.readRegisterFunc  = ttrReadUartRegister;
    p.writeRegisterFunc = ttrWriteUartRegister;
    p.crystalType       = PC16552D_CRYSTAL_1_8432;
    TRY(pc16552DInit(&p));

    /* MMIO(VO_CLOCK) = 0; Leave it running for testing */
    return TMLIBDEV_OK;
}                /* end of dtv_board_init() */

static tmLibdevErr_t dtv_ttr_board_activate(pcomponent_t comp)
{
    TRY(dtv_ttr_board_detect());

    /* At this point, we call the init function of the board */
    /* This function cannot fail according to the prototypes */
    /* Therefore, there is no error propagation */
    TRY(dtv_ttr_board_init());
    
    /* This is time to register the component outputs. */
    /* This will be used by all the devices to check */
    /* whether they can work with this board or not */
    TRY(dtv_ttr_board_register(comp));

    return True;
}

static tmLibdevErr_t dtv_ttr_board_register(pcomponent_t comp)
{
    if (boardID == BOARD_VERSION_PHILIPS_DTV_TTR)
        TRY(tsaBoardRegisterBoard(boardID, "Philips DTV TTR"));
    else /* (boardID == BOARD_VERSION_PHILIPS_DTV_TR) */
        TRY(tsaBoardRegisterBoard(boardID, "Philips DTV TR"));
    
    TRY(tsaBoardRegisterAO(0, &dtv_ao));
    TRY(tsaBoardRegisterAI(0, &dtv_ai));
    TRY(tsaBoardRegisterVO(0, &dtv_vo));
    TRY(tsaBoardRegisterVI(0, &dtv_vi));
    TRY(tsaBoardRegisterSSI(0, &dtv_afe));
    TRY(tsaBoardRegisterFlash(0, &ttrFlash));
    TRY(tsaBoardRegisterPIC(0, &ttrPIC));
    TRY(tsaBoardRegisterUart(0, &ttrUart1));
    TRY(tsaBoardRegisterUart(1, &ttrUart2));

    return TMLIBDEV_OK;
}

/******************** dtv_board_detect **********************************
 * Returns TMLIBDEV_OK if the hardware appears to be a Philips dtv board.
 */

static tmLibdevErr_t dtv_ttr_board_detect(void)
{
    Int         line;
    UInt32      d1, mfgID;
    UInt8       eepromData[8];

    for (line = 0; line < 8; line++) {
        TRY(iicReadReg(IIC_EEPROM_ADDRESS, line, &d1));
        eepromData[line] = d1;
    }
    mfgID   = (eepromData[3] << 8) + eepromData[4];
    boardID = (eepromData[1] << 8) + eepromData[2];

    if (mfgID != BOARD_ID_PHILIPS_MFG_ID)
    {
        return BOARD_ERR_UNKNOWN_BOARD;
    }

    if ((boardID == BOARD_VERSION_PHILIPS_DTV_TTR) || (boardID == BOARD_VERSION_PHILIPS_DTV_TR))
    {
        return TMLIBDEV_OK;
    }

    return BOARD_ERR_UNKNOWN_BOARD;
}

TSA_COMP_DEF_O_COMPONENT( Philips_dtv_ttr, 
                          TSA_COMP_BUILD_ARG_LIST_2("bsp/boardID", "bsp/uart"), 
                          dtv_ttr_board_activate);