drivers/usb/mdc800.c

   1 /*
   2  * copyright (C) 1999/2000 by Henning Zabel <henning@uni-paderborn.de>
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the
   6  * Free Software Foundation; either version 2 of the License, or (at your
   7  * option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19
  20 /*
  21  *      USB-Kernel Driver for the Mustek MDC800 Digital Camera
  22  *      (c) 1999/2000 Henning Zabel <henning@uni-paderborn.de>
  23  *
  24  *
  25  * The driver brings the USB functions of the MDC800 to Linux.
  26  * To use the Camera you must support the USB Protocoll of the camera
  27  * to the Kernel Node.
  28  * The Driver uses a misc device Node. Create it with :
  29  * mknod /dev/mustek c 180 32
  30  *
  31  * The driver supports only one camera.
  32  *
  33  * version 0.7.5
  34  * Fixed potential SMP races with Spinlocks.
  35  * Thanks to Oliver Neukum <oliver.neukum@lrz.uni-muenchen.de> who
  36  * noticed the race conditions.
  37  * (30/10/2000)
  38  *
  39  * Fixed: Setting urb->dev before submitting urb.
  40  * by Greg KH <greg@kroah.com>
  41  * (13/10/2000)
  42  *
  43  * version 0.7.3
  44  * bugfix : The mdc800->state field gets set to READY after the
  45  * the diconnect function sets it to NOT_CONNECTED. This makes the
  46  * driver running like the camera is connected and causes some
  47  * hang ups.
  48  *
  49  * version 0.7.1
  50  * MOD_INC and MOD_DEC are changed in usb_probe to prevent load/unload
  51  * problems when compiled as Module.
  52  * (04/04/2000)
  53  *
  54  * The mdc800 driver gets assigned the USB Minor 32-47. The Registration
  55  * was updated to use these values.
  56  * (26/03/2000)
  57  *
  58  * The Init und Exit Module Function are updated.
  59  * (01/03/2000)
  60  *
  61  * version 0.7.0
  62  * Rewrite of the driver : The driver now uses URB's. The old stuff
  63  * has been removed.
  64  *
  65  * version 0.6.0
  66  * Rewrite of this driver: The Emulation of the rs232 protocoll
  67  * has been removed from the driver. A special executeCommand function
  68  * for this driver is included to gphoto.
  69  * The driver supports two kind of communication to bulk endpoints.
  70  * Either with the dev->bus->ops->bulk... or with callback function.
  71  * (09/11/1999)
  72  *
  73  * version 0.5.0:
  74  * first Version that gets a version number. Most of the needed
  75  * functions work.
  76  * (20/10/1999)
  77  */
  78
  79 #include <linux/version.h>
  80 #include <linux/sched.h>
  81 #include <linux/signal.h>
  82 #include <linux/spinlock.h>
  83 #include <linux/errno.h>
  84 #include <linux/random.h>
  85 #include <linux/poll.h>
  86 #include <linux/init.h>
  87 #include <linux/malloc.h>
  88 #include <linux/module.h>
  89 #include <linux/smp_lock.h>
  90
  91 #include <linux/usb.h>
  92
  93 #define VERSION         "0.7.5"
  94 #define RELEASE_DATE    "(30/10/2000)"
  95
  96 /* Vendor and Product Information */
  97 #define MDC800_VENDOR_ID        0x055f
  98 #define MDC800_PRODUCT_ID       0xa800
  99
 100 /* Timeouts (msec) */
 101 #define TO_DOWNLOAD_GET_READY           1500
 102 #define TO_DOWNLOAD_GET_BUSY            1500
 103 #define TO_WRITE_GET_READY              1000
 104 #define TO_DEFAULT_COMMAND              5000
 105 #define TO_READ_FROM_IRQ                TO_DEFAULT_COMMAND
 106 #define TO_GET_READY                    TO_DEFAULT_COMMAND
 107
 108 /* Minor Number of the device (create with mknod /dev/mustek c 180 32) */
 109 #define MDC800_DEVICE_MINOR_BASE 32
 110
 111
 112 /**************************************************************************
 113         Data and structs
 114 ***************************************************************************/
 115
 116
 117 typedef enum {
 118         NOT_CONNECTED, READY, WORKING, DOWNLOAD
 119 } mdc800_state;
 120
 121
 122 /* Data for the driver */
 123 struct mdc800_data
 124 {
 125         struct usb_device *     dev;                    // Device Data
 126         mdc800_state            state;
 127
 128         unsigned int            endpoint [4];
 129
 130         purb_t                  irq_urb;
 131         wait_queue_head_t       irq_wait;
 132         char*                   irq_urb_buffer;
 133
 134         int                     camera_busy;          // is camera busy ?
 135         int                     camera_request_ready; // Status to synchronize with irq
 136         char                    camera_response [8];  // last Bytes send after busy
 137
 138         purb_t                  write_urb;
 139         char*                   write_urb_buffer;
 140         wait_queue_head_t       write_wait;
 141
 142
 143         purb_t                  download_urb;
 144         char*                   download_urb_buffer;
 145         wait_queue_head_t       download_wait;
 146         int                     download_left;          // Bytes left to download ?
 147
 148
 149         /* Device Data */
 150         char                    out [64];       // Answer Buffer
 151         int                     out_ptr;        // Index to the first not readen byte
 152         int                     out_count;      // Bytes in the buffer
 153
 154         int                     open;           // Camera device open ?
 155         spinlock_t              io_lock;        // IO -lock
 156
 157         char                    in [8];         // Command Input Buffer
 158         int                     in_count;
 159
 160         int                     pic_index;      // Cache for the Imagesize (-1 for nothing cached )
 161         int                     pic_len;
 162 };
 163
 164
 165 /* Specification of the Endpoints */
 166 static struct usb_endpoint_descriptor mdc800_ed [4] =
 167 {
 168         { 0,0, 0x01, 0x02,  8, 0,0,0 },
 169         { 0,0, 0x82, 0x03,  8, 0,0,0 },
 170         { 0,0, 0x03, 0x02, 64, 0,0,0 },
 171         { 0,0, 0x84, 0x02, 64, 0,0,0 }
 172 };
 173
 174
 175 /* The Variable used by the driver */
 176 static struct mdc800_data* mdc800=0;
 177
 178
 179 /***************************************************************************
 180         The USB Part of the driver
 181 ****************************************************************************/
 182
 183 static int mdc800_endpoint_equals (struct usb_endpoint_descriptor *a,struct usb_endpoint_descriptor *b)
 184 {
 185         return (
 186                    ( a->bEndpointAddress == b->bEndpointAddress )
 187                 && ( a->bmAttributes     == b->bmAttributes     )
 188                 && ( a->wMaxPacketSize   == b->wMaxPacketSize   )
 189         );
 190 }
 191
 192
 193 /*
 194  * Checks wether the camera responds busy
 195  */
 196 static int mdc800_isBusy (char* ch)
 197 {
 198         int i=0;
 199         while (i<8)
 200         {
 201                 if (ch [i] != (char)0x99)
 202                         return 0;
 203                 i++;
 204         }
 205         return 1;
 206 }
 207
 208
 209 /*
 210  * Checks wether the Camera is ready
 211  */
 212 static int mdc800_isReady (char *ch)
 213 {
 214         int i=0;
 215         while (i<8)
 216         {
 217                 if (ch [i] != (char)0xbb)
 218                         return 0;
 219                 i++;
 220         }
 221         return 1;
 222 }
 223
 224
 225
 226 /*
 227  * USB IRQ Handler for InputLine
 228  */
 229 static void mdc800_usb_irq (struct urb *urb)
 230 {
 231         int data_received=0, wake_up;
 232         unsigned char* b=urb->transfer_buffer;
 233         struct mdc800_data* mdc800=urb->context;
 234
 235         if (urb->status >= 0)
 236         {
 237
 238                 //dbg ("%i %i %i %i %i %i %i %i \n",b[0],b[1],b[2],b[3],b[4],b[5],b[6],b[7]);
 239
 240                 if (mdc800_isBusy (b))
 241                 {
 242                         if (!mdc800->camera_busy)
 243                         {
 244                                 mdc800->camera_busy=1;
 245                                 dbg ("gets busy");
 246                         }
 247                 }
 248                 else
 249                 {
 250                         if (mdc800->camera_busy && mdc800_isReady (b))
 251                         {
 252                                 mdc800->camera_busy=0;
 253                                 dbg ("gets ready");
 254                         }
 255                 }
 256                 if (!(mdc800_isBusy (b) || mdc800_isReady (b)))
 257                 {
 258                         /* Store Data in camera_answer field */
 259                         dbg ("%i %i %i %i %i %i %i %i ",b[0],b[1],b[2],b[3],b[4],b[5],b[6],b[7]);
 260
 261                         memcpy (mdc800->camera_response,b,8);
 262                         data_received=1;
 263                 }
 264         }
 265         wake_up= ( mdc800->camera_request_ready > 0 )
 266                 &&
 267                 (
 268                         ((mdc800->camera_request_ready == 1) && (!mdc800->camera_busy))
 269                 ||
 270                         ((mdc800->camera_request_ready == 2) && data_received)
 271                 ||
 272                         ((mdc800->camera_request_ready == 3) && (mdc800->camera_busy))
 273                 ||
 274                         (urb->status < 0)
 275                 );
 276
 277         if (wake_up)
 278         {
 279                 mdc800->camera_request_ready=0;
 280                 wake_up_interruptible (&mdc800->irq_wait);
 281         }
 282 }
 283
 284
 285 /*
 286  * Waits a while until the irq responds that camera is ready
 287  *
 288  *  mode : 0: Wait for camera gets ready
 289  *         1: Wait for receiving data
 290  *         2: Wait for camera gets busy
 291  *
 292  * msec: Time to wait
 293  */
 294 static int mdc800_usb_waitForIRQ (int mode, int msec)
 295 {
 296         mdc800->camera_request_ready=1+mode;
 297
 298         interruptible_sleep_on_timeout (&mdc800->irq_wait, msec*HZ/1000);
 299
 300         if (mdc800->camera_request_ready>0)
 301         {
 302                 mdc800->camera_request_ready=0;
 303                 err ("timeout waiting for camera.");
 304                 return -1;
 305         }
 306
 307         if (mdc800->state == NOT_CONNECTED)
 308         {
 309                 warn ("Camera gets disconnected during waiting for irq.");
 310                 mdc800->camera_request_ready=0;
 311                 return -2;
 312         }
 313
 314         return 0;
 315 }
 316
 317
 318 /*
 319  * The write_urb callback function
 320  */
 321 static void mdc800_usb_write_notify (struct urb *urb)
 322 {
 323         struct mdc800_data* mdc800=urb->context;
 324
 325         if (urb->status != 0)
 326         {
 327                 err ("writing command fails (status=%i)", urb->status);
 328         }
 329         else
 330         {
 331                 mdc800->state=READY;
 332         }
 333         wake_up_interruptible (&mdc800->write_wait);
 334 }
 335
 336
 337 /*
 338  * The download_urb callback function
 339  */
 340 static void mdc800_usb_download_notify (struct urb *urb)
 341 {
 342         struct mdc800_data* mdc800=urb->context;
 343
 344         if (urb->status == 0)
 345         {
 346                 /* Fill output buffer with these data */
 347                 memcpy (mdc800->out,  urb->transfer_buffer, 64);
 348                 mdc800->out_count=64;
 349                 mdc800->out_ptr=0;
 350                 mdc800->download_left-=64;
 351                 if (mdc800->download_left == 0)
 352                 {
 353                         mdc800->state=READY;
 354                 }
 355         }
 356         else
 357         {
 358                 err ("request bytes fails (status:%i)", urb->status);
 359         }
 360         wake_up_interruptible (&mdc800->download_wait);
 361 }
 362
 363
 364 /***************************************************************************
 365         Probing for the Camera
 366  ***************************************************************************/
 367
 368 static struct usb_driver mdc800_usb_driver;
 369
 370 /*
 371  * Callback to search the Mustek MDC800 on the USB Bus
 372  */
 373 static void* mdc800_usb_probe (struct usb_device *dev ,unsigned int ifnum,
 374                                const struct usb_device_id *id)
 375 {
 376         int i,j;
 377         struct usb_interface_descriptor *intf_desc;
 378         int irq_interval=0;
 379
 380         dbg ("(mdc800_usb_probe) called.");
 381
 382
 383         if (mdc800->dev != 0)
 384         {
 385                 warn ("only one Mustek MDC800 is supported.");
 386                 return 0;
 387         }
 388
 389         if (dev->descriptor.bNumConfigurations != 1)
 390         {
 391                 err ("probe fails -> wrong Number of Configuration");
 392                 return 0;
 393         }
 394         intf_desc=&dev->actconfig->interface[ifnum].altsetting[0];
 395
 396         if (
 397                         ( intf_desc->bInterfaceClass != 0xff )
 398                 ||      ( intf_desc->bInterfaceSubClass != 0 )
 399                 || ( intf_desc->bInterfaceProtocol != 0 )
 400                 || ( intf_desc->bNumEndpoints != 4)
 401         )
 402         {
 403                 err ("probe fails -> wrong Interface");
 404                 return 0;
 405         }
 406
 407         /* Check the Endpoints */
 408         for (i=0; i<4; i++)
 409         {
 410                 mdc800->endpoint[i]=-1;
 411                 for (j=0; j<4; j++)
 412                 {
 413                         if (mdc800_endpoint_equals (&intf_desc->endpoint [j],&mdc800_ed [i]))
 414                         {
 415                                 mdc800->endpoint[i]=intf_desc->endpoint [j].bEndpointAddress ;
 416                                 if (i==1)
 417                                 {
 418                                         irq_interval=intf_desc->endpoint [j].bInterval;
 419                                 }
 420
 421                                 continue;
 422                         }
 423                 }
 424                 if (mdc800->endpoint[i] == -1)
 425                 {
 426                         err ("probe fails -> Wrong Endpoints.");
 427                         return 0;
 428                 }
 429         }
 430
 431
 432         usb_driver_claim_interface (&mdc800_usb_driver, &dev->actconfig->interface[ifnum], mdc800);
 433         if (usb_set_interface (dev, ifnum, 0) < 0)
 434         {
 435                 err ("MDC800 Configuration fails.");
 436                 return 0;
 437         }
 438
 439         info ("Found Mustek MDC800 on USB.");
 440
 441         spin_lock (&mdc800->io_lock);
 442
 443         mdc800->dev=dev;
 444         mdc800->open=0;
 445
 446         /* Setup URB Structs */
 447         FILL_INT_URB (
 448                 mdc800->irq_urb,
 449                 mdc800->dev,
 450                 usb_rcvintpipe (mdc800->dev,mdc800->endpoint [1]),
 451                 mdc800->irq_urb_buffer,
 452                 8,
 453                 mdc800_usb_irq,
 454                 mdc800,
 455                 irq_interval
 456         );
 457
 458         FILL_BULK_URB (
 459                 mdc800->write_urb,
 460                 mdc800->dev,
 461                 usb_sndbulkpipe (mdc800->dev, mdc800->endpoint[0]),
 462                 mdc800->write_urb_buffer,
 463                 8,
 464                 mdc800_usb_write_notify,
 465                 mdc800
 466         );
 467
 468         FILL_BULK_URB (
 469                 mdc800->download_urb,
 470                 mdc800->dev,
 471                 usb_rcvbulkpipe (mdc800->dev, mdc800->endpoint [3]),
 472                 mdc800->download_urb_buffer,
 473                 64,
 474                 mdc800_usb_download_notify,
 475                 mdc800
 476         );
 477
 478         mdc800->state=READY;
 479
 480         spin_unlock (&mdc800->io_lock);
 481
 482         return mdc800;
 483 }
 484
 485
 486 /*
 487  * Disconnect USB device (maybe the MDC800)
 488  */
 489 static void mdc800_usb_disconnect (struct usb_device *dev,void* ptr)
 490 {
 491         struct mdc800_data* mdc800=(struct mdc800_data*) ptr;
 492
 493         dbg ("(mdc800_usb_disconnect) called");
 494
 495         if (mdc800->state == NOT_CONNECTED)
 496                 return;
 497
 498         mdc800->state=NOT_CONNECTED;
 499
 500         usb_unlink_urb (mdc800->irq_urb);
 501         usb_unlink_urb (mdc800->write_urb);
 502         usb_unlink_urb (mdc800->download_urb);
 503
 504         usb_driver_release_interface (&mdc800_usb_driver, &dev->actconfig->interface[1]);
 505
 506         mdc800->dev=0;
 507         info ("Mustek MDC800 disconnected from USB.");
 508 }
 509
 510
 511 /***************************************************************************
 512         The Misc device Part (file_operations)
 513 ****************************************************************************/
 514
 515 /*
 516  * This Function calc the Answersize for a command.
 517  */
 518 static int mdc800_getAnswerSize (char command)
 519 {
 520         switch ((unsigned char) command)
 521         {
 522                 case 0x2a:
 523                 case 0x49:
 524                 case 0x51:
 525                 case 0x0d:
 526                 case 0x20:
 527                 case 0x07:
 528                 case 0x01:
 529                 case 0x25:
 530                 case 0x00:
 531                         return 8;
 532
 533                 case 0x05:
 534                 case 0x3e:
 535                         return mdc800->pic_len;
 536
 537                 case 0x09:
 538                         return 4096;
 539
 540                 default:
 541                         return 0;
 542         }
 543 }
 544
 545
 546 /*
 547  * Init the device: (1) alloc mem (2) Increase MOD Count ..
 548  */
 549 static int mdc800_device_open (struct inode* inode, struct file *file)
 550 {
 551         int retval=0;
 552         int errn=0;
 553
 554         spin_lock (&mdc800->io_lock);
 555
 556         if (mdc800->state == NOT_CONNECTED)
 557         {
 558                 errn=-EBUSY;
 559                 goto error_out;
 560         }
 561         if (mdc800->open)
 562         {
 563                 errn=-EBUSY;
 564                 goto error_out;
 565         }
 566
 567         mdc800->in_count=0;
 568         mdc800->out_count=0;
 569         mdc800->out_ptr=0;
 570         mdc800->pic_index=0;
 571         mdc800->pic_len=-1;
 572         mdc800->download_left=0;
 573
 574         mdc800->camera_busy=0;
 575         mdc800->camera_request_ready=0;
 576
 577         retval=0;
 578         mdc800->irq_urb->dev = mdc800->dev;
 579         if (usb_submit_urb (mdc800->irq_urb))
 580         {
 581                 err ("request USB irq fails (submit_retval=%i urb_status=%i).",retval, mdc800->irq_urb->status);
 582                 errn = -EIO;
 583                 goto error_out;
 584         }
 585
 586         mdc800->open=1;
 587         dbg ("Mustek MDC800 device opened.");
 588
 589 error_out:
 590         spin_unlock (&mdc800->io_lock);
 591         return errn;
 592 }
 593
 594
 595 /*
 596  * Close the Camera and release Memory
 597  */
 598 static int mdc800_device_release (struct inode* inode, struct file *file)
 599 {
 600         int retval=0;
 601         dbg ("Mustek MDC800 device closed.");
 602
 603         spin_lock (&mdc800->io_lock);
 604         if (mdc800->open && (mdc800->state != NOT_CONNECTED))
 605         {
 606                 mdc800->open=0;
 607                 usb_unlink_urb (mdc800->irq_urb);
 608                 usb_unlink_urb (mdc800->write_urb);
 609                 usb_unlink_urb (mdc800->download_urb);
 610         }
 611         else
 612         {
 613                 retval=-EIO;
 614         }
 615         spin_unlock (&mdc800->io_lock);
 616
 617         return retval;
 618 }
 619
 620
 621 /*
 622  * The Device read callback Function
 623  */
 624 static ssize_t mdc800_device_read (struct file *file, char *buf, size_t len, loff_t *pos)
 625 {
 626         int   left=len, sts=len; /* single transfer size */
 627         char* ptr=buf;
 628
 629         spin_lock (&mdc800->io_lock);
 630         if (mdc800->state == NOT_CONNECTED)
 631         {
 632                 spin_unlock (&mdc800->io_lock);
 633                 return -EBUSY;
 634         }
 635         if (mdc800->state == WORKING)
 636         {
 637                 warn ("Illegal State \"working\" reached during read ?!");
 638                 spin_unlock (&mdc800->io_lock);
 639                 return -EBUSY;
 640         }
 641         if (!mdc800->open)
 642         {
 643                 spin_unlock (&mdc800->io_lock);
 644                 return -EBUSY;
 645         }
 646
 647         while (left)
 648         {
 649                 if (signal_pending (current))
 650                 {
 651                         spin_unlock (&mdc800->io_lock);
 652                         return -EINTR;
 653                 }
 654
 655                 sts=left > (mdc800->out_count-mdc800->out_ptr)?mdc800->out_count-mdc800->out_ptr:left;
 656
 657                 if (sts <= 0)
 658                 {
 659                         /* Too less Data in buffer */
 660                         if (mdc800->state == DOWNLOAD)
 661                         {
 662                                 mdc800->out_count=0;
 663                                 mdc800->out_ptr=0;
 664
 665                                 /* Download -> Request new bytes */
 666                                 mdc800->download_urb->dev = mdc800->dev;
 667                                 if (usb_submit_urb (mdc800->download_urb))
 668                                 {
 669                                         err ("Can't submit download urb (status=%i)",mdc800->download_urb->status);
 670                                         spin_unlock (&mdc800->io_lock);
 671                                         return len-left;
 672                                 }
 673                                 interruptible_sleep_on_timeout (&mdc800->download_wait, TO_DOWNLOAD_GET_READY*HZ/1000);
 674                                 if (mdc800->download_urb->status != 0)
 675                                 {
 676                                         err ("request download-bytes fails (status=%i)",mdc800->download_urb->status);
 677                                         spin_unlock (&mdc800->io_lock);
 678                                         return len-left;
 679                                 }
 680                         }
 681                         else
 682                         {
 683                                 /* No more bytes -> that's an error*/
 684                                 spin_unlock (&mdc800->io_lock);
 685                                 return -EIO;
 686                         }
 687                 }
 688                 else
 689                 {
 690                         /* memcpy Bytes */
 691                         memcpy (ptr, &mdc800->out [mdc800->out_ptr], sts);
 692                         ptr+=sts;
 693                         left-=sts;
 694                         mdc800->out_ptr+=sts;
 695                 }
 696         }
 697
 698         spin_unlock (&mdc800->io_lock);
 699         return len-left;
 700 }
 701
 702
 703 /*
 704  * The Device write callback Function
 705  * If a 8Byte Command is received, it will be send to the camera.
 706  * After this the driver initiates the request for the answer or
 707  * just waits until the camera becomes ready.
 708  */
 709 static ssize_t mdc800_device_write (struct file *file, const char *buf, size_t len, loff_t *pos)
 710 {
 711         int i=0;
 712
 713         spin_lock (&mdc800->io_lock);
 714         if (mdc800->state != READY)
 715         {
 716                 spin_unlock (&mdc800->io_lock);
 717                 return -EBUSY;
 718         }
 719         if (!mdc800->open )
 720         {
 721                 spin_unlock (&mdc800->io_lock);
 722                 return -EBUSY;
 723         }
 724
 725         while (i<len)
 726         {
 727                 if (signal_pending (current))
 728                 {
 729                         spin_unlock (&mdc800->io_lock);
 730                         return -EINTR;
 731                 }
 732
 733                 /* check for command start */
 734                 if (buf [i] == (char) 0x55)
 735                 {
 736                         mdc800->in_count=0;
 737                         mdc800->out_count=0;
 738                         mdc800->out_ptr=0;
 739                         mdc800->download_left=0;
 740                 }
 741
 742                 /* save command byte */
 743                 if (mdc800->in_count < 8)
 744                 {
 745                         mdc800->in[mdc800->in_count]=buf[i];
 746                         mdc800->in_count++;
 747                 }
 748                 else
 749                 {
 750                         err ("Command is to long !\n");
 751                         spin_unlock (&mdc800->io_lock);
 752                         return -EIO;
 753                 }
 754
 755                 /* Command Buffer full ? -> send it to camera */
 756                 if (mdc800->in_count == 8)
 757                 {
 758                         int answersize;
 759
 760                         if (mdc800_usb_waitForIRQ (0,TO_GET_READY))
 761                         {
 762                                 err ("Camera didn't get ready.\n");
 763                                 spin_unlock (&mdc800->io_lock);
 764                                 return -EIO;
 765                         }
 766
 767                         answersize=mdc800_getAnswerSize (mdc800->in[1]);
 768
 769                         mdc800->state=WORKING;
 770                         memcpy (mdc800->write_urb->transfer_buffer, mdc800->in,8);
 771                         mdc800->write_urb->dev = mdc800->dev;
 772                         if (usb_submit_urb (mdc800->write_urb))
 773                         {
 774                                 err ("submitting write urb fails (status=%i)", mdc800->write_urb->status);
 775                                 spin_unlock (&mdc800->io_lock);
 776                                 return -EIO;
 777                         }
 778                         interruptible_sleep_on_timeout (&mdc800->write_wait, TO_WRITE_GET_READY*HZ/1000);
 779                         if (mdc800->state == WORKING)
 780                         {
 781                                 usb_unlink_urb (mdc800->write_urb);
 782                                 spin_unlock (&mdc800->io_lock);
 783                                 return -EIO;
 784                         }
 785
 786                         switch ((unsigned char) mdc800->in[1])
 787                         {
 788                                 case 0x05: /* Download Image */
 789                                 case 0x3e: /* Take shot in Fine Mode (WCam Mode) */
 790                                         if (mdc800->pic_len < 0)
 791                                         {
 792                                                 err ("call 0x07 before 0x05,0x3e");
 793                                                 mdc800->state=READY;
 794                                                 spin_unlock (&mdc800->io_lock);
 795                                                 return -EIO;
 796                                         }
 797                                         mdc800->pic_len=-1;
 798
 799                                 case 0x09: /* Download Thumbnail */
 800                                         mdc800->download_left=answersize+64;
 801                                         mdc800->state=DOWNLOAD;
 802                                         mdc800_usb_waitForIRQ (0,TO_DOWNLOAD_GET_BUSY);
 803                                         break;
 804
 805
 806                                 default:
 807                                         if (answersize)
 808                                         {
 809
 810                                                 if (mdc800_usb_waitForIRQ (1,TO_READ_FROM_IRQ))
 811                                                 {
 812                                                         err ("requesting answer from irq fails");
 813                                                         spin_unlock (&mdc800->io_lock);
 814                                                         return -EIO;
 815                                                 }
 816
 817                                                 /* Write dummy data, (this is ugly but part of the USB Protokoll */
 818                                                 /* if you use endpoint 1 as bulk and not as irq */
 819                                                 memcpy (mdc800->out, mdc800->camera_response,8);
 820
 821                                                 /* This is the interpreted answer */
 822                                                 memcpy (&mdc800->out[8], mdc800->camera_response,8);
 823
 824                                                 mdc800->out_ptr=0;
 825                                                 mdc800->out_count=16;
 826
 827                                                 /* Cache the Imagesize, if command was getImageSize */
 828                                                 if (mdc800->in [1] == (char) 0x07)
 829                                                 {
 830                                                         mdc800->pic_len=(int) 65536*(unsigned char) mdc800->camera_response[0]+256*(unsigned char) mdc800->camera_response[1]+(unsigned char) mdc800->camera_response[2];
 831
 832                                                         dbg ("cached imagesize = %i",mdc800->pic_len);
 833                                                 }
 834
 835                                         }
 836                                         else
 837                                         {
 838                                                 if (mdc800_usb_waitForIRQ (0,TO_DEFAULT_COMMAND))
 839                                                 {
 840                                                         err ("Command Timeout.");
 841                                                         spin_unlock (&mdc800->io_lock);
 842                                                         return -EIO;
 843                                                 }
 844                                         }
 845                                         mdc800->state=READY;
 846                                         break;
 847                         }
 848                 }
 849                 i++;
 850         }
 851         spin_unlock (&mdc800->io_lock);
 852         return i;
 853 }
 854
 855
 856 /***************************************************************************
 857         Init and Cleanup this driver (Structs and types)
 858 ****************************************************************************/
 859
 860 /* File Operations of this drivers */
 861 static struct file_operations mdc800_device_ops =
 862 {
 863         owner:          THIS_MODULE,
 864         read:           mdc800_device_read,
 865         write:          mdc800_device_write,
 866         open:           mdc800_device_open,
 867         release:        mdc800_device_release,
 868 };
 869
 870
 871
 872 static struct usb_device_id mdc800_table [] = {
 873         { USB_DEVICE(MDC800_VENDOR_ID, MDC800_PRODUCT_ID) },
 874         { }                                             /* Terminating entry */
 875 };
 876
 877 MODULE_DEVICE_TABLE (usb, mdc800_table);
 878 /*
 879  * USB Driver Struct for this device
 880  */
 881 static struct usb_driver mdc800_usb_driver =
 882 {
 883         name:           "mdc800",
 884         probe:          mdc800_usb_probe,
 885         disconnect:     mdc800_usb_disconnect,
 886         fops:           &mdc800_device_ops,
 887         minor:          MDC800_DEVICE_MINOR_BASE,
 888         id_table:       mdc800_table
 889 };
 890
 891
 892
 893 /************************************************************************
 894         Init and Cleanup this driver (Main Functions)
 895 *************************************************************************/
 896
 897 #define try(A)           if ((A) == 0) goto cleanup_on_fail;
 898 #define try_free_mem(A)  if (A != 0) { kfree (A); A=0; }
 899 #define try_free_urb(A)  if (A != 0) { usb_free_urb (A); A=0; }
 900
 901 int __init usb_mdc800_init (void)
 902 {
 903         /* Allocate Memory */
 904         try (mdc800=kmalloc (sizeof (struct mdc800_data), GFP_KERNEL));
 905
 906         memset(mdc800, 0, sizeof(struct mdc800_data));
 907         mdc800->dev=0;
 908         mdc800->open=0;
 909         mdc800->state=NOT_CONNECTED;
 910         spin_lock_init (&mdc800->io_lock);
 911
 912         init_waitqueue_head (&mdc800->irq_wait);
 913         init_waitqueue_head (&mdc800->write_wait);
 914         init_waitqueue_head (&mdc800->download_wait);
 915
 916         try (mdc800->irq_urb_buffer=kmalloc (8, GFP_KERNEL));
 917         try (mdc800->write_urb_buffer=kmalloc (8, GFP_KERNEL));
 918         try (mdc800->download_urb_buffer=kmalloc (64, GFP_KERNEL));
 919
 920         try (mdc800->irq_urb=usb_alloc_urb (0));
 921         try (mdc800->download_urb=usb_alloc_urb (0));
 922         try (mdc800->write_urb=usb_alloc_urb (0));
 923
 924         /* Register the driver */
 925         if (usb_register (&mdc800_usb_driver) < 0)
 926                 goto cleanup_on_fail;
 927
 928         info ("Mustek Digital Camera Driver " VERSION " (MDC800)");
 929         info (RELEASE_DATE " Henning Zabel <henning@uni-paderborn.de>");
 930
 931         return 0;
 932
 933         /* Clean driver up, when something fails */
 934
 935 cleanup_on_fail:
 936
 937         if (mdc800 != 0)
 938         {
 939                 err ("can't alloc memory!");
 940
 941                 try_free_mem (mdc800->download_urb_buffer);
 942                 try_free_mem (mdc800->write_urb_buffer);
 943                 try_free_mem (mdc800->irq_urb_buffer);
 944
 945                 try_free_urb (mdc800->write_urb);
 946                 try_free_urb (mdc800->download_urb);
 947                 try_free_urb (mdc800->irq_urb);
 948
 949                 kfree (mdc800);
 950         }
 951         mdc800=0;
 952         return -1;
 953 }
 954
 955
 956 void __exit usb_mdc800_cleanup (void)
 957 {
 958         usb_deregister (&mdc800_usb_driver);
 959
 960         usb_free_urb (mdc800->irq_urb);
 961         usb_free_urb (mdc800->download_urb);
 962         usb_free_urb (mdc800->write_urb);
 963
 964         kfree (mdc800->irq_urb_buffer);
 965         kfree (mdc800->write_urb_buffer);
 966         kfree (mdc800->download_urb_buffer);
 967
 968         kfree (mdc800);
 969         mdc800=0;
 970 }
 971
 972
 973 MODULE_AUTHOR ("Henning Zabel <henning@uni-paderborn.de>");
 974 MODULE_DESCRIPTION ("USB Driver for Mustek MDC800 Digital Camera");
 975
 976 module_init (usb_mdc800_init);
 977 module_exit (usb_mdc800_cleanup);