cxpolarisdiagprop.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 "CxPolarisDiagProp.h"
#include "device.h"
#include "miscfuncs.h"
#include "DriverI2C.h"
#include "Merlin.h"
#include "PolarisUsbInterface.h"
#include "debug.h"
#include "SidewinderTunerProp.h"
#include "sidewinderprivate.h"


/////////////////////////////////////////////////////////////////////////////////////////
NTSTATUS CxPolarisDiagProp::i2cWrite(
                                     PIRP p_irp,
                                     PPROPERTY_CXPOLARIS_I2C_STRUCT p_request,
                                     PCXPOLARIS_I2C_STRUCT p_data)
{
    if(p_request->data.sub_size > CXPOLARIS_MAX_SUBADDRESS_BYTES ||
        p_request->data.buffer_size > CXPOLARIS_MAX_WRITE_I2C_BYTES)
    {
        return STATUS_INVALID_PARAMETER;
    }

    Device* p_device = getDevice(p_irp);
    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    DriverI2C* p_i2c = (DriverI2C*)p_device->getI2CInterface(p_request->data.channel);
    if(!p_i2c)
    {
        return STATUS_UNSUCCESSFUL;
    }
    BOOLEAN status = p_i2c->write(
        p_request->data.chip_address,
        p_request->data.sub_size,
        p_request->data.sub_buf,
        p_request->data.buffer_size,
        p_request->data.bytes);

#if DBG
    int i = 0;
    DbgLogInfo(("i2cWrite\n"));
    DbgLogInfo(("p_request->data.chip_address = %x\n",p_request->data.chip_address));
    DbgLogInfo(("p_request->data.sub_size = %x\n",p_request->data.sub_size));
    for(i = 0; i<p_request->data.sub_size;i++)  
        DbgLogInfo(("p_request->data.sub_buf[i] = %x\n", p_request->data.sub_buf[i]));
    for(i =0; i<p_request->data.buffer_size; i++)
        DbgLogInfo(("p_data->bytes[i]=%x\n",p_request->data.bytes[i]));
    DbgLogInfo(("p_request->data.channel = %x",p_request->data.channel));
#endif


    p_i2c->release();

    if (status==TRUE)
    {
        return STATUS_SUCCESS;
    }
    else
    {
        return STATUS_UNSUCCESSFUL;
    }
}

/////////////////////////////////////////////////////////////////////////////////////////
NTSTATUS CxPolarisDiagProp::i2cRead(
                                    PIRP p_irp,
                                    PPROPERTY_CXPOLARIS_I2C_STRUCT p_request,
                                    PCXPOLARIS_I2C_STRUCT p_data)
{
    if(p_request->data.sub_size > CXPOLARIS_MAX_SUBADDRESS_BYTES ||
        p_request->data.buffer_size > CXPOLARIS_MAX_READ_I2C_BYTES)
    {
        return STATUS_INVALID_PARAMETER;
    }

    Device* p_device = getDevice(p_irp);
    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    DriverI2C* p_i2c = (DriverI2C*)p_device->getI2CInterface(p_request->data.channel);
    if(!p_i2c)
    {
        return STATUS_UNSUCCESSFUL;
    }

    BOOLEAN status = p_i2c->read(
        p_request->data.chip_address,
        p_request->data.sub_size,
        p_request->data.sub_buf,
        p_request->data.buffer_size,
        p_data->bytes);

#if DBG
    int i = 0;
    DbgLogInfo(("i2cRead\n"));
    DbgLogInfo(("p_request->data.chip_address = %x\n",p_request->data.chip_address));
    DbgLogInfo(("p_request->data.sub_size = %x\n",p_request->data.sub_size));
    for(i = 0; i<p_request->data.sub_size;i++)  
        DbgLogInfo(("p_request->data.sub_buf[i] = %x\n", p_request->data.sub_buf[i]));
    for(i =0; i<p_request->data.buffer_size; i++)
        DbgLogInfo(("p_data->bytes[i]=%x\n",p_data->bytes[i]));
    DbgLogInfo(("p_request->data.channel = %x",p_request->data.channel));
#endif

    p_i2c->release();

    if (status==TRUE)
    {
        return STATUS_SUCCESS;
    }
    else
    {
        return STATUS_UNSUCCESSFUL;
    }
}

/////////////////////////////////////////////////////////////////////////////////////////
NTSTATUS CxPolarisDiagProp::i2cWriteThenRead(
    PIRP p_irp,
    PPROPERTY_CXPOLARIS_I2C_WRITE_THEN_READ_STRUCT p_request,
    PCXPOLARIS_I2C_WRITE_THEN_READ_STRUCT p_data)
{
    //this function only using as I2c read, so delegate to i2cRead
    return i2cRead(p_irp,
        (PPROPERTY_CXPOLARIS_I2C_STRUCT)p_request,
        (PCXPOLARIS_I2C_STRUCT)p_data);
}

NTSTATUS CxPolarisDiagProp::getPolarisRegister( 
    PIRP p_irp,
    PPROPERTY_CXPOLARIS_GET_REGISTER_STRUCT p_request,
    PCXPOLARIS_GET_REGISTER_STRUCT p_data)
{

    if(p_request->data.len > CXPOLARIS_MAX_REGISTER_BYTES) 
    {       
        return STATUS_INVALID_PARAMETER;
    }

    Device* p_device = getDevice(p_irp);

    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    PolarisUsbInterface* p_firmware = p_device->getPolarisUsbInterface();
    if(!p_firmware)
    {
        return STATUS_UNSUCCESSFUL;
    }

    WORD address = (p_request->data.address[1]<<8)|p_request->data.address[0];

    NTSTATUS status = p_firmware->getPolarisRegister(address , p_data->buffer, p_request->data.len);

    return status;
}

NTSTATUS CxPolarisDiagProp::setPolarisRegister( 
    PIRP p_irp,
    PPROPERTY_CXPOLARIS_SET_REGISTER_STRUCT p_request,
    PCXPOLARIS_SET_REGISTER_STRUCT p_data)
{

    if(p_request->data.len > CXPOLARIS_MAX_REGISTER_BYTES) 
    {       
        return STATUS_INVALID_PARAMETER;
    }

    Device* p_device = getDevice(p_irp);

    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    PolarisUsbInterface* p_firmware = p_device-> getPolarisUsbInterface();
    if(!p_firmware)
    {
        return STATUS_UNSUCCESSFUL;
    }

    WORD address = (p_request->data.address[1]<<8)|p_request->data.address[0];

    NTSTATUS status = p_firmware->setPolarisRegister(address, p_request->data.buffer, p_request->data.len);

    return status;
}

NTSTATUS CxPolarisDiagProp::getI2CPeriod( 
    PIRP p_irp,
    PPROPERTY_CXPOLARIS_I2C_PERIOD_STRUCT p_request,
    PCXPOLARIS_I2C_PERIOD_STRUCT p_data)
{
    Device* p_device = getDevice(p_irp);

    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    PolarisUsbInterface* p_firmware = p_device-> getPolarisUsbInterface();
    if(!p_firmware)
    {
        return STATUS_UNSUCCESSFUL;
    }

    NTSTATUS status = p_firmware->getI2CSpeed(&(p_data->value));

    return status;
}

NTSTATUS CxPolarisDiagProp::setI2CPeriod( 
    PIRP p_irp,
    PPROPERTY_CXPOLARIS_I2C_PERIOD_STRUCT p_request,
    PCXPOLARIS_I2C_PERIOD_STRUCT p_data)
{
    Device* p_device = getDevice(p_irp);

    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    PolarisUsbInterface* p_firmware = p_device-> getPolarisUsbInterface();
    if(!p_firmware)
    {
        return STATUS_UNSUCCESSFUL;
    }

    NTSTATUS status = p_firmware->setI2CSpeed(p_request->data.value);

    return status;
}

/////////////////////////////////////////////////////////////////////////////////////////
NTSTATUS CxPolarisDiagProp::reloadMerlinFirmware(
    PIRP p_irp,
    KSPROPERTY* p_request,  //No input or output parameters required
    PVOID p_data)
{
    Device* p_device = getDevice(p_irp);
    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    Merlin* p_merlin = (Merlin*)p_device->getAudDec();
    if(!p_merlin)
    {
        return STATUS_UNSUCCESSFUL;
    }
    //NOTE: use initialize rather than uploadFirmware to make sure all audio settings
    // get restored.
    p_merlin->initialize();

    return STATUS_SUCCESS;
}

/////////////////////////////////////////////////////////////////////////////////////////
NTSTATUS CxPolarisDiagProp::i2cDigitalWrite(
    PIRP p_irp,
    PPROPERTY_CXPOLARIS_I2C_STRUCT p_request,
    PCXPOLARIS_I2C_STRUCT p_data)
{
    return STATUS_SUCCESS;
}

/////////////////////////////////////////////////////////////////////////////////////////
NTSTATUS CxPolarisDiagProp::i2cDigitalWriteThenRead(
    PIRP p_irp,
    PPROPERTY_CXPOLARIS_I2C_WRITE_THEN_READ_STRUCT p_request,
    PCXPOLARIS_I2C_WRITE_THEN_READ_STRUCT p_data)
{
    return STATUS_SUCCESS;
}


//Below codes for supporting Tuner tab in Polaris Fulcrum
/////////////////////////////////////////////////////////////////////////////////////////
NTSTATUS CxPolarisDiagProp::GetSideWinderPrivateStruct(
		PIRP p_irp,
		PPROPERTY_SW_PRIVATE_STRUCT p_request,
		PSW_PRIVATE_STRUCT p_data)
{

    Device* p_device = getDevice(p_irp);
    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    CSidewinderTunerProp* p_Sidewinder_tuner_properties = (CSidewinderTunerProp*) (p_device->getTunerProperties());
	
    SIDEWINDER_PRIVATE_STRUCT* pTmp_prv_struct = (SIDEWINDER_PRIVATE_STRUCT*)
		p_Sidewinder_tuner_properties->getSwPrivateStruct();
	if(pTmp_prv_struct)
	{
        p_data->p_callback = pTmp_prv_struct->p_callback;
		p_data->p_context = pTmp_prv_struct->p_context;
        p_data->p_gen_si_tuner_callback = pTmp_prv_struct->p_gen_si_tuner_callback;
		p_data->saw_freq = pTmp_prv_struct->saw_freq;
		p_data->saw_type = pTmp_prv_struct->saw_type;
		p_data->xtal_freq  = pTmp_prv_struct->xtal_freq;
	}
	else
        return STATUS_UNSUCCESSFUL;

    return STATUS_SUCCESS;
}

/////////////////////////////////////////////////////////////////////////////////////////
NTSTATUS CxPolarisDiagProp::SwPrivateCallBack(
	PIRP p_irp,
	PPROPERTY_SW_PRIVATE_CALLBACK p_request,
	PSW_PRIVATE_CALLBACK p_data)
{
	if(p_request->data.p_context == NULL)
    {
        return STATUS_INVALID_PARAMETER;
    }


    Device* p_device = getDevice(p_irp);
    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }
    CSidewinderTunerProp* p_Sidewinder_tuner_properties = (CSidewinderTunerProp*) (p_device->getTunerProperties());
	
    SIDEWINDER_PRIVATE_STRUCT* pTmp_prv_struct = (SIDEWINDER_PRIVATE_STRUCT*)
		p_Sidewinder_tuner_properties->getSwPrivateStruct();

	if(pTmp_prv_struct && pTmp_prv_struct->p_context && pTmp_prv_struct->p_callback )
	{
		( *(pTmp_prv_struct->p_callback))(pTmp_prv_struct->p_context,
										  p_request->data.if_freq,
										  p_request->data.spectral_invert,
										  p_request->data.mode);
	}
	else
        return STATUS_UNSUCCESSFUL;

    return STATUS_SUCCESS;
}

/////////////////////////////////////////////////////////////////////////////////////////
NTSTATUS CxPolarisDiagProp::SwPrivateGenSiTunerCallBack(
	PIRP p_irp,
	PPROPERTY_SW_PRIVATE_GEN_SI_TUNER_CALLBACK p_request,
	PSW_PRIVATE_GEN_SI_TUNER_CALLBACK p_data)
{
	if(p_request->data.p_DIF == NULL)
    {
        return STATUS_INVALID_PARAMETER;
    }

	Device* p_device = getDevice(p_irp);
    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    CSidewinderTunerProp* p_Sidewinder_tuner_properties = (CSidewinderTunerProp*) (p_device->getTunerProperties());
	
    SIDEWINDER_PRIVATE_STRUCT* pTmp_prv_struct = (SIDEWINDER_PRIVATE_STRUCT*)
		p_Sidewinder_tuner_properties->getSwPrivateStruct();

	if(pTmp_prv_struct && pTmp_prv_struct->p_context && pTmp_prv_struct->p_gen_si_tuner_callback)
	{
		( *(pTmp_prv_struct->p_gen_si_tuner_callback))(pTmp_prv_struct->p_context,
										  p_request->data.command,
										  &p_data->callback_context);
		
	}
	else
		return STATUS_UNSUCCESSFUL;

    return STATUS_SUCCESS;
}

NTSTATUS CxPolarisDiagProp::getGPIO( 
    PIRP p_irp,
    PPROPERTY_CXPOLARIS_GPIO_STRUCT p_request,
    PCXPOLARIS_GPIO_STRUCT p_data)
{
    Device* p_device = getDevice(p_irp);

    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    PolarisUsbInterface* p_firmware = p_device-> getPolarisUsbInterface();
    if(!p_firmware)
    {
        return STATUS_UNSUCCESSFUL;
    }

    DWORD gpio_dir = p_request->data.gpio_bit[0]
        |(p_request->data.gpio_bit[1]<<8)
        |(p_request->data.gpio_bit[2]<<16)
        |(p_request->data.gpio_bit[3]<<24);
    
    NTSTATUS status = p_firmware->getGpio(gpio_dir,                                            
                                            p_data->gpio_value,
                                            p_request->data.len,
                                            p_request->data.request);

    return status;
}

NTSTATUS CxPolarisDiagProp::setGPIO( 
    PIRP p_irp,
    PPROPERTY_CXPOLARIS_GPIO_STRUCT p_request,
    PCXPOLARIS_GPIO_STRUCT p_data)
{
    Device* p_device = getDevice(p_irp);

    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    PolarisUsbInterface* p_firmware = p_device-> getPolarisUsbInterface();
    if(!p_firmware)
    {
        return STATUS_UNSUCCESSFUL;
    }
    DWORD gpio_dir = p_request->data.gpio_bit[0]
        |(p_request->data.gpio_bit[1]<<8)
        |(p_request->data.gpio_bit[2]<<16)
        |(p_request->data.gpio_bit[3]<<24);
    
    NTSTATUS status = p_firmware->setGpio(gpio_dir,                                            
                                            p_request->data.gpio_value,
                                            p_request->data.len,
                                            p_request->data.request);

    return status;
}