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 <sound/core.h>
23 #include <sound/pcm.h>
24 #include <sound/pcm_params.h>
25 #include <sound/soc.h>
26 #include <sound/soc-dapm.h>
27 #include <sound/initval.h>
28 #include <sound/tlv.h>
32 static struct snd_soc_codec
*wm8523_codec
;
33 struct snd_soc_codec_device soc_codec_dev_wm8523
;
35 #define WM8523_NUM_SUPPLIES 2
36 static const char *wm8523_supply_names
[WM8523_NUM_SUPPLIES
] = {
41 #define WM8523_NUM_RATES 7
43 /* codec private data */
45 struct snd_soc_codec codec
;
46 u16 reg_cache
[WM8523_REGISTER_COUNT
];
47 struct regulator_bulk_data supplies
[WM8523_NUM_SUPPLIES
];
49 unsigned int rate_constraint_list
[WM8523_NUM_RATES
];
50 struct snd_pcm_hw_constraint_list rate_constraint
;
53 static const u16 wm8523_reg
[WM8523_REGISTER_COUNT
] = {
54 0x8523, /* R0 - DEVICE_ID */
55 0x0001, /* R1 - REVISION */
56 0x0000, /* R2 - PSCTRL1 */
57 0x1812, /* R3 - AIF_CTRL1 */
58 0x0000, /* R4 - AIF_CTRL2 */
59 0x0001, /* R5 - DAC_CTRL3 */
60 0x0190, /* R6 - DAC_GAINL */
61 0x0190, /* R7 - DAC_GAINR */
62 0x0000, /* R8 - ZERO_DETECT */
65 static int wm8523_volatile(unsigned int reg
)
68 case WM8523_DEVICE_ID
:
76 static int wm8523_write(struct snd_soc_codec
*codec
, unsigned int reg
,
79 struct wm8523_priv
*wm8523
= codec
->private_data
;
82 BUG_ON(reg
> WM8523_MAX_REGISTER
);
85 data
[1] = (value
>> 8) & 0x00ff;
86 data
[2] = value
& 0x00ff;
88 if (!wm8523_volatile(reg
))
89 wm8523
->reg_cache
[reg
] = value
;
90 if (codec
->hw_write(codec
->control_data
, data
, 3) == 3)
96 static int wm8523_reset(struct snd_soc_codec
*codec
)
98 return wm8523_write(codec
, WM8523_DEVICE_ID
, 0);
101 static unsigned int wm8523_read_hw(struct snd_soc_codec
*codec
, u8 reg
)
103 struct i2c_msg xfer
[2];
106 struct i2c_client
*i2c
= codec
->control_data
;
109 xfer
[0].addr
= i2c
->addr
;
115 xfer
[1].addr
= i2c
->addr
;
116 xfer
[1].flags
= I2C_M_RD
;
118 xfer
[1].buf
= (u8
*)&data
;
120 ret
= i2c_transfer(i2c
->adapter
, xfer
, 2);
122 dev_err(codec
->dev
, "Failed to read 0x%x: %d\n", reg
, ret
);
126 return (data
>> 8) | ((data
& 0xff) << 8);
130 static unsigned int wm8523_read(struct snd_soc_codec
*codec
,
133 u16
*reg_cache
= codec
->reg_cache
;
135 BUG_ON(reg
> WM8523_MAX_REGISTER
);
137 if (wm8523_volatile(reg
))
138 return wm8523_read_hw(codec
, reg
);
140 return reg_cache
[reg
];
143 static const DECLARE_TLV_DB_SCALE(dac_tlv
, -10000, 25, 0);
145 static const char *wm8523_zd_count_text
[] = {
150 static const struct soc_enum wm8523_zc_count
=
151 SOC_ENUM_SINGLE(WM8523_ZERO_DETECT
, 0, 2, wm8523_zd_count_text
);
153 static const struct snd_kcontrol_new wm8523_snd_controls
[] = {
154 SOC_DOUBLE_R_TLV("Playback Volume", WM8523_DAC_GAINL
, WM8523_DAC_GAINR
,
156 SOC_SINGLE("ZC Switch", WM8523_DAC_CTRL3
, 4, 1, 0),
157 SOC_SINGLE("Playback Deemphasis Switch", WM8523_AIF_CTRL1
, 8, 1, 0),
158 SOC_DOUBLE("Playback Switch", WM8523_DAC_CTRL3
, 2, 3, 1, 1),
159 SOC_SINGLE("Volume Ramp Up Switch", WM8523_DAC_CTRL3
, 1, 1, 0),
160 SOC_SINGLE("Volume Ramp Down Switch", WM8523_DAC_CTRL3
, 0, 1, 0),
161 SOC_ENUM("Zero Detect Count", wm8523_zc_count
),
164 static const struct snd_soc_dapm_widget wm8523_dapm_widgets
[] = {
165 SND_SOC_DAPM_DAC("DAC", "Playback", SND_SOC_NOPM
, 0, 0),
166 SND_SOC_DAPM_OUTPUT("LINEVOUTL"),
167 SND_SOC_DAPM_OUTPUT("LINEVOUTR"),
170 static const struct snd_soc_dapm_route intercon
[] = {
171 { "LINEVOUTL", NULL
, "DAC" },
172 { "LINEVOUTR", NULL
, "DAC" },
175 static int wm8523_add_widgets(struct snd_soc_codec
*codec
)
177 snd_soc_dapm_new_controls(codec
, wm8523_dapm_widgets
,
178 ARRAY_SIZE(wm8523_dapm_widgets
));
180 snd_soc_dapm_add_routes(codec
, intercon
, ARRAY_SIZE(intercon
));
182 snd_soc_dapm_new_widgets(codec
);
189 } lrclk_ratios
[WM8523_NUM_RATES
] = {
199 static int wm8523_startup(struct snd_pcm_substream
*substream
,
200 struct snd_soc_dai
*dai
)
202 struct snd_soc_codec
*codec
= dai
->codec
;
203 struct wm8523_priv
*wm8523
= codec
->private_data
;
205 /* The set of sample rates that can be supported depends on the
206 * MCLK supplied to the CODEC - enforce this.
208 if (!wm8523
->sysclk
) {
210 "No MCLK configured, call set_sysclk() on init\n");
215 snd_pcm_hw_constraint_list(substream
->runtime
, 0,
216 SNDRV_PCM_HW_PARAM_RATE
,
217 &wm8523
->rate_constraint
);
222 static int wm8523_hw_params(struct snd_pcm_substream
*substream
,
223 struct snd_pcm_hw_params
*params
,
224 struct snd_soc_dai
*dai
)
226 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
227 struct snd_soc_device
*socdev
= rtd
->socdev
;
228 struct snd_soc_codec
*codec
= socdev
->card
->codec
;
229 struct wm8523_priv
*wm8523
= codec
->private_data
;
231 u16 aifctrl1
= wm8523_read(codec
, WM8523_AIF_CTRL1
);
232 u16 aifctrl2
= wm8523_read(codec
, WM8523_AIF_CTRL2
);
234 /* Find a supported LRCLK ratio */
235 for (i
= 0; i
< ARRAY_SIZE(lrclk_ratios
); i
++) {
236 if (wm8523
->sysclk
/ params_rate(params
) ==
237 lrclk_ratios
[i
].ratio
)
241 /* Should never happen, should be handled by constraints */
242 if (i
== ARRAY_SIZE(lrclk_ratios
)) {
243 dev_err(codec
->dev
, "MCLK/fs ratio %d unsupported\n",
244 wm8523
->sysclk
/ params_rate(params
));
248 aifctrl2
&= ~WM8523_SR_MASK
;
249 aifctrl2
|= lrclk_ratios
[i
].value
;
251 aifctrl1
&= ~WM8523_WL_MASK
;
252 switch (params_format(params
)) {
253 case SNDRV_PCM_FORMAT_S16_LE
:
255 case SNDRV_PCM_FORMAT_S20_3LE
:
258 case SNDRV_PCM_FORMAT_S24_LE
:
261 case SNDRV_PCM_FORMAT_S32_LE
:
266 wm8523_write(codec
, WM8523_AIF_CTRL1
, aifctrl1
);
267 wm8523_write(codec
, WM8523_AIF_CTRL2
, aifctrl2
);
272 static int wm8523_set_dai_sysclk(struct snd_soc_dai
*codec_dai
,
273 int clk_id
, unsigned int freq
, int dir
)
275 struct snd_soc_codec
*codec
= codec_dai
->codec
;
276 struct wm8523_priv
*wm8523
= codec
->private_data
;
280 wm8523
->sysclk
= freq
;
282 wm8523
->rate_constraint
.count
= 0;
283 for (i
= 0; i
< ARRAY_SIZE(lrclk_ratios
); i
++) {
284 val
= freq
/ lrclk_ratios
[i
].ratio
;
285 /* Check that it's a standard rate since core can't
286 * cope with others and having the odd rates confuses
287 * constraint matching.
302 dev_dbg(codec
->dev
, "Supported sample rate: %dHz\n",
304 wm8523
->rate_constraint_list
[i
] = val
;
305 wm8523
->rate_constraint
.count
++;
308 dev_dbg(codec
->dev
, "Skipping sample rate: %dHz\n",
313 /* Need at least one supported rate... */
314 if (wm8523
->rate_constraint
.count
== 0)
321 static int wm8523_set_dai_fmt(struct snd_soc_dai
*codec_dai
,
324 struct snd_soc_codec
*codec
= codec_dai
->codec
;
325 u16 aifctrl1
= wm8523_read(codec
, WM8523_AIF_CTRL1
);
327 aifctrl1
&= ~(WM8523_BCLK_INV_MASK
| WM8523_LRCLK_INV_MASK
|
328 WM8523_FMT_MASK
| WM8523_AIF_MSTR_MASK
);
330 switch (fmt
& SND_SOC_DAIFMT_MASTER_MASK
) {
331 case SND_SOC_DAIFMT_CBM_CFM
:
332 aifctrl1
|= WM8523_AIF_MSTR
;
334 case SND_SOC_DAIFMT_CBS_CFS
:
340 switch (fmt
& SND_SOC_DAIFMT_FORMAT_MASK
) {
341 case SND_SOC_DAIFMT_I2S
:
344 case SND_SOC_DAIFMT_RIGHT_J
:
346 case SND_SOC_DAIFMT_LEFT_J
:
349 case SND_SOC_DAIFMT_DSP_A
:
352 case SND_SOC_DAIFMT_DSP_B
:
359 switch (fmt
& SND_SOC_DAIFMT_INV_MASK
) {
360 case SND_SOC_DAIFMT_NB_NF
:
362 case SND_SOC_DAIFMT_IB_IF
:
363 aifctrl1
|= WM8523_BCLK_INV
| WM8523_LRCLK_INV
;
365 case SND_SOC_DAIFMT_IB_NF
:
366 aifctrl1
|= WM8523_BCLK_INV
;
368 case SND_SOC_DAIFMT_NB_IF
:
369 aifctrl1
|= WM8523_LRCLK_INV
;
375 wm8523_write(codec
, WM8523_AIF_CTRL1
, aifctrl1
);
380 static int wm8523_set_bias_level(struct snd_soc_codec
*codec
,
381 enum snd_soc_bias_level level
)
383 struct wm8523_priv
*wm8523
= codec
->private_data
;
387 case SND_SOC_BIAS_ON
:
390 case SND_SOC_BIAS_PREPARE
:
392 snd_soc_update_bits(codec
, WM8523_PSCTRL1
,
393 WM8523_SYS_ENA_MASK
, 3);
396 case SND_SOC_BIAS_STANDBY
:
397 if (codec
->bias_level
== SND_SOC_BIAS_OFF
) {
398 ret
= regulator_bulk_enable(ARRAY_SIZE(wm8523
->supplies
),
402 "Failed to enable supplies: %d\n",
407 /* Initial power up */
408 snd_soc_update_bits(codec
, WM8523_PSCTRL1
,
409 WM8523_SYS_ENA_MASK
, 1);
411 /* Sync back default/cached values */
412 for (i
= WM8523_AIF_CTRL1
;
413 i
< WM8523_MAX_REGISTER
; i
++)
414 wm8523_write(codec
, i
, wm8523
->reg_cache
[i
]);
420 /* Power up to mute */
421 snd_soc_update_bits(codec
, WM8523_PSCTRL1
,
422 WM8523_SYS_ENA_MASK
, 2);
426 case SND_SOC_BIAS_OFF
:
427 /* The chip runs through the power down sequence for us. */
428 snd_soc_update_bits(codec
, WM8523_PSCTRL1
,
429 WM8523_SYS_ENA_MASK
, 0);
432 regulator_bulk_disable(ARRAY_SIZE(wm8523
->supplies
),
436 codec
->bias_level
= level
;
440 #define WM8523_RATES SNDRV_PCM_RATE_8000_192000
442 #define WM8523_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
443 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
445 static struct snd_soc_dai_ops wm8523_dai_ops
= {
446 .startup
= wm8523_startup
,
447 .hw_params
= wm8523_hw_params
,
448 .set_sysclk
= wm8523_set_dai_sysclk
,
449 .set_fmt
= wm8523_set_dai_fmt
,
452 struct snd_soc_dai wm8523_dai
= {
455 .stream_name
= "Playback",
456 .channels_min
= 2, /* Mono modes not yet supported */
458 .rates
= WM8523_RATES
,
459 .formats
= WM8523_FORMATS
,
461 .ops
= &wm8523_dai_ops
,
463 EXPORT_SYMBOL_GPL(wm8523_dai
);
466 static int wm8523_suspend(struct platform_device
*pdev
, pm_message_t state
)
468 struct snd_soc_device
*socdev
= platform_get_drvdata(pdev
);
469 struct snd_soc_codec
*codec
= socdev
->card
->codec
;
471 wm8523_set_bias_level(codec
, SND_SOC_BIAS_OFF
);
475 static int wm8523_resume(struct platform_device
*pdev
)
477 struct snd_soc_device
*socdev
= platform_get_drvdata(pdev
);
478 struct snd_soc_codec
*codec
= socdev
->card
->codec
;
480 wm8523_set_bias_level(codec
, SND_SOC_BIAS_STANDBY
);
485 #define wm8523_suspend NULL
486 #define wm8523_resume NULL
489 static int wm8523_probe(struct platform_device
*pdev
)
491 struct snd_soc_device
*socdev
= platform_get_drvdata(pdev
);
492 struct snd_soc_codec
*codec
;
495 if (wm8523_codec
== NULL
) {
496 dev_err(&pdev
->dev
, "Codec device not registered\n");
500 socdev
->card
->codec
= wm8523_codec
;
501 codec
= wm8523_codec
;
504 ret
= snd_soc_new_pcms(socdev
, SNDRV_DEFAULT_IDX1
, SNDRV_DEFAULT_STR1
);
506 dev_err(codec
->dev
, "failed to create pcms: %d\n", ret
);
510 snd_soc_add_controls(codec
, wm8523_snd_controls
,
511 ARRAY_SIZE(wm8523_snd_controls
));
512 wm8523_add_widgets(codec
);
513 ret
= snd_soc_init_card(socdev
);
515 dev_err(codec
->dev
, "failed to register card: %d\n", ret
);
522 snd_soc_free_pcms(socdev
);
523 snd_soc_dapm_free(socdev
);
528 static int wm8523_remove(struct platform_device
*pdev
)
530 struct snd_soc_device
*socdev
= platform_get_drvdata(pdev
);
532 snd_soc_free_pcms(socdev
);
533 snd_soc_dapm_free(socdev
);
538 struct snd_soc_codec_device soc_codec_dev_wm8523
= {
539 .probe
= wm8523_probe
,
540 .remove
= wm8523_remove
,
541 .suspend
= wm8523_suspend
,
542 .resume
= wm8523_resume
,
544 EXPORT_SYMBOL_GPL(soc_codec_dev_wm8523
);
546 static int wm8523_register(struct wm8523_priv
*wm8523
)
549 struct snd_soc_codec
*codec
= &wm8523
->codec
;
553 dev_err(codec
->dev
, "Another WM8523 is registered\n");
557 mutex_init(&codec
->mutex
);
558 INIT_LIST_HEAD(&codec
->dapm_widgets
);
559 INIT_LIST_HEAD(&codec
->dapm_paths
);
561 codec
->private_data
= wm8523
;
562 codec
->name
= "WM8523";
563 codec
->owner
= THIS_MODULE
;
564 codec
->read
= wm8523_read
;
565 codec
->write
= wm8523_write
;
566 codec
->bias_level
= SND_SOC_BIAS_OFF
;
567 codec
->set_bias_level
= wm8523_set_bias_level
;
568 codec
->dai
= &wm8523_dai
;
570 codec
->reg_cache_size
= WM8523_REGISTER_COUNT
;
571 codec
->reg_cache
= &wm8523
->reg_cache
;
573 wm8523
->rate_constraint
.list
= &wm8523
->rate_constraint_list
[0];
574 wm8523
->rate_constraint
.count
=
575 ARRAY_SIZE(wm8523
->rate_constraint_list
);
577 memcpy(codec
->reg_cache
, wm8523_reg
, sizeof(wm8523_reg
));
579 for (i
= 0; i
< ARRAY_SIZE(wm8523
->supplies
); i
++)
580 wm8523
->supplies
[i
].supply
= wm8523_supply_names
[i
];
582 ret
= regulator_bulk_get(codec
->dev
, ARRAY_SIZE(wm8523
->supplies
),
585 dev_err(codec
->dev
, "Failed to request supplies: %d\n", ret
);
589 ret
= regulator_bulk_enable(ARRAY_SIZE(wm8523
->supplies
),
592 dev_err(codec
->dev
, "Failed to enable supplies: %d\n", ret
);
596 ret
= wm8523_read(codec
, WM8523_DEVICE_ID
);
598 dev_err(codec
->dev
, "Failed to read ID register\n");
601 if (ret
!= wm8523_reg
[WM8523_DEVICE_ID
]) {
602 dev_err(codec
->dev
, "Device is not a WM8523, ID is %x\n", ret
);
607 ret
= wm8523_read(codec
, WM8523_REVISION
);
609 dev_err(codec
->dev
, "Failed to read revision register\n");
612 dev_info(codec
->dev
, "revision %c\n",
613 (ret
& WM8523_CHIP_REV_MASK
) + 'A');
615 ret
= wm8523_reset(codec
);
617 dev_err(codec
->dev
, "Failed to issue reset\n");
621 wm8523_dai
.dev
= codec
->dev
;
623 /* Change some default settings - latch VU and enable ZC */
624 wm8523
->reg_cache
[WM8523_DAC_GAINR
] |= WM8523_DACR_VU
;
625 wm8523
->reg_cache
[WM8523_DAC_CTRL3
] |= WM8523_ZC
;
627 wm8523_set_bias_level(codec
, SND_SOC_BIAS_STANDBY
);
629 /* Bias level configuration will have done an extra enable */
630 regulator_bulk_disable(ARRAY_SIZE(wm8523
->supplies
), wm8523
->supplies
);
632 wm8523_codec
= codec
;
634 ret
= snd_soc_register_codec(codec
);
636 dev_err(codec
->dev
, "Failed to register codec: %d\n", ret
);
640 ret
= snd_soc_register_dai(&wm8523_dai
);
642 dev_err(codec
->dev
, "Failed to register DAI: %d\n", ret
);
643 snd_soc_unregister_codec(codec
);
650 regulator_bulk_disable(ARRAY_SIZE(wm8523
->supplies
), wm8523
->supplies
);
652 regulator_bulk_free(ARRAY_SIZE(wm8523
->supplies
), wm8523
->supplies
);
658 static void wm8523_unregister(struct wm8523_priv
*wm8523
)
660 wm8523_set_bias_level(&wm8523
->codec
, SND_SOC_BIAS_OFF
);
661 regulator_bulk_free(ARRAY_SIZE(wm8523
->supplies
), wm8523
->supplies
);
662 snd_soc_unregister_dai(&wm8523_dai
);
663 snd_soc_unregister_codec(&wm8523
->codec
);
668 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
669 static __devinit
int wm8523_i2c_probe(struct i2c_client
*i2c
,
670 const struct i2c_device_id
*id
)
672 struct wm8523_priv
*wm8523
;
673 struct snd_soc_codec
*codec
;
675 wm8523
= kzalloc(sizeof(struct wm8523_priv
), GFP_KERNEL
);
679 codec
= &wm8523
->codec
;
680 codec
->hw_write
= (hw_write_t
)i2c_master_send
;
682 i2c_set_clientdata(i2c
, wm8523
);
683 codec
->control_data
= i2c
;
685 codec
->dev
= &i2c
->dev
;
687 return wm8523_register(wm8523
);
690 static __devexit
int wm8523_i2c_remove(struct i2c_client
*client
)
692 struct wm8523_priv
*wm8523
= i2c_get_clientdata(client
);
693 wm8523_unregister(wm8523
);
698 static int wm8523_i2c_suspend(struct i2c_client
*i2c
, pm_message_t msg
)
700 return snd_soc_suspend_device(&i2c
->dev
);
703 static int wm8523_i2c_resume(struct i2c_client
*i2c
)
705 return snd_soc_resume_device(&i2c
->dev
);
708 #define wm8523_i2c_suspend NULL
709 #define wm8523_i2c_resume NULL
712 static const struct i2c_device_id wm8523_i2c_id
[] = {
716 MODULE_DEVICE_TABLE(i2c
, wm8523_i2c_id
);
718 static struct i2c_driver wm8523_i2c_driver
= {
721 .owner
= THIS_MODULE
,
723 .probe
= wm8523_i2c_probe
,
724 .remove
= __devexit_p(wm8523_i2c_remove
),
725 .suspend
= wm8523_i2c_suspend
,
726 .resume
= wm8523_i2c_resume
,
727 .id_table
= wm8523_i2c_id
,
731 static int __init
wm8523_modinit(void)
734 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
735 ret
= i2c_add_driver(&wm8523_i2c_driver
);
737 printk(KERN_ERR
"Failed to register WM8523 I2C driver: %d\n",
743 module_init(wm8523_modinit
);
745 static void __exit
wm8523_exit(void)
747 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
748 i2c_del_driver(&wm8523_i2c_driver
);
751 module_exit(wm8523_exit
);
753 MODULE_DESCRIPTION("ASoC WM8523 driver");
754 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
755 MODULE_LICENSE("GPL");