1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30#include <linux/module.h>
31#include <linux/socket.h>
32#include <linux/miscdevice.h>
33#include <linux/list.h>
34#include <linux/vmalloc.h>
35#include <linux/slab.h>
36#include <linux/init.h>
37#include <asm/uaccess.h>
38#include <asm/atomic.h>
39#include <linux/delay.h>
40#include <linux/usb.h>
41#include <linux/smp_lock.h>
42
43#include "dabusb.h"
44#include "dabfirmware.h"
45
46
47
48
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"
52
53
54
55#define NRDABUSB 4
56
57
58
59static dabusb_t dabusb[NRDABUSB];
60static int buffers = 256;
61
62
63
64static int dabusb_add_buf_tail (pdabusb_t s, struct list_head *dst, struct list_head *src)
65{
66 unsigned long flags;
67 struct list_head *tmp;
68 int ret = 0;
69
70 spin_lock_irqsave (&s->lock, flags);
71
72 if (list_empty (src)) {
73
74 ret = -1;
75 goto err;
76 }
77 tmp = src->next;
78 list_del (tmp);
79 list_add_tail (tmp, dst);
80
81 err: spin_unlock_irqrestore (&s->lock, flags);
82 return ret;
83}
84
85#ifdef DEBUG
86static void dump_urb (struct urb *purb)
87{
88 dbg("urb :%p", purb);
89 dbg("next :%p", purb->next);
90 dbg("dev :%p", purb->dev);
91 dbg("pipe :%08X", purb->pipe);
92 dbg("status :%d", purb->status);
93 dbg("transfer_flags :%08X", purb->transfer_flags);
94 dbg("transfer_buffer :%p", purb->transfer_buffer);
95 dbg("transfer_buffer_length:%d", purb->transfer_buffer_length);
96 dbg("actual_length :%d", purb->actual_length);
97 dbg("setup_packet :%p", purb->setup_packet);
98 dbg("start_frame :%d", purb->start_frame);
99 dbg("number_of_packets :%d", purb->number_of_packets);
100 dbg("interval :%d", purb->interval);
101 dbg("error_count :%d", purb->error_count);
102 dbg("context :%p", purb->context);
103 dbg("complete :%p", purb->complete);
104}
105#endif
106
107static int dabusb_cancel_queue (pdabusb_t s, struct list_head *q)
108{
109 unsigned long flags;
110 struct list_head *p;
111 pbuff_t b;
112
113 dbg("dabusb_cancel_queue");
114
115 spin_lock_irqsave (&s->lock, flags);
116
117 for (p = q->next; p != q; p = p->next) {
118 b = list_entry (p, buff_t, buff_list);
119
120#ifdef DEBUG
121 dump_urb(b->purb);
122#endif
123 usb_unlink_urb (b->purb);
124 }
125 spin_unlock_irqrestore (&s->lock, flags);
126 return 0;
127}
128
129static int dabusb_free_queue (struct list_head *q)
130{
131 struct list_head *tmp;
132 struct list_head *p;
133 pbuff_t b;
134
135 dbg("dabusb_free_queue");
136 for (p = q->next; p != q;) {
137 b = list_entry (p, buff_t, buff_list);
138
139#ifdef DEBUG
140 dump_urb(b->purb);
141#endif
142 if (b->purb->transfer_buffer)
143 kfree (b->purb->transfer_buffer);
144 usb_free_urb(b->purb);
145 tmp = p->next;
146 list_del (p);
147 kfree (b);
148 p = tmp;
149 }
150
151 return 0;
152}
153
154static int dabusb_free_buffers (pdabusb_t s)
155{
156 unsigned long flags;
157 dbg("dabusb_free_buffers");
158
159 spin_lock_irqsave(&s->lock, flags);
160
161 dabusb_free_queue (&s->free_buff_list);
162 dabusb_free_queue (&s->rec_buff_list);
163
164 spin_unlock_irqrestore(&s->lock, flags);
165
166 s->got_mem = 0;
167 return 0;
168}
169
170static void dabusb_iso_complete (struct urb *purb)
171{
172 pbuff_t b = purb->context;
173 pdabusb_t s = b->s;
174 int i;
175 int len;
176 int dst = 0;
177 void *buf = purb->transfer_buffer;
178
179 dbg("dabusb_iso_complete");
180
181
182 if (purb->status != -ENOENT) {
183 unsigned int pipe = usb_rcvisocpipe (purb->dev, _DABUSB_ISOPIPE);
184 int pipesize = usb_maxpacket (purb->dev, pipe, usb_pipeout (pipe));
185 for (i = 0; i < purb->number_of_packets; i++)
186 if (!purb->iso_frame_desc[i].status) {
187 len = purb->iso_frame_desc[i].actual_length;
188 if (len <= pipesize) {
189 memcpy (buf + dst, buf + purb->iso_frame_desc[i].offset, len);
190 dst += len;
191 }
192 else
193 err("dabusb_iso_complete: invalid len %d", len);
194 }
195 else
196 warn("dabusb_iso_complete: corrupted packet status: %d", purb->iso_frame_desc[i].status);
197 if (dst != purb->actual_length)
198 err("dst!=purb->actual_length:%d!=%d", dst, purb->actual_length);
199 }
200
201 if (atomic_dec_and_test (&s->pending_io) && !s->remove_pending && s->state != _stopped) {
202 s->overruns++;
203 err("overrun (%d)", s->overruns);
204 }
205 wake_up (&s->wait);
206}
207
208static int dabusb_alloc_buffers (pdabusb_t s)
209{
210 int buffers = 0;
211 pbuff_t b;
212 unsigned int pipe = usb_rcvisocpipe (s->usbdev, _DABUSB_ISOPIPE);
213 int pipesize = usb_maxpacket (s->usbdev, pipe, usb_pipeout (pipe));
214 int packets = _ISOPIPESIZE / pipesize;
215 int transfer_buffer_length = packets * pipesize;
216 int i;
217
218 dbg("dabusb_alloc_buffers pipesize:%d packets:%d transfer_buffer_len:%d",
219 pipesize, packets, transfer_buffer_length);
220
221 while (buffers < (s->total_buffer_size << 10)) {
222 b = (pbuff_t) kmalloc (sizeof (buff_t), GFP_KERNEL);
223 if (!b) {
224 err("kmalloc(sizeof(buff_t))==NULL");
225 goto err;
226 }
227 memset (b, 0, sizeof (buff_t));
228 b->s = s;
229 b->purb = usb_alloc_urb(packets);
230 if (!b->purb) {
231 err("usb_alloc_urb == NULL");
232 kfree (b);
233 goto err;
234 }
235
236 b->purb->transfer_buffer = kmalloc (transfer_buffer_length, GFP_KERNEL);
237 if (!b->purb->transfer_buffer) {
238 kfree (b->purb);
239 kfree (b);
240 err("kmalloc(%d)==NULL", transfer_buffer_length);
241 goto err;
242 }
243
244 b->purb->transfer_buffer_length = transfer_buffer_length;
245 b->purb->number_of_packets = packets;
246 b->purb->complete = dabusb_iso_complete;
247 b->purb->context = b;
248 b->purb->dev = s->usbdev;
249 b->purb->pipe = pipe;
250 b->purb->transfer_flags = USB_ISO_ASAP;
251
252 for (i = 0; i < packets; i++) {
253 b->purb->iso_frame_desc[i].offset = i * pipesize;
254 b->purb->iso_frame_desc[i].length = pipesize;
255 }
256
257 buffers += transfer_buffer_length;
258 list_add_tail (&b->buff_list, &s->free_buff_list);
259 }
260 s->got_mem = buffers;
261
262 return 0;
263
264 err:
265 dabusb_free_buffers (s);
266 return -ENOMEM;
267}
268
269static int dabusb_bulk (pdabusb_t s, pbulk_transfer_t pb)
270{
271 int ret;
272 unsigned int pipe;
273 int actual_length;
274
275 dbg("dabusb_bulk");
276
277 if (!pb->pipe)
278 pipe = usb_rcvbulkpipe (s->usbdev, 2);
279 else
280 pipe = usb_sndbulkpipe (s->usbdev, 2);
281
282 ret=usb_bulk_msg(s->usbdev, pipe, pb->data, pb->size, &actual_length, 100);
283 if(ret<0) {
284 err("dabusb: usb_bulk_msg failed(%d)",ret);
285
286 if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
287 err("set_interface failed");
288 return -EINVAL;
289 }
290
291 }
292
293 if( ret == -EPIPE ) {
294 warn("CLEAR_FEATURE request to remove STALL condition.");
295 if(usb_clear_halt(s->usbdev, usb_pipeendpoint(pipe)))
296 err("request failed");
297 }
298
299 pb->size = actual_length;
300 return ret;
301}
302
303static int dabusb_writemem (pdabusb_t s, int pos, unsigned char *data, int len)
304{
305 int ret;
306 unsigned char *transfer_buffer = kmalloc (len, GFP_KERNEL);
307
308 if (!transfer_buffer) {
309 err("dabusb_writemem: kmalloc(%d) failed.", len);
310 return -ENOMEM;
311 }
312
313 memcpy (transfer_buffer, data, len);
314
315 ret=usb_control_msg(s->usbdev, usb_sndctrlpipe( s->usbdev, 0 ), 0xa0, 0x40, pos, 0, transfer_buffer, len, 300);
316
317 kfree (transfer_buffer);
318 return ret;
319}
320
321static int dabusb_8051_reset (pdabusb_t s, unsigned char reset_bit)
322{
323 dbg("dabusb_8051_reset: %d",reset_bit);
324 return dabusb_writemem (s, CPUCS_REG, &reset_bit, 1);
325}
326
327static int dabusb_loadmem (pdabusb_t s, const char *fname)
328{
329 int ret;
330 PINTEL_HEX_RECORD ptr = firmware;
331
332 dbg("Enter dabusb_loadmem (internal)");
333
334 ret = dabusb_8051_reset (s, 1);
335 while (ptr->Type == 0) {
336
337 dbg("dabusb_writemem: %04X %p %d)", ptr->Address, ptr->Data, ptr->Length);
338
339 ret = dabusb_writemem (s, ptr->Address, ptr->Data, ptr->Length);
340 if (ret < 0) {
341 err("dabusb_writemem failed (%d %04X %p %d)", ret, ptr->Address, ptr->Data, ptr->Length);
342 break;
343 }
344 ptr++;
345 }
346 ret = dabusb_8051_reset (s, 0);
347
348 dbg("dabusb_loadmem: exit");
349
350 return ret;
351}
352
353static int dabusb_fpga_clear (pdabusb_t s, pbulk_transfer_t b)
354{
355 b->size = 4;
356 b->data[0] = 0x2a;
357 b->data[1] = 0;
358 b->data[2] = 0;
359 b->data[3] = 0;
360
361 dbg("dabusb_fpga_clear");
362
363 return dabusb_bulk (s, b);
364}
365
366static int dabusb_fpga_init (pdabusb_t s, pbulk_transfer_t b)
367{
368 b->size = 4;
369 b->data[0] = 0x2c;
370 b->data[1] = 0;
371 b->data[2] = 0;
372 b->data[3] = 0;
373
374 dbg("dabusb_fpga_init");
375
376 return dabusb_bulk (s, b);
377}
378
379static int dabusb_fpga_download (pdabusb_t s, const char *fname)
380{
381 pbulk_transfer_t b = kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
382 unsigned int blen, n;
383 int ret;
384 unsigned char *buf = bitstream;
385
386 dbg("Enter dabusb_fpga_download (internal)");
387
388 if (!b) {
389 err("kmalloc(sizeof(bulk_transfer_t))==NULL");
390 return -ENOMEM;
391 }
392
393 b->pipe = 1;
394 ret = dabusb_fpga_clear (s, b);
395 mdelay (10);
396 blen = buf[73] + (buf[72] << 8);
397
398 dbg("Bitstream len: %i", blen);
399
400 b->data[0] = 0x2b;
401 b->data[1] = 0;
402 b->data[2] = 0;
403 b->data[3] = 60;
404
405 for (n = 0; n <= blen + 60; n += 60) {
406
407 b->size = 64;
408 memcpy (b->data + 4, buf + 74 + n, 60);
409 ret = dabusb_bulk (s, b);
410 if (ret < 0) {
411 err("dabusb_bulk failed.");
412 break;
413 }
414 mdelay (1);
415 }
416
417 ret = dabusb_fpga_init (s, b);
418 kfree (b);
419
420 dbg("exit dabusb_fpga_download");
421
422 return ret;
423}
424
425static int dabusb_stop (pdabusb_t s)
426{
427 dbg("dabusb_stop");
428
429 s->state = _stopped;
430 dabusb_cancel_queue (s, &s->rec_buff_list);
431
432 dbg("pending_io: %d", s->pending_io.counter);
433
434 s->pending_io.counter = 0;
435 return 0;
436}
437
438static int dabusb_startrek (pdabusb_t s)
439{
440 if (!s->got_mem && s->state != _started) {
441
442 dbg("dabusb_startrek");
443
444 if (dabusb_alloc_buffers (s) < 0)
445 return -ENOMEM;
446 dabusb_stop (s);
447 s->state = _started;
448 s->readptr = 0;
449 }
450
451 if (!list_empty (&s->free_buff_list)) {
452 pbuff_t end;
453 int ret;
454
455 while (!dabusb_add_buf_tail (s, &s->rec_buff_list, &s->free_buff_list)) {
456
457 dbg("submitting: end:%p s->rec_buff_list:%p", s->rec_buff_list.prev, &s->rec_buff_list);
458
459 end = list_entry (s->rec_buff_list.prev, buff_t, buff_list);
460
461 ret = usb_submit_urb (end->purb);
462 if (ret) {
463 err("usb_submit_urb returned:%d", ret);
464 if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
465 err("startrek: dabusb_add_buf_tail failed");
466 break;
467 }
468 else
469 atomic_inc (&s->pending_io);
470 }
471 dbg("pending_io: %d",s->pending_io.counter);
472 }
473
474 return 0;
475}
476
477static ssize_t dabusb_read (struct file *file, char *buf, size_t count, loff_t * ppos)
478{
479 pdabusb_t s = (pdabusb_t) file->private_data;
480 unsigned long flags;
481 unsigned ret = 0;
482 int rem;
483 int cnt;
484 pbuff_t b;
485 struct urb *purb = NULL;
486
487 dbg("dabusb_read");
488
489 if (*ppos)
490 return -ESPIPE;
491
492 if (s->remove_pending)
493 return -EIO;
494
495
496 if (!s->usbdev)
497 return -EIO;
498
499 while (count > 0) {
500 dabusb_startrek (s);
501
502 spin_lock_irqsave (&s->lock, flags);
503
504 if (list_empty (&s->rec_buff_list)) {
505
506 spin_unlock_irqrestore(&s->lock, flags);
507
508 err("error: rec_buf_list is empty");
509 goto err;
510 }
511
512 b = list_entry (s->rec_buff_list.next, buff_t, buff_list);
513 purb = b->purb;
514
515 spin_unlock_irqrestore(&s->lock, flags);
516
517 if (purb->status == -EINPROGRESS) {
518 if (file->f_flags & O_NONBLOCK)
519 {
520 if (!ret)
521 ret = -EAGAIN;
522 goto err;
523 }
524
525 interruptible_sleep_on (&s->wait);
526
527 if (signal_pending (current)) {
528 if (!ret)
529 ret = -ERESTARTSYS;
530 goto err;
531 }
532
533 spin_lock_irqsave (&s->lock, flags);
534
535 if (list_empty (&s->rec_buff_list)) {
536 spin_unlock_irqrestore(&s->lock, flags);
537 err("error: still no buffer available.");
538 goto err;
539 }
540 spin_unlock_irqrestore(&s->lock, flags);
541 s->readptr = 0;
542 }
543 if (s->remove_pending) {
544 ret = -EIO;
545 goto err;
546 }
547
548 rem = purb->actual_length - s->readptr;
549
550 if (count >= rem)
551 cnt = rem;
552 else
553 cnt = count;
554
555 dbg("copy_to_user:%p %p %d",buf, purb->transfer_buffer + s->readptr, cnt);
556
557 if (copy_to_user (buf, purb->transfer_buffer + s->readptr, cnt)) {
558 err("read: copy_to_user failed");
559 if (!ret)
560 ret = -EFAULT;
561 goto err;
562 }
563
564 s->readptr += cnt;
565 count -= cnt;
566 buf += cnt;
567 ret += cnt;
568
569 if (s->readptr == purb->actual_length) {
570
571 if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
572 err("read: dabusb_add_buf_tail failed");
573 s->readptr = 0;
574 }
575 }
576 err:
577 return ret;
578}
579
580static int dabusb_open (struct inode *inode, struct file *file)
581{
582 int devnum = MINOR (inode->i_rdev);
583 pdabusb_t s;
584
585 if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB))
586 return -EIO;
587
588 s = &dabusb[devnum - DABUSB_MINOR];
589
590 dbg("dabusb_open");
591 down (&s->mutex);
592
593 while (!s->usbdev || s->opened) {
594 up (&s->mutex);
595
596 if (file->f_flags & O_NONBLOCK) {
597 return -EBUSY;
598 }
599 schedule_timeout (HZ / 2);
600
601 if (signal_pending (current)) {
602 return -EAGAIN;
603 }
604 down (&s->mutex);
605 }
606 if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
607 err("set_interface failed");
608 up(&s->mutex);
609 return -EINVAL;
610 }
611 s->opened = 1;
612 up (&s->mutex);
613
614 file->f_pos = 0;
615 file->private_data = s;
616
617 return 0;
618}
619
620static int dabusb_release (struct inode *inode, struct file *file)
621{
622 pdabusb_t s = (pdabusb_t) file->private_data;
623
624 dbg("dabusb_release");
625
626 lock_kernel();
627 down (&s->mutex);
628 dabusb_stop (s);
629 dabusb_free_buffers (s);
630 up (&s->mutex);
631
632 if (!s->remove_pending) {
633 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0)
634 err("set_interface failed");
635 }
636 else
637 wake_up (&s->remove_ok);
638
639 s->opened = 0;
640 unlock_kernel();
641 return 0;
642}
643
644static int dabusb_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
645{
646 pdabusb_t s = (pdabusb_t) file->private_data;
647 pbulk_transfer_t pbulk;
648 int ret = 0;
649 int version = DABUSB_VERSION;
650
651 dbg("dabusb_ioctl");
652
653 if (s->remove_pending)
654 return -EIO;
655
656 down (&s->mutex);
657
658 if (!s->usbdev) {
659 up (&s->mutex);
660 return -EIO;
661 }
662
663 switch (cmd) {
664
665 case IOCTL_DAB_BULK:
666 pbulk = (pbulk_transfer_t) kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
667
668 if (!pbulk) {
669 ret = -ENOMEM;
670 break;
671 }
672
673 if (copy_from_user (pbulk, (void *) arg, sizeof (bulk_transfer_t))) {
674 ret = -EFAULT;
675 kfree (pbulk);
676 break;
677 }
678
679 ret=dabusb_bulk (s, pbulk);
680 if(ret==0)
681 ret = copy_to_user ((void *) arg, pbulk, sizeof (bulk_transfer_t));
682 kfree (pbulk);
683 break;
684
685 case IOCTL_DAB_OVERRUNS:
686 ret = put_user (s->overruns, (unsigned int *) arg);
687 break;
688
689 case IOCTL_DAB_VERSION:
690 ret = put_user (version, (unsigned int *) arg);
691 break;
692
693 default:
694 ret = -ENOIOCTLCMD;
695 break;
696 }
697 up (&s->mutex);
698 return ret;
699}
700
701static struct file_operations dabusb_fops =
702{
703 owner: THIS_MODULE,
704 llseek: no_llseek,
705 read: dabusb_read,
706 ioctl: dabusb_ioctl,
707 open: dabusb_open,
708 release: dabusb_release,
709};
710
711static int dabusb_find_struct (void)
712{
713 int u;
714
715 for (u = 0; u < NRDABUSB; u++) {
716 pdabusb_t s = &dabusb[u];
717 if (!s->usbdev)
718 return u;
719 }
720 return -1;
721}
722
723
724static void *dabusb_probe (struct usb_device *usbdev, unsigned int ifnum,
725 const struct usb_device_id *id)
726{
727 int devnum;
728 pdabusb_t s;
729
730 dbg("dabusb: probe: vendor id 0x%x, device id 0x%x ifnum:%d",
731 usbdev->descriptor.idVendor, usbdev->descriptor.idProduct, ifnum);
732
733
734 if (usbdev->descriptor.bNumConfigurations != 1)
735 return NULL;
736
737 if (ifnum != _DABUSB_IF && usbdev->descriptor.idProduct == 0x9999)
738 return NULL;
739
740 devnum = dabusb_find_struct ();
741 if (devnum == -1)
742 return NULL;
743
744 s = &dabusb[devnum];
745
746 down (&s->mutex);
747 s->remove_pending = 0;
748 s->usbdev = usbdev;
749
750 if (usb_set_configuration (usbdev, usbdev->config[0].bConfigurationValue) < 0) {
751 err("set_configuration failed");
752 goto reject;
753 }
754 if (usbdev->descriptor.idProduct == 0x2131) {
755 dabusb_loadmem (s, NULL);
756 goto reject;
757 }
758 else {
759 dabusb_fpga_download (s, NULL);
760
761 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0) {
762 err("set_interface failed");
763 goto reject;
764 }
765 }
766 dbg("bound to interface: %d", ifnum);
767 up (&s->mutex);
768 MOD_INC_USE_COUNT;
769 return s;
770
771 reject:
772 up (&s->mutex);
773 s->usbdev = NULL;
774 return NULL;
775}
776
777static void dabusb_disconnect (struct usb_device *usbdev, void *ptr)
778{
779 pdabusb_t s = (pdabusb_t) ptr;
780
781 dbg("dabusb_disconnect");
782
783 s->remove_pending = 1;
784 wake_up (&s->wait);
785 if (s->state == _started)
786 sleep_on (&s->remove_ok);
787 s->usbdev = NULL;
788 s->overruns = 0;
789 MOD_DEC_USE_COUNT;
790}
791
792static struct usb_device_id dabusb_ids [] = {
793 { USB_DEVICE(0x0547, 0x2131) },
794 { USB_DEVICE(0x0547, 0x9999) },
795 { }
796};
797
798MODULE_DEVICE_TABLE (usb, dabusb_ids);
799
800static struct usb_driver dabusb_driver =
801{
802 name: "dabusb",
803 probe: dabusb_probe,
804 disconnect: dabusb_disconnect,
805 fops: &dabusb_fops,
806 minor: DABUSB_MINOR,
807 id_table: dabusb_ids,
808};
809
810
811
812static int __init dabusb_init (void)
813{
814 unsigned u;
815
816
817 for (u = 0; u < NRDABUSB; u++) {
818 pdabusb_t s = &dabusb[u];
819 memset (s, 0, sizeof (dabusb_t));
820 init_MUTEX (&s->mutex);
821 s->usbdev = NULL;
822 s->total_buffer_size = buffers;
823 init_waitqueue_head (&s->wait);
824 init_waitqueue_head (&s->remove_ok);
825 spin_lock_init (&s->lock);
826 INIT_LIST_HEAD (&s->free_buff_list);
827 INIT_LIST_HEAD (&s->rec_buff_list);
828 }
829
830
831 if (usb_register(&dabusb_driver))
832 return -1;
833
834 dbg("dabusb_init: driver registered");
835
836 info(DRIVER_VERSION ":" DRIVER_DESC);
837
838 return 0;
839}
840
841static void __exit dabusb_cleanup (void)
842{
843 dbg("dabusb_cleanup");
844
845 usb_deregister (&dabusb_driver);
846}
847
848
849
850MODULE_AUTHOR( DRIVER_AUTHOR );
851MODULE_DESCRIPTION( DRIVER_DESC );
852MODULE_LICENSE("GPL");
853
854MODULE_PARM (buffers, "i");
855MODULE_PARM_DESC (buffers, "Number of buffers (default=256)");
856
857module_init (dabusb_init);
858module_exit (dabusb_cleanup);
859
860
861
