projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (12294): b2c2: Use dvb-pll for Cablestar2
[deliverable/linux.git] / drivers / media / video / dabusb.c
CommitLineData
1da177e4
LT		 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>
405f5571 35#include <linux/smp_lock.h>
1da177e4
LT		 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>
4186ecf8 41#include <linux/mutex.h>
c4667746
DW		 42#include <linux/firmware.h>
43#include <linux/ihex.h>
1da177e4
LT		 44
45#include "dabusb.h"
1da177e4
LT		 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
64static dabusb_t dabusb[NRDABUSB];
65static int buffers = 256;
66static struct usb_driver dabusb_driver;
67
68/*-------------------------------------------------------------------*/
69
70static 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/*-------------------------------------------------------------------*/
d56410e0 90#ifdef DEBUG
1da177e4
LT		 91static 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/*-------------------------------------------------------------------*/
111static 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/*-------------------------------------------------------------------*/
130static 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
d56410e0 140#ifdef DEBUG
1da177e4
LT		 141 dump_urb(b->purb);
142#endif
1bc3c9e1 143 kfree(b->purb->transfer_buffer);
1da177e4
LT		 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/*-------------------------------------------------------------------*/
154static 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/*-------------------------------------------------------------------*/
7d12e780 170static void dabusb_iso_complete (struct urb *purb)
1da177e4
LT		 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
be9ed511
MCC		 193 dev_err(&purb->dev->dev,
194 "dabusb_iso_complete: invalid len %d\n", len);
1da177e4
LT		 195 }
196 else
aa82661b 197 dev_warn(&purb->dev->dev, "dabusb_iso_complete: corrupted packet status: %d\n", purb->iso_frame_desc[i].status);
1da177e4 198 if (dst != purb->actual_length)
be9ed511
MCC		 199 dev_err(&purb->dev->dev,
200 "dst!=purb->actual_length:%d!=%d\n",
201 dst, purb->actual_length);
1da177e4
LT		 202 }
203
204 if (atomic_dec_and_test (&s->pending_io) && !s->remove_pending && s->state != _stopped) {
205 s->overruns++;
be9ed511 206 dev_err(&purb->dev->dev, "overrun (%d)\n", s->overruns);
1da177e4
LT		 207 }
208 wake_up (&s->wait);
209}
210/*-------------------------------------------------------------------*/
211static int dabusb_alloc_buffers (pdabusb_t s)
212{
6f289675 213 int transfer_len = 0;
1da177e4
LT		 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
6f289675 224 while (transfer_len < (s->total_buffer_size << 10)) {
5cbded58 225 b = kzalloc(sizeof (buff_t), GFP_KERNEL);
1da177e4 226 if (!b) {
be9ed511
MCC		 227 dev_err(&s->usbdev->dev,
228 "kzalloc(sizeof(buff_t))==NULL\n");
1da177e4
LT		 229 goto err;
230 }
1da177e4
LT		 231 b->s = s;
232 b->purb = usb_alloc_urb(packets, GFP_KERNEL);
233 if (!b->purb) {
be9ed511 234 dev_err(&s->usbdev->dev, "usb_alloc_urb == NULL\n");
1da177e4
LT		 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);
be9ed511
MCC		 243 dev_err(&s->usbdev->dev,
244 "kmalloc(%d)==NULL\n", transfer_buffer_length);
1da177e4
LT		 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
6f289675 261 transfer_len += transfer_buffer_length;
1da177e4
LT		 262 list_add_tail (&b->buff_list, &s->free_buff_list);
263 }
6f289675 264 s->got_mem = transfer_len;
1da177e4
LT		 265
266 return 0;
267
268 err:
269 dabusb_free_buffers (s);
270 return -ENOMEM;
271}
272/*-------------------------------------------------------------------*/
273static 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) {
be9ed511
MCC		 288 dev_err(&s->usbdev->dev,
289 "usb_bulk_msg failed(%d)\n", ret);
1da177e4
LT		 290
291 if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
be9ed511 292 dev_err(&s->usbdev->dev, "set_interface failed\n");
1da177e4
LT		 293 return -EINVAL;
294 }
295
296 }
d56410e0 297
1da177e4 298 if( ret == -EPIPE ) {
aa82661b 299 dev_warn(&s->usbdev->dev, "CLEAR_FEATURE request to remove STALL condition.\n");
1da177e4 300 if(usb_clear_halt(s->usbdev, usb_pipeendpoint(pipe)))
be9ed511 301 dev_err(&s->usbdev->dev, "request failed\n");
1da177e4
LT		 302 }
303
304 pb->size = actual_length;
305 return ret;
306}
307/* --------------------------------------------------------------------- */
c4667746
DW		 308static int dabusb_writemem (pdabusb_t s, int pos, const unsigned char *data,
309 int len)
1da177e4
LT		 310{
311 int ret;
312 unsigned char *transfer_buffer = kmalloc (len, GFP_KERNEL);
313
314 if (!transfer_buffer) {
be9ed511
MCC		 315 dev_err(&s->usbdev->dev,
316 "dabusb_writemem: kmalloc(%d) failed.\n", len);
1da177e4
LT		 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/* --------------------------------------------------------------------- */
328static 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/* --------------------------------------------------------------------- */
334static int dabusb_loadmem (pdabusb_t s, const char *fname)
335{
336 int ret;
c4667746 337 const struct ihex_binrec *rec;
031002d7 338 const struct firmware *uninitialized_var(fw);
1da177e4
LT		 339
340 dbg("Enter dabusb_loadmem (internal)");
d56410e0 341
c4667746
DW		 342 ret = request_ihex_firmware(&fw, "dabusb/firmware.fw", &s->usbdev->dev);
343 if (ret) {
be9ed511
MCC		 344 dev_err(&s->usbdev->dev,
345 "Failed to load \"dabusb/firmware.fw\": %d\n", ret);
c4667746
DW		 346 goto out;
347 }
1da177e4 348 ret = dabusb_8051_reset (s, 1);
1da177e4 349
c4667746
DW		 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));
1da177e4 354
c4667746
DW		 355 ret = dabusb_writemem(s, be32_to_cpu(rec->addr), rec->data,
356 be16_to_cpu(rec->len));
1da177e4 357 if (ret < 0) {
be9ed511
MCC		 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));
1da177e4
LT		 362 break;
363 }
1da177e4
LT		 364 }
365 ret = dabusb_8051_reset (s, 0);
c4667746
DW		 366 release_firmware(fw);
367 out:
1da177e4
LT		 368 dbg("dabusb_loadmem: exit");
369
370 return ret;
371}
372/* --------------------------------------------------------------------- */
373static 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/* --------------------------------------------------------------------- */
386static 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/* --------------------------------------------------------------------- */
399static int dabusb_fpga_download (pdabusb_t s, const char *fname)
400{
401 pbulk_transfer_t b = kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
c4667746 402 const struct firmware *fw;
1da177e4
LT		 403 unsigned int blen, n;
404 int ret;
1da177e4
LT		 405
406 dbg("Enter dabusb_fpga_download (internal)");
407
408 if (!b) {
be9ed511
MCC		 409 dev_err(&s->usbdev->dev,
410 "kmalloc(sizeof(bulk_transfer_t))==NULL\n");
1da177e4
LT		 411 return -ENOMEM;
412 }
413
c4667746
DW		 414 ret = request_firmware(&fw, "dabusb/bitstream.bin", &s->usbdev->dev);
415 if (ret) {
be9ed511
MCC		 416 dev_err(&s->usbdev->dev,
417 "Failed to load \"dabusb/bitstream.bin\": %d\n", ret);
02c0267a 418 kfree(b);
c4667746
DW		 419 return ret;
420 }
421
1da177e4
LT		 422 b->pipe = 1;
423 ret = dabusb_fpga_clear (s, b);
424 mdelay (10);
c4667746 425 blen = fw->data[73] + (fw->data[72] << 8);
1da177e4
LT		 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;
c4667746 437 memcpy (b->data + 4, fw->data + 74 + n, 60);
1da177e4
LT		 438 ret = dabusb_bulk (s, b);
439 if (ret < 0) {
be9ed511 440 dev_err(&s->usbdev->dev, "dabusb_bulk failed.\n");
1da177e4
LT		 441 break;
442 }
443 mdelay (1);
444 }
445
446 ret = dabusb_fpga_init (s, b);
447 kfree (b);
c4667746 448 release_firmware(fw);
1da177e4
LT		 449
450 dbg("exit dabusb_fpga_download");
451
452 return ret;
453}
454
455static 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
468static 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;
d56410e0 484
1da177e4
LT		 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) {
be9ed511
MCC		 493 dev_err(&s->usbdev->dev,
494 "usb_submit_urb returned:%d\n", ret);
1da177e4 495 if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
be9ed511
MCC		 496 dev_err(&s->usbdev->dev,
497 "startrek: dabusb_add_buf_tail failed\n");
1da177e4
LT		 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
509static 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
be9ed511
MCC		 540 dev_err(&s->usbdev->dev,
541 "error: rec_buf_list is empty\n");
1da177e4
LT		 542 goto err;
543 }
d56410e0 544
1da177e4
LT		 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);
be9ed511
MCC		 570 dev_err(&s->usbdev->dev,
571 "error: still no buffer available.\n");
1da177e4
LT		 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)) {
be9ed511 592 dev_err(&s->usbdev->dev, "read: copy_to_user failed\n");
1da177e4
LT		 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))
be9ed511
MCC		 606 dev_err(&s->usbdev->dev,
607 "read: dabusb_add_buf_tail failed\n");
1da177e4
LT		 608 s->readptr = 0;
609 }
610 }
4186ecf8 611 err: //mutex_unlock(&s->mutex);
1da177e4
LT		 612 return ret;
613}
614
615static int dabusb_open (struct inode *inode, struct file *file)
616{
617 int devnum = iminor(inode);
618 pdabusb_t s;
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");
4186ecf8 626 mutex_lock(&s->mutex);
1da177e4
LT		 627
628 while (!s->usbdev || s->opened) {
4186ecf8 629 mutex_unlock(&s->mutex);
1da177e4
LT		 630
631 if (file->f_flags & O_NONBLOCK) {
632 return -EBUSY;
633 }
634 msleep_interruptible(500);
635
636 if (signal_pending (current)) {
637 return -EAGAIN;
638 }
4186ecf8 639 mutex_lock(&s->mutex);
1da177e4
LT		 640 }
641 if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
4186ecf8 642 mutex_unlock(&s->mutex);
be9ed511 643 dev_err(&s->usbdev->dev, "set_interface failed\n");
1da177e4
LT		 644 return -EINVAL;
645 }
646 s->opened = 1;
4186ecf8 647 mutex_unlock(&s->mutex);
1da177e4
LT		 648
649 file->f_pos = 0;
650 file->private_data = s;
651
652 return nonseekable_open(inode, file);
653}
654
655static int dabusb_release (struct inode *inode, struct file *file)
656{
657 pdabusb_t s = (pdabusb_t) file->private_data;
658
659 dbg("dabusb_release");
660
4186ecf8 661 mutex_lock(&s->mutex);
1da177e4
LT		 662 dabusb_stop (s);
663 dabusb_free_buffers (s);
4186ecf8 664 mutex_unlock(&s->mutex);
1da177e4
LT		 665
666 if (!s->remove_pending) {
667 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0)
be9ed511 668 dev_err(&s->usbdev->dev, "set_interface failed\n");
1da177e4
LT		 669 }
670 else
671 wake_up (&s->remove_ok);
672
673 s->opened = 0;
674 return 0;
675}
676
5ed2b641 677static long dabusb_ioctl (struct file *file, unsigned int cmd, unsigned long arg)
1da177e4
LT		 678{
679 pdabusb_t s = (pdabusb_t) file->private_data;
680 pbulk_transfer_t pbulk;
681 int ret = 0;
682 int version = DABUSB_VERSION;
683
684 dbg("dabusb_ioctl");
685
3fd8ab30 686 lock_kernel();
5ed2b641
SG		 687 if (s->remove_pending) {
688 unlock_kernel();
1da177e4 689 return -EIO;
5ed2b641 690 }
1da177e4 691
4186ecf8 692 mutex_lock(&s->mutex);
1da177e4
LT		 693
694 if (!s->usbdev) {
4186ecf8 695 mutex_unlock(&s->mutex);
5ed2b641 696 unlock_kernel();
1da177e4
LT		 697 return -EIO;
698 }
699
700 switch (cmd) {
701
702 case IOCTL_DAB_BULK:
5cbded58 703 pbulk = kmalloc(sizeof (bulk_transfer_t), GFP_KERNEL);
1da177e4
LT		 704
705 if (!pbulk) {
706 ret = -ENOMEM;
707 break;
708 }
709
710 if (copy_from_user (pbulk, (void __user *) arg, sizeof (bulk_transfer_t))) {
711 ret = -EFAULT;
712 kfree (pbulk);
713 break;
714 }
715
716 ret=dabusb_bulk (s, pbulk);
717 if(ret==0)
718 if (copy_to_user((void __user *)arg, pbulk,
719 sizeof(bulk_transfer_t)))
720 ret = -EFAULT;
721 kfree (pbulk);
722 break;
723
724 case IOCTL_DAB_OVERRUNS:
725 ret = put_user (s->overruns, (unsigned int __user *) arg);
726 break;
727
728 case IOCTL_DAB_VERSION:
729 ret = put_user (version, (unsigned int __user *) arg);
730 break;
731
732 default:
733 ret = -ENOIOCTLCMD;
734 break;
735 }
4186ecf8 736 mutex_unlock(&s->mutex);
5ed2b641 737 unlock_kernel();
1da177e4
LT		 738 return ret;
739}
740
fa027c2a 741static const struct file_operations dabusb_fops =
1da177e4
LT		 742{
743 .owner = THIS_MODULE,
744 .llseek = no_llseek,
745 .read = dabusb_read,
5ed2b641 746 .unlocked_ioctl = dabusb_ioctl,
1da177e4
LT		 747 .open = dabusb_open,
748 .release = dabusb_release,
749};
750
f7a386c5
KS		 751static char *dabusb_nodename(struct device *dev)
752{
753 return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
754}
755
1da177e4 756static struct usb_class_driver dabusb_class = {
d6e5bcf4 757 .name = "dabusb%d",
f7a386c5 758 .nodename = dabusb_nodename,
1da177e4 759 .fops = &dabusb_fops,
1da177e4
LT		 760 .minor_base = DABUSB_MINOR,
761};
762
763
764/* --------------------------------------------------------------------- */
765static int dabusb_probe (struct usb_interface *intf,
766 const struct usb_device_id *id)
767{
768 struct usb_device *usbdev = interface_to_usbdev(intf);
769 int retval;
770 pdabusb_t s;
771
772 dbg("dabusb: probe: vendor id 0x%x, device id 0x%x ifnum:%d",
773 le16_to_cpu(usbdev->descriptor.idVendor),
774 le16_to_cpu(usbdev->descriptor.idProduct),
775 intf->altsetting->desc.bInterfaceNumber);
776
777 /* We don't handle multiple configurations */
778 if (usbdev->descriptor.bNumConfigurations != 1)
779 return -ENODEV;
780
781 if (intf->altsetting->desc.bInterfaceNumber != _DABUSB_IF &&
782 le16_to_cpu(usbdev->descriptor.idProduct) == 0x9999)
783 return -ENODEV;
784
785
786
787 s = &dabusb[intf->minor];
788
4186ecf8 789 mutex_lock(&s->mutex);
1da177e4
LT		 790 s->remove_pending = 0;
791 s->usbdev = usbdev;
792 s->devnum = intf->minor;
793
794 if (usb_reset_configuration (usbdev) < 0) {
be9ed511 795 dev_err(&intf->dev, "reset_configuration failed\n");
1da177e4
LT		 796 goto reject;
797 }
798 if (le16_to_cpu(usbdev->descriptor.idProduct) == 0x2131) {
799 dabusb_loadmem (s, NULL);
800 goto reject;
801 }
802 else {
803 dabusb_fpga_download (s, NULL);
804
805 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0) {
be9ed511 806 dev_err(&intf->dev, "set_interface failed\n");
1da177e4
LT		 807 goto reject;
808 }
809 }
810 dbg("bound to interface: %d", intf->altsetting->desc.bInterfaceNumber);
811 usb_set_intfdata (intf, s);
4186ecf8 812 mutex_unlock(&s->mutex);
1da177e4
LT		 813
814 retval = usb_register_dev(intf, &dabusb_class);
815 if (retval) {
816 usb_set_intfdata (intf, NULL);
817 return -ENOMEM;
818 }
819
820 return 0;
821
822 reject:
4186ecf8 823 mutex_unlock(&s->mutex);
1da177e4
LT		 824 s->usbdev = NULL;
825 return -ENODEV;
826}
827
828static void dabusb_disconnect (struct usb_interface *intf)
829{
830 wait_queue_t __wait;
831 pdabusb_t s = usb_get_intfdata (intf);
832
833 dbg("dabusb_disconnect");
d56410e0 834
1da177e4 835 init_waitqueue_entry(&__wait, current);
d56410e0 836
1da177e4
LT		 837 usb_set_intfdata (intf, NULL);
838 if (s) {
839 usb_deregister_dev (intf, &dabusb_class);
840 s->remove_pending = 1;
841 wake_up (&s->wait);
842 add_wait_queue(&s->remove_ok, &__wait);
843 set_current_state(TASK_UNINTERRUPTIBLE);
844 if (s->state == _started)
845 schedule();
846 current->state = TASK_RUNNING;
847 remove_wait_queue(&s->remove_ok, &__wait);
d56410e0 848
1da177e4
LT		 849 s->usbdev = NULL;
850 s->overruns = 0;
851 }
852}
853
854static struct usb_device_id dabusb_ids [] = {
855 // { USB_DEVICE(0x0547, 0x2131) }, /* An2131 chip, no boot ROM */
856 { USB_DEVICE(0x0547, 0x9999) },
857 { } /* Terminating entry */
858};
859
860MODULE_DEVICE_TABLE (usb, dabusb_ids);
861
862static struct usb_driver dabusb_driver = {
1da177e4
LT		 863 .name = "dabusb",
864 .probe = dabusb_probe,
865 .disconnect = dabusb_disconnect,
866 .id_table = dabusb_ids,
867};
868
869/* --------------------------------------------------------------------- */
870
871static int __init dabusb_init (void)
872{
873 int retval;
874 unsigned u;
875
876 /* initialize struct */
877 for (u = 0; u < NRDABUSB; u++) {
878 pdabusb_t s = &dabusb[u];
879 memset (s, 0, sizeof (dabusb_t));
4186ecf8 880 mutex_init (&s->mutex);
1da177e4
LT		 881 s->usbdev = NULL;
882 s->total_buffer_size = buffers;
883 init_waitqueue_head (&s->wait);
884 init_waitqueue_head (&s->remove_ok);
885 spin_lock_init (&s->lock);
886 INIT_LIST_HEAD (&s->free_buff_list);
887 INIT_LIST_HEAD (&s->rec_buff_list);
888 }
889
890 /* register misc device */
891 retval = usb_register(&dabusb_driver);
892 if (retval)
893 goto out;
894
895 dbg("dabusb_init: driver registered");
896
a482f327
GKH		 897 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
898 DRIVER_DESC "\n");
1da177e4
LT		 899
900out:
901 return retval;
902}
903
904static void __exit dabusb_cleanup (void)
905{
906 dbg("dabusb_cleanup");
907
908 usb_deregister (&dabusb_driver);
909}
910
911/* --------------------------------------------------------------------- */
912
913MODULE_AUTHOR( DRIVER_AUTHOR );
914MODULE_DESCRIPTION( DRIVER_DESC );
915MODULE_LICENSE("GPL");
916
917module_param(buffers, int, 0);
918MODULE_PARM_DESC (buffers, "Number of buffers (default=256)");
919
920module_init (dabusb_init);
921module_exit (dabusb_cleanup);
922
923/* --------------------------------------------------------------------- */
Linux kernel - Deliverables
This page took 0.682394 seconds and 5 git commands to generate.