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