virtio_pcm_ops.c

  1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 * virtio-snd: Virtio sound device
  4 * Copyright (C) 2021 OpenSynergy GmbH
  5 */
  6#include <sound/pcm_params.h>
  7
  8#include "virtio_card.h"
  9
 10/*
 11 * I/O messages lifetime
 12 * ---------------------
 13 *
 14 * Allocation:
 15 *   Messages are initially allocated in the ops->hw_params() after the size and
 16 *   number of periods have been successfully negotiated.
 17 *
 18 * Freeing:
 19 *   Messages can be safely freed after the queue has been successfully flushed
 20 *   (RELEASE command in the ops->sync_stop()) and the ops->hw_free() has been
 21 *   called.
 22 *
 23 *   When the substream stops, the ops->sync_stop() waits until the device has
 24 *   completed all pending messages. This wait can be interrupted either by a
 25 *   signal or due to a timeout. In this case, the device can still access
 26 *   messages even after calling ops->hw_free(). It can also issue an interrupt,
 27 *   and the interrupt handler will also try to access message structures.
 28 *
 29 *   Therefore, freeing of already allocated messages occurs:
 30 *
 31 *   - in ops->hw_params(), if this operator was called several times in a row,
 32 *     or if ops->hw_free() failed to free messages previously;
 33 *
 34 *   - in ops->hw_free(), if the queue has been successfully flushed;
 35 *
 36 *   - in dev->release().
 37 */
 38
 39/* Map for converting ALSA format to VirtIO format. */
 40struct virtsnd_a2v_format {
 41	snd_pcm_format_t alsa_bit;
 42	unsigned int vio_bit;
 43};
 44
 45static const struct virtsnd_a2v_format g_a2v_format_map[] = {
 46	{ SNDRV_PCM_FORMAT_IMA_ADPCM, VIRTIO_SND_PCM_FMT_IMA_ADPCM },
 47	{ SNDRV_PCM_FORMAT_MU_LAW, VIRTIO_SND_PCM_FMT_MU_LAW },
 48	{ SNDRV_PCM_FORMAT_A_LAW, VIRTIO_SND_PCM_FMT_A_LAW },
 49	{ SNDRV_PCM_FORMAT_S8, VIRTIO_SND_PCM_FMT_S8 },
 50	{ SNDRV_PCM_FORMAT_U8, VIRTIO_SND_PCM_FMT_U8 },
 51	{ SNDRV_PCM_FORMAT_S16_LE, VIRTIO_SND_PCM_FMT_S16 },
 52	{ SNDRV_PCM_FORMAT_U16_LE, VIRTIO_SND_PCM_FMT_U16 },
 53	{ SNDRV_PCM_FORMAT_S18_3LE, VIRTIO_SND_PCM_FMT_S18_3 },
 54	{ SNDRV_PCM_FORMAT_U18_3LE, VIRTIO_SND_PCM_FMT_U18_3 },
 55	{ SNDRV_PCM_FORMAT_S20_3LE, VIRTIO_SND_PCM_FMT_S20_3 },
 56	{ SNDRV_PCM_FORMAT_U20_3LE, VIRTIO_SND_PCM_FMT_U20_3 },
 57	{ SNDRV_PCM_FORMAT_S24_3LE, VIRTIO_SND_PCM_FMT_S24_3 },
 58	{ SNDRV_PCM_FORMAT_U24_3LE, VIRTIO_SND_PCM_FMT_U24_3 },
 59	{ SNDRV_PCM_FORMAT_S20_LE, VIRTIO_SND_PCM_FMT_S20 },
 60	{ SNDRV_PCM_FORMAT_U20_LE, VIRTIO_SND_PCM_FMT_U20 },
 61	{ SNDRV_PCM_FORMAT_S24_LE, VIRTIO_SND_PCM_FMT_S24 },
 62	{ SNDRV_PCM_FORMAT_U24_LE, VIRTIO_SND_PCM_FMT_U24 },
 63	{ SNDRV_PCM_FORMAT_S32_LE, VIRTIO_SND_PCM_FMT_S32 },
 64	{ SNDRV_PCM_FORMAT_U32_LE, VIRTIO_SND_PCM_FMT_U32 },
 65	{ SNDRV_PCM_FORMAT_FLOAT_LE, VIRTIO_SND_PCM_FMT_FLOAT },
 66	{ SNDRV_PCM_FORMAT_FLOAT64_LE, VIRTIO_SND_PCM_FMT_FLOAT64 },
 67	{ SNDRV_PCM_FORMAT_DSD_U8, VIRTIO_SND_PCM_FMT_DSD_U8 },
 68	{ SNDRV_PCM_FORMAT_DSD_U16_LE, VIRTIO_SND_PCM_FMT_DSD_U16 },
 69	{ SNDRV_PCM_FORMAT_DSD_U32_LE, VIRTIO_SND_PCM_FMT_DSD_U32 },
 70	{ SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE,
 71	  VIRTIO_SND_PCM_FMT_IEC958_SUBFRAME }
 72};
 73
 74/* Map for converting ALSA frame rate to VirtIO frame rate. */
 75struct virtsnd_a2v_rate {
 76	unsigned int rate;
 77	unsigned int vio_bit;
 78};
 79
 80static const struct virtsnd_a2v_rate g_a2v_rate_map[] = {
 81	{ 5512, VIRTIO_SND_PCM_RATE_5512 },
 82	{ 8000, VIRTIO_SND_PCM_RATE_8000 },
 83	{ 11025, VIRTIO_SND_PCM_RATE_11025 },
 84	{ 16000, VIRTIO_SND_PCM_RATE_16000 },
 85	{ 22050, VIRTIO_SND_PCM_RATE_22050 },
 86	{ 32000, VIRTIO_SND_PCM_RATE_32000 },
 87	{ 44100, VIRTIO_SND_PCM_RATE_44100 },
 88	{ 48000, VIRTIO_SND_PCM_RATE_48000 },
 89	{ 64000, VIRTIO_SND_PCM_RATE_64000 },
 90	{ 88200, VIRTIO_SND_PCM_RATE_88200 },
 91	{ 96000, VIRTIO_SND_PCM_RATE_96000 },
 92	{ 176400, VIRTIO_SND_PCM_RATE_176400 },
 93	{ 192000, VIRTIO_SND_PCM_RATE_192000 }
 94};
 95
 96static int virtsnd_pcm_sync_stop(struct snd_pcm_substream *substream);
 97
 98/**
 99 * virtsnd_pcm_open() - Open the PCM substream.
100 * @substream: Kernel ALSA substream.
101 *
102 * Context: Process context.
103 * Return: 0 on success, -errno on failure.
104 */
105static int virtsnd_pcm_open(struct snd_pcm_substream *substream)
106{
107	struct virtio_pcm *vpcm = snd_pcm_substream_chip(substream);
108	struct virtio_pcm_stream *vs = &vpcm->streams[substream->stream];
109	struct virtio_pcm_substream *vss = vs->substreams[substream->number];
110
111	substream->runtime->hw = vss->hw;
112	substream->private_data = vss;
113
114	snd_pcm_hw_constraint_integer(substream->runtime,
115				      SNDRV_PCM_HW_PARAM_PERIODS);
116
117	vss->stopped = !!virtsnd_pcm_msg_pending_num(vss);
118	vss->suspended = false;
119
120	/*
121	 * If the substream has already been used, then the I/O queue may be in
122	 * an invalid state. Just in case, we do a check and try to return the
123	 * queue to its original state, if necessary.
124	 */
125	return virtsnd_pcm_sync_stop(substream);
126}
127
128/**
129 * virtsnd_pcm_close() - Close the PCM substream.
130 * @substream: Kernel ALSA substream.
131 *
132 * Context: Process context.
133 * Return: 0.
134 */
135static int virtsnd_pcm_close(struct snd_pcm_substream *substream)
136{
137	return 0;
138}
139
140/**
141 * virtsnd_pcm_dev_set_params() - Set the parameters of the PCM substream on
142 *                                the device side.
143 * @vss: VirtIO PCM substream.
144 * @buffer_bytes: Size of the hardware buffer.
145 * @period_bytes: Size of the hardware period.
146 * @channels: Selected number of channels.
147 * @format: Selected sample format (SNDRV_PCM_FORMAT_XXX).
148 * @rate: Selected frame rate.
149 *
150 * Context: Any context that permits to sleep.
151 * Return: 0 on success, -errno on failure.
152 */
153static int virtsnd_pcm_dev_set_params(struct virtio_pcm_substream *vss,
154				      unsigned int buffer_bytes,
155				      unsigned int period_bytes,
156				      unsigned int channels,
157				      snd_pcm_format_t format,
158				      unsigned int rate)
159{
160	struct virtio_snd_msg *msg;
161	struct virtio_snd_pcm_set_params *request;
162	unsigned int i;
163	int vformat = -1;
164	int vrate = -1;
165
166	for (i = 0; i < ARRAY_SIZE(g_a2v_format_map); ++i)
167		if (g_a2v_format_map[i].alsa_bit == format) {
168			vformat = g_a2v_format_map[i].vio_bit;
169
170			break;
171		}
172
173	for (i = 0; i < ARRAY_SIZE(g_a2v_rate_map); ++i)
174		if (g_a2v_rate_map[i].rate == rate) {
175			vrate = g_a2v_rate_map[i].vio_bit;
176
177			break;
178		}
179
180	if (vformat == -1 || vrate == -1)
181		return -EINVAL;
182
183	msg = virtsnd_pcm_ctl_msg_alloc(vss, VIRTIO_SND_R_PCM_SET_PARAMS,
184					GFP_KERNEL);
185	if (!msg)
186		return -ENOMEM;
187
188	request = virtsnd_ctl_msg_request(msg);
189	request->buffer_bytes = cpu_to_le32(buffer_bytes);
190	request->period_bytes = cpu_to_le32(period_bytes);
191	request->channels = channels;
192	request->format = vformat;
193	request->rate = vrate;
194
195	if (vss->features & (1U << VIRTIO_SND_PCM_F_MSG_POLLING))
196		request->features |=
197			cpu_to_le32(1U << VIRTIO_SND_PCM_F_MSG_POLLING);
198
199	if (vss->features & (1U << VIRTIO_SND_PCM_F_EVT_XRUNS))
200		request->features |=
201			cpu_to_le32(1U << VIRTIO_SND_PCM_F_EVT_XRUNS);
202
203	return virtsnd_ctl_msg_send_sync(vss->snd, msg);
204}
205
206/**
207 * virtsnd_pcm_hw_params() - Set the parameters of the PCM substream.
208 * @substream: Kernel ALSA substream.
209 * @hw_params: Hardware parameters.
210 *
211 * Context: Process context.
212 * Return: 0 on success, -errno on failure.
213 */
214static int virtsnd_pcm_hw_params(struct snd_pcm_substream *substream,
215				 struct snd_pcm_hw_params *hw_params)
216{
217	struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
218	struct virtio_device *vdev = vss->snd->vdev;
219	int rc;
220
221	if (virtsnd_pcm_msg_pending_num(vss)) {
222		dev_err(&vdev->dev, "SID %u: invalid I/O queue state\n",
223			vss->sid);
224		return -EBADFD;
225	}
226
227	rc = virtsnd_pcm_dev_set_params(vss, params_buffer_bytes(hw_params),
228					params_period_bytes(hw_params),
229					params_channels(hw_params),
230					params_format(hw_params),
231					params_rate(hw_params));
232	if (rc)
233		return rc;
234
235	/*
236	 * Free previously allocated messages if ops->hw_params() is called
237	 * several times in a row, or if ops->hw_free() failed to free messages.
238	 */
239	virtsnd_pcm_msg_free(vss);
240
241	return virtsnd_pcm_msg_alloc(vss, params_periods(hw_params),
242				     params_period_bytes(hw_params));
243}
244
245/**
246 * virtsnd_pcm_hw_free() - Reset the parameters of the PCM substream.
247 * @substream: Kernel ALSA substream.
248 *
249 * Context: Process context.
250 * Return: 0
251 */
252static int virtsnd_pcm_hw_free(struct snd_pcm_substream *substream)
253{
254	struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
255
256	/* If the queue is flushed, we can safely free the messages here. */
257	if (!virtsnd_pcm_msg_pending_num(vss))
258		virtsnd_pcm_msg_free(vss);
259
260	return 0;
261}
262
263/**
264 * virtsnd_pcm_prepare() - Prepare the PCM substream.
265 * @substream: Kernel ALSA substream.
266 *
267 * Context: Process context.
268 * Return: 0 on success, -errno on failure.
269 */
270static int virtsnd_pcm_prepare(struct snd_pcm_substream *substream)
271{
272	struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
273	struct virtio_device *vdev = vss->snd->vdev;
274	struct virtio_snd_msg *msg;
275
276	if (!vss->suspended) {
277		if (virtsnd_pcm_msg_pending_num(vss)) {
278			dev_err(&vdev->dev, "SID %u: invalid I/O queue state\n",
279				vss->sid);
280			return -EBADFD;
281		}
282
283		vss->buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
284		vss->hw_ptr = 0;
285	} else {
286		struct snd_pcm_runtime *runtime = substream->runtime;
287		unsigned int buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
288		unsigned int period_bytes = snd_pcm_lib_period_bytes(substream);
289		int rc;
290
291		rc = virtsnd_pcm_dev_set_params(vss, buffer_bytes, period_bytes,
292						runtime->channels,
293						runtime->format, runtime->rate);
294		if (rc)
295			return rc;
296	}
297
298	vss->xfer_xrun = false;
299	vss->suspended = false;
300	vss->msg_count = 0;
301
302	memset(&vss->pcm_indirect, 0, sizeof(vss->pcm_indirect));
303	vss->pcm_indirect.sw_buffer_size =
304		vss->pcm_indirect.hw_buffer_size =
305		snd_pcm_lib_buffer_bytes(substream);
306
307	msg = virtsnd_pcm_ctl_msg_alloc(vss, VIRTIO_SND_R_PCM_PREPARE,
308					GFP_KERNEL);
309	if (!msg)
310		return -ENOMEM;
311
312	return virtsnd_ctl_msg_send_sync(vss->snd, msg);
313}
314
315/**
316 * virtsnd_pcm_trigger() - Process command for the PCM substream.
317 * @substream: Kernel ALSA substream.
318 * @command: Substream command (SNDRV_PCM_TRIGGER_XXX).
319 *
320 * Context: Any context. Takes and releases the VirtIO substream spinlock.
321 *          May take and release the tx/rx queue spinlock.
322 * Return: 0 on success, -errno on failure.
323 */
324static int virtsnd_pcm_trigger(struct snd_pcm_substream *substream, int command)
325{
326	struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
327	struct virtio_snd *snd = vss->snd;
328	struct virtio_snd_queue *queue;
329	struct virtio_snd_msg *msg;
330	int rc = 0;
331
332	switch (command) {
333	case SNDRV_PCM_TRIGGER_START:
334	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
335		queue = virtsnd_pcm_queue(vss);
336
337		scoped_guard(spinlock_irqsave, &queue->lock) {
338			guard(spinlock)(&vss->lock);
339			if (vss->direction == SNDRV_PCM_STREAM_CAPTURE)
340				rc = virtsnd_pcm_msg_send(vss, 0, vss->buffer_bytes);
341			if (rc)
342				return rc;
343			vss->xfer_enabled = true;
344		}
345
346		msg = virtsnd_pcm_ctl_msg_alloc(vss, VIRTIO_SND_R_PCM_START,
347						GFP_KERNEL);
348		if (!msg) {
349			guard(spinlock_irqsave)(&vss->lock);
350			vss->xfer_enabled = false;
351
352			return -ENOMEM;
353		}
354
355		return virtsnd_ctl_msg_send_sync(snd, msg);
356	case SNDRV_PCM_TRIGGER_SUSPEND:
357		vss->suspended = true;
358		fallthrough;
359	case SNDRV_PCM_TRIGGER_STOP:
360		vss->stopped = true;
361		fallthrough;
362	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
363		scoped_guard(spinlock_irqsave, &vss->lock) {
364			vss->xfer_enabled = false;
365		}
366
367		msg = virtsnd_pcm_ctl_msg_alloc(vss, VIRTIO_SND_R_PCM_STOP,
368						GFP_KERNEL);
369		if (!msg)
370			return -ENOMEM;
371
372		return virtsnd_ctl_msg_send_sync(snd, msg);
373	default:
374		return -EINVAL;
375	}
376}
377
378/**
379 * virtsnd_pcm_sync_stop() - Synchronous PCM substream stop.
380 * @substream: Kernel ALSA substream.
381 *
382 * The function can be called both from the upper level or from the driver
383 * itself.
384 *
385 * Context: Process context. Takes and releases the VirtIO substream spinlock.
386 * Return: 0 on success, -errno on failure.
387 */
388static int virtsnd_pcm_sync_stop(struct snd_pcm_substream *substream)
389{
390	struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
391	struct virtio_snd *snd = vss->snd;
392	struct virtio_snd_msg *msg;
393	unsigned int js = msecs_to_jiffies(virtsnd_msg_timeout_ms);
394	int rc;
395
396	cancel_work_sync(&vss->elapsed_period);
397
398	if (!vss->stopped)
399		return 0;
400
401	msg = virtsnd_pcm_ctl_msg_alloc(vss, VIRTIO_SND_R_PCM_RELEASE,
402					GFP_KERNEL);
403	if (!msg)
404		return -ENOMEM;
405
406	rc = virtsnd_ctl_msg_send_sync(snd, msg);
407	if (rc)
408		return rc;
409
410	/*
411	 * The spec states that upon receipt of the RELEASE command "the device
412	 * MUST complete all pending I/O messages for the specified stream ID".
413	 * Thus, we consider the absence of I/O messages in the queue as an
414	 * indication that the substream has been released.
415	 */
416	rc = wait_event_interruptible_timeout(vss->msg_empty,
417					      !virtsnd_pcm_msg_pending_num(vss),
418					      js);
419	if (rc <= 0) {
420		dev_warn(&snd->vdev->dev, "SID %u: failed to flush I/O queue\n",
421			 vss->sid);
422
423		return !rc ? -ETIMEDOUT : rc;
424	}
425
426	vss->stopped = false;
427
428	return 0;
429}
430
431/**
432 * virtsnd_pcm_pb_pointer() - Get the current hardware position for the PCM
433 *                         substream for playback.
434 * @substream: Kernel ALSA substream.
435 *
436 * Context: Any context.
437 * Return: Hardware position in frames inside [0 ... buffer_size) range.
438 */
439static snd_pcm_uframes_t
440virtsnd_pcm_pb_pointer(struct snd_pcm_substream *substream)
441{
442	struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
443
444	return snd_pcm_indirect_playback_pointer(substream,
445		&vss->pcm_indirect,
446		vss->hw_ptr);
447}
448
449/**
450 * virtsnd_pcm_cp_pointer() - Get the current hardware position for the PCM
451 *                         substream for capture.
452 * @substream: Kernel ALSA substream.
453 *
454 * Context: Any context.
455 * Return: Hardware position in frames inside [0 ... buffer_size) range.
456 */
457static snd_pcm_uframes_t
458virtsnd_pcm_cp_pointer(struct snd_pcm_substream *substream)
459{
460	struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
461
462	return snd_pcm_indirect_capture_pointer(substream,
463		&vss->pcm_indirect,
464		vss->hw_ptr);
465}
466
467static void virtsnd_pcm_trans_copy(struct snd_pcm_substream *substream,
468				   struct snd_pcm_indirect *rec, size_t bytes)
469{
470	struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
471
472	virtsnd_pcm_msg_send(vss, rec->sw_data, bytes);
473}
474
475static int virtsnd_pcm_pb_ack(struct snd_pcm_substream *substream)
476{
477	struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
478	struct virtio_snd_queue *queue = virtsnd_pcm_queue(vss);
479
480	guard(spinlock_irqsave)(&queue->lock);
481	guard(spinlock)(&vss->lock);
482
483	return snd_pcm_indirect_playback_transfer(substream, &vss->pcm_indirect,
484						  virtsnd_pcm_trans_copy);
485}
486
487static int virtsnd_pcm_cp_ack(struct snd_pcm_substream *substream)
488{
489	struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
490	struct virtio_snd_queue *queue = virtsnd_pcm_queue(vss);
491
492	guard(spinlock_irqsave)(&queue->lock);
493	guard(spinlock)(&vss->lock);
494
495	return snd_pcm_indirect_capture_transfer(substream, &vss->pcm_indirect,
496						 virtsnd_pcm_trans_copy);
497}
498
499/* PCM substream operators map. */
500const struct snd_pcm_ops virtsnd_pcm_ops[] = {
501	{
502		.open = virtsnd_pcm_open,
503		.close = virtsnd_pcm_close,
504		.ioctl = snd_pcm_lib_ioctl,
505		.hw_params = virtsnd_pcm_hw_params,
506		.hw_free = virtsnd_pcm_hw_free,
507		.prepare = virtsnd_pcm_prepare,
508		.trigger = virtsnd_pcm_trigger,
509		.sync_stop = virtsnd_pcm_sync_stop,
510		.pointer = virtsnd_pcm_pb_pointer,
511		.ack = virtsnd_pcm_pb_ack,
512	},
513	{
514		.open = virtsnd_pcm_open,
515		.close = virtsnd_pcm_close,
516		.ioctl = snd_pcm_lib_ioctl,
517		.hw_params = virtsnd_pcm_hw_params,
518		.hw_free = virtsnd_pcm_hw_free,
519		.prepare = virtsnd_pcm_prepare,
520		.trigger = virtsnd_pcm_trigger,
521		.sync_stop = virtsnd_pcm_sync_stop,
522		.pointer = virtsnd_pcm_cp_pointer,
523		.ack = virtsnd_pcm_cp_ack,
524	},
525};