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