| // SPDX-License-Identifier: GPL-2.0+ | |
| /* | |
| * virtio-snd: Virtio sound device | |
| * Copyright (C) 2021 OpenSynergy GmbH | |
| */ | |
| #include <sound/pcm_params.h> | |
| #include "virtio_card.h" | |
| /* | |
| * I/O messages lifetime | |
| * --------------------- | |
| * | |
| * Allocation: | |
| * Messages are initially allocated in the ops->hw_params() after the size and | |
| * number of periods have been successfully negotiated. | |
| * | |
| * Freeing: | |
| * Messages can be safely freed after the queue has been successfully flushed | |
| * (RELEASE command in the ops->sync_stop()) and the ops->hw_free() has been | |
| * called. | |
| * | |
| * When the substream stops, the ops->sync_stop() waits until the device has | |
| * completed all pending messages. This wait can be interrupted either by a | |
| * signal or due to a timeout. In this case, the device can still access | |
| * messages even after calling ops->hw_free(). It can also issue an interrupt, | |
| * and the interrupt handler will also try to access message structures. | |
| * | |
| * Therefore, freeing of already allocated messages occurs: | |
| * | |
| * - in ops->hw_params(), if this operator was called several times in a row, | |
| * or if ops->hw_free() failed to free messages previously; | |
| * | |
| * - in ops->hw_free(), if the queue has been successfully flushed; | |
| * | |
| * - in dev->release(). | |
| */ | |
| /* Map for converting ALSA format to VirtIO format. */ | |
| struct virtsnd_a2v_format { | |
| snd_pcm_format_t alsa_bit; | |
| unsigned int vio_bit; | |
| }; | |
| static const struct virtsnd_a2v_format g_a2v_format_map[] = { | |
| { SNDRV_PCM_FORMAT_IMA_ADPCM, VIRTIO_SND_PCM_FMT_IMA_ADPCM }, | |
| { SNDRV_PCM_FORMAT_MU_LAW, VIRTIO_SND_PCM_FMT_MU_LAW }, | |
| { SNDRV_PCM_FORMAT_A_LAW, VIRTIO_SND_PCM_FMT_A_LAW }, | |
| { SNDRV_PCM_FORMAT_S8, VIRTIO_SND_PCM_FMT_S8 }, | |
| { SNDRV_PCM_FORMAT_U8, VIRTIO_SND_PCM_FMT_U8 }, | |
| { SNDRV_PCM_FORMAT_S16_LE, VIRTIO_SND_PCM_FMT_S16 }, | |
| { SNDRV_PCM_FORMAT_U16_LE, VIRTIO_SND_PCM_FMT_U16 }, | |
| { SNDRV_PCM_FORMAT_S18_3LE, VIRTIO_SND_PCM_FMT_S18_3 }, | |
| { SNDRV_PCM_FORMAT_U18_3LE, VIRTIO_SND_PCM_FMT_U18_3 }, | |
| { SNDRV_PCM_FORMAT_S20_3LE, VIRTIO_SND_PCM_FMT_S20_3 }, | |
| { SNDRV_PCM_FORMAT_U20_3LE, VIRTIO_SND_PCM_FMT_U20_3 }, | |
| { SNDRV_PCM_FORMAT_S24_3LE, VIRTIO_SND_PCM_FMT_S24_3 }, | |
| { SNDRV_PCM_FORMAT_U24_3LE, VIRTIO_SND_PCM_FMT_U24_3 }, | |
| { SNDRV_PCM_FORMAT_S20_LE, VIRTIO_SND_PCM_FMT_S20 }, | |
| { SNDRV_PCM_FORMAT_U20_LE, VIRTIO_SND_PCM_FMT_U20 }, | |
| { SNDRV_PCM_FORMAT_S24_LE, VIRTIO_SND_PCM_FMT_S24 }, | |
| { SNDRV_PCM_FORMAT_U24_LE, VIRTIO_SND_PCM_FMT_U24 }, | |
| { SNDRV_PCM_FORMAT_S32_LE, VIRTIO_SND_PCM_FMT_S32 }, | |
| { SNDRV_PCM_FORMAT_U32_LE, VIRTIO_SND_PCM_FMT_U32 }, | |
| { SNDRV_PCM_FORMAT_FLOAT_LE, VIRTIO_SND_PCM_FMT_FLOAT }, | |
| { SNDRV_PCM_FORMAT_FLOAT64_LE, VIRTIO_SND_PCM_FMT_FLOAT64 }, | |
| { SNDRV_PCM_FORMAT_DSD_U8, VIRTIO_SND_PCM_FMT_DSD_U8 }, | |
| { SNDRV_PCM_FORMAT_DSD_U16_LE, VIRTIO_SND_PCM_FMT_DSD_U16 }, | |
| { SNDRV_PCM_FORMAT_DSD_U32_LE, VIRTIO_SND_PCM_FMT_DSD_U32 }, | |
| { SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE, | |
| VIRTIO_SND_PCM_FMT_IEC958_SUBFRAME } | |
| }; | |
| /* Map for converting ALSA frame rate to VirtIO frame rate. */ | |
| struct virtsnd_a2v_rate { | |
| unsigned int rate; | |
| unsigned int vio_bit; | |
| }; | |
| static const struct virtsnd_a2v_rate g_a2v_rate_map[] = { | |
| { 5512, VIRTIO_SND_PCM_RATE_5512 }, | |
| { 8000, VIRTIO_SND_PCM_RATE_8000 }, | |
| { 11025, VIRTIO_SND_PCM_RATE_11025 }, | |
| { 16000, VIRTIO_SND_PCM_RATE_16000 }, | |
| { 22050, VIRTIO_SND_PCM_RATE_22050 }, | |
| { 32000, VIRTIO_SND_PCM_RATE_32000 }, | |
| { 44100, VIRTIO_SND_PCM_RATE_44100 }, | |
| { 48000, VIRTIO_SND_PCM_RATE_48000 }, | |
| { 64000, VIRTIO_SND_PCM_RATE_64000 }, | |
| { 88200, VIRTIO_SND_PCM_RATE_88200 }, | |
| { 96000, VIRTIO_SND_PCM_RATE_96000 }, | |
| { 176400, VIRTIO_SND_PCM_RATE_176400 }, | |
| { 192000, VIRTIO_SND_PCM_RATE_192000 }, | |
| { 384000, VIRTIO_SND_PCM_RATE_384000 } | |
| }; | |
| static int virtsnd_pcm_sync_stop(struct snd_pcm_substream *substream); | |
| /** | |
| * virtsnd_pcm_open() - Open the PCM substream. | |
| * @substream: Kernel ALSA substream. | |
| * | |
| * Context: Process context. | |
| * Return: 0 on success, -errno on failure. | |
| */ | |
| static int virtsnd_pcm_open(struct snd_pcm_substream *substream) | |
| { | |
| struct virtio_pcm *vpcm = snd_pcm_substream_chip(substream); | |
| struct virtio_pcm_stream *vs = &vpcm->streams[substream->stream]; | |
| struct virtio_pcm_substream *vss = vs->substreams[substream->number]; | |
| substream->runtime->hw = vss->hw; | |
| substream->private_data = vss; | |
| snd_pcm_hw_constraint_integer(substream->runtime, | |
| SNDRV_PCM_HW_PARAM_PERIODS); | |
| vss->stopped = !!virtsnd_pcm_msg_pending_num(vss); | |
| vss->suspended = false; | |
| /* | |
| * If the substream has already been used, then the I/O queue may be in | |
| * an invalid state. Just in case, we do a check and try to return the | |
| * queue to its original state, if necessary. | |
| */ | |
| return virtsnd_pcm_sync_stop(substream); | |
| } | |
| /** | |
| * virtsnd_pcm_close() - Close the PCM substream. | |
| * @substream: Kernel ALSA substream. | |
| * | |
| * Context: Process context. | |
| * Return: 0. | |
| */ | |
| static int virtsnd_pcm_close(struct snd_pcm_substream *substream) | |
| { | |
| return 0; | |
| } | |
| /** | |
| * virtsnd_pcm_dev_set_params() - Set the parameters of the PCM substream on | |
| * the device side. | |
| * @vss: VirtIO PCM substream. | |
| * @buffer_bytes: Size of the hardware buffer. | |
| * @period_bytes: Size of the hardware period. | |
| * @channels: Selected number of channels. | |
| * @format: Selected sample format (SNDRV_PCM_FORMAT_XXX). | |
| * @rate: Selected frame rate. | |
| * | |
| * Context: Any context that permits to sleep. | |
| * Return: 0 on success, -errno on failure. | |
| */ | |
| static int virtsnd_pcm_dev_set_params(struct virtio_pcm_substream *vss, | |
| unsigned int buffer_bytes, | |
| unsigned int period_bytes, | |
| unsigned int channels, | |
| snd_pcm_format_t format, | |
| unsigned int rate) | |
| { | |
| struct virtio_snd_msg *msg; | |
| struct virtio_snd_pcm_set_params *request; | |
| unsigned int i; | |
| int vformat = -1; | |
| int vrate = -1; | |
| for (i = 0; i < ARRAY_SIZE(g_a2v_format_map); ++i) | |
| if (g_a2v_format_map[i].alsa_bit == format) { | |
| vformat = g_a2v_format_map[i].vio_bit; | |
| break; | |
| } | |
| for (i = 0; i < ARRAY_SIZE(g_a2v_rate_map); ++i) | |
| if (g_a2v_rate_map[i].rate == rate) { | |
| vrate = g_a2v_rate_map[i].vio_bit; | |
| break; | |
| } | |
| if (vformat == -1 || vrate == -1) | |
| return -EINVAL; | |
| msg = virtsnd_pcm_ctl_msg_alloc(vss, VIRTIO_SND_R_PCM_SET_PARAMS, | |
| GFP_KERNEL); | |
| if (!msg) | |
| return -ENOMEM; | |
| request = virtsnd_ctl_msg_request(msg); | |
| request->buffer_bytes = cpu_to_le32(buffer_bytes); | |
| request->period_bytes = cpu_to_le32(period_bytes); | |
| request->channels = channels; | |
| request->format = vformat; | |
| request->rate = vrate; | |
| if (vss->features & (1U << VIRTIO_SND_PCM_F_MSG_POLLING)) | |
| request->features |= | |
| cpu_to_le32(1U << VIRTIO_SND_PCM_F_MSG_POLLING); | |
| if (vss->features & (1U << VIRTIO_SND_PCM_F_EVT_XRUNS)) | |
| request->features |= | |
| cpu_to_le32(1U << VIRTIO_SND_PCM_F_EVT_XRUNS); | |
| return virtsnd_ctl_msg_send_sync(vss->snd, msg); | |
| } | |
| /** | |
| * virtsnd_pcm_hw_params() - Set the parameters of the PCM substream. | |
| * @substream: Kernel ALSA substream. | |
| * @hw_params: Hardware parameters. | |
| * | |
| * Context: Process context. | |
| * Return: 0 on success, -errno on failure. | |
| */ | |
| static int virtsnd_pcm_hw_params(struct snd_pcm_substream *substream, | |
| struct snd_pcm_hw_params *hw_params) | |
| { | |
| struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream); | |
| struct virtio_device *vdev = vss->snd->vdev; | |
| int rc; | |
| if (virtsnd_pcm_msg_pending_num(vss)) { | |
| dev_err(&vdev->dev, "SID %u: invalid I/O queue state\n", | |
| vss->sid); | |
| return -EBADFD; | |
| } | |
| rc = virtsnd_pcm_dev_set_params(vss, params_buffer_bytes(hw_params), | |
| params_period_bytes(hw_params), | |
| params_channels(hw_params), | |
| params_format(hw_params), | |
| params_rate(hw_params)); | |
| if (rc) | |
| return rc; | |
| /* | |
| * Free previously allocated messages if ops->hw_params() is called | |
| * several times in a row, or if ops->hw_free() failed to free messages. | |
| */ | |
| virtsnd_pcm_msg_free(vss); | |
| return virtsnd_pcm_msg_alloc(vss, params_periods(hw_params), | |
| params_period_bytes(hw_params)); | |
| } | |
| /** | |
| * virtsnd_pcm_hw_free() - Reset the parameters of the PCM substream. | |
| * @substream: Kernel ALSA substream. | |
| * | |
| * Context: Process context. | |
| * Return: 0 | |
| */ | |
| static int virtsnd_pcm_hw_free(struct snd_pcm_substream *substream) | |
| { | |
| struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream); | |
| /* If the queue is flushed, we can safely free the messages here. */ | |
| if (!virtsnd_pcm_msg_pending_num(vss)) | |
| virtsnd_pcm_msg_free(vss); | |
| return 0; | |
| } | |
| /** | |
| * virtsnd_pcm_prepare() - Prepare the PCM substream. | |
| * @substream: Kernel ALSA substream. | |
| * | |
| * Context: Process context. | |
| * Return: 0 on success, -errno on failure. | |
| */ | |
| static int virtsnd_pcm_prepare(struct snd_pcm_substream *substream) | |
| { | |
| struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream); | |
| struct virtio_device *vdev = vss->snd->vdev; | |
| struct virtio_snd_msg *msg; | |
| if (!vss->suspended) { | |
| if (virtsnd_pcm_msg_pending_num(vss)) { | |
| dev_err(&vdev->dev, "SID %u: invalid I/O queue state\n", | |
| vss->sid); | |
| return -EBADFD; | |
| } | |
| vss->buffer_bytes = snd_pcm_lib_buffer_bytes(substream); | |
| vss->hw_ptr = 0; | |
| } else { | |
| struct snd_pcm_runtime *runtime = substream->runtime; | |
| unsigned int buffer_bytes = snd_pcm_lib_buffer_bytes(substream); | |
| unsigned int period_bytes = snd_pcm_lib_period_bytes(substream); | |
| int rc; | |
| rc = virtsnd_pcm_dev_set_params(vss, buffer_bytes, period_bytes, | |
| runtime->channels, | |
| runtime->format, runtime->rate); | |
| if (rc) | |
| return rc; | |
| } | |
| vss->xfer_xrun = false; | |
| vss->suspended = false; | |
| vss->msg_count = 0; | |
| memset(&vss->pcm_indirect, 0, sizeof(vss->pcm_indirect)); | |
| vss->pcm_indirect.sw_buffer_size = | |
| vss->pcm_indirect.hw_buffer_size = | |
| snd_pcm_lib_buffer_bytes(substream); | |
| msg = virtsnd_pcm_ctl_msg_alloc(vss, VIRTIO_SND_R_PCM_PREPARE, | |
| GFP_KERNEL); | |
| if (!msg) | |
| return -ENOMEM; | |
| return virtsnd_ctl_msg_send_sync(vss->snd, msg); | |
| } | |
| /** | |
| * virtsnd_pcm_trigger() - Process command for the PCM substream. | |
| * @substream: Kernel ALSA substream. | |
| * @command: Substream command (SNDRV_PCM_TRIGGER_XXX). | |
| * | |
| * Context: Any context. Takes and releases the VirtIO substream spinlock. | |
| * May take and release the tx/rx queue spinlock. | |
| * Return: 0 on success, -errno on failure. | |
| */ | |
| static int virtsnd_pcm_trigger(struct snd_pcm_substream *substream, int command) | |
| { | |
| struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream); | |
| struct virtio_snd *snd = vss->snd; | |
| struct virtio_snd_queue *queue; | |
| struct virtio_snd_msg *msg; | |
| int rc = 0; | |
| switch (command) { | |
| case SNDRV_PCM_TRIGGER_START: | |
| case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: | |
| queue = virtsnd_pcm_queue(vss); | |
| scoped_guard(spinlock_irqsave, &queue->lock) { | |
| guard(spinlock)(&vss->lock); | |
| if (vss->direction == SNDRV_PCM_STREAM_CAPTURE) | |
| rc = virtsnd_pcm_msg_send(vss, 0, vss->buffer_bytes); | |
| if (rc) | |
| return rc; | |
| vss->xfer_enabled = true; | |
| } | |
| msg = virtsnd_pcm_ctl_msg_alloc(vss, VIRTIO_SND_R_PCM_START, | |
| GFP_KERNEL); | |
| if (!msg) { | |
| guard(spinlock_irqsave)(&vss->lock); | |
| vss->xfer_enabled = false; | |
| return -ENOMEM; | |
| } | |
| return virtsnd_ctl_msg_send_sync(snd, msg); | |
| case SNDRV_PCM_TRIGGER_SUSPEND: | |
| vss->suspended = true; | |
| fallthrough; | |
| case SNDRV_PCM_TRIGGER_STOP: | |
| vss->stopped = true; | |
| fallthrough; | |
| case SNDRV_PCM_TRIGGER_PAUSE_PUSH: | |
| scoped_guard(spinlock_irqsave, &vss->lock) { | |
| vss->xfer_enabled = false; | |
| } | |
| msg = virtsnd_pcm_ctl_msg_alloc(vss, VIRTIO_SND_R_PCM_STOP, | |
| GFP_KERNEL); | |
| if (!msg) | |
| return -ENOMEM; | |
| return virtsnd_ctl_msg_send_sync(snd, msg); | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| /** | |
| * virtsnd_pcm_sync_stop() - Synchronous PCM substream stop. | |
| * @substream: Kernel ALSA substream. | |
| * | |
| * The function can be called both from the upper level or from the driver | |
| * itself. | |
| * | |
| * Context: Process context. Takes and releases the VirtIO substream spinlock. | |
| * Return: 0 on success, -errno on failure. | |
| */ | |
| static int virtsnd_pcm_sync_stop(struct snd_pcm_substream *substream) | |
| { | |
| struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream); | |
| struct virtio_snd *snd = vss->snd; | |
| struct virtio_snd_msg *msg; | |
| unsigned int js = msecs_to_jiffies(virtsnd_msg_timeout_ms); | |
| int rc; | |
| cancel_work_sync(&vss->elapsed_period); | |
| if (!vss->stopped) | |
| return 0; | |
| msg = virtsnd_pcm_ctl_msg_alloc(vss, VIRTIO_SND_R_PCM_RELEASE, | |
| GFP_KERNEL); | |
| if (!msg) | |
| return -ENOMEM; | |
| rc = virtsnd_ctl_msg_send_sync(snd, msg); | |
| if (rc) | |
| return rc; | |
| /* | |
| * The spec states that upon receipt of the RELEASE command "the device | |
| * MUST complete all pending I/O messages for the specified stream ID". | |
| * Thus, we consider the absence of I/O messages in the queue as an | |
| * indication that the substream has been released. | |
| */ | |
| rc = wait_event_interruptible_timeout(vss->msg_empty, | |
| !virtsnd_pcm_msg_pending_num(vss), | |
| js); | |
| if (rc <= 0) { | |
| dev_warn(&snd->vdev->dev, "SID %u: failed to flush I/O queue\n", | |
| vss->sid); | |
| return !rc ? -ETIMEDOUT : rc; | |
| } | |
| vss->stopped = false; | |
| return 0; | |
| } | |
| /** | |
| * virtsnd_pcm_pb_pointer() - Get the current hardware position for the PCM | |
| * substream for playback. | |
| * @substream: Kernel ALSA substream. | |
| * | |
| * Context: Any context. | |
| * Return: Hardware position in frames inside [0 ... buffer_size) range. | |
| */ | |
| static snd_pcm_uframes_t | |
| virtsnd_pcm_pb_pointer(struct snd_pcm_substream *substream) | |
| { | |
| struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream); | |
| return snd_pcm_indirect_playback_pointer(substream, | |
| &vss->pcm_indirect, | |
| vss->hw_ptr); | |
| } | |
| /** | |
| * virtsnd_pcm_cp_pointer() - Get the current hardware position for the PCM | |
| * substream for capture. | |
| * @substream: Kernel ALSA substream. | |
| * | |
| * Context: Any context. | |
| * Return: Hardware position in frames inside [0 ... buffer_size) range. | |
| */ | |
| static snd_pcm_uframes_t | |
| virtsnd_pcm_cp_pointer(struct snd_pcm_substream *substream) | |
| { | |
| struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream); | |
| return snd_pcm_indirect_capture_pointer(substream, | |
| &vss->pcm_indirect, | |
| vss->hw_ptr); | |
| } | |
| static void virtsnd_pcm_trans_copy(struct snd_pcm_substream *substream, | |
| struct snd_pcm_indirect *rec, size_t bytes) | |
| { | |
| struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream); | |
| virtsnd_pcm_msg_send(vss, rec->sw_data, bytes); | |
| } | |
| static int virtsnd_pcm_pb_ack(struct snd_pcm_substream *substream) | |
| { | |
| struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream); | |
| struct virtio_snd_queue *queue = virtsnd_pcm_queue(vss); | |
| guard(spinlock_irqsave)(&queue->lock); | |
| guard(spinlock)(&vss->lock); | |
| return snd_pcm_indirect_playback_transfer(substream, &vss->pcm_indirect, | |
| virtsnd_pcm_trans_copy); | |
| } | |
| static int virtsnd_pcm_cp_ack(struct snd_pcm_substream *substream) | |
| { | |
| struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream); | |
| struct virtio_snd_queue *queue = virtsnd_pcm_queue(vss); | |
| guard(spinlock_irqsave)(&queue->lock); | |
| guard(spinlock)(&vss->lock); | |
| return snd_pcm_indirect_capture_transfer(substream, &vss->pcm_indirect, | |
| virtsnd_pcm_trans_copy); | |
| } | |
| /* PCM substream operators map. */ | |
| const struct snd_pcm_ops virtsnd_pcm_ops[] = { | |
| { | |
| .open = virtsnd_pcm_open, | |
| .close = virtsnd_pcm_close, | |
| .ioctl = snd_pcm_lib_ioctl, | |
| .hw_params = virtsnd_pcm_hw_params, | |
| .hw_free = virtsnd_pcm_hw_free, | |
| .prepare = virtsnd_pcm_prepare, | |
| .trigger = virtsnd_pcm_trigger, | |
| .sync_stop = virtsnd_pcm_sync_stop, | |
| .pointer = virtsnd_pcm_pb_pointer, | |
| .ack = virtsnd_pcm_pb_ack, | |
| }, | |
| { | |
| .open = virtsnd_pcm_open, | |
| .close = virtsnd_pcm_close, | |
| .ioctl = snd_pcm_lib_ioctl, | |
| .hw_params = virtsnd_pcm_hw_params, | |
| .hw_free = virtsnd_pcm_hw_free, | |
| .prepare = virtsnd_pcm_prepare, | |
| .trigger = virtsnd_pcm_trigger, | |
| .sync_stop = virtsnd_pcm_sync_stop, | |
| .pointer = virtsnd_pcm_cp_pointer, | |
| .ack = virtsnd_pcm_cp_ack, | |
| }, | |
| }; |