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