2 * wm8523.c -- WM8523 ALSA SoC Audio driver
4 * Copyright 2009 Wolfson Microelectronics plc
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/init.h>
17 #include <linux/delay.h>
19 #include <linux/i2c.h>
20 #include <linux/platform_device.h>
21 #include <linux/regulator/consumer.h>
22 #include <linux/slab.h>
23 #include <sound/core.h>
24 #include <sound/pcm.h>
25 #include <sound/pcm_params.h>
26 #include <sound/soc.h>
27 #include <sound/soc-dapm.h>
28 #include <sound/initval.h>
29 #include <sound/tlv.h>
33 #define WM8523_NUM_SUPPLIES 2
34 static const char *wm8523_supply_names
[WM8523_NUM_SUPPLIES
] = {
39 #define WM8523_NUM_RATES 7
41 /* codec private data */
43 enum snd_soc_control_type control_type
;
44 u16 reg_cache
[WM8523_REGISTER_COUNT
];
45 struct regulator_bulk_data supplies
[WM8523_NUM_SUPPLIES
];
47 unsigned int rate_constraint_list
[WM8523_NUM_RATES
];
48 struct snd_pcm_hw_constraint_list rate_constraint
;
51 static const u16 wm8523_reg
[WM8523_REGISTER_COUNT
] = {
52 0x8523, /* R0 - DEVICE_ID */
53 0x0001, /* R1 - REVISION */
54 0x0000, /* R2 - PSCTRL1 */
55 0x1812, /* R3 - AIF_CTRL1 */
56 0x0000, /* R4 - AIF_CTRL2 */
57 0x0001, /* R5 - DAC_CTRL3 */
58 0x0190, /* R6 - DAC_GAINL */
59 0x0190, /* R7 - DAC_GAINR */
60 0x0000, /* R8 - ZERO_DETECT */
63 static int wm8523_volatile_register(unsigned int reg
)
66 case WM8523_DEVICE_ID
:
74 static int wm8523_reset(struct snd_soc_codec
*codec
)
76 return snd_soc_write(codec
, WM8523_DEVICE_ID
, 0);
79 static const DECLARE_TLV_DB_SCALE(dac_tlv
, -10000, 25, 0);
81 static const char *wm8523_zd_count_text
[] = {
86 static const struct soc_enum wm8523_zc_count
=
87 SOC_ENUM_SINGLE(WM8523_ZERO_DETECT
, 0, 2, wm8523_zd_count_text
);
89 static const struct snd_kcontrol_new wm8523_snd_controls
[] = {
90 SOC_DOUBLE_R_TLV("Playback Volume", WM8523_DAC_GAINL
, WM8523_DAC_GAINR
,
92 SOC_SINGLE("ZC Switch", WM8523_DAC_CTRL3
, 4, 1, 0),
93 SOC_SINGLE("Playback Deemphasis Switch", WM8523_AIF_CTRL1
, 8, 1, 0),
94 SOC_DOUBLE("Playback Switch", WM8523_DAC_CTRL3
, 2, 3, 1, 1),
95 SOC_SINGLE("Volume Ramp Up Switch", WM8523_DAC_CTRL3
, 1, 1, 0),
96 SOC_SINGLE("Volume Ramp Down Switch", WM8523_DAC_CTRL3
, 0, 1, 0),
97 SOC_ENUM("Zero Detect Count", wm8523_zc_count
),
100 static const struct snd_soc_dapm_widget wm8523_dapm_widgets
[] = {
101 SND_SOC_DAPM_DAC("DAC", "Playback", SND_SOC_NOPM
, 0, 0),
102 SND_SOC_DAPM_OUTPUT("LINEVOUTL"),
103 SND_SOC_DAPM_OUTPUT("LINEVOUTR"),
106 static const struct snd_soc_dapm_route intercon
[] = {
107 { "LINEVOUTL", NULL
, "DAC" },
108 { "LINEVOUTR", NULL
, "DAC" },
111 static int wm8523_add_widgets(struct snd_soc_codec
*codec
)
113 snd_soc_dapm_new_controls(codec
, wm8523_dapm_widgets
,
114 ARRAY_SIZE(wm8523_dapm_widgets
));
116 snd_soc_dapm_add_routes(codec
, intercon
, ARRAY_SIZE(intercon
));
124 } lrclk_ratios
[WM8523_NUM_RATES
] = {
134 static int wm8523_startup(struct snd_pcm_substream
*substream
,
135 struct snd_soc_dai
*dai
)
137 struct snd_soc_codec
*codec
= dai
->codec
;
138 struct wm8523_priv
*wm8523
= snd_soc_codec_get_drvdata(codec
);
140 /* The set of sample rates that can be supported depends on the
141 * MCLK supplied to the CODEC - enforce this.
143 if (!wm8523
->sysclk
) {
145 "No MCLK configured, call set_sysclk() on init\n");
150 snd_pcm_hw_constraint_list(substream
->runtime
, 0,
151 SNDRV_PCM_HW_PARAM_RATE
,
152 &wm8523
->rate_constraint
);
157 static int wm8523_hw_params(struct snd_pcm_substream
*substream
,
158 struct snd_pcm_hw_params
*params
,
159 struct snd_soc_dai
*dai
)
161 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
162 struct snd_soc_codec
*codec
= rtd
->codec
;
163 struct wm8523_priv
*wm8523
= snd_soc_codec_get_drvdata(codec
);
165 u16 aifctrl1
= snd_soc_read(codec
, WM8523_AIF_CTRL1
);
166 u16 aifctrl2
= snd_soc_read(codec
, WM8523_AIF_CTRL2
);
168 /* Find a supported LRCLK ratio */
169 for (i
= 0; i
< ARRAY_SIZE(lrclk_ratios
); i
++) {
170 if (wm8523
->sysclk
/ params_rate(params
) ==
171 lrclk_ratios
[i
].ratio
)
175 /* Should never happen, should be handled by constraints */
176 if (i
== ARRAY_SIZE(lrclk_ratios
)) {
177 dev_err(codec
->dev
, "MCLK/fs ratio %d unsupported\n",
178 wm8523
->sysclk
/ params_rate(params
));
182 aifctrl2
&= ~WM8523_SR_MASK
;
183 aifctrl2
|= lrclk_ratios
[i
].value
;
185 aifctrl1
&= ~WM8523_WL_MASK
;
186 switch (params_format(params
)) {
187 case SNDRV_PCM_FORMAT_S16_LE
:
189 case SNDRV_PCM_FORMAT_S20_3LE
:
192 case SNDRV_PCM_FORMAT_S24_LE
:
195 case SNDRV_PCM_FORMAT_S32_LE
:
200 snd_soc_write(codec
, WM8523_AIF_CTRL1
, aifctrl1
);
201 snd_soc_write(codec
, WM8523_AIF_CTRL2
, aifctrl2
);
206 static int wm8523_set_dai_sysclk(struct snd_soc_dai
*codec_dai
,
207 int clk_id
, unsigned int freq
, int dir
)
209 struct snd_soc_codec
*codec
= codec_dai
->codec
;
210 struct wm8523_priv
*wm8523
= snd_soc_codec_get_drvdata(codec
);
214 wm8523
->sysclk
= freq
;
216 wm8523
->rate_constraint
.count
= 0;
217 for (i
= 0; i
< ARRAY_SIZE(lrclk_ratios
); i
++) {
218 val
= freq
/ lrclk_ratios
[i
].ratio
;
219 /* Check that it's a standard rate since core can't
220 * cope with others and having the odd rates confuses
221 * constraint matching.
236 dev_dbg(codec
->dev
, "Supported sample rate: %dHz\n",
238 wm8523
->rate_constraint_list
[i
] = val
;
239 wm8523
->rate_constraint
.count
++;
242 dev_dbg(codec
->dev
, "Skipping sample rate: %dHz\n",
247 /* Need at least one supported rate... */
248 if (wm8523
->rate_constraint
.count
== 0)
255 static int wm8523_set_dai_fmt(struct snd_soc_dai
*codec_dai
,
258 struct snd_soc_codec
*codec
= codec_dai
->codec
;
259 u16 aifctrl1
= snd_soc_read(codec
, WM8523_AIF_CTRL1
);
261 aifctrl1
&= ~(WM8523_BCLK_INV_MASK
| WM8523_LRCLK_INV_MASK
|
262 WM8523_FMT_MASK
| WM8523_AIF_MSTR_MASK
);
264 switch (fmt
& SND_SOC_DAIFMT_MASTER_MASK
) {
265 case SND_SOC_DAIFMT_CBM_CFM
:
266 aifctrl1
|= WM8523_AIF_MSTR
;
268 case SND_SOC_DAIFMT_CBS_CFS
:
274 switch (fmt
& SND_SOC_DAIFMT_FORMAT_MASK
) {
275 case SND_SOC_DAIFMT_I2S
:
278 case SND_SOC_DAIFMT_RIGHT_J
:
280 case SND_SOC_DAIFMT_LEFT_J
:
283 case SND_SOC_DAIFMT_DSP_A
:
286 case SND_SOC_DAIFMT_DSP_B
:
293 switch (fmt
& SND_SOC_DAIFMT_INV_MASK
) {
294 case SND_SOC_DAIFMT_NB_NF
:
296 case SND_SOC_DAIFMT_IB_IF
:
297 aifctrl1
|= WM8523_BCLK_INV
| WM8523_LRCLK_INV
;
299 case SND_SOC_DAIFMT_IB_NF
:
300 aifctrl1
|= WM8523_BCLK_INV
;
302 case SND_SOC_DAIFMT_NB_IF
:
303 aifctrl1
|= WM8523_LRCLK_INV
;
309 snd_soc_write(codec
, WM8523_AIF_CTRL1
, aifctrl1
);
314 static int wm8523_set_bias_level(struct snd_soc_codec
*codec
,
315 enum snd_soc_bias_level level
)
317 struct wm8523_priv
*wm8523
= snd_soc_codec_get_drvdata(codec
);
321 case SND_SOC_BIAS_ON
:
324 case SND_SOC_BIAS_PREPARE
:
326 snd_soc_update_bits(codec
, WM8523_PSCTRL1
,
327 WM8523_SYS_ENA_MASK
, 3);
330 case SND_SOC_BIAS_STANDBY
:
331 if (codec
->bias_level
== SND_SOC_BIAS_OFF
) {
332 ret
= regulator_bulk_enable(ARRAY_SIZE(wm8523
->supplies
),
336 "Failed to enable supplies: %d\n",
341 /* Initial power up */
342 snd_soc_update_bits(codec
, WM8523_PSCTRL1
,
343 WM8523_SYS_ENA_MASK
, 1);
345 /* Sync back default/cached values */
346 for (i
= WM8523_AIF_CTRL1
;
347 i
< WM8523_MAX_REGISTER
; i
++)
348 snd_soc_write(codec
, i
, wm8523
->reg_cache
[i
]);
354 /* Power up to mute */
355 snd_soc_update_bits(codec
, WM8523_PSCTRL1
,
356 WM8523_SYS_ENA_MASK
, 2);
360 case SND_SOC_BIAS_OFF
:
361 /* The chip runs through the power down sequence for us. */
362 snd_soc_update_bits(codec
, WM8523_PSCTRL1
,
363 WM8523_SYS_ENA_MASK
, 0);
366 regulator_bulk_disable(ARRAY_SIZE(wm8523
->supplies
),
370 codec
->bias_level
= level
;
374 #define WM8523_RATES SNDRV_PCM_RATE_8000_192000
376 #define WM8523_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
377 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
379 static struct snd_soc_dai_ops wm8523_dai_ops
= {
380 .startup
= wm8523_startup
,
381 .hw_params
= wm8523_hw_params
,
382 .set_sysclk
= wm8523_set_dai_sysclk
,
383 .set_fmt
= wm8523_set_dai_fmt
,
386 static struct snd_soc_dai_driver wm8523_dai
= {
387 .name
= "wm8523-hifi",
389 .stream_name
= "Playback",
390 .channels_min
= 2, /* Mono modes not yet supported */
392 .rates
= WM8523_RATES
,
393 .formats
= WM8523_FORMATS
,
395 .ops
= &wm8523_dai_ops
,
399 static int wm8523_suspend(struct snd_soc_codec
*codec
, pm_message_t state
)
401 wm8523_set_bias_level(codec
, SND_SOC_BIAS_OFF
);
405 static int wm8523_resume(struct snd_soc_codec
*codec
)
407 wm8523_set_bias_level(codec
, SND_SOC_BIAS_STANDBY
);
411 #define wm8523_suspend NULL
412 #define wm8523_resume NULL
415 static int wm8523_probe(struct snd_soc_codec
*codec
)
417 struct wm8523_priv
*wm8523
= snd_soc_codec_get_drvdata(codec
);
420 codec
->hw_write
= (hw_write_t
)i2c_master_send
;
421 wm8523
->rate_constraint
.list
= &wm8523
->rate_constraint_list
[0];
422 wm8523
->rate_constraint
.count
=
423 ARRAY_SIZE(wm8523
->rate_constraint_list
);
425 ret
= snd_soc_codec_set_cache_io(codec
, 8, 16, wm8523
->control_type
);
427 dev_err(codec
->dev
, "Failed to set cache I/O: %d\n", ret
);
431 for (i
= 0; i
< ARRAY_SIZE(wm8523
->supplies
); i
++)
432 wm8523
->supplies
[i
].supply
= wm8523_supply_names
[i
];
434 ret
= regulator_bulk_get(codec
->dev
, ARRAY_SIZE(wm8523
->supplies
),
437 dev_err(codec
->dev
, "Failed to request supplies: %d\n", ret
);
441 ret
= regulator_bulk_enable(ARRAY_SIZE(wm8523
->supplies
),
444 dev_err(codec
->dev
, "Failed to enable supplies: %d\n", ret
);
448 ret
= snd_soc_read(codec
, WM8523_DEVICE_ID
);
450 dev_err(codec
->dev
, "Failed to read ID register\n");
453 if (ret
!= wm8523_reg
[WM8523_DEVICE_ID
]) {
454 dev_err(codec
->dev
, "Device is not a WM8523, ID is %x\n", ret
);
459 ret
= snd_soc_read(codec
, WM8523_REVISION
);
461 dev_err(codec
->dev
, "Failed to read revision register\n");
464 dev_info(codec
->dev
, "revision %c\n",
465 (ret
& WM8523_CHIP_REV_MASK
) + 'A');
467 ret
= wm8523_reset(codec
);
469 dev_err(codec
->dev
, "Failed to issue reset\n");
473 /* Change some default settings - latch VU and enable ZC */
474 wm8523
->reg_cache
[WM8523_DAC_GAINR
] |= WM8523_DACR_VU
;
475 wm8523
->reg_cache
[WM8523_DAC_CTRL3
] |= WM8523_ZC
;
477 wm8523_set_bias_level(codec
, SND_SOC_BIAS_STANDBY
);
479 /* Bias level configuration will have done an extra enable */
480 regulator_bulk_disable(ARRAY_SIZE(wm8523
->supplies
), wm8523
->supplies
);
482 snd_soc_add_controls(codec
, wm8523_snd_controls
,
483 ARRAY_SIZE(wm8523_snd_controls
));
484 wm8523_add_widgets(codec
);
489 regulator_bulk_disable(ARRAY_SIZE(wm8523
->supplies
), wm8523
->supplies
);
491 regulator_bulk_free(ARRAY_SIZE(wm8523
->supplies
), wm8523
->supplies
);
496 static int wm8523_remove(struct snd_soc_codec
*codec
)
498 struct wm8523_priv
*wm8523
= snd_soc_codec_get_drvdata(codec
);
500 wm8523_set_bias_level(codec
, SND_SOC_BIAS_OFF
);
501 regulator_bulk_free(ARRAY_SIZE(wm8523
->supplies
), wm8523
->supplies
);
505 static struct snd_soc_codec_driver soc_codec_dev_wm8523
= {
506 .probe
= wm8523_probe
,
507 .remove
= wm8523_remove
,
508 .suspend
= wm8523_suspend
,
509 .resume
= wm8523_resume
,
510 .set_bias_level
= wm8523_set_bias_level
,
511 .reg_cache_size
= WM8523_REGISTER_COUNT
,
512 .reg_word_size
= sizeof(u16
),
513 .reg_cache_default
= wm8523_reg
,
514 .volatile_register
= wm8523_volatile_register
,
517 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
518 static __devinit
int wm8523_i2c_probe(struct i2c_client
*i2c
,
519 const struct i2c_device_id
*id
)
521 struct wm8523_priv
*wm8523
;
524 wm8523
= kzalloc(sizeof(struct wm8523_priv
), GFP_KERNEL
);
528 i2c_set_clientdata(i2c
, wm8523
);
529 wm8523
->control_type
= SND_SOC_I2C
;
531 ret
= snd_soc_register_codec(&i2c
->dev
,
532 &soc_codec_dev_wm8523
, &wm8523_dai
, 1);
539 static __devexit
int wm8523_i2c_remove(struct i2c_client
*client
)
541 snd_soc_unregister_codec(&client
->dev
);
542 kfree(i2c_get_clientdata(client
));
546 static const struct i2c_device_id wm8523_i2c_id
[] = {
550 MODULE_DEVICE_TABLE(i2c
, wm8523_i2c_id
);
552 static struct i2c_driver wm8523_i2c_driver
= {
554 .name
= "wm8523-codec",
555 .owner
= THIS_MODULE
,
557 .probe
= wm8523_i2c_probe
,
558 .remove
= __devexit_p(wm8523_i2c_remove
),
559 .id_table
= wm8523_i2c_id
,
563 static int __init
wm8523_modinit(void)
566 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
567 ret
= i2c_add_driver(&wm8523_i2c_driver
);
569 printk(KERN_ERR
"Failed to register WM8523 I2C driver: %d\n",
575 module_init(wm8523_modinit
);
577 static void __exit
wm8523_exit(void)
579 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
580 i2c_del_driver(&wm8523_i2c_driver
);
583 module_exit(wm8523_exit
);
585 MODULE_DESCRIPTION("ASoC WM8523 driver");
586 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
587 MODULE_LICENSE("GPL");