ASoC: make ops a pointer in 'struct snd_soc_dai'

Considering the fact that most cpu_dai or codec_dai are using a same
'snd_soc_dai_ops' for several similar interfaces, 'ops' would be better
made a pointer instead, to make sharing easier and code a bit cleaner.

The patch below is rather preliminary since the asoc tree is being
actively developed, and this touches almost every piece of code,
(and possibly many others in development need to be changed as
well). Building of all codecs are OK, yet to every SoC, I didn't test
that.

Signed-off-by: Eric Miao <eric.miao@marvell.com>
Acked-by: Timur Tabi <timur@freescale.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>

1 files changed, 54 insertions, 48 deletions

diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
index d4b90d82a098..16518329f6b2 100644
--- a/sound/soc/soc-core.c
+++ b/sound/soc/soc-core.c
@@ -133,8 +133,8 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
         mutex_lock(&pcm_mutex);
 
         /* startup the audio subsystem */
-        if (cpu_dai->ops.startup) {
-                ret = cpu_dai->ops.startup(substream, cpu_dai);
+        if (cpu_dai->ops->startup) {
+                ret = cpu_dai->ops->startup(substream, cpu_dai);
                 if (ret < 0) {
                         printk(KERN_ERR "asoc: can't open interface %s\n",
                                 cpu_dai->name);
@@ -150,8 +150,8 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
                 }
         }
 
-        if (codec_dai->ops.startup) {
-                ret = codec_dai->ops.startup(substream, codec_dai);
+        if (codec_dai->ops->startup) {
+                ret = codec_dai->ops->startup(substream, codec_dai);
                 if (ret < 0) {
                         printk(KERN_ERR "asoc: can't open codec %s\n",
                                 codec_dai->name);
@@ -247,8 +247,8 @@ codec_dai_err:
                 platform->pcm_ops->close(substream);
 
 platform_err:
-        if (cpu_dai->ops.shutdown)
-                cpu_dai->ops.shutdown(substream, cpu_dai);
+        if (cpu_dai->ops->shutdown)
+                cpu_dai->ops->shutdown(substream, cpu_dai);
 out:
         mutex_unlock(&pcm_mutex);
         return ret;
@@ -340,11 +340,11 @@ static int soc_codec_close(struct snd_pcm_substream *substream)
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
                 snd_soc_dai_digital_mute(codec_dai, 1);
 
-        if (cpu_dai->ops.shutdown)
-                cpu_dai->ops.shutdown(substream, cpu_dai);
+        if (cpu_dai->ops->shutdown)
+                cpu_dai->ops->shutdown(substream, cpu_dai);
 
-        if (codec_dai->ops.shutdown)
-                codec_dai->ops.shutdown(substream, codec_dai);
+        if (codec_dai->ops->shutdown)
+                codec_dai->ops->shutdown(substream, codec_dai);
 
         if (machine->ops && machine->ops->shutdown)
                 machine->ops->shutdown(substream);
@@ -408,16 +408,16 @@ static int soc_pcm_prepare(struct snd_pcm_substream *substream)
                 }
         }
 
-        if (codec_dai->ops.prepare) {
-                ret = codec_dai->ops.prepare(substream, codec_dai);
+        if (codec_dai->ops->prepare) {
+                ret = codec_dai->ops->prepare(substream, codec_dai);
                 if (ret < 0) {
                         printk(KERN_ERR "asoc: codec DAI prepare error\n");
                         goto out;
                 }
         }
 
-        if (cpu_dai->ops.prepare) {
-                ret = cpu_dai->ops.prepare(substream, cpu_dai);
+        if (cpu_dai->ops->prepare) {
+                ret = cpu_dai->ops->prepare(substream, cpu_dai);
                 if (ret < 0) {
                         printk(KERN_ERR "asoc: cpu DAI prepare error\n");
                         goto out;
@@ -494,8 +494,8 @@ static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
                 }
         }
 
-        if (codec_dai->ops.hw_params) {
-                ret = codec_dai->ops.hw_params(substream, params, codec_dai);
+        if (codec_dai->ops->hw_params) {
+                ret = codec_dai->ops->hw_params(substream, params, codec_dai);
                 if (ret < 0) {
                         printk(KERN_ERR "asoc: can't set codec %s hw params\n",
                                 codec_dai->name);
@@ -503,8 +503,8 @@ static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
                 }
         }
 
-        if (cpu_dai->ops.hw_params) {
-                ret = cpu_dai->ops.hw_params(substream, params, cpu_dai);
+        if (cpu_dai->ops->hw_params) {
+                ret = cpu_dai->ops->hw_params(substream, params, cpu_dai);
                 if (ret < 0) {
                         printk(KERN_ERR "asoc: interface %s hw params failed\n",
                                 cpu_dai->name);
@@ -526,12 +526,12 @@ out:
         return ret;
 
 platform_err:
-        if (cpu_dai->ops.hw_free)
-                cpu_dai->ops.hw_free(substream, cpu_dai);
+        if (cpu_dai->ops->hw_free)
+                cpu_dai->ops->hw_free(substream, cpu_dai);
 
 interface_err:
-        if (codec_dai->ops.hw_free)
-                codec_dai->ops.hw_free(substream, codec_dai);
+        if (codec_dai->ops->hw_free)
+                codec_dai->ops->hw_free(substream, codec_dai);
 
 codec_err:
         if (machine->ops && machine->ops->hw_free)
@@ -570,11 +570,11 @@ static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
                 platform->pcm_ops->hw_free(substream);
 
         /* now free hw params for the DAI's  */
-        if (codec_dai->ops.hw_free)
-                codec_dai->ops.hw_free(substream, codec_dai);
+        if (codec_dai->ops->hw_free)
+                codec_dai->ops->hw_free(substream, codec_dai);
 
-        if (cpu_dai->ops.hw_free)
-                cpu_dai->ops.hw_free(substream, cpu_dai);
+        if (cpu_dai->ops->hw_free)
+                cpu_dai->ops->hw_free(substream, cpu_dai);
 
         mutex_unlock(&pcm_mutex);
         return 0;
@@ -591,8 +591,8 @@ static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
         struct snd_soc_dai *codec_dai = machine->codec_dai;
         int ret;
 
-        if (codec_dai->ops.trigger) {
-                ret = codec_dai->ops.trigger(substream, cmd, codec_dai);
+        if (codec_dai->ops->trigger) {
+                ret = codec_dai->ops->trigger(substream, cmd, codec_dai);
                 if (ret < 0)
                         return ret;
         }
@@ -603,8 +603,8 @@ static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
                         return ret;
         }
 
-        if (cpu_dai->ops.trigger) {
-                ret = cpu_dai->ops.trigger(substream, cmd, cpu_dai);
+        if (cpu_dai->ops->trigger) {
+                ret = cpu_dai->ops->trigger(substream, cmd, cpu_dai);
                 if (ret < 0)
                         return ret;
         }
@@ -645,8 +645,8 @@ static int soc_suspend(struct platform_device *pdev, pm_message_t state)
         /* mute any active DAC's */
         for (i = 0; i < card->num_links; i++) {
                 struct snd_soc_dai *dai = card->dai_link[i].codec_dai;
-                if (dai->ops.digital_mute && dai->playback.active)
-                        dai->ops.digital_mute(dai, 1);
+                if (dai->ops->digital_mute && dai->playback.active)
+                        dai->ops->digital_mute(dai, 1);
         }
 
         /* suspend all pcms */
@@ -741,8 +741,8 @@ static void soc_resume_deferred(struct work_struct *work)
         /* unmute any active DACs */
         for (i = 0; i < card->num_links; i++) {
                 struct snd_soc_dai *dai = card->dai_link[i].codec_dai;
-                if (dai->ops.digital_mute && dai->playback.active)
-                        dai->ops.digital_mute(dai, 0);
+                if (dai->ops->digital_mute && dai->playback.active)
+                        dai->ops->digital_mute(dai, 0);
         }
 
         for (i = 0; i < card->num_links; i++) {
@@ -2051,8 +2051,8 @@ EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
 int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
         unsigned int freq, int dir)
 {
-        if (dai->ops.set_sysclk)
-                return dai->ops.set_sysclk(dai, clk_id, freq, dir);
+        if (dai->ops->set_sysclk)
+                return dai->ops->set_sysclk(dai, clk_id, freq, dir);
         else
                 return -EINVAL;
 }
@@ -2071,8 +2071,8 @@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
 int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
         int div_id, int div)
 {
-        if (dai->ops.set_clkdiv)
-                return dai->ops.set_clkdiv(dai, div_id, div);
+        if (dai->ops->set_clkdiv)
+                return dai->ops->set_clkdiv(dai, div_id, div);
         else
                 return -EINVAL;
 }
@@ -2090,8 +2090,8 @@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
 int snd_soc_dai_set_pll(struct snd_soc_dai *dai,
         int pll_id, unsigned int freq_in, unsigned int freq_out)
 {
-        if (dai->ops.set_pll)
-                return dai->ops.set_pll(dai, pll_id, freq_in, freq_out);
+        if (dai->ops->set_pll)
+                return dai->ops->set_pll(dai, pll_id, freq_in, freq_out);
         else
                 return -EINVAL;
 }
@@ -2106,8 +2106,8 @@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
  */
 int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 {
-        if (dai->ops.set_fmt)
-                return dai->ops.set_fmt(dai, fmt);
+        if (dai->ops->set_fmt)
+                return dai->ops->set_fmt(dai, fmt);
         else
                 return -EINVAL;
 }
@@ -2125,8 +2125,8 @@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
         unsigned int mask, int slots)
 {
-        if (dai->ops.set_sysclk)
-                return dai->ops.set_tdm_slot(dai, mask, slots);
+        if (dai->ops->set_sysclk)
+                return dai->ops->set_tdm_slot(dai, mask, slots);
         else
                 return -EINVAL;
 }
@@ -2141,8 +2141,8 @@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
  */
 int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
 {
-        if (dai->ops.set_sysclk)
-                return dai->ops.set_tristate(dai, tristate);
+        if (dai->ops->set_sysclk)
+                return dai->ops->set_tristate(dai, tristate);
         else
                 return -EINVAL;
 }
@@ -2157,8 +2157,8 @@ EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
  */
 int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute)
 {
-        if (dai->ops.digital_mute)
-                return dai->ops.digital_mute(dai, mute);
+        if (dai->ops->digital_mute)
+                return dai->ops->digital_mute(dai, mute);
         else
                 return -EINVAL;
 }
@@ -2211,6 +2211,9 @@ static int snd_soc_unregister_card(struct snd_soc_card *card)
         return 0;
 }
 
+static struct snd_soc_dai_ops null_dai_ops = {
+};
+
 /**
  * snd_soc_register_dai - Register a DAI with the ASoC core
  *
@@ -2225,6 +2228,9 @@ int snd_soc_register_dai(struct snd_soc_dai *dai)
         if (!dai->dev)
                 printk(KERN_WARNING "No device for DAI %s\n", dai->name);
 
+        if (!dai->ops)
+                dai->ops = &null_dai_ops;
+
         INIT_LIST_HEAD(&dai->list);
 
         mutex_lock(&client_mutex);