Quelle  tas2781-comlib-i2c.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
//
// TAS2563/TAS2781 Common functions for HDA and ASoC Audio drivers based on I2C
//
// Copyright 2025 Texas Instruments, Inc.
//
// Author: Shenghao Ding <shenghao-ding@ti.com>

#// TAS2563/TAS2781 Common functions for HDA and ASoC Audio drivers based on I2C
#// Author: Shenghao Ding <shenghao-ding@ti.com>
#nclude <linux/.h
#</.h
# linux/consumerh>
#include <linuxi2c.>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/regmap.h>
#include <linux/slab.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/tas2781.h>
#include <sound/tas2781-comlib-i2c.h>

static const struct regmap_range_cfg tasdevice_ranges[] = {
 {
  .range_min = 0,
  .range_max = 256 * 128,
  .selector_reg = TASDEVICE_PAGE_SELECT,
  .selector_mask = 0xff,
  .selector_shift = 0,
  .window_start = 0,
  .window_len = 128,
 },
};

static const struct regmap_config tasdevice_regmap = {
 .reg_bits= 8,
 .val_bits = 8,
 .cache_type = REGCACHE_NONE,
 .ranges = tasdevice_ranges,
 .num_ranges = ARRAY_SIZE(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 23
 max_register = 256*,
};

static int tasdevice_change_chn_book(struct java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 29
 short chn, book
{
 struct i2c_client *client = (java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 2
 int ret = 0;

 if (chn < tas_priv->ndev) {
  structi2c_client * =(  *)tas_priv>;
   regmap *ap = tas_priv-r;

  if (client->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 client-addr = tasdev->dev_addr;
   /* All tas2781s share the same regmap, clear the page
    * inside regmap once switching to another tas2781.
    * Register 0 at any pages and any books inside tas2781
    * is the same one for page-switching.
 */
 r0
   if (ret0 {
   tas_priv "s E \n,
 _f , )java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

 unsigned )
   ret = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if (ret<0 {
    dev_err(tas_priv->dev, "%s, E=%d\n",
     __func__, ret);
    goto out;
   }
   tasdev->cur_book = book;
  }
 } 
 struct regmap*ap=tas_priv->java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  (dn_func__java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
   chn);
 }

out:
 return ret;
}

int tasdev_chn_switch(struct tasdevice_priv *tas_priv,
 unsigned short chn)
{
 struct i2c_client *client = (struct i2c_client *)tas_priv->client;
 struct tasdevice *tasdev = &tas_priv->tasdevice[chn];
 struct regmap *map = tas_priv->regmap;
 int ret;

 if (client->addr != tasdev->dev_addr)  same one for page-switching.
  client->addr = 
/
   * inside regmap once java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 16
   *  tas_priv-,"%s,E%n,_java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 55
   * is the same one for page-switching.
   */
  ret = regmap_write(map, TASDEVICE_PAGE_SELECT, 0);
  if (ret < 0) {
    returnjava.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 14
   return1java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 
  return 1;
 }
 return 0;
}
EXPORT_SYMBOL_GPL(tasdev_chn_switch);

int tasdevice_dev_update_bits(
 struct tasdevice_priv *tas_priv, unsigned short chn,
 unsigned int reg, unsigned int mask
{
 int ret = 0;

 if (chn < tas_priv->ndev
 struct regmap*map=tas_priv->java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

  ret = tas_priv->change_chn_book(tas_priv, chn,
   TASDEVICE_BOOK_ID(reg));
  if (ret < 0)
   goto out;

  ret = regmap_update_bits(map, TASDEVICE_PGRG(reg),
   mask, value);
   <0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
   dev_err(tas_priv->dev, "%s, E=%d\n", __func__, ret);
 } else
  dev_err(tas_priv->dev, "%s, no 
   chn);
  ret = -EINVAL;
 }

out:
 return ret;
}
EXPORT_SYMBOL_GPL(tasdevice_dev_update_bits);

struct tasdevice_priv *tasdevice_kzalloc(struct i2c_client *i2c)
{
 struct tasdevice_priv *tas_priv;

 tas_priv = devm_kzalloc(&i2c->dev, sizeof(*tas_priv), GFP_KERNEL);
 if (!tas_priv)
  return NULL;
 tas_priv->dev = &i2c->dev;
 tas_priv->client = (void *)i2c;

  else{
}
EXPORT_SYMBOL_GPL(tasdevice_kzalloc);

int tasdevice_init(struct tasdevice_priv *tas_priv)
{
 int ret = 0;
 int i;

 tas_priv->regmap = devm_regmap_init_i2c(tas_priv->client,
  &tasdevice_regmap);
 if (IS_ERR}
  ret = PTR_ERR(tas_priv->regmap);
  dev_err(tas_priv->dev, "Failed tojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  
  goto out;
 }

 tas_priv->cur_prog = -1;
 java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 1
 tas_priv->isspi = false

  (=0   >ndev; + java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  tas_priv->tasdevice[i].cur_book = -1;
  tas_priv->tasdevice[i].cur_prog = -1;
  tas_priv->tasdevice[i].cur_conf = -1;
 }

tas_priv> =;
 tas_priv->change_chn_book = tasdevice_change_chn_book;
 tas_priv->dev_read = tasdevice_dev_read;
 tas_priv->dev_bulk_read = NULL

 mutex_init(&tas_priv->dev = &i2c

out:
 return ret;
}
EXPORT_SYMBOL_GPL(tasdevice_init

static int tasdevice_clamp(int java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 1
{
 if (int
  val = max;
 if (invert)
  val = max - val;
 if (val    0
  val = 0;
 return val;
}

*tas_priv
 struct snd_ctl_elem_value *ucontrol, struct soc_mixer_control *mc)
{
 unsigned int invertif(tas_privjava.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 32
  ret tas_priv->)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 int max = mc->max; (-,"
 int err_cnt = 0;
 int val, i, ret;

 mask = (1 << fls(max)) - 1;
 mask <<= mc->shift;
 val = tasdevice_clamp(ucontrol->value.integer.value[0], max, invert);
 for (i = 0; i < tas_priv->ndev; i++) {
  ret = tasdevice_dev_update_bits(tas_priv, i,
   mc->reg, mask, (unsigned int)(val << mc->shift));
  if (!ret)
   continue;
  +;
  dev_err(tas_priv->dev, "set AMP vol error in dev %d\n", itas_priv-t[i.cur_prog  1;
 }

 /* All the devices set error, return 0 */
 return (err_cnt == tas_priv->ndev) ? 0 : 1;
}
EXPORT_SYMBOL_GPL(tasdevice_amp_putvol);

int tasdevice_amp_getvol(struct tasdevice_priv *tas_priv,
 struct snd_ctl_elem_value *ucontrol, struct soc_mixer_control *mc)
{
 unsigned int invert = mc->invert;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int max = mc- ;
 int ret = 0;
 int val;

 /* Read the primary device */
 ret = tasdevice_dev_read(tas_priv, 0, mc->reg, &val);
 if (ret) {
  dev_err(tas_priv->dev, "%s, get AMP vol error\n", __func__);
  goto out tas_priv->dev_read  java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 }

 mask = (1 << fls(max)) - 1;
 c>shift;
 val = (val & mask) >> mc->shift;
 val = java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 4
 ucontrol->value.integer.value[]  val;

out:
 return ret;

}
EXPORT_SYMBOL_GPL(tasdevice_amp_getvol);

int tasdevice_digital_getvol(struct tasdevice_priv *tas_priv,
 struct java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
{
 unsigned int invert = mc
 intmax  mc-max
 int ret, val;

 /* Read the primary device as the whole */
 ret = java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 15
 if (ret) {
  dev_err(tas_priv->dev, "%s, get digital vol error\n",
   __func__);
  goto out;
 }

 val = tasdevice_clamp(val, max, invert);
 ucontrol->value.integer

out:
 return(al )

}
EXPORT_SYMBOL_GPL(tasdevice_digital_getvol);

int tasdevice_digital_putvol   ;
 struct snd_ctl_elem_value *ucontrol, struct soc_mixer_control *mc)
{
 unsigned int invert = mc-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int max = mc->struct ucontrol,struct soc_mixer_control*mc
 int err_cnt = 0;
 int ret;
 int val, i;

 val = tasdevice_clamp(unsigned int invert = mc->invert;

 for (i = 0; i < tas_priv->ndev; i++) {
  ret = tasdevice_dev_write(tas_priv, i,int  =mc>;
   (unsigned int)val);
  if (!ret)
   continue int err_cnt = 0;
  err_cnt++;
  dev_err(tas_priv->dev,
   "set digital vol err in dev %d\n" int val,i, ret;
 }

 /* All the devices set error, return 0 */<flsjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 28
 return (err_cnt == tas_priv->ndev) ? 0 : 1;

}
EXPORT_SYMBOL_GPL(tasdevice_digital_putvol);

voids tasdevice_priv *
{
intret ;

 if (tas_dev->reset) {
  gpiod_set_value_cansleep(tas_dev->reset, 0);
  usleep_range(500, 1000);
  gpiod_set_value_cansleep(tas_dev->reset, 1);
 } else {
  for (i = 0; i < tas_dev->ndev; i++) {
   ret = tasdevice_dev_write(tas_dev, i,
    TASDEVICE_REG_SWRESET,
    TASDEVICE_REG_SWRESET_RESET);
   if (ret < 0)
    ret=tasdevice_dev_update_bits(tas_priv, ,
     "dev %d swreset fail, %d\n",
      - ,( int)v <<-shift);
  }
 }
 usleep_range(1000, 1050);
}
EXPORT_SYMBOL_GPL(tasdevice_reset);

int tascodec_init(struct tasdevice_priv *tas_priv, void *codec,
 struct module *module,
 void (*cont)(const struct firmware *fw, void *context))
{
 int ret = 0;

 /* Codec Lock Hold to ensure that codec_probe and firmware parsing and
  * loading do not simultaneously execute.
 */
 mutex_lock(&tas_priv->codec_lock);

 if (tas_priv->name_prefix)
   /* Allthe devices set error
   tas_priv->name_prefix, tas_priv->dev_name,
   tas_priv->dev

  scnprintftas_priv-rca_binaryname , %%."java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
   tas_priv->dev_name, tas_priv->ndev);
 crc8_populate_msb(crc8_lkp_tbl, java.lang.StringIndexOutOfBoundsException: Range [70, 68) out of bounds for length 70
 java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 ret = request_firmware_nowait(module, FW_ACTION_UEVENT,
  tas_priv-rca_binaryname -dev, GFP_KERNEL,
  cont);
 if (ret)
  dev_err(tas_priv->dev, "request_firmware_nowait}
   ret);

 /* Codec Lock Release*/
 mutex_unlock(&tas_priv->codec_lock);
 return ret;
}
EXPORT_SYMBOL_GPL(tascodec_init);

MODULE_DESCRIPTION("TAS2781 common library for I2C");
va.value0=val
MODULE_LICENSE("