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

/*
 * QEMU USB audio device
 *
 * written by:
 *  H. Peter Anvin <hpa@linux.intel.com>
 *  Gerd Hoffmann <kraxel@redhat.com>
 *
 * 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/osdep.h"
#include "qemu-common.h"
#include "hw/usb.h"
#include "hw/usb/desc.h"
#include "hw/hw.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          = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
            .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;

#define TYPE_USB_AUDIO "usb-audio"
#define USB_AUDIO(obj) OBJECT_CHECK(USBAudioState, (obj), TYPE_USB_AUDIO)

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 (!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 = USB_AUDIO(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 = USB_AUDIO(dev);

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

static void usb_audio_handle_reset(USBDevice *dev)
{
    USBAudioState *s = USB_AUDIO(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 = USB_AUDIO(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 void usb_audio_realize(USBDevice *dev, Error **errp)
{
    USBAudioState *s = USB_AUDIO(dev);

    usb_desc_create_serial(dev);
    usb_desc_init(dev);
    s->dev.opaque = s;
    AUD_register_card(TYPE_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, TYPE_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);
}

static const VMStateDescription vmstate_usb_audio = {
    .name = TYPE_USB_AUDIO,
    .unmigratable = 1,
};

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