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