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 /* --------------------------------------------------------------------- */