bdatunerfilter.cpp

完整的基于Conxant平台的USB电视棒的WIN驱动程序。

        _p_tuner->bdaTuner_setMode(modeRunning);

        _p_device->releaseTunerMutex();
    
        _tuner_is_initialized = TRUE;

        if (_p_device->getTunerMode() == TUNER_MODE_ANALOG)
        {
            _p_device->resetAnalogTuner();
            _p_device->setTunerMode(TUNER_MODE_DIGITAL);
        }
    }

    DbgLog(("BdaTunerFilter::commitChanges, setting tuner frequency to %ld\n", frequency)); 

    // AGC mux for Demod/Analog
    // 0 - Demod,  1 - Analog 
    PolarisGPIOPin* pGPIOpin = _p_device->getGPIOPin();    
    if(pGPIOpin)
    {   
		// Switch to Demod
        pGPIOpin->SetGpioPinLogicValue(pGPIOpin->getAGCAnalogDigitalMuxSelectGPIOBit(), 0);
    }
    
    if (_p_device->getTunerMode() == TUNER_MODE_ANALOG)
    {
        // now comes the tricky part. Remember that we have two distinct
        // Xceive library - one for Analog and one for Digital -  to sync them up
        // Whenever we create the Digital filter (MS creates it whenever we open a 
        // DVBT graph and destroys it when we close it), make sure that the Analog
        // part has been reset so that the next time the analog graph is created 
        // the firmware is reloaded.
        //Get the TunerProperties object from the filter
        _p_device->resetAnalogTuner();

        _p_device->acquireTunerMutex();

        //now force loading of the DVBT firmware
        _p_tuner->bdaTuner_setMode(modeStandby); // Put
        _p_tuner->bdaTuner_setMode(modeRunning);
    
        _p_device->releaseTunerMutex();
    }
    _p_device->setTunerMode(TUNER_MODE_DIGITAL);

    _p_device->acquireTunerMutex();

    //Set the frequency in the tuner.
    _p_tuner->bdaTuner_setFrequency(frequency, _current_freq.channel_bandwidth);

    _p_device->releaseTunerMutex();

    // set the flag to initialized
    _freq_initialized = TRUE;

    return TRUE;    
}

/////////////////////////////////////////////////////////////////////////////////////////
//static_BdaGetChangeState
//
// Returns rather or not we have any changes pending.
//
NTSTATUS BdaTunerFilter::static_BdaGetChangeState(PIRP        p_irp,
                                                  PKSMETHOD   p_ks_method,
                                                  PULONG      p_change_state)
{
    DbgLogInfo((__FUNCTION__));
    //Fail if the variable to return the state is NULL
    if(!p_change_state)
    {
        p_irp->IoStatus.Information = sizeof(ULONG);
        return STATUS_MORE_ENTRIES;
    }   


    //Get our filter
    PKSFILTER p_ks_filter = KsGetFilterFromIrp(p_irp);
    BdaTunerFilter* p_filter = (BdaTunerFilter*)p_ks_filter->Context;

    //Get the change state from the BDA class driver
    BDA_CHANGE_STATE bda_change_state;
    NTSTATUS status = BdaGetChangeState(p_irp, &bda_change_state);

    if(NT_SUCCESS(status))
    {
        //If our filter has pending changes, make sure we return that there are pending 
        // changes.
        if(p_filter->_bda_change_state == BDA_CHANGES_PENDING)
        {
            bda_change_state = BDA_CHANGES_PENDING;
        }

        *p_change_state = bda_change_state;
    }

    return status;
}

/////////////////////////////////////////////////////////////////////////////////////////
//The following three functions set the pending frequency parameters.  They are called
// by the BDA property sets.  The pending frequency will not apply until the user calls
// commitChanges on the filter.
//

/////////////////////////////////////////////////////////////////////////////////////////
VOID BdaTunerFilter::setPendingFrequency(ULONG frequency)
{
    if ( _current_freq.frequency != frequency )
    {
        _bda_change_state = BDA_CHANGES_PENDING;
        _pending_freq.frequency = frequency;
    }
    DbgLogInfo(("BdaTunerFilter::setPendingFrequency(frequency=%d)\n",frequency));
}

/////////////////////////////////////////////////////////////////////////////////////////
VOID BdaTunerFilter::setPendingFrequencyMultiplier(ULONG frequency_multiplier)
{
    if ( _current_freq.frequency_multiplier != frequency_multiplier )
    {
        _bda_change_state = BDA_CHANGES_PENDING;
        _pending_freq.frequency_multiplier = frequency_multiplier;
    }
    DbgLogInfo(("BdaTunerFilter::setPendingFrequencyMultiplier(frequency_multiplier=%d)\n",frequency_multiplier));
}

/////////////////////////////////////////////////////////////////////////////////////////
VOID BdaTunerFilter::setPendingChannelBandwidth(ULONG channel_bandwidth)
{
    if ( _current_freq.channel_bandwidth != channel_bandwidth )
    {
        _bda_change_state = BDA_CHANGES_PENDING;
        _pending_freq.channel_bandwidth = channel_bandwidth;
    }
    DbgLogInfo(("BdaTunerFilter::setPendingChannelBandwidth(bandwith=%d)\n",channel_bandwidth));
}

/////////////////////////////////////////////////////////////////////////////////////////
//The following two functions retreive the status from the tuner.

/////////////////////////////////////////////////////////////////////////////////////////
BOOL BdaTunerFilter::isTunerLocked()
{
    if(!_freq_initialized)
    {
        DbgLogInfo(("BdaTunerFilter::getSignalStrength: frequency not set\n"));
        return FALSE;
    }
    return _p_tuner->bdaTuner_isSignalLocked();
}

/////////////////////////////////////////////////////////////////////////////////////////
DWORD BdaTunerFilter::getSignalStrength()
{
    if(!_freq_initialized)
    {
        DbgLogInfo(("BdaTunerFilter::getSignalStrength: frequency not set\n"));
        return 0;
    }
    return _p_tuner->bdaTuner_getSignalStrength();
}

/////////////////////////////////////////////////////////////////////////////////////////
void BdaTunerFilter::resetFrequency()
{
    //Initialize the current and pending frequency settings.
    _current_freq.frequency = 0;
    _current_freq.frequency_multiplier = 1;
    _current_freq.channel_bandwidth = 0;

    _pending_freq.frequency = 0;
    _pending_freq.frequency_multiplier = 1;
    _pending_freq.channel_bandwidth = 0;

     _freq_initialized = FALSE;

    _bda_change_state = BDA_CHANGES_COMPLETE;
}

/////////////////////////////////////////////////////////////////////////////////////////
DWORD BdaTunerFilter::getDemodType()
{
    RegistryAccess registry(_p_device->getPdo());

    //Get the BDA demod/Tuner type
    DWORD bda_demod_tuner_type = TUNER_DEMOD_TYPE_PHILIPS_TUV1236D;
    registry.readDword("BDA_Demod_Tuner_Type", &bda_demod_tuner_type);

    switch (bda_demod_tuner_type)
    {
        case  TUNER_DEMOD_TYPE_PHILIPS_TUV1236D:
            return TUNER_DEMOD_TYPE_PHILIPS_TUV1236D;
        case  TUNER_DEMOD_TYPE_ZARLINK_XCEIVE:
            return TUNER_DEMOD_TYPE_ZARLINK_XCEIVE;
        case TUNER_DEMOD_TYPE_ALTAIR_SIDEWINDER:
            return TUNER_DEMOD_TYPE_ALTAIR_SIDEWINDER;
        default :
            return TUNER_DEMOD_TYPE_ALTAIR_SIDEWINDER;
    }
}


/////////////////////////////////////////////////////////////////////////////////////////
DWORD BdaTunerFilter::getDemodSignalQuality()
{
    if(_p_tuner)
    {
        if(!_freq_initialized)
        {
            DbgLogInfo(("BdaTunerFilter::getSignalStrength: frequency not set\n"));
            return 0;
        }
        return _p_tuner->bdaTuner_getSignalQuality();
    }
    else
    {
        return 0;
    }
}

/////////////////////////////////////////////////////////////////////////////////////////
//Intersect handler for the BDA filter's input pin
//
NTSTATUS BdaInPin_IntersectRange(PVOID        p_context,
                                 PIRP         p_irp,
                                 PKSP_PIN     p_pin,
                                 PKSDATARANGE p_ks_data_range,
                                 PKSDATARANGE p_ks_matching_data_range,
                                 ULONG        data_buffer_size,
                                 PVOID        p_data,
                                 PULONG       p_data_size)
{
    if(data_buffer_size < sizeof(KS_DATARANGE_BDA_ANTENNA))
    {
        *p_data_size = sizeof( KS_DATARANGE_BDA_ANTENNA );
        return STATUS_BUFFER_OVERFLOW;
    }
    else if(p_ks_data_range->FormatSize < sizeof(KS_DATARANGE_BDA_ANTENNA)) 
    {
        return STATUS_NO_MATCH;
    }
    else 
    {
        if(data_buffer_size == sizeof(KS_DATARANGE_BDA_ANTENNA))
        {
            *p_data_size = sizeof( KS_DATARANGE_BDA_ANTENNA );
            RtlCopyMemory(p_data, (PVOID)p_ks_data_range, sizeof(KS_DATARANGE_BDA_ANTENNA));
        }
        else
        {
            return STATUS_NO_MATCH;
        }

        return STATUS_SUCCESS;
    }
}


/////////////////////////////////////////////////////////////////////////////////////////
//Intersect handler for the BDA filter's output pin
//

NTSTATUS BdaTransportPin_IntersectRange(PVOID        p_context,
                                        PIRP         p_irp,
                                        PKSP_PIN     p_pin,
                                        PKSDATARANGE p_ks_data_range,
                                        PKSDATARANGE p_ks_matching_data_range,
                                        ULONG        data_buffer_size,
                                        PVOID        p_data,
                                        PULONG       p_data_size)
{
    if( data_buffer_size < sizeof(KS_DATARANGE_BDA_TRANSPORT))
    {
        *p_data_size = sizeof( KS_DATARANGE_BDA_TRANSPORT );

        return STATUS_BUFFER_OVERFLOW;
    }
    else if (p_ks_data_range->FormatSize < sizeof(KS_DATARANGE_BDA_TRANSPORT)) 
    {
        return STATUS_NO_MATCH;
    }
    else
    {
        if(data_buffer_size == sizeof(KS_DATARANGE_BDA_TRANSPORT))
        {
            *p_data_size = sizeof( KS_DATARANGE_BDA_TRANSPORT );
            RtlCopyMemory(p_data, (PVOID)p_ks_data_range, sizeof(KS_DATARANGE_BDA_TRANSPORT));
        }
        else
        {
            return STATUS_NO_MATCH;
        }

        return STATUS_SUCCESS;
    }
}