aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorHans Verkuil <hverkuil@xs4all.nl>2011-02-05 07:29:31 -0500
committerMauro Carvalho Chehab <mchehab@redhat.com>2011-03-21 19:32:11 -0400
commitdae86ccbc3c185aebfc396e8e668aa3d73d748d8 (patch)
tree1a60e4e16b445dd00b905c728870069c55a93f15
parentb287db119edb92548b53f63f05fd593c43cba200 (diff)
[media] dabusb: remove obsolete driver
The dabusb driver was conceived as an experimental driver for a test device. The driver never supported any shipped product, and, while there were some updates for it in 2003, for an ancient product, those changes were never submitted upstream. Also, there's no DocBook for its API, nor any upstream discussion. So it was decided to remove it in 2.6.39. Future support for a DAB API should be discussed on the linux-media list first. Signed-off-by: Hans Verkuil <hverkuil@xs4all.nl> Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Diffstat
-rw-r--r--drivers/staging/Kconfig2
-rw-r--r--drivers/staging/Makefile1
-rw-r--r--drivers/staging/dabusb/Kconfig14
-rw-r--r--drivers/staging/dabusb/Makefile2
-rw-r--r--drivers/staging/dabusb/TODO5
-rw-r--r--drivers/staging/dabusb/dabusb.c914
-rw-r--r--drivers/staging/dabusb/dabusb.h85
7 files changed, 0 insertions, 1023 deletions
diff --git a/drivers/staging/Kconfig b/drivers/staging/Kconfig
index fa5c007e74c8..a2742d8102c1 100644
--- a/drivers/staging/Kconfig
+++ b/drivers/staging/Kconfig
@@ -53,8 +53,6 @@ source "drivers/staging/tm6000/Kconfig"
53 53
54source "drivers/staging/cxd2099/Kconfig" 54source "drivers/staging/cxd2099/Kconfig"
55 55
56source "drivers/staging/dabusb/Kconfig"
57
58source "drivers/staging/usbip/Kconfig" 56source "drivers/staging/usbip/Kconfig"
59 57
60source "drivers/staging/winbond/Kconfig" 58source "drivers/staging/winbond/Kconfig"
diff --git a/drivers/staging/Makefile b/drivers/staging/Makefile
index 2bdd703ed208..4ddd3ce780e0 100644
--- a/drivers/staging/Makefile
+++ b/drivers/staging/Makefile
@@ -9,7 +9,6 @@ obj-$(CONFIG_VIDEO_GO7007) += go7007/
9obj-$(CONFIG_VIDEO_CX25821) += cx25821/ 9obj-$(CONFIG_VIDEO_CX25821) += cx25821/
10obj-$(CONFIG_VIDEO_TM6000) += tm6000/ 10obj-$(CONFIG_VIDEO_TM6000) += tm6000/
11obj-$(CONFIG_DVB_CXD2099) += cxd2099/ 11obj-$(CONFIG_DVB_CXD2099) += cxd2099/
12obj-$(CONFIG_USB_DABUSB) += dabusb/
13obj-$(CONFIG_LIRC_STAGING) += lirc/ 12obj-$(CONFIG_LIRC_STAGING) += lirc/
14obj-$(CONFIG_USB_IP_COMMON) += usbip/ 13obj-$(CONFIG_USB_IP_COMMON) += usbip/
15obj-$(CONFIG_W35UND) += winbond/ 14obj-$(CONFIG_W35UND) += winbond/
diff --git a/drivers/staging/dabusb/Kconfig b/drivers/staging/dabusb/Kconfig
deleted file mode 100644
index 87bdc425d3c5..000000000000
--- a/drivers/staging/dabusb/Kconfig
+++ /dev/null
@@ -1,14 +0,0 @@
1config USB_DABUSB
2 tristate "DABUSB driver"
3 depends on USB
4 ---help---
5 A Digital Audio Broadcasting (DAB) Receiver for USB and Linux
6 brought to you by the DAB-Team
7 <http://wwwbode.cs.tum.edu/Par/arch/dab/>. This driver can be taken
8 as an example for URB-based bulk, control, and isochronous
9 transactions. URB's are explained in
10 <Documentation/usb/URB.txt>.
11
12 To compile this driver as a module, choose M here: the
13 module will be called dabusb.
14
diff --git a/drivers/staging/dabusb/Makefile b/drivers/staging/dabusb/Makefile
deleted file mode 100644
index 2ff2f228e5f9..000000000000
--- a/drivers/staging/dabusb/Makefile
+++ /dev/null
@@ -1,2 +0,0 @@
1obj-$(CONFIG_USB_DABUSB) += dabusb.o
2
diff --git a/drivers/staging/dabusb/TODO b/drivers/staging/dabusb/TODO
deleted file mode 100644
index f9c0314ea0c1..000000000000
--- a/drivers/staging/dabusb/TODO
+++ /dev/null
@@ -1,5 +0,0 @@
1This is a driver for an experimental sample developed in 2003. The driver
2never supported any commercial product, nor had any known user.
3If nobody takes care on it, the driver will be removed for 2.6.39.
4
5Please send patches to linux-media@vger.kernel.org
diff --git a/drivers/staging/dabusb/dabusb.c b/drivers/staging/dabusb/dabusb.c
deleted file mode 100644
index f3e25e91366d..000000000000
--- a/drivers/staging/dabusb/dabusb.c
+++ /dev/null
@@ -1,914 +0,0 @@
1/*****************************************************************************/
2
3/*
4 * dabusb.c -- dab usb driver.
5 *
6 * Copyright (C) 1999 Deti Fliegl (deti@fliegl.de)
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 *
22 *
23 *
24 * $Id: dabusb.c,v 1.54 2000/07/24 21:39:39 deti Exp $
25 *
26 */
27
28/*****************************************************************************/
29
30#include <linux/module.h>
31#include <linux/socket.h>
32#include <linux/list.h>
33#include <linux/vmalloc.h>
34#include <linux/slab.h>
35#include <linux/init.h>
36#include <asm/uaccess.h>
37#include <asm/atomic.h>
38#include <linux/delay.h>
39#include <linux/usb.h>
40#include <linux/mutex.h>
41#include <linux/firmware.h>
42#include <linux/ihex.h>
43
44#include "dabusb.h"
45
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/*-------------------------------------------------------------------*/
89#ifdef DEBUG
90static 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
139#ifdef DEBUG
140 dump_urb(b->purb);
141#endif
142 kfree(b->purb->transfer_buffer);
143 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/*-------------------------------------------------------------------*/
169static void dabusb_iso_complete (struct urb *purb)
170{
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 dev_err(&purb->dev->dev,
193 "dabusb_iso_complete: invalid len %d\n", len);
194 }
195 else
196 dev_warn(&purb->dev->dev, "dabusb_iso_complete: corrupted packet status: %d\n", purb->iso_frame_desc[i].status);
197 if (dst != purb->actual_length)
198 dev_err(&purb->dev->dev,
199 "dst!=purb->actual_length:%d!=%d\n",
200 dst, purb->actual_length);
201 }
202
203 if (atomic_dec_and_test (&s->pending_io) && !s->remove_pending && s->state != _stopped) {
204 s->overruns++;
205 dev_err(&purb->dev->dev, "overrun (%d)\n", s->overruns);
206 }
207 wake_up (&s->wait);
208}
209/*-------------------------------------------------------------------*/
210static int dabusb_alloc_buffers (pdabusb_t s)
211{
212 int transfer_len = 0;
213 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
223 while (transfer_len < (s->total_buffer_size << 10)) {
224 b = kzalloc(sizeof (buff_t), GFP_KERNEL);
225 if (!b) {
226 dev_err(&s->usbdev->dev,
227 "kzalloc(sizeof(buff_t))==NULL\n");
228 goto err;
229 }
230 b->s = s;
231 b->purb = usb_alloc_urb(packets, GFP_KERNEL);
232 if (!b->purb) {
233 dev_err(&s->usbdev->dev, "usb_alloc_urb == NULL\n");
234 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);
242 dev_err(&s->usbdev->dev,
243 "kmalloc(%d)==NULL\n", transfer_buffer_length);
244 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
260 transfer_len += transfer_buffer_length;
261 list_add_tail (&b->buff_list, &s->free_buff_list);
262 }
263 s->got_mem = transfer_len;
264
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) {
287 dev_err(&s->usbdev->dev,
288 "usb_bulk_msg failed(%d)\n", ret);
289
290 if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
291 dev_err(&s->usbdev->dev, "set_interface failed\n");
292 return -EINVAL;
293 }
294
295 }
296
297 if( ret == -EPIPE ) {
298 dev_warn(&s->usbdev->dev, "CLEAR_FEATURE request to remove STALL condition.\n");
299 if(usb_clear_halt(s->usbdev, usb_pipeendpoint(pipe)))
300 dev_err(&s->usbdev->dev, "request failed\n");
301 }
302
303 pb->size = actual_length;
304 return ret;
305}
306/* --------------------------------------------------------------------- */
307static int dabusb_writemem (pdabusb_t s, int pos, const unsigned char *data,
308 int len)
309{
310 int ret;
311 unsigned char *transfer_buffer = kmalloc (len, GFP_KERNEL);
312
313 if (!transfer_buffer) {
314 dev_err(&s->usbdev->dev,
315 "dabusb_writemem: kmalloc(%d) failed.\n", len);
316 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;
336 const struct ihex_binrec *rec;
337 const struct firmware *uninitialized_var(fw);
338
339 dbg("Enter dabusb_loadmem (internal)");
340
341 ret = request_ihex_firmware(&fw, "dabusb/firmware.fw", &s->usbdev->dev);
342 if (ret) {
343 dev_err(&s->usbdev->dev,
344 "Failed to load \"dabusb/firmware.fw\": %d\n", ret);
345 goto out;
346 }
347 ret = dabusb_8051_reset (s, 1);
348
349 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));
353
354 ret = dabusb_writemem(s, be32_to_cpu(rec->addr), rec->data,
355 be16_to_cpu(rec->len));
356 if (ret < 0) {
357 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));
361 break;
362 }
363 }
364 ret = dabusb_8051_reset (s, 0);
365 release_firmware(fw);
366 out:
367 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);
401 const struct firmware *fw;
402 unsigned int blen, n;
403 int ret;
404
405 dbg("Enter dabusb_fpga_download (internal)");
406
407 if (!b) {
408 dev_err(&s->usbdev->dev,
409 "kmalloc(sizeof(bulk_transfer_t))==NULL\n");
410 return -ENOMEM;
411 }
412
413 ret = request_firmware(&fw, "dabusb/bitstream.bin", &s->usbdev->dev);
414 if (ret) {
415 dev_err(&s->usbdev->dev,
416 "Failed to load \"dabusb/bitstream.bin\": %d\n", ret);
417 kfree(b);
418 return ret;
419 }
420
421 b->pipe = 1;
422 ret = dabusb_fpga_clear (s, b);
423 mdelay (10);
424 blen = fw->data[73] + (fw->data[72] << 8);
425
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;
436 memcpy (b->data + 4, fw->data + 74 + n, 60);
437 ret = dabusb_bulk (s, b);
438 if (ret < 0) {
439 dev_err(&s->usbdev->dev, "dabusb_bulk failed.\n");
440 break;
441 }
442 mdelay (1);
443 }
444
445 ret = dabusb_fpga_init (s, b);
446 kfree (b);
447 release_firmware(fw);
448
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;
483
484 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) {
492 dev_err(&s->usbdev->dev,
493 "usb_submit_urb returned:%d\n", ret);
494 if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
495 dev_err(&s->usbdev->dev,
496 "startrek: dabusb_add_buf_tail failed\n");
497 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
539 dev_err(&s->usbdev->dev,
540 "error: rec_buf_list is empty\n");
541 goto err;
542 }
543
544 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);
569 dev_err(&s->usbdev->dev,
570 "error: still no buffer available.\n");
571 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)) {
591 dev_err(&s->usbdev->dev, "read: copy_to_user failed\n");
592 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))
605 dev_err(&s->usbdev->dev,
606 "read: dabusb_add_buf_tail failed\n");
607 s->readptr = 0;
608 }
609 }
610 err: //mutex_unlock(&s->mutex);
611 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 int r;
619
620 if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB))
621 return -EIO;
622
623 s = &dabusb[devnum - DABUSB_MINOR];
624
625 dbg("dabusb_open");
626 mutex_lock(&s->mutex);
627
628 while (!s->usbdev || s->opened) {
629 mutex_unlock(&s->mutex);
630
631 if (file->f_flags & O_NONBLOCK)
632 return -EBUSY;
633 msleep_interruptible(500);
634
635 if (signal_pending (current))
636 return -EAGAIN;
637 mutex_lock(&s->mutex);
638 }
639 if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
640 mutex_unlock(&s->mutex);
641 dev_err(&s->usbdev->dev, "set_interface failed\n");
642 return -EINVAL;
643 }
644 s->opened = 1;
645 mutex_unlock(&s->mutex);
646
647 file->f_pos = 0;
648 file->private_data = s;
649
650 r = nonseekable_open(inode, file);
651 return r;
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
660 mutex_lock(&s->mutex);
661 dabusb_stop (s);
662 dabusb_free_buffers (s);
663 mutex_unlock(&s->mutex);
664
665 if (!s->remove_pending) {
666 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0)
667 dev_err(&s->usbdev->dev, "set_interface failed\n");
668 }
669 else
670 wake_up (&s->remove_ok);
671
672 s->opened = 0;
673 return 0;
674}
675
676static long dabusb_ioctl (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
688 mutex_lock(&s->mutex);
689
690 if (!s->usbdev) {
691 mutex_unlock(&s->mutex);
692 return -EIO;
693 }
694
695 switch (cmd) {
696
697 case IOCTL_DAB_BULK:
698 pbulk = memdup_user((void __user *)arg,
699 sizeof(bulk_transfer_t));
700
701 if (IS_ERR(pbulk)) {
702 ret = PTR_ERR(pbulk);
703 break;
704 }
705
706 ret=dabusb_bulk (s, pbulk);
707 if(ret==0)
708 if (copy_to_user((void __user *)arg, pbulk,
709 sizeof(bulk_transfer_t)))
710 ret = -EFAULT;
711 kfree (pbulk);
712 break;
713
714 case IOCTL_DAB_OVERRUNS:
715 ret = put_user (s->overruns, (unsigned int __user *) arg);
716 break;
717
718 case IOCTL_DAB_VERSION:
719 ret = put_user (version, (unsigned int __user *) arg);
720 break;
721
722 default:
723 ret = -ENOIOCTLCMD;
724 break;
725 }
726 mutex_unlock(&s->mutex);
727 return ret;
728}
729
730static const struct file_operations dabusb_fops =
731{
732 .owner = THIS_MODULE,
733 .llseek = no_llseek,
734 .read = dabusb_read,
735 .unlocked_ioctl = dabusb_ioctl,
736 .open = dabusb_open,
737 .release = dabusb_release,
738};
739
740static char *dabusb_devnode(struct device *dev, mode_t *mode)
741{
742 return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
743}
744
745static struct usb_class_driver dabusb_class = {
746 .name = "dabusb%d",
747 .devnode = dabusb_devnode,
748 .fops = &dabusb_fops,
749 .minor_base = DABUSB_MINOR,
750};
751
752
753/* --------------------------------------------------------------------- */
754static int dabusb_probe (struct usb_interface *intf,
755 const struct usb_device_id *id)
756{
757 struct usb_device *usbdev = interface_to_usbdev(intf);
758 int retval;
759 pdabusb_t s;
760
761 dbg("dabusb: probe: vendor id 0x%x, device id 0x%x ifnum:%d",
762 le16_to_cpu(usbdev->descriptor.idVendor),
763 le16_to_cpu(usbdev->descriptor.idProduct),
764 intf->altsetting->desc.bInterfaceNumber);
765
766 /* We don't handle multiple configurations */
767 if (usbdev->descriptor.bNumConfigurations != 1)
768 return -ENODEV;
769
770 if (intf->altsetting->desc.bInterfaceNumber != _DABUSB_IF &&
771 le16_to_cpu(usbdev->descriptor.idProduct) == 0x9999)
772 return -ENODEV;
773
774
775
776 s = &dabusb[intf->minor];
777
778 mutex_lock(&s->mutex);
779 s->remove_pending = 0;
780 s->usbdev = usbdev;
781 s->devnum = intf->minor;
782
783 if (usb_reset_configuration (usbdev) < 0) {
784 dev_err(&intf->dev, "reset_configuration failed\n");
785 goto reject;
786 }
787 if (le16_to_cpu(usbdev->descriptor.idProduct) == 0x2131) {
788 dabusb_loadmem (s, NULL);
789 goto reject;
790 }
791 else {
792 dabusb_fpga_download (s, NULL);
793
794 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0) {
795 dev_err(&intf->dev, "set_interface failed\n");
796 goto reject;
797 }
798 }
799 dbg("bound to interface: %d", intf->altsetting->desc.bInterfaceNumber);
800 usb_set_intfdata (intf, s);
801 mutex_unlock(&s->mutex);
802
803 retval = usb_register_dev(intf, &dabusb_class);
804 if (retval) {
805 usb_set_intfdata (intf, NULL);
806 return -ENOMEM;
807 }
808
809 return 0;
810
811 reject:
812 mutex_unlock(&s->mutex);
813 s->usbdev = NULL;
814 return -ENODEV;
815}
816
817static void dabusb_disconnect (struct usb_interface *intf)
818{
819 wait_queue_t __wait;
820 pdabusb_t s = usb_get_intfdata (intf);
821
822 dbg("dabusb_disconnect");
823
824 init_waitqueue_entry(&__wait, current);
825
826 usb_set_intfdata (intf, NULL);
827 if (s) {
828 usb_deregister_dev (intf, &dabusb_class);
829 s->remove_pending = 1;
830 wake_up (&s->wait);
831 add_wait_queue(&s->remove_ok, &__wait);
832 set_current_state(TASK_UNINTERRUPTIBLE);
833 if (s->state == _started)
834 schedule();
835 current->state = TASK_RUNNING;
836 remove_wait_queue(&s->remove_ok, &__wait);
837
838 s->usbdev = NULL;
839 s->overruns = 0;
840 }
841}
842
843static struct usb_device_id dabusb_ids [] = {
844 // { USB_DEVICE(0x0547, 0x2131) }, /* An2131 chip, no boot ROM */
845 { USB_DEVICE(0x0547, 0x9999) },
846 { } /* Terminating entry */
847};
848
849MODULE_DEVICE_TABLE (usb, dabusb_ids);
850
851static struct usb_driver dabusb_driver = {
852 .name = "dabusb",
853 .probe = dabusb_probe,
854 .disconnect = dabusb_disconnect,
855 .id_table = dabusb_ids,
856};
857
858/* --------------------------------------------------------------------- */
859
860static int __init dabusb_init (void)
861{
862 int retval;
863 unsigned u;
864
865 /* initialize struct */
866 for (u = 0; u < NRDABUSB; u++) {
867 pdabusb_t s = &dabusb[u];
868 memset (s, 0, sizeof (dabusb_t));
869 mutex_init (&s->mutex);
870 s->usbdev = NULL;
871 s->total_buffer_size = buffers;
872 init_waitqueue_head (&s->wait);
873 init_waitqueue_head (&s->remove_ok);
874 spin_lock_init (&s->lock);
875 INIT_LIST_HEAD (&s->free_buff_list);
876 INIT_LIST_HEAD (&s->rec_buff_list);
877 }
878
879 /* register misc device */
880 retval = usb_register(&dabusb_driver);
881 if (retval)
882 goto out;
883
884 dbg("dabusb_init: driver registered");
885
886 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
887 DRIVER_DESC "\n");
888
889out:
890 return retval;
891}
892
893static void __exit dabusb_cleanup (void)
894{
895 dbg("dabusb_cleanup");
896
897 usb_deregister (&dabusb_driver);
898}
899
900/* --------------------------------------------------------------------- */
901
902MODULE_AUTHOR( DRIVER_AUTHOR );
903MODULE_DESCRIPTION( DRIVER_DESC );
904MODULE_LICENSE("GPL");
905MODULE_FIRMWARE("dabusb/firmware.fw");
906MODULE_FIRMWARE("dabusb/bitstream.bin");
907
908module_param(buffers, int, 0);
909MODULE_PARM_DESC (buffers, "Number of buffers (default=256)");
910
911module_init (dabusb_init);
912module_exit (dabusb_cleanup);
913
914/* --------------------------------------------------------------------- */
diff --git a/drivers/staging/dabusb/dabusb.h b/drivers/staging/dabusb/dabusb.h
deleted file mode 100644
index 00eb34c863eb..000000000000
--- a/drivers/staging/dabusb/dabusb.h
+++ /dev/null
@@ -1,85 +0,0 @@
1#define _BULK_DATA_LEN 64
2typedef struct
3{
4 unsigned char data[_BULK_DATA_LEN];
5 unsigned int size;
6 unsigned int pipe;
7}bulk_transfer_t,*pbulk_transfer_t;
8
9#define DABUSB_MINOR 240 /* some unassigned USB minor */
10#define DABUSB_VERSION 0x1000
11#define IOCTL_DAB_BULK _IOWR('d', 0x30, bulk_transfer_t)
12#define IOCTL_DAB_OVERRUNS _IOR('d', 0x15, int)
13#define IOCTL_DAB_VERSION _IOR('d', 0x3f, int)
14
15#ifdef __KERNEL__
16
17typedef enum { _stopped=0, _started } driver_state_t;
18
19typedef struct
20{
21 struct mutex mutex;
22 struct usb_device *usbdev;
23 wait_queue_head_t wait;
24 wait_queue_head_t remove_ok;
25 spinlock_t lock;
26 atomic_t pending_io;
27 driver_state_t state;
28 int remove_pending;
29 int got_mem;
30 int total_buffer_size;
31 unsigned int overruns;
32 int readptr;
33 int opened;
34 int devnum;
35 struct list_head free_buff_list;
36 struct list_head rec_buff_list;
37} dabusb_t,*pdabusb_t;
38
39typedef struct
40{
41 pdabusb_t s;
42 struct urb *purb;
43 struct list_head buff_list;
44} buff_t,*pbuff_t;
45
46typedef struct
47{
48 wait_queue_head_t wait;
49} bulk_completion_context_t, *pbulk_completion_context_t;
50
51
52#define _DABUSB_IF 2
53#define _DABUSB_ISOPIPE 0x09
54#define _ISOPIPESIZE 16384
55
56#define _BULK_DATA_LEN 64
57// Vendor specific request code for Anchor Upload/Download
58// This one is implemented in the core
59#define ANCHOR_LOAD_INTERNAL 0xA0
60
61// EZ-USB Control and Status Register. Bit 0 controls 8051 reset
62#define CPUCS_REG 0x7F92
63#define _TOTAL_BUFFERS 384
64
65#define MAX_INTEL_HEX_RECORD_LENGTH 16
66
67#ifndef _BYTE_DEFINED
68#define _BYTE_DEFINED
69typedef unsigned char BYTE;
70#endif // !_BYTE_DEFINED
71
72#ifndef _WORD_DEFINED
73#define _WORD_DEFINED
74typedef unsigned short WORD;
75#endif // !_WORD_DEFINED
76
77typedef struct _INTEL_HEX_RECORD
78{
79 BYTE Length;
80 WORD Address;
81 BYTE Type;
82 BYTE Data[MAX_INTEL_HEX_RECORD_LENGTH];
83} INTEL_HEX_RECORD, *PINTEL_HEX_RECORD;
84
85#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-14 12:31:38 -0400