LXR qemu/hw/usb/dev-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/osdep.h"
  33#include "qemu/module.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
  55enum 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
  69static 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
  93static 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
 219static 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
 236static 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 */
 257enum 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
 295struct streambuf {
 296    uint8_t *data;
 297    uint32_t size;
 298    uint32_t prod;
 299    uint32_t cons;
 300};
 301
 302static 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
 311static void streambuf_fini(struct streambuf *buf)
 312{
 313    g_free(buf->data);
 314    buf->data = NULL;
 315}
 316
 317static 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
 334static 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
 348typedef 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
 371static 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
 389static 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
 416static 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}
 463static 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
 512static 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:
 561fail:
 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
 572static 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
 582static 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
 592static 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
 606static 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
 623static 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
 638static 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
 663static const VMStateDescription vmstate_usb_audio = {
 664    .name = TYPE_USB_AUDIO,
 665    .unmigratable = 1,
 666};
 667
 668static 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
 675static 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
 693static 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
 700static 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
 706type_init(usb_audio_register_types)
 707