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. */
40 struct virtsnd_a2v_format {
41 snd_pcm_format_t alsa_bit;
42 unsigned int vio_bit;
43 };
44
45 static 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. */
75 struct virtsnd_a2v_rate {
76 unsigned int rate;
77 unsigned int vio_bit;
78 };
79
80 static 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
96 static 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 */
105 static 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 */
135 static 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 */
153 static 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 */
214 static 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 */
252 static 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 */
270 static 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 */
324 static 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 unsigned long flags;
331 int rc = 0;
332
333 switch (command) {
334 case SNDRV_PCM_TRIGGER_START:
335 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
336 queue = virtsnd_pcm_queue(vss);
337
338 spin_lock_irqsave(&queue->lock, flags);
339 spin_lock(&vss->lock);
340 if (vss->direction == SNDRV_PCM_STREAM_CAPTURE)
341 rc = virtsnd_pcm_msg_send(vss, 0, vss->buffer_bytes);
342 if (!rc)
343 vss->xfer_enabled = true;
344 spin_unlock(&vss->lock);
345 spin_unlock_irqrestore(&queue->lock, flags);
346 if (rc)
347 return rc;
348
349 msg = virtsnd_pcm_ctl_msg_alloc(vss, VIRTIO_SND_R_PCM_START,
350 GFP_KERNEL);
351 if (!msg) {
352 spin_lock_irqsave(&vss->lock, flags);
353 vss->xfer_enabled = false;
354 spin_unlock_irqrestore(&vss->lock, flags);
355
356 return -ENOMEM;
357 }
358
359 return virtsnd_ctl_msg_send_sync(snd, msg);
360 case SNDRV_PCM_TRIGGER_SUSPEND:
361 vss->suspended = true;
362 fallthrough;
363 case SNDRV_PCM_TRIGGER_STOP:
364 vss->stopped = true;
365 fallthrough;
366 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
367 spin_lock_irqsave(&vss->lock, flags);
368 vss->xfer_enabled = false;
369 spin_unlock_irqrestore(&vss->lock, flags);
370
371 msg = virtsnd_pcm_ctl_msg_alloc(vss, VIRTIO_SND_R_PCM_STOP,
372 GFP_KERNEL);
373 if (!msg)
374 return -ENOMEM;
375
376 return virtsnd_ctl_msg_send_sync(snd, msg);
377 default:
378 return -EINVAL;
379 }
380 }
381
382 /**
383 * virtsnd_pcm_sync_stop() - Synchronous PCM substream stop.
384 * @substream: Kernel ALSA substream.
385 *
386 * The function can be called both from the upper level or from the driver
387 * itself.
388 *
389 * Context: Process context. Takes and releases the VirtIO substream spinlock.
390 * Return: 0 on success, -errno on failure.
391 */
392 static int virtsnd_pcm_sync_stop(struct snd_pcm_substream *substream)
393 {
394 struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
395 struct virtio_snd *snd = vss->snd;
396 struct virtio_snd_msg *msg;
397 unsigned int js = msecs_to_jiffies(virtsnd_msg_timeout_ms);
398 int rc;
399
400 cancel_work_sync(&vss->elapsed_period);
401
402 if (!vss->stopped)
403 return 0;
404
405 msg = virtsnd_pcm_ctl_msg_alloc(vss, VIRTIO_SND_R_PCM_RELEASE,
406 GFP_KERNEL);
407 if (!msg)
408 return -ENOMEM;
409
410 rc = virtsnd_ctl_msg_send_sync(snd, msg);
411 if (rc)
412 return rc;
413
414 /*
415 * The spec states that upon receipt of the RELEASE command "the device
416 * MUST complete all pending I/O messages for the specified stream ID".
417 * Thus, we consider the absence of I/O messages in the queue as an
418 * indication that the substream has been released.
419 */
420 rc = wait_event_interruptible_timeout(vss->msg_empty,
421 !virtsnd_pcm_msg_pending_num(vss),
422 js);
423 if (rc <= 0) {
424 dev_warn(&snd->vdev->dev, "SID %u: failed to flush I/O queue\n",
425 vss->sid);
426
427 return !rc ? -ETIMEDOUT : rc;
428 }
429
430 vss->stopped = false;
431
432 return 0;
433 }
434
435 /**
436 * virtsnd_pcm_pb_pointer() - Get the current hardware position for the PCM
437 * substream for playback.
438 * @substream: Kernel ALSA substream.
439 *
440 * Context: Any context.
441 * Return: Hardware position in frames inside [0 ... buffer_size) range.
442 */
443 static snd_pcm_uframes_t
444 virtsnd_pcm_pb_pointer(struct snd_pcm_substream *substream)
445 {
446 struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
447
448 return snd_pcm_indirect_playback_pointer(substream,
449 &vss->pcm_indirect,
450 vss->hw_ptr);
451 }
452
453 /**
454 * virtsnd_pcm_cp_pointer() - Get the current hardware position for the PCM
455 * substream for capture.
456 * @substream: Kernel ALSA substream.
457 *
458 * Context: Any context.
459 * Return: Hardware position in frames inside [0 ... buffer_size) range.
460 */
461 static snd_pcm_uframes_t
462 virtsnd_pcm_cp_pointer(struct snd_pcm_substream *substream)
463 {
464 struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
465
466 return snd_pcm_indirect_capture_pointer(substream,
467 &vss->pcm_indirect,
468 vss->hw_ptr);
469 }
470
471 static void virtsnd_pcm_trans_copy(struct snd_pcm_substream *substream,
472 struct snd_pcm_indirect *rec, size_t bytes)
473 {
474 struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
475
476 virtsnd_pcm_msg_send(vss, rec->sw_data, bytes);
477 }
478
479 static int virtsnd_pcm_pb_ack(struct snd_pcm_substream *substream)
480 {
481 struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
482 struct virtio_snd_queue *queue = virtsnd_pcm_queue(vss);
483 unsigned long flags;
484 int rc;
485
486 spin_lock_irqsave(&queue->lock, flags);
487 spin_lock(&vss->lock);
488
489 rc = snd_pcm_indirect_playback_transfer(substream, &vss->pcm_indirect,
490 virtsnd_pcm_trans_copy);
491
492 spin_unlock(&vss->lock);
493 spin_unlock_irqrestore(&queue->lock, flags);
494
495 return rc;
496 }
497
498 static int virtsnd_pcm_cp_ack(struct snd_pcm_substream *substream)
499 {
500 struct virtio_pcm_substream *vss = snd_pcm_substream_chip(substream);
501 struct virtio_snd_queue *queue = virtsnd_pcm_queue(vss);
502 unsigned long flags;
503 int rc;
504
505 spin_lock_irqsave(&queue->lock, flags);
506 spin_lock(&vss->lock);
507
508 rc = snd_pcm_indirect_capture_transfer(substream, &vss->pcm_indirect,
509 virtsnd_pcm_trans_copy);
510
511 spin_unlock(&vss->lock);
512 spin_unlock_irqrestore(&queue->lock, flags);
513
514 return rc;
515 }
516
517 /* PCM substream operators map. */
518 const struct snd_pcm_ops virtsnd_pcm_ops[] = {
519 {
520 .open = virtsnd_pcm_open,
521 .close = virtsnd_pcm_close,
522 .ioctl = snd_pcm_lib_ioctl,
523 .hw_params = virtsnd_pcm_hw_params,
524 .hw_free = virtsnd_pcm_hw_free,
525 .prepare = virtsnd_pcm_prepare,
526 .trigger = virtsnd_pcm_trigger,
527 .sync_stop = virtsnd_pcm_sync_stop,
528 .pointer = virtsnd_pcm_pb_pointer,
529 .ack = virtsnd_pcm_pb_ack,
530 },
531 {
532 .open = virtsnd_pcm_open,
533 .close = virtsnd_pcm_close,
534 .ioctl = snd_pcm_lib_ioctl,
535 .hw_params = virtsnd_pcm_hw_params,
536 .hw_free = virtsnd_pcm_hw_free,
537 .prepare = virtsnd_pcm_prepare,
538 .trigger = virtsnd_pcm_trigger,
539 .sync_stop = virtsnd_pcm_sync_stop,
540 .pointer = virtsnd_pcm_cp_pointer,
541 .ack = virtsnd_pcm_cp_ack,
542 },
543 };
544
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.