drivers/staging/dabusb/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 <linux/uaccess.h>
  37 #include <linux/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
  63 static dabusb_t dabusb[NRDABUSB];
  64 static int buffers = 256;
  65 static struct usb_driver dabusb_driver;
  66
  67 /*-------------------------------------------------------------------*/
  68
  69 static int dabusb_add_buf_tail(pdabusb_t s, struct list_head *dst,
  70                                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 /*-------------------------------------------------------------------*/
  90 #ifdef DEBUG
  91 static 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 /*-------------------------------------------------------------------*/
 111 static 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 /*-------------------------------------------------------------------*/
 130 static 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
 140 #ifdef DEBUG
 141                 dump_urb(b->purb);
 142 #endif
 143                 kfree(b->purb->transfer_buffer);
 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 /*-------------------------------------------------------------------*/
 154 static 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 /*-------------------------------------------------------------------*/
 170 static void dabusb_iso_complete(struct urb *purb)
 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,
 185                                              usb_pipeout(pipe));
 186                 for (i = 0; i < purb->number_of_packets; i++)
 187                         if (!purb->iso_frame_desc[i].status) {
 188                                 len = purb->iso_frame_desc[i].actual_length;
 189                                 if (len <= pipesize) {
 190                                         memcpy(buf + dst, buf + purb->iso_frame_desc[i].offset, len);
 191                                         dst += len;
 192                                 } else
 193                                         dev_err(&purb->dev->dev,
 194                                                 "dabusb_iso_complete: invalid len %d\n",
 195                                                 len);
 196                         } else
 197                                 dev_warn(&purb->dev->dev,
 198                                          "dabusb_iso_complete: corrupted packet status: %d\n",
 199                                          purb->iso_frame_desc[i].status);
 200                 if (dst != purb->actual_length)
 201                         dev_err(&purb->dev->dev,
 202                                 "dst!=purb->actual_length:%d!=%d\n",
 203                                         dst, purb->actual_length);
 204         }
 205
 206         if (atomic_dec_and_test(&s->pending_io) &&
 207             !s->remove_pending && s->state != _stopped) {
 208                 s->overruns++;
 209                 dev_err(&purb->dev->dev, "overrun (%d)\n", s->overruns);
 210         }
 211         wake_up(&s->wait);
 212 }
 213 /*-------------------------------------------------------------------*/
 214 static int dabusb_alloc_buffers(pdabusb_t s)
 215 {
 216         int transfer_len = 0;
 217         pbuff_t b;
 218         unsigned int pipe = usb_rcvisocpipe(s->usbdev, _DABUSB_ISOPIPE);
 219         int pipesize = usb_maxpacket(s->usbdev, pipe, usb_pipeout(pipe));
 220         int packets = _ISOPIPESIZE / pipesize;
 221         int transfer_buffer_length = packets * pipesize;
 222         int i;
 223
 224         dbg("dabusb_alloc_buffers pipesize:%d packets:%d transfer_buffer_len:%d",
 225                  pipesize, packets, transfer_buffer_length);
 226
 227         while (transfer_len < (s->total_buffer_size << 10)) {
 228                 b = kzalloc(sizeof(buff_t), GFP_KERNEL);
 229                 if (!b) {
 230                         dev_err(&s->usbdev->dev,
 231                                 "kzalloc(sizeof(buff_t))==NULL\n");
 232                         goto err;
 233                 }
 234                 b->s = s;
 235                 b->purb = usb_alloc_urb(packets, GFP_KERNEL);
 236                 if (!b->purb) {
 237                         dev_err(&s->usbdev->dev, "usb_alloc_urb == NULL\n");
 238                         kfree(b);
 239                         goto err;
 240                 }
 241
 242                 b->purb->transfer_buffer = kmalloc(transfer_buffer_length,
 243                                                    GFP_KERNEL);
 244                 if (!b->purb->transfer_buffer) {
 245                         kfree(b->purb);
 246                         kfree(b);
 247                         dev_err(&s->usbdev->dev,
 248                                 "kmalloc(%d)==NULL\n", transfer_buffer_length);
 249                         goto err;
 250                 }
 251
 252                 b->purb->transfer_buffer_length = transfer_buffer_length;
 253                 b->purb->number_of_packets = packets;
 254                 b->purb->complete = dabusb_iso_complete;
 255                 b->purb->context = b;
 256                 b->purb->dev = s->usbdev;
 257                 b->purb->pipe = pipe;
 258                 b->purb->transfer_flags = URB_ISO_ASAP;
 259
 260                 for (i = 0; i < packets; i++) {
 261                         b->purb->iso_frame_desc[i].offset = i * pipesize;
 262                         b->purb->iso_frame_desc[i].length = pipesize;
 263                 }
 264
 265                 transfer_len += transfer_buffer_length;
 266                 list_add_tail(&b->buff_list, &s->free_buff_list);
 267         }
 268         s->got_mem = transfer_len;
 269
 270         return 0;
 271
 272 err:
 273         dabusb_free_buffers(s);
 274         return -ENOMEM;
 275 }
 276 /*-------------------------------------------------------------------*/
 277 static int dabusb_bulk(pdabusb_t s, pbulk_transfer_t pb)
 278 {
 279         int ret;
 280         unsigned int pipe;
 281         int actual_length;
 282
 283         dbg("dabusb_bulk");
 284
 285         if (!pb->pipe)
 286                 pipe = usb_rcvbulkpipe(s->usbdev, 2);
 287         else
 288                 pipe = usb_sndbulkpipe(s->usbdev, 2);
 289
 290         ret = usb_bulk_msg(s->usbdev, pipe, pb->data,
 291                            pb->size, &actual_length, 100);
 292         if (ret < 0) {
 293                 dev_err(&s->usbdev->dev,
 294                         "usb_bulk_msg failed(%d)\n", ret);
 295
 296                 if (usb_set_interface(s->usbdev, _DABUSB_IF, 1) < 0) {
 297                         dev_err(&s->usbdev->dev, "set_interface failed\n");
 298                         return -EINVAL;
 299                 }
 300
 301         }
 302
 303         if (ret == -EPIPE) {
 304                 dev_warn(&s->usbdev->dev, "CLEAR_FEATURE request to remove STALL condition.\n");
 305                 if (usb_clear_halt(s->usbdev, usb_pipeendpoint(pipe)))
 306                         dev_err(&s->usbdev->dev, "request failed\n");
 307         }
 308
 309         pb->size = actual_length;
 310         return ret;
 311 }
 312 /* --------------------------------------------------------------------- */
 313 static int dabusb_writemem(pdabusb_t s, int pos, const unsigned char *data,
 314                             int len)
 315 {
 316         int ret;
 317         unsigned char *transfer_buffer =  kmalloc(len, GFP_KERNEL);
 318
 319         if (!transfer_buffer) {
 320                 dev_err(&s->usbdev->dev,
 321                         "dabusb_writemem: kmalloc(%d) failed.\n", len);
 322                 return -ENOMEM;
 323         }
 324
 325         memcpy(transfer_buffer, data, len);
 326
 327         ret = usb_control_msg(s->usbdev, usb_sndctrlpipe(s->usbdev, 0),
 328                               0xa0, 0x40, pos, 0, transfer_buffer, len, 300);
 329
 330         kfree(transfer_buffer);
 331         return ret;
 332 }
 333 /* --------------------------------------------------------------------- */
 334 static int dabusb_8051_reset(pdabusb_t s, unsigned char reset_bit)
 335 {
 336         dbg("dabusb_8051_reset: %d", reset_bit);
 337         return dabusb_writemem(s, CPUCS_REG, &reset_bit, 1);
 338 }
 339 /* --------------------------------------------------------------------- */
 340 static int dabusb_loadmem(pdabusb_t s, const char *fname)
 341 {
 342         int ret;
 343         const struct ihex_binrec *rec;
 344         const struct firmware *uninitialized_var(fw);
 345
 346         dbg("Enter dabusb_loadmem (internal)");
 347
 348         ret = request_ihex_firmware(&fw, "dabusb/firmware.fw", &s->usbdev->dev);
 349         if (ret) {
 350                 dev_err(&s->usbdev->dev,
 351                         "Failed to load \"dabusb/firmware.fw\": %d\n", ret);
 352                 goto out;
 353         }
 354         ret = dabusb_8051_reset(s, 1);
 355
 356         for (rec = (const struct ihex_binrec *)fw->data; rec;
 357              rec = ihex_next_binrec(rec)) {
 358                 dbg("dabusb_writemem: %04X %p %d)", be32_to_cpu(rec->addr),
 359                     rec->data, be16_to_cpu(rec->len));
 360
 361                 ret = dabusb_writemem(s, be32_to_cpu(rec->addr), rec->data,
 362                                        be16_to_cpu(rec->len));
 363                 if (ret < 0) {
 364                         dev_err(&s->usbdev->dev,
 365                                 "dabusb_writemem failed (%d %04X %p %d)\n",
 366                                 ret, be32_to_cpu(rec->addr),
 367                                 rec->data, be16_to_cpu(rec->len));
 368                         break;
 369                 }
 370         }
 371         ret = dabusb_8051_reset(s, 0);
 372         release_firmware(fw);
 373  out:
 374         dbg("dabusb_loadmem: exit");
 375
 376         return ret;
 377 }
 378 /* --------------------------------------------------------------------- */
 379 static int dabusb_fpga_clear(pdabusb_t s, pbulk_transfer_t b)
 380 {
 381         b->size = 4;
 382         b->data[0] = 0x2a;
 383         b->data[1] = 0;
 384         b->data[2] = 0;
 385         b->data[3] = 0;
 386
 387         dbg("dabusb_fpga_clear");
 388
 389         return dabusb_bulk(s, b);
 390 }
 391 /* --------------------------------------------------------------------- */
 392 static int dabusb_fpga_init(pdabusb_t s, pbulk_transfer_t b)
 393 {
 394         b->size = 4;
 395         b->data[0] = 0x2c;
 396         b->data[1] = 0;
 397         b->data[2] = 0;
 398         b->data[3] = 0;
 399
 400         dbg("dabusb_fpga_init");
 401
 402         return dabusb_bulk(s, b);
 403 }
 404 /* --------------------------------------------------------------------- */
 405 static int dabusb_fpga_download(pdabusb_t s, const char *fname)
 406 {
 407         pbulk_transfer_t b = kmalloc(sizeof(bulk_transfer_t), GFP_KERNEL);
 408         const struct firmware *fw;
 409         unsigned int blen, n;
 410         int ret;
 411
 412         dbg("Enter dabusb_fpga_download (internal)");
 413
 414         if (!b) {
 415                 dev_err(&s->usbdev->dev,
 416                         "kmalloc(sizeof(bulk_transfer_t))==NULL\n");
 417                 return -ENOMEM;
 418         }
 419
 420         ret = request_firmware(&fw, "dabusb/bitstream.bin", &s->usbdev->dev);
 421         if (ret) {
 422                 dev_err(&s->usbdev->dev,
 423                         "Failed to load \"dabusb/bitstream.bin\": %d\n", ret);
 424                 kfree(b);
 425                 return ret;
 426         }
 427
 428         b->pipe = 1;
 429         ret = dabusb_fpga_clear(s, b);
 430         mdelay(10);
 431         blen = fw->data[73] + (fw->data[72] << 8);
 432
 433         dbg("Bitstream len: %i", blen);
 434
 435         b->data[0] = 0x2b;
 436         b->data[1] = 0;
 437         b->data[2] = 0;
 438         b->data[3] = 60;
 439
 440         for (n = 0; n <= blen + 60; n += 60) {
 441                 /* some cclks for startup */
 442                 b->size = 64;
 443                 memcpy(b->data + 4, fw->data + 74 + n, 60);
 444                 ret = dabusb_bulk(s, b);
 445                 if (ret < 0) {
 446                         dev_err(&s->usbdev->dev, "dabusb_bulk failed.\n");
 447                         break;
 448                 }
 449                 mdelay(1);
 450         }
 451
 452         ret = dabusb_fpga_init(s, b);
 453         kfree(b);
 454         release_firmware(fw);
 455
 456         dbg("exit dabusb_fpga_download");
 457
 458         return ret;
 459 }
 460
 461 static int dabusb_stop(pdabusb_t s)
 462 {
 463         dbg("dabusb_stop");
 464
 465         s->state = _stopped;
 466         dabusb_cancel_queue(s, &s->rec_buff_list);
 467
 468         dbg("pending_io: %d", s->pending_io.counter);
 469
 470         s->pending_io.counter = 0;
 471         return 0;
 472 }
 473
 474 static int dabusb_startrek(pdabusb_t s)
 475 {
 476         if (!s->got_mem && s->state != _started) {
 477
 478                 dbg("dabusb_startrek");
 479
 480                 if (dabusb_alloc_buffers(s) < 0)
 481                         return -ENOMEM;
 482                 dabusb_stop(s);
 483                 s->state = _started;
 484                 s->readptr = 0;
 485         }
 486
 487         if (!list_empty(&s->free_buff_list)) {
 488                 pbuff_t end;
 489                 int ret;
 490
 491         while (!dabusb_add_buf_tail(s, &s->rec_buff_list, &s->free_buff_list)) {
 492
 493                         dbg("submitting: end:%p s->rec_buff_list:%p",
 494                             s->rec_buff_list.prev, &s->rec_buff_list);
 495
 496                         end = list_entry(s->rec_buff_list.prev,
 497                                          buff_t, buff_list);
 498
 499                         ret = usb_submit_urb(end->purb, GFP_KERNEL);
 500                         if (ret) {
 501                                 dev_err(&s->usbdev->dev,
 502                                         "usb_submit_urb returned:%d\n", ret);
 503                                 if (dabusb_add_buf_tail(s, &s->free_buff_list,
 504                                                         &s->rec_buff_list))
 505                                         dev_err(&s->usbdev->dev,
 506                                                 "startrek: dabusb_add_buf_tail failed\n");
 507                                 break;
 508                         } else
 509                                 atomic_inc(&s->pending_io);
 510                 }
 511                 dbg("pending_io: %d", s->pending_io.counter);
 512         }
 513
 514         return 0;
 515 }
 516
 517 static ssize_t dabusb_read(struct file *file, char __user *buf,
 518                            size_t count, loff_t *ppos)
 519 {
 520         pdabusb_t s = (pdabusb_t)file->private_data;
 521         unsigned long flags;
 522         unsigned ret = 0;
 523         int rem;
 524         int cnt;
 525         pbuff_t b;
 526         struct urb *purb = NULL;
 527
 528         dbg("dabusb_read");
 529
 530         if (*ppos)
 531                 return -ESPIPE;
 532
 533         if (s->remove_pending)
 534                 return -EIO;
 535
 536
 537         if (!s->usbdev)
 538                 return -EIO;
 539
 540         while (count > 0) {
 541                 dabusb_startrek(s);
 542
 543                 spin_lock_irqsave(&s->lock, flags);
 544
 545                 if (list_empty(&s->rec_buff_list)) {
 546
 547                         spin_unlock_irqrestore(&s->lock, flags);
 548
 549                         dev_err(&s->usbdev->dev,
 550                                 "error: rec_buf_list is empty\n");
 551                         goto err;
 552                 }
 553
 554                 b = list_entry(s->rec_buff_list.next, buff_t, buff_list);
 555                 purb = b->purb;
 556
 557                 spin_unlock_irqrestore(&s->lock, flags);
 558
 559                 if (purb->status == -EINPROGRESS) {
 560                         /* return nonblocking */
 561                         if (file->f_flags & O_NONBLOCK) {
 562                                 if (!ret)
 563                                         ret = -EAGAIN;
 564                                 goto err;
 565                         }
 566
 567                         interruptible_sleep_on(&s->wait);
 568
 569                         if (signal_pending(current)) {
 570                                 if (!ret)
 571                                         ret = -ERESTARTSYS;
 572                                 goto err;
 573                         }
 574
 575                         spin_lock_irqsave(&s->lock, flags);
 576
 577                         if (list_empty(&s->rec_buff_list)) {
 578                                 spin_unlock_irqrestore(&s->lock, flags);
 579                                 dev_err(&s->usbdev->dev,
 580                                         "error: still no buffer available.\n");
 581                                 goto err;
 582                         }
 583                         spin_unlock_irqrestore(&s->lock, flags);
 584                         s->readptr = 0;
 585                 }
 586                 if (s->remove_pending) {
 587                         ret = -EIO;
 588                         goto err;
 589                 }
 590
 591                 /* set remaining bytes to copy */
 592                 rem = purb->actual_length - s->readptr;
 593
 594                 if (count >= rem)
 595                         cnt = rem;
 596                 else
 597                         cnt = count;
 598
 599                 dbg("copy_to_user:%p %p %d", buf,
 600                     purb->transfer_buffer + s->readptr, cnt);
 601
 602                 if (copy_to_user(buf,
 603                                 purb->transfer_buffer + s->readptr,
 604                                 cnt)) {
 605                         dev_err(&s->usbdev->dev, "read: copy_to_user failed\n");
 606                         if (!ret)
 607                                 ret = -EFAULT;
 608                         goto err;
 609                 }
 610
 611                 s->readptr += cnt;
 612                 count -= cnt;
 613                 buf += cnt;
 614                 ret += cnt;
 615
 616                 if (s->readptr == purb->actual_length) {
 617                         /* finished, take next buffer */
 618                         if (dabusb_add_buf_tail(s, &s->free_buff_list,
 619                                                 &s->rec_buff_list))
 620                                 dev_err(&s->usbdev->dev,
 621                                         "read: dabusb_add_buf_tail failed\n");
 622                         s->readptr = 0;
 623                 }
 624         }
 625 err:                    /*mutex_unlock(&s->mutex);*/
 626         return ret;
 627 }
 628
 629 static int dabusb_open(struct inode *inode, struct file *file)
 630 {
 631         int devnum = iminor(inode);
 632         pdabusb_t s;
 633         int r;
 634
 635         if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB))
 636                 return -EIO;
 637
 638         s = &dabusb[devnum - DABUSB_MINOR];
 639
 640         dbg("dabusb_open");
 641         mutex_lock(&s->mutex);
 642
 643         while (!s->usbdev || s->opened) {
 644                 mutex_unlock(&s->mutex);
 645
 646                 if (file->f_flags & O_NONBLOCK)
 647                         return -EBUSY;
 648                 msleep_interruptible(500);
 649
 650                 if (signal_pending(current))
 651                         return -EAGAIN;
 652                 mutex_lock(&s->mutex);
 653         }
 654         if (usb_set_interface(s->usbdev, _DABUSB_IF, 1) < 0) {
 655                 mutex_unlock(&s->mutex);
 656                 dev_err(&s->usbdev->dev, "set_interface failed\n");
 657                 return -EINVAL;
 658         }
 659         s->opened = 1;
 660         mutex_unlock(&s->mutex);
 661
 662         file->f_pos = 0;
 663         file->private_data = s;
 664
 665         r = nonseekable_open(inode, file);
 666         return r;
 667 }
 668
 669 static int dabusb_release(struct inode *inode, struct file *file)
 670 {
 671         pdabusb_t s = (pdabusb_t)file->private_data;
 672
 673         dbg("dabusb_release");
 674
 675         mutex_lock(&s->mutex);
 676         dabusb_stop(s);
 677         dabusb_free_buffers(s);
 678         mutex_unlock(&s->mutex);
 679
 680         if (!s->remove_pending) {
 681                 if (usb_set_interface(s->usbdev, _DABUSB_IF, 0) < 0)
 682                         dev_err(&s->usbdev->dev, "set_interface failed\n");
 683         } else
 684                 wake_up(&s->remove_ok);
 685
 686         s->opened = 0;
 687         return 0;
 688 }
 689
 690 static long dabusb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 691 {
 692         pdabusb_t s = (pdabusb_t)file->private_data;
 693         pbulk_transfer_t pbulk;
 694         int ret = 0;
 695         int version = DABUSB_VERSION;
 696
 697         dbg("dabusb_ioctl");
 698
 699         if (s->remove_pending)
 700                 return -EIO;
 701
 702         mutex_lock(&s->mutex);
 703
 704         if (!s->usbdev) {
 705                 mutex_unlock(&s->mutex);
 706                 return -EIO;
 707         }
 708
 709         switch (cmd) {
 710
 711         case IOCTL_DAB_BULK:
 712                 pbulk = memdup_user((void __user *)arg,
 713                                     sizeof(bulk_transfer_t));
 714
 715                 if (IS_ERR(pbulk)) {
 716                         ret = PTR_ERR(pbulk);
 717                         break;
 718                 }
 719
 720                 ret = dabusb_bulk(s, pbulk);
 721                 if (ret == 0)
 722                         if (copy_to_user((void __user *)arg, pbulk,
 723                                          sizeof(bulk_transfer_t)))
 724                                 ret = -EFAULT;
 725                 kfree(pbulk);
 726                 break;
 727
 728         case IOCTL_DAB_OVERRUNS:
 729                 ret = put_user(s->overruns, (unsigned int __user *) arg);
 730                 break;
 731
 732         case IOCTL_DAB_VERSION:
 733                 ret = put_user(version, (unsigned int __user *) arg);
 734                 break;
 735
 736         default:
 737                 ret = -ENOIOCTLCMD;
 738                 break;
 739         }
 740         mutex_unlock(&s->mutex);
 741         return ret;
 742 }
 743
 744 static const struct file_operations dabusb_fops = {
 745         .owner =        THIS_MODULE,
 746         .llseek =       no_llseek,
 747         .read =         dabusb_read,
 748         .unlocked_ioctl =       dabusb_ioctl,
 749         .open =         dabusb_open,
 750         .release =      dabusb_release,
 751 };
 752
 753 static char *dabusb_devnode(struct device *dev, mode_t *mode)
 754 {
 755         return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
 756 }
 757
 758 static struct usb_class_driver dabusb_class = {
 759         .name =         "dabusb%d",
 760         .devnode =      dabusb_devnode,
 761         .fops =         &dabusb_fops,
 762         .minor_base =   DABUSB_MINOR,
 763 };
 764
 765
 766 /* --------------------------------------------------------------------- */
 767 static int dabusb_probe(struct usb_interface *intf,
 768                          const struct usb_device_id *id)
 769 {
 770         struct usb_device *usbdev = interface_to_usbdev(intf);
 771         int retval;
 772         pdabusb_t s;
 773
 774         dbg("dabusb: probe: vendor id 0x%x, device id 0x%x ifnum:%d",
 775             le16_to_cpu(usbdev->descriptor.idVendor),
 776             le16_to_cpu(usbdev->descriptor.idProduct),
 777             intf->altsetting->desc.bInterfaceNumber);
 778
 779         /* We don't handle multiple configurations */
 780         if (usbdev->descriptor.bNumConfigurations != 1)
 781                 return -ENODEV;
 782
 783         if (intf->altsetting->desc.bInterfaceNumber != _DABUSB_IF &&
 784             le16_to_cpu(usbdev->descriptor.idProduct) == 0x9999)
 785                 return -ENODEV;
 786
 787
 788
 789         s = &dabusb[intf->minor];
 790
 791         mutex_lock(&s->mutex);
 792         s->remove_pending = 0;
 793         s->usbdev = usbdev;
 794         s->devnum = intf->minor;
 795
 796         if (usb_reset_configuration(usbdev) < 0) {
 797                 dev_err(&intf->dev, "reset_configuration failed\n");
 798                 goto reject;
 799         }
 800         if (le16_to_cpu(usbdev->descriptor.idProduct) == 0x2131) {
 801                 dabusb_loadmem(s, NULL);
 802                 goto reject;
 803         } else {
 804                 dabusb_fpga_download(s, NULL);
 805
 806                 if (usb_set_interface(s->usbdev, _DABUSB_IF, 0) < 0) {
 807                         dev_err(&intf->dev, "set_interface failed\n");
 808                         goto reject;
 809                 }
 810         }
 811         dbg("bound to interface: %d", intf->altsetting->desc.bInterfaceNumber);
 812         usb_set_intfdata(intf, s);
 813         mutex_unlock(&s->mutex);
 814
 815         retval = usb_register_dev(intf, &dabusb_class);
 816         if (retval) {
 817                 usb_set_intfdata(intf, NULL);
 818                 return -ENOMEM;
 819         }
 820
 821         return 0;
 822
 823 reject:
 824         mutex_unlock(&s->mutex);
 825         s->usbdev = NULL;
 826         return -ENODEV;
 827 }
 828
 829 static void dabusb_disconnect(struct usb_interface *intf)
 830 {
 831         wait_queue_t __wait;
 832         pdabusb_t s = usb_get_intfdata(intf);
 833
 834         dbg("dabusb_disconnect");
 835
 836         init_waitqueue_entry(&__wait, current);
 837
 838         usb_set_intfdata(intf, NULL);
 839         if (s) {
 840                 usb_deregister_dev(intf, &dabusb_class);
 841                 s->remove_pending = 1;
 842                 wake_up(&s->wait);
 843                 add_wait_queue(&s->remove_ok, &__wait);
 844                 set_current_state(TASK_UNINTERRUPTIBLE);
 845                 if (s->state == _started)
 846                         schedule();
 847                 current->state = TASK_RUNNING;
 848                 remove_wait_queue(&s->remove_ok, &__wait);
 849
 850                 s->usbdev = NULL;
 851                 s->overruns = 0;
 852         }
 853 }
 854
 855 static struct usb_device_id dabusb_ids[] = {
 856         /* { USB_DEVICE(0x0547, 0x2131) },*/    /* An2131 chip, no boot ROM */
 857         { USB_DEVICE(0x0547, 0x9999) },
 858         { }                                             /* Terminating entry */
 859 };
 860
 861 MODULE_DEVICE_TABLE(usb, dabusb_ids);
 862
 863 static struct usb_driver dabusb_driver = {
 864         .name =         "dabusb",
 865         .probe =        dabusb_probe,
 866         .disconnect =   dabusb_disconnect,
 867         .id_table =     dabusb_ids,
 868 };
 869
 870 /* --------------------------------------------------------------------- */
 871
 872 static int __init dabusb_init(void)
 873 {
 874         int retval;
 875         unsigned u;
 876
 877         /* initialize struct */
 878         for (u = 0; u < NRDABUSB; u++) {
 879                 pdabusb_t s = &dabusb[u];
 880                 memset(s, 0, sizeof(dabusb_t));
 881                 mutex_init(&s->mutex);
 882                 s->usbdev = NULL;
 883                 s->total_buffer_size = buffers;
 884                 init_waitqueue_head(&s->wait);
 885                 init_waitqueue_head(&s->remove_ok);
 886                 spin_lock_init(&s->lock);
 887                 INIT_LIST_HEAD(&s->free_buff_list);
 888                 INIT_LIST_HEAD(&s->rec_buff_list);
 889         }
 890
 891         /* register misc device */
 892         retval = usb_register(&dabusb_driver);
 893         if (retval)
 894                 goto out;
 895
 896         dbg("dabusb_init: driver registered");
 897
 898         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 899                DRIVER_DESC "\n");
 900
 901 out:
 902         return retval;
 903 }
 904
 905 static void __exit dabusb_cleanup(void)
 906 {
 907         dbg("dabusb_cleanup");
 908
 909         usb_deregister(&dabusb_driver);
 910 }
 911
 912 /* --------------------------------------------------------------------- */
 913
 914 MODULE_AUTHOR(DRIVER_AUTHOR);
 915 MODULE_DESCRIPTION(DRIVER_DESC);
 916 MODULE_LICENSE("GPL");
 917 MODULE_FIRMWARE("dabusb/firmware.fw");
 918 MODULE_FIRMWARE("dabusb/bitstream.bin");
 919
 920 module_param(buffers, int, 0);
 921 MODULE_PARM_DESC(buffers, "Number of buffers (default=256)");
 922
 923 module_init(dabusb_init);
 924 module_exit(dabusb_cleanup);
 925
 926 /* --------------------------------------------------------------------- */