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 | |
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 | */ |
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 | */ |
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 | */ |
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 (ch: 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 (ch: b)) |
289 | { |
290 | mdc800->camera_busy=0; |
291 | dev_dbg(dev, "gets ready\n" ); |
292 | } |
293 | } |
294 | if (!(mdc800_isBusy (ch: b) || mdc800_isReady (ch: 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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 (a: &intf_desc->endpoint [j].desc,b: &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, class_driver: &mdc800_class); |
486 | if (retval) { |
487 | dev_err(&intf->dev, "Not able to get a minor for this device.\n" ); |
488 | mutex_unlock(lock: &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 | urb: mdc800->irq_urb, |
498 | dev: mdc800->dev, |
499 | usb_rcvintpipe (mdc800->dev,mdc800->endpoint [1]), |
500 | transfer_buffer: mdc800->irq_urb_buffer, |
501 | buffer_length: 8, |
502 | complete_fn: mdc800_usb_irq, |
503 | context: mdc800, |
504 | interval: irq_interval |
505 | ); |
506 | |
507 | usb_fill_bulk_urb ( |
508 | urb: mdc800->write_urb, |
509 | dev: mdc800->dev, |
510 | usb_sndbulkpipe (mdc800->dev, mdc800->endpoint[0]), |
511 | transfer_buffer: mdc800->write_urb_buffer, |
512 | buffer_length: 8, |
513 | complete_fn: mdc800_usb_write_notify, |
514 | context: mdc800 |
515 | ); |
516 | |
517 | usb_fill_bulk_urb ( |
518 | urb: mdc800->download_urb, |
519 | dev: mdc800->dev, |
520 | usb_rcvbulkpipe (mdc800->dev, mdc800->endpoint [3]), |
521 | transfer_buffer: mdc800->download_urb_buffer, |
522 | buffer_length: 64, |
523 | complete_fn: mdc800_usb_download_notify, |
524 | context: mdc800 |
525 | ); |
526 | |
527 | mdc800->state=READY; |
528 | |
529 | mutex_unlock(lock: &mdc800->io_lock); |
530 | |
531 | usb_set_intfdata(intf, data: mdc800); |
532 | return 0; |
533 | } |
534 | |
535 | |
536 | /* |
537 | * Disconnect USB device (maybe the MDC800) |
538 | */ |
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, class_driver: &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(urb: mdc800->irq_urb); |
557 | usb_kill_urb(urb: mdc800->write_urb); |
558 | usb_kill_urb(urb: mdc800->download_urb); |
559 | mutex_unlock(lock: &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 | */ |
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 | */ |
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 (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(lock: &mdc800->io_lock); |
649 | return errn; |
650 | } |
651 | |
652 | |
653 | /* |
654 | * Close the Camera and release Memory |
655 | */ |
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(urb: mdc800->irq_urb); |
664 | usb_kill_urb(urb: mdc800->write_urb); |
665 | usb_kill_urb(urb: mdc800->download_urb); |
666 | mdc800->open=0; |
667 | } |
668 | else |
669 | { |
670 | retval=-EIO; |
671 | } |
672 | |
673 | mutex_unlock(lock: &mdc800->io_lock); |
674 | return retval; |
675 | } |
676 | |
677 | |
678 | /* |
679 | * The Device read callback Function |
680 | */ |
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(lock: &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(lock: &mdc800->io_lock); |
698 | return -EBUSY; |
699 | } |
700 | if (!mdc800->open) |
701 | { |
702 | mutex_unlock(lock: &mdc800->io_lock); |
703 | return -EBUSY; |
704 | } |
705 | |
706 | while (left) |
707 | { |
708 | if (signal_pending (current)) |
709 | { |
710 | mutex_unlock(lock: &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 (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(lock: &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(lock: &mdc800->io_lock); |
745 | return len-left; |
746 | } |
747 | } |
748 | else |
749 | { |
750 | /* No more bytes -> that's an error*/ |
751 | mutex_unlock(lock: &mdc800->io_lock); |
752 | return -EIO; |
753 | } |
754 | } |
755 | else |
756 | { |
757 | /* Copy Bytes */ |
758 | if (copy_to_user(to: ptr, from: &mdc800->out [mdc800->out_ptr], |
759 | n: sts)) { |
760 | mutex_unlock(lock: &mdc800->io_lock); |
761 | return -EFAULT; |
762 | } |
763 | ptr+=sts; |
764 | left-=sts; |
765 | mdc800->out_ptr+=sts; |
766 | } |
767 | } |
768 | |
769 | mutex_unlock(lock: &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 | */ |
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(lock: &mdc800->io_lock); |
789 | return -EBUSY; |
790 | } |
791 | if (!mdc800->open ) |
792 | { |
793 | mutex_unlock(lock: &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(lock: &mdc800->io_lock); |
803 | return -EINTR; |
804 | } |
805 | |
806 | if(get_user(c, buf+i)) |
807 | { |
808 | mutex_unlock(lock: &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(lock: &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 (mode: 0,TO_GET_READY)) |
839 | { |
840 | dev_err(&mdc800->dev->dev, |
841 | "Camera didn't get ready.\n" ); |
842 | mutex_unlock(lock: &mdc800->io_lock); |
843 | return -EIO; |
844 | } |
845 | |
846 | answersize=mdc800_getAnswerSize (command: 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 (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(lock: &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(urb: mdc800->write_urb); |
865 | mutex_unlock(lock: &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(lock: &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 (mode: 0,TO_DOWNLOAD_GET_BUSY); |
889 | break; |
890 | |
891 | |
892 | default: |
893 | if (answersize) |
894 | { |
895 | |
896 | if (mdc800_usb_waitForIRQ (mode: 1,TO_READ_FROM_IRQ)) |
897 | { |
898 | dev_err(&mdc800->dev->dev, "requesting answer from irq fails\n" ); |
899 | mutex_unlock(lock: &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 (mode: 0,TO_DEFAULT_COMMAND)) |
925 | { |
926 | dev_err(&mdc800->dev->dev, "Command Timeout.\n" ); |
927 | mutex_unlock(lock: &mdc800->io_lock); |
928 | return -EIO; |
929 | } |
930 | } |
931 | mdc800->state=READY; |
932 | break; |
933 | } |
934 | } |
935 | i++; |
936 | } |
937 | mutex_unlock(lock: &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 | |
982 | static int __init usb_mdc800_init (void) |
983 | { |
984 | int retval = -ENODEV; |
985 | /* Allocate Memory */ |
986 | mdc800=kzalloc (size: 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 (size: 8, GFP_KERNEL); |
1003 | if (!mdc800->irq_urb_buffer) |
1004 | goto cleanup_on_fail; |
1005 | mdc800->write_urb_buffer=kmalloc (size: 8, GFP_KERNEL); |
1006 | if (!mdc800->write_urb_buffer) |
1007 | goto cleanup_on_fail; |
1008 | mdc800->download_urb_buffer=kmalloc (size: 64, GFP_KERNEL); |
1009 | if (!mdc800->download_urb_buffer) |
1010 | goto cleanup_on_fail; |
1011 | |
1012 | mdc800->irq_urb=usb_alloc_urb (iso_packets: 0, GFP_KERNEL); |
1013 | if (!mdc800->irq_urb) |
1014 | goto cleanup_on_fail; |
1015 | mdc800->download_urb=usb_alloc_urb (iso_packets: 0, GFP_KERNEL); |
1016 | if (!mdc800->download_urb) |
1017 | goto cleanup_on_fail; |
1018 | mdc800->write_urb=usb_alloc_urb (iso_packets: 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(objp: mdc800->download_urb_buffer); |
1041 | kfree(objp: mdc800->write_urb_buffer); |
1042 | kfree(objp: mdc800->irq_urb_buffer); |
1043 | |
1044 | usb_free_urb(urb: mdc800->write_urb); |
1045 | usb_free_urb(urb: mdc800->download_urb); |
1046 | usb_free_urb(urb: mdc800->irq_urb); |
1047 | |
1048 | kfree (objp: mdc800); |
1049 | } |
1050 | mdc800 = NULL; |
1051 | return retval; |
1052 | } |
1053 | |
1054 | |
1055 | static void __exit usb_mdc800_cleanup (void) |
1056 | { |
1057 | usb_deregister (&mdc800_usb_driver); |
1058 | |
1059 | usb_free_urb (urb: mdc800->irq_urb); |
1060 | usb_free_urb (urb: mdc800->download_urb); |
1061 | usb_free_urb (urb: mdc800->write_urb); |
1062 | |
1063 | kfree (objp: mdc800->irq_urb_buffer); |
1064 | kfree (objp: mdc800->write_urb_buffer); |
1065 | kfree (objp: mdc800->download_urb_buffer); |
1066 | |
1067 | kfree (objp: 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 | |