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