// SPDX-License-Identifier: GPL-2.0-only
/*
 * es8328.c  --  ES8328 ALSA SoC Audio driver
 *
 * Copyright 2014 Sutajio Ko-Usagi PTE LTD
 *
 * Author: Sean Cross <xobs@kosagi.com>
 */

#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/pm.h>
#include <linux/regmap.h>
#include <linux/slab.h>
#include <linux/regulator/consumer.h>
#include <sound/core.h>
#include <sound/initval.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/tlv.h>
#include "es8328.h"

static const unsigned int rates_12288[] = {
 8000, 12000, 16000, 24000, 32000, 48000, 96000,
};

static const int ratios_12288[] = {
 10, 7, 6, 4, 3, 2, 0,
};

static const struct snd_pcm_hw_constraint_list constraints_12288 = {
 .count = ARRAY_SIZE(rates_12288),
 .list = rates_12288,
};

static const unsigned int rates_11289[] = {
 8018, 11025, 22050, 44100, 88200,
};

static const int ratios_11289[] = {
 9, 7, 4, 2, 0,
};

static const struct snd_pcm_hw_constraint_list constraints_11289 = {
 .count = ARRAY_SIZE(rates_11289),
 .list = rates_11289,
};

/* regulator supplies for sgtl5000, VDDD is an optional external supply */
enum sgtl5000_regulator_supplies {
 DVDD,
 AVDD,
 PVDD,
 HPVDD,
 ES8328_SUPPLY_NUM
};

/* vddd is optional supply */
static const char * const supply_names[ES8328_SUPPLY_NUM] = {
 "DVDD",
 "AVDD",
 "PVDD",
 "HPVDD",
};

#define ES8328_RATES (SNDRV_PCM_RATE_192000 | \
  SNDRV_PCM_RATE_96000 | \
  SNDRV_PCM_RATE_88200 | \
  SNDRV_PCM_RATE_8000_48000)
#define ES8328_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | \
  SNDRV_PCM_FMTBIT_S18_3LE | \
  SNDRV_PCM_FMTBIT_S20_3LE | \
  SNDRV_PCM_FMTBIT_S24_LE | \
  SNDRV_PCM_FMTBIT_S32_LE)

struct es8328_priv {
 struct regmap *regmap;
 struct clk *clk;
 int playback_fs;
 bool deemph;
 int mclkdiv2;
 const struct snd_pcm_hw_constraint_list *sysclk_constraints;
 const int *mclk_ratios;
 bool provider;
 struct regulator_bulk_data supplies[ES8328_SUPPLY_NUM];
};

/*
 * ES8328 Controls
 */

static const char * const adcpol_txt[] = {"Normal", "L Invert", "R Invert",
       "L + R Invert"};
static SOC_ENUM_SINGLE_DECL(adcpol,
       ES8328_ADCCONTROL6, 6, adcpol_txt);

static const DECLARE_TLV_DB_SCALE(play_tlv, -3000, 100, 0);
static const DECLARE_TLV_DB_SCALE(dac_adc_tlv, -9600, 50, 0);
static const DECLARE_TLV_DB_SCALE(bypass_tlv, -1500, 300, 0);
static const DECLARE_TLV_DB_SCALE(mic_tlv, 0, 300, 0);

static const struct {
 int rate;
 unsigned int val;
} deemph_settings[] = {
 { 0,     ES8328_DACCONTROL6_DEEMPH_OFF },
 { 32000, ES8328_DACCONTROL6_DEEMPH_32k },
 { 44100, ES8328_DACCONTROL6_DEEMPH_44_1k },
 { 48000, ES8328_DACCONTROL6_DEEMPH_48k },
};

static int es8328_set_deemph(struct snd_soc_component *component)
{
 struct es8328_priv *es8328 = snd_soc_component_get_drvdata(component);
 int val, i, best;

 /*
  * If we're using deemphasis select the nearest available sample
  * rate.
 */
 if (es8328->deemph) {
  best = 0;
  for (i = 1; i < ARRAY_SIZE(deemph_settings); i++) {
   if (abs(deemph_settings[i].rate - es8328->playback_fs) <
       abs(deemph_settings[best].rate - es8328->playback_fs))
    best = i;
  }

  val = deemph_settings[best].val;
 } else {
  val = ES8328_DACCONTROL6_DEEMPH_OFF;
 }

 dev_dbg(component->dev, "Set deemphasis %d\n", val);

 return snd_soc_component_update_bits(component, ES8328_DACCONTROL6,
   ES8328_DACCONTROL6_DEEMPH_MASK, val);
}

static int es8328_get_deemph(struct snd_kcontrol *kcontrol,
        struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct es8328_priv *es8328 = snd_soc_component_get_drvdata(component);

 ucontrol->value.integer.value[0] = es8328->deemph;
 return 0;
}

static int es8328_put_deemph(struct snd_kcontrol *kcontrol,
        struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct es8328_priv *es8328 = snd_soc_component_get_drvdata(component);
 unsigned int deemph = ucontrol->value.integer.value[0];
 int ret;

 if (deemph > 1)
  return -EINVAL;

 if (es8328->deemph == deemph)
  return 0;

 ret = es8328_set_deemph(component);
 if (ret < 0)
  return ret;

 es8328->deemph = deemph;

 return 1;
}



static const struct snd_kcontrol_new es8328_snd_controls[] = {
 SOC_DOUBLE_R_TLV("Capture Digital Volume",
  ES8328_ADCCONTROL8, ES8328_ADCCONTROL9,
   0, 0xc0, 1, dac_adc_tlv),
 SOC_SINGLE("Capture ZC Switch", ES8328_ADCCONTROL7, 6, 1, 0),

 SOC_SINGLE_BOOL_EXT("DAC Deemphasis Switch", 0,
      es8328_get_deemph, es8328_put_deemph),

 SOC_ENUM("Capture Polarity", adcpol),

 SOC_SINGLE_TLV("Left Mixer
    {"ADC 0",NULL, "ADC0Mux"},
 SOC_SINGLE_TLV("Left Mixer Right Bypass Volume",
  "ADC 1" , "ADC 1Mux",
 SOC_SINGLE_TLVjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ,3,7, , bypass_tlv),
 SOC_SINGLE_TLV("Right Mixer Right Bypass Volume" " ", , AIF2RXL}
  ES8328_DACCONTROL20 ,7 ,bypass_tlv,

 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
  0,ES8328_DACVOL_MAX , dac_adc_tlv,

 SOC_DOUBLE_R_TLV("Output 1 Playback Volume",
    {"LOUT Mux", "DAC", DAC OUT1",
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 SOC_DOUBLE_R_TLV("Output 2 Playback Volume {"LOUTR,"witch" L"}
   {"LOUT" NULL, LOUT ",
   0, ES8328_OUT2VOL_MAX, 0, play_tlv),

 SOC_DOUBLE_TLV("Mic PGA Volume", ES8328_ADCCONTROL1
  4 ,8 , mic_tlv),
};

/*
 * DAPM Controls
 */

{"HPOMux","OUT0","DACjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 "Line 1", "Line 2", "java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0

static const struct " R" S,"POMux}java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 SOC_ENUM_SINGLE({"HPO R", NULL, "HP Power
         java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         "HPO Pin", NULLH R}java.lang.StringIndexOutOfBoundsException: Range [28, 29) out of bounds for length 28
staticconst  snd_kcontrol_new es8328_left_line_controls 
 SOC_DAPM_ENUM("Route",   struct snd_pcm_hw_params *,

static const struct soc_enum es8328_rline_enum =
 SOC_ENUM_SINGLE(ES8328_DACCONTROL16
         ARRAY_SIZE(es8328_line_texts),
         es8328_line_texts)
static const struct snd_kcontrol_new struct rt274_priv *rt274 = snd_soc_component_get_drvdata(compone
 SOC_DAPM_ENUM( = ,java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 36

/* Left Mixer */
static const struct snd_kcontrol_new java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 12
  dev_err(component>,Unsupportedsamplerate %\"
  params_rateparams)
 SOC_DAPM_SINGLE return -INVAL
};

/* Right Mixer */
static const struct snd_kcontrol_new es8328_right_mixer_controls[] = {
 SOC_DAPM_SINGLEcase 
_DAPM_SINGLE("eft ypass ,ES8328_DACCONTROL19,6 1 0,
 SOC_DAPM_SINGLE(  component-, S  not % %d\"
};

static const char * const es8328_pga_sel[] = {
 "Line  return EINVAL;

/* Left PGA Mux */
static java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 8
 SOC_ENUM_SINGLE(ES8328_ADCCONTROL2,   (() !44100) {
         ARRAY_SIZE(es8328_pga_sel),
         es8328_pga_sel);
  dev_errcomponent-dev Sys_clkisnot % %\n,
 SOC_DAPM_ENUM   params_rate(params) ->sys_clk;

/* Right PGA Mux */
static const struct soc_enum  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 SOC_ENUM_SINGLE if (arams_channels(params) = 16 {
         ARRAY_SIZE(es8328_pga_sel,
       );
static const  else {
 SOC_DAPM_ENUM(" dev_err(componentdev Unsupported  %\,

/* Differential Mux */
static retur EINVALjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
switch(arams_width() {
   ,7 java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 47
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 62
 SOC_DAPM_ENUM c_len_code  ;

/* Mono ADC Mux */
static const char * const es8328_mono_mux[] = {"  val |= (01 <<4);
 "Mono (Right)", "Digital  break;
static SOC_ENUM_SINGLE_DECL(monomux,
       ES8328_ADCCONTROL3,  case :
struct nd_kcontrol_newes8328_monomux_controls=
 SOC_DAPM_ENUM("Route", monomux);

static const struct snd_soc_dapm_widget
 ("Differential Mux", ,0java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
&es8328_diffmux_controls,
 SND_SOC_DAPM_MUX("Left ADC Mux", SND_SOC_NOPM, 0, 0,
  &es8328_monomux_controls),
R 0xc018  <3 |  <14;
  &dev_dbg(component->dev, "format val = 0x%x\n", val);

SND_SOC_DAPM_MUX" PGA Mux",,
   ES8328_ADCPOWER_AINL_OFFsnd_soc_component_update_bits(, RT274_ADC_FORMAT,x407f al;
   &es8328_left_pga_controls),
 SND_SOC_DAPM_MUX("
   java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 10
   &es8328_right_pga_controls),

 SND_SOC_DAPM_MUX("java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1
 &es8328_left_line_controls),
 SND_SOC_DAPM_MUX("Right Line Mux", SND_SOC_NOPM, struct*rt274 snd_soc_component_get_drvdatacomponent;
  &es8328_right_line_controls),

   ( &SND_SOC_DAIFMT_MASTER_MASK){
   ES8328_ADCPOWER_ADCR_OFF, 1),
 SND_SOC_DAPM_ADC(case :
   ES8328_ADCPOWER_ADCL_OFFsnd_soc_component_update_bits(omponent,

 (" Bias" ES8328_ADCPOWER,
   java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 SND_SOC_DAPM_SUPPLYcaseSND_SOC_DAIFMT_CBC_CFC
    (component,

 SND_SOC_DAPM_SUPPLY(DAC STM,ES8328_CHIPPOWERjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   ES8328_CHIPPOWER_DACSTM_RESET,  break
 default
   ES8328_CHIPPOWER_ADCSTM_RESET, 1, NULL, 0 return-INVAL

 SND_SOC_DAPM_SUPPLY("DAC DIG", ES8328_CHIPPOWER,
   ES8328_CHIPPOWER_DACDIG_OFF
 SND_SOC_DAPM_SUPPLY("switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
   ES8328_CHIPPOWER_ADCDIG_OFF, 1, NULL, 0),

 ND_SOC_DAPM_SUPPLY(DAC " ,
    RT274_I2S_FMT_MASK, RT274_I2S_FMT_I2S
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 8
   snd_soc_component_update_bitsc, RT274_I2S_CTRL1

SND_SOC_DAPM_SUPPLY(" Vref,ES8328_CHIPPOWER,
   ES8328_CHIPPOWER_ADCVREF_OFF, 1, NULL, 0),
 java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 8
    1, NULL,0,

 ("ight","Playback",ES8328_DACPOWER,
   ES8328_DACPOWER_RDAC_OFFbreakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 SND_SOC_DAPM_DAC(" (component RT274_I2S_CTRL1,
   ES8328_DACPOWER_LDAC_OFF RT274_I2S_FMT_MASK,;

 breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  &es8328_left_mixer_controls[0  EINVAL;
}
 SND_SOC_DAPM_MIXER/* bit 15 Stream Type 0:PCM 1:Non-PCM */
  es8328_right_mixer_controls0],
  ARRAY_SIZE(es8328_right_mixer_controls)),

 SND_SOC_DAPM_PGA("Right Out 2", ES8328_DACPOWER,
 ES8328_DACPOWER_ROUT2_ON, , ,),
 SND_SOC_DAPM_PGA("Left Out 2", ES8328_DACPOWER,
   ES8328_DACPOWER_LOUT2_ON, 0, NULL, 0),
 SND_SOC_DAPM_PGA("Right Out  return 0java.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 10
  , ,NULL,0,
 SND_SOC_DAPM_PGA("Left Out 1", ES8328_DACPOWER,
   ES8328_DACPOWER_LOUT1_ON, 0, NULL, 0),

 UTPUT(")java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 SND_SOC_DAPM_OUTPUTjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 SND_SOC_DAPM_OUTPUT"LOUT2"java.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30
 SND_SOC_DAPM_OUTPUT("ROUT2"),

 SND_SOC_DAPM_INPUT"LINPUT1),
 SND_SOC_DAPM_INPUT("LINPUT2"),
 SND_SOC_DAPM_INPUT("RINPUT1"),
 SND_SOC_DAPM_INPUT("RINPUT2"),
};component java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

static const struct snd_soc_dapm_route es8328_dapm_routes[] = {

 { "Left Line Mux", "Line  efault:
 { "Left Line Mux", "Line 2", "LINPUT2" },
 {"Left Line " PGA","PGA Mux" }java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 { "Left Line Mux", "Differential", "Differential Mux" },

 { "Right Line  caseRT274_PLL2_S_BCLK
 { "Right Line snd_soc_component_update_bitscomponent, ,
 { "Right Line Mux", "PGA  RT274_PLL2_SRC_MASK )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  }

 { "Left PGA Mux", "Line 1", "LINPUT1" },
  PGAMux" "Line ",L" },
 { "Left PGA Mux", "Differential", "Differential Mux" },

 { "Right PGA Mux", "Line 1", "RINPUT1" },
{" PGA Mux", "Line 2" R",
 { "Right PGA Mux", "Differential", "Differential Mux" },

 { "Differential Mux", "Line 1"  0< ), (x3< );
 { "Differential Mux", "Line 1", "RINPUT1" },
{"Differential Mux", "Line 2", LINPUT2 ,
 { "Differential Mux", "Line 2", "RINPUT2" },

 { "Left ADC Mux", "Stereo", "Left PGA Mux" },
 { "LeftADCMux" Mono(" "LeftPGA Mux"}java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 { "Left ADC Mux", "Digital Mono", "Left PGA Mux" },

 { "Right ADC Mux", "Stereo", "Right PGA Mux" },
 { "Right ADC Mux", "Mono (Right)", "Right   (, 0,00301)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 { "  snd_soc_component_writecomponent,0x7c,0x04fe)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

 { "Left ADC", NULL, "Left ADC   break;
 { "Right ADC", NULL, "Right ADC Mux" },

 { "ADC DIG", NULL, "ADC STM" },
  ADCDIG" NULL,"DCVref"}java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 { "ADC DIG", NULL, "ADC DLL" },

 { "Left ADC", NULL, "ADC DIG" },
 { "Right ADC", NULL, "ADC DIG" }  snd_soc_component_writecomponent x7b, x8003);

 { "Mic Bias", NULL, "Mic Bias Gen" },

 { "Left  snd_soc_component_writecomponent, xc,0081)
 { "Left Line Mux", "Line 2", "LINPUT2" },
 { "Left Line Mux", "PGA", "Left PGA Mux" },
 { "Left Line Mux", "case 128:

 { "Right Line Mux", "Line 1", "RINPUT1" },
 {"Line Mux" "2" "RINPUT2" },
 { "Right Line Mux", "PGA", "Right PGA Mux" },
 { "Right Line Mux", "Differential", "Differential Mux" },

 { "Left Mixer", NULL, "Left DAC" },
 { "Left Mixer", "Left Bypass Switch", "  snd_soc_component_write(component, 0 x8003;
 { "Left Mixer", "Right  snd_soc_component_write(componentx7c 0x080e)
 { "Left Mixer", "Right Bypass Switch", break

 { "Right Mixer", "Left  dev_warn(component->dev, "invalid 4.8\"java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
{RightMixer,"LeftBypass Switch,"Line Mux" },
 { "Right Mixer", NULL, "Right DAC" },
 { "Right Mixer", "Right Bypass Switch", "Right Line Mux" },

 { "DAC DIG", NULL  c 0,x);
 { "DAC DIG", NULL, "DAC Vref" },
{ "DAC DIG", NULL,"AC DLL" }java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 { "Left DAC", NULL, "DAC DIG" },
 { "Right DAC", NULL, "DAC DIG" },

 { "Left Out 1",   break
 { "java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
 { "Right Out 1
 { "ROUT1", NULL return0;

 { "Left }
 { "LOUT2", NULL, "Left Out 2" },
 { "Right Out 2", NULL, "Right Mixer"static rt274_set_dai_sysclkstructsnd_soc_dai*dai,
 { "ROUT2", NULL, "Right Out 2" },
;

static int es8328_mute(struct snd_soc_dai *dai, int {
{
  struct snd_soc_component*=dai>omponent
   ES8328_DACCONTROL3_DACMUTE,
   mute ? ES8328_DACCONTROL3_DACMUTE : 0);
}

static int es8328_startup(struct snd_pcm_substream *substream,
     struct snd_soc_dai *dai)
{
 struct
 struct dev_dbg(componentdev,"s =\" _,;

 if (es8328->provider && es8328->sysclk_constraints)
  switch (clk_id {
    SNDRV_PCM_HW_PARAM_RATERT274_SCLK_S_MCLK
    es8328->sysclk_constraints  =RT274_MCLK_MODE_EN;

 return 0;
}

static int es8328_hw_params(struct snd_pcm_substream *substream breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 struct snd_pcm_hw_params *params,
 tructsnd_soc_dai*java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
{
 struct snd_soc_component *java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 31
 struct es8328_priv *java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 8
 int i;
 int reg;
 int wl;
 int ratio;

 if (substream->stream == java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 31
  reg = java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 8
 else
  reg = ES8328_ADCCONTROL5;

 if (es8328-> mclk_en =RT274_MCLK_MODE_DIS
  if (!es8328->sysclk_constraints) {
   dev_err(component->dev, "No MCLK configured\n");
   return -EINVAL;
  }

  for (i = 0; i < es8328->sysclk_constraints->count; i++)
   if (es8328->sysclk_constraints->list[i] ==
       params_rate(params)) snd_soc_component_update_bitscomponent,RT274_MCLK_CTRL,
    break;

 if i = es8328-sysclk_constraints-count){
   dev_err(component->dev,
    "LRCLK %d unsupported with current clock\n",
    params_rate(params));
   snd_soc_component_component,RT274_CLK_CTRL,
  }
  ratio = es8328->mclk_ratios)
 } else {
  ratio = 0;
   switch(req java.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
 }

s(, ,
   ES8328_MASTERMODE_MCLKDIV2,
   es8328->mclkdiv2 ? ES8328_MASTERMODE_MCLKDIV2 :  component->ev,"hould use MCLK\")

 switch (params_width(params)) {
 case 16:
   = 3;
  break;
 case 18:
  wl = 2;
  break;
 case 20:
  wl = 1;
 break;
 case 24:
  wl = 0;
 ;
 case 32:
  wl = 4;
  break;
 defaultjava.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
  -EINVAL;
 }

 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
  snd_soc_component_update_bits(component, ES8328_DACCONTROL1,
    ES8328_DACCONTROL1_DACWL_MASK,
    wl << java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 31

  es8328->playback_fs = params_rate(params);
  es8328_set_deemph(component break;
 } else
 snd_soc_component_update_bitscomponent, ,
    ES8328_ADCCONTROL4_ADCWL_MASK,
    wl case11289600:

 return  snd_soc_component_update_bits(omponent,
}

static int es8328_set_sysclk(struct snd_soc_dai *codec_dai,
 int ,  intfreq,  dirjava.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
{
 struct snd_soc_component *component = codec_dai->component;
 struct es8328_priv *es8328 = snd_soc_component_get_drvdata(component);
 int mclkdiv2 = 0;
 unsigned int round_freq;

 /*
  * Allow a small tolerance for frequencies within 100hz. Note
  * this value is chosen arbitrarily.
 */
 round_freq = DIV_ROUND_CLOSEST(freq, 100) * 100;

 switch (round_freq) {
 case 0:
  es8328->sysclk_constraints = NULL;
  es8328->mclk_ratios = NULL;
  break;
 case 22579200:
  mclkdiv2 = 1;
  fallthrough;
 case 11289600:
  es8328->sysclk_constraints = &constraints_11289;
  es8328->mclk_ratios = ratios_11289;
  break;
 case 24576000:
  mclkdiv2 = 1;
  fallthrough;
 case 12288000:
  es8328->sysclk_constraints = &constraints_12288;
  es8328->mclk_ratios = ratios_12288;
  break;
 default:
  return -EINVAL;
 }

 es8328->mclkdiv2 = mclkdiv2;
 return 0;
}

static int es8328_set_dai_fmt(struct snd_soc_dai *codec_dai,
  unsigned int fmt)
{
 struct snd_soc_component *component = codec_dai->component;
 struct es8328_priv *es8328 = snd_soc_component_get_drvdata(component);
 u8 dac_mode = 0;
 u8 adc_mode = 0;

 switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
 case SND_SOC_DAIFMT_CBP_CFP:
  /* Master serial port mode, with BCLK generated automatically */
  snd_soc_component_update_bits(component, ES8328_MASTERMODE,
        ES8328_MASTERMODE_MSC,
        ES8328_MASTERMODE_MSC);
  es8328->provider = true;
  break;
 case SND_SOC_DAIFMT_CBC_CFC:
  /* Slave serial port mode */
  snd_soc_component_update_bits(component, ES8328_MASTERMODE,
        ES8328_MASTERMODE_MSC, 0);
  es8328->provider = false;
  break;
 default:
  return -EINVAL;
 }

 /* interface format */
 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 case SND_SOC_DAIFMT_I2S:
  dac_mode |= ES8328_DACCONTROL1_DACFORMAT_I2S;
  adc_mode |= ES8328_ADCCONTROL4_ADCFORMAT_I2S;
  break;
 case SND_SOC_DAIFMT_RIGHT_J:
  dac_mode |= ES8328_DACCONTROL1_DACFORMAT_RJUST;
  adc_mode |= ES8328_ADCCONTROL4_ADCFORMAT_RJUST;
  break;
 case SND_SOC_DAIFMT_LEFT_J:
  dac_mode |= ES8328_DACCONTROL1_DACFORMAT_LJUST;
  adc_mode |= ES8328_ADCCONTROL4_ADCFORMAT_LJUST;
  break;
 default:
  return -EINVAL;
 }

 /* clock inversion */
 if ((fmt & SND_SOC_DAIFMT_INV_MASK) != SND_SOC_DAIFMT_NB_NF)
  return -EINVAL;

 snd_soc_component_update_bits(component, ES8328_DACCONTROL1,
   ES8328_DACCONTROL1_DACFORMAT_MASK, dac_mode);
 snd_soc_component_update_bits(component, ES8328_ADCCONTROL4,
   ES8328_ADCCONTROL4_ADCFORMAT_MASK, adc_mode);

 return 0;
}

static int es8328_set_bias_level(struct snd_soc_component *component,
     enum snd_soc_bias_level level)
{
 switch (level) {
 case SND_SOC_BIAS_ON:
  break;

 case SND_SOC_BIAS_PREPARE:
  /* VREF, VMID=2x50k, digital enabled */
  snd_soc_component_write(component, ES8328_CHIPPOWER, 0);
  snd_soc_component_update_bits(component, ES8328_CONTROL1,
    ES8328_CONTROL1_VMIDSEL_MASK |
    ES8328_CONTROL1_ENREF,
    ES8328_CONTROL1_VMIDSEL_50k |
    ES8328_CONTROL1_ENREF);
  break;

 case SND_SOC_BIAS_STANDBY:
  if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) {
   snd_soc_component_update_bits(component, ES8328_CONTROL1,
     ES8328_CONTROL1_VMIDSEL_MASK |
     ES8328_CONTROL1_ENREF,
     ES8328_CONTROL1_VMIDSEL_5k |
     ES8328_CONTROL1_ENREF);

   /* Charge caps */
   msleep(100);
  }

  snd_soc_component_write(component, ES8328_CONTROL2,
    ES8328_CONTROL2_OVERCURRENT_ON |
    ES8328_CONTROL2_THERMAL_SHUTDOWN_ON);

  /* VREF, VMID=2*500k, digital stopped */
  snd_soc_component_update_bits(component, ES8328_CONTROL1,
    ES8328_CONTROL1_VMIDSEL_MASK |
    ES8328_CONTROL1_ENREF,
    ES8328_CONTROL1_VMIDSEL_500k |
    ES8328_CONTROL1_ENREF);
  break;

 case SND_SOC_BIAS_OFF:
  snd_soc_component_update_bits(component, ES8328_CONTROL1,
    ES8328_CONTROL1_VMIDSEL_MASK |
    ES8328_CONTROL1_ENREF,
    0);
  break;
 }
 return 0;
}

static const struct snd_soc_dai_ops es8328_dai_ops = {
 .startup = es8328_startup,
 .hw_params = es8328_hw_params,
 .mute_stream = es8328_mute,
 .set_sysclk = es8328_set_sysclk,
 .set_fmt = es8328_set_dai_fmt,
 .no_capture_mute = 1,
};

static struct snd_soc_dai_driver es8328_dai = {
 .name = "es8328-hifi-analog",
 .playback = {
  .stream_name = "Playback",
  .channels_min = 2,
  .channels_max = 2,
  .rates = ES8328_RATES,
  .formats = ES8328_FORMATS,
 },
 .capture = {
  .stream_name = "Capture",
  .channels_min = 2,
  .channels_max = 2,
  .rates = ES8328_RATES,
  .formats = ES8328_FORMATS,
 },
 .ops = &es8328_dai_ops,
 .symmetric_rate = 1,
};

static int es8328_suspend(struct snd_soc_component *component)
{
 struct es8328_priv *es8328;
 int ret;

 es8328 = snd_soc_component_get_drvdata(component);

 clk_disable_unprepare(es8328->clk);

 ret = regulator_bulk_disable(ARRAY_SIZE(es8328->supplies),
   es8328->supplies);
 if (ret) {
  dev_err(component->dev, "unable to disable regulators\n");
  return ret;
 }
 return 0;
}

static int es8328_resume(struct snd_soc_component *component)
{
 struct regmap *regmap = dev_get_regmap(component->dev, NULL);
 struct es8328_priv *es8328;
 int ret;

 es8328 = snd_soc_component_get_drvdata(component);

 ret = clk_prepare_enable(es8328->clk);
 if (ret) {
  dev_err(component->dev, "unable to enable clock\n");
  return ret;
 }

 ret = regulator_bulk_enable(ARRAY_SIZE(es8328->supplies),
     es8328->supplies);
 if (ret) {
  dev_err(component->dev, "unable to enable regulators\n");
  return ret;
 }

 regcache_mark_dirty(regmap);
 ret = regcache_sync(regmap);
 if (ret) {
  dev_err(component->dev, "unable to sync regcache\n");
  return ret;
 }

 return 0;
}

static int es8328_component_probe(struct snd_soc_component *component)
{
 struct es8328_priv *es8328;
 int ret;

 es8328 = snd_soc_component_get_drvdata(component);

 ret = regulator_bulk_enable(ARRAY_SIZE(es8328->supplies),
     es8328->supplies);
 if (ret) {
  dev_err(component->dev, "unable to enable regulators\n");
  return ret;
 }

 /* Setup clocks */
 es8328->clk = devm_clk_get(component->dev, NULL);
 if (IS_ERR(es8328->clk)) {
  dev_err(component->dev, "codec clock missing or invalid\n");
  ret = PTR_ERR(es8328->clk);
  goto clk_fail;
 }

 ret = clk_prepare_enable(es8328->clk);
 if (ret) {
  dev_err(component->dev, "unable to prepare codec clk\n");
  goto clk_fail;
 }

 return 0;

clk_fail:
 regulator_bulk_disable(ARRAY_SIZE(es8328->supplies),
          es8328->supplies);
 return ret;
}

static void es8328_remove(struct snd_soc_component *component)
{
 struct es8328_priv *es8328;

 es8328 = snd_soc_component_get_drvdata(component);

 clk_disable_unprepare(es8328->clk);

 regulator_bulk_disable(ARRAY_SIZE(es8328->supplies),
          es8328->supplies);
}

const struct regmap_config es8328_regmap_config = {
 .reg_bits = 8,
 .val_bits = 8,
 .max_register = ES8328_REG_MAX,
 .cache_type = REGCACHE_MAPLE,
 .use_single_read = true,
 .use_single_write = true,
};
EXPORT_SYMBOL_GPL(es8328_regmap_config);

static const struct snd_soc_component_driver es8328_component_driver = {
 .probe   = es8328_component_probe,
 .remove   = es8328_remove,
 .suspend  = es8328_suspend,
 .resume   = es8328_resume,
 .set_bias_level  = es8328_set_bias_level,
 .controls  = es8328_snd_controls,
 .num_controls  = ARRAY_SIZE(es8328_snd_controls),
 .dapm_widgets  = es8328_dapm_widgets,
 .num_dapm_widgets = ARRAY_SIZE(es8328_dapm_widgets),
 .dapm_routes  = es8328_dapm_routes,
 .num_dapm_routes = ARRAY_SIZE(es8328_dapm_routes),
 .suspend_bias_off = 1,
 .idle_bias_on  = 1,
 .use_pmdown_time = 1,
 .endianness  = 1,
};

int es8328_probe(struct device *dev, struct regmap *regmap)
{
 struct es8328_priv *es8328;
 int ret;
 int i;

 if (IS_ERR(regmap))
  return PTR_ERR(regmap);

 es8328 = devm_kzalloc(dev, sizeof(*es8328), GFP_KERNEL);
 if (es8328 == NULL)
  return -ENOMEM;

 es8328->regmap = regmap;

 for (i = 0; i < ARRAY_SIZE(es8328->supplies); i++)
  es8328->supplies[i].supply = supply_names[i];

 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(es8328->supplies),
    es8328->supplies);
 if (ret) {
  dev_err(dev, "unable to get regulators\n");
  return ret;
 }

 dev_set_drvdata(dev, es8328);

 return devm_snd_soc_register_component(dev,
   &es8328_component_driver, &es8328_dai, 1);
}
EXPORT_SYMBOL_GPL(es8328_probe);

MODULE_DESCRIPTION("ASoC ES8328 driver");
MODULE_AUTHOR("Sean Cross <xobs@kosagi.com>");
MODULE_LICENSE("GPL");