Subversion Repositories shark

/* Linux driver for Philips webcam

   USB and Video4Linux interface part.

   (C) 1999-2003 Nemosoft Unv.

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

/*  

   This code forms the interface between the USB layers and the Philips

   specific stuff. Some adanved stuff of the driver falls under an

   NDA, signed between me and Philips B.V., Eindhoven, the Netherlands, and

   is thus not distributed in source form. The binary pwcx.o module

   contains the code that falls under the NDA.

   In case you're wondering: 'pwc' stands for "Philips WebCam", but

   I really didn't want to type 'philips_web_cam' every time (I'm lazy as

   any Linux kernel hacker, but I don't like uncomprehensible abbreviations

   without explanation).

   Oh yes, convention: to disctinguish between all the various pointers to

   device-structures, I use these names for the pointer variables:

   udev: struct usb_device *

   vdev: struct video_device *

   pdev: struct pwc_devive *

*/

/* Contributors:

   - Alvarado: adding whitebalance code

   - Alistar Moire: QuickCam 3000 Pro device/product ID

   - Tony Hoyle: Creative Labs Webcam 5 device/product ID

   - Mark Burazin: solving hang in VIDIOCSYNC when camera gets unplugged

   - Jk Fang: SOTEC Afina Eye ID

   - Xavier Roche: QuickCam Pro 4000 ID

   - Jens Knudsen: QuickCam Zoom ID

   - J. Debert: QuickCam for Notebooks ID

*/

#include <linuxcomp.h>

#include <linux/errno.h>

#include <linux/init.h>

#include <linux/mm.h>

#include <linux/module.h>

#include <linux/poll.h>

#include <linux/slab.h>

#include <linux/vmalloc.h>

#include <asm/io.h>

#include "pwc.h"

#include "pwc-ioctl.h"

#include "pwc-uncompress.h"

/* Function prototypes and driver templates */

/* hotplug device table support */

static struct usb_device_id pwc_device_table [] = {

        { USB_DEVICE(0x0471, 0x0302) }, /* Philips models */

        { USB_DEVICE(0x0471, 0x0303) },

        { USB_DEVICE(0x0471, 0x0304) },

        { USB_DEVICE(0x0471, 0x0307) },

        { USB_DEVICE(0x0471, 0x0308) },

        { USB_DEVICE(0x0471, 0x030C) },

        { USB_DEVICE(0x0471, 0x0310) },

        { USB_DEVICE(0x0471, 0x0311) },

        { USB_DEVICE(0x0471, 0x0312) },

        { USB_DEVICE(0x0471, 0x0313) }, /* the 'new' 720K */

        { USB_DEVICE(0x069A, 0x0001) }, /* Askey */

        { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam Pro 3000 */

        { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */

        { USB_DEVICE(0x046D, 0x08B2) }, /* Logitech QuickCam Pro 4000 */

        { USB_DEVICE(0x046D, 0x08B3) }, /* Logitech QuickCam Zoom (old model) */

        { USB_DEVICE(0x046D, 0x08B4) }, /* Logitech QuickCam Zoom (new model) */

        { USB_DEVICE(0x046D, 0x08B5) }, /* Logitech QuickCam Orbit/Sphere */

        { USB_DEVICE(0x046D, 0x08B6) }, /* Logitech (reserved) */

        { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech (reserved) */

        { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */

        { USB_DEVICE(0x055D, 0x9000) }, /* Samsung */

        { USB_DEVICE(0x055D, 0x9001) },

        { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */

        { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */

        { USB_DEVICE(0x04CC, 0x8116) }, /* Afina Eye */

        { USB_DEVICE(0x06BE, 0x8116) }, /* AME CU-001 */

        { USB_DEVICE(0x0d81, 0x1910) }, /* Visionite */

        { USB_DEVICE(0x0d81, 0x1900) },

        { }

};

MODULE_DEVICE_TABLE(usb, pwc_device_table);

static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id *id);

static void usb_pwc_disconnect(struct usb_interface *intf);

static struct usb_driver pwc_driver = {

        .owner =                THIS_MODULE,

        .name =                 "Philips webcam",       /* name */

        .id_table =             pwc_device_table,

        .probe =                usb_pwc_probe,          /* probe() */

        .disconnect =           usb_pwc_disconnect,     /* disconnect() */

};

#define MAX_DEV_HINTS   20

#define MAX_ISOC_ERRORS 20

static int default_size = PSZ_QCIF;

static int default_fps = 10;

static int default_fbufs = 3;   /* Default number of frame buffers */

static int default_mbufs = 2;   /* Default number of mmap() buffers */

       int pwc_trace = TRACE_MODULE | TRACE_FLOW | TRACE_PWCX;

static int power_save = 0;

static int led_on = 100, led_off = 0; /* defaults to LED that is on while in use */

       int pwc_preferred_compression = 2; /* 0..3 = uncompressed..high */

static struct {

        int type;

        char serial_number[30];

        int device_node;

        struct pwc_device *pdev;

} device_hint[MAX_DEV_HINTS];

/***/

/*static*/ int pwc_video_open(struct inode *inode, struct file *file);

static int pwc_video_close(struct inode *inode, struct file *file);

static void pwc_video_release(struct video_device *);                    

/*static*/ ssize_t pwc_video_read(struct file *file, char *buf,

                          size_t count, loff_t *ppos);

static unsigned int pwc_video_poll(struct file *file, poll_table *wait);

/*static*/ int  pwc_video_ioctl(struct inode *inode, struct file *file,

                            unsigned int ioctlnr, unsigned long arg);

static int  pwc_video_mmap(struct file *file, struct vm_area_struct *vma);

static struct file_operations pwc_fops = {

        .owner =        THIS_MODULE,

        .open =         pwc_video_open,

        .release =      pwc_video_close,

        .read =         pwc_video_read,

        .poll =         pwc_video_poll,

        .mmap =         pwc_video_mmap,

        .ioctl =        pwc_video_ioctl,

        .llseek =       no_llseek,

};

static struct video_device pwc_template = {

        .owner =        THIS_MODULE,

        .name =         "Philips Webcam",       /* Filled in later */

        .type =         VID_TYPE_CAPTURE,

        .hardware =     VID_HARDWARE_PWC,

        .fops =         &pwc_fops,

};

/***************************************************************************/

/* Okay, this is some magic that I worked out and the reasoning behind it...

   The biggest problem with any USB device is of course: "what to do

   when the user unplugs the device while it is in use by an application?"

   We have several options:

   1) Curse them with the 7 plagues when they do (requires divine intervention)

   2) Tell them not to (won't work: they'll do it anyway)

   3) Oops the kernel (this will have a negative effect on a user's uptime)

   4) Do something sensible.

   Of course, we go for option 4.

   It happens that this device will be linked to two times, once from

   usb_device and once from the video_device in their respective 'private'

   pointers. This is done when the device is probed() and all initialization

   succeeded. The pwc_device struct links back to both structures.

   When a device is unplugged while in use it will be removed from the

   list of known USB devices; I also de-register it as a V4L device, but

   unfortunately I can't free the memory since the struct is still in use

   by the file descriptor. This free-ing is then deferend until the first

   opportunity. Crude, but it works.

   A small 'advantage' is that if a user unplugs the cam and plugs it back

   in, it should get assigned the same video device minor, but unfortunately

   it's non-trivial to re-link the cam back to the video device... (that

   would surely be magic! :))

*/

/***************************************************************************/

/* Private functions */

/* Here we want the physical address of the memory.

 * This is used when initializing the contents of the area.

 */

static inline unsigned long kvirt_to_pa(unsigned long adr)

{

//    unsigned long kva, ret;

//      kva = (unsigned long) page_address(vmalloc_to_page((void *)adr));

//      kva |= adr & (PAGE_SIZE-1); /* restore the offset */

//      ret = __pa(kva); */

//      return ret;

        return adr;

}

static void * rvmalloc(unsigned long size)

{

        void * mem;

        unsigned long adr;

//      size=PAGE_ALIGN(size);

//    mem=vmalloc_32(size);

        mem=malloc(size);

        if (mem)

        {

                memset(mem, 0, size); /* Clear the ram out, no junk to the user */

//            adr=(unsigned long) mem;

//              while (size > 0) 

//                {

//                      SetPageReserved(vmalloc_to_page((void *)adr));

//                      adr+=PAGE_SIZE;

//                      size-=PAGE_SIZE;

//              }

        }

        return mem;

}

static void rvfree(void * mem, unsigned long size)

{

        unsigned long adr;

//      if (mem) 

//      {

//              adr=(unsigned long) mem;

//              while ((long) size > 0) 

//                {

//                      ClearPageReserved(vmalloc_to_page((void *)adr));

//                      adr+=PAGE_SIZE;

//                      size-=PAGE_SIZE;

//              }

//              vfree(mem);

//      }

}

static int pwc_allocate_buffers(struct pwc_device *pdev)

{

        int i;

        void *kbuf;

        Trace(TRACE_MEMORY, ">> pwc_allocate_buffers(pdev = 0x%p)\n", pdev);

        if (pdev == NULL)

                return -ENXIO;

#ifdef PWC_MAGIC

        if (pdev->magic != PWC_MAGIC) {

                Err("allocate_buffers(): magic failed.\n");

                return -ENXIO;

        }

#endif  

        /* Allocate Isochronous pipe buffers */

        for (i = 0; i < MAX_ISO_BUFS; i++) {

                if (pdev->sbuf[i].data == NULL) {

                        kbuf = kmalloc(ISO_BUFFER_SIZE, GFP_KERNEL);

                        if (kbuf == NULL) {

                                Err("Failed to allocate iso buffer %d.\n", i);

                                return -ENOMEM;

                        }

                        Trace(TRACE_MEMORY, "Allocated iso buffer at %p.\n", kbuf);

                        pdev->sbuf[i].data = kbuf;

                        memset(kbuf, 0, ISO_BUFFER_SIZE);

                }

        }

        /* Allocate frame buffer structure */

        if (pdev->fbuf == NULL) {

                kbuf = kmalloc(default_fbufs * sizeof(struct pwc_frame_buf), GFP_KERNEL);

                if (kbuf == NULL) {

                        Err("Failed to allocate frame buffer structure.\n");

                        return -ENOMEM;

                }

                Trace(TRACE_MEMORY, "Allocated frame buffer structure at %p.\n", kbuf);

                pdev->fbuf = kbuf;

                memset(kbuf, 0, default_fbufs * sizeof(struct pwc_frame_buf));

        }

        /* create frame buffers, and make circular ring */

        for (i = 0; i < default_fbufs; i++) {

                if (pdev->fbuf[i].data == NULL) {

                        kbuf = vmalloc(PWC_FRAME_SIZE); /* need vmalloc since frame buffer > 128K */

                        if (kbuf == NULL) {

                                Err("Failed to allocate frame buffer %d.\n", i);

                                return -ENOMEM;

                        }

                        Trace(TRACE_MEMORY, "Allocated frame buffer %d at %p.\n", i, kbuf);

                        pdev->fbuf[i].data = kbuf;

                        memset(kbuf, 128, PWC_FRAME_SIZE);

                }

        }

        /* Allocate decompressor table space */

        kbuf = NULL;

        if (pdev->decompressor != NULL) {

                kbuf = kmalloc(pdev->decompressor->table_size, GFP_KERNEL);

                if (kbuf == NULL) {

                        Err("Failed to allocate decompress table.\n");

                        return -ENOMEM;

                }

                Trace(TRACE_MEMORY, "Allocated decompress table %p.\n", kbuf);

        }

        pdev->decompress_data = kbuf;

        /* Allocate image buffer; double buffer for mmap() */

        kbuf = rvmalloc(default_mbufs * pdev->len_per_image);

        if (kbuf == NULL) {

                Err("Failed to allocate image buffer(s).\n");

                return -ENOMEM;

        }

        Trace(TRACE_MEMORY, "Allocated image buffer at %p.\n", kbuf);

        pdev->image_data = kbuf;

        for (i = 0; i < default_mbufs; i++)

                pdev->image_ptr[i] = kbuf + i * pdev->len_per_image;

        for (; i < MAX_IMAGES; i++)

                pdev->image_ptr[i] = NULL;

        kbuf = NULL;

        Trace(TRACE_MEMORY, "<< pwc_allocate_buffers()\n");

        return 0;

}

static void pwc_free_buffers(struct pwc_device *pdev)

{

        int i;

        Trace(TRACE_MEMORY, "Entering free_buffers(%p).\n", pdev);

        if (pdev == NULL)

                return;

#ifdef PWC_MAGIC

        if (pdev->magic != PWC_MAGIC) {

                Err("free_buffers(): magic failed.\n");

                return;

        }

#endif  

        /* Release Iso-pipe buffers */

        for (i = 0; i < MAX_ISO_BUFS; i++)

                if (pdev->sbuf[i].data != NULL) {

                        Trace(TRACE_MEMORY, "Freeing ISO buffer at %p.\n", pdev->sbuf[i].data);

                        kfree(pdev->sbuf[i].data);

                        pdev->sbuf[i].data = NULL;

                }

        /* The same for frame buffers */

        if (pdev->fbuf != NULL) {

                for (i = 0; i < default_fbufs; i++) {

                        if (pdev->fbuf[i].data != NULL) {

                                Trace(TRACE_MEMORY, "Freeing frame buffer %d at %p.\n", i, pdev->fbuf[i].data);

                                vfree(pdev->fbuf[i].data);

                                pdev->fbuf[i].data = NULL;

                        }

                }

                kfree(pdev->fbuf);

                pdev->fbuf = NULL;

        }

        /* Intermediate decompression buffer & tables */

        if (pdev->decompress_data != NULL) {

                Trace(TRACE_MEMORY, "Freeing decompression buffer at %p.\n", pdev->decompress_data);

                kfree(pdev->decompress_data);

                pdev->decompress_data = NULL;

        }

        pdev->decompressor = NULL;

        /* Release image buffers */

        if (pdev->image_data != NULL) {

                Trace(TRACE_MEMORY, "Freeing image buffer at %p.\n", pdev->image_data);

                rvfree(pdev->image_data, default_mbufs * pdev->len_per_image);

        }

        pdev->image_data = NULL;

        Trace(TRACE_MEMORY, "Leaving free_buffers().\n");

}

/* The frame & image buffer mess.

   Yes, this is a mess. Well, it used to be simple, but alas...  In this

   module, 3 buffers schemes are used to get the data from the USB bus to

   the user program. The first scheme involves the ISO buffers (called thus

   since they transport ISO data from the USB controller), and not really

   interesting. Suffices to say the data from this buffer is quickly

   gathered in an interrupt handler (pwc_isoc_handler) and placed into the

   frame buffer.

   The frame buffer is the second scheme, and is the central element here.

   It collects the data from a single frame from the camera (hence, the

   name). Frames are delimited by the USB camera with a short USB packet,

   so that's easy to detect. The frame buffers form a list that is filled

   by the camera+USB controller and drained by the user process through

   either read() or mmap().

   The image buffer is the third scheme, in which frames are decompressed

   and converted into planar format. For mmap() there is more than

   one image buffer available.

   The frame buffers provide the image buffering. In case the user process

   is a bit slow, this introduces lag and some undesired side-effects.

   The problem arises when the frame buffer is full. I used to drop the last

   frame, which makes the data in the queue stale very quickly. But dropping

   the frame at the head of the queue proved to be a litte bit more difficult.

   I tried a circular linked scheme, but this introduced more problems than

   it solved.

   Because filling and draining are completely asynchronous processes, this

   requires some fiddling with pointers and mutexes.

   Eventually, I came up with a system with 2 lists: an 'empty' frame list

   and a 'full' frame list:

     * Initially, all frame buffers but one are on the 'empty' list; the one

       remaining buffer is our initial fill frame.

     * If a frame is needed for filling, we try to take it from the 'empty'

       list, unless that list is empty, in which case we take the buffer at

       the head of the 'full' list.

     * When our fill buffer has been filled, it is appended to the 'full'

       list.

     * If a frame is needed by read() or mmap(), it is taken from the head of

       the 'full' list, handled, and then appended to the 'empty' list. If no

       buffer is present on the 'full' list, we wait.

   The advantage is that the buffer that is currently being decompressed/

   converted, is on neither list, and thus not in our way (any other scheme

   I tried had the problem of old data lingering in the queue).

   Whatever strategy you choose, it always remains a tradeoff: with more

   frame buffers the chances of a missed frame are reduced. On the other

   hand, on slower machines it introduces lag because the queue will

   always be full.

 */

/**

  \brief Find next frame buffer to fill. Take from empty or full list, whichever comes first.

 */

static inline int pwc_next_fill_frame(struct pwc_device *pdev)

{

        int ret;

        unsigned long flags;

        ret = 0;

        spin_lock_irqsave(&pdev->ptrlock, flags);

        if (pdev->fill_frame != NULL) {

                /* append to 'full' list */

                if (pdev->full_frames == NULL) {

                        pdev->full_frames = pdev->fill_frame;

                        pdev->full_frames_tail = pdev->full_frames;

                }

                else {

                        pdev->full_frames_tail->next = pdev->fill_frame;

                        pdev->full_frames_tail = pdev->fill_frame;

                }

        }

        if (pdev->empty_frames != NULL) {

                /* We have empty frames available. That's easy */

                pdev->fill_frame = pdev->empty_frames;

                pdev->empty_frames = pdev->empty_frames->next;

        }

        else {

                /* Hmm. Take it from the full list */

#if PWC_DEBUG

                /* sanity check */

                if (pdev->full_frames == NULL) {

                        Err("Neither empty or full frames available!\n");

                        spin_unlock_irqrestore(&pdev->ptrlock, flags);

                        return -EINVAL;

                }

#endif

                pdev->fill_frame = pdev->full_frames;

                pdev->full_frames = pdev->full_frames->next;

                ret = 1;

        }

        pdev->fill_frame->next = NULL;

#if PWC_DEBUG

        Trace(TRACE_SEQUENCE, "Assigning sequence number %d.\n", pdev->sequence);

        pdev->fill_frame->sequence = pdev->sequence++;

#endif

        spin_unlock_irqrestore(&pdev->ptrlock, flags);

        return ret;

}

/**

  \brief Reset all buffers, pointers and lists, except for the image_used[] buffer.

  If the image_used[] buffer is cleared too, mmap()/VIDIOCSYNC will run into trouble.

 */

static void pwc_reset_buffers(struct pwc_device *pdev)

{

        int i;

        unsigned long flags;

        spin_lock_irqsave(&pdev->ptrlock, flags);

        pdev->full_frames = NULL;

        pdev->full_frames_tail = NULL;

        for (i = 0; i < default_fbufs; i++) {

                pdev->fbuf[i].filled = 0;

                if (i > 0)

                        pdev->fbuf[i].next = &pdev->fbuf[i - 1];

                else

                        pdev->fbuf->next = NULL;

        }

        pdev->empty_frames = &pdev->fbuf[default_fbufs - 1];

        pdev->empty_frames_tail = pdev->fbuf;

        pdev->read_frame = NULL;

        pdev->fill_frame = pdev->empty_frames;

        pdev->empty_frames = pdev->empty_frames->next;

        pdev->image_read_pos = 0;

        pdev->fill_image = 0;

        spin_unlock_irqrestore(&pdev->ptrlock, flags);

}

/**

  \brief Do all the handling for getting one frame: get pointer, decompress, advance pointers.

 */

static int pwc_handle_frame(struct pwc_device *pdev)

{

        int ret = 0;

        unsigned long flags;

        spin_lock_irqsave(&pdev->ptrlock, flags);

        /* First grab our read_frame; this is removed from all lists, so

           we can release the lock after this without problems */

        if (pdev->read_frame != NULL) {

                /* This can't theoretically happen */

                Err("Huh? Read frame still in use?\n");

        }

        else {

                if (pdev->full_frames == NULL) {

                        Err("Woops. No frames ready.\n");

                }

                else {

                        pdev->read_frame = pdev->full_frames;

                        pdev->full_frames = pdev->full_frames->next;

                        pdev->read_frame->next = NULL;

                }

                if (pdev->read_frame != NULL) {

#if PWC_DEBUG

                        Trace(TRACE_SEQUENCE, "Decompressing frame %d\n", pdev->read_frame->sequence);

#endif

                        /* Decompression is a lenghty process, so it's outside of the lock.

                           This gives the isoc_handler the opportunity to fill more frames

                           in the mean time.

                        */

                        spin_unlock_irqrestore(&pdev->ptrlock, flags);

                        ret = pwc_decompress(pdev);

                        spin_lock_irqsave(&pdev->ptrlock, flags);

                        /* We're done with read_buffer, tack it to the end of the empty buffer list */

                        if (pdev->empty_frames == NULL) {

                                pdev->empty_frames = pdev->read_frame;

                                pdev->empty_frames_tail = pdev->empty_frames;

                        }

                        else {

                                pdev->empty_frames_tail->next = pdev->read_frame;

                                pdev->empty_frames_tail = pdev->read_frame;

                        }

                        pdev->read_frame = NULL;

                }

        }

        spin_unlock_irqrestore(&pdev->ptrlock, flags);

        return ret;

}

/**

  \brief Advance pointers of image buffer (after each user request)

*/

static inline void pwc_next_image(struct pwc_device *pdev)

{

        pdev->image_used[pdev->fill_image] = 0;

        pdev->fill_image = (pdev->fill_image + 1) % default_mbufs;

}

/* This gets called for the Isochronous pipe (video). This is done in

 * interrupt time, so it has to be fast, not crash, and not stall. Neat.

 */

static void pwc_isoc_handler(struct urb *urb, struct pt_regs *regs)

{

        struct pwc_device *pdev;

        int i, fst, flen;

        int awake;

        struct pwc_frame_buf *fbuf;

        unsigned char *fillptr = 0, *iso_buf = 0;

        awake = 0;

        pdev = (struct pwc_device *)urb->context;

        if (pdev == NULL) {

                Err("isoc_handler() called with NULL device?!\n");

                return;

        }

#ifdef PWC_MAGIC

        if (pdev->magic != PWC_MAGIC) {

                Err("isoc_handler() called with bad magic!\n");

                return;

        }

#endif

        if (urb->status == -ENOENT || urb->status == -ECONNRESET) {

                Trace(TRACE_OPEN, "pwc_isoc_handler(): URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");

                return;

        }

        if (urb->status != -EINPROGRESS && urb->status != 0) {

                const char *errmsg;

                errmsg = "Unknown";

                switch(urb->status) {

                        case -ENOSR:            errmsg = "Buffer error (overrun)"; break;

                        case -EPIPE:            errmsg = "Stalled (device not responding)"; break;

                        case -EOVERFLOW:        errmsg = "Babble (bad cable?)"; break;

                        case -EPROTO:           errmsg = "Bit-stuff error (bad cable?)"; break;

                        case -EILSEQ:           errmsg = "CRC/Timeout (could be anything)"; break;

                        case -ETIMEDOUT:        errmsg = "NAK (device does not respond)"; break;

                }

                Trace(TRACE_FLOW, "pwc_isoc_handler() called with status %d [%s].\n", urb->status, errmsg);

                /* Give up after a number of contiguous errors on the USB bus.

                   Appearantly something is wrong so we simulate an unplug event.

                 */

                if (++pdev->visoc_errors > MAX_ISOC_ERRORS)

                {

                        Info("Too many ISOC errors, bailing out.\n");

                        pdev->error_status = EIO;

                        awake = 1;

                        wake_up_interruptible(&pdev->frameq);

                }

                goto handler_end; // ugly, but practical

        }

        fbuf = pdev->fill_frame;

        if (fbuf == NULL) {

                Err("pwc_isoc_handler without valid fill frame.\n");

                awake = 1;

                goto handler_end;

        }

        else {

                fillptr = fbuf->data + fbuf->filled;

        }

        /* Reset ISOC error counter. We did get here, after all. */

        pdev->visoc_errors = 0;

        /* vsync: 0 = don't copy data

                  1 = sync-hunt

                  2 = synched

         */

        /* Compact data */

        for (i = 0; i < urb->number_of_packets; i++) {

                fst  = urb->iso_frame_desc[i].status;

                flen = urb->iso_frame_desc[i].actual_length;

                iso_buf = urb->transfer_buffer + urb->iso_frame_desc[i].offset;

                if (fst == 0) {

                        if (flen > 0) { /* if valid data... */

                                if (pdev->vsync > 0) { /* ...and we are not sync-hunting... */

                                        pdev->vsync = 2;

                                        /* ...copy data to frame buffer, if possible */

                                        if (flen + fbuf->filled > pdev->frame_total_size) {

                                                Trace(TRACE_FLOW, "Frame buffer overflow (flen = %d, frame_total_size = %d).\n", flen, pdev->frame_total_size);

                                                pdev->vsync = 0; /* Hmm, let's wait for an EOF (end-of-frame) */

                                                pdev->vframes_error++;

                                        }

                                        else {

                                                memmove(fillptr, iso_buf, flen);

                                                fillptr += flen;

                                        }

                                }

                                fbuf->filled += flen;

                        } /* ..flen > 0 */

                        if (flen < pdev->vlast_packet_size) {

                                /* Shorter packet... We probably have the end of an image-frame;

                                   wake up read() process and let select()/poll() do something.

                                   Decompression is done in user time over there.

                                 */

                                if (pdev->vsync == 2) {

                                        /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus

                                           frames on the USB wire after an exposure change. This conditition is

                                           however detected  in the cam and a bit is set in the header.

                                         */

                                        if (pdev->type == 730) {

                                                unsigned char *ptr = (unsigned char *)fbuf->data;

                                                if (ptr[1] == 1 && ptr[0] & 0x10) {

#if PWC_DEBUG

                                                        Debug("Hyundai CMOS sensor bug. Dropping frame %d.\n", fbuf->sequence);

#endif

                                                        pdev->drop_frames += 2;

                                                        pdev->vframes_error++;

                                                }

                                                if ((ptr[0] ^ pdev->vmirror) & 0x01) {

                                                        if (ptr[0] & 0x01)

                                                                Info("Snapshot button pressed.\n");

                                                        else

                                                                Info("Snapshot button released.\n");

                                                }

                                                if ((ptr[0] ^ pdev->vmirror) & 0x02) {

                                                        if (ptr[0] & 0x02)

                                                                Info("Image is mirrored.\n");

                                                        else

                                                                Info("Image is normal.\n");

                                                }

                                                pdev->vmirror = ptr[0] & 0x03;

                                                /* Sometimes the trailer of the 730 is still sent as a 4 byte packet

                                                   after a short frame; this condition is filtered out specifically. A 4 byte

                                                   frame doesn't make sense anyway.

                                                   So we get either this sequence:

                                                        drop_bit set -> 4 byte frame -> short frame -> good frame

                                                   Or this one:

                                                        drop_bit set -> short frame -> good frame

                                                   So we drop either 3 or 2 frames in all!

                                                 */

                                                if (fbuf->filled == 4)

                                                        pdev->drop_frames++;

                                        }

                                        /* In case we were instructed to drop the frame, do so silently.

                                           The buffer pointers are not updated either (but the counters are reset below).

                                         */

                                        if (pdev->drop_frames > 0)

                                                pdev->drop_frames--;

                                        else {

                                                /* Check for underflow first */

                                                if (fbuf->filled < pdev->frame_total_size) {

                                                        Trace(TRACE_FLOW, "Frame buffer underflow (%d bytes); discarded.\n", fbuf->filled);

                                                        pdev->vframes_error++;

                                                }

                                                else {

                                                        /* Send only once per EOF */

                                                        awake = 1; /* delay wake_ups */

                                                        /* Find our next frame to fill. This will always succeed, since we

                                                         * nick a frame from either empty or full list, but if we had to

                                                         * take it from the full list, it means a frame got dropped.

                                                         */

                                                        if (pwc_next_fill_frame(pdev)) {

                                                                pdev->vframes_dumped++;

                                                                if ((pdev->vframe_count > FRAME_LOWMARK) && (pwc_trace & TRACE_FLOW)) {

                                                                        if (pdev->vframes_dumped < 20)

                                                                                Trace(TRACE_FLOW, "Dumping frame %d.\n", pdev->vframe_count);

                                                                        if (pdev->vframes_dumped == 20)

                                                                                Trace(TRACE_FLOW, "Dumping frame %d (last message).\n", pdev->vframe_count);

                                                                }

                                                        }

                                                        fbuf = pdev->fill_frame;

                                                }

                                        } /* !drop_frames */

                                        pdev->vframe_count++;

                                }

                                fbuf->filled = 0;

                                fillptr = fbuf->data;

                                pdev->vsync = 1;

                        } /* .. flen < last_packet_size */

                        pdev->vlast_packet_size = flen;

                } /* ..status == 0 */

#if PWC_DEBUG

                /* This is normally not interesting to the user, unless you are really debugging something */

                else {

                        static int iso_error = 0;

                        iso_error++;

                        if (iso_error < 20)

                                Trace(TRACE_FLOW, "Iso frame %d of USB has error %d\n", i, fst);

                }

#endif

        }

handler_end:

        if (awake)

                wake_up_interruptible(&pdev->frameq);

        urb->dev = pdev->udev;

        i = usb_submit_urb(urb, GFP_ATOMIC);

        if (i != 0)

                Err("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);

}

static int pwc_isoc_init(struct pwc_device *pdev)