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