datatransfer.cpp

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

                    fail_counter = 0;
                    sendBuffer(p_buffer_entry);
                    p_buffer_entry = NULL;
                 
                    //Abort any outstanding requests if Pipe is broken
                    if(_p_usb->UsbGetStatusPipe(_pipe, _interface) != STATUS_SUCCESS)
                    {
                        KdPrint(("Data Transfer : parseBufferThread : Abort all ISO requests pending\n"));
                        status=_p_usb->UsbAbortPipe(_pipe, _interface);
                        if (!NT_SUCCESS(status))
	                    {
                            bUnrecoverableError = TRUE;
                        }
                    }
                    break;
                }
            }
           

            status=sendBuffer(p_buffer_entry);

            if( !NT_SUCCESS(status) || ( status == STATUS_NO_SUCH_DEVICE) || ( status == STATUS_DEVICE_NOT_CONNECTED))
            {
                p_buffer_entry = NULL;
                bUnrecoverableError = TRUE;
                KdPrint(("Data Transfer : parseBufferThread : looks like USB device is removed.\n"));
            }
            else
            {
                //Get the next buffer to parse
                p_buffer_entry = _buffer_complete_queue.getBuffer();
            }

        }

        if( _digital_stream && _polaris_engine_fail_count >= 10 )
        {
                KdPrint(("DataTransfer : parseBufferThread : All ZERO packets!\n"));

                stopStream();
                
                startStream();

                _polaris_engine_fail_count = 0;
		}

		if(bUnrecoverableError)
        {
            KdPrint(("Data Transfer : parseBufferThread : unrecoverable error\n"));
            break;
        }

        if(_stop_thread)
        {
            break;
        }

        //Wait for more buffers to come available
        _buffer_complete_queue.waitForBuffers(1000);
    }

    //If we had a buffer in progress, add it back to the buffer complete queue so it does
    // not get lost when we exit.
    if(p_buffer_entry)
    {
        _buffer_complete_queue.addBuffer(p_buffer_entry);
    }

    stopStream();

}


/////////////////////////////////////////////////////////////////////////////////////////
VOID DataTransfer::initializeTransfer()
{

      getUrbAndBufferSizes();

      if(_p_current_config->getUsbSpeed()==1)
      {
          switch(_media_type)
          {
            //case 1: //audio
            case 0x81:	// audio with HANC  		        
                KdPrint(("Audio enter HANC\n"));
                PolarisModeRegister(TS_MODE_REG, 0x9300);
                break;

            case 2: // vbi
                KdPrint(("set vanc registers\n"));
                PolarisModeRegister(TS_MODE_REG,  0x300);
                break;

            case 3: //sliced cc
                KdPrint(("set hanc registers\n"));
                PolarisModeRegister(TS_MODE_REG, 0x1300);
                break;

            case 0: //video
                PolarisModeRegister(TS_MODE_REG, 0x100);
                break;

            case 4: //ts1
                PolarisModeRegister(TS_MODE_REG, 0x101);
                PolarisModeRegister(TS1_CFG_REG , 0x400);
                break;		    
        }
    }
    else
    {
        PolarisModeRegister(TS_MODE_REG, 0x101);
    }     
    
    startStream();
}

/////////////////////////////////////////////////////////////////////////////////////////
VOID DataTransfer::setPin(BasePin* p_pin)
{
    PIN_TYPES pin_type = p_pin->getPinType();
    if(pin_type == PIN_TYPE_TS_MPEG || pin_type == PIN_TYPE_TS2_MPEG)
    {        
        // need to store the flag
        _digital_stream = 1;
        _ts_Data.setPin(p_pin);
    }
    else
    {
    	 if (pin_type == PIN_TYPE_AUDIO)
    	 {
    	    if(_media_type == 0x1)
    	    {
		        _data_parser.setAudioPin( p_pin);	
    	    }
	        else
		    {
                _data_parser.setPin(p_pin);	
            }
    	 }
	     else
         {
            _data_parser.setPin(p_pin);
         }
    }
}

/////////////////////////////////////////////////////////////////////////////////////////
VOID DataTransfer::releasePin(BasePin* p_pin)
{
    PIN_TYPES pin_type = p_pin->getPinType();
    if(pin_type == PIN_TYPE_TS_MPEG || pin_type == PIN_TYPE_TS2_MPEG)
    {        
        // need to store the flag
        //_digital_stream = 0;
        _ts_Data.setPin(p_pin);
    }
    else
    {
         if (pin_type == PIN_TYPE_AUDIO)
    	 {
    	    if(_media_type == 0x1)
    	    {
    	        _data_parser.releaseAudioPin();
    	    }
	        else
		    {
                _data_parser.releasePin(p_pin);	
            }
    	 }
         else
         {
            _data_parser.releasePin(p_pin);
         }
    }
}

/////////////////////////////////////////////////////////////////////////////////////////
NTSTATUS DataTransfer::startThread()
{
    if (_p_thread_object)
    {
        //Thread is already started
        return STATUS_UNSUCCESSFUL;
    }

    _stop_thread = FALSE;

    HANDLE thread_handle;
    NTSTATUS status = PsCreateSystemThread(
        &thread_handle,
        THREAD_ALL_ACCESS,
        NULL,
        NULL,
        NULL,
        (PKSTART_ROUTINE) DataTransfer::static_ThreadFunction,   // Thread routine
        this);                                                 // Context

    if(!NT_SUCCESS(status))
        return status;

    return ObReferenceObjectByHandle(
            thread_handle,
            THREAD_ALL_ACCESS,
            NULL,
            KernelMode,
            &_p_thread_object,
            NULL);
}

/////////////////////////////////////////////////////////////////////////////////////////
VOID DataTransfer::sleep(LONG time)
{
    ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);

    LARGE_INTEGER wait_time;

    wait_time.LowPart = -(time*10000);
    wait_time.HighPart = -1;

    KeDelayExecutionThread(
        KernelMode,
        FALSE,
        &wait_time);
}

/////////////////////////////////////////////////////////////////////////////////////////
VOID DataTransfer::startStream()
{
	BYTE  value[4];
    RtlZeroMemory(value, 4);
    DWORD tmp =0;

    KdPrint(("DataTransfer::startStream():::_ep_mask = %x\n", _ep_mask));
    _p_usb_firmware->getPolarisRegister(EP_MODE_SET, value, 4);

    tmp = *((DWORD *)value);
    tmp |= _ep_mask;
    value[0]=(BYTE)(tmp);
    value[1]=(BYTE)(tmp>>8);
    value[2]=(BYTE)(tmp>>16);
    value[3]=(BYTE)(tmp>>24);
    
    _p_usb_firmware->setPolarisRegister(EP_MODE_SET, value, 4);

    
}

/////////////////////////////////////////////////////////////////////////////////////////
VOID DataTransfer::stopStream()
{   
    BYTE  value[4];
    RtlZeroMemory(value, 4);
    DWORD tmp =0;
    KdPrint(("DataTransfer::stopStream():::_ep_mask = %x\n", _ep_mask));
    
    _p_usb_firmware->getPolarisRegister(EP_MODE_SET, value, 4);
    
    tmp = *((DWORD *)value);
    tmp&= (~_ep_mask);
    value[0]=(BYTE)tmp;
    value[1]=(BYTE)(tmp>>8);
    value[2]=(BYTE)(tmp>>16);
    value[3]=(BYTE)(tmp>>24);
    
    _p_usb_firmware->setPolarisRegister(EP_MODE_SET, value, 4);

}

/////////////////////////////////////////////////////////////////////////////////////////
VOID DataTransfer::PolarisModeRegister(WORD address, DWORD mode)
{
    BYTE  value[4];
    RtlZeroMemory(value, 4);
    DWORD tmp =0;
    
    _p_usb_firmware->getPolarisRegister(address , value, 4);
      
    tmp = *((DWORD *)value);
    tmp |= mode;

    value[0]=(BYTE)tmp;
    value[1]=(BYTE)(tmp>>8);
    value[2]=(BYTE)(tmp>>16);
    value[3]=(BYTE)(tmp>>24);

    _p_usb_firmware->setPolarisRegister(address, value, 4);   
    
}

/////////////////////////////////////////////////////////////////////////////////////////
BYTE DataTransfer::getType()
{
    return _media_type;
}

////////////////////////////////////////////////
// NTSTATUS DataTransfer::setInterface(UCHAR usb_interface_index)
// This function is only used for Polaris T0, which has multi-configuration
// scenarios, when configuration changes, dataTransfer should be updated.
// A0 donot need this function since A0 has only one configuration in each
// scenario.
NTSTATUS DataTransfer::setInterface(UCHAR usb_interface_index)
{
    _interface = usb_interface_index;
    return STATUS_SUCCESS;
}