2 * Copyright (c) 2006-2008 Daniel Mack, Karsten Wiese
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.
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.
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
19 #include <linux/spinlock.h>
20 #include <linux/slab.h>
21 #include <linux/init.h>
22 #include <linux/usb.h>
23 #include <sound/core.h>
24 #include <sound/pcm.h>
30 #define CLOCK_DRIFT_TOLERANCE 5
31 #define FRAMES_PER_URB 8
32 #define BYTES_PER_FRAME 512
33 #define CHANNELS_PER_STREAM 2
34 #define BYTES_PER_SAMPLE 3
35 #define BYTES_PER_SAMPLE_USB 4
36 #define MAX_BUFFER_SIZE (128*1024)
37 #define MAX_ENDPOINT_SIZE 512
39 #define ENDPOINT_CAPTURE 2
40 #define ENDPOINT_PLAYBACK 6
42 #define MAKE_CHECKBYTE(dev,stream,i) \
43 (stream << 1) | (~(i / (dev->n_streams * BYTES_PER_SAMPLE_USB)) & 1)
45 static struct snd_pcm_hardware snd_usb_caiaq_pcm_hardware
= {
46 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
47 SNDRV_PCM_INFO_BLOCK_TRANSFER
),
48 .formats
= SNDRV_PCM_FMTBIT_S24_3BE
,
49 .rates
= (SNDRV_PCM_RATE_44100
| SNDRV_PCM_RATE_48000
|
50 SNDRV_PCM_RATE_96000
),
52 .rate_max
= 0, /* will overwrite later */
53 .channels_min
= CHANNELS_PER_STREAM
,
54 .channels_max
= CHANNELS_PER_STREAM
,
55 .buffer_bytes_max
= MAX_BUFFER_SIZE
,
56 .period_bytes_min
= 128,
57 .period_bytes_max
= MAX_BUFFER_SIZE
,
63 activate_substream(struct snd_usb_caiaqdev
*dev
,
64 struct snd_pcm_substream
*sub
)
66 spin_lock(&dev
->spinlock
);
68 if (sub
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
69 dev
->sub_playback
[sub
->number
] = sub
;
71 dev
->sub_capture
[sub
->number
] = sub
;
73 spin_unlock(&dev
->spinlock
);
77 deactivate_substream(struct snd_usb_caiaqdev
*dev
,
78 struct snd_pcm_substream
*sub
)
81 spin_lock_irqsave(&dev
->spinlock
, flags
);
83 if (sub
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
84 dev
->sub_playback
[sub
->number
] = NULL
;
86 dev
->sub_capture
[sub
->number
] = NULL
;
88 spin_unlock_irqrestore(&dev
->spinlock
, flags
);
92 all_substreams_zero(struct snd_pcm_substream
**subs
)
95 for (i
= 0; i
< MAX_STREAMS
; i
++)
101 static int stream_start(struct snd_usb_caiaqdev
*dev
)
105 debug("%s(%p)\n", __func__
, dev
);
110 memset(dev
->sub_playback
, 0, sizeof(dev
->sub_playback
));
111 memset(dev
->sub_capture
, 0, sizeof(dev
->sub_capture
));
112 dev
->input_panic
= 0;
113 dev
->output_panic
= 0;
114 dev
->first_packet
= 4;
118 for (i
= 0; i
< N_URBS
; i
++) {
119 ret
= usb_submit_urb(dev
->data_urbs_in
[i
], GFP_ATOMIC
);
121 log("unable to trigger read #%d! (ret %d)\n", i
, ret
);
130 static void stream_stop(struct snd_usb_caiaqdev
*dev
)
134 debug("%s(%p)\n", __func__
, dev
);
140 for (i
= 0; i
< N_URBS
; i
++) {
141 usb_kill_urb(dev
->data_urbs_in
[i
]);
143 if (test_bit(i
, &dev
->outurb_active_mask
))
144 usb_kill_urb(dev
->data_urbs_out
[i
]);
147 dev
->outurb_active_mask
= 0;
150 static int snd_usb_caiaq_substream_open(struct snd_pcm_substream
*substream
)
152 struct snd_usb_caiaqdev
*dev
= snd_pcm_substream_chip(substream
);
153 debug("%s(%p)\n", __func__
, substream
);
154 substream
->runtime
->hw
= dev
->pcm_info
;
155 snd_pcm_limit_hw_rates(substream
->runtime
);
159 static int snd_usb_caiaq_substream_close(struct snd_pcm_substream
*substream
)
161 struct snd_usb_caiaqdev
*dev
= snd_pcm_substream_chip(substream
);
163 debug("%s(%p)\n", __func__
, substream
);
164 if (all_substreams_zero(dev
->sub_playback
) &&
165 all_substreams_zero(dev
->sub_capture
)) {
166 /* when the last client has stopped streaming,
167 * all sample rates are allowed again */
169 dev
->pcm_info
.rates
= dev
->samplerates
;
175 static int snd_usb_caiaq_pcm_hw_params(struct snd_pcm_substream
*sub
,
176 struct snd_pcm_hw_params
*hw_params
)
178 debug("%s(%p)\n", __func__
, sub
);
179 return snd_pcm_lib_malloc_pages(sub
, params_buffer_bytes(hw_params
));
182 static int snd_usb_caiaq_pcm_hw_free(struct snd_pcm_substream
*sub
)
184 struct snd_usb_caiaqdev
*dev
= snd_pcm_substream_chip(sub
);
185 debug("%s(%p)\n", __func__
, sub
);
186 deactivate_substream(dev
, sub
);
187 return snd_pcm_lib_free_pages(sub
);
190 /* this should probably go upstream */
191 #if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12
192 #error "Change this table"
195 static unsigned int rates
[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100,
196 48000, 64000, 88200, 96000, 176400, 192000 };
198 static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream
*substream
)
200 int bytes_per_sample
, bpp
, ret
, i
;
201 int index
= substream
->number
;
202 struct snd_usb_caiaqdev
*dev
= snd_pcm_substream_chip(substream
);
203 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
205 debug("%s(%p)\n", __func__
, substream
);
207 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
210 switch (dev
->spec
.data_alignment
) {
213 out_pos
= BYTES_PER_SAMPLE
+ 1;
221 dev
->period_out_count
[index
] = out_pos
;
222 dev
->audio_out_buf_pos
[index
] = out_pos
;
226 switch (dev
->spec
.data_alignment
) {
228 in_pos
= BYTES_PER_SAMPLE
+ 2;
231 in_pos
= BYTES_PER_SAMPLE
;
239 dev
->period_in_count
[index
] = in_pos
;
240 dev
->audio_in_buf_pos
[index
] = in_pos
;
246 /* the first client that opens a stream defines the sample rate
247 * setting for all subsequent calls, until the last client closed. */
248 for (i
=0; i
< ARRAY_SIZE(rates
); i
++)
249 if (runtime
->rate
== rates
[i
])
250 dev
->pcm_info
.rates
= 1 << i
;
252 snd_pcm_limit_hw_rates(runtime
);
254 bytes_per_sample
= BYTES_PER_SAMPLE
;
255 if (dev
->spec
.data_alignment
>= 2)
258 bpp
= ((runtime
->rate
/ 8000) + CLOCK_DRIFT_TOLERANCE
)
259 * bytes_per_sample
* CHANNELS_PER_STREAM
* dev
->n_streams
;
261 if (bpp
> MAX_ENDPOINT_SIZE
)
262 bpp
= MAX_ENDPOINT_SIZE
;
264 ret
= snd_usb_caiaq_set_audio_params(dev
, runtime
->rate
,
265 runtime
->sample_bits
, bpp
);
269 ret
= stream_start(dev
);
273 dev
->output_running
= 0;
274 wait_event_timeout(dev
->prepare_wait_queue
, dev
->output_running
, HZ
);
275 if (!dev
->output_running
) {
283 static int snd_usb_caiaq_pcm_trigger(struct snd_pcm_substream
*sub
, int cmd
)
285 struct snd_usb_caiaqdev
*dev
= snd_pcm_substream_chip(sub
);
287 debug("%s(%p) cmd %d\n", __func__
, sub
, cmd
);
290 case SNDRV_PCM_TRIGGER_START
:
291 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
292 activate_substream(dev
, sub
);
294 case SNDRV_PCM_TRIGGER_STOP
:
295 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
296 deactivate_substream(dev
, sub
);
305 static snd_pcm_uframes_t
306 snd_usb_caiaq_pcm_pointer(struct snd_pcm_substream
*sub
)
308 int index
= sub
->number
;
309 struct snd_usb_caiaqdev
*dev
= snd_pcm_substream_chip(sub
);
310 snd_pcm_uframes_t ptr
;
312 spin_lock(&dev
->spinlock
);
314 if (dev
->input_panic
|| dev
->output_panic
) {
315 ptr
= SNDRV_PCM_POS_XRUN
;
319 if (sub
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
320 ptr
= bytes_to_frames(sub
->runtime
,
321 dev
->audio_out_buf_pos
[index
]);
323 ptr
= bytes_to_frames(sub
->runtime
,
324 dev
->audio_in_buf_pos
[index
]);
327 spin_unlock(&dev
->spinlock
);
331 /* operators for both playback and capture */
332 static struct snd_pcm_ops snd_usb_caiaq_ops
= {
333 .open
= snd_usb_caiaq_substream_open
,
334 .close
= snd_usb_caiaq_substream_close
,
335 .ioctl
= snd_pcm_lib_ioctl
,
336 .hw_params
= snd_usb_caiaq_pcm_hw_params
,
337 .hw_free
= snd_usb_caiaq_pcm_hw_free
,
338 .prepare
= snd_usb_caiaq_pcm_prepare
,
339 .trigger
= snd_usb_caiaq_pcm_trigger
,
340 .pointer
= snd_usb_caiaq_pcm_pointer
343 static void check_for_elapsed_periods(struct snd_usb_caiaqdev
*dev
,
344 struct snd_pcm_substream
**subs
)
346 int stream
, pb
, *cnt
;
347 struct snd_pcm_substream
*sub
;
349 for (stream
= 0; stream
< dev
->n_streams
; stream
++) {
354 pb
= snd_pcm_lib_period_bytes(sub
);
355 cnt
= (sub
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) ?
356 &dev
->period_out_count
[stream
] :
357 &dev
->period_in_count
[stream
];
360 snd_pcm_period_elapsed(sub
);
366 static void read_in_urb_mode0(struct snd_usb_caiaqdev
*dev
,
367 const struct urb
*urb
,
368 const struct usb_iso_packet_descriptor
*iso
)
370 unsigned char *usb_buf
= urb
->transfer_buffer
+ iso
->offset
;
371 struct snd_pcm_substream
*sub
;
374 if (all_substreams_zero(dev
->sub_capture
))
377 for (i
= 0; i
< iso
->actual_length
;) {
378 for (stream
= 0; stream
< dev
->n_streams
; stream
++, i
++) {
379 sub
= dev
->sub_capture
[stream
];
381 struct snd_pcm_runtime
*rt
= sub
->runtime
;
382 char *audio_buf
= rt
->dma_area
;
383 int sz
= frames_to_bytes(rt
, rt
->buffer_size
);
384 audio_buf
[dev
->audio_in_buf_pos
[stream
]++]
386 dev
->period_in_count
[stream
]++;
387 if (dev
->audio_in_buf_pos
[stream
] == sz
)
388 dev
->audio_in_buf_pos
[stream
] = 0;
394 static void read_in_urb_mode2(struct snd_usb_caiaqdev
*dev
,
395 const struct urb
*urb
,
396 const struct usb_iso_packet_descriptor
*iso
)
398 unsigned char *usb_buf
= urb
->transfer_buffer
+ iso
->offset
;
399 unsigned char check_byte
;
400 struct snd_pcm_substream
*sub
;
403 for (i
= 0; i
< iso
->actual_length
;) {
404 if (i
% (dev
->n_streams
* BYTES_PER_SAMPLE_USB
) == 0) {
406 stream
< dev
->n_streams
;
408 if (dev
->first_packet
)
411 check_byte
= MAKE_CHECKBYTE(dev
, stream
, i
);
413 if ((usb_buf
[i
] & 0x3f) != check_byte
)
414 dev
->input_panic
= 1;
416 if (usb_buf
[i
] & 0x80)
417 dev
->output_panic
= 1;
420 dev
->first_packet
= 0;
422 for (stream
= 0; stream
< dev
->n_streams
; stream
++, i
++) {
423 sub
= dev
->sub_capture
[stream
];
424 if (dev
->input_panic
)
428 struct snd_pcm_runtime
*rt
= sub
->runtime
;
429 char *audio_buf
= rt
->dma_area
;
430 int sz
= frames_to_bytes(rt
, rt
->buffer_size
);
431 audio_buf
[dev
->audio_in_buf_pos
[stream
]++] =
433 dev
->period_in_count
[stream
]++;
434 if (dev
->audio_in_buf_pos
[stream
] == sz
)
435 dev
->audio_in_buf_pos
[stream
] = 0;
441 static void read_in_urb_mode3(struct snd_usb_caiaqdev
*dev
,
442 const struct urb
*urb
,
443 const struct usb_iso_packet_descriptor
*iso
)
445 unsigned char *usb_buf
= urb
->transfer_buffer
+ iso
->offset
;
449 if (iso
->actual_length
% (BYTES_PER_SAMPLE_USB
* CHANNELS_PER_STREAM
))
452 for (i
= 0; i
< iso
->actual_length
;) {
453 for (stream
= 0; stream
< dev
->n_streams
; stream
++) {
454 struct snd_pcm_substream
*sub
= dev
->sub_capture
[stream
];
455 char *audio_buf
= NULL
;
458 if (sub
&& !dev
->input_panic
) {
459 struct snd_pcm_runtime
*rt
= sub
->runtime
;
460 audio_buf
= rt
->dma_area
;
461 sz
= frames_to_bytes(rt
, rt
->buffer_size
);
464 for (c
= 0; c
< CHANNELS_PER_STREAM
; c
++) {
465 /* 3 audio data bytes, followed by 1 check byte */
467 for (n
= 0; n
< BYTES_PER_SAMPLE
; n
++) {
468 audio_buf
[dev
->audio_in_buf_pos
[stream
]++] = usb_buf
[i
+n
];
470 if (dev
->audio_in_buf_pos
[stream
] == sz
)
471 dev
->audio_in_buf_pos
[stream
] = 0;
474 dev
->period_in_count
[stream
] += BYTES_PER_SAMPLE
;
477 i
+= BYTES_PER_SAMPLE
;
479 if (usb_buf
[i
] != ((stream
<< 1) | c
) &&
480 !dev
->first_packet
) {
481 if (!dev
->input_panic
)
482 printk(" EXPECTED: %02x got %02x, c %d, stream %d, i %d\n",
483 ((stream
<< 1) | c
), usb_buf
[i
], c
, stream
, i
);
484 dev
->input_panic
= 1;
492 if (dev
->first_packet
> 0)
496 static void read_in_urb(struct snd_usb_caiaqdev
*dev
,
497 const struct urb
*urb
,
498 const struct usb_iso_packet_descriptor
*iso
)
503 if (iso
->actual_length
< dev
->bpp
)
506 switch (dev
->spec
.data_alignment
) {
508 read_in_urb_mode0(dev
, urb
, iso
);
511 read_in_urb_mode2(dev
, urb
, iso
);
514 read_in_urb_mode3(dev
, urb
, iso
);
518 if ((dev
->input_panic
|| dev
->output_panic
) && !dev
->warned
) {
519 debug("streaming error detected %s %s\n",
520 dev
->input_panic
? "(input)" : "",
521 dev
->output_panic
? "(output)" : "");
526 static void fill_out_urb_mode_0(struct snd_usb_caiaqdev
*dev
,
528 const struct usb_iso_packet_descriptor
*iso
)
530 unsigned char *usb_buf
= urb
->transfer_buffer
+ iso
->offset
;
531 struct snd_pcm_substream
*sub
;
534 for (i
= 0; i
< iso
->length
;) {
535 for (stream
= 0; stream
< dev
->n_streams
; stream
++, i
++) {
536 sub
= dev
->sub_playback
[stream
];
538 struct snd_pcm_runtime
*rt
= sub
->runtime
;
539 char *audio_buf
= rt
->dma_area
;
540 int sz
= frames_to_bytes(rt
, rt
->buffer_size
);
542 audio_buf
[dev
->audio_out_buf_pos
[stream
]];
543 dev
->period_out_count
[stream
]++;
544 dev
->audio_out_buf_pos
[stream
]++;
545 if (dev
->audio_out_buf_pos
[stream
] == sz
)
546 dev
->audio_out_buf_pos
[stream
] = 0;
551 /* fill in the check bytes */
552 if (dev
->spec
.data_alignment
== 2 &&
553 i
% (dev
->n_streams
* BYTES_PER_SAMPLE_USB
) ==
554 (dev
->n_streams
* CHANNELS_PER_STREAM
))
555 for (stream
= 0; stream
< dev
->n_streams
; stream
++, i
++)
556 usb_buf
[i
] = MAKE_CHECKBYTE(dev
, stream
, i
);
560 static void fill_out_urb_mode_3(struct snd_usb_caiaqdev
*dev
,
562 const struct usb_iso_packet_descriptor
*iso
)
564 unsigned char *usb_buf
= urb
->transfer_buffer
+ iso
->offset
;
567 for (i
= 0; i
< iso
->length
;) {
568 for (stream
= 0; stream
< dev
->n_streams
; stream
++) {
569 struct snd_pcm_substream
*sub
= dev
->sub_playback
[stream
];
570 char *audio_buf
= NULL
;
574 struct snd_pcm_runtime
*rt
= sub
->runtime
;
575 audio_buf
= rt
->dma_area
;
576 sz
= frames_to_bytes(rt
, rt
->buffer_size
);
579 for (c
= 0; c
< CHANNELS_PER_STREAM
; c
++) {
580 for (n
= 0; n
< BYTES_PER_SAMPLE
; n
++) {
582 usb_buf
[i
+n
] = audio_buf
[dev
->audio_out_buf_pos
[stream
]++];
584 if (dev
->audio_out_buf_pos
[stream
] == sz
)
585 dev
->audio_out_buf_pos
[stream
] = 0;
592 dev
->period_out_count
[stream
] += BYTES_PER_SAMPLE
;
594 i
+= BYTES_PER_SAMPLE
;
596 /* fill in the check byte pattern */
597 usb_buf
[i
++] = (stream
<< 1) | c
;
603 static inline void fill_out_urb(struct snd_usb_caiaqdev
*dev
,
605 const struct usb_iso_packet_descriptor
*iso
)
607 switch (dev
->spec
.data_alignment
) {
610 fill_out_urb_mode_0(dev
, urb
, iso
);
613 fill_out_urb_mode_3(dev
, urb
, iso
);
618 static void read_completed(struct urb
*urb
)
620 struct snd_usb_caiaq_cb_info
*info
= urb
->context
;
621 struct snd_usb_caiaqdev
*dev
;
622 struct urb
*out
= NULL
;
623 int i
, frame
, len
, send_it
= 0, outframe
= 0;
626 if (urb
->status
|| !info
)
634 /* find an unused output urb that is unused */
635 for (i
= 0; i
< N_URBS
; i
++)
636 if (test_and_set_bit(i
, &dev
->outurb_active_mask
) == 0) {
637 out
= dev
->data_urbs_out
[i
];
642 log("Unable to find an output urb to use\n");
646 /* read the recently received packet and send back one which has
648 for (frame
= 0; frame
< FRAMES_PER_URB
; frame
++) {
649 if (urb
->iso_frame_desc
[frame
].status
)
652 len
= urb
->iso_frame_desc
[outframe
].actual_length
;
653 out
->iso_frame_desc
[outframe
].length
= len
;
654 out
->iso_frame_desc
[outframe
].actual_length
= 0;
655 out
->iso_frame_desc
[outframe
].offset
= offset
;
659 spin_lock(&dev
->spinlock
);
660 fill_out_urb(dev
, out
, &out
->iso_frame_desc
[outframe
]);
661 read_in_urb(dev
, urb
, &urb
->iso_frame_desc
[frame
]);
662 spin_unlock(&dev
->spinlock
);
663 check_for_elapsed_periods(dev
, dev
->sub_playback
);
664 check_for_elapsed_periods(dev
, dev
->sub_capture
);
672 out
->number_of_packets
= outframe
;
673 out
->transfer_flags
= URB_ISO_ASAP
;
674 usb_submit_urb(out
, GFP_ATOMIC
);
676 struct snd_usb_caiaq_cb_info
*oinfo
= out
->context
;
677 clear_bit(oinfo
->index
, &dev
->outurb_active_mask
);
681 /* re-submit inbound urb */
682 for (frame
= 0; frame
< FRAMES_PER_URB
; frame
++) {
683 urb
->iso_frame_desc
[frame
].offset
= BYTES_PER_FRAME
* frame
;
684 urb
->iso_frame_desc
[frame
].length
= BYTES_PER_FRAME
;
685 urb
->iso_frame_desc
[frame
].actual_length
= 0;
688 urb
->number_of_packets
= FRAMES_PER_URB
;
689 urb
->transfer_flags
= URB_ISO_ASAP
;
690 usb_submit_urb(urb
, GFP_ATOMIC
);
693 static void write_completed(struct urb
*urb
)
695 struct snd_usb_caiaq_cb_info
*info
= urb
->context
;
696 struct snd_usb_caiaqdev
*dev
= info
->dev
;
698 if (!dev
->output_running
) {
699 dev
->output_running
= 1;
700 wake_up(&dev
->prepare_wait_queue
);
703 clear_bit(info
->index
, &dev
->outurb_active_mask
);
706 static struct urb
**alloc_urbs(struct snd_usb_caiaqdev
*dev
, int dir
, int *ret
)
710 struct usb_device
*usb_dev
= dev
->chip
.dev
;
713 pipe
= (dir
== SNDRV_PCM_STREAM_PLAYBACK
) ?
714 usb_sndisocpipe(usb_dev
, ENDPOINT_PLAYBACK
) :
715 usb_rcvisocpipe(usb_dev
, ENDPOINT_CAPTURE
);
717 urbs
= kmalloc(N_URBS
* sizeof(*urbs
), GFP_KERNEL
);
719 log("unable to kmalloc() urbs, OOM!?\n");
724 for (i
= 0; i
< N_URBS
; i
++) {
725 urbs
[i
] = usb_alloc_urb(FRAMES_PER_URB
, GFP_KERNEL
);
727 log("unable to usb_alloc_urb(), OOM!?\n");
732 urbs
[i
]->transfer_buffer
=
733 kmalloc(FRAMES_PER_URB
* BYTES_PER_FRAME
, GFP_KERNEL
);
734 if (!urbs
[i
]->transfer_buffer
) {
735 log("unable to kmalloc() transfer buffer, OOM!?\n");
740 for (frame
= 0; frame
< FRAMES_PER_URB
; frame
++) {
741 struct usb_iso_packet_descriptor
*iso
=
742 &urbs
[i
]->iso_frame_desc
[frame
];
744 iso
->offset
= BYTES_PER_FRAME
* frame
;
745 iso
->length
= BYTES_PER_FRAME
;
748 urbs
[i
]->dev
= usb_dev
;
749 urbs
[i
]->pipe
= pipe
;
750 urbs
[i
]->transfer_buffer_length
= FRAMES_PER_URB
752 urbs
[i
]->context
= &dev
->data_cb_info
[i
];
753 urbs
[i
]->interval
= 1;
754 urbs
[i
]->transfer_flags
= URB_ISO_ASAP
;
755 urbs
[i
]->number_of_packets
= FRAMES_PER_URB
;
756 urbs
[i
]->complete
= (dir
== SNDRV_PCM_STREAM_CAPTURE
) ?
757 read_completed
: write_completed
;
764 static void free_urbs(struct urb
**urbs
)
771 for (i
= 0; i
< N_URBS
; i
++) {
775 usb_kill_urb(urbs
[i
]);
776 kfree(urbs
[i
]->transfer_buffer
);
777 usb_free_urb(urbs
[i
]);
783 int snd_usb_caiaq_audio_init(struct snd_usb_caiaqdev
*dev
)
787 dev
->n_audio_in
= max(dev
->spec
.num_analog_audio_in
,
788 dev
->spec
.num_digital_audio_in
) /
790 dev
->n_audio_out
= max(dev
->spec
.num_analog_audio_out
,
791 dev
->spec
.num_digital_audio_out
) /
793 dev
->n_streams
= max(dev
->n_audio_in
, dev
->n_audio_out
);
795 debug("dev->n_audio_in = %d\n", dev
->n_audio_in
);
796 debug("dev->n_audio_out = %d\n", dev
->n_audio_out
);
797 debug("dev->n_streams = %d\n", dev
->n_streams
);
799 if (dev
->n_streams
> MAX_STREAMS
) {
800 log("unable to initialize device, too many streams.\n");
804 ret
= snd_pcm_new(dev
->chip
.card
, dev
->product_name
, 0,
805 dev
->n_audio_out
, dev
->n_audio_in
, &dev
->pcm
);
808 log("snd_pcm_new() returned %d\n", ret
);
812 dev
->pcm
->private_data
= dev
;
813 strlcpy(dev
->pcm
->name
, dev
->product_name
, sizeof(dev
->pcm
->name
));
815 memset(dev
->sub_playback
, 0, sizeof(dev
->sub_playback
));
816 memset(dev
->sub_capture
, 0, sizeof(dev
->sub_capture
));
818 memcpy(&dev
->pcm_info
, &snd_usb_caiaq_pcm_hardware
,
819 sizeof(snd_usb_caiaq_pcm_hardware
));
821 /* setup samplerates */
822 dev
->samplerates
= dev
->pcm_info
.rates
;
823 switch (dev
->chip
.usb_id
) {
824 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_AK1
):
825 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_RIGKONTROL3
):
826 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_SESSIONIO
):
827 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_GUITARRIGMOBILE
):
828 dev
->samplerates
|= SNDRV_PCM_RATE_192000
;
830 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_AUDIO2DJ
):
831 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_AUDIO4DJ
):
832 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_AUDIO8DJ
):
833 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_TRAKTORAUDIO2
):
834 dev
->samplerates
|= SNDRV_PCM_RATE_88200
;
838 snd_pcm_set_ops(dev
->pcm
, SNDRV_PCM_STREAM_PLAYBACK
,
840 snd_pcm_set_ops(dev
->pcm
, SNDRV_PCM_STREAM_CAPTURE
,
843 snd_pcm_lib_preallocate_pages_for_all(dev
->pcm
,
844 SNDRV_DMA_TYPE_CONTINUOUS
,
845 snd_dma_continuous_data(GFP_KERNEL
),
846 MAX_BUFFER_SIZE
, MAX_BUFFER_SIZE
);
849 kmalloc(sizeof(struct snd_usb_caiaq_cb_info
) * N_URBS
,
852 if (!dev
->data_cb_info
)
855 dev
->outurb_active_mask
= 0;
856 BUILD_BUG_ON(N_URBS
> (sizeof(dev
->outurb_active_mask
) * 8));
858 for (i
= 0; i
< N_URBS
; i
++) {
859 dev
->data_cb_info
[i
].dev
= dev
;
860 dev
->data_cb_info
[i
].index
= i
;
863 dev
->data_urbs_in
= alloc_urbs(dev
, SNDRV_PCM_STREAM_CAPTURE
, &ret
);
865 kfree(dev
->data_cb_info
);
866 free_urbs(dev
->data_urbs_in
);
870 dev
->data_urbs_out
= alloc_urbs(dev
, SNDRV_PCM_STREAM_PLAYBACK
, &ret
);
872 kfree(dev
->data_cb_info
);
873 free_urbs(dev
->data_urbs_in
);
874 free_urbs(dev
->data_urbs_out
);
881 void snd_usb_caiaq_audio_free(struct snd_usb_caiaqdev
*dev
)
883 debug("%s(%p)\n", __func__
, dev
);
885 free_urbs(dev
->data_urbs_in
);
886 free_urbs(dev
->data_urbs_out
);
887 kfree(dev
->data_cb_info
);