1 /*****************************************************************************/
4 * audio.c -- USB Audio Class driver
6 * Copyright (C) 1999, 2000, 2001
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
107 * Alan Cox and Thomas Sailer are starting to dig at opposite ends and
108 * are hoping to meet in the middle, just like tunnel diggers :)
109 * Alan tackles the descriptor parsing, Thomas the actual data IO and the
110 * OSS compatible interface.
112 * Data IO implementation issues
114 * A mmap'able ring buffer per direction is implemented, because
115 * almost every OSS app expects it. It is however impractical to
116 * transmit/receive USB data directly into and out of the ring buffer,
117 * due to alignment and synchronisation issues. Instead, the ring buffer
118 * feeds a constant time delay line that handles the USB issues.
120 * Now we first try to find an alternate setting that exactly matches
121 * the sample format requested by the user. If we find one, we do not
122 * need to perform any sample rate conversions. If there is no matching
123 * altsetting, we choose the closest one and perform sample format
124 * conversions. We never do sample rate conversion; these are too
125 * expensive to be performed in the kernel.
128 * - Pretty stable on UHCI-Acher/Fliegl/Sailer
129 * - Does not work on OHCI due to lack of OHCI driver supporting URB's
131 * Generally: Due to the brokenness of the Audio Class spec
132 * it seems generally impossible to write a generic Audio Class driver,
133 * so a reasonable driver should implement the features that are actually
136 * Parsing implementation issues
138 * One cannot reasonably parse the AudioClass descriptors linearly.
139 * Therefore the current implementation features routines to look
140 * for a specific descriptor in the descriptor list.
142 * How does the parsing work? First, all interfaces are searched
143 * for an AudioControl class interface. If found, the config descriptor
144 * that belongs to the current configuration is fetched from the device.
145 * Then the HEADER descriptor is fetched. It contains a list of
146 * all AudioStreaming and MIDIStreaming devices. This list is then walked,
147 * and all AudioStreaming interfaces are classified into input and output
148 * interfaces (according to the endpoint0 direction in altsetting1) (MIDIStreaming
149 * is currently not supported). The input & output list is then used
150 * to group inputs and outputs together and issued pairwise to the
151 * AudioStreaming class parser. Finally, all OUTPUT_TERMINAL descriptors
152 * are walked and issued to the mixer construction routine.
154 * The AudioStreaming parser simply enumerates all altsettings belonging
155 * to the specified interface. It looks for AS_GENERAL and FORMAT_TYPE
156 * class specific descriptors to extract the sample format/sample rate
157 * data. Only sample format types PCM and PCM8 are supported right now, and
158 * only FORMAT_TYPE_I is handled. The isochronous data endpoint needs to
159 * be the first endpoint of the interface, and the optional synchronisation
160 * isochronous endpoint the second one.
162 * Mixer construction works as follows: The various TERMINAL and UNIT
163 * descriptors span a tree from the root (OUTPUT_TERMINAL) through the
164 * intermediate nodes (UNITs) to the leaves (INPUT_TERMINAL). We walk
165 * that tree in a depth first manner. FEATURE_UNITs may contribute volume,
166 * bass and treble sliders to the mixer, MIXER_UNITs volume sliders.
167 * The terminal type encoded in the INPUT_TERMINALs feeds a heuristic
168 * to determine "meaningful" OSS slider numbers, however we will see
169 * how well this works in practice. Other features are not used at the
170 * moment, they seem less often used. Also, it seems difficult at least
171 * to construct recording source switches from SELECTOR_UNITs, but
172 * since there are not many USB ADC's available, we leave that for later.
175 /*****************************************************************************/
177 #include <linux/version.h>
178 #include <linux/kernel.h>
179 #include <linux/slab.h>
180 #include <linux/string.h>
181 #include <linux/timer.h>
182 #include <linux/sched.h>
183 #include <linux/smp_lock.h>
184 #include <linux/module.h>
185 #include <linux/sound.h>
186 #include <linux/soundcard.h>
187 #include <linux/list.h>
188 #include <linux/vmalloc.h>
189 #include <linux/wrapper.h>
190 #include <linux/init.h>
191 #include <linux/poll.h>
192 #include <linux/bitops.h>
193 #include <asm/uaccess.h>
195 #include <linux/usb.h>
200 * Version Information
202 #define DRIVER_VERSION "v1.0.0"
203 #define DRIVER_AUTHOR "Alan Cox <alan@lxorguk.ukuu.org.uk>, Thomas Sailer (sailer@ife.ee.ethz.ch)"
204 #define DRIVER_DESC "USB Audio Class driver"
206 #define AUDIO_DEBUG 1
208 #define SND_DEV_DSP16 5
213 extern int abs(int __x) __attribute__ ((__const__)); /* Shut up warning */
215 /* --------------------------------------------------------------------- */
218 * Linked list of all audio devices...
220 static struct list_head audiodevs = LIST_HEAD_INIT(audiodevs);
221 static DECLARE_MUTEX(open_sem);
224 * wait queue for processes wanting to open an USB audio device
226 static DECLARE_WAIT_QUEUE_HEAD(open_wait);
229 #define MAXFORMATS MAX_ALT
230 #define DMABUFSHIFT 17 /* 128k worth of DMA buffer */
231 #define NRSGBUF (1U<<(DMABUFSHIFT-PAGE_SHIFT))
237 * - Synchronisation behaviour
238 * Don't touch this if you don't understand all of the above.
241 #define SYNCFRAMES DESCFRAMES
243 #define MIXFLG_STEREOIN 1
244 #define MIXFLG_STEREOOUT 2
246 struct mixerchannel {
248 __u16 osschannel; /* number of the OSS channel */
249 __s16 minval, maxval;
259 unsigned int sratelo;
260 unsigned int sratehi;
261 unsigned char altsetting;
262 unsigned char attributes;
266 /* buffer data format */
269 /* physical buffer */
270 unsigned char *sgbuf[NRSGBUF];
274 unsigned wrptr, rdptr;
275 unsigned total_bytes;
277 unsigned error; /* over/underrun */
278 wait_queue_head_t wait;
279 /* redundant, but makes calculations easier */
285 unsigned ossfragshift;
287 unsigned subdivision;
290 struct usb_audio_state;
292 #define FLG_URB0RUNNING 1
293 #define FLG_URB1RUNNING 2
294 #define FLG_SYNC0RUNNING 4
295 #define FLG_SYNC1RUNNING 8
296 #define FLG_RUNNING 16
297 #define FLG_CONNECTED 32
301 iso_packet_descriptor_t isoframe[DESCFRAMES];
306 iso_packet_descriptor_t isoframe[SYNCFRAMES];
310 struct usb_audiodev {
311 struct list_head list;
312 struct usb_audio_state *state;
314 /* soundcore stuff */
319 spinlock_t lock; /* DMA buffer access spinlock */
322 int interface; /* Interface number, -1 means not used */
323 unsigned int format; /* USB data format */
324 unsigned int datapipe; /* the data input pipe */
325 unsigned int syncpipe; /* the synchronisation pipe - 0 for anything but adaptive IN mode */
326 unsigned int syncinterval; /* P for adaptive IN mode, 0 otherwise */
327 unsigned int freqn; /* nominal sampling rate in USB format, i.e. fs/1000 in Q10.14 */
328 unsigned int freqmax; /* maximum sampling rate, used for buffer management */
329 unsigned int phase; /* phase accumulator */
330 unsigned int flags; /* see FLG_ defines */
332 struct my_data_urb durb[2]; /* ISO descriptors for the data endpoint */
333 struct my_sync_urb surb[2]; /* ISO sync pipe descriptor if needed */
339 int interface; /* Interface number, -1 means not used */
340 unsigned int format; /* USB data format */
341 unsigned int datapipe; /* the data input pipe */
342 unsigned int syncpipe; /* the synchronisation pipe - 0 for anything but asynchronous OUT mode */
343 unsigned int syncinterval; /* P for asynchronous OUT mode, 0 otherwise */
344 unsigned int freqn; /* nominal sampling rate in USB format, i.e. fs/1000 in Q10.14 */
345 unsigned int freqm; /* momentary sampling rate in USB format, i.e. fs/1000 in Q10.14 */
346 unsigned int freqmax; /* maximum sampling rate, used for buffer management */
347 unsigned int phase; /* phase accumulator */
348 unsigned int flags; /* see FLG_ defines */
350 struct my_data_urb durb[2]; /* ISO descriptors for the data endpoint */
351 struct my_sync_urb surb[2]; /* ISO sync pipe descriptor if needed */
357 unsigned int numfmtin, numfmtout;
358 struct audioformat fmtin[MAXFORMATS];
359 struct audioformat fmtout[MAXFORMATS];
362 struct usb_mixerdev {
363 struct list_head list;
364 struct usb_audio_state *state;
366 /* soundcore stuff */
369 unsigned char iface; /* interface number of the AudioControl interface */
371 /* USB format descriptions */
372 unsigned int numch, modcnt;
374 /* mixch is last and gets allocated dynamically */
375 struct mixerchannel ch[0];
378 struct usb_audio_state {
379 struct list_head audiodev;
382 struct usb_device *usbdev;
384 struct list_head audiolist;
385 struct list_head mixerlist;
387 unsigned count; /* usage counter; NOTE: the usb stack is also considered a user */
390 /* private audio format extensions */
391 #define AFMT_STEREO 0x80000000
392 #define AFMT_ISSTEREO(x) ((x) & AFMT_STEREO)
393 #define AFMT_IS16BIT(x) ((x) & (AFMT_S16_LE|AFMT_S16_BE|AFMT_U16_LE|AFMT_U16_BE))
394 #define AFMT_ISUNSIGNED(x) ((x) & (AFMT_U8|AFMT_U16_LE|AFMT_U16_BE))
395 #define AFMT_BYTESSHIFT(x) ((AFMT_ISSTEREO(x) ? 1 : 0) + (AFMT_IS16BIT(x) ? 1 : 0))
396 #define AFMT_BYTES(x) (1<<AFMT_BYTESSHFIT(x))
398 /* --------------------------------------------------------------------- */
400 /* prevent picking up a bogus abs macro */
402 extern inline int abs(int x)
409 /* --------------------------------------------------------------------- */
411 extern inline unsigned ld2(unsigned int x)
436 /* --------------------------------------------------------------------- */
439 * OSS compatible ring buffer management. The ring buffer may be mmap'ed into
440 * an application address space.
442 * I first used the rvmalloc stuff copied from bttv. Alan Cox did not like it, so
443 * we now use an array of pointers to a single page each. This saves us the
444 * kernel page table manipulations, but we have to do a page table alike mechanism
445 * (though only one indirection) in software.
448 static void dmabuf_release(struct dmabuf *db)
453 for(nr = 0; nr < NRSGBUF; nr++) {
454 if (!(p = db->sgbuf[nr]))
456 mem_map_unreserve(virt_to_page(p));
457 free_page((unsigned long)p);
458 db->sgbuf[nr] = NULL;
460 db->mapped = db->ready = 0;
463 static int dmabuf_init(struct dmabuf *db)
465 unsigned int nr, bytepersec, bufs;
468 /* initialize some fields */
469 db->rdptr = db->wrptr = db->total_bytes = db->count = db->error = 0;
470 /* calculate required buffer size */
471 bytepersec = db->srate << AFMT_BYTESSHIFT(db->format);
472 bufs = 1U << DMABUFSHIFT;
473 if (db->ossfragshift) {
474 if ((1000 << db->ossfragshift) < bytepersec)
475 db->fragshift = ld2(bytepersec/1000);
477 db->fragshift = db->ossfragshift;
479 db->fragshift = ld2(bytepersec/100/(db->subdivision ? db->subdivision : 1));
480 if (db->fragshift < 3)
483 db->numfrag = bufs >> db->fragshift;
484 while (db->numfrag < 4 && db->fragshift > 3) {
486 db->numfrag = bufs >> db->fragshift;
488 db->fragsize = 1 << db->fragshift;
489 if (db->ossmaxfrags >= 4 && db->ossmaxfrags < db->numfrag)
490 db->numfrag = db->ossmaxfrags;
491 db->dmasize = db->numfrag << db->fragshift;
492 for(nr = 0; nr < NRSGBUF; nr++) {
493 if (!db->sgbuf[nr]) {
494 p = (void *)get_free_page(GFP_KERNEL);
498 mem_map_reserve(virt_to_page(p));
500 memset(db->sgbuf[nr], AFMT_ISUNSIGNED(db->format) ? 0x80 : 0, PAGE_SIZE);
501 if ((nr << PAGE_SHIFT) >= db->dmasize)
504 db->bufsize = nr << PAGE_SHIFT;
506 dprintk((KERN_DEBUG "usbaudio: dmabuf_init bytepersec %d bufs %d ossfragshift %d ossmaxfrags %d "
507 "fragshift %d fragsize %d numfrag %d dmasize %d bufsize %d fmt 0x%x srate %d\n",
508 bytepersec, bufs, db->ossfragshift, db->ossmaxfrags, db->fragshift, db->fragsize,
509 db->numfrag, db->dmasize, db->bufsize, db->format, db->srate));
513 static int dmabuf_mmap(struct dmabuf *db, unsigned long start, unsigned long size, pgprot_t prot)
517 if (!db->ready || db->mapped || (start | size) & (PAGE_SIZE-1) || size > db->bufsize)
520 for(nr = 0; nr < size; nr++)
524 for(nr = 0; nr < size; nr++) {
525 if (remap_page_range(start, virt_to_phys(db->sgbuf[nr]), PAGE_SIZE, prot))
532 static void dmabuf_copyin(struct dmabuf *db, const void *buffer, unsigned int size)
534 unsigned int pgrem, rem;
536 db->total_bytes += size;
540 pgrem = ((~db->wrptr) & (PAGE_SIZE-1)) + 1;
543 rem = db->dmasize - db->wrptr;
546 memcpy((db->sgbuf[db->wrptr >> PAGE_SHIFT]) + (db->wrptr & (PAGE_SIZE-1)), buffer, pgrem);
548 (char *)buffer += pgrem;
550 if (db->wrptr >= db->dmasize)
555 static void dmabuf_copyout(struct dmabuf *db, void *buffer, unsigned int size)
557 unsigned int pgrem, rem;
559 db->total_bytes += size;
563 pgrem = ((~db->rdptr) & (PAGE_SIZE-1)) + 1;
566 rem = db->dmasize - db->rdptr;
569 memcpy(buffer, (db->sgbuf[db->rdptr >> PAGE_SHIFT]) + (db->rdptr & (PAGE_SIZE-1)), pgrem);
571 (char *)buffer += pgrem;
573 if (db->rdptr >= db->dmasize)
578 static int dmabuf_copyin_user(struct dmabuf *db, unsigned int ptr, const void *buffer, unsigned int size)
580 unsigned int pgrem, rem;
582 if (!db->ready || db->mapped)
587 pgrem = ((~ptr) & (PAGE_SIZE-1)) + 1;
590 rem = db->dmasize - ptr;
593 if (copy_from_user((db->sgbuf[ptr >> PAGE_SHIFT]) + (ptr & (PAGE_SIZE-1)), buffer, pgrem))
596 (char *)buffer += pgrem;
598 if (ptr >= db->dmasize)
603 static int dmabuf_copyout_user(struct dmabuf *db, unsigned int ptr, void *buffer, unsigned int size)
605 unsigned int pgrem, rem;
607 if (!db->ready || db->mapped)
612 pgrem = ((~ptr) & (PAGE_SIZE-1)) + 1;
615 rem = db->dmasize - ptr;
618 if (copy_to_user(buffer, (db->sgbuf[ptr >> PAGE_SHIFT]) + (ptr & (PAGE_SIZE-1)), pgrem))
621 (char *)buffer += pgrem;
623 if (ptr >= db->dmasize)
628 /* --------------------------------------------------------------------- */
630 * USB I/O code. We do sample format conversion if necessary
633 static void usbin_stop(struct usb_audiodev *as)
635 struct usbin *u = &as->usbin;
637 unsigned int i, notkilled = 1;
639 spin_lock_irqsave(&as->lock, flags);
640 u->flags &= ~FLG_RUNNING;
642 spin_unlock_irqrestore(&as->lock, flags);
643 while (i & (FLG_URB0RUNNING|FLG_URB1RUNNING|FLG_SYNC0RUNNING|FLG_SYNC1RUNNING)) {
644 set_current_state(notkilled ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
646 spin_lock_irqsave(&as->lock, flags);
648 spin_unlock_irqrestore(&as->lock, flags);
649 if (notkilled && signal_pending(current)) {
650 if (i & FLG_URB0RUNNING)
651 usb_unlink_urb(&u->durb[0].urb);
652 if (i & FLG_URB1RUNNING)
653 usb_unlink_urb(&u->durb[1].urb);
654 if (i & FLG_SYNC0RUNNING)
655 usb_unlink_urb(&u->surb[0].urb);
656 if (i & FLG_SYNC1RUNNING)
657 usb_unlink_urb(&u->surb[1].urb);
661 set_current_state(TASK_RUNNING);
662 if (u->durb[0].urb.transfer_buffer)
663 kfree(u->durb[0].urb.transfer_buffer);
664 if (u->durb[1].urb.transfer_buffer)
665 kfree(u->durb[1].urb.transfer_buffer);
666 if (u->surb[0].urb.transfer_buffer)
667 kfree(u->surb[0].urb.transfer_buffer);
668 if (u->surb[1].urb.transfer_buffer)
669 kfree(u->surb[1].urb.transfer_buffer);
670 u->durb[0].urb.transfer_buffer = u->durb[1].urb.transfer_buffer =
671 u->surb[0].urb.transfer_buffer = u->surb[1].urb.transfer_buffer = NULL;
674 static inline void usbin_release(struct usb_audiodev *as)
679 static void usbin_disc(struct usb_audiodev *as)
681 struct usbin *u = &as->usbin;
685 spin_lock_irqsave(&as->lock, flags);
686 u->flags &= ~(FLG_RUNNING | FLG_CONNECTED);
687 spin_unlock_irqrestore(&as->lock, flags);
691 static void conversion(const void *ibuf, unsigned int ifmt, void *obuf, unsigned int ofmt, void *tmp, unsigned int scnt)
698 if (AFMT_ISSTEREO(ifmt))
700 sp = ((__s16 *)tmp) + cnt;
701 switch (ifmt & ~AFMT_STEREO) {
703 for (bp = ((unsigned char *)ibuf)+cnt, i = 0; i < cnt; i++) {
706 *sp = (*bp ^ 0x80) << 8;
711 for (bp = ((unsigned char *)ibuf)+cnt, i = 0; i < cnt; i++) {
719 for (bp = ((unsigned char *)ibuf)+2*cnt, i = 0; i < cnt; i++) {
722 *sp = (bp[0] | (bp[1] << 8)) ^ 0x8000;
727 for (bp = ((unsigned char *)ibuf)+2*cnt, i = 0; i < cnt; i++) {
730 *sp = (bp[1] | (bp[0] << 8)) ^ 0x8000;
735 for (bp = ((unsigned char *)ibuf)+2*cnt, i = 0; i < cnt; i++) {
738 *sp = bp[0] | (bp[1] << 8);
743 for (bp = ((unsigned char *)ibuf)+2*cnt, i = 0; i < cnt; i++) {
746 *sp = bp[1] | (bp[0] << 8);
750 if (!AFMT_ISSTEREO(ifmt) && AFMT_ISSTEREO(ofmt)) {
751 /* expand from mono to stereo */
752 for (sp = ((__s16 *)tmp)+scnt, sp2 = ((__s16 *)tmp)+2*scnt, i = 0; i < scnt; i++) {
755 sp2[0] = sp2[1] = sp[0];
758 if (AFMT_ISSTEREO(ifmt) && !AFMT_ISSTEREO(ofmt)) {
759 /* contract from stereo to mono */
760 for (sp = sp2 = ((__s16 *)tmp), i = 0; i < scnt; i++, sp++, sp2 += 2)
761 sp[0] = (sp2[0] + sp2[1]) >> 1;
764 if (AFMT_ISSTEREO(ofmt))
767 bp = ((unsigned char *)obuf);
768 switch (ofmt & ~AFMT_STEREO) {
770 for (i = 0; i < cnt; i++, sp++, bp++)
771 *bp = (*sp >> 8) ^ 0x80;
775 for (i = 0; i < cnt; i++, sp++, bp++)
780 for (i = 0; i < cnt; i++, sp++, bp += 2) {
783 bp[1] = (s >> 8) ^ 0x80;
788 for (i = 0; i < cnt; i++, sp++, bp += 2) {
791 bp[0] = (s >> 8) ^ 0x80;
796 for (i = 0; i < cnt; i++, sp++, bp += 2) {
804 for (i = 0; i < cnt; i++, sp++, bp += 2) {
814 static void usbin_convert(struct usbin *u, unsigned char *buffer, unsigned int samples)
820 unsigned int scnt, maxs, ufmtsh, dfmtsh;
822 ufmtsh = AFMT_BYTESSHIFT(u->format);
823 dfmtsh = AFMT_BYTESSHIFT(u->dma.format);
824 maxs = (AFMT_ISSTEREO(u->dma.format | u->format)) ? 32 : 64;
825 while (samples > 0) {
829 conversion(buffer, u->format, tmp.b, u->dma.format, tmp.b, scnt);
830 dmabuf_copyin(&u->dma, tmp.b, scnt << dfmtsh);
831 buffer += scnt << ufmtsh;
836 static int usbin_prepare_desc(struct usbin *u, purb_t urb)
838 unsigned int i, maxsize, offs;
840 maxsize = (u->freqmax + 0x3fff) >> (14 - AFMT_BYTESSHIFT(u->format));
841 //printk(KERN_DEBUG "usbin_prepare_desc: maxsize %d freq 0x%x format 0x%x\n", maxsize, u->freqn, u->format);
842 for (i = offs = 0; i < DESCFRAMES; i++, offs += maxsize) {
843 urb->iso_frame_desc[i].length = maxsize;
844 urb->iso_frame_desc[i].offset = offs;
850 * return value: 0 if descriptor should be restarted, -1 otherwise
851 * convert sample format on the fly if necessary
853 static int usbin_retire_desc(struct usbin *u, purb_t urb)
855 unsigned int i, ufmtsh, dfmtsh, err = 0, cnt, scnt, dmafree;
858 ufmtsh = AFMT_BYTESSHIFT(u->format);
859 dfmtsh = AFMT_BYTESSHIFT(u->dma.format);
860 for (i = 0; i < DESCFRAMES; i++) {
861 cp = ((unsigned char *)urb->transfer_buffer) + urb->iso_frame_desc[i].offset;
862 if (urb->iso_frame_desc[i].status) {
863 dprintk((KERN_DEBUG "usbin_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
866 scnt = urb->iso_frame_desc[i].actual_length >> ufmtsh;
869 cnt = scnt << dfmtsh;
870 if (!u->dma.mapped) {
871 dmafree = u->dma.dmasize - u->dma.count;
873 scnt = dmafree >> dfmtsh;
874 cnt = scnt << dfmtsh;
879 if (u->format == u->dma.format) {
880 /* we do not need format conversion */
881 dprintk((KERN_DEBUG "usbaudio: no sample format conversion\n"));
882 dmabuf_copyin(&u->dma, cp, cnt);
884 /* we need sampling format conversion */
885 dprintk((KERN_DEBUG "usbaudio: sample format conversion %x != %x\n", u->format, u->dma.format));
886 usbin_convert(u, cp, scnt);
891 if (u->dma.count >= (signed)u->dma.fragsize)
892 wake_up(&u->dma.wait);
896 static void usbin_completed(struct urb *urb)
898 struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
899 struct usbin *u = &as->usbin;
902 int suret = USB_ST_NOERROR;
905 printk(KERN_DEBUG "usbin_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
907 if (urb == &u->durb[0].urb)
908 mask = FLG_URB0RUNNING;
909 else if (urb == &u->durb[1].urb)
910 mask = FLG_URB1RUNNING;
913 printk(KERN_ERR "usbin_completed: panic: unknown URB\n");
915 urb->dev = as->state->usbdev;
916 spin_lock_irqsave(&as->lock, flags);
917 if (!usbin_retire_desc(u, urb) &&
918 u->flags & FLG_RUNNING &&
919 !usbin_prepare_desc(u, urb) &&
920 (suret = usb_submit_urb(urb)) == USB_ST_NOERROR) {
923 u->flags &= ~(mask | FLG_RUNNING);
924 wake_up(&u->dma.wait);
925 printk(KERN_DEBUG "usbin_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret);
927 spin_unlock_irqrestore(&as->lock, flags);
931 * we output sync data
933 static int usbin_sync_prepare_desc(struct usbin *u, purb_t urb)
935 unsigned char *cp = urb->transfer_buffer;
936 unsigned int i, offs;
938 for (i = offs = 0; i < SYNCFRAMES; i++, offs += 3, cp += 3) {
939 urb->iso_frame_desc[i].length = 3;
940 urb->iso_frame_desc[i].offset = offs;
942 cp[1] = u->freqn >> 8;
943 cp[2] = u->freqn >> 16;
949 * return value: 0 if descriptor should be restarted, -1 otherwise
951 static int usbin_sync_retire_desc(struct usbin *u, purb_t urb)
955 for (i = 0; i < SYNCFRAMES; i++)
956 if (urb->iso_frame_desc[0].status)
957 dprintk((KERN_DEBUG "usbin_sync_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
961 static void usbin_sync_completed(struct urb *urb)
963 struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
964 struct usbin *u = &as->usbin;
967 int suret = USB_ST_NOERROR;
970 printk(KERN_DEBUG "usbin_sync_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
972 if (urb == &u->surb[0].urb)
973 mask = FLG_SYNC0RUNNING;
974 else if (urb == &u->surb[1].urb)
975 mask = FLG_SYNC1RUNNING;
978 printk(KERN_ERR "usbin_sync_completed: panic: unknown URB\n");
980 urb->dev = as->state->usbdev;
981 spin_lock_irqsave(&as->lock, flags);
982 if (!usbin_sync_retire_desc(u, urb) &&
983 u->flags & FLG_RUNNING &&
984 !usbin_sync_prepare_desc(u, urb) &&
985 (suret = usb_submit_urb(urb)) == USB_ST_NOERROR) {
988 u->flags &= ~(mask | FLG_RUNNING);
989 wake_up(&u->dma.wait);
990 dprintk((KERN_DEBUG "usbin_sync_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret));
992 spin_unlock_irqrestore(&as->lock, flags);
995 static int usbin_start(struct usb_audiodev *as)
997 struct usb_device *dev = as->state->usbdev;
998 struct usbin *u = &as->usbin;
1000 unsigned long flags;
1001 unsigned int maxsze, bufsz;
1004 printk(KERN_DEBUG "usbin_start: device %d ufmt 0x%08x dfmt 0x%08x srate %d\n",
1005 dev->devnum, u->format, u->dma.format, u->dma.srate);
1007 /* allocate USB storage if not already done */
1008 spin_lock_irqsave(&as->lock, flags);
1009 if (!(u->flags & FLG_CONNECTED)) {
1010 spin_unlock_irqrestore(&as->lock, flags);
1013 if (!(u->flags & FLG_RUNNING)) {
1014 spin_unlock_irqrestore(&as->lock, flags);
1015 u->freqn = ((u->dma.srate << 11) + 62) / 125; /* this will overflow at approx 2MSPS */
1016 u->freqmax = u->freqn + (u->freqn >> 2);
1018 maxsze = (u->freqmax + 0x3fff) >> (14 - AFMT_BYTESSHIFT(u->format));
1019 bufsz = DESCFRAMES * maxsze;
1020 if (u->durb[0].urb.transfer_buffer)
1021 kfree(u->durb[0].urb.transfer_buffer);
1022 u->durb[0].urb.transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1023 u->durb[0].urb.transfer_buffer_length = bufsz;
1024 if (u->durb[1].urb.transfer_buffer)
1025 kfree(u->durb[1].urb.transfer_buffer);
1026 u->durb[1].urb.transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1027 u->durb[1].urb.transfer_buffer_length = bufsz;
1029 if (u->surb[0].urb.transfer_buffer)
1030 kfree(u->surb[0].urb.transfer_buffer);
1031 u->surb[0].urb.transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1032 u->surb[0].urb.transfer_buffer_length = 3*SYNCFRAMES;
1033 if (u->surb[1].urb.transfer_buffer)
1034 kfree(u->surb[1].urb.transfer_buffer);
1035 u->surb[1].urb.transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1036 u->surb[1].urb.transfer_buffer_length = 3*SYNCFRAMES;
1038 if (!u->durb[0].urb.transfer_buffer || !u->durb[1].urb.transfer_buffer ||
1039 (u->syncpipe && (!u->surb[0].urb.transfer_buffer || !u->surb[1].urb.transfer_buffer))) {
1040 printk(KERN_ERR "usbaudio: cannot start playback device %d\n", dev->devnum);
1043 spin_lock_irqsave(&as->lock, flags);
1045 if (u->dma.count >= u->dma.dmasize && !u->dma.mapped) {
1046 spin_unlock_irqrestore(&as->lock, flags);
1049 u->flags |= FLG_RUNNING;
1050 if (!(u->flags & FLG_URB0RUNNING)) {
1051 urb = &u->durb[0].urb;
1053 urb->pipe = u->datapipe;
1054 urb->transfer_flags = USB_ISO_ASAP;
1055 urb->number_of_packets = DESCFRAMES;
1057 urb->complete = usbin_completed;
1058 if (!usbin_prepare_desc(u, urb) && !usb_submit_urb(urb))
1059 u->flags |= FLG_URB0RUNNING;
1061 u->flags &= ~FLG_RUNNING;
1063 if (u->flags & FLG_RUNNING && !(u->flags & FLG_URB1RUNNING)) {
1064 urb = &u->durb[1].urb;
1066 urb->pipe = u->datapipe;
1067 urb->transfer_flags = USB_ISO_ASAP;
1068 urb->number_of_packets = DESCFRAMES;
1070 urb->complete = usbin_completed;
1071 if (!usbin_prepare_desc(u, urb) && !usb_submit_urb(urb))
1072 u->flags |= FLG_URB1RUNNING;
1074 u->flags &= ~FLG_RUNNING;
1077 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC0RUNNING)) {
1078 urb = &u->surb[0].urb;
1080 urb->pipe = u->syncpipe;
1081 urb->transfer_flags = USB_ISO_ASAP;
1082 urb->number_of_packets = SYNCFRAMES;
1084 urb->complete = usbin_sync_completed;
1085 /* stride: u->syncinterval */
1086 if (!usbin_sync_prepare_desc(u, urb) && !usb_submit_urb(urb))
1087 u->flags |= FLG_SYNC0RUNNING;
1089 u->flags &= ~FLG_RUNNING;
1091 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC1RUNNING)) {
1092 urb = &u->surb[1].urb;
1094 urb->pipe = u->syncpipe;
1095 urb->transfer_flags = USB_ISO_ASAP;
1096 urb->number_of_packets = SYNCFRAMES;
1098 urb->complete = usbin_sync_completed;
1099 /* stride: u->syncinterval */
1100 if (!usbin_sync_prepare_desc(u, urb) && !usb_submit_urb(urb))
1101 u->flags |= FLG_SYNC1RUNNING;
1103 u->flags &= ~FLG_RUNNING;
1106 spin_unlock_irqrestore(&as->lock, flags);
1110 static void usbout_stop(struct usb_audiodev *as)
1112 struct usbout *u = &as->usbout;
1113 unsigned long flags;
1114 unsigned int i, notkilled = 1;
1116 spin_lock_irqsave(&as->lock, flags);
1117 u->flags &= ~FLG_RUNNING;
1119 spin_unlock_irqrestore(&as->lock, flags);
1120 while (i & (FLG_URB0RUNNING|FLG_URB1RUNNING|FLG_SYNC0RUNNING|FLG_SYNC1RUNNING)) {
1121 set_current_state(notkilled ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
1122 schedule_timeout(1);
1123 spin_lock_irqsave(&as->lock, flags);
1125 spin_unlock_irqrestore(&as->lock, flags);
1126 if (notkilled && signal_pending(current)) {
1127 if (i & FLG_URB0RUNNING)
1128 usb_unlink_urb(&u->durb[0].urb);
1129 if (i & FLG_URB1RUNNING)
1130 usb_unlink_urb(&u->durb[1].urb);
1131 if (i & FLG_SYNC0RUNNING)
1132 usb_unlink_urb(&u->surb[0].urb);
1133 if (i & FLG_SYNC1RUNNING)
1134 usb_unlink_urb(&u->surb[1].urb);
1138 set_current_state(TASK_RUNNING);
1139 if (u->durb[0].urb.transfer_buffer)
1140 kfree(u->durb[0].urb.transfer_buffer);
1141 if (u->durb[1].urb.transfer_buffer)
1142 kfree(u->durb[1].urb.transfer_buffer);
1143 if (u->surb[0].urb.transfer_buffer)
1144 kfree(u->surb[0].urb.transfer_buffer);
1145 if (u->surb[1].urb.transfer_buffer)
1146 kfree(u->surb[1].urb.transfer_buffer);
1147 u->durb[0].urb.transfer_buffer = u->durb[1].urb.transfer_buffer =
1148 u->surb[0].urb.transfer_buffer = u->surb[1].urb.transfer_buffer = NULL;
1151 static inline void usbout_release(struct usb_audiodev *as)
1156 static void usbout_disc(struct usb_audiodev *as)
1158 struct usbout *u = &as->usbout;
1159 unsigned long flags;
1161 spin_lock_irqsave(&as->lock, flags);
1162 u->flags &= ~(FLG_RUNNING | FLG_CONNECTED);
1163 spin_unlock_irqrestore(&as->lock, flags);
1167 static void usbout_convert(struct usbout *u, unsigned char *buffer, unsigned int samples)
1173 unsigned int scnt, maxs, ufmtsh, dfmtsh;
1175 ufmtsh = AFMT_BYTESSHIFT(u->format);
1176 dfmtsh = AFMT_BYTESSHIFT(u->dma.format);
1177 maxs = (AFMT_ISSTEREO(u->dma.format | u->format)) ? 32 : 64;
1178 while (samples > 0) {
1182 dmabuf_copyout(&u->dma, tmp.b, scnt << dfmtsh);
1183 conversion(tmp.b, u->dma.format, buffer, u->format, tmp.b, scnt);
1184 buffer += scnt << ufmtsh;
1189 static int usbout_prepare_desc(struct usbout *u, purb_t urb)
1191 unsigned int i, ufmtsh, dfmtsh, err = 0, cnt, scnt, offs;
1192 unsigned char *cp = urb->transfer_buffer;
1194 ufmtsh = AFMT_BYTESSHIFT(u->format);
1195 dfmtsh = AFMT_BYTESSHIFT(u->dma.format);
1196 for (i = offs = 0; i < DESCFRAMES; i++) {
1197 urb->iso_frame_desc[i].offset = offs;
1198 u->phase = (u->phase & 0x3fff) + u->freqm;
1199 scnt = u->phase >> 14;
1201 urb->iso_frame_desc[i].length = 0;
1204 cnt = scnt << dfmtsh;
1205 if (!u->dma.mapped) {
1206 if (cnt > u->dma.count) {
1207 scnt = u->dma.count >> dfmtsh;
1208 cnt = scnt << dfmtsh;
1211 u->dma.count -= cnt;
1213 u->dma.count += cnt;
1214 if (u->format == u->dma.format) {
1215 /* we do not need format conversion */
1216 dmabuf_copyout(&u->dma, cp, cnt);
1218 /* we need sampling format conversion */
1219 usbout_convert(u, cp, scnt);
1221 cnt = scnt << ufmtsh;
1222 urb->iso_frame_desc[i].length = cnt;
1228 if (u->dma.mapped) {
1229 if (u->dma.count >= (signed)u->dma.fragsize)
1230 wake_up(&u->dma.wait);
1232 if ((signed)u->dma.dmasize >= u->dma.count + (signed)u->dma.fragsize)
1233 wake_up(&u->dma.wait);
1235 return err ? -1 : 0;
1239 * return value: 0 if descriptor should be restarted, -1 otherwise
1241 static int usbout_retire_desc(struct usbout *u, purb_t urb)
1245 for (i = 0; i < DESCFRAMES; i++) {
1246 if (urb->iso_frame_desc[i].status) {
1247 dprintk((KERN_DEBUG "usbout_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
1254 static void usbout_completed(struct urb *urb)
1256 struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
1257 struct usbout *u = &as->usbout;
1258 unsigned long flags;
1260 int suret = USB_ST_NOERROR;
1263 printk(KERN_DEBUG "usbout_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
1265 if (urb == &u->durb[0].urb)
1266 mask = FLG_URB0RUNNING;
1267 else if (urb == &u->durb[1].urb)
1268 mask = FLG_URB1RUNNING;
1271 printk(KERN_ERR "usbout_completed: panic: unknown URB\n");
1273 urb->dev = as->state->usbdev;
1274 spin_lock_irqsave(&as->lock, flags);
1275 if (!usbout_retire_desc(u, urb) &&
1276 u->flags & FLG_RUNNING &&
1277 !usbout_prepare_desc(u, urb) &&
1278 (suret = usb_submit_urb(urb)) == USB_ST_NOERROR) {
1281 u->flags &= ~(mask | FLG_RUNNING);
1282 wake_up(&u->dma.wait);
1283 dprintk((KERN_DEBUG "usbout_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret));
1285 spin_unlock_irqrestore(&as->lock, flags);
1288 static int usbout_sync_prepare_desc(struct usbout *u, purb_t urb)
1290 unsigned int i, offs;
1292 for (i = offs = 0; i < SYNCFRAMES; i++, offs += 3) {
1293 urb->iso_frame_desc[i].length = 3;
1294 urb->iso_frame_desc[i].offset = offs;
1300 * return value: 0 if descriptor should be restarted, -1 otherwise
1302 static int usbout_sync_retire_desc(struct usbout *u, purb_t urb)
1304 unsigned char *cp = urb->transfer_buffer;
1307 for (i = 0; i < SYNCFRAMES; i++, cp += 3) {
1308 if (urb->iso_frame_desc[i].status) {
1309 dprintk((KERN_DEBUG "usbout_sync_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
1312 if (urb->iso_frame_desc[i].actual_length < 3) {
1313 dprintk((KERN_DEBUG "usbout_sync_retire_desc: frame %u length %d\n", i, urb->iso_frame_desc[i].actual_length));
1316 f = cp[0] | (cp[1] << 8) | (cp[2] << 16);
1317 if (abs(f - u->freqn) > (u->freqn >> 3) || f > u->freqmax) {
1318 printk(KERN_WARNING "usbout_sync_retire_desc: requested frequency %u (nominal %u) out of range!\n", f, u->freqn);
1326 static void usbout_sync_completed(struct urb *urb)
1328 struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
1329 struct usbout *u = &as->usbout;
1330 unsigned long flags;
1332 int suret = USB_ST_NOERROR;
1335 printk(KERN_DEBUG "usbout_sync_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
1337 if (urb == &u->surb[0].urb)
1338 mask = FLG_SYNC0RUNNING;
1339 else if (urb == &u->surb[1].urb)
1340 mask = FLG_SYNC1RUNNING;
1343 printk(KERN_ERR "usbout_sync_completed: panic: unknown URB\n");
1345 urb->dev = as->state->usbdev;
1346 spin_lock_irqsave(&as->lock, flags);
1347 if (!usbout_sync_retire_desc(u, urb) &&
1348 u->flags & FLG_RUNNING &&
1349 !usbout_sync_prepare_desc(u, urb) &&
1350 (suret = usb_submit_urb(urb)) == USB_ST_NOERROR) {
1353 u->flags &= ~(mask | FLG_RUNNING);
1354 wake_up(&u->dma.wait);
1355 dprintk((KERN_DEBUG "usbout_sync_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret));
1357 spin_unlock_irqrestore(&as->lock, flags);
1360 static int usbout_start(struct usb_audiodev *as)
1362 struct usb_device *dev = as->state->usbdev;
1363 struct usbout *u = &as->usbout;
1365 unsigned long flags;
1366 unsigned int maxsze, bufsz;
1369 printk(KERN_DEBUG "usbout_start: device %d ufmt 0x%08x dfmt 0x%08x srate %d\n",
1370 dev->devnum, u->format, u->dma.format, u->dma.srate);
1372 /* allocate USB storage if not already done */
1373 spin_lock_irqsave(&as->lock, flags);
1374 if (!(u->flags & FLG_CONNECTED)) {
1375 spin_unlock_irqrestore(&as->lock, flags);
1378 if (!(u->flags & FLG_RUNNING)) {
1379 spin_unlock_irqrestore(&as->lock, flags);
1380 u->freqn = u->freqm = ((u->dma.srate << 11) + 62) / 125; /* this will overflow at approx 2MSPS */
1381 u->freqmax = u->freqn + (u->freqn >> 2);
1383 maxsze = (u->freqmax + 0x3fff) >> (14 - AFMT_BYTESSHIFT(u->format));
1384 bufsz = DESCFRAMES * maxsze;
1385 if (u->durb[0].urb.transfer_buffer)
1386 kfree(u->durb[0].urb.transfer_buffer);
1387 u->durb[0].urb.transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1388 u->durb[0].urb.transfer_buffer_length = bufsz;
1389 if (u->durb[1].urb.transfer_buffer)
1390 kfree(u->durb[1].urb.transfer_buffer);
1391 u->durb[1].urb.transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1392 u->durb[1].urb.transfer_buffer_length = bufsz;
1394 if (u->surb[0].urb.transfer_buffer)
1395 kfree(u->surb[0].urb.transfer_buffer);
1396 u->surb[0].urb.transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1397 u->surb[0].urb.transfer_buffer_length = 3*SYNCFRAMES;
1398 if (u->surb[1].urb.transfer_buffer)
1399 kfree(u->surb[1].urb.transfer_buffer);
1400 u->surb[1].urb.transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1401 u->surb[1].urb.transfer_buffer_length = 3*SYNCFRAMES;
1403 if (!u->durb[0].urb.transfer_buffer || !u->durb[1].urb.transfer_buffer ||
1404 (u->syncpipe && (!u->surb[0].urb.transfer_buffer || !u->surb[1].urb.transfer_buffer))) {
1405 printk(KERN_ERR "usbaudio: cannot start playback device %d\n", dev->devnum);
1408 spin_lock_irqsave(&as->lock, flags);
1410 if (u->dma.count <= 0 && !u->dma.mapped) {
1411 spin_unlock_irqrestore(&as->lock, flags);
1414 u->flags |= FLG_RUNNING;
1415 if (!(u->flags & FLG_URB0RUNNING)) {
1416 urb = &u->durb[0].urb;
1418 urb->pipe = u->datapipe;
1419 urb->transfer_flags = USB_ISO_ASAP;
1420 urb->number_of_packets = DESCFRAMES;
1422 urb->complete = usbout_completed;
1423 if (!usbout_prepare_desc(u, urb) && !usb_submit_urb(urb))
1424 u->flags |= FLG_URB0RUNNING;
1426 u->flags &= ~FLG_RUNNING;
1428 if (u->flags & FLG_RUNNING && !(u->flags & FLG_URB1RUNNING)) {
1429 urb = &u->durb[1].urb;
1431 urb->pipe = u->datapipe;
1432 urb->transfer_flags = USB_ISO_ASAP;
1433 urb->number_of_packets = DESCFRAMES;
1435 urb->complete = usbout_completed;
1436 if (!usbout_prepare_desc(u, urb) && !usb_submit_urb(urb))
1437 u->flags |= FLG_URB1RUNNING;
1439 u->flags &= ~FLG_RUNNING;
1442 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC0RUNNING)) {
1443 urb = &u->surb[0].urb;
1445 urb->pipe = u->syncpipe;
1446 urb->transfer_flags = USB_ISO_ASAP;
1447 urb->number_of_packets = SYNCFRAMES;
1449 urb->complete = usbout_sync_completed;
1450 /* stride: u->syncinterval */
1451 if (!usbout_sync_prepare_desc(u, urb) && !usb_submit_urb(urb))
1452 u->flags |= FLG_SYNC0RUNNING;
1454 u->flags &= ~FLG_RUNNING;
1456 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC1RUNNING)) {
1457 urb = &u->surb[1].urb;
1459 urb->pipe = u->syncpipe;
1460 urb->transfer_flags = USB_ISO_ASAP;
1461 urb->number_of_packets = SYNCFRAMES;
1463 urb->complete = usbout_sync_completed;
1464 /* stride: u->syncinterval */
1465 if (!usbout_sync_prepare_desc(u, urb) && !usb_submit_urb(urb))
1466 u->flags |= FLG_SYNC1RUNNING;
1468 u->flags &= ~FLG_RUNNING;
1471 spin_unlock_irqrestore(&as->lock, flags);
1475 /* --------------------------------------------------------------------- */
1477 static unsigned int format_goodness(struct audioformat *afp, unsigned int fmt, unsigned int srate)
1481 if (srate < afp->sratelo)
1482 g += afp->sratelo - srate;
1483 if (srate > afp->sratehi)
1484 g += srate - afp->sratehi;
1485 if (AFMT_ISSTEREO(afp->format) && !AFMT_ISSTEREO(fmt))
1487 if (!AFMT_ISSTEREO(afp->format) && AFMT_ISSTEREO(fmt))
1489 if (AFMT_IS16BIT(afp->format) && !AFMT_IS16BIT(fmt))
1491 if (!AFMT_IS16BIT(afp->format) && AFMT_IS16BIT(fmt))
1496 static int find_format(struct audioformat *afp, unsigned int nr, unsigned int fmt, unsigned int srate)
1498 unsigned int i, g, gb = ~0;
1499 int j = -1; /* default to failure */
1501 /* find "best" format (according to format_goodness) */
1502 for (i = 0; i < nr; i++) {
1503 g = format_goodness(&afp[i], fmt, srate);
1512 static int set_format_in(struct usb_audiodev *as)
1514 struct usb_device *dev = as->state->usbdev;
1515 struct usb_config_descriptor *config = dev->actconfig;
1516 struct usb_interface_descriptor *alts;
1517 struct usb_interface *iface;
1518 struct usbin *u = &as->usbin;
1519 struct dmabuf *d = &u->dma;
1520 struct audioformat *fmt;
1522 unsigned char data[3];
1525 if (u->interface < 0 || u->interface >= config->bNumInterfaces)
1527 iface = &config->interface[u->interface];
1529 fmtnr = find_format(as->fmtin, as->numfmtin, d->format, d->srate);
1531 printk(KERN_ERR "usbaudio: set_format_in(): failed to find desired format/speed combination.\n");
1535 fmt = as->fmtin + fmtnr;
1536 alts = &iface->altsetting[fmt->altsetting];
1537 u->format = fmt->format;
1538 u->datapipe = usb_rcvisocpipe(dev, alts->endpoint[0].bEndpointAddress & 0xf);
1539 u->syncpipe = u->syncinterval = 0;
1540 if ((alts->endpoint[0].bmAttributes & 0x0c) == 0x08) {
1541 if (alts->bNumEndpoints < 2 ||
1542 alts->endpoint[1].bmAttributes != 0x01 ||
1543 alts->endpoint[1].bSynchAddress != 0 ||
1544 alts->endpoint[1].bEndpointAddress != (alts->endpoint[0].bSynchAddress & 0x7f)) {
1545 printk(KERN_ERR "usbaudio: device %d interface %d altsetting %d invalid synch pipe\n",
1546 dev->devnum, u->interface, fmt->altsetting);
1549 u->syncpipe = usb_sndisocpipe(dev, alts->endpoint[1].bEndpointAddress & 0xf);
1550 u->syncinterval = alts->endpoint[1].bRefresh;
1552 if (d->srate < fmt->sratelo)
1553 d->srate = fmt->sratelo;
1554 if (d->srate > fmt->sratehi)
1555 d->srate = fmt->sratehi;
1556 dprintk((KERN_DEBUG "usbaudio: set_format_in: usb_set_interface %u %u\n", alts->bInterfaceNumber, fmt->altsetting));
1557 if (usb_set_interface(dev, alts->bInterfaceNumber, fmt->altsetting) < 0) {
1558 printk(KERN_WARNING "usbaudio: usb_set_interface failed, device %d interface %d altsetting %d\n",
1559 dev->devnum, u->interface, fmt->altsetting);
1562 if (fmt->sratelo == fmt->sratehi)
1564 ep = usb_pipeendpoint(u->datapipe) | (u->datapipe & USB_DIR_IN);
1565 /* if endpoint has pitch control, enable it */
1566 if (fmt->attributes & 0x02) {
1568 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1569 PITCH_CONTROL << 8, ep, data, 1, HZ)) < 0) {
1570 printk(KERN_ERR "usbaudio: failure (error %d) to set output pitch control device %d interface %u endpoint 0x%x to %u\n",
1571 ret, dev->devnum, u->interface, ep, d->srate);
1575 /* if endpoint has sampling rate control, set it */
1576 if (fmt->attributes & 0x01) {
1578 data[1] = d->srate >> 8;
1579 data[2] = d->srate >> 16;
1580 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1581 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
1582 printk(KERN_ERR "usbaudio: failure (error %d) to set input sampling frequency device %d interface %u endpoint 0x%x to %u\n",
1583 ret, dev->devnum, u->interface, ep, d->srate);
1586 if ((ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
1587 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
1588 printk(KERN_ERR "usbaudio: failure (error %d) to get input sampling frequency device %d interface %u endpoint 0x%x\n",
1589 ret, dev->devnum, u->interface, ep);
1592 dprintk((KERN_DEBUG "usbaudio: set_format_in: device %d interface %d altsetting %d srate req: %u real %u\n",
1593 dev->devnum, u->interface, fmt->altsetting, d->srate, data[0] | (data[1] << 8) | (data[2] << 16)));
1594 d->srate = data[0] | (data[1] << 8) | (data[2] << 16);
1596 dprintk((KERN_DEBUG "usbaudio: set_format_in: USB format 0x%x, DMA format 0x%x srate %u\n", u->format, d->format, d->srate));
1600 static int set_format_out(struct usb_audiodev *as)
1602 struct usb_device *dev = as->state->usbdev;
1603 struct usb_config_descriptor *config = dev->actconfig;
1604 struct usb_interface_descriptor *alts;
1605 struct usb_interface *iface;
1606 struct usbout *u = &as->usbout;
1607 struct dmabuf *d = &u->dma;
1608 struct audioformat *fmt;
1610 unsigned char data[3];
1613 if (u->interface < 0 || u->interface >= config->bNumInterfaces)
1615 iface = &config->interface[u->interface];
1617 fmtnr = find_format(as->fmtout, as->numfmtout, d->format, d->srate);
1619 printk(KERN_ERR "usbaudio: set_format_out(): failed to find desired format/speed combination.\n");
1623 fmt = as->fmtout + fmtnr;
1624 u->format = fmt->format;
1625 alts = &iface->altsetting[fmt->altsetting];
1626 u->datapipe = usb_sndisocpipe(dev, alts->endpoint[0].bEndpointAddress & 0xf);
1627 u->syncpipe = u->syncinterval = 0;
1628 if ((alts->endpoint[0].bmAttributes & 0x0c) == 0x04) {
1630 printk(KERN_DEBUG "bNumEndpoints 0x%02x endpoint[1].bmAttributes 0x%02x\n"
1631 KERN_DEBUG "endpoint[1].bSynchAddress 0x%02x endpoint[1].bEndpointAddress 0x%02x\n"
1632 KERN_DEBUG "endpoint[0].bSynchAddress 0x%02x\n", alts->bNumEndpoints,
1633 alts->endpoint[1].bmAttributes, alts->endpoint[1].bSynchAddress,
1634 alts->endpoint[1].bEndpointAddress, alts->endpoint[0].bSynchAddress);
1636 if (alts->bNumEndpoints < 2 ||
1637 alts->endpoint[1].bmAttributes != 0x01 ||
1638 alts->endpoint[1].bSynchAddress != 0 ||
1639 alts->endpoint[1].bEndpointAddress != (alts->endpoint[0].bSynchAddress | 0x80)) {
1640 printk(KERN_ERR "usbaudio: device %d interface %d altsetting %d invalid synch pipe\n",
1641 dev->devnum, u->interface, fmt->altsetting);
1644 u->syncpipe = usb_rcvisocpipe(dev, alts->endpoint[1].bEndpointAddress & 0xf);
1645 u->syncinterval = alts->endpoint[1].bRefresh;
1647 if (d->srate < fmt->sratelo)
1648 d->srate = fmt->sratelo;
1649 if (d->srate > fmt->sratehi)
1650 d->srate = fmt->sratehi;
1651 dprintk((KERN_DEBUG "usbaudio: set_format_out: usb_set_interface %u %u\n", alts->bInterfaceNumber, fmt->altsetting));
1652 if (usb_set_interface(dev, u->interface, fmt->altsetting) < 0) {
1653 printk(KERN_WARNING "usbaudio: usb_set_interface failed, device %d interface %d altsetting %d\n",
1654 dev->devnum, u->interface, fmt->altsetting);
1657 if (fmt->sratelo == fmt->sratehi)
1659 ep = usb_pipeendpoint(u->datapipe) | (u->datapipe & USB_DIR_IN);
1660 /* if endpoint has pitch control, enable it */
1661 if (fmt->attributes & 0x02) {
1663 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1664 PITCH_CONTROL << 8, ep, data, 1, HZ)) < 0) {
1665 printk(KERN_ERR "usbaudio: failure (error %d) to set output pitch control device %d interface %u endpoint 0x%x to %u\n",
1666 ret, dev->devnum, u->interface, ep, d->srate);
1670 /* if endpoint has sampling rate control, set it */
1671 if (fmt->attributes & 0x01) {
1673 data[1] = d->srate >> 8;
1674 data[2] = d->srate >> 16;
1675 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1676 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
1677 printk(KERN_ERR "usbaudio: failure (error %d) to set output sampling frequency device %d interface %u endpoint 0x%x to %u\n",
1678 ret, dev->devnum, u->interface, ep, d->srate);
1681 if ((ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
1682 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, HZ)) < 0) {
1683 printk(KERN_ERR "usbaudio: failure (error %d) to get output sampling frequency device %d interface %u endpoint 0x%x\n",
1684 ret, dev->devnum, u->interface, ep);
1687 dprintk((KERN_DEBUG "usbaudio: set_format_out: device %d interface %d altsetting %d srate req: %u real %u\n",
1688 dev->devnum, u->interface, fmt->altsetting, d->srate, data[0] | (data[1] << 8) | (data[2] << 16)));
1689 d->srate = data[0] | (data[1] << 8) | (data[2] << 16);
1691 dprintk((KERN_DEBUG "usbaudio: set_format_out: USB format 0x%x, DMA format 0x%x srate %u\n", u->format, d->format, d->srate));
1695 static int set_format(struct usb_audiodev *s, unsigned int fmode, unsigned int fmt, unsigned int srate)
1697 int ret1 = 0, ret2 = 0;
1699 if (!(fmode & (FMODE_READ|FMODE_WRITE)))
1701 if (fmode & FMODE_READ) {
1703 s->usbin.dma.ready = 0;
1704 if (fmt == AFMT_QUERY)
1705 fmt = s->usbin.dma.format;
1707 s->usbin.dma.format = fmt;
1709 srate = s->usbin.dma.srate;
1711 s->usbin.dma.srate = srate;
1713 if (fmode & FMODE_WRITE) {
1715 s->usbout.dma.ready = 0;
1716 if (fmt == AFMT_QUERY)
1717 fmt = s->usbout.dma.format;
1719 s->usbout.dma.format = fmt;
1721 srate = s->usbout.dma.srate;
1723 s->usbout.dma.srate = srate;
1725 if (fmode & FMODE_READ)
1726 ret1 = set_format_in(s);
1727 if (fmode & FMODE_WRITE)
1728 ret2 = set_format_out(s);
1729 return ret1 ? ret1 : ret2;
1732 /* --------------------------------------------------------------------- */
1734 static int wrmixer(struct usb_mixerdev *ms, unsigned mixch, unsigned value)
1736 struct usb_device *dev = ms->state->usbdev;
1737 unsigned char data[2];
1738 struct mixerchannel *ch;
1741 if (mixch >= ms->numch)
1743 ch = &ms->ch[mixch];
1744 v3 = ch->maxval - ch->minval;
1746 v2 = (value >> 8) & 0xff;
1751 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1753 ch->value = v1 | (v2 << 8);
1754 v1 = (v1 * v3) / 100 + ch->minval;
1755 v2 = (v2 * v3) / 100 + ch->minval;
1756 switch (ch->selector) {
1757 case 0: /* mixer unit request */
1760 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1761 (ch->chnum << 8) | 1, ms->iface | (ch->unitid << 8), data, 2, HZ) < 0)
1763 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1767 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1768 ((ch->chnum + !!(ch->flags & MIXFLG_STEREOIN)) << 8) | (1 + !!(ch->flags & MIXFLG_STEREOOUT)),
1769 ms->iface | (ch->unitid << 8), data, 2, HZ) < 0)
1773 /* various feature unit controls */
1774 case VOLUME_CONTROL:
1777 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1778 (ch->selector << 8) | ch->chnum, ms->iface | (ch->unitid << 8), data, 2, HZ) < 0)
1780 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
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 + 1), ms->iface | (ch->unitid << 8), data, 2, HZ) < 0)
1791 case TREBLE_CONTROL:
1793 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1794 (ch->selector << 8) | ch->chnum, ms->iface | (ch->unitid << 8), data, 1, HZ) < 0)
1796 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1799 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1800 (ch->selector << 8) | (ch->chnum + 1), ms->iface | (ch->unitid << 8), data, 1, HZ) < 0)
1810 printk(KERN_ERR "usbaudio: mixer request device %u if %u unit %u ch %u selector %u failed\n",
1811 dev->devnum, ms->iface, ch->unitid, ch->chnum, ch->selector);
1815 static int get_rec_src(struct usb_mixerdev *ms)
1817 struct usb_device *dev = ms->state->usbdev;
1818 unsigned int mask = 0, retmask = 0;
1823 for (i = 0; i < ms->numch; i++) {
1824 if (!ms->ch[i].slctunitid || (mask & (1 << i)))
1826 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1827 0, ms->iface | (ms->ch[i].slctunitid << 8), &buf, 1, HZ) < 0) {
1829 printk(KERN_ERR "usbaudio: selector read request device %u if %u unit %u failed\n",
1830 dev->devnum, ms->iface, ms->ch[i].slctunitid & 0xff);
1833 for (j = i; j < ms->numch; j++) {
1834 if ((ms->ch[i].slctunitid ^ ms->ch[j].slctunitid) & 0xff)
1837 if (buf == (ms->ch[j].slctunitid >> 8))
1838 retmask |= 1 << ms->ch[j].osschannel;
1846 static int set_rec_src(struct usb_mixerdev *ms, int srcmask)
1848 struct usb_device *dev = ms->state->usbdev;
1849 unsigned int mask = 0, smask, bmask;
1854 for (i = 0; i < ms->numch; i++) {
1855 if (!ms->ch[i].slctunitid || (mask & (1 << i)))
1857 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1858 0, ms->iface | (ms->ch[i].slctunitid << 8), &buf, 1, HZ) < 0) {
1860 printk(KERN_ERR "usbaudio: selector read request device %u if %u unit %u failed\n",
1861 dev->devnum, ms->iface, ms->ch[i].slctunitid & 0xff);
1864 /* first generate smask */
1866 for (j = i; j < ms->numch; j++) {
1867 if ((ms->ch[i].slctunitid ^ ms->ch[j].slctunitid) & 0xff)
1869 smask |= 1 << ms->ch[j].osschannel;
1870 if (buf == (ms->ch[j].slctunitid >> 8))
1871 bmask |= 1 << ms->ch[j].osschannel;
1874 /* check for multiple set sources */
1875 j = hweight32(srcmask & smask);
1880 for (j = i; j < ms->numch; j++) {
1881 if ((ms->ch[i].slctunitid ^ ms->ch[j].slctunitid) & 0xff)
1883 if (!(srcmask & (1 << ms->ch[j].osschannel)))
1885 buf = ms->ch[j].slctunitid >> 8;
1886 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1887 0, ms->iface | (ms->ch[j].slctunitid << 8), &buf, 1, HZ) < 0) {
1889 printk(KERN_ERR "usbaudio: selector write request device %u if %u unit %u failed\n",
1890 dev->devnum, ms->iface, ms->ch[j].slctunitid & 0xff);
1895 return err ? -EIO : 0;
1898 /* --------------------------------------------------------------------- */
1901 * should be called with open_sem hold, so that no new processes
1902 * look at the audio device to be destroyed
1905 static void release(struct usb_audio_state *s)
1907 struct usb_audiodev *as;
1908 struct usb_mixerdev *ms;
1916 wake_up(&open_wait);
1917 while (!list_empty(&s->audiolist)) {
1918 as = list_entry(s->audiolist.next, struct usb_audiodev, list);
1919 list_del(&as->list);
1922 dmabuf_release(&as->usbin.dma);
1923 dmabuf_release(&as->usbout.dma);
1926 while (!list_empty(&s->mixerlist)) {
1927 ms = list_entry(s->mixerlist.next, struct usb_mixerdev, list);
1928 list_del(&ms->list);
1934 extern inline int prog_dmabuf_in(struct usb_audiodev *as)
1937 return dmabuf_init(&as->usbin.dma);
1940 extern inline int prog_dmabuf_out(struct usb_audiodev *as)
1943 return dmabuf_init(&as->usbout.dma);
1946 /* --------------------------------------------------------------------- */
1948 static int usb_audio_open_mixdev(struct inode *inode, struct file *file)
1950 int minor = MINOR(inode->i_rdev);
1951 struct list_head *devs, *mdevs;
1952 struct usb_mixerdev *ms;
1953 struct usb_audio_state *s;
1956 for (devs = audiodevs.next; devs != &audiodevs; devs = devs->next) {
1957 s = list_entry(devs, struct usb_audio_state, audiodev);
1958 for (mdevs = s->mixerlist.next; mdevs != &s->mixerlist; mdevs = mdevs->next) {
1959 ms = list_entry(mdevs, struct usb_mixerdev, list);
1960 if (ms->dev_mixer == minor)
1972 file->private_data = ms;
1979 static int usb_audio_release_mixdev(struct inode *inode, struct file *file)
1981 struct usb_mixerdev *ms = (struct usb_mixerdev *)file->private_data;
1982 struct usb_audio_state *s;
1992 static int usb_audio_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1994 struct usb_mixerdev *ms = (struct usb_mixerdev *)file->private_data;
1997 if (!ms->state->usbdev)
2000 if (cmd == SOUND_MIXER_INFO) {
2002 strncpy(info.id, "USB_AUDIO", sizeof(info.id));
2003 strncpy(info.name, "USB Audio Class Driver", sizeof(info.name));
2004 info.modify_counter = ms->modcnt;
2005 if (copy_to_user((void *)arg, &info, sizeof(info)))
2009 if (cmd == SOUND_OLD_MIXER_INFO) {
2010 _old_mixer_info info;
2011 strncpy(info.id, "USB_AUDIO", sizeof(info.id));
2012 strncpy(info.name, "USB Audio Class Driver", sizeof(info.name));
2013 if (copy_to_user((void *)arg, &info, sizeof(info)))
2017 if (cmd == OSS_GETVERSION)
2018 return put_user(SOUND_VERSION, (int *)arg);
2019 if (_IOC_TYPE(cmd) != 'M' || _IOC_SIZE(cmd) != sizeof(int))
2021 if (_IOC_DIR(cmd) == _IOC_READ) {
2022 switch (_IOC_NR(cmd)) {
2023 case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
2024 val = get_rec_src(ms);
2027 return put_user(val, (int *)arg);
2029 case SOUND_MIXER_DEVMASK: /* Arg contains a bit for each supported device */
2030 for (val = i = 0; i < ms->numch; i++)
2031 val |= 1 << ms->ch[i].osschannel;
2032 return put_user(val, (int *)arg);
2034 case SOUND_MIXER_RECMASK: /* Arg contains a bit for each supported recording source */
2035 for (val = i = 0; i < ms->numch; i++)
2036 if (ms->ch[i].slctunitid)
2037 val |= 1 << ms->ch[i].osschannel;
2038 return put_user(val, (int *)arg);
2040 case SOUND_MIXER_STEREODEVS: /* Mixer channels supporting stereo */
2041 for (val = i = 0; i < ms->numch; i++)
2042 if (ms->ch[i].flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT))
2043 val |= 1 << ms->ch[i].osschannel;
2044 return put_user(val, (int *)arg);
2046 case SOUND_MIXER_CAPS:
2047 return put_user(SOUND_CAP_EXCL_INPUT, (int *)arg);
2051 if (i >= SOUND_MIXER_NRDEVICES)
2053 for (j = 0; j < ms->numch; j++) {
2054 if (ms->ch[j].osschannel == i) {
2055 return put_user(ms->ch[j].value, (int *)arg);
2061 if (_IOC_DIR(cmd) != (_IOC_READ|_IOC_WRITE))
2064 switch (_IOC_NR(cmd)) {
2065 case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
2066 if (get_user(val, (int *)arg))
2068 return set_rec_src(ms, val);
2072 if (i >= SOUND_MIXER_NRDEVICES)
2074 for (j = 0; j < ms->numch && ms->ch[j].osschannel != i; j++);
2077 if (get_user(val, (int *)arg))
2079 if (wrmixer(ms, j, val))
2081 return put_user(ms->ch[j].value, (int *)arg);
2085 static /*const*/ struct file_operations usb_mixer_fops = {
2088 ioctl: usb_audio_ioctl_mixdev,
2089 open: usb_audio_open_mixdev,
2090 release: usb_audio_release_mixdev,
2093 /* --------------------------------------------------------------------- */
2095 static int drain_out(struct usb_audiodev *as, int nonblock)
2097 DECLARE_WAITQUEUE(wait, current);
2098 unsigned long flags;
2101 if (as->usbout.dma.mapped || !as->usbout.dma.ready)
2104 add_wait_queue(&as->usbout.dma.wait, &wait);
2106 __set_current_state(TASK_INTERRUPTIBLE);
2107 spin_lock_irqsave(&as->lock, flags);
2108 count = as->usbout.dma.count;
2109 spin_unlock_irqrestore(&as->lock, flags);
2112 if (signal_pending(current))
2115 remove_wait_queue(&as->usbout.dma.wait, &wait);
2116 set_current_state(TASK_RUNNING);
2119 tmo = 3 * HZ * count / as->usbout.dma.srate;
2120 tmo >>= AFMT_BYTESSHIFT(as->usbout.dma.format);
2121 if (!schedule_timeout(tmo + 1)) {
2122 printk(KERN_DEBUG "usbaudio: dma timed out??\n");
2126 remove_wait_queue(&as->usbout.dma.wait, &wait);
2127 set_current_state(TASK_RUNNING);
2128 if (signal_pending(current))
2129 return -ERESTARTSYS;
2133 /* --------------------------------------------------------------------- */
2135 static ssize_t usb_audio_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
2137 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2138 DECLARE_WAITQUEUE(wait, current);
2140 unsigned long flags;
2144 if (ppos != &file->f_pos)
2146 if (as->usbin.dma.mapped)
2148 if (!as->usbin.dma.ready && (ret = prog_dmabuf_in(as)))
2150 if (!access_ok(VERIFY_WRITE, buffer, count))
2152 add_wait_queue(&as->usbin.dma.wait, &wait);
2154 spin_lock_irqsave(&as->lock, flags);
2155 ptr = as->usbin.dma.rdptr;
2156 cnt = as->usbin.dma.count;
2157 /* set task state early to avoid wakeup races */
2159 __set_current_state(TASK_INTERRUPTIBLE);
2160 spin_unlock_irqrestore(&as->lock, flags);
2164 if (usbin_start(as)) {
2169 if (file->f_flags & O_NONBLOCK) {
2175 if (signal_pending(current)) {
2182 if ((err = dmabuf_copyout_user(&as->usbin.dma, ptr, buffer, cnt))) {
2188 if (ptr >= as->usbin.dma.dmasize)
2189 ptr -= as->usbin.dma.dmasize;
2190 spin_lock_irqsave(&as->lock, flags);
2191 as->usbin.dma.rdptr = ptr;
2192 as->usbin.dma.count -= cnt;
2193 spin_unlock_irqrestore(&as->lock, flags);
2198 __set_current_state(TASK_RUNNING);
2199 remove_wait_queue(&as->usbin.dma.wait, &wait);
2203 static ssize_t usb_audio_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
2205 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2206 DECLARE_WAITQUEUE(wait, current);
2208 unsigned long flags;
2210 unsigned int start_thr;
2213 if (ppos != &file->f_pos)
2215 if (as->usbout.dma.mapped)
2217 if (!as->usbout.dma.ready && (ret = prog_dmabuf_out(as)))
2219 if (!access_ok(VERIFY_READ, buffer, count))
2221 start_thr = (as->usbout.dma.srate << AFMT_BYTESSHIFT(as->usbout.dma.format)) / (1000 / (3 * DESCFRAMES));
2222 add_wait_queue(&as->usbout.dma.wait, &wait);
2225 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",
2226 count, as->usbout.dma.count, as->usbout.dma.rdptr, as->usbout.dma.wrptr, as->usbout.dma.dmasize, as->usbout.dma.fragsize,
2227 as->usbout.flags, current->state);
2229 spin_lock_irqsave(&as->lock, flags);
2230 if (as->usbout.dma.count < 0) {
2231 as->usbout.dma.count = 0;
2232 as->usbout.dma.rdptr = as->usbout.dma.wrptr;
2234 ptr = as->usbout.dma.wrptr;
2235 cnt = as->usbout.dma.dmasize - as->usbout.dma.count;
2236 /* set task state early to avoid wakeup races */
2238 __set_current_state(TASK_INTERRUPTIBLE);
2239 spin_unlock_irqrestore(&as->lock, flags);
2243 if (usbout_start(as)) {
2248 if (file->f_flags & O_NONBLOCK) {
2254 if (signal_pending(current)) {
2261 if ((err = dmabuf_copyin_user(&as->usbout.dma, ptr, buffer, cnt))) {
2267 if (ptr >= as->usbout.dma.dmasize)
2268 ptr -= as->usbout.dma.dmasize;
2269 spin_lock_irqsave(&as->lock, flags);
2270 as->usbout.dma.wrptr = ptr;
2271 as->usbout.dma.count += cnt;
2272 spin_unlock_irqrestore(&as->lock, flags);
2276 if (as->usbout.dma.count >= start_thr && usbout_start(as)) {
2282 __set_current_state(TASK_RUNNING);
2283 remove_wait_queue(&as->usbout.dma.wait, &wait);
2287 /* Called without the kernel lock - fine */
2288 static unsigned int usb_audio_poll(struct file *file, struct poll_table_struct *wait)
2290 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2291 unsigned long flags;
2292 unsigned int mask = 0;
2294 if (file->f_mode & FMODE_WRITE) {
2295 if (!as->usbout.dma.ready)
2296 prog_dmabuf_out(as);
2297 poll_wait(file, &as->usbout.dma.wait, wait);
2299 if (file->f_mode & FMODE_READ) {
2300 if (!as->usbin.dma.ready)
2302 poll_wait(file, &as->usbin.dma.wait, wait);
2304 spin_lock_irqsave(&as->lock, flags);
2305 if (file->f_mode & FMODE_READ) {
2306 if (as->usbin.dma.count >= (signed)as->usbin.dma.fragsize)
2307 mask |= POLLIN | POLLRDNORM;
2309 if (file->f_mode & FMODE_WRITE) {
2310 if (as->usbout.dma.mapped) {
2311 if (as->usbout.dma.count >= (signed)as->usbout.dma.fragsize)
2312 mask |= POLLOUT | POLLWRNORM;
2314 if ((signed)as->usbout.dma.dmasize >= as->usbout.dma.count + (signed)as->usbout.dma.fragsize)
2315 mask |= POLLOUT | POLLWRNORM;
2318 spin_unlock_irqrestore(&as->lock, flags);
2322 static int usb_audio_mmap(struct file *file, struct vm_area_struct *vma)
2324 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2329 if (vma->vm_flags & VM_WRITE) {
2330 if ((ret = prog_dmabuf_out(as)) != 0)
2332 db = &as->usbout.dma;
2333 } else if (vma->vm_flags & VM_READ) {
2334 if ((ret = prog_dmabuf_in(as)) != 0)
2336 db = &as->usbin.dma;
2341 if (vma->vm_pgoff != 0)
2344 ret = dmabuf_mmap(db, vma->vm_start, vma->vm_end - vma->vm_start, vma->vm_page_prot);
2350 static int usb_audio_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2352 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2353 struct usb_audio_state *s = as->state;
2354 unsigned long flags;
2355 audio_buf_info abinfo;
2358 int val2, mapped, ret;
2362 mapped = ((file->f_mode & FMODE_WRITE) && as->usbout.dma.mapped) ||
2363 ((file->f_mode & FMODE_READ) && as->usbin.dma.mapped);
2366 get_user(val, (int *)arg);
2367 printk(KERN_DEBUG "usbaudio: usb_audio_ioctl cmd=%x arg=%lx *arg=%d\n", cmd, arg, val)
2370 case OSS_GETVERSION:
2371 return put_user(SOUND_VERSION, (int *)arg);
2373 case SNDCTL_DSP_SYNC:
2374 if (file->f_mode & FMODE_WRITE)
2375 return drain_out(as, 0/*file->f_flags & O_NONBLOCK*/);
2378 case SNDCTL_DSP_SETDUPLEX:
2381 case SNDCTL_DSP_GETCAPS:
2382 return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER |
2383 DSP_CAP_MMAP | DSP_CAP_BATCH, (int *)arg);
2385 case SNDCTL_DSP_RESET:
2386 if (file->f_mode & FMODE_WRITE) {
2388 as->usbout.dma.rdptr = as->usbout.dma.wrptr = as->usbout.dma.count = as->usbout.dma.total_bytes = 0;
2390 if (file->f_mode & FMODE_READ) {
2392 as->usbin.dma.rdptr = as->usbin.dma.wrptr = as->usbin.dma.count = as->usbin.dma.total_bytes = 0;
2396 case SNDCTL_DSP_SPEED:
2397 if (get_user(val, (int *)arg))
2404 if (set_format(as, file->f_mode, AFMT_QUERY, val))
2407 return put_user((file->f_mode & FMODE_READ) ? as->usbin.dma.srate : as->usbout.dma.srate, (int *)arg);
2409 case SNDCTL_DSP_STEREO:
2410 if (get_user(val, (int *)arg))
2412 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2414 val2 |= AFMT_STEREO;
2416 val2 &= ~AFMT_STEREO;
2417 if (set_format(as, file->f_mode, val2, 0))
2421 case SNDCTL_DSP_CHANNELS:
2422 if (get_user(val, (int *)arg))
2425 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2427 val2 &= ~AFMT_STEREO;
2429 val2 |= AFMT_STEREO;
2430 if (set_format(as, file->f_mode, val2, 0))
2433 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2434 return put_user(AFMT_ISSTEREO(val2) ? 2 : 1, (int *)arg);
2436 case SNDCTL_DSP_GETFMTS: /* Returns a mask */
2437 return put_user(AFMT_U8 | AFMT_U16_LE | AFMT_U16_BE |
2438 AFMT_S8 | AFMT_S16_LE | AFMT_S16_BE, (int *)arg);
2440 case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
2441 if (get_user(val, (int *)arg))
2443 if (val != AFMT_QUERY) {
2444 if (hweight32(val) != 1)
2446 if (!(val & (AFMT_U8 | AFMT_U16_LE | AFMT_U16_BE |
2447 AFMT_S8 | AFMT_S16_LE | AFMT_S16_BE)))
2449 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2450 val |= val2 & AFMT_STEREO;
2451 if (set_format(as, file->f_mode, val, 0))
2454 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2455 return put_user(val2 & ~AFMT_STEREO, (int *)arg);
2457 case SNDCTL_DSP_POST:
2460 case SNDCTL_DSP_GETTRIGGER:
2462 if (file->f_mode & FMODE_READ && as->usbin.flags & FLG_RUNNING)
2463 val |= PCM_ENABLE_INPUT;
2464 if (file->f_mode & FMODE_WRITE && as->usbout.flags & FLG_RUNNING)
2465 val |= PCM_ENABLE_OUTPUT;
2466 return put_user(val, (int *)arg);
2468 case SNDCTL_DSP_SETTRIGGER:
2469 if (get_user(val, (int *)arg))
2471 if (file->f_mode & FMODE_READ) {
2472 if (val & PCM_ENABLE_INPUT) {
2473 if (!as->usbin.dma.ready && (ret = prog_dmabuf_in(as)))
2475 if (usbin_start(as))
2480 if (file->f_mode & FMODE_WRITE) {
2481 if (val & PCM_ENABLE_OUTPUT) {
2482 if (!as->usbout.dma.ready && (ret = prog_dmabuf_out(as)))
2484 if (usbout_start(as))
2491 case SNDCTL_DSP_GETOSPACE:
2492 if (!(file->f_mode & FMODE_WRITE))
2494 if (!(as->usbout.flags & FLG_RUNNING) && (val = prog_dmabuf_out(as)) != 0)
2496 spin_lock_irqsave(&as->lock, flags);
2497 abinfo.fragsize = as->usbout.dma.fragsize;
2498 abinfo.bytes = as->usbout.dma.dmasize - as->usbout.dma.count;
2499 abinfo.fragstotal = as->usbout.dma.numfrag;
2500 abinfo.fragments = abinfo.bytes >> as->usbout.dma.fragshift;
2501 spin_unlock_irqrestore(&as->lock, flags);
2502 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2504 case SNDCTL_DSP_GETISPACE:
2505 if (!(file->f_mode & FMODE_READ))
2507 if (!(as->usbin.flags & FLG_RUNNING) && (val = prog_dmabuf_in(as)) != 0)
2509 spin_lock_irqsave(&as->lock, flags);
2510 abinfo.fragsize = as->usbin.dma.fragsize;
2511 abinfo.bytes = as->usbin.dma.count;
2512 abinfo.fragstotal = as->usbin.dma.numfrag;
2513 abinfo.fragments = abinfo.bytes >> as->usbin.dma.fragshift;
2514 spin_unlock_irqrestore(&as->lock, flags);
2515 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2517 case SNDCTL_DSP_NONBLOCK:
2518 file->f_flags |= O_NONBLOCK;
2521 case SNDCTL_DSP_GETODELAY:
2522 if (!(file->f_mode & FMODE_WRITE))
2524 spin_lock_irqsave(&as->lock, flags);
2525 val = as->usbout.dma.count;
2526 spin_unlock_irqrestore(&as->lock, flags);
2527 return put_user(val, (int *)arg);
2529 case SNDCTL_DSP_GETIPTR:
2530 if (!(file->f_mode & FMODE_READ))
2532 spin_lock_irqsave(&as->lock, flags);
2533 cinfo.bytes = as->usbin.dma.total_bytes;
2534 cinfo.blocks = as->usbin.dma.count >> as->usbin.dma.fragshift;
2535 cinfo.ptr = as->usbin.dma.wrptr;
2536 if (as->usbin.dma.mapped)
2537 as->usbin.dma.count &= as->usbin.dma.fragsize-1;
2538 spin_unlock_irqrestore(&as->lock, flags);
2539 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));
2541 case SNDCTL_DSP_GETOPTR:
2542 if (!(file->f_mode & FMODE_WRITE))
2544 spin_lock_irqsave(&as->lock, flags);
2545 cinfo.bytes = as->usbout.dma.total_bytes;
2546 cinfo.blocks = as->usbout.dma.count >> as->usbout.dma.fragshift;
2547 cinfo.ptr = as->usbout.dma.rdptr;
2548 if (as->usbout.dma.mapped)
2549 as->usbout.dma.count &= as->usbout.dma.fragsize-1;
2550 spin_unlock_irqrestore(&as->lock, flags);
2551 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));
2553 case SNDCTL_DSP_GETBLKSIZE:
2554 if (file->f_mode & FMODE_WRITE) {
2555 if ((val = prog_dmabuf_out(as)))
2557 return put_user(as->usbout.dma.fragsize, (int *)arg);
2559 if ((val = prog_dmabuf_in(as)))
2561 return put_user(as->usbin.dma.fragsize, (int *)arg);
2563 case SNDCTL_DSP_SETFRAGMENT:
2564 if (get_user(val, (int *)arg))
2566 if (file->f_mode & FMODE_READ) {
2567 as->usbin.dma.ossfragshift = val & 0xffff;
2568 as->usbin.dma.ossmaxfrags = (val >> 16) & 0xffff;
2569 if (as->usbin.dma.ossfragshift < 4)
2570 as->usbin.dma.ossfragshift = 4;
2571 if (as->usbin.dma.ossfragshift > 15)
2572 as->usbin.dma.ossfragshift = 15;
2573 if (as->usbin.dma.ossmaxfrags < 4)
2574 as->usbin.dma.ossmaxfrags = 4;
2576 if (file->f_mode & FMODE_WRITE) {
2577 as->usbout.dma.ossfragshift = val & 0xffff;
2578 as->usbout.dma.ossmaxfrags = (val >> 16) & 0xffff;
2579 if (as->usbout.dma.ossfragshift < 4)
2580 as->usbout.dma.ossfragshift = 4;
2581 if (as->usbout.dma.ossfragshift > 15)
2582 as->usbout.dma.ossfragshift = 15;
2583 if (as->usbout.dma.ossmaxfrags < 4)
2584 as->usbout.dma.ossmaxfrags = 4;
2588 case SNDCTL_DSP_SUBDIVIDE:
2589 if ((file->f_mode & FMODE_READ && as->usbin.dma.subdivision) ||
2590 (file->f_mode & FMODE_WRITE && as->usbout.dma.subdivision))
2592 if (get_user(val, (int *)arg))
2594 if (val != 1 && val != 2 && val != 4)
2596 if (file->f_mode & FMODE_READ)
2597 as->usbin.dma.subdivision = val;
2598 if (file->f_mode & FMODE_WRITE)
2599 as->usbout.dma.subdivision = val;
2602 case SOUND_PCM_READ_RATE:
2603 return put_user((file->f_mode & FMODE_READ) ? as->usbin.dma.srate : as->usbout.dma.srate, (int *)arg);
2605 case SOUND_PCM_READ_CHANNELS:
2606 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2607 return put_user(AFMT_ISSTEREO(val2) ? 2 : 1, (int *)arg);
2609 case SOUND_PCM_READ_BITS:
2610 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2611 return put_user(AFMT_IS16BIT(val2) ? 16 : 8, (int *)arg);
2613 case SOUND_PCM_WRITE_FILTER:
2614 case SNDCTL_DSP_SETSYNCRO:
2615 case SOUND_PCM_READ_FILTER:
2618 dprintk((KERN_DEBUG "usbaudio: usb_audio_ioctl - no command found\n"));
2619 return -ENOIOCTLCMD;
2622 static int usb_audio_open(struct inode *inode, struct file *file)
2624 int minor = MINOR(inode->i_rdev);
2625 DECLARE_WAITQUEUE(wait, current);
2626 struct list_head *devs, *adevs;
2627 struct usb_audiodev *as;
2628 struct usb_audio_state *s;
2632 for (devs = audiodevs.next; devs != &audiodevs; devs = devs->next) {
2633 s = list_entry(devs, struct usb_audio_state, audiodev);
2634 for (adevs = s->audiolist.next; adevs != &s->audiolist; adevs = adevs->next) {