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) 707