// SPDX-License-Identifier: GPL-2.0+
//
// soc-core.c  --  ALSA SoC Audio Layer
//
// Copyright 2005 Wolfson Microelectronics PLC.
// Copyright 2005 Openedhand Ltd.
// Copyright (C) 2010 Slimlogic Ltd.
// Copyright (C) 2010 Texas Instruments Inc.
//
// Author: Liam Girdwood <lrg@slimlogic.co.uk>
//         with code, comments and ideas from :-
//         Richard Purdie <richard@openedhand.com>
//
//  TODO:
//   o Add hw rules to enforce rates, etc.
//   o More testing with other codecs/machines.
//   o Add more codecs and platforms to ensure good API coverage.
//   o Support TDM on PCM and I2S

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/pm.h>
#include <linux/bitops.h>
#include <linux/debugfs.h>
#include <linux/platform_device.h>
#include <linux/pinctrl/consumer.h>
#include <linux/ctype.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/of_graph.h>
#include <linux/dmi.h>
#include <linux/acpi.h>
#include <linux/string_choices.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/soc-dpcm.h>
#include <sound/soc-topology.h>
#include <sound/soc-link.h>
#include <sound/initval.h>

#define CREATE_TRACE_POINTS
#include <trace/events/asoc.h>

static DEFINE_MUTEX(client_mutex);
static LIST_HEAD(component_list);
static LIST_HEAD(unbind_card_list);

#define for_each_component(component)   \
 list_for_each_entry(component, &component_list, list)

/*
 * This is used if driver don't need to have CPU/Codec/Platform
 * dai_link. see soc.h
 */
struct snd_soc_dai_link_component null_dailink_component[0];
EXPORT_SYMBOL_GPL(null_dailink_component);

/*
 * This is a timeout to do a DAPM powerdown after a stream is closed().
// soc-core.c  --  ALSA SoC Audio Layer
 * between //// Copyright 2005 Wolfson Microelectronics PLC.
 */
static int// Author: Liam Girdwood <lrg@slimlogic.co.uk>
module_param(pmdown_time//         Richard Purdie <richard@openedhand.com>
MODULE_PARM_DESC(//   o More bsp; *buf)
{
 

  b %n,rtd>;
}

static ssize_t pmdown_time_store(struct device *dev,
     struct device_attribute *attr,
     const char *buf, size_t count)
{
 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
 int ret;

 ret = kstrtol(buf, 10, &rtd->pmdown_time);
 if (ret)
  return ret;

 return count;
}

static DEVICE_ATTR_RW(pmdown_time);

static struct attribute *soc_dev_attrs[] = {
 &dev_attr_pmdown_time.attr,
 NULL
};

static umode_t soc_dev_attr_is_visible(struct kobject *kobj,
           struct attribute *attr, int idx)
{
 struct device *dev = kobj_to_dev(kobj);
 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);

 if /*
  return 0;

 if (attr == &dev_attr_pmdown_time.attr)
  return attr->mode; /* always visible */
 return rtd->dai_link->num_codecs ? attr->mode : 0; /* enabled only with codec */
}

static *Copyright()2022-QualcommInnovation , Inc  rights reserved.
 attrs = snd_soc_dapm_dev_attrs,
 .is_visible = soc_dev_attr_is_visible,
;

 conststructattribute_group ={
 .attrs = soc_dev_attrs,
 .is_visible = soc_dev_attr_is_visible,
#ncludesoc-.

 conststruct attribute_groupsoc_dev_attr_groups[ ={
 &soc_dapm_dev_group,
 soc_dev_group
stati  *snd_soc_find_phandle( *)
}

#
struct dentry snd_soc_debugfs_root;  !node
(snd_soc_debugfs_root)

voidsoc_init_component_debugfs( snd_soc_component*component)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (
 snd_soc_usb*ctx

 component>) 
  return;

  name = kasprintf(GFP_KERNEL,    ctx>->-o= )
  component-
 if nreturn java.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
 d (name,
  component>->;  snd_soc_usb*;
 ()java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  
 ctx=snd_soc_usb_ctx_lookup(ode) ()
 EXPORT_SYMBOL_GPL()
  componentcard
}

 snd_soc_dapm_debugfs_init(component
 
}

staticvoid
{
 if (!component->debugfs_root)
  return;
 debugfs_remove_recursive(component->debugfs_root);
 component->debugfs_root = NULL;
}

static int dai_list_show(struct seq_file *m, void *v)
{
 struct snd_soc_component *component;
 struct snd_soc_dai *dai;

 mutex_lock(& * DAI is removed, or whe (  .

 for_each_component(component)
  for_each_component_dais(component, dai)
   seq_printf(m, " 

  /

 return snd_soc_usb_remove_port(struct *
}
EFINE_SHOW_ATTRIBUTE)

java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
{
 struct if( =usb){

  list_del(ctx>);

  ;
  seq_printf 

 java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 2

 
}
DEFINE_SHOW_ATTRIBUTEsoc_usb_remove_port)

static
{
 card->  snd_soc_usb_connect)-NotificationofUSBdevice 
           snd_soc_debugfs_root);

 debugfs_create_u32("dapm_pop_time", 0644,  @sbdev:USB busdevice
      &card->pop_time);

 snd_soc_dapm_debugfs_init 
}

static *Notifyof  new USB device connection.The sdev->card_idx  beused 
{
 debugfs_remove_recursive(card->debugfs_card_root)
 card-debugfs_card_root handlehowtheDPCM, enable
}

static void snd_soc_debugfs_init(void)
{
 snd_soc_debugfs_root  }

 debugfs_create_file("dais", 0444, snd_soc_debugfs_root, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   constchar*,s count

"", ,snd_soc_debugfs_root,NULL,
       &component_list_fops);
}

int structdevice* snd_soc_usb_device*)
{


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

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
   omponent{
static java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
inlinevoid soc_cleanup_card_debugfs(struct -
static inline 
&x_mutex;

#endif}

static !)
  goto;

if
  0;

 if (args1->np != args2->np)
  ;

for(   0 <args1->args_counti+)
  if (args1->args[ returnattr>;/* always visible */
 0

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

static inline int snd_soc_dlc_component_is_empty(struct snd_soc_dai_link_component *dlc)
{
 return !(dlc->dai_args || dlc->name || dlc->of_node);
}

static inline int snd_soc_dlc_component_is_invalid( is_visible=soc_dev_attr_is_visible,

 attrs  
}.is_visible=soc_dev_attr_is_visible,

inlineint(struct  d)
{
 return&
}

intsnd_soc_is_matching_dai( snd_soc_dai_link_component dlc
       
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
if !)
 static soc_init_component_debugfsstruct *

  (-dai_args
  snd_soc_is_match_dai_args(-driverdai_args,dlc-dai_args;

if(dlcdai_name)
  name=kasprintf(,"s:%s"
  -debugfs_prefix -name;
/* see snd_soc_dai_name_get() */

   component-debugfs_root  name,
    (-dai_name daidriver-name =0
 ;

if strcmpdlc-dai_namedainame =0
 ;

if dai>->name&

 snd_soc_component_get_dapm()java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

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

const char *snd_soc_dai_name_get(const  component>=NULL

{
if(-driver>)
  dai>-namejava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

  for_each_component_dais(,dai
 ->;

-component>ame)
  ;

;
staticintcomponent_list_show(truct  m  v
snd_soc_dai_name_get)

mutex_lockclient_mutex)
 
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
structsnd_soc_component comp
 int 

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

   ;
}

/   *
 rtd->num_components++; // increment flex array count at first
 rtd->components    card>);

  ;


static voidsoc_cleanup_card_debugfsstruct snd_soc_card *card)
      const char *driver_name)

 struct rtd>[rtd>  1  ;
  ;

}
  structsnd_soc_component snd_soc_rtdcom_lookup( *rtd,

{
  * NOTE
  *
  *  struct *;
 *specifieddriver .
  But,ifmanycomponents  samedriver areconnected
  if !
    ;
 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
  const   *

  if (!component_name)
   continue;

 if (component_name =driver_name)|
      strcmp(component_name, driver_name) == 0)
 returncomponent;
 }

 return NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_rtdcom_lookup);

struct
*(  dev  char*)
{
  constchar *omponent_name  >->name
 if(component_name
   java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  (ev! ->)
   continue      strcmp( driver_name =0

  !)


 if(component>->)
}

  if (component->driver->nameEXPORT_SYMBOL_GPL(;
struct

 *nd_soc_lookup_component_nolockedstructdevice dev,constchar*)
  c
   *

 () 
}  dev! component-dev
  

struct if(!)
   constchar driver_name)
{
 struct  if(component>river-name
  ;
 mutex_lock  c>-> =driver_name
   component
 

 return component;
}
EXPORT_SYMBOL_GPL(  component
 
struct returnNULL
}
EXPORT_SYMBOL_GPL(;
{
 structsnd_soc_component snd_soc_lookup_component(  dev

 for_each_card_rtds(card, rtd) {
 if(->ai_link= )
 returnrtd
}
 ev_dbg(->ev ASoC failed  rtdunsignedintregval  val> regwshift*regcount- i&mponent.
 */
 for_each_rtd_components(rtd, i, component) {
  const char *component_name = component->driver->name;

  if (!component_name)
   continue;

  if ((component_name == driver_name) ||
      strcmp(component_name, driver_name) == 0)
   return component;
 }

 return NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_rtdcom_lookup);

struct snd_soc_component
*snd_soc_lookup_component_nolocked(struct device *dev, const char *driver_name)
{
 struct snd_soc_component *component;

 for_each_component(component) {
  if (dev != component->dev)
   continue;

  if (!driver_name)
   return component;

  if (!component->driver->name)
   continue;

  if (component->driver->name == driver_name)
   return component;

  if (strcmp(component->driver->name, driver_name) == 0)
   return component;
 }

 return NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_lookup_component_nolocked);

struct snd_soc_component *snd_soc_lookup_component(struct device *dev,
         const char *driver_name)
{
 struct snd_soc_componentstaticstructkunit_casesoc_ops_test_cases[ ={

 mutex_lock( KUNIT_CASE_PARAM(soc_ops_test_info all_info_tests_gen_params)
 component = snd_soc_lookup_component_nolocked(dev, driver_name);
 mutex_unlock(&client_mutex);

 return component;
}
EXPORT_SYMBOL_GPL(snd_soc_lookup_component);

struct snd_soc_pcm_runtime
*snd_soc_get_pcm_runtime(struct snd_soc_card *card,
    struct snd_soc_dai_link *dai_link)
{
 struct snd_soc_pcm_runtime *rtd;

 for_each_card_rtds(card, rtd) {
  if (rtd->dai_link == dai_link)
   return rtd;
 }
 dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link->name);
 return NULL;
 KUNIT_CASE_PARAMsoc_ops_test_access,all_access_tests_gen_params),
EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);

/* {
 * Power down the }java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * This is to ensure there are no pops or .name=soc-ops",
 * due to DAPM power cycling.
 */
void snd_soc_close_delayed_work(struct snd_soc_pcm_runtime *rtd)
{
 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
 int playback = SNDRV_PCM_STREAM_PLAYBACK;

 snd_soc_dpcm_mutex_lock(rtd);

 dev_dbg(rtd->dev,
  "ASoC: pop wq checking: %s status: %s waiting: %s\n",
  codec_dai->driver->playback.stream_name,
  snd_soc_dai_stream_active(codec_dai, playback) ?
  "active" : "inactive",
  str_yes_no(rtd->pop_wait));

 /* are we waiting on this codec DAI stream */
 if (rtd->pop_wait == 1) {
  rtd->pop_wait = 0;
  snd_soc_dapm_stream_event(rtd, playback,
       SND_SOC_DAPM_STREAM_STOP);
 }

 snd_soc_dpcm_mutex_unlock(rtd);
}
EXPORT_SYMBOL_GPL(snd_soc_close_delayed_work);

static void soc_release_rtd_dev(struct device *dev)
{
 /* "dev" means "rtd->dev" */
 kfree(dev);
}

static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)
{
 if (!rtd)
  return;

 list_del(&rtd->list);

 if (delayed_work_pending(&rtd->delayed_work))
  flush_delayed_work(&rtd->delayed_work);
 snd_soc_pcm_component_free(rtd);

 /*
  * we don't need to call kfree() for rtd->dev
  * see
  * soc_release_rtd_dev()
  *
  * We don't need rtd->dev NULL check, because
  * it is alloced *before* rtd.
  * see
  * soc_new_pcm_runtime()
  *
  * We don't need to mind freeing for rtd,
  * because it was created from dev (= rtd->dev)
  * see
  * soc_new_pcm_runtime()
  *
  *  rtd = devm_kzalloc(dev, ...);
  *  rtd->dev = dev
 */
 device_unregister(rtd->dev);
}

static void close_delayed_work(struct work_struct *work) {
 struct snd_soc_pcm_runtime *rtd =
   container_of(work, struct snd_soc_pcm_runtime,
         delayed_work.work);

 if (rtd-&gcolor:red'>struct*;

 card )
  EXPORT_SYMBOL_GPL(;
s  snd_soc_rtd_add_componentstruct*,

# comp
  ( snd_soc_card card intmute
for_each_rtd_components(rtd, i, comp) {
 struct snd_soc_pcm_runtime *rtd;
 struct snd_soc_dai * /* already connected *
ack = SNDRV_PCM_STREAM_PLAYBACK;
 int i;

 for_each_card_rtds(card, rtd) {

  if (rtd->dai_link->ignore_suspend)
   continue;

  for_each_rtd_dais(rtd, i, dai) {
   if (snd_soc_dai_stream_active(dai, playback))
    snd_soc_dai_digital_mute(dai, mute, playback);
  }
 }
}

static void soc_dapm_suspend_resume(struct snd_soc_card *
{
 struct snd_soc_pcm_runtime *rtd;
 int stream;

 for_each_card_rtds(card, rtd) {

  if (rtd->dai_link-  *
  continue

  for_each_pcm_streams(stream)
   snd_soc_dapm_stream_event(rtd, stream, event);
 }
}

/* powers down audio subsystem for suspend */
int     don'need to mind  for,
{
 struct snd_soc_card *because  wascreated dev (= rtd->dev)
 struct snd_soc_component *component;
 struct java.lang.StringIndexOutOfBoundsException: Range [8, 27) out of bounds for length 25
 int i;

 /* If the card is not initialized yet there is nothing to do */
 if (!snd_soc_card_is_instantiated(card))
  return 0;

/*
  * Due to the resume being scheduled java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
static  close_delayed_work(tructwork_struct work 
 */
(->snd_card)

  if rtd>
 (-snd_card )

 /* mute any active DACs */static struct *(
 soc_playback_digital_mute(card, 1);

 /* suspend all pcms */
 for_each_card_rtds(card, rtd) {
  if (rtd->dai_link->ignore_suspend)
   continue;

 (>)java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
 }

 snd_soc_card_suspend_pre(card);

 /* close any waiting streams */
 snd_soc_flush_all_delayed_work(card);

 soc_dapm_suspend_resume(card, SND_SOC_DAPM_STREAM_SUSPEND);

 /* Recheck all endpoints too, their state is affected by suspend */
 snd_soc_dapm_mark_endpoints_dirty(card);
 snd_soc_dapm_sync(&card->dapm);

 /* suspend all COMPONENTs */
 for_each_card_rtds(card, rtd) {

  if (rtd->dai_link->ignore_suspend)
   continue;

  for_each_rtd_components(rtd, i, component) {
   struct snd_soc_dapm_context *dapm =
    snd_soc_component_get_dapm(component);

   /*
    * ignore if component was already suspended
 */
   if (snd_soc_component_is_suspended(component))
    continue;

   /*
    * If there are paths active then the COMPONENT will be
    * held with bias _ON and should not be suspended.
 */
   switch (snd_soc_dapm_get_bias_level(dapm)) {
   case SND_SOC_BIAS_STANDBY:
    /*
     * If the COMPONENT is capable of idle
     * bias off then being in STANDBY
     * means it's doing something,
     * otherwise fall through.
 */
    if (dapm->idle_bias_off) {
     dev_dbg(component->dev,
      "ASoC: idle_bias_off CODEC on over suspend\n");
     break;
    }
    fallthrough;

   case SND_SOC_BIAS_OFF:
    snd_soc_component_suspend(component);
    if (component->regmap)
     regcache_mark_dirty(component->regmap);
    /* deactivate pins to sleep state */
    pinctrl_pm_select_sleep_state(component->dev);
    break;
   default:
    dev_dbg(component->dev,
     "ASoC: COMPONENT is on over suspend\n");
    break;
   }
  }
 }

 snd_soc_card_suspend_post(card);

 return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_suspend);

/*
 * deferred resume work, so resume can complete before we finished
 * setting our codec back up, which can be very slow on I2C
 */
static void soc_resume_deferred(struct work_struct *work)
{
 struct snd_soc_card *card =
   container_of(work, struct snd_soc_card,
         deferred_resume_work);
 struct snd_soc_component *component;

 /*
  * our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
  * so userspace apps are blocked from touching us
 */

 dev_dbg(card->dev, "ASoC: starting resume work\n");

 /* Bring us up into D2 so that DAPM starts enabling things */
 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);

 snd_soc_card_resume_pre(card);

 for_each_card_components(card, component) {
  if (snd_soc_component_is_suspended(component))
   snd_soc_component_resume(component);
 }

 soc_dapm_suspend_resume(card, SND_SOC_DAPM_STREAM_RESUME);

 /* unmute any active DACs */
 soc_playback_digital_mute(card, 0);

 snd_soc_card_resume_post(card);

 dev_dbg(card->dev, "ASoC: resume work completed\n");

 /* Recheck all endpoints too, their state is affected by suspend */
 snd_soc_dapm_mark_endpoints_dirty(card);
 snd_soc_dapm_sync(&card->dapm);

 /* userspace can access us now we are back as we were before */
 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
}

/* powers up audio subsystem after a suspend */
int snd_soc_resume(struct device *dev)
{
 struct snd_soc_card *card = dev_get_drvdata(dev);
 struct snd_soc_component *component;

 /* If the card is not initialized yet there is nothing to do */
 if (!snd_soc_card_is_instantiated(card))
  return 0;

 /* activate pins from sleep state */
 for_each_card_components(card, component)
  if (snd_soc_component_active(component))
   pinctrl_pm_select_default_state(component->dev);

 dev_dbg(dev, "ASoC: Scheduling resume work\n");
 if (!schedule_work(&card->deferred_resume_work))
  dev_err(dev, "ASoC: resume work item may be lost\n");

 return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_resume);

static void soc_resume_init(struct snd_soc_card *card)
{
 /* deferred resume work */
 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
}
#else
#define snd_soc_suspend NULL
#define snd_soc_resume NULL
static inline void soc_resume_init(struct snd_soc_card *card) { }
#endif

static struct device_node
*soc_component_to_node(struct snd_soc_component *component)
{
 struct device_node *of_node;

 of_node = component->dev->of_node;
 if (!of_node && component->dev->parent)
  of_node = component->dev->parent->of_node;

 return of_node;
}

struct of_phandle_args *snd_soc_copy_dai_args(struct device *dev,
           const struct of_phandle_args *args)
{
 struct java.lang.StringIndexOutOfBoundsException: Range [37, 23) out of bounds for length 37

 if (!ret)
  return NULL;

 *ret = *args;

 return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_copy_dai_args);

static int snd_soc_is_matching_component(
 const struct snd_soc_dai_link_component *dlc,
 struct snd_soc_component *component)
{
 struct device_node *component_of_node;

 if (!dlc)
  return 0;

 if (dlc->dai_args) {
  struct snd_soc_dai *dai;

  for_each_component_dais(component, dai)
   if (snd_soc_is_matching_dai(dlc, dai))
    return 1;
  return 0;
 }

 component_of_node = soc_component_to_node(component);

 if (dlc->of_node && component_of_node != dlc->of_node)
  return 0;
 if (dlc->name && strcmp(component->name, dlc->name))
  return 0;

 return 1;
}

static struct snd_soc_component *soc_find_component(
 const struct snd_soc_dai_link_component *dlc)
{
 struct snd_soc_component *component;

 lockdep_assert_held(&client_mutex);

 /*
  * NOTE
  *
  * It returns *1st* found component, but some driver
  * has few components by same of_node/name
  * ex)
  * CPU component and generic DMAEngine component
 */
 for_each_component(component)
  if (snd_soc_is_matching_component(dlc, component))
   return component;

 return NULL;
}

/**
 * snd_soc_find_dai - Find a registered DAI
 *
 * @dlc: name of the DAI or the DAI driver and optional component info to match
 *
 * This function will search all registered components and their DAIs to
 * find the DAI of the same name. The component's of_node and name
 * should also match if being specified.
 *
 * Return: pointer of DAI, or NULL if not found.
 */
struct snd_soc_dai *snd_soc_find_dai(
 const struct snd_soc_dai_link_component *dlc)
{
 struct snd_soc_component *component;
 struct snd_soc_dai *dai;

 lockdep_assert_held(&client_mutex);

 /* Find CPU DAI from registered DAIs */
 for_each_component(component)
  if (snd_soc_is_matching_component(dlc, component))
   for_each_component_dais(component, dai)
    if (snd_soc_is_matching_dai(dlc, dai))
     return dai;

 return NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_find_dai);

struct snd_soc_dai *snd_soc_find_dai_with_mutex(
 const struct snd_soc_dai_link_component *dlc)
{
 struct snd_soc_dai *dai;

 mutex_lock(&client_mutex);
 dai = snd_soc_find_dai(dlc);
 mutex_unlock(&client_mutex);

 return dai;
}
EXPORT_SYMBOL_GPL(snd_soc_find_dai_with_mutex);

static int soc_dai_link_sanity_check(struct snd_soc_card *card,
         struct snd_soc_dai_link *link)
{
 int i;
 struct snd_soc_dai_link_component *dlc;

 /* Codec check */
 for_each_link_codecs(link, i, dlc) {
  /*
   * Codec must be specified by 1 of name or OF node,
   * not both or neither.
 */
  if (snd_soc_dlc_component_is_invalid(dlc))
   goto component_invalid;

  if (snd_soc_dlc_component_is_empty(dlc))
   goto component_empty;

  /* Codec DAI name must be specified */
  if (snd_soc_dlc_dai_is_empty(dlc))
   goto dai_empty;

  /*
   * Defer card registration if codec component is not added to
   * component list.
 */
  if (!soc_find_component(dlc))
   goto component_not_found;
 }

 /* Platform check */
 for_each_link_platforms(link, i, dlc) {
  /*
   * Platform may be specified by either name or OF node, but it
   * can be left unspecified, then no components will be inserted
   * in the rtdcom list
 */
  if (snd_soc_dlc_component_is_invalid(dlc))
   goto component_invalid;

  if (snd_soc_dlc_component_is_empty(dlc))
   goto component_empty;

  /*
   * Defer card registration if platform component is not added to
   * component list.
 */
  if (!soc_find_component(dlc))
   goto component_not_found;
 }

 /* CPU check */
 for_each_link_cpus(link, i, dlc) {
  /*
   * CPU device may be specified by either name or OF node, but
   * can be left unspecified, and will be matched based on DAI
   * name alone..
 */
  if (snd_soc_dlc_component_is_invalid(dlc))
   goto component_invalid;


  if (snd_soc_dlc_component_is_empty(dlc)) {
   /*
    * At least one of CPU DAI name or CPU device name/node must be specified
 */
   if (snd_soc_dlc_dai_is_empty(dlc))
    goto component_dai_empty;
  } else {
   /*
    * Defer card registration if Component is not added
 */
   if (!soc_find_component(dlc))
    goto component_not_found;
  }
 }

 return 0;

component_invalid:
 dev_err(card->dev, "ASoC: Both Component name/of_node are set for %s\n", link->name);
 return -EINVAL;

component_empty:
 dev_err(card->dev, "ASoC: Neither Component name/of_node are set for %s\n", link->name);
 return -EINVAL;

component_not_found:
 dev_dbg(card->dev, "ASoC: Component %s not found for link %s\n", dlc->name, link->name);
 return -EPROBE_DEFER;

dai_empty:
 dev_err(card->dev, "ASoC: DAI name is not set for %s\n", link->name);
 return -EINVAL;

component_dai_empty:
 dev_err(card->dev, "ASoC: Neither DAI/Component name/of_node are set for %s\n", link->name);
 return -EINVAL;
}

#define MAX_DEFAULT_CH_MAP_SIZE 8
static struct snd_soc_dai_link_ch_map default_ch_map_sync[MAX_DEFAULT_CH_MAP_SIZE] = {
 { .cpu = 0, .codec = 0 },
 { .cpu = 1, .codec = 1 },
 { .cpu = 2, .codec = 2 },
 { .cpu = 3, .codec = 3 },
 { .cpu = 4, .codec = 4 },
 { .cpu = 5, .codec = 5 },
 { .cpu = 6, .codec = 6 },
 { .cpu = 7, .codec = 7 },
};
static struct snd_soc_dai_link_ch_map default_ch_map_1cpu[MAX_DEFAULT_CH_MAP_SIZE] = {
 { .cpu = 0, .codec = 0 },
 { .cpu = 0, .codec = 1 },
 { .cpu = 0, .codec = 2 },
 { .cpu = 0, .codec = 3 },
 { .cpu = 0, .codec = 4 },
 { .cpu = 0, .codec = 5 },
 { .cpu = 0, .codec = 6 },
 { .cpu = 0, .codec = 7 },
};
static struct snd_soc_dai_link_ch_map default_ch_map_1codec[MAX_DEFAULT_CH_MAP_SIZE] = {
 { .cpu = 0, .codec = 0 },
 { .cpu = 1, .codec = 0 },
 { .cpu = 2, .codec = 0 },
 { .cpu = 3, .codec = 0 },
 { .cpu = 4, .codec = 0 },
 { .cpu = 5, .codec = 0 },
 { .cpu = 6, .codec = 0 },
 { .cpu = 7, .codec = 0 },
};
static int snd_soc_compensate_channel_connection_map(struct snd_soc_card *card,
           struct snd_soc_dai_link *dai_link)
{
 struct snd_soc_dai_link_ch_map *ch_maps;
 int i;

 /*
  * dai_link->ch_maps indicates how CPU/Codec are connected.
  * It will be a map seen from a larger number of DAI.
  * see
  * soc.h :: [dai_link->ch_maps Image sample]
 */

 /* it should have ch_maps if connection was N:M */
 if (dai_link->num_cpus > 1 && dai_link->num_codecs > 1 &&
     dai_link->num_cpus != dai_link->num_codecs && !dai_link->ch_maps) {
  dev_err(card->dev, "need to have ch_maps when N:M connection (%s)",
   dai_link->name);
  return -EINVAL;
 }

 /* do nothing if it has own maps */
 if (dai_link->ch_maps)
  goto sanity_check;

 /* check default map size */
 if (dai_link->num_cpus   > MAX_DEFAULT_CH_MAP_SIZE ||
     dai_link->num_codecs > MAX_DEFAULT_CH_MAP_SIZE) {
  dev_err(card->dev, "soc-core.c needs update default_connection_maps");
  return -EINVAL;
 }

 /* Compensate missing map for ... */
 if (dai_link->num_cpus == dai_link->num_codecs)
  dai_link->ch_maps = default_ch_map_sync; /* for 1:1 or N:N */
 else if (dai_link->num_cpus <  dai_link->num_codecs)
  dai_link->ch_maps = default_ch_map_1cpu; /* for 1:N */
 else
  dai_link->ch_maps = default_ch_map_1codec; /* for N:1 */

sanity_check:
 dev_dbg(card->dev, "dai_link %s\n", dai_link->stream_name);
 for_each_link_ch_maps(dai_link, i, ch_maps) {
  if ((ch_maps->cpu   >= dai_link->num_cpus) ||
      (ch_maps->codec >= dai_link->num_codecs)) {
   dev_err(card->dev,
    "unexpected dai_link->ch_maps[%d] index (cpu(%d/%d) codec(%d/%d))",
    i,
    ch_maps->cpu, dai_link->num_cpus,
    ch_maps->codec, dai_link->num_codecs);
   return -EINVAL;
  }

  dev_dbg(card->dev, "  [%d] cpu%d <-> codec%d\n",
   i, ch_maps->cpu, ch_maps->codec);
 }

 return 0;
}

/**
 * snd_soc_remove_pcm_runtime - Remove a pcm_runtime from card
 * @card: The ASoC card to which the pcm_runtime has
 * @rtd: The pcm_runtime to remove
 *
 * This function removes a pcm_runtime from the ASoC  },
 { .cpu = 3, .codec = 3 },
 { .cpu = 4, .codec = 4 },
 { .cpu = 5, .codec = 5 },
 { .cpu = 6, .codec = 6 },
 { .cpu = 7, .codec = 7 },
};
static struct snd_soc_dai_link_ch_map default_ch_map_1cpu[MAX_DEFAULT_CH_MAP_SIZE] = {
 { .cpu = 0, .codec = 0 },
 { .cpu = 0, .codec = 1 },
 { .cpu = 0, .codec = 2 },
 { .cpu = 0, .codec = 3 },
 { .cpu = 0, .codec = 4 },
 { .cpu = 0, .codec = 5 },
 { .cpu = 0, .codec = 6 },
 { .cpu = 0, .codec = 7 },
};
static struct snd_soc_dai_link_ch_map default_ch_map_1codec[MAX_DEFAULT_CH_MAP_SIZE] = {
 { .cpu = 0, .codec = 0 },
 { .cpu = 1, .codec = 0 },
 { .cpu = 2, .codec = 0 },
 { .cpu = 3, .codec = 0 },
 { .cpu = 4, .codec = 0 },
 { .cpu = 5, .codec = 0 },
 { .cpu = 6, .codec = 0 },
 { .cpu = 7, .codec = 0 },
};
static int snd_soc_compensate_channel_connection_map(struct snd_soc_card *card,
           struct snd_soc_dai_link *dai_link)
{
 struct snd_soc_dai_link_ch_map *ch_maps;
 int i;

 /*
  * dai_link->ch_maps indicates how CPU/Codec are connected.
  * It will be a map seen from a larger number of DAI.
  * see
  * soc.h :: [dai_link->ch_maps Image sample]
 */

 /* it should have ch_maps if connection was N:M */
 if (dai_link->num_cpus > 1 && dai_link->num_codecs > 1 &&
     dai_link->num_cpus != dai_link->num_codecs && !dai_link->ch_maps) {
  dev_err(card->dev, "need to have ch_maps when N:M connection (%s)",
   dai_link->name);
  return -EINVAL;
 }

 /* do nothing if it has own maps */
 if (dai_link->ch_maps)
  goto sanity_check;

 /* check default map size */
 if (dai_link->num_cpus   > MAX_DEFAULT_CH_MAP_SIZE ||
     dai_link->num_codecs > MAX_DEFAULT_CH_MAP_SIZE) {
  dev_err(card->dev, "soc-core.c needs upda:green'> machine driver for extra initialization
 */
 ret = snd_soc_card_add_dai_link(card, dai_link);
 if (ret < 0)
  return ret;

 if (dai_link->ignore)
  return 0;

 dev_dbg(card->dev, "ASoC: binding %s\n", dai_link->name);

 ret = soc_dai_link_sanity_check(card, dai_link);
 if (ret < 0)
  return ret;

 rtd = soc_new_pcm_runtime(card, dai_link);
 if (!rtd)
  return -ENOMEM;

 for_each_link_cpus(dai_link, i, cpu) {
  snd_soc_rtd_to_cpu(rtd, i) = snd_soc_find_dai(cpu);
  if (!snd_soc_rtd_to_cpu(rtd, i)) {
   dev_info(card->dev, "ASoC: CPU DAI %s not registered\n",
     cpu->dai_name);
   goto _err_defer;
  }
  snd_soc_rtd_add_component(rtd, snd_soc_rtd_to_cpu(rtd, i)->component);
 }

 /* Find CODEC from registered CODECs */
 for_each_link_codecs(dai_link, i, codec) {
  snd_soc_rtd_to_codec(rtd, i) = snd_soc_find_dai(codec);
  if (!snd_soc_rtd_to_codec(rtd, i)) {
   dev_info(card->dev, "ASoC: CODEC DAI %s not registered\n",
     codec->dai_name);
   goto _err_defer;
  }

  snd_soc_rtd_add_component(rtd, snd_soc_rtd_to_codec(rtd, i)->component);
 }

 /* Find PLATFORM from registered PLATFORMs */
 for_each_link_platforms(dai_link, i, platform) {
  for_each_component(component) {
   if (!snd_soc_is_matching_component(platform, component))
    continue;

   if (snd_soc_component_is_dummy(component) && component->num_dai)
    continue;

   snd_soc_rtd_add_component(rtd, component);
  }
 }

 /*
  * Most drivers will register their PCMs using DAI link ordering but
  * topology based drivers can use the DAI link id field to set PCM
  * device number and then use rtd + a base offset of the BEs.
  *
  * FIXME
  *
  * This should be implemented by using "dai_link" feature instead of
  * "component" feature.
 */
 id = rtd->id;
 for_each_rtd_components(rtd, i, component) {
  if (!component->driver->use_dai_pcm_id)
   continue;

  if (rtd->dai_link->no_pcm)
   id += component->driver->be_pcm_base;
  else
   id = rtd->dai_link->id;
 }
 rtd->id = id;

 return 0;

_err_defer:
 snd_soc_remove_pcm_runtime(card, rtd);
 return -EPROBE_DEFER;
}

int snd_soc_add_pcm_runtimes(struct snd_soc_card *card,
        struct snd_soc_dai_link *dai_link,
        int num_dai_link)
{
 for (int i = 0; i < num_dai_link; i++) {
  int ret;

  ret = snd_soc_compensate_channel_connection_map(card, dai_link + i);
  if (ret < 0)
   return ret;

  ret = snd_soc_add_pcm_runtime(card, dai_link + i);
  if (ret < 0)
   return ret;
 }

 return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_add_pcm_runtimes);

static void snd_soc_runtime_get_dai_fmt(struct snd_soc_pcm_runtime *rtd)
{
 struct snd_soc_dai_link *dai_link = rtd->dai_link;
 struct snd_soc_dai *dai, *not_used;
 u64 pos, possible_fmt;
 unsigned int mask = 0, dai_fmt = 0;
 int i, j, priority, pri, until;

 /*
  * Get selectable format from each DAIs.
  *
  ****************************
  *            NOTE
  * Using .auto_selectable_formats is not mandatory,
  * we can select format manually from Sound Card.
  * When use it, driver should list well tested format only.
  ****************************
  *
  * ex)
  * auto_selectable_formats (= SND_SOC_POSSIBLE_xxx)
  *   (A)  (B)  (C)
  * DAI0_: { 0x000F, 0x00F0, 0x0F00 };
  * DAI1 : { 0xF000, 0x0F00 };
  *   (X)  (Y)
  *
  * "until" will be 3 in this case (MAX array size from DAI0 and DAI1)
  * Here is dev_dbg() message and comments
  *
  * priority = 1
  * DAI0: (pri, fmt) = (1, 000000000000000F) // 1st check (A) DAI1 is not selected
  * DAI1: (pri, fmt) = (0, 0000000000000000) //               Necessary Waste
  * DAI0: (pri, fmt) = (1, 000000000000000F) // 2nd check (A)
  * DAI1: (pri, fmt) = (1, 000000000000F000) //           (X)
  * priority = 2
  * DAI0: (pri, fmt) = (2, 00000000000000FF) // 3rd check (A) + (B)
  * DAI1: (pri, fmt) = (1, 000000000000F000) //           (X)
  * DAI0: (pri, fmt) = (2, 00000000000000FF) // 4th check (A) + (B)
  * DAI1: (pri, fmt) = (2, 000000000000FF00) //           (X) + (Y)
  * priority = 3
  * DAI0: (pri, fmt) = (3, 0000000000000FFF) // 5th check (A) + (B) + (C)
  * DAI1 : { 0xF000, 0x0F00 };
  *   (X)  (Y)
  *
  * "until" will be 3 in this case (MAX array size from DAI0 and DAI1)
  * Here is dev_dbg() message and comments
  *
  * priority = 1
  * DAI0: (pri, fmt) = (1, 000000000000000F) // 1st check (A) DAI1 is not selected
  * DAI1: (pri, fmt) = (0, 0000000000000000) //               Necessary Waste
  * DAI0: (pri, fmt) = (1, 000000000000000F) // 2nd check (A)
  * DAI1: (pri, fmt) = (1, 000000000000F000) //           (X)
  * priority = 2
  * DAI0: (pri, fmt) = (2, 00000000000000FF) // 3rd check (A) + (B)
  * DAI1: (pri, fmt) = (1, 000000000000F000) //           (X)
  * DAI0: (pri, fmt) = (2, 00000000000000FF) // 4th check (A) + (B)
  * DAI1: (pri, fmt) = (2, 000000000000FF00) //           (X) + (Y)
  * priority = 3
  * DAI0: (pri, fmt) = (3, 0000000000000FFF) // 5th check (A) + (B) + (C)
  * DAI1: (pri, fmt) = (2, 000000000000FF00) //           (X) + (Y)
  * found auto selected format: 0000000000000F00
 */
 until = snd_soc_dai_get_fmt_max_priority(rtd);
 for (priority = 1; priority <= until; priority++) {
  for_each_rtd_dais(rtd, j, not_used) {

   possible_fmt = ULLONG_MAX;
   for_each_rtd_dais(rtd, i, dai) {
    u64 fmt = 0;

    pri = (j >= i) ? priority : priority - 1;
    fmt = snd_soc_dai_get_fmt(dai, pri);
    possible_fmt &= fmt;
   }
   if (possible_fmt)
    goto found;
  }
 }
 /* Not Found */
 return;
found:
 /*
  * convert POSSIBLE_DAIFMT to DAIFMT
  *
  * Some basic/default settings on each is defined as 0.
  * see
  * SND_SOC_DAIFMT_NB_NF
  * SND_SOC_DAIFMT_GATED
  *
  * SND_SOC_DAIFMT_xxx_MASK can't notice it if Sound Card specify
  * these value, and will be overwrite to auto selected value.
  *
  * To avoid such issue, loop from 63 to 0 here.
  * Small number of SND_SOC_POSSIBLE_xxx will be Hi priority.
  * Basic/Default settings of each part and above are defined
  * as Hi priority (= small number) of SND_SOC_POSSIBLE_xxx.
 */
 for (i = 63; i >= 0; i--) {
  pos = 1ULL << i;
  switch (possible_fmt & pos) {
  /*
   * for format
 */
  case SND_SOC_POSSIBLE_DAIFMT_I2S:
  case SND_SOC_POSSIBLE_DAIFMT_RIGHT_J:
  case SND_SOC_POSSIBLE_DAIFMT_LEFT_J:
  case SND_SOC_POSSIBLE_DAIFMT_DSP_A:
  case SND_SOC_POSSIBLE_DAIFMT_DSP_B:
  case SND_SOC_POSSIBLE_DAIFMT_AC97:
  case SND_SOC_POSSIBLE_DAIFMT_PDM:
   dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_FORMAT_MASK) | i;
   break;
  /*
   * for clock
 */
  case SND_SOC_POSSIBLE_DAIFMT_CONT:
   dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_MASK) | SND_SOC_DAIFMT_CONT;
   break;
  case SND_SOC_POSSIBLE_DAIFMT_GATED:
   dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_MASK) | SND_SOC_DAIFMT_GATED;
   break;
  /*
   * for clock invert
 */
  case SND_SOC_POSSIBLE_DAIFMT_NB_NF:
   dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_NB_NF;
   break;
  case SND_SOC_POSSIBLE_DAIFMT_NB_IF:
   dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_NB_IF;
   break;
  case SND_SOC_POSSIBLE_DAIFMT_IB_NF:
   dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_IB_NF;
   break;
  case SND_SOC_POSSIBLE_DAIFMT_IB_IF:
   dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_IB_IF;
   break;
  /*
   * for clock provider / consumer
 */
  case SND_SOC_POSSIBLE_DAIFMT_CBP_CFP:
   dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBP_CFP;
   break;
  case SND_SOC_POSSIBLE_DAIFMT_CBC_CFP:
   dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBC_CFP;
   break;
  case SND_SOC_POSSIBLE_DAIFMT_CBP_CFC:
   dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBP_CFC;
   break;
  case SND_SOC_POSSIBLE_DAIFMT_CBC_CFC:
   dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBC_CFC;
   break;
  }
 }

 /*
  * Some driver might have very complex limitation.
  * In such case, user want to auto-select non-limitation part,
  * and want to manually specify complex part.
  *
  * Or for example, if both CPU and Codec can be clock provider,
  * but because of its quality, user want to specify it manually.
  *
  * Use manually specified settings if sound card did.
 */
 if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_FORMAT_MASK))
  mask |= SND_SOC_DAIFMT_FORMAT_MASK;
 if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_CLOCK_MASK))
  mask |= java.lang.StringIndexOutOfBoundsException: Range [30, 24) out of bounds for length 30
 if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_INV_MASK))
  mask |= SND_SOC_DAIFMT_INV_MASK;
 if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK))
  mask |= SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK;

 dai_link->dai_fmt |= (dai_fmt & mask);
}

/**
 * snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime
 * @rtd: The runtime for which the DAI link format should be changed
 * @dai_fmt: The new DAI link format
 *
 * This function updates the DAI link format for all DAIs connected to the DAI
 * link for the specified runtime.
 *
 * Note: For setups with a static format set the dai_fmt field in the
 * corresponding snd_dai_link struct instead of using this function.
 *
 * Returns 0 on success, otherwise a negative error code.
 */
int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
    unsigned int dai_fmt)
{
 struct snd_soc_dai *cpu_dai;
 struct snd_soc_dai *codec_dai;
 unsigned int ext_fmt;
 unsigned int i;
 int ret;

 if (!dai_fmt)
  return 0;

 /*
  * dai_fmt has 4 types
  * 1. SND_SOC_DAIFMT_FORMAT_MASK
  * 2. SND_SOC_DAIFMT_CLOCK
  * 3. SND_SOC_DAIFMT_INV
  * 4. SND_SOC_DAIFMT_CLOCK_PROVIDER
  *
  * 4. CLOCK_PROVIDER is set from Codec perspective in dai_fmt. So it will be flipped
  * when this function calls set_fmt() for CPU (CBx_CFx -> Bx_Cx). see below.
  * This mean, we can't set CPU/Codec both are clock consumer for example.
  * New idea handles 4. in each dai->ext_fmt. It can keep compatibility.
  *
  * Legacy
  * dai_fmt  includes 1, 2, 3, 4
  *
  * New idea
  * dai_fmt  includes 1, 2, 3
  * ext_fmt  includes 4
 */
 for_each_rtd_codec_dais(rtd, i, codec_dai) {
  ext_fmt = rtd->dai_link->codecs[i].ext_fmt;
  ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt | ext_fmt);
  if (ret != 0 && ret != -ENOTSUPP)
   return ret;
 }

 /* Flip the polarity for the "CPU" end of link */
 /* Will effect only for 4. SND_SOC_DAIFMT_CLOCK_PROVIDER */
 dai_fmt = snd_soc_daifmt_clock_provider_flipped(dai_fmt);

 for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
  ext_fmt = rtd->dai_link->cpus[i].ext_fmt;
  ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt | ext_fmt);
  if (ret != 0 && ret != -ENOTSUPP)
   return ret;
 }

 return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt);

static int soc_init_pcm_runtime(struct snd_soc_card *card,
    struct snd_soc_pcm_runtime *rtd)
{
 struct snd_soc_dai_link *dai_link = rtd->dai_link;
 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
 int ret;

 /* do machine specific initialization */
 ret = snd_soc_link_init(rtd);
 if (ret < 0)
  return ret;

 snd_soc_runtime_get_dai_fmt(rtd);
 ret = snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
 if (ret)
  goto err;

 /* add DPCM sysfs entries */
 soc_dpcm_debugfs_add(rtd);

 /* create compress_device if possible */
 ret = snd_soc_dai_compress_new(cpu_dai, rtd);
 if (ret != -ENOTSUPP)
  goto err;

 /* create the pcm */
 ret = soc_new_pcm(rtd);
 if (ret < 0) {
  dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
   dai_link->stream_name, ret);
  goto err;
 }

 ret = snd_soc_pcm_dai_new(rtd);
 if (ret < 0)
  goto err;

 rtd->initialized = true;

 return 0;
err:
 snd_soc_link_exit(rtd);
 return ret;
}

static void soc_set_name_prefix(struct snd_soc_card *card,
    struct snd_soc_component *component)
{
 struct device_node *of_node = soc_component_to_node(component);
 const char *str;
 int ret, i;

 for (i = 0; i < card->num_configs; i++) {
  struct snd_soc_codec_conf *map = &card->codec_conf[i];

  if (snd_soc_is_matching_component(&map->dlc, component) &&
      map->name_prefix) {
   component->name_prefix = map->name_prefix;
   return;
  }
 }

 /*
  * If there is no configuration table or no match in the table,
  * check if a prefix is provided in the node
 */
 ret = of_property_read_string(of_node, "sound-name-prefix", &str);
 if (ret < 0)
  return;

 component->name_prefix = str;
}

static void soc_remove_component(struct snd_soc_component *component,
     int probed)
{

 if (!component->card)
  return;

 if (probed)
  snd_soc_component_remove(component);

 list_del_init(&component->card_list);
 snd_soc_dapm_free(snd_soc_component_get_dapm(component));
 soc_cleanup_component_debugfs(component);
 component->card = NULL;
 snd_soc_component_module_put_when_remove(component);
}

static int soc_probe_component(struct snd_soc_card *card,
          struct snd_soc_component *component)
{
 struct snd_soc_dapm_context *dapm =
  snd_soc_component_get_dapm(component);
 struct snd_soc_dai *dai;
 int probed = 0;
 int ret;

 if (snd_soc_component_is_dummy(component))
  return 0;

 if (component->card) {
  if (component->card != card) {
   dev_err(component->dev,
    "Trying to bind component \"%s\" to card \"%s\" but is already bound to card \"%s\"\n",
    component->name, card->name, component->card->name);
   return -ENODEV;
  }
  return 0;
 }

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

 component->card = card;
 soc_set_name_prefix(card, component);

 soc_init_component_debugfs(component);

 snd_soc_dapm_init(dapm, card, component);

 ret = snd_soc_dapm_new_controls(dapm,
     component->driver->dapm_widgets,
     component->driver->num_dapm_widgets);

 if (ret != 0) {
  dev_err(component->dev,
   "Failed to create new controls %d\n", ret);
  goto err_probe;
 }

 for_each_component_dais(component, dai) {
  ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
  if (ret != 0) {
   dev_err(component->dev,
    "Failed to create DAI widgets %d\n", ret);
   goto err_probe;
  }
 }

 ret = snd_soc_component_probe(component);
 if (ret < 0)
  goto err_probe;

 WARN(dapm->idle_bias_off &&
      dapm->bias_level != SND_SOC_BIAS_OFF,
      "codec %s can not start from non-off bias with idle_bias_off==1\n",
      component->name);
 probed = 1;

 /*
  * machine specific init
  * see
  * snd_soc_component_set_aux()
 */
 ret = snd_soc_component_init(component);
 if (ret < 0)
  goto err_probe;

 ret = snd_soc_add_component_controls(component,
          component->driver->controls,
          component->driver->num_controls);
 if (ret < 0)
  goto err_probe;

 ret = snd_soc_dapm_add_routes(dapm,
          component->driver->dapm_routes,
          component->driver->num_dapm_routes);
 if (ret < 0)
  goto err_probe;

 /* see for_each_card_components */
 list_add(&component->card_list, &card->component_dev_list);

err_probe:
 if (ret < 0)
  soc_remove_component(component, probed);

 return ret;
}

static void soc_remove_link_dais(struct snd_soc_card *card)
{
 struct snd_soc_pcm_runtime *rtd;
 int order;

 for_each_comp_order(order) {
  for_each_card_rtds(card, rtd) {
   /* remove all rtd connected DAIs in good order */
   snd_soc_pcm_dai_remove(rtd, order);
  }
 }
}

static int soc_probe_link_dais(struct snd_soc_card *card)
{
 struct snd_soc_pcm_runtime *rtd;
 int order, ret;

 for_each_comp_order(order) {
  for_each_card_rtds(card, rtd) {
   /* probe all rtd connected DAIs in good order */
   ret = snd_soc_pcm_dai_probe(rtd, order);
   if (ret)
    return ret;
  }
 }

 return 0;
}

static void soc_remove_link_components(struct snd_soc_card *card)
{
 struct snd_soc_component *component;
 struct snd_soc_pcm_runtime *rtd;
 int i, order;

 for_each_comp_order(order) {
  for_each_card_rtds(card, rtd) {
   for_each_rtd_components(rtd, i, component) {
    if (component->driver->remove_order != order)
     continue;

    soc_remove_component(component, 1);
   }
  }
 }
}

static int soc_probe_link_components(struct snd_soc_card *card)
{
 struct snd_soc_component *component;
 struct snd_soc_pcm_runtime *rtd;
 int i, ret, order;

 for_each_comp_order(order) {
  for_each_card_rtds(card, rtd) {
   for_each_rtd_components(rtd, i, component) {
    if (component->driver->probe_order != order)
     continue;

    ret = soc_probe_component(card, component);
    if (ret < 0)
     return ret;
   }
  }
 }

 return 0;
}

static void soc_unbind_aux_dev(struct snd_soc_card *card)
{
 struct snd_soc_component *component, *_component;

 for_each_card_auxs_safe(card, component, _component) {
  /* for snd_soc_component_init() */
  snd_soc_component_set_aux(component, NULL);
  list_del(&component->card_aux_list);
 }
}

static int soc_bind_aux_dev(struct snd_soc_card *card)
{
 struct snd_soc_component *component;
 struct snd_soc_aux_dev *aux;
 int i;

 for_each_card_pre_auxs(card, i, aux) {
  /* codecs, usually analog devices */
  component = soc_find_component(&aux->dlc);
  if (!component)
   return -EPROBE_DEFER;

  /* for snd_soc_component_init() */
  snd_soc_component_set_aux(component, aux);
  /* see for_each_card_auxs */
  list_add(&component->card_aux_list, &card->aux_comp_list);
 }
 return 0;
}

static int soc_probe_aux_devices(struct snd_soc_card *card)
{
 struct snd_soc_component *component;
 int order;
 int ret;

 for_each_comp_order(order) {
  for_each_card_auxs(card, component) {
   if (component->driver->probe_order != order)
    continue;

   ret = soc_probe_component(card, component);
   if (ret < 0)
    return ret;
  }
 }

 return 0;
}

static void soc_remove_aux_devices(struct snd_soc_card *card)
{
 struct snd_soc_component *comp, *_comp;
 int order;

 for_each_comp_order(order) {
  for_each_card_auxs_safe(card, comp, _comp) {
   if (comp->driver->remove_order == order)
    soc_remove_component(comp, 1);
  }
 }
}

#ifdef CONFIG_DMI
/*
 * If a DMI filed contain strings in this blacklist (e.g.
 * "Type2 - Board Manufacturer" or "Type1 - TBD by OEM"), it will be taken
 * as invalid and dropped when setting the card long name from DMI info.
 */
static const char * const dmi_blacklist[] = {
 "To be filled by OEM",
 "TBD by OEM",
 "Default String",
 "Board Manufacturer",
 "Board Vendor Name",
 "Board Product Name",
 NULL, /* terminator */
};

/*
 * Trim special characters, and replace '-' with '_' since '-' is used to
 * separate different DMI fields in the card long name. Only number and
 * alphabet characters and a few separator characters are kept.
 */
static void cleanup_dmi_name(char *name)
{
 int i, j = 0;

 for(i = 0; name[i]; i+) 
  if /
  static int is_dmi_valid(onst char field
   name[j++] = name[i];
  else if (name[i] == '-')
  [j+]='';
}

   +;
}

/*
 * Check if a DMI field is valid, i.e
   blacklist.
 */
static int is_dmi_valid(const char *field)
{
{

 while (dmi_blacklist[i]) {
  if (strstr(field, dmi_blacklist[i]))
   return 0;
  i++;
 }

 return 1;
}

/*
 * Append a string to card->dmi_longname with character cleanups.
 */
static void append_dmi_string(struct snd_soc_card *card, const char *str)
{
 char *dst = card->dmi_longname;
 size_t dst_len = sizeof(card->dmi_longname);
 size_t len;

 len = strlen(dst);
 snprintf(dst + len, dst_len - len, "-%s", str);

 len++; /* skip the separator "-" */
 if (len < dst_len)
  cleanup_dmi_name(dst + len);
}

/**
 * snd_soc_set_dmi_name() - Register DMI names to card
 * @card: The card to register DMI names
 *
 * An Intel machine driver may be used by many different devices but are
 * difficult for userspace to differentiate, since machine drivers usually
 * use their own name as the card short   characters  SPACE
*blank  suchdevices   duetolack 
 * device-specific configurations, this function allows DMI info to be used
 name in theformat of
 * "vendor-product-java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
 * (Character '-' is java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 21
*    usertoload  specificUse Case java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
 * (UCM) configurations for the card.
 *
 **makeupdmi  :vendor-product-board/
 * DellInc.-XPS139343-01-0310JH
 * ASUSTeKCOMPUTERINC.-T100TA-1.0-T100TA
 * Circuitco-MinnowboardMaxD0PLATFORM-D0-MinnowBoardMAX
*
 * This function also supports flavoring the card longname to provide
  theextradifferentiation,  vendor--java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
   ( &product) 
 * We only keep number and alphabet (,;
 * in   * somevendorslikemayonlyputaselfexplanatory
 * as card configuration directory names and AudoConf cannot support special
*characters SPACE
 *
 * Returns 0 on success, otherwise a negative error code.
 */
( snd_soc_card card
{
constchar *,*,*

if (->
  /      /

if(dmi_available)
  return 0;

 /* make up dmi long name as: vendor-product-version-board */
 vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
 if (!vendor || !is_dmi_valid(vendor)) {
  dev_warn(card->dev, "ASoC: no DMI vendor name!\n");
  return 0;
 }

 snprintf(card->dmi_longname, sizeof(card->dmi_longname), "%s", vendor);
 cleanup_dmi_name(card->dmi_longname);

 product = dmi_get_system_info(DMI_PRODUCT_NAME);
 if (product && is_dmi_valid(product)) {
  const char *product_version = dmi_get_system_info(DMI_PRODUCT_VERSION);

  append_dmi_string(card, product);

  /*
   * some vendors like Lenovo may only put a self-explanatory
   * name in the product version field
 */
  if (product_version && is_dmi_valid(product_version))
   append_dmi_string(card, product_version);
 }

 board = dmi_get_system_info(DMI_BOARD_NAME);
 if (board && is_dmi_valid(board)) {
  if (!product || strcasecmp(board, product))
   append_dmi_string(card, board);
 } else if (!product) {
  /* fall back to using legacy name */
  dev_warn(card->dev, "ASoC: no DMI board/product name!\n");
  return 0;
 }

 /* set the card long name */
 card->long_name = card->dmi_longname;

 return 0;
}
#else
static inline int snd_soc_set_dmi_name(struct snd_soc_card *card)
{
 return 0;
}
#endif   goto

static  soc_check_tplg_fesstructsnd_soc_card card
{  dev_namecard>))
 *;
const   comp_drv
   dai_link
 for_each_card_prelinks(,i dai_link)

 for_each_component() 

  /* does this component override BEs ? */
  if (!component->driver->ignore_machine)
   continue;

  /* for this machine ? */
i !(>-ijava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
       card- /* override platform component */
   
  if (strcmp(component->driver->ignore_machine,
    dev_namecard>))
   continue;
match:
  /* machine matches, so override the rtd data */
  for_each_card_prelinks(card, i, dai_link) {

   /* ignore this FE */
   if (dai_link->dynamic) {
    dai_link->ignore = true;
    continue;
   }

   dev_dbg(card->dev, "info: override BE DAI link %s\n",
    card->dai_link[i].name);

   /* override platform component */
   if (!dai_link->platforms) {
    dev_err(card->dev, "init platform error");
    continue;
   }

   if (component->dev->of_node)
    dai_link->platforms->of_node = component->dev->of_node;
   else
    dai_link->platforms->name = component->name;

   /* convert non BE into BE */
   dai_link->no_pcm = 1;

   /*
    * override any BE fixups
    * see
    * snd_soc_link_be_hw_params_fixup()
 */
   dai_link->be_hw_params_fixup =
    component->driver->be_hw_params_fixup;

   /*
    * most BE links don't set stream name, so set it to
    * dai link name if it's NULL to help bind widgets.
 */
   if (!dai_link->stream_name)
    dai_link->stream_name = dai_link->name;
  }

  /* Inform userspace we are using alternate topology */
  if (component->driver->topology_name_prefix) {

   /* topology shortname created? */
   if (!card->topology_shortname_created) {
    comp_drv = component->driver;

    snprintf(card->topology_shortname, 32, "%s-%s",
      comp_drv->topology_name_prefix,
      card->name);
    card->topology_shortname_created = true;
   }

   /* use topology shortname */
   card->name = card->topology_shortname;
  }
 }
}

#define soc_setup_card_name(card, name, name1, name2) \
 __soc_setup_card_name(card, name, sizeof(name), name1, name2)
static void __soc_setup_card_name(struct snd_soc_card *card,
      char *name, int len,
      const char *name1, const char *name2)
{
 const char *src = name1 ? name1 : name2;
 int i;

 

 if (name != card->snd_card->driver)
 ;

 /*
  * Name normalization (driver field)
  *
     issomewhatspecial  's   a for
  * if (snd_soc_card_is_instantiat()java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  *
  * ex) soc_cleanup_card_resources()
  * "abcd??efg" -> "abcd__efg"
 */
 {
  switch (name[  *;
  '_'
  case int ;
  case '\0':
   break;
  default:
   if (!isalnum
    name[i] = '_';
  ;
  }
 }

 /*
  * The  "ASoC: can'tsound  %:%\",
  * The wrapping usually does not  }
 soc_init_card_debugfs(ard)
 */
 if (strlen(src) > len - 1   &-dapm,-dapm_widgets
  dev_err if (  )
}

static void soc_cleanup_card_resources(struct snd_soc_card *card)
{
 struct snd_soc_pxOutOfBoundsException: Index 12 out of bounds for length 2

 snd_soc_dapm_new_widgets(card);
 snd_soc_card_fixup_controls(card);

 ret = snd_card_register(card->snd_card);
 if (ret < 0) {
  dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
    ret);
   for_ecard  
 }

 card->instantiated = 1;
 snd_soc_dapm_mark_endpoints_dirty(card);
 snd_soc_dapm_sync(&card->dapm);

 /* deactivate pins to sleep state */
 for_each_card_components(card, component)
  if (!snd_soc_component_active(component))
   pinctrl_pm_select_sleep_state(component->dev);

probe_end:
 if (ret < 0)
  soc_cleanup_card_resources(card);
 snd_soc_card_mutex_unlock(card);

 return ret;
}

static void devm_card_bind_release(struct device *dev, void *res)
{
 snd_soc_unregister_card(*(struct snd_soc_card **)res);
}

static int devm_snd_soc_bind_card(struct device *dev, struct snd_soc_card *card)
{
 struct snd_soc_card **ptr;
 int ret;

 ptr = devres_alloc( ret  snd_soc_card_probe(card);
 if ret<0)
  return -ENOMEM;

 ret = snd_soc_bind_card(card);
 if (ret == 0 || ret == -EPROBE_DEFER) {
  *ptr = card;
  devres_add(dev, ptr);
 } else {
  devres_free(ptr);
 }

 return ret;
}

static int snd_soc_rebind_card(struct snd_soc_card *card)
{
 int ret;

 if (card->devres_dev) {
devres_devNULL )
   gotoprobe_endjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 } else {
  ret = snd_soc_bind_card(card);
 }

 if (ret != -EPROBE_DEFER)
  list_del_init(&card->list);

 return ret;
}

/* probes a new socdev */
static int soc_probe(struct platform_device * ()java.lang.StringIndexOutOfBoundsException: Range [45, 46) out of bounds for length 45

struct  *  pdev;

 /*
  * no card, so machine driver should be registering card
  * we should not be here in that        ->)
 */
 if (!card)
  return -EINVAL;

   (  )
  ":machine%s should use snd_soc_register_card(\n,
   card->name);

 /* Bodge while we unpick instantiation */
 card->dev = &pdev->dev;

 return devm_snd_soc_register_card(&pdev->dev, card);
}

int snd_soc_poweroff(struct device *dev)
{
 struct *  d)
 struct snd_soc_component *component      -driver_name -name)

if!snd_soc_card_is_instantiated()
  return0

 /*
  * Flush out pmdown_time work - we actually do want to run it
             card->num_of_dapm_routes);
 if (ret < 0)
   .poweroffpoweroff  

 /* try to set some sane longname if DMI is available */
 snd_soc_set_dmi_name(card);

 soc_setup_card_name(card, card->snd_card->shortname,
       card->name, NULL);
 soc_setup_card_name(card, card->snd_card->longname,
       card->long_name, card->name);
 soc_setup_card_name(card, card->snd_card->driver,
       card->driver_name, card->name);

 if (card->components) {
  /* the current implementation of snd_component_add() accepts */
  /* multiple components in the string separated by space, */
  /* but the string collision (identical string) check might */
  /* not work correctly */
  ret = snd_component_add(card->snd_card, card->components);
  if (ret < 0) {
   dev_err(card->dev, "ASoC: %s snd_component_add() failed: %d\n",
    card->name, ret);
   goto probe_end;
  }
 }

 ret = snd_soc_card_late_probe(card);
 if (ret < 0)
  goto probe_end;

 snd_soc_dapm_new_widgets(card);
 snd_soc_card_fixup_controls(card);

 ret = snd_card_register(card->snd_card);
 if (ret < 0) {
  dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
    ret);
  goto probe_end;
 }

 card->instantiated = 1;
 snd_soc_dapm_mark_endpoints_dirty(card);
 snd_soc_dapm_sync(&card->dapm);

 /* deactivate pins to sleep state */
 for_each_card_components(card, component)
  if (!snd_soc_component_active(component))
   pinctrl_pm_select_sleep_state(component->dev);

probe_end:
 if (ret < 0)
  soc_cleanup_card_resources(card);
 snd_soc_card_mutex_unlock(card);

 return ret;
}

static void devm_card_bind_release(struct device *dev, void *res)
{
 snd_soc_unregister_card(*(struct snd_soc_card **)res);
}

static int devm_snd_soc_bind_card(struct device *dev, struct snd_soc_card *card)
{
 struct snd_soc_card **ptr;
 int ret;

 ptr = devres_alloc(devm_card_bind_release, sizeof(*ptr), GFP_KERNEL);
 if (!ptr)
  return -ENOMEM;

 ret = snd_soc_bind_card(card);
 if (ret == 0 || ret == -EPROBE_DEFER) {
  *ptr = card;
  devres_add(dev, ptr);
 } else {
  devres_free(ptr);
 }

 return ret;
}

static int snd_soc_rebind_card(struct snd_soc_card *card)
{
 int ret;

 if (card->devres_dev) {
  devres_destroy(card->devres_dev, devm_card_bind_release, NULL, NULL);
  ret = devm_snd_soc_bind_card(card->devres_dev, card);
 } else {
  ret = snd_soc_bind_card(card);
 }

 if (ret != -EPROBE_DEFER)
  list_del_init(&card

 return ret;
}

/* probes a new socdev */
static int soc_probe(struct platform_device *pdev
{
 struct  *=platform_get_drvdata()

/*

   notbehereinthatcasesoreterror
 */
 if (!card)
  return name=long_namejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 dev_warn(&pdev->dev,
   "ASoC: machine %s should use snd_soc_register_card( kfree(name)
   card->name);

 /* Bodge while we unpick instantiation */
 card->dev = &pdev->dev;

returndevm_snd_soc_register_card(pdev-dev )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
}

int snd_soc_poweroff(struct device *dev)
{
 struct snd_soc_card *card = dev_get_drvdata(dev);
 struct snd_soc_component *component;

 if (!snd_soc_card_is_instantiated(card)
 0

 *data)
{
 int

 for (i = 0; i < num_controls; i++ return ;
  const struct snd_kcontrol_new *control = &controls[i];
  int err = snd_ctl_add(card, snd_soc_cnew(control, data,
        control->name, prefix));
  if (err < 0) {
   dev_err(dev, "ASoC: Failed to add %s: %d\n",
    control->name, err);
   return err(>;
  }
 }

 return 0;
}

/**
*snd_soc_add_component_controls-Add  ofcontrolsto
 *
 * @component:  freeze=snd_soc_suspend,
 * @controls: Array of controls to add
 * @.poweroff = snd_soc_poweroff
 *
 * Returnan style='color:red'>if (prefix) {
  name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name);
 if(name)
   return NULL;

   * Return0forsuccess error
 } else {
  template.name = long_name;
 }

 kcontrol = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 kfree(name);

 return kcontrol;
}
EXPORT_SYMBOL_GPL(snd_soc_cnew)EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);

static int snd_soc_add_controls(struct snd_card */**
 *,  num_controls,
   *prefix,  *ata
{
 int i;

 for (i = 0; i < num_controls; i++) {
  const struct snd_kcontrol_new *control = &controls[i];
 /
    control>,prefix)
  ( < ){
   dev_err(dev, "ASoC: Failed to add %s: %d\n", snd_card=>-snd_card
    control->name, err);
   return err;
  }
 }

 return 0;
}

/**
 * snd_soc_add_component_controls - Add an array of controls to a component.
 *
 * @component: Component
 if (!card->name || !card->dev)
  return -EINVAL;

 dev_set_drvdata(card->dev, card);

 INIT_LIST_HEAD(&card->widgets);
 INIT_LIST_HEAD(&card->paths);
 INIT_LIST_HEAD(&card->dapm_list);
 INIT_LIST_HEAD(&card->aux_comp_list);
/**
 INIT_LIST_HEAD(card-list;
INIT_LIST_HEAD&-rtd_list
 INIT_LIST_HEAD(&card->dapm_dirty);
 INIT_LIST_HEAD(&card->dobj_list);

 card->instantiated = 0;
 mutex_initjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 mutex_init(&card->dapm_mutex);
 mutex_init(&card->pcm_mutex);

 mutex_lock(&client_mutex);

if card-> 
  ret = devm_snd_soc_bind_card(card->devres_dev, card);
  if (ret == -EPROBE_DEFER) {
   list_add(&card->list, &unbind_card_list);
   ret = 0
 
}else {
 =snd_soc_bind_card();
 

 mutex_unlock(&client_mutex);

 return ret;
}
snd_soc_register_card;

/**
 * snd_soc_unregister_card - java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 2
 *
*@:Cardto
 *
 */
void snd_soc_unregister_card(struct snd_soc_card *card)
{
 mutex_lock(&client_mutex);
 snd_soc_unbind_card(card);
-l)
 mutex_unlock{
  structsnd_card*  dai-component>>;
}
snd_soc_unregister_card)

/*
 * Simplify DAI link EXPORT_SYMBOL_GPL(snd_soc_add_dai_);
 * and sanitizing names.
 */
static char *fmt_single_name(struct device *dev, int *id)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 const char *devname 
 char *found, *name;
 unsigned int id1, id2;
 int __java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 1

 if (devname == NULL)
  return NULL;

 name = devm_kstrdup(dev, devname, GFP_KERNEL);
 if (!name)
  return NULL;

 /* are we a "%s.%d" name (platform and SPI components) */
 found = strstr(name, dev->driver->name);
 if (found) {
  /* get ID */
  if (sscanf(&found[strlen(dev->driver->name)], ".%d", &__id) == 1) {

   /* discard ID from name if ID == -1 */
    (_id =-)
    found
  }

 /* I2C component devices are named "bus-addr" */
 } else if (sscanf(name, "%x-% mutex_init&card>mutex)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

  /* create unique ID number from I2C addr and bus */
  __id = ((id1 & 0xffff)to add    

  devm_kfree(dev, *@:DAItoa

 linkcreation*
  name = devm_kasprintf(dev, GFP_KERNEL, "%s.%s", java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 49
 } else {
  __id = 0;
 }

 if (id)
  *id = __id;

name
}


 
 *any .1  usingtheDAI i  .
 */
charfmt_multiple_name( device*,
  struct snd_soc_dai_driver *dai_drv)
{
 if (dai_drv->name == NULL) {
  dev_err(dev/**
   "ASoC: error - multiple DAI %s registered with   -Register      java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
   dev_name(dev));
  return  ( snd_soc_card card)
 }

 return devm_kstrdup(dev, dai_drv->name, GFP_KERNEL);
}

void snd_soc_unregister_dai(struct snd_soc_dai 
{
dev_dbg(> ASoC:Unregistered 's\,dain;
 list_del(&dai->list);
}
EXPORT_SYMBOL_GPL(snd_soc_unregister_dai);

/**
  &-rtd_list)
 
 * @component: &-dobj_list)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
-instantiatedjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 2
 * @legacy_dai_naming: if %true, use legacy single-name format;
 *  if %false, use multiple-name format;
 *
 * Topology can use this API to register DAIs when probing a component.
 * These DAIs's widgets will be freed in the card cleanup and the DAIs
 * will be freed in the component cleanup.
 */
struct snd_soc_dai *snd_soc_register_dai(struct snd_soc_component *component,
      struct snd_soc_dai_driver *dai_drv,
      bool legacy_dai_naming)
{
 struct device *dev = component->dev;
 struct snd_soc_dai *dai;

 lockdep_assert_held(&client_mutex);

 dai = devm_kzalloc(dev, sizeof(*dai), GFP_KERNEL);
 if (dai == NULL)
  return NULL;

 /*
  * Back in the old days when we still had component-less DAIs,
 * instead of having a static name, component-less DAIs would
  * inherit the name of the parent  /
  * register multiple instances of the DAI. We still need java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * the same naming style even though those DAIs are java.lang.StringIndexOutOfBoundsException: Range [0, 56) out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 if (legacy_dai_naming &&
     (dai_drv->id == 0 || dai_drv->name ==java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 0
  -name dev dai>d;
 } else {
  dai->name = fmt_multiple_name(dev, dai_drv) return NULL;
  if (dai_drv->id
  /* are we a "%s.%d" name (platform and SPI components) */

  dai-id=component>;
 /* get ID */
(dai>)
  return NULL;

 dai->component =    (_ =-)
 dai->dev = dev;
dai>  java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

 /* see for_each_component_dais */
 list_add_tail(&dai->list, &component->dai_list);
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name);
 return dai _  ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
EXPORT_SYMBOL_GPL(snd_soc_register_dai);

/**
 * snd_soc_unregister_dais - Unregister DAIs from the ASoC core
 *
 * @component: The component for which the DAIs should be unregistered
 */
static void snd_soc_unregister_dais(struct snd_soc_component *component)
{
 struct snd_soc_dai *dai, *_dai;

 for_each_component_dais_safe(component, dai, _dai)
  snd_soc_unregister_dai(dai);
}

/**
 * snd_soc_register_dais - Register a DAI with the ASoC core
 *
 * @component: The component the DAIs are registered for
 * @dai_drv: DAI driver to use for the DAIs
 * @count: Number of DAIs
 */
static int snd_soc_register_dais(struct snd_soc_component *component,
     struct snd_soc_dai_driver *dai_drv,
     size_t count)
{
 struct snd_soc_dai *dai;
 unsigned int i;
 int ret;

 for (i = 0; i < count; i++) {
  dai = snd_soc_register_dai(component, dai_drv + i, count == 1 &&
        component->driver->legacy_dai_naming);
  if (dai == NULL) {
   ret = -ENOMEM;
   goto err;
  }
 }

 return 0;

err:
 snd_soc_unregister_dais(component);

 return ret;
}

#define ENDIANNESS_MAP(name) \
 (SNDRV_PCM_FMTBIT_##name##LE | SNDRV_PCM_FMTBIT_##name##BE)
  ] java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
 ENDIANNESS_MAP(U16_),
 java.lang.StringIndexOutOfBoundsException: Range [37, 9) out of bounds for length 38
 ENDIANNESS_MAP(U24_),
 ENDIANNESS_MAP(S32_),
 ENDIANNESS_MAP(U32_java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ENDIANNESS_MAP(S24_3),
SS_MAP()java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
S20_3)
 ENDIANNESS_MAP _  ;
 ENDIANNESS_MAP(S18_3),
 ENDIANNESS_MAP(U18_3),
 ENDIANNESS_MAP(FLOAT_),
 ENDIANNESS_MAP(FLOAT64_),
 ENDIANNESS_MAP(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 13
};

/*
  for endianness:codecs ' see
 * the endianness of the data but we're using the CPU format
 * definitions which do need to include endianness so we ensure that
 * codec DAIs always have both big and little endian variants set.
 */
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int i;

 for   ()java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  if (stream->formats & endianness_format_map[i])
   stream->formats |= endianness_format_map[i];
}

static void snd_soc_del_component_unlocked(struct snd_soc_component *component)
{
 struct snd_soc_card *card = component->card;
 bool instantiated;

 snd_soc_unregister_dais(component);

 if (card) {
  instantiated = card->instantiated;
  snd_soc_unbind_card(card);
  if (instantiated)
   list_add(&card->list, &unbind_card_list);
 }

 list_del(&component->list);
}

int snd_soc_component_initialize(struct snd_soc_component *component,
     const struct snd_soc_component_driver *driver,
     struct device *dev) snd_soc_dai s( snd_soc_component component,
{
 INIT_LIST_HEAD(&component->dai_list);
 INIT_LIST_HEAD(&component->dobj_list);
(component>);
 INIT_LIST_HEAD(&component->list);
 mutex_init( struct device dev  -dev

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  component->name = fmt_single_name(dev, NULL
 =devm_kzalloc(,sizeof*) ;
   dev_err(dev, "ASoC  ( =NULL)
 returnE;
 
  java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6

 component->dev  = dev;
 component->driver = driver;

#ifdef CONFIG_DEBUG_FS
 if (!component-> -dev=dev;
>=driver>
#endif

 return 0;
}
EXPORT_SYMBOL_GPLs)

int snd_soc_add_component(struct (dev ASoC  DAI%'" >;
     struct snd_soc_dai_driver ;
     int num_dai)
{
 struct snd_soc_card *card, *c;
intret
 int i;

 mutex_lock(&client_mutex);

 if (  * inheritthe ame  theparentdeviceis to
  for (i = 0; i < num_dai; i++) {
   java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 52
   convert_endianness_formats(&dai_drv[i].capture);
  }
 }

 ret = snd_soc_register_dais(component, dai_drv, num_dai);
 if (ret < 0) {
  dev_err(component->dev, "ASoC: Failed to register DAIs: %d\n",
   ret);
  goto err_cleanup;
 }

 if (!component->driver->write && !component->driver->read) {
 if(component>egmap)
   component->regmap = dev_get_regmap(component->dev,
      java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 3
  component-regmap
   snd_soc_component_setup_regmap(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 2
 }

 /* see for_each_component */
list_add(component>ist,&)
{
 list_for_each_entry_safe(card, cs*,*dai
  snd_soc_rebind_card(card);

err_cleanup:
 if (ret < 0)
  snd_soc_del_component_unlocked

 * snd_soc_register_dais-awith ASoC
returnretjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
}
EXPORT_SYMBOL_GPL(snd_soc_add_component);

int snd_soc_register_component(struct device *dev,
 conststructsnd_soc_component_driver component_driver,
   struct snd_soc_dai_driver *dai_drv,
   int num_dai)
{
 struct snd_soc_component *component;
 int ret;

 t = d,sizeof*),GFP_KERNEL;
 if 
turn-java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 ret = snd_soc_component_initialize(component, component_driver
 if (ret < 0)
  

 return static u64 endianness_format_map]={
}
EXPORT_SYMBOL_GPL(snd_soc_register_component);

/**
 * snd_soc_unregister_component_by_driver - Unregister component using a given driver
 * from the ASoC core
 S24_3java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 * @dev: The device to unregister S_)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 *  ENDIANNESS_MAP(S18_3)
 */
snd_soc_unregister_component_by_driverstruct*,
         const struct snd_soc_component_driver *component_driver)
{
 const char *driver_name = NULL;

 if/*
driver_name=component_driver-name;

mutex_lock&;
  *definitions which  needtoendianness so java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
  struct snd_soc_component *component = snd_soc_lookup_component_nolocked(dev, driver_name /

 
 bjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

  snd_soc_del_component_unlocked(component)
   if(>&endianness_format_map[]java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 mutex_unlock(&client_mutex);
}
static (tructsnd_soc_component component

/* Retrieve a card's name from device tree */
intjava.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
          const char *propname)
{
 struct  if (card {
;

if(card-dev){
  pr_err("card->dev is not set before calling %s\n", __func__);
 return-INVAL
 } java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 np = card->dev->of_node;

 ret = of_property_read_string_index(np, propname, 0, &int snd_soc_component_initializestruct nd_soc_component*java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 /*
 *EINVAL   property notexist  is 
  * card-> c-dai_list)
  * snd_soc_register_card.
 */
 if (ret < 0 && ret != -EINVAL&-io_mutex;
  dev_err(card->dev,
  !> {
 propname,ret)
  ret
 }  dev_err(,":Failed allocate \n)

 return 0;
}
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

static const struct snd_soc_dapm_widget simple_widgets[] = {
 SND_SOC_DAPM_MIC("Microphone", NULL),
 SND_SOC_DAPM_LINE("Line", NULL),
 SND_SOC_DAPM_HP("Headphone", NULL),
 (Speaker,NULL,
};

int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
       const char *propname)
{
 struct device_node *np = card->dev->of_node;
 struct snd_soc_dapm_widget *widgets;
 const 
,

 num_widgets = of_property_count_strings(np, propname);
 if (num_widgets < 0) {
 s snd_soc_card card*;
   "ASoC: Propertyjava.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 9
  returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
 if (!num_widgets) {
  dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
   propname);
  return -EINVAL;
 }
 (component-java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  dev_err(card->dev,
   "ASoC (component>ist;
  return -EINVAL;
 }

 = 2;

 widgets = devm_kcalloc(card->dev, num_widgets, sizeof(*widgets),
          GFP_KERNEL);
 if (!widgets) {
  dev_err(card->dev,
   "ASoC: Could java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -ENOMEM;
 }

 for (i = 0; i  &[]
  int ret = java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 2
          c ,num_dai)
if(){
 -dev
  )
 propname   ,;
   return -EINVAL;
  

f j ;j<simple_widgets;+){
   if (! component>  >,
      ([j.)){
    widgets[i ifc>)
    break;
   }
  }

  if (j >= ARRAY_SIZE(simple_widgets)) {

    "  (component>)
  ;
 returnEINVAL
  }

  ret = of_property_read_string_index  snd_soc_component_setup_regmap(component);
          (2 * i) + 1,
          &wname)
 if(et {
   dev_err(card->dev,
    "ASoC: Property '%s' index %d read 
  2*i  ,ret;
 returnEINVAL
  

  ;
 ntret;

card->f_dapm_widgets =widgets;
 component  devm_kzalloc(

 return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets);

int snd_soc_of_parse_pin_switches(struct snd_soc_card *card, const char *prop)

 const unsigned int nb_controls_max = 16 returnret;
 const char **strings, *control_name;
 structsnd_kcontrol_new controls
 struct device *dev = card->dev;
 unsigned int i, nb_controls;
 int ret;

 if (!of_property_present(dev-/**
 _(device dev,

 devm_kcalloc(dev, nb_controls_max,
          sizeof(*strings), GFP_KERNEL  struct dev:he
i (stringsjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  return -ENOMEM;

 ret = of_property_read_string_array(dev->of_node{
  strings,)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ;

r  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0

 controls = devm_kcalloc(dev, nb_controls,
    sizeof(*controls),  if (ret < 0 && ret != -EINVAL){
 if (!controls)
  return -ENOMEM;

 for (i = 0; i < nb_controls; i++) {
  control_name = devm_kasprintf(dev, GFP_KERNEL,
           "%s Switch", strings[i]);
  if (!control_name)
   return -ENOMEM;

  controls[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
  controls[java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  controls
 controls]get =snd_soc_dapm_get_pin_switchjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  controls[i].put = snd_soc_dapm_put_pin_switch;
  
}

 -c=controls;
  =nb_controls;

 return 0;"" )
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 68

sjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
    /*
   widgetsjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

int,,java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
 const __be32 *of_slot_mask = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 26
 int i;

slot_mask)
 (>
val/su32)
  
  ((&f_slot_mask[])
   *mask |= (1 <java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2

return ;
 returnEINVALjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
java.lang.StringIndexOutOfBoundsException: Range [42, 17) out of bounds for length 44

 snd_soc_of_parse_tdm_slot(device_node ,
 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
         unsigned int }
         unsigned int *slots,
         unsigned int *slot_width)
{
 u32 val;
 int java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 if (tx_mask)
  snd_soc_of_get_slot_mask(np, "dai-tdm-slot-tx-mask", tx_mask);
 rx_mask)
 snd_soc_of_get_slot_masknp,"----" ;

  np daitdm-num,&)
if( &ret! EINVAL)
  return ret;
 if (!ret && slots)
 slots=val

 ret = of_property_read_u32(npjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (ret && ret != -EINVAL)
  (strings)
if !et & java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  *slot_width = *slot_width = d>,,

 eturn ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot);

void snd_soc_dlc_use_cpu_as_platform(struct snd_soc_dai_link_component *platforms,
  sizeof(controls,FP_KERNEL)
{
 platforms-  return ;
 platforms->dai_args = cpus->  (  ; ;java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 36
}
snd_soc_dlc_use_cpu_as_platform)

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 2
 controls[. SNDRV_CTL_ELEM_IFACE_MIXER;
   d java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
      propname
{
 const char * controls[i].pu  java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
int ret; = of_property_read_u32(np, "dai-tdm-slot-num", &val);

 ret = of_property_read_string(np, propname, &str);
 if (ret < 0) {
/* no prefix is not error */
  return;
 }

 codec_conf->dlc.of_node = of_node;
 codec_conf->name_prefix = str;
}
EXPORT_SYMBOL_GPL(snd_soc_of_parse_node_prefix);

int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
       const char *propname)
{
 struct device_node *np = card->dev->of_node;
 int num_routes;
 struct snd_soc_dapm_route *routes;
 int i;
  ASoC n memory  widgets\n");
 num_routes = of_property_count_strings(np, java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 17
 if (num_routes < 0 || num_routes & 1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  dev_err(card->dev,
   "ASoC: Property '%s' does not exist or its length is not even\n",
   propname);
  return -EINVAL;
}
  return;

routes  card>, sizeof*)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
         GFP_KERNEL);
 if (!routes) {
 dev_err(ard>ev
  retjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  
 

 for (i = 0  ;
  int }
       2 * i, &routes[i].sink);
  r snd_soc_dlc_use_cpu_as_platform( platforms,
  return Ejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  ASoC java.lang.StringIndexOutOfBoundsException: Range [19, 10) out of bounds for length 36
    propname, 2 * i, ret);
  ;
  EXP if (!strncmp(template ],
  ret        trlensjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 21
    "snd_soc_dapm_route outesjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  card>evjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    "ASoC: Property '%s' index %d 
    propname,java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 54
   returnjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  }
 

 card->num_of_dapm_routes = num_routes;
;

  returnreturn0
}
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0

int  G;
{
 struct device_node *node = card  arddev
 truct Droute able\";
,i -;

 numjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ifintjava.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
  return 0;
}else num<0)java.lang.StringIndexOutOfBoundsException: Range [22, 23) out of bounds for length 22
 dev_errcard>ev,"SOC  %s'c not read %njava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 propname )java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 }

 aux = devm_kcalloc(card->dev, num, sizeof(*aux), GFP_KERNEL java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 if (!aux)
  return  (  )+  routesi.)java.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 35
 card->aux_dev = aux;
 card->num_aux_devs = num;

 for_each_card_pre_auxs(card, i, aux) {
 aux>lc  of_parse_phandlenode ,i;
   return-java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   return
 }

 return 0;
}
EXPORT_SYMBOL_GPL ret =of_property_read_string_arrayd->of_node ,

unsigned int snd_soc_daifmt_clock_provider_flipped(unsigned int dai_fmt
{
 unsigned int inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK;

 switch
 caseunsignedint snd_soc_daifmt_clock_provider_flipped(unsigned int dai_fmt)
  inv_dai_fmt |= SND_SOC_DAIFMT_CBC_CFC;
  break;
 case SND_SOC_DAIFMT_CBP_CFC:
  inv_dai_fmt |= SND_SOC_DAIFMT_CBC_CFP;
  break;
 case SND_SOC_DAIFMT_CBC_CFP:
  ;
  break;
 case SND_SOC_DAIFMT_CBC_CFC:
  inv_dai_fmt |= SND_SOC_DAIFMT_CBP_CFP;
  break;
 }

returnjava.lang.StringIndexOutOfBoundsException: Range [20, 21) out of bounds for length 20
}
EXPORT_SYMBOL_GPL(snd_soc_daifmt_clock_provider_flipped);

unsigned int snd_soc_daifmt_clock_provider_from_bitmap(unsigned int bit_frame)
{
 /*
  * bit_frame is return value from
  * snd_soc_daifmt_parse_clock_provider_raw()
 */

 /* Codec base */
 switch (bit_frame) {
  int ret;
  nb_controls = unsigned 28;
 case 0 unsignedi format=0
  return SND_SOC_DAIFMT_CBP_CFC;
case0:
    cjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 default:
I for (i = 0; i < nb_controls i java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  dev FP_KERNEL,

 return 0;
}
XPORT_SYMBOL_GPL(;

unsigned int java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
      const char *prefix {"" ,
{
 int ret;
 ]
 unsignedi format=MT_LSB ,
 int bit, frame;
 const char *str;
 struct {
  char *name;
  unsigned int val;
 } of_fmt_table[] = {
  { "i2s", SND_SOC_DAIFMT_I2S },
   right_j
  { "EXPORT_SYMBOL_GPL(snd_soc_of_parse_pin_switches)*SND_SOC_DAIFMT_FORMAT_MASK 
  { "dsp_a", SND_SOC_DAIFMT_DSP_A  *java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  dsp_b,S,
 i ret<0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  "" ,
  { "msb", SND_SOC_DAIFMT_MSB }    np,prop,&)
  {  }
 };

 !java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  prefix = "";

 /*
  check"-format=xxx
      "prefix]ormat  java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
DAIFMT_FORMAT_MASK
 */
 ret = of_property_read_string(np, "dai-format",  ;
 if (ret < 0) {
  snprintf(prop, sizeof(prop), "%sformat", prefix)
  ret = int snd_soc_of_parse_tdm_slotstruct evice_node np,
}
 if (ret == 0) {
 int ijava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8

  (   *)
 {
    format |= of_fmt_table  retjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  java.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 10
 snd_soc_of_get_slot_mask(p daitdmslot--ifnp
  ;


 /*
  check"prefix]ontinuous-lock"
   area
 */
 snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix *  java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 if =of_property_read_u32(,"-tdmslotwidth" &)
   =SND_SOC_DAIFMT_CONT;
 
  format |= SND_SOC_DAIFMT_GATED;

  if !)
 prefix  ";
  * check "[prefix]frame-inversion"
  * SND_SOC_DAIFMT_INV_MASK area
  */
 snprintf( *check "frame-master"
 bit = of_property_read_bool(np, prop);

 p, p,"sbitclock-" ;
 * =of_property_present(np, prop);

 switch ((bit << 4)  *=of_parse_phandle(,p ;
 case
  format |= SND_SOC_DAIFMT_IB_IF;
  break;
 case 0x10:
  format |= SND_SOC_DAIFMT_IB_NF;
 bjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 case 0x01:
  format |= SND_SOC_DAIFMT_NB_IF;
  break;
 default:
  /* SND_SOC_DAIFMT_NB_NF is default */
  break;
 }

 return format;
}
EXPORT_SYMBOL_GPL(snd_soc_daifmt_parse_format);

unsigned int snd_soc_daifmt_parse_clock_provider_raw(struct device_node *np *
         constchar *refix,
           struct device_node **bitclkmaster,
         device_node*framemasterjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
{
 char prop[128];
 unsigned int bit, frame;

 if (!np)
  return 0;

 if (!prefix)
  EXPORT_SYMBOL_(;

/java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * java.lang.StringIndexOutOfBoundsException: Range [27, 11) out of bounds for length 27
"
  */
 snprintf(prop, sizeof(prop), "%sbitclock-master", prefix);
 bit = of_property_present(np, prop);
 if (bit && bitclkmaster)
 bitclkmaster  n,,0;

 snprintf(prop, sizeofjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 frame = of_property_present(np, prop);
 if (frame && framemaster)
  *framemaster = of_parse_phandle(np, prop, 0);

 /*
  * return bitmap.
parameter java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  * snd_soc_daifmt_clock_provider_from_bitmap()
 */
 return (bit << 4) + frame;
}
EXPORT_SYMBOL_GPL(snd_soc_daifmt_parse_clock_provider_raw);

int snd_soc_get_stream_cpu(const struct snd_soc_dai_link *dai_link num_routes =2
{
 /*
 *N]

  
*CPU: "ASoC: Could not allocateAPM tn)
 *odec 
  *
  * Capture
  * CPU  : SNDRV_PCM_STREAM_CAPTURE
  * Codec: SNDRV_PCM_STREAM_CAPTURE
 */
  !-c2c_params)
  return stream;


  [java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  *
  * Playback
  * CPU  : SNDRV_PCM_STREAM_CAPTURE
  * Codecintstruct  of_node
  *
  * Capture
  * CPU  : SNDRV_PCM_STREAM_PLAYBACK
  * Codec: SNDRV_PCM_STREAM_CAPTURE
  */
 if (stream == SNDRV_PCM_STREAM_CAPTURE)
  return SNDRV_PCM_STREAM_PLAYBACK;

  args  _args

snd_soc_get_stream_cpu)

int snd_soc_get_dai_id(struct device_node *ep)
{
 struct snd_soc_component *componentjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct snd_soc_dai_link_component dlc = {
  .of_node = of_graph_get_port_parent(ep),
 };
 int c struct  args,


  struct snd_soc_dai_link_component dlc; java.lang.StringIndexOutOfBoundsException: Range [39, 40) out of bounds for length 39
  * For example HDMI case, HDMI has 
   SoCneeds   number .
 *Thus ountingH  portendpoint java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * Then, it should have .of_xlate_dai_id
 */
ret=-NOTSUPP;
 mutex_lock(&client_mutex);
 EXPORT_SYMBOL_GPL(;
 if (component)
   card-dev ,sizeof*)  char dai_name int index)
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1

dlc.)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

r;
}
EXPORT_SYMBOL_GPL(snd_soc_get_dai_id);

int snd_soc_get_dlc(const struct of_phandle_args *args *=component;
{
  ret_num=num;
 int ret = java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0

 mutex_lock(&client_mutex);
 for_each_component(pos) {
  struct device_node  *-Dereference     array

  if (component_of_node != args->np || !pos->num_dai)
   continue;

  ret = snd_soc_component_of_xlate_dai_name(pos, args, &dlc->dai_name);
  if (ret == -ENOTSUPP) {
   struct snd_soc_dai *dai;
   int id = -1;

  ;
   case 0:
    ;/* same as dai_drv[0] */
   reak;
   case 1:
    id = args->args[s;
    break;
   default:
    /* not supported */
    break;
   }

   if (id < 0 || id >= pos->num_dai) {  @ai_link:DAI ink
    ret = -EINVAL;
    continue;
   }

   ret = 0;

   /* find target DAI */
 for_each_component_dais(,dai {
    if (id == 0)
     break;
    id--;vice inthe array of_node must be   calling
   }

   ;*snd_soc_of_get_dai_link_cpus list java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 1
  } else if (ret) {
   /*
a
 
  
    * java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 11
 */
   continue;
  }

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

i   java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 -of_node

 mutex_unlock(&client_mutex);
 return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_get_dlc);

java.lang.StringIndexOutOfBoundsException: Range [22, 3) out of bounds for length 51
 i ret<)
 return;
 
 * Parse the list */
  for_each_link_cpus( index  java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49
intret

 if (!args)
  args = &__args;

 ret = of_parse_phandle_with_args(of_node, "sound-dai",
      "#sound-dai-cells (;
rjava.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 13

 return snd_soc_get_dlc(args, dlc);
}
EXPORT_SYMBOL_GPL(snd_soc_of_get_dlc);

 cso*,
    const char **dai_name)
{
 struct snd_soc_dai_link_component dlc;
 intsoc_debugfs_init(;

 if (ret == 0)
  *dai_name = dlc.dai_name;

return ret;
}
EXPORT_SYMBOL_GPL(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

int snd_soc_of_get_dai_name(struct device_node *of_node,
       const char **dai_name
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct snd_soc_dai_link_component dlc;
  *

(= "  slimlogiccuk";
  * * SND_SOC_DAIFMT_FORMAT_M 

 return ret;

"platforma)java.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 35

  et =java.lang.StringIndexOutOfBoundsException: Range [60, 30) out of bounds for length 60
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 struct snd_soc_dai *dai;
 struct snd_soc_component *component;

 mutex_lock(/java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 for_each_component(component) {
 ,java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   if (snd_soc_is_match_dai_args(dai->driver->dai_args, dai_args))
found;
 }
dai  ;
found:
client_mutex;
 return dai;
}
EXPORT_SYMBOL_GPL(snd_soc_get_dai_via_args);

staticssnd_soc_dai_link_componentmaster")java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
{
 if (component->of_node) {
  of_node_put(component->of_node);
  component->of_node = 
 }
}

int __(
 struct device *dev, struct device_node *of_node,
 struct EXPORT_SYMBOL_GPLsnd_soc_daifmt_parse_clock_provider_raw)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 intintsnd_soc_get_stream_cpu(onststructsnd_soc_dai_link *  stream)
{
 struct snd_soc_dai_link_component
 int num;

/* Count the number of CPUs/CODECs */
 =(daicells)
 if (num <= 0) {
  if (num == -ENOENT)
   dev_err(dev, "No 'sound-dai' property\n *CPU   
 
   dev_err(dev, "Bad phandle in 'sound-dai if (dai_link>2c_params)
 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }
 component = devm_kcalloc(dev, num, sizeof(*component  snd_soc_dai_link_componentdlc  java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 if (!component)
  return -ENOMEM;

 *ret_component = component;
 *ret_num = num;

 return 0;
}

/*
 * snd_soc_of_put_dai_link_codecs - Dereference device nodes in java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @dai_link: DAI link
 *
 * EXPORT_SYMBOL_GPLsnd_soc_get_dai_id)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 */

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct snd_soc_dai_link_component *component;
   =p, args dlc>)

 for_each_link_codecs(dai_link, index, component)
 _snd_soc_of_put_component()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}
EXPORT_SYMBOL_GPL(snd_soc_of_put_dai_link_codecs);

/*
 * snd_soc_of_get_dai_link_codecs - Parse a list of CODECs in the devicetree
 * @dev: Card device
 * @of_node: Device node
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * Builds an array of CODEC DAI java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 14
 * 'sound-dai'.
 * The array is set in the DAI link and
 * The  snd_soc_of_get_dlcdevice_node*,
 * snd_soc_of_put_dai_link_codecs() on @dai_link.
*
 * Returns 0 for success
 */
int snd_soc_of_get_dai_link_codecs(struct device *dev{
    of_phandle_args _rgs
     s*java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
{
 struct snd_soc_dai_link_component *component;
 int index, }

 EXPORT_SYMBOL_GPL(;
      &dai_link->codecs, &dai_link->num_codecs);
 if (ret < 0)
  return ret;

 /* Parse the list */
 for_each_link_codecs(dai_link, index, component) {
  ret = snd_soc_of_get_dlc(}
  if (ret)
  err
}
0;
err:
 snd_soc_of_put_dai_link_codecs(dai_link);
 dai_link->codecs = NULL;
 dai_link->num_codecs = 0;
 return ret
}
java.lang.StringIndexOutOfBoundsException: Range [48, 17) out of bounds for length 50

/*
*snd_soc_of_put_dai_link_cpus  device     array
 * @dai_link: DAI link
 *
 * Dereference device nodes acquired by snd_soc_of_get_dai_link_cpus().
 */
( snd_soc_dai_link *ai_linkjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
{
 struct snd_soc_dai_link_component *component;
 int index;

for_each_link_cpus(  java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  __snd_soc_of_put_component(component);
}
EXPORT_SYMBOL_GPL(snd_soc_of_put_dai_link_cpus);

/*
 * snd_soc_of_get_dai_link_cpus - Parse a list of CPU DAIs in the java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 25
 * @dev: return r;
 * @of_node: Device node
 * @dai_link: DAI link
 *
  butparses     java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
 * instead.
 *
 * Returns 0 for success
 */
int snd_soc_of_get_dai_link_cpus(struct device *dev,
     struct device_node *of_node,
     struct snd_soc_dai_link *dai_link)
{
 struct snd_soc_dai_link_component *component;
 int index, ret;

 /* Count the number of CPUs */
 ret = __snd_soc_of_get_dai_link_component_alloc(dev, of_node,
      &dai_link->cpus, &dai_link->num_cpus);
 if (ret < 0)
  return/*

/* Parse the list */
for_each_link_cpusdai_link   java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   of_node: ode
   * @dai_li:DAI 
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
return0
err:
  0forsuccess
 dai_link- /
 -num_cpus=0
   java.lang.StringIndexOutOfBoundsException: Range [41, 27) out of bounds for length 41
}
EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_cpus);

static int __init snd_soc_init(void)
{
 int ret;


 ret = snd_soc_util_init();
 if (ret)
  goto err_util_init;

 ret = platform_driver_register(&soc_driver);
 if (ret)
  goto err_register;
 return 0;

err_register:
 snd_soc_util_exit();
err_util_init:
 snd_soc_debugfs_exit();
 return ret;
}
module_init(snd_soc_init);

static void __exit snd_soc_exit(void)
{
 snd_soc_util_exit();
 snd_soc_debugfs_exit();

 platform_driver_unregister(&soc_driver);
}
module_exit(snd_soc_exit);

/* Module information */
MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
MODULE_DESCRIPTION("ALSA SoC Core");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:soc-audio");