phantom_cmd.c

来自「QPSK Tuner details, for conexant chipset」· C语言 代码 · 共 769 行 · 第 1/3 页

            /* 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;

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

            /* write byte to hardware */
            (*p_nim->SBWrite)(handle, (unsigned char)(p_register_map[reg_field_index].address), data_read, &p_nim->iostatus);
        }
        break;

		case PHANTOM_REGT_MBYTE: /* 1 to 4 byte(s) wide */
		{
			unsigned char startbit = p_register_map[reg_field_index].start_bit;
			signed char bitcnt = p_register_map[reg_field_index].bit_count;
			unsigned char mask;

			/* Read write the multiple bit (> 8 bits) value */
			while (bytes < p_register_map[reg_field_index].bit_count)
			{
				data_read = (*p_nim->SBRead)(handle, (unsigned char)(p_register_map[reg_field_index].address+offset), 
							&p_nim->iostatus);

				/* Watch for special-case error, read error during write */
				if (p_nim->iostatus != 0UL)
				{
					/* Hardware write error */
					PHANTOM_DBG_SET_ERROR(PHANTOM_REG_HDWR_RD_WR_ERR);
					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[offset]));
				if ((long)value < 0) 
				{
					/* Take the 2's complement. */
					value = value + (1UL << bitcnt);
				}
				bitcnt = (signed char)(bitcnt - (startbit + 1));
				if (bitcnt > 0)
				{
					data_write = (unsigned char)(value >> bitcnt);
					mask = p_register_map[reg_field_index].p_hw_mask[offset];
					data_write &= p_register_map[reg_field_index].p_hw_mask[offset];
				}
				else
				{
					mask = p_register_map[reg_field_index].p_hw_mask[offset];
					data_write = (unsigned char)((value << (0 - bitcnt)) & p_register_map[reg_field_index].p_hw_mask[offset]);
				}
				startbit = 7;
				data_read |= data_write;

				(*p_nim->SBWrite)(handle, (unsigned char)(p_register_map[reg_field_index].address+offset), 
								data_read,
								&p_nim->iostatus);
		        
				/* Watch for special-case error, read error during write */
				if (p_nim->iostatus != 0UL)
				{
					/* Hardware write error */
					PHANTOM_DBG_SET_ERROR(PHANTOM_REG_HDWR_RD_WR_ERR);
					return (False);
				}

				offset++;
				if (offset == PHANTOM_MAX_REGISTER_LEN)
				{
					break;
				}
				bytes += 8;
			}
		}
		break;

        case PHANTOM_REG_RESERVED:
        default:
        break;
    }
    /* SB Write error */
    if (p_nim->iostatus != 0UL)
    {
      /* write error writing to hardware */
      PHANTOM_DBG_SET_ERROR(PHANTOM_IO_WRITERR);
      return (False);
    }

    return (True);
} /* PHANTOM_RegisterWrite */


/*******************************************************************************************************
 * Name: PHANTOM_RegisterRead
 * Description:
 * 	This function reads from 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	PHANTOM_NIM*               p_nim	        Pointer to PHANTOM_NIM structure allocated by application
 * IN	unsigned short     reg_field_index	Index that uniquely identifies the value within a register 
 *                                          or one that spans multiple 8-bit registers beginning form 
 *                                          the address that corresponds to this reg_field_index. 
 * IN	unsigned long*     p_value	        Value read from the Page0 or Special control address.
 * IN   PHANTOM_SB_USE_HANDLE      use_handle		Use specified serial bus handle from the PHANTOM_NIM.
 *   
 *******************************************************************************************************/
BOOL 
PHANTOM_RegisterRead(PHANTOM_NIM*               p_nim,
             unsigned short     reg_field_index, 
             unsigned long*     p_value,
			 PHANTOM_SB_USE_HANDLE      use_handle)
{
    register int   bytes  = 0;    /* counts 8-bits read */
    unsigned char  offset = 0;  
    unsigned char  reg_buffer[PHANTOM_MAX_REGISTER_LEN];

	unsigned long  handle;
	const PHANTOM_REGISTER_MAP*  p_register_map;

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

    if (p_value == 0)
    {
        return (False);
    }
    *p_value = 0;

	/* Initialization */
	switch (use_handle)
	{
		case PHANTOM_USE_DEMOD_HANDLE:
			handle = p_nim->demod_handle;
			p_register_map  = phantom_register_map;
			break;

		default:
			return (False);
	}

    /* Verify that index passed points to the correct register record */
    PHANTOM_DBG_VALIDATE_REG_IDX(p_register_map, reg_field_index);

    /* Register write-only */
    PHANTOM_DBG_VALIDATE_REG_WO (p_register_map, reg_field_index);

    /* Read the register(s) */
    p_nim->iostatus = 0UL; /* clear io error return value */

    /* Read the multiple bit (> 8 bits) value */
    while (bytes < p_register_map[reg_field_index].bit_count && p_nim->iostatus != 1UL)
    {
        reg_buffer[offset] = (*p_nim->SBRead)(handle, 
                             (unsigned char)(p_register_map[reg_field_index].address+offset), 
                             &p_nim->iostatus);

		if (p_nim->iostatus != 0UL)
		{
			/* hardware read error */
			PHANTOM_DBG_SET_ERROR(PHANTOM_IO_READERR);
			return (False);
		}

        offset++;
        if (offset == PHANTOM_MAX_REGISTER_LEN)
        {
            break;
        }
        bytes += 8;
    }
    
    /* Translate: raw data read from the hardware registers to data used by the driver*/  
    switch(p_register_map[reg_field_index].reg_type)
    {
        case PHANTOM_REGT_BIT:
        case PHANTOM_REGT_BYTE:
        if (p_register_map[reg_field_index].bit_count == 0x01) /* single bit */
        {
            /* Mask the bit to 1 or 0 */
            if ((reg_buffer[0] & p_register_map[reg_field_index].p_hw_mask[0]) != 0)            
            {
                *p_value = 0x01;
            }
            else
            {
                *p_value = 0x00;
            }
            break;
        }
        else
        {
            /* Min 2 bits, max 8 bits */
            unsigned long temp;

            /* mask useful bits from raw, shift rt (make range 0..2^bit_count) */
            temp = (long)(reg_buffer[0] & (unsigned char)p_register_map[reg_field_index].p_hw_mask[0]);            
            temp = (temp >> (p_register_map[reg_field_index].start_bit-(p_register_map[reg_field_index].bit_count-1)));
            *p_value = (unsigned char)temp;
            break;
        }
        case  PHANTOM_REGT_MBYTE:
        {
            unsigned short byte_count;
            unsigned char  bit_value; 
            unsigned char  byte_index; 
            unsigned char  bit_mask;

			/* count the number of hardware reg bytes that comprise the register in question */
            for (byte_count = 0; byte_count < PHANTOM_MAX_REGISTER_LEN; byte_count++)  
            {
                if (p_register_map[reg_field_index].p_hw_mask[byte_count] == 0x00)  
                {
                    break;
                }
            }

            /* Convert multiple byte value from spread bits to compressed */
            for (byte_index = 0; byte_index < byte_count; byte_index++)
            {
                for (bit_mask = 0x80; bit_mask != 0; bit_mask >>= 1)
                {
                    if ((p_register_map[reg_field_index].p_hw_mask[byte_index]  & bit_mask) != 0)
                    {
                        bit_value = (unsigned char)((bit_mask & reg_buffer[byte_index]) != 0 ? 1UL : 0UL);
                        *p_value  = ((*p_value << 1) | bit_value);
                    }
                }
            }
            break;
        }

        default:
			PHANTOM_DBG_SET_ERROR(PHANTOM_REG_VERFY_REGDTP_ERR);
			return(False);
    }  /* switch(... */

    return (True);
} /* PHANTOM_RegisterRead */



/*******************************************************************************************************/
/* ===                             Low-level DPR Functions                                          ===*/
/*******************************************************************************************************
* Name: PHANTOM_ExecuteLLF
* Description:
* 	This function executes any DPR LLF command. This function waits for the return response depending 
*   on the wait for response flag. The error flags and LLF returned values are passed back to the caller. 
*   This function generates and manages the read/write tokens.
* Return Value: