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
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
308 struct usb_audiodev
{
309 struct list_head list
;
310 struct usb_audio_state
*state
;
312 /* soundcore stuff */
317 spinlock_t lock
; /* DMA buffer access spinlock */
320 int interface
; /* Interface number, -1 means not used */
321 unsigned int format
; /* USB data format */
322 unsigned int datapipe
; /* the data input pipe */
323 unsigned int syncpipe
; /* the synchronisation pipe - 0 for anything but adaptive IN mode */
324 unsigned int syncinterval
; /* P for adaptive IN mode, 0 otherwise */
325 unsigned int freqn
; /* nominal sampling rate in USB format, i.e. fs/1000 in Q10.14 */
326 unsigned int freqmax
; /* maximum sampling rate, used for buffer management */
327 unsigned int phase
; /* phase accumulator */
328 unsigned int flags
; /* see FLG_ defines */
330 struct my_data_urb durb
[2]; /* ISO descriptors for the data endpoint */
331 struct my_sync_urb surb
[2]; /* ISO sync pipe descriptor if needed */
337 int interface
; /* Interface number, -1 means not used */
338 unsigned int format
; /* USB data format */
339 unsigned int datapipe
; /* the data input pipe */
340 unsigned int syncpipe
; /* the synchronisation pipe - 0 for anything but asynchronous OUT mode */
341 unsigned int syncinterval
; /* P for asynchronous OUT mode, 0 otherwise */
342 unsigned int freqn
; /* nominal sampling rate in USB format, i.e. fs/1000 in Q10.14 */
343 unsigned int freqm
; /* momentary sampling rate in USB format, i.e. fs/1000 in Q10.14 */
344 unsigned int freqmax
; /* maximum sampling rate, used for buffer management */
345 unsigned int phase
; /* phase accumulator */
346 unsigned int flags
; /* see FLG_ defines */
348 struct my_data_urb durb
[2]; /* ISO descriptors for the data endpoint */
349 struct my_sync_urb surb
[2]; /* ISO sync pipe descriptor if needed */
355 unsigned int numfmtin
, numfmtout
;
356 struct audioformat fmtin
[MAXFORMATS
];
357 struct audioformat fmtout
[MAXFORMATS
];
360 struct usb_mixerdev
{
361 struct list_head list
;
362 struct usb_audio_state
*state
;
364 /* soundcore stuff */
367 unsigned char iface
; /* interface number of the AudioControl interface */
369 /* USB format descriptions */
370 unsigned int numch
, modcnt
;
372 /* mixch is last and gets allocated dynamically */
373 struct mixerchannel ch
[0];
376 struct usb_audio_state
{
377 struct list_head audiodev
;
380 struct usb_device
*usbdev
;
382 struct list_head audiolist
;
383 struct list_head mixerlist
;
385 unsigned count
; /* usage counter; NOTE: the usb stack is also considered a user */
388 /* private audio format extensions */
389 #define AFMT_STEREO 0x80000000
390 #define AFMT_ISSTEREO(x) ((x) & AFMT_STEREO)
391 #define AFMT_IS16BIT(x) ((x) & (AFMT_S16_LE|AFMT_S16_BE|AFMT_U16_LE|AFMT_U16_BE))
392 #define AFMT_ISUNSIGNED(x) ((x) & (AFMT_U8|AFMT_U16_LE|AFMT_U16_BE))
393 #define AFMT_BYTESSHIFT(x) ((AFMT_ISSTEREO(x) ? 1 : 0) + (AFMT_IS16BIT(x) ? 1 : 0))
394 #define AFMT_BYTES(x) (1<<AFMT_BYTESSHFIT(x))
396 /* --------------------------------------------------------------------- */
398 static inline unsigned ld2(unsigned int x
)
423 /* --------------------------------------------------------------------- */
426 * OSS compatible ring buffer management. The ring buffer may be mmap'ed into
427 * an application address space.
429 * I first used the rvmalloc stuff copied from bttv. Alan Cox did not like it, so
430 * we now use an array of pointers to a single page each. This saves us the
431 * kernel page table manipulations, but we have to do a page table alike mechanism
432 * (though only one indirection) in software.
435 static void dmabuf_release(struct dmabuf
*db
)
440 for(nr
= 0; nr
< NRSGBUF
; nr
++) {
441 if (!(p
= db
->sgbuf
[nr
]))
443 ClearPageReserved(virt_to_page(p
));
444 free_page((unsigned long)p
);
445 db
->sgbuf
[nr
] = NULL
;
447 db
->mapped
= db
->ready
= 0;
450 static int dmabuf_init(struct dmabuf
*db
)
452 unsigned int nr
, bytepersec
, bufs
;
455 /* initialize some fields */
456 db
->rdptr
= db
->wrptr
= db
->total_bytes
= db
->count
= db
->error
= 0;
457 /* calculate required buffer size */
458 bytepersec
= db
->srate
<< AFMT_BYTESSHIFT(db
->format
);
459 bufs
= 1U << DMABUFSHIFT
;
460 if (db
->ossfragshift
) {
461 if ((1000 << db
->ossfragshift
) < bytepersec
)
462 db
->fragshift
= ld2(bytepersec
/1000);
464 db
->fragshift
= db
->ossfragshift
;
466 db
->fragshift
= ld2(bytepersec
/100/(db
->subdivision
? db
->subdivision
: 1));
467 if (db
->fragshift
< 3)
470 db
->numfrag
= bufs
>> db
->fragshift
;
471 while (db
->numfrag
< 4 && db
->fragshift
> 3) {
473 db
->numfrag
= bufs
>> db
->fragshift
;
475 db
->fragsize
= 1 << db
->fragshift
;
476 if (db
->ossmaxfrags
>= 4 && db
->ossmaxfrags
< db
->numfrag
)
477 db
->numfrag
= db
->ossmaxfrags
;
478 db
->dmasize
= db
->numfrag
<< db
->fragshift
;
479 for(nr
= 0; nr
< NRSGBUF
; nr
++) {
480 if (!db
->sgbuf
[nr
]) {
481 p
= (void *)get_zeroed_page(GFP_KERNEL
);
485 SetPageReserved(virt_to_page(p
));
487 memset(db
->sgbuf
[nr
], AFMT_ISUNSIGNED(db
->format
) ? 0x80 : 0, PAGE_SIZE
);
488 if ((nr
<< PAGE_SHIFT
) >= db
->dmasize
)
491 db
->bufsize
= nr
<< PAGE_SHIFT
;
493 dprintk((KERN_DEBUG
"usbaudio: dmabuf_init bytepersec %d bufs %d ossfragshift %d ossmaxfrags %d "
494 "fragshift %d fragsize %d numfrag %d dmasize %d bufsize %d fmt 0x%x srate %d\n",
495 bytepersec
, bufs
, db
->ossfragshift
, db
->ossmaxfrags
, db
->fragshift
, db
->fragsize
,
496 db
->numfrag
, db
->dmasize
, db
->bufsize
, db
->format
, db
->srate
));
500 static int dmabuf_mmap(struct vm_area_struct
*vma
, struct dmabuf
*db
, unsigned long start
, unsigned long size
, pgprot_t prot
)
504 if (!db
->ready
|| db
->mapped
|| (start
| size
) & (PAGE_SIZE
-1) || size
> db
->bufsize
)
507 for(nr
= 0; nr
< size
; nr
++)
511 for(nr
= 0; nr
< size
; nr
++) {
514 pfn
= virt_to_phys(db
->sgbuf
[nr
]) >> PAGE_SHIFT
;
515 if (remap_pfn_range(vma
, start
, pfn
, PAGE_SIZE
, prot
))
522 static void dmabuf_copyin(struct dmabuf
*db
, const void *buffer
, unsigned int size
)
524 unsigned int pgrem
, rem
;
526 db
->total_bytes
+= size
;
530 pgrem
= ((~db
->wrptr
) & (PAGE_SIZE
-1)) + 1;
533 rem
= db
->dmasize
- db
->wrptr
;
536 memcpy((db
->sgbuf
[db
->wrptr
>> PAGE_SHIFT
]) + (db
->wrptr
& (PAGE_SIZE
-1)), buffer
, pgrem
);
540 if (db
->wrptr
>= db
->dmasize
)
545 static void dmabuf_copyout(struct dmabuf
*db
, void *buffer
, unsigned int size
)
547 unsigned int pgrem
, rem
;
549 db
->total_bytes
+= size
;
553 pgrem
= ((~db
->rdptr
) & (PAGE_SIZE
-1)) + 1;
556 rem
= db
->dmasize
- db
->rdptr
;
559 memcpy(buffer
, (db
->sgbuf
[db
->rdptr
>> PAGE_SHIFT
]) + (db
->rdptr
& (PAGE_SIZE
-1)), pgrem
);
563 if (db
->rdptr
>= db
->dmasize
)
568 static int dmabuf_copyin_user(struct dmabuf
*db
, unsigned int ptr
, const void __user
*buffer
, unsigned int size
)
570 unsigned int pgrem
, rem
;
572 if (!db
->ready
|| db
->mapped
)
577 pgrem
= ((~ptr
) & (PAGE_SIZE
-1)) + 1;
580 rem
= db
->dmasize
- ptr
;
583 if (copy_from_user((db
->sgbuf
[ptr
>> PAGE_SHIFT
]) + (ptr
& (PAGE_SIZE
-1)), buffer
, pgrem
))
588 if (ptr
>= db
->dmasize
)
593 static int dmabuf_copyout_user(struct dmabuf
*db
, unsigned int ptr
, void __user
*buffer
, unsigned int size
)
595 unsigned int pgrem
, rem
;
597 if (!db
->ready
|| db
->mapped
)
602 pgrem
= ((~ptr
) & (PAGE_SIZE
-1)) + 1;
605 rem
= db
->dmasize
- ptr
;
608 if (copy_to_user(buffer
, (db
->sgbuf
[ptr
>> PAGE_SHIFT
]) + (ptr
& (PAGE_SIZE
-1)), pgrem
))
613 if (ptr
>= db
->dmasize
)
618 /* --------------------------------------------------------------------- */
620 * USB I/O code. We do sample format conversion if necessary
623 static void usbin_stop(struct usb_audiodev
*as
)
625 struct usbin
*u
= &as
->usbin
;
627 unsigned int i
, notkilled
= 1;
629 spin_lock_irqsave(&as
->lock
, flags
);
630 u
->flags
&= ~FLG_RUNNING
;
632 spin_unlock_irqrestore(&as
->lock
, flags
);
633 while (i
& (FLG_URB0RUNNING
|FLG_URB1RUNNING
|FLG_SYNC0RUNNING
|FLG_SYNC1RUNNING
)) {
635 schedule_timeout_interruptible(1);
637 schedule_timeout_uninterruptible(1);
638 spin_lock_irqsave(&as
->lock
, flags
);
640 spin_unlock_irqrestore(&as
->lock
, flags
);
641 if (notkilled
&& signal_pending(current
)) {
642 if (i
& FLG_URB0RUNNING
)
643 usb_kill_urb(u
->durb
[0].urb
);
644 if (i
& FLG_URB1RUNNING
)
645 usb_kill_urb(u
->durb
[1].urb
);
646 if (i
& FLG_SYNC0RUNNING
)
647 usb_kill_urb(u
->surb
[0].urb
);
648 if (i
& FLG_SYNC1RUNNING
)
649 usb_kill_urb(u
->surb
[1].urb
);
653 set_current_state(TASK_RUNNING
);
654 kfree(u
->durb
[0].urb
->transfer_buffer
);
655 kfree(u
->durb
[1].urb
->transfer_buffer
);
656 kfree(u
->surb
[0].urb
->transfer_buffer
);
657 kfree(u
->surb
[1].urb
->transfer_buffer
);
658 u
->durb
[0].urb
->transfer_buffer
= u
->durb
[1].urb
->transfer_buffer
=
659 u
->surb
[0].urb
->transfer_buffer
= u
->surb
[1].urb
->transfer_buffer
= NULL
;
662 static inline void usbin_release(struct usb_audiodev
*as
)
667 static void usbin_disc(struct usb_audiodev
*as
)
669 struct usbin
*u
= &as
->usbin
;
673 spin_lock_irqsave(&as
->lock
, flags
);
674 u
->flags
&= ~(FLG_RUNNING
| FLG_CONNECTED
);
675 spin_unlock_irqrestore(&as
->lock
, flags
);
679 static void conversion(const void *ibuf
, unsigned int ifmt
, void *obuf
, unsigned int ofmt
, void *tmp
, unsigned int scnt
)
686 if (AFMT_ISSTEREO(ifmt
))
688 sp
= ((__s16
*)tmp
) + cnt
;
689 switch (ifmt
& ~AFMT_STEREO
) {
691 for (bp
= ((unsigned char *)ibuf
)+cnt
, i
= 0; i
< cnt
; i
++) {
694 *sp
= (*bp
^ 0x80) << 8;
699 for (bp
= ((unsigned char *)ibuf
)+cnt
, i
= 0; i
< cnt
; i
++) {
707 for (bp
= ((unsigned char *)ibuf
)+2*cnt
, i
= 0; i
< cnt
; i
++) {
710 *sp
= (bp
[0] | (bp
[1] << 8)) ^ 0x8000;
715 for (bp
= ((unsigned char *)ibuf
)+2*cnt
, i
= 0; i
< cnt
; i
++) {
718 *sp
= (bp
[1] | (bp
[0] << 8)) ^ 0x8000;
723 for (bp
= ((unsigned char *)ibuf
)+2*cnt
, i
= 0; i
< cnt
; i
++) {
726 *sp
= bp
[0] | (bp
[1] << 8);
731 for (bp
= ((unsigned char *)ibuf
)+2*cnt
, i
= 0; i
< cnt
; i
++) {
734 *sp
= bp
[1] | (bp
[0] << 8);
738 if (!AFMT_ISSTEREO(ifmt
) && AFMT_ISSTEREO(ofmt
)) {
739 /* expand from mono to stereo */
740 for (sp
= ((__s16
*)tmp
)+scnt
, sp2
= ((__s16
*)tmp
)+2*scnt
, i
= 0; i
< scnt
; i
++) {
743 sp2
[0] = sp2
[1] = sp
[0];
746 if (AFMT_ISSTEREO(ifmt
) && !AFMT_ISSTEREO(ofmt
)) {
747 /* contract from stereo to mono */
748 for (sp
= sp2
= ((__s16
*)tmp
), i
= 0; i
< scnt
; i
++, sp
++, sp2
+= 2)
749 sp
[0] = (sp2
[0] + sp2
[1]) >> 1;
752 if (AFMT_ISSTEREO(ofmt
))
755 bp
= ((unsigned char *)obuf
);
756 switch (ofmt
& ~AFMT_STEREO
) {
758 for (i
= 0; i
< cnt
; i
++, sp
++, bp
++)
759 *bp
= (*sp
>> 8) ^ 0x80;
763 for (i
= 0; i
< cnt
; i
++, sp
++, bp
++)
768 for (i
= 0; i
< cnt
; i
++, sp
++, bp
+= 2) {
771 bp
[1] = (s
>> 8) ^ 0x80;
776 for (i
= 0; i
< cnt
; i
++, sp
++, bp
+= 2) {
779 bp
[0] = (s
>> 8) ^ 0x80;
784 for (i
= 0; i
< cnt
; i
++, sp
++, bp
+= 2) {
792 for (i
= 0; i
< cnt
; i
++, sp
++, bp
+= 2) {
802 static void usbin_convert(struct usbin
*u
, unsigned char *buffer
, unsigned int samples
)
808 unsigned int scnt
, maxs
, ufmtsh
, dfmtsh
;
810 ufmtsh
= AFMT_BYTESSHIFT(u
->format
);
811 dfmtsh
= AFMT_BYTESSHIFT(u
->dma
.format
);
812 maxs
= (AFMT_ISSTEREO(u
->dma
.format
| u
->format
)) ? 32 : 64;
813 while (samples
> 0) {
817 conversion(buffer
, u
->format
, tmp
.b
, u
->dma
.format
, tmp
.b
, scnt
);
818 dmabuf_copyin(&u
->dma
, tmp
.b
, scnt
<< dfmtsh
);
819 buffer
+= scnt
<< ufmtsh
;
824 static int usbin_prepare_desc(struct usbin
*u
, struct urb
*urb
)
826 unsigned int i
, maxsize
, offs
;
828 maxsize
= (u
->freqmax
+ 0x3fff) >> (14 - AFMT_BYTESSHIFT(u
->format
));
829 //printk(KERN_DEBUG "usbin_prepare_desc: maxsize %d freq 0x%x format 0x%x\n", maxsize, u->freqn, u->format);
830 for (i
= offs
= 0; i
< DESCFRAMES
; i
++, offs
+= maxsize
) {
831 urb
->iso_frame_desc
[i
].length
= maxsize
;
832 urb
->iso_frame_desc
[i
].offset
= offs
;
839 * return value: 0 if descriptor should be restarted, -1 otherwise
840 * convert sample format on the fly if necessary
842 static int usbin_retire_desc(struct usbin
*u
, struct urb
*urb
)
844 unsigned int i
, ufmtsh
, dfmtsh
, err
= 0, cnt
, scnt
, dmafree
;
847 ufmtsh
= AFMT_BYTESSHIFT(u
->format
);
848 dfmtsh
= AFMT_BYTESSHIFT(u
->dma
.format
);
849 for (i
= 0; i
< DESCFRAMES
; i
++) {
850 cp
= ((unsigned char *)urb
->transfer_buffer
) + urb
->iso_frame_desc
[i
].offset
;
851 if (urb
->iso_frame_desc
[i
].status
) {
852 dprintk((KERN_DEBUG
"usbin_retire_desc: frame %u status %d\n", i
, urb
->iso_frame_desc
[i
].status
));
855 scnt
= urb
->iso_frame_desc
[i
].actual_length
>> ufmtsh
;
858 cnt
= scnt
<< dfmtsh
;
859 if (!u
->dma
.mapped
) {
860 dmafree
= u
->dma
.dmasize
- u
->dma
.count
;
862 scnt
= dmafree
>> dfmtsh
;
863 cnt
= scnt
<< dfmtsh
;
868 if (u
->format
== u
->dma
.format
) {
869 /* we do not need format conversion */
870 dprintk((KERN_DEBUG
"usbaudio: no sample format conversion\n"));
871 dmabuf_copyin(&u
->dma
, cp
, cnt
);
873 /* we need sampling format conversion */
874 dprintk((KERN_DEBUG
"usbaudio: sample format conversion %x != %x\n", u
->format
, u
->dma
.format
));
875 usbin_convert(u
, cp
, scnt
);
880 if (u
->dma
.count
>= (signed)u
->dma
.fragsize
)
881 wake_up(&u
->dma
.wait
);
885 static void usbin_completed(struct urb
*urb
, struct pt_regs
*regs
)
887 struct usb_audiodev
*as
= (struct usb_audiodev
*)urb
->context
;
888 struct usbin
*u
= &as
->usbin
;
894 printk(KERN_DEBUG
"usbin_completed: status %d errcnt %d flags 0x%x\n", urb
->status
, urb
->error_count
, u
->flags
);
896 if (urb
== u
->durb
[0].urb
)
897 mask
= FLG_URB0RUNNING
;
898 else if (urb
== u
->durb
[1].urb
)
899 mask
= FLG_URB1RUNNING
;
902 printk(KERN_ERR
"usbin_completed: panic: unknown URB\n");
904 urb
->dev
= as
->state
->usbdev
;
905 spin_lock_irqsave(&as
->lock
, flags
);
906 if (!usbin_retire_desc(u
, urb
) &&
907 u
->flags
& FLG_RUNNING
&&
908 !usbin_prepare_desc(u
, urb
) &&
909 (suret
= usb_submit_urb(urb
, GFP_ATOMIC
)) == 0) {
912 u
->flags
&= ~(mask
| FLG_RUNNING
);
913 wake_up(&u
->dma
.wait
);
914 printk(KERN_DEBUG
"usbin_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret
);
916 spin_unlock_irqrestore(&as
->lock
, flags
);
920 * we output sync data
922 static int usbin_sync_prepare_desc(struct usbin
*u
, struct urb
*urb
)
924 unsigned char *cp
= urb
->transfer_buffer
;
925 unsigned int i
, offs
;
927 for (i
= offs
= 0; i
< SYNCFRAMES
; i
++, offs
+= 3, cp
+= 3) {
928 urb
->iso_frame_desc
[i
].length
= 3;
929 urb
->iso_frame_desc
[i
].offset
= offs
;
931 cp
[1] = u
->freqn
>> 8;
932 cp
[2] = u
->freqn
>> 16;
939 * return value: 0 if descriptor should be restarted, -1 otherwise
941 static int usbin_sync_retire_desc(struct usbin
*u
, struct urb
*urb
)
945 for (i
= 0; i
< SYNCFRAMES
; i
++)
946 if (urb
->iso_frame_desc
[0].status
)
947 dprintk((KERN_DEBUG
"usbin_sync_retire_desc: frame %u status %d\n", i
, urb
->iso_frame_desc
[i
].status
));
951 static void usbin_sync_completed(struct urb
*urb
, struct pt_regs
*regs
)
953 struct usb_audiodev
*as
= (struct usb_audiodev
*)urb
->context
;
954 struct usbin
*u
= &as
->usbin
;
960 printk(KERN_DEBUG
"usbin_sync_completed: status %d errcnt %d flags 0x%x\n", urb
->status
, urb
->error_count
, u
->flags
);
962 if (urb
== u
->surb
[0].urb
)
963 mask
= FLG_SYNC0RUNNING
;
964 else if (urb
== u
->surb
[1].urb
)
965 mask
= FLG_SYNC1RUNNING
;
968 printk(KERN_ERR
"usbin_sync_completed: panic: unknown URB\n");
970 urb
->dev
= as
->state
->usbdev
;
971 spin_lock_irqsave(&as
->lock
, flags
);
972 if (!usbin_sync_retire_desc(u
, urb
) &&
973 u
->flags
& FLG_RUNNING
&&
974 !usbin_sync_prepare_desc(u
, urb
) &&
975 (suret
= usb_submit_urb(urb
, GFP_ATOMIC
)) == 0) {
978 u
->flags
&= ~(mask
| FLG_RUNNING
);
979 wake_up(&u
->dma
.wait
);
980 dprintk((KERN_DEBUG
"usbin_sync_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret
));
982 spin_unlock_irqrestore(&as
->lock
, flags
);
985 static int usbin_start(struct usb_audiodev
*as
)
987 struct usb_device
*dev
= as
->state
->usbdev
;
988 struct usbin
*u
= &as
->usbin
;
991 unsigned int maxsze
, bufsz
;
994 printk(KERN_DEBUG
"usbin_start: device %d ufmt 0x%08x dfmt 0x%08x srate %d\n",
995 dev
->devnum
, u
->format
, u
->dma
.format
, u
->dma
.srate
);
997 /* allocate USB storage if not already done */
998 spin_lock_irqsave(&as
->lock
, flags
);
999 if (!(u
->flags
& FLG_CONNECTED
)) {
1000 spin_unlock_irqrestore(&as
->lock
, flags
);
1003 if (!(u
->flags
& FLG_RUNNING
)) {
1004 spin_unlock_irqrestore(&as
->lock
, flags
);
1005 u
->freqn
= ((u
->dma
.srate
<< 11) + 62) / 125; /* this will overflow at approx 2MSPS */
1006 u
->freqmax
= u
->freqn
+ (u
->freqn
>> 2);
1008 maxsze
= (u
->freqmax
+ 0x3fff) >> (14 - AFMT_BYTESSHIFT(u
->format
));
1009 bufsz
= DESCFRAMES
* maxsze
;
1010 kfree(u
->durb
[0].urb
->transfer_buffer
);
1011 u
->durb
[0].urb
->transfer_buffer
= kmalloc(bufsz
, GFP_KERNEL
);
1012 u
->durb
[0].urb
->transfer_buffer_length
= bufsz
;
1013 kfree(u
->durb
[1].urb
->transfer_buffer
);
1014 u
->durb
[1].urb
->transfer_buffer
= kmalloc(bufsz
, GFP_KERNEL
);
1015 u
->durb
[1].urb
->transfer_buffer_length
= bufsz
;
1017 kfree(u
->surb
[0].urb
->transfer_buffer
);
1018 u
->surb
[0].urb
->transfer_buffer
= kmalloc(3*SYNCFRAMES
, GFP_KERNEL
);
1019 u
->surb
[0].urb
->transfer_buffer_length
= 3*SYNCFRAMES
;
1020 kfree(u
->surb
[1].urb
->transfer_buffer
);
1021 u
->surb
[1].urb
->transfer_buffer
= kmalloc(3*SYNCFRAMES
, GFP_KERNEL
);
1022 u
->surb
[1].urb
->transfer_buffer_length
= 3*SYNCFRAMES
;
1024 if (!u
->durb
[0].urb
->transfer_buffer
|| !u
->durb
[1].urb
->transfer_buffer
||
1025 (u
->syncpipe
&& (!u
->surb
[0].urb
->transfer_buffer
|| !u
->surb
[1].urb
->transfer_buffer
))) {
1026 printk(KERN_ERR
"usbaudio: cannot start playback device %d\n", dev
->devnum
);
1029 spin_lock_irqsave(&as
->lock
, flags
);
1031 if (u
->dma
.count
>= u
->dma
.dmasize
&& !u
->dma
.mapped
) {
1032 spin_unlock_irqrestore(&as
->lock
, flags
);
1035 u
->flags
|= FLG_RUNNING
;
1036 if (!(u
->flags
& FLG_URB0RUNNING
)) {
1037 urb
= u
->durb
[0].urb
;
1039 urb
->pipe
= u
->datapipe
;
1040 urb
->transfer_flags
= URB_ISO_ASAP
;
1041 urb
->number_of_packets
= DESCFRAMES
;
1043 urb
->complete
= usbin_completed
;
1044 if (!usbin_prepare_desc(u
, urb
) && !usb_submit_urb(urb
, GFP_KERNEL
))
1045 u
->flags
|= FLG_URB0RUNNING
;
1047 u
->flags
&= ~FLG_RUNNING
;
1049 if (u
->flags
& FLG_RUNNING
&& !(u
->flags
& FLG_URB1RUNNING
)) {
1050 urb
= u
->durb
[1].urb
;
1052 urb
->pipe
= u
->datapipe
;
1053 urb
->transfer_flags
= URB_ISO_ASAP
;
1054 urb
->number_of_packets
= DESCFRAMES
;
1056 urb
->complete
= usbin_completed
;
1057 if (!usbin_prepare_desc(u
, urb
) && !usb_submit_urb(urb
, GFP_KERNEL
))
1058 u
->flags
|= FLG_URB1RUNNING
;
1060 u
->flags
&= ~FLG_RUNNING
;
1063 if (u
->flags
& FLG_RUNNING
&& !(u
->flags
& FLG_SYNC0RUNNING
)) {
1064 urb
= u
->surb
[0].urb
;
1066 urb
->pipe
= u
->syncpipe
;
1067 urb
->transfer_flags
= URB_ISO_ASAP
;
1068 urb
->number_of_packets
= SYNCFRAMES
;
1070 urb
->complete
= usbin_sync_completed
;
1071 /* stride: u->syncinterval */
1072 if (!usbin_sync_prepare_desc(u
, urb
) && !usb_submit_urb(urb
, GFP_KERNEL
))
1073 u
->flags
|= FLG_SYNC0RUNNING
;
1075 u
->flags
&= ~FLG_RUNNING
;
1077 if (u
->flags
& FLG_RUNNING
&& !(u
->flags
& FLG_SYNC1RUNNING
)) {
1078 urb
= u
->surb
[1].urb
;
1080 urb
->pipe
= u
->syncpipe
;
1081 urb
->transfer_flags
= URB_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
, GFP_KERNEL
))
1087 u
->flags
|= FLG_SYNC1RUNNING
;
1089 u
->flags
&= ~FLG_RUNNING
;
1092 spin_unlock_irqrestore(&as
->lock
, flags
);
1096 static void usbout_stop(struct usb_audiodev
*as
)
1098 struct usbout
*u
= &as
->usbout
;
1099 unsigned long flags
;
1100 unsigned int i
, notkilled
= 1;
1102 spin_lock_irqsave(&as
->lock
, flags
);
1103 u
->flags
&= ~FLG_RUNNING
;
1105 spin_unlock_irqrestore(&as
->lock
, flags
);
1106 while (i
& (FLG_URB0RUNNING
|FLG_URB1RUNNING
|FLG_SYNC0RUNNING
|FLG_SYNC1RUNNING
)) {
1108 schedule_timeout_interruptible(1);
1110 schedule_timeout_uninterruptible(1);
1111 spin_lock_irqsave(&as
->lock
, flags
);
1113 spin_unlock_irqrestore(&as
->lock
, flags
);
1114 if (notkilled
&& signal_pending(current
)) {
1115 if (i
& FLG_URB0RUNNING
)
1116 usb_kill_urb(u
->durb
[0].urb
);
1117 if (i
& FLG_URB1RUNNING
)
1118 usb_kill_urb(u
->durb
[1].urb
);
1119 if (i
& FLG_SYNC0RUNNING
)
1120 usb_kill_urb(u
->surb
[0].urb
);
1121 if (i
& FLG_SYNC1RUNNING
)
1122 usb_kill_urb(u
->surb
[1].urb
);
1126 set_current_state(TASK_RUNNING
);
1127 kfree(u
->durb
[0].urb
->transfer_buffer
);
1128 kfree(u
->durb
[1].urb
->transfer_buffer
);
1129 kfree(u
->surb
[0].urb
->transfer_buffer
);
1130 kfree(u
->surb
[1].urb
->transfer_buffer
);
1131 u
->durb
[0].urb
->transfer_buffer
= u
->durb
[1].urb
->transfer_buffer
=
1132 u
->surb
[0].urb
->transfer_buffer
= u
->surb
[1].urb
->transfer_buffer
= NULL
;
1135 static inline void usbout_release(struct usb_audiodev
*as
)
1140 static void usbout_disc(struct usb_audiodev
*as
)
1142 struct usbout
*u
= &as
->usbout
;
1143 unsigned long flags
;
1145 spin_lock_irqsave(&as
->lock
, flags
);
1146 u
->flags
&= ~(FLG_RUNNING
| FLG_CONNECTED
);
1147 spin_unlock_irqrestore(&as
->lock
, flags
);
1151 static void usbout_convert(struct usbout
*u
, unsigned char *buffer
, unsigned int samples
)
1157 unsigned int scnt
, maxs
, ufmtsh
, dfmtsh
;
1159 ufmtsh
= AFMT_BYTESSHIFT(u
->format
);
1160 dfmtsh
= AFMT_BYTESSHIFT(u
->dma
.format
);
1161 maxs
= (AFMT_ISSTEREO(u
->dma
.format
| u
->format
)) ? 32 : 64;
1162 while (samples
> 0) {
1166 dmabuf_copyout(&u
->dma
, tmp
.b
, scnt
<< dfmtsh
);
1167 conversion(tmp
.b
, u
->dma
.format
, buffer
, u
->format
, tmp
.b
, scnt
);
1168 buffer
+= scnt
<< ufmtsh
;
1173 static int usbout_prepare_desc(struct usbout
*u
, struct urb
*urb
)
1175 unsigned int i
, ufmtsh
, dfmtsh
, err
= 0, cnt
, scnt
, offs
;
1176 unsigned char *cp
= urb
->transfer_buffer
;
1178 ufmtsh
= AFMT_BYTESSHIFT(u
->format
);
1179 dfmtsh
= AFMT_BYTESSHIFT(u
->dma
.format
);
1180 for (i
= offs
= 0; i
< DESCFRAMES
; i
++) {
1181 urb
->iso_frame_desc
[i
].offset
= offs
;
1182 u
->phase
= (u
->phase
& 0x3fff) + u
->freqm
;
1183 scnt
= u
->phase
>> 14;
1185 urb
->iso_frame_desc
[i
].length
= 0;
1188 cnt
= scnt
<< dfmtsh
;
1189 if (!u
->dma
.mapped
) {
1190 if (cnt
> u
->dma
.count
) {
1191 scnt
= u
->dma
.count
>> dfmtsh
;
1192 cnt
= scnt
<< dfmtsh
;
1195 u
->dma
.count
-= cnt
;
1197 u
->dma
.count
+= cnt
;
1198 if (u
->format
== u
->dma
.format
) {
1199 /* we do not need format conversion */
1200 dmabuf_copyout(&u
->dma
, cp
, cnt
);
1202 /* we need sampling format conversion */
1203 usbout_convert(u
, cp
, scnt
);
1205 cnt
= scnt
<< ufmtsh
;
1206 urb
->iso_frame_desc
[i
].length
= cnt
;
1213 if (u
->dma
.mapped
) {
1214 if (u
->dma
.count
>= (signed)u
->dma
.fragsize
)
1215 wake_up(&u
->dma
.wait
);
1217 if ((signed)u
->dma
.dmasize
>= u
->dma
.count
+ (signed)u
->dma
.fragsize
)
1218 wake_up(&u
->dma
.wait
);
1220 return err
? -1 : 0;
1224 * return value: 0 if descriptor should be restarted, -1 otherwise
1226 static int usbout_retire_desc(struct usbout
*u
, struct urb
*urb
)
1230 for (i
= 0; i
< DESCFRAMES
; i
++) {
1231 if (urb
->iso_frame_desc
[i
].status
) {
1232 dprintk((KERN_DEBUG
"usbout_retire_desc: frame %u status %d\n", i
, urb
->iso_frame_desc
[i
].status
));
1239 static void usbout_completed(struct urb
*urb
, struct pt_regs
*regs
)
1241 struct usb_audiodev
*as
= (struct usb_audiodev
*)urb
->context
;
1242 struct usbout
*u
= &as
->usbout
;
1243 unsigned long flags
;
1248 printk(KERN_DEBUG
"usbout_completed: status %d errcnt %d flags 0x%x\n", urb
->status
, urb
->error_count
, u
->flags
);
1250 if (urb
== u
->durb
[0].urb
)
1251 mask
= FLG_URB0RUNNING
;
1252 else if (urb
== u
->durb
[1].urb
)
1253 mask
= FLG_URB1RUNNING
;
1256 printk(KERN_ERR
"usbout_completed: panic: unknown URB\n");
1258 urb
->dev
= as
->state
->usbdev
;
1259 spin_lock_irqsave(&as
->lock
, flags
);
1260 if (!usbout_retire_desc(u
, urb
) &&
1261 u
->flags
& FLG_RUNNING
&&
1262 !usbout_prepare_desc(u
, urb
) &&
1263 (suret
= usb_submit_urb(urb
, GFP_ATOMIC
)) == 0) {
1266 u
->flags
&= ~(mask
| FLG_RUNNING
);
1267 wake_up(&u
->dma
.wait
);
1268 dprintk((KERN_DEBUG
"usbout_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret
));
1270 spin_unlock_irqrestore(&as
->lock
, flags
);
1273 static int usbout_sync_prepare_desc(struct usbout
*u
, struct urb
*urb
)
1275 unsigned int i
, offs
;
1277 for (i
= offs
= 0; i
< SYNCFRAMES
; i
++, offs
+= 3) {
1278 urb
->iso_frame_desc
[i
].length
= 3;
1279 urb
->iso_frame_desc
[i
].offset
= offs
;
1286 * return value: 0 if descriptor should be restarted, -1 otherwise
1288 static int usbout_sync_retire_desc(struct usbout
*u
, struct urb
*urb
)
1290 unsigned char *cp
= urb
->transfer_buffer
;
1293 for (i
= 0; i
< SYNCFRAMES
; i
++, cp
+= 3) {
1294 if (urb
->iso_frame_desc
[i
].status
) {
1295 dprintk((KERN_DEBUG
"usbout_sync_retire_desc: frame %u status %d\n", i
, urb
->iso_frame_desc
[i
].status
));
1298 if (urb
->iso_frame_desc
[i
].actual_length
< 3) {
1299 dprintk((KERN_DEBUG
"usbout_sync_retire_desc: frame %u length %d\n", i
, urb
->iso_frame_desc
[i
].actual_length
));
1302 f
= cp
[0] | (cp
[1] << 8) | (cp
[2] << 16);
1303 if (abs(f
- u
->freqn
) > (u
->freqn
>> 3) || f
> u
->freqmax
) {
1304 printk(KERN_WARNING
"usbout_sync_retire_desc: requested frequency %u (nominal %u) out of range!\n", f
, u
->freqn
);
1312 static void usbout_sync_completed(struct urb
*urb
, struct pt_regs
*regs
)
1314 struct usb_audiodev
*as
= (struct usb_audiodev
*)urb
->context
;
1315 struct usbout
*u
= &as
->usbout
;
1316 unsigned long flags
;
1321 printk(KERN_DEBUG
"usbout_sync_completed: status %d errcnt %d flags 0x%x\n", urb
->status
, urb
->error_count
, u
->flags
);
1323 if (urb
== u
->surb
[0].urb
)
1324 mask
= FLG_SYNC0RUNNING
;
1325 else if (urb
== u
->surb
[1].urb
)
1326 mask
= FLG_SYNC1RUNNING
;
1329 printk(KERN_ERR
"usbout_sync_completed: panic: unknown URB\n");
1331 urb
->dev
= as
->state
->usbdev
;
1332 spin_lock_irqsave(&as
->lock
, flags
);
1333 if (!usbout_sync_retire_desc(u
, urb
) &&
1334 u
->flags
& FLG_RUNNING
&&
1335 !usbout_sync_prepare_desc(u
, urb
) &&
1336 (suret
= usb_submit_urb(urb
, GFP_ATOMIC
)) == 0) {
1339 u
->flags
&= ~(mask
| FLG_RUNNING
);
1340 wake_up(&u
->dma
.wait
);
1341 dprintk((KERN_DEBUG
"usbout_sync_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret
));
1343 spin_unlock_irqrestore(&as
->lock
, flags
);
1346 static int usbout_start(struct usb_audiodev
*as
)
1348 struct usb_device
*dev
= as
->state
->usbdev
;
1349 struct usbout
*u
= &as
->usbout
;
1351 unsigned long flags
;
1352 unsigned int maxsze
, bufsz
;
1355 printk(KERN_DEBUG
"usbout_start: device %d ufmt 0x%08x dfmt 0x%08x srate %d\n",
1356 dev
->devnum
, u
->format
, u
->dma
.format
, u
->dma
.srate
);
1358 /* allocate USB storage if not already done */
1359 spin_lock_irqsave(&as
->lock
, flags
);
1360 if (!(u
->flags
& FLG_CONNECTED
)) {
1361 spin_unlock_irqrestore(&as
->lock
, flags
);
1364 if (!(u
->flags
& FLG_RUNNING
)) {
1365 spin_unlock_irqrestore(&as
->lock
, flags
);
1366 u
->freqn
= u
->freqm
= ((u
->dma
.srate
<< 11) + 62) / 125; /* this will overflow at approx 2MSPS */
1367 u
->freqmax
= u
->freqn
+ (u
->freqn
>> 2);
1369 maxsze
= (u
->freqmax
+ 0x3fff) >> (14 - AFMT_BYTESSHIFT(u
->format
));
1370 bufsz
= DESCFRAMES
* maxsze
;
1371 kfree(u
->durb
[0].urb
->transfer_buffer
);
1372 u
->durb
[0].urb
->transfer_buffer
= kmalloc(bufsz
, GFP_KERNEL
);
1373 u
->durb
[0].urb
->transfer_buffer_length
= bufsz
;
1374 kfree(u
->durb
[1].urb
->transfer_buffer
);
1375 u
->durb
[1].urb
->transfer_buffer
= kmalloc(bufsz
, GFP_KERNEL
);
1376 u
->durb
[1].urb
->transfer_buffer_length
= bufsz
;
1378 kfree(u
->surb
[0].urb
->transfer_buffer
);
1379 u
->surb
[0].urb
->transfer_buffer
= kmalloc(3*SYNCFRAMES
, GFP_KERNEL
);
1380 u
->surb
[0].urb
->transfer_buffer_length
= 3*SYNCFRAMES
;
1381 kfree(u
->surb
[1].urb
->transfer_buffer
);
1382 u
->surb
[1].urb
->transfer_buffer
= kmalloc(3*SYNCFRAMES
, GFP_KERNEL
);
1383 u
->surb
[1].urb
->transfer_buffer_length
= 3*SYNCFRAMES
;
1385 if (!u
->durb
[0].urb
->transfer_buffer
|| !u
->durb
[1].urb
->transfer_buffer
||
1386 (u
->syncpipe
&& (!u
->surb
[0].urb
->transfer_buffer
|| !u
->surb
[1].urb
->transfer_buffer
))) {
1387 printk(KERN_ERR
"usbaudio: cannot start playback device %d\n", dev
->devnum
);
1390 spin_lock_irqsave(&as
->lock
, flags
);
1392 if (u
->dma
.count
<= 0 && !u
->dma
.mapped
) {
1393 spin_unlock_irqrestore(&as
->lock
, flags
);
1396 u
->flags
|= FLG_RUNNING
;
1397 if (!(u
->flags
& FLG_URB0RUNNING
)) {
1398 urb
= u
->durb
[0].urb
;
1400 urb
->pipe
= u
->datapipe
;
1401 urb
->transfer_flags
= URB_ISO_ASAP
;
1402 urb
->number_of_packets
= DESCFRAMES
;
1404 urb
->complete
= usbout_completed
;
1405 if (!usbout_prepare_desc(u
, urb
) && !usb_submit_urb(urb
, GFP_ATOMIC
))
1406 u
->flags
|= FLG_URB0RUNNING
;
1408 u
->flags
&= ~FLG_RUNNING
;
1410 if (u
->flags
& FLG_RUNNING
&& !(u
->flags
& FLG_URB1RUNNING
)) {
1411 urb
= u
->durb
[1].urb
;
1413 urb
->pipe
= u
->datapipe
;
1414 urb
->transfer_flags
= URB_ISO_ASAP
;
1415 urb
->number_of_packets
= DESCFRAMES
;
1417 urb
->complete
= usbout_completed
;
1418 if (!usbout_prepare_desc(u
, urb
) && !usb_submit_urb(urb
, GFP_ATOMIC
))
1419 u
->flags
|= FLG_URB1RUNNING
;
1421 u
->flags
&= ~FLG_RUNNING
;
1424 if (u
->flags
& FLG_RUNNING
&& !(u
->flags
& FLG_SYNC0RUNNING
)) {
1425 urb
= u
->surb
[0].urb
;
1427 urb
->pipe
= u
->syncpipe
;
1428 urb
->transfer_flags
= URB_ISO_ASAP
;
1429 urb
->number_of_packets
= SYNCFRAMES
;
1431 urb
->complete
= usbout_sync_completed
;
1432 /* stride: u->syncinterval */
1433 if (!usbout_sync_prepare_desc(u
, urb
) && !usb_submit_urb(urb
, GFP_ATOMIC
))
1434 u
->flags
|= FLG_SYNC0RUNNING
;
1436 u
->flags
&= ~FLG_RUNNING
;
1438 if (u
->flags
& FLG_RUNNING
&& !(u
->flags
& FLG_SYNC1RUNNING
)) {
1439 urb
= u
->surb
[1].urb
;
1441 urb
->pipe
= u
->syncpipe
;
1442 urb
->transfer_flags
= URB_ISO_ASAP
;
1443 urb
->number_of_packets
= SYNCFRAMES
;
1445 urb
->complete
= usbout_sync_completed
;
1446 /* stride: u->syncinterval */
1447 if (!usbout_sync_prepare_desc(u
, urb
) && !usb_submit_urb(urb
, GFP_ATOMIC
))
1448 u
->flags
|= FLG_SYNC1RUNNING
;
1450 u
->flags
&= ~FLG_RUNNING
;
1453 spin_unlock_irqrestore(&as
->lock
, flags
);
1457 /* --------------------------------------------------------------------- */
1459 static unsigned int format_goodness(struct audioformat
*afp
, unsigned int fmt
, unsigned int srate
)
1463 if (srate
< afp
->sratelo
)
1464 g
+= afp
->sratelo
- srate
;
1465 if (srate
> afp
->sratehi
)
1466 g
+= srate
- afp
->sratehi
;
1467 if (AFMT_ISSTEREO(afp
->format
) && !AFMT_ISSTEREO(fmt
))
1469 if (!AFMT_ISSTEREO(afp
->format
) && AFMT_ISSTEREO(fmt
))
1471 if (AFMT_IS16BIT(afp
->format
) && !AFMT_IS16BIT(fmt
))
1473 if (!AFMT_IS16BIT(afp
->format
) && AFMT_IS16BIT(fmt
))
1478 static int find_format(struct audioformat
*afp
, unsigned int nr
, unsigned int fmt
, unsigned int srate
)
1480 unsigned int i
, g
, gb
= ~0;
1481 int j
= -1; /* default to failure */
1483 /* find "best" format (according to format_goodness) */
1484 for (i
= 0; i
< nr
; i
++) {
1485 g
= format_goodness(&afp
[i
], fmt
, srate
);
1494 static int set_format_in(struct usb_audiodev
*as
)
1496 struct usb_device
*dev
= as
->state
->usbdev
;
1497 struct usb_host_interface
*alts
;
1498 struct usb_interface
*iface
;
1499 struct usbin
*u
= &as
->usbin
;
1500 struct dmabuf
*d
= &u
->dma
;
1501 struct audioformat
*fmt
;
1503 unsigned char data
[3];
1506 iface
= usb_ifnum_to_if(dev
, u
->interface
);
1510 fmtnr
= find_format(as
->fmtin
, as
->numfmtin
, d
->format
, d
->srate
);
1512 printk(KERN_ERR
"usbaudio: set_format_in(): failed to find desired format/speed combination.\n");
1516 fmt
= as
->fmtin
+ fmtnr
;
1517 alts
= usb_altnum_to_altsetting(iface
, fmt
->altsetting
);
1518 u
->format
= fmt
->format
;
1519 u
->datapipe
= usb_rcvisocpipe(dev
, alts
->endpoint
[0].desc
.bEndpointAddress
& 0xf);
1520 u
->syncpipe
= u
->syncinterval
= 0;
1521 if ((alts
->endpoint
[0].desc
.bmAttributes
& 0x0c) == 0x08) {
1522 if (alts
->desc
.bNumEndpoints
< 2 ||
1523 alts
->endpoint
[1].desc
.bmAttributes
!= 0x01 ||
1524 alts
->endpoint
[1].desc
.bSynchAddress
!= 0 ||
1525 alts
->endpoint
[1].desc
.bEndpointAddress
!= (alts
->endpoint
[0].desc
.bSynchAddress
& 0x7f)) {
1526 printk(KERN_WARNING
"usbaudio: device %d interface %d altsetting %d claims adaptive in "
1527 "but has invalid synch pipe; treating as asynchronous in\n",
1528 dev
->devnum
, u
->interface
, fmt
->altsetting
);
1530 u
->syncpipe
= usb_sndisocpipe(dev
, alts
->endpoint
[1].desc
.bEndpointAddress
& 0xf);
1531 u
->syncinterval
= alts
->endpoint
[1].desc
.bRefresh
;
1534 if (d
->srate
< fmt
->sratelo
)
1535 d
->srate
= fmt
->sratelo
;
1536 if (d
->srate
> fmt
->sratehi
)
1537 d
->srate
= fmt
->sratehi
;
1538 dprintk((KERN_DEBUG
"usbaudio: set_format_in: usb_set_interface %u %u\n",
1539 u
->interface
, fmt
->altsetting
));
1540 if (usb_set_interface(dev
, alts
->desc
.bInterfaceNumber
, fmt
->altsetting
) < 0) {
1541 printk(KERN_WARNING
"usbaudio: usb_set_interface failed, device %d interface %d altsetting %d\n",
1542 dev
->devnum
, u
->interface
, fmt
->altsetting
);
1545 if (fmt
->sratelo
== fmt
->sratehi
)
1547 ep
= usb_pipeendpoint(u
->datapipe
) | (u
->datapipe
& USB_DIR_IN
);
1548 /* if endpoint has pitch control, enable it */
1549 if (fmt
->attributes
& 0x02) {
1551 if ((ret
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), SET_CUR
, USB_TYPE_CLASS
|USB_RECIP_ENDPOINT
|USB_DIR_OUT
,
1552 PITCH_CONTROL
<< 8, ep
, data
, 1, 1000)) < 0) {
1553 printk(KERN_ERR
"usbaudio: failure (error %d) to set output pitch control device %d interface %u endpoint 0x%x to %u\n",
1554 ret
, dev
->devnum
, u
->interface
, ep
, d
->srate
);
1558 /* if endpoint has sampling rate control, set it */
1559 if (fmt
->attributes
& 0x01) {
1561 data
[1] = d
->srate
>> 8;
1562 data
[2] = d
->srate
>> 16;
1563 if ((ret
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), SET_CUR
, USB_TYPE_CLASS
|USB_RECIP_ENDPOINT
|USB_DIR_OUT
,
1564 SAMPLING_FREQ_CONTROL
<< 8, ep
, data
, 3, 1000)) < 0) {
1565 printk(KERN_ERR
"usbaudio: failure (error %d) to set input sampling frequency device %d interface %u endpoint 0x%x to %u\n",
1566 ret
, dev
->devnum
, u
->interface
, ep
, d
->srate
);
1569 if ((ret
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_CUR
, USB_TYPE_CLASS
|USB_RECIP_ENDPOINT
|USB_DIR_IN
,
1570 SAMPLING_FREQ_CONTROL
<< 8, ep
, data
, 3, 1000)) < 0) {
1571 printk(KERN_ERR
"usbaudio: failure (error %d) to get input sampling frequency device %d interface %u endpoint 0x%x\n",
1572 ret
, dev
->devnum
, u
->interface
, ep
);
1575 dprintk((KERN_DEBUG
"usbaudio: set_format_in: device %d interface %d altsetting %d srate req: %u real %u\n",
1576 dev
->devnum
, u
->interface
, fmt
->altsetting
, d
->srate
, data
[0] | (data
[1] << 8) | (data
[2] << 16)));
1577 d
->srate
= data
[0] | (data
[1] << 8) | (data
[2] << 16);
1579 dprintk((KERN_DEBUG
"usbaudio: set_format_in: USB format 0x%x, DMA format 0x%x srate %u\n", u
->format
, d
->format
, d
->srate
));
1583 static int set_format_out(struct usb_audiodev
*as
)
1585 struct usb_device
*dev
= as
->state
->usbdev
;
1586 struct usb_host_interface
*alts
;
1587 struct usb_interface
*iface
;
1588 struct usbout
*u
= &as
->usbout
;
1589 struct dmabuf
*d
= &u
->dma
;
1590 struct audioformat
*fmt
;
1592 unsigned char data
[3];
1595 iface
= usb_ifnum_to_if(dev
, u
->interface
);
1599 fmtnr
= find_format(as
->fmtout
, as
->numfmtout
, d
->format
, d
->srate
);
1601 printk(KERN_ERR
"usbaudio: set_format_out(): failed to find desired format/speed combination.\n");
1605 fmt
= as
->fmtout
+ fmtnr
;
1606 u
->format
= fmt
->format
;
1607 alts
= usb_altnum_to_altsetting(iface
, fmt
->altsetting
);
1608 u
->datapipe
= usb_sndisocpipe(dev
, alts
->endpoint
[0].desc
.bEndpointAddress
& 0xf);
1609 u
->syncpipe
= u
->syncinterval
= 0;
1610 if ((alts
->endpoint
[0].desc
.bmAttributes
& 0x0c) == 0x04) {
1612 printk(KERN_DEBUG
"bNumEndpoints 0x%02x endpoint[1].bmAttributes 0x%02x\n"
1613 KERN_DEBUG
"endpoint[1].bSynchAddress 0x%02x endpoint[1].bEndpointAddress 0x%02x\n"
1614 KERN_DEBUG
"endpoint[0].bSynchAddress 0x%02x\n", alts
->bNumEndpoints
,
1615 alts
->endpoint
[1].bmAttributes
, alts
->endpoint
[1].bSynchAddress
,
1616 alts
->endpoint
[1].bEndpointAddress
, alts
->endpoint
[0].bSynchAddress
);
1618 if (alts
->desc
.bNumEndpoints
< 2 ||
1619 alts
->endpoint
[1].desc
.bmAttributes
!= 0x01 ||
1620 alts
->endpoint
[1].desc
.bSynchAddress
!= 0 ||
1621 alts
->endpoint
[1].desc
.bEndpointAddress
!= (alts
->endpoint
[0].desc
.bSynchAddress
| 0x80)) {
1622 printk(KERN_WARNING
"usbaudio: device %d interface %d altsetting %d claims asynch out "
1623 "but has invalid synch pipe; treating as adaptive out\n",
1624 dev
->devnum
, u
->interface
, fmt
->altsetting
);
1626 u
->syncpipe
= usb_rcvisocpipe(dev
, alts
->endpoint
[1].desc
.bEndpointAddress
& 0xf);
1627 u
->syncinterval
= alts
->endpoint
[1].desc
.bRefresh
;
1630 if (d
->srate
< fmt
->sratelo
)
1631 d
->srate
= fmt
->sratelo
;
1632 if (d
->srate
> fmt
->sratehi
)
1633 d
->srate
= fmt
->sratehi
;
1634 dprintk((KERN_DEBUG
"usbaudio: set_format_out: usb_set_interface %u %u\n",
1635 u
->interface
, fmt
->altsetting
));
1636 if (usb_set_interface(dev
, u
->interface
, fmt
->altsetting
) < 0) {
1637 printk(KERN_WARNING
"usbaudio: usb_set_interface failed, device %d interface %d altsetting %d\n",
1638 dev
->devnum
, u
->interface
, fmt
->altsetting
);
1641 if (fmt
->sratelo
== fmt
->sratehi
)
1643 ep
= usb_pipeendpoint(u
->datapipe
) | (u
->datapipe
& USB_DIR_IN
);
1644 /* if endpoint has pitch control, enable it */
1645 if (fmt
->attributes
& 0x02) {
1647 if ((ret
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), SET_CUR
, USB_TYPE_CLASS
|USB_RECIP_ENDPOINT
|USB_DIR_OUT
,
1648 PITCH_CONTROL
<< 8, ep
, data
, 1, 1000)) < 0) {
1649 printk(KERN_ERR
"usbaudio: failure (error %d) to set output pitch control device %d interface %u endpoint 0x%x to %u\n",
1650 ret
, dev
->devnum
, u
->interface
, ep
, d
->srate
);
1654 /* if endpoint has sampling rate control, set it */
1655 if (fmt
->attributes
& 0x01) {
1657 data
[1] = d
->srate
>> 8;
1658 data
[2] = d
->srate
>> 16;
1659 if ((ret
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), SET_CUR
, USB_TYPE_CLASS
|USB_RECIP_ENDPOINT
|USB_DIR_OUT
,
1660 SAMPLING_FREQ_CONTROL
<< 8, ep
, data
, 3, 1000)) < 0) {
1661 printk(KERN_ERR
"usbaudio: failure (error %d) to set output sampling frequency device %d interface %u endpoint 0x%x to %u\n",
1662 ret
, dev
->devnum
, u
->interface
, ep
, d
->srate
);
1665 if ((ret
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_CUR
, USB_TYPE_CLASS
|USB_RECIP_ENDPOINT
|USB_DIR_IN
,
1666 SAMPLING_FREQ_CONTROL
<< 8, ep
, data
, 3, 1000)) < 0) {
1667 printk(KERN_ERR
"usbaudio: failure (error %d) to get output sampling frequency device %d interface %u endpoint 0x%x\n",
1668 ret
, dev
->devnum
, u
->interface
, ep
);
1671 dprintk((KERN_DEBUG
"usbaudio: set_format_out: device %d interface %d altsetting %d srate req: %u real %u\n",
1672 dev
->devnum
, u
->interface
, fmt
->altsetting
, d
->srate
, data
[0] | (data
[1] << 8) | (data
[2] << 16)));
1673 d
->srate
= data
[0] | (data
[1] << 8) | (data
[2] << 16);
1675 dprintk((KERN_DEBUG
"usbaudio: set_format_out: USB format 0x%x, DMA format 0x%x srate %u\n", u
->format
, d
->format
, d
->srate
));
1679 static int set_format(struct usb_audiodev
*s
, unsigned int fmode
, unsigned int fmt
, unsigned int srate
)
1681 int ret1
= 0, ret2
= 0;
1683 if (!(fmode
& (FMODE_READ
|FMODE_WRITE
)))
1685 if (fmode
& FMODE_READ
) {
1687 s
->usbin
.dma
.ready
= 0;
1688 if (fmt
== AFMT_QUERY
)
1689 fmt
= s
->usbin
.dma
.format
;
1691 s
->usbin
.dma
.format
= fmt
;
1693 srate
= s
->usbin
.dma
.srate
;
1695 s
->usbin
.dma
.srate
= srate
;
1697 if (fmode
& FMODE_WRITE
) {
1699 s
->usbout
.dma
.ready
= 0;
1700 if (fmt
== AFMT_QUERY
)
1701 fmt
= s
->usbout
.dma
.format
;
1703 s
->usbout
.dma
.format
= fmt
;
1705 srate
= s
->usbout
.dma
.srate
;
1707 s
->usbout
.dma
.srate
= srate
;
1709 if (fmode
& FMODE_READ
)
1710 ret1
= set_format_in(s
);
1711 if (fmode
& FMODE_WRITE
)
1712 ret2
= set_format_out(s
);
1713 return ret1
? ret1
: ret2
;
1716 /* --------------------------------------------------------------------- */
1718 static int wrmixer(struct usb_mixerdev
*ms
, unsigned mixch
, unsigned value
)
1720 struct usb_device
*dev
= ms
->state
->usbdev
;
1721 unsigned char data
[2];
1722 struct mixerchannel
*ch
;
1725 if (mixch
>= ms
->numch
)
1727 ch
= &ms
->ch
[mixch
];
1728 v3
= ch
->maxval
- ch
->minval
;
1730 v2
= (value
>> 8) & 0xff;
1735 if (!(ch
->flags
& (MIXFLG_STEREOIN
| MIXFLG_STEREOOUT
)))
1737 ch
->value
= v1
| (v2
<< 8);
1738 v1
= (v1
* v3
) / 100 + ch
->minval
;
1739 v2
= (v2
* v3
) / 100 + ch
->minval
;
1740 switch (ch
->selector
) {
1741 case 0: /* mixer unit request */
1744 if (usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), SET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_OUT
,
1745 (ch
->chnum
<< 8) | 1, ms
->iface
| (ch
->unitid
<< 8), data
, 2, 1000) < 0)
1747 if (!(ch
->flags
& (MIXFLG_STEREOIN
| MIXFLG_STEREOOUT
)))
1751 if (usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), SET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_OUT
,
1752 ((ch
->chnum
+ !!(ch
->flags
& MIXFLG_STEREOIN
)) << 8) | (1 + !!(ch
->flags
& MIXFLG_STEREOOUT
)),
1753 ms
->iface
| (ch
->unitid
<< 8), data
, 2, 1000) < 0)
1757 /* various feature unit controls */
1758 case VOLUME_CONTROL
:
1761 if (usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), SET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_OUT
,
1762 (ch
->selector
<< 8) | ch
->chnum
, ms
->iface
| (ch
->unitid
<< 8), data
, 2, 1000) < 0)
1764 if (!(ch
->flags
& (MIXFLG_STEREOIN
| MIXFLG_STEREOOUT
)))
1768 if (usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), SET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_OUT
,
1769 (ch
->selector
<< 8) | (ch
->chnum
+ 1), ms
->iface
| (ch
->unitid
<< 8), data
, 2, 1000) < 0)
1775 case TREBLE_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
, 1, 1000) < 0)
1780 if (!(ch
->flags
& (MIXFLG_STEREOIN
| MIXFLG_STEREOOUT
)))
1783 if (usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), SET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_OUT
,
1784 (ch
->selector
<< 8) | (ch
->chnum
+ 1), ms
->iface
| (ch
->unitid
<< 8), data
, 1, 1000) < 0)
1794 printk(KERN_ERR
"usbaudio: mixer request device %u if %u unit %u ch %u selector %u failed\n",
1795 dev
->devnum
, ms
->iface
, ch
->unitid
, ch
->chnum
, ch
->selector
);
1799 static int get_rec_src(struct usb_mixerdev
*ms
)
1801 struct usb_device
*dev
= ms
->state
->usbdev
;
1802 unsigned int mask
= 0, retmask
= 0;
1807 for (i
= 0; i
< ms
->numch
; i
++) {
1808 if (!ms
->ch
[i
].slctunitid
|| (mask
& (1 << i
)))
1810 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
1811 0, ms
->iface
| (ms
->ch
[i
].slctunitid
<< 8), &buf
, 1, 1000) < 0) {
1813 printk(KERN_ERR
"usbaudio: selector read request device %u if %u unit %u failed\n",
1814 dev
->devnum
, ms
->iface
, ms
->ch
[i
].slctunitid
& 0xff);
1817 for (j
= i
; j
< ms
->numch
; j
++) {
1818 if ((ms
->ch
[i
].slctunitid
^ ms
->ch
[j
].slctunitid
) & 0xff)
1821 if (buf
== (ms
->ch
[j
].slctunitid
>> 8))
1822 retmask
|= 1 << ms
->ch
[j
].osschannel
;
1830 static int set_rec_src(struct usb_mixerdev
*ms
, int srcmask
)
1832 struct usb_device
*dev
= ms
->state
->usbdev
;
1833 unsigned int mask
= 0, smask
, bmask
;
1838 for (i
= 0; i
< ms
->numch
; i
++) {
1839 if (!ms
->ch
[i
].slctunitid
|| (mask
& (1 << i
)))
1841 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
1842 0, ms
->iface
| (ms
->ch
[i
].slctunitid
<< 8), &buf
, 1, 1000) < 0) {
1844 printk(KERN_ERR
"usbaudio: selector read request device %u if %u unit %u failed\n",
1845 dev
->devnum
, ms
->iface
, ms
->ch
[i
].slctunitid
& 0xff);
1848 /* first generate smask */
1850 for (j
= i
; j
< ms
->numch
; j
++) {
1851 if ((ms
->ch
[i
].slctunitid
^ ms
->ch
[j
].slctunitid
) & 0xff)
1853 smask
|= 1 << ms
->ch
[j
].osschannel
;
1854 if (buf
== (ms
->ch
[j
].slctunitid
>> 8))
1855 bmask
|= 1 << ms
->ch
[j
].osschannel
;
1858 /* check for multiple set sources */
1859 j
= hweight32(srcmask
& smask
);
1864 for (j
= i
; j
< ms
->numch
; j
++) {
1865 if ((ms
->ch
[i
].slctunitid
^ ms
->ch
[j
].slctunitid
) & 0xff)
1867 if (!(srcmask
& (1 << ms
->ch
[j
].osschannel
)))
1869 buf
= ms
->ch
[j
].slctunitid
>> 8;
1870 if (usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), SET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_OUT
,
1871 0, ms
->iface
| (ms
->ch
[j
].slctunitid
<< 8), &buf
, 1, 1000) < 0) {
1873 printk(KERN_ERR
"usbaudio: selector write request device %u if %u unit %u failed\n",
1874 dev
->devnum
, ms
->iface
, ms
->ch
[j
].slctunitid
& 0xff);
1879 return err
? -EIO
: 0;
1882 /* --------------------------------------------------------------------- */
1885 * should be called with open_sem hold, so that no new processes
1886 * look at the audio device to be destroyed
1889 static void release(struct usb_audio_state
*s
)
1891 struct usb_audiodev
*as
;
1892 struct usb_mixerdev
*ms
;
1900 wake_up(&open_wait
);
1901 while (!list_empty(&s
->audiolist
)) {
1902 as
= list_entry(s
->audiolist
.next
, struct usb_audiodev
, list
);
1903 list_del(&as
->list
);
1906 dmabuf_release(&as
->usbin
.dma
);
1907 dmabuf_release(&as
->usbout
.dma
);
1908 usb_free_urb(as
->usbin
.durb
[0].urb
);
1909 usb_free_urb(as
->usbin
.durb
[1].urb
);
1910 usb_free_urb(as
->usbin
.surb
[0].urb
);
1911 usb_free_urb(as
->usbin
.surb
[1].urb
);
1912 usb_free_urb(as
->usbout
.durb
[0].urb
);
1913 usb_free_urb(as
->usbout
.durb
[1].urb
);
1914 usb_free_urb(as
->usbout
.surb
[0].urb
);
1915 usb_free_urb(as
->usbout
.surb
[1].urb
);
1918 while (!list_empty(&s
->mixerlist
)) {
1919 ms
= list_entry(s
->mixerlist
.next
, struct usb_mixerdev
, list
);
1920 list_del(&ms
->list
);
1926 static inline int prog_dmabuf_in(struct usb_audiodev
*as
)
1929 return dmabuf_init(&as
->usbin
.dma
);
1932 static inline int prog_dmabuf_out(struct usb_audiodev
*as
)
1935 return dmabuf_init(&as
->usbout
.dma
);
1938 /* --------------------------------------------------------------------- */
1940 static int usb_audio_open_mixdev(struct inode
*inode
, struct file
*file
)
1942 unsigned int minor
= iminor(inode
);
1943 struct usb_mixerdev
*ms
;
1944 struct usb_audio_state
*s
;
1947 list_for_each_entry(s
, &audiodevs
, audiodev
) {
1948 list_for_each_entry(ms
, &s
->mixerlist
, list
) {
1949 if (ms
->dev_mixer
== minor
)
1961 file
->private_data
= ms
;
1965 return nonseekable_open(inode
, file
);
1968 static int usb_audio_release_mixdev(struct inode
*inode
, struct file
*file
)
1970 struct usb_mixerdev
*ms
= (struct usb_mixerdev
*)file
->private_data
;
1971 struct usb_audio_state
*s
;
1981 static int usb_audio_ioctl_mixdev(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1983 struct usb_mixerdev
*ms
= (struct usb_mixerdev
*)file
->private_data
;
1985 int __user
*user_arg
= (int __user
*)arg
;
1987 if (!ms
->state
->usbdev
)
1990 if (cmd
== SOUND_MIXER_INFO
) {
1993 memset(&info
, 0, sizeof(info
));
1994 strncpy(info
.id
, "USB_AUDIO", sizeof(info
.id
));
1995 strncpy(info
.name
, "USB Audio Class Driver", sizeof(info
.name
));
1996 info
.modify_counter
= ms
->modcnt
;
1997 if (copy_to_user((void __user
*)arg
, &info
, sizeof(info
)))
2001 if (cmd
== SOUND_OLD_MIXER_INFO
) {
2002 _old_mixer_info info
;
2004 memset(&info
, 0, sizeof(info
));
2005 strncpy(info
.id
, "USB_AUDIO", sizeof(info
.id
));
2006 strncpy(info
.name
, "USB Audio Class Driver", sizeof(info
.name
));
2007 if (copy_to_user((void __user
*)arg
, &info
, sizeof(info
)))
2011 if (cmd
== OSS_GETVERSION
)
2012 return put_user(SOUND_VERSION
, user_arg
);
2013 if (_IOC_TYPE(cmd
) != 'M' || _IOC_SIZE(cmd
) != sizeof(int))
2015 if (_IOC_DIR(cmd
) == _IOC_READ
) {
2016 switch (_IOC_NR(cmd
)) {
2017 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
2018 val
= get_rec_src(ms
);
2021 return put_user(val
, user_arg
);
2023 case SOUND_MIXER_DEVMASK
: /* Arg contains a bit for each supported device */
2024 for (val
= i
= 0; i
< ms
->numch
; i
++)
2025 val
|= 1 << ms
->ch
[i
].osschannel
;
2026 return put_user(val
, user_arg
);
2028 case SOUND_MIXER_RECMASK
: /* Arg contains a bit for each supported recording source */
2029 for (val
= i
= 0; i
< ms
->numch
; i
++)
2030 if (ms
->ch
[i
].slctunitid
)
2031 val
|= 1 << ms
->ch
[i
].osschannel
;
2032 return put_user(val
, user_arg
);
2034 case SOUND_MIXER_STEREODEVS
: /* Mixer channels supporting stereo */
2035 for (val
= i
= 0; i
< ms
->numch
; i
++)
2036 if (ms
->ch
[i
].flags
& (MIXFLG_STEREOIN
| MIXFLG_STEREOOUT
))
2037 val
|= 1 << ms
->ch
[i
].osschannel
;
2038 return put_user(val
, user_arg
);
2040 case SOUND_MIXER_CAPS
:
2041 return put_user(SOUND_CAP_EXCL_INPUT
, user_arg
);
2045 if (i
>= SOUND_MIXER_NRDEVICES
)
2047 for (j
= 0; j
< ms
->numch
; j
++) {
2048 if (ms
->ch
[j
].osschannel
== i
) {
2049 return put_user(ms
->ch
[j
].value
, user_arg
);
2055 if (_IOC_DIR(cmd
) != (_IOC_READ
|_IOC_WRITE
))
2058 switch (_IOC_NR(cmd
)) {
2059 case SOUND_MIXER_RECSRC
: /* Arg contains a bit for each recording source */
2060 if (get_user(val
, user_arg
))
2062 return set_rec_src(ms
, val
);
2066 if (i
>= SOUND_MIXER_NRDEVICES
)
2068 for (j
= 0; j
< ms
->numch
&& ms
->ch
[j
].osschannel
!= i
; j
++);
2071 if (get_user(val
, user_arg
))
2073 if (wrmixer(ms
, j
, val
))
2075 return put_user(ms
->ch
[j
].value
, user_arg
);
2079 static /*const*/ struct file_operations usb_mixer_fops
= {
2080 .owner
= THIS_MODULE
,
2081 .llseek
= no_llseek
,
2082 .ioctl
= usb_audio_ioctl_mixdev
,
2083 .open
= usb_audio_open_mixdev
,
2084 .release
= usb_audio_release_mixdev
,
2087 /* --------------------------------------------------------------------- */
2089 static int drain_out(struct usb_audiodev
*as
, int nonblock
)
2091 DECLARE_WAITQUEUE(wait
, current
);
2092 unsigned long flags
;
2095 if (as
->usbout
.dma
.mapped
|| !as
->usbout
.dma
.ready
)
2098 add_wait_queue(&as
->usbout
.dma
.wait
, &wait
);
2100 __set_current_state(TASK_INTERRUPTIBLE
);
2101 spin_lock_irqsave(&as
->lock
, flags
);
2102 count
= as
->usbout
.dma
.count
;
2103 spin_unlock_irqrestore(&as
->lock
, flags
);
2106 if (signal_pending(current
))
2109 remove_wait_queue(&as
->usbout
.dma
.wait
, &wait
);
2110 set_current_state(TASK_RUNNING
);
2113 tmo
= 3 * HZ
* count
/ as
->usbout
.dma
.srate
;
2114 tmo
>>= AFMT_BYTESSHIFT(as
->usbout
.dma
.format
);
2115 if (!schedule_timeout(tmo
+ 1)) {
2116 printk(KERN_DEBUG
"usbaudio: dma timed out??\n");
2120 remove_wait_queue(&as
->usbout
.dma
.wait
, &wait
);
2121 set_current_state(TASK_RUNNING
);
2122 if (signal_pending(current
))
2123 return -ERESTARTSYS
;
2127 /* --------------------------------------------------------------------- */
2129 static ssize_t
usb_audio_read(struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*ppos
)
2131 struct usb_audiodev
*as
= (struct usb_audiodev
*)file
->private_data
;
2132 DECLARE_WAITQUEUE(wait
, current
);
2134 unsigned long flags
;
2138 if (as
->usbin
.dma
.mapped
)
2140 if (!as
->usbin
.dma
.ready
&& (ret
= prog_dmabuf_in(as
)))
2142 if (!access_ok(VERIFY_WRITE
, buffer
, count
))
2144 add_wait_queue(&as
->usbin
.dma
.wait
, &wait
);
2146 spin_lock_irqsave(&as
->lock
, flags
);
2147 ptr
= as
->usbin
.dma
.rdptr
;
2148 cnt
= as
->usbin
.dma
.count
;
2149 /* set task state early to avoid wakeup races */
2151 __set_current_state(TASK_INTERRUPTIBLE
);
2152 spin_unlock_irqrestore(&as
->lock
, flags
);
2156 if (usbin_start(as
)) {
2161 if (file
->f_flags
& O_NONBLOCK
) {
2167 if (signal_pending(current
)) {
2174 if ((err
= dmabuf_copyout_user(&as
->usbin
.dma
, ptr
, buffer
, cnt
))) {
2180 if (ptr
>= as
->usbin
.dma
.dmasize
)
2181 ptr
-= as
->usbin
.dma
.dmasize
;
2182 spin_lock_irqsave(&as
->lock
, flags
);
2183 as
->usbin
.dma
.rdptr
= ptr
;
2184 as
->usbin
.dma
.count
-= cnt
;
2185 spin_unlock_irqrestore(&as
->lock
, flags
);
2190 __set_current_state(TASK_RUNNING
);
2191 remove_wait_queue(&as
->usbin
.dma
.wait
, &wait
);
2195 static ssize_t
usb_audio_write(struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
2197 struct usb_audiodev
*as
= (struct usb_audiodev
*)file
->private_data
;
2198 DECLARE_WAITQUEUE(wait
, current
);
2200 unsigned long flags
;
2202 unsigned int start_thr
;
2205 if (as
->usbout
.dma
.mapped
)
2207 if (!as
->usbout
.dma
.ready
&& (ret
= prog_dmabuf_out(as
)))
2209 if (!access_ok(VERIFY_READ
, buffer
, count
))
2211 start_thr
= (as
->usbout
.dma
.srate
<< AFMT_BYTESSHIFT(as
->usbout
.dma
.format
)) / (1000 / (3 * DESCFRAMES
));
2212 add_wait_queue(&as
->usbout
.dma
.wait
, &wait
);
2215 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",
2216 count
, as
->usbout
.dma
.count
, as
->usbout
.dma
.rdptr
, as
->usbout
.dma
.wrptr
, as
->usbout
.dma
.dmasize
, as
->usbout
.dma
.fragsize
,
2217 as
->usbout
.flags
, current
->state
);
2219 spin_lock_irqsave(&as
->lock
, flags
);
2220 if (as
->usbout
.dma
.count
< 0) {
2221 as
->usbout
.dma
.count
= 0;
2222 as
->usbout
.dma
.rdptr
= as
->usbout
.dma
.wrptr
;
2224 ptr
= as
->usbout
.dma
.wrptr
;
2225 cnt
= as
->usbout
.dma
.dmasize
- as
->usbout
.dma
.count
;
2226 /* set task state early to avoid wakeup races */
2228 __set_current_state(TASK_INTERRUPTIBLE
);
2229 spin_unlock_irqrestore(&as
->lock
, flags
);
2233 if (usbout_start(as
)) {
2238 if (file
->f_flags
& O_NONBLOCK
) {
2244 if (signal_pending(current
)) {
2251 if ((err
= dmabuf_copyin_user(&as
->usbout
.dma
, ptr
, buffer
, cnt
))) {
2257 if (ptr
>= as
->usbout
.dma
.dmasize
)
2258 ptr
-= as
->usbout
.dma
.dmasize
;
2259 spin_lock_irqsave(&as
->lock
, flags
);
2260 as
->usbout
.dma
.wrptr
= ptr
;
2261 as
->usbout
.dma
.count
+= cnt
;
2262 spin_unlock_irqrestore(&as
->lock
, flags
);
2266 if (as
->usbout
.dma
.count
>= start_thr
&& usbout_start(as
)) {
2272 __set_current_state(TASK_RUNNING
);
2273 remove_wait_queue(&as
->usbout
.dma
.wait
, &wait
);
2277 /* Called without the kernel lock - fine */
2278 static unsigned int usb_audio_poll(struct file
*file
, struct poll_table_struct
*wait
)
2280 struct usb_audiodev
*as
= (struct usb_audiodev
*)file
->private_data
;
2281 unsigned long flags
;
2282 unsigned int mask
= 0;
2284 if (file
->f_mode
& FMODE_WRITE
) {
2285 if (!as
->usbout
.dma
.ready
)
2286 prog_dmabuf_out(as
);
2287 poll_wait(file
, &as
->usbout
.dma
.wait
, wait
);
2289 if (file
->f_mode
& FMODE_READ
) {
2290 if (!as
->usbin
.dma
.ready
)
2292 poll_wait(file
, &as
->usbin
.dma
.wait
, wait
);
2294 spin_lock_irqsave(&as
->lock
, flags
);
2295 if (file
->f_mode
& FMODE_READ
) {
2296 if (as
->usbin
.dma
.count
>= (signed)as
->usbin
.dma
.fragsize
)
2297 mask
|= POLLIN
| POLLRDNORM
;
2299 if (file
->f_mode
& FMODE_WRITE
) {
2300 if (as
->usbout
.dma
.mapped
) {
2301 if (as
->usbout
.dma
.count
>= (signed)as
->usbout
.dma
.fragsize
)
2302 mask
|= POLLOUT
| POLLWRNORM
;
2304 if ((signed)as
->usbout
.dma
.dmasize
>= as
->usbout
.dma
.count
+ (signed)as
->usbout
.dma
.fragsize
)
2305 mask
|= POLLOUT
| POLLWRNORM
;
2308 spin_unlock_irqrestore(&as
->lock
, flags
);
2312 static int usb_audio_mmap(struct file
*file
, struct vm_area_struct
*vma
)
2314 struct usb_audiodev
*as
= (struct usb_audiodev
*)file
->private_data
;
2319 if (vma
->vm_flags
& VM_WRITE
) {
2320 if ((ret
= prog_dmabuf_out(as
)) != 0)
2322 db
= &as
->usbout
.dma
;
2323 } else if (vma
->vm_flags
& VM_READ
) {
2324 if ((ret
= prog_dmabuf_in(as
)) != 0)
2326 db
= &as
->usbin
.dma
;
2331 if (vma
->vm_pgoff
!= 0)
2334 ret
= dmabuf_mmap(vma
, db
, vma
->vm_start
, vma
->vm_end
- vma
->vm_start
, vma
->vm_page_prot
);
2340 static int usb_audio_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
2342 struct usb_audiodev
*as
= (struct usb_audiodev
*)file
->private_data
;
2343 struct usb_audio_state
*s
= as
->state
;
2344 int __user
*user_arg
= (int __user
*)arg
;
2345 unsigned long flags
;
2346 audio_buf_info abinfo
;
2349 int val2
, mapped
, ret
;
2353 mapped
= ((file
->f_mode
& FMODE_WRITE
) && as
->usbout
.dma
.mapped
) ||
2354 ((file
->f_mode
& FMODE_READ
) && as
->usbin
.dma
.mapped
);
2357 get_user(val
, (int *)arg
);
2358 printk(KERN_DEBUG
"usbaudio: usb_audio_ioctl cmd=%x arg=%lx *arg=%d\n", cmd
, arg
, val
)
2361 case OSS_GETVERSION
:
2362 return put_user(SOUND_VERSION
, user_arg
);
2364 case SNDCTL_DSP_SYNC
:
2365 if (file
->f_mode
& FMODE_WRITE
)
2366 return drain_out(as
, 0/*file->f_flags & O_NONBLOCK*/);
2369 case SNDCTL_DSP_SETDUPLEX
:
2372 case SNDCTL_DSP_GETCAPS
:
2373 return put_user(DSP_CAP_DUPLEX
| DSP_CAP_REALTIME
| DSP_CAP_TRIGGER
|
2374 DSP_CAP_MMAP
| DSP_CAP_BATCH
, user_arg
);
2376 case SNDCTL_DSP_RESET
:
2377 if (file
->f_mode
& FMODE_WRITE
) {
2379 as
->usbout
.dma
.rdptr
= as
->usbout
.dma
.wrptr
= as
->usbout
.dma
.count
= as
->usbout
.dma
.total_bytes
= 0;
2381 if (file
->f_mode
& FMODE_READ
) {
2383 as
->usbin
.dma
.rdptr
= as
->usbin
.dma
.wrptr
= as
->usbin
.dma
.count
= as
->usbin
.dma
.total_bytes
= 0;
2387 case SNDCTL_DSP_SPEED
:
2388 if (get_user(val
, user_arg
))
2395 if (set_format(as
, file
->f_mode
, AFMT_QUERY
, val
))
2398 return put_user((file
->f_mode
& FMODE_READ
) ?
2399 as
->usbin
.dma
.srate
: as
->usbout
.dma
.srate
,
2402 case SNDCTL_DSP_STEREO
:
2403 if (get_user(val
, user_arg
))
2405 val2
= (file
->f_mode
& FMODE_READ
) ? as
->usbin
.dma
.format
: as
->usbout
.dma
.format
;
2407 val2
|= AFMT_STEREO
;
2409 val2
&= ~AFMT_STEREO
;
2410 if (set_format(as
, file
->f_mode
, val2
, 0))
2414 case SNDCTL_DSP_CHANNELS
:
2415 if (get_user(val
, user_arg
))
2418 val2
= (file
->f_mode
& FMODE_READ
) ? as
->usbin
.dma
.format
: as
->usbout
.dma
.format
;
2420 val2
&= ~AFMT_STEREO
;
2422 val2
|= AFMT_STEREO
;
2423 if (set_format(as
, file
->f_mode
, val2
, 0))
2426 val2
= (file
->f_mode
& FMODE_READ
) ? as
->usbin
.dma
.format
: as
->usbout
.dma
.format
;
2427 return put_user(AFMT_ISSTEREO(val2
) ? 2 : 1, user_arg
);
2429 case SNDCTL_DSP_GETFMTS
: /* Returns a mask */
2430 return put_user(AFMT_U8
| AFMT_U16_LE
| AFMT_U16_BE
|
2431 AFMT_S8
| AFMT_S16_LE
| AFMT_S16_BE
, user_arg
);
2433 case SNDCTL_DSP_SETFMT
: /* Selects ONE fmt*/
2434 if (get_user(val
, user_arg
))
2436 if (val
!= AFMT_QUERY
) {
2437 if (hweight32(val
) != 1)
2439 if (!(val
& (AFMT_U8
| AFMT_U16_LE
| AFMT_U16_BE
|
2440 AFMT_S8
| AFMT_S16_LE
| AFMT_S16_BE
)))
2442 val2
= (file
->f_mode
& FMODE_READ
) ? as
->usbin
.dma
.format
: as
->usbout
.dma
.format
;
2443 val
|= val2
& AFMT_STEREO
;
2444 if (set_format(as
, file
->f_mode
, val
, 0))
2447 val2
= (file
->f_mode
& FMODE_READ
) ? as
->usbin
.dma
.format
: as
->usbout
.dma
.format
;
2448 return put_user(val2
& ~AFMT_STEREO
, user_arg
);
2450 case SNDCTL_DSP_POST
:
2453 case SNDCTL_DSP_GETTRIGGER
:
2455 if (file
->f_mode
& FMODE_READ
&& as
->usbin
.flags
& FLG_RUNNING
)
2456 val
|= PCM_ENABLE_INPUT
;
2457 if (file
->f_mode
& FMODE_WRITE
&& as
->usbout
.flags
& FLG_RUNNING
)
2458 val
|= PCM_ENABLE_OUTPUT
;
2459 return put_user(val
, user_arg
);
2461 case SNDCTL_DSP_SETTRIGGER
:
2462 if (get_user(val
, user_arg
))
2464 if (file
->f_mode
& FMODE_READ
) {
2465 if (val
& PCM_ENABLE_INPUT
) {
2466 if (!as
->usbin
.dma
.ready
&& (ret
= prog_dmabuf_in(as
)))
2468 if (usbin_start(as
))
2473 if (file
->f_mode
& FMODE_WRITE
) {
2474 if (val
& PCM_ENABLE_OUTPUT
) {
2475 if (!as
->usbout
.dma
.ready
&& (ret
= prog_dmabuf_out(as
)))
2477 if (usbout_start(as
))
2484 case SNDCTL_DSP_GETOSPACE
:
2485 if (!(file
->f_mode
& FMODE_WRITE
))
2487 if (!(as
->usbout
.flags
& FLG_RUNNING
) && (val
= prog_dmabuf_out(as
)) != 0)
2489 spin_lock_irqsave(&as
->lock
, flags
);
2490 abinfo
.fragsize
= as
->usbout
.dma
.fragsize
;
2491 abinfo
.bytes
= as
->usbout
.dma
.dmasize
- as
->usbout
.dma
.count
;
2492 abinfo
.fragstotal
= as
->usbout
.dma
.numfrag
;
2493 abinfo
.fragments
= abinfo
.bytes
>> as
->usbout
.dma
.fragshift
;
2494 spin_unlock_irqrestore(&as
->lock
, flags
);
2495 return copy_to_user((void __user
*)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
2497 case SNDCTL_DSP_GETISPACE
:
2498 if (!(file
->f_mode
& FMODE_READ
))
2500 if (!(as
->usbin
.flags
& FLG_RUNNING
) && (val
= prog_dmabuf_in(as
)) != 0)
2502 spin_lock_irqsave(&as
->lock
, flags
);
2503 abinfo
.fragsize
= as
->usbin
.dma
.fragsize
;
2504 abinfo
.bytes
= as
->usbin
.dma
.count
;
2505 abinfo
.fragstotal
= as
->usbin
.dma
.numfrag
;
2506 abinfo
.fragments
= abinfo
.bytes
>> as
->usbin
.dma
.fragshift
;
2507 spin_unlock_irqrestore(&as
->lock
, flags
);
2508 return copy_to_user((void __user
*)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
2510 case SNDCTL_DSP_NONBLOCK
:
2511 file
->f_flags
|= O_NONBLOCK
;
2514 case SNDCTL_DSP_GETODELAY
:
2515 if (!(file
->f_mode
& FMODE_WRITE
))
2517 spin_lock_irqsave(&as
->lock
, flags
);
2518 val
= as
->usbout
.dma
.count
;
2519 spin_unlock_irqrestore(&as
->lock
, flags
);
2520 return put_user(val
, user_arg
);
2522 case SNDCTL_DSP_GETIPTR
:
2523 if (!(file
->f_mode
& FMODE_READ
))
2525 spin_lock_irqsave(&as
->lock
, flags
);
2526 cinfo
.bytes
= as
->usbin
.dma
.total_bytes
;
2527 cinfo
.blocks
= as
->usbin
.dma
.count
>> as
->usbin
.dma
.fragshift
;
2528 cinfo
.ptr
= as
->usbin
.dma
.wrptr
;
2529 if (as
->usbin
.dma
.mapped
)
2530 as
->usbin
.dma
.count
&= as
->usbin
.dma
.fragsize
-1;
2531 spin_unlock_irqrestore(&as
->lock
, flags
);
2532 if (copy_to_user((void __user
*)arg
, &cinfo
, sizeof(cinfo
)))
2536 case SNDCTL_DSP_GETOPTR
:
2537 if (!(file
->f_mode
& FMODE_WRITE
))
2539 spin_lock_irqsave(&as
->lock
, flags
);
2540 cinfo
.bytes
= as
->usbout
.dma
.total_bytes
;
2541 cinfo
.blocks
= as
->usbout
.dma
.count
>> as
->usbout
.dma
.fragshift
;
2542 cinfo
.ptr
= as
->usbout
.dma
.rdptr
;
2543 if (as
->usbout
.dma
.mapped
)
2544 as
->usbout
.dma
.count
&= as
->usbout
.dma
.fragsize
-1;
2545 spin_unlock_irqrestore(&as
->lock
, flags
);
2546 if (copy_to_user((void __user
*)arg
, &cinfo
, sizeof(cinfo
)))
2550 case SNDCTL_DSP_GETBLKSIZE
:
2551 if (file
->f_mode
& FMODE_WRITE
) {
2552 if ((val
= prog_dmabuf_out(as
)))
2554 return put_user(as
->usbout
.dma
.fragsize
, user_arg
);
2556 if ((val
= prog_dmabuf_in(as
)))
2558 return put_user(as
->usbin
.dma
.fragsize
, user_arg
);
2560 case SNDCTL_DSP_SETFRAGMENT
:
2561 if (get_user(val
, user_arg
))
2563 if (file
->f_mode
& FMODE_READ
) {
2564 as
->usbin
.dma
.ossfragshift
= val
& 0xffff;
2565 as
->usbin
.dma
.ossmaxfrags
= (val
>> 16) & 0xffff;
2566 if (as
->usbin
.dma
.ossfragshift
< 4)
2567 as
->usbin
.dma
.ossfragshift
= 4;
2568 if (as
->usbin
.dma
.ossfragshift
> 15)
2569 as
->usbin
.dma
.ossfragshift
= 15;
2570 if (as
->usbin
.dma
.ossmaxfrags
< 4)
2571 as
->usbin
.dma
.ossmaxfrags
= 4;
2573 if (file
->f_mode
& FMODE_WRITE
) {
2574 as
->usbout
.dma
.ossfragshift
= val
& 0xffff;
2575 as
->usbout
.dma
.ossmaxfrags
= (val
>> 16) & 0xffff;
2576 if (as
->usbout
.dma
.ossfragshift
< 4)
2577 as
->usbout
.dma
.ossfragshift
= 4;
2578 if (as
->usbout
.dma
.ossfragshift
> 15)
2579 as
->usbout
.dma
.ossfragshift
= 15;
2580 if (as
->usbout
.dma
.ossmaxfrags
< 4)
2581 as
->usbout
.dma
.ossmaxfrags
= 4;
2585 case SNDCTL_DSP_SUBDIVIDE
:
2586 if ((file
->f_mode
& FMODE_READ
&& as
->usbin
.dma
.subdivision
) ||
2587 (file
->f_mode
& FMODE_WRITE
&& as
->usbout
.dma
.subdivision
))
2589 if (get_user(val
, user_arg
))
2591 if (val
!= 1 && val
!= 2 && val
!= 4)
2593 if (file
->f_mode
& FMODE_READ
)
2594 as
->usbin
.dma
.subdivision
= val
;
2595 if (file
->f_mode
& FMODE_WRITE
)
2596 as
->usbout
.dma
.subdivision
= val
;
2599 case SOUND_PCM_READ_RATE
:
2600 return put_user((file
->f_mode
& FMODE_READ
) ?
2601 as
->usbin
.dma
.srate
: as
->usbout
.dma
.srate
,
2604 case SOUND_PCM_READ_CHANNELS
:
2605 val2
= (file
->f_mode
& FMODE_READ
) ? as
->usbin
.dma
.format
: as
->usbout
.dma
.format
;
2606 return put_user(AFMT_ISSTEREO(val2
) ? 2 : 1, user_arg
);
2608 case SOUND_PCM_READ_BITS
:
2609 val2
= (file
->f_mode
& FMODE_READ
) ? as
->usbin
.dma
.format
: as
->usbout
.dma
.format
;
2610 return put_user(AFMT_IS16BIT(val2
) ? 16 : 8, user_arg
);
2612 case SOUND_PCM_WRITE_FILTER
:
2613 case SNDCTL_DSP_SETSYNCRO
:
2614 case SOUND_PCM_READ_FILTER
:
2617 dprintk((KERN_DEBUG
"usbaudio: usb_audio_ioctl - no command found\n"));
2618 return -ENOIOCTLCMD
;
2621 static int usb_audio_open(struct inode
*inode
, struct file
*file
)
2623 unsigned int minor
= iminor(inode
);
2624 DECLARE_WAITQUEUE(wait
, current
);
2625 struct usb_audiodev
*as
;
2626 struct usb_audio_state
*s
;
2630 list_for_each_entry(s
, &audiodevs
, audiodev
) {
2631 list_for_each_entry(as
, &s
->audiolist
, list
) {
2632 if (!((as
->dev_audio
^ minor
) & ~0xf))
2644 /* wait for device to become free */
2645 if (!(as
->open_mode
& file
->f_mode
))
2647 if (file
->f_flags
& O_NONBLOCK
) {
2651 __set_current_state(TASK_INTERRUPTIBLE
);
2652 add_wait_queue(&open_wait
, &wait
);
2655 __set_current_state(TASK_RUNNING
);
2656 remove_wait_queue(&open_wait
, &wait
);
2657 if (signal_pending(current
))
2658 return -ERESTARTSYS
;
2660 if (file
->f_mode
& FMODE_READ
)
2661 as
->usbin
.dma
.ossfragshift
= as
->usbin
.dma
.ossmaxfrags
= as
->usbin
.dma
.subdivision
= 0;
2662 if (file
->f_mode
& FMODE_WRITE
)
2663 as
->usbout
.dma
.ossfragshift
= as
->usbout
.dma
.ossmaxfrags
= as
->usbout
.dma
.subdivision
= 0;
2664 if (set_format(as
, file
->f_mode
, ((minor
& 0xf) == SND_DEV_DSP16
) ? AFMT_S16_LE
: AFMT_U8
/* AFMT_ULAW */, 8000)) {
2668 file
->private_data
= as
;
2669 as
->open_mode
|= file
->f_mode
& (FMODE_READ
| FMODE_WRITE
);
2672 return nonseekable_open(inode
, file
);
2675 static int usb_audio_release(struct inode
*inode
, struct file
*file
)
2677 struct usb_audiodev
*as
= (struct usb_audiodev
*)file
->private_data
;
2678 struct usb_audio_state
*s
;
2679 struct usb_device
*dev
;
2684 if (file
->f_mode
& FMODE_WRITE
)
2685 drain_out(as
, file
->f_flags
& O_NONBLOCK
);
2687 if (file
->f_mode
& FMODE_WRITE
) {
2689 if (dev
&& as
->usbout
.interface
>= 0)
2690 usb_set_interface(dev
, as
->usbout
.interface
, 0);
2691 dmabuf_release(&as
->usbout
.dma
);
2694 if (file
->f_mode
& FMODE_READ
) {
2696 if (dev
&& as
->usbin
.interface
>= 0)
2697 usb_set_interface(dev
, as
->usbin
.interface
, 0);
2698 dmabuf_release(&as
->usbin
.dma
);
2701 as
->open_mode
&= (~file
->f_mode
) & (FMODE_READ
|FMODE_WRITE
);
2703 wake_up(&open_wait
);
2708 static /*const*/ struct file_operations usb_audio_fops
= {
2709 .owner
= THIS_MODULE
,
2710 .llseek
= no_llseek
,
2711 .read
= usb_audio_read
,
2712 .write
= usb_audio_write
,
2713 .poll
= usb_audio_poll
,
2714 .ioctl
= usb_audio_ioctl
,
2715 .mmap
= usb_audio_mmap
,
2716 .open
= usb_audio_open
,
2717 .release
= usb_audio_release
,
2720 /* --------------------------------------------------------------------- */
2722 static int usb_audio_probe(struct usb_interface
*iface
,
2723 const struct usb_device_id
*id
);
2724 static void usb_audio_disconnect(struct usb_interface
*iface
);
2726 static struct usb_device_id usb_audio_ids
[] = {
2727 { .match_flags
= (USB_DEVICE_ID_MATCH_INT_CLASS
| USB_DEVICE_ID_MATCH_INT_SUBCLASS
),
2728 .bInterfaceClass
= USB_CLASS_AUDIO
, .bInterfaceSubClass
= 1},
2729 { } /* Terminating entry */
2732 MODULE_DEVICE_TABLE (usb
, usb_audio_ids
);
2734 static struct usb_driver usb_audio_driver
= {
2736 .probe
= usb_audio_probe
,
2737 .disconnect
= usb_audio_disconnect
,
2738 .id_table
= usb_audio_ids
,
2741 static void *find_descriptor(void *descstart
, unsigned int desclen
, void *after
,
2742 u8 dtype
, int iface
, int altsetting
)
2745 int ifc
= -1, as
= -1;
2755 if (p
[1] == USB_DT_INTERFACE
) {
2756 /* minimum length of interface descriptor */
2762 if (p
[1] == dtype
&& (!after
|| (void *)p
> after
) &&
2763 (iface
== -1 || iface
== ifc
) && (altsetting
== -1 || altsetting
== as
)) {
2771 static void *find_csinterface_descriptor(void *descstart
, unsigned int desclen
, void *after
, u8 dsubtype
, int iface
, int altsetting
)
2775 p
= find_descriptor(descstart
, desclen
, after
, USB_DT_CS_INTERFACE
, iface
, altsetting
);
2777 if (p
[0] >= 3 && p
[2] == dsubtype
)
2779 p
= find_descriptor(descstart
, desclen
, p
, USB_DT_CS_INTERFACE
, iface
, altsetting
);
2784 static void *find_audiocontrol_unit(void *descstart
, unsigned int desclen
, void *after
, u8 unit
, int iface
)
2788 p
= find_descriptor(descstart
, desclen
, after
, USB_DT_CS_INTERFACE
, iface
, -1);
2790 if (p
[0] >= 4 && p
[2] >= INPUT_TERMINAL
&& p
[2] <= EXTENSION_UNIT
&& p
[3] == unit
)
2792 p
= find_descriptor(descstart
, desclen
, p
, USB_DT_CS_INTERFACE
, iface
, -1);
2797 static void usb_audio_parsestreaming(struct usb_audio_state
*s
, unsigned char *buffer
, unsigned int buflen
, int asifin
, int asifout
)
2799 struct usb_device
*dev
= s
->usbdev
;
2800 struct usb_audiodev
*as
;
2801 struct usb_host_interface
*alts
;
2802 struct usb_interface
*iface
;
2803 struct audioformat
*fp
;
2804 unsigned char *fmt
, *csep
;
2805 unsigned int i
, j
, k
, format
, idx
;
2807 if (!(as
= kmalloc(sizeof(struct usb_audiodev
), GFP_KERNEL
)))
2809 memset(as
, 0, sizeof(struct usb_audiodev
));
2810 init_waitqueue_head(&as
->usbin
.dma
.wait
);
2811 init_waitqueue_head(&as
->usbout
.dma
.wait
);
2812 spin_lock_init(&as
->lock
);
2813 as
->usbin
.durb
[0].urb
= usb_alloc_urb (DESCFRAMES
, GFP_KERNEL
);
2814 as
->usbin
.durb
[1].urb
= usb_alloc_urb (DESCFRAMES
, GFP_KERNEL
);
2815 as
->usbin
.surb
[0].urb
= usb_alloc_urb (SYNCFRAMES
, GFP_KERNEL
);
2816 as
->usbin
.surb
[1].urb
= usb_alloc_urb (SYNCFRAMES
, GFP_KERNEL
);
2817 as
->usbout
.durb
[0].urb
= usb_alloc_urb (DESCFRAMES
, GFP_KERNEL
);
2818 as
->usbout
.durb
[1].urb
= usb_alloc_urb (DESCFRAMES
, GFP_KERNEL
);
2819 as
->usbout
.surb
[0].urb
= usb_alloc_urb (SYNCFRAMES
, GFP_KERNEL
);
2820 as
->usbout
.surb
[1].urb
= usb_alloc_urb (SYNCFRAMES
, GFP_KERNEL
);
2821 if ((!as
->usbin
.durb
[0].urb
) ||
2822 (!as
->usbin
.durb
[1].urb
) ||
2823 (!as
->usbin
.surb
[0].urb
) ||
2824 (!as
->usbin
.surb
[1].urb
) ||
2825 (!as
->usbout
.durb
[0].urb
) ||
2826 (!as
->usbout
.durb
[1].urb
) ||
2827 (!as
->usbout
.surb
[0].urb
) ||
2828 (!as
->usbout
.surb
[1].urb
)) {
2829 usb_free_urb(as
->usbin
.durb
[0].urb
);
2830 usb_free_urb(as
->usbin
.durb
[1].urb
);
2831 usb_free_urb(as
->usbin
.surb
[0].urb
);
2832 usb_free_urb(as
->usbin
.surb
[1].urb
);
2833 usb_free_urb(as
->usbout
.durb
[0].urb
);
2834 usb_free_urb(as
->usbout
.durb
[1].urb
);
2835 usb_free_urb(as
->usbout
.surb
[0].urb
);
2836 usb_free_urb(as
->usbout
.surb
[1].urb
);
2841 as
->usbin
.interface
= asifin
;
2842 as
->usbout
.interface
= asifout
;
2843 /* search for input formats */
2845 as
->usbin
.flags
= FLG_CONNECTED
;
2846 iface
= usb_ifnum_to_if(dev
, asifin
);
2847 for (idx
= 0; idx
< iface
->num_altsetting
; idx
++) {
2848 alts
= &iface
->altsetting
[idx
];
2849 i
= alts
->desc
.bAlternateSetting
;
2850 if (alts
->desc
.bInterfaceClass
!= USB_CLASS_AUDIO
|| alts
->desc
.bInterfaceSubClass
!= 2)
2852 if (alts
->desc
.bNumEndpoints
< 1) {
2853 if (i
!= 0) { /* altsetting 0 has no endpoints (Section B.3.4.1) */
2854 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u does not have an endpoint\n",
2855 dev
->devnum
, asifin
, i
);
2859 if ((alts
->endpoint
[0].desc
.bmAttributes
& 0x03) != 0x01 ||
2860 !(alts
->endpoint
[0].desc
.bEndpointAddress
& 0x80)) {
2861 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u first endpoint not isochronous in\n",
2862 dev
->devnum
, asifin
, i
);
2865 fmt
= find_csinterface_descriptor(buffer
, buflen
, NULL
, AS_GENERAL
, asifin
, i
);
2867 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
2868 dev
->devnum
, asifin
, i
);
2871 if (fmt
[0] < 7 || fmt
[6] != 0 || (fmt
[5] != 1 && fmt
[5] != 2)) {
2872 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u format not supported\n",
2873 dev
->devnum
, asifin
, i
);
2876 format
= (fmt
[5] == 2) ? (AFMT_U16_LE
| AFMT_U8
) : (AFMT_S16_LE
| AFMT_S8
);
2877 fmt
= find_csinterface_descriptor(buffer
, buflen
, NULL
, FORMAT_TYPE
, asifin
, i
);
2879 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
2880 dev
->devnum
, asifin
, i
);
2883 if (fmt
[0] < 8+3*(fmt
[7] ? fmt
[7] : 2) || fmt
[3] != 1) {
2884 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not supported\n",
2885 dev
->devnum
, asifin
, i
);
2888 if (fmt
[4] < 1 || fmt
[4] > 2 || fmt
[5] < 1 || fmt
[5] > 2) {
2889 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u unsupported channels %u framesize %u\n",
2890 dev
->devnum
, asifin
, i
, fmt
[4], fmt
[5]);
2893 csep
= find_descriptor(buffer
, buflen
, NULL
, USB_DT_CS_ENDPOINT
, asifin
, i
);
2894 if (!csep
|| csep
[0] < 7 || csep
[2] != EP_GENERAL
) {
2895 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u no or invalid class specific endpoint descriptor\n",
2896 dev
->devnum
, asifin
, i
);
2899 if (as
->numfmtin
>= MAXFORMATS
)
2901 fp
= &as
->fmtin
[as
->numfmtin
++];
2903 format
&= (AFMT_U16_LE
| AFMT_S16_LE
);
2905 format
&= (AFMT_U8
| AFMT_S8
);
2907 format
|= AFMT_STEREO
;
2908 fp
->format
= format
;
2910 fp
->sratelo
= fp
->sratehi
= fmt
[8] | (fmt
[9] << 8) | (fmt
[10] << 16);
2911 printk(KERN_INFO
"usbaudio: valid input sample rate %u\n", fp
->sratelo
);
2912 for (j
= fmt
[7] ? (fmt
[7]-1) : 1; j
> 0; j
--) {
2913 k
= fmt
[8+3*j
] | (fmt
[9+3*j
] << 8) | (fmt
[10+3*j
] << 16);
2914 printk(KERN_INFO
"usbaudio: valid input sample rate %u\n", k
);
2915 if (k
> fp
->sratehi
)
2917 if (k
< fp
->sratelo
)
2920 fp
->attributes
= csep
[3];
2921 printk(KERN_INFO
"usbaudio: device %u interface %u altsetting %u: format 0x%08x sratelo %u sratehi %u attributes 0x%02x\n",
2922 dev
->devnum
, asifin
, i
, fp
->format
, fp
->sratelo
, fp
->sratehi
, fp
->attributes
);
2925 /* search for output formats */
2927 as
->usbout
.flags
= FLG_CONNECTED
;
2928 iface
= usb_ifnum_to_if(dev
, asifout
);
2929 for (idx
= 0; idx
< iface
->num_altsetting
; idx
++) {
2930 alts
= &iface
->altsetting
[idx
];
2931 i
= alts
->desc
.bAlternateSetting
;
2932 if (alts
->desc
.bInterfaceClass
!= USB_CLASS_AUDIO
|| alts
->desc
.bInterfaceSubClass
!= 2)
2934 if (alts
->desc
.bNumEndpoints
< 1) {
2935 /* altsetting 0 should never have iso EPs */
2937 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u does not have an endpoint\n",
2938 dev
->devnum
, asifout
, i
);
2941 if ((alts
->endpoint
[0].desc
.bmAttributes
& 0x03) != 0x01 ||
2942 (alts
->endpoint
[0].desc
.bEndpointAddress
& 0x80)) {
2943 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u first endpoint not isochronous out\n",
2944 dev
->devnum
, asifout
, i
);
2947 /* See USB audio formats manual, section 2 */
2948 fmt
= find_csinterface_descriptor(buffer
, buflen
, NULL
, AS_GENERAL
, asifout
, i
);
2950 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
2951 dev
->devnum
, asifout
, i
);
2954 if (fmt
[0] < 7 || fmt
[6] != 0 || (fmt
[5] != 1 && fmt
[5] != 2)) {
2955 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u format not supported\n",
2956 dev
->devnum
, asifout
, i
);
2959 format
= (fmt
[5] == 2) ? (AFMT_U16_LE
| AFMT_U8
) : (AFMT_S16_LE
| AFMT_S8
);
2960 /* Dallas DS4201 workaround */
2961 if (le16_to_cpu(dev
->descriptor
.idVendor
) == 0x04fa &&
2962 le16_to_cpu(dev
->descriptor
.idProduct
) == 0x4201)
2963 format
= (AFMT_S16_LE
| AFMT_S8
);
2964 fmt
= find_csinterface_descriptor(buffer
, buflen
, NULL
, FORMAT_TYPE
, asifout
, i
);
2966 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
2967 dev
->devnum
, asifout
, i
);
2970 if (fmt
[0] < 8+3*(fmt
[7] ? fmt
[7] : 2) || fmt
[3] != 1) {
2971 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not supported\n",
2972 dev
->devnum
, asifout
, i
);
2975 if (fmt
[4] < 1 || fmt
[4] > 2 || fmt
[5] < 1 || fmt
[5] > 2) {
2976 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u unsupported channels %u framesize %u\n",
2977 dev
->devnum
, asifout
, i
, fmt
[4], fmt
[5]);
2980 csep
= find_descriptor(buffer
, buflen
, NULL
, USB_DT_CS_ENDPOINT
, asifout
, i
);
2981 if (!csep
|| csep
[0] < 7 || csep
[2] != EP_GENERAL
) {
2982 printk(KERN_ERR
"usbaudio: device %u interface %u altsetting %u no or invalid class specific endpoint descriptor\n",
2983 dev
->devnum
, asifout
, i
);
2986 if (as
->numfmtout
>= MAXFORMATS
)
2988 fp
= &as
->fmtout
[as
->numfmtout
++];
2990 format
&= (AFMT_U16_LE
| AFMT_S16_LE
);
2992 format
&= (AFMT_U8
| AFMT_S8
);
2994 format
|= AFMT_STEREO
;
2995 fp
->format
= format
;
2997 fp
->sratelo
= fp
->sratehi
= fmt
[8] | (fmt
[9] << 8) | (fmt
[10] << 16);
2998 printk(KERN_INFO
"usbaudio: valid output sample rate %u\n", fp
->sratelo
);
2999 for (j
= fmt
[7] ? (fmt
[7]-1) : 1; j
> 0; j
--) {
3000 k
= fmt
[8+3*j
] | (fmt
[9+3*j
] << 8) | (fmt
[10+3*j
] << 16);
3001 printk(KERN_INFO
"usbaudio: valid output sample rate %u\n", k
);
3002 if (k
> fp
->sratehi
)
3004 if (k
< fp
->sratelo
)
3007 fp
->attributes
= csep
[3];
3008 printk(KERN_INFO
"usbaudio: device %u interface %u altsetting %u: format 0x%08x sratelo %u sratehi %u attributes 0x%02x\n",
3009 dev
->devnum
, asifout
, i
, fp
->format
, fp
->sratelo
, fp
->sratehi
, fp
->attributes
);
3012 if (as
->numfmtin
== 0 && as
->numfmtout
== 0) {
3013 usb_free_urb(as
->usbin
.durb
[0].urb
);
3014 usb_free_urb(as
->usbin
.durb
[1].urb
);
3015 usb_free_urb(as
->usbin
.surb
[0].urb
);
3016 usb_free_urb(as
->usbin
.surb
[1].urb
);
3017 usb_free_urb(as
->usbout
.durb
[0].urb
);
3018 usb_free_urb(as
->usbout
.durb
[1].urb
);
3019 usb_free_urb(as
->usbout
.surb
[0].urb
);
3020 usb_free_urb(as
->usbout
.surb
[1].urb
);
3024 if ((as
->dev_audio
= register_sound_dsp(&usb_audio_fops
, -1)) < 0) {
3025 printk(KERN_ERR
"usbaudio: cannot register dsp\n");
3026 usb_free_urb(as
->usbin
.durb
[0].urb
);
3027 usb_free_urb(as
->usbin
.durb
[1].urb
);
3028 usb_free_urb(as
->usbin
.surb
[0].urb
);
3029 usb_free_urb(as
->usbin
.surb
[1].urb
);
3030 usb_free_urb(as
->usbout
.durb
[0].urb
);
3031 usb_free_urb(as
->usbout
.durb
[1].urb
);
3032 usb_free_urb(as
->usbout
.surb
[0].urb
);
3033 usb_free_urb(as
->usbout
.surb
[1].urb
);
3037 printk(KERN_INFO
"usbaudio: registered dsp 14,%d\n", as
->dev_audio
);
3038 /* everything successful */
3039 list_add_tail(&as
->list
, &s
->audiolist
);
3042 struct consmixstate
{
3043 struct usb_audio_state
*s
;
3044 unsigned char *buffer
;
3045 unsigned int buflen
;
3046 unsigned int ctrlif
;
3047 struct mixerchannel mixch
[SOUND_MIXER_NRDEVICES
];
3048 unsigned int nrmixch
;
3049 unsigned int mixchmask
;
3050 unsigned long unitbitmap
[32/sizeof(unsigned long)];
3052 unsigned int nrchannels
;
3053 unsigned int termtype
;
3054 unsigned int chconfig
;
3057 static struct mixerchannel
*getmixchannel(struct consmixstate
*state
, unsigned int nr
)
3059 struct mixerchannel
*c
;
3061 if (nr
>= SOUND_MIXER_NRDEVICES
) {
3062 printk(KERN_ERR
"usbaudio: invalid OSS mixer channel %u\n", nr
);
3065 if (!(state
->mixchmask
& (1 << nr
))) {
3066 printk(KERN_WARNING
"usbaudio: OSS mixer channel %u already in use\n", nr
);
3069 c
= &state
->mixch
[state
->nrmixch
++];
3071 state
->mixchmask
&= ~(1 << nr
);
3075 static unsigned int getvolchannel(struct consmixstate
*state
)
3079 if ((state
->termtype
& 0xff00) == 0x0000 && (state
->mixchmask
& SOUND_MASK_VOLUME
))
3080 return SOUND_MIXER_VOLUME
;
3081 if ((state
->termtype
& 0xff00) == 0x0100) {
3082 if (state
->mixchmask
& SOUND_MASK_PCM
)
3083 return SOUND_MIXER_PCM
;
3084 if (state
->mixchmask
& SOUND_MASK_ALTPCM
)
3085 return SOUND_MIXER_ALTPCM
;
3087 if ((state
->termtype
& 0xff00) == 0x0200 && (state
->mixchmask
& SOUND_MASK_MIC
))
3088 return SOUND_MIXER_MIC
;
3089 if ((state
->termtype
& 0xff00) == 0x0300 && (state
->mixchmask
& SOUND_MASK_SPEAKER
))
3090 return SOUND_MIXER_SPEAKER
;
3091 if ((state
->termtype
& 0xff00) == 0x0500) {
3092 if (state
->mixchmask
& SOUND_MASK_PHONEIN
)
3093 return SOUND_MIXER_PHONEIN
;
3094 if (state
->mixchmask
& SOUND_MASK_PHONEOUT
)
3095 return SOUND_MIXER_PHONEOUT
;
3097 if (state
->termtype
>= 0x710 && state
->termtype
<= 0x711 && (state
->mixchmask
& SOUND_MASK_RADIO
))
3098 return SOUND_MIXER_RADIO
;
3099 if (state
->termtype
>= 0x709 && state
->termtype
<= 0x70f && (state
->mixchmask
& SOUND_MASK_VIDEO
))
3100 return SOUND_MIXER_VIDEO
;
3101 u
= ffs(state
->mixchmask
& (SOUND_MASK_LINE
| SOUND_MASK_CD
| SOUND_MASK_LINE1
| SOUND_MASK_LINE2
| SOUND_MASK_LINE3
|
3102 SOUND_MASK_DIGITAL1
| SOUND_MASK_DIGITAL2
| SOUND_MASK_DIGITAL3
));
3106 static void prepmixch(struct consmixstate
*state
)
3108 struct usb_device
*dev
= state
->s
->usbdev
;
3109 struct mixerchannel
*ch
;
3112 unsigned int v2
, v3
;
3114 if (!state
->nrmixch
|| state
->nrmixch
> SOUND_MIXER_NRDEVICES
)
3116 buf
= kmalloc(sizeof(*buf
) * 2, GFP_KERNEL
);
3118 printk(KERN_ERR
"prepmixch: out of memory\n") ;
3122 ch
= &state
->mixch
[state
->nrmixch
-1];
3123 switch (ch
->selector
) {
3124 case 0: /* mixer unit request */
3125 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_MIN
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
3126 (ch
->chnum
<< 8) | 1, state
->ctrlif
| (ch
->unitid
<< 8), buf
, 2, 1000) < 0)
3128 ch
->minval
= buf
[0] | (buf
[1] << 8);
3129 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_MAX
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
3130 (ch
->chnum
<< 8) | 1, state
->ctrlif
| (ch
->unitid
<< 8), buf
, 2, 1000) < 0)
3132 ch
->maxval
= buf
[0] | (buf
[1] << 8);
3133 v2
= ch
->maxval
- ch
->minval
;
3136 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
3137 (ch
->chnum
<< 8) | 1, state
->ctrlif
| (ch
->unitid
<< 8), buf
, 2, 1000) < 0)
3139 v1
= buf
[0] | (buf
[1] << 8);
3140 v3
= v1
- ch
->minval
;
3145 if (ch
->flags
& (MIXFLG_STEREOIN
| MIXFLG_STEREOOUT
)) {
3146 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
3147 ((ch
->chnum
+ !!(ch
->flags
& MIXFLG_STEREOIN
)) << 8) | (1 + !!(ch
->flags
& MIXFLG_STEREOOUT
)),
3148 state
->ctrlif
| (ch
->unitid
<< 8), buf
, 2, 1000) < 0)
3150 v1
= buf
[0] | (buf
[1] << 8);
3151 v3
= v1
- ch
->minval
;
3156 ch
->value
|= v3
<< 8;
3159 /* various feature unit controls */
3160 case VOLUME_CONTROL
:
3161 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_MIN
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
3162 (ch
->selector
<< 8) | ch
->chnum
, state
->ctrlif
| (ch
->unitid
<< 8), buf
, 2, 1000) < 0)
3164 ch
->minval
= buf
[0] | (buf
[1] << 8);
3165 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_MAX
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
3166 (ch
->selector
<< 8) | ch
->chnum
, state
->ctrlif
| (ch
->unitid
<< 8), buf
, 2, 1000) < 0)
3168 ch
->maxval
= buf
[0] | (buf
[1] << 8);
3169 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
3170 (ch
->selector
<< 8) | ch
->chnum
, state
->ctrlif
| (ch
->unitid
<< 8), buf
, 2, 1000) < 0)
3172 v1
= buf
[0] | (buf
[1] << 8);
3173 v2
= ch
->maxval
- ch
->minval
;
3174 v3
= v1
- ch
->minval
;
3181 if (ch
->flags
& (MIXFLG_STEREOIN
| MIXFLG_STEREOOUT
)) {
3182 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
3183 (ch
->selector
<< 8) | (ch
->chnum
+ 1), state
->ctrlif
| (ch
->unitid
<< 8), buf
, 2, 1000) < 0)
3185 v1
= buf
[0] | (buf
[1] << 8);
3186 v3
= v1
- ch
->minval
;
3191 ch
->value
|= v3
<< 8;
3196 case TREBLE_CONTROL
:
3197 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_MIN
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
3198 (ch
->selector
<< 8) | ch
->chnum
, state
->ctrlif
| (ch
->unitid
<< 8), buf
, 1, 1000) < 0)
3200 ch
->minval
= buf
[0] << 8;
3201 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_MAX
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
3202 (ch
->selector
<< 8) | ch
->chnum
, state
->ctrlif
| (ch
->unitid
<< 8), buf
, 1, 1000) < 0)
3204 ch
->maxval
= buf
[0] << 8;
3205 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
3206 (ch
->selector
<< 8) | ch
->chnum
, state
->ctrlif
| (ch
->unitid
<< 8), buf
, 1, 1000) < 0)
3209 v2
= ch
->maxval
- ch
->minval
;
3210 v3
= v1
- ch
->minval
;
3217 if (ch
->flags
& (MIXFLG_STEREOIN
| MIXFLG_STEREOOUT
)) {
3218 if (usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), GET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
3219 (ch
->selector
<< 8) | (ch
->chnum
+ 1), state
->ctrlif
| (ch
->unitid
<< 8), buf
, 1, 1000) < 0)
3222 v3
= v1
- ch
->minval
;
3227 ch
->value
|= v3
<< 8;
3238 printk(KERN_ERR
"usbaudio: mixer request device %u if %u unit %u ch %u selector %u failed\n",
3239 dev
->devnum
, state
->ctrlif
, ch
->unitid
, ch
->chnum
, ch
->selector
);
3246 static void usb_audio_recurseunit(struct consmixstate
*state
, unsigned char unitid
);
3248 static inline int checkmixbmap(unsigned char *bmap
, unsigned char flg
, unsigned int inidx
, unsigned int numoch
)
3253 if (!(bmap
[-(idx
>> 3)] & (0x80 >> (idx
& 7))))
3255 if (!(flg
& (MIXFLG_STEREOIN
| MIXFLG_STEREOOUT
)))
3257 idx
= (inidx
+!!(flg
& MIXFLG_STEREOIN
))*numoch
+!!(flg
& MIXFLG_STEREOOUT
);
3258 if (!(bmap
[-(idx
>> 3)] & (0x80 >> (idx
& 7))))
3263 static void usb_audio_mixerunit(struct consmixstate
*state
, unsigned char *mixer
)
3265 unsigned int nroutch
= mixer
[5+mixer
[4]];
3266 unsigned int chidx
[SOUND_MIXER_NRDEVICES
+1];
3267 unsigned int termt
[SOUND_MIXER_NRDEVICES
];
3268 unsigned char flg
= (nroutch
>= 2) ? MIXFLG_STEREOOUT
: 0;
3269 unsigned char *bmap
= &mixer
[9+mixer
[4]];
3270 unsigned int bmapsize
;
3271 struct mixerchannel
*ch
;
3275 printk(KERN_ERR
"usbaudio: unit %u invalid MIXER_UNIT descriptor\n", mixer
[3]);
3278 if (mixer
[4] > SOUND_MIXER_NRDEVICES
) {
3279 printk(KERN_ERR
"usbaudio: mixer unit %u: too many input pins\n", mixer
[3]);
3283 for (i
= 0; i
< mixer
[4]; i
++) {
3284 usb_audio_recurseunit(state
, mixer
[5+i
]);
3285 chidx
[i
+1] = chidx
[i
] + state
->nrchannels
;
3286 termt
[i
] = state
->termtype
;
3288 state
->termtype
= 0;
3289 state
->chconfig
= mixer
[6+mixer
[4]] | (mixer
[7+mixer
[4]] << 8);
3290 bmapsize
= (nroutch
* chidx
[mixer
[4]] + 7) >> 3;
3291 bmap
+= bmapsize
- 1;
3292 if (mixer
[0] < 10+mixer
[4]+bmapsize
) {
3293 printk(KERN_ERR
"usbaudio: unit %u invalid MIXER_UNIT descriptor (bitmap too small)\n", mixer
[3]);
3296 for (i
= 0; i
< mixer
[4]; i
++) {
3297 state
->termtype
= termt
[i
];
3298 if (chidx
[i
+1]-chidx
[i
] >= 2) {
3299 flg
|= MIXFLG_STEREOIN
;
3300 if (checkmixbmap(bmap
, flg
, chidx
[i
], nroutch
)) {
3301 ch
= getmixchannel(state
, getvolchannel(state
));
3303 ch
->unitid
= mixer
[3];
3305 ch
->chnum
= chidx
[i
]+1;
3312 flg
&= ~MIXFLG_STEREOIN
;
3313 if (checkmixbmap(bmap
, flg
, chidx
[i
], nroutch
)) {
3314 ch
= getmixchannel(state
, getvolchannel(state
));
3316 ch
->unitid
= mixer
[3];
3318 ch
->chnum
= chidx
[i
]+1;
3324 state
->termtype
= 0;
3327 static struct mixerchannel
*slctsrc_findunit(struct consmixstate
*state
, __u8 unitid
)
3331 for (i
= 0; i
< state
->nrmixch
; i
++)
3332 if (state
->mixch
[i
].unitid
== unitid
)
3333 return &state
->mixch
[i
];
3337 static void usb_audio_selectorunit(struct consmixstate
*state
, unsigned char *selector
)
3339 unsigned int chnum
, i
, mixch
;
3340 struct mixerchannel
*mch
;
3343 printk(KERN_ERR
"usbaudio: unit %u invalid SELECTOR_UNIT descriptor\n", selector
[3]);
3346 mixch
= state
->nrmixch
;
3347 usb_audio_recurseunit(state
, selector
[5]);
3348 if (state
->nrmixch
!= mixch
) {
3349 mch
= &state
->mixch
[state
->nrmixch
-1];
3350 mch
->slctunitid
= selector
[3] | (1 << 8);
3351 } else if ((mch
= slctsrc_findunit(state
, selector
[5]))) {
3352 mch
->slctunitid
= selector
[3] | (1 << 8);
3354 printk(KERN_INFO
"usbaudio: selector unit %u: ignoring channel 1\n", selector
[3]);
3356 chnum
= state
->nrchannels
;
3357 for (i
= 1; i
< selector
[4]; i
++) {
3358 mixch
= state
->nrmixch
;
3359 usb_audio_recurseunit(state
, selector
[5+i
]);
3360 if (chnum
!= state
->nrchannels
) {
3361 printk(KERN_ERR
"usbaudio: selector unit %u: input pins with varying channel numbers\n", selector
[3]);
3362 state
->termtype
= 0;
3363 state
->chconfig
= 0;
3364 state
->nrchannels
= 0;
3367 if (state
->nrmixch
!= mixch
) {
3368 mch
= &state
->mixch
[state
->nrmixch
-1];
3369 mch
->slctunitid
= selector
[3] | ((i
+ 1) << 8);
3370 } else if ((mch
= slctsrc_findunit(state
, selector
[5+i
]))) {
3371 mch
->slctunitid
= selector
[3] | ((i
+ 1) << 8);
3373 printk(KERN_INFO
"usbaudio: selector unit %u: ignoring channel %u\n", selector
[3], i
+1);
3376 state
->termtype
= 0;
3377 state
->chconfig
= 0;
3380 /* in the future we might try to handle 3D etc. effect units */
3382 static void usb_audio_processingunit(struct consmixstate
*state
, unsigned char *proc
)
3386 for (i
= 0; i
< proc
[6]; i
++)
3387 usb_audio_recurseunit(state
, proc
[7+i
]);
3388 state
->nrchannels
= proc
[7+proc
[6]];
3389 state
->termtype
= 0;
3390 state
->chconfig
= proc
[8+proc
[6]] | (proc
[9+proc
[6]] << 8);
3394 /* See Audio Class Spec, section 4.3.2.5 */
3395 static void usb_audio_featureunit(struct consmixstate
*state
, unsigned char *ftr
)
3397 struct mixerchannel
*ch
;
3398 unsigned short chftr
, mchftr
;
3400 struct usb_device
*dev
= state
->s
->usbdev
;
3401 unsigned char data
[1];
3403 unsigned char nr_logical_channels
, i
;
3405 usb_audio_recurseunit(state
, ftr
[4]);
3408 printk(KERN_ERR
"usbaudio: wrong controls size in feature unit %u\n",ftr
[3]);
3412 if (state
->nrchannels
== 0) {
3413 printk(KERN_ERR
"usbaudio: feature unit %u source has no channels\n", ftr
[3]);
3416 if (state
->nrchannels
> 2)
3417 printk(KERN_WARNING
"usbaudio: feature unit %u: OSS mixer interface does not support more than 2 channels\n", ftr
[3]);
3419 nr_logical_channels
=(ftr
[0]-7)/ftr
[5]-1;
3421 if (nr_logical_channels
!= state
->nrchannels
) {
3422 printk(KERN_WARNING
"usbaudio: warning: found %d of %d logical channels.\n", state
->nrchannels
,nr_logical_channels
);
3424 if (state
->nrchannels
== 1 && nr_logical_channels
==0) {
3425 printk(KERN_INFO
"usbaudio: assuming the channel found is the master channel (got a Philips camera?). Should be fine.\n");
3426 } else if (state
->nrchannels
== 1 && nr_logical_channels
==2) {
3427 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");
3428 state
->nrchannels
=nr_logical_channels
;
3430 printk(KERN_WARNING
"usbaudio: no idea what's going on..., contact linux-usb-devel@lists.sourceforge.net\n");
3434 /* There is always a master channel */
3436 /* Binary AND over logical channels if they exist */
3437 if (nr_logical_channels
) {
3438 chftr
= ftr
[6+ftr
[5]];
3439 for (i
= 2; i
<= nr_logical_channels
; i
++)
3440 chftr
&= ftr
[6+i
*ftr
[5]];
3445 /* volume control */
3447 ch
= getmixchannel(state
, getvolchannel(state
));
3449 ch
->unitid
= ftr
[3];
3450 ch
->selector
= VOLUME_CONTROL
;
3452 ch
->flags
= (state
->nrchannels
> 1) ? (MIXFLG_STEREOIN
| MIXFLG_STEREOOUT
) : 0;
3455 } else if (mchftr
& 2) {
3456 ch
= getmixchannel(state
, getvolchannel(state
));
3458 ch
->unitid
= ftr
[3];
3459 ch
->selector
= VOLUME_CONTROL
;
3467 ch
= getmixchannel(state
, SOUND_MIXER_BASS
);
3469 ch
->unitid
= ftr
[3];
3470 ch
->selector
= BASS_CONTROL
;
3472 ch
->flags
= (state
->nrchannels
> 1) ? (MIXFLG_STEREOIN
| MIXFLG_STEREOOUT
) : 0;
3475 } else if (mchftr
& 4) {
3476 ch
= getmixchannel(state
, SOUND_MIXER_BASS
);
3478 ch
->unitid
= ftr
[3];
3479 ch
->selector
= BASS_CONTROL
;
3485 /* treble control */
3487 ch
= getmixchannel(state
, SOUND_MIXER_TREBLE
);
3489 ch
->unitid
= ftr
[3];
3490 ch
->selector
= TREBLE_CONTROL
;
3492 ch
->flags
= (state
->nrchannels
> 1) ? (MIXFLG_STEREOIN
| MIXFLG_STEREOOUT
) : 0;
3495 } else if (mchftr
& 16) {
3496 ch
= getmixchannel(state
, SOUND_MIXER_TREBLE
);
3498 ch
->unitid
= ftr
[3];
3499 ch
->selector
= TREBLE_CONTROL
;
3506 /* if there are mute controls, unmute them */
3507 /* does not seem to be necessary, and the Dallas chip does not seem to support the "all" channel (255) */
3508 if ((chftr
& 1) || (mchftr
& 1)) {
3509 printk(KERN_DEBUG
"usbaudio: unmuting feature unit %u interface %u\n", ftr
[3], state
->ctrlif
);
3511 if (usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), SET_CUR
, USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_OUT
,
3512 (MUTE_CONTROL
<< 8) | 0xff, state
->ctrlif
| (ftr
[3] << 8), data
, 1, 1000) < 0)
3513 printk(KERN_WARNING
"usbaudio: failure to unmute feature unit %u interface %u\n", ftr
[3], state
->ctrlif
);
3518 static void usb_audio_recurseunit(struct consmixstate
*state
, unsigned char unitid
)
3523 if (test_and_set_bit(unitid
, state
->unitbitmap
)) {
3524 printk(KERN_INFO
"usbaudio: mixer path revisits unit %d\n", unitid
);
3527 p1
= find_audiocontrol_unit(state
->buffer
, state
->buflen
, NULL
, unitid
, state
->ctrlif
);
3529 printk(KERN_ERR
"usbaudio: unit %d not found!\n", unitid
);
3532 state
->nrchannels
= 0;
3533 state
->termtype
= 0;
3534 state
->chconfig
= 0;
3536 case INPUT_TERMINAL
:
3538 printk(KERN_ERR
"usbaudio: unit %u: invalid INPUT_TERMINAL descriptor\n", unitid
);
3541 state
->nrchannels
= p1
[7];
3542 state
->termtype
= p1
[4] | (p1
[5] << 8);
3543 state
->chconfig
= p1
[8] | (p1
[9] << 8);
3547 if (p1
[0] < 10 || p1
[0] < 10+p1
[4]) {
3548 printk(KERN_ERR
"usbaudio: unit %u: invalid MIXER_UNIT descriptor\n", unitid
);
3551 usb_audio_mixerunit(state
, p1
);
3555 if (p1
[0] < 6 || p1
[0] < 6+p1
[4]) {
3556 printk(KERN_ERR
"usbaudio: unit %u: invalid SELECTOR_UNIT descriptor\n", unitid
);
3559 usb_audio_selectorunit(state
, p1
);
3562 case FEATURE_UNIT
: /* See USB Audio Class Spec 4.3.2.5 */
3563 if (p1
[0] < 7 || p1
[0] < 7+p1
[5]) {
3564 printk(KERN_ERR
"usbaudio: unit %u: invalid FEATURE_UNIT descriptor\n", unitid
);
3567 usb_audio_featureunit(state
, p1
);
3570 case PROCESSING_UNIT
:
3571 if (p1
[0] < 13 || p1
[0] < 13+p1
[6] || p1
[0] < 13+p1
[6]+p1
[11+p1
[6]]) {
3572 printk(KERN_ERR
"usbaudio: unit %u: invalid PROCESSING_UNIT descriptor\n", unitid
);
3575 usb_audio_processingunit(state
, p1
);
3578 case EXTENSION_UNIT
:
3579 if (p1
[0] < 13 || p1
[0] < 13+p1
[6] || p1
[0] < 13+p1
[6]+p1
[11+p1
[6]]) {
3580 printk(KERN_ERR
"usbaudio: unit %u: invalid EXTENSION_UNIT descriptor\n", unitid
);
3583 for (j
= i
= 0; i
< p1
[6]; i
++) {
3584 usb_audio_recurseunit(state
, p1
[7+i
]);
3586 j
= state
->termtype
;
3587 else if (j
!= state
->termtype
)
3590 state
->nrchannels
= p1
[7+p1
[6]];
3591 state
->chconfig
= p1
[8+p1
[6]] | (p1
[9+p1
[6]] << 8);
3592 state
->termtype
= j
;
3596 printk(KERN_ERR
"usbaudio: unit %u: unexpected type 0x%02x\n", unitid
, p1
[2]);
3601 static void usb_audio_constructmixer(struct usb_audio_state
*s
, unsigned char *buffer
, unsigned int buflen
, unsigned int ctrlif
, unsigned char *oterm
)
3603 struct usb_mixerdev
*ms
;
3604 struct consmixstate state
;
3606 memset(&state
, 0, sizeof(state
));
3609 state
.mixchmask
= ~0;
3610 state
.buffer
= buffer
;
3611 state
.buflen
= buflen
;
3612 state
.ctrlif
= ctrlif
;
3613 set_bit(oterm
[3], state
.unitbitmap
); /* mark terminal ID as visited */
3614 printk(KERN_DEBUG
"usbaudio: constructing mixer for Terminal %u type 0x%04x\n",
3615 oterm
[3], oterm
[4] | (oterm
[5] << 8));
3616 usb_audio_recurseunit(&state
, oterm
[7]);
3617 if (!state
.nrmixch
) {
3618 printk(KERN_INFO
"usbaudio: no mixer controls found for Terminal %u\n", oterm
[3]);
3621 if (!(ms
= kmalloc(sizeof(struct usb_mixerdev
)+state
.nrmixch
*sizeof(struct mixerchannel
), GFP_KERNEL
)))
3623 memset(ms
, 0, sizeof(struct usb_mixerdev
));
3624 memcpy(&ms
->ch
, &state
.mixch
, state
.nrmixch
*sizeof(struct mixerchannel
));
3627 ms
->numch
= state
.nrmixch
;
3628 if ((ms
->dev_mixer
= register_sound_mixer(&usb_mixer_fops
, -1)) < 0) {
3629 printk(KERN_ERR
"usbaudio: cannot register mixer\n");
3633 printk(KERN_INFO
"usbaudio: registered mixer 14,%d\n", ms
->dev_mixer
);
3634 list_add_tail(&ms
->list
, &s
->mixerlist
);
3637 /* arbitrary limit, we won't check more interfaces than this */
3638 #define USB_MAXINTERFACES 32
3640 static struct usb_audio_state
*usb_audio_parsecontrol(struct usb_device
*dev
, unsigned char *buffer
, unsigned int buflen
, unsigned int ctrlif
)
3642 struct usb_audio_state
*s
;
3643 struct usb_interface
*iface
;
3644 struct usb_host_interface
*alt
;
3645 unsigned char ifin
[USB_MAXINTERFACES
], ifout
[USB_MAXINTERFACES
];
3647 unsigned int i
, j
, k
, numifin
= 0, numifout
= 0;
3649 if (!(s
= kmalloc(sizeof(struct usb_audio_state
), GFP_KERNEL
)))
3651 memset(s
, 0, sizeof(struct usb_audio_state
));
3652 INIT_LIST_HEAD(&s
->audiolist
);
3653 INIT_LIST_HEAD(&s
->mixerlist
);
3657 /* find audiocontrol interface */
3658 if (!(p1
= find_csinterface_descriptor(buffer
, buflen
, NULL
, HEADER
, ctrlif
, -1))) {
3659 printk(KERN_ERR
"usbaudio: device %d audiocontrol interface %u no HEADER found\n",
3660 dev
->devnum
, ctrlif
);
3663 if (p1
[0] < 8 + p1
[7]) {
3664 printk(KERN_ERR
"usbaudio: device %d audiocontrol interface %u HEADER error\n",
3665 dev
->devnum
, ctrlif
);
3669 printk(KERN_INFO
"usbaudio: device %d audiocontrol interface %u has no AudioStreaming and MidiStreaming interfaces\n",
3670 dev
->devnum
, ctrlif
);
3671 for (i
= 0; i
< p1
[7]; i
++) {
3673 iface
= usb_ifnum_to_if(dev
, j
);
3675 printk(KERN_ERR
"usbaudio: device %d audiocontrol interface %u interface %u does not exist\n",
3676 dev
->devnum
, ctrlif
, j
);
3679 if (iface
->num_altsetting
== 1) {
3680 printk(KERN_ERR
"usbaudio: device %d audiocontrol interface %u has only 1 altsetting.\n", dev
->devnum
, ctrlif
);
3683 alt
= usb_altnum_to_altsetting(iface
, 0);
3685 printk(KERN_ERR
"usbaudio: device %d audiocontrol interface %u interface %u has no altsetting 0\n",
3686 dev
->devnum
, ctrlif
, j
);
3689 if (alt
->desc
.bInterfaceClass
!= USB_CLASS_AUDIO
) {
3690 printk(KERN_ERR
"usbaudio: device %d audiocontrol interface %u interface %u is not an AudioClass interface\n",
3691 dev
->devnum
, ctrlif
, j
);
3694 if (alt
->desc
.bInterfaceSubClass
== 3) {
3695 printk(KERN_INFO
"usbaudio: device %d audiocontrol interface %u interface %u MIDIStreaming not supported\n",
3696 dev
->devnum
, ctrlif
, j
);
3699 if (alt
->desc
.bInterfaceSubClass
!= 2) {
3700 printk(KERN_ERR
"usbaudio: device %d audiocontrol interface %u interface %u invalid AudioClass subtype\n",
3701 dev
->devnum
, ctrlif
, j
);
3704 if (alt
->desc
.bNumEndpoints
> 0) {
3705 /* Check all endpoints; should they all have a bandwidth of 0 ? */
3706 for (k
= 0; k
< alt
->desc
.bNumEndpoints
; k
++) {
3707 if (le16_to_cpu(alt
->endpoint
[k
].desc
.wMaxPacketSize
) > 0) {
3708 printk(KERN_ERR
"usbaudio: device %d audiocontrol interface %u endpoint %d does not have 0 bandwidth at alt[0]\n", dev
->devnum
, ctrlif
, k
);
3712 if (k
< alt
->desc
.bNumEndpoints
)
3716 alt
= usb_altnum_to_altsetting(iface
, 1);
3718 printk(KERN_ERR
"usbaudio: device %d audiocontrol interface %u interface %u has no altsetting 1\n",
3719 dev
->devnum
, ctrlif
, j
);
3722 if (alt
->desc
.bNumEndpoints
< 1) {
3723 printk(KERN_ERR
"usbaudio: device %d audiocontrol interface %u interface %u has no endpoint\n",
3724 dev
->devnum
, ctrlif
, j
);
3727 /* note: this requires the data endpoint to be ep0 and the optional sync
3728 ep to be ep1, which seems to be the case */
3729 if (alt
->endpoint
[0].desc
.bEndpointAddress
& USB_DIR_IN
) {
3730 if (numifin
< USB_MAXINTERFACES
) {
3731 ifin
[numifin
++] = j
;
3732 usb_driver_claim_interface(&usb_audio_driver
, iface
, (void *)-1);
3735 if (numifout
< USB_MAXINTERFACES
) {
3736 ifout
[numifout
++] = j
;
3737 usb_driver_claim_interface(&usb_audio_driver
, iface
, (void *)-1);
3741 printk(KERN_INFO
"usbaudio: device %d audiocontrol interface %u has %u input and %u output AudioStreaming interfaces\n",
3742 dev
->devnum
, ctrlif
, numifin
, numifout
);
3743 for (i
= 0; i
< numifin
&& i
< numifout
; i
++)
3744 usb_audio_parsestreaming(s
, buffer
, buflen
, ifin
[i
], ifout
[i
]);
3745 for (j
= i
; j
< numifin
; j
++)
3746 usb_audio_parsestreaming(s
, buffer
, buflen
, ifin
[i
], -1);
3747 for (j
= i
; j
< numifout
; j
++)
3748 usb_audio_parsestreaming(s
, buffer
, buflen
, -1, ifout
[i
]);
3749 /* now walk through all OUTPUT_TERMINAL descriptors to search for mixers */
3750 p1
= find_csinterface_descriptor(buffer
, buflen
, NULL
, OUTPUT_TERMINAL
, ctrlif
, -1);
3753 usb_audio_constructmixer(s
, buffer
, buflen
, ctrlif
, p1
);
3754 p1
= find_csinterface_descriptor(buffer
, buflen
, p1
, OUTPUT_TERMINAL
, ctrlif
, -1);
3758 if (list_empty(&s
->audiolist
) && list_empty(&s
->mixerlist
)) {
3762 /* everything successful */
3764 list_add_tail(&s
->audiodev
, &audiodevs
);
3766 printk(KERN_DEBUG
"usb_audio_parsecontrol: usb_audio_state at %p\n", s
);
3770 /* we only care for the currently active configuration */
3772 static int usb_audio_probe(struct usb_interface
*intf
,
3773 const struct usb_device_id
*id
)
3775 struct usb_device
*dev
= interface_to_usbdev (intf
);
3776 struct usb_audio_state
*s
;
3777 unsigned char *buffer
;
3778 unsigned int buflen
;
3781 printk(KERN_DEBUG
"usbaudio: Probing if %i: IC %x, ISC %x\n", ifnum
,
3782 config
->interface
[ifnum
].altsetting
[0].desc
.bInterfaceClass
,
3783 config
->interface
[ifnum
].altsetting
[0].desc
.bInterfaceSubClass
);
3787 * audiocontrol interface found
3788 * find which configuration number is active
3790 buffer
= dev
->rawdescriptors
[dev
->actconfig
- dev
->config
];
3791 buflen
= le16_to_cpu(dev
->actconfig
->desc
.wTotalLength
);
3792 s
= usb_audio_parsecontrol(dev
, buffer
, buflen
, intf
->altsetting
->desc
.bInterfaceNumber
);
3794 usb_set_intfdata (intf
, s
);
3801 /* a revoke facility would make things simpler */
3803 static void usb_audio_disconnect(struct usb_interface
*intf
)
3805 struct usb_audio_state
*s
= usb_get_intfdata (intf
);
3806 struct usb_audiodev
*as
;
3807 struct usb_mixerdev
*ms
;
3812 /* we get called with -1 for every audiostreaming interface registered */
3813 if (s
== (struct usb_audio_state
*)-1) {
3814 dprintk((KERN_DEBUG
"usbaudio: note, usb_audio_disconnect called with -1\n"));
3818 dprintk((KERN_DEBUG
"usbaudio: error, usb_audio_disconnect already called for %p!\n", s
));
3822 list_del_init(&s
->audiodev
);
3824 usb_set_intfdata (intf
, NULL
);
3826 /* deregister all audio and mixer devices, so no new processes can open this device */
3827 list_for_each_entry(as
, &s
->audiolist
, list
) {
3830 wake_up(&as
->usbin
.dma
.wait
);
3831 wake_up(&as
->usbout
.dma
.wait
);
3832 if (as
->dev_audio
>= 0) {
3833 unregister_sound_dsp(as
->dev_audio
);
3834 printk(KERN_INFO
"usbaudio: unregister dsp 14,%d\n", as
->dev_audio
);
3838 list_for_each_entry(ms
, &s
->mixerlist
, list
) {
3839 if (ms
->dev_mixer
>= 0) {
3840 unregister_sound_mixer(ms
->dev_mixer
);
3841 printk(KERN_INFO
"usbaudio: unregister mixer 14,%d\n", ms
->dev_mixer
);
3846 wake_up(&open_wait
);
3849 static int __init
usb_audio_init(void)
3851 int result
= usb_register(&usb_audio_driver
);
3853 info(DRIVER_VERSION
":" DRIVER_DESC
);
3858 static void __exit
usb_audio_cleanup(void)
3860 usb_deregister(&usb_audio_driver
);
3863 module_init(usb_audio_init
);
3864 module_exit(usb_audio_cleanup
);
3866 MODULE_AUTHOR( DRIVER_AUTHOR
);
3867 MODULE_DESCRIPTION( DRIVER_DESC
);
3868 MODULE_LICENSE("GPL");