]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - sound/usb/caiaq/caiaq-audio.c
08d51e0c9feae466175f87cb45fe87cebbcd13ec
[linux-2.6.git] / sound / usb / caiaq / caiaq-audio.c
1 /*
2  *   Copyright (c) 2006-2008 Daniel Mack, Karsten Wiese
3  *
4  *   This program is free software; you can redistribute it and/or modify
5  *   it under the terms of the GNU General Public License as published by
6  *   the Free Software Foundation; either version 2 of the License, or
7  *   (at your option) any later version.
8  *
9  *   This program is distributed in the hope that it will be useful,
10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  *   GNU General Public License for more details.
13  *
14  *   You should have received a copy of the GNU General Public License
15  *   along with this program; if not, write to the Free Software
16  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
17 */
18
19 #include <linux/init.h>
20 #include <linux/module.h>
21 #include <linux/moduleparam.h>
22 #include <linux/interrupt.h>
23 #include <linux/usb.h>
24 #include <linux/spinlock.h>
25 #include <sound/core.h>
26 #include <sound/initval.h>
27 #include <sound/pcm.h>
28 #include <sound/rawmidi.h>
29 #include <linux/input.h>
30
31 #include "caiaq-device.h"
32 #include "caiaq-audio.h"
33
34 #define N_URBS                  32
35 #define CLOCK_DRIFT_TOLERANCE   5
36 #define FRAMES_PER_URB          8
37 #define BYTES_PER_FRAME         512
38 #define CHANNELS_PER_STREAM     2
39 #define BYTES_PER_SAMPLE        3
40 #define BYTES_PER_SAMPLE_USB    4
41 #define MAX_BUFFER_SIZE         (128*1024)
42 #define MAX_ENDPOINT_SIZE       512
43
44 #define ENDPOINT_CAPTURE        2
45 #define ENDPOINT_PLAYBACK       6
46
47 #define MAKE_CHECKBYTE(dev,stream,i) \
48         (stream << 1) | (~(i / (dev->n_streams * BYTES_PER_SAMPLE_USB)) & 1)
49
50 static struct snd_pcm_hardware snd_usb_caiaq_pcm_hardware = {
51         .info           = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 
52                            SNDRV_PCM_INFO_BLOCK_TRANSFER),
53         .formats        = SNDRV_PCM_FMTBIT_S24_3BE,
54         .rates          = (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | 
55                            SNDRV_PCM_RATE_96000),
56         .rate_min       = 44100,
57         .rate_max       = 0, /* will overwrite later */
58         .channels_min   = CHANNELS_PER_STREAM,
59         .channels_max   = CHANNELS_PER_STREAM,
60         .buffer_bytes_max = MAX_BUFFER_SIZE,
61         .period_bytes_min = 128,
62         .period_bytes_max = MAX_BUFFER_SIZE,
63         .periods_min    = 1,
64         .periods_max    = 1024,
65 };
66
67 static void
68 activate_substream(struct snd_usb_caiaqdev *dev,
69                    struct snd_pcm_substream *sub)
70 {
71         if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
72                 dev->sub_playback[sub->number] = sub;
73         else
74                 dev->sub_capture[sub->number] = sub;
75 }
76
77 static void 
78 deactivate_substream(struct snd_usb_caiaqdev *dev,
79                      struct snd_pcm_substream *sub)
80 {
81         unsigned long flags;
82         spin_lock_irqsave(&dev->spinlock, flags);
83
84         if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
85                 dev->sub_playback[sub->number] = NULL;
86         else
87                 dev->sub_capture[sub->number] = NULL;
88
89         spin_unlock_irqrestore(&dev->spinlock, flags);
90 }
91
92 static int
93 all_substreams_zero(struct snd_pcm_substream **subs)
94 {
95         int i;
96         for (i = 0; i < MAX_STREAMS; i++)
97                 if (subs[i] != NULL)
98                         return 0;
99         return 1;
100 }
101
102 static int stream_start(struct snd_usb_caiaqdev *dev)
103 {
104         int i, ret;
105
106         debug("%s(%p)\n", __func__, dev);
107
108         if (dev->streaming)
109                 return -EINVAL;
110
111         memset(dev->sub_playback, 0, sizeof(dev->sub_playback));
112         memset(dev->sub_capture, 0, sizeof(dev->sub_capture));
113         dev->input_panic = 0;
114         dev->output_panic = 0;
115         dev->first_packet = 1;
116         dev->streaming = 1;
117         dev->warned = 0;
118
119         for (i = 0; i < N_URBS; i++) {
120                 ret = usb_submit_urb(dev->data_urbs_in[i], GFP_ATOMIC);
121                 if (ret) {
122                         log("unable to trigger read #%d! (ret %d)\n", i, ret);
123                         dev->streaming = 0;
124                         return -EPIPE;
125                 }
126         }
127         
128         return 0;
129 }
130
131 static void stream_stop(struct snd_usb_caiaqdev *dev)
132 {
133         int i;
134
135         debug("%s(%p)\n", __func__, dev);
136         if (!dev->streaming)
137                 return;
138         
139         dev->streaming = 0;
140
141         for (i = 0; i < N_URBS; i++) {
142                 usb_kill_urb(dev->data_urbs_in[i]);
143                 usb_kill_urb(dev->data_urbs_out[i]);
144         }
145 }
146
147 static int snd_usb_caiaq_substream_open(struct snd_pcm_substream *substream)
148 {
149         struct snd_usb_caiaqdev *dev = snd_pcm_substream_chip(substream);
150         debug("%s(%p)\n", __func__, substream);
151         substream->runtime->hw = dev->pcm_info;
152         snd_pcm_limit_hw_rates(substream->runtime);
153         return 0;
154 }
155
156 static int snd_usb_caiaq_substream_close(struct snd_pcm_substream *substream)
157 {
158         struct snd_usb_caiaqdev *dev = snd_pcm_substream_chip(substream);
159
160         debug("%s(%p)\n", __func__, substream);
161         if (all_substreams_zero(dev->sub_playback) &&
162             all_substreams_zero(dev->sub_capture)) {
163                 /* when the last client has stopped streaming, 
164                  * all sample rates are allowed again */
165                 stream_stop(dev);
166                 dev->pcm_info.rates = dev->samplerates;
167         }
168
169         return 0;
170 }
171
172 static int snd_usb_caiaq_pcm_hw_params(struct snd_pcm_substream *sub,
173                                         struct snd_pcm_hw_params *hw_params)
174 {
175         debug("%s(%p)\n", __func__, sub);
176         return snd_pcm_lib_malloc_pages(sub, params_buffer_bytes(hw_params));
177 }
178
179 static int snd_usb_caiaq_pcm_hw_free(struct snd_pcm_substream *sub)
180 {
181         struct snd_usb_caiaqdev *dev = snd_pcm_substream_chip(sub);
182         debug("%s(%p)\n", __func__, sub);
183         deactivate_substream(dev, sub);
184         return snd_pcm_lib_free_pages(sub);
185 }
186
187 /* this should probably go upstream */
188 #if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12
189 #error "Change this table"
190 #endif
191
192 static unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100,
193                                  48000, 64000, 88200, 96000, 176400, 192000 };
194
195 static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream *substream)
196 {
197         int bytes_per_sample, bpp, ret, i;
198         int index = substream->number;
199         struct snd_usb_caiaqdev *dev = snd_pcm_substream_chip(substream);
200         struct snd_pcm_runtime *runtime = substream->runtime;
201
202         debug("%s(%p)\n", __func__, substream);
203         
204         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
205                 dev->audio_out_buf_pos[index] = BYTES_PER_SAMPLE + 1;
206         else
207                 dev->audio_in_buf_pos[index] = BYTES_PER_SAMPLE;
208         
209         if (dev->streaming)
210                 return 0;
211         
212         /* the first client that opens a stream defines the sample rate
213          * setting for all subsequent calls, until the last client closed. */
214         for (i=0; i < ARRAY_SIZE(rates); i++)
215                 if (runtime->rate == rates[i])
216                         dev->pcm_info.rates = 1 << i;
217         
218         snd_pcm_limit_hw_rates(runtime);
219
220         bytes_per_sample = BYTES_PER_SAMPLE;
221         if (dev->spec.data_alignment == 2)
222                 bytes_per_sample++;
223         
224         bpp = ((runtime->rate / 8000) + CLOCK_DRIFT_TOLERANCE)
225                 * bytes_per_sample * CHANNELS_PER_STREAM * dev->n_streams;
226
227         if (bpp > MAX_ENDPOINT_SIZE)
228                 bpp = MAX_ENDPOINT_SIZE;
229
230         ret = snd_usb_caiaq_set_audio_params(dev, runtime->rate,
231                                              runtime->sample_bits, bpp);
232         if (ret)
233                 return ret;
234
235         ret = stream_start(dev);
236         if (ret)
237                 return ret;
238         
239         dev->output_running = 0;
240         wait_event_timeout(dev->prepare_wait_queue, dev->output_running, HZ);
241         if (!dev->output_running) {
242                 stream_stop(dev);
243                 return -EPIPE;
244         }
245
246         return 0;
247 }
248
249 static int snd_usb_caiaq_pcm_trigger(struct snd_pcm_substream *sub, int cmd)
250 {
251         struct snd_usb_caiaqdev *dev = snd_pcm_substream_chip(sub);
252
253         switch (cmd) {
254         case SNDRV_PCM_TRIGGER_START:
255         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
256                 activate_substream(dev, sub);
257                 break;
258         case SNDRV_PCM_TRIGGER_STOP:
259         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
260                 deactivate_substream(dev, sub);
261                 break;
262         default:
263                 return -EINVAL;
264         }
265
266         return 0;
267 }
268
269 static snd_pcm_uframes_t
270 snd_usb_caiaq_pcm_pointer(struct snd_pcm_substream *sub)
271 {
272         int index = sub->number;
273         struct snd_usb_caiaqdev *dev = snd_pcm_substream_chip(sub);
274
275         if (dev->input_panic || dev->output_panic)
276                 return SNDRV_PCM_POS_XRUN;
277
278         if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
279                 return bytes_to_frames(sub->runtime, 
280                                         dev->audio_out_buf_pos[index]);
281         else
282                 return bytes_to_frames(sub->runtime,
283                                         dev->audio_in_buf_pos[index]);
284 }
285
286 /* operators for both playback and capture */
287 static struct snd_pcm_ops snd_usb_caiaq_ops = {
288         .open =         snd_usb_caiaq_substream_open,
289         .close =        snd_usb_caiaq_substream_close,
290         .ioctl =        snd_pcm_lib_ioctl,
291         .hw_params =    snd_usb_caiaq_pcm_hw_params,
292         .hw_free =      snd_usb_caiaq_pcm_hw_free,
293         .prepare =      snd_usb_caiaq_pcm_prepare,
294         .trigger =      snd_usb_caiaq_pcm_trigger,
295         .pointer =      snd_usb_caiaq_pcm_pointer
296 };
297         
298 static void check_for_elapsed_periods(struct snd_usb_caiaqdev *dev,
299                                       struct snd_pcm_substream **subs)
300 {
301         int stream, pb, *cnt;
302         struct snd_pcm_substream *sub;
303
304         for (stream = 0; stream < dev->n_streams; stream++) {
305                 sub = subs[stream];
306                 if (!sub)
307                         continue;
308
309                 pb = frames_to_bytes(sub->runtime, 
310                                      sub->runtime->period_size);
311                 cnt = (sub->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
312                                         &dev->period_out_count[stream] :
313                                         &dev->period_in_count[stream];
314
315                 if (*cnt >= pb) {
316                         snd_pcm_period_elapsed(sub);
317                         *cnt %= pb;
318                 }
319         }
320 }
321
322 static void read_in_urb_mode0(struct snd_usb_caiaqdev *dev,
323                               const struct urb *urb,
324                               const struct usb_iso_packet_descriptor *iso)
325 {
326         unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
327         struct snd_pcm_substream *sub;
328         int stream, i;
329
330         if (all_substreams_zero(dev->sub_capture))
331                 return;
332
333         for (i = 0; i < iso->actual_length;) {
334                 for (stream = 0; stream < dev->n_streams; stream++, i++) {
335                         sub = dev->sub_capture[stream];
336                         if (sub) {
337                                 struct snd_pcm_runtime *rt = sub->runtime;
338                                 char *audio_buf = rt->dma_area;
339                                 int sz = frames_to_bytes(rt, rt->buffer_size);
340                                 audio_buf[dev->audio_in_buf_pos[stream]++] 
341                                         = usb_buf[i];
342                                 dev->period_in_count[stream]++;
343                                 if (dev->audio_in_buf_pos[stream] == sz)
344                                         dev->audio_in_buf_pos[stream] = 0;
345                         }
346                 }
347         }
348 }
349
350 static void read_in_urb_mode2(struct snd_usb_caiaqdev *dev,
351                               const struct urb *urb,
352                               const struct usb_iso_packet_descriptor *iso)
353 {
354         unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
355         unsigned char check_byte;
356         struct snd_pcm_substream *sub;
357         int stream, i;
358
359         for (i = 0; i < iso->actual_length;) {
360                 if (i % (dev->n_streams * BYTES_PER_SAMPLE_USB) == 0) {
361                         for (stream = 0; 
362                              stream < dev->n_streams; 
363                              stream++, i++) {
364                                 if (dev->first_packet)
365                                         continue;
366
367                                 check_byte = MAKE_CHECKBYTE(dev, stream, i);
368                                 
369                                 if ((usb_buf[i] & 0x3f) != check_byte)
370                                         dev->input_panic = 1;
371
372                                 if (usb_buf[i] & 0x80)
373                                         dev->output_panic = 1;
374                         }
375                 }
376                 dev->first_packet = 0;
377
378                 for (stream = 0; stream < dev->n_streams; stream++, i++) {
379                         sub = dev->sub_capture[stream];
380                         if (dev->input_panic)
381                                 usb_buf[i] = 0;
382
383                         if (sub) {
384                                 struct snd_pcm_runtime *rt = sub->runtime;
385                                 char *audio_buf = rt->dma_area;
386                                 int sz = frames_to_bytes(rt, rt->buffer_size);
387                                 audio_buf[dev->audio_in_buf_pos[stream]++] =
388                                         usb_buf[i];
389                                 dev->period_in_count[stream]++;
390                                 if (dev->audio_in_buf_pos[stream] == sz)
391                                         dev->audio_in_buf_pos[stream] = 0;
392                         }
393                 }
394         }
395 }
396
397 static void read_in_urb(struct snd_usb_caiaqdev *dev,
398                         const struct urb *urb,
399                         const struct usb_iso_packet_descriptor *iso)
400 {
401         if (!dev->streaming)
402                 return;
403
404         if (iso->actual_length < dev->bpp)
405                 return;
406
407         switch (dev->spec.data_alignment) {
408         case 0:
409                 read_in_urb_mode0(dev, urb, iso);
410                 break;
411         case 2:
412                 read_in_urb_mode2(dev, urb, iso);
413                 break;
414         }
415
416         if ((dev->input_panic || dev->output_panic) && !dev->warned) {
417                 debug("streaming error detected %s %s\n", 
418                                 dev->input_panic ? "(input)" : "",
419                                 dev->output_panic ? "(output)" : "");
420                 dev->warned = 1;
421         }
422 }
423
424 static void fill_out_urb(struct snd_usb_caiaqdev *dev, 
425                          struct urb *urb, 
426                          const struct usb_iso_packet_descriptor *iso)
427 {
428         unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
429         struct snd_pcm_substream *sub;
430         int stream, i;
431         
432         for (i = 0; i < iso->length;) {
433                 for (stream = 0; stream < dev->n_streams; stream++, i++) {
434                         sub = dev->sub_playback[stream];
435                         if (sub) {
436                                 struct snd_pcm_runtime *rt = sub->runtime;
437                                 char *audio_buf = rt->dma_area;
438                                 int sz = frames_to_bytes(rt, rt->buffer_size);
439                                 usb_buf[i] =
440                                         audio_buf[dev->audio_out_buf_pos[stream]];
441                                 dev->period_out_count[stream]++;
442                                 dev->audio_out_buf_pos[stream]++;
443                                 if (dev->audio_out_buf_pos[stream] == sz)
444                                         dev->audio_out_buf_pos[stream] = 0;
445                         } else
446                                 usb_buf[i] = 0;
447                 }
448
449                 /* fill in the check bytes */
450                 if (dev->spec.data_alignment == 2 &&
451                     i % (dev->n_streams * BYTES_PER_SAMPLE_USB) == 
452                         (dev->n_streams * CHANNELS_PER_STREAM))
453                     for (stream = 0; stream < dev->n_streams; stream++, i++)
454                         usb_buf[i] = MAKE_CHECKBYTE(dev, stream, i);
455         }
456 }
457
458 static void read_completed(struct urb *urb)
459 {
460         struct snd_usb_caiaq_cb_info *info = urb->context; 
461         struct snd_usb_caiaqdev *dev;
462         struct urb *out;
463         int frame, len, send_it = 0, outframe = 0;
464
465         if (urb->status || !info)
466                 return;
467
468         dev = info->dev;
469
470         if (!dev->streaming)
471                 return;
472
473         out = dev->data_urbs_out[info->index];
474
475         /* read the recently received packet and send back one which has
476          * the same layout */
477         for (frame = 0; frame < FRAMES_PER_URB; frame++) {
478                 if (urb->iso_frame_desc[frame].status)
479                         continue;
480
481                 len = urb->iso_frame_desc[outframe].actual_length;
482                 out->iso_frame_desc[outframe].length = len;
483                 out->iso_frame_desc[outframe].actual_length = 0;
484                 out->iso_frame_desc[outframe].offset = BYTES_PER_FRAME * frame;
485                 
486                 if (len > 0) {
487                         spin_lock(&dev->spinlock);
488                         fill_out_urb(dev, out, &out->iso_frame_desc[outframe]);
489                         read_in_urb(dev, urb, &urb->iso_frame_desc[frame]);
490                         spin_unlock(&dev->spinlock);
491                         check_for_elapsed_periods(dev, dev->sub_playback);
492                         check_for_elapsed_periods(dev, dev->sub_capture);
493                         send_it = 1;
494                 }
495
496                 outframe++;
497         }
498
499         if (send_it) {
500                 out->number_of_packets = FRAMES_PER_URB;
501                 out->transfer_flags = URB_ISO_ASAP;
502                 usb_submit_urb(out, GFP_ATOMIC);
503         }
504         
505         /* re-submit inbound urb */
506         for (frame = 0; frame < FRAMES_PER_URB; frame++) {
507                 urb->iso_frame_desc[frame].offset = BYTES_PER_FRAME * frame;
508                 urb->iso_frame_desc[frame].length = BYTES_PER_FRAME;
509                 urb->iso_frame_desc[frame].actual_length = 0;
510         }
511         
512         urb->number_of_packets = FRAMES_PER_URB;
513         urb->transfer_flags = URB_ISO_ASAP;
514         usb_submit_urb(urb, GFP_ATOMIC);
515 }
516
517 static void write_completed(struct urb *urb)
518 {
519         struct snd_usb_caiaq_cb_info *info = urb->context;
520         struct snd_usb_caiaqdev *dev = info->dev;
521
522         if (!dev->output_running) {
523                 dev->output_running = 1;
524                 wake_up(&dev->prepare_wait_queue);
525         }
526 }
527
528 static struct urb **alloc_urbs(struct snd_usb_caiaqdev *dev, int dir, int *ret)
529 {
530         int i, frame;
531         struct urb **urbs;
532         struct usb_device *usb_dev = dev->chip.dev;
533         unsigned int pipe;
534
535         pipe = (dir == SNDRV_PCM_STREAM_PLAYBACK) ? 
536                 usb_sndisocpipe(usb_dev, ENDPOINT_PLAYBACK) :
537                 usb_rcvisocpipe(usb_dev, ENDPOINT_CAPTURE);
538
539         urbs = kmalloc(N_URBS * sizeof(*urbs), GFP_KERNEL);
540         if (!urbs) {
541                 log("unable to kmalloc() urbs, OOM!?\n");
542                 *ret = -ENOMEM;
543                 return NULL;
544         }
545
546         for (i = 0; i < N_URBS; i++) {
547                 urbs[i] = usb_alloc_urb(FRAMES_PER_URB, GFP_KERNEL);
548                 if (!urbs[i]) {
549                         log("unable to usb_alloc_urb(), OOM!?\n");
550                         *ret = -ENOMEM;
551                         return urbs;
552                 }
553
554                 urbs[i]->transfer_buffer = 
555                         kmalloc(FRAMES_PER_URB * BYTES_PER_FRAME, GFP_KERNEL);
556                 if (!urbs[i]->transfer_buffer) {
557                         log("unable to kmalloc() transfer buffer, OOM!?\n");
558                         *ret = -ENOMEM;
559                         return urbs;
560                 }
561                 
562                 for (frame = 0; frame < FRAMES_PER_URB; frame++) {
563                         struct usb_iso_packet_descriptor *iso = 
564                                 &urbs[i]->iso_frame_desc[frame];
565                         
566                         iso->offset = BYTES_PER_FRAME * frame;
567                         iso->length = BYTES_PER_FRAME;
568                 }
569                 
570                 urbs[i]->dev = usb_dev;
571                 urbs[i]->pipe = pipe;
572                 urbs[i]->transfer_buffer_length = FRAMES_PER_URB 
573                                                 * BYTES_PER_FRAME;
574                 urbs[i]->context = &dev->data_cb_info[i];
575                 urbs[i]->interval = 1;
576                 urbs[i]->transfer_flags = URB_ISO_ASAP;
577                 urbs[i]->number_of_packets = FRAMES_PER_URB;
578                 urbs[i]->complete = (dir == SNDRV_PCM_STREAM_CAPTURE) ?
579                                         read_completed : write_completed;
580         }
581
582         *ret = 0;
583         return urbs;
584 }
585
586 static void free_urbs(struct urb **urbs)
587 {
588         int i;
589
590         if (!urbs)
591                 return;
592
593         for (i = 0; i < N_URBS; i++) {
594                 if (!urbs[i])
595                         continue;
596                 
597                 usb_kill_urb(urbs[i]);
598                 kfree(urbs[i]->transfer_buffer);
599                 usb_free_urb(urbs[i]);
600         }
601
602         kfree(urbs);
603 }
604
605 int snd_usb_caiaq_audio_init(struct snd_usb_caiaqdev *dev)
606 {
607         int i, ret;
608
609         dev->n_audio_in  = max(dev->spec.num_analog_audio_in, 
610                                dev->spec.num_digital_audio_in) / 
611                                 CHANNELS_PER_STREAM;
612         dev->n_audio_out = max(dev->spec.num_analog_audio_out,
613                                dev->spec.num_digital_audio_out) / 
614                                 CHANNELS_PER_STREAM;
615         dev->n_streams = max(dev->n_audio_in, dev->n_audio_out);
616
617         debug("dev->n_audio_in = %d\n", dev->n_audio_in);
618         debug("dev->n_audio_out = %d\n", dev->n_audio_out);
619         debug("dev->n_streams = %d\n", dev->n_streams);
620
621         if (dev->n_streams > MAX_STREAMS) {
622                 log("unable to initialize device, too many streams.\n");
623                 return -EINVAL;
624         }
625
626         ret = snd_pcm_new(dev->chip.card, dev->product_name, 0, 
627                         dev->n_audio_out, dev->n_audio_in, &dev->pcm);
628
629         if (ret < 0) {
630                 log("snd_pcm_new() returned %d\n", ret);
631                 return ret;
632         }
633
634         dev->pcm->private_data = dev;
635         strcpy(dev->pcm->name, dev->product_name);
636
637         memset(dev->sub_playback, 0, sizeof(dev->sub_playback));
638         memset(dev->sub_capture, 0, sizeof(dev->sub_capture));
639         
640         memcpy(&dev->pcm_info, &snd_usb_caiaq_pcm_hardware,
641                         sizeof(snd_usb_caiaq_pcm_hardware));
642
643         /* setup samplerates */
644         dev->samplerates = dev->pcm_info.rates;
645         switch (dev->chip.usb_id) {
646         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):
647         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
648         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_SESSIONIO):
649         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_GUITARRIGMOBILE):
650                 dev->samplerates |= SNDRV_PCM_RATE_192000;
651                 /* fall thru */
652         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ):
653         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ):
654                 dev->samplerates |= SNDRV_PCM_RATE_88200;
655                 break;
656         }
657
658         snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_PLAYBACK, 
659                                 &snd_usb_caiaq_ops);
660         snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_CAPTURE, 
661                                 &snd_usb_caiaq_ops);
662
663         snd_pcm_lib_preallocate_pages_for_all(dev->pcm,
664                                         SNDRV_DMA_TYPE_CONTINUOUS,
665                                         snd_dma_continuous_data(GFP_KERNEL),
666                                         MAX_BUFFER_SIZE, MAX_BUFFER_SIZE);
667
668         dev->data_cb_info =
669                 kmalloc(sizeof(struct snd_usb_caiaq_cb_info) * N_URBS, 
670                                         GFP_KERNEL);
671
672         if (!dev->data_cb_info)
673                 return -ENOMEM;
674
675         for (i = 0; i < N_URBS; i++) {
676                 dev->data_cb_info[i].dev = dev;
677                 dev->data_cb_info[i].index = i;
678         }
679         
680         dev->data_urbs_in = alloc_urbs(dev, SNDRV_PCM_STREAM_CAPTURE, &ret);
681         if (ret < 0) {
682                 kfree(dev->data_cb_info);
683                 free_urbs(dev->data_urbs_in);
684                 return ret;
685         }
686         
687         dev->data_urbs_out = alloc_urbs(dev, SNDRV_PCM_STREAM_PLAYBACK, &ret);
688         if (ret < 0) {
689                 kfree(dev->data_cb_info);
690                 free_urbs(dev->data_urbs_in);
691                 free_urbs(dev->data_urbs_out);
692                 return ret;
693         }
694
695         return 0;
696 }
697
698 void snd_usb_caiaq_audio_free(struct snd_usb_caiaqdev *dev)
699 {
700         debug("%s(%p)\n", __func__, dev);
701         stream_stop(dev);
702         free_urbs(dev->data_urbs_in);
703         free_urbs(dev->data_urbs_out);
704         kfree(dev->data_cb_info);
705 }
706