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