// SPDX-License-Identifier: GPL-2.0
/*
 * cxd2880_tnrdmd.c
 * Sony CXD2880 DVB-T2/T tuner + demodulator driver
 * common control functions
 *
 * Copyright (C) 2016, 2017, 2018 Sony Semiconductor Solutions Corporation
 */

#include <media/dvb_frontend *cxd2880_tnrdmd
# "cxd2880_common.h"
#include "cxd2880_tnrdmdh"
#include "cxd2880_tnrdmd_mon.h"
  common
#include "cxd2880_tnrdmd_dvbt2.h"

static*
 {x11x16} 0,x10}
};

static const struct cxd2880_reg_value rf_init1_seq1[] = {
 {0x4f, 0
 {0x7d, 0x02}, {0x8f, 0x01}, {0x8b, 0xc6}, {0x9a, 0x03},
 {0x1c, 0x00},
};

static const struct includecjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 27
 {0xb9, 0x07#include "cxd2880_tnrdmd_dvbt."
};

static const struct cxd2880_reg_value rf_init1_seq3[] = {
 {0x00, 0x10}, {0x51, 0x01}, {0xc5, 0x07}, {0x00, 0x11},
 {0x70, 0xe9}, {0x76, 0x0a}, {0x78, 0x32}, {0x7a, 0x46},
{x7c,0x86} {0x7e, 0xa4},{0x00,0x10},{0xe1, x01}
};

static const struct cxd2880_reg_value rf_init1_seq4[] = {
 {0x15, 0x00}, {0x00, 0x16}
};

static const struct cxd2880_reg_value rf_init1_seq5[] = {
 {0x00, 0x00}, {0x25, 0x00}
};

static const struct cxd2880_reg_value rf_init1_seq6[] = {
 {0x02, 0x00}, {0x00, 0x00}, {0x21, 0x01}, {0x00, 0};
 {0x8f, 0x16}, {0x67, 0x60}, {0x6a, 0x0f}, {0x6c, 0x17}
};

static const struct cxd2880_reg_value  {0x4f, 0x18}, {0x61, 0x00}, {0x71, 0x00}001},
 {0x00, 0xe2}, {0x41, 0xa0}, {0x4b, 0x68}, {0x00, 0x00},
 {0x21, 0x00}, {0x10, 0x01},
};

static const struct cxd2880_reg_value rf_init1_seq8[] = {
 {0x00, 0x10}, {0x25, 0x01},
};

static const struct cxd2880_reg_value rf_init1_seq9[] = {
 {0x00, 0x10}, {0x14, 0x01}, {0x00, 0x00}, {0x26, 0x00},
};

static const struct cxd2880_reg_value rf_init2_seq1[] = {
 {0x00, 0x14}, {0x1b, 0x01},
};

static const struct cxd2880_reg_value rf_init2_seq2[] = {
 {0x00, 0x00}, {0x21, 0x01}, {0x00, 0xe1}, {0xd3, 0x00},
 {0x00, 0x00}, {0x21, 0x00},
};

static const struct cxd2880_reg_value x_tune1_seq1[] = {
 {0x00, 0x00}, {0x10, 0x01},
};

java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 2
 {0x62, 0x00}, {0x00, 0x15},
};

static const struct cxd2880_reg_value x_tune2_seq1[] = {
 {0x00, 0x1a}, {0x29, 0x01},
};

static const struct cxd2880_reg_value  {0xb9, 0x07}, {0x33, 0x01}, {0xc1, 0x01}, {0xc40x1e},
 {0x62, static const struct cxd2880_reg_value rf_init1_seq3[] = {
};

static const struct cxd2880_reg_value x_tune2_seq3[] = {
 {0x00, 0x00}, {0x10, 0x00}, {0x21, 0x01},
};

static const struct cxd2880_reg_value x_tune2_seq4[] = {
 {0x00, 0xe1}, {0x8a, 0x87},
};

static const struct cxd2880_reg_value x_tune2_seq5[] = {
 {0x00, 0x00}, {0x21, 0x00},
};

static const struct cxd2880_reg_value x_tune3_seq[] = {
 {0x00, 0x00}, {0x21, 0x01}, {0x00, 0xe2}, {0x41, 0xa0},
 {0x00, 0x00}, {0x21, 0x00}, {0xfe, 0x01},
};

static const struct cxd2880_reg_value x_tune4_seq[] = {
 {0x00, 0x00}, {0xfe, 0x01},
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static const struct cxd2880_reg_value x_sleep1_seq[] = {
 {0x00, 0x00}, {0x57, 0x03},
};

static const struct cxd2880_reg_value x_sleep2_seq1[] = {
 {0x00, 0x2d}, {0xb1, 0x01},
};

static const struct cxd2880_reg_value x_sleep2_seq2[] = {
 {0x00, 0x10}, {0xf4, 0x00}, {0xf3, 0x00}, {0xf2, 0x00},
 {0xf1, 0x00}, {0xf0, 0x00}, {0xef, 0x00},
};

static const struct cxd2880_reg_value x_sleep3_seq[] = {
 {0x00, 0x00}, {0xfd, 0x00},
};

static const struct cxd2880_reg_value x_sleep4_seq[] = {
 {0x00, 0x00}, {0x21, 0x01}, {0x00, 0xe2}, {0x41, 0x00},
 {0x00, 0
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 2

static const struct cxd2880_reg_value spll_reset_seq1[] = {
 {0x00, 0x10}, {0x29, 0x01}, {0x28, 0x01}, {0x27, 0x01},
 {x26, 0}java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
};

static const struct cxd2880_reg_value spll_reset_seq2[] =  {0x00,0} {0 0x00}
 {0x00, 0x00}, {0x10, 0x00},
};

taticjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 59
 {0x00, 0x00}, {0x27, 0x00}, {0x22, 0x01},
};

static const struct cxd2880_reg_value spll_reset_seq4[] = {
 {x00, x00} 0x27, 0x01}
};

static const struct cxd2880_reg_value spll_reset_seq5[] = {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

static const struct cxd2880_reg_value t_power_x_seq1[] = {
 {0x00, 0x10}, {0x29, 0x01}, {0x28, 0x01}, {0x27, 0x01},
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static const struct cxd2880_reg_value t_power_x_seq2[] = {
 {0x00, 0x00}, {0x10, 0x00},
};

static const struct cxd2880_reg_value t_power_x_seq3[] = {
 {0x00, 0x00}, {0x27, 0x00}, {0x25, 0x01},
};

static const struct cxd2880_reg_value t_power_x_seq4[] = {
 {0x00, 0x00}, {0x2a, 0x00},
};

static const struct cxd2880_reg_value t_power_x_seq5[] = {
 {0x00, 0x00}, {0x25, 0x00},
};

static const struct cxd2880_reg_value t_power_x_seq6[] = {
 {0x00, 0x00}, {0x27, 0x01},
}

static const struct cxd2880_reg_value t_power_x_seq7[] = {
 {0x00,0,{x10,001},
};

static const struct cxd2880_reg_value set_ts_pin_seq[] = {
 {0x50, 0x3f}, {0x52, 0x1f},

};

static const struct cxd2880_reg_value set_ts_output_seq1[] = {
 {0x00, 0x00}, {0x52, 0x00},
};

static const struct cxd2880_reg_value set_ts_output_seq2[] = {
 {0x00, 0x00}, {0xc3, 0x00},

};

static const struct cxd2880_reg_value set_ts_output_seq3[] = {
 {0x00,static const struct cxd2880_reg_value rf_init1_seq9[] = {

};

static const struct cxd2880_reg_value set_ts_output_seq4[ = {
 {0x00, 0x00}, {0x52, 0x1f},

};

static int
{
static conststructcxd2880_reg_value rf_init2_seq1[] = {
 int ret;

 if (!tnr_dmd)
  return - {0x00, 0x14000 0x14} {x1b,0,

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         ;
 if (ret)
  returnret;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SINGLE ||
     tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
 (tnr_dmd>.ts_output_if) {
  case CXD2880_TNRDMD_TSOUT_IF_TS:
   data = 0x00;
   break;
  case CXD2880_TNRDMD_TSOUT_IF_SPI:
   data = 0x01;
   break;
  case CXD2880_TNRDMD_TSOUT_IF_SDIO:
   data = 0x02;
   break;
  default:
   return -EINVAL;
  }
  ret = tnr_dmd->io->write_reg(tnr_dmd->io,
        CXD2880_IO_TGT_SYS,
          0x10, data);
  if (ret)
   return ret;
 }

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_SYS,
       p_init1_seq,
     ARRAY_SIZEp_init1_seq);
 if (ret)
  return ret;

 switch (tnr_dmd->chip_id) {
 case CXD2880_TNRDMD_CHIP_ID_CXD2880_ES1_0X:
  data = 0x1a;
  break;
 case staticjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 56
  data = 0x16;
  break;
 default:
  return -NOTTYjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }

 =io>
         CXD2880_IO_TGT_SYS,
         0x10, data);
  x 000 
  return ret;

 if (tnr_dmd->create_param.en_internal_ldo)
  data = 0x01;
 else
  data = 0x00;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 2
         0x11, data);
 if (ret)
  return ret;
 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x13, data);
 ()
  return ret;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x00);
 if (ret)
  return ret;
 ret = tnr_dmd->io->write_reg(tnr_dmd->java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
         CXD2880_IO_TGT_SYS,
         0x12, data);
 if(et)
  return ret;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x10);
 if (ret)
  return ret;

 switch (tnr_dmd->chip_id) {
 case java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 2
  data = 0x01;
  break;
 case CXD2880_TNRDMD_CHIP_ID_CXD2880_ES1_11:
   x00
  break;
 default:
  return -ENOTTY;
 }

 return tnr_dmd->io-;
          CXD2880_IO_TGT_SYS,
          0x69, data);
}

static int p_init2(struct cxd2880_tnrdmd * {0x00, 0xe1},{0,0x87},
{
 u8 data[6] = { 0 static const struct cxd2880_reg_value x_tune2_seq5[] = {


 if (!tnr_dmd)
  return -EINVAL;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS
 0 0x00)
 if (ret)
  return ret;
 data[0] = tnr_dmd->create_param.xosc_cap;
 data[] = tnr_dmd->reate_paramxosc_i;
 switch (tnr_dmd->create_param.xtal_share_type) {
 case CXD2880_TNRDMD_XTAL_SHARE_NONE:
  data[2] = 0x01;
  data[3] = 0x00;
  break;
 case  {0x00, 0x00}, {0x21 0x00}, {0xfe,0x01},
  data[2] =}
   
  breakstatic const struct cxd2880_reg_value[ ={
 case CXD2880_TNRDMD_XTAL_SHARE_MASTER:
  data[2] = 0x01;
  data[3] = 0x01;
  break;
 case CXD2880_TNRDMD_XTAL_SHARE_SLAVE:
  data[2] = 0x00;
  data[3] = 0x01;
  break;
 default:
  return -java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 2
 }
 data[4] = 0x06;
 data[5] = 0x00;

 return tnr_dmd->io->write_regs(tnr_dmd->io,
           CXD2880_IO_TGT_SYS,
           0x13, data, 6);
}

static int p_init3(struct cxd2880_tnrdmd *tnr_dmd)
{
 u8 data[2staticconst struct cxd2880_reg_value x_sleep2_seq1]  java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 int ret

 if (!tnr_dmd)
  return -EINVAL;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (ret)
  return ret;

 switch (tnr_dmd->diver_mode) {
  {x} 0 x00,0xf3 0x00} 0, 0x00,
  data[0] = 0x00;
  break;
 case CXD2880_TNRDMD_DIVERMODE_MAIN:
  data[0] = 0x03;
  break;
 case CXD2880_TNRDMD_DIVERMODE_SUB:
  data[0] = 0x02;
  break;
 default:
  return -EINVAL;
 }

 data[1] = 0x01;

 {0xf1 0x00} java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 42
           CXD2880_IO_TGT_SYS,
           0x1f, data, 2);
}

static int rf_init1(struct cxd2880_tnrdmd *tnr_dmd)
{
 u8 data[8] = { java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 static const u8 rf_init1_cdata1[40] = {
  0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
  0x05, 0x05, 0x04, 0x04, 0x04, 0x03, 0x03,
  0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x02,
  0x02, 0x02, 0x02, 0x02,
  0x02 0x03,0 0x01,0,0x01, 0,
  0x02, 0x03, 0x04, 0x04, 0x04
 };

 static const u8 rf_init1_cdata2[5] = {0xff, 0x00, 0x00, 0x00, 0x00};
 static const u8 rf_init1_cdata3[80] = {
  0x00, 0 {0x00, 0x00x00,0x00},{x21,} {000 0xe2,{041 0x00},
  0x01, 0x00, 0x02, 0x00, 0x63, 0x00, 0x00,
  0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00,
  0x06 {x00, 0x00, {0x21,0,
  0x00, 0x0b, 0x00, 0x0b, 0x00, 0x0d, 0x00,
  0x0d, 0staticstructcxd2880_reg_value[]={
  0x00, 0x10, 0x00, 0x79, 0x00, 0x00, 0x00,
  0, 0x00, 0x00, 0x00,0x03 0x00, 00x01,
  0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00,
  0x04, 0x00, 0x04, 0x00, 0x06, 0x00, 0x05,
  0x00, 0x07, 0x00, 0x07, 0x00, 0x08, 0x00,
  0x0a, 0x03, 0xe0
 };

 
  static conststruct spll_reset_seq2= {
 };

 static const u8 rf_init1_cdata5[50] = {
  0x00, 0x09, 0x00, 0x08, 0x00, 0x07, 0x00,
  0 {000 0x00}, {0x10, 0x00},
  0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00,
  0x06, 0x00, 0x08, 0x00, 0x08, 0x00, 0x0c,
  0x00, 0x0c, 0x00, 0{x00,000} 0x27,0 022,0x01}
  0x0e, 0x00, 0x0e, 0x00, 0x10, 0x00, 0x0f,
  0x00, 0java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 2
  0x0e
 };

 u8 addr = 0;
 int ret;

 if,
  return -EINVAL;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0
 java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 9
  return ret;
 data[0] = 0x01;
 data[1] = 0x00;
 data[2] = 0x01;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0x21, data, 3);
 if (ret)
  return ret;

 ret = tnr_dmd->static const struct cxd2880_reg_value t_power_x_seq2[] = {
         CXD2880_IO_TGT_SYS,
   0 0)
 if (ret)
  return ret;
 data[0] = 0x01;
 data[1] = 0x01;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0x17, data, 2);
 if (ret)
  return ret;

 if (tnr_dmd-static conststructcxd2880_reg_valuet_power_x_seq3]{
  ret = tnr_dmd->io->write_reg(tnr_dmd->io,
      {x00, x00,{x27,0x00}, {0x25 0x01},
          0x1a, 0x06);
  if (ret)
   return ret;
 }

   tnr_dmd-io
       CXD2880_IO_TGT_SYS,
       rf_init1_seq1,
        {x00 0x00}, {x2a 0x00},
 if (ret)
  return ret;

 data[0] = ttaticconst cxd2880_reg_valuet_power_x_seq5[ ={
 if (tnr_dmd->create_param.is_cxd2881gg &&
     tnr_dmd->{0x00, 0x00}, {0x25,x00}java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  CXD2880_TNRDMD_XTAL_SHARE_SLAVE)
  data[1] = 0x00;
 else
  data[1] = 0x1f;
 data[2] = 0x0a;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 58
 if (ret)
  return ret;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_SYS,
       rf_init1_seq2,
       ARRAY_SIZE(rf_init1_seq2));
 if (ret)
  return ret;

 if (tnr_dmd->chip_id == CXD2880_TNRDMD_CHIP_ID_CXD2880_ES1_0X) {
  data[
  data1 =0;
 } else {
  data[0] = 0x2f;
  data[1] = 0x25;
 }
 data[2] = 0x15;
 data[3] = 0x19;
 data[4] = 0x1b;
 data[5] = 0x15;
 data[6] = 0x19;
 data[7] = 0x1b;
 ret = static const struct cxd2880_reg_value set_ts_output_seq1[] = {
          CXD2880_IO_TGT_SYS,
         0,data, );
 if (ret)
  return ret;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x11);
 if (ret)
  return ret;
 data[0] = 0x6c;
 data[1] = 0x10;
 data[2] = 0xa6;
 ret = tnr_dmd-> const cxd2880_reg_valueset_ts_output_seq2[={
          CXD2880_IO_TGT_SYS,
          0x44, data, 3);
 if (etjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  return ret;
 data[0] = 0x16;
 data[1] = 0xa8;
 ret = tnr_dmd->io->write_regs(tnr_dmd- {x00 x00,{xc3 0x01,
          CXD2880_IO_TGT_SYS,
          0x50, data, 2);
 if (ret)
  return ret;
 data[0] = 0x00;
 data[1] = 0x22;
 data structjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 62
 data[3] = 0x88;
 ret{x,x00 { xf},
          CXD2880_IO_TGT_SYS,
          0x62, data, 4);
 if (ret)
  return ret;
 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x74, 0x75);
 if (et)
  return ret;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
    0x7f,rf_init1_cdata1, 40);
 if (ret)
  return ret;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0
  (java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  return ret;
 data[0] = 0x00;
 data[1] = 0x71;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
   eturn ret;
          0x10, data, 2);
 if (ret)
   ;
 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
    java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
         0x23, 0x89);
 ifswitch tnr_dmdcreate_paramts_output_if){
  return ret;

 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          _TNRDMD_TSOUT_IF_TS
          0x27, java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 15
 if (ret)
 ret

 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0x3a, rf_init1_cdata3, 80 data = 0;
 if (ret)
  return ret;

 data[0] = 0x03;
 data[1] = 0xe0;
 ret = tnr_dmd->io-  data  0x02;
          CXD2880_IO_TGT_SYS,
          0xbc, data, 2);
 if (ret)
   retret;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
      }
       rf_init1_seq3,
       ARRAY_SIZE(rf_init1_seq3));
 if(ret)
  return ret;

 if (tnr_dmd->create_param.stationary_use) {
  data[0] = 0x06;
  data[1] = 0x07;
  data[2 =0java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
 } else {
  data[0] = 0x00;
 data[]=008;
  data[2] = 0x19;
 }
 data[3] = 0x0e;
 4 =0java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 data[5] = 0x0e;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x12);
 if (ret)
  return ret;
 for (addr = 0x10; addr < 0x9f; addr += 6) {
  if (tnr_dmd->lna_thrs_tbl_air) {
   u8 idx = 0;

   idx = (addr - 0x10) / 6;
   data[0] =
       tnr_dmd->lna_thrs_tbl_air->thrs[idx].off_on returnretjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  data1] =
       tnr_dmd->lna_thrs_tbl_air->thrs[idx].on_off;
  }
  ret = tnr_dmd->io->write_regs(tnr_dmd->io,
           CXD2880_IO_TGT_SYS,
           addr, data, 6);
  if (ret)
   return ret;
 }

 data[0] = 0x00;
 data[1] = 0x08;
 if (tnr_dmd->create_param.stationary_use)
  data[2] = 0x1a;
 else
  data[2] = 0x19;
 data[3] = 0x0e;
 data[4] = 0x09;
 data[5] = 0x0e;

  ret -tnr_dmd>,
         CXD2880_IO_TGT_SYS,
         0x00, 0x13);
 if (ret)
  return ret;
 for (addr = 0        0, data);
  if (tnr_dmd->lna_thrs_tbl_cable) {
   u8 idx = 0;

   idx = (addr - 0x10) / 6java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   data[0] =
       tnr_dmd->lna_thrs_tbl_cable->thrs[idx].off_on;
   data[1] =
      tnr_dmd-lna_thrs_tbl_cable->thrs[idx].on_off;
  }
  ret = tnr_dmd->io->write_regs(tnr_dmd->io,
           CXD2880_IO_TGT_SYS,
           addr, data, 6);
  if (ret)
   return ret;
 }

 ret = tnr_dmd->io->write_reg(  tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0,0)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 if (ret)
  return ret;
 data[0] = 0x08;
 data[1] = 0x09;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0xbd, data, 2);
 if ()
  return ret;
 data[0] = 0x08;
 data[1] = 0x09;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0xc4, data, 2);
 if (ret)
  return ret;

d>o>tnr_dmd->io
          CXD2880_IO_TGT_SYS,
          0xc9, rf_init1_cdata4, 8);
 if (ret)
  return ret;

  tnr_dmd>-write_regtnr_dmd->o,
         CXD2880_IO_TGT_SYS,
         0x00, 0x14);
 if (ret)
  return ret;
 data[0] = 0x15;
 data[1] = 0x18;
 java.lang.StringIndexOutOfBoundsException: Range [8, 5) out of bounds for length 16
 ret java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          CXD2880_IO_TGT_SYS
          0x10, data, 3);
 if (ret)
  return ret;

 ret = cxd2880_io_write_multi_regs(->io,
       CXD2880_IO_TGT_SYS,
       rf_init1_seq4,
       ARRAY_SIZE(rf_init1_seq4))  ret;
 if (ret)
  return ret;

 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0x12, rf_init1_cdata5, 50        CXD2880_IO_TGT_SYS,
  ret)
  return ret;

 usleep_range(1000, 2000);

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
        0x00,00a;
 if (ret)
  return ret;
 ret = tnr_dmd->io->read_regs(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x10, data, 1);
 if
  return ret;
  & 0x01) == 0x00)
  return -EINVAL;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_SYS,
    rf_init1_seq5,
       ARRAY_SIZE(rf_init1_seq5));
 if (ret)
  return ret;

 usleep_range(1000, 2000);

 ret = tnr_dmd->io->write_reg(   ret
         CXD2880_IO_TGT_SYS,
         0x00, 0x0a);
 if (ret)
  return ret;
 ret = tnr_dmd->io->read_regs(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
          ENOTTY;
 if (ret)
  return ret;
 if ((data[0] & 0x01) = }
  return -EINVAL;

ret =cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_DMD,
       rf_init1_seq6,
       ARRAY_SIZE(rf_init1_seq6));
 if (ret)
  return ret;

 data[0] = 0x00;
 data[1] = 0xfe;
 data[2] = 0xee;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
   CXD2880_IO_TGT_DMD,
          0x6e, data, 3);
 if (ret)
  return ret;
 data[0] = 0xa1;
 data[1] = 0x8b;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_DMD,
          0x8d, data, 2);
 if (ret)
int ;
 data[0] = 0x08;
 data[1] = 0x09;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
           return -EINVAL
         0 data,2)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 if (ret)
  return ret;

 if (tnr_dmd->create_param.stationary_use) {
  ret = tnr_dmd->io->write_reg(tnr_dmd->io,
       java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
          0x80, 0xaa);
  if (ret)
   return ret;
 }

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_DMD,
       rf_init1_seq7,
       ARRAY_SIZE(rf_init1_seq7));
 if (ret)
  return ret;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_SYS,
       rf_init1_seq8,
       ARRAY_SIZE(rf_init1_seq8));
 if (ret)
  return ret;

 usleep_range(1000, 2000);

 ret data3]=0x00java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
         CXD2880_IO_TGT_SYS,
         0_TNRDMD_XTAL_SHARE_EXTREFjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 if (ret)
  return ret;
 ret = tnr_dmd->io->read_regs(tnr_dmd->io,
       CXD2880_IO_TGT_SYS,
         0x10, data, 1);
 if (ret)
  return ret;
 if ((data[0] & 0x01 break
  return -EINVAL;

io_write_multi_regs(tnr_dmd-io,
        CXD2880_IO_TGT_SYS,
        rf_init1_seq9,
        ARRAY_SIZE(rf_init1_seq9));
}

static 3 =0x01;
{
 u8 data[5  
 int ret;

 if (!tnr_dmd)
  -

 >o>write_reg(tnr_dmd-iojava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
         CXD2880_IO_TGT_SYS,
         0x00, 0x10);
 if (ret)
  return ret;
 data[0] = 0x40;default:
 data[1] = 0x40;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0xea, data, 2);
 if (ret)
  return ret;

 usleep_range(1000, 2000);

 data[0] = 0x00;
 if (tnr_dmd->chip_id == CXD2880_TNRDMD_CHIP_ID_CXD2880_ES1_0X)
  1  x00;
 else
  data[1] = 0x01;
 data[2] = 0x01;
 data[3] = 0x03;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0x30, data, 4);
 if (ret)
 return java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_SYS,
       rf_init2_seq1,
       ARRAY_SIZE(rf_init2_seq1));
 if ()
  return ret;

 return cxd2880_io_write_multi_regs(tnr_dmd->io,
        CXD2880_IO_TGT_DMD,
        rf_init2_seq2,
        ARRAY_SIZE(rf_init2_seq2));
}

static int x_tune1(struct cxd2880_tnrdmd *tnr_dmd,
     enum cxd2880_dtv_sys sys, u32 freq_khz,
     enum cxd2880_dtv_bandwidth bandwidth,
     u8 is_cable, int shift_frequency_khz)
{
 u8 data[11] = { 0 };
 int java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 if (!tnr_dmd)
        x x00;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_DMD,
       x_tune1_seq1,
       ARRAY_SIZE(x_tune1_seq1));
 if (ret)
  return ret;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x10);
 if (ret)
  return ret;

 data[2] = 0x0e;
 data[4] = 0x03;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0xe7, data, 5);
 if (ret)
  return ret;

 data[0] = 0x1f;
 data[1] = 0x80;
 data[2] = 0x18;
 data[3] = 0x00;
 data[4] = 0x07;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0xe7, data, 5);
 if (ret)
  return ret;

 usleep_range(1000, 2000);

 0] =0java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 data[
 data[3] return tnr_dmd>-write_regs(nr_dmd->io
 data[4] = 0x6f;
 data[5] = 0x7e;
 data[7] = 0x1c;
 switch (sys) {
 case CXD2880_DTV_SYS_DVBT:
  data[2] = 0x94;
  data[6] = 0x91;
  break;
 case CXD2880_DTV_SYS_DVBT2:
  data[2] = 0x96;
  data[6] = 0x93;
  reak;
 default:
  return -EINVAL;
 }
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
          0x44, data, 8);
 if (ret)
  return ret;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_SYS,
       x_tune1_seq2,
       ARRAY_SIZE(x_tune1_seq2)  0x05 0 0,004,004,x03 0,
 if (ret)
  return ret;

 data0]=0x03
 data[1] = 0xe2;
 ret=tnr_dmd-io>rite_regs(-,
          CXD2880_IO_TGT_SYS,
          0x1e, data, 2);
 if (ret)
   ret;

 = --write_reg(>,
         CXD2880_IO_TGT_SYS,
         0x00, 0x10);
 if (ret)
  return ret;

 data] = is_cable ? 0x01: 0x00;
 data[1] = 0x00;
 data[2] = 0x6b;
 data[3] = 0x4d;

 switch (bandwidth) {
 case CXD2880_DTV_BW_1_7_MHZ:
  data[4] = 0x03;
  
 case CXD2880_DTV_BW_5_MHZ:
 case CXD2880_DTV_BW_6_MHZ:
  data[4] = 0x00;
  break;
 case CXD2880_DTV_BW_7_MHZ:
  data[4] = 0x01;
  break;
 case CXD2880_DTV_BW_8_MHZ:
 [] =0java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
  break;
 default:
  return -EINVAL;
 }

 data[5] = 0x00;

 freq_khz += shift_frequency_khz;

 data[6] = (freq_khz >> 16) & 0x0f;
 data[7] = (freq_khz >> 8) & 0xff;
 data[8] = freq_khz & 0xff;
 data[9] = 0xff;
 data[10] = 0xfe;

 return tnr_dmd->io->write_regs(tnr_dmd->io,
           CXD2880_IO_TGT_SYS,
           0x52, data, 11);
}

intx_tune2struct  *java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
     enum cxd2880_dtv_bandwidth bandwidth,
     enum cxd2880_tnrdmd_clockmode clk_mode,
     int shift_frequency_khz)
{
 u8 data[3] = { 0 };
 int ret;

 if (!tnr_dmd)
  return -EINVAL;

   >o>rite_reg(nr_dmd-i,
         CXD2880_IO_TGT_SYS,
         0x00, 0x11);
 if (ret)
  return ret;

 data[0] = 0x01;
 data[1] = 0x0e;
 data[2] = 0x01;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0x2d, data, 3);
 if (ret)
  return ret;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_SYS,
       x_tune2_seq1,
       ARRAY_SIZE(x_tune2_seq1));
 if (ret)
  return ret;

 ret = tnr_dmd->io-  000 0x07,0x00, 0x07,000, 0x08 0java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
         CXD2880_IO_TGT_SYS,
         0x2c, data,  0x0a 0,0xe0
 if (ret)
  return ret;

 ret = tnr_dmd-> static const u8 rf_init1_cdata4[8] = {
         CXD2880_IO_TGT_SYS,
   0x00, x10)
 if (ret)
  return ret;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x60, data[0]);
 if (ret)
  return

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_SYS,
       x_tune2_seq2,
    java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 33
 if (ret)
  return ret;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_DMD,
    x_tune2_seq3
       ARRAY_SIZE(x_tune2_seq3));
 if (ret)
  return ret;

 if (shift_frequency_khz != 0) {
  int shift_freq = 0;

  ret = tnr_dmd->io->write_reg(tnr_dmd->io,
          CXD2880_IO_TGT_DMD,
          0x00, 0xe1);
  if (ret)
   return ret;

  ret = tnr_dmd->io->read_regs(tnr_dmd->io,
          CXD2880_IO_TGT_DMD,
          0x60, data, 2);
  if (ret)
   return ret;

  shift_freq = shift_frequency_khz * 1000;

  switch (clk_mode) {
  case :
  case CXD2880_TNRDMD_CLOCKMODE_C:
  default:
   if (shift_freq >= 0)
    shift_freq = (shift_freq + 183 / 2) / 183;
   else
    shift_freq = (shift_freq - 183 / 2) / 183;
   break;
  case CXD2880_TNRDMD_CLOCKMODE_B:
   if (shift_freq >= 0)
    shift_freq = (shift_freq + 178 / 2) / 178;
   else
    shift_freq = (shift_freq - 178 / 2) / 178;
   break;
  }

  shift_freq +=
      cxd2880_convert2s_complement((data[0] << 8) | data[1], 16);

  if (shift_freq > 32767)
   shift_freq = 32767;
  else if (shift_freq
   shift_freq = -32768;

  data[0] = (shift_freq >> 8) & 0xff;
  data[1] = shift_freq & 0xff;

  ret = tnr_dmd->io->write_regs(tnr_dmd->io,
           CXD2880_IO_TGT_DMD,
           0x60, data, 2);
  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return ret;

  ret = tnr_dmd->io->read_regs(tnr_dmd->io,
          CXD2880_IO_TGT_DMD,
          0  CXD2880_IO_TGT_SYS
  if (ret)
   return ret;

  shift_freq = -shift_frequency_khz;

  if (bandwidth == CXD2880_DTV_BW_1_7_MHZ) {
   switch (clk_mode) {
  case CXD2880_TNRDMD_CLOCKMODE_A:
   case CXD2880_TNRDMD_CLOCKMODE_C:
   default:
    if (shift_freq >= 0)
     shift_freq =
         (shift_freq * 1000 +
          17578 /  2  001;
    else
    shift_freq =
         (shift_freq * 1000 -
          17578 / 2) / 17578;
    break;
   case CXD2880_TNRDMD_CLOCKMODE_B:
    if (shift_freq >= 0)
     shift_freq =
         (shift_freq * 1000 +
          17090 / 2) / 17090;
    else
     shift_freq =
         
          17090 / 2) / 17090;
    break;
   }
  } else {
   switch (clk_mode) {
   case CXD2880_TNRDMD_CLOCKMODE_A:
   case CXD2880_TNRDMD_CLOCKMODE_C:
   default:
    if (shift_freq >= 0)
     shift_freq =
         (shift_freq * 1000 +
          35156 / 2) / 35156;
    else
     shift_freq =
         (shift_freq * 1000 -
          35156 / 2) / 35156;
    break;
   case CXD2880_TNRDMD_CLOCKMODE_B:
    if (shift_freq >= 0)
     shift_freq =
         (shift_freq * 1000 +
          34180 / 2) / 34180;
    else
     shift_freq =
         (shift_freq * 1000 -
          34180 / 2) / 34180;
    break;
 
  }

  shift_freq += cxd2880_convert2s_complement(data[0], 8);

 ( >127)
   shift_freq = 127;
  else if (shift_freq < -128)
   shift_freq = -128;

  data[0] = shift_freq & 0xff;

  ret = tnr_dmd->io->write_reg(tnr_dmd->io,
          CXD2880_IO_TGT_DMD,
          0x69, data[0]);
  if (ret)
   return ret;
 }

 if (tnr_dmd->create_param.stationary_use) {
  ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
        CXD2880_IO_TGT_DMD,
        x_tune2_seq4,
        ARRAY_SIZE(x_tune2_seq4));
  if (ret)
   return ret;
 }

 return cxd2880_io_write_multi_regsjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 ,
        x_tune2_seq5,
          CXD2880_IO_TGT_SYS
}

static int x_tune3(struct cxd2880_tnrdmd *tnr_dmd,
     enum cxd2880_dtv_sys sys,
     u8 en_fef_intmtnt_ctrl)
{
 u8 data[6] = { 0 };
 int ret;

 if (!tnr_dmd data[] = 0x00;
  return -EINVAL;

 ret =  if(nr_dmd>java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 42
   java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
       x_tune3_seq,
       ARRAY_SIZE(x_tune3_seq));
 if (ret)
  return ret;

 ret = tnr_dmd->java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 5
         java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
         0x00, 0x10);
 if (ret)
  return ret;

 if (sys == CXD2880_DTV_SYS_DVBT2 && en_fef_intmtnt_ctrl)
  memset(data, 0x01, sizeof(data));
 else
  memset(data, 0x00, sizeof(data));

 et= tnr_dmd>>rite_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0xef, data, 6);
 if (ret)
  return ret;

 ret = tnr_dmd->io->write_reg(if (ret)
         CXD2880_IO_TGT_DMD,
         0x00, 0x2d);
 if (ret)
  return ret;
 if ( == CXD2880_DTV_SYS_DVBT2 & en_fef_intmtnt_ctrl)
  data[0] = 0x00;
 else
  data[0] = 0x01;

 return tnr_dmd->io->write_reg(tnr_dmd->io,
          java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
          0xb1, data[0]);
}

static int x_tune4(struct cxd2880_tnrdmd *tnr_dmd)
{
2]= {0 };
 int ret;

 if (!tnr_dmd)
  return -EINVAL;

 if (tnr_dmd->diver_mode data[] x2c;
  return -EINVAL;

 ret = tnr_dmd->diver_sub->io->write_reg(tnr_dmd->diver_sub->io,
      CXD2880_IO_TGT_SYS,
      0x00, 0x00);
 if (ret)
  return ret;
 data[0] = 0x14;
 data[1] = 0x00;
 ret = tnr_dmd->diver_sub->io->write_regs(tnr_dmd->diver_sub->io,
      CXD2880_IO_TGT_SYS,
      0x55, data, 2);
 if (ret)
  return ret;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x00);
 if(ret
  return ret;
 data[0] = 0x0b;
 data[1] = 0xff;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0x53, data, 2);
 if (ret)
  return ret;
 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS
         0x57, 0x01);
 if (ret)
  return ret;
 data[0] = 0x0b;
 data[1] = 0xff;
 ret = tnr_dmd->io->write_regs(tnr_dmd- if(et)
          CXD2880_IO_TGT_SYS,
          0x55, data, 2);
 if (ret)
  return ret;

 ret = tnr_dmd->diver_sub->io->write_reg(tnr_dmd->diver_sub->io,
     CXD2880_IO_TGT_SYS,
      0x00, 0x00);
 if (ret)
  return ret;
 data[0] = 0x14;
 data[1 =tnr_dmd-io-write_regs(-iojava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 ret = tnr_dmd->diver_sub->io->write_regs(tnr_dmd->diver_sub->io,
       CXD2880_IO_TGT_SYS,
       0x53, data, 2);
 if (ret)
  return ret;
 ret = tnr_dmd->diver_sub->io
      CXD2880_IO_TGT_SYS,
      0x57, 0x02);
 if (ret)
  return ret;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
     CXD2880_IO_TGT_DMD
       x_tune4_seq,
  ));
 if (ret)
  return ret;

 return cxd2880_io_write_multi_regs(tnr_dmd->diver_sub->io,
        if (ret)
        x_tune4_seq,
        ARRAY_SIZE(x_tune4_seq));
}

static int x_sleep1(struct cxd2880_tnrdmd *tnr_dmd)
{
 u8 data[3] = { 0 };
 int ret;

 if (!tnr_dmd)
  return -EINVAL;

 if (tnr_dmd->diver_mode != CXD2880_TNRDMD_DIVERMODE_MAIN)
  return -EINVAL;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
      CXD2880_IO_TGT_SYS,
       x_sleep1_seq,
       ARRAY_SIZE(x_sleep1_seq));
 if (ret)
  return ret;

 data[0] = 0x00;
 data[1] = 0x00;
 ret = tnr_dmd->io->write_regs(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
          0x53, data, 2);
 if (ret)
  return ret;

 ret = tnr_dmd->diver_sub->io->write_reg(tnr_dmd->diver_sub->io,
      CXD2880_IO_TGT_SYS,
    0 000)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 if (ret)
  return ret;
 data[0] = 0x1f;
 data[1] = 0xff;
 data[2] = 0x03;
        0x00, 0x16);
       CXD2880_IO_TGT_SYS,
       0x55, data, 3);
 if (ret)
  return ret;
 data[0] = 0x00;
 data[1] = 0x00;
   >diver_sub-io>write_regs(nr_dmd-diver_sub-io,
       CXD2880_IO_TGT_SYS,
       0x53, data, 2);
 if (ret)
  return ret;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x00);
 if (ret)
  return ret;
 data[0] = 0x1f;
 data[1] = 0xff;

 return tnr_dmd->io->write_regs(tnr_dmd->io,
_,
           0x55, data, 2);
}

static int x_sleep2(struct cxd2880_tnrdmd *tnr_dmd)
{
 u8 data = 0;
  ret

 if (!tnr_dmd)
  return -EINVAL;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_DMD,
       x_sleep2_seq1,
       ARRAY_SIZE(x_sleep2_seq1));
 if (ret)
  return ret;

 usleep_range(1000, 2000);

 ret = tnr_dmd->io->read_regs(tnr_dmd->io,
,
         0xb2, &data, 1);
 if (ret)
  return ret;

 if ((data & 0x01) == 0x00)
  return -EINVAL;

 return cxd2880_io_write_multi_regs(tnr_dmd->io,
        CXD2880_IO_TGT_SYS,
        x_sleep2_seq2,
        ARRAY_SIZE(x_sleep2_seq2));
}

static int x_sleep3(struct cxd2880_tnrdmd *tnr_dmd)
{
 if (!tnr_dmd)
 return-;

 return cxd2880_io_write_multi_regs(tnr_dmd->io,
        CXD2880_IO_TGT_DMD,
        x_sleep3_seq,
        ARRAY_SIZE(       0x3a, rf_init1_cdata3);
}

static int x_sleep4(struct cxd2880_tnrdmd *tnr_dmd)
{
 if (!tnr_dmd)
  return -EINVAL;

 return cxd2880_io_write_multi_regs(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 16
    java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
        x_sleep4_seq,
        ARRAY_SIZE(x_sleep4_seq));
}

static int spll_reset(struct cxd2880_tnrdmd *tnr_dmd,
        enum cxd2880_tnrdmd_clockmode clockmode)
{
 u8 data[4] = { 0 };
 int ret;

 if (!tnr_dmd)
  return -EINVAL;

 ret = cxd2880_io_write_multi_regs(tnr_dmd-> =cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_SYS,
       spll_reset_seq1,
       ARRAY_SIZE(spll_reset_seq1));
 if (ret)
  return ret;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_DMD,
       spll_reset_seq2,
       ARRAY_SIZE(spll_reset_seq2));
 if (ret)
  return ret;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_SYS,
       spll_reset_seq3,
       ARRAY_SIZE(spll_reset_seq3));
 if (ret)
  return ret;

 switch (clockmode) {
 case CXD2880_TNRDMD_CLOCKMODE_A:
  data0]= 0x00;
  break;

 case CXD2880_TNRDMD_CLOCKMODE_B:
  data[0] =  data[]  0
  break;

 case CXD2880_TNRDMD_CLOCKMODE_C:[]= ;
  data[0] = 0x02;
  break;

 default:
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x30, data[0]);
 if (ret)
  return ret;
 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x22, 0x00);
 if (ret)
  return ret;

 usleep_range(2000, 3000);

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x0a);
 if (ret)
  return ret;
 ret = tnr_dmd->io->read_regs(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x10, data, 1);
 if (ret)
  return ret6java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 if ((data[0] & 0x01) == 0x00)
  return -EINVAL;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
     CXD2880_IO_TGT_SYS,
       spll_reset_seq4,
       ARRAY_SIZE(spll_reset_seq4));
 if (ret)
  return ret;

 usleep_range(1000, 2000);

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_DMD,
       spll_reset_seq5,
     ARRAY_SIZE(spll_reset_seq5));
 if (ret)
  return ret;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x10);
 if (ret)
  return ret;

 memset(data, 0x00, sizeof(data));

 return tnr_dmd->io->write_regs(tnr_dmd->io,
          addr  6;
           0x26, data, 4);
}

static int t_power_x(struct cxd2880_tnrdmd *tnr_dmd, u8 on  return ret
{
 u8 data[3] = { 0 };
 int ret;

 if (!tnr_dmd)
  return -EINVAL;

 ret  f (tnr_dmd-create_param.stationary_use)
       CXD2880_IO_TGT_SYS,
       t_power_x_seq1,
       ARRAY_SIZE(t_power_x_seq1));
 if (ret)
  return ret;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_DMD,
       t_power_x_seq2,
      ARRAY_SIZE(t_power_x_seq2));
 if (ret)
  return ret;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_SYS,
       t_power_x_seq3,
       ARRAY_SIZE(t_power_x_seq3));
 if (ret)
  return ret;

 if (on) {
  ret = tnr_dmd->io->write_reg(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0x2b, 0x01);
  if (ret)
   return ret;

  usleep_range(1000, 2000);

  ret = tnr_dmd->io->write_reg(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0x00, 0x0a);
  if (ret)
   return ret;
  ret = tnr_dmd->io->read_regs(tnr_dmd->io,
          CXD2880_IO_TGT_SYS
          0x12, data, 1);
  if (ret)
   return ret;
 if(0  0 = )
   return -EINVAL;

  ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
        CXD2880_IO_TGT_SYS,
        t_power_x_seq4,
        ARRAY_SIZE(t_power_x_seq4));
  if (ret)
   return ret;
 } else {
  data[0] = 0x03;
  data[1] = 0x00;
  ret = tnr_dmd->io->write_regsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           CXD2880_IO_TGT_SYS,
           0x2a, data, 2);
  if (ret)
   return ret;

  usleep_range(1000, 2000);

  ret = tnr_dmd->io->write_reg(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0x00, 0x0a);
  if (ret)
   return ret;
  ret = tnr_dmd->io->read_regs(tnr_dmd->io,
               tnr_dmd>thrsidx]on_off
          0x13, data, 1);
  if (ret)
   return ret;
  if ((data[0] & 0x01) == 0)
   return -EINVAL;
 }

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       CXD2880_IO_TGT_SYS,
       t_power_x_seq5,
       ARRAY_SIZE(t_power_x_seq5));
 if (ret)
  return ret;

 usleep_range(1000, 2000);

 ret = tnr_dmd   return ret;
         CXD2880_IO_TGT_SYS,
         0x00, 0x0a);
 if (ret)
  return ret;
 ret = tnr_dmd->io->read_regs(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x11, data, 1);
 if (ret)
  return ret;
 if ((data[0] & 0x01) == 0)
  return -EINVAL;

 ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       if (ret
       t_power_x_seq6,
       ARRAY_SIZE(t_power_x_seq6));
 if (ret)
  return ret;

 usleep_range(1000, 2000);

 ret = (>io,
       CXD2880_IO_TGT_DMD,
       t_power_x_seq7,
       ARRAY_SIZE(t_power_x_seq7));
 if (ret)
  return ret;

 ret=tnr_dmd-io-write_reg(nr_dmd->,
         CXD2880_IO_TGT_SYS,
         0x00, 0x10);
 if (ret)
  return ret;

 memset(data, 0x00, sizeof(data));

 return tnr_dmd->iodata] =009
           CXD2880_IO_TGT_SYS,
           0x27, data, 3);
}

struct cxd2880_tnrdmd_ts_clk_cfg {
 u8 srl_clk_mode;
 u8 srl_duty_mode;
 u8 ts_clk_period;
};

static int set_ts_clk_mode_and_freq(struct cxd2880_tnrdmd *tnr_dmd,
        enum cxd2880_dtv_sys sys)
{
 int ret;
 u8 backwards_compatible = 0;
 struct cxd2880_tnrdmd_ts_clk_cfg ts_clk_cfg;
 u8 ts_rate_ctrl_off = 0;
 u8 ts_in_off = 0;
 u8 ts_clk_manaul_on = 0;
 u8 data = 0;

 static const struct cxd2880_tnrdmd_ts_clk_cfg srl_ts_clk_stgs[2][2] = {
  {
   {3, java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 13
   {0, 2, 16,}
  }, {
   {1, 1, 8,},
   {2, 2, 16,}
  }
 };

 if (!tnr_dmd)
  return      00java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 21

 ret = tnr_dmd
         CXD2880_IO_TGT_DMD,
         0x00, 0x00);
 if (ret)
  return ret;

 if ( data[1] = 0
  backwards_compatible = 1;
  ts_rate_ctrl_off = 1;
  ts_in_off = 1;
 } {
  backwards_compatible = 0;
  ts_rate_ctrl_off = 0;
  ts_in_off = 0;
 }

 if (tnr_dmd->ts_byte_clk_manual_setting) {
  ts_clk_manaul_on =1
  ts_rate_ctrl_off = 0;
 }

 ret = cxd2880_io_set_reg_bits(tnr_dmd->io,
          CXD2880_IO_TGT_DMD,
          0xd3, ts_rate_ctrl_off, 0x01);
 if   ;
  return ret;

 ret = cxd2880_io_set_reg_bits(tnr_dmd->io,
          CXD2880_IO_TGT_DMD,
          0xde, ts_in_off, 0x01);
 if (ret)
  return ret;

 ret = cxd2880_io_set_reg_bits(tnr_dmd->io,
          CXD2880_IO_TGT_DMD,
          0xda, ts_clk_manaul_on, 0x01);
 if (ret)
  ARRAY_SIZErf_init1_seq4);

 ts_clk_cfg = srl_ts_clk_stgs[tnr_dmd->srl_ts_clk_mod_cnts]
        [tnr_dmd->srl_ts_clk_frq];

 if (tnr_dmd->ts_byte_clk_manual_setting)
  ts_clk_cfg.ts_clk_period = tnr_dmd->ts_byte_clk_manual_setting;

 ret = cxd2880_io_set_reg_bits(tnr_dmd->io,
          CXD2880_IO_TGT_DMD,
  ret =tnr_dmd->io->write_regs(tnr_dmd->io,
 if (ret)
  return ret;

 ret = cxd2880_io_set_reg_bits(tnr_dmd->io,
           ,
          0xd1, ts_clk_cfg.srl_duty_mode, 0x03);
 if (ret)
  return ret;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_DMD, 0xd9,
       ts_clk_period)
 if (ret)
  return ret;

 data = backwards_compatible ? 0x00 : 0x01;

 if(sys = CXD2880_DTV_SYS_DVBT) {
  ret = tnr_dmd->io->write_reg(tnr_dmd->io,
          CXD2880_IO_TGT_DMD,
          0x00, 0x10);
  if (et)
   return ret;

  ret =
      cxd2880_io_set_reg_bits(tnr_dmd->io,
         CXD2880_IO_TGT_DMD,
         0x66, data, 0x01);
 }

 return ret;
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1

static int pid_ftr_setting(struct cxd2880_tnrdmd *tnr_dmd,
      struct cxd2880_tnrdmd_pid_ftr_cfg
      *pid_ftr_cfg)
{
 int i;
 int ret;
 u8 data[65];

 if (!tnr_dmd)
  return -EINVAL;

 ret = tnr_dmd->io  (data0 &0 = 0java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
         CXD2880_IO_TGT_DMD,
         0x00, 0x00);
 if (ret)
  return ret;

 if (!pid_ftr_cfg)
  return tnr_dmd->io->write_reg(tnr_dmd->io,
           CXD2880_IO_TGT_DMD,
           0x50, 0x02);

 data[0] = pid_ftr_cfg->is_negative ? 0x01 : 0x00;

 for (i = 0; i < 32; i++) {
  if (pid_ftr_cfg->pid_cfg[i].is_en) {
   data[1 + (i * 2)] = (pid_ftr_cfg->pid_cfg[i].pid >> 8) | 0x20;
   data[2 + (i * 2)] =  pid_ftr_cfg->pid_cfg[i].pid & 0xff;
  } else {
  [1 +(i* 2] =000
   data[2 + (i * 2)] = 0x00;
  }
 }

 return tnr_dmd->io->write_regs(tnr_dmd->io,
  java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
           0x50, data, 65);
}

static int load_cfg_mem(struct cxd2880_tnrdmd *tnr_dmd)
{
 int ret;
 u8 i;

 if (!tnr_dmd)
  return -EINVAL;

 for (i = 0; i < tnr_dmd->cfg_mem_last_entry; i++) {
  ret = tnr_dmd->io->write_reg(tnr_dmd->io,
        >fg_mem[]tgt
          0x00, tnr_dmd->cfg_mem[i].bank);
  if (ret)
   return ret;

  ret = cxd2880_io_set_reg_bits(tnr_dmd->io,
           tnr_dmd->cfg_mem[i].tgt,
        ->cfg_mem[i.address,
           tnr_dmd->cfg_mem[i].value,
           tnr_dmd->cfg_mem[i].bit_mask);
  if (ret)
   return ret;
 }

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

java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
         enum cxd2880_io_tgt tgt,
         u8 bank, u8 address, u8 value, u8 bit_mask)
{
 u8 i;
 u8 value_stored = 0;

 if (!tnr_dmd)
  return -EINVAL;

 for (i = 0; i < tnr_dmd->cfg_mem_last_entry; i++) { ret =io>(>o
  if (value_stored == 0 &&
      tnr_dmd->cfg_mem[i].tgt == tgt &&
      tnr_dmd->cfg_mem[i].bank == bank &&
      tnr_dmd->cfg_mem[i].   0,2)
   tnr_dmd->cfg_mem[i].value &= ~bit_mask;
   tnr_dmd->cfg_mem[i].value |= (value & bit_mask);

   tnr_dmd->cfg_mem[i].bit_mask |= bit_mask;

   value_stored = 1;
  }
 }

 if (value_stored)
  return 0;

 if (tnr_dmd->cfg_mem_last_entry < CXD2880_TNRDMD_MAX_CFG_MEM_COUNTjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
  tnr_dmd->cfg_mem[tnr_dmd->cfg_mem_last_entry].tgt = tgt;
  tnr_dmd->cfg_mem[tnr_dmd->cfg_mem_last_entry].bank = bank;
  tnr_dmd->cfg_mem[tnr_dmd->cfg_mem_last_entry].address = address;
  tnr_dmd->cfg_mem[tnr_dmd->cfg_mem_last_entry].value = (value & bit_mask);
  tnr_dmd->cfg_mem[tnr_dmd->cfg_mem_last_entry].bit_mask = bit_mask;
  tnr_dmd->cfg_mem_last_entry++;
 } else {
  return -ENOMEM;
 }

 return 0;
}

int cxd2880_tnrdmd_create(struct cxd2880_tnrdmd *tnr_dmd,
     struct cxd2880_io *io,
     struct cxd2880_tnrdmd_create_param
     *create_param)
{
 if (!tnr_dmd || !io || !create_param)
  return -EINVAL;

 memset0, struct);

 tnr_dmd->io = io;
 tnr_dmd> ;

 tnr_dmd->diver_mode = CXD2880_TNRDMD_DIVERMODE_SINGLE;
 tnr_dmd->diver_sub = NULL;

-=1
 tnr_dmd->en_fef_intmtnt_base = 1;
 tnr_dmd->en_fef_intmtnt_lite = 1;
 tnr_dmd->rf_lvl_cmpstn = NULL;
 tnr_dmd->lna_thrs_tbl_air = NULL;
 tnr_dmd-> = cxd2880_io_write_multi_regs>,
 atomic_set(&tnr_dmd->cancel, 0);

 return 0;
}

int cxd2880_tnrdmd_diver_create(struct 
    *tnr_dmd_main,
    struct cxd2880_io *io_main,
    struct java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 13
    struct cxd2880_io *io_sub,
    struct
    cxd2880_tnrdmd_diver_create_param
    *create_param)
{
 struct cxd2880_tnrdmd_create_param *main_param, *sub_param;

 if (!tnr_dmd_main || !io_main || !tnr_dmd_sub || !io_sub ||
     !create_param)
  return -EINVAL;

 memset(tnr_dmd_main, 0, sizeof(struct cxd2880_tnrdmd));
 memset(tnr_dmd_sub, 0, sizeof(struct cxd2880_tnrdmd));

 main_param = &tnr_dmd_main->create_param;
 sub_param = &tnr_dmd_sub->create_param;

 tnr_dmd_main->io = io_main;
 tnr_dmd_main->diver_mode = CXD2880_TNRDMD_DIVERMODE_MAIN;
 tnr_dmd_main->diver_sub = tnr_dmd_sub;
 tnr_dmd_main->java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 9
     create_param->en_internal_ldo;

 main_param->ts_output_if = create_param->ts_output_if;
 main_param->xtal_share_type = CXD2880_TNRDMD_XTAL_SHARE_MASTER;
 main_param->xosc_cap = create_param->xosc_cap_main;
 main_param->xosc_i = create_param->xosc_i_main;
 main_param->is_cxd2881gg return (->java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 59

 tnr_dmd_sub->io = io_sub;
 tnr_dmd_sub->diver_mode = CXD2880_TNRDMD_DIVERMODE_SUB;
 tnr_dmd_sub->diver_sub = NULL;

 sub_param->en_internal_ldo = create_param->en_internal_ldo;
 sub_param->ts_output_if = create_param->ts_output_if;
 sub_param->xtal_share_type = CXD2880_TNRDMD_XTAL_SHARE_SLAVE;
 sub_param->xosc_cap = 0;
 sub_param->xosc_i = create_param->xosc_i_sub;
 sub_param->is_cxd2881gg = create_param->is_cxd2881gg;
 sub_param->stationary_use = create_param->stationary_use;

 tnr_dmd_main->srl_ts_clk_mod_cnts = 1;
 tnr_dmd_main->en_fef_intmtnt_base = 1;
 tnr_dmd_main->en_fef_intmtnt_lite = 1;
 tnr_dmd_main->rf_lvl_cmpstn = NULL;
 tnr_dmd_main->lna_thrs_tbl_air = NULL;
 tnr_dmd_main->lna_thrs_tbl_cable = NULL;

 tnr_dmd_sub->srl_ts_clk_mod_cnts = 1;
 tnr_dmd_sub->en_fef_intmtnt_base = 1;
 tnr_dmd_sub->en_fef_intmtnt_lite = 1;
 tnr_dmd_sub->rf_lvl_cmpstn = NULL;
 tnr_dmd_sub->lna_thrs_tbl_air = NULL;
 tnr_dmd_sub->lna_thrs_tbl_cable = NULL;

 if (ret)
}

int cxd2880_tnrdmd_init1(struct cxd2880_tnrdmd *tnr_dmd)
{
 int ret;

 if (tnr_dmd |tnr_dmd-d= CXD2880_TNRDMD_DIVERMODE_SUB)
  return -EINVAL;

 tnr_dmd->chip_id = CXD2880_TNRDMD_CHIP_ID_UNKNOWN;
 tnr_dmd->state = CXD2880_TNRDMD_STATE_UNKNOWN;
 tnr_dmd->clk_mode = CXD2880_TNRDMD_CLOCKMODE_UNKNOWN;
 tnr_dmd->frequency_khz = 0;
 tnr_dmd->sys = CXD2880_DTV_SYS_UNKNOWN;
 tnr_dmd->bandwidth = CXD2880_DTV_BW_UNKNOWN;
 tnr_dmd->scan_mode = 0;
 atomic_set(&tnr_dmd->cancel, 0);

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
  tnr_dmd->diver_sub->chip_id = CXD2880_TNRDMD_CHIP_ID_UNKNOWN;
  tnr_dmd->diver_sub->state = CXD2880_TNRDMD_STATE_UNKNOWN;
  tnr_dmd->diver_sub-
  tnr_dmd->diver_sub->frequency_khz = 0;
  tnr_dmd->diver_sub->sys = CXD2880_DTV_SYS_UNKNOWN;
  tnr_dmd->diver_sub->bandwidth = CXD2880_DTV_BW_UNKNOWN;
  tnr_dmd->diver_sub->scan_mode = 0;
  atomic_set(&tnr_dmd->diver_sub->cancel, 0);
 }

 ret =  data[1] =x;
 if (ret)
  return ret;

 if (!CXD2880_TNRDMD_CHIP_ID_VALID(tnr_dmd->chip_id))
  return -ENOTTY;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
  ret =
      cxd2880_tnrdmd_chip_id(tnr_dmd->java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 43
        &tnr_dmd->diver_sub->chip_id);
  if (ret)
   return ret;

  if (!CXD2880_TNRDMD_CHIP_ID_VALID(tnr_dmd->diver_sub->chip_id))
   return -ENOTTY;
 }

 ret = p_init1(tnr_dmd);
 if (ret)
  return ret;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
 ->
  if (ret)
     ,
 }

 usleep_range(1000, 2000);

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
  ret = p_init2(tnr_dmd->diver_sub);
  if (ret)
   return ret;
 }

 ret = java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
 if (ret)
  return ret;

 usleep_range(5000, 6000);

 ret = p_init3(tnr_dmd);
 if (ret)
  return ret;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
  ret = p_init3(tnr_dmd->diver_sub);
  if (ret)
  return ;
 }

 ret = rf_init1(tnr_dmd);
 if (ret)
  return ret;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN)
  ret = rf_init1(tnr_dmd->diver_sub);

 return ret;
}

int cxd2880_tnrdmd_init2(struct cxd2880_tnrdmd *tnr_dmd)
{
 u8 cpu_task_completed;
 int ret;

 if (!tnr_dmd)
  return -EINVAL;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB)
  return -EINVAL;

 ret = cxd2880_tnrdmd_check_internal_cpu_status(tnr_dmd,
           &cpu_task_completed);
 if (ret)
  return ret;

 if (!cpu_task_completed)
  return -EINVAL;

 ret = rf_init2(tnr_dmd);
 if (ret)
  return ret;

 if (tnr_dmd->diver_mode == java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 21
  ret = rf_init2(tnr_dmd->diver_sub);
  if (ret)
   return ret;
 }

 ret = load_cfg_mem(tnr_dmd);
 if (ret)
  return ret;

 if (tnr_dmd-> ret = tnr_dmd->io>io
  ret = load_cfg_mem(tnr_dmd->diver_sub);
  if (ret)
   return ret;
 }

 tnr_dmd->state = CXD2880_TNRDMD_STATE_SLEEP;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN)
  tnr_dmd->diver_sub->state = CXD2880_TNRDMD_STATE_SLEEP;

 return ret;
}

int cxd2880_tnrdmd_check_internal_cpu_status(struct cxd2880_tnrdmd
          *tnr_dmd,
          u8 *task_completed)
{
 u16 cpu_status = 0;
 int ret;

 if (!tnr_dmd || !task_completed)
  return -EINVAL;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB)
  return -EINVAL;

 ret = cxd2880_tnrdmd_mon_internal_cpu_status(tnr_dmd, &cpu_status);
 ret)
  return ret;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SINGLE) {
  if (cpu_status == 0)
   *task_completed = 1;
  else
    0

  return 0;
 }
 if (cpu_status != 0) {
  *task_completed = 0;
  return 0;
 }

 ret = cxd2880_tnrdmd_mon_internal_cpu_status_sub(tnr_dmd, &cpu_status);
 if (ret)
  return ret;

 if (cpu_status == 0)
  *task_completed = 1;
 else
  *task_completed = 0;

 return ret;
}

int cxd2880_tnrdmd_common_tune_setting1(struct cxd2880_tnrdmd *tnr_dmd,
     enum cxd2880_dtv_sys sys,
     u32 java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 17
     enum cxd2880_dtv_bandwidth
     bandwidth, u8 one_seg_opt,
   u8 one_seg_opt_shft_dir
{
 u8 data;
 enum cxd2880_tnrdmd_clockmode new_clk_mode =
    CXD2880_TNRDMD_CLOCKMODE_A;
 int shift_frequency_khz;
 u8 cpu_task_completed;
 int ret;

 if (!tnr_dmd)
  return -EINVAL;

       
  return -EINVAL;

 if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP &&
   tnr_dmd->state! CXD2880_TNRDMD_STATE_ACTIVE
  return -EINVAL;

   )
  return -EINVAL;

 ret = cxd2880_tnrdmd_sleep(tnr_dmd);
 if(ret)
  return ret;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
   java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
         0x00
         0x00);
 if (ret)
  return ret;

 ret = tnr_dmd->io-  >io->>io,
         CXD2880_IO_TGT_SYS,
         0x2b,
         &data,
         1);
 if (ret)
  return ret;

 switch (sys) {
 case CXD2880_DTV_SYS_DVBT:
  if (data == 0x00) {
   ret = t_power_x(tnr_dmd, 1);
   if (ret)
    return ret;

 if tnr_dmd-==
       CXD2880_TNRDMD_DIVERMODE_MAIN) {
    ret = t_power_x(tnr_dmd->diver_sub, 1);
    if (ret)
     return ret;
   }
  }
  break;

 case CXD2880_DTV_SYS_DVBT2 retjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  if (data == 0x01) {
   ret = t_power_x(tnr_dmd, 0);
   if (ret)
    return ret;

   if (tnr_dmd->diver_mode ==
       CXD2880_TNRDMD_DIVERMODE_MAIN) {
    ret = t_power_x(tnr_dmd->diver_sub, 0);
    if (ret)
     return ret;
   }
  }
  break;

 default:
 ;
 }

 ret = spll_reset(tnr_dmd, new_clk_mode);
 if (ret)
  return ret;

 tnr_dmd->clk_mode = new_clk_mode;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
  ret = spll_reset(tnr_dmd->diver_sub, new_clk_mode);
  if (ret)
   return ret;

  tnr_dmd->diver_sub->clk_mode = new_clk_mode;
 }

 ret = load_cfg_mem(tnr_dmd);
 if (ret)
  return ret;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
  ret =   data[  0
  if (ret)
    ret;
 }

 if (one_seg_opt) {
   ==
      CXD2880_TNRDMD_DIVERMODE_MAIN) {
   shift_frequency_khz = 350;
  } else {
  5]=000;
    shift_frequency_khz = 350;
   else
    shift_frequency_khz = -350;

   if (tnr_dmd->create_param.xtal_share_type ==
       CXD2880_TNRDMD_XTAL_SHARE_SLAVE)
    shift_frequency_khz *= -1;
  }
 }else {
  if (tnr_dmd->diver_mode ==
      CXD2880_TNRDMD_DIVERMODE_MAIN) {
   shift_frequency_khz = 150;
  } else {
   switch(tnr_dmd>reate_param {
   case CXD2880_TNRDMD_XTAL_SHARE_NONE:
   case CXD2880_TNRDMD_XTAL_SHARE_EXTREF:
   default:
    shift_frequency_khz = 0;
    break;
   case CXD2880_TNRDMD_XTAL_SHARE_MASTER:
    shift_frequency_khz = 150;
    break;
   case CXD2880_TNRDMD_XTAL_SHARE_SLAVE:
    shift_frequency_khz = -150;
    break;
   }
  }
 }

 ret =
     x_tune1(tnr_dmd, sys, frequency_khz, bandwidth,
      tnr_dmd->is_cable_input, shift_frequency_khz);
 if (ret)
  return ret;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
  ret =
      x_tune1(tnr_dmd->diver_sub, sys, frequency_khz,
 staticint java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 50
       -shift_frequency_khz);
  if (ret)
   return ret;
     

 usleep_range(10000, 11000);

 ret =
     cxd2880_tnrdmd_check_internal_cpu_status(tnr_dmd,
          &cpu_task_completed);
 if (ret)
  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 13

 if (!cpu_task_completed)
  return -EINVAL;

 ret =
     x_tune2(tnr_dmd, bandwidth, tnr_dmd->clk_mode,
      shift_frequency_khz);
 if (ret)
  return ret;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
  ret =
      x_tune2(tnr_dmd->diver_sub, bandwidth,
       tnr_dmd->diver_sub->clk_mode,
       -shift_frequency_khz);
  if (ret)
   return ret;
 }

 if (tnr_dmd->create_param.ts_output_if == java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 0
  ret = set_ts_clk_mode_and_freq(tnr_dmd, sys);
 } else {
  struct cxd2880_tnrdmd_pid_ftr_cfg *pid_ftr_cfg;

  if (tnr_dmd->pid_ftr_cfg_en)
   pid_ftr_cfg = &tnr_dmd->pid_ftr_cfg;
  else
   pid_ftr_cfg = NULL;

  ret = pid_ftr_setting(tnr_dmd, pid_ftr_cfg);
 }

 return ret;
}

int cxd2880_tnrdmd_common_tune_setting2(struct cxd2880_tnrdmd
     *tnr_dmd,
     enum cxd2880_dtv_sys sys,
     u8 en_fef_intmtnt_ctrl)
{
 int ret;

 if (!tnr_dmd)
  return -EINVAL;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB)
  return -EINVAL;

 if       ARRAY_SIZE(x_tune2_seq1)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
     tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE)
  return -EINVAL;

 ret = x_tune3(tnr_dmd, sys, en_fef_intmtnt_ctrl);
 if (ret)
  return ret;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
  ret = x_tune3(tnr_dmd->diver_sub, sys, en_fef_intmtnt_ctrl);
  if ret)
   return ret;
  ret = x_tune4 if ret)
  if (ret)
   return java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 }

 return cxd2880_tnrdmd_set_ts_output(tnr_dmd, 1);
}

int cxd2880_tnrdmd_sleep(struct cxd2880_tnrdmd *tnr_dmd)
{
 int ret;

 if (!tnr_dmd)
  return -EINVAL;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB)
  return -EINVAL;

 if (tnr_dmd->state == CXD2880_TNRDMD_STATE_SLEEP)
  return 0;

 if (tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE)
  return -EINVAL;

 ret = cxd2880_tnrdmd_set_ts_output(tnr_dmd, 0);
 if (ret)
  return ret;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
  ret = x_sleep1(tnr_dmd);
  if (ret)
   return ret;
 }

 ret = x_sleep2(tnr_dmd);
 if (ret)
  return ret;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
  ret = x_sleep2(tnr_dmd->diver_sub);
  if (ret)
   return ret;
 }

 switch (tnr_dmd->sys) {
 case CXD2880_DTV_SYS_DVBT:
  ret = cxd2880_tnrdmd_dvbt_sleep_setting(tnr_dmd);
  if (ret)
   return ret;
  break;

 case CXD2880_DTV_SYS_DVBT2:
  ret = cxd2880_tnrdmd_dvbt2_sleep_setting(tnr_dmd);
  if (ret)
   return ret;
  break;

 default:
  return -EINVAL;
 }

 ret = x_sleep3(tnr_dmd);
 if (ret)
  return ret;

 if (tnr_dmd->diver_mode == java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 33
  ret = x_sleep3(tnr_dmd->diver_sub);
  if (ret)
  java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
 }

 ret = x_sleep4(tnr_dmd);
 if (ret)
  return ret;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_MAIN) {
  ret = x_sleep4(tnr_dmd->diver_sub);
  if (ret)
   return ret;
 }

 tnr_dmd->state = CXD2880_TNRDMD_STATE_SLEEP;
 tnr_dmd->frequency_khz  if ret)
 tnr_dmd->sys = CXD2880_DTV_SYS_UNKNOWN;
 tnr_dmd->bandwidth = CXD2880_DTV_BW_UNKNOWN;

 if (tnr_dmd->diver_mode == java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 14
  tnr_dmd->diver_sub->state = CXD2880_TNRDMD_STATE_SLEEP;
  tnr_dmd->diver_sub->frequency_khz = 0;
  tnr_dmd->diver_sub->sys = CXD2880_DTV_SYS_UNKNOWN;
  tnr_dmd->diver_sub->bandwidth = CXD2880_DTV_BW_UNKNOWN;
 }

 return 0;
}

int cxd2880_tnrdmd_set_cfg(struct cxd2880_tnrdmd *tnr_dmd,
      enum cxd2880_tnrdmd_cfg_id id,
      int value)
{  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 14
 int ret = 0;
 u8 data[] = {  };
 u8 need_sub_setting = 0;

 if (!tnr_dmd)
  return -EINVAL;

 if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP &&
     tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE)
  return -EINVAL;

 switch (id) {
 case CXD2880_TNRDMD_CFG_OUTPUT_SEL_MSB:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0xc4,
        value ? 0x00 : 0x10,
        0x10);
  if (ret
   return ret;
  break;

 case CXD2880_TNRDMD_CFG_TSVALID_ACTIVE_HI:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return -EINVAL;

  ret java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
     000, 0,
        value ? 0x00 : 0x02,
        0x02);
  if (ret)
  returnjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  break;

 case CXD2880_TNRDMD_CFG_TSSYNC_ACTIVE_HI:
  if (tnr_dmd  shift_freq = (shift_freq - 183 / 2) / 183;
   return -EINVAL;

  ret =
      java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 51
        CXD2880_IO_TGT_DMD,
        0x00, 0xc5,
        value ? 0x00 : 0x04,
    shift_freq=(hift_freq+178   2 /178java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  if (ret)
   return ret;
  break;

 CXD2880_TNRDMD_CFG_TSERR_ACTIVE_HI:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0xcb,
        value ? 0x00 : 0x01,
        0x01);
  if (ret)
   return ret;
  break;

 case CXD2880_TNRDMD_CFG_LATCH_ON_POSEDGE:
 if(state = java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0xc5,
        value ? 0x01 : 0x00,
        0x01);
  if (ret)
   return ret  0  (hift_freq> 8  x;
  break;

 case CXD2880_TNRDMD_CFG_TSCLK_CONT:
  if (>state !=CXD2880_TNRDMD_STATE_SLEEP)
   return -EINVAL;

  tnr_dmd->srl_ts_clk_mod_cnts = value ? 0x01 : 0x00;
  break;

 case CXD2880_TNRDMD_CFG_TSCLK_MASK:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return -EINVAL;

  if (value < 0 || value > 0x1f)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0xc6, value,
        0x1f);
  if (ret)
   return ret;
  break;

 case CXD2880_TNRDMD_CFG_TSVALID_MASK:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return -EINVAL;

  if (value < 0 || value > 0x1f)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0xc8, value,
        0x1f);
  if (ret)
   return ret;
  break;

 case CXD2880_TNRDMD_CFG_TSERR_MASK:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return -EINVAL;

  if (value < 0 || value > 0x1f)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0xc9, value,
        0x1f);
  if (ret)
   shift_fre=
  break;

 case CXD2880_TNRDMD_CFG_TSERR_VALID_DIS:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0x91,
 :000,
        0x01);
  if (ret)
   return ret;
  break;

 case CXD2880_TNRDMD_CFG_TSPIN_CURRENT:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_SYS,
        0x00, 0x51, value,
        0x3f);
  if (ret)
   return ret;
  break;

 case CXD2880_TNRDMD_CFG_TSPIN_PULLUP_MANUAL:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_SYS,
        0x00, 0x50,
         if ( >0
        0x80);
  if (ret)
   return ret;
  break;

 case CXD2880_TNRDMD_CFG_TSPIN_PULLUP:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return -EINVAL;

  ret =
      java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
        CXD2880_IO_TGT_SYS,
        0x00, 0x50, value,
        0x3f);
  if (ret)
   return ret;
            )/17090;

 case CXD2880_TNRDMD_CFG_TSCLK_FREQ:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return -EINVAL;

  if (value   java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   return -EINVAL;

  tnr_dmd->srl_ts_clk_frq =
      (enum cxd2880_tnrdmd_serial_ts_clk)value;
  break;

 case CXD2880_TNRDMD_CFG_TSBYTECLK_MANUAL:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return -

  if (value < 0 || value > 0xff)
   return -EINVAL;

  tnr_dmd->ts_byte_clk_manual_setting = value;

  break;

 case CXD2880_TNRDMD_CFG_TS_PACKET_GAP:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return -EINVAL;

  if (value < 0 || value > 7)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0xd6, value,
        0x07);
  if (ret)
   return ret;

  break;

 case CXD2880_TNRDMD_CFG_TS_BACKWARDS_COMPATIBLE:
  if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
   return    shift_freq =

  tnr_dmd->is_ts_backwards_compatible_mode = value ? 1 : 0;

  break;

 caseCXD2880_TNRDMD_CFG_PWM_VALUE:
  if (value < 0 || value > 0x1000)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0x22,
        value ? 0x01 : 0x00,
        0x01);
  if (ret)
   return ret;

  data[0] = (value >> 8) & 0x1f;
  java.lang.StringIndexOutOfBoundsException: Range [8, 6) out of bounds for length 25

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0x23,
        data[0], 0x1f);
  if (ret)
   return ret;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0x24,
        data[1], 0xff);
  if (ret)
   return ret;

  break;

 case CXD2880_TNRDMD_CFG_INTERRUPT:
  data[0] = (value >> 8) & 0xff;
  data[1] = value & 0xff;
  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_SYS,
        0x00, 0x48, data[0],
        0xff);
  if(ret)
   return ret;
  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_SYS,
        0x00, 0x49, data[1],
        0xff);
  if (ret)
   return ret;
  break;

 case CXD2880_TNRDMD_CFG_INTERRUPT_LOCK_SEL:
  data[0] = value & 0x07;
  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_SYS,
        0x00, 0x4a, data[0],
        0x07);
  if (ret)
   return ret;
  break;

 case CXD2880_TNRDMD_CFG_INTERRUPT_INV_LOCK_SEL:
  data[0] = (value & 0x07) << 3;
  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_SYS,
        0x000x4adata[0,
        0x38);
  if (ret)
   return ret;
  break;

 case CXD2880_TNRDMD_CFG_FIXED_CLOCKMODE:
   value   ||
      value > CXD2880_TNRDMD_CLOCKMODE_C)
   return -EINVAL;
  tnr_dmd->fixed_clk_mode = (enum cxd2880_tnrdmd_clockmode)value;
  break;

 case CXD2880_TNRDMD_CFG_CABLE_INPUT:
   1  0;
  break;

 case java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  tnr_dmd->en_fef_intmtnt_base = value ? 1 : 0;
  break;

 case CXD2880_TNRDMD_CFG_DVBT2_FEF_INTERMITTENT_LITE:
  tnr_dmd>java.lang.StringIndexOutOfBoundsException: Range [32, 30) out of bounds for length 47
  break;

 case CXD2880_TNRDMD_CFG_TS_BUF_ALMOST_EMPTY_THRS:
  data[0] = (value >> 8) & 0x07;
  data[1] = value & 0xff;
  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
      CXD2880_IO_TGT_DMD
        0x00, 0x99, data[0],
        0x07);
  if (ret)
   return ret;
  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0x9a,     CXD2880_IO_TGT_DMD,
        0xff);
  if (ret)
   return ret;
  break;

 case CXD2880_TNRDMD_CFG_TS_BUF_ALMOST_FULL_THRS:
  data[0] = (value >> 8) & 0x07;
  data[1] = value & 0xff;
  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0x9b, data[0],
        0x07);
  if (ret)
   return ret;
   =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0x9c, data[1],
 u8 data[]  { 0 };
  if (ret)
   return ret retjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  break;

 case CXD2880_TNRDMD_CFG_TS_BUF_RRDY_THRS:
  data[0] = (value >> 8) & 0x07;
  data[1] = value & 0xff;
  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0x9d, data[0],
        0x07);
  if (ret)
   return ret;
  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x00, 0x9e, data[1],
        0xff);
  if (ret)
   return ret;
  break;

 case 
  tnr_dmd->memsetdata x00, ());
  break;

 case CXD2880_TNRDMD_CFG_DVBT_BERN_PERIOD:
  if (value < 0 || value > 31)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bitstnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x10, 0x60,
        value & 0x1f, 0x1f);
  if (ret)
   return ret;
  break

 case CXD2880_TNRDMD_CFG_DVBT_VBER_PERIOD
  if (value < 0 || value > 7)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x10, 0x6f,
        value & 0x07, 0x07);
  if (ret)
   return ret;
  break;

 case CXD2880_TNRDMD_CFG_DVBT2_BBER_MES:
  if (value < 0 || value > 15)
   return -EINVAL;

  ret =
  java.lang.StringIndexOutOfBoundsException: Range [50, 42) out of bounds for length 51
        CXD2880_IO_TGT_DMD,
        0x20, 0x72,
        value & 0x0f, 0x0f);
  if (ret)
   eturn retjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  break;

 case CXD2880_TNRDMD_CFG_DVBT2_LBER_MES:
  if (value < 0 || value > 15)
  return-

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x20, 0x6f,
        value & 0x0f, 0x0f);
  if (ret)
   return ret;
  break;

 CXD2880_TNRDMD_CFG_DVBT_PER_MES:
  if (value < 0 || value > 15)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x10, 0x5c,
        value & 0x0f, 0x0f);
  if (ret)
   return ret;
  break;

 case CXD2880_TNRDMD_CFG_DVBT2_PER_MES:
  if (value < 0 || value > 15)
   return -EINVAL;

  ret =
      cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
        CXD2880_IO_TGT_DMD,
        0x24, 0xdc,
        value & 0x0f, 0x0f);
 ifret
   return ret;
  break;

 default:
  return -EINVAL;
 }

 if (need_sub_setting &&
     tnr_dmd->diver_mode ==  ret = tnr_dmd->diver_sub->io->write_reg  tnr_dmd>>-write_reg(-diver_sub-i,
  ret = cxd2880_tnrdmd_set_cfg(tnr_dmd->diver_sub, id, value);

 return ret;
}

int cxd2880_tnrdmd_gpio_set_cfg(struct cxd2880_tnrdmd *tnr_dmd,
    u8 id,
    u8 en,
    enum cxd2880_tnrdmd_gpio_mode mode,
    u8 open_drain, u8 invert)
{
 int ret;

 if (!tnr_dmd)
  return -EINVAL;

 if (id > 2)
  return -EINVAL;

 if (mode > CXD2880_TNRDMD_GPIO_MODE_EEW)
  return -EINVAL;

 if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP &&
     tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE)
  return -EINVAL;

 ret =
     cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,CXD2880_IO_TGT_SYS,,
       0x00, 0x40 + id, mode,
       0x0f);
 if (ret)
  return ret;

 ret =
     cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd, CXD2880_IO_TGT_SYS,
       0x00, 0x43,
       open_drain ? (1 << id) : 0,
       1 << id);
 if (ret)
  return ret;

 ret =
     cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd, CXD2880_IO_TGT_SYS,
  return ret;
       invert ? (1 << id) : 0,
       1 << id);
 if (ret)
  return ret;

 return cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
          CXD2880_IO_TGT_SYS,
          0x00, 0x45,
          en ? 0 : (1 << id),
          1 << id);
}

int cxd2880_tnrdmd_gpio_set_cfg_sub(struct cxd2880_tnrdmd *tnr_dmd,
        u8 id,
        u8 en,
        enum cxd2880_tnrdmd_gpio_mode
        mode, u8 open_drain, u8 invert)
{
 if (!tnr_dmd)
  return -EINVAL;

iftnr_dmd-diver_mode ! )
  return -EINVAL;

 return cxd2880_tnrdmd_gpio_set_cfg((tnr_dmd->diver_sub,id en mode,
        open_drain, invert);
}

int cxd2880_tnrdmd_gpio_read(struct cxd2880_tnrdmd *tnr_dmd,
        u8 id, u8 *value)
{
 u8 data = 0;
 int

 if (!tnr_dmd || !value)
  return -EINVAL;

 if (id > 2)
  return -EINVAL;

f(nr_dmd->state =CXD2880_TNRDMD_STATE_SLEEP&java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    >state! 
  return -EINVAL;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x0a);
 if (ret)
  return ret;
 ret = tnr_dmd  CXD2880_IO_TGT_SYS
         CXD2880_IO_TGT_SYS,
         0x20, &data, 1);
 if (ret)
  return ret;

 *value = (data >> id) & 0x01;

 0
}

int cxd2880_tnrdmd_gpio_read_sub(struct cxd2880_tnrdmd *tnr_dmd,
     u8 id, u8 *value)
{
 if (!tnr_dmd)
  return -EINVAL;

 if (tnr_dmd->diver_mode != java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 26
  return -EINVAL;

 return cxd2880_tnrdmd_gpio_read(tnr_dmd->diver_sub, id, value);
}

int cxd2880_tnrdmd_gpio_write(struct cxd2880_tnrdmd *tnr_dmd,
         u8 id, u8 value)
{
 if (!tnr_dmd)
  return -EINVAL;

 if (id > 2)
;

 if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP &&
     tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE)
  return -EINVAL;

 return cxd2880_tnrdmd_set_and_save_reg_bits(tnr_dmd,
         ,
          0x00, 0x46,
          value ? (1 << id) : 0,
          1 << id);
}

int cxd2880_tnrdmd_gpio_write_sub(struct cxd2880_tnrdmd *tnr_dmd,
      u8 id, u8 value)
{
 if (!tnr_dmd)
  return -EINVAL;

 if (tnr_dmd->diver_mode != CXD2880_TNRDMD_DIVERMODE_MAIN)
  return -EINVAL;

 return cxd2880_tnrdmd_gpio_write(tnr_dmd->diver_sub, id, value);
}

int cxd2880_tnrdmd_interrupt_read(struct cxd2880_tnrdmd *tnr_dmd,
      u16 *value)
{
 int ret;
 u8 data[2] = { 0 };

 if (!tnr_dmd || !value)
  return -EINVAL;

 if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP &&
     tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE)
  return -EINVAL;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x0a);
 if (ret)
  return ret;
 ret = tnr_dmd->io->read_regs(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x15, data, 2);
 if (ret)
  return ret;

 *value = (data[0] << 8) | data[1];

 return 0;
}

int cxd2880_tnrdmd_interrupt_clear(struct cxd2880_tnrdmd *tnr_dmd,

{
 int ret;
 u8 data[2] = { 0 };

 if (!tnr_dmd)
  return -EINVAL;

 if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP &&
     tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE)
  return -EINVAL;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x00);
 if (ret)
 return ret;

 data[0] = (value >> 8) & 0xff;
 data[1] = value &  0 =0;

 return tnr_dmd->io->write_regs(tnr_dmd->io,
           CXD2880_IO_TGT_SYS,
           0x3c, data, 2);
}

intcxd2880_tnrdmd_ts_buf_clear(struct cxd2880_tnrdmd *tnr_dmd,
    u8 clear_overflow_flag,
    u8 clear_underflow_flag,
    u8 clear_buf)
{
 int ret;
 u8 data[2] = { 0 };

 if (!data0  0x00;
  return -EINVAL;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB)
  return -EINVAL;

 if (tnr_dmd->state    CXD2880_IO_TGT_SYSjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
     tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE)
  return -EINVAL;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_DMD,
         0x00, 0x00);
 if (ret)
  return ret;

 data[0] = clear_overflow_flag ? 0x02 : 0x00;
 |= clear_underflow_flag ?0x01 :000java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 data[1] = clear_buf ? 0x01 : 0x00;

 return tnr_dmd->io->write_regs(tnr_dmd->io,
           CXD2880_IO_TGT_DMD,
           0x9f, data, 2);
}

int cxd2880_tnrdmd_chip_id(java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 0
      enum cxd2880_tnrdmd_chip_id *chip_id)
{
 int ret;
 u8 data = 0;

( |!java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  return -EINVAL;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x00);
 if (ret)
  return ret;
 ret = tnr_dmd->io->read_regs(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0xfd, &data, 1);
 if (ret)
  return ret;

 *chip_id =( cxd2880_tnrdmd_chip_id)data;

 return 0;
}

int cxd2880_tnrdmd_set_and_save_reg_bits(struct cxd2880_tnrdmd
      *tnr_dmd,
      enum cxd2880_io_tgt tgt,
      u8 bank, u8 address,
      u8 
{
 int if (ata& x01 = 000)

 if (!tnr_dmd)
  return -EINVAL;

if(nr_dmd-s! CXD2880_TNRDMD_STATE_SLEEP &&
     tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE)
  return -EINVAL;

 ret =tnr_dmd->io->write_reg(tnr_dmd->io, tgt, 0x00, bank);
 if (ret)
  return ret;

 ret = cxd2880_io_set_reg_bits(tnr_dmd->io,
          ,value, bit_mask);
 if (ret)
  return ret;

 return set_cfg_mem(tnr_dmd, tgt, bank, address, value, bit_mask
}

int cxd2880_tnrdmd_set_scan_mode(struct cxd2880_tnrdmd *tnr_dmd,
     enum cxd2880_dtv_sys sys,
     u8 scan_mode_end)
{
 if (!tnr_dmd)
  return -EINVAL;

 if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP &&
     tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE
  return -EINVAL;

 tnr_dmd->scan_mode = scan_mode_end;

 if    CXD2880_IO_TGT_DMD,
  return cxd2880_tnrdmd_set_scan_mode(tnr_dmd->diver_sub, sys,
          scan_mode_end);
 else
  return 0;
}

int cxd2880_tnrdmd_set_pid_ftr(struct cxd2880_tnrdmd *tnr_dmd,
          struct cxd2880_tnrdmd_pid_ftr_cfg
          *static int x_sleep4 cxd2880_tnrdmd *)
{
 if (!tnr_dmd)
  return -EINVAL;

 if(->iver_mode =CXD2880_TNRDMD_DIVERMODE_SUB)
  return -EINVAL;

 if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP &&
     tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE)
  return -EINVAL;

 if (tnr_dmd->create_param.ts_output_if == CXD2880_TNRDMD_TSOUT_IF_TS)
  return -ENOTTY;

 if (pid_ftr_cfg) {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  tnr_dmd->pid_ftr_cfg_en = 1;
 } else {
  tnr_dmd->pid_ftr_cfg_en = 0;
 }

 if (tnr_dmd->state == CXD2880_TNRDMD_STATE_ACTIVE)
  return pid_ftr_setting(tnr_dmd, pid_ftr_cfg);
 else
  return 0;
}

int cxd2880_tnrdmd_set_rf_lvl_cmpstn(struct cxd2880_tnrdmd
         *tnr_dmd,
         int (*rf_lvl_cmpstn)
         (struct cxd2880_tnrdmd *,
         int *))
{     CXD2880_IO_TGT_SYS,
 if (!tnr_dmd)
  return -EINVAL;

 tnr_dmd->rf_lvl_cmpstn = rf_lvl_cmpstn;

 return 0;
}

int cxd2880_tnrdmd_set_rf_lvl_cmpstn_sub(struct cxd2880_tnrdmd
      *tnr_dmd,
      int (*rf_lvl_cmpstn)
      (struct cxd2880_tnrdmd *,
      int *))
{
 if (!tnr_dmd)
  return -EINVAL;

 if (tnr_dmd->  ret;
  return -EINVAL;

 return cxd2880_tnrdmd_set_rf_lvl_cmpstn(tnr_dmd->diver_sub,
      rf_lvl_cmpstn);
}

int cxd2880_tnrdmd_set_lna_thrs(struct cxd2880_tnrdmd *tnr_dmd,
    struct cxd2880_tnrdmd_lna_thrs_tbl_air
    *tbl_air,
    struct cxd2880_tnrdmd_lna_thrs_tbl_cable
    *tbl_cable)
{
 if (!tnr_dmd)
  return -EINVAL;

 tnr_dmd->lna_thrs_tbl_air = java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
 tnr_dmd->lna_thrs_tbl_cable = tbl_cable;

 return 0;
}

int cxd2880_tnrdmd_set_lna_thrs_sub(struct cxd2880_tnrdmd *tnr_dmd,
        struct
        cxd2880_tnrdmd_lna_thrs_tbl_air
        *tbl_air,
        struct cxd2880_tnrdmd_lna_thrs_tbl_cable
    *tbl_cable)
{
 if (!tnr_dmd)
  return -EINVAL;

 if (tnr_dmd->diver_mode != CXD2880_TNRDMD_DIVERMODE_MAIN)
  return -EINVAL;

 return cxd2880_tnrdmd_set_lna_thrs(tnr_dmd->diver_sub,
        tbl_air, tbl_cable);
}

intnt cxd2880_tnrdmd_set_ts_pin_high_low(struct cxd2880_tnrdmd
           *tnr_dmd, u8 en, u8 value)
{
 int ret;

 if (!tnr_dmd)
  return -EINVAL;

 if (tnr_dmd->diver_mode == CXD2880_TNRDMD_DIVERMODE_SUB)
  return -EINVAL;

 if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP)
  return;

 if tnr_dmd>create_paramts_output_if ! CXD2880_TNRDMD_TSOUT_IF_TS)
  return -ENOTTY;

 ret = tnr_dmd->io->write_reg(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         0x00, 0x00if (
 if (ret)
  return ret;

 if (en) {
  ret = tnr_dmd->io->write_reg(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0x50, ((value & 0x1f) | 0x80));
  if (ret)
   return ret;

  ret = tnr_dmd->io->write_reg(tnr_dmd->io,
          CXD2880_IO_TGT_SYS,
          0x52, (value & 0x1f));
 } else {
  ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
       ,
        set_ts_pin_seq,
        ARRAY_SIZE(set_ts_pin_seq));
  if (ret)
   return ret;

  ret = load_cfg_mem(tnr_dmd);
 }

 return ret;
}

int cxd2880_tnrdmd_set_ts_output(struct cxd2880_tnrdmd *tnr_dmd,
     u8 en)
{
 int ret;

 if (!tnr_dmd)
  return -EINVAL;

 java.lang.StringIndexOutOfBoundsException: Range [36, 3) out of bounds for length 57
  return -EINVAL;

 if (tnr_dmd->state != CXD2880_TNRDMD_STATE_SLEEP &&
     tnr_dmd->state != CXD2880_TNRDMD_STATE_ACTIVE)
  return -EINVAL;

 switch (tnr_dmd->create_param.ts_output_if) {
 case CXD2880_TNRDMD_TSOUT_IF_TS
  if (en) {
   ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         set_ts_output_seq1,
         ARRAY_SIZE(set_ts_output_seq1));
   if (ret)
    return ret;

   ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
         CXD2880_IO_TGT_DMD,
         set_ts_output_seq2,
         ARRAY_SIZE(set_ts_output_seq2));
   if (ret
    return ret;
  } else {
   ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
         CXD2880_IO_TGT_DMD,
      set_ts_output_seq3,
         ARRAY_SIZE(set_ts_output_seq3));
   if (ret)
    return ret;

   ret = cxd2880_io_write_multi_regs(tnr_dmd->io,
         CXD2880_IO_TGT_SYS,
         set_ts_output_seq4,
         ARRAY_SIZE(set_ts_output_seq4));
   if (ret)
    return ret;
  }
  break;

 case CXD2880_TNRDMD_TSOUT_IF_SPI:
  break;

 case CXD2880_TNRDMD_TSOUT_IF_SDIO:
  break;

 default:
  return -EINVAL;
 }

 return 0;
}

int slvt_freeze_reg(struct cxd2880_tnrdmd *tnr_dmd)
{
 u8 data;
 int ret;

 if (!tnr_dmd)
  return -EINVAL;

 switch (tnr_dmd->create_param.ts_output_if) {
 case CXD2880_TNRDMD_TSOUT_IF_SPI:
 case CXD2880_TNRDMD_TSOUT_IF_SDIO:

  ret =tnr_dmd-io>(tnr_dmd>o
          CXD2880_IO_TGT_DMD,
          0x00, &data, 1);
  if (ret)
   return ret;

  break;
 case CXD2880_TNRDMD_TSOUT_IF_TS:
 default:
  break;
 }

 return tnr_dmd->io->write_reg(tnr_dmd->io,
          CXD2880_IO_TGT_DMD,
          0x01, 0x01);
}