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