USB: Fix double-linking of drivers/usb/otg when ULPI is selected
[linux-2.6.git] / drivers / usb / image / mdc800.c
1 /*
2  * copyright (C) 1999/2000 by Henning Zabel <henning@uni-paderborn.de>
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of the GNU General Public License as published by the
6  * Free Software Foundation; either version 2 of the License, or (at your
7  * option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12  * for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19
20 /*
21  *      USB-Kernel Driver for the Mustek MDC800 Digital Camera
22  *      (c) 1999/2000 Henning Zabel <henning@uni-paderborn.de>
23  *
24  *
25  * The driver brings the USB functions of the MDC800 to Linux.
26  * To use the Camera you must support the USB Protocol of the camera
27  * to the Kernel Node.
28  * The Driver uses a misc device Node. Create it with :
29  * mknod /dev/mustek c 180 32
30  *
31  * The driver supports only one camera.
32  * 
33  * Fix: mdc800 used sleep_on and slept with io_lock held.
34  * Converted sleep_on to waitqueues with schedule_timeout and made io_lock
35  * a semaphore from a spinlock.
36  * by Oliver Neukum <oliver@neukum.name>
37  * (02/12/2001)
38  * 
39  * Identify version on module load.
40  * (08/04/2001) gb
41  *
42  * version 0.7.5
43  * Fixed potential SMP races with Spinlocks.
44  * Thanks to Oliver Neukum <oliver@neukum.name> who 
45  * noticed the race conditions.
46  * (30/10/2000)
47  *
48  * Fixed: Setting urb->dev before submitting urb.
49  * by Greg KH <greg@kroah.com>
50  * (13/10/2000)
51  *
52  * version 0.7.3
53  * bugfix : The mdc800->state field gets set to READY after the
54  * the diconnect function sets it to NOT_CONNECTED. This makes the
55  * driver running like the camera is connected and causes some
56  * hang ups.
57  *
58  * version 0.7.1
59  * MOD_INC and MOD_DEC are changed in usb_probe to prevent load/unload
60  * problems when compiled as Module.
61  * (04/04/2000)
62  *
63  * The mdc800 driver gets assigned the USB Minor 32-47. The Registration
64  * was updated to use these values.
65  * (26/03/2000)
66  *
67  * The Init und Exit Module Function are updated.
68  * (01/03/2000)
69  *
70  * version 0.7.0
71  * Rewrite of the driver : The driver now uses URB's. The old stuff
72  * has been removed.
73  *
74  * version 0.6.0
75  * Rewrite of this driver: The Emulation of the rs232 protocoll
76  * has been removed from the driver. A special executeCommand function
77  * for this driver is included to gphoto.
78  * The driver supports two kind of communication to bulk endpoints.
79  * Either with the dev->bus->ops->bulk... or with callback function.
80  * (09/11/1999)
81  *
82  * version 0.5.0:
83  * first Version that gets a version number. Most of the needed
84  * functions work.
85  * (20/10/1999)
86  */
87
88 #include <linux/sched.h>
89 #include <linux/signal.h>
90 #include <linux/spinlock.h>
91 #include <linux/errno.h>
92 #include <linux/random.h>
93 #include <linux/poll.h>
94 #include <linux/init.h>
95 #include <linux/slab.h>
96 #include <linux/module.h>
97 #include <linux/wait.h>
98 #include <linux/mutex.h>
99
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         int status = urb->status;
288
289         if (status >= 0) {
290
291                 //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]);
292
293                 if (mdc800_isBusy (b))
294                 {
295                         if (!mdc800->camera_busy)
296                         {
297                                 mdc800->camera_busy=1;
298                                 dbg ("gets busy");
299                         }
300                 }
301                 else
302                 {
303                         if (mdc800->camera_busy && mdc800_isReady (b))
304                         {
305                                 mdc800->camera_busy=0;
306                                 dbg ("gets ready");
307                         }
308                 }
309                 if (!(mdc800_isBusy (b) || mdc800_isReady (b)))
310                 {
311                         /* Store Data in camera_answer field */
312                         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]);
313
314                         memcpy (mdc800->camera_response,b,8);
315                         data_received=1;
316                 }
317         }
318         wake_up= ( mdc800->camera_request_ready > 0 )
319                 &&
320                 (
321                         ((mdc800->camera_request_ready == 1) && (!mdc800->camera_busy))
322                 ||
323                         ((mdc800->camera_request_ready == 2) && data_received)
324                 ||
325                         ((mdc800->camera_request_ready == 3) && (mdc800->camera_busy))
326                 ||
327                         (status < 0)
328                 );
329
330         if (wake_up)
331         {
332                 mdc800->camera_request_ready=0;
333                 mdc800->irq_woken=1;
334                 wake_up (&mdc800->irq_wait);
335         }
336 }
337
338
339 /*
340  * Waits a while until the irq responds that camera is ready
341  *
342  *  mode : 0: Wait for camera gets ready
343  *         1: Wait for receiving data
344  *         2: Wait for camera gets busy
345  *
346  * msec: Time to wait
347  */
348 static int mdc800_usb_waitForIRQ (int mode, int msec)
349 {
350         mdc800->camera_request_ready=1+mode;
351
352         wait_event_timeout(mdc800->irq_wait, mdc800->irq_woken, msec*HZ/1000);
353         mdc800->irq_woken = 0;
354
355         if (mdc800->camera_request_ready>0)
356         {
357                 mdc800->camera_request_ready=0;
358                 dev_err(&mdc800->dev->dev, "timeout waiting for camera.\n");
359                 return -1;
360         }
361         
362         if (mdc800->state == NOT_CONNECTED)
363         {
364                 printk(KERN_WARNING "mdc800: Camera gets disconnected "
365                        "during waiting for irq.\n");
366                 mdc800->camera_request_ready=0;
367                 return -2;
368         }
369         
370         return 0;
371 }
372
373
374 /*
375  * The write_urb callback function
376  */
377 static void mdc800_usb_write_notify (struct urb *urb)
378 {
379         struct mdc800_data* mdc800=urb->context;
380         int status = urb->status;
381
382         if (status != 0)
383                 dev_err(&mdc800->dev->dev,
384                         "writing command fails (status=%i)\n", status);
385         else
386                 mdc800->state=READY;
387         mdc800->written = 1;
388         wake_up (&mdc800->write_wait);
389 }
390
391
392 /*
393  * The download_urb callback function
394  */
395 static void mdc800_usb_download_notify (struct urb *urb)
396 {
397         struct mdc800_data* mdc800=urb->context;
398         int status = urb->status;
399
400         if (status == 0) {
401                 /* Fill output buffer with these data */
402                 memcpy (mdc800->out,  urb->transfer_buffer, 64);
403                 mdc800->out_count=64;
404                 mdc800->out_ptr=0;
405                 mdc800->download_left-=64;
406                 if (mdc800->download_left == 0)
407                 {
408                         mdc800->state=READY;
409                 }
410         } else {
411                 dev_err(&mdc800->dev->dev,
412                         "request bytes fails (status:%i)\n", status);
413         }
414         mdc800->downloaded = 1;
415         wake_up (&mdc800->download_wait);
416 }
417
418
419 /***************************************************************************
420         Probing for the Camera
421  ***************************************************************************/
422
423 static struct usb_driver mdc800_usb_driver;
424 static const struct file_operations mdc800_device_ops;
425 static struct usb_class_driver mdc800_class = {
426         .name =         "mdc800%d",
427         .fops =         &mdc800_device_ops,
428         .minor_base =   MDC800_DEVICE_MINOR_BASE,
429 };
430
431
432 /*
433  * Callback to search the Mustek MDC800 on the USB Bus
434  */
435 static int mdc800_usb_probe (struct usb_interface *intf,
436                                const struct usb_device_id *id)
437 {
438         int i,j;
439         struct usb_host_interface *intf_desc;
440         struct usb_device *dev = interface_to_usbdev (intf);
441         int irq_interval=0;
442         int retval;
443
444         dbg ("(mdc800_usb_probe) called.");
445
446
447         if (mdc800->dev != NULL)
448         {
449                 dev_warn(&intf->dev, "only one Mustek MDC800 is supported.\n");
450                 return -ENODEV;
451         }
452
453         if (dev->descriptor.bNumConfigurations != 1)
454         {
455                 dev_err(&intf->dev,
456                         "probe fails -> wrong Number of Configuration\n");
457                 return -ENODEV;
458         }
459         intf_desc = intf->cur_altsetting;
460
461         if (
462                         ( intf_desc->desc.bInterfaceClass != 0xff )
463                 ||      ( intf_desc->desc.bInterfaceSubClass != 0 )
464                 || ( intf_desc->desc.bInterfaceProtocol != 0 )
465                 || ( intf_desc->desc.bNumEndpoints != 4)
466         )
467         {
468                 dev_err(&intf->dev, "probe fails -> wrong Interface\n");
469                 return -ENODEV;
470         }
471
472         /* Check the Endpoints */
473         for (i=0; i<4; i++)
474         {
475                 mdc800->endpoint[i]=-1;
476                 for (j=0; j<4; j++)
477                 {
478                         if (mdc800_endpoint_equals (&intf_desc->endpoint [j].desc,&mdc800_ed [i]))
479                         {
480                                 mdc800->endpoint[i]=intf_desc->endpoint [j].desc.bEndpointAddress ;
481                                 if (i==1)
482                                 {
483                                         irq_interval=intf_desc->endpoint [j].desc.bInterval;
484                                 }
485                         }
486                 }
487                 if (mdc800->endpoint[i] == -1)
488                 {
489                         dev_err(&intf->dev, "probe fails -> Wrong Endpoints.\n");
490                         return -ENODEV;
491                 }
492         }
493
494
495         dev_info(&intf->dev, "Found Mustek MDC800 on USB.\n");
496
497         mutex_lock(&mdc800->io_lock);
498
499         retval = usb_register_dev(intf, &mdc800_class);
500         if (retval) {
501                 dev_err(&intf->dev, "Not able to get a minor for this device.\n");
502                 mutex_unlock(&mdc800->io_lock);
503                 return -ENODEV;
504         }
505
506         mdc800->dev=dev;
507         mdc800->open=0;
508
509         /* Setup URB Structs */
510         usb_fill_int_urb (
511                 mdc800->irq_urb,
512                 mdc800->dev,
513                 usb_rcvintpipe (mdc800->dev,mdc800->endpoint [1]),
514                 mdc800->irq_urb_buffer,
515                 8,
516                 mdc800_usb_irq,
517                 mdc800,
518                 irq_interval
519         );
520
521         usb_fill_bulk_urb (
522                 mdc800->write_urb,
523                 mdc800->dev,
524                 usb_sndbulkpipe (mdc800->dev, mdc800->endpoint[0]),
525                 mdc800->write_urb_buffer,
526                 8,
527                 mdc800_usb_write_notify,
528                 mdc800
529         );
530
531         usb_fill_bulk_urb (
532                 mdc800->download_urb,
533                 mdc800->dev,
534                 usb_rcvbulkpipe (mdc800->dev, mdc800->endpoint [3]),
535                 mdc800->download_urb_buffer,
536                 64,
537                 mdc800_usb_download_notify,
538                 mdc800
539         );
540
541         mdc800->state=READY;
542
543         mutex_unlock(&mdc800->io_lock);
544         
545         usb_set_intfdata(intf, mdc800);
546         return 0;
547 }
548
549
550 /*
551  * Disconnect USB device (maybe the MDC800)
552  */
553 static void mdc800_usb_disconnect (struct usb_interface *intf)
554 {
555         struct mdc800_data* mdc800 = usb_get_intfdata(intf);
556
557         dbg ("(mdc800_usb_disconnect) called");
558
559         if (mdc800) {
560                 if (mdc800->state == NOT_CONNECTED)
561                         return;
562
563                 usb_deregister_dev(intf, &mdc800_class);
564
565                 /* must be under lock to make sure no URB
566                    is submitted after usb_kill_urb() */
567                 mutex_lock(&mdc800->io_lock);
568                 mdc800->state=NOT_CONNECTED;
569
570                 usb_kill_urb(mdc800->irq_urb);
571                 usb_kill_urb(mdc800->write_urb);
572                 usb_kill_urb(mdc800->download_urb);
573                 mutex_unlock(&mdc800->io_lock);
574
575                 mdc800->dev = NULL;
576                 usb_set_intfdata(intf, NULL);
577         }
578         dev_info(&intf->dev, "Mustek MDC800 disconnected from USB.\n");
579 }
580
581
582 /***************************************************************************
583         The Misc device Part (file_operations)
584 ****************************************************************************/
585
586 /*
587  * This Function calc the Answersize for a command.
588  */
589 static int mdc800_getAnswerSize (char command)
590 {
591         switch ((unsigned char) command)
592         {
593                 case 0x2a:
594                 case 0x49:
595                 case 0x51:
596                 case 0x0d:
597                 case 0x20:
598                 case 0x07:
599                 case 0x01:
600                 case 0x25:
601                 case 0x00:
602                         return 8;
603
604                 case 0x05:
605                 case 0x3e:
606                         return mdc800->pic_len;
607
608                 case 0x09:
609                         return 4096;
610
611                 default:
612                         return 0;
613         }
614 }
615
616
617 /*
618  * Init the device: (1) alloc mem (2) Increase MOD Count ..
619  */
620 static int mdc800_device_open (struct inode* inode, struct file *file)
621 {
622         int retval=0;
623         int errn=0;
624
625         mutex_lock(&mdc800->io_lock);
626         
627         if (mdc800->state == NOT_CONNECTED)
628         {
629                 errn=-EBUSY;
630                 goto error_out;
631         }
632         if (mdc800->open)
633         {
634                 errn=-EBUSY;
635                 goto error_out;
636         }
637
638         mdc800->in_count=0;
639         mdc800->out_count=0;
640         mdc800->out_ptr=0;
641         mdc800->pic_index=0;
642         mdc800->pic_len=-1;
643         mdc800->download_left=0;
644
645         mdc800->camera_busy=0;
646         mdc800->camera_request_ready=0;
647
648         retval=0;
649         mdc800->irq_urb->dev = mdc800->dev;
650         retval = usb_submit_urb (mdc800->irq_urb, GFP_KERNEL);
651         if (retval) {
652                 dev_err(&mdc800->dev->dev,
653                         "request USB irq fails (submit_retval=%i).\n", retval);
654                 errn = -EIO;
655                 goto error_out;
656         }
657
658         mdc800->open=1;
659         dbg ("Mustek MDC800 device opened.");
660
661 error_out:
662         mutex_unlock(&mdc800->io_lock);
663         return errn;
664 }
665
666
667 /*
668  * Close the Camera and release Memory
669  */
670 static int mdc800_device_release (struct inode* inode, struct file *file)
671 {
672         int retval=0;
673         dbg ("Mustek MDC800 device closed.");
674
675         mutex_lock(&mdc800->io_lock);
676         if (mdc800->open && (mdc800->state != NOT_CONNECTED))
677         {
678                 usb_kill_urb(mdc800->irq_urb);
679                 usb_kill_urb(mdc800->write_urb);
680                 usb_kill_urb(mdc800->download_urb);
681                 mdc800->open=0;
682         }
683         else
684         {
685                 retval=-EIO;
686         }
687
688         mutex_unlock(&mdc800->io_lock);
689         return retval;
690 }
691
692
693 /*
694  * The Device read callback Function
695  */
696 static ssize_t mdc800_device_read (struct file *file, char __user *buf, size_t len, loff_t *pos)
697 {
698         size_t left=len, sts=len; /* single transfer size */
699         char __user *ptr = buf;
700         int retval;
701
702         mutex_lock(&mdc800->io_lock);
703         if (mdc800->state == NOT_CONNECTED)
704         {
705                 mutex_unlock(&mdc800->io_lock);
706                 return -EBUSY;
707         }
708         if (mdc800->state == WORKING)
709         {
710                 printk(KERN_WARNING "mdc800: Illegal State \"working\""
711                        "reached during read ?!\n");
712                 mutex_unlock(&mdc800->io_lock);
713                 return -EBUSY;
714         }
715         if (!mdc800->open)
716         {
717                 mutex_unlock(&mdc800->io_lock);
718                 return -EBUSY;
719         }
720
721         while (left)
722         {
723                 if (signal_pending (current)) 
724                 {
725                         mutex_unlock(&mdc800->io_lock);
726                         return -EINTR;
727                 }
728
729                 sts=left > (mdc800->out_count-mdc800->out_ptr)?mdc800->out_count-mdc800->out_ptr:left;
730
731                 if (sts <= 0)
732                 {
733                         /* Too less Data in buffer */
734                         if (mdc800->state == DOWNLOAD)
735                         {
736                                 mdc800->out_count=0;
737                                 mdc800->out_ptr=0;
738
739                                 /* Download -> Request new bytes */
740                                 mdc800->download_urb->dev = mdc800->dev;
741                                 retval = usb_submit_urb (mdc800->download_urb, GFP_KERNEL);
742                                 if (retval) {
743                                         dev_err(&mdc800->dev->dev,
744                                                 "Can't submit download urb "
745                                                 "(retval=%i)\n", retval);
746                                         mutex_unlock(&mdc800->io_lock);
747                                         return len-left;
748                                 }
749                                 wait_event_timeout(mdc800->download_wait, mdc800->downloaded,
750                                                                                 TO_DOWNLOAD_GET_READY*HZ/1000);
751                                 mdc800->downloaded = 0;
752                                 if (mdc800->download_urb->status != 0)
753                                 {
754                                         dev_err(&mdc800->dev->dev,
755                                                 "request download-bytes fails "
756                                                 "(status=%i)\n",
757                                                 mdc800->download_urb->status);
758                                         mutex_unlock(&mdc800->io_lock);
759                                         return len-left;
760                                 }
761                         }
762                         else
763                         {
764                                 /* No more bytes -> that's an error*/
765                                 mutex_unlock(&mdc800->io_lock);
766                                 return -EIO;
767                         }
768                 }
769                 else
770                 {
771                         /* Copy Bytes */
772                         if (copy_to_user(ptr, &mdc800->out [mdc800->out_ptr],
773                                                 sts)) {
774                                 mutex_unlock(&mdc800->io_lock);
775                                 return -EFAULT;
776                         }
777                         ptr+=sts;
778                         left-=sts;
779                         mdc800->out_ptr+=sts;
780                 }
781         }
782
783         mutex_unlock(&mdc800->io_lock);
784         return len-left;
785 }
786
787
788 /*
789  * The Device write callback Function
790  * If a 8Byte Command is received, it will be send to the camera.
791  * After this the driver initiates the request for the answer or
792  * just waits until the camera becomes ready.
793  */
794 static ssize_t mdc800_device_write (struct file *file, const char __user *buf, size_t len, loff_t *pos)
795 {
796         size_t i=0;
797         int retval;
798
799         mutex_lock(&mdc800->io_lock);
800         if (mdc800->state != READY)
801         {
802                 mutex_unlock(&mdc800->io_lock);
803                 return -EBUSY;
804         }
805         if (!mdc800->open )
806         {
807                 mutex_unlock(&mdc800->io_lock);
808                 return -EBUSY;
809         }
810
811         while (i<len)
812         {
813                 unsigned char c;
814                 if (signal_pending (current)) 
815                 {
816                         mutex_unlock(&mdc800->io_lock);
817                         return -EINTR;
818                 }
819                 
820                 if(get_user(c, buf+i))
821                 {
822                         mutex_unlock(&mdc800->io_lock);
823                         return -EFAULT;
824                 }
825
826                 /* check for command start */
827                 if (c == 0x55)
828                 {
829                         mdc800->in_count=0;
830                         mdc800->out_count=0;
831                         mdc800->out_ptr=0;
832                         mdc800->download_left=0;
833                 }
834
835                 /* save command byte */
836                 if (mdc800->in_count < 8)
837                 {
838                         mdc800->in[mdc800->in_count] = c;
839                         mdc800->in_count++;
840                 }
841                 else
842                 {
843                         mutex_unlock(&mdc800->io_lock);
844                         return -EIO;
845                 }
846
847                 /* Command Buffer full ? -> send it to camera */
848                 if (mdc800->in_count == 8)
849                 {
850                         int answersize;
851
852                         if (mdc800_usb_waitForIRQ (0,TO_GET_READY))
853                         {
854                                 dev_err(&mdc800->dev->dev,
855                                         "Camera didn't get ready.\n");
856                                 mutex_unlock(&mdc800->io_lock);
857                                 return -EIO;
858                         }
859
860                         answersize=mdc800_getAnswerSize (mdc800->in[1]);
861
862                         mdc800->state=WORKING;
863                         memcpy (mdc800->write_urb->transfer_buffer, mdc800->in,8);
864                         mdc800->write_urb->dev = mdc800->dev;
865                         retval = usb_submit_urb (mdc800->write_urb, GFP_KERNEL);
866                         if (retval) {
867                                 dev_err(&mdc800->dev->dev,
868                                         "submitting write urb fails "
869                                         "(retval=%i)\n", retval);
870                                 mutex_unlock(&mdc800->io_lock);
871                                 return -EIO;
872                         }
873                         wait_event_timeout(mdc800->write_wait, mdc800->written, TO_WRITE_GET_READY*HZ/1000);
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                                                         dbg ("cached imagesize = %i",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 };
967
968
969
970 static struct usb_device_id mdc800_table [] = {
971         { USB_DEVICE(MDC800_VENDOR_ID, MDC800_PRODUCT_ID) },
972         { }                                             /* Terminating entry */
973 };
974
975 MODULE_DEVICE_TABLE (usb, mdc800_table);
976 /*
977  * USB Driver Struct for this device
978  */
979 static struct usb_driver mdc800_usb_driver =
980 {
981         .name =         "mdc800",
982         .probe =        mdc800_usb_probe,
983         .disconnect =   mdc800_usb_disconnect,
984         .id_table =     mdc800_table
985 };
986
987
988
989 /************************************************************************
990         Init and Cleanup this driver (Main Functions)
991 *************************************************************************/
992
993 static int __init usb_mdc800_init (void)
994 {
995         int retval = -ENODEV;
996         /* Allocate Memory */
997         mdc800=kzalloc (sizeof (struct mdc800_data), GFP_KERNEL);
998         if (!mdc800)
999                 goto cleanup_on_fail;
1000
1001         mdc800->dev = NULL;
1002         mdc800->state=NOT_CONNECTED;
1003         mutex_init (&mdc800->io_lock);
1004
1005         init_waitqueue_head (&mdc800->irq_wait);
1006         init_waitqueue_head (&mdc800->write_wait);
1007         init_waitqueue_head (&mdc800->download_wait);
1008
1009         mdc800->irq_woken = 0;
1010         mdc800->downloaded = 0;
1011         mdc800->written = 0;
1012
1013         mdc800->irq_urb_buffer=kmalloc (8, GFP_KERNEL);
1014         if (!mdc800->irq_urb_buffer)
1015                 goto cleanup_on_fail;
1016         mdc800->write_urb_buffer=kmalloc (8, GFP_KERNEL);
1017         if (!mdc800->write_urb_buffer)
1018                 goto cleanup_on_fail;
1019         mdc800->download_urb_buffer=kmalloc (64, GFP_KERNEL);
1020         if (!mdc800->download_urb_buffer)
1021                 goto cleanup_on_fail;
1022
1023         mdc800->irq_urb=usb_alloc_urb (0, GFP_KERNEL);
1024         if (!mdc800->irq_urb)
1025                 goto cleanup_on_fail;
1026         mdc800->download_urb=usb_alloc_urb (0, GFP_KERNEL);
1027         if (!mdc800->download_urb)
1028                 goto cleanup_on_fail;
1029         mdc800->write_urb=usb_alloc_urb (0, GFP_KERNEL);
1030         if (!mdc800->write_urb)
1031                 goto cleanup_on_fail;
1032
1033         /* Register the driver */
1034         retval = usb_register(&mdc800_usb_driver);
1035         if (retval)
1036                 goto cleanup_on_fail;
1037
1038         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1039                DRIVER_DESC "\n");
1040
1041         return 0;
1042
1043         /* Clean driver up, when something fails */
1044
1045 cleanup_on_fail:
1046
1047         if (mdc800 != NULL)
1048         {
1049                 printk(KERN_ERR "mdc800: can't alloc memory!\n");
1050
1051                 kfree(mdc800->download_urb_buffer);
1052                 kfree(mdc800->write_urb_buffer);
1053                 kfree(mdc800->irq_urb_buffer);
1054
1055                 usb_free_urb(mdc800->write_urb);
1056                 usb_free_urb(mdc800->download_urb);
1057                 usb_free_urb(mdc800->irq_urb);
1058
1059                 kfree (mdc800);
1060         }
1061         mdc800 = NULL;
1062         return retval;
1063 }
1064
1065
1066 static void __exit usb_mdc800_cleanup (void)
1067 {
1068         usb_deregister (&mdc800_usb_driver);
1069
1070         usb_free_urb (mdc800->irq_urb);
1071         usb_free_urb (mdc800->download_urb);
1072         usb_free_urb (mdc800->write_urb);
1073
1074         kfree (mdc800->irq_urb_buffer);
1075         kfree (mdc800->write_urb_buffer);
1076         kfree (mdc800->download_urb_buffer);
1077
1078         kfree (mdc800);
1079         mdc800 = NULL;
1080 }
1081
1082 module_init (usb_mdc800_init);
1083 module_exit (usb_mdc800_cleanup);
1084
1085 MODULE_AUTHOR( DRIVER_AUTHOR );
1086 MODULE_DESCRIPTION( DRIVER_DESC );
1087 MODULE_LICENSE("GPL");
1088