hamaro_cx24128.c

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

/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_GetPLLFrequency() 
 * returns current frequency. programmed into the tuner pll register 
 *******************************************************************************************************/
BOOL           
HAMARO_TUNER_CX24128_GetPLLFrequency(HAMARO_NIM            *p_nim,     /* pointer to nim */
                              unsigned long  *p_pllfreq) /* pointer to unsigned long where pll frequency.*/ 
                                                         /* in Hz. will be returned */
{
	unsigned short nvalue; /* Returned N value */
	/*unsigned long*/int  fvalue; 
	signed long    fvalue_signed;
	unsigned long  Nfrac;
  HAMARO_RDIVVAL        R;
  HAMARO_VCODIV         vcodiv;

	HAMARO_BCDNO bcd;

	/* test for valid nim */
	HAMARO_TUNER_CX24128_VALIDATE(p_nim);

	if (p_pllfreq == 0)
	{
		HAMARO_DRIVER_SET_ERROR(p_nim, HAMARO_BAD_PARM);
		return(False);
	}

	/* save last n,a,r settings */
	nvalue = (unsigned short)p_nim->tuner.cx24128.N; 
	fvalue = p_nim->tuner.cx24128.F;

	fvalue_signed = (signed long)(fvalue);

    R = p_nim->tuner.cx24128.R;
    vcodiv = p_nim->tuner.cx24128.vcodiv;

	/* catch any div by zero errors */
	if ((R != 0UL) && (vcodiv != 0UL))
	{
		/*
			The frequency can be calculated from the crystal frequency and divider settings as follows:

			FLO = [2 * Nfrac * (Fxtal/R)]/D

			,where R = reference divider setting (either 1 or 2)
			D = LO divider setting (either 2 or 4)
			Fxtal = actual crystal frequency
			Nfrac = total fractional divide ratio and can be calculated from
			Nfrac = (Dividend/262144) + Nreg + 32

			where, Dividend = DSM setting 18-bit signed value (between +/-131072)
			Nreg = 9-bit divider setting
		*/
		/* multiplication factor of 10000 is used to improve precision */
		Nfrac = ( (fvalue_signed * 10000L) / HAMARO_CX24128_DIVIDER) + (nvalue * 10000UL) + (32UL * 10000UL);
		HAMARO_BCD_set (&bcd, (p_nim->tuner_crystal_freq / R));

		HAMARO_BCD_mult(&bcd, Nfrac);
		HAMARO_BCD_mult(&bcd, 2);
		HAMARO_BCD_div (&bcd, 10000);
		HAMARO_BCD_div (&bcd, vcodiv);
    		if ((p_nim->tuner_crystal_freq) / HAMARO_MM >= 20)
		{
			HAMARO_BCD_mult(&bcd, 2);
		}

		*p_pllfreq = HAMARO_BCD_out(&bcd); 
	}
	else
	{
		HAMARO_DRIVER_SET_ERROR(p_nim,HAMARO_BAD_DIV);
		return(False);
	}
    return(True);
}/* HAMARO_TUNER_CX24128_GetPLLFrequency() */

/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_pll_status
 * reads current tuner pll lock status 
 *******************************************************************************************************/
BOOL  
HAMARO_TUNER_CX24128_pll_status(HAMARO_NIM  *p_nim,    /* nim pointer */
                               BOOL       *p_locked) /* BOOL pointer, where tuner pll lock status is returned */
{
  unsigned long  reg_value = 0;

    if(HAMARO_CX24128_refresh_tuner_pll_lock == True)
	{
		/* read the tuner register to get tuner pll lock status */
		if(HAMARO_RegisterRead(p_nim, HAMARO_CX24128_LOCK_DET, &reg_value, p_nim->tuner.cx24128.io_method) != True)  
		{
			return(False);
		}
	             
		if (reg_value == 0UL)  
		{
			*p_locked = False;
			HAMARO_CX24128_tuner_pll_lock = False;
		}
		else  
		{
			*p_locked = True;
			HAMARO_CX24128_tuner_pll_lock = True;
		}
		HAMARO_CX24128_refresh_tuner_pll_lock = False;
		
	}
	else
	{		
		*p_locked = HAMARO_CX24128_tuner_pll_lock;
	}

	return(True);
}  /* HAMARO_TUNER_CX24128_pll_status() */

/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_calc_pllNF()  
 * function to calc pll settings (n,f) using bcd functions.
 * input is the specified pll frequency, output is N, F values to be set
 * to tuner and nim.
 *******************************************************************************************************/
BOOL 
HAMARO_TUNER_CX24128_calc_pllNF(HAMARO_NIM *p_nim,        /* nim pointer */
                         unsigned short *nvalue, /* Returned N value. */
                         int  *fvalue) /* Returned F value. */
{
  long           N;
  long           F;
  HAMARO_RDIVVAL        R;
  HAMARO_VCODIV         vcodiv;
  HAMARO_BCDNO          bcd;
  unsigned char  factor;
     unsigned char reg_value;

  /* set frequency to a default setting, if not presently set, test xtal for zero before divide. */
  if (p_nim->pll_frequency == 0UL)  p_nim->pll_frequency = HAMARO_NIM_DEFAULT_FREQ;
  if (p_nim->tuner_crystal_freq == 0UL)  p_nim->tuner_crystal_freq = HAMARO_NIM_DEFAULT_XTAL;

  if ((p_nim->tuner_crystal_freq) /HAMARO_MM < 20)
  {
    factor = 1;
  }
  else
  {
    factor = 2;
  }

	/* Set lo divider to tuner and nim. */
	if (p_nim->tuner_type == HAMARO_CX24113)
	{
		if (((p_nim->pll_frequency) / HAMARO_MM) >= HAMARO_CX24113_LO_DIV_BREAKPOINT)
		{
			vcodiv = HAMARO_VCODIV2;
			if (HAMARO_TUNER_CX24128_SetVcoDivider(p_nim,vcodiv) != True) return(False);
		}
		else
		{
			vcodiv = HAMARO_VCODIV4;
			if (HAMARO_TUNER_CX24128_SetVcoDivider(p_nim,vcodiv) != True) return(False);
		}
	}
	else
	{
		if (((p_nim->pll_frequency) / HAMARO_MM) >= HAMARO_CX24128_LO_DIV_BREAKPOINT)
		{
			vcodiv = HAMARO_VCODIV2;
			if (HAMARO_TUNER_CX24128_SetVcoDivider(p_nim,vcodiv) != True) return(False);
		}
		else
		{
			vcodiv = HAMARO_VCODIV4;
			if (HAMARO_TUNER_CX24128_SetVcoDivider(p_nim,vcodiv) != True) return(False);
		}
	}  

  /* Set reference divider to nim. */
  HAMARO_TUNER_CX24128_SetReferenceDivider(p_nim,HAMARO_RDIV_1);

  R = p_nim->tuner.cx24128.R;

  /* calculate tuner PLL settings: */
  /* Calculate N first. No need to use BCD functions. */  
  N = (p_nim->pll_frequency / 100UL * vcodiv) * R;
  N /= ((p_nim->tuner_crystal_freq /HAMARO_M * factor) * 2UL);
  N += 5UL;     /* For round up. */
  N /= 10UL;
  N -= 32UL;

  /* N has to be >= than 6. */
  if (N < 6)
  {
    /* Set reference divider to nim. */
    HAMARO_TUNER_CX24128_SetReferenceDivider(p_nim,HAMARO_RDIV_2);

    R = p_nim->tuner.cx24128.R;

    /* Calculate N again. No need to use BCD functions. */  
    N = (p_nim->pll_frequency * vcodiv / 100UL) * R;
    N /= ((p_nim->tuner_crystal_freq * factor / HAMARO_M) * 2UL);
    N += 5UL;     /* For round up. */
    N /= 10UL;
    N -= 32UL;

    if (N < 6)
    {
      return(False);
    }
  }

  /* Now calculate F. */
  HAMARO_BCD_set(&bcd,p_nim->pll_frequency);
  HAMARO_BCD_mult(&bcd,((unsigned long)R * (unsigned long)vcodiv * HAMARO_CX24128_DIVIDER));
  HAMARO_BCD_div(&bcd,(p_nim->tuner_crystal_freq * factor * 2UL));
  F = HAMARO_BCD_out(&bcd);
  F -= (N + 32) * HAMARO_CX24128_DIVIDER;

  if (HAMARO_FWindowEnable == True)
  {
    if (F > (HAMARO_CX24128_DIVIDER / 2 - HAMARO_CX24128_F_SIDE_WINDOW))
    {
      F = HAMARO_CX24128_DIVIDER / 2 - HAMARO_CX24128_F_SIDE_WINDOW;
    }
    if (F < (-HAMARO_CX24128_DIVIDER / 2 + HAMARO_CX24128_F_SIDE_WINDOW))
    {
      F = -HAMARO_CX24128_DIVIDER / 2 + HAMARO_CX24128_F_SIDE_WINDOW;
    }
    if ((F < HAMARO_CX24128_F_0_WINDOW && F > 0)|| (F > -HAMARO_CX24128_F_0_WINDOW && F < 0))
    {
      F = 0;
         F = 0;
         /* Enable ps_test mode. */
	  /* read 0x10, set 0x10[6] to 1 */
	  if(HAMARO_TunerRegisterRead(p_nim, (unsigned short)(0x10), (unsigned long*)&reg_value, HAMARO_IO_UNKNOWN) != True)  
         {
            return(False);
         }
         reg_value |= 0x40;
         if(HAMARO_TunerRegisterWrite(p_nim, (unsigned short)(0x10), (unsigned long)reg_value, HAMARO_IO_UNKNOWN) != True)  
            return(False);    }
  }

  *nvalue = (unsigned short)N;
  *fvalue = (int)F;

  p_nim->tuner.cx24128.N = *nvalue; 
  p_nim->tuner.cx24128.F = *fvalue; 

  return(True);
}  /* HAMARO_TUNER_CX24128_calc_pllNF() */

/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_calculateNFR() - GUI only
 * function to calc pll settings (n,f) using bcd functions 
 * input is the specified frequency and specified R value, the output is
 * N, F values to be displayed in GUI.
 *******************************************************************************************************/
BOOL           
HAMARO_TUNER_CX24128_CalculateNFR(HAMARO_NIM            *p_nim,   /* nim pointer */
                           unsigned long  Fdesired, /* desired frequency */
                           HAMARO_RDIVVAL        R,        /* input R value */
                           unsigned int   *nvalue,  /* returned N value */
                           long           *fvalue)  /* returned F value */
{
  unsigned long  N;
  long           F;
  unsigned long  vcodiv;
  unsigned char  factor;
  HAMARO_BCDNO          bcd;

  if ((p_nim->tuner_crystal_freq / HAMARO_MM) < 20)
  {
    factor = 1;
  }
  else
  {
    factor =2;
  }

	if (p_nim->tuner_type == HAMARO_CX24113)
	{
		if ((Fdesired / HAMARO_MM) >= HAMARO_CX24113_LO_DIV_BREAKPOINT)
		{
			vcodiv = 2;
		}
		else
		{
			vcodiv = 4;
		}
	}
	else
	{
		if ((Fdesired / HAMARO_MM) >= HAMARO_CX24128_LO_DIV_BREAKPOINT)
		{
			vcodiv = 2;
		}
		else
		{
			vcodiv = 4;
		}
	}

  /* Calculate N first. No need to use BCD functions. */  
  N = (Fdesired * R / 100UL) * vcodiv;
  N /= ((p_nim->tuner_crystal_freq * factor / HAMARO_M) * 2UL);
  N += 5UL;     /* For round up. */
  N /= 10UL;
  N -= 32UL;

  /* Now calculate F. */
  HAMARO_BCD_set(&bcd,Fdesired);

  HAMARO_BCD_mult(&bcd,(vcodiv * R * HAMARO_CX24128_DIVIDER));
  HAMARO_BCD_div(&bcd,(p_nim->tuner_crystal_freq * factor * 2UL));

  F = HAMARO_BCD_out(&bcd);
  F -= (N + 32) * HAMARO_CX24128_DIVIDER;

  // if (HAMARO_FWindowEnable == True)
  {
    if (F > (HAMARO_CX24128_DIVIDER / 2 - HAMARO_CX24128_F_SIDE_WINDOW))
    {
      F = HAMARO_CX24128_DIVIDER / 2 - 1;
    }
    if (F < (-HAMARO_CX24128_DIVIDER / 2 + HAMARO_CX24128_F_SIDE_WINDOW))
    {
      F = -HAMARO_CX24128_DIVIDER / 2;
    }
    if ((F < HAMARO_CX24128_F_0_WINDOW && F > 0)|| (F > -HAMARO_CX24128_F_0_WINDOW && F < 0))
    {
      F = 0;
    }
  }

  *nvalue = (unsigned short)N;
  *fvalue = F;

  return(True);
}  /* HAMARO_TUNER_CX24128_CalculateNFR() */

/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_validate() 
 * performs nim and other validation prior to tuner operations 
 *******************************************************************************************************/
#if HAMARO_INCLUDE_DEBUG
BOOL  HAMARO_TUNER_CX24128_validate(HAMARO_NIM   *p_nim)  /* pointer to nim */ 
{
  if (p_nim == 0)
  {
    HAMARO_DRIVER_SET_ERROR(p_nim,HAMARO_NIM_NULL);
    return(False);
  }

  /* validate that the tuner-type is valid */
  if (p_nim->tuner_type == HAMARO_CX24128 || p_nim->tuner_type == HAMARO_CX24113)  
  {
	  return(True);
  }

  /* tuner setting not supported */
  HAMARO_DRIVER_SET_ERROR(p_nim,HAMARO_NOTSUPPORT);

  return(False);
}  /* HAMARO_TUNER_CX24128_validate() */
#endif /* HAMARO_INCLUDE_DEBUG */

#endif

/* CR 9509 : Add an extra newline */