[2/2] CHROMIUM: ASoC: Tegra: Seaboard: Control power to digital mics

sound/soc/tegra/seaboard.c

 /*
  * seaboard.c - Seaboard machine ASoC driver
  *
  * Author: Stephen Warren <swarren@nvidia.com>
  * Copyright (C) 2010-2011 - NVIDIA, Inc.
  *
  * Based on code copyright/by:
  *
  * (c) 2009, 2010 Nvidia Graphics Pvt. Ltd.
  *
@@ skipping 14 matching lines @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA
  *
  */
 
 #include <asm/mach-types.h>
 
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
 #include <linux/slab.h>
 #include <linux/gpio.h>
 
 #include <mach/seaboard_audio.h>
 
 #include <sound/core.h>
 #include <sound/jack.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
 
 #include "../codecs/wm8903.h"
 
 #include "tegra_das.h"
 #include "tegra_i2s.h"
 #include "tegra_pcm.h"
 #include "tegra_asoc_utils.h"
 
 #define DRV_NAME "tegra-snd-seaboard"
 
 #define GPIO_SPKR_EN    BIT(0)
 #define GPIO_HP_MUTE    BIT(1)
 
 struct tegra_seaboard {
         struct tegra_asoc_utils_data util_data;
         struct seaboard_audio_platform_data *pdata;
         int gpio_requested;
+        struct regulator *vdd_dmic;
+        bool first_dmic_event;

[jiesun, 2011/04/25 18:21:04]

I understand this is for preventing regulator_disable before enable, based on
the assumption that event on/off are interleaving. I do not know if that's
always true. wouldn't that keep the enable status of that regulator be more
reliable?

[Stephen Warren, 2011/04/25 22:27:41]

The issue isn't continual interleaving; it's a startup condition.

Initially, the new consumer entry for the DMICs is off. If we attempt to turn it
off again, the kernel will complain.

However, the ASoC core calls seaboard_event_dmic(off) at startup, which would
usually trigger this complaint. this variable is used to indicate if the call to
seaboard_event_dmic is the very first, and if so, ignore any request to turn off
the regulator, since we know it's already off. In any other case, we just do
exactly what the ASoC core tells us to; it doesn't give us any duplicate events.

Note that we can't query the regulator API to determine if the power rail is
off; it reports the power rail status, not the individual consumer status.
Specifically, if the camera consumer is on, and hence the power rail is on, if
we query the regulator API to get the state, it'll say on. If we avoid turning
our consumer on in this case (since desired == current state), then when the
camera is turned off, it'll turn off the rail, since no other consumers are
marked active, which will turn off the DMICs too.


Should I describe this in a comment in seaboard_event_dmic?

 };
 
 static int seaboard_asoc_hw_params(struct snd_pcm_substream *substream,
                                         struct snd_pcm_hw_params *params)
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *codec_dai = rtd->codec_dai;
         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
         struct snd_soc_codec *codec = rtd->codec;
         struct snd_soc_card *card = codec->card;
@@ skipping 150 matching lines @@
         struct seaboard_audio_platform_data *pdata = seaboard->pdata;
 
         if (!(seaboard->gpio_requested & GPIO_HP_MUTE))
                 return 0;
 
         gpio_set_value_cansleep(pdata->gpio_hp_mute,
                                 !SND_SOC_DAPM_EVENT_ON(event));
 
         return 0;
 }
+
+static int seaboard_event_dmic(struct snd_soc_dapm_widget *w,
+                                struct snd_kcontrol *k, int event)
+{
+        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_card *card = codec->card;
+        struct tegra_seaboard *seaboard = snd_soc_card_get_drvdata(card);
+
+        if (IS_ERR(seaboard->vdd_dmic))
+                return 0;
+
+        if (SND_SOC_DAPM_EVENT_ON(event)) {
+                return regulator_enable(seaboard->vdd_dmic);
+        } else {
+                if (!seaboard->first_dmic_event)
+                        return regulator_disable(seaboard->vdd_dmic);
+        }
+
+        seaboard->first_dmic_event = false;
+}
+
 static const struct snd_soc_dapm_widget seaboard_dapm_widgets[] = {
         SND_SOC_DAPM_SPK("Int Spk", seaboard_event_int_spk),
         SND_SOC_DAPM_HP("Headphone Jack", seaboard_event_hp),
         SND_SOC_DAPM_MIC("Mic Jack", NULL),
-        SND_SOC_DAPM_MIC("Digital Mic", NULL),
+        SND_SOC_DAPM_MIC("Digital Mic", seaboard_event_dmic),
 };
 
 static const struct snd_soc_dapm_route seaboard_audio_map[] = {
         {"Headphone Jack", NULL, "HPOUTR"},
         {"Headphone Jack", NULL, "HPOUTL"},
         {"Int Spk", NULL, "ROP"},
         {"Int Spk", NULL, "RON"},
         {"Int Spk", NULL, "LOP"},
         {"Int Spk", NULL, "LON"},
         {"Mic Bias", NULL, "Mic Jack"},
@@ skipping 171 matching lines @@
                 dev_err(&pdev->dev, "Can't allocate tegra_seaboard\n");
                 return -ENOMEM;
         }
 
         seaboard->pdata = pdata;
 
         ret = tegra_asoc_utils_init(&seaboard->util_data, &pdev->dev);
         if (ret)
                 goto err_free_seaboard;
 
+        seaboard->vdd_dmic = regulator_get(&pdev->dev, "vdd_dmic");
+        if (IS_ERR(seaboard->vdd_dmic)) {
+                dev_info(&pdev->dev, "regulator_get() returned error %ld\n",
+                         PTR_ERR(seaboard->vdd_dmic));
+                ret = PTR_ERR(seaboard->vdd_dmic);
+                goto err_fini_utils;
+        }
+        seaboard->first_dmic_event = true;
+
         card->dev = &pdev->dev;
         platform_set_drvdata(pdev, card);
         snd_soc_card_set_drvdata(card, seaboard);
 
         ret = snd_soc_register_card(card);
         if (ret) {
                 dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
                         ret);
                 goto err_clear_drvdata;
         }
 
         return 0;
 
 err_clear_drvdata:
         snd_soc_card_set_drvdata(card, NULL);
         platform_set_drvdata(pdev, NULL);
         card->dev = NULL;

[jiesun, 2011/04/25 18:21:04]

missing a regulator_put here.

+err_fini_utils:
         tegra_asoc_utils_fini(&seaboard->util_data);
 err_free_seaboard:
         kfree(seaboard);
         return ret;
 }
 
 static int __devexit tegra_snd_seaboard_remove(struct platform_device *pdev)
 {
         struct snd_soc_card *card = platform_get_drvdata(pdev);
         struct tegra_seaboard *seaboard = snd_soc_card_get_drvdata(card);
         struct seaboard_audio_platform_data *pdata = seaboard->pdata;
 
         snd_soc_unregister_card(card);
 
         snd_soc_card_set_drvdata(card, NULL);
         platform_set_drvdata(pdev, NULL);
         card->dev = NULL;
 
+        regulator_put(seaboard->vdd_dmic);
+
         tegra_asoc_utils_fini(&seaboard->util_data);
 
         if (seaboard->gpio_requested & GPIO_HP_MUTE)
                 gpio_free(pdata->gpio_hp_mute);
         if (seaboard->gpio_requested & GPIO_SPKR_EN)
                 gpio_free(pdata->gpio_spkr_en);
 
         kfree(seaboard);
 
         return 0;
@@ skipping 18 matching lines @@
 static void __exit snd_tegra_seaboard_exit(void)
 {
         platform_driver_unregister(&tegra_snd_seaboard_driver);
 }
 module_exit(snd_tegra_seaboard_exit);
 
 MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>");
 MODULE_DESCRIPTION("Seaboard machine ASoC driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:" DRV_NAME);