xref: /openbmc/qemu/hw/usb/dev-audio.c (revision 0a553c58)
1 /*
2  * QEMU USB audio device
3  *
4  * written by:
5  *  H. Peter Anvin <hpa@linux.intel.com>
6  *  Gerd Hoffmann <kraxel@redhat.com>
7  *
8  * lousely based on usb net device code which is:
9  *
10  * Copyright (c) 2006 Thomas Sailer
11  * Copyright (c) 2008 Andrzej Zaborowski
12  *
13  * Permission is hereby granted, free of charge, to any person obtaining a copy
14  * of this software and associated documentation files (the "Software"), to deal
15  * in the Software without restriction, including without limitation the rights
16  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
17  * copies of the Software, and to permit persons to whom the Software is
18  * furnished to do so, subject to the following conditions:
19  *
20  * The above copyright notice and this permission notice shall be included in
21  * all copies or substantial portions of the Software.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
24  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
26  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
28  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
29  * THE SOFTWARE.
30  */
31 
32 #include "qemu/osdep.h"
33 #include "qemu-common.h"
34 #include "hw/usb.h"
35 #include "desc.h"
36 #include "hw/hw.h"
37 #include "audio/audio.h"
38 
39 #define USBAUDIO_VENDOR_NUM     0x46f4 /* CRC16() of "QEMU" */
40 #define USBAUDIO_PRODUCT_NUM    0x0002
41 
42 #define DEV_CONFIG_VALUE        1 /* The one and only */
43 
44 /* Descriptor subtypes for AC interfaces */
45 #define DST_AC_HEADER           1
46 #define DST_AC_INPUT_TERMINAL   2
47 #define DST_AC_OUTPUT_TERMINAL  3
48 #define DST_AC_FEATURE_UNIT     6
49 /* Descriptor subtypes for AS interfaces */
50 #define DST_AS_GENERAL          1
51 #define DST_AS_FORMAT_TYPE      2
52 /* Descriptor subtypes for endpoints */
53 #define DST_EP_GENERAL          1
54 
55 enum usb_audio_strings {
56     STRING_NULL,
57     STRING_MANUFACTURER,
58     STRING_PRODUCT,
59     STRING_SERIALNUMBER,
60     STRING_CONFIG,
61     STRING_USBAUDIO_CONTROL,
62     STRING_INPUT_TERMINAL,
63     STRING_FEATURE_UNIT,
64     STRING_OUTPUT_TERMINAL,
65     STRING_NULL_STREAM,
66     STRING_REAL_STREAM,
67 };
68 
69 static const USBDescStrings usb_audio_stringtable = {
70     [STRING_MANUFACTURER]       = "QEMU",
71     [STRING_PRODUCT]            = "QEMU USB Audio",
72     [STRING_SERIALNUMBER]       = "1",
73     [STRING_CONFIG]             = "Audio Configuration",
74     [STRING_USBAUDIO_CONTROL]   = "Audio Device",
75     [STRING_INPUT_TERMINAL]     = "Audio Output Pipe",
76     [STRING_FEATURE_UNIT]       = "Audio Output Volume Control",
77     [STRING_OUTPUT_TERMINAL]    = "Audio Output Terminal",
78     [STRING_NULL_STREAM]        = "Audio Output - Disabled",
79     [STRING_REAL_STREAM]        = "Audio Output - 48 kHz Stereo",
80 };
81 
82 #define U16(x) ((x) & 0xff), (((x) >> 8) & 0xff)
83 #define U24(x) U16(x), (((x) >> 16) & 0xff)
84 #define U32(x) U24(x), (((x) >> 24) & 0xff)
85 
86 /*
87  * A Basic Audio Device uses these specific values
88  */
89 #define USBAUDIO_PACKET_SIZE     192
90 #define USBAUDIO_SAMPLE_RATE     48000
91 #define USBAUDIO_PACKET_INTERVAL 1
92 
93 static const USBDescIface desc_iface[] = {
94     {
95         .bInterfaceNumber              = 0,
96         .bNumEndpoints                 = 0,
97         .bInterfaceClass               = USB_CLASS_AUDIO,
98         .bInterfaceSubClass            = USB_SUBCLASS_AUDIO_CONTROL,
99         .bInterfaceProtocol            = 0x04,
100         .iInterface                    = STRING_USBAUDIO_CONTROL,
101         .ndesc                         = 4,
102         .descs = (USBDescOther[]) {
103             {
104                 /* Headphone Class-Specific AC Interface Header Descriptor */
105                 .data = (uint8_t[]) {
106                     0x09,                       /*  u8  bLength */
107                     USB_DT_CS_INTERFACE,        /*  u8  bDescriptorType */
108                     DST_AC_HEADER,              /*  u8  bDescriptorSubtype */
109                     U16(0x0100),                /* u16  bcdADC */
110                     U16(0x2b),                  /* u16  wTotalLength */
111                     0x01,                       /*  u8  bInCollection */
112                     0x01,                       /*  u8  baInterfaceNr */
113                 }
114             },{
115                 /* Generic Stereo Input Terminal ID1 Descriptor */
116                 .data = (uint8_t[]) {
117                     0x0c,                       /*  u8  bLength */
118                     USB_DT_CS_INTERFACE,        /*  u8  bDescriptorType */
119                     DST_AC_INPUT_TERMINAL,      /*  u8  bDescriptorSubtype */
120                     0x01,                       /*  u8  bTerminalID */
121                     U16(0x0101),                /* u16  wTerminalType */
122                     0x00,                       /*  u8  bAssocTerminal */
123                     0x02,                       /* u16  bNrChannels */
124                     U16(0x0003),                /* u16  wChannelConfig */
125                     0x00,                       /*  u8  iChannelNames */
126                     STRING_INPUT_TERMINAL,      /*  u8  iTerminal */
127                 }
128             },{
129                 /* Generic Stereo Feature Unit ID2 Descriptor */
130                 .data = (uint8_t[]) {
131                     0x0d,                       /*  u8  bLength */
132                     USB_DT_CS_INTERFACE,        /*  u8  bDescriptorType */
133                     DST_AC_FEATURE_UNIT,        /*  u8  bDescriptorSubtype */
134                     0x02,                       /*  u8  bUnitID */
135                     0x01,                       /*  u8  bSourceID */
136                     0x02,                       /*  u8  bControlSize */
137                     U16(0x0001),                /* u16  bmaControls(0) */
138                     U16(0x0002),                /* u16  bmaControls(1) */
139                     U16(0x0002),                /* u16  bmaControls(2) */
140                     STRING_FEATURE_UNIT,        /*  u8  iFeature */
141                 }
142             },{
143                 /* Headphone Ouptut Terminal ID3 Descriptor */
144                 .data = (uint8_t[]) {
145                     0x09,                       /*  u8  bLength */
146                     USB_DT_CS_INTERFACE,        /*  u8  bDescriptorType */
147                     DST_AC_OUTPUT_TERMINAL,     /*  u8  bDescriptorSubtype */
148                     0x03,                       /*  u8  bUnitID */
149                     U16(0x0301),                /* u16  wTerminalType (SPK) */
150                     0x00,                       /*  u8  bAssocTerminal */
151                     0x02,                       /*  u8  bSourceID */
152                     STRING_OUTPUT_TERMINAL,     /*  u8  iTerminal */
153                 }
154             }
155         },
156     },{
157         .bInterfaceNumber              = 1,
158         .bAlternateSetting             = 0,
159         .bNumEndpoints                 = 0,
160         .bInterfaceClass               = USB_CLASS_AUDIO,
161         .bInterfaceSubClass            = USB_SUBCLASS_AUDIO_STREAMING,
162         .iInterface                    = STRING_NULL_STREAM,
163     },{
164         .bInterfaceNumber              = 1,
165         .bAlternateSetting             = 1,
166         .bNumEndpoints                 = 1,
167         .bInterfaceClass               = USB_CLASS_AUDIO,
168         .bInterfaceSubClass            = USB_SUBCLASS_AUDIO_STREAMING,
169         .iInterface                    = STRING_REAL_STREAM,
170         .ndesc                         = 2,
171         .descs = (USBDescOther[]) {
172             {
173                 /* Headphone Class-specific AS General Interface Descriptor */
174                 .data = (uint8_t[]) {
175                     0x07,                       /*  u8  bLength */
176                     USB_DT_CS_INTERFACE,        /*  u8  bDescriptorType */
177                     DST_AS_GENERAL,             /*  u8  bDescriptorSubtype */
178                     0x01,                       /*  u8  bTerminalLink */
179                     0x00,                       /*  u8  bDelay */
180                     0x01, 0x00,                 /* u16  wFormatTag */
181                 }
182             },{
183                 /* Headphone Type I Format Type Descriptor */
184                 .data = (uint8_t[]) {
185                     0x0b,                       /*  u8  bLength */
186                     USB_DT_CS_INTERFACE,        /*  u8  bDescriptorType */
187                     DST_AS_FORMAT_TYPE,         /*  u8  bDescriptorSubtype */
188                     0x01,                       /*  u8  bFormatType */
189                     0x02,                       /*  u8  bNrChannels */
190                     0x02,                       /*  u8  bSubFrameSize */
191                     0x10,                       /*  u8  bBitResolution */
192                     0x01,                       /*  u8  bSamFreqType */
193                     U24(USBAUDIO_SAMPLE_RATE),  /* u24  tSamFreq */
194                 }
195             }
196         },
197         .eps = (USBDescEndpoint[]) {
198             {
199                 .bEndpointAddress      = USB_DIR_OUT | 0x01,
200                 .bmAttributes          = 0x0d,
201                 .wMaxPacketSize        = USBAUDIO_PACKET_SIZE,
202                 .bInterval             = 1,
203                 .is_audio              = 1,
204                 /* Stereo Headphone Class-specific
205                    AS Audio Data Endpoint Descriptor */
206                 .extra = (uint8_t[]) {
207                     0x07,                       /*  u8  bLength */
208                     USB_DT_CS_ENDPOINT,         /*  u8  bDescriptorType */
209                     DST_EP_GENERAL,             /*  u8  bDescriptorSubtype */
210                     0x00,                       /*  u8  bmAttributes */
211                     0x00,                       /*  u8  bLockDelayUnits */
212                     U16(0x0000),                /* u16  wLockDelay */
213                 },
214             },
215         }
216     }
217 };
218 
219 static const USBDescDevice desc_device = {
220     .bcdUSB                        = 0x0100,
221     .bMaxPacketSize0               = 64,
222     .bNumConfigurations            = 1,
223     .confs = (USBDescConfig[]) {
224         {
225             .bNumInterfaces        = 2,
226             .bConfigurationValue   = DEV_CONFIG_VALUE,
227             .iConfiguration        = STRING_CONFIG,
228             .bmAttributes          = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
229             .bMaxPower             = 0x32,
230             .nif = ARRAY_SIZE(desc_iface),
231             .ifs = desc_iface,
232         },
233     },
234 };
235 
236 static const USBDesc desc_audio = {
237     .id = {
238         .idVendor          = USBAUDIO_VENDOR_NUM,
239         .idProduct         = USBAUDIO_PRODUCT_NUM,
240         .bcdDevice         = 0,
241         .iManufacturer     = STRING_MANUFACTURER,
242         .iProduct          = STRING_PRODUCT,
243         .iSerialNumber     = STRING_SERIALNUMBER,
244     },
245     .full = &desc_device,
246     .str  = usb_audio_stringtable,
247 };
248 
249 /*
250  * A USB audio device supports an arbitrary number of alternate
251  * interface settings for each interface.  Each corresponds to a block
252  * diagram of parameterized blocks.  This can thus refer to things like
253  * number of channels, data rates, or in fact completely different
254  * block diagrams.  Alternative setting 0 is always the null block diagram,
255  * which is used by a disabled device.
256  */
257 enum usb_audio_altset {
258     ALTSET_OFF  = 0x00,         /* No endpoint */
259     ALTSET_ON   = 0x01,         /* Single endpoint */
260 };
261 
262 /*
263  * Class-specific control requests
264  */
265 #define CR_SET_CUR      0x01
266 #define CR_GET_CUR      0x81
267 #define CR_SET_MIN      0x02
268 #define CR_GET_MIN      0x82
269 #define CR_SET_MAX      0x03
270 #define CR_GET_MAX      0x83
271 #define CR_SET_RES      0x04
272 #define CR_GET_RES      0x84
273 #define CR_SET_MEM      0x05
274 #define CR_GET_MEM      0x85
275 #define CR_GET_STAT     0xff
276 
277 /*
278  * Feature Unit Control Selectors
279  */
280 #define MUTE_CONTROL                    0x01
281 #define VOLUME_CONTROL                  0x02
282 #define BASS_CONTROL                    0x03
283 #define MID_CONTROL                     0x04
284 #define TREBLE_CONTROL                  0x05
285 #define GRAPHIC_EQUALIZER_CONTROL       0x06
286 #define AUTOMATIC_GAIN_CONTROL          0x07
287 #define DELAY_CONTROL                   0x08
288 #define BASS_BOOST_CONTROL              0x09
289 #define LOUDNESS_CONTROL                0x0a
290 
291 /*
292  * buffering
293  */
294 
295 struct streambuf {
296     uint8_t *data;
297     uint32_t size;
298     uint32_t prod;
299     uint32_t cons;
300 };
301 
302 static void streambuf_init(struct streambuf *buf, uint32_t size)
303 {
304     g_free(buf->data);
305     buf->size = size - (size % USBAUDIO_PACKET_SIZE);
306     buf->data = g_malloc(buf->size);
307     buf->prod = 0;
308     buf->cons = 0;
309 }
310 
311 static void streambuf_fini(struct streambuf *buf)
312 {
313     g_free(buf->data);
314     buf->data = NULL;
315 }
316 
317 static int streambuf_put(struct streambuf *buf, USBPacket *p)
318 {
319     uint32_t free = buf->size - (buf->prod - buf->cons);
320 
321     if (!free) {
322         return 0;
323     }
324     if (p->iov.size != USBAUDIO_PACKET_SIZE) {
325         return 0;
326     }
327     assert(free >= USBAUDIO_PACKET_SIZE);
328     usb_packet_copy(p, buf->data + (buf->prod % buf->size),
329                     USBAUDIO_PACKET_SIZE);
330     buf->prod += USBAUDIO_PACKET_SIZE;
331     return USBAUDIO_PACKET_SIZE;
332 }
333 
334 static uint8_t *streambuf_get(struct streambuf *buf)
335 {
336     uint32_t used = buf->prod - buf->cons;
337     uint8_t *data;
338 
339     if (!used) {
340         return NULL;
341     }
342     assert(used >= USBAUDIO_PACKET_SIZE);
343     data = buf->data + (buf->cons % buf->size);
344     buf->cons += USBAUDIO_PACKET_SIZE;
345     return data;
346 }
347 
348 typedef struct USBAudioState {
349     /* qemu interfaces */
350     USBDevice dev;
351     QEMUSoundCard card;
352 
353     /* state */
354     struct {
355         enum usb_audio_altset altset;
356         struct audsettings as;
357         SWVoiceOut *voice;
358         bool mute;
359         uint8_t vol[2];
360         struct streambuf buf;
361     } out;
362 
363     /* properties */
364     uint32_t debug;
365     uint32_t buffer;
366 } USBAudioState;
367 
368 #define TYPE_USB_AUDIO "usb-audio"
369 #define USB_AUDIO(obj) OBJECT_CHECK(USBAudioState, (obj), TYPE_USB_AUDIO)
370 
371 static void output_callback(void *opaque, int avail)
372 {
373     USBAudioState *s = opaque;
374     uint8_t *data;
375 
376     for (;;) {
377         if (avail < USBAUDIO_PACKET_SIZE) {
378             return;
379         }
380         data = streambuf_get(&s->out.buf);
381         if (!data) {
382             return;
383         }
384         AUD_write(s->out.voice, data, USBAUDIO_PACKET_SIZE);
385         avail -= USBAUDIO_PACKET_SIZE;
386     }
387 }
388 
389 static int usb_audio_set_output_altset(USBAudioState *s, int altset)
390 {
391     switch (altset) {
392     case ALTSET_OFF:
393         streambuf_init(&s->out.buf, s->buffer);
394         AUD_set_active_out(s->out.voice, false);
395         break;
396     case ALTSET_ON:
397         AUD_set_active_out(s->out.voice, true);
398         break;
399     default:
400         return -1;
401     }
402 
403     if (s->debug) {
404         fprintf(stderr, "usb-audio: set interface %d\n", altset);
405     }
406     s->out.altset = altset;
407     return 0;
408 }
409 
410 /*
411  * Note: we arbitrarily map the volume control range onto -inf..+8 dB
412  */
413 #define ATTRIB_ID(cs, attrib, idif)     \
414     (((cs) << 24) | ((attrib) << 16) | (idif))
415 
416 static int usb_audio_get_control(USBAudioState *s, uint8_t attrib,
417                                  uint16_t cscn, uint16_t idif,
418                                  int length, uint8_t *data)
419 {
420     uint8_t cs = cscn >> 8;
421     uint8_t cn = cscn - 1;      /* -1 for the non-present master control */
422     uint32_t aid = ATTRIB_ID(cs, attrib, idif);
423     int ret = USB_RET_STALL;
424 
425     switch (aid) {
426     case ATTRIB_ID(MUTE_CONTROL, CR_GET_CUR, 0x0200):
427         data[0] = s->out.mute;
428         ret = 1;
429         break;
430     case ATTRIB_ID(VOLUME_CONTROL, CR_GET_CUR, 0x0200):
431         if (cn < 2) {
432             uint16_t vol = (s->out.vol[cn] * 0x8800 + 127) / 255 + 0x8000;
433             data[0] = vol;
434             data[1] = vol >> 8;
435             ret = 2;
436         }
437         break;
438     case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MIN, 0x0200):
439         if (cn < 2) {
440             data[0] = 0x01;
441             data[1] = 0x80;
442             ret = 2;
443         }
444         break;
445     case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MAX, 0x0200):
446         if (cn < 2) {
447             data[0] = 0x00;
448             data[1] = 0x08;
449             ret = 2;
450         }
451         break;
452     case ATTRIB_ID(VOLUME_CONTROL, CR_GET_RES, 0x0200):
453         if (cn < 2) {
454             data[0] = 0x88;
455             data[1] = 0x00;
456             ret = 2;
457         }
458         break;
459     }
460 
461     return ret;
462 }
463 static int usb_audio_set_control(USBAudioState *s, uint8_t attrib,
464                                  uint16_t cscn, uint16_t idif,
465                                  int length, uint8_t *data)
466 {
467     uint8_t cs = cscn >> 8;
468     uint8_t cn = cscn - 1;      /* -1 for the non-present master control */
469     uint32_t aid = ATTRIB_ID(cs, attrib, idif);
470     int ret = USB_RET_STALL;
471     bool set_vol = false;
472 
473     switch (aid) {
474     case ATTRIB_ID(MUTE_CONTROL, CR_SET_CUR, 0x0200):
475         s->out.mute = data[0] & 1;
476         set_vol = true;
477         ret = 0;
478         break;
479     case ATTRIB_ID(VOLUME_CONTROL, CR_SET_CUR, 0x0200):
480         if (cn < 2) {
481             uint16_t vol = data[0] + (data[1] << 8);
482 
483             if (s->debug) {
484                 fprintf(stderr, "usb-audio: vol %04x\n", (uint16_t)vol);
485             }
486 
487             vol -= 0x8000;
488             vol = (vol * 255 + 0x4400) / 0x8800;
489             if (vol > 255) {
490                 vol = 255;
491             }
492 
493             s->out.vol[cn] = vol;
494             set_vol = true;
495             ret = 0;
496         }
497         break;
498     }
499 
500     if (set_vol) {
501         if (s->debug) {
502             fprintf(stderr, "usb-audio: mute %d, lvol %3d, rvol %3d\n",
503                     s->out.mute, s->out.vol[0], s->out.vol[1]);
504         }
505         AUD_set_volume_out(s->out.voice, s->out.mute,
506                            s->out.vol[0], s->out.vol[1]);
507     }
508 
509     return ret;
510 }
511 
512 static void usb_audio_handle_control(USBDevice *dev, USBPacket *p,
513                                     int request, int value, int index,
514                                     int length, uint8_t *data)
515 {
516     USBAudioState *s = USB_AUDIO(dev);
517     int ret = 0;
518 
519     if (s->debug) {
520         fprintf(stderr, "usb-audio: control transaction: "
521                 "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
522                 request, value, index, length);
523     }
524 
525     ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
526     if (ret >= 0) {
527         return;
528     }
529 
530     switch (request) {
531     case ClassInterfaceRequest | CR_GET_CUR:
532     case ClassInterfaceRequest | CR_GET_MIN:
533     case ClassInterfaceRequest | CR_GET_MAX:
534     case ClassInterfaceRequest | CR_GET_RES:
535         ret = usb_audio_get_control(s, request & 0xff, value, index,
536                                     length, data);
537         if (ret < 0) {
538             if (s->debug) {
539                 fprintf(stderr, "usb-audio: fail: get control\n");
540             }
541             goto fail;
542         }
543         p->actual_length = ret;
544         break;
545 
546     case ClassInterfaceOutRequest | CR_SET_CUR:
547     case ClassInterfaceOutRequest | CR_SET_MIN:
548     case ClassInterfaceOutRequest | CR_SET_MAX:
549     case ClassInterfaceOutRequest | CR_SET_RES:
550         ret = usb_audio_set_control(s, request & 0xff, value, index,
551                                     length, data);
552         if (ret < 0) {
553             if (s->debug) {
554                 fprintf(stderr, "usb-audio: fail: set control\n");
555             }
556             goto fail;
557         }
558         break;
559 
560     default:
561 fail:
562         if (s->debug) {
563             fprintf(stderr, "usb-audio: failed control transaction: "
564                     "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
565                     request, value, index, length);
566         }
567         p->status = USB_RET_STALL;
568         break;
569     }
570 }
571 
572 static void usb_audio_set_interface(USBDevice *dev, int iface,
573                                     int old, int value)
574 {
575     USBAudioState *s = USB_AUDIO(dev);
576 
577     if (iface == 1) {
578         usb_audio_set_output_altset(s, value);
579     }
580 }
581 
582 static void usb_audio_handle_reset(USBDevice *dev)
583 {
584     USBAudioState *s = USB_AUDIO(dev);
585 
586     if (s->debug) {
587         fprintf(stderr, "usb-audio: reset\n");
588     }
589     usb_audio_set_output_altset(s, ALTSET_OFF);
590 }
591 
592 static void usb_audio_handle_dataout(USBAudioState *s, USBPacket *p)
593 {
594     if (s->out.altset == ALTSET_OFF) {
595         p->status = USB_RET_STALL;
596         return;
597     }
598 
599     streambuf_put(&s->out.buf, p);
600     if (p->actual_length < p->iov.size && s->debug > 1) {
601         fprintf(stderr, "usb-audio: output overrun (%zd bytes)\n",
602                 p->iov.size - p->actual_length);
603     }
604 }
605 
606 static void usb_audio_handle_data(USBDevice *dev, USBPacket *p)
607 {
608     USBAudioState *s = (USBAudioState *) dev;
609 
610     if (p->pid == USB_TOKEN_OUT && p->ep->nr == 1) {
611         usb_audio_handle_dataout(s, p);
612         return;
613     }
614 
615     p->status = USB_RET_STALL;
616     if (s->debug) {
617         fprintf(stderr, "usb-audio: failed data transaction: "
618                         "pid 0x%x ep 0x%x len 0x%zx\n",
619                         p->pid, p->ep->nr, p->iov.size);
620     }
621 }
622 
623 static void usb_audio_unrealize(USBDevice *dev, Error **errp)
624 {
625     USBAudioState *s = USB_AUDIO(dev);
626 
627     if (s->debug) {
628         fprintf(stderr, "usb-audio: destroy\n");
629     }
630 
631     usb_audio_set_output_altset(s, ALTSET_OFF);
632     AUD_close_out(&s->card, s->out.voice);
633     AUD_remove_card(&s->card);
634 
635     streambuf_fini(&s->out.buf);
636 }
637 
638 static void usb_audio_realize(USBDevice *dev, Error **errp)
639 {
640     USBAudioState *s = USB_AUDIO(dev);
641 
642     usb_desc_create_serial(dev);
643     usb_desc_init(dev);
644     s->dev.opaque = s;
645     AUD_register_card(TYPE_USB_AUDIO, &s->card);
646 
647     s->out.altset        = ALTSET_OFF;
648     s->out.mute          = false;
649     s->out.vol[0]        = 240; /* 0 dB */
650     s->out.vol[1]        = 240; /* 0 dB */
651     s->out.as.freq       = USBAUDIO_SAMPLE_RATE;
652     s->out.as.nchannels  = 2;
653     s->out.as.fmt        = AUDIO_FORMAT_S16;
654     s->out.as.endianness = 0;
655     streambuf_init(&s->out.buf, s->buffer);
656 
657     s->out.voice = AUD_open_out(&s->card, s->out.voice, TYPE_USB_AUDIO,
658                                 s, output_callback, &s->out.as);
659     AUD_set_volume_out(s->out.voice, s->out.mute, s->out.vol[0], s->out.vol[1]);
660     AUD_set_active_out(s->out.voice, 0);
661 }
662 
663 static const VMStateDescription vmstate_usb_audio = {
664     .name = TYPE_USB_AUDIO,
665     .unmigratable = 1,
666 };
667 
668 static Property usb_audio_properties[] = {
669     DEFINE_PROP_UINT32("debug", USBAudioState, debug, 0),
670     DEFINE_PROP_UINT32("buffer", USBAudioState, buffer,
671                        32 * USBAUDIO_PACKET_SIZE),
672     DEFINE_PROP_END_OF_LIST(),
673 };
674 
675 static void usb_audio_class_init(ObjectClass *klass, void *data)
676 {
677     DeviceClass *dc = DEVICE_CLASS(klass);
678     USBDeviceClass *k = USB_DEVICE_CLASS(klass);
679 
680     dc->vmsd          = &vmstate_usb_audio;
681     dc->props         = usb_audio_properties;
682     set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
683     k->product_desc   = "QEMU USB Audio Interface";
684     k->usb_desc       = &desc_audio;
685     k->realize        = usb_audio_realize;
686     k->handle_reset   = usb_audio_handle_reset;
687     k->handle_control = usb_audio_handle_control;
688     k->handle_data    = usb_audio_handle_data;
689     k->unrealize      = usb_audio_unrealize;
690     k->set_interface  = usb_audio_set_interface;
691 }
692 
693 static const TypeInfo usb_audio_info = {
694     .name          = TYPE_USB_AUDIO,
695     .parent        = TYPE_USB_DEVICE,
696     .instance_size = sizeof(USBAudioState),
697     .class_init    = usb_audio_class_init,
698 };
699 
700 static void usb_audio_register_types(void)
701 {
702     type_register_static(&usb_audio_info);
703     usb_legacy_register(TYPE_USB_AUDIO, "audio", NULL);
704 }
705 
706 type_init(usb_audio_register_types)
707