?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
blockjob: do not allow coroutine double entry or entry-after-completion
[qemu/ar7.git] / hw / usb / dev-audio.c
blob343345235c9b2f38d0d8dabd956af866999c8b50
1 /*
2 * QEMU USB audio device
3 *
4 * written by:
5 * H. Peter Anvin <hpa@linux.intel.com>
6 * Gerd Hoffmann <kraxel@redhat.com>
7 *
8 * lousely based on usb net device code which is:
9 *
10 * Copyright (c) 2006 Thomas Sailer
11 * Copyright (c) 2008 Andrzej Zaborowski
12 *
13 * Permission is hereby granted, free of charge, to any person obtaining a copy
14 * of this software and associated documentation files (the "Software"), to deal
15 * in the Software without restriction, including without limitation the rights
16 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
17 * copies of the Software, and to permit persons to whom the Software is
18 * furnished to do so, subject to the following conditions:
19 *
20 * The above copyright notice and this permission notice shall be included in
21 * all copies or substantial portions of the Software.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
24 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
26 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
28 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
29 * THE SOFTWARE.
30 */
31
32 #include "qemu/osdep.h"
33 #include "qemu-common.h"
34 #include "hw/usb.h"
35 #include "hw/usb/desc.h"
36 #include "hw/hw.h"
37 #include "audio/audio.h"
38
39 #define USBAUDIO_VENDOR_NUM 0x46f4 /* CRC16() of "QEMU" */
40 #define USBAUDIO_PRODUCT_NUM 0x0002
41
42 #define DEV_CONFIG_VALUE 1 /* The one and only */
43
44 /* Descriptor subtypes for AC interfaces */
45 #define DST_AC_HEADER 1
46 #define DST_AC_INPUT_TERMINAL 2
47 #define DST_AC_OUTPUT_TERMINAL 3
48 #define DST_AC_FEATURE_UNIT 6
49 /* Descriptor subtypes for AS interfaces */
50 #define DST_AS_GENERAL 1
51 #define DST_AS_FORMAT_TYPE 2
52 /* Descriptor subtypes for endpoints */
53 #define DST_EP_GENERAL 1
54
55 enum usb_audio_strings {
56 STRING_NULL,
57 STRING_MANUFACTURER,
58 STRING_PRODUCT,
59 STRING_SERIALNUMBER,
60 STRING_CONFIG,
61 STRING_USBAUDIO_CONTROL,
62 STRING_INPUT_TERMINAL,
63 STRING_FEATURE_UNIT,
64 STRING_OUTPUT_TERMINAL,
65 STRING_NULL_STREAM,
66 STRING_REAL_STREAM,
67 };
68
69 static const USBDescStrings usb_audio_stringtable = {
70 [STRING_MANUFACTURER] = "QEMU",
71 [STRING_PRODUCT] = "QEMU USB Audio",
72 [STRING_SERIALNUMBER] = "1",
73 [STRING_CONFIG] = "Audio Configuration",
74 [STRING_USBAUDIO_CONTROL] = "Audio Device",
75 [STRING_INPUT_TERMINAL] = "Audio Output Pipe",
76 [STRING_FEATURE_UNIT] = "Audio Output Volume Control",
77 [STRING_OUTPUT_TERMINAL] = "Audio Output Terminal",
78 [STRING_NULL_STREAM] = "Audio Output - Disabled",
79 [STRING_REAL_STREAM] = "Audio Output - 48 kHz Stereo",
80 };
81
82 #define U16(x) ((x) & 0xff), (((x) >> 8) & 0xff)
83 #define U24(x) U16(x), (((x) >> 16) & 0xff)
84 #define U32(x) U24(x), (((x) >> 24) & 0xff)
85
86 /*
87 * A Basic Audio Device uses these specific values
88 */
89 #define USBAUDIO_PACKET_SIZE 192
90 #define USBAUDIO_SAMPLE_RATE 48000
91 #define USBAUDIO_PACKET_INTERVAL 1
92
93 static const USBDescIface desc_iface[] = {
94 {
95 .bInterfaceNumber = 0,
96 .bNumEndpoints = 0,
97 .bInterfaceClass = USB_CLASS_AUDIO,
98 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL,
99 .bInterfaceProtocol = 0x04,
100 .iInterface = STRING_USBAUDIO_CONTROL,
101 .ndesc = 4,
102 .descs = (USBDescOther[]) {
103 {
104 /* Headphone Class-Specific AC Interface Header Descriptor */
105 .data = (uint8_t[]) {
106 0x09, /* u8 bLength */
107 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
108 DST_AC_HEADER, /* u8 bDescriptorSubtype */
109 U16(0x0100), /* u16 bcdADC */
110 U16(0x2b), /* u16 wTotalLength */
111 0x01, /* u8 bInCollection */
112 0x01, /* u8 baInterfaceNr */
113 }
114 },{
115 /* Generic Stereo Input Terminal ID1 Descriptor */
116 .data = (uint8_t[]) {
117 0x0c, /* u8 bLength */
118 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
119 DST_AC_INPUT_TERMINAL, /* u8 bDescriptorSubtype */
120 0x01, /* u8 bTerminalID */
121 U16(0x0101), /* u16 wTerminalType */
122 0x00, /* u8 bAssocTerminal */
123 0x02, /* u16 bNrChannels */
124 U16(0x0003), /* u16 wChannelConfig */
125 0x00, /* u8 iChannelNames */
126 STRING_INPUT_TERMINAL, /* u8 iTerminal */
127 }
128 },{
129 /* Generic Stereo Feature Unit ID2 Descriptor */
130 .data = (uint8_t[]) {
131 0x0d, /* u8 bLength */
132 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
133 DST_AC_FEATURE_UNIT, /* u8 bDescriptorSubtype */
134 0x02, /* u8 bUnitID */
135 0x01, /* u8 bSourceID */
136 0x02, /* u8 bControlSize */
137 U16(0x0001), /* u16 bmaControls(0) */
138 U16(0x0002), /* u16 bmaControls(1) */
139 U16(0x0002), /* u16 bmaControls(2) */
140 STRING_FEATURE_UNIT, /* u8 iFeature */
141 }
142 },{
143 /* Headphone Ouptut Terminal ID3 Descriptor */
144 .data = (uint8_t[]) {
145 0x09, /* u8 bLength */
146 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
147 DST_AC_OUTPUT_TERMINAL, /* u8 bDescriptorSubtype */
148 0x03, /* u8 bUnitID */
149 U16(0x0301), /* u16 wTerminalType (SPK) */
150 0x00, /* u8 bAssocTerminal */
151 0x02, /* u8 bSourceID */
152 STRING_OUTPUT_TERMINAL, /* u8 iTerminal */
153 }
154 }
155 },
156 },{
157 .bInterfaceNumber = 1,
158 .bAlternateSetting = 0,
159 .bNumEndpoints = 0,
160 .bInterfaceClass = USB_CLASS_AUDIO,
161 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_STREAMING,
162 .iInterface = STRING_NULL_STREAM,
163 },{
164 .bInterfaceNumber = 1,
165 .bAlternateSetting = 1,
166 .bNumEndpoints = 1,
167 .bInterfaceClass = USB_CLASS_AUDIO,
168 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_STREAMING,
169 .iInterface = STRING_REAL_STREAM,
170 .ndesc = 2,
171 .descs = (USBDescOther[]) {
172 {
173 /* Headphone Class-specific AS General Interface Descriptor */
174 .data = (uint8_t[]) {
175 0x07, /* u8 bLength */
176 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
177 DST_AS_GENERAL, /* u8 bDescriptorSubtype */
178 0x01, /* u8 bTerminalLink */
179 0x00, /* u8 bDelay */
180 0x01, 0x00, /* u16 wFormatTag */
181 }
182 },{
183 /* Headphone Type I Format Type Descriptor */
184 .data = (uint8_t[]) {
185 0x0b, /* u8 bLength */
186 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
187 DST_AS_FORMAT_TYPE, /* u8 bDescriptorSubtype */
188 0x01, /* u8 bFormatType */
189 0x02, /* u8 bNrChannels */
190 0x02, /* u8 bSubFrameSize */
191 0x10, /* u8 bBitResolution */
192 0x01, /* u8 bSamFreqType */
193 U24(USBAUDIO_SAMPLE_RATE), /* u24 tSamFreq */
194 }
195 }
196 },
197 .eps = (USBDescEndpoint[]) {
198 {
199 .bEndpointAddress = USB_DIR_OUT | 0x01,
200 .bmAttributes = 0x0d,
201 .wMaxPacketSize = USBAUDIO_PACKET_SIZE,
202 .bInterval = 1,
203 .is_audio = 1,
204 /* Stereo Headphone Class-specific
205 AS Audio Data Endpoint Descriptor */
206 .extra = (uint8_t[]) {
207 0x07, /* u8 bLength */
208 USB_DT_CS_ENDPOINT, /* u8 bDescriptorType */
209 DST_EP_GENERAL, /* u8 bDescriptorSubtype */
210 0x00, /* u8 bmAttributes */
211 0x00, /* u8 bLockDelayUnits */
212 U16(0x0000), /* u16 wLockDelay */
213 },
214 },
215 }
216 }
217 };
218
219 static const USBDescDevice desc_device = {
220 .bcdUSB = 0x0100,
221 .bMaxPacketSize0 = 64,
222 .bNumConfigurations = 1,
223 .confs = (USBDescConfig[]) {
224 {
225 .bNumInterfaces = 2,
226 .bConfigurationValue = DEV_CONFIG_VALUE,
227 .iConfiguration = STRING_CONFIG,
228 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
229 .bMaxPower = 0x32,
230 .nif = ARRAY_SIZE(desc_iface),
231 .ifs = desc_iface,
232 },
233 },
234 };
235
236 static const USBDesc desc_audio = {
237 .id = {
238 .idVendor = USBAUDIO_VENDOR_NUM,
239 .idProduct = USBAUDIO_PRODUCT_NUM,
240 .bcdDevice = 0,
241 .iManufacturer = STRING_MANUFACTURER,
242 .iProduct = STRING_PRODUCT,
243 .iSerialNumber = STRING_SERIALNUMBER,
244 },
245 .full = &desc_device,
246 .str = usb_audio_stringtable,
247 };
248
249 /*
250 * A USB audio device supports an arbitrary number of alternate
251 * interface settings for each interface. Each corresponds to a block
252 * diagram of parameterized blocks. This can thus refer to things like
253 * number of channels, data rates, or in fact completely different
254 * block diagrams. Alternative setting 0 is always the null block diagram,
255 * which is used by a disabled device.
256 */
257 enum usb_audio_altset {
258 ALTSET_OFF = 0x00, /* No endpoint */
259 ALTSET_ON = 0x01, /* Single endpoint */
260 };
261
262 /*
263 * Class-specific control requests
264 */
265 #define CR_SET_CUR 0x01
266 #define CR_GET_CUR 0x81
267 #define CR_SET_MIN 0x02
268 #define CR_GET_MIN 0x82
269 #define CR_SET_MAX 0x03
270 #define CR_GET_MAX 0x83
271 #define CR_SET_RES 0x04
272 #define CR_GET_RES 0x84
273 #define CR_SET_MEM 0x05
274 #define CR_GET_MEM 0x85
275 #define CR_GET_STAT 0xff
276
277 /*
278 * Feature Unit Control Selectors
279 */
280 #define MUTE_CONTROL 0x01
281 #define VOLUME_CONTROL 0x02
282 #define BASS_CONTROL 0x03
283 #define MID_CONTROL 0x04
284 #define TREBLE_CONTROL 0x05
285 #define GRAPHIC_EQUALIZER_CONTROL 0x06
286 #define AUTOMATIC_GAIN_CONTROL 0x07
287 #define DELAY_CONTROL 0x08
288 #define BASS_BOOST_CONTROL 0x09
289 #define LOUDNESS_CONTROL 0x0a
290
291 /*
292 * buffering
293 */
294
295 struct streambuf {
296 uint8_t *data;
297 uint32_t size;
298 uint32_t prod;
299 uint32_t cons;
300 };
301
302 static void streambuf_init(struct streambuf *buf, uint32_t size)
303 {
304 g_free(buf->data);
305 buf->size = size - (size % USBAUDIO_PACKET_SIZE);
306 buf->data = g_malloc(buf->size);
307 buf->prod = 0;
308 buf->cons = 0;
309 }
310
311 static void streambuf_fini(struct streambuf *buf)
312 {
313 g_free(buf->data);
314 buf->data = NULL;
315 }
316
317 static int streambuf_put(struct streambuf *buf, USBPacket *p)
318 {
319 uint32_t free = buf->size - (buf->prod - buf->cons);
320
321 if (!free) {
322 return 0;
323 }
324 assert(free >= USBAUDIO_PACKET_SIZE);
325 usb_packet_copy(p, buf->data + (buf->prod % buf->size),
326 USBAUDIO_PACKET_SIZE);
327 buf->prod += USBAUDIO_PACKET_SIZE;
328 return USBAUDIO_PACKET_SIZE;
329 }
330
331 static uint8_t *streambuf_get(struct streambuf *buf)
332 {
333 uint32_t used = buf->prod - buf->cons;
334 uint8_t *data;
335
336 if (!used) {
337 return NULL;
338 }
339 assert(used >= USBAUDIO_PACKET_SIZE);
340 data = buf->data + (buf->cons % buf->size);
341 buf->cons += USBAUDIO_PACKET_SIZE;
342 return data;
343 }
344
345 typedef struct USBAudioState {
346 /* qemu interfaces */
347 USBDevice dev;
348 QEMUSoundCard card;
349
350 /* state */
351 struct {
352 enum usb_audio_altset altset;
353 struct audsettings as;
354 SWVoiceOut *voice;
355 bool mute;
356 uint8_t vol[2];
357 struct streambuf buf;
358 } out;
359
360 /* properties */
361 uint32_t debug;
362 uint32_t buffer;
363 } USBAudioState;
364
365 #define TYPE_USB_AUDIO "usb-audio"
366 #define USB_AUDIO(obj) OBJECT_CHECK(USBAudioState, (obj), TYPE_USB_AUDIO)
367
368 static void output_callback(void *opaque, int avail)
369 {
370 USBAudioState *s = opaque;
371 uint8_t *data;
372
373 for (;;) {
374 if (avail < USBAUDIO_PACKET_SIZE) {
375 return;
376 }
377 data = streambuf_get(&s->out.buf);
378 if (!data) {
379 return;
380 }
381 AUD_write(s->out.voice, data, USBAUDIO_PACKET_SIZE);
382 avail -= USBAUDIO_PACKET_SIZE;
383 }
384 }
385
386 static int usb_audio_set_output_altset(USBAudioState *s, int altset)
387 {
388 switch (altset) {
389 case ALTSET_OFF:
390 streambuf_init(&s->out.buf, s->buffer);
391 AUD_set_active_out(s->out.voice, false);
392 break;
393 case ALTSET_ON:
394 AUD_set_active_out(s->out.voice, true);
395 break;
396 default:
397 return -1;
398 }
399
400 if (s->debug) {
401 fprintf(stderr, "usb-audio: set interface %d\n", altset);
402 }
403 s->out.altset = altset;
404 return 0;
405 }
406
407 /*
408 * Note: we arbitrarily map the volume control range onto -inf..+8 dB
409 */
410 #define ATTRIB_ID(cs, attrib, idif) \
411 (((cs) << 24) | ((attrib) << 16) | (idif))
412
413 static int usb_audio_get_control(USBAudioState *s, uint8_t attrib,
414 uint16_t cscn, uint16_t idif,
415 int length, uint8_t *data)
416 {
417 uint8_t cs = cscn >> 8;
418 uint8_t cn = cscn - 1; /* -1 for the non-present master control */
419 uint32_t aid = ATTRIB_ID(cs, attrib, idif);
420 int ret = USB_RET_STALL;
421
422 switch (aid) {
423 case ATTRIB_ID(MUTE_CONTROL, CR_GET_CUR, 0x0200):
424 data[0] = s->out.mute;
425 ret = 1;
426 break;
427 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_CUR, 0x0200):
428 if (cn < 2) {
429 uint16_t vol = (s->out.vol[cn] * 0x8800 + 127) / 255 + 0x8000;
430 data[0] = vol;
431 data[1] = vol >> 8;
432 ret = 2;
433 }
434 break;
435 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MIN, 0x0200):
436 if (cn < 2) {
437 data[0] = 0x01;
438 data[1] = 0x80;
439 ret = 2;
440 }
441 break;
442 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MAX, 0x0200):
443 if (cn < 2) {
444 data[0] = 0x00;
445 data[1] = 0x08;
446 ret = 2;
447 }
448 break;
449 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_RES, 0x0200):
450 if (cn < 2) {
451 data[0] = 0x88;
452 data[1] = 0x00;
453 ret = 2;
454 }
455 break;
456 }
457
458 return ret;
459 }
460 static int usb_audio_set_control(USBAudioState *s, uint8_t attrib,
461 uint16_t cscn, uint16_t idif,
462 int length, uint8_t *data)
463 {
464 uint8_t cs = cscn >> 8;
465 uint8_t cn = cscn - 1; /* -1 for the non-present master control */
466 uint32_t aid = ATTRIB_ID(cs, attrib, idif);
467 int ret = USB_RET_STALL;
468 bool set_vol = false;
469
470 switch (aid) {
471 case ATTRIB_ID(MUTE_CONTROL, CR_SET_CUR, 0x0200):
472 s->out.mute = data[0] & 1;
473 set_vol = true;
474 ret = 0;
475 break;
476 case ATTRIB_ID(VOLUME_CONTROL, CR_SET_CUR, 0x0200):
477 if (cn < 2) {
478 uint16_t vol = data[0] + (data[1] << 8);
479
480 if (s->debug) {
481 fprintf(stderr, "usb-audio: vol %04x\n", (uint16_t)vol);
482 }
483
484 vol -= 0x8000;
485 vol = (vol * 255 + 0x4400) / 0x8800;
486 if (vol > 255) {
487 vol = 255;
488 }
489
490 s->out.vol[cn] = vol;
491 set_vol = true;
492 ret = 0;
493 }
494 break;
495 }
496
497 if (set_vol) {
498 if (s->debug) {
499 fprintf(stderr, "usb-audio: mute %d, lvol %3d, rvol %3d\n",
500 s->out.mute, s->out.vol[0], s->out.vol[1]);
501 }
502 AUD_set_volume_out(s->out.voice, s->out.mute,
503 s->out.vol[0], s->out.vol[1]);
504 }
505
506 return ret;
507 }
508
509 static void usb_audio_handle_control(USBDevice *dev, USBPacket *p,
510 int request, int value, int index,
511 int length, uint8_t *data)
512 {
513 USBAudioState *s = USB_AUDIO(dev);
514 int ret = 0;
515
516 if (s->debug) {
517 fprintf(stderr, "usb-audio: control transaction: "
518 "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
519 request, value, index, length);
520 }
521
522 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
523 if (ret >= 0) {
524 return;
525 }
526
527 switch (request) {
528 case ClassInterfaceRequest | CR_GET_CUR:
529 case ClassInterfaceRequest | CR_GET_MIN:
530 case ClassInterfaceRequest | CR_GET_MAX:
531 case ClassInterfaceRequest | CR_GET_RES:
532 ret = usb_audio_get_control(s, request & 0xff, value, index,
533 length, data);
534 if (ret < 0) {
535 if (s->debug) {
536 fprintf(stderr, "usb-audio: fail: get control\n");
537 }
538 goto fail;
539 }
540 p->actual_length = ret;
541 break;
542
543 case ClassInterfaceOutRequest | CR_SET_CUR:
544 case ClassInterfaceOutRequest | CR_SET_MIN:
545 case ClassInterfaceOutRequest | CR_SET_MAX:
546 case ClassInterfaceOutRequest | CR_SET_RES:
547 ret = usb_audio_set_control(s, request & 0xff, value, index,
548 length, data);
549 if (ret < 0) {
550 if (s->debug) {
551 fprintf(stderr, "usb-audio: fail: set control\n");
552 }
553 goto fail;
554 }
555 break;
556
557 default:
558 fail:
559 if (s->debug) {
560 fprintf(stderr, "usb-audio: failed control transaction: "
561 "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
562 request, value, index, length);
563 }
564 p->status = USB_RET_STALL;
565 break;
566 }
567 }
568
569 static void usb_audio_set_interface(USBDevice *dev, int iface,
570 int old, int value)
571 {
572 USBAudioState *s = USB_AUDIO(dev);
573
574 if (iface == 1) {
575 usb_audio_set_output_altset(s, value);
576 }
577 }
578
579 static void usb_audio_handle_reset(USBDevice *dev)
580 {
581 USBAudioState *s = USB_AUDIO(dev);
582
583 if (s->debug) {
584 fprintf(stderr, "usb-audio: reset\n");
585 }
586 usb_audio_set_output_altset(s, ALTSET_OFF);
587 }
588
589 static void usb_audio_handle_dataout(USBAudioState *s, USBPacket *p)
590 {
591 if (s->out.altset == ALTSET_OFF) {
592 p->status = USB_RET_STALL;
593 return;
594 }
595
596 streambuf_put(&s->out.buf, p);
597 if (p->actual_length < p->iov.size && s->debug > 1) {
598 fprintf(stderr, "usb-audio: output overrun (%zd bytes)\n",
599 p->iov.size - p->actual_length);
600 }
601 }
602
603 static void usb_audio_handle_data(USBDevice *dev, USBPacket *p)
604 {
605 USBAudioState *s = (USBAudioState *) dev;
606
607 if (p->pid == USB_TOKEN_OUT && p->ep->nr == 1) {
608 usb_audio_handle_dataout(s, p);
609 return;
610 }
611
612 p->status = USB_RET_STALL;
613 if (s->debug) {
614 fprintf(stderr, "usb-audio: failed data transaction: "
615 "pid 0x%x ep 0x%x len 0x%zx\n",
616 p->pid, p->ep->nr, p->iov.size);
617 }
618 }
619
620 static void usb_audio_unrealize(USBDevice *dev, Error **errp)
621 {
622 USBAudioState *s = USB_AUDIO(dev);
623
624 if (s->debug) {
625 fprintf(stderr, "usb-audio: destroy\n");
626 }
627
628 usb_audio_set_output_altset(s, ALTSET_OFF);
629 AUD_close_out(&s->card, s->out.voice);
630 AUD_remove_card(&s->card);
631
632 streambuf_fini(&s->out.buf);
633 }
634
635 static void usb_audio_realize(USBDevice *dev, Error **errp)
636 {
637 USBAudioState *s = USB_AUDIO(dev);
638
639 usb_desc_create_serial(dev);
640 usb_desc_init(dev);
641 s->dev.opaque = s;
642 AUD_register_card(TYPE_USB_AUDIO, &s->card);
643
644 s->out.altset = ALTSET_OFF;
645 s->out.mute = false;
646 s->out.vol[0] = 240; /* 0 dB */
647 s->out.vol[1] = 240; /* 0 dB */
648 s->out.as.freq = USBAUDIO_SAMPLE_RATE;
649 s->out.as.nchannels = 2;
650 s->out.as.fmt = AUD_FMT_S16;
651 s->out.as.endianness = 0;
652 streambuf_init(&s->out.buf, s->buffer);
653
654 s->out.voice = AUD_open_out(&s->card, s->out.voice, TYPE_USB_AUDIO,
655 s, output_callback, &s->out.as);
656 AUD_set_volume_out(s->out.voice, s->out.mute, s->out.vol[0], s->out.vol[1]);
657 AUD_set_active_out(s->out.voice, 0);
658 }
659
660 static const VMStateDescription vmstate_usb_audio = {
661 .name = TYPE_USB_AUDIO,
662 .unmigratable = 1,
663 };
664
665 static Property usb_audio_properties[] = {
666 DEFINE_PROP_UINT32("debug", USBAudioState, debug, 0),
667 DEFINE_PROP_UINT32("buffer", USBAudioState, buffer,
668 32 * USBAUDIO_PACKET_SIZE),
669 DEFINE_PROP_END_OF_LIST(),
670 };
671
672 static void usb_audio_class_init(ObjectClass *klass, void *data)
673 {
674 DeviceClass *dc = DEVICE_CLASS(klass);
675 USBDeviceClass *k = USB_DEVICE_CLASS(klass);
676
677 dc->vmsd = &vmstate_usb_audio;
678 dc->props = usb_audio_properties;
679 set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
680 k->product_desc = "QEMU USB Audio Interface";
681 k->usb_desc = &desc_audio;
682 k->realize = usb_audio_realize;
683 k->handle_reset = usb_audio_handle_reset;
684 k->handle_control = usb_audio_handle_control;
685 k->handle_data = usb_audio_handle_data;
686 k->unrealize = usb_audio_unrealize;
687 k->set_interface = usb_audio_set_interface;
688 }
689
690 static const TypeInfo usb_audio_info = {
691 .name = TYPE_USB_AUDIO,
692 .parent = TYPE_USB_DEVICE,
693 .instance_size = sizeof(USBAudioState),
694 .class_init = usb_audio_class_init,
695 };
696
697 static void usb_audio_register_types(void)
698 {
699 type_register_static(&usb_audio_info);
700 usb_legacy_register(TYPE_USB_AUDIO, "audio", NULL);
701 }
702
703 type_init(usb_audio_register_types)
AR7 emulation for QEMU