SSL cs48l32.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
//
// Cirrus Logic CS48L32 audio DSP.
//
// Copyright (C) 2016-2018, 2020, 2022, 2025 Cirrus Logic, Inc. and
//               Cirrus Logic International Semiconductor Ltd.

#include <dt-bindings/sound/cs48l32.h>
#include <linux/array_size.h>
#include <linux/build_bug.h>
#include <linux/clk.h>
#include <linux/container_of.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/gcd.h>
#include <linux/gpio/consumer.h>
#include <linux/minmax.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/pm_runtime.h>
#include <linux/property.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/slab.h>
#include <linux/spi/spi.h>
#include <linux/string_choices.h>
#include <sound/cs48l32.h>
#include <sound/cs48l32_registers.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/soc-component.h>
#include <sound/soc-dai.h>
#include <sound/soc-dapm.h>
#include <sound/tlv.h>

#include "cs48l32.h"

static const char * const cs48l32_core_supplies[] = { "vdd-a", "vdd-io" };

static const struct cs_dsp_region cs48l32_dsp1_regions[] = {
 { .type = WMFW_HALO_PM_PACKED, .base = 0x3800000 },
 { .type = WMFW_HALO_XM_PACKED, .base = 0x2000000 },
 { .type = WMFW_ADSP2_XM, .base = 0x2800000 },
 { .type = WMFW_HALO_YM_PACKED, .base = 0x2C00000 },
 { .type = WMFW_ADSP2_YM, .base = 0x3400000 },
};

static const struct cs48l32_dsp_power_reg_block cs48l32_dsp1_sram_ext_regs[] = {
 { CS48L32_DSP1_XM_SRAM_IBUS_SETUP_1, CS48L32_DSP1_XM_SRAM_IBUS_SETUP_24 },
 { CS48L32_DSP1_YM_SRAM_IBUS_SETUP_1, CS48L32_DSP1_YM_SRAM_IBUS_SETUP_8 },
 { CS48L32_DSP1_PM_SRAM_IBUS_SETUP_1, CS48L32_DSP1_PM_SRAM_IBUS_SETUP_7 },
};

static const unsigned int cs48l32_dsp1_sram_pwd_regs[] = {
 CS48L32_DSP1_XM_SRAM_IBUS_SETUP_0,
 CS48L32_DSP1_YM_SRAM_IBUS_SETUP_0,
 CS48L32_DSP1_PM_SRAM_IBUS_SETUP_0,
};

static const struct cs48l32_dsp_power_regs cs48l32_dsp_sram_regs = {
 .ext = cs48l32_dsp1_sram_ext_regs,
 .n_ext = ARRAY_SIZE(cs48l32_dsp1_sram_ext_regs),
 .pwd = cs48l32_dsp1_sram_pwd_regs,
 .n_pwd = ARRAY_SIZE(cs48l32_dsp1_sram_pwd_regs),
};

static const char * const cs48l32_mixer_texts[] = {
 "None",
 "Tone Generator 1",
 "Tone Generator 2",
 "Noise Generator",
 "IN1L",
 "IN1R",
 "IN2L",
 "IN2R",
 "ASP1RX1",
 "ASP1RX2",
 "ASP1RX3",
 "ASP1RX4",
 "ASP1RX5",
 "ASP1RX6",
 "ASP1RX7",
 "ASP1RX8",
 "ASP2RX1",
 "ASP2RX2",
 "ASP2RX3",
 "ASP2RX4",
 "ISRC1INT1",
 "ISRC1INT2",
 "ISRC1INT3",
 "ISRC1INT4",
 "ISRC1DEC1",
 "ISRC1DEC2",
 "ISRC1DEC3",
 "ISRC1DEC4",
 "ISRC2INT1",
 "ISRC2INT2",
 "ISRC2DEC1",
 "ISRC2DEC2",
 "ISRC3INT1",
 "ISRC3INT2",
 "ISRC3DEC1",
 "ISRC3DEC2",
 "EQ1",
 "EQ2",
 "EQ3",
 "EQ4",
 "DRC1L",
 "DRC1R",
 "DRC2L",
 "DRC2R",
 "LHPF1",
 "LHPF2",
 "LHPF3",
 "LHPF4",
 "Ultrasonic 1",
 "Ultrasonic 2",
 "DSP1.1",
 "DSP1.2",
 "DSP1.3",
 "DSP1.4",
 "DSP1.5",
 "DSP1.6",
 "DSP1.7",
 "DSP1.8",
};

static unsigned int cs48l32_mixer_values[] = {
 0x000, /* Silence (mute) */
 0x004, /* Tone generator 1 */
 0x005, /* Tone generator 2 */
 0x00C, /* Noise Generator */
 0x010, /* IN1L signal path */
 0x011, /* IN1R signal path */
 0x012, /* IN2L signal path */
 0x013, /* IN2R signal path */
 0x020, /* ASP1 RX1 */
 0x021, /* ASP1 RX2 */
 0x022, /* ASP1 RX3 */
 0x023, /* ASP1 RX4 */
 0x024, /* ASP1 RX5 */
 0x025, /* ASP1 RX6 */
 0x026, /* ASP1 RX7 */
 0x027, /* ASP1 RX8 */
 0x030, /* ASP2 RX1 */
 0x031, /* ASP2 RX2 */
 0x032, /* ASP2 RX3 */
 0x033, /* ASP2 RX4 */
 0x098, /* ISRC1 INT1 */
 0x099, /* ISRC1 INT2 */
 0x09a, /* ISRC1 INT3 */
 0x09b, /* ISRC1 INT4 */
 0x09C, /* ISRC1 DEC1 */
 0x09D, /* ISRC1 DEC2 */
 0x09e, /* ISRC1 DEC3 */
 0x09f, /* ISRC1 DEC4 */
 0x0A0, /* ISRC2 INT1 */
 0x0A1, /* ISRC2 INT2 */
 0x0A4, /* ISRC2 DEC1 */
 0x0A5, /* ISRC2 DEC2 */
 0x0A8, /* ISRC3 INT1 */
 0x0A9, /* ISRC3 INT2 */
 0x0AC, /* ISRC3 DEC1 */
 0x0AD, /* ISRC3 DEC2 */
 0x0B8, /* EQ1 */
 0x0B9, /* EQ2 */
 0x0BA, /* EQ3 */
 0x0BB, /* EQ4 */
 0x0C0, /* DRC1 Left */
 0x0C1, /* DRC1 Right */
 0x0C2, /* DRC2 Left */
 0x0C3, /* DRC2 Right */
 0x0C8, /* LHPF1 */
 0x0C9, /* LHPF2 */
 0x0CA, /* LHPF3 */
 0x0CB, /* LHPF4 */
 0x0D8, /* Ultrasonic 1 */
 0x0D9, /* Ultrasonic 2 */
 0x100, /* DSP1 channel 1 */
 0x101, /* DSP1 channel 2 */
 0x102, /* DSP1 channel 3 */
 0x103, /* DSP1 channel 4 */
 0x104, /* DSP1 channel 5 */
 0x105, /* DSP1 channel 6 */
 0x106, /* DSP1 channel 7 */
 0x107, /* DSP1 channel 8 */
};
static_assert(ARRAY_SIZE(cs48l32_mixer_texts) == ARRAY_SIZE(cs48l32_mixer_values));
#define CS48L32_NUM_MIXER_INPUTS ARRAY_SIZE(cs48l32_mixer_values)

static const DECLARE_TLV_DB_SCALE(cs48l32_ana_tlv, 0, 100, 0);
static const DECLARE_TLV_DB_SCALE(cs48l32_eq_tlv, -1200, 100, 0);
static const DECLARE_TLV_DB_SCALE(cs48l32_digital_tlv, -6400, 50, 0);
static const DECLARE_TLV_DB_SCALE(cs48l32_noise_tlv, -10800, 600, 0);
static const DECLARE_TLV_DB_SCALE(cs48l32_mixer_tlv, -3200, 100, 0);
static const DECLARE_TLV_DB_SCALE(cs48l32_us_tlv, 0, 600, 0);

static void cs48l32_spin_sysclk(struct cs48l32_codec *cs48l32_codec)
{
 struct cs48l32 *cs48l32 = &cs48l32_codec->core;
 unsigned int val;
 int ret, i;

 /* Skip this if the chip is down */
 if (pm_runtime_suspended(cs48l32->dev))
  return;

 /*
  * Just read a register a few times to ensure the internal
  * oscillator sends out some clocks.
 */
 for (i = 0; i < 4; i++) {
  ret = regmap_read(cs48l32->regmap, CS48L32_DEVID, &val);
  if (ret)
   dev_err(cs48l32_codec->core.dev, "%s Failed to read register: %d (%d)\n",
    __func__, ret, i);
 }

 udelay(300);
}

static const char * const cs48l32_rate_text[] = {
 "Sample Rate 1", "Sample Rate 2", "Sample Rate 3", "Sample Rate 4",
};

static const unsigned int cs48l32_rate_val[] = {
 0x0, 0x1, 0x2, 0x3,
};
static_assert(ARRAY_SIZE(cs48l32_rate_val) == ARRAY_SIZE(cs48l32_rate_text));

static int cs48l32_rate_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);
 int ret;

 /* Prevent any mixer mux changes while we do this */
 mutex_lock(&cs48l32_codec->rate_lock);

 /* The write must be guarded by a number of SYSCLK cycles */
 cs48l32_spin_sysclk(cs48l32_codec);
 ret = snd_soc_put_enum_double(kcontrol, ucontrol);
 cs48l32_spin_sysclk(cs48l32_codec);

 mutex_unlock(&cs48l32_codec->rate_lock);

 return ret;
}

static const char * const cs48l32_sample_rate_text[] = {
 "12kHz",
 "24kHz",
 "48kHz",
 "96kHz",
 "192kHz",
 "384kHz",
 "768kHz",
 "11.025kHz",
 "22.05kHz",
 "44.1kHz",
 "88.2kHz",
 "176.4kHz",
 "352.8kHz",
 "705.6kHz",
 "8kHz",
 "16kHz",
 "32kHz",
};

static const unsigned int cs48l32_sample_rate_val[] = {
 0x01, /* 12kHz */
 0x02, /* 24kHz */
 0x03, /* 48kHz */
 0x04, /* 96kHz */
 0x05, /* 192kHz */
 0x06, /* 384kHz */
 0x07, /* 768kHz */
 0x09, /* 11.025kHz */
 0x0a, /* 22.05kHz */
 0x0b, /* 44.1kHz */
 0x0c, /* 88.2kHz */
 0x0d, /* 176.4kHz */
 0x0e, /* 352.8kHz */
 0x0f, /* 705.6kHz */
 0x11, /* 8kHz */
 0x12, /* 16kHz */
 0x13, /* 32kHz */
};
static_assert(ARRAY_SIZE(cs48l32_sample_rate_val) == ARRAY_SIZE(cs48l32_sample_rate_text));
#define CS48L32_SAMPLE_RATE_ENUM_SIZE ARRAY_SIZE(cs48l32_sample_rate_val)

static const struct soc_enum cs48l32_sample_rate[] = {
 SOC_VALUE_ENUM_SINGLE(CS48L32_SAMPLE_RATE1,
         CS48L32_SAMPLE_RATE_1_SHIFT,
         CS48L32_SAMPLE_RATE_1_MASK >> CS48L32_SAMPLE_RATE_1_SHIFT,
         CS48L32_SAMPLE_RATE_ENUM_SIZE,
         cs48l32_sample_rate_text,
         cs48l32_sample_rate_val),
 SOC_VALUE_ENUM_SINGLE(CS48L32_SAMPLE_RATE2,
         CS48L32_SAMPLE_RATE_1_SHIFT,
         CS48L32_SAMPLE_RATE_1_MASK >> CS48L32_SAMPLE_RATE_1_SHIFT,
         CS48L32_SAMPLE_RATE_ENUM_SIZE,
         cs48l32_sample_rate_text,
         cs48l32_sample_rate_val),
 SOC_VALUE_ENUM_SINGLE(CS48L32_SAMPLE_RATE3,
         CS48L32_SAMPLE_RATE_1_SHIFT,
         CS48L32_SAMPLE_RATE_1_MASK >> CS48L32_SAMPLE_RATE_1_SHIFT,
         CS48L32_SAMPLE_RATE_ENUM_SIZE,
         cs48l32_sample_rate_text,
         cs48l32_sample_rate_val),
 SOC_VALUE_ENUM_SINGLE(CS48L32_SAMPLE_RATE4,
         CS48L32_SAMPLE_RATE_1_SHIFT,
         CS48L32_SAMPLE_RATE_1_MASK >> CS48L32_SAMPLE_RATE_1_SHIFT,
         CS48L32_SAMPLE_RATE_ENUM_SIZE,
         cs48l32_sample_rate_text,
         cs48l32_sample_rate_val),
};

static int cs48l32_inmux_put(struct snd_kcontrol *kcontrol,
        struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_dapm_kcontrol_component(kcontrol);
 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);
 struct soc_enum *e = (struct soc_enum *) kcontrol->private_value;
 unsigned int mux, src_val, in_type;
 int ret;

 mux = ucontrol->value.enumerated.item[0];
 if (mux > 1)
  return -EINVAL;

 switch (e->reg) {
 case CS48L32_IN1L_CONTROL1:
  in_type = cs48l32_codec->in_type[0][mux];
  break;
 case CS48L32_IN1R_CONTROL1:
  in_type = cs48l32_codec->in_type[1][mux];
  break;
 default:
  return -EINVAL;
 }

 src_val = mux << e->shift_l;

 if (in_type == CS48L32_IN_TYPE_SE)
  src_val |= 1 << CS48L32_INx_SRC_SHIFT;

 ret = snd_soc_component_update_bits(dapm->component,
         e->reg,
         CS48L32_INx_SRC_MASK,
         src_val);
 if (ret > 0)
  snd_soc_dapm_mux_update_power(dapm, kcontrol, mux, e, NULL);

 return ret;
}

static const char * const cs48l32_inmux_texts[] = {
 "Analog 1", "Analog 2",
};

static SOC_ENUM_SINGLE_DECL(cs48l32_in1muxl_enum,
       CS48L32_IN1L_CONTROL1,
       CS48L32_INx_SRC_SHIFT + 1,
       cs48l32_inmux_texts);

static SOC_ENUM_SINGLE_DECL(cs48l32_in1muxr_enum,
       CS48L32_IN1R_CONTROL1,
       CS48L32_INx_SRC_SHIFT + 1,
       cs48l32_inmux_texts);

static const struct snd_kcontrol_new cs48l32_inmux[] = {
 SOC_DAPM_ENUM_EXT("IN1L Mux", cs48l32_in1muxl_enum,
     snd_soc_dapm_get_enum_double, cs48l32_inmux_put),
 SOC_DAPM_ENUM_EXT("IN1R Mux", cs48l32_in1muxr_enum,
     snd_soc_dapm_get_enum_double, cs48l32_inmux_put),
};

static const char * const cs48l32_dmode_texts[] = {
 "Analog", "Digital",
};

static int cs48l32_dmode_put(struct snd_kcontrol *kcontrol,
        struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
 struct snd_soc_component *component = snd_soc_dapm_to_component(dapm);
 struct soc_enum *e = (struct soc_enum *) kcontrol->private_value;
 unsigned int mode;
 int ret, result;

 mode = ucontrol->value.enumerated.item[0];
 switch (mode) {
 case 0:
  ret = snd_soc_component_update_bits(component,
          CS48L32_ADC1L_ANA_CONTROL1,
          CS48L32_ADC1x_INT_ENA_FRC_MASK,
          CS48L32_ADC1x_INT_ENA_FRC_MASK);
  if (ret < 0) {
   dev_err(component->dev,
    "Failed to set ADC1L_INT_ENA_FRC: %d\n", ret);
   return ret;
  }

  ret = snd_soc_component_update_bits(component,
          CS48L32_ADC1R_ANA_CONTROL1,
          CS48L32_ADC1x_INT_ENA_FRC_MASK,
          CS48L32_ADC1x_INT_ENA_FRC_MASK);
  if (ret < 0) {
   dev_err(component->dev,
    "Failed to set ADC1R_INT_ENA_FRC: %d\n", ret);
   return ret;
  }

  result = snd_soc_component_update_bits(component,
             e->reg,
             BIT(CS48L32_IN1_MODE_SHIFT),
             0);
  if (result < 0) {
   dev_err(component->dev, "Failed to set input mode: %d\n", result);
   return result;
  }

  usleep_range(200, 300);

  ret = snd_soc_component_update_bits(component,
          CS48L32_ADC1L_ANA_CONTROL1,
          CS48L32_ADC1x_INT_ENA_FRC_MASK,
          0);
  if (ret < 0) {
   dev_err(component->dev,
    "Failed to clear ADC1L_INT_ENA_FRC: %d\n", ret);
   return ret;
  }

  ret = snd_soc_component_update_bits(component,
          CS48L32_ADC1R_ANA_CONTROL1,
          CS48L32_ADC1x_INT_ENA_FRC_MASK,
          0);
  if (ret < 0) {
   dev_err(component->dev,
    "Failed to clear ADC1R_INT_ENA_FRC: %d\n", ret);
   return ret;
  }

  if (result > 0)
   snd_soc_dapm_mux_update_power(dapm, kcontrol, mode, e, NULL);

  return result;
 case 1:
  return snd_soc_dapm_put_enum_double(kcontrol, ucontrol);
 default:
  return -EINVAL;
 }
}

static SOC_ENUM_SINGLE_DECL(cs48l32_in1dmode_enum,
       CS48L32_INPUT1_CONTROL1,
       CS48L32_IN1_MODE_SHIFT,
       cs48l32_dmode_texts);

static const struct snd_kcontrol_new cs48l32_dmode_mux[] = {
 SOC_DAPM_ENUM_EXT("IN1 Mode", cs48l32_in1dmode_enum,
     snd_soc_dapm_get_enum_double, cs48l32_dmode_put),
};

static const char * const cs48l32_in_texts[] = {
 "IN1L", "IN1R", "IN2L", "IN2R",
};
static_assert(ARRAY_SIZE(cs48l32_in_texts) == CS48L32_MAX_INPUT);

static const char * const cs48l32_us_freq_texts[] = {
 "16-24kHz", "20-28kHz",
};

static const unsigned int cs48l32_us_freq_val[] = {
 0x2, 0x3,
};

static const struct soc_enum cs48l32_us_freq[] = {
 SOC_VALUE_ENUM_SINGLE(CS48L32_US1_CONTROL,
         CS48L32_US1_FREQ_SHIFT,
         CS48L32_US1_FREQ_MASK >> CS48L32_US1_FREQ_SHIFT,
         ARRAY_SIZE(cs48l32_us_freq_val),
         cs48l32_us_freq_texts,
         cs48l32_us_freq_val),
 SOC_VALUE_ENUM_SINGLE(CS48L32_US2_CONTROL,
         CS48L32_US1_FREQ_SHIFT,
         CS48L32_US1_FREQ_MASK >> CS48L32_US1_FREQ_SHIFT,
         ARRAY_SIZE(cs48l32_us_freq_val),
         cs48l32_us_freq_texts,
         cs48l32_us_freq_val),
};

static const unsigned int cs48l32_us_in_val[] = {
 0x0, 0x1, 0x2, 0x3,
};

static const struct soc_enum cs48l32_us_inmux_enum[] = {
 SOC_VALUE_ENUM_SINGLE(CS48L32_US1_CONTROL,
         CS48L32_US1_SRC_SHIFT,
         CS48L32_US1_SRC_MASK >> CS48L32_US1_SRC_SHIFT,
         ARRAY_SIZE(cs48l32_us_in_val),
         cs48l32_in_texts,
         cs48l32_us_in_val),
 SOC_VALUE_ENUM_SINGLE(CS48L32_US2_CONTROL,
         CS48L32_US1_SRC_SHIFT,
         CS48L32_US1_SRC_MASK >> CS48L32_US1_SRC_SHIFT,
         ARRAY_SIZE(cs48l32_us_in_val),
         cs48l32_in_texts,
         cs48l32_us_in_val),
};

static const struct snd_kcontrol_new cs48l32_us_inmux[] = {
 SOC_DAPM_ENUM("Ultrasonic 1 Input", cs48l32_us_inmux_enum[0]),
 SOC_DAPM_ENUM("Ultrasonic 2 Input", cs48l32_us_inmux_enum[1]),
};

static const char * const cs48l32_us_det_thr_texts[] = {
 "-6dB", "-9dB", "-12dB", "-15dB", "-18dB", "-21dB", "-24dB", "-27dB",
};

static const struct soc_enum cs48l32_us_det_thr[] = {
 SOC_ENUM_SINGLE(CS48L32_US1_DET_CONTROL,
   CS48L32_US1_DET_THR_SHIFT,
   ARRAY_SIZE(cs48l32_us_det_thr_texts),
   cs48l32_us_det_thr_texts),
 SOC_ENUM_SINGLE(CS48L32_US2_DET_CONTROL,
   CS48L32_US1_DET_THR_SHIFT,
   ARRAY_SIZE(cs48l32_us_det_thr_texts),
   cs48l32_us_det_thr_texts),
};

static const char * const cs48l32_us_det_num_texts[] = {
 "1 Sample",
 "2 Samples",
 "4 Samples",
 "8 Samples",
 "16 Samples",
 "32 Samples",
 "64 Samples",
 "128 Samples",
 "256 Samples",
 "512 Samples",
 "1024 Samples",
 "2048 Samples",
 "4096 Samples",
 "8192 Samples",
 "16384 Samples",
 "32768 Samples",
};

static const struct soc_enum cs48l32_us_det_num[] = {
 SOC_ENUM_SINGLE(CS48L32_US1_DET_CONTROL,
   CS48L32_US1_DET_NUM_SHIFT,
   ARRAY_SIZE(cs48l32_us_det_num_texts),
   cs48l32_us_det_num_texts),
 SOC_ENUM_SINGLE(CS48L32_US2_DET_CONTROL,
   CS48L32_US1_DET_NUM_SHIFT,
   ARRAY_SIZE(cs48l32_us_det_num_texts),
   cs48l32_us_det_num_texts),
};

static const char * const cs48l32_us_det_hold_texts[] = {
 "0 Samples",
 "31 Samples",
 "63 Samples",
 "127 Samples",
 "255 Samples",
 "511 Samples",
 "1023 Samples",
 "2047 Samples",
 "4095 Samples",
 "8191 Samples",
 "16383 Samples",
 "32767 Samples",
 "65535 Samples",
 "131071 Samples",
 "262143 Samples",
 "524287 Samples",
};

static const struct soc_enum cs48l32_us_det_hold[] = {
 SOC_ENUM_SINGLE(CS48L32_US1_DET_CONTROL,
   CS48L32_US1_DET_HOLD_SHIFT,
   ARRAY_SIZE(cs48l32_us_det_hold_texts),
   cs48l32_us_det_hold_texts),
 SOC_ENUM_SINGLE(CS48L32_US2_DET_CONTROL,
   CS48L32_US1_DET_HOLD_SHIFT,
   ARRAY_SIZE(cs48l32_us_det_hold_texts),
   cs48l32_us_det_hold_texts),
};

static const struct soc_enum cs48l32_us_output_rate[] = {
 SOC_VALUE_ENUM_SINGLE(CS48L32_US1_CONTROL,
         CS48L32_US1_RATE_SHIFT,
         CS48L32_US1_RATE_MASK >> CS48L32_US1_RATE_SHIFT,
         ARRAY_SIZE(cs48l32_rate_text),
         cs48l32_rate_text,
         cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLE(CS48L32_US2_CONTROL,
         CS48L32_US1_RATE_SHIFT,
         CS48L32_US1_RATE_MASK >> CS48L32_US1_RATE_SHIFT,
         ARRAY_SIZE(cs48l32_rate_text),
         cs48l32_rate_text,
         cs48l32_rate_val),
};

static const char * const cs48l32_us_det_lpf_cut_texts[] = {
 "1722Hz", "833Hz", "408Hz", "203Hz",
};

static const struct soc_enum cs48l32_us_det_lpf_cut[] = {
 SOC_ENUM_SINGLE(CS48L32_US1_DET_CONTROL,
   CS48L32_US1_DET_LPF_CUT_SHIFT,
   ARRAY_SIZE(cs48l32_us_det_lpf_cut_texts),
   cs48l32_us_det_lpf_cut_texts),
 SOC_ENUM_SINGLE(CS48L32_US2_DET_CONTROL,
   CS48L32_US1_DET_LPF_CUT_SHIFT,
   ARRAY_SIZE(cs48l32_us_det_lpf_cut_texts),
   cs48l32_us_det_lpf_cut_texts),
};

static const char * const cs48l32_us_det_dcy_texts[] = {
 "0 ms", "0.79 ms", "1.58 ms", "3.16 ms", "6.33 ms", "12.67 ms", "25.34 ms", "50.69 ms",
};

static const struct soc_enum cs48l32_us_det_dcy[] = {
 SOC_ENUM_SINGLE(CS48L32_US1_DET_CONTROL,
   CS48L32_US1_DET_DCY_SHIFT,
   ARRAY_SIZE(cs48l32_us_det_dcy_texts),
   cs48l32_us_det_dcy_texts),
 SOC_ENUM_SINGLE(CS48L32_US2_DET_CONTROL,
   CS48L32_US1_DET_DCY_SHIFT,
   ARRAY_SIZE(cs48l32_us_det_dcy_texts),
   cs48l32_us_det_dcy_texts),
};

static const struct snd_kcontrol_new cs48l32_us_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
};

static const char * const cs48l32_vol_ramp_text[] = {
 "0ms/6dB", "0.5ms/6dB", "1ms/6dB", "2ms/6dB", "4ms/6dB", "8ms/6dB", "16ms/6dB", "32ms/6dB",
};

static SOC_ENUM_SINGLE_DECL(cs48l32_in_vd_ramp,
       CS48L32_INPUT_VOL_CONTROL,
       CS48L32_IN_VD_RAMP_SHIFT,
       cs48l32_vol_ramp_text);

static SOC_ENUM_SINGLE_DECL(cs48l32_in_vi_ramp,
       CS48L32_INPUT_VOL_CONTROL,
       CS48L32_IN_VI_RAMP_SHIFT,
       cs48l32_vol_ramp_text);

static const char * const cs48l32_in_hpf_cut_text[] = {
 "2.5Hz", "5Hz", "10Hz", "20Hz", "40Hz"
};

static SOC_ENUM_SINGLE_DECL(cs48l32_in_hpf_cut_enum,
       CS48L32_INPUT_HPF_CONTROL,
       CS48L32_IN_HPF_CUT_SHIFT,
       cs48l32_in_hpf_cut_text);

static const char * const cs48l32_in_dmic_osr_text[] = {
 "384kHz", "768kHz", "1.536MHz", "2.048MHz", "2.4576MHz", "3.072MHz", "6.144MHz",
};

static const struct soc_enum cs48l32_in_dmic_osr[] = {
 SOC_ENUM_SINGLE(CS48L32_INPUT1_CONTROL1,
   CS48L32_IN1_OSR_SHIFT,
   ARRAY_SIZE(cs48l32_in_dmic_osr_text),
   cs48l32_in_dmic_osr_text),
 SOC_ENUM_SINGLE(CS48L32_INPUT2_CONTROL1,
   CS48L32_IN1_OSR_SHIFT,
   ARRAY_SIZE(cs48l32_in_dmic_osr_text),
   cs48l32_in_dmic_osr_text),
};

static bool cs48l32_is_input_enabled(struct snd_soc_component *component,
         unsigned int reg)
{
 unsigned int input_active;

 input_active = snd_soc_component_read(component, CS48L32_INPUT_CONTROL);
 switch (reg) {
 case CS48L32_IN1L_CONTROL1:
  return input_active & BIT(CS48L32_IN1L_EN_SHIFT);
 case CS48L32_IN1R_CONTROL1:
  return input_active & BIT(CS48L32_IN1R_EN_SHIFT);
 case CS48L32_IN2L_CONTROL1:
  return input_active & BIT(CS48L32_IN2L_EN_SHIFT);
 case CS48L32_IN2R_CONTROL1:
  return input_active & BIT(CS48L32_IN2R_EN_SHIFT);
 default:
  return false;
 }
}

static int cs48l32_in_rate_put(struct snd_kcontrol *kcontrol,
          struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 int ret;

 snd_soc_dapm_mutex_lock(dapm);

 /* Cannot change rate on an active input */
 if (cs48l32_is_input_enabled(component, e->reg)) {
  ret = -EBUSY;
  goto exit;
 }

 ret = snd_soc_put_enum_double(kcontrol, ucontrol);
exit:
 snd_soc_dapm_mutex_unlock(dapm);

 return ret;
}

static const struct soc_enum cs48l32_input_rate[] = {
 SOC_VALUE_ENUM_SINGLE(CS48L32_IN1L_CONTROL1,
         CS48L32_INx_RATE_SHIFT,
         CS48L32_INx_RATE_MASK >> CS48L32_INx_RATE_SHIFT,
         ARRAY_SIZE(cs48l32_rate_text),
         cs48l32_rate_text,
         cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLE(CS48L32_IN1R_CONTROL1,
         CS48L32_INx_RATE_SHIFT,
         CS48L32_INx_RATE_MASK >> CS48L32_INx_RATE_SHIFT,
         ARRAY_SIZE(cs48l32_rate_text),
         cs48l32_rate_text,
         cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLE(CS48L32_IN2L_CONTROL1,
         CS48L32_INx_RATE_SHIFT,
         CS48L32_INx_RATE_MASK >> CS48L32_INx_RATE_SHIFT,
         ARRAY_SIZE(cs48l32_rate_text),
         cs48l32_rate_text,
         cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLE(CS48L32_IN2R_CONTROL1,
         CS48L32_INx_RATE_SHIFT,
         CS48L32_INx_RATE_MASK >> CS48L32_INx_RATE_SHIFT,
         ARRAY_SIZE(cs48l32_rate_text),
         cs48l32_rate_text,
         cs48l32_rate_val),
};

static int cs48l32_low_power_mode_put(struct snd_kcontrol *kcontrol,
          struct snd_ctl_elem_value *ucontrol)
{
 struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value;
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
 int ret;

 snd_soc_dapm_mutex_lock(dapm);

 /* Cannot change rate on an active input */
 if (cs48l32_is_input_enabled(component, mc->reg)) {
  ret = -EBUSY;
  goto exit;
 }

 ret = snd_soc_put_volsw(kcontrol, ucontrol);

exit:
 snd_soc_dapm_mutex_unlock(dapm);
 return ret;
}

static const struct soc_enum noise_gen_rate =
 SOC_VALUE_ENUM_SINGLE(CS48L32_COMFORT_NOISE_GENERATOR,
         CS48L32_NOISE_GEN_RATE_SHIFT,
         CS48L32_NOISE_GEN_RATE_MASK >> CS48L32_NOISE_GEN_RATE_SHIFT,
         ARRAY_SIZE(cs48l32_rate_text),
         cs48l32_rate_text,
         cs48l32_rate_val);

static const char * const cs48l32_auxpdm_freq_texts[] = {
 "3.072MHz", "2.048MHz", "1.536MHz", "768kHz",
};

static SOC_ENUM_SINGLE_DECL(cs48l32_auxpdm1_freq,
       CS48L32_AUXPDM1_CONTROL1,
       CS48L32_AUXPDM1_FREQ_SHIFT,
       cs48l32_auxpdm_freq_texts);

static SOC_ENUM_SINGLE_DECL(cs48l32_auxpdm2_freq,
       CS48L32_AUXPDM2_CONTROL1,
       CS48L32_AUXPDM1_FREQ_SHIFT,
       cs48l32_auxpdm_freq_texts);

static const char * const cs48l32_auxpdm_src_texts[] = {
 "Analog", "IN1 Digital", "IN2 Digital",
};

static SOC_ENUM_SINGLE_DECL(cs48l32_auxpdm1_in,
       CS48L32_AUXPDM_CTRL2,
       CS48L32_AUXPDMDAT1_SRC_SHIFT,
       cs48l32_auxpdm_src_texts);

static SOC_ENUM_SINGLE_DECL(cs48l32_auxpdm2_in,
       CS48L32_AUXPDM_CTRL2,
       CS48L32_AUXPDMDAT2_SRC_SHIFT,
       cs48l32_auxpdm_src_texts);

static const struct snd_kcontrol_new cs48l32_auxpdm_inmux[] = {
 SOC_DAPM_ENUM("AUXPDM1 Input", cs48l32_auxpdm1_in),
 SOC_DAPM_ENUM("AUXPDM2 Input", cs48l32_auxpdm2_in),
};

static const unsigned int cs48l32_auxpdm_analog_in_val[] = {
 0x0, 0x1,
};

static const struct soc_enum cs48l32_auxpdm_analog_inmux_enum[] = {
 SOC_VALUE_ENUM_SINGLE(CS48L32_AUXPDM1_CONTROL1,
         CS48L32_AUXPDM1_SRC_SHIFT,
         CS48L32_AUXPDM1_SRC_MASK >> CS48L32_AUXPDM1_SRC_SHIFT,
         ARRAY_SIZE(cs48l32_auxpdm_analog_in_val),
         cs48l32_in_texts,
         cs48l32_auxpdm_analog_in_val),
 SOC_VALUE_ENUM_SINGLE(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
         java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 33
 java.lang.StringIndexOutOfBoundsException: Range [31, 25) out of bounds for length 33
         ARRAY_SIZE(cs48l32_auxpdm_analog_in_val),
         RT5677_DSP_IB_6_H_SFT,1 )
         cs48l32_auxpdm_analog_in_val),
};

kcontrol_newjava.lang.StringIndexOutOfBoundsException: Range [66, 64) out of bounds for length 70
"Analog ,cs48l32_auxpdm_analog_inmux_enum],
 SOC_DAPM_ENUM("AUXPDM2 Analog Input", java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 32
};

static const struct snd_kcontrol_new cs48l32_auxpdm_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, ,1 )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
};

static const struct const   rt5677_ob_7_mix]= {
 SOC_VALUE_ENUM_SINGLE(CS48L32_ISRC1_CONTROL1,
 ,
         CS48L32_ISRC1_FSH_MASK >> CS48L32_ISRC1_FSH_SHIFT,
    RT5677_DSP_IB_01_L_SFT 1 )java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

         cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLE(CS48L32_ISRC2_CONTROL1,
         CS48L32_ISRC1_FSH_SHIFT,
         CS48L32_ISRC1_FSH_MASK >> CS48L32_ISRC1_FSH_SHIFT,
        ARRAY_SIZEcs48l32_rate_text),
         cs48l32_rate_text,
         cs48l32_rate_valjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 33
java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 46
   java.lang.StringIndexOutOfBoundsException: Range [27, 24) out of bounds for length 32
         CS48L32_ISRC1_FSH_MASKRT5677_DSP_IB_7_L_SFT  )
         ARRAY_SIZE(cs48l32_rate_text),
         cs48l32_rate_text,
         cs48l32_rate_val),
};

static const struct soc_enum cs48l32_isrc_fsl[] = {
 SOC_VALUE_ENUM_SINGLE(CS48L32_ISRC1_CONTROL1,
         CS48L32_ISRC1_FSL_SHIFT,
         CS48L32_ISRC1_FSL_MASK >> CS48L32_ISRC1_FSL_SHIFT,
         ARRAY_SIZE(cs48l32_rate_text),
         java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
         cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLE(CS48L32_ISRC2_CONTROL1,
         CS48L32_ISRC1_FSL_SHIFT,
         CS48L32_ISRC1_FSL_MASK >> CS48L32_ISRC1_FSL_SHIFT,
       java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 39
         cs48l32_rate_text,
         cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLE(CS48L32_ISRC3_CONTROL1,
         java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 8
         CS48L32_ISRC1_FSL_MASK >> CS48L32_ISRC1_FSL_SHIFT,
         ARRAY_SIZE(cs48l32_rate_text),
   cs48l32_rate_text,
         cs48l32_rate_val),
};

static const struct soc_enum cs48l32_fx_rate = java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 46
  D ,java.lang.StringIndexOutOfBoundsException: Range [48, 49) out of bounds for length 48
         CS48L32_FX_RATE_MASK >> CS48L32_FX_RATE_SHIFT,
         ARRAY_SIZE(cs48l32_rate_text),
         cs48l32_rate_text,
        cs48l32_rate_val)

static const char * const " ADC ,"java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 41
 "Low-pass", "High-pass"
};

static constjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
 SOC_ENUM_SINGLE(CS48L32_LHPF_CONTROL2, 0,
 java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 63
 SOC_ENUM_SINGLE(CS48L32_LHPF_CONTROL2, 1,
   ARRAY_SIZE(cs48l32_lhpf_mode_text), cs48l32_lhpf_mode_text),
 ,
   ARRAY_SIZE(cs48l32_lhpf_mode_text), cs48l32_lhpf_mode_text),
 SOC_ENUM_SINGLE(CS48L32_LHPF_CONTROL2, 3,
  () )java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
};

static int cs48l32_lhpf_coeff_put(struct
      struct snd_ctl_elem_value *ucontrol/
{
 struct static const char * const rt5677_dac2l_src[] = {
 struct cs48l32_codec *IF1 DAC2,"DAC""  L" IF4  "  "
 __be32"
 s16 val = (s16)be32_to_cpu(*data);

 if (abs(val) > CS48L32_LHPF_MAX_COEFF) {
e.dev,"ejectingunstable  \";
  return -EINVAL;
 }

 rt5677_dac2l_enum,RT5677_IF_DSP_DAC2_MIXER
}

   * onst cs48l32_eq_mode_text[]={
 "Low-pass", "High-pass",
};

static const struct soc_enum cs48l32_eq_mode[] = {
(CS48L32_EQ_CONTROL2java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   ARRAY_SIZE(cs48l32_eq_mode_text),
   cs48l32_eq_mode_text),
 SOC_ENUM_SINGLE(CS48L32_EQ_CONTROL2, 1,
   ARRAY_SIZE(cs48l32_eq_mode_text),
   cs48l32_eq_mode_text),
 SOC_ENUM_SINGLE(CS48L32_EQ_CONTROL2, 2,
   ARRAY_SIZE(cs48l32_eq_mode_text),
   cs48l32_eq_mode_text),
 SOC_ENUM_SINGLE(S48L32_EQ_CONTROL2 3,
   ARRAY_SIZE(cs48l32_eq_mode_text),
   cs48l32_eq_mode_text),
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static int cs48l32_eq_mode_get(struct snd_kcontrol *kcontrol,
          struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *omponent = snd_soc_kcontrol_component(kcontrol);
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);
 struct soc_enum *e = (struct soc_enum *) kcontrol->java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 45
 unsigned int item;

 item = snd_soc_enum_val_to_item(e, cs48l32_codec->eq_mode[e->shift_l]);
 ucontrol->value.enumerated.item[0] = item;

 return 0;
}

static int  SOC_DAPM_ENUMD RSource" );
          struct java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
{
 *omponent =snd_soc_kcontrol_component(control);
 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
  "IF1 D 4," DAC " IDAC ," DAC L"
 struct soc_enum *e = (struct soc_enum *) kcontrol->private_value;
 unsigned int *item = ucontrol->value.enumerated.item;
 unsigned int}
 bool changed = false;

 if (item[0] >= e->items)
  return -EINVAL;

 val = snd_soc_enum_item_to_valrt5677_dac3l_enum ,

 RT5677_SEL_DAC3_L_SRC_SFT, rt5677_dac3l_src);
 if (cs48l32_codec->eq_mode[e->shift_l] != val) {
  cs48l32_codec->eq_mode[e->shift_l] = val;
  changed = true;
 }
 snd_soc_dapm_mutex_unlock(dapm);

 return changed;
}

static int cs48l32_eq_coeff_info(struct snd_kcontrol *kcontrol,
   snd_ctl_elem_infouinfo
{
 struct cs48l32_eq_control *ctl = (java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 20

 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 uinfo->count = 1;
 uinfo->value.integerjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
vmax=>java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

  ;
}

 intcs48l32_eq_coeff_getstructsnd_kcontrol*control,
    struct snd_ctl_elem_value *ucontrol)
{
 static conststruct snd_kcontrol_new rt5677_dac3_r_mux =
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);
 struct cs48l32_eq_control *params = (voidDAC3 java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 51
 __be16 *coeffs;
 unsigned int coeff_idx/*DAC4 L/R Source*/ /* MX-16 [14:12] [10:8] */
 int block_idx;

 (int -block_base -(nt );
 block_idx /= (CS48L32_EQ2_BAND1_COEFF1 - CS48L32_EQ1_BAND1_COEFF1);

 coeffs = &cs48l32_codec-> "IF1 DAC 6", "IF2 DAC 6", "IF3 DAC L" L,
 coeff_idx = (params->reg - params->block_base) / 2;

 /* High __be16 is in [coeff_idx] and low __be16 in [coeff_idx + 1] */
 if (params->shift == 0)
  coeff_idx++;

staticSOC_ENUM_SINGLE_DECL

 return 0;
}

intcs48l32_eq_coeff_putstruct,
    struct snd_ctl_elem_value *ucontrol)
{
 struct  const struct snd_kcontrol_newjava.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 56
snd_soc_dapm_context *dapm =snd_soc_component_get_dapm(omponent;
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);
 struct cs48l32_eq_control *params = (void *)kcontrol->private_value;
 __be16 *coeffs;
 unsigned int coeff_idx;
 block_idx

 block_idx = ((int) params->block_base - (int) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 52
 block_idx /= (CS48L32_EQ2_BAND1_COEFF1 - CS48L32_EQ1_BAND1_COEFF1);

 coeffs = &cs48l32_codec->eq_coefficients[block_idx][0];
 coeff_idx = (params->reg - params->block_base) / 2;

 /* Put high __be16 in [coeff_idx] and low __be16 in [coeff_idx + 1] */
 if (params->shift == 0)
  coeff_idx++;

 snd_soc_dapm_mutex_lock(dapm);
 coeffs[coeff_idx] = cpu_to_be16(ucontrol->value.integer.value[0]);
 snd_soc_dapm_mutex_unlock(dapm);

 return return dac4r_enum, ,
}

static const struct snd_kcontrol_new cs48l32_drc_activity_output_mux[] = {
, 1, 0,
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
};

staticconst snd_kcontrol_newcs48l32_dsp_trigger_output_mux ={
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
};

static int cs48l32_dsp_rate_get(struct snd_kcontrol *kcontrol,
    struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol) *[  java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 struct cs48l32_codec *cs48l32_codec = java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 2
 struct soc_enum *e = (struct soc_enum *) kcontrol (
 unsigned int cached_rate;
 const unsigned int rate_num= e->maskjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 int item;

 if (rate_num >= ARRAY_SIZE(cs48l32_codec->dsp_dma_rates))
  returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 cached_rate = cs48l32_codec->dsp_dma_rates[rate_num];
 item = snd_soc_enum_val_to_item(e, cached_rate);
 ucontrol->value.enumerated.item[0] = item;

 return 0;
}

static int cs48l32_dsp_rate_put
    struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component Drt5677_ib01_bypass_src_enum RT5677_DSP_IN_OUTB_CTRL
 struct snd_soc_dapm_context *dapm = java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct soc_enum *e =static    =
 const unsigned int rate_num = e->mask;

 unsigned int val;
 bool changed = false;

 if (item >= e->items ,RT5677_DSP_IN_OUTB_CTRL
  return -EINVAL;

 if (rate_num >= ARRAY_SIZE(cs48l32_codec->dsp_dma_rates))
  return -EINVAL;

 val = snd_soc_enum_item_to_val conststruct snd_kcontrol_new rt5677_ib23_bypass_src_mux =

 snd_soc_dapm_mutex_lockSOC_DAPM_ENUM(BypassSource,rt5677_ib23_bypass_src_enumjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 if (cs48l32_codec->dsp_dma_rates[rate_num] != val) {
  ->[rate_num]=val;
  changed = true;
 }
 ()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 return changed;
}

{
 /* RX rates */
 SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 0,
         ,
         ARRAY_SIZE(cs48l32_rate_text),
         cs48l32_rate_text, cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 0,
         1,
         ARRAY_SIZEcs48l32_rate_text),
         cs48l32_rate_text, cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLESND_SOC_NOPM, 0,
         2,
}
         cs48l32_rate_text, cs48l32_rate_val),
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
         3,
         ARRAY_SIZE(cs48l32_rate_text),
  cs48l32_rate_text, cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 0,
         4,
         ARRAY_SIZE(cs48l32_rate_text),
         java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
 SOC_VALUE_ENUM_SINGLEstaticconststruct   =
         5,
        ,
         cs48l32_rate_text, cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 0,
         6,
   java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
         cs48l32_rate_text, cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 0,
 ,
         ARRAY_SIZE(
         cs48l32_rate_text, cs48l32_rate_val)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 /* TX rates */
 DMIC1 DMIC2,D,"java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
         8,
 
         cs48l32_rate_text, cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 0,
         9,
           java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 46
         cs48l32_rate_text, cs48l32_rate_val),
 SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 0,
         10,
         ARRAY_SIZE(cs48l32_rate_text),
       java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 46
 SOC_VALUE_ENUM_SINGLE
         11,
       java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 39
   , cs48l32_rate_val,
 SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 0,
         12,
         ARRAY_SIZE(cs48l32_rate_text),
         java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
static const    =
         13,
         ARRAY_SIZE(cs48l32_rate_text),
        ,)
 SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 0,
         14,
  java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
         cs48l32_rate_text cs48l32_rate_val)
 SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 0,
         15,
         ARRAY_SIZE(cs48l32_rate_text),
         cs48l32_rate_text, cs48l32_rate_val),
};

 cs48l32_dsp_pre_runstructwm_adsp *sp)
{
 struct cs48l32_codecSOC_DAPM_ENUM(Stereo1 Source" );
 unsigned int reg;
 const u8 *rate = cs48l32_codec->dsp_dma_rates;


 reg = dsp->cs_dsp.base + rt5677_stereo2_dmic_enum, RT5677_STO2_ADC_MIXER,
 for (i = 0; i < CS48L32_DSP_N_RX_CHANNELS; ++i) {
 regmap_update_bits(dsp->cs_dsp.regmap,reg CS48L32_HALO_DSP_RATE_MASK, *rate);
  reg += 8;
  rate++;
 }

 reg = dsp->cs_dsp.base + CS48L32_HALO_SAMPLE_RATE_TX1;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 regmap_update_bits(sp>s_dspregmap,reg CS48L32_HALO_DSP_RATE_MASK,*);
  reg += 8;
  rate++;
 }

 usleep_range(300, 600);

 return 0;
}

 voidcs48l32_dsp_memory_disablestruct cs48l32_codec*cs48l32_codec,
           const struct cs48l32_dsp_power_regs *regs)
{
 struct regmap *regmap = cs48l32_codec->core.regmap;
 int i, j, ret;

 for (i = 0; i < regs->n_pwd; ++i) {
  ret = regmap_write(regmap, regs->pwd[i], 0);
  if (ret (Stereo3DMICSource,rt5677_stereo3_dmic_enumjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
   goto err;
 }

 for (i = 0; i < regs->n_ext; ++i) {
  for (j = regs->ext[i].start; j <= regs->ext[i].end; java.lang.StringIndexOutOfBoundsException: Range [0, 55) out of bounds for length 44
   java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
   if static  struct  =
    goto err;
  }
 }

 return;

err:
 dev_warn(cs48l32_codec->core.dev, "Failed to write SRAM java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 40
}

static int cs48l32_dsp_memory_enable(struct cs48l32_codec *cs48l32_codec,
         const struct cs48l32_dsp_power_regs *regs)
{
 struct regmap *regmap = cs48l32_codec->core.regmap;
 int i, j, ret;

 /* disable power-off */
 for (i = 0; i < regs->n_ext; ++i) {
  for (j = regs->ext[i].start; j <= regs->ext[i].end; j += 4) {
   ret = regmap_write(regmap, j, 0x3);
   if (ret)
    goto err;
 }
 }

 /* power-up the banks in sequence */
  ( 0;i<regs-n_pwd;+i {
  ret = regmap_write(regmap, regs->pwd[i], 0x1);
  if
   goto err;

  udelay(1); /* allow bank to power-up */

  java.lang.StringIndexOutOfBoundsException: Range [20, 5) out of bounds for length 48
  if (ret)
   goto err;

  udelay(1); /* allow bank to power-up */
 }

 return 0;

err:
 ->coredev "ailed  writeSRAM  (%)\", ret);
 cs48l32_dsp_memory_disable(cs48l32_codec, regs);

 return ret;
}

_pdate(structsnd_soc_dapm_widget *w, unsigned int freq_reg,
       unsigned int freqsel_reg)
{
  *  (w>apm);
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);
 struct regmap *regmap = cs48l32_codec->core.regmap;
 struct wm_adsp *dsp = &cs48l32_codec->dsp;
 int ret;
 unsigned intUM_SINGLE_DECL(

 if (!freq_reg)
  return -EINVAL;

 ret = regmap_read(regmap, freq_reg, &freq);
 if (ret) {
  dev_err(omponent>dev,"  read #%x: %d\n", freq_reg, ret);
  return ret;
 }

 if (freqsel_reg) {
  freq_sts = (freq & CS48L32_SYSCLK_FREQ_STS_MASK

  ret = regmap_read(regmap, freqsel_reg, &freq_sel);
et {
   dev_err(component->dev, "Failed to read #%x: %d\n", freqsel_reg, ret);
   return ret;
  
  freq_sel = (freq_sel & CS48L32_SYSCLK_FREQ_MASK) >> CS48L32_SYSCLK_FREQ_SHIFTstatic SOC_ENUM_SINGLE_DECL(

  if (freq_sts != freq_sel) {
 FREQ #x =FREQ  (%)\n",
    freq_sel, freq_sts);
   return -ETIMEDOUT;
  }
 }

 freq &= CS48L32_DSP_CLK_FREQ_MASK;
 freq >>= CS48L32_DSP_CLK_FREQ_SHIFT;

 ret = regmap_write(dsp->cs_dsp.regmap,
      dsp>cs_dsp.base + CS48L32_DSP_CLOCK_FREQ_OFFS, freq);
 if (ret) {
  dev_err(component->dev, "Failed dev_err(component->dev, "Failed 
  return ret;
 }

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

static }
          struct snd_kcontrol *kcontrol, int event)
{
 switch (event) {
caseSND_SOC_DAPM_POST_PMU
  return cs48l32_dsp_freq_update(w, CS48L32_SYSTEM_CLOCK2, CS48L32_SYSTEM_CLOCK1RT5677_SEL_MONO_ADC_L1_SFT );
 default:
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static irqreturn_t cs48l32_irq(int irq, void *data)
{
 static const unsigned int eint1_regs[] = {
  CS48L32_IRQ1_EINT_9, CS48L32_IRQ1_MASK_9,
  CS48L32_IRQ1_EINT_7, CS48L32_IRQ1_MASK_7
 };
 u32 reg_vals[4];
 struct cs48l32_codec *cs48l32_codec = data;
 ,java.lang.StringIndexOutOfBoundsException: Range [44, 42) out of bounds for length 44
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 59
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int i, ret;

 static_assert(ARRAY_SIZE(eint1_regs) == ARRAY_SIZE(" DAC " IF2DAC23,"LB  " STO2ADCMIX,

ret c>java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 58
 if (ret) {
  dev_warn(cs48l32_codec->core.dev, "irq could not get pm runtime: %d\n", ret);
  return IRQ_NONE;
 }

 ret = regmap_read(regmap, CS48L32_IRQ1_STATUS, &eint_pending);
 if (ret) {
  dev_warn(cs48l32_codec-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ;
 }
 if ((eint_pending & CS48L32_IRQ1_STS_MASK) == 0)SOC_DAPM_ENUM"/Source" )
  goto out;

 ret = regmap_multi_reg_read
 if (ret) {
staticconst *const []={
  return IRQ_NONE;
 }

 for (i = 0; i < ARRAY_SIZE(reg_vals); i += java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 10
  reg_vals[i] &= ~reg_vals[i + 1];
  regmap_write(regmap, eint1_regs[i], reg_vals[i]);
 }

 if (reg_vals[0] & CS48L32_DSP1_IRQ0_EINT1_MASK)
  &->sp;

 if (reg_vals[2] RT5677_IB45_SRC_SFT rt5677_inbound45_srcjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  dev_warn(cs48l32_codec->core.dev, "MPU err static const struct snd_kcontrol_new rt5677_ib45_src_mux =
  wm_halo_bus_error(irq, &cs48l32_codec->dsp);
 }

 if (reg_vals[2] & CS48L32_DSP1_WDT_EXPIRE_EINT1_MASK) {
  dev_warn(cs48l32_codec->core.dev, "WDT expire IRQ\n");
  wm_halo_wdt_expire(irq, &cs48l32_codec->dsp);
 }

 result = IRQ_HANDLED;

out:"  6,"DAC6,"LB 6,"  MIXL,
 pm_runtime_put_autosuspend(cs48l32_codec->core.dev);

rresultjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int cs48l32_get_dspclk_setting(struct cs48l32_codec *cs48l32_codec, java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 28
signed v)
{
 freq /= 15625; /* convert to 1/64ths of 1MHz */
 *val |= RT5677_IB6_SRC_SFT rt5677_inbound6_src);

 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
}static   rt5677_ib6_src_muxjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

static int cs48l32_get_sysclk_setting(unsigned int freq)
{
 switch (freq) {
 :
 case 5644800:
 case 6144000:
  return CS48L32_SYSCLK_RATE_6MHZIF4 DAC R,"   "," MIX " STO3ADCMIXR
 case 11289600:
 case 12288000:
  return CS48L32_SYSCLK_RATE_12MHZ << java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 0
 case 22579200:
 case 24576000:
  return CS48L32_SYSCLK_RATE_24MHZ << CS48L32_SYSCLK_FREQ_SHIFT;
 case 45158400:
 case 49152000:
  eturnCS48L32_SYSCLK_RATE_49MHZ< CS48L32_SYSCLK_FREQ_SHIFT;
 case 90316800:
 case 98304000:
  return CS48L32_SYSCLK_RATE_98MHZ << CS48L32_SYSCLK_FREQ_SHIFT;
 :
  return -EINVAL;
 }
}

static int cs48l32_set_pdm_fllclk(struct snd_soc_component *component, int source)
{
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);
  regmap * =cs48l32_codec-core.;
 unsigned int val;

 (ource java.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 18
 case CS48L32_PDMCLK_SRC_IN1_PDMCLK:
 case CS48L32_PDMCLK_SRC_IN2_PDMCLK:
 case CS48L32_PDMCLK_SRC_IN3_PDMCLK:
 case CS48L32_PDMCLK_SRC_IN4_PDMCLK:
 case CS48L32_PDMCLK_SRC_AUXPDM1_CLK:
 CS48L32_PDMCLK_SRC_AUXPDM2_CLK:
  val = source << CS48L32_PDM_FLLCLK_SRC_SHIFT;
  break;
 default:
  dev_err(cs48l32_codec->core.dev, "Invalid PDM FLLCLK src %d\n", source);
  return -EINVAL;
 }

 java.lang.StringIndexOutOfBoundsException: Range [26, 7) out of bounds for length 58
      CS48L32_PDM_FLLCLK_SRC_MASKSOC_DAPM_ENUM(InBound8Source,rt5677_inbound8_enum;
}

static int cs48l32_set_sysclk(struct snd_soc_component *component, int clk_id, int java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 39
         intfreq int dir)
{
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);
 struct regmap *regmap = cs48l32_codec->core.regmap;
 char *name;
 unsigned int reg;
 unsigned int mask = CS48L32_SYSCLK_SRC_MASK;
 unsigned int val = source << CS48L32_SYSCLK_SRC_SHIFT;
 int clk_freq_sel, *clk;

 switch (clk_id) {
 case CS48L32_CLK_SYSCLK_1:
  name = "SYSCLK";
  reg = CS48L32_SYSTEM_CLOCK1;
  clk = &cs48l32_codec->sysclk;
  clk_freq_sel = cs48l32_get_sysclk_setting(freq);
  mask |= CS48L32_SYSCLK_FREQ_MASK | CS48L32_SYSCLK_FRAC_MASK;
  break;
 case CS48L32_CLK_DSPCLK:
  name = "DSPCLK";
  reg = CS48L32_DSP_CLOCK1;
  clk = &cs48l32_codec->dspclk;
  clk_freq_sel = cs48l32_get_dspclk_setting(cs48l32_codec, freq, source, &val);
  mask |= CS48L32_DSP_CLK_FREQ_MASK;
  break;
 case CS48L32_CLK_PDM_FLLCLK:
  return cs48l32_set_pdm_fllclk(component, source);
 default:
  return -EINVAL;
 }

 if (clk_freq_sel < 0) {
  dev_err(cs48l32_codec->core.dev, "Failed to get %s setting for %dHZ\n", name, freq);
  return clk_freq_sel;
 }

 *clk = freq;

 if (freq == 0) {
  dev_dbg(cs48l32_codec->core.dev, "%s cleared\n", name);
  return 0;
 }

 val |= clk_freq_sel;

 if (freq % 6144000)
  val |= CS48L32_SYSCLK_FRAC_MASK;

 dev_dbg(cs48l32_codec->core.dev, "%s set to %uHz", name, freq);

 return regmap_update_bits(regmap, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static int cs48l32_is_enabled_fll(struct cs48l32_fll *fll, int base)
{
 struct regmap "MIC1 L, "L," L,"L,"DC1,A"
 unsigned int reg;
 int ret;

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

 rt5677_sidetone_enum,RT5677_SIDETONE_CTRL
}

static int cs48l32_wait_for_fll(struct cs48l32_fll *fll, bool requested)
{
 regmap *egmap= -codec>.regmapjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  intval=0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 int

 cs48l32_fll_dbg/

 for (i = 0; i < 30; i++) {
  regmap_read(regmap, fll->sts_addr, &val);
  if((&fll>sts_mask) ==requested
   return 0;

  switch (i) {
  case 0 ... 5:
   usleep_range(75, 125);
   break;
  case 6 ... 20:
   usleep_range(750, 1250);
   break;
  default:
   fsleep(20000);
   break;
  }
 }

cs48l32_fll_warnfll "imedout  for sn"  ?"ock": u";

 return -ETIMEDOUT;
}

static int cs48l32_fllhj_disable/
{
 struct cs48l32 *static const char * consrt5677_dac3_src]={
 bool change;

 cs48l32_fll_dbg(fll, "Disabling FLL\n");

 /*
  * Disable
  * lock status bit to clear as normal, but /* PDM channel Source */ /* MX-31 [13:12][9:8][5:4
  * again due to a control clock DD ,"DMIX2"
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * enables.
 */
 regmap_set_bits(cs48l32->regmap,
   fll ,rt5677_pdm_src;
   CS48L32_FLL_HOLD_MASK);
 regmap_clear_bits(cs48l32->regmap,
     java.lang.StringIndexOutOfBoundsException: Range [42, 8) out of bounds for length 43
     CS48L32_FLL_LOCKDET_MASK);
 regmap_set_bits(
   fll->base + CS48L32_FLL_CONTROL5_OFFS,
   CS48L32_FLL_FRC_INTEG_UPD_MASK);
 regmap_update_bits_check(cs48l32->regmap,
     fll->base + CS48L32_FLL_CONTROL1_OFFS,
     CS48L32_FLL_EN_MASK,
     0,
     &change);

 cs48l32_wait_for_fll

 /*
    thesregisters java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 72
  * here ensures that after a runtime suspend/ const struct snd_kcontrol_new rt5677_pdm1_r_mux
  * enables the fll then ctrl_up is the last bit SOC_ENUM_SINGLE_DECLjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  * by the fll enable code rather than the cache sync operation which
  * would java.lang.StringIndexOutOfBoundsException: Range [75, 14) out of bounds for length 75
*
 */
 regmap_clear_bits(cs48l32->regmap,
     fll->base + CS48L32_FLL_CONTROL1_OFFS,
     CS48L32_FLL_CTRL_UPD_MASK);

 if (change)
  RT5677_IF1_ADC1_SFT java.lang.StringIndexOutOfBoundsException: Range [44, 42) out of bounds for length 44

java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 10
}

static int cs48l32_fllhj_apply(struct cs48l32_fll *fll
{
 struct regmap *regmap = fll->codec->core.regmap;
 int refdiv, fref, fout, lockdet_thr, fbdiv, fllgcd;
 bool frac = false;
 unsigned int fll_n, min_n, max_n, ratio, theta, lambda, hp;
 unsigned int gains, num;

 cs48l32_fll_dbg(fll, "fin=%d, fout=%d\n", fin, SOC_DAPM_ENUM("IF2 ADC1 Source", rt5677_if2_adc1_enum

 for (refdiv = 0; refdiv < 4; refdiv++) {
  if ((fin / (1 << refdiv)) <= rt5677_slb_adc1_enum, RT5677_SLIMBUS_RX
  T5677_SLB_ADC1_SFT ;
 }

 fref      rt5677_slb_adc1_mux
 fout = fll->fout;
 frac = fout % fref;

 /*
  * Use simple heuristic approach to find a configuration that
     most  clocks.
 */
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  lockdet_thr = 2;
  gains = CS48L32_FLLHJ_LOW_GAINS;

  if (frac)
   fbdiv = 256;
  else
   fbdiv = 4;

  lockdet_thr = 8;

  fbdiv = (frac) ? 16 : 2;
 } else {
  lockdet_thr = 8;
  static java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   =1;
 }
 /* Use high performance mode for fractional configurations. */
 if (frac) {
  hp = 3;
  min_n  struct  =
  max_n = CS48L32_FLLHJ_FRAC_MAX_N;
}elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  if (fref < CS48L32_FLLHJ_LP_INT_MODE_THRESH)
   hp = 0;
  else
   hp = 1;

  min_n = CS48L32_FLLHJ_INT_MIN_N;
  max_n = CS48L32_FLLHJ_INT_MAX_N;
 }

 ratio = fout / fref;

 cs48l32_fll_dbg(fll, "refdiv=%d, fref=%d, frac:%d\n", java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 0

 while (ratio / fbdiv < min_n) {
  fbdiv /= 2;
  if (fbdiv < min_n) {
   cs48l32_fll_err(fll, "FBDIV (%u) < minimum N (%u)\n", fbdiv, min_n);
   return -EINVAL;
  }
 }
 while (frac && (ratio / fbdiv > max_n)) {
  fbdiv *= 2;
  if (fbdiv >= 1024) {
   cs48l32_fll_err(fll, "FBDIV (%u) >= 1024\n", fbdivjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   returnIF1Swapjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 66
  }
 }

 cs48l32_fll_dbg(fll, "lockdet=%d, hp=#%x, fbdiv:%d\n", lockdet_thr, hp,RT5677_TDM2_CTRL1

 /* Calculate N.K values */
 fllgcd = gcd(fout, fbdiv * fref);
 num = constsnd_kcontrol_new =
 lambda = (fref * fbdiv) / fllgcd;
 java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 22
 theta = num java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 cs48l32_fll_dbg(fll, "fll_n=%d, gcd=%d, theta=%d, lambda=%d\n",
   fll_n, fllgcd, theta, lambda);

 /* Some sanity checks before any registers are written. */
 if (fll_n < min_n || fll_n > max_n) {
  cs48l32_fll_err(fll, "N not in valid %s mode range %d-%d: %d\n",
   f":"nteger,min_n, max_n )
  return -EINVAL;
 }
 if (fbdiv < 1 || (static SOC_ENUM_SINGLE_DECL(
  cs48l32_fll_err(fll, "Invalid fbdiv for %s mode (%u)\n",
   ?"":"nteger",fbdiv);
  return -EINVAL;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* clear the ctrl_upd bit to guarantee we write to it later. */
 regmap_update_bits(regmap,
      SOC_DAPM_ENUMIADC3SwapSource,rt5677_if2_adc3_swap_enum;
      CS48L32_FLL_LOCKDET_THR_MASK |
      CS48L32_FLL_PHASEDET_MASK |
      CS48L32_FLL_REFCLK_DIV_MASK |
      CS48L32_FLL_N_MASK |
  ,RT5677_TDM2_CTRL1
      (lockdet_thr << CS48L32_FLL_LOCKDET_THR_SHIFT) |
      (1 << CS48L32_FLL_PHASEDET_SHIFT) |
      (refdiv << static const struct snd_kcontrol_new rt5677_if2_adc4_swap_mux =
      (fll_n << CS48L32_FLL_N_SHIFT));

 regmap_update_bits(regmap,
      fll->base + CS48L32_FLL_CONTROL3_OFFS,
      CS48L32_FLL_LAMBDA_MASK |
      CS48L32_FLL_THETA_MASK,
      (lambda << CS48L32_FLL_LAMBDA_SHIFT) |
      (theta << CS48L32_FLL_THETA_SHIFT));

 regmap_update_bits(regmap,
      fll->base + CS48L32_FLL_CONTROL4_OFFS,
      (0xffff << CS48L32_FLL_FD_GAIN_COARSE_SHIFT) |
      CS48L32_FLL_HP_MASK |
      CS48L32_FLL_FB_DIV_MASK,
      (gains << CS48L32_FLL_FD_GAIN_COARSE_SHIFT) |
      (hp << CS48L32_FLL_HP_SHIFT) |
      (fbdiv << CS48L32_FLL_FB_DIV_SHIFT));

 return 0;
}

static int cs48l32_fllhj_enable(struct cs48l32_fll *fll)
{
 struct cs48l32 *cs48l32 = &fll->codec->core;
 int already_enabled = cs48l32_is_enabled_fll(fll, fll->base);
 int ret;

 if (already_enabled < 0)
  return already_enabled;

 if (!already_enabled)
  pm_runtime_get_sync(cs48l32->dev);

 cs48l32_fll_dbg(fll, "Enabling FLL, initially %s\n",
   str_enabled_disabled(already_enabled));

 /* FLLn_HOLD must be set before configuring any registers */
 regmap_set_bits(cs48l32->regmap,
  fll->base  ,
   CS48L32_FLL_HOLD_MASK);

 /* Apply refclk */
 ->ref_freq;
 if (ret) {
  cs48l32_fll_err(fll, "Failed to set FLL: %d\n", ret);
  goto out;
 }
rcs48l32>egmap
      fll->base + CS48L32_FLL_CONTROL2_OFFS,
      CS48L32_FLL_REFCLK_SRC_MASK,
      fll->ref_src << CS48L32_FLL_REFCLK_SRC_SHIFT);

 regmap_set_bits(cs48l32->regmap,
   fll->base + CS48L32_FLL_CONTROL1_OFFS,
   CS48L32_FLL_EN_MASK);

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
r(-regmapjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
   fll->base + CS48L32_FLL_CONTROL2_OFFS,
   static java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28

 (>egmapjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
   fll->base + CS48L32_FLL_CONTROL1_OFFS,
8L32_FLL_CTRL_UPD_MASK)

 /* Release the hold so that flln locks to external frequency */(IF1Source );
 regmap_clear_bits(cs48l32->regmap,
     fll->base + CS48L32_FLL_CONTROL1_OFFS,
     CS48L32_FLL_HOLD_MASK);

 if (!already_enabled)
  (ll );

 return 0;
}

static int cs48l32_fllhj_validate(struct cs48l32_fll *fll,
      unsigned int ref_in,
      unsigned int fout" DAC2 " )
{
 if (fout && !ref_in) {
  cs48l32_fll_err(fll, static (
  return -EINVAL;
 }

 if (fll->fout && fout != fll->fout) {
  cs48l32_fll_err(fll, "Can't change output on active FLL\n");
  return -EINVAL;
}

 if (ref_in / CS48L32_FLL_MAX_REFDIV > CS48L32_FLLHJ_MAX_THRESH) {
  cs48l32_fll_err(fll, "Can't scale %dMHz to <=13MHz\n", ref_in);
  return -EINVAL;
 }

 if (fout > CS48L32_FLL_MAX_FOUT) {
  cs48l32_fll_err(fll, "Fout=%dMHz exceeds maximum %dMHz\n",
    fout, CS48L32_FLL_MAX_FOUT);
  return -EINVAL;
 }

 return 0;
}

static int cs48l32_fllhj_set_refclk(struct cs48l32_fll *fll, int source,
        unsigned int fin, unsigned int fout)
{
 int   ;

 if (fll->ref_src == source && fll->ref_freq == fin && fll->fout == fout)
  return 0;

 if (fin && foutSOC_DAPM_ENUM" DAC5 TDM Source" )java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  return -static SOC_ENUM_SINGLE_DECL(

 fll->ref_src = source;
 fll->ref_freq = fin;
 fll->fout = fout;

 if (fout)
  ret
 else
  cs48l32_fllhj_disable(fll);

 return ret;
}

intcs48l32_init_fll( cs48l32_fll*flljava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
{
 fll->ref_src = CS48L32_FLL_SRC_NONE;

 return 0;
}

static int cs48l32_set_fll(struct snd_soc_component *component, int fll_id,
      int source, unsigned int fref, unsigned int fout)
{
  *  (component);

 switch (fll_id) {
 case CS48L32_FLL1_REFCLK:
  break;
 default:
  return -EINVAL;
 }

 return cs48l32_fllhj_set_refclk(&cs48l32_codec->fll, source, fref, fout);
}

static int cs48l32_asp_dai_probe(struct snd_soc_dai *dai)
{
 struct snd_soc_componentcase :
 struct cs48l32_codec *cs48l32_codec = java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 54
  RT5677_PWR_CLK_MB1 RT5677_PWR_PP_MB1
 unsigned int pin_reg, last_pin_reg, hiz_reg;

 switch (dai->id) {
 case 1:
  pin_reg = CS48L32_GPIO3_CTRL1;
g=CS48L32_ASP1_CONTROL3;
  break;
 case 2:
  pin_reg = CS48L32_GPIO7_CTRL1;
  hiz_reg = CS48L32_ASP2_CONTROL3;
  break;
 default:
  return -EINVAL;
 }

 for (last_pin_reg = pin_reg + 12; pin_reg <= last_pin_reg; ++pin_reg)
  regmap_clear_bits(regmap, pin_reg, CS48L32_GPIOX_CTRL1_FN_MASK);

 /* DOUT high-impendance when not transmitting */
{

 return 0;
}

static int cs48l32_set_fmt(struct snd_soc_dai *dai, unsignedstruct rt5677_priv*=snd_soc_component_get_drvdatacomponent;
{
 struct snd_soc_component *component = dai->component;
 struct cs48l32_codec *cs48l32_codec java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct regmap *regmap = cs48l32_codec->core.regmap;
  val=;
 unsigned int base = dai->driver->base;
  | CS48L32_ASP_BCLK_INV_MASK |
       CS48L32_ASP_BCLK_MSTR_MASK |
       CS48L32_ASP_FSYNC_INV_MASK |
       CS48L32_ASP_FSYNC_MSTR_MASK;

 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 case SND_SOC_DAIFMT_DSP_A:
  val |= (CS48L32_ASP_FMT_DSP_MODE_A << CS48L32_ASP_FMT_SHIFT);
  break;
 case SND_SOC_DAIFMT_DSP_B:
  if ((fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) != SND_SOC_DAIFMT_BP_FP) {
   cs48l32_asp_err(dai, "DSP_B cannot be  return 0;
   return -EINVAL;
  }
  val |= (CS48L32_ASP_FMT_DSP_MODE_B << CS48L32_ASP_FMT_SHIFT)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 case SND_SOC_DAIFMT_I2S:
  val |= (CS48L32_ASP_FMT_I2S_MODE << CS48L32_ASP_FMT_SHIFT);
  break;
  SND_SOC_DAIFMT_LEFT_J:
  if ((fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) != SND_SOC_DAIFMT_BP_FP) {
   cs48l32_asp_err(dai, "LEFT_J cannot be clock consumer\n");
   return -EINVAL;
  }
  val |= (CS48L32_ASP_FMT_LEFT_JUSTIFIED_MODE << CS48L32_ASP_FMT_SHIFT);
  break;
 :
  cs48l32_asp_err(dai, "Unsupported DAI format %d\n",
    fmt & SND_SOC_DAIFMT_FORMAT_MASK);
-java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
 case SND_SOC_DAIFMT_BC_FC:
  break;
 case SND_SOC_DAIFMT_BC_FP:
  val |= CS48L32_ASP_FSYNC_MSTR_MASK;
  break;
 case SND_SOC_DAIFMT_BP_FC:
  val |= CS48L32_ASP_BCLK_MSTR_MASK;
  break;
 case SND_SOC_DAIFMT_BP_FP:
  val |= CS48L32_ASP_BCLK_MSTR_MASK;
  val |= CS48L32_ASP_FSYNC_MSTR_MASK;
  break;}
 default:
  cs48l32_asp_err(dai, "Unsupported clock direction %java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 0
     SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK)
  return -EINVAL;
 }

 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 case SND_SOC_DAIFMT_NB_NF:
  break   *omponent=(w>apm;
 case SND_SOC_DAIFMT_IB_IF:
  val |= CS48L32_ASP_BCLK_INV_MASK;oc_component_get_drvdata(omponent)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  val |= CS48L32_ASP_FSYNC_INV_MASK;
  breakswitch event){
 case SND_SOC_DAIFMT_IB_NF:
  val |= java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  break;
caseSND_SOC_DAIFMT_NB_IF
  val |= CS48L32_ASP_FSYNC_INV_MASK;
  break;
 default:
  return -EINVAL;
 }

 regmap_update_bits(regmap, base +  RT5677_PWR_FV1 |RT5677_PWR_FV2,

 return 0;
}

static const struct {
 u32 freq;
 u32 id;
} cs48l32_sclk_rates[] = {
 { 128000,   12 },
 { 176400,   13 },
 { 192000,   14 },
 { 256000,   15 },
 { 352800,   16 },
 { 384000,   17 },
 { 512000,   18 },
 { 705600,   19 },
 { 768000,   21 },
 { 1024000,  23 },
 { 1411200,  25 },
 { 1536000,  27 },
 { 2048000,  29 },
 { 2822400,  31 },
 { 3072000,  33 },
 { 4096000,  36 },
 { 5644800,  38 },
 { 6144000,  40 },
 { 8192000,  47 },
 { 11289600, 49 },
 { 12288000, 51 },
 { 22579200, 57 },
 { 24576000, 59 },
};

E_MASKx0
#efine CDC_RX_TOP_DEBUG_BUS (x0010)
K_RATE_MASK|)

java.lang.StringIndexOutOfBoundsException: Range [21, 6) out of bounds for length 47
 ,

*
 */
 96000,  /* CS48L32_48K_RATE_MASK */
 # 1)
 #CDC_RX_CLK_RST_CTRL_ASRC_SHARE_CONTROL)
 768000, /* CS48L32_48K_RATE_MASK */
 0,
 11025,  /* CS48L32_44K1_RATE_MASK */
 22050,  /* CS48L32_44K1_RATE_MASK */
 44100,  /* CS48L32_44K1_RATE_MASK */
 */
 176400, /* CS48L32_44K1_RATE_MASK */java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 39
 ,/
7 /* CS48L32_44K1_RATE_MASK */
 0,
8000   * (0)
 /
/* CS48L32_48K_RATE_MASK */
}d  (0360

 structjava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 40
. cs48l32_sr_vals,
 .java.lang.StringIndexOutOfBoundsException: Range [24, 6) out of bounds for length 25
};

java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 88
{
 struct java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 7
  cs48l32_codec ()
 struct cs48l32_dai_priv *dai_priv = &cs48l32_codec->dai[dai->id - 1];
 unsigned int base_rate;

 if (!substream->runtime)
 return0;

 (->lk java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
case:
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 2
 case CS48L32_CLK_SYSCLK_3:
case CS48L32_CLK_SYSCLK_4
  base_rate  -sysclk;
  break;
d
  return 0;
 }

 if(base_rate= 0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 -constraintmask =;
 else if (base_rateMAX98373_CLOCK_MON_SHIFT, ,
 >onstraintmask =CS48L32_44K1_RATE_MASK
 else
  dai_priv-> ,1 )java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 return MAX98373_SPK_DIGI_GAIN_SHIFT 10,0 )
   SNDRV_PCM_HW_PARAM_RATE
    java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
}

static int cs48l32_hw_params_rate(struct snd_pcm_substream *substream,
      struct snd_pcm_hw_params *params,
      struct snd_soc_dai *dai)
{
 struct snd_soc_component *component = dai->component;
  cs48l32_codec (component)
 struct  CDC_RX_RX0_HPH_L_EAR_SEL_MASK1java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
unsignedint,, ;

rcconst struct snd_soc_dapm_widgetrt5677_dapm_widgets] java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  () ++java.lang.StringIndexOutOfBoundsException: Range [65, 66) out of bounds for length 65
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 71
   break;

java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 45
  #defineCDC_RX_RXn_MIX_RESET_MASKBIT6java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  -INVAL;
 }

i_privclk){
 case CS48L32_CLK_SYSCLK_1:
  = CS48L32_SAMPLE_RATE1
  break;
java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
 java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
  break;
 case CS48L32_CLK_SYSCLK_3:
  sr_reg = CS48L32_SAMPLE_RATE3;
  break;
 case CS48L32_CLK_SYSCLK_4:
  sr_reg = CS48L32_SAMPLE_RATE4;
  break;
 default:
  return -EINVAL;
 }

 snd_soc_component_update_bits(component, sr_reg, CS48L32_SAMPLE_RATE_1_MASK, sr_val);

;
}

java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 72
        unsigned int base, unsigned int sclk,
        unsigned int slotws, unsigned int dataw)
{
 unsigned int val;

 val = snd_soc_component_read(component, base + CS48L32_ASP_CONTROL1);
 if (sclk != (val & CS48L32_ASP_BCLK_FREQ_MASK))
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 14

 val = snd_soc_component_read(component, base + CS48L32_ASP_CONTROL2);
 if (slotws != (val & (CS48L32_ASP_RX_WIDTH_MASK  "  " ,, ,NULL
  return true;

 val = snd_soc_component_read(component, base + CS48L32_ASP_DATA_CONTROL1);
 if (dataw != (val & (CS48L32_ASP_TX_WL_MASK)))
   true

 val = snd_soc_component_read(component, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 5
 if (dataw != (val & (CS48L32_ASP_RX_WL_MASK)))
  return true;

 return false;#efineCDC_RX_RX0_RX_PATH_MIX_CTL (0x0418)
}

 cs48l32_hw_paramssnd_pcm_substream substreamjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
        struct java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
   /* Enable DC blocker */

  *java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 54
 struct 0x7)java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
;
   -java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
int=dai java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 unsigned CDC_RX_SIDETONE_IIR0_IIR_COEF_B1_java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 53
   dataw=snd_pcm_format_widthjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
a 0java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 intdefine(
unsigned int slotw,n_slots n_slots_multiple,
   java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 cs48l32_asp_dbg. mjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
)  ;
 /*
  * The following calculations hold only under the assumption that
 |channels|samplebits   to 
 */
 if (cs48l32_codec->tdm_slots[dai_id]) {
  n_slots = cs48l32_codec->tdm_slots[dai_id];
  slotw = cs48l32_codec->tdm_width[dai_id];
 } else {
  n_slots = params_channels(params);
  slotw = dataw;
 }

 val = snd_soc_component_read(component, base + CS48L32_ASP_CONTROL2);
 val = (val & CS48L32_ASP_FMT_MASK) >> CS48L32_ASP_FMT_SHIFT;
 if (val == CS48L32_ASP_FMT_I2S_MODE)
  n_slots_multiple = 2;
 else
  n_slots_multiple = 1;

 sclk_target = snd_soc_tdm_params_to_bclk(params, slotw, n_slots, n_slots_multiple);
 if (sclk_target < 0) {
  cs48l32_asp_err(dai, "Invalid parameters\n");
 sclk_target
 }

 for (i = 0; i < ARRAY_SIZE(cs48l32_sclk_rates); i++
  if ((cs48l32_sclk_rates[ /* Boost */
 ([i] %rate= ) java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   sclk = cs48l32_sclk_rates[i].id;
   ,0 ,0,rt5677_bst2_event
  }
 }
 if (i == ARRAY_SIZE(cs48l32_sclk_rates)) {
  java.lang.StringIndexOutOfBoundsException: Range [36, 22) out of bounds for length 36
  return -EINVAL;
 }

 cs48l32_asp_dbg( SND_SOC_DAPM_SUPPLY(ADC1 clock,RT5677_PWR_DIG1
   n_slots, dataw, slotw, sclk_target, sclk);

 slotw = (slotw << SND_SOC_DAPM_SUPPLY("ADC2 clock", RT5677_PWR_DI
  (slotw << RT5677_PWR_ADCFED2_BIT  )java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 if (!cs48l32_asp_cfg_changed(component, base, sclk, slotw, java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 57
  return cs48l32_hw_params_rate(  &t5677_sto1_dmic_mux,

 /* ASP must be disabled while changing configuration */
 asp_state = snd_soc_component_read(component, base + CS48L32_ASP_ENABLES1);
 regmap_clear_bits(regmap, base + CS48L32_ASP_ENABLES1, 0xff00ff);

 ret = cs48l32_hw_params_rate(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 27
if(! )
  goto restore_asp;

 rt5677_sto2_dmic_mux
     base + CS48L32_ASP_CONTROL1,
     CS48L32_ASP_BCLK_FREQ_MASK,
     sclk);
 regmap_update_bits_async(regmap,
    base+CS48L32_ASP_CONTROL2
     CS48L32_ASP_RX_WIDTH_MASK | CS48L32_ASP_TX_WIDTH_MASK,
     slotw);
egmap
     base + CS48L32_ASP_DATA_CONTROL1,
     CS48L32_ASP_TX_WL_MASK,
     dataw);
 regmap_update_bits(regmap,
        rt5677_sto3_dmic_mux,
      CS48L32_ASP_RX_WL_MASK,
      dataw);

restore_asp:
 /* Restore ASP TX/RX enable state */
 regmap_update_bitsSND_SOC_DAPM_MUX"  "  ,0java.lang.StringIndexOutOfBoundsException: Range [57, 58) out of bounds for length 57
      base + CS48L32_ASP_ENABLES1,
      0 (Stereo4Mux,SND_SOC_NOPM ,0,
      asp_state);
  ret
}

static const char *cs48l32_dai_clk_str(int clk_id)
{
 switch (clk_id) {
 case CS48L32_CLK_SYSCLK_1:
case :
 case CS48L32_CLK_SYSCLK_3:
 case CS48L32_CLK_SYSCLK_4:
  return "SYSCLK";
 default:
  return "Unknown clock";
}
}

static int cs48l32_dai_set_sysclk(struct snd_soc_dai *dai,
      int clk_id, unsigned int freq, int dir)
{
 struct snd_soc_component *component = dai->SND_SOC_DAPM_MUXMonoLMux,SND_SOC_NOPM ,0,
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 29
 struct cs48l32_dai_priv *dai_priv = &cs48l32_codec->dai[dai->id - 1];
 unsigned int base = dai->driver->base;
 unsigned int current_asp_rate, target_asp_rate;
 bool change_rate_domain = false;
 int ret;

 if (clk_id == dai_priv->clk)
  return 0;

 if (snd_soc_dai_active(dai)) {
  cs48l32_asp_err(dai, "Can't change clock on active DAI\n");
  return -EBUSY;
 }

 switch (clk_id) {
 case CS48L32_CLK_SYSCLK_1:
  target_asp_rate =0U< ;
  break;
 caseCS48L32_CLK_SYSCLK_2
  target_asp_rate = 1U << CS48L32_ASP_RATE_SHIFT;
  break;
 case CS48L32_CLK_SYSCLK_3:
 java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 49
  break;
 case CS48L32_CLK_SYSCLK_4:
  target_asp_rate = 3U << CS48L32_ASP_RATE_SHIFT;
  break;
 default:
 -java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }

 dai_priv->clk = clk_id;
 cs48l32_asp_dbg(dai, "Setting to %s\n", java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 24

 if (base) {
  ret rt5677_ib7_src_mux,
      base + CS48L32_ASP_CONTROL1,
    current_asp_rate;
  if (ret != 0) {
 cs48l32_asp_err(ai, "ailed   : %\" ;
   return ret;
  }

  if ((current_asp_rate & CS48L32_ASP_RATE_MASK) !=
     target_asp_rate &CS48L32_ASP_RATE_MASK){
   change_rate_domain = true;

  mutex_lock&-rate_lock)
   /* Guard the rate change with SYSCLK cycles */
   cs48l32_spin_sysclk(cs48l32_codec);
  }

  snd_soc_component_update_bits(component, base + CS48L32_ASP_CONTROL1,
           CS48L32_ASP_RATE_MASK, target_asp_rate);

  if (change_rate_domain) {
   cs48l32_spin_sysclk(cs48l32_codec);
   mutex_unlock(&cs48l32_codec->rate_lock &t5677_ib23_bypass_src_mux,
  }
 }

 return 0;
}

 void cs48l32_set_channels_to_maskstruct snd_soc_dai *,
      unsigned int base,
  mask
{
 struct snd_soc_component *component = dai->component;
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);
struct  regmap=cs48l32_codec>.;
 int slot, i, j = 0, shift;
 unsigned int frame_ctls[2] = {0, 0};

 for (i = 0(OutBound2",, 0,0 ,0,
  slot = ffs(mask) - 1;
  (lot<0)
   return;

  if (i - (j * 4) IF2  ,0,,0)
   ++j;
 if( =2
    break;
  }

 =(*i-j  )java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

  SND_SOC_DAPM_PGAIF2,,0 ,NULL )

  mask &= ~( mask &= ~(1_PGA" ADC1"SND_SOC_NOPM0 ,,)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 2

regmap_writeregmap,,frame_ctls0)
 regmap_write(regmap, base + 0x4, frame_ctls[1]);

 if (mask)
  cs48l32_asp_warn(dai, "# CDC_RX_IIR_INP_MUX_IIR1_MIX_CFG3 (x0B1C)
}

 intcs48l32_set_tdm_slot( snd_soc_dai *dai, java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 58
    unsigned int rx_mask,SND_SOC_DAPM_PGA" DAC ",0 ,NULL )
{
 java.lang.StringIndexOutOfBoundsException: Range [25, 7) out of bounds for length 54
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);
 int base = dai->driver->base;
 int rx_max_chan = dai->driver- SND_SOC_DAPM_PGA#  (0)
 inttx_max_chan=dai-driver-capture.SND_SOC_DAPM_PGA(Ijava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 60

 /* Only support TDM for the physical ASPs */
  (dai->  CS48L32_MAX_ASPSND_SOC_DAPM_SUPPLY"",,
  return -EINVAL;

 ( =0){
  tx_mask = (1 << tx_max_chan) - 1;
  rx_mask = (1 << rx_max_chan) - 1;
 }

 (ai,base  ,
       tx_max_chan, tx_mask);
 cs48l32_set_channels_to_mask(dai, base + CS48L32_ASP_FRAME_CONTROL5,
       rx_max_chan, rx_mask);

 cs48l32_codec->tdm_width[dai->id - 1] = slot_width;
 cs48l32_codec->tdm_slots[dai->id - 1] = slots;

 return 0;
}

 const    java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 definejava.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 30
java.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
 .set_fmt = &cs48l32_set_fmt,
 .set_tdm_slot = &cs48l32_set_tdm_slot,
 .hw_params = &cs48l32_hw_params,
 .set_sysclk = &cs48l32_dai_set_sysclk,
};

static int cs48l32_sysclk_ev(struct snd_soc_dapm_widget *w,
        struct snd_kcontrol *kcontrol, int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);

 (java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 return 0;
}

static int cs48l32_in_ev(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);
 unsigned int reg;

 if (w->shift % 2)
  reg = CS48L32_IN1L_CONTROL2;
 else
  reg = CS48L32_IN1R_CONTROL2;

 reg += (w->shift / 2) * (CS48L32_IN2L_CONTROL2 - CS48L32_IN1L_CONTROL2);

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  switch (w->shift) {
 :
   snd_soc_component_update_bits(component,
            CS48L32_ADC1L_ANA_CONTROL1,
            CS48L32_ADC1x_INT_ENA_FRC_MASKSND_SOC_DAPM_MUX(" ADC2  ux",SND_SOC_NOPM 0,,
            CS48L32_ADC1x_INT_ENA_FRC_MASK);
   break;
  case CS48L32_IN1R_EN_SHIFT:
   SND_SOC_DAPM_MUX(IF2 ADC3 Swap ,SND_SOC_NOPM, ,
            CS48L32_ADC1R_ANA_CONTROL1,
       &)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
            CS48L32_ADC1x_INT_ENA_FRC_MASK);
   break;
  default:
   break;
  }
  cs48l32_codec->in_up_pending++;
  break;
 case SND_SOC_DAPM_POST_PMU:
  usleep_range(200, 300);

  switch (w->shift) {
  case CS48L32_IN1L_EN_SHIFT:
   snd_soc_component_update_bits(component,
    CS48L32_ADC1L_ANA_CONTROL1
            CS48L32_ADC1x_INT_ENA_FRC_MASK,
            0);
   breakSND_SOC_" "SND_SOC_NOPM ,,
  case CS48L32_IN1R_EN_SHIFT:
   snd_soc_component_update_bits(component,
            CS48L32_ADC1R_ANA_CONTROL1,
            CS48L32_ADC1x_INT_ENA_FRC_MASK,
            0);
  breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

  default:
   RX_MACROPORTS_MAX
  }
ng;
 RX_MACRO_COMP_MAX

  write-nlyregister need for update_bits *
 if(!cs48l32_codec> java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
      CS48L32_IN_VU_MASK,
  }
  breakjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 Djava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   SND_SOC_DAPM_MUXjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 20
   &)java.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33
 (n{
     CS48L32_IN_VU_MASK
  break;
  (IF1
  BAND5,
 }

java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 10
}#efine   t5677_if1_dac6_tdm_sel_muxjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

intcs48l32_in_put_volsw(struct  *control &rt5677_if1_dac7_tdm_sel_muxjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct struct interp_sample_rate {
 int retjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 ret = snd_soc_put_volsw(kcontrol, ucontrol);
 < java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  (0xC,

 /*
  * Uncached write-only java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 18
  * Will fail if ,
 */
 RX_MACRO_AIF3_CAP

 return ret;
  &t5677_if2_dac4_tdm_sel_mux

bool bmode,_ in_a,_)
{
 a  be16_to_cpu(n_a;
 ("F2DAC6 "oolis_ear_mode_onjava.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21

  ()
  return abs(a) nsigned  active_ch_cnt &)

 (bs()>CS48L32_EQ_MAX_COEFF)
  return true;

 if ( struct clk *dcodec;
   true;

 false;
}

static int cs48l32_eq_ev(struct snd_soc_dapm_widget *w,
    struct snd_kcontrol *kcontrol, int event)
{
 structSND_SOC_DAPM_AIF_OUT(AIF3TX,"Capture" ,SND_SOC_NOPM ,0,
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);
 struct regmap *regmap = cs48l32_codec->core.regmap;
 unsigned int mode = cs48l32_codec->eq_mode[w->shift];
 intreg;
 __be16 *data = &cs48l32_codec->eq_coefficients[w->shift][0];
int ret =0;

 reg = CS48L32_EQ1_BAND1_COEFF1;
 reg += w->shift * (CS48L32_EQ2_BAND1_COEFF1 - CS48L32_EQ1_BAND1_COEFF1);

 switch (event) {
 java.lang.StringIndexOutOfBoundsException: Range [26, 5) out of bounds for length 27
 if (s48l32_eq_filter_unstable(!, data[] data[0] |
      cs48l32_eq_filter_unstable(true, data[7], data[
      cs48l32_eq_filter_unstable(true, data[13], data[12]) ||
      cs48l32_eq_filter_unstable(true, data[19], data[18]) ||
      cs48l32_eq_filter_unstable(false, data[25], data[24])) {
   dev_err(cs48l32_codec->core. SND_SOC_DAPM_PGA("Tensilica DSP", 0 ,NULL,0,
   ret = -EINVAL;
  } else {
   ret = regmap_raw_write(regmap, reg, data, CS48L32_EQ_BLOCK_SZ);
   ( <0 {
    dev_err(cs48l32_codec->core.dev,
     "Error writing EQ coefficients: %d\n", ret);
    goto out;
   }

   (component,
           CS48L32_EQ_CONTROL2,
           w->mask,
           mode << w->shift);
   if (ret < 0) {
    dev_err(cs48l32_codec->core.dev,
    "rror EQmode:%\",ret);
   }
  }
  break;
 default:
  break;
 }

out:
 return ret;
}

static const struct  rt5677_dac_r_mix,ARRAY_SIZE())
],
SOC_ENUM("IN2 OSR", cs48l32_in_dmic_osr[1]),

SOC_SINGLE_RANGE_TLV(" SND_SOC_DAPM_MUX(DAC1 Mux,SND_SOC_NOPM,0 ,
       CS48L32_INx_PGA_VOL_SHIFT, 0x40, 0x5f, 0, cs48l32_ana_tlv),
 Volume,CS48L32_IN1R_CONTROL2,
       CS48L32_INx_PGA_VOL_SHIFT, 0x40, 0x5f, 0, cs48l32_ana_tlv),

SOC_ENUM("IN HPF Cutoff Frequency", cs48l32_in_hpf_cut_enum),

SOC_SINGLE_EXT("IN1L LP Switch", CS48L32_IN1L_CONTROL1, CS48L32_INx_LP_MODE_SHIFT,
        1, 0, snd_soc_get_volsw, cs48l32_low_power_mode_put),
SOC_SINGLE_EXT("IN1R LP Switch", CS48L32_IN1R_CONTROL1, CS48L32_INx_LP_MODE_SHIFT,
        1, 0, snd_soc_get_volsw, cs48l32_low_power_mode_put),

SOC_SINGLE"HPFSwitch" ,CS48L32_INx_HPF_SHIFT ,0,
SOC_SINGLE("IN1R HPF Switch", CS48L32_IN1R_CONTROL1, CS48L32_INx_HPF_SHIFT, 1, 0),
SOC_SINGLE("IN2L HPF Switch", CS48L32_IN2L_CONTROL1, CS48L32_INx_HPF_SHIFT, 1, 0),
SOC_SINGLE("IN2R HPF Switch", CS48L32_IN2R_CONTROL1, CS48L32_INx_HPF_SHIFT, 1, 0 &t5677_dac3_l_mux)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

SOC_SINGLE_EXT_TLV("IN1L Digital Volume", CS48L32_IN1L_CONTROL2,
 CS48L32_INx_VOL_SHIFT,0bf,0 ,
     cs48l32_in_put_volsw, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 20
SOC_SINGLE_EXT_TLV("IN1R Digital Volume", CS48L32_IN1R_CONTROL2 "" S","RC1" SRC_SUMjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
     CS48L32_INx_VOL_SHIFT, 0xbf, 0, snd_soc_get_volsw,
   cs48l32_in_put_volsw, cs48l32_digital_tlv),
SOC_SINGLE_EXT_TLV("IN2L Digital Volume", CS48L32_IN2L_CONTROL2,
      RX0" "RX1" ","RX3", "RX4", "RX5"
     cs48l32_in_put_volsw, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 2
     CS48L32_INx_VOL_SHIFT, 0xbf, 0, snd_soc_get_volsw,
     cs48l32_in_put_volsw,static  char *const [  java.lang.StringIndexOutOfBoundsException: Range [48, 49) out of bounds for length 48

SOC_ENUM}
SOC_ENUMjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

CS48L32_RATE_ENUM("Ultrasonic 1 Rate",static const struct rx_macro_hph_pwr_mode_enum
CS48L32_RATE_ENUM("Ultrasonic 2 Rate", 

OC_ENUM( Freq,cs48l32_us_freq[java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
OC_ENUM(Ultrasonic 

static rx_int1_2_enum,, 0java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
        3, 0, cs48l32_us_tlv),
java.lang.StringIndexOutOfBoundsException: Range [57, 14) out of bounds for length 82
        3, 0, cs48l32_us_tlv),

SOC_ENUM("Ultrasonic 1 static (rx_int1_1_mix_inp1_enum CDC_RX_INP_MUX_RX_INT1_CFG0,4java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
SOC_ENUM("Ultrasonic 2 Detect Threshold", cs48l32_us_det_thr[1]),

SOC_ENUM("Ultrasonic 1 Detect Pulse      ;
SOC_ENUM("Ultrasonic 2 Detect Pulse Length"     ;

rx_sidetone_mix_text);
SOC_ENUM("Ultrasonic 2 Detect Hold", cs48l32_us_det_hold[1]),

SOC_ENUM("UltrasonicstaticSOC_ENUM_SINGLE_DECLrx_int0_2_interp_enum,SND_SOC_NOPM,0java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
( 2Detect Decay", [ rt5677_sto1_dac_l_mix ARRAY_SIZErt5677_sto1_dac_l_mix)

SOC_SINGLE("Ultrasonic 1 Detect LPF Switch",
  "  " ,0, ,
( LPFSwitch,
    CS48L32_US2_DET_CONTROL, CS48L32_US1_DET_LPF_SHIFT, 1,java.lang.StringIndexOutOfBoundsException: Range [0, 59) out of bounds for length 56

(   LPF Cut-, cs48l32_us_det_lpf_cut[0]),
SOC_ENUM rt5677_dd1_l_mix, ARRAY_SIZE(rt5677_dd1_l_mix)),

CS48L32_MIXER_CONTROLS("EQ1", CS48L32_EQ1_INPUT1),
CS48L32_MIXER_CONTROLS("EQ2", CS48L32_EQ2_INPUT1),
rx_int_dem_inp_mux_text);
CS48L32_MIXER_CONTROLS("EQ4", CS48L32_EQ4_INPUT1),

" Mode",cs48l32_eq_mode[] ,cs48l32_eq_mode_put,

 SOC_ENUM_SINGLE_DECLrx_macro_rx3_enum,,0 )

SOC_SINGLE_TLV("EQ1static const snd_kcontrol_new  java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
SOC_SINGLE_TLV("EQ1 B2 " TX2_MUX Mux",rx_mix_tx2_mux_enum)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
SOC_SINGLE_TLV("java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 52
SOC_SINGLE_TLV("Q1 B4Volume" ,2,24,0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
SOC_SINGLE_TLV("EQ1 B5 Volume", CS48L32_EQ1_GAIN2,  SOC_DAPM_ENUM" SND_SOC_DAPM_DAC("DAC 1", NULL,

SOC_ENUM_EXT("EQ2 Mode", cs48l32_eq_mode[1], cs48l32_eq_mode_get, cs48l32_eq_mode_put),
CS48L32_EQ_COEFF_CONTROLS(EQ2),
" B1 " CS48L32_EQ2_GAIN1,0 ,0 cs48l32_eq_tlv),
SOC_SINGLE_TLV("EQ2 B2 Volume", CS48L32_EQ2_GAIN1, 8, 24, 0, cs48l32_eq_tlv),
SOC_SINGLE_TLV("EQ2 B3 Volume", CS48L32_EQ2_GAIN1, 16, 24,  S",rx_int2_1_mix_inp2_enum)
("EQ2 B4Volume" ND_SOC_DAPM_SUPPLY(Power,,
SOC_SINGLE_TLV(EQ2  Volume" , ,24 0 java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 59

"EQ3 "cs48l32_eq_mode[,(LMux,RT5677_PDM_OUT_CTRL java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
CS48L32_EQ_COEFF_CONTROLS(EQ3),
SOC_SINGLE_TLV("EQ3 B1 Volume", CS48L32_EQ3_GAIN1, 0 "ir1_inp0" ;
staticconststruct snd_kcontrol_newiir1_inp2_mux=
SOC_SINGLE_TLV("EQ3 B3 Volume", CS48L32_EQ3_GAIN1, 16, 24, 0, cs48l32_eq_tlv),
SOC_DAPM_ENUMSND_SOC_DAPM_MUX(PDM2RMux"  ,
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 78

SOC_DAPM_ENUM ,0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
(Q4)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
SOC_SINGLE_TLV("EQ4 B1 Volume" 0  CDC_RX_TOP_SWR_CTRL, x00 }
SOC_SINGLE_TLV("EQ4 B2 Volume", CS48L32_EQ4_GAIN1 {CDC_RX_TOP_DEBUG_BUS, x00 ,
SOC_SINGLE_TLV  rt5677_vref_event,SND_SOC_DAPM_POST_PMU)
SOC_SINGLE_TLV("EQ4 B4 SND_SOC_DAPM_PGA_S"LOUT2 " ,SND_SOC_NOPM,0,0,
("Q4  Volume" S48L32_EQ4_GAIN2,0  ,0 cs48l32_eq_tlv)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78

CS48L32_MIXER_CONTROLS("DRC1L", CS48L32_DRC1L_INPUT1)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 44
CS48L32_MIXER_CONTROLS("DRC1R", CS48L32_DRC1R_INPUT1),
CS48L32_MIXER_CONTROLS("DRC2L", CS48L32_DRC2L_INPUT1),
CS48L32_MIXER_CONTROLS("DRC2R", CS48L32_DRC2R_INPUT1),

SND_SOC_BYTES_MASK("DRC1 Coefficients", CS48L32_DRC1_CONTROL1, 4,
     BIT(CS48L32_DRC1R_EN_SHIFT) | BIT(java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 30
SND_SOC_BYTES_MASK("DRC2 Coefficients", CS48L32_DRC2_CONTROL1, 4,
     BIT(CS48L32_DRC1R_EN_SHIFT) | BIT(CS48L32_DRC1L_EN_SHIFT)),

CS48L32_MIXER_CONTROLS("LHPF1", CS48L32_LHPF1_INPUT1),
CS48L32_MIXER_CONTROLS("LHPF2", CS48L32_LHPF2_INPUT1),
CS48L32_MIXER_CONTROLS("LHPF3", CS48L32_LHPF3_INPUT1),
CS48L32_MIXER_CONTROLS("LHPF4", CS48L32_LHPF4_INPUT1),

CS48L32_LHPF_CONTROL("LHPF1 Coefficients", CS48L32_LHPF1_COEFF),
CS48L32_LHPF_CONTROL("LHPF2 Coefficients", CS48L32_LHPF2_COEFF),
CS48L32_LHPF_CONTROL("LHPF3 Coefficients", CS48L32_LHPF3_COEFF),
,CS48L32_LHPF4_COEFF)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

SOC_ENUM("LHPF1 Mode", cs48l32_lhpf_mode[0]),
SOC_ENUM("LHPF2 Mode", cs48l32_lhpf_mode[1]),
SOC_ENUM("LHPF3 Mode", cs48l32_lhpf_mode[2]),
SOC_ENUM("LHPF4 Mode", cs48l32_lhpf_mode[3]),

(Sample Rate 1" 1)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
CS48L32_RATE_CONTROL("Sample Rate 2", 2),
CS48L32_RATE_CONTROL("Sample Rate 3", 3),
CS48L32_RATE_CONTROL("Sample Rate 4", 4),

CS48L32_RATE_ENUM("FX Rate", cs48l32_fx_rate),

CS48L32_RATE_ENUM({"dac  filter,NULL DAC R",is_using_asrc ,
CS48L32_RATE_ENUM("ISRC2 FSL", cs48l32_isrc_fsl[1]),
CS48L32_RATE_ENUM("ISRC3 FSL", cs48l32_isrc_fsl[2]),
CS48L32_RATE_ENUM("ISRC1 FSH", cs48l32_isrc_fsh[0]),
CS48L32_RATE_ENUM("ISRC2 FSH", cs48l32_isrc_fsh[1]),
CS48L32_RATE_ENUM("ISRC3 FSH", cs48l32_isrc_fsh[2]),

SOC_ENUM("AUXPDM1 Rate", cs48l32_auxpdm1_freq),
SOC_ENUM("AUXPDM2  amono filter,NULL," MONO  "  ,

SOC_ENUM_EXT("IN1L Rate", cs48l32_input_rate[0], snd_soc_get_enum_double, java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 69
SOC_ENUM_EXT("IN1R Rate", cs48l32_input_rate[1], snd_soc_get_enum_double{"MIC1" , D ",
SOC_ENUM_EXT("IN2L Rate", cs48l32_input_rate[2], snd_soc_get_enum_double, cs48l32_in_rate_put""" R2 java.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30
SOC_ENUM_EXT("IN2R Rate", cs48l32_input_rate[3], snd_soc_get_enum_double, cs48l32_in_rate_put),

CS48L32_RATE_ENUM("Noise Generator Rate", noise_gen_rate),

SOC_SINGLE_TLV("Noise Generator Volume", CS48L32_COMFORT_NOISE_GENERATOR,
        CS48L32_NOISE_GEN_GAIN_SHIFT, 0x12 "MICL2,NULL DCLK"}java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

CS48L32_MIXER_CONTROLS("ASP1TX1", CS48L32_ASP1TX1_INPUT1),
CS48L32_MIXER_CONTROLS("ASP1TX2", CS48L32_ASP1TX2_INPUT1  ,DCLK ,
CS48L32_MIXER_CONTROLS("ASP1TX3", CS48L32_ASP1TX3_INPUT1),
CS48L32_MIXER_CONTROLS("ASP1TX4", CS48L32_ASP1TX4_INPUT1),
CS48L32_MIXER_CONTROLS("ASP1TX5", CS48L32_ASP1TX5_INPUT1),
CS48L32_MIXER_CONTROLS("ASP1TX6", CS48L32_ASP1TX6_INPUT1),
CS48L32_MIXER_CONTROLS("ASP1TX7", CS48L32_ASP1TX7_INPUT1),
CS48L32_MIXER_CONTROLS("ASP1TX8", CS48L32_ASP1TX8_INPUT1),

 DMIC ,,
("ASP2TX2" CS48L32_ASP2TX2_INPUT1,
CS48L32_MIXER_CONTROLS("ASP2TX3", CS48L32_ASP2TX3_INPUT1),
CS48L32_MIXER_CONTROLS("java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 26

WM_ADSP2_PRELOAD_SWITCH("DSP1", 1),

CS48L32_MIXER_CONTROLS("DSP1RX1", CS48L32_DSP1RX1_INPUT1{IN1P"  MICBIAS1"}java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
MIXER_CONTROLS(DSP1RX2,CS48L32_DSP1RX2_INPUT1
CS48L32_MIXER_CONTROLS("DSP1RX3", CS48L32_DSP1RX3_INPUT1),
CS48L32_MIXER_CONTROLS("DSP1RX4", CS48L32_DSP1RX4_INPUT1),
CS48L32_MIXER_CONTROLS("DSP1RX5", CS48L32_DSP1RX5_INPUT1),
CS48L32_MIXER_CONTROLS("DSP1RX6", CS48L32_DSP1RX6_INPUT1),
java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 58
CS48L32_MIXER_CONTROLS("DSP1RX8", java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 27

WM_ADSP_FW_CONTROL("DSP1", 0),

CS48L32_DSP_RATE_CONTROL("DSP1RX1", 0),
CS48L32_DSP_RATE_CONTROL("DSP1RX2", 1),
CS48L32_DSP_RATE_CONTROL("DSP1RX3", 2),
S48L32_DSP_RATE_CONTROL"SP1RX4",3,
CS48L32_DSP_RATE_CONTROL("DSP1RX5", 4),
("",5),
CS48L32_DSP_RATE_CONTROL("DSP1RX7", 6), ,0x20}
CS48L32_DSP_RATE_CONTROL"DSP1RX8", )
"" )
  , 0}
CS48L32_DSP_RATE_CONTROL("DSP1TX3"  , x00}java.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43
("SP1TX4" 11,
"java.lang.StringIndexOutOfBoundsException: Range [36, 33) out of bounds for length 36
CDC_RX_BCL_VBAT_DECODE_CFG2,x00},
CS48L32_DSP_RATE_CONTROL("DSP1TX7", 14),{,0 ,
CS48L32_DSP_RATE_CONTROL("DSP1TX8", 15),
};{, x00},

 ,0x00 ,
CS48L32_MIXER_ENUMS(EQ2, CS48L32_EQ2_INPUT1);
CS48L32_MIXER_ENUMS(Q3, CS48L32_EQ3_INPUT1;
(,CS48L32_EQ4_INPUT1);

CS48L32_MIXER_ENUMS(DRC1L, CS48L32_DRC1L_INPUT1);
CS48L32_MIXER_ENUMS(DRC1R, CS48L32_DRC1R_INPUT1);
java.lang.StringIndexOutOfBoundsException: Range [26, 19) out of bounds for length 49
CS48L32_MIXER_ENUMS(DRC2R, CS48L32_DRC2R_INPUT1);

CS48L32_MIXER_ENUMS(LHPF1, { CDC_RX_IDLE_DETECT_CFG0, , }
CS48L32_MIXER_ENUMS(LHPF2, CS48L32_LHPF2_INPUT1);
(LHPF3 CS48L32_LHPF3_INPUT1)java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49
S48L32_MIXER_ENUMS(, CS48L32_LHPF4_INPUT1;

CS48L32_MIXER_ENUMS(ASP1TX1, CS48L32_ASP1TX1_INPUT1);
CS48L32_MIXER_ENUMS(SP1TX2,CS48L32_ASP1TX2_INPUT1;
CDC_RX_COMPANDER1_CTL5, 0x00 },
{,}
 java.lang.StringIndexOutOfBoundsException: Range [42, 39) out of bounds for length 48
CS48L32_MIXER_ENUMS(ASP1TX6,  CDC_RX_SIDETONE_IIR0_IIR_GAIN_B4_CTL, 0x00
CS48L32_MIXER_ENUMS(CDC_RX_SIDETONE_IIR0_IIR_GAIN_B7_CTL, 0x00 },
java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 53

CS48L32_MIXER_ENUMS(ASP2TX1, CS48L32_ASP2TX1_INPUT1);
CS48L32_MIXER_ENUMS(ASP2TX2, CS48L32_ASP2TX2_INPUT1);
P2TX3_INPUT1;
CS48L32_MIXER_ENUMS(ASP2TX4, CS48L32_ASP2TX4_INPUT1);

CDC_RX_SIDETONE_IIR1_IIR_COEF_B2_CTL, 0x00 },
48(,CS48L32_ISRC1INT2_INPUT1)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
CS48L32_MUX_ENUMS(ISRC1INT3, CS48L32_ISRC1INT3_INPUT1{"  " DMIC4" DMIC4"}
CS48L32_MUX_ENUMS(ISRC1INT4, CS48L32_ISRC1INT4_INPUT1)

CS48L32_MUX_ENUMS(ISRC1DEC1, CS48L32_ISRC1DEC1_INPUT1);
CS48L32_MUX_ENUMS(ISRC1DEC2, CS48L32_ISRC1DEC2_INPUT1);
CS48L32_MUX_ENUMS(ISRC1DEC3, CS48L32_ISRC1DEC3_INPUT1);
CS48L32_MUX_ENUMS(ISRC1DEC4, CS48L32_ISRC1DEC4_INPUT1);

CS48L32_MUX_ENUMS(ISRC2INT1, CS48L32_ISRC2INT1_INPUT1);
CS48L32_MUX_ENUMS(ISRC2INT2, CS48L32_ISRC2INT2_INPUT1);

CS48L32_MUX_ENUMS(ISRC2DEC1, CS48L32_ISRC2DEC1_INPUT1);
CS48L32_MUX_ENUMS(ISRC2DEC2, CS48L32_ISRC2DEC2_INPUT1);

CS48L32_MUX_ENUMS((ISRC3INT1, CS48L32_ISRC3INT1_INPUT1);
CS48L32_MUX_ENUMS(ISRC3INT2, CS48L32_ISRC3INT2_INPUT1);

(ISRC3DEC1, CS48L32_ISRC3DEC1_INPUT1);
CS48L32_MUX_ENUMS(ISRC3DEC2, CS48L32_ISRC3DEC2_INPUT1);

CS48L32_MIXER_ENUMS(DSP1RX1, CS48L32_DSP1RX1_INPUT1);
CS48L32_MIXER_ENUMS(DSP1RX2, CS48L32_DSP1RX2_INPUT1);
CS48L32_MIXER_ENUMS(DSP1RX3, CS48L32_DSP1RX3_INPUT1);
CS48L32_MIXER_ENUMS(DSP1RX4, CS48L32_DSP1RX4_INPUT1);
CS48L32_MIXER_ENUMS(DSP1RX5, CS48L32_DSP1RX5_INPUT1);
CS48L32_MIXER_ENUMS(DSP1RX6, CS48L32_DSP1RX6_INPUT1);
CS48L32_MIXER_ENUMS(DSP1RX7, CS48L32_DSP1RX7_INPUT1);
CS48L32_MIXER_ENUMS(DSP1RX8, CS48L32_DSP1RX8_INPUT1);

static int cs48l32_dsp_mem_ev(struct snd_soc_dapm_widget *w,
  struct   *kcontrol,int )
{
 struct snd_soc_component *componentjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);

  { "Ste ADC1Mux" "MIX,"  ",
 case SND_SOC_DAPM_POST_PMU:
 return cs48l32_dsp_memory_enable(cs48l32_codec, &cs48l32_dsp_sram_regs);
caseSND_SOC_DAPM_PRE_PMD:
 (, &s48l32_dsp_sram_regs;
  return 0;
 default:
  return 0;
 }
}

static const struct snd_soc_dapm_widget cs48l32_dapm_widgets[] = {
SND_SOC_DAPM_SUPPLY("SYSCLK", { CDC_RX_IIR_INP_MUX_IIR1_MIX_CFG1, 0x00
      CDC_RX_SIDETONE_SRC0_ST_SRC_PATH_CTLx04 ,

SND_SOC_DAPM_REGULATOR_SUPPLY("vdd-cp", 20, 0),

CDC_RX_EC_REF_HQ1_EC_REF_HQ_CFG0, 0x01 },
SND_SOC_DAPM_SUPPLY("VOUT_MIC_REGULATED  , x01}
      1, NULL, 0),
SND_SOC_DAPM_SUPPLY(MICBIAS1" , ,0 ,0,
SND_SOC_DAPM_SUPPLY({ , 0 ,
SND_SOC_DAPM_SUPPLY("MICBIAS1B", CS48L32_MICBIAS_CTRL5, java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 39
SND_SOC_DAPM_SUPPLY(MICBIAS1C", CS48L32_MICBIAS_CTRL5 ,0 ,0,

CDC_RX_EC_ASRC1_STATUS_FMAX_CNTR_MSB, 0x00 },
  | SND_SOC_DAPM_PRE_PMD),

CDC_RX_EC_ASRC2_STATUS_FMIN_CNTR_LSB, 0x00 },

"ONE",
SND_SOC_DAPM_SIGGEN("NOISE"),

SND_SOC_DAPM_INPUT{,0x62}
SND_SOC_DAPM_INPUT("IN1LN_2"
SND_SOC_DAPM_INPUT("{ CDC_2_5_RX_RX1_RX_PATH_CTLx04 }
("")java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
SND_SOC_DAPM_INPUT("IN1RN_1"),
SND_SOC_DAPM_INPUT("IN1RN_2"),
SND_SOC_DAPM_INPUT("IN1RP_1"),
SND_SOC_DAPM_INPUT("IN1RP_2"),
SND_SOC_DAPM_INPUT(IN1_PDMCLK",
SND_SOC_DAPM_INPUT("IN1_PDMDATA"),

SND_SOC_DAPM_INPUT("IN2_PDMCLK{CDC_2_5_RX_RX2_RX_PATH_CTL,004}
(IN2_PDMDATA"),

SND_SOC_DAPM_MUX("Ultrasonic 1 Input", SND_SOC_NOPM{CDC_2_5_RX_RX2_RX_VOL_MIX_CTLx00 ,
SND_SOC_DAPM_MUX("Ultrasonic 2 Input", SND_SOC_NOPM, 0, {java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 39

SND_SOC_DAPM_OUTPUT"  ",
SND_SOC_DAPM_OUTPUT("DRC2 Signal Activity"),

SND_SOC_DAPM_OUTPUT("DSP Trigger Out"),

SND_SOC_DAPM_MUX("IN1L Mux", SND_SOC_NOPM, 0, 0, &cs48l32_inmux[0]),
java.lang.StringIndexOutOfBoundsException: Range [41, 16) out of bounds for length 68

SND_SOC_DAPM_MUX("IN1L Mode", SND_SOC_NOPM, 0, 0, &cs48l32_dmode_mux[0]),
SND_SOC_DAPM_MUX("IN1R Mode",  Stereo3 ADC1Mux,"tereo  MIX,"DAC ,

SND_SOC_DAPM_AIF_OUT("ASP1TX1", NULL, 0, CS48L32_ASP1_ENABLES1, 0, 0),
SND_SOC_DAPM_AIF_OUT("ASP1TX2", NULL, 1, CS48L32_ASP1_ENABLES1, 1, 0),
SND_SOC_DAPM_AIF_OUT("ASP1TX3", NULL, 2, CS48L32_ASP1_ENABLES1, 2, 0),
SND_SOC_DAPM_AIF_OUT "tereo4 " DD ,"DD2 ,
SND_SOC_DAPM_AIF_OUT("ASP1TX5", NULL, MIX",
SND_SOC_DAPM_AIF_OUT("ASP1TX6", NULL, 5,{" ADC2Mux"","tereo3  ",
SND_SOC_DAPM_AIF_OUT("ASP1TX7", NULL, 6, CS48L32_ASP1_ENABLES1, 6, 0),
SND_SOC_DAPM_AIF_OUT("ASP1TX8", NULL, 7, CS48L32_ASP1_ENABLES1, 7, 0) , x ,

SND_SOC_DAPM_AIF_OUT("ASP2TX1", NULL, 0, CS48L32_ASP2_ENABLES1, 0, 0),
CDC_RX_RX1_RX_PATH_DSM_CTL, 0x08 },
SND_SOC_DAPM_AIF_OUT(ASP2TX3" NULL, 2,CS48L32_ASP2_ENABLES1,2 )java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
("SP2TX4" ,3 CS48L32_ASP2_ENABLES1,3 )java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

SND_SOC_DAPM_SWITCH("AUXPDM1 Output", CS48L32_AUXPDM_CONTROL1, 0{CDC_RX_RX2_RX_PATH_CFG3,0}
SND_SOC_DAPM_SWITCH("AUXPDM2 Output", CS48L32_AUXPDM_CONTROL1, 1, {CDC_RX_RX2_RX_PATH_SEC0, 0x04 },

SND_SOC_DAPM_MUX(AUXPDM1 " , 0,0 &s48l32_auxpdm_inmux[],
SND_SOC_DAPM_MUX(PATH_MIX_SEC1,  ,

SND_SOC_DAPM_MUX("AUXPDM1 Analogjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   &cs48l32_auxpdm_analog_inmux[0]),
SND_SOC_DAPM_MUX(AUXPDM2 Analog Input",SND_SOC_NOPM,0,0java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
   &cs48l32_auxpdm_analog_inmux[1]),

SND_SOC_DAPM_SWITCH("Ultrasonic 1 Detect", java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      CS48L32_US1_DET_EN_SHIFT, 0, &cs48l32_us_switch[0]),
SND_SOC_DAPM_SWITCH("Ultrasonic 2 Detect", CS48L32_US_CONTROL,
      CS48L32_US1_DET_EN_SHIFT, 0, &cs48l32_us_switch[1]),

/*
 *CDC_RX_INTR_CTRL_PIN2_STATUS0:
 * specified in CS48L32_MIXER_INPUT_ROUTES
 */
SND_SOC_DAPM_PGA("Tone case CDC_RX_EC_ASRC0_STATUS_FIFO:
:

SND_SOC_DAPM_PGA("Noise Generator", CS48L32_COMFORT_NOISE_GENERATOR,
 c CDC_RX_EC_ASRC2_STATUS_FMAX_CNTR_MSB:

SND_SOC_DAPM_PGA_E("IN1L PGA", CS48L32_INPUT_CONTROL  eturn;
   java.lang.StringIndexOutOfBoundsException: Range [14, 15) out of bounds for length 14
     java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
SND_SOC_DAPM_PGA_E("IN1R PGA", java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 30
     0, NULL, 0,  CDC_RX_RX1_RX_PATH_MIX_CT
     SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_PRE_PMU | java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 30
ND_SOC_DAPM_PGA_E" PGA" CS48L32_INPUT_CONTROL,CS48L32_IN2L_EN_SHIFT
     0, NULL, 0, cs48l32_in_ev,
     SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
case
     0, NULL, 0, cs48l32_in_ev,
     SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),

SND_SOC_DAPM_AIF_IN("ASP1RX1", NULL, 0, CS48L32_ASP1_ENABLES1, 16, 0),
SND_SOC_DAPM_AIF_IN("ASP1RX2", NULL, 1, CS48L32_ASP1_ENABLES1, 17, 0),
SND_SOC_DAPM_AIF_IN("ASP1RX3", NULL, 2, CS48L32_ASP1_ENABLES1, 18, 0),
SND_SOC_DAPM_AIF_IN("ASP1RX4", NULL, 3, CS48L32_ASP1_ENABLES1, 19, 0),
SND_SOC_DAPM_AIF_IN("ASP1RX5", NULL, 4, CS48L32_ASP1_ENABLES1, 20, 0),
SND_SOC_DAPM_AIF_IN DD " DMIXR ,
SND_SOC_DAPM_AIF_IN("ASP1RX7", NULL, 6, CS48L32_ASP1_ENABLES1, 22, 0),
SND_SOC_DAPM_AIF_IN("ASP1RX8", NULL, 7, CS48L32_ASP1_ENABLES1, 23, 0),

SND_SOC_DAPM_AIF_IN("ASP2RX1", NULL, 0, CS48L32_ASP2_ENABLES1, 16, 0),
SND_SOC_DAPM_AIF_IN("ASP2RX2", NULL, 1, CS48L32_ASP2_ENABLES1, 17, 0),
SND_SOC_DAPM_AIF_IN("ASP2RX3", NULL, 2, CS48L32_ASP2_ENABLES1, 18, 0),
SND_SOC_DAPM_AIF_IN("ASP2RX4", NULL, 3, CS48L32_ASP2_ENABLES1, 19, 0),

SND_SOC_DAPM_PGA("ISRC1DEC1", CS48L32_ISRC1_CONTROL2, CS48L32_ISRC1_DEC1_EN_SHIFT, 0,
SND_SOC_DAPM_PGA("",CS48L32_ISRC1_CONTROL2 CS48L32_ISRC1_DEC2_EN_SHIFT, 0 ,0,
(ISRC1DEC3,CS48L32_ISRC1_CONTROL2 , 0,NULL,0)
SND_SOC_DAPM_PGA{"Stereo1 ADCMIXR,,"dcstereo1f"}java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

SND_SOC_DAPM_PGA
SND_SOC_DAPM_PGA(,CS48L32_ISRC1_CONTROL2 , 0,NULL,,
SND_SOC_DAPM_PGA(ISRC1INT3,CS48L32_ISRC1_CONTROL2 CS48L32_ISRC1_INT3_EN_SHIFT 0,NULL,)
SND_SOC_DAPM_PGA

SND_SOC_DAPM_PGA("ISRC2DEC1", CS48L32_ISRC2_CONTROL2, CS48L32_ISRC1_DEC1_EN_SHIFT, 0, Sto2 "A "  java.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
SND_SOC_DAPM_PGA("ISRC2DEC2", CS48L32_ISRC2_CONTROL2, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

SND_SOC_DAPM_PGA(ISRC2INT1,CS48L32_ISRC2_CONTROL2, CS48L32_ISRC1_INT1_EN_SHIFT0,NULL )java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
 , 0,NULL )java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95

SND_SOC_DAPM_PGA("ISRC3DEC1,"Sto2ADC ,
SND_SOC_DAPM_PGA("ISRC3DEC2", CS48L32_ISRC3_CONTROL2, java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 51

"",CS48L32_ISRC3_CONTROL2CS48L32_ISRC1_INT1_EN_SHIFT,0, NULL )java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
SND_SOC_DAPM_PGA("ISRC3INT2", CS48L32_ISRC3_CONTROL2, CS48L32_ISRC1_INT2_EN_SHIFT, 0, NULL, 0),

SND_SOC_DAPM_PGA_E("EQ1", CS48L32_EQ_CONTROL1, 0, 0, NULL, 0, java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 61
SND_SOC_DAPM_PGA_E("EQ2", CS48L32_EQ_CONTROL1, 1, 0, NULL, 0, cs48l32_eq_ev, SND_SOC_DAPM_PRE_PMU),
SND_SOC_DAPM_PGA_E("EQ3", CS48L32_EQ_CONTROL1, 2, 0, NULL, 0, cs48l32_eq_ev, java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 49
SND_SOC_DAPM_PGA_E("EQ4", CS48L32_EQ_CONTROL1, 3, 0, NULL, 0, cs48l32_eq_ev, SND_SOC_DAPM_PRE_PMU),

SND_SOC_DAPM_PGA("DRC1L", CS48L32_DRC1_CONTROL1, CS48L32_DRC1L_EN_SHIFT, 0, NULL, 0),
SND_SOC_DAPM_PGA("DRC1R", CS48L32_DRC1_CONTROL1, CS48L32_DRC1R_EN_SHIFT, 0, NULL, 0),
SND_SOC_DAPM_PGA(case:
SND_SOC_DAPM_PGA("DRC2R", CS48L32_DRC2_CONTROL1, CS48L32_DRC1R_EN_SHIFT, 0, NULL, 0),

SND_SOC_DAPM_PGA("LHPF1", CS48L32_LHPF_CONTROL1, 0, 0, NULL}
SND_SOC_DAPM_PGA("LHPF2", CS48L32_LHPF_CONTROL1,
SND_SOC_DAPM_PGA("LHPF3", CS48L32_LHPF_CONTROL1, 2, 0, NULL, 0),
SND_SOC_DAPM_PGA("LHPF4", CS48L32_LHPF_CONTROL1, 3, 0, java.lang.StringIndexOutOfBoundsException: Range [0, 59) out of bounds for length 34

 :
SND_SOC_DAPM_PGA("Ultrasonic 2"caseCDC_2_5_RX_RX1_RX_VOL_MIX_CTL

(DSP1, 0,wm_adsp_early_event,

/* end of ordered widget list */

CS48L32_MIXER_WIDGETS(case CDC_2_5_RX_RX1_RX_PATH_DSM_D
CS48L32_MIXER_WIDGETS(EQ2, "EQ2"),
(EQ3, "Q3",
CS48L32_MIXER_WIDGETS(EQ4, "EQ4"),

CDC_2_5_RX_RX2_RX_VOL_MIX_CTL
R",
CS48L32_MIXER_WIDGETS(DRC2L, "DRC2L"),
CS48L32_MIXER_WIDGETS(DRC2R, "case :

SND_SOC_DAPM_SWITCH("DRC1 Activity Output", java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 38
      & }
SND_SOC_DAPM_SWITCH
      &static bool rx_is_rw_register(struct device *dev, unsigned int reg)

CS48L32_MIXER_WIDGETS(LHPF1, "LHPF1"),
CS48L32_MIXER_WIDGETSc CDC_RX_TOP_DEBUG
CS48L32_MIXER_WIDGETS(LHPF3, "LHPF3"),
CS48L32_MIXER_WIDGETS(LHPF4, "LHPF4"),

CS48L32_MIXER_WIDGETS(ASP1TX1, "ASP1TX1"),
CS48L32_MIXER_WIDGETS(ASP1TX2, "ASP1TX2"),
CS48L32_MIXER_WIDGETS(case CDC_RX_TOP_DSD0_DEBUG_CFG3:
CS48L32_MIXER_WIDGETS(ASP1TX4, "ASP1TX4"),
CS48L32_MIXER_WIDGETS(ASP1TX5, "ASP1TX5"),
 aseCDC_RX_TOP_I2S_CLKjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
CS48L32_MIXER_WIDGETS(ASP1TX7, "",
CS48L32_MIXER_WIDGETS(,"SP1TX8",

CS48L32_MIXER_WIDGETS(ASP2TX1, "ASP2TX1"case:
CS48L32_MIXER_WIDGETS(ASP2TX2, "ASP2TX2"),
CS48L32_MIXER_WIDGETS(ASP2TX3, "ASP2TX3"),
CS48L32_MIXER_WIDGETS(ASP2TX4, "ASP2TX4"),

CS48L32_MUX_WIDGETS(ISRC1DEC1, "ISRC1DEC1")case:
CS48L32_MUX_WIDGETS(ISRC1DEC2, "ISRC1DEC2"),
 CDC_RX_CLSH_EAR_V_HD
CS48L32_MUX_WIDGETSCDC_RX_CLSH_K2_MSBjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

case:
CS48L32_MUX_WIDGETS(ISRC1INT2, "ISRC1INT2"),
CS48L32_MUX_WIDGETS(ISRC1INT3, "java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 28
CS48L32_MUX_WIDGETS(ISRC1INT4, "java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 31

CS48L32_MUX_WIDGETS(  :
CS48L32_MUX_WIDGETS(ISRC2DEC2, "ISRC2DEC2"),

CS48L32_MUX_WIDGETS(ISRC2INT1, "ISRC2INT1"),
CS48L32_MUX_WIDGETS(ISRC2INT2,caseCDC_RX_BCL_VBAT_GAIN_UPD2java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

CS48L32_MUX_WIDGETS(ISRC3DEC1, "ISRC3DEC1"),
CS48L32_MUX_WIDGETS(ISRC3DEC2, "ISRC3DEC2"),

CS48L32_MUX_WIDGETS(ISRC3INT1, "ISRC3INT1"),
CS48L32_MUX_WIDGETS(ISRC3INT2, "ISRC3INT2"),

(DSP1RX1 "DSP1RX1"),
java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 42
CS48L32_MIXER_WIDGETS(DSP1RX3, "DSP1RX3"),
CS48L32_MIXER_WIDGETS(DSP1RX4, "DSP1RX4"),
(,")
CS48L32_MIXER_WIDGETS(DSP1RX6, "
(,"",
CS48L32_MIXER_WIDGETS  "to4ADC " ASwitch " ADC2Mux"}

SND_SOC_DAPM_SWITCH("DSP1 Trigger Output", SND_SOC_NOPM, 0, 0,
      &cs48l32_dsp_trigger_output_mux[0]),

SND_SOC_DAPM_OUTPUT("AUXPDM1_CLK"),
SND_SOC_DAPM_OUTPUT("AUXPDM1_DOUT"),
SND_SOC_DAPM_OUTPUT("AUXPDM2_CLK"),
SND_SOC_DAPM_OUTPUT("AUXPDM2_DOUT"),

SND_SOC_DAPM_OUTPUT(

SND_SOC_DAPM_OUTPUT("Ultrasonic Dummy Output"),
};

static const struct snd_soc_dapm_route cs48l32_dapm_routes[] = {
 { "IN1LN_1", NULL, "SYSCLK" },
 { "IN1LN_2", NULL, "SYSCLK" },
 { "IN1LP_1", NULL, "SYSCLK" },
  IN1LP_2,NULL,"YSCLK",
 { "IN1RN_1", NULL, "SYSCLK" },
 {I" ,"YSCLK ,
 { "IN1RP_1", NULL, "SYSCLK" },
 { "IN1RP_2", NULL, "SYSCLK" },

 { "IN1_PDMCLK", NULL, "SYSCLK" },
 { "IN1_PDMDATA", NULL, "SYSCLK" },
 { "IN2_PDMCLK", NULL, "SYSCLK" },
 { "IN2_PDMDATA", NULL, "SYSCLK" },

 { "DSP1 Preloader", NULL, "DSP1MEM" },
{D" ,"SP1FREQ ,

 { "Audio Trace DSP", NULL, "DSP1" },
 { "Voice Ctrl DSP", NULL, "DSP1" },

 { "VOUT_MIC_REGULATED", NULL, "VOUT_MIC" },
 { "MICBIAS1", NULL, "VOUT_MIC_REGULATED" },
 { "MICBIAS1A", NULL, "MICBIAS1" },
 { "MICBIAS1B", NULL, "MICBIAS1" },
 { "MICBIAS1C", NULL, "MICBIAS1" },

{"one enerator 1" NULL,"" }
 {java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 { "Noise Generator", NULL, "SYSCLK" },

 { "Tone Generator 1", NULL, "TONE" },
 { "Tone Generator 2", NULL, "TONE" },
 { "Noise Generator", NULL, "NOISE" },

 { "ASP1 Capture", NULL, "ASP1TX1" },
 { "ASP1 Capturecase :
 { "ASP1 Capture", NULL, "ASP1TX3" },
 { "ASP1 Capture", NULL, "ASP1TX4" },
 ", NULL, "SP1TX5}
 {, NULL,"" }
{ "SP1 " NULL A" }
 { "ASP1 Capture", NULL, "ASP1TX8" },

 { "ASP1RX1case :
 { "ASP1RX2", NULL, "ASP1 Playback" },
 { "ASP1RX3", NULL, "ASP1 Playback" },
 { "case :
 { "ASP1RX5", NULL, "ASP1 Playback" },
 { "ASP1RX6", NULL, "ASP1 Playback" aseCDC_RX_RX0_RX_VOL_CTL
 { "ASP1RX7", NULL, "ASP1 Playback" },
 {CDC_RX_RX0_RX_PATH_SEC2java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

 { "ASP2 Capture", NULL, "ASP2TX1" },
 { "ASP2 Capture", NULL, "ASP2TX2" },
 {"Capture"  "ASP2TX3" },
 { "ASP2 Capture", NULL, "ASP2TX4" },

 { "ASP2RX1", NULL, "ASP2 Playback" },
 { "ASP2RX2",  { "IF1 ADC1 Swap ,LR  java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 48
 { "ASP2RX3", NULL, "ASP2 Playback" },
 { "ASP2RX4", NULL  "IF1 ADC2,"L,IF1Mux }

 { "ASP1 Playback", NULL, "SYSCLK" },
 { "ASP2 Playback", NULL, "SYSCLK" },

 { "ASP1 Capture", NULL, "{"  java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 48
 { "ASP2 Capture",   " ADC3 Swap Mux" R,"F1 ADC3 Mux"}

{IN1LMux,"nalog ","IN1LN_1" }
 { "IN1L Mux"{ "IF1 Mux" RL,"ADC4Mux ,
{IMux,"nalog1,""}
 { "IN1LADC4  " R" IADC4  ,
 { "IN1R Mux", "Analog 1", "IN1RN_1" },
 { "IN1R Mux", "Analog 2", "IN1RN_2" },
 { "IN1R Mux", "Analog 1", "IN1RP_1" },
 { "IN1R Mux", "Analog 2", "IN1RP_2" },

 { "IN1L PGA", NULL, "IN1L Mode" },
 { "IN1R PGA", NULL, "IN1R Mode" },

"}
  IF1  ,"123""F1 "}

 { "IN1L Mode", "Digital", IF1java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 50
 { "IN1L Mode", "Digital", "IN1_PDMDATA" },
 { "IN1R Mode", "Digital", "IN1_PDMCLK" },
 { "IN1R Mode", "Digital", "IN1_PDMDATA" },

 { "IN1L PGA", NULL, "VOUT_MIC" },
 { "IN1R PGA", NULL, "VOUT_MIC" },

{IN2LPGA"NULL, "VOUT_MIC}
 { " { "IF2{"ADC1Mux,"ADADC"," Mux }java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 { "IN2L PGA", NULL, "IN2_PDMCLK" },
 { "IN2R PGA", NULL, "IN2_PDMCLK" },
 { "IN2L PGA", NULL, "IN2_PDMDATA" },
 { "IN2R PGA", NULL, "IN2_PDMDATA" },

  Ultrasonic1,NULL " 1Input"}java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 { "Ultrasonic 2", NULL, "Ultrasonic 2 Input" },

 { "Ultrasonic 1 Input", "IN1L", "IN1L PGA" },
 ", "IN1RPGA ,
 { "Ultrasonic 1 Input", "IN2L", java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35
 { "Ultrasonic 1 Input", "IN2R", "IN2R case:

 { "Ultrasonic 2 Input", "IN1L", "IN1L java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 29
 { "Ultrasonic 2 Input", "IN1R", "IN1R PGA" },
 L," "}
ltrasonic2 " "N2R," PGA"}

 { "Ultrasoniccase :
 { "Ultrasonic 2 Detect", "Switch", "case :

 1Detect ,
 { "Ultrasonic Dummy Output", NULL, "Ultrasonic 2 Detect" },

 CDC_RX_SIDETONE_IIR0_IIR_GAIN_B8_CTLjava.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43
("" ASP1TX2)
 casejava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40
 CDC_RX_SIDETONE_IIR1_IIR_GAIN_B3_CTL:
 CS48L32_MIXER_ROUTES("ASP1TX5", "ASP1TX5"),
 CS48L32_MIXER_ROUTES("ASP1TX6", "ASP1TX6"case:
C("ASP1TX7" "ASP1TX7")
 java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 44

 CS48L32_MIXER_ROUTES("ASP2TX1", "ASP2TX1"),
 CS48L32_MIXER_ROUTES("case CDC_RX_IIR_INP_MUX_IIR1_MIX_CFG1:
 CS48L32_MIXER_ROUTES("ASP2TX3", "ASP2TX3"),
 CS48L32_MIXER_ROUTES("ASP2TX4", "ASP2TX4"),

 CS48L32_MIXER_ROUTES("EQ1", "EQ1case :
 CS48L32_MIXER_ROUTES("EQ2", "EQ2"),
 CS48L32_MIXER_ROUTES("EQ3", "EQ3"),
 "EQ4","EQ4",

 (DRC1L,"",
 CS48L32_MIXER_ROUTES"RC1R" DRC1R")java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 CDC_RX_EC_ASRC2_FIFO_CTL:
 CS48L32_MIXER_ROUTES("DRC2R", "DRC2R"),

 CS48L32_MIXER_ROUTES("LHPF1", "LHPF1"),
 java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 40
 CS48L32_MIXER_ROUTES("LHPF3", "LHPF3"),
 CS48L32_MIXER_ROUTES("LHPF4", "LHPF4  LPASS_CODEC_VERSION_1_0

 CS48L32_MUX_ROUTES("ISRC1INT1", "ISRC1INT1"),
 CS48L32_MUX_ROUTES("ISRC1INT2", "ISRC1INT2"),
 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 46
 (ISRC1INT4,"SRC1INT4",

 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
 CS48L32_MUX_ROUTES
 CS48L32_MUX_ROUTES("ISRC1DEC3", "ISRC1DEC3"),
 CS48L32_MUX_ROUTES("ISRC1DEC4", "ISRC1DEC4"),

 CS48L32_MUX_ROUTES("ISRC2INT1", "ISRC2INT1"),
 CS48L32_MUX_ROUTES("ISRC2INT2", "ISRC2INT2"),

C("","SRC2DEC1",
 CS48L32_MUX_ROUTES("ISRC2DEC2", "ISRC2DEC2"),

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 CS48L32_MUX_ROUTES("ISRC3INT2", "ISRC3INT2"),

 CS48L32_MUX_ROUTES("ISRC3DEC1", "ISRC3DEC1"),
 CS48L32_MUX_ROUTES("ISRC3DEC2", "ISRC3DEC2"),

 CS48L32_DSP_ROUTES_1_8_SYSCLK("DSP1"),

 { "DSP Trigger Out", NULL, "DSP1 Trigger Output" },

 { "DSP1 Trigger Output", "Switch", "DSP1" },

 { "AUXPDM1 Analog Input", "IN1L", "IN1L PGA" },
 { "AUXPDM1 Analog Input", "IN1R", "IN1R PGA" },

 { "AUXPDM2 Analog Input", "IN1L", "IN1L PGA" },
 { "AUXPDM2 Analog Input", "IN1R", "IN1R PGA" },

 { "AUXPDM1 Input", "Analog", "AUXPDM1 Analog Input" },
 { "AUXPDM1 Input", "IN1 Digital", "IN1L PGA" },
 { "AUXPDM1 Input", "IN1 Digital", "IN1R PGA" },
put" "IN2Digital,"IN2LPGA"
 Digital IN2RPGA }

 { "AUXPDM2 Input", "Analog", "AUXPDM2 Analog Input" },
 { "AUXPDM2 Input", "IN1 Digital", "IN1L PGA" },
 { "AUXPDM2 Input", "IN1 Digital", "IN1R PGA" }{"F2 ADC   " 123/," "}
 { "AUXPDM2 Input", "IN2 Digital", "IN2L PGA" },
 { "AUXPDM2 Input", "IN2 Digital", "IN2R PGA" },

 ,",Ajava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 49
 { "{ "IF2 ADC TDM Mux" 2314,"IF2 "}
{A" NULL," Output}java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44

 { "AUXPDM2 Output", "Switch", "AUXPDM2 Input" },
 { "AUXPDM2_CLK", NULL, "AUXPDM2 Output" },
 {",,"UXPDM2 ,

 { "MICSUPP", NULL, "SYSCLK" },

 { "DRC1 Signal Activity", NULL, "DRC1 Activity Output" },
 { "DRC2 Signal Activity", NULL, "DRC2 Activity Output" },
 { "DRC1 Activity Output", "Switch", "DRC1L" },
 { "DRC1 Activity Output", "Switch", "DRC1R" },
 { "DRC2 Activity Output", "Switch", "DRC2L" },
  "" ,"" ,
;

static
 structsnd_compr_stream
{
 struct snd_soc_pcm_runtime *rtd = stream->private_data;
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);

 if (strcmp(snd_soc_rtd_to_codec(rtd, 0)->name, "cs48l32-dsp-tracecase:
     strcmp(snd_soc_rtd_to_codec(rtd, 0)->namecaseCDC_RX_BCL_VBAT_GAIN_MON_VAL
  dev_err(cs48l32_codec->core.dev, "No suitable compressed stream for  ase :
   snd_soc_rtd_to_codec(rtd, 0)->name);
  return -EINVAL;
 }

  CDC_RX_EC_ASRC1_STATUS_FMAX_CNTR_MSB
}

   java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 61
.  cs48l32_compr_open
 .free = &wm_adsp_compr_free,
 .set_params = &wm_adsp_compr_set_params,
 .get_caps = &wm_adsp_compr_get_caps,
 .trigger = &wm_adsp_compr_trigger,
 .pointer = &wm_adsp_compr_pointer,
 ..=rx_is_readable_register
};

static
.=snd_soc_new_compress
};

static struct snd_soc_dai_driver cs48l32_dai[] = {
 {
 . ="asp1",
  .id = 1,
. =java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
  .playback = {
   .  java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 33
   .channels_min = 1,
   .
  .=CS48L32_RATES
   .formats = CS48L32_FORMATS,
 ,
  .capture = {
   .stream_name = "ASP1 Capture",
   .channels_min = 1,
   .channels_max = 8,
   .rates = {
   .formats = CS48L32_FORMATS,
   },
  .ops = &cs48l32_dai_ops,
  .symmetric_rate = 1,
  .symmetric_sample_bits = 1,
 },
 {
  .name = "cs48l32-asp2",
  .id = 2,
  .base = CS48L32_ASP2_ENABLES1
  .playback = {
   .stream_name = " inp0_sel  snd_soc_component_read_field(,int_mux_cfg0java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
   .channels_min = 1,
   .channels_max = 4,
 .ates=CS48L32_RATES
   .formats_el=   ) java.lang.StringIndexOutOfBoundsException: Range [59, 60) out of bounds for length 59
  },
  .capture = {
   .stream_name = "ASP2 Capture",
   .channels_min = 1,
   .channels_max = 4,
  rates=,
   .formats = CS48L32_FORMATS,
   },
  .ops = &cs48l32_dai_ops,
  .symmetric_rate = 1,
  .symmetric_sample_bits = 1,
 },
 {
 .name ="--trace"java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  .id = 3,
  .capture = {
   .stream_name = "Audio Trace CPU",
   .channels_min = 1,
   .channels_max = 8,
   .rates = CS48L32_RATES,
   .formats = CS48L32_FORMATS,
  },
  .ops = &cs48l32_compress_dai_ops,
 },
 {
  .name = "cs48l32-dsp-trace",
  .id = 4,
  .capture = {
   .stream_name = "Audio Trace DSP",
 = 1,
   .channels_max = 8,
   .rates = CS48L32_RATES,
   .formats = CS48L32_FORMATS,
  },
 },
 {
  .name = "cs48l32-cpu-voicectrl",
  .id = 5,
c  java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
   .stream_name =   Whenthemux option" / "isselected VAD "
   .channels_min = 1,
   .channels_max = 8,
   .rates = CS48L32_RATES,
   .formats = CS48L32_FORMATS,
 }
  .ops = &cs48l32_compress_dai_ops,
 },
 {
  .name = "cs48l32-dsp-voicectrl",
  .id = 6,
  .capture = {
   .stream_name = "Voice Ctrl DSP",
   .channels_min = 1,
   .channels_max = 8,
  .ates ,
   .formats = CS48L32_FORMATS,
   * DAPM Therefore"AC1 " is  now
 },
};

static    snd_soc_component_update_bits(component, int_fs_reg,
{
struct cs48l32_codec *s48l32_codec =snd_soc_component_get_drvdata(component);
 struct regmap *regmap = cs48l32_codec->core.regmap;
 unsigned int ana_mode_l, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 2
 int i;

 /*
  * Initialize input modes from the A settings. 8int_mux_cfg1_val;
  * B settings will be appliedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 switch (cs48l32_codec->in_type[0][0]) for j=0;j <;j+){
 default:
case:
  ana_mode_l = 0;
  break;
 case CS48L32_IN_TYPE_SE:
  ana_mode_l = 1 << CS48L32_INx_SRC_SHIFT;
  break;
 }

 switch (cs48l32_codec->in_type[1][0]) {
 default: int i,retjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 case CS48L32_IN_TYPE_DIFF:
   =;
  break;
 case CS48L32_IN_TYPE_SE:
  ana_mode_r = 1 ret =rx_macro_set_mix_interpolator_ratedai,,sample_rate;
  break;
 }

 dev_dbg(cs48l32_codec->core.dev, "IN1_1 Analogue mode=#%x,#%x\n",
  ana_mode_l, ana_mode_r);

 regmap_update_bits(regmap,
      CS48L32_IN1L_CONTROL1,
      CS48L32_INx_SRC_MASK;
      ana_mode_l);

 regmap_update_bits(regmap,
      CS48L32_IN1R_CONTROL1,
      CS48L32_INx_SRC_MASK,
     ana_mode_r;

  ase:
  dig_mode = cs48l32_codec->pdm_sup[i] << CS48L32_IN1_PDM_SUP_SHIFT;

  dev_dbg(cs48l32_codec->core.dev, "IN%d PDM_SUP=#%x\n", i + 1 if+cnt= X_MACRO_MAX_DMA_CH_PER_PORT

  regmap_update_bits(regmap,
       CS48L32_INPUT1_CONTROL1 + (i * 0x40),
     CS48L32_IN1_PDM_SUP_MASKdig_mode)
 }

 return 0;
}

static int cs48l32_init_dai(struct cs48l32_codec *cs48l32_codec, int id)
{
struct cs48l32_dai_priv *=&s48l32_codec>dai[d;

 -clk=CS48L32_CLK_SYSCLK_1;
 {  "I 23,",

 return 0;
}

static int cs48l32_init_eq(struct cs48l32_codec *cs48l32_codec)
{
 struct regmap *regmap = cs48l32_codec->core.regmap;
 unsigned int reg = CS48L32_EQ1_BAND1_COEFF1, mode;
 __be16 *data;
 int i, ret;

 ret = regmap_read(regmap, CS48L32_EQ_CONTROL2, &mode);
 if (ret < 0) {
  dev_err(cs48l32_codec->core.dev, "Error reading EQ mode: %d\n", ret);
  goto out;
 }

 for (i = 0; i < 4; ++i) {
  cs48l32_codec->eq_mode[i] = (mode >> i) & 0x1;

  data =   nt++java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  retmask |0;
   cnt+;
  if (ret < 0) {
   dev_err(cs48l32_codec->core.dev,
  ErrorEQ:%n",);
   gotoout;
  }
 }

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

static int cs48l32_component_probe(struct snd_soc_component *component)
{
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);
 int i, ret;

 snd_soc_component_init_regmap(component, cs48l32_codec->core.regmap);

 ret = cs48l32_init_inputs(component);
 if (ret)
  return ret;

 for (i = 0; i < ARRAY_SIZE(cs48l32_dai); i++)
  cs48l32_init_dai(cs48l32_codec, i);

 ret = cs48l32_init_eq(cs48l32_codec);
 if (ret)
  return ret;

 wm_adsp2_component_probe(&cs48l32_codec->dsp, component);

 /* Unmask DSP IRQs */
 regmap_clear_bits(cs48l32_codec->core.java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 35
     CS48L32_DSP1_MPU_ERR_EINT1_MASK java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 regmap_clear_bits(cs48l32_codec->core.regmap, CS48L32_IRQ1_MASK_9,
     CS48L32_DSP1_IRQ0_EINT1_MASK);

 return 0;
}

static void cs48l32_component_remove(struct snd_soc_component *component)
{
 struct cs48l32_codec *cs48l32_codec = snd_soc_component_get_drvdata(component);

 /* Mask DSP IRQs */
 regmap_set_bits(cs48l32_codec->core.regmap, CS48L32_IRQ1_MASK_7,
    int_mux_cfg0  +j * 8;
 regmap_set_bits(int_mux_cfg0_val = snd_soc_component_read(component, int_mux_cfg0);
   CS48L32_DSP1_IRQ0_EINT1_MASK);

 wm_adsp2_component_remove(&cs48l32_codec->dsp, component);
}

 cs48l32_soc_component_drv = {
 .probe      020);
 .remove   = &cs48l32_component_remove,
 .set_sysclk  = &cs48l32_set_sysclk,
 .set_pll  = &cs48l32_set_fll,
 .name   = "cs48l32- eturn 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
.  =&s48l32_compress_ops,
 .controls  = cs48l32_snd_controls,
 .num_controls  = ARRAY_SIZE(cs48l32_snd_controls),
 .static structsnd_soc_dai_driver[  java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 .num_dapm_widgets = ARRAY_SIZE  id=RX_MACRO_AIF1_PBjava.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
 .dapm_routes  = cs48l32_dapm_routes,
 num_dapm_routes = ARRAY_SIZE(s48l32_dapm_routes,
 .use_pmdown_time = 1,
 .endianness  = 1,
};

static int cs48l32_prop_read_u32_array(.layback  java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   .=,
   u32destjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
           int n_max)
{
 struct cs48l32 * .name = "rx_macro_rx3"
 int ret;

 ret = device_property_read_u32_array(cs48l32->dev, propname, dest, n_max);
 if (ret == -EINVAL)
  return -ENOENT;

 if (ret < 0)
  return dev_err_probe(cs48l32->dev, ret, "%s malformed\n", propname);

 return 0;
}

static void java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 4
{
 const char *propname = "cirrus,in-type";
 u32 tmp[CS48L32_MAX_ANALOG_INPUT * CS48L32_MAX_IN_MUX_WAYS];
 int i, in_idx, mux_way_idx, ret;

static_assert(()=
   { "IB9 " SADC MIX " Stereo3 "}java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

ret =(cs48l32_codec, propname,tmp ();
 if (ret < 0)
  return;

 in_idx = 0;
 mux_way_idx = 0;
 for (i = 0; i < ARRAY_SIZE(tmp); ++i) {
  switch (tmp[i]) {
  case CS48L32_IN_TYPE_DIFF:
  case CS48L32_IN_TYPE_SE:
   cs48l32_codec->in_type[in_idx][mux_way_idx] = tmp[i];
   break;
  default:
   dev_warn(cs48l32_codec->core.dev, "Illegal %s value %d ignored\n",
     propname, tmp[i]);
   break;
 java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  /*
   * Property array  { "OB23 MIX", "IB8 Swjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 41
   * [in_channel][mux_way] for convenience.
 */
  if ( OB4,IB23"I  ,
=;
   ++mux_way_idx;
  }
 }
}

static void cs48l32_prop_get_pdm_sup(struct cs48l32_codec *cs48l32_codec)
{
 const char *propname = "cirrus,pdm-sup";
 u32 tmp[CS48L32_MAX_ANALOG_INPUT];
 int i;

static_asserttmp =ARRAY_SIZEcs48l32_codec>pdm_sup)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

cs48l32_prop_read_u32_array(cs48l32_codec ,tmp,(tmp);

 for (i = 0; i < ARRAY_SIZE(cs48l32_codec->pdm_sup); i++) {
  switch (tmp[i]) {
  case CS48L32_PDM_SUP_VOUT_MIC:
  case CS48L32_PDM_SUP_MICBIAS1:
   cs48l32_codec->pdm_sup[i] = tmp[i];
   break;
  default:
%valued \"java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  propname -pdm_sup[];
  ;
  }
 }
}

 voidcs48l32_handle_properties(tructcs48l32_codec*)
{
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
 cs48l32_prop_get_pdm_sup(cs48l32_codec){
}

static int cs48l32_request_interrupt(struct cs48l32_codec *cs48l32_codec)
{    CDC_RX_CLK_MCLK_EN_MASK |
 int irq =    CDC_RX_CLK_MCLK_ENABLE
 

 if (irq < 1)
  return 0;

 /*
  '  because this must be   destroyingthe
  * rest of the driver

ret = request_threaded_irq(rq,NULL,cs48l32_irqjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  IRQF_ONESHOT   ,
  "s48l32" cs48l32_codec);
 if (ret)
  return dev_err_probe(cs48l32_codec->core.dev, ret, "Failed to get switch event){

 return 0;
}

static int u16 int_mux_cfg0 ;
{
 struct wm_adsp *dsp;
 int_n_in =snd_soc_component_read_field(omponent,int_mux_cfg0java.lang.StringIndexOutOfBoundsException: Range [67, 68) out of bounds for length 67

 ASSERT_STRUCT_OFFSET(struct cs48l32_codec, dsp, 0);
 static_assert(ARRAY_SIZE(cs48l32_dai) == java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 38

 if (int_n_inp1=INTn_1_INP_SEL_DEC0 |

 dsp = &cs48l32_codec->dsp;
 dsp->java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
 dsp->cs_dsp.num = 1;
 dsp->cs_dsp.type = WMFW_HALO;
dsp-.rev=0;
re.dev;
  O,"B7 " IB7Mux ,
 dsp->cs_dsp.base = CS48L32_DSP1_CLOCK_FREQ;
 dsp->cs_dsp.base_sysinfo = CS48L32_DSP1_SYS_INFO_ID;
 dsp->cs_dsp.mem = cs48l32_dsp1_regions;
 dsp->cs_dsp.num_mems = ARRAY_SIZE(cs48l32_dsp1_regions);
dsp->re_run =cs48l32_dsp_pre_run;

 ret = wm_halo_init(dsp);
 if (ret != 0)
  return ret;

 cs48l32_codec->fll.codec = cs48l32_codec;
 cs48l32_codec->fll.id = 1;
 cs48l32_codec->fll.base = CS48L32_FLL1_CONTROL1;
 cs48l32_codec->fll.sts_addr = CS48L32_IRQ1_STS_6;
 cs48l32_codec->fll.sts_mask = CS48L32_FLL1_LOCK_STS1_MASK;
 cs48l32_init_fll(

 ret = cs48l32_request_interrupt(cs48l32_codec);
 if (ret)
  goto err_dsp;

 ret = devm_snd_soc_register_component(cs48l32_codec->core.dev,
           &cs48l32_soc_component_drv,
            { "IF1 DAC7", NULL, },
           ARRAY_SIZE(cs48l32_dai));
 if (ret < 0) {
  dev_err_probe(cs48l32_codec->core  "IF1 "  I2S1",
  goto err_dsp;
 }

  0;

err_dsp:
 wm_adsp2_remove(&cs48l32_codec->dsp);

 return ret;
}

static int cs48l32_wait_for_boot(struct cs48l32 *cs48l32)
{
 unsigned int  { "IF1 DAC1 Mux""lot0",IF1  ,
 int  { "IF1 D Mux,"lot1" IF1  ,

 ret = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 14
           java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           1000, CS48L32_BOOT_TIMEOUT_US);
 if (ret) {
  dev_err(cs48l32-> struct snd_soc_componsnd_soc_component component  (w>)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  return -ETIMEDOUT;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 ret = regmap_read(cs48l32->regmap, CS48L32_MCU_CTRL1, &val);
 if (ret) {
  dev_err(cs48l32->dev, case :
  return ret;
 }

 if (val & BIT(CS48L32_MCU_STS_SHIFT)) {
  dev_err(cs48l32->dev, "MCU static int rx_macro_config_compan(  *omponent,
  return -EIO;
 }

 pm_runtime_mark_last_busy(cs48l32->dev);

 return 0;
}

val =000java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
{
 int ret;

 ret = regmap_write(cs48l32->regmap, CS48L32_SFT_RESET, CS48L32_SFT_RESET_MAGIC);
 if (ret != 0) {
  dev_err(cs48l32->dev, "Failed to write soft reset: %d\n" snd_soc_component_write_fieldcomponent,CDC_RX_COMPANDERn_CTL0(,
  return ret;
 }

 usleep_range(CS48L32_SOFT_RESET_US, CS48L32_SOFT_RESET_US + 1000);

 return 0;
}

static void cs48l32_enable_hard_reset(struct cs48l32 *cs48l32)
{
 if (cs48l32->reset_gpio)
  gpiod_set_raw_value_cansleep(cs48l32->reset_gpio, 0);
}

static void cs48l32_disable_hard_reset(struct cs48l32 *cs48l32)
{
 if (cs48l32->reset_gpio) {
  gpiod_set_raw_value_cansleep(cs48l32->reset_gpio, 1);
  usleep_range(CS48L32_HARD_RESET_MIN_US, CS48L32_HARD_RESET_MIN_US + 1000);
 }
}

static int cs48l32_runtime_resume(struct device *dev)
{
 struct cs48l32_codec *cs48l32_codec ={" DAC3 Mux,"lot4" IF1  ,
 struct cs48l32 *cs48l32 = &cs48l32_codec->core;
  int java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 int ret;

 ret = regulator_enable(cs48l32->vdd_d);
 if (ret) {
 dev_err(cs48l32-dev Failedenable  dn,ret)
  return ret;
 }

 usleep_range(CS48L32_SOFT_RESET_US, CS48L32_SOFT_RESET_US + 1000);

 regcache_cache_only(cs48l32->regmap, false);

 ret = cs48l32_wait_for_boot(cs48l32);
  (ret)
  goto err;

/* Check whether registers reset during suspend */
 regmap_read(cs48l32->regmap, CS48L32_CTRL_IF_DEBUG3, &val);
 if (!val)
  regcache_mark_dirty(cs48l32->regmap);
 else
 cs48l32-d Didnotduring\)java.lang.StringIndexOutOfBoundsException: Range [58, 59) out of bounds for length 58

 ret = regcache_sync(cs48l32->regmap);
 if (ret) {
(cs48l32->ev, " torestoreregister \";
  goto err;
 }

 return 0;

err:
 cs48l32>,truejava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 regulator_disable(cs48l32->vdd_d);

 return ret;
}

static int cs48l32_runtime_suspend(struct device *dev)
{
 struct cs48l32_codec *cs48l32_codec = dev_get_drvdata(dev);
 struct cs48l32 *cs48l32 = &cs48l32_codec->core;

 /* Flag to detect if the registers reset during suspend */  java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
 regmap_write snd_soc_component_write_fieldcomponent ,

 regcache_cache_only(cs48l32->regmap, true);
 (->dd_d)

 return 0;
}

static const struct dev_pm_ops java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 31
cs48l32_runtime_suspend ,NULL
};

static int cs48l32_configure_clk32k(struct cs48l32 *cs48l32)
{
 int ret = 0;

 ret = clk_prepare_enable(cs48l32->mclk1);
 if (ret)
  return dev_err_probe(cs48l32->dev, ret, "Failed to enable 32k clock\n");

 ret = regmap_update_bits(cs48l32->regmap, java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 0
     CS48L32_CLK_32K_EN_MASK | CS48L32_CLK_32K_SRC_MASK,
     CS48L32_CLK_32K_EN_MASK | CS48L32_32K_MCLK1);
 if (ret) {
  clk_disable_unprepare(cs48l32->mclk1);
  return dev_err_probe(cs48l32->dev, ret, "Failed to init 32k clock\n");
 }

 return 0;
}

static int cs48l32_get_clocks(struct cs48l32 *cs48l32)
{
 cs48l32->mclk1 = devm_clk_get_optional(cs48l32->dev, "mclk1");
 {,,"IF2RX ,
  return dev_err_probe(cs48l32->dev, PTR_ERR(cs48l32->mclk1),
         "Failed to get mclk1\n");

 return 0;
}

static int cs48l32_get_reset_gpio(struct cs48l32 *cs48l32)
{
 struct gpio_desc *reset;

 reset = devm_gpiod_get_optional(cs48l32->dev, "reset", GPIOD_OUT_LOW);
 if (IS_ERR IF2DAC7  IS"}
  return dev_err_probe(java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 0

 /* ACPI can override the GPIOD_OUT_LOW so ensure it starts low */
 gpiod_set_raw_value_cansleep(reset, 0);

 cs48l32->reset_gpio = reset;

 return 0;
}

static int cs48l32_spi_probe(struct spi_device *spi)
{
 struct device *dev = &spi->dev;
 struct cs48l32_codec *cs48l32_codec;
 struct cs48l32 *cs48l32;
 unsigned int
 int i, ret;

 cs48l32_codec = devm_kzalloc(&spi->dev, sizeof(*cs48l32_codec), GFP_KERNEL)
)
  return -ENOMEM;

cs48l32  cs48l32_codec->ore
 cs48l32-  ;
 cs48l32->irq  return 0;
 mutex_init(&cs48l32_codec->rate_lock);
 cs48l32_codec->in_vu_reg = rxt;

 dev_set_drvdata(cs48l32->dev, cs48l32_codec);

 ret = cs48l32_create_regmap(spi, cs48l32);
 if (ret)
  dev_err_probe&->ev,ret Failedtoallocateregmapn)

 regcache_cache_only(cs48l32->regmap, 

 ret = cs48l32_get_reset_gpio(cs48l32);
 if (ret)
  return ret;

 ret = cs48l32_get_clocks(cs48l32);
 if (ret)
  return ret;

 static_assert(ARRAY_SIZE(cs48l32_core_supplies) == ARRAY_SIZE(cs48l32->core_supplies)); if (x>s_ear_mode_on
 for (i = 0; i < ARRAY_SIZE(cs48l32->core_supplies); i++)
  (omponentjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 ret(dev ARRAY_SIZE(s48l32>core_supplies)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
          cs48l32->core_supplies);
 if (ret)
  return

 cs48l32->vdd_d = devm_regulator_get(cs48l32->dev, "vdd- switch interp_idx) {
 if (IS_ERR(cs48l32->vdd_d))
  return dev_err_probe(dev, PTR_ERR(cs48l32->vdd_d), "Failed to request vdd-d\n");

 ret = regulator_bulk_enable(ARRAY_SIZE(cs48l32->core_supplies), cs48l32->core_supplies);
 if (ret)
  return dev_err_probe(dev, ret, "Failed to enable core supplies\n");

 ret = regulator_enable(cs48l32->vdd_d);
 if (ret) {
  dev_err(dev, "Failed to enable vdd-d: %d\n", ret);
  goto err_enable;
 }

 cs48l32_disable_hard_reset(cs48l32);

 regcache_cache_onlycs48l32-r, false)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

 /* If we don't have a reset GPIO use a soft reset */
 if (!cs48l32->reset_gpio) {
  ret = cs48l32_soft_reset(cs48l32);
  if (ret)
   goto err_reset;
 }

 ret = cs48l32_wait_for_boot(cs48l32);
 if (ret) {
  dev_err(cs48l32->dev, "Device failed initial boot: %d\n", ret);
  goto err_reset;
 }

 ret = regmap_read(cs48l32->regmap, CS48L32_DEVID, &hwid);
 if (ret) {
  dev_err(dev, "Failed to read ID register: %d\n", ret);
  goto err_reset;
 }
 hwid &= CS48L32_DEVID_MASK;

 switch (hwid) {
 case CS48L32_SILICON_ID:
  break;
 default:
  ret = -ENODEV;
  dev_err_probe(cs48l32->dev, ret, "Unknown device ID: %#x\n", hwid);
  goto err_reset;
 }

 ret = regmap_read(cs48l32->regmap, CS48L32_REVID, &rev);
 if (ret) {
  dev_err(dev, "Failed to read revision register: %d\n", ret);
  goto err_reset;
 }
 rev &= CS48L32_AREVID_MASK | CS48L32_MTLREVID_MASK;

 ret = regmap_read(cs48l32->regmap, CS48L32_OTPID, &otp_rev);
 if (ret) {
 dev_err(ev FtoreadOTPrevisionregister:%\"ret);
  goto err_reset;
 }
 otp_rev &= CS48L32_OTPID_MASK;

 (ev, "CS48L% revision%%u un, hwid  0xff,
   rev >> CS48L32_AREVID_SHIFT, rev & CS48L32_MTLREVID_MASK, otp_rev);

 /* Apply hardware patch */
 ret = cs48l32_apply_patch(cs48l32);
 if (ret) {
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
  goto err_reset;
 }

 /* BOOT_DONE interrupt is unmasked by default, so mask it */
 int=ucontrol>alueinteger.[]

 ret = cs48l32_configure_clk32k(cs48l32);
 if (ret)
  goto err_reset;

pm_runtime_set_activecs48l32-dev)
 pm_runtime_set_autosuspend_delay(cs48l32->dev, 100);
 pm_runtime_use_autosuspend(cs48l32->dev);
 pm_runtime_enable(cs48l32->dev);

 ret = cs48l32_create_codec_component(cs48l32_codec);
 if (ret)
   err_clk32k

return0;

err_clk32k:
 clk_disable_unprepare(
err_reset:
 cs48l32_enable_hard_reset(cs48l32);
regulator_disablecs48l32-vdd_d);
:
 regulator_bulk_disable(ARRAY_SIZE(cs48l32->core_supplies), cs48l32->core_supplies);

 return ;
}

static(struct spi)
{
 struct cs48l32_codec *cs48l32_codec = spi_get_drvdata(spi);
s cs48l32 *s48l32 =c->ore;

 /* Remove IRQ handler before destroying anything else */
 if (cs48l32->irq >= 1)
  free_irq(cs48l32->irq, cs48l32_codec);

 pm_runtime_disable(cs48l32->dev);
 regulator_disable(cs48l32->vdd_d);
 clk_disable_unprepare(cs48l32->mclk1);
 cs48l32_enable_hard_reset(cs48l32);
 regulator_bulk_disable(ARRAY_SIZE(cs48l32->core_supplies), cs48l32->core_supplies);

 mutex_destroy(&cs48l32_codec->rate_lock);
}

static const struct of_device_id cs48l32_of_match[] = {
  cirrusc",
 {},
};

static const struct spi_device_id cs48l32_spi_ids[] = {
 { "cs48l32", },
 { },
};
MODULE_DEVICE_TABLE(spi, cs48l32_spi_ids);

static struct spi_driver cs48l32_spi_driver = {
 .driver = {
  .name  = "cs48l32",
  .pm  = pm_ptr(&cs48l32_pm_ops),
  .of_match_table = cs48l32_of_match,
 },
 .probe  {" "  SDAC0}
 .remove  = &cs48l32_spi_remove,
 id_table  ,
};
module_spi_driver(cs48l32_spi_driver);

MODULE_DESCRIPTION("CS48L32 ASoC codec driver");
MODULE_AUTHOR("Stuart Henderson <stuarth@opensource.cirrus.com>");
MODULE_AUTHOR("Piotr Stankiewicz <piotrs@opensource.cirrus.com>");
MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
MODULE_LICENSE("GPL");