blob: 3aa538afcc0b3ab2343c2c29833cfe02621370f3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*****************************************************************************/
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>
Arjan van de Ven4186ecf2006-01-11 15:55:29 +010040#include <linux/mutex.h>
David Woodhousec4667742008-06-23 11:41:04 +010041#include <linux/firmware.h>
42#include <linux/ihex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
44#include "dabusb.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46/*
47 * Version Information
48 */
49#define DRIVER_VERSION "v1.54"
50#define DRIVER_AUTHOR "Deti Fliegl, deti@fliegl.de"
51#define DRIVER_DESC "DAB-USB Interface Driver for Linux (c)1999"
52
53/* --------------------------------------------------------------------- */
54
55#ifdef CONFIG_USB_DYNAMIC_MINORS
56#define NRDABUSB 256
57#else
58#define NRDABUSB 4
59#endif
60
61/*-------------------------------------------------------------------*/
62
63static dabusb_t dabusb[NRDABUSB];
64static int buffers = 256;
65static struct usb_driver dabusb_driver;
66
67/*-------------------------------------------------------------------*/
68
69static int dabusb_add_buf_tail (pdabusb_t s, struct list_head *dst, struct list_head *src)
70{
71 unsigned long flags;
72 struct list_head *tmp;
73 int ret = 0;
74
75 spin_lock_irqsave (&s->lock, flags);
76
77 if (list_empty (src)) {
78 // no elements in source buffer
79 ret = -1;
80 goto err;
81 }
82 tmp = src->next;
83 list_move_tail (tmp, dst);
84
85 err: spin_unlock_irqrestore (&s->lock, flags);
86 return ret;
87}
88/*-------------------------------------------------------------------*/
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -030089#ifdef DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -070090static void dump_urb (struct urb *urb)
91{
92 dbg("urb :%p", urb);
93 dbg("dev :%p", urb->dev);
94 dbg("pipe :%08X", urb->pipe);
95 dbg("status :%d", urb->status);
96 dbg("transfer_flags :%08X", urb->transfer_flags);
97 dbg("transfer_buffer :%p", urb->transfer_buffer);
98 dbg("transfer_buffer_length:%d", urb->transfer_buffer_length);
99 dbg("actual_length :%d", urb->actual_length);
100 dbg("setup_packet :%p", urb->setup_packet);
101 dbg("start_frame :%d", urb->start_frame);
102 dbg("number_of_packets :%d", urb->number_of_packets);
103 dbg("interval :%d", urb->interval);
104 dbg("error_count :%d", urb->error_count);
105 dbg("context :%p", urb->context);
106 dbg("complete :%p", urb->complete);
107}
108#endif
109/*-------------------------------------------------------------------*/
110static int dabusb_cancel_queue (pdabusb_t s, struct list_head *q)
111{
112 unsigned long flags;
113 pbuff_t b;
114
115 dbg("dabusb_cancel_queue");
116
117 spin_lock_irqsave (&s->lock, flags);
118
119 list_for_each_entry(b, q, buff_list) {
120#ifdef DEBUG
121 dump_urb(b->purb);
122#endif
123 usb_unlink_urb (b->purb);
124 }
125 spin_unlock_irqrestore (&s->lock, flags);
126 return 0;
127}
128/*-------------------------------------------------------------------*/
129static int dabusb_free_queue (struct list_head *q)
130{
131 struct list_head *tmp;
132 struct list_head *p;
133 pbuff_t b;
134
135 dbg("dabusb_free_queue");
136 for (p = q->next; p != q;) {
137 b = list_entry (p, buff_t, buff_list);
138
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300139#ifdef DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 dump_urb(b->purb);
141#endif
Jesper Juhl1bc3c9e2005-04-18 17:39:34 -0700142 kfree(b->purb->transfer_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 usb_free_urb(b->purb);
144 tmp = p->next;
145 list_del (p);
146 kfree (b);
147 p = tmp;
148 }
149
150 return 0;
151}
152/*-------------------------------------------------------------------*/
153static int dabusb_free_buffers (pdabusb_t s)
154{
155 unsigned long flags;
156 dbg("dabusb_free_buffers");
157
158 spin_lock_irqsave(&s->lock, flags);
159
160 dabusb_free_queue (&s->free_buff_list);
161 dabusb_free_queue (&s->rec_buff_list);
162
163 spin_unlock_irqrestore(&s->lock, flags);
164
165 s->got_mem = 0;
166 return 0;
167}
168/*-------------------------------------------------------------------*/
David Howells7d12e782006-10-05 14:55:46 +0100169static void dabusb_iso_complete (struct urb *purb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170{
171 pbuff_t b = purb->context;
172 pdabusb_t s = b->s;
173 int i;
174 int len;
175 int dst = 0;
176 void *buf = purb->transfer_buffer;
177
178 dbg("dabusb_iso_complete");
179
180 // process if URB was not killed
181 if (purb->status != -ENOENT) {
182 unsigned int pipe = usb_rcvisocpipe (purb->dev, _DABUSB_ISOPIPE);
183 int pipesize = usb_maxpacket (purb->dev, pipe, usb_pipeout (pipe));
184 for (i = 0; i < purb->number_of_packets; i++)
185 if (!purb->iso_frame_desc[i].status) {
186 len = purb->iso_frame_desc[i].actual_length;
187 if (len <= pipesize) {
188 memcpy (buf + dst, buf + purb->iso_frame_desc[i].offset, len);
189 dst += len;
190 }
191 else
192 err("dabusb_iso_complete: invalid len %d", len);
193 }
194 else
195 warn("dabusb_iso_complete: corrupted packet status: %d", purb->iso_frame_desc[i].status);
196 if (dst != purb->actual_length)
197 err("dst!=purb->actual_length:%d!=%d", dst, purb->actual_length);
198 }
199
200 if (atomic_dec_and_test (&s->pending_io) && !s->remove_pending && s->state != _stopped) {
201 s->overruns++;
202 err("overrun (%d)", s->overruns);
203 }
204 wake_up (&s->wait);
205}
206/*-------------------------------------------------------------------*/
207static int dabusb_alloc_buffers (pdabusb_t s)
208{
Harvey Harrison6f289672008-04-22 14:45:32 -0300209 int transfer_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 pbuff_t b;
211 unsigned int pipe = usb_rcvisocpipe (s->usbdev, _DABUSB_ISOPIPE);
212 int pipesize = usb_maxpacket (s->usbdev, pipe, usb_pipeout (pipe));
213 int packets = _ISOPIPESIZE / pipesize;
214 int transfer_buffer_length = packets * pipesize;
215 int i;
216
217 dbg("dabusb_alloc_buffers pipesize:%d packets:%d transfer_buffer_len:%d",
218 pipesize, packets, transfer_buffer_length);
219
Harvey Harrison6f289672008-04-22 14:45:32 -0300220 while (transfer_len < (s->total_buffer_size << 10)) {
Robert P. J. Day5cbded52006-12-13 00:35:56 -0800221 b = kzalloc(sizeof (buff_t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 if (!b) {
Oliver Neukumd8e298d2006-01-06 21:01:47 +0100223 err("kzalloc(sizeof(buff_t))==NULL");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 goto err;
225 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 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
Harvey Harrison6f289672008-04-22 14:45:32 -0300255 transfer_len += transfer_buffer_length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 list_add_tail (&b->buff_list, &s->free_buff_list);
257 }
Harvey Harrison6f289672008-04-22 14:45:32 -0300258 s->got_mem = transfer_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
260 return 0;
261
262 err:
263 dabusb_free_buffers (s);
264 return -ENOMEM;
265}
266/*-------------------------------------------------------------------*/
267static 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 }
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 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/* --------------------------------------------------------------------- */
David Woodhousec4667742008-06-23 11:41:04 +0100301static int dabusb_writemem (pdabusb_t s, int pos, const unsigned char *data,
302 int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303{
304 int ret;
305 unsigned char *transfer_buffer = kmalloc (len, GFP_KERNEL);
306
307 if (!transfer_buffer) {
308 err("dabusb_writemem: kmalloc(%d) failed.", len);
309 return -ENOMEM;
310 }
311
312 memcpy (transfer_buffer, data, len);
313
314 ret=usb_control_msg(s->usbdev, usb_sndctrlpipe( s->usbdev, 0 ), 0xa0, 0x40, pos, 0, transfer_buffer, len, 300);
315
316 kfree (transfer_buffer);
317 return ret;
318}
319/* --------------------------------------------------------------------- */
320static int dabusb_8051_reset (pdabusb_t s, unsigned char reset_bit)
321{
322 dbg("dabusb_8051_reset: %d",reset_bit);
323 return dabusb_writemem (s, CPUCS_REG, &reset_bit, 1);
324}
325/* --------------------------------------------------------------------- */
326static int dabusb_loadmem (pdabusb_t s, const char *fname)
327{
328 int ret;
David Woodhousec4667742008-06-23 11:41:04 +0100329 const struct ihex_binrec *rec;
330 const struct firmware *fw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
332 dbg("Enter dabusb_loadmem (internal)");
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300333
David Woodhousec4667742008-06-23 11:41:04 +0100334 ret = request_ihex_firmware(&fw, "dabusb/firmware.fw", &s->usbdev->dev);
335 if (ret) {
336 err("Failed to load \"dabusb/firmware.fw\": %d\n", ret);
337 goto out;
338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 ret = dabusb_8051_reset (s, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
David Woodhousec4667742008-06-23 11:41:04 +0100341 for (rec = (const struct ihex_binrec *)fw->data; rec;
342 rec = ihex_next_binrec(rec)) {
343 dbg("dabusb_writemem: %04X %p %d)", be32_to_cpu(rec->addr),
344 rec->data, be16_to_cpu(rec->len));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
David Woodhousec4667742008-06-23 11:41:04 +0100346 ret = dabusb_writemem(s, be32_to_cpu(rec->addr), rec->data,
347 be16_to_cpu(rec->len));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 if (ret < 0) {
David Woodhousec4667742008-06-23 11:41:04 +0100349 err("dabusb_writemem failed (%d %04X %p %d)", ret,
350 be32_to_cpu(rec->addr), rec->data,
351 be16_to_cpu(rec->len));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 break;
353 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 }
355 ret = dabusb_8051_reset (s, 0);
David Woodhousec4667742008-06-23 11:41:04 +0100356 release_firmware(fw);
357 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 dbg("dabusb_loadmem: exit");
359
360 return ret;
361}
362/* --------------------------------------------------------------------- */
363static int dabusb_fpga_clear (pdabusb_t s, pbulk_transfer_t b)
364{
365 b->size = 4;
366 b->data[0] = 0x2a;
367 b->data[1] = 0;
368 b->data[2] = 0;
369 b->data[3] = 0;
370
371 dbg("dabusb_fpga_clear");
372
373 return dabusb_bulk (s, b);
374}
375/* --------------------------------------------------------------------- */
376static int dabusb_fpga_init (pdabusb_t s, pbulk_transfer_t b)
377{
378 b->size = 4;
379 b->data[0] = 0x2c;
380 b->data[1] = 0;
381 b->data[2] = 0;
382 b->data[3] = 0;
383
384 dbg("dabusb_fpga_init");
385
386 return dabusb_bulk (s, b);
387}
388/* --------------------------------------------------------------------- */
389static int dabusb_fpga_download (pdabusb_t s, const char *fname)
390{
391 pbulk_transfer_t b = kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
David Woodhousec4667742008-06-23 11:41:04 +0100392 const struct firmware *fw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 unsigned int blen, n;
394 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
396 dbg("Enter dabusb_fpga_download (internal)");
397
398 if (!b) {
399 err("kmalloc(sizeof(bulk_transfer_t))==NULL");
400 return -ENOMEM;
401 }
402
David Woodhousec4667742008-06-23 11:41:04 +0100403 ret = request_firmware(&fw, "dabusb/bitstream.bin", &s->usbdev->dev);
404 if (ret) {
405 err("Failed to load \"dabusb/bitstream.bin\": %d\n", ret);
Adrian Bunk02c02672008-08-28 01:04:30 +0300406 kfree(b);
David Woodhousec4667742008-06-23 11:41:04 +0100407 return ret;
408 }
409
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 b->pipe = 1;
411 ret = dabusb_fpga_clear (s, b);
412 mdelay (10);
David Woodhousec4667742008-06-23 11:41:04 +0100413 blen = fw->data[73] + (fw->data[72] << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
415 dbg("Bitstream len: %i", blen);
416
417 b->data[0] = 0x2b;
418 b->data[1] = 0;
419 b->data[2] = 0;
420 b->data[3] = 60;
421
422 for (n = 0; n <= blen + 60; n += 60) {
423 // some cclks for startup
424 b->size = 64;
David Woodhousec4667742008-06-23 11:41:04 +0100425 memcpy (b->data + 4, fw->data + 74 + n, 60);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 ret = dabusb_bulk (s, b);
427 if (ret < 0) {
428 err("dabusb_bulk failed.");
429 break;
430 }
431 mdelay (1);
432 }
433
434 ret = dabusb_fpga_init (s, b);
435 kfree (b);
David Woodhousec4667742008-06-23 11:41:04 +0100436 release_firmware(fw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
438 dbg("exit dabusb_fpga_download");
439
440 return ret;
441}
442
443static int dabusb_stop (pdabusb_t s)
444{
445 dbg("dabusb_stop");
446
447 s->state = _stopped;
448 dabusb_cancel_queue (s, &s->rec_buff_list);
449
450 dbg("pending_io: %d", s->pending_io.counter);
451
452 s->pending_io.counter = 0;
453 return 0;
454}
455
456static int dabusb_startrek (pdabusb_t s)
457{
458 if (!s->got_mem && s->state != _started) {
459
460 dbg("dabusb_startrek");
461
462 if (dabusb_alloc_buffers (s) < 0)
463 return -ENOMEM;
464 dabusb_stop (s);
465 s->state = _started;
466 s->readptr = 0;
467 }
468
469 if (!list_empty (&s->free_buff_list)) {
470 pbuff_t end;
471 int ret;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300472
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 while (!dabusb_add_buf_tail (s, &s->rec_buff_list, &s->free_buff_list)) {
474
475 dbg("submitting: end:%p s->rec_buff_list:%p", s->rec_buff_list.prev, &s->rec_buff_list);
476
477 end = list_entry (s->rec_buff_list.prev, buff_t, buff_list);
478
479 ret = usb_submit_urb (end->purb, GFP_KERNEL);
480 if (ret) {
481 err("usb_submit_urb returned:%d", ret);
482 if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
483 err("startrek: dabusb_add_buf_tail failed");
484 break;
485 }
486 else
487 atomic_inc (&s->pending_io);
488 }
489 dbg("pending_io: %d",s->pending_io.counter);
490 }
491
492 return 0;
493}
494
495static ssize_t dabusb_read (struct file *file, char __user *buf, size_t count, loff_t * ppos)
496{
497 pdabusb_t s = (pdabusb_t) file->private_data;
498 unsigned long flags;
499 unsigned ret = 0;
500 int rem;
501 int cnt;
502 pbuff_t b;
503 struct urb *purb = NULL;
504
505 dbg("dabusb_read");
506
507 if (*ppos)
508 return -ESPIPE;
509
510 if (s->remove_pending)
511 return -EIO;
512
513
514 if (!s->usbdev)
515 return -EIO;
516
517 while (count > 0) {
518 dabusb_startrek (s);
519
520 spin_lock_irqsave (&s->lock, flags);
521
522 if (list_empty (&s->rec_buff_list)) {
523
524 spin_unlock_irqrestore(&s->lock, flags);
525
526 err("error: rec_buf_list is empty");
527 goto err;
528 }
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300529
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 b = list_entry (s->rec_buff_list.next, buff_t, buff_list);
531 purb = b->purb;
532
533 spin_unlock_irqrestore(&s->lock, flags);
534
535 if (purb->status == -EINPROGRESS) {
536 if (file->f_flags & O_NONBLOCK) // return nonblocking
537 {
538 if (!ret)
539 ret = -EAGAIN;
540 goto err;
541 }
542
543 interruptible_sleep_on (&s->wait);
544
545 if (signal_pending (current)) {
546 if (!ret)
547 ret = -ERESTARTSYS;
548 goto err;
549 }
550
551 spin_lock_irqsave (&s->lock, flags);
552
553 if (list_empty (&s->rec_buff_list)) {
554 spin_unlock_irqrestore(&s->lock, flags);
555 err("error: still no buffer available.");
556 goto err;
557 }
558 spin_unlock_irqrestore(&s->lock, flags);
559 s->readptr = 0;
560 }
561 if (s->remove_pending) {
562 ret = -EIO;
563 goto err;
564 }
565
566 rem = purb->actual_length - s->readptr; // set remaining bytes to copy
567
568 if (count >= rem)
569 cnt = rem;
570 else
571 cnt = count;
572
573 dbg("copy_to_user:%p %p %d",buf, purb->transfer_buffer + s->readptr, cnt);
574
575 if (copy_to_user (buf, purb->transfer_buffer + s->readptr, cnt)) {
576 err("read: copy_to_user failed");
577 if (!ret)
578 ret = -EFAULT;
579 goto err;
580 }
581
582 s->readptr += cnt;
583 count -= cnt;
584 buf += cnt;
585 ret += cnt;
586
587 if (s->readptr == purb->actual_length) {
588 // finished, take next buffer
589 if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
590 err("read: dabusb_add_buf_tail failed");
591 s->readptr = 0;
592 }
593 }
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100594 err: //mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 return ret;
596}
597
598static int dabusb_open (struct inode *inode, struct file *file)
599{
600 int devnum = iminor(inode);
601 pdabusb_t s;
602
603 if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB))
604 return -EIO;
605
606 s = &dabusb[devnum - DABUSB_MINOR];
607
608 dbg("dabusb_open");
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100609 mutex_lock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
611 while (!s->usbdev || s->opened) {
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100612 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
614 if (file->f_flags & O_NONBLOCK) {
615 return -EBUSY;
616 }
617 msleep_interruptible(500);
618
619 if (signal_pending (current)) {
620 return -EAGAIN;
621 }
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100622 mutex_lock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 }
624 if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100625 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 err("set_interface failed");
627 return -EINVAL;
628 }
629 s->opened = 1;
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100630 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631
632 file->f_pos = 0;
633 file->private_data = s;
634
635 return nonseekable_open(inode, file);
636}
637
638static int dabusb_release (struct inode *inode, struct file *file)
639{
640 pdabusb_t s = (pdabusb_t) file->private_data;
641
642 dbg("dabusb_release");
643
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100644 mutex_lock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 dabusb_stop (s);
646 dabusb_free_buffers (s);
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100647 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
649 if (!s->remove_pending) {
650 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0)
651 err("set_interface failed");
652 }
653 else
654 wake_up (&s->remove_ok);
655
656 s->opened = 0;
657 return 0;
658}
659
660static int dabusb_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
661{
662 pdabusb_t s = (pdabusb_t) file->private_data;
663 pbulk_transfer_t pbulk;
664 int ret = 0;
665 int version = DABUSB_VERSION;
666
667 dbg("dabusb_ioctl");
668
669 if (s->remove_pending)
670 return -EIO;
671
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100672 mutex_lock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
674 if (!s->usbdev) {
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100675 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 return -EIO;
677 }
678
679 switch (cmd) {
680
681 case IOCTL_DAB_BULK:
Robert P. J. Day5cbded52006-12-13 00:35:56 -0800682 pbulk = kmalloc(sizeof (bulk_transfer_t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683
684 if (!pbulk) {
685 ret = -ENOMEM;
686 break;
687 }
688
689 if (copy_from_user (pbulk, (void __user *) arg, sizeof (bulk_transfer_t))) {
690 ret = -EFAULT;
691 kfree (pbulk);
692 break;
693 }
694
695 ret=dabusb_bulk (s, pbulk);
696 if(ret==0)
697 if (copy_to_user((void __user *)arg, pbulk,
698 sizeof(bulk_transfer_t)))
699 ret = -EFAULT;
700 kfree (pbulk);
701 break;
702
703 case IOCTL_DAB_OVERRUNS:
704 ret = put_user (s->overruns, (unsigned int __user *) arg);
705 break;
706
707 case IOCTL_DAB_VERSION:
708 ret = put_user (version, (unsigned int __user *) arg);
709 break;
710
711 default:
712 ret = -ENOIOCTLCMD;
713 break;
714 }
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100715 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 return ret;
717}
718
Arjan van de Venfa027c22007-02-12 00:55:33 -0800719static const struct file_operations dabusb_fops =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720{
721 .owner = THIS_MODULE,
722 .llseek = no_llseek,
723 .read = dabusb_read,
724 .ioctl = dabusb_ioctl,
725 .open = dabusb_open,
726 .release = dabusb_release,
727};
728
729static struct usb_class_driver dabusb_class = {
Greg Kroah-Hartmand6e5bcf2005-06-20 21:15:16 -0700730 .name = "dabusb%d",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 .fops = &dabusb_fops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 .minor_base = DABUSB_MINOR,
733};
734
735
736/* --------------------------------------------------------------------- */
737static int dabusb_probe (struct usb_interface *intf,
738 const struct usb_device_id *id)
739{
740 struct usb_device *usbdev = interface_to_usbdev(intf);
741 int retval;
742 pdabusb_t s;
743
744 dbg("dabusb: probe: vendor id 0x%x, device id 0x%x ifnum:%d",
745 le16_to_cpu(usbdev->descriptor.idVendor),
746 le16_to_cpu(usbdev->descriptor.idProduct),
747 intf->altsetting->desc.bInterfaceNumber);
748
749 /* We don't handle multiple configurations */
750 if (usbdev->descriptor.bNumConfigurations != 1)
751 return -ENODEV;
752
753 if (intf->altsetting->desc.bInterfaceNumber != _DABUSB_IF &&
754 le16_to_cpu(usbdev->descriptor.idProduct) == 0x9999)
755 return -ENODEV;
756
757
758
759 s = &dabusb[intf->minor];
760
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100761 mutex_lock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 s->remove_pending = 0;
763 s->usbdev = usbdev;
764 s->devnum = intf->minor;
765
766 if (usb_reset_configuration (usbdev) < 0) {
767 err("reset_configuration failed");
768 goto reject;
769 }
770 if (le16_to_cpu(usbdev->descriptor.idProduct) == 0x2131) {
771 dabusb_loadmem (s, NULL);
772 goto reject;
773 }
774 else {
775 dabusb_fpga_download (s, NULL);
776
777 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0) {
778 err("set_interface failed");
779 goto reject;
780 }
781 }
782 dbg("bound to interface: %d", intf->altsetting->desc.bInterfaceNumber);
783 usb_set_intfdata (intf, s);
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100784 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
786 retval = usb_register_dev(intf, &dabusb_class);
787 if (retval) {
788 usb_set_intfdata (intf, NULL);
789 return -ENOMEM;
790 }
791
792 return 0;
793
794 reject:
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100795 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 s->usbdev = NULL;
797 return -ENODEV;
798}
799
800static void dabusb_disconnect (struct usb_interface *intf)
801{
802 wait_queue_t __wait;
803 pdabusb_t s = usb_get_intfdata (intf);
804
805 dbg("dabusb_disconnect");
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300806
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 init_waitqueue_entry(&__wait, current);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300808
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 usb_set_intfdata (intf, NULL);
810 if (s) {
811 usb_deregister_dev (intf, &dabusb_class);
812 s->remove_pending = 1;
813 wake_up (&s->wait);
814 add_wait_queue(&s->remove_ok, &__wait);
815 set_current_state(TASK_UNINTERRUPTIBLE);
816 if (s->state == _started)
817 schedule();
818 current->state = TASK_RUNNING;
819 remove_wait_queue(&s->remove_ok, &__wait);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300820
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 s->usbdev = NULL;
822 s->overruns = 0;
823 }
824}
825
826static struct usb_device_id dabusb_ids [] = {
827 // { USB_DEVICE(0x0547, 0x2131) }, /* An2131 chip, no boot ROM */
828 { USB_DEVICE(0x0547, 0x9999) },
829 { } /* Terminating entry */
830};
831
832MODULE_DEVICE_TABLE (usb, dabusb_ids);
833
834static struct usb_driver dabusb_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 .name = "dabusb",
836 .probe = dabusb_probe,
837 .disconnect = dabusb_disconnect,
838 .id_table = dabusb_ids,
839};
840
841/* --------------------------------------------------------------------- */
842
843static int __init dabusb_init (void)
844{
845 int retval;
846 unsigned u;
847
848 /* initialize struct */
849 for (u = 0; u < NRDABUSB; u++) {
850 pdabusb_t s = &dabusb[u];
851 memset (s, 0, sizeof (dabusb_t));
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100852 mutex_init (&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 s->usbdev = NULL;
854 s->total_buffer_size = buffers;
855 init_waitqueue_head (&s->wait);
856 init_waitqueue_head (&s->remove_ok);
857 spin_lock_init (&s->lock);
858 INIT_LIST_HEAD (&s->free_buff_list);
859 INIT_LIST_HEAD (&s->rec_buff_list);
860 }
861
862 /* register misc device */
863 retval = usb_register(&dabusb_driver);
864 if (retval)
865 goto out;
866
867 dbg("dabusb_init: driver registered");
868
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -0300869 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
870 DRIVER_DESC "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
872out:
873 return retval;
874}
875
876static void __exit dabusb_cleanup (void)
877{
878 dbg("dabusb_cleanup");
879
880 usb_deregister (&dabusb_driver);
881}
882
883/* --------------------------------------------------------------------- */
884
885MODULE_AUTHOR( DRIVER_AUTHOR );
886MODULE_DESCRIPTION( DRIVER_DESC );
887MODULE_LICENSE("GPL");
888
889module_param(buffers, int, 0);
890MODULE_PARM_DESC (buffers, "Number of buffers (default=256)");
891
892module_init (dabusb_init);
893module_exit (dabusb_cleanup);
894
895/* --------------------------------------------------------------------- */