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