[linux-2.6-block.git] / drivers / media / dvb / dvb-usb / dvb-usb-urb.c

/* dvb-usb-urb.c is part of the DVB USB library.
 *
 * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
 * see dvb-usb-init.c for copyright information.
 *
 * This file contains functions for initializing and handling the
 * USB and URB stuff.
 */
#include "dvb-usb-common.h"

int dvb_usb_generic_rw(struct dvb_usb_device *d, u8 *wbuf, u16 wlen, u8 *rbuf,
	u16 rlen, int delay_ms)
{
	int actlen,ret = -ENOMEM;

	if (d->props.generic_bulk_ctrl_endpoint == 0) {
		err("endpoint for generic control not specified.");
		return -EINVAL;
	}

	if (wbuf == NULL || wlen == 0)
		return -EINVAL;

	if ((ret = down_interruptible(&d->usb_sem)))
		return ret;

	deb_xfer(">>> ");
	debug_dump(wbuf,wlen,deb_xfer);

	ret = usb_bulk_msg(d->udev,usb_sndbulkpipe(d->udev,
			d->props.generic_bulk_ctrl_endpoint), wbuf,wlen,&actlen,
			2000);

	if (ret)
		err("bulk message failed: %d (%d/%d)",ret,wlen,actlen);
	else
		ret = actlen != wlen ? -1 : 0;

	/* an answer is expected, and no error before */
	if (!ret && rbuf && rlen) {
		if (delay_ms)
			msleep(delay_ms);

		ret = usb_bulk_msg(d->udev,usb_rcvbulkpipe(d->udev,
				d->props.generic_bulk_ctrl_endpoint),rbuf,rlen,&actlen,
				2000);

		if (ret)
			err("recv bulk message failed: %d",ret);
		else {
			deb_xfer("<<< ");
			debug_dump(rbuf,actlen,deb_xfer);
		}
	}

	up(&d->usb_sem);
	return ret;
}
EXPORT_SYMBOL(dvb_usb_generic_rw);

int dvb_usb_generic_write(struct dvb_usb_device *d, u8 *buf, u16 len)
{
	return dvb_usb_generic_rw(d,buf,len,NULL,0,0);
}
EXPORT_SYMBOL(dvb_usb_generic_write);


/* URB stuff for streaming */
static void dvb_usb_urb_complete(struct urb *urb, struct pt_regs *ptregs)
{
	struct dvb_usb_device *d = urb->context;
	int ptype = usb_pipetype(urb->pipe);
	int i;
	u8 *b;

	deb_ts("'%s' urb completed. feedcount: %d, status: %d, length: %d/%d, pack_num: %d, errors: %d\n",
			ptype == PIPE_ISOCHRONOUS ? "isoc" : "bulk", d->feedcount,
			urb->status,urb->actual_length,urb->transfer_buffer_length,
			urb->number_of_packets,urb->error_count);

	switch (urb->status) {
		case 0:         /* success */
		case -ETIMEDOUT:    /* NAK */
			break;
		case -ECONNRESET:   /* kill */
		case -ENOENT:
		case -ESHUTDOWN:
			return;
		default:        /* error */
			deb_ts("urb completition error %d.", urb->status);
			break;
	}

	if (d->feedcount > 0) {
		if (d->state & DVB_USB_STATE_DVB) {
			switch (ptype) {
				case PIPE_ISOCHRONOUS:
					b = (u8 *) urb->transfer_buffer;
					for (i = 0; i < urb->number_of_packets; i++) {
						if (urb->iso_frame_desc[i].status != 0)
							deb_ts("iso frame descriptor has an error: %d\n",urb->iso_frame_desc[i].status);
						else if (urb->iso_frame_desc[i].actual_length > 0) {
								dvb_dmx_swfilter(&d->demux,b + urb->iso_frame_desc[i].offset,
										urb->iso_frame_desc[i].actual_length);
							}
						urb->iso_frame_desc[i].status = 0;
						urb->iso_frame_desc[i].actual_length = 0;
					}
					debug_dump(b,20,deb_ts);
					break;
				case PIPE_BULK:
					if (urb->actual_length > 0)
						dvb_dmx_swfilter(&d->demux, (u8 *) urb->transfer_buffer,urb->actual_length);
					break;
				default:
					err("unkown endpoint type in completition handler.");
					return;
			}
		}
	}

	usb_submit_urb(urb,GFP_ATOMIC);
}

int dvb_usb_urb_kill(struct dvb_usb_device *d)
{
	int i;
	for (i = 0; i < d->urbs_submitted; i++) {
		deb_ts("killing URB no. %d.\n",i);

		/* stop the URB */
		usb_kill_urb(d->urb_list[i]);
	}
	d->urbs_submitted = 0;
	return 0;
}

int dvb_usb_urb_submit(struct dvb_usb_device *d)
{
	int i,ret;
	for (i = 0; i < d->urbs_initialized; i++) {
		deb_ts("submitting URB no. %d\n",i);
		if ((ret = usb_submit_urb(d->urb_list[i],GFP_ATOMIC))) {
			err("could not submit URB no. %d - get them all back",i);
			dvb_usb_urb_kill(d);
			return ret;
		}
		d->urbs_submitted++;
	}
	return 0;
}

static int dvb_usb_free_stream_buffers(struct dvb_usb_device *d)
{
	if (d->state & DVB_USB_STATE_URB_BUF) {
		while (d->buf_num) {
			d->buf_num--;
			deb_mem("freeing buffer %d\n",d->buf_num);
			usb_buffer_free(d->udev, d->buf_size,
					d->buf_list[d->buf_num], d->dma_addr[d->buf_num]);
		}
		kfree(d->buf_list);
		kfree(d->dma_addr);
	}

	d->state &= ~DVB_USB_STATE_URB_BUF;

	return 0;
}

static int dvb_usb_allocate_stream_buffers(struct dvb_usb_device *d, int num, unsigned long size)
{
	d->buf_num = 0;
	d->buf_size = size;

	deb_mem("all in all I will use %lu bytes for streaming\n",num*size);

	if ((d->buf_list = kmalloc(num*sizeof(u8 *), GFP_ATOMIC)) == NULL)
		return -ENOMEM;

	if ((d->dma_addr = kmalloc(num*sizeof(dma_addr_t), GFP_ATOMIC)) == NULL) {
		kfree(d->buf_list);
		return -ENOMEM;
	}
	memset(d->buf_list,0,num*sizeof(u8 *));
	memset(d->dma_addr,0,num*sizeof(dma_addr_t));

	d->state |= DVB_USB_STATE_URB_BUF;

	for (d->buf_num = 0; d->buf_num < num; d->buf_num++) {
		deb_mem("allocating buffer %d\n",d->buf_num);
		if (( d->buf_list[d->buf_num] =
					usb_buffer_alloc(d->udev, size, SLAB_ATOMIC,
					&d->dma_addr[d->buf_num]) ) == NULL) {
			deb_mem("not enough memory for urb-buffer allocation.\n");
			dvb_usb_free_stream_buffers(d);
			return -ENOMEM;
		}
		deb_mem("buffer %d: %p (dma: %llu)\n",
			d->buf_num, d->buf_list[d->buf_num],
			(unsigned long long)d->dma_addr[d->buf_num]);
		memset(d->buf_list[d->buf_num],0,size);
	}
	deb_mem("allocation successful\n");

	return 0;
}

static int dvb_usb_bulk_urb_init(struct dvb_usb_device *d)
{
	int i;

	if ((i = dvb_usb_allocate_stream_buffers(d,d->props.urb.count,
					d->props.urb.u.bulk.buffersize)) < 0)
		return i;

	/* allocate the URBs */
	for (i = 0; i < d->props.urb.count; i++) {
		if ((d->urb_list[i] = usb_alloc_urb(0,GFP_ATOMIC)) == NULL)
			return -ENOMEM;

		usb_fill_bulk_urb( d->urb_list[i], d->udev,
				usb_rcvbulkpipe(d->udev,d->props.urb.endpoint),
				d->buf_list[i],
				d->props.urb.u.bulk.buffersize,
				dvb_usb_urb_complete, d);

		d->urb_list[i]->transfer_flags = 0;
		d->urbs_initialized++;
	}
	return 0;
}

static int dvb_usb_isoc_urb_init(struct dvb_usb_device *d)
{
	int i,j;

	if ((i = dvb_usb_allocate_stream_buffers(d,d->props.urb.count,
					d->props.urb.u.isoc.framesize*d->props.urb.u.isoc.framesperurb)) < 0)
		return i;

	/* allocate the URBs */
	for (i = 0; i < d->props.urb.count; i++) {
		struct urb *urb;
		int frame_offset = 0;
		if ((d->urb_list[i] =
					usb_alloc_urb(d->props.urb.u.isoc.framesperurb,GFP_ATOMIC)) == NULL)
			return -ENOMEM;

		urb = d->urb_list[i];

		urb->dev = d->udev;
		urb->context = d;
		urb->complete = dvb_usb_urb_complete;
		urb->pipe = usb_rcvisocpipe(d->udev,d->props.urb.endpoint);
		urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
		urb->interval = d->props.urb.u.isoc.interval;
		urb->number_of_packets = d->props.urb.u.isoc.framesperurb;
		urb->transfer_buffer_length = d->buf_size;
		urb->transfer_buffer = d->buf_list[i];
		urb->transfer_dma = d->dma_addr[i];

		for (j = 0; j < d->props.urb.u.isoc.framesperurb; j++) {
			urb->iso_frame_desc[j].offset = frame_offset;
			urb->iso_frame_desc[j].length = d->props.urb.u.isoc.framesize;
			frame_offset += d->props.urb.u.isoc.framesize;
		}

		d->urbs_initialized++;
	}
	return 0;

}

int dvb_usb_urb_init(struct dvb_usb_device *d)
{
	/*
	 * when reloading the driver w/o replugging the device
	 * sometimes a timeout occures, this helps
	 */
	if (d->props.generic_bulk_ctrl_endpoint != 0) {
		usb_clear_halt(d->udev,usb_sndbulkpipe(d->udev,d->props.generic_bulk_ctrl_endpoint));
		usb_clear_halt(d->udev,usb_rcvbulkpipe(d->udev,d->props.generic_bulk_ctrl_endpoint));
	}
	usb_clear_halt(d->udev,usb_rcvbulkpipe(d->udev,d->props.urb.endpoint));

	/* allocate the array for the data transfer URBs */
	d->urb_list = kmalloc(d->props.urb.count * sizeof(struct urb *),GFP_KERNEL);
	if (d->urb_list == NULL)
		return -ENOMEM;
	memset(d->urb_list,0,d->props.urb.count * sizeof(struct urb *));
	d->state |= DVB_USB_STATE_URB_LIST;

	switch (d->props.urb.type) {
		case DVB_USB_BULK:
			return dvb_usb_bulk_urb_init(d);
		case DVB_USB_ISOC:
			return dvb_usb_isoc_urb_init(d);
		default:
			err("unkown URB-type for data transfer.");
			return -EINVAL;
	}
}

int dvb_usb_urb_exit(struct dvb_usb_device *d)
{
	int i;

	dvb_usb_urb_kill(d);

	if (d->state & DVB_USB_STATE_URB_LIST) {
		for (i = 0; i < d->urbs_initialized; i++) {
			if (d->urb_list[i] != NULL) {
				deb_mem("freeing URB no. %d.\n",i);
				/* free the URBs */
				usb_free_urb(d->urb_list[i]);
			}
		}
		d->urbs_initialized = 0;
		/* free the urb array */
		kfree(d->urb_list);
		d->state &= ~DVB_USB_STATE_URB_LIST;
	}

	dvb_usb_free_stream_buffers(d);
	return 0;
}
Commit	Line	Data
776338e1 JS	1	/* dvb-usb-urb.c is part of the DVB USB library.
	2	*
	3	* Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de)
	4	* see dvb-usb-init.c for copyright information.
	5	*
	6	* This file contains functions for initializing and handling the
	7	* USB and URB stuff.
	8	*/
	9	#include "dvb-usb-common.h"
	10
	11	int dvb_usb_generic_rw(struct dvb_usb_device d, u8 wbuf, u16 wlen, u8 *rbuf,
	12	u16 rlen, int delay_ms)
	13	{
	14	int actlen,ret = -ENOMEM;
	15
	16	if (d->props.generic_bulk_ctrl_endpoint == 0) {
	17	err("endpoint for generic control not specified.");
	18	return -EINVAL;
	19	}
	20
	21	if (wbuf == NULL \|\| wlen == 0)
	22	return -EINVAL;
	23
	24	if ((ret = down_interruptible(&d->usb_sem)))
	25	return ret;
	26
7f5fee57	27	deb_xfer(">>> ");
776338e1 JS	28	debug_dump(wbuf,wlen,deb_xfer);
	29
	30	ret = usb_bulk_msg(d->udev,usb_sndbulkpipe(d->udev,
	31	d->props.generic_bulk_ctrl_endpoint), wbuf,wlen,&actlen,
e161f817	32	2000);
776338e1 JS	33
	34	if (ret)
	35	err("bulk message failed: %d (%d/%d)",ret,wlen,actlen);
	36	else
	37	ret = actlen != wlen ? -1 : 0;
	38
	39	/* an answer is expected, and no error before */
	40	if (!ret && rbuf && rlen) {
	41	if (delay_ms)
	42	msleep(delay_ms);
	43
	44	ret = usb_bulk_msg(d->udev,usb_rcvbulkpipe(d->udev,
	45	d->props.generic_bulk_ctrl_endpoint),rbuf,rlen,&actlen,
e161f817	46	2000);
776338e1 JS	47
	48	if (ret)
	49	err("recv bulk message failed: %d",ret);
7f5fee57 PB	50	else {
7f5fee57 PB	51	deb_xfer("<<< ");
776338e1	52	debug_dump(rbuf,actlen,deb_xfer);
7f5fee57	53	}
776338e1 JS	54	}
	55
	56	up(&d->usb_sem);
	57	return ret;
	58	}
	59	EXPORT_SYMBOL(dvb_usb_generic_rw);
	60
	61	int dvb_usb_generic_write(struct dvb_usb_device d, u8 buf, u16 len)
	62	{
	63	return dvb_usb_generic_rw(d,buf,len,NULL,0,0);
	64	}
	65	EXPORT_SYMBOL(dvb_usb_generic_write);
	66
7f5fee57 PB	67
	68	/* URB stuff for streaming */
	69	static void dvb_usb_urb_complete(struct urb urb, struct pt_regs ptregs)
776338e1 JS	70	{
776338e1 JS	71	struct dvb_usb_device *d = urb->context;
7f5fee57 PB	72	int ptype = usb_pipetype(urb->pipe);
	73	int i;
	74	u8 *b;
776338e1	75
7f5fee57 PB	76	deb_ts("'%s' urb completed. feedcount: %d, status: %d, length: %d/%d, pack_num: %d, errors: %d\n",
	77	ptype == PIPE_ISOCHRONOUS ? "isoc" : "bulk", d->feedcount,
	78	urb->status,urb->actual_length,urb->transfer_buffer_length,
	79	urb->number_of_packets,urb->error_count);
776338e1 JS	80
	81	switch (urb->status) {
	82	case 0: /* success */
	83	case -ETIMEDOUT: /* NAK */
	84	break;
	85	case -ECONNRESET: /* kill */
	86	case -ENOENT:
	87	case -ESHUTDOWN:
	88	return;
	89	default: /* error */
	90	deb_ts("urb completition error %d.", urb->status);
	91	break;
	92	}
	93
7f5fee57 PB	94	if (d->feedcount > 0) {
	95	if (d->state & DVB_USB_STATE_DVB) {
	96	switch (ptype) {
	97	case PIPE_ISOCHRONOUS:
	98	b = (u8 *) urb->transfer_buffer;
	99	for (i = 0; i < urb->number_of_packets; i++) {
	100	if (urb->iso_frame_desc[i].status != 0)
	101	deb_ts("iso frame descriptor has an error: %d\n",urb->iso_frame_desc[i].status);
	102	else if (urb->iso_frame_desc[i].actual_length > 0) {
	103	dvb_dmx_swfilter(&d->demux,b + urb->iso_frame_desc[i].offset,
	104	urb->iso_frame_desc[i].actual_length);
	105	}
	106	urb->iso_frame_desc[i].status = 0;
	107	urb->iso_frame_desc[i].actual_length = 0;
	108	}
	109	debug_dump(b,20,deb_ts);
	110	break;
	111	case PIPE_BULK:
	112	if (urb->actual_length > 0)
	113	dvb_dmx_swfilter(&d->demux, (u8 *) urb->transfer_buffer,urb->actual_length);
	114	break;
	115	default:
	116	err("unkown endpoint type in completition handler.");
	117	return;
	118	}
	119	}
	120	}
776338e1 JS	121
	122	usb_submit_urb(urb,GFP_ATOMIC);
	123	}
	124
	125	int dvb_usb_urb_kill(struct dvb_usb_device *d)
	126	{
	127	int i;
	128	for (i = 0; i < d->urbs_submitted; i++) {
7f5fee57	129	deb_ts("killing URB no. %d.\n",i);
776338e1 JS	130
	131	/* stop the URB */
	132	usb_kill_urb(d->urb_list[i]);
	133	}
	134	d->urbs_submitted = 0;
	135	return 0;
	136	}
	137
	138	int dvb_usb_urb_submit(struct dvb_usb_device *d)
	139	{
	140	int i,ret;
	141	for (i = 0; i < d->urbs_initialized; i++) {
7f5fee57	142	deb_ts("submitting URB no. %d\n",i);
776338e1	143	if ((ret = usb_submit_urb(d->urb_list[i],GFP_ATOMIC))) {
7f5fee57	144	err("could not submit URB no. %d - get them all back",i);
776338e1 JS	145	dvb_usb_urb_kill(d);
	146	return ret;
	147	}
	148	d->urbs_submitted++;
	149	}
	150	return 0;
	151	}
	152
7f5fee57	153	static int dvb_usb_free_stream_buffers(struct dvb_usb_device *d)
776338e1	154	{
7f5fee57 PB	155	if (d->state & DVB_USB_STATE_URB_BUF) {
	156	while (d->buf_num) {
	157	d->buf_num--;
	158	deb_mem("freeing buffer %d\n",d->buf_num);
	159	usb_buffer_free(d->udev, d->buf_size,
	160	d->buf_list[d->buf_num], d->dma_addr[d->buf_num]);
	161	}
	162	kfree(d->buf_list);
	163	kfree(d->dma_addr);
	164	}
	165
	166	d->state &= ~DVB_USB_STATE_URB_BUF;
776338e1	167
7f5fee57 PB	168	return 0;
	169	}
	170
	171	static int dvb_usb_allocate_stream_buffers(struct dvb_usb_device *d, int num, unsigned long size)
	172	{
	173	d->buf_num = 0;
	174	d->buf_size = size;
	175
	176	deb_mem("all in all I will use %lu bytes for streaming\n",num*size);
	177
	178	if ((d->buf_list = kmalloc(numsizeof(u8 ), GFP_ATOMIC)) == NULL)
	179	return -ENOMEM;
	180
	181	if ((d->dma_addr = kmalloc(num*sizeof(dma_addr_t), GFP_ATOMIC)) == NULL) {
	182	kfree(d->buf_list);
776338e1 JS	183	return -ENOMEM;
776338e1 JS	184	}
7f5fee57 PB	185	memset(d->buf_list,0,numsizeof(u8 ));
7f5fee57 PB	186	memset(d->dma_addr,0,num*sizeof(dma_addr_t));
776338e1 JS	187
	188	d->state \|= DVB_USB_STATE_URB_BUF;
	189
7f5fee57 PB	190	for (d->buf_num = 0; d->buf_num < num; d->buf_num++) {
	191	deb_mem("allocating buffer %d\n",d->buf_num);
	192	if (( d->buf_list[d->buf_num] =
	193	usb_buffer_alloc(d->udev, size, SLAB_ATOMIC,
	194	&d->dma_addr[d->buf_num]) ) == NULL) {
	195	deb_mem("not enough memory for urb-buffer allocation.\n");
	196	dvb_usb_free_stream_buffers(d);
	197	return -ENOMEM;
	198	}
d371d6a0 AM	199	deb_mem("buffer %d: %p (dma: %llu)\n",
	200	d->buf_num, d->buf_list[d->buf_num],
	201	(unsigned long long)d->dma_addr[d->buf_num]);
7f5fee57 PB	202	memset(d->buf_list[d->buf_num],0,size);
	203	}
	204	deb_mem("allocation successful\n");
	205
	206	return 0;
	207	}
	208
	209	static int dvb_usb_bulk_urb_init(struct dvb_usb_device *d)
	210	{
	211	int i;
	212
	213	if ((i = dvb_usb_allocate_stream_buffers(d,d->props.urb.count,
	214	d->props.urb.u.bulk.buffersize)) < 0)
	215	return i;
	216
776338e1 JS	217	/* allocate the URBs */
776338e1 JS	218	for (i = 0; i < d->props.urb.count; i++) {
7f5fee57	219	if ((d->urb_list[i] = usb_alloc_urb(0,GFP_ATOMIC)) == NULL)
776338e1	220	return -ENOMEM;
776338e1 JS	221
	222	usb_fill_bulk_urb( d->urb_list[i], d->udev,
	223	usb_rcvbulkpipe(d->udev,d->props.urb.endpoint),
7f5fee57	224	d->buf_list[i],
776338e1	225	d->props.urb.u.bulk.buffersize,
7f5fee57	226	dvb_usb_urb_complete, d);
776338e1 JS	227
	228	d->urb_list[i]->transfer_flags = 0;
	229	d->urbs_initialized++;
	230	}
	231	return 0;
	232	}
	233
7f5fee57 PB	234	static int dvb_usb_isoc_urb_init(struct dvb_usb_device *d)
	235	{
	236	int i,j;
	237
	238	if ((i = dvb_usb_allocate_stream_buffers(d,d->props.urb.count,
	239	d->props.urb.u.isoc.framesize*d->props.urb.u.isoc.framesperurb)) < 0)
	240	return i;
	241
	242	/* allocate the URBs */
	243	for (i = 0; i < d->props.urb.count; i++) {
	244	struct urb *urb;
	245	int frame_offset = 0;
	246	if ((d->urb_list[i] =
	247	usb_alloc_urb(d->props.urb.u.isoc.framesperurb,GFP_ATOMIC)) == NULL)
	248	return -ENOMEM;
	249
	250	urb = d->urb_list[i];
	251
	252	urb->dev = d->udev;
	253	urb->context = d;
	254	urb->complete = dvb_usb_urb_complete;
	255	urb->pipe = usb_rcvisocpipe(d->udev,d->props.urb.endpoint);
	256	urb->transfer_flags = URB_ISO_ASAP \| URB_NO_TRANSFER_DMA_MAP;
	257	urb->interval = d->props.urb.u.isoc.interval;
	258	urb->number_of_packets = d->props.urb.u.isoc.framesperurb;
	259	urb->transfer_buffer_length = d->buf_size;
	260	urb->transfer_buffer = d->buf_list[i];
	261	urb->transfer_dma = d->dma_addr[i];
	262
	263	for (j = 0; j < d->props.urb.u.isoc.framesperurb; j++) {
	264	urb->iso_frame_desc[j].offset = frame_offset;
	265	urb->iso_frame_desc[j].length = d->props.urb.u.isoc.framesize;
	266	frame_offset += d->props.urb.u.isoc.framesize;
	267	}
	268
	269	d->urbs_initialized++;
	270	}
	271	return 0;
	272
	273	}
	274
776338e1 JS	275	int dvb_usb_urb_init(struct dvb_usb_device *d)
	276	{
	277	/*
	278	* when reloading the driver w/o replugging the device
	279	* sometimes a timeout occures, this helps
	280	*/
	281	if (d->props.generic_bulk_ctrl_endpoint != 0) {
	282	usb_clear_halt(d->udev,usb_sndbulkpipe(d->udev,d->props.generic_bulk_ctrl_endpoint));
	283	usb_clear_halt(d->udev,usb_rcvbulkpipe(d->udev,d->props.generic_bulk_ctrl_endpoint));
	284	}
	285	usb_clear_halt(d->udev,usb_rcvbulkpipe(d->udev,d->props.urb.endpoint));
	286
	287	/* allocate the array for the data transfer URBs */
	288	d->urb_list = kmalloc(d->props.urb.count * sizeof(struct urb *),GFP_KERNEL);
	289	if (d->urb_list == NULL)
	290	return -ENOMEM;
	291	memset(d->urb_list,0,d->props.urb.count * sizeof(struct urb *));
	292	d->state \|= DVB_USB_STATE_URB_LIST;
	293
	294	switch (d->props.urb.type) {
	295	case DVB_USB_BULK:
	296	return dvb_usb_bulk_urb_init(d);
	297	case DVB_USB_ISOC:
7f5fee57	298	return dvb_usb_isoc_urb_init(d);
776338e1 JS	299	default:
	300	err("unkown URB-type for data transfer.");
	301	return -EINVAL;
	302	}
	303	}
	304
	305	int dvb_usb_urb_exit(struct dvb_usb_device *d)
	306	{
	307	int i;
	308
	309	dvb_usb_urb_kill(d);
	310
	311	if (d->state & DVB_USB_STATE_URB_LIST) {
	312	for (i = 0; i < d->urbs_initialized; i++) {
	313	if (d->urb_list[i] != NULL) {
7f5fee57	314	deb_mem("freeing URB no. %d.\n",i);
776338e1 JS	315	/* free the URBs */
	316	usb_free_urb(d->urb_list[i]);
	317	}
	318	}
	319	d->urbs_initialized = 0;
	320	/* free the urb array */
	321	kfree(d->urb_list);
	322	d->state &= ~DVB_USB_STATE_URB_LIST;
	323	}
	324
7f5fee57	325	dvb_usb_free_stream_buffers(d);
776338e1 JS	326	return 0;
776338e1 JS	327	}