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/usb.h"
35#include "desc.h"
36#include "hw/hw.h"
37#include "audio/audio.h"
38
39#define USBAUDIO_VENDOR_NUM 0x46f4
40#define USBAUDIO_PRODUCT_NUM 0x0002
41
42#define DEV_CONFIG_VALUE 1
43
44
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
50#define DST_AS_GENERAL 1
51#define DST_AS_FORMAT_TYPE 2
52
53#define DST_EP_GENERAL 1
54
55enum usb_audio_strings {
56 STRING_NULL,
57 STRING_MANUFACTURER,
58 STRING_PRODUCT,
59 STRING_SERIALNUMBER,
60 STRING_CONFIG,
61 STRING_USBAUDIO_CONTROL,
62 STRING_INPUT_TERMINAL,
63 STRING_FEATURE_UNIT,
64 STRING_OUTPUT_TERMINAL,
65 STRING_NULL_STREAM,
66 STRING_REAL_STREAM,
67};
68
69static const USBDescStrings usb_audio_stringtable = {
70 [STRING_MANUFACTURER] = "QEMU",
71 [STRING_PRODUCT] = "QEMU USB Audio",
72 [STRING_SERIALNUMBER] = "1",
73 [STRING_CONFIG] = "Audio Configuration",
74 [STRING_USBAUDIO_CONTROL] = "Audio Device",
75 [STRING_INPUT_TERMINAL] = "Audio Output Pipe",
76 [STRING_FEATURE_UNIT] = "Audio Output Volume Control",
77 [STRING_OUTPUT_TERMINAL] = "Audio Output Terminal",
78 [STRING_NULL_STREAM] = "Audio Output - Disabled",
79 [STRING_REAL_STREAM] = "Audio Output - 48 kHz Stereo",
80};
81
82#define U16(x) ((x) & 0xff), (((x) >> 8) & 0xff)
83#define U24(x) U16(x), (((x) >> 16) & 0xff)
84#define U32(x) U24(x), (((x) >> 24) & 0xff)
85
86
87
88
89#define USBAUDIO_PACKET_SIZE 192
90#define USBAUDIO_SAMPLE_RATE 48000
91#define USBAUDIO_PACKET_INTERVAL 1
92
93static const USBDescIface desc_iface[] = {
94 {
95 .bInterfaceNumber = 0,
96 .bNumEndpoints = 0,
97 .bInterfaceClass = USB_CLASS_AUDIO,
98 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL,
99 .bInterfaceProtocol = 0x04,
100 .iInterface = STRING_USBAUDIO_CONTROL,
101 .ndesc = 4,
102 .descs = (USBDescOther[]) {
103 {
104
105 .data = (uint8_t[]) {
106 0x09,
107 USB_DT_CS_INTERFACE,
108 DST_AC_HEADER,
109 U16(0x0100),
110 U16(0x2b),
111 0x01,
112 0x01,
113 }
114 },{
115
116 .data = (uint8_t[]) {
117 0x0c,
118 USB_DT_CS_INTERFACE,
119 DST_AC_INPUT_TERMINAL,
120 0x01,
121 U16(0x0101),
122 0x00,
123 0x02,
124 U16(0x0003),
125 0x00,
126 STRING_INPUT_TERMINAL,
127 }
128 },{
129
130 .data = (uint8_t[]) {
131 0x0d,
132 USB_DT_CS_INTERFACE,
133 DST_AC_FEATURE_UNIT,
134 0x02,
135 0x01,
136 0x02,
137 U16(0x0001),
138 U16(0x0002),
139 U16(0x0002),
140 STRING_FEATURE_UNIT,
141 }
142 },{
143
144 .data = (uint8_t[]) {
145 0x09,
146 USB_DT_CS_INTERFACE,
147 DST_AC_OUTPUT_TERMINAL,
148 0x03,
149 U16(0x0301),
150 0x00,
151 0x02,
152 STRING_OUTPUT_TERMINAL,
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
174 .data = (uint8_t[]) {
175 0x07,
176 USB_DT_CS_INTERFACE,
177 DST_AS_GENERAL,
178 0x01,
179 0x00,
180 0x01, 0x00,
181 }
182 },{
183
184 .data = (uint8_t[]) {
185 0x0b,
186 USB_DT_CS_INTERFACE,
187 DST_AS_FORMAT_TYPE,
188 0x01,
189 0x02,
190 0x02,
191 0x10,
192 0x01,
193 U24(USBAUDIO_SAMPLE_RATE),
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
205
206 .extra = (uint8_t[]) {
207 0x07,
208 USB_DT_CS_ENDPOINT,
209 DST_EP_GENERAL,
210 0x00,
211 0x00,
212 U16(0x0000),
213 },
214 },
215 }
216 }
217};
218
219static const USBDescDevice desc_device = {
220 .bcdUSB = 0x0100,
221 .bMaxPacketSize0 = 64,
222 .bNumConfigurations = 1,
223 .confs = (USBDescConfig[]) {
224 {
225 .bNumInterfaces = 2,
226 .bConfigurationValue = DEV_CONFIG_VALUE,
227 .iConfiguration = STRING_CONFIG,
228 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
229 .bMaxPower = 0x32,
230 .nif = ARRAY_SIZE(desc_iface),
231 .ifs = desc_iface,
232 },
233 },
234};
235
236static const USBDesc desc_audio = {
237 .id = {
238 .idVendor = USBAUDIO_VENDOR_NUM,
239 .idProduct = USBAUDIO_PRODUCT_NUM,
240 .bcdDevice = 0,
241 .iManufacturer = STRING_MANUFACTURER,
242 .iProduct = STRING_PRODUCT,
243 .iSerialNumber = STRING_SERIALNUMBER,
244 },
245 .full = &desc_device,
246 .str = usb_audio_stringtable,
247};
248
249
250
251
252
253
254
255
256
257enum usb_audio_altset {
258 ALTSET_OFF = 0x00,
259 ALTSET_ON = 0x01,
260};
261
262
263
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
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
293
294
295struct streambuf {
296 uint8_t *data;
297 uint32_t size;
298 uint32_t prod;
299 uint32_t cons;
300};
301
302static void streambuf_init(struct streambuf *buf, uint32_t size)
303{
304 g_free(buf->data);
305 buf->size = size - (size % USBAUDIO_PACKET_SIZE);
306 buf->data = g_malloc(buf->size);
307 buf->prod = 0;
308 buf->cons = 0;
309}
310
311static void streambuf_fini(struct streambuf *buf)
312{
313 g_free(buf->data);
314 buf->data = NULL;
315}
316
317static int streambuf_put(struct streambuf *buf, USBPacket *p)
318{
319 uint32_t free = buf->size - (buf->prod - buf->cons);
320
321 if (!free) {
322 return 0;
323 }
324 if (p->iov.size != USBAUDIO_PACKET_SIZE) {
325 return 0;
326 }
327 assert(free >= USBAUDIO_PACKET_SIZE);
328 usb_packet_copy(p, buf->data + (buf->prod % buf->size),
329 USBAUDIO_PACKET_SIZE);
330 buf->prod += USBAUDIO_PACKET_SIZE;
331 return USBAUDIO_PACKET_SIZE;
332}
333
334static uint8_t *streambuf_get(struct streambuf *buf)
335{
336 uint32_t used = buf->prod - buf->cons;
337 uint8_t *data;
338
339 if (!used) {
340 return NULL;
341 }
342 assert(used >= USBAUDIO_PACKET_SIZE);
343 data = buf->data + (buf->cons % buf->size);
344 buf->cons += USBAUDIO_PACKET_SIZE;
345 return data;
346}
347
348typedef struct USBAudioState {
349
350 USBDevice dev;
351 QEMUSoundCard card;
352
353
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
364 uint32_t debug;
365 uint32_t buffer;
366} USBAudioState;
367
368#define TYPE_USB_AUDIO "usb-audio"
369#define USB_AUDIO(obj) OBJECT_CHECK(USBAudioState, (obj), TYPE_USB_AUDIO)
370
371static void output_callback(void *opaque, int avail)
372{
373 USBAudioState *s = opaque;
374 uint8_t *data;
375
376 for (;;) {
377 if (avail < USBAUDIO_PACKET_SIZE) {
378 return;
379 }
380 data = streambuf_get(&s->out.buf);
381 if (!data) {
382 return;
383 }
384 AUD_write(s->out.voice, data, USBAUDIO_PACKET_SIZE);
385 avail -= USBAUDIO_PACKET_SIZE;
386 }
387}
388
389static int usb_audio_set_output_altset(USBAudioState *s, int altset)
390{
391 switch (altset) {
392 case ALTSET_OFF:
393 streambuf_init(&s->out.buf, s->buffer);
394 AUD_set_active_out(s->out.voice, false);
395 break;
396 case ALTSET_ON:
397 AUD_set_active_out(s->out.voice, true);
398 break;
399 default:
400 return -1;
401 }
402
403 if (s->debug) {
404 fprintf(stderr, "usb-audio: set interface %d\n", altset);
405 }
406 s->out.altset = altset;
407 return 0;
408}
409
410
411
412
413#define ATTRIB_ID(cs, attrib, idif) \
414 (((cs) << 24) | ((attrib) << 16) | (idif))
415
416static int usb_audio_get_control(USBAudioState *s, uint8_t attrib,
417 uint16_t cscn, uint16_t idif,
418 int length, uint8_t *data)
419{
420 uint8_t cs = cscn >> 8;
421 uint8_t cn = cscn - 1;
422 uint32_t aid = ATTRIB_ID(cs, attrib, idif);
423 int ret = USB_RET_STALL;
424
425 switch (aid) {
426 case ATTRIB_ID(MUTE_CONTROL, CR_GET_CUR, 0x0200):
427 data[0] = s->out.mute;
428 ret = 1;
429 break;
430 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_CUR, 0x0200):
431 if (cn < 2) {
432 uint16_t vol = (s->out.vol[cn] * 0x8800 + 127) / 255 + 0x8000;
433 data[0] = vol;
434 data[1] = vol >> 8;
435 ret = 2;
436 }
437 break;
438 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MIN, 0x0200):
439 if (cn < 2) {
440 data[0] = 0x01;
441 data[1] = 0x80;
442 ret = 2;
443 }
444 break;
445 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MAX, 0x0200):
446 if (cn < 2) {
447 data[0] = 0x00;
448 data[1] = 0x08;
449 ret = 2;
450 }
451 break;
452 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_RES, 0x0200):
453 if (cn < 2) {
454 data[0] = 0x88;
455 data[1] = 0x00;
456 ret = 2;
457 }
458 break;
459 }
460
461 return ret;
462}
463static int usb_audio_set_control(USBAudioState *s, uint8_t attrib,
464 uint16_t cscn, uint16_t idif,
465 int length, uint8_t *data)
466{
467 uint8_t cs = cscn >> 8;
468 uint8_t cn = cscn - 1;
469 uint32_t aid = ATTRIB_ID(cs, attrib, idif);
470 int ret = USB_RET_STALL;
471 bool set_vol = false;
472
473 switch (aid) {
474 case ATTRIB_ID(MUTE_CONTROL, CR_SET_CUR, 0x0200):
475 s->out.mute = data[0] & 1;
476 set_vol = true;
477 ret = 0;
478 break;
479 case ATTRIB_ID(VOLUME_CONTROL, CR_SET_CUR, 0x0200):
480 if (cn < 2) {
481 uint16_t vol = data[0] + (data[1] << 8);
482
483 if (s->debug) {
484 fprintf(stderr, "usb-audio: vol %04x\n", (uint16_t)vol);
485 }
486
487 vol -= 0x8000;
488 vol = (vol * 255 + 0x4400) / 0x8800;
489 if (vol > 255) {
490 vol = 255;
491 }
492
493 s->out.vol[cn] = vol;
494 set_vol = true;
495 ret = 0;
496 }
497 break;
498 }
499
500 if (set_vol) {
501 if (s->debug) {
502 fprintf(stderr, "usb-audio: mute %d, lvol %3d, rvol %3d\n",
503 s->out.mute, s->out.vol[0], s->out.vol[1]);
504 }
505 AUD_set_volume_out(s->out.voice, s->out.mute,
506 s->out.vol[0], s->out.vol[1]);
507 }
508
509 return ret;
510}
511
512static void usb_audio_handle_control(USBDevice *dev, USBPacket *p,
513 int request, int value, int index,
514 int length, uint8_t *data)
515{
516 USBAudioState *s = USB_AUDIO(dev);
517 int ret = 0;
518
519 if (s->debug) {
520 fprintf(stderr, "usb-audio: control transaction: "
521 "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
522 request, value, index, length);
523 }
524
525 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
526 if (ret >= 0) {
527 return;
528 }
529
530 switch (request) {
531 case ClassInterfaceRequest | CR_GET_CUR:
532 case ClassInterfaceRequest | CR_GET_MIN:
533 case ClassInterfaceRequest | CR_GET_MAX:
534 case ClassInterfaceRequest | CR_GET_RES:
535 ret = usb_audio_get_control(s, request & 0xff, value, index,
536 length, data);
537 if (ret < 0) {
538 if (s->debug) {
539 fprintf(stderr, "usb-audio: fail: get control\n");
540 }
541 goto fail;
542 }
543 p->actual_length = ret;
544 break;
545
546 case ClassInterfaceOutRequest | CR_SET_CUR:
547 case ClassInterfaceOutRequest | CR_SET_MIN:
548 case ClassInterfaceOutRequest | CR_SET_MAX:
549 case ClassInterfaceOutRequest | CR_SET_RES:
550 ret = usb_audio_set_control(s, request & 0xff, value, index,
551 length, data);
552 if (ret < 0) {
553 if (s->debug) {
554 fprintf(stderr, "usb-audio: fail: set control\n");
555 }
556 goto fail;
557 }
558 break;
559
560 default:
561fail:
562 if (s->debug) {
563 fprintf(stderr, "usb-audio: failed control transaction: "
564 "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
565 request, value, index, length);
566 }
567 p->status = USB_RET_STALL;
568 break;
569 }
570}
571
572static void usb_audio_set_interface(USBDevice *dev, int iface,
573 int old, int value)
574{
575 USBAudioState *s = USB_AUDIO(dev);
576
577 if (iface == 1) {
578 usb_audio_set_output_altset(s, value);
579 }
580}
581
582static void usb_audio_handle_reset(USBDevice *dev)
583{
584 USBAudioState *s = USB_AUDIO(dev);
585
586 if (s->debug) {
587 fprintf(stderr, "usb-audio: reset\n");
588 }
589 usb_audio_set_output_altset(s, ALTSET_OFF);
590}
591
592static void usb_audio_handle_dataout(USBAudioState *s, USBPacket *p)
593{
594 if (s->out.altset == ALTSET_OFF) {
595 p->status = USB_RET_STALL;
596 return;
597 }
598
599 streambuf_put(&s->out.buf, p);
600 if (p->actual_length < p->iov.size && s->debug > 1) {
601 fprintf(stderr, "usb-audio: output overrun (%zd bytes)\n",
602 p->iov.size - p->actual_length);
603 }
604}
605
606static void usb_audio_handle_data(USBDevice *dev, USBPacket *p)
607{
608 USBAudioState *s = (USBAudioState *) dev;
609
610 if (p->pid == USB_TOKEN_OUT && p->ep->nr == 1) {
611 usb_audio_handle_dataout(s, p);
612 return;
613 }
614
615 p->status = USB_RET_STALL;
616 if (s->debug) {
617 fprintf(stderr, "usb-audio: failed data transaction: "
618 "pid 0x%x ep 0x%x len 0x%zx\n",
619 p->pid, p->ep->nr, p->iov.size);
620 }
621}
622
623static void usb_audio_unrealize(USBDevice *dev, Error **errp)
624{
625 USBAudioState *s = USB_AUDIO(dev);
626
627 if (s->debug) {
628 fprintf(stderr, "usb-audio: destroy\n");
629 }
630
631 usb_audio_set_output_altset(s, ALTSET_OFF);
632 AUD_close_out(&s->card, s->out.voice);
633 AUD_remove_card(&s->card);
634
635 streambuf_fini(&s->out.buf);
636}
637
638static void usb_audio_realize(USBDevice *dev, Error **errp)
639{
640 USBAudioState *s = USB_AUDIO(dev);
641
642 usb_desc_create_serial(dev);
643 usb_desc_init(dev);
644 s->dev.opaque = s;
645 AUD_register_card(TYPE_USB_AUDIO, &s->card);
646
647 s->out.altset = ALTSET_OFF;
648 s->out.mute = false;
649 s->out.vol[0] = 240;
650 s->out.vol[1] = 240;
651 s->out.as.freq = USBAUDIO_SAMPLE_RATE;
652 s->out.as.nchannels = 2;
653 s->out.as.fmt = AUDIO_FORMAT_S16;
654 s->out.as.endianness = 0;
655 streambuf_init(&s->out.buf, s->buffer);
656
657 s->out.voice = AUD_open_out(&s->card, s->out.voice, TYPE_USB_AUDIO,
658 s, output_callback, &s->out.as);
659 AUD_set_volume_out(s->out.voice, s->out.mute, s->out.vol[0], s->out.vol[1]);
660 AUD_set_active_out(s->out.voice, 0);
661}
662
663static const VMStateDescription vmstate_usb_audio = {
664 .name = TYPE_USB_AUDIO,
665 .unmigratable = 1,
666};
667
668static Property usb_audio_properties[] = {
669 DEFINE_PROP_UINT32("debug", USBAudioState, debug, 0),
670 DEFINE_PROP_UINT32("buffer", USBAudioState, buffer,
671 32 * USBAUDIO_PACKET_SIZE),
672 DEFINE_PROP_END_OF_LIST(),
673};
674
675static void usb_audio_class_init(ObjectClass *klass, void *data)
676{
677 DeviceClass *dc = DEVICE_CLASS(klass);
678 USBDeviceClass *k = USB_DEVICE_CLASS(klass);
679
680 dc->vmsd = &vmstate_usb_audio;
681 dc->props = usb_audio_properties;
682 set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
683 k->product_desc = "QEMU USB Audio Interface";
684 k->usb_desc = &desc_audio;
685 k->realize = usb_audio_realize;
686 k->handle_reset = usb_audio_handle_reset;
687 k->handle_control = usb_audio_handle_control;
688 k->handle_data = usb_audio_handle_data;
689 k->unrealize = usb_audio_unrealize;
690 k->set_interface = usb_audio_set_interface;
691}
692
693static const TypeInfo usb_audio_info = {
694 .name = TYPE_USB_AUDIO,
695 .parent = TYPE_USB_DEVICE,
696 .instance_size = sizeof(USBAudioState),
697 .class_init = usb_audio_class_init,
698};
699
700static void usb_audio_register_types(void)
701{
702 type_register_static(&usb_audio_info);
703 usb_legacy_register(TYPE_USB_AUDIO, "audio", NULL);
704}
705
706type_init(usb_audio_register_types)
707