1 /*****************************************************************************/
4 * audio.c -- USB Audio Class driver
6 * Copyright (C) 1999, 2000, 2001, 2003, 2004
7 * Alan Cox (alan@lxorguk.ukuu.org.uk)
8 * Thomas Sailer (sailer@ife.ee.ethz.ch)
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
16 * Use the 'lsusb' utility to dump the descriptors.
18 * 1999-09-07: Alan Cox
19 * Parsing Audio descriptor patch
20 * 1999-09-08: Thomas Sailer
21 * Added OSS compatible data io functions; both parts of the
22 * driver remain to be glued together
23 * 1999-09-10: Thomas Sailer
24 * Beautified the driver. Added sample format conversions.
25 * Still not properly glued with the parsing code.
26 * The parsing code seems to have its problems btw,
27 * Since it parses all available configs but doesn't
28 * store which iface/altsetting belongs to which config.
29 * 1999-09-20: Thomas Sailer
30 * Threw out Alan's parsing code and implemented my own one.
31 * You cannot reasonnably linearly parse audio descriptors,
32 * especially the AudioClass descriptors have to be considered
33 * pointer lists. Mixer parsing untested, due to lack of device.
34 * First stab at synch pipe implementation, the Dallas USB DAC
35 * wants to use an Asynch out pipe. usb_audio_state now basically
36 * only contains lists of mixer and wave devices. We can therefore
37 * now have multiple mixer/wave devices per USB device.
38 * 1999-10-28: Thomas Sailer
39 * Converted to URB API. Fixed a taskstate/wakeup semantics mistake
40 * that made the driver consume all available CPU cycles.
41 * Now runs stable on UHCI-Acher/Fliegl/Sailer.
42 * 1999-10-31: Thomas Sailer
43 * Audio can now be unloaded if it is not in use by any mixer
44 * or dsp client (formerly you had to disconnect the audio devices
46 * Finally, about three months after ordering, my "Maxxtro SPK222"
47 * speakers arrived, isn't disdata a great mail order company 8-)
48 * Parse class specific endpoint descriptor of the audiostreaming
49 * interfaces and take the endpoint attributes from there.
50 * Unbelievably, the Philips USB DAC has a sampling rate range
51 * of over a decade, yet does not support the sampling rate control!
52 * No wonder it sounds so bad, has very audible sampling rate
53 * conversion distortion. Don't try to listen to it using
55 * "Let's make things better" -> but please Philips start with your
57 * 1999-11-02: Thomas Sailer
58 * It takes the Philips boxes several seconds to acquire synchronisation
59 * that means they won't play short sounds. Should probably maintain
60 * the ISO datastream even if there's nothing to play.
61 * Fix counting the total_bytes counter, RealPlayer G2 depends on it.
62 * 1999-12-20: Thomas Sailer
63 * Fix bad bug in conversion to per interface probing.
64 * disconnect was called multiple times for the audio device,
65 * leading to a premature freeing of the audio structures
66 * 2000-05-13: Thomas Sailer
67 * I don't remember who changed the find_format routine,
68 * but the change was completely broken for the Dallas
69 * chip. Anyway taking sampling rate into account in find_format
70 * is bad and should not be done unless there are devices with
71 * completely broken audio descriptors. Unless someone shows
72 * me such a descriptor, I will not allow find_format to
73 * take the sampling rate into account.
74 * Also, the former find_format made:
75 * - mpg123 play mono instead of stereo
76 * - sox completely fail for wav's with sample rates < 44.1kHz
77 * for the Dallas chip.
78 * Also fix a rather long standing problem with applications that
79 * use "small" writes producing no sound at all.
80 * 2000-05-15: Thomas Sailer
81 * My fears came true, the Philips camera indeed has pretty stupid
83 * 2000-05-17: Thomas Sailer
84 * Nemsoft spotted my stupid last minute change, thanks
85 * 2000-05-19: Thomas Sailer
86 * Fixed FEATURE_UNIT thinkos found thanks to the KC Technology
87 * Xtend device. Basically the driver treated FEATURE_UNIT's sourced
88 * by mono terminals as stereo.
89 * 2000-05-20: Thomas Sailer
90 * SELECTOR support (and thus selecting record channels from the mixer).
91 * Somewhat peculiar due to OSS interface limitations. Only works
92 * for channels where a "slider" is already in front of it (i.e.
93 * a MIXER unit or a FEATURE unit with volume capability).
94 * 2000-11-26: Thomas Sailer
95 * Workaround for Dallas DS4201. The DS4201 uses PCM8 as format tag for
96 * its 8 bit modes, but expects signed data (and should therefore have used PCM).
97 * 2001-03-10: Thomas Sailer
98 * provide abs function, prevent picking up a bogus kernel macro
99 * for abs. Bug report by Andrew Morton <andrewm@uow.edu.au>
100 * 2001-06-16: Bryce Nesbitt <bryce@obviously.com>
101 * Fix SNDCTL_DSP_STEREO API violation
102 * 2003-04-08: Oliver Neukum (oliver@neukum.name):
103 * Setting a configuration is done by usbcore and must not be overridden
104 * 2004-02-27: Workaround for broken synch descriptors
105 * 2004-03-07: Alan Stern <stern@rowland.harvard.edu>
106 * Add usb_ifnum_to_if() and usb_altnum_to_altsetting() support.
107 * Use the in-memory descriptors instead of reading them from the device.
114 * Alan Cox and Thomas Sailer are starting to dig at opposite ends and
115 * are hoping to meet in the middle, just like tunnel diggers :)
116 * Alan tackles the descriptor parsing, Thomas the actual data IO and the
117 * OSS compatible interface.
119 * Data IO implementation issues
121 * A mmap'able ring buffer per direction is implemented, because
122 * almost every OSS app expects it. It is however impractical to
123 * transmit/receive USB data directly into and out of the ring buffer,
124 * due to alignment and synchronisation issues. Instead, the ring buffer
125 * feeds a constant time delay line that handles the USB issues.
127 * Now we first try to find an alternate setting that exactly matches
128 * the sample format requested by the user. If we find one, we do not
129 * need to perform any sample rate conversions. If there is no matching
130 * altsetting, we choose the closest one and perform sample format
131 * conversions. We never do sample rate conversion; these are too
132 * expensive to be performed in the kernel.
134 * Current status: no known HCD-specific issues.
136 * Generally: Due to the brokenness of the Audio Class spec
137 * it seems generally impossible to write a generic Audio Class driver,
138 * so a reasonable driver should implement the features that are actually
141 * Parsing implementation issues
143 * One cannot reasonably parse the AudioClass descriptors linearly.
144 * Therefore the current implementation features routines to look
145 * for a specific descriptor in the descriptor list.
147 * How does the parsing work? First, all interfaces are searched
148 * for an AudioControl class interface. If found, the config descriptor
149 * that belongs to the current configuration is searched and
150 * the HEADER descriptor is found. It contains a list of
151 * all AudioStreaming and MIDIStreaming devices. This list is then walked,
152 * and all AudioStreaming interfaces are classified into input and output
153 * interfaces (according to the endpoint0 direction in altsetting1) (MIDIStreaming
154 * is currently not supported). The input & output list is then used
155 * to group inputs and outputs together and issued pairwise to the
156 * AudioStreaming class parser. Finally, all OUTPUT_TERMINAL descriptors
157 * are walked and issued to the mixer construction routine.
159 * The AudioStreaming parser simply enumerates all altsettings belonging
160 * to the specified interface. It looks for AS_GENERAL and FORMAT_TYPE
161 * class specific descriptors to extract the sample format/sample rate
162 * data. Only sample format types PCM and PCM8 are supported right now, and
163 * only FORMAT_TYPE_I is handled. The isochronous data endpoint needs to
164 * be the first endpoint of the interface, and the optional synchronisation
165 * isochronous endpoint the second one.
167 * Mixer construction works as follows: The various TERMINAL and UNIT
168 * descriptors span a tree from the root (OUTPUT_TERMINAL) through the
169 * intermediate nodes (UNITs) to the leaves (INPUT_TERMINAL). We walk
170 * that tree in a depth first manner. FEATURE_UNITs may contribute volume,
171 * bass and treble sliders to the mixer, MIXER_UNITs volume sliders.
172 * The terminal type encoded in the INPUT_TERMINALs feeds a heuristic
173 * to determine "meaningful" OSS slider numbers, however we will see
174 * how well this works in practice. Other features are not used at the
175 * moment, they seem less often used. Also, it seems difficult at least
176 * to construct recording source switches from SELECTOR_UNITs, but
177 * since there are not many USB ADC's available, we leave that for later.
180 /*****************************************************************************/
182 #include <linux/kernel.h>
183 #include <linux/slab.h>
184 #include <linux/string.h>
185 #include <linux/timer.h>
186 #include <linux/sched.h>
187 #include <linux/smp_lock.h>
188 #include <linux/module.h>
189 #include <linux/sound.h>
190 #include <linux/soundcard.h>
191 #include <linux/list.h>
192 #include <linux/vmalloc.h>
193 #include <linux/init.h>
194 #include <linux/poll.h>
195 #include <linux/bitops.h>
196 #include <asm/uaccess.h>
198 #include <linux/usb.h>
203 * Version Information
205 #define DRIVER_VERSION "v1.0.0"
206 #define DRIVER_AUTHOR "Alan Cox <alan@lxorguk.ukuu.org.uk>, Thomas Sailer (sailer@ife.ee.ethz.ch)"
207 #define DRIVER_DESC "USB Audio Class driver"
209 #define AUDIO_DEBUG 1
211 #define SND_DEV_DSP16 5
216 extern int abs(int __x) __attribute_const__; /* Shut up warning */
218 /* --------------------------------------------------------------------- */
221 * Linked list of all audio devices...
223 static struct list_head audiodevs = LIST_HEAD_INIT(audiodevs);
224 static DECLARE_MUTEX(open_sem);
227 * wait queue for processes wanting to open an USB audio device
229 static DECLARE_WAIT_QUEUE_HEAD(open_wait);
232 #define MAXFORMATS MAX_ALT
233 #define DMABUFSHIFT 17 /* 128k worth of DMA buffer */
234 #define NRSGBUF (1U<<(DMABUFSHIFT-PAGE_SHIFT))
240 * - Synchronisation behaviour
241 * Don't touch this if you don't understand all of the above.
244 #define SYNCFRAMES DESCFRAMES
246 #define MIXFLG_STEREOIN 1
247 #define MIXFLG_STEREOOUT 2
249 struct mixerchannel {
251 __u16 osschannel; /* number of the OSS channel */
252 __s16 minval, maxval;
262 unsigned int sratelo;
263 unsigned int sratehi;
264 unsigned char altsetting;
265 unsigned char attributes;
269 /* buffer data format */
272 /* physical buffer */
273 unsigned char *sgbuf[NRSGBUF];
277 unsigned wrptr, rdptr;
278 unsigned total_bytes;
280 unsigned error; /* over/underrun */
281 wait_queue_head_t wait;
282 /* redundant, but makes calculations easier */
288 unsigned ossfragshift;
290 unsigned subdivision;
293 struct usb_audio_state;
295 #define FLG_URB0RUNNING 1
296 #define FLG_URB1RUNNING 2
297 #define FLG_SYNC0RUNNING 4
298 #define FLG_SYNC1RUNNING 8
299 #define FLG_RUNNING 16
300 #define FLG_CONNECTED 32
311 struct usb_audiodev {
312 struct list_head list;
313 struct usb_audio_state *state;
315 /* soundcore stuff */
320 spinlock_t lock; /* DMA buffer access spinlock */
323 int interface; /* Interface number, -1 means not used */
324 unsigned int format; /* USB data format */
325 unsigned int datapipe; /* the data input pipe */
326 unsigned int syncpipe; /* the synchronisation pipe - 0 for anything but adaptive IN mode */
327 unsigned int syncinterval; /* P for adaptive IN mode, 0 otherwise */
328 unsigned int freqn; /* nominal sampling rate in USB format, i.e. fs/1000 in Q10.14 */
329 unsigned int freqmax; /* maximum sampling rate, used for buffer management */
330 unsigned int phase; /* phase accumulator */
331 unsigned int flags; /* see FLG_ defines */
333 struct my_data_urb durb[2]; /* ISO descriptors for the data endpoint */
334 struct my_sync_urb surb[2]; /* ISO sync pipe descriptor if needed */
340 int interface; /* Interface number, -1 means not used */
341 unsigned int format; /* USB data format */
342 unsigned int datapipe; /* the data input pipe */
343 unsigned int syncpipe; /* the synchronisation pipe - 0 for anything but asynchronous OUT mode */
344 unsigned int syncinterval; /* P for asynchronous OUT mode, 0 otherwise */
345 unsigned int freqn; /* nominal sampling rate in USB format, i.e. fs/1000 in Q10.14 */
346 unsigned int freqm; /* momentary sampling rate in USB format, i.e. fs/1000 in Q10.14 */
347 unsigned int freqmax; /* maximum sampling rate, used for buffer management */
348 unsigned int phase; /* phase accumulator */
349 unsigned int flags; /* see FLG_ defines */
351 struct my_data_urb durb[2]; /* ISO descriptors for the data endpoint */
352 struct my_sync_urb surb[2]; /* ISO sync pipe descriptor if needed */
358 unsigned int numfmtin, numfmtout;
359 struct audioformat fmtin[MAXFORMATS];
360 struct audioformat fmtout[MAXFORMATS];
363 struct usb_mixerdev {
364 struct list_head list;
365 struct usb_audio_state *state;
367 /* soundcore stuff */
370 unsigned char iface; /* interface number of the AudioControl interface */
372 /* USB format descriptions */
373 unsigned int numch, modcnt;
375 /* mixch is last and gets allocated dynamically */
376 struct mixerchannel ch[0];
379 struct usb_audio_state {
380 struct list_head audiodev;
383 struct usb_device *usbdev;
385 struct list_head audiolist;
386 struct list_head mixerlist;
388 unsigned count; /* usage counter; NOTE: the usb stack is also considered a user */
391 /* private audio format extensions */
392 #define AFMT_STEREO 0x80000000
393 #define AFMT_ISSTEREO(x) ((x) & AFMT_STEREO)
394 #define AFMT_IS16BIT(x) ((x) & (AFMT_S16_LE|AFMT_S16_BE|AFMT_U16_LE|AFMT_U16_BE))
395 #define AFMT_ISUNSIGNED(x) ((x) & (AFMT_U8|AFMT_U16_LE|AFMT_U16_BE))
396 #define AFMT_BYTESSHIFT(x) ((AFMT_ISSTEREO(x) ? 1 : 0) + (AFMT_IS16BIT(x) ? 1 : 0))
397 #define AFMT_BYTES(x) (1<<AFMT_BYTESSHFIT(x))
399 /* --------------------------------------------------------------------- */
401 /* prevent picking up a bogus abs macro */
403 static inline int abs(int x)
410 /* --------------------------------------------------------------------- */
412 static inline unsigned ld2(unsigned int x)
437 /* --------------------------------------------------------------------- */
440 * OSS compatible ring buffer management. The ring buffer may be mmap'ed into
441 * an application address space.
443 * I first used the rvmalloc stuff copied from bttv. Alan Cox did not like it, so
444 * we now use an array of pointers to a single page each. This saves us the
445 * kernel page table manipulations, but we have to do a page table alike mechanism
446 * (though only one indirection) in software.
449 static void dmabuf_release(struct dmabuf *db)
454 for(nr = 0; nr < NRSGBUF; nr++) {
455 if (!(p = db->sgbuf[nr]))
457 ClearPageReserved(virt_to_page(p));
458 free_page((unsigned long)p);
459 db->sgbuf[nr] = NULL;
461 db->mapped = db->ready = 0;
464 static int dmabuf_init(struct dmabuf *db)
466 unsigned int nr, bytepersec, bufs;
469 /* initialize some fields */
470 db->rdptr = db->wrptr = db->total_bytes = db->count = db->error = 0;
471 /* calculate required buffer size */
472 bytepersec = db->srate << AFMT_BYTESSHIFT(db->format);
473 bufs = 1U << DMABUFSHIFT;
474 if (db->ossfragshift) {
475 if ((1000 << db->ossfragshift) < bytepersec)
476 db->fragshift = ld2(bytepersec/1000);
478 db->fragshift = db->ossfragshift;
480 db->fragshift = ld2(bytepersec/100/(db->subdivision ? db->subdivision : 1));
481 if (db->fragshift < 3)
484 db->numfrag = bufs >> db->fragshift;
485 while (db->numfrag < 4 && db->fragshift > 3) {
487 db->numfrag = bufs >> db->fragshift;
489 db->fragsize = 1 << db->fragshift;
490 if (db->ossmaxfrags >= 4 && db->ossmaxfrags < db->numfrag)
491 db->numfrag = db->ossmaxfrags;
492 db->dmasize = db->numfrag << db->fragshift;
493 for(nr = 0; nr < NRSGBUF; nr++) {
494 if (!db->sgbuf[nr]) {
495 p = (void *)get_zeroed_page(GFP_KERNEL);
499 SetPageReserved(virt_to_page(p));
501 memset(db->sgbuf[nr], AFMT_ISUNSIGNED(db->format) ? 0x80 : 0, PAGE_SIZE);
502 if ((nr << PAGE_SHIFT) >= db->dmasize)
505 db->bufsize = nr << PAGE_SHIFT;
507 dprintk((KERN_DEBUG "usbaudio: dmabuf_init bytepersec %d bufs %d ossfragshift %d ossmaxfrags %d "
508 "fragshift %d fragsize %d numfrag %d dmasize %d bufsize %d fmt 0x%x srate %d\n",
509 bytepersec, bufs, db->ossfragshift, db->ossmaxfrags, db->fragshift, db->fragsize,
510 db->numfrag, db->dmasize, db->bufsize, db->format, db->srate));
514 static int dmabuf_mmap(struct vm_area_struct *vma, struct dmabuf *db, unsigned long start, unsigned long size, pgprot_t prot)
518 if (!db->ready || db->mapped || (start | size) & (PAGE_SIZE-1) || size > db->bufsize)
521 for(nr = 0; nr < size; nr++)
525 for(nr = 0; nr < size; nr++) {
526 if (remap_page_range(vma, start, virt_to_phys(db->sgbuf[nr]), PAGE_SIZE, prot))
533 static void dmabuf_copyin(struct dmabuf *db, const void *buffer, unsigned int size)
535 unsigned int pgrem, rem;
537 db->total_bytes += size;
541 pgrem = ((~db->wrptr) & (PAGE_SIZE-1)) + 1;
544 rem = db->dmasize - db->wrptr;
547 memcpy((db->sgbuf[db->wrptr >> PAGE_SHIFT]) + (db->wrptr & (PAGE_SIZE-1)), buffer, pgrem);
551 if (db->wrptr >= db->dmasize)
556 static void dmabuf_copyout(struct dmabuf *db, void *buffer, unsigned int size)
558 unsigned int pgrem, rem;
560 db->total_bytes += size;
564 pgrem = ((~db->rdptr) & (PAGE_SIZE-1)) + 1;
567 rem = db->dmasize - db->rdptr;
570 memcpy(buffer, (db->sgbuf[db->rdptr >> PAGE_SHIFT]) + (db->rdptr & (PAGE_SIZE-1)), pgrem);
574 if (db->rdptr >= db->dmasize)
579 static int dmabuf_copyin_user(struct dmabuf *db, unsigned int ptr, const void __user *buffer, unsigned int size)
581 unsigned int pgrem, rem;
583 if (!db->ready || db->mapped)
588 pgrem = ((~ptr) & (PAGE_SIZE-1)) + 1;
591 rem = db->dmasize - ptr;
594 if (copy_from_user((db->sgbuf[ptr >> PAGE_SHIFT]) + (ptr & (PAGE_SIZE-1)), buffer, pgrem))
599 if (ptr >= db->dmasize)
604 static int dmabuf_copyout_user(struct dmabuf *db, unsigned int ptr, void __user *buffer, unsigned int size)
606 unsigned int pgrem, rem;
608 if (!db->ready || db->mapped)
613 pgrem = ((~ptr) & (PAGE_SIZE-1)) + 1;
616 rem = db->dmasize - ptr;
619 if (copy_to_user(buffer, (db->sgbuf[ptr >> PAGE_SHIFT]) + (ptr & (PAGE_SIZE-1)), pgrem))
624 if (ptr >= db->dmasize)
629 /* --------------------------------------------------------------------- */
631 * USB I/O code. We do sample format conversion if necessary
634 static void usbin_stop(struct usb_audiodev *as)
636 struct usbin *u = &as->usbin;
638 unsigned int i, notkilled = 1;
640 spin_lock_irqsave(&as->lock, flags);
641 u->flags &= ~FLG_RUNNING;
643 spin_unlock_irqrestore(&as->lock, flags);
644 while (i & (FLG_URB0RUNNING|FLG_URB1RUNNING|FLG_SYNC0RUNNING|FLG_SYNC1RUNNING)) {
645 set_current_state(notkilled ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
647 spin_lock_irqsave(&as->lock, flags);
649 spin_unlock_irqrestore(&as->lock, flags);
650 if (notkilled && signal_pending(current)) {
651 if (i & FLG_URB0RUNNING)
652 usb_unlink_urb(u->durb[0].urb);
653 if (i & FLG_URB1RUNNING)
654 usb_unlink_urb(u->durb[1].urb);
655 if (i & FLG_SYNC0RUNNING)
656 usb_unlink_urb(u->surb[0].urb);
657 if (i & FLG_SYNC1RUNNING)
658 usb_unlink_urb(u->surb[1].urb);
662 set_current_state(TASK_RUNNING);
663 if (u->durb[0].urb->transfer_buffer)
664 kfree(u->durb[0].urb->transfer_buffer);
665 if (u->durb[1].urb->transfer_buffer)
666 kfree(u->durb[1].urb->transfer_buffer);
667 if (u->surb[0].urb->transfer_buffer)
668 kfree(u->surb[0].urb->transfer_buffer);
669 if (u->surb[1].urb->transfer_buffer)
670 kfree(u->surb[1].urb->transfer_buffer);
671 u->durb[0].urb->transfer_buffer = u->durb[1].urb->transfer_buffer =
672 u->surb[0].urb->transfer_buffer = u->surb[1].urb->transfer_buffer = NULL;
675 static inline void usbin_release(struct usb_audiodev *as)
680 static void usbin_disc(struct usb_audiodev *as)
682 struct usbin *u = &as->usbin;
686 spin_lock_irqsave(&as->lock, flags);
687 u->flags &= ~(FLG_RUNNING | FLG_CONNECTED);
688 spin_unlock_irqrestore(&as->lock, flags);
692 static void conversion(const void *ibuf, unsigned int ifmt, void *obuf, unsigned int ofmt, void *tmp, unsigned int scnt)
699 if (AFMT_ISSTEREO(ifmt))
701 sp = ((__s16 *)tmp) + cnt;
702 switch (ifmt & ~AFMT_STEREO) {
704 for (bp = ((unsigned char *)ibuf)+cnt, i = 0; i < cnt; i++) {
707 *sp = (*bp ^ 0x80) << 8;
712 for (bp = ((unsigned char *)ibuf)+cnt, i = 0; i < cnt; i++) {
720 for (bp = ((unsigned char *)ibuf)+2*cnt, i = 0; i < cnt; i++) {
723 *sp = (bp[0] | (bp[1] << 8)) ^ 0x8000;
728 for (bp = ((unsigned char *)ibuf)+2*cnt, i = 0; i < cnt; i++) {
731 *sp = (bp[1] | (bp[0] << 8)) ^ 0x8000;
736 for (bp = ((unsigned char *)ibuf)+2*cnt, i = 0; i < cnt; i++) {
739 *sp = bp[0] | (bp[1] << 8);
744 for (bp = ((unsigned char *)ibuf)+2*cnt, i = 0; i < cnt; i++) {
747 *sp = bp[1] | (bp[0] << 8);
751 if (!AFMT_ISSTEREO(ifmt) && AFMT_ISSTEREO(ofmt)) {
752 /* expand from mono to stereo */
753 for (sp = ((__s16 *)tmp)+scnt, sp2 = ((__s16 *)tmp)+2*scnt, i = 0; i < scnt; i++) {
756 sp2[0] = sp2[1] = sp[0];
759 if (AFMT_ISSTEREO(ifmt) && !AFMT_ISSTEREO(ofmt)) {
760 /* contract from stereo to mono */
761 for (sp = sp2 = ((__s16 *)tmp), i = 0; i < scnt; i++, sp++, sp2 += 2)
762 sp[0] = (sp2[0] + sp2[1]) >> 1;
765 if (AFMT_ISSTEREO(ofmt))
768 bp = ((unsigned char *)obuf);
769 switch (ofmt & ~AFMT_STEREO) {
771 for (i = 0; i < cnt; i++, sp++, bp++)
772 *bp = (*sp >> 8) ^ 0x80;
776 for (i = 0; i < cnt; i++, sp++, bp++)
781 for (i = 0; i < cnt; i++, sp++, bp += 2) {
784 bp[1] = (s >> 8) ^ 0x80;
789 for (i = 0; i < cnt; i++, sp++, bp += 2) {
792 bp[0] = (s >> 8) ^ 0x80;
797 for (i = 0; i < cnt; i++, sp++, bp += 2) {
805 for (i = 0; i < cnt; i++, sp++, bp += 2) {
815 static void usbin_convert(struct usbin *u, unsigned char *buffer, unsigned int samples)
821 unsigned int scnt, maxs, ufmtsh, dfmtsh;
823 ufmtsh = AFMT_BYTESSHIFT(u->format);
824 dfmtsh = AFMT_BYTESSHIFT(u->dma.format);
825 maxs = (AFMT_ISSTEREO(u->dma.format | u->format)) ? 32 : 64;
826 while (samples > 0) {
830 conversion(buffer, u->format, tmp.b, u->dma.format, tmp.b, scnt);
831 dmabuf_copyin(&u->dma, tmp.b, scnt << dfmtsh);
832 buffer += scnt << ufmtsh;
837 static int usbin_prepare_desc(struct usbin *u, struct urb *urb)
839 unsigned int i, maxsize, offs;
841 maxsize = (u->freqmax + 0x3fff) >> (14 - AFMT_BYTESSHIFT(u->format));
842 //printk(KERN_DEBUG "usbin_prepare_desc: maxsize %d freq 0x%x format 0x%x\n", maxsize, u->freqn, u->format);
843 for (i = offs = 0; i < DESCFRAMES; i++, offs += maxsize) {
844 urb->iso_frame_desc[i].length = maxsize;
845 urb->iso_frame_desc[i].offset = offs;
852 * return value: 0 if descriptor should be restarted, -1 otherwise
853 * convert sample format on the fly if necessary
855 static int usbin_retire_desc(struct usbin *u, struct urb *urb)
857 unsigned int i, ufmtsh, dfmtsh, err = 0, cnt, scnt, dmafree;
860 ufmtsh = AFMT_BYTESSHIFT(u->format);
861 dfmtsh = AFMT_BYTESSHIFT(u->dma.format);
862 for (i = 0; i < DESCFRAMES; i++) {
863 cp = ((unsigned char *)urb->transfer_buffer) + urb->iso_frame_desc[i].offset;
864 if (urb->iso_frame_desc[i].status) {
865 dprintk((KERN_DEBUG "usbin_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
868 scnt = urb->iso_frame_desc[i].actual_length >> ufmtsh;
871 cnt = scnt << dfmtsh;
872 if (!u->dma.mapped) {
873 dmafree = u->dma.dmasize - u->dma.count;
875 scnt = dmafree >> dfmtsh;
876 cnt = scnt << dfmtsh;
881 if (u->format == u->dma.format) {
882 /* we do not need format conversion */
883 dprintk((KERN_DEBUG "usbaudio: no sample format conversion\n"));
884 dmabuf_copyin(&u->dma, cp, cnt);
886 /* we need sampling format conversion */
887 dprintk((KERN_DEBUG "usbaudio: sample format conversion %x != %x\n", u->format, u->dma.format));
888 usbin_convert(u, cp, scnt);
893 if (u->dma.count >= (signed)u->dma.fragsize)
894 wake_up(&u->dma.wait);
898 static void usbin_completed(struct urb *urb, struct pt_regs *regs)
900 struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
901 struct usbin *u = &as->usbin;
907 printk(KERN_DEBUG "usbin_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
909 if (urb == u->durb[0].urb)
910 mask = FLG_URB0RUNNING;
911 else if (urb == u->durb[1].urb)
912 mask = FLG_URB1RUNNING;
915 printk(KERN_ERR "usbin_completed: panic: unknown URB\n");
917 urb->dev = as->state->usbdev;
918 spin_lock_irqsave(&as->lock, flags);
919 if (!usbin_retire_desc(u, urb) &&
920 u->flags & FLG_RUNNING &&
921 !usbin_prepare_desc(u, urb) &&
922 (suret = usb_submit_urb(urb, GFP_ATOMIC)) == 0) {
925 u->flags &= ~(mask | FLG_RUNNING);
926 wake_up(&u->dma.wait);
927 printk(KERN_DEBUG "usbin_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret);
929 spin_unlock_irqrestore(&as->lock, flags);
933 * we output sync data
935 static int usbin_sync_prepare_desc(struct usbin *u, struct urb *urb)
937 unsigned char *cp = urb->transfer_buffer;
938 unsigned int i, offs;
940 for (i = offs = 0; i < SYNCFRAMES; i++, offs += 3, cp += 3) {
941 urb->iso_frame_desc[i].length = 3;
942 urb->iso_frame_desc[i].offset = offs;
944 cp[1] = u->freqn >> 8;
945 cp[2] = u->freqn >> 16;
952 * return value: 0 if descriptor should be restarted, -1 otherwise
954 static int usbin_sync_retire_desc(struct usbin *u, struct urb *urb)
958 for (i = 0; i < SYNCFRAMES; i++)
959 if (urb->iso_frame_desc[0].status)
960 dprintk((KERN_DEBUG "usbin_sync_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
964 static void usbin_sync_completed(struct urb *urb, struct pt_regs *regs)
966 struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
967 struct usbin *u = &as->usbin;
973 printk(KERN_DEBUG "usbin_sync_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
975 if (urb == u->surb[0].urb)
976 mask = FLG_SYNC0RUNNING;
977 else if (urb == u->surb[1].urb)
978 mask = FLG_SYNC1RUNNING;
981 printk(KERN_ERR "usbin_sync_completed: panic: unknown URB\n");
983 urb->dev = as->state->usbdev;
984 spin_lock_irqsave(&as->lock, flags);
985 if (!usbin_sync_retire_desc(u, urb) &&
986 u->flags & FLG_RUNNING &&
987 !usbin_sync_prepare_desc(u, urb) &&
988 (suret = usb_submit_urb(urb, GFP_ATOMIC)) == 0) {
991 u->flags &= ~(mask | FLG_RUNNING);
992 wake_up(&u->dma.wait);
993 dprintk((KERN_DEBUG "usbin_sync_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret));
995 spin_unlock_irqrestore(&as->lock, flags);
998 static int usbin_start(struct usb_audiodev *as)
1000 struct usb_device *dev = as->state->usbdev;
1001 struct usbin *u = &as->usbin;
1003 unsigned long flags;
1004 unsigned int maxsze, bufsz;
1007 printk(KERN_DEBUG "usbin_start: device %d ufmt 0x%08x dfmt 0x%08x srate %d\n",
1008 dev->devnum, u->format, u->dma.format, u->dma.srate);
1010 /* allocate USB storage if not already done */
1011 spin_lock_irqsave(&as->lock, flags);
1012 if (!(u->flags & FLG_CONNECTED)) {
1013 spin_unlock_irqrestore(&as->lock, flags);
1016 if (!(u->flags & FLG_RUNNING)) {
1017 spin_unlock_irqrestore(&as->lock, flags);
1018 u->freqn = ((u->dma.srate << 11) + 62) / 125; /* this will overflow at approx 2MSPS */
1019 u->freqmax = u->freqn + (u->freqn >> 2);
1021 maxsze = (u->freqmax + 0x3fff) >> (14 - AFMT_BYTESSHIFT(u->format));
1022 bufsz = DESCFRAMES * maxsze;
1023 if (u->durb[0].urb->transfer_buffer)
1024 kfree(u->durb[0].urb->transfer_buffer);
1025 u->durb[0].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1026 u->durb[0].urb->transfer_buffer_length = bufsz;
1027 if (u->durb[1].urb->transfer_buffer)
1028 kfree(u->durb[1].urb->transfer_buffer);
1029 u->durb[1].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1030 u->durb[1].urb->transfer_buffer_length = bufsz;
1032 if (u->surb[0].urb->transfer_buffer)
1033 kfree(u->surb[0].urb->transfer_buffer);
1034 u->surb[0].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1035 u->surb[0].urb->transfer_buffer_length = 3*SYNCFRAMES;
1036 if (u->surb[1].urb->transfer_buffer)
1037 kfree(u->surb[1].urb->transfer_buffer);
1038 u->surb[1].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1039 u->surb[1].urb->transfer_buffer_length = 3*SYNCFRAMES;
1041 if (!u->durb[0].urb->transfer_buffer || !u->durb[1].urb->transfer_buffer ||
1042 (u->syncpipe && (!u->surb[0].urb->transfer_buffer || !u->surb[1].urb->transfer_buffer))) {
1043 printk(KERN_ERR "usbaudio: cannot start playback device %d\n", dev->devnum);
1046 spin_lock_irqsave(&as->lock, flags);
1048 if (u->dma.count >= u->dma.dmasize && !u->dma.mapped) {
1049 spin_unlock_irqrestore(&as->lock, flags);
1052 u->flags |= FLG_RUNNING;
1053 if (!(u->flags & FLG_URB0RUNNING)) {
1054 urb = u->durb[0].urb;
1056 urb->pipe = u->datapipe;
1057 urb->transfer_flags = URB_ISO_ASAP;
1058 urb->number_of_packets = DESCFRAMES;
1060 urb->complete = usbin_completed;
1061 if (!usbin_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_KERNEL))
1062 u->flags |= FLG_URB0RUNNING;
1064 u->flags &= ~FLG_RUNNING;
1066 if (u->flags & FLG_RUNNING && !(u->flags & FLG_URB1RUNNING)) {
1067 urb = u->durb[1].urb;
1069 urb->pipe = u->datapipe;
1070 urb->transfer_flags = URB_ISO_ASAP;
1071 urb->number_of_packets = DESCFRAMES;
1073 urb->complete = usbin_completed;
1074 if (!usbin_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_KERNEL))
1075 u->flags |= FLG_URB1RUNNING;
1077 u->flags &= ~FLG_RUNNING;
1080 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC0RUNNING)) {
1081 urb = u->surb[0].urb;
1083 urb->pipe = u->syncpipe;
1084 urb->transfer_flags = URB_ISO_ASAP;
1085 urb->number_of_packets = SYNCFRAMES;
1087 urb->complete = usbin_sync_completed;
1088 /* stride: u->syncinterval */
1089 if (!usbin_sync_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_KERNEL))
1090 u->flags |= FLG_SYNC0RUNNING;
1092 u->flags &= ~FLG_RUNNING;
1094 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC1RUNNING)) {
1095 urb = u->surb[1].urb;
1097 urb->pipe = u->syncpipe;
1098 urb->transfer_flags = URB_ISO_ASAP;
1099 urb->number_of_packets = SYNCFRAMES;
1101 urb->complete = usbin_sync_completed;
1102 /* stride: u->syncinterval */
1103 if (!usbin_sync_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_KERNEL))
1104 u->flags |= FLG_SYNC1RUNNING;
1106 u->flags &= ~FLG_RUNNING;
1109 spin_unlock_irqrestore(&as->lock, flags);
1113 static void usbout_stop(struct usb_audiodev *as)
1115 struct usbout *u = &as->usbout;
1116 unsigned long flags;
1117 unsigned int i, notkilled = 1;
1119 spin_lock_irqsave(&as->lock, flags);
1120 u->flags &= ~FLG_RUNNING;
1122 spin_unlock_irqrestore(&as->lock, flags);
1123 while (i & (FLG_URB0RUNNING|FLG_URB1RUNNING|FLG_SYNC0RUNNING|FLG_SYNC1RUNNING)) {
1124 set_current_state(notkilled ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
1125 schedule_timeout(1);
1126 spin_lock_irqsave(&as->lock, flags);
1128 spin_unlock_irqrestore(&as->lock, flags);
1129 if (notkilled && signal_pending(current)) {
1130 if (i & FLG_URB0RUNNING)
1131 usb_unlink_urb(u->durb[0].urb);
1132 if (i & FLG_URB1RUNNING)
1133 usb_unlink_urb(u->durb[1].urb);
1134 if (i & FLG_SYNC0RUNNING)
1135 usb_unlink_urb(u->surb[0].urb);
1136 if (i & FLG_SYNC1RUNNING)
1137 usb_unlink_urb(u->surb[1].urb);
1141 set_current_state(TASK_RUNNING);
1142 if (u->durb[0].urb->transfer_buffer)
1143 kfree(u->durb[0].urb->transfer_buffer);
1144 if (u->durb[1].urb->transfer_buffer)
1145 kfree(u->durb[1].urb->transfer_buffer);
1146 if (u->surb[0].urb->transfer_buffer)
1147 kfree(u->surb[0].urb->transfer_buffer);
1148 if (u->surb[1].urb->transfer_buffer)
1149 kfree(u->surb[1].urb->transfer_buffer);
1150 u->durb[0].urb->transfer_buffer = u->durb[1].urb->transfer_buffer =
1151 u->surb[0].urb->transfer_buffer = u->surb[1].urb->transfer_buffer = NULL;
1154 static inline void usbout_release(struct usb_audiodev *as)
1159 static void usbout_disc(struct usb_audiodev *as)
1161 struct usbout *u = &as->usbout;
1162 unsigned long flags;
1164 spin_lock_irqsave(&as->lock, flags);
1165 u->flags &= ~(FLG_RUNNING | FLG_CONNECTED);
1166 spin_unlock_irqrestore(&as->lock, flags);
1170 static void usbout_convert(struct usbout *u, unsigned char *buffer, unsigned int samples)
1176 unsigned int scnt, maxs, ufmtsh, dfmtsh;
1178 ufmtsh = AFMT_BYTESSHIFT(u->format);
1179 dfmtsh = AFMT_BYTESSHIFT(u->dma.format);
1180 maxs = (AFMT_ISSTEREO(u->dma.format | u->format)) ? 32 : 64;
1181 while (samples > 0) {
1185 dmabuf_copyout(&u->dma, tmp.b, scnt << dfmtsh);
1186 conversion(tmp.b, u->dma.format, buffer, u->format, tmp.b, scnt);
1187 buffer += scnt << ufmtsh;
1192 static int usbout_prepare_desc(struct usbout *u, struct urb *urb)
1194 unsigned int i, ufmtsh, dfmtsh, err = 0, cnt, scnt, offs;
1195 unsigned char *cp = urb->transfer_buffer;
1197 ufmtsh = AFMT_BYTESSHIFT(u->format);
1198 dfmtsh = AFMT_BYTESSHIFT(u->dma.format);
1199 for (i = offs = 0; i < DESCFRAMES; i++) {
1200 urb->iso_frame_desc[i].offset = offs;
1201 u->phase = (u->phase & 0x3fff) + u->freqm;
1202 scnt = u->phase >> 14;
1204 urb->iso_frame_desc[i].length = 0;
1207 cnt = scnt << dfmtsh;
1208 if (!u->dma.mapped) {
1209 if (cnt > u->dma.count) {
1210 scnt = u->dma.count >> dfmtsh;
1211 cnt = scnt << dfmtsh;
1214 u->dma.count -= cnt;
1216 u->dma.count += cnt;
1217 if (u->format == u->dma.format) {
1218 /* we do not need format conversion */
1219 dmabuf_copyout(&u->dma, cp, cnt);
1221 /* we need sampling format conversion */
1222 usbout_convert(u, cp, scnt);
1224 cnt = scnt << ufmtsh;
1225 urb->iso_frame_desc[i].length = cnt;
1232 if (u->dma.mapped) {
1233 if (u->dma.count >= (signed)u->dma.fragsize)
1234 wake_up(&u->dma.wait);
1236 if ((signed)u->dma.dmasize >= u->dma.count + (signed)u->dma.fragsize)
1237 wake_up(&u->dma.wait);
1239 return err ? -1 : 0;
1243 * return value: 0 if descriptor should be restarted, -1 otherwise
1245 static int usbout_retire_desc(struct usbout *u, struct urb *urb)
1249 for (i = 0; i < DESCFRAMES; i++) {
1250 if (urb->iso_frame_desc[i].status) {
1251 dprintk((KERN_DEBUG "usbout_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
1258 static void usbout_completed(struct urb *urb, struct pt_regs *regs)
1260 struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
1261 struct usbout *u = &as->usbout;
1262 unsigned long flags;
1267 printk(KERN_DEBUG "usbout_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
1269 if (urb == u->durb[0].urb)
1270 mask = FLG_URB0RUNNING;
1271 else if (urb == u->durb[1].urb)
1272 mask = FLG_URB1RUNNING;
1275 printk(KERN_ERR "usbout_completed: panic: unknown URB\n");
1277 urb->dev = as->state->usbdev;
1278 spin_lock_irqsave(&as->lock, flags);
1279 if (!usbout_retire_desc(u, urb) &&
1280 u->flags & FLG_RUNNING &&
1281 !usbout_prepare_desc(u, urb) &&
1282 (suret = usb_submit_urb(urb, GFP_ATOMIC)) == 0) {
1285 u->flags &= ~(mask | FLG_RUNNING);
1286 wake_up(&u->dma.wait);
1287 dprintk((KERN_DEBUG "usbout_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret));
1289 spin_unlock_irqrestore(&as->lock, flags);
1292 static int usbout_sync_prepare_desc(struct usbout *u, struct urb *urb)
1294 unsigned int i, offs;
1296 for (i = offs = 0; i < SYNCFRAMES; i++, offs += 3) {
1297 urb->iso_frame_desc[i].length = 3;
1298 urb->iso_frame_desc[i].offset = offs;
1305 * return value: 0 if descriptor should be restarted, -1 otherwise
1307 static int usbout_sync_retire_desc(struct usbout *u, struct urb *urb)
1309 unsigned char *cp = urb->transfer_buffer;
1312 for (i = 0; i < SYNCFRAMES; i++, cp += 3) {
1313 if (urb->iso_frame_desc[i].status) {
1314 dprintk((KERN_DEBUG "usbout_sync_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
1317 if (urb->iso_frame_desc[i].actual_length < 3) {
1318 dprintk((KERN_DEBUG "usbout_sync_retire_desc: frame %u length %d\n", i, urb->iso_frame_desc[i].actual_length));
1321 f = cp[0] | (cp[1] << 8) | (cp[2] << 16);
1322 if (abs(f - u->freqn) > (u->freqn >> 3) || f > u->freqmax) {
1323 printk(KERN_WARNING "usbout_sync_retire_desc: requested frequency %u (nominal %u) out of range!\n", f, u->freqn);
1331 static void usbout_sync_completed(struct urb *urb, struct pt_regs *regs)
1333 struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
1334 struct usbout *u = &as->usbout;
1335 unsigned long flags;
1340 printk(KERN_DEBUG "usbout_sync_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
1342 if (urb == u->surb[0].urb)
1343 mask = FLG_SYNC0RUNNING;
1344 else if (urb == u->surb[1].urb)
1345 mask = FLG_SYNC1RUNNING;
1348 printk(KERN_ERR "usbout_sync_completed: panic: unknown URB\n");
1350 urb->dev = as->state->usbdev;
1351 spin_lock_irqsave(&as->lock, flags);
1352 if (!usbout_sync_retire_desc(u, urb) &&
1353 u->flags & FLG_RUNNING &&
1354 !usbout_sync_prepare_desc(u, urb) &&
1355 (suret = usb_submit_urb(urb, GFP_ATOMIC)) == 0) {
1358 u->flags &= ~(mask | FLG_RUNNING);
1359 wake_up(&u->dma.wait);
1360 dprintk((KERN_DEBUG "usbout_sync_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret));
1362 spin_unlock_irqrestore(&as->lock, flags);
1365 static int usbout_start(struct usb_audiodev *as)
1367 struct usb_device *dev = as->state->usbdev;
1368 struct usbout *u = &as->usbout;
1370 unsigned long flags;
1371 unsigned int maxsze, bufsz;
1374 printk(KERN_DEBUG "usbout_start: device %d ufmt 0x%08x dfmt 0x%08x srate %d\n",
1375 dev->devnum, u->format, u->dma.format, u->dma.srate);
1377 /* allocate USB storage if not already done */
1378 spin_lock_irqsave(&as->lock, flags);
1379 if (!(u->flags & FLG_CONNECTED)) {
1380 spin_unlock_irqrestore(&as->lock, flags);
1383 if (!(u->flags & FLG_RUNNING)) {
1384 spin_unlock_irqrestore(&as->lock, flags);
1385 u->freqn = u->freqm = ((u->dma.srate << 11) + 62) / 125; /* this will overflow at approx 2MSPS */
1386 u->freqmax = u->freqn + (u->freqn >> 2);
1388 maxsze = (u->freqmax + 0x3fff) >> (14 - AFMT_BYTESSHIFT(u->format));
1389 bufsz = DESCFRAMES * maxsze;
1390 if (u->durb[0].urb->transfer_buffer)
1391 kfree(u->durb[0].urb->transfer_buffer);
1392 u->durb[0].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1393 u->durb[0].urb->transfer_buffer_length = bufsz;
1394 if (u->durb[1].urb->transfer_buffer)
1395 kfree(u->durb[1].urb->transfer_buffer);
1396 u->durb[1].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1397 u->durb[1].urb->transfer_buffer_length = bufsz;
1399 if (u->surb[0].urb->transfer_buffer)
1400 kfree(u->surb[0].urb->transfer_buffer);
1401 u->surb[0].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1402 u->surb[0].urb->transfer_buffer_length = 3*SYNCFRAMES;
1403 if (u->surb[1].urb->transfer_buffer)
1404 kfree(u->surb[1].urb->transfer_buffer);
1405 u->surb[1].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1406 u->surb[1].urb->transfer_buffer_length = 3*SYNCFRAMES;
1408 if (!u->durb[0].urb->transfer_buffer || !u->durb[1].urb->transfer_buffer ||
1409 (u->syncpipe && (!u->surb[0].urb->transfer_buffer || !u->surb[1].urb->transfer_buffer))) {
1410 printk(KERN_ERR "usbaudio: cannot start playback device %d\n", dev->devnum);
1413 spin_lock_irqsave(&as->lock, flags);
1415 if (u->dma.count <= 0 && !u->dma.mapped) {
1416 spin_unlock_irqrestore(&as->lock, flags);
1419 u->flags |= FLG_RUNNING;
1420 if (!(u->flags & FLG_URB0RUNNING)) {
1421 urb = u->durb[0].urb;
1423 urb->pipe = u->datapipe;
1424 urb->transfer_flags = URB_ISO_ASAP;
1425 urb->number_of_packets = DESCFRAMES;
1427 urb->complete = usbout_completed;
1428 if (!usbout_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_ATOMIC))
1429 u->flags |= FLG_URB0RUNNING;
1431 u->flags &= ~FLG_RUNNING;
1433 if (u->flags & FLG_RUNNING && !(u->flags & FLG_URB1RUNNING)) {
1434 urb = u->durb[1].urb;
1436 urb->pipe = u->datapipe;
1437 urb->transfer_flags = URB_ISO_ASAP;
1438 urb->number_of_packets = DESCFRAMES;
1440 urb->complete = usbout_completed;
1441 if (!usbout_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_ATOMIC))
1442 u->flags |= FLG_URB1RUNNING;
1444 u->flags &= ~FLG_RUNNING;
1447 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC0RUNNING)) {
1448 urb = u->surb[0].urb;
1450 urb->pipe = u->syncpipe;
1451 urb->transfer_flags = URB_ISO_ASAP;
1452 urb->number_of_packets = SYNCFRAMES;
1454 urb->complete = usbout_sync_completed;
1455 /* stride: u->syncinterval */
1456 if (!usbout_sync_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_ATOMIC))
1457 u->flags |= FLG_SYNC0RUNNING;
1459 u->flags &= ~FLG_RUNNING;
1461 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC1RUNNING)) {
1462 urb = u->surb[1].urb;
1464 urb->pipe = u->syncpipe;
1465 urb->transfer_flags = URB_ISO_ASAP;
1466 urb->number_of_packets = SYNCFRAMES;
1468 urb->complete = usbout_sync_completed;
1469 /* stride: u->syncinterval */
1470 if (!usbout_sync_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_ATOMIC))
1471 u->flags |= FLG_SYNC1RUNNING;
1473 u->flags &= ~FLG_RUNNING;
1476 spin_unlock_irqrestore(&as->lock, flags);
1480 /* --------------------------------------------------------------------- */
1482 static unsigned int format_goodness(struct audioformat *afp, unsigned int fmt, unsigned int srate)
1486 if (srate < afp->sratelo)
1487 g += afp->sratelo - srate;
1488 if (srate > afp->sratehi)
1489 g += srate - afp->sratehi;
1490 if (AFMT_ISSTEREO(afp->format) && !AFMT_ISSTEREO(fmt))
1492 if (!AFMT_ISSTEREO(afp->format) && AFMT_ISSTEREO(fmt))
1494 if (AFMT_IS16BIT(afp->format) && !AFMT_IS16BIT(fmt))
1496 if (!AFMT_IS16BIT(afp->format) && AFMT_IS16BIT(fmt))
1501 static int find_format(struct audioformat *afp, unsigned int nr, unsigned int fmt, unsigned int srate)
1503 unsigned int i, g, gb = ~0;
1504 int j = -1; /* default to failure */
1506 /* find "best" format (according to format_goodness) */
1507 for (i = 0; i < nr; i++) {
1508 g = format_goodness(&afp[i], fmt, srate);
1517 static int set_format_in(struct usb_audiodev *as)
1519 struct usb_device *dev = as->state->usbdev;
1520 struct usb_host_interface *alts;
1521 struct usb_interface *iface;
1522 struct usbin *u = &as->usbin;
1523 struct dmabuf *d = &u->dma;
1524 struct audioformat *fmt;
1526 unsigned char data[3];
1529 iface = usb_ifnum_to_if(dev, u->interface);
1533 fmtnr = find_format(as->fmtin, as->numfmtin, d->format, d->srate);
1535 printk(KERN_ERR "usbaudio: set_format_in(): failed to find desired format/speed combination.\n");
1539 fmt = as->fmtin + fmtnr;
1540 alts = usb_altnum_to_altsetting(iface, fmt->altsetting);
1541 u->format = fmt->format;
1542 u->datapipe = usb_rcvisocpipe(dev, alts->endpoint[0].desc.bEndpointAddress & 0xf);
1543 u->syncpipe = u->syncinterval = 0;
1544 if ((alts->endpoint[0].desc.bmAttributes & 0x0c) == 0x08) {
1545 if (alts->desc.bNumEndpoints < 2 ||
1546 alts->endpoint[1].desc.bmAttributes != 0x01 ||
1547 alts->endpoint[1].desc.bSynchAddress != 0 ||
1548 alts->endpoint[1].desc.bEndpointAddress != (alts->endpoint[0].desc.bSynchAddress & 0x7f)) {
1549 printk(KERN_WARNING "usbaudio: device %d interface %d altsetting %d claims adaptive in "
1550 "but has invalid synch pipe; treating as asynchronous in\n",
1551 dev->devnum, u->interface, fmt->altsetting);
1553 u->syncpipe = usb_sndisocpipe(dev, alts->endpoint[1].desc.bEndpointAddress & 0xf);
1554 u->syncinterval = alts->endpoint[1].desc.bRefresh;
1557 if (d->srate < fmt->sratelo)
1558 d->srate = fmt->sratelo;
1559 if (d->srate > fmt->sratehi)
1560 d->srate = fmt->sratehi;
1561 dprintk((KERN_DEBUG "usbaudio: set_format_in: usb_set_interface %u %u\n",
1562 u->interface, fmt->altsetting));
1563 if (usb_set_interface(dev, alts->desc.bInterfaceNumber, fmt->altsetting) < 0) {
1564 printk(KERN_WARNING "usbaudio: usb_set_interface failed, device %d interface %d altsetting %d\n",
1565 dev->devnum, u->interface, fmt->altsetting);
1568 if (fmt->sratelo == fmt->sratehi)
1570 ep = usb_pipeendpoint(u->datapipe) | (u->datapipe & USB_DIR_IN);
1571 /* if endpoint has pitch control, enable it */
1572 if (fmt->attributes & 0x02) {
1574 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1575 PITCH_CONTROL << 8, ep, data, 1, HZ)) < 0) {
1576 printk(KERN_ERR "usbaudio: failure (error %d) to set output pitch control device %d interface %u endpoint 0x%x to %u\n",
1577 ret, dev->devnum, u->interface, ep, d->srate);
1581 /* if endpoint has sampling rate control, set it */
1582 if (fmt->attributes & 0x01) {
1584 data[1] = d->srate >> 8;
1585 data[2] = d->srate >> 16;
1586 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1587 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
1588 printk(KERN_ERR "usbaudio: failure (error %d) to set input sampling frequency device %d interface %u endpoint 0x%x to %u\n",
1589 ret, dev->devnum, u->interface, ep, d->srate);
1592 if ((ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
1593 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
1594 printk(KERN_ERR "usbaudio: failure (error %d) to get input sampling frequency device %d interface %u endpoint 0x%x\n",
1595 ret, dev->devnum, u->interface, ep);
1598 dprintk((KERN_DEBUG "usbaudio: set_format_in: device %d interface %d altsetting %d srate req: %u real %u\n",
1599 dev->devnum, u->interface, fmt->altsetting, d->srate, data[0] | (data[1] << 8) | (data[2] << 16)));
1600 d->srate = data[0] | (data[1] << 8) | (data[2] << 16);
1602 dprintk((KERN_DEBUG "usbaudio: set_format_in: USB format 0x%x, DMA format 0x%x srate %u\n", u->format, d->format, d->srate));
1606 static int set_format_out(struct usb_audiodev *as)
1608 struct usb_device *dev = as->state->usbdev;
1609 struct usb_host_interface *alts;
1610 struct usb_interface *iface;
1611 struct usbout *u = &as->usbout;
1612 struct dmabuf *d = &u->dma;
1613 struct audioformat *fmt;
1615 unsigned char data[3];
1618 iface = usb_ifnum_to_if(dev, u->interface);
1622 fmtnr = find_format(as->fmtout, as->numfmtout, d->format, d->srate);
1624 printk(KERN_ERR "usbaudio: set_format_out(): failed to find desired format/speed combination.\n");
1628 fmt = as->fmtout + fmtnr;
1629 u->format = fmt->format;
1630 alts = usb_altnum_to_altsetting(iface, fmt->altsetting);
1631 u->datapipe = usb_sndisocpipe(dev, alts->endpoint[0].desc.bEndpointAddress & 0xf);
1632 u->syncpipe = u->syncinterval = 0;
1633 if ((alts->endpoint[0].desc.bmAttributes & 0x0c) == 0x04) {
1635 printk(KERN_DEBUG "bNumEndpoints 0x%02x endpoint[1].bmAttributes 0x%02x\n"
1636 KERN_DEBUG "endpoint[1].bSynchAddress 0x%02x endpoint[1].bEndpointAddress 0x%02x\n"
1637 KERN_DEBUG "endpoint[0].bSynchAddress 0x%02x\n", alts->bNumEndpoints,
1638 alts->endpoint[1].bmAttributes, alts->endpoint[1].bSynchAddress,
1639 alts->endpoint[1].bEndpointAddress, alts->endpoint[0].bSynchAddress);
1641 if (alts->desc.bNumEndpoints < 2 ||
1642 alts->endpoint[1].desc.bmAttributes != 0x01 ||
1643 alts->endpoint[1].desc.bSynchAddress != 0 ||
1644 alts->endpoint[1].desc.bEndpointAddress != (alts->endpoint[0].desc.bSynchAddress | 0x80)) {
1645 printk(KERN_WARNING "usbaudio: device %d interface %d altsetting %d claims asynch out "
1646 "but has invalid synch pipe; treating as adaptive out\n",
1647 dev->devnum, u->interface, fmt->altsetting);
1649 u->syncpipe = usb_rcvisocpipe(dev, alts->endpoint[1].desc.bEndpointAddress & 0xf);
1650 u->syncinterval = alts->endpoint[1].desc.bRefresh;
1653 if (d->srate < fmt->sratelo)
1654 d->srate = fmt->sratelo;
1655 if (d->srate > fmt->sratehi)
1656 d->srate = fmt->sratehi;
1657 dprintk((KERN_DEBUG "usbaudio: set_format_out: usb_set_interface %u %u\n",
1658 u->interface, fmt->altsetting));
1659 if (usb_set_interface(dev, u->interface, fmt->altsetting) < 0) {
1660 printk(KERN_WARNING "usbaudio: usb_set_interface failed, device %d interface %d altsetting %d\n",
1661 dev->devnum, u->interface, fmt->altsetting);
1664 if (fmt->sratelo == fmt->sratehi)
1666 ep = usb_pipeendpoint(u->datapipe) | (u->datapipe & USB_DIR_IN);
1667 /* if endpoint has pitch control, enable it */
1668 if (fmt->attributes & 0x02) {
1670 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1671 PITCH_CONTROL << 8, ep, data, 1, HZ)) < 0) {
1672 printk(KERN_ERR "usbaudio: failure (error %d) to set output pitch control device %d interface %u endpoint 0x%x to %u\n",
1673 ret, dev->devnum, u->interface, ep, d->srate);
1677 /* if endpoint has sampling rate control, set it */
1678 if (fmt->attributes & 0x01) {
1680 data[1] = d->srate >> 8;
1681 data[2] = d->srate >> 16;
1682 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1683 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
1684 printk(KERN_ERR "usbaudio: failure (error %d) to set output sampling frequency device %d interface %u endpoint 0x%x to %u\n",
1685 ret, dev->devnum, u->interface, ep, d->srate);
1688 if ((ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
1689 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
1690 printk(KERN_ERR "usbaudio: failure (error %d) to get output sampling frequency device %d interface %u endpoint 0x%x\n",
1691 ret, dev->devnum, u->interface, ep);
1694 dprintk((KERN_DEBUG "usbaudio: set_format_out: device %d interface %d altsetting %d srate req: %u real %u\n",
1695 dev->devnum, u->interface, fmt->altsetting, d->srate, data[0] | (data[1] << 8) | (data[2] << 16)));
1696 d->srate = data[0] | (data[1] << 8) | (data[2] << 16);
1698 dprintk((KERN_DEBUG "usbaudio: set_format_out: USB format 0x%x, DMA format 0x%x srate %u\n", u->format, d->format, d->srate));
1702 static int set_format(struct usb_audiodev *s, unsigned int fmode, unsigned int fmt, unsigned int srate)
1704 int ret1 = 0, ret2 = 0;
1706 if (!(fmode & (FMODE_READ|FMODE_WRITE)))
1708 if (fmode & FMODE_READ) {
1710 s->usbin.dma.ready = 0;
1711 if (fmt == AFMT_QUERY)
1712 fmt = s->usbin.dma.format;
1714 s->usbin.dma.format = fmt;
1716 srate = s->usbin.dma.srate;
1718 s->usbin.dma.srate = srate;
1720 if (fmode & FMODE_WRITE) {
1722 s->usbout.dma.ready = 0;
1723 if (fmt == AFMT_QUERY)
1724 fmt = s->usbout.dma.format;
1726 s->usbout.dma.format = fmt;
1728 srate = s->usbout.dma.srate;
1730 s->usbout.dma.srate = srate;
1732 if (fmode & FMODE_READ)
1733 ret1 = set_format_in(s);
1734 if (fmode & FMODE_WRITE)
1735 ret2 = set_format_out(s);
1736 return ret1 ? ret1 : ret2;
1739 /* --------------------------------------------------------------------- */
1741 static int wrmixer(struct usb_mixerdev *ms, unsigned mixch, unsigned value)
1743 struct usb_device *dev = ms->state->usbdev;
1744 unsigned char data[2];
1745 struct mixerchannel *ch;
1748 if (mixch >= ms->numch)
1750 ch = &ms->ch[mixch];
1751 v3 = ch->maxval - ch->minval;
1753 v2 = (value >> 8) & 0xff;
1758 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1760 ch->value = v1 | (v2 << 8);
1761 v1 = (v1 * v3) / 100 + ch->minval;
1762 v2 = (v2 * v3) / 100 + ch->minval;
1763 switch (ch->selector) {
1764 case 0: /* mixer unit request */
1767 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1768 (ch->chnum << 8) | 1, ms->iface | (ch->unitid << 8), data, 2, HZ) < 0)
1770 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1774 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1775 ((ch->chnum + !!(ch->flags & MIXFLG_STEREOIN)) << 8) | (1 + !!(ch->flags & MIXFLG_STEREOOUT)),
1776 ms->iface | (ch->unitid << 8), data, 2, HZ) < 0)
1780 /* various feature unit controls */
1781 case VOLUME_CONTROL:
1784 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1785 (ch->selector << 8) | ch->chnum, ms->iface | (ch->unitid << 8), data, 2, HZ) < 0)
1787 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1791 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1792 (ch->selector << 8) | (ch->chnum + 1), ms->iface | (ch->unitid << 8), data, 2, HZ) < 0)
1798 case TREBLE_CONTROL:
1800 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1801 (ch->selector << 8) | ch->chnum, ms->iface | (ch->unitid << 8), data, 1, HZ) < 0)
1803 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1806 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1807 (ch->selector << 8) | (ch->chnum + 1), ms->iface | (ch->unitid << 8), data, 1, HZ) < 0)
1817 printk(KERN_ERR "usbaudio: mixer request device %u if %u unit %u ch %u selector %u failed\n",
1818 dev->devnum, ms->iface, ch->unitid, ch->chnum, ch->selector);
1822 static int get_rec_src(struct usb_mixerdev *ms)
1824 struct usb_device *dev = ms->state->usbdev;
1825 unsigned int mask = 0, retmask = 0;
1830 for (i = 0; i < ms->numch; i++) {
1831 if (!ms->ch[i].slctunitid || (mask & (1 << i)))
1833 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1834 0, ms->iface | (ms->ch[i].slctunitid << 8), &buf, 1, HZ) < 0) {
1836 printk(KERN_ERR "usbaudio: selector read request device %u if %u unit %u failed\n",
1837 dev->devnum, ms->iface, ms->ch[i].slctunitid & 0xff);
1840 for (j = i; j < ms->numch; j++) {
1841 if ((ms->ch[i].slctunitid ^ ms->ch[j].slctunitid) & 0xff)
1844 if (buf == (ms->ch[j].slctunitid >> 8))
1845 retmask |= 1 << ms->ch[j].osschannel;
1853 static int set_rec_src(struct usb_mixerdev *ms, int srcmask)
1855 struct usb_device *dev = ms->state->usbdev;
1856 unsigned int mask = 0, smask, bmask;
1861 for (i = 0; i < ms->numch; i++) {
1862 if (!ms->ch[i].slctunitid || (mask & (1 << i)))
1864 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1865 0, ms->iface | (ms->ch[i].slctunitid << 8), &buf, 1, HZ) < 0) {
1867 printk(KERN_ERR "usbaudio: selector read request device %u if %u unit %u failed\n",
1868 dev->devnum, ms->iface, ms->ch[i].slctunitid & 0xff);
1871 /* first generate smask */
1873 for (j = i; j < ms->numch; j++) {
1874 if ((ms->ch[i].slctunitid ^ ms->ch[j].slctunitid) & 0xff)
1876 smask |= 1 << ms->ch[j].osschannel;
1877 if (buf == (ms->ch[j].slctunitid >> 8))
1878 bmask |= 1 << ms->ch[j].osschannel;
1881 /* check for multiple set sources */
1882 j = hweight32(srcmask & smask);
1887 for (j = i; j < ms->numch; j++) {
1888 if ((ms->ch[i].slctunitid ^ ms->ch[j].slctunitid) & 0xff)
1890 if (!(srcmask & (1 << ms->ch[j].osschannel)))
1892 buf = ms->ch[j].slctunitid >> 8;
1893 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1894 0, ms->iface | (ms->ch[j].slctunitid << 8), &buf, 1, HZ) < 0) {
1896 printk(KERN_ERR "usbaudio: selector write request device %u if %u unit %u failed\n",
1897 dev->devnum, ms->iface, ms->ch[j].slctunitid & 0xff);
1902 return err ? -EIO : 0;
1905 /* --------------------------------------------------------------------- */
1908 * should be called with open_sem hold, so that no new processes
1909 * look at the audio device to be destroyed
1912 static void release(struct usb_audio_state *s)
1914 struct usb_audiodev *as;
1915 struct usb_mixerdev *ms;
1923 wake_up(&open_wait);
1924 while (!list_empty(&s->audiolist)) {
1925 as = list_entry(s->audiolist.next, struct usb_audiodev, list);
1926 list_del(&as->list);
1929 dmabuf_release(&as->usbin.dma);
1930 dmabuf_release(&as->usbout.dma);
1931 usb_free_urb(as->usbin.durb[0].urb);
1932 usb_free_urb(as->usbin.durb[1].urb);
1933 usb_free_urb(as->usbin.surb[0].urb);
1934 usb_free_urb(as->usbin.surb[1].urb);
1935 usb_free_urb(as->usbout.durb[0].urb);
1936 usb_free_urb(as->usbout.durb[1].urb);
1937 usb_free_urb(as->usbout.surb[0].urb);
1938 usb_free_urb(as->usbout.surb[1].urb);
1941 while (!list_empty(&s->mixerlist)) {
1942 ms = list_entry(s->mixerlist.next, struct usb_mixerdev, list);
1943 list_del(&ms->list);
1949 static inline int prog_dmabuf_in(struct usb_audiodev *as)
1952 return dmabuf_init(&as->usbin.dma);
1955 static inline int prog_dmabuf_out(struct usb_audiodev *as)
1958 return dmabuf_init(&as->usbout.dma);
1961 /* --------------------------------------------------------------------- */
1963 static int usb_audio_open_mixdev(struct inode *inode, struct file *file)
1965 unsigned int minor = iminor(inode);
1966 struct list_head *devs, *mdevs;
1967 struct usb_mixerdev *ms;
1968 struct usb_audio_state *s;
1971 for (devs = audiodevs.next; devs != &audiodevs; devs = devs->next) {
1972 s = list_entry(devs, struct usb_audio_state, audiodev);
1973 for (mdevs = s->mixerlist.next; mdevs != &s->mixerlist; mdevs = mdevs->next) {
1974 ms = list_entry(mdevs, struct usb_mixerdev, list);
1975 if (ms->dev_mixer == minor)
1987 file->private_data = ms;
1994 static int usb_audio_release_mixdev(struct inode *inode, struct file *file)
1996 struct usb_mixerdev *ms = (struct usb_mixerdev *)file->private_data;
1997 struct usb_audio_state *s;
2007 static int usb_audio_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2009 struct usb_mixerdev *ms = (struct usb_mixerdev *)file->private_data;
2011 int __user *user_arg = (int __user *)arg;
2013 if (!ms->state->usbdev)
2016 if (cmd == SOUND_MIXER_INFO) {
2019 memset(&info, 0, sizeof(info));
2020 strncpy(info.id, "USB_AUDIO", sizeof(info.id));
2021 strncpy(info.name, "USB Audio Class Driver", sizeof(info.name));
2022 info.modify_counter = ms->modcnt;
2023 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
2027 if (cmd == SOUND_OLD_MIXER_INFO) {
2028 _old_mixer_info info;
2030 memset(&info, 0, sizeof(info));
2031 strncpy(info.id, "USB_AUDIO", sizeof(info.id));
2032 strncpy(info.name, "USB Audio Class Driver", sizeof(info.name));
2033 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
2037 if (cmd == OSS_GETVERSION)
2038 return put_user(SOUND_VERSION, user_arg);
2039 if (_IOC_TYPE(cmd) != 'M' || _IOC_SIZE(cmd) != sizeof(int))
2041 if (_IOC_DIR(cmd) == _IOC_READ) {
2042 switch (_IOC_NR(cmd)) {
2043 case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
2044 val = get_rec_src(ms);
2047 return put_user(val, user_arg);
2049 case SOUND_MIXER_DEVMASK: /* Arg contains a bit for each supported device */
2050 for (val = i = 0; i < ms->numch; i++)
2051 val |= 1 << ms->ch[i].osschannel;
2052 return put_user(val, user_arg);
2054 case SOUND_MIXER_RECMASK: /* Arg contains a bit for each supported recording source */
2055 for (val = i = 0; i < ms->numch; i++)
2056 if (ms->ch[i].slctunitid)
2057 val |= 1 << ms->ch[i].osschannel;
2058 return put_user(val, user_arg);
2060 case SOUND_MIXER_STEREODEVS: /* Mixer channels supporting stereo */
2061 for (val = i = 0; i < ms->numch; i++)
2062 if (ms->ch[i].flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT))
2063 val |= 1 << ms->ch[i].osschannel;
2064 return put_user(val, user_arg);
2066 case SOUND_MIXER_CAPS:
2067 return put_user(SOUND_CAP_EXCL_INPUT, user_arg);
2071 if (i >= SOUND_MIXER_NRDEVICES)
2073 for (j = 0; j < ms->numch; j++) {
2074 if (ms->ch[j].osschannel == i) {
2075 return put_user(ms->ch[j].value, user_arg);
2081 if (_IOC_DIR(cmd) != (_IOC_READ|_IOC_WRITE))
2084 switch (_IOC_NR(cmd)) {
2085 case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
2086 if (get_user(val, user_arg))
2088 return set_rec_src(ms, val);
2092 if (i >= SOUND_MIXER_NRDEVICES)
2094 for (j = 0; j < ms->numch && ms->ch[j].osschannel != i; j++);
2097 if (get_user(val, user_arg))
2099 if (wrmixer(ms, j, val))
2101 return put_user(ms->ch[j].value, user_arg);
2105 static /*const*/ struct file_operations usb_mixer_fops = {
2106 .owner = THIS_MODULE,
2107 .llseek = no_llseek,
2108 .ioctl = usb_audio_ioctl_mixdev,
2109 .open = usb_audio_open_mixdev,
2110 .release = usb_audio_release_mixdev,
2113 /* --------------------------------------------------------------------- */
2115 static int drain_out(struct usb_audiodev *as, int nonblock)
2117 DECLARE_WAITQUEUE(wait, current);
2118 unsigned long flags;
2121 if (as->usbout.dma.mapped || !as->usbout.dma.ready)
2124 add_wait_queue(&as->usbout.dma.wait, &wait);
2126 __set_current_state(TASK_INTERRUPTIBLE);
2127 spin_lock_irqsave(&as->lock, flags);
2128 count = as->usbout.dma.count;
2129 spin_unlock_irqrestore(&as->lock, flags);
2132 if (signal_pending(current))
2135 remove_wait_queue(&as->usbout.dma.wait, &wait);
2136 set_current_state(TASK_RUNNING);
2139 tmo = 3 * HZ * count / as->usbout.dma.srate;
2140 tmo >>= AFMT_BYTESSHIFT(as->usbout.dma.format);
2141 if (!schedule_timeout(tmo + 1)) {
2142 printk(KERN_DEBUG "usbaudio: dma timed out??\n");
2146 remove_wait_queue(&as->usbout.dma.wait, &wait);
2147 set_current_state(TASK_RUNNING);
2148 if (signal_pending(current))
2149 return -ERESTARTSYS;
2153 /* --------------------------------------------------------------------- */
2155 static ssize_t usb_audio_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
2157 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2158 DECLARE_WAITQUEUE(wait, current);
2160 unsigned long flags;
2164 if (ppos != &file->f_pos)
2166 if (as->usbin.dma.mapped)
2168 if (!as->usbin.dma.ready && (ret = prog_dmabuf_in(as)))
2170 if (!access_ok(VERIFY_WRITE, buffer, count))
2172 add_wait_queue(&as->usbin.dma.wait, &wait);
2174 spin_lock_irqsave(&as->lock, flags);
2175 ptr = as->usbin.dma.rdptr;
2176 cnt = as->usbin.dma.count;
2177 /* set task state early to avoid wakeup races */
2179 __set_current_state(TASK_INTERRUPTIBLE);
2180 spin_unlock_irqrestore(&as->lock, flags);
2184 if (usbin_start(as)) {
2189 if (file->f_flags & O_NONBLOCK) {
2195 if (signal_pending(current)) {
2202 if ((err = dmabuf_copyout_user(&as->usbin.dma, ptr, buffer, cnt))) {
2208 if (ptr >= as->usbin.dma.dmasize)
2209 ptr -= as->usbin.dma.dmasize;
2210 spin_lock_irqsave(&as->lock, flags);
2211 as->usbin.dma.rdptr = ptr;
2212 as->usbin.dma.count -= cnt;
2213 spin_unlock_irqrestore(&as->lock, flags);
2218 __set_current_state(TASK_RUNNING);
2219 remove_wait_queue(&as->usbin.dma.wait, &wait);
2223 static ssize_t usb_audio_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
2225 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2226 DECLARE_WAITQUEUE(wait, current);
2228 unsigned long flags;
2230 unsigned int start_thr;
2233 if (ppos != &file->f_pos)
2235 if (as->usbout.dma.mapped)
2237 if (!as->usbout.dma.ready && (ret = prog_dmabuf_out(as)))
2239 if (!access_ok(VERIFY_READ, buffer, count))
2241 start_thr = (as->usbout.dma.srate << AFMT_BYTESSHIFT(as->usbout.dma.format)) / (1000 / (3 * DESCFRAMES));
2242 add_wait_queue(&as->usbout.dma.wait, &wait);
2245 printk(KERN_DEBUG "usb_audio_write: count %u dma: count %u rdptr %u wrptr %u dmasize %u fragsize %u flags 0x%02x taskst 0x%lx\n",
2246 count, as->usbout.dma.count, as->usbout.dma.rdptr, as->usbout.dma.wrptr, as->usbout.dma.dmasize, as->usbout.dma.fragsize,
2247 as->usbout.flags, current->state);
2249 spin_lock_irqsave(&as->lock, flags);
2250 if (as->usbout.dma.count < 0) {
2251 as->usbout.dma.count = 0;
2252 as->usbout.dma.rdptr = as->usbout.dma.wrptr;
2254 ptr = as->usbout.dma.wrptr;
2255 cnt = as->usbout.dma.dmasize - as->usbout.dma.count;
2256 /* set task state early to avoid wakeup races */
2258 __set_current_state(TASK_INTERRUPTIBLE);
2259 spin_unlock_irqrestore(&as->lock, flags);
2263 if (usbout_start(as)) {
2268 if (file->f_flags & O_NONBLOCK) {
2274 if (signal_pending(current)) {
2281 if ((err = dmabuf_copyin_user(&as->usbout.dma, ptr, buffer, cnt))) {
2287 if (ptr >= as->usbout.dma.dmasize)
2288 ptr -= as->usbout.dma.dmasize;
2289 spin_lock_irqsave(&as->lock, flags);
2290 as->usbout.dma.wrptr = ptr;
2291 as->usbout.dma.count += cnt;
2292 spin_unlock_irqrestore(&as->lock, flags);
2296 if (as->usbout.dma.count >= start_thr && usbout_start(as)) {
2302 __set_current_state(TASK_RUNNING);
2303 remove_wait_queue(&as->usbout.dma.wait, &wait);
2307 /* Called without the kernel lock - fine */
2308 static unsigned int usb_audio_poll(struct file *file, struct poll_table_struct *wait)
2310 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2311 unsigned long flags;
2312 unsigned int mask = 0;
2314 if (file->f_mode & FMODE_WRITE) {
2315 if (!as->usbout.dma.ready)
2316 prog_dmabuf_out(as);
2317 poll_wait(file, &as->usbout.dma.wait, wait);
2319 if (file->f_mode & FMODE_READ) {
2320 if (!as->usbin.dma.ready)
2322 poll_wait(file, &as->usbin.dma.wait, wait);
2324 spin_lock_irqsave(&as->lock, flags);
2325 if (file->f_mode & FMODE_READ) {
2326 if (as->usbin.dma.count >= (signed)as->usbin.dma.fragsize)
2327 mask |= POLLIN | POLLRDNORM;
2329 if (file->f_mode & FMODE_WRITE) {
2330 if (as->usbout.dma.mapped) {
2331 if (as->usbout.dma.count >= (signed)as->usbout.dma.fragsize)
2332 mask |= POLLOUT | POLLWRNORM;
2334 if ((signed)as->usbout.dma.dmasize >= as->usbout.dma.count + (signed)as->usbout.dma.fragsize)
2335 mask |= POLLOUT | POLLWRNORM;
2338 spin_unlock_irqrestore(&as->lock, flags);
2342 static int usb_audio_mmap(struct file *file, struct vm_area_struct *vma)
2344 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2349 if (vma->vm_flags & VM_WRITE) {
2350 if ((ret = prog_dmabuf_out(as)) != 0)
2352 db = &as->usbout.dma;
2353 } else if (vma->vm_flags & VM_READ) {
2354 if ((ret = prog_dmabuf_in(as)) != 0)
2356 db = &as->usbin.dma;
2361 if (vma->vm_pgoff != 0)
2364 ret = dmabuf_mmap(vma, db, vma->vm_start, vma->vm_end - vma->vm_start, vma->vm_page_prot);
2370 static int usb_audio_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2372 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2373 struct usb_audio_state *s = as->state;
2374 int __user *user_arg = (int __user *)arg;
2375 unsigned long flags;
2376 audio_buf_info abinfo;
2379 int val2, mapped, ret;
2383 mapped = ((file->f_mode & FMODE_WRITE) && as->usbout.dma.mapped) ||
2384 ((file->f_mode & FMODE_READ) && as->usbin.dma.mapped);
2387 get_user(val, (int *)arg);
2388 printk(KERN_DEBUG "usbaudio: usb_audio_ioctl cmd=%x arg=%lx *arg=%d\n", cmd, arg, val)
2391 case OSS_GETVERSION:
2392 return put_user(SOUND_VERSION, user_arg);
2394 case SNDCTL_DSP_SYNC:
2395 if (file->f_mode & FMODE_WRITE)
2396 return drain_out(as, 0/*file->f_flags & O_NONBLOCK*/);
2399 case SNDCTL_DSP_SETDUPLEX:
2402 case SNDCTL_DSP_GETCAPS:
2403 return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER |
2404 DSP_CAP_MMAP | DSP_CAP_BATCH, user_arg);
2406 case SNDCTL_DSP_RESET:
2407 if (file->f_mode & FMODE_WRITE) {
2409 as->usbout.dma.rdptr = as->usbout.dma.wrptr = as->usbout.dma.count = as->usbout.dma.total_bytes = 0;
2411 if (file->f_mode & FMODE_READ) {
2413 as->usbin.dma.rdptr = as->usbin.dma.wrptr = as->usbin.dma.count = as->usbin.dma.total_bytes = 0;
2417 case SNDCTL_DSP_SPEED:
2418 if (get_user(val, user_arg))
2425 if (set_format(as, file->f_mode, AFMT_QUERY, val))
2428 return put_user((file->f_mode & FMODE_READ) ?
2429 as->usbin.dma.srate : as->usbout.dma.srate,
2432 case SNDCTL_DSP_STEREO:
2433 if (get_user(val, user_arg))
2435 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2437 val2 |= AFMT_STEREO;
2439 val2 &= ~AFMT_STEREO;
2440 if (set_format(as, file->f_mode, val2, 0))
2444 case SNDCTL_DSP_CHANNELS:
2445 if (get_user(val, user_arg))
2448 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2450 val2 &= ~AFMT_STEREO;
2452 val2 |= AFMT_STEREO;
2453 if (set_format(as, file->f_mode, val2, 0))
2456 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2457 return put_user(AFMT_ISSTEREO(val2) ? 2 : 1, user_arg);
2459 case SNDCTL_DSP_GETFMTS: /* Returns a mask */
2460 return put_user(AFMT_U8 | AFMT_U16_LE | AFMT_U16_BE |
2461 AFMT_S8 | AFMT_S16_LE | AFMT_S16_BE, user_arg);
2463 case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
2464 if (get_user(val, user_arg))
2466 if (val != AFMT_QUERY) {
2467 if (hweight32(val) != 1)
2469 if (!(val & (AFMT_U8 | AFMT_U16_LE | AFMT_U16_BE |
2470 AFMT_S8 | AFMT_S16_LE | AFMT_S16_BE)))
2472 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2473 val |= val2 & AFMT_STEREO;
2474 if (set_format(as, file->f_mode, val, 0))
2477 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2478 return put_user(val2 & ~AFMT_STEREO, user_arg);
2480 case SNDCTL_DSP_POST:
2483 case SNDCTL_DSP_GETTRIGGER:
2485 if (file->f_mode & FMODE_READ && as->usbin.flags & FLG_RUNNING)
2486 val |= PCM_ENABLE_INPUT;
2487 if (file->f_mode & FMODE_WRITE && as->usbout.flags & FLG_RUNNING)
2488 val |= PCM_ENABLE_OUTPUT;
2489 return put_user(val, user_arg);
2491 case SNDCTL_DSP_SETTRIGGER:
2492 if (get_user(val, user_arg))
2494 if (file->f_mode & FMODE_READ) {
2495 if (val & PCM_ENABLE_INPUT) {
2496 if (!as->usbin.dma.ready && (ret = prog_dmabuf_in(as)))
2498 if (usbin_start(as))
2503 if (file->f_mode & FMODE_WRITE) {
2504 if (val & PCM_ENABLE_OUTPUT) {
2505 if (!as->usbout.dma.ready && (ret = prog_dmabuf_out(as)))
2507 if (usbout_start(as))
2514 case SNDCTL_DSP_GETOSPACE:
2515 if (!(file->f_mode & FMODE_WRITE))
2517 if (!(as->usbout.flags & FLG_RUNNING) && (val = prog_dmabuf_out(as)) != 0)
2519 spin_lock_irqsave(&as->lock, flags);
2520 abinfo.fragsize = as->usbout.dma.fragsize;
2521 abinfo.bytes = as->usbout.dma.dmasize - as->usbout.dma.count;
2522 abinfo.fragstotal = as->usbout.dma.numfrag;
2523 abinfo.fragments = abinfo.bytes >> as->usbout.dma.fragshift;
2524 spin_unlock_irqrestore(&as->lock, flags);
2525 return copy_to_user((void __user *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2527 case SNDCTL_DSP_GETISPACE:
2528 if (!(file->f_mode & FMODE_READ))
2530 if (!(as->usbin.flags & FLG_RUNNING) && (val = prog_dmabuf_in(as)) != 0)
2532 spin_lock_irqsave(&as->lock, flags);
2533 abinfo.fragsize = as->usbin.dma.fragsize;
2534 abinfo.bytes = as->usbin.dma.count;
2535 abinfo.fragstotal = as->usbin.dma.numfrag;
2536 abinfo.fragments = abinfo.bytes >> as->usbin.dma.fragshift;
2537 spin_unlock_irqrestore(&as->lock, flags);
2538 return copy_to_user((void __user *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2540 case SNDCTL_DSP_NONBLOCK:
2541 file->f_flags |= O_NONBLOCK;
2544 case SNDCTL_DSP_GETODELAY:
2545 if (!(file->f_mode & FMODE_WRITE))
2547 spin_lock_irqsave(&as->lock, flags);
2548 val = as->usbout.dma.count;
2549 spin_unlock_irqrestore(&as->lock, flags);
2550 return put_user(val, user_arg);
2552 case SNDCTL_DSP_GETIPTR:
2553 if (!(file->f_mode & FMODE_READ))
2555 spin_lock_irqsave(&as->lock, flags);
2556 cinfo.bytes = as->usbin.dma.total_bytes;
2557 cinfo.blocks = as->usbin.dma.count >> as->usbin.dma.fragshift;
2558 cinfo.ptr = as->usbin.dma.wrptr;
2559 if (as->usbin.dma.mapped)
2560 as->usbin.dma.count &= as->usbin.dma.fragsize-1;
2561 spin_unlock_irqrestore(&as->lock, flags);
2562 if (copy_to_user((void __user *)arg, &cinfo, sizeof(cinfo)))
2566 case SNDCTL_DSP_GETOPTR:
2567 if (!(file->f_mode & FMODE_WRITE))
2569 spin_lock_irqsave(&as->lock, flags);
2570 cinfo.bytes = as->usbout.dma.total_bytes;
2571 cinfo.blocks = as->usbout.dma.count >> as->usbout.dma.fragshift;
2572 cinfo.ptr = as->usbout.dma.rdptr;
2573 if (as->usbout.dma.mapped)
2574 as->usbout.dma.count &= as->usbout.dma.fragsize-1;
2575 spin_unlock_irqrestore(&as->lock, flags);
2576 if (copy_to_user((void __user *)arg, &cinfo, sizeof(cinfo)))
2580 case SNDCTL_DSP_GETBLKSIZE:
2581 if (file->f_mode & FMODE_WRITE) {
2582 if ((val = prog_dmabuf_out(as)))
2584 return put_user(as->usbout.dma.fragsize, user_arg);
2586 if ((val = prog_dmabuf_in(as)))
2588 return put_user(as->usbin.dma.fragsize, user_arg);
2590 case SNDCTL_DSP_SETFRAGMENT:
2591 if (get_user(val, user_arg))
2593 if (file->f_mode & FMODE_READ) {
2594 as->usbin.dma.ossfragshift = val & 0xffff;
2595 as->usbin.dma.ossmaxfrags = (val >> 16) & 0xffff;
2596 if (as->usbin.dma.ossfragshift < 4)
2597 as->usbin.dma.ossfragshift = 4;
2598 if (as->usbin.dma.ossfragshift > 15)
2599 as->usbin.dma.ossfragshift = 15;
2600 if (as->usbin.dma.ossmaxfrags < 4)
2601 as->usbin.dma.ossmaxfrags = 4;
2603 if (file->f_mode & FMODE_WRITE) {
2604 as->usbout.dma.ossfragshift = val & 0xffff;
2605 as->usbout.dma.ossmaxfrags = (val >> 16) & 0xffff;
2606 if (as->usbout.dma.ossfragshift < 4)
2607 as->usbout.dma.ossfragshift = 4;
2608 if (as->usbout.dma.ossfragshift > 15)
2609 as->usbout.dma.ossfragshift = 15;
2610 if (as->usbout.dma.ossmaxfrags < 4)
2611 as->usbout.dma.ossmaxfrags = 4;
2615 case SNDCTL_DSP_SUBDIVIDE:
2616 if ((file->f_mode & FMODE_READ && as->usbin.dma.subdivision) ||
2617 (file->f_mode & FMODE_WRITE && as->usbout.dma.subdivision))
2619 if (get_user(val, user_arg))
2621 if (val != 1 && val != 2 && val != 4)
2623 if (file->f_mode & FMODE_READ)
2624 as->usbin.dma.subdivision = val;
2625 if (file->f_mode & FMODE_WRITE)
2626 as->usbout.dma.subdivision = val;
2629 case SOUND_PCM_READ_RATE:
2630 return put_user((file->f_mode & FMODE_READ) ?
2631 as->usbin.dma.srate : as->usbout.dma.srate,
2634 case SOUND_PCM_READ_CHANNELS:
2635 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2636 return put_user(AFMT_ISSTEREO(val2) ? 2 : 1, user_arg);
2638 case SOUND_PCM_READ_BITS:
2639 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2640 return put_user(AFMT_IS16BIT(val2) ? 16 : 8, user_arg);
2642 case SOUND_PCM_WRITE_FILTER:
2643 case SNDCTL_DSP_SETSYNCRO:
2644 case SOUND_PCM_READ_FILTER:
2647 dprintk((KERN_DEBUG "usbaudio: usb_audio_ioctl - no command found\n"));
2648 return -ENOIOCTLCMD;
2651 static int usb_audio_open(struct inode *inode, struct file *file)
2653 unsigned int minor = iminor(inode);
2654 DECLARE_WAITQUEUE(wait, current);
2655 struct list_head *devs, *adevs;
2656 struct usb_audiodev *as;
2657 struct usb_audio_state *s;
2661 for (devs = audiodevs.next; devs != &audiodevs; devs = devs->next) {
2662 s = list_entry(devs, struct usb_audio_state, audiodev);
2663 for (adevs = s->audiolist.next; adevs != &s->audiolist; adevs = adevs->next) {
2664 as = list_entry(adevs, struct usb_audiodev, list);
2665 if (!((as->dev_audio ^ minor) & ~0xf))
2677 /* wait for device to become free */
2678 if (!(as->open_mode & file->f_mode))
2680 if (file->f_flags & O_NONBLOCK) {
2684 __set_current_state(TASK_INTERRUPTIBLE);
2685 add_wait_queue(&open_wait, &wait);
2688 __set_current_state(TASK_RUNNING);
2689 remove_wait_queue(&open_wait, &wait);
2690 if (signal_pending(current))
2691 return -ERESTARTSYS;
2693 if (file->f_mode & FMODE_READ)
2694 as->usbin.dma.ossfragshift = as->usbin.dma.ossmaxfrags = as->usbin.dma.subdivision = 0;
2695 if (file->f_mode & FMODE_WRITE)
2696 as->usbout.dma.ossfragshift = as->usbout.dma.ossmaxfrags = as->usbout.dma.subdivision = 0;
2697 if (set_format(as, file->f_mode, ((minor & 0xf) == SND_DEV_DSP16) ? AFMT_S16_LE : AFMT_U8 /* AFMT_ULAW */, 8000)) {
2701 file->private_data = as;
2702 as->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2708 static int usb_audio_release(struct inode *inode, struct file *file)
2710 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2711 struct usb_audio_state *s;
2712 struct usb_device *dev;
2717 if (file->f_mode & FMODE_WRITE)
2718 drain_out(as, file->f_flags & O_NONBLOCK);
2720 if (file->f_mode & FMODE_WRITE) {
2722 if (dev && as->usbout.interface >= 0)
2723 usb_set_interface(dev, as->usbout.interface, 0);
2724 dmabuf_release(&as->usbout.dma);
2727 if (file->f_mode & FMODE_READ) {
2729 if (dev && as->usbin.interface >= 0)
2730 usb_set_interface(dev, as->usbin.interface, 0);
2731 dmabuf_release(&as->usbin.dma);
2734 as->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
2736 wake_up(&open_wait);
2741 static /*const*/ struct file_operations usb_audio_fops = {
2742 .owner = THIS_MODULE,
2743 .llseek = no_llseek,
2744 .read = usb_audio_read,
2745 .write = usb_audio_write,
2746 .poll = usb_audio_poll,
2747 .ioctl = usb_audio_ioctl,
2748 .mmap = usb_audio_mmap,
2749 .open = usb_audio_open,
2750 .release = usb_audio_release,
2753 /* --------------------------------------------------------------------- */
2755 static int usb_audio_probe(struct usb_interface *iface,
2756 const struct usb_device_id *id);
2757 static void usb_audio_disconnect(struct usb_interface *iface);
2759 static struct usb_device_id usb_audio_ids [] = {
2760 { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
2761 .bInterfaceClass = USB_CLASS_AUDIO, .bInterfaceSubClass = 1},
2762 { } /* Terminating entry */
2765 MODULE_DEVICE_TABLE (usb, usb_audio_ids);
2767 static struct usb_driver usb_audio_driver = {
2768 .owner = THIS_MODULE,
2770 .probe = usb_audio_probe,
2771 .disconnect = usb_audio_disconnect,
2772 .id_table = usb_audio_ids,
2775 static void *find_descriptor(void *descstart, unsigned int desclen, void *after,
2776 u8 dtype, int iface, int altsetting)
2779 int ifc = -1, as = -1;
2789 if (p[1] == USB_DT_INTERFACE) {
2790 /* minimum length of interface descriptor */
2796 if (p[1] == dtype && (!after || (void *)p > after) &&
2797 (iface == -1 || iface == ifc) && (altsetting == -1 || altsetting == as)) {
2805 static void *find_csinterface_descriptor(void *descstart, unsigned int desclen, void *after, u8 dsubtype, int iface, int altsetting)
2809 p = find_descriptor(descstart, desclen, after, USB_DT_CS_INTERFACE, iface, altsetting);
2811 if (p[0] >= 3 && p[2] == dsubtype)
2813 p = find_descriptor(descstart, desclen, p, USB_DT_CS_INTERFACE, iface, altsetting);
2818 static void *find_audiocontrol_unit(void *descstart, unsigned int desclen, void *after, u8 unit, int iface)
2822 p = find_descriptor(descstart, desclen, after, USB_DT_CS_INTERFACE, iface, -1);
2824 if (p[0] >= 4 && p[2] >= INPUT_TERMINAL && p[2] <= EXTENSION_UNIT && p[3] == unit)
2826 p = find_descriptor(descstart, desclen, p, USB_DT_CS_INTERFACE, iface, -1);
2831 static void usb_audio_parsestreaming(struct usb_audio_state *s, unsigned char *buffer, unsigned int buflen, int asifin, int asifout)
2833 struct usb_device *dev = s->usbdev;
2834 struct usb_audiodev *as;
2835 struct usb_host_interface *alts;
2836 struct usb_interface *iface;
2837 struct audioformat *fp;
2838 unsigned char *fmt, *csep;
2839 unsigned int i, j, k, format, idx;
2841 if (!(as = kmalloc(sizeof(struct usb_audiodev), GFP_KERNEL)))
2843 memset(as, 0, sizeof(struct usb_audiodev));
2844 init_waitqueue_head(&as->usbin.dma.wait);
2845 init_waitqueue_head(&as->usbout.dma.wait);
2846 spin_lock_init(&as->lock);
2847 as->usbin.durb[0].urb = usb_alloc_urb (DESCFRAMES, GFP_KERNEL);
2848 as->usbin.durb[1].urb = usb_alloc_urb (DESCFRAMES, GFP_KERNEL);
2849 as->usbin.surb[0].urb = usb_alloc_urb (SYNCFRAMES, GFP_KERNEL);
2850 as->usbin.surb[1].urb = usb_alloc_urb (SYNCFRAMES, GFP_KERNEL);
2851 as->usbout.durb[0].urb = usb_alloc_urb (DESCFRAMES, GFP_KERNEL);
2852 as->usbout.durb[1].urb = usb_alloc_urb (DESCFRAMES, GFP_KERNEL);
2853 as->usbout.surb[0].urb = usb_alloc_urb (SYNCFRAMES, GFP_KERNEL);
2854 as->usbout.surb[1].urb = usb_alloc_urb (SYNCFRAMES, GFP_KERNEL);
2855 if ((!as->usbin.durb[0].urb) ||
2856 (!as->usbin.durb[1].urb) ||
2857 (!as->usbin.surb[0].urb) ||
2858 (!as->usbin.surb[1].urb) ||
2859 (!as->usbout.durb[0].urb) ||
2860 (!as->usbout.durb[1].urb) ||
2861 (!as->usbout.surb[0].urb) ||
2862 (!as->usbout.surb[1].urb)) {
2863 usb_free_urb(as->usbin.durb[0].urb);
2864 usb_free_urb(as->usbin.durb[1].urb);
2865 usb_free_urb(as->usbin.surb[0].urb);
2866 usb_free_urb(as->usbin.surb[1].urb);
2867 usb_free_urb(as->usbout.durb[0].urb);
2868 usb_free_urb(as->usbout.durb[1].urb);
2869 usb_free_urb(as->usbout.surb[0].urb);
2870 usb_free_urb(as->usbout.surb[1].urb);
2875 as->usbin.interface = asifin;
2876 as->usbout.interface = asifout;
2877 /* search for input formats */
2879 as->usbin.flags = FLG_CONNECTED;
2880 iface = usb_ifnum_to_if(dev, asifin);
2881 for (idx = 0; idx < iface->num_altsetting; idx++) {
2882 alts = &iface->altsetting[idx];
2883 i = alts->desc.bAlternateSetting;
2884 if (alts->desc.bInterfaceClass != USB_CLASS_AUDIO || alts->desc.bInterfaceSubClass != 2)
2886 if (alts->desc.bNumEndpoints < 1) {
2887 if (i != 0) { /* altsetting 0 has no endpoints (Section B.3.4.1) */
2888 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u does not have an endpoint\n",
2889 dev->devnum, asifin, i);
2893 if ((alts->endpoint[0].desc.bmAttributes & 0x03) != 0x01 ||
2894 !(alts->endpoint[0].desc.bEndpointAddress & 0x80)) {
2895 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u first endpoint not isochronous in\n",
2896 dev->devnum, asifin, i);
2899 fmt = find_csinterface_descriptor(buffer, buflen, NULL, AS_GENERAL, asifin, i);
2901 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
2902 dev->devnum, asifin, i);
2905 if (fmt[0] < 7 || fmt[6] != 0 || (fmt[5] != 1 && fmt[5] != 2)) {
2906 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u format not supported\n",
2907 dev->devnum, asifin, i);
2910 format = (fmt[5] == 2) ? (AFMT_U16_LE | AFMT_U8) : (AFMT_S16_LE | AFMT_S8);
2911 fmt = find_csinterface_descriptor(buffer, buflen, NULL, FORMAT_TYPE, asifin, i);
2913 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
2914 dev->devnum, asifin, i);
2917 if (fmt[0] < 8+3*(fmt[7] ? fmt[7] : 2) || fmt[3] != 1) {
2918 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not supported\n",
2919 dev->devnum, asifin, i);
2922 if (fmt[4] < 1 || fmt[4] > 2 || fmt[5] < 1 || fmt[5] > 2) {
2923 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u unsupported channels %u framesize %u\n",
2924 dev->devnum, asifin, i, fmt[4], fmt[5]);
2927 csep = find_descriptor(buffer, buflen, NULL, USB_DT_CS_ENDPOINT, asifin, i);
2928 if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
2929 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u no or invalid class specific endpoint descriptor\n",
2930 dev->devnum, asifin, i);
2933 if (as->numfmtin >= MAXFORMATS)
2935 fp = &as->fmtin[as->numfmtin++];
2937 format &= (AFMT_U16_LE | AFMT_S16_LE);
2939 format &= (AFMT_U8 | AFMT_S8);
2941 format |= AFMT_STEREO;
2942 fp->format = format;
2944 fp->sratelo = fp->sratehi = fmt[8] | (fmt[9] << 8) | (fmt[10] << 16);
2945 printk(KERN_INFO "usbaudio: valid input sample rate %u\n", fp->sratelo);
2946 for (j = fmt[7] ? (fmt[7]-1) : 1; j > 0; j--) {
2947 k = fmt[8+3*j] | (fmt[9+3*j] << 8) | (fmt[10+3*j] << 16);
2948 printk(KERN_INFO "usbaudio: valid input sample rate %u\n", k);
2949 if (k > fp->sratehi)
2951 if (k < fp->sratelo)
2954 fp->attributes = csep[3];
2955 printk(KERN_INFO "usbaudio: device %u interface %u altsetting %u: format 0x%08x sratelo %u sratehi %u attributes 0x%02x\n",
2956 dev->devnum, asifin, i, fp->format, fp->sratelo, fp->sratehi, fp->attributes);
2959 /* search for output formats */
2961 as->usbout.flags = FLG_CONNECTED;
2962 iface = usb_ifnum_to_if(dev, asifout);
2963 for (idx = 0; idx < iface->num_altsetting; idx++) {
2964 alts = &iface->altsetting[idx];
2965 i = alts->desc.bAlternateSetting;
2966 if (alts->desc.bInterfaceClass != USB_CLASS_AUDIO || alts->desc.bInterfaceSubClass != 2)
2968 if (alts->desc.bNumEndpoints < 1) {
2969 /* altsetting 0 should never have iso EPs */
2971 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u does not have an endpoint\n",
2972 dev->devnum, asifout, i);
2975 if ((alts->endpoint[0].desc.bmAttributes & 0x03) != 0x01 ||
2976 (alts->endpoint[0].desc.bEndpointAddress & 0x80)) {
2977 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u first endpoint not isochronous out\n",
2978 dev->devnum, asifout, i);
2981 /* See USB audio formats manual, section 2 */
2982 fmt = find_csinterface_descriptor(buffer, buflen, NULL, AS_GENERAL, asifout, i);
2984 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
2985 dev->devnum, asifout, i);
2988 if (fmt[0] < 7 || fmt[6] != 0 || (fmt[5] != 1 && fmt[5] != 2)) {
2989 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u format not supported\n",
2990 dev->devnum, asifout, i);
2993 format = (fmt[5] == 2) ? (AFMT_U16_LE | AFMT_U8) : (AFMT_S16_LE | AFMT_S8);
2994 /* Dallas DS4201 workaround */
2995 if (dev->descriptor.idVendor == 0x04fa && dev->descriptor.idProduct == 0x4201)
2996 format = (AFMT_S16_LE | AFMT_S8);
2997 fmt = find_csinterface_descriptor(buffer, buflen, NULL, FORMAT_TYPE, asifout, i);
2999 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
3000 dev->devnum, asifout, i);
3003 if (fmt[0] < 8+3*(fmt[7] ? fmt[7] : 2) || fmt[3] != 1) {
3004 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not supported\n",
3005 dev->devnum, asifout, i);
3008 if (fmt[4] < 1 || fmt[4] > 2 || fmt[5] < 1 || fmt[5] > 2) {
3009 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u unsupported channels %u framesize %u\n",
3010 dev->devnum, asifout, i, fmt[4], fmt[5]);
3013 csep = find_descriptor(buffer, buflen, NULL, USB_DT_CS_ENDPOINT, asifout, i);
3014 if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
3015 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u no or invalid class specific endpoint descriptor\n",
3016 dev->devnum, asifout, i);
3019 if (as->numfmtout >= MAXFORMATS)
3021 fp = &as->fmtout[as->numfmtout++];
3023 format &= (AFMT_U16_LE | AFMT_S16_LE);
3025 format &= (AFMT_U8 | AFMT_S8);
3027 format |= AFMT_STEREO;
3028 fp->format = format;
3030 fp->sratelo = fp->sratehi = fmt[8] | (fmt[9] << 8) | (fmt[10] << 16);
3031 printk(KERN_INFO "usbaudio: valid output sample rate %u\n", fp->sratelo);
3032 for (j = fmt[7] ? (fmt[7]-1) : 1; j > 0; j--) {
3033 k = fmt[8+3*j] | (fmt[9+3*j] << 8) | (fmt[10+3*j] << 16);
3034 printk(KERN_INFO "usbaudio: valid output sample rate %u\n", k);
3035 if (k > fp->sratehi)
3037 if (k < fp->sratelo)
3040 fp->attributes = csep[3];
3041 printk(KERN_INFO "usbaudio: device %u interface %u altsetting %u: format 0x%08x sratelo %u sratehi %u attributes 0x%02x\n",
3042 dev->devnum, asifout, i, fp->format, fp->sratelo, fp->sratehi, fp->attributes);
3045 if (as->numfmtin == 0 && as->numfmtout == 0) {
3046 usb_free_urb(as->usbin.durb[0].urb);
3047 usb_free_urb(as->usbin.durb[1].urb);
3048 usb_free_urb(as->usbin.surb[0].urb);
3049 usb_free_urb(as->usbin.surb[1].urb);
3050 usb_free_urb(as->usbout.durb[0].urb);
3051 usb_free_urb(as->usbout.durb[1].urb);
3052 usb_free_urb(as->usbout.surb[0].urb);
3053 usb_free_urb(as->usbout.surb[1].urb);
3057 if ((as->dev_audio = register_sound_dsp(&usb_audio_fops, -1)) < 0) {
3058 printk(KERN_ERR "usbaudio: cannot register dsp\n");
3059 usb_free_urb(as->usbin.durb[0].urb);
3060 usb_free_urb(as->usbin.durb[1].urb);
3061 usb_free_urb(as->usbin.surb[0].urb);
3062 usb_free_urb(as->usbin.surb[1].urb);
3063 usb_free_urb(as->usbout.durb[0].urb);
3064 usb_free_urb(as->usbout.durb[1].urb);
3065 usb_free_urb(as->usbout.surb[0].urb);
3066 usb_free_urb(as->usbout.surb[1].urb);
3070 printk(KERN_INFO "usbaudio: registered dsp 14,%d\n", as->dev_audio);
3071 /* everything successful */
3072 list_add_tail(&as->list, &s->audiolist);
3075 struct consmixstate {
3076 struct usb_audio_state *s;
3077 unsigned char *buffer;
3078 unsigned int buflen;
3079 unsigned int ctrlif;
3080 struct mixerchannel mixch[SOUND_MIXER_NRDEVICES];
3081 unsigned int nrmixch;
3082 unsigned int mixchmask;
3083 unsigned long unitbitmap[32/sizeof(unsigned long)];
3085 unsigned int nrchannels;
3086 unsigned int termtype;
3087 unsigned int chconfig;
3090 static struct mixerchannel *getmixchannel(struct consmixstate *state, unsigned int nr)
3092 struct mixerchannel *c;
3094 if (nr >= SOUND_MIXER_NRDEVICES) {
3095 printk(KERN_ERR "usbaudio: invalid OSS mixer channel %u\n", nr);
3098 if (!(state->mixchmask & (1 << nr))) {
3099 printk(KERN_WARNING "usbaudio: OSS mixer channel %u already in use\n", nr);
3102 c = &state->mixch[state->nrmixch++];
3104 state->mixchmask &= ~(1 << nr);
3108 static unsigned int getvolchannel(struct consmixstate *state)
3112 if ((state->termtype & 0xff00) == 0x0000 && (state->mixchmask & SOUND_MASK_VOLUME))
3113 return SOUND_MIXER_VOLUME;
3114 if ((state->termtype & 0xff00) == 0x0100) {
3115 if (state->mixchmask & SOUND_MASK_PCM)
3116 return SOUND_MIXER_PCM;
3117 if (state->mixchmask & SOUND_MASK_ALTPCM)
3118 return SOUND_MIXER_ALTPCM;
3120 if ((state->termtype & 0xff00) == 0x0200 && (state->mixchmask & SOUND_MASK_MIC))
3121 return SOUND_MIXER_MIC;
3122 if ((state->termtype & 0xff00) == 0x0300 && (state->mixchmask & SOUND_MASK_SPEAKER))
3123 return SOUND_MIXER_SPEAKER;
3124 if ((state->termtype & 0xff00) == 0x0500) {
3125 if (state->mixchmask & SOUND_MASK_PHONEIN)
3126 return SOUND_MIXER_PHONEIN;
3127 if (state->mixchmask & SOUND_MASK_PHONEOUT)
3128 return SOUND_MIXER_PHONEOUT;
3130 if (state->termtype >= 0x710 && state->termtype <= 0x711 && (state->mixchmask & SOUND_MASK_RADIO))
3131 return SOUND_MIXER_RADIO;
3132 if (state->termtype >= 0x709 && state->termtype <= 0x70f && (state->mixchmask & SOUND_MASK_VIDEO))
3133 return SOUND_MIXER_VIDEO;
3134 u = ffs(state->mixchmask & (SOUND_MASK_LINE | SOUND_MASK_CD | SOUND_MASK_LINE1 | SOUND_MASK_LINE2 | SOUND_MASK_LINE3 |
3135 SOUND_MASK_DIGITAL1 | SOUND_MASK_DIGITAL2 | SOUND_MASK_DIGITAL3));
3139 static void prepmixch(struct consmixstate *state)
3141 struct usb_device *dev = state->s->usbdev;
3142 struct mixerchannel *ch;
3143 unsigned char buf[2];
3145 unsigned int v2, v3;
3147 if (!state->nrmixch || state->nrmixch > SOUND_MIXER_NRDEVICES)
3149 ch = &state->mixch[state->nrmixch-1];
3150 switch (ch->selector) {
3151 case 0: /* mixer unit request */
3152 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MIN, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3153 (ch->chnum << 8) | 1, state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3155 ch->minval = buf[0] | (buf[1] << 8);
3156 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MAX, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3157 (ch->chnum << 8) | 1, state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3159 ch->maxval = buf[0] | (buf[1] << 8);
3160 v2 = ch->maxval - ch->minval;
3163 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3164 (ch->chnum << 8) | 1, state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3166 v1 = buf[0] | (buf[1] << 8);
3167 v3 = v1 - ch->minval;
3172 if (ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)) {
3173 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3174 ((ch->chnum + !!(ch->flags & MIXFLG_STEREOIN)) << 8) | (1 + !!(ch->flags & MIXFLG_STEREOOUT)),
3175 state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3177 v1 = buf[0] | (buf[1] << 8);
3178 v3 = v1 - ch->minval;
3183 ch->value |= v3 << 8;
3186 /* various feature unit controls */
3187 case VOLUME_CONTROL:
3188 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MIN, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3189 (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3191 ch->minval = buf[0] | (buf[1] << 8);
3192 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MAX, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3193 (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3195 ch->maxval = buf[0] | (buf[1] << 8);
3196 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3197 (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3199 v1 = buf[0] | (buf[1] << 8);
3200 v2 = ch->maxval - ch->minval;
3201 v3 = v1 - ch->minval;
3208 if (ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)) {
3209 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3210 (ch->selector << 8) | (ch->chnum + 1), state->ctrlif | (ch->unitid << 8), buf, 2, HZ) < 0)
3212 v1 = buf[0] | (buf[1] << 8);
3213 v3 = v1 - ch->minval;
3218 ch->value |= v3 << 8;
3223 case TREBLE_CONTROL:
3224 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MIN, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3225 (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 1, HZ) < 0)
3227 ch->minval = buf[0] << 8;
3228 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MAX, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3229 (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 1, HZ) < 0)
3231 ch->maxval = buf[0] << 8;
3232 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3233 (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 1, HZ) < 0)
3236 v2 = ch->maxval - ch->minval;
3237 v3 = v1 - ch->minval;
3244 if (ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)) {
3245 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3246 (ch->selector << 8) | (ch->chnum + 1), state->ctrlif | (ch->unitid << 8), buf, 1, HZ) < 0)
3249 v3 = v1 - ch->minval;
3254 ch->value |= v3 << 8;
3263 printk(KERN_ERR "usbaudio: mixer request device %u if %u unit %u ch %u selector %u failed\n",
3264 dev->devnum, state->ctrlif, ch->unitid, ch->chnum, ch->selector);
3270 static void usb_audio_recurseunit(struct consmixstate *state, unsigned char unitid);
3272 static inline int checkmixbmap(unsigned char *bmap, unsigned char flg, unsigned int inidx, unsigned int numoch)
3277 if (!(bmap[-(idx >> 3)] & (0x80 >> (idx & 7))))
3279 if (!(flg & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
3281 idx = (inidx+!!(flg & MIXFLG_STEREOIN))*numoch+!!(flg & MIXFLG_STEREOOUT);
3282 if (!(bmap[-(idx >> 3)] & (0x80 >> (idx & 7))))
3287 static void usb_audio_mixerunit(struct consmixstate *state, unsigned char *mixer)
3289 unsigned int nroutch = mixer[5+mixer[4]];
3290 unsigned int chidx[SOUND_MIXER_NRDEVICES+1];
3291 unsigned int termt[SOUND_MIXER_NRDEVICES];
3292 unsigned char flg = (nroutch >= 2) ? MIXFLG_STEREOOUT : 0;
3293 unsigned char *bmap = &mixer[9+mixer[4]];
3294 unsigned int bmapsize;
3295 struct mixerchannel *ch;
3299 printk(KERN_ERR "usbaudio: unit %u invalid MIXER_UNIT descriptor\n", mixer[3]);
3302 if (mixer[4] > SOUND_MIXER_NRDEVICES) {
3303 printk(KERN_ERR "usbaudio: mixer unit %u: too many input pins\n", mixer[3]);
3307 for (i = 0; i < mixer[4]; i++) {
3308 usb_audio_recurseunit(state, mixer[5+i]);
3309 chidx[i+1] = chidx[i] + state->nrchannels;
3310 termt[i] = state->termtype;
3312 state->termtype = 0;
3313 state->chconfig = mixer[6+mixer[4]] | (mixer[7+mixer[4]] << 8);
3314 bmapsize = (nroutch * chidx[mixer[4]] + 7) >> 3;
3315 bmap += bmapsize - 1;
3316 if (mixer[0] < 10+mixer[4]+bmapsize) {
3317 printk(KERN_ERR "usbaudio: unit %u invalid MIXER_UNIT descriptor (bitmap too small)\n", mixer[3]);
3320 for (i = 0; i < mixer[4]; i++) {
3321 state->termtype = termt[i];
3322 if (chidx[i+1]-chidx[i] >= 2) {
3323 flg |= MIXFLG_STEREOIN;
3324 if (checkmixbmap(bmap, flg, chidx[i], nroutch)) {
3325 ch = getmixchannel(state, getvolchannel(state));
3327 ch->unitid = mixer[3];
3329 ch->chnum = chidx[i]+1;
3336 flg &= ~MIXFLG_STEREOIN;
3337 if (checkmixbmap(bmap, flg, chidx[i], nroutch)) {
3338 ch = getmixchannel(state, getvolchannel(state));
3340 ch->unitid = mixer[3];
3342 ch->chnum = chidx[i]+1;
3348 state->termtype = 0;
3351 static struct mixerchannel *slctsrc_findunit(struct consmixstate *state, __u8 unitid)
3355 for (i = 0; i < state->nrmixch; i++)
3356 if (state->mixch[i].unitid == unitid)
3357 return &state->mixch[i];
3361 static void usb_audio_selectorunit(struct consmixstate *state, unsigned char *selector)
3363 unsigned int chnum, i, mixch;
3364 struct mixerchannel *mch;
3367 printk(KERN_ERR "usbaudio: unit %u invalid SELECTOR_UNIT descriptor\n", selector[3]);
3370 mixch = state->nrmixch;
3371 usb_audio_recurseunit(state, selector[5]);
3372 if (state->nrmixch != mixch) {
3373 mch = &state->mixch[state->nrmixch-1];
3374 mch->slctunitid = selector[3] | (1 << 8);
3375 } else if ((mch = slctsrc_findunit(state, selector[5]))) {
3376 mch->slctunitid = selector[3] | (1 << 8);
3378 printk(KERN_INFO "usbaudio: selector unit %u: ignoring channel 1\n", selector[3]);
3380 chnum = state->nrchannels;
3381 for (i = 1; i < selector[4]; i++) {
3382 mixch = state->nrmixch;
3383 usb_audio_recurseunit(state, selector[5+i]);
3384 if (chnum != state->nrchannels) {
3385 printk(KERN_ERR "usbaudio: selector unit %u: input pins with varying channel numbers\n", selector[3]);
3386 state->termtype = 0;
3387 state->chconfig = 0;
3388 state->nrchannels = 0;
3391 if (state->nrmixch != mixch) {
3392 mch = &state->mixch[state->nrmixch-1];
3393 mch->slctunitid = selector[3] | ((i + 1) << 8);
3394 } else if ((mch = slctsrc_findunit(state, selector[5+i]))) {
3395 mch->slctunitid = selector[3] | ((i + 1) << 8);
3397 printk(KERN_INFO "usbaudio: selector unit %u: ignoring channel %u\n", selector[3], i+1);
3400 state->termtype = 0;
3401 state->chconfig = 0;
3404 /* in the future we might try to handle 3D etc. effect units */
3406 static void usb_audio_processingunit(struct consmixstate *state, unsigned char *proc)
3410 for (i = 0; i < proc[6]; i++)
3411 usb_audio_recurseunit(state, proc[7+i]);
3412 state->nrchannels = proc[7+proc[6]];
3413 state->termtype = 0;
3414 state->chconfig = proc[8+proc[6]] | (proc[9+proc[6]] << 8);
3418 /* See Audio Class Spec, section 4.3.2.5 */
3419 static void usb_audio_featureunit(struct consmixstate *state, unsigned char *ftr)
3421 struct mixerchannel *ch;
3422 unsigned short chftr, mchftr;
3424 struct usb_device *dev = state->s->usbdev;
3425 unsigned char data[1];
3427 unsigned char nr_logical_channels, i;
3429 usb_audio_recurseunit(state, ftr[4]);
3432 printk(KERN_ERR "usbaudio: wrong controls size in feature unit %u\n",ftr[3]);
3436 if (state->nrchannels == 0) {
3437 printk(KERN_ERR "usbaudio: feature unit %u source has no channels\n", ftr[3]);
3440 if (state->nrchannels > 2)
3441 printk(KERN_WARNING "usbaudio: feature unit %u: OSS mixer interface does not support more than 2 channels\n", ftr[3]);
3443 nr_logical_channels=(ftr[0]-7)/ftr[5]-1;
3445 if (nr_logical_channels != state->nrchannels) {
3446 printk(KERN_WARNING "usbaudio: warning: found %d of %d logical channels.\n", state->nrchannels,nr_logical_channels);
3448 if (state->nrchannels == 1 && nr_logical_channels==0) {
3449 printk(KERN_INFO "usbaudio: assuming the channel found is the master channel (got a Philips camera?). Should be fine.\n");
3450 } else if (state->nrchannels == 1 && nr_logical_channels==2) {
3451 printk(KERN_INFO "usbaudio: assuming that a stereo channel connected directly to a mixer is missing in search (got Labtec headset?). Should be fine.\n");
3452 state->nrchannels=nr_logical_channels;
3454 printk(KERN_WARNING "usbaudio: no idea what's going on..., contact linux-usb-devel@lists.sourceforge.net\n");
3458 /* There is always a master channel */
3460 /* Binary AND over logical channels if they exist */
3461 if (nr_logical_channels) {
3462 chftr = ftr[6+ftr[5]];
3463 for (i = 2; i <= nr_logical_channels; i++)
3464 chftr &= ftr[6+i*ftr[5]];
3469 /* volume control */
3471 ch = getmixchannel(state, getvolchannel(state));
3473 ch->unitid = ftr[3];
3474 ch->selector = VOLUME_CONTROL;
3476 ch->flags = (state->nrchannels > 1) ? (MIXFLG_STEREOIN | MIXFLG_STEREOOUT) : 0;
3479 } else if (mchftr & 2) {
3480 ch = getmixchannel(state, getvolchannel(state));
3482 ch->unitid = ftr[3];
3483 ch->selector = VOLUME_CONTROL;
3491 ch = getmixchannel(state, SOUND_MIXER_BASS);
3493 ch->unitid = ftr[3];
3494 ch->selector = BASS_CONTROL;
3496 ch->flags = (state->nrchannels > 1) ? (MIXFLG_STEREOIN | MIXFLG_STEREOOUT) : 0;
3499 } else if (mchftr & 4) {
3500 ch = getmixchannel(state, SOUND_MIXER_BASS);
3502 ch->unitid = ftr[3];
3503 ch->selector = BASS_CONTROL;
3509 /* treble control */
3511 ch = getmixchannel(state, SOUND_MIXER_TREBLE);
3513 ch->unitid = ftr[3];
3514 ch->selector = TREBLE_CONTROL;
3516 ch->flags = (state->nrchannels > 1) ? (MIXFLG_STEREOIN | MIXFLG_STEREOOUT) : 0;
3519 } else if (mchftr & 16) {
3520 ch = getmixchannel(state, SOUND_MIXER_TREBLE);
3522 ch->unitid = ftr[3];
3523 ch->selector = TREBLE_CONTROL;
3530 /* if there are mute controls, unmute them */
3531 /* does not seem to be necessary, and the Dallas chip does not seem to support the "all" channel (255) */
3532 if ((chftr & 1) || (mchftr & 1)) {
3533 printk(KERN_DEBUG "usbaudio: unmuting feature unit %u interface %u\n", ftr[3], state->ctrlif);
3535 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
3536 (MUTE_CONTROL << 8) | 0xff, state->ctrlif | (ftr[3] << 8), data, 1, HZ) < 0)
3537 printk(KERN_WARNING "usbaudio: failure to unmute feature unit %u interface %u\n", ftr[3], state->ctrlif);
3542 static void usb_audio_recurseunit(struct consmixstate *state, unsigned char unitid)
3547 if (test_and_set_bit(unitid, state->unitbitmap)) {
3548 printk(KERN_INFO "usbaudio: mixer path revisits unit %d\n", unitid);
3551 p1 = find_audiocontrol_unit(state->buffer, state->buflen, NULL, unitid, state->ctrlif);
3553 printk(KERN_ERR "usbaudio: unit %d not found!\n", unitid);
3556 state->nrchannels = 0;
3557 state->termtype = 0;
3558 state->chconfig = 0;
3560 case INPUT_TERMINAL:
3562 printk(KERN_ERR "usbaudio: unit %u: invalid INPUT_TERMINAL descriptor\n", unitid);
3565 state->nrchannels = p1[7];
3566 state->termtype = p1[4] | (p1[5] << 8);
3567 state->chconfig = p1[8] | (p1[9] << 8);
3571 if (p1[0] < 10 || p1[0] < 10+p1[4]) {
3572 printk(KERN_ERR "usbaudio: unit %u: invalid MIXER_UNIT descriptor\n", unitid);
3575 usb_audio_mixerunit(state, p1);
3579 if (p1[0] < 6 || p1[0] < 6+p1[4]) {
3580 printk(KERN_ERR "usbaudio: unit %u: invalid SELECTOR_UNIT descriptor\n", unitid);
3583 usb_audio_selectorunit(state, p1);
3586 case FEATURE_UNIT: /* See USB Audio Class Spec 4.3.2.5 */
3587 if (p1[0] < 7 || p1[0] < 7+p1[5]) {
3588 printk(KERN_ERR "usbaudio: unit %u: invalid FEATURE_UNIT descriptor\n", unitid);
3591 usb_audio_featureunit(state, p1);
3594 case PROCESSING_UNIT:
3595 if (p1[0] < 13 || p1[0] < 13+p1[6] || p1[0] < 13+p1[6]+p1[11+p1[6]]) {
3596 printk(KERN_ERR "usbaudio: unit %u: invalid PROCESSING_UNIT descriptor\n", unitid);
3599 usb_audio_processingunit(state, p1);
3602 case EXTENSION_UNIT:
3603 if (p1[0] < 13 || p1[0] < 13+p1[6] || p1[0] < 13+p1[6]+p1[11+p1[6]]) {
3604 printk(KERN_ERR "usbaudio: unit %u: invalid EXTENSION_UNIT descriptor\n", unitid);
3607 for (j = i = 0; i < p1[6]; i++) {
3608 usb_audio_recurseunit(state, p1[7+i]);
3610 j = state->termtype;
3611 else if (j != state->termtype)
3614 state->nrchannels = p1[7+p1[6]];
3615 state->chconfig = p1[8+p1[6]] | (p1[9+p1[6]] << 8);
3616 state->termtype = j;
3620 printk(KERN_ERR "usbaudio: unit %u: unexpected type 0x%02x\n", unitid, p1[2]);
3625 static void usb_audio_constructmixer(struct usb_audio_state *s, unsigned char *buffer, unsigned int buflen, unsigned int ctrlif, unsigned char *oterm)
3627 struct usb_mixerdev *ms;
3628 struct consmixstate state;
3630 memset(&state, 0, sizeof(state));
3633 state.mixchmask = ~0;
3634 state.buffer = buffer;
3635 state.buflen = buflen;
3636 state.ctrlif = ctrlif;
3637 set_bit(oterm[3], state.unitbitmap); /* mark terminal ID as visited */
3638 printk(KERN_DEBUG "usbaudio: constructing mixer for Terminal %u type 0x%04x\n",
3639 oterm[3], oterm[4] | (oterm[5] << 8));
3640 usb_audio_recurseunit(&state, oterm[7]);
3641 if (!state.nrmixch) {
3642 printk(KERN_INFO "usbaudio: no mixer controls found for Terminal %u\n", oterm[3]);
3645 if (!(ms = kmalloc(sizeof(struct usb_mixerdev)+state.nrmixch*sizeof(struct mixerchannel), GFP_KERNEL)))
3647 memset(ms, 0, sizeof(struct usb_mixerdev));
3648 memcpy(&ms->ch, &state.mixch, state.nrmixch*sizeof(struct mixerchannel));
3651 ms->numch = state.nrmixch;
3652 if ((ms->dev_mixer = register_sound_mixer(&usb_mixer_fops, -1)) < 0) {
3653 printk(KERN_ERR "usbaudio: cannot register mixer\n");
3657 printk(KERN_INFO "usbaudio: registered mixer 14,%d\n", ms->dev_mixer);
3658 list_add_tail(&ms->list, &s->mixerlist);
3661 /* arbitrary limit, we won't check more interfaces than this */
3662 #define USB_MAXINTERFACES 32
3664 static struct usb_audio_state *usb_audio_parsecontrol(struct usb_device *dev, unsigned char *buffer, unsigned int buflen, unsigned int ctrlif)
3666 struct usb_audio_state *s;
3667 struct usb_interface *iface;
3668 struct usb_host_interface *alt;
3669 unsigned char ifin[USB_MAXINTERFACES], ifout[USB_MAXINTERFACES];
3671 unsigned int i, j, k, numifin = 0, numifout = 0;
3673 if (!(s = kmalloc(sizeof(struct usb_audio_state), GFP_KERNEL)))
3675 memset(s, 0, sizeof(struct usb_audio_state));
3676 INIT_LIST_HEAD(&s->audiolist);
3677 INIT_LIST_HEAD(&s->mixerlist);
3681 /* find audiocontrol interface */
3682 if (!(p1 = find_csinterface_descriptor(buffer, buflen, NULL, HEADER, ctrlif, -1))) {
3683 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u no HEADER found\n",
3684 dev->devnum, ctrlif);
3687 if (p1[0] < 8 + p1[7]) {
3688 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u HEADER error\n",
3689 dev->devnum, ctrlif);
3693 printk(KERN_INFO "usbaudio: device %d audiocontrol interface %u has no AudioStreaming and MidiStreaming interfaces\n",
3694 dev->devnum, ctrlif);
3695 for (i = 0; i < p1[7]; i++) {
3697 iface = usb_ifnum_to_if(dev, j);
3699 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u does not exist\n",
3700 dev->devnum, ctrlif, j);
3703 if (iface->num_altsetting == 1) {
3704 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u has only 1 altsetting.\n", dev->devnum, ctrlif);
3707 alt = usb_altnum_to_altsetting(iface, 0);
3709 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u has no altsetting 0\n",
3710 dev->devnum, ctrlif, j);
3713 if (alt->desc.bInterfaceClass != USB_CLASS_AUDIO) {
3714 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u is not an AudioClass interface\n",
3715 dev->devnum, ctrlif, j);
3718 if (alt->desc.bInterfaceSubClass == 3) {
3719 printk(KERN_INFO "usbaudio: device %d audiocontrol interface %u interface %u MIDIStreaming not supported\n",
3720 dev->devnum, ctrlif, j);
3723 if (alt->desc.bInterfaceSubClass != 2) {
3724 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u invalid AudioClass subtype\n",
3725 dev->devnum, ctrlif, j);
3728 if (alt->desc.bNumEndpoints > 0) {
3729 /* Check all endpoints; should they all have a bandwidth of 0 ? */
3730 for (k = 0; k < alt->desc.bNumEndpoints; k++) {
3731 if (alt->endpoint[k].desc.wMaxPacketSize > 0) {
3732 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u endpoint %d does not have 0 bandwidth at alt[0]\n", dev->devnum, ctrlif, k);
3736 if (k < alt->desc.bNumEndpoints)
3740 alt = usb_altnum_to_altsetting(iface, 1);
3742 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u has no altsetting 1\n",
3743 dev->devnum, ctrlif, j);
3746 if (alt->desc.bNumEndpoints < 1) {
3747 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u has no endpoint\n",
3748 dev->devnum, ctrlif, j);
3751 /* note: this requires the data endpoint to be ep0 and the optional sync
3752 ep to be ep1, which seems to be the case */
3753 if (alt->endpoint[0].desc.bEndpointAddress & USB_DIR_IN) {
3754 if (numifin < USB_MAXINTERFACES) {
3755 ifin[numifin++] = j;
3756 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1);
3759 if (numifout < USB_MAXINTERFACES) {
3760 ifout[numifout++] = j;
3761 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1);
3765 printk(KERN_INFO "usbaudio: device %d audiocontrol interface %u has %u input and %u output AudioStreaming interfaces\n",
3766 dev->devnum, ctrlif, numifin, numifout);
3767 for (i = 0; i < numifin && i < numifout; i++)
3768 usb_audio_parsestreaming(s, buffer, buflen, ifin[i], ifout[i]);
3769 for (j = i; j < numifin; j++)
3770 usb_audio_parsestreaming(s, buffer, buflen, ifin[i], -1);
3771 for (j = i; j < numifout; j++)
3772 usb_audio_parsestreaming(s, buffer, buflen, -1, ifout[i]);
3773 /* now walk through all OUTPUT_TERMINAL descriptors to search for mixers */
3774 p1 = find_csinterface_descriptor(buffer, buflen, NULL, OUTPUT_TERMINAL, ctrlif, -1);
3777 usb_audio_constructmixer(s, buffer, buflen, ctrlif, p1);
3778 p1 = find_csinterface_descriptor(buffer, buflen, p1, OUTPUT_TERMINAL, ctrlif, -1);
3782 if (list_empty(&s->audiolist) && list_empty(&s->mixerlist)) {
3786 /* everything successful */
3788 list_add_tail(&s->audiodev, &audiodevs);
3790 printk(KERN_DEBUG "usb_audio_parsecontrol: usb_audio_state at %p\n", s);
3794 /* we only care for the currently active configuration */
3796 static int usb_audio_probe(struct usb_interface *intf,
3797 const struct usb_device_id *id)
3799 struct usb_device *dev = interface_to_usbdev (intf);
3800 struct usb_audio_state *s;
3801 unsigned char *buffer;
3802 unsigned int buflen;
3805 printk(KERN_DEBUG "usbaudio: Probing if %i: IC %x, ISC %x\n", ifnum,
3806 config->interface[ifnum].altsetting[0].desc.bInterfaceClass,
3807 config->interface[ifnum].altsetting[0].desc.bInterfaceSubClass);
3811 * audiocontrol interface found
3812 * find which configuration number is active
3814 buffer = dev->rawdescriptors[dev->actconfig - dev->config];
3815 buflen = dev->actconfig->desc.wTotalLength;
3816 s = usb_audio_parsecontrol(dev, buffer, buflen, intf->altsetting->desc.bInterfaceNumber);
3818 usb_set_intfdata (intf, s);
3825 /* a revoke facility would make things simpler */
3827 static void usb_audio_disconnect(struct usb_interface *intf)
3829 struct usb_audio_state *s = usb_get_intfdata (intf);
3830 struct list_head *list;
3831 struct usb_audiodev *as;
3832 struct usb_mixerdev *ms;
3837 /* we get called with -1 for every audiostreaming interface registered */
3838 if (s == (struct usb_audio_state *)-1) {
3839 dprintk((KERN_DEBUG "usbaudio: note, usb_audio_disconnect called with -1\n"));
3843 dprintk((KERN_DEBUG "usbaudio: error, usb_audio_disconnect already called for %p!\n", s));
3847 list_del_init(&s->audiodev);
3849 usb_set_intfdata (intf, NULL);
3851 /* deregister all audio and mixer devices, so no new processes can open this device */
3852 for(list = s->audiolist.next; list != &s->audiolist; list = list->next) {
3853 as = list_entry(list, struct usb_audiodev, list);
3856 wake_up(&as->usbin.dma.wait);
3857 wake_up(&as->usbout.dma.wait);
3858 if (as->dev_audio >= 0) {
3859 unregister_sound_dsp(as->dev_audio);
3860 printk(KERN_INFO "usbaudio: unregister dsp 14,%d\n", as->dev_audio);
3864 for(list = s->mixerlist.next; list != &s->mixerlist; list = list->next) {
3865 ms = list_entry(list, struct usb_mixerdev, list);
3866 if (ms->dev_mixer >= 0) {
3867 unregister_sound_mixer(ms->dev_mixer);
3868 printk(KERN_INFO "usbaudio: unregister mixer 14,%d\n", ms->dev_mixer);
3873 wake_up(&open_wait);
3876 static int __init usb_audio_init(void)
3878 int result = usb_register(&usb_audio_driver);
3880 info(DRIVER_VERSION ":" DRIVER_DESC);
3885 static void __exit usb_audio_cleanup(void)
3887 usb_deregister(&usb_audio_driver);
3890 module_init(usb_audio_init);
3891 module_exit(usb_audio_cleanup);
3893 MODULE_AUTHOR( DRIVER_AUTHOR );
3894 MODULE_DESCRIPTION( DRIVER_DESC );
3895 MODULE_LICENSE("GPL");