blob: a525a924edfadaef9daf7076c3cf4e627900e186 [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
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300192 dev_err(&purb->dev->dev,
193 "dabusb_iso_complete: invalid len %d\n", len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 }
195 else
Greg Kroah-Hartmanaa826612008-08-14 09:37:34 -0700196 dev_warn(&purb->dev->dev, "dabusb_iso_complete: corrupted packet status: %d\n", purb->iso_frame_desc[i].status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 if (dst != purb->actual_length)
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300198 dev_err(&purb->dev->dev,
199 "dst!=purb->actual_length:%d!=%d\n",
200 dst, purb->actual_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 }
202
203 if (atomic_dec_and_test (&s->pending_io) && !s->remove_pending && s->state != _stopped) {
204 s->overruns++;
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300205 dev_err(&purb->dev->dev, "overrun (%d)\n", s->overruns);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 }
207 wake_up (&s->wait);
208}
209/*-------------------------------------------------------------------*/
210static int dabusb_alloc_buffers (pdabusb_t s)
211{
Harvey Harrison6f289672008-04-22 14:45:32 -0300212 int transfer_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 pbuff_t b;
214 unsigned int pipe = usb_rcvisocpipe (s->usbdev, _DABUSB_ISOPIPE);
215 int pipesize = usb_maxpacket (s->usbdev, pipe, usb_pipeout (pipe));
216 int packets = _ISOPIPESIZE / pipesize;
217 int transfer_buffer_length = packets * pipesize;
218 int i;
219
220 dbg("dabusb_alloc_buffers pipesize:%d packets:%d transfer_buffer_len:%d",
221 pipesize, packets, transfer_buffer_length);
222
Harvey Harrison6f289672008-04-22 14:45:32 -0300223 while (transfer_len < (s->total_buffer_size << 10)) {
Robert P. J. Day5cbded52006-12-13 00:35:56 -0800224 b = kzalloc(sizeof (buff_t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 if (!b) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300226 dev_err(&s->usbdev->dev,
227 "kzalloc(sizeof(buff_t))==NULL\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 goto err;
229 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 b->s = s;
231 b->purb = usb_alloc_urb(packets, GFP_KERNEL);
232 if (!b->purb) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300233 dev_err(&s->usbdev->dev, "usb_alloc_urb == NULL\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 kfree (b);
235 goto err;
236 }
237
238 b->purb->transfer_buffer = kmalloc (transfer_buffer_length, GFP_KERNEL);
239 if (!b->purb->transfer_buffer) {
240 kfree (b->purb);
241 kfree (b);
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300242 dev_err(&s->usbdev->dev,
243 "kmalloc(%d)==NULL\n", transfer_buffer_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 goto err;
245 }
246
247 b->purb->transfer_buffer_length = transfer_buffer_length;
248 b->purb->number_of_packets = packets;
249 b->purb->complete = dabusb_iso_complete;
250 b->purb->context = b;
251 b->purb->dev = s->usbdev;
252 b->purb->pipe = pipe;
253 b->purb->transfer_flags = URB_ISO_ASAP;
254
255 for (i = 0; i < packets; i++) {
256 b->purb->iso_frame_desc[i].offset = i * pipesize;
257 b->purb->iso_frame_desc[i].length = pipesize;
258 }
259
Harvey Harrison6f289672008-04-22 14:45:32 -0300260 transfer_len += transfer_buffer_length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 list_add_tail (&b->buff_list, &s->free_buff_list);
262 }
Harvey Harrison6f289672008-04-22 14:45:32 -0300263 s->got_mem = transfer_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
265 return 0;
266
267 err:
268 dabusb_free_buffers (s);
269 return -ENOMEM;
270}
271/*-------------------------------------------------------------------*/
272static int dabusb_bulk (pdabusb_t s, pbulk_transfer_t pb)
273{
274 int ret;
275 unsigned int pipe;
276 int actual_length;
277
278 dbg("dabusb_bulk");
279
280 if (!pb->pipe)
281 pipe = usb_rcvbulkpipe (s->usbdev, 2);
282 else
283 pipe = usb_sndbulkpipe (s->usbdev, 2);
284
285 ret=usb_bulk_msg(s->usbdev, pipe, pb->data, pb->size, &actual_length, 100);
286 if(ret<0) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300287 dev_err(&s->usbdev->dev,
288 "usb_bulk_msg failed(%d)\n", ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
290 if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300291 dev_err(&s->usbdev->dev, "set_interface failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 return -EINVAL;
293 }
294
295 }
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 if( ret == -EPIPE ) {
Greg Kroah-Hartmanaa826612008-08-14 09:37:34 -0700298 dev_warn(&s->usbdev->dev, "CLEAR_FEATURE request to remove STALL condition.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 if(usb_clear_halt(s->usbdev, usb_pipeendpoint(pipe)))
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300300 dev_err(&s->usbdev->dev, "request failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 }
302
303 pb->size = actual_length;
304 return ret;
305}
306/* --------------------------------------------------------------------- */
David Woodhousec4667742008-06-23 11:41:04 +0100307static int dabusb_writemem (pdabusb_t s, int pos, const unsigned char *data,
308 int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309{
310 int ret;
311 unsigned char *transfer_buffer = kmalloc (len, GFP_KERNEL);
312
313 if (!transfer_buffer) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300314 dev_err(&s->usbdev->dev,
315 "dabusb_writemem: kmalloc(%d) failed.\n", len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 return -ENOMEM;
317 }
318
319 memcpy (transfer_buffer, data, len);
320
321 ret=usb_control_msg(s->usbdev, usb_sndctrlpipe( s->usbdev, 0 ), 0xa0, 0x40, pos, 0, transfer_buffer, len, 300);
322
323 kfree (transfer_buffer);
324 return ret;
325}
326/* --------------------------------------------------------------------- */
327static int dabusb_8051_reset (pdabusb_t s, unsigned char reset_bit)
328{
329 dbg("dabusb_8051_reset: %d",reset_bit);
330 return dabusb_writemem (s, CPUCS_REG, &reset_bit, 1);
331}
332/* --------------------------------------------------------------------- */
333static int dabusb_loadmem (pdabusb_t s, const char *fname)
334{
335 int ret;
David Woodhousec4667742008-06-23 11:41:04 +0100336 const struct ihex_binrec *rec;
Mauro Carvalho Chehab031002d2009-03-26 12:24:46 -0300337 const struct firmware *uninitialized_var(fw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
339 dbg("Enter dabusb_loadmem (internal)");
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300340
David Woodhousec4667742008-06-23 11:41:04 +0100341 ret = request_ihex_firmware(&fw, "dabusb/firmware.fw", &s->usbdev->dev);
342 if (ret) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300343 dev_err(&s->usbdev->dev,
344 "Failed to load \"dabusb/firmware.fw\": %d\n", ret);
David Woodhousec4667742008-06-23 11:41:04 +0100345 goto out;
346 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 ret = dabusb_8051_reset (s, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
David Woodhousec4667742008-06-23 11:41:04 +0100349 for (rec = (const struct ihex_binrec *)fw->data; rec;
350 rec = ihex_next_binrec(rec)) {
351 dbg("dabusb_writemem: %04X %p %d)", be32_to_cpu(rec->addr),
352 rec->data, be16_to_cpu(rec->len));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
David Woodhousec4667742008-06-23 11:41:04 +0100354 ret = dabusb_writemem(s, be32_to_cpu(rec->addr), rec->data,
355 be16_to_cpu(rec->len));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 if (ret < 0) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300357 dev_err(&s->usbdev->dev,
358 "dabusb_writemem failed (%d %04X %p %d)\n",
359 ret, be32_to_cpu(rec->addr),
360 rec->data, be16_to_cpu(rec->len));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 break;
362 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 }
364 ret = dabusb_8051_reset (s, 0);
David Woodhousec4667742008-06-23 11:41:04 +0100365 release_firmware(fw);
366 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 dbg("dabusb_loadmem: exit");
368
369 return ret;
370}
371/* --------------------------------------------------------------------- */
372static int dabusb_fpga_clear (pdabusb_t s, pbulk_transfer_t b)
373{
374 b->size = 4;
375 b->data[0] = 0x2a;
376 b->data[1] = 0;
377 b->data[2] = 0;
378 b->data[3] = 0;
379
380 dbg("dabusb_fpga_clear");
381
382 return dabusb_bulk (s, b);
383}
384/* --------------------------------------------------------------------- */
385static int dabusb_fpga_init (pdabusb_t s, pbulk_transfer_t b)
386{
387 b->size = 4;
388 b->data[0] = 0x2c;
389 b->data[1] = 0;
390 b->data[2] = 0;
391 b->data[3] = 0;
392
393 dbg("dabusb_fpga_init");
394
395 return dabusb_bulk (s, b);
396}
397/* --------------------------------------------------------------------- */
398static int dabusb_fpga_download (pdabusb_t s, const char *fname)
399{
400 pbulk_transfer_t b = kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
David Woodhousec4667742008-06-23 11:41:04 +0100401 const struct firmware *fw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 unsigned int blen, n;
403 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
405 dbg("Enter dabusb_fpga_download (internal)");
406
407 if (!b) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300408 dev_err(&s->usbdev->dev,
409 "kmalloc(sizeof(bulk_transfer_t))==NULL\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 return -ENOMEM;
411 }
412
David Woodhousec4667742008-06-23 11:41:04 +0100413 ret = request_firmware(&fw, "dabusb/bitstream.bin", &s->usbdev->dev);
414 if (ret) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300415 dev_err(&s->usbdev->dev,
416 "Failed to load \"dabusb/bitstream.bin\": %d\n", ret);
Adrian Bunk02c02672008-08-28 01:04:30 +0300417 kfree(b);
David Woodhousec4667742008-06-23 11:41:04 +0100418 return ret;
419 }
420
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 b->pipe = 1;
422 ret = dabusb_fpga_clear (s, b);
423 mdelay (10);
David Woodhousec4667742008-06-23 11:41:04 +0100424 blen = fw->data[73] + (fw->data[72] << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
426 dbg("Bitstream len: %i", blen);
427
428 b->data[0] = 0x2b;
429 b->data[1] = 0;
430 b->data[2] = 0;
431 b->data[3] = 60;
432
433 for (n = 0; n <= blen + 60; n += 60) {
434 // some cclks for startup
435 b->size = 64;
David Woodhousec4667742008-06-23 11:41:04 +0100436 memcpy (b->data + 4, fw->data + 74 + n, 60);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 ret = dabusb_bulk (s, b);
438 if (ret < 0) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300439 dev_err(&s->usbdev->dev, "dabusb_bulk failed.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 break;
441 }
442 mdelay (1);
443 }
444
445 ret = dabusb_fpga_init (s, b);
446 kfree (b);
David Woodhousec4667742008-06-23 11:41:04 +0100447 release_firmware(fw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
449 dbg("exit dabusb_fpga_download");
450
451 return ret;
452}
453
454static int dabusb_stop (pdabusb_t s)
455{
456 dbg("dabusb_stop");
457
458 s->state = _stopped;
459 dabusb_cancel_queue (s, &s->rec_buff_list);
460
461 dbg("pending_io: %d", s->pending_io.counter);
462
463 s->pending_io.counter = 0;
464 return 0;
465}
466
467static int dabusb_startrek (pdabusb_t s)
468{
469 if (!s->got_mem && s->state != _started) {
470
471 dbg("dabusb_startrek");
472
473 if (dabusb_alloc_buffers (s) < 0)
474 return -ENOMEM;
475 dabusb_stop (s);
476 s->state = _started;
477 s->readptr = 0;
478 }
479
480 if (!list_empty (&s->free_buff_list)) {
481 pbuff_t end;
482 int ret;
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300483
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 while (!dabusb_add_buf_tail (s, &s->rec_buff_list, &s->free_buff_list)) {
485
486 dbg("submitting: end:%p s->rec_buff_list:%p", s->rec_buff_list.prev, &s->rec_buff_list);
487
488 end = list_entry (s->rec_buff_list.prev, buff_t, buff_list);
489
490 ret = usb_submit_urb (end->purb, GFP_KERNEL);
491 if (ret) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300492 dev_err(&s->usbdev->dev,
493 "usb_submit_urb returned:%d\n", ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300495 dev_err(&s->usbdev->dev,
496 "startrek: dabusb_add_buf_tail failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 break;
498 }
499 else
500 atomic_inc (&s->pending_io);
501 }
502 dbg("pending_io: %d",s->pending_io.counter);
503 }
504
505 return 0;
506}
507
508static ssize_t dabusb_read (struct file *file, char __user *buf, size_t count, loff_t * ppos)
509{
510 pdabusb_t s = (pdabusb_t) file->private_data;
511 unsigned long flags;
512 unsigned ret = 0;
513 int rem;
514 int cnt;
515 pbuff_t b;
516 struct urb *purb = NULL;
517
518 dbg("dabusb_read");
519
520 if (*ppos)
521 return -ESPIPE;
522
523 if (s->remove_pending)
524 return -EIO;
525
526
527 if (!s->usbdev)
528 return -EIO;
529
530 while (count > 0) {
531 dabusb_startrek (s);
532
533 spin_lock_irqsave (&s->lock, flags);
534
535 if (list_empty (&s->rec_buff_list)) {
536
537 spin_unlock_irqrestore(&s->lock, flags);
538
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300539 dev_err(&s->usbdev->dev,
540 "error: rec_buf_list is empty\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 goto err;
542 }
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300543
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 b = list_entry (s->rec_buff_list.next, buff_t, buff_list);
545 purb = b->purb;
546
547 spin_unlock_irqrestore(&s->lock, flags);
548
549 if (purb->status == -EINPROGRESS) {
550 if (file->f_flags & O_NONBLOCK) // return nonblocking
551 {
552 if (!ret)
553 ret = -EAGAIN;
554 goto err;
555 }
556
557 interruptible_sleep_on (&s->wait);
558
559 if (signal_pending (current)) {
560 if (!ret)
561 ret = -ERESTARTSYS;
562 goto err;
563 }
564
565 spin_lock_irqsave (&s->lock, flags);
566
567 if (list_empty (&s->rec_buff_list)) {
568 spin_unlock_irqrestore(&s->lock, flags);
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300569 dev_err(&s->usbdev->dev,
570 "error: still no buffer available.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 goto err;
572 }
573 spin_unlock_irqrestore(&s->lock, flags);
574 s->readptr = 0;
575 }
576 if (s->remove_pending) {
577 ret = -EIO;
578 goto err;
579 }
580
581 rem = purb->actual_length - s->readptr; // set remaining bytes to copy
582
583 if (count >= rem)
584 cnt = rem;
585 else
586 cnt = count;
587
588 dbg("copy_to_user:%p %p %d",buf, purb->transfer_buffer + s->readptr, cnt);
589
590 if (copy_to_user (buf, purb->transfer_buffer + s->readptr, cnt)) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300591 dev_err(&s->usbdev->dev, "read: copy_to_user failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 if (!ret)
593 ret = -EFAULT;
594 goto err;
595 }
596
597 s->readptr += cnt;
598 count -= cnt;
599 buf += cnt;
600 ret += cnt;
601
602 if (s->readptr == purb->actual_length) {
603 // finished, take next buffer
604 if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300605 dev_err(&s->usbdev->dev,
606 "read: dabusb_add_buf_tail failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 s->readptr = 0;
608 }
609 }
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100610 err: //mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 return ret;
612}
613
614static int dabusb_open (struct inode *inode, struct file *file)
615{
616 int devnum = iminor(inode);
617 pdabusb_t s;
618
619 if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB))
620 return -EIO;
621
622 s = &dabusb[devnum - DABUSB_MINOR];
623
624 dbg("dabusb_open");
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100625 mutex_lock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626
627 while (!s->usbdev || s->opened) {
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100628 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
630 if (file->f_flags & O_NONBLOCK) {
631 return -EBUSY;
632 }
633 msleep_interruptible(500);
634
635 if (signal_pending (current)) {
636 return -EAGAIN;
637 }
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100638 mutex_lock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 }
640 if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100641 mutex_unlock(&s->mutex);
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300642 dev_err(&s->usbdev->dev, "set_interface failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 return -EINVAL;
644 }
645 s->opened = 1;
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100646 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
648 file->f_pos = 0;
649 file->private_data = s;
650
651 return nonseekable_open(inode, file);
652}
653
654static int dabusb_release (struct inode *inode, struct file *file)
655{
656 pdabusb_t s = (pdabusb_t) file->private_data;
657
658 dbg("dabusb_release");
659
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100660 mutex_lock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 dabusb_stop (s);
662 dabusb_free_buffers (s);
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100663 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
665 if (!s->remove_pending) {
666 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0)
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300667 dev_err(&s->usbdev->dev, "set_interface failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 }
669 else
670 wake_up (&s->remove_ok);
671
672 s->opened = 0;
673 return 0;
674}
675
676static int dabusb_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
677{
678 pdabusb_t s = (pdabusb_t) file->private_data;
679 pbulk_transfer_t pbulk;
680 int ret = 0;
681 int version = DABUSB_VERSION;
682
683 dbg("dabusb_ioctl");
684
685 if (s->remove_pending)
686 return -EIO;
687
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100688 mutex_lock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
690 if (!s->usbdev) {
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100691 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 return -EIO;
693 }
694
695 switch (cmd) {
696
697 case IOCTL_DAB_BULK:
Robert P. J. Day5cbded52006-12-13 00:35:56 -0800698 pbulk = kmalloc(sizeof (bulk_transfer_t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
700 if (!pbulk) {
701 ret = -ENOMEM;
702 break;
703 }
704
705 if (copy_from_user (pbulk, (void __user *) arg, sizeof (bulk_transfer_t))) {
706 ret = -EFAULT;
707 kfree (pbulk);
708 break;
709 }
710
711 ret=dabusb_bulk (s, pbulk);
712 if(ret==0)
713 if (copy_to_user((void __user *)arg, pbulk,
714 sizeof(bulk_transfer_t)))
715 ret = -EFAULT;
716 kfree (pbulk);
717 break;
718
719 case IOCTL_DAB_OVERRUNS:
720 ret = put_user (s->overruns, (unsigned int __user *) arg);
721 break;
722
723 case IOCTL_DAB_VERSION:
724 ret = put_user (version, (unsigned int __user *) arg);
725 break;
726
727 default:
728 ret = -ENOIOCTLCMD;
729 break;
730 }
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100731 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 return ret;
733}
734
Arjan van de Venfa027c22007-02-12 00:55:33 -0800735static const struct file_operations dabusb_fops =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736{
737 .owner = THIS_MODULE,
738 .llseek = no_llseek,
739 .read = dabusb_read,
740 .ioctl = dabusb_ioctl,
741 .open = dabusb_open,
742 .release = dabusb_release,
743};
744
745static struct usb_class_driver dabusb_class = {
Greg Kroah-Hartmand6e5bcf2005-06-20 21:15:16 -0700746 .name = "dabusb%d",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 .fops = &dabusb_fops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 .minor_base = DABUSB_MINOR,
749};
750
751
752/* --------------------------------------------------------------------- */
753static int dabusb_probe (struct usb_interface *intf,
754 const struct usb_device_id *id)
755{
756 struct usb_device *usbdev = interface_to_usbdev(intf);
757 int retval;
758 pdabusb_t s;
759
760 dbg("dabusb: probe: vendor id 0x%x, device id 0x%x ifnum:%d",
761 le16_to_cpu(usbdev->descriptor.idVendor),
762 le16_to_cpu(usbdev->descriptor.idProduct),
763 intf->altsetting->desc.bInterfaceNumber);
764
765 /* We don't handle multiple configurations */
766 if (usbdev->descriptor.bNumConfigurations != 1)
767 return -ENODEV;
768
769 if (intf->altsetting->desc.bInterfaceNumber != _DABUSB_IF &&
770 le16_to_cpu(usbdev->descriptor.idProduct) == 0x9999)
771 return -ENODEV;
772
773
774
775 s = &dabusb[intf->minor];
776
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100777 mutex_lock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 s->remove_pending = 0;
779 s->usbdev = usbdev;
780 s->devnum = intf->minor;
781
782 if (usb_reset_configuration (usbdev) < 0) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300783 dev_err(&intf->dev, "reset_configuration failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 goto reject;
785 }
786 if (le16_to_cpu(usbdev->descriptor.idProduct) == 0x2131) {
787 dabusb_loadmem (s, NULL);
788 goto reject;
789 }
790 else {
791 dabusb_fpga_download (s, NULL);
792
793 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0) {
Mauro Carvalho Chehabbe9ed512009-01-08 09:13:42 -0300794 dev_err(&intf->dev, "set_interface failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 goto reject;
796 }
797 }
798 dbg("bound to interface: %d", intf->altsetting->desc.bInterfaceNumber);
799 usb_set_intfdata (intf, s);
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100800 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
802 retval = usb_register_dev(intf, &dabusb_class);
803 if (retval) {
804 usb_set_intfdata (intf, NULL);
805 return -ENOMEM;
806 }
807
808 return 0;
809
810 reject:
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100811 mutex_unlock(&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 s->usbdev = NULL;
813 return -ENODEV;
814}
815
816static void dabusb_disconnect (struct usb_interface *intf)
817{
818 wait_queue_t __wait;
819 pdabusb_t s = usb_get_intfdata (intf);
820
821 dbg("dabusb_disconnect");
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300822
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 init_waitqueue_entry(&__wait, current);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300824
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 usb_set_intfdata (intf, NULL);
826 if (s) {
827 usb_deregister_dev (intf, &dabusb_class);
828 s->remove_pending = 1;
829 wake_up (&s->wait);
830 add_wait_queue(&s->remove_ok, &__wait);
831 set_current_state(TASK_UNINTERRUPTIBLE);
832 if (s->state == _started)
833 schedule();
834 current->state = TASK_RUNNING;
835 remove_wait_queue(&s->remove_ok, &__wait);
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300836
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 s->usbdev = NULL;
838 s->overruns = 0;
839 }
840}
841
842static struct usb_device_id dabusb_ids [] = {
843 // { USB_DEVICE(0x0547, 0x2131) }, /* An2131 chip, no boot ROM */
844 { USB_DEVICE(0x0547, 0x9999) },
845 { } /* Terminating entry */
846};
847
848MODULE_DEVICE_TABLE (usb, dabusb_ids);
849
850static struct usb_driver dabusb_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 .name = "dabusb",
852 .probe = dabusb_probe,
853 .disconnect = dabusb_disconnect,
854 .id_table = dabusb_ids,
855};
856
857/* --------------------------------------------------------------------- */
858
859static int __init dabusb_init (void)
860{
861 int retval;
862 unsigned u;
863
864 /* initialize struct */
865 for (u = 0; u < NRDABUSB; u++) {
866 pdabusb_t s = &dabusb[u];
867 memset (s, 0, sizeof (dabusb_t));
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100868 mutex_init (&s->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 s->usbdev = NULL;
870 s->total_buffer_size = buffers;
871 init_waitqueue_head (&s->wait);
872 init_waitqueue_head (&s->remove_ok);
873 spin_lock_init (&s->lock);
874 INIT_LIST_HEAD (&s->free_buff_list);
875 INIT_LIST_HEAD (&s->rec_buff_list);
876 }
877
878 /* register misc device */
879 retval = usb_register(&dabusb_driver);
880 if (retval)
881 goto out;
882
883 dbg("dabusb_init: driver registered");
884
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -0300885 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
886 DRIVER_DESC "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
888out:
889 return retval;
890}
891
892static void __exit dabusb_cleanup (void)
893{
894 dbg("dabusb_cleanup");
895
896 usb_deregister (&dabusb_driver);
897}
898
899/* --------------------------------------------------------------------- */
900
901MODULE_AUTHOR( DRIVER_AUTHOR );
902MODULE_DESCRIPTION( DRIVER_DESC );
903MODULE_LICENSE("GPL");
904
905module_param(buffers, int, 0);
906MODULE_PARM_DESC (buffers, "Number of buffers (default=256)");
907
908module_init (dabusb_init);
909module_exit (dabusb_cleanup);
910
911/* --------------------------------------------------------------------- */