windows-server-2003/drivers/wdm/capture/mini/atiwdm/tuners/1236/tuneprop.cpp

//==========================================================================;
//
//  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
//  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
//  PURPOSE.
//
//  Copyright (c) 1992 - 1996  Microsoft Corporation.  All Rights Reserved.
//
//==========================================================================;

extern "C"
{
#include "strmini.h"
#include "ksmedia.h"

#include "wdmdebug.h"
}

#include "wdmdrv.h"
#include "atitunep.h"
#include "aticonfg.h"


/*^^*
 *      AdapterGetProperty()
 * Purpose  : Called when SRB_GET_PROPERTY SRB is received.
 *
 * Inputs   :   PHW_STREAM_REQUEST_BLOCK pSrb   : pointer to the current Srb
 *
 * Outputs  : BOOL : returns returns FALSE, if it is not a TVTuner property
 *              it also returns the required property
 * Author   : IKLEBANOV
 *^^*/
BOOL CATIWDMTuner::AdapterGetProperty( PHW_STREAM_REQUEST_BLOCK pSrb)
{
    PSTREAM_PROPERTY_DESCRIPTOR pSpd = pSrb->CommandData.PropertyInfo;
    ULONG   uiPropertyId = pSpd->Property->Id;              // index of the property
    BOOL    bResult = FALSE;

    if( !::IsEqualGUID(( const struct _GUID &)PROPSETID_TUNER, ( const struct _GUID &)pSpd->Property->Set))
        return( bResult);

    if(( pSpd == NULL) || ( pSpd->PropertyInfo == NULL))
        return( bResult);
    
    OutputDebugInfo(( "CATIWDMTuner:AdapterGetProperty() Id = %d\n", uiPropertyId));

    bResult = TRUE;

    switch( uiPropertyId)
    {
    case KSPROPERTY_TUNER_CAPS:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_CAPS_S));
        {
            KSPIN_MEDIUM NoPinMedium;
            PKSPROPERTY_TUNER_CAPS_S pTunerCaps = ( PKSPROPERTY_TUNER_CAPS_S)pSpd->PropertyInfo;

            // Copy the input property info to the output property info
            ::RtlCopyMemory( pTunerCaps, pSpd->Property, sizeof( KSPROPERTY_TUNER_CAPS_S));

            pTunerCaps->ModesSupported = m_ulSupportedModes;

            NoPinMedium.Set = GUID_NULL;
            NoPinMedium.Id = 0;
            NoPinMedium.Flags = 0;

            switch( m_ulNumberOfPins)
            {
            case 2:
            case 3:
                // TVTuner with TVAudio
/*
                pTunerCaps->VideoMedium = &m_pTVTunerPinsMediumInfo[0];
                pTunerCaps->TVAudioMedium = &m_pTVTunerPinsMediumInfo[1];
                pTunerCaps->RadioAudioMedium = ( m_ulNumberOfPins == 3) ?
                    &m_pTVTunerPinsMediumInfo[2] : NULL;
*/
                pTunerCaps->VideoMedium = m_pTVTunerPinsMediumInfo[0];
                pTunerCaps->TVAudioMedium = m_pTVTunerPinsMediumInfo[1];
                pTunerCaps->RadioAudioMedium = ( m_ulNumberOfPins == 3) ?
                    m_pTVTunerPinsMediumInfo[2] : NoPinMedium;
                break;

            case 1:
                // it can be FM Tuner only.
/*
                pTunerCaps->VideoMedium = NULL;
                pTunerCaps->TVAudioMedium = NULL;
                pTunerCaps->RadioAudioMedium = &m_pTVTunerPinsMediumInfo[0];
*/
                pTunerCaps->VideoMedium = NoPinMedium;
                pTunerCaps->TVAudioMedium = NoPinMedium;
                pTunerCaps->RadioAudioMedium = m_pTVTunerPinsMediumInfo[0];
                break;
            }

            pSrb->ActualBytesTransferred = sizeof( KSPROPERTY_TUNER_CAPS_S);
        }
        break;

    case KSPROPERTY_TUNER_MODE_CAPS:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_MODE_CAPS_S));
        {
            PKSPROPERTY_TUNER_MODE_CAPS_S   pTunerModeCaps = ( PKSPROPERTY_TUNER_MODE_CAPS_S)pSpd->PropertyInfo;
            ULONG                           ulOperationMode = (( PKSPROPERTY_TUNER_MODE_CAPS_S)pSpd->Property)->Mode;

            // Copy the input property info to the output property info
            ::RtlCopyMemory( pTunerModeCaps, pSpd->Property, sizeof( PKSPROPERTY_TUNER_MODE_CAPS_S));

            if( !( ulOperationMode & m_ulSupportedModes))
            {
                TRAP;
                bResult = FALSE;
                break;
            }

            // There is support for TVTuner at this tinme only. It will be enchanced later on to
            // support FM Tuner as well.
            switch( ulOperationMode)
            {
                case KSPROPERTY_TUNER_MODE_TV :
                    ::RtlCopyMemory( &pTunerModeCaps->StandardsSupported, &m_wdmTunerCaps, sizeof( ATI_KSPROPERTY_TUNER_CAPS));
                    break;

                default:
                    bResult = FALSE;
                    break;
            }

            pSrb->ActualBytesTransferred = sizeof( KSPROPERTY_TUNER_MODE_CAPS_S);
        }
        break;

    case KSPROPERTY_TUNER_MODE:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_MODE_S));
        {
            PKSPROPERTY_TUNER_MODE_S pTunerMode = ( PKSPROPERTY_TUNER_MODE_S)pSpd->PropertyInfo;

            // Copy the input property info to the output property info
            ::RtlCopyMemory( pTunerMode, pSpd->Property, sizeof( PKSPROPERTY_TUNER_MODE_S));

            pTunerMode->Mode = m_ulTunerMode;

            pSrb->ActualBytesTransferred = sizeof( KSPROPERTY_TUNER_MODE_S);
        }
        break;

    case KSPROPERTY_TUNER_STANDARD:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_STANDARD_S));
        {
            PKSPROPERTY_TUNER_STANDARD_S pTunerStandard = ( PKSPROPERTY_TUNER_STANDARD_S)pSpd->PropertyInfo;

            // Copy the input property info to the output property info
            ::RtlCopyMemory( pTunerStandard, pSpd->Property, sizeof( KSPROPERTY_TUNER_STANDARD_S));

            pTunerStandard->Standard = m_ulVideoStandard;

            pSrb->ActualBytesTransferred = sizeof( KSPROPERTY_TUNER_STANDARD_S);
        }
        break;

    case KSPROPERTY_TUNER_FREQUENCY:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_FREQUENCY_S));
        {
            PKSPROPERTY_TUNER_FREQUENCY_S pTunerFrequency = ( PKSPROPERTY_TUNER_FREQUENCY_S)pSpd->PropertyInfo;

            // Copy the input property info to the output property info
            ::RtlCopyMemory( pTunerFrequency, pSpd->Property, sizeof( KSPROPERTY_TUNER_FREQUENCY_S));

            pTunerFrequency->Frequency = m_ulTuningFrequency;

            pSrb->ActualBytesTransferred = sizeof( KSPROPERTY_TUNER_FREQUENCY_S);
        }
        break;

    case KSPROPERTY_TUNER_INPUT:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_INPUT_S));
        {
            PKSPROPERTY_TUNER_INPUT_S pTunerInput = ( PKSPROPERTY_TUNER_INPUT_S)pSpd->PropertyInfo;

            // Copy the input property info to the output property info
            ::RtlCopyMemory( pTunerInput, pSpd->Property, sizeof( KSPROPERTY_TUNER_INPUT_S));

            pTunerInput->InputIndex = m_ulTunerInput;

            pSrb->ActualBytesTransferred = sizeof( KSPROPERTY_TUNER_INPUT_S);
        }
        break;

    case KSPROPERTY_TUNER_STATUS:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_STATUS_S));
        {
            BOOL    bBusy;
            LONG    lPLLOffset;
            PKSPROPERTY_TUNER_STATUS_S pTunerStatus = ( PKSPROPERTY_TUNER_STATUS_S)pSpd->PropertyInfo;

            if(( bResult = GetTunerPLLOffsetBusyStatus( &lPLLOffset, &bBusy)))
            {
                OutputDebugInfo(( "CATIWDMTuner:GetStatus() Busy = %d, Quality = %d, Frequency = %ld\n",
                    bBusy, lPLLOffset, m_ulTuningFrequency));

                // Copy the input property info to the output property info
                ::RtlCopyMemory( pTunerStatus, pSpd->Property, sizeof( KSPROPERTY_TUNER_STATUS_S));

                pTunerStatus->Busy = bBusy;
                if( !bBusy)
                {
                    pTunerStatus->PLLOffset = lPLLOffset;
                    pTunerStatus->CurrentFrequency = m_ulTuningFrequency;
                }

                pSrb->ActualBytesTransferred = sizeof( KSPROPERTY_TUNER_STATUS_S);
            }
            else
            {
                bResult = FALSE;
                OutputDebugError(( "CATIWDMTuner:GetStatus() fails\n"));
            }
        }
        break;

    default:
        TRAP;
        bResult = FALSE;
        break;
    }

    return( bResult);
}



/*^^*
 *      AdapterSetProperty()
 * Purpose  : Called when SRB_GET_PROPERTY SRB is received.
 *
 * Inputs   :   PHW_STREAM_REQUEST_BLOCK pSrb   : pointer to the current Srb
 *
 * Outputs  : BOOL : returns FALSE, if it is not a TVTuner property
 *              it also sets the required property
 * Author   : IKLEBANOV
 *^^*/
BOOL CATIWDMTuner::AdapterSetProperty( PHW_STREAM_REQUEST_BLOCK pSrb)
{

    PSTREAM_PROPERTY_DESCRIPTOR pSpd = pSrb->CommandData.PropertyInfo;
    ULONG uiPropertyId = pSpd->Property->Id;            // index of the property

    if( !::IsEqualGUID( ( const struct _GUID &)PROPSETID_TUNER, ( const struct _GUID &)pSpd->Property->Set))
        return( FALSE);

    OutputDebugInfo(( "CATIWDMTuner:AdapterSetProperty() Id = %d\n", uiPropertyId));

    switch( uiPropertyId)
    {
    case KSPROPERTY_TUNER_MODE:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_MODE_S));
        {
            ULONG ulModeToSet = (( PKSPROPERTY_TUNER_MODE_S)pSpd->PropertyInfo)->Mode;

            if( ulModeToSet & m_ulSupportedModes)
            {
                if( ulModeToSet != m_ulTunerMode)
                    if( SetTunerMode( ulModeToSet))
                        m_ulTunerMode = ulModeToSet;
            }
            else
                return( FALSE);
        }
        break;

    case KSPROPERTY_TUNER_STANDARD:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_STANDARD_S));
        {
            ULONG ulStandardToSet = (( PKSPROPERTY_TUNER_STANDARD_S)pSpd->PropertyInfo)->Standard;

            if( ulStandardToSet & m_wdmTunerCaps.ulStandardsSupported)
            {
                if( ulStandardToSet != m_ulVideoStandard)
                    if( SetTunerVideoStandard( ulStandardToSet))
                        m_ulVideoStandard = ulStandardToSet;
            }
            else
                return( FALSE);
        }
        break;

    case KSPROPERTY_TUNER_FREQUENCY:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_FREQUENCY_S));
        {
            ULONG   ulFrequencyToSet = (( PKSPROPERTY_TUNER_FREQUENCY_S)pSpd->PropertyInfo)->Frequency;
            BOOL    bResult = FALSE;

            ENSURE
            {
                if(( ulFrequencyToSet < m_wdmTunerCaps.ulMinFrequency) ||
                    ( ulFrequencyToSet > m_wdmTunerCaps.ulMaxFrequency))
                        FAIL;

                if( ulFrequencyToSet != m_ulTuningFrequency)
                {
                    if( !SetTunerFrequency( ulFrequencyToSet))
                        FAIL;

                    // update driver
                    m_ulTuningFrequency = ulFrequencyToSet;
                }

                bResult = TRUE;

            } END_ENSURE;

            if( !bResult)
            {
                OutputDebugError(( "CATIWDMTuner:SetFrequency() fails Frequency = %ld\n", ulFrequencyToSet));

                return( FALSE);
            }

            OutputDebugInfo(( "CATIWDMTuner:SetFrequency() new TuningFrequency = %ld\n", ulFrequencyToSet));
        }
        break;

    case KSPROPERTY_TUNER_INPUT:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_INPUT_S));
        {
            ULONG nInputToSet = (( PKSPROPERTY_TUNER_INPUT_S)pSpd->PropertyInfo)->InputIndex;

            if( nInputToSet < m_wdmTunerCaps.ulNumberOfInputs)
            {
                if( nInputToSet != m_ulTunerInput)
                    if( SetTunerInput( nInputToSet))
                        m_ulTunerInput = nInputToSet;
                    else
                        return( FALSE);
            }
            else
                return( FALSE);
        }
        break;

    default:
        TRAP;
        return( FALSE);
    }

    return( TRUE);
}



/*^^*
 *      SetWDMTunerKSTopology()
 * Purpose  : Sets the KSTopology structure
 *              Called during CWDMTuner class construction time.
 *
 * Inputs   : none
 *
 * Outputs  : none
 * Author   : IKLEBANOV
 *^^*/
void CATIWDMTuner::SetWDMTunerKSTopology( void)
{
    GUID wdmTunerTopologyCategory[] =
    {
        STATIC_KSCATEGORY_TVTUNER
    };
    
    ::RtlCopyMemory( &m_wdmTunerTopologyCategory, wdmTunerTopologyCategory, sizeof( wdmTunerTopologyCategory));

    m_wdmTunerTopology.CategoriesCount = 1;
    m_wdmTunerTopology.Categories = &m_wdmTunerTopologyCategory;
    m_wdmTunerTopology.TopologyNodesCount = 0;
    m_wdmTunerTopology.TopologyNodes = NULL;
    m_wdmTunerTopology.TopologyConnectionsCount = 0;
    m_wdmTunerTopology.TopologyConnections = NULL;
}



/*^^*
 *      SetWDMTunerKSProperties()
 * Purpose  : Sets the KSProperty structures array
 *              Called during CWDMTuner class construction time.
 *
 * Inputs   : none
 *
 * Outputs  : none
 * Author   : IKLEBANOV
 *^^*/
void CATIWDMTuner::SetWDMTunerKSProperties( void)
{

    DEFINE_KSPROPERTY_TABLE( wdmTunerProperties)
    {
        DEFINE_KSPROPERTY_ITEM                              
        (
            KSPROPERTY_TUNER_CAPS,                          // 1
            TRUE,                                           // GetSupported or Handler
            sizeof(KSPROPERTY_TUNER_CAPS_S),                // MinProperty
            sizeof(KSPROPERTY_TUNER_CAPS_S),                // MinData
            FALSE,                                          // SetSupported or Handler
            NULL,                                           // Values
            0,                                              // RelationsCount
            NULL,                                           // Relations
            NULL,                                           // SupportHandler
            0                                               // SerializedSize
        ),
        DEFINE_KSPROPERTY_ITEM                              
        (
            KSPROPERTY_TUNER_MODE_CAPS,                     // 2
            TRUE,                                           // GetSupported or Handler
            sizeof(KSPROPERTY_TUNER_MODE_CAPS_S),           // MinProperty
            sizeof(KSPROPERTY_TUNER_MODE_CAPS_S),           // MinData
            FALSE,                                          // SetSupported or Handler
            NULL,                                           // Values
            0,                                              // RelationsCount
            NULL,                                           // Relations
            NULL,                                           // SupportHandler
            0                                               // SerializedSize
        ),
        DEFINE_KSPROPERTY_ITEM                              
        (
            KSPROPERTY_TUNER_MODE,                          // 3
            TRUE,                                           // GetSupported or Handler
            sizeof(KSPROPERTY_TUNER_MODE_S),                // MinProperty
            sizeof(KSPROPERTY_TUNER_MODE_S),                // MinData
            TRUE,                                           // SetSupported or Handler
            NULL,                                           // Values
            0,                                              // RelationsCount
            NULL,                                           // Relations
            NULL,                                           // SupportHandler
            0                                               // SerializedSize
        ),
        DEFINE_KSPROPERTY_ITEM
        (
            KSPROPERTY_TUNER_STANDARD,                      // 4
            TRUE,                                           // GetSupported or Handler
            sizeof(KSPROPERTY_TUNER_STANDARD_S),            // MinProperty
            sizeof(KSPROPERTY_TUNER_STANDARD_S),            // MinData
            TRUE,                                           // SetSupported or Handler
            NULL,                                           // Values
            0,                                              // RelationsCount
            NULL,                                           // Relations
            NULL,                                           // SupportHandler
            sizeof(KSPROPERTY_TUNER_STANDARD_S)         // SerializedSize
        ),
        DEFINE_KSPROPERTY_ITEM
        (
            KSPROPERTY_TUNER_FREQUENCY,                     // 5
            TRUE,                                           // GetSupported or Handler
            sizeof(KSPROPERTY_TUNER_FREQUENCY_S),           // MinProperty
            sizeof(KSPROPERTY_TUNER_FREQUENCY_S),           // MinData
            TRUE,                                           // SetSupported or Handler
            NULL,                                           // Values
            0,                                              // RelationsCount
            NULL,                                           // Relations
            NULL,                                           // SupportHandler
            sizeof(KSPROPERTY_TUNER_FREQUENCY_S)            // SerializedSize
        ),
        DEFINE_KSPROPERTY_ITEM
        (
            KSPROPERTY_TUNER_INPUT,                         // 6
            TRUE,                                           // GetSupported or Handler
            sizeof(KSPROPERTY_TUNER_INPUT_S),               // MinProperty
            sizeof(KSPROPERTY_TUNER_INPUT_S),               // MinData
            TRUE,                                           // SetSupported or Handler
            NULL,                                           // Values
            0,                                              // RelationsCount
            NULL,                                           // Relations
            NULL,                                           // SupportHandler
            sizeof(KSPROPERTY_TUNER_INPUT_S)                // SerializedSize
        ),
        DEFINE_KSPROPERTY_ITEM
        (
            KSPROPERTY_TUNER_STATUS,                        // 6
            TRUE,                                           // GetSupported or Handler
            sizeof(KSPROPERTY_TUNER_STATUS_S),              // MinProperty
            sizeof(KSPROPERTY_TUNER_STATUS_S),              // MinData
            FALSE,                                          // SetSupported or Handler
            NULL,                                           // Values
            0,                                              // RelationsCount
            NULL,                                           // Relations
            NULL,                                           // SupportHandler
            sizeof(KSPROPERTY_TUNER_STATUS_S)               // SerializedSize
        )
    };

    DEFINE_KSPROPERTY_SET_TABLE( wdmTunerPropertySet)
    {
        DEFINE_KSPROPERTY_SET
        (
            &PROPSETID_TUNER,                               // Set
            KSPROPERTIES_TUNER_LAST,                        // PropertiesCount
            m_wdmTunerProperties,                           // PropertyItems
            0,                                              // FastIoCount
            NULL                                            // FastIoTable
        )
    };

    ::RtlCopyMemory( m_wdmTunerProperties,  wdmTunerProperties, sizeof( wdmTunerProperties));
    ::RtlCopyMemory( &m_wdmTunerPropertySet, wdmTunerPropertySet, sizeof( wdmTunerPropertySet));
}