1 /*
2 * VIRTIO Sound Device conforming to
3 *
4 * "Virtual I/O Device (VIRTIO) Version 1.2
5 * Committee Specification Draft 01
6 * 09 May 2022"
7 *
8 * <https://docs.oasis-open.org/virtio/virtio/v1.2/csd01/virtio-v1.2-csd01.html#x1-52900014>
9 *
10 * Copyright (c) 2023 Emmanouil Pitsidianakis <manos.pitsidianakis@linaro.org>
11 * Copyright (C) 2019 OpenSynergy GmbH
12 *
13 * This work is licensed under the terms of the GNU GPL, version 2 or
14 * (at your option) any later version. See the COPYING file in the
15 * top-level directory.
16 */
17
18 #include "qemu/osdep.h"
19 #include "qemu/iov.h"
20 #include "qemu/log.h"
21 #include "qemu/error-report.h"
22 #include "qemu/lockable.h"
23 #include "exec/tswap.h"
24 #include "sysemu/runstate.h"
25 #include "trace.h"
26 #include "qapi/error.h"
27 #include "hw/audio/virtio-snd.h"
28
29 #define VIRTIO_SOUND_VM_VERSION 1
30 #define VIRTIO_SOUND_JACK_DEFAULT 0
31 #define VIRTIO_SOUND_STREAM_DEFAULT 2
32 #define VIRTIO_SOUND_CHMAP_DEFAULT 0
33 #define VIRTIO_SOUND_HDA_FN_NID 0
34
35 static void virtio_snd_pcm_out_cb(void *data, int available);
36 static void virtio_snd_process_cmdq(VirtIOSound *s);
37 static void virtio_snd_pcm_flush(VirtIOSoundPCMStream *stream);
38 static void virtio_snd_pcm_in_cb(void *data, int available);
39 static void virtio_snd_unrealize(DeviceState *dev);
40
41 static uint32_t supported_formats = BIT(VIRTIO_SND_PCM_FMT_S8)
42 | BIT(VIRTIO_SND_PCM_FMT_U8)
43 | BIT(VIRTIO_SND_PCM_FMT_S16)
44 | BIT(VIRTIO_SND_PCM_FMT_U16)
45 | BIT(VIRTIO_SND_PCM_FMT_S32)
46 | BIT(VIRTIO_SND_PCM_FMT_U32)
47 | BIT(VIRTIO_SND_PCM_FMT_FLOAT);
48
49 static uint32_t supported_rates = BIT(VIRTIO_SND_PCM_RATE_5512)
50 | BIT(VIRTIO_SND_PCM_RATE_8000)
51 | BIT(VIRTIO_SND_PCM_RATE_11025)
52 | BIT(VIRTIO_SND_PCM_RATE_16000)
53 | BIT(VIRTIO_SND_PCM_RATE_22050)
54 | BIT(VIRTIO_SND_PCM_RATE_32000)
55 | BIT(VIRTIO_SND_PCM_RATE_44100)
56 | BIT(VIRTIO_SND_PCM_RATE_48000)
57 | BIT(VIRTIO_SND_PCM_RATE_64000)
58 | BIT(VIRTIO_SND_PCM_RATE_88200)
59 | BIT(VIRTIO_SND_PCM_RATE_96000)
60 | BIT(VIRTIO_SND_PCM_RATE_176400)
61 | BIT(VIRTIO_SND_PCM_RATE_192000)
62 | BIT(VIRTIO_SND_PCM_RATE_384000);
63
64 static const VMStateDescription vmstate_virtio_snd_device = {
65 .name = TYPE_VIRTIO_SND,
66 .version_id = VIRTIO_SOUND_VM_VERSION,
67 .minimum_version_id = VIRTIO_SOUND_VM_VERSION,
68 };
69
70 static const VMStateDescription vmstate_virtio_snd = {
71 .name = TYPE_VIRTIO_SND,
72 .unmigratable = 1,
73 .minimum_version_id = VIRTIO_SOUND_VM_VERSION,
74 .version_id = VIRTIO_SOUND_VM_VERSION,
75 .fields = (const VMStateField[]) {
76 VMSTATE_VIRTIO_DEVICE,
77 VMSTATE_END_OF_LIST()
78 },
79 };
80
81 static Property virtio_snd_properties[] = {
82 DEFINE_AUDIO_PROPERTIES(VirtIOSound, card),
83 DEFINE_PROP_UINT32("jacks", VirtIOSound, snd_conf.jacks,
84 VIRTIO_SOUND_JACK_DEFAULT),
85 DEFINE_PROP_UINT32("streams", VirtIOSound, snd_conf.streams,
86 VIRTIO_SOUND_STREAM_DEFAULT),
87 DEFINE_PROP_UINT32("chmaps", VirtIOSound, snd_conf.chmaps,
88 VIRTIO_SOUND_CHMAP_DEFAULT),
89 DEFINE_PROP_END_OF_LIST(),
90 };
91
92 static void
virtio_snd_get_config(VirtIODevice * vdev,uint8_t * config)93 virtio_snd_get_config(VirtIODevice *vdev, uint8_t *config)
94 {
95 VirtIOSound *s = VIRTIO_SND(vdev);
96 virtio_snd_config *sndconfig =
97 (virtio_snd_config *)config;
98 trace_virtio_snd_get_config(vdev,
99 s->snd_conf.jacks,
100 s->snd_conf.streams,
101 s->snd_conf.chmaps);
102
103 memcpy(sndconfig, &s->snd_conf, sizeof(s->snd_conf));
104 cpu_to_le32s(&sndconfig->jacks);
105 cpu_to_le32s(&sndconfig->streams);
106 cpu_to_le32s(&sndconfig->chmaps);
107
108 }
109
110 static void
virtio_snd_set_config(VirtIODevice * vdev,const uint8_t * config)111 virtio_snd_set_config(VirtIODevice *vdev, const uint8_t *config)
112 {
113 VirtIOSound *s = VIRTIO_SND(vdev);
114 const virtio_snd_config *sndconfig =
115 (const virtio_snd_config *)config;
116
117
118 trace_virtio_snd_set_config(vdev,
119 s->snd_conf.jacks,
120 sndconfig->jacks,
121 s->snd_conf.streams,
122 sndconfig->streams,
123 s->snd_conf.chmaps,
124 sndconfig->chmaps);
125
126 memcpy(&s->snd_conf, sndconfig, sizeof(virtio_snd_config));
127 le32_to_cpus(&s->snd_conf.jacks);
128 le32_to_cpus(&s->snd_conf.streams);
129 le32_to_cpus(&s->snd_conf.chmaps);
130
131 }
132
133 static void
virtio_snd_pcm_buffer_free(VirtIOSoundPCMBuffer * buffer)134 virtio_snd_pcm_buffer_free(VirtIOSoundPCMBuffer *buffer)
135 {
136 g_free(buffer->elem);
137 g_free(buffer);
138 }
139
140 static void
virtio_snd_ctrl_cmd_free(virtio_snd_ctrl_command * cmd)141 virtio_snd_ctrl_cmd_free(virtio_snd_ctrl_command *cmd)
142 {
143 g_free(cmd->elem);
144 g_free(cmd);
145 }
146
147 /*
148 * Get a specific stream from the virtio sound card device.
149 * Returns NULL if @stream_id is invalid or not allocated.
150 *
151 * @s: VirtIOSound device
152 * @stream_id: stream id
153 */
virtio_snd_pcm_get_stream(VirtIOSound * s,uint32_t stream_id)154 static VirtIOSoundPCMStream *virtio_snd_pcm_get_stream(VirtIOSound *s,
155 uint32_t stream_id)
156 {
157 return stream_id >= s->snd_conf.streams ? NULL :
158 s->pcm->streams[stream_id];
159 }
160
161 /*
162 * Get params for a specific stream.
163 *
164 * @s: VirtIOSound device
165 * @stream_id: stream id
166 */
virtio_snd_pcm_get_params(VirtIOSound * s,uint32_t stream_id)167 static virtio_snd_pcm_set_params *virtio_snd_pcm_get_params(VirtIOSound *s,
168 uint32_t stream_id)
169 {
170 return stream_id >= s->snd_conf.streams ? NULL
171 : &s->pcm->pcm_params[stream_id];
172 }
173
174 /*
175 * Handle the VIRTIO_SND_R_PCM_INFO request.
176 * The function writes the info structs to the request element.
177 *
178 * @s: VirtIOSound device
179 * @cmd: The request command queue element from VirtIOSound cmdq field
180 */
virtio_snd_handle_pcm_info(VirtIOSound * s,virtio_snd_ctrl_command * cmd)181 static void virtio_snd_handle_pcm_info(VirtIOSound *s,
182 virtio_snd_ctrl_command *cmd)
183 {
184 uint32_t stream_id, start_id, count, size;
185 virtio_snd_pcm_info val;
186 virtio_snd_query_info req;
187 VirtIOSoundPCMStream *stream = NULL;
188 g_autofree virtio_snd_pcm_info *pcm_info = NULL;
189 size_t msg_sz = iov_to_buf(cmd->elem->out_sg,
190 cmd->elem->out_num,
191 0,
192 &req,
193 sizeof(virtio_snd_query_info));
194
195 if (msg_sz != sizeof(virtio_snd_query_info)) {
196 /*
197 * TODO: do we need to set DEVICE_NEEDS_RESET?
198 */
199 qemu_log_mask(LOG_GUEST_ERROR,
200 "%s: virtio-snd command size incorrect %zu vs \
201 %zu\n", __func__, msg_sz, sizeof(virtio_snd_query_info));
202 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
203 return;
204 }
205
206 start_id = le32_to_cpu(req.start_id);
207 count = le32_to_cpu(req.count);
208 size = le32_to_cpu(req.size);
209
210 if (iov_size(cmd->elem->in_sg, cmd->elem->in_num) <
211 sizeof(virtio_snd_hdr) + size * count) {
212 /*
213 * TODO: do we need to set DEVICE_NEEDS_RESET?
214 */
215 error_report("pcm info: buffer too small, got: %zu, needed: %zu",
216 iov_size(cmd->elem->in_sg, cmd->elem->in_num),
217 sizeof(virtio_snd_pcm_info));
218 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
219 return;
220 }
221
222 pcm_info = g_new0(virtio_snd_pcm_info, count);
223 for (uint32_t i = 0; i < count; i++) {
224 stream_id = i + start_id;
225 trace_virtio_snd_handle_pcm_info(stream_id);
226 stream = virtio_snd_pcm_get_stream(s, stream_id);
227 if (!stream) {
228 error_report("Invalid stream id: %"PRIu32, stream_id);
229 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
230 return;
231 }
232 val = stream->info;
233 val.hdr.hda_fn_nid = cpu_to_le32(val.hdr.hda_fn_nid);
234 val.features = cpu_to_le32(val.features);
235 val.formats = cpu_to_le64(val.formats);
236 val.rates = cpu_to_le64(val.rates);
237 /*
238 * 5.14.6.6.2.1 Device Requirements: Stream Information The device MUST
239 * NOT set undefined feature, format, rate and direction values. The
240 * device MUST initialize the padding bytes to 0.
241 */
242 pcm_info[i] = val;
243 memset(&pcm_info[i].padding, 0, 5);
244 }
245
246 cmd->payload_size = sizeof(virtio_snd_pcm_info) * count;
247 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_OK);
248 iov_from_buf(cmd->elem->in_sg,
249 cmd->elem->in_num,
250 sizeof(virtio_snd_hdr),
251 pcm_info,
252 cmd->payload_size);
253 }
254
255 /*
256 * Set the given stream params.
257 * Called by both virtio_snd_handle_pcm_set_params and during device
258 * initialization.
259 * Returns the response status code. (VIRTIO_SND_S_*).
260 *
261 * @s: VirtIOSound device
262 * @params: The PCM params as defined in the virtio specification
263 */
264 static
virtio_snd_set_pcm_params(VirtIOSound * s,uint32_t stream_id,virtio_snd_pcm_set_params * params)265 uint32_t virtio_snd_set_pcm_params(VirtIOSound *s,
266 uint32_t stream_id,
267 virtio_snd_pcm_set_params *params)
268 {
269 virtio_snd_pcm_set_params *st_params;
270
271 if (stream_id >= s->snd_conf.streams || s->pcm->pcm_params == NULL) {
272 /*
273 * TODO: do we need to set DEVICE_NEEDS_RESET?
274 */
275 virtio_error(VIRTIO_DEVICE(s), "Streams have not been initialized.\n");
276 return cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
277 }
278
279 st_params = virtio_snd_pcm_get_params(s, stream_id);
280
281 if (params->channels < 1 || params->channels > AUDIO_MAX_CHANNELS) {
282 error_report("Number of channels is not supported.");
283 return cpu_to_le32(VIRTIO_SND_S_NOT_SUPP);
284 }
285 if (BIT(params->format) > sizeof(supported_formats) ||
286 !(supported_formats & BIT(params->format))) {
287 error_report("Stream format is not supported.");
288 return cpu_to_le32(VIRTIO_SND_S_NOT_SUPP);
289 }
290 if (BIT(params->rate) > sizeof(supported_rates) ||
291 !(supported_rates & BIT(params->rate))) {
292 error_report("Stream rate is not supported.");
293 return cpu_to_le32(VIRTIO_SND_S_NOT_SUPP);
294 }
295
296 st_params->buffer_bytes = le32_to_cpu(params->buffer_bytes);
297 st_params->period_bytes = le32_to_cpu(params->period_bytes);
298 st_params->features = le32_to_cpu(params->features);
299 /* the following are uint8_t, so there's no need to bswap the values. */
300 st_params->channels = params->channels;
301 st_params->format = params->format;
302 st_params->rate = params->rate;
303
304 return cpu_to_le32(VIRTIO_SND_S_OK);
305 }
306
307 /*
308 * Handles the VIRTIO_SND_R_PCM_SET_PARAMS request.
309 *
310 * @s: VirtIOSound device
311 * @cmd: The request command queue element from VirtIOSound cmdq field
312 */
virtio_snd_handle_pcm_set_params(VirtIOSound * s,virtio_snd_ctrl_command * cmd)313 static void virtio_snd_handle_pcm_set_params(VirtIOSound *s,
314 virtio_snd_ctrl_command *cmd)
315 {
316 virtio_snd_pcm_set_params req = { 0 };
317 uint32_t stream_id;
318 size_t msg_sz = iov_to_buf(cmd->elem->out_sg,
319 cmd->elem->out_num,
320 0,
321 &req,
322 sizeof(virtio_snd_pcm_set_params));
323
324 if (msg_sz != sizeof(virtio_snd_pcm_set_params)) {
325 /*
326 * TODO: do we need to set DEVICE_NEEDS_RESET?
327 */
328 qemu_log_mask(LOG_GUEST_ERROR,
329 "%s: virtio-snd command size incorrect %zu vs \
330 %zu\n", __func__, msg_sz, sizeof(virtio_snd_pcm_set_params));
331 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
332 return;
333 }
334 stream_id = le32_to_cpu(req.hdr.stream_id);
335 trace_virtio_snd_handle_pcm_set_params(stream_id);
336 cmd->resp.code = virtio_snd_set_pcm_params(s, stream_id, &req);
337 }
338
339 /*
340 * Get a QEMU Audiosystem compatible format value from a VIRTIO_SND_PCM_FMT_*
341 */
virtio_snd_get_qemu_format(uint32_t format)342 static AudioFormat virtio_snd_get_qemu_format(uint32_t format)
343 {
344 #define CASE(FMT) \
345 case VIRTIO_SND_PCM_FMT_##FMT: \
346 return AUDIO_FORMAT_##FMT;
347
348 switch (format) {
349 CASE(U8)
350 CASE(S8)
351 CASE(U16)
352 CASE(S16)
353 CASE(U32)
354 CASE(S32)
355 case VIRTIO_SND_PCM_FMT_FLOAT:
356 return AUDIO_FORMAT_F32;
357 default:
358 g_assert_not_reached();
359 }
360
361 #undef CASE
362 }
363
364 /*
365 * Get a QEMU Audiosystem compatible frequency value from a
366 * VIRTIO_SND_PCM_RATE_*
367 */
virtio_snd_get_qemu_freq(uint32_t rate)368 static uint32_t virtio_snd_get_qemu_freq(uint32_t rate)
369 {
370 #define CASE(RATE) \
371 case VIRTIO_SND_PCM_RATE_##RATE: \
372 return RATE;
373
374 switch (rate) {
375 CASE(5512)
376 CASE(8000)
377 CASE(11025)
378 CASE(16000)
379 CASE(22050)
380 CASE(32000)
381 CASE(44100)
382 CASE(48000)
383 CASE(64000)
384 CASE(88200)
385 CASE(96000)
386 CASE(176400)
387 CASE(192000)
388 CASE(384000)
389 default:
390 g_assert_not_reached();
391 }
392
393 #undef CASE
394 }
395
396 /*
397 * Get QEMU Audiosystem compatible audsettings from virtio based pcm stream
398 * params.
399 */
virtio_snd_get_qemu_audsettings(audsettings * as,virtio_snd_pcm_set_params * params)400 static void virtio_snd_get_qemu_audsettings(audsettings *as,
401 virtio_snd_pcm_set_params *params)
402 {
403 as->nchannels = MIN(AUDIO_MAX_CHANNELS, params->channels);
404 as->fmt = virtio_snd_get_qemu_format(params->format);
405 as->freq = virtio_snd_get_qemu_freq(params->rate);
406 as->endianness = 0; /* Conforming to VIRTIO 1.0: always little endian. */
407 }
408
409 /*
410 * Close a stream and free all its resources.
411 *
412 * @stream: VirtIOSoundPCMStream *stream
413 */
virtio_snd_pcm_close(VirtIOSoundPCMStream * stream)414 static void virtio_snd_pcm_close(VirtIOSoundPCMStream *stream)
415 {
416 if (stream) {
417 virtio_snd_pcm_flush(stream);
418 if (stream->info.direction == VIRTIO_SND_D_OUTPUT) {
419 AUD_close_out(&stream->pcm->snd->card, stream->voice.out);
420 stream->voice.out = NULL;
421 } else if (stream->info.direction == VIRTIO_SND_D_INPUT) {
422 AUD_close_in(&stream->pcm->snd->card, stream->voice.in);
423 stream->voice.in = NULL;
424 }
425 }
426 }
427
428 /*
429 * Prepares a VirtIOSound card stream.
430 * Returns the response status code. (VIRTIO_SND_S_*).
431 *
432 * @s: VirtIOSound device
433 * @stream_id: stream id
434 */
virtio_snd_pcm_prepare(VirtIOSound * s,uint32_t stream_id)435 static uint32_t virtio_snd_pcm_prepare(VirtIOSound *s, uint32_t stream_id)
436 {
437 audsettings as;
438 virtio_snd_pcm_set_params *params;
439 VirtIOSoundPCMStream *stream;
440
441 if (s->pcm->streams == NULL ||
442 s->pcm->pcm_params == NULL ||
443 stream_id >= s->snd_conf.streams) {
444 return cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
445 }
446
447 params = virtio_snd_pcm_get_params(s, stream_id);
448 if (params == NULL) {
449 return cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
450 }
451
452 stream = virtio_snd_pcm_get_stream(s, stream_id);
453 if (stream == NULL) {
454 stream = g_new0(VirtIOSoundPCMStream, 1);
455 stream->active = false;
456 stream->id = stream_id;
457 stream->pcm = s->pcm;
458 stream->s = s;
459 qemu_mutex_init(&stream->queue_mutex);
460 QSIMPLEQ_INIT(&stream->queue);
461
462 /*
463 * stream_id >= s->snd_conf.streams was checked before so this is
464 * in-bounds
465 */
466 s->pcm->streams[stream_id] = stream;
467 }
468
469 virtio_snd_get_qemu_audsettings(&as, params);
470 stream->info.direction = stream_id < s->snd_conf.streams / 2 +
471 (s->snd_conf.streams & 1) ? VIRTIO_SND_D_OUTPUT : VIRTIO_SND_D_INPUT;
472 stream->info.hdr.hda_fn_nid = VIRTIO_SOUND_HDA_FN_NID;
473 stream->info.features = 0;
474 stream->info.channels_min = 1;
475 stream->info.channels_max = as.nchannels;
476 stream->info.formats = supported_formats;
477 stream->info.rates = supported_rates;
478 stream->params = *params;
479
480 stream->positions[0] = VIRTIO_SND_CHMAP_FL;
481 stream->positions[1] = VIRTIO_SND_CHMAP_FR;
482 stream->as = as;
483
484 if (stream->info.direction == VIRTIO_SND_D_OUTPUT) {
485 stream->voice.out = AUD_open_out(&s->card,
486 stream->voice.out,
487 "virtio-sound.out",
488 stream,
489 virtio_snd_pcm_out_cb,
490 &as);
491 AUD_set_volume_out(stream->voice.out, 0, 255, 255);
492 } else {
493 stream->voice.in = AUD_open_in(&s->card,
494 stream->voice.in,
495 "virtio-sound.in",
496 stream,
497 virtio_snd_pcm_in_cb,
498 &as);
499 AUD_set_volume_in(stream->voice.in, 0, 255, 255);
500 }
501
502 return cpu_to_le32(VIRTIO_SND_S_OK);
503 }
504
print_code(uint32_t code)505 static const char *print_code(uint32_t code)
506 {
507 #define CASE(CODE) \
508 case VIRTIO_SND_R_##CODE: \
509 return "VIRTIO_SND_R_"#CODE
510
511 switch (code) {
512 CASE(JACK_INFO);
513 CASE(JACK_REMAP);
514 CASE(PCM_INFO);
515 CASE(PCM_SET_PARAMS);
516 CASE(PCM_PREPARE);
517 CASE(PCM_RELEASE);
518 CASE(PCM_START);
519 CASE(PCM_STOP);
520 CASE(CHMAP_INFO);
521 default:
522 return "invalid code";
523 }
524
525 #undef CASE
526 };
527
528 /*
529 * Handles VIRTIO_SND_R_PCM_PREPARE.
530 *
531 * @s: VirtIOSound device
532 * @cmd: The request command queue element from VirtIOSound cmdq field
533 */
virtio_snd_handle_pcm_prepare(VirtIOSound * s,virtio_snd_ctrl_command * cmd)534 static void virtio_snd_handle_pcm_prepare(VirtIOSound *s,
535 virtio_snd_ctrl_command *cmd)
536 {
537 uint32_t stream_id;
538 size_t msg_sz = iov_to_buf(cmd->elem->out_sg,
539 cmd->elem->out_num,
540 sizeof(virtio_snd_hdr),
541 &stream_id,
542 sizeof(stream_id));
543
544 stream_id = le32_to_cpu(stream_id);
545 cmd->resp.code = msg_sz == sizeof(stream_id)
546 ? virtio_snd_pcm_prepare(s, stream_id)
547 : cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
548 }
549
550 /*
551 * Handles VIRTIO_SND_R_PCM_START.
552 *
553 * @s: VirtIOSound device
554 * @cmd: The request command queue element from VirtIOSound cmdq field
555 * @start: whether to start or stop the device
556 */
virtio_snd_handle_pcm_start_stop(VirtIOSound * s,virtio_snd_ctrl_command * cmd,bool start)557 static void virtio_snd_handle_pcm_start_stop(VirtIOSound *s,
558 virtio_snd_ctrl_command *cmd,
559 bool start)
560 {
561 VirtIOSoundPCMStream *stream;
562 virtio_snd_pcm_hdr req;
563 uint32_t stream_id;
564 size_t msg_sz = iov_to_buf(cmd->elem->out_sg,
565 cmd->elem->out_num,
566 0,
567 &req,
568 sizeof(virtio_snd_pcm_hdr));
569
570 if (msg_sz != sizeof(virtio_snd_pcm_hdr)) {
571 qemu_log_mask(LOG_GUEST_ERROR,
572 "%s: virtio-snd command size incorrect %zu vs \
573 %zu\n", __func__, msg_sz, sizeof(virtio_snd_pcm_hdr));
574 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
575 return;
576 }
577
578 stream_id = le32_to_cpu(req.stream_id);
579 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_OK);
580 trace_virtio_snd_handle_pcm_start_stop(start ? "VIRTIO_SND_R_PCM_START" :
581 "VIRTIO_SND_R_PCM_STOP", stream_id);
582
583 stream = virtio_snd_pcm_get_stream(s, stream_id);
584 if (stream) {
585 WITH_QEMU_LOCK_GUARD(&stream->queue_mutex) {
586 stream->active = start;
587 }
588 if (stream->info.direction == VIRTIO_SND_D_OUTPUT) {
589 AUD_set_active_out(stream->voice.out, start);
590 } else {
591 AUD_set_active_in(stream->voice.in, start);
592 }
593 } else {
594 error_report("Invalid stream id: %"PRIu32, stream_id);
595 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
596 return;
597 }
598 stream->active = start;
599 }
600
601 /*
602 * Returns the number of I/O messages that are being processed.
603 *
604 * @stream: VirtIOSoundPCMStream
605 */
virtio_snd_pcm_get_io_msgs_count(VirtIOSoundPCMStream * stream)606 static size_t virtio_snd_pcm_get_io_msgs_count(VirtIOSoundPCMStream *stream)
607 {
608 VirtIOSoundPCMBuffer *buffer, *next;
609 size_t count = 0;
610
611 WITH_QEMU_LOCK_GUARD(&stream->queue_mutex) {
612 QSIMPLEQ_FOREACH_SAFE(buffer, &stream->queue, entry, next) {
613 count += 1;
614 }
615 }
616 return count;
617 }
618
619 /*
620 * Handles VIRTIO_SND_R_PCM_RELEASE.
621 *
622 * @s: VirtIOSound device
623 * @cmd: The request command queue element from VirtIOSound cmdq field
624 */
virtio_snd_handle_pcm_release(VirtIOSound * s,virtio_snd_ctrl_command * cmd)625 static void virtio_snd_handle_pcm_release(VirtIOSound *s,
626 virtio_snd_ctrl_command *cmd)
627 {
628 uint32_t stream_id;
629 VirtIOSoundPCMStream *stream;
630 size_t msg_sz = iov_to_buf(cmd->elem->out_sg,
631 cmd->elem->out_num,
632 sizeof(virtio_snd_hdr),
633 &stream_id,
634 sizeof(stream_id));
635
636 if (msg_sz != sizeof(stream_id)) {
637 /*
638 * TODO: do we need to set DEVICE_NEEDS_RESET?
639 */
640 qemu_log_mask(LOG_GUEST_ERROR,
641 "%s: virtio-snd command size incorrect %zu vs \
642 %zu\n", __func__, msg_sz, sizeof(stream_id));
643 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
644 return;
645 }
646
647 stream_id = le32_to_cpu(stream_id);
648 trace_virtio_snd_handle_pcm_release(stream_id);
649 stream = virtio_snd_pcm_get_stream(s, stream_id);
650 if (stream == NULL) {
651 /*
652 * TODO: do we need to set DEVICE_NEEDS_RESET?
653 */
654 error_report("already released stream %"PRIu32, stream_id);
655 virtio_error(VIRTIO_DEVICE(s),
656 "already released stream %"PRIu32,
657 stream_id);
658 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
659 return;
660 }
661
662 if (virtio_snd_pcm_get_io_msgs_count(stream)) {
663 /*
664 * virtio-v1.2-csd01, 5.14.6.6.5.1,
665 * Device Requirements: Stream Release
666 *
667 * - The device MUST complete all pending I/O messages for the
668 * specified stream ID.
669 * - The device MUST NOT complete the control request while there
670 * are pending I/O messages for the specified stream ID.
671 */
672 trace_virtio_snd_pcm_stream_flush(stream_id);
673 virtio_snd_pcm_flush(stream);
674 }
675
676 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_OK);
677 }
678
679 /*
680 * The actual processing done in virtio_snd_process_cmdq().
681 *
682 * @s: VirtIOSound device
683 * @cmd: control command request
684 */
685 static inline void
process_cmd(VirtIOSound * s,virtio_snd_ctrl_command * cmd)686 process_cmd(VirtIOSound *s, virtio_snd_ctrl_command *cmd)
687 {
688 uint32_t code;
689 size_t msg_sz = iov_to_buf(cmd->elem->out_sg,
690 cmd->elem->out_num,
691 0,
692 &cmd->ctrl,
693 sizeof(virtio_snd_hdr));
694
695 if (msg_sz != sizeof(virtio_snd_hdr)) {
696 /*
697 * TODO: do we need to set DEVICE_NEEDS_RESET?
698 */
699 qemu_log_mask(LOG_GUEST_ERROR,
700 "%s: virtio-snd command size incorrect %zu vs \
701 %zu\n", __func__, msg_sz, sizeof(virtio_snd_hdr));
702 return;
703 }
704
705 code = le32_to_cpu(cmd->ctrl.code);
706
707 trace_virtio_snd_handle_code(code, print_code(code));
708
709 switch (code) {
710 case VIRTIO_SND_R_JACK_INFO:
711 case VIRTIO_SND_R_JACK_REMAP:
712 qemu_log_mask(LOG_UNIMP,
713 "virtio_snd: jack functionality is unimplemented.\n");
714 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_NOT_SUPP);
715 break;
716 case VIRTIO_SND_R_PCM_INFO:
717 virtio_snd_handle_pcm_info(s, cmd);
718 break;
719 case VIRTIO_SND_R_PCM_START:
720 virtio_snd_handle_pcm_start_stop(s, cmd, true);
721 break;
722 case VIRTIO_SND_R_PCM_STOP:
723 virtio_snd_handle_pcm_start_stop(s, cmd, false);
724 break;
725 case VIRTIO_SND_R_PCM_SET_PARAMS:
726 virtio_snd_handle_pcm_set_params(s, cmd);
727 break;
728 case VIRTIO_SND_R_PCM_PREPARE:
729 virtio_snd_handle_pcm_prepare(s, cmd);
730 break;
731 case VIRTIO_SND_R_PCM_RELEASE:
732 virtio_snd_handle_pcm_release(s, cmd);
733 break;
734 case VIRTIO_SND_R_CHMAP_INFO:
735 qemu_log_mask(LOG_UNIMP,
736 "virtio_snd: chmap info functionality is unimplemented.\n");
737 trace_virtio_snd_handle_chmap_info();
738 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_NOT_SUPP);
739 break;
740 default:
741 /* error */
742 error_report("virtio snd header not recognized: %"PRIu32, code);
743 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
744 }
745
746 iov_from_buf(cmd->elem->in_sg,
747 cmd->elem->in_num,
748 0,
749 &cmd->resp,
750 sizeof(virtio_snd_hdr));
751 virtqueue_push(cmd->vq, cmd->elem,
752 sizeof(virtio_snd_hdr) + cmd->payload_size);
753 virtio_notify(VIRTIO_DEVICE(s), cmd->vq);
754 }
755
756 /*
757 * Consume all elements in command queue.
758 *
759 * @s: VirtIOSound device
760 */
virtio_snd_process_cmdq(VirtIOSound * s)761 static void virtio_snd_process_cmdq(VirtIOSound *s)
762 {
763 virtio_snd_ctrl_command *cmd;
764
765 if (unlikely(qatomic_read(&s->processing_cmdq))) {
766 return;
767 }
768
769 WITH_QEMU_LOCK_GUARD(&s->cmdq_mutex) {
770 qatomic_set(&s->processing_cmdq, true);
771 while (!QTAILQ_EMPTY(&s->cmdq)) {
772 cmd = QTAILQ_FIRST(&s->cmdq);
773
774 /* process command */
775 process_cmd(s, cmd);
776
777 QTAILQ_REMOVE(&s->cmdq, cmd, next);
778
779 virtio_snd_ctrl_cmd_free(cmd);
780 }
781 qatomic_set(&s->processing_cmdq, false);
782 }
783 }
784
785 /*
786 * The control message handler. Pops an element from the control virtqueue,
787 * and stores them to VirtIOSound's cmdq queue and finally calls
788 * virtio_snd_process_cmdq() for processing.
789 *
790 * @vdev: VirtIOSound device
791 * @vq: Control virtqueue
792 */
virtio_snd_handle_ctrl(VirtIODevice * vdev,VirtQueue * vq)793 static void virtio_snd_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
794 {
795 VirtIOSound *s = VIRTIO_SND(vdev);
796 VirtQueueElement *elem;
797 virtio_snd_ctrl_command *cmd;
798
799 trace_virtio_snd_handle_ctrl(vdev, vq);
800
801 if (!virtio_queue_ready(vq)) {
802 return;
803 }
804
805 elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
806 while (elem) {
807 cmd = g_new0(virtio_snd_ctrl_command, 1);
808 cmd->elem = elem;
809 cmd->vq = vq;
810 cmd->resp.code = cpu_to_le32(VIRTIO_SND_S_OK);
811 /* implicit cmd->payload_size = 0; */
812 QTAILQ_INSERT_TAIL(&s->cmdq, cmd, next);
813 elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
814 }
815
816 virtio_snd_process_cmdq(s);
817 }
818
819 /*
820 * The event virtqueue handler.
821 * Not implemented yet.
822 *
823 * @vdev: VirtIOSound device
824 * @vq: event vq
825 */
virtio_snd_handle_event(VirtIODevice * vdev,VirtQueue * vq)826 static void virtio_snd_handle_event(VirtIODevice *vdev, VirtQueue *vq)
827 {
828 qemu_log_mask(LOG_UNIMP, "virtio_snd: event queue is unimplemented.\n");
829 trace_virtio_snd_handle_event();
830 }
831
832 /*
833 * Must only be called if vsnd->invalid is not empty.
834 */
empty_invalid_queue(VirtIODevice * vdev,VirtQueue * vq)835 static inline void empty_invalid_queue(VirtIODevice *vdev, VirtQueue *vq)
836 {
837 VirtIOSoundPCMBuffer *buffer = NULL;
838 virtio_snd_pcm_status resp = { 0 };
839 VirtIOSound *vsnd = VIRTIO_SND(vdev);
840
841 g_assert(!QSIMPLEQ_EMPTY(&vsnd->invalid));
842
843 while (!QSIMPLEQ_EMPTY(&vsnd->invalid)) {
844 buffer = QSIMPLEQ_FIRST(&vsnd->invalid);
845 /* If buffer->vq != vq, our logic is fundamentally wrong, so bail out */
846 g_assert(buffer->vq == vq);
847
848 resp.status = cpu_to_le32(VIRTIO_SND_S_BAD_MSG);
849 iov_from_buf(buffer->elem->in_sg,
850 buffer->elem->in_num,
851 0,
852 &resp,
853 sizeof(virtio_snd_pcm_status));
854 virtqueue_push(vq,
855 buffer->elem,
856 sizeof(virtio_snd_pcm_status));
857 QSIMPLEQ_REMOVE_HEAD(&vsnd->invalid, entry);
858 virtio_snd_pcm_buffer_free(buffer);
859 }
860 /* Notify vq about virtio_snd_pcm_status responses. */
861 virtio_notify(vdev, vq);
862 }
863
864 /*
865 * The tx virtqueue handler. Makes the buffers available to their respective
866 * streams for consumption.
867 *
868 * @vdev: VirtIOSound device
869 * @vq: tx virtqueue
870 */
virtio_snd_handle_tx_xfer(VirtIODevice * vdev,VirtQueue * vq)871 static void virtio_snd_handle_tx_xfer(VirtIODevice *vdev, VirtQueue *vq)
872 {
873 VirtIOSound *vsnd = VIRTIO_SND(vdev);
874 VirtIOSoundPCMBuffer *buffer;
875 VirtQueueElement *elem;
876 size_t msg_sz, size;
877 virtio_snd_pcm_xfer hdr;
878 uint32_t stream_id;
879 /*
880 * If any of the I/O messages are invalid, put them in vsnd->invalid and
881 * return them after the for loop.
882 */
883 bool must_empty_invalid_queue = false;
884
885 if (!virtio_queue_ready(vq)) {
886 return;
887 }
888 trace_virtio_snd_handle_tx_xfer();
889
890 for (;;) {
891 VirtIOSoundPCMStream *stream;
892
893 elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
894 if (!elem) {
895 break;
896 }
897 /* get the message hdr object */
898 msg_sz = iov_to_buf(elem->out_sg,
899 elem->out_num,
900 0,
901 &hdr,
902 sizeof(virtio_snd_pcm_xfer));
903 if (msg_sz != sizeof(virtio_snd_pcm_xfer)) {
904 goto tx_err;
905 }
906 stream_id = le32_to_cpu(hdr.stream_id);
907
908 if (stream_id >= vsnd->snd_conf.streams
909 || vsnd->pcm->streams[stream_id] == NULL) {
910 goto tx_err;
911 }
912
913 stream = vsnd->pcm->streams[stream_id];
914 if (stream->info.direction != VIRTIO_SND_D_OUTPUT) {
915 goto tx_err;
916 }
917
918 WITH_QEMU_LOCK_GUARD(&stream->queue_mutex) {
919 size = iov_size(elem->out_sg, elem->out_num) - msg_sz;
920
921 buffer = g_malloc0(sizeof(VirtIOSoundPCMBuffer) + size);
922 buffer->elem = elem;
923 buffer->populated = false;
924 buffer->vq = vq;
925 buffer->size = size;
926 buffer->offset = 0;
927
928 QSIMPLEQ_INSERT_TAIL(&stream->queue, buffer, entry);
929 }
930 continue;
931
932 tx_err:
933 must_empty_invalid_queue = true;
934 buffer = g_malloc0(sizeof(VirtIOSoundPCMBuffer));
935 buffer->elem = elem;
936 buffer->vq = vq;
937 QSIMPLEQ_INSERT_TAIL(&vsnd->invalid, buffer, entry);
938 }
939
940 if (must_empty_invalid_queue) {
941 empty_invalid_queue(vdev, vq);
942 }
943 }
944
945 /*
946 * The rx virtqueue handler. Makes the buffers available to their respective
947 * streams for consumption.
948 *
949 * @vdev: VirtIOSound device
950 * @vq: rx virtqueue
951 */
virtio_snd_handle_rx_xfer(VirtIODevice * vdev,VirtQueue * vq)952 static void virtio_snd_handle_rx_xfer(VirtIODevice *vdev, VirtQueue *vq)
953 {
954 VirtIOSound *vsnd = VIRTIO_SND(vdev);
955 VirtIOSoundPCMBuffer *buffer;
956 VirtQueueElement *elem;
957 size_t msg_sz, size;
958 virtio_snd_pcm_xfer hdr;
959 uint32_t stream_id;
960 /*
961 * if any of the I/O messages are invalid, put them in vsnd->invalid and
962 * return them after the for loop.
963 */
964 bool must_empty_invalid_queue = false;
965
966 if (!virtio_queue_ready(vq)) {
967 return;
968 }
969 trace_virtio_snd_handle_rx_xfer();
970
971 for (;;) {
972 VirtIOSoundPCMStream *stream;
973
974 elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
975 if (!elem) {
976 break;
977 }
978 /* get the message hdr object */
979 msg_sz = iov_to_buf(elem->out_sg,
980 elem->out_num,
981 0,
982 &hdr,
983 sizeof(virtio_snd_pcm_xfer));
984 if (msg_sz != sizeof(virtio_snd_pcm_xfer)) {
985 goto rx_err;
986 }
987 stream_id = le32_to_cpu(hdr.stream_id);
988
989 if (stream_id >= vsnd->snd_conf.streams
990 || !vsnd->pcm->streams[stream_id]) {
991 goto rx_err;
992 }
993
994 stream = vsnd->pcm->streams[stream_id];
995 if (stream == NULL || stream->info.direction != VIRTIO_SND_D_INPUT) {
996 goto rx_err;
997 }
998 WITH_QEMU_LOCK_GUARD(&stream->queue_mutex) {
999 size = iov_size(elem->in_sg, elem->in_num) -
1000 sizeof(virtio_snd_pcm_status);
1001 buffer = g_malloc0(sizeof(VirtIOSoundPCMBuffer) + size);
1002 buffer->elem = elem;
1003 buffer->vq = vq;
1004 buffer->size = 0;
1005 buffer->offset = 0;
1006 QSIMPLEQ_INSERT_TAIL(&stream->queue, buffer, entry);
1007 }
1008 continue;
1009
1010 rx_err:
1011 must_empty_invalid_queue = true;
1012 buffer = g_malloc0(sizeof(VirtIOSoundPCMBuffer));
1013 buffer->elem = elem;
1014 buffer->vq = vq;
1015 QSIMPLEQ_INSERT_TAIL(&vsnd->invalid, buffer, entry);
1016 }
1017
1018 if (must_empty_invalid_queue) {
1019 empty_invalid_queue(vdev, vq);
1020 }
1021 }
1022
get_features(VirtIODevice * vdev,uint64_t features,Error ** errp)1023 static uint64_t get_features(VirtIODevice *vdev, uint64_t features,
1024 Error **errp)
1025 {
1026 /*
1027 * virtio-v1.2-csd01, 5.14.3,
1028 * Feature Bits
1029 * None currently defined.
1030 */
1031 VirtIOSound *s = VIRTIO_SND(vdev);
1032 features |= s->features;
1033
1034 trace_virtio_snd_get_features(vdev, features);
1035
1036 return features;
1037 }
1038
1039 static void
virtio_snd_vm_state_change(void * opaque,bool running,RunState state)1040 virtio_snd_vm_state_change(void *opaque, bool running,
1041 RunState state)
1042 {
1043 if (running) {
1044 trace_virtio_snd_vm_state_running();
1045 } else {
1046 trace_virtio_snd_vm_state_stopped();
1047 }
1048 }
1049
virtio_snd_realize(DeviceState * dev,Error ** errp)1050 static void virtio_snd_realize(DeviceState *dev, Error **errp)
1051 {
1052 ERRP_GUARD();
1053 VirtIOSound *vsnd = VIRTIO_SND(dev);
1054 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1055 virtio_snd_pcm_set_params default_params = { 0 };
1056 uint32_t status;
1057
1058 trace_virtio_snd_realize(vsnd);
1059
1060 /* check number of jacks and streams */
1061 if (vsnd->snd_conf.jacks > 8) {
1062 error_setg(errp,
1063 "Invalid number of jacks: %"PRIu32,
1064 vsnd->snd_conf.jacks);
1065 return;
1066 }
1067 if (vsnd->snd_conf.streams < 1 || vsnd->snd_conf.streams > 10) {
1068 error_setg(errp,
1069 "Invalid number of streams: %"PRIu32,
1070 vsnd->snd_conf.streams);
1071 return;
1072 }
1073
1074 if (vsnd->snd_conf.chmaps > VIRTIO_SND_CHMAP_MAX_SIZE) {
1075 error_setg(errp,
1076 "Invalid number of channel maps: %"PRIu32,
1077 vsnd->snd_conf.chmaps);
1078 return;
1079 }
1080
1081 if (!AUD_register_card("virtio-sound", &vsnd->card, errp)) {
1082 return;
1083 }
1084
1085 vsnd->vmstate =
1086 qemu_add_vm_change_state_handler(virtio_snd_vm_state_change, vsnd);
1087
1088 vsnd->pcm = g_new0(VirtIOSoundPCM, 1);
1089 vsnd->pcm->snd = vsnd;
1090 vsnd->pcm->streams =
1091 g_new0(VirtIOSoundPCMStream *, vsnd->snd_conf.streams);
1092 vsnd->pcm->pcm_params =
1093 g_new0(virtio_snd_pcm_set_params, vsnd->snd_conf.streams);
1094
1095 virtio_init(vdev, VIRTIO_ID_SOUND, sizeof(virtio_snd_config));
1096 virtio_add_feature(&vsnd->features, VIRTIO_F_VERSION_1);
1097
1098 /* set default params for all streams */
1099 default_params.features = 0;
1100 default_params.buffer_bytes = cpu_to_le32(8192);
1101 default_params.period_bytes = cpu_to_le32(2048);
1102 default_params.channels = 2;
1103 default_params.format = VIRTIO_SND_PCM_FMT_S16;
1104 default_params.rate = VIRTIO_SND_PCM_RATE_48000;
1105 vsnd->queues[VIRTIO_SND_VQ_CONTROL] =
1106 virtio_add_queue(vdev, 64, virtio_snd_handle_ctrl);
1107 vsnd->queues[VIRTIO_SND_VQ_EVENT] =
1108 virtio_add_queue(vdev, 64, virtio_snd_handle_event);
1109 vsnd->queues[VIRTIO_SND_VQ_TX] =
1110 virtio_add_queue(vdev, 64, virtio_snd_handle_tx_xfer);
1111 vsnd->queues[VIRTIO_SND_VQ_RX] =
1112 virtio_add_queue(vdev, 64, virtio_snd_handle_rx_xfer);
1113 qemu_mutex_init(&vsnd->cmdq_mutex);
1114 QTAILQ_INIT(&vsnd->cmdq);
1115 QSIMPLEQ_INIT(&vsnd->invalid);
1116
1117 for (uint32_t i = 0; i < vsnd->snd_conf.streams; i++) {
1118 status = virtio_snd_set_pcm_params(vsnd, i, &default_params);
1119 if (status != cpu_to_le32(VIRTIO_SND_S_OK)) {
1120 error_setg(errp,
1121 "Can't initialize stream params, device responded with %s.",
1122 print_code(status));
1123 goto error_cleanup;
1124 }
1125 status = virtio_snd_pcm_prepare(vsnd, i);
1126 if (status != cpu_to_le32(VIRTIO_SND_S_OK)) {
1127 error_setg(errp,
1128 "Can't prepare streams, device responded with %s.",
1129 print_code(status));
1130 goto error_cleanup;
1131 }
1132 }
1133
1134 return;
1135
1136 error_cleanup:
1137 virtio_snd_unrealize(dev);
1138 }
1139
return_tx_buffer(VirtIOSoundPCMStream * stream,VirtIOSoundPCMBuffer * buffer)1140 static inline void return_tx_buffer(VirtIOSoundPCMStream *stream,
1141 VirtIOSoundPCMBuffer *buffer)
1142 {
1143 virtio_snd_pcm_status resp = { 0 };
1144 resp.status = cpu_to_le32(VIRTIO_SND_S_OK);
1145 resp.latency_bytes = cpu_to_le32((uint32_t)buffer->size);
1146 iov_from_buf(buffer->elem->in_sg,
1147 buffer->elem->in_num,
1148 0,
1149 &resp,
1150 sizeof(virtio_snd_pcm_status));
1151 virtqueue_push(buffer->vq,
1152 buffer->elem,
1153 sizeof(virtio_snd_pcm_status));
1154 virtio_notify(VIRTIO_DEVICE(stream->s), buffer->vq);
1155 QSIMPLEQ_REMOVE(&stream->queue,
1156 buffer,
1157 VirtIOSoundPCMBuffer,
1158 entry);
1159 virtio_snd_pcm_buffer_free(buffer);
1160 }
1161
1162 /*
1163 * AUD_* output callback.
1164 *
1165 * @data: VirtIOSoundPCMStream stream
1166 * @available: number of bytes that can be written with AUD_write()
1167 */
virtio_snd_pcm_out_cb(void * data,int available)1168 static void virtio_snd_pcm_out_cb(void *data, int available)
1169 {
1170 VirtIOSoundPCMStream *stream = data;
1171 VirtIOSoundPCMBuffer *buffer;
1172 size_t size;
1173
1174 WITH_QEMU_LOCK_GUARD(&stream->queue_mutex) {
1175 while (!QSIMPLEQ_EMPTY(&stream->queue)) {
1176 buffer = QSIMPLEQ_FIRST(&stream->queue);
1177 if (!virtio_queue_ready(buffer->vq)) {
1178 return;
1179 }
1180 if (!stream->active) {
1181 /* Stream has stopped, so do not perform AUD_write. */
1182 return_tx_buffer(stream, buffer);
1183 continue;
1184 }
1185 if (!buffer->populated) {
1186 iov_to_buf(buffer->elem->out_sg,
1187 buffer->elem->out_num,
1188 sizeof(virtio_snd_pcm_xfer),
1189 buffer->data,
1190 buffer->size);
1191 buffer->populated = true;
1192 }
1193 for (;;) {
1194 size = AUD_write(stream->voice.out,
1195 buffer->data + buffer->offset,
1196 MIN(buffer->size, available));
1197 assert(size <= MIN(buffer->size, available));
1198 if (size == 0) {
1199 /* break out of both loops */
1200 available = 0;
1201 break;
1202 }
1203 buffer->size -= size;
1204 buffer->offset += size;
1205 available -= size;
1206 if (buffer->size < 1) {
1207 return_tx_buffer(stream, buffer);
1208 break;
1209 }
1210 if (!available) {
1211 break;
1212 }
1213 }
1214 if (!available) {
1215 break;
1216 }
1217 }
1218 }
1219 }
1220
1221 /*
1222 * Flush all buffer data from this input stream's queue into the driver's
1223 * virtual queue.
1224 *
1225 * @stream: VirtIOSoundPCMStream *stream
1226 */
return_rx_buffer(VirtIOSoundPCMStream * stream,VirtIOSoundPCMBuffer * buffer)1227 static inline void return_rx_buffer(VirtIOSoundPCMStream *stream,
1228 VirtIOSoundPCMBuffer *buffer)
1229 {
1230 virtio_snd_pcm_status resp = { 0 };
1231 resp.status = cpu_to_le32(VIRTIO_SND_S_OK);
1232 resp.latency_bytes = 0;
1233 /* Copy data -if any- to guest */
1234 iov_from_buf(buffer->elem->in_sg,
1235 buffer->elem->in_num,
1236 0,
1237 buffer->data,
1238 buffer->size);
1239 iov_from_buf(buffer->elem->in_sg,
1240 buffer->elem->in_num,
1241 buffer->size,
1242 &resp,
1243 sizeof(virtio_snd_pcm_status));
1244 virtqueue_push(buffer->vq,
1245 buffer->elem,
1246 sizeof(virtio_snd_pcm_status) + buffer->size);
1247 virtio_notify(VIRTIO_DEVICE(stream->s), buffer->vq);
1248 QSIMPLEQ_REMOVE(&stream->queue,
1249 buffer,
1250 VirtIOSoundPCMBuffer,
1251 entry);
1252 virtio_snd_pcm_buffer_free(buffer);
1253 }
1254
1255
1256 /*
1257 * AUD_* input callback.
1258 *
1259 * @data: VirtIOSoundPCMStream stream
1260 * @available: number of bytes that can be read with AUD_read()
1261 */
virtio_snd_pcm_in_cb(void * data,int available)1262 static void virtio_snd_pcm_in_cb(void *data, int available)
1263 {
1264 VirtIOSoundPCMStream *stream = data;
1265 VirtIOSoundPCMBuffer *buffer;
1266 size_t size, max_size;
1267
1268 WITH_QEMU_LOCK_GUARD(&stream->queue_mutex) {
1269 while (!QSIMPLEQ_EMPTY(&stream->queue)) {
1270 buffer = QSIMPLEQ_FIRST(&stream->queue);
1271 if (!virtio_queue_ready(buffer->vq)) {
1272 return;
1273 }
1274 if (!stream->active) {
1275 /* Stream has stopped, so do not perform AUD_read. */
1276 return_rx_buffer(stream, buffer);
1277 continue;
1278 }
1279
1280 max_size = iov_size(buffer->elem->in_sg, buffer->elem->in_num);
1281 for (;;) {
1282 if (buffer->size >= max_size) {
1283 return_rx_buffer(stream, buffer);
1284 break;
1285 }
1286 size = AUD_read(stream->voice.in,
1287 buffer->data + buffer->size,
1288 MIN(available, (stream->params.period_bytes -
1289 buffer->size)));
1290 if (!size) {
1291 available = 0;
1292 break;
1293 }
1294 buffer->size += size;
1295 available -= size;
1296 if (buffer->size >= stream->params.period_bytes) {
1297 return_rx_buffer(stream, buffer);
1298 break;
1299 }
1300 if (!available) {
1301 break;
1302 }
1303 }
1304 if (!available) {
1305 break;
1306 }
1307 }
1308 }
1309 }
1310
1311 /*
1312 * Flush all buffer data from this output stream's queue into the driver's
1313 * virtual queue.
1314 *
1315 * @stream: VirtIOSoundPCMStream *stream
1316 */
virtio_snd_pcm_flush(VirtIOSoundPCMStream * stream)1317 static inline void virtio_snd_pcm_flush(VirtIOSoundPCMStream *stream)
1318 {
1319 VirtIOSoundPCMBuffer *buffer;
1320 void (*cb)(VirtIOSoundPCMStream *, VirtIOSoundPCMBuffer *) =
1321 (stream->info.direction == VIRTIO_SND_D_OUTPUT) ? return_tx_buffer :
1322 return_rx_buffer;
1323
1324 WITH_QEMU_LOCK_GUARD(&stream->queue_mutex) {
1325 while (!QSIMPLEQ_EMPTY(&stream->queue)) {
1326 buffer = QSIMPLEQ_FIRST(&stream->queue);
1327 cb(stream, buffer);
1328 }
1329 }
1330 }
1331
virtio_snd_unrealize(DeviceState * dev)1332 static void virtio_snd_unrealize(DeviceState *dev)
1333 {
1334 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1335 VirtIOSound *vsnd = VIRTIO_SND(dev);
1336 VirtIOSoundPCMStream *stream;
1337
1338 qemu_del_vm_change_state_handler(vsnd->vmstate);
1339 trace_virtio_snd_unrealize(vsnd);
1340
1341 if (vsnd->pcm) {
1342 if (vsnd->pcm->streams) {
1343 for (uint32_t i = 0; i < vsnd->snd_conf.streams; i++) {
1344 stream = vsnd->pcm->streams[i];
1345 if (stream) {
1346 virtio_snd_process_cmdq(stream->s);
1347 virtio_snd_pcm_close(stream);
1348 qemu_mutex_destroy(&stream->queue_mutex);
1349 g_free(stream);
1350 }
1351 }
1352 g_free(vsnd->pcm->streams);
1353 }
1354 g_free(vsnd->pcm->pcm_params);
1355 g_free(vsnd->pcm);
1356 vsnd->pcm = NULL;
1357 }
1358 AUD_remove_card(&vsnd->card);
1359 qemu_mutex_destroy(&vsnd->cmdq_mutex);
1360 virtio_delete_queue(vsnd->queues[VIRTIO_SND_VQ_CONTROL]);
1361 virtio_delete_queue(vsnd->queues[VIRTIO_SND_VQ_EVENT]);
1362 virtio_delete_queue(vsnd->queues[VIRTIO_SND_VQ_TX]);
1363 virtio_delete_queue(vsnd->queues[VIRTIO_SND_VQ_RX]);
1364 virtio_cleanup(vdev);
1365 }
1366
1367
virtio_snd_reset(VirtIODevice * vdev)1368 static void virtio_snd_reset(VirtIODevice *vdev)
1369 {
1370 VirtIOSound *vsnd = VIRTIO_SND(vdev);
1371 virtio_snd_ctrl_command *cmd;
1372
1373 /*
1374 * Sanity check that the invalid buffer message queue is emptied at the end
1375 * of every virtio_snd_handle_tx_xfer/virtio_snd_handle_rx_xfer call, and
1376 * must be empty otherwise.
1377 */
1378 g_assert(QSIMPLEQ_EMPTY(&vsnd->invalid));
1379
1380 WITH_QEMU_LOCK_GUARD(&vsnd->cmdq_mutex) {
1381 while (!QTAILQ_EMPTY(&vsnd->cmdq)) {
1382 cmd = QTAILQ_FIRST(&vsnd->cmdq);
1383 QTAILQ_REMOVE(&vsnd->cmdq, cmd, next);
1384 virtio_snd_ctrl_cmd_free(cmd);
1385 }
1386 }
1387 }
1388
virtio_snd_class_init(ObjectClass * klass,void * data)1389 static void virtio_snd_class_init(ObjectClass *klass, void *data)
1390 {
1391 DeviceClass *dc = DEVICE_CLASS(klass);
1392 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
1393
1394
1395 set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
1396 device_class_set_props(dc, virtio_snd_properties);
1397
1398 dc->vmsd = &vmstate_virtio_snd;
1399 vdc->vmsd = &vmstate_virtio_snd_device;
1400 vdc->realize = virtio_snd_realize;
1401 vdc->unrealize = virtio_snd_unrealize;
1402 vdc->get_config = virtio_snd_get_config;
1403 vdc->set_config = virtio_snd_set_config;
1404 vdc->get_features = get_features;
1405 vdc->reset = virtio_snd_reset;
1406 vdc->legacy_features = 0;
1407 }
1408
1409 static const TypeInfo virtio_snd_types[] = {
1410 {
1411 .name = TYPE_VIRTIO_SND,
1412 .parent = TYPE_VIRTIO_DEVICE,
1413 .instance_size = sizeof(VirtIOSound),
1414 .class_init = virtio_snd_class_init,
1415 }
1416 };
1417
1418 DEFINE_TYPES(virtio_snd_types)
1419