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