Linux 2.6.37-rc1
[pandora-kernel.git] / sound / soc / codecs / ssm2602.c
1 /*
2  * File:         sound/soc/codecs/ssm2602.c
3  * Author:       Cliff Cai <Cliff.Cai@analog.com>
4  *
5  * Created:      Tue June 06 2008
6  * Description:  Driver for ssm2602 sound chip
7  *
8  * Modified:
9  *               Copyright 2008 Analog Devices Inc.
10  *
11  * Bugs:         Enter bugs at http://blackfin.uclinux.org/
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, see the file COPYING, or write
25  * to the Free Software Foundation, Inc.,
26  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
27  */
28
29 #include <linux/module.h>
30 #include <linux/moduleparam.h>
31 #include <linux/init.h>
32 #include <linux/delay.h>
33 #include <linux/pm.h>
34 #include <linux/i2c.h>
35 #include <linux/platform_device.h>
36 #include <linux/slab.h>
37 #include <sound/core.h>
38 #include <sound/pcm.h>
39 #include <sound/pcm_params.h>
40 #include <sound/soc.h>
41 #include <sound/soc-dapm.h>
42 #include <sound/initval.h>
43
44 #include "ssm2602.h"
45
46 #define SSM2602_VERSION "0.1"
47
48 /* codec private data */
49 struct ssm2602_priv {
50         unsigned int sysclk;
51         enum snd_soc_control_type control_type;
52         void *control_data;
53         struct snd_pcm_substream *master_substream;
54         struct snd_pcm_substream *slave_substream;
55 };
56
57 /*
58  * ssm2602 register cache
59  * We can't read the ssm2602 register space when we are
60  * using 2 wire for device control, so we cache them instead.
61  * There is no point in caching the reset register
62  */
63 static const u16 ssm2602_reg[SSM2602_CACHEREGNUM] = {
64         0x0017, 0x0017, 0x0079, 0x0079,
65         0x0000, 0x0000, 0x0000, 0x000a,
66         0x0000, 0x0000
67 };
68
69 /*
70  * read ssm2602 register cache
71  */
72 static inline unsigned int ssm2602_read_reg_cache(struct snd_soc_codec *codec,
73         unsigned int reg)
74 {
75         u16 *cache = codec->reg_cache;
76         if (reg == SSM2602_RESET)
77                 return 0;
78         if (reg >= SSM2602_CACHEREGNUM)
79                 return -1;
80         return cache[reg];
81 }
82
83 /*
84  * write ssm2602 register cache
85  */
86 static inline void ssm2602_write_reg_cache(struct snd_soc_codec *codec,
87         u16 reg, unsigned int value)
88 {
89         u16 *cache = codec->reg_cache;
90         if (reg >= SSM2602_CACHEREGNUM)
91                 return;
92         cache[reg] = value;
93 }
94
95 /*
96  * write to the ssm2602 register space
97  */
98 static int ssm2602_write(struct snd_soc_codec *codec, unsigned int reg,
99         unsigned int value)
100 {
101         u8 data[2];
102
103         /* data is
104          *   D15..D9 ssm2602 register offset
105          *   D8...D0 register data
106          */
107         data[0] = (reg << 1) | ((value >> 8) & 0x0001);
108         data[1] = value & 0x00ff;
109
110         ssm2602_write_reg_cache(codec, reg, value);
111         if (codec->hw_write(codec->control_data, data, 2) == 2)
112                 return 0;
113         else
114                 return -EIO;
115 }
116
117 #define ssm2602_reset(c)        ssm2602_write(c, SSM2602_RESET, 0)
118
119 /*Appending several "None"s just for OSS mixer use*/
120 static const char *ssm2602_input_select[] = {
121         "Line", "Mic", "None", "None", "None",
122         "None", "None", "None",
123 };
124
125 static const char *ssm2602_deemph[] = {"None", "32Khz", "44.1Khz", "48Khz"};
126
127 static const struct soc_enum ssm2602_enum[] = {
128         SOC_ENUM_SINGLE(SSM2602_APANA, 2, 2, ssm2602_input_select),
129         SOC_ENUM_SINGLE(SSM2602_APDIGI, 1, 4, ssm2602_deemph),
130 };
131
132 static const struct snd_kcontrol_new ssm2602_snd_controls[] = {
133
134 SOC_DOUBLE_R("Master Playback Volume", SSM2602_LOUT1V, SSM2602_ROUT1V,
135         0, 127, 0),
136 SOC_DOUBLE_R("Master Playback ZC Switch", SSM2602_LOUT1V, SSM2602_ROUT1V,
137         7, 1, 0),
138
139 SOC_DOUBLE_R("Capture Volume", SSM2602_LINVOL, SSM2602_RINVOL, 0, 31, 0),
140 SOC_DOUBLE_R("Capture Switch", SSM2602_LINVOL, SSM2602_RINVOL, 7, 1, 1),
141
142 SOC_SINGLE("Mic Boost (+20dB)", SSM2602_APANA, 0, 1, 0),
143 SOC_SINGLE("Mic Boost2 (+20dB)", SSM2602_APANA, 7, 1, 0),
144 SOC_SINGLE("Mic Switch", SSM2602_APANA, 1, 1, 1),
145
146 SOC_SINGLE("Sidetone Playback Volume", SSM2602_APANA, 6, 3, 1),
147
148 SOC_SINGLE("ADC High Pass Filter Switch", SSM2602_APDIGI, 0, 1, 1),
149 SOC_SINGLE("Store DC Offset Switch", SSM2602_APDIGI, 4, 1, 0),
150
151 SOC_ENUM("Capture Source", ssm2602_enum[0]),
152
153 SOC_ENUM("Playback De-emphasis", ssm2602_enum[1]),
154 };
155
156 /* Output Mixer */
157 static const struct snd_kcontrol_new ssm2602_output_mixer_controls[] = {
158 SOC_DAPM_SINGLE("Line Bypass Switch", SSM2602_APANA, 3, 1, 0),
159 SOC_DAPM_SINGLE("Mic Sidetone Switch", SSM2602_APANA, 5, 1, 0),
160 SOC_DAPM_SINGLE("HiFi Playback Switch", SSM2602_APANA, 4, 1, 0),
161 };
162
163 /* Input mux */
164 static const struct snd_kcontrol_new ssm2602_input_mux_controls =
165 SOC_DAPM_ENUM("Input Select", ssm2602_enum[0]);
166
167 static const struct snd_soc_dapm_widget ssm2602_dapm_widgets[] = {
168 SND_SOC_DAPM_MIXER("Output Mixer", SSM2602_PWR, 4, 1,
169         &ssm2602_output_mixer_controls[0],
170         ARRAY_SIZE(ssm2602_output_mixer_controls)),
171 SND_SOC_DAPM_DAC("DAC", "HiFi Playback", SSM2602_PWR, 3, 1),
172 SND_SOC_DAPM_OUTPUT("LOUT"),
173 SND_SOC_DAPM_OUTPUT("LHPOUT"),
174 SND_SOC_DAPM_OUTPUT("ROUT"),
175 SND_SOC_DAPM_OUTPUT("RHPOUT"),
176 SND_SOC_DAPM_ADC("ADC", "HiFi Capture", SSM2602_PWR, 2, 1),
177 SND_SOC_DAPM_MUX("Input Mux", SND_SOC_NOPM, 0, 0, &ssm2602_input_mux_controls),
178 SND_SOC_DAPM_PGA("Line Input", SSM2602_PWR, 0, 1, NULL, 0),
179 SND_SOC_DAPM_MICBIAS("Mic Bias", SSM2602_PWR, 1, 1),
180 SND_SOC_DAPM_INPUT("MICIN"),
181 SND_SOC_DAPM_INPUT("RLINEIN"),
182 SND_SOC_DAPM_INPUT("LLINEIN"),
183 };
184
185 static const struct snd_soc_dapm_route audio_conn[] = {
186         /* output mixer */
187         {"Output Mixer", "Line Bypass Switch", "Line Input"},
188         {"Output Mixer", "HiFi Playback Switch", "DAC"},
189         {"Output Mixer", "Mic Sidetone Switch", "Mic Bias"},
190
191         /* outputs */
192         {"RHPOUT", NULL, "Output Mixer"},
193         {"ROUT", NULL, "Output Mixer"},
194         {"LHPOUT", NULL, "Output Mixer"},
195         {"LOUT", NULL, "Output Mixer"},
196
197         /* input mux */
198         {"Input Mux", "Line", "Line Input"},
199         {"Input Mux", "Mic", "Mic Bias"},
200         {"ADC", NULL, "Input Mux"},
201
202         /* inputs */
203         {"Line Input", NULL, "LLINEIN"},
204         {"Line Input", NULL, "RLINEIN"},
205         {"Mic Bias", NULL, "MICIN"},
206 };
207
208 static int ssm2602_add_widgets(struct snd_soc_codec *codec)
209 {
210         snd_soc_dapm_new_controls(codec, ssm2602_dapm_widgets,
211                                   ARRAY_SIZE(ssm2602_dapm_widgets));
212
213         snd_soc_dapm_add_routes(codec, audio_conn, ARRAY_SIZE(audio_conn));
214
215         return 0;
216 }
217
218 struct _coeff_div {
219         u32 mclk;
220         u32 rate;
221         u16 fs;
222         u8 sr:4;
223         u8 bosr:1;
224         u8 usb:1;
225 };
226
227 /* codec mclk clock divider coefficients */
228 static const struct _coeff_div coeff_div[] = {
229         /* 48k */
230         {12288000, 48000, 256, 0x0, 0x0, 0x0},
231         {18432000, 48000, 384, 0x0, 0x1, 0x0},
232         {12000000, 48000, 250, 0x0, 0x0, 0x1},
233
234         /* 32k */
235         {12288000, 32000, 384, 0x6, 0x0, 0x0},
236         {18432000, 32000, 576, 0x6, 0x1, 0x0},
237         {12000000, 32000, 375, 0x6, 0x0, 0x1},
238
239         /* 8k */
240         {12288000, 8000, 1536, 0x3, 0x0, 0x0},
241         {18432000, 8000, 2304, 0x3, 0x1, 0x0},
242         {11289600, 8000, 1408, 0xb, 0x0, 0x0},
243         {16934400, 8000, 2112, 0xb, 0x1, 0x0},
244         {12000000, 8000, 1500, 0x3, 0x0, 0x1},
245
246         /* 96k */
247         {12288000, 96000, 128, 0x7, 0x0, 0x0},
248         {18432000, 96000, 192, 0x7, 0x1, 0x0},
249         {12000000, 96000, 125, 0x7, 0x0, 0x1},
250
251         /* 44.1k */
252         {11289600, 44100, 256, 0x8, 0x0, 0x0},
253         {16934400, 44100, 384, 0x8, 0x1, 0x0},
254         {12000000, 44100, 272, 0x8, 0x1, 0x1},
255
256         /* 88.2k */
257         {11289600, 88200, 128, 0xf, 0x0, 0x0},
258         {16934400, 88200, 192, 0xf, 0x1, 0x0},
259         {12000000, 88200, 136, 0xf, 0x1, 0x1},
260 };
261
262 static inline int get_coeff(int mclk, int rate)
263 {
264         int i;
265
266         for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
267                 if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk)
268                         return i;
269         }
270         return i;
271 }
272
273 static int ssm2602_hw_params(struct snd_pcm_substream *substream,
274         struct snd_pcm_hw_params *params,
275         struct snd_soc_dai *dai)
276 {
277         u16 srate;
278         struct snd_soc_pcm_runtime *rtd = substream->private_data;
279         struct snd_soc_codec *codec = rtd->codec;
280         struct ssm2602_priv *ssm2602 = snd_soc_codec_get_drvdata(codec);
281         struct i2c_client *i2c = codec->control_data;
282         u16 iface = ssm2602_read_reg_cache(codec, SSM2602_IFACE) & 0xfff3;
283         int i = get_coeff(ssm2602->sysclk, params_rate(params));
284
285         if (substream == ssm2602->slave_substream) {
286                 dev_dbg(&i2c->dev, "Ignoring hw_params for slave substream\n");
287                 return 0;
288         }
289
290         /*no match is found*/
291         if (i == ARRAY_SIZE(coeff_div))
292                 return -EINVAL;
293
294         srate = (coeff_div[i].sr << 2) |
295                 (coeff_div[i].bosr << 1) | coeff_div[i].usb;
296
297         ssm2602_write(codec, SSM2602_ACTIVE, 0);
298         ssm2602_write(codec, SSM2602_SRATE, srate);
299
300         /* bit size */
301         switch (params_format(params)) {
302         case SNDRV_PCM_FORMAT_S16_LE:
303                 break;
304         case SNDRV_PCM_FORMAT_S20_3LE:
305                 iface |= 0x0004;
306                 break;
307         case SNDRV_PCM_FORMAT_S24_LE:
308                 iface |= 0x0008;
309                 break;
310         case SNDRV_PCM_FORMAT_S32_LE:
311                 iface |= 0x000c;
312                 break;
313         }
314         ssm2602_write(codec, SSM2602_IFACE, iface);
315         ssm2602_write(codec, SSM2602_ACTIVE, ACTIVE_ACTIVATE_CODEC);
316         return 0;
317 }
318
319 static int ssm2602_startup(struct snd_pcm_substream *substream,
320                            struct snd_soc_dai *dai)
321 {
322         struct snd_soc_pcm_runtime *rtd = substream->private_data;
323         struct snd_soc_codec *codec = rtd->codec;
324         struct ssm2602_priv *ssm2602 = snd_soc_codec_get_drvdata(codec);
325         struct i2c_client *i2c = codec->control_data;
326         struct snd_pcm_runtime *master_runtime;
327
328         /* The DAI has shared clocks so if we already have a playback or
329          * capture going then constrain this substream to match it.
330          * TODO: the ssm2602 allows pairs of non-matching PB/REC rates
331          */
332         if (ssm2602->master_substream) {
333                 master_runtime = ssm2602->master_substream->runtime;
334                 dev_dbg(&i2c->dev, "Constraining to %d bits at %dHz\n",
335                         master_runtime->sample_bits,
336                         master_runtime->rate);
337
338                 if (master_runtime->rate != 0)
339                         snd_pcm_hw_constraint_minmax(substream->runtime,
340                                                      SNDRV_PCM_HW_PARAM_RATE,
341                                                      master_runtime->rate,
342                                                      master_runtime->rate);
343
344                 if (master_runtime->sample_bits != 0)
345                         snd_pcm_hw_constraint_minmax(substream->runtime,
346                                                      SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
347                                                      master_runtime->sample_bits,
348                                                      master_runtime->sample_bits);
349
350                 ssm2602->slave_substream = substream;
351         } else
352                 ssm2602->master_substream = substream;
353
354         return 0;
355 }
356
357 static int ssm2602_pcm_prepare(struct snd_pcm_substream *substream,
358                                struct snd_soc_dai *dai)
359 {
360         struct snd_soc_pcm_runtime *rtd = substream->private_data;
361         struct snd_soc_codec *codec = rtd->codec;
362         /* set active */
363         ssm2602_write(codec, SSM2602_ACTIVE, ACTIVE_ACTIVATE_CODEC);
364
365         return 0;
366 }
367
368 static void ssm2602_shutdown(struct snd_pcm_substream *substream,
369                              struct snd_soc_dai *dai)
370 {
371         struct snd_soc_pcm_runtime *rtd = substream->private_data;
372         struct snd_soc_codec *codec = rtd->codec;
373         struct ssm2602_priv *ssm2602 = snd_soc_codec_get_drvdata(codec);
374
375         /* deactivate */
376         if (!codec->active)
377                 ssm2602_write(codec, SSM2602_ACTIVE, 0);
378
379         if (ssm2602->master_substream == substream)
380                 ssm2602->master_substream = ssm2602->slave_substream;
381
382         ssm2602->slave_substream = NULL;
383 }
384
385 static int ssm2602_mute(struct snd_soc_dai *dai, int mute)
386 {
387         struct snd_soc_codec *codec = dai->codec;
388         u16 mute_reg = ssm2602_read_reg_cache(codec, SSM2602_APDIGI) & ~APDIGI_ENABLE_DAC_MUTE;
389         if (mute)
390                 ssm2602_write(codec, SSM2602_APDIGI,
391                                 mute_reg | APDIGI_ENABLE_DAC_MUTE);
392         else
393                 ssm2602_write(codec, SSM2602_APDIGI, mute_reg);
394         return 0;
395 }
396
397 static int ssm2602_set_dai_sysclk(struct snd_soc_dai *codec_dai,
398                 int clk_id, unsigned int freq, int dir)
399 {
400         struct snd_soc_codec *codec = codec_dai->codec;
401         struct ssm2602_priv *ssm2602 = snd_soc_codec_get_drvdata(codec);
402         switch (freq) {
403         case 11289600:
404         case 12000000:
405         case 12288000:
406         case 16934400:
407         case 18432000:
408                 ssm2602->sysclk = freq;
409                 return 0;
410         }
411         return -EINVAL;
412 }
413
414 static int ssm2602_set_dai_fmt(struct snd_soc_dai *codec_dai,
415                 unsigned int fmt)
416 {
417         struct snd_soc_codec *codec = codec_dai->codec;
418         u16 iface = 0;
419
420         /* set master/slave audio interface */
421         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
422         case SND_SOC_DAIFMT_CBM_CFM:
423                 iface |= 0x0040;
424                 break;
425         case SND_SOC_DAIFMT_CBS_CFS:
426                 break;
427         default:
428                 return -EINVAL;
429         }
430
431         /* interface format */
432         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
433         case SND_SOC_DAIFMT_I2S:
434                 iface |= 0x0002;
435                 break;
436         case SND_SOC_DAIFMT_RIGHT_J:
437                 break;
438         case SND_SOC_DAIFMT_LEFT_J:
439                 iface |= 0x0001;
440                 break;
441         case SND_SOC_DAIFMT_DSP_A:
442                 iface |= 0x0013;
443                 break;
444         case SND_SOC_DAIFMT_DSP_B:
445                 iface |= 0x0003;
446                 break;
447         default:
448                 return -EINVAL;
449         }
450
451         /* clock inversion */
452         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
453         case SND_SOC_DAIFMT_NB_NF:
454                 break;
455         case SND_SOC_DAIFMT_IB_IF:
456                 iface |= 0x0090;
457                 break;
458         case SND_SOC_DAIFMT_IB_NF:
459                 iface |= 0x0080;
460                 break;
461         case SND_SOC_DAIFMT_NB_IF:
462                 iface |= 0x0010;
463                 break;
464         default:
465                 return -EINVAL;
466         }
467
468         /* set iface */
469         ssm2602_write(codec, SSM2602_IFACE, iface);
470         return 0;
471 }
472
473 static int ssm2602_set_bias_level(struct snd_soc_codec *codec,
474                                  enum snd_soc_bias_level level)
475 {
476         u16 reg = ssm2602_read_reg_cache(codec, SSM2602_PWR) & 0xff7f;
477
478         switch (level) {
479         case SND_SOC_BIAS_ON:
480                 /* vref/mid, osc on, dac unmute */
481                 ssm2602_write(codec, SSM2602_PWR, reg);
482                 break;
483         case SND_SOC_BIAS_PREPARE:
484                 break;
485         case SND_SOC_BIAS_STANDBY:
486                 /* everything off except vref/vmid, */
487                 ssm2602_write(codec, SSM2602_PWR, reg | PWR_CLK_OUT_PDN);
488                 break;
489         case SND_SOC_BIAS_OFF:
490                 /* everything off, dac mute, inactive */
491                 ssm2602_write(codec, SSM2602_ACTIVE, 0);
492                 ssm2602_write(codec, SSM2602_PWR, 0xffff);
493                 break;
494
495         }
496         codec->bias_level = level;
497         return 0;
498 }
499
500 #define SSM2602_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_32000 |\
501                 SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
502                 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
503
504 #define SSM2602_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
505                 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
506
507 static struct snd_soc_dai_ops ssm2602_dai_ops = {
508         .startup        = ssm2602_startup,
509         .prepare        = ssm2602_pcm_prepare,
510         .hw_params      = ssm2602_hw_params,
511         .shutdown       = ssm2602_shutdown,
512         .digital_mute   = ssm2602_mute,
513         .set_sysclk     = ssm2602_set_dai_sysclk,
514         .set_fmt        = ssm2602_set_dai_fmt,
515 };
516
517 static struct snd_soc_dai_driver ssm2602_dai = {
518         .name = "ssm2602-hifi",
519         .playback = {
520                 .stream_name = "Playback",
521                 .channels_min = 2,
522                 .channels_max = 2,
523                 .rates = SSM2602_RATES,
524                 .formats = SSM2602_FORMATS,},
525         .capture = {
526                 .stream_name = "Capture",
527                 .channels_min = 2,
528                 .channels_max = 2,
529                 .rates = SSM2602_RATES,
530                 .formats = SSM2602_FORMATS,},
531         .ops = &ssm2602_dai_ops,
532 };
533
534 static int ssm2602_suspend(struct snd_soc_codec *codec, pm_message_t state)
535 {
536         ssm2602_set_bias_level(codec, SND_SOC_BIAS_OFF);
537         return 0;
538 }
539
540 static int ssm2602_resume(struct snd_soc_codec *codec)
541 {
542         int i;
543         u8 data[2];
544         u16 *cache = codec->reg_cache;
545
546         /* Sync reg_cache with the hardware */
547         for (i = 0; i < ARRAY_SIZE(ssm2602_reg); i++) {
548                 data[0] = (i << 1) | ((cache[i] >> 8) & 0x0001);
549                 data[1] = cache[i] & 0x00ff;
550                 codec->hw_write(codec->control_data, data, 2);
551         }
552         ssm2602_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
553         return 0;
554 }
555
556 static int ssm2602_probe(struct snd_soc_codec *codec)
557 {
558         struct ssm2602_priv *ssm2602 = snd_soc_codec_get_drvdata(codec);
559         int ret = 0, reg;
560
561         pr_info("ssm2602 Audio Codec %s", SSM2602_VERSION);
562
563         codec->control_data = ssm2602->control_data;
564
565         ssm2602_reset(codec);
566
567         /*power on device*/
568         ssm2602_write(codec, SSM2602_ACTIVE, 0);
569         /* set the update bits */
570         reg = ssm2602_read_reg_cache(codec, SSM2602_LINVOL);
571         ssm2602_write(codec, SSM2602_LINVOL, reg | LINVOL_LRIN_BOTH);
572         reg = ssm2602_read_reg_cache(codec, SSM2602_RINVOL);
573         ssm2602_write(codec, SSM2602_RINVOL, reg | RINVOL_RLIN_BOTH);
574         reg = ssm2602_read_reg_cache(codec, SSM2602_LOUT1V);
575         ssm2602_write(codec, SSM2602_LOUT1V, reg | LOUT1V_LRHP_BOTH);
576         reg = ssm2602_read_reg_cache(codec, SSM2602_ROUT1V);
577         ssm2602_write(codec, SSM2602_ROUT1V, reg | ROUT1V_RLHP_BOTH);
578         /*select Line in as default input*/
579         ssm2602_write(codec, SSM2602_APANA, APANA_SELECT_DAC |
580                         APANA_ENABLE_MIC_BOOST);
581         ssm2602_write(codec, SSM2602_PWR, 0);
582
583         snd_soc_add_controls(codec, ssm2602_snd_controls,
584                                 ARRAY_SIZE(ssm2602_snd_controls));
585         ssm2602_add_widgets(codec);
586
587         return ret;
588 }
589
590 /* remove everything here */
591 static int ssm2602_remove(struct snd_soc_codec *codec)
592 {
593         ssm2602_set_bias_level(codec, SND_SOC_BIAS_OFF);
594         return 0;
595 }
596
597 static struct snd_soc_codec_driver soc_codec_dev_ssm2602 = {
598         .probe =        ssm2602_probe,
599         .remove =       ssm2602_remove,
600         .suspend =      ssm2602_suspend,
601         .resume =       ssm2602_resume,
602         .read = ssm2602_read_reg_cache,
603         .write = ssm2602_write,
604         .set_bias_level = ssm2602_set_bias_level,
605         .reg_cache_size = sizeof(ssm2602_reg),
606         .reg_word_size = sizeof(u16),
607         .reg_cache_default = ssm2602_reg,
608 };
609
610 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
611 /*
612  * ssm2602 2 wire address is determined by GPIO5
613  * state during powerup.
614  *    low  = 0x1a
615  *    high = 0x1b
616  */
617 static int ssm2602_i2c_probe(struct i2c_client *i2c,
618                              const struct i2c_device_id *id)
619 {
620         struct ssm2602_priv *ssm2602;
621         int ret;
622
623         ssm2602 = kzalloc(sizeof(struct ssm2602_priv), GFP_KERNEL);
624         if (ssm2602 == NULL)
625                 return -ENOMEM;
626
627         i2c_set_clientdata(i2c, ssm2602);
628         ssm2602->control_data = i2c;
629         ssm2602->control_type = SND_SOC_I2C;
630
631         ret = snd_soc_register_codec(&i2c->dev,
632                         &soc_codec_dev_ssm2602, &ssm2602_dai, 1);
633         if (ret < 0)
634                 kfree(ssm2602);
635         return ret;
636 }
637
638 static int ssm2602_i2c_remove(struct i2c_client *client)
639 {
640         snd_soc_unregister_codec(&client->dev);
641         kfree(i2c_get_clientdata(client));
642         return 0;
643 }
644
645 static const struct i2c_device_id ssm2602_i2c_id[] = {
646         { "ssm2602", 0 },
647         { }
648 };
649 MODULE_DEVICE_TABLE(i2c, ssm2602_i2c_id);
650
651 /* corgi i2c codec control layer */
652 static struct i2c_driver ssm2602_i2c_driver = {
653         .driver = {
654                 .name = "ssm2602-codec",
655                 .owner = THIS_MODULE,
656         },
657         .probe = ssm2602_i2c_probe,
658         .remove = ssm2602_i2c_remove,
659         .id_table = ssm2602_i2c_id,
660 };
661 #endif
662
663
664 static int __init ssm2602_modinit(void)
665 {
666         int ret = 0;
667 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
668         ret = i2c_add_driver(&ssm2602_i2c_driver);
669         if (ret != 0) {
670                 printk(KERN_ERR "Failed to register SSM2602 I2C driver: %d\n",
671                        ret);
672         }
673 #endif
674         return ret;
675 }
676 module_init(ssm2602_modinit);
677
678 static void __exit ssm2602_exit(void)
679 {
680 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
681         i2c_del_driver(&ssm2602_i2c_driver);
682 #endif
683 }
684 module_exit(ssm2602_exit);
685
686 MODULE_DESCRIPTION("ASoC ssm2602 driver");
687 MODULE_AUTHOR("Cliff Cai");
688 MODULE_LICENSE("GPL");