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 * the 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 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 */ 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 */ 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 */ 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 /* fall through */ 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 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 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