1
2
3
4
5
6
7
8#include <linux/slab.h>
9#include <linux/of.h>
10#include <linux/of_graph.h>
11#include <linux/module.h>
12#include <linux/workqueue.h>
13#include <sound/pcm.h>
14#include <sound/soc.h>
15
16#define TEST_NAME_LEN 32
17struct test_dai_name {
18 char name[TEST_NAME_LEN];
19 char name_playback[TEST_NAME_LEN];
20 char name_capture[TEST_NAME_LEN];
21};
22
23struct test_priv {
24 struct device *dev;
25 struct snd_pcm_substream *substream;
26 struct delayed_work dwork;
27 struct snd_soc_component_driver *component_driver;
28 struct snd_soc_dai_driver *dai_driver;
29 struct test_dai_name *name;
30};
31
32struct test_adata {
33 u32 is_cpu:1;
34 u32 cmp_v:1;
35 u32 dai_v:1;
36};
37
38#define mile_stone(d) dev_info((d)->dev, "%s() : %s", __func__, (d)->driver->name)
39#define mile_stone_x(dev) dev_info(dev, "%s()", __func__)
40
41static int test_dai_set_sysclk(struct snd_soc_dai *dai,
42 int clk_id, unsigned int freq, int dir)
43{
44 mile_stone(dai);
45
46 return 0;
47}
48
49static int test_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
50 unsigned int freq_in, unsigned int freq_out)
51{
52 mile_stone(dai);
53
54 return 0;
55}
56
57static int test_dai_set_clkdiv(struct snd_soc_dai *dai, int div_id, int div)
58{
59 mile_stone(dai);
60
61 return 0;
62}
63
64static int test_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
65{
66 unsigned int format = fmt & SND_SOC_DAIFMT_FORMAT_MASK;
67 unsigned int clock = fmt & SND_SOC_DAIFMT_CLOCK_MASK;
68 unsigned int inv = fmt & SND_SOC_DAIFMT_INV_MASK;
69 unsigned int master = fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK;
70 char *str;
71
72 dev_info(dai->dev, "name : %s", dai->name);
73
74 str = "unknown";
75 switch (format) {
76 case SND_SOC_DAIFMT_I2S:
77 str = "i2s";
78 break;
79 case SND_SOC_DAIFMT_RIGHT_J:
80 str = "right_j";
81 break;
82 case SND_SOC_DAIFMT_LEFT_J:
83 str = "left_j";
84 break;
85 case SND_SOC_DAIFMT_DSP_A:
86 str = "dsp_a";
87 break;
88 case SND_SOC_DAIFMT_DSP_B:
89 str = "dsp_b";
90 break;
91 case SND_SOC_DAIFMT_AC97:
92 str = "ac97";
93 break;
94 case SND_SOC_DAIFMT_PDM:
95 str = "pdm";
96 break;
97 }
98 dev_info(dai->dev, "format : %s", str);
99
100 if (clock == SND_SOC_DAIFMT_CONT)
101 str = "continuous";
102 else
103 str = "gated";
104 dev_info(dai->dev, "clock : %s", str);
105
106 str = "unknown";
107 switch (master) {
108 case SND_SOC_DAIFMT_BP_FP:
109 str = "clk provider, frame provider";
110 break;
111 case SND_SOC_DAIFMT_BC_FP:
112 str = "clk consumer, frame provider";
113 break;
114 case SND_SOC_DAIFMT_BP_FC:
115 str = "clk provider, frame consumer";
116 break;
117 case SND_SOC_DAIFMT_BC_FC:
118 str = "clk consumer, frame consumer";
119 break;
120 }
121 dev_info(dai->dev, "clock : codec is %s", str);
122
123 str = "unknown";
124 switch (inv) {
125 case SND_SOC_DAIFMT_NB_NF:
126 str = "normal bit, normal frame";
127 break;
128 case SND_SOC_DAIFMT_NB_IF:
129 str = "normal bit, invert frame";
130 break;
131 case SND_SOC_DAIFMT_IB_NF:
132 str = "invert bit, normal frame";
133 break;
134 case SND_SOC_DAIFMT_IB_IF:
135 str = "invert bit, invert frame";
136 break;
137 }
138 dev_info(dai->dev, "signal : %s", str);
139
140 return 0;
141}
142
143static int test_dai_set_tdm_slot(struct snd_soc_dai *dai,
144 unsigned int tx_mask, unsigned int rx_mask,
145 int slots, int slot_width)
146{
147 dev_info(dai->dev, "set tdm slot: tx_mask=0x%08X, rx_mask=0x%08X, slots=%d, slot_width=%d\n",
148 tx_mask, rx_mask, slots, slot_width);
149 return 0;
150}
151
152static int test_dai_mute_stream(struct snd_soc_dai *dai, int mute, int stream)
153{
154 mile_stone(dai);
155
156 return 0;
157}
158
159static int test_dai_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
160{
161 mile_stone(dai);
162
163 return 0;
164}
165
166static void test_dai_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
167{
168 mile_stone(dai);
169}
170
171static int test_dai_hw_params(struct snd_pcm_substream *substream,
172 struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
173{
174 mile_stone(dai);
175
176 return 0;
177}
178
179static int test_dai_hw_free(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
180{
181 mile_stone(dai);
182
183 return 0;
184}
185
186static int test_dai_trigger(struct snd_pcm_substream *substream, int cmd, struct snd_soc_dai *dai)
187{
188 mile_stone(dai);
189
190 return 0;
191}
192
193static const u64 test_dai_formats =
194
195
196
197
198
199
200
201 SND_SOC_POSSIBLE_DAIFMT_I2S |
202 SND_SOC_POSSIBLE_DAIFMT_RIGHT_J |
203 SND_SOC_POSSIBLE_DAIFMT_LEFT_J |
204 SND_SOC_POSSIBLE_DAIFMT_DSP_A |
205 SND_SOC_POSSIBLE_DAIFMT_DSP_B |
206 SND_SOC_POSSIBLE_DAIFMT_AC97 |
207 SND_SOC_POSSIBLE_DAIFMT_PDM |
208 SND_SOC_POSSIBLE_DAIFMT_NB_NF |
209 SND_SOC_POSSIBLE_DAIFMT_NB_IF |
210 SND_SOC_POSSIBLE_DAIFMT_IB_NF |
211 SND_SOC_POSSIBLE_DAIFMT_IB_IF;
212
213static const struct snd_soc_dai_ops test_ops = {
214 .set_fmt = test_dai_set_fmt,
215 .set_tdm_slot = test_dai_set_tdm_slot,
216 .startup = test_dai_startup,
217 .shutdown = test_dai_shutdown,
218 .auto_selectable_formats = &test_dai_formats,
219 .num_auto_selectable_formats = 1,
220};
221
222static const struct snd_soc_dai_ops test_verbose_ops = {
223 .set_sysclk = test_dai_set_sysclk,
224 .set_pll = test_dai_set_pll,
225 .set_clkdiv = test_dai_set_clkdiv,
226 .set_fmt = test_dai_set_fmt,
227 .set_tdm_slot = test_dai_set_tdm_slot,
228 .mute_stream = test_dai_mute_stream,
229 .startup = test_dai_startup,
230 .shutdown = test_dai_shutdown,
231 .hw_params = test_dai_hw_params,
232 .hw_free = test_dai_hw_free,
233 .trigger = test_dai_trigger,
234 .auto_selectable_formats = &test_dai_formats,
235 .num_auto_selectable_formats = 1,
236};
237
238#define STUB_RATES SNDRV_PCM_RATE_CONTINUOUS
239#define STUB_FORMATS (SNDRV_PCM_FMTBIT_S8 | \
240 SNDRV_PCM_FMTBIT_U8 | \
241 SNDRV_PCM_FMTBIT_S16_LE | \
242 SNDRV_PCM_FMTBIT_U16_LE | \
243 SNDRV_PCM_FMTBIT_S24_LE | \
244 SNDRV_PCM_FMTBIT_S24_3LE | \
245 SNDRV_PCM_FMTBIT_U24_LE | \
246 SNDRV_PCM_FMTBIT_S32_LE | \
247 SNDRV_PCM_FMTBIT_U32_LE)
248
249static int test_component_probe(struct snd_soc_component *component)
250{
251 mile_stone(component);
252
253 return 0;
254}
255
256static void test_component_remove(struct snd_soc_component *component)
257{
258 mile_stone(component);
259}
260
261static int test_component_suspend(struct snd_soc_component *component)
262{
263 mile_stone(component);
264
265 return 0;
266}
267
268static int test_component_resume(struct snd_soc_component *component)
269{
270 mile_stone(component);
271
272 return 0;
273}
274
275#define PREALLOC_BUFFER (32 * 1024)
276static int test_component_pcm_construct(struct snd_soc_component *component,
277 struct snd_soc_pcm_runtime *rtd)
278{
279 mile_stone(component);
280
281 snd_pcm_set_managed_buffer_all(
282 rtd->pcm,
283 SNDRV_DMA_TYPE_DEV,
284 rtd->card->snd_card->dev,
285 PREALLOC_BUFFER, PREALLOC_BUFFER);
286
287 return 0;
288}
289
290static void test_component_pcm_destruct(struct snd_soc_component *component,
291 struct snd_pcm *pcm)
292{
293 mile_stone(component);
294}
295
296static int test_component_set_sysclk(struct snd_soc_component *component,
297 int clk_id, int source, unsigned int freq, int dir)
298{
299 mile_stone(component);
300
301 return 0;
302}
303
304static int test_component_set_pll(struct snd_soc_component *component, int pll_id,
305 int source, unsigned int freq_in, unsigned int freq_out)
306{
307 mile_stone(component);
308
309 return 0;
310}
311
312static int test_component_set_jack(struct snd_soc_component *component,
313 struct snd_soc_jack *jack, void *data)
314{
315 mile_stone(component);
316
317 return 0;
318}
319
320static void test_component_seq_notifier(struct snd_soc_component *component,
321 enum snd_soc_dapm_type type, int subseq)
322{
323 mile_stone(component);
324}
325
326static int test_component_stream_event(struct snd_soc_component *component, int event)
327{
328 mile_stone(component);
329
330 return 0;
331}
332
333static int test_component_set_bias_level(struct snd_soc_component *component,
334 enum snd_soc_bias_level level)
335{
336 mile_stone(component);
337
338 return 0;
339}
340
341static const struct snd_pcm_hardware test_component_hardware = {
342
343 .info = SNDRV_PCM_INFO_INTERLEAVED |
344 SNDRV_PCM_INFO_MMAP |
345 SNDRV_PCM_INFO_MMAP_VALID,
346 .buffer_bytes_max = 32 * 1024,
347 .period_bytes_min = 32,
348 .period_bytes_max = 8192,
349 .periods_min = 1,
350 .periods_max = 128,
351 .fifo_size = 256,
352};
353
354static int test_component_open(struct snd_soc_component *component,
355 struct snd_pcm_substream *substream)
356{
357 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
358
359 mile_stone(component);
360
361
362 if (!rtd->dai_link->no_pcm)
363 snd_soc_set_runtime_hwparams(substream, &test_component_hardware);
364
365 return 0;
366}
367
368static int test_component_close(struct snd_soc_component *component,
369 struct snd_pcm_substream *substream)
370{
371 mile_stone(component);
372
373 return 0;
374}
375
376static int test_component_ioctl(struct snd_soc_component *component,
377 struct snd_pcm_substream *substream,
378 unsigned int cmd, void *arg)
379{
380 mile_stone(component);
381
382 return 0;
383}
384
385static int test_component_hw_params(struct snd_soc_component *component,
386 struct snd_pcm_substream *substream,
387 struct snd_pcm_hw_params *params)
388{
389 mile_stone(component);
390
391 return 0;
392}
393
394static int test_component_hw_free(struct snd_soc_component *component,
395 struct snd_pcm_substream *substream)
396{
397 mile_stone(component);
398
399 return 0;
400}
401
402static int test_component_prepare(struct snd_soc_component *component,
403 struct snd_pcm_substream *substream)
404{
405 mile_stone(component);
406
407 return 0;
408}
409
410static void test_component_timer_stop(struct test_priv *priv)
411{
412 cancel_delayed_work(&priv->dwork);
413}
414
415static void test_component_timer_start(struct test_priv *priv)
416{
417 schedule_delayed_work(&priv->dwork, msecs_to_jiffies(10));
418}
419
420static void test_component_dwork(struct work_struct *work)
421{
422 struct test_priv *priv = container_of(work, struct test_priv, dwork.work);
423
424 if (priv->substream)
425 snd_pcm_period_elapsed(priv->substream);
426
427 test_component_timer_start(priv);
428}
429
430static int test_component_trigger(struct snd_soc_component *component,
431 struct snd_pcm_substream *substream, int cmd)
432{
433 struct test_priv *priv = dev_get_drvdata(component->dev);
434
435 mile_stone(component);
436
437 switch (cmd) {
438 case SNDRV_PCM_TRIGGER_START:
439 test_component_timer_start(priv);
440 priv->substream = substream;
441 break;
442 case SNDRV_PCM_TRIGGER_STOP:
443 priv->substream = NULL;
444 test_component_timer_stop(priv);
445 }
446
447 return 0;
448}
449
450static int test_component_sync_stop(struct snd_soc_component *component,
451 struct snd_pcm_substream *substream)
452{
453 mile_stone(component);
454
455 return 0;
456}
457
458static snd_pcm_uframes_t test_component_pointer(struct snd_soc_component *component,
459 struct snd_pcm_substream *substream)
460{
461 struct snd_pcm_runtime *runtime = substream->runtime;
462 static int pointer;
463
464 if (!runtime)
465 return 0;
466
467 pointer += 10;
468 if (pointer > PREALLOC_BUFFER)
469 pointer = 0;
470
471
472
473 return bytes_to_frames(runtime, pointer);
474}
475
476static int test_component_get_time_info(struct snd_soc_component *component,
477 struct snd_pcm_substream *substream,
478 struct timespec64 *system_ts,
479 struct timespec64 *audio_ts,
480 struct snd_pcm_audio_tstamp_config *audio_tstamp_config,
481 struct snd_pcm_audio_tstamp_report *audio_tstamp_report)
482{
483 mile_stone(component);
484
485 return 0;
486}
487
488static int test_component_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
489 struct snd_pcm_hw_params *params)
490{
491 mile_stone_x(rtd->dev);
492
493 return 0;
494}
495
496
497static const struct test_adata test_cpu = { .is_cpu = 1, .cmp_v = 0, .dai_v = 0, };
498static const struct test_adata test_cpu_vv = { .is_cpu = 1, .cmp_v = 1, .dai_v = 1, };
499static const struct test_adata test_cpu_nv = { .is_cpu = 1, .cmp_v = 0, .dai_v = 1, };
500static const struct test_adata test_cpu_vn = { .is_cpu = 1, .cmp_v = 1, .dai_v = 0, };
501
502static const struct test_adata test_codec = { .is_cpu = 0, .cmp_v = 0, .dai_v = 0, };
503static const struct test_adata test_codec_vv = { .is_cpu = 0, .cmp_v = 1, .dai_v = 1, };
504static const struct test_adata test_codec_nv = { .is_cpu = 0, .cmp_v = 0, .dai_v = 1, };
505static const struct test_adata test_codec_vn = { .is_cpu = 0, .cmp_v = 1, .dai_v = 0, };
506
507static const struct of_device_id test_of_match[] = {
508 { .compatible = "test-cpu", .data = (void *)&test_cpu, },
509 { .compatible = "test-cpu-verbose", .data = (void *)&test_cpu_vv, },
510 { .compatible = "test-cpu-verbose-dai", .data = (void *)&test_cpu_nv, },
511 { .compatible = "test-cpu-verbose-component", .data = (void *)&test_cpu_vn, },
512 { .compatible = "test-codec", .data = (void *)&test_codec, },
513 { .compatible = "test-codec-verbose", .data = (void *)&test_codec_vv, },
514 { .compatible = "test-codec-verbose-dai", .data = (void *)&test_codec_nv, },
515 { .compatible = "test-codec-verbose-component", .data = (void *)&test_codec_vn, },
516 {},
517};
518MODULE_DEVICE_TABLE(of, test_of_match);
519
520static const struct snd_soc_dapm_widget widgets[] = {
521
522
523
524
525
526
527 SND_SOC_DAPM_INPUT("IN"),
528 SND_SOC_DAPM_OUTPUT("OUT"),
529};
530
531static int test_driver_probe(struct platform_device *pdev)
532{
533 struct device *dev = &pdev->dev;
534 struct device_node *node = dev->of_node;
535 const struct test_adata *adata = of_device_get_match_data(&pdev->dev);
536 struct snd_soc_component_driver *cdriv;
537 struct snd_soc_dai_driver *ddriv;
538 struct test_dai_name *dname;
539 struct test_priv *priv;
540 int num, ret, i;
541
542 num = of_graph_get_endpoint_count(node);
543 if (!num) {
544 dev_err(dev, "no port exits\n");
545 return -EINVAL;
546 }
547
548 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
549 cdriv = devm_kzalloc(dev, sizeof(*cdriv), GFP_KERNEL);
550 ddriv = devm_kzalloc(dev, sizeof(*ddriv) * num, GFP_KERNEL);
551 dname = devm_kzalloc(dev, sizeof(*dname) * num, GFP_KERNEL);
552 if (!priv || !cdriv || !ddriv || !dname || !adata)
553 return -EINVAL;
554
555 priv->dev = dev;
556 priv->component_driver = cdriv;
557 priv->dai_driver = ddriv;
558 priv->name = dname;
559
560 INIT_DELAYED_WORK(&priv->dwork, test_component_dwork);
561 dev_set_drvdata(dev, priv);
562
563 if (adata->is_cpu) {
564 cdriv->name = "test_cpu";
565 cdriv->pcm_construct = test_component_pcm_construct;
566 cdriv->pointer = test_component_pointer;
567 cdriv->trigger = test_component_trigger;
568 cdriv->legacy_dai_naming = 1;
569 } else {
570 cdriv->name = "test_codec";
571 cdriv->idle_bias_on = 1;
572 cdriv->endianness = 1;
573 }
574
575 cdriv->open = test_component_open;
576 cdriv->dapm_widgets = widgets;
577 cdriv->num_dapm_widgets = ARRAY_SIZE(widgets);
578
579 if (adata->cmp_v) {
580 cdriv->probe = test_component_probe;
581 cdriv->remove = test_component_remove;
582 cdriv->suspend = test_component_suspend;
583 cdriv->resume = test_component_resume;
584 cdriv->set_sysclk = test_component_set_sysclk;
585 cdriv->set_pll = test_component_set_pll;
586 cdriv->set_jack = test_component_set_jack;
587 cdriv->seq_notifier = test_component_seq_notifier;
588 cdriv->stream_event = test_component_stream_event;
589 cdriv->set_bias_level = test_component_set_bias_level;
590 cdriv->close = test_component_close;
591 cdriv->ioctl = test_component_ioctl;
592 cdriv->hw_params = test_component_hw_params;
593 cdriv->hw_free = test_component_hw_free;
594 cdriv->prepare = test_component_prepare;
595 cdriv->sync_stop = test_component_sync_stop;
596 cdriv->get_time_info = test_component_get_time_info;
597 cdriv->be_hw_params_fixup = test_component_be_hw_params_fixup;
598
599 if (adata->is_cpu)
600 cdriv->pcm_destruct = test_component_pcm_destruct;
601 }
602
603 i = 0;
604 for_each_of_graph_port(node, port) {
605 snprintf(dname[i].name, TEST_NAME_LEN, "%s.%d", node->name, i);
606 ddriv[i].name = dname[i].name;
607
608 snprintf(dname[i].name_playback, TEST_NAME_LEN, "DAI%d Playback", i);
609 ddriv[i].playback.stream_name = dname[i].name_playback;
610 ddriv[i].playback.channels_min = 1;
611 ddriv[i].playback.channels_max = 384;
612 ddriv[i].playback.rates = STUB_RATES;
613 ddriv[i].playback.formats = STUB_FORMATS;
614
615 snprintf(dname[i].name_capture, TEST_NAME_LEN, "DAI%d Capture", i);
616 ddriv[i].capture.stream_name = dname[i].name_capture;
617 ddriv[i].capture.channels_min = 1;
618 ddriv[i].capture.channels_max = 384;
619 ddriv[i].capture.rates = STUB_RATES;
620 ddriv[i].capture.formats = STUB_FORMATS;
621
622 if (adata->dai_v)
623 ddriv[i].ops = &test_verbose_ops;
624 else
625 ddriv[i].ops = &test_ops;
626
627 i++;
628 }
629
630 ret = devm_snd_soc_register_component(dev, cdriv, ddriv, num);
631 if (ret < 0)
632 return ret;
633
634 mile_stone_x(dev);
635
636 return 0;
637}
638
639static void test_driver_remove(struct platform_device *pdev)
640{
641 mile_stone_x(&pdev->dev);
642}
643
644static struct platform_driver test_driver = {
645 .driver = {
646 .name = "test-component",
647 .of_match_table = test_of_match,
648 },
649 .probe = test_driver_probe,
650 .remove = test_driver_remove,
651};
652module_platform_driver(test_driver);
653
654MODULE_ALIAS("platform:asoc-test-component");
655MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
656MODULE_DESCRIPTION("ASoC Test Component");
657MODULE_LICENSE("GPL v2");
658
