drivers/usb/mdc800.c

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