?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.34-rc3
[pohmelfs.git] / drivers / media / video / dabusb.c
blob0f505086774c73b45e94636fb0fc3b2182ccb49e
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/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 * Version Information
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
64 static dabusb_t dabusb[NRDABUSB];
65 static int buffers = 256;
66 static struct usb_driver dabusb_driver;
67
68 /*-------------------------------------------------------------------*/
69
70 static 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 // no elements in source buffer
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
91 static 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 /*-------------------------------------------------------------------*/
111 static 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 /*-------------------------------------------------------------------*/
130 static 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 /*-------------------------------------------------------------------*/
154 static 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 /*-------------------------------------------------------------------*/
170 static 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 // process if URB was not killed
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 /*-------------------------------------------------------------------*/
211 static 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 /*-------------------------------------------------------------------*/
273 static 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 /* --------------------------------------------------------------------- */
308 static 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 /* --------------------------------------------------------------------- */
328 static 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 /* --------------------------------------------------------------------- */
334 static 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 /* --------------------------------------------------------------------- */
373 static 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 /* --------------------------------------------------------------------- */
386 static 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 /* --------------------------------------------------------------------- */
399 static 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 // some cclks for startup
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
455 static 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
468 static 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
509 static 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) // return nonblocking
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; // set remaining bytes to copy
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 // finished, take next buffer
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: //mutex_unlock(&s->mutex);
612 return ret;
613 }
614
615 static int dabusb_open (struct inode *inode, struct file *file)
616 {
617 int devnum = iminor(inode);
618 pdabusb_t s;
619 int r;
620
621 if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB))
622 return -EIO;
623
624 lock_kernel();
625 s = &dabusb[devnum - DABUSB_MINOR];
626
627 dbg("dabusb_open");
628 mutex_lock(&s->mutex);
629
630 while (!s->usbdev || s->opened) {
631 mutex_unlock(&s->mutex);
632
633 if (file->f_flags & O_NONBLOCK) {
634 return -EBUSY;
635 }
636 msleep_interruptible(500);
637
638 if (signal_pending (current)) {
639 unlock_kernel();
640 return -EAGAIN;
641 }
642 mutex_lock(&s->mutex);
643 }
644 if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
645 mutex_unlock(&s->mutex);
646 dev_err(&s->usbdev->dev, "set_interface failed\n");
647 unlock_kernel();
648 return -EINVAL;
649 }
650 s->opened = 1;
651 mutex_unlock(&s->mutex);
652
653 file->f_pos = 0;
654 file->private_data = s;
655
656 r = nonseekable_open(inode, file);
657 unlock_kernel();
658 return r;
659 }
660
661 static int dabusb_release (struct inode *inode, struct file *file)
662 {
663 pdabusb_t s = (pdabusb_t) file->private_data;
664
665 dbg("dabusb_release");
666
667 mutex_lock(&s->mutex);
668 dabusb_stop (s);
669 dabusb_free_buffers (s);
670 mutex_unlock(&s->mutex);
671
672 if (!s->remove_pending) {
673 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0)
674 dev_err(&s->usbdev->dev, "set_interface failed\n");
675 }
676 else
677 wake_up (&s->remove_ok);
678
679 s->opened = 0;
680 return 0;
681 }
682
683 static long dabusb_ioctl (struct file *file, unsigned int cmd, unsigned long arg)
684 {
685 pdabusb_t s = (pdabusb_t) file->private_data;
686 pbulk_transfer_t pbulk;
687 int ret = 0;
688 int version = DABUSB_VERSION;
689
690 dbg("dabusb_ioctl");
691
692 lock_kernel();
693 if (s->remove_pending) {
694 unlock_kernel();
695 return -EIO;
696 }
697
698 mutex_lock(&s->mutex);
699
700 if (!s->usbdev) {
701 mutex_unlock(&s->mutex);
702 unlock_kernel();
703 return -EIO;
704 }
705
706 switch (cmd) {
707
708 case IOCTL_DAB_BULK:
709 pbulk = kmalloc(sizeof (bulk_transfer_t), GFP_KERNEL);
710
711 if (!pbulk) {
712 ret = -ENOMEM;
713 break;
714 }
715
716 if (copy_from_user (pbulk, (void __user *) arg, sizeof (bulk_transfer_t))) {
717 ret = -EFAULT;
718 kfree (pbulk);
719 break;
720 }
721
722 ret=dabusb_bulk (s, pbulk);
723 if(ret==0)
724 if (copy_to_user((void __user *)arg, pbulk,
725 sizeof(bulk_transfer_t)))
726 ret = -EFAULT;
727 kfree (pbulk);
728 break;
729
730 case IOCTL_DAB_OVERRUNS:
731 ret = put_user (s->overruns, (unsigned int __user *) arg);
732 break;
733
734 case IOCTL_DAB_VERSION:
735 ret = put_user (version, (unsigned int __user *) arg);
736 break;
737
738 default:
739 ret = -ENOIOCTLCMD;
740 break;
741 }
742 mutex_unlock(&s->mutex);
743 unlock_kernel();
744 return ret;
745 }
746
747 static const struct file_operations dabusb_fops =
748 {
749 .owner = THIS_MODULE,
750 .llseek = no_llseek,
751 .read = dabusb_read,
752 .unlocked_ioctl = dabusb_ioctl,
753 .open = dabusb_open,
754 .release = dabusb_release,
755 };
756
757 static char *dabusb_devnode(struct device *dev, mode_t *mode)
758 {
759 return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
760 }
761
762 static struct usb_class_driver dabusb_class = {
763 .name = "dabusb%d",
764 .devnode = dabusb_devnode,
765 .fops = &dabusb_fops,
766 .minor_base = DABUSB_MINOR,
767 };
768
769
770 /* --------------------------------------------------------------------- */
771 static int dabusb_probe (struct usb_interface *intf,
772 const struct usb_device_id *id)
773 {
774 struct usb_device *usbdev = interface_to_usbdev(intf);
775 int retval;
776 pdabusb_t s;
777
778 dbg("dabusb: probe: vendor id 0x%x, device id 0x%x ifnum:%d",
779 le16_to_cpu(usbdev->descriptor.idVendor),
780 le16_to_cpu(usbdev->descriptor.idProduct),
781 intf->altsetting->desc.bInterfaceNumber);
782
783 /* We don't handle multiple configurations */
784 if (usbdev->descriptor.bNumConfigurations != 1)
785 return -ENODEV;
786
787 if (intf->altsetting->desc.bInterfaceNumber != _DABUSB_IF &&
788 le16_to_cpu(usbdev->descriptor.idProduct) == 0x9999)
789 return -ENODEV;
790
791
792
793 s = &dabusb[intf->minor];
794
795 mutex_lock(&s->mutex);
796 s->remove_pending = 0;
797 s->usbdev = usbdev;
798 s->devnum = intf->minor;
799
800 if (usb_reset_configuration (usbdev) < 0) {
801 dev_err(&intf->dev, "reset_configuration failed\n");
802 goto reject;
803 }
804 if (le16_to_cpu(usbdev->descriptor.idProduct) == 0x2131) {
805 dabusb_loadmem (s, NULL);
806 goto reject;
807 }
808 else {
809 dabusb_fpga_download (s, NULL);
810
811 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0) {
812 dev_err(&intf->dev, "set_interface failed\n");
813 goto reject;
814 }
815 }
816 dbg("bound to interface: %d", intf->altsetting->desc.bInterfaceNumber);
817 usb_set_intfdata (intf, s);
818 mutex_unlock(&s->mutex);
819
820 retval = usb_register_dev(intf, &dabusb_class);
821 if (retval) {
822 usb_set_intfdata (intf, NULL);
823 return -ENOMEM;
824 }
825
826 return 0;
827
828 reject:
829 mutex_unlock(&s->mutex);
830 s->usbdev = NULL;
831 return -ENODEV;
832 }
833
834 static void dabusb_disconnect (struct usb_interface *intf)
835 {
836 wait_queue_t __wait;
837 pdabusb_t s = usb_get_intfdata (intf);
838
839 dbg("dabusb_disconnect");
840
841 init_waitqueue_entry(&__wait, current);
842
843 usb_set_intfdata (intf, NULL);
844 if (s) {
845 usb_deregister_dev (intf, &dabusb_class);
846 s->remove_pending = 1;
847 wake_up (&s->wait);
848 add_wait_queue(&s->remove_ok, &__wait);
849 set_current_state(TASK_UNINTERRUPTIBLE);
850 if (s->state == _started)
851 schedule();
852 current->state = TASK_RUNNING;
853 remove_wait_queue(&s->remove_ok, &__wait);
854
855 s->usbdev = NULL;
856 s->overruns = 0;
857 }
858 }
859
860 static struct usb_device_id dabusb_ids [] = {
861 // { USB_DEVICE(0x0547, 0x2131) }, /* An2131 chip, no boot ROM */
862 { USB_DEVICE(0x0547, 0x9999) },
863 { } /* Terminating entry */
864 };
865
866 MODULE_DEVICE_TABLE (usb, dabusb_ids);
867
868 static struct usb_driver dabusb_driver = {
869 .name = "dabusb",
870 .probe = dabusb_probe,
871 .disconnect = dabusb_disconnect,
872 .id_table = dabusb_ids,
873 };
874
875 /* --------------------------------------------------------------------- */
876
877 static int __init dabusb_init (void)
878 {
879 int retval;
880 unsigned u;
881
882 /* initialize struct */
883 for (u = 0; u < NRDABUSB; u++) {
884 pdabusb_t s = &dabusb[u];
885 memset (s, 0, sizeof (dabusb_t));
886 mutex_init (&s->mutex);
887 s->usbdev = NULL;
888 s->total_buffer_size = buffers;
889 init_waitqueue_head (&s->wait);
890 init_waitqueue_head (&s->remove_ok);
891 spin_lock_init (&s->lock);
892 INIT_LIST_HEAD (&s->free_buff_list);
893 INIT_LIST_HEAD (&s->rec_buff_list);
894 }
895
896 /* register misc device */
897 retval = usb_register(&dabusb_driver);
898 if (retval)
899 goto out;
900
901 dbg("dabusb_init: driver registered");
902
903 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
904 DRIVER_DESC "\n");
905
906 out:
907 return retval;
908 }
909
910 static void __exit dabusb_cleanup (void)
911 {
912 dbg("dabusb_cleanup");
913
914 usb_deregister (&dabusb_driver);
915 }
916
917 /* --------------------------------------------------------------------- */
918
919 MODULE_AUTHOR( DRIVER_AUTHOR );
920 MODULE_DESCRIPTION( DRIVER_DESC );
921 MODULE_LICENSE("GPL");
922 MODULE_FIRMWARE("dabusb/firmware.fw");
923 MODULE_FIRMWARE("dabusb/bitstream.bin");
924
925 module_param(buffers, int, 0);
926 MODULE_PARM_DESC (buffers, "Number of buffers (default=256)");
927
928 module_init (dabusb_init);
929 module_exit (dabusb_cleanup);
930
931 /* --------------------------------------------------------------------- */