bdatunerfilter.cpp

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

        }
        pPinDescriptor->Mediums = pPinMediums;
    }
    (*ppFilterDescriptor)->PinDescriptors = pPinDescriptorsEx;

    return ntStatus;
}
/////////////////////////////////////////////////////////////////////////////////////////
NTSTATUS BdaTunerFilter::static_CreateFilterFactory(KSDEVICE* p_ks_device, 
                                                    DWORD medium_id,
                                                    DWORD bda_demod_tuner_type,
                                                    PVOID *   pp_filter_template)
{

    PKSFILTERFACTORY p_filter_factory = NULL;
    NTSTATUS ntStatus = STATUS_SUCCESS;
    // Newly allocated filter descriptor
    KSFILTER_DESCRIPTOR* pNewFilterDescriptor = NULL;


    KSFILTER_DESCRIPTOR* p_filter_descriptor = &g_dvbt_bda_filter_descriptor;
    BDA_FILTER_TEMPLATE* p_filter_template = &g_dvbt_bda_filter_template;


    switch (bda_demod_tuner_type)
    {
        case TUNER_DEMOD_TYPE_ZARLINK_XCEIVE:
        case TUNER_DEMOD_TYPE_ALTAIR_SIDEWINDER:
        {
            //We need to use the DVB-T filter descriptor and template
            p_filter_descriptor = &g_dvbt_bda_filter_descriptor;
            p_filter_template = &g_dvbt_bda_filter_template;
            break;
        }
        case TUNER_DEMOD_TYPE_GEMINI3_SIDEWINDER:
        {
            //We need to use the ATSC filter
            p_filter_descriptor = &g_atsc_bda_filter_descriptor;
            p_filter_template = &g_atsc_bda_filter_template;
            break;
        }
        default :
        {
            p_filter_descriptor = &g_dvbt_bda_filter_descriptor;
            p_filter_template = &g_dvbt_bda_filter_template;
            break;
        }
    }

    //Set the medium ID in the filter descriptor (Pin 1 is the output pin)
    setMediumId(p_filter_descriptor, 1, medium_id);

    // Create a new copy of the filter descriptor with the correct medium id
    ntStatus = AllocateFilterDescriptorForMediums(*p_filter_descriptor,
                                                  p_ks_device->Bag,
                                                  medium_id,
                                                  &pNewFilterDescriptor);
    if (!NT_SUCCESS(ntStatus))
    {
        DbgLogError(("BdaTunerFilter:static_CreateFilterFactory: Allocate filter descriptor failed\n"));
        return ntStatus;
    }

    // Allocate dynamic memory for the template since we need to modify the embedded descriptor
    BDA_FILTER_TEMPLATE *pNewBdaTemplateDgtlTunerFilter = NULL;
    pNewBdaTemplateDgtlTunerFilter = (BDA_FILTER_TEMPLATE *) ExAllocatePoolWithTag(
                                            NonPagedPool, sizeof(BDA_FILTER_TEMPLATE), 'txnC');
    if (!pNewBdaTemplateDgtlTunerFilter)
    {
        DbgLogError(("BdaTunerFilter:static_CreateFilterFactory: Insufficient memory for digital tuner template\n"));
        ntStatus = STATUS_NO_MEMORY;
        return ntStatus;
    }

    ntStatus = KsAddItemToObjectBag(p_ks_device->Bag, pNewBdaTemplateDgtlTunerFilter, NULL);
    if (!NT_SUCCESS(ntStatus))
    {
        DbgLogError(("BdaTunerFilter:static_CreateFilterFactory: Failed to add bda template filter to object bag\n"));
        ExFreePool(pNewBdaTemplateDgtlTunerFilter);
        return ntStatus;
    }

    pNewBdaTemplateDgtlTunerFilter->ulcPinPairs = p_filter_template->ulcPinPairs;
    pNewBdaTemplateDgtlTunerFilter->pPinPairs = p_filter_template->pPinPairs;
    pNewBdaTemplateDgtlTunerFilter->pFilterDescriptor = pNewFilterDescriptor;

    // Create filter factory
    ntStatus = BdaCreateFilterFactoryEx( p_ks_device,
                                       pNewFilterDescriptor,
                                       pNewBdaTemplateDgtlTunerFilter,
                                       &p_filter_factory);

    if (!NT_SUCCESS(ntStatus)) 
    {
        DbgLogError(("BdaTunerFilter:static_CreateFilterFactory: Cannot create digital tuner filter factory\n"));
        return ntStatus;
    }

    // Update the registry - FilterData and MediumCache 
    // Explicitly pass filter descriptor because pins are created only at FilterCreate (by BdaInit)
    ntStatus = BdaFilterFactoryUpdateCacheData(p_filter_factory, pNewFilterDescriptor);
    if (!NT_SUCCESS(ntStatus))
    {
        DbgLogError(("BdaTunerFilter:static_CreateFilterFactory: Update cache data failed\n"));
        return ntStatus;
    }

    //Register BDA tuner/demod filter
    ntStatus = static_RegisterFilter(p_ks_device, medium_id);
    if (!NT_SUCCESS(ntStatus))
    {
        DbgLogWarn(("Register BDA filter failed\n"));
    }

    return ntStatus;

}


/////////////////////////////////////////////////////////////////////////////////////////
//BDA changes methods
/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////
//static_BdaStartChanges
//
// This function is called to notify the BDA tuner filter that the user is about to 
// change the settings (tuner frequency) through the node property sets.
//
// The new frequency should not be applied until static_BdaCommitChanges is called.
// 
NTSTATUS BdaTunerFilter::static_BdaStartChanges(
                                                PIRP        p_irp,
                                                PKSMETHOD   p_ks_method,
                                                PVOID       p_ignored)
{
    PKSFILTER p_ks_filter = KsGetFilterFromIrp(p_irp);
    BdaTunerFilter* p_filter = (BdaTunerFilter*)p_ks_filter->Context;

    DbgLogInfo(("BdaTunerFilter::static_BdaStartChanges \n"));
    
    if(p_filter->_p_device->getTunerMode()!= TUNER_MODE_DIGITAL)
    {
        p_filter->InitBdaDevices();
    }

    // reset the frequency if we need to
    if(p_filter->_p_device->getDigitalFrequencyState() )
    {
        DbgLogInfo(("BdaTunerFilter::static_BdaStartChanges - reset Frequency\n"));

        p_filter->_p_device->resetDigitalFrequency(FALSE);

        // reset current state of frequency
        p_filter->resetFrequency();
    }

    NTSTATUS status = BdaStartChanges(p_irp);
    if(NT_SUCCESS(status))
    {
        //Reset any pending frequency changes.
        if(p_filter->_current_freq.frequency)
        {
            p_filter->_pending_freq  = p_filter->_current_freq;
        }
        p_filter->_bda_change_state = BDA_CHANGES_COMPLETE;  
    }

    return status;

}


/////////////////////////////////////////////////////////////////////////////////////////
//static_BdaCheckChanges
//
// We can just pass this through to the BDA library.  
//
NTSTATUS BdaTunerFilter::static_BdaCheckChanges(
                                                PIRP        p_irp,
                                                PKSMETHOD   p_ks_method,
                                                PVOID       p_ignored)
{
    return BdaCheckChanges(p_irp);
}


/////////////////////////////////////////////////////////////////////////////////////////
//static_BdaCommitChanges
//
// Apply any pending changes to the settings.  In our case, pending changes are a new 
// tuner frequency set through the pin property sets.
//
NTSTATUS BdaTunerFilter::static_BdaCommitChanges(
                                                 PIRP        p_irp,
                                                 PKSMETHOD   p_ks_method,
                                                 PVOID       p_ignored)
{
    DbgLogInfo((__FUNCTION__));
    //Get our filter
    PKSFILTER p_ks_filter = KsGetFilterFromIrp(p_irp);
    BdaTunerFilter* p_filter = (BdaTunerFilter*)p_ks_filter->Context;

    // Somehow, we got pending changes while our device is still in D3/sleep mode
    // call the function that delays this function call till bda power up occurs.
    NTSTATUS status = p_filter->_p_device->checkHwInitialization();

    if(status != STATUS_SUCCESS)
    {
        DbgLogError(("BdaTunerFilter: BdaCommitChanges - hardware is still not initialized!\n"));
        return STATUS_UNSUCCESSFUL;      
    }

    //check power up is pending or not
    // reset the frequency if we need to
    if(p_filter->_p_device->getBdaTunerPowerUpState() )
    {
        DbgLogInfo(("BdaTunerFilter::static_BdaCommitChanges - Power up state pending\n"));
        p_filter->_p_device->setBdaTunerPowerUpState(FALSE);

        // bda tuner power up 
        if(p_filter->_p_tuner)
        {
            p_filter->_p_tuner->bdaTuner_powerUp();
        }
    }

    if ( p_filter->_bda_change_state == BDA_CHANGES_COMPLETE &&	p_filter->isTunerLocked())
    {
        DbgLogInfo(("BdaTunerFilter: BdaCommitChanges - BDA changes complete & tuner locked status !!\n"));
        return STATUS_SUCCESS;
    }

    if (p_filter->_p_device->getCurrentGraphMode() != GRAPH_MODE_ANALOG)
    {
        BOOL status = p_filter->commitChanges();   
        if(!status)
        {
            DbgLogError(("BdaTunerFilter: BdaCommitChanges - failed to commit changes\n"));
            return STATUS_UNSUCCESSFUL;
        }
    }

    status = BdaCommitChanges(p_irp);
    if (status != STATUS_SUCCESS)
        DbgLogError(("Failed to Commit Changes !!! Status = %x\n", status));
    return status;
}

/////////////////////////////////////////////////////////////////////////////////////////
//BdaTunerFilter::commitChanges
//
// Commit any changes that were pending.  In general, this is where the tuner gets tuned.
//
// return value : BOOL - TRUE - success
//                     - FALSE - Fail
BOOL BdaTunerFilter::commitChanges()
{
    DbgLogInfo((__FUNCTION__));
    BOOL status = FALSE;
    // First check and see if we are to send this down or not
    if (
        (_current_freq.frequency == _pending_freq.frequency) && 
        (_current_freq.channel_bandwidth == _pending_freq.channel_bandwidth) && 
        (_current_freq.frequency_multiplier == _pending_freq.frequency_multiplier) && 
        (_tuner_is_initialized) && 
        (_p_device->getTunerMode() == TUNER_MODE_DIGITAL) &&
        (isTunerLocked())
       )
    {
        DbgLog(("BdaTunerFilter::commitChanges, tuner already locked to frequency %ld. Returning !!!\n", _current_freq.frequency)); 
        //  Mark the changes as having been made.
        _current_freq  = _pending_freq;
        _bda_change_state = BDA_CHANGES_COMPLETE;
        return TRUE;
    }

    //  Mark the changes as having been made.
    _current_freq  = _pending_freq;
    _bda_change_state = BDA_CHANGES_COMPLETE;

    DWORD frequency = _current_freq.frequency;
    DWORD multiplier = _current_freq.frequency_multiplier;
    
    //If the multiplier is valid, multiply the frequency by it.
    if((multiplier != BDA_FREQUENCY_MULTIPLIER_NOT_SET) &&
       (multiplier != BDA_FREQUENCY_MULTIPLIER_NOT_DEFINED))
    {
        frequency *= multiplier;
    }

    if(!_tuner_is_initialized)
    {
        _p_device->acquireTunerMutex();
    
        _p_tuner->bdaTuner_initialize();

        //now force loading of the DVBT firmware
        _p_tuner->bdaTuner_setMode(modeStandby); // Put