]>
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 */ | |
b323dd30 | 73 | #define DFS_MASK (3 << 2) |
b0757062 KM |
74 | #define DFS_NORMAL_SPEED (0 << 2) |
75 | #define DFS_DOUBLE_SPEED (1 << 2) | |
76 | #define DFS_QUAD_SPEED (2 << 2) | |
77 | ||
4898b61e KM |
78 | /* ICTRL */ |
79 | #define ICTRL_MASK (0x3) | |
80 | ||
81 | /* OCTRL */ | |
82 | #define OCTRL_MASK (0x3F) | |
83 | ||
b0757062 KM |
84 | struct ak4613_formats { |
85 | unsigned int width; | |
86 | unsigned int fmt; | |
87 | }; | |
88 | ||
89 | struct ak4613_interface { | |
90 | struct ak4613_formats capture; | |
91 | struct ak4613_formats playback; | |
92 | }; | |
93 | ||
35299f17 KM |
94 | struct ak4613_priv { |
95 | struct mutex lock; | |
96 | const struct ak4613_interface *iface; | |
907cd880 KM |
97 | struct snd_pcm_hw_constraint_list constraint; |
98 | unsigned int sysclk; | |
35299f17 KM |
99 | |
100 | unsigned int fmt; | |
101 | u8 oc; | |
102 | u8 ic; | |
103 | int cnt; | |
104 | }; | |
105 | ||
e3a4d958 KM |
106 | /* |
107 | * Playback Volume | |
108 | * | |
109 | * max : 0x00 : 0 dB | |
110 | * ( 0.5 dB step ) | |
111 | * min : 0xFE : -127.0 dB | |
112 | * mute: 0xFF | |
113 | */ | |
114 | static const DECLARE_TLV_DB_SCALE(out_tlv, -12750, 50, 1); | |
115 | ||
116 | static const struct snd_kcontrol_new ak4613_snd_controls[] = { | |
117 | SOC_DOUBLE_R_TLV("Digital Playback Volume1", LOUT1, ROUT1, | |
118 | 0, 0xFF, 1, out_tlv), | |
119 | SOC_DOUBLE_R_TLV("Digital Playback Volume2", LOUT2, ROUT2, | |
120 | 0, 0xFF, 1, out_tlv), | |
121 | SOC_DOUBLE_R_TLV("Digital Playback Volume3", LOUT3, ROUT3, | |
122 | 0, 0xFF, 1, out_tlv), | |
123 | SOC_DOUBLE_R_TLV("Digital Playback Volume4", LOUT4, ROUT4, | |
124 | 0, 0xFF, 1, out_tlv), | |
125 | SOC_DOUBLE_R_TLV("Digital Playback Volume5", LOUT5, ROUT5, | |
126 | 0, 0xFF, 1, out_tlv), | |
127 | SOC_DOUBLE_R_TLV("Digital Playback Volume6", LOUT6, ROUT6, | |
128 | 0, 0xFF, 1, out_tlv), | |
129 | }; | |
130 | ||
b0757062 KM |
131 | static const struct reg_default ak4613_reg[] = { |
132 | { 0x0, 0x0f }, { 0x1, 0x07 }, { 0x2, 0x3f }, { 0x3, 0x20 }, | |
133 | { 0x4, 0x20 }, { 0x5, 0x55 }, { 0x6, 0x05 }, { 0x7, 0x07 }, | |
134 | { 0x8, 0x0f }, { 0x9, 0x07 }, { 0xa, 0x3f }, { 0xb, 0x00 }, | |
135 | { 0xc, 0x00 }, { 0xd, 0x00 }, { 0xe, 0x00 }, { 0xf, 0x00 }, | |
136 | { 0x10, 0x00 }, { 0x11, 0x00 }, { 0x12, 0x00 }, { 0x13, 0x00 }, | |
137 | { 0x14, 0x00 }, { 0x15, 0x00 }, { 0x16, 0x00 }, | |
138 | }; | |
139 | ||
35299f17 | 140 | #define AUDIO_IFACE_TO_VAL(fmts) ((fmts - ak4613_iface) << 3) |
b0757062 KM |
141 | #define AUDIO_IFACE(b, fmt) { b, SND_SOC_DAIFMT_##fmt } |
142 | static const struct ak4613_interface ak4613_iface[] = { | |
143 | /* capture */ /* playback */ | |
ec185f95 | 144 | /* [0] - [2] are not supported */ |
b0757062 KM |
145 | [3] = { AUDIO_IFACE(24, LEFT_J), AUDIO_IFACE(24, LEFT_J) }, |
146 | [4] = { AUDIO_IFACE(24, I2S), AUDIO_IFACE(24, I2S) }, | |
147 | }; | |
148 | ||
149 | static const struct regmap_config ak4613_regmap_cfg = { | |
150 | .reg_bits = 8, | |
151 | .val_bits = 8, | |
152 | .max_register = 0x16, | |
153 | .reg_defaults = ak4613_reg, | |
154 | .num_reg_defaults = ARRAY_SIZE(ak4613_reg), | |
dcd2d1f7 | 155 | .cache_type = REGCACHE_RBTREE, |
b0757062 KM |
156 | }; |
157 | ||
158 | static const struct of_device_id ak4613_of_match[] = { | |
159 | { .compatible = "asahi-kasei,ak4613", .data = &ak4613_regmap_cfg }, | |
160 | {}, | |
161 | }; | |
162 | MODULE_DEVICE_TABLE(of, ak4613_of_match); | |
163 | ||
164 | static const struct i2c_device_id ak4613_i2c_id[] = { | |
165 | { "ak4613", (kernel_ulong_t)&ak4613_regmap_cfg }, | |
166 | { } | |
167 | }; | |
168 | MODULE_DEVICE_TABLE(i2c, ak4613_i2c_id); | |
169 | ||
170 | static const struct snd_soc_dapm_widget ak4613_dapm_widgets[] = { | |
171 | ||
172 | /* Outputs */ | |
173 | SND_SOC_DAPM_OUTPUT("LOUT1"), | |
174 | SND_SOC_DAPM_OUTPUT("LOUT2"), | |
175 | SND_SOC_DAPM_OUTPUT("LOUT3"), | |
176 | SND_SOC_DAPM_OUTPUT("LOUT4"), | |
177 | SND_SOC_DAPM_OUTPUT("LOUT5"), | |
178 | SND_SOC_DAPM_OUTPUT("LOUT6"), | |
179 | ||
180 | SND_SOC_DAPM_OUTPUT("ROUT1"), | |
181 | SND_SOC_DAPM_OUTPUT("ROUT2"), | |
182 | SND_SOC_DAPM_OUTPUT("ROUT3"), | |
183 | SND_SOC_DAPM_OUTPUT("ROUT4"), | |
184 | SND_SOC_DAPM_OUTPUT("ROUT5"), | |
185 | SND_SOC_DAPM_OUTPUT("ROUT6"), | |
186 | ||
187 | /* Inputs */ | |
188 | SND_SOC_DAPM_INPUT("LIN1"), | |
189 | SND_SOC_DAPM_INPUT("LIN2"), | |
190 | ||
191 | SND_SOC_DAPM_INPUT("RIN1"), | |
192 | SND_SOC_DAPM_INPUT("RIN2"), | |
193 | ||
194 | /* DAC */ | |
195 | SND_SOC_DAPM_DAC("DAC1", NULL, PW_MGMT3, 0, 0), | |
196 | SND_SOC_DAPM_DAC("DAC2", NULL, PW_MGMT3, 1, 0), | |
197 | SND_SOC_DAPM_DAC("DAC3", NULL, PW_MGMT3, 2, 0), | |
198 | SND_SOC_DAPM_DAC("DAC4", NULL, PW_MGMT3, 3, 0), | |
199 | SND_SOC_DAPM_DAC("DAC5", NULL, PW_MGMT3, 4, 0), | |
200 | SND_SOC_DAPM_DAC("DAC6", NULL, PW_MGMT3, 5, 0), | |
201 | ||
202 | /* ADC */ | |
203 | SND_SOC_DAPM_ADC("ADC1", NULL, PW_MGMT2, 0, 0), | |
204 | SND_SOC_DAPM_ADC("ADC2", NULL, PW_MGMT2, 1, 0), | |
205 | }; | |
206 | ||
207 | static const struct snd_soc_dapm_route ak4613_intercon[] = { | |
208 | {"LOUT1", NULL, "DAC1"}, | |
209 | {"LOUT2", NULL, "DAC2"}, | |
210 | {"LOUT3", NULL, "DAC3"}, | |
211 | {"LOUT4", NULL, "DAC4"}, | |
212 | {"LOUT5", NULL, "DAC5"}, | |
213 | {"LOUT6", NULL, "DAC6"}, | |
214 | ||
215 | {"ROUT1", NULL, "DAC1"}, | |
216 | {"ROUT2", NULL, "DAC2"}, | |
217 | {"ROUT3", NULL, "DAC3"}, | |
218 | {"ROUT4", NULL, "DAC4"}, | |
219 | {"ROUT5", NULL, "DAC5"}, | |
220 | {"ROUT6", NULL, "DAC6"}, | |
221 | ||
222 | {"DAC1", NULL, "Playback"}, | |
223 | {"DAC2", NULL, "Playback"}, | |
224 | {"DAC3", NULL, "Playback"}, | |
225 | {"DAC4", NULL, "Playback"}, | |
226 | {"DAC5", NULL, "Playback"}, | |
227 | {"DAC6", NULL, "Playback"}, | |
228 | ||
229 | {"Capture", NULL, "ADC1"}, | |
230 | {"Capture", NULL, "ADC2"}, | |
231 | ||
232 | {"ADC1", NULL, "LIN1"}, | |
233 | {"ADC2", NULL, "LIN2"}, | |
234 | ||
235 | {"ADC1", NULL, "RIN1"}, | |
236 | {"ADC2", NULL, "RIN2"}, | |
237 | }; | |
238 | ||
239 | static void ak4613_dai_shutdown(struct snd_pcm_substream *substream, | |
240 | struct snd_soc_dai *dai) | |
241 | { | |
242 | struct snd_soc_codec *codec = dai->codec; | |
243 | struct ak4613_priv *priv = snd_soc_codec_get_drvdata(codec); | |
244 | struct device *dev = codec->dev; | |
245 | ||
246 | mutex_lock(&priv->lock); | |
247 | priv->cnt--; | |
248 | if (priv->cnt < 0) { | |
249 | dev_err(dev, "unexpected counter error\n"); | |
250 | priv->cnt = 0; | |
251 | } | |
252 | if (!priv->cnt) | |
35299f17 | 253 | priv->iface = NULL; |
b0757062 KM |
254 | mutex_unlock(&priv->lock); |
255 | } | |
256 | ||
907cd880 KM |
257 | static void ak4613_hw_constraints(struct ak4613_priv *priv, |
258 | struct snd_pcm_runtime *runtime) | |
259 | { | |
260 | static const unsigned int ak4613_rates[] = { | |
261 | 32000, | |
262 | 44100, | |
263 | 48000, | |
264 | 64000, | |
265 | 88200, | |
266 | 96000, | |
267 | 176400, | |
268 | 192000, | |
269 | }; | |
270 | struct snd_pcm_hw_constraint_list *constraint = &priv->constraint; | |
271 | unsigned int fs; | |
272 | int i; | |
273 | ||
274 | constraint->list = ak4613_rates; | |
275 | constraint->mask = 0; | |
276 | constraint->count = 0; | |
277 | ||
278 | /* | |
279 | * Slave Mode | |
280 | * Normal: [32kHz, 48kHz] : 256fs,384fs or 512fs | |
281 | * Double: [64kHz, 96kHz] : 256fs | |
282 | * Quad : [128kHz,192kHz]: 128fs | |
283 | * | |
284 | * Master mode | |
285 | * Normal: [32kHz, 48kHz] : 256fs or 512fs | |
286 | * Double: [64kHz, 96kHz] : 256fs | |
287 | * Quad : [128kHz,192kHz]: 128fs | |
288 | */ | |
289 | for (i = 0; i < ARRAY_SIZE(ak4613_rates); i++) { | |
290 | /* minimum fs on each range */ | |
291 | fs = (ak4613_rates[i] <= 96000) ? 256 : 128; | |
292 | ||
293 | if (priv->sysclk >= ak4613_rates[i] * fs) | |
294 | constraint->count = i + 1; | |
295 | } | |
296 | ||
297 | snd_pcm_hw_constraint_list(runtime, 0, | |
298 | SNDRV_PCM_HW_PARAM_RATE, constraint); | |
299 | } | |
300 | ||
41165298 RK |
301 | static int ak4613_dai_startup(struct snd_pcm_substream *substream, |
302 | struct snd_soc_dai *dai) | |
303 | { | |
304 | struct snd_soc_codec *codec = dai->codec; | |
305 | struct ak4613_priv *priv = snd_soc_codec_get_drvdata(codec); | |
306 | ||
307 | priv->cnt++; | |
308 | ||
907cd880 KM |
309 | ak4613_hw_constraints(priv, substream->runtime); |
310 | ||
311 | return 0; | |
312 | } | |
313 | ||
314 | static int ak4613_dai_set_sysclk(struct snd_soc_dai *codec_dai, | |
315 | int clk_id, unsigned int freq, int dir) | |
316 | { | |
317 | struct snd_soc_codec *codec = codec_dai->codec; | |
318 | struct ak4613_priv *priv = snd_soc_codec_get_drvdata(codec); | |
319 | ||
320 | priv->sysclk = freq; | |
321 | ||
41165298 RK |
322 | return 0; |
323 | } | |
324 | ||
b0757062 KM |
325 | static int ak4613_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) |
326 | { | |
327 | struct snd_soc_codec *codec = dai->codec; | |
328 | struct ak4613_priv *priv = snd_soc_codec_get_drvdata(codec); | |
329 | ||
330 | fmt &= SND_SOC_DAIFMT_FORMAT_MASK; | |
331 | ||
332 | switch (fmt) { | |
b0757062 KM |
333 | case SND_SOC_DAIFMT_LEFT_J: |
334 | case SND_SOC_DAIFMT_I2S: | |
335 | priv->fmt = fmt; | |
b0757062 KM |
336 | break; |
337 | default: | |
338 | return -EINVAL; | |
339 | } | |
340 | ||
341 | return 0; | |
342 | } | |
343 | ||
35299f17 KM |
344 | static bool ak4613_dai_fmt_matching(const struct ak4613_interface *iface, |
345 | int is_play, | |
346 | unsigned int fmt, unsigned int width) | |
347 | { | |
348 | const struct ak4613_formats *fmts; | |
349 | ||
350 | fmts = (is_play) ? &iface->playback : &iface->capture; | |
351 | ||
352 | if (fmts->fmt != fmt) | |
353 | return false; | |
354 | ||
ec185f95 KM |
355 | if (fmts->width != width) |
356 | return false; | |
35299f17 KM |
357 | |
358 | return true; | |
359 | } | |
360 | ||
b0757062 KM |
361 | static int ak4613_dai_hw_params(struct snd_pcm_substream *substream, |
362 | struct snd_pcm_hw_params *params, | |
363 | struct snd_soc_dai *dai) | |
364 | { | |
365 | struct snd_soc_codec *codec = dai->codec; | |
366 | struct ak4613_priv *priv = snd_soc_codec_get_drvdata(codec); | |
35299f17 | 367 | const struct ak4613_interface *iface; |
b0757062 KM |
368 | struct device *dev = codec->dev; |
369 | unsigned int width = params_width(params); | |
370 | unsigned int fmt = priv->fmt; | |
371 | unsigned int rate; | |
372 | int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; | |
373 | int i, ret; | |
374 | u8 fmt_ctrl, ctrl2; | |
375 | ||
376 | rate = params_rate(params); | |
377 | switch (rate) { | |
378 | case 32000: | |
379 | case 44100: | |
380 | case 48000: | |
381 | ctrl2 = DFS_NORMAL_SPEED; | |
382 | break; | |
a83ac486 | 383 | case 64000: |
b0757062 KM |
384 | case 88200: |
385 | case 96000: | |
386 | ctrl2 = DFS_DOUBLE_SPEED; | |
387 | break; | |
388 | case 176400: | |
389 | case 192000: | |
390 | ctrl2 = DFS_QUAD_SPEED; | |
391 | break; | |
392 | default: | |
393 | return -EINVAL; | |
394 | } | |
395 | ||
396 | /* | |
397 | * FIXME | |
398 | * | |
399 | * It doesn't support TDM at this point | |
400 | */ | |
401 | fmt_ctrl = NO_FMT; | |
35299f17 KM |
402 | ret = -EINVAL; |
403 | iface = NULL; | |
b0757062 | 404 | |
35299f17 KM |
405 | mutex_lock(&priv->lock); |
406 | if (priv->iface) { | |
407 | if (ak4613_dai_fmt_matching(priv->iface, is_play, fmt, width)) | |
408 | iface = priv->iface; | |
409 | } else { | |
b5f2a487 | 410 | for (i = ARRAY_SIZE(ak4613_iface) - 1; i >= 0; i--) { |
35299f17 KM |
411 | if (!ak4613_dai_fmt_matching(ak4613_iface + i, |
412 | is_play, | |
413 | fmt, width)) | |
b0757062 | 414 | continue; |
35299f17 KM |
415 | iface = ak4613_iface + i; |
416 | break; | |
b0757062 | 417 | } |
b0757062 KM |
418 | } |
419 | ||
35299f17 KM |
420 | if ((priv->iface == NULL) || |
421 | (priv->iface == iface)) { | |
422 | priv->iface = iface; | |
b0757062 KM |
423 | ret = 0; |
424 | } | |
425 | mutex_unlock(&priv->lock); | |
426 | ||
427 | if (ret < 0) | |
428 | goto hw_params_end; | |
429 | ||
35299f17 KM |
430 | fmt_ctrl = AUDIO_IFACE_TO_VAL(iface); |
431 | ||
b0757062 | 432 | snd_soc_update_bits(codec, CTRL1, FMT_MASK, fmt_ctrl); |
b323dd30 | 433 | snd_soc_update_bits(codec, CTRL2, DFS_MASK, ctrl2); |
b0757062 | 434 | |
4898b61e KM |
435 | snd_soc_update_bits(codec, ICTRL, ICTRL_MASK, priv->ic); |
436 | snd_soc_update_bits(codec, OCTRL, OCTRL_MASK, priv->oc); | |
a3af0c65 | 437 | |
b0757062 KM |
438 | hw_params_end: |
439 | if (ret < 0) | |
440 | dev_warn(dev, "unsupported data width/format combination\n"); | |
441 | ||
442 | return ret; | |
443 | } | |
444 | ||
445 | static int ak4613_set_bias_level(struct snd_soc_codec *codec, | |
446 | enum snd_soc_bias_level level) | |
447 | { | |
448 | u8 mgmt1 = 0; | |
449 | ||
450 | switch (level) { | |
451 | case SND_SOC_BIAS_ON: | |
452 | mgmt1 |= RSTN; | |
453 | /* fall through */ | |
454 | case SND_SOC_BIAS_PREPARE: | |
455 | mgmt1 |= PMADC | PMDAC; | |
456 | /* fall through */ | |
457 | case SND_SOC_BIAS_STANDBY: | |
458 | mgmt1 |= PMVR; | |
459 | /* fall through */ | |
460 | case SND_SOC_BIAS_OFF: | |
461 | default: | |
462 | break; | |
463 | } | |
464 | ||
465 | snd_soc_write(codec, PW_MGMT1, mgmt1); | |
466 | ||
467 | return 0; | |
468 | } | |
469 | ||
470 | static const struct snd_soc_dai_ops ak4613_dai_ops = { | |
41165298 | 471 | .startup = ak4613_dai_startup, |
b0757062 | 472 | .shutdown = ak4613_dai_shutdown, |
907cd880 | 473 | .set_sysclk = ak4613_dai_set_sysclk, |
b0757062 KM |
474 | .set_fmt = ak4613_dai_set_fmt, |
475 | .hw_params = ak4613_dai_hw_params, | |
476 | }; | |
477 | ||
478 | #define AK4613_PCM_RATE (SNDRV_PCM_RATE_32000 |\ | |
479 | SNDRV_PCM_RATE_44100 |\ | |
480 | SNDRV_PCM_RATE_48000 |\ | |
481 | SNDRV_PCM_RATE_64000 |\ | |
482 | SNDRV_PCM_RATE_88200 |\ | |
483 | SNDRV_PCM_RATE_96000 |\ | |
484 | SNDRV_PCM_RATE_176400 |\ | |
485 | SNDRV_PCM_RATE_192000) | |
ec185f95 | 486 | #define AK4613_PCM_FMTBIT (SNDRV_PCM_FMTBIT_S24_LE) |
b0757062 KM |
487 | |
488 | static struct snd_soc_dai_driver ak4613_dai = { | |
489 | .name = "ak4613-hifi", | |
490 | .playback = { | |
491 | .stream_name = "Playback", | |
492 | .channels_min = 2, | |
493 | .channels_max = 2, | |
494 | .rates = AK4613_PCM_RATE, | |
495 | .formats = AK4613_PCM_FMTBIT, | |
496 | }, | |
497 | .capture = { | |
498 | .stream_name = "Capture", | |
499 | .channels_min = 2, | |
500 | .channels_max = 2, | |
501 | .rates = AK4613_PCM_RATE, | |
502 | .formats = AK4613_PCM_FMTBIT, | |
503 | }, | |
504 | .ops = &ak4613_dai_ops, | |
505 | .symmetric_rates = 1, | |
506 | }; | |
507 | ||
f9ae17ba | 508 | static int ak4613_suspend(struct snd_soc_codec *codec) |
b0757062 KM |
509 | { |
510 | struct regmap *regmap = dev_get_regmap(codec->dev, NULL); | |
511 | ||
f9ae17ba | 512 | regcache_cache_only(regmap, true); |
b0757062 | 513 | regcache_mark_dirty(regmap); |
f9ae17ba GU |
514 | return 0; |
515 | } | |
516 | ||
517 | static int ak4613_resume(struct snd_soc_codec *codec) | |
518 | { | |
519 | struct regmap *regmap = dev_get_regmap(codec->dev, NULL); | |
520 | ||
521 | regcache_cache_only(regmap, false); | |
b0757062 KM |
522 | return regcache_sync(regmap); |
523 | } | |
524 | ||
a180ba45 | 525 | static const struct snd_soc_codec_driver soc_codec_dev_ak4613 = { |
f9ae17ba | 526 | .suspend = ak4613_suspend, |
b0757062 KM |
527 | .resume = ak4613_resume, |
528 | .set_bias_level = ak4613_set_bias_level, | |
beb84f75 KM |
529 | .component_driver = { |
530 | .controls = ak4613_snd_controls, | |
531 | .num_controls = ARRAY_SIZE(ak4613_snd_controls), | |
532 | .dapm_widgets = ak4613_dapm_widgets, | |
533 | .num_dapm_widgets = ARRAY_SIZE(ak4613_dapm_widgets), | |
534 | .dapm_routes = ak4613_intercon, | |
535 | .num_dapm_routes = ARRAY_SIZE(ak4613_intercon), | |
536 | }, | |
b0757062 KM |
537 | }; |
538 | ||
a3af0c65 KM |
539 | static void ak4613_parse_of(struct ak4613_priv *priv, |
540 | struct device *dev) | |
541 | { | |
542 | struct device_node *np = dev->of_node; | |
543 | char prop[32]; | |
544 | int i; | |
545 | ||
546 | /* Input 1 - 2 */ | |
547 | for (i = 0; i < 2; i++) { | |
5547ba61 | 548 | snprintf(prop, sizeof(prop), "asahi-kasei,in%d-single-end", i + 1); |
a3af0c65 KM |
549 | if (!of_get_property(np, prop, NULL)) |
550 | priv->ic |= 1 << i; | |
551 | } | |
552 | ||
553 | /* Output 1 - 6 */ | |
554 | for (i = 0; i < 6; i++) { | |
5547ba61 | 555 | snprintf(prop, sizeof(prop), "asahi-kasei,out%d-single-end", i + 1); |
a3af0c65 KM |
556 | if (!of_get_property(np, prop, NULL)) |
557 | priv->oc |= 1 << i; | |
558 | } | |
559 | } | |
560 | ||
b0757062 KM |
561 | static int ak4613_i2c_probe(struct i2c_client *i2c, |
562 | const struct i2c_device_id *id) | |
563 | { | |
564 | struct device *dev = &i2c->dev; | |
565 | struct device_node *np = dev->of_node; | |
566 | const struct regmap_config *regmap_cfg; | |
567 | struct regmap *regmap; | |
568 | struct ak4613_priv *priv; | |
569 | ||
570 | regmap_cfg = NULL; | |
571 | if (np) { | |
572 | const struct of_device_id *of_id; | |
573 | ||
574 | of_id = of_match_device(ak4613_of_match, dev); | |
575 | if (of_id) | |
576 | regmap_cfg = of_id->data; | |
577 | } else { | |
578 | regmap_cfg = (const struct regmap_config *)id->driver_data; | |
579 | } | |
580 | ||
581 | if (!regmap_cfg) | |
582 | return -EINVAL; | |
583 | ||
584 | priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); | |
585 | if (!priv) | |
586 | return -ENOMEM; | |
587 | ||
a3af0c65 KM |
588 | ak4613_parse_of(priv, dev); |
589 | ||
35299f17 | 590 | priv->iface = NULL; |
b0757062 | 591 | priv->cnt = 0; |
907cd880 | 592 | priv->sysclk = 0; |
b0757062 KM |
593 | |
594 | mutex_init(&priv->lock); | |
595 | ||
596 | i2c_set_clientdata(i2c, priv); | |
597 | ||
598 | regmap = devm_regmap_init_i2c(i2c, regmap_cfg); | |
599 | if (IS_ERR(regmap)) | |
600 | return PTR_ERR(regmap); | |
601 | ||
602 | return snd_soc_register_codec(dev, &soc_codec_dev_ak4613, | |
603 | &ak4613_dai, 1); | |
604 | } | |
605 | ||
606 | static int ak4613_i2c_remove(struct i2c_client *client) | |
607 | { | |
608 | snd_soc_unregister_codec(&client->dev); | |
609 | return 0; | |
610 | } | |
611 | ||
612 | static struct i2c_driver ak4613_i2c_driver = { | |
613 | .driver = { | |
614 | .name = "ak4613-codec", | |
b0757062 KM |
615 | .of_match_table = ak4613_of_match, |
616 | }, | |
617 | .probe = ak4613_i2c_probe, | |
618 | .remove = ak4613_i2c_remove, | |
619 | .id_table = ak4613_i2c_id, | |
620 | }; | |
621 | ||
622 | module_i2c_driver(ak4613_i2c_driver); | |
623 | ||
624 | MODULE_DESCRIPTION("Soc AK4613 driver"); | |
625 | MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); | |
626 | MODULE_LICENSE("GPL v2"); |