Merge branch 'linus' into sched/core
[linux-3.10.git] / drivers / media / video / dabusb.c
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 /* --------------------------------------------------------------------- */