hw/usb-audio.c

   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 "usb.h"
  34 #include "usb-desc.h"
  35 #include "hw.h"
  36 #include "audiodev.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                        = 0x0200,
 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 int 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 ret;
 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         break;
 538
 539     case ClassInterfaceOutRequest | CR_SET_CUR:
 540     case ClassInterfaceOutRequest | CR_SET_MIN:
 541     case ClassInterfaceOutRequest | CR_SET_MAX:
 542     case ClassInterfaceOutRequest | CR_SET_RES:
 543         ret = usb_audio_set_control(s, request & 0xff, value, index,
 544                                     length, data);
 545         if (ret < 0) {
 546             if (s->debug) {
 547                 fprintf(stderr, "usb-audio: fail: set control\n");
 548             }
 549             goto fail;
 550         }
 551         break;
 552
 553     default:
 554 fail:
 555         if (s->debug) {
 556             fprintf(stderr, "usb-audio: failed control transaction: "
 557                     "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
 558                     request, value, index, length);
 559         }
 560         ret = USB_RET_STALL;
 561         break;
 562     }
 563     return ret;
 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 int usb_audio_handle_dataout(USBAudioState *s, USBPacket *p)
 587 {
 588     int rc;
 589
 590     if (s->out.altset == ALTSET_OFF) {
 591         return USB_RET_STALL;
 592     }
 593
 594     rc = streambuf_put(&s->out.buf, p);
 595     if (rc < p->iov.size && s->debug > 1) {
 596         fprintf(stderr, "usb-audio: output overrun (%zd bytes)\n",
 597                 p->iov.size - rc);
 598     }
 599
 600     return 0;
 601 }
 602
 603 static int usb_audio_handle_data(USBDevice *dev, USBPacket *p)
 604 {
 605     USBAudioState *s = (USBAudioState *) dev;
 606     int ret = 0;
 607
 608     switch (p->pid) {
 609     case USB_TOKEN_OUT:
 610         switch (p->ep->nr) {
 611         case 1:
 612             ret = usb_audio_handle_dataout(s, p);
 613             break;
 614         default:
 615             goto fail;
 616         }
 617         break;
 618
 619     default:
 620 fail:
 621         ret = USB_RET_STALL;
 622         break;
 623     }
 624     if (ret == USB_RET_STALL && s->debug) {
 625         fprintf(stderr, "usb-audio: failed data transaction: "
 626                         "pid 0x%x ep 0x%x len 0x%zx\n",
 627                         p->pid, p->ep->nr, p->iov.size);
 628     }
 629     return ret;
 630 }
 631
 632 static void usb_audio_handle_destroy(USBDevice *dev)
 633 {
 634     USBAudioState *s = DO_UPCAST(USBAudioState, dev, dev);
 635
 636     if (s->debug) {
 637         fprintf(stderr, "usb-audio: destroy\n");
 638     }
 639
 640     usb_audio_set_output_altset(s, ALTSET_OFF);
 641     AUD_close_out(&s->card, s->out.voice);
 642     AUD_remove_card(&s->card);
 643
 644     streambuf_fini(&s->out.buf);
 645 }
 646
 647 static int usb_audio_initfn(USBDevice *dev)
 648 {
 649     USBAudioState *s = DO_UPCAST(USBAudioState, dev, dev);
 650
 651     usb_desc_init(dev);
 652     s->dev.opaque = s;
 653     AUD_register_card("usb-audio", &s->card);
 654
 655     s->out.altset        = ALTSET_OFF;
 656     s->out.mute          = false;
 657     s->out.vol[0]        = 240; /* 0 dB */
 658     s->out.vol[1]        = 240; /* 0 dB */
 659     s->out.as.freq       = USBAUDIO_SAMPLE_RATE;
 660     s->out.as.nchannels  = 2;
 661     s->out.as.fmt        = AUD_FMT_S16;
 662     s->out.as.endianness = 0;
 663     streambuf_init(&s->out.buf, s->buffer);
 664
 665     s->out.voice = AUD_open_out(&s->card, s->out.voice, "usb-audio",
 666                                 s, output_callback, &s->out.as);
 667     AUD_set_volume_out(s->out.voice, s->out.mute, s->out.vol[0], s->out.vol[1]);
 668     AUD_set_active_out(s->out.voice, 0);
 669     return 0;
 670 }
 671
 672 static const VMStateDescription vmstate_usb_audio = {
 673     .name = "usb-audio",
 674     .unmigratable = 1,
 675 };
 676
 677 static Property usb_audio_properties[] = {
 678     DEFINE_PROP_UINT32("debug", USBAudioState, debug, 0),
 679     DEFINE_PROP_UINT32("buffer", USBAudioState, buffer,
 680                        8 * USBAUDIO_PACKET_SIZE),
 681     DEFINE_PROP_END_OF_LIST(),
 682 };
 683
 684 static void usb_audio_class_init(ObjectClass *klass, void *data)
 685 {
 686     DeviceClass *dc = DEVICE_CLASS(klass);
 687     USBDeviceClass *k = USB_DEVICE_CLASS(klass);
 688
 689     dc->vmsd          = &vmstate_usb_audio;
 690     dc->props         = usb_audio_properties;
 691     k->product_desc   = "QEMU USB Audio Interface";
 692     k->usb_desc       = &desc_audio;
 693     k->init           = usb_audio_initfn;
 694     k->handle_reset   = usb_audio_handle_reset;
 695     k->handle_control = usb_audio_handle_control;
 696     k->handle_data    = usb_audio_handle_data;
 697     k->handle_destroy = usb_audio_handle_destroy;
 698     k->set_interface  = usb_audio_set_interface;
 699 }
 700
 701 static TypeInfo usb_audio_info = {
 702     .name          = "usb-audio",
 703     .parent        = TYPE_USB_DEVICE,
 704     .instance_size = sizeof(USBAudioState),
 705     .class_init    = usb_audio_class_init,
 706 };
 707
 708 static void usb_audio_register_types(void)
 709 {
 710     type_register_static(&usb_audio_info);
 711     usb_legacy_register("usb-audio", "audio", NULL);
 712 }
 713
 714 type_init(usb_audio_register_types)