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