?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux v2.6.13
[linux-2.6/next.git] / drivers / usb / class / audio.c
blobf8f21567cc22489c505d104851c80ab03fe8e47f
1 /*****************************************************************************/
2
3 /*
4 * audio.c -- USB Audio Class driver
5 *
6 * Copyright (C) 1999, 2000, 2001, 2003, 2004
7 * Alan Cox (alan@lxorguk.ukuu.org.uk)
8 * Thomas Sailer (sailer@ife.ee.ethz.ch)
9 *
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.
14 *
15 * Debugging:
16 * Use the 'lsusb' utility to dump the descriptors.
17 *
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
45 * from the USB port)
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
54 * decent headphones!
55 * "Let's make things better" -> but please Philips start with your
56 * own stuff!!!!
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
82 * audio descriptors.
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.
108 *
109 */
110
111 /*
112 * Strategy:
113 *
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.
118 *
119 * Data IO implementation issues
120 *
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.
126 *
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.
133 *
134 * Current status: no known HCD-specific issues.
135 *
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
139 * used.
140 *
141 * Parsing implementation issues
142 *
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.
146 *
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.
158 *
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.
166 *
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.
178 */
179
180 /*****************************************************************************/
181
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>
197 #include <asm/io.h>
198 #include <linux/usb.h>
199
200 #include "audio.h"
201
202 /*
203 * Version Information
204 */
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"
208
209 #define AUDIO_DEBUG 1
210
211 #define SND_DEV_DSP16 5
212
213 #define dprintk(x)
214
215 /* --------------------------------------------------------------------- */
216
217 /*
218 * Linked list of all audio devices...
219 */
220 static struct list_head audiodevs = LIST_HEAD_INIT(audiodevs);
221 static DECLARE_MUTEX(open_sem);
222
223 /*
224 * wait queue for processes wanting to open an USB audio device
225 */
226 static DECLARE_WAIT_QUEUE_HEAD(open_wait);
227
228
229 #define MAXFORMATS MAX_ALT
230 #define DMABUFSHIFT 17 /* 128k worth of DMA buffer */
231 #define NRSGBUF (1U<<(DMABUFSHIFT-PAGE_SHIFT))
232
233 /*
234 * This influences:
235 * - Latency
236 * - Interrupt rate
237 * - Synchronisation behaviour
238 * Don't touch this if you don't understand all of the above.
239 */
240 #define DESCFRAMES 5
241 #define SYNCFRAMES DESCFRAMES
242
243 #define MIXFLG_STEREOIN 1
244 #define MIXFLG_STEREOOUT 2
245
246 struct mixerchannel {
247 __u16 value;
248 __u16 osschannel; /* number of the OSS channel */
249 __s16 minval, maxval;
250 __u16 slctunitid;
251 __u8 unitid;
252 __u8 selector;
253 __u8 chnum;
254 __u8 flags;
255 };
256
257 struct audioformat {
258 unsigned int format;
259 unsigned int sratelo;
260 unsigned int sratehi;
261 unsigned char altsetting;
262 unsigned char attributes;
263 };
264
265 struct dmabuf {
266 /* buffer data format */
267 unsigned int format;
268 unsigned int srate;
269 /* physical buffer */
270 unsigned char *sgbuf[NRSGBUF];
271 unsigned bufsize;
272 unsigned numfrag;
273 unsigned fragshift;
274 unsigned wrptr, rdptr;
275 unsigned total_bytes;
276 int count;
277 unsigned error; /* over/underrun */
278 wait_queue_head_t wait;
279 /* redundant, but makes calculations easier */
280 unsigned fragsize;
281 unsigned dmasize;
282 /* OSS stuff */
283 unsigned mapped:1;
284 unsigned ready:1;
285 unsigned ossfragshift;
286 int ossmaxfrags;
287 unsigned subdivision;
288 };
289
290 struct usb_audio_state;
291
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
298
299 struct my_data_urb {
300 struct urb *urb;
301 };
302
303 struct my_sync_urb {
304 struct urb *urb;
305 };
306
307
308 struct usb_audiodev {
309 struct list_head list;
310 struct usb_audio_state *state;
311
312 /* soundcore stuff */
313 int dev_audio;
314
315 /* wave stuff */
316 mode_t open_mode;
317 spinlock_t lock; /* DMA buffer access spinlock */
318
319 struct usbin {
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 */
329
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 */
332
333 struct dmabuf dma;
334 } usbin;
335
336 struct usbout {
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 */
347
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 */
350
351 struct dmabuf dma;
352 } usbout;
353
354
355 unsigned int numfmtin, numfmtout;
356 struct audioformat fmtin[MAXFORMATS];
357 struct audioformat fmtout[MAXFORMATS];
358 };
359
360 struct usb_mixerdev {
361 struct list_head list;
362 struct usb_audio_state *state;
363
364 /* soundcore stuff */
365 int dev_mixer;
366
367 unsigned char iface; /* interface number of the AudioControl interface */
368
369 /* USB format descriptions */
370 unsigned int numch, modcnt;
371
372 /* mixch is last and gets allocated dynamically */
373 struct mixerchannel ch[0];
374 };
375
376 struct usb_audio_state {
377 struct list_head audiodev;
378
379 /* USB device */
380 struct usb_device *usbdev;
381
382 struct list_head audiolist;
383 struct list_head mixerlist;
384
385 unsigned count; /* usage counter; NOTE: the usb stack is also considered a user */
386 };
387
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))
395
396 /* --------------------------------------------------------------------- */
397
398 static inline unsigned ld2(unsigned int x)
399 {
400 unsigned r = 0;
401
402 if (x >= 0x10000) {
403 x >>= 16;
404 r += 16;
405 }
406 if (x >= 0x100) {
407 x >>= 8;
408 r += 8;
409 }
410 if (x >= 0x10) {
411 x >>= 4;
412 r += 4;
413 }
414 if (x >= 4) {
415 x >>= 2;
416 r += 2;
417 }
418 if (x >= 2)
419 r++;
420 return r;
421 }
422
423 /* --------------------------------------------------------------------- */
424
425 /*
426 * OSS compatible ring buffer management. The ring buffer may be mmap'ed into
427 * an application address space.
428 *
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.
433 */
434
435 static void dmabuf_release(struct dmabuf *db)
436 {
437 unsigned int nr;
438 void *p;
439
440 for(nr = 0; nr < NRSGBUF; nr++) {
441 if (!(p = db->sgbuf[nr]))
442 continue;
443 ClearPageReserved(virt_to_page(p));
444 free_page((unsigned long)p);
445 db->sgbuf[nr] = NULL;
446 }
447 db->mapped = db->ready = 0;
448 }
449
450 static int dmabuf_init(struct dmabuf *db)
451 {
452 unsigned int nr, bytepersec, bufs;
453 void *p;
454
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);
463 else
464 db->fragshift = db->ossfragshift;
465 } else {
466 db->fragshift = ld2(bytepersec/100/(db->subdivision ? db->subdivision : 1));
467 if (db->fragshift < 3)
468 db->fragshift = 3;
469 }
470 db->numfrag = bufs >> db->fragshift;
471 while (db->numfrag < 4 && db->fragshift > 3) {
472 db->fragshift--;
473 db->numfrag = bufs >> db->fragshift;
474 }
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);
482 if (!p)
483 return -ENOMEM;
484 db->sgbuf[nr] = p;
485 SetPageReserved(virt_to_page(p));
486 }
487 memset(db->sgbuf[nr], AFMT_ISUNSIGNED(db->format) ? 0x80 : 0, PAGE_SIZE);
488 if ((nr << PAGE_SHIFT) >= db->dmasize)
489 break;
490 }
491 db->bufsize = nr << PAGE_SHIFT;
492 db->ready = 1;
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));
497 return 0;
498 }
499
500 static int dmabuf_mmap(struct vm_area_struct *vma, struct dmabuf *db, unsigned long start, unsigned long size, pgprot_t prot)
501 {
502 unsigned int nr;
503
504 if (!db->ready || db->mapped || (start | size) & (PAGE_SIZE-1) || size > db->bufsize)
505 return -EINVAL;
506 size >>= PAGE_SHIFT;
507 for(nr = 0; nr < size; nr++)
508 if (!db->sgbuf[nr])
509 return -EINVAL;
510 db->mapped = 1;
511 for(nr = 0; nr < size; nr++) {
512 unsigned long pfn;
513
514 pfn = virt_to_phys(db->sgbuf[nr]) >> PAGE_SHIFT;
515 if (remap_pfn_range(vma, start, pfn, PAGE_SIZE, prot))
516 return -EAGAIN;
517 start += PAGE_SIZE;
518 }
519 return 0;
520 }
521
522 static void dmabuf_copyin(struct dmabuf *db, const void *buffer, unsigned int size)
523 {
524 unsigned int pgrem, rem;
525
526 db->total_bytes += size;
527 for (;;) {
528 if (size <= 0)
529 return;
530 pgrem = ((~db->wrptr) & (PAGE_SIZE-1)) + 1;
531 if (pgrem > size)
532 pgrem = size;
533 rem = db->dmasize - db->wrptr;
534 if (pgrem > rem)
535 pgrem = rem;
536 memcpy((db->sgbuf[db->wrptr >> PAGE_SHIFT]) + (db->wrptr & (PAGE_SIZE-1)), buffer, pgrem);
537 size -= pgrem;
538 buffer += pgrem;
539 db->wrptr += pgrem;
540 if (db->wrptr >= db->dmasize)
541 db->wrptr = 0;
542 }
543 }
544
545 static void dmabuf_copyout(struct dmabuf *db, void *buffer, unsigned int size)
546 {
547 unsigned int pgrem, rem;
548
549 db->total_bytes += size;
550 for (;;) {
551 if (size <= 0)
552 return;
553 pgrem = ((~db->rdptr) & (PAGE_SIZE-1)) + 1;
554 if (pgrem > size)
555 pgrem = size;
556 rem = db->dmasize - db->rdptr;
557 if (pgrem > rem)
558 pgrem = rem;
559 memcpy(buffer, (db->sgbuf[db->rdptr >> PAGE_SHIFT]) + (db->rdptr & (PAGE_SIZE-1)), pgrem);
560 size -= pgrem;
561 buffer += pgrem;
562 db->rdptr += pgrem;
563 if (db->rdptr >= db->dmasize)
564 db->rdptr = 0;
565 }
566 }
567
568 static int dmabuf_copyin_user(struct dmabuf *db, unsigned int ptr, const void __user *buffer, unsigned int size)
569 {
570 unsigned int pgrem, rem;
571
572 if (!db->ready || db->mapped)
573 return -EINVAL;
574 for (;;) {
575 if (size <= 0)
576 return 0;
577 pgrem = ((~ptr) & (PAGE_SIZE-1)) + 1;
578 if (pgrem > size)
579 pgrem = size;
580 rem = db->dmasize - ptr;
581 if (pgrem > rem)
582 pgrem = rem;
583 if (copy_from_user((db->sgbuf[ptr >> PAGE_SHIFT]) + (ptr & (PAGE_SIZE-1)), buffer, pgrem))
584 return -EFAULT;
585 size -= pgrem;
586 buffer += pgrem;
587 ptr += pgrem;
588 if (ptr >= db->dmasize)
589 ptr = 0;
590 }
591 }
592
593 static int dmabuf_copyout_user(struct dmabuf *db, unsigned int ptr, void __user *buffer, unsigned int size)
594 {
595 unsigned int pgrem, rem;
596
597 if (!db->ready || db->mapped)
598 return -EINVAL;
599 for (;;) {
600 if (size <= 0)
601 return 0;
602 pgrem = ((~ptr) & (PAGE_SIZE-1)) + 1;
603 if (pgrem > size)
604 pgrem = size;
605 rem = db->dmasize - ptr;
606 if (pgrem > rem)
607 pgrem = rem;
608 if (copy_to_user(buffer, (db->sgbuf[ptr >> PAGE_SHIFT]) + (ptr & (PAGE_SIZE-1)), pgrem))
609 return -EFAULT;
610 size -= pgrem;
611 buffer += pgrem;
612 ptr += pgrem;
613 if (ptr >= db->dmasize)
614 ptr = 0;
615 }
616 }
617
618 /* --------------------------------------------------------------------- */
619 /*
620 * USB I/O code. We do sample format conversion if necessary
621 */
622
623 static void usbin_stop(struct usb_audiodev *as)
624 {
625 struct usbin *u = &as->usbin;
626 unsigned long flags;
627 unsigned int i, notkilled = 1;
628
629 spin_lock_irqsave(&as->lock, flags);
630 u->flags &= ~FLG_RUNNING;
631 i = u->flags;
632 spin_unlock_irqrestore(&as->lock, flags);
633 while (i & (FLG_URB0RUNNING|FLG_URB1RUNNING|FLG_SYNC0RUNNING|FLG_SYNC1RUNNING)) {
634 set_current_state(notkilled ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
635 schedule_timeout(1);
636 spin_lock_irqsave(&as->lock, flags);
637 i = u->flags;
638 spin_unlock_irqrestore(&as->lock, flags);
639 if (notkilled && signal_pending(current)) {
640 if (i & FLG_URB0RUNNING)
641 usb_kill_urb(u->durb[0].urb);
642 if (i & FLG_URB1RUNNING)
643 usb_kill_urb(u->durb[1].urb);
644 if (i & FLG_SYNC0RUNNING)
645 usb_kill_urb(u->surb[0].urb);
646 if (i & FLG_SYNC1RUNNING)
647 usb_kill_urb(u->surb[1].urb);
648 notkilled = 0;
649 }
650 }
651 set_current_state(TASK_RUNNING);
652 kfree(u->durb[0].urb->transfer_buffer);
653 kfree(u->durb[1].urb->transfer_buffer);
654 kfree(u->surb[0].urb->transfer_buffer);
655 kfree(u->surb[1].urb->transfer_buffer);
656 u->durb[0].urb->transfer_buffer = u->durb[1].urb->transfer_buffer =
657 u->surb[0].urb->transfer_buffer = u->surb[1].urb->transfer_buffer = NULL;
658 }
659
660 static inline void usbin_release(struct usb_audiodev *as)
661 {
662 usbin_stop(as);
663 }
664
665 static void usbin_disc(struct usb_audiodev *as)
666 {
667 struct usbin *u = &as->usbin;
668
669 unsigned long flags;
670
671 spin_lock_irqsave(&as->lock, flags);
672 u->flags &= ~(FLG_RUNNING | FLG_CONNECTED);
673 spin_unlock_irqrestore(&as->lock, flags);
674 usbin_stop(as);
675 }
676
677 static void conversion(const void *ibuf, unsigned int ifmt, void *obuf, unsigned int ofmt, void *tmp, unsigned int scnt)
678 {
679 unsigned int cnt, i;
680 __s16 *sp, *sp2, s;
681 unsigned char *bp;
682
683 cnt = scnt;
684 if (AFMT_ISSTEREO(ifmt))
685 cnt <<= 1;
686 sp = ((__s16 *)tmp) + cnt;
687 switch (ifmt & ~AFMT_STEREO) {
688 case AFMT_U8:
689 for (bp = ((unsigned char *)ibuf)+cnt, i = 0; i < cnt; i++) {
690 bp--;
691 sp--;
692 *sp = (*bp ^ 0x80) << 8;
693 }
694 break;
695
696 case AFMT_S8:
697 for (bp = ((unsigned char *)ibuf)+cnt, i = 0; i < cnt; i++) {
698 bp--;
699 sp--;
700 *sp = *bp << 8;
701 }
702 break;
703
704 case AFMT_U16_LE:
705 for (bp = ((unsigned char *)ibuf)+2*cnt, i = 0; i < cnt; i++) {
706 bp -= 2;
707 sp--;
708 *sp = (bp[0] | (bp[1] << 8)) ^ 0x8000;
709 }
710 break;
711
712 case AFMT_U16_BE:
713 for (bp = ((unsigned char *)ibuf)+2*cnt, i = 0; i < cnt; i++) {
714 bp -= 2;
715 sp--;
716 *sp = (bp[1] | (bp[0] << 8)) ^ 0x8000;
717 }
718 break;
719
720 case AFMT_S16_LE:
721 for (bp = ((unsigned char *)ibuf)+2*cnt, i = 0; i < cnt; i++) {
722 bp -= 2;
723 sp--;
724 *sp = bp[0] | (bp[1] << 8);
725 }
726 break;
727
728 case AFMT_S16_BE:
729 for (bp = ((unsigned char *)ibuf)+2*cnt, i = 0; i < cnt; i++) {
730 bp -= 2;
731 sp--;
732 *sp = bp[1] | (bp[0] << 8);
733 }
734 break;
735 }
736 if (!AFMT_ISSTEREO(ifmt) && AFMT_ISSTEREO(ofmt)) {
737 /* expand from mono to stereo */
738 for (sp = ((__s16 *)tmp)+scnt, sp2 = ((__s16 *)tmp)+2*scnt, i = 0; i < scnt; i++) {
739 sp--;
740 sp2 -= 2;
741 sp2[0] = sp2[1] = sp[0];
742 }
743 }
744 if (AFMT_ISSTEREO(ifmt) && !AFMT_ISSTEREO(ofmt)) {
745 /* contract from stereo to mono */
746 for (sp = sp2 = ((__s16 *)tmp), i = 0; i < scnt; i++, sp++, sp2 += 2)
747 sp[0] = (sp2[0] + sp2[1]) >> 1;
748 }
749 cnt = scnt;
750 if (AFMT_ISSTEREO(ofmt))
751 cnt <<= 1;
752 sp = ((__s16 *)tmp);
753 bp = ((unsigned char *)obuf);
754 switch (ofmt & ~AFMT_STEREO) {
755 case AFMT_U8:
756 for (i = 0; i < cnt; i++, sp++, bp++)
757 *bp = (*sp >> 8) ^ 0x80;
758 break;
759
760 case AFMT_S8:
761 for (i = 0; i < cnt; i++, sp++, bp++)
762 *bp = *sp >> 8;
763 break;
764
765 case AFMT_U16_LE:
766 for (i = 0; i < cnt; i++, sp++, bp += 2) {
767 s = *sp;
768 bp[0] = s;
769 bp[1] = (s >> 8) ^ 0x80;
770 }
771 break;
772
773 case AFMT_U16_BE:
774 for (i = 0; i < cnt; i++, sp++, bp += 2) {
775 s = *sp;
776 bp[1] = s;
777 bp[0] = (s >> 8) ^ 0x80;
778 }
779 break;
780
781 case AFMT_S16_LE:
782 for (i = 0; i < cnt; i++, sp++, bp += 2) {
783 s = *sp;
784 bp[0] = s;
785 bp[1] = s >> 8;
786 }
787 break;
788
789 case AFMT_S16_BE:
790 for (i = 0; i < cnt; i++, sp++, bp += 2) {
791 s = *sp;
792 bp[1] = s;
793 bp[0] = s >> 8;
794 }
795 break;
796 }
797
798 }
799
800 static void usbin_convert(struct usbin *u, unsigned char *buffer, unsigned int samples)
801 {
802 union {
803 __s16 s[64];
804 unsigned char b[0];
805 } tmp;
806 unsigned int scnt, maxs, ufmtsh, dfmtsh;
807
808 ufmtsh = AFMT_BYTESSHIFT(u->format);
809 dfmtsh = AFMT_BYTESSHIFT(u->dma.format);
810 maxs = (AFMT_ISSTEREO(u->dma.format | u->format)) ? 32 : 64;
811 while (samples > 0) {
812 scnt = samples;
813 if (scnt > maxs)
814 scnt = maxs;
815 conversion(buffer, u->format, tmp.b, u->dma.format, tmp.b, scnt);
816 dmabuf_copyin(&u->dma, tmp.b, scnt << dfmtsh);
817 buffer += scnt << ufmtsh;
818 samples -= scnt;
819 }
820 }
821
822 static int usbin_prepare_desc(struct usbin *u, struct urb *urb)
823 {
824 unsigned int i, maxsize, offs;
825
826 maxsize = (u->freqmax + 0x3fff) >> (14 - AFMT_BYTESSHIFT(u->format));
827 //printk(KERN_DEBUG "usbin_prepare_desc: maxsize %d freq 0x%x format 0x%x\n", maxsize, u->freqn, u->format);
828 for (i = offs = 0; i < DESCFRAMES; i++, offs += maxsize) {
829 urb->iso_frame_desc[i].length = maxsize;
830 urb->iso_frame_desc[i].offset = offs;
831 }
832 urb->interval = 1;
833 return 0;
834 }
835
836 /*
837 * return value: 0 if descriptor should be restarted, -1 otherwise
838 * convert sample format on the fly if necessary
839 */
840 static int usbin_retire_desc(struct usbin *u, struct urb *urb)
841 {
842 unsigned int i, ufmtsh, dfmtsh, err = 0, cnt, scnt, dmafree;
843 unsigned char *cp;
844
845 ufmtsh = AFMT_BYTESSHIFT(u->format);
846 dfmtsh = AFMT_BYTESSHIFT(u->dma.format);
847 for (i = 0; i < DESCFRAMES; i++) {
848 cp = ((unsigned char *)urb->transfer_buffer) + urb->iso_frame_desc[i].offset;
849 if (urb->iso_frame_desc[i].status) {
850 dprintk((KERN_DEBUG "usbin_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
851 continue;
852 }
853 scnt = urb->iso_frame_desc[i].actual_length >> ufmtsh;
854 if (!scnt)
855 continue;
856 cnt = scnt << dfmtsh;
857 if (!u->dma.mapped) {
858 dmafree = u->dma.dmasize - u->dma.count;
859 if (cnt > dmafree) {
860 scnt = dmafree >> dfmtsh;
861 cnt = scnt << dfmtsh;
862 err++;
863 }
864 }
865 u->dma.count += cnt;
866 if (u->format == u->dma.format) {
867 /* we do not need format conversion */
868 dprintk((KERN_DEBUG "usbaudio: no sample format conversion\n"));
869 dmabuf_copyin(&u->dma, cp, cnt);
870 } else {
871 /* we need sampling format conversion */
872 dprintk((KERN_DEBUG "usbaudio: sample format conversion %x != %x\n", u->format, u->dma.format));
873 usbin_convert(u, cp, scnt);
874 }
875 }
876 if (err)
877 u->dma.error++;
878 if (u->dma.count >= (signed)u->dma.fragsize)
879 wake_up(&u->dma.wait);
880 return err ? -1 : 0;
881 }
882
883 static void usbin_completed(struct urb *urb, struct pt_regs *regs)
884 {
885 struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
886 struct usbin *u = &as->usbin;
887 unsigned long flags;
888 unsigned int mask;
889 int suret = 0;
890
891 #if 0
892 printk(KERN_DEBUG "usbin_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
893 #endif
894 if (urb == u->durb[0].urb)
895 mask = FLG_URB0RUNNING;
896 else if (urb == u->durb[1].urb)
897 mask = FLG_URB1RUNNING;
898 else {
899 mask = 0;
900 printk(KERN_ERR "usbin_completed: panic: unknown URB\n");
901 }
902 urb->dev = as->state->usbdev;
903 spin_lock_irqsave(&as->lock, flags);
904 if (!usbin_retire_desc(u, urb) &&
905 u->flags & FLG_RUNNING &&
906 !usbin_prepare_desc(u, urb) &&
907 (suret = usb_submit_urb(urb, GFP_ATOMIC)) == 0) {
908 u->flags |= mask;
909 } else {
910 u->flags &= ~(mask | FLG_RUNNING);
911 wake_up(&u->dma.wait);
912 printk(KERN_DEBUG "usbin_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret);
913 }
914 spin_unlock_irqrestore(&as->lock, flags);
915 }
916
917 /*
918 * we output sync data
919 */
920 static int usbin_sync_prepare_desc(struct usbin *u, struct urb *urb)
921 {
922 unsigned char *cp = urb->transfer_buffer;
923 unsigned int i, offs;
924
925 for (i = offs = 0; i < SYNCFRAMES; i++, offs += 3, cp += 3) {
926 urb->iso_frame_desc[i].length = 3;
927 urb->iso_frame_desc[i].offset = offs;
928 cp[0] = u->freqn;
929 cp[1] = u->freqn >> 8;
930 cp[2] = u->freqn >> 16;
931 }
932 urb->interval = 1;
933 return 0;
934 }
935
936 /*
937 * return value: 0 if descriptor should be restarted, -1 otherwise
938 */
939 static int usbin_sync_retire_desc(struct usbin *u, struct urb *urb)
940 {
941 unsigned int i;
942
943 for (i = 0; i < SYNCFRAMES; i++)
944 if (urb->iso_frame_desc[0].status)
945 dprintk((KERN_DEBUG "usbin_sync_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
946 return 0;
947 }
948
949 static void usbin_sync_completed(struct urb *urb, struct pt_regs *regs)
950 {
951 struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
952 struct usbin *u = &as->usbin;
953 unsigned long flags;
954 unsigned int mask;
955 int suret = 0;
956
957 #if 0
958 printk(KERN_DEBUG "usbin_sync_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
959 #endif
960 if (urb == u->surb[0].urb)
961 mask = FLG_SYNC0RUNNING;
962 else if (urb == u->surb[1].urb)
963 mask = FLG_SYNC1RUNNING;
964 else {
965 mask = 0;
966 printk(KERN_ERR "usbin_sync_completed: panic: unknown URB\n");
967 }
968 urb->dev = as->state->usbdev;
969 spin_lock_irqsave(&as->lock, flags);
970 if (!usbin_sync_retire_desc(u, urb) &&
971 u->flags & FLG_RUNNING &&
972 !usbin_sync_prepare_desc(u, urb) &&
973 (suret = usb_submit_urb(urb, GFP_ATOMIC)) == 0) {
974 u->flags |= mask;
975 } else {
976 u->flags &= ~(mask | FLG_RUNNING);
977 wake_up(&u->dma.wait);
978 dprintk((KERN_DEBUG "usbin_sync_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret));
979 }
980 spin_unlock_irqrestore(&as->lock, flags);
981 }
982
983 static int usbin_start(struct usb_audiodev *as)
984 {
985 struct usb_device *dev = as->state->usbdev;
986 struct usbin *u = &as->usbin;
987 struct urb *urb;
988 unsigned long flags;
989 unsigned int maxsze, bufsz;
990
991 #if 0
992 printk(KERN_DEBUG "usbin_start: device %d ufmt 0x%08x dfmt 0x%08x srate %d\n",
993 dev->devnum, u->format, u->dma.format, u->dma.srate);
994 #endif
995 /* allocate USB storage if not already done */
996 spin_lock_irqsave(&as->lock, flags);
997 if (!(u->flags & FLG_CONNECTED)) {
998 spin_unlock_irqrestore(&as->lock, flags);
999 return -EIO;
1000 }
1001 if (!(u->flags & FLG_RUNNING)) {
1002 spin_unlock_irqrestore(&as->lock, flags);
1003 u->freqn = ((u->dma.srate << 11) + 62) / 125; /* this will overflow at approx 2MSPS */
1004 u->freqmax = u->freqn + (u->freqn >> 2);
1005 u->phase = 0;
1006 maxsze = (u->freqmax + 0x3fff) >> (14 - AFMT_BYTESSHIFT(u->format));
1007 bufsz = DESCFRAMES * maxsze;
1008 kfree(u->durb[0].urb->transfer_buffer);
1009 u->durb[0].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1010 u->durb[0].urb->transfer_buffer_length = bufsz;
1011 kfree(u->durb[1].urb->transfer_buffer);
1012 u->durb[1].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1013 u->durb[1].urb->transfer_buffer_length = bufsz;
1014 if (u->syncpipe) {
1015 kfree(u->surb[0].urb->transfer_buffer);
1016 u->surb[0].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1017 u->surb[0].urb->transfer_buffer_length = 3*SYNCFRAMES;
1018 kfree(u->surb[1].urb->transfer_buffer);
1019 u->surb[1].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1020 u->surb[1].urb->transfer_buffer_length = 3*SYNCFRAMES;
1021 }
1022 if (!u->durb[0].urb->transfer_buffer || !u->durb[1].urb->transfer_buffer ||
1023 (u->syncpipe && (!u->surb[0].urb->transfer_buffer || !u->surb[1].urb->transfer_buffer))) {
1024 printk(KERN_ERR "usbaudio: cannot start playback device %d\n", dev->devnum);
1025 return 0;
1026 }
1027 spin_lock_irqsave(&as->lock, flags);
1028 }
1029 if (u->dma.count >= u->dma.dmasize && !u->dma.mapped) {
1030 spin_unlock_irqrestore(&as->lock, flags);
1031 return 0;
1032 }
1033 u->flags |= FLG_RUNNING;
1034 if (!(u->flags & FLG_URB0RUNNING)) {
1035 urb = u->durb[0].urb;
1036 urb->dev = dev;
1037 urb->pipe = u->datapipe;
1038 urb->transfer_flags = URB_ISO_ASAP;
1039 urb->number_of_packets = DESCFRAMES;
1040 urb->context = as;
1041 urb->complete = usbin_completed;
1042 if (!usbin_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_KERNEL))
1043 u->flags |= FLG_URB0RUNNING;
1044 else
1045 u->flags &= ~FLG_RUNNING;
1046 }
1047 if (u->flags & FLG_RUNNING && !(u->flags & FLG_URB1RUNNING)) {
1048 urb = u->durb[1].urb;
1049 urb->dev = dev;
1050 urb->pipe = u->datapipe;
1051 urb->transfer_flags = URB_ISO_ASAP;
1052 urb->number_of_packets = DESCFRAMES;
1053 urb->context = as;
1054 urb->complete = usbin_completed;
1055 if (!usbin_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_KERNEL))
1056 u->flags |= FLG_URB1RUNNING;
1057 else
1058 u->flags &= ~FLG_RUNNING;
1059 }
1060 if (u->syncpipe) {
1061 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC0RUNNING)) {
1062 urb = u->surb[0].urb;
1063 urb->dev = dev;
1064 urb->pipe = u->syncpipe;
1065 urb->transfer_flags = URB_ISO_ASAP;
1066 urb->number_of_packets = SYNCFRAMES;
1067 urb->context = as;
1068 urb->complete = usbin_sync_completed;
1069 /* stride: u->syncinterval */
1070 if (!usbin_sync_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_KERNEL))
1071 u->flags |= FLG_SYNC0RUNNING;
1072 else
1073 u->flags &= ~FLG_RUNNING;
1074 }
1075 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC1RUNNING)) {
1076 urb = u->surb[1].urb;
1077 urb->dev = dev;
1078 urb->pipe = u->syncpipe;
1079 urb->transfer_flags = URB_ISO_ASAP;
1080 urb->number_of_packets = SYNCFRAMES;
1081 urb->context = as;
1082 urb->complete = usbin_sync_completed;
1083 /* stride: u->syncinterval */
1084 if (!usbin_sync_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_KERNEL))
1085 u->flags |= FLG_SYNC1RUNNING;
1086 else
1087 u->flags &= ~FLG_RUNNING;
1088 }
1089 }
1090 spin_unlock_irqrestore(&as->lock, flags);
1091 return 0;
1092 }
1093
1094 static void usbout_stop(struct usb_audiodev *as)
1095 {
1096 struct usbout *u = &as->usbout;
1097 unsigned long flags;
1098 unsigned int i, notkilled = 1;
1099
1100 spin_lock_irqsave(&as->lock, flags);
1101 u->flags &= ~FLG_RUNNING;
1102 i = u->flags;
1103 spin_unlock_irqrestore(&as->lock, flags);
1104 while (i & (FLG_URB0RUNNING|FLG_URB1RUNNING|FLG_SYNC0RUNNING|FLG_SYNC1RUNNING)) {
1105 set_current_state(notkilled ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
1106 schedule_timeout(1);
1107 spin_lock_irqsave(&as->lock, flags);
1108 i = u->flags;
1109 spin_unlock_irqrestore(&as->lock, flags);
1110 if (notkilled && signal_pending(current)) {
1111 if (i & FLG_URB0RUNNING)
1112 usb_kill_urb(u->durb[0].urb);
1113 if (i & FLG_URB1RUNNING)
1114 usb_kill_urb(u->durb[1].urb);
1115 if (i & FLG_SYNC0RUNNING)
1116 usb_kill_urb(u->surb[0].urb);
1117 if (i & FLG_SYNC1RUNNING)
1118 usb_kill_urb(u->surb[1].urb);
1119 notkilled = 0;
1120 }
1121 }
1122 set_current_state(TASK_RUNNING);
1123 kfree(u->durb[0].urb->transfer_buffer);
1124 kfree(u->durb[1].urb->transfer_buffer);
1125 kfree(u->surb[0].urb->transfer_buffer);
1126 kfree(u->surb[1].urb->transfer_buffer);
1127 u->durb[0].urb->transfer_buffer = u->durb[1].urb->transfer_buffer =
1128 u->surb[0].urb->transfer_buffer = u->surb[1].urb->transfer_buffer = NULL;
1129 }
1130
1131 static inline void usbout_release(struct usb_audiodev *as)
1132 {
1133 usbout_stop(as);
1134 }
1135
1136 static void usbout_disc(struct usb_audiodev *as)
1137 {
1138 struct usbout *u = &as->usbout;
1139 unsigned long flags;
1140
1141 spin_lock_irqsave(&as->lock, flags);
1142 u->flags &= ~(FLG_RUNNING | FLG_CONNECTED);
1143 spin_unlock_irqrestore(&as->lock, flags);
1144 usbout_stop(as);
1145 }
1146
1147 static void usbout_convert(struct usbout *u, unsigned char *buffer, unsigned int samples)
1148 {
1149 union {
1150 __s16 s[64];
1151 unsigned char b[0];
1152 } tmp;
1153 unsigned int scnt, maxs, ufmtsh, dfmtsh;
1154
1155 ufmtsh = AFMT_BYTESSHIFT(u->format);
1156 dfmtsh = AFMT_BYTESSHIFT(u->dma.format);
1157 maxs = (AFMT_ISSTEREO(u->dma.format | u->format)) ? 32 : 64;
1158 while (samples > 0) {
1159 scnt = samples;
1160 if (scnt > maxs)
1161 scnt = maxs;
1162 dmabuf_copyout(&u->dma, tmp.b, scnt << dfmtsh);
1163 conversion(tmp.b, u->dma.format, buffer, u->format, tmp.b, scnt);
1164 buffer += scnt << ufmtsh;
1165 samples -= scnt;
1166 }
1167 }
1168
1169 static int usbout_prepare_desc(struct usbout *u, struct urb *urb)
1170 {
1171 unsigned int i, ufmtsh, dfmtsh, err = 0, cnt, scnt, offs;
1172 unsigned char *cp = urb->transfer_buffer;
1173
1174 ufmtsh = AFMT_BYTESSHIFT(u->format);
1175 dfmtsh = AFMT_BYTESSHIFT(u->dma.format);
1176 for (i = offs = 0; i < DESCFRAMES; i++) {
1177 urb->iso_frame_desc[i].offset = offs;
1178 u->phase = (u->phase & 0x3fff) + u->freqm;
1179 scnt = u->phase >> 14;
1180 if (!scnt) {
1181 urb->iso_frame_desc[i].length = 0;
1182 continue;
1183 }
1184 cnt = scnt << dfmtsh;
1185 if (!u->dma.mapped) {
1186 if (cnt > u->dma.count) {
1187 scnt = u->dma.count >> dfmtsh;
1188 cnt = scnt << dfmtsh;
1189 err++;
1190 }
1191 u->dma.count -= cnt;
1192 } else
1193 u->dma.count += cnt;
1194 if (u->format == u->dma.format) {
1195 /* we do not need format conversion */
1196 dmabuf_copyout(&u->dma, cp, cnt);
1197 } else {
1198 /* we need sampling format conversion */
1199 usbout_convert(u, cp, scnt);
1200 }
1201 cnt = scnt << ufmtsh;
1202 urb->iso_frame_desc[i].length = cnt;
1203 offs += cnt;
1204 cp += cnt;
1205 }
1206 urb->interval = 1;
1207 if (err)
1208 u->dma.error++;
1209 if (u->dma.mapped) {
1210 if (u->dma.count >= (signed)u->dma.fragsize)
1211 wake_up(&u->dma.wait);
1212 } else {
1213 if ((signed)u->dma.dmasize >= u->dma.count + (signed)u->dma.fragsize)
1214 wake_up(&u->dma.wait);
1215 }
1216 return err ? -1 : 0;
1217 }
1218
1219 /*
1220 * return value: 0 if descriptor should be restarted, -1 otherwise
1221 */
1222 static int usbout_retire_desc(struct usbout *u, struct urb *urb)
1223 {
1224 unsigned int i;
1225
1226 for (i = 0; i < DESCFRAMES; i++) {
1227 if (urb->iso_frame_desc[i].status) {
1228 dprintk((KERN_DEBUG "usbout_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
1229 continue;
1230 }
1231 }
1232 return 0;
1233 }
1234
1235 static void usbout_completed(struct urb *urb, struct pt_regs *regs)
1236 {
1237 struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
1238 struct usbout *u = &as->usbout;
1239 unsigned long flags;
1240 unsigned int mask;
1241 int suret = 0;
1242
1243 #if 0
1244 printk(KERN_DEBUG "usbout_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
1245 #endif
1246 if (urb == u->durb[0].urb)
1247 mask = FLG_URB0RUNNING;
1248 else if (urb == u->durb[1].urb)
1249 mask = FLG_URB1RUNNING;
1250 else {
1251 mask = 0;
1252 printk(KERN_ERR "usbout_completed: panic: unknown URB\n");
1253 }
1254 urb->dev = as->state->usbdev;
1255 spin_lock_irqsave(&as->lock, flags);
1256 if (!usbout_retire_desc(u, urb) &&
1257 u->flags & FLG_RUNNING &&
1258 !usbout_prepare_desc(u, urb) &&
1259 (suret = usb_submit_urb(urb, GFP_ATOMIC)) == 0) {
1260 u->flags |= mask;
1261 } else {
1262 u->flags &= ~(mask | FLG_RUNNING);
1263 wake_up(&u->dma.wait);
1264 dprintk((KERN_DEBUG "usbout_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret));
1265 }
1266 spin_unlock_irqrestore(&as->lock, flags);
1267 }
1268
1269 static int usbout_sync_prepare_desc(struct usbout *u, struct urb *urb)
1270 {
1271 unsigned int i, offs;
1272
1273 for (i = offs = 0; i < SYNCFRAMES; i++, offs += 3) {
1274 urb->iso_frame_desc[i].length = 3;
1275 urb->iso_frame_desc[i].offset = offs;
1276 }
1277 urb->interval = 1;
1278 return 0;
1279 }
1280
1281 /*
1282 * return value: 0 if descriptor should be restarted, -1 otherwise
1283 */
1284 static int usbout_sync_retire_desc(struct usbout *u, struct urb *urb)
1285 {
1286 unsigned char *cp = urb->transfer_buffer;
1287 unsigned int f, i;
1288
1289 for (i = 0; i < SYNCFRAMES; i++, cp += 3) {
1290 if (urb->iso_frame_desc[i].status) {
1291 dprintk((KERN_DEBUG "usbout_sync_retire_desc: frame %u status %d\n", i, urb->iso_frame_desc[i].status));
1292 continue;
1293 }
1294 if (urb->iso_frame_desc[i].actual_length < 3) {
1295 dprintk((KERN_DEBUG "usbout_sync_retire_desc: frame %u length %d\n", i, urb->iso_frame_desc[i].actual_length));
1296 continue;
1297 }
1298 f = cp[0] | (cp[1] << 8) | (cp[2] << 16);
1299 if (abs(f - u->freqn) > (u->freqn >> 3) || f > u->freqmax) {
1300 printk(KERN_WARNING "usbout_sync_retire_desc: requested frequency %u (nominal %u) out of range!\n", f, u->freqn);
1301 continue;
1302 }
1303 u->freqm = f;
1304 }
1305 return 0;
1306 }
1307
1308 static void usbout_sync_completed(struct urb *urb, struct pt_regs *regs)
1309 {
1310 struct usb_audiodev *as = (struct usb_audiodev *)urb->context;
1311 struct usbout *u = &as->usbout;
1312 unsigned long flags;
1313 unsigned int mask;
1314 int suret = 0;
1315
1316 #if 0
1317 printk(KERN_DEBUG "usbout_sync_completed: status %d errcnt %d flags 0x%x\n", urb->status, urb->error_count, u->flags);
1318 #endif
1319 if (urb == u->surb[0].urb)
1320 mask = FLG_SYNC0RUNNING;
1321 else if (urb == u->surb[1].urb)
1322 mask = FLG_SYNC1RUNNING;
1323 else {
1324 mask = 0;
1325 printk(KERN_ERR "usbout_sync_completed: panic: unknown URB\n");
1326 }
1327 urb->dev = as->state->usbdev;
1328 spin_lock_irqsave(&as->lock, flags);
1329 if (!usbout_sync_retire_desc(u, urb) &&
1330 u->flags & FLG_RUNNING &&
1331 !usbout_sync_prepare_desc(u, urb) &&
1332 (suret = usb_submit_urb(urb, GFP_ATOMIC)) == 0) {
1333 u->flags |= mask;
1334 } else {
1335 u->flags &= ~(mask | FLG_RUNNING);
1336 wake_up(&u->dma.wait);
1337 dprintk((KERN_DEBUG "usbout_sync_completed: descriptor not restarted (usb_submit_urb: %d)\n", suret));
1338 }
1339 spin_unlock_irqrestore(&as->lock, flags);
1340 }
1341
1342 static int usbout_start(struct usb_audiodev *as)
1343 {
1344 struct usb_device *dev = as->state->usbdev;
1345 struct usbout *u = &as->usbout;
1346 struct urb *urb;
1347 unsigned long flags;
1348 unsigned int maxsze, bufsz;
1349
1350 #if 0
1351 printk(KERN_DEBUG "usbout_start: device %d ufmt 0x%08x dfmt 0x%08x srate %d\n",
1352 dev->devnum, u->format, u->dma.format, u->dma.srate);
1353 #endif
1354 /* allocate USB storage if not already done */
1355 spin_lock_irqsave(&as->lock, flags);
1356 if (!(u->flags & FLG_CONNECTED)) {
1357 spin_unlock_irqrestore(&as->lock, flags);
1358 return -EIO;
1359 }
1360 if (!(u->flags & FLG_RUNNING)) {
1361 spin_unlock_irqrestore(&as->lock, flags);
1362 u->freqn = u->freqm = ((u->dma.srate << 11) + 62) / 125; /* this will overflow at approx 2MSPS */
1363 u->freqmax = u->freqn + (u->freqn >> 2);
1364 u->phase = 0;
1365 maxsze = (u->freqmax + 0x3fff) >> (14 - AFMT_BYTESSHIFT(u->format));
1366 bufsz = DESCFRAMES * maxsze;
1367 kfree(u->durb[0].urb->transfer_buffer);
1368 u->durb[0].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1369 u->durb[0].urb->transfer_buffer_length = bufsz;
1370 kfree(u->durb[1].urb->transfer_buffer);
1371 u->durb[1].urb->transfer_buffer = kmalloc(bufsz, GFP_KERNEL);
1372 u->durb[1].urb->transfer_buffer_length = bufsz;
1373 if (u->syncpipe) {
1374 kfree(u->surb[0].urb->transfer_buffer);
1375 u->surb[0].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1376 u->surb[0].urb->transfer_buffer_length = 3*SYNCFRAMES;
1377 kfree(u->surb[1].urb->transfer_buffer);
1378 u->surb[1].urb->transfer_buffer = kmalloc(3*SYNCFRAMES, GFP_KERNEL);
1379 u->surb[1].urb->transfer_buffer_length = 3*SYNCFRAMES;
1380 }
1381 if (!u->durb[0].urb->transfer_buffer || !u->durb[1].urb->transfer_buffer ||
1382 (u->syncpipe && (!u->surb[0].urb->transfer_buffer || !u->surb[1].urb->transfer_buffer))) {
1383 printk(KERN_ERR "usbaudio: cannot start playback device %d\n", dev->devnum);
1384 return 0;
1385 }
1386 spin_lock_irqsave(&as->lock, flags);
1387 }
1388 if (u->dma.count <= 0 && !u->dma.mapped) {
1389 spin_unlock_irqrestore(&as->lock, flags);
1390 return 0;
1391 }
1392 u->flags |= FLG_RUNNING;
1393 if (!(u->flags & FLG_URB0RUNNING)) {
1394 urb = u->durb[0].urb;
1395 urb->dev = dev;
1396 urb->pipe = u->datapipe;
1397 urb->transfer_flags = URB_ISO_ASAP;
1398 urb->number_of_packets = DESCFRAMES;
1399 urb->context = as;
1400 urb->complete = usbout_completed;
1401 if (!usbout_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_ATOMIC))
1402 u->flags |= FLG_URB0RUNNING;
1403 else
1404 u->flags &= ~FLG_RUNNING;
1405 }
1406 if (u->flags & FLG_RUNNING && !(u->flags & FLG_URB1RUNNING)) {
1407 urb = u->durb[1].urb;
1408 urb->dev = dev;
1409 urb->pipe = u->datapipe;
1410 urb->transfer_flags = URB_ISO_ASAP;
1411 urb->number_of_packets = DESCFRAMES;
1412 urb->context = as;
1413 urb->complete = usbout_completed;
1414 if (!usbout_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_ATOMIC))
1415 u->flags |= FLG_URB1RUNNING;
1416 else
1417 u->flags &= ~FLG_RUNNING;
1418 }
1419 if (u->syncpipe) {
1420 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC0RUNNING)) {
1421 urb = u->surb[0].urb;
1422 urb->dev = dev;
1423 urb->pipe = u->syncpipe;
1424 urb->transfer_flags = URB_ISO_ASAP;
1425 urb->number_of_packets = SYNCFRAMES;
1426 urb->context = as;
1427 urb->complete = usbout_sync_completed;
1428 /* stride: u->syncinterval */
1429 if (!usbout_sync_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_ATOMIC))
1430 u->flags |= FLG_SYNC0RUNNING;
1431 else
1432 u->flags &= ~FLG_RUNNING;
1433 }
1434 if (u->flags & FLG_RUNNING && !(u->flags & FLG_SYNC1RUNNING)) {
1435 urb = u->surb[1].urb;
1436 urb->dev = dev;
1437 urb->pipe = u->syncpipe;
1438 urb->transfer_flags = URB_ISO_ASAP;
1439 urb->number_of_packets = SYNCFRAMES;
1440 urb->context = as;
1441 urb->complete = usbout_sync_completed;
1442 /* stride: u->syncinterval */
1443 if (!usbout_sync_prepare_desc(u, urb) && !usb_submit_urb(urb, GFP_ATOMIC))
1444 u->flags |= FLG_SYNC1RUNNING;
1445 else
1446 u->flags &= ~FLG_RUNNING;
1447 }
1448 }
1449 spin_unlock_irqrestore(&as->lock, flags);
1450 return 0;
1451 }
1452
1453 /* --------------------------------------------------------------------- */
1454
1455 static unsigned int format_goodness(struct audioformat *afp, unsigned int fmt, unsigned int srate)
1456 {
1457 unsigned int g = 0;
1458
1459 if (srate < afp->sratelo)
1460 g += afp->sratelo - srate;
1461 if (srate > afp->sratehi)
1462 g += srate - afp->sratehi;
1463 if (AFMT_ISSTEREO(afp->format) && !AFMT_ISSTEREO(fmt))
1464 g += 0x100000;
1465 if (!AFMT_ISSTEREO(afp->format) && AFMT_ISSTEREO(fmt))
1466 g += 0x400000;
1467 if (AFMT_IS16BIT(afp->format) && !AFMT_IS16BIT(fmt))
1468 g += 0x100000;
1469 if (!AFMT_IS16BIT(afp->format) && AFMT_IS16BIT(fmt))
1470 g += 0x400000;
1471 return g;
1472 }
1473
1474 static int find_format(struct audioformat *afp, unsigned int nr, unsigned int fmt, unsigned int srate)
1475 {
1476 unsigned int i, g, gb = ~0;
1477 int j = -1; /* default to failure */
1478
1479 /* find "best" format (according to format_goodness) */
1480 for (i = 0; i < nr; i++) {
1481 g = format_goodness(&afp[i], fmt, srate);
1482 if (g >= gb)
1483 continue;
1484 j = i;
1485 gb = g;
1486 }
1487 return j;
1488 }
1489
1490 static int set_format_in(struct usb_audiodev *as)
1491 {
1492 struct usb_device *dev = as->state->usbdev;
1493 struct usb_host_interface *alts;
1494 struct usb_interface *iface;
1495 struct usbin *u = &as->usbin;
1496 struct dmabuf *d = &u->dma;
1497 struct audioformat *fmt;
1498 unsigned int ep;
1499 unsigned char data[3];
1500 int fmtnr, ret;
1501
1502 iface = usb_ifnum_to_if(dev, u->interface);
1503 if (!iface)
1504 return 0;
1505
1506 fmtnr = find_format(as->fmtin, as->numfmtin, d->format, d->srate);
1507 if (fmtnr < 0) {
1508 printk(KERN_ERR "usbaudio: set_format_in(): failed to find desired format/speed combination.\n");
1509 return -1;
1510 }
1511
1512 fmt = as->fmtin + fmtnr;
1513 alts = usb_altnum_to_altsetting(iface, fmt->altsetting);
1514 u->format = fmt->format;
1515 u->datapipe = usb_rcvisocpipe(dev, alts->endpoint[0].desc.bEndpointAddress & 0xf);
1516 u->syncpipe = u->syncinterval = 0;
1517 if ((alts->endpoint[0].desc.bmAttributes & 0x0c) == 0x08) {
1518 if (alts->desc.bNumEndpoints < 2 ||
1519 alts->endpoint[1].desc.bmAttributes != 0x01 ||
1520 alts->endpoint[1].desc.bSynchAddress != 0 ||
1521 alts->endpoint[1].desc.bEndpointAddress != (alts->endpoint[0].desc.bSynchAddress & 0x7f)) {
1522 printk(KERN_WARNING "usbaudio: device %d interface %d altsetting %d claims adaptive in "
1523 "but has invalid synch pipe; treating as asynchronous in\n",
1524 dev->devnum, u->interface, fmt->altsetting);
1525 } else {
1526 u->syncpipe = usb_sndisocpipe(dev, alts->endpoint[1].desc.bEndpointAddress & 0xf);
1527 u->syncinterval = alts->endpoint[1].desc.bRefresh;
1528 }
1529 }
1530 if (d->srate < fmt->sratelo)
1531 d->srate = fmt->sratelo;
1532 if (d->srate > fmt->sratehi)
1533 d->srate = fmt->sratehi;
1534 dprintk((KERN_DEBUG "usbaudio: set_format_in: usb_set_interface %u %u\n",
1535 u->interface, fmt->altsetting));
1536 if (usb_set_interface(dev, alts->desc.bInterfaceNumber, fmt->altsetting) < 0) {
1537 printk(KERN_WARNING "usbaudio: usb_set_interface failed, device %d interface %d altsetting %d\n",
1538 dev->devnum, u->interface, fmt->altsetting);
1539 return -1;
1540 }
1541 if (fmt->sratelo == fmt->sratehi)
1542 return 0;
1543 ep = usb_pipeendpoint(u->datapipe) | (u->datapipe & USB_DIR_IN);
1544 /* if endpoint has pitch control, enable it */
1545 if (fmt->attributes & 0x02) {
1546 data[0] = 1;
1547 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1548 PITCH_CONTROL << 8, ep, data, 1, 1000)) < 0) {
1549 printk(KERN_ERR "usbaudio: failure (error %d) to set output pitch control device %d interface %u endpoint 0x%x to %u\n",
1550 ret, dev->devnum, u->interface, ep, d->srate);
1551 return -1;
1552 }
1553 }
1554 /* if endpoint has sampling rate control, set it */
1555 if (fmt->attributes & 0x01) {
1556 data[0] = d->srate;
1557 data[1] = d->srate >> 8;
1558 data[2] = d->srate >> 16;
1559 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1560 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
1561 printk(KERN_ERR "usbaudio: failure (error %d) to set input sampling frequency device %d interface %u endpoint 0x%x to %u\n",
1562 ret, dev->devnum, u->interface, ep, d->srate);
1563 return -1;
1564 }
1565 if ((ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
1566 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
1567 printk(KERN_ERR "usbaudio: failure (error %d) to get input sampling frequency device %d interface %u endpoint 0x%x\n",
1568 ret, dev->devnum, u->interface, ep);
1569 return -1;
1570 }
1571 dprintk((KERN_DEBUG "usbaudio: set_format_in: device %d interface %d altsetting %d srate req: %u real %u\n",
1572 dev->devnum, u->interface, fmt->altsetting, d->srate, data[0] | (data[1] << 8) | (data[2] << 16)));
1573 d->srate = data[0] | (data[1] << 8) | (data[2] << 16);
1574 }
1575 dprintk((KERN_DEBUG "usbaudio: set_format_in: USB format 0x%x, DMA format 0x%x srate %u\n", u->format, d->format, d->srate));
1576 return 0;
1577 }
1578
1579 static int set_format_out(struct usb_audiodev *as)
1580 {
1581 struct usb_device *dev = as->state->usbdev;
1582 struct usb_host_interface *alts;
1583 struct usb_interface *iface;
1584 struct usbout *u = &as->usbout;
1585 struct dmabuf *d = &u->dma;
1586 struct audioformat *fmt;
1587 unsigned int ep;
1588 unsigned char data[3];
1589 int fmtnr, ret;
1590
1591 iface = usb_ifnum_to_if(dev, u->interface);
1592 if (!iface)
1593 return 0;
1594
1595 fmtnr = find_format(as->fmtout, as->numfmtout, d->format, d->srate);
1596 if (fmtnr < 0) {
1597 printk(KERN_ERR "usbaudio: set_format_out(): failed to find desired format/speed combination.\n");
1598 return -1;
1599 }
1600
1601 fmt = as->fmtout + fmtnr;
1602 u->format = fmt->format;
1603 alts = usb_altnum_to_altsetting(iface, fmt->altsetting);
1604 u->datapipe = usb_sndisocpipe(dev, alts->endpoint[0].desc.bEndpointAddress & 0xf);
1605 u->syncpipe = u->syncinterval = 0;
1606 if ((alts->endpoint[0].desc.bmAttributes & 0x0c) == 0x04) {
1607 #if 0
1608 printk(KERN_DEBUG "bNumEndpoints 0x%02x endpoint[1].bmAttributes 0x%02x\n"
1609 KERN_DEBUG "endpoint[1].bSynchAddress 0x%02x endpoint[1].bEndpointAddress 0x%02x\n"
1610 KERN_DEBUG "endpoint[0].bSynchAddress 0x%02x\n", alts->bNumEndpoints,
1611 alts->endpoint[1].bmAttributes, alts->endpoint[1].bSynchAddress,
1612 alts->endpoint[1].bEndpointAddress, alts->endpoint[0].bSynchAddress);
1613 #endif
1614 if (alts->desc.bNumEndpoints < 2 ||
1615 alts->endpoint[1].desc.bmAttributes != 0x01 ||
1616 alts->endpoint[1].desc.bSynchAddress != 0 ||
1617 alts->endpoint[1].desc.bEndpointAddress != (alts->endpoint[0].desc.bSynchAddress | 0x80)) {
1618 printk(KERN_WARNING "usbaudio: device %d interface %d altsetting %d claims asynch out "
1619 "but has invalid synch pipe; treating as adaptive out\n",
1620 dev->devnum, u->interface, fmt->altsetting);
1621 } else {
1622 u->syncpipe = usb_rcvisocpipe(dev, alts->endpoint[1].desc.bEndpointAddress & 0xf);
1623 u->syncinterval = alts->endpoint[1].desc.bRefresh;
1624 }
1625 }
1626 if (d->srate < fmt->sratelo)
1627 d->srate = fmt->sratelo;
1628 if (d->srate > fmt->sratehi)
1629 d->srate = fmt->sratehi;
1630 dprintk((KERN_DEBUG "usbaudio: set_format_out: usb_set_interface %u %u\n",
1631 u->interface, fmt->altsetting));
1632 if (usb_set_interface(dev, u->interface, fmt->altsetting) < 0) {
1633 printk(KERN_WARNING "usbaudio: usb_set_interface failed, device %d interface %d altsetting %d\n",
1634 dev->devnum, u->interface, fmt->altsetting);
1635 return -1;
1636 }
1637 if (fmt->sratelo == fmt->sratehi)
1638 return 0;
1639 ep = usb_pipeendpoint(u->datapipe) | (u->datapipe & USB_DIR_IN);
1640 /* if endpoint has pitch control, enable it */
1641 if (fmt->attributes & 0x02) {
1642 data[0] = 1;
1643 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1644 PITCH_CONTROL << 8, ep, data, 1, 1000)) < 0) {
1645 printk(KERN_ERR "usbaudio: failure (error %d) to set output pitch control device %d interface %u endpoint 0x%x to %u\n",
1646 ret, dev->devnum, u->interface, ep, d->srate);
1647 return -1;
1648 }
1649 }
1650 /* if endpoint has sampling rate control, set it */
1651 if (fmt->attributes & 0x01) {
1652 data[0] = d->srate;
1653 data[1] = d->srate >> 8;
1654 data[2] = d->srate >> 16;
1655 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1656 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
1657 printk(KERN_ERR "usbaudio: failure (error %d) to set output sampling frequency device %d interface %u endpoint 0x%x to %u\n",
1658 ret, dev->devnum, u->interface, ep, d->srate);
1659 return -1;
1660 }
1661 if ((ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
1662 SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
1663 printk(KERN_ERR "usbaudio: failure (error %d) to get output sampling frequency device %d interface %u endpoint 0x%x\n",
1664 ret, dev->devnum, u->interface, ep);
1665 return -1;
1666 }
1667 dprintk((KERN_DEBUG "usbaudio: set_format_out: device %d interface %d altsetting %d srate req: %u real %u\n",
1668 dev->devnum, u->interface, fmt->altsetting, d->srate, data[0] | (data[1] << 8) | (data[2] << 16)));
1669 d->srate = data[0] | (data[1] << 8) | (data[2] << 16);
1670 }
1671 dprintk((KERN_DEBUG "usbaudio: set_format_out: USB format 0x%x, DMA format 0x%x srate %u\n", u->format, d->format, d->srate));
1672 return 0;
1673 }
1674
1675 static int set_format(struct usb_audiodev *s, unsigned int fmode, unsigned int fmt, unsigned int srate)
1676 {
1677 int ret1 = 0, ret2 = 0;
1678
1679 if (!(fmode & (FMODE_READ|FMODE_WRITE)))
1680 return -EINVAL;
1681 if (fmode & FMODE_READ) {
1682 usbin_stop(s);
1683 s->usbin.dma.ready = 0;
1684 if (fmt == AFMT_QUERY)
1685 fmt = s->usbin.dma.format;
1686 else
1687 s->usbin.dma.format = fmt;
1688 if (!srate)
1689 srate = s->usbin.dma.srate;
1690 else
1691 s->usbin.dma.srate = srate;
1692 }
1693 if (fmode & FMODE_WRITE) {
1694 usbout_stop(s);
1695 s->usbout.dma.ready = 0;
1696 if (fmt == AFMT_QUERY)
1697 fmt = s->usbout.dma.format;
1698 else
1699 s->usbout.dma.format = fmt;
1700 if (!srate)
1701 srate = s->usbout.dma.srate;
1702 else
1703 s->usbout.dma.srate = srate;
1704 }
1705 if (fmode & FMODE_READ)
1706 ret1 = set_format_in(s);
1707 if (fmode & FMODE_WRITE)
1708 ret2 = set_format_out(s);
1709 return ret1 ? ret1 : ret2;
1710 }
1711
1712 /* --------------------------------------------------------------------- */
1713
1714 static int wrmixer(struct usb_mixerdev *ms, unsigned mixch, unsigned value)
1715 {
1716 struct usb_device *dev = ms->state->usbdev;
1717 unsigned char data[2];
1718 struct mixerchannel *ch;
1719 int v1, v2, v3;
1720
1721 if (mixch >= ms->numch)
1722 return -1;
1723 ch = &ms->ch[mixch];
1724 v3 = ch->maxval - ch->minval;
1725 v1 = value & 0xff;
1726 v2 = (value >> 8) & 0xff;
1727 if (v1 > 100)
1728 v1 = 100;
1729 if (v2 > 100)
1730 v2 = 100;
1731 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1732 v2 = v1;
1733 ch->value = v1 | (v2 << 8);
1734 v1 = (v1 * v3) / 100 + ch->minval;
1735 v2 = (v2 * v3) / 100 + ch->minval;
1736 switch (ch->selector) {
1737 case 0: /* mixer unit request */
1738 data[0] = v1;
1739 data[1] = v1 >> 8;
1740 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1741 (ch->chnum << 8) | 1, ms->iface | (ch->unitid << 8), data, 2, 1000) < 0)
1742 goto err;
1743 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1744 return 0;
1745 data[0] = v2;
1746 data[1] = v2 >> 8;
1747 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1748 ((ch->chnum + !!(ch->flags & MIXFLG_STEREOIN)) << 8) | (1 + !!(ch->flags & MIXFLG_STEREOOUT)),
1749 ms->iface | (ch->unitid << 8), data, 2, 1000) < 0)
1750 goto err;
1751 return 0;
1752
1753 /* various feature unit controls */
1754 case VOLUME_CONTROL:
1755 data[0] = v1;
1756 data[1] = v1 >> 8;
1757 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1758 (ch->selector << 8) | ch->chnum, ms->iface | (ch->unitid << 8), data, 2, 1000) < 0)
1759 goto err;
1760 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1761 return 0;
1762 data[0] = v2;
1763 data[1] = v2 >> 8;
1764 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1765 (ch->selector << 8) | (ch->chnum + 1), ms->iface | (ch->unitid << 8), data, 2, 1000) < 0)
1766 goto err;
1767 return 0;
1768
1769 case BASS_CONTROL:
1770 case MID_CONTROL:
1771 case TREBLE_CONTROL:
1772 data[0] = v1 >> 8;
1773 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1774 (ch->selector << 8) | ch->chnum, ms->iface | (ch->unitid << 8), data, 1, 1000) < 0)
1775 goto err;
1776 if (!(ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
1777 return 0;
1778 data[0] = v2 >> 8;
1779 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1780 (ch->selector << 8) | (ch->chnum + 1), ms->iface | (ch->unitid << 8), data, 1, 1000) < 0)
1781 goto err;
1782 return 0;
1783
1784 default:
1785 return -1;
1786 }
1787 return 0;
1788
1789 err:
1790 printk(KERN_ERR "usbaudio: mixer request device %u if %u unit %u ch %u selector %u failed\n",
1791 dev->devnum, ms->iface, ch->unitid, ch->chnum, ch->selector);
1792 return -1;
1793 }
1794
1795 static int get_rec_src(struct usb_mixerdev *ms)
1796 {
1797 struct usb_device *dev = ms->state->usbdev;
1798 unsigned int mask = 0, retmask = 0;
1799 unsigned int i, j;
1800 unsigned char buf;
1801 int err = 0;
1802
1803 for (i = 0; i < ms->numch; i++) {
1804 if (!ms->ch[i].slctunitid || (mask & (1 << i)))
1805 continue;
1806 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1807 0, ms->iface | (ms->ch[i].slctunitid << 8), &buf, 1, 1000) < 0) {
1808 err = -EIO;
1809 printk(KERN_ERR "usbaudio: selector read request device %u if %u unit %u failed\n",
1810 dev->devnum, ms->iface, ms->ch[i].slctunitid & 0xff);
1811 continue;
1812 }
1813 for (j = i; j < ms->numch; j++) {
1814 if ((ms->ch[i].slctunitid ^ ms->ch[j].slctunitid) & 0xff)
1815 continue;
1816 mask |= 1 << j;
1817 if (buf == (ms->ch[j].slctunitid >> 8))
1818 retmask |= 1 << ms->ch[j].osschannel;
1819 }
1820 }
1821 if (err)
1822 return -EIO;
1823 return retmask;
1824 }
1825
1826 static int set_rec_src(struct usb_mixerdev *ms, int srcmask)
1827 {
1828 struct usb_device *dev = ms->state->usbdev;
1829 unsigned int mask = 0, smask, bmask;
1830 unsigned int i, j;
1831 unsigned char buf;
1832 int err = 0;
1833
1834 for (i = 0; i < ms->numch; i++) {
1835 if (!ms->ch[i].slctunitid || (mask & (1 << i)))
1836 continue;
1837 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1838 0, ms->iface | (ms->ch[i].slctunitid << 8), &buf, 1, 1000) < 0) {
1839 err = -EIO;
1840 printk(KERN_ERR "usbaudio: selector read request device %u if %u unit %u failed\n",
1841 dev->devnum, ms->iface, ms->ch[i].slctunitid & 0xff);
1842 continue;
1843 }
1844 /* first generate smask */
1845 smask = bmask = 0;
1846 for (j = i; j < ms->numch; j++) {
1847 if ((ms->ch[i].slctunitid ^ ms->ch[j].slctunitid) & 0xff)
1848 continue;
1849 smask |= 1 << ms->ch[j].osschannel;
1850 if (buf == (ms->ch[j].slctunitid >> 8))
1851 bmask |= 1 << ms->ch[j].osschannel;
1852 mask |= 1 << j;
1853 }
1854 /* check for multiple set sources */
1855 j = hweight32(srcmask & smask);
1856 if (j == 0)
1857 continue;
1858 if (j > 1)
1859 srcmask &= ~bmask;
1860 for (j = i; j < ms->numch; j++) {
1861 if ((ms->ch[i].slctunitid ^ ms->ch[j].slctunitid) & 0xff)
1862 continue;
1863 if (!(srcmask & (1 << ms->ch[j].osschannel)))
1864 continue;
1865 buf = ms->ch[j].slctunitid >> 8;
1866 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1867 0, ms->iface | (ms->ch[j].slctunitid << 8), &buf, 1, 1000) < 0) {
1868 err = -EIO;
1869 printk(KERN_ERR "usbaudio: selector write request device %u if %u unit %u failed\n",
1870 dev->devnum, ms->iface, ms->ch[j].slctunitid & 0xff);
1871 continue;
1872 }
1873 }
1874 }
1875 return err ? -EIO : 0;
1876 }
1877
1878 /* --------------------------------------------------------------------- */
1879
1880 /*
1881 * should be called with open_sem hold, so that no new processes
1882 * look at the audio device to be destroyed
1883 */
1884
1885 static void release(struct usb_audio_state *s)
1886 {
1887 struct usb_audiodev *as;
1888 struct usb_mixerdev *ms;
1889
1890 s->count--;
1891 if (s->count) {
1892 up(&open_sem);
1893 return;
1894 }
1895 up(&open_sem);
1896 wake_up(&open_wait);
1897 while (!list_empty(&s->audiolist)) {
1898 as = list_entry(s->audiolist.next, struct usb_audiodev, list);
1899 list_del(&as->list);
1900 usbin_release(as);
1901 usbout_release(as);
1902 dmabuf_release(&as->usbin.dma);
1903 dmabuf_release(&as->usbout.dma);
1904 usb_free_urb(as->usbin.durb[0].urb);
1905 usb_free_urb(as->usbin.durb[1].urb);
1906 usb_free_urb(as->usbin.surb[0].urb);
1907 usb_free_urb(as->usbin.surb[1].urb);
1908 usb_free_urb(as->usbout.durb[0].urb);
1909 usb_free_urb(as->usbout.durb[1].urb);
1910 usb_free_urb(as->usbout.surb[0].urb);
1911 usb_free_urb(as->usbout.surb[1].urb);
1912 kfree(as);
1913 }
1914 while (!list_empty(&s->mixerlist)) {
1915 ms = list_entry(s->mixerlist.next, struct usb_mixerdev, list);
1916 list_del(&ms->list);
1917 kfree(ms);
1918 }
1919 kfree(s);
1920 }
1921
1922 static inline int prog_dmabuf_in(struct usb_audiodev *as)
1923 {
1924 usbin_stop(as);
1925 return dmabuf_init(&as->usbin.dma);
1926 }
1927
1928 static inline int prog_dmabuf_out(struct usb_audiodev *as)
1929 {
1930 usbout_stop(as);
1931 return dmabuf_init(&as->usbout.dma);
1932 }
1933
1934 /* --------------------------------------------------------------------- */
1935
1936 static int usb_audio_open_mixdev(struct inode *inode, struct file *file)
1937 {
1938 unsigned int minor = iminor(inode);
1939 struct usb_mixerdev *ms;
1940 struct usb_audio_state *s;
1941
1942 down(&open_sem);
1943 list_for_each_entry(s, &audiodevs, audiodev) {
1944 list_for_each_entry(ms, &s->mixerlist, list) {
1945 if (ms->dev_mixer == minor)
1946 goto mixer_found;
1947 }
1948 }
1949 up(&open_sem);
1950 return -ENODEV;
1951
1952 mixer_found:
1953 if (!s->usbdev) {
1954 up(&open_sem);
1955 return -EIO;
1956 }
1957 file->private_data = ms;
1958 s->count++;
1959
1960 up(&open_sem);
1961 return nonseekable_open(inode, file);
1962 }
1963
1964 static int usb_audio_release_mixdev(struct inode *inode, struct file *file)
1965 {
1966 struct usb_mixerdev *ms = (struct usb_mixerdev *)file->private_data;
1967 struct usb_audio_state *s;
1968
1969 lock_kernel();
1970 s = ms->state;
1971 down(&open_sem);
1972 release(s);
1973 unlock_kernel();
1974 return 0;
1975 }
1976
1977 static int usb_audio_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1978 {
1979 struct usb_mixerdev *ms = (struct usb_mixerdev *)file->private_data;
1980 int i, j, val;
1981 int __user *user_arg = (int __user *)arg;
1982
1983 if (!ms->state->usbdev)
1984 return -ENODEV;
1985
1986 if (cmd == SOUND_MIXER_INFO) {
1987 mixer_info info;
1988
1989 memset(&info, 0, sizeof(info));
1990 strncpy(info.id, "USB_AUDIO", sizeof(info.id));
1991 strncpy(info.name, "USB Audio Class Driver", sizeof(info.name));
1992 info.modify_counter = ms->modcnt;
1993 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
1994 return -EFAULT;
1995 return 0;
1996 }
1997 if (cmd == SOUND_OLD_MIXER_INFO) {
1998 _old_mixer_info info;
1999
2000 memset(&info, 0, sizeof(info));
2001 strncpy(info.id, "USB_AUDIO", sizeof(info.id));
2002 strncpy(info.name, "USB Audio Class Driver", sizeof(info.name));
2003 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
2004 return -EFAULT;
2005 return 0;
2006 }
2007 if (cmd == OSS_GETVERSION)
2008 return put_user(SOUND_VERSION, user_arg);
2009 if (_IOC_TYPE(cmd) != 'M' || _IOC_SIZE(cmd) != sizeof(int))
2010 return -EINVAL;
2011 if (_IOC_DIR(cmd) == _IOC_READ) {
2012 switch (_IOC_NR(cmd)) {
2013 case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
2014 val = get_rec_src(ms);
2015 if (val < 0)
2016 return val;
2017 return put_user(val, user_arg);
2018
2019 case SOUND_MIXER_DEVMASK: /* Arg contains a bit for each supported device */
2020 for (val = i = 0; i < ms->numch; i++)
2021 val |= 1 << ms->ch[i].osschannel;
2022 return put_user(val, user_arg);
2023
2024 case SOUND_MIXER_RECMASK: /* Arg contains a bit for each supported recording source */
2025 for (val = i = 0; i < ms->numch; i++)
2026 if (ms->ch[i].slctunitid)
2027 val |= 1 << ms->ch[i].osschannel;
2028 return put_user(val, user_arg);
2029
2030 case SOUND_MIXER_STEREODEVS: /* Mixer channels supporting stereo */
2031 for (val = i = 0; i < ms->numch; i++)
2032 if (ms->ch[i].flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT))
2033 val |= 1 << ms->ch[i].osschannel;
2034 return put_user(val, user_arg);
2035
2036 case SOUND_MIXER_CAPS:
2037 return put_user(SOUND_CAP_EXCL_INPUT, user_arg);
2038
2039 default:
2040 i = _IOC_NR(cmd);
2041 if (i >= SOUND_MIXER_NRDEVICES)
2042 return -EINVAL;
2043 for (j = 0; j < ms->numch; j++) {
2044 if (ms->ch[j].osschannel == i) {
2045 return put_user(ms->ch[j].value, user_arg);
2046 }
2047 }
2048 return -EINVAL;
2049 }
2050 }
2051 if (_IOC_DIR(cmd) != (_IOC_READ|_IOC_WRITE))
2052 return -EINVAL;
2053 ms->modcnt++;
2054 switch (_IOC_NR(cmd)) {
2055 case SOUND_MIXER_RECSRC: /* Arg contains a bit for each recording source */
2056 if (get_user(val, user_arg))
2057 return -EFAULT;
2058 return set_rec_src(ms, val);
2059
2060 default:
2061 i = _IOC_NR(cmd);
2062 if (i >= SOUND_MIXER_NRDEVICES)
2063 return -EINVAL;
2064 for (j = 0; j < ms->numch && ms->ch[j].osschannel != i; j++);
2065 if (j >= ms->numch)
2066 return -EINVAL;
2067 if (get_user(val, user_arg))
2068 return -EFAULT;
2069 if (wrmixer(ms, j, val))
2070 return -EIO;
2071 return put_user(ms->ch[j].value, user_arg);
2072 }
2073 }
2074
2075 static /*const*/ struct file_operations usb_mixer_fops = {
2076 .owner = THIS_MODULE,
2077 .llseek = no_llseek,
2078 .ioctl = usb_audio_ioctl_mixdev,
2079 .open = usb_audio_open_mixdev,
2080 .release = usb_audio_release_mixdev,
2081 };
2082
2083 /* --------------------------------------------------------------------- */
2084
2085 static int drain_out(struct usb_audiodev *as, int nonblock)
2086 {
2087 DECLARE_WAITQUEUE(wait, current);
2088 unsigned long flags;
2089 int count, tmo;
2090
2091 if (as->usbout.dma.mapped || !as->usbout.dma.ready)
2092 return 0;
2093 usbout_start(as);
2094 add_wait_queue(&as->usbout.dma.wait, &wait);
2095 for (;;) {
2096 __set_current_state(TASK_INTERRUPTIBLE);
2097 spin_lock_irqsave(&as->lock, flags);
2098 count = as->usbout.dma.count;
2099 spin_unlock_irqrestore(&as->lock, flags);
2100 if (count <= 0)
2101 break;
2102 if (signal_pending(current))
2103 break;
2104 if (nonblock) {
2105 remove_wait_queue(&as->usbout.dma.wait, &wait);
2106 set_current_state(TASK_RUNNING);
2107 return -EBUSY;
2108 }
2109 tmo = 3 * HZ * count / as->usbout.dma.srate;
2110 tmo >>= AFMT_BYTESSHIFT(as->usbout.dma.format);
2111 if (!schedule_timeout(tmo + 1)) {
2112 printk(KERN_DEBUG "usbaudio: dma timed out??\n");
2113 break;
2114 }
2115 }
2116 remove_wait_queue(&as->usbout.dma.wait, &wait);
2117 set_current_state(TASK_RUNNING);
2118 if (signal_pending(current))
2119 return -ERESTARTSYS;
2120 return 0;
2121 }
2122
2123 /* --------------------------------------------------------------------- */
2124
2125 static ssize_t usb_audio_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
2126 {
2127 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2128 DECLARE_WAITQUEUE(wait, current);
2129 ssize_t ret = 0;
2130 unsigned long flags;
2131 unsigned int ptr;
2132 int cnt, err;
2133
2134 if (as->usbin.dma.mapped)
2135 return -ENXIO;
2136 if (!as->usbin.dma.ready && (ret = prog_dmabuf_in(as)))
2137 return ret;
2138 if (!access_ok(VERIFY_WRITE, buffer, count))
2139 return -EFAULT;
2140 add_wait_queue(&as->usbin.dma.wait, &wait);
2141 while (count > 0) {
2142 spin_lock_irqsave(&as->lock, flags);
2143 ptr = as->usbin.dma.rdptr;
2144 cnt = as->usbin.dma.count;
2145 /* set task state early to avoid wakeup races */
2146 if (cnt <= 0)
2147 __set_current_state(TASK_INTERRUPTIBLE);
2148 spin_unlock_irqrestore(&as->lock, flags);
2149 if (cnt > count)
2150 cnt = count;
2151 if (cnt <= 0) {
2152 if (usbin_start(as)) {
2153 if (!ret)
2154 ret = -ENODEV;
2155 break;
2156 }
2157 if (file->f_flags & O_NONBLOCK) {
2158 if (!ret)
2159 ret = -EAGAIN;
2160 break;
2161 }
2162 schedule();
2163 if (signal_pending(current)) {
2164 if (!ret)
2165 ret = -ERESTARTSYS;
2166 break;
2167 }
2168 continue;
2169 }
2170 if ((err = dmabuf_copyout_user(&as->usbin.dma, ptr, buffer, cnt))) {
2171 if (!ret)
2172 ret = err;
2173 break;
2174 }
2175 ptr += cnt;
2176 if (ptr >= as->usbin.dma.dmasize)
2177 ptr -= as->usbin.dma.dmasize;
2178 spin_lock_irqsave(&as->lock, flags);
2179 as->usbin.dma.rdptr = ptr;
2180 as->usbin.dma.count -= cnt;
2181 spin_unlock_irqrestore(&as->lock, flags);
2182 count -= cnt;
2183 buffer += cnt;
2184 ret += cnt;
2185 }
2186 __set_current_state(TASK_RUNNING);
2187 remove_wait_queue(&as->usbin.dma.wait, &wait);
2188 return ret;
2189 }
2190
2191 static ssize_t usb_audio_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
2192 {
2193 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2194 DECLARE_WAITQUEUE(wait, current);
2195 ssize_t ret = 0;
2196 unsigned long flags;
2197 unsigned int ptr;
2198 unsigned int start_thr;
2199 int cnt, err;
2200
2201 if (as->usbout.dma.mapped)
2202 return -ENXIO;
2203 if (!as->usbout.dma.ready && (ret = prog_dmabuf_out(as)))
2204 return ret;
2205 if (!access_ok(VERIFY_READ, buffer, count))
2206 return -EFAULT;
2207 start_thr = (as->usbout.dma.srate << AFMT_BYTESSHIFT(as->usbout.dma.format)) / (1000 / (3 * DESCFRAMES));
2208 add_wait_queue(&as->usbout.dma.wait, &wait);
2209 while (count > 0) {
2210 #if 0
2211 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",
2212 count, as->usbout.dma.count, as->usbout.dma.rdptr, as->usbout.dma.wrptr, as->usbout.dma.dmasize, as->usbout.dma.fragsize,
2213 as->usbout.flags, current->state);
2214 #endif
2215 spin_lock_irqsave(&as->lock, flags);
2216 if (as->usbout.dma.count < 0) {
2217 as->usbout.dma.count = 0;
2218 as->usbout.dma.rdptr = as->usbout.dma.wrptr;
2219 }
2220 ptr = as->usbout.dma.wrptr;
2221 cnt = as->usbout.dma.dmasize - as->usbout.dma.count;
2222 /* set task state early to avoid wakeup races */
2223 if (cnt <= 0)
2224 __set_current_state(TASK_INTERRUPTIBLE);
2225 spin_unlock_irqrestore(&as->lock, flags);
2226 if (cnt > count)
2227 cnt = count;
2228 if (cnt <= 0) {
2229 if (usbout_start(as)) {
2230 if (!ret)
2231 ret = -ENODEV;
2232 break;
2233 }
2234 if (file->f_flags & O_NONBLOCK) {
2235 if (!ret)
2236 ret = -EAGAIN;
2237 break;
2238 }
2239 schedule();
2240 if (signal_pending(current)) {
2241 if (!ret)
2242 ret = -ERESTARTSYS;
2243 break;
2244 }
2245 continue;
2246 }
2247 if ((err = dmabuf_copyin_user(&as->usbout.dma, ptr, buffer, cnt))) {
2248 if (!ret)
2249 ret = err;
2250 break;
2251 }
2252 ptr += cnt;
2253 if (ptr >= as->usbout.dma.dmasize)
2254 ptr -= as->usbout.dma.dmasize;
2255 spin_lock_irqsave(&as->lock, flags);
2256 as->usbout.dma.wrptr = ptr;
2257 as->usbout.dma.count += cnt;
2258 spin_unlock_irqrestore(&as->lock, flags);
2259 count -= cnt;
2260 buffer += cnt;
2261 ret += cnt;
2262 if (as->usbout.dma.count >= start_thr && usbout_start(as)) {
2263 if (!ret)
2264 ret = -ENODEV;
2265 break;
2266 }
2267 }
2268 __set_current_state(TASK_RUNNING);
2269 remove_wait_queue(&as->usbout.dma.wait, &wait);
2270 return ret;
2271 }
2272
2273 /* Called without the kernel lock - fine */
2274 static unsigned int usb_audio_poll(struct file *file, struct poll_table_struct *wait)
2275 {
2276 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2277 unsigned long flags;
2278 unsigned int mask = 0;
2279
2280 if (file->f_mode & FMODE_WRITE) {
2281 if (!as->usbout.dma.ready)
2282 prog_dmabuf_out(as);
2283 poll_wait(file, &as->usbout.dma.wait, wait);
2284 }
2285 if (file->f_mode & FMODE_READ) {
2286 if (!as->usbin.dma.ready)
2287 prog_dmabuf_in(as);
2288 poll_wait(file, &as->usbin.dma.wait, wait);
2289 }
2290 spin_lock_irqsave(&as->lock, flags);
2291 if (file->f_mode & FMODE_READ) {
2292 if (as->usbin.dma.count >= (signed)as->usbin.dma.fragsize)
2293 mask |= POLLIN | POLLRDNORM;
2294 }
2295 if (file->f_mode & FMODE_WRITE) {
2296 if (as->usbout.dma.mapped) {
2297 if (as->usbout.dma.count >= (signed)as->usbout.dma.fragsize)
2298 mask |= POLLOUT | POLLWRNORM;
2299 } else {
2300 if ((signed)as->usbout.dma.dmasize >= as->usbout.dma.count + (signed)as->usbout.dma.fragsize)
2301 mask |= POLLOUT | POLLWRNORM;
2302 }
2303 }
2304 spin_unlock_irqrestore(&as->lock, flags);
2305 return mask;
2306 }
2307
2308 static int usb_audio_mmap(struct file *file, struct vm_area_struct *vma)
2309 {
2310 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2311 struct dmabuf *db;
2312 int ret = -EINVAL;
2313
2314 lock_kernel();
2315 if (vma->vm_flags & VM_WRITE) {
2316 if ((ret = prog_dmabuf_out(as)) != 0)
2317 goto out;
2318 db = &as->usbout.dma;
2319 } else if (vma->vm_flags & VM_READ) {
2320 if ((ret = prog_dmabuf_in(as)) != 0)
2321 goto out;
2322 db = &as->usbin.dma;
2323 } else
2324 goto out;
2325
2326 ret = -EINVAL;
2327 if (vma->vm_pgoff != 0)
2328 goto out;
2329
2330 ret = dmabuf_mmap(vma, db, vma->vm_start, vma->vm_end - vma->vm_start, vma->vm_page_prot);
2331 out:
2332 unlock_kernel();
2333 return ret;
2334 }
2335
2336 static int usb_audio_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2337 {
2338 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2339 struct usb_audio_state *s = as->state;
2340 int __user *user_arg = (int __user *)arg;
2341 unsigned long flags;
2342 audio_buf_info abinfo;
2343 count_info cinfo;
2344 int val = 0;
2345 int val2, mapped, ret;
2346
2347 if (!s->usbdev)
2348 return -EIO;
2349 mapped = ((file->f_mode & FMODE_WRITE) && as->usbout.dma.mapped) ||
2350 ((file->f_mode & FMODE_READ) && as->usbin.dma.mapped);
2351 #if 0
2352 if (arg)
2353 get_user(val, (int *)arg);
2354 printk(KERN_DEBUG "usbaudio: usb_audio_ioctl cmd=%x arg=%lx *arg=%d\n", cmd, arg, val)
2355 #endif
2356 switch (cmd) {
2357 case OSS_GETVERSION:
2358 return put_user(SOUND_VERSION, user_arg);
2359
2360 case SNDCTL_DSP_SYNC:
2361 if (file->f_mode & FMODE_WRITE)
2362 return drain_out(as, 0/*file->f_flags & O_NONBLOCK*/);
2363 return 0;
2364
2365 case SNDCTL_DSP_SETDUPLEX:
2366 return 0;
2367
2368 case SNDCTL_DSP_GETCAPS:
2369 return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER |
2370 DSP_CAP_MMAP | DSP_CAP_BATCH, user_arg);
2371
2372 case SNDCTL_DSP_RESET:
2373 if (file->f_mode & FMODE_WRITE) {
2374 usbout_stop(as);
2375 as->usbout.dma.rdptr = as->usbout.dma.wrptr = as->usbout.dma.count = as->usbout.dma.total_bytes = 0;
2376 }
2377 if (file->f_mode & FMODE_READ) {
2378 usbin_stop(as);
2379 as->usbin.dma.rdptr = as->usbin.dma.wrptr = as->usbin.dma.count = as->usbin.dma.total_bytes = 0;
2380 }
2381 return 0;
2382
2383 case SNDCTL_DSP_SPEED:
2384 if (get_user(val, user_arg))
2385 return -EFAULT;
2386 if (val >= 0) {
2387 if (val < 4000)
2388 val = 4000;
2389 if (val > 100000)
2390 val = 100000;
2391 if (set_format(as, file->f_mode, AFMT_QUERY, val))
2392 return -EIO;
2393 }
2394 return put_user((file->f_mode & FMODE_READ) ?
2395 as->usbin.dma.srate : as->usbout.dma.srate,
2396 user_arg);
2397
2398 case SNDCTL_DSP_STEREO:
2399 if (get_user(val, user_arg))
2400 return -EFAULT;
2401 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2402 if (val)
2403 val2 |= AFMT_STEREO;
2404 else
2405 val2 &= ~AFMT_STEREO;
2406 if (set_format(as, file->f_mode, val2, 0))
2407 return -EIO;
2408 return 0;
2409
2410 case SNDCTL_DSP_CHANNELS:
2411 if (get_user(val, user_arg))
2412 return -EFAULT;
2413 if (val != 0) {
2414 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2415 if (val == 1)
2416 val2 &= ~AFMT_STEREO;
2417 else
2418 val2 |= AFMT_STEREO;
2419 if (set_format(as, file->f_mode, val2, 0))
2420 return -EIO;
2421 }
2422 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2423 return put_user(AFMT_ISSTEREO(val2) ? 2 : 1, user_arg);
2424
2425 case SNDCTL_DSP_GETFMTS: /* Returns a mask */
2426 return put_user(AFMT_U8 | AFMT_U16_LE | AFMT_U16_BE |
2427 AFMT_S8 | AFMT_S16_LE | AFMT_S16_BE, user_arg);
2428
2429 case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
2430 if (get_user(val, user_arg))
2431 return -EFAULT;
2432 if (val != AFMT_QUERY) {
2433 if (hweight32(val) != 1)
2434 return -EINVAL;
2435 if (!(val & (AFMT_U8 | AFMT_U16_LE | AFMT_U16_BE |
2436 AFMT_S8 | AFMT_S16_LE | AFMT_S16_BE)))
2437 return -EINVAL;
2438 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2439 val |= val2 & AFMT_STEREO;
2440 if (set_format(as, file->f_mode, val, 0))
2441 return -EIO;
2442 }
2443 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2444 return put_user(val2 & ~AFMT_STEREO, user_arg);
2445
2446 case SNDCTL_DSP_POST:
2447 return 0;
2448
2449 case SNDCTL_DSP_GETTRIGGER:
2450 val = 0;
2451 if (file->f_mode & FMODE_READ && as->usbin.flags & FLG_RUNNING)
2452 val |= PCM_ENABLE_INPUT;
2453 if (file->f_mode & FMODE_WRITE && as->usbout.flags & FLG_RUNNING)
2454 val |= PCM_ENABLE_OUTPUT;
2455 return put_user(val, user_arg);
2456
2457 case SNDCTL_DSP_SETTRIGGER:
2458 if (get_user(val, user_arg))
2459 return -EFAULT;
2460 if (file->f_mode & FMODE_READ) {
2461 if (val & PCM_ENABLE_INPUT) {
2462 if (!as->usbin.dma.ready && (ret = prog_dmabuf_in(as)))
2463 return ret;
2464 if (usbin_start(as))
2465 return -ENODEV;
2466 } else
2467 usbin_stop(as);
2468 }
2469 if (file->f_mode & FMODE_WRITE) {
2470 if (val & PCM_ENABLE_OUTPUT) {
2471 if (!as->usbout.dma.ready && (ret = prog_dmabuf_out(as)))
2472 return ret;
2473 if (usbout_start(as))
2474 return -ENODEV;
2475 } else
2476 usbout_stop(as);
2477 }
2478 return 0;
2479
2480 case SNDCTL_DSP_GETOSPACE:
2481 if (!(file->f_mode & FMODE_WRITE))
2482 return -EINVAL;
2483 if (!(as->usbout.flags & FLG_RUNNING) && (val = prog_dmabuf_out(as)) != 0)
2484 return val;
2485 spin_lock_irqsave(&as->lock, flags);
2486 abinfo.fragsize = as->usbout.dma.fragsize;
2487 abinfo.bytes = as->usbout.dma.dmasize - as->usbout.dma.count;
2488 abinfo.fragstotal = as->usbout.dma.numfrag;
2489 abinfo.fragments = abinfo.bytes >> as->usbout.dma.fragshift;
2490 spin_unlock_irqrestore(&as->lock, flags);
2491 return copy_to_user((void __user *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2492
2493 case SNDCTL_DSP_GETISPACE:
2494 if (!(file->f_mode & FMODE_READ))
2495 return -EINVAL;
2496 if (!(as->usbin.flags & FLG_RUNNING) && (val = prog_dmabuf_in(as)) != 0)
2497 return val;
2498 spin_lock_irqsave(&as->lock, flags);
2499 abinfo.fragsize = as->usbin.dma.fragsize;
2500 abinfo.bytes = as->usbin.dma.count;
2501 abinfo.fragstotal = as->usbin.dma.numfrag;
2502 abinfo.fragments = abinfo.bytes >> as->usbin.dma.fragshift;
2503 spin_unlock_irqrestore(&as->lock, flags);
2504 return copy_to_user((void __user *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2505
2506 case SNDCTL_DSP_NONBLOCK:
2507 file->f_flags |= O_NONBLOCK;
2508 return 0;
2509
2510 case SNDCTL_DSP_GETODELAY:
2511 if (!(file->f_mode & FMODE_WRITE))
2512 return -EINVAL;
2513 spin_lock_irqsave(&as->lock, flags);
2514 val = as->usbout.dma.count;
2515 spin_unlock_irqrestore(&as->lock, flags);
2516 return put_user(val, user_arg);
2517
2518 case SNDCTL_DSP_GETIPTR:
2519 if (!(file->f_mode & FMODE_READ))
2520 return -EINVAL;
2521 spin_lock_irqsave(&as->lock, flags);
2522 cinfo.bytes = as->usbin.dma.total_bytes;
2523 cinfo.blocks = as->usbin.dma.count >> as->usbin.dma.fragshift;
2524 cinfo.ptr = as->usbin.dma.wrptr;
2525 if (as->usbin.dma.mapped)
2526 as->usbin.dma.count &= as->usbin.dma.fragsize-1;
2527 spin_unlock_irqrestore(&as->lock, flags);
2528 if (copy_to_user((void __user *)arg, &cinfo, sizeof(cinfo)))
2529 return -EFAULT;
2530 return 0;
2531
2532 case SNDCTL_DSP_GETOPTR:
2533 if (!(file->f_mode & FMODE_WRITE))
2534 return -EINVAL;
2535 spin_lock_irqsave(&as->lock, flags);
2536 cinfo.bytes = as->usbout.dma.total_bytes;
2537 cinfo.blocks = as->usbout.dma.count >> as->usbout.dma.fragshift;
2538 cinfo.ptr = as->usbout.dma.rdptr;
2539 if (as->usbout.dma.mapped)
2540 as->usbout.dma.count &= as->usbout.dma.fragsize-1;
2541 spin_unlock_irqrestore(&as->lock, flags);
2542 if (copy_to_user((void __user *)arg, &cinfo, sizeof(cinfo)))
2543 return -EFAULT;
2544 return 0;
2545
2546 case SNDCTL_DSP_GETBLKSIZE:
2547 if (file->f_mode & FMODE_WRITE) {
2548 if ((val = prog_dmabuf_out(as)))
2549 return val;
2550 return put_user(as->usbout.dma.fragsize, user_arg);
2551 }
2552 if ((val = prog_dmabuf_in(as)))
2553 return val;
2554 return put_user(as->usbin.dma.fragsize, user_arg);
2555
2556 case SNDCTL_DSP_SETFRAGMENT:
2557 if (get_user(val, user_arg))
2558 return -EFAULT;
2559 if (file->f_mode & FMODE_READ) {
2560 as->usbin.dma.ossfragshift = val & 0xffff;
2561 as->usbin.dma.ossmaxfrags = (val >> 16) & 0xffff;
2562 if (as->usbin.dma.ossfragshift < 4)
2563 as->usbin.dma.ossfragshift = 4;
2564 if (as->usbin.dma.ossfragshift > 15)
2565 as->usbin.dma.ossfragshift = 15;
2566 if (as->usbin.dma.ossmaxfrags < 4)
2567 as->usbin.dma.ossmaxfrags = 4;
2568 }
2569 if (file->f_mode & FMODE_WRITE) {
2570 as->usbout.dma.ossfragshift = val & 0xffff;
2571 as->usbout.dma.ossmaxfrags = (val >> 16) & 0xffff;
2572 if (as->usbout.dma.ossfragshift < 4)
2573 as->usbout.dma.ossfragshift = 4;
2574 if (as->usbout.dma.ossfragshift > 15)
2575 as->usbout.dma.ossfragshift = 15;
2576 if (as->usbout.dma.ossmaxfrags < 4)
2577 as->usbout.dma.ossmaxfrags = 4;
2578 }
2579 return 0;
2580
2581 case SNDCTL_DSP_SUBDIVIDE:
2582 if ((file->f_mode & FMODE_READ && as->usbin.dma.subdivision) ||
2583 (file->f_mode & FMODE_WRITE && as->usbout.dma.subdivision))
2584 return -EINVAL;
2585 if (get_user(val, user_arg))
2586 return -EFAULT;
2587 if (val != 1 && val != 2 && val != 4)
2588 return -EINVAL;
2589 if (file->f_mode & FMODE_READ)
2590 as->usbin.dma.subdivision = val;
2591 if (file->f_mode & FMODE_WRITE)
2592 as->usbout.dma.subdivision = val;
2593 return 0;
2594
2595 case SOUND_PCM_READ_RATE:
2596 return put_user((file->f_mode & FMODE_READ) ?
2597 as->usbin.dma.srate : as->usbout.dma.srate,
2598 user_arg);
2599
2600 case SOUND_PCM_READ_CHANNELS:
2601 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2602 return put_user(AFMT_ISSTEREO(val2) ? 2 : 1, user_arg);
2603
2604 case SOUND_PCM_READ_BITS:
2605 val2 = (file->f_mode & FMODE_READ) ? as->usbin.dma.format : as->usbout.dma.format;
2606 return put_user(AFMT_IS16BIT(val2) ? 16 : 8, user_arg);
2607
2608 case SOUND_PCM_WRITE_FILTER:
2609 case SNDCTL_DSP_SETSYNCRO:
2610 case SOUND_PCM_READ_FILTER:
2611 return -EINVAL;
2612 }
2613 dprintk((KERN_DEBUG "usbaudio: usb_audio_ioctl - no command found\n"));
2614 return -ENOIOCTLCMD;
2615 }
2616
2617 static int usb_audio_open(struct inode *inode, struct file *file)
2618 {
2619 unsigned int minor = iminor(inode);
2620 DECLARE_WAITQUEUE(wait, current);
2621 struct usb_audiodev *as;
2622 struct usb_audio_state *s;
2623
2624 for (;;) {
2625 down(&open_sem);
2626 list_for_each_entry(s, &audiodevs, audiodev) {
2627 list_for_each_entry(as, &s->audiolist, list) {
2628 if (!((as->dev_audio ^ minor) & ~0xf))
2629 goto device_found;
2630 }
2631 }
2632 up(&open_sem);
2633 return -ENODEV;
2634
2635 device_found:
2636 if (!s->usbdev) {
2637 up(&open_sem);
2638 return -EIO;
2639 }
2640 /* wait for device to become free */
2641 if (!(as->open_mode & file->f_mode))
2642 break;
2643 if (file->f_flags & O_NONBLOCK) {
2644 up(&open_sem);
2645 return -EBUSY;
2646 }
2647 __set_current_state(TASK_INTERRUPTIBLE);
2648 add_wait_queue(&open_wait, &wait);
2649 up(&open_sem);
2650 schedule();
2651 __set_current_state(TASK_RUNNING);
2652 remove_wait_queue(&open_wait, &wait);
2653 if (signal_pending(current))
2654 return -ERESTARTSYS;
2655 }
2656 if (file->f_mode & FMODE_READ)
2657 as->usbin.dma.ossfragshift = as->usbin.dma.ossmaxfrags = as->usbin.dma.subdivision = 0;
2658 if (file->f_mode & FMODE_WRITE)
2659 as->usbout.dma.ossfragshift = as->usbout.dma.ossmaxfrags = as->usbout.dma.subdivision = 0;
2660 if (set_format(as, file->f_mode, ((minor & 0xf) == SND_DEV_DSP16) ? AFMT_S16_LE : AFMT_U8 /* AFMT_ULAW */, 8000)) {
2661 up(&open_sem);
2662 return -EIO;
2663 }
2664 file->private_data = as;
2665 as->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
2666 s->count++;
2667 up(&open_sem);
2668 return nonseekable_open(inode, file);
2669 }
2670
2671 static int usb_audio_release(struct inode *inode, struct file *file)
2672 {
2673 struct usb_audiodev *as = (struct usb_audiodev *)file->private_data;
2674 struct usb_audio_state *s;
2675 struct usb_device *dev;
2676
2677 lock_kernel();
2678 s = as->state;
2679 dev = s->usbdev;
2680 if (file->f_mode & FMODE_WRITE)
2681 drain_out(as, file->f_flags & O_NONBLOCK);
2682 down(&open_sem);
2683 if (file->f_mode & FMODE_WRITE) {
2684 usbout_stop(as);
2685 if (dev && as->usbout.interface >= 0)
2686 usb_set_interface(dev, as->usbout.interface, 0);
2687 dmabuf_release(&as->usbout.dma);
2688 usbout_release(as);
2689 }
2690 if (file->f_mode & FMODE_READ) {
2691 usbin_stop(as);
2692 if (dev && as->usbin.interface >= 0)
2693 usb_set_interface(dev, as->usbin.interface, 0);
2694 dmabuf_release(&as->usbin.dma);
2695 usbin_release(as);
2696 }
2697 as->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
2698 release(s);
2699 wake_up(&open_wait);
2700 unlock_kernel();
2701 return 0;
2702 }
2703
2704 static /*const*/ struct file_operations usb_audio_fops = {
2705 .owner = THIS_MODULE,
2706 .llseek = no_llseek,
2707 .read = usb_audio_read,
2708 .write = usb_audio_write,
2709 .poll = usb_audio_poll,
2710 .ioctl = usb_audio_ioctl,
2711 .mmap = usb_audio_mmap,
2712 .open = usb_audio_open,
2713 .release = usb_audio_release,
2714 };
2715
2716 /* --------------------------------------------------------------------- */
2717
2718 static int usb_audio_probe(struct usb_interface *iface,
2719 const struct usb_device_id *id);
2720 static void usb_audio_disconnect(struct usb_interface *iface);
2721
2722 static struct usb_device_id usb_audio_ids [] = {
2723 { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
2724 .bInterfaceClass = USB_CLASS_AUDIO, .bInterfaceSubClass = 1},
2725 { } /* Terminating entry */
2726 };
2727
2728 MODULE_DEVICE_TABLE (usb, usb_audio_ids);
2729
2730 static struct usb_driver usb_audio_driver = {
2731 .owner = THIS_MODULE,
2732 .name = "audio",
2733 .probe = usb_audio_probe,
2734 .disconnect = usb_audio_disconnect,
2735 .id_table = usb_audio_ids,
2736 };
2737
2738 static void *find_descriptor(void *descstart, unsigned int desclen, void *after,
2739 u8 dtype, int iface, int altsetting)
2740 {
2741 u8 *p, *end, *next;
2742 int ifc = -1, as = -1;
2743
2744 p = descstart;
2745 end = p + desclen;
2746 for (; p < end;) {
2747 if (p[0] < 2)
2748 return NULL;
2749 next = p + p[0];
2750 if (next > end)
2751 return NULL;
2752 if (p[1] == USB_DT_INTERFACE) {
2753 /* minimum length of interface descriptor */
2754 if (p[0] < 9)
2755 return NULL;
2756 ifc = p[2];
2757 as = p[3];
2758 }
2759 if (p[1] == dtype && (!after || (void *)p > after) &&
2760 (iface == -1 || iface == ifc) && (altsetting == -1 || altsetting == as)) {
2761 return p;
2762 }
2763 p = next;
2764 }
2765 return NULL;
2766 }
2767
2768 static void *find_csinterface_descriptor(void *descstart, unsigned int desclen, void *after, u8 dsubtype, int iface, int altsetting)
2769 {
2770 unsigned char *p;
2771
2772 p = find_descriptor(descstart, desclen, after, USB_DT_CS_INTERFACE, iface, altsetting);
2773 while (p) {
2774 if (p[0] >= 3 && p[2] == dsubtype)
2775 return p;
2776 p = find_descriptor(descstart, desclen, p, USB_DT_CS_INTERFACE, iface, altsetting);
2777 }
2778 return NULL;
2779 }
2780
2781 static void *find_audiocontrol_unit(void *descstart, unsigned int desclen, void *after, u8 unit, int iface)
2782 {
2783 unsigned char *p;
2784
2785 p = find_descriptor(descstart, desclen, after, USB_DT_CS_INTERFACE, iface, -1);
2786 while (p) {
2787 if (p[0] >= 4 && p[2] >= INPUT_TERMINAL && p[2] <= EXTENSION_UNIT && p[3] == unit)
2788 return p;
2789 p = find_descriptor(descstart, desclen, p, USB_DT_CS_INTERFACE, iface, -1);
2790 }
2791 return NULL;
2792 }
2793
2794 static void usb_audio_parsestreaming(struct usb_audio_state *s, unsigned char *buffer, unsigned int buflen, int asifin, int asifout)
2795 {
2796 struct usb_device *dev = s->usbdev;
2797 struct usb_audiodev *as;
2798 struct usb_host_interface *alts;
2799 struct usb_interface *iface;
2800 struct audioformat *fp;
2801 unsigned char *fmt, *csep;
2802 unsigned int i, j, k, format, idx;
2803
2804 if (!(as = kmalloc(sizeof(struct usb_audiodev), GFP_KERNEL)))
2805 return;
2806 memset(as, 0, sizeof(struct usb_audiodev));
2807 init_waitqueue_head(&as->usbin.dma.wait);
2808 init_waitqueue_head(&as->usbout.dma.wait);
2809 spin_lock_init(&as->lock);
2810 as->usbin.durb[0].urb = usb_alloc_urb (DESCFRAMES, GFP_KERNEL);
2811 as->usbin.durb[1].urb = usb_alloc_urb (DESCFRAMES, GFP_KERNEL);
2812 as->usbin.surb[0].urb = usb_alloc_urb (SYNCFRAMES, GFP_KERNEL);
2813 as->usbin.surb[1].urb = usb_alloc_urb (SYNCFRAMES, GFP_KERNEL);
2814 as->usbout.durb[0].urb = usb_alloc_urb (DESCFRAMES, GFP_KERNEL);
2815 as->usbout.durb[1].urb = usb_alloc_urb (DESCFRAMES, GFP_KERNEL);
2816 as->usbout.surb[0].urb = usb_alloc_urb (SYNCFRAMES, GFP_KERNEL);
2817 as->usbout.surb[1].urb = usb_alloc_urb (SYNCFRAMES, GFP_KERNEL);
2818 if ((!as->usbin.durb[0].urb) ||
2819 (!as->usbin.durb[1].urb) ||
2820 (!as->usbin.surb[0].urb) ||
2821 (!as->usbin.surb[1].urb) ||
2822 (!as->usbout.durb[0].urb) ||
2823 (!as->usbout.durb[1].urb) ||
2824 (!as->usbout.surb[0].urb) ||
2825 (!as->usbout.surb[1].urb)) {
2826 usb_free_urb(as->usbin.durb[0].urb);
2827 usb_free_urb(as->usbin.durb[1].urb);
2828 usb_free_urb(as->usbin.surb[0].urb);
2829 usb_free_urb(as->usbin.surb[1].urb);
2830 usb_free_urb(as->usbout.durb[0].urb);
2831 usb_free_urb(as->usbout.durb[1].urb);
2832 usb_free_urb(as->usbout.surb[0].urb);
2833 usb_free_urb(as->usbout.surb[1].urb);
2834 kfree(as);
2835 return;
2836 }
2837 as->state = s;
2838 as->usbin.interface = asifin;
2839 as->usbout.interface = asifout;
2840 /* search for input formats */
2841 if (asifin >= 0) {
2842 as->usbin.flags = FLG_CONNECTED;
2843 iface = usb_ifnum_to_if(dev, asifin);
2844 for (idx = 0; idx < iface->num_altsetting; idx++) {
2845 alts = &iface->altsetting[idx];
2846 i = alts->desc.bAlternateSetting;
2847 if (alts->desc.bInterfaceClass != USB_CLASS_AUDIO || alts->desc.bInterfaceSubClass != 2)
2848 continue;
2849 if (alts->desc.bNumEndpoints < 1) {
2850 if (i != 0) { /* altsetting 0 has no endpoints (Section B.3.4.1) */
2851 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u does not have an endpoint\n",
2852 dev->devnum, asifin, i);
2853 }
2854 continue;
2855 }
2856 if ((alts->endpoint[0].desc.bmAttributes & 0x03) != 0x01 ||
2857 !(alts->endpoint[0].desc.bEndpointAddress & 0x80)) {
2858 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u first endpoint not isochronous in\n",
2859 dev->devnum, asifin, i);
2860 continue;
2861 }
2862 fmt = find_csinterface_descriptor(buffer, buflen, NULL, AS_GENERAL, asifin, i);
2863 if (!fmt) {
2864 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
2865 dev->devnum, asifin, i);
2866 continue;
2867 }
2868 if (fmt[0] < 7 || fmt[6] != 0 || (fmt[5] != 1 && fmt[5] != 2)) {
2869 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u format not supported\n",
2870 dev->devnum, asifin, i);
2871 continue;
2872 }
2873 format = (fmt[5] == 2) ? (AFMT_U16_LE | AFMT_U8) : (AFMT_S16_LE | AFMT_S8);
2874 fmt = find_csinterface_descriptor(buffer, buflen, NULL, FORMAT_TYPE, asifin, i);
2875 if (!fmt) {
2876 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
2877 dev->devnum, asifin, i);
2878 continue;
2879 }
2880 if (fmt[0] < 8+3*(fmt[7] ? fmt[7] : 2) || fmt[3] != 1) {
2881 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not supported\n",
2882 dev->devnum, asifin, i);
2883 continue;
2884 }
2885 if (fmt[4] < 1 || fmt[4] > 2 || fmt[5] < 1 || fmt[5] > 2) {
2886 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u unsupported channels %u framesize %u\n",
2887 dev->devnum, asifin, i, fmt[4], fmt[5]);
2888 continue;
2889 }
2890 csep = find_descriptor(buffer, buflen, NULL, USB_DT_CS_ENDPOINT, asifin, i);
2891 if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
2892 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u no or invalid class specific endpoint descriptor\n",
2893 dev->devnum, asifin, i);
2894 continue;
2895 }
2896 if (as->numfmtin >= MAXFORMATS)
2897 continue;
2898 fp = &as->fmtin[as->numfmtin++];
2899 if (fmt[5] == 2)
2900 format &= (AFMT_U16_LE | AFMT_S16_LE);
2901 else
2902 format &= (AFMT_U8 | AFMT_S8);
2903 if (fmt[4] == 2)
2904 format |= AFMT_STEREO;
2905 fp->format = format;
2906 fp->altsetting = i;
2907 fp->sratelo = fp->sratehi = fmt[8] | (fmt[9] << 8) | (fmt[10] << 16);
2908 printk(KERN_INFO "usbaudio: valid input sample rate %u\n", fp->sratelo);
2909 for (j = fmt[7] ? (fmt[7]-1) : 1; j > 0; j--) {
2910 k = fmt[8+3*j] | (fmt[9+3*j] << 8) | (fmt[10+3*j] << 16);
2911 printk(KERN_INFO "usbaudio: valid input sample rate %u\n", k);
2912 if (k > fp->sratehi)
2913 fp->sratehi = k;
2914 if (k < fp->sratelo)
2915 fp->sratelo = k;
2916 }
2917 fp->attributes = csep[3];
2918 printk(KERN_INFO "usbaudio: device %u interface %u altsetting %u: format 0x%08x sratelo %u sratehi %u attributes 0x%02x\n",
2919 dev->devnum, asifin, i, fp->format, fp->sratelo, fp->sratehi, fp->attributes);
2920 }
2921 }
2922 /* search for output formats */
2923 if (asifout >= 0) {
2924 as->usbout.flags = FLG_CONNECTED;
2925 iface = usb_ifnum_to_if(dev, asifout);
2926 for (idx = 0; idx < iface->num_altsetting; idx++) {
2927 alts = &iface->altsetting[idx];
2928 i = alts->desc.bAlternateSetting;
2929 if (alts->desc.bInterfaceClass != USB_CLASS_AUDIO || alts->desc.bInterfaceSubClass != 2)
2930 continue;
2931 if (alts->desc.bNumEndpoints < 1) {
2932 /* altsetting 0 should never have iso EPs */
2933 if (i != 0)
2934 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u does not have an endpoint\n",
2935 dev->devnum, asifout, i);
2936 continue;
2937 }
2938 if ((alts->endpoint[0].desc.bmAttributes & 0x03) != 0x01 ||
2939 (alts->endpoint[0].desc.bEndpointAddress & 0x80)) {
2940 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u first endpoint not isochronous out\n",
2941 dev->devnum, asifout, i);
2942 continue;
2943 }
2944 /* See USB audio formats manual, section 2 */
2945 fmt = find_csinterface_descriptor(buffer, buflen, NULL, AS_GENERAL, asifout, i);
2946 if (!fmt) {
2947 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
2948 dev->devnum, asifout, i);
2949 continue;
2950 }
2951 if (fmt[0] < 7 || fmt[6] != 0 || (fmt[5] != 1 && fmt[5] != 2)) {
2952 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u format not supported\n",
2953 dev->devnum, asifout, i);
2954 continue;
2955 }
2956 format = (fmt[5] == 2) ? (AFMT_U16_LE | AFMT_U8) : (AFMT_S16_LE | AFMT_S8);
2957 /* Dallas DS4201 workaround */
2958 if (le16_to_cpu(dev->descriptor.idVendor) == 0x04fa &&
2959 le16_to_cpu(dev->descriptor.idProduct) == 0x4201)
2960 format = (AFMT_S16_LE | AFMT_S8);
2961 fmt = find_csinterface_descriptor(buffer, buflen, NULL, FORMAT_TYPE, asifout, i);
2962 if (!fmt) {
2963 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not found\n",
2964 dev->devnum, asifout, i);
2965 continue;
2966 }
2967 if (fmt[0] < 8+3*(fmt[7] ? fmt[7] : 2) || fmt[3] != 1) {
2968 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u FORMAT_TYPE descriptor not supported\n",
2969 dev->devnum, asifout, i);
2970 continue;
2971 }
2972 if (fmt[4] < 1 || fmt[4] > 2 || fmt[5] < 1 || fmt[5] > 2) {
2973 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u unsupported channels %u framesize %u\n",
2974 dev->devnum, asifout, i, fmt[4], fmt[5]);
2975 continue;
2976 }
2977 csep = find_descriptor(buffer, buflen, NULL, USB_DT_CS_ENDPOINT, asifout, i);
2978 if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
2979 printk(KERN_ERR "usbaudio: device %u interface %u altsetting %u no or invalid class specific endpoint descriptor\n",
2980 dev->devnum, asifout, i);
2981 continue;
2982 }
2983 if (as->numfmtout >= MAXFORMATS)
2984 continue;
2985 fp = &as->fmtout[as->numfmtout++];
2986 if (fmt[5] == 2)
2987 format &= (AFMT_U16_LE | AFMT_S16_LE);
2988 else
2989 format &= (AFMT_U8 | AFMT_S8);
2990 if (fmt[4] == 2)
2991 format |= AFMT_STEREO;
2992 fp->format = format;
2993 fp->altsetting = i;
2994 fp->sratelo = fp->sratehi = fmt[8] | (fmt[9] << 8) | (fmt[10] << 16);
2995 printk(KERN_INFO "usbaudio: valid output sample rate %u\n", fp->sratelo);
2996 for (j = fmt[7] ? (fmt[7]-1) : 1; j > 0; j--) {
2997 k = fmt[8+3*j] | (fmt[9+3*j] << 8) | (fmt[10+3*j] << 16);
2998 printk(KERN_INFO "usbaudio: valid output sample rate %u\n", k);
2999 if (k > fp->sratehi)
3000 fp->sratehi = k;
3001 if (k < fp->sratelo)
3002 fp->sratelo = k;
3003 }
3004 fp->attributes = csep[3];
3005 printk(KERN_INFO "usbaudio: device %u interface %u altsetting %u: format 0x%08x sratelo %u sratehi %u attributes 0x%02x\n",
3006 dev->devnum, asifout, i, fp->format, fp->sratelo, fp->sratehi, fp->attributes);
3007 }
3008 }
3009 if (as->numfmtin == 0 && as->numfmtout == 0) {
3010 usb_free_urb(as->usbin.durb[0].urb);
3011 usb_free_urb(as->usbin.durb[1].urb);
3012 usb_free_urb(as->usbin.surb[0].urb);
3013 usb_free_urb(as->usbin.surb[1].urb);
3014 usb_free_urb(as->usbout.durb[0].urb);
3015 usb_free_urb(as->usbout.durb[1].urb);
3016 usb_free_urb(as->usbout.surb[0].urb);
3017 usb_free_urb(as->usbout.surb[1].urb);
3018 kfree(as);
3019 return;
3020 }
3021 if ((as->dev_audio = register_sound_dsp(&usb_audio_fops, -1)) < 0) {
3022 printk(KERN_ERR "usbaudio: cannot register dsp\n");
3023 usb_free_urb(as->usbin.durb[0].urb);
3024 usb_free_urb(as->usbin.durb[1].urb);
3025 usb_free_urb(as->usbin.surb[0].urb);
3026 usb_free_urb(as->usbin.surb[1].urb);
3027 usb_free_urb(as->usbout.durb[0].urb);
3028 usb_free_urb(as->usbout.durb[1].urb);
3029 usb_free_urb(as->usbout.surb[0].urb);
3030 usb_free_urb(as->usbout.surb[1].urb);
3031 kfree(as);
3032 return;
3033 }
3034 printk(KERN_INFO "usbaudio: registered dsp 14,%d\n", as->dev_audio);
3035 /* everything successful */
3036 list_add_tail(&as->list, &s->audiolist);
3037 }
3038
3039 struct consmixstate {
3040 struct usb_audio_state *s;
3041 unsigned char *buffer;
3042 unsigned int buflen;
3043 unsigned int ctrlif;
3044 struct mixerchannel mixch[SOUND_MIXER_NRDEVICES];
3045 unsigned int nrmixch;
3046 unsigned int mixchmask;
3047 unsigned long unitbitmap[32/sizeof(unsigned long)];
3048 /* return values */
3049 unsigned int nrchannels;
3050 unsigned int termtype;
3051 unsigned int chconfig;
3052 };
3053
3054 static struct mixerchannel *getmixchannel(struct consmixstate *state, unsigned int nr)
3055 {
3056 struct mixerchannel *c;
3057
3058 if (nr >= SOUND_MIXER_NRDEVICES) {
3059 printk(KERN_ERR "usbaudio: invalid OSS mixer channel %u\n", nr);
3060 return NULL;
3061 }
3062 if (!(state->mixchmask & (1 << nr))) {
3063 printk(KERN_WARNING "usbaudio: OSS mixer channel %u already in use\n", nr);
3064 return NULL;
3065 }
3066 c = &state->mixch[state->nrmixch++];
3067 c->osschannel = nr;
3068 state->mixchmask &= ~(1 << nr);
3069 return c;
3070 }
3071
3072 static unsigned int getvolchannel(struct consmixstate *state)
3073 {
3074 unsigned int u;
3075
3076 if ((state->termtype & 0xff00) == 0x0000 && (state->mixchmask & SOUND_MASK_VOLUME))
3077 return SOUND_MIXER_VOLUME;
3078 if ((state->termtype & 0xff00) == 0x0100) {
3079 if (state->mixchmask & SOUND_MASK_PCM)
3080 return SOUND_MIXER_PCM;
3081 if (state->mixchmask & SOUND_MASK_ALTPCM)
3082 return SOUND_MIXER_ALTPCM;
3083 }
3084 if ((state->termtype & 0xff00) == 0x0200 && (state->mixchmask & SOUND_MASK_MIC))
3085 return SOUND_MIXER_MIC;
3086 if ((state->termtype & 0xff00) == 0x0300 && (state->mixchmask & SOUND_MASK_SPEAKER))
3087 return SOUND_MIXER_SPEAKER;
3088 if ((state->termtype & 0xff00) == 0x0500) {
3089 if (state->mixchmask & SOUND_MASK_PHONEIN)
3090 return SOUND_MIXER_PHONEIN;
3091 if (state->mixchmask & SOUND_MASK_PHONEOUT)
3092 return SOUND_MIXER_PHONEOUT;
3093 }
3094 if (state->termtype >= 0x710 && state->termtype <= 0x711 && (state->mixchmask & SOUND_MASK_RADIO))
3095 return SOUND_MIXER_RADIO;
3096 if (state->termtype >= 0x709 && state->termtype <= 0x70f && (state->mixchmask & SOUND_MASK_VIDEO))
3097 return SOUND_MIXER_VIDEO;
3098 u = ffs(state->mixchmask & (SOUND_MASK_LINE | SOUND_MASK_CD | SOUND_MASK_LINE1 | SOUND_MASK_LINE2 | SOUND_MASK_LINE3 |
3099 SOUND_MASK_DIGITAL1 | SOUND_MASK_DIGITAL2 | SOUND_MASK_DIGITAL3));
3100 return u-1;
3101 }
3102
3103 static void prepmixch(struct consmixstate *state)
3104 {
3105 struct usb_device *dev = state->s->usbdev;
3106 struct mixerchannel *ch;
3107 unsigned char *buf;
3108 __s16 v1;
3109 unsigned int v2, v3;
3110
3111 if (!state->nrmixch || state->nrmixch > SOUND_MIXER_NRDEVICES)
3112 return;
3113 buf = kmalloc(sizeof(*buf) * 2, GFP_KERNEL);
3114 if (!buf) {
3115 printk(KERN_ERR "prepmixch: out of memory\n") ;
3116 return;
3117 }
3118
3119 ch = &state->mixch[state->nrmixch-1];
3120 switch (ch->selector) {
3121 case 0: /* mixer unit request */
3122 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MIN, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3123 (ch->chnum << 8) | 1, state->ctrlif | (ch->unitid << 8), buf, 2, 1000) < 0)
3124 goto err;
3125 ch->minval = buf[0] | (buf[1] << 8);
3126 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MAX, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3127 (ch->chnum << 8) | 1, state->ctrlif | (ch->unitid << 8), buf, 2, 1000) < 0)
3128 goto err;
3129 ch->maxval = buf[0] | (buf[1] << 8);
3130 v2 = ch->maxval - ch->minval;
3131 if (!v2)
3132 v2 = 1;
3133 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3134 (ch->chnum << 8) | 1, state->ctrlif | (ch->unitid << 8), buf, 2, 1000) < 0)
3135 goto err;
3136 v1 = buf[0] | (buf[1] << 8);
3137 v3 = v1 - ch->minval;
3138 v3 = 100 * v3 / v2;
3139 if (v3 > 100)
3140 v3 = 100;
3141 ch->value = v3;
3142 if (ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)) {
3143 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3144 ((ch->chnum + !!(ch->flags & MIXFLG_STEREOIN)) << 8) | (1 + !!(ch->flags & MIXFLG_STEREOOUT)),
3145 state->ctrlif | (ch->unitid << 8), buf, 2, 1000) < 0)
3146 goto err;
3147 v1 = buf[0] | (buf[1] << 8);
3148 v3 = v1 - ch->minval;
3149 v3 = 100 * v3 / v2;
3150 if (v3 > 100)
3151 v3 = 100;
3152 }
3153 ch->value |= v3 << 8;
3154 break;
3155
3156 /* various feature unit controls */
3157 case VOLUME_CONTROL:
3158 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MIN, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3159 (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 2, 1000) < 0)
3160 goto err;
3161 ch->minval = buf[0] | (buf[1] << 8);
3162 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MAX, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3163 (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 2, 1000) < 0)
3164 goto err;
3165 ch->maxval = buf[0] | (buf[1] << 8);
3166 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3167 (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 2, 1000) < 0)
3168 goto err;
3169 v1 = buf[0] | (buf[1] << 8);
3170 v2 = ch->maxval - ch->minval;
3171 v3 = v1 - ch->minval;
3172 if (!v2)
3173 v2 = 1;
3174 v3 = 100 * v3 / v2;
3175 if (v3 > 100)
3176 v3 = 100;
3177 ch->value = v3;
3178 if (ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)) {
3179 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3180 (ch->selector << 8) | (ch->chnum + 1), state->ctrlif | (ch->unitid << 8), buf, 2, 1000) < 0)
3181 goto err;
3182 v1 = buf[0] | (buf[1] << 8);
3183 v3 = v1 - ch->minval;
3184 v3 = 100 * v3 / v2;
3185 if (v3 > 100)
3186 v3 = 100;
3187 }
3188 ch->value |= v3 << 8;
3189 break;
3190
3191 case BASS_CONTROL:
3192 case MID_CONTROL:
3193 case TREBLE_CONTROL:
3194 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MIN, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3195 (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 1, 1000) < 0)
3196 goto err;
3197 ch->minval = buf[0] << 8;
3198 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_MAX, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3199 (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 1, 1000) < 0)
3200 goto err;
3201 ch->maxval = buf[0] << 8;
3202 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3203 (ch->selector << 8) | ch->chnum, state->ctrlif | (ch->unitid << 8), buf, 1, 1000) < 0)
3204 goto err;
3205 v1 = buf[0] << 8;
3206 v2 = ch->maxval - ch->minval;
3207 v3 = v1 - ch->minval;
3208 if (!v2)
3209 v2 = 1;
3210 v3 = 100 * v3 / v2;
3211 if (v3 > 100)
3212 v3 = 100;
3213 ch->value = v3;
3214 if (ch->flags & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)) {
3215 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3216 (ch->selector << 8) | (ch->chnum + 1), state->ctrlif | (ch->unitid << 8), buf, 1, 1000) < 0)
3217 goto err;
3218 v1 = buf[0] << 8;
3219 v3 = v1 - ch->minval;
3220 v3 = 100 * v3 / v2;
3221 if (v3 > 100)
3222 v3 = 100;
3223 }
3224 ch->value |= v3 << 8;
3225 break;
3226
3227 default:
3228 goto err;
3229 }
3230
3231 freebuf:
3232 kfree(buf);
3233 return;
3234 err:
3235 printk(KERN_ERR "usbaudio: mixer request device %u if %u unit %u ch %u selector %u failed\n",
3236 dev->devnum, state->ctrlif, ch->unitid, ch->chnum, ch->selector);
3237 if (state->nrmixch)
3238 state->nrmixch--;
3239 goto freebuf;
3240 }
3241
3242
3243 static void usb_audio_recurseunit(struct consmixstate *state, unsigned char unitid);
3244
3245 static inline int checkmixbmap(unsigned char *bmap, unsigned char flg, unsigned int inidx, unsigned int numoch)
3246 {
3247 unsigned int idx;
3248
3249 idx = inidx*numoch;
3250 if (!(bmap[-(idx >> 3)] & (0x80 >> (idx & 7))))
3251 return 0;
3252 if (!(flg & (MIXFLG_STEREOIN | MIXFLG_STEREOOUT)))
3253 return 1;
3254 idx = (inidx+!!(flg & MIXFLG_STEREOIN))*numoch+!!(flg & MIXFLG_STEREOOUT);
3255 if (!(bmap[-(idx >> 3)] & (0x80 >> (idx & 7))))
3256 return 0;
3257 return 1;
3258 }
3259
3260 static void usb_audio_mixerunit(struct consmixstate *state, unsigned char *mixer)
3261 {
3262 unsigned int nroutch = mixer[5+mixer[4]];
3263 unsigned int chidx[SOUND_MIXER_NRDEVICES+1];
3264 unsigned int termt[SOUND_MIXER_NRDEVICES];
3265 unsigned char flg = (nroutch >= 2) ? MIXFLG_STEREOOUT : 0;
3266 unsigned char *bmap = &mixer[9+mixer[4]];
3267 unsigned int bmapsize;
3268 struct mixerchannel *ch;
3269 unsigned int i;
3270
3271 if (!mixer[4]) {
3272 printk(KERN_ERR "usbaudio: unit %u invalid MIXER_UNIT descriptor\n", mixer[3]);
3273 return;
3274 }
3275 if (mixer[4] > SOUND_MIXER_NRDEVICES) {
3276 printk(KERN_ERR "usbaudio: mixer unit %u: too many input pins\n", mixer[3]);
3277 return;
3278 }
3279 chidx[0] = 0;
3280 for (i = 0; i < mixer[4]; i++) {
3281 usb_audio_recurseunit(state, mixer[5+i]);
3282 chidx[i+1] = chidx[i] + state->nrchannels;
3283 termt[i] = state->termtype;
3284 }
3285 state->termtype = 0;
3286 state->chconfig = mixer[6+mixer[4]] | (mixer[7+mixer[4]] << 8);
3287 bmapsize = (nroutch * chidx[mixer[4]] + 7) >> 3;
3288 bmap += bmapsize - 1;
3289 if (mixer[0] < 10+mixer[4]+bmapsize) {
3290 printk(KERN_ERR "usbaudio: unit %u invalid MIXER_UNIT descriptor (bitmap too small)\n", mixer[3]);
3291 return;
3292 }
3293 for (i = 0; i < mixer[4]; i++) {
3294 state->termtype = termt[i];
3295 if (chidx[i+1]-chidx[i] >= 2) {
3296 flg |= MIXFLG_STEREOIN;
3297 if (checkmixbmap(bmap, flg, chidx[i], nroutch)) {
3298 ch = getmixchannel(state, getvolchannel(state));
3299 if (ch) {
3300 ch->unitid = mixer[3];
3301 ch->selector = 0;
3302 ch->chnum = chidx[i]+1;
3303 ch->flags = flg;
3304 prepmixch(state);
3305 }
3306 continue;
3307 }
3308 }
3309 flg &= ~MIXFLG_STEREOIN;
3310 if (checkmixbmap(bmap, flg, chidx[i], nroutch)) {
3311 ch = getmixchannel(state, getvolchannel(state));
3312 if (ch) {
3313 ch->unitid = mixer[3];
3314 ch->selector = 0;
3315 ch->chnum = chidx[i]+1;
3316 ch->flags = flg;
3317 prepmixch(state);
3318 }
3319 }
3320 }
3321 state->termtype = 0;
3322 }
3323
3324 static struct mixerchannel *slctsrc_findunit(struct consmixstate *state, __u8 unitid)
3325 {
3326 unsigned int i;
3327
3328 for (i = 0; i < state->nrmixch; i++)
3329 if (state->mixch[i].unitid == unitid)
3330 return &state->mixch[i];
3331 return NULL;
3332 }
3333
3334 static void usb_audio_selectorunit(struct consmixstate *state, unsigned char *selector)
3335 {
3336 unsigned int chnum, i, mixch;
3337 struct mixerchannel *mch;
3338
3339 if (!selector[4]) {
3340 printk(KERN_ERR "usbaudio: unit %u invalid SELECTOR_UNIT descriptor\n", selector[3]);
3341 return;
3342 }
3343 mixch = state->nrmixch;
3344 usb_audio_recurseunit(state, selector[5]);
3345 if (state->nrmixch != mixch) {
3346 mch = &state->mixch[state->nrmixch-1];
3347 mch->slctunitid = selector[3] | (1 << 8);
3348 } else if ((mch = slctsrc_findunit(state, selector[5]))) {
3349 mch->slctunitid = selector[3] | (1 << 8);
3350 } else {
3351 printk(KERN_INFO "usbaudio: selector unit %u: ignoring channel 1\n", selector[3]);
3352 }
3353 chnum = state->nrchannels;
3354 for (i = 1; i < selector[4]; i++) {
3355 mixch = state->nrmixch;
3356 usb_audio_recurseunit(state, selector[5+i]);
3357 if (chnum != state->nrchannels) {
3358 printk(KERN_ERR "usbaudio: selector unit %u: input pins with varying channel numbers\n", selector[3]);
3359 state->termtype = 0;
3360 state->chconfig = 0;
3361 state->nrchannels = 0;
3362 return;
3363 }
3364 if (state->nrmixch != mixch) {
3365 mch = &state->mixch[state->nrmixch-1];
3366 mch->slctunitid = selector[3] | ((i + 1) << 8);
3367 } else if ((mch = slctsrc_findunit(state, selector[5+i]))) {
3368 mch->slctunitid = selector[3] | ((i + 1) << 8);
3369 } else {
3370 printk(KERN_INFO "usbaudio: selector unit %u: ignoring channel %u\n", selector[3], i+1);
3371 }
3372 }
3373 state->termtype = 0;
3374 state->chconfig = 0;
3375 }
3376
3377 /* in the future we might try to handle 3D etc. effect units */
3378
3379 static void usb_audio_processingunit(struct consmixstate *state, unsigned char *proc)
3380 {
3381 unsigned int i;
3382
3383 for (i = 0; i < proc[6]; i++)
3384 usb_audio_recurseunit(state, proc[7+i]);
3385 state->nrchannels = proc[7+proc[6]];
3386 state->termtype = 0;
3387 state->chconfig = proc[8+proc[6]] | (proc[9+proc[6]] << 8);
3388 }
3389
3390
3391 /* See Audio Class Spec, section 4.3.2.5 */
3392 static void usb_audio_featureunit(struct consmixstate *state, unsigned char *ftr)
3393 {
3394 struct mixerchannel *ch;
3395 unsigned short chftr, mchftr;
3396 #if 0
3397 struct usb_device *dev = state->s->usbdev;
3398 unsigned char data[1];
3399 #endif
3400 unsigned char nr_logical_channels, i;
3401
3402 usb_audio_recurseunit(state, ftr[4]);
3403
3404 if (ftr[5] == 0 ) {
3405 printk(KERN_ERR "usbaudio: wrong controls size in feature unit %u\n",ftr[3]);
3406 return;
3407 }
3408
3409 if (state->nrchannels == 0) {
3410 printk(KERN_ERR "usbaudio: feature unit %u source has no channels\n", ftr[3]);
3411 return;
3412 }
3413 if (state->nrchannels > 2)
3414 printk(KERN_WARNING "usbaudio: feature unit %u: OSS mixer interface does not support more than 2 channels\n", ftr[3]);
3415
3416 nr_logical_channels=(ftr[0]-7)/ftr[5]-1;
3417
3418 if (nr_logical_channels != state->nrchannels) {
3419 printk(KERN_WARNING "usbaudio: warning: found %d of %d logical channels.\n", state->nrchannels,nr_logical_channels);
3420
3421 if (state->nrchannels == 1 && nr_logical_channels==0) {
3422 printk(KERN_INFO "usbaudio: assuming the channel found is the master channel (got a Philips camera?). Should be fine.\n");
3423 } else if (state->nrchannels == 1 && nr_logical_channels==2) {
3424 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");
3425 state->nrchannels=nr_logical_channels;
3426 } else {
3427 printk(KERN_WARNING "usbaudio: no idea what's going on..., contact linux-usb-devel@lists.sourceforge.net\n");
3428 }
3429 }
3430
3431 /* There is always a master channel */
3432 mchftr = ftr[6];
3433 /* Binary AND over logical channels if they exist */
3434 if (nr_logical_channels) {
3435 chftr = ftr[6+ftr[5]];
3436 for (i = 2; i <= nr_logical_channels; i++)
3437 chftr &= ftr[6+i*ftr[5]];
3438 } else {
3439 chftr = 0;
3440 }
3441
3442 /* volume control */
3443 if (chftr & 2) {
3444 ch = getmixchannel(state, getvolchannel(state));
3445 if (ch) {
3446 ch->unitid = ftr[3];
3447 ch->selector = VOLUME_CONTROL;
3448 ch->chnum = 1;
3449 ch->flags = (state->nrchannels > 1) ? (MIXFLG_STEREOIN | MIXFLG_STEREOOUT) : 0;
3450 prepmixch(state);
3451 }
3452 } else if (mchftr & 2) {
3453 ch = getmixchannel(state, getvolchannel(state));
3454 if (ch) {
3455 ch->unitid = ftr[3];
3456 ch->selector = VOLUME_CONTROL;
3457 ch->chnum = 0;
3458 ch->flags = 0;
3459 prepmixch(state);
3460 }
3461 }
3462 /* bass control */
3463 if (chftr & 4) {
3464 ch = getmixchannel(state, SOUND_MIXER_BASS);
3465 if (ch) {
3466 ch->unitid = ftr[3];
3467 ch->selector = BASS_CONTROL;
3468 ch->chnum = 1;
3469 ch->flags = (state->nrchannels > 1) ? (MIXFLG_STEREOIN | MIXFLG_STEREOOUT) : 0;
3470 prepmixch(state);
3471 }
3472 } else if (mchftr & 4) {
3473 ch = getmixchannel(state, SOUND_MIXER_BASS);
3474 if (ch) {
3475 ch->unitid = ftr[3];
3476 ch->selector = BASS_CONTROL;
3477 ch->chnum = 0;
3478 ch->flags = 0;
3479 prepmixch(state);
3480 }
3481 }
3482 /* treble control */
3483 if (chftr & 16) {
3484 ch = getmixchannel(state, SOUND_MIXER_TREBLE);
3485 if (ch) {
3486 ch->unitid = ftr[3];
3487 ch->selector = TREBLE_CONTROL;
3488 ch->chnum = 1;
3489 ch->flags = (state->nrchannels > 1) ? (MIXFLG_STEREOIN | MIXFLG_STEREOOUT) : 0;
3490 prepmixch(state);
3491 }
3492 } else if (mchftr & 16) {
3493 ch = getmixchannel(state, SOUND_MIXER_TREBLE);
3494 if (ch) {
3495 ch->unitid = ftr[3];
3496 ch->selector = TREBLE_CONTROL;
3497 ch->chnum = 0;
3498 ch->flags = 0;
3499 prepmixch(state);
3500 }
3501 }
3502 #if 0
3503 /* if there are mute controls, unmute them */
3504 /* does not seem to be necessary, and the Dallas chip does not seem to support the "all" channel (255) */
3505 if ((chftr & 1) || (mchftr & 1)) {
3506 printk(KERN_DEBUG "usbaudio: unmuting feature unit %u interface %u\n", ftr[3], state->ctrlif);
3507 data[0] = 0;
3508 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
3509 (MUTE_CONTROL << 8) | 0xff, state->ctrlif | (ftr[3] << 8), data, 1, 1000) < 0)
3510 printk(KERN_WARNING "usbaudio: failure to unmute feature unit %u interface %u\n", ftr[3], state->ctrlif);
3511 }
3512 #endif
3513 }
3514
3515 static void usb_audio_recurseunit(struct consmixstate *state, unsigned char unitid)
3516 {
3517 unsigned char *p1;
3518 unsigned int i, j;
3519
3520 if (test_and_set_bit(unitid, state->unitbitmap)) {
3521 printk(KERN_INFO "usbaudio: mixer path revisits unit %d\n", unitid);
3522 return;
3523 }
3524 p1 = find_audiocontrol_unit(state->buffer, state->buflen, NULL, unitid, state->ctrlif);
3525 if (!p1) {
3526 printk(KERN_ERR "usbaudio: unit %d not found!\n", unitid);
3527 return;
3528 }
3529 state->nrchannels = 0;
3530 state->termtype = 0;
3531 state->chconfig = 0;
3532 switch (p1[2]) {
3533 case INPUT_TERMINAL:
3534 if (p1[0] < 12) {
3535 printk(KERN_ERR "usbaudio: unit %u: invalid INPUT_TERMINAL descriptor\n", unitid);
3536 return;
3537 }
3538 state->nrchannels = p1[7];
3539 state->termtype = p1[4] | (p1[5] << 8);
3540 state->chconfig = p1[8] | (p1[9] << 8);
3541 return;
3542
3543 case MIXER_UNIT:
3544 if (p1[0] < 10 || p1[0] < 10+p1[4]) {
3545 printk(KERN_ERR "usbaudio: unit %u: invalid MIXER_UNIT descriptor\n", unitid);
3546 return;
3547 }
3548 usb_audio_mixerunit(state, p1);
3549 return;
3550
3551 case SELECTOR_UNIT:
3552 if (p1[0] < 6 || p1[0] < 6+p1[4]) {
3553 printk(KERN_ERR "usbaudio: unit %u: invalid SELECTOR_UNIT descriptor\n", unitid);
3554 return;
3555 }
3556 usb_audio_selectorunit(state, p1);
3557 return;
3558
3559 case FEATURE_UNIT: /* See USB Audio Class Spec 4.3.2.5 */
3560 if (p1[0] < 7 || p1[0] < 7+p1[5]) {
3561 printk(KERN_ERR "usbaudio: unit %u: invalid FEATURE_UNIT descriptor\n", unitid);
3562 return;
3563 }
3564 usb_audio_featureunit(state, p1);
3565 return;
3566
3567 case PROCESSING_UNIT:
3568 if (p1[0] < 13 || p1[0] < 13+p1[6] || p1[0] < 13+p1[6]+p1[11+p1[6]]) {
3569 printk(KERN_ERR "usbaudio: unit %u: invalid PROCESSING_UNIT descriptor\n", unitid);
3570 return;
3571 }
3572 usb_audio_processingunit(state, p1);
3573 return;
3574
3575 case EXTENSION_UNIT:
3576 if (p1[0] < 13 || p1[0] < 13+p1[6] || p1[0] < 13+p1[6]+p1[11+p1[6]]) {
3577 printk(KERN_ERR "usbaudio: unit %u: invalid EXTENSION_UNIT descriptor\n", unitid);
3578 return;
3579 }
3580 for (j = i = 0; i < p1[6]; i++) {
3581 usb_audio_recurseunit(state, p1[7+i]);
3582 if (!i)
3583 j = state->termtype;
3584 else if (j != state->termtype)
3585 j = 0;
3586 }
3587 state->nrchannels = p1[7+p1[6]];
3588 state->chconfig = p1[8+p1[6]] | (p1[9+p1[6]] << 8);
3589 state->termtype = j;
3590 return;
3591
3592 default:
3593 printk(KERN_ERR "usbaudio: unit %u: unexpected type 0x%02x\n", unitid, p1[2]);
3594 return;
3595 }
3596 }
3597
3598 static void usb_audio_constructmixer(struct usb_audio_state *s, unsigned char *buffer, unsigned int buflen, unsigned int ctrlif, unsigned char *oterm)
3599 {
3600 struct usb_mixerdev *ms;
3601 struct consmixstate state;
3602
3603 memset(&state, 0, sizeof(state));
3604 state.s = s;
3605 state.nrmixch = 0;
3606 state.mixchmask = ~0;
3607 state.buffer = buffer;
3608 state.buflen = buflen;
3609 state.ctrlif = ctrlif;
3610 set_bit(oterm[3], state.unitbitmap); /* mark terminal ID as visited */
3611 printk(KERN_DEBUG "usbaudio: constructing mixer for Terminal %u type 0x%04x\n",
3612 oterm[3], oterm[4] | (oterm[5] << 8));
3613 usb_audio_recurseunit(&state, oterm[7]);
3614 if (!state.nrmixch) {
3615 printk(KERN_INFO "usbaudio: no mixer controls found for Terminal %u\n", oterm[3]);
3616 return;
3617 }
3618 if (!(ms = kmalloc(sizeof(struct usb_mixerdev)+state.nrmixch*sizeof(struct mixerchannel), GFP_KERNEL)))
3619 return;
3620 memset(ms, 0, sizeof(struct usb_mixerdev));
3621 memcpy(&ms->ch, &state.mixch, state.nrmixch*sizeof(struct mixerchannel));
3622 ms->state = s;
3623 ms->iface = ctrlif;
3624 ms->numch = state.nrmixch;
3625 if ((ms->dev_mixer = register_sound_mixer(&usb_mixer_fops, -1)) < 0) {
3626 printk(KERN_ERR "usbaudio: cannot register mixer\n");
3627 kfree(ms);
3628 return;
3629 }
3630 printk(KERN_INFO "usbaudio: registered mixer 14,%d\n", ms->dev_mixer);
3631 list_add_tail(&ms->list, &s->mixerlist);
3632 }
3633
3634 /* arbitrary limit, we won't check more interfaces than this */
3635 #define USB_MAXINTERFACES 32
3636
3637 static struct usb_audio_state *usb_audio_parsecontrol(struct usb_device *dev, unsigned char *buffer, unsigned int buflen, unsigned int ctrlif)
3638 {
3639 struct usb_audio_state *s;
3640 struct usb_interface *iface;
3641 struct usb_host_interface *alt;
3642 unsigned char ifin[USB_MAXINTERFACES], ifout[USB_MAXINTERFACES];
3643 unsigned char *p1;
3644 unsigned int i, j, k, numifin = 0, numifout = 0;
3645
3646 if (!(s = kmalloc(sizeof(struct usb_audio_state), GFP_KERNEL)))
3647 return NULL;
3648 memset(s, 0, sizeof(struct usb_audio_state));
3649 INIT_LIST_HEAD(&s->audiolist);
3650 INIT_LIST_HEAD(&s->mixerlist);
3651 s->usbdev = dev;
3652 s->count = 1;
3653
3654 /* find audiocontrol interface */
3655 if (!(p1 = find_csinterface_descriptor(buffer, buflen, NULL, HEADER, ctrlif, -1))) {
3656 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u no HEADER found\n",
3657 dev->devnum, ctrlif);
3658 goto ret;
3659 }
3660 if (p1[0] < 8 + p1[7]) {
3661 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u HEADER error\n",
3662 dev->devnum, ctrlif);
3663 goto ret;
3664 }
3665 if (!p1[7])
3666 printk(KERN_INFO "usbaudio: device %d audiocontrol interface %u has no AudioStreaming and MidiStreaming interfaces\n",
3667 dev->devnum, ctrlif);
3668 for (i = 0; i < p1[7]; i++) {
3669 j = p1[8+i];
3670 iface = usb_ifnum_to_if(dev, j);
3671 if (!iface) {
3672 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u does not exist\n",
3673 dev->devnum, ctrlif, j);
3674 continue;
3675 }
3676 if (iface->num_altsetting == 1) {
3677 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u has only 1 altsetting.\n", dev->devnum, ctrlif);
3678 continue;
3679 }
3680 alt = usb_altnum_to_altsetting(iface, 0);
3681 if (!alt) {
3682 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u has no altsetting 0\n",
3683 dev->devnum, ctrlif, j);
3684 continue;
3685 }
3686 if (alt->desc.bInterfaceClass != USB_CLASS_AUDIO) {
3687 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u is not an AudioClass interface\n",
3688 dev->devnum, ctrlif, j);
3689 continue;
3690 }
3691 if (alt->desc.bInterfaceSubClass == 3) {
3692 printk(KERN_INFO "usbaudio: device %d audiocontrol interface %u interface %u MIDIStreaming not supported\n",
3693 dev->devnum, ctrlif, j);
3694 continue;
3695 }
3696 if (alt->desc.bInterfaceSubClass != 2) {
3697 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u invalid AudioClass subtype\n",
3698 dev->devnum, ctrlif, j);
3699 continue;
3700 }
3701 if (alt->desc.bNumEndpoints > 0) {
3702 /* Check all endpoints; should they all have a bandwidth of 0 ? */
3703 for (k = 0; k < alt->desc.bNumEndpoints; k++) {
3704 if (le16_to_cpu(alt->endpoint[k].desc.wMaxPacketSize) > 0) {
3705 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u endpoint %d does not have 0 bandwidth at alt[0]\n", dev->devnum, ctrlif, k);
3706 break;
3707 }
3708 }
3709 if (k < alt->desc.bNumEndpoints)
3710 continue;
3711 }
3712
3713 alt = usb_altnum_to_altsetting(iface, 1);
3714 if (!alt) {
3715 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u has no altsetting 1\n",
3716 dev->devnum, ctrlif, j);
3717 continue;
3718 }
3719 if (alt->desc.bNumEndpoints < 1) {
3720 printk(KERN_ERR "usbaudio: device %d audiocontrol interface %u interface %u has no endpoint\n",
3721 dev->devnum, ctrlif, j);
3722 continue;
3723 }
3724 /* note: this requires the data endpoint to be ep0 and the optional sync
3725 ep to be ep1, which seems to be the case */
3726 if (alt->endpoint[0].desc.bEndpointAddress & USB_DIR_IN) {
3727 if (numifin < USB_MAXINTERFACES) {
3728 ifin[numifin++] = j;
3729 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1);
3730 }
3731 } else {
3732 if (numifout < USB_MAXINTERFACES) {
3733 ifout[numifout++] = j;
3734 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1);
3735 }
3736 }
3737 }
3738 printk(KERN_INFO "usbaudio: device %d audiocontrol interface %u has %u input and %u output AudioStreaming interfaces\n",
3739 dev->devnum, ctrlif, numifin, numifout);
3740 for (i = 0; i < numifin && i < numifout; i++)
3741 usb_audio_parsestreaming(s, buffer, buflen, ifin[i], ifout[i]);
3742 for (j = i; j < numifin; j++)
3743 usb_audio_parsestreaming(s, buffer, buflen, ifin[i], -1);
3744 for (j = i; j < numifout; j++)
3745 usb_audio_parsestreaming(s, buffer, buflen, -1, ifout[i]);
3746 /* now walk through all OUTPUT_TERMINAL descriptors to search for mixers */
3747 p1 = find_csinterface_descriptor(buffer, buflen, NULL, OUTPUT_TERMINAL, ctrlif, -1);
3748 while (p1) {
3749 if (p1[0] >= 9)
3750 usb_audio_constructmixer(s, buffer, buflen, ctrlif, p1);
3751 p1 = find_csinterface_descriptor(buffer, buflen, p1, OUTPUT_TERMINAL, ctrlif, -1);
3752 }
3753
3754 ret:
3755 if (list_empty(&s->audiolist) && list_empty(&s->mixerlist)) {
3756 kfree(s);
3757 return NULL;
3758 }
3759 /* everything successful */
3760 down(&open_sem);
3761 list_add_tail(&s->audiodev, &audiodevs);
3762 up(&open_sem);
3763 printk(KERN_DEBUG "usb_audio_parsecontrol: usb_audio_state at %p\n", s);
3764 return s;
3765 }
3766
3767 /* we only care for the currently active configuration */
3768
3769 static int usb_audio_probe(struct usb_interface *intf,
3770 const struct usb_device_id *id)
3771 {
3772 struct usb_device *dev = interface_to_usbdev (intf);
3773 struct usb_audio_state *s;
3774 unsigned char *buffer;
3775 unsigned int buflen;
3776
3777 #if 0
3778 printk(KERN_DEBUG "usbaudio: Probing if %i: IC %x, ISC %x\n", ifnum,
3779 config->interface[ifnum].altsetting[0].desc.bInterfaceClass,
3780 config->interface[ifnum].altsetting[0].desc.bInterfaceSubClass);
3781 #endif
3782
3783 /*
3784 * audiocontrol interface found
3785 * find which configuration number is active
3786 */
3787 buffer = dev->rawdescriptors[dev->actconfig - dev->config];
3788 buflen = le16_to_cpu(dev->actconfig->desc.wTotalLength);
3789 s = usb_audio_parsecontrol(dev, buffer, buflen, intf->altsetting->desc.bInterfaceNumber);
3790 if (s) {
3791 usb_set_intfdata (intf, s);
3792 return 0;
3793 }
3794 return -ENODEV;
3795 }
3796
3797
3798 /* a revoke facility would make things simpler */
3799
3800 static void usb_audio_disconnect(struct usb_interface *intf)
3801 {
3802 struct usb_audio_state *s = usb_get_intfdata (intf);
3803 struct usb_audiodev *as;
3804 struct usb_mixerdev *ms;
3805
3806 if (!s)
3807 return;
3808
3809 /* we get called with -1 for every audiostreaming interface registered */
3810 if (s == (struct usb_audio_state *)-1) {
3811 dprintk((KERN_DEBUG "usbaudio: note, usb_audio_disconnect called with -1\n"));
3812 return;
3813 }
3814 if (!s->usbdev) {
3815 dprintk((KERN_DEBUG "usbaudio: error, usb_audio_disconnect already called for %p!\n", s));
3816 return;
3817 }
3818 down(&open_sem);
3819 list_del_init(&s->audiodev);
3820 s->usbdev = NULL;
3821 usb_set_intfdata (intf, NULL);
3822
3823 /* deregister all audio and mixer devices, so no new processes can open this device */
3824 list_for_each_entry(as, &s->audiolist, list) {
3825 usbin_disc(as);
3826 usbout_disc(as);
3827 wake_up(&as->usbin.dma.wait);
3828 wake_up(&as->usbout.dma.wait);
3829 if (as->dev_audio >= 0) {
3830 unregister_sound_dsp(as->dev_audio);
3831 printk(KERN_INFO "usbaudio: unregister dsp 14,%d\n", as->dev_audio);
3832 }
3833 as->dev_audio = -1;
3834 }
3835 list_for_each_entry(ms, &s->mixerlist, list) {
3836 if (ms->dev_mixer >= 0) {
3837 unregister_sound_mixer(ms->dev_mixer);
3838 printk(KERN_INFO "usbaudio: unregister mixer 14,%d\n", ms->dev_mixer);
3839 }
3840 ms->dev_mixer = -1;
3841 }
3842 release(s);
3843 wake_up(&open_wait);
3844 }
3845
3846 static int __init usb_audio_init(void)
3847 {
3848 int result = usb_register(&usb_audio_driver);
3849 if (result == 0)
3850 info(DRIVER_VERSION ":" DRIVER_DESC);
3851 return result;
3852 }
3853
3854
3855 static void __exit usb_audio_cleanup(void)
3856 {
3857 usb_deregister(&usb_audio_driver);
3858 }
3859
3860 module_init(usb_audio_init);
3861 module_exit(usb_audio_cleanup);
3862
3863 MODULE_AUTHOR( DRIVER_AUTHOR );
3864 MODULE_DESCRIPTION( DRIVER_DESC );
3865 MODULE_LICENSE("GPL");
3866
linux-next