1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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_device.h>
42#include <linux/of_gpio.h>
43#include <linux/regulator/consumer.h>
44
45#include <sound/soc.h>
46#include <sound/pcm_params.h>
47
48struct tse850_priv {
49 struct gpio_desc *add;
50 struct gpio_desc *loop1;
51 struct gpio_desc *loop2;
52
53 struct regulator *ana;
54
55 int add_cache;
56 int loop1_cache;
57 int loop2_cache;
58};
59
60static int tse850_get_mux1(struct snd_kcontrol *kctrl,
61 struct snd_ctl_elem_value *ucontrol)
62{
63 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
64 struct snd_soc_card *card = dapm->card;
65 struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
66
67 ucontrol->value.enumerated.item[0] = tse850->loop1_cache;
68
69 return 0;
70}
71
72static int tse850_put_mux1(struct snd_kcontrol *kctrl,
73 struct snd_ctl_elem_value *ucontrol)
74{
75 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
76 struct snd_soc_card *card = dapm->card;
77 struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
78 struct soc_enum *e = (struct soc_enum *)kctrl->private_value;
79 unsigned int val = ucontrol->value.enumerated.item[0];
80
81 if (val >= e->items)
82 return -EINVAL;
83
84 gpiod_set_value_cansleep(tse850->loop1, val);
85 tse850->loop1_cache = val;
86
87 return snd_soc_dapm_put_enum_double(kctrl, ucontrol);
88}
89
90static int tse850_get_mux2(struct snd_kcontrol *kctrl,
91 struct snd_ctl_elem_value *ucontrol)
92{
93 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
94 struct snd_soc_card *card = dapm->card;
95 struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
96
97 ucontrol->value.enumerated.item[0] = tse850->loop2_cache;
98
99 return 0;
100}
101
102static int tse850_put_mux2(struct snd_kcontrol *kctrl,
103 struct snd_ctl_elem_value *ucontrol)
104{
105 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
106 struct snd_soc_card *card = dapm->card;
107 struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
108 struct soc_enum *e = (struct soc_enum *)kctrl->private_value;
109 unsigned int val = ucontrol->value.enumerated.item[0];
110
111 if (val >= e->items)
112 return -EINVAL;
113
114 gpiod_set_value_cansleep(tse850->loop2, val);
115 tse850->loop2_cache = val;
116
117 return snd_soc_dapm_put_enum_double(kctrl, ucontrol);
118}
119
120static int tse850_get_mix(struct snd_kcontrol *kctrl,
121 struct snd_ctl_elem_value *ucontrol)
122{
123 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
124 struct snd_soc_card *card = dapm->card;
125 struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
126
127 ucontrol->value.enumerated.item[0] = tse850->add_cache;
128
129 return 0;
130}
131
132static int tse850_put_mix(struct snd_kcontrol *kctrl,
133 struct snd_ctl_elem_value *ucontrol)
134{
135 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
136 struct snd_soc_card *card = dapm->card;
137 struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
138 int connect = !!ucontrol->value.integer.value[0];
139
140 if (tse850->add_cache == connect)
141 return 0;
142
143
144
145
146
147 gpiod_set_value_cansleep(tse850->add, connect);
148 tse850->add_cache = connect;
149
150 snd_soc_dapm_mixer_update_power(dapm, kctrl, connect, NULL);
151 return 1;
152}
153
154static int tse850_get_ana(struct snd_kcontrol *kctrl,
155 struct snd_ctl_elem_value *ucontrol)
156{
157 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
158 struct snd_soc_card *card = dapm->card;
159 struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
160 int ret;
161
162 ret = regulator_get_voltage(tse850->ana);
163 if (ret < 0)
164 return ret;
165
166
167
168
169
170
171
172
173
174
175 if (ret < 11000000)
176 ret = 11000000;
177 else if (ret > 20000000)
178 ret = 20000000;
179 ret -= 11000000;
180 ret = (ret + 500000) / 1000000;
181
182 ucontrol->value.enumerated.item[0] = ret;
183
184 return 0;
185}
186
187static int tse850_put_ana(struct snd_kcontrol *kctrl,
188 struct snd_ctl_elem_value *ucontrol)
189{
190 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
191 struct snd_soc_card *card = dapm->card;
192 struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
193 struct soc_enum *e = (struct soc_enum *)kctrl->private_value;
194 unsigned int uV = ucontrol->value.enumerated.item[0];
195 int ret;
196
197 if (uV >= e->items)
198 return -EINVAL;
199
200
201
202
203
204
205
206
207
208
209 if (uV)
210 uV = 11000000 + (1000000 * uV);
211 else
212 uV = 2000000;
213
214 ret = regulator_set_voltage(tse850->ana, uV, uV);
215 if (ret < 0)
216 return ret;
217
218 return snd_soc_dapm_put_enum_double(kctrl, ucontrol);
219}
220
221static const char * const mux_text[] = { "Mixer", "Loop" };
222
223static const struct soc_enum mux_enum =
224 SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, ARRAY_SIZE(mux_text), mux_text);
225
226static const struct snd_kcontrol_new mux1 =
227 SOC_DAPM_ENUM_EXT("MUX1", mux_enum, tse850_get_mux1, tse850_put_mux1);
228
229static const struct snd_kcontrol_new mux2 =
230 SOC_DAPM_ENUM_EXT("MUX2", mux_enum, tse850_get_mux2, tse850_put_mux2);
231
232#define TSE850_DAPM_SINGLE_EXT(xname, reg, shift, max, invert, xget, xput) \
233{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
234 .info = snd_soc_info_volsw, \
235 .get = xget, \
236 .put = xput, \
237 .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
238
239static const struct snd_kcontrol_new mix[] = {
240 TSE850_DAPM_SINGLE_EXT("IN Switch", SND_SOC_NOPM, 0, 1, 0,
241 tse850_get_mix, tse850_put_mix),
242};
243
244static const char * const ana_text[] = {
245 "Low", "12V", "13V", "14V", "15V", "16V", "17V", "18V", "19V", "20V"
246};
247
248static const struct soc_enum ana_enum =
249 SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, ARRAY_SIZE(ana_text), ana_text);
250
251static const struct snd_kcontrol_new out =
252 SOC_DAPM_ENUM_EXT("ANA", ana_enum, tse850_get_ana, tse850_put_ana);
253
254static const struct snd_soc_dapm_widget tse850_dapm_widgets[] = {
255 SND_SOC_DAPM_LINE("OUT1", NULL),
256 SND_SOC_DAPM_LINE("OUT2", NULL),
257 SND_SOC_DAPM_LINE("IN1", NULL),
258 SND_SOC_DAPM_LINE("IN2", NULL),
259 SND_SOC_DAPM_INPUT("DAC"),
260 SND_SOC_DAPM_AIF_IN("AIFINL", "Playback", 0, SND_SOC_NOPM, 0, 0),
261 SND_SOC_DAPM_AIF_IN("AIFINR", "Playback", 1, SND_SOC_NOPM, 0, 0),
262 SOC_MIXER_ARRAY("MIX", SND_SOC_NOPM, 0, 0, mix),
263 SND_SOC_DAPM_MUX("MUX1", SND_SOC_NOPM, 0, 0, &mux1),
264 SND_SOC_DAPM_MUX("MUX2", SND_SOC_NOPM, 0, 0, &mux2),
265 SND_SOC_DAPM_OUT_DRV("OUT", SND_SOC_NOPM, 0, 0, &out, 1),
266};
267
268
269
270
271
272
273
274
275
276
277static const struct snd_soc_dapm_route tse850_intercon[] = {
278 { "OUT1", NULL, "MUX1" },
279 { "OUT2", NULL, "MUX2" },
280
281 { "MUX1", "Loop", "IN1" },
282 { "MUX1", "Mixer", "OUT" },
283
284 { "MUX2", "Loop", "IN2" },
285 { "MUX2", "Mixer", "OUT" },
286
287 { "OUT", NULL, "MIX" },
288
289 { "MIX", NULL, "DAC" },
290 { "MIX", "IN Switch", "IN1" },
291 { "MIX", "IN Switch", "IN2" },
292
293
294 { "DAC", NULL, "OUTL" },
295};
296
297SND_SOC_DAILINK_DEFS(pcm,
298 DAILINK_COMP_ARRAY(COMP_EMPTY()),
299 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "pcm512x-hifi")),
300 DAILINK_COMP_ARRAY(COMP_EMPTY()));
301
302static struct snd_soc_dai_link tse850_dailink = {
303 .name = "TSE-850",
304 .stream_name = "TSE-850-PCM",
305 .dai_fmt = SND_SOC_DAIFMT_I2S
306 | SND_SOC_DAIFMT_NB_NF
307 | SND_SOC_DAIFMT_CBM_CFS,
308 SND_SOC_DAILINK_REG(pcm),
309};
310
311static struct snd_soc_card tse850_card = {
312 .name = "TSE-850-ASoC",
313 .owner = THIS_MODULE,
314 .dai_link = &tse850_dailink,
315 .num_links = 1,
316 .dapm_widgets = tse850_dapm_widgets,
317 .num_dapm_widgets = ARRAY_SIZE(tse850_dapm_widgets),
318 .dapm_routes = tse850_intercon,
319 .num_dapm_routes = ARRAY_SIZE(tse850_intercon),
320 .fully_routed = true,
321};
322
323static int tse850_dt_init(struct platform_device *pdev)
324{
325 struct device_node *np = pdev->dev.of_node;
326 struct device_node *codec_np, *cpu_np;
327 struct snd_soc_dai_link *dailink = &tse850_dailink;
328
329 if (!np) {
330 dev_err(&pdev->dev, "only device tree supported\n");
331 return -EINVAL;
332 }
333
334 cpu_np = of_parse_phandle(np, "axentia,cpu-dai", 0);
335 if (!cpu_np) {
336 dev_err(&pdev->dev, "failed to get cpu dai\n");
337 return -EINVAL;
338 }
339 dailink->cpus->of_node = cpu_np;
340 dailink->platforms->of_node = cpu_np;
341 of_node_put(cpu_np);
342
343 codec_np = of_parse_phandle(np, "axentia,audio-codec", 0);
344 if (!codec_np) {
345 dev_err(&pdev->dev, "failed to get codec info\n");
346 return -EINVAL;
347 }
348 dailink->codecs->of_node = codec_np;
349 of_node_put(codec_np);
350
351 return 0;
352}
353
354static int tse850_probe(struct platform_device *pdev)
355{
356 struct snd_soc_card *card = &tse850_card;
357 struct device *dev = card->dev = &pdev->dev;
358 struct tse850_priv *tse850;
359 int ret;
360
361 tse850 = devm_kzalloc(dev, sizeof(*tse850), GFP_KERNEL);
362 if (!tse850)
363 return -ENOMEM;
364
365 snd_soc_card_set_drvdata(card, tse850);
366
367 ret = tse850_dt_init(pdev);
368 if (ret) {
369 dev_err(dev, "failed to init dt info\n");
370 return ret;
371 }
372
373 tse850->add = devm_gpiod_get(dev, "axentia,add", GPIOD_OUT_HIGH);
374 if (IS_ERR(tse850->add)) {
375 if (PTR_ERR(tse850->add) != -EPROBE_DEFER)
376 dev_err(dev, "failed to get 'add' gpio\n");
377 return PTR_ERR(tse850->add);
378 }
379 tse850->add_cache = 1;
380
381 tse850->loop1 = devm_gpiod_get(dev, "axentia,loop1", GPIOD_OUT_HIGH);
382 if (IS_ERR(tse850->loop1)) {
383 if (PTR_ERR(tse850->loop1) != -EPROBE_DEFER)
384 dev_err(dev, "failed to get 'loop1' gpio\n");
385 return PTR_ERR(tse850->loop1);
386 }
387 tse850->loop1_cache = 1;
388
389 tse850->loop2 = devm_gpiod_get(dev, "axentia,loop2", GPIOD_OUT_HIGH);
390 if (IS_ERR(tse850->loop2)) {
391 if (PTR_ERR(tse850->loop2) != -EPROBE_DEFER)
392 dev_err(dev, "failed to get 'loop2' gpio\n");
393 return PTR_ERR(tse850->loop2);
394 }
395 tse850->loop2_cache = 1;
396
397 tse850->ana = devm_regulator_get(dev, "axentia,ana");
398 if (IS_ERR(tse850->ana)) {
399 if (PTR_ERR(tse850->ana) != -EPROBE_DEFER)
400 dev_err(dev, "failed to get 'ana' regulator\n");
401 return PTR_ERR(tse850->ana);
402 }
403
404 ret = regulator_enable(tse850->ana);
405 if (ret < 0) {
406 dev_err(dev, "failed to enable the 'ana' regulator\n");
407 return ret;
408 }
409
410 ret = snd_soc_register_card(card);
411 if (ret) {
412 dev_err(dev, "snd_soc_register_card failed\n");
413 goto err_disable_ana;
414 }
415
416 return 0;
417
418err_disable_ana:
419 regulator_disable(tse850->ana);
420 return ret;
421}
422
423static int tse850_remove(struct platform_device *pdev)
424{
425 struct snd_soc_card *card = platform_get_drvdata(pdev);
426 struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
427
428 snd_soc_unregister_card(card);
429 regulator_disable(tse850->ana);
430
431 return 0;
432}
433
434static const struct of_device_id tse850_dt_ids[] = {
435 { .compatible = "axentia,tse850-pcm5142", },
436 { }
437};
438MODULE_DEVICE_TABLE(of, tse850_dt_ids);
439
440static struct platform_driver tse850_driver = {
441 .driver = {
442 .name = "axentia-tse850-pcm5142",
443 .of_match_table = of_match_ptr(tse850_dt_ids),
444 },
445 .probe = tse850_probe,
446 .remove = tse850_remove,
447};
448
449module_platform_driver(tse850_driver);
450
451
452MODULE_AUTHOR("Peter Rosin <peda@axentia.se>");
453MODULE_DESCRIPTION("ALSA SoC driver for TSE-850 with PCM5142 codec");
454MODULE_LICENSE("GPL v2");
455
