1
2
3
4
5
6
7
8#include <linux/pm_runtime.h>
9#include <sound/soc.h>
10#include <sound/pcm_params.h>
11#include <uapi/sound/tlv.h>
12#include "core.h"
13#include "messages.h"
14
15struct catpt_stream_template {
16 enum catpt_path_id path_id;
17 enum catpt_stream_type type;
18 u32 persistent_size;
19 u8 num_entries;
20 struct catpt_module_entry entries[];
21};
22
23static struct catpt_stream_template system_pb = {
24 .path_id = CATPT_PATH_SSP0_OUT,
25 .type = CATPT_STRM_TYPE_SYSTEM,
26 .num_entries = 1,
27 .entries = {{ CATPT_MODID_PCM_SYSTEM, 0 }},
28};
29
30static struct catpt_stream_template system_cp = {
31 .path_id = CATPT_PATH_SSP0_IN,
32 .type = CATPT_STRM_TYPE_CAPTURE,
33 .num_entries = 1,
34 .entries = {{ CATPT_MODID_PCM_CAPTURE, 0 }},
35};
36
37static struct catpt_stream_template offload_pb = {
38 .path_id = CATPT_PATH_SSP0_OUT,
39 .type = CATPT_STRM_TYPE_RENDER,
40 .num_entries = 1,
41 .entries = {{ CATPT_MODID_PCM, 0 }},
42};
43
44static struct catpt_stream_template loopback_cp = {
45 .path_id = CATPT_PATH_SSP0_OUT,
46 .type = CATPT_STRM_TYPE_LOOPBACK,
47 .num_entries = 1,
48 .entries = {{ CATPT_MODID_PCM_REFERENCE, 0 }},
49};
50
51static struct catpt_stream_template bluetooth_pb = {
52 .path_id = CATPT_PATH_SSP1_OUT,
53 .type = CATPT_STRM_TYPE_BLUETOOTH_RENDER,
54 .num_entries = 1,
55 .entries = {{ CATPT_MODID_BLUETOOTH_RENDER, 0 }},
56};
57
58static struct catpt_stream_template bluetooth_cp = {
59 .path_id = CATPT_PATH_SSP1_IN,
60 .type = CATPT_STRM_TYPE_BLUETOOTH_CAPTURE,
61 .num_entries = 1,
62 .entries = {{ CATPT_MODID_BLUETOOTH_CAPTURE, 0 }},
63};
64
65static struct catpt_stream_template *catpt_topology[] = {
66 [CATPT_STRM_TYPE_RENDER] = &offload_pb,
67 [CATPT_STRM_TYPE_SYSTEM] = &system_pb,
68 [CATPT_STRM_TYPE_CAPTURE] = &system_cp,
69 [CATPT_STRM_TYPE_LOOPBACK] = &loopback_cp,
70 [CATPT_STRM_TYPE_BLUETOOTH_RENDER] = &bluetooth_pb,
71 [CATPT_STRM_TYPE_BLUETOOTH_CAPTURE] = &bluetooth_cp,
72};
73
74static struct catpt_stream_template *
75catpt_get_stream_template(struct snd_pcm_substream *substream)
76{
77 struct snd_soc_pcm_runtime *rtm = substream->private_data;
78 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtm, 0);
79 enum catpt_stream_type type;
80
81 type = cpu_dai->driver->id;
82
83
84 switch (type) {
85 case CATPT_STRM_TYPE_SYSTEM:
86 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
87 type = CATPT_STRM_TYPE_CAPTURE;
88 break;
89 case CATPT_STRM_TYPE_BLUETOOTH_RENDER:
90 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
91 type = CATPT_STRM_TYPE_BLUETOOTH_CAPTURE;
92 break;
93 default:
94 break;
95 }
96
97 return catpt_topology[type];
98}
99
100struct catpt_stream_runtime *
101catpt_stream_find(struct catpt_dev *cdev, u8 stream_hw_id)
102{
103 struct catpt_stream_runtime *pos, *result = NULL;
104
105 spin_lock(&cdev->list_lock);
106 list_for_each_entry(pos, &cdev->stream_list, node) {
107 if (pos->info.stream_hw_id == stream_hw_id) {
108 result = pos;
109 break;
110 }
111 }
112
113 spin_unlock(&cdev->list_lock);
114 return result;
115}
116
117static u32 catpt_stream_read_position(struct catpt_dev *cdev,
118 struct catpt_stream_runtime *stream)
119{
120 u32 pos;
121
122 memcpy_fromio(&pos, cdev->lpe_ba + stream->info.read_pos_regaddr,
123 sizeof(pos));
124 return pos;
125}
126
127static u32 catpt_stream_volume(struct catpt_dev *cdev,
128 struct catpt_stream_runtime *stream, u32 channel)
129{
130 u32 volume, offset;
131
132 if (channel >= CATPT_CHANNELS_MAX)
133 channel = 0;
134
135 offset = stream->info.volume_regaddr[channel];
136 memcpy_fromio(&volume, cdev->lpe_ba + offset, sizeof(volume));
137 return volume;
138}
139
140static u32 catpt_mixer_volume(struct catpt_dev *cdev,
141 struct catpt_mixer_stream_info *info, u32 channel)
142{
143 u32 volume, offset;
144
145 if (channel >= CATPT_CHANNELS_MAX)
146 channel = 0;
147
148 offset = info->volume_regaddr[channel];
149 memcpy_fromio(&volume, cdev->lpe_ba + offset, sizeof(volume));
150 return volume;
151}
152
153static void catpt_arrange_page_table(struct snd_pcm_substream *substream,
154 struct snd_dma_buffer *pgtbl)
155{
156 struct snd_pcm_runtime *rtm = substream->runtime;
157 struct snd_dma_buffer *databuf = snd_pcm_get_dma_buf(substream);
158 int i, pages;
159
160 pages = snd_sgbuf_aligned_pages(rtm->dma_bytes);
161
162 for (i = 0; i < pages; i++) {
163 u32 pfn, offset;
164 u32 *page_table;
165
166 pfn = PFN_DOWN(snd_sgbuf_get_addr(databuf, i * PAGE_SIZE));
167
168 offset = ((i << 2) + i) >> 1;
169 page_table = (u32 *)(pgtbl->area + offset);
170
171 if (i & 1)
172 *page_table |= (pfn << 4);
173 else
174 *page_table |= pfn;
175 }
176}
177
178static u32 catpt_get_channel_map(enum catpt_channel_config config)
179{
180 switch (config) {
181 case CATPT_CHANNEL_CONFIG_MONO:
182 return GENMASK(31, 4) | CATPT_CHANNEL_CENTER;
183
184 case CATPT_CHANNEL_CONFIG_STEREO:
185 return GENMASK(31, 8) | CATPT_CHANNEL_LEFT
186 | (CATPT_CHANNEL_RIGHT << 4);
187
188 case CATPT_CHANNEL_CONFIG_2_POINT_1:
189 return GENMASK(31, 12) | CATPT_CHANNEL_LEFT
190 | (CATPT_CHANNEL_RIGHT << 4)
191 | (CATPT_CHANNEL_LFE << 8);
192
193 case CATPT_CHANNEL_CONFIG_3_POINT_0:
194 return GENMASK(31, 12) | CATPT_CHANNEL_LEFT
195 | (CATPT_CHANNEL_CENTER << 4)
196 | (CATPT_CHANNEL_RIGHT << 8);
197
198 case CATPT_CHANNEL_CONFIG_3_POINT_1:
199 return GENMASK(31, 16) | CATPT_CHANNEL_LEFT
200 | (CATPT_CHANNEL_CENTER << 4)
201 | (CATPT_CHANNEL_RIGHT << 8)
202 | (CATPT_CHANNEL_LFE << 12);
203
204 case CATPT_CHANNEL_CONFIG_QUATRO:
205 return GENMASK(31, 16) | CATPT_CHANNEL_LEFT
206 | (CATPT_CHANNEL_RIGHT << 4)
207 | (CATPT_CHANNEL_LEFT_SURROUND << 8)
208 | (CATPT_CHANNEL_RIGHT_SURROUND << 12);
209
210 case CATPT_CHANNEL_CONFIG_4_POINT_0:
211 return GENMASK(31, 16) | CATPT_CHANNEL_LEFT
212 | (CATPT_CHANNEL_CENTER << 4)
213 | (CATPT_CHANNEL_RIGHT << 8)
214 | (CATPT_CHANNEL_CENTER_SURROUND << 12);
215
216 case CATPT_CHANNEL_CONFIG_5_POINT_0:
217 return GENMASK(31, 20) | CATPT_CHANNEL_LEFT
218 | (CATPT_CHANNEL_CENTER << 4)
219 | (CATPT_CHANNEL_RIGHT << 8)
220 | (CATPT_CHANNEL_LEFT_SURROUND << 12)
221 | (CATPT_CHANNEL_RIGHT_SURROUND << 16);
222
223 case CATPT_CHANNEL_CONFIG_5_POINT_1:
224 return GENMASK(31, 24) | CATPT_CHANNEL_CENTER
225 | (CATPT_CHANNEL_LEFT << 4)
226 | (CATPT_CHANNEL_RIGHT << 8)
227 | (CATPT_CHANNEL_LEFT_SURROUND << 12)
228 | (CATPT_CHANNEL_RIGHT_SURROUND << 16)
229 | (CATPT_CHANNEL_LFE << 20);
230
231 case CATPT_CHANNEL_CONFIG_DUAL_MONO:
232 return GENMASK(31, 8) | CATPT_CHANNEL_LEFT
233 | (CATPT_CHANNEL_LEFT << 4);
234
235 default:
236 return U32_MAX;
237 }
238}
239
240static enum catpt_channel_config catpt_get_channel_config(u32 num_channels)
241{
242 switch (num_channels) {
243 case 6:
244 return CATPT_CHANNEL_CONFIG_5_POINT_1;
245 case 5:
246 return CATPT_CHANNEL_CONFIG_5_POINT_0;
247 case 4:
248 return CATPT_CHANNEL_CONFIG_QUATRO;
249 case 3:
250 return CATPT_CHANNEL_CONFIG_2_POINT_1;
251 case 1:
252 return CATPT_CHANNEL_CONFIG_MONO;
253 case 2:
254 default:
255 return CATPT_CHANNEL_CONFIG_STEREO;
256 }
257}
258
259static int catpt_dai_startup(struct snd_pcm_substream *substream,
260 struct snd_soc_dai *dai)
261{
262 struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
263 struct catpt_stream_template *template;
264 struct catpt_stream_runtime *stream;
265 struct resource *res;
266 int ret;
267
268 template = catpt_get_stream_template(substream);
269
270 stream = kzalloc(sizeof(*stream), GFP_KERNEL);
271 if (!stream)
272 return -ENOMEM;
273
274 ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, cdev->dev, PAGE_SIZE,
275 &stream->pgtbl);
276 if (ret)
277 goto err_pgtbl;
278
279 res = catpt_request_region(&cdev->dram, template->persistent_size);
280 if (!res) {
281 ret = -EBUSY;
282 goto err_request;
283 }
284
285 catpt_dsp_update_srampge(cdev, &cdev->dram, cdev->spec->dram_mask);
286
287 stream->template = template;
288 stream->persistent = res;
289 stream->substream = substream;
290 INIT_LIST_HEAD(&stream->node);
291 snd_soc_dai_set_dma_data(dai, substream, stream);
292
293 spin_lock(&cdev->list_lock);
294 list_add_tail(&stream->node, &cdev->stream_list);
295 spin_unlock(&cdev->list_lock);
296
297 return 0;
298
299err_request:
300 snd_dma_free_pages(&stream->pgtbl);
301err_pgtbl:
302 kfree(stream);
303 return ret;
304}
305
306static void catpt_dai_shutdown(struct snd_pcm_substream *substream,
307 struct snd_soc_dai *dai)
308{
309 struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
310 struct catpt_stream_runtime *stream;
311
312 stream = snd_soc_dai_get_dma_data(dai, substream);
313
314 spin_lock(&cdev->list_lock);
315 list_del(&stream->node);
316 spin_unlock(&cdev->list_lock);
317
318 release_resource(stream->persistent);
319 kfree(stream->persistent);
320 catpt_dsp_update_srampge(cdev, &cdev->dram, cdev->spec->dram_mask);
321
322 snd_dma_free_pages(&stream->pgtbl);
323 kfree(stream);
324 snd_soc_dai_set_dma_data(dai, substream, NULL);
325}
326
327static int catpt_set_dspvol(struct catpt_dev *cdev, u8 stream_id, long *ctlvol);
328
329static int catpt_dai_apply_usettings(struct snd_soc_dai *dai,
330 struct catpt_stream_runtime *stream)
331{
332 struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
333 struct snd_soc_component *component = dai->component;
334 struct snd_kcontrol *pos;
335 const char *name;
336 int ret;
337 u32 id = stream->info.stream_hw_id;
338
339
340 switch (id) {
341 case CATPT_PIN_ID_OFFLOAD1:
342 name = "Media0 Playback Volume";
343 break;
344 case CATPT_PIN_ID_OFFLOAD2:
345 name = "Media1 Playback Volume";
346 break;
347 case CATPT_PIN_ID_CAPTURE1:
348 name = "Mic Capture Volume";
349 break;
350 case CATPT_PIN_ID_REFERENCE:
351 name = "Loopback Mute";
352 break;
353 default:
354 return 0;
355 }
356
357 list_for_each_entry(pos, &component->card->snd_card->controls, list) {
358 if (pos->private_data == component &&
359 !strncmp(name, pos->id.name, sizeof(pos->id.name)))
360 break;
361 }
362 if (list_entry_is_head(pos, &component->card->snd_card->controls, list))
363 return -ENOENT;
364
365 if (stream->template->type != CATPT_STRM_TYPE_LOOPBACK)
366 return catpt_set_dspvol(cdev, id, (long *)pos->private_value);
367 ret = catpt_ipc_mute_loopback(cdev, id, *(bool *)pos->private_value);
368 if (ret)
369 return CATPT_IPC_ERROR(ret);
370 return 0;
371}
372
373static int catpt_dai_hw_params(struct snd_pcm_substream *substream,
374 struct snd_pcm_hw_params *params,
375 struct snd_soc_dai *dai)
376{
377 struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
378 struct catpt_stream_runtime *stream;
379 struct catpt_audio_format afmt;
380 struct catpt_ring_info rinfo;
381 struct snd_pcm_runtime *rtm = substream->runtime;
382 struct snd_dma_buffer *dmab;
383 int ret;
384
385 stream = snd_soc_dai_get_dma_data(dai, substream);
386 if (stream->allocated)
387 return 0;
388
389 memset(&afmt, 0, sizeof(afmt));
390 afmt.sample_rate = params_rate(params);
391 afmt.bit_depth = params_physical_width(params);
392 afmt.valid_bit_depth = params_width(params);
393 afmt.num_channels = params_channels(params);
394 afmt.channel_config = catpt_get_channel_config(afmt.num_channels);
395 afmt.channel_map = catpt_get_channel_map(afmt.channel_config);
396 afmt.interleaving = CATPT_INTERLEAVING_PER_CHANNEL;
397
398 dmab = snd_pcm_get_dma_buf(substream);
399 catpt_arrange_page_table(substream, &stream->pgtbl);
400
401 memset(&rinfo, 0, sizeof(rinfo));
402 rinfo.page_table_addr = stream->pgtbl.addr;
403 rinfo.num_pages = DIV_ROUND_UP(rtm->dma_bytes, PAGE_SIZE);
404 rinfo.size = rtm->dma_bytes;
405 rinfo.offset = 0;
406 rinfo.ring_first_page_pfn = PFN_DOWN(snd_sgbuf_get_addr(dmab, 0));
407
408 ret = catpt_ipc_alloc_stream(cdev, stream->template->path_id,
409 stream->template->type,
410 &afmt, &rinfo,
411 stream->template->num_entries,
412 stream->template->entries,
413 stream->persistent,
414 cdev->scratch,
415 &stream->info);
416 if (ret)
417 return CATPT_IPC_ERROR(ret);
418
419 ret = catpt_dai_apply_usettings(dai, stream);
420 if (ret)
421 return ret;
422
423 stream->allocated = true;
424 return 0;
425}
426
427static int catpt_dai_hw_free(struct snd_pcm_substream *substream,
428 struct snd_soc_dai *dai)
429{
430 struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
431 struct catpt_stream_runtime *stream;
432
433 stream = snd_soc_dai_get_dma_data(dai, substream);
434 if (!stream->allocated)
435 return 0;
436
437 catpt_ipc_reset_stream(cdev, stream->info.stream_hw_id);
438 catpt_ipc_free_stream(cdev, stream->info.stream_hw_id);
439
440 stream->allocated = false;
441 return 0;
442}
443
444static int catpt_dai_prepare(struct snd_pcm_substream *substream,
445 struct snd_soc_dai *dai)
446{
447 struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
448 struct catpt_stream_runtime *stream;
449 int ret;
450
451 stream = snd_soc_dai_get_dma_data(dai, substream);
452 if (stream->prepared)
453 return 0;
454
455 ret = catpt_ipc_reset_stream(cdev, stream->info.stream_hw_id);
456 if (ret)
457 return CATPT_IPC_ERROR(ret);
458
459 ret = catpt_ipc_pause_stream(cdev, stream->info.stream_hw_id);
460 if (ret)
461 return CATPT_IPC_ERROR(ret);
462
463 stream->prepared = true;
464 return 0;
465}
466
467static int catpt_dai_trigger(struct snd_pcm_substream *substream, int cmd,
468 struct snd_soc_dai *dai)
469{
470 struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
471 struct catpt_stream_runtime *stream;
472 struct snd_pcm_runtime *runtime = substream->runtime;
473 snd_pcm_uframes_t pos;
474 int ret;
475
476 stream = snd_soc_dai_get_dma_data(dai, substream);
477
478 switch (cmd) {
479 case SNDRV_PCM_TRIGGER_START:
480
481 if (stream->template->type != CATPT_STRM_TYPE_RENDER)
482 goto resume_stream;
483
484 pos = frames_to_bytes(runtime, runtime->start_threshold);
485
486
487
488
489 ret = catpt_ipc_set_write_pos(cdev, stream->info.stream_hw_id,
490 pos, false, false);
491 if (ret)
492 return CATPT_IPC_ERROR(ret);
493 fallthrough;
494 case SNDRV_PCM_TRIGGER_RESUME:
495 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
496 resume_stream:
497 catpt_dsp_update_lpclock(cdev);
498 ret = catpt_ipc_resume_stream(cdev, stream->info.stream_hw_id);
499 if (ret)
500 return CATPT_IPC_ERROR(ret);
501 break;
502
503 case SNDRV_PCM_TRIGGER_STOP:
504 stream->prepared = false;
505 fallthrough;
506 case SNDRV_PCM_TRIGGER_SUSPEND:
507 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
508 ret = catpt_ipc_pause_stream(cdev, stream->info.stream_hw_id);
509 catpt_dsp_update_lpclock(cdev);
510 if (ret)
511 return CATPT_IPC_ERROR(ret);
512 break;
513
514 default:
515 break;
516 }
517
518 return 0;
519}
520
521void catpt_stream_update_position(struct catpt_dev *cdev,
522 struct catpt_stream_runtime *stream,
523 struct catpt_notify_position *pos)
524{
525 struct snd_pcm_substream *substream = stream->substream;
526 struct snd_pcm_runtime *r = substream->runtime;
527 snd_pcm_uframes_t dsppos, newpos;
528 int ret;
529
530 dsppos = bytes_to_frames(r, pos->stream_position);
531
532 if (!stream->prepared)
533 goto exit;
534
535 if (stream->template->type != CATPT_STRM_TYPE_RENDER)
536 goto exit;
537
538 if (dsppos >= r->buffer_size / 2)
539 newpos = r->buffer_size / 2;
540 else
541 newpos = 0;
542
543
544
545
546 ret = catpt_ipc_set_write_pos(cdev, stream->info.stream_hw_id,
547 frames_to_bytes(r, newpos),
548 false, false);
549 if (ret) {
550 dev_err(cdev->dev, "update position for stream %d failed: %d\n",
551 stream->info.stream_hw_id, ret);
552 return;
553 }
554exit:
555 snd_pcm_period_elapsed(substream);
556}
557
558
559#define CATPT_BUFFER_MAX_SIZE 76800
560#define CATPT_PCM_PERIODS_MAX 4
561#define CATPT_PCM_PERIODS_MIN 2
562
563static const struct snd_pcm_hardware catpt_pcm_hardware = {
564 .info = SNDRV_PCM_INFO_MMAP |
565 SNDRV_PCM_INFO_MMAP_VALID |
566 SNDRV_PCM_INFO_INTERLEAVED |
567 SNDRV_PCM_INFO_PAUSE |
568 SNDRV_PCM_INFO_RESUME |
569 SNDRV_PCM_INFO_NO_PERIOD_WAKEUP,
570 .formats = SNDRV_PCM_FMTBIT_S16_LE |
571 SNDRV_PCM_FMTBIT_S24_LE |
572 SNDRV_PCM_FMTBIT_S32_LE,
573 .period_bytes_min = PAGE_SIZE,
574 .period_bytes_max = CATPT_BUFFER_MAX_SIZE / CATPT_PCM_PERIODS_MIN,
575 .periods_min = CATPT_PCM_PERIODS_MIN,
576 .periods_max = CATPT_PCM_PERIODS_MAX,
577 .buffer_bytes_max = CATPT_BUFFER_MAX_SIZE,
578};
579
580static int catpt_component_pcm_construct(struct snd_soc_component *component,
581 struct snd_soc_pcm_runtime *rtm)
582{
583 struct catpt_dev *cdev = dev_get_drvdata(component->dev);
584
585 snd_pcm_set_managed_buffer_all(rtm->pcm, SNDRV_DMA_TYPE_DEV_SG,
586 cdev->dev,
587 catpt_pcm_hardware.buffer_bytes_max,
588 catpt_pcm_hardware.buffer_bytes_max);
589
590 return 0;
591}
592
593static int catpt_component_open(struct snd_soc_component *component,
594 struct snd_pcm_substream *substream)
595{
596 struct snd_soc_pcm_runtime *rtm = substream->private_data;
597
598 if (rtm->dai_link->no_pcm)
599 return 0;
600 snd_soc_set_runtime_hwparams(substream, &catpt_pcm_hardware);
601 return 0;
602}
603
604static snd_pcm_uframes_t
605catpt_component_pointer(struct snd_soc_component *component,
606 struct snd_pcm_substream *substream)
607{
608 struct catpt_dev *cdev = dev_get_drvdata(component->dev);
609 struct catpt_stream_runtime *stream;
610 struct snd_soc_pcm_runtime *rtm = substream->private_data;
611 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtm, 0);
612 u32 pos;
613
614 if (rtm->dai_link->no_pcm)
615 return 0;
616
617 stream = snd_soc_dai_get_dma_data(cpu_dai, substream);
618 pos = catpt_stream_read_position(cdev, stream);
619
620 return bytes_to_frames(substream->runtime, pos);
621}
622
623static const struct snd_soc_dai_ops catpt_fe_dai_ops = {
624 .startup = catpt_dai_startup,
625 .shutdown = catpt_dai_shutdown,
626 .hw_params = catpt_dai_hw_params,
627 .hw_free = catpt_dai_hw_free,
628 .prepare = catpt_dai_prepare,
629 .trigger = catpt_dai_trigger,
630};
631
632static int catpt_dai_pcm_new(struct snd_soc_pcm_runtime *rtm,
633 struct snd_soc_dai *dai)
634{
635 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtm, 0);
636 struct catpt_dev *cdev = dev_get_drvdata(dai->dev);
637 struct catpt_ssp_device_format devfmt;
638 int ret;
639
640 devfmt.iface = dai->driver->id;
641 devfmt.channels = codec_dai->driver->capture.channels_max;
642
643 switch (devfmt.iface) {
644 case CATPT_SSP_IFACE_0:
645 devfmt.mclk = CATPT_MCLK_FREQ_24_MHZ;
646
647 switch (devfmt.channels) {
648 case 4:
649 devfmt.mode = CATPT_SSP_MODE_TDM_PROVIDER;
650 devfmt.clock_divider = 4;
651 break;
652 case 2:
653 default:
654 devfmt.mode = CATPT_SSP_MODE_I2S_PROVIDER;
655 devfmt.clock_divider = 9;
656 break;
657 }
658 break;
659
660 case CATPT_SSP_IFACE_1:
661 devfmt.mclk = CATPT_MCLK_OFF;
662 devfmt.mode = CATPT_SSP_MODE_I2S_CONSUMER;
663 devfmt.clock_divider = 0;
664 break;
665 }
666
667
668 if (!memcmp(&cdev->devfmt[devfmt.iface], &devfmt, sizeof(devfmt)))
669 return 0;
670
671 pm_runtime_get_sync(cdev->dev);
672
673 ret = catpt_ipc_set_device_format(cdev, &devfmt);
674
675 pm_runtime_mark_last_busy(cdev->dev);
676 pm_runtime_put_autosuspend(cdev->dev);
677
678 if (ret)
679 return CATPT_IPC_ERROR(ret);
680
681
682 memcpy(&cdev->devfmt[devfmt.iface], &devfmt, sizeof(devfmt));
683 return 0;
684}
685
686static struct snd_soc_dai_driver dai_drivers[] = {
687
688{
689 .name = "System Pin",
690 .id = CATPT_STRM_TYPE_SYSTEM,
691 .ops = &catpt_fe_dai_ops,
692 .playback = {
693 .stream_name = "System Playback",
694 .channels_min = 2,
695 .channels_max = 2,
696 .rates = SNDRV_PCM_RATE_48000,
697 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
698 },
699 .capture = {
700 .stream_name = "Analog Capture",
701 .channels_min = 2,
702 .channels_max = 4,
703 .rates = SNDRV_PCM_RATE_48000,
704 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
705 },
706},
707{
708 .name = "Offload0 Pin",
709 .id = CATPT_STRM_TYPE_RENDER,
710 .ops = &catpt_fe_dai_ops,
711 .playback = {
712 .stream_name = "Offload0 Playback",
713 .channels_min = 2,
714 .channels_max = 2,
715 .rates = SNDRV_PCM_RATE_8000_192000,
716 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
717 },
718},
719{
720 .name = "Offload1 Pin",
721 .id = CATPT_STRM_TYPE_RENDER,
722 .ops = &catpt_fe_dai_ops,
723 .playback = {
724 .stream_name = "Offload1 Playback",
725 .channels_min = 2,
726 .channels_max = 2,
727 .rates = SNDRV_PCM_RATE_8000_192000,
728 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
729 },
730},
731{
732 .name = "Loopback Pin",
733 .id = CATPT_STRM_TYPE_LOOPBACK,
734 .ops = &catpt_fe_dai_ops,
735 .capture = {
736 .stream_name = "Loopback Capture",
737 .channels_min = 2,
738 .channels_max = 2,
739 .rates = SNDRV_PCM_RATE_48000,
740 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
741 },
742},
743{
744 .name = "Bluetooth Pin",
745 .id = CATPT_STRM_TYPE_BLUETOOTH_RENDER,
746 .ops = &catpt_fe_dai_ops,
747 .playback = {
748 .stream_name = "Bluetooth Playback",
749 .channels_min = 1,
750 .channels_max = 1,
751 .rates = SNDRV_PCM_RATE_8000,
752 .formats = SNDRV_PCM_FMTBIT_S16_LE,
753 },
754 .capture = {
755 .stream_name = "Bluetooth Capture",
756 .channels_min = 1,
757 .channels_max = 1,
758 .rates = SNDRV_PCM_RATE_8000,
759 .formats = SNDRV_PCM_FMTBIT_S16_LE,
760 },
761},
762
763{
764 .name = "ssp0-port",
765 .id = CATPT_SSP_IFACE_0,
766 .pcm_new = catpt_dai_pcm_new,
767 .playback = {
768 .channels_min = 1,
769 .channels_max = 8,
770 },
771 .capture = {
772 .channels_min = 1,
773 .channels_max = 8,
774 },
775},
776{
777 .name = "ssp1-port",
778 .id = CATPT_SSP_IFACE_1,
779 .pcm_new = catpt_dai_pcm_new,
780 .playback = {
781 .channels_min = 1,
782 .channels_max = 8,
783 },
784 .capture = {
785 .channels_min = 1,
786 .channels_max = 8,
787 },
788},
789};
790
791#define DSP_VOLUME_MAX S32_MAX
792#define DSP_VOLUME_STEP_MAX 30
793
794static u32 ctlvol_to_dspvol(u32 value)
795{
796 if (value > DSP_VOLUME_STEP_MAX)
797 value = 0;
798 return DSP_VOLUME_MAX >> (DSP_VOLUME_STEP_MAX - value);
799}
800
801static u32 dspvol_to_ctlvol(u32 volume)
802{
803 if (volume > DSP_VOLUME_MAX)
804 return DSP_VOLUME_STEP_MAX;
805 return volume ? __fls(volume) : 0;
806}
807
808static int catpt_set_dspvol(struct catpt_dev *cdev, u8 stream_id, long *ctlvol)
809{
810 u32 dspvol;
811 int ret, i;
812
813 for (i = 1; i < CATPT_CHANNELS_MAX; i++)
814 if (ctlvol[i] != ctlvol[0])
815 break;
816
817 if (i == CATPT_CHANNELS_MAX) {
818 dspvol = ctlvol_to_dspvol(ctlvol[0]);
819
820 ret = catpt_ipc_set_volume(cdev, stream_id,
821 CATPT_ALL_CHANNELS_MASK, dspvol,
822 0, CATPT_AUDIO_CURVE_NONE);
823 } else {
824 for (i = 0; i < CATPT_CHANNELS_MAX; i++) {
825 dspvol = ctlvol_to_dspvol(ctlvol[i]);
826
827 ret = catpt_ipc_set_volume(cdev, stream_id,
828 i, dspvol,
829 0, CATPT_AUDIO_CURVE_NONE);
830 if (ret)
831 break;
832 }
833 }
834
835 if (ret)
836 return CATPT_IPC_ERROR(ret);
837 return 0;
838}
839
840static int catpt_volume_info(struct snd_kcontrol *kcontrol,
841 struct snd_ctl_elem_info *uinfo)
842{
843 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
844 uinfo->count = CATPT_CHANNELS_MAX;
845 uinfo->value.integer.min = 0;
846 uinfo->value.integer.max = DSP_VOLUME_STEP_MAX;
847 return 0;
848}
849
850static int catpt_mixer_volume_get(struct snd_kcontrol *kcontrol,
851 struct snd_ctl_elem_value *ucontrol)
852{
853 struct snd_soc_component *component =
854 snd_soc_kcontrol_component(kcontrol);
855 struct catpt_dev *cdev = dev_get_drvdata(component->dev);
856 u32 dspvol;
857 int i;
858
859 pm_runtime_get_sync(cdev->dev);
860
861 for (i = 0; i < CATPT_CHANNELS_MAX; i++) {
862 dspvol = catpt_mixer_volume(cdev, &cdev->mixer, i);
863 ucontrol->value.integer.value[i] = dspvol_to_ctlvol(dspvol);
864 }
865
866 pm_runtime_mark_last_busy(cdev->dev);
867 pm_runtime_put_autosuspend(cdev->dev);
868
869 return 0;
870}
871
872static int catpt_mixer_volume_put(struct snd_kcontrol *kcontrol,
873 struct snd_ctl_elem_value *ucontrol)
874{
875 struct snd_soc_component *component =
876 snd_soc_kcontrol_component(kcontrol);
877 struct catpt_dev *cdev = dev_get_drvdata(component->dev);
878 int ret;
879
880 pm_runtime_get_sync(cdev->dev);
881
882 ret = catpt_set_dspvol(cdev, cdev->mixer.mixer_hw_id,
883 ucontrol->value.integer.value);
884
885 pm_runtime_mark_last_busy(cdev->dev);
886 pm_runtime_put_autosuspend(cdev->dev);
887
888 return ret;
889}
890
891static int catpt_stream_volume_get(struct snd_kcontrol *kcontrol,
892 struct snd_ctl_elem_value *ucontrol,
893 enum catpt_pin_id pin_id)
894{
895 struct snd_soc_component *component =
896 snd_soc_kcontrol_component(kcontrol);
897 struct catpt_dev *cdev = dev_get_drvdata(component->dev);
898 struct catpt_stream_runtime *stream;
899 long *ctlvol = (long *)kcontrol->private_value;
900 u32 dspvol;
901 int i;
902
903 stream = catpt_stream_find(cdev, pin_id);
904 if (!stream) {
905 for (i = 0; i < CATPT_CHANNELS_MAX; i++)
906 ucontrol->value.integer.value[i] = ctlvol[i];
907 return 0;
908 }
909
910 pm_runtime_get_sync(cdev->dev);
911
912 for (i = 0; i < CATPT_CHANNELS_MAX; i++) {
913 dspvol = catpt_stream_volume(cdev, stream, i);
914 ucontrol->value.integer.value[i] = dspvol_to_ctlvol(dspvol);
915 }
916
917 pm_runtime_mark_last_busy(cdev->dev);
918 pm_runtime_put_autosuspend(cdev->dev);
919
920 return 0;
921}
922
923static int catpt_stream_volume_put(struct snd_kcontrol *kcontrol,
924 struct snd_ctl_elem_value *ucontrol,
925 enum catpt_pin_id pin_id)
926{
927 struct snd_soc_component *component =
928 snd_soc_kcontrol_component(kcontrol);
929 struct catpt_dev *cdev = dev_get_drvdata(component->dev);
930 struct catpt_stream_runtime *stream;
931 long *ctlvol = (long *)kcontrol->private_value;
932 int ret, i;
933
934 stream = catpt_stream_find(cdev, pin_id);
935 if (!stream) {
936 for (i = 0; i < CATPT_CHANNELS_MAX; i++)
937 ctlvol[i] = ucontrol->value.integer.value[i];
938 return 0;
939 }
940
941 pm_runtime_get_sync(cdev->dev);
942
943 ret = catpt_set_dspvol(cdev, stream->info.stream_hw_id,
944 ucontrol->value.integer.value);
945
946 pm_runtime_mark_last_busy(cdev->dev);
947 pm_runtime_put_autosuspend(cdev->dev);
948
949 if (ret)
950 return ret;
951
952 for (i = 0; i < CATPT_CHANNELS_MAX; i++)
953 ctlvol[i] = ucontrol->value.integer.value[i];
954 return 0;
955}
956
957static int catpt_offload1_volume_get(struct snd_kcontrol *kctl,
958 struct snd_ctl_elem_value *uctl)
959{
960 return catpt_stream_volume_get(kctl, uctl, CATPT_PIN_ID_OFFLOAD1);
961}
962
963static int catpt_offload1_volume_put(struct snd_kcontrol *kctl,
964 struct snd_ctl_elem_value *uctl)
965{
966 return catpt_stream_volume_put(kctl, uctl, CATPT_PIN_ID_OFFLOAD1);
967}
968
969static int catpt_offload2_volume_get(struct snd_kcontrol *kctl,
970 struct snd_ctl_elem_value *uctl)
971{
972 return catpt_stream_volume_get(kctl, uctl, CATPT_PIN_ID_OFFLOAD2);
973}
974
975static int catpt_offload2_volume_put(struct snd_kcontrol *kctl,
976 struct snd_ctl_elem_value *uctl)
977{
978 return catpt_stream_volume_put(kctl, uctl, CATPT_PIN_ID_OFFLOAD2);
979}
980
981static int catpt_capture_volume_get(struct snd_kcontrol *kctl,
982 struct snd_ctl_elem_value *uctl)
983{
984 return catpt_stream_volume_get(kctl, uctl, CATPT_PIN_ID_CAPTURE1);
985}
986
987static int catpt_capture_volume_put(struct snd_kcontrol *kctl,
988 struct snd_ctl_elem_value *uctl)
989{
990 return catpt_stream_volume_put(kctl, uctl, CATPT_PIN_ID_CAPTURE1);
991}
992
993static int catpt_loopback_switch_get(struct snd_kcontrol *kcontrol,
994 struct snd_ctl_elem_value *ucontrol)
995{
996 ucontrol->value.integer.value[0] = *(bool *)kcontrol->private_value;
997 return 0;
998}
999
1000static int catpt_loopback_switch_put(struct snd_kcontrol *kcontrol,
1001 struct snd_ctl_elem_value *ucontrol)
1002{
1003 struct snd_soc_component *component =
1004 snd_soc_kcontrol_component(kcontrol);
1005 struct catpt_dev *cdev = dev_get_drvdata(component->dev);
1006 struct catpt_stream_runtime *stream;
1007 bool mute;
1008 int ret;
1009
1010 mute = (bool)ucontrol->value.integer.value[0];
1011 stream = catpt_stream_find(cdev, CATPT_PIN_ID_REFERENCE);
1012 if (!stream) {
1013 *(bool *)kcontrol->private_value = mute;
1014 return 0;
1015 }
1016
1017 pm_runtime_get_sync(cdev->dev);
1018
1019 ret = catpt_ipc_mute_loopback(cdev, stream->info.stream_hw_id, mute);
1020
1021 pm_runtime_mark_last_busy(cdev->dev);
1022 pm_runtime_put_autosuspend(cdev->dev);
1023
1024 if (ret)
1025 return CATPT_IPC_ERROR(ret);
1026
1027 *(bool *)kcontrol->private_value = mute;
1028 return 0;
1029}
1030
1031static int catpt_waves_switch_get(struct snd_kcontrol *kcontrol,
1032 struct snd_ctl_elem_value *ucontrol)
1033{
1034 return 0;
1035}
1036
1037static int catpt_waves_switch_put(struct snd_kcontrol *kcontrol,
1038 struct snd_ctl_elem_value *ucontrol)
1039{
1040 return 0;
1041}
1042
1043static int catpt_waves_param_get(struct snd_kcontrol *kcontrol,
1044 unsigned int __user *bytes,
1045 unsigned int size)
1046{
1047 return 0;
1048}
1049
1050static int catpt_waves_param_put(struct snd_kcontrol *kcontrol,
1051 const unsigned int __user *bytes,
1052 unsigned int size)
1053{
1054 return 0;
1055}
1056
1057static const SNDRV_CTL_TLVD_DECLARE_DB_SCALE(catpt_volume_tlv, -9000, 300, 1);
1058
1059#define CATPT_VOLUME_CTL(kname, sname) \
1060{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1061 .name = (kname), \
1062 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1063 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1064 .info = catpt_volume_info, \
1065 .get = catpt_##sname##_volume_get, \
1066 .put = catpt_##sname##_volume_put, \
1067 .tlv.p = catpt_volume_tlv, \
1068 .private_value = (unsigned long) \
1069 &(long[CATPT_CHANNELS_MAX]) {0} }
1070
1071static const struct snd_kcontrol_new component_kcontrols[] = {
1072
1073CATPT_VOLUME_CTL("Master Playback Volume", mixer),
1074
1075CATPT_VOLUME_CTL("Media0 Playback Volume", offload1),
1076CATPT_VOLUME_CTL("Media1 Playback Volume", offload2),
1077CATPT_VOLUME_CTL("Mic Capture Volume", capture),
1078SOC_SINGLE_BOOL_EXT("Loopback Mute", (unsigned long)&(bool[1]) {0},
1079 catpt_loopback_switch_get, catpt_loopback_switch_put),
1080
1081SOC_SINGLE_BOOL_EXT("Waves Switch", 0,
1082 catpt_waves_switch_get, catpt_waves_switch_put),
1083
1084SND_SOC_BYTES_TLV("Waves Set Param", 128,
1085 catpt_waves_param_get, catpt_waves_param_put),
1086};
1087
1088static const struct snd_soc_dapm_widget component_widgets[] = {
1089 SND_SOC_DAPM_AIF_IN("SSP0 CODEC IN", NULL, 0, SND_SOC_NOPM, 0, 0),
1090 SND_SOC_DAPM_AIF_OUT("SSP0 CODEC OUT", NULL, 0, SND_SOC_NOPM, 0, 0),
1091 SND_SOC_DAPM_AIF_IN("SSP1 BT IN", NULL, 0, SND_SOC_NOPM, 0, 0),
1092 SND_SOC_DAPM_AIF_OUT("SSP1 BT OUT", NULL, 0, SND_SOC_NOPM, 0, 0),
1093
1094 SND_SOC_DAPM_MIXER("Playback VMixer", SND_SOC_NOPM, 0, 0, NULL, 0),
1095};
1096
1097static const struct snd_soc_dapm_route component_routes[] = {
1098 {"Playback VMixer", NULL, "System Playback"},
1099 {"Playback VMixer", NULL, "Offload0 Playback"},
1100 {"Playback VMixer", NULL, "Offload1 Playback"},
1101
1102 {"SSP0 CODEC OUT", NULL, "Playback VMixer"},
1103
1104 {"Analog Capture", NULL, "SSP0 CODEC IN"},
1105 {"Loopback Capture", NULL, "SSP0 CODEC IN"},
1106
1107 {"SSP1 BT OUT", NULL, "Bluetooth Playback"},
1108 {"Bluetooth Capture", NULL, "SSP1 BT IN"},
1109};
1110
1111static const struct snd_soc_component_driver catpt_comp_driver = {
1112 .name = "catpt-platform",
1113
1114 .pcm_construct = catpt_component_pcm_construct,
1115 .open = catpt_component_open,
1116 .pointer = catpt_component_pointer,
1117
1118 .controls = component_kcontrols,
1119 .num_controls = ARRAY_SIZE(component_kcontrols),
1120 .dapm_widgets = component_widgets,
1121 .num_dapm_widgets = ARRAY_SIZE(component_widgets),
1122 .dapm_routes = component_routes,
1123 .num_dapm_routes = ARRAY_SIZE(component_routes),
1124};
1125
1126int catpt_arm_stream_templates(struct catpt_dev *cdev)
1127{
1128 struct resource *res;
1129 u32 scratch_size = 0;
1130 int i, j;
1131
1132 for (i = 0; i < ARRAY_SIZE(catpt_topology); i++) {
1133 struct catpt_stream_template *template;
1134 struct catpt_module_entry *entry;
1135 struct catpt_module_type *type;
1136
1137 template = catpt_topology[i];
1138 template->persistent_size = 0;
1139
1140 for (j = 0; j < template->num_entries; j++) {
1141 entry = &template->entries[j];
1142 type = &cdev->modules[entry->module_id];
1143
1144 if (!type->loaded)
1145 return -ENOENT;
1146
1147 entry->entry_point = type->entry_point;
1148 template->persistent_size += type->persistent_size;
1149 if (type->scratch_size > scratch_size)
1150 scratch_size = type->scratch_size;
1151 }
1152 }
1153
1154 if (scratch_size) {
1155
1156 res = catpt_request_region(&cdev->dram, scratch_size);
1157 if (!res)
1158 return -EBUSY;
1159 cdev->scratch = res;
1160 }
1161
1162 return 0;
1163}
1164
1165int catpt_register_plat_component(struct catpt_dev *cdev)
1166{
1167 struct snd_soc_component *component;
1168 int ret;
1169
1170 component = devm_kzalloc(cdev->dev, sizeof(*component), GFP_KERNEL);
1171 if (!component)
1172 return -ENOMEM;
1173
1174 ret = snd_soc_component_initialize(component, &catpt_comp_driver,
1175 cdev->dev);
1176 if (ret)
1177 return ret;
1178
1179 component->name = catpt_comp_driver.name;
1180 return snd_soc_add_component(component, dai_drivers,
1181 ARRAY_SIZE(dai_drivers));
1182}
1183
