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