sound/soc/s3c24xx/neo1973_wm8753.c

   1 /*
   2  * neo1973_wm8753.c  --  SoC audio for Neo1973
   3  *
   4  * Copyright 2007 Wolfson Microelectronics PLC.
   5  * Author: Graeme Gregory
   6  *         graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
   7  *
   8  *  This program is free software; you can redistribute  it and/or modify it
   9  *  under  the terms of  the GNU General  Public License as published by the
  10  *  Free Software Foundation;  either version 2 of the  License, or (at your
  11  *  option) any later version.
  12  *
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/moduleparam.h>
  17 #include <linux/timer.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/i2c.h>
  21 #include <sound/core.h>
  22 #include <sound/pcm.h>
  23 #include <sound/soc.h>
  24 #include <sound/soc-dapm.h>
  25 #include <sound/tlv.h>
  26
  27 #include <asm/mach-types.h>
  28 #include <asm/hardware/scoop.h>
  29 #include <mach/regs-clock.h>
  30 #include <mach/regs-gpio.h>
  31 #include <mach/hardware.h>
  32 #include <linux/io.h>
  33 #include <mach/spi-gpio.h>
  34
  35 #include <plat/regs-iis.h>
  36
  37 #include "../codecs/wm8753.h"
  38 #include "lm4857.h"
  39 #include "s3c-dma.h"
  40 #include "s3c24xx-i2s.h"
  41
  42 /* define the scenarios */
  43 #define NEO_AUDIO_OFF                   0
  44 #define NEO_GSM_CALL_AUDIO_HANDSET      1
  45 #define NEO_GSM_CALL_AUDIO_HEADSET      2
  46 #define NEO_GSM_CALL_AUDIO_BLUETOOTH    3
  47 #define NEO_STEREO_TO_SPEAKERS          4
  48 #define NEO_STEREO_TO_HEADPHONES        5
  49 #define NEO_CAPTURE_HANDSET             6
  50 #define NEO_CAPTURE_HEADSET             7
  51 #define NEO_CAPTURE_BLUETOOTH           8
  52
  53 static struct snd_soc_card neo1973;
  54 static struct i2c_client *i2c;
  55
  56 static int neo1973_hifi_hw_params(struct snd_pcm_substream *substream,
  57         struct snd_pcm_hw_params *params)
  58 {
  59         struct snd_soc_pcm_runtime *rtd = substream->private_data;
  60         struct snd_soc_dai *codec_dai = rtd->codec_dai;
  61         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
  62         unsigned int pll_out = 0, bclk = 0;
  63         int ret = 0;
  64         unsigned long iis_clkrate;
  65
  66         pr_debug("Entered %s\n", __func__);
  67
  68         iis_clkrate = s3c24xx_i2s_get_clockrate();
  69
  70         switch (params_rate(params)) {
  71         case 8000:
  72         case 16000:
  73                 pll_out = 12288000;
  74                 break;
  75         case 48000:
  76                 bclk = WM8753_BCLK_DIV_4;
  77                 pll_out = 12288000;
  78                 break;
  79         case 96000:
  80                 bclk = WM8753_BCLK_DIV_2;
  81                 pll_out = 12288000;
  82                 break;
  83         case 11025:
  84                 bclk = WM8753_BCLK_DIV_16;
  85                 pll_out = 11289600;
  86                 break;
  87         case 22050:
  88                 bclk = WM8753_BCLK_DIV_8;
  89                 pll_out = 11289600;
  90                 break;
  91         case 44100:
  92                 bclk = WM8753_BCLK_DIV_4;
  93                 pll_out = 11289600;
  94                 break;
  95         case 88200:
  96                 bclk = WM8753_BCLK_DIV_2;
  97                 pll_out = 11289600;
  98                 break;
  99         }
 100
 101         /* set codec DAI configuration */
 102         ret = snd_soc_dai_set_fmt(codec_dai,
 103                 SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 104                 SND_SOC_DAIFMT_CBM_CFM);
 105         if (ret < 0)
 106                 return ret;
 107
 108         /* set cpu DAI configuration */
 109         ret = snd_soc_dai_set_fmt(cpu_dai,
 110                 SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 111                 SND_SOC_DAIFMT_CBM_CFM);
 112         if (ret < 0)
 113                 return ret;
 114
 115         /* set the codec system clock for DAC and ADC */
 116         ret = snd_soc_dai_set_sysclk(codec_dai, WM8753_MCLK, pll_out,
 117                 SND_SOC_CLOCK_IN);
 118         if (ret < 0)
 119                 return ret;
 120
 121         /* set MCLK division for sample rate */
 122         ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_MCLK,
 123                 S3C2410_IISMOD_32FS);
 124         if (ret < 0)
 125                 return ret;
 126
 127         /* set codec BCLK division for sample rate */
 128         ret = snd_soc_dai_set_clkdiv(codec_dai, WM8753_BCLKDIV, bclk);
 129         if (ret < 0)
 130                 return ret;
 131
 132         /* set prescaler division for sample rate */
 133         ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_PRESCALER,
 134                 S3C24XX_PRESCALE(4, 4));
 135         if (ret < 0)
 136                 return ret;
 137
 138         /* codec PLL input is PCLK/4 */
 139         ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0,
 140                 iis_clkrate / 4, pll_out);
 141         if (ret < 0)
 142                 return ret;
 143
 144         return 0;
 145 }
 146
 147 static int neo1973_hifi_hw_free(struct snd_pcm_substream *substream)
 148 {
 149         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 150         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 151
 152         pr_debug("Entered %s\n", __func__);
 153
 154         /* disable the PLL */
 155         return snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0, 0, 0);
 156 }
 157
 158 /*
 159  * Neo1973 WM8753 HiFi DAI opserations.
 160  */
 161 static struct snd_soc_ops neo1973_hifi_ops = {
 162         .hw_params = neo1973_hifi_hw_params,
 163         .hw_free = neo1973_hifi_hw_free,
 164 };
 165
 166 static int neo1973_voice_hw_params(struct snd_pcm_substream *substream,
 167         struct snd_pcm_hw_params *params)
 168 {
 169         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 170         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 171         unsigned int pcmdiv = 0;
 172         int ret = 0;
 173         unsigned long iis_clkrate;
 174
 175         pr_debug("Entered %s\n", __func__);
 176
 177         iis_clkrate = s3c24xx_i2s_get_clockrate();
 178
 179         if (params_rate(params) != 8000)
 180                 return -EINVAL;
 181         if (params_channels(params) != 1)
 182                 return -EINVAL;
 183
 184         pcmdiv = WM8753_PCM_DIV_6; /* 2.048 MHz */
 185
 186         /* todo: gg check mode (DSP_B) against CSR datasheet */
 187         /* set codec DAI configuration */
 188         ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_DSP_B |
 189                 SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
 190         if (ret < 0)
 191                 return ret;
 192
 193         /* set the codec system clock for DAC and ADC */
 194         ret = snd_soc_dai_set_sysclk(codec_dai, WM8753_PCMCLK, 12288000,
 195                 SND_SOC_CLOCK_IN);
 196         if (ret < 0)
 197                 return ret;
 198
 199         /* set codec PCM division for sample rate */
 200         ret = snd_soc_dai_set_clkdiv(codec_dai, WM8753_PCMDIV, pcmdiv);
 201         if (ret < 0)
 202                 return ret;
 203
 204         /* configure and enable PLL for 12.288MHz output */
 205         ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0,
 206                 iis_clkrate / 4, 12288000);
 207         if (ret < 0)
 208                 return ret;
 209
 210         return 0;
 211 }
 212
 213 static int neo1973_voice_hw_free(struct snd_pcm_substream *substream)
 214 {
 215         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 216         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 217
 218         pr_debug("Entered %s\n", __func__);
 219
 220         /* disable the PLL */
 221         return snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0, 0, 0);
 222 }
 223
 224 static struct snd_soc_ops neo1973_voice_ops = {
 225         .hw_params = neo1973_voice_hw_params,
 226         .hw_free = neo1973_voice_hw_free,
 227 };
 228
 229 static int neo1973_scenario;
 230
 231 static int neo1973_get_scenario(struct snd_kcontrol *kcontrol,
 232         struct snd_ctl_elem_value *ucontrol)
 233 {
 234         ucontrol->value.integer.value[0] = neo1973_scenario;
 235         return 0;
 236 }
 237
 238 static int set_scenario_endpoints(struct snd_soc_codec *codec, int scenario)
 239 {
 240         pr_debug("Entered %s\n", __func__);
 241
 242         switch (neo1973_scenario) {
 243         case NEO_AUDIO_OFF:
 244                 snd_soc_dapm_disable_pin(codec, "Audio Out");
 245                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
 246                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
 247                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
 248                 snd_soc_dapm_disable_pin(codec, "Call Mic");
 249                 break;
 250         case NEO_GSM_CALL_AUDIO_HANDSET:
 251                 snd_soc_dapm_enable_pin(codec, "Audio Out");
 252                 snd_soc_dapm_enable_pin(codec, "GSM Line Out");
 253                 snd_soc_dapm_enable_pin(codec, "GSM Line In");
 254                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
 255                 snd_soc_dapm_enable_pin(codec, "Call Mic");
 256                 break;
 257         case NEO_GSM_CALL_AUDIO_HEADSET:
 258                 snd_soc_dapm_enable_pin(codec, "Audio Out");
 259                 snd_soc_dapm_enable_pin(codec, "GSM Line Out");
 260                 snd_soc_dapm_enable_pin(codec, "GSM Line In");
 261                 snd_soc_dapm_enable_pin(codec, "Headset Mic");
 262                 snd_soc_dapm_disable_pin(codec, "Call Mic");
 263                 break;
 264         case NEO_GSM_CALL_AUDIO_BLUETOOTH:
 265                 snd_soc_dapm_disable_pin(codec, "Audio Out");
 266                 snd_soc_dapm_enable_pin(codec, "GSM Line Out");
 267                 snd_soc_dapm_enable_pin(codec, "GSM Line In");
 268                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
 269                 snd_soc_dapm_disable_pin(codec, "Call Mic");
 270                 break;
 271         case NEO_STEREO_TO_SPEAKERS:
 272                 snd_soc_dapm_enable_pin(codec, "Audio Out");
 273                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
 274                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
 275                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
 276                 snd_soc_dapm_disable_pin(codec, "Call Mic");
 277                 break;
 278         case NEO_STEREO_TO_HEADPHONES:
 279                 snd_soc_dapm_enable_pin(codec, "Audio Out");
 280                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
 281                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
 282                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
 283                 snd_soc_dapm_disable_pin(codec, "Call Mic");
 284                 break;
 285         case NEO_CAPTURE_HANDSET:
 286                 snd_soc_dapm_disable_pin(codec, "Audio Out");
 287                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
 288                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
 289                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
 290                 snd_soc_dapm_enable_pin(codec, "Call Mic");
 291                 break;
 292         case NEO_CAPTURE_HEADSET:
 293                 snd_soc_dapm_disable_pin(codec, "Audio Out");
 294                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
 295                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
 296                 snd_soc_dapm_enable_pin(codec, "Headset Mic");
 297                 snd_soc_dapm_disable_pin(codec, "Call Mic");
 298                 break;
 299         case NEO_CAPTURE_BLUETOOTH:
 300                 snd_soc_dapm_disable_pin(codec, "Audio Out");
 301                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
 302                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
 303                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
 304                 snd_soc_dapm_disable_pin(codec, "Call Mic");
 305                 break;
 306         default:
 307                 snd_soc_dapm_disable_pin(codec, "Audio Out");
 308                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
 309                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
 310                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
 311                 snd_soc_dapm_disable_pin(codec, "Call Mic");
 312         }
 313
 314         snd_soc_dapm_sync(codec);
 315
 316         return 0;
 317 }
 318
 319 static int neo1973_set_scenario(struct snd_kcontrol *kcontrol,
 320         struct snd_ctl_elem_value *ucontrol)
 321 {
 322         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 323
 324         pr_debug("Entered %s\n", __func__);
 325
 326         if (neo1973_scenario == ucontrol->value.integer.value[0])
 327                 return 0;
 328
 329         neo1973_scenario = ucontrol->value.integer.value[0];
 330         set_scenario_endpoints(codec, neo1973_scenario);
 331         return 1;
 332 }
 333
 334 static u8 lm4857_regs[4] = {0x00, 0x40, 0x80, 0xC0};
 335
 336 static void lm4857_write_regs(void)
 337 {
 338         pr_debug("Entered %s\n", __func__);
 339
 340         if (i2c_master_send(i2c, lm4857_regs, 4) != 4)
 341                 printk(KERN_ERR "lm4857: i2c write failed\n");
 342 }
 343
 344 static int lm4857_get_reg(struct snd_kcontrol *kcontrol,
 345         struct snd_ctl_elem_value *ucontrol)
 346 {
 347         struct soc_mixer_control *mc =
 348                 (struct soc_mixer_control *)kcontrol->private_value;
 349         int reg = mc->reg;
 350         int shift = mc->shift;
 351         int mask = mc->max;
 352
 353         pr_debug("Entered %s\n", __func__);
 354
 355         ucontrol->value.integer.value[0] = (lm4857_regs[reg] >> shift) & mask;
 356         return 0;
 357 }
 358
 359 static int lm4857_set_reg(struct snd_kcontrol *kcontrol,
 360         struct snd_ctl_elem_value *ucontrol)
 361 {
 362         struct soc_mixer_control *mc =
 363                 (struct soc_mixer_control *)kcontrol->private_value;
 364         int reg = mc->reg;
 365         int shift = mc->shift;
 366         int mask = mc->max;
 367
 368         if (((lm4857_regs[reg] >> shift) & mask) ==
 369                 ucontrol->value.integer.value[0])
 370                 return 0;
 371
 372         lm4857_regs[reg] &= ~(mask << shift);
 373         lm4857_regs[reg] |= ucontrol->value.integer.value[0] << shift;
 374         lm4857_write_regs();
 375         return 1;
 376 }
 377
 378 static int lm4857_get_mode(struct snd_kcontrol *kcontrol,
 379         struct snd_ctl_elem_value *ucontrol)
 380 {
 381         u8 value = lm4857_regs[LM4857_CTRL] & 0x0F;
 382
 383         pr_debug("Entered %s\n", __func__);
 384
 385         if (value)
 386                 value -= 5;
 387
 388         ucontrol->value.integer.value[0] = value;
 389         return 0;
 390 }
 391
 392 static int lm4857_set_mode(struct snd_kcontrol *kcontrol,
 393         struct snd_ctl_elem_value *ucontrol)
 394 {
 395         u8 value = ucontrol->value.integer.value[0];
 396
 397         pr_debug("Entered %s\n", __func__);
 398
 399         if (value)
 400                 value += 5;
 401
 402         if ((lm4857_regs[LM4857_CTRL] & 0x0F) == value)
 403                 return 0;
 404
 405         lm4857_regs[LM4857_CTRL] &= 0xF0;
 406         lm4857_regs[LM4857_CTRL] |= value;
 407         lm4857_write_regs();
 408         return 1;
 409 }
 410
 411 static const struct snd_soc_dapm_widget wm8753_dapm_widgets[] = {
 412         SND_SOC_DAPM_LINE("Audio Out", NULL),
 413         SND_SOC_DAPM_LINE("GSM Line Out", NULL),
 414         SND_SOC_DAPM_LINE("GSM Line In", NULL),
 415         SND_SOC_DAPM_MIC("Headset Mic", NULL),
 416         SND_SOC_DAPM_MIC("Call Mic", NULL),
 417 };
 418
 419
 420 static const struct snd_soc_dapm_route dapm_routes[] = {
 421
 422         /* Connections to the lm4857 amp */
 423         {"Audio Out", NULL, "LOUT1"},
 424         {"Audio Out", NULL, "ROUT1"},
 425
 426         /* Connections to the GSM Module */
 427         {"GSM Line Out", NULL, "MONO1"},
 428         {"GSM Line Out", NULL, "MONO2"},
 429         {"RXP", NULL, "GSM Line In"},
 430         {"RXN", NULL, "GSM Line In"},
 431
 432         /* Connections to Headset */
 433         {"MIC1", NULL, "Mic Bias"},
 434         {"Mic Bias", NULL, "Headset Mic"},
 435
 436         /* Call Mic */
 437         {"MIC2", NULL, "Mic Bias"},
 438         {"MIC2N", NULL, "Mic Bias"},
 439         {"Mic Bias", NULL, "Call Mic"},
 440
 441         /* Connect the ALC pins */
 442         {"ACIN", NULL, "ACOP"},
 443 };
 444
 445 static const char *lm4857_mode[] = {
 446         "Off",
 447         "Call Speaker",
 448         "Stereo Speakers",
 449         "Stereo Speakers + Headphones",
 450         "Headphones"
 451 };
 452
 453 static const struct soc_enum lm4857_mode_enum[] = {
 454         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(lm4857_mode), lm4857_mode),
 455 };
 456
 457 static const char *neo_scenarios[] = {
 458         "Off",
 459         "GSM Handset",
 460         "GSM Headset",
 461         "GSM Bluetooth",
 462         "Speakers",
 463         "Headphones",
 464         "Capture Handset",
 465         "Capture Headset",
 466         "Capture Bluetooth"
 467 };
 468
 469 static const struct soc_enum neo_scenario_enum[] = {
 470         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(neo_scenarios), neo_scenarios),
 471 };
 472
 473 static const DECLARE_TLV_DB_SCALE(stereo_tlv, -4050, 150, 0);
 474 static const DECLARE_TLV_DB_SCALE(mono_tlv, -3450, 150, 0);
 475
 476 static const struct snd_kcontrol_new wm8753_neo1973_controls[] = {
 477         SOC_SINGLE_EXT_TLV("Amp Left Playback Volume", LM4857_LVOL, 0, 31, 0,
 478                 lm4857_get_reg, lm4857_set_reg, stereo_tlv),
 479         SOC_SINGLE_EXT_TLV("Amp Right Playback Volume", LM4857_RVOL, 0, 31, 0,
 480                 lm4857_get_reg, lm4857_set_reg, stereo_tlv),
 481         SOC_SINGLE_EXT_TLV("Amp Mono Playback Volume", LM4857_MVOL, 0, 31, 0,
 482                 lm4857_get_reg, lm4857_set_reg, mono_tlv),
 483         SOC_ENUM_EXT("Amp Mode", lm4857_mode_enum[0],
 484                 lm4857_get_mode, lm4857_set_mode),
 485         SOC_ENUM_EXT("Neo Mode", neo_scenario_enum[0],
 486                 neo1973_get_scenario, neo1973_set_scenario),
 487         SOC_SINGLE_EXT("Amp Spk 3D Playback Switch", LM4857_LVOL, 5, 1, 0,
 488                 lm4857_get_reg, lm4857_set_reg),
 489         SOC_SINGLE_EXT("Amp HP 3d Playback Switch", LM4857_RVOL, 5, 1, 0,
 490                 lm4857_get_reg, lm4857_set_reg),
 491         SOC_SINGLE_EXT("Amp Fast Wakeup Playback Switch", LM4857_CTRL, 5, 1, 0,
 492                 lm4857_get_reg, lm4857_set_reg),
 493         SOC_SINGLE_EXT("Amp Earpiece 6dB Playback Switch", LM4857_CTRL, 4, 1, 0,
 494                 lm4857_get_reg, lm4857_set_reg),
 495 };
 496
 497 /*
 498  * This is an example machine initialisation for a wm8753 connected to a
 499  * neo1973 II. It is missing logic to detect hp/mic insertions and logic
 500  * to re-route the audio in such an event.
 501  */
 502 static int neo1973_wm8753_init(struct snd_soc_pcm_runtime *rtd)
 503 {
 504         struct snd_soc_codec *codec = rtd->codec;
 505         int err;
 506
 507         pr_debug("Entered %s\n", __func__);
 508
 509         /* set up NC codec pins */
 510         snd_soc_dapm_nc_pin(codec, "LOUT2");
 511         snd_soc_dapm_nc_pin(codec, "ROUT2");
 512         snd_soc_dapm_nc_pin(codec, "OUT3");
 513         snd_soc_dapm_nc_pin(codec, "OUT4");
 514         snd_soc_dapm_nc_pin(codec, "LINE1");
 515         snd_soc_dapm_nc_pin(codec, "LINE2");
 516
 517         /* Add neo1973 specific widgets */
 518         snd_soc_dapm_new_controls(codec, wm8753_dapm_widgets,
 519                                   ARRAY_SIZE(wm8753_dapm_widgets));
 520
 521         /* set endpoints to default mode */
 522         set_scenario_endpoints(codec, NEO_AUDIO_OFF);
 523
 524         /* add neo1973 specific controls */
 525         err = snd_soc_add_controls(codec, wm8753_neo1973_controls,
 526                                 ARRAY_SIZE(8753_neo1973_controls));
 527         if (err < 0)
 528                 return err;
 529
 530         /* set up neo1973 specific audio routes */
 531         err = snd_soc_dapm_add_routes(codec, dapm_routes,
 532                                       ARRAY_SIZE(dapm_routes));
 533
 534         snd_soc_dapm_sync(codec);
 535         return 0;
 536 }
 537
 538 /*
 539  * BT Codec DAI
 540  */
 541 static struct snd_soc_dai bt_dai = {
 542         .name = "bluetooth-dai",
 543         .playback = {
 544                 .channels_min = 1,
 545                 .channels_max = 1,
 546                 .rates = SNDRV_PCM_RATE_8000,
 547                 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
 548         .capture = {
 549                 .channels_min = 1,
 550                 .channels_max = 1,
 551                 .rates = SNDRV_PCM_RATE_8000,
 552                 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
 553 };
 554
 555 static struct snd_soc_dai_link neo1973_dai[] = {
 556 { /* Hifi Playback - for similatious use with voice below */
 557         .name = "WM8753",
 558         .stream_name = "WM8753 HiFi",
 559         .platform_name = "s3c24xx-pcm-audio",
 560         .cpu_dai_name = "s3c24xx-i2s",
 561         .codec_dai_name = "wm8753-hifi",
 562         .codec_name = "wm8753-codec.0-0x1a",
 563         .init = neo1973_wm8753_init,
 564         .ops = &neo1973_hifi_ops,
 565 },
 566 { /* Voice via BT */
 567         .name = "Bluetooth",
 568         .stream_name = "Voice",
 569         .platform_name = "s3c24xx-pcm-audio",
 570         .cpu_dai_name = "bluetooth-dai",
 571         .codec_dai_name = "wm8753-voice",
 572         .codec_name = "wm8753-codec.0-0x1a",
 573         .ops = &neo1973_voice_ops,
 574 },
 575 };
 576
 577 static struct snd_soc_card neo1973 = {
 578         .name = "neo1973",
 579         .dai_link = neo1973_dai,
 580         .num_links = ARRAY_SIZE(neo1973_dai),
 581 };
 582
 583 static int lm4857_i2c_probe(struct i2c_client *client,
 584                             const struct i2c_device_id *id)
 585 {
 586         pr_debug("Entered %s\n", __func__);
 587
 588         i2c = client;
 589
 590         lm4857_write_regs();
 591         return 0;
 592 }
 593
 594 static int lm4857_i2c_remove(struct i2c_client *client)
 595 {
 596         pr_debug("Entered %s\n", __func__);
 597
 598         i2c = NULL;
 599
 600         return 0;
 601 }
 602
 603 static u8 lm4857_state;
 604
 605 static int lm4857_suspend(struct i2c_client *dev, pm_message_t state)
 606 {
 607         pr_debug("Entered %s\n", __func__);
 608
 609         dev_dbg(&dev->dev, "lm4857_suspend\n");
 610         lm4857_state = lm4857_regs[LM4857_CTRL] & 0xf;
 611         if (lm4857_state) {
 612                 lm4857_regs[LM4857_CTRL] &= 0xf0;
 613                 lm4857_write_regs();
 614         }
 615         return 0;
 616 }
 617
 618 static int lm4857_resume(struct i2c_client *dev)
 619 {
 620         pr_debug("Entered %s\n", __func__);
 621
 622         if (lm4857_state) {
 623                 lm4857_regs[LM4857_CTRL] |= (lm4857_state & 0x0f);
 624                 lm4857_write_regs();
 625         }
 626         return 0;
 627 }
 628
 629 static void lm4857_shutdown(struct i2c_client *dev)
 630 {
 631         pr_debug("Entered %s\n", __func__);
 632
 633         dev_dbg(&dev->dev, "lm4857_shutdown\n");
 634         lm4857_regs[LM4857_CTRL] &= 0xf0;
 635         lm4857_write_regs();
 636 }
 637
 638 static const struct i2c_device_id lm4857_i2c_id[] = {
 639         { "neo1973_lm4857", 0 },
 640         { }
 641 };
 642
 643 static struct i2c_driver lm4857_i2c_driver = {
 644         .driver = {
 645                 .name = "LM4857 I2C Amp",
 646                 .owner = THIS_MODULE,
 647         },
 648         .suspend =        lm4857_suspend,
 649         .resume =         lm4857_resume,
 650         .shutdown =       lm4857_shutdown,
 651         .probe =          lm4857_i2c_probe,
 652         .remove =         lm4857_i2c_remove,
 653         .id_table =       lm4857_i2c_id,
 654 };
 655
 656 static struct platform_device *neo1973_snd_device;
 657
 658 static int __init neo1973_init(void)
 659 {
 660         int ret;
 661
 662         pr_debug("Entered %s\n", __func__);
 663
 664         if (!machine_is_neo1973_gta01()) {
 665                 printk(KERN_INFO
 666                         "Only GTA01 hardware supported by ASoC driver\n");
 667                 return -ENODEV;
 668         }
 669
 670         neo1973_snd_device = platform_device_alloc("soc-audio", -1);
 671         if (!neo1973_snd_device)
 672                 return -ENOMEM;
 673
 674         platform_set_drvdata(neo1973_snd_device, &neo1973);
 675         ret = platform_device_add(neo1973_snd_device);
 676
 677         if (ret) {
 678                 platform_device_put(neo1973_snd_device);
 679                 return ret;
 680         }
 681
 682         ret = i2c_add_driver(&lm4857_i2c_driver);
 683
 684         if (ret != 0)
 685                 platform_device_unregister(neo1973_snd_device);
 686
 687         return ret;
 688 }
 689
 690 static void __exit neo1973_exit(void)
 691 {
 692         pr_debug("Entered %s\n", __func__);
 693
 694         i2c_del_driver(&lm4857_i2c_driver);
 695         platform_device_unregister(neo1973_snd_device);
 696 }
 697
 698 module_init(neo1973_init);
 699 module_exit(neo1973_exit);
 700
 701 /* Module information */
 702 MODULE_AUTHOR("Graeme Gregory, graeme@openmoko.org, www.openmoko.org");
 703 MODULE_DESCRIPTION("ALSA SoC WM8753 Neo1973");
 704 MODULE_LICENSE("GPL");