?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usb-audio: support more than two channels of audio
[qemu/ar7.git] / hw / usb / dev-audio.c
blobe42bdfbdc101f368b32d68f63fd64a4f91717441
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/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
40 static void usb_audio_reinit(USBDevice *dev, unsigned channels);
41
42 #define USBAUDIO_VENDOR_NUM 0x46f4 /* CRC16() of "QEMU" */
43 #define USBAUDIO_PRODUCT_NUM 0x0002
44
45 #define DEV_CONFIG_VALUE 1 /* The one and only */
46
47 #define USBAUDIO_MAX_CHANNELS(s) (s->multi ? 8 : 2)
48
49 /* Descriptor subtypes for AC interfaces */
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 /* Descriptor subtypes for AS interfaces */
55 #define DST_AS_GENERAL 1
56 #define DST_AS_FORMAT_TYPE 2
57 /* Descriptor subtypes for endpoints */
58 #define DST_EP_GENERAL 1
59
60 enum 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
74 static 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 * A USB audio device supports an arbitrary number of alternate
89 * interface settings for each interface. Each corresponds to a block
90 * diagram of parameterized blocks. This can thus refer to things like
91 * number of channels, data rates, or in fact completely different
92 * block diagrams. Alternative setting 0 is always the null block diagram,
93 * which is used by a disabled device.
94 */
95 enum usb_audio_altset {
96 ALTSET_OFF = 0x00, /* No endpoint */
97 ALTSET_STEREO = 0x01, /* Single endpoint */
98 ALTSET_51 = 0x02,
99 ALTSET_71 = 0x03,
100 };
101
102 static 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 * A Basic Audio Device uses these specific values
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
120 static 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 /* Headphone Class-Specific AC Interface Header Descriptor */
132 .data = (uint8_t[]) {
133 0x09, /* u8 bLength */
134 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
135 DST_AC_HEADER, /* u8 bDescriptorSubtype */
136 U16(0x0100), /* u16 bcdADC */
137 U16(0x2b), /* u16 wTotalLength */
138 0x01, /* u8 bInCollection */
139 0x01, /* u8 baInterfaceNr */
140 }
141 },{
142 /* Generic Stereo Input Terminal ID1 Descriptor */
143 .data = (uint8_t[]) {
144 0x0c, /* u8 bLength */
145 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
146 DST_AC_INPUT_TERMINAL, /* u8 bDescriptorSubtype */
147 0x01, /* u8 bTerminalID */
148 U16(0x0101), /* u16 wTerminalType */
149 0x00, /* u8 bAssocTerminal */
150 0x02, /* u8 bNrChannels */
151 U16(0x0003), /* u16 wChannelConfig */
152 0x00, /* u8 iChannelNames */
153 STRING_INPUT_TERMINAL, /* u8 iTerminal */
154 }
155 },{
156 /* Generic Stereo Feature Unit ID2 Descriptor */
157 .data = (uint8_t[]) {
158 0x0d, /* u8 bLength */
159 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
160 DST_AC_FEATURE_UNIT, /* u8 bDescriptorSubtype */
161 0x02, /* u8 bUnitID */
162 0x01, /* u8 bSourceID */
163 0x02, /* u8 bControlSize */
164 U16(0x0001), /* u16 bmaControls(0) */
165 U16(0x0002), /* u16 bmaControls(1) */
166 U16(0x0002), /* u16 bmaControls(2) */
167 STRING_FEATURE_UNIT, /* u8 iFeature */
168 }
169 },{
170 /* Headphone Ouptut Terminal ID3 Descriptor */
171 .data = (uint8_t[]) {
172 0x09, /* u8 bLength */
173 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
174 DST_AC_OUTPUT_TERMINAL, /* u8 bDescriptorSubtype */
175 0x03, /* u8 bUnitID */
176 U16(0x0301), /* u16 wTerminalType (SPK) */
177 0x00, /* u8 bAssocTerminal */
178 0x02, /* u8 bSourceID */
179 STRING_OUTPUT_TERMINAL, /* u8 iTerminal */
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 /* Headphone Class-specific AS General Interface Descriptor */
201 .data = (uint8_t[]) {
202 0x07, /* u8 bLength */
203 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
204 DST_AS_GENERAL, /* u8 bDescriptorSubtype */
205 0x01, /* u8 bTerminalLink */
206 0x00, /* u8 bDelay */
207 0x01, 0x00, /* u16 wFormatTag */
208 }
209 },{
210 /* Headphone Type I Format Type Descriptor */
211 .data = (uint8_t[]) {
212 0x0b, /* u8 bLength */
213 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
214 DST_AS_FORMAT_TYPE, /* u8 bDescriptorSubtype */
215 0x01, /* u8 bFormatType */
216 0x02, /* u8 bNrChannels */
217 0x02, /* u8 bSubFrameSize */
218 0x10, /* u8 bBitResolution */
219 0x01, /* u8 bSamFreqType */
220 U24(USBAUDIO_SAMPLE_RATE), /* u24 tSamFreq */
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 /* Stereo Headphone Class-specific
232 AS Audio Data Endpoint Descriptor */
233 .extra = (uint8_t[]) {
234 0x07, /* u8 bLength */
235 USB_DT_CS_ENDPOINT, /* u8 bDescriptorType */
236 DST_EP_GENERAL, /* u8 bDescriptorSubtype */
237 0x00, /* u8 bmAttributes */
238 0x00, /* u8 bLockDelayUnits */
239 U16(0x0000), /* u16 wLockDelay */
240 },
241 },
242 }
243 }
244 };
245
246 static 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
263 static 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 /* multi channel compatible desc */
277
278 static 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 /* Headphone Class-Specific AC Interface Header Descriptor */
290 .data = (uint8_t[]) {
291 0x09, /* u8 bLength */
292 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
293 DST_AC_HEADER, /* u8 bDescriptorSubtype */
294 U16(0x0100), /* u16 bcdADC */
295 U16(0x38), /* u16 wTotalLength */
296 0x01, /* u8 bInCollection */
297 0x01, /* u8 baInterfaceNr */
298 }
299 },{
300 /* Generic Stereo Input Terminal ID1 Descriptor */
301 .data = (uint8_t[]) {
302 0x0c, /* u8 bLength */
303 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
304 DST_AC_INPUT_TERMINAL, /* u8 bDescriptorSubtype */
305 0x01, /* u8 bTerminalID */
306 U16(0x0101), /* u16 wTerminalType */
307 0x00, /* u8 bAssocTerminal */
308 0x08, /* u8 bNrChannels */
309 U16(0x063f), /* u16 wChannelConfig */
310 0x00, /* u8 iChannelNames */
311 STRING_INPUT_TERMINAL, /* u8 iTerminal */
312 }
313 },{
314 /* Generic Stereo Feature Unit ID2 Descriptor */
315 .data = (uint8_t[]) {
316 0x19, /* u8 bLength */
317 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
318 DST_AC_FEATURE_UNIT, /* u8 bDescriptorSubtype */
319 0x02, /* u8 bUnitID */
320 0x01, /* u8 bSourceID */
321 0x02, /* u8 bControlSize */
322 U16(0x0001), /* u16 bmaControls(0) */
323 U16(0x0002), /* u16 bmaControls(1) */
324 U16(0x0002), /* u16 bmaControls(2) */
325 U16(0x0002), /* u16 bmaControls(3) */
326 U16(0x0002), /* u16 bmaControls(4) */
327 U16(0x0002), /* u16 bmaControls(5) */
328 U16(0x0002), /* u16 bmaControls(6) */
329 U16(0x0002), /* u16 bmaControls(7) */
330 U16(0x0002), /* u16 bmaControls(8) */
331 STRING_FEATURE_UNIT, /* u8 iFeature */
332 }
333 },{
334 /* Headphone Ouptut Terminal ID3 Descriptor */
335 .data = (uint8_t[]) {
336 0x09, /* u8 bLength */
337 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
338 DST_AC_OUTPUT_TERMINAL, /* u8 bDescriptorSubtype */
339 0x03, /* u8 bUnitID */
340 U16(0x0301), /* u16 wTerminalType (SPK) */
341 0x00, /* u8 bAssocTerminal */
342 0x02, /* u8 bSourceID */
343 STRING_OUTPUT_TERMINAL, /* u8 iTerminal */
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 /* Headphone Class-specific AS General Interface Descriptor */
365 .data = (uint8_t[]) {
366 0x07, /* u8 bLength */
367 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
368 DST_AS_GENERAL, /* u8 bDescriptorSubtype */
369 0x01, /* u8 bTerminalLink */
370 0x00, /* u8 bDelay */
371 0x01, 0x00, /* u16 wFormatTag */
372 }
373 },{
374 /* Headphone Type I Format Type Descriptor */
375 .data = (uint8_t[]) {
376 0x0b, /* u8 bLength */
377 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
378 DST_AS_FORMAT_TYPE, /* u8 bDescriptorSubtype */
379 0x01, /* u8 bFormatType */
380 0x02, /* u8 bNrChannels */
381 0x02, /* u8 bSubFrameSize */
382 0x10, /* u8 bBitResolution */
383 0x01, /* u8 bSamFreqType */
384 U24(USBAUDIO_SAMPLE_RATE), /* u24 tSamFreq */
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 /* Stereo Headphone Class-specific
396 AS Audio Data Endpoint Descriptor */
397 .extra = (uint8_t[]) {
398 0x07, /* u8 bLength */
399 USB_DT_CS_ENDPOINT, /* u8 bDescriptorType */
400 DST_EP_GENERAL, /* u8 bDescriptorSubtype */
401 0x00, /* u8 bmAttributes */
402 0x00, /* u8 bLockDelayUnits */
403 U16(0x0000), /* u16 wLockDelay */
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 /* Headphone Class-specific AS General Interface Descriptor */
418 .data = (uint8_t[]) {
419 0x07, /* u8 bLength */
420 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
421 DST_AS_GENERAL, /* u8 bDescriptorSubtype */
422 0x01, /* u8 bTerminalLink */
423 0x00, /* u8 bDelay */
424 0x01, 0x00, /* u16 wFormatTag */
425 }
426 },{
427 /* Headphone Type I Format Type Descriptor */
428 .data = (uint8_t[]) {
429 0x0b, /* u8 bLength */
430 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
431 DST_AS_FORMAT_TYPE, /* u8 bDescriptorSubtype */
432 0x01, /* u8 bFormatType */
433 0x06, /* u8 bNrChannels */
434 0x02, /* u8 bSubFrameSize */
435 0x10, /* u8 bBitResolution */
436 0x01, /* u8 bSamFreqType */
437 U24(USBAUDIO_SAMPLE_RATE), /* u24 tSamFreq */
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 /* Stereo Headphone Class-specific
449 AS Audio Data Endpoint Descriptor */
450 .extra = (uint8_t[]) {
451 0x07, /* u8 bLength */
452 USB_DT_CS_ENDPOINT, /* u8 bDescriptorType */
453 DST_EP_GENERAL, /* u8 bDescriptorSubtype */
454 0x00, /* u8 bmAttributes */
455 0x00, /* u8 bLockDelayUnits */
456 U16(0x0000), /* u16 wLockDelay */
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 /* Headphone Class-specific AS General Interface Descriptor */
471 .data = (uint8_t[]) {
472 0x07, /* u8 bLength */
473 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
474 DST_AS_GENERAL, /* u8 bDescriptorSubtype */
475 0x01, /* u8 bTerminalLink */
476 0x00, /* u8 bDelay */
477 0x01, 0x00, /* u16 wFormatTag */
478 }
479 },{
480 /* Headphone Type I Format Type Descriptor */
481 .data = (uint8_t[]) {
482 0x0b, /* u8 bLength */
483 USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
484 DST_AS_FORMAT_TYPE, /* u8 bDescriptorSubtype */
485 0x01, /* u8 bFormatType */
486 0x08, /* u8 bNrChannels */
487 0x02, /* u8 bSubFrameSize */
488 0x10, /* u8 bBitResolution */
489 0x01, /* u8 bSamFreqType */
490 U24(USBAUDIO_SAMPLE_RATE), /* u24 tSamFreq */
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 /* Stereo Headphone Class-specific
502 AS Audio Data Endpoint Descriptor */
503 .extra = (uint8_t[]) {
504 0x07, /* u8 bLength */
505 USB_DT_CS_ENDPOINT, /* u8 bDescriptorType */
506 DST_EP_GENERAL, /* u8 bDescriptorSubtype */
507 0x00, /* u8 bmAttributes */
508 0x00, /* u8 bLockDelayUnits */
509 U16(0x0000), /* u16 wLockDelay */
510 },
511 },
512 }
513 }
514 };
515
516 static 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
533 static 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 * Class-specific control requests
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 * Feature Unit Control Selectors
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 * buffering
577 */
578
579 struct streambuf {
580 uint8_t *data;
581 uint32_t size;
582 uint32_t prod;
583 uint32_t cons;
584 };
585
586 static 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
596 static void streambuf_fini(struct streambuf *buf)
597 {
598 g_free(buf->data);
599 buf->data = NULL;
600 }
601
602 static int streambuf_put(struct streambuf *buf, USBPacket *p, uint32_t channels)
603 {
604 uint32_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 usb_packet_copy(p, buf->data + (buf->prod % buf->size),
614 USBAUDIO_PACKET_SIZE(channels));
615 buf->prod += USBAUDIO_PACKET_SIZE(channels);
616 return USBAUDIO_PACKET_SIZE(channels);
617 }
618
619 static uint8_t *streambuf_get(struct streambuf *buf, size_t *len)
620 {
621 uint32_t used = buf->prod - buf->cons;
622 uint8_t *data;
623
624 if (!used) {
625 *len = 0;
626 return NULL;
627 }
628 data = buf->data + (buf->cons % buf->size);
629 *len = MIN(buf->prod - buf->cons,
630 buf->size - (buf->cons % buf->size));
631 return data;
632 }
633
634 typedef struct USBAudioState {
635 /* qemu interfaces */
636 USBDevice dev;
637 QEMUSoundCard card;
638
639 /* state */
640 struct {
641 enum usb_audio_altset altset;
642 struct audsettings as;
643 SWVoiceOut *voice;
644 Volume vol;
645 struct streambuf buf;
646 uint32_t channels;
647 } out;
648
649 /* properties */
650 uint32_t debug;
651 uint32_t buffer_user, buffer;
652 bool multi;
653 } USBAudioState;
654
655 #define TYPE_USB_AUDIO "usb-audio"
656 #define USB_AUDIO(obj) OBJECT_CHECK(USBAudioState, (obj), TYPE_USB_AUDIO)
657
658 static void output_callback(void *opaque, int avail)
659 {
660 USBAudioState *s = opaque;
661 uint8_t *data;
662
663 while (avail) {
664 size_t written, len;
665
666 data = streambuf_get(&s->out.buf, &len);
667 if (!data) {
668 return;
669 }
670
671 written = AUD_write(s->out.voice, data, len);
672 avail -= written;
673 s->out.buf.cons += written;
674
675 if (written < len) {
676 return;
677 }
678 }
679 }
680
681 static int usb_audio_set_output_altset(USBAudioState *s, int altset)
682 {
683 switch (altset) {
684 case ALTSET_OFF:
685 AUD_set_active_out(s->out.voice, false);
686 break;
687 case ALTSET_STEREO:
688 case ALTSET_51:
689 case ALTSET_71:
690 if (s->out.channels != altset_channels[altset]) {
691 usb_audio_reinit(USB_DEVICE(s), altset_channels[altset]);
692 }
693 streambuf_init(&s->out.buf, s->buffer, s->out.channels);
694 AUD_set_active_out(s->out.voice, true);
695 break;
696 default:
697 return -1;
698 }
699
700 if (s->debug) {
701 fprintf(stderr, "usb-audio: set interface %d\n", altset);
702 }
703 s->out.altset = altset;
704 return 0;
705 }
706
707 /*
708 * Note: we arbitrarily map the volume control range onto -inf..+8 dB
709 */
710 #define ATTRIB_ID(cs, attrib, idif) \
711 (((cs) << 24) | ((attrib) << 16) | (idif))
712
713 static int usb_audio_get_control(USBAudioState *s, uint8_t attrib,
714 uint16_t cscn, uint16_t idif,
715 int length, uint8_t *data)
716 {
717 uint8_t cs = cscn >> 8;
718 uint8_t cn = cscn - 1; /* -1 for the non-present master control */
719 uint32_t aid = ATTRIB_ID(cs, attrib, idif);
720 int ret = USB_RET_STALL;
721
722 switch (aid) {
723 case ATTRIB_ID(MUTE_CONTROL, CR_GET_CUR, 0x0200):
724 data[0] = s->out.vol.mute;
725 ret = 1;
726 break;
727 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_CUR, 0x0200):
728 if (cn < USBAUDIO_MAX_CHANNELS(s)) {
729 uint16_t vol = (s->out.vol.vol[cn] * 0x8800 + 127) / 255 + 0x8000;
730 data[0] = vol;
731 data[1] = vol >> 8;
732 ret = 2;
733 }
734 break;
735 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MIN, 0x0200):
736 if (cn < USBAUDIO_MAX_CHANNELS(s)) {
737 data[0] = 0x01;
738 data[1] = 0x80;
739 ret = 2;
740 }
741 break;
742 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_MAX, 0x0200):
743 if (cn < USBAUDIO_MAX_CHANNELS(s)) {
744 data[0] = 0x00;
745 data[1] = 0x08;
746 ret = 2;
747 }
748 break;
749 case ATTRIB_ID(VOLUME_CONTROL, CR_GET_RES, 0x0200):
750 if (cn < USBAUDIO_MAX_CHANNELS(s)) {
751 data[0] = 0x88;
752 data[1] = 0x00;
753 ret = 2;
754 }
755 break;
756 }
757
758 return ret;
759 }
760 static int usb_audio_set_control(USBAudioState *s, uint8_t attrib,
761 uint16_t cscn, uint16_t idif,
762 int length, uint8_t *data)
763 {
764 uint8_t cs = cscn >> 8;
765 uint8_t cn = cscn - 1; /* -1 for the non-present master control */
766 uint32_t aid = ATTRIB_ID(cs, attrib, idif);
767 int ret = USB_RET_STALL;
768 bool set_vol = false;
769
770 switch (aid) {
771 case ATTRIB_ID(MUTE_CONTROL, CR_SET_CUR, 0x0200):
772 s->out.vol.mute = data[0] & 1;
773 set_vol = true;
774 ret = 0;
775 break;
776 case ATTRIB_ID(VOLUME_CONTROL, CR_SET_CUR, 0x0200):
777 if (cn < USBAUDIO_MAX_CHANNELS(s)) {
778 uint16_t vol = data[0] + (data[1] << 8);
779
780 if (s->debug) {
781 fprintf(stderr, "usb-audio: cn %d vol %04x\n", cn,
782 (uint16_t)vol);
783 }
784
785 vol -= 0x8000;
786 vol = (vol * 255 + 0x4400) / 0x8800;
787 if (vol > 255) {
788 vol = 255;
789 }
790
791 s->out.vol.vol[cn] = vol;
792 set_vol = true;
793 ret = 0;
794 }
795 break;
796 }
797
798 if (set_vol) {
799 if (s->debug) {
800 int i;
801 fprintf(stderr, "usb-audio: mute %d", s->out.vol.mute);
802 for (i = 0; i < USBAUDIO_MAX_CHANNELS(s); ++i) {
803 fprintf(stderr, ", vol[%d] %3d", i, s->out.vol.vol[i]);
804 }
805 fprintf(stderr, "\n");
806 }
807 audio_set_volume_out(s->out.voice, &s->out.vol);
808 }
809
810 return ret;
811 }
812
813 static void usb_audio_handle_control(USBDevice *dev, USBPacket *p,
814 int request, int value, int index,
815 int length, uint8_t *data)
816 {
817 USBAudioState *s = USB_AUDIO(dev);
818 int ret = 0;
819
820 if (s->debug) {
821 fprintf(stderr, "usb-audio: control transaction: "
822 "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
823 request, value, index, length);
824 }
825
826 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
827 if (ret >= 0) {
828 return;
829 }
830
831 switch (request) {
832 case ClassInterfaceRequest | CR_GET_CUR:
833 case ClassInterfaceRequest | CR_GET_MIN:
834 case ClassInterfaceRequest | CR_GET_MAX:
835 case ClassInterfaceRequest | CR_GET_RES:
836 ret = usb_audio_get_control(s, request & 0xff, value, index,
837 length, data);
838 if (ret < 0) {
839 if (s->debug) {
840 fprintf(stderr, "usb-audio: fail: get control\n");
841 }
842 goto fail;
843 }
844 p->actual_length = ret;
845 break;
846
847 case ClassInterfaceOutRequest | CR_SET_CUR:
848 case ClassInterfaceOutRequest | CR_SET_MIN:
849 case ClassInterfaceOutRequest | CR_SET_MAX:
850 case ClassInterfaceOutRequest | CR_SET_RES:
851 ret = usb_audio_set_control(s, request & 0xff, value, index,
852 length, data);
853 if (ret < 0) {
854 if (s->debug) {
855 fprintf(stderr, "usb-audio: fail: set control\n");
856 }
857 goto fail;
858 }
859 break;
860
861 default:
862 fail:
863 if (s->debug) {
864 fprintf(stderr, "usb-audio: failed control transaction: "
865 "request 0x%04x value 0x%04x index 0x%04x length 0x%04x\n",
866 request, value, index, length);
867 }
868 p->status = USB_RET_STALL;
869 break;
870 }
871 }
872
873 static void usb_audio_set_interface(USBDevice *dev, int iface,
874 int old, int value)
875 {
876 USBAudioState *s = USB_AUDIO(dev);
877
878 if (iface == 1) {
879 usb_audio_set_output_altset(s, value);
880 }
881 }
882
883 static void usb_audio_handle_reset(USBDevice *dev)
884 {
885 USBAudioState *s = USB_AUDIO(dev);
886
887 if (s->debug) {
888 fprintf(stderr, "usb-audio: reset\n");
889 }
890 usb_audio_set_output_altset(s, ALTSET_OFF);
891 }
892
893 static void usb_audio_handle_dataout(USBAudioState *s, USBPacket *p)
894 {
895 if (s->out.altset == ALTSET_OFF) {
896 p->status = USB_RET_STALL;
897 return;
898 }
899
900 streambuf_put(&s->out.buf, p, s->out.channels);
901 if (p->actual_length < p->iov.size && s->debug > 1) {
902 fprintf(stderr, "usb-audio: output overrun (%zd bytes)\n",
903 p->iov.size - p->actual_length);
904 }
905 }
906
907 static void usb_audio_handle_data(USBDevice *dev, USBPacket *p)
908 {
909 USBAudioState *s = (USBAudioState *) dev;
910
911 if (p->pid == USB_TOKEN_OUT && p->ep->nr == 1) {
912 usb_audio_handle_dataout(s, p);
913 return;
914 }
915
916 p->status = USB_RET_STALL;
917 if (s->debug) {
918 fprintf(stderr, "usb-audio: failed data transaction: "
919 "pid 0x%x ep 0x%x len 0x%zx\n",
920 p->pid, p->ep->nr, p->iov.size);
921 }
922 }
923
924 static void usb_audio_unrealize(USBDevice *dev, Error **errp)
925 {
926 USBAudioState *s = USB_AUDIO(dev);
927
928 if (s->debug) {
929 fprintf(stderr, "usb-audio: destroy\n");
930 }
931
932 usb_audio_set_output_altset(s, ALTSET_OFF);
933 AUD_close_out(&s->card, s->out.voice);
934 AUD_remove_card(&s->card);
935
936 streambuf_fini(&s->out.buf);
937 }
938
939 static void usb_audio_realize(USBDevice *dev, Error **errp)
940 {
941 USBAudioState *s = USB_AUDIO(dev);
942 int i;
943
944 dev->usb_desc = s->multi ? &desc_audio_multi : &desc_audio;
945
946 usb_desc_create_serial(dev);
947 usb_desc_init(dev);
948 s->dev.opaque = s;
949 AUD_register_card(TYPE_USB_AUDIO, &s->card);
950
951 s->out.altset = ALTSET_OFF;
952 s->out.vol.mute = false;
953 for (i = 0; i < USBAUDIO_MAX_CHANNELS(s); ++i) {
954 s->out.vol.vol[i] = 240; /* 0 dB */
955 }
956
957 usb_audio_reinit(dev, 2);
958 }
959
960 static void usb_audio_reinit(USBDevice *dev, unsigned channels)
961 {
962 USBAudioState *s = USB_AUDIO(dev);
963
964 s->out.channels = channels;
965 if (!s->buffer_user) {
966 s->buffer = 32 * USBAUDIO_PACKET_SIZE(s->out.channels);
967 } else {
968 s->buffer = s->buffer_user;
969 }
970
971 s->out.vol.channels = s->out.channels;
972 s->out.as.freq = USBAUDIO_SAMPLE_RATE;
973 s->out.as.nchannels = s->out.channels;
974 s->out.as.fmt = AUDIO_FORMAT_S16;
975 s->out.as.endianness = 0;
976 streambuf_init(&s->out.buf, s->buffer, s->out.channels);
977
978 s->out.voice = AUD_open_out(&s->card, s->out.voice, TYPE_USB_AUDIO,
979 s, output_callback, &s->out.as);
980 audio_set_volume_out(s->out.voice, &s->out.vol);
981 AUD_set_active_out(s->out.voice, 0);
982 }
983
984 static const VMStateDescription vmstate_usb_audio = {
985 .name = TYPE_USB_AUDIO,
986 .unmigratable = 1,
987 };
988
989 static Property usb_audio_properties[] = {
990 DEFINE_AUDIO_PROPERTIES(USBAudioState, card),
991 DEFINE_PROP_UINT32("debug", USBAudioState, debug, 0),
992 DEFINE_PROP_UINT32("buffer", USBAudioState, buffer_user, 0),
993 DEFINE_PROP_BOOL("multi", USBAudioState, multi, false),
994 DEFINE_PROP_END_OF_LIST(),
995 };
996
997 static void usb_audio_class_init(ObjectClass *klass, void *data)
998 {
999 DeviceClass *dc = DEVICE_CLASS(klass);
1000 USBDeviceClass *k = USB_DEVICE_CLASS(klass);
1001
1002 dc->vmsd = &vmstate_usb_audio;
1003 dc->props = usb_audio_properties;
1004 set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
1005 k->product_desc = "QEMU USB Audio Interface";
1006 k->realize = usb_audio_realize;
1007 k->handle_reset = usb_audio_handle_reset;
1008 k->handle_control = usb_audio_handle_control;
1009 k->handle_data = usb_audio_handle_data;
1010 k->unrealize = usb_audio_unrealize;
1011 k->set_interface = usb_audio_set_interface;
1012 }
1013
1014 static const TypeInfo usb_audio_info = {
1015 .name = TYPE_USB_AUDIO,
1016 .parent = TYPE_USB_DEVICE,
1017 .instance_size = sizeof(USBAudioState),
1018 .class_init = usb_audio_class_init,
1019 };
1020
1021 static void usb_audio_register_types(void)
1022 {
1023 type_register_static(&usb_audio_info);
1024 usb_legacy_register(TYPE_USB_AUDIO, "audio", NULL);
1025 }
1026
1027 type_init(usb_audio_register_types)
AR7 emulation for QEMU