[GitHub/mt8127/android_kernel_alcatel_ttab.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 = mutex_lock_interruptible(&d->usb_mutex)))
		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);
		}
	}

	mutex_unlock(&d->usb_mutex);
	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 */
			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 = kcalloc(num, sizeof(u8 *), GFP_ATOMIC)) == NULL)
		return -ENOMEM;

	if ((d->dma_addr = kcalloc(num, sizeof(dma_addr_t), GFP_ATOMIC)) == NULL) {
		kfree(d->buf_list);
		return -ENOMEM;
	}

	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 = kzalloc(d->props.urb.count * sizeof(struct urb *),GFP_KERNEL);
	if (d->urb_list == NULL)
		return -ENOMEM;
	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
3593cab5	24	if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
776338e1 JS	25	return ret;
776338e1 JS	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	}
776338e1 JS	55
3593cab5	56	mutex_unlock(&d->usb_mutex);
776338e1 JS	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 */
776338e1 JS	83	break;
	84	case -ECONNRESET: /* kill */
	85	case -ENOENT:
	86	case -ESHUTDOWN:
	87	return;
	88	default: /* error */
	89	deb_ts("urb completition error %d.", urb->status);
	90	break;
	91	}
	92
7f5fee57 PB	93	if (d->feedcount > 0) {
	94	if (d->state & DVB_USB_STATE_DVB) {
	95	switch (ptype) {
	96	case PIPE_ISOCHRONOUS:
	97	b = (u8 *) urb->transfer_buffer;
	98	for (i = 0; i < urb->number_of_packets; i++) {
	99	if (urb->iso_frame_desc[i].status != 0)
	100	deb_ts("iso frame descriptor has an error: %d\n",urb->iso_frame_desc[i].status);
	101	else if (urb->iso_frame_desc[i].actual_length > 0) {
	102	dvb_dmx_swfilter(&d->demux,b + urb->iso_frame_desc[i].offset,
	103	urb->iso_frame_desc[i].actual_length);
	104	}
	105	urb->iso_frame_desc[i].status = 0;
	106	urb->iso_frame_desc[i].actual_length = 0;
	107	}
	108	debug_dump(b,20,deb_ts);
	109	break;
	110	case PIPE_BULK:
	111	if (urb->actual_length > 0)
	112	dvb_dmx_swfilter(&d->demux, (u8 *) urb->transfer_buffer,urb->actual_length);
	113	break;
	114	default:
	115	err("unkown endpoint type in completition handler.");
	116	return;
	117	}
	118	}
	119	}
776338e1 JS	120
	121	usb_submit_urb(urb,GFP_ATOMIC);
	122	}
	123
	124	int dvb_usb_urb_kill(struct dvb_usb_device *d)
	125	{
	126	int i;
	127	for (i = 0; i < d->urbs_submitted; i++) {
7f5fee57	128	deb_ts("killing URB no. %d.\n",i);
776338e1 JS	129
	130	/* stop the URB */
	131	usb_kill_urb(d->urb_list[i]);
	132	}
	133	d->urbs_submitted = 0;
	134	return 0;
	135	}
	136
	137	int dvb_usb_urb_submit(struct dvb_usb_device *d)
	138	{
	139	int i,ret;
	140	for (i = 0; i < d->urbs_initialized; i++) {
7f5fee57	141	deb_ts("submitting URB no. %d\n",i);
776338e1	142	if ((ret = usb_submit_urb(d->urb_list[i],GFP_ATOMIC))) {
7f5fee57	143	err("could not submit URB no. %d - get them all back",i);
776338e1 JS	144	dvb_usb_urb_kill(d);
	145	return ret;
	146	}
	147	d->urbs_submitted++;
	148	}
	149	return 0;
	150	}
	151
7f5fee57	152	static int dvb_usb_free_stream_buffers(struct dvb_usb_device *d)
776338e1	153	{
7f5fee57 PB	154	if (d->state & DVB_USB_STATE_URB_BUF) {
	155	while (d->buf_num) {
	156	d->buf_num--;
	157	deb_mem("freeing buffer %d\n",d->buf_num);
	158	usb_buffer_free(d->udev, d->buf_size,
	159	d->buf_list[d->buf_num], d->dma_addr[d->buf_num]);
	160	}
	161	kfree(d->buf_list);
	162	kfree(d->dma_addr);
	163	}
	164
	165	d->state &= ~DVB_USB_STATE_URB_BUF;
776338e1	166
7f5fee57 PB	167	return 0;
	168	}
	169
	170	static int dvb_usb_allocate_stream_buffers(struct dvb_usb_device *d, int num, unsigned long size)
	171	{
	172	d->buf_num = 0;
	173	d->buf_size = size;
	174
	175	deb_mem("all in all I will use %lu bytes for streaming\n",num*size);
	176
7408187d	177	if ((d->buf_list = kcalloc(num, sizeof(u8 *), GFP_ATOMIC)) == NULL)
7f5fee57 PB	178	return -ENOMEM;
7f5fee57 PB	179
7408187d	180	if ((d->dma_addr = kcalloc(num, sizeof(dma_addr_t), GFP_ATOMIC)) == NULL) {
7f5fee57	181	kfree(d->buf_list);
776338e1 JS	182	return -ENOMEM;
776338e1 JS	183	}
776338e1 JS	184
	185	d->state \|= DVB_USB_STATE_URB_BUF;
	186
7f5fee57 PB	187	for (d->buf_num = 0; d->buf_num < num; d->buf_num++) {
	188	deb_mem("allocating buffer %d\n",d->buf_num);
	189	if (( d->buf_list[d->buf_num] =
	190	usb_buffer_alloc(d->udev, size, SLAB_ATOMIC,
	191	&d->dma_addr[d->buf_num]) ) == NULL) {
	192	deb_mem("not enough memory for urb-buffer allocation.\n");
	193	dvb_usb_free_stream_buffers(d);
	194	return -ENOMEM;
	195	}
d371d6a0 AM	196	deb_mem("buffer %d: %p (dma: %llu)\n",
	197	d->buf_num, d->buf_list[d->buf_num],
	198	(unsigned long long)d->dma_addr[d->buf_num]);
7f5fee57 PB	199	memset(d->buf_list[d->buf_num],0,size);
	200	}
	201	deb_mem("allocation successful\n");
	202
	203	return 0;
	204	}
	205
	206	static int dvb_usb_bulk_urb_init(struct dvb_usb_device *d)
	207	{
	208	int i;
	209
	210	if ((i = dvb_usb_allocate_stream_buffers(d,d->props.urb.count,
	211	d->props.urb.u.bulk.buffersize)) < 0)
	212	return i;
	213
776338e1 JS	214	/* allocate the URBs */
776338e1 JS	215	for (i = 0; i < d->props.urb.count; i++) {
7f5fee57	216	if ((d->urb_list[i] = usb_alloc_urb(0,GFP_ATOMIC)) == NULL)
776338e1	217	return -ENOMEM;
776338e1 JS	218
	219	usb_fill_bulk_urb( d->urb_list[i], d->udev,
	220	usb_rcvbulkpipe(d->udev,d->props.urb.endpoint),
7f5fee57	221	d->buf_list[i],
776338e1	222	d->props.urb.u.bulk.buffersize,
7f5fee57	223	dvb_usb_urb_complete, d);
776338e1 JS	224
	225	d->urb_list[i]->transfer_flags = 0;
	226	d->urbs_initialized++;
	227	}
	228	return 0;
	229	}
	230
7f5fee57 PB	231	static int dvb_usb_isoc_urb_init(struct dvb_usb_device *d)
	232	{
	233	int i,j;
	234
	235	if ((i = dvb_usb_allocate_stream_buffers(d,d->props.urb.count,
	236	d->props.urb.u.isoc.framesize*d->props.urb.u.isoc.framesperurb)) < 0)
	237	return i;
	238
	239	/* allocate the URBs */
	240	for (i = 0; i < d->props.urb.count; i++) {
	241	struct urb *urb;
	242	int frame_offset = 0;
	243	if ((d->urb_list[i] =
	244	usb_alloc_urb(d->props.urb.u.isoc.framesperurb,GFP_ATOMIC)) == NULL)
	245	return -ENOMEM;
	246
	247	urb = d->urb_list[i];
	248
	249	urb->dev = d->udev;
	250	urb->context = d;
	251	urb->complete = dvb_usb_urb_complete;
	252	urb->pipe = usb_rcvisocpipe(d->udev,d->props.urb.endpoint);
	253	urb->transfer_flags = URB_ISO_ASAP \| URB_NO_TRANSFER_DMA_MAP;
	254	urb->interval = d->props.urb.u.isoc.interval;
	255	urb->number_of_packets = d->props.urb.u.isoc.framesperurb;
	256	urb->transfer_buffer_length = d->buf_size;
	257	urb->transfer_buffer = d->buf_list[i];
	258	urb->transfer_dma = d->dma_addr[i];
	259
	260	for (j = 0; j < d->props.urb.u.isoc.framesperurb; j++) {
	261	urb->iso_frame_desc[j].offset = frame_offset;
	262	urb->iso_frame_desc[j].length = d->props.urb.u.isoc.framesize;
	263	frame_offset += d->props.urb.u.isoc.framesize;
	264	}
	265
	266	d->urbs_initialized++;
	267	}
	268	return 0;
	269
	270	}
	271
776338e1 JS	272	int dvb_usb_urb_init(struct dvb_usb_device *d)
	273	{
	274	/*
	275	* when reloading the driver w/o replugging the device
	276	* sometimes a timeout occures, this helps
	277	*/
	278	if (d->props.generic_bulk_ctrl_endpoint != 0) {
	279	usb_clear_halt(d->udev,usb_sndbulkpipe(d->udev,d->props.generic_bulk_ctrl_endpoint));
	280	usb_clear_halt(d->udev,usb_rcvbulkpipe(d->udev,d->props.generic_bulk_ctrl_endpoint));
	281	}
	282	usb_clear_halt(d->udev,usb_rcvbulkpipe(d->udev,d->props.urb.endpoint));
	283
	284	/* allocate the array for the data transfer URBs */
7408187d	285	d->urb_list = kzalloc(d->props.urb.count * sizeof(struct urb *),GFP_KERNEL);
776338e1 JS	286	if (d->urb_list == NULL)
776338e1 JS	287	return -ENOMEM;
776338e1 JS	288	d->state \|= DVB_USB_STATE_URB_LIST;
	289
	290	switch (d->props.urb.type) {
	291	case DVB_USB_BULK:
	292	return dvb_usb_bulk_urb_init(d);
	293	case DVB_USB_ISOC:
7f5fee57	294	return dvb_usb_isoc_urb_init(d);
776338e1 JS	295	default:
	296	err("unkown URB-type for data transfer.");
	297	return -EINVAL;
	298	}
	299	}
	300
	301	int dvb_usb_urb_exit(struct dvb_usb_device *d)
	302	{
	303	int i;
	304
	305	dvb_usb_urb_kill(d);
	306
	307	if (d->state & DVB_USB_STATE_URB_LIST) {
	308	for (i = 0; i < d->urbs_initialized; i++) {
	309	if (d->urb_list[i] != NULL) {
7f5fee57	310	deb_mem("freeing URB no. %d.\n",i);
776338e1 JS	311	/* free the URBs */
	312	usb_free_urb(d->urb_list[i]);
	313	}
	314	}
	315	d->urbs_initialized = 0;
	316	/* free the urb array */
	317	kfree(d->urb_list);
	318	d->state &= ~DVB_USB_STATE_URB_LIST;
	319	}
	320
7f5fee57	321	dvb_usb_free_stream_buffers(d);
776338e1 JS	322	return 0;
776338e1 JS	323	}