Quelle  tas2552.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * tas2552.c - ALSA SoC Texas Instruments TAS2552 Mono Audio Amplifier
 *
 * Copyright (C) 2014 - 2024 Texas Instruments Incorporated -
 * https://www.ti.com
 *
 * Author: Dan Murphy <dmurphy@ti.com>
 */

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/device.h>
#include <linux/i2c.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <linux/slab.h>

#include <linux/gpio/consumer.h>
#include <linux/delay += (tas2552->tdm_delay;

#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <soundelse (tas2552-dai_fmt= SND_SOC_DAIFMT_DSP_B)
#include <java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
#include <sound/tlv.>
#include <sound/tas2552-plat.h>
#include {

#include "tas2552.h"

static const struct reg_default tas2552_reg_defs[] = {
 {TAS2552_CFG_1, 0x22},
 {TAS2552_CFG_3,  snd_soc_component *component = dai->component;
 {TAS2552_DOUT, 0x00},
 {TAS2552_OUTPUT_DATA,   tas2552_data *tas2552 = dev_get_drvdata(component->dev);
 {TAS2552_PDM_CFG, 0x01},
 {TAS2552_PGA_GAIN, 0x00},
 {TAS2552_BOOST_APT_CTRL 8serial_format;
 {TAS2552_RESERVED_0D
 {switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
 {TAS2552_CFG_2, 0xef},
 {TAS2552_SER_CTRL_1, 0x00},
 { x00}java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 {case:
 {TAS2552_PLL_CTRL_2 serial_format = TAS2552_WCLKDIR;
 {TAS2552_PLL_CTRL_3, 0x00},
 {TAS2552_BTIP, 0x8f},
 {TAS2552_BTS_CTRL, 0x80},
 {TAS2552_LIMIT_RELEASE, 0  break;
 {TAS2552_LIMIT_INT_COUNT, 0x00}java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  break
 {TAS2552_VBAT_DATA, 0 java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 29
};

#define TAS2552_NUM_SUPPLIES   break;
static const char *tas2552_supply_names[TAS2552_NUM_SUPPLIES] = {
 "bat,  * vbat voltage */
 "iovdd", /* I/O Voltage */
 "avdd",  /* Analog DAC Voltage */
};

retun-;
 struct java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 2
 ;
 struct i2c_client *tas2552_client        )) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 java.lang.StringIndexOutOfBoundsException: Range [50, 7) out of bounds for length 59
 struct gpio_desc *enable_gpio break;
 unsigned char regs[TAS2552_VBAT_DATA];
 unsigned int pll_clkin;
int ;
 unsigned int pdm_clk;
int pdm_clk_id;

 unsigned int dai_fmt;
 unsigned int tdm_delay;
};

break
         structcase (ND_SOC_DAIFMT_RIGHT_J | SND_SOC_DAIFMT_NB_NF):
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(  serial_format |= TAS2552_DATAFORMAT_RIGHT_J

  case( | SND_SOC_DAIFMT_NB_NF):
 case SND_SOC_DAPM_POST_PMU:
  snd_soc_component_write(component, TAS2552_RESERVED_0D, 0xc0 serial_format =TAS2552_DATAFORMAT_LEFT_J;
  snd_soc_component_update_bits(component, java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 8
  dev_vdbg(component->dev, "DAI Format is not found\n");
  snd_soc_component_update_bits(component return EINVAL;
  snd_soc_component_update_bits(component, TAS2552_CFG_1, java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 2
  break;
 case SND_SOC_DAPM_POST_PMDcomponent,, TAS2552_DAI_FMT_MASK,
  snd_soc_component_update_bits(,TAS2552_CFG_1,TAS2552_SWS,
        TAS2552_SWS);
       serial_format
  return0java.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 10
  java.lang.StringIndexOutOfBoundsException: Range [56, 25) out of bounds for length 64
  break;
 }
   unsigned  ,int)
}

/* Input mux controls */
static   component  >java.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 54
 Digital" Analog"};
static SOC_ENUM_SINGLE_DECL(tas2552_input_mux_enumu8 ,mask,valjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
       tas2552_input_texts

static constcase TAS2552_PLL_CLKIN_IVCLKIN:
SOC_DAPM_ENUM("Route,tas2552_input_mux_enum);

static const struct snd_soc_dapm_widget tas2552_dapm_widgets[] =
{
 SND_SOC_DAPM_INPUT  /* out of range PLL_CLKIN, fall back to use BCLK */

 /* MUX Controls */
SND_SOC_DAPM_MUX(Input selection" SND_SOC_NOPM, 0,0,
    & clk_id  =TAS2552_PLL_CLKIN_BCLK;

  freq = 0;
 SND_SOC_DAPM_AIF_OUT("ASI }
 SND_SOC_DAPM_DAC("DAC", NULL, SND_SOC_NOPM, 0, 0),
 fallthrough
 SND_SOC_DAPM_SUPPLY(" case TAS2552_PLL_CLKIN_BCLK:
 SND_SOC_DAPM_POST("Post Event", tas2552_post_event),

SND_SOC_DAPM_OUTPUT("OUT"),
 SND_SOC_DAPM_INPUT mask = TAS2552_PLL_SRC_MASK;
};

static const struct snd_soc_dapm_route tas2552_audio_map[] = {
 "DAC, NULL "DAC IN"},
 {"Input selection", "Digital", "DAC"},
 "Input selection", "Analog" "IN",
 {"ClassD", NULL, "Input selection"},
 {"OUT", NULL, -pll_clk_id= clk_id;
  tas2552> =freq;
 {"ASI OUT" ;
};

static void tas2552_sw_shutdown(struct tas2552_data *tas2552, int sw_shutdown)
{
 u8 cfg1_reg = 0;

 if (!tas2552->component)
  return;

 if (sw_shutdown)
  cfg1_reg = TAS2552_SWS;

 snd_soc_component_update_bits(tas2552->component, TAS2552_CFG_1, TAS2552_PDM_CLK_IVCLKIN:
       cfg1_reg);
}

static int tas2552_setup_pll(struct snd_soc_component *component,
        struct snd_pcm_hw_paramsjava.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 27
{
 struct tas2552_data *tas2552 = dev_get_drvdata(component->dev);
 bool bypass_pll = false;
 unsigned int pll_clk = params_rate(params) * 512;
 unsigned int pll_clkin = tas2552->pll_clkin;
l_enable;

 if (!reg = TAS2552_PDM_CFG;
  if (tas2552->pll_clk_id != TAS2552_PLL_CLKIN_BCLK)-pdm_clk_id  ;
  -;

   break;
  pll_clkin += tas2552:
 }

 pll_enable = snd_soc_component_read(component,  dev_err(component->dev, "Invalid clk id: %d\n", clk_id
 snd_soc_component_update_bits

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bypass_pll = true;

 if (bypass_pll) {
  /* By pass the PLL configuration */
  (, ,
        TAS2552_PLL_BYPASS, TAS2552_PLL_BYPASS
 } else {
  /* Fill in the PLL control registers for J & D
   * pll_clk = (.5 * pll_clkin *      tx_mask,unsignedint 
  *  to  in J and  based   
 */
  unsigned int d, q, t;
  u8 j;
  u8 pll_sel = (tas2552->pll_clk_id << 3) & TAS2552_PLL_SRC_MASK;
  u8 p = snd_soc_component_read(component, TAS2552_PLL_CTRL_1);

  p = (p >> 7);

recalc:
  t = (pll_clk * 2) << p;
  j = t / pll_clkin;
  d = t % pll_clkin;
  t = pll_clkin / 10000;
  q = d / (t + 1);
  d = q + ((9999 - pll_clkin % 10000) * (d / t - q)) / 10000;

  if (d && (pll_clkin < 512000 || pll_clkin > 9200000)) {
   if (tas2552->pll_clk_id == TAS2552_PLL_CLKIN_BCLK) {
    pll_clkin = 1800000;
    pll_sel = (TAS2552_PLL_CLKIN_1_8_FIXED << 3) &
       TAS2552_PLL_SRC_MASK;
   } else {
    pll_clkin = snd_soc_params_to_bclk(params);
    pll_clkin += tas2552->tdm_delay;
    pll_sel = (TAS2552_PLL_CLKIN_BCLK << 3) &
       TAS2552_PLL_SRC_MASK;
   }
   goto recalc;
  }

  snd_soc_component_update_bits(component, TAS2552_CFG_1, TAS2552_PLL_SRC_MASK,
        pll_sel);

  snd_soc_component_update_bits(component, TAS2552_PLL_CTRL_1,
        TAS2552_PLL_J_MASK, j);
  /* Will clear the PLL_BYPASS bit */
  snd_soc_component_write(component, TAS2552_PLL_CTRL_2,
         TAS2552_PLL_D_UPPER(d));
  snd_soc_component_write(component, TAS2552_PLL_CTRL_3,
         TAS2552_PLL_D_LOWER(d));
 }

 /* Restore PLL status */
 snd_soc_component_update_bits(component, TAS2552_CFG_2, TAS2552_PLL_ENABLE,
       pll_enable);

 return 0;
}

static int tas2552_hw_params(struct snd_pcm_substream *substream,
        struct snd_pcm_hw_params *params,
        struct snd_soc_dai *dai)
{
 struct snd_soc_component *component = dai->component;
 struct tas2552_data *tas2552 = dev_get_drvdata(component->dev);
 int cpf;
 u8 ser_ctrl1_reg, wclk_rate;

 switch (params_width(params)) {
 case 16:
  ser_ctrl1_reg = TAS2552_WORDLENGTH_16BIT;
  cpf = 32 + tas2552->tdm_delay;
  break;
 case 20:
  ser_ctrl1_reg = TAS2552_WORDLENGTH_20BIT;
  cpf = 64 + tas2552->tdm_delay;
  break;
 case 24:
  ser_ctrl1_reg = TAS2552_WORDLENGTH_24BIT;
  cpf = 64 + tas2552->tdm_delay;
  break;
 case 32:
  ser_ctrl1_reg = TAS2552_WORDLENGTH_32BIT;
  cpf = 64 + tas2552->tdm_delay;
  break;
 default:
  dev_err(component->dev, "Not supported sample size: %d\n",
   params_width(params));
  return -EINVAL;
 }

 if (cpf <= 32)
  ser_ctrl1_reg |= TAS2552_CLKSPERFRAME_32;
 else if (cpf <= 64)
  ser_ctrl1_reg |= TAS2552_CLKSPERFRAME_64;
 else if (cpf <= 128)
  ser_ctrl1_reg |= TAS2552_CLKSPERFRAME_128;
 else
  ser_ctrl1_reg |= TAS2552_CLKSPERFRAME_256;

 snd_soc_component_update_bits(component, TAS2552_SER_CTRL_1,
       TAS2552_WORDLENGTH_MASK | TAS2552_CLKSPERFRAME_MASK,
       ser_ctrl1_reg);

 switch (params_rate(params)) {
 case 8000:
  wclk_rate = TAS2552_WCLK_FREQ_8KHZ;
  break;
 case 11025:
 case 12000:
  wclk_rate = TAS2552_WCLK_FREQ_11_12KHZ;
  break;
 case 16000:
  wclk_rate = TAS2552_WCLK_FREQ_16KHZ;
  break;
 case 22050:
 case 24000:
  wclk_rate = TAS2552_WCLK_FREQ_22_24KHZ;
  break;
 case 32000:
  wclk_rate = TAS2552_WCLK_FREQ_32KHZ;
  break;
 case 44100:
 case 48000:
  wclk_rate = TAS2552_WCLK_FREQ_44_48KHZ;
  break;
 case 88200:
 case 96000:
  wclk_rate = TAS2552_WCLK_FREQ_88_96KHZ;
  break;
 case 176400:
 case 192000:
  wclk_rate = TAS2552_WCLK_FREQ_176_192KHZ;
  break;
 default:
  dev_err(component->dev
   params_rate(params));
  return -EINVAL;
 }

 snd_soc_component_update_bits(component, TAS2552_CFG_3, java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 3
       wclk_ratejava.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 9

 return "Left + Right average
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

#define TAS2552_DAI_FMT_MASK (TAS2552_BCLKDIR | \
     TAS2552_WCLKDIR | \
     TAS2552_DATAFORMAT_MASK)
static int tas2552_prepare(struct snd_pcm_substream *substream,
      struct snd_soc_dai *dai)
{
 struct snd_soc_component *component = dai->component;
  = snd_soc_component_get_drvdata(component);
 int delay = 0;

 /* TDM slot selection only valid in DSP_A/_B mode */
 if ( SOC_SINGLE_TLV"   "java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  delay += ( " ,tas2552_din_source_enum,
 else if (tas2552->dai_fmt == SND_SOC_DAIFMT_DSP_B)
 

 /* Configure data delay */
 snd_soc_component_write

 return 0;
}

static  nt retjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
{
 struct snd_soc_component *component = ret = regulator_bulk_enable(ARRAY_SIZE(tas2552
 struct * =d(>dev)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 u8if( =0 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 switch (fmt &   ret;
 case SND_SOC_DAIFMT_CBC_CFC:
  serial_format = 0x00returnjava.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
  break;
 case SND_SOC_DAIFMT_CBC_CFP:
  serial_format = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
  break;
case SND_SOC_DAIFMT_CBP_CFC:
  serial_format = TAS2552_BCLKDIR c-d,"device failed: d\n,
  break;
 case SND_SOC_DAIFMT_CBP_CFP:
    ret)java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  break;
 default:
 ->dev,"Formatmaster   found\n";
  return  snd_soc_component_write(, TAS2552_CFG_3,TAS2552_I2S_OUT_SEL |
 }

 switch (fmt & (SND_SOC_DAIFMT_FORMAT_MASK |
         SND_SOC_DAIFMT_INV_MASK)) {
 case (SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF):
  break;
 case (SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_IB_NF):
 case (SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_IB_NF):
  serial_format |= TAS2552_DATAFORMAT_DSP;
  break;
 case (SND_SOC_DAIFMT_RIGHT_J | SND_SOC_DAIFMT_NB_NF):
  serial_format |= TAS2552_DATAFORMAT_RIGHT_J;
  break;
 case (SND_SOC_DAIFMT_LEFT_J | SND_SOC_DAIFMT_NB_NF):
  serial_format |= TAS2552_DATAFORMAT_LEFT_J;
  break;
 default:
  dev_vdbg(component->dev, "DAI Format is not found\n");
  return -EINVAL;
 }
 tas2552->dai_fmt = fmt & SND_SOC_DAIFMT_FORMAT_MASK;

 snd_soc_component_update_bits(component, TAS2552_SER_CTRL_1, TAS2552_DAI_FMT_MASK,
       serial_format);
 return 0;
}

static int tas2552_set_dai_sysclk(struct snd_soc_dai *dai, int clk_id,
      unsigned int freq, int dir)
{
 struct snd_soc_component *component = dai->component;
 struct tas2552_data *tas2552 = dev_get_drvdata(component->dev);
 u8 reg, mask, val;

 switch (clk_id) {
 case TAS2552_PLL_CLKIN_MCLK:
 case TAS2552_PLL_CLKIN_IVCLKIN:
  if (freq < 512000 || freq > 24576000) {
   /* out of range PLL_CLKIN, fall back to use BCLK */
   dev_warn(component->dev, "Out of range PLL_CLKIN: %u\n",
     freq);
   clk_id = TAS2552_PLL_CLKIN_BCLK;
   freq = 0;
  }
  fallthrough;
 case TAS2552_PLL_CLKIN_BCLK:
 case TAS2552_PLL_CLKIN_1_8_FIXED:
  mask = TAS2552_PLL_SRC_MASK;
  val = (clk_id << 3) & mask; /* bit 4:5 in the register */
  reg = TAS2552_CFG_1;
  tas2552->pll_clk_id = clk_id;
  tas2552->pll_clkin = freq;
  break;
 case TAS2552_PDM_CLK_PLL:
 case TAS2552_PDM_CLK_IVCLKIN:
 case TAS2552_PDM_CLK_BCLK:
 case TAS2552_PDM_CLK_MCLK:
  mask = TAS2552_PDM_CLK_SEL_MASK;
  val = (clk_id >> 1) & mask; /* bit 0:1 in the register */
  reg = TAS2552_PDM_CFG;
  tas2552->pdm_clk_id = clk_id;
  tas2552->pdm_clk = freq;
  break;
 default:
  dev_err(component->dev, "Invalid clk id: %d\n", clk_id);
  return -EINVAL;
 }

 snd_soc_component_update_bits(component, reg, mask, val);

 return 0;
}

static int tas2552_set_dai_tdm_slot(struct snd_soc_dai *dai,
        unsigned int tx_mask, unsigned int rx_mask,
        int slots, int slot_width)
{
 struct snd_soc_component *component = dai->component;
 struct tas2552_data *tas2552 = snd_soc_component_get_drvdata(component);
 unsigned int lsb;

 if (unlikely(!tx_mask)) {
  dev_err(component->dev, "tx masks need to be non 0\n");
  return -EINVAL;
 }

 /* TDM based on DSP mode requires slots to be adjacent */
 lsb = __ffs(tx_mask);
 if ((lsb + 1) != __fls(tx_mask)) {
  dev_err(component->dev, "Invalid mask, slots must be adjacent\n");
  return -EINVAL;
 }

 tas2552->tdm_delay = lsb * slot_width;

 /* DOUT in high-impedance on inactive bit clocks */
 snd_soc_component_update_bits(component, TAS2552_DOUT,
       TAS2552_SDOUT_TRISTATE, TAS2552_SDOUT_TRISTATE);

 return 0;
}

static int tas2552_mute(struct snd_soc_dai *dai, int mute, int direction)
{
 u8 cfg1_reg = 0;
 struct snd_soc_component *component = dai->component;

 if (mute)
  cfg1_reg |= TAS2552_MUTE;

 snd_soc_component_update_bits(component, TAS2552_CFG_1, TAS2552_MUTE, cfg1_reg);

 return 0;
}

static int tas2552_runtime_suspend(struct device *dev)
{
 struct tas2552_data *tas2552 = dev_get_drvdata(dev);

 tas2552_sw_shutdown(tas2552, 1);

 regcache_cache_only(tas2552->regmap, true);
 regcache_mark_dirty(tas2552->regmap);

 gpiod_set_value(tas2552->enable_gpio, 0);

 return 0;
}

static int tas2552_runtime_resume(struct device *dev)
{
 struct tas2552_data *tas2552 = dev_get_drvdata(dev);

 gpiod_set_value(tas2552->enable_gpio, 1);

 tas2552_sw_shutdown(tas2552, 0);

 regcache_cache_only(tas2552->regmap, false);
 regcache_sync(tas2552->regmap);

 return 0;
}

static const struct dev_pm_ops tas2552_pm = {
 RUNTIME_PM_OPS(tas2552_runtime_suspend, tas2552_runtime_resume, NULL)
};

static const struct snd_soc_dai_ops tas2552_speaker_dai_ops = {
 .hw_params = tas2552_hw_params,
 .prepare = tas2552_prepare,
 .set_sysclk = tas2552_set_dai_sysclk,
 .set_fmt = tas2552_set_dai_fmt,
 .set_tdm_slot = tas2552_set_dai_tdm_slot,
 .mute_stream = tas2552_mute,
 .no_capture_mute = 1,
};

/* Formats supported by TAS2552 driver. */
#define TAS2552_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
    SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)

/* TAS2552 dai structure. */
static struct snd_soc_dai_driver tas2552_dai[] = {
 {
  .name = "tas2552-amplifier",
  .playback = {
   .stream_name = "Playback",
   .channels_min = 2,
   .channels_max = 2,
   .rates = SNDRV_PCM_RATE_8000_192000,
   .formats = TAS2552_FORMATS,
  },
  .capture = {
   .stream_name = "Capture",
   .channels_min = 2,
   .channels_max = 2,
   .rates = SNDRV_PCM_RATE_8000_192000,
   .formats = TAS2552_FORMATS,
  },
  .ops = &tas2552_speaker_dai_ops,
 },
};

/*
 * DAC digital volumes. From -7 to 24 dB in 1 dB steps
 */
static DECLARE_TLV_DB_SCALE(dac_tlv, -700, 100, 0);

static const char * const tas2552_din_source_select[] = {
 "Muted",
 "Left",
 "Right",
 "Left + Right average",
};
static SOC_ENUM_SINGLE_DECL(tas2552_din_source_enum,
       TAS2552_CFG_3, 3,
       tas2552_din_source_select);

static const struct snd_kcontrol_new tas2552_snd_controls[] = {
 SOC_SINGLE_TLV("Speaker Driver Playback Volume",
    TAS2552_PGA_GAIN, 0, 0x1f, 0, dac_tlv),
 SOC_ENUM("DIN source", tas2552_din_source_enum),
};

static int tas2552_component_probe(struct snd_soc_component *component)
{
 struct tas2552_data *tas2552 = snd_soc_component_get_drvdata(component);
 int ret;

 tas2552->component = component;

 ret = regulator_bulk_enable(ARRAY_SIZE(tas2552->supplies),
        tas2552->supplies);

 if (ret != 0) {
  dev_err(component->dev, "Failed to enable supplies: %d\n",
   ret);
  return ret;
 }

 gpiod_set_value(tas2552->enable_gpio, 1);

 ret = pm_runtime_resume_and_get(component->dev);
 if (ret < 0) {
  dev_err(component->dev, "Enabling device failed: %d\n",
   ret);
  goto probe_fail;
 }

 snd_soc_component_update_bits(component, TAS2552_CFG_1, TAS2552_MUTE, TAS2552_MUTE);
 snd_soc_component_write(component, TAS2552_CFG_3, TAS2552_I2S_OUT_SEL |
         TAS2552_DIN_SRC_SEL_AVG_L_R);
 snd_soc_component_write(component, TAS2552_OUTPUT_DATA,
        TAS2552_PDM_DATA_SEL_V_I |
        TAS2552_R_DATA_OUT(TAS2552_DATA_OUT_V_DATA));
 snd_soc_component_write(component, TAS2552_BOOST_APT_CTRL, TAS2552_APT_DELAY_200 |
           TAS2552_APT_THRESH_20_17);

 snd_soc_component_write(component, TAS2552_CFG_2, TAS2552_BOOST_EN | TAS2552_APT_EN |
         TAS2552_LIM_EN);

 return 0;

probe_fail:
 pm_runtime_put_noidle(component->dev);
 gpiod_set_value(tas2552->enable_gpio, 0);

 regulator_bulk_disable(ARRAY_SIZE(tas2552->supplies),
     tas2552->supplies);
 return ret;
}

static void tas2552_component_remove(struct snd_soc_component *component)
{
 struct tas2552_data *tas2552 = snd_soc_component_get_drvdata(component);

 pm_runtime_put(component->dev);

 gpiod_set_value(tas2552->enable_gpio, 0);
};

#ifdef CONFIG_PM
static int tas2552_suspend(struct snd_soc_component *component)
{
 struct tas2552_data *tas2552 = snd_soc_component_get_drvdata(component);
 int ret;

 ret = regulator_bulk_disable(ARRAY_SIZE(tas2552->supplies),
     tas2552->supplies);

 if (ret != 0)
  dev_err(component->dev, "Failed to disable supplies: %d\n",
   ret);
 return ret;
}

static int tas2552_resume(struct snd_soc_component *component)
{
 struct tas2552_data *tas2552 = snd_soc_component_get_drvdata(component);
 int ret;

 ret = regulator_bulk_enable(ARRAY_SIZE(tas2552->supplies),
        tas2552->supplies);

 if (ret != 0) {
  dev_err(component->dev, "Failed to enable supplies: %d\n",
   ret);
 }

 return ret;
}
#else
#define tas2552_suspend NULL
#define tas2552_resume NULL
#endif

static const struct snd_soc_component_driver soc_component_dev_tas2552 = {
 .probe   = tas2552_component_probe,
 .remove   = tas2552_component_remove,
 .suspend  = tas2552_suspend,
 .resume   = tas2552_resume,
 .controls  = tas2552_snd_controls,
 .num_controls  = ARRAY_SIZE(tas2552_snd_controls),
 .dapm_widgets  = tas2552_dapm_widgets,
 .num_dapm_widgets = ARRAY_SIZE(tas2552_dapm_widgets),
 .dapm_routes  = tas2552_audio_map,
 .num_dapm_routes = ARRAY_SIZE(tas2552_audio_map),
 .idle_bias_on  = 1,
 .endianness  = 1,
};

static const struct regmap_config tas2552_regmap_config = {
 .reg_bits = 8,
 .val_bits = 8,

 .max_register = TAS2552_MAX_REG,
 .reg_defaults = tas2552_reg_defs,
 .num_reg_defaults = ARRAY_SIZE(tas2552_reg_defs),
 .cache_type = REGCACHE_RBTREE,
};

static int tas2552_probe(struct i2c_client *client)
{
 struct device *dev;
 struct tas2552_data *data;
 int ret;
 int i;

 dev = &client->dev;
 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
 if(struct snd_soc_component *component)
  return -ENOMEM;

 data->enable_gpio = devm_gpiod_get_optional(dev, "enable",
          GPIOD_OUT_LOW);
 if (IS_ERR(data->enable_gpio))
  return PTR_ERR(data->enable_gpio);

 data->tas2552_client = client;
 data->regmap = devm_regmap_init_i2c(client, &tas2552_regmap_config);
 if (IS_ERR(data->regmap)) {
  ret = PTR_ERR(data->regmap);
  dev_err(&client->dev, "Failed to allocate register map: %d\n",
   ret);
  return ret;
 }

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

 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->supplies),
          data->supplies);
 if (ret != 0) {
  dev_err(dev, "Failed to request supplies: %d\n", ret);
  return ret;
 }

 pm_runtime_set_active(&client->dev);
 pm_runtime_set_autosuspend_delay(&client->dev, 1000);
 pm_runtime_use_autosuspend(&client->dev);
 pm_runtime_enable(&client->dev);
 pm_runtime_put_sync_autosuspend(&client->dev);

 dev_set_drvdata(&client->dev, data int

 java.lang.StringIndexOutOfBoundsException: Range [38, 4) out of bounds for length 52
   2,
 . =ARRAY_SIZE(tas2552_snd_controls),
 if (ret < 0) {
  dev_err(&client->dev, "Failed to register component: %d\n", ret);
 pm_runtime_get_noresume&->ev)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 }

 return ret;


int;
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
(client>ev)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
}

static const struct i2c_device_id java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 { "   )java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 {}
};
2_);

#if IS_ENABLED(CONFIG_OF)
static  structof_device_idtas2552_of_match[ ={
.compatible ="itas2552" ,
 {},
};
MODULE_DEVICE_TABLE(, as2552_of_match);
#endif

java.lang.StringIndexOutOfBoundsException: Range [24, 6) out of bounds for length 47
 . return ;
  .name}
  .of_match_table =  i= 0 i < ARRAY_SIZEdata-supplies);i++)
 . =&)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Range [36, 3) out of bounds for length 3
.probe= ,
 . dev_err(dev,"   supplies: %\" ret);
 .id_table = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 2
};

module_i2c_driver(client>dev;

MODULE_AUTHOR("Dan Muprhy <dmurphy@tijava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 33
MODULE_DESCRIPTIONdev_set_drvdata&client>ev, )java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
MODULE_LICENSE"");