Commit | Line | Data |
---|---|---|
b0757062 KM |
1 | /* |
2 | * ak4613.c -- Asahi Kasei ALSA Soc Audio driver | |
3 | * | |
4 | * Copyright (C) 2015 Renesas Electronics Corporation | |
5 | * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> | |
6 | * | |
7 | * Based on ak4642.c by Kuninori Morimoto | |
8 | * Based on wm8731.c by Richard Purdie | |
9 | * Based on ak4535.c by Richard Purdie | |
10 | * Based on wm8753.c by Liam Girdwood | |
11 | * | |
12 | * This program is free software; you can redistribute it and/or modify | |
13 | * it under the terms of the GNU General Public License version 2 as | |
14 | * published by the Free Software Foundation. | |
15 | */ | |
16 | ||
17 | #include <linux/clk.h> | |
18 | #include <linux/i2c.h> | |
19 | #include <linux/slab.h> | |
20 | #include <linux/of_device.h> | |
21 | #include <linux/module.h> | |
22 | #include <linux/regmap.h> | |
23 | #include <sound/soc.h> | |
24 | #include <sound/pcm_params.h> | |
e3a4d958 | 25 | #include <sound/tlv.h> |
b0757062 KM |
26 | |
27 | #define PW_MGMT1 0x00 /* Power Management 1 */ | |
28 | #define PW_MGMT2 0x01 /* Power Management 2 */ | |
29 | #define PW_MGMT3 0x02 /* Power Management 3 */ | |
30 | #define CTRL1 0x03 /* Control 1 */ | |
31 | #define CTRL2 0x04 /* Control 2 */ | |
32 | #define DEMP1 0x05 /* De-emphasis1 */ | |
33 | #define DEMP2 0x06 /* De-emphasis2 */ | |
34 | #define OFD 0x07 /* Overflow Detect */ | |
35 | #define ZRD 0x08 /* Zero Detect */ | |
36 | #define ICTRL 0x09 /* Input Control */ | |
37 | #define OCTRL 0x0a /* Output Control */ | |
38 | #define LOUT1 0x0b /* LOUT1 Volume Control */ | |
39 | #define ROUT1 0x0c /* ROUT1 Volume Control */ | |
40 | #define LOUT2 0x0d /* LOUT2 Volume Control */ | |
41 | #define ROUT2 0x0e /* ROUT2 Volume Control */ | |
42 | #define LOUT3 0x0f /* LOUT3 Volume Control */ | |
43 | #define ROUT3 0x10 /* ROUT3 Volume Control */ | |
44 | #define LOUT4 0x11 /* LOUT4 Volume Control */ | |
45 | #define ROUT4 0x12 /* ROUT4 Volume Control */ | |
46 | #define LOUT5 0x13 /* LOUT5 Volume Control */ | |
47 | #define ROUT5 0x14 /* ROUT5 Volume Control */ | |
48 | #define LOUT6 0x15 /* LOUT6 Volume Control */ | |
49 | #define ROUT6 0x16 /* ROUT6 Volume Control */ | |
50 | ||
51 | /* PW_MGMT1 */ | |
52 | #define RSTN BIT(0) | |
53 | #define PMDAC BIT(1) | |
54 | #define PMADC BIT(2) | |
55 | #define PMVR BIT(3) | |
56 | ||
57 | /* PW_MGMT2 */ | |
58 | #define PMAD_ALL 0x7 | |
59 | ||
60 | /* PW_MGMT3 */ | |
61 | #define PMDA_ALL 0x3f | |
62 | ||
63 | /* CTRL1 */ | |
64 | #define DIF0 BIT(3) | |
65 | #define DIF1 BIT(4) | |
66 | #define DIF2 BIT(5) | |
67 | #define TDM0 BIT(6) | |
68 | #define TDM1 BIT(7) | |
69 | #define NO_FMT (0xff) | |
70 | #define FMT_MASK (0xf8) | |
71 | ||
72 | /* CTRL2 */ | |
73 | #define DFS_NORMAL_SPEED (0 << 2) | |
74 | #define DFS_DOUBLE_SPEED (1 << 2) | |
75 | #define DFS_QUAD_SPEED (2 << 2) | |
76 | ||
77 | struct ak4613_priv { | |
78 | struct mutex lock; | |
79 | ||
80 | unsigned int fmt; | |
81 | u8 fmt_ctrl; | |
82 | int cnt; | |
83 | }; | |
84 | ||
85 | struct ak4613_formats { | |
86 | unsigned int width; | |
87 | unsigned int fmt; | |
88 | }; | |
89 | ||
90 | struct ak4613_interface { | |
91 | struct ak4613_formats capture; | |
92 | struct ak4613_formats playback; | |
93 | }; | |
94 | ||
e3a4d958 KM |
95 | /* |
96 | * Playback Volume | |
97 | * | |
98 | * max : 0x00 : 0 dB | |
99 | * ( 0.5 dB step ) | |
100 | * min : 0xFE : -127.0 dB | |
101 | * mute: 0xFF | |
102 | */ | |
103 | static const DECLARE_TLV_DB_SCALE(out_tlv, -12750, 50, 1); | |
104 | ||
105 | static const struct snd_kcontrol_new ak4613_snd_controls[] = { | |
106 | SOC_DOUBLE_R_TLV("Digital Playback Volume1", LOUT1, ROUT1, | |
107 | 0, 0xFF, 1, out_tlv), | |
108 | SOC_DOUBLE_R_TLV("Digital Playback Volume2", LOUT2, ROUT2, | |
109 | 0, 0xFF, 1, out_tlv), | |
110 | SOC_DOUBLE_R_TLV("Digital Playback Volume3", LOUT3, ROUT3, | |
111 | 0, 0xFF, 1, out_tlv), | |
112 | SOC_DOUBLE_R_TLV("Digital Playback Volume4", LOUT4, ROUT4, | |
113 | 0, 0xFF, 1, out_tlv), | |
114 | SOC_DOUBLE_R_TLV("Digital Playback Volume5", LOUT5, ROUT5, | |
115 | 0, 0xFF, 1, out_tlv), | |
116 | SOC_DOUBLE_R_TLV("Digital Playback Volume6", LOUT6, ROUT6, | |
117 | 0, 0xFF, 1, out_tlv), | |
118 | }; | |
119 | ||
b0757062 KM |
120 | static const struct reg_default ak4613_reg[] = { |
121 | { 0x0, 0x0f }, { 0x1, 0x07 }, { 0x2, 0x3f }, { 0x3, 0x20 }, | |
122 | { 0x4, 0x20 }, { 0x5, 0x55 }, { 0x6, 0x05 }, { 0x7, 0x07 }, | |
123 | { 0x8, 0x0f }, { 0x9, 0x07 }, { 0xa, 0x3f }, { 0xb, 0x00 }, | |
124 | { 0xc, 0x00 }, { 0xd, 0x00 }, { 0xe, 0x00 }, { 0xf, 0x00 }, | |
125 | { 0x10, 0x00 }, { 0x11, 0x00 }, { 0x12, 0x00 }, { 0x13, 0x00 }, | |
126 | { 0x14, 0x00 }, { 0x15, 0x00 }, { 0x16, 0x00 }, | |
127 | }; | |
128 | ||
129 | #define AUDIO_IFACE_IDX_TO_VAL(i) (i << 3) | |
130 | #define AUDIO_IFACE(b, fmt) { b, SND_SOC_DAIFMT_##fmt } | |
131 | static const struct ak4613_interface ak4613_iface[] = { | |
132 | /* capture */ /* playback */ | |
133 | [0] = { AUDIO_IFACE(24, LEFT_J), AUDIO_IFACE(16, RIGHT_J) }, | |
134 | [1] = { AUDIO_IFACE(24, LEFT_J), AUDIO_IFACE(20, RIGHT_J) }, | |
135 | [2] = { AUDIO_IFACE(24, LEFT_J), AUDIO_IFACE(24, RIGHT_J) }, | |
136 | [3] = { AUDIO_IFACE(24, LEFT_J), AUDIO_IFACE(24, LEFT_J) }, | |
137 | [4] = { AUDIO_IFACE(24, I2S), AUDIO_IFACE(24, I2S) }, | |
138 | }; | |
139 | ||
140 | static const struct regmap_config ak4613_regmap_cfg = { | |
141 | .reg_bits = 8, | |
142 | .val_bits = 8, | |
143 | .max_register = 0x16, | |
144 | .reg_defaults = ak4613_reg, | |
145 | .num_reg_defaults = ARRAY_SIZE(ak4613_reg), | |
146 | }; | |
147 | ||
148 | static const struct of_device_id ak4613_of_match[] = { | |
149 | { .compatible = "asahi-kasei,ak4613", .data = &ak4613_regmap_cfg }, | |
150 | {}, | |
151 | }; | |
152 | MODULE_DEVICE_TABLE(of, ak4613_of_match); | |
153 | ||
154 | static const struct i2c_device_id ak4613_i2c_id[] = { | |
155 | { "ak4613", (kernel_ulong_t)&ak4613_regmap_cfg }, | |
156 | { } | |
157 | }; | |
158 | MODULE_DEVICE_TABLE(i2c, ak4613_i2c_id); | |
159 | ||
160 | static const struct snd_soc_dapm_widget ak4613_dapm_widgets[] = { | |
161 | ||
162 | /* Outputs */ | |
163 | SND_SOC_DAPM_OUTPUT("LOUT1"), | |
164 | SND_SOC_DAPM_OUTPUT("LOUT2"), | |
165 | SND_SOC_DAPM_OUTPUT("LOUT3"), | |
166 | SND_SOC_DAPM_OUTPUT("LOUT4"), | |
167 | SND_SOC_DAPM_OUTPUT("LOUT5"), | |
168 | SND_SOC_DAPM_OUTPUT("LOUT6"), | |
169 | ||
170 | SND_SOC_DAPM_OUTPUT("ROUT1"), | |
171 | SND_SOC_DAPM_OUTPUT("ROUT2"), | |
172 | SND_SOC_DAPM_OUTPUT("ROUT3"), | |
173 | SND_SOC_DAPM_OUTPUT("ROUT4"), | |
174 | SND_SOC_DAPM_OUTPUT("ROUT5"), | |
175 | SND_SOC_DAPM_OUTPUT("ROUT6"), | |
176 | ||
177 | /* Inputs */ | |
178 | SND_SOC_DAPM_INPUT("LIN1"), | |
179 | SND_SOC_DAPM_INPUT("LIN2"), | |
180 | ||
181 | SND_SOC_DAPM_INPUT("RIN1"), | |
182 | SND_SOC_DAPM_INPUT("RIN2"), | |
183 | ||
184 | /* DAC */ | |
185 | SND_SOC_DAPM_DAC("DAC1", NULL, PW_MGMT3, 0, 0), | |
186 | SND_SOC_DAPM_DAC("DAC2", NULL, PW_MGMT3, 1, 0), | |
187 | SND_SOC_DAPM_DAC("DAC3", NULL, PW_MGMT3, 2, 0), | |
188 | SND_SOC_DAPM_DAC("DAC4", NULL, PW_MGMT3, 3, 0), | |
189 | SND_SOC_DAPM_DAC("DAC5", NULL, PW_MGMT3, 4, 0), | |
190 | SND_SOC_DAPM_DAC("DAC6", NULL, PW_MGMT3, 5, 0), | |
191 | ||
192 | /* ADC */ | |
193 | SND_SOC_DAPM_ADC("ADC1", NULL, PW_MGMT2, 0, 0), | |
194 | SND_SOC_DAPM_ADC("ADC2", NULL, PW_MGMT2, 1, 0), | |
195 | }; | |
196 | ||
197 | static const struct snd_soc_dapm_route ak4613_intercon[] = { | |
198 | {"LOUT1", NULL, "DAC1"}, | |
199 | {"LOUT2", NULL, "DAC2"}, | |
200 | {"LOUT3", NULL, "DAC3"}, | |
201 | {"LOUT4", NULL, "DAC4"}, | |
202 | {"LOUT5", NULL, "DAC5"}, | |
203 | {"LOUT6", NULL, "DAC6"}, | |
204 | ||
205 | {"ROUT1", NULL, "DAC1"}, | |
206 | {"ROUT2", NULL, "DAC2"}, | |
207 | {"ROUT3", NULL, "DAC3"}, | |
208 | {"ROUT4", NULL, "DAC4"}, | |
209 | {"ROUT5", NULL, "DAC5"}, | |
210 | {"ROUT6", NULL, "DAC6"}, | |
211 | ||
212 | {"DAC1", NULL, "Playback"}, | |
213 | {"DAC2", NULL, "Playback"}, | |
214 | {"DAC3", NULL, "Playback"}, | |
215 | {"DAC4", NULL, "Playback"}, | |
216 | {"DAC5", NULL, "Playback"}, | |
217 | {"DAC6", NULL, "Playback"}, | |
218 | ||
219 | {"Capture", NULL, "ADC1"}, | |
220 | {"Capture", NULL, "ADC2"}, | |
221 | ||
222 | {"ADC1", NULL, "LIN1"}, | |
223 | {"ADC2", NULL, "LIN2"}, | |
224 | ||
225 | {"ADC1", NULL, "RIN1"}, | |
226 | {"ADC2", NULL, "RIN2"}, | |
227 | }; | |
228 | ||
229 | static void ak4613_dai_shutdown(struct snd_pcm_substream *substream, | |
230 | struct snd_soc_dai *dai) | |
231 | { | |
232 | struct snd_soc_codec *codec = dai->codec; | |
233 | struct ak4613_priv *priv = snd_soc_codec_get_drvdata(codec); | |
234 | struct device *dev = codec->dev; | |
235 | ||
236 | mutex_lock(&priv->lock); | |
237 | priv->cnt--; | |
238 | if (priv->cnt < 0) { | |
239 | dev_err(dev, "unexpected counter error\n"); | |
240 | priv->cnt = 0; | |
241 | } | |
242 | if (!priv->cnt) | |
243 | priv->fmt_ctrl = NO_FMT; | |
244 | mutex_unlock(&priv->lock); | |
245 | } | |
246 | ||
247 | static int ak4613_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) | |
248 | { | |
249 | struct snd_soc_codec *codec = dai->codec; | |
250 | struct ak4613_priv *priv = snd_soc_codec_get_drvdata(codec); | |
251 | ||
252 | fmt &= SND_SOC_DAIFMT_FORMAT_MASK; | |
253 | ||
254 | switch (fmt) { | |
255 | case SND_SOC_DAIFMT_RIGHT_J: | |
256 | case SND_SOC_DAIFMT_LEFT_J: | |
257 | case SND_SOC_DAIFMT_I2S: | |
258 | priv->fmt = fmt; | |
259 | ||
260 | break; | |
261 | default: | |
262 | return -EINVAL; | |
263 | } | |
264 | ||
265 | return 0; | |
266 | } | |
267 | ||
268 | static int ak4613_dai_hw_params(struct snd_pcm_substream *substream, | |
269 | struct snd_pcm_hw_params *params, | |
270 | struct snd_soc_dai *dai) | |
271 | { | |
272 | struct snd_soc_codec *codec = dai->codec; | |
273 | struct ak4613_priv *priv = snd_soc_codec_get_drvdata(codec); | |
274 | const struct ak4613_formats *fmts; | |
275 | struct device *dev = codec->dev; | |
276 | unsigned int width = params_width(params); | |
277 | unsigned int fmt = priv->fmt; | |
278 | unsigned int rate; | |
279 | int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; | |
280 | int i, ret; | |
281 | u8 fmt_ctrl, ctrl2; | |
282 | ||
283 | rate = params_rate(params); | |
284 | switch (rate) { | |
285 | case 32000: | |
286 | case 44100: | |
287 | case 48000: | |
288 | ctrl2 = DFS_NORMAL_SPEED; | |
289 | break; | |
290 | case 88200: | |
291 | case 96000: | |
292 | ctrl2 = DFS_DOUBLE_SPEED; | |
293 | break; | |
294 | case 176400: | |
295 | case 192000: | |
296 | ctrl2 = DFS_QUAD_SPEED; | |
297 | break; | |
298 | default: | |
299 | return -EINVAL; | |
300 | } | |
301 | ||
302 | /* | |
303 | * FIXME | |
304 | * | |
305 | * It doesn't support TDM at this point | |
306 | */ | |
307 | fmt_ctrl = NO_FMT; | |
308 | for (i = 0; i < ARRAY_SIZE(ak4613_iface); i++) { | |
309 | fmts = (is_play) ? &ak4613_iface[i].playback : | |
310 | &ak4613_iface[i].capture; | |
311 | ||
312 | if (fmts->fmt != fmt) | |
313 | continue; | |
314 | ||
315 | if (fmt == SND_SOC_DAIFMT_RIGHT_J) { | |
316 | if (fmts->width != width) | |
317 | continue; | |
318 | } else { | |
319 | if (fmts->width < width) | |
320 | continue; | |
321 | } | |
322 | ||
323 | fmt_ctrl = AUDIO_IFACE_IDX_TO_VAL(i); | |
324 | break; | |
325 | } | |
326 | ||
327 | ret = -EINVAL; | |
328 | if (fmt_ctrl == NO_FMT) | |
329 | goto hw_params_end; | |
330 | ||
331 | mutex_lock(&priv->lock); | |
332 | if ((priv->fmt_ctrl == NO_FMT) || | |
333 | (priv->fmt_ctrl == fmt_ctrl)) { | |
334 | priv->fmt_ctrl = fmt_ctrl; | |
335 | priv->cnt++; | |
336 | ret = 0; | |
337 | } | |
338 | mutex_unlock(&priv->lock); | |
339 | ||
340 | if (ret < 0) | |
341 | goto hw_params_end; | |
342 | ||
343 | snd_soc_update_bits(codec, CTRL1, FMT_MASK, fmt_ctrl); | |
344 | snd_soc_write(codec, CTRL2, ctrl2); | |
345 | ||
346 | hw_params_end: | |
347 | if (ret < 0) | |
348 | dev_warn(dev, "unsupported data width/format combination\n"); | |
349 | ||
350 | return ret; | |
351 | } | |
352 | ||
353 | static int ak4613_set_bias_level(struct snd_soc_codec *codec, | |
354 | enum snd_soc_bias_level level) | |
355 | { | |
356 | u8 mgmt1 = 0; | |
357 | ||
358 | switch (level) { | |
359 | case SND_SOC_BIAS_ON: | |
360 | mgmt1 |= RSTN; | |
361 | /* fall through */ | |
362 | case SND_SOC_BIAS_PREPARE: | |
363 | mgmt1 |= PMADC | PMDAC; | |
364 | /* fall through */ | |
365 | case SND_SOC_BIAS_STANDBY: | |
366 | mgmt1 |= PMVR; | |
367 | /* fall through */ | |
368 | case SND_SOC_BIAS_OFF: | |
369 | default: | |
370 | break; | |
371 | } | |
372 | ||
373 | snd_soc_write(codec, PW_MGMT1, mgmt1); | |
374 | ||
375 | return 0; | |
376 | } | |
377 | ||
378 | static const struct snd_soc_dai_ops ak4613_dai_ops = { | |
379 | .shutdown = ak4613_dai_shutdown, | |
380 | .set_fmt = ak4613_dai_set_fmt, | |
381 | .hw_params = ak4613_dai_hw_params, | |
382 | }; | |
383 | ||
384 | #define AK4613_PCM_RATE (SNDRV_PCM_RATE_32000 |\ | |
385 | SNDRV_PCM_RATE_44100 |\ | |
386 | SNDRV_PCM_RATE_48000 |\ | |
387 | SNDRV_PCM_RATE_64000 |\ | |
388 | SNDRV_PCM_RATE_88200 |\ | |
389 | SNDRV_PCM_RATE_96000 |\ | |
390 | SNDRV_PCM_RATE_176400 |\ | |
391 | SNDRV_PCM_RATE_192000) | |
392 | #define AK4613_PCM_FMTBIT (SNDRV_PCM_FMTBIT_S16_LE |\ | |
393 | SNDRV_PCM_FMTBIT_S24_LE) | |
394 | ||
395 | static struct snd_soc_dai_driver ak4613_dai = { | |
396 | .name = "ak4613-hifi", | |
397 | .playback = { | |
398 | .stream_name = "Playback", | |
399 | .channels_min = 2, | |
400 | .channels_max = 2, | |
401 | .rates = AK4613_PCM_RATE, | |
402 | .formats = AK4613_PCM_FMTBIT, | |
403 | }, | |
404 | .capture = { | |
405 | .stream_name = "Capture", | |
406 | .channels_min = 2, | |
407 | .channels_max = 2, | |
408 | .rates = AK4613_PCM_RATE, | |
409 | .formats = AK4613_PCM_FMTBIT, | |
410 | }, | |
411 | .ops = &ak4613_dai_ops, | |
412 | .symmetric_rates = 1, | |
413 | }; | |
414 | ||
415 | static int ak4613_resume(struct snd_soc_codec *codec) | |
416 | { | |
417 | struct regmap *regmap = dev_get_regmap(codec->dev, NULL); | |
418 | ||
419 | regcache_mark_dirty(regmap); | |
420 | return regcache_sync(regmap); | |
421 | } | |
422 | ||
423 | static struct snd_soc_codec_driver soc_codec_dev_ak4613 = { | |
424 | .resume = ak4613_resume, | |
425 | .set_bias_level = ak4613_set_bias_level, | |
e3a4d958 KM |
426 | .controls = ak4613_snd_controls, |
427 | .num_controls = ARRAY_SIZE(ak4613_snd_controls), | |
b0757062 KM |
428 | .dapm_widgets = ak4613_dapm_widgets, |
429 | .num_dapm_widgets = ARRAY_SIZE(ak4613_dapm_widgets), | |
430 | .dapm_routes = ak4613_intercon, | |
431 | .num_dapm_routes = ARRAY_SIZE(ak4613_intercon), | |
432 | }; | |
433 | ||
434 | static int ak4613_i2c_probe(struct i2c_client *i2c, | |
435 | const struct i2c_device_id *id) | |
436 | { | |
437 | struct device *dev = &i2c->dev; | |
438 | struct device_node *np = dev->of_node; | |
439 | const struct regmap_config *regmap_cfg; | |
440 | struct regmap *regmap; | |
441 | struct ak4613_priv *priv; | |
442 | ||
443 | regmap_cfg = NULL; | |
444 | if (np) { | |
445 | const struct of_device_id *of_id; | |
446 | ||
447 | of_id = of_match_device(ak4613_of_match, dev); | |
448 | if (of_id) | |
449 | regmap_cfg = of_id->data; | |
450 | } else { | |
451 | regmap_cfg = (const struct regmap_config *)id->driver_data; | |
452 | } | |
453 | ||
454 | if (!regmap_cfg) | |
455 | return -EINVAL; | |
456 | ||
457 | priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); | |
458 | if (!priv) | |
459 | return -ENOMEM; | |
460 | ||
461 | priv->fmt_ctrl = NO_FMT; | |
462 | priv->cnt = 0; | |
463 | ||
464 | mutex_init(&priv->lock); | |
465 | ||
466 | i2c_set_clientdata(i2c, priv); | |
467 | ||
468 | regmap = devm_regmap_init_i2c(i2c, regmap_cfg); | |
469 | if (IS_ERR(regmap)) | |
470 | return PTR_ERR(regmap); | |
471 | ||
472 | return snd_soc_register_codec(dev, &soc_codec_dev_ak4613, | |
473 | &ak4613_dai, 1); | |
474 | } | |
475 | ||
476 | static int ak4613_i2c_remove(struct i2c_client *client) | |
477 | { | |
478 | snd_soc_unregister_codec(&client->dev); | |
479 | return 0; | |
480 | } | |
481 | ||
482 | static struct i2c_driver ak4613_i2c_driver = { | |
483 | .driver = { | |
484 | .name = "ak4613-codec", | |
485 | .owner = THIS_MODULE, | |
486 | .of_match_table = ak4613_of_match, | |
487 | }, | |
488 | .probe = ak4613_i2c_probe, | |
489 | .remove = ak4613_i2c_remove, | |
490 | .id_table = ak4613_i2c_id, | |
491 | }; | |
492 | ||
493 | module_i2c_driver(ak4613_i2c_driver); | |
494 | ||
495 | MODULE_DESCRIPTION("Soc AK4613 driver"); | |
496 | MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); | |
497 | MODULE_LICENSE("GPL v2"); |