device.cpp

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

        
        resetDigitalFrequency(TRUE);
        
        break;
        
    default:
        break;
    }  
    
}

/////////////////////////////////////////////////////////////////////////////////////////
VOID Device::powerUp()
{
    if(_p_usb)
    {
        _p_usb->InitDevice();
    }
    if(_p_usb_firmware)
    {
        _p_usb_firmware->InitDevice();
    }

    DWORD revID = getRevID();    
    if(revID >=POLARIS_REVID_A0 && getUSBType() == USB_BUS_POWER)
    {
        setPowerMode(_power_mode);
    }
    
    if(_p_colibri)
    {
        _p_colibri->initialize();
    }

    if(revID >=POLARIS_REVID_A0 && getUSBType() == USB_BUS_POWER)
    {
        powerUpModule(_power_mode);
    }
    else
    {
    
        if(_p_DIF)
        {
            _p_DIF->powerUp();
        }
    
        if(_p_flatrion)
        {
            _p_flatrion->powerUp();
        }
    
        if(_p_video_transfer)
        {
            _p_video_transfer->powerUp();
        }
    
        if(_p_decoder)
        {
            _p_decoder->powerUp();  
        }
    
        if(_p_audio)
        {
            _p_audio->powerUp();
        } 
        
        resetDigitalFrequency(TRUE);
  
        startInitializationThread();
    }

    _power_state = PowerDeviceD0;
}

/////////////////////////////////////////////////////////////////////////////////////////
VOID Device::dispatchSetPower(
                              KSDEVICE           *p_ks_dev,
                              IRP                *p_irp,
                              DEVICE_POWER_STATE  to,
                              DEVICE_POWER_STATE  from)
{
    if(to == from)
    {
        return;
    }

    Device* p_device = (Device*)p_ks_dev->Context;

    if( (to == PowerDeviceD3) || ( to == PowerDeviceD2) ) // low power state
    {
        p_device->_power_state = to;

        p_device->setTunerMode(TUNER_MODE_ANALOG);

        p_device->powerDown();

    }
    else if(to == PowerDeviceD0) // Fully working state
    {
        DbgLogInfo(("Device:dispatchSetPower - Switching to High power state\n"));

        KeClearEvent(&p_device->_hw_init_event);

        p_device->powerUp();
    }

}
////////////////////////////////////////////////////////////////////////
//To check if configuration to be changed according to the pin input type
//If yes, then running streams need to be stopped firstly in PreCrossbarChange(). 
//Then configuration will be re-selected in setCrossbarInputPin()
//Finally re-start those running streams in PostCrossbarChange().
BOOLEAN  Device::IsConfigToBeChanged(DWORD pin_input_type)
{
    BYTE config_num=0;
    PPCB_CONFIG pcb_config;
    pcb_config = _p_current_config->getCurrentPcb();
    if(pcb_config==NULL)
    {
        return FALSE;
    }
    
    switch(pin_input_type)
    {
        //Tuner in
        case VIDEO_INPUT_DIF_TUNER:
        case VIDEO_INPUT_TUNER:
        case VIDEO_INPUT_TUNER_YC:
        {
            config_num=pcb_config->dif_index;
            
            break;
        }        
        //external in
        case VIDEO_INPUT_SVIDEO:
        case VIDEO_INPUT_COMPOSITE: 
        case VIDEO_INPUT_COMPOSITE_YC: 
        case VIDEO_INPUT_COMPONENT:
        {
            config_num=pcb_config->external_index;           
           
            break;
        } 
        case VIDEO_INPUT_BDA:
        {
            config_num=pcb_config->digital_index;
            
            break;
        }
        default:
        {
            //For other input such as audio, just return FALSE
            return FALSE;
            
            break;
        }
            
    }

    return (config_num!=_current_config_num)?TRUE:FALSE;

}
//To stop pins before the crossbar change
VOID Device::PreCrossbarChange(DWORD pin_input_type)
{
    BasePin *p_pin=NULL;
    IDataTransfer *p_data_transfer=NULL;

    PIN_TYPES pin_type;
    
    if(isRunning() && IsConfigToBeChanged(pin_input_type))
    {
        for(int i=0;i<PIN_TYPE_MAX_NUM;i++)            
        {
            lockDeviceState();

            p_pin=_p_pins_with_resources[i];
            if(p_pin)
            {
                pin_type=p_pin->getPinType();
                p_data_transfer=NULL;
                switch(pin_type)
                {
                case PIN_TYPE_VIDEO:
                    if(IsPinStreaming(PIN_TYPE_VIDEO))                        
                    {
                        p_data_transfer = _p_video_transfer;
                        _config_changed |=DEVICE_STREAM_VIDEO;
                    }                    
                    break;
                case PIN_TYPE_AUDIO:
                    if(IsPinStreaming(PIN_TYPE_AUDIO))
                    {
                        p_data_transfer = _p_audio_transfer;
                        _config_changed |=DEVICE_STREAM_AUDIO;
                    }
                    break;
                case PIN_TYPE_VBI:
                    if(IsPinStreaming(PIN_TYPE_VBI))                        
                    {
                        p_data_transfer = _p_vbi_transfer;
                        _config_changed |=DEVICE_STREAM_VBI;
                    }
                    break;
                case PIN_TYPE_TS_MPEG:
                    if(IsPinStreaming(PIN_TYPE_TS_MPEG))                        
                    {
                        p_data_transfer = _p_ts1_transfer;
                        _config_changed |=DEVICE_STREAM_TS_MPEG;
                    }
                    break;
                case PIN_TYPE_SLICED_CC:
                    if(IsPinStreaming(PIN_TYPE_SLICED_CC))                        
                    {
                        p_data_transfer = _p_sliced_cc_transfer;
                        _config_changed |=DEVICE_STREAM_SLICED_CC;
                    }
                    break;
                case PIN_TYPE_TS2_MPEG:
                    if(IsPinStreaming(PIN_TYPE_TS2_MPEG))                        
                    {
                        p_data_transfer = _p_ts2_transfer;    
                        _config_changed |=DEVICE_STREAM_TS2_MPEG;
                    }
                    break;
                }
                if(p_data_transfer!=NULL)             
                {
                    p_data_transfer->releasePin(p_pin);
                    p_data_transfer->stop();
                    p_pin->releaseClones();
                    p_pin->setDiscontinuity();
                }                 

            }

            unlockDeviceState();
        }

    }
}

/////////////////////////////////////////////
//To re-start pins again after crossbar changed
//Note: only re-set alternate setting when configuration has really changed.
VOID Device::PostCrossbarChange()
{
    BasePin *p_pin=NULL;
    IDataTransfer *p_data_transfer=NULL;
    PIN_TYPES pin_type;
    NTSTATUS status=STATUS_UNSUCCESSFUL;
    if(isRunning() && _config_changed)
    {
        for(int i=0;i<MAX_PIN_TYPES;i++)
        {
            lockDeviceState();

            p_pin=_p_pins_with_resources[i];
            if(p_pin)
            {
                pin_type=p_pin->getPinType();
                p_data_transfer=NULL;
                status=STATUS_SUCCESS;                
                switch(pin_type)
                {
                case PIN_TYPE_VIDEO:
                    if(IsPinStreaming(PIN_TYPE_VIDEO))
                    {
                        if(_config_changed & DEVICE_STREAM_VIDEO)
                        {
                            //Only re-set alternate setting when configuration has changed.
                            status=setVideoAlternateSetting(TRUE);                            
                            _config_changed &=~DEVICE_STREAM_VIDEO;
                        }
                        p_data_transfer = _p_video_transfer;
                    }                                        
                    break;
                case PIN_TYPE_AUDIO:
                    if(IsPinStreaming(PIN_TYPE_AUDIO))
                    {
                        if(_config_changed & DEVICE_STREAM_AUDIO)
                        {
                            status=setAudioAlternateSetting(TRUE);                            
                            _config_changed &=~DEVICE_STREAM_AUDIO;
                        }
                        p_data_transfer = _p_audio_transfer;
                    }                    
                    break;
                case PIN_TYPE_VBI:
                    if(IsPinStreaming(PIN_TYPE_VBI))
                    {
                        if(_config_changed & DEVICE_STREAM_VBI)
                        {
                            status=setVANCAlternateSetting(TRUE);                            
                            _config_changed &=~DEVICE_STREAM_VBI;
                        }
                        p_data_transfer = _p_vbi_transfer;
                    }                    
                    break;
                case PIN_TYPE_TS_MPEG:
                    if(IsPinStreaming(PIN_TYPE_TS_MPEG))
                    {
                        if(_config_changed & DEVICE_STREAM_TS_MPEG)
                        {
                            status=setTS1AlternateSetting(TRUE);                            
                            _config_changed &=~DEVICE_STREAM_TS_MPEG;
                        }
                        p_data_transfer = _p_ts1_transfer;
                    }                    
                    break;
                case PIN_TYPE_SLICED_CC:
                    if(IsPinStreaming(PIN_TYPE_SLICED_CC))
                    {
                        if(_config_changed & DEVICE_STREAM_SLICED_CC)
                        {
                            status=setHANCAlternateSetting(TRUE);                            
                            _config_changed &=~DEVICE_STREAM_SLICED_CC;
                        }
                        p_data_transfer = _p_sliced_cc_transfer;
                    } 
                    break;
                case PIN_TYPE_TS2_MPEG:
                    if(IsPinStreaming(PIN_TYPE_TS2_MPEG))
                    {
                        if(_config_changed & DEVICE_STREAM_TS2_MPEG)
                        {
                            status=setTS2AlternateSetting(TRUE);                            
                            _config_changed &=~DEVICE_STREAM_TS2_MPEG;
                        }
                        p_data_transfer = _p_ts2_transfer;
                    }                    
                    break;
                }
                if(p_data_transfer!=NULL)                    
                {
                    p_data_transfer->setPin(p_pin);
                    p_data_transfer->start();
                }                 
                
            }

            unlockDeviceState();
        }
        
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
VOID Device::setCrossbarInputPin(
                                 DWORD pin_input_type, 
                                 DWORD input_mux,
                                 DWORD input_mux2,
                                 DWORD gpio_mask,
                                 DWORD gpio_setting)
{
    DbgLogInfo(("Enter Device::setCrossbarInputPin(PinInputType=%d,mux=%d)\n ",pin_input_type,input_mux));

    if(_bSurpriseRemoval)
    {
        DbgLogError(("Device::setCrossbarInputPin : Device surprise removed!\n"));
        return;
    }
    POLARIS_REV_ID rev_id = (POLARIS_REV_ID)getRevID();

    PreCrossbarChange(pin_input_type);
    PPCB_CONFIG pcb_config;
    pcb_config = _p_current_config->getCurrentPcb();
    if(pcb_config==NULL)
    {
        return;
    }
    if(NOT_DECIDE_YET==pcb_config->speed)
    {
        return;
    }

    switch(pin_input_type)
    {
        case VIDEO_INPUT_DIF_TUNER:
        case VIDEO_INPUT_TUNER:
        case VIDEO_INPUT_TUNER_YC:
        {  
                            
            if(rev_id == POLARIS_REVID_T0)
            {
                setUSBConfiguration(pin_input_type);
            }
            
            // AGC mux for Demod/Analog
            // 0 - Demod,  1 - Analog    
            PolarisGPIOPin* pGPIOpin = getGPIOPin();
            if( pGPIOpin )
            {
                // Switch to Analog         
                pGPIOpin->SetGpioPinLogicValue(pGPIOpin->getAGCAnalogDigitalMuxSelectGPIOBit(), 1);
            }   

            if(rev_id >=POLARIS_REVID_A0)
            {
                if((pcb_config->type == USB_BUS_POWER) && (getPowerMode() != POLARIS_AVMODE_ANALOGT_TV)) //bus power 
                {
                    setPowerMode(POLARIS_AVMODE_ANALOGT_TV);  //tuner

                    if(_p_tuner_properties)
                    {
                        _p_tuner_properties->powerUp();
                    }
                }
            } 
            
            _p_decoder->setVideoInput(pin_input_type, input_mux);  //need check           
           
            break; 
        }
        case VIDEO_INPUT_SVIDEO:
        case VIDEO_INPUT_COMPOSITE: 
        case VIDEO_INPUT_COMPOSITE_YC: 
        case VIDEO_INPUT_COMPONENT:
        {
                           
            if(rev_id == POLARIS_REVID_T0)
            {
                setUSBConfiguration(pin_input_type);
            }