Loading...
1// SPDX-License-Identifier: GPL-2.0
2//
3// simple-card-utils.c
4//
5// Copyright (c) 2016 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
6
7#include <linux/clk.h>
8#include <linux/gpio.h>
9#include <linux/gpio/consumer.h>
10#include <linux/module.h>
11#include <linux/of.h>
12#include <linux/of_graph.h>
13#include <sound/jack.h>
14#include <sound/pcm_params.h>
15#include <sound/simple_card_utils.h>
16
17static void asoc_simple_fixup_sample_fmt(struct asoc_simple_data *data,
18 struct snd_pcm_hw_params *params)
19{
20 int i;
21 struct snd_mask *mask = hw_param_mask(params,
22 SNDRV_PCM_HW_PARAM_FORMAT);
23 struct {
24 char *fmt;
25 u32 val;
26 } of_sample_fmt_table[] = {
27 { "s8", SNDRV_PCM_FORMAT_S8},
28 { "s16_le", SNDRV_PCM_FORMAT_S16_LE},
29 { "s24_le", SNDRV_PCM_FORMAT_S24_LE},
30 { "s24_3le", SNDRV_PCM_FORMAT_S24_3LE},
31 { "s32_le", SNDRV_PCM_FORMAT_S32_LE},
32 };
33
34 for (i = 0; i < ARRAY_SIZE(of_sample_fmt_table); i++) {
35 if (!strcmp(data->convert_sample_format,
36 of_sample_fmt_table[i].fmt)) {
37 snd_mask_none(mask);
38 snd_mask_set(mask, of_sample_fmt_table[i].val);
39 break;
40 }
41 }
42}
43
44void asoc_simple_parse_convert(struct device_node *np,
45 char *prefix,
46 struct asoc_simple_data *data)
47{
48 char prop[128];
49
50 if (!prefix)
51 prefix = "";
52
53 /* sampling rate convert */
54 snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-rate");
55 of_property_read_u32(np, prop, &data->convert_rate);
56
57 /* channels transfer */
58 snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-channels");
59 of_property_read_u32(np, prop, &data->convert_channels);
60
61 /* convert sample format */
62 snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-sample-format");
63 of_property_read_string(np, prop, &data->convert_sample_format);
64}
65EXPORT_SYMBOL_GPL(asoc_simple_parse_convert);
66
67/**
68 * asoc_simple_is_convert_required() - Query if HW param conversion was requested
69 * @data: Link data.
70 *
71 * Returns true if any HW param conversion was requested for this DAI link with
72 * any "convert-xxx" properties.
73 */
74bool asoc_simple_is_convert_required(const struct asoc_simple_data *data)
75{
76 return data->convert_rate ||
77 data->convert_channels ||
78 data->convert_sample_format;
79}
80EXPORT_SYMBOL_GPL(asoc_simple_is_convert_required);
81
82int asoc_simple_parse_daifmt(struct device *dev,
83 struct device_node *node,
84 struct device_node *codec,
85 char *prefix,
86 unsigned int *retfmt)
87{
88 struct device_node *bitclkmaster = NULL;
89 struct device_node *framemaster = NULL;
90 unsigned int daifmt;
91
92 daifmt = snd_soc_daifmt_parse_format(node, prefix);
93
94 snd_soc_daifmt_parse_clock_provider_as_phandle(node, prefix, &bitclkmaster, &framemaster);
95 if (!bitclkmaster && !framemaster) {
96 /*
97 * No dai-link level and master setting was not found from
98 * sound node level, revert back to legacy DT parsing and
99 * take the settings from codec node.
100 */
101 dev_dbg(dev, "Revert to legacy daifmt parsing\n");
102
103 daifmt |= snd_soc_daifmt_parse_clock_provider_as_flag(codec, NULL);
104 } else {
105 daifmt |= snd_soc_daifmt_clock_provider_from_bitmap(
106 ((codec == bitclkmaster) << 4) | (codec == framemaster));
107 }
108
109 of_node_put(bitclkmaster);
110 of_node_put(framemaster);
111
112 *retfmt = daifmt;
113
114 return 0;
115}
116EXPORT_SYMBOL_GPL(asoc_simple_parse_daifmt);
117
118int asoc_simple_parse_tdm_width_map(struct device *dev, struct device_node *np,
119 struct asoc_simple_dai *dai)
120{
121 u32 *array_values, *p;
122 int n, i, ret;
123
124 if (!of_property_read_bool(np, "dai-tdm-slot-width-map"))
125 return 0;
126
127 n = of_property_count_elems_of_size(np, "dai-tdm-slot-width-map", sizeof(u32));
128 if (n % 3) {
129 dev_err(dev, "Invalid number of cells for dai-tdm-slot-width-map\n");
130 return -EINVAL;
131 }
132
133 dai->tdm_width_map = devm_kcalloc(dev, n, sizeof(*dai->tdm_width_map), GFP_KERNEL);
134 if (!dai->tdm_width_map)
135 return -ENOMEM;
136
137 array_values = kcalloc(n, sizeof(*array_values), GFP_KERNEL);
138 if (!array_values)
139 return -ENOMEM;
140
141 ret = of_property_read_u32_array(np, "dai-tdm-slot-width-map", array_values, n);
142 if (ret < 0) {
143 dev_err(dev, "Could not read dai-tdm-slot-width-map: %d\n", ret);
144 goto out;
145 }
146
147 p = array_values;
148 for (i = 0; i < n / 3; ++i) {
149 dai->tdm_width_map[i].sample_bits = *p++;
150 dai->tdm_width_map[i].slot_width = *p++;
151 dai->tdm_width_map[i].slot_count = *p++;
152 }
153
154 dai->n_tdm_widths = i;
155 ret = 0;
156out:
157 kfree(array_values);
158
159 return ret;
160}
161EXPORT_SYMBOL_GPL(asoc_simple_parse_tdm_width_map);
162
163int asoc_simple_set_dailink_name(struct device *dev,
164 struct snd_soc_dai_link *dai_link,
165 const char *fmt, ...)
166{
167 va_list ap;
168 char *name = NULL;
169 int ret = -ENOMEM;
170
171 va_start(ap, fmt);
172 name = devm_kvasprintf(dev, GFP_KERNEL, fmt, ap);
173 va_end(ap);
174
175 if (name) {
176 ret = 0;
177
178 dai_link->name = name;
179 dai_link->stream_name = name;
180 }
181
182 return ret;
183}
184EXPORT_SYMBOL_GPL(asoc_simple_set_dailink_name);
185
186int asoc_simple_parse_card_name(struct snd_soc_card *card,
187 char *prefix)
188{
189 int ret;
190
191 if (!prefix)
192 prefix = "";
193
194 /* Parse the card name from DT */
195 ret = snd_soc_of_parse_card_name(card, "label");
196 if (ret < 0 || !card->name) {
197 char prop[128];
198
199 snprintf(prop, sizeof(prop), "%sname", prefix);
200 ret = snd_soc_of_parse_card_name(card, prop);
201 if (ret < 0)
202 return ret;
203 }
204
205 if (!card->name && card->dai_link)
206 card->name = card->dai_link->name;
207
208 return 0;
209}
210EXPORT_SYMBOL_GPL(asoc_simple_parse_card_name);
211
212static int asoc_simple_clk_enable(struct asoc_simple_dai *dai)
213{
214 if (dai)
215 return clk_prepare_enable(dai->clk);
216
217 return 0;
218}
219
220static void asoc_simple_clk_disable(struct asoc_simple_dai *dai)
221{
222 if (dai)
223 clk_disable_unprepare(dai->clk);
224}
225
226int asoc_simple_parse_clk(struct device *dev,
227 struct device_node *node,
228 struct asoc_simple_dai *simple_dai,
229 struct snd_soc_dai_link_component *dlc)
230{
231 struct clk *clk;
232 u32 val;
233
234 /*
235 * Parse dai->sysclk come from "clocks = <&xxx>"
236 * (if system has common clock)
237 * or "system-clock-frequency = <xxx>"
238 * or device's module clock.
239 */
240 clk = devm_get_clk_from_child(dev, node, NULL);
241 simple_dai->clk_fixed = of_property_read_bool(
242 node, "system-clock-fixed");
243 if (!IS_ERR(clk)) {
244 simple_dai->sysclk = clk_get_rate(clk);
245
246 simple_dai->clk = clk;
247 } else if (!of_property_read_u32(node, "system-clock-frequency", &val)) {
248 simple_dai->sysclk = val;
249 simple_dai->clk_fixed = true;
250 } else {
251 clk = devm_get_clk_from_child(dev, dlc->of_node, NULL);
252 if (!IS_ERR(clk))
253 simple_dai->sysclk = clk_get_rate(clk);
254 }
255
256 if (of_property_read_bool(node, "system-clock-direction-out"))
257 simple_dai->clk_direction = SND_SOC_CLOCK_OUT;
258
259 return 0;
260}
261EXPORT_SYMBOL_GPL(asoc_simple_parse_clk);
262
263static int asoc_simple_check_fixed_sysclk(struct device *dev,
264 struct asoc_simple_dai *dai,
265 unsigned int *fixed_sysclk)
266{
267 if (dai->clk_fixed) {
268 if (*fixed_sysclk && *fixed_sysclk != dai->sysclk) {
269 dev_err(dev, "inconsistent fixed sysclk rates (%u vs %u)\n",
270 *fixed_sysclk, dai->sysclk);
271 return -EINVAL;
272 }
273 *fixed_sysclk = dai->sysclk;
274 }
275
276 return 0;
277}
278
279int asoc_simple_startup(struct snd_pcm_substream *substream)
280{
281 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
282 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
283 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
284 struct asoc_simple_dai *dai;
285 unsigned int fixed_sysclk = 0;
286 int i1, i2, i;
287 int ret;
288
289 for_each_prop_dai_cpu(props, i1, dai) {
290 ret = asoc_simple_clk_enable(dai);
291 if (ret)
292 goto cpu_err;
293 ret = asoc_simple_check_fixed_sysclk(rtd->dev, dai, &fixed_sysclk);
294 if (ret)
295 goto cpu_err;
296 }
297
298 for_each_prop_dai_codec(props, i2, dai) {
299 ret = asoc_simple_clk_enable(dai);
300 if (ret)
301 goto codec_err;
302 ret = asoc_simple_check_fixed_sysclk(rtd->dev, dai, &fixed_sysclk);
303 if (ret)
304 goto codec_err;
305 }
306
307 if (fixed_sysclk && props->mclk_fs) {
308 unsigned int fixed_rate = fixed_sysclk / props->mclk_fs;
309
310 if (fixed_sysclk % props->mclk_fs) {
311 dev_err(rtd->dev, "fixed sysclk %u not divisible by mclk_fs %u\n",
312 fixed_sysclk, props->mclk_fs);
313 return -EINVAL;
314 }
315 ret = snd_pcm_hw_constraint_minmax(substream->runtime, SNDRV_PCM_HW_PARAM_RATE,
316 fixed_rate, fixed_rate);
317 if (ret)
318 goto codec_err;
319 }
320
321 return 0;
322
323codec_err:
324 for_each_prop_dai_codec(props, i, dai) {
325 if (i >= i2)
326 break;
327 asoc_simple_clk_disable(dai);
328 }
329cpu_err:
330 for_each_prop_dai_cpu(props, i, dai) {
331 if (i >= i1)
332 break;
333 asoc_simple_clk_disable(dai);
334 }
335 return ret;
336}
337EXPORT_SYMBOL_GPL(asoc_simple_startup);
338
339void asoc_simple_shutdown(struct snd_pcm_substream *substream)
340{
341 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
342 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
343 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
344 struct asoc_simple_dai *dai;
345 int i;
346
347 for_each_prop_dai_cpu(props, i, dai) {
348 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, i);
349
350 if (props->mclk_fs && !dai->clk_fixed && !snd_soc_dai_active(cpu_dai))
351 snd_soc_dai_set_sysclk(cpu_dai,
352 0, 0, SND_SOC_CLOCK_OUT);
353
354 asoc_simple_clk_disable(dai);
355 }
356 for_each_prop_dai_codec(props, i, dai) {
357 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, i);
358
359 if (props->mclk_fs && !dai->clk_fixed && !snd_soc_dai_active(codec_dai))
360 snd_soc_dai_set_sysclk(codec_dai,
361 0, 0, SND_SOC_CLOCK_IN);
362
363 asoc_simple_clk_disable(dai);
364 }
365}
366EXPORT_SYMBOL_GPL(asoc_simple_shutdown);
367
368static int asoc_simple_set_clk_rate(struct device *dev,
369 struct asoc_simple_dai *simple_dai,
370 unsigned long rate)
371{
372 if (!simple_dai)
373 return 0;
374
375 if (simple_dai->clk_fixed && rate != simple_dai->sysclk) {
376 dev_err(dev, "dai %s invalid clock rate %lu\n", simple_dai->name, rate);
377 return -EINVAL;
378 }
379
380 if (!simple_dai->clk)
381 return 0;
382
383 if (clk_get_rate(simple_dai->clk) == rate)
384 return 0;
385
386 return clk_set_rate(simple_dai->clk, rate);
387}
388
389static int asoc_simple_set_tdm(struct snd_soc_dai *dai,
390 struct asoc_simple_dai *simple_dai,
391 struct snd_pcm_hw_params *params)
392{
393 int sample_bits = params_width(params);
394 int slot_width, slot_count;
395 int i, ret;
396
397 if (!simple_dai || !simple_dai->tdm_width_map)
398 return 0;
399
400 slot_width = simple_dai->slot_width;
401 slot_count = simple_dai->slots;
402
403 if (slot_width == 0)
404 slot_width = sample_bits;
405
406 for (i = 0; i < simple_dai->n_tdm_widths; ++i) {
407 if (simple_dai->tdm_width_map[i].sample_bits == sample_bits) {
408 slot_width = simple_dai->tdm_width_map[i].slot_width;
409 slot_count = simple_dai->tdm_width_map[i].slot_count;
410 break;
411 }
412 }
413
414 ret = snd_soc_dai_set_tdm_slot(dai,
415 simple_dai->tx_slot_mask,
416 simple_dai->rx_slot_mask,
417 slot_count,
418 slot_width);
419 if (ret && ret != -ENOTSUPP) {
420 dev_err(dai->dev, "simple-card: set_tdm_slot error: %d\n", ret);
421 return ret;
422 }
423
424 return 0;
425}
426
427int asoc_simple_hw_params(struct snd_pcm_substream *substream,
428 struct snd_pcm_hw_params *params)
429{
430 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
431 struct asoc_simple_dai *pdai;
432 struct snd_soc_dai *sdai;
433 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
434 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
435 unsigned int mclk, mclk_fs = 0;
436 int i, ret;
437
438 if (props->mclk_fs)
439 mclk_fs = props->mclk_fs;
440
441 if (mclk_fs) {
442 struct snd_soc_component *component;
443 mclk = params_rate(params) * mclk_fs;
444
445 for_each_prop_dai_codec(props, i, pdai) {
446 ret = asoc_simple_set_clk_rate(rtd->dev, pdai, mclk);
447 if (ret < 0)
448 return ret;
449 }
450
451 for_each_prop_dai_cpu(props, i, pdai) {
452 ret = asoc_simple_set_clk_rate(rtd->dev, pdai, mclk);
453 if (ret < 0)
454 return ret;
455 }
456
457 /* Ensure sysclk is set on all components in case any
458 * (such as platform components) are missed by calls to
459 * snd_soc_dai_set_sysclk.
460 */
461 for_each_rtd_components(rtd, i, component) {
462 ret = snd_soc_component_set_sysclk(component, 0, 0,
463 mclk, SND_SOC_CLOCK_IN);
464 if (ret && ret != -ENOTSUPP)
465 return ret;
466 }
467
468 for_each_rtd_codec_dais(rtd, i, sdai) {
469 ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_IN);
470 if (ret && ret != -ENOTSUPP)
471 return ret;
472 }
473
474 for_each_rtd_cpu_dais(rtd, i, sdai) {
475 ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_OUT);
476 if (ret && ret != -ENOTSUPP)
477 return ret;
478 }
479 }
480
481 for_each_prop_dai_codec(props, i, pdai) {
482 sdai = asoc_rtd_to_codec(rtd, i);
483 ret = asoc_simple_set_tdm(sdai, pdai, params);
484 if (ret < 0)
485 return ret;
486 }
487
488 for_each_prop_dai_cpu(props, i, pdai) {
489 sdai = asoc_rtd_to_cpu(rtd, i);
490 ret = asoc_simple_set_tdm(sdai, pdai, params);
491 if (ret < 0)
492 return ret;
493 }
494
495 return 0;
496}
497EXPORT_SYMBOL_GPL(asoc_simple_hw_params);
498
499int asoc_simple_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
500 struct snd_pcm_hw_params *params)
501{
502 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
503 struct simple_dai_props *dai_props = simple_priv_to_props(priv, rtd->num);
504 struct asoc_simple_data *data = &dai_props->adata;
505 struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
506 struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
507
508 if (data->convert_rate)
509 rate->min =
510 rate->max = data->convert_rate;
511
512 if (data->convert_channels)
513 channels->min =
514 channels->max = data->convert_channels;
515
516 if (data->convert_sample_format)
517 asoc_simple_fixup_sample_fmt(data, params);
518
519 return 0;
520}
521EXPORT_SYMBOL_GPL(asoc_simple_be_hw_params_fixup);
522
523static int asoc_simple_init_dai(struct snd_soc_dai *dai,
524 struct asoc_simple_dai *simple_dai)
525{
526 int ret;
527
528 if (!simple_dai)
529 return 0;
530
531 if (simple_dai->sysclk) {
532 ret = snd_soc_dai_set_sysclk(dai, 0, simple_dai->sysclk,
533 simple_dai->clk_direction);
534 if (ret && ret != -ENOTSUPP) {
535 dev_err(dai->dev, "simple-card: set_sysclk error\n");
536 return ret;
537 }
538 }
539
540 if (simple_dai->slots) {
541 ret = snd_soc_dai_set_tdm_slot(dai,
542 simple_dai->tx_slot_mask,
543 simple_dai->rx_slot_mask,
544 simple_dai->slots,
545 simple_dai->slot_width);
546 if (ret && ret != -ENOTSUPP) {
547 dev_err(dai->dev, "simple-card: set_tdm_slot error\n");
548 return ret;
549 }
550 }
551
552 return 0;
553}
554
555static inline int asoc_simple_component_is_codec(struct snd_soc_component *component)
556{
557 return component->driver->endianness;
558}
559
560static int asoc_simple_init_for_codec2codec(struct snd_soc_pcm_runtime *rtd,
561 struct simple_dai_props *dai_props)
562{
563 struct snd_soc_dai_link *dai_link = rtd->dai_link;
564 struct snd_soc_component *component;
565 struct snd_soc_pcm_stream *params;
566 struct snd_pcm_hardware hw;
567 int i, ret, stream;
568
569 /* Do nothing if it already has Codec2Codec settings */
570 if (dai_link->params)
571 return 0;
572
573 /* Do nothing if it was DPCM :: BE */
574 if (dai_link->no_pcm)
575 return 0;
576
577 /* Only Codecs */
578 for_each_rtd_components(rtd, i, component) {
579 if (!asoc_simple_component_is_codec(component))
580 return 0;
581 }
582
583 /* Assumes the capabilities are the same for all supported streams */
584 for_each_pcm_streams(stream) {
585 ret = snd_soc_runtime_calc_hw(rtd, &hw, stream);
586 if (ret == 0)
587 break;
588 }
589
590 if (ret < 0) {
591 dev_err(rtd->dev, "simple-card: no valid dai_link params\n");
592 return ret;
593 }
594
595 params = devm_kzalloc(rtd->dev, sizeof(*params), GFP_KERNEL);
596 if (!params)
597 return -ENOMEM;
598
599 params->formats = hw.formats;
600 params->rates = hw.rates;
601 params->rate_min = hw.rate_min;
602 params->rate_max = hw.rate_max;
603 params->channels_min = hw.channels_min;
604 params->channels_max = hw.channels_max;
605
606 dai_link->params = params;
607 dai_link->num_params = 1;
608
609 return 0;
610}
611
612int asoc_simple_dai_init(struct snd_soc_pcm_runtime *rtd)
613{
614 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
615 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
616 struct asoc_simple_dai *dai;
617 int i, ret;
618
619 for_each_prop_dai_codec(props, i, dai) {
620 ret = asoc_simple_init_dai(asoc_rtd_to_codec(rtd, i), dai);
621 if (ret < 0)
622 return ret;
623 }
624 for_each_prop_dai_cpu(props, i, dai) {
625 ret = asoc_simple_init_dai(asoc_rtd_to_cpu(rtd, i), dai);
626 if (ret < 0)
627 return ret;
628 }
629
630 ret = asoc_simple_init_for_codec2codec(rtd, props);
631 if (ret < 0)
632 return ret;
633
634 return 0;
635}
636EXPORT_SYMBOL_GPL(asoc_simple_dai_init);
637
638void asoc_simple_canonicalize_platform(struct snd_soc_dai_link_component *platforms,
639 struct snd_soc_dai_link_component *cpus)
640{
641 /* Assumes platform == cpu */
642 if (!platforms->of_node)
643 platforms->of_node = cpus->of_node;
644}
645EXPORT_SYMBOL_GPL(asoc_simple_canonicalize_platform);
646
647void asoc_simple_canonicalize_cpu(struct snd_soc_dai_link_component *cpus,
648 int is_single_links)
649{
650 /*
651 * In soc_bind_dai_link() will check cpu name after
652 * of_node matching if dai_link has cpu_dai_name.
653 * but, it will never match if name was created by
654 * fmt_single_name() remove cpu_dai_name if cpu_args
655 * was 0. See:
656 * fmt_single_name()
657 * fmt_multiple_name()
658 */
659 if (is_single_links)
660 cpus->dai_name = NULL;
661}
662EXPORT_SYMBOL_GPL(asoc_simple_canonicalize_cpu);
663
664void asoc_simple_clean_reference(struct snd_soc_card *card)
665{
666 struct snd_soc_dai_link *dai_link;
667 struct snd_soc_dai_link_component *cpu;
668 struct snd_soc_dai_link_component *codec;
669 int i, j;
670
671 for_each_card_prelinks(card, i, dai_link) {
672 for_each_link_cpus(dai_link, j, cpu)
673 of_node_put(cpu->of_node);
674 for_each_link_codecs(dai_link, j, codec)
675 of_node_put(codec->of_node);
676 }
677}
678EXPORT_SYMBOL_GPL(asoc_simple_clean_reference);
679
680int asoc_simple_parse_routing(struct snd_soc_card *card,
681 char *prefix)
682{
683 struct device_node *node = card->dev->of_node;
684 char prop[128];
685
686 if (!prefix)
687 prefix = "";
688
689 snprintf(prop, sizeof(prop), "%s%s", prefix, "routing");
690
691 if (!of_property_read_bool(node, prop))
692 return 0;
693
694 return snd_soc_of_parse_audio_routing(card, prop);
695}
696EXPORT_SYMBOL_GPL(asoc_simple_parse_routing);
697
698int asoc_simple_parse_widgets(struct snd_soc_card *card,
699 char *prefix)
700{
701 struct device_node *node = card->dev->of_node;
702 char prop[128];
703
704 if (!prefix)
705 prefix = "";
706
707 snprintf(prop, sizeof(prop), "%s%s", prefix, "widgets");
708
709 if (of_property_read_bool(node, prop))
710 return snd_soc_of_parse_audio_simple_widgets(card, prop);
711
712 /* no widgets is not error */
713 return 0;
714}
715EXPORT_SYMBOL_GPL(asoc_simple_parse_widgets);
716
717int asoc_simple_parse_pin_switches(struct snd_soc_card *card,
718 char *prefix)
719{
720 char prop[128];
721
722 if (!prefix)
723 prefix = "";
724
725 snprintf(prop, sizeof(prop), "%s%s", prefix, "pin-switches");
726
727 return snd_soc_of_parse_pin_switches(card, prop);
728}
729EXPORT_SYMBOL_GPL(asoc_simple_parse_pin_switches);
730
731int asoc_simple_init_jack(struct snd_soc_card *card,
732 struct asoc_simple_jack *sjack,
733 int is_hp, char *prefix,
734 char *pin)
735{
736 struct device *dev = card->dev;
737 struct gpio_desc *desc;
738 char prop[128];
739 char *pin_name;
740 char *gpio_name;
741 int mask;
742 int error;
743
744 if (!prefix)
745 prefix = "";
746
747 sjack->gpio.gpio = -ENOENT;
748
749 if (is_hp) {
750 snprintf(prop, sizeof(prop), "%shp-det", prefix);
751 pin_name = pin ? pin : "Headphones";
752 gpio_name = "Headphone detection";
753 mask = SND_JACK_HEADPHONE;
754 } else {
755 snprintf(prop, sizeof(prop), "%smic-det", prefix);
756 pin_name = pin ? pin : "Mic Jack";
757 gpio_name = "Mic detection";
758 mask = SND_JACK_MICROPHONE;
759 }
760
761 desc = gpiod_get_optional(dev, prop, GPIOD_IN);
762 error = PTR_ERR_OR_ZERO(desc);
763 if (error)
764 return error;
765
766 if (desc) {
767 error = gpiod_set_consumer_name(desc, gpio_name);
768 if (error)
769 return error;
770
771 sjack->pin.pin = pin_name;
772 sjack->pin.mask = mask;
773
774 sjack->gpio.name = gpio_name;
775 sjack->gpio.report = mask;
776 sjack->gpio.desc = desc;
777 sjack->gpio.debounce_time = 150;
778
779 snd_soc_card_jack_new_pins(card, pin_name, mask, &sjack->jack,
780 &sjack->pin, 1);
781
782 snd_soc_jack_add_gpios(&sjack->jack, 1, &sjack->gpio);
783 }
784
785 return 0;
786}
787EXPORT_SYMBOL_GPL(asoc_simple_init_jack);
788
789int asoc_simple_init_priv(struct asoc_simple_priv *priv,
790 struct link_info *li)
791{
792 struct snd_soc_card *card = simple_priv_to_card(priv);
793 struct device *dev = simple_priv_to_dev(priv);
794 struct snd_soc_dai_link *dai_link;
795 struct simple_dai_props *dai_props;
796 struct asoc_simple_dai *dais;
797 struct snd_soc_dai_link_component *dlcs;
798 struct snd_soc_codec_conf *cconf = NULL;
799 int i, dai_num = 0, dlc_num = 0, cnf_num = 0;
800
801 dai_props = devm_kcalloc(dev, li->link, sizeof(*dai_props), GFP_KERNEL);
802 dai_link = devm_kcalloc(dev, li->link, sizeof(*dai_link), GFP_KERNEL);
803 if (!dai_props || !dai_link)
804 return -ENOMEM;
805
806 /*
807 * dais (= CPU+Codec)
808 * dlcs (= CPU+Codec+Platform)
809 */
810 for (i = 0; i < li->link; i++) {
811 int cc = li->num[i].cpus + li->num[i].codecs;
812
813 dai_num += cc;
814 dlc_num += cc + li->num[i].platforms;
815
816 if (!li->num[i].cpus)
817 cnf_num += li->num[i].codecs;
818 }
819
820 dais = devm_kcalloc(dev, dai_num, sizeof(*dais), GFP_KERNEL);
821 dlcs = devm_kcalloc(dev, dlc_num, sizeof(*dlcs), GFP_KERNEL);
822 if (!dais || !dlcs)
823 return -ENOMEM;
824
825 if (cnf_num) {
826 cconf = devm_kcalloc(dev, cnf_num, sizeof(*cconf), GFP_KERNEL);
827 if (!cconf)
828 return -ENOMEM;
829 }
830
831 dev_dbg(dev, "link %d, dais %d, ccnf %d\n",
832 li->link, dai_num, cnf_num);
833
834 /* dummy CPU/Codec */
835 priv->dummy.of_node = NULL;
836 priv->dummy.dai_name = "snd-soc-dummy-dai";
837 priv->dummy.name = "snd-soc-dummy";
838
839 priv->dai_props = dai_props;
840 priv->dai_link = dai_link;
841 priv->dais = dais;
842 priv->dlcs = dlcs;
843 priv->codec_conf = cconf;
844
845 card->dai_link = priv->dai_link;
846 card->num_links = li->link;
847 card->codec_conf = cconf;
848 card->num_configs = cnf_num;
849
850 for (i = 0; i < li->link; i++) {
851 if (li->num[i].cpus) {
852 /* Normal CPU */
853 dai_props[i].cpus =
854 dai_link[i].cpus = dlcs;
855 dai_props[i].num.cpus =
856 dai_link[i].num_cpus = li->num[i].cpus;
857 dai_props[i].cpu_dai = dais;
858
859 dlcs += li->num[i].cpus;
860 dais += li->num[i].cpus;
861 } else {
862 /* DPCM Be's CPU = dummy */
863 dai_props[i].cpus =
864 dai_link[i].cpus = &priv->dummy;
865 dai_props[i].num.cpus =
866 dai_link[i].num_cpus = 1;
867 }
868
869 if (li->num[i].codecs) {
870 /* Normal Codec */
871 dai_props[i].codecs =
872 dai_link[i].codecs = dlcs;
873 dai_props[i].num.codecs =
874 dai_link[i].num_codecs = li->num[i].codecs;
875 dai_props[i].codec_dai = dais;
876
877 dlcs += li->num[i].codecs;
878 dais += li->num[i].codecs;
879
880 if (!li->num[i].cpus) {
881 /* DPCM Be's Codec */
882 dai_props[i].codec_conf = cconf;
883 cconf += li->num[i].codecs;
884 }
885 } else {
886 /* DPCM Fe's Codec = dummy */
887 dai_props[i].codecs =
888 dai_link[i].codecs = &priv->dummy;
889 dai_props[i].num.codecs =
890 dai_link[i].num_codecs = 1;
891 }
892
893 if (li->num[i].platforms) {
894 /* Have Platform */
895 dai_props[i].platforms =
896 dai_link[i].platforms = dlcs;
897 dai_props[i].num.platforms =
898 dai_link[i].num_platforms = li->num[i].platforms;
899
900 dlcs += li->num[i].platforms;
901 } else {
902 /* Doesn't have Platform */
903 dai_props[i].platforms =
904 dai_link[i].platforms = NULL;
905 dai_props[i].num.platforms =
906 dai_link[i].num_platforms = 0;
907 }
908 }
909
910 return 0;
911}
912EXPORT_SYMBOL_GPL(asoc_simple_init_priv);
913
914int asoc_simple_remove(struct platform_device *pdev)
915{
916 struct snd_soc_card *card = platform_get_drvdata(pdev);
917
918 asoc_simple_clean_reference(card);
919
920 return 0;
921}
922EXPORT_SYMBOL_GPL(asoc_simple_remove);
923
924int asoc_graph_card_probe(struct snd_soc_card *card)
925{
926 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(card);
927 int ret;
928
929 ret = asoc_simple_init_hp(card, &priv->hp_jack, NULL);
930 if (ret < 0)
931 return ret;
932
933 ret = asoc_simple_init_mic(card, &priv->mic_jack, NULL);
934 if (ret < 0)
935 return ret;
936
937 return 0;
938}
939EXPORT_SYMBOL_GPL(asoc_graph_card_probe);
940
941int asoc_graph_is_ports0(struct device_node *np)
942{
943 struct device_node *port, *ports, *ports0, *top;
944 int ret;
945
946 /* np is "endpoint" or "port" */
947 if (of_node_name_eq(np, "endpoint")) {
948 port = of_get_parent(np);
949 } else {
950 port = np;
951 of_node_get(port);
952 }
953
954 ports = of_get_parent(port);
955 top = of_get_parent(ports);
956 ports0 = of_get_child_by_name(top, "ports");
957
958 ret = ports0 == ports;
959
960 of_node_put(port);
961 of_node_put(ports);
962 of_node_put(ports0);
963 of_node_put(top);
964
965 return ret;
966}
967EXPORT_SYMBOL_GPL(asoc_graph_is_ports0);
968
969/* Module information */
970MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
971MODULE_DESCRIPTION("ALSA SoC Simple Card Utils");
972MODULE_LICENSE("GPL v2");
1// SPDX-License-Identifier: GPL-2.0
2//
3// simple-card-utils.c
4//
5// Copyright (c) 2016 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
6
7#include <linux/clk.h>
8#include <linux/gpio.h>
9#include <linux/gpio/consumer.h>
10#include <linux/module.h>
11#include <linux/of.h>
12#include <linux/of_gpio.h>
13#include <linux/of_graph.h>
14#include <sound/jack.h>
15#include <sound/simple_card_utils.h>
16
17void asoc_simple_convert_fixup(struct asoc_simple_data *data,
18 struct snd_pcm_hw_params *params)
19{
20 struct snd_interval *rate = hw_param_interval(params,
21 SNDRV_PCM_HW_PARAM_RATE);
22 struct snd_interval *channels = hw_param_interval(params,
23 SNDRV_PCM_HW_PARAM_CHANNELS);
24
25 if (data->convert_rate)
26 rate->min =
27 rate->max = data->convert_rate;
28
29 if (data->convert_channels)
30 channels->min =
31 channels->max = data->convert_channels;
32}
33EXPORT_SYMBOL_GPL(asoc_simple_convert_fixup);
34
35void asoc_simple_parse_convert(struct device_node *np,
36 char *prefix,
37 struct asoc_simple_data *data)
38{
39 char prop[128];
40
41 if (!prefix)
42 prefix = "";
43
44 /* sampling rate convert */
45 snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-rate");
46 of_property_read_u32(np, prop, &data->convert_rate);
47
48 /* channels transfer */
49 snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-channels");
50 of_property_read_u32(np, prop, &data->convert_channels);
51}
52EXPORT_SYMBOL_GPL(asoc_simple_parse_convert);
53
54int asoc_simple_parse_daifmt(struct device *dev,
55 struct device_node *node,
56 struct device_node *codec,
57 char *prefix,
58 unsigned int *retfmt)
59{
60 struct device_node *bitclkmaster = NULL;
61 struct device_node *framemaster = NULL;
62 unsigned int daifmt;
63
64 daifmt = snd_soc_daifmt_parse_format(node, prefix);
65
66 snd_soc_daifmt_parse_clock_provider_as_phandle(node, prefix, &bitclkmaster, &framemaster);
67 if (!bitclkmaster && !framemaster) {
68 /*
69 * No dai-link level and master setting was not found from
70 * sound node level, revert back to legacy DT parsing and
71 * take the settings from codec node.
72 */
73 dev_dbg(dev, "Revert to legacy daifmt parsing\n");
74
75 daifmt |= snd_soc_daifmt_parse_clock_provider_as_flag(codec, NULL);
76 } else {
77 daifmt |= snd_soc_daifmt_clock_provider_from_bitmap(
78 ((codec == bitclkmaster) << 4) | (codec == framemaster));
79 }
80
81 of_node_put(bitclkmaster);
82 of_node_put(framemaster);
83
84 *retfmt = daifmt;
85
86 return 0;
87}
88EXPORT_SYMBOL_GPL(asoc_simple_parse_daifmt);
89
90int asoc_simple_set_dailink_name(struct device *dev,
91 struct snd_soc_dai_link *dai_link,
92 const char *fmt, ...)
93{
94 va_list ap;
95 char *name = NULL;
96 int ret = -ENOMEM;
97
98 va_start(ap, fmt);
99 name = devm_kvasprintf(dev, GFP_KERNEL, fmt, ap);
100 va_end(ap);
101
102 if (name) {
103 ret = 0;
104
105 dai_link->name = name;
106 dai_link->stream_name = name;
107 }
108
109 return ret;
110}
111EXPORT_SYMBOL_GPL(asoc_simple_set_dailink_name);
112
113int asoc_simple_parse_card_name(struct snd_soc_card *card,
114 char *prefix)
115{
116 int ret;
117
118 if (!prefix)
119 prefix = "";
120
121 /* Parse the card name from DT */
122 ret = snd_soc_of_parse_card_name(card, "label");
123 if (ret < 0 || !card->name) {
124 char prop[128];
125
126 snprintf(prop, sizeof(prop), "%sname", prefix);
127 ret = snd_soc_of_parse_card_name(card, prop);
128 if (ret < 0)
129 return ret;
130 }
131
132 if (!card->name && card->dai_link)
133 card->name = card->dai_link->name;
134
135 return 0;
136}
137EXPORT_SYMBOL_GPL(asoc_simple_parse_card_name);
138
139static int asoc_simple_clk_enable(struct asoc_simple_dai *dai)
140{
141 if (dai)
142 return clk_prepare_enable(dai->clk);
143
144 return 0;
145}
146
147static void asoc_simple_clk_disable(struct asoc_simple_dai *dai)
148{
149 if (dai)
150 clk_disable_unprepare(dai->clk);
151}
152
153int asoc_simple_parse_clk(struct device *dev,
154 struct device_node *node,
155 struct asoc_simple_dai *simple_dai,
156 struct snd_soc_dai_link_component *dlc)
157{
158 struct clk *clk;
159 u32 val;
160
161 /*
162 * Parse dai->sysclk come from "clocks = <&xxx>"
163 * (if system has common clock)
164 * or "system-clock-frequency = <xxx>"
165 * or device's module clock.
166 */
167 clk = devm_get_clk_from_child(dev, node, NULL);
168 if (!IS_ERR(clk)) {
169 simple_dai->sysclk = clk_get_rate(clk);
170
171 simple_dai->clk = clk;
172 } else if (!of_property_read_u32(node, "system-clock-frequency", &val)) {
173 simple_dai->sysclk = val;
174 } else {
175 clk = devm_get_clk_from_child(dev, dlc->of_node, NULL);
176 if (!IS_ERR(clk))
177 simple_dai->sysclk = clk_get_rate(clk);
178 }
179
180 if (of_property_read_bool(node, "system-clock-direction-out"))
181 simple_dai->clk_direction = SND_SOC_CLOCK_OUT;
182
183 return 0;
184}
185EXPORT_SYMBOL_GPL(asoc_simple_parse_clk);
186
187int asoc_simple_startup(struct snd_pcm_substream *substream)
188{
189 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
190 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
191 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
192 struct asoc_simple_dai *dai;
193 int i1, i2, i;
194 int ret;
195
196 for_each_prop_dai_cpu(props, i1, dai) {
197 ret = asoc_simple_clk_enable(dai);
198 if (ret)
199 goto cpu_err;
200 }
201
202 for_each_prop_dai_codec(props, i2, dai) {
203 ret = asoc_simple_clk_enable(dai);
204 if (ret)
205 goto codec_err;
206 }
207
208 return 0;
209
210codec_err:
211 for_each_prop_dai_codec(props, i, dai) {
212 if (i >= i2)
213 break;
214 asoc_simple_clk_disable(dai);
215 }
216cpu_err:
217 for_each_prop_dai_cpu(props, i, dai) {
218 if (i >= i1)
219 break;
220 asoc_simple_clk_disable(dai);
221 }
222 return ret;
223}
224EXPORT_SYMBOL_GPL(asoc_simple_startup);
225
226void asoc_simple_shutdown(struct snd_pcm_substream *substream)
227{
228 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
229 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
230 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
231 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
232 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
233 struct asoc_simple_dai *dai;
234 int i;
235
236 if (props->mclk_fs) {
237 snd_soc_dai_set_sysclk(codec_dai, 0, 0, SND_SOC_CLOCK_IN);
238 snd_soc_dai_set_sysclk(cpu_dai, 0, 0, SND_SOC_CLOCK_OUT);
239 }
240
241 for_each_prop_dai_cpu(props, i, dai)
242 asoc_simple_clk_disable(dai);
243 for_each_prop_dai_codec(props, i, dai)
244 asoc_simple_clk_disable(dai);
245}
246EXPORT_SYMBOL_GPL(asoc_simple_shutdown);
247
248static int asoc_simple_set_clk_rate(struct asoc_simple_dai *simple_dai,
249 unsigned long rate)
250{
251 if (!simple_dai)
252 return 0;
253
254 if (!simple_dai->clk)
255 return 0;
256
257 if (clk_get_rate(simple_dai->clk) == rate)
258 return 0;
259
260 return clk_set_rate(simple_dai->clk, rate);
261}
262
263int asoc_simple_hw_params(struct snd_pcm_substream *substream,
264 struct snd_pcm_hw_params *params)
265{
266 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
267 struct asoc_simple_dai *pdai;
268 struct snd_soc_dai *sdai;
269 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
270 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
271 unsigned int mclk, mclk_fs = 0;
272 int i, ret;
273
274 if (props->mclk_fs)
275 mclk_fs = props->mclk_fs;
276
277 if (mclk_fs) {
278 mclk = params_rate(params) * mclk_fs;
279
280 for_each_prop_dai_codec(props, i, pdai) {
281 ret = asoc_simple_set_clk_rate(pdai, mclk);
282 if (ret < 0)
283 return ret;
284 }
285 for_each_prop_dai_cpu(props, i, pdai) {
286 ret = asoc_simple_set_clk_rate(pdai, mclk);
287 if (ret < 0)
288 return ret;
289 }
290 for_each_rtd_codec_dais(rtd, i, sdai) {
291 ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_IN);
292 if (ret && ret != -ENOTSUPP)
293 return ret;
294 }
295 for_each_rtd_cpu_dais(rtd, i, sdai) {
296 ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_OUT);
297 if (ret && ret != -ENOTSUPP)
298 return ret;
299 }
300 }
301 return 0;
302}
303EXPORT_SYMBOL_GPL(asoc_simple_hw_params);
304
305int asoc_simple_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
306 struct snd_pcm_hw_params *params)
307{
308 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
309 struct simple_dai_props *dai_props = simple_priv_to_props(priv, rtd->num);
310
311 asoc_simple_convert_fixup(&dai_props->adata, params);
312
313 return 0;
314}
315EXPORT_SYMBOL_GPL(asoc_simple_be_hw_params_fixup);
316
317static int asoc_simple_init_dai(struct snd_soc_dai *dai,
318 struct asoc_simple_dai *simple_dai)
319{
320 int ret;
321
322 if (!simple_dai)
323 return 0;
324
325 if (simple_dai->sysclk) {
326 ret = snd_soc_dai_set_sysclk(dai, 0, simple_dai->sysclk,
327 simple_dai->clk_direction);
328 if (ret && ret != -ENOTSUPP) {
329 dev_err(dai->dev, "simple-card: set_sysclk error\n");
330 return ret;
331 }
332 }
333
334 if (simple_dai->slots) {
335 ret = snd_soc_dai_set_tdm_slot(dai,
336 simple_dai->tx_slot_mask,
337 simple_dai->rx_slot_mask,
338 simple_dai->slots,
339 simple_dai->slot_width);
340 if (ret && ret != -ENOTSUPP) {
341 dev_err(dai->dev, "simple-card: set_tdm_slot error\n");
342 return ret;
343 }
344 }
345
346 return 0;
347}
348
349static int asoc_simple_init_dai_link_params(struct snd_soc_pcm_runtime *rtd,
350 struct simple_dai_props *dai_props)
351{
352 struct snd_soc_dai_link *dai_link = rtd->dai_link;
353 struct snd_soc_component *component;
354 struct snd_soc_pcm_stream *params;
355 struct snd_pcm_hardware hw;
356 int i, ret, stream;
357
358 /* Only codecs should have non_legacy_dai_naming set. */
359 for_each_rtd_components(rtd, i, component) {
360 if (!component->driver->non_legacy_dai_naming)
361 return 0;
362 }
363
364 /* Assumes the capabilities are the same for all supported streams */
365 for_each_pcm_streams(stream) {
366 ret = snd_soc_runtime_calc_hw(rtd, &hw, stream);
367 if (ret == 0)
368 break;
369 }
370
371 if (ret < 0) {
372 dev_err(rtd->dev, "simple-card: no valid dai_link params\n");
373 return ret;
374 }
375
376 params = devm_kzalloc(rtd->dev, sizeof(*params), GFP_KERNEL);
377 if (!params)
378 return -ENOMEM;
379
380 params->formats = hw.formats;
381 params->rates = hw.rates;
382 params->rate_min = hw.rate_min;
383 params->rate_max = hw.rate_max;
384 params->channels_min = hw.channels_min;
385 params->channels_max = hw.channels_max;
386
387 dai_link->params = params;
388 dai_link->num_params = 1;
389
390 return 0;
391}
392
393int asoc_simple_dai_init(struct snd_soc_pcm_runtime *rtd)
394{
395 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
396 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
397 struct asoc_simple_dai *dai;
398 int i, ret;
399
400 for_each_prop_dai_codec(props, i, dai) {
401 ret = asoc_simple_init_dai(asoc_rtd_to_codec(rtd, i), dai);
402 if (ret < 0)
403 return ret;
404 }
405 for_each_prop_dai_cpu(props, i, dai) {
406 ret = asoc_simple_init_dai(asoc_rtd_to_cpu(rtd, i), dai);
407 if (ret < 0)
408 return ret;
409 }
410
411 ret = asoc_simple_init_dai_link_params(rtd, props);
412 if (ret < 0)
413 return ret;
414
415 return 0;
416}
417EXPORT_SYMBOL_GPL(asoc_simple_dai_init);
418
419void asoc_simple_canonicalize_platform(struct snd_soc_dai_link_component *platforms,
420 struct snd_soc_dai_link_component *cpus)
421{
422 /* Assumes platform == cpu */
423 if (!platforms->of_node)
424 platforms->of_node = cpus->of_node;
425}
426EXPORT_SYMBOL_GPL(asoc_simple_canonicalize_platform);
427
428void asoc_simple_canonicalize_cpu(struct snd_soc_dai_link_component *cpus,
429 int is_single_links)
430{
431 /*
432 * In soc_bind_dai_link() will check cpu name after
433 * of_node matching if dai_link has cpu_dai_name.
434 * but, it will never match if name was created by
435 * fmt_single_name() remove cpu_dai_name if cpu_args
436 * was 0. See:
437 * fmt_single_name()
438 * fmt_multiple_name()
439 */
440 if (is_single_links)
441 cpus->dai_name = NULL;
442}
443EXPORT_SYMBOL_GPL(asoc_simple_canonicalize_cpu);
444
445int asoc_simple_clean_reference(struct snd_soc_card *card)
446{
447 struct snd_soc_dai_link *dai_link;
448 struct snd_soc_dai_link_component *cpu;
449 struct snd_soc_dai_link_component *codec;
450 int i, j;
451
452 for_each_card_prelinks(card, i, dai_link) {
453 for_each_link_cpus(dai_link, j, cpu)
454 of_node_put(cpu->of_node);
455 for_each_link_codecs(dai_link, j, codec)
456 of_node_put(codec->of_node);
457 }
458 return 0;
459}
460EXPORT_SYMBOL_GPL(asoc_simple_clean_reference);
461
462int asoc_simple_parse_routing(struct snd_soc_card *card,
463 char *prefix)
464{
465 struct device_node *node = card->dev->of_node;
466 char prop[128];
467
468 if (!prefix)
469 prefix = "";
470
471 snprintf(prop, sizeof(prop), "%s%s", prefix, "routing");
472
473 if (!of_property_read_bool(node, prop))
474 return 0;
475
476 return snd_soc_of_parse_audio_routing(card, prop);
477}
478EXPORT_SYMBOL_GPL(asoc_simple_parse_routing);
479
480int asoc_simple_parse_widgets(struct snd_soc_card *card,
481 char *prefix)
482{
483 struct device_node *node = card->dev->of_node;
484 char prop[128];
485
486 if (!prefix)
487 prefix = "";
488
489 snprintf(prop, sizeof(prop), "%s%s", prefix, "widgets");
490
491 if (of_property_read_bool(node, prop))
492 return snd_soc_of_parse_audio_simple_widgets(card, prop);
493
494 /* no widgets is not error */
495 return 0;
496}
497EXPORT_SYMBOL_GPL(asoc_simple_parse_widgets);
498
499int asoc_simple_parse_pin_switches(struct snd_soc_card *card,
500 char *prefix)
501{
502 const unsigned int nb_controls_max = 16;
503 const char **strings, *control_name;
504 struct snd_kcontrol_new *controls;
505 struct device *dev = card->dev;
506 unsigned int i, nb_controls;
507 char prop[128];
508 int ret;
509
510 if (!prefix)
511 prefix = "";
512
513 snprintf(prop, sizeof(prop), "%s%s", prefix, "pin-switches");
514
515 if (!of_property_read_bool(dev->of_node, prop))
516 return 0;
517
518 strings = devm_kcalloc(dev, nb_controls_max,
519 sizeof(*strings), GFP_KERNEL);
520 if (!strings)
521 return -ENOMEM;
522
523 ret = of_property_read_string_array(dev->of_node, prop,
524 strings, nb_controls_max);
525 if (ret < 0)
526 return ret;
527
528 nb_controls = (unsigned int)ret;
529
530 controls = devm_kcalloc(dev, nb_controls,
531 sizeof(*controls), GFP_KERNEL);
532 if (!controls)
533 return -ENOMEM;
534
535 for (i = 0; i < nb_controls; i++) {
536 control_name = devm_kasprintf(dev, GFP_KERNEL,
537 "%s Switch", strings[i]);
538 if (!control_name)
539 return -ENOMEM;
540
541 controls[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
542 controls[i].name = control_name;
543 controls[i].info = snd_soc_dapm_info_pin_switch;
544 controls[i].get = snd_soc_dapm_get_pin_switch;
545 controls[i].put = snd_soc_dapm_put_pin_switch;
546 controls[i].private_value = (unsigned long)strings[i];
547 }
548
549 card->controls = controls;
550 card->num_controls = nb_controls;
551
552 return 0;
553}
554EXPORT_SYMBOL_GPL(asoc_simple_parse_pin_switches);
555
556int asoc_simple_init_jack(struct snd_soc_card *card,
557 struct asoc_simple_jack *sjack,
558 int is_hp, char *prefix,
559 char *pin)
560{
561 struct device *dev = card->dev;
562 enum of_gpio_flags flags;
563 char prop[128];
564 char *pin_name;
565 char *gpio_name;
566 int mask;
567 int det;
568
569 if (!prefix)
570 prefix = "";
571
572 sjack->gpio.gpio = -ENOENT;
573
574 if (is_hp) {
575 snprintf(prop, sizeof(prop), "%shp-det-gpio", prefix);
576 pin_name = pin ? pin : "Headphones";
577 gpio_name = "Headphone detection";
578 mask = SND_JACK_HEADPHONE;
579 } else {
580 snprintf(prop, sizeof(prop), "%smic-det-gpio", prefix);
581 pin_name = pin ? pin : "Mic Jack";
582 gpio_name = "Mic detection";
583 mask = SND_JACK_MICROPHONE;
584 }
585
586 det = of_get_named_gpio_flags(dev->of_node, prop, 0, &flags);
587 if (det == -EPROBE_DEFER)
588 return -EPROBE_DEFER;
589
590 if (gpio_is_valid(det)) {
591 sjack->pin.pin = pin_name;
592 sjack->pin.mask = mask;
593
594 sjack->gpio.name = gpio_name;
595 sjack->gpio.report = mask;
596 sjack->gpio.gpio = det;
597 sjack->gpio.invert = !!(flags & OF_GPIO_ACTIVE_LOW);
598 sjack->gpio.debounce_time = 150;
599
600 snd_soc_card_jack_new(card, pin_name, mask,
601 &sjack->jack,
602 &sjack->pin, 1);
603
604 snd_soc_jack_add_gpios(&sjack->jack, 1,
605 &sjack->gpio);
606 }
607
608 return 0;
609}
610EXPORT_SYMBOL_GPL(asoc_simple_init_jack);
611
612int asoc_simple_init_priv(struct asoc_simple_priv *priv,
613 struct link_info *li)
614{
615 struct snd_soc_card *card = simple_priv_to_card(priv);
616 struct device *dev = simple_priv_to_dev(priv);
617 struct snd_soc_dai_link *dai_link;
618 struct simple_dai_props *dai_props;
619 struct asoc_simple_dai *dais;
620 struct snd_soc_dai_link_component *dlcs;
621 struct snd_soc_codec_conf *cconf = NULL;
622 int i, dai_num = 0, dlc_num = 0, cnf_num = 0;
623
624 dai_props = devm_kcalloc(dev, li->link, sizeof(*dai_props), GFP_KERNEL);
625 dai_link = devm_kcalloc(dev, li->link, sizeof(*dai_link), GFP_KERNEL);
626 if (!dai_props || !dai_link)
627 return -ENOMEM;
628
629 /*
630 * dais (= CPU+Codec)
631 * dlcs (= CPU+Codec+Platform)
632 */
633 for (i = 0; i < li->link; i++) {
634 int cc = li->num[i].cpus + li->num[i].codecs;
635
636 dai_num += cc;
637 dlc_num += cc + li->num[i].platforms;
638
639 if (!li->num[i].cpus)
640 cnf_num += li->num[i].codecs;
641 }
642
643 dais = devm_kcalloc(dev, dai_num, sizeof(*dais), GFP_KERNEL);
644 dlcs = devm_kcalloc(dev, dlc_num, sizeof(*dai_props), GFP_KERNEL);
645 if (!dais || !dlcs)
646 return -ENOMEM;
647
648 if (cnf_num) {
649 cconf = devm_kcalloc(dev, cnf_num, sizeof(*cconf), GFP_KERNEL);
650 if (!cconf)
651 return -ENOMEM;
652 }
653
654 dev_dbg(dev, "link %d, dais %d, ccnf %d\n",
655 li->link, dai_num, cnf_num);
656
657 /* dummy CPU/Codec */
658 priv->dummy.of_node = NULL;
659 priv->dummy.dai_name = "snd-soc-dummy-dai";
660 priv->dummy.name = "snd-soc-dummy";
661
662 priv->dai_props = dai_props;
663 priv->dai_link = dai_link;
664 priv->dais = dais;
665 priv->dlcs = dlcs;
666 priv->codec_conf = cconf;
667
668 card->dai_link = priv->dai_link;
669 card->num_links = li->link;
670 card->codec_conf = cconf;
671 card->num_configs = cnf_num;
672
673 for (i = 0; i < li->link; i++) {
674 if (li->num[i].cpus) {
675 /* Normal CPU */
676 dai_props[i].cpus =
677 dai_link[i].cpus = dlcs;
678 dai_props[i].num.cpus =
679 dai_link[i].num_cpus = li->num[i].cpus;
680 dai_props[i].cpu_dai = dais;
681
682 dlcs += li->num[i].cpus;
683 dais += li->num[i].cpus;
684 } else {
685 /* DPCM Be's CPU = dummy */
686 dai_props[i].cpus =
687 dai_link[i].cpus = &priv->dummy;
688 dai_props[i].num.cpus =
689 dai_link[i].num_cpus = 1;
690 }
691
692 if (li->num[i].codecs) {
693 /* Normal Codec */
694 dai_props[i].codecs =
695 dai_link[i].codecs = dlcs;
696 dai_props[i].num.codecs =
697 dai_link[i].num_codecs = li->num[i].codecs;
698 dai_props[i].codec_dai = dais;
699
700 dlcs += li->num[i].codecs;
701 dais += li->num[i].codecs;
702
703 if (!li->num[i].cpus) {
704 /* DPCM Be's Codec */
705 dai_props[i].codec_conf = cconf;
706 cconf += li->num[i].codecs;
707 }
708 } else {
709 /* DPCM Fe's Codec = dummy */
710 dai_props[i].codecs =
711 dai_link[i].codecs = &priv->dummy;
712 dai_props[i].num.codecs =
713 dai_link[i].num_codecs = 1;
714 }
715
716 if (li->num[i].platforms) {
717 /* Have Platform */
718 dai_props[i].platforms =
719 dai_link[i].platforms = dlcs;
720 dai_props[i].num.platforms =
721 dai_link[i].num_platforms = li->num[i].platforms;
722
723 dlcs += li->num[i].platforms;
724 } else {
725 /* Doesn't have Platform */
726 dai_props[i].platforms =
727 dai_link[i].platforms = NULL;
728 dai_props[i].num.platforms =
729 dai_link[i].num_platforms = 0;
730 }
731 }
732
733 return 0;
734}
735EXPORT_SYMBOL_GPL(asoc_simple_init_priv);
736
737int asoc_simple_remove(struct platform_device *pdev)
738{
739 struct snd_soc_card *card = platform_get_drvdata(pdev);
740
741 return asoc_simple_clean_reference(card);
742}
743EXPORT_SYMBOL_GPL(asoc_simple_remove);
744
745int asoc_graph_card_probe(struct snd_soc_card *card)
746{
747 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(card);
748 int ret;
749
750 ret = asoc_simple_init_hp(card, &priv->hp_jack, NULL);
751 if (ret < 0)
752 return ret;
753
754 ret = asoc_simple_init_mic(card, &priv->mic_jack, NULL);
755 if (ret < 0)
756 return ret;
757
758 return 0;
759}
760EXPORT_SYMBOL_GPL(asoc_graph_card_probe);
761
762/* Module information */
763MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
764MODULE_DESCRIPTION("ALSA SoC Simple Card Utils");
765MODULE_LICENSE("GPL v2");