ALSA: ua101: add Edirol UA-1000 support
[linux-2.6.git] / sound / usb / ua101.c
1 /*
2  * Edirol UA-101/UA-1000 driver
3  * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
4  *
5  * This driver is free software: you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License, version 2.
7  *
8  * This driver is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this driver.  If not, see <http://www.gnu.org/licenses/>.
15  */
16
17 #include <linux/init.h>
18 #include <linux/module.h>
19 #include <linux/slab.h>
20 #include <linux/usb.h>
21 #include <linux/usb/audio.h>
22 #include <sound/core.h>
23 #include <sound/initval.h>
24 #include <sound/pcm.h>
25 #include <sound/pcm_params.h>
26 #include "usbaudio.h"
27
28 MODULE_DESCRIPTION("Edirol UA-101/1000 driver");
29 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
30 MODULE_LICENSE("GPL v2");
31 MODULE_SUPPORTED_DEVICE("{{Edirol,UA-101},{Edirol,UA-1000}}");
32
33 /* I use my UA-1A for testing because I don't have a UA-101 ... */
34 #define UA1A_HACK
35
36 /*
37  * Should not be lower than the minimum scheduling delay of the host
38  * controller.  Some Intel controllers need more than one frame; as long as
39  * that driver doesn't tell us about this, use 1.5 frames just to be sure.
40  */
41 #define MIN_QUEUE_LENGTH        12
42 /* Somewhat random. */
43 #define MAX_QUEUE_LENGTH        30
44 /*
45  * This magic value optimizes memory usage efficiency for the UA-101's packet
46  * sizes at all sample rates, taking into account the stupid cache pool sizes
47  * that usb_buffer_alloc() uses.
48  */
49 #define DEFAULT_QUEUE_LENGTH    21
50
51 #define MAX_PACKET_SIZE         672 /* hardware specific */
52 #define MAX_MEMORY_BUFFERS      DIV_ROUND_UP(MAX_QUEUE_LENGTH, \
53                                              PAGE_SIZE / MAX_PACKET_SIZE)
54
55 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
56 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
57 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
58 static unsigned int queue_length = 21;
59
60 module_param_array(index, int, NULL, 0444);
61 MODULE_PARM_DESC(index, "card index");
62 module_param_array(id, charp, NULL, 0444);
63 MODULE_PARM_DESC(id, "ID string");
64 module_param_array(enable, bool, NULL, 0444);
65 MODULE_PARM_DESC(enable, "enable card");
66 module_param(queue_length, uint, 0644);
67 MODULE_PARM_DESC(queue_length, "USB queue length in microframes, "
68                  __stringify(MIN_QUEUE_LENGTH)"-"__stringify(MAX_QUEUE_LENGTH));
69
70 enum {
71         INTF_PLAYBACK,
72         INTF_CAPTURE,
73         INTF_MIDI,
74
75         INTF_COUNT
76 };
77
78 /* bits in struct ua101::states */
79 enum {
80         USB_CAPTURE_RUNNING,
81         USB_PLAYBACK_RUNNING,
82         ALSA_CAPTURE_OPEN,
83         ALSA_PLAYBACK_OPEN,
84         ALSA_CAPTURE_RUNNING,
85         ALSA_PLAYBACK_RUNNING,
86         CAPTURE_URB_COMPLETED,
87         PLAYBACK_URB_COMPLETED,
88         DISCONNECTED,
89 };
90
91 struct ua101 {
92         struct usb_device *dev;
93         struct snd_card *card;
94         struct usb_interface *intf[INTF_COUNT];
95         int card_index;
96         struct snd_pcm *pcm;
97         struct list_head midi_list;
98         u64 format_bit;
99         unsigned int rate;
100         unsigned int packets_per_second;
101         spinlock_t lock;
102         struct mutex mutex;
103         unsigned long states;
104
105         /* FIFO to synchronize playback rate to capture rate */
106         unsigned int rate_feedback_start;
107         unsigned int rate_feedback_count;
108         u8 rate_feedback[MAX_QUEUE_LENGTH];
109
110         struct list_head ready_playback_urbs;
111         struct tasklet_struct playback_tasklet;
112         wait_queue_head_t alsa_capture_wait;
113         wait_queue_head_t rate_feedback_wait;
114         wait_queue_head_t alsa_playback_wait;
115         struct ua101_stream {
116                 struct snd_pcm_substream *substream;
117                 unsigned int usb_pipe;
118                 unsigned int channels;
119                 unsigned int frame_bytes;
120                 unsigned int max_packet_bytes;
121                 unsigned int period_pos;
122                 unsigned int buffer_pos;
123                 unsigned int queue_length;
124                 struct ua101_urb {
125                         struct urb urb;
126                         struct usb_iso_packet_descriptor iso_frame_desc[1];
127                         struct list_head ready_list;
128                 } *urbs[MAX_QUEUE_LENGTH];
129                 struct {
130                         unsigned int size;
131                         void *addr;
132                         dma_addr_t dma;
133                 } buffers[MAX_MEMORY_BUFFERS];
134         } capture, playback;
135
136         unsigned int fps[10];
137         unsigned int frame_counter;
138 };
139
140 static DEFINE_MUTEX(devices_mutex);
141 static unsigned int devices_used;
142 static struct usb_driver ua101_driver;
143
144 static void abort_alsa_playback(struct ua101 *ua);
145 static void abort_alsa_capture(struct ua101 *ua);
146
147 static const char *usb_error_string(int err)
148 {
149         switch (err) {
150         case -ENODEV:
151                 return "no device";
152         case -ENOENT:
153                 return "endpoint not enabled";
154         case -EPIPE:
155                 return "endpoint stalled";
156         case -ENOSPC:
157                 return "not enough bandwidth";
158         case -ESHUTDOWN:
159                 return "device disabled";
160         case -EHOSTUNREACH:
161                 return "device suspended";
162         case -EINVAL:
163         case -EAGAIN:
164         case -EFBIG:
165         case -EMSGSIZE:
166                 return "internal error";
167         default:
168                 return "unknown error";
169         }
170 }
171
172 static void abort_usb_capture(struct ua101 *ua)
173 {
174         if (test_and_clear_bit(USB_CAPTURE_RUNNING, &ua->states)) {
175                 wake_up(&ua->alsa_capture_wait);
176                 wake_up(&ua->rate_feedback_wait);
177         }
178 }
179
180 static void abort_usb_playback(struct ua101 *ua)
181 {
182         if (test_and_clear_bit(USB_PLAYBACK_RUNNING, &ua->states))
183                 wake_up(&ua->alsa_playback_wait);
184 }
185
186 static void playback_urb_complete(struct urb *usb_urb)
187 {
188         struct ua101_urb *urb = (struct ua101_urb *)usb_urb;
189         struct ua101 *ua = urb->urb.context;
190         unsigned long flags;
191
192         if (unlikely(urb->urb.status == -ENOENT ||      /* unlinked */
193                      urb->urb.status == -ENODEV ||      /* device removed */
194                      urb->urb.status == -ECONNRESET ||  /* unlinked */
195                      urb->urb.status == -ESHUTDOWN)) {  /* device disabled */
196                 abort_usb_playback(ua);
197                 abort_alsa_playback(ua);
198                 return;
199         }
200
201         if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) {
202                 /* append URB to FIFO */
203                 spin_lock_irqsave(&ua->lock, flags);
204                 list_add_tail(&urb->ready_list, &ua->ready_playback_urbs);
205                 if (ua->rate_feedback_count > 0)
206                         tasklet_schedule(&ua->playback_tasklet);
207                 ua->playback.substream->runtime->delay -=
208                                 urb->urb.iso_frame_desc[0].length /
209                                                 ua->playback.frame_bytes;
210                 spin_unlock_irqrestore(&ua->lock, flags);
211         }
212 }
213
214 static void first_playback_urb_complete(struct urb *urb)
215 {
216         struct ua101 *ua = urb->context;
217
218         urb->complete = playback_urb_complete;
219         playback_urb_complete(urb);
220
221         set_bit(PLAYBACK_URB_COMPLETED, &ua->states);
222         wake_up(&ua->alsa_playback_wait);
223 }
224
225 /* copy data from the ALSA ring buffer into the URB buffer */
226 static bool copy_playback_data(struct ua101_stream *stream, struct urb *urb,
227                                unsigned int frames)
228 {
229         struct snd_pcm_runtime *runtime;
230         unsigned int frame_bytes, frames1;
231         const u8 *source;
232
233         runtime = stream->substream->runtime;
234         frame_bytes = stream->frame_bytes;
235         source = runtime->dma_area + stream->buffer_pos * frame_bytes;
236         if (stream->buffer_pos + frames <= runtime->buffer_size) {
237                 memcpy(urb->transfer_buffer, source, frames * frame_bytes);
238         } else {
239                 /* wrap around at end of ring buffer */
240                 frames1 = runtime->buffer_size - stream->buffer_pos;
241                 memcpy(urb->transfer_buffer, source, frames1 * frame_bytes);
242                 memcpy(urb->transfer_buffer + frames1 * frame_bytes,
243                        runtime->dma_area, (frames - frames1) * frame_bytes);
244         }
245
246         stream->buffer_pos += frames;
247         if (stream->buffer_pos >= runtime->buffer_size)
248                 stream->buffer_pos -= runtime->buffer_size;
249         stream->period_pos += frames;
250         if (stream->period_pos >= runtime->period_size) {
251                 stream->period_pos -= runtime->period_size;
252                 return true;
253         }
254         return false;
255 }
256
257 static inline void add_with_wraparound(struct ua101 *ua,
258                                        unsigned int *value, unsigned int add)
259 {
260         *value += add;
261         if (*value >= ua->playback.queue_length)
262                 *value -= ua->playback.queue_length;
263 }
264
265 static void playback_tasklet(unsigned long data)
266 {
267         struct ua101 *ua = (void *)data;
268         unsigned long flags;
269         unsigned int frames;
270         struct ua101_urb *urb;
271         bool do_period_elapsed = false;
272         int err;
273
274         if (unlikely(!test_bit(USB_PLAYBACK_RUNNING, &ua->states)))
275                 return;
276
277         /*
278          * Synchronizing the playback rate to the capture rate is done by using
279          * the same sequence of packet sizes for both streams.
280          * Submitting a playback URB therefore requires both a ready URB and
281          * the size of the corresponding capture packet, i.e., both playback
282          * and capture URBs must have been completed.  Since the USB core does
283          * not guarantee that playback and capture complete callbacks are
284          * called alternately, we use two FIFOs for packet sizes and read URBs;
285          * submitting playback URBs is possible as long as both FIFOs are
286          * nonempty.
287          */
288         spin_lock_irqsave(&ua->lock, flags);
289         while (ua->rate_feedback_count > 0 &&
290                !list_empty(&ua->ready_playback_urbs)) {
291                 /* take packet size out of FIFO */
292                 frames = ua->rate_feedback[ua->rate_feedback_start];
293                 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
294                 ua->rate_feedback_count--;
295
296                 /* take URB out of FIFO */
297                 urb = list_first_entry(&ua->ready_playback_urbs,
298                                        struct ua101_urb, ready_list);
299                 list_del(&urb->ready_list);
300
301                 /* fill packet with data or silence */
302                 urb->urb.iso_frame_desc[0].length =
303                         frames * ua->playback.frame_bytes;
304                 if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
305                         do_period_elapsed |= copy_playback_data(&ua->playback,
306                                                                 &urb->urb,
307                                                                 frames);
308                 else
309                         memset(urb->urb.transfer_buffer, 0,
310                                urb->urb.iso_frame_desc[0].length);
311
312                 /* and off you go ... */
313                 err = usb_submit_urb(&urb->urb, GFP_ATOMIC);
314                 if (unlikely(err < 0)) {
315                         spin_unlock_irqrestore(&ua->lock, flags);
316                         abort_usb_playback(ua);
317                         abort_alsa_playback(ua);
318                         dev_err(&ua->dev->dev, "USB request error %d: %s\n",
319                                 err, usb_error_string(err));
320                         return;
321                 }
322                 ua->playback.substream->runtime->delay += frames;
323         }
324         spin_unlock_irqrestore(&ua->lock, flags);
325         if (do_period_elapsed)
326                 snd_pcm_period_elapsed(ua->playback.substream);
327 }
328
329 /* copy data from the URB buffer into the ALSA ring buffer */
330 static bool copy_capture_data(struct ua101_stream *stream, struct urb *urb,
331                               unsigned int frames)
332 {
333         struct snd_pcm_runtime *runtime;
334         unsigned int frame_bytes, frames1;
335         u8 *dest;
336
337         runtime = stream->substream->runtime;
338         frame_bytes = stream->frame_bytes;
339         dest = runtime->dma_area + stream->buffer_pos * frame_bytes;
340         if (stream->buffer_pos + frames <= runtime->buffer_size) {
341                 memcpy(dest, urb->transfer_buffer, frames * frame_bytes);
342         } else {
343                 /* wrap around at end of ring buffer */
344                 frames1 = runtime->buffer_size - stream->buffer_pos;
345                 memcpy(dest, urb->transfer_buffer, frames1 * frame_bytes);
346                 memcpy(runtime->dma_area,
347                        urb->transfer_buffer + frames1 * frame_bytes,
348                        (frames - frames1) * frame_bytes);
349         }
350
351         stream->buffer_pos += frames;
352         if (stream->buffer_pos >= runtime->buffer_size)
353                 stream->buffer_pos -= runtime->buffer_size;
354         stream->period_pos += frames;
355         if (stream->period_pos >= runtime->period_size) {
356                 stream->period_pos -= runtime->period_size;
357                 return true;
358         }
359         return false;
360 }
361
362 static void capture_urb_complete(struct urb *urb)
363 {
364         struct ua101 *ua = urb->context;
365         struct ua101_stream *stream = &ua->capture;
366         unsigned long flags;
367         unsigned int frames, write_ptr;
368         bool do_period_elapsed;
369         int err;
370
371         if (unlikely(urb->status == -ENOENT ||          /* unlinked */
372                      urb->status == -ENODEV ||          /* device removed */
373                      urb->status == -ECONNRESET ||      /* unlinked */
374                      urb->status == -ESHUTDOWN))        /* device disabled */
375                 goto stream_stopped;
376
377         if (urb->status >= 0 && urb->iso_frame_desc[0].status >= 0)
378                 frames = urb->iso_frame_desc[0].actual_length /
379                         stream->frame_bytes;
380         else
381                 frames = 0;
382
383         spin_lock_irqsave(&ua->lock, flags);
384
385         if (frames > 0 && test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
386                 do_period_elapsed = copy_capture_data(stream, urb, frames);
387         else
388                 do_period_elapsed = false;
389
390         if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
391                 err = usb_submit_urb(urb, GFP_ATOMIC);
392                 if (unlikely(err < 0)) {
393                         spin_unlock_irqrestore(&ua->lock, flags);
394                         dev_err(&ua->dev->dev, "USB request error %d: %s\n",
395                                 err, usb_error_string(err));
396                         goto stream_stopped;
397                 }
398
399                 /* append packet size to FIFO */
400                 write_ptr = ua->rate_feedback_start;
401                 add_with_wraparound(ua, &write_ptr, ua->rate_feedback_count);
402                 ua->rate_feedback[write_ptr] = frames;
403                 if (ua->rate_feedback_count < ua->playback.queue_length) {
404                         ua->rate_feedback_count++;
405                         if (ua->rate_feedback_count ==
406                                                 ua->playback.queue_length)
407                                 wake_up(&ua->rate_feedback_wait);
408                 } else {
409                         /*
410                          * Ring buffer overflow; this happens when the playback
411                          * stream is not running.  Throw away the oldest entry,
412                          * so that the playback stream, when it starts, sees
413                          * the most recent packet sizes.
414                          */
415                         add_with_wraparound(ua, &ua->rate_feedback_start, 1);
416                 }
417                 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states) &&
418                     !list_empty(&ua->ready_playback_urbs))
419                         tasklet_schedule(&ua->playback_tasklet);
420         }
421
422         spin_unlock_irqrestore(&ua->lock, flags);
423
424         if (do_period_elapsed)
425                 snd_pcm_period_elapsed(stream->substream);
426
427         /* for debugging: measure the sample rate relative to the USB clock */
428         ua->fps[ua->frame_counter++ / ua->packets_per_second] += frames;
429         if (ua->frame_counter >= ARRAY_SIZE(ua->fps) * ua->packets_per_second) {
430                 printk(KERN_DEBUG "capture rate:");
431                 for (frames = 0; frames < ARRAY_SIZE(ua->fps); ++frames)
432                         printk(KERN_CONT " %u", ua->fps[frames]);
433                 printk(KERN_CONT "\n");
434                 memset(ua->fps, 0, sizeof(ua->fps));
435                 ua->frame_counter = 0;
436         }
437         return;
438
439 stream_stopped:
440         abort_usb_playback(ua);
441         abort_usb_capture(ua);
442         abort_alsa_playback(ua);
443         abort_alsa_capture(ua);
444 }
445
446 static void first_capture_urb_complete(struct urb *urb)
447 {
448         struct ua101 *ua = urb->context;
449
450         urb->complete = capture_urb_complete;
451         capture_urb_complete(urb);
452
453         set_bit(CAPTURE_URB_COMPLETED, &ua->states);
454         wake_up(&ua->alsa_capture_wait);
455 }
456
457 static int submit_stream_urbs(struct ua101 *ua, struct ua101_stream *stream)
458 {
459         unsigned int i;
460
461         for (i = 0; i < stream->queue_length; ++i) {
462                 int err = usb_submit_urb(&stream->urbs[i]->urb, GFP_KERNEL);
463                 if (err < 0) {
464                         dev_err(&ua->dev->dev, "USB request error %d: %s\n",
465                                 err, usb_error_string(err));
466                         return err;
467                 }
468         }
469         return 0;
470 }
471
472 static void kill_stream_urbs(struct ua101_stream *stream)
473 {
474         unsigned int i;
475
476         for (i = 0; i < stream->queue_length; ++i)
477                 usb_kill_urb(&stream->urbs[i]->urb);
478 }
479
480 static int enable_iso_interface(struct ua101 *ua, unsigned int intf_index)
481 {
482         struct usb_host_interface *alts;
483
484         alts = ua->intf[intf_index]->cur_altsetting;
485         if (alts->desc.bAlternateSetting != 1) {
486                 int err = usb_set_interface(ua->dev,
487                                             alts->desc.bInterfaceNumber, 1);
488                 if (err < 0) {
489                         dev_err(&ua->dev->dev,
490                                 "cannot initialize interface; error %d: %s\n",
491                                 err, usb_error_string(err));
492                         return err;
493                 }
494         }
495         return 0;
496 }
497
498 static void disable_iso_interface(struct ua101 *ua, unsigned int intf_index)
499 {
500         struct usb_host_interface *alts;
501
502         alts = ua->intf[intf_index]->cur_altsetting;
503         if (alts->desc.bAlternateSetting != 0) {
504                 int err = usb_set_interface(ua->dev,
505                                             alts->desc.bInterfaceNumber, 0);
506                 if (err < 0 && !test_bit(DISCONNECTED, &ua->states))
507                         dev_warn(&ua->dev->dev,
508                                  "interface reset failed; error %d: %s\n",
509                                  err, usb_error_string(err));
510         }
511 }
512
513 static void stop_usb_capture(struct ua101 *ua)
514 {
515         clear_bit(USB_CAPTURE_RUNNING, &ua->states);
516
517         kill_stream_urbs(&ua->capture);
518
519         disable_iso_interface(ua, INTF_CAPTURE);
520 }
521
522 static int start_usb_capture(struct ua101 *ua)
523 {
524         int err;
525
526         if (test_bit(DISCONNECTED, &ua->states))
527                 return -ENODEV;
528
529         if (test_bit(USB_CAPTURE_RUNNING, &ua->states))
530                 return 0;
531
532         kill_stream_urbs(&ua->capture);
533
534         err = enable_iso_interface(ua, INTF_CAPTURE);
535         if (err < 0)
536                 return err;
537
538         clear_bit(CAPTURE_URB_COMPLETED, &ua->states);
539         ua->capture.urbs[0]->urb.complete = first_capture_urb_complete;
540         ua->rate_feedback_start = 0;
541         ua->rate_feedback_count = 0;
542
543         set_bit(USB_CAPTURE_RUNNING, &ua->states);
544         err = submit_stream_urbs(ua, &ua->capture);
545         if (err < 0)
546                 stop_usb_capture(ua);
547         return err;
548 }
549
550 static void stop_usb_playback(struct ua101 *ua)
551 {
552         clear_bit(USB_PLAYBACK_RUNNING, &ua->states);
553
554         kill_stream_urbs(&ua->playback);
555
556         tasklet_kill(&ua->playback_tasklet);
557
558         disable_iso_interface(ua, INTF_PLAYBACK);
559 }
560
561 static int start_usb_playback(struct ua101 *ua)
562 {
563         unsigned int i, frames;
564         struct urb *urb;
565         int err = 0;
566
567         if (test_bit(DISCONNECTED, &ua->states))
568                 return -ENODEV;
569
570         if (test_bit(USB_PLAYBACK_RUNNING, &ua->states))
571                 return 0;
572
573         kill_stream_urbs(&ua->playback);
574         tasklet_kill(&ua->playback_tasklet);
575
576         err = enable_iso_interface(ua, INTF_PLAYBACK);
577         if (err < 0)
578                 return err;
579
580         clear_bit(PLAYBACK_URB_COMPLETED, &ua->states);
581         ua->playback.urbs[0]->urb.complete =
582                 first_playback_urb_complete;
583         spin_lock_irq(&ua->lock);
584         INIT_LIST_HEAD(&ua->ready_playback_urbs);
585         spin_unlock_irq(&ua->lock);
586
587         /*
588          * We submit the initial URBs all at once, so we have to wait for the
589          * packet size FIFO to be full.
590          */
591         wait_event(ua->rate_feedback_wait,
592                    ua->rate_feedback_count >= ua->playback.queue_length ||
593                    !test_bit(USB_CAPTURE_RUNNING, &ua->states) ||
594                    test_bit(DISCONNECTED, &ua->states));
595         if (test_bit(DISCONNECTED, &ua->states)) {
596                 stop_usb_playback(ua);
597                 return -ENODEV;
598         }
599         if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
600                 stop_usb_playback(ua);
601                 return -EIO;
602         }
603
604         for (i = 0; i < ua->playback.queue_length; ++i) {
605                 /* all initial URBs contain silence */
606                 spin_lock_irq(&ua->lock);
607                 frames = ua->rate_feedback[ua->rate_feedback_start];
608                 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
609                 ua->rate_feedback_count--;
610                 spin_unlock_irq(&ua->lock);
611                 urb = &ua->playback.urbs[i]->urb;
612                 urb->iso_frame_desc[0].length =
613                         frames * ua->playback.frame_bytes;
614                 memset(urb->transfer_buffer, 0,
615                        urb->iso_frame_desc[0].length);
616         }
617
618         set_bit(USB_PLAYBACK_RUNNING, &ua->states);
619         err = submit_stream_urbs(ua, &ua->playback);
620         if (err < 0)
621                 stop_usb_playback(ua);
622         return err;
623 }
624
625 static void abort_alsa_capture(struct ua101 *ua)
626 {
627         if (test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
628                 snd_pcm_stop(ua->capture.substream, SNDRV_PCM_STATE_XRUN);
629 }
630
631 static void abort_alsa_playback(struct ua101 *ua)
632 {
633         if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
634                 snd_pcm_stop(ua->playback.substream, SNDRV_PCM_STATE_XRUN);
635 }
636
637 static int set_stream_hw(struct ua101 *ua, struct snd_pcm_substream *substream,
638                          unsigned int channels)
639 {
640         int err;
641
642         substream->runtime->hw.info =
643                 SNDRV_PCM_INFO_MMAP |
644                 SNDRV_PCM_INFO_MMAP_VALID |
645                 SNDRV_PCM_INFO_BATCH |
646                 SNDRV_PCM_INFO_INTERLEAVED |
647                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
648                 SNDRV_PCM_INFO_FIFO_IN_FRAMES;
649         substream->runtime->hw.formats = ua->format_bit;
650         substream->runtime->hw.rates = snd_pcm_rate_to_rate_bit(ua->rate);
651         substream->runtime->hw.rate_min = ua->rate;
652         substream->runtime->hw.rate_max = ua->rate;
653         substream->runtime->hw.channels_min = channels;
654         substream->runtime->hw.channels_max = channels;
655         substream->runtime->hw.buffer_bytes_max = 45000 * 1024;
656         substream->runtime->hw.period_bytes_min = 1;
657         substream->runtime->hw.period_bytes_max = UINT_MAX;
658         substream->runtime->hw.periods_min = 2;
659         substream->runtime->hw.periods_max = UINT_MAX;
660         err = snd_pcm_hw_constraint_minmax(substream->runtime,
661                                            SNDRV_PCM_HW_PARAM_PERIOD_TIME,
662                                            1500000 / ua->packets_per_second,
663                                            8192000);
664         if (err < 0)
665                 return err;
666         err = snd_pcm_hw_constraint_msbits(substream->runtime, 0, 32, 24);
667         return err;
668 }
669
670 static int capture_pcm_open(struct snd_pcm_substream *substream)
671 {
672         struct ua101 *ua = substream->private_data;
673         int err;
674
675         ua->capture.substream = substream;
676         err = set_stream_hw(ua, substream, ua->capture.channels);
677         if (err < 0)
678                 return err;
679         substream->runtime->hw.fifo_size =
680                 DIV_ROUND_CLOSEST(ua->rate, ua->packets_per_second);
681         substream->runtime->delay = substream->runtime->hw.fifo_size;
682
683         mutex_lock(&ua->mutex);
684         err = start_usb_capture(ua);
685         if (err >= 0)
686                 set_bit(ALSA_CAPTURE_OPEN, &ua->states);
687         mutex_unlock(&ua->mutex);
688         return err;
689 }
690
691 static int playback_pcm_open(struct snd_pcm_substream *substream)
692 {
693         struct ua101 *ua = substream->private_data;
694         int err;
695
696         ua->playback.substream = substream;
697         err = set_stream_hw(ua, substream, ua->playback.channels);
698         if (err < 0)
699                 return err;
700         substream->runtime->hw.fifo_size =
701                 DIV_ROUND_CLOSEST(ua->rate * ua->playback.queue_length,
702                                   ua->packets_per_second);
703
704         mutex_lock(&ua->mutex);
705         err = start_usb_capture(ua);
706         if (err < 0)
707                 goto error;
708         err = start_usb_playback(ua);
709         if (err < 0) {
710                 if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
711                         stop_usb_capture(ua);
712                 goto error;
713         }
714         set_bit(ALSA_PLAYBACK_OPEN, &ua->states);
715 error:
716         mutex_unlock(&ua->mutex);
717         return err;
718 }
719
720 static int capture_pcm_close(struct snd_pcm_substream *substream)
721 {
722         struct ua101 *ua = substream->private_data;
723
724         mutex_lock(&ua->mutex);
725         clear_bit(ALSA_CAPTURE_OPEN, &ua->states);
726         if (!test_bit(ALSA_PLAYBACK_OPEN, &ua->states))
727                 stop_usb_capture(ua);
728         mutex_unlock(&ua->mutex);
729         return 0;
730 }
731
732 static int playback_pcm_close(struct snd_pcm_substream *substream)
733 {
734         struct ua101 *ua = substream->private_data;
735
736         mutex_lock(&ua->mutex);
737         stop_usb_playback(ua);
738         clear_bit(ALSA_PLAYBACK_OPEN, &ua->states);
739         if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
740                 stop_usb_capture(ua);
741         mutex_unlock(&ua->mutex);
742         return 0;
743 }
744
745 static int capture_pcm_hw_params(struct snd_pcm_substream *substream,
746                                  struct snd_pcm_hw_params *hw_params)
747 {
748         struct ua101 *ua = substream->private_data;
749         int err;
750
751         mutex_lock(&ua->mutex);
752         err = start_usb_capture(ua);
753         mutex_unlock(&ua->mutex);
754         if (err < 0)
755                 return err;
756
757         return snd_pcm_lib_alloc_vmalloc_buffer(substream,
758                                                 params_buffer_bytes(hw_params));
759 }
760
761 static int playback_pcm_hw_params(struct snd_pcm_substream *substream,
762                                   struct snd_pcm_hw_params *hw_params)
763 {
764         struct ua101 *ua = substream->private_data;
765         int err;
766
767         mutex_lock(&ua->mutex);
768         err = start_usb_capture(ua);
769         if (err >= 0)
770                 err = start_usb_playback(ua);
771         mutex_unlock(&ua->mutex);
772         if (err < 0)
773                 return err;
774
775         return snd_pcm_lib_alloc_vmalloc_buffer(substream,
776                                                 params_buffer_bytes(hw_params));
777 }
778
779 static int ua101_pcm_hw_free(struct snd_pcm_substream *substream)
780 {
781         return snd_pcm_lib_free_vmalloc_buffer(substream);
782 }
783
784 static int capture_pcm_prepare(struct snd_pcm_substream *substream)
785 {
786         struct ua101 *ua = substream->private_data;
787         int err;
788
789         mutex_lock(&ua->mutex);
790         err = start_usb_capture(ua);
791         mutex_unlock(&ua->mutex);
792         if (err < 0)
793                 return err;
794
795         /*
796          * The EHCI driver schedules the first packet of an iso stream at 10 ms
797          * in the future, i.e., no data is actually captured for that long.
798          * Take the wait here so that the stream is known to be actually
799          * running when the start trigger has been called.
800          */
801         wait_event(ua->alsa_capture_wait,
802                    test_bit(CAPTURE_URB_COMPLETED, &ua->states) ||
803                    !test_bit(USB_CAPTURE_RUNNING, &ua->states));
804         if (test_bit(DISCONNECTED, &ua->states))
805                 return -ENODEV;
806         if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
807                 return -EIO;
808
809         ua->capture.period_pos = 0;
810         ua->capture.buffer_pos = 0;
811         return 0;
812 }
813
814 static int playback_pcm_prepare(struct snd_pcm_substream *substream)
815 {
816         struct ua101 *ua = substream->private_data;
817         int err;
818
819         mutex_lock(&ua->mutex);
820         err = start_usb_capture(ua);
821         if (err >= 0)
822                 err = start_usb_playback(ua);
823         mutex_unlock(&ua->mutex);
824         if (err < 0)
825                 return err;
826
827         /* see the comment in capture_pcm_prepare() */
828         wait_event(ua->alsa_playback_wait,
829                    test_bit(PLAYBACK_URB_COMPLETED, &ua->states) ||
830                    !test_bit(USB_PLAYBACK_RUNNING, &ua->states));
831         if (test_bit(DISCONNECTED, &ua->states))
832                 return -ENODEV;
833         if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
834                 return -EIO;
835
836         substream->runtime->delay = 0;
837         ua->playback.period_pos = 0;
838         ua->playback.buffer_pos = 0;
839         return 0;
840 }
841
842 static int capture_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
843 {
844         struct ua101 *ua = substream->private_data;
845
846         switch (cmd) {
847         case SNDRV_PCM_TRIGGER_START:
848                 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
849                         return -EIO;
850                 set_bit(ALSA_CAPTURE_RUNNING, &ua->states);
851                 return 0;
852         case SNDRV_PCM_TRIGGER_STOP:
853                 clear_bit(ALSA_CAPTURE_RUNNING, &ua->states);
854                 return 0;
855         default:
856                 return -EINVAL;
857         }
858 }
859
860 static int playback_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
861 {
862         struct ua101 *ua = substream->private_data;
863
864         switch (cmd) {
865         case SNDRV_PCM_TRIGGER_START:
866                 if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
867                         return -EIO;
868                 set_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
869                 return 0;
870         case SNDRV_PCM_TRIGGER_STOP:
871                 clear_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
872                 return 0;
873         default:
874                 return -EINVAL;
875         }
876 }
877
878 static inline snd_pcm_uframes_t ua101_pcm_pointer(struct ua101 *ua,
879                                                   struct ua101_stream *stream)
880 {
881         unsigned long flags;
882         unsigned int pos;
883
884         spin_lock_irqsave(&ua->lock, flags);
885         pos = stream->buffer_pos;
886         spin_unlock_irqrestore(&ua->lock, flags);
887         return pos;
888 }
889
890 static snd_pcm_uframes_t capture_pcm_pointer(struct snd_pcm_substream *subs)
891 {
892         struct ua101 *ua = subs->private_data;
893
894         return ua101_pcm_pointer(ua, &ua->capture);
895 }
896
897 static snd_pcm_uframes_t playback_pcm_pointer(struct snd_pcm_substream *subs)
898 {
899         struct ua101 *ua = subs->private_data;
900
901         return ua101_pcm_pointer(ua, &ua->playback);
902 }
903
904 static struct snd_pcm_ops capture_pcm_ops = {
905         .open = capture_pcm_open,
906         .close = capture_pcm_close,
907         .ioctl = snd_pcm_lib_ioctl,
908         .hw_params = capture_pcm_hw_params,
909         .hw_free = ua101_pcm_hw_free,
910         .prepare = capture_pcm_prepare,
911         .trigger = capture_pcm_trigger,
912         .pointer = capture_pcm_pointer,
913         .page = snd_pcm_lib_get_vmalloc_page,
914         .mmap = snd_pcm_lib_mmap_vmalloc,
915 };
916
917 static struct snd_pcm_ops playback_pcm_ops = {
918         .open = playback_pcm_open,
919         .close = playback_pcm_close,
920         .ioctl = snd_pcm_lib_ioctl,
921         .hw_params = playback_pcm_hw_params,
922         .hw_free = ua101_pcm_hw_free,
923         .prepare = playback_pcm_prepare,
924         .trigger = playback_pcm_trigger,
925         .pointer = playback_pcm_pointer,
926         .page = snd_pcm_lib_get_vmalloc_page,
927         .mmap = snd_pcm_lib_mmap_vmalloc,
928 };
929
930 static const struct uac_format_type_i_discrete_descriptor *
931 find_format_descriptor(struct usb_interface *interface)
932 {
933         struct usb_host_interface *alt;
934         u8 *extra;
935         int extralen;
936
937         if (interface->num_altsetting != 2) {
938                 dev_err(&interface->dev, "invalid num_altsetting\n");
939                 return NULL;
940         }
941
942         alt = &interface->altsetting[0];
943         if (alt->desc.bNumEndpoints != 0) {
944                 dev_err(&interface->dev, "invalid bNumEndpoints\n");
945                 return NULL;
946         }
947
948         alt = &interface->altsetting[1];
949         if (alt->desc.bNumEndpoints != 1) {
950                 dev_err(&interface->dev, "invalid bNumEndpoints\n");
951                 return NULL;
952         }
953
954         extra = alt->extra;
955         extralen = alt->extralen;
956         while (extralen >= sizeof(struct usb_descriptor_header)) {
957                 struct uac_format_type_i_discrete_descriptor *desc;
958
959                 desc = (struct uac_format_type_i_discrete_descriptor *)extra;
960                 if (desc->bLength > extralen) {
961                         dev_err(&interface->dev, "descriptor overflow\n");
962                         return NULL;
963                 }
964                 if (desc->bLength == UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1) &&
965                     desc->bDescriptorType == USB_DT_CS_INTERFACE &&
966                     desc->bDescriptorSubtype == UAC_FORMAT_TYPE) {
967                         if (desc->bFormatType != UAC_FORMAT_TYPE_I_PCM ||
968                             desc->bSamFreqType != 1) {
969                                 dev_err(&interface->dev,
970                                         "invalid format type\n");
971                                 return NULL;
972                         }
973                         return desc;
974                 }
975                 extralen -= desc->bLength;
976                 extra += desc->bLength;
977         }
978         dev_err(&interface->dev, "sample format descriptor not found\n");
979         return NULL;
980 }
981
982 static int detect_usb_format(struct ua101 *ua)
983 {
984         const struct uac_format_type_i_discrete_descriptor *fmt_capture;
985         const struct uac_format_type_i_discrete_descriptor *fmt_playback;
986         const struct usb_endpoint_descriptor *epd;
987         unsigned int rate2;
988
989         fmt_capture = find_format_descriptor(ua->intf[INTF_CAPTURE]);
990         fmt_playback = find_format_descriptor(ua->intf[INTF_PLAYBACK]);
991         if (!fmt_capture || !fmt_playback)
992                 return -ENXIO;
993
994         switch (fmt_capture->bSubframeSize) {
995         case 3:
996                 ua->format_bit = SNDRV_PCM_FMTBIT_S24_3LE;
997                 break;
998         case 4:
999                 ua->format_bit = SNDRV_PCM_FMTBIT_S32_LE;
1000                 break;
1001         default:
1002                 dev_err(&ua->dev->dev, "sample width is not 24 or 32 bits\n");
1003                 return -ENXIO;
1004         }
1005         if (fmt_capture->bSubframeSize != fmt_playback->bSubframeSize) {
1006                 dev_err(&ua->dev->dev,
1007                         "playback/capture sample widths do not match\n");
1008                 return -ENXIO;
1009         }
1010
1011         if (fmt_capture->bBitResolution != 24 ||
1012             fmt_playback->bBitResolution != 24) {
1013                 dev_err(&ua->dev->dev, "sample width is not 24 bits\n");
1014                 return -ENXIO;
1015         }
1016
1017         ua->rate = combine_triple(fmt_capture->tSamFreq[0]);
1018         rate2 = combine_triple(fmt_playback->tSamFreq[0]);
1019         if (ua->rate != rate2) {
1020                 dev_err(&ua->dev->dev,
1021                         "playback/capture rates do not match: %u/%u\n",
1022                         rate2, ua->rate);
1023                 return -ENXIO;
1024         }
1025
1026         switch (ua->dev->speed) {
1027         case USB_SPEED_FULL:
1028                 ua->packets_per_second = 1000;
1029                 break;
1030         case USB_SPEED_HIGH:
1031                 ua->packets_per_second = 8000;
1032                 break;
1033         default:
1034                 dev_err(&ua->dev->dev, "unknown device speed\n");
1035                 return -ENXIO;
1036         }
1037
1038         ua->capture.channels = fmt_capture->bNrChannels;
1039         ua->playback.channels = fmt_playback->bNrChannels;
1040         ua->capture.frame_bytes =
1041                 fmt_capture->bSubframeSize * ua->capture.channels;
1042         ua->playback.frame_bytes =
1043                 fmt_playback->bSubframeSize * ua->playback.channels;
1044
1045         epd = &ua->intf[INTF_CAPTURE]->altsetting[1].endpoint[0].desc;
1046         if (!usb_endpoint_is_isoc_in(epd)) {
1047                 dev_err(&ua->dev->dev, "invalid capture endpoint\n");
1048                 return -ENXIO;
1049         }
1050         ua->capture.usb_pipe = usb_rcvisocpipe(ua->dev, usb_endpoint_num(epd));
1051         ua->capture.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize);
1052
1053         epd = &ua->intf[INTF_PLAYBACK]->altsetting[1].endpoint[0].desc;
1054         if (!usb_endpoint_is_isoc_out(epd)) {
1055                 dev_err(&ua->dev->dev, "invalid playback endpoint\n");
1056                 return -ENXIO;
1057         }
1058         ua->playback.usb_pipe = usb_sndisocpipe(ua->dev, usb_endpoint_num(epd));
1059         ua->playback.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize);
1060         return 0;
1061 }
1062
1063 static int alloc_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
1064 {
1065         unsigned int remaining_packets, packets, packets_per_page, i;
1066         size_t size;
1067
1068         stream->queue_length = queue_length;
1069         stream->queue_length = max(stream->queue_length,
1070                                    (unsigned int)MIN_QUEUE_LENGTH);
1071         stream->queue_length = min(stream->queue_length,
1072                                    (unsigned int)MAX_QUEUE_LENGTH);
1073
1074         /*
1075          * The cache pool sizes used by usb_buffer_alloc() (128, 512, 2048) are
1076          * quite bad when used with the packet sizes of this device (e.g. 280,
1077          * 520, 624).  Therefore, we allocate and subdivide entire pages, using
1078          * a smaller buffer only for the last chunk.
1079          */
1080         remaining_packets = stream->queue_length;
1081         packets_per_page = PAGE_SIZE / stream->max_packet_bytes;
1082         for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) {
1083                 packets = min(remaining_packets, packets_per_page);
1084                 size = packets * stream->max_packet_bytes;
1085                 stream->buffers[i].addr =
1086                         usb_buffer_alloc(ua->dev, size, GFP_KERNEL,
1087                                          &stream->buffers[i].dma);
1088                 if (!stream->buffers[i].addr)
1089                         return -ENOMEM;
1090                 stream->buffers[i].size = size;
1091                 remaining_packets -= packets;
1092                 if (!remaining_packets)
1093                         break;
1094         }
1095         if (remaining_packets) {
1096                 dev_err(&ua->dev->dev, "too many packets\n");
1097                 return -ENXIO;
1098         }
1099         return 0;
1100 }
1101
1102 static void free_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
1103 {
1104         unsigned int i;
1105
1106         for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i)
1107                 usb_buffer_free(ua->dev,
1108                                 stream->buffers[i].size,
1109                                 stream->buffers[i].addr,
1110                                 stream->buffers[i].dma);
1111 }
1112
1113 static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream,
1114                              void (*urb_complete)(struct urb *))
1115 {
1116         unsigned max_packet_size = stream->max_packet_bytes;
1117         struct ua101_urb *urb;
1118         unsigned int b, u = 0;
1119
1120         for (b = 0; b < ARRAY_SIZE(stream->buffers); ++b) {
1121                 unsigned int size = stream->buffers[b].size;
1122                 u8 *addr = stream->buffers[b].addr;
1123                 dma_addr_t dma = stream->buffers[b].dma;
1124
1125                 while (size >= max_packet_size) {
1126                         if (u >= stream->queue_length)
1127                                 goto bufsize_error;
1128                         urb = kmalloc(sizeof(*urb), GFP_KERNEL);
1129                         if (!urb)
1130                                 return -ENOMEM;
1131                         usb_init_urb(&urb->urb);
1132                         urb->urb.dev = ua->dev;
1133                         urb->urb.pipe = stream->usb_pipe;
1134                         urb->urb.transfer_flags = URB_ISO_ASAP |
1135                                         URB_NO_TRANSFER_DMA_MAP;
1136                         urb->urb.transfer_buffer = addr;
1137                         urb->urb.transfer_dma = dma;
1138                         urb->urb.transfer_buffer_length = max_packet_size;
1139                         urb->urb.number_of_packets = 1;
1140                         urb->urb.interval = 1;
1141                         urb->urb.context = ua;
1142                         urb->urb.complete = urb_complete;
1143                         urb->urb.iso_frame_desc[0].offset = 0;
1144                         urb->urb.iso_frame_desc[0].length = max_packet_size;
1145                         stream->urbs[u++] = urb;
1146                         size -= max_packet_size;
1147                         addr += max_packet_size;
1148                         dma += max_packet_size;
1149                 }
1150         }
1151         if (u == stream->queue_length)
1152                 return 0;
1153 bufsize_error:
1154         dev_err(&ua->dev->dev, "internal buffer size error\n");
1155         return -ENXIO;
1156 }
1157
1158 static void free_stream_urbs(struct ua101_stream *stream)
1159 {
1160         unsigned int i;
1161
1162         for (i = 0; i < stream->queue_length; ++i)
1163                 kfree(stream->urbs[i]);
1164 }
1165
1166 static void free_usb_related_resources(struct ua101 *ua,
1167                                        struct usb_interface *interface)
1168 {
1169         unsigned int i;
1170
1171         free_stream_urbs(&ua->capture);
1172         free_stream_urbs(&ua->playback);
1173         free_stream_buffers(ua, &ua->capture);
1174         free_stream_buffers(ua, &ua->playback);
1175
1176         for (i = 0; i < ARRAY_SIZE(ua->intf); ++i)
1177                 if (ua->intf[i]) {
1178                         usb_set_intfdata(ua->intf[i], NULL);
1179                         if (ua->intf[i] != interface)
1180                                 usb_driver_release_interface(&ua101_driver,
1181                                                              ua->intf[i]);
1182                 }
1183 }
1184
1185 static void ua101_card_free(struct snd_card *card)
1186 {
1187         struct ua101 *ua = card->private_data;
1188
1189         mutex_destroy(&ua->mutex);
1190 }
1191
1192 static int ua101_probe(struct usb_interface *interface,
1193                        const struct usb_device_id *usb_id)
1194 {
1195         static const struct snd_usb_midi_endpoint_info midi_ep = {
1196                 .out_cables = 0x0001,
1197                 .in_cables = 0x0001
1198         };
1199         static const struct snd_usb_audio_quirk midi_quirk = {
1200                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1201                 .data = &midi_ep
1202         };
1203         static const int intf_numbers[2][3] = {
1204                 {       /* UA-101 */
1205                         [INTF_PLAYBACK] = 0,
1206                         [INTF_CAPTURE] = 1,
1207                         [INTF_MIDI] = 2,
1208                 },
1209                 {       /* UA-1000 */
1210                         [INTF_CAPTURE] = 1,
1211                         [INTF_PLAYBACK] = 2,
1212                         [INTF_MIDI] = 3,
1213                 },
1214         };
1215         struct snd_card *card;
1216         struct ua101 *ua;
1217         unsigned int card_index, i;
1218         int is_ua1000;
1219         const char *name;
1220         char usb_path[32];
1221         int err;
1222
1223         is_ua1000 = usb_id->idProduct == 0x0044;
1224
1225         if (interface->altsetting->desc.bInterfaceNumber !=
1226             intf_numbers[is_ua1000][0])
1227                 return -ENODEV;
1228
1229         mutex_lock(&devices_mutex);
1230
1231         for (card_index = 0; card_index < SNDRV_CARDS; ++card_index)
1232                 if (enable[card_index] && !(devices_used & (1 << card_index)))
1233                         break;
1234         if (card_index >= SNDRV_CARDS) {
1235                 mutex_unlock(&devices_mutex);
1236                 return -ENOENT;
1237         }
1238         err = snd_card_create(index[card_index], id[card_index], THIS_MODULE,
1239                               sizeof(*ua), &card);
1240         if (err < 0) {
1241                 mutex_unlock(&devices_mutex);
1242                 return err;
1243         }
1244         card->private_free = ua101_card_free;
1245         ua = card->private_data;
1246         ua->dev = interface_to_usbdev(interface);
1247         ua->card = card;
1248         ua->card_index = card_index;
1249         INIT_LIST_HEAD(&ua->midi_list);
1250         spin_lock_init(&ua->lock);
1251         mutex_init(&ua->mutex);
1252         INIT_LIST_HEAD(&ua->ready_playback_urbs);
1253         tasklet_init(&ua->playback_tasklet,
1254                      playback_tasklet, (unsigned long)ua);
1255         init_waitqueue_head(&ua->alsa_capture_wait);
1256         init_waitqueue_head(&ua->rate_feedback_wait);
1257         init_waitqueue_head(&ua->alsa_playback_wait);
1258
1259 #ifdef UA1A_HACK
1260         if (ua->dev->descriptor.idProduct == cpu_to_le16(0x0018)) {
1261                 ua->intf[2] = interface;
1262                 ua->intf[0] = usb_ifnum_to_if(ua->dev, 1);
1263                 ua->intf[1] = usb_ifnum_to_if(ua->dev, 2);
1264                 usb_driver_claim_interface(&ua101_driver, ua->intf[0], ua);
1265                 usb_driver_claim_interface(&ua101_driver, ua->intf[1], ua);
1266         } else {
1267 #endif
1268         ua->intf[0] = interface;
1269         for (i = 1; i < ARRAY_SIZE(ua->intf); ++i) {
1270                 ua->intf[i] = usb_ifnum_to_if(ua->dev,
1271                                               intf_numbers[is_ua1000][i]);
1272                 if (!ua->intf[i]) {
1273                         dev_err(&ua->dev->dev, "interface %u not found\n",
1274                                 intf_numbers[is_ua1000][i]);
1275                         err = -ENXIO;
1276                         goto probe_error;
1277                 }
1278                 err = usb_driver_claim_interface(&ua101_driver,
1279                                                  ua->intf[i], ua);
1280                 if (err < 0) {
1281                         ua->intf[i] = NULL;
1282                         err = -EBUSY;
1283                         goto probe_error;
1284                 }
1285         }
1286 #ifdef UA1A_HACK
1287         }
1288 #endif
1289
1290         snd_card_set_dev(card, &interface->dev);
1291
1292 #ifdef UA1A_HACK
1293         if (ua->dev->descriptor.idProduct == cpu_to_le16(0x0018)) {
1294                 ua->format_bit = SNDRV_PCM_FMTBIT_S16_LE;
1295                 ua->rate = 44100;
1296                 ua->packets_per_second = 1000;
1297                 ua->capture.channels = 2;
1298                 ua->playback.channels = 2;
1299                 ua->capture.frame_bytes = 4;
1300                 ua->playback.frame_bytes = 4;
1301                 ua->capture.usb_pipe = usb_rcvisocpipe(ua->dev, 2);
1302                 ua->playback.usb_pipe = usb_sndisocpipe(ua->dev, 1);
1303                 ua->capture.max_packet_bytes = 192;
1304                 ua->playback.max_packet_bytes = 192;
1305         } else {
1306 #endif
1307         err = detect_usb_format(ua);
1308         if (err < 0)
1309                 goto probe_error;
1310 #ifdef UA1A_HACK
1311         }
1312 #endif
1313
1314         name = usb_id->idProduct == 0x0044 ? "UA-1000" : "UA-101";
1315         strcpy(card->driver, "UA-101");
1316         strcpy(card->shortname, name);
1317         usb_make_path(ua->dev, usb_path, sizeof(usb_path));
1318         snprintf(ua->card->longname, sizeof(ua->card->longname),
1319                  "EDIROL %s (serial %s), %u Hz at %s, %s speed", name,
1320                  ua->dev->serial ? ua->dev->serial : "?", ua->rate, usb_path,
1321                  ua->dev->speed == USB_SPEED_HIGH ? "high" : "full");
1322
1323         err = alloc_stream_buffers(ua, &ua->capture);
1324         if (err < 0)
1325                 goto probe_error;
1326         err = alloc_stream_buffers(ua, &ua->playback);
1327         if (err < 0)
1328                 goto probe_error;
1329
1330         err = alloc_stream_urbs(ua, &ua->capture, capture_urb_complete);
1331         if (err < 0)
1332                 goto probe_error;
1333         err = alloc_stream_urbs(ua, &ua->playback, playback_urb_complete);
1334         if (err < 0)
1335                 goto probe_error;
1336
1337         err = snd_pcm_new(card, name, 0, 1, 1, &ua->pcm);
1338         if (err < 0)
1339                 goto probe_error;
1340         ua->pcm->private_data = ua;
1341         strcpy(ua->pcm->name, name);
1342         snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_pcm_ops);
1343         snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_pcm_ops);
1344
1345 #ifdef UA1A_HACK
1346         if (ua->dev->descriptor.idProduct != cpu_to_le16(0x0018)) {
1347 #endif
1348         err = snd_usbmidi_create(card, ua->intf[INTF_MIDI],
1349                                  &ua->midi_list, &midi_quirk);
1350         if (err < 0)
1351                 goto probe_error;
1352 #ifdef UA1A_HACK
1353         }
1354 #endif
1355
1356         err = snd_card_register(card);
1357         if (err < 0)
1358                 goto probe_error;
1359
1360         usb_set_intfdata(interface, ua);
1361         devices_used |= 1 << card_index;
1362
1363         mutex_unlock(&devices_mutex);
1364         return 0;
1365
1366 probe_error:
1367         free_usb_related_resources(ua, interface);
1368         snd_card_free(card);
1369         mutex_unlock(&devices_mutex);
1370         return err;
1371 }
1372
1373 static void ua101_disconnect(struct usb_interface *interface)
1374 {
1375         struct ua101 *ua = usb_get_intfdata(interface);
1376         struct list_head *midi;
1377
1378         if (!ua)
1379                 return;
1380
1381         mutex_lock(&devices_mutex);
1382
1383         set_bit(DISCONNECTED, &ua->states);
1384         wake_up(&ua->rate_feedback_wait);
1385
1386         /* make sure that userspace cannot create new requests */
1387         snd_card_disconnect(ua->card);
1388
1389         /* make sure that there are no pending USB requests */
1390         __list_for_each(midi, &ua->midi_list)
1391                 snd_usbmidi_disconnect(midi);
1392         abort_alsa_playback(ua);
1393         abort_alsa_capture(ua);
1394         mutex_lock(&ua->mutex);
1395         stop_usb_playback(ua);
1396         stop_usb_capture(ua);
1397         mutex_unlock(&ua->mutex);
1398
1399         free_usb_related_resources(ua, interface);
1400
1401         devices_used &= ~(1 << ua->card_index);
1402
1403         snd_card_free_when_closed(ua->card);
1404
1405         mutex_unlock(&devices_mutex);
1406 }
1407
1408 static struct usb_device_id ua101_ids[] = {
1409 #ifdef UA1A_HACK
1410         { USB_DEVICE(0x0582, 0x0018) },
1411 #endif
1412         { USB_DEVICE(0x0582, 0x0044) }, /* UA-1000 high speed */
1413         { USB_DEVICE(0x0582, 0x007d) }, /* UA-101 high speed */
1414         { USB_DEVICE(0x0582, 0x008d) }, /* UA-101 full speed */
1415         { }
1416 };
1417 MODULE_DEVICE_TABLE(usb, ua101_ids);
1418
1419 static struct usb_driver ua101_driver = {
1420         .name = "snd-ua101",
1421         .id_table = ua101_ids,
1422         .probe = ua101_probe,
1423         .disconnect = ua101_disconnect,
1424 #if 0
1425         .suspend = ua101_suspend,
1426         .resume = ua101_resume,
1427 #endif
1428 };
1429
1430 static int __init alsa_card_ua101_init(void)
1431 {
1432         return usb_register(&ua101_driver);
1433 }
1434
1435 static void __exit alsa_card_ua101_exit(void)
1436 {
1437         usb_deregister(&ua101_driver);
1438         mutex_destroy(&devices_mutex);
1439 }
1440
1441 module_init(alsa_card_ua101_init);
1442 module_exit(alsa_card_ua101_exit);