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