?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Ok. I didn't make 2.4.0 in 2000. Tough. I tried, but we had some
[davej-history.git] / drivers / usb / mdc800.c
blob131681c8e7815c03f7e8a27cdbf73f76109251ae
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 * version 0.7.5
34 * Fixed potential SMP races with Spinlocks.
35 * Thanks to Oliver Neukum <oliver.neukum@lrz.uni-muenchen.de> who
36 * noticed the race conditions.
37 * (30/10/2000)
38 *
39 * Fixed: Setting urb->dev before submitting urb.
40 * by Greg KH <greg@kroah.com>
41 * (13/10/2000)
42 *
43 * version 0.7.3
44 * bugfix : The mdc800->state field gets set to READY after the
45 * the diconnect function sets it to NOT_CONNECTED. This makes the
46 * driver running like the camera is connected and causes some
47 * hang ups.
48 *
49 * version 0.7.1
50 * MOD_INC and MOD_DEC are changed in usb_probe to prevent load/unload
51 * problems when compiled as Module.
52 * (04/04/2000)
53 *
54 * The mdc800 driver gets assigned the USB Minor 32-47. The Registration
55 * was updated to use these values.
56 * (26/03/2000)
57 *
58 * The Init und Exit Module Function are updated.
59 * (01/03/2000)
60 *
61 * version 0.7.0
62 * Rewrite of the driver : The driver now uses URB's. The old stuff
63 * has been removed.
64 *
65 * version 0.6.0
66 * Rewrite of this driver: The Emulation of the rs232 protocoll
67 * has been removed from the driver. A special executeCommand function
68 * for this driver is included to gphoto.
69 * The driver supports two kind of communication to bulk endpoints.
70 * Either with the dev->bus->ops->bulk... or with callback function.
71 * (09/11/1999)
72 *
73 * version 0.5.0:
74 * first Version that gets a version number. Most of the needed
75 * functions work.
76 * (20/10/1999)
77 */
78
79 #include <linux/version.h>
80 #include <linux/sched.h>
81 #include <linux/signal.h>
82 #include <linux/spinlock.h>
83 #include <linux/errno.h>
84 #include <linux/random.h>
85 #include <linux/poll.h>
86 #include <linux/init.h>
87 #include <linux/malloc.h>
88 #include <linux/module.h>
89 #include <linux/smp_lock.h>
90
91 #include <linux/usb.h>
92
93 #define VERSION "0.7.5"
94 #define RELEASE_DATE "(30/10/2000)"
95
96 /* Vendor and Product Information */
97 #define MDC800_VENDOR_ID 0x055f
98 #define MDC800_PRODUCT_ID 0xa800
99
100 /* Timeouts (msec) */
101 #define TO_DOWNLOAD_GET_READY 1500
102 #define TO_DOWNLOAD_GET_BUSY 1500
103 #define TO_WRITE_GET_READY 1000
104 #define TO_DEFAULT_COMMAND 5000
105 #define TO_READ_FROM_IRQ TO_DEFAULT_COMMAND
106 #define TO_GET_READY TO_DEFAULT_COMMAND
107
108 /* Minor Number of the device (create with mknod /dev/mustek c 180 32) */
109 #define MDC800_DEVICE_MINOR_BASE 32
110
111
112 /**************************************************************************
113 Data and structs
114 ***************************************************************************/
115
116
117 typedef enum {
118 NOT_CONNECTED, READY, WORKING, DOWNLOAD
119 } mdc800_state;
120
121
122 /* Data for the driver */
123 struct mdc800_data
124 {
125 struct usb_device * dev; // Device Data
126 mdc800_state state;
127
128 unsigned int endpoint [4];
129
130 purb_t irq_urb;
131 wait_queue_head_t irq_wait;
132 char* irq_urb_buffer;
133
134 int camera_busy; // is camera busy ?
135 int camera_request_ready; // Status to synchronize with irq
136 char camera_response [8]; // last Bytes send after busy
137
138 purb_t write_urb;
139 char* write_urb_buffer;
140 wait_queue_head_t write_wait;
141
142
143 purb_t download_urb;
144 char* download_urb_buffer;
145 wait_queue_head_t download_wait;
146 int download_left; // Bytes left to download ?
147
148
149 /* Device Data */
150 char out [64]; // Answer Buffer
151 int out_ptr; // Index to the first not readen byte
152 int out_count; // Bytes in the buffer
153
154 int open; // Camera device open ?
155 spinlock_t io_lock; // IO -lock
156
157 char in [8]; // Command Input Buffer
158 int in_count;
159
160 int pic_index; // Cache for the Imagesize (-1 for nothing cached )
161 int pic_len;
162 };
163
164
165 /* Specification of the Endpoints */
166 static struct usb_endpoint_descriptor mdc800_ed [4] =
167 {
168 { 0,0, 0x01, 0x02, 8, 0,0,0 },
169 { 0,0, 0x82, 0x03, 8, 0,0,0 },
170 { 0,0, 0x03, 0x02, 64, 0,0,0 },
171 { 0,0, 0x84, 0x02, 64, 0,0,0 }
172 };
173
174
175 /* The Variable used by the driver */
176 static struct mdc800_data* mdc800=0;
177
178
179 /***************************************************************************
180 The USB Part of the driver
181 ****************************************************************************/
182
183 static int mdc800_endpoint_equals (struct usb_endpoint_descriptor *a,struct usb_endpoint_descriptor *b)
184 {
185 return (
186 ( a->bEndpointAddress == b->bEndpointAddress )
187 && ( a->bmAttributes == b->bmAttributes )
188 && ( a->wMaxPacketSize == b->wMaxPacketSize )
189 );
190 }
191
192
193 /*
194 * Checks wether the camera responds busy
195 */
196 static int mdc800_isBusy (char* ch)
197 {
198 int i=0;
199 while (i<8)
200 {
201 if (ch [i] != (char)0x99)
202 return 0;
203 i++;
204 }
205 return 1;
206 }
207
208
209 /*
210 * Checks wether the Camera is ready
211 */
212 static int mdc800_isReady (char *ch)
213 {
214 int i=0;
215 while (i<8)
216 {
217 if (ch [i] != (char)0xbb)
218 return 0;
219 i++;
220 }
221 return 1;
222 }
223
224
225
226 /*
227 * USB IRQ Handler for InputLine
228 */
229 static void mdc800_usb_irq (struct urb *urb)
230 {
231 int data_received=0, wake_up;
232 unsigned char* b=urb->transfer_buffer;
233 struct mdc800_data* mdc800=urb->context;
234
235 if (urb->status >= 0)
236 {
237
238 //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]);
239
240 if (mdc800_isBusy (b))
241 {
242 if (!mdc800->camera_busy)
243 {
244 mdc800->camera_busy=1;
245 dbg ("gets busy");
246 }
247 }
248 else
249 {
250 if (mdc800->camera_busy && mdc800_isReady (b))
251 {
252 mdc800->camera_busy=0;
253 dbg ("gets ready");
254 }
255 }
256 if (!(mdc800_isBusy (b) || mdc800_isReady (b)))
257 {
258 /* Store Data in camera_answer field */
259 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]);
260
261 memcpy (mdc800->camera_response,b,8);
262 data_received=1;
263 }
264 }
265 wake_up= ( mdc800->camera_request_ready > 0 )
266 &&
267 (
268 ((mdc800->camera_request_ready == 1) && (!mdc800->camera_busy))
269 ||
270 ((mdc800->camera_request_ready == 2) && data_received)
271 ||
272 ((mdc800->camera_request_ready == 3) && (mdc800->camera_busy))
273 ||
274 (urb->status < 0)
275 );
276
277 if (wake_up)
278 {
279 mdc800->camera_request_ready=0;
280 wake_up_interruptible (&mdc800->irq_wait);
281 }
282 }
283
284
285 /*
286 * Waits a while until the irq responds that camera is ready
287 *
288 * mode : 0: Wait for camera gets ready
289 * 1: Wait for receiving data
290 * 2: Wait for camera gets busy
291 *
292 * msec: Time to wait
293 */
294 static int mdc800_usb_waitForIRQ (int mode, int msec)
295 {
296 mdc800->camera_request_ready=1+mode;
297
298 interruptible_sleep_on_timeout (&mdc800->irq_wait, msec*HZ/1000);
299
300 if (mdc800->camera_request_ready>0)
301 {
302 mdc800->camera_request_ready=0;
303 err ("timeout waiting for camera.");
304 return -1;
305 }
306
307 if (mdc800->state == NOT_CONNECTED)
308 {
309 warn ("Camera gets disconnected during waiting for irq.");
310 mdc800->camera_request_ready=0;
311 return -2;
312 }
313
314 return 0;
315 }
316
317
318 /*
319 * The write_urb callback function
320 */
321 static void mdc800_usb_write_notify (struct urb *urb)
322 {
323 struct mdc800_data* mdc800=urb->context;
324
325 if (urb->status != 0)
326 {
327 err ("writing command fails (status=%i)", urb->status);
328 }
329 else
330 {
331 mdc800->state=READY;
332 }
333 wake_up_interruptible (&mdc800->write_wait);
334 }
335
336
337 /*
338 * The download_urb callback function
339 */
340 static void mdc800_usb_download_notify (struct urb *urb)
341 {
342 struct mdc800_data* mdc800=urb->context;
343
344 if (urb->status == 0)
345 {
346 /* Fill output buffer with these data */
347 memcpy (mdc800->out, urb->transfer_buffer, 64);
348 mdc800->out_count=64;
349 mdc800->out_ptr=0;
350 mdc800->download_left-=64;
351 if (mdc800->download_left == 0)
352 {
353 mdc800->state=READY;
354 }
355 }
356 else
357 {
358 err ("request bytes fails (status:%i)", urb->status);
359 }
360 wake_up_interruptible (&mdc800->download_wait);
361 }
362
363
364 /***************************************************************************
365 Probing for the Camera
366 ***************************************************************************/
367
368 static struct usb_driver mdc800_usb_driver;
369
370 /*
371 * Callback to search the Mustek MDC800 on the USB Bus
372 */
373 static void* mdc800_usb_probe (struct usb_device *dev ,unsigned int ifnum,
374 const struct usb_device_id *id)
375 {
376 int i,j;
377 struct usb_interface_descriptor *intf_desc;
378 int irq_interval=0;
379
380 dbg ("(mdc800_usb_probe) called.");
381
382
383 if (mdc800->dev != 0)
384 {
385 warn ("only one Mustek MDC800 is supported.");
386 return 0;
387 }
388
389 if (dev->descriptor.bNumConfigurations != 1)
390 {
391 err ("probe fails -> wrong Number of Configuration");
392 return 0;
393 }
394 intf_desc=&dev->actconfig->interface[ifnum].altsetting[0];
395
396 if (
397 ( intf_desc->bInterfaceClass != 0xff )
398 || ( intf_desc->bInterfaceSubClass != 0 )
399 || ( intf_desc->bInterfaceProtocol != 0 )
400 || ( intf_desc->bNumEndpoints != 4)
401 )
402 {
403 err ("probe fails -> wrong Interface");
404 return 0;
405 }
406
407 /* Check the Endpoints */
408 for (i=0; i<4; i++)
409 {
410 mdc800->endpoint[i]=-1;
411 for (j=0; j<4; j++)
412 {
413 if (mdc800_endpoint_equals (&intf_desc->endpoint [j],&mdc800_ed [i]))
414 {
415 mdc800->endpoint[i]=intf_desc->endpoint [j].bEndpointAddress ;
416 if (i==1)
417 {
418 irq_interval=intf_desc->endpoint [j].bInterval;
419 }
420
421 continue;
422 }
423 }
424 if (mdc800->endpoint[i] == -1)
425 {
426 err ("probe fails -> Wrong Endpoints.");
427 return 0;
428 }
429 }
430
431
432 usb_driver_claim_interface (&mdc800_usb_driver, &dev->actconfig->interface[ifnum], mdc800);
433 if (usb_set_interface (dev, ifnum, 0) < 0)
434 {
435 err ("MDC800 Configuration fails.");
436 return 0;
437 }
438
439 info ("Found Mustek MDC800 on USB.");
440
441 spin_lock (&mdc800->io_lock);
442
443 mdc800->dev=dev;
444 mdc800->open=0;
445
446 /* Setup URB Structs */
447 FILL_INT_URB (
448 mdc800->irq_urb,
449 mdc800->dev,
450 usb_rcvintpipe (mdc800->dev,mdc800->endpoint [1]),
451 mdc800->irq_urb_buffer,
452 8,
453 mdc800_usb_irq,
454 mdc800,
455 irq_interval
456 );
457
458 FILL_BULK_URB (
459 mdc800->write_urb,
460 mdc800->dev,
461 usb_sndbulkpipe (mdc800->dev, mdc800->endpoint[0]),
462 mdc800->write_urb_buffer,
463 8,
464 mdc800_usb_write_notify,
465 mdc800
466 );
467
468 FILL_BULK_URB (
469 mdc800->download_urb,
470 mdc800->dev,
471 usb_rcvbulkpipe (mdc800->dev, mdc800->endpoint [3]),
472 mdc800->download_urb_buffer,
473 64,
474 mdc800_usb_download_notify,
475 mdc800
476 );
477
478 mdc800->state=READY;
479
480 spin_unlock (&mdc800->io_lock);
481
482 return mdc800;
483 }
484
485
486 /*
487 * Disconnect USB device (maybe the MDC800)
488 */
489 static void mdc800_usb_disconnect (struct usb_device *dev,void* ptr)
490 {
491 struct mdc800_data* mdc800=(struct mdc800_data*) ptr;
492
493 dbg ("(mdc800_usb_disconnect) called");
494
495 if (mdc800->state == NOT_CONNECTED)
496 return;
497
498 mdc800->state=NOT_CONNECTED;
499
500 usb_unlink_urb (mdc800->irq_urb);
501 usb_unlink_urb (mdc800->write_urb);
502 usb_unlink_urb (mdc800->download_urb);
503
504 usb_driver_release_interface (&mdc800_usb_driver, &dev->actconfig->interface[1]);
505
506 mdc800->dev=0;
507 info ("Mustek MDC800 disconnected from USB.");
508 }
509
510
511 /***************************************************************************
512 The Misc device Part (file_operations)
513 ****************************************************************************/
514
515 /*
516 * This Function calc the Answersize for a command.
517 */
518 static int mdc800_getAnswerSize (char command)
519 {
520 switch ((unsigned char) command)
521 {
522 case 0x2a:
523 case 0x49:
524 case 0x51:
525 case 0x0d:
526 case 0x20:
527 case 0x07:
528 case 0x01:
529 case 0x25:
530 case 0x00:
531 return 8;
532
533 case 0x05:
534 case 0x3e:
535 return mdc800->pic_len;
536
537 case 0x09:
538 return 4096;
539
540 default:
541 return 0;
542 }
543 }
544
545
546 /*
547 * Init the device: (1) alloc mem (2) Increase MOD Count ..
548 */
549 static int mdc800_device_open (struct inode* inode, struct file *file)
550 {
551 int retval=0;
552 int errn=0;
553
554 spin_lock (&mdc800->io_lock);
555
556 if (mdc800->state == NOT_CONNECTED)
557 {
558 errn=-EBUSY;
559 goto error_out;
560 }
561 if (mdc800->open)
562 {
563 errn=-EBUSY;
564 goto error_out;
565 }
566
567 mdc800->in_count=0;
568 mdc800->out_count=0;
569 mdc800->out_ptr=0;
570 mdc800->pic_index=0;
571 mdc800->pic_len=-1;
572 mdc800->download_left=0;
573
574 mdc800->camera_busy=0;
575 mdc800->camera_request_ready=0;
576
577 retval=0;
578 mdc800->irq_urb->dev = mdc800->dev;
579 if (usb_submit_urb (mdc800->irq_urb))
580 {
581 err ("request USB irq fails (submit_retval=%i urb_status=%i).",retval, mdc800->irq_urb->status);
582 errn = -EIO;
583 goto error_out;
584 }
585
586 mdc800->open=1;
587 dbg ("Mustek MDC800 device opened.");
588
589 error_out:
590 spin_unlock (&mdc800->io_lock);
591 return errn;
592 }
593
594
595 /*
596 * Close the Camera and release Memory
597 */
598 static int mdc800_device_release (struct inode* inode, struct file *file)
599 {
600 int retval=0;
601 dbg ("Mustek MDC800 device closed.");
602
603 spin_lock (&mdc800->io_lock);
604 if (mdc800->open && (mdc800->state != NOT_CONNECTED))
605 {
606 mdc800->open=0;
607 usb_unlink_urb (mdc800->irq_urb);
608 usb_unlink_urb (mdc800->write_urb);
609 usb_unlink_urb (mdc800->download_urb);
610 }
611 else
612 {
613 retval=-EIO;
614 }
615 spin_unlock (&mdc800->io_lock);
616
617 return retval;
618 }
619
620
621 /*
622 * The Device read callback Function
623 */
624 static ssize_t mdc800_device_read (struct file *file, char *buf, size_t len, loff_t *pos)
625 {
626 int left=len, sts=len; /* single transfer size */
627 char* ptr=buf;
628
629 spin_lock (&mdc800->io_lock);
630 if (mdc800->state == NOT_CONNECTED)
631 {
632 spin_unlock (&mdc800->io_lock);
633 return -EBUSY;
634 }
635 if (mdc800->state == WORKING)
636 {
637 warn ("Illegal State \"working\" reached during read ?!");
638 spin_unlock (&mdc800->io_lock);
639 return -EBUSY;
640 }
641 if (!mdc800->open)
642 {
643 spin_unlock (&mdc800->io_lock);
644 return -EBUSY;
645 }
646
647 while (left)
648 {
649 if (signal_pending (current))
650 {
651 spin_unlock (&mdc800->io_lock);
652 return -EINTR;
653 }
654
655 sts=left > (mdc800->out_count-mdc800->out_ptr)?mdc800->out_count-mdc800->out_ptr:left;
656
657 if (sts <= 0)
658 {
659 /* Too less Data in buffer */
660 if (mdc800->state == DOWNLOAD)
661 {
662 mdc800->out_count=0;
663 mdc800->out_ptr=0;
664
665 /* Download -> Request new bytes */
666 mdc800->download_urb->dev = mdc800->dev;
667 if (usb_submit_urb (mdc800->download_urb))
668 {
669 err ("Can't submit download urb (status=%i)",mdc800->download_urb->status);
670 spin_unlock (&mdc800->io_lock);
671 return len-left;
672 }
673 interruptible_sleep_on_timeout (&mdc800->download_wait, TO_DOWNLOAD_GET_READY*HZ/1000);
674 if (mdc800->download_urb->status != 0)
675 {
676 err ("request download-bytes fails (status=%i)",mdc800->download_urb->status);
677 spin_unlock (&mdc800->io_lock);
678 return len-left;
679 }
680 }
681 else
682 {
683 /* No more bytes -> that's an error*/
684 spin_unlock (&mdc800->io_lock);
685 return -EIO;
686 }
687 }
688 else
689 {
690 /* memcpy Bytes */
691 memcpy (ptr, &mdc800->out [mdc800->out_ptr], sts);
692 ptr+=sts;
693 left-=sts;
694 mdc800->out_ptr+=sts;
695 }
696 }
697
698 spin_unlock (&mdc800->io_lock);
699 return len-left;
700 }
701
702
703 /*
704 * The Device write callback Function
705 * If a 8Byte Command is received, it will be send to the camera.
706 * After this the driver initiates the request for the answer or
707 * just waits until the camera becomes ready.
708 */
709 static ssize_t mdc800_device_write (struct file *file, const char *buf, size_t len, loff_t *pos)
710 {
711 int i=0;
712
713 spin_lock (&mdc800->io_lock);
714 if (mdc800->state != READY)
715 {
716 spin_unlock (&mdc800->io_lock);
717 return -EBUSY;
718 }
719 if (!mdc800->open )
720 {
721 spin_unlock (&mdc800->io_lock);
722 return -EBUSY;
723 }
724
725 while (i<len)
726 {
727 if (signal_pending (current))
728 {
729 spin_unlock (&mdc800->io_lock);
730 return -EINTR;
731 }
732
733 /* check for command start */
734 if (buf [i] == (char) 0x55)
735 {
736 mdc800->in_count=0;
737 mdc800->out_count=0;
738 mdc800->out_ptr=0;
739 mdc800->download_left=0;
740 }
741
742 /* save command byte */
743 if (mdc800->in_count < 8)
744 {
745 mdc800->in[mdc800->in_count]=buf[i];
746 mdc800->in_count++;
747 }
748 else
749 {
750 err ("Command is to long !\n");
751 spin_unlock (&mdc800->io_lock);
752 return -EIO;
753 }
754
755 /* Command Buffer full ? -> send it to camera */
756 if (mdc800->in_count == 8)
757 {
758 int answersize;
759
760 if (mdc800_usb_waitForIRQ (0,TO_GET_READY))
761 {
762 err ("Camera didn't get ready.\n");
763 spin_unlock (&mdc800->io_lock);
764 return -EIO;
765 }
766
767 answersize=mdc800_getAnswerSize (mdc800->in[1]);
768
769 mdc800->state=WORKING;
770 memcpy (mdc800->write_urb->transfer_buffer, mdc800->in,8);
771 mdc800->write_urb->dev = mdc800->dev;
772 if (usb_submit_urb (mdc800->write_urb))
773 {
774 err ("submitting write urb fails (status=%i)", mdc800->write_urb->status);
775 spin_unlock (&mdc800->io_lock);
776 return -EIO;
777 }
778 interruptible_sleep_on_timeout (&mdc800->write_wait, TO_WRITE_GET_READY*HZ/1000);
779 if (mdc800->state == WORKING)
780 {
781 usb_unlink_urb (mdc800->write_urb);
782 spin_unlock (&mdc800->io_lock);
783 return -EIO;
784 }
785
786 switch ((unsigned char) mdc800->in[1])
787 {
788 case 0x05: /* Download Image */
789 case 0x3e: /* Take shot in Fine Mode (WCam Mode) */
790 if (mdc800->pic_len < 0)
791 {
792 err ("call 0x07 before 0x05,0x3e");
793 mdc800->state=READY;
794 spin_unlock (&mdc800->io_lock);
795 return -EIO;
796 }
797 mdc800->pic_len=-1;
798
799 case 0x09: /* Download Thumbnail */
800 mdc800->download_left=answersize+64;
801 mdc800->state=DOWNLOAD;
802 mdc800_usb_waitForIRQ (0,TO_DOWNLOAD_GET_BUSY);
803 break;
804
805
806 default:
807 if (answersize)
808 {
809
810 if (mdc800_usb_waitForIRQ (1,TO_READ_FROM_IRQ))
811 {
812 err ("requesting answer from irq fails");
813 spin_unlock (&mdc800->io_lock);
814 return -EIO;
815 }
816
817 /* Write dummy data, (this is ugly but part of the USB Protokoll */
818 /* if you use endpoint 1 as bulk and not as irq */
819 memcpy (mdc800->out, mdc800->camera_response,8);
820
821 /* This is the interpreted answer */
822 memcpy (&mdc800->out[8], mdc800->camera_response,8);
823
824 mdc800->out_ptr=0;
825 mdc800->out_count=16;
826
827 /* Cache the Imagesize, if command was getImageSize */
828 if (mdc800->in [1] == (char) 0x07)
829 {
830 mdc800->pic_len=(int) 65536*(unsigned char) mdc800->camera_response[0]+256*(unsigned char) mdc800->camera_response[1]+(unsigned char) mdc800->camera_response[2];
831
832 dbg ("cached imagesize = %i",mdc800->pic_len);
833 }
834
835 }
836 else
837 {
838 if (mdc800_usb_waitForIRQ (0,TO_DEFAULT_COMMAND))
839 {
840 err ("Command Timeout.");
841 spin_unlock (&mdc800->io_lock);
842 return -EIO;
843 }
844 }
845 mdc800->state=READY;
846 break;
847 }
848 }
849 i++;
850 }
851 spin_unlock (&mdc800->io_lock);
852 return i;
853 }
854
855
856 /***************************************************************************
857 Init and Cleanup this driver (Structs and types)
858 ****************************************************************************/
859
860 /* File Operations of this drivers */
861 static struct file_operations mdc800_device_ops =
862 {
863 owner: THIS_MODULE,
864 read: mdc800_device_read,
865 write: mdc800_device_write,
866 open: mdc800_device_open,
867 release: mdc800_device_release,
868 };
869
870
871
872 static struct usb_device_id mdc800_table [] = {
873 { idVendor: MDC800_VENDOR_ID, idProduct: MDC800_PRODUCT_ID },
874 { } /* Terminating entry */
875 };
876
877 MODULE_DEVICE_TABLE (usb, mdc800_table);
878 /*
879 * USB Driver Struct for this device
880 */
881 static struct usb_driver mdc800_usb_driver =
882 {
883 name: "mdc800",
884 probe: mdc800_usb_probe,
885 disconnect: mdc800_usb_disconnect,
886 fops: &mdc800_device_ops,
887 minor: MDC800_DEVICE_MINOR_BASE,
888 id_table: mdc800_table
889 };
890
891
892
893 /************************************************************************
894 Init and Cleanup this driver (Main Functions)
895 *************************************************************************/
896
897 #define try(A) if ((A) == 0) goto cleanup_on_fail;
898 #define try_free_mem(A) if (A != 0) { kfree (A); A=0; }
899 #define try_free_urb(A) if (A != 0) { usb_free_urb (A); A=0; }
900
901 int __init usb_mdc800_init (void)
902 {
903 /* Allocate Memory */
904 try (mdc800=kmalloc (sizeof (struct mdc800_data), GFP_KERNEL));
905
906 memset(mdc800, 0, sizeof(struct mdc800_data));
907 mdc800->dev=0;
908 mdc800->open=0;
909 mdc800->state=NOT_CONNECTED;
910 spin_lock_init (&mdc800->io_lock);
911
912 init_waitqueue_head (&mdc800->irq_wait);
913 init_waitqueue_head (&mdc800->write_wait);
914 init_waitqueue_head (&mdc800->download_wait);
915
916 try (mdc800->irq_urb_buffer=kmalloc (8, GFP_KERNEL));
917 try (mdc800->write_urb_buffer=kmalloc (8, GFP_KERNEL));
918 try (mdc800->download_urb_buffer=kmalloc (64, GFP_KERNEL));
919
920 try (mdc800->irq_urb=usb_alloc_urb (0));
921 try (mdc800->download_urb=usb_alloc_urb (0));
922 try (mdc800->write_urb=usb_alloc_urb (0));
923
924 /* Register the driver */
925 if (usb_register (&mdc800_usb_driver) < 0)
926 goto cleanup_on_fail;
927
928 info ("Mustek Digital Camera Driver " VERSION " (MDC800)");
929 info (RELEASE_DATE " Henning Zabel <henning@uni-paderborn.de>");
930
931 return 0;
932
933 /* Clean driver up, when something fails */
934
935 cleanup_on_fail:
936
937 if (mdc800 != 0)
938 {
939 err ("can't alloc memory!");
940
941 try_free_mem (mdc800->download_urb_buffer);
942 try_free_mem (mdc800->write_urb_buffer);
943 try_free_mem (mdc800->irq_urb_buffer);
944
945 try_free_urb (mdc800->write_urb);
946 try_free_urb (mdc800->download_urb);
947 try_free_urb (mdc800->irq_urb);
948
949 kfree (mdc800);
950 }
951 mdc800=0;
952 return -1;
953 }
954
955
956 void __exit usb_mdc800_cleanup (void)
957 {
958 usb_deregister (&mdc800_usb_driver);
959
960 usb_free_urb (mdc800->irq_urb);
961 usb_free_urb (mdc800->download_urb);
962 usb_free_urb (mdc800->write_urb);
963
964 kfree (mdc800->irq_urb_buffer);
965 kfree (mdc800->write_urb_buffer);
966 kfree (mdc800->download_urb_buffer);
967
968 kfree (mdc800);
969 mdc800=0;
970 }
971
972
973 MODULE_AUTHOR ("Henning Zabel <henning@uni-paderborn.de>");
974 MODULE_DESCRIPTION ("USB Driver for Mustek MDC800 Digital Camera");
975
976 module_init (usb_mdc800_init);
977 module_exit (usb_mdc800_cleanup);
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux