sound/soc/omap/zoom2.c

   1 /*
   2  * zoom2.c  --  SoC audio for Zoom2
   3  *
   4  * Author: Misael Lopez Cruz <x0052729@ti.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * version 2 as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  18  * 02110-1301 USA
  19  *
  20  */
  21
  22 #include <linux/clk.h>
  23 #include <linux/platform_device.h>
  24 #include <sound/core.h>
  25 #include <sound/pcm.h>
  26 #include <sound/soc.h>
  27 #include <sound/soc-dapm.h>
  28
  29 #include <asm/mach-types.h>
  30 #include <mach/hardware.h>
  31 #include <mach/gpio.h>
  32 #include <plat/mcbsp.h>
  33
  34 #include "omap-mcbsp.h"
  35 #include "omap-pcm.h"
  36 #include "../codecs/twl4030.h"
  37
  38 #define ZOOM2_HEADSET_MUX_GPIO          (OMAP_MAX_GPIO_LINES + 15)
  39 #define ZOOM2_HEADSET_EXTMUTE_GPIO      153
  40
  41 static int zoom2_hw_params(struct snd_pcm_substream *substream,
  42                                 struct snd_pcm_hw_params *params)
  43 {
  44         struct snd_soc_pcm_runtime *rtd = substream->private_data;
  45         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
  46         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
  47         int ret;
  48
  49         /* Set codec DAI configuration */
  50         ret = snd_soc_dai_set_fmt(codec_dai,
  51                                   SND_SOC_DAIFMT_I2S |
  52                                   SND_SOC_DAIFMT_NB_NF |
  53                                   SND_SOC_DAIFMT_CBM_CFM);
  54         if (ret < 0) {
  55                 printk(KERN_ERR "can't set codec DAI configuration\n");
  56                 return ret;
  57         }
  58
  59         /* Set cpu DAI configuration */
  60         ret = snd_soc_dai_set_fmt(cpu_dai,
  61                                   SND_SOC_DAIFMT_I2S |
  62                                   SND_SOC_DAIFMT_NB_NF |
  63                                   SND_SOC_DAIFMT_CBM_CFM);
  64         if (ret < 0) {
  65                 printk(KERN_ERR "can't set cpu DAI configuration\n");
  66                 return ret;
  67         }
  68
  69         /* Set the codec system clock for DAC and ADC */
  70         ret = snd_soc_dai_set_sysclk(codec_dai, 0, 26000000,
  71                                         SND_SOC_CLOCK_IN);
  72         if (ret < 0) {
  73                 printk(KERN_ERR "can't set codec system clock\n");
  74                 return ret;
  75         }
  76
  77         return 0;
  78 }
  79
  80 static struct snd_soc_ops zoom2_ops = {
  81         .hw_params = zoom2_hw_params,
  82 };
  83
  84 static int zoom2_hw_voice_params(struct snd_pcm_substream *substream,
  85                                 struct snd_pcm_hw_params *params)
  86 {
  87         struct snd_soc_pcm_runtime *rtd = substream->private_data;
  88         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
  89         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
  90         int ret;
  91
  92         /* Set codec DAI configuration */
  93         ret = snd_soc_dai_set_fmt(codec_dai,
  94                                 SND_SOC_DAIFMT_DSP_A |
  95                                 SND_SOC_DAIFMT_IB_NF |
  96                                 SND_SOC_DAIFMT_CBM_CFM);
  97         if (ret) {
  98                 printk(KERN_ERR "can't set codec DAI configuration\n");
  99                 return ret;
 100         }
 101
 102         /* Set cpu DAI configuration */
 103         ret = snd_soc_dai_set_fmt(cpu_dai,
 104                                 SND_SOC_DAIFMT_DSP_A |
 105                                 SND_SOC_DAIFMT_IB_NF |
 106                                 SND_SOC_DAIFMT_CBM_CFM);
 107         if (ret < 0) {
 108                 printk(KERN_ERR "can't set cpu DAI configuration\n");
 109                 return ret;
 110         }
 111
 112         /* Set the codec system clock for DAC and ADC */
 113         ret = snd_soc_dai_set_sysclk(codec_dai, 0, 26000000,
 114                                         SND_SOC_CLOCK_IN);
 115         if (ret < 0) {
 116                 printk(KERN_ERR "can't set codec system clock\n");
 117                 return ret;
 118         }
 119
 120         return 0;
 121 }
 122
 123 static struct snd_soc_ops zoom2_voice_ops = {
 124         .hw_params = zoom2_hw_voice_params,
 125 };
 126
 127 /* Zoom2 machine DAPM */
 128 static const struct snd_soc_dapm_widget zoom2_twl4030_dapm_widgets[] = {
 129         SND_SOC_DAPM_MIC("Ext Mic", NULL),
 130         SND_SOC_DAPM_SPK("Ext Spk", NULL),
 131         SND_SOC_DAPM_MIC("Headset Mic", NULL),
 132         SND_SOC_DAPM_HP("Headset Stereophone", NULL),
 133         SND_SOC_DAPM_LINE("Aux In", NULL),
 134 };
 135
 136 static const struct snd_soc_dapm_route audio_map[] = {
 137         /* External Mics: MAINMIC, SUBMIC with bias*/
 138         {"MAINMIC", NULL, "Mic Bias 1"},
 139         {"SUBMIC", NULL, "Mic Bias 2"},
 140         {"Mic Bias 1", NULL, "Ext Mic"},
 141         {"Mic Bias 2", NULL, "Ext Mic"},
 142
 143         /* External Speakers: HFL, HFR */
 144         {"Ext Spk", NULL, "HFL"},
 145         {"Ext Spk", NULL, "HFR"},
 146
 147         /* Headset Stereophone:  HSOL, HSOR */
 148         {"Headset Stereophone", NULL, "HSOL"},
 149         {"Headset Stereophone", NULL, "HSOR"},
 150
 151         /* Headset Mic: HSMIC with bias */
 152         {"HSMIC", NULL, "Headset Mic Bias"},
 153         {"Headset Mic Bias", NULL, "Headset Mic"},
 154
 155         /* Aux In: AUXL, AUXR */
 156         {"Aux In", NULL, "AUXL"},
 157         {"Aux In", NULL, "AUXR"},
 158 };
 159
 160 static int zoom2_twl4030_init(struct snd_soc_codec *codec)
 161 {
 162         int ret;
 163
 164         /* Add Zoom2 specific widgets */
 165         ret = snd_soc_dapm_new_controls(codec, zoom2_twl4030_dapm_widgets,
 166                                 ARRAY_SIZE(zoom2_twl4030_dapm_widgets));
 167         if (ret)
 168                 return ret;
 169
 170         /* Set up Zoom2 specific audio path audio_map */
 171         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 172
 173         /* Zoom2 connected pins */
 174         snd_soc_dapm_enable_pin(codec, "Ext Mic");
 175         snd_soc_dapm_enable_pin(codec, "Ext Spk");
 176         snd_soc_dapm_enable_pin(codec, "Headset Mic");
 177         snd_soc_dapm_enable_pin(codec, "Headset Stereophone");
 178         snd_soc_dapm_enable_pin(codec, "Aux In");
 179
 180         /* TWL4030 not connected pins */
 181         snd_soc_dapm_nc_pin(codec, "CARKITMIC");
 182         snd_soc_dapm_nc_pin(codec, "DIGIMIC0");
 183         snd_soc_dapm_nc_pin(codec, "DIGIMIC1");
 184         snd_soc_dapm_nc_pin(codec, "EARPIECE");
 185         snd_soc_dapm_nc_pin(codec, "PREDRIVEL");
 186         snd_soc_dapm_nc_pin(codec, "PREDRIVER");
 187         snd_soc_dapm_nc_pin(codec, "CARKITL");
 188         snd_soc_dapm_nc_pin(codec, "CARKITR");
 189
 190         ret = snd_soc_dapm_sync(codec);
 191
 192         return ret;
 193 }
 194
 195 static int zoom2_twl4030_voice_init(struct snd_soc_codec *codec)
 196 {
 197         unsigned short reg;
 198
 199         /* Enable voice interface */
 200         reg = codec->read(codec, TWL4030_REG_VOICE_IF);
 201         reg |= TWL4030_VIF_DIN_EN | TWL4030_VIF_DOUT_EN | TWL4030_VIF_EN;
 202         codec->write(codec, TWL4030_REG_VOICE_IF, reg);
 203
 204         return 0;
 205 }
 206
 207 /* Digital audio interface glue - connects codec <--> CPU */
 208 static struct snd_soc_dai_link zoom2_dai[] = {
 209         {
 210                 .name = "TWL4030 I2S",
 211                 .stream_name = "TWL4030 Audio",
 212                 .cpu_dai = &omap_mcbsp_dai[0],
 213                 .codec_dai = &twl4030_dai[TWL4030_DAI_HIFI],
 214                 .init = zoom2_twl4030_init,
 215                 .ops = &zoom2_ops,
 216         },
 217         {
 218                 .name = "TWL4030 PCM",
 219                 .stream_name = "TWL4030 Voice",
 220                 .cpu_dai = &omap_mcbsp_dai[1],
 221                 .codec_dai = &twl4030_dai[TWL4030_DAI_VOICE],
 222                 .init = zoom2_twl4030_voice_init,
 223                 .ops = &zoom2_voice_ops,
 224         },
 225 };
 226
 227 /* Audio machine driver */
 228 static struct snd_soc_card snd_soc_zoom2 = {
 229         .name = "Zoom2",
 230         .platform = &omap_soc_platform,
 231         .dai_link = zoom2_dai,
 232         .num_links = ARRAY_SIZE(zoom2_dai),
 233 };
 234
 235 /* EXTMUTE callback function */
 236 void zoom2_set_hs_extmute(int mute)
 237 {
 238         gpio_set_value(ZOOM2_HEADSET_EXTMUTE_GPIO, mute);
 239 }
 240
 241 /* twl4030 setup */
 242 static struct twl4030_setup_data twl4030_setup = {
 243         .ramp_delay_value = 3,  /* 161 ms */
 244         .sysclk = 26000,
 245         .hs_extmute = 1,
 246         .set_hs_extmute = zoom2_set_hs_extmute,
 247 };
 248
 249 /* Audio subsystem */
 250 static struct snd_soc_device zoom2_snd_devdata = {
 251         .card = &snd_soc_zoom2,
 252         .codec_dev = &soc_codec_dev_twl4030,
 253         .codec_data = &twl4030_setup,
 254 };
 255
 256 static struct platform_device *zoom2_snd_device;
 257
 258 static int __init zoom2_soc_init(void)
 259 {
 260         int ret;
 261
 262         if (!machine_is_omap_zoom2()) {
 263                 pr_debug("Not Zoom2!\n");
 264                 return -ENODEV;
 265         }
 266         printk(KERN_INFO "Zoom2 SoC init\n");
 267
 268         zoom2_snd_device = platform_device_alloc("soc-audio", -1);
 269         if (!zoom2_snd_device) {
 270                 printk(KERN_ERR "Platform device allocation failed\n");
 271                 return -ENOMEM;
 272         }
 273
 274         platform_set_drvdata(zoom2_snd_device, &zoom2_snd_devdata);
 275         zoom2_snd_devdata.dev = &zoom2_snd_device->dev;
 276         *(unsigned int *)zoom2_dai[0].cpu_dai->private_data = 1; /* McBSP2 */
 277         *(unsigned int *)zoom2_dai[1].cpu_dai->private_data = 2; /* McBSP3 */
 278
 279         ret = platform_device_add(zoom2_snd_device);
 280         if (ret)
 281                 goto err1;
 282
 283         BUG_ON(gpio_request(ZOOM2_HEADSET_MUX_GPIO, "hs_mux") < 0);
 284         gpio_direction_output(ZOOM2_HEADSET_MUX_GPIO, 0);
 285
 286         BUG_ON(gpio_request(ZOOM2_HEADSET_EXTMUTE_GPIO, "ext_mute") < 0);
 287         gpio_direction_output(ZOOM2_HEADSET_EXTMUTE_GPIO, 0);
 288
 289         return 0;
 290
 291 err1:
 292         printk(KERN_ERR "Unable to add platform device\n");
 293         platform_device_put(zoom2_snd_device);
 294
 295         return ret;
 296 }
 297 module_init(zoom2_soc_init);
 298
 299 static void __exit zoom2_soc_exit(void)
 300 {
 301         gpio_free(ZOOM2_HEADSET_MUX_GPIO);
 302         gpio_free(ZOOM2_HEADSET_EXTMUTE_GPIO);
 303
 304         platform_device_unregister(zoom2_snd_device);
 305 }
 306 module_exit(zoom2_soc_exit);
 307
 308 MODULE_AUTHOR("Misael Lopez Cruz <x0052729@ti.com>");
 309 MODULE_DESCRIPTION("ALSA SoC Zoom2");
 310 MODULE_LICENSE("GPL");
 311