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/mutex.h>
41 #include <linux/firmware.h>
42 #include <linux/ihex.h>
49 #define DRIVER_VERSION "v1.54"
50 #define DRIVER_AUTHOR "Deti Fliegl, deti@fliegl.de"
51 #define DRIVER_DESC "DAB-USB Interface Driver for Linux (c)1999"
53 /* --------------------------------------------------------------------- */
55 #ifdef CONFIG_USB_DYNAMIC_MINORS
61 /*-------------------------------------------------------------------*/
63 static dabusb_t dabusb
[NRDABUSB
];
64 static int buffers
= 256;
65 static struct usb_driver dabusb_driver
;
67 /*-------------------------------------------------------------------*/
69 static int dabusb_add_buf_tail (pdabusb_t s
, struct list_head
*dst
, struct list_head
*src
)
72 struct list_head
*tmp
;
75 spin_lock_irqsave (&s
->lock
, flags
);
77 if (list_empty (src
)) {
78 // no elements in source buffer
83 list_move_tail (tmp
, dst
);
85 err
: spin_unlock_irqrestore (&s
->lock
, flags
);
88 /*-------------------------------------------------------------------*/
90 static void dump_urb (struct urb
*urb
)
93 dbg("dev :%p", urb
->dev
);
94 dbg("pipe :%08X", urb
->pipe
);
95 dbg("status :%d", urb
->status
);
96 dbg("transfer_flags :%08X", urb
->transfer_flags
);
97 dbg("transfer_buffer :%p", urb
->transfer_buffer
);
98 dbg("transfer_buffer_length:%d", urb
->transfer_buffer_length
);
99 dbg("actual_length :%d", urb
->actual_length
);
100 dbg("setup_packet :%p", urb
->setup_packet
);
101 dbg("start_frame :%d", urb
->start_frame
);
102 dbg("number_of_packets :%d", urb
->number_of_packets
);
103 dbg("interval :%d", urb
->interval
);
104 dbg("error_count :%d", urb
->error_count
);
105 dbg("context :%p", urb
->context
);
106 dbg("complete :%p", urb
->complete
);
109 /*-------------------------------------------------------------------*/
110 static int dabusb_cancel_queue (pdabusb_t s
, struct list_head
*q
)
115 dbg("dabusb_cancel_queue");
117 spin_lock_irqsave (&s
->lock
, flags
);
119 list_for_each_entry(b
, q
, buff_list
) {
123 usb_unlink_urb (b
->purb
);
125 spin_unlock_irqrestore (&s
->lock
, flags
);
128 /*-------------------------------------------------------------------*/
129 static int dabusb_free_queue (struct list_head
*q
)
131 struct list_head
*tmp
;
135 dbg("dabusb_free_queue");
136 for (p
= q
->next
; p
!= q
;) {
137 b
= list_entry (p
, buff_t
, buff_list
);
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
)
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
)
209 int transfer_len
= 0;
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 (transfer_len
< (s
->total_buffer_size
<< 10)) {
221 b
= kzalloc(sizeof (buff_t
), GFP_KERNEL
);
223 err("kzalloc(sizeof(buff_t))==NULL");
227 b
->purb
= usb_alloc_urb(packets
, GFP_KERNEL
);
229 err("usb_alloc_urb == NULL");
234 b
->purb
->transfer_buffer
= kmalloc (transfer_buffer_length
, GFP_KERNEL
);
235 if (!b
->purb
->transfer_buffer
) {
238 err("kmalloc(%d)==NULL", transfer_buffer_length
);
242 b
->purb
->transfer_buffer_length
= transfer_buffer_length
;
243 b
->purb
->number_of_packets
= packets
;
244 b
->purb
->complete
= dabusb_iso_complete
;
245 b
->purb
->context
= b
;
246 b
->purb
->dev
= s
->usbdev
;
247 b
->purb
->pipe
= pipe
;
248 b
->purb
->transfer_flags
= URB_ISO_ASAP
;
250 for (i
= 0; i
< packets
; i
++) {
251 b
->purb
->iso_frame_desc
[i
].offset
= i
* pipesize
;
252 b
->purb
->iso_frame_desc
[i
].length
= pipesize
;
255 transfer_len
+= transfer_buffer_length
;
256 list_add_tail (&b
->buff_list
, &s
->free_buff_list
);
258 s
->got_mem
= transfer_len
;
263 dabusb_free_buffers (s
);
266 /*-------------------------------------------------------------------*/
267 static int dabusb_bulk (pdabusb_t s
, pbulk_transfer_t pb
)
276 pipe
= usb_rcvbulkpipe (s
->usbdev
, 2);
278 pipe
= usb_sndbulkpipe (s
->usbdev
, 2);
280 ret
=usb_bulk_msg(s
->usbdev
, pipe
, pb
->data
, pb
->size
, &actual_length
, 100);
282 err("dabusb: usb_bulk_msg failed(%d)",ret
);
284 if (usb_set_interface (s
->usbdev
, _DABUSB_IF
, 1) < 0) {
285 err("set_interface failed");
291 if( ret
== -EPIPE
) {
292 warn("CLEAR_FEATURE request to remove STALL condition.");
293 if(usb_clear_halt(s
->usbdev
, usb_pipeendpoint(pipe
)))
294 err("request failed");
297 pb
->size
= actual_length
;
300 /* --------------------------------------------------------------------- */
301 static int dabusb_writemem (pdabusb_t s
, int pos
, const unsigned char *data
,
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 const struct ihex_binrec
*rec
;
330 const struct firmware
*fw
;
332 dbg("Enter dabusb_loadmem (internal)");
334 ret
= request_ihex_firmware(&fw
, "dabusb/firmware.fw", &s
->usbdev
->dev
);
336 err("Failed to load \"dabusb/firmware.fw\": %d\n", ret
);
339 ret
= dabusb_8051_reset (s
, 1);
341 for (rec
= (const struct ihex_binrec
*)fw
->data
; rec
;
342 rec
= ihex_next_binrec(rec
)) {
343 dbg("dabusb_writemem: %04X %p %d)", be32_to_cpu(rec
->addr
),
344 rec
->data
, be16_to_cpu(rec
->len
));
346 ret
= dabusb_writemem(s
, be32_to_cpu(rec
->addr
), rec
->data
,
347 be16_to_cpu(rec
->len
));
349 err("dabusb_writemem failed (%d %04X %p %d)", ret
,
350 be32_to_cpu(rec
->addr
), rec
->data
,
351 be16_to_cpu(rec
->len
));
355 ret
= dabusb_8051_reset (s
, 0);
356 release_firmware(fw
);
358 dbg("dabusb_loadmem: exit");
362 /* --------------------------------------------------------------------- */
363 static int dabusb_fpga_clear (pdabusb_t s
, pbulk_transfer_t b
)
371 dbg("dabusb_fpga_clear");
373 return dabusb_bulk (s
, b
);
375 /* --------------------------------------------------------------------- */
376 static int dabusb_fpga_init (pdabusb_t s
, pbulk_transfer_t b
)
384 dbg("dabusb_fpga_init");
386 return dabusb_bulk (s
, b
);
388 /* --------------------------------------------------------------------- */
389 static int dabusb_fpga_download (pdabusb_t s
, const char *fname
)
391 pbulk_transfer_t b
= kmalloc (sizeof (bulk_transfer_t
), GFP_KERNEL
);
392 const struct firmware
*fw
;
393 unsigned int blen
, n
;
396 dbg("Enter dabusb_fpga_download (internal)");
399 err("kmalloc(sizeof(bulk_transfer_t))==NULL");
403 ret
= request_firmware(&fw
, "dabusb/bitstream.bin", &s
->usbdev
->dev
);
405 err("Failed to load \"dabusb/bitstream.bin\": %d\n", ret
);
410 ret
= dabusb_fpga_clear (s
, b
);
412 blen
= fw
->data
[73] + (fw
->data
[72] << 8);
414 dbg("Bitstream len: %i", blen
);
421 for (n
= 0; n
<= blen
+ 60; n
+= 60) {
422 // some cclks for startup
424 memcpy (b
->data
+ 4, fw
->data
+ 74 + n
, 60);
425 ret
= dabusb_bulk (s
, b
);
427 err("dabusb_bulk failed.");
433 ret
= dabusb_fpga_init (s
, b
);
435 release_firmware(fw
);
437 dbg("exit dabusb_fpga_download");
442 static int dabusb_stop (pdabusb_t s
)
447 dabusb_cancel_queue (s
, &s
->rec_buff_list
);
449 dbg("pending_io: %d", s
->pending_io
.counter
);
451 s
->pending_io
.counter
= 0;
455 static int dabusb_startrek (pdabusb_t s
)
457 if (!s
->got_mem
&& s
->state
!= _started
) {
459 dbg("dabusb_startrek");
461 if (dabusb_alloc_buffers (s
) < 0)
468 if (!list_empty (&s
->free_buff_list
)) {
472 while (!dabusb_add_buf_tail (s
, &s
->rec_buff_list
, &s
->free_buff_list
)) {
474 dbg("submitting: end:%p s->rec_buff_list:%p", s
->rec_buff_list
.prev
, &s
->rec_buff_list
);
476 end
= list_entry (s
->rec_buff_list
.prev
, buff_t
, buff_list
);
478 ret
= usb_submit_urb (end
->purb
, GFP_KERNEL
);
480 err("usb_submit_urb returned:%d", ret
);
481 if (dabusb_add_buf_tail (s
, &s
->free_buff_list
, &s
->rec_buff_list
))
482 err("startrek: dabusb_add_buf_tail failed");
486 atomic_inc (&s
->pending_io
);
488 dbg("pending_io: %d",s
->pending_io
.counter
);
494 static ssize_t
dabusb_read (struct file
*file
, char __user
*buf
, size_t count
, loff_t
* ppos
)
496 pdabusb_t s
= (pdabusb_t
) file
->private_data
;
502 struct urb
*purb
= NULL
;
509 if (s
->remove_pending
)
519 spin_lock_irqsave (&s
->lock
, flags
);
521 if (list_empty (&s
->rec_buff_list
)) {
523 spin_unlock_irqrestore(&s
->lock
, flags
);
525 err("error: rec_buf_list is empty");
529 b
= list_entry (s
->rec_buff_list
.next
, buff_t
, buff_list
);
532 spin_unlock_irqrestore(&s
->lock
, flags
);
534 if (purb
->status
== -EINPROGRESS
) {
535 if (file
->f_flags
& O_NONBLOCK
) // return nonblocking
542 interruptible_sleep_on (&s
->wait
);
544 if (signal_pending (current
)) {
550 spin_lock_irqsave (&s
->lock
, flags
);
552 if (list_empty (&s
->rec_buff_list
)) {
553 spin_unlock_irqrestore(&s
->lock
, flags
);
554 err("error: still no buffer available.");
557 spin_unlock_irqrestore(&s
->lock
, flags
);
560 if (s
->remove_pending
) {
565 rem
= purb
->actual_length
- s
->readptr
; // set remaining bytes to copy
572 dbg("copy_to_user:%p %p %d",buf
, purb
->transfer_buffer
+ s
->readptr
, cnt
);
574 if (copy_to_user (buf
, purb
->transfer_buffer
+ s
->readptr
, cnt
)) {
575 err("read: copy_to_user failed");
586 if (s
->readptr
== purb
->actual_length
) {
587 // finished, take next buffer
588 if (dabusb_add_buf_tail (s
, &s
->free_buff_list
, &s
->rec_buff_list
))
589 err("read: dabusb_add_buf_tail failed");
593 err
: //mutex_unlock(&s->mutex);
597 static int dabusb_open (struct inode
*inode
, struct file
*file
)
599 int devnum
= iminor(inode
);
602 if (devnum
< DABUSB_MINOR
|| devnum
>= (DABUSB_MINOR
+ NRDABUSB
))
605 s
= &dabusb
[devnum
- DABUSB_MINOR
];
608 mutex_lock(&s
->mutex
);
610 while (!s
->usbdev
|| s
->opened
) {
611 mutex_unlock(&s
->mutex
);
613 if (file
->f_flags
& O_NONBLOCK
) {
616 msleep_interruptible(500);
618 if (signal_pending (current
)) {
621 mutex_lock(&s
->mutex
);
623 if (usb_set_interface (s
->usbdev
, _DABUSB_IF
, 1) < 0) {
624 mutex_unlock(&s
->mutex
);
625 err("set_interface failed");
629 mutex_unlock(&s
->mutex
);
632 file
->private_data
= s
;
634 return nonseekable_open(inode
, file
);
637 static int dabusb_release (struct inode
*inode
, struct file
*file
)
639 pdabusb_t s
= (pdabusb_t
) file
->private_data
;
641 dbg("dabusb_release");
643 mutex_lock(&s
->mutex
);
645 dabusb_free_buffers (s
);
646 mutex_unlock(&s
->mutex
);
648 if (!s
->remove_pending
) {
649 if (usb_set_interface (s
->usbdev
, _DABUSB_IF
, 0) < 0)
650 err("set_interface failed");
653 wake_up (&s
->remove_ok
);
659 static int dabusb_ioctl (struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
661 pdabusb_t s
= (pdabusb_t
) file
->private_data
;
662 pbulk_transfer_t pbulk
;
664 int version
= DABUSB_VERSION
;
668 if (s
->remove_pending
)
671 mutex_lock(&s
->mutex
);
674 mutex_unlock(&s
->mutex
);
681 pbulk
= kmalloc(sizeof (bulk_transfer_t
), GFP_KERNEL
);
688 if (copy_from_user (pbulk
, (void __user
*) arg
, sizeof (bulk_transfer_t
))) {
694 ret
=dabusb_bulk (s
, pbulk
);
696 if (copy_to_user((void __user
*)arg
, pbulk
,
697 sizeof(bulk_transfer_t
)))
702 case IOCTL_DAB_OVERRUNS
:
703 ret
= put_user (s
->overruns
, (unsigned int __user
*) arg
);
706 case IOCTL_DAB_VERSION
:
707 ret
= put_user (version
, (unsigned int __user
*) arg
);
714 mutex_unlock(&s
->mutex
);
718 static const struct file_operations dabusb_fops
=
720 .owner
= THIS_MODULE
,
723 .ioctl
= dabusb_ioctl
,
725 .release
= dabusb_release
,
728 static struct usb_class_driver dabusb_class
= {
730 .fops
= &dabusb_fops
,
731 .minor_base
= DABUSB_MINOR
,
735 /* --------------------------------------------------------------------- */
736 static int dabusb_probe (struct usb_interface
*intf
,
737 const struct usb_device_id
*id
)
739 struct usb_device
*usbdev
= interface_to_usbdev(intf
);
743 dbg("dabusb: probe: vendor id 0x%x, device id 0x%x ifnum:%d",
744 le16_to_cpu(usbdev
->descriptor
.idVendor
),
745 le16_to_cpu(usbdev
->descriptor
.idProduct
),
746 intf
->altsetting
->desc
.bInterfaceNumber
);
748 /* We don't handle multiple configurations */
749 if (usbdev
->descriptor
.bNumConfigurations
!= 1)
752 if (intf
->altsetting
->desc
.bInterfaceNumber
!= _DABUSB_IF
&&
753 le16_to_cpu(usbdev
->descriptor
.idProduct
) == 0x9999)
758 s
= &dabusb
[intf
->minor
];
760 mutex_lock(&s
->mutex
);
761 s
->remove_pending
= 0;
763 s
->devnum
= intf
->minor
;
765 if (usb_reset_configuration (usbdev
) < 0) {
766 err("reset_configuration failed");
769 if (le16_to_cpu(usbdev
->descriptor
.idProduct
) == 0x2131) {
770 dabusb_loadmem (s
, NULL
);
774 dabusb_fpga_download (s
, NULL
);
776 if (usb_set_interface (s
->usbdev
, _DABUSB_IF
, 0) < 0) {
777 err("set_interface failed");
781 dbg("bound to interface: %d", intf
->altsetting
->desc
.bInterfaceNumber
);
782 usb_set_intfdata (intf
, s
);
783 mutex_unlock(&s
->mutex
);
785 retval
= usb_register_dev(intf
, &dabusb_class
);
787 usb_set_intfdata (intf
, NULL
);
794 mutex_unlock(&s
->mutex
);
799 static void dabusb_disconnect (struct usb_interface
*intf
)
802 pdabusb_t s
= usb_get_intfdata (intf
);
804 dbg("dabusb_disconnect");
806 init_waitqueue_entry(&__wait
, current
);
808 usb_set_intfdata (intf
, NULL
);
810 usb_deregister_dev (intf
, &dabusb_class
);
811 s
->remove_pending
= 1;
813 add_wait_queue(&s
->remove_ok
, &__wait
);
814 set_current_state(TASK_UNINTERRUPTIBLE
);
815 if (s
->state
== _started
)
817 current
->state
= TASK_RUNNING
;
818 remove_wait_queue(&s
->remove_ok
, &__wait
);
825 static struct usb_device_id dabusb_ids
[] = {
826 // { USB_DEVICE(0x0547, 0x2131) }, /* An2131 chip, no boot ROM */
827 { USB_DEVICE(0x0547, 0x9999) },
828 { } /* Terminating entry */
831 MODULE_DEVICE_TABLE (usb
, dabusb_ids
);
833 static struct usb_driver dabusb_driver
= {
835 .probe
= dabusb_probe
,
836 .disconnect
= dabusb_disconnect
,
837 .id_table
= dabusb_ids
,
840 /* --------------------------------------------------------------------- */
842 static int __init
dabusb_init (void)
847 /* initialize struct */
848 for (u
= 0; u
< NRDABUSB
; u
++) {
849 pdabusb_t s
= &dabusb
[u
];
850 memset (s
, 0, sizeof (dabusb_t
));
851 mutex_init (&s
->mutex
);
853 s
->total_buffer_size
= buffers
;
854 init_waitqueue_head (&s
->wait
);
855 init_waitqueue_head (&s
->remove_ok
);
856 spin_lock_init (&s
->lock
);
857 INIT_LIST_HEAD (&s
->free_buff_list
);
858 INIT_LIST_HEAD (&s
->rec_buff_list
);
861 /* register misc device */
862 retval
= usb_register(&dabusb_driver
);
866 dbg("dabusb_init: driver registered");
868 info(DRIVER_VERSION
":" DRIVER_DESC
);
874 static void __exit
dabusb_cleanup (void)
876 dbg("dabusb_cleanup");
878 usb_deregister (&dabusb_driver
);
881 /* --------------------------------------------------------------------- */
883 MODULE_AUTHOR( DRIVER_AUTHOR
);
884 MODULE_DESCRIPTION( DRIVER_DESC
);
885 MODULE_LICENSE("GPL");
887 module_param(buffers
, int, 0);
888 MODULE_PARM_DESC (buffers
, "Number of buffers (default=256)");
890 module_init (dabusb_init
);
891 module_exit (dabusb_cleanup
);
893 /* --------------------------------------------------------------------- */