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 (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 */ 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 (&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 */ 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 */ 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 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 646 error_out: 647 mutex_unlock(&mdc800->io_lock); 648 return errn; 649 } 650 651 652 /* 653 * Close the Camera and release Memory 654 */ 655 static 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 */ 680 static 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 */ 779 static 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 */ 946 static 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 958 static const struct usb_device_id mdc800_table[] = { 959 { USB_DEVICE(MDC800_VENDOR_ID, MDC800_PRODUCT_ID) }, 960 { } /* Terminating entry */ 961 }; 962 963 MODULE_DEVICE_TABLE (usb, mdc800_table); 964 /* 965 * USB Driver Struct for this device 966 */ 967 static 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 981 static 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 1033 cleanup_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 1054 static 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 1070 module_init (usb_mdc800_init); 1071 module_exit (usb_mdc800_cleanup); 1072 1073 MODULE_AUTHOR( DRIVER_AUTHOR ); 1074 MODULE_DESCRIPTION( DRIVER_DESC ); 1075 MODULE_LICENSE("GPL"); 1076 1077