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