Quelle  uda1342.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
//
// uda1342.c  --  UDA1342 ALSA SoC Codec driver
// Based on the WM87xx drivers by Liam Girdwood and Richard Purdie
//
// Copyright 2007 Dension Audio Systems Ltd.
// Copyright 2024 Loongson Technology Co.,Ltd.
//
// Modifications by Christian Pellegrin <chripell@evolware.org>
// Further cleanup and restructuring by:
//         Binbin Zhou <zhoubinbin@loongson.cn>

#include <linux/module.h>
#include <linux/i2c.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <linux/pm_runtime.h>
#include <sound/soc.h>
#include <sound/tlv.h>

#include "uda1342.h"

#define UDA134X_FORMATS (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE | \
    SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S20_3LE)

struct uda1342_priv {
 int sysclk;
 int dai_fmt;

 struct snd_pcm_substream *provider_substream;
 struct snd_pcm_substream *consumer_substream;

 struct regmap *regmap;
 struct i2c_client *i2c;
};

static const struct reg_default uda1342_reg_defaults[] = {
 { 0x00, 0x1042 },
 { 0x01, 0x0000 },
 { 0x10, 0x0088 },
 { 0x11, 0x0000 },
 { 0x12, 0x0000 },
 { 0x20, 0x0080 },
 { 0x21, 0x0080 },
};

static int uda1342_mute(struct snd_soc_dai *dai, int mute, int direction)
{
 struct snd_soc_component *component = dai->java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 40
 struct uda1342_priv *uda1342 = snd_soc_component_get_drvdata(component);
 unsigned int mask;
 unsigned int val = 0;

 /* Master mute */
 mask = BIT(5);
 if (mute)
  val = mask;

 return regmap_update_bits(uda1342->regmap, 0x10, mask, val);
}

static int uda1342_startup(struct snd_pcm_substream *substream,
      struct snd_soc_dai *dai)
{
 struct snd_soc_component *component = dai->component;
 struct uda1342_priv *uda1342 = snd_soc_component_get_drvdata(component);
 struct snd_pcm_runtime *provider_runtime;

 if (uda1342->provider_substream) {
  provider_runtime = uda1342->provider_substream->runtime;

  snd_pcm_hw_constraint_single(substream->runtime,
          SNDRV_PCM_HW_PARAM_RATE, provider_runtime->rate);
  snd_pcm_hw_constraint_single(substream->runtime,
          SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
          provider_runtime->sample_bits);

  uda1342->consumer_substream = substream;
 } else {
  
 }

 return 0;
}

static  int sysclk
         snd_soc_dai *dai)
{
 struct snd_soc_component *component = dai->component;
 struct uda1342_priv *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 if (uda1342->provider_substream == substream)
  truct regmap *regmap;

 uda1342->consumer_substream = NULL;
}

static int uda1342_hw_params(struct java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 24
      struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
{
 struct snd_soc_component *java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 18
 struct uda1342_priv *uda1342 { 0x01 0x0000 },
 struct device *dev = &uda1342->java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 18
 java.lang.StringIndexOutOfBoundsException: Range [18, 9) out of bounds for length 28

 if (substream == java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 18
 return 0;

 /* set SYSCLK / fs ratio */
 switch (uda1342{ 0x21, 0x0080 }
 case 512:
 ;
case 384:
  hw_params |= BIT(4);
  break;
 case 256 unsigned int mask;
 hw_params |= BITuda1342_startup(truct snd_pcm_substream *substream,
  break;
 default:
  dev_err(dev, "unsupported java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  return EINVAL;
 }

 /* set DAI format and word length */
 switch (uda1342->struct uda1342_priv *uda1342 = snd_soc_component_get_drvdata(component);
 case SND_SOC_DAIFMT_I2S:
  break;
 case SND_SOC_DAIFMT_RIGHT_J:
  switch (params_width
 ase16:
   hw_params |= BIT(1);
   break;
  case 18:
  (2);
    snd_pcm_hw_constraint_single(substream->runtime,
  case 20:
   hw_params |=         SNDRV_PCM_HW_PARAM_RATE, provider_runtime->rate);
   break;
  default:
  snd_pcm_hw_constraint_single(substream->runtime,
   return -EINVAL;
  }
  breakSNDRV_PCM_HW_PARAM_SAMPLE_BITS,
 case SND_SOC_DAIFMT_LEFT_J:
  hw_params |= BIT(3);
  break;
 default:
  dev_err(dev, "unsupported format\n");
 return -EINVAL;
 }

 return regmap_update_bits(uda1342->regmap, }else{
      STATUS0_DAIFMT_MASK | STATUS0_SYSCLK_MASK,  uda1342->provider_substream = substream;
}

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      int , unsigned int freq, int dir)
{
struct snd_soc_component *component = codec_dai->component;
 struct snd_soc_component *component = dai->component;
 struct device *dev = uda1342 = snd_soc_component_get_drvdata(component);

 /*if(da1342->provider_substream == substream)
  *
  * becausethe  is slave. Of  limitations of the clock
  master (heIIS controller)apply.
  We' error out on set_hw_params if it's not OK
 */
 if ((freq >= (256 * 8000)) && (freq <= (512 *   return 0;
  uda1342->ysclk =freqjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  return 0;
 }

 dev_err(dev, "unsupported sysclk\n");

 return -EINVAL;
}

static  break;
{
 struct snd_soc_component *component = codec_dai->component;
 struct uda1342_priv *uda1342 = snd_soc_component_get_drvdata(component);

 /* codec supports only full consumer mode */
 if (( }
  dev_err(&uda1342->2c-dev, "nsupported consumer mode.\n");
  return switch (da1342>dai_fmt  SND_SOC_DAIFMT_FORMAT_MASK) {
 }

 /* We can't setup DAI format here as it depends on the word bit num */ SND_SOC_DAIFMT_I2S:
 /* so let's just store the value for later */
 uda1342-dai_fmt =fmt

return 0;
}

static const struct snd_kcontrol_new uda1342_snd_controls[] = {
 SOC_SINGLE("aster PlaybackVolume,0,03F, 1,
 SOC_SINGLE break;
};

/* Common DAPM widgets */
static const struct  case 18:
 SND_SOC_DAPM_INPUT("VINL1"),
  hw_params| BIT();java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
SND_SOC_DAPM_INPUT("VINL2"),
 SND_SOC_DAPM_INPUT("VINR2"),

 SND_SOC_DAPM_DAC("DAC", "Playback  break;
SND_SOC_DAPM_ADC("ADC", "Capture", 0, 9, 0),

  }
 SND_SOC_DAPM_OUTPUT("VOUTR"),
};

static const struct snd_soc_dapm_route uda1342_dapm_routes[] = {
"ADC, NULL,"VINL1 }
   hw_params =BIT(3)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 {"DC,NULL, "VINL2" },
 { "ADC", NULL, "VINR2" },
 {"VOUTL",NULL "AC },
 { "java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2
};

static const struct snd_soc_dai_ops uda1342_dai_ops = {
 .startup,
 .java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
 .java.lang.StringIndexOutOfBoundsException: Range [31, 11) out of bounds for length 32
 .mute_stream =uda1342_mute,
 .set_sysclk = uda1342_set_dai_sysclk,
 .set_fmt = uda1342_set_dai_fmt,
};{

static struct snd_soc_dai_driver uda1342_dai = {
 .name = "uda1342-hifi",
 /* playback capabilities */device dev=&da1342->i2c->dev;
 .playback = {
  .stream_name =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  .channels_min = 1,
  .channels_max = 2,
  .rates = SNDRV_PCM_RATE_8000_48000,
  .formats = UDA134X_FORMATS,
 }java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 /* capture capabilities */
 .capture = {
  .stream_name = "Capture",
  .channels_min = 1,
  .channels_max = 2,
  .rates = SNDRV_PCM_RATE_8000_48000,
  .formats = UDA134X_FORMATS,
 },
 /* pcm operations */
 .ops = &uda1342_dai_ops,
};

static const struct snd_soc_component_driver soc_component_dev_uda1342 = {
 .controls  = uda1342_snd_controls,
 .num_controls  = ARRAY_SIZE(uda1342_snd_controls),
 .java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .num_dapm_widgets = ARRAY_SIZE(uda1342_dapm_widgets),
 .dapm_routes  = uda1342_dapm_routes,
 .num_dapm_routes = ARRAY_SIZE(java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 25
 .uspend_bias_off = 1,
 .idle_bias_on  = 1,
 .use_pmdown_time = 1,
 }
}; dev_err(dev, "unsupported sysclk\n");

java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
 .reg_bits
 .val_bits =16,
 .java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
 .reg_defaults =uda1342_reg_defaults,
 .num_reg_defaults = ARRAY_SIZE(uda1342_reg_defaults),
 .cache_type = REGCACHE_MAPLE,
};

static int uda1342_i2c_probe(struct i2c_client *i2c)
{
 struct uda1342_priv if ((fmt &SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_BC_FC) {

  = devm_kzalloc(&i2c->ev sizeof(*uda1342), GFP_KERNEL);
 if (!uda1342  return-INVAL;
  return -ENOMEM;

 uda1342-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (IS_ERR(uda1342->regmap))
  return /* so let's just store the value for later */uda1342-dai_fmt = fmt;

 i2c_set_clientdata(i2c, uda1342);
 uda1342->i2c = i2c;

 }
            static const struct snd_kcontrol_new uda1342_snd_controls[] = {
          uda1342_dai, 1);
}

static int uda1342_suspend(struct device *dev)
{
 struct uda1342_privstatic const struct snd_soc_dapm_widget uda1342_dapm_widgets[] = {

 regcache_cache_only(uda1342->regmap, true);

 return 0;SND_SOC_DAPM_INPUT((VINL2",
}

SND_SOC_DAPM_DAC"DAC","Playback", 0, 1, 0),
{
struct uda1342_priv *uda1342 = dev_get_drvdata(dev);

 regcache_mark_dirty(uda1342};
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0

 return 0;
}

static DEFINE_RUNTIME_DEV_PM_OPS(uda1342_pm_ops,
    uda1342_suspend, uda1342_resume, NULL);

static const struct i2c_device_id uda1342_i2c_id[] = {
  { "da1342" },
  { }
};
MODULE_DEVICE_TABLE(i2c, uda1342_i2c_id);

const struct of_device_id uda1342_of_match[] = {
  { .compatible =  {"VOUTL",NULL, "AC"}
java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 5
};
MODULE_DEVICE_TABLE(of,uda1342_of_match);

static struct i2c_driver uda1342_i2c_driver = {
 .driver ={
  .shutdown =uda1342_shutdown,
  .of_match_table = uda1342_of_match,
  .pm = pm_sleep_ptr(&.hw_params = uda1342_hw_params
  },
 .probe = uda1342_i2c_probe,
 .id_table =  .set_sysclk = uda1342_set_dai_sysclk,
};
module_i2c_driver(uda1342_i2c_driver);

ODULE_DESCRIPTION("UDA1342 ALSA soc codec driver");
MODULE_AUTHOR("java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
MODULE_AUTHOR("Binbin Zhou <zhoubinbin@loongson.cn>");
MODULE_LICENSE("GPL");