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