]>
Commit | Line | Data |
---|---|---|
aa431124 PR |
1 | /* |
2 | * TSE-850 audio - ASoC driver for the Axentia TSE-850 with a PCM5142 codec | |
3 | * | |
4 | * Copyright (C) 2016 Axentia Technologies AB | |
5 | * | |
6 | * Author: Peter Rosin <peda@axentia.se> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | */ | |
12 | ||
13 | /* | |
14 | * loop1 relays | |
15 | * IN1 +---o +------------+ o---+ OUT1 | |
16 | * \ / | |
17 | * + + | |
18 | * | / | | |
19 | * +--o +--. | | |
20 | * | add | | | |
21 | * | V | | |
22 | * | .---. | | |
23 | * DAC +----------->|Sum|---+ | |
24 | * | '---' | | |
25 | * | | | |
26 | * + + | |
27 | * | |
28 | * IN2 +---o--+------------+--o---+ OUT2 | |
29 | * loop2 relays | |
30 | * | |
31 | * The 'loop1' gpio pin controlls two relays, which are either in loop | |
32 | * position, meaning that input and output are directly connected, or | |
33 | * they are in mixer position, meaning that the signal is passed through | |
34 | * the 'Sum' mixer. Similarly for 'loop2'. | |
35 | * | |
36 | * In the above, the 'loop1' relays are inactive, thus feeding IN1 to the | |
37 | * mixer (if 'add' is active) and feeding the mixer output to OUT1. The | |
38 | * 'loop2' relays are active, short-cutting the TSE-850 from channel 2. | |
39 | * IN1, IN2, OUT1 and OUT2 are TSE-850 connectors and DAC is the PCB name | |
40 | * of the (filtered) output from the PCM5142 codec. | |
41 | */ | |
42 | ||
43 | #include <linux/clk.h> | |
44 | #include <linux/gpio.h> | |
45 | #include <linux/module.h> | |
46 | #include <linux/of.h> | |
47 | #include <linux/of_device.h> | |
48 | #include <linux/of_gpio.h> | |
49 | #include <linux/regulator/consumer.h> | |
50 | ||
51 | #include <sound/soc.h> | |
52 | #include <sound/pcm_params.h> | |
53 | ||
aa431124 | 54 | struct tse850_priv { |
aa431124 PR |
55 | struct gpio_desc *add; |
56 | struct gpio_desc *loop1; | |
57 | struct gpio_desc *loop2; | |
58 | ||
59 | struct regulator *ana; | |
60 | ||
61 | int add_cache; | |
62 | int loop1_cache; | |
63 | int loop2_cache; | |
64 | }; | |
65 | ||
66 | static int tse850_get_mux1(struct snd_kcontrol *kctrl, | |
67 | struct snd_ctl_elem_value *ucontrol) | |
68 | { | |
69 | struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl); | |
70 | struct snd_soc_card *card = dapm->card; | |
71 | struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card); | |
72 | ||
73 | ucontrol->value.enumerated.item[0] = tse850->loop1_cache; | |
74 | ||
75 | return 0; | |
76 | } | |
77 | ||
78 | static int tse850_put_mux1(struct snd_kcontrol *kctrl, | |
79 | struct snd_ctl_elem_value *ucontrol) | |
80 | { | |
81 | struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl); | |
82 | struct snd_soc_card *card = dapm->card; | |
83 | struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card); | |
84 | struct soc_enum *e = (struct soc_enum *)kctrl->private_value; | |
85 | unsigned int val = ucontrol->value.enumerated.item[0]; | |
86 | ||
87 | if (val >= e->items) | |
88 | return -EINVAL; | |
89 | ||
90 | gpiod_set_value_cansleep(tse850->loop1, val); | |
91 | tse850->loop1_cache = val; | |
92 | ||
93 | return snd_soc_dapm_put_enum_double(kctrl, ucontrol); | |
94 | } | |
95 | ||
96 | static int tse850_get_mux2(struct snd_kcontrol *kctrl, | |
97 | struct snd_ctl_elem_value *ucontrol) | |
98 | { | |
99 | struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl); | |
100 | struct snd_soc_card *card = dapm->card; | |
101 | struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card); | |
102 | ||
103 | ucontrol->value.enumerated.item[0] = tse850->loop2_cache; | |
104 | ||
105 | return 0; | |
106 | } | |
107 | ||
108 | static int tse850_put_mux2(struct snd_kcontrol *kctrl, | |
109 | struct snd_ctl_elem_value *ucontrol) | |
110 | { | |
111 | struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl); | |
112 | struct snd_soc_card *card = dapm->card; | |
113 | struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card); | |
114 | struct soc_enum *e = (struct soc_enum *)kctrl->private_value; | |
115 | unsigned int val = ucontrol->value.enumerated.item[0]; | |
116 | ||
117 | if (val >= e->items) | |
118 | return -EINVAL; | |
119 | ||
120 | gpiod_set_value_cansleep(tse850->loop2, val); | |
121 | tse850->loop2_cache = val; | |
122 | ||
123 | return snd_soc_dapm_put_enum_double(kctrl, ucontrol); | |
124 | } | |
125 | ||
126 | int tse850_get_mix(struct snd_kcontrol *kctrl, | |
127 | struct snd_ctl_elem_value *ucontrol) | |
128 | { | |
129 | struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl); | |
130 | struct snd_soc_card *card = dapm->card; | |
131 | struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card); | |
132 | ||
133 | ucontrol->value.enumerated.item[0] = tse850->add_cache; | |
134 | ||
135 | return 0; | |
136 | } | |
137 | ||
138 | int tse850_put_mix(struct snd_kcontrol *kctrl, | |
139 | struct snd_ctl_elem_value *ucontrol) | |
140 | { | |
141 | struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl); | |
142 | struct snd_soc_card *card = dapm->card; | |
143 | struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card); | |
144 | int connect = !!ucontrol->value.integer.value[0]; | |
145 | ||
146 | if (tse850->add_cache == connect) | |
147 | return 0; | |
148 | ||
149 | /* | |
150 | * Hmmm, this gpiod_set_value_cansleep call should probably happen | |
151 | * inside snd_soc_dapm_mixer_update_power in the loop. | |
152 | */ | |
153 | gpiod_set_value_cansleep(tse850->add, connect); | |
154 | tse850->add_cache = connect; | |
155 | ||
156 | snd_soc_dapm_mixer_update_power(dapm, kctrl, connect, NULL); | |
157 | return 1; | |
158 | } | |
159 | ||
160 | int tse850_get_ana(struct snd_kcontrol *kctrl, | |
161 | struct snd_ctl_elem_value *ucontrol) | |
162 | { | |
163 | struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl); | |
164 | struct snd_soc_card *card = dapm->card; | |
165 | struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card); | |
166 | int ret; | |
167 | ||
168 | ret = regulator_get_voltage(tse850->ana); | |
169 | if (ret < 0) | |
170 | return ret; | |
171 | ||
172 | /* | |
173 | * Map regulator output values like so: | |
174 | * -11.5V to "Low" (enum 0) | |
175 | * 11.5V-12.5V to "12V" (enum 1) | |
176 | * 12.5V-13.5V to "13V" (enum 2) | |
177 | * ... | |
178 | * 18.5V-19.5V to "19V" (enum 8) | |
179 | * 19.5V- to "20V" (enum 9) | |
180 | */ | |
181 | if (ret < 11000000) | |
182 | ret = 11000000; | |
183 | else if (ret > 20000000) | |
184 | ret = 20000000; | |
185 | ret -= 11000000; | |
186 | ret = (ret + 500000) / 1000000; | |
187 | ||
188 | ucontrol->value.enumerated.item[0] = ret; | |
189 | ||
190 | return 0; | |
191 | } | |
192 | ||
193 | int tse850_put_ana(struct snd_kcontrol *kctrl, | |
194 | struct snd_ctl_elem_value *ucontrol) | |
195 | { | |
196 | struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl); | |
197 | struct snd_soc_card *card = dapm->card; | |
198 | struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card); | |
199 | struct soc_enum *e = (struct soc_enum *)kctrl->private_value; | |
200 | unsigned int uV = ucontrol->value.enumerated.item[0]; | |
201 | int ret; | |
202 | ||
203 | if (uV >= e->items) | |
204 | return -EINVAL; | |
205 | ||
206 | /* | |
207 | * Map enum zero (Low) to 2 volts on the regulator, do this since | |
208 | * the ana regulator is supplied by the system 12V voltage and | |
209 | * requesting anything below the system voltage causes the system | |
210 | * voltage to be passed through the regulator. Also, the ana | |
211 | * regulator induces noise when requesting voltages near the | |
212 | * system voltage. So, by mapping Low to 2V, that noise is | |
213 | * eliminated when all that is needed is 12V (the system voltage). | |
214 | */ | |
215 | if (uV) | |
216 | uV = 11000000 + (1000000 * uV); | |
217 | else | |
218 | uV = 2000000; | |
219 | ||
220 | ret = regulator_set_voltage(tse850->ana, uV, uV); | |
221 | if (ret < 0) | |
222 | return ret; | |
223 | ||
224 | return snd_soc_dapm_put_enum_double(kctrl, ucontrol); | |
225 | } | |
226 | ||
227 | static const char * const mux_text[] = { "Mixer", "Loop" }; | |
228 | ||
229 | static const struct soc_enum mux_enum = | |
a00cebf5 | 230 | SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, ARRAY_SIZE(mux_text), mux_text); |
aa431124 PR |
231 | |
232 | static const struct snd_kcontrol_new mux1 = | |
233 | SOC_DAPM_ENUM_EXT("MUX1", mux_enum, tse850_get_mux1, tse850_put_mux1); | |
234 | ||
235 | static const struct snd_kcontrol_new mux2 = | |
236 | SOC_DAPM_ENUM_EXT("MUX2", mux_enum, tse850_get_mux2, tse850_put_mux2); | |
237 | ||
238 | #define TSE850_DAPM_SINGLE_EXT(xname, reg, shift, max, invert, xget, xput) \ | |
239 | { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \ | |
240 | .info = snd_soc_info_volsw, \ | |
241 | .get = xget, \ | |
242 | .put = xput, \ | |
243 | .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) } | |
244 | ||
245 | static const struct snd_kcontrol_new mix[] = { | |
246 | TSE850_DAPM_SINGLE_EXT("IN Switch", SND_SOC_NOPM, 0, 1, 0, | |
247 | tse850_get_mix, tse850_put_mix), | |
248 | }; | |
249 | ||
250 | static const char * const ana_text[] = { | |
251 | "Low", "12V", "13V", "14V", "15V", "16V", "17V", "18V", "19V", "20V" | |
252 | }; | |
253 | ||
254 | static const struct soc_enum ana_enum = | |
a00cebf5 | 255 | SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, ARRAY_SIZE(ana_text), ana_text); |
aa431124 PR |
256 | |
257 | static const struct snd_kcontrol_new out = | |
258 | SOC_DAPM_ENUM_EXT("ANA", ana_enum, tse850_get_ana, tse850_put_ana); | |
259 | ||
260 | static const struct snd_soc_dapm_widget tse850_dapm_widgets[] = { | |
261 | SND_SOC_DAPM_LINE("OUT1", NULL), | |
262 | SND_SOC_DAPM_LINE("OUT2", NULL), | |
263 | SND_SOC_DAPM_LINE("IN1", NULL), | |
264 | SND_SOC_DAPM_LINE("IN2", NULL), | |
265 | SND_SOC_DAPM_INPUT("DAC"), | |
266 | SND_SOC_DAPM_AIF_IN("AIFINL", "Playback", 0, SND_SOC_NOPM, 0, 0), | |
267 | SND_SOC_DAPM_AIF_IN("AIFINR", "Playback", 1, SND_SOC_NOPM, 0, 0), | |
268 | SOC_MIXER_ARRAY("MIX", SND_SOC_NOPM, 0, 0, mix), | |
269 | SND_SOC_DAPM_MUX("MUX1", SND_SOC_NOPM, 0, 0, &mux1), | |
270 | SND_SOC_DAPM_MUX("MUX2", SND_SOC_NOPM, 0, 0, &mux2), | |
271 | SND_SOC_DAPM_OUT_DRV("OUT", SND_SOC_NOPM, 0, 0, &out, 1), | |
272 | }; | |
273 | ||
274 | /* | |
275 | * These connections are not entirely correct, since both IN1 and IN2 | |
276 | * are always fed to MIX (if the "IN switch" is set so), i.e. without | |
277 | * regard to the loop1 and loop2 relays that according to this only | |
278 | * control MUX1 and MUX2 but in fact also control how the input signals | |
279 | * are routed. | |
280 | * But, 1) I don't know how to do it right, and 2) it doesn't seem to | |
281 | * matter in practice since nothing is powered in those sections anyway. | |
282 | */ | |
283 | static const struct snd_soc_dapm_route tse850_intercon[] = { | |
284 | { "OUT1", NULL, "MUX1" }, | |
285 | { "OUT2", NULL, "MUX2" }, | |
286 | ||
287 | { "MUX1", "Loop", "IN1" }, | |
288 | { "MUX1", "Mixer", "OUT" }, | |
289 | ||
290 | { "MUX2", "Loop", "IN2" }, | |
291 | { "MUX2", "Mixer", "OUT" }, | |
292 | ||
293 | { "OUT", NULL, "MIX" }, | |
294 | ||
295 | { "MIX", NULL, "DAC" }, | |
296 | { "MIX", "IN Switch", "IN1" }, | |
297 | { "MIX", "IN Switch", "IN2" }, | |
298 | ||
299 | /* connect board input to the codec left channel output pin */ | |
300 | { "DAC", NULL, "OUTL" }, | |
301 | }; | |
302 | ||
303 | static struct snd_soc_dai_link tse850_dailink = { | |
304 | .name = "TSE-850", | |
305 | .stream_name = "TSE-850-PCM", | |
306 | .codec_dai_name = "pcm512x-hifi", | |
307 | .dai_fmt = SND_SOC_DAIFMT_I2S | |
308 | | SND_SOC_DAIFMT_NB_NF | |
309 | | SND_SOC_DAIFMT_CBM_CFS, | |
310 | }; | |
311 | ||
312 | static struct snd_soc_card tse850_card = { | |
313 | .name = "TSE-850-ASoC", | |
314 | .owner = THIS_MODULE, | |
315 | .dai_link = &tse850_dailink, | |
316 | .num_links = 1, | |
317 | .dapm_widgets = tse850_dapm_widgets, | |
318 | .num_dapm_widgets = ARRAY_SIZE(tse850_dapm_widgets), | |
319 | .dapm_routes = tse850_intercon, | |
320 | .num_dapm_routes = ARRAY_SIZE(tse850_intercon), | |
321 | .fully_routed = true, | |
322 | }; | |
323 | ||
324 | static int tse850_dt_init(struct platform_device *pdev) | |
325 | { | |
326 | struct device_node *np = pdev->dev.of_node; | |
327 | struct device_node *codec_np, *cpu_np; | |
aa431124 | 328 | struct snd_soc_dai_link *dailink = &tse850_dailink; |
aa431124 PR |
329 | |
330 | if (!np) { | |
331 | dev_err(&pdev->dev, "only device tree supported\n"); | |
332 | return -EINVAL; | |
333 | } | |
334 | ||
ca8c7f23 | 335 | cpu_np = of_parse_phandle(np, "axentia,cpu-dai", 0); |
aa431124 | 336 | if (!cpu_np) { |
ca8c7f23 | 337 | dev_err(&pdev->dev, "failed to get cpu dai\n"); |
aa431124 PR |
338 | return -EINVAL; |
339 | } | |
340 | dailink->cpu_of_node = cpu_np; | |
341 | dailink->platform_of_node = cpu_np; | |
aa431124 PR |
342 | of_node_put(cpu_np); |
343 | ||
344 | codec_np = of_parse_phandle(np, "axentia,audio-codec", 0); | |
345 | if (!codec_np) { | |
346 | dev_err(&pdev->dev, "failed to get codec info\n"); | |
347 | return -EINVAL; | |
348 | } | |
349 | dailink->codec_of_node = codec_np; | |
350 | of_node_put(codec_np); | |
351 | ||
352 | return 0; | |
353 | } | |
354 | ||
355 | static int tse850_probe(struct platform_device *pdev) | |
356 | { | |
357 | struct snd_soc_card *card = &tse850_card; | |
358 | struct device *dev = card->dev = &pdev->dev; | |
359 | struct tse850_priv *tse850; | |
360 | int ret; | |
361 | ||
362 | tse850 = devm_kzalloc(dev, sizeof(*tse850), GFP_KERNEL); | |
363 | if (!tse850) | |
364 | return -ENOMEM; | |
365 | ||
366 | snd_soc_card_set_drvdata(card, tse850); | |
367 | ||
368 | ret = tse850_dt_init(pdev); | |
369 | if (ret) { | |
370 | dev_err(dev, "failed to init dt info\n"); | |
371 | return ret; | |
372 | } | |
373 | ||
374 | tse850->add = devm_gpiod_get(dev, "axentia,add", GPIOD_OUT_HIGH); | |
375 | if (IS_ERR(tse850->add)) { | |
376 | if (PTR_ERR(tse850->add) != -EPROBE_DEFER) | |
377 | dev_err(dev, "failed to get 'add' gpio\n"); | |
378 | return PTR_ERR(tse850->add); | |
379 | } | |
380 | tse850->add_cache = 1; | |
381 | ||
382 | tse850->loop1 = devm_gpiod_get(dev, "axentia,loop1", GPIOD_OUT_HIGH); | |
383 | if (IS_ERR(tse850->loop1)) { | |
384 | if (PTR_ERR(tse850->loop1) != -EPROBE_DEFER) | |
385 | dev_err(dev, "failed to get 'loop1' gpio\n"); | |
386 | return PTR_ERR(tse850->loop1); | |
387 | } | |
388 | tse850->loop1_cache = 1; | |
389 | ||
390 | tse850->loop2 = devm_gpiod_get(dev, "axentia,loop2", GPIOD_OUT_HIGH); | |
391 | if (IS_ERR(tse850->loop2)) { | |
392 | if (PTR_ERR(tse850->loop2) != -EPROBE_DEFER) | |
393 | dev_err(dev, "failed to get 'loop2' gpio\n"); | |
394 | return PTR_ERR(tse850->loop2); | |
395 | } | |
396 | tse850->loop2_cache = 1; | |
397 | ||
398 | tse850->ana = devm_regulator_get(dev, "axentia,ana"); | |
399 | if (IS_ERR(tse850->ana)) { | |
400 | if (PTR_ERR(tse850->ana) != -EPROBE_DEFER) | |
401 | dev_err(dev, "failed to get 'ana' regulator\n"); | |
402 | return PTR_ERR(tse850->ana); | |
403 | } | |
404 | ||
405 | ret = regulator_enable(tse850->ana); | |
406 | if (ret < 0) { | |
407 | dev_err(dev, "failed to enable the 'ana' regulator\n"); | |
408 | return ret; | |
409 | } | |
410 | ||
aa431124 PR |
411 | ret = snd_soc_register_card(card); |
412 | if (ret) { | |
413 | dev_err(dev, "snd_soc_register_card failed\n"); | |
ca8c7f23 | 414 | goto err_disable_ana; |
aa431124 PR |
415 | } |
416 | ||
417 | return 0; | |
418 | ||
aa431124 PR |
419 | err_disable_ana: |
420 | regulator_disable(tse850->ana); | |
421 | return ret; | |
422 | } | |
423 | ||
424 | static int tse850_remove(struct platform_device *pdev) | |
425 | { | |
426 | struct snd_soc_card *card = platform_get_drvdata(pdev); | |
427 | struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card); | |
428 | ||
429 | snd_soc_unregister_card(card); | |
aa431124 PR |
430 | regulator_disable(tse850->ana); |
431 | ||
432 | return 0; | |
433 | } | |
434 | ||
435 | static const struct of_device_id tse850_dt_ids[] = { | |
436 | { .compatible = "axentia,tse850-pcm5142", }, | |
437 | { /* sentinel */ } | |
438 | }; | |
439 | MODULE_DEVICE_TABLE(of, tse850_dt_ids); | |
440 | ||
441 | static struct platform_driver tse850_driver = { | |
442 | .driver = { | |
443 | .name = "axentia-tse850-pcm5142", | |
444 | .of_match_table = of_match_ptr(tse850_dt_ids), | |
445 | }, | |
446 | .probe = tse850_probe, | |
447 | .remove = tse850_remove, | |
448 | }; | |
449 | ||
450 | module_platform_driver(tse850_driver); | |
451 | ||
452 | /* Module information */ | |
453 | MODULE_AUTHOR("Peter Rosin <peda@axentia.se>"); | |
454 | MODULE_DESCRIPTION("ALSA SoC driver for TSE-850 with PCM5142 codec"); | |
455 | MODULE_LICENSE("GPL"); |