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/regulator/consumer.h>
21 #include <linux/slab.h>
22 #include <linux/of_device.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/initval.h>
28 #include <sound/tlv.h>
32 #define WM8523_NUM_SUPPLIES 2
33 static const char *wm8523_supply_names
[WM8523_NUM_SUPPLIES
] = {
38 #define WM8523_NUM_RATES 7
40 /* codec private data */
42 enum snd_soc_control_type control_type
;
43 struct regulator_bulk_data supplies
[WM8523_NUM_SUPPLIES
];
45 unsigned int rate_constraint_list
[WM8523_NUM_RATES
];
46 struct snd_pcm_hw_constraint_list rate_constraint
;
49 static const u16 wm8523_reg
[WM8523_REGISTER_COUNT
] = {
50 0x8523, /* R0 - DEVICE_ID */
51 0x0001, /* R1 - REVISION */
52 0x0000, /* R2 - PSCTRL1 */
53 0x1812, /* R3 - AIF_CTRL1 */
54 0x0000, /* R4 - AIF_CTRL2 */
55 0x0001, /* R5 - DAC_CTRL3 */
56 0x0190, /* R6 - DAC_GAINL */
57 0x0190, /* R7 - DAC_GAINR */
58 0x0000, /* R8 - ZERO_DETECT */
61 static int wm8523_volatile_register(struct snd_soc_codec
*codec
, unsigned int reg
)
64 case WM8523_DEVICE_ID
:
72 static int wm8523_reset(struct snd_soc_codec
*codec
)
74 return snd_soc_write(codec
, WM8523_DEVICE_ID
, 0);
77 static const DECLARE_TLV_DB_SCALE(dac_tlv
, -10000, 25, 0);
79 static const char *wm8523_zd_count_text
[] = {
84 static const struct soc_enum wm8523_zc_count
=
85 SOC_ENUM_SINGLE(WM8523_ZERO_DETECT
, 0, 2, wm8523_zd_count_text
);
87 static const struct snd_kcontrol_new wm8523_controls
[] = {
88 SOC_DOUBLE_R_TLV("Playback Volume", WM8523_DAC_GAINL
, WM8523_DAC_GAINR
,
90 SOC_SINGLE("ZC Switch", WM8523_DAC_CTRL3
, 4, 1, 0),
91 SOC_SINGLE("Playback Deemphasis Switch", WM8523_AIF_CTRL1
, 8, 1, 0),
92 SOC_DOUBLE("Playback Switch", WM8523_DAC_CTRL3
, 2, 3, 1, 1),
93 SOC_SINGLE("Volume Ramp Up Switch", WM8523_DAC_CTRL3
, 1, 1, 0),
94 SOC_SINGLE("Volume Ramp Down Switch", WM8523_DAC_CTRL3
, 0, 1, 0),
95 SOC_ENUM("Zero Detect Count", wm8523_zc_count
),
98 static const struct snd_soc_dapm_widget wm8523_dapm_widgets
[] = {
99 SND_SOC_DAPM_DAC("DAC", "Playback", SND_SOC_NOPM
, 0, 0),
100 SND_SOC_DAPM_OUTPUT("LINEVOUTL"),
101 SND_SOC_DAPM_OUTPUT("LINEVOUTR"),
104 static const struct snd_soc_dapm_route wm8523_dapm_routes
[] = {
105 { "LINEVOUTL", NULL
, "DAC" },
106 { "LINEVOUTR", NULL
, "DAC" },
112 } lrclk_ratios
[WM8523_NUM_RATES
] = {
122 static int wm8523_startup(struct snd_pcm_substream
*substream
,
123 struct snd_soc_dai
*dai
)
125 struct snd_soc_codec
*codec
= dai
->codec
;
126 struct wm8523_priv
*wm8523
= snd_soc_codec_get_drvdata(codec
);
128 /* The set of sample rates that can be supported depends on the
129 * MCLK supplied to the CODEC - enforce this.
131 if (!wm8523
->sysclk
) {
133 "No MCLK configured, call set_sysclk() on init\n");
137 snd_pcm_hw_constraint_list(substream
->runtime
, 0,
138 SNDRV_PCM_HW_PARAM_RATE
,
139 &wm8523
->rate_constraint
);
144 static int wm8523_hw_params(struct snd_pcm_substream
*substream
,
145 struct snd_pcm_hw_params
*params
,
146 struct snd_soc_dai
*dai
)
148 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
149 struct snd_soc_codec
*codec
= rtd
->codec
;
150 struct wm8523_priv
*wm8523
= snd_soc_codec_get_drvdata(codec
);
152 u16 aifctrl1
= snd_soc_read(codec
, WM8523_AIF_CTRL1
);
153 u16 aifctrl2
= snd_soc_read(codec
, WM8523_AIF_CTRL2
);
155 /* Find a supported LRCLK ratio */
156 for (i
= 0; i
< ARRAY_SIZE(lrclk_ratios
); i
++) {
157 if (wm8523
->sysclk
/ params_rate(params
) ==
158 lrclk_ratios
[i
].ratio
)
162 /* Should never happen, should be handled by constraints */
163 if (i
== ARRAY_SIZE(lrclk_ratios
)) {
164 dev_err(codec
->dev
, "MCLK/fs ratio %d unsupported\n",
165 wm8523
->sysclk
/ params_rate(params
));
169 aifctrl2
&= ~WM8523_SR_MASK
;
170 aifctrl2
|= lrclk_ratios
[i
].value
;
172 aifctrl1
&= ~WM8523_WL_MASK
;
173 switch (params_format(params
)) {
174 case SNDRV_PCM_FORMAT_S16_LE
:
176 case SNDRV_PCM_FORMAT_S20_3LE
:
179 case SNDRV_PCM_FORMAT_S24_LE
:
182 case SNDRV_PCM_FORMAT_S32_LE
:
187 snd_soc_write(codec
, WM8523_AIF_CTRL1
, aifctrl1
);
188 snd_soc_write(codec
, WM8523_AIF_CTRL2
, aifctrl2
);
193 static int wm8523_set_dai_sysclk(struct snd_soc_dai
*codec_dai
,
194 int clk_id
, unsigned int freq
, int dir
)
196 struct snd_soc_codec
*codec
= codec_dai
->codec
;
197 struct wm8523_priv
*wm8523
= snd_soc_codec_get_drvdata(codec
);
201 wm8523
->sysclk
= freq
;
203 wm8523
->rate_constraint
.count
= 0;
204 for (i
= 0; i
< ARRAY_SIZE(lrclk_ratios
); i
++) {
205 val
= freq
/ lrclk_ratios
[i
].ratio
;
206 /* Check that it's a standard rate since core can't
207 * cope with others and having the odd rates confuses
208 * constraint matching.
223 dev_dbg(codec
->dev
, "Supported sample rate: %dHz\n",
225 wm8523
->rate_constraint_list
[i
] = val
;
226 wm8523
->rate_constraint
.count
++;
229 dev_dbg(codec
->dev
, "Skipping sample rate: %dHz\n",
234 /* Need at least one supported rate... */
235 if (wm8523
->rate_constraint
.count
== 0)
242 static int wm8523_set_dai_fmt(struct snd_soc_dai
*codec_dai
,
245 struct snd_soc_codec
*codec
= codec_dai
->codec
;
246 u16 aifctrl1
= snd_soc_read(codec
, WM8523_AIF_CTRL1
);
248 aifctrl1
&= ~(WM8523_BCLK_INV_MASK
| WM8523_LRCLK_INV_MASK
|
249 WM8523_FMT_MASK
| WM8523_AIF_MSTR_MASK
);
251 switch (fmt
& SND_SOC_DAIFMT_MASTER_MASK
) {
252 case SND_SOC_DAIFMT_CBM_CFM
:
253 aifctrl1
|= WM8523_AIF_MSTR
;
255 case SND_SOC_DAIFMT_CBS_CFS
:
261 switch (fmt
& SND_SOC_DAIFMT_FORMAT_MASK
) {
262 case SND_SOC_DAIFMT_I2S
:
265 case SND_SOC_DAIFMT_RIGHT_J
:
267 case SND_SOC_DAIFMT_LEFT_J
:
270 case SND_SOC_DAIFMT_DSP_A
:
273 case SND_SOC_DAIFMT_DSP_B
:
280 switch (fmt
& SND_SOC_DAIFMT_INV_MASK
) {
281 case SND_SOC_DAIFMT_NB_NF
:
283 case SND_SOC_DAIFMT_IB_IF
:
284 aifctrl1
|= WM8523_BCLK_INV
| WM8523_LRCLK_INV
;
286 case SND_SOC_DAIFMT_IB_NF
:
287 aifctrl1
|= WM8523_BCLK_INV
;
289 case SND_SOC_DAIFMT_NB_IF
:
290 aifctrl1
|= WM8523_LRCLK_INV
;
296 snd_soc_write(codec
, WM8523_AIF_CTRL1
, aifctrl1
);
301 static int wm8523_set_bias_level(struct snd_soc_codec
*codec
,
302 enum snd_soc_bias_level level
)
304 struct wm8523_priv
*wm8523
= snd_soc_codec_get_drvdata(codec
);
305 u16
*reg_cache
= codec
->reg_cache
;
309 case SND_SOC_BIAS_ON
:
312 case SND_SOC_BIAS_PREPARE
:
314 snd_soc_update_bits(codec
, WM8523_PSCTRL1
,
315 WM8523_SYS_ENA_MASK
, 3);
318 case SND_SOC_BIAS_STANDBY
:
319 if (codec
->dapm
.bias_level
== SND_SOC_BIAS_OFF
) {
320 ret
= regulator_bulk_enable(ARRAY_SIZE(wm8523
->supplies
),
324 "Failed to enable supplies: %d\n",
329 /* Initial power up */
330 snd_soc_update_bits(codec
, WM8523_PSCTRL1
,
331 WM8523_SYS_ENA_MASK
, 1);
333 /* Sync back default/cached values */
334 for (i
= WM8523_AIF_CTRL1
;
335 i
< WM8523_MAX_REGISTER
; i
++)
336 snd_soc_write(codec
, i
, reg_cache
[i
]);
342 /* Power up to mute */
343 snd_soc_update_bits(codec
, WM8523_PSCTRL1
,
344 WM8523_SYS_ENA_MASK
, 2);
348 case SND_SOC_BIAS_OFF
:
349 /* The chip runs through the power down sequence for us. */
350 snd_soc_update_bits(codec
, WM8523_PSCTRL1
,
351 WM8523_SYS_ENA_MASK
, 0);
354 regulator_bulk_disable(ARRAY_SIZE(wm8523
->supplies
),
358 codec
->dapm
.bias_level
= level
;
362 #define WM8523_RATES SNDRV_PCM_RATE_8000_192000
364 #define WM8523_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
365 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
367 static const struct snd_soc_dai_ops wm8523_dai_ops
= {
368 .startup
= wm8523_startup
,
369 .hw_params
= wm8523_hw_params
,
370 .set_sysclk
= wm8523_set_dai_sysclk
,
371 .set_fmt
= wm8523_set_dai_fmt
,
374 static struct snd_soc_dai_driver wm8523_dai
= {
375 .name
= "wm8523-hifi",
377 .stream_name
= "Playback",
378 .channels_min
= 2, /* Mono modes not yet supported */
380 .rates
= WM8523_RATES
,
381 .formats
= WM8523_FORMATS
,
383 .ops
= &wm8523_dai_ops
,
387 static int wm8523_suspend(struct snd_soc_codec
*codec
)
389 wm8523_set_bias_level(codec
, SND_SOC_BIAS_OFF
);
393 static int wm8523_resume(struct snd_soc_codec
*codec
)
395 wm8523_set_bias_level(codec
, SND_SOC_BIAS_STANDBY
);
399 #define wm8523_suspend NULL
400 #define wm8523_resume NULL
403 static int wm8523_probe(struct snd_soc_codec
*codec
)
405 struct wm8523_priv
*wm8523
= snd_soc_codec_get_drvdata(codec
);
408 wm8523
->rate_constraint
.list
= &wm8523
->rate_constraint_list
[0];
409 wm8523
->rate_constraint
.count
=
410 ARRAY_SIZE(wm8523
->rate_constraint_list
);
412 ret
= snd_soc_codec_set_cache_io(codec
, 8, 16, wm8523
->control_type
);
414 dev_err(codec
->dev
, "Failed to set cache I/O: %d\n", ret
);
418 for (i
= 0; i
< ARRAY_SIZE(wm8523
->supplies
); i
++)
419 wm8523
->supplies
[i
].supply
= wm8523_supply_names
[i
];
421 ret
= regulator_bulk_get(codec
->dev
, ARRAY_SIZE(wm8523
->supplies
),
424 dev_err(codec
->dev
, "Failed to request supplies: %d\n", ret
);
428 ret
= regulator_bulk_enable(ARRAY_SIZE(wm8523
->supplies
),
431 dev_err(codec
->dev
, "Failed to enable supplies: %d\n", ret
);
435 ret
= snd_soc_read(codec
, WM8523_DEVICE_ID
);
437 dev_err(codec
->dev
, "Failed to read ID register\n");
440 if (ret
!= wm8523_reg
[WM8523_DEVICE_ID
]) {
441 dev_err(codec
->dev
, "Device is not a WM8523, ID is %x\n", ret
);
446 ret
= snd_soc_read(codec
, WM8523_REVISION
);
448 dev_err(codec
->dev
, "Failed to read revision register\n");
451 dev_info(codec
->dev
, "revision %c\n",
452 (ret
& WM8523_CHIP_REV_MASK
) + 'A');
454 ret
= wm8523_reset(codec
);
456 dev_err(codec
->dev
, "Failed to issue reset\n");
460 /* Change some default settings - latch VU and enable ZC */
461 snd_soc_update_bits(codec
, WM8523_DAC_GAINR
,
462 WM8523_DACR_VU
, WM8523_DACR_VU
);
463 snd_soc_update_bits(codec
, WM8523_DAC_CTRL3
, WM8523_ZC
, WM8523_ZC
);
465 wm8523_set_bias_level(codec
, SND_SOC_BIAS_STANDBY
);
467 /* Bias level configuration will have done an extra enable */
468 regulator_bulk_disable(ARRAY_SIZE(wm8523
->supplies
), wm8523
->supplies
);
473 regulator_bulk_disable(ARRAY_SIZE(wm8523
->supplies
), wm8523
->supplies
);
475 regulator_bulk_free(ARRAY_SIZE(wm8523
->supplies
), wm8523
->supplies
);
480 static int wm8523_remove(struct snd_soc_codec
*codec
)
482 struct wm8523_priv
*wm8523
= snd_soc_codec_get_drvdata(codec
);
484 wm8523_set_bias_level(codec
, SND_SOC_BIAS_OFF
);
485 regulator_bulk_free(ARRAY_SIZE(wm8523
->supplies
), wm8523
->supplies
);
489 static struct snd_soc_codec_driver soc_codec_dev_wm8523
= {
490 .probe
= wm8523_probe
,
491 .remove
= wm8523_remove
,
492 .suspend
= wm8523_suspend
,
493 .resume
= wm8523_resume
,
494 .set_bias_level
= wm8523_set_bias_level
,
495 .reg_cache_size
= WM8523_REGISTER_COUNT
,
496 .reg_word_size
= sizeof(u16
),
497 .reg_cache_default
= wm8523_reg
,
498 .volatile_register
= wm8523_volatile_register
,
500 .controls
= wm8523_controls
,
501 .num_controls
= ARRAY_SIZE(wm8523_controls
),
502 .dapm_widgets
= wm8523_dapm_widgets
,
503 .num_dapm_widgets
= ARRAY_SIZE(wm8523_dapm_widgets
),
504 .dapm_routes
= wm8523_dapm_routes
,
505 .num_dapm_routes
= ARRAY_SIZE(wm8523_dapm_routes
),
508 static const struct of_device_id wm8523_of_match
[] = {
509 { .compatible
= "wlf,wm8523" },
513 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
514 static __devinit
int wm8523_i2c_probe(struct i2c_client
*i2c
,
515 const struct i2c_device_id
*id
)
517 struct wm8523_priv
*wm8523
;
520 wm8523
= kzalloc(sizeof(struct wm8523_priv
), GFP_KERNEL
);
524 i2c_set_clientdata(i2c
, wm8523
);
525 wm8523
->control_type
= SND_SOC_I2C
;
527 ret
= snd_soc_register_codec(&i2c
->dev
,
528 &soc_codec_dev_wm8523
, &wm8523_dai
, 1);
535 static __devexit
int wm8523_i2c_remove(struct i2c_client
*client
)
537 snd_soc_unregister_codec(&client
->dev
);
538 kfree(i2c_get_clientdata(client
));
542 static const struct i2c_device_id wm8523_i2c_id
[] = {
546 MODULE_DEVICE_TABLE(i2c
, wm8523_i2c_id
);
548 static struct i2c_driver wm8523_i2c_driver
= {
551 .owner
= THIS_MODULE
,
552 .of_match_table
= wm8523_of_match
,
554 .probe
= wm8523_i2c_probe
,
555 .remove
= __devexit_p(wm8523_i2c_remove
),
556 .id_table
= wm8523_i2c_id
,
560 static int __init
wm8523_modinit(void)
563 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
564 ret
= i2c_add_driver(&wm8523_i2c_driver
);
566 printk(KERN_ERR
"Failed to register WM8523 I2C driver: %d\n",
572 module_init(wm8523_modinit
);
574 static void __exit
wm8523_exit(void)
576 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
577 i2c_del_driver(&wm8523_i2c_driver
);
580 module_exit(wm8523_exit
);
582 MODULE_DESCRIPTION("ASoC WM8523 driver");
583 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
584 MODULE_LICENSE("GPL");