saa7111.c

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

{
    return saa7111ConfigureM(&defaultVD[0], subaddr, value);
}

/******************************************************************************/


#define SAA711_LUMINANCE_REG    0x0a    /* 8 bits */
#define SAA711_CONTRAST_REG    0x0b     /* 7 bits */
#define SAA711_SATURATION_REG    0x0c   /* 8 bits */
#define SAA711_HUE_REG        0x0d      /* 8 bits */

extern      tmLibdevErr_t
saa7111GetBrightnessM(pboardVIDec_t pVD, UInt * val)
{
    return iicReadReg(pVD->slaveAddr, SAA711_LUMINANCE_REG, val);
}

extern      tmLibdevErr_t
saa7111GetBrightness(UInt * val)
{
    return saa7111GetBrightnessM(&defaultVD[0], val);
}

/******************************************************************************/

extern      tmLibdevErr_t
saa7111SetBrightnessM(pboardVIDec_t pVD, UInt val)
{
    if (val > 255)
        return BOARD_ERR_VAL_OUT_OF_RANGE;

    return iicWriteReg(pVD->slaveAddr, LuminanceBrightness, val);
}

extern      tmLibdevErr_t
saa7111SetBrightness(UInt val)
{
    return saa7111SetBrightnessM(&defaultVD[0], val);
}

/******************************************************************************/

extern      tmLibdevErr_t
saa7111GetContrastM(pboardVIDec_t pVD, UInt * val)
{
    return iicReadReg(pVD->slaveAddr, LuminanceContrast, val);
}

extern      tmLibdevErr_t
saa7111GetContrast(UInt * val)
{
    return saa7111GetContrastM(&defaultVD[0], val);
}

/******************************************************************************/

extern      tmLibdevErr_t
saa7111SetContrastM(pboardVIDec_t pVD, UInt val)
{
    if (val > 127)
        return BOARD_ERR_VAL_OUT_OF_RANGE;

    return iicWriteReg(pVD->slaveAddr, LuminanceContrast, val);
}

extern      tmLibdevErr_t
saa7111SetContrast(UInt val)
{
    return saa7111SetContrastM(&defaultVD[0], val);
}

/******************************************************************************/

extern      tmLibdevErr_t
saa7111GetSaturationM(pboardVIDec_t pVD, UInt * val)
{
    return iicReadReg(pVD->slaveAddr, ChromaSaturation, val);
}

extern      tmLibdevErr_t
saa7111GetSaturation(UInt * val)
{
    return saa7111GetSaturationM(&defaultVD[0], val);
}

/******************************************************************************/

extern      tmLibdevErr_t
saa7111SetSaturationM(pboardVIDec_t pVD, UInt val)
{
    if (val > 127)
        return BOARD_ERR_VAL_OUT_OF_RANGE;

    return iicWriteReg(pVD->slaveAddr, ChromaSaturation, val);
}

extern      tmLibdevErr_t
saa7111SetSaturation(UInt val)
{
    return saa7111SetSaturationM(&defaultVD[0], val);
}

/******************************************************************************/

extern      tmLibdevErr_t
saa7111GetHueM(pboardVIDec_t pVD, UInt * val)
{
    return iicReadReg(pVD->slaveAddr, ChromaHueControl, val);
}

extern      tmLibdevErr_t
saa7111GetHue(UInt * val)
{
    return saa7111GetHueM(&defaultVD[0], val);
}

/******************************************************************************/

extern      tmLibdevErr_t
saa7111SetHueM(pboardVIDec_t pVD, UInt val)
{
    if (val > 255)
        return BOARD_ERR_VAL_OUT_OF_RANGE;

    return iicWriteReg(pVD->slaveAddr, ChromaHueControl, val);
}

extern      tmLibdevErr_t
saa7111SetHue(UInt val)
{
    return saa7111SetHueM(&defaultVD[0], val);
}

/********************************************************************************************/
/* Helper functions for video decoder HAL functionality */

static Bool                         /* Successful or not */
SetReg(                             /* Set a register value */
    pboardVIDec_t pVD,              /* Pointer to I2C access structure */
    UInt8 bReg,                     /* Subaddress of the register */
    UInt8 bData)                    /* Value to be written */
{
    lastI2cError = 0;
    return ((lastI2cError = iicWriteReg(pVD->slaveAddr, bReg, bData)) == TMLIBDEV_OK);
}

static Bool                         /* Successful or not */
GetReg(                             /* Get a register value */
    pboardVIDec_t pVD,              /* Pointer to I2C access structure */
    UInt8 bReg,                     /* Subaddress of the register */
    UInt8 * pbData)                 /* Pointer to variable to recieve value */
{
    UInt data;
    Bool retVal;

    lastI2cError = 0;
    if (retVal = ((lastI2cError = iicReadReg (pVD->slaveAddr, bReg, &data)) == TMLIBDEV_OK))
        *pbData = data;
    else
        *pbData = 0;
    
    return retVal;
}

/********************************************************************************************/
extern tmLibdevErr_t
saa7111GetVSyncFallingEdge(pboardVIDec_t pVD, UInt *lineNumber)
{
    /* Equivalent to Video DecHAL VideoDecGetDefaultAcquisitionWnd */

    switch (pVD->curVideoStandard)
    {
    case vasNTSC:
        /* First line seen by TM */
        *lineNumber = 10;
        break;
    case vasPAL:
        *lineNumber = 23;
        break;
    default:
        return BOARD_ERR_COLOR_STANDARD_NOT_DETECTED;
    }

    return TMLIBDEV_OK;
}

extern tmLibdevErr_t
saa7111GetSlicedData(pboardVIDec_t pVD, UInt8 *Y, UInt8 *U, UInt8 *V, tmVideoDataService_t service, 
                     UInt sizeY, UInt8 *data, UInt8 *dataSize)
{
    /* Only Closed Caption supported by 7111 */

    switch (service)
    {
    case vdsUSClosedCaption:
      {
        UInt8 ccData[3];         /* Buffer for storing CC data */

        Int instance = 0;
        iicRequest_t req;
        tmLibdevErr_t err;
        
        if (err = iicOpen(&instance))
            return err;
            
        req.direction           = IIC_READ;
        req.byteCount           = 3;
        req.address             = pVD->slaveAddr;
        req.subaddress          = TextSlicerStatus;
        req.numRetries          = 10;
        req.waitBeforeRetry     = 50;
        req.data                = ccData;
        req.mode                = IIC_Synchronous_By_Polling;
        req.type                = IIC_SUBADDRESS;
        req.completion_function = Null;

        /* Read the decoder's CC registers */
        err  = iicDispatch(instance, &req);

        err |= iicClose(instance);

        /* Assume no data */
        *dataSize = 0;

        /* Check if new CC Bytes have arrived */
        if (ccData[0] & 0x5)
        {
            int mask;
            Bool addParity;

            /* Copy data bytes - don't forget to add parity bit... */
            addParity = True;
            for (mask = 1; mask < 0x80; mask <<= 1)
                if (ccData[1] & mask)
                    addParity = !addParity;
            data[0] = ccData[1] | (addParity ? 0x80 : 0);
 
            addParity = True;
            for (mask = 1; mask < 0x80; mask <<= 1)
                if (ccData[2] & mask)
                    addParity = !addParity;
            data[1] = ccData[2] | (addParity ? 0x80 : 0);

            *dataSize = 2;
        }
      }
      break;
    
    default:
        return BOARD_ERR_VAL_OUT_OF_RANGE;
    }

    return TMLIBDEV_OK;
}

extern tmLibdevErr_t
saa7111GetStatus(pboardVIDec_t pVD, tmVideoStatusType_t type, UInt *pState)
{
    UInt8 ucStatus;

    switch (type)
    {
        case vstLocked:                         /* HIGH unlocked, LOW locked */
            if(!GetReg(pVD, StatusByte, &ucStatus))
                return IIC_ERR_TIMEOUT;
            *pState = (ucStatus & 0x40) ? False : True;
            break;

        case vstColorSignal:                    /* HIGH color, LOW no color */
            if(!GetReg(pVD, StatusByte, &ucStatus))
                return IIC_ERR_TIMEOUT;
            *pState = (ucStatus & 0x01) ? True : False;
            break;

        case vstFrequency:                      /* HIGH 60Hz, LOW 50Hz */
            if(!GetReg(pVD, StatusByte, &ucStatus))
                return IIC_ERR_TIMEOUT;
            *pState = (ucStatus & 0x20) ? 60 : 50;
            break;

        case vstPowerUp:
            *pState = 0;                        /* Clear all */

            /* Check if new CC Bytes arrived */
            if(!GetReg(pVD, TextSlicerStatus, &ucStatus)) 
                return IIC_ERR_TIMEOUT;
            if (ucStatus & 0x5)
            {
                *pState |=
                    (vdsEuroClosedCaption | vdsUSClosedCaption);
            }
            break;
        default:
            return BOARD_ERR_VAL_OUT_OF_RANGE;
    }

    return TMLIBDEV_OK;
}

extern tmLibdevErr_t
saa7111GetSupportedDataServices(tmVideoDataService_t fieldOne[], tmVideoDataService_t fieldTwo[], UInt8 tblSize)
{
    int i;

    /* Write supported data services into arrays */
    for (i = 0; i < tblSize; i++)
    {
        if (i == 21)
        {
                    /* Closed caption OK */
            fieldOne [i] = fieldTwo [i] = vdsUSClosedCaption; 
        }
        else
        {
                    /* No other services... */
            fieldOne [i] = fieldTwo [i] = vdsNone;
        }
    }
                                                    
    return TMLIBDEV_OK;
}

extern tmLibdevErr_t
saa7111SetDataServices(pboardVIDec_t pVD, tmVideoDataService_t fieldOne[], tmVideoDataService_t fieldTwo[], UInt8 tblSize)
{
    /* Equivalent to Video DecHAL VideoDecOpenTT */

    int nCount;                                 /* Counter */

    int nProgrammableTextDataType;              /* Programmable text data type */
    int nAllowedDataTypes;

    if (tblSize > 25)                           /* Check upper bound */
    {
        tblSize = 25;
    }

    nProgrammableTextDataType = 0;
    nAllowedDataTypes         = vdsUSClosedCaption;

    /* Collect all teletext standards to be used -> 7111 only allows closed caption */
    for (nCount = 0; nCount < tblSize; nCount++)
        nProgrammableTextDataType |= (fieldOne[nCount] | fieldTwo[nCount]);

    if (nProgrammableTextDataType & ~nAllowedDataTypes)
            return BOARD_ERR_VAL_OUT_OF_RANGE;  /* Illegal standard requested */

    return TMLIBDEV_OK;
}

extern tmLibdevErr_t   
saa7111GetSlicerLineFlags(pboardVIDec_t pVD, Bool fieldOne[], Bool fieldTwo[], UInt8 tblSize)
{
    /* Equivalent to Video DecHAL VideoDecGetTTLineFlags */

    /* Line status is not supported by SAA7111 -> indicate error */

    return BOARD_ERR_UNSUPPORTED_STANDARD;
}

extern tmLibdevErr_t
saa7111EnableSlicing(pboardVIDec_t pVD, Bool enable)
{
    /* Equivalent to Video DecHAL VideoDecEnableTT */

    /* There's no way to turn on/off the 7111 slicer specificly */