device.cpp

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

    _p_audio=NULL;
    
    delete _p_DIF;
    _p_DIF=NULL;
    
    delete _p_sync_registers;
    _p_sync_registers=NULL;
    
    delete _p_colibri;
    _p_colibri=NULL;
    
    delete _p_flatrion;
    _p_flatrion=NULL;
    
    delete _p_DigitalI2C;
    _p_DigitalI2C=NULL;
    
    delete _p_AnalogI2C;
    _p_AnalogI2C=NULL;
    
    delete _p_i2c_0;
    _p_i2c_0=NULL;
    
    delete _p_i2c_1;
    _p_i2c_1=NULL;
    
    delete _p_i2c_2;
    _p_i2c_2=NULL;
    
    delete _p_GPIOPin;
    _p_GPIOPin=NULL;
    
    if(_p_usb_i2c_interface)
    {
        INT refCnt = _p_usb_i2c_interface->release();
        if( refCnt != 0 )
        {
            DbgLogError(("Device: unInit: usb i2c interfaces not released completley\n"));           
        }           
        _p_usb_i2c_interface = NULL;
    }
    
    if(_p_usb_firmware)
    {
        _p_usb_firmware->Release();
        delete _p_usb_firmware;
        _p_usb_firmware=NULL;
    }
    
    if(_p_usb)
    {
        _p_usb->Release();
        delete _p_usb;
        _p_usb=NULL;
    }

    _enable_bda = FALSE;
}

/////////////////////////////////////////////////////////////////////////////////////////
NTSTATUS Device::initObjects()
{
    DbgLogInfo(("Device::initObjects\n"));
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////
    POLARIS_REV_ID rev_id = (POLARIS_REV_ID)_p_usb->getRevID();   
    RegistryAccess registry(_p_ks_dev->PhysicalDeviceObject);

    DWORD demod_reset_gpio_bit  = 0xff;
    registry.readDword( "demod_reset_gpio_bit",  &demod_reset_gpio_bit );

    // Get the IF Select GPIO Pin info
    DWORD if_select_gpio_bit  = 0xff;
    registry.readDword( "if_select_gpio_bit",  &if_select_gpio_bit );

    // Get the Siedewinder tuner I2C enable GPIO bit
    DWORD tuner_i2c_enable_gpio_bit  = 0xff;
    registry.readDword( "tuner_i2c_enable_gpio_bit",  &tuner_i2c_enable_gpio_bit );

    ///////////////////////////////////////////////////////////////////////////////////////////////////////
    _p_GPIOPin = new PolarisGPIOPin(_p_usb_firmware,
        (BYTE) demod_reset_gpio_bit,
        (BYTE) if_select_gpio_bit,
        (BYTE) tuner_i2c_enable_gpio_bit);
    if(!_p_GPIOPin)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    DWORD agc_gpio_bit = 0xFF;
    if( registry.readDword( "AGC_Analog_Digitial_Select_Gpio_Bit", &agc_gpio_bit ) == STATUS_SUCCESS )
    {
        DbgLog(( " AGC_Analog_Digitial_Select_Gpio_Bit = %d\n", agc_gpio_bit));
        _p_GPIOPin->setAGCAnalogDigitalMuxSelectGPIOBit( (BYTE) agc_gpio_bit);
    }

    // get Usb I2C interface 
    _p_usb_i2c_interface = new UsbI2cInterface(_p_usb_firmware, _p_usb, this);

    if(_p_usb_i2c_interface)
    {        
        // Allocate I2C interface for Analog Path
        if(!(_p_i2c_0 = new DriverI2C(_p_usb_i2c_interface, 0)))  //channal 0
        {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        
        if(!(_p_i2c_1 = new DriverI2C(_p_usb_i2c_interface, 1))) //channel 1
        {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        
        if(!(_p_i2c_2 = new DriverI2C(_p_usb_i2c_interface, 2))) //channel 2
        {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        

        // Allocate I2C interface for Demodulator
        if(!(_p_DigitalI2C = new ExtI2CInterface(_p_i2c_1,rev_id))) //channel 1
        {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        
        
        // Allocate I2C interface for Tuner
        if(!(_p_AnalogI2C = new ExtI2CInterface(_p_i2c_2,rev_id))) // channel 2
        {
            return STATUS_INSUFFICIENT_RESOURCES;
        }       
        
    }
    else
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    //////////////////////////////////////////////////////////////////
    DWORD video_standard = KS_AnalogVideo_NTSC_M;
    registry.readDword("VideoStandard", &video_standard);
    DbgLogInfo(("VideoStandard = 0x%x\n", video_standard));    

    registry.readDword("DisableVBI", &_disable_VBI);

    _disable_audio_out_pin = FALSE;
    registry.readDword("DisableAudioOutPin", &_disable_audio_out_pin);
    ////////////////////////////////////////////////////////////////
    _enable_hanc_audio = FALSE;
    registry.readDword("EnableHANCAudioOut", &_enable_hanc_audio);
    ////////////////////////////////////////////////////////////////

    // if it doesn't have audio out pin, the vbi pin is the next element
    // in the Capture Filter Descriptor array.
    if ( _disable_audio_out_pin )
    {
        _vbi_pin_index = CAPTURE_FILTER_VIDEO_OUT + 1;
    }
 
    _p_sync_registers = new SyncRegIo(_p_i2c_0);
    if(!_p_sync_registers)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    
    //Enable automatic AGC control by driver
    if (!(_p_DIF = new DirectIF(_p_ks_dev->PhysicalDeviceObject,this,_p_sync_registers,TRUE)))
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    //////////////////////////////////////////////////////////////////
    /// initialize Colibri for HH thresh used
    _p_colibri = new Colibri(_p_i2c_0,_p_DIF);
    if(!_p_colibri)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    _p_colibri->initialize();

    ///initialize flatrion for HH merlin used
    _p_flatrion = new Flatrion(_p_i2c_0);
    if(!_p_flatrion)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    _p_flatrion->initialize();

    if(!( _p_decoder = new Thresher(this, video_standard,  _p_sync_registers, _p_DIF, _p_colibri)))
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    
    if(!(_p_audio = new Merlin(this, _p_ks_dev->PhysicalDeviceObject,_p_sync_registers, _p_DIF)))
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    

    DWORD reg_val = CP_METHOD_USE_DEFAULT;
    registry.readDword("CpMethod", &reg_val);
    COPY_PROTECT_METHOD copy_protect_method = static_cast<COPY_PROTECT_METHOD>(reg_val);

    _p_copy_protect = new CxCopyProtectProp(_p_decoder, copy_protect_method);
    if(!_p_copy_protect)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    //////////////////////////////////////////////////////////////////////////////////////////////////////
    ////data transfer class
    //////////////////////////////////////////////////////////////////////////////////////////////////////
    PPCB_CONFIG pcb_config;
    pcb_config = _p_current_config->getCurrentPcb();
    if(pcb_config==NULL)
    {
        return STATUS_UNSUCCESSFUL;
    }

    if(pcb_config->mode&(MOD_ANALOG|MOD_DIF|MOD_EXTERNAL))
    {
        _p_video_transfer = IDataTransfer::allocate(
            _p_usb, 
            _p_usb_firmware, 
            _p_ks_dev->PhysicalDeviceObject,
            _p_current_config,
            Raw_Video);
        DbgLogInfo(("create video transfer class\n"));

        if(_enable_hanc_audio)
        {
            _p_audio_transfer = IDataTransfer::allocate(
                _p_usb, 
                _p_usb_firmware, 
                _p_ks_dev->PhysicalDeviceObject,
                _p_current_config,
                (Audio|0x80));  // highest bit set means we need use HANC to transfer AUDIO data
        }
        else
        {
            _p_audio_transfer = IDataTransfer::allocate(
                _p_usb, 
                _p_usb_firmware, 
                _p_ks_dev->PhysicalDeviceObject,
                _p_current_config,
                Audio);
        }
        DbgLogInfo(("create audio transfer class\n"));

        if( HIGH_SPEED==_usb_speed )  //high_speed
        {
            _p_vbi_transfer=IDataTransfer::allocate(
                _p_usb, 
                _p_usb_firmware, 
                _p_ks_dev->PhysicalDeviceObject,
                _p_current_config,
                Vbi);
            DbgLogInfo(("create vbi transfer class\n"));

            _p_sliced_cc_transfer=IDataTransfer::allocate(
                _p_usb, 
                _p_usb_firmware,
                _p_ks_dev->PhysicalDeviceObject,
                _p_current_config,
                Sliced_cc);
            DbgLogInfo(("create sliced_cc transfer class\n"));

            if( !_p_vbi_transfer || !_p_sliced_cc_transfer )
            {
                return STATUS_INSUFFICIENT_RESOURCES;
            }
        }

        if(!_p_video_transfer || !_p_audio_transfer) 
        {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
    }

    
    if(pcb_config->mode & MOD_DIGITAL) //ts exist
    {
        if( pcb_config->ts1_source!=0xff && pcb_config->index != 5 ) //ts1 exist
        {
            _p_ts1_transfer=IDataTransfer::allocate(
                _p_usb, 
                _p_usb_firmware, 
                _p_ks_dev->PhysicalDeviceObject,
                _p_current_config,
                TS1);
            DbgLogInfo(("create ts1 transfer class\n"));

            if(!_p_ts1_transfer)
            {
                return STATUS_INSUFFICIENT_RESOURCES;
            }
        }

        if(pcb_config->ts2_source!=0xff) //ts2 exist
        {
            _p_ts2_transfer=IDataTransfer::allocate(
                _p_usb, 
                _p_usb_firmware, 
                _p_ks_dev->PhysicalDeviceObject,
                _p_current_config,
                TS2);
            DbgLogInfo(("create ts2 transfer class\n"));

            if(!_p_ts2_transfer)
            {
                return STATUS_INSUFFICIENT_RESOURCES;
            }
        }
    }

    return STATUS_SUCCESS;
}

/////////////////////////////////////////////////////////////////////////////////////////
VOID Device::updatePinDataRanges()
{
    BOOLEAN use_mpeg1 = FALSE;

    BOOLEAN is_ntsc = _p_decoder->getVideoMode() == VIDEO_MODE_NTSC;
    BYTE usb_speed=getUSBSpeed();

    BOOLEAN is_fullspeed = (usb_speed==FULL_SPEED)?TRUE:FALSE;

    KsAcquireDevice(_p_ks_dev);

    //Get all capture filters that exist and change the available formats on the
    // capture and 656 output pins
    PKSFILTER p_filter = KsFilterFactoryGetFirstChildFilter(_p_capture_filter_factory);
    while(p_filter)
    {
        CaptureFilter* p_capture_filter = (CaptureFilter*)p_filter->Context;
        p_capture_filter->setVideoOutPinCategories(CAPTURE_FILTER_VIDEO_OUT, is_ntsc, is_fullspeed, use_mpeg1);

        if(!is_fullspeed)
        {
            p_capture_filter->setVideoOutPinCategories(_vbi_pin_index, is_ntsc, is_fullspeed);
        }

        p_filter = KsFilterGetNextSiblingFilter(p_filter);
    }

    KsReleaseDevice(_p_ks_dev);
}

/////////////////////////////////////////////////////////////////////////////////////////
BOOLEAN Device::acquireResources(BasePin* p_pin)
{
    BOOLEAN resources_acquired = FALSE;
    BOOL test_flag = FALSE;

    if( (_power_state == PowerDeviceD3) || (_power_state == PowerDeviceD2) )
    {
        DbgLogInfo(("Device::acquireResources : Device in PowerDeviceD3/D2 state, setting wait up Event\n"));

        NTSTATUS status = checkHwInitialization();

        if (!NT_SUCCESS(status))
        {
            DbgLogInfo(("Device::start : Power up did not happen !!\n"));
            return FALSE;
        }        
    }

    PIN_TYPES pin_type = p_pin->getPinType();
    DbgLogInfo(("Device::acquireResources\n"));    

    lockDeviceState();
    
    if(Is_Analog_TS_Supported())
    {
        //Both digital and analog supported simultaneously
        if(!_p_pins_with_resources[pin_type])            
        {
            _p_pins_with_resources[pin_type]=p_pin;
            resources_acquired = TRUE;
        }
        else if(_p_pins_with_resources[pin_type]==p_pin)
        {
            resources_acquired = TRUE;            
        }        
    }
    else
    {
        if( (pin_type == PIN_TYPE_BDA_ANTENNA) || (pin_type == PIN_TYPE_TS_MPEG) )
            
        {
            // check if resource acquired on Analog side
            
            // check for the pins that have acquired resources
            if(_p_pins_with_resources[PIN_TYPE_VIDEO] ||
                _p_pins_with_resources[PIN_TYPE_AUDIO] ||
                _p_pins_with_resources[PIN_TYPE_VBI] ||
                _p_pins_with_resources[PIN_TYPE_SLICED_CC])
            {
                // resources acquired on Analog side
                test_flag = TRUE;
            }
        }
        else
        {
            // check if resource acquired on Digital side
            if(_p_pins_with_resources[PIN_TYPE_BDA_ANTENNA] || _p_pins_with_resources[PIN_TYPE_TS_MPEG] )
            {
                // resources acquired on Digital side
                test_flag = TRUE;
            }    
        }
        
        ////change this with multi_transfer used
        if(!test_flag)
        {
            //Let the pin acquire the resources if they are available.
            if(!_p_pins_with_resources[pin_type])
            {
                _p_pins_with_resources[pin_type]  = p_pin;
                resources_acquired = TRUE;
            }
            //If this pin already has the resources reserved, return TRUE
            else if(_p_pi