cx24143_regs.c

QPSK Tuner details, for conexant chipset.

/*******************************************************************************************************/
/* RegisterTranslateFromMint() */
/*******************************************************************************************************/
LONG           RegisterTranslateFromMint(     /* function to translate MINT format to raw data */
UCHAR  *raw_out,                      /* storage where translated data will be written */
ULONG  mint,                          /* MINT formatted data */
REGIDX         regidx)                        /* register id */
{
  register UCHAR j;        /* outer loop */
  register int  i;                 /* inner loop */
  
  int    byte_count;
  int    shifted = 0;      /* */
  const  CHAR    *mask = Register[regidx].hwmask;
  ULONG  lmask = 0x01UL << (Register[regidx].bit_count-1);

  /* count the bytes that comprise the mask, clear output */
  for (byte_count = 0 ; mask[byte_count] != 0 ; byte_count++);

  for (i = 0 ; i < byte_count ; i++)  raw_out[i] = CNULL;

  /* count bits in mask */
  for (i = 0 ; i < byte_count ; i++)
  {
    for (j = 0x80 ; j != 0 ; j>>= 1)
    {
      /* mask bits tell where actual bits can be placed */
      if ((mask[i]&j) != 0)
      {
        raw_out[i] |= (UCHAR)((mint&lmask) == 0UL ? 0 : j);
        lmask >>=1;
        shifted++;
      }
    }
  }
  

  /* at this point., mint passed by caller has not been masked, so mask it */
  return(RegisterTranslateMint(raw_out,mask));

}  /* RegisterTranslateFromMint() */


/*******************************************************************************************************/
/* RegisterVerifyMap() */
/*******************************************************************************************************/
BOOL  RegisterVerifyMap(               /* function to verify register map (run at start of driver) */
NIM   *nim)                            /* pointer to nim */
{
  /* performs initialization-time checking of register structure */
  int  i;
  static CHAR  *rvm_msg = "RegisterVerifyMap()";

  for (i = 0 ; i < CX24130_REG_COUNT ; i++)
  {
    /* test that index number matches the count */
    if (Register[i].reg_idx != (REGIDX)i)
    {
      /* read error reading hardware */
      _DRIVER_SetError(nim,REG_VERFY_IDX,rvm_msg,i);
      return(False);
    }

    /* test that address is within valid range */
    if (Register[i].addr > MAX_COBRA_ADDR)
    {
      /* read error reading hardware */
      _DRIVER_SetError(nim,REG_VERFY_ADDR,rvm_msg,i);
      return(False);
    }

    /* test that the various enum flags are valid */
    if (RegisterVerifyRegRW(nim,i) == False)  return(False);
    if (RegisterVerifyRegFilter(nim,i) == False)  return(False);
    if (RegisterVerifyRegDataType(nim,i) == False)  return(False);

    /* test that starting bit number is valid in conjunction with bit_count */
    if (RegisterVerifyRegBitCount(nim,i) == False)  return(False);

    /* test that default_value and testsetting are within the range of pow(2,bit-length) */
    if (RegisterVerifyRegDefault(nim,i) == False)  return(False);
  }

  return(True);

}  /* RegisterVerifyMap() */


/*******************************************************************************************************/
/* RegisterVerifyRegRW() */
/*******************************************************************************************************/
BOOL  RegisterVerifyRegRW(             /* function to verify register settings */
NIM   *nim,                            /* pointer to nim */
int   idx)                             /* register to test */
{
  static CHAR  *rvm_msg = "RegisterVerifyRegRW()";

  switch (Register[idx].regRW)
  {
    case  REG_RW:
    case  REG_RO:
    case  REG_WO:
    {
      /* above constitute valid values for regrw in reg.map */
      break;
    }
    case  REG_UNUSED:
    default:
    {
      /* invalid setting in reg.map, report to app */
      _DRIVER_SetError(nim,REG_VERFY_REGRW,rvm_msg,idx);
      return(False);
      break;
    }
  }  /* switch(... */

  return(True);

}  /* RegisterVerifyRegRW() */


/*******************************************************************************************************/
/* RegisterVerifyRegFilter() */
/*******************************************************************************************************/
BOOL  RegisterVerifyRegFilter(         /* function to verify reg.map filter setting */
NIM   *nim,                            /* pointer to nim */
int   idx)                             /* register to test */
{
  static CHAR  *rvm_msg = "RegisterVerifyRegFilter()";

  if ((Register[idx].regfilter&(REGF_COBRA|REGF_CAM_DEF|REGF_CAM_EXT|REGF_CAM_ONLY|REGF_CAM_RED|REGF_ZEROB6)) == 0)
  {
    /* invalid setting in reg.map, report to app */
    _DRIVER_SetError(nim,REG_VERFY_REGFLT,rvm_msg,idx);
    return(False);
  }

  return(True);

}  /* RegisterVerifyRegFilter() */


/*******************************************************************************************************/
/* RegisterVerifyRegDataType() */
/*******************************************************************************************************/
BOOL  RegisterVerifyRegDataType(       /* function to verify register data type value in reg.map */
NIM   *nim,                            /* pointer to nim */
int   idx)                             /* register to test */
{
  static CHAR  *rvm_msg = "RegisterVerifyRegDataType()";

  /* test data-type contained in reg.map against 1) valid type; 2) bit_count must be consistant */
  switch (Register[idx].regtype)
  {
    case  REGT_INT:
    case  REGT_UINT:
    case  REGT_LONG:
    case  REGT_ULONG:
    case  REGT_INVBIT:
    case  REGT_EOLIST:
    {
      /* above constitute valid values in reg.map */
      break;
    }
    case  REGT_MINT:
    {
      /* length must be > 8 */
      if (Register[idx].bit_count < 9)
      {
        _DRIVER_SetError(nim,REG_VERFY_DTLEN,rvm_msg,idx);
        return(False);
      }
      break;
    }
    case  REGT_BYTE:
    {
      /* length must be <= 8 */
      if (Register[idx].bit_count > 8)
      {
        _DRIVER_SetError(nim,REG_VERFY_DTLEN,rvm_msg,idx);
        return(False);
      }
      break;
    }
    case  REGT_BITHL:
    case  REGT_BIT:
    {
      /* length must be == 1 */
      if (Register[idx].bit_count != 1)
      {
        _DRIVER_SetError(nim,REG_VERFY_DTLEN,rvm_msg,idx);
        return(False);
      }
      break;
    }
    case  REGT_NULL:
    {
      /* perform no special tests on register designated as NULL */
      break;
    }
    default:
    {
      /* invalid setting in reg.map, report to app */
      _DRIVER_SetError(nim,REG_VERFY_REGDTP,rvm_msg,idx);
      return(False);
      break;
    }
  }  /* switch(... */

  return(True);

}  /* RegisterVerifyRegDataType() */


/*******************************************************************************************************/
/* RegisterVerifyRegDefault() */
/*******************************************************************************************************/
BOOL  RegisterVerifyRegDefault(        /* function to verify range of default setting in reg.map */
NIM   *nim,                            /* pointer to nim */
int   idx)                             /* register to test */
{
  static CHAR  *rvm_msg = "RegisterVerifyRegDefault()";
  ULONG  ulTemp;

  /* create max bit pattern to test against */
  ulTemp = (Register[idx].bit_count == 0 ? 0x01UL : (0x01UL<<Register[idx].bit_count));
  
  /* bitmap in l will be pow(2,bit_count)+1, so values below this are valid */
  if (Register[idx].default_value >= ulTemp && Register[idx].default_value != 0xffffffffUL)
  {
    if (Register[idx].regtype != REGT_NULL)