]> bbs.cooldavid.org Git - net-next-2.6.git/blame - sound/soc/codecs/ak4642.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ASoC: Add indirection for CODEC private data
[net-next-2.6.git] / sound / soc / codecs / ak4642.c
CommitLineData
a3a83d9a
KM		 1/*
2 * ak4642.c -- AK4642/AK4643 ALSA Soc Audio driver
3 *
4 * Copyright (C) 2009 Renesas Solutions Corp.
5 * Kuninori Morimoto <morimoto.kuninori@renesas.com>
6 *
7 * Based on wm8731.c by Richard Purdie
8 * Based on ak4535.c by Richard Purdie
9 * Based on wm8753.c by Liam Girdwood
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 */
15
16/* ** CAUTION **
17 *
18 * This is very simple driver.
19 * It can use headphone output / stereo input only
20 *
21 * AK4642 is not tested.
22 * AK4643 is tested.
23 */
24
25#include <linux/module.h>
26#include <linux/moduleparam.h>
27#include <linux/init.h>
28#include <linux/delay.h>
29#include <linux/pm.h>
30#include <linux/i2c.h>
31#include <linux/platform_device.h>
32#include <sound/core.h>
33#include <sound/pcm.h>
34#include <sound/pcm_params.h>
35#include <sound/soc.h>
36#include <sound/soc-dapm.h>
37#include <sound/initval.h>
38
39#include "ak4642.h"
40
41#define AK4642_VERSION "0.0.1"
42
43#define PW_MGMT1 0x00
44#define PW_MGMT2 0x01
45#define SG_SL1 0x02
46#define SG_SL2 0x03
47#define MD_CTL1 0x04
48#define MD_CTL2 0x05
49#define TIMER 0x06
50#define ALC_CTL1 0x07
51#define ALC_CTL2 0x08
52#define L_IVC 0x09
53#define L_DVC 0x0a
54#define ALC_CTL3 0x0b
55#define R_IVC 0x0c
56#define R_DVC 0x0d
57#define MD_CTL3 0x0e
58#define MD_CTL4 0x0f
59#define PW_MGMT3 0x10
60#define DF_S 0x11
61#define FIL3_0 0x12
62#define FIL3_1 0x13
63#define FIL3_2 0x14
64#define FIL3_3 0x15
65#define EQ_0 0x16
66#define EQ_1 0x17
67#define EQ_2 0x18
68#define EQ_3 0x19
69#define EQ_4 0x1a
70#define EQ_5 0x1b
71#define FIL1_0 0x1c
72#define FIL1_1 0x1d
73#define FIL1_2 0x1e
74#define FIL1_3 0x1f
75#define PW_MGMT4 0x20
76#define MD_CTL5 0x21
77#define LO_MS 0x22
78#define HP_MS 0x23
79#define SPK_MS 0x24
80
81#define AK4642_CACHEREGNUM 0x25
82
0643ce8f
KM		 83/* PW_MGMT2 */
84#define HPMTN (1 << 6)
85#define PMHPL (1 << 5)
86#define PMHPR (1 << 4)
87#define MS (1 << 3) /* master/slave select */
88#define MCKO (1 << 1)
89#define PMPLL (1 << 0)
90
91#define PMHP_MASK (PMHPL | PMHPR)
92#define PMHP PMHP_MASK
93
4b6316b4
KM		 94/* MD_CTL1 */
95#define PLL3 (1 << 7)
96#define PLL2 (1 << 6)
97#define PLL1 (1 << 5)
98#define PLL0 (1 << 4)
99#define PLL_MASK (PLL3 | PLL2 | PLL1 | PLL0)
100
0643ce8f
KM		 101#define BCKO_MASK (1 << 3)
102#define BCKO_64 BCKO_MASK
103
1ad747ca
KM		 104/* MD_CTL2 */
105#define FS0 (1 << 0)
106#define FS1 (1 << 1)
107#define FS2 (1 << 2)
108#define FS3 (1 << 5)
109#define FS_MASK (FS0 | FS1 | FS2 | FS3)
110
a3a83d9a
KM		 111struct snd_soc_codec_device soc_codec_dev_ak4642;
112
113/* codec private data */
114struct ak4642_priv {
115 struct snd_soc_codec codec;
a3a83d9a
KM		 116};
117
118static struct snd_soc_codec *ak4642_codec;
119
120/*
121 * ak4642 register cache
122 */
123static const u16 ak4642_reg[AK4642_CACHEREGNUM] = {
124 0x0000, 0x0000, 0x0001, 0x0000,
125 0x0002, 0x0000, 0x0000, 0x0000,
126 0x00e1, 0x00e1, 0x0018, 0x0000,
127 0x00e1, 0x0018, 0x0011, 0x0008,
128 0x0000, 0x0000, 0x0000, 0x0000,
129 0x0000, 0x0000, 0x0000, 0x0000,
130 0x0000, 0x0000, 0x0000, 0x0000,
131 0x0000, 0x0000, 0x0000, 0x0000,
132 0x0000, 0x0000, 0x0000, 0x0000,
133 0x0000,
134};
135
136/*
137 * read ak4642 register cache
138 */
139static inline unsigned int ak4642_read_reg_cache(struct snd_soc_codec *codec,
140 unsigned int reg)
141{
142 u16 *cache = codec->reg_cache;
143 if (reg >= AK4642_CACHEREGNUM)
144 return -1;
145 return cache[reg];
146}
147
148/*
149 * write ak4642 register cache
150 */
151static inline void ak4642_write_reg_cache(struct snd_soc_codec *codec,
152 u16 reg, unsigned int value)
153{
154 u16 *cache = codec->reg_cache;
155 if (reg >= AK4642_CACHEREGNUM)
156 return;
157
158 cache[reg] = value;
159}
160
161/*
162 * write to the AK4642 register space
163 */
164static int ak4642_write(struct snd_soc_codec *codec, unsigned int reg,
165 unsigned int value)
166{
167 u8 data[2];
168
169 /* data is
170 * D15..D8 AK4642 register offset
171 * D7...D0 register data
172 */
173 data[0] = reg & 0xff;
174 data[1] = value & 0xff;
175
176 if (codec->hw_write(codec->control_data, data, 2) == 2) {
177 ak4642_write_reg_cache(codec, reg, value);
178 return 0;
179 } else
180 return -EIO;
181}
182
183static int ak4642_sync(struct snd_soc_codec *codec)
184{
185 u16 *cache = codec->reg_cache;
186 int i, r = 0;
187
188 for (i = 0; i < AK4642_CACHEREGNUM; i++)
189 r |= ak4642_write(codec, i, cache[i]);
190
191 return r;
192};
193
194static int ak4642_dai_startup(struct snd_pcm_substream *substream,
195 struct snd_soc_dai *dai)
196{
197 int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
198 struct snd_soc_codec *codec = dai->codec;
199
200 if (is_play) {
201 /*
202 * start headphone output
203 *
204 * PLL, Master Mode
205 * Audio I/F Format :MSB justified (ADC & DAC)
1ad747ca 206 * Digital Volume: -8dB
a3a83d9a
KM		 207 * Bass Boost Level : Middle
208 *
209 * This operation came from example code of
210 * "ASAHI KASEI AK4642" (japanese) manual p97.
a3a83d9a 211 */
a3a83d9a
KM		 212 ak4642_write(codec, 0x0f, 0x09);
213 ak4642_write(codec, 0x0e, 0x19);
214 ak4642_write(codec, 0x09, 0x91);
215 ak4642_write(codec, 0x0c, 0x91);
216 ak4642_write(codec, 0x0a, 0x28);
217 ak4642_write(codec, 0x0d, 0x28);
218 ak4642_write(codec, 0x00, 0x64);
0643ce8f
KM		 219 snd_soc_update_bits(codec, PW_MGMT2, PMHP_MASK, PMHP);
220 snd_soc_update_bits(codec, PW_MGMT2, HPMTN, HPMTN);
a3a83d9a
KM		 221 } else {
222 /*
223 * start stereo input
224 *
225 * PLL Master Mode
226 * Audio I/F Format:MSB justified (ADC & DAC)
a3a83d9a
KM		 227 * Pre MIC AMP:+20dB
228 * MIC Power On
229 * ALC setting:Refer to Table 35
230 * ALC bit=“1”
231 *
232 * This operation came from example code of
233 * "ASAHI KASEI AK4642" (japanese) manual p94.
234 */
a3a83d9a
KM		 235 ak4642_write(codec, 0x02, 0x05);
236 ak4642_write(codec, 0x06, 0x3c);
237 ak4642_write(codec, 0x08, 0xe1);
238 ak4642_write(codec, 0x0b, 0x00);
239 ak4642_write(codec, 0x07, 0x21);
240 ak4642_write(codec, 0x00, 0x41);
241 ak4642_write(codec, 0x10, 0x01);
242 }
243
244 return 0;
245}
246
247static void ak4642_dai_shutdown(struct snd_pcm_substream *substream,
248 struct snd_soc_dai *dai)
249{
250 int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
251 struct snd_soc_codec *codec = dai->codec;
252
253 if (is_play) {
254 /* stop headphone output */
0643ce8f
KM		 255 snd_soc_update_bits(codec, PW_MGMT2, HPMTN, 0);
256 snd_soc_update_bits(codec, PW_MGMT2, PMHP_MASK, 0);
a3a83d9a
KM		 257 ak4642_write(codec, 0x00, 0x40);
258 ak4642_write(codec, 0x0e, 0x11);
259 ak4642_write(codec, 0x0f, 0x08);
260 } else {
261 /* stop stereo input */
262 ak4642_write(codec, 0x00, 0x40);
263 ak4642_write(codec, 0x10, 0x00);
264 ak4642_write(codec, 0x07, 0x01);
265 }
266}
267
268static int ak4642_dai_set_sysclk(struct snd_soc_dai *codec_dai,
269 int clk_id, unsigned int freq, int dir)
270{
271 struct snd_soc_codec *codec = codec_dai->codec;
4b6316b4
KM		 272 u8 pll;
273
274 switch (freq) {
275 case 11289600:
276 pll = PLL2;
277 break;
278 case 12288000:
279 pll = PLL2 | PLL0;
280 break;
281 case 12000000:
282 pll = PLL2 | PLL1;
283 break;
284 case 24000000:
285 pll = PLL2 | PLL1 | PLL0;
286 break;
287 case 13500000:
288 pll = PLL3 | PLL2;
289 break;
290 case 27000000:
291 pll = PLL3 | PLL2 | PLL0;
292 break;
293 default:
294 return -EINVAL;
295 }
296 snd_soc_update_bits(codec, MD_CTL1, PLL_MASK, pll);
a3a83d9a 297
a3a83d9a
KM		 298 return 0;
299}
300
0643ce8f
KM		 301static int ak4642_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
302{
303 struct snd_soc_codec *codec = dai->codec;
304 u8 data;
305 u8 bcko;
306
307 data = MCKO | PMPLL; /* use MCKO */
308 bcko = 0;
309
310 /* set master/slave audio interface */
311 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
312 case SND_SOC_DAIFMT_CBM_CFM:
313 data |= MS;
314 bcko = BCKO_64;
315 break;
316 case SND_SOC_DAIFMT_CBS_CFS:
317 break;
318 default:
319 return -EINVAL;
320 }
321 snd_soc_update_bits(codec, PW_MGMT2, MS, data);
322 snd_soc_update_bits(codec, MD_CTL1, BCKO_MASK, bcko);
323
324 return 0;
325}
326
1ad747ca
KM		 327static int ak4642_dai_hw_params(struct snd_pcm_substream *substream,
328 struct snd_pcm_hw_params *params,
329 struct snd_soc_dai *dai)
330{
331 struct snd_soc_codec *codec = dai->codec;
332 u8 rate;
333
334 switch (params_rate(params)) {
335 case 7350:
336 rate = FS2;
337 break;
338 case 8000:
339 rate = 0;
340 break;
341 case 11025:
342 rate = FS2 | FS0;
343 break;
344 case 12000:
345 rate = FS0;
346 break;
347 case 14700:
348 rate = FS2 | FS1;
349 break;
350 case 16000:
351 rate = FS1;
352 break;
353 case 22050:
354 rate = FS2 | FS1 | FS0;
355 break;
356 case 24000:
357 rate = FS1 | FS0;
358 break;
359 case 29400:
360 rate = FS3 | FS2 | FS1;
361 break;
362 case 32000:
363 rate = FS3 | FS1;
364 break;
365 case 44100:
366 rate = FS3 | FS2 | FS1 | FS0;
367 break;
368 case 48000:
369 rate = FS3 | FS1 | FS0;
370 break;
371 default:
372 return -EINVAL;
373 break;
374 }
375 snd_soc_update_bits(codec, MD_CTL2, FS_MASK, rate);
376
377 return 0;
378}
379
a3a83d9a
KM		 380static struct snd_soc_dai_ops ak4642_dai_ops = {
381 .startup = ak4642_dai_startup,
382 .shutdown = ak4642_dai_shutdown,
383 .set_sysclk = ak4642_dai_set_sysclk,
0643ce8f 384 .set_fmt = ak4642_dai_set_fmt,
1ad747ca 385 .hw_params = ak4642_dai_hw_params,
a3a83d9a
KM		 386};
387
388struct snd_soc_dai ak4642_dai = {
389 .name = "AK4642",
390 .playback = {
391 .stream_name = "Playback",
392 .channels_min = 1,
393 .channels_max = 2,
394 .rates = SNDRV_PCM_RATE_8000_48000,
395 .formats = SNDRV_PCM_FMTBIT_S16_LE },
396 .capture = {
397 .stream_name = "Capture",
398 .channels_min = 1,
399 .channels_max = 2,
400 .rates = SNDRV_PCM_RATE_8000_48000,
401 .formats = SNDRV_PCM_FMTBIT_S16_LE },
402 .ops = &ak4642_dai_ops,
1ad747ca 403 .symmetric_rates = 1,
a3a83d9a
KM		 404};
405EXPORT_SYMBOL_GPL(ak4642_dai);
406
407static int ak4642_resume(struct platform_device *pdev)
408{
409 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
410 struct snd_soc_codec *codec = socdev->card->codec;
411
412 ak4642_sync(codec);
413 return 0;
414}
415
416/*
417 * initialise the AK4642 driver
418 * register the mixer and dsp interfaces with the kernel
419 */
420static int ak4642_init(struct ak4642_priv *ak4642)
421{
422 struct snd_soc_codec *codec = &ak4642->codec;
423 int ret = 0;
424
425 if (ak4642_codec) {
426 dev_err(codec->dev, "Another ak4642 is registered\n");
427 return -EINVAL;
428 }
429
430 mutex_init(&codec->mutex);
431 INIT_LIST_HEAD(&codec->dapm_widgets);
432 INIT_LIST_HEAD(&codec->dapm_paths);
433
b2c812e2 434 snd_soc_codec_set_drvdata(codec, ak4642);
a3a83d9a
KM		 435 codec->name = "AK4642";
436 codec->owner = THIS_MODULE;
437 codec->read = ak4642_read_reg_cache;
438 codec->write = ak4642_write;
439 codec->dai = &ak4642_dai;
440 codec->num_dai = 1;
441 codec->hw_write = (hw_write_t)i2c_master_send;
442 codec->reg_cache_size = ARRAY_SIZE(ak4642_reg);
443 codec->reg_cache = kmemdup(ak4642_reg,
444 sizeof(ak4642_reg), GFP_KERNEL);
445
446 if (!codec->reg_cache)
447 return -ENOMEM;
448
449 ak4642_dai.dev = codec->dev;
450 ak4642_codec = codec;
451
452 ret = snd_soc_register_codec(codec);
453 if (ret) {
454 dev_err(codec->dev, "Failed to register codec: %d\n", ret);
455 goto reg_cache_err;
456 }
457
458 ret = snd_soc_register_dai(&ak4642_dai);
459 if (ret) {
460 dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
461 snd_soc_unregister_codec(codec);
462 goto reg_cache_err;
463 }
464
a3a83d9a
KM		 465 return ret;
466
467reg_cache_err:
468 kfree(codec->reg_cache);
469 codec->reg_cache = NULL;
470
471 return ret;
472}
473
474#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
475static int ak4642_i2c_probe(struct i2c_client *i2c,
476 const struct i2c_device_id *id)
477{
478 struct ak4642_priv *ak4642;
479 struct snd_soc_codec *codec;
480 int ret;
481
482 ak4642 = kzalloc(sizeof(struct ak4642_priv), GFP_KERNEL);
483 if (!ak4642)
484 return -ENOMEM;
485
486 codec = &ak4642->codec;
487 codec->dev = &i2c->dev;
488
489 i2c_set_clientdata(i2c, ak4642);
490 codec->control_data = i2c;
491
492 ret = ak4642_init(ak4642);
493 if (ret < 0)
494 printk(KERN_ERR "failed to initialise AK4642\n");
495
496 return ret;
497}
498
499static int ak4642_i2c_remove(struct i2c_client *client)
500{
501 struct ak4642_priv *ak4642 = i2c_get_clientdata(client);
502
503 snd_soc_unregister_dai(&ak4642_dai);
504 snd_soc_unregister_codec(&ak4642->codec);
505 kfree(ak4642->codec.reg_cache);
506 kfree(ak4642);
507 ak4642_codec = NULL;
508
509 return 0;
510}
511
512static const struct i2c_device_id ak4642_i2c_id[] = {
513 { "ak4642", 0 },
514 { "ak4643", 0 },
515 { }
516};
517MODULE_DEVICE_TABLE(i2c, ak4642_i2c_id);
518
519static struct i2c_driver ak4642_i2c_driver = {
520 .driver = {
521 .name = "AK4642 I2C Codec",
522 .owner = THIS_MODULE,
523 },
524 .probe = ak4642_i2c_probe,
525 .remove = ak4642_i2c_remove,
526 .id_table = ak4642_i2c_id,
527};
528
529#endif
530
531static int ak4642_probe(struct platform_device *pdev)
532{
533 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
534 int ret;
535
536 if (!ak4642_codec) {
537 dev_err(&pdev->dev, "Codec device not registered\n");
538 return -ENODEV;
539 }
540
541 socdev->card->codec = ak4642_codec;
542
543 /* register pcms */
544 ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
545 if (ret < 0) {
546 printk(KERN_ERR "ak4642: failed to create pcms\n");
547 goto pcm_err;
548 }
549
a3a83d9a
KM		 550 dev_info(&pdev->dev, "AK4642 Audio Codec %s", AK4642_VERSION);
551 return ret;
552
a3a83d9a
KM		 553pcm_err:
554 return ret;
555
556}
557
558/* power down chip */
559static int ak4642_remove(struct platform_device *pdev)
560{
561 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
562
563 snd_soc_free_pcms(socdev);
564 snd_soc_dapm_free(socdev);
565
566 return 0;
567}
568
569struct snd_soc_codec_device soc_codec_dev_ak4642 = {
570 .probe = ak4642_probe,
571 .remove = ak4642_remove,
572 .resume = ak4642_resume,
573};
574EXPORT_SYMBOL_GPL(soc_codec_dev_ak4642);
575
576static int __init ak4642_modinit(void)
577{
1cf86f6f 578 int ret = 0;
a3a83d9a
KM		 579#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
580 ret = i2c_add_driver(&ak4642_i2c_driver);
581#endif
582 return ret;
583
584}
585module_init(ak4642_modinit);
586
587static void __exit ak4642_exit(void)
588{
589#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
590 i2c_del_driver(&ak4642_i2c_driver);
591#endif
592
593}
594module_exit(ak4642_exit);
595
596MODULE_DESCRIPTION("Soc AK4642 driver");
597MODULE_AUTHOR("Kuninori Morimoto <morimoto.kuninori@renesas.com>");
598MODULE_LICENSE("GPL");
Clone of davem's net-next-2.6 tree