Merge remote-tracking branches 'asoc/topic/cygnus', 'asoc/topic/da7213', 'asoc/topic...

[sfrench/cifs-2.6.git] / sound / soc / soc-core.c

diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
index fee4b0ef5566cf9e8de0bf5c568706da9cab2ea2..c0edac80df34e683291cff5fb86c560ee8e22ffd 100644 (file)
--- a/sound/soc/soc-core.c
+++ b/sound/soc/soc-core.c
@@ -614,6 +614,8 @@ struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
 }
 EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream);
 
 }
 EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream);
 

+static const struct snd_soc_ops null_snd_soc_ops;
+

 static struct snd_soc_pcm_runtime *soc_new_pcm_runtime(
        struct snd_soc_card *card, struct snd_soc_dai_link *dai_link)
 {
 static struct snd_soc_pcm_runtime *soc_new_pcm_runtime(
        struct snd_soc_card *card, struct snd_soc_dai_link *dai_link)
 {


@@ -626,6 +628,9 @@ static struct snd_soc_pcm_runtime *soc_new_pcm_runtime(
        INIT_LIST_HEAD(&rtd->component_list);
        rtd->card = card;
        rtd->dai_link = dai_link;
        INIT_LIST_HEAD(&rtd->component_list);
        rtd->card = card;
        rtd->dai_link = dai_link;

+       if (!rtd->dai_link->ops)
+               rtd->dai_link->ops = &null_snd_soc_ops;
+

        rtd->codec_dais = kzalloc(sizeof(struct snd_soc_dai *) *
                                        dai_link->num_codecs,
                                        GFP_KERNEL);
        rtd->codec_dais = kzalloc(sizeof(struct snd_soc_dai *) *
                                        dai_link->num_codecs,
                                        GFP_KERNEL);


@@ -639,8 +644,7 @@ static struct snd_soc_pcm_runtime *soc_new_pcm_runtime(
 
 static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)
 {
 
 static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)
 {

-       if (rtd && rtd->codec_dais)
-               kfree(rtd->codec_dais);
+       kfree(rtd->codec_dais);

        snd_soc_rtdcom_del_all(rtd);
        kfree(rtd);
 }
        snd_soc_rtdcom_del_all(rtd);
        kfree(rtd);
 }


@@ -2632,7 +2636,7 @@ EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);
 int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
        unsigned int freq, int dir)
 {
 int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
        unsigned int freq, int dir)
 {

-       if (dai->driver && dai->driver->ops->set_sysclk)
+       if (dai->driver->ops->set_sysclk)

                return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
 
        return snd_soc_component_set_sysclk(dai->component, clk_id, 0,
                return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
 
        return snd_soc_component_set_sysclk(dai->component, clk_id, 0,


@@ -2700,7 +2704,7 @@ EXPORT_SYMBOL_GPL(snd_soc_component_set_sysclk);
 int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
        int div_id, int div)
 {
 int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
        int div_id, int div)
 {

-       if (dai->driver && dai->driver->ops->set_clkdiv)
+       if (dai->driver->ops->set_clkdiv)

                return dai->driver->ops->set_clkdiv(dai, div_id, div);
        else
                return -EINVAL;
                return dai->driver->ops->set_clkdiv(dai, div_id, div);
        else
                return -EINVAL;


@@ -2720,7 +2724,7 @@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
 int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
        unsigned int freq_in, unsigned int freq_out)
 {
 int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
        unsigned int freq_in, unsigned int freq_out)
 {

-       if (dai->driver && dai->driver->ops->set_pll)
+       if (dai->driver->ops->set_pll)

                return dai->driver->ops->set_pll(dai, pll_id, source,
                                         freq_in, freq_out);
 
                return dai->driver->ops->set_pll(dai, pll_id, source,
                                         freq_in, freq_out);
 


@@ -2786,7 +2790,7 @@ EXPORT_SYMBOL_GPL(snd_soc_component_set_pll);
  */
 int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
 {
  */
 int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
 {

-       if (dai->driver && dai->driver->ops->set_bclk_ratio)
+       if (dai->driver->ops->set_bclk_ratio)

                return dai->driver->ops->set_bclk_ratio(dai, ratio);
        else
                return -EINVAL;
                return dai->driver->ops->set_bclk_ratio(dai, ratio);
        else
                return -EINVAL;


@@ -2796,7 +2800,7 @@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);
 /**
  * snd_soc_dai_set_fmt - configure DAI hardware audio format.
  * @dai: DAI
 /**
  * snd_soc_dai_set_fmt - configure DAI hardware audio format.
  * @dai: DAI

- * @fmt: SND_SOC_DAIFMT_ format value.
+ * @fmt: SND_SOC_DAIFMT_* format value.

  *
  * Configures the DAI hardware format and clocking.
  */
  *
  * Configures the DAI hardware format and clocking.
  */


@@ -2860,7 +2864,7 @@ static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
        unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
 {
 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
        unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
 {

-       if (dai->driver && dai->driver->ops->xlate_tdm_slot_mask)
+       if (dai->driver->ops->xlate_tdm_slot_mask)

                dai->driver->ops->xlate_tdm_slot_mask(slots,
                                                &tx_mask, &rx_mask);
        else
                dai->driver->ops->xlate_tdm_slot_mask(slots,
                                                &tx_mask, &rx_mask);
        else


@@ -2869,7 +2873,7 @@ int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
        dai->tx_mask = tx_mask;
        dai->rx_mask = rx_mask;
 
        dai->tx_mask = tx_mask;
        dai->rx_mask = rx_mask;
 

-       if (dai->driver && dai->driver->ops->set_tdm_slot)
+       if (dai->driver->ops->set_tdm_slot)

                return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
                                slots, slot_width);
        else
                return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
                                slots, slot_width);
        else


@@ -2893,7 +2897,7 @@ int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
        unsigned int tx_num, unsigned int *tx_slot,
        unsigned int rx_num, unsigned int *rx_slot)
 {
        unsigned int tx_num, unsigned int *tx_slot,
        unsigned int rx_num, unsigned int *rx_slot)
 {

-       if (dai->driver && dai->driver->ops->set_channel_map)
+       if (dai->driver->ops->set_channel_map)

                return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
                        rx_num, rx_slot);
        else
                return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
                        rx_num, rx_slot);
        else


@@ -2910,7 +2914,7 @@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
  */
 int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
 {
  */
 int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
 {

-       if (dai->driver && dai->driver->ops->set_tristate)
+       if (dai->driver->ops->set_tristate)

                return dai->driver->ops->set_tristate(dai, tristate);
        else
                return -EINVAL;
                return dai->driver->ops->set_tristate(dai, tristate);
        else
                return -EINVAL;


@@ -3250,6 +3254,30 @@ static int snd_soc_component_stream_event(struct snd_soc_dapm_context *dapm,
        return component->driver->stream_event(component, event);
 }
 
        return component->driver->stream_event(component, event);
 }
 

+static int snd_soc_component_drv_pcm_new(struct snd_soc_component *component,
+                                       struct snd_soc_pcm_runtime *rtd)
+{
+       if (component->driver->pcm_new)
+               return component->driver->pcm_new(rtd);
+
+       return 0;
+}
+
+static void snd_soc_component_drv_pcm_free(struct snd_soc_component *component,
+                                         struct snd_pcm *pcm)
+{
+       if (component->driver->pcm_free)
+               component->driver->pcm_free(pcm);
+}
+
+static int snd_soc_component_set_bias_level(struct snd_soc_dapm_context *dapm,
+                                       enum snd_soc_bias_level level)
+{
+       struct snd_soc_component *component = dapm->component;
+
+       return component->driver->set_bias_level(component, level);
+}
+

 static int snd_soc_component_initialize(struct snd_soc_component *component,
        const struct snd_soc_component_driver *driver, struct device *dev)
 {
 static int snd_soc_component_initialize(struct snd_soc_component *component,
        const struct snd_soc_component_driver *driver, struct device *dev)
 {


@@ -3270,16 +3298,21 @@ static int snd_soc_component_initialize(struct snd_soc_component *component,
        component->set_sysclk = component->driver->set_sysclk;
        component->set_pll = component->driver->set_pll;
        component->set_jack = component->driver->set_jack;
        component->set_sysclk = component->driver->set_sysclk;
        component->set_pll = component->driver->set_pll;
        component->set_jack = component->driver->set_jack;

+       component->pcm_new = snd_soc_component_drv_pcm_new;
+       component->pcm_free = snd_soc_component_drv_pcm_free;

 
        dapm = snd_soc_component_get_dapm(component);
        dapm->dev = dev;
        dapm->component = component;
        dapm->bias_level = SND_SOC_BIAS_OFF;
 
        dapm = snd_soc_component_get_dapm(component);
        dapm->dev = dev;
        dapm->component = component;
        dapm->bias_level = SND_SOC_BIAS_OFF;

-       dapm->idle_bias_off = true;
+       dapm->idle_bias_off = !driver->idle_bias_on;
+       dapm->suspend_bias_off = driver->suspend_bias_off;

        if (driver->seq_notifier)
                dapm->seq_notifier = snd_soc_component_seq_notifier;
        if (driver->stream_event)
                dapm->stream_event = snd_soc_component_stream_event;
        if (driver->seq_notifier)
                dapm->seq_notifier = snd_soc_component_seq_notifier;
        if (driver->stream_event)
                dapm->stream_event = snd_soc_component_stream_event;

+       if (driver->set_bias_level)
+               dapm->set_bias_level = snd_soc_component_set_bias_level;

 
        INIT_LIST_HEAD(&component->dai_list);
        mutex_init(&component->io_mutex);
 
        INIT_LIST_HEAD(&component->dai_list);
        mutex_init(&component->io_mutex);


@@ -3371,19 +3404,49 @@ static void snd_soc_component_del_unlocked(struct snd_soc_component *component)
        list_del(&component->list);
 }
 
        list_del(&component->list);
 }
 

-int snd_soc_register_component(struct device *dev,
-                              const struct snd_soc_component_driver *component_driver,
-                              struct snd_soc_dai_driver *dai_drv,
-                              int num_dai)
+#define ENDIANNESS_MAP(name) \
+       (SNDRV_PCM_FMTBIT_##name##LE | SNDRV_PCM_FMTBIT_##name##BE)
+static u64 endianness_format_map[] = {
+       ENDIANNESS_MAP(S16_),
+       ENDIANNESS_MAP(U16_),
+       ENDIANNESS_MAP(S24_),
+       ENDIANNESS_MAP(U24_),
+       ENDIANNESS_MAP(S32_),
+       ENDIANNESS_MAP(U32_),
+       ENDIANNESS_MAP(S24_3),
+       ENDIANNESS_MAP(U24_3),
+       ENDIANNESS_MAP(S20_3),
+       ENDIANNESS_MAP(U20_3),
+       ENDIANNESS_MAP(S18_3),
+       ENDIANNESS_MAP(U18_3),
+       ENDIANNESS_MAP(FLOAT_),
+       ENDIANNESS_MAP(FLOAT64_),
+       ENDIANNESS_MAP(IEC958_SUBFRAME_),
+};
+
+/*
+ * Fix up the DAI formats for endianness: codecs don't actually 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.
+ */
+static void convert_endianness_formats(struct snd_soc_pcm_stream *stream)

 {
 {

-       struct snd_soc_component *component;
-       int ret;
+       int i;

 
 

-       component = kzalloc(sizeof(*component), GFP_KERNEL);
-       if (!component) {
-               dev_err(dev, "ASoC: Failed to allocate memory\n");
-               return -ENOMEM;
-       }
+       for (i = 0; i < ARRAY_SIZE(endianness_format_map); i++)
+               if (stream->formats & endianness_format_map[i])
+                       stream->formats |= endianness_format_map[i];
+}
+
+int snd_soc_add_component(struct device *dev,
+                       struct snd_soc_component *component,
+                       const struct snd_soc_component_driver *component_driver,
+                       struct snd_soc_dai_driver *dai_drv,
+                       int num_dai)
+{
+       int ret;
+       int i;

 
        ret = snd_soc_component_initialize(component, component_driver, dev);
        if (ret)
 
        ret = snd_soc_component_initialize(component, component_driver, dev);
        if (ret)


@@ -3392,7 +3455,15 @@ int snd_soc_register_component(struct device *dev,
        component->ignore_pmdown_time = true;
        component->registered_as_component = true;
 
        component->ignore_pmdown_time = true;
        component->registered_as_component = true;
 

-       ret = snd_soc_register_dais(component, dai_drv, num_dai, true);
+       if (component_driver->endianness) {
+               for (i = 0; i < num_dai; i++) {
+                       convert_endianness_formats(&dai_drv[i].playback);
+                       convert_endianness_formats(&dai_drv[i].capture);
+               }
+       }
+
+       ret = snd_soc_register_dais(component, dai_drv, num_dai,
+                                   !component_driver->non_legacy_dai_naming);

        if (ret < 0) {
                dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
                goto err_cleanup;
        if (ret < 0) {
                dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
                goto err_cleanup;


@@ -3408,6 +3479,22 @@ err_free:
        kfree(component);
        return ret;
 }
        kfree(component);
        return ret;
 }

+EXPORT_SYMBOL_GPL(snd_soc_add_component);
+
+int snd_soc_register_component(struct device *dev,
+                       const struct snd_soc_component_driver *component_driver,
+                       struct snd_soc_dai_driver *dai_drv,
+                       int num_dai)
+{
+       struct snd_soc_component *component;
+
+       component = kzalloc(sizeof(*component), GFP_KERNEL);
+       if (!component)
+               return -ENOMEM;
+
+       return snd_soc_add_component(dev, component, component_driver,
+                                    dai_drv, num_dai);
+}

 EXPORT_SYMBOL_GPL(snd_soc_register_component);
 
 /**
 EXPORT_SYMBOL_GPL(snd_soc_register_component);
 
 /**


@@ -3448,6 +3535,32 @@ void snd_soc_unregister_component(struct device *dev)
 }
 EXPORT_SYMBOL_GPL(snd_soc_unregister_component);
 
 }
 EXPORT_SYMBOL_GPL(snd_soc_unregister_component);
 

+struct snd_soc_component *snd_soc_lookup_component(struct device *dev,
+                                                  const char *driver_name)
+{
+       struct snd_soc_component *component;
+       struct snd_soc_component *ret;
+
+       ret = NULL;
+       mutex_lock(&client_mutex);
+       list_for_each_entry(component, &component_list, list) {
+               if (dev != component->dev)
+                       continue;
+
+               if (driver_name &&
+                   (driver_name != component->driver->name) &&
+                   (strcmp(component->driver->name, driver_name) != 0))
+                       continue;
+
+               ret = component;
+               break;
+       }
+       mutex_unlock(&client_mutex);
+
+       return ret;
+}
+EXPORT_SYMBOL_GPL(snd_soc_lookup_component);
+

 static int snd_soc_platform_drv_probe(struct snd_soc_component *component)
 {
        struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
 static int snd_soc_platform_drv_probe(struct snd_soc_component *component)
 {
        struct snd_soc_platform *platform = snd_soc_component_to_platform(component);


@@ -3462,6 +3575,26 @@ static void snd_soc_platform_drv_remove(struct snd_soc_component *component)
        platform->driver->remove(platform);
 }
 
        platform->driver->remove(platform);
 }
 

+static int snd_soc_platform_drv_pcm_new(struct snd_soc_component *component,
+                                       struct snd_soc_pcm_runtime *rtd)
+{
+       struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
+
+       if (platform->driver->pcm_new)
+               return platform->driver->pcm_new(rtd);
+
+       return 0;
+}
+
+static void snd_soc_platform_drv_pcm_free(struct snd_soc_component *component,
+                                         struct snd_pcm *pcm)
+{
+       struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
+
+       if (platform->driver->pcm_free)
+               platform->driver->pcm_free(pcm);
+}
+

 /**
  * snd_soc_add_platform - Add a platform to the ASoC core
  * @dev: The parent device for the platform
 /**
  * snd_soc_add_platform - Add a platform to the ASoC core
  * @dev: The parent device for the platform


@@ -3485,6 +3618,10 @@ int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
                platform->component.probe = snd_soc_platform_drv_probe;
        if (platform_drv->remove)
                platform->component.remove = snd_soc_platform_drv_remove;
                platform->component.probe = snd_soc_platform_drv_probe;
        if (platform_drv->remove)
                platform->component.remove = snd_soc_platform_drv_remove;

+       if (platform_drv->pcm_new)
+               platform->component.pcm_new = snd_soc_platform_drv_pcm_new;
+       if (platform_drv->pcm_free)
+               platform->component.pcm_free = snd_soc_platform_drv_pcm_free;

 
 #ifdef CONFIG_DEBUG_FS
        platform->component.debugfs_prefix = "platform";
 
 #ifdef CONFIG_DEBUG_FS
        platform->component.debugfs_prefix = "platform";


@@ -3582,39 +3719,6 @@ void snd_soc_unregister_platform(struct device *dev)
 }
 EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
 
 }
 EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
 

-static u64 codec_format_map[] = {
-       SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
-       SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
-       SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
-       SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
-       SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
-       SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
-       SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
-       SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
-       SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
-       SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
-       SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
-       SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
-       SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
-       SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
-       SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
-       | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
-};
-
-/* Fix up the DAI formats for endianness: codecs don't actually 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.
- */
-static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
-{
-       int i;
-
-       for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
-               if (stream->formats & codec_format_map[i])
-                       stream->formats |= codec_format_map[i];
-}
-

 static int snd_soc_codec_drv_probe(struct snd_soc_component *component)
 {
        struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
 static int snd_soc_codec_drv_probe(struct snd_soc_component *component)
 {
        struct snd_soc_codec *codec = snd_soc_component_to_codec(component);


@@ -3765,8 +3869,8 @@ int snd_soc_register_codec(struct device *dev,
                codec->component.regmap = codec_drv->get_regmap(dev);
 
        for (i = 0; i < num_dai; i++) {
                codec->component.regmap = codec_drv->get_regmap(dev);
 
        for (i = 0; i < num_dai; i++) {

-               fixup_codec_formats(&dai_drv[i].playback);
-               fixup_codec_formats(&dai_drv[i].capture);
+               convert_endianness_formats(&dai_drv[i].playback);
+               convert_endianness_formats(&dai_drv[i].capture);

        }
 
        ret = snd_soc_register_dais(&codec->component, dai_drv, num_dai, false);
        }
 
        ret = snd_soc_register_dais(&codec->component, dai_drv, num_dai, false);