Logo Search packages:      
Sourcecode: linux version File versions  Download package

mdc800.c

/*
 * copyright (C) 1999/2000 by Henning Zabel <henning@uni-paderborn.de>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */


/*
 *    USB-Kernel Driver for the Mustek MDC800 Digital Camera
 *    (c) 1999/2000 Henning Zabel <henning@uni-paderborn.de>
 *
 *
 * The driver brings the USB functions of the MDC800 to Linux.
 * To use the Camera you must support the USB Protocol of the camera
 * to the Kernel Node.
 * The Driver uses a misc device Node. Create it with :
 * mknod /dev/mustek c 180 32
 *
 * The driver supports only one camera.
 * 
 * Fix: mdc800 used sleep_on and slept with io_lock held.
 * Converted sleep_on to waitqueues with schedule_timeout and made io_lock
 * a semaphore from a spinlock.
 * by Oliver Neukum <oliver@neukum.name>
 * (02/12/2001)
 * 
 * Identify version on module load.
 * (08/04/2001) gb
 *
 * version 0.7.5
 * Fixed potential SMP races with Spinlocks.
 * Thanks to Oliver Neukum <oliver@neukum.name> who 
 * noticed the race conditions.
 * (30/10/2000)
 *
 * Fixed: Setting urb->dev before submitting urb.
 * by Greg KH <greg@kroah.com>
 * (13/10/2000)
 *
 * version 0.7.3
 * bugfix : The mdc800->state field gets set to READY after the
 * the diconnect function sets it to NOT_CONNECTED. This makes the
 * driver running like the camera is connected and causes some
 * hang ups.
 *
 * version 0.7.1
 * MOD_INC and MOD_DEC are changed in usb_probe to prevent load/unload
 * problems when compiled as Module.
 * (04/04/2000)
 *
 * The mdc800 driver gets assigned the USB Minor 32-47. The Registration
 * was updated to use these values.
 * (26/03/2000)
 *
 * The Init und Exit Module Function are updated.
 * (01/03/2000)
 *
 * version 0.7.0
 * Rewrite of the driver : The driver now uses URB's. The old stuff
 * has been removed.
 *
 * version 0.6.0
 * Rewrite of this driver: The Emulation of the rs232 protocoll
 * has been removed from the driver. A special executeCommand function
 * for this driver is included to gphoto.
 * The driver supports two kind of communication to bulk endpoints.
 * Either with the dev->bus->ops->bulk... or with callback function.
 * (09/11/1999)
 *
 * version 0.5.0:
 * first Version that gets a version number. Most of the needed
 * functions work.
 * (20/10/1999)
 */

#include <linux/sched.h>
#include <linux/signal.h>
#include <linux/spinlock.h>
#include <linux/errno.h>
#include <linux/random.h>
#include <linux/poll.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/wait.h>
#include <linux/mutex.h>

#include <linux/usb.h>
#include <linux/fs.h>

/*
 * Version Information
 */
#define DRIVER_VERSION "v0.7.5 (30/10/2000)"
#define DRIVER_AUTHOR "Henning Zabel <henning@uni-paderborn.de>"
#define DRIVER_DESC "USB Driver for Mustek MDC800 Digital Camera"

/* Vendor and Product Information */
#define MDC800_VENDOR_ID      0x055f
#define MDC800_PRODUCT_ID     0xa800

/* Timeouts (msec) */
#define TO_DOWNLOAD_GET_READY       1500
#define TO_DOWNLOAD_GET_BUSY        1500
#define TO_WRITE_GET_READY          1000
#define TO_DEFAULT_COMMAND          5000
#define TO_READ_FROM_IRQ            TO_DEFAULT_COMMAND
#define TO_GET_READY                TO_DEFAULT_COMMAND

/* Minor Number of the device (create with mknod /dev/mustek c 180 32) */
#define MDC800_DEVICE_MINOR_BASE 32


/**************************************************************************
      Data and structs
***************************************************************************/


typedef enum {
      NOT_CONNECTED, READY, WORKING, DOWNLOAD
} mdc800_state;


/* Data for the driver */
struct mdc800_data
{
      struct usb_device *     dev;              // Device Data
      mdc800_state            state;

      unsigned int            endpoint [4];

      struct urb *            irq_urb;
      wait_queue_head_t irq_wait;
      int               irq_woken;
      char*             irq_urb_buffer;

      int               camera_busy;          // is camera busy ?
      int               camera_request_ready; // Status to synchronize with irq
      char              camera_response [8];  // last Bytes send after busy

      struct urb *            write_urb;
      char*             write_urb_buffer;
      wait_queue_head_t write_wait;
      int               written;


      struct urb *            download_urb;
      char*             download_urb_buffer;
      wait_queue_head_t download_wait;
      int               downloaded;
      int               download_left;          // Bytes left to download ?


      /* Device Data */
      char              out [64];   // Answer Buffer
      int               out_ptr;    // Index to the first not readen byte
      int               out_count;  // Bytes in the buffer

      int               open;       // Camera device open ?
      struct mutex            io_lock;    // IO -lock

      char              in [8];           // Command Input Buffer
      int               in_count;

      int               pic_index;  // Cache for the Imagesize (-1 for nothing cached )
      int               pic_len;
      int               minor;
};


/* Specification of the Endpoints */
static struct usb_endpoint_descriptor mdc800_ed [4] =
{
      { 
            .bLength =        0,
            .bDescriptorType =      0,
            .bEndpointAddress =     0x01,
            .bmAttributes =   0x02,
            .wMaxPacketSize = __constant_cpu_to_le16(8),
            .bInterval =            0,
            .bRefresh =             0,
            .bSynchAddress =  0,
      },
      {
            .bLength =        0,
            .bDescriptorType =      0,
            .bEndpointAddress =     0x82,
            .bmAttributes =   0x03,
            .wMaxPacketSize =       __constant_cpu_to_le16(8),
            .bInterval =            0,
            .bRefresh =             0,
            .bSynchAddress =  0,
      },
      {
            .bLength =        0,
            .bDescriptorType =      0,
            .bEndpointAddress =     0x03,
            .bmAttributes =   0x02,
            .wMaxPacketSize =       __constant_cpu_to_le16(64),
            .bInterval =            0,
            .bRefresh =             0,
            .bSynchAddress =  0,
      },
      {
            .bLength =        0,
            .bDescriptorType =      0,
            .bEndpointAddress =     0x84,
            .bmAttributes =   0x02,
            .wMaxPacketSize =       __constant_cpu_to_le16(64),
            .bInterval =            0,
            .bRefresh =             0,
            .bSynchAddress =  0,
      },
};

/* The Variable used by the driver */
static struct mdc800_data* mdc800;


/***************************************************************************
      The USB Part of the driver
****************************************************************************/

static int mdc800_endpoint_equals (struct usb_endpoint_descriptor *a,struct usb_endpoint_descriptor *b)
{
      return (
               ( a->bEndpointAddress == b->bEndpointAddress )
            && ( a->bmAttributes     == b->bmAttributes     )
            && ( a->wMaxPacketSize   == b->wMaxPacketSize   )
      );
}


/*
 * Checks whether the camera responds busy
 */
static int mdc800_isBusy (char* ch)
{
      int i=0;
      while (i<8)
      {
            if (ch [i] != (char)0x99)
                  return 0;
            i++;
      }
      return 1;
}


/*
 * Checks whether the Camera is ready
 */
static int mdc800_isReady (char *ch)
{
      int i=0;
      while (i<8)
      {
            if (ch [i] != (char)0xbb)
                  return 0;
            i++;
      }
      return 1;
}



/*
 * USB IRQ Handler for InputLine
 */
static void mdc800_usb_irq (struct urb *urb)
{
      int data_received=0, wake_up;
      unsigned char* b=urb->transfer_buffer;
      struct mdc800_data* mdc800=urb->context;
      int status = urb->status;

      if (status >= 0) {

            //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]);

            if (mdc800_isBusy (b))
            {
                  if (!mdc800->camera_busy)
                  {
                        mdc800->camera_busy=1;
                        dbg ("gets busy");
                  }
            }
            else
            {
                  if (mdc800->camera_busy && mdc800_isReady (b))
                  {
                        mdc800->camera_busy=0;
                        dbg ("gets ready");
                  }
            }
            if (!(mdc800_isBusy (b) || mdc800_isReady (b)))
            {
                  /* Store Data in camera_answer field */
                  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]);

                  memcpy (mdc800->camera_response,b,8);
                  data_received=1;
            }
      }
      wake_up= ( mdc800->camera_request_ready > 0 )
            &&
            (
                  ((mdc800->camera_request_ready == 1) && (!mdc800->camera_busy))
            ||
                  ((mdc800->camera_request_ready == 2) && data_received)
            ||
                  ((mdc800->camera_request_ready == 3) && (mdc800->camera_busy))
            ||
                  (status < 0)
            );

      if (wake_up)
      {
            mdc800->camera_request_ready=0;
            mdc800->irq_woken=1;
            wake_up (&mdc800->irq_wait);
      }
}


/*
 * Waits a while until the irq responds that camera is ready
 *
 *  mode : 0: Wait for camera gets ready
 *         1: Wait for receiving data
 *         2: Wait for camera gets busy
 *
 * msec: Time to wait
 */
static int mdc800_usb_waitForIRQ (int mode, int msec)
{
      mdc800->camera_request_ready=1+mode;

      wait_event_timeout(mdc800->irq_wait, mdc800->irq_woken, msec*HZ/1000);
      mdc800->irq_woken = 0;

      if (mdc800->camera_request_ready>0)
      {
            mdc800->camera_request_ready=0;
            err ("timeout waiting for camera.");
            return -1;
      }
      
      if (mdc800->state == NOT_CONNECTED)
      {
            warn ("Camera gets disconnected during waiting for irq.");
            mdc800->camera_request_ready=0;
            return -2;
      }
      
      return 0;
}


/*
 * The write_urb callback function
 */
static void mdc800_usb_write_notify (struct urb *urb)
{
      struct mdc800_data* mdc800=urb->context;
      int status = urb->status;

      if (status != 0)
            err ("writing command fails (status=%i)", status);
      else
            mdc800->state=READY;
      mdc800->written = 1;
      wake_up (&mdc800->write_wait);
}


/*
 * The download_urb callback function
 */
static void mdc800_usb_download_notify (struct urb *urb)
{
      struct mdc800_data* mdc800=urb->context;
      int status = urb->status;

      if (status == 0) {
            /* Fill output buffer with these data */
            memcpy (mdc800->out,  urb->transfer_buffer, 64);
            mdc800->out_count=64;
            mdc800->out_ptr=0;
            mdc800->download_left-=64;
            if (mdc800->download_left == 0)
            {
                  mdc800->state=READY;
            }
      } else {
            err ("request bytes fails (status:%i)", status);
      }
      mdc800->downloaded = 1;
      wake_up (&mdc800->download_wait);
}


/***************************************************************************
      Probing for the Camera
 ***************************************************************************/

static struct usb_driver mdc800_usb_driver;
static const struct file_operations mdc800_device_ops;
static struct usb_class_driver mdc800_class = {
      .name =           "mdc800%d",
      .fops =           &mdc800_device_ops,
      .minor_base =     MDC800_DEVICE_MINOR_BASE,
};


/*
 * Callback to search the Mustek MDC800 on the USB Bus
 */
static int mdc800_usb_probe (struct usb_interface *intf,
                         const struct usb_device_id *id)
{
      int i,j;
      struct usb_host_interface *intf_desc;
      struct usb_device *dev = interface_to_usbdev (intf);
      int irq_interval=0;
      int retval;

      dbg ("(mdc800_usb_probe) called.");


      if (mdc800->dev != NULL)
      {
            warn ("only one Mustek MDC800 is supported.");
            return -ENODEV;
      }

      if (dev->descriptor.bNumConfigurations != 1)
      {
            err ("probe fails -> wrong Number of Configuration");
            return -ENODEV;
      }
      intf_desc = intf->cur_altsetting;

      if (
                  ( intf_desc->desc.bInterfaceClass != 0xff )
            ||    ( intf_desc->desc.bInterfaceSubClass != 0 )
            || ( intf_desc->desc.bInterfaceProtocol != 0 )
            || ( intf_desc->desc.bNumEndpoints != 4)
      )
      {
            err ("probe fails -> wrong Interface");
            return -ENODEV;
      }

      /* Check the Endpoints */
      for (i=0; i<4; i++)
      {
            mdc800->endpoint[i]=-1;
            for (j=0; j<4; j++)
            {
                  if (mdc800_endpoint_equals (&intf_desc->endpoint [j].desc,&mdc800_ed [i]))
                  {
                        mdc800->endpoint[i]=intf_desc->endpoint [j].desc.bEndpointAddress ;
                        if (i==1)
                        {
                              irq_interval=intf_desc->endpoint [j].desc.bInterval;
                        }

                        continue;
                  }
            }
            if (mdc800->endpoint[i] == -1)
            {
                  err ("probe fails -> Wrong Endpoints.");
                  return -ENODEV;
            }
      }


      info ("Found Mustek MDC800 on USB.");

      mutex_lock(&mdc800->io_lock);

      retval = usb_register_dev(intf, &mdc800_class);
      if (retval) {
            err ("Not able to get a minor for this device.");
            return -ENODEV;
      }

      mdc800->dev=dev;
      mdc800->open=0;

      /* Setup URB Structs */
      usb_fill_int_urb (
            mdc800->irq_urb,
            mdc800->dev,
            usb_rcvintpipe (mdc800->dev,mdc800->endpoint [1]),
            mdc800->irq_urb_buffer,
            8,
            mdc800_usb_irq,
            mdc800,
            irq_interval
      );

      usb_fill_bulk_urb (
            mdc800->write_urb,
            mdc800->dev,
            usb_sndbulkpipe (mdc800->dev, mdc800->endpoint[0]),
            mdc800->write_urb_buffer,
            8,
            mdc800_usb_write_notify,
            mdc800
      );

      usb_fill_bulk_urb (
            mdc800->download_urb,
            mdc800->dev,
            usb_rcvbulkpipe (mdc800->dev, mdc800->endpoint [3]),
            mdc800->download_urb_buffer,
            64,
            mdc800_usb_download_notify,
            mdc800
      );

      mdc800->state=READY;

      mutex_unlock(&mdc800->io_lock);
      
      usb_set_intfdata(intf, mdc800);
      return 0;
}


/*
 * Disconnect USB device (maybe the MDC800)
 */
static void mdc800_usb_disconnect (struct usb_interface *intf)
{
      struct mdc800_data* mdc800 = usb_get_intfdata(intf);

      dbg ("(mdc800_usb_disconnect) called");

      if (mdc800) {
            if (mdc800->state == NOT_CONNECTED)
                  return;

            usb_deregister_dev(intf, &mdc800_class);

            /* must be under lock to make sure no URB
               is submitted after usb_kill_urb() */
            mutex_lock(&mdc800->io_lock);
            mdc800->state=NOT_CONNECTED;

            usb_kill_urb(mdc800->irq_urb);
            usb_kill_urb(mdc800->write_urb);
            usb_kill_urb(mdc800->download_urb);
            mutex_unlock(&mdc800->io_lock);

            mdc800->dev = NULL;
            usb_set_intfdata(intf, NULL);
      }
      info ("Mustek MDC800 disconnected from USB.");
}


/***************************************************************************
      The Misc device Part (file_operations)
****************************************************************************/

/*
 * This Function calc the Answersize for a command.
 */
static int mdc800_getAnswerSize (char command)
{
      switch ((unsigned char) command)
      {
            case 0x2a:
            case 0x49:
            case 0x51:
            case 0x0d:
            case 0x20:
            case 0x07:
            case 0x01:
            case 0x25:
            case 0x00:
                  return 8;

            case 0x05:
            case 0x3e:
                  return mdc800->pic_len;

            case 0x09:
                  return 4096;

            default:
                  return 0;
      }
}


/*
 * Init the device: (1) alloc mem (2) Increase MOD Count ..
 */
static int mdc800_device_open (struct inode* inode, struct file *file)
{
      int retval=0;
      int errn=0;

      mutex_lock(&mdc800->io_lock);
      
      if (mdc800->state == NOT_CONNECTED)
      {
            errn=-EBUSY;
            goto error_out;
      }
      if (mdc800->open)
      {
            errn=-EBUSY;
            goto error_out;
      }

      mdc800->in_count=0;
      mdc800->out_count=0;
      mdc800->out_ptr=0;
      mdc800->pic_index=0;
      mdc800->pic_len=-1;
      mdc800->download_left=0;

      mdc800->camera_busy=0;
      mdc800->camera_request_ready=0;

      retval=0;
      mdc800->irq_urb->dev = mdc800->dev;
      retval = usb_submit_urb (mdc800->irq_urb, GFP_KERNEL);
      if (retval) {
            err ("request USB irq fails (submit_retval=%i).", retval);
            errn = -EIO;
            goto error_out;
      }

      mdc800->open=1;
      dbg ("Mustek MDC800 device opened.");

error_out:
      mutex_unlock(&mdc800->io_lock);
      return errn;
}


/*
 * Close the Camera and release Memory
 */
static int mdc800_device_release (struct inode* inode, struct file *file)
{
      int retval=0;
      dbg ("Mustek MDC800 device closed.");

      mutex_lock(&mdc800->io_lock);
      if (mdc800->open && (mdc800->state != NOT_CONNECTED))
      {
            usb_kill_urb(mdc800->irq_urb);
            usb_kill_urb(mdc800->write_urb);
            usb_kill_urb(mdc800->download_urb);
            mdc800->open=0;
      }
      else
      {
            retval=-EIO;
      }

      mutex_unlock(&mdc800->io_lock);
      return retval;
}


/*
 * The Device read callback Function
 */
static ssize_t mdc800_device_read (struct file *file, char __user *buf, size_t len, loff_t *pos)
{
      size_t left=len, sts=len; /* single transfer size */
      char __user *ptr = buf;
      int retval;

      mutex_lock(&mdc800->io_lock);
      if (mdc800->state == NOT_CONNECTED)
      {
            mutex_unlock(&mdc800->io_lock);
            return -EBUSY;
      }
      if (mdc800->state == WORKING)
      {
            warn ("Illegal State \"working\" reached during read ?!");
            mutex_unlock(&mdc800->io_lock);
            return -EBUSY;
      }
      if (!mdc800->open)
      {
            mutex_unlock(&mdc800->io_lock);
            return -EBUSY;
      }

      while (left)
      {
            if (signal_pending (current)) 
            {
                  mutex_unlock(&mdc800->io_lock);
                  return -EINTR;
            }

            sts=left > (mdc800->out_count-mdc800->out_ptr)?mdc800->out_count-mdc800->out_ptr:left;

            if (sts <= 0)
            {
                  /* Too less Data in buffer */
                  if (mdc800->state == DOWNLOAD)
                  {
                        mdc800->out_count=0;
                        mdc800->out_ptr=0;

                        /* Download -> Request new bytes */
                        mdc800->download_urb->dev = mdc800->dev;
                        retval = usb_submit_urb (mdc800->download_urb, GFP_KERNEL);
                        if (retval) {
                              err ("Can't submit download urb (retval=%i)",retval);
                              mutex_unlock(&mdc800->io_lock);
                              return len-left;
                        }
                        wait_event_timeout(mdc800->download_wait, mdc800->downloaded,
                                                            TO_DOWNLOAD_GET_READY*HZ/1000);
                        mdc800->downloaded = 0;
                        if (mdc800->download_urb->status != 0)
                        {
                              err ("request download-bytes fails (status=%i)",mdc800->download_urb->status);
                              mutex_unlock(&mdc800->io_lock);
                              return len-left;
                        }
                  }
                  else
                  {
                        /* No more bytes -> that's an error*/
                        mutex_unlock(&mdc800->io_lock);
                        return -EIO;
                  }
            }
            else
            {
                  /* Copy Bytes */
                  if (copy_to_user(ptr, &mdc800->out [mdc800->out_ptr],
                                    sts)) {
                        mutex_unlock(&mdc800->io_lock);
                        return -EFAULT;
                  }
                  ptr+=sts;
                  left-=sts;
                  mdc800->out_ptr+=sts;
            }
      }

      mutex_unlock(&mdc800->io_lock);
      return len-left;
}


/*
 * The Device write callback Function
 * If a 8Byte Command is received, it will be send to the camera.
 * After this the driver initiates the request for the answer or
 * just waits until the camera becomes ready.
 */
static ssize_t mdc800_device_write (struct file *file, const char __user *buf, size_t len, loff_t *pos)
{
      size_t i=0;
      int retval;

      mutex_lock(&mdc800->io_lock);
      if (mdc800->state != READY)
      {
            mutex_unlock(&mdc800->io_lock);
            return -EBUSY;
      }
      if (!mdc800->open )
      {
            mutex_unlock(&mdc800->io_lock);
            return -EBUSY;
      }

      while (i<len)
      {
            unsigned char c;
            if (signal_pending (current)) 
            {
                  mutex_unlock(&mdc800->io_lock);
                  return -EINTR;
            }
            
            if(get_user(c, buf+i))
            {
                  mutex_unlock(&mdc800->io_lock);
                  return -EFAULT;
            }

            /* check for command start */
            if (c == 0x55)
            {
                  mdc800->in_count=0;
                  mdc800->out_count=0;
                  mdc800->out_ptr=0;
                  mdc800->download_left=0;
            }

            /* save command byte */
            if (mdc800->in_count < 8)
            {
                  mdc800->in[mdc800->in_count] = c;
                  mdc800->in_count++;
            }
            else
            {
                  mutex_unlock(&mdc800->io_lock);
                  return -EIO;
            }

            /* Command Buffer full ? -> send it to camera */
            if (mdc800->in_count == 8)
            {
                  int answersize;

                  if (mdc800_usb_waitForIRQ (0,TO_GET_READY))
                  {
                        err ("Camera didn't get ready.\n");
                        mutex_unlock(&mdc800->io_lock);
                        return -EIO;
                  }

                  answersize=mdc800_getAnswerSize (mdc800->in[1]);

                  mdc800->state=WORKING;
                  memcpy (mdc800->write_urb->transfer_buffer, mdc800->in,8);
                  mdc800->write_urb->dev = mdc800->dev;
                  retval = usb_submit_urb (mdc800->write_urb, GFP_KERNEL);
                  if (retval) {
                        err ("submitting write urb fails (retval=%i)", retval);
                        mutex_unlock(&mdc800->io_lock);
                        return -EIO;
                  }
                  wait_event_timeout(mdc800->write_wait, mdc800->written, TO_WRITE_GET_READY*HZ/1000);
                  mdc800->written = 0;
                  if (mdc800->state == WORKING)
                  {
                        usb_kill_urb(mdc800->write_urb);
                        mutex_unlock(&mdc800->io_lock);
                        return -EIO;
                  }

                  switch ((unsigned char) mdc800->in[1])
                  {
                        case 0x05: /* Download Image */
                        case 0x3e: /* Take shot in Fine Mode (WCam Mode) */
                              if (mdc800->pic_len < 0)
                              {
                                    err ("call 0x07 before 0x05,0x3e");
                                    mdc800->state=READY;
                                    mutex_unlock(&mdc800->io_lock);
                                    return -EIO;
                              }
                              mdc800->pic_len=-1;

                        case 0x09: /* Download Thumbnail */
                              mdc800->download_left=answersize+64;
                              mdc800->state=DOWNLOAD;
                              mdc800_usb_waitForIRQ (0,TO_DOWNLOAD_GET_BUSY);
                              break;


                        default:
                              if (answersize)
                              {

                                    if (mdc800_usb_waitForIRQ (1,TO_READ_FROM_IRQ))
                                    {
                                          err ("requesting answer from irq fails");
                                          mutex_unlock(&mdc800->io_lock);
                                          return -EIO;
                                    }

                                    /* Write dummy data, (this is ugly but part of the USB Protocol */
                                    /* if you use endpoint 1 as bulk and not as irq) */
                                    memcpy (mdc800->out, mdc800->camera_response,8);

                                    /* This is the interpreted answer */
                                    memcpy (&mdc800->out[8], mdc800->camera_response,8);

                                    mdc800->out_ptr=0;
                                    mdc800->out_count=16;

                                    /* Cache the Imagesize, if command was getImageSize */
                                    if (mdc800->in [1] == (char) 0x07)
                                    {
                                          mdc800->pic_len=(int) 65536*(unsigned char) mdc800->camera_response[0]+256*(unsigned char) mdc800->camera_response[1]+(unsigned char) mdc800->camera_response[2];

                                          dbg ("cached imagesize = %i",mdc800->pic_len);
                                    }

                              }
                              else
                              {
                                    if (mdc800_usb_waitForIRQ (0,TO_DEFAULT_COMMAND))
                                    {
                                          err ("Command Timeout.");
                                          mutex_unlock(&mdc800->io_lock);
                                          return -EIO;
                                    }
                              }
                              mdc800->state=READY;
                              break;
                  }
            }
            i++;
      }
      mutex_unlock(&mdc800->io_lock);
      return i;
}


/***************************************************************************
      Init and Cleanup this driver (Structs and types)
****************************************************************************/

/* File Operations of this drivers */
static const struct file_operations mdc800_device_ops =
{
      .owner =    THIS_MODULE,
      .read =           mdc800_device_read,
      .write =    mdc800_device_write,
      .open =           mdc800_device_open,
      .release =  mdc800_device_release,
};



static struct usb_device_id mdc800_table [] = {
      { USB_DEVICE(MDC800_VENDOR_ID, MDC800_PRODUCT_ID) },
      { }                                 /* Terminating entry */
};

MODULE_DEVICE_TABLE (usb, mdc800_table);
/*
 * USB Driver Struct for this device
 */
static struct usb_driver mdc800_usb_driver =
{
      .name =           "mdc800",
      .probe =    mdc800_usb_probe,
      .disconnect =     mdc800_usb_disconnect,
      .id_table = mdc800_table
};



/************************************************************************
      Init and Cleanup this driver (Main Functions)
*************************************************************************/

static int __init usb_mdc800_init (void)
{
      int retval = -ENODEV;
      /* Allocate Memory */
      mdc800=kzalloc (sizeof (struct mdc800_data), GFP_KERNEL);
      if (!mdc800)
            goto cleanup_on_fail;

      mdc800->dev = NULL;
      mdc800->state=NOT_CONNECTED;
      mutex_init (&mdc800->io_lock);

      init_waitqueue_head (&mdc800->irq_wait);
      init_waitqueue_head (&mdc800->write_wait);
      init_waitqueue_head (&mdc800->download_wait);

      mdc800->irq_woken = 0;
      mdc800->downloaded = 0;
      mdc800->written = 0;

      mdc800->irq_urb_buffer=kmalloc (8, GFP_KERNEL);
      if (!mdc800->irq_urb_buffer)
            goto cleanup_on_fail;
      mdc800->write_urb_buffer=kmalloc (8, GFP_KERNEL);
      if (!mdc800->write_urb_buffer)
            goto cleanup_on_fail;
      mdc800->download_urb_buffer=kmalloc (64, GFP_KERNEL);
      if (!mdc800->download_urb_buffer)
            goto cleanup_on_fail;

      mdc800->irq_urb=usb_alloc_urb (0, GFP_KERNEL);
      if (!mdc800->irq_urb)
            goto cleanup_on_fail;
      mdc800->download_urb=usb_alloc_urb (0, GFP_KERNEL);
      if (!mdc800->download_urb)
            goto cleanup_on_fail;
      mdc800->write_urb=usb_alloc_urb (0, GFP_KERNEL);
      if (!mdc800->write_urb)
            goto cleanup_on_fail;

      /* Register the driver */
      retval = usb_register(&mdc800_usb_driver);
      if (retval)
            goto cleanup_on_fail;

      info (DRIVER_VERSION ":" DRIVER_DESC);

      return 0;

      /* Clean driver up, when something fails */

cleanup_on_fail:

      if (mdc800 != NULL)
      {
            err ("can't alloc memory!");

            kfree(mdc800->download_urb_buffer);
            kfree(mdc800->write_urb_buffer);
            kfree(mdc800->irq_urb_buffer);

            usb_free_urb(mdc800->write_urb);
            usb_free_urb(mdc800->download_urb);
            usb_free_urb(mdc800->irq_urb);

            kfree (mdc800);
      }
      mdc800 = NULL;
      return retval;
}


static void __exit usb_mdc800_cleanup (void)
{
      usb_deregister (&mdc800_usb_driver);

      usb_free_urb (mdc800->irq_urb);
      usb_free_urb (mdc800->download_urb);
      usb_free_urb (mdc800->write_urb);

      kfree (mdc800->irq_urb_buffer);
      kfree (mdc800->write_urb_buffer);
      kfree (mdc800->download_urb_buffer);

      kfree (mdc800);
      mdc800 = NULL;
}

module_init (usb_mdc800_init);
module_exit (usb_mdc800_cleanup);

MODULE_AUTHOR( DRIVER_AUTHOR );
MODULE_DESCRIPTION( DRIVER_DESC );
MODULE_LICENSE("GPL");


Generated by  Doxygen 1.6.0   Back to index