drivers/usb/media/dabusb.c

   1 /*****************************************************************************/
   2
   3 /*
   4  *      dabusb.c  --  dab usb driver.
   5  *
   6  *      Copyright (C) 1999  Deti Fliegl (deti@fliegl.de)
   7  *
   8  *      This program is free software; you can redistribute it and/or modify
   9  *      it under the terms of the GNU General Public License as published by
  10  *      the Free Software Foundation; either version 2 of the License, or
  11  *      (at your option) any later version.
  12  *
  13  *      This program is distributed in the hope that it will be useful,
  14  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *      GNU General Public License for more details.
  17  *
  18  *      You should have received a copy of the GNU General Public License
  19  *      along with this program; if not, write to the Free Software
  20  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  *
  22  *
  23  *
  24  *  $Id: dabusb.c,v 1.54 2000/07/24 21:39:39 deti Exp $
  25  *
  26  */
  27
  28 /*****************************************************************************/
  29
  30 #include <linux/module.h>
  31 #include <linux/socket.h>
  32 #include <linux/list.h>
  33 #include <linux/vmalloc.h>
  34 #include <linux/slab.h>
  35 #include <linux/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/smp_lock.h>
  41
  42 #include "dabusb.h"
  43 #include "dabfirmware.h"
  44
  45 /*
  46  * Version Information
  47  */
  48 #define DRIVER_VERSION "v1.54"
  49 #define DRIVER_AUTHOR "Deti Fliegl, deti@fliegl.de"
  50 #define DRIVER_DESC "DAB-USB Interface Driver for Linux (c)1999"
  51
  52 /* --------------------------------------------------------------------- */
  53
  54 #ifdef CONFIG_USB_DYNAMIC_MINORS
  55 #define NRDABUSB 256
  56 #else
  57 #define NRDABUSB 4
  58 #endif
  59
  60 /*-------------------------------------------------------------------*/
  61
  62 static dabusb_t dabusb[NRDABUSB];
  63 static int buffers = 256;
  64 extern struct usb_driver dabusb_driver;
  65
  66 /*-------------------------------------------------------------------*/
  67
  68 static int dabusb_add_buf_tail (pdabusb_t s, struct list_head *dst, struct list_head *src)
  69 {
  70         unsigned long flags;
  71         struct list_head *tmp;
  72         int ret = 0;
  73
  74         spin_lock_irqsave (&s->lock, flags);
  75
  76         if (list_empty (src)) {
  77                 // no elements in source buffer
  78                 ret = -1;
  79                 goto err;
  80         }
  81         tmp = src->next;
  82         list_move_tail (tmp, dst);
  83
  84   err:  spin_unlock_irqrestore (&s->lock, flags);
  85         return ret;
  86 }
  87 /*-------------------------------------------------------------------*/
  88 #ifdef DEBUG
  89 static void dump_urb (struct urb *urb)
  90 {
  91         dbg("urb                   :%p", urb);
  92         dbg("dev                   :%p", urb->dev);
  93         dbg("pipe                  :%08X", urb->pipe);
  94         dbg("status                :%d", urb->status);
  95         dbg("transfer_flags        :%08X", urb->transfer_flags);
  96         dbg("transfer_buffer       :%p", urb->transfer_buffer);
  97         dbg("transfer_buffer_length:%d", urb->transfer_buffer_length);
  98         dbg("actual_length         :%d", urb->actual_length);
  99         dbg("setup_packet          :%p", urb->setup_packet);
 100         dbg("start_frame           :%d", urb->start_frame);
 101         dbg("number_of_packets     :%d", urb->number_of_packets);
 102         dbg("interval              :%d", urb->interval);
 103         dbg("error_count           :%d", urb->error_count);
 104         dbg("context               :%p", urb->context);
 105         dbg("complete              :%p", urb->complete);
 106 }
 107 #endif
 108 /*-------------------------------------------------------------------*/
 109 static int dabusb_cancel_queue (pdabusb_t s, struct list_head *q)
 110 {
 111         unsigned long flags;
 112         struct list_head *p;
 113         pbuff_t b;
 114
 115         dbg("dabusb_cancel_queue");
 116
 117         spin_lock_irqsave (&s->lock, flags);
 118
 119         for (p = q->next; p != q; p = p->next) {
 120                 b = list_entry (p, buff_t, buff_list);
 121
 122 #ifdef DEBUG
 123                 dump_urb(b->purb);
 124 #endif
 125                 usb_unlink_urb (b->purb);
 126         }
 127         spin_unlock_irqrestore (&s->lock, flags);
 128         return 0;
 129 }
 130 /*-------------------------------------------------------------------*/
 131 static int dabusb_free_queue (struct list_head *q)
 132 {
 133         struct list_head *tmp;
 134         struct list_head *p;
 135         pbuff_t b;
 136
 137         dbg("dabusb_free_queue");
 138         for (p = q->next; p != q;) {
 139                 b = list_entry (p, buff_t, buff_list);
 140
 141 #ifdef DEBUG
 142                 dump_urb(b->purb);
 143 #endif
 144                 if (b->purb->transfer_buffer)
 145                         kfree (b->purb->transfer_buffer);
 146                 usb_free_urb(b->purb);
 147                 tmp = p->next;
 148                 list_del (p);
 149                 kfree (b);
 150                 p = tmp;
 151         }
 152
 153         return 0;
 154 }
 155 /*-------------------------------------------------------------------*/
 156 static int dabusb_free_buffers (pdabusb_t s)
 157 {
 158         unsigned long flags;
 159         dbg("dabusb_free_buffers");
 160
 161         spin_lock_irqsave(&s->lock, flags);
 162
 163         dabusb_free_queue (&s->free_buff_list);
 164         dabusb_free_queue (&s->rec_buff_list);
 165
 166         spin_unlock_irqrestore(&s->lock, flags);
 167
 168         s->got_mem = 0;
 169         return 0;
 170 }
 171 /*-------------------------------------------------------------------*/
 172 static void dabusb_iso_complete (struct urb *purb, struct pt_regs *regs)
 173 {
 174         pbuff_t b = purb->context;
 175         pdabusb_t s = b->s;
 176         int i;
 177         int len;
 178         int dst = 0;
 179         void *buf = purb->transfer_buffer;
 180
 181         dbg("dabusb_iso_complete");
 182
 183         // process if URB was not killed
 184         if (purb->status != -ENOENT) {
 185                 unsigned int pipe = usb_rcvisocpipe (purb->dev, _DABUSB_ISOPIPE);
 186                 int pipesize = usb_maxpacket (purb->dev, pipe, usb_pipeout (pipe));
 187                 for (i = 0; i < purb->number_of_packets; i++)
 188                         if (!purb->iso_frame_desc[i].status) {
 189                                 len = purb->iso_frame_desc[i].actual_length;
 190                                 if (len <= pipesize) {
 191                                         memcpy (buf + dst, buf + purb->iso_frame_desc[i].offset, len);
 192                                         dst += len;
 193                                 }
 194                                 else
 195                                         err("dabusb_iso_complete: invalid len %d", len);
 196                         }
 197                         else
 198                                 warn("dabusb_iso_complete: corrupted packet status: %d", purb->iso_frame_desc[i].status);
 199                 if (dst != purb->actual_length)
 200                         err("dst!=purb->actual_length:%d!=%d", 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                 err("overrun (%d)", s->overruns);
 206         }
 207         wake_up (&s->wait);
 208 }
 209 /*-------------------------------------------------------------------*/
 210 static int dabusb_alloc_buffers (pdabusb_t s)
 211 {
 212         int buffers = 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 (buffers < (s->total_buffer_size << 10)) {
 224                 b = (pbuff_t) kmalloc (sizeof (buff_t), GFP_KERNEL);
 225                 if (!b) {
 226                         err("kmalloc(sizeof(buff_t))==NULL");
 227                         goto err;
 228                 }
 229                 memset (b, 0, sizeof (buff_t));
 230                 b->s = s;
 231                 b->purb = usb_alloc_urb(packets, GFP_KERNEL);
 232                 if (!b->purb) {
 233                         err("usb_alloc_urb == NULL");
 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                         err("kmalloc(%d)==NULL", transfer_buffer_length);
 243                         goto err;
 244                 }
 245
 246                 b->purb->transfer_buffer_length = transfer_buffer_length;
 247                 b->purb->number_of_packets = packets;
 248                 b->purb->complete = dabusb_iso_complete;
 249                 b->purb->context = b;
 250                 b->purb->dev = s->usbdev;
 251                 b->purb->pipe = pipe;
 252                 b->purb->transfer_flags = URB_ISO_ASAP;
 253
 254                 for (i = 0; i < packets; i++) {
 255                         b->purb->iso_frame_desc[i].offset = i * pipesize;
 256                         b->purb->iso_frame_desc[i].length = pipesize;
 257                 }
 258
 259                 buffers += transfer_buffer_length;
 260                 list_add_tail (&b->buff_list, &s->free_buff_list);
 261         }
 262         s->got_mem = buffers;
 263
 264         return 0;
 265
 266         err:
 267         dabusb_free_buffers (s);
 268         return -ENOMEM;
 269 }
 270 /*-------------------------------------------------------------------*/
 271 static int dabusb_bulk (pdabusb_t s, pbulk_transfer_t pb)
 272 {
 273         int ret;
 274         unsigned int pipe;
 275         int actual_length;
 276
 277         dbg("dabusb_bulk");
 278
 279         if (!pb->pipe)
 280                 pipe = usb_rcvbulkpipe (s->usbdev, 2);
 281         else
 282                 pipe = usb_sndbulkpipe (s->usbdev, 2);
 283
 284         ret=usb_bulk_msg(s->usbdev, pipe, pb->data, pb->size, &actual_length, 100);
 285         if(ret<0) {
 286                 err("dabusb: usb_bulk_msg failed(%d)",ret);
 287
 288                 if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
 289                         err("set_interface failed");
 290                         return -EINVAL;
 291                 }
 292
 293         }
 294
 295         if( ret == -EPIPE ) {
 296                 warn("CLEAR_FEATURE request to remove STALL condition.");
 297                 if(usb_clear_halt(s->usbdev, usb_pipeendpoint(pipe)))
 298                         err("request failed");
 299         }
 300
 301         pb->size = actual_length;
 302         return ret;
 303 }
 304 /* --------------------------------------------------------------------- */
 305 static int dabusb_writemem (pdabusb_t s, int pos, unsigned char *data, int len)
 306 {
 307         int ret;
 308         unsigned char *transfer_buffer =  kmalloc (len, GFP_KERNEL);
 309
 310         if (!transfer_buffer) {
 311                 err("dabusb_writemem: kmalloc(%d) failed.", len);
 312                 return -ENOMEM;
 313         }
 314
 315         memcpy (transfer_buffer, data, len);
 316
 317         ret=usb_control_msg(s->usbdev, usb_sndctrlpipe( s->usbdev, 0 ), 0xa0, 0x40, pos, 0, transfer_buffer, len, 300);
 318
 319         kfree (transfer_buffer);
 320         return ret;
 321 }
 322 /* --------------------------------------------------------------------- */
 323 static int dabusb_8051_reset (pdabusb_t s, unsigned char reset_bit)
 324 {
 325         dbg("dabusb_8051_reset: %d",reset_bit);
 326         return dabusb_writemem (s, CPUCS_REG, &reset_bit, 1);
 327 }
 328 /* --------------------------------------------------------------------- */
 329 static int dabusb_loadmem (pdabusb_t s, const char *fname)
 330 {
 331         int ret;
 332         PINTEL_HEX_RECORD ptr = firmware;
 333
 334         dbg("Enter dabusb_loadmem (internal)");
 335
 336         ret = dabusb_8051_reset (s, 1);
 337         while (ptr->Type == 0) {
 338
 339                 dbg("dabusb_writemem: %04X %p %d)", ptr->Address, ptr->Data, ptr->Length);
 340
 341                 ret = dabusb_writemem (s, ptr->Address, ptr->Data, ptr->Length);
 342                 if (ret < 0) {
 343                         err("dabusb_writemem failed (%d %04X %p %d)", ret, ptr->Address, ptr->Data, ptr->Length);
 344                         break;
 345                 }
 346                 ptr++;
 347         }
 348         ret = dabusb_8051_reset (s, 0);
 349
 350         dbg("dabusb_loadmem: exit");
 351
 352         return ret;
 353 }
 354 /* --------------------------------------------------------------------- */
 355 static int dabusb_fpga_clear (pdabusb_t s, pbulk_transfer_t b)
 356 {
 357         b->size = 4;
 358         b->data[0] = 0x2a;
 359         b->data[1] = 0;
 360         b->data[2] = 0;
 361         b->data[3] = 0;
 362
 363         dbg("dabusb_fpga_clear");
 364
 365         return dabusb_bulk (s, b);
 366 }
 367 /* --------------------------------------------------------------------- */
 368 static int dabusb_fpga_init (pdabusb_t s, pbulk_transfer_t b)
 369 {
 370         b->size = 4;
 371         b->data[0] = 0x2c;
 372         b->data[1] = 0;
 373         b->data[2] = 0;
 374         b->data[3] = 0;
 375
 376         dbg("dabusb_fpga_init");
 377
 378         return dabusb_bulk (s, b);
 379 }
 380 /* --------------------------------------------------------------------- */
 381 static int dabusb_fpga_download (pdabusb_t s, const char *fname)
 382 {
 383         pbulk_transfer_t b = kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
 384         unsigned int blen, n;
 385         int ret;
 386         unsigned char *buf = bitstream;
 387
 388         dbg("Enter dabusb_fpga_download (internal)");
 389
 390         if (!b) {
 391                 err("kmalloc(sizeof(bulk_transfer_t))==NULL");
 392                 return -ENOMEM;
 393         }
 394
 395         b->pipe = 1;
 396         ret = dabusb_fpga_clear (s, b);
 397         mdelay (10);
 398         blen = buf[73] + (buf[72] << 8);
 399
 400         dbg("Bitstream len: %i", blen);
 401
 402         b->data[0] = 0x2b;
 403         b->data[1] = 0;
 404         b->data[2] = 0;
 405         b->data[3] = 60;
 406
 407         for (n = 0; n <= blen + 60; n += 60) {
 408                 // some cclks for startup
 409                 b->size = 64;
 410                 memcpy (b->data + 4, buf + 74 + n, 60);
 411                 ret = dabusb_bulk (s, b);
 412                 if (ret < 0) {
 413                         err("dabusb_bulk failed.");
 414                         break;
 415                 }
 416                 mdelay (1);
 417         }
 418
 419         ret = dabusb_fpga_init (s, b);
 420         kfree (b);
 421
 422         dbg("exit dabusb_fpga_download");
 423
 424         return ret;
 425 }
 426
 427 static int dabusb_stop (pdabusb_t s)
 428 {
 429         dbg("dabusb_stop");
 430
 431         s->state = _stopped;
 432         dabusb_cancel_queue (s, &s->rec_buff_list);
 433
 434         dbg("pending_io: %d", s->pending_io.counter);
 435
 436         s->pending_io.counter = 0;
 437         return 0;
 438 }
 439
 440 static int dabusb_startrek (pdabusb_t s)
 441 {
 442         if (!s->got_mem && s->state != _started) {
 443
 444                 dbg("dabusb_startrek");
 445
 446                 if (dabusb_alloc_buffers (s) < 0)
 447                         return -ENOMEM;
 448                 dabusb_stop (s);
 449                 s->state = _started;
 450                 s->readptr = 0;
 451         }
 452
 453         if (!list_empty (&s->free_buff_list)) {
 454                 pbuff_t end;
 455                 int ret;
 456
 457         while (!dabusb_add_buf_tail (s, &s->rec_buff_list, &s->free_buff_list)) {
 458
 459                         dbg("submitting: end:%p s->rec_buff_list:%p", s->rec_buff_list.prev, &s->rec_buff_list);
 460
 461                         end = list_entry (s->rec_buff_list.prev, buff_t, buff_list);
 462
 463                         ret = usb_submit_urb (end->purb, GFP_KERNEL);
 464                         if (ret) {
 465                                 err("usb_submit_urb returned:%d", ret);
 466                                 if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
 467                                         err("startrek: dabusb_add_buf_tail failed");
 468                                 break;
 469                         }
 470                         else
 471                                 atomic_inc (&s->pending_io);
 472                 }
 473                 dbg("pending_io: %d",s->pending_io.counter);
 474         }
 475
 476         return 0;
 477 }
 478
 479 static ssize_t dabusb_read (struct file *file, char *buf, size_t count, loff_t * ppos)
 480 {
 481         pdabusb_t s = (pdabusb_t) file->private_data;
 482         unsigned long flags;
 483         unsigned ret = 0;
 484         int rem;
 485         int cnt;
 486         pbuff_t b;
 487         struct urb *purb = NULL;
 488
 489         dbg("dabusb_read");
 490
 491         if (*ppos)
 492                 return -ESPIPE;
 493
 494         if (s->remove_pending)
 495                 return -EIO;
 496
 497
 498         if (!s->usbdev)
 499                 return -EIO;
 500
 501         while (count > 0) {
 502                 dabusb_startrek (s);
 503
 504                 spin_lock_irqsave (&s->lock, flags);
 505
 506                 if (list_empty (&s->rec_buff_list)) {
 507
 508                         spin_unlock_irqrestore(&s->lock, flags);
 509
 510                         err("error: rec_buf_list is empty");
 511                         goto err;
 512                 }
 513
 514                 b = list_entry (s->rec_buff_list.next, buff_t, buff_list);
 515                 purb = b->purb;
 516
 517                 spin_unlock_irqrestore(&s->lock, flags);
 518
 519                 if (purb->status == -EINPROGRESS) {
 520                         if (file->f_flags & O_NONBLOCK)         // return nonblocking
 521                          {
 522                                 if (!ret)
 523                                         ret = -EAGAIN;
 524                                 goto err;
 525                         }
 526
 527                         interruptible_sleep_on (&s->wait);
 528
 529                         if (signal_pending (current)) {
 530                                 if (!ret)
 531                                         ret = -ERESTARTSYS;
 532                                 goto err;
 533                         }
 534
 535                         spin_lock_irqsave (&s->lock, flags);
 536
 537                         if (list_empty (&s->rec_buff_list)) {
 538                                 spin_unlock_irqrestore(&s->lock, flags);
 539                                 err("error: still no buffer available.");
 540                                 goto err;
 541                         }
 542                         spin_unlock_irqrestore(&s->lock, flags);
 543                         s->readptr = 0;
 544                 }
 545                 if (s->remove_pending) {
 546                         ret = -EIO;
 547                         goto err;
 548                 }
 549
 550                 rem = purb->actual_length - s->readptr;         // set remaining bytes to copy
 551
 552                 if (count >= rem)
 553                         cnt = rem;
 554                 else
 555                         cnt = count;
 556
 557                 dbg("copy_to_user:%p %p %d",buf, purb->transfer_buffer + s->readptr, cnt);
 558
 559                 if (copy_to_user (buf, purb->transfer_buffer + s->readptr, cnt)) {
 560                         err("read: copy_to_user failed");
 561                         if (!ret)
 562                                 ret = -EFAULT;
 563                         goto err;
 564                 }
 565
 566                 s->readptr += cnt;
 567                 count -= cnt;
 568                 buf += cnt;
 569                 ret += cnt;
 570
 571                 if (s->readptr == purb->actual_length) {
 572                         // finished, take next buffer
 573                         if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
 574                                 err("read: dabusb_add_buf_tail failed");
 575                         s->readptr = 0;
 576                 }
 577         }
 578       err:                      //up(&s->mutex);
 579         return ret;
 580 }
 581
 582 static int dabusb_open (struct inode *inode, struct file *file)
 583 {
 584         int devnum = iminor(inode);
 585         pdabusb_t s;
 586
 587         if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB))
 588                 return -EIO;
 589
 590         s = &dabusb[devnum - DABUSB_MINOR];
 591
 592         dbg("dabusb_open");
 593         down (&s->mutex);
 594
 595         while (!s->usbdev || s->opened) {
 596                 up (&s->mutex);
 597
 598                 if (file->f_flags & O_NONBLOCK) {
 599                         return -EBUSY;
 600                 }
 601                 schedule_timeout (HZ / 2);
 602
 603                 if (signal_pending (current)) {
 604                         return -EAGAIN;
 605                 }
 606                 down (&s->mutex);
 607         }
 608         if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
 609                 up(&s->mutex);
 610                 err("set_interface failed");
 611                 return -EINVAL;
 612         }
 613         s->opened = 1;
 614         up (&s->mutex);
 615
 616         file->f_pos = 0;
 617         file->private_data = s;
 618
 619         return 0;
 620 }
 621
 622 static int dabusb_release (struct inode *inode, struct file *file)
 623 {
 624         pdabusb_t s = (pdabusb_t) file->private_data;
 625
 626         dbg("dabusb_release");
 627
 628         down (&s->mutex);
 629         dabusb_stop (s);
 630         dabusb_free_buffers (s);
 631         up (&s->mutex);
 632
 633         if (!s->remove_pending) {
 634                 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0)
 635                         err("set_interface failed");
 636         }
 637         else
 638                 wake_up (&s->remove_ok);
 639
 640         s->opened = 0;
 641         return 0;
 642 }
 643
 644 static int dabusb_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 645 {
 646         pdabusb_t s = (pdabusb_t) file->private_data;
 647         pbulk_transfer_t pbulk;
 648         int ret = 0;
 649         int version = DABUSB_VERSION;
 650
 651         dbg("dabusb_ioctl");
 652
 653         if (s->remove_pending)
 654                 return -EIO;
 655
 656         down (&s->mutex);
 657
 658         if (!s->usbdev) {
 659                 up (&s->mutex);
 660                 return -EIO;
 661         }
 662
 663         switch (cmd) {
 664
 665         case IOCTL_DAB_BULK:
 666                 pbulk = (pbulk_transfer_t) kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
 667
 668                 if (!pbulk) {
 669                         ret = -ENOMEM;
 670                         break;
 671                 }
 672
 673                 if (copy_from_user (pbulk, (void *) arg, sizeof (bulk_transfer_t))) {
 674                         ret = -EFAULT;
 675                         kfree (pbulk);
 676                         break;
 677                 }
 678
 679                 ret=dabusb_bulk (s, pbulk);
 680                 if(ret==0)
 681                         if (copy_to_user((void *)arg, pbulk,
 682                                          sizeof(bulk_transfer_t)))
 683                                 ret = -EFAULT;
 684                 kfree (pbulk);
 685                 break;
 686
 687         case IOCTL_DAB_OVERRUNS:
 688                 ret = put_user (s->overruns, (unsigned int *) arg);
 689                 break;
 690
 691         case IOCTL_DAB_VERSION:
 692                 ret = put_user (version, (unsigned int *) arg);
 693                 break;
 694
 695         default:
 696                 ret = -ENOIOCTLCMD;
 697                 break;
 698         }
 699         up (&s->mutex);
 700         return ret;
 701 }
 702
 703 static struct file_operations dabusb_fops =
 704 {
 705         .owner =        THIS_MODULE,
 706         .llseek =       no_llseek,
 707         .read =         dabusb_read,
 708         .ioctl =        dabusb_ioctl,
 709         .open =         dabusb_open,
 710         .release =      dabusb_release,
 711 };
 712
 713 static struct usb_class_driver dabusb_class = {
 714         .name =         "usb/dabusb%d",
 715         .fops =         &dabusb_fops,
 716         .mode =         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
 717         .minor_base =   DABUSB_MINOR,
 718 };
 719
 720
 721 /* --------------------------------------------------------------------- */
 722 static int dabusb_probe (struct usb_interface *intf,
 723                          const struct usb_device_id *id)
 724 {
 725         struct usb_device *usbdev = interface_to_usbdev(intf);
 726         int retval;
 727         pdabusb_t s;
 728
 729         dbg("dabusb: probe: vendor id 0x%x, device id 0x%x ifnum:%d",
 730           usbdev->descriptor.idVendor, usbdev->descriptor.idProduct, intf->altsetting->desc.bInterfaceNumber);
 731
 732         /* We don't handle multiple configurations */
 733         if (usbdev->descriptor.bNumConfigurations != 1)
 734                 return -ENODEV;
 735
 736         if (intf->altsetting->desc.bInterfaceNumber != _DABUSB_IF && usbdev->descriptor.idProduct == 0x9999)
 737                 return -ENODEV;
 738
 739
 740
 741         s = &dabusb[intf->minor];
 742
 743         down (&s->mutex);
 744         s->remove_pending = 0;
 745         s->usbdev = usbdev;
 746         s->devnum = intf->minor;
 747
 748         if (usb_reset_configuration (usbdev) < 0) {
 749                 err("reset_configuration failed");
 750                 goto reject;
 751         }
 752         if (usbdev->descriptor.idProduct == 0x2131) {
 753                 dabusb_loadmem (s, NULL);
 754                 goto reject;
 755         }
 756         else {
 757                 dabusb_fpga_download (s, NULL);
 758
 759                 if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0) {
 760                         err("set_interface failed");
 761                         goto reject;
 762                 }
 763         }
 764         dbg("bound to interface: %d", intf->altsetting->desc.bInterfaceNumber);
 765         usb_set_intfdata (intf, s);
 766         up (&s->mutex);
 767
 768         retval = usb_register_dev(intf, &dabusb_class);
 769         if (retval) {
 770                 usb_set_intfdata (intf, NULL);
 771                 return -ENOMEM;
 772         }
 773
 774         return 0;
 775
 776       reject:
 777         up (&s->mutex);
 778         s->usbdev = NULL;
 779         return -ENODEV;
 780 }
 781
 782 static void dabusb_disconnect (struct usb_interface *intf)
 783 {
 784         wait_queue_t __wait;
 785         pdabusb_t s = usb_get_intfdata (intf);
 786
 787         dbg("dabusb_disconnect");
 788
 789         init_waitqueue_entry(&__wait, current);
 790
 791         usb_set_intfdata (intf, NULL);
 792         if (s) {
 793                 usb_deregister_dev (intf, &dabusb_class);
 794                 s->remove_pending = 1;
 795                 wake_up (&s->wait);
 796                 add_wait_queue(&s->remove_ok, &__wait);
 797                 set_current_state(TASK_UNINTERRUPTIBLE);
 798                 if (s->state == _started)
 799                         schedule();
 800                 current->state = TASK_RUNNING;
 801                 remove_wait_queue(&s->remove_ok, &__wait);
 802
 803                 s->usbdev = NULL;
 804                 s->overruns = 0;
 805         }
 806 }
 807
 808 static struct usb_device_id dabusb_ids [] = {
 809         // { USB_DEVICE(0x0547, 0x2131) },      /* An2131 chip, no boot ROM */
 810         { USB_DEVICE(0x0547, 0x9999) },
 811         { }                                             /* Terminating entry */
 812 };
 813
 814 MODULE_DEVICE_TABLE (usb, dabusb_ids);
 815
 816 static struct usb_driver dabusb_driver = {
 817         .owner =        THIS_MODULE,
 818         .name =         "dabusb",
 819         .probe =        dabusb_probe,
 820         .disconnect =   dabusb_disconnect,
 821         .id_table =     dabusb_ids,
 822 };
 823
 824 /* --------------------------------------------------------------------- */
 825
 826 static int __init dabusb_init (void)
 827 {
 828         int retval;
 829         unsigned u;
 830
 831         /* initialize struct */
 832         for (u = 0; u < NRDABUSB; u++) {
 833                 pdabusb_t s = &dabusb[u];
 834                 memset (s, 0, sizeof (dabusb_t));
 835                 init_MUTEX (&s->mutex);
 836                 s->usbdev = NULL;
 837                 s->total_buffer_size = buffers;
 838                 init_waitqueue_head (&s->wait);
 839                 init_waitqueue_head (&s->remove_ok);
 840                 spin_lock_init (&s->lock);
 841                 INIT_LIST_HEAD (&s->free_buff_list);
 842                 INIT_LIST_HEAD (&s->rec_buff_list);
 843         }
 844
 845         /* register misc device */
 846         retval = usb_register(&dabusb_driver);
 847         if (retval)
 848                 goto out;
 849
 850         dbg("dabusb_init: driver registered");
 851
 852         info(DRIVER_VERSION ":" DRIVER_DESC);
 853
 854 out:
 855         return retval;
 856 }
 857
 858 static void __exit dabusb_cleanup (void)
 859 {
 860         dbg("dabusb_cleanup");
 861
 862         usb_deregister (&dabusb_driver);
 863 }
 864
 865 /* --------------------------------------------------------------------- */
 866
 867 MODULE_AUTHOR( DRIVER_AUTHOR );
 868 MODULE_DESCRIPTION( DRIVER_DESC );
 869 MODULE_LICENSE("GPL");
 870
 871 MODULE_PARM (buffers, "i");
 872 MODULE_PARM_DESC (buffers, "Number of buffers (default=256)");
 873
 874 module_init (dabusb_init);
 875 module_exit (dabusb_cleanup);
 876
 877 /* --------------------------------------------------------------------- */