source: svn/newcon3bcm2_21bu/dta/tests/unit_test/cert_common.c

/***************************************************************************
 *     Copyright (c) 2011, Broadcom Corporation
 *     All Rights Reserved
 *     Confidential Property of Broadcom Corporation
 *
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Workfile: $
 * $brcm_Revision: $
 * $brcm_Date: $
 *
 * Module Description: common routines for certification
 *
 * Revision History:
 *
 * $brcm_Log: $
 * 
 *
 ***************************************************************************/

#include "bstd.h"
#include "bkni.h"
#include "bdbg.h"
#include "bavc.h"
#include "bchp_sun_top_ctrl.h"

#include "gist.h"
#include "cert_common.h"
#include "ts_psi.h"

BDBG_MODULE(common);

struct comm_state_t commstate;

#define TUNE_FREQ 411000000
//#define TUNE_FREQ 723000000
#define TUNE_FEC eFEC_ANNEX_B
#define TUNE_QAM eQAM_Scan

#define VIDEO_PID 2176
#define AUDIO_PID 2177
#define PCR_PID 2176

#define ReadReg32(reg)  BREG_Read32(GetREG(),reg)
#define WriteReg32(reg,val) BREG_Write32(GetREG(),reg,val)

extern unsigned int menu_read_number(void);

int comm_decode_init(void);

void comm_init_tuner(void)
{
    if(NULL == commstate.tuner){
        bsettop_init(0);
        commstate.tuner = btuner_open(B_ID(0));
        BDBG_ASSERT(commstate.tuner);
        smessage_init(NULL);
        commstate.display = bdisplay_open(B_ID(0));
#if (BCHP_VER>=BCHP_VER_B0)
        commstate.rfm = brfm_open(0);
#endif
        commstate.freq = TUNE_FREQ;
        commstate.qam = TUNE_QAM;
        /* new settop api access the status register (500ms after ds_task is started)
           even though tuner lock evenrt was not generated it causes system crash by accessing status register */
        comm_tune();
    }
    BKNI_Printf("Enter numbers in decimal (1234) or hex (0x1234) format.\n");
    BKNI_Printf("Enter Frequency in KHz: ");
    commstate.freq = menu_read_number();
    commstate.freq = commstate.freq * 1000;
    BKNI_Printf("\n");
}

void comm_init_tuner_default(void)
{
    if(NULL == commstate.tuner){
        bsettop_init(0);
        commstate.tuner = btuner_open(B_ID(0));
        BDBG_ASSERT(commstate.tuner);
        smessage_init(NULL);
        commstate.display = bdisplay_open(B_ID(0));
#if (BCHP_VER>=BCHP_VER_B0)
        commstate.rfm = brfm_open(0);
#endif
    }
    commstate.freq = TUNE_FREQ;
    commstate.qam = TUNE_QAM;
    BKNI_Printf("Default tuner frequency is %d\n", commstate.freq);
}

int comm_tune(void)
{
    btuner_params params;
    bband_t tune_result;

    if(NULL == commstate.tuner){
        BDBG_ERR(("Tuner not initialized. Set tuner frequency first."));
        tune_result = -1;
        goto ExitFunc;
    }
    btuner_params_init(&params,commstate.tuner);
    params.qamMode = commstate.qam;
    params.fecMode = TUNE_FEC;
    params.wait_for_lock = 1;    
    tune_result = btuner_tune(commstate.tuner,commstate.freq,&params);
    if(0 > tune_result){
        BDBG_ERR(("Tune to %dHz failed\n",commstate.freq));
     }else{
        BDBG_ERR(("Tune to %dHz success\n",commstate.freq));
    }
ExitFunc:
    return tune_result;
}

/* dump memory in hex */
void comm_dump_mem(unsigned char * buff, size_t size)
{
    size_t i;

    for(i = 0; i < size; i++){
        BKNI_Printf(" %02x", buff[i]);
        if(0 == ((i+1)%16)){
            BKNI_Printf("\n");
        }
    }
    BKNI_Printf("\n");
}

/* dump memory in hex */
void comm_dump_mem32(unsigned int * buff, size_t size)
{
    size_t i;

    for(i = 0; i < size; i++){
        BKNI_Printf(" %08x", buff[i]);
        if(0 == ((i+1)%8)){
            BKNI_Printf("\n");
        }
    }
    BKNI_Printf("\n");
}

void comm_decode_params(void)
{
    BKNI_Printf("Enter numbers in decimal (1234) or hex (0x1234) format.\n");
    BKNI_Printf("Video pid: ");
    commstate.vpid = menu_read_number();
    BKNI_Printf("\nAudio pid: ");
    commstate.apid = menu_read_number();
    BKNI_Printf("\nPcr pid: ");
    commstate.ppid = menu_read_number();
    BKNI_Printf("\n");
}

void comm_decode_start(void)
{
    bstream_mpeg mpeg;
    bresult bres;
    bdecode_config cfg;
    bstream_t stream;

    bres = comm_decode_init();
    if(0 != bres){
        goto ExitFunc;
    }

    mpeg.video[0].pid = commstate.vpid;
    mpeg.video[0].format = BAVC_VideoCompressionStd_eMPEG2;
    mpeg.audio[0].pid = commstate.apid;
    mpeg.audio[0].format = BAVC_AudioCompressionStd_eAc3;
    mpeg.pcr_pid = commstate.ppid;
    stream = bstream_open(TUNER_BAND,&mpeg);
    if(NULL == stream){
        BDBG_ERR(("Unable to start decode. Already decoding?"));
        goto ExitFunc;
    }
    commstate.stream = stream;
    bres = bdecode_start(commstate.decode, commstate.stream, commstate.decode_w);
    bres = baudio_decode_start(commstate.audio, commstate.display, commstate.stream);

    bdecode_get_config(commstate.decode,&cfg);
    cfg.mute = 0;
    bdecode_set_config(commstate.decode,&cfg);
ExitFunc:
    return;
}

void comm_decode_start_ex(uint16_t vpid, uint16_t apid, uint16_t ppid, uint8_t vtype, uint8_t atype)
{
    bstream_mpeg mpeg;
    bresult bres;
    bdecode_config cfg;
    bstream_t stream;

    bres = comm_decode_init();
    if(0 != bres){
        goto ExitFunc;
    }
    mpeg.video[0].pid = vpid;
    mpeg.audio[0].pid = apid;
    mpeg.pcr_pid = ppid;

    switch (vtype)
    {
        case TS_PSI_ST_AVS_Video:
            mpeg.video[0].format = BAVC_VideoCompressionStd_eAVS;
            break;
        case TS_PSI_ST_14496_10_Video:
            mpeg.video[0].format = BAVC_VideoCompressionStd_eH264;
            break;
        case TS_PSI_ST_SMPTE_VC1:
            mpeg.video[0].format = BAVC_VideoCompressionStd_eVC1;
            break;
        case TS_PSI_ST_14496_2_Video:
            mpeg.video[0].format = BAVC_VideoCompressionStd_eMPEG4Part2;
            break;
        case TS_PSI_ST_13818_2_Video:
        case TS_PSI_ST_ATSC_Video:
        default:
            mpeg.video[0].format = BAVC_VideoCompressionStd_eMPEG2;
            break;
    }
    switch (atype)
    {
        case TS_PSI_ST_11172_3_Audio:
        case TS_PSI_ST_13818_3_Audio:
            mpeg.audio[0].format = BAVC_AudioCompressionStd_eMpegL1;
            break;
        case TS_PSI_ST_ATSC_EAC3:
            mpeg.audio[0].format = BAVC_AudioCompressionStd_eAc3Plus;
            break;
        case TS_PSI_ST_ATSC_AC3:
        default:
            mpeg.audio[0].format = BAVC_AudioCompressionStd_eAc3;
            break;
    }
    stream = bstream_open(TUNER_BAND, &mpeg);
    if (NULL == stream) {
        BDBG_ERR(("Unable to start decode. Already decoding?"));
        goto ExitFunc;
    }
    commstate.stream = stream;
    bres = bdecode_start(commstate.decode, commstate.stream, commstate.decode_w);
    bres = baudio_decode_start(commstate.audio, commstate.display, commstate.stream);

    bdecode_get_config(commstate.decode,&cfg);
    cfg.mute = 0;
    bdecode_set_config(commstate.decode,&cfg);
ExitFunc:
    return;
}

void comm_decode_stop(void)
{
    if(NULL != commstate.stream){
        bdecode_stop(commstate.decode);
        baudio_decode_stop(commstate.audio);
        bstream_close(commstate.stream);
        commstate.stream = NULL;
    }
}

void comm_decode_status()
{
    bdecode_status status;

    if (commstate.decode != NULL) {
        bdecode_get_status(commstate.decode, &status);
        BDBG_WRN(("width:%d height:%d", status.source_width, status.source_height));
    }
}

void comm_hdcp_callback(bool auth_valid)
{
    return;
}

int comm_decode_init(void)
{
    int res;
    res = 1;                    /* failure */
    if(NULL == commstate.display){
        BKNI_Printf("Error: did you forget to tune?\n");
        goto ExitFunc;
    }
    if(NULL == commstate.decode){
        commstate.decode = bdecode_open(0);
        BDBG_ASSERT(commstate.decode);

        /* this function returns NULL do no check result */
        commstate.decode_w = bdecode_window_open(0, commstate.display);

        commstate.audio = baudio_decode_open(B_ID(0));
        /* open hdmi output */
        bsettop_hdmi_open(&commstate.hdmi, commstate.display, commstate.audio, comm_hdcp_callback);
    }
    res = 0;
ExitFunc:
    return res;
}

void comm_decode_params_default(void)
{
    commstate.vpid = VIDEO_PID;
    BKNI_Printf("Video pid: %8d", commstate.vpid);
    commstate.apid = AUDIO_PID;
    BKNI_Printf("\nAudio pid: %8d", commstate.apid);
    commstate.ppid = PCR_PID;
    BKNI_Printf("\nPcr pid: %8d", commstate.ppid);
    BKNI_Printf("\n");    
}

void comm_reset(void)
{
    uint32_t value;

    value = ReadReg32(BCHP_SUN_TOP_CTRL_RESET_SOURCE_ENABLE);
    value |= BCHP_SUN_TOP_CTRL_RESET_SOURCE_ENABLE_sw_master_reset_enable_MASK;
    WriteReg32(BCHP_SUN_TOP_CTRL_RESET_SOURCE_ENABLE, value);
    value = ReadReg32(BCHP_SUN_TOP_CTRL_SW_MASTER_RESET);
    value |= BCHP_SUN_TOP_CTRL_SW_MASTER_RESET_chip_master_reset_MASK;
    WriteReg32(BCHP_SUN_TOP_CTRL_SW_MASTER_RESET, value);
}