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