1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32#include "qemu/osdep.h"
33#include "qemu/module.h"
34#include "hw/qdev-properties.h"
35#include "hw/usb.h"
36#include "migration/vmstate.h"
37#include "desc.h"
38#include "audio/audio.h"
39
40static void usb_audio_reinit(USBDevice *dev, unsigned channels);
41
42#define USBAUDIO_VENDOR_NUM 0x46f4
43#define USBAUDIO_PRODUCT_NUM 0x0002
44
45#define DEV_CONFIG_VALUE 1
46
47#define USBAUDIO_MAX_CHANNELS(s) (s->multi ? 8 : 2)
48
49
50#define DST_AC_HEADER 1
51#define DST_AC_INPUT_TERMINAL 2
52#define DST_AC_OUTPUT_TERMINAL 3
53#define DST_AC_FEATURE_UNIT 6
54
55#define DST_AS_GENERAL 1
56#define DST_AS_FORMAT_TYPE 2
57
58#define DST_EP_GENERAL 1
59
60enum usb_audio_strings {
61 STRING_NULL,
62 STRING_MANUFACTURER,
63 STRING_PRODUCT,
64 STRING_SERIALNUMBER,
65 STRING_CONFIG,
66 STRING_USBAUDIO_CONTROL,
67 STRING_INPUT_TERMINAL,
68 STRING_FEATURE_UNIT,
69 STRING_OUTPUT_TERMINAL,
70 STRING_NULL_STREAM,
71 STRING_REAL_STREAM,
72};
73
74static const USBDescStrings usb_audio_stringtable = {
75 [STRING_MANUFACTURER] = "QEMU",
76 [STRING_PRODUCT] = "QEMU USB Audio",
77 [STRING_SERIALNUMBER] = "1",
78 [STRING_CONFIG] = "Audio Configuration",
79 [STRING_USBAUDIO_CONTROL] = "Audio Device",
80 [STRING_INPUT_TERMINAL] = "Audio Output Pipe",
81 [STRING_FEATURE_UNIT] = "Audio Output Volume Control",
82 [STRING_OUTPUT_TERMINAL] = "Audio Output Terminal",
83 [STRING_NULL_STREAM] = "Audio Output - Disabled",
84 [STRING_REAL_STREAM] = "Audio Output - 48 kHz Stereo",
85};
86
87
88
89
90
91
92
93
94
95enum usb_audio_altset {
96 ALTSET_OFF = 0x00,
97 ALTSET_STEREO = 0x01,
98 ALTSET_51 = 0x02,
99 ALTSET_71 = 0x03,
100};
101
102static unsigned altset_channels[] = {
103 [ALTSET_STEREO] = 2,
104 [ALTSET_51] = 6,
105 [ALTSET_71] = 8,
106};
107
108#define U16(x) ((x) & 0xff), (((x) >> 8) & 0xff)
109#define U24(x) U16(x), (((x) >> 16) & 0xff)
110#define U32(x) U24(x), (((x) >> 24) & 0xff)
111
112
113
114
115#define USBAUDIO_PACKET_SIZE_BASE 96
116#define USBAUDIO_PACKET_SIZE(channels) (USBAUDIO_PACKET_SIZE_BASE * channels)
117#define USBAUDIO_SAMPLE_RATE 48000
118#define USBAUDIO_PACKET_INTERVAL 1
119
120static const USBDescIface desc_iface[] = {
121 {
122 .bInterfaceNumber = 0,
123 .bNumEndpoints = 0,
124 .bInterfaceClass = USB_CLASS_AUDIO,
125 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL,
126 .bInterfaceProtocol = 0x04,
127 .iInterface = STRING_USBAUDIO_CONTROL,
128 .ndesc = 4,
129 .descs = (USBDescOther[]) {
130 {
131
132 .data = (uint8_t[]) {
133 0x09,
134 USB_DT_CS_INTERFACE,
135 DST_AC_HEADER,
136 U16(0x0100),
137 U16(0x2b),
138 0x01,
139 0x01,
140 }
141 },{
142
143 .data = (uint8_t[]) {
144 0x0c,
145 USB_DT_CS_INTERFACE,
146 DST_AC_INPUT_TERMINAL,
147 0x01,
148 U16(0x0101),
149 0x00,
150 0x02,
151 U16(0x0003),
152 0x00,
153 STRING_INPUT_TERMINAL,
154 }
155 },{
156
157 .data = (uint8_t[]) {
158 0x0d,
159 USB_DT_CS_INTERFACE,
160 DST_AC_FEATURE_UNIT,
161 0x02,
162 0x01,
163 0x02,
164 U16(0x0001),
165 U16(0x0002),
166 U16(0x0002),
167 STRING_FEATURE_UNIT,
168 }
169 },{
170
171 .data = (uint8_t[]) {
172 0x09,
173 USB_DT_CS_INTERFACE,
174 DST_AC_OUTPUT_TERMINAL,
175 0x03,
176 U16(0x0301),
177 0x00,
178 0x02,
179 STRING_OUTPUT_TERMINAL,
180 }
181 }
182 },
183 },{
184 .bInterfaceNumber = 1,
185 .bAlternateSetting = ALTSET_OFF,
186 .bNumEndpoints = 0,
187 .bInterfaceClass = USB_CLASS_AUDIO,
188 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_STREAMING,
189 .iInterface = STRING_NULL_STREAM,
190 },{
191 .bInterfaceNumber = 1,
192 .bAlternateSetting = ALTSET_STEREO,
193 .bNumEndpoints = 1,
194 .bInterfaceClass = USB_CLASS_AUDIO,
195 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_STREAMING,
196 .iInterface = STRING_REAL_STREAM,
197 .ndesc = 2,
198 .descs = (USBDescOther[]) {
199 {
200
201 .data = (uint8_t[]) {
202 0x07,
203 USB_DT_CS_INTERFACE,
204 DST_AS_GENERAL,
205 0x01,
206 0x00,
207 0x01, 0x00,
208 }
209 },{
210
211 .data = (uint8_t[]) {
212 0x0b,
213 USB_DT_CS_INTERFACE,
214 DST_AS_FORMAT_TYPE,
215 0x01,
216 0x02,
217 0x02,
218 0x10,
219 0x01,
220 U24(USBAUDIO_SAMPLE_RATE),
221 }
222 }
223 },
224 .eps = (USBDescEndpoint[]) {
225 {
226 .bEndpointAddress = USB_DIR_OUT | 0x01,
227 .bmAttributes = 0x0d,
228 .wMaxPacketSize = USBAUDIO_PACKET_SIZE(2),
229 .bInterval = 1,
230 .is_audio = 1,
231
232
233 .extra = (uint8_t[]) {
234 0x07,
235 USB_DT_CS_ENDPOINT,
236 DST_EP_GENERAL,
237 0x00,
238 0x00,
239 U16(0x0000),
240 },
241 },
242 }
243 }
244};
245
246static const USBDescDevice desc_device = {
247 .bcdUSB = 0x0100,
248 .bMaxPacketSize0 = 64,
249 .bNumConfigurations = 1,
250 .confs = (USBDescConfig[]) {
251 {
252 .bNumInterfaces = 2,
253 .bConfigurationValue = DEV_CONFIG_VALUE,
254 .iConfiguration = STRING_CONFIG,
255 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
256 .bMaxPower = 0x32,
257 .nif = ARRAY_SIZE(desc_iface),
258 .ifs = desc_iface,
259 },
260 },
261};
262
263static const USBDesc desc_audio = {
264 .id = {
265 .idVendor = USBAUDIO_VENDOR_NUM,
266 .idProduct = USBAUDIO_PRODUCT_NUM,
267 .bcdDevice = 0,
268 .iManufacturer = STRING_MANUFACTURER,
269 .iProduct = STRING_PRODUCT,
270 .iSerialNumber = STRING_SERIALNUMBER,
271 },
272 .full = &desc_device,
273 .str = usb_audio_stringtable,
274};
275
276
277
278static const USBDescIface desc_iface_multi[] = {
279 {
280 .bInterfaceNumber = 0,
281 .bNumEndpoints = 0,
282 .bInterfaceClass = USB_CLASS_AUDIO,
283 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL,
284 .bInterfaceProtocol = 0x04,
285 .iInterface = STRING_USBAUDIO_CONTROL,
286 .ndesc = 4,
287 .descs = (USBDescOther[]) {
288 {
289
290 .data = (uint8_t[]) {
291 0x09,
292 USB_DT_CS_INTERFACE,
293 DST_AC_HEADER,
294 U16(0x0100),
295 U16(0x38),
296 0x01,
297 0x01,
298 }
299 },{
300
301 .data = (uint8_t[]) {
302 0x0c,
303 USB_DT_CS_INTERFACE,
304 DST_AC_INPUT_TERMINAL,
305 0x01,
306 U16(0x0101),
307 0x00,
308 0x08,
309 U16(0x063f),
310 0x00,
311 STRING_INPUT_TERMINAL,
312 }
313 },{
314
315 .data = (uint8_t[]) {
316 0x19,
317 USB_DT_CS_INTERFACE,
318 DST_AC_FEATURE_UNIT,
319 0x02,
320 0x01,
321 0x02,
322 U16(0x0001),
323 U16(0x0002),
324 U16(0x0002),
325 U16(0x0002),
326 U16(0x0002),
327 U16(0x0002),
328 U16(0x0002),
329 U16(0x0002),
330 U16(0x0002),
331 STRING_FEATURE_UNIT,
332 }
333 },{
334
335 .data = (uint8_t[]) {
336 0x09,
337 USB_DT_CS_INTERFACE,
338 DST_AC_OUTPUT_TERMINAL,
339 0x03,
340 U16(0x0301),
341 0x00,
342 0x02,
343 STRING_OUTPUT_TERMINAL,
344 }
345 }
346 },
347 },{
348 .bInterfaceNumber = 1,
349 .bAlternateSetting = ALTSET_OFF,
350 .bNumEndpoints = 0,
351 .bInterfaceClass = USB_CLASS_AUDIO,
352 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_STREAMING,
353 .iInterface = STRING_NULL_STREAM,
354 },{
355 .bInterfaceNumber = 1,
356 .bAlternateSetting = ALTSET_STEREO,
357 .bNumEndpoints = 1,
358 .bInterfaceClass = USB_CLASS_AUDIO,
359 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_STREAMING,
360 .iInterface = STRING_REAL_STREAM,
361 .ndesc = 2,
362 .descs = (USBDescOther[]) {
363 {
364
365 .data = (uint8_t[]) {
366 0x07,
367 USB_DT_CS_INTERFACE,
368 DST_AS_GENERAL,
369 0x01,
370 0x00,
371 0x01, 0x00,
372 }
373 },{
374
375 .data = (uint8_t[]) {
376 0x0b,
377 USB_DT_CS_INTERFACE,
378 DST_AS_FORMAT_TYPE,
379 0x01,
380 0x02,
381 0x02,
382 0x10,
383 0x01,
384 U24(USBAUDIO_SAMPLE_RATE),
385 }
386 }
387 },
388 .eps = (USBDescEndpoint[]) {
389 {
390 .bEndpointAddress = USB_DIR_OUT | 0x01,
391 .bmAttributes = 0x0d,
392 .wMaxPacketSize = USBAUDIO_PACKET_SIZE(2),
393 .bInterval = 1,
394 .is_audio = 1,
395
396
397 .extra = (uint8_t[]) {
398 0x07,
399 USB_DT_CS_ENDPOINT,
400 DST_EP_GENERAL,
401 0x00,
402 0x00,
403 U16(0x0000),
404 },
405 },
406 }
407 },{
408 .bInterfaceNumber = 1,
409 .bAlternateSetting = ALTSET_51,
410 .bNumEndpoints = 1,
411 .bInterfaceClass = USB_CLASS_AUDIO,
412 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_STREAMING,
413 .iInterface = STRING_REAL_STREAM,
414 .ndesc = 2,
415 .descs = (USBDescOther[]) {
416 {
417
418 .data = (uint8_t[]) {
419 0x07,
420 USB_DT_CS_INTERFACE,
421 DST_AS_GENERAL,
422 0x01,
423 0x00,
424 0x01, 0x00,
425 }
426 },{
427
428 .data = (uint8_t[]) {
429 0x0b,
430 USB_DT_CS_INTERFACE,
431 DST_AS_FORMAT_TYPE,
432 0x01,
433 0x06,
434 0x02,
435 0x10,
436 0x01,
437 U24(USBAUDIO_SAMPLE_RATE),
438 }
439 }
440 },
441 .eps = (USBDescEndpoint[]) {
442 {
443 .bEndpointAddress = USB_DIR_OUT | 0x01,
444 .bmAttributes = 0x0d,
445 .wMaxPacketSize = USBAUDIO_PACKET_SIZE(6),
446 .bInterval = 1,
447 .is_audio = 1,
448
449
450 .extra = (uint8_t[]) {
451 0x07,
452 USB_DT_CS_ENDPOINT,
453 DST_EP_GENERAL,
454 0x00,
455 0x00,
456 U16(0x0000),
457 },
458 },
459 }
460 },{
461 .bInterfaceNumber = 1,
462 .bAlternateSetting = ALTSET_71,
463 .bNumEndpoints = 1,
464 .bInterfaceClass = USB_CLASS_AUDIO,
465 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_STREAMING,
466 .iInterface = STRING_REAL_STREAM,
467 .ndesc = 2,
468 .descs = (USBDescOther[]) {
469 {
470
471 .data = (uint8_t[]) {
472 0x07,
473 USB_DT_CS_INTERFACE,
474 DST_AS_GENERAL,
475 0x01,
476 0x00,
477 0x01, 0x00,
478 }
479 },{
480
481 .data = (uint8_t[]) {
482 0x0b,
483 USB_DT_CS_INTERFACE,
484 DST_AS_FORMAT_TYPE,
485 0x01,
486 0x08,
487 0x02,
488 0x10,
489 0x01,
490 U24(USBAUDIO_SAMPLE_RATE),
491 }
492 }
493 },
494 .eps = (USBDescEndpoint[]) {
495 {
496 .bEndpointAddress = USB_DIR_OUT | 0x01,
497 .bmAttributes = 0x0d,
498 .wMaxPacketSize = USBAUDIO_PACKET_SIZE(8),
499 .bInterval = 1,
500 .is_audio = 1,
501
502
503 .extra = (uint8_t[]) {
504 0x07,
505 USB_DT_CS_ENDPOINT,
506 DST_EP_GENERAL,
507 0x00,
508 0x00,
509 U16(0x0000),
510 },
511 },
512 }
513 }
514};
515
516static const USBDescDevice desc_device_multi = {
517 .bcdUSB = 0x0100,
518 .bMaxPacketSize0 = 64,
519 .bNumConfigurations = 1,
520 .confs = (USBDescConfig[]) {
521 {
522 .bNumInterfaces = 2,
523 .bConfigurationValue = DEV_CONFIG_VALUE,
524 .iConfiguration = STRING_CONFIG,
525 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
526 .bMaxPower = 0x32,
527 .nif = ARRAY_SIZE(desc_iface_multi),
528 .ifs = desc_iface_multi,
529 }
530 },
531};
532
533static const USBDesc desc_audio_multi = {
534 .id = {
535 .idVendor = USBAUDIO_VENDOR_NUM,
536 .idProduct = USBAUDIO_PRODUCT_NUM,
537 .bcdDevice = 0,
538 .iManufacturer = STRING_MANUFACTURER,
539 .iProduct = STRING_PRODUCT,
540 .iSerialNumber = STRING_SERIALNUMBER,
541 },
542 .full = &desc_device_multi,
543 .str = usb_audio_stringtable,
544};
545
546
547
548
549#define CR_SET_CUR 0x01
550#define CR_GET_CUR 0x81
551#define CR_SET_MIN 0x02
552#define CR_GET_MIN 0x82
553#define CR_SET_MAX 0x03
554#define CR_GET_MAX 0x83
555#define CR_SET_RES 0x04
556#define CR_GET_RES 0x84
557#define CR_SET_MEM 0x05
558#define CR_GET_MEM 0x85
559#define CR_GET_STAT 0xff
560
561
562
563
564#define MUTE_CONTROL 0x01
565#define VOLUME_CONTROL 0x02
566#define BASS_CONTROL 0x03
567#define MID_CONTROL 0x04
568#define TREBLE_CONTROL 0x05
569#define GRAPHIC_EQUALIZER_CONTROL 0x06
570#define AUTOMATIC_GAIN_CONTROL 0x07
571#define DELAY_CONTROL 0x08
572#define BASS_BOOST_CONTROL 0x09
573#define LOUDNESS_CONTROL 0x0a
574
575
576
577
578
579struct streambuf {
580 uint8_t *data;
581 size_t size;
582 uint64_t prod;
583 uint64_t cons;
584};
585
586static void streambuf_init(struct streambuf *buf, uint32_t size,
587 uint32_t channels)
588{
589 g_free(buf->data);
590 buf->size = size - (size % USBAUDIO_PACKET_SIZE(channels));
591 buf->data = g_malloc(buf->size);
592 buf->prod = 0;
593 buf->cons = 0;
594}
595
596static void streambuf_fini(struct streambuf *buf)
597{
598 g_free(buf->data);
599 buf->data = NULL;
600}
601
602static int streambuf_put(struct streambuf *buf, USBPacket *p, uint32_t channels)
603{
604 int64_t free = buf->size - (buf->prod - buf->cons);
605
606 if (free < USBAUDIO_PACKET_SIZE(channels)) {
607 return 0;
608 }
609 if (p->iov.size != USBAUDIO_PACKET_SIZE(channels)) {
610 return 0;
611 }
612
613
614 assert(buf->prod % USBAUDIO_PACKET_SIZE(channels) == 0);
615 usb_packet_copy(p, buf->data + (buf->prod % buf->size),
616 USBAUDIO_PACKET_SIZE(channels));
617 buf->prod += USBAUDIO_PACKET_SIZE(channels);
618 return USBAUDIO_PACKET_SIZE(channels);
619}
620
621static uint8_t *streambuf_get(struct streambuf *buf, size_t *len)
622{
623 int64_t used = buf->prod - buf->cons;
624 uint8_t *data;
625
626 if (used <= 0) {
627 *len = 0;
628 return NULL;
629 }
630 data = buf->data + (buf->cons % buf->size);
631 *len = MIN(buf->prod - buf->cons,
632 buf->size - (buf->cons % buf->size));
633 return data;
634}
635
636typedef struct USBAudioState {
637
638 USBDevice dev;
639 QEMUSoundCard card;
640
641
642 struct {
643 enum usb_audio_altset altset;
644 struct audsettings as;
645 SWVoiceOut *voice;
646 Volume vol;
647 struct streambuf buf;
648 uint32_t channels;
649 } out;
650
651
652 uint32_t debug;
653 uint32_t buffer_user, buffer;
654 bool multi;
655} USBAudioState;
656
657#define TYPE_USB_AUDIO "usb-audio"
658#define USB_AUDIO(obj) OBJECT_CHECK(USBAudioState, (obj), TYPE_USB_AUDIO)
659
660static void output_callback(void *opaque, int avail)
661{
662 USBAudioState *s = opaque;
663 uint8_t *data;
664
665 while (avail) {
666 size_t written, len;
667
668 data = streambuf_get(&s->out.buf, &len);
669 if (!data) {
670 return;
671 }
672
673 written = AUD_write(s->out.voice, data, len);
674 avail -= written;
675 s->out.buf.cons += written;
676
677 if (written < len) {
678 return;
679 }
680 }
681}
682
683static int usb_audio_set_output_altset(USBAudioState *s, int altset)
684{
685 switch (altset) {
686 case ALTSET_OFF:
687 AUD_set_active_out(s->out.voice, false);
688 break;
689 case ALTSET_STEREO:
690 case ALTSET_51:
691 case ALTSET_71:
692 if (s->out.channels != altset_channels[altset]) {
693 usb_audio_reinit(USB_DEVICE(s), altset_channels[altset]);
694 }
695 streambuf_init(&s->out.buf, s->buffer, s->out.channels);
696 AUD_set_active_out(s->out.voice, true);
697 break;
698 default:
699 return -1;
700 }
701
702 if (s->debug) {
703 fprintf(stderr, "usb-audio: set interface %d\n", altset);
704 }
705 s->out.altset = altset;
706 return 0;
707}
708
709
710
711
712#define ATTRIB_ID(cs, attrib, idif) \
713 (((cs) << 24) | ((attrib) << 16) | (idif))
714
715static int usb_audio_get_control(USBAudioState *s, uint8_t attrib,
716 uint16_t cscn, uint16_t idif,
717 int length, uint8_t *data)
718{
719 uint8_t cs = cscn >> 8;
720 uint8_t cn = cscn - 1;
721 uint32_t aid = ATTRIB_ID(cs, attrib, idif);
722 int ret = USB_RET_STALL;
723
724 switch (aid) {
725 case ATTRIB_ID(MUTE_CONTROL, CR_GET_CUR, 0x0200):
726 data[0] = s->out.vol.mute;
727 ret = 1;
728 break;
729 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_CUR, 0x0200):
730 if (cn < USBAUDIO_MAX_CHANNELS(s)) {
731 uint16_t vol = (s->out.vol.vol[cn] * 0x8800 + 127) / 255 + 0x8000;
732 data[0] = vol;
733 data[1] = vol >> 8;
734 ret = 2;
735 }
736 break;
737 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MIN, 0x0200):
738 if (cn < USBAUDIO_MAX_CHANNELS(s)) {
739 data[0] = 0x01;
740 data[1] = 0x80;
741 ret = 2;
742 }
743 break;
744 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MAX, 0x0200):
745 if (cn < USBAUDIO_MAX_CHANNELS(s)) {
746 data[0] = 0x00;
747 data[1] = 0x08;
748 ret = 2;
749 }
750 break;
751 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_RES, 0x0200):
752 if (cn < USBAUDIO_MAX_CHANNELS(s)) {
753 data[0] = 0x88;
754 data[1] = 0x00;
755 ret = 2;
756 }
757 break;
758 }
759
760 return ret;
761}
762static int usb_audio_set_control(USBAudioState *s, uint8_t attrib,
763 uint16_t cscn, uint16_t idif,
764 int length, uint8_t *data)
765{
766 uint8_t cs = cscn >> 8;
767 uint8_t cn = cscn - 1;
768 uint32_t aid = ATTRIB_ID(cs, attrib, idif);
769 int ret = USB_RET_STALL;
770 bool set_vol = false;
771
772 switch (aid) {
773 case ATTRIB_ID(MUTE_CONTROL, CR_SET_CUR, 0x0200):
774 s->out.vol.mute = data[0] & 1;
775 set_vol = true;
776 ret = 0;
777 break;
778 case ATTRIB_ID(VOLUME_CONTROL, CR_SET_CUR, 0x0200):
779 if (cn < USBAUDIO_MAX_CHANNELS(s)) {
780 uint16_t vol = data[0] + (data[1] << 8);
781
782 if (s->debug) {
783 fprintf(stderr, "usb-audio: cn %d vol %04x\n", cn,
784 (uint16_t)vol);
785 }
786
787 vol -= 0x8000;
788 vol = (vol * 255 + 0x4400) / 0x8800;
789 if (vol > 255) {
790 vol = 255;
791 }
792
793 s->out.vol.vol[cn] = vol;
794 set_vol = true;
795 ret = 0;
796 }
797 break;
798 }
799
800 if (set_vol) {
801 if (s->debug) {
802 int i;
803 fprintf(stderr, "usb-audio: mute %d", s->out.vol.mute);
804 for (i = 0; i < USBAUDIO_MAX_CHANNELS(s); ++i) {
805 fprintf(stderr, ", vol[%d] %3d", i, s->out.vol.vol[i]);
806 }
807 fprintf(stderr, "\n");
808 }
809 audio_set_volume_out(s->out.voice, &s->out.vol);
810 }
811
812 return ret;
813}
814
815static void usb_audio_handle_control(USBDevice *dev, USBPacket *p,
816 int request, int value, int index,
817 int length, uint8_t *data)
818{
819 USBAudioState *s = USB_AUDIO(dev);
820 int ret = 0;
821
822 if (s->debug) {
823 fprintf(stderr, "usb-audio: control transaction: "
824 "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
825 request, value, index, length);
826 }
827
828 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
829 if (ret >= 0) {
830 return;
831 }
832
833 switch (request) {
834 case ClassInterfaceRequest | CR_GET_CUR:
835 case ClassInterfaceRequest | CR_GET_MIN:
836 case ClassInterfaceRequest | CR_GET_MAX:
837 case ClassInterfaceRequest | CR_GET_RES:
838 ret = usb_audio_get_control(s, request & 0xff, value, index,
839 length, data);
840 if (ret < 0) {
841 if (s->debug) {
842 fprintf(stderr, "usb-audio: fail: get control\n");
843 }
844 goto fail;
845 }
846 p->actual_length = ret;
847 break;
848
849 case ClassInterfaceOutRequest | CR_SET_CUR:
850 case ClassInterfaceOutRequest | CR_SET_MIN:
851 case ClassInterfaceOutRequest | CR_SET_MAX:
852 case ClassInterfaceOutRequest | CR_SET_RES:
853 ret = usb_audio_set_control(s, request & 0xff, value, index,
854 length, data);
855 if (ret < 0) {
856 if (s->debug) {
857 fprintf(stderr, "usb-audio: fail: set control\n");
858 }
859 goto fail;
860 }
861 break;
862
863 default:
864fail:
865 if (s->debug) {
866 fprintf(stderr, "usb-audio: failed control transaction: "
867 "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
868 request, value, index, length);
869 }
870 p->status = USB_RET_STALL;
871 break;
872 }
873}
874
875static void usb_audio_set_interface(USBDevice *dev, int iface,
876 int old, int value)
877{
878 USBAudioState *s = USB_AUDIO(dev);
879
880 if (iface == 1) {
881 usb_audio_set_output_altset(s, value);
882 }
883}
884
885static void usb_audio_handle_reset(USBDevice *dev)
886{
887 USBAudioState *s = USB_AUDIO(dev);
888
889 if (s->debug) {
890 fprintf(stderr, "usb-audio: reset\n");
891 }
892 usb_audio_set_output_altset(s, ALTSET_OFF);
893}
894
895static void usb_audio_handle_dataout(USBAudioState *s, USBPacket *p)
896{
897 if (s->out.altset == ALTSET_OFF) {
898 p->status = USB_RET_STALL;
899 return;
900 }
901
902 streambuf_put(&s->out.buf, p, s->out.channels);
903 if (p->actual_length < p->iov.size && s->debug > 1) {
904 fprintf(stderr, "usb-audio: output overrun (%zd bytes)\n",
905 p->iov.size - p->actual_length);
906 }
907}
908
909static void usb_audio_handle_data(USBDevice *dev, USBPacket *p)
910{
911 USBAudioState *s = (USBAudioState *) dev;
912
913 if (p->pid == USB_TOKEN_OUT && p->ep->nr == 1) {
914 usb_audio_handle_dataout(s, p);
915 return;
916 }
917
918 p->status = USB_RET_STALL;
919 if (s->debug) {
920 fprintf(stderr, "usb-audio: failed data transaction: "
921 "pid 0x%x ep 0x%x len 0x%zx\n",
922 p->pid, p->ep->nr, p->iov.size);
923 }
924}
925
926static void usb_audio_unrealize(USBDevice *dev, Error **errp)
927{
928 USBAudioState *s = USB_AUDIO(dev);
929
930 if (s->debug) {
931 fprintf(stderr, "usb-audio: destroy\n");
932 }
933
934 usb_audio_set_output_altset(s, ALTSET_OFF);
935 AUD_close_out(&s->card, s->out.voice);
936 AUD_remove_card(&s->card);
937
938 streambuf_fini(&s->out.buf);
939}
940
941static void usb_audio_realize(USBDevice *dev, Error **errp)
942{
943 USBAudioState *s = USB_AUDIO(dev);
944 int i;
945
946 dev->usb_desc = s->multi ? &desc_audio_multi : &desc_audio;
947
948 usb_desc_create_serial(dev);
949 usb_desc_init(dev);
950 s->dev.opaque = s;
951 AUD_register_card(TYPE_USB_AUDIO, &s->card);
952
953 s->out.altset = ALTSET_OFF;
954 s->out.vol.mute = false;
955 for (i = 0; i < USBAUDIO_MAX_CHANNELS(s); ++i) {
956 s->out.vol.vol[i] = 240;
957 }
958
959 usb_audio_reinit(dev, 2);
960}
961
962static void usb_audio_reinit(USBDevice *dev, unsigned channels)
963{
964 USBAudioState *s = USB_AUDIO(dev);
965
966 s->out.channels = channels;
967 if (!s->buffer_user) {
968 s->buffer = 32 * USBAUDIO_PACKET_SIZE(s->out.channels);
969 } else {
970 s->buffer = s->buffer_user;
971 }
972
973 s->out.vol.channels = s->out.channels;
974 s->out.as.freq = USBAUDIO_SAMPLE_RATE;
975 s->out.as.nchannels = s->out.channels;
976 s->out.as.fmt = AUDIO_FORMAT_S16;
977 s->out.as.endianness = 0;
978 streambuf_init(&s->out.buf, s->buffer, s->out.channels);
979
980 s->out.voice = AUD_open_out(&s->card, s->out.voice, TYPE_USB_AUDIO,
981 s, output_callback, &s->out.as);
982 audio_set_volume_out(s->out.voice, &s->out.vol);
983 AUD_set_active_out(s->out.voice, 0);
984}
985
986static const VMStateDescription vmstate_usb_audio = {
987 .name = TYPE_USB_AUDIO,
988 .unmigratable = 1,
989};
990
991static Property usb_audio_properties[] = {
992 DEFINE_AUDIO_PROPERTIES(USBAudioState, card),
993 DEFINE_PROP_UINT32("debug", USBAudioState, debug, 0),
994 DEFINE_PROP_UINT32("buffer", USBAudioState, buffer_user, 0),
995 DEFINE_PROP_BOOL("multi", USBAudioState, multi, false),
996 DEFINE_PROP_END_OF_LIST(),
997};
998
999static void usb_audio_class_init(ObjectClass *klass, void *data)
1000{
1001 DeviceClass *dc = DEVICE_CLASS(klass);
1002 USBDeviceClass *k = USB_DEVICE_CLASS(klass);
1003
1004 dc->vmsd = &vmstate_usb_audio;
1005 dc->props = usb_audio_properties;
1006 set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
1007 k->product_desc = "QEMU USB Audio Interface";
1008 k->realize = usb_audio_realize;
1009 k->handle_reset = usb_audio_handle_reset;
1010 k->handle_control = usb_audio_handle_control;
1011 k->handle_data = usb_audio_handle_data;
1012 k->unrealize = usb_audio_unrealize;
1013 k->set_interface = usb_audio_set_interface;
1014}
1015
1016static const TypeInfo usb_audio_info = {
1017 .name = TYPE_USB_AUDIO,
1018 .parent = TYPE_USB_DEVICE,
1019 .instance_size = sizeof(USBAudioState),
1020 .class_init = usb_audio_class_init,
1021};
1022
1023static void usb_audio_register_types(void)
1024{
1025 type_register_static(&usb_audio_info);
1026 usb_legacy_register(TYPE_USB_AUDIO, "audio", NULL);
1027}
1028
1029type_init(usb_audio_register_types)
1030
