hamaro_reg.c

机顶盒Hamaro解调器驱动。包含自动搜台

/* hamaro_reg.c */

/*+++ *******************************************************************\
*
*   Copyright and Disclaimer:
*
*       ---------------------------------------------------------------
*       ALL SOFTWARE, APPLICATIONS, DOCUMENTATION, OR MATERIALS        
*       FURNISHED HEREIN IS PROVIDED *AS IS*.  CONEXANT DOES NOT MAKE  
*       ANY WARRANTIES, EITHER EXPRESS OR IMPLIED, AND HEREBY EXPRESSLY
*       DISCLAIMS ANY AND ALL SUCH WARRANTIES TO THE EXTENT PERMITTED  
*       BY LAW, INCLUDING, SPECIFICALLY, ANY IMPLIED WARRANTY ARISING  
*       BY STATUTE OR OTHERWISE IN LAW OR FROM A COURSE OF DEALING OR  
*       USAGE OF TRADE.  CONEXANT DOES NOT MAKE ANY WARRANTIES, EITHER 
*       EXPRESS OR IMPLIED, AND HEREBY EXPRESSLY DISCLAIMS ANY AND ALL 
*       SUCH WARRANTIES WITH RESPECT TO ALL SOFTWARE, APPLICATIONS,    
*       DOCUMENTATION, AND MATERIALS INCLUDING ALL IMPLIED WARRANTIES  
*       OF MERCHANTABILITY, OR OF MERCHANTABLE QUALITY, OR OF FITNESS  
*       FOR ANY PURPOSE, PARTICULAR, SPECIFIC OR OTHERWISE, OR OF      
*       NONINFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OF OTHERS,     
*       RELATING TO THE SOFTWARE, APPLICATIONS, OPERATION,             
*       DOCUMENTATION, DATA OR RESULTS GENERATED BY THE OPERATION OR   
*       USE THEREOF, AND MATERIALS PROVIDED HEREIN.  THE ENTIRE RISK AS
*       TO THE SUBSTANCE, QUALITY AND PERFORMANCE OF SOFTWARE,         
*       APPLICATIONS, AND DOCUMENTATION DESCRIBING SUCH SOFTWARE       
*       REMAINS WITH THE BUYER.                                        
*                                                                      
*       REGARDLESS OF WHETHER ANY REMEDY SET FORTH HEREIN FAILS OF ITS 
*       ESSENTIAL PURPOSE OR OTHERWISE, CONEXANT SHALL NOT BE LIABLE   
*       FOR ANY EXEMPLARY, SPECIAL, PUNITIVE, SPECULATIVE, INDIRECT,   
*       CONSEQUENTIAL OR INCIDENTAL DAMAGES OF ANY KIND (INCLUDING     
*       WITHOUT LIMITATION LOST PROFITS, LOSS OF INCOME, LOSS OF       
*       GOODWILL, OR OTHER TANGIBLE OR INTANGIBLE BUSINESS LOSS)       
*       ARISING OUT OF OR IN CONNECTION WITH, DIRECTLY OR INDIRECTLY,  
*       SOFTWARE, APPLICATIONS, DOCUMENTATION, OR ANY SERVICES OR      
*       MATERIALS PROVIDED HEREUNDER, OR USE OR INABILITY TO USE THE   
*       SOFTWARE, EVEN IF CONEXANT HAS BEEN ADVISED OF THE POSSIBILITY 
*       OF SUCH DAMAGES.                                               
*
*       Copyright (c) 2001 Conexant Systems, Inc.
*       All Rights Reserved.
*       ---------------------------------------------------------------
*
*   Module Revision Id:
*
*       $Header: hamaro_reg.c, 21, 2007-8-17 15:37:13, Tim Lu$
*
*   Abstract:
*
*       Contains all register-based code to perform I/O to, from the Demod,
*       excluding the lowest-level I/O functions: SBREAD and SBWRITE.  Both 
*       of which are dependant upon hardware implementation.
*
\******************************************************************* ---*/

#include <stdio.h>                     /* ANSI Standard */

#include "hamaro.h"                     /* Hamaro include files, ordered */
#include "hamaro_regs.h"                /* Hamaro Internal */

#if HAMARO_INCLUDE_DEBUG
static BOOL  RegisterVerifyRegRW(HAMARO_NIM *nim,int);
static BOOL  RegisterVerifyRegFilter(HAMARO_NIM *nim,int);
static BOOL  RegisterVerifyRegDataType(HAMARO_NIM *nim,int);
static BOOL  RegisterVerifyRegDefault(HAMARO_NIM *nim,int);
static BOOL  RegisterVerifyRegBitCount(HAMARO_NIM *nim,int);
static BOOL  RegisterOneOf(char,char*,int);
#endif /* HAMARO_INCLUDE_DEBUG */


#ifndef TONE22K_AMP
#define TONE22K_AMP 3
#endif

/* performs Hamaro register I/O using the hamaro_reg.h REGISTER structure to determine        */
/* how register data is read and written to the Demod.                                      */

/*******************************************************************************************************
 *                 R E G I S T E R    I N T E R F A C E    F U N C T I O N S
 *******************************************************************************************************/
/* ===                                Register Functions                                            ===*/
/*******************************************************************************************************
 * Name: HAMARO_RegisterWrite
 *
 * Description:
 * 	This function writes to a bit-field or a byte in the special control area. This function is NOT 
 *     applicable for Page0 address space since it is read-only.
 * Return Value:
 * 	TRUE - operation successful; FALSE - otherwise.
 *
 * I/O	Parameters	                         Descriptions
 * IN	HAMARO_NIM*               p_nim	     Pointer to HAMARO_NIM structure allocated by application
 * IN	REGISTER_BIT_FIELD reg_field_index	 Index that uniquely identifies the value within a register 
 *                                           (or spanning multiple 8-bit registers while reading from Page0). 
 * IN	unsigned long      value	         Value to be written.
 *******************************************************************************************************/
BOOL 
HAMARO_RegisterWrite(HAMARO_NIM*       p_nim,
					unsigned short   reg_field_index, 
					unsigned long    value,
					HAMARO_IO_METHOD  io_method)
{
    int            bytes      = 0;
    unsigned char  offset     = 0;
	unsigned char  index      = 0;
    unsigned char  data_write = 0x00U;
    unsigned char  data_read  = 0x00U;
	unsigned char  sub_address = 0;

	unsigned long              handle;
	const HAMARO_REGISTER_MAP*  p_register_map;

    /* Validation */
    if (p_nim == 0) /* bad pointer */
    {
        return (False);
    }

	/* Initialization */
	switch (io_method)
	{
		case HAMARO_DEMOD_I2C_IO:
			handle = p_nim->demod_handle;
			p_register_map = hamaro_demod_register_map;
			break;

#if HAMARO_INCLUDE_VIPER
		case HAMARO_VIPER_I2C_IO:
			handle = p_nim->tuner.cx24128.tuner_handle;
			p_register_map = hamaro_viper_register_map;
			break;
#endif /* HAMARO_INCLUDE_VIPER */
		default:
			return (False);
	}
    
    /* Verify that index passed points to the correct register record */
    if (p_register_map[reg_field_index].bit_field != reg_field_index)
    {
        HAMARO_DRIVER_SET_ERROR (p_nim, HAMARO_REG_MATCH_IDX);
        return (False);
    }
    
    /* Register read-only */
    if (p_register_map[reg_field_index].access_level == HAMARO_REG_RO ||
        p_register_map[reg_field_index].access_level == HAMARO_REG_UNUSED)
    {
        HAMARO_DRIVER_SET_ERROR(p_nim, HAMARO_REG_HDWR_REGRDO);
        return (False);
    }
    
	sub_address = (unsigned char)(p_register_map[reg_field_index].address);

	if (io_method == HAMARO_DEMOD_I2C_IO)
	{
		sub_address = (unsigned char)(sub_address + p_nim->register_offset);
	}
#if HAMARO_INCLUDE_VIPER
	else if (io_method == HAMARO_VIPER_I2C_IO)
	{
		sub_address = (unsigned char)(sub_address + p_nim->tuner.cx24128.register_offset);
	}
#endif /* HAMARO_INCLUDE_VIPER */

    /* de-translate from variable to hardware bit positioned value and write to hardware */
    switch (p_register_map[reg_field_index].reg_type)
    {
        case HAMARO_REGT_BIT:    /* 1 to 7 bit(s) wide */
		case HAMARO_REGT_NULL:
        case HAMARO_REGT_BYTE:   /* 1 byte wide */
		case HAMARO_REGT_BITHL:  /* 1 bit wide. Toggle */
        {
			unsigned char startbit = p_register_map[reg_field_index].start_bit;

            if (p_register_map[reg_field_index].bit_count == 0x01) /* single bit */
            {
                if (value)
                {
                    data_write = (unsigned char)(p_register_map[reg_field_index].p_hw_mask[0]);
                }
                else
                {
                    data_write = 0x00;
                }
            }
            else /* Minimum 2 bits, max 8 bits */
            {                
                unsigned long temp;

                /* mask useful bits from raw, shift left (make range 0..2^bit_count) */
                temp = value & ((0x01UL<<(p_register_map[reg_field_index].bit_count))-1UL);
                temp = (temp << (startbit-(p_register_map[reg_field_index].bit_count-1)));
                data_write = (unsigned char)temp;
            }
            
            /* clear io error return value */
            p_nim->iostatus = 0UL;

#if HAMARO_INCLUDE_VIPER
			if (io_method == HAMARO_VIPER_I2C_IO)
			{
				/* Set special control register to repeater mode. It will go off after one serial bus transaction.*/
				if (HAMARO_TUNER_CX24128_RepeaterModeReadData(p_nim, handle, sub_address, &data_read) == False)
				{
					return (False);
				}
			}
#endif /* HAMARO_INCLUDE_VIPER */

			if (io_method == HAMARO_DEMOD_I2C_IO)
			{
				/* Byte must be read, modified, written */
				data_read = (unsigned char)((*p_nim->SBRead)(handle, sub_address, &p_nim->iostatus)); 
				/* Watch for special-case error, read error during write */
				if (p_nim->iostatus != 0UL)
				{
					/* Hardware write error */
					HAMARO_DRIVER_SET_ERROR(p_nim, HAMARO_REG_HDWR_REWTERR);
					return (False);
				}
			}

            /* mask data that must be retained */
            data_read = (unsigned char)(data_read & (unsigned char)(~p_register_map[reg_field_index].p_hw_mask[0]));
            data_read |= data_write;

            if ((p_register_map[reg_field_index].regfilter & HAMARO_REGF_ZEROB6) != 0) /* zero bit 6 */
            {
                data_read &= (unsigned char)0xBF;
            }

            /* clear io error return value */
            p_nim->iostatus = 0UL;

            /* write byte to hardware */
#if HAMARO_INCLUDE_VIPER
			if (io_method == HAMARO_VIPER_I2C_IO)
			{
				/* Set special control register to repeater mode. It will go off after one serial bus transaction.*/
				if (HAMARO_TUNER_CX24128_RepeaterModeWriteData(p_nim, handle, sub_address, data_read) == False)
				{
					return (False);
				}
				/* add toggle code here when regmap of that type defined for viper */
			}
#endif /* HAMARO_INCLUDE_VIPER */

			if (io_method == HAMARO_DEMOD_I2C_IO)
			{
				(*p_nim->SBWrite)(handle, sub_address, data_read, &p_nim->iostatus); 
				if (p_register_map[reg_field_index].reg_type == HAMARO_REGT_BITHL) /* toggle */