[qemu.git] / hw / usb / dev-audio.c

/*
 * QEMU USB audio device
 *
 * written by:
 *  H. Peter Anvin <[email protected]>
 *  Gerd Hoffmann <[email protected]>
 *
 * lousely based on usb net device code which is:
 *
 * Copyright (c) 2006 Thomas Sailer
 * Copyright (c) 2008 Andrzej Zaborowski
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "qemu-common.h"
#include "hw/usb.h"
#include "hw/usb/desc.h"
#include "hw/hw.h"
#include "hw/audiodev.h"
#include "audio/audio.h"

#define USBAUDIO_VENDOR_NUM     0x46f4 /* CRC16() of "QEMU" */
#define USBAUDIO_PRODUCT_NUM    0x0002

#define DEV_CONFIG_VALUE        1 /* The one and only */

/* Descriptor subtypes for AC interfaces */
#define DST_AC_HEADER           1
#define DST_AC_INPUT_TERMINAL   2
#define DST_AC_OUTPUT_TERMINAL  3
#define DST_AC_FEATURE_UNIT     6
/* Descriptor subtypes for AS interfaces */
#define DST_AS_GENERAL          1
#define DST_AS_FORMAT_TYPE      2
/* Descriptor subtypes for endpoints */
#define DST_EP_GENERAL          1

enum usb_audio_strings {
    STRING_NULL,
    STRING_MANUFACTURER,
    STRING_PRODUCT,
    STRING_SERIALNUMBER,
    STRING_CONFIG,
    STRING_USBAUDIO_CONTROL,
    STRING_INPUT_TERMINAL,
    STRING_FEATURE_UNIT,
    STRING_OUTPUT_TERMINAL,
    STRING_NULL_STREAM,
    STRING_REAL_STREAM,
};

static const USBDescStrings usb_audio_stringtable = {
    [STRING_MANUFACTURER]       = "QEMU",
    [STRING_PRODUCT]            = "QEMU USB Audio",
    [STRING_SERIALNUMBER]       = "1",
    [STRING_CONFIG]             = "Audio Configuration",
    [STRING_USBAUDIO_CONTROL]   = "Audio Device",
    [STRING_INPUT_TERMINAL]     = "Audio Output Pipe",
    [STRING_FEATURE_UNIT]       = "Audio Output Volume Control",
    [STRING_OUTPUT_TERMINAL]    = "Audio Output Terminal",
    [STRING_NULL_STREAM]        = "Audio Output - Disabled",
    [STRING_REAL_STREAM]        = "Audio Output - 48 kHz Stereo",
};

#define U16(x) ((x) & 0xff), (((x) >> 8) & 0xff)
#define U24(x) U16(x), (((x) >> 16) & 0xff)
#define U32(x) U24(x), (((x) >> 24) & 0xff)

/*
 * A Basic Audio Device uses these specific values
 */
#define USBAUDIO_PACKET_SIZE     192
#define USBAUDIO_SAMPLE_RATE     48000
#define USBAUDIO_PACKET_INTERVAL 1

static const USBDescIface desc_iface[] = {
    {
        .bInterfaceNumber              = 0,
        .bNumEndpoints                 = 0,
        .bInterfaceClass               = USB_CLASS_AUDIO,
        .bInterfaceSubClass            = USB_SUBCLASS_AUDIO_CONTROL,
        .bInterfaceProtocol            = 0x04,
        .iInterface                    = STRING_USBAUDIO_CONTROL,
        .ndesc                         = 4,
        .descs = (USBDescOther[]) {
            {
                /* Headphone Class-Specific AC Interface Header Descriptor */
                .data = (uint8_t[]) {
                    0x09,                       /*  u8  bLength */
                    USB_DT_CS_INTERFACE,        /*  u8  bDescriptorType */
                    DST_AC_HEADER,              /*  u8  bDescriptorSubtype */
                    U16(0x0100),                /* u16  bcdADC */
                    U16(0x2b),                  /* u16  wTotalLength */
                    0x01,                       /*  u8  bInCollection */
                    0x01,                       /*  u8  baInterfaceNr */
                }
            },{
                /* Generic Stereo Input Terminal ID1 Descriptor */
                .data = (uint8_t[]) {
                    0x0c,                       /*  u8  bLength */
                    USB_DT_CS_INTERFACE,        /*  u8  bDescriptorType */
                    DST_AC_INPUT_TERMINAL,      /*  u8  bDescriptorSubtype */
                    0x01,                       /*  u8  bTerminalID */
                    U16(0x0101),                /* u16  wTerminalType */
                    0x00,                       /*  u8  bAssocTerminal */
                    0x02,                       /* u16  bNrChannels */
                    U16(0x0003),                /* u16  wChannelConfig */
                    0x00,                       /*  u8  iChannelNames */
                    STRING_INPUT_TERMINAL,      /*  u8  iTerminal */
                }
            },{
                /* Generic Stereo Feature Unit ID2 Descriptor */
                .data = (uint8_t[]) {
                    0x0d,                       /*  u8  bLength */
                    USB_DT_CS_INTERFACE,        /*  u8  bDescriptorType */
                    DST_AC_FEATURE_UNIT,        /*  u8  bDescriptorSubtype */
                    0x02,                       /*  u8  bUnitID */
                    0x01,                       /*  u8  bSourceID */
                    0x02,                       /*  u8  bControlSize */
                    U16(0x0001),                /* u16  bmaControls(0) */
                    U16(0x0002),                /* u16  bmaControls(1) */
                    U16(0x0002),                /* u16  bmaControls(2) */
                    STRING_FEATURE_UNIT,        /*  u8  iFeature */
                }
            },{
                /* Headphone Ouptut Terminal ID3 Descriptor */
                .data = (uint8_t[]) {
                    0x09,                       /*  u8  bLength */
                    USB_DT_CS_INTERFACE,        /*  u8  bDescriptorType */
                    DST_AC_OUTPUT_TERMINAL,     /*  u8  bDescriptorSubtype */
                    0x03,                       /*  u8  bUnitID */
                    U16(0x0301),                /* u16  wTerminalType (SPK) */
                    0x00,                       /*  u8  bAssocTerminal */
                    0x02,                       /*  u8  bSourceID */
                    STRING_OUTPUT_TERMINAL,     /*  u8  iTerminal */
                }
            }
        },
    },{
        .bInterfaceNumber              = 1,
        .bAlternateSetting             = 0,
        .bNumEndpoints                 = 0,
        .bInterfaceClass               = USB_CLASS_AUDIO,
        .bInterfaceSubClass            = USB_SUBCLASS_AUDIO_STREAMING,
        .iInterface                    = STRING_NULL_STREAM,
    },{
        .bInterfaceNumber              = 1,
        .bAlternateSetting             = 1,
        .bNumEndpoints                 = 1,
        .bInterfaceClass               = USB_CLASS_AUDIO,
        .bInterfaceSubClass            = USB_SUBCLASS_AUDIO_STREAMING,
        .iInterface                    = STRING_REAL_STREAM,
        .ndesc                         = 2,
        .descs = (USBDescOther[]) {
            {
                /* Headphone Class-specific AS General Interface Descriptor */
                .data = (uint8_t[]) {
                    0x07,                       /*  u8  bLength */
                    USB_DT_CS_INTERFACE,        /*  u8  bDescriptorType */
                    DST_AS_GENERAL,             /*  u8  bDescriptorSubtype */
                    0x01,                       /*  u8  bTerminalLink */
                    0x00,                       /*  u8  bDelay */
                    0x01, 0x00,                 /* u16  wFormatTag */
                }
            },{
                /* Headphone Type I Format Type Descriptor */
                .data = (uint8_t[]) {
                    0x0b,                       /*  u8  bLength */
                    USB_DT_CS_INTERFACE,        /*  u8  bDescriptorType */
                    DST_AS_FORMAT_TYPE,         /*  u8  bDescriptorSubtype */
                    0x01,                       /*  u8  bFormatType */
                    0x02,                       /*  u8  bNrChannels */
                    0x02,                       /*  u8  bSubFrameSize */
                    0x10,                       /*  u8  bBitResolution */
                    0x01,                       /*  u8  bSamFreqType */
                    U24(USBAUDIO_SAMPLE_RATE),  /* u24  tSamFreq */
                }
            }
        },
        .eps = (USBDescEndpoint[]) {
            {
                .bEndpointAddress      = USB_DIR_OUT | 0x01,
                .bmAttributes          = 0x0d,
                .wMaxPacketSize        = USBAUDIO_PACKET_SIZE,
                .bInterval             = 1,
                .is_audio              = 1,
                /* Stereo Headphone Class-specific
                   AS Audio Data Endpoint Descriptor */
                .extra = (uint8_t[]) {
                    0x07,                       /*  u8  bLength */
                    USB_DT_CS_ENDPOINT,         /*  u8  bDescriptorType */
                    DST_EP_GENERAL,             /*  u8  bDescriptorSubtype */
                    0x00,                       /*  u8  bmAttributes */
                    0x00,                       /*  u8  bLockDelayUnits */
                    U16(0x0000),                /* u16  wLockDelay */
                },
            },
        }
    }
};

static const USBDescDevice desc_device = {
    .bcdUSB                        = 0x0100,
    .bMaxPacketSize0               = 64,
    .bNumConfigurations            = 1,
    .confs = (USBDescConfig[]) {
        {
            .bNumInterfaces        = 2,
            .bConfigurationValue   = DEV_CONFIG_VALUE,
            .iConfiguration        = STRING_CONFIG,
            .bmAttributes          = 0xc0,
            .bMaxPower             = 0x32,
            .nif = ARRAY_SIZE(desc_iface),
            .ifs = desc_iface,
        },
    },
};

static const USBDesc desc_audio = {
    .id = {
        .idVendor          = USBAUDIO_VENDOR_NUM,
        .idProduct         = USBAUDIO_PRODUCT_NUM,
        .bcdDevice         = 0,
        .iManufacturer     = STRING_MANUFACTURER,
        .iProduct          = STRING_PRODUCT,
        .iSerialNumber     = STRING_SERIALNUMBER,
    },
    .full = &desc_device,
    .str  = usb_audio_stringtable,
};

/*
 * A USB audio device supports an arbitrary number of alternate
 * interface settings for each interface.  Each corresponds to a block
 * diagram of parameterized blocks.  This can thus refer to things like
 * number of channels, data rates, or in fact completely different
 * block diagrams.  Alternative setting 0 is always the null block diagram,
 * which is used by a disabled device.
 */
enum usb_audio_altset {
    ALTSET_OFF  = 0x00,         /* No endpoint */
    ALTSET_ON   = 0x01,         /* Single endpoint */
};

/*
 * Class-specific control requests
 */
#define CR_SET_CUR      0x01
#define CR_GET_CUR      0x81
#define CR_SET_MIN      0x02
#define CR_GET_MIN      0x82
#define CR_SET_MAX      0x03
#define CR_GET_MAX      0x83
#define CR_SET_RES      0x04
#define CR_GET_RES      0x84
#define CR_SET_MEM      0x05
#define CR_GET_MEM      0x85
#define CR_GET_STAT     0xff

/*
 * Feature Unit Control Selectors
 */
#define MUTE_CONTROL                    0x01
#define VOLUME_CONTROL                  0x02
#define BASS_CONTROL                    0x03
#define MID_CONTROL                     0x04
#define TREBLE_CONTROL                  0x05
#define GRAPHIC_EQUALIZER_CONTROL       0x06
#define AUTOMATIC_GAIN_CONTROL          0x07
#define DELAY_CONTROL                   0x08
#define BASS_BOOST_CONTROL              0x09
#define LOUDNESS_CONTROL                0x0a

/*
 * buffering
 */

struct streambuf {
    uint8_t *data;
    uint32_t size;
    uint32_t prod;
    uint32_t cons;
};

static void streambuf_init(struct streambuf *buf, uint32_t size)
{
    g_free(buf->data);
    buf->size = size - (size % USBAUDIO_PACKET_SIZE);
    buf->data = g_malloc(buf->size);
    buf->prod = 0;
    buf->cons = 0;
}

static void streambuf_fini(struct streambuf *buf)
{
    g_free(buf->data);
    buf->data = NULL;
}

static int streambuf_put(struct streambuf *buf, USBPacket *p)
{
    uint32_t free = buf->size - (buf->prod - buf->cons);

    if (!free) {
        return 0;
    }
    assert(free >= USBAUDIO_PACKET_SIZE);
    usb_packet_copy(p, buf->data + (buf->prod % buf->size),
                    USBAUDIO_PACKET_SIZE);
    buf->prod += USBAUDIO_PACKET_SIZE;
    return USBAUDIO_PACKET_SIZE;
}

static uint8_t *streambuf_get(struct streambuf *buf)
{
    uint32_t used = buf->prod - buf->cons;
    uint8_t *data;

    if (!used) {
        return NULL;
    }
    assert(used >= USBAUDIO_PACKET_SIZE);
    data = buf->data + (buf->cons % buf->size);
    buf->cons += USBAUDIO_PACKET_SIZE;
    return data;
}

typedef struct USBAudioState {
    /* qemu interfaces */
    USBDevice dev;
    QEMUSoundCard card;

    /* state */
    struct {
        enum usb_audio_altset altset;
        struct audsettings as;
        SWVoiceOut *voice;
        bool mute;
        uint8_t vol[2];
        struct streambuf buf;
    } out;

    /* properties */
    uint32_t debug;
    uint32_t buffer;
} USBAudioState;

static void output_callback(void *opaque, int avail)
{
    USBAudioState *s = opaque;
    uint8_t *data;

    for (;;) {
        if (avail < USBAUDIO_PACKET_SIZE) {
            return;
        }
        data = streambuf_get(&s->out.buf);
        if (NULL == data) {
            return;
        }
        AUD_write(s->out.voice, data, USBAUDIO_PACKET_SIZE);
        avail -= USBAUDIO_PACKET_SIZE;
    }
}

static int usb_audio_set_output_altset(USBAudioState *s, int altset)
{
    switch (altset) {
    case ALTSET_OFF:
        streambuf_init(&s->out.buf, s->buffer);
        AUD_set_active_out(s->out.voice, false);
        break;
    case ALTSET_ON:
        AUD_set_active_out(s->out.voice, true);
        break;
    default:
        return -1;
    }

    if (s->debug) {
        fprintf(stderr, "usb-audio: set interface %d\n", altset);
    }
    s->out.altset = altset;
    return 0;
}

/*
 * Note: we arbitrarily map the volume control range onto -inf..+8 dB
 */
#define ATTRIB_ID(cs, attrib, idif)     \
    (((cs) << 24) | ((attrib) << 16) | (idif))

static int usb_audio_get_control(USBAudioState *s, uint8_t attrib,
                                 uint16_t cscn, uint16_t idif,
                                 int length, uint8_t *data)
{
    uint8_t cs = cscn >> 8;
    uint8_t cn = cscn - 1;      /* -1 for the non-present master control */
    uint32_t aid = ATTRIB_ID(cs, attrib, idif);
    int ret = USB_RET_STALL;

    switch (aid) {
    case ATTRIB_ID(MUTE_CONTROL, CR_GET_CUR, 0x0200):
        data[0] = s->out.mute;
        ret = 1;
        break;
    case ATTRIB_ID(VOLUME_CONTROL, CR_GET_CUR, 0x0200):
        if (cn < 2) {
            uint16_t vol = (s->out.vol[cn] * 0x8800 + 127) / 255 + 0x8000;
            data[0] = vol;
            data[1] = vol >> 8;
            ret = 2;
        }
        break;
    case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MIN, 0x0200):
        if (cn < 2) {
            data[0] = 0x01;
            data[1] = 0x80;
            ret = 2;
        }
        break;
    case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MAX, 0x0200):
        if (cn < 2) {
            data[0] = 0x00;
            data[1] = 0x08;
            ret = 2;
        }
        break;
    case ATTRIB_ID(VOLUME_CONTROL, CR_GET_RES, 0x0200):
        if (cn < 2) {
            data[0] = 0x88;
            data[1] = 0x00;
            ret = 2;
        }
        break;
    }

    return ret;
}
static int usb_audio_set_control(USBAudioState *s, uint8_t attrib,
                                 uint16_t cscn, uint16_t idif,
                                 int length, uint8_t *data)
{
    uint8_t cs = cscn >> 8;
    uint8_t cn = cscn - 1;      /* -1 for the non-present master control */
    uint32_t aid = ATTRIB_ID(cs, attrib, idif);
    int ret = USB_RET_STALL;
    bool set_vol = false;

    switch (aid) {
    case ATTRIB_ID(MUTE_CONTROL, CR_SET_CUR, 0x0200):
        s->out.mute = data[0] & 1;
        set_vol = true;
        ret = 0;
        break;
    case ATTRIB_ID(VOLUME_CONTROL, CR_SET_CUR, 0x0200):
        if (cn < 2) {
            uint16_t vol = data[0] + (data[1] << 8);

            if (s->debug) {
                fprintf(stderr, "usb-audio: vol %04x\n", (uint16_t)vol);
            }

            vol -= 0x8000;
            vol = (vol * 255 + 0x4400) / 0x8800;
            if (vol > 255) {
                vol = 255;
            }

            s->out.vol[cn] = vol;
            set_vol = true;
            ret = 0;
        }
        break;
    }

    if (set_vol) {
        if (s->debug) {
            fprintf(stderr, "usb-audio: mute %d, lvol %3d, rvol %3d\n",
                    s->out.mute, s->out.vol[0], s->out.vol[1]);
        }
        AUD_set_volume_out(s->out.voice, s->out.mute,
                           s->out.vol[0], s->out.vol[1]);
    }

    return ret;
}

static void usb_audio_handle_control(USBDevice *dev, USBPacket *p,
                                    int request, int value, int index,
                                    int length, uint8_t *data)
{
    USBAudioState *s = DO_UPCAST(USBAudioState, dev, dev);
    int ret = 0;

    if (s->debug) {
        fprintf(stderr, "usb-audio: control transaction: "
                "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
                request, value, index, length);
    }

    ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
    if (ret >= 0) {
        return;
    }

    switch (request) {
    case ClassInterfaceRequest | CR_GET_CUR:
    case ClassInterfaceRequest | CR_GET_MIN:
    case ClassInterfaceRequest | CR_GET_MAX:
    case ClassInterfaceRequest | CR_GET_RES:
        ret = usb_audio_get_control(s, request & 0xff, value, index,
                                    length, data);
        if (ret < 0) {
            if (s->debug) {
                fprintf(stderr, "usb-audio: fail: get control\n");
            }
            goto fail;
        }
        p->actual_length = ret;
        break;

    case ClassInterfaceOutRequest | CR_SET_CUR:
    case ClassInterfaceOutRequest | CR_SET_MIN:
    case ClassInterfaceOutRequest | CR_SET_MAX:
    case ClassInterfaceOutRequest | CR_SET_RES:
        ret = usb_audio_set_control(s, request & 0xff, value, index,
                                    length, data);
        if (ret < 0) {
            if (s->debug) {
                fprintf(stderr, "usb-audio: fail: set control\n");
            }
            goto fail;
        }
        break;

    default:
fail:
        if (s->debug) {
            fprintf(stderr, "usb-audio: failed control transaction: "
                    "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
                    request, value, index, length);
        }
        p->status = USB_RET_STALL;
        break;
    }
}

static void usb_audio_set_interface(USBDevice *dev, int iface,
                                    int old, int value)
{
    USBAudioState *s = DO_UPCAST(USBAudioState, dev, dev);

    if (iface == 1) {
        usb_audio_set_output_altset(s, value);
    }
}

static void usb_audio_handle_reset(USBDevice *dev)
{
    USBAudioState *s = DO_UPCAST(USBAudioState, dev, dev);

    if (s->debug) {
        fprintf(stderr, "usb-audio: reset\n");
    }
    usb_audio_set_output_altset(s, ALTSET_OFF);
}

static void usb_audio_handle_dataout(USBAudioState *s, USBPacket *p)
{
    if (s->out.altset == ALTSET_OFF) {
        p->status = USB_RET_STALL;
        return;
    }

    streambuf_put(&s->out.buf, p);
    if (p->actual_length < p->iov.size && s->debug > 1) {
        fprintf(stderr, "usb-audio: output overrun (%zd bytes)\n",
                p->iov.size - p->actual_length);
    }
}

static void usb_audio_handle_data(USBDevice *dev, USBPacket *p)
{
    USBAudioState *s = (USBAudioState *) dev;

    if (p->pid == USB_TOKEN_OUT && p->ep->nr == 1) {
        usb_audio_handle_dataout(s, p);
        return;
    }

    p->status = USB_RET_STALL;
    if (s->debug) {
        fprintf(stderr, "usb-audio: failed data transaction: "
                        "pid 0x%x ep 0x%x len 0x%zx\n",
                        p->pid, p->ep->nr, p->iov.size);
    }
}

static void usb_audio_handle_destroy(USBDevice *dev)
{
    USBAudioState *s = DO_UPCAST(USBAudioState, dev, dev);

    if (s->debug) {
        fprintf(stderr, "usb-audio: destroy\n");
    }

    usb_audio_set_output_altset(s, ALTSET_OFF);
    AUD_close_out(&s->card, s->out.voice);
    AUD_remove_card(&s->card);

    streambuf_fini(&s->out.buf);
}

static int usb_audio_initfn(USBDevice *dev)
{
    USBAudioState *s = DO_UPCAST(USBAudioState, dev, dev);

    usb_desc_create_serial(dev);
    usb_desc_init(dev);
    s->dev.opaque = s;
    AUD_register_card("usb-audio", &s->card);

    s->out.altset        = ALTSET_OFF;
    s->out.mute          = false;
    s->out.vol[0]        = 240; /* 0 dB */
    s->out.vol[1]        = 240; /* 0 dB */
    s->out.as.freq       = USBAUDIO_SAMPLE_RATE;
    s->out.as.nchannels  = 2;
    s->out.as.fmt        = AUD_FMT_S16;
    s->out.as.endianness = 0;
    streambuf_init(&s->out.buf, s->buffer);

    s->out.voice = AUD_open_out(&s->card, s->out.voice, "usb-audio",
                                s, output_callback, &s->out.as);
    AUD_set_volume_out(s->out.voice, s->out.mute, s->out.vol[0], s->out.vol[1]);
    AUD_set_active_out(s->out.voice, 0);
    return 0;
}

static const VMStateDescription vmstate_usb_audio = {
    .name = "usb-audio",
    .unmigratable = 1,
};

static Property usb_audio_properties[] = {
    DEFINE_PROP_UINT32("debug", USBAudioState, debug, 0),
    DEFINE_PROP_UINT32("buffer", USBAudioState, buffer,
                       8 * USBAUDIO_PACKET_SIZE),
    DEFINE_PROP_END_OF_LIST(),
};

static void usb_audio_class_init(ObjectClass *klass, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(klass);
    USBDeviceClass *k = USB_DEVICE_CLASS(klass);

    dc->vmsd          = &vmstate_usb_audio;
    dc->props         = usb_audio_properties;
    k->product_desc   = "QEMU USB Audio Interface";
    k->usb_desc       = &desc_audio;
    k->init           = usb_audio_initfn;
    k->handle_reset   = usb_audio_handle_reset;
    k->handle_control = usb_audio_handle_control;
    k->handle_data    = usb_audio_handle_data;
    k->handle_destroy = usb_audio_handle_destroy;
    k->set_interface  = usb_audio_set_interface;
}

static const TypeInfo usb_audio_info = {
    .name          = "usb-audio",
    .parent        = TYPE_USB_DEVICE,
    .instance_size = sizeof(USBAudioState),
    .class_init    = usb_audio_class_init,
};

static void usb_audio_register_types(void)
{
    type_register_static(&usb_audio_info);
    usb_legacy_register("usb-audio", "audio", NULL);
}

type_init(usb_audio_register_types)
Commit	Line	Data
b870472d PA	1	/*
	2	* QEMU USB audio device
	3	*
	4	* written by:
	5	* H. Peter Anvin <[email protected]>
	6	* Gerd Hoffmann <[email protected]>
	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"
f1ae32a1 GH	33	#include "hw/usb.h"
	34	#include "hw/usb/desc.h"
	35	#include "hw/hw.h"
	36	#include "hw/audiodev.h"
b870472d PA	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 = {
2bbd086c	220	.bcdUSB = 0x0100,
b870472d PA	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
9a77a0f5	506	static void usb_audio_handle_control(USBDevice dev, USBPacket p,
b870472d PA	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) {
9a77a0f5	521	return;
b870472d PA	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	}
9a77a0f5	537	p->actual_length = ret;
b870472d PA	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	}
9a77a0f5	561	p->status = USB_RET_STALL;
b870472d PA	562	break;
b870472d PA	563	}
b870472d PA	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
9a77a0f5	586	static void usb_audio_handle_dataout(USBAudioState s, USBPacket p)
b870472d	587	{
b870472d	588	if (s->out.altset == ALTSET_OFF) {
9a77a0f5 HG	589	p->status = USB_RET_STALL;
9a77a0f5 HG	590	return;
b870472d PA	591	}
b870472d PA	592
9a77a0f5 HG	593	streambuf_put(&s->out.buf, p);
9a77a0f5 HG	594	if (p->actual_length < p->iov.size && s->debug > 1) {
b870472d	595	fprintf(stderr, "usb-audio: output overrun (%zd bytes)\n",
9a77a0f5	596	p->iov.size - p->actual_length);
b870472d	597	}
b870472d PA	598	}
b870472d PA	599
9a77a0f5	600	static void usb_audio_handle_data(USBDevice dev, USBPacket p)
b870472d PA	601	{
b870472d PA	602	USBAudioState s = (USBAudioState ) dev;
b870472d	603
9a77a0f5 HG	604	if (p->pid == USB_TOKEN_OUT && p->ep->nr == 1) {
	605	usb_audio_handle_dataout(s, p);
	606	return;
b870472d	607	}
9a77a0f5 HG	608
	609	p->status = USB_RET_STALL;
	610	if (s->debug) {
b870472d PA	611	fprintf(stderr, "usb-audio: failed data transaction: "
b870472d PA	612	"pid 0x%x ep 0x%x len 0x%zx\n",
079d0b7f	613	p->pid, p->ep->nr, p->iov.size);
b870472d	614	}
b870472d PA	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
9d55d1ad	636	usb_desc_create_serial(dev);
b870472d PA	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
39bffca2 AL	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
62aed765 AL	670	static void usb_audio_class_init(ObjectClass klass, void data)
62aed765 AL	671	{
39bffca2	672	DeviceClass *dc = DEVICE_CLASS(klass);
62aed765 AL	673	USBDeviceClass *k = USB_DEVICE_CLASS(klass);
62aed765 AL	674
39bffca2 AL	675	dc->vmsd = &vmstate_usb_audio;
39bffca2 AL	676	dc->props = usb_audio_properties;
62aed765 AL	677	k->product_desc = "QEMU USB Audio Interface";
	678	k->usb_desc = &desc_audio;
	679	k->init = usb_audio_initfn;
62aed765 AL	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
8c43a6f0	687	static const TypeInfo usb_audio_info = {
39bffca2 AL	688	.name = "usb-audio",
	689	.parent = TYPE_USB_DEVICE,
	690	.instance_size = sizeof(USBAudioState),
	691	.class_init = usb_audio_class_init,
b870472d PA	692	};
b870472d PA	693
83f7d43a	694	static void usb_audio_register_types(void)
b870472d	695	{
39bffca2	696	type_register_static(&usb_audio_info);
ba02430f	697	usb_legacy_register("usb-audio", "audio", NULL);
b870472d PA	698	}
b870472d PA	699
83f7d43a	700	type_init(usb_audio_register_types)