URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [usb/] [dabusb.c] - Rev 1765
Compare with Previous | Blame | View Log
/*****************************************************************************/ /* * dabusb.c -- dab usb driver. * * Copyright (C) 1999 Deti Fliegl (deti@fliegl.de) * * 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; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * * * $Id: dabusb.c,v 1.1.1.1 2004-04-15 01:54:14 phoenix Exp $ * */ /*****************************************************************************/ #include <linux/module.h> #include <linux/socket.h> #include <linux/miscdevice.h> #include <linux/list.h> #include <linux/vmalloc.h> #include <linux/slab.h> #include <linux/init.h> #include <asm/uaccess.h> #include <asm/atomic.h> #include <linux/delay.h> #include <linux/usb.h> #include <linux/smp_lock.h> #include "dabusb.h" #include "dabfirmware.h" /* * Version Information */ #define DRIVER_VERSION "v1.54" #define DRIVER_AUTHOR "Deti Fliegl, deti@fliegl.de" #define DRIVER_DESC "DAB-USB Interface Driver for Linux (c)1999" /* --------------------------------------------------------------------- */ #define NRDABUSB 4 /*-------------------------------------------------------------------*/ static dabusb_t dabusb[NRDABUSB]; static int buffers = 256; /*-------------------------------------------------------------------*/ static int dabusb_add_buf_tail (pdabusb_t s, struct list_head *dst, struct list_head *src) { unsigned long flags; struct list_head *tmp; int ret = 0; spin_lock_irqsave (&s->lock, flags); if (list_empty (src)) { // no elements in source buffer ret = -1; goto err; } tmp = src->next; list_del (tmp); list_add_tail (tmp, dst); err: spin_unlock_irqrestore (&s->lock, flags); return ret; } /*-------------------------------------------------------------------*/ #ifdef DEBUG static void dump_urb (struct urb *purb) { dbg("urb :%p", purb); dbg("next :%p", purb->next); dbg("dev :%p", purb->dev); dbg("pipe :%08X", purb->pipe); dbg("status :%d", purb->status); dbg("transfer_flags :%08X", purb->transfer_flags); dbg("transfer_buffer :%p", purb->transfer_buffer); dbg("transfer_buffer_length:%d", purb->transfer_buffer_length); dbg("actual_length :%d", purb->actual_length); dbg("setup_packet :%p", purb->setup_packet); dbg("start_frame :%d", purb->start_frame); dbg("number_of_packets :%d", purb->number_of_packets); dbg("interval :%d", purb->interval); dbg("error_count :%d", purb->error_count); dbg("context :%p", purb->context); dbg("complete :%p", purb->complete); } #endif /*-------------------------------------------------------------------*/ static int dabusb_cancel_queue (pdabusb_t s, struct list_head *q) { unsigned long flags; struct list_head *p; pbuff_t b; dbg("dabusb_cancel_queue"); spin_lock_irqsave (&s->lock, flags); for (p = q->next; p != q; p = p->next) { b = list_entry (p, buff_t, buff_list); #ifdef DEBUG dump_urb(b->purb); #endif usb_unlink_urb (b->purb); } spin_unlock_irqrestore (&s->lock, flags); return 0; } /*-------------------------------------------------------------------*/ static int dabusb_free_queue (struct list_head *q) { struct list_head *tmp; struct list_head *p; pbuff_t b; dbg("dabusb_free_queue"); for (p = q->next; p != q;) { b = list_entry (p, buff_t, buff_list); #ifdef DEBUG dump_urb(b->purb); #endif if (b->purb->transfer_buffer) kfree (b->purb->transfer_buffer); usb_free_urb(b->purb); tmp = p->next; list_del (p); kfree (b); p = tmp; } return 0; } /*-------------------------------------------------------------------*/ static int dabusb_free_buffers (pdabusb_t s) { unsigned long flags; dbg("dabusb_free_buffers"); spin_lock_irqsave(&s->lock, flags); dabusb_free_queue (&s->free_buff_list); dabusb_free_queue (&s->rec_buff_list); spin_unlock_irqrestore(&s->lock, flags); s->got_mem = 0; return 0; } /*-------------------------------------------------------------------*/ static void dabusb_iso_complete (struct urb *purb) { pbuff_t b = purb->context; pdabusb_t s = b->s; int i; int len; int dst = 0; void *buf = purb->transfer_buffer; dbg("dabusb_iso_complete"); // process if URB was not killed if (purb->status != -ENOENT) { unsigned int pipe = usb_rcvisocpipe (purb->dev, _DABUSB_ISOPIPE); int pipesize = usb_maxpacket (purb->dev, pipe, usb_pipeout (pipe)); for (i = 0; i < purb->number_of_packets; i++) if (!purb->iso_frame_desc[i].status) { len = purb->iso_frame_desc[i].actual_length; if (len <= pipesize) { memcpy (buf + dst, buf + purb->iso_frame_desc[i].offset, len); dst += len; } else err("dabusb_iso_complete: invalid len %d", len); } else warn("dabusb_iso_complete: corrupted packet status: %d", purb->iso_frame_desc[i].status); if (dst != purb->actual_length) err("dst!=purb->actual_length:%d!=%d", dst, purb->actual_length); } if (atomic_dec_and_test (&s->pending_io) && !s->remove_pending && s->state != _stopped) { s->overruns++; err("overrun (%d)", s->overruns); } wake_up (&s->wait); } /*-------------------------------------------------------------------*/ static int dabusb_alloc_buffers (pdabusb_t s) { int buffers = 0; pbuff_t b; unsigned int pipe = usb_rcvisocpipe (s->usbdev, _DABUSB_ISOPIPE); int pipesize = usb_maxpacket (s->usbdev, pipe, usb_pipeout (pipe)); int packets = _ISOPIPESIZE / pipesize; int transfer_buffer_length = packets * pipesize; int i; dbg("dabusb_alloc_buffers pipesize:%d packets:%d transfer_buffer_len:%d", pipesize, packets, transfer_buffer_length); while (buffers < (s->total_buffer_size << 10)) { b = (pbuff_t) kmalloc (sizeof (buff_t), GFP_KERNEL); if (!b) { err("kmalloc(sizeof(buff_t))==NULL"); goto err; } memset (b, 0, sizeof (buff_t)); b->s = s; b->purb = usb_alloc_urb(packets); if (!b->purb) { err("usb_alloc_urb == NULL"); kfree (b); goto err; } b->purb->transfer_buffer = kmalloc (transfer_buffer_length, GFP_KERNEL); if (!b->purb->transfer_buffer) { kfree (b->purb); kfree (b); err("kmalloc(%d)==NULL", transfer_buffer_length); goto err; } b->purb->transfer_buffer_length = transfer_buffer_length; b->purb->number_of_packets = packets; b->purb->complete = dabusb_iso_complete; b->purb->context = b; b->purb->dev = s->usbdev; b->purb->pipe = pipe; b->purb->transfer_flags = USB_ISO_ASAP; for (i = 0; i < packets; i++) { b->purb->iso_frame_desc[i].offset = i * pipesize; b->purb->iso_frame_desc[i].length = pipesize; } buffers += transfer_buffer_length; list_add_tail (&b->buff_list, &s->free_buff_list); } s->got_mem = buffers; return 0; err: dabusb_free_buffers (s); return -ENOMEM; } /*-------------------------------------------------------------------*/ static int dabusb_bulk (pdabusb_t s, pbulk_transfer_t pb) { int ret; unsigned int pipe; int actual_length; dbg("dabusb_bulk"); if (!pb->pipe) pipe = usb_rcvbulkpipe (s->usbdev, 2); else pipe = usb_sndbulkpipe (s->usbdev, 2); ret=usb_bulk_msg(s->usbdev, pipe, pb->data, pb->size, &actual_length, 100); if(ret<0) { err("dabusb: usb_bulk_msg failed(%d)",ret); if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) { err("set_interface failed"); return -EINVAL; } } if( ret == -EPIPE ) { warn("CLEAR_FEATURE request to remove STALL condition."); if(usb_clear_halt(s->usbdev, usb_pipeendpoint(pipe))) err("request failed"); } pb->size = actual_length; return ret; } /* --------------------------------------------------------------------- */ static int dabusb_writemem (pdabusb_t s, int pos, unsigned char *data, int len) { int ret; unsigned char *transfer_buffer = kmalloc (len, GFP_KERNEL); if (!transfer_buffer) { err("dabusb_writemem: kmalloc(%d) failed.", len); return -ENOMEM; } memcpy (transfer_buffer, data, len); ret=usb_control_msg(s->usbdev, usb_sndctrlpipe( s->usbdev, 0 ), 0xa0, 0x40, pos, 0, transfer_buffer, len, 300); kfree (transfer_buffer); return ret; } /* --------------------------------------------------------------------- */ static int dabusb_8051_reset (pdabusb_t s, unsigned char reset_bit) { dbg("dabusb_8051_reset: %d",reset_bit); return dabusb_writemem (s, CPUCS_REG, &reset_bit, 1); } /* --------------------------------------------------------------------- */ static int dabusb_loadmem (pdabusb_t s, const char *fname) { int ret; PINTEL_HEX_RECORD ptr = firmware; dbg("Enter dabusb_loadmem (internal)"); ret = dabusb_8051_reset (s, 1); while (ptr->Type == 0) { dbg("dabusb_writemem: %04X %p %d)", ptr->Address, ptr->Data, ptr->Length); ret = dabusb_writemem (s, ptr->Address, ptr->Data, ptr->Length); if (ret < 0) { err("dabusb_writemem failed (%d %04X %p %d)", ret, ptr->Address, ptr->Data, ptr->Length); break; } ptr++; } ret = dabusb_8051_reset (s, 0); dbg("dabusb_loadmem: exit"); return ret; } /* --------------------------------------------------------------------- */ static int dabusb_fpga_clear (pdabusb_t s, pbulk_transfer_t b) { b->size = 4; b->data[0] = 0x2a; b->data[1] = 0; b->data[2] = 0; b->data[3] = 0; dbg("dabusb_fpga_clear"); return dabusb_bulk (s, b); } /* --------------------------------------------------------------------- */ static int dabusb_fpga_init (pdabusb_t s, pbulk_transfer_t b) { b->size = 4; b->data[0] = 0x2c; b->data[1] = 0; b->data[2] = 0; b->data[3] = 0; dbg("dabusb_fpga_init"); return dabusb_bulk (s, b); } /* --------------------------------------------------------------------- */ static int dabusb_fpga_download (pdabusb_t s, const char *fname) { pbulk_transfer_t b = kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL); unsigned int blen, n; int ret; unsigned char *buf = bitstream; dbg("Enter dabusb_fpga_download (internal)"); if (!b) { err("kmalloc(sizeof(bulk_transfer_t))==NULL"); return -ENOMEM; } b->pipe = 1; ret = dabusb_fpga_clear (s, b); mdelay (10); blen = buf[73] + (buf[72] << 8); dbg("Bitstream len: %i", blen); b->data[0] = 0x2b; b->data[1] = 0; b->data[2] = 0; b->data[3] = 60; for (n = 0; n <= blen + 60; n += 60) { // some cclks for startup b->size = 64; memcpy (b->data + 4, buf + 74 + n, 60); ret = dabusb_bulk (s, b); if (ret < 0) { err("dabusb_bulk failed."); break; } mdelay (1); } ret = dabusb_fpga_init (s, b); kfree (b); dbg("exit dabusb_fpga_download"); return ret; } static int dabusb_stop (pdabusb_t s) { dbg("dabusb_stop"); s->state = _stopped; dabusb_cancel_queue (s, &s->rec_buff_list); dbg("pending_io: %d", s->pending_io.counter); s->pending_io.counter = 0; return 0; } static int dabusb_startrek (pdabusb_t s) { if (!s->got_mem && s->state != _started) { dbg("dabusb_startrek"); if (dabusb_alloc_buffers (s) < 0) return -ENOMEM; dabusb_stop (s); s->state = _started; s->readptr = 0; } if (!list_empty (&s->free_buff_list)) { pbuff_t end; int ret; while (!dabusb_add_buf_tail (s, &s->rec_buff_list, &s->free_buff_list)) { dbg("submitting: end:%p s->rec_buff_list:%p", s->rec_buff_list.prev, &s->rec_buff_list); end = list_entry (s->rec_buff_list.prev, buff_t, buff_list); ret = usb_submit_urb (end->purb); if (ret) { err("usb_submit_urb returned:%d", ret); if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list)) err("startrek: dabusb_add_buf_tail failed"); break; } else atomic_inc (&s->pending_io); } dbg("pending_io: %d",s->pending_io.counter); } return 0; } static ssize_t dabusb_read (struct file *file, char *buf, size_t count, loff_t * ppos) { pdabusb_t s = (pdabusb_t) file->private_data; unsigned long flags; unsigned ret = 0; int rem; int cnt; pbuff_t b; struct urb *purb = NULL; dbg("dabusb_read"); if (*ppos) return -ESPIPE; if (s->remove_pending) return -EIO; if (!s->usbdev) return -EIO; while (count > 0) { dabusb_startrek (s); spin_lock_irqsave (&s->lock, flags); if (list_empty (&s->rec_buff_list)) { spin_unlock_irqrestore(&s->lock, flags); err("error: rec_buf_list is empty"); goto err; } b = list_entry (s->rec_buff_list.next, buff_t, buff_list); purb = b->purb; spin_unlock_irqrestore(&s->lock, flags); if (purb->status == -EINPROGRESS) { if (file->f_flags & O_NONBLOCK) // return nonblocking { if (!ret) ret = -EAGAIN; goto err; } interruptible_sleep_on (&s->wait); if (signal_pending (current)) { if (!ret) ret = -ERESTARTSYS; goto err; } spin_lock_irqsave (&s->lock, flags); if (list_empty (&s->rec_buff_list)) { spin_unlock_irqrestore(&s->lock, flags); err("error: still no buffer available."); goto err; } spin_unlock_irqrestore(&s->lock, flags); s->readptr = 0; } if (s->remove_pending) { ret = -EIO; goto err; } rem = purb->actual_length - s->readptr; // set remaining bytes to copy if (count >= rem) cnt = rem; else cnt = count; dbg("copy_to_user:%p %p %d",buf, purb->transfer_buffer + s->readptr, cnt); if (copy_to_user (buf, purb->transfer_buffer + s->readptr, cnt)) { err("read: copy_to_user failed"); if (!ret) ret = -EFAULT; goto err; } s->readptr += cnt; count -= cnt; buf += cnt; ret += cnt; if (s->readptr == purb->actual_length) { // finished, take next buffer if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list)) err("read: dabusb_add_buf_tail failed"); s->readptr = 0; } } err: //up(&s->mutex); return ret; } static int dabusb_open (struct inode *inode, struct file *file) { int devnum = MINOR (inode->i_rdev); pdabusb_t s; if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB)) return -EIO; s = &dabusb[devnum - DABUSB_MINOR]; dbg("dabusb_open"); down (&s->mutex); while (!s->usbdev || s->opened) { up (&s->mutex); if (file->f_flags & O_NONBLOCK) { return -EBUSY; } schedule_timeout (HZ / 2); if (signal_pending (current)) { return -EAGAIN; } down (&s->mutex); } if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) { err("set_interface failed"); up(&s->mutex); return -EINVAL; } s->opened = 1; up (&s->mutex); file->f_pos = 0; file->private_data = s; return 0; } static int dabusb_release (struct inode *inode, struct file *file) { pdabusb_t s = (pdabusb_t) file->private_data; dbg("dabusb_release"); lock_kernel(); down (&s->mutex); dabusb_stop (s); dabusb_free_buffers (s); up (&s->mutex); if (!s->remove_pending) { if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0) err("set_interface failed"); } else wake_up (&s->remove_ok); s->opened = 0; unlock_kernel(); return 0; } static int dabusb_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { pdabusb_t s = (pdabusb_t) file->private_data; pbulk_transfer_t pbulk; int ret = 0; int version = DABUSB_VERSION; dbg("dabusb_ioctl"); if (s->remove_pending) return -EIO; down (&s->mutex); if (!s->usbdev) { up (&s->mutex); return -EIO; } switch (cmd) { case IOCTL_DAB_BULK: pbulk = (pbulk_transfer_t) kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL); if (!pbulk) { ret = -ENOMEM; break; } if (copy_from_user (pbulk, (void *) arg, sizeof (bulk_transfer_t))) { ret = -EFAULT; kfree (pbulk); break; } ret=dabusb_bulk (s, pbulk); if(ret==0) ret = copy_to_user ((void *) arg, pbulk, sizeof (bulk_transfer_t)); kfree (pbulk); break; case IOCTL_DAB_OVERRUNS: ret = put_user (s->overruns, (unsigned int *) arg); break; case IOCTL_DAB_VERSION: ret = put_user (version, (unsigned int *) arg); break; default: ret = -ENOIOCTLCMD; break; } up (&s->mutex); return ret; } static struct file_operations dabusb_fops = { owner: THIS_MODULE, llseek: no_llseek, read: dabusb_read, ioctl: dabusb_ioctl, open: dabusb_open, release: dabusb_release, }; static int dabusb_find_struct (void) { int u; for (u = 0; u < NRDABUSB; u++) { pdabusb_t s = &dabusb[u]; if (!s->usbdev) return u; } return -1; } /* --------------------------------------------------------------------- */ static void *dabusb_probe (struct usb_device *usbdev, unsigned int ifnum, const struct usb_device_id *id) { int devnum; pdabusb_t s; dbg("dabusb: probe: vendor id 0x%x, device id 0x%x ifnum:%d", usbdev->descriptor.idVendor, usbdev->descriptor.idProduct, ifnum); /* We don't handle multiple configurations */ if (usbdev->descriptor.bNumConfigurations != 1) return NULL; if (ifnum != _DABUSB_IF && usbdev->descriptor.idProduct == 0x9999) return NULL; devnum = dabusb_find_struct (); if (devnum == -1) return NULL; s = &dabusb[devnum]; down (&s->mutex); s->remove_pending = 0; s->usbdev = usbdev; if (usb_set_configuration (usbdev, usbdev->config[0].bConfigurationValue) < 0) { err("set_configuration failed"); goto reject; } if (usbdev->descriptor.idProduct == 0x2131) { dabusb_loadmem (s, NULL); goto reject; } else { dabusb_fpga_download (s, NULL); if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0) { err("set_interface failed"); goto reject; } } dbg("bound to interface: %d", ifnum); up (&s->mutex); MOD_INC_USE_COUNT; return s; reject: up (&s->mutex); s->usbdev = NULL; return NULL; } static void dabusb_disconnect (struct usb_device *usbdev, void *ptr) { pdabusb_t s = (pdabusb_t) ptr; dbg("dabusb_disconnect"); s->remove_pending = 1; wake_up (&s->wait); if (s->state == _started) sleep_on (&s->remove_ok); s->usbdev = NULL; s->overruns = 0; MOD_DEC_USE_COUNT; } static struct usb_device_id dabusb_ids [] = { { USB_DEVICE(0x0547, 0x2131) }, { USB_DEVICE(0x0547, 0x9999) }, { } /* Terminating entry */ }; MODULE_DEVICE_TABLE (usb, dabusb_ids); static struct usb_driver dabusb_driver = { name: "dabusb", probe: dabusb_probe, disconnect: dabusb_disconnect, fops: &dabusb_fops, minor: DABUSB_MINOR, id_table: dabusb_ids, }; /* --------------------------------------------------------------------- */ static int __init dabusb_init (void) { unsigned u; /* initialize struct */ for (u = 0; u < NRDABUSB; u++) { pdabusb_t s = &dabusb[u]; memset (s, 0, sizeof (dabusb_t)); init_MUTEX (&s->mutex); s->usbdev = NULL; s->total_buffer_size = buffers; init_waitqueue_head (&s->wait); init_waitqueue_head (&s->remove_ok); spin_lock_init (&s->lock); INIT_LIST_HEAD (&s->free_buff_list); INIT_LIST_HEAD (&s->rec_buff_list); } /* register misc device */ if (usb_register(&dabusb_driver)) return -1; dbg("dabusb_init: driver registered"); info(DRIVER_VERSION ":" DRIVER_DESC); return 0; } static void __exit dabusb_cleanup (void) { dbg("dabusb_cleanup"); usb_deregister (&dabusb_driver); } /* --------------------------------------------------------------------- */ MODULE_AUTHOR( DRIVER_AUTHOR ); MODULE_DESCRIPTION( DRIVER_DESC ); MODULE_LICENSE("GPL"); MODULE_PARM (buffers, "i"); MODULE_PARM_DESC (buffers, "Number of buffers (default=256)"); module_init (dabusb_init); module_exit (dabusb_cleanup); /* --------------------------------------------------------------------- */