1
2
3
4
5
6
7
8
9
10
11
12
13
14#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15
16#include <linux/module.h>
17#include <linux/printk.h>
18#include <linux/kernel.h>
19#include <linux/init.h>
20#include <sound/core.h>
21#include <sound/pcm.h>
22#include <sound/pcm_params.h>
23#include <linux/sched.h>
24#include <linux/kthread.h>
25#include <mostcore.h>
26
27#define DRIVER_NAME "sound"
28
29static struct list_head dev_list;
30static struct most_aim audio_aim;
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47struct channel {
48 struct snd_pcm_substream *substream;
49 struct snd_pcm_hardware pcm_hardware;
50 struct most_interface *iface;
51 struct most_channel_config *cfg;
52 struct snd_card *card;
53 struct list_head list;
54 int id;
55 unsigned int period_pos;
56 unsigned int buffer_pos;
57 bool is_stream_running;
58
59 struct task_struct *playback_task;
60 wait_queue_head_t playback_waitq;
61
62 void (*copy_fn)(void *alsa, void *most, unsigned int bytes);
63};
64
65#define MOST_PCM_INFO (SNDRV_PCM_INFO_MMAP | \
66 SNDRV_PCM_INFO_MMAP_VALID | \
67 SNDRV_PCM_INFO_BATCH | \
68 SNDRV_PCM_INFO_INTERLEAVED | \
69 SNDRV_PCM_INFO_BLOCK_TRANSFER)
70
71#define swap16(val) ( \
72 (((u16)(val) << 8) & (u16)0xFF00) | \
73 (((u16)(val) >> 8) & (u16)0x00FF))
74
75#define swap32(val) ( \
76 (((u32)(val) << 24) & (u32)0xFF000000) | \
77 (((u32)(val) << 8) & (u32)0x00FF0000) | \
78 (((u32)(val) >> 8) & (u32)0x0000FF00) | \
79 (((u32)(val) >> 24) & (u32)0x000000FF))
80
81static void swap_copy16(u16 *dest, const u16 *source, unsigned int bytes)
82{
83 unsigned int i = 0;
84
85 while (i < (bytes / 2)) {
86 dest[i] = swap16(source[i]);
87 i++;
88 }
89}
90
91static void swap_copy24(u8 *dest, const u8 *source, unsigned int bytes)
92{
93 unsigned int i = 0;
94
95 while (i < bytes - 2) {
96 dest[i] = source[i + 2];
97 dest[i + 1] = source[i + 1];
98 dest[i + 2] = source[i];
99 i += 3;
100 }
101}
102
103static void swap_copy32(u32 *dest, const u32 *source, unsigned int bytes)
104{
105 unsigned int i = 0;
106
107 while (i < bytes / 4) {
108 dest[i] = swap32(source[i]);
109 i++;
110 }
111}
112
113static void alsa_to_most_memcpy(void *alsa, void *most, unsigned int bytes)
114{
115 memcpy(most, alsa, bytes);
116}
117
118static void alsa_to_most_copy16(void *alsa, void *most, unsigned int bytes)
119{
120 swap_copy16(most, alsa, bytes);
121}
122
123static void alsa_to_most_copy24(void *alsa, void *most, unsigned int bytes)
124{
125 swap_copy24(most, alsa, bytes);
126}
127
128static void alsa_to_most_copy32(void *alsa, void *most, unsigned int bytes)
129{
130 swap_copy32(most, alsa, bytes);
131}
132
133static void most_to_alsa_memcpy(void *alsa, void *most, unsigned int bytes)
134{
135 memcpy(alsa, most, bytes);
136}
137
138static void most_to_alsa_copy16(void *alsa, void *most, unsigned int bytes)
139{
140 swap_copy16(alsa, most, bytes);
141}
142
143static void most_to_alsa_copy24(void *alsa, void *most, unsigned int bytes)
144{
145 swap_copy24(alsa, most, bytes);
146}
147
148static void most_to_alsa_copy32(void *alsa, void *most, unsigned int bytes)
149{
150 swap_copy32(alsa, most, bytes);
151}
152
153
154
155
156
157
158
159
160
161
162
163static struct channel *get_channel(struct most_interface *iface,
164 int channel_id)
165{
166 struct channel *channel, *tmp;
167
168 list_for_each_entry_safe(channel, tmp, &dev_list, list) {
169 if ((channel->iface == iface) && (channel->id == channel_id))
170 return channel;
171 }
172
173 return NULL;
174}
175
176
177
178
179
180
181
182
183static bool copy_data(struct channel *channel, struct mbo *mbo)
184{
185 struct snd_pcm_runtime *const runtime = channel->substream->runtime;
186 unsigned int const frame_bytes = channel->cfg->subbuffer_size;
187 unsigned int const buffer_size = runtime->buffer_size;
188 unsigned int frames;
189 unsigned int fr0;
190
191 if (channel->cfg->direction & MOST_CH_RX)
192 frames = mbo->processed_length / frame_bytes;
193 else
194 frames = mbo->buffer_length / frame_bytes;
195 fr0 = min(buffer_size - channel->buffer_pos, frames);
196
197 channel->copy_fn(runtime->dma_area + channel->buffer_pos * frame_bytes,
198 mbo->virt_address,
199 fr0 * frame_bytes);
200
201 if (frames > fr0) {
202
203 channel->copy_fn(runtime->dma_area,
204 mbo->virt_address + fr0 * frame_bytes,
205 (frames - fr0) * frame_bytes);
206 }
207
208 channel->buffer_pos += frames;
209 if (channel->buffer_pos >= buffer_size)
210 channel->buffer_pos -= buffer_size;
211 channel->period_pos += frames;
212 if (channel->period_pos >= runtime->period_size) {
213 channel->period_pos -= runtime->period_size;
214 return true;
215 }
216
217 return false;
218}
219
220
221
222
223
224
225
226
227
228
229
230static int playback_thread(void *data)
231{
232 struct channel *const channel = data;
233
234 while (!kthread_should_stop()) {
235 struct mbo *mbo = NULL;
236 bool period_elapsed = false;
237 int ret;
238
239 wait_event_interruptible(
240 channel->playback_waitq,
241 kthread_should_stop() ||
242 (channel->is_stream_running &&
243 (mbo = most_get_mbo(channel->iface, channel->id,
244 &audio_aim))));
245 if (!mbo)
246 continue;
247
248 if (channel->is_stream_running)
249 period_elapsed = copy_data(channel, mbo);
250 else
251 memset(mbo->virt_address, 0, mbo->buffer_length);
252
253 ret = most_submit_mbo(mbo);
254 if (ret)
255 channel->is_stream_running = false;
256
257 if (period_elapsed)
258 snd_pcm_period_elapsed(channel->substream);
259 }
260
261 return 0;
262}
263
264
265
266
267
268
269
270
271
272
273static int pcm_open(struct snd_pcm_substream *substream)
274{
275 struct channel *channel = substream->private_data;
276 struct snd_pcm_runtime *runtime = substream->runtime;
277 struct most_channel_config *cfg = channel->cfg;
278
279 channel->substream = substream;
280
281 if (cfg->direction == MOST_CH_TX) {
282 channel->playback_task = kthread_run(playback_thread, channel,
283 "most_audio_playback");
284 if (IS_ERR(channel->playback_task)) {
285 pr_err("Couldn't start thread\n");
286 return PTR_ERR(channel->playback_task);
287 }
288 }
289
290 if (most_start_channel(channel->iface, channel->id, &audio_aim)) {
291 pr_err("most_start_channel() failed!\n");
292 if (cfg->direction == MOST_CH_TX)
293 kthread_stop(channel->playback_task);
294 return -EBUSY;
295 }
296
297 runtime->hw = channel->pcm_hardware;
298 return 0;
299}
300
301
302
303
304
305
306
307
308
309
310
311static int pcm_close(struct snd_pcm_substream *substream)
312{
313 struct channel *channel = substream->private_data;
314
315 if (channel->cfg->direction == MOST_CH_TX)
316 kthread_stop(channel->playback_task);
317 most_stop_channel(channel->iface, channel->id, &audio_aim);
318
319 return 0;
320}
321
322
323
324
325
326
327
328
329
330
331
332
333
334static int pcm_hw_params(struct snd_pcm_substream *substream,
335 struct snd_pcm_hw_params *hw_params)
336{
337 struct channel *channel = substream->private_data;
338
339 if ((params_channels(hw_params) > channel->pcm_hardware.channels_max) ||
340 (params_channels(hw_params) < channel->pcm_hardware.channels_min)) {
341 pr_err("Requested number of channels not supported.\n");
342 return -EINVAL;
343 }
344 return snd_pcm_lib_alloc_vmalloc_buffer(substream,
345 params_buffer_bytes(hw_params));
346}
347
348
349
350
351
352
353
354
355
356
357static int pcm_hw_free(struct snd_pcm_substream *substream)
358{
359 return snd_pcm_lib_free_vmalloc_buffer(substream);
360}
361
362
363
364
365
366
367
368
369
370
371static int pcm_prepare(struct snd_pcm_substream *substream)
372{
373 struct channel *channel = substream->private_data;
374 struct snd_pcm_runtime *runtime = substream->runtime;
375 struct most_channel_config *cfg = channel->cfg;
376 int width = snd_pcm_format_physical_width(runtime->format);
377
378 channel->copy_fn = NULL;
379
380 if (cfg->direction == MOST_CH_TX) {
381 if (snd_pcm_format_big_endian(runtime->format) || width == 8)
382 channel->copy_fn = alsa_to_most_memcpy;
383 else if (width == 16)
384 channel->copy_fn = alsa_to_most_copy16;
385 else if (width == 24)
386 channel->copy_fn = alsa_to_most_copy24;
387 else if (width == 32)
388 channel->copy_fn = alsa_to_most_copy32;
389 } else {
390 if (snd_pcm_format_big_endian(runtime->format) || width == 8)
391 channel->copy_fn = most_to_alsa_memcpy;
392 else if (width == 16)
393 channel->copy_fn = most_to_alsa_copy16;
394 else if (width == 24)
395 channel->copy_fn = most_to_alsa_copy24;
396 else if (width == 32)
397 channel->copy_fn = most_to_alsa_copy32;
398 }
399
400 if (!channel->copy_fn) {
401 pr_err("unsupported format\n");
402 return -EINVAL;
403 }
404
405 channel->period_pos = 0;
406 channel->buffer_pos = 0;
407
408 return 0;
409}
410
411
412
413
414
415
416
417
418
419
420
421static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
422{
423 struct channel *channel = substream->private_data;
424
425 switch (cmd) {
426 case SNDRV_PCM_TRIGGER_START:
427 channel->is_stream_running = true;
428 wake_up_interruptible(&channel->playback_waitq);
429 return 0;
430
431 case SNDRV_PCM_TRIGGER_STOP:
432 channel->is_stream_running = false;
433 return 0;
434
435 default:
436 pr_info("pcm_trigger(), invalid\n");
437 return -EINVAL;
438 }
439 return 0;
440}
441
442
443
444
445
446
447
448
449
450static snd_pcm_uframes_t pcm_pointer(struct snd_pcm_substream *substream)
451{
452 struct channel *channel = substream->private_data;
453
454 return channel->buffer_pos;
455}
456
457
458
459
460static struct snd_pcm_ops pcm_ops = {
461 .open = pcm_open,
462 .close = pcm_close,
463 .ioctl = snd_pcm_lib_ioctl,
464 .hw_params = pcm_hw_params,
465 .hw_free = pcm_hw_free,
466 .prepare = pcm_prepare,
467 .trigger = pcm_trigger,
468 .pointer = pcm_pointer,
469 .page = snd_pcm_lib_get_vmalloc_page,
470 .mmap = snd_pcm_lib_mmap_vmalloc,
471};
472
473static int split_arg_list(char *buf, char **card_name, char **pcm_format)
474{
475 *card_name = strsep(&buf, ".");
476 if (!*card_name)
477 return -EIO;
478 *pcm_format = strsep(&buf, ".\n");
479 if (!*pcm_format)
480 return -EIO;
481 return 0;
482}
483
484static int audio_set_hw_params(struct snd_pcm_hardware *pcm_hw,
485 char *pcm_format,
486 struct most_channel_config *cfg)
487{
488 pcm_hw->info = MOST_PCM_INFO;
489 pcm_hw->rates = SNDRV_PCM_RATE_48000;
490 pcm_hw->rate_min = 48000;
491 pcm_hw->rate_max = 48000;
492 pcm_hw->buffer_bytes_max = cfg->num_buffers * cfg->buffer_size;
493 pcm_hw->period_bytes_min = cfg->buffer_size;
494 pcm_hw->period_bytes_max = cfg->buffer_size;
495 pcm_hw->periods_min = 1;
496 pcm_hw->periods_max = cfg->num_buffers;
497
498 if (!strcmp(pcm_format, "1x8")) {
499 if (cfg->subbuffer_size != 1)
500 goto error;
501 pr_info("PCM format is 8-bit mono\n");
502 pcm_hw->channels_min = 1;
503 pcm_hw->channels_max = 1;
504 pcm_hw->formats = SNDRV_PCM_FMTBIT_S8;
505 } else if (!strcmp(pcm_format, "2x16")) {
506 if (cfg->subbuffer_size != 4)
507 goto error;
508 pr_info("PCM format is 16-bit stereo\n");
509 pcm_hw->channels_min = 2;
510 pcm_hw->channels_max = 2;
511 pcm_hw->formats = SNDRV_PCM_FMTBIT_S16_LE |
512 SNDRV_PCM_FMTBIT_S16_BE;
513 } else if (!strcmp(pcm_format, "2x24")) {
514 if (cfg->subbuffer_size != 6)
515 goto error;
516 pr_info("PCM format is 24-bit stereo\n");
517 pcm_hw->channels_min = 2;
518 pcm_hw->channels_max = 2;
519 pcm_hw->formats = SNDRV_PCM_FMTBIT_S24_3LE |
520 SNDRV_PCM_FMTBIT_S24_3BE;
521 } else if (!strcmp(pcm_format, "2x32")) {
522 if (cfg->subbuffer_size != 8)
523 goto error;
524 pr_info("PCM format is 32-bit stereo\n");
525 pcm_hw->channels_min = 2;
526 pcm_hw->channels_max = 2;
527 pcm_hw->formats = SNDRV_PCM_FMTBIT_S32_LE |
528 SNDRV_PCM_FMTBIT_S32_BE;
529 } else if (!strcmp(pcm_format, "6x16")) {
530 if (cfg->subbuffer_size != 12)
531 goto error;
532 pr_info("PCM format is 16-bit 5.1 multi channel\n");
533 pcm_hw->channels_min = 6;
534 pcm_hw->channels_max = 6;
535 pcm_hw->formats = SNDRV_PCM_FMTBIT_S16_LE |
536 SNDRV_PCM_FMTBIT_S16_BE;
537 } else {
538 pr_err("PCM format %s not supported\n", pcm_format);
539 return -EIO;
540 }
541 return 0;
542error:
543 pr_err("Audio resolution doesn't fit subbuffer size\n");
544 return -EINVAL;
545}
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560static int audio_probe_channel(struct most_interface *iface, int channel_id,
561 struct most_channel_config *cfg,
562 struct kobject *parent, char *arg_list)
563{
564 struct channel *channel;
565 struct snd_card *card;
566 struct snd_pcm *pcm;
567 int playback_count = 0;
568 int capture_count = 0;
569 int ret;
570 int direction;
571 char *card_name;
572 char *pcm_format;
573
574 if (!iface)
575 return -EINVAL;
576
577 if (cfg->data_type != MOST_CH_SYNC) {
578 pr_err("Incompatible channel type\n");
579 return -EINVAL;
580 }
581
582 if (get_channel(iface, channel_id)) {
583 pr_err("channel (%s:%d) is already linked\n",
584 iface->description, channel_id);
585 return -EINVAL;
586 }
587
588 if (cfg->direction == MOST_CH_TX) {
589 playback_count = 1;
590 direction = SNDRV_PCM_STREAM_PLAYBACK;
591 } else {
592 capture_count = 1;
593 direction = SNDRV_PCM_STREAM_CAPTURE;
594 }
595
596 ret = split_arg_list(arg_list, &card_name, &pcm_format);
597 if (ret < 0) {
598 pr_info("PCM format missing\n");
599 return ret;
600 }
601
602 ret = snd_card_new(NULL, -1, card_name, THIS_MODULE,
603 sizeof(*channel), &card);
604 if (ret < 0)
605 return ret;
606
607 channel = card->private_data;
608 channel->card = card;
609 channel->cfg = cfg;
610 channel->iface = iface;
611 channel->id = channel_id;
612 init_waitqueue_head(&channel->playback_waitq);
613
614 if (audio_set_hw_params(&channel->pcm_hardware, pcm_format, cfg))
615 goto err_free_card;
616
617 snprintf(card->driver, sizeof(card->driver), "%s", DRIVER_NAME);
618 snprintf(card->shortname, sizeof(card->shortname), "Microchip MOST:%d",
619 card->number);
620 snprintf(card->longname, sizeof(card->longname), "%s at %s, ch %d",
621 card->shortname, iface->description, channel_id);
622
623 ret = snd_pcm_new(card, card_name, 0, playback_count,
624 capture_count, &pcm);
625 if (ret < 0)
626 goto err_free_card;
627
628 pcm->private_data = channel;
629
630 snd_pcm_set_ops(pcm, direction, &pcm_ops);
631
632 ret = snd_card_register(card);
633 if (ret < 0)
634 goto err_free_card;
635
636 list_add_tail(&channel->list, &dev_list);
637
638 return 0;
639
640err_free_card:
641 snd_card_free(card);
642 return ret;
643}
644
645
646
647
648
649
650
651
652
653
654static int audio_disconnect_channel(struct most_interface *iface,
655 int channel_id)
656{
657 struct channel *channel;
658
659 channel = get_channel(iface, channel_id);
660 if (!channel) {
661 pr_err("sound_disconnect_channel(), invalid channel %d\n",
662 channel_id);
663 return -EINVAL;
664 }
665
666 list_del(&channel->list);
667 snd_card_free(channel->card);
668
669 return 0;
670}
671
672
673
674
675
676
677
678
679
680
681static int audio_rx_completion(struct mbo *mbo)
682{
683 struct channel *channel = get_channel(mbo->ifp, mbo->hdm_channel_id);
684 bool period_elapsed = false;
685
686 if (!channel) {
687 pr_err("sound_rx_completion(), invalid channel %d\n",
688 mbo->hdm_channel_id);
689 return -EINVAL;
690 }
691
692 if (channel->is_stream_running)
693 period_elapsed = copy_data(channel, mbo);
694
695 most_put_mbo(mbo);
696
697 if (period_elapsed)
698 snd_pcm_period_elapsed(channel->substream);
699
700 return 0;
701}
702
703
704
705
706
707
708
709
710
711
712
713
714static int audio_tx_completion(struct most_interface *iface, int channel_id)
715{
716 struct channel *channel = get_channel(iface, channel_id);
717
718 if (!channel) {
719 pr_err("sound_tx_completion(), invalid channel %d\n",
720 channel_id);
721 return -EINVAL;
722 }
723
724 wake_up_interruptible(&channel->playback_waitq);
725
726 return 0;
727}
728
729
730
731
732static struct most_aim audio_aim = {
733 .name = DRIVER_NAME,
734 .probe_channel = audio_probe_channel,
735 .disconnect_channel = audio_disconnect_channel,
736 .rx_completion = audio_rx_completion,
737 .tx_completion = audio_tx_completion,
738};
739
740static int __init audio_init(void)
741{
742 pr_info("init()\n");
743
744 INIT_LIST_HEAD(&dev_list);
745
746 return most_register_aim(&audio_aim);
747}
748
749static void __exit audio_exit(void)
750{
751 struct channel *channel, *tmp;
752
753 pr_info("exit()\n");
754
755 list_for_each_entry_safe(channel, tmp, &dev_list, list) {
756 list_del(&channel->list);
757 snd_card_free(channel->card);
758 }
759
760 most_deregister_aim(&audio_aim);
761}
762
763module_init(audio_init);
764module_exit(audio_exit);
765
766MODULE_LICENSE("GPL");
767MODULE_AUTHOR("Christian Gromm <christian.gromm@microchip.com>");
768MODULE_DESCRIPTION("Audio Application Interface Module for MostCore");
769