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
118 typedef enum {
119 NOT_CONNECTED, READY, WORKING, DOWNLOAD
120 } mdc800_state;
121
122
123 /* Data for the driver */
124 struct 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 */
171 static 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 */
216 static struct mdc800_data* mdc800;
217
218
219 /***************************************************************************
220 The USB Part of the driver
221 ****************************************************************************/
222
mdc800_endpoint_equals(struct usb_endpoint_descriptor * a,struct usb_endpoint_descriptor * b)223 static 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 */
mdc800_isBusy(char * ch)236 static 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 */
mdc800_isReady(char * ch)252 static 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 */
mdc800_usb_irq(struct urb * urb)269 static 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 */
mdc800_usb_waitForIRQ(int mode,int msec)333 static 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 */
mdc800_usb_write_notify(struct urb * urb)363 static 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 */
mdc800_usb_download_notify(struct urb * urb)381 static 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
409 static struct usb_driver mdc800_usb_driver;
410 static const struct file_operations mdc800_device_ops;
411 static 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 */
mdc800_usb_probe(struct usb_interface * intf,const struct usb_device_id * id)421 static 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 */
mdc800_usb_disconnect(struct usb_interface * intf)539 static 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 */
mdc800_getAnswerSize(char command)575 static 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 */
mdc800_device_open(struct inode * inode,struct file * file)606 static 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 retval=0;
635 mdc800->irq_urb->dev = mdc800->dev;
636 retval = usb_submit_urb (mdc800->irq_urb, GFP_KERNEL);
637 if (retval) {
638 dev_err(&mdc800->dev->dev,
639 "request USB irq fails (submit_retval=%i).\n", retval);
640 errn = -EIO;
641 goto error_out;
642 }
643
644 mdc800->open=1;
645 dev_dbg(&mdc800->dev->dev, "Mustek MDC800 device opened.\n");
646
647 error_out:
648 mutex_unlock(&mdc800->io_lock);
649 return errn;
650 }
651
652
653 /*
654 * Close the Camera and release Memory
655 */
mdc800_device_release(struct inode * inode,struct file * file)656 static int mdc800_device_release (struct inode* inode, struct file *file)
657 {
658 int retval=0;
659
660 mutex_lock(&mdc800->io_lock);
661 if (mdc800->open && (mdc800->state != NOT_CONNECTED))
662 {
663 usb_kill_urb(mdc800->irq_urb);
664 usb_kill_urb(mdc800->write_urb);
665 usb_kill_urb(mdc800->download_urb);
666 mdc800->open=0;
667 }
668 else
669 {
670 retval=-EIO;
671 }
672
673 mutex_unlock(&mdc800->io_lock);
674 return retval;
675 }
676
677
678 /*
679 * The Device read callback Function
680 */
mdc800_device_read(struct file * file,char __user * buf,size_t len,loff_t * pos)681 static ssize_t mdc800_device_read (struct file *file, char __user *buf, size_t len, loff_t *pos)
682 {
683 size_t left=len, sts=len; /* single transfer size */
684 char __user *ptr = buf;
685 int retval;
686
687 mutex_lock(&mdc800->io_lock);
688 if (mdc800->state == NOT_CONNECTED)
689 {
690 mutex_unlock(&mdc800->io_lock);
691 return -EBUSY;
692 }
693 if (mdc800->state == WORKING)
694 {
695 printk(KERN_WARNING "mdc800: Illegal State \"working\""
696 "reached during read ?!\n");
697 mutex_unlock(&mdc800->io_lock);
698 return -EBUSY;
699 }
700 if (!mdc800->open)
701 {
702 mutex_unlock(&mdc800->io_lock);
703 return -EBUSY;
704 }
705
706 while (left)
707 {
708 if (signal_pending (current))
709 {
710 mutex_unlock(&mdc800->io_lock);
711 return -EINTR;
712 }
713
714 sts=left > (mdc800->out_count-mdc800->out_ptr)?mdc800->out_count-mdc800->out_ptr:left;
715
716 if (sts <= 0)
717 {
718 /* Too less Data in buffer */
719 if (mdc800->state == DOWNLOAD)
720 {
721 mdc800->out_count=0;
722 mdc800->out_ptr=0;
723
724 /* Download -> Request new bytes */
725 mdc800->download_urb->dev = mdc800->dev;
726 retval = usb_submit_urb (mdc800->download_urb, GFP_KERNEL);
727 if (retval) {
728 dev_err(&mdc800->dev->dev,
729 "Can't submit download urb "
730 "(retval=%i)\n", retval);
731 mutex_unlock(&mdc800->io_lock);
732 return len-left;
733 }
734 wait_event_timeout(mdc800->download_wait,
735 mdc800->downloaded,
736 msecs_to_jiffies(TO_DOWNLOAD_GET_READY));
737 mdc800->downloaded = 0;
738 if (mdc800->download_urb->status != 0)
739 {
740 dev_err(&mdc800->dev->dev,
741 "request download-bytes fails "
742 "(status=%i)\n",
743 mdc800->download_urb->status);
744 mutex_unlock(&mdc800->io_lock);
745 return len-left;
746 }
747 }
748 else
749 {
750 /* No more bytes -> that's an error*/
751 mutex_unlock(&mdc800->io_lock);
752 return -EIO;
753 }
754 }
755 else
756 {
757 /* Copy Bytes */
758 if (copy_to_user(ptr, &mdc800->out [mdc800->out_ptr],
759 sts)) {
760 mutex_unlock(&mdc800->io_lock);
761 return -EFAULT;
762 }
763 ptr+=sts;
764 left-=sts;
765 mdc800->out_ptr+=sts;
766 }
767 }
768
769 mutex_unlock(&mdc800->io_lock);
770 return len-left;
771 }
772
773
774 /*
775 * The Device write callback Function
776 * If a 8Byte Command is received, it will be send to the camera.
777 * After this the driver initiates the request for the answer or
778 * just waits until the camera becomes ready.
779 */
mdc800_device_write(struct file * file,const char __user * buf,size_t len,loff_t * pos)780 static ssize_t mdc800_device_write (struct file *file, const char __user *buf, size_t len, loff_t *pos)
781 {
782 size_t i=0;
783 int retval;
784
785 mutex_lock(&mdc800->io_lock);
786 if (mdc800->state != READY)
787 {
788 mutex_unlock(&mdc800->io_lock);
789 return -EBUSY;
790 }
791 if (!mdc800->open )
792 {
793 mutex_unlock(&mdc800->io_lock);
794 return -EBUSY;
795 }
796
797 while (i<len)
798 {
799 unsigned char c;
800 if (signal_pending (current))
801 {
802 mutex_unlock(&mdc800->io_lock);
803 return -EINTR;
804 }
805
806 if(get_user(c, buf+i))
807 {
808 mutex_unlock(&mdc800->io_lock);
809 return -EFAULT;
810 }
811
812 /* check for command start */
813 if (c == 0x55)
814 {
815 mdc800->in_count=0;
816 mdc800->out_count=0;
817 mdc800->out_ptr=0;
818 mdc800->download_left=0;
819 }
820
821 /* save command byte */
822 if (mdc800->in_count < 8)
823 {
824 mdc800->in[mdc800->in_count] = c;
825 mdc800->in_count++;
826 }
827 else
828 {
829 mutex_unlock(&mdc800->io_lock);
830 return -EIO;
831 }
832
833 /* Command Buffer full ? -> send it to camera */
834 if (mdc800->in_count == 8)
835 {
836 int answersize;
837
838 if (mdc800_usb_waitForIRQ (0,TO_GET_READY))
839 {
840 dev_err(&mdc800->dev->dev,
841 "Camera didn't get ready.\n");
842 mutex_unlock(&mdc800->io_lock);
843 return -EIO;
844 }
845
846 answersize=mdc800_getAnswerSize (mdc800->in[1]);
847
848 mdc800->state=WORKING;
849 memcpy (mdc800->write_urb->transfer_buffer, mdc800->in,8);
850 mdc800->write_urb->dev = mdc800->dev;
851 retval = usb_submit_urb (mdc800->write_urb, GFP_KERNEL);
852 if (retval) {
853 dev_err(&mdc800->dev->dev,
854 "submitting write urb fails "
855 "(retval=%i)\n", retval);
856 mutex_unlock(&mdc800->io_lock);
857 return -EIO;
858 }
859 wait_event_timeout(mdc800->write_wait, mdc800->written,
860 msecs_to_jiffies(TO_WRITE_GET_READY));
861 mdc800->written = 0;
862 if (mdc800->state == WORKING)
863 {
864 usb_kill_urb(mdc800->write_urb);
865 mutex_unlock(&mdc800->io_lock);
866 return -EIO;
867 }
868
869 switch ((unsigned char) mdc800->in[1])
870 {
871 case 0x05: /* Download Image */
872 case 0x3e: /* Take shot in Fine Mode (WCam Mode) */
873 if (mdc800->pic_len < 0)
874 {
875 dev_err(&mdc800->dev->dev,
876 "call 0x07 before "
877 "0x05,0x3e\n");
878 mdc800->state=READY;
879 mutex_unlock(&mdc800->io_lock);
880 return -EIO;
881 }
882 mdc800->pic_len=-1;
883 fallthrough;
884
885 case 0x09: /* Download Thumbnail */
886 mdc800->download_left=answersize+64;
887 mdc800->state=DOWNLOAD;
888 mdc800_usb_waitForIRQ (0,TO_DOWNLOAD_GET_BUSY);
889 break;
890
891
892 default:
893 if (answersize)
894 {
895
896 if (mdc800_usb_waitForIRQ (1,TO_READ_FROM_IRQ))
897 {
898 dev_err(&mdc800->dev->dev, "requesting answer from irq fails\n");
899 mutex_unlock(&mdc800->io_lock);
900 return -EIO;
901 }
902
903 /* Write dummy data, (this is ugly but part of the USB Protocol */
904 /* if you use endpoint 1 as bulk and not as irq) */
905 memcpy (mdc800->out, mdc800->camera_response,8);
906
907 /* This is the interpreted answer */
908 memcpy (&mdc800->out[8], mdc800->camera_response,8);
909
910 mdc800->out_ptr=0;
911 mdc800->out_count=16;
912
913 /* Cache the Imagesize, if command was getImageSize */
914 if (mdc800->in [1] == (char) 0x07)
915 {
916 mdc800->pic_len=(int) 65536*(unsigned char) mdc800->camera_response[0]+256*(unsigned char) mdc800->camera_response[1]+(unsigned char) mdc800->camera_response[2];
917
918 dev_dbg(&mdc800->dev->dev, "cached imagesize = %i\n", mdc800->pic_len);
919 }
920
921 }
922 else
923 {
924 if (mdc800_usb_waitForIRQ (0,TO_DEFAULT_COMMAND))
925 {
926 dev_err(&mdc800->dev->dev, "Command Timeout.\n");
927 mutex_unlock(&mdc800->io_lock);
928 return -EIO;
929 }
930 }
931 mdc800->state=READY;
932 break;
933 }
934 }
935 i++;
936 }
937 mutex_unlock(&mdc800->io_lock);
938 return i;
939 }
940
941
942 /***************************************************************************
943 Init and Cleanup this driver (Structs and types)
944 ****************************************************************************/
945
946 /* File Operations of this drivers */
947 static const struct file_operations mdc800_device_ops =
948 {
949 .owner = THIS_MODULE,
950 .read = mdc800_device_read,
951 .write = mdc800_device_write,
952 .open = mdc800_device_open,
953 .release = mdc800_device_release,
954 .llseek = noop_llseek,
955 };
956
957
958
959 static const struct usb_device_id mdc800_table[] = {
960 { USB_DEVICE(MDC800_VENDOR_ID, MDC800_PRODUCT_ID) },
961 { } /* Terminating entry */
962 };
963
964 MODULE_DEVICE_TABLE (usb, mdc800_table);
965 /*
966 * USB Driver Struct for this device
967 */
968 static struct usb_driver mdc800_usb_driver =
969 {
970 .name = "mdc800",
971 .probe = mdc800_usb_probe,
972 .disconnect = mdc800_usb_disconnect,
973 .id_table = mdc800_table
974 };
975
976
977
978 /************************************************************************
979 Init and Cleanup this driver (Main Functions)
980 *************************************************************************/
981
usb_mdc800_init(void)982 static int __init usb_mdc800_init (void)
983 {
984 int retval = -ENODEV;
985 /* Allocate Memory */
986 mdc800=kzalloc (sizeof (struct mdc800_data), GFP_KERNEL);
987 if (!mdc800)
988 goto cleanup_on_fail;
989
990 mdc800->dev = NULL;
991 mdc800->state=NOT_CONNECTED;
992 mutex_init (&mdc800->io_lock);
993
994 init_waitqueue_head (&mdc800->irq_wait);
995 init_waitqueue_head (&mdc800->write_wait);
996 init_waitqueue_head (&mdc800->download_wait);
997
998 mdc800->irq_woken = 0;
999 mdc800->downloaded = 0;
1000 mdc800->written = 0;
1001
1002 mdc800->irq_urb_buffer=kmalloc (8, GFP_KERNEL);
1003 if (!mdc800->irq_urb_buffer)
1004 goto cleanup_on_fail;
1005 mdc800->write_urb_buffer=kmalloc (8, GFP_KERNEL);
1006 if (!mdc800->write_urb_buffer)
1007 goto cleanup_on_fail;
1008 mdc800->download_urb_buffer=kmalloc (64, GFP_KERNEL);
1009 if (!mdc800->download_urb_buffer)
1010 goto cleanup_on_fail;
1011
1012 mdc800->irq_urb=usb_alloc_urb (0, GFP_KERNEL);
1013 if (!mdc800->irq_urb)
1014 goto cleanup_on_fail;
1015 mdc800->download_urb=usb_alloc_urb (0, GFP_KERNEL);
1016 if (!mdc800->download_urb)
1017 goto cleanup_on_fail;
1018 mdc800->write_urb=usb_alloc_urb (0, GFP_KERNEL);
1019 if (!mdc800->write_urb)
1020 goto cleanup_on_fail;
1021
1022 /* Register the driver */
1023 retval = usb_register(&mdc800_usb_driver);
1024 if (retval)
1025 goto cleanup_on_fail;
1026
1027 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1028 DRIVER_DESC "\n");
1029
1030 return 0;
1031
1032 /* Clean driver up, when something fails */
1033
1034 cleanup_on_fail:
1035
1036 if (mdc800 != NULL)
1037 {
1038 printk(KERN_ERR "mdc800: can't alloc memory!\n");
1039
1040 kfree(mdc800->download_urb_buffer);
1041 kfree(mdc800->write_urb_buffer);
1042 kfree(mdc800->irq_urb_buffer);
1043
1044 usb_free_urb(mdc800->write_urb);
1045 usb_free_urb(mdc800->download_urb);
1046 usb_free_urb(mdc800->irq_urb);
1047
1048 kfree (mdc800);
1049 }
1050 mdc800 = NULL;
1051 return retval;
1052 }
1053
1054
usb_mdc800_cleanup(void)1055 static void __exit usb_mdc800_cleanup (void)
1056 {
1057 usb_deregister (&mdc800_usb_driver);
1058
1059 usb_free_urb (mdc800->irq_urb);
1060 usb_free_urb (mdc800->download_urb);
1061 usb_free_urb (mdc800->write_urb);
1062
1063 kfree (mdc800->irq_urb_buffer);
1064 kfree (mdc800->write_urb_buffer);
1065 kfree (mdc800->download_urb_buffer);
1066
1067 kfree (mdc800);
1068 mdc800 = NULL;
1069 }
1070
1071 module_init (usb_mdc800_init);
1072 module_exit (usb_mdc800_cleanup);
1073
1074 MODULE_AUTHOR( DRIVER_AUTHOR );
1075 MODULE_DESCRIPTION( DRIVER_DESC );
1076 MODULE_LICENSE("GPL");
1077
1078