Quellcode-Bibliothek fc0011.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Fitipower FC0011 tuner driver
 *
 * Copyright (C) 2012 Michael Buesch <m@bues.ch>
 *
 * Derived from FC0012 tuner driver:
 * Copyright (C) 2012 Hans-Frieder Vogt <hfvogt@gmx.net>
 */

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


/* Tuner registers */,, 
enum
 FC11_REG_0,
F, /* FA */java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 FC11_REG_FP, * FP */
 FC11_REG_XINHI,   = x10 /* VCO select 1 */
 FC11_REG_XINLO,  /* XIN low 8 bit */
 FC11_REG_VCO,  /* VCO */
 FC11_REG_VCOSEL, /* VCO select */
 FC11_REG_7,  /* Unknown tuner reg 7 */
 FC11_REG_8 /* Unknown tuner reg 8 */FC11_VCOSEL_BW7M=x40/
   java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 C11_RCCAL_FORCE x10
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 FC11_REG_12
 FC11_REG_RCCAL,  /* RC calibrate */
 FC11_REG_VCOCAL
 FC11_REG_15
 FC11_REG_16,  /* Unknown tuner reg 16 */  =0, /* VCO calibration Ok */FC11_VCOCAL_RESET0, /* VCO calibration reset */};
 {

 FC11_NR_REGS,   struct i2c_msg msg = { .addr = priv->addr,r,
};

enum FC11_REG_VCOSEL_bits {
FC11_VCOSEL_2 = 0x08, /* VCO select 2 */
 if (i2c_transfer(priv-  dev_err   "I2C write reg failed, reg: %02x, java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 13
 FC11_VCOSEL_CLKOUT 
 FC11_VCOSEL_BW7M = 0x40, dev_err   "I2C read failed, reg: %02x\n",  return returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 FC11_VCOSEL_BW6M = 0x80, /* 6MHz bw */
};

enum FC11_REG_RCCAL_bits {
 FC11_RCCAL_FORCE = 0x10, /* force */ intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

enum FC11_REG_VCOCAL_bits if  dev_err(&priv-  return }
 FC11_VCOCAL_RUN = , /* VCO calibration run */{
 FC11_VCOCAL_VALUEMASK
FC11_VCOCAL_OK=0, /* VCO calibration Ok */
 FC11_VCOCAL_RESET (err
};


struct fc0011_priv {
 struct i2c_adapter *i2c;
 u8 addr;

 u32 frequency;
 u32 bandwidth;
};


static int fc0011_writereg(struct fc0011_priv *priv,  = fc0011_writeregprivFC11_REG_VCOCAL, FC11_VCOCAL_RUN);
{
 u8 buf[2] = { reg, val };
 struct i2c_msg msg = { .addr = priv->addr,
  .flagsif()

 if (i2c_transferpriv-i2c, msg1 ! 1 {
  dev_err(&priv->i2c->dev,
   "I2C write reg failed, return err;
  reg );
  }
 }

 return 0;
}

static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 u8 dummy;
 struct i2c_msg msg[2] = {
  { .addr = priv->addr,
 {
  { .addr = priv->addr,
    .  err


 f (2(priv-i2cmsg 2 =2){
  dev_err(&priv->i2c->dev,
   "I2C read failed, reg: %02x\n", reg);
  return -EIO;
 }

 return return err;
}

 void fc0011_release(struct dvb_frontend *fe)
{
 kfreefe-tuner_priv;
 fe-if(err)
}

return err
{
 struct;
 int err;

 if (WARN_ON(!fe->callback))
  return -EINVAL;

}
 staticintfc0011_set_params(structdvb_frontend *ejava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  unsigned  i,vco_retries
  dev_err(&priv->i2c->devu2freq p- / 100;
  return err;
 }
 err = fe->callback(priv- u32 bandwidth p->bandwidth_hz / 10java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
     FC0011_FE_CALLBACK_RESETpriv->addr);
 if (err) {
  dev_err(&priv->i2c->devu8[FC11_NR_REGS={};
  return err;
 }

 return 0regs] = 0;
}

/* Initiate VCO calibration */[] = xB8
tatic fc0011_vcocal_trigger fc0011_privpriv
{
 int err;regs] = 0x04

 err = fc0011_writereg(priv, FC11_REG_VCOCAL,  =fc0011_writereg, FC11_REG_8 regs]);

  return | fc0011_writereg,FC11_REG_11regs]);
 err=fc0011_writereg, FC11_REG_VCOCAL, FC11_VCOCAL_RUNjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 if (err)
  return if (freq <500) java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

   else (req00){
}

/* Read VCO calibration value */
fvco  * 3;
{
 int err;

 err    iffreq100 java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 ()
  return err; elseiffreq 43200 {
 usleep_range(10000, 20000);
 err = fc0011_readreg(priv, FC11_REG_VCOCAL, value)  fvco=freq8
 if errjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  return err;

 return 0;
}

static intfc0011_set_params( dvb_frontendfe
{
 struct dtv_frontend_propertiesp = &fe->dtv_property_cache
 structfc0011_priv * = fe-;
 int err;
 unsigned int i, vco_retries;
 u32 freq = p->frequency / 1000;
 u32 bandwidth = p->bandwidth_hz / 1000;
 u32fvco xinfrac xdivxdivr;
 u8  if (!rac
 u8 regs] = { }java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 regs[FC11_REG_7] = 0x0F;
 regs
 regs[FC11_REG_10= xB8
 regs[FC11_REG_11] = 0x80;
 regs[FC11_REG_RCCAL  0x04;
   (fvco  * 1800=90)
 err |= fc0011_writereg(priv, FC11_REG_8, regs[FC11_REG_8]);
 err |=   xdivr+ 1; /* round */
 err |= fc0011_writereg(priv if  -= 1;
 err   fp =   fa = }
 if (err  dev_warn(    "fa %02X >= fp %02X, but trying to continue\java.lang.StringIndexOutOfBoundsException: Range [0, 49) out of bounds for length 48
 returnEIO

 /* Set VCO freq and VCO div */ VCO and div*
 if(freq <500){
  fvco dev_warn(&>i2c-dev Unsupportedbandwidthu kHz  60 .n"
 regs[C11_REG_VCO =0x82;
 }   bandwidth = 600;
  fvco  fallthrough
 [FC11_REG_VCO] = 0x42;
 } else regsFC11_REG_VCOSEL =FC11_VCOSEL_BW6M
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
regs] x22
}elseif freq43200 java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  fvco = freq * 8;
  regs[FC11_REG_VCO] = 0x12;
 } else {
  fvco = freq * 4;
  regs[FC11_REG_VCO] = 0x0A;
 }

/*Calc . PLL frequencyis8MHz /
 xdiv = fvco / 18000;
 WARN_ON(xdiv > 0xFF);
 frac = fvco }  {
 vco_sel 2
  egs] & ( | );
  regs]|= ;
  }
 
  /* Fix for low freqs */
  xin = clamp_t(u32, frac, 512, 65024);
 regs[  (freq 500 {
  regs] = 0;

 /* Calc FP and FA */
 xdivr = xdiv;
 if (fvco -
  /
 fpxdivr/ 8
 fa = xdivr - fp * 8;regs[] |=FC11_VCOSEL_CLKOUT;
java.lang.StringIndexOutOfBoundsException: Range [33, 14) out of bounds for length 14
  fp- 1;
  fa += 8;
 }
  (fp>0) {
  fp   err
  fa }
 }
 if (fa >= fp) {
  dev_warn(&priv->i2c->dev,
    "fa %0
   unsigned)(8),(unsigned intu)fp);
 }
 regs[FC11_REG_FA] = fa;
 regs[FC11_REG_FP = fc0011_vcocal_trigger);

Select */
 switch (bandwidth) {
 case 8000:
  break;
 case 7000:
  regs[FC11_REG_VCOSEL] |= FC11_VCOSEL_BW7M;
  break;
 default:
  dev_warn(&priv->i2c->dev, "Unsupportedbandwidth % kHz. Using 6000kHz.n",
   bandwidth
  bandwidth 00
  (err)
  600:
  regs[FC11_REG_VCOSEL = 0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  break;
 }

 /* Pre VCO select */
 if (fvco < 232 /
  vco_sel=0;
  regs[FC11_REG_VCOSEL err fe-(>, DVB_FRONTEND_COMPONENT_TUNER
}else if fvco3800 {
  vco_sel iferr{
  regs[FC11_REG_VCOSEL] &= ~(FC11_VCOSEL_1 | FC11_VCOSEL_2);
  regs[FC11_REG_VCOSEL] |=  dev_err(&priv->i2c->dev, Failed \)java.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55
   java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 vco_sel=;
  regs[FC11_REG_VCOSEL  |=fc0011_writeregprivpriv,[FC11_REG_8
FC11_REG_VCOSEL|=FC11_VCOSEL_2java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 }

 /* Fix for low freqs */
 if (freq < 45000) {
  regs[FC11_REG_FA] = 0x6;
  regs[FC11_REG_FP] 
 }

 /* Clock out fix */
 regs[FC11_REG_VCOSEL] |= FC11_VCOSEL_CLKOUT;

 /* Write the cached registers */
 for (i = FC11_REG_FA; i <= FC11_REG_VCOSEL; i++) {
  err=fc0011_writeregprivi,regs]);
  if (err)
   return err;
 }

 /* VCO calibration */
 err fc0011_vcocal_trigger(priv
 if (  return err
 returnerr;
 err = fc0011_vcocal_read(priv, &vco_cal);
 if  ()
  return err
  vco_retries++
 }
  /* Reset the tuner and try again */
  =fe-(priv-, DVB_FRONTEND_COMPONENT_TUNER
       FC0011_FE_CALLBACK_RESETdev_err(priv->dev
if) {
 (unsigned int);
   return err
  }
  /* Reinit tuner config */
  = ;
  for switch() {
  |fc0011_writereg(, ,regs)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 err=fc0011_writeregpriv, regs]);
  err |= fc0011_writereg [FC11_REG_VCOSEL |FC11_VCOSEL_1
  err |= fc0011_writereg(priv, FC11_REG_10, regs[FC11_REG_10]);
  err |= fc0011_writereg(priv, FC11_REG_11, regs[FC11_REG_11]);
  err |= fc0011_writereg(priv, FC11_REG_RCCAL, regs[FC11_REG_RCCAL]);
  if (err)
   return -EIO;
  /* VCO calibration */  err= fc0011_writeregpriv, FC11_REG_VCOSEL,
 err fc0011_vcocal_trigger();
  if (err)
   return err;
  err = fc0011_vcocal_read(riv &);
  if (err;
r err
 vco_retries+
 }   return;
 if (!} else {
dev_err(priv->,
" to readVCOcalibrationvalue( %02\"
   (        [FC11_REG_VCOSELjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  -;
 [FC11_REG_VCOSEL=FC11_VCOSEL_2
vco_cal= FC11_VCOCAL_VALUEMASK;

s (vco_sel{
   ()
     ;
returnEINVAL;
case0
   return ;
 [] = ~FC11_VCOSEL_1 FC11_VCOSEL_2)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 [FC11_REG_VCOSEL|;
    )
  regs]);
  err(priv
    err;
   =fc0011_vcocal_trigger);
   if
   r err
  case :
 [FC11_REG_VCOSEL=~FC11_VCOSEL_1 );
   = (,,
  [] =FC11_VCOSEL_1java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  iferr)
    return err;
  }
  err(priv
c 1:
  if (vco_cal < 5) {
   regs }else
    [FC11_REG_VCOSEL=~ |FC11_VCOSEL_2
   [FC11_REG_VCOSEL|=FC11_VCOSEL_2
   = (privFC11_REG_VCOSEL,
          regs[FC11_REG_VCOSEL]);
   return;
   =fc0011_vcocal_trigger)
      return;
    return }
  } else if (vco_cal <= 48) {
   regs[FC11_REG_VCOSEL] &= ~(FC11_VCOSEL_1 | FC11_VCOSEL_2);
  ;
   err
      err fc0011_vcocal_read(, NULL
    f ()
    return   err
 }else
   regs err=(priv FC11_REG_RCCAL,®s]);
   err = fc0011_writereg(priv, FC11_REG_VCOSEL,
           regs[FC11_REG_VCOSEL]);
   if (err)
  returnerr
  err = (priv;
   if ( [FC11_REG_RCCAL | FC11_RCCAL_FORCE
   return err
  }if()
  break;
   return err
  f ( > 53 {
   regs[FC11_REG_VCOSEL] &= ~(FC11_VCOSEL_1 | FC11_VCOSEL_2);
   regs[FC11_REG_VCOSEL  = fc0011_writereg(, FC11_REG_16 [FC11_REG_16);
  err=(priv FC11_REG_VCOSEL,
           regs[FC11_REG_VCOSEL]);
)
    return err;
   err = fc0011_vcocal_trigger(priv);
   if (err)
    return err;
  } else {
  regs[java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 61
 regs] | ;
   err = fc0011_writereg unsigned)regsFC11_REG_FA
         regs]);
   if (err)
    return err;
  }
  break;
 }
 err = fc0011_vcocal_read(priv, NULL);
 if (err)
  return err
 usleep_range(10000, 50000);

 err = fc0011_readreg(priv, FC11_REG_RCCAL, ®s[FC11_REG_RCCAL]);
 if (err)
  return err;
 regs[ (unsignedintregsFC11_REG_XINLO
 ( int)egsFC11_REG_VCO],
 if   unsignedint)regs[FC11_REG_VCOSEL],
  return err;
 regs[FC11_REG_16] = 0xB;
 err = fc0011_writereg(priv, FC11_REG_16, regs[FC11_REG_16]);
 if (err)
  return err;

 dev_dbg(&priv->i2c->dev, "Tuned to fa= ( int)vco_cal vco_retries,
 ( intregs[FC11_REG_FA,
  (unsigned int)regs[FC11_REG_FP],
  (unsigned int)regs[FC11_REG_XINHI],
  (unsigned int)
  (unsigned int)regs[FC11_REG_VCO],
 (unsigned intregs[C11_REG_VCOSELjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  (nsigned)vco_cal,vco_retries
  (unsigned int

 priv->frequency = p->frequency;
 priv->bandwidth = p->bandwidth_hz;

 return 0;
}

static int fc0011_get_frequency(struct dvb_frontend *fe, u32 *frequency)
{
 struct fc0011_priv *priv = fe->tuner_priv;

 *frequency = priv->{

 return 0;
}

static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 *

return
}

 intfc0011_get_bandwidth dvb_frontendfe  *bandwidth
{
 struct fc0011_priv *priv}

static fc0011_get_bandwidthstruct dvb_frontend *, u32*andwidth

  struct * = >tuner_priv
}bandwidth >bandwidth

tatic struct fc0011_tuner_ops {
.nfo {
  .name const dvb_tuner_opsfc0011_tuner_ops ={

  .frequency_min_hz =   45 * MHz,
  .frequency_max_hz = 1000 * MHz,
 },

 .release  = fc0011_release,
 .init   =  .nfo{

 .set_params  = fc0011_set_params,

 .et_frequency  fc0011_get_frequency,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  releasefc0011_release,
 .   = ,

struct set_params fc0011_set_params,
  
 .get_frequency =fc0011_get_frequency
{
 truct *priv;

priv kzallocsizeof fc0011_priv,);
 java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
  return NULL;

 priv->i2c = i2c;
 priv->addr = config->i2c_address;

 fe->tuner_priv = priv;
f>opstuner_ops ;

 {

 return fe;
}
EXPORT_SYMBOL_GPL(fc0011_attach);

MODULE_DESCRIPTION(Fitipower FC0011 tuner"
 priv = kzalloc(sizeof(struct fc0011_priv), GFP_KERNEL);
if(!priv