?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target/ppc/kvm: Convert DPRINTF to traces
[qemu.git] / hw / usb / dev-audio.c
blobc46d5eeb79a397d9156d170c4c9a8d16abf87422
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 "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 if (p->iov.size != USBAUDIO_PACKET_SIZE) {
325 return 0;
326 }
327 assert(free >= USBAUDIO_PACKET_SIZE);
328 usb_packet_copy(p, buf->data + (buf->prod % buf->size),
329 USBAUDIO_PACKET_SIZE);
330 buf->prod += USBAUDIO_PACKET_SIZE;
331 return USBAUDIO_PACKET_SIZE;
332 }
333
334 static uint8_t *streambuf_get(struct streambuf *buf)
335 {
336 uint32_t used = buf->prod - buf->cons;
337 uint8_t *data;
338
339 if (!used) {
340 return NULL;
341 }
342 assert(used >= USBAUDIO_PACKET_SIZE);
343 data = buf->data + (buf->cons % buf->size);
344 buf->cons += USBAUDIO_PACKET_SIZE;
345 return data;
346 }
347
348 typedef struct USBAudioState {
349 /* qemu interfaces */
350 USBDevice dev;
351 QEMUSoundCard card;
352
353 /* state */
354 struct {
355 enum usb_audio_altset altset;
356 struct audsettings as;
357 SWVoiceOut *voice;
358 bool mute;
359 uint8_t vol[2];
360 struct streambuf buf;
361 } out;
362
363 /* properties */
364 uint32_t debug;
365 uint32_t buffer;
366 } USBAudioState;
367
368 #define TYPE_USB_AUDIO "usb-audio"
369 #define USB_AUDIO(obj) OBJECT_CHECK(USBAudioState, (obj), TYPE_USB_AUDIO)
370
371 static void output_callback(void *opaque, int avail)
372 {
373 USBAudioState *s = opaque;
374 uint8_t *data;
375
376 for (;;) {
377 if (avail < USBAUDIO_PACKET_SIZE) {
378 return;
379 }
380 data = streambuf_get(&s->out.buf);
381 if (!data) {
382 return;
383 }
384 AUD_write(s->out.voice, data, USBAUDIO_PACKET_SIZE);
385 avail -= USBAUDIO_PACKET_SIZE;
386 }
387 }
388
389 static int usb_audio_set_output_altset(USBAudioState *s, int altset)
390 {
391 switch (altset) {
392 case ALTSET_OFF:
393 streambuf_init(&s->out.buf, s->buffer);
394 AUD_set_active_out(s->out.voice, false);
395 break;
396 case ALTSET_ON:
397 AUD_set_active_out(s->out.voice, true);
398 break;
399 default:
400 return -1;
401 }
402
403 if (s->debug) {
404 fprintf(stderr, "usb-audio: set interface %d\n", altset);
405 }
406 s->out.altset = altset;
407 return 0;
408 }
409
410 /*
411 * Note: we arbitrarily map the volume control range onto -inf..+8 dB
412 */
413 #define ATTRIB_ID(cs, attrib, idif) \
414 (((cs) << 24) | ((attrib) << 16) | (idif))
415
416 static int usb_audio_get_control(USBAudioState *s, uint8_t attrib,
417 uint16_t cscn, uint16_t idif,
418 int length, uint8_t *data)
419 {
420 uint8_t cs = cscn >> 8;
421 uint8_t cn = cscn - 1; /* -1 for the non-present master control */
422 uint32_t aid = ATTRIB_ID(cs, attrib, idif);
423 int ret = USB_RET_STALL;
424
425 switch (aid) {
426 case ATTRIB_ID(MUTE_CONTROL, CR_GET_CUR, 0x0200):
427 data[0] = s->out.mute;
428 ret = 1;
429 break;
430 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_CUR, 0x0200):
431 if (cn < 2) {
432 uint16_t vol = (s->out.vol[cn] * 0x8800 + 127) / 255 + 0x8000;
433 data[0] = vol;
434 data[1] = vol >> 8;
435 ret = 2;
436 }
437 break;
438 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MIN, 0x0200):
439 if (cn < 2) {
440 data[0] = 0x01;
441 data[1] = 0x80;
442 ret = 2;
443 }
444 break;
445 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MAX, 0x0200):
446 if (cn < 2) {
447 data[0] = 0x00;
448 data[1] = 0x08;
449 ret = 2;
450 }
451 break;
452 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_RES, 0x0200):
453 if (cn < 2) {
454 data[0] = 0x88;
455 data[1] = 0x00;
456 ret = 2;
457 }
458 break;
459 }
460
461 return ret;
462 }
463 static int usb_audio_set_control(USBAudioState *s, uint8_t attrib,
464 uint16_t cscn, uint16_t idif,
465 int length, uint8_t *data)
466 {
467 uint8_t cs = cscn >> 8;
468 uint8_t cn = cscn - 1; /* -1 for the non-present master control */
469 uint32_t aid = ATTRIB_ID(cs, attrib, idif);
470 int ret = USB_RET_STALL;
471 bool set_vol = false;
472
473 switch (aid) {
474 case ATTRIB_ID(MUTE_CONTROL, CR_SET_CUR, 0x0200):
475 s->out.mute = data[0] & 1;
476 set_vol = true;
477 ret = 0;
478 break;
479 case ATTRIB_ID(VOLUME_CONTROL, CR_SET_CUR, 0x0200):
480 if (cn < 2) {
481 uint16_t vol = data[0] + (data[1] << 8);
482
483 if (s->debug) {
484 fprintf(stderr, "usb-audio: vol %04x\n", (uint16_t)vol);
485 }
486
487 vol -= 0x8000;
488 vol = (vol * 255 + 0x4400) / 0x8800;
489 if (vol > 255) {
490 vol = 255;
491 }
492
493 s->out.vol[cn] = vol;
494 set_vol = true;
495 ret = 0;
496 }
497 break;
498 }
499
500 if (set_vol) {
501 if (s->debug) {
502 fprintf(stderr, "usb-audio: mute %d, lvol %3d, rvol %3d\n",
503 s->out.mute, s->out.vol[0], s->out.vol[1]);
504 }
505 AUD_set_volume_out(s->out.voice, s->out.mute,
506 s->out.vol[0], s->out.vol[1]);
507 }
508
509 return ret;
510 }
511
512 static void usb_audio_handle_control(USBDevice *dev, USBPacket *p,
513 int request, int value, int index,
514 int length, uint8_t *data)
515 {
516 USBAudioState *s = USB_AUDIO(dev);
517 int ret = 0;
518
519 if (s->debug) {
520 fprintf(stderr, "usb-audio: control transaction: "
521 "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
522 request, value, index, length);
523 }
524
525 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
526 if (ret >= 0) {
527 return;
528 }
529
530 switch (request) {
531 case ClassInterfaceRequest | CR_GET_CUR:
532 case ClassInterfaceRequest | CR_GET_MIN:
533 case ClassInterfaceRequest | CR_GET_MAX:
534 case ClassInterfaceRequest | CR_GET_RES:
535 ret = usb_audio_get_control(s, request & 0xff, value, index,
536 length, data);
537 if (ret < 0) {
538 if (s->debug) {
539 fprintf(stderr, "usb-audio: fail: get control\n");
540 }
541 goto fail;
542 }
543 p->actual_length = ret;
544 break;
545
546 case ClassInterfaceOutRequest | CR_SET_CUR:
547 case ClassInterfaceOutRequest | CR_SET_MIN:
548 case ClassInterfaceOutRequest | CR_SET_MAX:
549 case ClassInterfaceOutRequest | CR_SET_RES:
550 ret = usb_audio_set_control(s, request & 0xff, value, index,
551 length, data);
552 if (ret < 0) {
553 if (s->debug) {
554 fprintf(stderr, "usb-audio: fail: set control\n");
555 }
556 goto fail;
557 }
558 break;
559
560 default:
561 fail:
562 if (s->debug) {
563 fprintf(stderr, "usb-audio: failed control transaction: "
564 "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
565 request, value, index, length);
566 }
567 p->status = USB_RET_STALL;
568 break;
569 }
570 }
571
572 static void usb_audio_set_interface(USBDevice *dev, int iface,
573 int old, int value)
574 {
575 USBAudioState *s = USB_AUDIO(dev);
576
577 if (iface == 1) {
578 usb_audio_set_output_altset(s, value);
579 }
580 }
581
582 static void usb_audio_handle_reset(USBDevice *dev)
583 {
584 USBAudioState *s = USB_AUDIO(dev);
585
586 if (s->debug) {
587 fprintf(stderr, "usb-audio: reset\n");
588 }
589 usb_audio_set_output_altset(s, ALTSET_OFF);
590 }
591
592 static void usb_audio_handle_dataout(USBAudioState *s, USBPacket *p)
593 {
594 if (s->out.altset == ALTSET_OFF) {
595 p->status = USB_RET_STALL;
596 return;
597 }
598
599 streambuf_put(&s->out.buf, p);
600 if (p->actual_length < p->iov.size && s->debug > 1) {
601 fprintf(stderr, "usb-audio: output overrun (%zd bytes)\n",
602 p->iov.size - p->actual_length);
603 }
604 }
605
606 static void usb_audio_handle_data(USBDevice *dev, USBPacket *p)
607 {
608 USBAudioState *s = (USBAudioState *) dev;
609
610 if (p->pid == USB_TOKEN_OUT && p->ep->nr == 1) {
611 usb_audio_handle_dataout(s, p);
612 return;
613 }
614
615 p->status = USB_RET_STALL;
616 if (s->debug) {
617 fprintf(stderr, "usb-audio: failed data transaction: "
618 "pid 0x%x ep 0x%x len 0x%zx\n",
619 p->pid, p->ep->nr, p->iov.size);
620 }
621 }
622
623 static void usb_audio_unrealize(USBDevice *dev, Error **errp)
624 {
625 USBAudioState *s = USB_AUDIO(dev);
626
627 if (s->debug) {
628 fprintf(stderr, "usb-audio: destroy\n");
629 }
630
631 usb_audio_set_output_altset(s, ALTSET_OFF);
632 AUD_close_out(&s->card, s->out.voice);
633 AUD_remove_card(&s->card);
634
635 streambuf_fini(&s->out.buf);
636 }
637
638 static void usb_audio_realize(USBDevice *dev, Error **errp)
639 {
640 USBAudioState *s = USB_AUDIO(dev);
641
642 usb_desc_create_serial(dev);
643 usb_desc_init(dev);
644 s->dev.opaque = s;
645 AUD_register_card(TYPE_USB_AUDIO, &s->card);
646
647 s->out.altset = ALTSET_OFF;
648 s->out.mute = false;
649 s->out.vol[0] = 240; /* 0 dB */
650 s->out.vol[1] = 240; /* 0 dB */
651 s->out.as.freq = USBAUDIO_SAMPLE_RATE;
652 s->out.as.nchannels = 2;
653 s->out.as.fmt = AUDIO_FORMAT_S16;
654 s->out.as.endianness = 0;
655 streambuf_init(&s->out.buf, s->buffer);
656
657 s->out.voice = AUD_open_out(&s->card, s->out.voice, TYPE_USB_AUDIO,
658 s, output_callback, &s->out.as);
659 AUD_set_volume_out(s->out.voice, s->out.mute, s->out.vol[0], s->out.vol[1]);
660 AUD_set_active_out(s->out.voice, 0);
661 }
662
663 static const VMStateDescription vmstate_usb_audio = {
664 .name = TYPE_USB_AUDIO,
665 .unmigratable = 1,
666 };
667
668 static Property usb_audio_properties[] = {
669 DEFINE_PROP_UINT32("debug", USBAudioState, debug, 0),
670 DEFINE_PROP_UINT32("buffer", USBAudioState, buffer,
671 32 * USBAUDIO_PACKET_SIZE),
672 DEFINE_PROP_END_OF_LIST(),
673 };
674
675 static void usb_audio_class_init(ObjectClass *klass, void *data)
676 {
677 DeviceClass *dc = DEVICE_CLASS(klass);
678 USBDeviceClass *k = USB_DEVICE_CLASS(klass);
679
680 dc->vmsd = &vmstate_usb_audio;
681 dc->props = usb_audio_properties;
682 set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
683 k->product_desc = "QEMU USB Audio Interface";
684 k->usb_desc = &desc_audio;
685 k->realize = usb_audio_realize;
686 k->handle_reset = usb_audio_handle_reset;
687 k->handle_control = usb_audio_handle_control;
688 k->handle_data = usb_audio_handle_data;
689 k->unrealize = usb_audio_unrealize;
690 k->set_interface = usb_audio_set_interface;
691 }
692
693 static const TypeInfo usb_audio_info = {
694 .name = TYPE_USB_AUDIO,
695 .parent = TYPE_USB_DEVICE,
696 .instance_size = sizeof(USBAudioState),
697 .class_init = usb_audio_class_init,
698 };
699
700 static void usb_audio_register_types(void)
701 {
702 type_register_static(&usb_audio_info);
703 usb_legacy_register(TYPE_USB_AUDIO, "audio", NULL);
704 }
705
706 type_init(usb_audio_register_types)
QEmu