开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
mdc800.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：23k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

mdc800.c：源码内容
  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.  */
  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 Protocoll 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 <520047054719-0001@t-online.de>
  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@lrz.uni-muenchen.de> 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.  */
  88. #include <linux/version.h>
  89. #include <linux/sched.h>
  90. #include <linux/signal.h>
  91. #include <linux/spinlock.h>
  92. #include <linux/errno.h>
  93. #include <linux/random.h>
  94. #include <linux/poll.h>
  95. #include <linux/init.h>
  96. #include <linux/slab.h>
  97. #include <linux/module.h>
  98. #include <linux/smp_lock.h>
  100. #include <linux/usb.h>
  102. /*
  103.  * Version Information
  104.  */
  105. #define DRIVER_VERSION "v0.7.5 (30/10/2000)"
  106. #define DRIVER_AUTHOR "Henning Zabel <henning@uni-paderborn.de>"
  107. #define DRIVER_DESC "USB Driver for Mustek MDC800 Digital Camera"
  109. /* Vendor and Product Information */
  110. #define MDC800_VENDOR_ID  0x055f
  111. #define MDC800_PRODUCT_ID 0xa800
  113. /* Timeouts (msec) */
  114. #define TO_DOWNLOAD_GET_READY 1500
  115. #define TO_DOWNLOAD_GET_BUSY 1500
  116. #define TO_WRITE_GET_READY 1000
  117. #define TO_DEFAULT_COMMAND 5000
  118. #define TO_READ_FROM_IRQ  TO_DEFAULT_COMMAND
  119. #define TO_GET_READY TO_DEFAULT_COMMAND
  121. /* Minor Number of the device (create with mknod /dev/mustek c 180 32) */
  122. #define MDC800_DEVICE_MINOR_BASE 32
  125. /**************************************************************************
  126. Data and structs
  127. ***************************************************************************/
  130. typedef enum {
  131. NOT_CONNECTED, READY, WORKING, DOWNLOAD
  132. } mdc800_state;
  135. /* Data for the driver */
  136. struct mdc800_data
  137. {
  138. struct usb_device * dev; // Device Data
  139. mdc800_state  state;
  141. unsigned int endpoint [4];
  143. struct urb * irq_urb;
  144. wait_queue_head_t irq_wait;
  145. int                     irq_woken;
  146. char* irq_urb_buffer;
  148. int camera_busy;          // is camera busy ?
  149. int  camera_request_ready; // Status to synchronize with irq
  150. char  camera_response [8];  // last Bytes send after busy
  152. struct urb *    write_urb;
  153. char* write_urb_buffer;
  154. wait_queue_head_t write_wait;
  155. int                     written;
  158. struct urb * download_urb;
  159. char* download_urb_buffer;
  160. wait_queue_head_t download_wait;
  161. int                     downloaded;
  162. int download_left; // Bytes left to download ?
  165. /* Device Data */
  166. char out [64]; // Answer Buffer
  167. int  out_ptr; // Index to the first not readen byte
  168. int out_count; // Bytes in the buffer
  170. int open; // Camera device open ?
  171. struct semaphore io_lock; // IO -lock
  173. char  in [8]; // Command Input Buffer
  174. int   in_count;
  176. int pic_index; // Cache for the Imagesize (-1 for nothing cached )
  177. int pic_len;
  178. };
  181. /* Specification of the Endpoints */
  182. static struct usb_endpoint_descriptor mdc800_ed [4] =
  183. {
  184. { 0,0, 0x01, 0x02,  8, 0,0,0 },
  185. { 0,0, 0x82, 0x03,  8, 0,0,0 },
  186. { 0,0, 0x03, 0x02, 64, 0,0,0 },
  187. { 0,0, 0x84, 0x02, 64, 0,0,0 }
  188. };
  191. /* The Variable used by the driver */
  192. static struct mdc800_data* mdc800=0;
  195. /***************************************************************************
  196. The USB Part of the driver
  197. ****************************************************************************/
  199. static int mdc800_endpoint_equals (struct usb_endpoint_descriptor *a,struct usb_endpoint_descriptor *b)
  200. {
  201. return (
  202.    ( a->bEndpointAddress == b->bEndpointAddress )
  203. && ( a->bmAttributes     == b->bmAttributes     )
  204. && ( a->wMaxPacketSize   == b->wMaxPacketSize   )
  205. );
  206. }
  209. /*
  210.  * Checks wether the camera responds busy
  211.  */
  212. static int mdc800_isBusy (char* ch)
  213. {
  214. int i=0;
  215. while (i<8)
  216. {
  217. if (ch [i] != (char)0x99)
  218. return 0;
  219. i++;
  220. }
  221. return 1;
  222. }
  225. /*
  226.  * Checks wether the Camera is ready
  227.  */
  228. static int mdc800_isReady (char *ch)
  229. {
  230. int i=0;
  231. while (i<8)
  232. {
  233. if (ch [i] != (char)0xbb)
  234. return 0;
  235. i++;
  236. }
  237. return 1;
  238. }
  242. /*
  243.  * USB IRQ Handler for InputLine
  244.  */
  245. static void mdc800_usb_irq (struct urb *urb)
  246. {
  247. int data_received=0, wake_up;
  248. unsigned char* b=urb->transfer_buffer;
  249. struct mdc800_data* mdc800=urb->context;
  251. if (urb->status >= 0)
  252. {
  254. //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]);
  256. if (mdc800_isBusy (b))
  257. {
  258. if (!mdc800->camera_busy)
  259. {
  260. mdc800->camera_busy=1;
  261. dbg ("gets busy");
  262. }
  263. }
  264. else
  265. {
  266. if (mdc800->camera_busy && mdc800_isReady (b))
  267. {
  268. mdc800->camera_busy=0;
  269. dbg ("gets ready");
  270. }
  271. }
  272. if (!(mdc800_isBusy (b) || mdc800_isReady (b)))
  273. {
  274. /* Store Data in camera_answer field */
  275. 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]);
  277. memcpy (mdc800->camera_response,b,8);
  278. data_received=1;
  279. }
  280. }
  281. wake_up= ( mdc800->camera_request_ready > 0 )
  282. &&
  283. (
  284. ((mdc800->camera_request_ready == 1) && (!mdc800->camera_busy))
  285. ||
  286. ((mdc800->camera_request_ready == 2) && data_received)
  287. ||
  288. ((mdc800->camera_request_ready == 3) && (mdc800->camera_busy))
  289. ||
  290. (urb->status < 0)
  291. );
  293. if (wake_up)
  294. {
  295. mdc800->camera_request_ready=0;
  296. mdc800->irq_woken=1;
  297. wake_up_interruptible (&mdc800->irq_wait);
  298. }
  299. }
  302. /*
  303.  * Waits a while until the irq responds that camera is ready
  304.  *
  305.  *  mode : 0: Wait for camera gets ready
  306.  *         1: Wait for receiving data
  307.  *         2: Wait for camera gets busy
  308.  *
  309.  * msec: Time to wait
  310.  */
  311. static int mdc800_usb_waitForIRQ (int mode, int msec)
  312. {
  313.         DECLARE_WAITQUEUE(wait, current);
  315. mdc800->camera_request_ready=1+mode;
  317. add_wait_queue(&mdc800->irq_wait, &wait);
  318. set_current_state(TASK_INTERRUPTIBLE);
  319. if (!mdc800->irq_woken)
  320. {
  321.         schedule_timeout (msec*HZ/1000);
  322. }
  323.         remove_wait_queue(&mdc800->irq_wait, &wait);
  324. set_current_state(TASK_RUNNING);
  325. mdc800->irq_woken = 0;
  327. if (mdc800->camera_request_ready>0)
  328. {
  329. mdc800->camera_request_ready=0;
  330. err ("timeout waiting for camera.");
  331. return -1;
  332. }
  334. if (mdc800->state == NOT_CONNECTED)
  335. {
  336. warn ("Camera gets disconnected during waiting for irq.");
  337. mdc800->camera_request_ready=0;
  338. return -2;
  339. }
  341. return 0;
  342. }
  345. /*
  346.  * The write_urb callback function
  347.  */
  348. static void mdc800_usb_write_notify (struct urb *urb)
  349. {
  350. struct mdc800_data* mdc800=urb->context;
  352. if (urb->status != 0)
  353. {
  354. err ("writing command fails (status=%i)", urb->status);
  355. }
  356. else
  357. {
  358. mdc800->state=READY;
  359. }
  360. mdc800->written = 1;
  361. wake_up_interruptible (&mdc800->write_wait);
  362. }
  365. /*
  366.  * The download_urb callback function
  367.  */
  368. static void mdc800_usb_download_notify (struct urb *urb)
  369. {
  370. struct mdc800_data* mdc800=urb->context;
  372. if (urb->status == 0)
  373. {
  374. /* Fill output buffer with these data */
  375. memcpy (mdc800->out,  urb->transfer_buffer, 64);
  376. mdc800->out_count=64;
  377. mdc800->out_ptr=0;
  378. mdc800->download_left-=64;
  379. if (mdc800->download_left == 0)
  380. {
  381. mdc800->state=READY;
  382. }
  383. }
  384. else
  385. {
  386. err ("request bytes fails (status:%i)", urb->status);
  387. }
  388. mdc800->downloaded = 1;
  389. wake_up_interruptible (&mdc800->download_wait);
  390. }
  393. /***************************************************************************
  394. Probing for the Camera
  395.  ***************************************************************************/
  397. static struct usb_driver mdc800_usb_driver;
  399. /*
  400.  * Callback to search the Mustek MDC800 on the USB Bus
  401.  */
  402. static void* mdc800_usb_probe (struct usb_device *dev ,unsigned int ifnum,
  403.        const struct usb_device_id *id)
  404. {
  405. int i,j;
  406. struct usb_interface_descriptor *intf_desc;
  407. int irq_interval=0;
  409. dbg ("(mdc800_usb_probe) called.");
  412. if (mdc800->dev != 0)
  413. {
  414. warn ("only one Mustek MDC800 is supported.");
  415. return 0;
  416. }
  418. if (dev->descriptor.bNumConfigurations != 1)
  419. {
  420. err ("probe fails -> wrong Number of Configuration");
  421. return 0;
  422. }
  423. intf_desc=&dev->actconfig->interface[ifnum].altsetting[0];
  425. if (
  426. ( intf_desc->bInterfaceClass != 0xff )
  427. || ( intf_desc->bInterfaceSubClass != 0 )
  428. || ( intf_desc->bInterfaceProtocol != 0 )
  429. || ( intf_desc->bNumEndpoints != 4)
  430. )
  431. {
  432. err ("probe fails -> wrong Interface");
  433. return 0;
  434. }
  436. /* Check the Endpoints */
  437. for (i=0; i<4; i++)
  438. {
  439. mdc800->endpoint[i]=-1;
  440. for (j=0; j<4; j++)
  441. {
  442. if (mdc800_endpoint_equals (&intf_desc->endpoint [j],&mdc800_ed [i]))
  443. {
  444. mdc800->endpoint[i]=intf_desc->endpoint [j].bEndpointAddress ;
  445. if (i==1)
  446. {
  447. irq_interval=intf_desc->endpoint [j].bInterval;
  448. }
  450. continue;
  451. }
  452. }
  453. if (mdc800->endpoint[i] == -1)
  454. {
  455. err ("probe fails -> Wrong Endpoints.");
  456. return 0;
  457. }
  458. }
  461. usb_driver_claim_interface (&mdc800_usb_driver, &dev->actconfig->interface[ifnum], mdc800);
  462. if (usb_set_interface (dev, ifnum, 0) < 0)
  463. {
  464. err ("MDC800 Configuration fails.");
  465. return 0;
  466. }
  468. info ("Found Mustek MDC800 on USB.");
  470. down (&mdc800->io_lock);
  472. mdc800->dev=dev;
  473. mdc800->open=0;
  475. /* Setup URB Structs */
  476. FILL_INT_URB (
  477. mdc800->irq_urb,
  478. mdc800->dev,
  479. usb_rcvintpipe (mdc800->dev,mdc800->endpoint [1]),
  480. mdc800->irq_urb_buffer,
  481. 8,
  482. mdc800_usb_irq,
  483. mdc800,
  484. irq_interval
  485. );
  487. FILL_BULK_URB (
  488. mdc800->write_urb,
  489. mdc800->dev,
  490. usb_sndbulkpipe (mdc800->dev, mdc800->endpoint[0]),
  491. mdc800->write_urb_buffer,
  492. 8,
  493. mdc800_usb_write_notify,
  494. mdc800
  495. );
  497. FILL_BULK_URB (
  498. mdc800->download_urb,
  499. mdc800->dev,
  500. usb_rcvbulkpipe (mdc800->dev, mdc800->endpoint [3]),
  501. mdc800->download_urb_buffer,
  502. 64,
  503. mdc800_usb_download_notify,
  504. mdc800
  505. );
  507. mdc800->state=READY;
  509. up (&mdc800->io_lock);
  511. return mdc800;
  512. }
  515. /*
  516.  * Disconnect USB device (maybe the MDC800)
  517.  */
  518. static void mdc800_usb_disconnect (struct usb_device *dev,void* ptr)
  519. {
  520. struct mdc800_data* mdc800=(struct mdc800_data*) ptr;
  522. dbg ("(mdc800_usb_disconnect) called");
  524. if (mdc800->state == NOT_CONNECTED)
  525. return;
  527. mdc800->state=NOT_CONNECTED;
  529. usb_unlink_urb (mdc800->irq_urb);
  530. usb_unlink_urb (mdc800->write_urb);
  531. usb_unlink_urb (mdc800->download_urb);
  533. usb_driver_release_interface (&mdc800_usb_driver, &dev->actconfig->interface[1]);
  535. mdc800->dev=0;
  536. info ("Mustek MDC800 disconnected from USB.");
  537. }
  540. /***************************************************************************
  541. The Misc device Part (file_operations)
  542. ****************************************************************************/
  544. /*
  545.  * This Function calc the Answersize for a command.
  546.  */
  547. static int mdc800_getAnswerSize (char command)
  548. {
  549. switch ((unsigned char) command)
  550. {
  551. case 0x2a:
  552. case 0x49:
  553. case 0x51:
  554. case 0x0d:
  555. case 0x20:
  556. case 0x07:
  557. case 0x01:
  558. case 0x25:
  559. case 0x00:
  560. return 8;
  562. case 0x05:
  563. case 0x3e:
  564. return mdc800->pic_len;
  566. case 0x09:
  567. return 4096;
  569. default:
  570. return 0;
  571. }
  572. }
  575. /*
  576.  * Init the device: (1) alloc mem (2) Increase MOD Count ..
  577.  */
  578. static int mdc800_device_open (struct inode* inode, struct file *file)
  579. {
  580. int retval=0;
  581. int errn=0;
  583. down (&mdc800->io_lock);
  585. if (mdc800->state == NOT_CONNECTED)
  586. {
  587. errn=-EBUSY;
  588. goto error_out;
  589. }
  590. if (mdc800->open)
  591. {
  592. errn=-EBUSY;
  593. goto error_out;
  594. }
  596. mdc800->in_count=0;
  597. mdc800->out_count=0;
  598. mdc800->out_ptr=0;
  599. mdc800->pic_index=0;
  600. mdc800->pic_len=-1;
  601. mdc800->download_left=0;
  603. mdc800->camera_busy=0;
  604. mdc800->camera_request_ready=0;
  606. retval=0;
  607. mdc800->irq_urb->dev = mdc800->dev;
  608. if (usb_submit_urb (mdc800->irq_urb))
  609. {
  610. err ("request USB irq fails (submit_retval=%i urb_status=%i).",retval, mdc800->irq_urb->status);
  611. errn = -EIO;
  612. goto error_out;
  613. }
  615. mdc800->open=1;
  616. dbg ("Mustek MDC800 device opened.");
  618. error_out:
  619. up (&mdc800->io_lock);
  620. return errn;
  621. }
  624. /*
  625.  * Close the Camera and release Memory
  626.  */
  627. static int mdc800_device_release (struct inode* inode, struct file *file)
  628. {
  629. int retval=0;
  630. dbg ("Mustek MDC800 device closed.");
  632. down (&mdc800->io_lock);
  633. if (mdc800->open && (mdc800->state != NOT_CONNECTED))
  634. {
  635. usb_unlink_urb (mdc800->irq_urb);
  636. usb_unlink_urb (mdc800->write_urb);
  637. usb_unlink_urb (mdc800->download_urb);
  638. mdc800->open=0;
  639. }
  640. else
  641. {
  642. retval=-EIO;
  643. }
  645.         up(&mdc800->io_lock);
  646. return retval;
  647. }
  650. /*
  651.  * The Device read callback Function
  652.  */
  653. static ssize_t mdc800_device_read (struct file *file, char *buf, size_t len, loff_t *pos)
  654. {
  655. size_t left=len, sts=len; /* single transfer size */
  656. char* ptr=buf;
  657. DECLARE_WAITQUEUE(wait, current);
  659. down (&mdc800->io_lock);
  660. if (mdc800->state == NOT_CONNECTED)
  661. {
  662. up (&mdc800->io_lock);
  663. return -EBUSY;
  664. }
  665. if (mdc800->state == WORKING)
  666. {
  667. warn ("Illegal State "working" reached during read ?!");
  668. up (&mdc800->io_lock);
  669. return -EBUSY;
  670. }
  671. if (!mdc800->open)
  672. {
  673. up (&mdc800->io_lock);
  674. return -EBUSY;
  675. }
  677. while (left)
  678. {
  679. if (signal_pending (current)) 
  680. {
  681. up (&mdc800->io_lock);
  682. return -EINTR;
  683. }
  685. sts=left > (mdc800->out_count-mdc800->out_ptr)?mdc800->out_count-mdc800->out_ptr:left;
  687. if (sts <= 0)
  688. {
  689. /* Too less Data in buffer */
  690. if (mdc800->state == DOWNLOAD)
  691. {
  692. mdc800->out_count=0;
  693. mdc800->out_ptr=0;
  695. /* Download -> Request new bytes */
  696. mdc800->download_urb->dev = mdc800->dev;
  697. if (usb_submit_urb (mdc800->download_urb))
  698. {
  699. err ("Can't submit download urb (status=%i)",mdc800->download_urb->status);
  700. up (&mdc800->io_lock);
  701. return len-left;
  702. }
  703. add_wait_queue(&mdc800->download_wait, &wait);
  704. set_current_state(TASK_INTERRUPTIBLE);
  705. if (!mdc800->downloaded)
  706. {
  707.         schedule_timeout (TO_DOWNLOAD_GET_READY*HZ/1000);
  708. }
  709.                                 set_current_state(TASK_RUNNING);
  710. remove_wait_queue(&mdc800->download_wait, &wait);
  711. mdc800->downloaded = 0;
  712. if (mdc800->download_urb->status != 0)
  713. {
  714. err ("request download-bytes fails (status=%i)",mdc800->download_urb->status);
  715. up (&mdc800->io_lock);
  716. return len-left;
  717. }
  718. }
  719. else
  720. {
  721. /* No more bytes -> that's an error*/
  722. up (&mdc800->io_lock);
  723. return -EIO;
  724. }
  725. }
  726. else
  727. {
  728. /* memcpy Bytes */
  729. memcpy (ptr, &mdc800->out [mdc800->out_ptr], sts);
  730. ptr+=sts;
  731. left-=sts;
  732. mdc800->out_ptr+=sts;
  733. }
  734. }
  736. up (&mdc800->io_lock);
  737. return len-left;
  738. }
  741. /*
  742.  * The Device write callback Function
  743.  * If a 8Byte Command is received, it will be send to the camera.
  744.  * After this the driver initiates the request for the answer or
  745.  * just waits until the camera becomes ready.
  746.  */
  747. static ssize_t mdc800_device_write (struct file *file, const char *buf, size_t len, loff_t *pos)
  748. {
  749. size_t i=0;
  750. DECLARE_WAITQUEUE(wait, current);
  752. down (&mdc800->io_lock);
  753. if (mdc800->state != READY)
  754. {
  755. up (&mdc800->io_lock);
  756. return -EBUSY;
  757. }
  758. if (!mdc800->open )
  759. {
  760. up (&mdc800->io_lock);
  761. return -EBUSY;
  762. }
  764. while (i<len)
  765. {
  766. if (signal_pending (current)) 
  767. {
  768. up (&mdc800->io_lock);
  769. return -EINTR;
  770. }
  772. /* check for command start */
  773. if (buf [i] == (char) 0x55)
  774. {
  775. mdc800->in_count=0;
  776. mdc800->out_count=0;
  777. mdc800->out_ptr=0;
  778. mdc800->download_left=0;
  779. }
  781. /* save command byte */
  782. if (mdc800->in_count < 8)
  783. {
  784. mdc800->in[mdc800->in_count]=buf[i];
  785. mdc800->in_count++;
  786. }
  787. else
  788. {
  789. err ("Command is to long !n");
  790. up (&mdc800->io_lock);
  791. return -EIO;
  792. }
  794. /* Command Buffer full ? -> send it to camera */
  795. if (mdc800->in_count == 8)
  796. {
  797. int answersize;
  799. if (mdc800_usb_waitForIRQ (0,TO_GET_READY))
  800. {
  801. err ("Camera didn't get ready.n");
  802. up (&mdc800->io_lock);
  803. return -EIO;
  804. }
  806. answersize=mdc800_getAnswerSize (mdc800->in[1]);
  808. mdc800->state=WORKING;
  809. memcpy (mdc800->write_urb->transfer_buffer, mdc800->in,8);
  810. mdc800->write_urb->dev = mdc800->dev;
  811. if (usb_submit_urb (mdc800->write_urb))
  812. {
  813. err ("submitting write urb fails (status=%i)", mdc800->write_urb->status);
  814. up (&mdc800->io_lock);
  815. return -EIO;
  816. }
  817. add_wait_queue(&mdc800->write_wait, &wait);
  818. set_current_state(TASK_INTERRUPTIBLE);
  819. if (!mdc800->written)
  820. {
  821.         schedule_timeout (TO_WRITE_GET_READY*HZ/1000);
  822. }
  823.                         set_current_state(TASK_RUNNING);
  824. remove_wait_queue(&mdc800->write_wait, &wait);
  825. mdc800->written = 0;
  826. if (mdc800->state == WORKING)
  827. {
  828. usb_unlink_urb (mdc800->write_urb);
  829. up (&mdc800->io_lock);
  830. return -EIO;
  831. }
  833. switch ((unsigned char) mdc800->in[1])
  834. {
  835. case 0x05: /* Download Image */
  836. case 0x3e: /* Take shot in Fine Mode (WCam Mode) */
  837. if (mdc800->pic_len < 0)
  838. {
  839. err ("call 0x07 before 0x05,0x3e");
  840. mdc800->state=READY;
  841. up (&mdc800->io_lock);
  842. return -EIO;
  843. }
  844. mdc800->pic_len=-1;
  846. case 0x09: /* Download Thumbnail */
  847. mdc800->download_left=answersize+64;
  848. mdc800->state=DOWNLOAD;
  849. mdc800_usb_waitForIRQ (0,TO_DOWNLOAD_GET_BUSY);
  850. break;
  853. default:
  854. if (answersize)
  855. {
  857. if (mdc800_usb_waitForIRQ (1,TO_READ_FROM_IRQ))
  858. {
  859. err ("requesting answer from irq fails");
  860. up (&mdc800->io_lock);
  861. return -EIO;
  862. }
  864. /* Write dummy data, (this is ugly but part of the USB Protokoll */
  865. /* if you use endpoint 1 as bulk and not as irq */
  866. memcpy (mdc800->out, mdc800->camera_response,8);
  868. /* This is the interpreted answer */
  869. memcpy (&mdc800->out[8], mdc800->camera_response,8);
  871. mdc800->out_ptr=0;
  872. mdc800->out_count=16;
  874. /* Cache the Imagesize, if command was getImageSize */
  875. if (mdc800->in [1] == (char) 0x07)
  876. {
  877. mdc800->pic_len=(int) 65536*(unsigned char) mdc800->camera_response[0]+256*(unsigned char) mdc800->camera_response[1]+(unsigned char) mdc800->camera_response[2];
  879. dbg ("cached imagesize = %i",mdc800->pic_len);
  880. }
  882. }
  883. else
  884. {
  885. if (mdc800_usb_waitForIRQ (0,TO_DEFAULT_COMMAND))
  886. {
  887. err ("Command Timeout.");
  888. up (&mdc800->io_lock);
  889. return -EIO;
  890. }
  891. }
  892. mdc800->state=READY;
  893. break;
  894. }
  895. }
  896. i++;
  897. }
  898. up (&mdc800->io_lock);
  899. return i;
  900. }
  903. /***************************************************************************
  904. Init and Cleanup this driver (Structs and types)
  905. ****************************************************************************/
  907. /* File Operations of this drivers */
  908. static struct file_operations mdc800_device_ops =
  909. {
  910. owner: THIS_MODULE,
  911. read: mdc800_device_read,
  912. write: mdc800_device_write,
  913. open: mdc800_device_open,
  914. release: mdc800_device_release,
  915. };
  919. static struct usb_device_id mdc800_table [] = {
  920. { USB_DEVICE(MDC800_VENDOR_ID, MDC800_PRODUCT_ID) },
  921. { } /* Terminating entry */
  922. };
  924. MODULE_DEVICE_TABLE (usb, mdc800_table);
  925. /*
  926.  * USB Driver Struct for this device
  927.  */
  928. static struct usb_driver mdc800_usb_driver =
  929. {
  930. name: "mdc800",
  931. probe: mdc800_usb_probe,
  932. disconnect: mdc800_usb_disconnect,
  933. fops: &mdc800_device_ops,
  934. minor: MDC800_DEVICE_MINOR_BASE,
  935. id_table: mdc800_table
  936. };
  940. /************************************************************************
  941. Init and Cleanup this driver (Main Functions)
  942. *************************************************************************/
  944. #define try(A)           if ((A) == 0) goto cleanup_on_fail;
  945. #define try_free_mem(A)  if (A != 0) { kfree (A); A=0; }
  946. #define try_free_urb(A)  if (A != 0) { usb_free_urb (A); A=0; }
  948. int __init usb_mdc800_init (void)
  949. {
  950. /* Allocate Memory */
  951. try (mdc800=kmalloc (sizeof (struct mdc800_data), GFP_KERNEL));
  953. memset(mdc800, 0, sizeof(struct mdc800_data));
  954. mdc800->dev=0;
  955. mdc800->open=0;
  956. mdc800->state=NOT_CONNECTED;
  957. init_MUTEX (&mdc800->io_lock);
  959. init_waitqueue_head (&mdc800->irq_wait);
  960. init_waitqueue_head (&mdc800->write_wait);
  961. init_waitqueue_head (&mdc800->download_wait);
  963. mdc800->irq_woken = 0;
  964. mdc800->downloaded = 0;
  965. mdc800->written = 0;
  967. try (mdc800->irq_urb_buffer=kmalloc (8, GFP_KERNEL));
  968. try (mdc800->write_urb_buffer=kmalloc (8, GFP_KERNEL));
  969. try (mdc800->download_urb_buffer=kmalloc (64, GFP_KERNEL));
  971. try (mdc800->irq_urb=usb_alloc_urb (0));
  972. try (mdc800->download_urb=usb_alloc_urb (0));
  973. try (mdc800->write_urb=usb_alloc_urb (0));
  975. /* Register the driver */
  976. if (usb_register (&mdc800_usb_driver) < 0)
  977. goto cleanup_on_fail;
  979. info (DRIVER_VERSION ":" DRIVER_DESC);
  981. return 0;
  983. /* Clean driver up, when something fails */
  985. cleanup_on_fail:
  987. if (mdc800 != 0)
  988. {
  989. err ("can't alloc memory!");
  991. try_free_mem (mdc800->download_urb_buffer);
  992. try_free_mem (mdc800->write_urb_buffer);
  993. try_free_mem (mdc800->irq_urb_buffer);
  995. try_free_urb (mdc800->write_urb);
  996. try_free_urb (mdc800->download_urb);
  997. try_free_urb (mdc800->irq_urb);
  999. kfree (mdc800);
  1000. }
  1001. mdc800=0;
  1002. return -1;
  1003. }
  1006. void __exit usb_mdc800_cleanup (void)
  1007. {
  1008. usb_deregister (&mdc800_usb_driver);
  1010. usb_free_urb (mdc800->irq_urb);
  1011. usb_free_urb (mdc800->download_urb);
  1012. usb_free_urb (mdc800->write_urb);
  1014. kfree (mdc800->irq_urb_buffer);
  1015. kfree (mdc800->write_urb_buffer);
  1016. kfree (mdc800->download_urb_buffer);
  1018. kfree (mdc800);
  1019. mdc800=0;
  1020. }
  1022. module_init (usb_mdc800_init);
  1023. module_exit (usb_mdc800_cleanup);
  1025. MODULE_AUTHOR( DRIVER_AUTHOR );
  1026. MODULE_DESCRIPTION( DRIVER_DESC );
  1027. MODULE_LICENSE("GPL");