?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Save sram context after changing MPU, DSP or core clocks
[linux-ginger.git] / drivers / usb / image / mdc800.c
blobeca355dccf651215387cf76e7ef5951c4ed35f25
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
Linux for Ginger Game Console