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