mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-16 15:34:48 +08:00
1b6d823258
dbg() was a very old USB-specific macro that should no longer be used. This patch removes it from being used in the driver and uses dev_dbg() instead. Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
1087 lines
24 KiB
C
1087 lines
24 KiB
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 = cpu_to_le16(8),
|
|
.bInterval = 0,
|
|
.bRefresh = 0,
|
|
.bSynchAddress = 0,
|
|
},
|
|
{
|
|
.bLength = 0,
|
|
.bDescriptorType = 0,
|
|
.bEndpointAddress = 0x82,
|
|
.bmAttributes = 0x03,
|
|
.wMaxPacketSize = cpu_to_le16(8),
|
|
.bInterval = 0,
|
|
.bRefresh = 0,
|
|
.bSynchAddress = 0,
|
|
},
|
|
{
|
|
.bLength = 0,
|
|
.bDescriptorType = 0,
|
|
.bEndpointAddress = 0x03,
|
|
.bmAttributes = 0x02,
|
|
.wMaxPacketSize = cpu_to_le16(64),
|
|
.bInterval = 0,
|
|
.bRefresh = 0,
|
|
.bSynchAddress = 0,
|
|
},
|
|
{
|
|
.bLength = 0,
|
|
.bDescriptorType = 0,
|
|
.bEndpointAddress = 0x84,
|
|
.bmAttributes = 0x02,
|
|
.wMaxPacketSize = 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;
|
|
struct device *dev = &mdc800->dev->dev;
|
|
int status = urb->status;
|
|
|
|
if (status >= 0) {
|
|
if (mdc800_isBusy (b))
|
|
{
|
|
if (!mdc800->camera_busy)
|
|
{
|
|
mdc800->camera_busy=1;
|
|
dev_dbg(dev, "gets busy\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (mdc800->camera_busy && mdc800_isReady (b))
|
|
{
|
|
mdc800->camera_busy=0;
|
|
dev_dbg(dev, "gets ready\n");
|
|
}
|
|
}
|
|
if (!(mdc800_isBusy (b) || mdc800_isReady (b)))
|
|
{
|
|
/* Store Data in camera_answer field */
|
|
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]);
|
|
|
|
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;
|
|
dev_err(&mdc800->dev->dev, "timeout waiting for camera.\n");
|
|
return -1;
|
|
}
|
|
|
|
if (mdc800->state == NOT_CONNECTED)
|
|
{
|
|
printk(KERN_WARNING "mdc800: Camera gets disconnected "
|
|
"during waiting for irq.\n");
|
|
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)
|
|
dev_err(&mdc800->dev->dev,
|
|
"writing command fails (status=%i)\n", 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 {
|
|
dev_err(&mdc800->dev->dev,
|
|
"request bytes fails (status:%i)\n", 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;
|
|
|
|
dev_dbg(&intf->dev, "(%s) called.\n", __func__);
|
|
|
|
|
|
if (mdc800->dev != NULL)
|
|
{
|
|
dev_warn(&intf->dev, "only one Mustek MDC800 is supported.\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
if (dev->descriptor.bNumConfigurations != 1)
|
|
{
|
|
dev_err(&intf->dev,
|
|
"probe fails -> wrong Number of Configuration\n");
|
|
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)
|
|
)
|
|
{
|
|
dev_err(&intf->dev, "probe fails -> wrong Interface\n");
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
if (mdc800->endpoint[i] == -1)
|
|
{
|
|
dev_err(&intf->dev, "probe fails -> Wrong Endpoints.\n");
|
|
return -ENODEV;
|
|
}
|
|
}
|
|
|
|
|
|
dev_info(&intf->dev, "Found Mustek MDC800 on USB.\n");
|
|
|
|
mutex_lock(&mdc800->io_lock);
|
|
|
|
retval = usb_register_dev(intf, &mdc800_class);
|
|
if (retval) {
|
|
dev_err(&intf->dev, "Not able to get a minor for this device.\n");
|
|
mutex_unlock(&mdc800->io_lock);
|
|
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);
|
|
|
|
dev_dbg(&intf->dev, "(%s) called\n", __func__);
|
|
|
|
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);
|
|
}
|
|
dev_info(&intf->dev, "Mustek MDC800 disconnected from USB.\n");
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
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) {
|
|
dev_err(&mdc800->dev->dev,
|
|
"request USB irq fails (submit_retval=%i).\n", retval);
|
|
errn = -EIO;
|
|
goto error_out;
|
|
}
|
|
|
|
mdc800->open=1;
|
|
dev_dbg(&mdc800->dev->dev, "Mustek MDC800 device opened.\n");
|
|
|
|
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;
|
|
|
|
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)
|
|
{
|
|
printk(KERN_WARNING "mdc800: Illegal State \"working\""
|
|
"reached during read ?!\n");
|
|
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) {
|
|
dev_err(&mdc800->dev->dev,
|
|
"Can't submit download urb "
|
|
"(retval=%i)\n", 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)
|
|
{
|
|
dev_err(&mdc800->dev->dev,
|
|
"request download-bytes fails "
|
|
"(status=%i)\n",
|
|
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))
|
|
{
|
|
dev_err(&mdc800->dev->dev,
|
|
"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) {
|
|
dev_err(&mdc800->dev->dev,
|
|
"submitting write urb fails "
|
|
"(retval=%i)\n", 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)
|
|
{
|
|
dev_err(&mdc800->dev->dev,
|
|
"call 0x07 before "
|
|
"0x05,0x3e\n");
|
|
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))
|
|
{
|
|
dev_err(&mdc800->dev->dev, "requesting answer from irq fails\n");
|
|
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];
|
|
|
|
dev_dbg(&mdc800->dev->dev, "cached imagesize = %i\n", mdc800->pic_len);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (mdc800_usb_waitForIRQ (0,TO_DEFAULT_COMMAND))
|
|
{
|
|
dev_err(&mdc800->dev->dev, "Command Timeout.\n");
|
|
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,
|
|
.llseek = noop_llseek,
|
|
};
|
|
|
|
|
|
|
|
static const 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;
|
|
|
|
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
|
|
DRIVER_DESC "\n");
|
|
|
|
return 0;
|
|
|
|
/* Clean driver up, when something fails */
|
|
|
|
cleanup_on_fail:
|
|
|
|
if (mdc800 != NULL)
|
|
{
|
|
printk(KERN_ERR "mdc800: can't alloc memory!\n");
|
|
|
|
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");
|
|
|