tmbslhdmitx_local.c

HDMI NXP9983 chipset controller driver

    fieldValue <<= kMaskToShift[fieldMask];

    /* Reset shifted field bits that are not set in the mask */
    fieldValue &= fieldMask;

    /* Set the shifted bitfield */
    regValue |= fieldValue;

    /* Set shadow copy */
    if (regShad != E_SNONE)
    {
        pDis->shadowReg[regShad] = regValue;
    }

    /* Write to I2C - all non-OK results are errors */
    sysArgs.slaveAddr       = pDis->uHwAddress;
    sysArgs.firstRegister   = regAddr;
    sysArgs.lenData         = 1;
    sysArgs.pData           = &regValue;
    err = pDis->sysFuncWrite(&sysArgs);
    return (err == TM_OK) ? TM_OK : TMBSL_ERR_HDMI_I2C_WRITE;
}

/*============================================================================*/
/* setHwRegisterFieldTable                                                    */
/*============================================================================*/
tmErrorCode_t
setHwRegisterFieldTable
(
    tmHdmiTxobject_t *pDis,
    const tmHdmiTxRegMaskVal_t *pTable
)
{
    tmErrorCode_t err; /* Error code */
    Int           i;   /* Table index */

    /* Set register, mask and value from table until terminator is reached */
    for (i = 0; pTable[i].Reg > 0; i++)
    {
        err = setHwRegisterField(pDis, pTable[i].Reg, pTable[i].Mask, pTable[i].Val);
        RETIF(err != TM_OK, err)
    }
    return TM_OK;
}

/*============================================================================*/
/* setState                                                                   */
/*============================================================================*/
tmErrorCode_t
setState
(
    tmHdmiTxobject_t   *pDis,
    tmbslHdmiTxEvent_t  event
)
{
    tmbslHdmiTxState_t state = pDis->state;
    UInt8 nIgnoredEvents = pDis->nIgnoredEvents;

    switch (state)
    {
    case ST_UNINITIALIZED:
        switch (event)
        {
        case EV_UNPLUGGED:          state = ST_DISCONNECTED;      break;
        case EV_PLUGGEDIN:          state = ST_AWAIT_EDID;        break;
        default:                    nIgnoredEvents++;             break;
        }                                                               
        break;                                                          
    case ST_DISCONNECTED:                                               
        switch (event)                                                  
        {                                                               
        case EV_DEINIT:             state = ST_UNINITIALIZED;     break;
        case EV_PLUGGEDIN:          state = ST_AWAIT_EDID;        break;
        case EV_STANDBY:            state = ST_STANDBY;           break;
        default:                    nIgnoredEvents++;             break;
        }                                                               
        break;                                                          
    case ST_AWAIT_EDID:                                                 
        switch (event)                                                  
        {                                                               
        case EV_DEINIT:             state = ST_UNINITIALIZED;     break;
        case EV_UNPLUGGED:          state = ST_DISCONNECTED;      break;
        case EV_STANDBY:            state = ST_STANDBY;           break;
#if defined (TMFL_TDA9981_SUPPORT) && defined(TMFL_RX_SENSE_ON)
		case EV_GETBLOCKDATA:       state = ST_AWAIT_RX_SENSE;	  break;
#else /* TMFL_TDA9981_SUPPORT & TMFL_RX_SENSE_ON */
        case EV_GETBLOCKDATA:       state = ST_SINK_CONNECTED;    break;
#endif /* TMFL_TDA9981_SUPPORT & TMFL_RX_SENSE_ON */
        default:                    nIgnoredEvents++;             break;
        }
        break;
#if defined (TMFL_TDA9981_SUPPORT) && defined(TMFL_RX_SENSE_ON)
   case ST_AWAIT_RX_SENSE:                                                 
        switch (event)                                                  
        {                                                               
        case EV_DEINIT:             state = ST_UNINITIALIZED;     break;
        case EV_UNPLUGGED:          state = ST_DISCONNECTED;      break;
        case EV_STANDBY:            state = ST_STANDBY;           break;
        case EV_SINKON:             state = ST_SINK_CONNECTED;    break;
        default:                    nIgnoredEvents++;             break;
        }
        break;
#endif /* TMFL_TDA9981_SUPPORT & TMFL_RX_SENSE_ON */
  case ST_SINK_CONNECTED:
        switch (event)
        {
        case EV_DEINIT:             state = ST_UNINITIALIZED;     break;
        case EV_UNPLUGGED:          state = ST_DISCONNECTED;      break;
        case EV_STANDBY:            state = ST_STANDBY;           break;
        case EV_SETINOUT:           state = ST_VIDEO_NO_HDCP;     break;
#if defined (TMFL_TDA9981_SUPPORT) && defined(TMFL_RX_SENSE_ON)
        case EV_SINKOFF:            state = ST_AWAIT_RX_SENSE;    break;
#endif /* TMFL_TDA9981_SUPPORT & TMFL_RX_SENSE_ON */
        default:                    nIgnoredEvents++;             break;
        }                                                               
        break;                                                          
    case ST_VIDEO_NO_HDCP:                                              
        switch (event)                                                  
        {                                                               
        case EV_DEINIT:             state = ST_UNINITIALIZED;     break;
        case EV_UNPLUGGED:          state = ST_DISCONNECTED;      break;
        case EV_STANDBY:            state = ST_STANDBY;           break;
        case EV_OUTDISABLE:         state = ST_SINK_CONNECTED;    break;
        case EV_HDCP_RUN:           state = ST_HDCP_WAIT_RX;      break;
#if defined (TMFL_TDA9981_SUPPORT) && defined(TMFL_RX_SENSE_ON)
        case EV_SINKOFF:            state = ST_AWAIT_RX_SENSE;    break;
#endif /* TMFL_TDA9981_SUPPORT & TMFL_RX_SENSE_ON */
        default:                    nIgnoredEvents++;             break;
        }                                                               
        break;                                                          
    case ST_HDCP_WAIT_RX:                                               
        switch (event)                                                  
        {                                                               
        case EV_DEINIT:             state = ST_UNINITIALIZED;     break;
        case EV_UNPLUGGED:          state = ST_DISCONNECTED;      break;
        case EV_STANDBY:            state = ST_STANDBY;           break;
        case EV_HDCP_BKSV_NREPEAT:  state = ST_HDCP_AUTHENTICATED;break;
        case EV_HDCP_BKSV_REPEAT:   state = ST_HDCP_WAIT_BSTATUS; break;
        case EV_HDCP_BKSV_NSECURE:  state = ST_HDCP_WAIT_RX;      break;
        case EV_HDCP_T0:            state = ST_HDCP_WAIT_RX;      break;
        case EV_HDCP_STOP:          state = ST_VIDEO_NO_HDCP;     break;
#if defined (TMFL_TDA9981_SUPPORT) && defined(TMFL_RX_SENSE_ON)
        case EV_SINKOFF:            state = ST_AWAIT_RX_SENSE;    break;
#endif /* TMFL_TDA9981_SUPPORT & TMFL_RX_SENSE_ON */
        default:                    nIgnoredEvents++;             break;
        }
        break;
    case ST_HDCP_WAIT_BSTATUS:
        switch (event)
        {
        case EV_DEINIT:             state = ST_UNINITIALIZED;     break;
        case EV_UNPLUGGED:          state = ST_DISCONNECTED;      break;
        case EV_STANDBY:            state = ST_STANDBY;           break;
        case EV_HDCP_BSTATUS_GOOD:  state = ST_HDCP_WAIT_SHA_1;   break;
        case EV_HDCP_T0:            state = ST_HDCP_WAIT_RX;      break;
        case EV_HDCP_STOP:          state = ST_VIDEO_NO_HDCP;     break;
#if defined (TMFL_TDA9981_SUPPORT) && defined(TMFL_RX_SENSE_ON)
        case EV_SINKOFF:            state = ST_AWAIT_RX_SENSE;    break;
#endif /* TMFL_TDA9981_SUPPORT & TMFL_RX_SENSE_ON */
        default:                    nIgnoredEvents++;             break;
        }
        break;
    case ST_HDCP_WAIT_SHA_1:
        switch (event)
        {
        case EV_DEINIT:             state = ST_UNINITIALIZED;     break;
        case EV_UNPLUGGED:          state = ST_DISCONNECTED;      break;
        case EV_STANDBY:            state = ST_STANDBY;           break;
        case EV_HDCP_KSV_SECURE:    state = ST_HDCP_AUTHENTICATED;break;
        case EV_HDCP_T0:            state = ST_HDCP_WAIT_RX;      break;
        case EV_HDCP_STOP:          state = ST_VIDEO_NO_HDCP;     break;
#if defined (TMFL_TDA9981_SUPPORT) && defined(TMFL_RX_SENSE_ON) 
        case EV_SINKOFF:            state = ST_AWAIT_RX_SENSE;    break;
#endif /* TMFL_TDA9981_SUPPORT & TMFL_RX_SENSE_ON */
        default:                    nIgnoredEvents++;             break;
        }
        break;
    case ST_HDCP_AUTHENTICATED:
        switch (event)
        {
        case EV_DEINIT:             state = ST_UNINITIALIZED;     break;
        case EV_UNPLUGGED:          state = ST_DISCONNECTED;      break;
        case EV_STANDBY:            state = ST_STANDBY;           break;
        case EV_HDCP_T0:            state = ST_HDCP_WAIT_RX;      break;
        case EV_HDCP_STOP:          state = ST_VIDEO_NO_HDCP;     break;
#if defined (TMFL_TDA9981_SUPPORT) && defined(TMFL_RX_SENSE_ON)
        case EV_SINKOFF:            state = ST_AWAIT_RX_SENSE;    break;
#endif /* TMFL_TDA9981_SUPPORT & TMFL_RX_SENSE_ON */
        default:                    nIgnoredEvents++;             break;
        }
        break;
    case ST_STANDBY:
        switch (event)
        {
        case EV_DEINIT:             state = ST_UNINITIALIZED;     break;
        case EV_RESUME_UNPLUGGED:   state = ST_DISCONNECTED;      break;
        case EV_RESUME_PLUGGEDIN:   state = ST_AWAIT_EDID;        break;
        default:                    nIgnoredEvents++;             break;
        }
        break;
    case ST_INVALID:
        nIgnoredEvents++;
        break;
    }
    pDis->state = state;
    pDis->nIgnoredEvents = nIgnoredEvents;
    return TM_OK;
}

/*============================================================================*/
/* lmemcpy                                                                     */
/*============================================================================*/
tmErrorCode_t
lmemcpy
(
    void *pTable1,
    const void * pTable2,
    UInt Size
)
{
    char *ptrSource = (char*) pTable1;
    char *endSource = (char*)pTable1 + Size;
    char *ptrDest = (char *)pTable2;

    RETIF_BADPARAM(pTable1 == Null)
    RETIF_BADPARAM(pTable2 == Null)

    while (endSource > ptrSource)
    {
        *(ptrSource++) = *(ptrDest++);
    }
    return TM_OK;
}

/*============================================================================*/
/* lmemset                                                                     */
/*============================================================================*/
tmErrorCode_t
lmemset
(
    void *pTable1,
    const UInt8 Value,
    UInt Size
)
{
    char *ptrSource = (char*) pTable1;
    char *endSource = (char*)pTable1 + Size;

    RETIF_BADPARAM(pTable1 == Null)

    while (endSource > ptrSource)
    {
        *(ptrSource++) = Value;
    }
    return TM_OK;
}

/*============================================================================*/
/*                   STATIC FUNCTION DEFINTIONS                               */
/*============================================================================*/

/*============================================================================*/
/*                     END OF FILE                                            */
/*============================================================================*/