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
= 1;
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
]);
142 usb_kill_urb(dev
->data_urbs_out
[i
]);
146 static int snd_usb_caiaq_substream_open(struct snd_pcm_substream
*substream
)
148 struct snd_usb_caiaqdev
*dev
= snd_pcm_substream_chip(substream
);
149 debug("%s(%p)\n", __func__
, substream
);
150 substream
->runtime
->hw
= dev
->pcm_info
;
151 snd_pcm_limit_hw_rates(substream
->runtime
);
155 static int snd_usb_caiaq_substream_close(struct snd_pcm_substream
*substream
)
157 struct snd_usb_caiaqdev
*dev
= snd_pcm_substream_chip(substream
);
159 debug("%s(%p)\n", __func__
, substream
);
160 if (all_substreams_zero(dev
->sub_playback
) &&
161 all_substreams_zero(dev
->sub_capture
)) {
162 /* when the last client has stopped streaming,
163 * all sample rates are allowed again */
165 dev
->pcm_info
.rates
= dev
->samplerates
;
171 static int snd_usb_caiaq_pcm_hw_params(struct snd_pcm_substream
*sub
,
172 struct snd_pcm_hw_params
*hw_params
)
174 debug("%s(%p)\n", __func__
, sub
);
175 return snd_pcm_lib_malloc_pages(sub
, params_buffer_bytes(hw_params
));
178 static int snd_usb_caiaq_pcm_hw_free(struct snd_pcm_substream
*sub
)
180 struct snd_usb_caiaqdev
*dev
= snd_pcm_substream_chip(sub
);
181 debug("%s(%p)\n", __func__
, sub
);
182 deactivate_substream(dev
, sub
);
183 return snd_pcm_lib_free_pages(sub
);
186 /* this should probably go upstream */
187 #if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12
188 #error "Change this table"
191 static unsigned int rates
[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100,
192 48000, 64000, 88200, 96000, 176400, 192000 };
194 static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream
*substream
)
196 int bytes_per_sample
, bpp
, ret
, i
;
197 int index
= substream
->number
;
198 struct snd_usb_caiaqdev
*dev
= snd_pcm_substream_chip(substream
);
199 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
201 debug("%s(%p)\n", __func__
, substream
);
203 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
204 dev
->period_out_count
[index
] = BYTES_PER_SAMPLE
+ 1;
205 dev
->audio_out_buf_pos
[index
] = BYTES_PER_SAMPLE
+ 1;
207 int in_pos
= (dev
->spec
.data_alignment
== 2) ? 0 : 2;
208 dev
->period_in_count
[index
] = BYTES_PER_SAMPLE
+ in_pos
;
209 dev
->audio_in_buf_pos
[index
] = BYTES_PER_SAMPLE
+ in_pos
;
215 /* the first client that opens a stream defines the sample rate
216 * setting for all subsequent calls, until the last client closed. */
217 for (i
=0; i
< ARRAY_SIZE(rates
); i
++)
218 if (runtime
->rate
== rates
[i
])
219 dev
->pcm_info
.rates
= 1 << i
;
221 snd_pcm_limit_hw_rates(runtime
);
223 bytes_per_sample
= BYTES_PER_SAMPLE
;
224 if (dev
->spec
.data_alignment
== 2)
227 bpp
= ((runtime
->rate
/ 8000) + CLOCK_DRIFT_TOLERANCE
)
228 * bytes_per_sample
* CHANNELS_PER_STREAM
* dev
->n_streams
;
230 if (bpp
> MAX_ENDPOINT_SIZE
)
231 bpp
= MAX_ENDPOINT_SIZE
;
233 ret
= snd_usb_caiaq_set_audio_params(dev
, runtime
->rate
,
234 runtime
->sample_bits
, bpp
);
238 ret
= stream_start(dev
);
242 dev
->output_running
= 0;
243 wait_event_timeout(dev
->prepare_wait_queue
, dev
->output_running
, HZ
);
244 if (!dev
->output_running
) {
252 static int snd_usb_caiaq_pcm_trigger(struct snd_pcm_substream
*sub
, int cmd
)
254 struct snd_usb_caiaqdev
*dev
= snd_pcm_substream_chip(sub
);
257 case SNDRV_PCM_TRIGGER_START
:
258 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
259 activate_substream(dev
, sub
);
261 case SNDRV_PCM_TRIGGER_STOP
:
262 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
263 deactivate_substream(dev
, sub
);
272 static snd_pcm_uframes_t
273 snd_usb_caiaq_pcm_pointer(struct snd_pcm_substream
*sub
)
275 int index
= sub
->number
;
276 struct snd_usb_caiaqdev
*dev
= snd_pcm_substream_chip(sub
);
277 snd_pcm_uframes_t ptr
;
279 spin_lock(&dev
->spinlock
);
281 if (dev
->input_panic
|| dev
->output_panic
)
282 ptr
= SNDRV_PCM_POS_XRUN
;
284 if (sub
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
285 ptr
= bytes_to_frames(sub
->runtime
,
286 dev
->audio_out_buf_pos
[index
]);
288 ptr
= bytes_to_frames(sub
->runtime
,
289 dev
->audio_in_buf_pos
[index
]);
291 spin_unlock(&dev
->spinlock
);
295 /* operators for both playback and capture */
296 static struct snd_pcm_ops snd_usb_caiaq_ops
= {
297 .open
= snd_usb_caiaq_substream_open
,
298 .close
= snd_usb_caiaq_substream_close
,
299 .ioctl
= snd_pcm_lib_ioctl
,
300 .hw_params
= snd_usb_caiaq_pcm_hw_params
,
301 .hw_free
= snd_usb_caiaq_pcm_hw_free
,
302 .prepare
= snd_usb_caiaq_pcm_prepare
,
303 .trigger
= snd_usb_caiaq_pcm_trigger
,
304 .pointer
= snd_usb_caiaq_pcm_pointer
307 static void check_for_elapsed_periods(struct snd_usb_caiaqdev
*dev
,
308 struct snd_pcm_substream
**subs
)
310 int stream
, pb
, *cnt
;
311 struct snd_pcm_substream
*sub
;
313 for (stream
= 0; stream
< dev
->n_streams
; stream
++) {
318 pb
= snd_pcm_lib_period_bytes(sub
);
319 cnt
= (sub
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) ?
320 &dev
->period_out_count
[stream
] :
321 &dev
->period_in_count
[stream
];
324 snd_pcm_period_elapsed(sub
);
330 static void read_in_urb_mode0(struct snd_usb_caiaqdev
*dev
,
331 const struct urb
*urb
,
332 const struct usb_iso_packet_descriptor
*iso
)
334 unsigned char *usb_buf
= urb
->transfer_buffer
+ iso
->offset
;
335 struct snd_pcm_substream
*sub
;
338 if (all_substreams_zero(dev
->sub_capture
))
341 for (i
= 0; i
< iso
->actual_length
;) {
342 for (stream
= 0; stream
< dev
->n_streams
; stream
++, i
++) {
343 sub
= dev
->sub_capture
[stream
];
345 struct snd_pcm_runtime
*rt
= sub
->runtime
;
346 char *audio_buf
= rt
->dma_area
;
347 int sz
= frames_to_bytes(rt
, rt
->buffer_size
);
348 audio_buf
[dev
->audio_in_buf_pos
[stream
]++]
350 dev
->period_in_count
[stream
]++;
351 if (dev
->audio_in_buf_pos
[stream
] == sz
)
352 dev
->audio_in_buf_pos
[stream
] = 0;
358 static void read_in_urb_mode2(struct snd_usb_caiaqdev
*dev
,
359 const struct urb
*urb
,
360 const struct usb_iso_packet_descriptor
*iso
)
362 unsigned char *usb_buf
= urb
->transfer_buffer
+ iso
->offset
;
363 unsigned char check_byte
;
364 struct snd_pcm_substream
*sub
;
367 for (i
= 0; i
< iso
->actual_length
;) {
368 if (i
% (dev
->n_streams
* BYTES_PER_SAMPLE_USB
) == 0) {
370 stream
< dev
->n_streams
;
372 if (dev
->first_packet
)
375 check_byte
= MAKE_CHECKBYTE(dev
, stream
, i
);
377 if ((usb_buf
[i
] & 0x3f) != check_byte
)
378 dev
->input_panic
= 1;
380 if (usb_buf
[i
] & 0x80)
381 dev
->output_panic
= 1;
384 dev
->first_packet
= 0;
386 for (stream
= 0; stream
< dev
->n_streams
; stream
++, i
++) {
387 sub
= dev
->sub_capture
[stream
];
388 if (dev
->input_panic
)
392 struct snd_pcm_runtime
*rt
= sub
->runtime
;
393 char *audio_buf
= rt
->dma_area
;
394 int sz
= frames_to_bytes(rt
, rt
->buffer_size
);
395 audio_buf
[dev
->audio_in_buf_pos
[stream
]++] =
397 dev
->period_in_count
[stream
]++;
398 if (dev
->audio_in_buf_pos
[stream
] == sz
)
399 dev
->audio_in_buf_pos
[stream
] = 0;
405 static void read_in_urb(struct snd_usb_caiaqdev
*dev
,
406 const struct urb
*urb
,
407 const struct usb_iso_packet_descriptor
*iso
)
412 if (iso
->actual_length
< dev
->bpp
)
415 switch (dev
->spec
.data_alignment
) {
417 read_in_urb_mode0(dev
, urb
, iso
);
420 read_in_urb_mode2(dev
, urb
, iso
);
424 if ((dev
->input_panic
|| dev
->output_panic
) && !dev
->warned
) {
425 debug("streaming error detected %s %s\n",
426 dev
->input_panic
? "(input)" : "",
427 dev
->output_panic
? "(output)" : "");
432 static void fill_out_urb(struct snd_usb_caiaqdev
*dev
,
434 const struct usb_iso_packet_descriptor
*iso
)
436 unsigned char *usb_buf
= urb
->transfer_buffer
+ iso
->offset
;
437 struct snd_pcm_substream
*sub
;
440 for (i
= 0; i
< iso
->length
;) {
441 for (stream
= 0; stream
< dev
->n_streams
; stream
++, i
++) {
442 sub
= dev
->sub_playback
[stream
];
444 struct snd_pcm_runtime
*rt
= sub
->runtime
;
445 char *audio_buf
= rt
->dma_area
;
446 int sz
= frames_to_bytes(rt
, rt
->buffer_size
);
448 audio_buf
[dev
->audio_out_buf_pos
[stream
]];
449 dev
->period_out_count
[stream
]++;
450 dev
->audio_out_buf_pos
[stream
]++;
451 if (dev
->audio_out_buf_pos
[stream
] == sz
)
452 dev
->audio_out_buf_pos
[stream
] = 0;
457 /* fill in the check bytes */
458 if (dev
->spec
.data_alignment
== 2 &&
459 i
% (dev
->n_streams
* BYTES_PER_SAMPLE_USB
) ==
460 (dev
->n_streams
* CHANNELS_PER_STREAM
))
461 for (stream
= 0; stream
< dev
->n_streams
; stream
++, i
++)
462 usb_buf
[i
] = MAKE_CHECKBYTE(dev
, stream
, i
);
466 static void read_completed(struct urb
*urb
)
468 struct snd_usb_caiaq_cb_info
*info
= urb
->context
;
469 struct snd_usb_caiaqdev
*dev
;
471 int frame
, len
, send_it
= 0, outframe
= 0;
473 if (urb
->status
|| !info
)
481 out
= dev
->data_urbs_out
[info
->index
];
483 /* read the recently received packet and send back one which has
485 for (frame
= 0; frame
< FRAMES_PER_URB
; frame
++) {
486 if (urb
->iso_frame_desc
[frame
].status
)
489 len
= urb
->iso_frame_desc
[outframe
].actual_length
;
490 out
->iso_frame_desc
[outframe
].length
= len
;
491 out
->iso_frame_desc
[outframe
].actual_length
= 0;
492 out
->iso_frame_desc
[outframe
].offset
= BYTES_PER_FRAME
* frame
;
495 spin_lock(&dev
->spinlock
);
496 fill_out_urb(dev
, out
, &out
->iso_frame_desc
[outframe
]);
497 read_in_urb(dev
, urb
, &urb
->iso_frame_desc
[frame
]);
498 spin_unlock(&dev
->spinlock
);
499 check_for_elapsed_periods(dev
, dev
->sub_playback
);
500 check_for_elapsed_periods(dev
, dev
->sub_capture
);
508 out
->number_of_packets
= FRAMES_PER_URB
;
509 out
->transfer_flags
= URB_ISO_ASAP
;
510 usb_submit_urb(out
, GFP_ATOMIC
);
513 /* re-submit inbound urb */
514 for (frame
= 0; frame
< FRAMES_PER_URB
; frame
++) {
515 urb
->iso_frame_desc
[frame
].offset
= BYTES_PER_FRAME
* frame
;
516 urb
->iso_frame_desc
[frame
].length
= BYTES_PER_FRAME
;
517 urb
->iso_frame_desc
[frame
].actual_length
= 0;
520 urb
->number_of_packets
= FRAMES_PER_URB
;
521 urb
->transfer_flags
= URB_ISO_ASAP
;
522 usb_submit_urb(urb
, GFP_ATOMIC
);
525 static void write_completed(struct urb
*urb
)
527 struct snd_usb_caiaq_cb_info
*info
= urb
->context
;
528 struct snd_usb_caiaqdev
*dev
= info
->dev
;
530 if (!dev
->output_running
) {
531 dev
->output_running
= 1;
532 wake_up(&dev
->prepare_wait_queue
);
536 static struct urb
**alloc_urbs(struct snd_usb_caiaqdev
*dev
, int dir
, int *ret
)
540 struct usb_device
*usb_dev
= dev
->chip
.dev
;
543 pipe
= (dir
== SNDRV_PCM_STREAM_PLAYBACK
) ?
544 usb_sndisocpipe(usb_dev
, ENDPOINT_PLAYBACK
) :
545 usb_rcvisocpipe(usb_dev
, ENDPOINT_CAPTURE
);
547 urbs
= kmalloc(N_URBS
* sizeof(*urbs
), GFP_KERNEL
);
549 log("unable to kmalloc() urbs, OOM!?\n");
554 for (i
= 0; i
< N_URBS
; i
++) {
555 urbs
[i
] = usb_alloc_urb(FRAMES_PER_URB
, GFP_KERNEL
);
557 log("unable to usb_alloc_urb(), OOM!?\n");
562 urbs
[i
]->transfer_buffer
=
563 kmalloc(FRAMES_PER_URB
* BYTES_PER_FRAME
, GFP_KERNEL
);
564 if (!urbs
[i
]->transfer_buffer
) {
565 log("unable to kmalloc() transfer buffer, OOM!?\n");
570 for (frame
= 0; frame
< FRAMES_PER_URB
; frame
++) {
571 struct usb_iso_packet_descriptor
*iso
=
572 &urbs
[i
]->iso_frame_desc
[frame
];
574 iso
->offset
= BYTES_PER_FRAME
* frame
;
575 iso
->length
= BYTES_PER_FRAME
;
578 urbs
[i
]->dev
= usb_dev
;
579 urbs
[i
]->pipe
= pipe
;
580 urbs
[i
]->transfer_buffer_length
= FRAMES_PER_URB
582 urbs
[i
]->context
= &dev
->data_cb_info
[i
];
583 urbs
[i
]->interval
= 1;
584 urbs
[i
]->transfer_flags
= URB_ISO_ASAP
;
585 urbs
[i
]->number_of_packets
= FRAMES_PER_URB
;
586 urbs
[i
]->complete
= (dir
== SNDRV_PCM_STREAM_CAPTURE
) ?
587 read_completed
: write_completed
;
594 static void free_urbs(struct urb
**urbs
)
601 for (i
= 0; i
< N_URBS
; i
++) {
605 usb_kill_urb(urbs
[i
]);
606 kfree(urbs
[i
]->transfer_buffer
);
607 usb_free_urb(urbs
[i
]);
613 int snd_usb_caiaq_audio_init(struct snd_usb_caiaqdev
*dev
)
617 dev
->n_audio_in
= max(dev
->spec
.num_analog_audio_in
,
618 dev
->spec
.num_digital_audio_in
) /
620 dev
->n_audio_out
= max(dev
->spec
.num_analog_audio_out
,
621 dev
->spec
.num_digital_audio_out
) /
623 dev
->n_streams
= max(dev
->n_audio_in
, dev
->n_audio_out
);
625 debug("dev->n_audio_in = %d\n", dev
->n_audio_in
);
626 debug("dev->n_audio_out = %d\n", dev
->n_audio_out
);
627 debug("dev->n_streams = %d\n", dev
->n_streams
);
629 if (dev
->n_streams
> MAX_STREAMS
) {
630 log("unable to initialize device, too many streams.\n");
634 ret
= snd_pcm_new(dev
->chip
.card
, dev
->product_name
, 0,
635 dev
->n_audio_out
, dev
->n_audio_in
, &dev
->pcm
);
638 log("snd_pcm_new() returned %d\n", ret
);
642 dev
->pcm
->private_data
= dev
;
643 strcpy(dev
->pcm
->name
, dev
->product_name
);
645 memset(dev
->sub_playback
, 0, sizeof(dev
->sub_playback
));
646 memset(dev
->sub_capture
, 0, sizeof(dev
->sub_capture
));
648 memcpy(&dev
->pcm_info
, &snd_usb_caiaq_pcm_hardware
,
649 sizeof(snd_usb_caiaq_pcm_hardware
));
651 /* setup samplerates */
652 dev
->samplerates
= dev
->pcm_info
.rates
;
653 switch (dev
->chip
.usb_id
) {
654 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_AK1
):
655 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_RIGKONTROL3
):
656 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_SESSIONIO
):
657 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_GUITARRIGMOBILE
):
658 dev
->samplerates
|= SNDRV_PCM_RATE_192000
;
660 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_AUDIO2DJ
):
661 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_AUDIO4DJ
):
662 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_AUDIO8DJ
):
663 dev
->samplerates
|= SNDRV_PCM_RATE_88200
;
667 snd_pcm_set_ops(dev
->pcm
, SNDRV_PCM_STREAM_PLAYBACK
,
669 snd_pcm_set_ops(dev
->pcm
, SNDRV_PCM_STREAM_CAPTURE
,
672 snd_pcm_lib_preallocate_pages_for_all(dev
->pcm
,
673 SNDRV_DMA_TYPE_CONTINUOUS
,
674 snd_dma_continuous_data(GFP_KERNEL
),
675 MAX_BUFFER_SIZE
, MAX_BUFFER_SIZE
);
678 kmalloc(sizeof(struct snd_usb_caiaq_cb_info
) * N_URBS
,
681 if (!dev
->data_cb_info
)
684 for (i
= 0; i
< N_URBS
; i
++) {
685 dev
->data_cb_info
[i
].dev
= dev
;
686 dev
->data_cb_info
[i
].index
= i
;
689 dev
->data_urbs_in
= alloc_urbs(dev
, SNDRV_PCM_STREAM_CAPTURE
, &ret
);
691 kfree(dev
->data_cb_info
);
692 free_urbs(dev
->data_urbs_in
);
696 dev
->data_urbs_out
= alloc_urbs(dev
, SNDRV_PCM_STREAM_PLAYBACK
, &ret
);
698 kfree(dev
->data_cb_info
);
699 free_urbs(dev
->data_urbs_in
);
700 free_urbs(dev
->data_urbs_out
);
707 void snd_usb_caiaq_audio_free(struct snd_usb_caiaqdev
*dev
)
709 debug("%s(%p)\n", __func__
, dev
);
711 free_urbs(dev
->data_urbs_in
);
712 free_urbs(dev
->data_urbs_out
);
713 kfree(dev
->data_cb_info
);