[ALSA] usb-audio: use vmalloc for the PCM buffer
[linux-2.6.git] / sound / usb / usbaudio.c
1 /*
2  *   (Tentative) USB Audio Driver for ALSA
3  *
4  *   Main and PCM part
5  *
6  *   Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
7  *
8  *   Many codes borrowed from audio.c by
9  *          Alan Cox (alan@lxorguk.ukuu.org.uk)
10  *          Thomas Sailer (sailer@ife.ee.ethz.ch)
11  *
12  *
13  *   This program is free software; you can redistribute it and/or modify
14  *   it under the terms of the GNU General Public License as published by
15  *   the Free Software Foundation; either version 2 of the License, or
16  *   (at your option) any later version.
17  *
18  *   This program is distributed in the hope that it will be useful,
19  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
20  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  *   GNU General Public License for more details.
22  *
23  *   You should have received a copy of the GNU General Public License
24  *   along with this program; if not, write to the Free Software
25  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
26  *
27  *
28  *  NOTES:
29  *
30  *   - async unlink should be used for avoiding the sleep inside lock.
31  *     2.4.22 usb-uhci seems buggy for async unlinking and results in
32  *     oops.  in such a cse, pass async_unlink=0 option.
33  *   - the linked URBs would be preferred but not used so far because of
34  *     the instability of unlinking.
35  *   - type II is not supported properly.  there is no device which supports
36  *     this type *correctly*.  SB extigy looks as if it supports, but it's
37  *     indeed an AC3 stream packed in SPDIF frames (i.e. no real AC3 stream).
38  */
39
40
41 #include <sound/driver.h>
42 #include <linux/bitops.h>
43 #include <linux/init.h>
44 #include <linux/interrupt.h>
45 #include <linux/list.h>
46 #include <linux/slab.h>
47 #include <linux/string.h>
48 #include <linux/usb.h>
49 #include <linux/vmalloc.h>
50 #include <linux/moduleparam.h>
51 #include <sound/core.h>
52 #include <sound/info.h>
53 #include <sound/pcm.h>
54 #include <sound/pcm_params.h>
55 #include <sound/initval.h>
56
57 #include "usbaudio.h"
58
59
60 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
61 MODULE_DESCRIPTION("USB Audio");
62 MODULE_LICENSE("GPL");
63 MODULE_SUPPORTED_DEVICE("{{Generic,USB Audio}}");
64
65
66 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
67 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
68 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;      /* Enable this card */
69 static int vid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; /* Vendor ID for this card */
70 static int pid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; /* Product ID for this card */
71 static int nrpacks = 4;         /* max. number of packets per urb */
72 static int async_unlink = 1;
73
74 module_param_array(index, int, NULL, 0444);
75 MODULE_PARM_DESC(index, "Index value for the USB audio adapter.");
76 module_param_array(id, charp, NULL, 0444);
77 MODULE_PARM_DESC(id, "ID string for the USB audio adapter.");
78 module_param_array(enable, bool, NULL, 0444);
79 MODULE_PARM_DESC(enable, "Enable USB audio adapter.");
80 module_param_array(vid, int, NULL, 0444);
81 MODULE_PARM_DESC(vid, "Vendor ID for the USB audio device.");
82 module_param_array(pid, int, NULL, 0444);
83 MODULE_PARM_DESC(pid, "Product ID for the USB audio device.");
84 module_param(nrpacks, int, 0644);
85 MODULE_PARM_DESC(nrpacks, "Max. number of packets per URB.");
86 module_param(async_unlink, bool, 0444);
87 MODULE_PARM_DESC(async_unlink, "Use async unlink mode.");
88
89
90 /*
91  * debug the h/w constraints
92  */
93 /* #define HW_CONST_DEBUG */
94
95
96 /*
97  *
98  */
99
100 #define MAX_PACKS       10
101 #define MAX_PACKS_HS    (MAX_PACKS * 8) /* in high speed mode */
102 #define MAX_URBS        8
103 #define SYNC_URBS       4       /* always four urbs for sync */
104 #define MIN_PACKS_URB   1       /* minimum 1 packet per urb */
105
106 typedef struct snd_usb_substream snd_usb_substream_t;
107 typedef struct snd_usb_stream snd_usb_stream_t;
108 typedef struct snd_urb_ctx snd_urb_ctx_t;
109
110 struct audioformat {
111         struct list_head list;
112         snd_pcm_format_t format;        /* format type */
113         unsigned int channels;          /* # channels */
114         unsigned int fmt_type;          /* USB audio format type (1-3) */
115         unsigned int frame_size;        /* samples per frame for non-audio */
116         int iface;                      /* interface number */
117         unsigned char altsetting;       /* corresponding alternate setting */
118         unsigned char altset_idx;       /* array index of altenate setting */
119         unsigned char attributes;       /* corresponding attributes of cs endpoint */
120         unsigned char endpoint;         /* endpoint */
121         unsigned char ep_attr;          /* endpoint attributes */
122         unsigned int maxpacksize;       /* max. packet size */
123         unsigned int rates;             /* rate bitmasks */
124         unsigned int rate_min, rate_max;        /* min/max rates */
125         unsigned int nr_rates;          /* number of rate table entries */
126         unsigned int *rate_table;       /* rate table */
127 };
128
129 struct snd_urb_ctx {
130         struct urb *urb;
131         unsigned int buffer_size;       /* size of data buffer, if data URB */
132         snd_usb_substream_t *subs;
133         int index;      /* index for urb array */
134         int packets;    /* number of packets per urb */
135 };
136
137 struct snd_urb_ops {
138         int (*prepare)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
139         int (*retire)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
140         int (*prepare_sync)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
141         int (*retire_sync)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u);
142 };
143
144 struct snd_usb_substream {
145         snd_usb_stream_t *stream;
146         struct usb_device *dev;
147         snd_pcm_substream_t *pcm_substream;
148         int direction;  /* playback or capture */
149         int interface;  /* current interface */
150         int endpoint;   /* assigned endpoint */
151         struct audioformat *cur_audiofmt;       /* current audioformat pointer (for hw_params callback) */
152         unsigned int cur_rate;          /* current rate (for hw_params callback) */
153         unsigned int period_bytes;      /* current period bytes (for hw_params callback) */
154         unsigned int format;     /* USB data format */
155         unsigned int datapipe;   /* the data i/o pipe */
156         unsigned int syncpipe;   /* 1 - async out or adaptive in */
157         unsigned int datainterval;      /* log_2 of data packet interval */
158         unsigned int syncinterval;  /* P for adaptive mode, 0 otherwise */
159         unsigned int freqn;      /* nominal sampling rate in fs/fps in Q16.16 format */
160         unsigned int freqm;      /* momentary sampling rate in fs/fps in Q16.16 format */
161         unsigned int freqmax;    /* maximum sampling rate, used for buffer management */
162         unsigned int phase;      /* phase accumulator */
163         unsigned int maxpacksize;       /* max packet size in bytes */
164         unsigned int maxframesize;      /* max packet size in frames */
165         unsigned int curpacksize;       /* current packet size in bytes (for capture) */
166         unsigned int curframesize;      /* current packet size in frames (for capture) */
167         unsigned int fill_max: 1;       /* fill max packet size always */
168         unsigned int fmt_type;          /* USB audio format type (1-3) */
169         unsigned int packs_per_ms;      /* packets per millisecond (for playback) */
170
171         unsigned int running: 1;        /* running status */
172
173         unsigned int hwptr_done;                        /* processed frame position in the buffer */
174         unsigned int transfer_done;             /* processed frames since last period update */
175         unsigned long active_mask;      /* bitmask of active urbs */
176         unsigned long unlink_mask;      /* bitmask of unlinked urbs */
177
178         unsigned int nurbs;                     /* # urbs */
179         snd_urb_ctx_t dataurb[MAX_URBS];        /* data urb table */
180         snd_urb_ctx_t syncurb[SYNC_URBS];       /* sync urb table */
181         char *syncbuf;                          /* sync buffer for all sync URBs */
182         dma_addr_t sync_dma;                    /* DMA address of syncbuf */
183
184         u64 formats;                    /* format bitmasks (all or'ed) */
185         unsigned int num_formats;               /* number of supported audio formats (list) */
186         struct list_head fmt_list;      /* format list */
187         spinlock_t lock;
188         struct tasklet_struct start_period_elapsed;     /* for start trigger */
189
190         struct snd_urb_ops ops;         /* callbacks (must be filled at init) */
191 };
192
193
194 struct snd_usb_stream {
195         snd_usb_audio_t *chip;
196         snd_pcm_t *pcm;
197         int pcm_index;
198         unsigned int fmt_type;          /* USB audio format type (1-3) */
199         snd_usb_substream_t substream[2];
200         struct list_head list;
201 };
202
203
204 /*
205  * we keep the snd_usb_audio_t instances by ourselves for merging
206  * the all interfaces on the same card as one sound device.
207  */
208
209 static DECLARE_MUTEX(register_mutex);
210 static snd_usb_audio_t *usb_chip[SNDRV_CARDS];
211
212
213 /*
214  * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
215  * this will overflow at approx 524 kHz
216  */
217 static inline unsigned get_usb_full_speed_rate(unsigned int rate)
218 {
219         return ((rate << 13) + 62) / 125;
220 }
221
222 /*
223  * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
224  * this will overflow at approx 4 MHz
225  */
226 static inline unsigned get_usb_high_speed_rate(unsigned int rate)
227 {
228         return ((rate << 10) + 62) / 125;
229 }
230
231 /* convert our full speed USB rate into sampling rate in Hz */
232 static inline unsigned get_full_speed_hz(unsigned int usb_rate)
233 {
234         return (usb_rate * 125 + (1 << 12)) >> 13;
235 }
236
237 /* convert our high speed USB rate into sampling rate in Hz */
238 static inline unsigned get_high_speed_hz(unsigned int usb_rate)
239 {
240         return (usb_rate * 125 + (1 << 9)) >> 10;
241 }
242
243
244 /*
245  * prepare urb for full speed capture sync pipe
246  *
247  * fill the length and offset of each urb descriptor.
248  * the fixed 10.14 frequency is passed through the pipe.
249  */
250 static int prepare_capture_sync_urb(snd_usb_substream_t *subs,
251                                     snd_pcm_runtime_t *runtime,
252                                     struct urb *urb)
253 {
254         unsigned char *cp = urb->transfer_buffer;
255         snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
256
257         urb->dev = ctx->subs->dev; /* we need to set this at each time */
258         urb->iso_frame_desc[0].length = 3;
259         urb->iso_frame_desc[0].offset = 0;
260         cp[0] = subs->freqn >> 2;
261         cp[1] = subs->freqn >> 10;
262         cp[2] = subs->freqn >> 18;
263         return 0;
264 }
265
266 /*
267  * prepare urb for high speed capture sync pipe
268  *
269  * fill the length and offset of each urb descriptor.
270  * the fixed 12.13 frequency is passed as 16.16 through the pipe.
271  */
272 static int prepare_capture_sync_urb_hs(snd_usb_substream_t *subs,
273                                        snd_pcm_runtime_t *runtime,
274                                        struct urb *urb)
275 {
276         unsigned char *cp = urb->transfer_buffer;
277         snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
278
279         urb->dev = ctx->subs->dev; /* we need to set this at each time */
280         urb->iso_frame_desc[0].length = 4;
281         urb->iso_frame_desc[0].offset = 0;
282         cp[0] = subs->freqn;
283         cp[1] = subs->freqn >> 8;
284         cp[2] = subs->freqn >> 16;
285         cp[3] = subs->freqn >> 24;
286         return 0;
287 }
288
289 /*
290  * process after capture sync complete
291  * - nothing to do
292  */
293 static int retire_capture_sync_urb(snd_usb_substream_t *subs,
294                                    snd_pcm_runtime_t *runtime,
295                                    struct urb *urb)
296 {
297         return 0;
298 }
299
300 /*
301  * prepare urb for capture data pipe
302  *
303  * fill the offset and length of each descriptor.
304  *
305  * we use a temporary buffer to write the captured data.
306  * since the length of written data is determined by host, we cannot
307  * write onto the pcm buffer directly...  the data is thus copied
308  * later at complete callback to the global buffer.
309  */
310 static int prepare_capture_urb(snd_usb_substream_t *subs,
311                                snd_pcm_runtime_t *runtime,
312                                struct urb *urb)
313 {
314         int i, offs;
315         snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
316
317         offs = 0;
318         urb->dev = ctx->subs->dev; /* we need to set this at each time */
319         for (i = 0; i < ctx->packets; i++) {
320                 urb->iso_frame_desc[i].offset = offs;
321                 urb->iso_frame_desc[i].length = subs->curpacksize;
322                 offs += subs->curpacksize;
323         }
324         urb->transfer_buffer_length = offs;
325         urb->number_of_packets = ctx->packets;
326 #if 0 // for check
327         if (! urb->bandwidth) {
328                 int bustime;
329                 bustime = usb_check_bandwidth(urb->dev, urb);
330                 if (bustime < 0)
331                         return bustime;
332                 printk("urb %d: bandwidth = %d (packets = %d)\n", ctx->index, bustime, urb->number_of_packets);
333                 usb_claim_bandwidth(urb->dev, urb, bustime, 1);
334         }
335 #endif // for check
336         return 0;
337 }
338
339 /*
340  * process after capture complete
341  *
342  * copy the data from each desctiptor to the pcm buffer, and
343  * update the current position.
344  */
345 static int retire_capture_urb(snd_usb_substream_t *subs,
346                               snd_pcm_runtime_t *runtime,
347                               struct urb *urb)
348 {
349         unsigned long flags;
350         unsigned char *cp;
351         int i;
352         unsigned int stride, len, oldptr;
353         int period_elapsed = 0;
354
355         stride = runtime->frame_bits >> 3;
356
357         for (i = 0; i < urb->number_of_packets; i++) {
358                 cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset;
359                 if (urb->iso_frame_desc[i].status) {
360                         snd_printd(KERN_ERR "frame %d active: %d\n", i, urb->iso_frame_desc[i].status);
361                         // continue;
362                 }
363                 len = urb->iso_frame_desc[i].actual_length / stride;
364                 if (! len)
365                         continue;
366                 /* update the current pointer */
367                 spin_lock_irqsave(&subs->lock, flags);
368                 oldptr = subs->hwptr_done;
369                 subs->hwptr_done += len;
370                 if (subs->hwptr_done >= runtime->buffer_size)
371                         subs->hwptr_done -= runtime->buffer_size;
372                 subs->transfer_done += len;
373                 if (subs->transfer_done >= runtime->period_size) {
374                         subs->transfer_done -= runtime->period_size;
375                         period_elapsed = 1;
376                 }
377                 spin_unlock_irqrestore(&subs->lock, flags);
378                 /* copy a data chunk */
379                 if (oldptr + len > runtime->buffer_size) {
380                         unsigned int cnt = runtime->buffer_size - oldptr;
381                         unsigned int blen = cnt * stride;
382                         memcpy(runtime->dma_area + oldptr * stride, cp, blen);
383                         memcpy(runtime->dma_area, cp + blen, len * stride - blen);
384                 } else {
385                         memcpy(runtime->dma_area + oldptr * stride, cp, len * stride);
386                 }
387         }
388         if (period_elapsed)
389                 snd_pcm_period_elapsed(subs->pcm_substream);
390         return 0;
391 }
392
393
394 /*
395  * prepare urb for full speed playback sync pipe
396  *
397  * set up the offset and length to receive the current frequency.
398  */
399
400 static int prepare_playback_sync_urb(snd_usb_substream_t *subs,
401                                      snd_pcm_runtime_t *runtime,
402                                      struct urb *urb)
403 {
404         snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
405
406         urb->dev = ctx->subs->dev; /* we need to set this at each time */
407         urb->iso_frame_desc[0].length = 3;
408         urb->iso_frame_desc[0].offset = 0;
409         return 0;
410 }
411
412 /*
413  * prepare urb for high speed playback sync pipe
414  *
415  * set up the offset and length to receive the current frequency.
416  */
417
418 static int prepare_playback_sync_urb_hs(snd_usb_substream_t *subs,
419                                         snd_pcm_runtime_t *runtime,
420                                         struct urb *urb)
421 {
422         snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
423
424         urb->dev = ctx->subs->dev; /* we need to set this at each time */
425         urb->iso_frame_desc[0].length = 4;
426         urb->iso_frame_desc[0].offset = 0;
427         return 0;
428 }
429
430 /*
431  * process after full speed playback sync complete
432  *
433  * retrieve the current 10.14 frequency from pipe, and set it.
434  * the value is referred in prepare_playback_urb().
435  */
436 static int retire_playback_sync_urb(snd_usb_substream_t *subs,
437                                     snd_pcm_runtime_t *runtime,
438                                     struct urb *urb)
439 {
440         unsigned int f;
441         unsigned long flags;
442
443         if (urb->iso_frame_desc[0].status == 0 &&
444             urb->iso_frame_desc[0].actual_length == 3) {
445                 f = combine_triple((u8*)urb->transfer_buffer) << 2;
446                 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
447                         spin_lock_irqsave(&subs->lock, flags);
448                         subs->freqm = f;
449                         spin_unlock_irqrestore(&subs->lock, flags);
450                 }
451         }
452
453         return 0;
454 }
455
456 /*
457  * process after high speed playback sync complete
458  *
459  * retrieve the current 12.13 frequency from pipe, and set it.
460  * the value is referred in prepare_playback_urb().
461  */
462 static int retire_playback_sync_urb_hs(snd_usb_substream_t *subs,
463                                        snd_pcm_runtime_t *runtime,
464                                        struct urb *urb)
465 {
466         unsigned int f;
467         unsigned long flags;
468
469         if (urb->iso_frame_desc[0].status == 0 &&
470             urb->iso_frame_desc[0].actual_length == 4) {
471                 f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff;
472                 if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
473                         spin_lock_irqsave(&subs->lock, flags);
474                         subs->freqm = f;
475                         spin_unlock_irqrestore(&subs->lock, flags);
476                 }
477         }
478
479         return 0;
480 }
481
482 /*
483  * prepare urb for playback data pipe
484  *
485  * Since a URB can handle only a single linear buffer, we must use double
486  * buffering when the data to be transferred overflows the buffer boundary.
487  * To avoid inconsistencies when updating hwptr_done, we use double buffering
488  * for all URBs.
489  */
490 static int prepare_playback_urb(snd_usb_substream_t *subs,
491                                 snd_pcm_runtime_t *runtime,
492                                 struct urb *urb)
493 {
494         int i, stride, offs;
495         unsigned int counts;
496         unsigned long flags;
497         int period_elapsed = 0;
498         snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
499
500         stride = runtime->frame_bits >> 3;
501
502         offs = 0;
503         urb->dev = ctx->subs->dev; /* we need to set this at each time */
504         urb->number_of_packets = 0;
505         spin_lock_irqsave(&subs->lock, flags);
506         for (i = 0; i < ctx->packets; i++) {
507                 /* calculate the size of a packet */
508                 if (subs->fill_max)
509                         counts = subs->maxframesize; /* fixed */
510                 else {
511                         subs->phase = (subs->phase & 0xffff)
512                                 + (subs->freqm << subs->datainterval);
513                         counts = subs->phase >> 16;
514                         if (counts > subs->maxframesize)
515                                 counts = subs->maxframesize;
516                 }
517                 /* set up descriptor */
518                 urb->iso_frame_desc[i].offset = offs * stride;
519                 urb->iso_frame_desc[i].length = counts * stride;
520                 offs += counts;
521                 urb->number_of_packets++;
522                 subs->transfer_done += counts;
523                 if (subs->transfer_done >= runtime->period_size) {
524                         subs->transfer_done -= runtime->period_size;
525                         period_elapsed = 1;
526                         if (subs->fmt_type == USB_FORMAT_TYPE_II) {
527                                 if (subs->transfer_done > 0) {
528                                         /* FIXME: fill-max mode is not
529                                          * supported yet */
530                                         offs -= subs->transfer_done;
531                                         counts -= subs->transfer_done;
532                                         urb->iso_frame_desc[i].length =
533                                                 counts * stride;
534                                         subs->transfer_done = 0;
535                                 }
536                                 i++;
537                                 if (i < ctx->packets) {
538                                         /* add a transfer delimiter */
539                                         urb->iso_frame_desc[i].offset =
540                                                 offs * stride;
541                                         urb->iso_frame_desc[i].length = 0;
542                                         urb->number_of_packets++;
543                                 }
544                                 break;
545                         }
546                 }
547                 /* finish at the frame boundary at/after the period boundary */
548                 if (period_elapsed &&
549                     (i & (subs->packs_per_ms - 1)) == subs->packs_per_ms - 1)
550                         break;
551         }
552         if (subs->hwptr_done + offs > runtime->buffer_size) {
553                 /* err, the transferred area goes over buffer boundary. */
554                 unsigned int len = runtime->buffer_size - subs->hwptr_done;
555                 memcpy(urb->transfer_buffer,
556                        runtime->dma_area + subs->hwptr_done * stride,
557                        len * stride);
558                 memcpy(urb->transfer_buffer + len * stride,
559                        runtime->dma_area,
560                        (offs - len) * stride);
561         } else {
562                 memcpy(urb->transfer_buffer,
563                        runtime->dma_area + subs->hwptr_done * stride,
564                        offs * stride);
565         }
566         subs->hwptr_done += offs;
567         if (subs->hwptr_done >= runtime->buffer_size)
568                 subs->hwptr_done -= runtime->buffer_size;
569         spin_unlock_irqrestore(&subs->lock, flags);
570         urb->transfer_buffer_length = offs * stride;
571         if (period_elapsed) {
572                 if (likely(subs->running))
573                         snd_pcm_period_elapsed(subs->pcm_substream);
574                 else
575                         tasklet_hi_schedule(&subs->start_period_elapsed);
576         }
577         return 0;
578 }
579
580 /*
581  * process after playback data complete
582  * - nothing to do
583  */
584 static int retire_playback_urb(snd_usb_substream_t *subs,
585                                snd_pcm_runtime_t *runtime,
586                                struct urb *urb)
587 {
588         return 0;
589 }
590
591 /*
592  * Delay the snd_pcm_period_elapsed() call until after the start trigger
593  * callback so that we're not longer in the substream's lock.
594  */
595 static void start_period_elapsed(unsigned long data)
596 {
597         snd_usb_substream_t *subs = (snd_usb_substream_t *)data;
598         snd_pcm_period_elapsed(subs->pcm_substream);
599 }
600
601
602 /*
603  */
604 static struct snd_urb_ops audio_urb_ops[2] = {
605         {
606                 .prepare =      prepare_playback_urb,
607                 .retire =       retire_playback_urb,
608                 .prepare_sync = prepare_playback_sync_urb,
609                 .retire_sync =  retire_playback_sync_urb,
610         },
611         {
612                 .prepare =      prepare_capture_urb,
613                 .retire =       retire_capture_urb,
614                 .prepare_sync = prepare_capture_sync_urb,
615                 .retire_sync =  retire_capture_sync_urb,
616         },
617 };
618
619 static struct snd_urb_ops audio_urb_ops_high_speed[2] = {
620         {
621                 .prepare =      prepare_playback_urb,
622                 .retire =       retire_playback_urb,
623                 .prepare_sync = prepare_playback_sync_urb_hs,
624                 .retire_sync =  retire_playback_sync_urb_hs,
625         },
626         {
627                 .prepare =      prepare_capture_urb,
628                 .retire =       retire_capture_urb,
629                 .prepare_sync = prepare_capture_sync_urb_hs,
630                 .retire_sync =  retire_capture_sync_urb,
631         },
632 };
633
634 /*
635  * complete callback from data urb
636  */
637 static void snd_complete_urb(struct urb *urb, struct pt_regs *regs)
638 {
639         snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
640         snd_usb_substream_t *subs = ctx->subs;
641         snd_pcm_substream_t *substream = ctx->subs->pcm_substream;
642         int err = 0;
643
644         if ((subs->running && subs->ops.retire(subs, substream->runtime, urb)) ||
645             ! subs->running || /* can be stopped during retire callback */
646             (err = subs->ops.prepare(subs, substream->runtime, urb)) < 0 ||
647             (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
648                 clear_bit(ctx->index, &subs->active_mask);
649                 if (err < 0) {
650                         snd_printd(KERN_ERR "cannot submit urb (err = %d)\n", err);
651                         snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
652                 }
653         }
654 }
655
656
657 /*
658  * complete callback from sync urb
659  */
660 static void snd_complete_sync_urb(struct urb *urb, struct pt_regs *regs)
661 {
662         snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context;
663         snd_usb_substream_t *subs = ctx->subs;
664         snd_pcm_substream_t *substream = ctx->subs->pcm_substream;
665         int err = 0;
666
667         if ((subs->running && subs->ops.retire_sync(subs, substream->runtime, urb)) ||
668             ! subs->running || /* can be stopped during retire callback */
669             (err = subs->ops.prepare_sync(subs, substream->runtime, urb)) < 0 ||
670             (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
671                 clear_bit(ctx->index + 16, &subs->active_mask);
672                 if (err < 0) {
673                         snd_printd(KERN_ERR "cannot submit sync urb (err = %d)\n", err);
674                         snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
675                 }
676         }
677 }
678
679
680 /* get the physical page pointer at the given offset */
681 static struct page *snd_pcm_get_vmalloc_page(snd_pcm_substream_t *subs,
682                                              unsigned long offset)
683 {
684         void *pageptr = subs->runtime->dma_area + offset;
685         return vmalloc_to_page(pageptr);
686 }
687
688 /* allocate virtual buffer; may be called more than once */
689 static int snd_pcm_alloc_vmalloc_buffer(snd_pcm_substream_t *subs, size_t size)
690 {
691         snd_pcm_runtime_t *runtime = subs->runtime;
692         if (runtime->dma_area) {
693                 if (runtime->dma_bytes >= size)
694                         return 0; /* already large enough */
695                 vfree_nocheck(runtime->dma_area);
696         }
697         runtime->dma_area = vmalloc_nocheck(size);
698         if (! runtime->dma_area)
699                 return -ENOMEM;
700         runtime->dma_bytes = size;
701         return 0;
702 }
703
704 /* free virtual buffer; may be called more than once */
705 static int snd_pcm_free_vmalloc_buffer(snd_pcm_substream_t *subs)
706 {
707         snd_pcm_runtime_t *runtime = subs->runtime;
708         if (runtime->dma_area) {
709                 vfree_nocheck(runtime->dma_area);
710                 runtime->dma_area = NULL;
711         }
712         return 0;
713 }
714
715
716 /*
717  * unlink active urbs.
718  */
719 static int deactivate_urbs(snd_usb_substream_t *subs, int force, int can_sleep)
720 {
721         unsigned int i;
722         int async;
723
724         subs->running = 0;
725
726         if (!force && subs->stream->chip->shutdown) /* to be sure... */
727                 return -EBADFD;
728
729         async = !can_sleep && async_unlink;
730
731         if (! async && in_interrupt())
732                 return 0;
733
734         for (i = 0; i < subs->nurbs; i++) {
735                 if (test_bit(i, &subs->active_mask)) {
736                         if (! test_and_set_bit(i, &subs->unlink_mask)) {
737                                 struct urb *u = subs->dataurb[i].urb;
738                                 if (async) {
739                                         u->transfer_flags |= URB_ASYNC_UNLINK;
740                                         usb_unlink_urb(u);
741                                 } else
742                                         usb_kill_urb(u);
743                         }
744                 }
745         }
746         if (subs->syncpipe) {
747                 for (i = 0; i < SYNC_URBS; i++) {
748                         if (test_bit(i+16, &subs->active_mask)) {
749                                 if (! test_and_set_bit(i+16, &subs->unlink_mask)) {
750                                         struct urb *u = subs->syncurb[i].urb;
751                                         if (async) {
752                                                 u->transfer_flags |= URB_ASYNC_UNLINK;
753                                                 usb_unlink_urb(u);
754                                         } else
755                                                 usb_kill_urb(u);
756                                 }
757                         }
758                 }
759         }
760         return 0;
761 }
762
763
764 /*
765  * set up and start data/sync urbs
766  */
767 static int start_urbs(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime)
768 {
769         unsigned int i;
770         int err;
771
772         if (subs->stream->chip->shutdown)
773                 return -EBADFD;
774
775         for (i = 0; i < subs->nurbs; i++) {
776                 snd_assert(subs->dataurb[i].urb, return -EINVAL);
777                 if (subs->ops.prepare(subs, runtime, subs->dataurb[i].urb) < 0) {
778                         snd_printk(KERN_ERR "cannot prepare datapipe for urb %d\n", i);
779                         goto __error;
780                 }
781         }
782         if (subs->syncpipe) {
783                 for (i = 0; i < SYNC_URBS; i++) {
784                         snd_assert(subs->syncurb[i].urb, return -EINVAL);
785                         if (subs->ops.prepare_sync(subs, runtime, subs->syncurb[i].urb) < 0) {
786                                 snd_printk(KERN_ERR "cannot prepare syncpipe for urb %d\n", i);
787                                 goto __error;
788                         }
789                 }
790         }
791
792         subs->active_mask = 0;
793         subs->unlink_mask = 0;
794         subs->running = 1;
795         for (i = 0; i < subs->nurbs; i++) {
796                 if ((err = usb_submit_urb(subs->dataurb[i].urb, GFP_ATOMIC)) < 0) {
797                         snd_printk(KERN_ERR "cannot submit datapipe for urb %d, err = %d\n", i, err);
798                         goto __error;
799                 }
800                 set_bit(i, &subs->active_mask);
801         }
802         if (subs->syncpipe) {
803                 for (i = 0; i < SYNC_URBS; i++) {
804                         if ((err = usb_submit_urb(subs->syncurb[i].urb, GFP_ATOMIC)) < 0) {
805                                 snd_printk(KERN_ERR "cannot submit syncpipe for urb %d, err = %d\n", i, err);
806                                 goto __error;
807                         }
808                         set_bit(i + 16, &subs->active_mask);
809                 }
810         }
811         return 0;
812
813  __error:
814         // snd_pcm_stop(subs->pcm_substream, SNDRV_PCM_STATE_XRUN);
815         deactivate_urbs(subs, 0, 0);
816         return -EPIPE;
817 }
818
819
820 /*
821  *  wait until all urbs are processed.
822  */
823 static int wait_clear_urbs(snd_usb_substream_t *subs)
824 {
825         unsigned long end_time = jiffies + msecs_to_jiffies(1000);
826         unsigned int i;
827         int alive;
828
829         do {
830                 alive = 0;
831                 for (i = 0; i < subs->nurbs; i++) {
832                         if (test_bit(i, &subs->active_mask))
833                                 alive++;
834                 }
835                 if (subs->syncpipe) {
836                         for (i = 0; i < SYNC_URBS; i++) {
837                                 if (test_bit(i + 16, &subs->active_mask))
838                                         alive++;
839                         }
840                 }
841                 if (! alive)
842                         break;
843                 set_current_state(TASK_UNINTERRUPTIBLE);
844                 schedule_timeout(1);
845         } while (time_before(jiffies, end_time));
846         if (alive)
847                 snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);
848         return 0;
849 }
850
851
852 /*
853  * return the current pcm pointer.  just return the hwptr_done value.
854  */
855 static snd_pcm_uframes_t snd_usb_pcm_pointer(snd_pcm_substream_t *substream)
856 {
857         snd_usb_substream_t *subs;
858         snd_pcm_uframes_t hwptr_done;
859         
860         subs = (snd_usb_substream_t *)substream->runtime->private_data;
861         spin_lock(&subs->lock);
862         hwptr_done = subs->hwptr_done;
863         spin_unlock(&subs->lock);
864         return hwptr_done;
865 }
866
867
868 /*
869  * start/stop substream
870  */
871 static int snd_usb_pcm_trigger(snd_pcm_substream_t *substream, int cmd)
872 {
873         snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data;
874         int err;
875
876         switch (cmd) {
877         case SNDRV_PCM_TRIGGER_START:
878                 err = start_urbs(subs, substream->runtime);
879                 break;
880         case SNDRV_PCM_TRIGGER_STOP:
881                 err = deactivate_urbs(subs, 0, 0);
882                 break;
883         default:
884                 err = -EINVAL;
885                 break;
886         }
887         return err < 0 ? err : 0;
888 }
889
890
891 /*
892  * release a urb data
893  */
894 static void release_urb_ctx(snd_urb_ctx_t *u)
895 {
896         if (u->urb) {
897                 if (u->buffer_size)
898                         usb_buffer_free(u->subs->dev, u->buffer_size,
899                                         u->urb->transfer_buffer,
900                                         u->urb->transfer_dma);
901                 usb_free_urb(u->urb);
902                 u->urb = NULL;
903         }
904 }
905
906 /*
907  * release a substream
908  */
909 static void release_substream_urbs(snd_usb_substream_t *subs, int force)
910 {
911         int i;
912
913         /* stop urbs (to be sure) */
914         deactivate_urbs(subs, force, 1);
915         wait_clear_urbs(subs);
916
917         for (i = 0; i < MAX_URBS; i++)
918                 release_urb_ctx(&subs->dataurb[i]);
919         for (i = 0; i < SYNC_URBS; i++)
920                 release_urb_ctx(&subs->syncurb[i]);
921         usb_buffer_free(subs->dev, SYNC_URBS * 4,
922                         subs->syncbuf, subs->sync_dma);
923         subs->syncbuf = NULL;
924         subs->nurbs = 0;
925 }
926
927 /*
928  * initialize a substream for plaback/capture
929  */
930 static int init_substream_urbs(snd_usb_substream_t *subs, unsigned int period_bytes,
931                                unsigned int rate, unsigned int frame_bits)
932 {
933         unsigned int maxsize, n, i;
934         int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
935         unsigned int npacks[MAX_URBS], urb_packs, total_packs, packs_per_ms;
936
937         /* calculate the frequency in 16.16 format */
938         if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
939                 subs->freqn = get_usb_full_speed_rate(rate);
940         else
941                 subs->freqn = get_usb_high_speed_rate(rate);
942         subs->freqm = subs->freqn;
943         /* calculate max. frequency */
944         if (subs->maxpacksize) {
945                 /* whatever fits into a max. size packet */
946                 maxsize = subs->maxpacksize;
947                 subs->freqmax = (maxsize / (frame_bits >> 3))
948                                 << (16 - subs->datainterval);
949         } else {
950                 /* no max. packet size: just take 25% higher than nominal */
951                 subs->freqmax = subs->freqn + (subs->freqn >> 2);
952                 maxsize = ((subs->freqmax + 0xffff) * (frame_bits >> 3))
953                                 >> (16 - subs->datainterval);
954         }
955         subs->phase = 0;
956
957         if (subs->fill_max)
958                 subs->curpacksize = subs->maxpacksize;
959         else
960                 subs->curpacksize = maxsize;
961
962         if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH)
963                 packs_per_ms = 8 >> subs->datainterval;
964         else
965                 packs_per_ms = 1;
966         subs->packs_per_ms = packs_per_ms;
967
968         if (is_playback) {
969                 urb_packs = nrpacks;
970                 urb_packs = max(urb_packs, (unsigned int)MIN_PACKS_URB);
971                 urb_packs = min(urb_packs, (unsigned int)MAX_PACKS);
972         } else
973                 urb_packs = 1;
974         urb_packs *= packs_per_ms;
975
976         /* decide how many packets to be used */
977         if (is_playback) {
978                 unsigned int minsize;
979                 /* determine how small a packet can be */
980                 minsize = (subs->freqn >> (16 - subs->datainterval))
981                           * (frame_bits >> 3);
982                 /* with sync from device, assume it can be 12% lower */
983                 if (subs->syncpipe)
984                         minsize -= minsize >> 3;
985                 minsize = max(minsize, 1u);
986                 total_packs = (period_bytes + minsize - 1) / minsize;
987                 /* round up to multiple of packs_per_ms */
988                 total_packs = (total_packs + packs_per_ms - 1)
989                                 & ~(packs_per_ms - 1);
990                 /* we need at least two URBs for queueing */
991                 if (total_packs < 2 * MIN_PACKS_URB * packs_per_ms)
992                         total_packs = 2 * MIN_PACKS_URB * packs_per_ms;
993         } else {
994                 total_packs = MAX_URBS * urb_packs;
995         }
996         subs->nurbs = (total_packs + urb_packs - 1) / urb_packs;
997         if (subs->nurbs > MAX_URBS) {
998                 /* too much... */
999                 subs->nurbs = MAX_URBS;
1000                 total_packs = MAX_URBS * urb_packs;
1001         }
1002         n = total_packs;
1003         for (i = 0; i < subs->nurbs; i++) {
1004                 npacks[i] = n > urb_packs ? urb_packs : n;
1005                 n -= urb_packs;
1006         }
1007         if (subs->nurbs <= 1) {
1008                 /* too little - we need at least two packets
1009                  * to ensure contiguous playback/capture
1010                  */
1011                 subs->nurbs = 2;
1012                 npacks[0] = (total_packs + 1) / 2;
1013                 npacks[1] = total_packs - npacks[0];
1014         } else if (npacks[subs->nurbs-1] < MIN_PACKS_URB * packs_per_ms) {
1015                 /* the last packet is too small.. */
1016                 if (subs->nurbs > 2) {
1017                         /* merge to the first one */
1018                         npacks[0] += npacks[subs->nurbs - 1];
1019                         subs->nurbs--;
1020                 } else {
1021                         /* divide to two */
1022                         subs->nurbs = 2;
1023                         npacks[0] = (total_packs + 1) / 2;
1024                         npacks[1] = total_packs - npacks[0];
1025                 }
1026         }
1027
1028         /* allocate and initialize data urbs */
1029         for (i = 0; i < subs->nurbs; i++) {
1030                 snd_urb_ctx_t *u = &subs->dataurb[i];
1031                 u->index = i;
1032                 u->subs = subs;
1033                 u->packets = npacks[i];
1034                 u->buffer_size = maxsize * u->packets;
1035                 if (subs->fmt_type == USB_FORMAT_TYPE_II)
1036                         u->packets++; /* for transfer delimiter */
1037                 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
1038                 if (! u->urb)
1039                         goto out_of_memory;
1040                 u->urb->transfer_buffer =
1041                         usb_buffer_alloc(subs->dev, u->buffer_size, GFP_KERNEL,
1042                                          &u->urb->transfer_dma);
1043                 if (! u->urb->transfer_buffer)
1044                         goto out_of_memory;
1045                 u->urb->pipe = subs->datapipe;
1046                 u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1047                 u->urb->interval = 1 << subs->datainterval;
1048                 u->urb->context = u;
1049                 u->urb->complete = snd_usb_complete_callback(snd_complete_urb);
1050         }
1051
1052         if (subs->syncpipe) {
1053                 /* allocate and initialize sync urbs */
1054                 subs->syncbuf = usb_buffer_alloc(subs->dev, SYNC_URBS * 4,
1055                                                  GFP_KERNEL, &subs->sync_dma);
1056                 if (! subs->syncbuf)
1057                         goto out_of_memory;
1058                 for (i = 0; i < SYNC_URBS; i++) {
1059                         snd_urb_ctx_t *u = &subs->syncurb[i];
1060                         u->index = i;
1061                         u->subs = subs;
1062                         u->packets = 1;
1063                         u->urb = usb_alloc_urb(1, GFP_KERNEL);
1064                         if (! u->urb)
1065                                 goto out_of_memory;
1066                         u->urb->transfer_buffer = subs->syncbuf + i * 4;
1067                         u->urb->transfer_dma = subs->sync_dma + i * 4;
1068                         u->urb->transfer_buffer_length = 4;
1069                         u->urb->pipe = subs->syncpipe;
1070                         u->urb->transfer_flags = URB_ISO_ASAP |
1071                                                  URB_NO_TRANSFER_DMA_MAP;
1072                         u->urb->number_of_packets = 1;
1073                         u->urb->interval = 1 << subs->syncinterval;
1074                         u->urb->context = u;
1075                         u->urb->complete = snd_usb_complete_callback(snd_complete_sync_urb);
1076                 }
1077         }
1078         return 0;
1079
1080 out_of_memory:
1081         release_substream_urbs(subs, 0);
1082         return -ENOMEM;
1083 }
1084
1085
1086 /*
1087  * find a matching audio format
1088  */
1089 static struct audioformat *find_format(snd_usb_substream_t *subs, unsigned int format,
1090                                        unsigned int rate, unsigned int channels)
1091 {
1092         struct list_head *p;
1093         struct audioformat *found = NULL;
1094         int cur_attr = 0, attr;
1095
1096         list_for_each(p, &subs->fmt_list) {
1097                 struct audioformat *fp;
1098                 fp = list_entry(p, struct audioformat, list);
1099                 if (fp->format != format || fp->channels != channels)
1100                         continue;
1101                 if (rate < fp->rate_min || rate > fp->rate_max)
1102                         continue;
1103                 if (! (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) {
1104                         unsigned int i;
1105                         for (i = 0; i < fp->nr_rates; i++)
1106                                 if (fp->rate_table[i] == rate)
1107                                         break;
1108                         if (i >= fp->nr_rates)
1109                                 continue;
1110                 }
1111                 attr = fp->ep_attr & EP_ATTR_MASK;
1112                 if (! found) {
1113                         found = fp;
1114                         cur_attr = attr;
1115                         continue;
1116                 }
1117                 /* avoid async out and adaptive in if the other method
1118                  * supports the same format.
1119                  * this is a workaround for the case like
1120                  * M-audio audiophile USB.
1121                  */
1122                 if (attr != cur_attr) {
1123                         if ((attr == EP_ATTR_ASYNC &&
1124                              subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
1125                             (attr == EP_ATTR_ADAPTIVE &&
1126                              subs->direction == SNDRV_PCM_STREAM_CAPTURE))
1127                                 continue;
1128                         if ((cur_attr == EP_ATTR_ASYNC &&
1129                              subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
1130                             (cur_attr == EP_ATTR_ADAPTIVE &&
1131                              subs->direction == SNDRV_PCM_STREAM_CAPTURE)) {
1132                                 found = fp;
1133                                 cur_attr = attr;
1134                                 continue;
1135                         }
1136                 }
1137                 /* find the format with the largest max. packet size */
1138                 if (fp->maxpacksize > found->maxpacksize) {
1139                         found = fp;
1140                         cur_attr = attr;
1141                 }
1142         }
1143         return found;
1144 }
1145
1146
1147 /*
1148  * initialize the picth control and sample rate
1149  */
1150 static int init_usb_pitch(struct usb_device *dev, int iface,
1151                           struct usb_host_interface *alts,
1152                           struct audioformat *fmt)
1153 {
1154         unsigned int ep;
1155         unsigned char data[1];
1156         int err;
1157
1158         ep = get_endpoint(alts, 0)->bEndpointAddress;
1159         /* if endpoint has pitch control, enable it */
1160         if (fmt->attributes & EP_CS_ATTR_PITCH_CONTROL) {
1161                 data[0] = 1;
1162                 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
1163                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1164                                            PITCH_CONTROL << 8, ep, data, 1, 1000)) < 0) {
1165                         snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n",
1166                                    dev->devnum, iface, ep);
1167                         return err;
1168                 }
1169         }
1170         return 0;
1171 }
1172
1173 static int init_usb_sample_rate(struct usb_device *dev, int iface,
1174                                 struct usb_host_interface *alts,
1175                                 struct audioformat *fmt, int rate)
1176 {
1177         unsigned int ep;
1178         unsigned char data[3];
1179         int err;
1180
1181         ep = get_endpoint(alts, 0)->bEndpointAddress;
1182         /* if endpoint has sampling rate control, set it */
1183         if (fmt->attributes & EP_CS_ATTR_SAMPLE_RATE) {
1184                 int crate;
1185                 data[0] = rate;
1186                 data[1] = rate >> 8;
1187                 data[2] = rate >> 16;
1188                 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
1189                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
1190                                            SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
1191                         snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep 0x%x\n",
1192                                    dev->devnum, iface, fmt->altsetting, rate, ep);
1193                         return err;
1194                 }
1195                 if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR,
1196                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
1197                                            SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
1198                         snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep 0x%x\n",
1199                                    dev->devnum, iface, fmt->altsetting, ep);
1200                         return 0; /* some devices don't support reading */
1201                 }
1202                 crate = data[0] | (data[1] << 8) | (data[2] << 16);
1203                 if (crate != rate) {
1204                         snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);
1205                         // runtime->rate = crate;
1206                 }
1207         }
1208         return 0;
1209 }
1210
1211 /*
1212  * find a matching format and set up the interface
1213  */
1214 static int set_format(snd_usb_substream_t *subs, struct audioformat *fmt)
1215 {
1216         struct usb_device *dev = subs->dev;
1217         struct usb_host_interface *alts;
1218         struct usb_interface_descriptor *altsd;
1219         struct usb_interface *iface;
1220         unsigned int ep, attr;
1221         int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
1222         int err;
1223
1224         iface = usb_ifnum_to_if(dev, fmt->iface);
1225         snd_assert(iface, return -EINVAL);
1226         alts = &iface->altsetting[fmt->altset_idx];
1227         altsd = get_iface_desc(alts);
1228         snd_assert(altsd->bAlternateSetting == fmt->altsetting, return -EINVAL);
1229
1230         if (fmt == subs->cur_audiofmt)
1231                 return 0;
1232
1233         /* close the old interface */
1234         if (subs->interface >= 0 && subs->interface != fmt->iface) {
1235                 usb_set_interface(subs->dev, subs->interface, 0);
1236                 subs->interface = -1;
1237                 subs->format = 0;
1238         }
1239
1240         /* set interface */
1241         if (subs->interface != fmt->iface || subs->format != fmt->altset_idx) {
1242                 if (usb_set_interface(dev, fmt->iface, fmt->altsetting) < 0) {
1243                         snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed\n",
1244                                    dev->devnum, fmt->iface, fmt->altsetting);
1245                         return -EIO;
1246                 }
1247                 snd_printdd(KERN_INFO "setting usb interface %d:%d\n", fmt->iface, fmt->altsetting);
1248                 subs->interface = fmt->iface;
1249                 subs->format = fmt->altset_idx;
1250         }
1251
1252         /* create a data pipe */
1253         ep = fmt->endpoint & USB_ENDPOINT_NUMBER_MASK;
1254         if (is_playback)
1255                 subs->datapipe = usb_sndisocpipe(dev, ep);
1256         else
1257                 subs->datapipe = usb_rcvisocpipe(dev, ep);
1258         if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH &&
1259             get_endpoint(alts, 0)->bInterval >= 1 &&
1260             get_endpoint(alts, 0)->bInterval <= 4)
1261                 subs->datainterval = get_endpoint(alts, 0)->bInterval - 1;
1262         else
1263                 subs->datainterval = 0;
1264         subs->syncpipe = subs->syncinterval = 0;
1265         subs->maxpacksize = fmt->maxpacksize;
1266         subs->fill_max = 0;
1267
1268         /* we need a sync pipe in async OUT or adaptive IN mode */
1269         /* check the number of EP, since some devices have broken
1270          * descriptors which fool us.  if it has only one EP,
1271          * assume it as adaptive-out or sync-in.
1272          */
1273         attr = fmt->ep_attr & EP_ATTR_MASK;
1274         if (((is_playback && attr == EP_ATTR_ASYNC) ||
1275              (! is_playback && attr == EP_ATTR_ADAPTIVE)) &&
1276             altsd->bNumEndpoints >= 2) {
1277                 /* check sync-pipe endpoint */
1278                 /* ... and check descriptor size before accessing bSynchAddress
1279                    because there is a version of the SB Audigy 2 NX firmware lacking
1280                    the audio fields in the endpoint descriptors */
1281                 if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 0x01 ||
1282                     (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1283                      get_endpoint(alts, 1)->bSynchAddress != 0)) {
1284                         snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
1285                                    dev->devnum, fmt->iface, fmt->altsetting);
1286                         return -EINVAL;
1287                 }
1288                 ep = get_endpoint(alts, 1)->bEndpointAddress;
1289                 if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1290                     (( is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
1291                      (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
1292                         snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
1293                                    dev->devnum, fmt->iface, fmt->altsetting);
1294                         return -EINVAL;
1295                 }
1296                 ep &= USB_ENDPOINT_NUMBER_MASK;
1297                 if (is_playback)
1298                         subs->syncpipe = usb_rcvisocpipe(dev, ep);
1299                 else
1300                         subs->syncpipe = usb_sndisocpipe(dev, ep);
1301                 if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
1302                     get_endpoint(alts, 1)->bRefresh >= 1 &&
1303                     get_endpoint(alts, 1)->bRefresh <= 9)
1304                         subs->syncinterval = get_endpoint(alts, 1)->bRefresh;
1305                 else if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
1306                         subs->syncinterval = 1;
1307                 else if (get_endpoint(alts, 1)->bInterval >= 1 &&
1308                          get_endpoint(alts, 1)->bInterval <= 16)
1309                         subs->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
1310                 else
1311                         subs->syncinterval = 3;
1312         }
1313
1314         /* always fill max packet size */
1315         if (fmt->attributes & EP_CS_ATTR_FILL_MAX)
1316                 subs->fill_max = 1;
1317
1318         if ((err = init_usb_pitch(dev, subs->interface, alts, fmt)) < 0)
1319                 return err;
1320
1321         subs->cur_audiofmt = fmt;
1322
1323 #if 0
1324         printk("setting done: format = %d, rate = %d, channels = %d\n",
1325                fmt->format, fmt->rate, fmt->channels);
1326         printk("  datapipe = 0x%0x, syncpipe = 0x%0x\n",
1327                subs->datapipe, subs->syncpipe);
1328 #endif
1329
1330         return 0;
1331 }
1332
1333 /*
1334  * hw_params callback
1335  *
1336  * allocate a buffer and set the given audio format.
1337  *
1338  * so far we use a physically linear buffer although packetize transfer
1339  * doesn't need a continuous area.
1340  * if sg buffer is supported on the later version of alsa, we'll follow
1341  * that.
1342  */
1343 static int snd_usb_hw_params(snd_pcm_substream_t *substream,
1344                              snd_pcm_hw_params_t *hw_params)
1345 {
1346         snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data;
1347         struct audioformat *fmt;
1348         unsigned int channels, rate, format;
1349         int ret, changed;
1350
1351         ret = snd_pcm_alloc_vmalloc_buffer(substream,
1352                                            params_buffer_bytes(hw_params));
1353         if (ret < 0)
1354                 return ret;
1355
1356         format = params_format(hw_params);
1357         rate = params_rate(hw_params);
1358         channels = params_channels(hw_params);
1359         fmt = find_format(subs, format, rate, channels);
1360         if (! fmt) {
1361                 snd_printd(KERN_DEBUG "cannot set format: format = %s, rate = %d, channels = %d\n",
1362                            snd_pcm_format_name(format), rate, channels);
1363                 return -EINVAL;
1364         }
1365
1366         changed = subs->cur_audiofmt != fmt ||
1367                 subs->period_bytes != params_period_bytes(hw_params) ||
1368                 subs->cur_rate != rate;
1369         if ((ret = set_format(subs, fmt)) < 0)
1370                 return ret;
1371
1372         if (subs->cur_rate != rate) {
1373                 struct usb_host_interface *alts;
1374                 struct usb_interface *iface;
1375                 iface = usb_ifnum_to_if(subs->dev, fmt->iface);
1376                 alts = &iface->altsetting[fmt->altset_idx];
1377                 ret = init_usb_sample_rate(subs->dev, subs->interface, alts, fmt, rate);
1378                 if (ret < 0)
1379                         return ret;
1380                 subs->cur_rate = rate;
1381         }
1382
1383         if (changed) {
1384                 /* format changed */
1385                 release_substream_urbs(subs, 0);
1386                 /* influenced: period_bytes, channels, rate, format, */
1387                 ret = init_substream_urbs(subs, params_period_bytes(hw_params),
1388                                           params_rate(hw_params),
1389                                           snd_pcm_format_physical_width(params_format(hw_params)) * params_channels(hw_params));
1390         }
1391
1392         return ret;
1393 }
1394
1395 /*
1396  * hw_free callback
1397  *
1398  * reset the audio format and release the buffer
1399  */
1400 static int snd_usb_hw_free(snd_pcm_substream_t *substream)
1401 {
1402         snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data;
1403
1404         subs->cur_audiofmt = NULL;
1405         subs->cur_rate = 0;
1406         subs->period_bytes = 0;
1407         release_substream_urbs(subs, 0);
1408         return snd_pcm_free_vmalloc_buffer(substream);
1409 }
1410
1411 /*
1412  * prepare callback
1413  *
1414  * only a few subtle things...
1415  */
1416 static int snd_usb_pcm_prepare(snd_pcm_substream_t *substream)
1417 {
1418         snd_pcm_runtime_t *runtime = substream->runtime;
1419         snd_usb_substream_t *subs = (snd_usb_substream_t *)runtime->private_data;
1420
1421         if (! subs->cur_audiofmt) {
1422                 snd_printk(KERN_ERR "usbaudio: no format is specified!\n");
1423                 return -ENXIO;
1424         }
1425
1426         /* some unit conversions in runtime */
1427         subs->maxframesize = bytes_to_frames(runtime, subs->maxpacksize);
1428         subs->curframesize = bytes_to_frames(runtime, subs->curpacksize);
1429
1430         /* reset the pointer */
1431         subs->hwptr_done = 0;
1432         subs->transfer_done = 0;
1433         subs->phase = 0;
1434
1435         /* clear urbs (to be sure) */
1436         deactivate_urbs(subs, 0, 1);
1437         wait_clear_urbs(subs);
1438
1439         return 0;
1440 }
1441
1442 static snd_pcm_hardware_t snd_usb_playback =
1443 {
1444         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1445                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1446                                  SNDRV_PCM_INFO_MMAP_VALID),
1447         .buffer_bytes_max =     (256*1024),
1448         .period_bytes_min =     64,
1449         .period_bytes_max =     (128*1024),
1450         .periods_min =          2,
1451         .periods_max =          1024,
1452 };
1453
1454 static snd_pcm_hardware_t snd_usb_capture =
1455 {
1456         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1457                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1458                                  SNDRV_PCM_INFO_MMAP_VALID),
1459         .buffer_bytes_max =     (256*1024),
1460         .period_bytes_min =     64,
1461         .period_bytes_max =     (128*1024),
1462         .periods_min =          2,
1463         .periods_max =          1024,
1464 };
1465
1466 /*
1467  * h/w constraints
1468  */
1469
1470 #ifdef HW_CONST_DEBUG
1471 #define hwc_debug(fmt, args...) printk(KERN_DEBUG fmt, ##args)
1472 #else
1473 #define hwc_debug(fmt, args...) /**/
1474 #endif
1475
1476 static int hw_check_valid_format(snd_pcm_hw_params_t *params, struct audioformat *fp)
1477 {
1478         snd_interval_t *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1479         snd_interval_t *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
1480         snd_mask_t *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1481
1482         /* check the format */
1483         if (! snd_mask_test(fmts, fp->format)) {
1484                 hwc_debug("   > check: no supported format %d\n", fp->format);
1485                 return 0;
1486         }
1487         /* check the channels */
1488         if (fp->channels < ct->min || fp->channels > ct->max) {
1489                 hwc_debug("   > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max);
1490                 return 0;
1491         }
1492         /* check the rate is within the range */
1493         if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) {
1494                 hwc_debug("   > check: rate_min %d > max %d\n", fp->rate_min, it->max);
1495                 return 0;
1496         }
1497         if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) {
1498                 hwc_debug("   > check: rate_max %d < min %d\n", fp->rate_max, it->min);
1499                 return 0;
1500         }
1501         return 1;
1502 }
1503
1504 static int hw_rule_rate(snd_pcm_hw_params_t *params,
1505                         snd_pcm_hw_rule_t *rule)
1506 {
1507         snd_usb_substream_t *subs = rule->private;
1508         struct list_head *p;
1509         snd_interval_t *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1510         unsigned int rmin, rmax;
1511         int changed;
1512
1513         hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max);
1514         changed = 0;
1515         rmin = rmax = 0;
1516         list_for_each(p, &subs->fmt_list) {
1517                 struct audioformat *fp;
1518                 fp = list_entry(p, struct audioformat, list);
1519                 if (! hw_check_valid_format(params, fp))
1520                         continue;
1521                 if (changed++) {
1522                         if (rmin > fp->rate_min)
1523                                 rmin = fp->rate_min;
1524                         if (rmax < fp->rate_max)
1525                                 rmax = fp->rate_max;
1526                 } else {
1527                         rmin = fp->rate_min;
1528                         rmax = fp->rate_max;
1529                 }
1530         }
1531
1532         if (! changed) {
1533                 hwc_debug("  --> get empty\n");
1534                 it->empty = 1;
1535                 return -EINVAL;
1536         }
1537
1538         changed = 0;
1539         if (it->min < rmin) {
1540                 it->min = rmin;
1541                 it->openmin = 0;
1542                 changed = 1;
1543         }
1544         if (it->max > rmax) {
1545                 it->max = rmax;
1546                 it->openmax = 0;
1547                 changed = 1;
1548         }
1549         if (snd_interval_checkempty(it)) {
1550                 it->empty = 1;
1551                 return -EINVAL;
1552         }
1553         hwc_debug("  --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
1554         return changed;
1555 }
1556
1557
1558 static int hw_rule_channels(snd_pcm_hw_params_t *params,
1559                             snd_pcm_hw_rule_t *rule)
1560 {
1561         snd_usb_substream_t *subs = rule->private;
1562         struct list_head *p;
1563         snd_interval_t *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
1564         unsigned int rmin, rmax;
1565         int changed;
1566
1567         hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max);
1568         changed = 0;
1569         rmin = rmax = 0;
1570         list_for_each(p, &subs->fmt_list) {
1571                 struct audioformat *fp;
1572                 fp = list_entry(p, struct audioformat, list);
1573                 if (! hw_check_valid_format(params, fp))
1574                         continue;
1575                 if (changed++) {
1576                         if (rmin > fp->channels)
1577                                 rmin = fp->channels;
1578                         if (rmax < fp->channels)
1579                                 rmax = fp->channels;
1580                 } else {
1581                         rmin = fp->channels;
1582                         rmax = fp->channels;
1583                 }
1584         }
1585
1586         if (! changed) {
1587                 hwc_debug("  --> get empty\n");
1588                 it->empty = 1;
1589                 return -EINVAL;
1590         }
1591
1592         changed = 0;
1593         if (it->min < rmin) {
1594                 it->min = rmin;
1595                 it->openmin = 0;
1596                 changed = 1;
1597         }
1598         if (it->max > rmax) {
1599                 it->max = rmax;
1600                 it->openmax = 0;
1601                 changed = 1;
1602         }
1603         if (snd_interval_checkempty(it)) {
1604                 it->empty = 1;
1605                 return -EINVAL;
1606         }
1607         hwc_debug("  --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
1608         return changed;
1609 }
1610
1611 static int hw_rule_format(snd_pcm_hw_params_t *params,
1612                           snd_pcm_hw_rule_t *rule)
1613 {
1614         snd_usb_substream_t *subs = rule->private;
1615         struct list_head *p;
1616         snd_mask_t *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1617         u64 fbits;
1618         u32 oldbits[2];
1619         int changed;
1620
1621         hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]);
1622         fbits = 0;
1623         list_for_each(p, &subs->fmt_list) {
1624                 struct audioformat *fp;
1625                 fp = list_entry(p, struct audioformat, list);
1626                 if (! hw_check_valid_format(params, fp))
1627                         continue;
1628                 fbits |= (1ULL << fp->format);
1629         }
1630
1631         oldbits[0] = fmt->bits[0];
1632         oldbits[1] = fmt->bits[1];
1633         fmt->bits[0] &= (u32)fbits;
1634         fmt->bits[1] &= (u32)(fbits >> 32);
1635         if (! fmt->bits[0] && ! fmt->bits[1]) {
1636                 hwc_debug("  --> get empty\n");
1637                 return -EINVAL;
1638         }
1639         changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]);
1640         hwc_debug("  --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed);
1641         return changed;
1642 }
1643
1644 #define MAX_MASK        64
1645
1646 /*
1647  * check whether the registered audio formats need special hw-constraints
1648  */
1649 static int check_hw_params_convention(snd_usb_substream_t *subs)
1650 {
1651         int i;
1652         u32 *channels;
1653         u32 *rates;
1654         u32 cmaster, rmaster;
1655         u32 rate_min = 0, rate_max = 0;
1656         struct list_head *p;
1657         int err = 1;
1658
1659         channels = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
1660         rates = kcalloc(MAX_MASK, sizeof(u32), GFP_KERNEL);
1661
1662         list_for_each(p, &subs->fmt_list) {
1663                 struct audioformat *f;
1664                 f = list_entry(p, struct audioformat, list);
1665                 /* unconventional channels? */
1666                 if (f->channels > 32)
1667                         goto __out;
1668                 /* continuous rate min/max matches? */
1669                 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) {
1670                         if (rate_min && f->rate_min != rate_min)
1671                                 goto __out;
1672                         if (rate_max && f->rate_max != rate_max)
1673                                 goto __out;
1674                         rate_min = f->rate_min;
1675                         rate_max = f->rate_max;
1676                 }
1677                 /* combination of continuous rates and fixed rates? */
1678                 if (rates[f->format] & SNDRV_PCM_RATE_CONTINUOUS) {
1679                         if (f->rates != rates[f->format])
1680                                 goto __out;
1681                 }
1682                 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS) {
1683                         if (rates[f->format] && rates[f->format] != f->rates)
1684                                 goto __out;
1685                 }
1686                 channels[f->format] |= (1 << f->channels);
1687                 rates[f->format] |= f->rates;
1688         }
1689         /* check whether channels and rates match for all formats */
1690         cmaster = rmaster = 0;
1691         for (i = 0; i < MAX_MASK; i++) {
1692                 if (cmaster != channels[i] && cmaster && channels[i])
1693                         goto __out;
1694                 if (rmaster != rates[i] && rmaster && rates[i])
1695                         goto __out;
1696                 if (channels[i])
1697                         cmaster = channels[i];
1698                 if (rates[i])
1699                         rmaster = rates[i];
1700         }
1701         /* check whether channels match for all distinct rates */
1702         memset(channels, 0, MAX_MASK * sizeof(u32));
1703         list_for_each(p, &subs->fmt_list) {
1704                 struct audioformat *f;
1705                 f = list_entry(p, struct audioformat, list);
1706                 if (f->rates & SNDRV_PCM_RATE_CONTINUOUS)
1707                         continue;
1708                 for (i = 0; i < 32; i++) {
1709                         if (f->rates & (1 << i))
1710                                 channels[i] |= (1 << f->channels);
1711                 }
1712         }
1713         cmaster = 0;
1714         for (i = 0; i < 32; i++) {
1715                 if (cmaster != channels[i] && cmaster && channels[i])
1716                         goto __out;
1717                 if (channels[i])
1718                         cmaster = channels[i];
1719         }
1720         err = 0;
1721
1722  __out:
1723         kfree(channels);
1724         kfree(rates);
1725         return err;
1726 }
1727
1728
1729 /*
1730  * set up the runtime hardware information.
1731  */
1732
1733 static int setup_hw_info(snd_pcm_runtime_t *runtime, snd_usb_substream_t *subs)
1734 {
1735         struct list_head *p;
1736         int err;
1737
1738         runtime->hw.formats = subs->formats;
1739
1740         runtime->hw.rate_min = 0x7fffffff;
1741         runtime->hw.rate_max = 0;
1742         runtime->hw.channels_min = 256;
1743         runtime->hw.channels_max = 0;
1744         runtime->hw.rates = 0;
1745         /* check min/max rates and channels */
1746         list_for_each(p, &subs->fmt_list) {
1747                 struct audioformat *fp;
1748                 fp = list_entry(p, struct audioformat, list);
1749                 runtime->hw.rates |= fp->rates;
1750                 if (runtime->hw.rate_min > fp->rate_min)
1751                         runtime->hw.rate_min = fp->rate_min;
1752                 if (runtime->hw.rate_max < fp->rate_max)
1753                         runtime->hw.rate_max = fp->rate_max;
1754                 if (runtime->hw.channels_min > fp->channels)
1755                         runtime->hw.channels_min = fp->channels;
1756                 if (runtime->hw.channels_max < fp->channels)
1757                         runtime->hw.channels_max = fp->channels;
1758                 if (fp->fmt_type == USB_FORMAT_TYPE_II && fp->frame_size > 0) {
1759                         /* FIXME: there might be more than one audio formats... */
1760                         runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
1761                                 fp->frame_size;
1762                 }
1763         }
1764
1765         /* set the period time minimum 1ms */
1766         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1767                                      1000 * MIN_PACKS_URB,
1768                                      /*(nrpacks * MAX_URBS) * 1000*/ UINT_MAX);
1769
1770         if (check_hw_params_convention(subs)) {
1771                 hwc_debug("setting extra hw constraints...\n");
1772                 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
1773                                                hw_rule_rate, subs,
1774                                                SNDRV_PCM_HW_PARAM_FORMAT,
1775                                                SNDRV_PCM_HW_PARAM_CHANNELS,
1776                                                -1)) < 0)
1777                         return err;
1778                 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
1779                                                hw_rule_channels, subs,
1780                                                SNDRV_PCM_HW_PARAM_FORMAT,
1781                                                SNDRV_PCM_HW_PARAM_RATE,
1782                                                -1)) < 0)
1783                         return err;
1784                 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
1785                                                hw_rule_format, subs,
1786                                                SNDRV_PCM_HW_PARAM_RATE,
1787                                                SNDRV_PCM_HW_PARAM_CHANNELS,
1788                                                -1)) < 0)
1789                         return err;
1790         }
1791         return 0;
1792 }
1793
1794 static int snd_usb_pcm_open(snd_pcm_substream_t *substream, int direction,
1795                             snd_pcm_hardware_t *hw)
1796 {
1797         snd_usb_stream_t *as = snd_pcm_substream_chip(substream);
1798         snd_pcm_runtime_t *runtime = substream->runtime;
1799         snd_usb_substream_t *subs = &as->substream[direction];
1800
1801         subs->interface = -1;
1802         subs->format = 0;
1803         runtime->hw = *hw;
1804         runtime->private_data = subs;
1805         subs->pcm_substream = substream;
1806         return setup_hw_info(runtime, subs);
1807 }
1808
1809 static int snd_usb_pcm_close(snd_pcm_substream_t *substream, int direction)
1810 {
1811         snd_usb_stream_t *as = snd_pcm_substream_chip(substream);
1812         snd_usb_substream_t *subs = &as->substream[direction];
1813
1814         if (subs->interface >= 0) {
1815                 usb_set_interface(subs->dev, subs->interface, 0);
1816                 subs->interface = -1;
1817         }
1818         subs->pcm_substream = NULL;
1819         return 0;
1820 }
1821
1822 static int snd_usb_playback_open(snd_pcm_substream_t *substream)
1823 {
1824         return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK, &snd_usb_playback);
1825 }
1826
1827 static int snd_usb_playback_close(snd_pcm_substream_t *substream)
1828 {
1829         return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK);
1830 }
1831
1832 static int snd_usb_capture_open(snd_pcm_substream_t *substream)
1833 {
1834         return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE, &snd_usb_capture);
1835 }
1836
1837 static int snd_usb_capture_close(snd_pcm_substream_t *substream)
1838 {
1839         return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE);
1840 }
1841
1842 static snd_pcm_ops_t snd_usb_playback_ops = {
1843         .open =         snd_usb_playback_open,
1844         .close =        snd_usb_playback_close,
1845         .ioctl =        snd_pcm_lib_ioctl,
1846         .hw_params =    snd_usb_hw_params,
1847         .hw_free =      snd_usb_hw_free,
1848         .prepare =      snd_usb_pcm_prepare,
1849         .trigger =      snd_usb_pcm_trigger,
1850         .pointer =      snd_usb_pcm_pointer,
1851         .page =         snd_pcm_get_vmalloc_page,
1852 };
1853
1854 static snd_pcm_ops_t snd_usb_capture_ops = {
1855         .open =         snd_usb_capture_open,
1856         .close =        snd_usb_capture_close,
1857         .ioctl =        snd_pcm_lib_ioctl,
1858         .hw_params =    snd_usb_hw_params,
1859         .hw_free =      snd_usb_hw_free,
1860         .prepare =      snd_usb_pcm_prepare,
1861         .trigger =      snd_usb_pcm_trigger,
1862         .pointer =      snd_usb_pcm_pointer,
1863         .page =         snd_pcm_get_vmalloc_page,
1864 };
1865
1866
1867
1868 /*
1869  * helper functions
1870  */
1871
1872 /*
1873  * combine bytes and get an integer value
1874  */
1875 unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size)
1876 {
1877         switch (size) {
1878         case 1:  return *bytes;
1879         case 2:  return combine_word(bytes);
1880         case 3:  return combine_triple(bytes);
1881         case 4:  return combine_quad(bytes);
1882         default: return 0;
1883         }
1884 }
1885
1886 /*
1887  * parse descriptor buffer and return the pointer starting the given
1888  * descriptor type.
1889  */
1890 void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype)
1891 {
1892         u8 *p, *end, *next;
1893
1894         p = descstart;
1895         end = p + desclen;
1896         for (; p < end;) {
1897                 if (p[0] < 2)
1898                         return NULL;
1899                 next = p + p[0];
1900                 if (next > end)
1901                         return NULL;
1902                 if (p[1] == dtype && (!after || (void *)p > after)) {
1903                         return p;
1904                 }
1905                 p = next;
1906         }
1907         return NULL;
1908 }
1909
1910 /*
1911  * find a class-specified interface descriptor with the given subtype.
1912  */
1913 void *snd_usb_find_csint_desc(void *buffer, int buflen, void *after, u8 dsubtype)
1914 {
1915         unsigned char *p = after;
1916
1917         while ((p = snd_usb_find_desc(buffer, buflen, p,
1918                                       USB_DT_CS_INTERFACE)) != NULL) {
1919                 if (p[0] >= 3 && p[2] == dsubtype)
1920                         return p;
1921         }
1922         return NULL;
1923 }
1924
1925 /*
1926  * Wrapper for usb_control_msg().
1927  * Allocates a temp buffer to prevent dmaing from/to the stack.
1928  */
1929 int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
1930                     __u8 requesttype, __u16 value, __u16 index, void *data,
1931                     __u16 size, int timeout)
1932 {
1933         int err;
1934         void *buf = NULL;
1935
1936         if (size > 0) {
1937                 buf = kmalloc(size, GFP_KERNEL);
1938                 if (!buf)
1939                         return -ENOMEM;
1940                 memcpy(buf, data, size);
1941         }
1942         err = usb_control_msg(dev, pipe, request, requesttype,
1943                               value, index, buf, size, timeout);
1944         if (size > 0) {
1945                 memcpy(data, buf, size);
1946                 kfree(buf);
1947         }
1948         return err;
1949 }
1950
1951
1952 /*
1953  * entry point for linux usb interface
1954  */
1955
1956 static int usb_audio_probe(struct usb_interface *intf,
1957                            const struct usb_device_id *id);
1958 static void usb_audio_disconnect(struct usb_interface *intf);
1959
1960 static struct usb_device_id usb_audio_ids [] = {
1961 #include "usbquirks.h"
1962     { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
1963       .bInterfaceClass = USB_CLASS_AUDIO,
1964       .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL },
1965     { }                                         /* Terminating entry */
1966 };
1967
1968 MODULE_DEVICE_TABLE (usb, usb_audio_ids);
1969
1970 static struct usb_driver usb_audio_driver = {
1971         .owner =        THIS_MODULE,
1972         .name =         "snd-usb-audio",
1973         .probe =        usb_audio_probe,
1974         .disconnect =   usb_audio_disconnect,
1975         .id_table =     usb_audio_ids,
1976 };
1977
1978
1979 /*
1980  * proc interface for list the supported pcm formats
1981  */
1982 static void proc_dump_substream_formats(snd_usb_substream_t *subs, snd_info_buffer_t *buffer)
1983 {
1984         struct list_head *p;
1985         static char *sync_types[4] = {
1986                 "NONE", "ASYNC", "ADAPTIVE", "SYNC"
1987         };
1988
1989         list_for_each(p, &subs->fmt_list) {
1990                 struct audioformat *fp;
1991                 fp = list_entry(p, struct audioformat, list);
1992                 snd_iprintf(buffer, "  Interface %d\n", fp->iface);
1993                 snd_iprintf(buffer, "    Altset %d\n", fp->altsetting);
1994                 snd_iprintf(buffer, "    Format: %s\n", snd_pcm_format_name(fp->format));
1995                 snd_iprintf(buffer, "    Channels: %d\n", fp->channels);
1996                 snd_iprintf(buffer, "    Endpoint: %d %s (%s)\n",
1997                             fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
1998                             fp->endpoint & USB_DIR_IN ? "IN" : "OUT",
1999                             sync_types[(fp->ep_attr & EP_ATTR_MASK) >> 2]);
2000                 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) {
2001                         snd_iprintf(buffer, "    Rates: %d - %d (continuous)\n",
2002                                     fp->rate_min, fp->rate_max);
2003                 } else {
2004                         unsigned int i;
2005                         snd_iprintf(buffer, "    Rates: ");
2006                         for (i = 0; i < fp->nr_rates; i++) {
2007                                 if (i > 0)
2008                                         snd_iprintf(buffer, ", ");
2009                                 snd_iprintf(buffer, "%d", fp->rate_table[i]);
2010                         }
2011                         snd_iprintf(buffer, "\n");
2012                 }
2013                 // snd_iprintf(buffer, "    Max Packet Size = %d\n", fp->maxpacksize);
2014                 // snd_iprintf(buffer, "    EP Attribute = 0x%x\n", fp->attributes);
2015         }
2016 }
2017
2018 static void proc_dump_substream_status(snd_usb_substream_t *subs, snd_info_buffer_t *buffer)
2019 {
2020         if (subs->running) {
2021                 unsigned int i;
2022                 snd_iprintf(buffer, "  Status: Running\n");
2023                 snd_iprintf(buffer, "    Interface = %d\n", subs->interface);
2024                 snd_iprintf(buffer, "    Altset = %d\n", subs->format);
2025                 snd_iprintf(buffer, "    URBs = %d [ ", subs->nurbs);
2026                 for (i = 0; i < subs->nurbs; i++)
2027                         snd_iprintf(buffer, "%d ", subs->dataurb[i].packets);
2028                 snd_iprintf(buffer, "]\n");
2029                 snd_iprintf(buffer, "    Packet Size = %d\n", subs->curpacksize);
2030                 snd_iprintf(buffer, "    Momentary freq = %u Hz (%#x.%04x)\n",
2031                             snd_usb_get_speed(subs->dev) == USB_SPEED_FULL
2032                             ? get_full_speed_hz(subs->freqm)
2033                             : get_high_speed_hz(subs->freqm),
2034                             subs->freqm >> 16, subs->freqm & 0xffff);
2035         } else {
2036                 snd_iprintf(buffer, "  Status: Stop\n");
2037         }
2038 }
2039
2040 static void proc_pcm_format_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
2041 {
2042         snd_usb_stream_t *stream = entry->private_data;
2043
2044         snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name);
2045
2046         if (stream->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats) {
2047                 snd_iprintf(buffer, "\nPlayback:\n");
2048                 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
2049                 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
2050         }
2051         if (stream->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats) {
2052                 snd_iprintf(buffer, "\nCapture:\n");
2053                 proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
2054                 proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
2055         }
2056 }
2057
2058 static void proc_pcm_format_add(snd_usb_stream_t *stream)
2059 {
2060         snd_info_entry_t *entry;
2061         char name[32];
2062         snd_card_t *card = stream->chip->card;
2063
2064         sprintf(name, "stream%d", stream->pcm_index);
2065         if (! snd_card_proc_new(card, name, &entry))
2066                 snd_info_set_text_ops(entry, stream, 1024, proc_pcm_format_read);
2067 }
2068
2069
2070 /*
2071  * initialize the substream instance.
2072  */
2073
2074 static void init_substream(snd_usb_stream_t *as, int stream, struct audioformat *fp)
2075 {
2076         snd_usb_substream_t *subs = &as->substream[stream];
2077
2078         INIT_LIST_HEAD(&subs->fmt_list);
2079         spin_lock_init(&subs->lock);
2080         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
2081                 tasklet_init(&subs->start_period_elapsed, start_period_elapsed,
2082                              (unsigned long)subs);
2083
2084         subs->stream = as;
2085         subs->direction = stream;
2086         subs->dev = as->chip->dev;
2087         if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
2088                 subs->ops = audio_urb_ops[stream];
2089         else
2090                 subs->ops = audio_urb_ops_high_speed[stream];
2091         snd_pcm_set_ops(as->pcm, stream,
2092                         stream == SNDRV_PCM_STREAM_PLAYBACK ?
2093                         &snd_usb_playback_ops : &snd_usb_capture_ops);
2094
2095         list_add_tail(&fp->list, &subs->fmt_list);
2096         subs->formats |= 1ULL << fp->format;
2097         subs->endpoint = fp->endpoint;
2098         subs->num_formats++;
2099         subs->fmt_type = fp->fmt_type;
2100 }
2101
2102
2103 /*
2104  * free a substream
2105  */
2106 static void free_substream(snd_usb_substream_t *subs)
2107 {
2108         struct list_head *p, *n;
2109
2110         if (! subs->num_formats)
2111                 return; /* not initialized */
2112         list_for_each_safe(p, n, &subs->fmt_list) {
2113                 struct audioformat *fp = list_entry(p, struct audioformat, list);
2114                 kfree(fp->rate_table);
2115                 kfree(fp);
2116         }
2117 }
2118
2119
2120 /*
2121  * free a usb stream instance
2122  */
2123 static void snd_usb_audio_stream_free(snd_usb_stream_t *stream)
2124 {
2125         free_substream(&stream->substream[0]);
2126         free_substream(&stream->substream[1]);
2127         list_del(&stream->list);
2128         kfree(stream);
2129 }
2130
2131 static void snd_usb_audio_pcm_free(snd_pcm_t *pcm)
2132 {
2133         snd_usb_stream_t *stream = pcm->private_data;
2134         if (stream) {
2135                 stream->pcm = NULL;
2136                 snd_usb_audio_stream_free(stream);
2137         }
2138 }
2139
2140
2141 /*
2142  * add this endpoint to the chip instance.
2143  * if a stream with the same endpoint already exists, append to it.
2144  * if not, create a new pcm stream.
2145  */
2146 static int add_audio_endpoint(snd_usb_audio_t *chip, int stream, struct audioformat *fp)
2147 {
2148         struct list_head *p;
2149         snd_usb_stream_t *as;
2150         snd_usb_substream_t *subs;
2151         snd_pcm_t *pcm;
2152         int err;
2153
2154         list_for_each(p, &chip->pcm_list) {
2155                 as = list_entry(p, snd_usb_stream_t, list);
2156                 if (as->fmt_type != fp->fmt_type)
2157                         continue;
2158                 subs = &as->substream[stream];
2159                 if (! subs->endpoint)
2160                         continue;
2161                 if (subs->endpoint == fp->endpoint) {
2162                         list_add_tail(&fp->list, &subs->fmt_list);
2163                         subs->num_formats++;
2164                         subs->formats |= 1ULL << fp->format;
2165                         return 0;
2166                 }
2167         }
2168         /* look for an empty stream */
2169         list_for_each(p, &chip->pcm_list) {
2170                 as = list_entry(p, snd_usb_stream_t, list);
2171                 if (as->fmt_type != fp->fmt_type)
2172                         continue;
2173                 subs = &as->substream[stream];
2174                 if (subs->endpoint)
2175                         continue;
2176                 err = snd_pcm_new_stream(as->pcm, stream, 1);
2177                 if (err < 0)
2178                         return err;
2179                 init_substream(as, stream, fp);
2180                 return 0;
2181         }
2182
2183         /* create a new pcm */
2184         as = kmalloc(sizeof(*as), GFP_KERNEL);
2185         if (! as)
2186                 return -ENOMEM;
2187         memset(as, 0, sizeof(*as));
2188         as->pcm_index = chip->pcm_devs;
2189         as->chip = chip;
2190         as->fmt_type = fp->fmt_type;
2191         err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs,
2192                           stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0,
2193                           stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1,
2194                           &pcm);
2195         if (err < 0) {
2196                 kfree(as);
2197                 return err;
2198         }
2199         as->pcm = pcm;
2200         pcm->private_data = as;
2201         pcm->private_free = snd_usb_audio_pcm_free;
2202         pcm->info_flags = 0;
2203         if (chip->pcm_devs > 0)
2204                 sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs);
2205         else
2206                 strcpy(pcm->name, "USB Audio");
2207
2208         init_substream(as, stream, fp);
2209
2210         list_add(&as->list, &chip->pcm_list);
2211         chip->pcm_devs++;
2212
2213         proc_pcm_format_add(as);
2214
2215         return 0;
2216 }
2217
2218
2219 /*
2220  * check if the device uses big-endian samples
2221  */
2222 static int is_big_endian_format(snd_usb_audio_t *chip, struct audioformat *fp)
2223 {
2224         switch (chip->usb_id) {
2225         case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
2226                 if (fp->endpoint & USB_DIR_IN)
2227                         return 1;
2228                 break;
2229         case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
2230                 return 1;
2231         }
2232         return 0;
2233 }
2234
2235 /*
2236  * parse the audio format type I descriptor
2237  * and returns the corresponding pcm format
2238  *
2239  * @dev: usb device
2240  * @fp: audioformat record
2241  * @format: the format tag (wFormatTag)
2242  * @fmt: the format type descriptor
2243  */
2244 static int parse_audio_format_i_type(snd_usb_audio_t *chip, struct audioformat *fp,
2245                                      int format, unsigned char *fmt)
2246 {
2247         int pcm_format;
2248         int sample_width, sample_bytes;
2249
2250         /* FIXME: correct endianess and sign? */
2251         pcm_format = -1;
2252         sample_width = fmt[6];
2253         sample_bytes = fmt[5];
2254         switch (format) {
2255         case 0: /* some devices don't define this correctly... */
2256                 snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n",
2257                             chip->dev->devnum, fp->iface, fp->altsetting);
2258                 /* fall-through */
2259         case USB_AUDIO_FORMAT_PCM:
2260                 if (sample_width > sample_bytes * 8) {
2261                         snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n",
2262                                    chip->dev->devnum, fp->iface, fp->altsetting,
2263                                    sample_width, sample_bytes);
2264                 }
2265                 /* check the format byte size */
2266                 switch (fmt[5]) {
2267                 case 1:
2268                         pcm_format = SNDRV_PCM_FORMAT_S8;
2269                         break;
2270                 case 2:
2271                         if (is_big_endian_format(chip, fp))
2272                                 pcm_format = SNDRV_PCM_FORMAT_S16_BE; /* grrr, big endian!! */
2273                         else
2274                                 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
2275                         break;
2276                 case 3:
2277                         if (is_big_endian_format(chip, fp))
2278                                 pcm_format = SNDRV_PCM_FORMAT_S24_3BE; /* grrr, big endian!! */
2279                         else
2280                                 pcm_format = SNDRV_PCM_FORMAT_S24_3LE;
2281                         break;
2282                 case 4:
2283                         pcm_format = SNDRV_PCM_FORMAT_S32_LE;
2284                         break;
2285                 default:
2286                         snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",
2287                                    chip->dev->devnum, fp->iface,
2288                                    fp->altsetting, sample_width, sample_bytes);
2289                         break;
2290                 }
2291                 break;
2292         case USB_AUDIO_FORMAT_PCM8:
2293                 /* Dallas DS4201 workaround */
2294                 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
2295                         pcm_format = SNDRV_PCM_FORMAT_S8;
2296                 else
2297                         pcm_format = SNDRV_PCM_FORMAT_U8;
2298                 break;
2299         case USB_AUDIO_FORMAT_IEEE_FLOAT:
2300                 pcm_format = SNDRV_PCM_FORMAT_FLOAT_LE;
2301                 break;
2302         case USB_AUDIO_FORMAT_ALAW:
2303                 pcm_format = SNDRV_PCM_FORMAT_A_LAW;
2304                 break;
2305         case USB_AUDIO_FORMAT_MU_LAW:
2306                 pcm_format = SNDRV_PCM_FORMAT_MU_LAW;
2307                 break;
2308         default:
2309                 snd_printk(KERN_INFO "%d:%u:%d : unsupported format type %d\n",
2310                            chip->dev->devnum, fp->iface, fp->altsetting, format);
2311                 break;
2312         }
2313         return pcm_format;
2314 }
2315
2316
2317 /*
2318  * parse the format descriptor and stores the possible sample rates
2319  * on the audioformat table.
2320  *
2321  * @dev: usb device
2322  * @fp: audioformat record
2323  * @fmt: the format descriptor
2324  * @offset: the start offset of descriptor pointing the rate type
2325  *          (7 for type I and II, 8 for type II)
2326  */
2327 static int parse_audio_format_rates(snd_usb_audio_t *chip, struct audioformat *fp,
2328                                     unsigned char *fmt, int offset)
2329 {
2330         int nr_rates = fmt[offset];
2331         if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {
2332                 snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
2333                                    chip->dev->devnum, fp->iface, fp->altsetting);
2334                 return -1;
2335         }
2336
2337         if (nr_rates) {
2338                 /*
2339                  * build the rate table and bitmap flags
2340                  */
2341                 int r, idx, c;
2342                 /* this table corresponds to the SNDRV_PCM_RATE_XXX bit */
2343                 static unsigned int conv_rates[] = {
2344                         5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000,
2345                         64000, 88200, 96000, 176400, 192000
2346                 };
2347                 fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
2348                 if (fp->rate_table == NULL) {
2349                         snd_printk(KERN_ERR "cannot malloc\n");
2350                         return -1;
2351                 }
2352
2353                 fp->nr_rates = nr_rates;
2354                 fp->rate_min = fp->rate_max = combine_triple(&fmt[8]);
2355                 for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) {
2356                         unsigned int rate = fp->rate_table[r] = combine_triple(&fmt[idx]);
2357                         if (rate < fp->rate_min)
2358                                 fp->rate_min = rate;
2359                         else if (rate > fp->rate_max)
2360                                 fp->rate_max = rate;
2361                         for (c = 0; c < (int)ARRAY_SIZE(conv_rates); c++) {
2362                                 if (rate == conv_rates[c]) {
2363                                         fp->rates |= (1 << c);
2364                                         break;
2365                                 }
2366                         }
2367                 }
2368         } else {
2369                 /* continuous rates */
2370                 fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
2371                 fp->rate_min = combine_triple(&fmt[offset + 1]);
2372                 fp->rate_max = combine_triple(&fmt[offset + 4]);
2373         }
2374         return 0;
2375 }
2376
2377 /*
2378  * parse the format type I and III descriptors
2379  */
2380 static int parse_audio_format_i(snd_usb_audio_t *chip, struct audioformat *fp,
2381                                 int format, unsigned char *fmt)
2382 {
2383         int pcm_format;
2384
2385         if (fmt[3] == USB_FORMAT_TYPE_III) {
2386                 /* FIXME: the format type is really IECxxx
2387                  *        but we give normal PCM format to get the existing
2388                  *        apps working...
2389                  */
2390                 pcm_format = SNDRV_PCM_FORMAT_S16_LE;
2391         } else {
2392                 pcm_format = parse_audio_format_i_type(chip, fp, format, fmt);
2393                 if (pcm_format < 0)
2394                         return -1;
2395         }
2396         fp->format = pcm_format;
2397         fp->channels = fmt[4];
2398         if (fp->channels < 1) {
2399                 snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",
2400                            chip->dev->devnum, fp->iface, fp->altsetting, fp->channels);
2401                 return -1;
2402         }
2403         return parse_audio_format_rates(chip, fp, fmt, 7);
2404 }
2405
2406 /*
2407  * prase the format type II descriptor
2408  */
2409 static int parse_audio_format_ii(snd_usb_audio_t *chip, struct audioformat *fp,
2410                                  int format, unsigned char *fmt)
2411 {
2412         int brate, framesize;
2413         switch (format) {
2414         case USB_AUDIO_FORMAT_AC3:
2415                 /* FIXME: there is no AC3 format defined yet */
2416                 // fp->format = SNDRV_PCM_FORMAT_AC3;
2417                 fp->format = SNDRV_PCM_FORMAT_U8; /* temporarily hack to receive byte streams */
2418                 break;
2419         case USB_AUDIO_FORMAT_MPEG:
2420                 fp->format = SNDRV_PCM_FORMAT_MPEG;
2421                 break;
2422         default:
2423                 snd_printd(KERN_INFO "%d:%u:%d : unknown format tag 0x%x is detected.  processed as MPEG.\n",
2424                            chip->dev->devnum, fp->iface, fp->altsetting, format);
2425                 fp->format = SNDRV_PCM_FORMAT_MPEG;
2426                 break;
2427         }
2428         fp->channels = 1;
2429         brate = combine_word(&fmt[4]);  /* fmt[4,5] : wMaxBitRate (in kbps) */
2430         framesize = combine_word(&fmt[6]); /* fmt[6,7]: wSamplesPerFrame */
2431         snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
2432         fp->frame_size = framesize;
2433         return parse_audio_format_rates(chip, fp, fmt, 8); /* fmt[8..] sample rates */
2434 }
2435
2436 static int parse_audio_format(snd_usb_audio_t *chip, struct audioformat *fp,
2437                               int format, unsigned char *fmt, int stream)
2438 {
2439         int err;
2440
2441         switch (fmt[3]) {
2442         case USB_FORMAT_TYPE_I:
2443         case USB_FORMAT_TYPE_III:
2444                 err = parse_audio_format_i(chip, fp, format, fmt);
2445                 break;
2446         case USB_FORMAT_TYPE_II:
2447                 err = parse_audio_format_ii(chip, fp, format, fmt);
2448                 break;
2449         default:
2450                 snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",
2451                            chip->dev->devnum, fp->iface, fp->altsetting, fmt[3]);
2452                 return -1;
2453         }
2454         fp->fmt_type = fmt[3];
2455         if (err < 0)
2456                 return err;
2457 #if 1
2458         /* FIXME: temporary hack for extigy/audigy 2 nx */
2459         /* extigy apparently supports sample rates other than 48k
2460          * but not in ordinary way.  so we enable only 48k atm.
2461          */
2462         if (chip->usb_id == USB_ID(0x041e, 0x3000) ||
2463             chip->usb_id == USB_ID(0x041e, 0x3020)) {
2464                 if (fmt[3] == USB_FORMAT_TYPE_I &&
2465                     fp->rates != SNDRV_PCM_RATE_48000 &&
2466                     fp->rates != SNDRV_PCM_RATE_96000)
2467                         return -1;
2468         }
2469 #endif
2470         return 0;
2471 }
2472
2473 static int parse_audio_endpoints(snd_usb_audio_t *chip, int iface_no)
2474 {
2475         struct usb_device *dev;
2476         struct usb_interface *iface;
2477         struct usb_host_interface *alts;
2478         struct usb_interface_descriptor *altsd;
2479         int i, altno, err, stream;
2480         int format;
2481         struct audioformat *fp;
2482         unsigned char *fmt, *csep;
2483
2484         dev = chip->dev;
2485
2486         /* parse the interface's altsettings */
2487         iface = usb_ifnum_to_if(dev, iface_no);
2488         for (i = 0; i < iface->num_altsetting; i++) {
2489                 alts = &iface->altsetting[i];
2490                 altsd = get_iface_desc(alts);
2491                 /* skip invalid one */
2492                 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
2493                      altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
2494                     (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING &&
2495                      altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC) ||
2496                     altsd->bNumEndpoints < 1 ||
2497                     le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
2498                         continue;
2499                 /* must be isochronous */
2500                 if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
2501                     USB_ENDPOINT_XFER_ISOC)
2502                         continue;
2503                 /* check direction */
2504                 stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ?
2505                         SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2506                 altno = altsd->bAlternateSetting;
2507
2508                 /* get audio formats */
2509                 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, AS_GENERAL);
2510                 if (!fmt) {
2511                         snd_printk(KERN_ERR "%d:%u:%d : AS_GENERAL descriptor not found\n",
2512                                    dev->devnum, iface_no, altno);
2513                         continue;
2514                 }
2515
2516                 if (fmt[0] < 7) {
2517                         snd_printk(KERN_ERR "%d:%u:%d : invalid AS_GENERAL desc\n",
2518                                    dev->devnum, iface_no, altno);
2519                         continue;
2520                 }
2521
2522                 format = (fmt[6] << 8) | fmt[5]; /* remember the format value */
2523
2524                 /* get format type */
2525                 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, FORMAT_TYPE);
2526                 if (!fmt) {
2527                         snd_printk(KERN_ERR "%d:%u:%d : no FORMAT_TYPE desc\n",
2528                                    dev->devnum, iface_no, altno);
2529                         continue;
2530                 }
2531                 if (fmt[0] < 8) {
2532                         snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
2533                                    dev->devnum, iface_no, altno);
2534                         continue;
2535                 }
2536
2537                 csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT);
2538                 /* Creamware Noah has this descriptor after the 2nd endpoint */
2539                 if (!csep && altsd->bNumEndpoints >= 2)
2540                         csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);
2541                 if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
2542                         snd_printk(KERN_ERR "%d:%u:%d : no or invalid class specific endpoint descriptor\n",
2543                                    dev->devnum, iface_no, altno);
2544                         continue;
2545                 }
2546
2547                 fp = kmalloc(sizeof(*fp), GFP_KERNEL);
2548                 if (! fp) {
2549                         snd_printk(KERN_ERR "cannot malloc\n");
2550                         return -ENOMEM;
2551                 }
2552
2553                 memset(fp, 0, sizeof(*fp));
2554                 fp->iface = iface_no;
2555                 fp->altsetting = altno;
2556                 fp->altset_idx = i;
2557                 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
2558                 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
2559                 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
2560                 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
2561                         fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
2562                                         * (fp->maxpacksize & 0x7ff);
2563                 fp->attributes = csep[3];
2564
2565                 /* some quirks for attributes here */
2566
2567                 switch (chip->usb_id) {
2568                 case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
2569                         /* Optoplay sets the sample rate attribute although
2570                          * it seems not supporting it in fact.
2571                          */
2572                         fp->attributes &= ~EP_CS_ATTR_SAMPLE_RATE;
2573                         break;
2574                 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
2575                 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
2576                         /* doesn't set the sample rate attribute, but supports it */
2577                         fp->attributes |= EP_CS_ATTR_SAMPLE_RATE;
2578                         break;
2579                 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
2580                 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
2581                                                 an older model 77d:223) */
2582                 /*
2583                  * plantronics headset and Griffin iMic have set adaptive-in
2584                  * although it's really not...
2585                  */
2586                         fp->ep_attr &= ~EP_ATTR_MASK;
2587                         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
2588                                 fp->ep_attr |= EP_ATTR_ADAPTIVE;
2589                         else
2590                                 fp->ep_attr |= EP_ATTR_SYNC;
2591                         break;
2592                 }
2593
2594                 /* ok, let's parse further... */
2595                 if (parse_audio_format(chip, fp, format, fmt, stream) < 0) {
2596                         kfree(fp->rate_table);
2597                         kfree(fp);
2598                         continue;
2599                 }
2600
2601                 snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint 0x%x\n", dev->devnum, iface_no, i, fp->endpoint);
2602                 err = add_audio_endpoint(chip, stream, fp);
2603                 if (err < 0) {
2604                         kfree(fp->rate_table);
2605                         kfree(fp);
2606                         return err;
2607                 }
2608                 /* try to set the interface... */
2609                 usb_set_interface(chip->dev, iface_no, altno);
2610                 init_usb_pitch(chip->dev, iface_no, alts, fp);
2611                 init_usb_sample_rate(chip->dev, iface_no, alts, fp, fp->rate_max);
2612         }
2613         return 0;
2614 }
2615
2616
2617 /*
2618  * disconnect streams
2619  * called from snd_usb_audio_disconnect()
2620  */
2621 static void snd_usb_stream_disconnect(struct list_head *head)
2622 {
2623         int idx;
2624         snd_usb_stream_t *as;
2625         snd_usb_substream_t *subs;
2626
2627         as = list_entry(head, snd_usb_stream_t, list);
2628         for (idx = 0; idx < 2; idx++) {
2629                 subs = &as->substream[idx];
2630                 if (!subs->num_formats)
2631                         return;
2632                 release_substream_urbs(subs, 1);
2633                 subs->interface = -1;
2634         }
2635 }
2636
2637 /*
2638  * parse audio control descriptor and create pcm/midi streams
2639  */
2640 static int snd_usb_create_streams(snd_usb_audio_t *chip, int ctrlif)
2641 {
2642         struct usb_device *dev = chip->dev;
2643         struct usb_host_interface *host_iface;
2644         struct usb_interface *iface;
2645         unsigned char *p1;
2646         int i, j;
2647
2648         /* find audiocontrol interface */
2649         host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0];
2650         if (!(p1 = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen, NULL, HEADER))) {
2651                 snd_printk(KERN_ERR "cannot find HEADER\n");
2652                 return -EINVAL;
2653         }
2654         if (! p1[7] || p1[0] < 8 + p1[7]) {
2655                 snd_printk(KERN_ERR "invalid HEADER\n");
2656                 return -EINVAL;
2657         }
2658
2659         /*
2660          * parse all USB audio streaming interfaces
2661          */
2662         for (i = 0; i < p1[7]; i++) {
2663                 struct usb_host_interface *alts;
2664                 struct usb_interface_descriptor *altsd;
2665                 j = p1[8 + i];
2666                 iface = usb_ifnum_to_if(dev, j);
2667                 if (!iface) {
2668                         snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
2669                                    dev->devnum, ctrlif, j);
2670                         continue;
2671                 }
2672                 if (usb_interface_claimed(iface)) {
2673                         snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n", dev->devnum, ctrlif, j);
2674                         continue;
2675                 }
2676                 alts = &iface->altsetting[0];
2677                 altsd = get_iface_desc(alts);
2678                 if ((altsd->bInterfaceClass == USB_CLASS_AUDIO ||
2679                      altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
2680                     altsd->bInterfaceSubClass == USB_SUBCLASS_MIDI_STREAMING) {
2681                         if (snd_usb_create_midi_interface(chip, iface, NULL) < 0) {
2682                                 snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n", dev->devnum, ctrlif, j);
2683                                 continue;
2684                         }
2685                         usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
2686                         continue;
2687                 }
2688                 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
2689                      altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
2690                     altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING) {
2691                         snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n", dev->devnum, ctrlif, j, altsd->bInterfaceClass);
2692                         /* skip non-supported classes */
2693                         continue;
2694                 }
2695                 if (! parse_audio_endpoints(chip, j)) {
2696                         usb_set_interface(dev, j, 0); /* reset the current interface */
2697                         usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
2698                 }
2699         }
2700
2701         return 0;
2702 }
2703
2704 /*
2705  * create a stream for an endpoint/altsetting without proper descriptors
2706  */
2707 static int create_fixed_stream_quirk(snd_usb_audio_t *chip,
2708                                      struct usb_interface *iface,
2709                                      const snd_usb_audio_quirk_t *quirk)
2710 {
2711         struct audioformat *fp;
2712         struct usb_host_interface *alts;
2713         int stream, err;
2714         int *rate_table = NULL;
2715
2716         fp = kmalloc(sizeof(*fp), GFP_KERNEL);
2717         if (! fp) {
2718                 snd_printk(KERN_ERR "cannot malloc\n");
2719                 return -ENOMEM;
2720         }
2721         memcpy(fp, quirk->data, sizeof(*fp));
2722         if (fp->nr_rates > 0) {
2723                 rate_table = kmalloc(sizeof(int) * fp->nr_rates, GFP_KERNEL);
2724                 if (!rate_table) {
2725                         kfree(fp);
2726                         return -ENOMEM;
2727                 }
2728                 memcpy(rate_table, fp->rate_table, sizeof(int) * fp->nr_rates);
2729                 fp->rate_table = rate_table;
2730         }
2731
2732         stream = (fp->endpoint & USB_DIR_IN)
2733                 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2734         err = add_audio_endpoint(chip, stream, fp);
2735         if (err < 0) {
2736                 kfree(fp);
2737                 kfree(rate_table);
2738                 return err;
2739         }
2740         if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber ||
2741             fp->altset_idx >= iface->num_altsetting) {
2742                 kfree(fp);
2743                 kfree(rate_table);
2744                 return -EINVAL;
2745         }
2746         alts = &iface->altsetting[fp->altset_idx];
2747         usb_set_interface(chip->dev, fp->iface, 0);
2748         init_usb_pitch(chip->dev, fp->iface, alts, fp);
2749         init_usb_sample_rate(chip->dev, fp->iface, alts, fp, fp->rate_max);
2750         return 0;
2751 }
2752
2753 /*
2754  * create a stream for an interface with proper descriptors
2755  */
2756 static int create_standard_interface_quirk(snd_usb_audio_t *chip,
2757                                            struct usb_interface *iface,
2758                                            const snd_usb_audio_quirk_t *quirk)
2759 {
2760         struct usb_host_interface *alts;
2761         struct usb_interface_descriptor *altsd;
2762         int err;
2763
2764         alts = &iface->altsetting[0];
2765         altsd = get_iface_desc(alts);
2766         switch (quirk->type) {
2767         case QUIRK_AUDIO_STANDARD_INTERFACE:
2768                 err = parse_audio_endpoints(chip, altsd->bInterfaceNumber);
2769                 if (!err)
2770                         usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0); /* reset the current interface */
2771                 break;
2772         case QUIRK_MIDI_STANDARD_INTERFACE:
2773                 err = snd_usb_create_midi_interface(chip, iface, NULL);
2774                 break;
2775         default:
2776                 snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
2777                 return -ENXIO;
2778         }
2779         if (err < 0) {
2780                 snd_printk(KERN_ERR "cannot setup if %d: error %d\n",
2781                            altsd->bInterfaceNumber, err);
2782                 return err;
2783         }
2784         return 0;
2785 }
2786
2787 /*
2788  * Create a stream for an Edirol UA-700/UA-25 interface.  The only way
2789  * to detect the sample rate is by looking at wMaxPacketSize.
2790  */
2791 static int create_ua700_ua25_quirk(snd_usb_audio_t *chip,
2792                                    struct usb_interface *iface,
2793                                    const snd_usb_audio_quirk_t *quirk)
2794 {
2795         static const struct audioformat ua_format = {
2796                 .format = SNDRV_PCM_FORMAT_S24_3LE,
2797                 .channels = 2,
2798                 .fmt_type = USB_FORMAT_TYPE_I,
2799                 .altsetting = 1,
2800                 .altset_idx = 1,
2801                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
2802         };
2803         struct usb_host_interface *alts;
2804         struct usb_interface_descriptor *altsd;
2805         struct audioformat *fp;
2806         int stream, err;
2807
2808         /* both PCM and MIDI interfaces have 2 altsettings */
2809         if (iface->num_altsetting != 2)
2810                 return -ENXIO;
2811         alts = &iface->altsetting[1];
2812         altsd = get_iface_desc(alts);
2813
2814         if (altsd->bNumEndpoints == 2) {
2815                 static const snd_usb_midi_endpoint_info_t ua700_ep = {
2816                         .out_cables = 0x0003,
2817                         .in_cables  = 0x0003
2818                 };
2819                 static const snd_usb_audio_quirk_t ua700_quirk = {
2820                         .type = QUIRK_MIDI_FIXED_ENDPOINT,
2821                         .data = &ua700_ep
2822                 };
2823                 static const snd_usb_midi_endpoint_info_t ua25_ep = {
2824                         .out_cables = 0x0001,
2825                         .in_cables  = 0x0001
2826                 };
2827                 static const snd_usb_audio_quirk_t ua25_quirk = {
2828                         .type = QUIRK_MIDI_FIXED_ENDPOINT,
2829                         .data = &ua25_ep
2830                 };
2831                 if (chip->usb_id == USB_ID(0x0582, 0x002b))
2832                         return snd_usb_create_midi_interface(chip, iface,
2833                                                              &ua700_quirk);
2834                 else
2835                         return snd_usb_create_midi_interface(chip, iface,
2836                                                              &ua25_quirk);
2837         }
2838
2839         if (altsd->bNumEndpoints != 1)
2840                 return -ENXIO;
2841
2842         fp = kmalloc(sizeof(*fp), GFP_KERNEL);
2843         if (!fp)
2844                 return -ENOMEM;
2845         memcpy(fp, &ua_format, sizeof(*fp));
2846
2847         fp->iface = altsd->bInterfaceNumber;
2848         fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
2849         fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
2850         fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
2851
2852         switch (fp->maxpacksize) {
2853         case 0x120:
2854                 fp->rate_max = fp->rate_min = 44100;
2855                 break;
2856         case 0x138:
2857         case 0x140:
2858                 fp->rate_max = fp->rate_min = 48000;
2859                 break;
2860         case 0x258:
2861         case 0x260:
2862                 fp->rate_max = fp->rate_min = 96000;
2863                 break;
2864         default:
2865                 snd_printk(KERN_ERR "unknown sample rate\n");
2866                 kfree(fp);
2867                 return -ENXIO;
2868         }
2869
2870         stream = (fp->endpoint & USB_DIR_IN)
2871                 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2872         err = add_audio_endpoint(chip, stream, fp);
2873         if (err < 0) {
2874                 kfree(fp);
2875                 return err;
2876         }
2877         usb_set_interface(chip->dev, fp->iface, 0);
2878         return 0;
2879 }
2880
2881 /*
2882  * Create a stream for an Edirol UA-1000 interface.
2883  */
2884 static int create_ua1000_quirk(snd_usb_audio_t *chip,
2885                                struct usb_interface *iface,
2886                                const snd_usb_audio_quirk_t *quirk)
2887 {
2888         static const struct audioformat ua1000_format = {
2889                 .format = SNDRV_PCM_FORMAT_S32_LE,
2890                 .fmt_type = USB_FORMAT_TYPE_I,
2891                 .altsetting = 1,
2892                 .altset_idx = 1,
2893                 .attributes = 0,
2894                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
2895         };
2896         struct usb_host_interface *alts;
2897         struct usb_interface_descriptor *altsd;
2898         struct audioformat *fp;
2899         int stream, err;
2900
2901         if (iface->num_altsetting != 2)
2902                 return -ENXIO;
2903         alts = &iface->altsetting[1];
2904         altsd = get_iface_desc(alts);
2905         if (alts->extralen != 11 || alts->extra[1] != CS_AUDIO_INTERFACE ||
2906             altsd->bNumEndpoints != 1)
2907                 return -ENXIO;
2908
2909         fp = kmalloc(sizeof(*fp), GFP_KERNEL);
2910         if (!fp)
2911                 return -ENOMEM;
2912         memcpy(fp, &ua1000_format, sizeof(*fp));
2913
2914         fp->channels = alts->extra[4];
2915         fp->iface = altsd->bInterfaceNumber;
2916         fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
2917         fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
2918         fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
2919         fp->rate_max = fp->rate_min = combine_triple(&alts->extra[8]);
2920
2921         stream = (fp->endpoint & USB_DIR_IN)
2922                 ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2923         err = add_audio_endpoint(chip, stream, fp);
2924         if (err < 0) {
2925                 kfree(fp);
2926                 return err;
2927         }
2928         /* FIXME: playback must be synchronized to capture */
2929         usb_set_interface(chip->dev, fp->iface, 0);
2930         return 0;
2931 }
2932
2933 static int snd_usb_create_quirk(snd_usb_audio_t *chip,
2934                                 struct usb_interface *iface,
2935                                 const snd_usb_audio_quirk_t *quirk);
2936
2937 /*
2938  * handle the quirks for the contained interfaces
2939  */
2940 static int create_composite_quirk(snd_usb_audio_t *chip,
2941                                   struct usb_interface *iface,
2942                                   const snd_usb_audio_quirk_t *quirk)
2943 {
2944         int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
2945         int err;
2946
2947         for (quirk = quirk->data; quirk->ifnum >= 0; ++quirk) {
2948                 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
2949                 if (!iface)
2950                         continue;
2951                 if (quirk->ifnum != probed_ifnum &&
2952                     usb_interface_claimed(iface))
2953                         continue;
2954                 err = snd_usb_create_quirk(chip, iface, quirk);
2955                 if (err < 0)
2956                         return err;
2957                 if (quirk->ifnum != probed_ifnum)
2958                         usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
2959         }
2960         return 0;
2961 }
2962
2963 static int ignore_interface_quirk(snd_usb_audio_t *chip,
2964                                   struct usb_interface *iface,
2965                                   const snd_usb_audio_quirk_t *quirk)
2966 {
2967         return 0;
2968 }
2969
2970
2971 /*
2972  * boot quirks
2973  */
2974
2975 #define EXTIGY_FIRMWARE_SIZE_OLD 794
2976 #define EXTIGY_FIRMWARE_SIZE_NEW 483
2977
2978 static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf)
2979 {
2980         struct usb_host_config *config = dev->actconfig;
2981         int err;
2982
2983         if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||
2984             le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {
2985                 snd_printdd("sending Extigy boot sequence...\n");
2986                 /* Send message to force it to reconnect with full interface. */
2987                 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),
2988                                       0x10, 0x43, 0x0001, 0x000a, NULL, 0, 1000);
2989                 if (err < 0) snd_printdd("error sending boot message: %d\n", err);
2990                 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
2991                                 &dev->descriptor, sizeof(dev->descriptor));
2992                 config = dev->actconfig;
2993                 if (err < 0) snd_printdd("error usb_get_descriptor: %d\n", err);
2994                 err = usb_reset_configuration(dev);
2995                 if (err < 0) snd_printdd("error usb_reset_configuration: %d\n", err);
2996                 snd_printdd("extigy_boot: new boot length = %d\n",
2997                             le16_to_cpu(get_cfg_desc(config)->wTotalLength));
2998                 return -ENODEV; /* quit this anyway */
2999         }
3000         return 0;
3001 }
3002
3003 static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)
3004 {
3005         u8 buf = 1;
3006
3007         snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a,
3008                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
3009                         0, 0, &buf, 1, 1000);
3010         if (buf == 0) {
3011                 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29,
3012                                 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
3013                                 1, 2000, NULL, 0, 1000);
3014                 return -ENODEV;
3015         }
3016         return 0;
3017 }
3018
3019
3020 /*
3021  * audio-interface quirks
3022  *
3023  * returns zero if no standard audio/MIDI parsing is needed.
3024  * returns a postive value if standard audio/midi interfaces are parsed
3025  * after this.
3026  * returns a negative value at error.
3027  */
3028 static int snd_usb_create_quirk(snd_usb_audio_t *chip,
3029                                 struct usb_interface *iface,
3030                                 const snd_usb_audio_quirk_t *quirk)
3031 {
3032         typedef int (*quirk_func_t)(snd_usb_audio_t *, struct usb_interface *,
3033                                     const snd_usb_audio_quirk_t *);
3034         static const quirk_func_t quirk_funcs[] = {
3035                 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
3036                 [QUIRK_COMPOSITE] = create_composite_quirk,
3037                 [QUIRK_MIDI_STANDARD_INTERFACE] = snd_usb_create_midi_interface,
3038                 [QUIRK_MIDI_FIXED_ENDPOINT] = snd_usb_create_midi_interface,
3039                 [QUIRK_MIDI_YAMAHA] = snd_usb_create_midi_interface,
3040                 [QUIRK_MIDI_MIDIMAN] = snd_usb_create_midi_interface,
3041                 [QUIRK_MIDI_NOVATION] = snd_usb_create_midi_interface,
3042                 [QUIRK_MIDI_RAW] = snd_usb_create_midi_interface,
3043                 [QUIRK_MIDI_EMAGIC] = snd_usb_create_midi_interface,
3044                 [QUIRK_MIDI_MIDITECH] = snd_usb_create_midi_interface,
3045                 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_interface_quirk,
3046                 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
3047                 [QUIRK_AUDIO_EDIROL_UA700_UA25] = create_ua700_ua25_quirk,
3048                 [QUIRK_AUDIO_EDIROL_UA1000] = create_ua1000_quirk,
3049         };
3050
3051         if (quirk->type < QUIRK_TYPE_COUNT) {
3052                 return quirk_funcs[quirk->type](chip, iface, quirk);
3053         } else {
3054                 snd_printd(KERN_ERR "invalid quirk type %d\n", quirk->type);
3055                 return -ENXIO;
3056         }
3057 }
3058
3059
3060 /*
3061  * common proc files to show the usb device info
3062  */
3063 static void proc_audio_usbbus_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
3064 {
3065         snd_usb_audio_t *chip = entry->private_data;
3066         if (! chip->shutdown)
3067                 snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum);
3068 }
3069
3070 static void proc_audio_usbid_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
3071 {
3072         snd_usb_audio_t *chip = entry->private_data;
3073         if (! chip->shutdown)
3074                 snd_iprintf(buffer, "%04x:%04x\n", 
3075                             USB_ID_VENDOR(chip->usb_id),
3076                             USB_ID_PRODUCT(chip->usb_id));
3077 }
3078
3079 static void snd_usb_audio_create_proc(snd_usb_audio_t *chip)
3080 {
3081         snd_info_entry_t *entry;
3082         if (! snd_card_proc_new(chip->card, "usbbus", &entry))
3083                 snd_info_set_text_ops(entry, chip, 1024, proc_audio_usbbus_read);
3084         if (! snd_card_proc_new(chip->card, "usbid", &entry))
3085                 snd_info_set_text_ops(entry, chip, 1024, proc_audio_usbid_read);
3086 }
3087
3088 /*
3089  * free the chip instance
3090  *
3091  * here we have to do not much, since pcm and controls are already freed
3092  *
3093  */
3094
3095 static int snd_usb_audio_free(snd_usb_audio_t *chip)
3096 {
3097         kfree(chip);
3098         return 0;
3099 }
3100
3101 static int snd_usb_audio_dev_free(snd_device_t *device)
3102 {
3103         snd_usb_audio_t *chip = device->device_data;
3104         return snd_usb_audio_free(chip);
3105 }
3106
3107
3108 /*
3109  * create a chip instance and set its names.
3110  */
3111 static int snd_usb_audio_create(struct usb_device *dev, int idx,
3112                                 const snd_usb_audio_quirk_t *quirk,
3113                                 snd_usb_audio_t **rchip)
3114 {
3115         snd_card_t *card;
3116         snd_usb_audio_t *chip;
3117         int err, len;
3118         char component[14];
3119         static snd_device_ops_t ops = {
3120                 .dev_free =     snd_usb_audio_dev_free,
3121         };
3122
3123         *rchip = NULL;
3124
3125         if (snd_usb_get_speed(dev) != USB_SPEED_FULL &&
3126             snd_usb_get_speed(dev) != USB_SPEED_HIGH) {
3127                 snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev));
3128                 return -ENXIO;
3129         }
3130
3131         card = snd_card_new(index[idx], id[idx], THIS_MODULE, 0);
3132         if (card == NULL) {
3133                 snd_printk(KERN_ERR "cannot create card instance %d\n", idx);
3134                 return -ENOMEM;
3135         }
3136
3137         chip = kcalloc(1, sizeof(*chip), GFP_KERNEL);
3138         if (! chip) {
3139                 snd_card_free(card);
3140                 return -ENOMEM;
3141         }
3142
3143         chip->index = idx;
3144         chip->dev = dev;
3145         chip->card = card;
3146         chip->usb_id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
3147                               le16_to_cpu(dev->descriptor.idProduct));
3148         INIT_LIST_HEAD(&chip->pcm_list);
3149         INIT_LIST_HEAD(&chip->midi_list);
3150         INIT_LIST_HEAD(&chip->mixer_list);
3151
3152         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
3153                 snd_usb_audio_free(chip);
3154                 snd_card_free(card);
3155                 return err;
3156         }
3157
3158         strcpy(card->driver, "USB-Audio");
3159         sprintf(component, "USB%04x:%04x",
3160                 USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id));
3161         snd_component_add(card, component);
3162
3163         /* retrieve the device string as shortname */
3164         if (quirk && quirk->product_name) {
3165                 strlcpy(card->shortname, quirk->product_name, sizeof(card->shortname));
3166         } else {
3167                 if (!dev->descriptor.iProduct ||
3168                     usb_string(dev, dev->descriptor.iProduct,
3169                                card->shortname, sizeof(card->shortname)) <= 0) {
3170                         /* no name available from anywhere, so use ID */
3171                         sprintf(card->shortname, "USB Device %#04x:%#04x",
3172                                 USB_ID_VENDOR(chip->usb_id),
3173                                 USB_ID_PRODUCT(chip->usb_id));
3174                 }
3175         }
3176
3177         /* retrieve the vendor and device strings as longname */
3178         if (quirk && quirk->vendor_name) {
3179                 len = strlcpy(card->longname, quirk->vendor_name, sizeof(card->longname));
3180         } else {
3181                 if (dev->descriptor.iManufacturer)
3182                         len = usb_string(dev, dev->descriptor.iManufacturer,
3183                                          card->longname, sizeof(card->longname));
3184                 else
3185                         len = 0;
3186                 /* we don't really care if there isn't any vendor string */
3187         }
3188         if (len > 0)
3189                 strlcat(card->longname, " ", sizeof(card->longname));
3190
3191         strlcat(card->longname, card->shortname, sizeof(card->longname));
3192
3193         len = strlcat(card->longname, " at ", sizeof(card->longname));
3194
3195         if (len < sizeof(card->longname))
3196                 usb_make_path(dev, card->longname + len, sizeof(card->longname) - len);
3197
3198         strlcat(card->longname,
3199                 snd_usb_get_speed(dev) == USB_SPEED_FULL ? ", full speed" : ", high speed",
3200                 sizeof(card->longname));
3201
3202         snd_usb_audio_create_proc(chip);
3203
3204         *rchip = chip;
3205         return 0;
3206 }
3207
3208
3209 /*
3210  * probe the active usb device
3211  *
3212  * note that this can be called multiple times per a device, when it
3213  * includes multiple audio control interfaces.
3214  *
3215  * thus we check the usb device pointer and creates the card instance