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