sound/soc/pxa/tosa.c

   1 /*
   2  * tosa.c  --  SoC audio for Tosa
   3  *
   4  * Copyright 2005 Wolfson Microelectronics PLC.
   5  * Copyright 2005 Openedhand Ltd.
   6  *
   7  * Authors: Liam Girdwood <lrg@slimlogic.co.uk>
   8  *          Richard Purdie <richard@openedhand.com>
   9  *
  10  *  This program is free software; you can redistribute  it and/or modify it
  11  *  under  the terms of  the GNU General  Public License as published by the
  12  *  Free Software Foundation;  either version 2 of the  License, or (at your
  13  *  option) any later version.
  14  *
  15  * GPIO's
  16  *  1 - Jack Insertion
  17  *  5 - Hookswitch (headset answer/hang up switch)
  18  *
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/moduleparam.h>
  23 #include <linux/device.h>
  24 #include <linux/gpio.h>
  25
  26 #include <sound/core.h>
  27 #include <sound/pcm.h>
  28 #include <sound/soc.h>
  29
  30 #include <asm/mach-types.h>
  31 #include <mach/tosa.h>
  32 #include <mach/audio.h>
  33
  34 #define TOSA_HP        0
  35 #define TOSA_MIC_INT   1
  36 #define TOSA_HEADSET   2
  37 #define TOSA_HP_OFF    3
  38 #define TOSA_SPK_ON    0
  39 #define TOSA_SPK_OFF   1
  40
  41 static int tosa_jack_func;
  42 static int tosa_spk_func;
  43
  44 static void tosa_ext_control(struct snd_soc_dapm_context *dapm)
  45 {
  46
  47         snd_soc_dapm_mutex_lock(dapm);
  48
  49         /* set up jack connection */
  50         switch (tosa_jack_func) {
  51         case TOSA_HP:
  52                 snd_soc_dapm_disable_pin_unlocked(dapm, "Mic (Internal)");
  53                 snd_soc_dapm_enable_pin_unlocked(dapm, "Headphone Jack");
  54                 snd_soc_dapm_disable_pin_unlocked(dapm, "Headset Jack");
  55                 break;
  56         case TOSA_MIC_INT:
  57                 snd_soc_dapm_enable_pin_unlocked(dapm, "Mic (Internal)");
  58                 snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
  59                 snd_soc_dapm_disable_pin_unlocked(dapm, "Headset Jack");
  60                 break;
  61         case TOSA_HEADSET:
  62                 snd_soc_dapm_disable_pin_unlocked(dapm, "Mic (Internal)");
  63                 snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
  64                 snd_soc_dapm_enable_pin_unlocked(dapm, "Headset Jack");
  65                 break;
  66         }
  67
  68         if (tosa_spk_func == TOSA_SPK_ON)
  69                 snd_soc_dapm_enable_pin_unlocked(dapm, "Speaker");
  70         else
  71                 snd_soc_dapm_disable_pin_unlocked(dapm, "Speaker");
  72
  73         snd_soc_dapm_sync_unlocked(dapm);
  74
  75         snd_soc_dapm_mutex_unlock(dapm);
  76 }
  77
  78 static int tosa_startup(struct snd_pcm_substream *substream)
  79 {
  80         struct snd_soc_pcm_runtime *rtd = substream->private_data;
  81
  82         /* check the jack status at stream startup */
  83         tosa_ext_control(&rtd->card->dapm);
  84
  85         return 0;
  86 }
  87
  88 static const struct snd_soc_ops tosa_ops = {
  89         .startup = tosa_startup,
  90 };
  91
  92 static int tosa_get_jack(struct snd_kcontrol *kcontrol,
  93         struct snd_ctl_elem_value *ucontrol)
  94 {
  95         ucontrol->value.enumerated.item[0] = tosa_jack_func;
  96         return 0;
  97 }
  98
  99 static int tosa_set_jack(struct snd_kcontrol *kcontrol,
 100         struct snd_ctl_elem_value *ucontrol)
 101 {
 102         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
 103
 104         if (tosa_jack_func == ucontrol->value.enumerated.item[0])
 105                 return 0;
 106
 107         tosa_jack_func = ucontrol->value.enumerated.item[0];
 108         tosa_ext_control(&card->dapm);
 109         return 1;
 110 }
 111
 112 static int tosa_get_spk(struct snd_kcontrol *kcontrol,
 113         struct snd_ctl_elem_value *ucontrol)
 114 {
 115         ucontrol->value.enumerated.item[0] = tosa_spk_func;
 116         return 0;
 117 }
 118
 119 static int tosa_set_spk(struct snd_kcontrol *kcontrol,
 120         struct snd_ctl_elem_value *ucontrol)
 121 {
 122         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
 123
 124         if (tosa_spk_func == ucontrol->value.enumerated.item[0])
 125                 return 0;
 126
 127         tosa_spk_func = ucontrol->value.enumerated.item[0];
 128         tosa_ext_control(&card->dapm);
 129         return 1;
 130 }
 131
 132 /* tosa dapm event handlers */
 133 static int tosa_hp_event(struct snd_soc_dapm_widget *w,
 134         struct snd_kcontrol *k, int event)
 135 {
 136         gpio_set_value(TOSA_GPIO_L_MUTE, SND_SOC_DAPM_EVENT_ON(event) ? 1 : 0);
 137         return 0;
 138 }
 139
 140 /* tosa machine dapm widgets */
 141 static const struct snd_soc_dapm_widget tosa_dapm_widgets[] = {
 142 SND_SOC_DAPM_HP("Headphone Jack", tosa_hp_event),
 143 SND_SOC_DAPM_HP("Headset Jack", NULL),
 144 SND_SOC_DAPM_MIC("Mic (Internal)", NULL),
 145 SND_SOC_DAPM_SPK("Speaker", NULL),
 146 };
 147
 148 /* tosa audio map */
 149 static const struct snd_soc_dapm_route audio_map[] = {
 150
 151         /* headphone connected to HPOUTL, HPOUTR */
 152         {"Headphone Jack", NULL, "HPOUTL"},
 153         {"Headphone Jack", NULL, "HPOUTR"},
 154
 155         /* ext speaker connected to LOUT2, ROUT2 */
 156         {"Speaker", NULL, "LOUT2"},
 157         {"Speaker", NULL, "ROUT2"},
 158
 159         /* internal mic is connected to mic1, mic2 differential - with bias */
 160         {"MIC1", NULL, "Mic Bias"},
 161         {"MIC2", NULL, "Mic Bias"},
 162         {"Mic Bias", NULL, "Mic (Internal)"},
 163
 164         /* headset is connected to HPOUTR, and LINEINR with bias */
 165         {"Headset Jack", NULL, "HPOUTR"},
 166         {"LINEINR", NULL, "Mic Bias"},
 167         {"Mic Bias", NULL, "Headset Jack"},
 168 };
 169
 170 static const char * const jack_function[] = {"Headphone", "Mic", "Line",
 171         "Headset", "Off"};
 172 static const char * const spk_function[] = {"On", "Off"};
 173 static const struct soc_enum tosa_enum[] = {
 174         SOC_ENUM_SINGLE_EXT(5, jack_function),
 175         SOC_ENUM_SINGLE_EXT(2, spk_function),
 176 };
 177
 178 static const struct snd_kcontrol_new tosa_controls[] = {
 179         SOC_ENUM_EXT("Jack Function", tosa_enum[0], tosa_get_jack,
 180                 tosa_set_jack),
 181         SOC_ENUM_EXT("Speaker Function", tosa_enum[1], tosa_get_spk,
 182                 tosa_set_spk),
 183 };
 184
 185 static struct snd_soc_dai_link tosa_dai[] = {
 186 {
 187         .name = "AC97",
 188         .stream_name = "AC97 HiFi",
 189         .cpu_dai_name = "pxa2xx-ac97",
 190         .codec_dai_name = "wm9712-hifi",
 191         .platform_name = "pxa-pcm-audio",
 192         .codec_name = "wm9712-codec",
 193         .ops = &tosa_ops,
 194 },
 195 {
 196         .name = "AC97 Aux",
 197         .stream_name = "AC97 Aux",
 198         .cpu_dai_name = "pxa2xx-ac97-aux",
 199         .codec_dai_name = "wm9712-aux",
 200         .platform_name = "pxa-pcm-audio",
 201         .codec_name = "wm9712-codec",
 202         .ops = &tosa_ops,
 203 },
 204 };
 205
 206 static struct snd_soc_card tosa = {
 207         .name = "Tosa",
 208         .owner = THIS_MODULE,
 209         .dai_link = tosa_dai,
 210         .num_links = ARRAY_SIZE(tosa_dai),
 211
 212         .controls = tosa_controls,
 213         .num_controls = ARRAY_SIZE(tosa_controls),
 214         .dapm_widgets = tosa_dapm_widgets,
 215         .num_dapm_widgets = ARRAY_SIZE(tosa_dapm_widgets),
 216         .dapm_routes = audio_map,
 217         .num_dapm_routes = ARRAY_SIZE(audio_map),
 218         .fully_routed = true,
 219 };
 220
 221 static int tosa_probe(struct platform_device *pdev)
 222 {
 223         struct snd_soc_card *card = &tosa;
 224         int ret;
 225
 226         ret = gpio_request_one(TOSA_GPIO_L_MUTE, GPIOF_OUT_INIT_LOW,
 227                                "Headphone Jack");
 228         if (ret)
 229                 return ret;
 230
 231         card->dev = &pdev->dev;
 232
 233         ret = devm_snd_soc_register_card(&pdev->dev, card);
 234         if (ret) {
 235                 dev_err(&pdev->dev, "snd_soc_register_card() failed: %d\n",
 236                         ret);
 237                 gpio_free(TOSA_GPIO_L_MUTE);
 238         }
 239         return ret;
 240 }
 241
 242 static int tosa_remove(struct platform_device *pdev)
 243 {
 244         gpio_free(TOSA_GPIO_L_MUTE);
 245         return 0;
 246 }
 247
 248 static struct platform_driver tosa_driver = {
 249         .driver         = {
 250                 .name   = "tosa-audio",
 251                 .pm     = &snd_soc_pm_ops,
 252         },
 253         .probe          = tosa_probe,
 254         .remove         = tosa_remove,
 255 };
 256
 257 module_platform_driver(tosa_driver);
 258
 259 /* Module information */
 260 MODULE_AUTHOR("Richard Purdie");
 261 MODULE_DESCRIPTION("ALSA SoC Tosa");
 262 MODULE_LICENSE("GPL");
 263 MODULE_ALIAS("platform:tosa-audio");