[deliverable/linux.git] / drivers / staging / line6 / capture.c

/*
 * Line6 Linux USB driver - 0.8.0
 *
 * Copyright (C) 2004-2009 Markus Grabner (grabner@icg.tugraz.at)
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License as
 *	published by the Free Software Foundation, version 2.
 *
 */

#include "driver.h"

#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>

#include "audio.h"
#include "pcm.h"
#include "pod.h"
#include "capture.h"


/*
	Find a free URB and submit it.
*/
static int submit_audio_in_urb(struct snd_pcm_substream *substream)
{
	int index;
	unsigned long flags;
	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
	int i, urb_size;
	struct urb *urb_in;

	spin_lock_irqsave(&line6pcm->lock_audio_in, flags);
	index = find_first_zero_bit(&line6pcm->active_urb_in, LINE6_ISO_BUFFERS);

	if(index < 0 || index >= LINE6_ISO_BUFFERS) {
		spin_unlock_irqrestore(&line6pcm->lock_audio_in, flags);
		dev_err(s2m(substream), "no free URB found\n");
		return -EINVAL;
	}

	urb_in = line6pcm->urb_audio_in[index];
	urb_size = 0;

	for(i = 0; i < LINE6_ISO_PACKETS; ++i) {
		struct usb_iso_packet_descriptor *fin = &urb_in->iso_frame_desc[i];
		fin->offset = urb_size;
		fin->length = line6pcm->max_packet_size;
		urb_size += line6pcm->max_packet_size;
	}

	urb_in->transfer_buffer = line6pcm->buffer_in + index * LINE6_ISO_PACKETS * line6pcm->max_packet_size;
	urb_in->transfer_buffer_length = urb_size;
	urb_in->context = substream;

	if(usb_submit_urb(urb_in, GFP_ATOMIC) == 0)
		set_bit(index, &line6pcm->active_urb_in);
	else
		dev_err(s2m(substream), "URB in #%d submission failed\n", index);

	spin_unlock_irqrestore(&line6pcm->lock_audio_in, flags);
	return 0;
}

/*
	Submit all currently available capture URBs.
*/
static int submit_audio_in_all_urbs(struct snd_pcm_substream *substream)
{
	int ret, i;

	for(i = 0; i < LINE6_ISO_BUFFERS; ++i)
		if((ret = submit_audio_in_urb(substream)) < 0)
			return ret;

	return 0;
}

/*
	Unlink all currently active capture URBs.
*/
static void unlink_audio_in_urbs(struct snd_line6_pcm *line6pcm)
{
	unsigned int i;

	for(i = LINE6_ISO_BUFFERS; i--;) {
		if(test_bit(i, &line6pcm->active_urb_in)) {
			if(!test_and_set_bit(i, &line6pcm->unlink_urb_in)) {
				struct urb *u = line6pcm->urb_audio_in[i];
				usb_unlink_urb(u);
			}
		}
	}
}

/*
	Wait until unlinking of all currently active capture URBs has been finished.
*/
static void wait_clear_audio_in_urbs(struct snd_line6_pcm *line6pcm)
{
	int timeout = HZ;
	unsigned int i;
	int alive;

	do {
		alive = 0;
		for (i = LINE6_ISO_BUFFERS; i--;) {
			if (test_bit(i, &line6pcm->active_urb_in))
				alive++;
		}
		if (! alive)
			break;
		set_current_state(TASK_UNINTERRUPTIBLE);
		schedule_timeout(1);
	} while (--timeout > 0);
	if (alive)
		snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);

	line6pcm->active_urb_in = 0;
	line6pcm->unlink_urb_in = 0;
}

/*
	Unlink all currently active capture URBs, and wait for finishing.
*/
void unlink_wait_clear_audio_in_urbs(struct snd_line6_pcm *line6pcm)
{
	unlink_audio_in_urbs(line6pcm);
	wait_clear_audio_in_urbs(line6pcm);
}

/*
	Callback for completed capture URB.
*/
static void audio_in_callback(struct urb *urb)
{
	int i, index, length = 0, shutdown = 0;
	int frames;
	unsigned long flags;

	struct snd_pcm_substream *substream = (struct snd_pcm_substream *)urb->context;
	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
	const int bytes_per_frame = line6pcm->properties->bytes_per_frame;
	struct snd_pcm_runtime *runtime = substream->runtime;

	/* find index of URB */
	for(index = 0; index < LINE6_ISO_BUFFERS; ++index)
		if(urb == line6pcm->urb_audio_in[index])
			break;

#if DO_DUMP_PCM_RECEIVE
	for(i = 0; i < LINE6_ISO_PACKETS; ++i) {
		struct usb_iso_packet_descriptor *fout = &urb->iso_frame_desc[i];
		line6_write_hexdump(line6pcm->line6, 'C', urb->transfer_buffer + fout->offset, fout->length);
	}
#endif

	spin_lock_irqsave(&line6pcm->lock_audio_in, flags);

	for(i = 0; i < LINE6_ISO_PACKETS; ++i) {
		char *fbuf;
		int fsize;
		struct usb_iso_packet_descriptor *fin = &urb->iso_frame_desc[i];

		if(fin->status == -18) {
			shutdown = 1;
			break;
		}

		fbuf = urb->transfer_buffer + fin->offset;
		fsize = fin->actual_length;
		length += fsize;

		if(fsize > 0) {
			frames = fsize / bytes_per_frame;

			if(line6pcm->pos_in_done + frames > runtime->buffer_size) {
				/*
					The transferred area goes over buffer boundary,
					copy two separate chunks.
				*/
				int len;
				len = runtime->buffer_size - line6pcm->pos_in_done;

				if(len > 0) {
					memcpy(runtime->dma_area + line6pcm->pos_in_done * bytes_per_frame, fbuf, len * bytes_per_frame);
					memcpy(runtime->dma_area, fbuf + len * bytes_per_frame, (frames - len) * bytes_per_frame);
				}
				else
					dev_err(s2m(substream), "driver bug: len = %d\n", len);  /* this is somewhat paranoid */
			}
			else {
				/* copy single chunk */
				memcpy(runtime->dma_area + line6pcm->pos_in_done * bytes_per_frame, fbuf, fsize * bytes_per_frame);
			}

			if((line6pcm->pos_in_done += frames) >= runtime->buffer_size)
				line6pcm->pos_in_done -= runtime->buffer_size;
		}
	}

	clear_bit(index, &line6pcm->active_urb_in);

	if(test_bit(index, &line6pcm->unlink_urb_in))
		shutdown = 1;

	spin_unlock_irqrestore(&line6pcm->lock_audio_in, flags);

	if(!shutdown) {
		submit_audio_in_urb(substream);

		if((line6pcm->bytes_in += length) >= line6pcm->period_in) {
			line6pcm->bytes_in -= line6pcm->period_in;
			snd_pcm_period_elapsed(substream);
		}
	}
}

/* open capture callback */
static int snd_line6_capture_open(struct snd_pcm_substream *substream)
{
	int err;
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);

	if((err = snd_pcm_hw_constraint_ratdens(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
																					(&line6pcm->properties->snd_line6_rates))) < 0)
		return err;

	runtime->hw = line6pcm->properties->snd_line6_capture_hw;
	return 0;
}

/* close capture callback */
static int snd_line6_capture_close(struct snd_pcm_substream *substream)
{
	return 0;
}

/* hw_params capture callback */
static int snd_line6_capture_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params)
{
	int ret;
	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);

	/* -- Florian Demski [FD] */
	/* don't ask me why, but this fixes the bug on my machine */
	if ( line6pcm == NULL ) {
		if ( substream->pcm == NULL )
			return -ENOMEM;
		if ( substream->pcm->private_data == NULL )
			return -ENOMEM;
		substream->private_data = substream->pcm->private_data;
		line6pcm = snd_pcm_substream_chip( substream );
	}
	/* -- [FD] end */

	if((ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
		return ret;

	line6pcm->period_in = params_period_bytes(hw_params);
	line6pcm->buffer_in = kmalloc(LINE6_ISO_BUFFERS * LINE6_ISO_PACKETS * LINE6_ISO_PACKET_SIZE_MAX, GFP_KERNEL);

	if(!line6pcm->buffer_in) {
		dev_err(s2m(substream), "cannot malloc buffer_in\n");
		return -ENOMEM;
	}

	return 0;
}

/* hw_free capture callback */
static int snd_line6_capture_hw_free(struct snd_pcm_substream *substream)
{
	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
	unlink_wait_clear_audio_in_urbs(line6pcm);

	if(line6pcm->buffer_in) {
		kfree(line6pcm->buffer_in);
		line6pcm->buffer_in = 0;
	}

	return snd_pcm_lib_free_pages(substream);
}

/* trigger callback */
int snd_line6_capture_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
	int err;
	line6pcm->count_in = 0;

	switch(cmd) {
	case SNDRV_PCM_TRIGGER_START:
		if(!test_and_set_bit(BIT_RUNNING_CAPTURE, &line6pcm->flags)) {
			err = submit_audio_in_all_urbs(substream);

			if(err < 0) {
				clear_bit(BIT_RUNNING_CAPTURE, &line6pcm->flags);
				return err;
			}
		}

		break;

	case SNDRV_PCM_TRIGGER_STOP:
		if(test_and_clear_bit(BIT_RUNNING_CAPTURE, &line6pcm->flags))
			unlink_audio_in_urbs(line6pcm);

		break;

	default:
		return -EINVAL;
	}

	return 0;
}

/* capture pointer callback */
static snd_pcm_uframes_t
snd_line6_capture_pointer(struct snd_pcm_substream *substream)
{
	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
	return line6pcm->pos_in_done;
}

/* capture operators */
struct snd_pcm_ops snd_line6_capture_ops = {
	.open =        snd_line6_capture_open,
	.close =       snd_line6_capture_close,
	.ioctl =       snd_pcm_lib_ioctl,
	.hw_params =   snd_line6_capture_hw_params,
	.hw_free =     snd_line6_capture_hw_free,
	.prepare =     snd_line6_prepare,
	.trigger =     snd_line6_trigger,
	.pointer =     snd_line6_capture_pointer,
};

int create_audio_in_urbs(struct snd_line6_pcm *line6pcm)
{
	int i;

	/* create audio URBs and fill in constant values: */
	for(i = 0; i < LINE6_ISO_BUFFERS; ++i) {
		struct urb *urb;

		/* URB for audio in: */
		urb = line6pcm->urb_audio_in[i] = usb_alloc_urb(LINE6_ISO_PACKETS, GFP_KERNEL);

		if(urb == NULL) {
			dev_err(line6pcm->line6->ifcdev, "Out of memory\n");
			return -ENOMEM;
		}

		urb->dev = line6pcm->line6->usbdev;
		urb->pipe = usb_rcvisocpipe(line6pcm->line6->usbdev, line6pcm->ep_audio_read & USB_ENDPOINT_NUMBER_MASK);
		urb->transfer_flags = URB_ISO_ASAP;
		urb->start_frame = -1;
		urb->number_of_packets = LINE6_ISO_PACKETS;
		urb->interval = LINE6_ISO_INTERVAL;
		urb->error_count = 0;
		urb->complete = audio_in_callback;
	}

	return 0;
}
Commit	Line	Data
705ececd MG	1	/*
	2	* Line6 Linux USB driver - 0.8.0
	3	*
	4	* Copyright (C) 2004-2009 Markus Grabner (grabner@icg.tugraz.at)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License as
	8	* published by the Free Software Foundation, version 2.
	9	*
	10	*/
	11
	12	#include "driver.h"
	13
	14	#include <sound/core.h>
	15	#include <sound/pcm.h>
	16	#include <sound/pcm_params.h>
	17
	18	#include "audio.h"
	19	#include "pcm.h"
	20	#include "pod.h"
b702ed25	21	#include "capture.h"
705ececd MG	22
	23
	24	/*
	25	Find a free URB and submit it.
	26	*/
	27	static int submit_audio_in_urb(struct snd_pcm_substream *substream)
	28	{
	29	int index;
	30	unsigned long flags;
	31	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
	32	int i, urb_size;
	33	struct urb *urb_in;
	34
	35	spin_lock_irqsave(&line6pcm->lock_audio_in, flags);
	36	index = find_first_zero_bit(&line6pcm->active_urb_in, LINE6_ISO_BUFFERS);
	37
	38	if(index < 0 \|\| index >= LINE6_ISO_BUFFERS) {
	39	spin_unlock_irqrestore(&line6pcm->lock_audio_in, flags);
	40	dev_err(s2m(substream), "no free URB found\n");
	41	return -EINVAL;
	42	}
	43
	44	urb_in = line6pcm->urb_audio_in[index];
	45	urb_size = 0;
	46
	47	for(i = 0; i < LINE6_ISO_PACKETS; ++i) {
	48	struct usb_iso_packet_descriptor *fin = &urb_in->iso_frame_desc[i];
	49	fin->offset = urb_size;
	50	fin->length = line6pcm->max_packet_size;
	51	urb_size += line6pcm->max_packet_size;
	52	}
	53
	54	urb_in->transfer_buffer = line6pcm->buffer_in + index * LINE6_ISO_PACKETS * line6pcm->max_packet_size;
	55	urb_in->transfer_buffer_length = urb_size;
	56	urb_in->context = substream;
	57
	58	if(usb_submit_urb(urb_in, GFP_ATOMIC) == 0)
	59	set_bit(index, &line6pcm->active_urb_in);
	60	else
	61	dev_err(s2m(substream), "URB in #%d submission failed\n", index);
	62
	63	spin_unlock_irqrestore(&line6pcm->lock_audio_in, flags);
	64	return 0;
	65	}
	66
	67	/*
	68	Submit all currently available capture URBs.
	69	*/
	70	static int submit_audio_in_all_urbs(struct snd_pcm_substream *substream)
	71	{
	72	int ret, i;
	73
	74	for(i = 0; i < LINE6_ISO_BUFFERS; ++i)
	75	if((ret = submit_audio_in_urb(substream)) < 0)
	76	return ret;
	77
	78	return 0;
	79	}
	80
	81	/*
	82	Unlink all currently active capture URBs.
	83	*/
	84	static void unlink_audio_in_urbs(struct snd_line6_pcm *line6pcm)
	85	{
86	unsigned int i;
87
88	for(i = LINE6_ISO_BUFFERS; i--;) {
89	if(test_bit(i, &line6pcm->active_urb_in)) {
90	if(!test_and_set_bit(i, &line6pcm->unlink_urb_in)) {
91	struct urb *u = line6pcm->urb_audio_in[i];
705ececd MG	92	usb_unlink_urb(u);
	93	}
	94	}
	95	}
	96	}
	97
	98	/*
	99	Wait until unlinking of all currently active capture URBs has been finished.
	100	*/
	101	static void wait_clear_audio_in_urbs(struct snd_line6_pcm *line6pcm)
	102	{
	103	int timeout = HZ;
	104	unsigned int i;
	105	int alive;
	106
	107	do {
	108	alive = 0;
	109	for (i = LINE6_ISO_BUFFERS; i--;) {
	110	if (test_bit(i, &line6pcm->active_urb_in))
	111	alive++;
	112	}
	113	if (! alive)
	114	break;
	115	set_current_state(TASK_UNINTERRUPTIBLE);
	116	schedule_timeout(1);
	117	} while (--timeout > 0);
	118	if (alive)
	119	snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);
	120
	121	line6pcm->active_urb_in = 0;
	122	line6pcm->unlink_urb_in = 0;
	123	}
	124
	125	/*
	126	Unlink all currently active capture URBs, and wait for finishing.
	127	*/
	128	void unlink_wait_clear_audio_in_urbs(struct snd_line6_pcm *line6pcm)
	129	{
	130	unlink_audio_in_urbs(line6pcm);
	131	wait_clear_audio_in_urbs(line6pcm);
	132	}
	133
	134	/*
	135	Callback for completed capture URB.
	136	*/
0c7ab158	137	static void audio_in_callback(struct urb *urb)
705ececd MG	138	{
	139	int i, index, length = 0, shutdown = 0;
	140	int frames;
	141	unsigned long flags;
	142
	143	struct snd_pcm_substream substream = (struct snd_pcm_substream )urb->context;
	144	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
	145	const int bytes_per_frame = line6pcm->properties->bytes_per_frame;
	146	struct snd_pcm_runtime *runtime = substream->runtime;
	147
	148	/* find index of URB */
	149	for(index = 0; index < LINE6_ISO_BUFFERS; ++index)
	150	if(urb == line6pcm->urb_audio_in[index])
	151	break;
	152
	153	#if DO_DUMP_PCM_RECEIVE
	154	for(i = 0; i < LINE6_ISO_PACKETS; ++i) {
	155	struct usb_iso_packet_descriptor *fout = &urb->iso_frame_desc[i];
	156	line6_write_hexdump(line6pcm->line6, 'C', urb->transfer_buffer + fout->offset, fout->length);
	157	}
	158	#endif
	159
	160	spin_lock_irqsave(&line6pcm->lock_audio_in, flags);
	161
	162	for(i = 0; i < LINE6_ISO_PACKETS; ++i) {
	163	char *fbuf;
	164	int fsize;
	165	struct usb_iso_packet_descriptor *fin = &urb->iso_frame_desc[i];
	166
	167	if(fin->status == -18) {
	168	shutdown = 1;
	169	break;
	170	}
	171
	172	fbuf = urb->transfer_buffer + fin->offset;
	173	fsize = fin->actual_length;
	174	length += fsize;
	175
	176	if(fsize > 0) {
	177	frames = fsize / bytes_per_frame;
	178
	179	if(line6pcm->pos_in_done + frames > runtime->buffer_size) {
	180	/*
	181	The transferred area goes over buffer boundary,
	182	copy two separate chunks.
	183	*/
	184	int len;
	185	len = runtime->buffer_size - line6pcm->pos_in_done;
	186
	187	if(len > 0) {
	188	memcpy(runtime->dma_area + line6pcm->pos_in_done * bytes_per_frame, fbuf, len * bytes_per_frame);
	189	memcpy(runtime->dma_area, fbuf + len * bytes_per_frame, (frames - len) * bytes_per_frame);
	190	}
	191	else
	192	dev_err(s2m(substream), "driver bug: len = %d\n", len); /* this is somewhat paranoid */
	193	}
	194	else {
	195	/* copy single chunk */
	196	memcpy(runtime->dma_area + line6pcm->pos_in_done * bytes_per_frame, fbuf, fsize * bytes_per_frame);
	197	}
	198
	199	if((line6pcm->pos_in_done += frames) >= runtime->buffer_size)
	200	line6pcm->pos_in_done -= runtime->buffer_size;
	201	}
202	}
203
204	clear_bit(index, &line6pcm->active_urb_in);
205
206	if(test_bit(index, &line6pcm->unlink_urb_in))
207	shutdown = 1;
208
209	spin_unlock_irqrestore(&line6pcm->lock_audio_in, flags);
210
211	if(!shutdown) {
212	submit_audio_in_urb(substream);
213
214	if((line6pcm->bytes_in += length) >= line6pcm->period_in) {
215	line6pcm->bytes_in -= line6pcm->period_in;
216	snd_pcm_period_elapsed(substream);
217	}
218	}
219	}
220
221	/* open capture callback */
222	static int snd_line6_capture_open(struct snd_pcm_substream *substream)
223	{
224	int err;
225	struct snd_pcm_runtime *runtime = substream->runtime;
226	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
227
228	if((err = snd_pcm_hw_constraint_ratdens(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
229	(&line6pcm->properties->snd_line6_rates))) < 0)
230	return err;
231
232	runtime->hw = line6pcm->properties->snd_line6_capture_hw;
233	return 0;
234	}
235
236	/* close capture callback */
237	static int snd_line6_capture_close(struct snd_pcm_substream *substream)
238	{
239	return 0;
240	}
241
242	/* hw_params capture callback */
243	static int snd_line6_capture_hw_params(struct snd_pcm_substream substream, struct snd_pcm_hw_params hw_params)
244	{
245	int ret;
246	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
247
248	/* -- Florian Demski [FD] */
249	/* don't ask me why, but this fixes the bug on my machine */
250	if ( line6pcm == NULL ) {
251	if ( substream->pcm == NULL )
252	return -ENOMEM;
253	if ( substream->pcm->private_data == NULL )
254	return -ENOMEM;
255	substream->private_data = substream->pcm->private_data;
256	line6pcm = snd_pcm_substream_chip( substream );
257	}
258	/* -- [FD] end */
259
260	if((ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
261	return ret;
262
263	line6pcm->period_in = params_period_bytes(hw_params);
264	line6pcm->buffer_in = kmalloc(LINE6_ISO_BUFFERS * LINE6_ISO_PACKETS * LINE6_ISO_PACKET_SIZE_MAX, GFP_KERNEL);
265
266	if(!line6pcm->buffer_in) {
267	dev_err(s2m(substream), "cannot malloc buffer_in\n");
268	return -ENOMEM;
269	}
270
271	return 0;
272	}
273
274	/* hw_free capture callback */
275	static int snd_line6_capture_hw_free(struct snd_pcm_substream *substream)
276	{
277	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
278	unlink_wait_clear_audio_in_urbs(line6pcm);
279
280	if(line6pcm->buffer_in) {
281	kfree(line6pcm->buffer_in);
282	line6pcm->buffer_in = 0;
283	}
284
285	return snd_pcm_lib_free_pages(substream);
286	}
287
288	/* trigger callback */
289	int snd_line6_capture_trigger(struct snd_pcm_substream *substream, int cmd)
290	{
291	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
292	int err;
293	line6pcm->count_in = 0;
294
295	switch(cmd) {
296	case SNDRV_PCM_TRIGGER_START:
297	if(!test_and_set_bit(BIT_RUNNING_CAPTURE, &line6pcm->flags)) {
298	err = submit_audio_in_all_urbs(substream);
299
300	if(err < 0) {
301	clear_bit(BIT_RUNNING_CAPTURE, &line6pcm->flags);
302	return err;
303	}
304	}
305
306	break;
307
308	case SNDRV_PCM_TRIGGER_STOP:
309	if(test_and_clear_bit(BIT_RUNNING_CAPTURE, &line6pcm->flags))
310	unlink_audio_in_urbs(line6pcm);
311
312	break;
313
314	default:
315	return -EINVAL;
316	}
317
318	return 0;
319	}
320
321	/* capture pointer callback */
322	static snd_pcm_uframes_t
323	snd_line6_capture_pointer(struct snd_pcm_substream *substream)
324	{
325	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
326	return line6pcm->pos_in_done;
327	}
328
329	/* capture operators */
330	struct snd_pcm_ops snd_line6_capture_ops = {
331	.open = snd_line6_capture_open,
332	.close = snd_line6_capture_close,
333	.ioctl = snd_pcm_lib_ioctl,
334	.hw_params = snd_line6_capture_hw_params,
335	.hw_free = snd_line6_capture_hw_free,
336	.prepare = snd_line6_prepare,
337	.trigger = snd_line6_trigger,
338	.pointer = snd_line6_capture_pointer,
339	};
340
341	int create_audio_in_urbs(struct snd_line6_pcm *line6pcm)
342	{
343	int i;
344
345	/* create audio URBs and fill in constant values: */
346	for(i = 0; i < LINE6_ISO_BUFFERS; ++i) {
347	struct urb *urb;
348
349	/* URB for audio in: */
350	urb = line6pcm->urb_audio_in[i] = usb_alloc_urb(LINE6_ISO_PACKETS, GFP_KERNEL);
351
352	if(urb == NULL) {
353	dev_err(line6pcm->line6->ifcdev, "Out of memory\n");
354	return -ENOMEM;
355	}
356
357	urb->dev = line6pcm->line6->usbdev;
358	urb->pipe = usb_rcvisocpipe(line6pcm->line6->usbdev, line6pcm->ep_audio_read & USB_ENDPOINT_NUMBER_MASK);
359	urb->transfer_flags = URB_ISO_ASAP;
360	urb->start_frame = -1;
361	urb->number_of_packets = LINE6_ISO_PACKETS;
362	urb->interval = LINE6_ISO_INTERVAL;
363	urb->error_count = 0;
364	urb->complete = audio_in_callback;
365	}
366
367	return 0;
368	}