Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * sound.c - Sound component for Mostcore
4 *
5 * Copyright (C) 2015 Microchip Technology Germany II GmbH & Co. KG
6 */
7
8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10#include <linux/module.h>
11#include <linux/printk.h>
12#include <linux/kernel.h>
13#include <linux/slab.h>
14#include <linux/init.h>
15#include <sound/core.h>
16#include <sound/pcm.h>
17#include <sound/pcm_params.h>
18#include <linux/sched.h>
19#include <linux/kthread.h>
20#include <linux/most.h>
21
22#define DRIVER_NAME "sound"
23#define STRING_SIZE 80
24
25static struct most_component comp;
26
27/**
28 * struct channel - private structure to keep channel specific data
29 * @substream: stores the substream structure
30 * @iface: interface for which the channel belongs to
31 * @cfg: channel configuration
32 * @card: registered sound card
33 * @list: list for private use
34 * @id: channel index
35 * @period_pos: current period position (ring buffer)
36 * @buffer_pos: current buffer position (ring buffer)
37 * @is_stream_running: identifies whether a stream is running or not
38 * @opened: set when the stream is opened
39 * @playback_task: playback thread
40 * @playback_waitq: waitq used by playback thread
41 */
42struct channel {
43 struct snd_pcm_substream *substream;
44 struct snd_pcm_hardware pcm_hardware;
45 struct most_interface *iface;
46 struct most_channel_config *cfg;
47 struct snd_card *card;
48 struct list_head list;
49 int id;
50 unsigned int period_pos;
51 unsigned int buffer_pos;
52 bool is_stream_running;
53 struct task_struct *playback_task;
54 wait_queue_head_t playback_waitq;
55 void (*copy_fn)(void *alsa, void *most, unsigned int bytes);
56};
57
58struct sound_adapter {
59 struct list_head dev_list;
60 struct most_interface *iface;
61 struct snd_card *card;
62 struct list_head list;
63 bool registered;
64 int pcm_dev_idx;
65};
66
67static struct list_head adpt_list;
68
69#define MOST_PCM_INFO (SNDRV_PCM_INFO_MMAP | \
70 SNDRV_PCM_INFO_MMAP_VALID | \
71 SNDRV_PCM_INFO_BATCH | \
72 SNDRV_PCM_INFO_INTERLEAVED | \
73 SNDRV_PCM_INFO_BLOCK_TRANSFER)
74
75static void swap_copy16(u16 *dest, const u16 *source, unsigned int bytes)
76{
77 unsigned int i = 0;
78
79 while (i < (bytes / 2)) {
80 dest[i] = swab16(source[i]);
81 i++;
82 }
83}
84
85static void swap_copy24(u8 *dest, const u8 *source, unsigned int bytes)
86{
87 unsigned int i = 0;
88
89 if (bytes < 2)
90 return;
91 while (i < bytes - 2) {
92 dest[i] = source[i + 2];
93 dest[i + 1] = source[i + 1];
94 dest[i + 2] = source[i];
95 i += 3;
96 }
97}
98
99static void swap_copy32(u32 *dest, const u32 *source, unsigned int bytes)
100{
101 unsigned int i = 0;
102
103 while (i < bytes / 4) {
104 dest[i] = swab32(source[i]);
105 i++;
106 }
107}
108
109static void alsa_to_most_memcpy(void *alsa, void *most, unsigned int bytes)
110{
111 memcpy(most, alsa, bytes);
112}
113
114static void alsa_to_most_copy16(void *alsa, void *most, unsigned int bytes)
115{
116 swap_copy16(most, alsa, bytes);
117}
118
119static void alsa_to_most_copy24(void *alsa, void *most, unsigned int bytes)
120{
121 swap_copy24(most, alsa, bytes);
122}
123
124static void alsa_to_most_copy32(void *alsa, void *most, unsigned int bytes)
125{
126 swap_copy32(most, alsa, bytes);
127}
128
129static void most_to_alsa_memcpy(void *alsa, void *most, unsigned int bytes)
130{
131 memcpy(alsa, most, bytes);
132}
133
134static void most_to_alsa_copy16(void *alsa, void *most, unsigned int bytes)
135{
136 swap_copy16(alsa, most, bytes);
137}
138
139static void most_to_alsa_copy24(void *alsa, void *most, unsigned int bytes)
140{
141 swap_copy24(alsa, most, bytes);
142}
143
144static void most_to_alsa_copy32(void *alsa, void *most, unsigned int bytes)
145{
146 swap_copy32(alsa, most, bytes);
147}
148
149/**
150 * get_channel - get pointer to channel
151 * @iface: interface structure
152 * @channel_id: channel ID
153 *
154 * This traverses the channel list and returns the channel matching the
155 * ID and interface.
156 *
157 * Returns pointer to channel on success or NULL otherwise.
158 */
159static struct channel *get_channel(struct most_interface *iface,
160 int channel_id)
161{
162 struct sound_adapter *adpt = iface->priv;
163 struct channel *channel;
164
165 list_for_each_entry(channel, &adpt->dev_list, list) {
166 if ((channel->iface == iface) && (channel->id == channel_id))
167 return channel;
168 }
169 return NULL;
170}
171
172/**
173 * copy_data - implements data copying function
174 * @channel: channel
175 * @mbo: MBO from core
176 *
177 * Copy data from/to ring buffer to/from MBO and update the buffer position
178 */
179static bool copy_data(struct channel *channel, struct mbo *mbo)
180{
181 struct snd_pcm_runtime *const runtime = channel->substream->runtime;
182 unsigned int const frame_bytes = channel->cfg->subbuffer_size;
183 unsigned int const buffer_size = runtime->buffer_size;
184 unsigned int frames;
185 unsigned int fr0;
186
187 if (channel->cfg->direction & MOST_CH_RX)
188 frames = mbo->processed_length / frame_bytes;
189 else
190 frames = mbo->buffer_length / frame_bytes;
191 fr0 = min(buffer_size - channel->buffer_pos, frames);
192
193 channel->copy_fn(runtime->dma_area + channel->buffer_pos * frame_bytes,
194 mbo->virt_address,
195 fr0 * frame_bytes);
196
197 if (frames > fr0) {
198 /* wrap around at end of ring buffer */
199 channel->copy_fn(runtime->dma_area,
200 mbo->virt_address + fr0 * frame_bytes,
201 (frames - fr0) * frame_bytes);
202 }
203
204 channel->buffer_pos += frames;
205 if (channel->buffer_pos >= buffer_size)
206 channel->buffer_pos -= buffer_size;
207 channel->period_pos += frames;
208 if (channel->period_pos >= runtime->period_size) {
209 channel->period_pos -= runtime->period_size;
210 return true;
211 }
212 return false;
213}
214
215/**
216 * playback_thread - function implements the playback thread
217 * @data: private data
218 *
219 * Thread which does the playback functionality in a loop. It waits for a free
220 * MBO from mostcore for a particular channel and copy the data from ring buffer
221 * to MBO. Submit the MBO back to mostcore, after copying the data.
222 *
223 * Returns 0 on success or error code otherwise.
224 */
225static int playback_thread(void *data)
226{
227 struct channel *const channel = data;
228
229 while (!kthread_should_stop()) {
230 struct mbo *mbo = NULL;
231 bool period_elapsed = false;
232
233 wait_event_interruptible(
234 channel->playback_waitq,
235 kthread_should_stop() ||
236 (channel->is_stream_running &&
237 (mbo = most_get_mbo(channel->iface, channel->id,
238 &comp))));
239 if (!mbo)
240 continue;
241
242 if (channel->is_stream_running)
243 period_elapsed = copy_data(channel, mbo);
244 else
245 memset(mbo->virt_address, 0, mbo->buffer_length);
246
247 most_submit_mbo(mbo);
248 if (period_elapsed)
249 snd_pcm_period_elapsed(channel->substream);
250 }
251 return 0;
252}
253
254/**
255 * pcm_open - implements open callback function for PCM middle layer
256 * @substream: pointer to ALSA PCM substream
257 *
258 * This is called when a PCM substream is opened. At least, the function should
259 * initialize the runtime->hw record.
260 *
261 * Returns 0 on success or error code otherwise.
262 */
263static int pcm_open(struct snd_pcm_substream *substream)
264{
265 struct channel *channel = substream->private_data;
266 struct snd_pcm_runtime *runtime = substream->runtime;
267 struct most_channel_config *cfg = channel->cfg;
268 int ret;
269
270 channel->substream = substream;
271
272 if (cfg->direction == MOST_CH_TX) {
273 channel->playback_task = kthread_run(playback_thread, channel,
274 "most_audio_playback");
275 if (IS_ERR(channel->playback_task)) {
276 pr_err("Couldn't start thread\n");
277 return PTR_ERR(channel->playback_task);
278 }
279 }
280
281 ret = most_start_channel(channel->iface, channel->id, &comp);
282 if (ret) {
283 pr_err("most_start_channel() failed!\n");
284 if (cfg->direction == MOST_CH_TX)
285 kthread_stop(channel->playback_task);
286 return ret;
287 }
288
289 runtime->hw = channel->pcm_hardware;
290 return 0;
291}
292
293/**
294 * pcm_close - implements close callback function for PCM middle layer
295 * @substream: sub-stream pointer
296 *
297 * Obviously, this is called when a PCM substream is closed. Any private
298 * instance for a PCM substream allocated in the open callback will be
299 * released here.
300 *
301 * Returns 0 on success or error code otherwise.
302 */
303static int pcm_close(struct snd_pcm_substream *substream)
304{
305 struct channel *channel = substream->private_data;
306
307 if (channel->cfg->direction == MOST_CH_TX)
308 kthread_stop(channel->playback_task);
309 most_stop_channel(channel->iface, channel->id, &comp);
310 return 0;
311}
312
313/**
314 * pcm_prepare - implements prepare callback function for PCM middle layer
315 * @substream: substream pointer
316 *
317 * This callback is called when the PCM is "prepared". Format rate, sample rate,
318 * etc., can be set here. This callback can be called many times at each setup.
319 *
320 * Returns 0 on success or error code otherwise.
321 */
322static int pcm_prepare(struct snd_pcm_substream *substream)
323{
324 struct channel *channel = substream->private_data;
325 struct snd_pcm_runtime *runtime = substream->runtime;
326 struct most_channel_config *cfg = channel->cfg;
327 int width = snd_pcm_format_physical_width(runtime->format);
328
329 channel->copy_fn = NULL;
330
331 if (cfg->direction == MOST_CH_TX) {
332 if (snd_pcm_format_big_endian(runtime->format) || width == 8)
333 channel->copy_fn = alsa_to_most_memcpy;
334 else if (width == 16)
335 channel->copy_fn = alsa_to_most_copy16;
336 else if (width == 24)
337 channel->copy_fn = alsa_to_most_copy24;
338 else if (width == 32)
339 channel->copy_fn = alsa_to_most_copy32;
340 } else {
341 if (snd_pcm_format_big_endian(runtime->format) || width == 8)
342 channel->copy_fn = most_to_alsa_memcpy;
343 else if (width == 16)
344 channel->copy_fn = most_to_alsa_copy16;
345 else if (width == 24)
346 channel->copy_fn = most_to_alsa_copy24;
347 else if (width == 32)
348 channel->copy_fn = most_to_alsa_copy32;
349 }
350
351 if (!channel->copy_fn)
352 return -EINVAL;
353 channel->period_pos = 0;
354 channel->buffer_pos = 0;
355 return 0;
356}
357
358/**
359 * pcm_trigger - implements trigger callback function for PCM middle layer
360 * @substream: substream pointer
361 * @cmd: action to perform
362 *
363 * This is called when the PCM is started, stopped or paused. The action will be
364 * specified in the second argument, SNDRV_PCM_TRIGGER_XXX
365 *
366 * Returns 0 on success or error code otherwise.
367 */
368static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
369{
370 struct channel *channel = substream->private_data;
371
372 switch (cmd) {
373 case SNDRV_PCM_TRIGGER_START:
374 channel->is_stream_running = true;
375 wake_up_interruptible(&channel->playback_waitq);
376 return 0;
377
378 case SNDRV_PCM_TRIGGER_STOP:
379 channel->is_stream_running = false;
380 return 0;
381
382 default:
383 return -EINVAL;
384 }
385 return 0;
386}
387
388/**
389 * pcm_pointer - implements pointer callback function for PCM middle layer
390 * @substream: substream pointer
391 *
392 * This callback is called when the PCM middle layer inquires the current
393 * hardware position on the buffer. The position must be returned in frames,
394 * ranging from 0 to buffer_size-1.
395 */
396static snd_pcm_uframes_t pcm_pointer(struct snd_pcm_substream *substream)
397{
398 struct channel *channel = substream->private_data;
399
400 return channel->buffer_pos;
401}
402
403/**
404 * Initialization of struct snd_pcm_ops
405 */
406static const struct snd_pcm_ops pcm_ops = {
407 .open = pcm_open,
408 .close = pcm_close,
409 .prepare = pcm_prepare,
410 .trigger = pcm_trigger,
411 .pointer = pcm_pointer,
412};
413
414static int split_arg_list(char *buf, u16 *ch_num, char **sample_res)
415{
416 char *num;
417 int ret;
418
419 num = strsep(&buf, "x");
420 if (!num)
421 goto err;
422 ret = kstrtou16(num, 0, ch_num);
423 if (ret)
424 goto err;
425 *sample_res = strsep(&buf, ".\n");
426 if (!*sample_res)
427 goto err;
428 return 0;
429
430err:
431 pr_err("Bad PCM format\n");
432 return -EINVAL;
433}
434
435static const struct sample_resolution_info {
436 const char *sample_res;
437 int bytes;
438 u64 formats;
439} sinfo[] = {
440 { "8", 1, SNDRV_PCM_FMTBIT_S8 },
441 { "16", 2, SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE },
442 { "24", 3, SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE },
443 { "32", 4, SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE },
444};
445
446static int audio_set_hw_params(struct snd_pcm_hardware *pcm_hw,
447 u16 ch_num, char *sample_res,
448 struct most_channel_config *cfg)
449{
450 int i;
451
452 for (i = 0; i < ARRAY_SIZE(sinfo); i++) {
453 if (!strcmp(sample_res, sinfo[i].sample_res))
454 goto found;
455 }
456 pr_err("Unsupported PCM format\n");
457 return -EINVAL;
458
459found:
460 if (!ch_num) {
461 pr_err("Bad number of channels\n");
462 return -EINVAL;
463 }
464
465 if (cfg->subbuffer_size != ch_num * sinfo[i].bytes) {
466 pr_err("Audio resolution doesn't fit subbuffer size\n");
467 return -EINVAL;
468 }
469
470 pcm_hw->info = MOST_PCM_INFO;
471 pcm_hw->rates = SNDRV_PCM_RATE_48000;
472 pcm_hw->rate_min = 48000;
473 pcm_hw->rate_max = 48000;
474 pcm_hw->buffer_bytes_max = cfg->num_buffers * cfg->buffer_size;
475 pcm_hw->period_bytes_min = cfg->buffer_size;
476 pcm_hw->period_bytes_max = cfg->buffer_size;
477 pcm_hw->periods_min = 1;
478 pcm_hw->periods_max = cfg->num_buffers;
479 pcm_hw->channels_min = ch_num;
480 pcm_hw->channels_max = ch_num;
481 pcm_hw->formats = sinfo[i].formats;
482 return 0;
483}
484
485static void release_adapter(struct sound_adapter *adpt)
486{
487 struct channel *channel, *tmp;
488
489 list_for_each_entry_safe(channel, tmp, &adpt->dev_list, list) {
490 list_del(&channel->list);
491 kfree(channel);
492 }
493 if (adpt->card)
494 snd_card_free(adpt->card);
495 list_del(&adpt->list);
496 kfree(adpt);
497}
498
499/**
500 * audio_probe_channel - probe function of the driver module
501 * @iface: pointer to interface instance
502 * @channel_id: channel index/ID
503 * @cfg: pointer to actual channel configuration
504 * @arg_list: string that provides the name of the device to be created in /dev
505 * plus the desired audio resolution
506 *
507 * Creates sound card, pcm device, sets pcm ops and registers sound card.
508 *
509 * Returns 0 on success or error code otherwise.
510 */
511static int audio_probe_channel(struct most_interface *iface, int channel_id,
512 struct most_channel_config *cfg,
513 char *device_name, char *arg_list)
514{
515 struct channel *channel;
516 struct sound_adapter *adpt;
517 struct snd_pcm *pcm;
518 int playback_count = 0;
519 int capture_count = 0;
520 int ret;
521 int direction;
522 u16 ch_num;
523 char *sample_res;
524 char arg_list_cpy[STRING_SIZE];
525
526 if (cfg->data_type != MOST_CH_SYNC) {
527 pr_err("Incompatible channel type\n");
528 return -EINVAL;
529 }
530 strscpy(arg_list_cpy, arg_list, STRING_SIZE);
531 ret = split_arg_list(arg_list_cpy, &ch_num, &sample_res);
532 if (ret < 0)
533 return ret;
534
535 list_for_each_entry(adpt, &adpt_list, list) {
536 if (adpt->iface != iface)
537 continue;
538 if (adpt->registered)
539 return -ENOSPC;
540 adpt->pcm_dev_idx++;
541 goto skip_adpt_alloc;
542 }
543 adpt = kzalloc(sizeof(*adpt), GFP_KERNEL);
544 if (!adpt)
545 return -ENOMEM;
546
547 adpt->iface = iface;
548 INIT_LIST_HEAD(&adpt->dev_list);
549 iface->priv = adpt;
550 list_add_tail(&adpt->list, &adpt_list);
551 ret = snd_card_new(iface->driver_dev, -1, "INIC", THIS_MODULE,
552 sizeof(*channel), &adpt->card);
553 if (ret < 0)
554 goto err_free_adpt;
555 snprintf(adpt->card->driver, sizeof(adpt->card->driver),
556 "%s", DRIVER_NAME);
557 snprintf(adpt->card->shortname, sizeof(adpt->card->shortname),
558 "Microchip INIC");
559 snprintf(adpt->card->longname, sizeof(adpt->card->longname),
560 "%s at %s", adpt->card->shortname, iface->description);
561skip_adpt_alloc:
562 if (get_channel(iface, channel_id)) {
563 pr_err("channel (%s:%d) is already linked\n",
564 iface->description, channel_id);
565 return -EEXIST;
566 }
567
568 if (cfg->direction == MOST_CH_TX) {
569 playback_count = 1;
570 direction = SNDRV_PCM_STREAM_PLAYBACK;
571 } else {
572 capture_count = 1;
573 direction = SNDRV_PCM_STREAM_CAPTURE;
574 }
575 channel = kzalloc(sizeof(*channel), GFP_KERNEL);
576 if (!channel) {
577 ret = -ENOMEM;
578 goto err_free_adpt;
579 }
580 channel->card = adpt->card;
581 channel->cfg = cfg;
582 channel->iface = iface;
583 channel->id = channel_id;
584 init_waitqueue_head(&channel->playback_waitq);
585 list_add_tail(&channel->list, &adpt->dev_list);
586
587 ret = audio_set_hw_params(&channel->pcm_hardware, ch_num, sample_res,
588 cfg);
589 if (ret)
590 goto err_free_adpt;
591
592 ret = snd_pcm_new(adpt->card, device_name, adpt->pcm_dev_idx,
593 playback_count, capture_count, &pcm);
594
595 if (ret < 0)
596 goto err_free_adpt;
597
598 pcm->private_data = channel;
599 strscpy(pcm->name, device_name, sizeof(pcm->name));
600 snd_pcm_set_ops(pcm, direction, &pcm_ops);
601 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0);
602 return 0;
603
604err_free_adpt:
605 release_adapter(adpt);
606 return ret;
607}
608
609static int audio_create_sound_card(void)
610{
611 int ret;
612 struct sound_adapter *adpt;
613
614 list_for_each_entry(adpt, &adpt_list, list) {
615 if (!adpt->registered)
616 goto adpt_alloc;
617 }
618 return -ENODEV;
619adpt_alloc:
620 ret = snd_card_register(adpt->card);
621 if (ret < 0) {
622 release_adapter(adpt);
623 return ret;
624 }
625 adpt->registered = true;
626 return 0;
627}
628
629/**
630 * audio_disconnect_channel - function to disconnect a channel
631 * @iface: pointer to interface instance
632 * @channel_id: channel index
633 *
634 * This frees allocated memory and removes the sound card from ALSA
635 *
636 * Returns 0 on success or error code otherwise.
637 */
638static int audio_disconnect_channel(struct most_interface *iface,
639 int channel_id)
640{
641 struct channel *channel;
642 struct sound_adapter *adpt = iface->priv;
643
644 channel = get_channel(iface, channel_id);
645 if (!channel)
646 return -EINVAL;
647
648 list_del(&channel->list);
649
650 kfree(channel);
651 if (list_empty(&adpt->dev_list))
652 release_adapter(adpt);
653 return 0;
654}
655
656/**
657 * audio_rx_completion - completion handler for rx channels
658 * @mbo: pointer to buffer object that has completed
659 *
660 * This searches for the channel this MBO belongs to and copy the data from MBO
661 * to ring buffer
662 *
663 * Returns 0 on success or error code otherwise.
664 */
665static int audio_rx_completion(struct mbo *mbo)
666{
667 struct channel *channel = get_channel(mbo->ifp, mbo->hdm_channel_id);
668 bool period_elapsed = false;
669
670 if (!channel)
671 return -EINVAL;
672 if (channel->is_stream_running)
673 period_elapsed = copy_data(channel, mbo);
674 most_put_mbo(mbo);
675 if (period_elapsed)
676 snd_pcm_period_elapsed(channel->substream);
677 return 0;
678}
679
680/**
681 * audio_tx_completion - completion handler for tx channels
682 * @iface: pointer to interface instance
683 * @channel_id: channel index/ID
684 *
685 * This searches the channel that belongs to this combination of interface
686 * pointer and channel ID and wakes a process sitting in the wait queue of
687 * this channel.
688 *
689 * Returns 0 on success or error code otherwise.
690 */
691static int audio_tx_completion(struct most_interface *iface, int channel_id)
692{
693 struct channel *channel = get_channel(iface, channel_id);
694
695 if (!channel)
696 return -EINVAL;
697
698 wake_up_interruptible(&channel->playback_waitq);
699 return 0;
700}
701
702/**
703 * Initialization of the struct most_component
704 */
705static struct most_component comp = {
706 .mod = THIS_MODULE,
707 .name = DRIVER_NAME,
708 .probe_channel = audio_probe_channel,
709 .disconnect_channel = audio_disconnect_channel,
710 .rx_completion = audio_rx_completion,
711 .tx_completion = audio_tx_completion,
712 .cfg_complete = audio_create_sound_card,
713};
714
715static int __init audio_init(void)
716{
717 int ret;
718
719 INIT_LIST_HEAD(&adpt_list);
720
721 ret = most_register_component(&comp);
722 if (ret) {
723 pr_err("Failed to register %s\n", comp.name);
724 return ret;
725 }
726 ret = most_register_configfs_subsys(&comp);
727 if (ret) {
728 pr_err("Failed to register %s configfs subsys\n", comp.name);
729 most_deregister_component(&comp);
730 }
731 return ret;
732}
733
734static void __exit audio_exit(void)
735{
736 most_deregister_configfs_subsys(&comp);
737 most_deregister_component(&comp);
738}
739
740module_init(audio_init);
741module_exit(audio_exit);
742
743MODULE_LICENSE("GPL");
744MODULE_AUTHOR("Christian Gromm <christian.gromm@microchip.com>");
745MODULE_DESCRIPTION("Sound Component Module for Mostcore");
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * sound.c - Sound component for Mostcore
4 *
5 * Copyright (C) 2015 Microchip Technology Germany II GmbH & Co. KG
6 */
7
8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10#include <linux/module.h>
11#include <linux/printk.h>
12#include <linux/kernel.h>
13#include <linux/slab.h>
14#include <linux/init.h>
15#include <sound/core.h>
16#include <sound/pcm.h>
17#include <sound/pcm_params.h>
18#include <linux/sched.h>
19#include <linux/kthread.h>
20#include <linux/most.h>
21
22#define DRIVER_NAME "sound"
23#define STRING_SIZE 80
24
25static struct most_component comp;
26
27/**
28 * struct channel - private structure to keep channel specific data
29 * @substream: stores the substream structure
30 * @pcm_hardware: low-level hardware description
31 * @iface: interface for which the channel belongs to
32 * @cfg: channel configuration
33 * @card: registered sound card
34 * @list: list for private use
35 * @id: channel index
36 * @period_pos: current period position (ring buffer)
37 * @buffer_pos: current buffer position (ring buffer)
38 * @is_stream_running: identifies whether a stream is running or not
39 * @opened: set when the stream is opened
40 * @playback_task: playback thread
41 * @playback_waitq: waitq used by playback thread
42 * @copy_fn: copy function for PCM-specific format and width
43 */
44struct channel {
45 struct snd_pcm_substream *substream;
46 struct snd_pcm_hardware pcm_hardware;
47 struct most_interface *iface;
48 struct most_channel_config *cfg;
49 struct snd_card *card;
50 struct list_head list;
51 int id;
52 unsigned int period_pos;
53 unsigned int buffer_pos;
54 bool is_stream_running;
55 struct task_struct *playback_task;
56 wait_queue_head_t playback_waitq;
57 void (*copy_fn)(void *alsa, void *most, unsigned int bytes);
58};
59
60struct sound_adapter {
61 struct list_head dev_list;
62 struct most_interface *iface;
63 struct snd_card *card;
64 struct list_head list;
65 bool registered;
66 int pcm_dev_idx;
67};
68
69static struct list_head adpt_list;
70
71#define MOST_PCM_INFO (SNDRV_PCM_INFO_MMAP | \
72 SNDRV_PCM_INFO_MMAP_VALID | \
73 SNDRV_PCM_INFO_BATCH | \
74 SNDRV_PCM_INFO_INTERLEAVED | \
75 SNDRV_PCM_INFO_BLOCK_TRANSFER)
76
77static void swap_copy16(u16 *dest, const u16 *source, unsigned int bytes)
78{
79 unsigned int i = 0;
80
81 while (i < (bytes / 2)) {
82 dest[i] = swab16(source[i]);
83 i++;
84 }
85}
86
87static void swap_copy24(u8 *dest, const u8 *source, unsigned int bytes)
88{
89 unsigned int i = 0;
90
91 if (bytes < 2)
92 return;
93 while (i < bytes - 2) {
94 dest[i] = source[i + 2];
95 dest[i + 1] = source[i + 1];
96 dest[i + 2] = source[i];
97 i += 3;
98 }
99}
100
101static void swap_copy32(u32 *dest, const u32 *source, unsigned int bytes)
102{
103 unsigned int i = 0;
104
105 while (i < bytes / 4) {
106 dest[i] = swab32(source[i]);
107 i++;
108 }
109}
110
111static void alsa_to_most_memcpy(void *alsa, void *most, unsigned int bytes)
112{
113 memcpy(most, alsa, bytes);
114}
115
116static void alsa_to_most_copy16(void *alsa, void *most, unsigned int bytes)
117{
118 swap_copy16(most, alsa, bytes);
119}
120
121static void alsa_to_most_copy24(void *alsa, void *most, unsigned int bytes)
122{
123 swap_copy24(most, alsa, bytes);
124}
125
126static void alsa_to_most_copy32(void *alsa, void *most, unsigned int bytes)
127{
128 swap_copy32(most, alsa, bytes);
129}
130
131static void most_to_alsa_memcpy(void *alsa, void *most, unsigned int bytes)
132{
133 memcpy(alsa, most, bytes);
134}
135
136static void most_to_alsa_copy16(void *alsa, void *most, unsigned int bytes)
137{
138 swap_copy16(alsa, most, bytes);
139}
140
141static void most_to_alsa_copy24(void *alsa, void *most, unsigned int bytes)
142{
143 swap_copy24(alsa, most, bytes);
144}
145
146static void most_to_alsa_copy32(void *alsa, void *most, unsigned int bytes)
147{
148 swap_copy32(alsa, most, bytes);
149}
150
151/**
152 * get_channel - get pointer to channel
153 * @iface: interface structure
154 * @channel_id: channel ID
155 *
156 * This traverses the channel list and returns the channel matching the
157 * ID and interface.
158 *
159 * Returns pointer to channel on success or NULL otherwise.
160 */
161static struct channel *get_channel(struct most_interface *iface,
162 int channel_id)
163{
164 struct sound_adapter *adpt = iface->priv;
165 struct channel *channel;
166
167 list_for_each_entry(channel, &adpt->dev_list, list) {
168 if ((channel->iface == iface) && (channel->id == channel_id))
169 return channel;
170 }
171 return NULL;
172}
173
174/**
175 * copy_data - implements data copying function
176 * @channel: channel
177 * @mbo: MBO from core
178 *
179 * Copy data from/to ring buffer to/from MBO and update the buffer position
180 */
181static bool copy_data(struct channel *channel, struct mbo *mbo)
182{
183 struct snd_pcm_runtime *const runtime = channel->substream->runtime;
184 unsigned int const frame_bytes = channel->cfg->subbuffer_size;
185 unsigned int const buffer_size = runtime->buffer_size;
186 unsigned int frames;
187 unsigned int fr0;
188
189 if (channel->cfg->direction & MOST_CH_RX)
190 frames = mbo->processed_length / frame_bytes;
191 else
192 frames = mbo->buffer_length / frame_bytes;
193 fr0 = min(buffer_size - channel->buffer_pos, frames);
194
195 channel->copy_fn(runtime->dma_area + channel->buffer_pos * frame_bytes,
196 mbo->virt_address,
197 fr0 * frame_bytes);
198
199 if (frames > fr0) {
200 /* wrap around at end of ring buffer */
201 channel->copy_fn(runtime->dma_area,
202 mbo->virt_address + fr0 * frame_bytes,
203 (frames - fr0) * frame_bytes);
204 }
205
206 channel->buffer_pos += frames;
207 if (channel->buffer_pos >= buffer_size)
208 channel->buffer_pos -= buffer_size;
209 channel->period_pos += frames;
210 if (channel->period_pos >= runtime->period_size) {
211 channel->period_pos -= runtime->period_size;
212 return true;
213 }
214 return false;
215}
216
217/**
218 * playback_thread - function implements the playback thread
219 * @data: private data
220 *
221 * Thread which does the playback functionality in a loop. It waits for a free
222 * MBO from mostcore for a particular channel and copy the data from ring buffer
223 * to MBO. Submit the MBO back to mostcore, after copying the data.
224 *
225 * Returns 0 on success or error code otherwise.
226 */
227static int playback_thread(void *data)
228{
229 struct channel *const channel = data;
230
231 while (!kthread_should_stop()) {
232 struct mbo *mbo = NULL;
233 bool period_elapsed = false;
234
235 wait_event_interruptible(
236 channel->playback_waitq,
237 kthread_should_stop() ||
238 (channel->is_stream_running &&
239 (mbo = most_get_mbo(channel->iface, channel->id,
240 &comp))));
241 if (!mbo)
242 continue;
243
244 if (channel->is_stream_running)
245 period_elapsed = copy_data(channel, mbo);
246 else
247 memset(mbo->virt_address, 0, mbo->buffer_length);
248
249 most_submit_mbo(mbo);
250 if (period_elapsed)
251 snd_pcm_period_elapsed(channel->substream);
252 }
253 return 0;
254}
255
256/**
257 * pcm_open - implements open callback function for PCM middle layer
258 * @substream: pointer to ALSA PCM substream
259 *
260 * This is called when a PCM substream is opened. At least, the function should
261 * initialize the runtime->hw record.
262 *
263 * Returns 0 on success or error code otherwise.
264 */
265static int pcm_open(struct snd_pcm_substream *substream)
266{
267 struct channel *channel = substream->private_data;
268 struct snd_pcm_runtime *runtime = substream->runtime;
269 struct most_channel_config *cfg = channel->cfg;
270 int ret;
271
272 channel->substream = substream;
273
274 if (cfg->direction == MOST_CH_TX) {
275 channel->playback_task = kthread_run(playback_thread, channel,
276 "most_audio_playback");
277 if (IS_ERR(channel->playback_task)) {
278 pr_err("Couldn't start thread\n");
279 return PTR_ERR(channel->playback_task);
280 }
281 }
282
283 ret = most_start_channel(channel->iface, channel->id, &comp);
284 if (ret) {
285 pr_err("most_start_channel() failed!\n");
286 if (cfg->direction == MOST_CH_TX)
287 kthread_stop(channel->playback_task);
288 return ret;
289 }
290
291 runtime->hw = channel->pcm_hardware;
292 return 0;
293}
294
295/**
296 * pcm_close - implements close callback function for PCM middle layer
297 * @substream: sub-stream pointer
298 *
299 * Obviously, this is called when a PCM substream is closed. Any private
300 * instance for a PCM substream allocated in the open callback will be
301 * released here.
302 *
303 * Returns 0 on success or error code otherwise.
304 */
305static int pcm_close(struct snd_pcm_substream *substream)
306{
307 struct channel *channel = substream->private_data;
308
309 if (channel->cfg->direction == MOST_CH_TX)
310 kthread_stop(channel->playback_task);
311 most_stop_channel(channel->iface, channel->id, &comp);
312 return 0;
313}
314
315/**
316 * pcm_prepare - implements prepare callback function for PCM middle layer
317 * @substream: substream pointer
318 *
319 * This callback is called when the PCM is "prepared". Format rate, sample rate,
320 * etc., can be set here. This callback can be called many times at each setup.
321 *
322 * Returns 0 on success or error code otherwise.
323 */
324static int pcm_prepare(struct snd_pcm_substream *substream)
325{
326 struct channel *channel = substream->private_data;
327 struct snd_pcm_runtime *runtime = substream->runtime;
328 struct most_channel_config *cfg = channel->cfg;
329 int width = snd_pcm_format_physical_width(runtime->format);
330
331 channel->copy_fn = NULL;
332
333 if (cfg->direction == MOST_CH_TX) {
334 if (snd_pcm_format_big_endian(runtime->format) || width == 8)
335 channel->copy_fn = alsa_to_most_memcpy;
336 else if (width == 16)
337 channel->copy_fn = alsa_to_most_copy16;
338 else if (width == 24)
339 channel->copy_fn = alsa_to_most_copy24;
340 else if (width == 32)
341 channel->copy_fn = alsa_to_most_copy32;
342 } else {
343 if (snd_pcm_format_big_endian(runtime->format) || width == 8)
344 channel->copy_fn = most_to_alsa_memcpy;
345 else if (width == 16)
346 channel->copy_fn = most_to_alsa_copy16;
347 else if (width == 24)
348 channel->copy_fn = most_to_alsa_copy24;
349 else if (width == 32)
350 channel->copy_fn = most_to_alsa_copy32;
351 }
352
353 if (!channel->copy_fn)
354 return -EINVAL;
355 channel->period_pos = 0;
356 channel->buffer_pos = 0;
357 return 0;
358}
359
360/**
361 * pcm_trigger - implements trigger callback function for PCM middle layer
362 * @substream: substream pointer
363 * @cmd: action to perform
364 *
365 * This is called when the PCM is started, stopped or paused. The action will be
366 * specified in the second argument, SNDRV_PCM_TRIGGER_XXX
367 *
368 * Returns 0 on success or error code otherwise.
369 */
370static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
371{
372 struct channel *channel = substream->private_data;
373
374 switch (cmd) {
375 case SNDRV_PCM_TRIGGER_START:
376 channel->is_stream_running = true;
377 wake_up_interruptible(&channel->playback_waitq);
378 return 0;
379
380 case SNDRV_PCM_TRIGGER_STOP:
381 channel->is_stream_running = false;
382 return 0;
383
384 default:
385 return -EINVAL;
386 }
387 return 0;
388}
389
390/**
391 * pcm_pointer - implements pointer callback function for PCM middle layer
392 * @substream: substream pointer
393 *
394 * This callback is called when the PCM middle layer inquires the current
395 * hardware position on the buffer. The position must be returned in frames,
396 * ranging from 0 to buffer_size-1.
397 */
398static snd_pcm_uframes_t pcm_pointer(struct snd_pcm_substream *substream)
399{
400 struct channel *channel = substream->private_data;
401
402 return channel->buffer_pos;
403}
404
405/*
406 * Initialization of struct snd_pcm_ops
407 */
408static const struct snd_pcm_ops pcm_ops = {
409 .open = pcm_open,
410 .close = pcm_close,
411 .prepare = pcm_prepare,
412 .trigger = pcm_trigger,
413 .pointer = pcm_pointer,
414};
415
416static int split_arg_list(char *buf, u16 *ch_num, char **sample_res)
417{
418 char *num;
419 int ret;
420
421 num = strsep(&buf, "x");
422 if (!num)
423 goto err;
424 ret = kstrtou16(num, 0, ch_num);
425 if (ret)
426 goto err;
427 *sample_res = strsep(&buf, ".\n");
428 if (!*sample_res)
429 goto err;
430 return 0;
431
432err:
433 pr_err("Bad PCM format\n");
434 return -EINVAL;
435}
436
437static const struct sample_resolution_info {
438 const char *sample_res;
439 int bytes;
440 u64 formats;
441} sinfo[] = {
442 { "8", 1, SNDRV_PCM_FMTBIT_S8 },
443 { "16", 2, SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE },
444 { "24", 3, SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE },
445 { "32", 4, SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE },
446};
447
448static int audio_set_hw_params(struct snd_pcm_hardware *pcm_hw,
449 u16 ch_num, char *sample_res,
450 struct most_channel_config *cfg)
451{
452 int i;
453
454 for (i = 0; i < ARRAY_SIZE(sinfo); i++) {
455 if (!strcmp(sample_res, sinfo[i].sample_res))
456 goto found;
457 }
458 pr_err("Unsupported PCM format\n");
459 return -EINVAL;
460
461found:
462 if (!ch_num) {
463 pr_err("Bad number of channels\n");
464 return -EINVAL;
465 }
466
467 if (cfg->subbuffer_size != ch_num * sinfo[i].bytes) {
468 pr_err("Audio resolution doesn't fit subbuffer size\n");
469 return -EINVAL;
470 }
471
472 pcm_hw->info = MOST_PCM_INFO;
473 pcm_hw->rates = SNDRV_PCM_RATE_48000;
474 pcm_hw->rate_min = 48000;
475 pcm_hw->rate_max = 48000;
476 pcm_hw->buffer_bytes_max = cfg->num_buffers * cfg->buffer_size;
477 pcm_hw->period_bytes_min = cfg->buffer_size;
478 pcm_hw->period_bytes_max = cfg->buffer_size;
479 pcm_hw->periods_min = 1;
480 pcm_hw->periods_max = cfg->num_buffers;
481 pcm_hw->channels_min = ch_num;
482 pcm_hw->channels_max = ch_num;
483 pcm_hw->formats = sinfo[i].formats;
484 return 0;
485}
486
487static void release_adapter(struct sound_adapter *adpt)
488{
489 struct channel *channel, *tmp;
490
491 list_for_each_entry_safe(channel, tmp, &adpt->dev_list, list) {
492 list_del(&channel->list);
493 kfree(channel);
494 }
495 if (adpt->card)
496 snd_card_free(adpt->card);
497 list_del(&adpt->list);
498 kfree(adpt);
499}
500
501/**
502 * audio_probe_channel - probe function of the driver module
503 * @iface: pointer to interface instance
504 * @channel_id: channel index/ID
505 * @cfg: pointer to actual channel configuration
506 * @device_name: name of the device to be created in /dev
507 * @arg_list: string that provides the desired audio resolution
508 *
509 * Creates sound card, pcm device, sets pcm ops and registers sound card.
510 *
511 * Returns 0 on success or error code otherwise.
512 */
513static int audio_probe_channel(struct most_interface *iface, int channel_id,
514 struct most_channel_config *cfg,
515 char *device_name, char *arg_list)
516{
517 struct channel *channel;
518 struct sound_adapter *adpt;
519 struct snd_pcm *pcm;
520 int playback_count = 0;
521 int capture_count = 0;
522 int ret;
523 int direction;
524 u16 ch_num;
525 char *sample_res;
526 char arg_list_cpy[STRING_SIZE];
527
528 if (cfg->data_type != MOST_CH_SYNC) {
529 pr_err("Incompatible channel type\n");
530 return -EINVAL;
531 }
532 strscpy(arg_list_cpy, arg_list, STRING_SIZE);
533 ret = split_arg_list(arg_list_cpy, &ch_num, &sample_res);
534 if (ret < 0)
535 return ret;
536
537 list_for_each_entry(adpt, &adpt_list, list) {
538 if (adpt->iface != iface)
539 continue;
540 if (adpt->registered)
541 return -ENOSPC;
542 adpt->pcm_dev_idx++;
543 goto skip_adpt_alloc;
544 }
545 adpt = kzalloc(sizeof(*adpt), GFP_KERNEL);
546 if (!adpt)
547 return -ENOMEM;
548
549 adpt->iface = iface;
550 INIT_LIST_HEAD(&adpt->dev_list);
551 iface->priv = adpt;
552 list_add_tail(&adpt->list, &adpt_list);
553 ret = snd_card_new(iface->driver_dev, -1, "INIC", THIS_MODULE,
554 sizeof(*channel), &adpt->card);
555 if (ret < 0)
556 goto err_free_adpt;
557 snprintf(adpt->card->driver, sizeof(adpt->card->driver),
558 "%s", DRIVER_NAME);
559 snprintf(adpt->card->shortname, sizeof(adpt->card->shortname),
560 "Microchip INIC");
561 snprintf(adpt->card->longname, sizeof(adpt->card->longname),
562 "%s at %s", adpt->card->shortname, iface->description);
563skip_adpt_alloc:
564 if (get_channel(iface, channel_id)) {
565 pr_err("channel (%s:%d) is already linked\n",
566 iface->description, channel_id);
567 return -EEXIST;
568 }
569
570 if (cfg->direction == MOST_CH_TX) {
571 playback_count = 1;
572 direction = SNDRV_PCM_STREAM_PLAYBACK;
573 } else {
574 capture_count = 1;
575 direction = SNDRV_PCM_STREAM_CAPTURE;
576 }
577 channel = kzalloc(sizeof(*channel), GFP_KERNEL);
578 if (!channel) {
579 ret = -ENOMEM;
580 goto err_free_adpt;
581 }
582 channel->card = adpt->card;
583 channel->cfg = cfg;
584 channel->iface = iface;
585 channel->id = channel_id;
586 init_waitqueue_head(&channel->playback_waitq);
587 list_add_tail(&channel->list, &adpt->dev_list);
588
589 ret = audio_set_hw_params(&channel->pcm_hardware, ch_num, sample_res,
590 cfg);
591 if (ret)
592 goto err_free_adpt;
593
594 ret = snd_pcm_new(adpt->card, device_name, adpt->pcm_dev_idx,
595 playback_count, capture_count, &pcm);
596
597 if (ret < 0)
598 goto err_free_adpt;
599
600 pcm->private_data = channel;
601 strscpy(pcm->name, device_name, sizeof(pcm->name));
602 snd_pcm_set_ops(pcm, direction, &pcm_ops);
603 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0);
604 return 0;
605
606err_free_adpt:
607 release_adapter(adpt);
608 return ret;
609}
610
611static int audio_create_sound_card(void)
612{
613 int ret;
614 struct sound_adapter *adpt;
615
616 list_for_each_entry(adpt, &adpt_list, list) {
617 if (!adpt->registered)
618 goto adpt_alloc;
619 }
620 return -ENODEV;
621adpt_alloc:
622 ret = snd_card_register(adpt->card);
623 if (ret < 0) {
624 release_adapter(adpt);
625 return ret;
626 }
627 adpt->registered = true;
628 return 0;
629}
630
631/**
632 * audio_disconnect_channel - function to disconnect a channel
633 * @iface: pointer to interface instance
634 * @channel_id: channel index
635 *
636 * This frees allocated memory and removes the sound card from ALSA
637 *
638 * Returns 0 on success or error code otherwise.
639 */
640static int audio_disconnect_channel(struct most_interface *iface,
641 int channel_id)
642{
643 struct channel *channel;
644 struct sound_adapter *adpt = iface->priv;
645
646 channel = get_channel(iface, channel_id);
647 if (!channel)
648 return -EINVAL;
649
650 list_del(&channel->list);
651
652 kfree(channel);
653 if (list_empty(&adpt->dev_list))
654 release_adapter(adpt);
655 return 0;
656}
657
658/**
659 * audio_rx_completion - completion handler for rx channels
660 * @mbo: pointer to buffer object that has completed
661 *
662 * This searches for the channel this MBO belongs to and copy the data from MBO
663 * to ring buffer
664 *
665 * Returns 0 on success or error code otherwise.
666 */
667static int audio_rx_completion(struct mbo *mbo)
668{
669 struct channel *channel = get_channel(mbo->ifp, mbo->hdm_channel_id);
670 bool period_elapsed = false;
671
672 if (!channel)
673 return -EINVAL;
674 if (channel->is_stream_running)
675 period_elapsed = copy_data(channel, mbo);
676 most_put_mbo(mbo);
677 if (period_elapsed)
678 snd_pcm_period_elapsed(channel->substream);
679 return 0;
680}
681
682/**
683 * audio_tx_completion - completion handler for tx channels
684 * @iface: pointer to interface instance
685 * @channel_id: channel index/ID
686 *
687 * This searches the channel that belongs to this combination of interface
688 * pointer and channel ID and wakes a process sitting in the wait queue of
689 * this channel.
690 *
691 * Returns 0 on success or error code otherwise.
692 */
693static int audio_tx_completion(struct most_interface *iface, int channel_id)
694{
695 struct channel *channel = get_channel(iface, channel_id);
696
697 if (!channel)
698 return -EINVAL;
699
700 wake_up_interruptible(&channel->playback_waitq);
701 return 0;
702}
703
704/*
705 * Initialization of the struct most_component
706 */
707static struct most_component comp = {
708 .mod = THIS_MODULE,
709 .name = DRIVER_NAME,
710 .probe_channel = audio_probe_channel,
711 .disconnect_channel = audio_disconnect_channel,
712 .rx_completion = audio_rx_completion,
713 .tx_completion = audio_tx_completion,
714 .cfg_complete = audio_create_sound_card,
715};
716
717static int __init audio_init(void)
718{
719 int ret;
720
721 INIT_LIST_HEAD(&adpt_list);
722
723 ret = most_register_component(&comp);
724 if (ret) {
725 pr_err("Failed to register %s\n", comp.name);
726 return ret;
727 }
728 ret = most_register_configfs_subsys(&comp);
729 if (ret) {
730 pr_err("Failed to register %s configfs subsys\n", comp.name);
731 most_deregister_component(&comp);
732 }
733 return ret;
734}
735
736static void __exit audio_exit(void)
737{
738 most_deregister_configfs_subsys(&comp);
739 most_deregister_component(&comp);
740}
741
742module_init(audio_init);
743module_exit(audio_exit);
744
745MODULE_LICENSE("GPL");
746MODULE_AUTHOR("Christian Gromm <christian.gromm@microchip.com>");
747MODULE_DESCRIPTION("Sound Component Module for Mostcore");