tmbslhdmitx_app.c

HDMI NXP9983 chipset controller driver

    }

    /* Script: API_output fine adj */
    pixRateSingleDouble = pixRate;
    if (pixRate == HDMITX_PIXRATE_SINGLE_REPEATED)
    {
        pixRateSingleDouble = HDMITX_PIXRATE_SINGLE;
    }

        /* Script: api_input_output  - may give NOT_SUPPORTED error */
    err = tmbslHdmiTxVideoSetInOut(txUnit, vinFmt, HDMITX_SCAMODE_AUTO,
                             voutFmt, pixRepeat, 
                             HDMITX_MATMODE_AUTO, pathBits);
    RETIF(err != TM_OK, err + 0xC00);
    
    if (getReflineRefpix(vinFmt, vinMode, voutFmt, syncIn, pixRateSingleDouble,
                 &uRefPix, &uRefLine, &uScRefPix, &uScRefLine, pbVerified) > 0)
    {
        /* Combination found in table for scaler: configure input manually */
        err = tmbslHdmiTxVideoInSetSyncManual(txUnit, syncSource, syncMethod,
                     toggle, toggle, toggle, uRefPix, uRefLine);
        RETIF(err != TM_OK, err + 0xA00);
    }
    else
    {
        /* Not found so assume non-scaler and auto-configure input */
        err = tmbslHdmiTxVideoInSetSyncAuto(txUnit, syncSource, vinFmt, vinMode);
        RETIF(err != TM_OK, err + 0xB00);
    }



    /* Only set infoframes for HDMI, not DVI */
    if (sinkType == HDMITX_SINK_HDMI)
    {
        /* Script: api_set_avi_infoframe */
        err = setVideoInfoframe(txUnit, voutFmt, voutMode);
        RETIF(err != TM_OK, err + 0xD00);
    }

    /* Set scaler details if it has been switched on by previous APIs */
#ifdef __RC51__
#pragma nowarning(C207) /* Hide Raisonance "suspicious pointer conversion" */
#endif
    err = tmbslHdmiTxScalerGetMode(txUnit, &scalerMode);
#ifdef __RC51__
#pragma warning(C207)
#endif
    /* Ignore scaler TMBSL_ERR_HDMI_NOT_SUPPORTED error */
    if ((err == TM_OK) && (scalerMode == HDMITX_SCAMODE_ON))
    {
        /* Script: api_scaler_frame */
        err = tmbslHdmiTxScalerInDisable(txUnit, False);
        RETIF(err != TM_OK, err + 0xE00);

        /* Correction to interlace */
        topSel = HDMITX_TOPSEL_INTERNAL;
        if ((voutFmt == HDMITX_VFMT_05_1920x1080i_60Hz)
        ||  (voutFmt == HDMITX_VFMT_20_1920x1080i_50Hz))
        {
            /* vinFmt is range-checked by tmbslHdmiTxVideoSetInOut above */
            if ((kVfmtToShortFmt_TV[vinFmt] == TV_480p_60Hz)
            ||  (kVfmtToShortFmt_TV[vinFmt] == TV_576p_50Hz))
            {
                /* Correct for 1080i output for p->i conversion only */
                topSel = HDMITX_TOPSEL_VRF;
            }
        }
        err = tmbslHdmiTxScalerSetFieldOrder(txUnit,
            HDMITX_INTEXT_NO_CHANGE, HDMITX_INTEXT_NO_CHANGE,
            topSel, HDMITX_TOPTGL_NO_CHANGE);
        RETIF(err != TM_OK, err + 0xF00);

        /* Script: api_scaler_fineadj */
        err = tmbslHdmiTxScalerSetFine(txUnit, uScRefPix, uScRefLine);
        RETIF(err != TM_OK, err + 0x1000);

        /* Script: api_scaler_sync */
        err = tmbslHdmiTxScalerSetSync(txUnit, syncMethod,
                                       HDMITX_VSONCE_EACH_FRAME);
        RETIF(err != TM_OK, err + 0x1100);

        /* With scaler, use Only Once setting for tmbslHdmiTxVideoOutSetSync */
        once = HDMITX_VSONCE_ONCE;
    }
    else
    {
        once = HDMITX_VSONCE_EACH_FRAME;
    }

    /* Script: api_output_sync */
    err = tmbslHdmiTxVideoOutSetSync(txUnit, HDMITX_VSSRC_INTERNAL,
                               HDMITX_VSSRC_INTERNAL, HDMITX_VSSRC_INTERNAL,
                               HDMITX_VSTGL_TABLE, once);
    RETIF(err != TM_OK, err + 0x1200);
    
    /* tmbslHdmiTxTmdsSetOutputs not needed here as srl_force "toggle"
       in tmbslHdmiTxVideoOutSetSync resets NORMAL mode */

    return TM_OK;
}
/*============================================================================*/
/* Set audio format and audio rate */
tmErrorCode_t
appHdmiTx_setAudio
(
    tmUnitSelect_t          txUnit,     /* Defaults: */
    tmbslHdmiTxVidFmt_t     voutFmt,    /* HDMITX_VFMT_04_1280x720p_60Hz etc */
    tmbslHdmiTxSinkType_t   sinkType,   /* HDMITX_SINK_HDMI */
    tmbslHdmiTxaFmt_t       audioFmt,   /* HDMITX_AFMT_SPDIF */
    tmbslHdmiTxafs_t        audioRate,  /* HDMITX_AFS_48K */
    UInt8                   i2sQualifier
)
{
    tmErrorCode_t           err;        /* Error code from APIs */
    tmbslHdmiTxVfreq_t      vOutFreq;   /* Vertical output frequency */
    UInt16                  uCtsX;      /* CtsX value */
    UInt8                   layout;     /* 0 or 1 */
    tmbslHdmiTxctsRef_t     ctsRef;     /* CTS ref source */
    UInt8                   aifChannelCountCode = 0; /* audio info frame channels */
    tmbslHdmiTxPktAif_t     pktAif;     /* Audio infoframe packet */

    /* Only set audio for HDMI, not DVI */
    if (sinkType == HDMITX_SINK_HDMI)
    {
        if (AudioChannelAllocation == 0)
        {
            /* 2 channels */
            layout = 0;
        }
        else
        {
            /* Multi channels */
            layout = 1;
        }

        err = tmbslHdmiTxAudioInSetConfig(txUnit,
                        audioFmt, AudioChannelAllocation,
                        HDMITX_CHAN_NO_CHANGE, HDMITX_CLKPOLDSD_NO_CHANGE,
                        HDMITX_SWAPDSD_NO_CHANGE, layout,
                        0x80); /* uLatency_rd */
        RETIF(err != TM_OK, err + 0x010);

        vOutFreq = fmtToFreq(voutFmt);
        if ((audioFmt == HDMITX_AFMT_SPDIF) || (audioFmt == HDMITX_AFMT_DSD))
        {
            ctsRef = HDMITX_CTSREF_FS64SPDIF;
            uCtsX = HDMITX_CTSX_64;
        }
        else /* I2S */
        {
            ctsRef = HDMITX_CTSREF_ACLK;
            if (i2sQualifier == 32)
            {
                uCtsX = HDMITX_CTSX_64;
            }
            else
            {
                uCtsX = HDMITX_CTSX_32;
            }
        }
        err = tmbslHdmiTxAudioInSetCts(txUnit, ctsRef,
                        audioRate, voutFmt, vOutFreq, HDMITX_CTS_AUTO,
                        uCtsX, HDMITX_CTSK_USE_CTSX, HDMITX_CTSMTS_USE_CTSX);
        RETIF(err != TM_OK, err + 0x020);

        /* Set Channel Status registers
           No need to call tmbslHdmiTxAudioOutSetChanStatusMapping, since default Byte 2
           values of "Do not take into account" are adequate */
        err = tmbslHdmiTxAudioOutSetChanStatus(txUnit, HDMITX_CSFI_PCM_2CHAN_NO_PRE,
                        HDMITX_CSCOPYRIGHT_PROTECTED, 0x00, audioRate, 
                        HDMITX_CSCLK_LEVEL_II, HDMITX_CSMAX_LENGTH_20, HDMITX_CSWORD_DEFAULT,
                        HDMITX_CSOFREQ_NOT_INDICATED);
        RETIF(err != TM_OK, err + 0x030);

        /* Set reset_fifo to 1 */
        err = tmbslHdmiTxAudioOutSetMute(txUnit, HDMITX_AMUTE_ON);
        RETIF(err != TM_OK, err + 0x040);
        /* Wait for 20 ms */
        (void)tmbslHdmiTxSysTimerWait(txUnit, 20);
        /* Set reset_fifo to 0 */
        err = tmbslHdmiTxAudioOutSetMute(txUnit, HDMITX_AMUTE_OFF);
        RETIF(err != TM_OK, err + 0x050);

        aifChannelCountCode = kChanAllocChanNum[AudioChannelAllocation] - 1;

        /* Script: api_set_audio_infoframe */
        pktAif.ChannelCount       = aifChannelCountCode;
        pktAif.CodingType         = 0; /* refer to stream header */
        pktAif.SampleSize         = 0; /* refer to stream header */
        pktAif.ChannelAlloc       = AudioChannelAllocation;
        pktAif.LevelShift         = 0; /* 0dB level shift */
        pktAif.DownMixInhibit     = 0; /* down-mix stereo permitted */
        pktAif.SampleFreq		= AIF_SF_REFER_TO_STREAM_HEADER; /* refer to stream header */
        err = tmbslHdmiTxPktSetAudioInfoframe(txUnit, &pktAif, True);
        RETIF(err != TM_OK, err + 0x060);
    }
    else
    {
        err = TMBSL_ERR_HDMI_BAD_PARAMETER;
    }
    return err;
}

/*============================================================================*/
/* Set audio channel allocation */
void
appHdmiTx_setAudioChannelAllocation
(
    UInt8                   channelAllocation
)
{

    AudioChannelAllocation = channelAllocation;

}

#ifndef NO_HDCP
/*============================================================================*/
/* Set HDCP On */
tmErrorCode_t
appHdmiTx_Hdcp_On
(
    tmUnitSelect_t           txUnit,
    tmbslHdmiTxVidFmt_t      voutFmt,
    tmbslHdmiTxHdcpOptions_t options
)
{
    tmErrorCode_t            err;
    tmbslHdmiTxVfreq_t       voutFreq;
    UInt8                    slaveAddress;

    /* Reset HDCP app data to ensure that new values are used */
    HdcpKsvDevices = 0;
    lAppMemset(HdcpBksv, 0, sizeof(HdcpBksv));

    /* Derive output vertical frequency from output format */
    voutFreq = fmtToFreq(voutFmt);

    /* Configure HDCP */
    slaveAddress = HDMITX_HDCP_SLAVE_PRIMARY;
#ifdef DEMO_REPEATER
    txMode       = HDMITX_HDCP_TXMODE_REPEATER;
#else /* DEMO_REPEATER */
    txMode       = HDMITX_HDCP_TXMODE_TOP_LEVEL;
#endif /* DEMO_REPEATER */
    err = tmbslHdmiTxHdcpConfigure(txUnit, slaveAddress, txMode, options,
        HDCP_CHECK_INTERVAL_MS, HDCP_NUM_CHECKS);
    RETIF(err != TM_OK, err + 0x100);

    /* Start HDCP */
    err = tmbslHdmiTxHdcpInit(txUnit, voutFmt, voutFreq);
    RETIF(err != TM_OK, err + 0x200);
    err = tmbslHdmiTxHdcpRun(txUnit);
    return err;
}

/*============================================================================*/
/* Set HDCP Off */
tmErrorCode_t
appHdmiTx_Hdcp_Off
(
    tmUnitSelect_t txUnit
)
{
    return tmbslHdmiTxHdcpStop(txUnit);
}

/*==========================================