Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * copyright (C) 1999/2000 by Henning Zabel <henning@uni-paderborn.de>
0004  */
0005 
0006 
0007 /*
0008  *  USB-Kernel Driver for the Mustek MDC800 Digital Camera
0009  *  (c) 1999/2000 Henning Zabel <henning@uni-paderborn.de>
0010  *
0011  *
0012  * The driver brings the USB functions of the MDC800 to Linux.
0013  * To use the Camera you must support the USB Protocol of the camera
0014  * to the Kernel Node.
0015  * The Driver uses a misc device Node. Create it with :
0016  * mknod /dev/mustek c 180 32
0017  *
0018  * The driver supports only one camera.
0019  * 
0020  * Fix: mdc800 used sleep_on and slept with io_lock held.
0021  * Converted sleep_on to waitqueues with schedule_timeout and made io_lock
0022  * a semaphore from a spinlock.
0023  * by Oliver Neukum <oliver@neukum.name>
0024  * (02/12/2001)
0025  * 
0026  * Identify version on module load.
0027  * (08/04/2001) gb
0028  *
0029  * version 0.7.5
0030  * Fixed potential SMP races with Spinlocks.
0031  * Thanks to Oliver Neukum <oliver@neukum.name> who 
0032  * noticed the race conditions.
0033  * (30/10/2000)
0034  *
0035  * Fixed: Setting urb->dev before submitting urb.
0036  * by Greg KH <greg@kroah.com>
0037  * (13/10/2000)
0038  *
0039  * version 0.7.3
0040  * bugfix : The mdc800->state field gets set to READY after the
0041  * disconnect function sets it to NOT_CONNECTED. This makes the
0042  * driver running like the camera is connected and causes some
0043  * hang ups.
0044  *
0045  * version 0.7.1
0046  * MOD_INC and MOD_DEC are changed in usb_probe to prevent load/unload
0047  * problems when compiled as Module.
0048  * (04/04/2000)
0049  *
0050  * The mdc800 driver gets assigned the USB Minor 32-47. The Registration
0051  * was updated to use these values.
0052  * (26/03/2000)
0053  *
0054  * The Init und Exit Module Function are updated.
0055  * (01/03/2000)
0056  *
0057  * version 0.7.0
0058  * Rewrite of the driver : The driver now uses URB's. The old stuff
0059  * has been removed.
0060  *
0061  * version 0.6.0
0062  * Rewrite of this driver: The Emulation of the rs232 protocoll
0063  * has been removed from the driver. A special executeCommand function
0064  * for this driver is included to gphoto.
0065  * The driver supports two kind of communication to bulk endpoints.
0066  * Either with the dev->bus->ops->bulk... or with callback function.
0067  * (09/11/1999)
0068  *
0069  * version 0.5.0:
0070  * first Version that gets a version number. Most of the needed
0071  * functions work.
0072  * (20/10/1999)
0073  */
0074 
0075 #include <linux/sched/signal.h>
0076 #include <linux/signal.h>
0077 #include <linux/spinlock.h>
0078 #include <linux/errno.h>
0079 #include <linux/random.h>
0080 #include <linux/poll.h>
0081 #include <linux/init.h>
0082 #include <linux/slab.h>
0083 #include <linux/module.h>
0084 #include <linux/wait.h>
0085 #include <linux/mutex.h>
0086 
0087 #include <linux/usb.h>
0088 #include <linux/fs.h>
0089 
0090 /*
0091  * Version Information
0092  */
0093 #define DRIVER_VERSION "v0.7.5 (30/10/2000)"
0094 #define DRIVER_AUTHOR "Henning Zabel <henning@uni-paderborn.de>"
0095 #define DRIVER_DESC "USB Driver for Mustek MDC800 Digital Camera"
0096 
0097 /* Vendor and Product Information */
0098 #define MDC800_VENDOR_ID    0x055f
0099 #define MDC800_PRODUCT_ID   0xa800
0100 
0101 /* Timeouts (msec) */
0102 #define TO_DOWNLOAD_GET_READY       1500
0103 #define TO_DOWNLOAD_GET_BUSY        1500
0104 #define TO_WRITE_GET_READY      1000
0105 #define TO_DEFAULT_COMMAND      5000
0106 #define TO_READ_FROM_IRQ        TO_DEFAULT_COMMAND
0107 #define TO_GET_READY            TO_DEFAULT_COMMAND
0108 
0109 /* Minor Number of the device (create with mknod /dev/mustek c 180 32) */
0110 #define MDC800_DEVICE_MINOR_BASE 32
0111 
0112 
0113 /**************************************************************************
0114     Data and structs
0115 ***************************************************************************/
0116 
0117 
0118 typedef enum {
0119     NOT_CONNECTED, READY, WORKING, DOWNLOAD
0120 } mdc800_state;
0121 
0122 
0123 /* Data for the driver */
0124 struct mdc800_data
0125 {
0126     struct usb_device * dev;            // Device Data
0127     mdc800_state        state;
0128 
0129     unsigned int        endpoint [4];
0130 
0131     struct urb *        irq_urb;
0132     wait_queue_head_t   irq_wait;
0133     int         irq_woken;
0134     char*           irq_urb_buffer;
0135 
0136     int         camera_busy;          // is camera busy ?
0137     int             camera_request_ready; // Status to synchronize with irq
0138     char            camera_response [8];  // last Bytes send after busy
0139 
0140     struct urb *        write_urb;
0141     char*           write_urb_buffer;
0142     wait_queue_head_t   write_wait;
0143     int         written;
0144 
0145 
0146     struct urb *        download_urb;
0147     char*           download_urb_buffer;
0148     wait_queue_head_t   download_wait;
0149     int         downloaded;
0150     int         download_left;      // Bytes left to download ?
0151 
0152 
0153     /* Device Data */
0154     char            out [64];   // Answer Buffer
0155     int             out_ptr;    // Index to the first not readen byte
0156     int         out_count;  // Bytes in the buffer
0157 
0158     int         open;       // Camera device open ?
0159     struct mutex        io_lock;    // IO -lock
0160 
0161     char            in [8];     // Command Input Buffer
0162     int             in_count;
0163 
0164     int         pic_index;  // Cache for the Imagesize (-1 for nothing cached )
0165     int         pic_len;
0166     int         minor;
0167 };
0168 
0169 
0170 /* Specification of the Endpoints */
0171 static struct usb_endpoint_descriptor mdc800_ed [4] =
0172 {
0173     { 
0174         .bLength =      0,
0175         .bDescriptorType =  0,
0176         .bEndpointAddress = 0x01,
0177         .bmAttributes =     0x02,
0178         .wMaxPacketSize =   cpu_to_le16(8),
0179         .bInterval =        0,
0180         .bRefresh =         0,
0181         .bSynchAddress =    0,
0182     },
0183     {
0184         .bLength =      0,
0185         .bDescriptorType =  0,
0186         .bEndpointAddress =     0x82,
0187         .bmAttributes =     0x03,
0188         .wMaxPacketSize =   cpu_to_le16(8),
0189         .bInterval =        0,
0190         .bRefresh =         0,
0191         .bSynchAddress =    0,
0192     },
0193     {
0194         .bLength =      0,
0195         .bDescriptorType =  0,
0196         .bEndpointAddress =     0x03,
0197         .bmAttributes =     0x02,
0198         .wMaxPacketSize =   cpu_to_le16(64),
0199         .bInterval =        0,
0200         .bRefresh =         0,
0201         .bSynchAddress =    0,
0202     },
0203     {
0204         .bLength =      0,
0205         .bDescriptorType =  0,
0206         .bEndpointAddress =     0x84,
0207         .bmAttributes =     0x02,
0208         .wMaxPacketSize =   cpu_to_le16(64),
0209         .bInterval =        0,
0210         .bRefresh =         0,
0211         .bSynchAddress =    0,
0212     },
0213 };
0214 
0215 /* The Variable used by the driver */
0216 static struct mdc800_data* mdc800;
0217 
0218 
0219 /***************************************************************************
0220     The USB Part of the driver
0221 ****************************************************************************/
0222 
0223 static int mdc800_endpoint_equals (struct usb_endpoint_descriptor *a,struct usb_endpoint_descriptor *b)
0224 {
0225     return (
0226            ( a->bEndpointAddress == b->bEndpointAddress )
0227         && ( a->bmAttributes     == b->bmAttributes     )
0228         && ( a->wMaxPacketSize   == b->wMaxPacketSize   )
0229     );
0230 }
0231 
0232 
0233 /*
0234  * Checks whether the camera responds busy
0235  */
0236 static int mdc800_isBusy (char* ch)
0237 {
0238     int i=0;
0239     while (i<8)
0240     {
0241         if (ch [i] != (char)0x99)
0242             return 0;
0243         i++;
0244     }
0245     return 1;
0246 }
0247 
0248 
0249 /*
0250  * Checks whether the Camera is ready
0251  */
0252 static int mdc800_isReady (char *ch)
0253 {
0254     int i=0;
0255     while (i<8)
0256     {
0257         if (ch [i] != (char)0xbb)
0258             return 0;
0259         i++;
0260     }
0261     return 1;
0262 }
0263 
0264 
0265 
0266 /*
0267  * USB IRQ Handler for InputLine
0268  */
0269 static void mdc800_usb_irq (struct urb *urb)
0270 {
0271     int data_received=0, wake_up;
0272     unsigned char* b=urb->transfer_buffer;
0273     struct mdc800_data* mdc800=urb->context;
0274     struct device *dev = &mdc800->dev->dev;
0275     int status = urb->status;
0276 
0277     if (status >= 0) {
0278         if (mdc800_isBusy (b))
0279         {
0280             if (!mdc800->camera_busy)
0281             {
0282                 mdc800->camera_busy=1;
0283                 dev_dbg(dev, "gets busy\n");
0284             }
0285         }
0286         else
0287         {
0288             if (mdc800->camera_busy && mdc800_isReady (b))
0289             {
0290                 mdc800->camera_busy=0;
0291                 dev_dbg(dev, "gets ready\n");
0292             }
0293         }
0294         if (!(mdc800_isBusy (b) || mdc800_isReady (b)))
0295         {
0296             /* Store Data in camera_answer field */
0297             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]);
0298 
0299             memcpy (mdc800->camera_response,b,8);
0300             data_received=1;
0301         }
0302     }
0303     wake_up= ( mdc800->camera_request_ready > 0 )
0304         &&
0305         (
0306             ((mdc800->camera_request_ready == 1) && (!mdc800->camera_busy))
0307         ||
0308             ((mdc800->camera_request_ready == 2) && data_received)
0309         ||
0310             ((mdc800->camera_request_ready == 3) && (mdc800->camera_busy))
0311         ||
0312             (status < 0)
0313         );
0314 
0315     if (wake_up)
0316     {
0317         mdc800->camera_request_ready=0;
0318         mdc800->irq_woken=1;
0319         wake_up (&mdc800->irq_wait);
0320     }
0321 }
0322 
0323 
0324 /*
0325  * Waits a while until the irq responds that camera is ready
0326  *
0327  *  mode : 0: Wait for camera gets ready
0328  *         1: Wait for receiving data
0329  *         2: Wait for camera gets busy
0330  *
0331  * msec: Time to wait
0332  */
0333 static int mdc800_usb_waitForIRQ (int mode, int msec)
0334 {
0335     mdc800->camera_request_ready=1+mode;
0336 
0337     wait_event_timeout(mdc800->irq_wait, mdc800->irq_woken,
0338                msecs_to_jiffies(msec));
0339     mdc800->irq_woken = 0;
0340 
0341     if (mdc800->camera_request_ready>0)
0342     {
0343         mdc800->camera_request_ready=0;
0344         dev_err(&mdc800->dev->dev, "timeout waiting for camera.\n");
0345         return -1;
0346     }
0347     
0348     if (mdc800->state == NOT_CONNECTED)
0349     {
0350         printk(KERN_WARNING "mdc800: Camera gets disconnected "
0351                "during waiting for irq.\n");
0352         mdc800->camera_request_ready=0;
0353         return -2;
0354     }
0355     
0356     return 0;
0357 }
0358 
0359 
0360 /*
0361  * The write_urb callback function
0362  */
0363 static void mdc800_usb_write_notify (struct urb *urb)
0364 {
0365     struct mdc800_data* mdc800=urb->context;
0366     int status = urb->status;
0367 
0368     if (status != 0)
0369         dev_err(&mdc800->dev->dev,
0370             "writing command fails (status=%i)\n", status);
0371     else
0372         mdc800->state=READY;
0373     mdc800->written = 1;
0374     wake_up (&mdc800->write_wait);
0375 }
0376 
0377 
0378 /*
0379  * The download_urb callback function
0380  */
0381 static void mdc800_usb_download_notify (struct urb *urb)
0382 {
0383     struct mdc800_data* mdc800=urb->context;
0384     int status = urb->status;
0385 
0386     if (status == 0) {
0387         /* Fill output buffer with these data */
0388         memcpy (mdc800->out,  urb->transfer_buffer, 64);
0389         mdc800->out_count=64;
0390         mdc800->out_ptr=0;
0391         mdc800->download_left-=64;
0392         if (mdc800->download_left == 0)
0393         {
0394             mdc800->state=READY;
0395         }
0396     } else {
0397         dev_err(&mdc800->dev->dev,
0398             "request bytes fails (status:%i)\n", status);
0399     }
0400     mdc800->downloaded = 1;
0401     wake_up (&mdc800->download_wait);
0402 }
0403 
0404 
0405 /***************************************************************************
0406     Probing for the Camera
0407  ***************************************************************************/
0408 
0409 static struct usb_driver mdc800_usb_driver;
0410 static const struct file_operations mdc800_device_ops;
0411 static struct usb_class_driver mdc800_class = {
0412     .name =     "mdc800%d",
0413     .fops =     &mdc800_device_ops,
0414     .minor_base =   MDC800_DEVICE_MINOR_BASE,
0415 };
0416 
0417 
0418 /*
0419  * Callback to search the Mustek MDC800 on the USB Bus
0420  */
0421 static int mdc800_usb_probe (struct usb_interface *intf,
0422                    const struct usb_device_id *id)
0423 {
0424     int i,j;
0425     struct usb_host_interface *intf_desc;
0426     struct usb_device *dev = interface_to_usbdev (intf);
0427     int irq_interval=0;
0428     int retval;
0429 
0430     dev_dbg(&intf->dev, "(%s) called.\n", __func__);
0431 
0432 
0433     if (mdc800->dev != NULL)
0434     {
0435         dev_warn(&intf->dev, "only one Mustek MDC800 is supported.\n");
0436         return -ENODEV;
0437     }
0438 
0439     if (dev->descriptor.bNumConfigurations != 1)
0440     {
0441         dev_err(&intf->dev,
0442             "probe fails -> wrong Number of Configuration\n");
0443         return -ENODEV;
0444     }
0445     intf_desc = intf->cur_altsetting;
0446 
0447     if (
0448             ( intf_desc->desc.bInterfaceClass != 0xff )
0449         ||  ( intf_desc->desc.bInterfaceSubClass != 0 )
0450         || ( intf_desc->desc.bInterfaceProtocol != 0 )
0451         || ( intf_desc->desc.bNumEndpoints != 4)
0452     )
0453     {
0454         dev_err(&intf->dev, "probe fails -> wrong Interface\n");
0455         return -ENODEV;
0456     }
0457 
0458     /* Check the Endpoints */
0459     for (i=0; i<4; i++)
0460     {
0461         mdc800->endpoint[i]=-1;
0462         for (j=0; j<4; j++)
0463         {
0464             if (mdc800_endpoint_equals (&intf_desc->endpoint [j].desc,&mdc800_ed [i]))
0465             {
0466                 mdc800->endpoint[i]=intf_desc->endpoint [j].desc.bEndpointAddress ;
0467                 if (i==1)
0468                 {
0469                     irq_interval=intf_desc->endpoint [j].desc.bInterval;
0470                 }
0471             }
0472         }
0473         if (mdc800->endpoint[i] == -1)
0474         {
0475             dev_err(&intf->dev, "probe fails -> Wrong Endpoints.\n");
0476             return -ENODEV;
0477         }
0478     }
0479 
0480 
0481     dev_info(&intf->dev, "Found Mustek MDC800 on USB.\n");
0482 
0483     mutex_lock(&mdc800->io_lock);
0484 
0485     retval = usb_register_dev(intf, &mdc800_class);
0486     if (retval) {
0487         dev_err(&intf->dev, "Not able to get a minor for this device.\n");
0488         mutex_unlock(&mdc800->io_lock);
0489         return -ENODEV;
0490     }
0491 
0492     mdc800->dev=dev;
0493     mdc800->open=0;
0494 
0495     /* Setup URB Structs */
0496     usb_fill_int_urb (
0497         mdc800->irq_urb,
0498         mdc800->dev,
0499         usb_rcvintpipe (mdc800->dev,mdc800->endpoint [1]),
0500         mdc800->irq_urb_buffer,
0501         8,
0502         mdc800_usb_irq,
0503         mdc800,
0504         irq_interval
0505     );
0506 
0507     usb_fill_bulk_urb (
0508         mdc800->write_urb,
0509         mdc800->dev,
0510         usb_sndbulkpipe (mdc800->dev, mdc800->endpoint[0]),
0511         mdc800->write_urb_buffer,
0512         8,
0513         mdc800_usb_write_notify,
0514         mdc800
0515     );
0516 
0517     usb_fill_bulk_urb (
0518         mdc800->download_urb,
0519         mdc800->dev,
0520         usb_rcvbulkpipe (mdc800->dev, mdc800->endpoint [3]),
0521         mdc800->download_urb_buffer,
0522         64,
0523         mdc800_usb_download_notify,
0524         mdc800
0525     );
0526 
0527     mdc800->state=READY;
0528 
0529     mutex_unlock(&mdc800->io_lock);
0530     
0531     usb_set_intfdata(intf, mdc800);
0532     return 0;
0533 }
0534 
0535 
0536 /*
0537  * Disconnect USB device (maybe the MDC800)
0538  */
0539 static void mdc800_usb_disconnect (struct usb_interface *intf)
0540 {
0541     struct mdc800_data* mdc800 = usb_get_intfdata(intf);
0542 
0543     dev_dbg(&intf->dev, "(%s) called\n", __func__);
0544 
0545     if (mdc800) {
0546         if (mdc800->state == NOT_CONNECTED)
0547             return;
0548 
0549         usb_deregister_dev(intf, &mdc800_class);
0550 
0551         /* must be under lock to make sure no URB
0552            is submitted after usb_kill_urb() */
0553         mutex_lock(&mdc800->io_lock);
0554         mdc800->state=NOT_CONNECTED;
0555 
0556         usb_kill_urb(mdc800->irq_urb);
0557         usb_kill_urb(mdc800->write_urb);
0558         usb_kill_urb(mdc800->download_urb);
0559         mutex_unlock(&mdc800->io_lock);
0560 
0561         mdc800->dev = NULL;
0562         usb_set_intfdata(intf, NULL);
0563     }
0564     dev_info(&intf->dev, "Mustek MDC800 disconnected from USB.\n");
0565 }
0566 
0567 
0568 /***************************************************************************
0569     The Misc device Part (file_operations)
0570 ****************************************************************************/
0571 
0572 /*
0573  * This Function calc the Answersize for a command.
0574  */
0575 static int mdc800_getAnswerSize (char command)
0576 {
0577     switch ((unsigned char) command)
0578     {
0579         case 0x2a:
0580         case 0x49:
0581         case 0x51:
0582         case 0x0d:
0583         case 0x20:
0584         case 0x07:
0585         case 0x01:
0586         case 0x25:
0587         case 0x00:
0588             return 8;
0589 
0590         case 0x05:
0591         case 0x3e:
0592             return mdc800->pic_len;
0593 
0594         case 0x09:
0595             return 4096;
0596 
0597         default:
0598             return 0;
0599     }
0600 }
0601 
0602 
0603 /*
0604  * Init the device: (1) alloc mem (2) Increase MOD Count ..
0605  */
0606 static int mdc800_device_open (struct inode* inode, struct file *file)
0607 {
0608     int retval=0;
0609     int errn=0;
0610 
0611     mutex_lock(&mdc800->io_lock);
0612     
0613     if (mdc800->state == NOT_CONNECTED)
0614     {
0615         errn=-EBUSY;
0616         goto error_out;
0617     }
0618     if (mdc800->open)
0619     {
0620         errn=-EBUSY;
0621         goto error_out;
0622     }
0623 
0624     mdc800->in_count=0;
0625     mdc800->out_count=0;
0626     mdc800->out_ptr=0;
0627     mdc800->pic_index=0;
0628     mdc800->pic_len=-1;
0629     mdc800->download_left=0;
0630 
0631     mdc800->camera_busy=0;
0632     mdc800->camera_request_ready=0;
0633 
0634     retval=0;
0635     mdc800->irq_urb->dev = mdc800->dev;
0636     retval = usb_submit_urb (mdc800->irq_urb, GFP_KERNEL);
0637     if (retval) {
0638         dev_err(&mdc800->dev->dev,
0639             "request USB irq fails (submit_retval=%i).\n", retval);
0640         errn = -EIO;
0641         goto error_out;
0642     }
0643 
0644     mdc800->open=1;
0645     dev_dbg(&mdc800->dev->dev, "Mustek MDC800 device opened.\n");
0646 
0647 error_out:
0648     mutex_unlock(&mdc800->io_lock);
0649     return errn;
0650 }
0651 
0652 
0653 /*
0654  * Close the Camera and release Memory
0655  */
0656 static int mdc800_device_release (struct inode* inode, struct file *file)
0657 {
0658     int retval=0;
0659 
0660     mutex_lock(&mdc800->io_lock);
0661     if (mdc800->open && (mdc800->state != NOT_CONNECTED))
0662     {
0663         usb_kill_urb(mdc800->irq_urb);
0664         usb_kill_urb(mdc800->write_urb);
0665         usb_kill_urb(mdc800->download_urb);
0666         mdc800->open=0;
0667     }
0668     else
0669     {
0670         retval=-EIO;
0671     }
0672 
0673     mutex_unlock(&mdc800->io_lock);
0674     return retval;
0675 }
0676 
0677 
0678 /*
0679  * The Device read callback Function
0680  */
0681 static ssize_t mdc800_device_read (struct file *file, char __user *buf, size_t len, loff_t *pos)
0682 {
0683     size_t left=len, sts=len; /* single transfer size */
0684     char __user *ptr = buf;
0685     int retval;
0686 
0687     mutex_lock(&mdc800->io_lock);
0688     if (mdc800->state == NOT_CONNECTED)
0689     {
0690         mutex_unlock(&mdc800->io_lock);
0691         return -EBUSY;
0692     }
0693     if (mdc800->state == WORKING)
0694     {
0695         printk(KERN_WARNING "mdc800: Illegal State \"working\""
0696                "reached during read ?!\n");
0697         mutex_unlock(&mdc800->io_lock);
0698         return -EBUSY;
0699     }
0700     if (!mdc800->open)
0701     {
0702         mutex_unlock(&mdc800->io_lock);
0703         return -EBUSY;
0704     }
0705 
0706     while (left)
0707     {
0708         if (signal_pending (current)) 
0709         {
0710             mutex_unlock(&mdc800->io_lock);
0711             return -EINTR;
0712         }
0713 
0714         sts=left > (mdc800->out_count-mdc800->out_ptr)?mdc800->out_count-mdc800->out_ptr:left;
0715 
0716         if (sts <= 0)
0717         {
0718             /* Too less Data in buffer */
0719             if (mdc800->state == DOWNLOAD)
0720             {
0721                 mdc800->out_count=0;
0722                 mdc800->out_ptr=0;
0723 
0724                 /* Download -> Request new bytes */
0725                 mdc800->download_urb->dev = mdc800->dev;
0726                 retval = usb_submit_urb (mdc800->download_urb, GFP_KERNEL);
0727                 if (retval) {
0728                     dev_err(&mdc800->dev->dev,
0729                         "Can't submit download urb "
0730                         "(retval=%i)\n", retval);
0731                     mutex_unlock(&mdc800->io_lock);
0732                     return len-left;
0733                 }
0734                 wait_event_timeout(mdc800->download_wait,
0735                      mdc800->downloaded,
0736                      msecs_to_jiffies(TO_DOWNLOAD_GET_READY));
0737                 mdc800->downloaded = 0;
0738                 if (mdc800->download_urb->status != 0)
0739                 {
0740                     dev_err(&mdc800->dev->dev,
0741                         "request download-bytes fails "
0742                         "(status=%i)\n",
0743                         mdc800->download_urb->status);
0744                     mutex_unlock(&mdc800->io_lock);
0745                     return len-left;
0746                 }
0747             }
0748             else
0749             {
0750                 /* No more bytes -> that's an error*/
0751                 mutex_unlock(&mdc800->io_lock);
0752                 return -EIO;
0753             }
0754         }
0755         else
0756         {
0757             /* Copy Bytes */
0758             if (copy_to_user(ptr, &mdc800->out [mdc800->out_ptr],
0759                         sts)) {
0760                 mutex_unlock(&mdc800->io_lock);
0761                 return -EFAULT;
0762             }
0763             ptr+=sts;
0764             left-=sts;
0765             mdc800->out_ptr+=sts;
0766         }
0767     }
0768 
0769     mutex_unlock(&mdc800->io_lock);
0770     return len-left;
0771 }
0772 
0773 
0774 /*
0775  * The Device write callback Function
0776  * If a 8Byte Command is received, it will be send to the camera.
0777  * After this the driver initiates the request for the answer or
0778  * just waits until the camera becomes ready.
0779  */
0780 static ssize_t mdc800_device_write (struct file *file, const char __user *buf, size_t len, loff_t *pos)
0781 {
0782     size_t i=0;
0783     int retval;
0784 
0785     mutex_lock(&mdc800->io_lock);
0786     if (mdc800->state != READY)
0787     {
0788         mutex_unlock(&mdc800->io_lock);
0789         return -EBUSY;
0790     }
0791     if (!mdc800->open )
0792     {
0793         mutex_unlock(&mdc800->io_lock);
0794         return -EBUSY;
0795     }
0796 
0797     while (i<len)
0798     {
0799         unsigned char c;
0800         if (signal_pending (current)) 
0801         {
0802             mutex_unlock(&mdc800->io_lock);
0803             return -EINTR;
0804         }
0805         
0806         if(get_user(c, buf+i))
0807         {
0808             mutex_unlock(&mdc800->io_lock);
0809             return -EFAULT;
0810         }
0811 
0812         /* check for command start */
0813         if (c == 0x55)
0814         {
0815             mdc800->in_count=0;
0816             mdc800->out_count=0;
0817             mdc800->out_ptr=0;
0818             mdc800->download_left=0;
0819         }
0820 
0821         /* save command byte */
0822         if (mdc800->in_count < 8)
0823         {
0824             mdc800->in[mdc800->in_count] = c;
0825             mdc800->in_count++;
0826         }
0827         else
0828         {
0829             mutex_unlock(&mdc800->io_lock);
0830             return -EIO;
0831         }
0832 
0833         /* Command Buffer full ? -> send it to camera */
0834         if (mdc800->in_count == 8)
0835         {
0836             int answersize;
0837 
0838             if (mdc800_usb_waitForIRQ (0,TO_GET_READY))
0839             {
0840                 dev_err(&mdc800->dev->dev,
0841                     "Camera didn't get ready.\n");
0842                 mutex_unlock(&mdc800->io_lock);
0843                 return -EIO;
0844             }
0845 
0846             answersize=mdc800_getAnswerSize (mdc800->in[1]);
0847 
0848             mdc800->state=WORKING;
0849             memcpy (mdc800->write_urb->transfer_buffer, mdc800->in,8);
0850             mdc800->write_urb->dev = mdc800->dev;
0851             retval = usb_submit_urb (mdc800->write_urb, GFP_KERNEL);
0852             if (retval) {
0853                 dev_err(&mdc800->dev->dev,
0854                     "submitting write urb fails "
0855                     "(retval=%i)\n", retval);
0856                 mutex_unlock(&mdc800->io_lock);
0857                 return -EIO;
0858             }
0859             wait_event_timeout(mdc800->write_wait, mdc800->written,
0860                     msecs_to_jiffies(TO_WRITE_GET_READY));
0861             mdc800->written = 0;
0862             if (mdc800->state == WORKING)
0863             {
0864                 usb_kill_urb(mdc800->write_urb);
0865                 mutex_unlock(&mdc800->io_lock);
0866                 return -EIO;
0867             }
0868 
0869             switch ((unsigned char) mdc800->in[1])
0870             {
0871                 case 0x05: /* Download Image */
0872                 case 0x3e: /* Take shot in Fine Mode (WCam Mode) */
0873                     if (mdc800->pic_len < 0)
0874                     {
0875                         dev_err(&mdc800->dev->dev,
0876                             "call 0x07 before "
0877                             "0x05,0x3e\n");
0878                         mdc800->state=READY;
0879                         mutex_unlock(&mdc800->io_lock);
0880                         return -EIO;
0881                     }
0882                     mdc800->pic_len=-1;
0883                     fallthrough;
0884 
0885                 case 0x09: /* Download Thumbnail */
0886                     mdc800->download_left=answersize+64;
0887                     mdc800->state=DOWNLOAD;
0888                     mdc800_usb_waitForIRQ (0,TO_DOWNLOAD_GET_BUSY);
0889                     break;
0890 
0891 
0892                 default:
0893                     if (answersize)
0894                     {
0895 
0896                         if (mdc800_usb_waitForIRQ (1,TO_READ_FROM_IRQ))
0897                         {
0898                             dev_err(&mdc800->dev->dev, "requesting answer from irq fails\n");
0899                             mutex_unlock(&mdc800->io_lock);
0900                             return -EIO;
0901                         }
0902 
0903                         /* Write dummy data, (this is ugly but part of the USB Protocol */
0904                         /* if you use endpoint 1 as bulk and not as irq) */
0905                         memcpy (mdc800->out, mdc800->camera_response,8);
0906 
0907                         /* This is the interpreted answer */
0908                         memcpy (&mdc800->out[8], mdc800->camera_response,8);
0909 
0910                         mdc800->out_ptr=0;
0911                         mdc800->out_count=16;
0912 
0913                         /* Cache the Imagesize, if command was getImageSize */
0914                         if (mdc800->in [1] == (char) 0x07)
0915                         {
0916                             mdc800->pic_len=(int) 65536*(unsigned char) mdc800->camera_response[0]+256*(unsigned char) mdc800->camera_response[1]+(unsigned char) mdc800->camera_response[2];
0917 
0918                             dev_dbg(&mdc800->dev->dev, "cached imagesize = %i\n", mdc800->pic_len);
0919                         }
0920 
0921                     }
0922                     else
0923                     {
0924                         if (mdc800_usb_waitForIRQ (0,TO_DEFAULT_COMMAND))
0925                         {
0926                             dev_err(&mdc800->dev->dev, "Command Timeout.\n");
0927                             mutex_unlock(&mdc800->io_lock);
0928                             return -EIO;
0929                         }
0930                     }
0931                     mdc800->state=READY;
0932                     break;
0933             }
0934         }
0935         i++;
0936     }
0937     mutex_unlock(&mdc800->io_lock);
0938     return i;
0939 }
0940 
0941 
0942 /***************************************************************************
0943     Init and Cleanup this driver (Structs and types)
0944 ****************************************************************************/
0945 
0946 /* File Operations of this drivers */
0947 static const struct file_operations mdc800_device_ops =
0948 {
0949     .owner =    THIS_MODULE,
0950     .read =     mdc800_device_read,
0951     .write =    mdc800_device_write,
0952     .open =     mdc800_device_open,
0953     .release =  mdc800_device_release,
0954     .llseek =   noop_llseek,
0955 };
0956 
0957 
0958 
0959 static const struct usb_device_id mdc800_table[] = {
0960     { USB_DEVICE(MDC800_VENDOR_ID, MDC800_PRODUCT_ID) },
0961     { }                     /* Terminating entry */
0962 };
0963 
0964 MODULE_DEVICE_TABLE (usb, mdc800_table);
0965 /*
0966  * USB Driver Struct for this device
0967  */
0968 static struct usb_driver mdc800_usb_driver =
0969 {
0970     .name =     "mdc800",
0971     .probe =    mdc800_usb_probe,
0972     .disconnect =   mdc800_usb_disconnect,
0973     .id_table = mdc800_table
0974 };
0975 
0976 
0977 
0978 /************************************************************************
0979     Init and Cleanup this driver (Main Functions)
0980 *************************************************************************/
0981 
0982 static int __init usb_mdc800_init (void)
0983 {
0984     int retval = -ENODEV;
0985     /* Allocate Memory */
0986     mdc800=kzalloc (sizeof (struct mdc800_data), GFP_KERNEL);
0987     if (!mdc800)
0988         goto cleanup_on_fail;
0989 
0990     mdc800->dev = NULL;
0991     mdc800->state=NOT_CONNECTED;
0992     mutex_init (&mdc800->io_lock);
0993 
0994     init_waitqueue_head (&mdc800->irq_wait);
0995     init_waitqueue_head (&mdc800->write_wait);
0996     init_waitqueue_head (&mdc800->download_wait);
0997 
0998     mdc800->irq_woken = 0;
0999     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
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!