1 /*****************************************************************************/
4 * dabusb.c -- dab usb driver.
6 * Copyright (C) 1999 Deti Fliegl (deti@fliegl.de)
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 * $Id: dabusb.c,v 1.54 2000/07/24 21:39:39 deti Exp $
28 /*****************************************************************************/
30 #include <linux/module.h>
31 #include <linux/socket.h>
32 #include <linux/list.h>
33 #include <linux/vmalloc.h>
34 #include <linux/slab.h>
35 #include <linux/init.h>
36 #include <asm/uaccess.h>
37 #include <asm/atomic.h>
38 #include <linux/delay.h>
39 #include <linux/usb.h>
40 #include <linux/smp_lock.h>
43 #include "dabfirmware.h"
48 #define DRIVER_VERSION "v1.54"
49 #define DRIVER_AUTHOR "Deti Fliegl, deti@fliegl.de"
50 #define DRIVER_DESC "DAB-USB Interface Driver for Linux (c)1999"
52 /* --------------------------------------------------------------------- */
54 #ifdef CONFIG_USB_DYNAMIC_MINORS
60 /*-------------------------------------------------------------------*/
62 static dabusb_t dabusb[NRDABUSB];
63 static int buffers = 256;
64 static struct usb_driver dabusb_driver;
66 /*-------------------------------------------------------------------*/
68 static int dabusb_add_buf_tail (pdabusb_t s, struct list_head *dst, struct list_head *src)
71 struct list_head *tmp;
74 spin_lock_irqsave (&s->lock, flags);
76 if (list_empty (src)) {
77 // no elements in source buffer
82 list_move_tail (tmp, dst);
84 err: spin_unlock_irqrestore (&s->lock, flags);
87 /*-------------------------------------------------------------------*/
89 static void dump_urb (struct urb *urb)
92 dbg("dev :%p", urb->dev);
93 dbg("pipe :%08X", urb->pipe);
94 dbg("status :%d", urb->status);
95 dbg("transfer_flags :%08X", urb->transfer_flags);
96 dbg("transfer_buffer :%p", urb->transfer_buffer);
97 dbg("transfer_buffer_length:%d", urb->transfer_buffer_length);
98 dbg("actual_length :%d", urb->actual_length);
99 dbg("setup_packet :%p", urb->setup_packet);
100 dbg("start_frame :%d", urb->start_frame);
101 dbg("number_of_packets :%d", urb->number_of_packets);
102 dbg("interval :%d", urb->interval);
103 dbg("error_count :%d", urb->error_count);
104 dbg("context :%p", urb->context);
105 dbg("complete :%p", urb->complete);
108 /*-------------------------------------------------------------------*/
109 static int dabusb_cancel_queue (pdabusb_t s, struct list_head *q)
114 dbg("dabusb_cancel_queue");
116 spin_lock_irqsave (&s->lock, flags);
118 list_for_each_entry(b, q, buff_list) {
122 usb_unlink_urb (b->purb);
124 spin_unlock_irqrestore (&s->lock, flags);
127 /*-------------------------------------------------------------------*/
128 static int dabusb_free_queue (struct list_head *q)
130 struct list_head *tmp;
134 dbg("dabusb_free_queue");
135 for (p = q->next; p != q;) {
136 b = list_entry (p, buff_t, buff_list);
141 if (b->purb->transfer_buffer)
142 kfree (b->purb->transfer_buffer);
143 usb_free_urb(b->purb);
152 /*-------------------------------------------------------------------*/
153 static int dabusb_free_buffers (pdabusb_t s)
156 dbg("dabusb_free_buffers");
158 spin_lock_irqsave(&s->lock, flags);
160 dabusb_free_queue (&s->free_buff_list);
161 dabusb_free_queue (&s->rec_buff_list);
163 spin_unlock_irqrestore(&s->lock, flags);
168 /*-------------------------------------------------------------------*/
169 static void dabusb_iso_complete (struct urb *purb, struct pt_regs *regs)
171 pbuff_t b = purb->context;
176 void *buf = purb->transfer_buffer;
178 dbg("dabusb_iso_complete");
180 // process if URB was not killed
181 if (purb->status != -ENOENT) {
182 unsigned int pipe = usb_rcvisocpipe (purb->dev, _DABUSB_ISOPIPE);
183 int pipesize = usb_maxpacket (purb->dev, pipe, usb_pipeout (pipe));
184 for (i = 0; i < purb->number_of_packets; i++)
185 if (!purb->iso_frame_desc[i].status) {
186 len = purb->iso_frame_desc[i].actual_length;
187 if (len <= pipesize) {
188 memcpy (buf + dst, buf + purb->iso_frame_desc[i].offset, len);
192 err("dabusb_iso_complete: invalid len %d", len);
195 warn("dabusb_iso_complete: corrupted packet status: %d", purb->iso_frame_desc[i].status);
196 if (dst != purb->actual_length)
197 err("dst!=purb->actual_length:%d!=%d", dst, purb->actual_length);
200 if (atomic_dec_and_test (&s->pending_io) && !s->remove_pending && s->state != _stopped) {
202 err("overrun (%d)", s->overruns);
206 /*-------------------------------------------------------------------*/
207 static int dabusb_alloc_buffers (pdabusb_t s)
211 unsigned int pipe = usb_rcvisocpipe (s->usbdev, _DABUSB_ISOPIPE);
212 int pipesize = usb_maxpacket (s->usbdev, pipe, usb_pipeout (pipe));
213 int packets = _ISOPIPESIZE / pipesize;
214 int transfer_buffer_length = packets * pipesize;
217 dbg("dabusb_alloc_buffers pipesize:%d packets:%d transfer_buffer_len:%d",
218 pipesize, packets, transfer_buffer_length);
220 while (buffers < (s->total_buffer_size << 10)) {
221 b = (pbuff_t) kmalloc (sizeof (buff_t), GFP_KERNEL);
223 err("kmalloc(sizeof(buff_t))==NULL");
226 memset (b, 0, sizeof (buff_t));
228 b->purb = usb_alloc_urb(packets, GFP_KERNEL);
230 err("usb_alloc_urb == NULL");
235 b->purb->transfer_buffer = kmalloc (transfer_buffer_length, GFP_KERNEL);
236 if (!b->purb->transfer_buffer) {
239 err("kmalloc(%d)==NULL", transfer_buffer_length);
243 b->purb->transfer_buffer_length = transfer_buffer_length;
244 b->purb->number_of_packets = packets;
245 b->purb->complete = dabusb_iso_complete;
246 b->purb->context = b;
247 b->purb->dev = s->usbdev;
248 b->purb->pipe = pipe;
249 b->purb->transfer_flags = URB_ISO_ASAP;
251 for (i = 0; i < packets; i++) {
252 b->purb->iso_frame_desc[i].offset = i * pipesize;
253 b->purb->iso_frame_desc[i].length = pipesize;
256 buffers += transfer_buffer_length;
257 list_add_tail (&b->buff_list, &s->free_buff_list);
259 s->got_mem = buffers;
264 dabusb_free_buffers (s);
267 /*-------------------------------------------------------------------*/
268 static int dabusb_bulk (pdabusb_t s, pbulk_transfer_t pb)
277 pipe = usb_rcvbulkpipe (s->usbdev, 2);
279 pipe = usb_sndbulkpipe (s->usbdev, 2);
281 ret=usb_bulk_msg(s->usbdev, pipe, pb->data, pb->size, &actual_length, 100);
283 err("dabusb: usb_bulk_msg failed(%d)",ret);
285 if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
286 err("set_interface failed");
292 if( ret == -EPIPE ) {
293 warn("CLEAR_FEATURE request to remove STALL condition.");
294 if(usb_clear_halt(s->usbdev, usb_pipeendpoint(pipe)))
295 err("request failed");
298 pb->size = actual_length;
301 /* --------------------------------------------------------------------- */
302 static int dabusb_writemem (pdabusb_t s, int pos, unsigned char *data, int len)
305 unsigned char *transfer_buffer = kmalloc (len, GFP_KERNEL);
307 if (!transfer_buffer) {
308 err("dabusb_writemem: kmalloc(%d) failed.", len);
312 memcpy (transfer_buffer, data, len);
314 ret=usb_control_msg(s->usbdev, usb_sndctrlpipe( s->usbdev, 0 ), 0xa0, 0x40, pos, 0, transfer_buffer, len, 300);
316 kfree (transfer_buffer);
319 /* --------------------------------------------------------------------- */
320 static int dabusb_8051_reset (pdabusb_t s, unsigned char reset_bit)
322 dbg("dabusb_8051_reset: %d",reset_bit);
323 return dabusb_writemem (s, CPUCS_REG, &reset_bit, 1);
325 /* --------------------------------------------------------------------- */
326 static int dabusb_loadmem (pdabusb_t s, const char *fname)
329 PINTEL_HEX_RECORD ptr = firmware;
331 dbg("Enter dabusb_loadmem (internal)");
333 ret = dabusb_8051_reset (s, 1);
334 while (ptr->Type == 0) {
336 dbg("dabusb_writemem: %04X %p %d)", ptr->Address, ptr->Data, ptr->Length);
338 ret = dabusb_writemem (s, ptr->Address, ptr->Data, ptr->Length);
340 err("dabusb_writemem failed (%d %04X %p %d)", ret, ptr->Address, ptr->Data, ptr->Length);
345 ret = dabusb_8051_reset (s, 0);
347 dbg("dabusb_loadmem: exit");
351 /* --------------------------------------------------------------------- */
352 static int dabusb_fpga_clear (pdabusb_t s, pbulk_transfer_t b)
360 dbg("dabusb_fpga_clear");
362 return dabusb_bulk (s, b);
364 /* --------------------------------------------------------------------- */
365 static int dabusb_fpga_init (pdabusb_t s, pbulk_transfer_t b)
373 dbg("dabusb_fpga_init");
375 return dabusb_bulk (s, b);
377 /* --------------------------------------------------------------------- */
378 static int dabusb_fpga_download (pdabusb_t s, const char *fname)
380 pbulk_transfer_t b = kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
381 unsigned int blen, n;
383 unsigned char *buf = bitstream;
385 dbg("Enter dabusb_fpga_download (internal)");
388 err("kmalloc(sizeof(bulk_transfer_t))==NULL");
393 ret = dabusb_fpga_clear (s, b);
395 blen = buf[73] + (buf[72] << 8);
397 dbg("Bitstream len: %i", blen);
404 for (n = 0; n <= blen + 60; n += 60) {
405 // some cclks for startup
407 memcpy (b->data + 4, buf + 74 + n, 60);
408 ret = dabusb_bulk (s, b);
410 err("dabusb_bulk failed.");
416 ret = dabusb_fpga_init (s, b);
419 dbg("exit dabusb_fpga_download");
424 static int dabusb_stop (pdabusb_t s)
429 dabusb_cancel_queue (s, &s->rec_buff_list);
431 dbg("pending_io: %d", s->pending_io.counter);
433 s->pending_io.counter = 0;
437 static int dabusb_startrek (pdabusb_t s)
439 if (!s->got_mem && s->state != _started) {
441 dbg("dabusb_startrek");
443 if (dabusb_alloc_buffers (s) < 0)
450 if (!list_empty (&s->free_buff_list)) {
454 while (!dabusb_add_buf_tail (s, &s->rec_buff_list, &s->free_buff_list)) {
456 dbg("submitting: end:%p s->rec_buff_list:%p", s->rec_buff_list.prev, &s->rec_buff_list);
458 end = list_entry (s->rec_buff_list.prev, buff_t, buff_list);
460 ret = usb_submit_urb (end->purb, GFP_KERNEL);
462 err("usb_submit_urb returned:%d", ret);
463 if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
464 err("startrek: dabusb_add_buf_tail failed");
468 atomic_inc (&s->pending_io);
470 dbg("pending_io: %d",s->pending_io.counter);
476 static ssize_t dabusb_read (struct file *file, char __user *buf, size_t count, loff_t * ppos)
478 pdabusb_t s = (pdabusb_t) file->private_data;
484 struct urb *purb = NULL;
491 if (s->remove_pending)
501 spin_lock_irqsave (&s->lock, flags);
503 if (list_empty (&s->rec_buff_list)) {
505 spin_unlock_irqrestore(&s->lock, flags);
507 err("error: rec_buf_list is empty");
511 b = list_entry (s->rec_buff_list.next, buff_t, buff_list);
514 spin_unlock_irqrestore(&s->lock, flags);
516 if (purb->status == -EINPROGRESS) {
517 if (file->f_flags & O_NONBLOCK) // return nonblocking
524 interruptible_sleep_on (&s->wait);
526 if (signal_pending (current)) {
532 spin_lock_irqsave (&s->lock, flags);
534 if (list_empty (&s->rec_buff_list)) {
535 spin_unlock_irqrestore(&s->lock, flags);
536 err("error: still no buffer available.");
539 spin_unlock_irqrestore(&s->lock, flags);
542 if (s->remove_pending) {
547 rem = purb->actual_length - s->readptr; // set remaining bytes to copy
554 dbg("copy_to_user:%p %p %d",buf, purb->transfer_buffer + s->readptr, cnt);
556 if (copy_to_user (buf, purb->transfer_buffer + s->readptr, cnt)) {
557 err("read: copy_to_user failed");
568 if (s->readptr == purb->actual_length) {
569 // finished, take next buffer
570 if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
571 err("read: dabusb_add_buf_tail failed");
575 err: //up(&s->mutex);
579 static int dabusb_open (struct inode *inode, struct file *file)
581 int devnum = iminor(inode);
584 if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB))
587 s = &dabusb[devnum - DABUSB_MINOR];
592 while (!s->usbdev || s->opened) {
595 if (file->f_flags & O_NONBLOCK) {
598 msleep_interruptible(500);
600 if (signal_pending (current)) {
605 if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
607 err("set_interface failed");
614 file->private_data = s;
616 return nonseekable_open(inode, file);
619 static int dabusb_release (struct inode *inode, struct file *file)
621 pdabusb_t s = (pdabusb_t) file->private_data;
623 dbg("dabusb_release");
627 dabusb_free_buffers (s);
630 if (!s->remove_pending) {
631 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0)
632 err("set_interface failed");
635 wake_up (&s->remove_ok);
641 static int dabusb_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
643 pdabusb_t s = (pdabusb_t) file->private_data;
644 pbulk_transfer_t pbulk;
646 int version = DABUSB_VERSION;
650 if (s->remove_pending)
663 pbulk = (pbulk_transfer_t) kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
670 if (copy_from_user (pbulk, (void __user *) arg, sizeof (bulk_transfer_t))) {
676 ret=dabusb_bulk (s, pbulk);
678 if (copy_to_user((void __user *)arg, pbulk,
679 sizeof(bulk_transfer_t)))
684 case IOCTL_DAB_OVERRUNS:
685 ret = put_user (s->overruns, (unsigned int __user *) arg);
688 case IOCTL_DAB_VERSION:
689 ret = put_user (version, (unsigned int __user *) arg);
700 static struct file_operations dabusb_fops =
702 .owner = THIS_MODULE,
705 .ioctl = dabusb_ioctl,
707 .release = dabusb_release,
710 static struct usb_class_driver dabusb_class = {
711 .name = "usb/dabusb%d",
712 .fops = &dabusb_fops,
713 .mode = S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
714 .minor_base = DABUSB_MINOR,
718 /* --------------------------------------------------------------------- */
719 static int dabusb_probe (struct usb_interface *intf,
720 const struct usb_device_id *id)
722 struct usb_device *usbdev = interface_to_usbdev(intf);
726 dbg("dabusb: probe: vendor id 0x%x, device id 0x%x ifnum:%d",
727 le16_to_cpu(usbdev->descriptor.idVendor),
728 le16_to_cpu(usbdev->descriptor.idProduct),
729 intf->altsetting->desc.bInterfaceNumber);
731 /* We don't handle multiple configurations */
732 if (usbdev->descriptor.bNumConfigurations != 1)
735 if (intf->altsetting->desc.bInterfaceNumber != _DABUSB_IF &&
736 le16_to_cpu(usbdev->descriptor.idProduct) == 0x9999)
741 s = &dabusb[intf->minor];
744 s->remove_pending = 0;
746 s->devnum = intf->minor;
748 if (usb_reset_configuration (usbdev) < 0) {
749 err("reset_configuration failed");
752 if (le16_to_cpu(usbdev->descriptor.idProduct) == 0x2131) {
753 dabusb_loadmem (s, NULL);
757 dabusb_fpga_download (s, NULL);
759 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0) {
760 err("set_interface failed");
764 dbg("bound to interface: %d", intf->altsetting->desc.bInterfaceNumber);
765 usb_set_intfdata (intf, s);
768 retval = usb_register_dev(intf, &dabusb_class);
770 usb_set_intfdata (intf, NULL);
782 static void dabusb_disconnect (struct usb_interface *intf)
785 pdabusb_t s = usb_get_intfdata (intf);
787 dbg("dabusb_disconnect");
789 init_waitqueue_entry(&__wait, current);
791 usb_set_intfdata (intf, NULL);
793 usb_deregister_dev (intf, &dabusb_class);
794 s->remove_pending = 1;
796 add_wait_queue(&s->remove_ok, &__wait);
797 set_current_state(TASK_UNINTERRUPTIBLE);
798 if (s->state == _started)
800 current->state = TASK_RUNNING;
801 remove_wait_queue(&s->remove_ok, &__wait);
808 static struct usb_device_id dabusb_ids [] = {
809 // { USB_DEVICE(0x0547, 0x2131) }, /* An2131 chip, no boot ROM */
810 { USB_DEVICE(0x0547, 0x9999) },
811 { } /* Terminating entry */
814 MODULE_DEVICE_TABLE (usb, dabusb_ids);
816 static struct usb_driver dabusb_driver = {
817 .owner = THIS_MODULE,
819 .probe = dabusb_probe,
820 .disconnect = dabusb_disconnect,
821 .id_table = dabusb_ids,
824 /* --------------------------------------------------------------------- */
826 static int __init dabusb_init (void)
831 /* initialize struct */
832 for (u = 0; u < NRDABUSB; u++) {
833 pdabusb_t s = &dabusb[u];
834 memset (s, 0, sizeof (dabusb_t));
835 init_MUTEX (&s->mutex);
837 s->total_buffer_size = buffers;
838 init_waitqueue_head (&s->wait);
839 init_waitqueue_head (&s->remove_ok);
840 spin_lock_init (&s->lock);
841 INIT_LIST_HEAD (&s->free_buff_list);
842 INIT_LIST_HEAD (&s->rec_buff_list);
845 /* register misc device */
846 retval = usb_register(&dabusb_driver);
850 dbg("dabusb_init: driver registered");
852 info(DRIVER_VERSION ":" DRIVER_DESC);
858 static void __exit dabusb_cleanup (void)
860 dbg("dabusb_cleanup");
862 usb_deregister (&dabusb_driver);
865 /* --------------------------------------------------------------------- */
867 MODULE_AUTHOR( DRIVER_AUTHOR );
868 MODULE_DESCRIPTION( DRIVER_DESC );
869 MODULE_LICENSE("GPL");
871 module_param(buffers, int, 0);
872 MODULE_PARM_DESC (buffers, "Number of buffers (default=256)");
874 module_init (dabusb_init);
875 module_exit (dabusb_cleanup);
877 /* --------------------------------------------------------------------- */