cx24143_regs.c

QPSK Tuner details, for conexant chipset.

          {
            /* write error writing to hardware */
            DRIVER_SetError(nim,REG_HDWR_REWTERR);
            return(False);
          }

          /* mask data that must be retained */
          u.c[offst] = (UCHAR)(u.c[offst]&(UCHAR)(~Register[regidx].hwmask[i]));
          u.c[offst] |= wbuf[i];

          /* (CR 7665) perform any special filter functionality prior to write as required */
          RegisterFilter(Register[regidx].regfilter, &u.c[offst]);

          /* write byte to hardware */
          (*nim->SBWrite)(nim->demod_handle,(UCHAR)(Register[regidx].addr+offst),u.c[i],&nim->iostatus);
        }
        else
        {
          /* special register type -- Register[regidx].regtype == REGT_BITHL */
          (*nim->SBWrite)(nim->demod_handle,(UCHAR)Register[regidx].addr,(UCHAR)Register[regidx].hwmask[0],&nim->iostatus);
          (*nim->SBWrite)(nim->demod_handle,(UCHAR)Register[regidx].addr,(UCHAR)0x00,&nim->iostatus);
          break;
        }
      }
    }

    /* watch for any errors */
    if (nim->iostatus != 0UL)
    {
      /* write error writing to hardware */
      DRIVER_SetError(nim,API_IO_WRITERR);
      return(False);
    }
  }

  return(True);

}  /* RegisterWriteToHDWR() */


/*******************************************************************************************************/
/* RegisterFilter() */
/*******************************************************************************************************/
void           RegisterFilter(         /* function to perform pre-write filtering */
REGF           filter,                 /* enum filer to perform against byte passed-in */
UCHAR  *ch)                    /* byte to be filtered */
{
   if ((filter & REGF_ZEROB6) == REGF_ZEROB6)
   {
      *ch &= (UCHAR)~0x40;
   }

   return;

}  /* RegisterFilter() */


/*******************************************************************************************************/
/* RegisterTranslate() */
/*******************************************************************************************************/
BOOL           RegisterTranslate(      /* function to translate from value in register, to value used by API */
REGIDX         regidx,                 /* register index */
LONG           *data_out,              /* result (raw data translated to long) */
UCHAR  *raw_data)              /* input (raw data from hardware) */
{
  /* Function to translate raw data read from the hardware registers to data that */
  /* is usable by the application */

  /* clear the output */
  *data_out = 0L;

  switch(Register[regidx].regtype)
  {
    case  REGT_BITHL:
    {
      /* Latch -> this bit is latched hi, then immediately low */
      *data_out = (UCHAR)Register[regidx].hwmask[0];
      break;
    }
    case  REGT_BIT:
    {
      /* mask the bit, if zero, report False, else, True */
      *data_out = (LONG)((raw_data[0] & Register[regidx].hwmask[0]) == 0 ? False : True);
      break;
    }
    case  REGT_INVBIT:
    {
      /* INVERSE -> mask the bit, if zero, report True, else, False */
      *data_out = (LONG)((raw_data[0] & Register[regidx].hwmask[0]) == 0 ? True : False);
      break;
    }
    case  REGT_NULL:
    case  REGT_BYTE:
    {
      /* min 2 bits, max 8 bit.  Also, does not cross reg.address bounds */
      ULONG temp;

      /* mask useful bits from raw, shift rt (make range 0..2^bit_count) */
      temp = (LONG)(raw_data[0] & (UCHAR)Register[regidx].hwmask[0]);
      temp = (temp >> (Register[regidx].starting-(Register[regidx].bit_count-1)));
      *data_out = (UCHAR)temp;
      break;
    }
    case  REGT_MINT:
    {
      LONG  mint_val = 0L;

      mint_val = RegisterTranslateMint(raw_data,Register[regidx].hwmask);
      *data_out = mint_val;
      break;
    }
    default:
    {
      return(False);
      break;
    }
  }  /* switch(... */
  
  return(True);

}  /* RegisterTranslate() */


/*******************************************************************************************************/
/* RegisterDeTranslate() */
/*******************************************************************************************************/
BOOL           RegisterDeTranslate(    /* function to translate from API value to hardware value */
REGIDX         regidx,                 /* register index */
UCHAR  *data_out,              /* result (data bytes writable to hardware) */
ULONG  data_in)                /* input (ULONG used in driver) */
{
  /* Function to translate numeric data to raw data format that can be */
  /* written to the hardware register(s) */

  static union 
  {
    ULONG   ulTemp;
    UCHAR   c[sizeof(ULONG)];
  }u;

  /* be certain to initialize!!! */
  u.ulTemp = 0UL;

  switch(Register[regidx].regtype)
  {
    case  REGT_BIT:
    {
      /* mask the bit, if zero, report False, else, True */
      *data_out = (UCHAR)(data_in == (UCHAR)True ? (UCHAR)Register[regidx].hwmask[0] : (UCHAR)0x00U);
      break;
    }
    case  REGT_INVBIT:
    {
      /* INVERSE -> mask the bit, if zero, report True, else, False */
      *data_out = (UCHAR)(data_in == (UCHAR)True ? (UCHAR)0x00U : Register[regidx].hwmask[0]);
      break;
    }
    case  REGT_NULL:
    case  REGT_BYTE:
    {
      /* min 2 bits, max 8 bit.  Also, does not cross reg.address bounds */
      ULONG  temp;

      /* mask useful bits from raw, shift rt (make range 0..2^bit_count) */
	  temp = data_in & ( (0x01UL<<(Register[regidx].bit_count))-1UL );
      temp = (temp << (Register[regidx].starting-(Register[regidx].bit_count-1)));
      *data_out = (UCHAR)temp;
      break;
    }
    case  REGT_MINT:
    {
      LONG  temp;

      /* mint_val = RegisterTranslateMint(u.raw,Register[regidx].hwmask); */
      temp = RegisterTranslateFromMint(data_out,data_in,regidx);
      break;
    }
    case  REGT_BITHL:
    {
      /* do nothing for translation */
      break;
    }
    default:
    {
      return(False);
      break;
    }
  }  /* switch(... */
  
  
  return(True);

}  /* RegisterDeTranslate() */


/*******************************************************************************************************/
/* RegisterTranslateMint() */
/*******************************************************************************************************/
LONG           RegisterTranslateMint(  /* function to translate raw bytes to a MINT format */
UCHAR  *raw,                   /* raw data to use */
const CHAR     *mask)                  /* mask to translate raw data into */
{
  register UCHAR  j;       /* inner loop, force (ask) compiler to user register */
  register int   i;       /* outer loop, might help if this in register, too */

  ULONG  bit;             /* bit being worked on */
  int    count = 0;       /* count of bytes to process */
  ULONG  rtn = 0UL;       /* return value */

  /* count the number of hardware reg bytes that comprise the register in question */
  for ( count = 0; count < 5 ; count++)  
  {
    if (mask[count] == 0x00)  break;
  }

  /* walk Mint value from spread bits to expected compressed */
  for (i = 0 ; i < count ; i++)
  {
    for (j = 0x80 ; j != 0 ; j >>= 1)
    {
      if ((mask[i]&j) != 0)
      {
        bit = ((j&raw[i]) != 0 ? 1UL : 0UL);
        rtn = ((rtn<<1)|bit);
      }
    }
  }

  return((LONG)rtn);

}  /* RegisterTranslateMint() */