usbi2cinterface.cpp

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

/*+++ *******************************************************************\ 
* 
*  Copyright and Disclaimer: 
*  
*     --------------------------------------------------------------- 
*     This software is provided "AS IS" without warranty of any kind, 
*     either expressed or implied, including but not limited to the 
*     implied warranties of noninfringement, merchantability and/or 
*     fitness for a particular purpose.
*     --------------------------------------------------------------- 
*   
*     Copyright (c) 2008 Conexant Systems, Inc. 
*     All rights reserved. 
*
\******************************************************************* ---*/ 
#include "UsbI2cInterface.h"
#include "PolarisUsbInterface.h"
#include "CUSBIntf.h"
#include "debug.h"
#include "Device.h"

static const DWORD MAX_BYTE_VALUE = 255;
static const DWORD WRITE_INFORMATION_BYTES = 3;
static const DWORD WRITE_THEN_READ_INFO_BYTES = 4;
static const DWORD STATUS_BYTES = 1;

/////////////////////////////////////////////////////////////////////////////////////////
UsbI2cInterface::UsbI2cInterface (PolarisUsbInterface* p_usb_firmware, CUsbInterface* p_usb, Device* p_device):
_reference_count( 1 ),
_p_usb(p_usb),
_p_usb_firmware(p_usb_firmware),
_p_device(p_device),
_is_digital_mode(0)
{
    DbgLogInfo(("UsbI2cInterface::UsbI2cInterface constructor\n"));
    KeInitializeMutex( &_mutex, 0 );	
}

/////////////////////////////////////////////////////////////////////////////////////////
INT UsbI2cInterface::addRef()
{
    return ++_reference_count;
}

/////////////////////////////////////////////////////////////////////////////////////////
INT UsbI2cInterface::release()
{
    if( --_reference_count == 0 ) 
    {
        DbgLogInfo(("UsbI2cInterface::release : deleting UsbI2cInterface\n"));
        delete this;
        return 0;
    }

    return _reference_count;
}

/////////////////////////////////////////////////////////////////////////////////////////
VOID UsbI2cInterface::lock()
{
    KeWaitForSingleObject(&_mutex, Executive, KernelMode, FALSE, NULL );
}


/////////////////////////////////////////////////////////////////////////////////////////
VOID UsbI2cInterface::unlock()
{
    KeReleaseMutex(&_mutex, FALSE);
}

NTSTATUS UsbI2cInterface::setCommandFormat(BOOLEAN first,BOOLEAN last)
{
    if(!_p_usb_firmware)
        return STATUS_UNSUCCESSFUL;
    else
        return _p_usb_firmware->setCommandFormat(first,last);
}

/////////////////////////////////////////////////////////////////////////////////////////
BOOLEAN UsbI2cInterface::read( 
                              BYTE        device_adr, 
                              INT         subaddr_size, 
                              const BYTE  *p_subaddr_buf,
                              INT         read_size,
                              BYTE        *p_read_buf,
                              BYTE        channel)
{
    if (read_size==0)
    {
        return TRUE;
    }

    BYTE buffer[MAX_BYTE_VALUE];
    INT length = 0;

    buffer[0] = channel;
    buffer[1] = device_adr ;
    buffer[2] = (BYTE)subaddr_size;

    if (p_subaddr_buf)
    {
        RtlCopyMemory(&buffer[WRITE_INFORMATION_BYTES], p_subaddr_buf, subaddr_size);
    }

    buffer[WRITE_INFORMATION_BYTES+subaddr_size] = (BYTE) read_size;
    length = WRITE_INFORMATION_BYTES+subaddr_size+1;

    for(int i=0; i<read_size; i++)
    {
        buffer[length+i] = 0; //clear read buffer
    }

    //Perform the read
    NTSTATUS status = _p_usb_firmware->sendCommand(
        NULL, 0,                        //write buffer and size
        buffer, length + read_size);    //read buffer and size

    if (p_read_buf)
    {
        RtlCopyMemory(p_read_buf, &buffer[length], read_size);
    }

    return (status == STATUS_SUCCESS);
}

/////////////////////////////////////////////////////////////////////////////////////////
BOOLEAN UsbI2cInterface::write( 
                               BYTE        device_adr, 
                               INT         subaddr_size,
                               const BYTE  *p_subaddr_buf,
                               INT         write_size,
                               BYTE        *p_write_buf,
                               BYTE        channel)
{
    if (write_size==0)
    {
        return TRUE;
    }

    BYTE buffer[MAX_BYTE_VALUE];
    DWORD length = 0;

    buffer[0] = channel;
    buffer[1] = device_adr ;
    buffer[2] = (BYTE)subaddr_size;

    if (p_subaddr_buf)
    {
        RtlCopyMemory(&buffer[WRITE_INFORMATION_BYTES], p_subaddr_buf, subaddr_size);
    }

    buffer[WRITE_INFORMATION_BYTES+subaddr_size] = (BYTE) write_size;
    length = WRITE_INFORMATION_BYTES+subaddr_size+1;

    if (p_write_buf)
    {
        RtlCopyMemory(&(buffer[length]), p_write_buf, write_size);
    }

    NTSTATUS status = _p_usb_firmware->sendCommand(
        buffer, length + write_size,    //write buffer and size
        NULL, 0);                       //read buffer and size

    return (status == STATUS_SUCCESS);
}

/////////////////////////////////////////////////////////////////////////////////////////
BOOL UsbI2cInterface::SelectAnalogMode()
{
    // Analog path is requested
    // check whether Analog path is already selected or not
    if(!_is_digital_mode )
    {
        return TRUE;  // Analog path is already selected
    }

    _is_digital_mode = FALSE;  // set the flag to Analog

    DbgLogInfo(("UsbI2cInterface: SelectAnalogMode : Analog Path selected\n"));

    return TRUE;
}

/////////////////////////////////////////////////////////////////////////////////////////


BOOL UsbI2cInterface::SelectDigitalMode()
{
    // Digital path is requested

    // check whether Digital path is already selected or not
    if(_is_digital_mode)
        return TRUE;  // Digital path is already selected

    _is_digital_mode = TRUE;  // set the flag to Digital

    DbgLogInfo(("UsbI2cInterface: SelectDigitalMode : Digital Path selected\n"));

    return TRUE;
}

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////
BOOLEAN UsbI2cInterface::IsDigitalStreamRunning()
{
    // check for Digital path is already running
    return (_p_device->getStreamRunning() & (DWORD)DEVICE_STREAM_TS_MPEG)?TRUE:FALSE;    
}

/////////////////////////////////////////////////////////////////////////////////////////
BOOLEAN UsbI2cInterface::IsAnalogStreamRunning()
{
    // check for Analog path is already running
    return (_p_device->getStreamRunning() & ~(DWORD)DEVICE_STREAM_TS_MPEG)?TRUE:FALSE;    
}

DWORD UsbI2cInterface::maxTransferSize()
{

    DWORD transfer_size=0;

    DWORD revID = _p_usb->getRevID();

    if(revID >=POLARIS_REVID_A0)
    {
        transfer_size = TRANSFER_SIZE_A0;
    }
    else if(revID == POLARIS_REVID_T0)
    {
        transfer_size = TRANSFER_SIZE_T0;
    }
    else
    {
        transfer_size = 0;
    }
        
    return transfer_size;    
}