mirror of https://gitee.com/openkylin/linux.git
325 lines
8.3 KiB
C
325 lines
8.3 KiB
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 */
|
|
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 = 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;
|
|
}
|