aticonfg.cpp

winddk src目录下的WDM源码压缩!

    if( puchI2CValue == NULL)
        return( FALSE);

    i2cPacket.uchChipAddress = m_uchI2CExpanderAddress;
    i2cPacket.cbReadCount = 1;
    i2cPacket.cbWriteCount = 0;
    i2cPacket.puchReadBuffer = puchI2CValue;
    i2cPacket.puchWriteBuffer = NULL;
    i2cPacket.usFlags = 0;

    pCScript->ExecuteI2CPacket( &i2cPacket);

    return(( i2cPacket.uchI2CResult == I2C_STATUS_NOERROR) ? TRUE : FALSE);
}



/*^^*
 *      FindI2CExpanderAddress()
 * Purpose  : Determines I2C expander address.
 *
 * Inputs   :   CI2CScript * pCScript   : pointer to the I2CScript class object
 *
 * Outputs  : BOOL : returns TRUE, if no I2C access error;
 *              also sets m_uchI2CExpanderAddress class member. If any was not found, set it as 0xFF
 * Author   : IKLEBANOV
 *^^*/
BOOL CATIHwConfiguration::FindI2CExpanderAddress( CI2CScript * pCScript)
{
    USHORT      nIndex;
    UCHAR       uchI2CValue;
    I2CPacket   i2cPacket;
    // table of the possible I2C expender addresses
    UCHAR       auchI2CExpenderAddress[] = { 0x70, 0x78, 0x7c, 0x76};

    // unknown I2C expender address
    m_uchI2CExpanderAddress = 0xFF;
    for( nIndex = 0; nIndex < sizeof( auchI2CExpenderAddress); nIndex ++)
    {
        i2cPacket.uchChipAddress = auchI2CExpenderAddress[nIndex];
        i2cPacket.cbReadCount = 1;
        i2cPacket.cbWriteCount = 0;
        i2cPacket.puchReadBuffer = &uchI2CValue;
        i2cPacket.puchWriteBuffer = NULL;
        i2cPacket.usFlags = 0;

        pCScript->ExecuteI2CPacket( &i2cPacket);
        if( i2cPacket.uchI2CResult == I2C_STATUS_NOERROR)
        {
            m_uchI2CExpanderAddress = auchI2CExpenderAddress[nIndex];
            break;
        }
    }

    OutputDebugInfo(( "CATIHwConfig:FindI2CExpanderAddress() exit address = %x\n", m_uchI2CExpanderAddress));

    return( TRUE);
}



/*^^*
 *      GetAudioProperties()
 * Purpose  : Gets numbers of Audio inputs and outputs
 * Inputs   :   PULONG pulNumberOfInputs    : pointer to return number of Audio inputs
 *              PULONG pulNumberOfOutputs   : pointer to return number of Audio outputs
 *
 * Outputs  : BOOL : returns TRUE
 *              also sets the requested values into the input pointers
 * Author   : IKLEBANOV
 *^^*/
BOOL CATIHwConfiguration::GetAudioProperties( PULONG pulNumberOfInputs, PULONG pulNumberOfOutputs)
{

    if(( pulNumberOfInputs != NULL) && ( pulNumberOfOutputs != NULL))
    {
        // Hardcoded for AIW with no FM support - FM stuff has not been defined by Microsoft yet 
        * pulNumberOfInputs = 2;
        * pulNumberOfOutputs = 1;

        return( TRUE);
    }
    else
        return( FALSE);
}



/*^^*
 *      CanConnectAudioSource()
 * Purpose  : Determines possibility to connect the specified Audio source to the audio output.
 *
 * Inputs   : int nAudioSource  : the audio source the function is asked about
 *
 * Outputs  : BOOL : returns TRUE, the connection is possible;
 * Author   : IKLEBANOV
 *^^*/
BOOL CATIHwConfiguration::CanConnectAudioSource( int nAudioSource)
{
    BOOL bResult;

    if( nAudioSource != AUDIOSOURCE_MUTE)
        bResult = nAudioSource < AUDIOSOURCE_LASTSUPPORTED;
    else
        switch( m_uiAudioConfiguration)
        {
            case ATI_AUDIO_CONFIG_1:
            case ATI_AUDIO_CONFIG_2:
            case ATI_AUDIO_CONFIG_4:
            case ATI_AUDIO_CONFIG_5:
            case ATI_AUDIO_CONFIG_6:
            case ATI_AUDIO_CONFIG_7:
            case ATI_AUDIO_CONFIG_8:
                bResult = TRUE;
                break;

            case ATI_AUDIO_CONFIG_3:
            default:
                bResult = FALSE;
                break;
        }

    return( bResult);
}


/*^^*
 *      SetDefaultVolumeControl()
 * Purpose  : Set the default volume level, if the hardware support volume control
 *
 * Inputs   :   CI2CScript * pCScript   : pointer to I2CScript class object
 *
 * Outputs  : BOOL : returns FALSE, if either unknown audio source or I2C access error;
 * Author   : IKLEBANOV
 *^^*/
BOOL CATIHwConfiguration::SetDefaultVolumeControl( CI2CScript * pCScript)
{
    BOOL        bResult;
    I2CPacket   i2cPacket;
    UCHAR       uchWriteBuffer[3];

    switch( m_uiAudioConfiguration)
    {
        case ATI_AUDIO_CONFIG_4:

            ENSURE
            {
                i2cPacket.uchChipAddress = m_uchAudioAddress;
                i2cPacket.cbReadCount = 0;
                i2cPacket.cbWriteCount = 3;
                i2cPacket.puchReadBuffer = NULL;
                i2cPacket.puchWriteBuffer = uchWriteBuffer;
                i2cPacket.usFlags = I2COPERATION_WRITE;

                uchWriteBuffer[0] = 0x00;       // volume left + right
                uchWriteBuffer[1] = 0xFA;
                uchWriteBuffer[2] = 0xFA;

                bResult = pCScript->PerformI2CPacketOperation( &i2cPacket);

            } END_ENSURE;

            break;

        default:
            bResult = TRUE;
            break;
    }

    return( bResult);
}



/*^^*
 *      ConnectAudioSource()
 * Purpose  : Connects the specified Audio input to the Audio output.
 *
 * Inputs   :   CI2CScript * pCScript   : pointer to I2CScript class object
 *              int nAudioSource        : the audio source to be connected to the audio output
 *
 * Outputs  : BOOL : returns FALSE, if either unknown audio source or I2C access error;
 * Author   : IKLEBANOV
 *^^*/
BOOL CATIHwConfiguration::ConnectAudioSource( CI2CScript *  pCScript, 
                                              int           nAudioSource)
{
    UCHAR       uchORMask = 0;
    UCHAR       uchANDMask = 0xFF;
    UCHAR       uchReadValue, uchWriteValue[2];
    UCHAR       uchWrite16Value[5]; 
    I2CPacket   i2cPacket;
    BOOL        bI2CAccess, bResult;
    GPIOControl gpioAccessBlock;
    UCHAR       uchI2CAddr;
    USHORT      cbWRCount;
    USHORT      cbRDCount;
    USHORT      usI2CMode;

    switch( m_uiAudioConfiguration)
    {
        case ATI_AUDIO_CONFIG_1:
            bI2CAccess = TRUE;
            uchI2CAddr = m_uchI2CExpanderAddress;
            cbWRCount = 1;
            cbRDCount = 1;
            usI2CMode = I2COPERATION_READWRITE;

            uchANDMask &= 0xAF;
            switch( nAudioSource)
            {
                case AUDIOSOURCE_MUTE:
                    uchORMask |= 0x00;
                    break;
            
                case AUDIOSOURCE_TVAUDIO:
                    uchORMask |= 0x10;
                    break;
            
                case AUDIOSOURCE_LINEIN:
                    uchORMask |= 0x50;
                    break;
            
                case AUDIOSOURCE_FMAUDIO:
                    // no FM is supported

                default:
                    return( FALSE);
            }
            break;

        case ATI_AUDIO_CONFIG_2:
            bI2CAccess = FALSE;
            uchANDMask &= 0xFC;
            switch( nAudioSource)
            {
                case AUDIOSOURCE_MUTE:
                    uchORMask |= 0x02;
                    break;
            
                case AUDIOSOURCE_TVAUDIO:
                    uchORMask |= 0x01;
                    break;
            
                case AUDIOSOURCE_LINEIN:
                    uchORMask |= 0x00;
                    break;
            
                case AUDIOSOURCE_FMAUDIO:
                    uchORMask |= 0x03;

                default:
                    return( FALSE);
            }
            break;


        case ATI_AUDIO_CONFIG_3:
            bI2CAccess = TRUE;
            uchI2CAddr = m_uchI2CExpanderAddress;
            cbWRCount = 1;
            cbRDCount = 1;
            usI2CMode = I2COPERATION_READWRITE;

            uchANDMask &= 0xDF;
            switch( nAudioSource)
            {
                case AUDIOSOURCE_TVAUDIO:
                    uchORMask |= 0x00;
                    break;
            
                case AUDIOSOURCE_LINEIN:
                    uchORMask |= 0x40;
                    break;
            
                case AUDIOSOURCE_FMAUDIO:
                    // no FM is supported
                case AUDIOSOURCE_MUTE:
                    // no mute is supported
                default:
                    return( FALSE);
            }
            break;

        case ATI_AUDIO_CONFIG_4:
            bI2CAccess = TRUE;
            uchI2CAddr = m_uchAudioAddress;
            cbWRCount = 2;
            cbRDCount = 0;
            usI2CMode = I2COPERATION_WRITE;

            uchWriteValue[0] = 0x08;
            switch( nAudioSource)
            {
                case AUDIOSOURCE_MUTE:
                    uchWriteValue[1] = 0xF7;
                    break;

                case AUDIOSOURCE_TVAUDIO:
                    SetDefaultVolumeControl( pCScript);
                    uchWriteValue[1] = 0xD7;
                    break;
            
                case AUDIOSOURCE_LINEIN:
                    SetDefaultVolumeControl( pCScript);
                    uchWriteValue[1] = 0xCE;
                    break;
            
                case AUDIOSOURCE_FMAUDIO:
                    // no FM is supported
                default:
                    return( FALSE);
            }
            break;

        case ATI_AUDIO_CONFIG_5:
            bI2CAccess = TRUE;
            uchI2CAddr = m_uchI2CExpanderAddress;
            cbWRCount = 1;
            cbRDCount = 1;
            usI2CMode = I2COPERATION_READWRITE;

            uchANDMask &= 0xAF;
            switch( nAudioSource)
            {
                case AUDIOSOURCE_MUTE:
                    uchORMask |= 0x50;
                    break;
            
                case AUDIOSOURCE_TVAUDIO:
                    uchORMask |= 0x00;
                    break;
            
                case AUDIOSOURCE_LINEIN:
                    uchORMask |= 0x40;
                    break;
            
                case AUDIOSOURCE_FMAUDIO:
                    uchORMask |= 0x10;

                default:
                    return( FALSE);
            }
            break;

        case ATI_AUDIO_CONFIG_6:
        case ATI_AUDIO_CONFIG_7:
            bI2CAccess = TRUE;
            uchI2CAddr = m_uchDecoderAddress;
            cbWRCount = 2;
            cbRDCount = 1;
            usI2CMode = I2COPERATION_READWRITE;
            uchWriteValue[0] = 0x3F;

            uchANDMask &= 0xFC;
            switch( nAudioSource)
            {
                case AUDIOSOURCE_MUTE:
                    uchORMask |= 0x02;