}
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
        if (data[0] == 0xff && data[1] == 0xd8) {
 
                /* start of frame */
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
-                                       data, 0);
+               gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
 
                /* put the JPEG header in the new frame */
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
-                       sd->jpeg_hdr, JPEG_HDR_SZ);
+               gspca_frame_add(gspca_dev, FIRST_PACKET,
+                               sd->jpeg_hdr, JPEG_HDR_SZ);
                data += 2;
                len -= 2;
        }
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static void setbrightness(struct gspca_dev*gspca_dev)
 
 #undef LIMIT
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        int seqframe;
                       data[2], data[3], data[4], data[5]);
                data += 30;
                /* don't change datalength as the chips provided it */
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
-                                       data, 0);
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, len);
+               gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
+               gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
                return;
        }
        if (len) {
                data += 8;
-               gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+               gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
        } else {                        /* Drop Packet */
                gspca_dev->last_packet_type = DISCARD_PACKET;
        }
 
        struct gspca_dev *gspca_dev = &dev->gspca_dev;
        struct urb *urb = gspca_dev->urb[0];
        u8 *data = urb->transfer_buffer;
-       struct gspca_frame *frame;
        int ret = 0;
        int len;
 
                        }
                        if (!gspca_dev->present || !gspca_dev->streaming)
                                goto out;
-                       frame = gspca_get_i_frame(&dev->gspca_dev);
-                       if (frame == NULL)
-                               gspca_dev->last_packet_type = DISCARD_PACKET;
-
                        if (len < FPIX_MAX_TRANSFER ||
                                (data[len - 2] == 0xff &&
                                        data[len - 1] == 0xd9)) {
                                 * but there's nothing we can do. We also end
                                 * here if the the jpeg ends right at the end
                                 * of the frame. */
-                               if (frame)
-                                       frame = gspca_frame_add(gspca_dev,
-                                                       LAST_PACKET,
-                                                       frame,
-                                                       data, len);
+                               gspca_frame_add(gspca_dev, LAST_PACKET,
+                                               data, len);
                                break;
                        }
 
                        /* got a partial image */
-                       if (frame)
-                               gspca_frame_add(gspca_dev,
-                                               gspca_dev->last_packet_type
-                                                       == LAST_PACKET
-                                               ? FIRST_PACKET : INTER_PACKET,
-                                               frame, data, len);
+                       gspca_frame_add(gspca_dev,
+                                       gspca_dev->last_packet_type
+                                               == LAST_PACKET
+                                       ? FIRST_PACKET : INTER_PACKET,
+                                       data, len);
                }
 
                /* We must wait before trying reading the next
 
 static int  sd_start(struct gspca_dev *gspca_dev);
 static void sd_stop0(struct gspca_dev *gspca_dev);
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame, u8 *data, s32 len);
+                       u8 *data, int len);
 static void sd_callback(struct gspca_dev *gspca_dev);
 
 static int gl860_guess_sensor(struct gspca_dev *gspca_dev,
 
 /* This function is called when an image is being received */
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame, u8 *data, s32 len)
+                       u8 *data, int len)
 {
        struct sd *sd = (struct sd *) gspca_dev;
        static s32 nSkipped;
        /* Test only against 0202h, so endianess does not matter */
        switch (*(s16 *) data) {
        case 0x0202:            /* End of frame, start a new one */
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame, data, 0);
+               gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
                nSkipped = 0;
                if (sd->nbIm >= 0 && sd->nbIm < 10)
                        sd->nbIm++;
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, 0);
+               gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
                break;
 
        default:
                                nSkipped = nToSkip + 1;
                        }
                        gspca_frame_add(gspca_dev,
-                               INTER_PACKET, frame, data, len);
+                               INTER_PACKET, data, len);
                }
                break;
        }
 
                        i, urb->iso_frame_desc[i].offset, len);
                data = (u8 *) urb->transfer_buffer
                                        + urb->iso_frame_desc[i].offset;
-               pkt_scan(gspca_dev, gspca_dev->cur_frame, data, len);
+               pkt_scan(gspca_dev, data, len);
        }
 
 resubmit:
 
        PDEBUG(D_PACK, "packet l:%d", urb->actual_length);
        gspca_dev->sd_desc->pkt_scan(gspca_dev,
-                               gspca_dev->frame,
                                urb->transfer_buffer,
                                urb->actual_length);
 
  * DISCARD_PACKET invalidates the whole frame.
  * On LAST_PACKET, a new frame is returned.
  */
-struct gspca_frame *gspca_frame_add(struct gspca_dev *gspca_dev,
-                                   enum gspca_packet_type packet_type,
-                                   struct gspca_frame *dummy,
-                                   const __u8 *data,
-                                   int len)
+void gspca_frame_add(struct gspca_dev *gspca_dev,
+                       enum gspca_packet_type packet_type,
+                       const u8 *data,
+                       int len)
 {
        struct gspca_frame *frame;
        int i, j;
        if ((frame->v4l2_buf.flags & BUF_ALL_FLAGS)
                                        != V4L2_BUF_FLAG_QUEUED) {
                gspca_dev->last_packet_type = DISCARD_PACKET;
-               return frame;
+               return;
        }
 
        /* when start of a new frame, if the current frame buffer
        } else if (gspca_dev->last_packet_type == DISCARD_PACKET) {
                if (packet_type == LAST_PACKET)
                        gspca_dev->last_packet_type = packet_type;
-               return frame;
+               return;
        }
 
        /* append the packet to the frame buffer */
                        i,
                        gspca_dev->fr_o);
                j = gspca_dev->fr_queue[i];
-               gspca_dev->cur_frame = frame = &gspca_dev->frame[j];
+               gspca_dev->cur_frame = &gspca_dev->frame[j];
        }
-       return frame;
+       return;
 }
 EXPORT_SYMBOL(gspca_frame_add);
 
 
 typedef int (*cam_qmnu_op) (struct gspca_dev *,
                        struct v4l2_querymenu *);
 typedef void (*cam_pkt_op) (struct gspca_dev *gspca_dev,
-                               struct gspca_frame *frame,
-                               __u8 *data,
+                               u8 *data,
                                int len);
 
 struct ctrl {
                int dev_size,
                struct module *module);
 void gspca_disconnect(struct usb_interface *intf);
-struct gspca_frame *gspca_frame_add(struct gspca_dev *gspca_dev,
-                                   enum gspca_packet_type packet_type,
-                                   struct gspca_frame *frame,
-                                   const __u8 *data,
-                                   int len);
+void gspca_frame_add(struct gspca_dev *gspca_dev,
+                       enum gspca_packet_type packet_type,
+                       const u8 *data,
+                       int len);
 struct gspca_frame *gspca_get_i_frame(struct gspca_dev *gspca_dev);
 #ifdef CONFIG_PM
 int gspca_suspend(struct usb_interface *intf, pm_message_t message);
 
 {
        struct sd *dev = container_of(work, struct sd, work_struct);
        struct gspca_dev *gspca_dev = &dev->gspca_dev;
-       struct gspca_frame *frame;
        int blocks_left; /* 0x200-sized blocks remaining in current frame. */
        int size_in_blocks;
        int act_len;
                PDEBUG(D_STREAM, "blocks_left = 0x%x", blocks_left);
 
                /* Start a new frame, and add the JPEG header, first thing */
-               frame = gspca_get_i_frame(gspca_dev);
-               if (frame) {
-                       gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
-                                       dev->jpeg_hdr, JPEG_HDR_SZ);
-                       /* Toss line 0 of data block 0, keep the rest. */
-                       gspca_frame_add(gspca_dev, INTER_PACKET,
-                               frame, buffer + FRAME_HEADER_LEN,
+               gspca_frame_add(gspca_dev, FIRST_PACKET,
+                               dev->jpeg_hdr, JPEG_HDR_SZ);
+               /* Toss line 0 of data block 0, keep the rest. */
+               gspca_frame_add(gspca_dev, INTER_PACKET,
+                               buffer + FRAME_HEADER_LEN,
                                JEILINJ_MAX_TRANSFER - FRAME_HEADER_LEN);
-               }
+
                while (blocks_left > 0) {
                        if (!gspca_dev->present)
                                goto quit_stream;
                                packet_type = LAST_PACKET;
                        else
                                packet_type = INTER_PACKET;
-                       if (frame)
-                               gspca_frame_add(gspca_dev, packet_type,
-                                               frame, buffer,
-                                               JEILINJ_MAX_TRANSFER);
+                       gspca_frame_add(gspca_dev, packet_type,
+                                       buffer, JEILINJ_MAX_TRANSFER);
                }
        }
 quit_stream:
 
 }
 
 static void m5602_urb_complete(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,
-                       __u8 *data, int len)
+                               u8 *data, int len)
 {
        struct sd *sd = (struct sd *) gspca_dev;
 
                len -= 6;
 
                /* Complete the last frame (if any) */
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET,
-                                       frame, data, 0);
+               gspca_frame_add(gspca_dev, LAST_PACKET,
+                               NULL, 0);
                sd->frame_count++;
 
                /* Create a new frame */
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, len);
+               gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
 
                PDEBUG(D_FRAM, "Starting new frame %d",
                       sd->frame_count);
 
        } else {
-               int cur_frame_len = frame->data_end - frame->data;
+               struct gspca_frame *frame;
+               int cur_frame_len;
 
+               frame = gspca_get_i_frame(gspca_dev);
+               if (frame == NULL) {
+                       gspca_dev->last_packet_type = DISCARD_PACKET;
+                       return;
+               }
+
+               cur_frame_len = frame->data_end - frame->data;
                /* Remove urb header */
                data += 4;
                len -= 4;
                        PDEBUG(D_FRAM, "Continuing frame %d copying %d bytes",
                               sd->frame_count, len);
 
-                       gspca_frame_add(gspca_dev, INTER_PACKET, frame,
+                       gspca_frame_add(gspca_dev, INTER_PACKET,
                                        data, len);
                } else if (frame->v4l2_buf.length - cur_frame_len > 0) {
                        /* Add the remaining data up to frame size */
-                       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data,
-                                       frame->v4l2_buf.length - cur_frame_len);
+                       gspca_frame_add(gspca_dev, INTER_PACKET, data,
+                                   frame->v4l2_buf.length - cur_frame_len);
                }
        }
 }
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
                            || data[5 + p] == 0x67) {
                                PDEBUG(D_PACK, "sof offset: %d len: %d",
                                        p, len);
-                               frame = gspca_frame_add(gspca_dev, LAST_PACKET,
-                                                       frame, data, p);
+                               gspca_frame_add(gspca_dev, LAST_PACKET,
+                                               data, p);
 
                                /* put the JPEG header */
-                               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+                               gspca_frame_add(gspca_dev, FIRST_PACKET,
                                        sd->jpeg_hdr, JPEG_HDR_SZ);
                                data += p + 16;
                                len -= p + 16;
                        }
                }
        }
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 
 #include "pac_common.h"
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,    /* target */
-                       __u8 *data,                   /* isoc packet */
-                       int len)                      /* iso packet length */
+                       u8 *data,               /* isoc packet */
+                       int len)                /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
        unsigned char *sof;
                        n -= sizeof pac_sof_marker;
                else
                        n = 0;
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
+               gspca_frame_add(gspca_dev, LAST_PACKET,
                                        data, n);
                /* Start next frame. */
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+               gspca_frame_add(gspca_dev, FIRST_PACKET,
                        pac_sof_marker, sizeof pac_sof_marker);
                len -= sof - data;
                data = sof;
        }
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 /* sub-driver description */
 
 }
 
 static void ov511_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *in,                       /* isoc packet */
-                       int len)                        /* iso packet length */
+                       u8 *in,                 /* isoc packet */
+                       int len)                /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
 
                                return;
                        }
                        /* Add 11 byte footer to frame, might be usefull */
-                       gspca_frame_add(gspca_dev, LAST_PACKET, frame, in, 11);
+                       gspca_frame_add(gspca_dev, LAST_PACKET, in, 11);
                        return;
                } else {
                        /* Frame start */
-                       gspca_frame_add(gspca_dev, FIRST_PACKET, frame, in, 0);
+                       gspca_frame_add(gspca_dev, FIRST_PACKET, in, 0);
                        sd->packet_nr = 0;
                }
        }
        len--;
 
        /* intermediate packet */
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, in, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, in, len);
 }
 
 static void ov518_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
        /* A false positive here is likely, until OVT gives me
         * the definitive SOF/EOF format */
        if ((!(data[0] | data[1] | data[2] | data[3] | data[5])) && data[6]) {
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame, data, 0);
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, 0);
+               gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
+               gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
                sd->packet_nr = 0;
        }
 
        }
 
        /* intermediate packet */
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static void ov519_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        /* Header of ov519 is 16 bytes:
                        len -= HDRSZ;
 #undef HDRSZ
                        if (data[0] == 0xff || data[1] == 0xd8)
-                               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+                               gspca_frame_add(gspca_dev, FIRST_PACKET,
                                                data, len);
                        else
                                gspca_dev->last_packet_type = DISCARD_PACKET;
                case 0x51:              /* end of frame */
                        if (data[9] != 0)
                                gspca_dev->last_packet_type = DISCARD_PACKET;
-                       gspca_frame_add(gspca_dev, LAST_PACKET, frame,
-                                       data, 0);
+                       gspca_frame_add(gspca_dev, LAST_PACKET,
+                                       NULL, 0);
                        return;
                }
        }
 
        /* intermediate packet */
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame,
-                       data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static void ovfx2_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        /* A short read signals EOF */
        if (len < OVFX2_BULK_SIZE) {
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame, data, len);
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame, NULL, 0);
+               gspca_frame_add(gspca_dev, LAST_PACKET, data, len);
+               gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
                return;
        }
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
        switch (sd->bridge) {
        case BRIDGE_OV511:
        case BRIDGE_OV511PLUS:
-               ov511_pkt_scan(gspca_dev, frame, data, len);
+               ov511_pkt_scan(gspca_dev, data, len);
                break;
        case BRIDGE_OV518:
        case BRIDGE_OV518PLUS:
-               ov518_pkt_scan(gspca_dev, frame, data, len);
+               ov518_pkt_scan(gspca_dev, data, len);
                break;
        case BRIDGE_OV519:
-               ov519_pkt_scan(gspca_dev, frame, data, len);
+               ov519_pkt_scan(gspca_dev, data, len);
                break;
        case BRIDGE_OVFX2:
-               ovfx2_pkt_scan(gspca_dev, frame, data, len);
+               ovfx2_pkt_scan(gspca_dev, data, len);
                break;
        case BRIDGE_W9968CF:
-               w9968cf_pkt_scan(gspca_dev, frame, data, len);
+               w9968cf_pkt_scan(gspca_dev, data, len);
                break;
        }
 }
 
 #define UVC_STREAM_EOF (1 << 1)
 #define UVC_STREAM_FID (1 << 0)
 
-static void sd_pkt_scan(struct gspca_dev *gspca_dev, struct gspca_frame *frame,
-                       __u8 *data, int len)
+static void sd_pkt_scan(struct gspca_dev *gspca_dev,
+                       u8 *data, int len)
 {
        struct sd *sd = (struct sd *) gspca_dev;
        __u32 this_pts;
                /* If PTS or FID has changed, start a new frame. */
                if (this_pts != sd->last_pts || this_fid != sd->last_fid) {
                        if (gspca_dev->last_packet_type == INTER_PACKET)
-                               frame = gspca_frame_add(gspca_dev,
-                                                       LAST_PACKET, frame,
-                                                       NULL, 0);
+                               gspca_frame_add(gspca_dev, LAST_PACKET,
+                                               NULL, 0);
                        sd->last_pts = this_pts;
                        sd->last_fid = this_fid;
-                       gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+                       gspca_frame_add(gspca_dev, FIRST_PACKET,
                                        data + 12, len - 12);
                /* If this packet is marked as EOF, end the frame */
                } else if (data[1] & UVC_STREAM_EOF) {
                        sd->last_pts = 0;
-                       frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
-                                               data + 12, len - 12);
+                       gspca_frame_add(gspca_dev, LAST_PACKET,
+                                       data + 12, len - 12);
                } else {
 
                        /* Add the data from this payload */
-                       gspca_frame_add(gspca_dev, INTER_PACKET, frame,
-                                               data + 12, len - 12);
+                       gspca_frame_add(gspca_dev, INTER_PACKET,
+                                       data + 12, len - 12);
                }
 
                /* Done this payload */
 
 discard:
                /* Discard data until a new frame starts. */
-               gspca_frame_add(gspca_dev, DISCARD_PACKET, frame, NULL, 0);
+               gspca_dev->last_packet_type = DISCARD_PACKET;
 
 scan_next:
                remaining_len -= len;
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,
-                       __u8 *data,
+                       u8 *data,
                        int len)
 {
        struct sd *sd = (struct sd *) gspca_dev;
                        n -= sizeof pac_sof_marker;
                else
                        n = 0;
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
-                                       data, n);
+               gspca_frame_add(gspca_dev, LAST_PACKET,
+                               data, n);
                sd->header_read = 0;
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame, NULL, 0);
+               gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
                len -= sof - data;
                data = sof;
        }
                sd->header_read = 11;
        }
 
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static void setbrightness(struct gspca_dev *gspca_dev)
 
 {
        unsigned char tmpbuf[4];
 
-       gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+       gspca_frame_add(gspca_dev, FIRST_PACKET,
                pac_jpeg_header1, sizeof(pac_jpeg_header1));
 
        tmpbuf[0] = lines >> 8;
        tmpbuf[2] = samples_per_line >> 8;
        tmpbuf[3] = samples_per_line & 0xff;
 
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame,
+       gspca_frame_add(gspca_dev, INTER_PACKET,
                tmpbuf, sizeof(tmpbuf));
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame,
+       gspca_frame_add(gspca_dev, INTER_PACKET,
                pac_jpeg_header2, sizeof(pac_jpeg_header2));
 }
 
 /* this function is run at interrupt level */
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
+       struct gspca_frame *frame;
        unsigned char *sof;
 
        sof = pac_find_sof(&sd->sof_read, data, len);
        if (sof) {
                int n, lum_offset, footer_length;
 
+               frame = gspca_get_i_frame(gspca_dev);
+               if (frame == NULL) {
+                       gspca_dev->last_packet_type = DISCARD_PACKET;
+                       return;
+               }
+
                /* 6 bytes after the FF D9 EOF marker a number of lumination
                   bytes are send corresponding to different parts of the
                   image, the 14th and 15th byte after the EOF seem to
                        frame->data_end += n;
                        n = 0;
                }
-               frame = gspca_frame_add(gspca_dev, INTER_PACKET, frame,
+               gspca_frame_add(gspca_dev, INTER_PACKET,
                                        data, n);
                if (gspca_dev->last_packet_type != DISCARD_PACKET &&
                                frame->data_end[-2] == 0xff &&
                                frame->data_end[-1] == 0xd9)
-                       frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
+                       gspca_frame_add(gspca_dev, LAST_PACKET,
                                                NULL, 0);
 
                n = sof - data;
                pac_start_frame(gspca_dev, frame,
                        gspca_dev->width, gspca_dev->height);
        }
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 
 {
        unsigned char tmpbuf[4];
 
-       gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+       gspca_frame_add(gspca_dev, FIRST_PACKET,
                pac_jpeg_header1, sizeof(pac_jpeg_header1));
 
        tmpbuf[0] = lines >> 8;
        tmpbuf[2] = samples_per_line >> 8;
        tmpbuf[3] = samples_per_line & 0xff;
 
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame,
+       gspca_frame_add(gspca_dev, INTER_PACKET,
                tmpbuf, sizeof(tmpbuf));
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame,
+       gspca_frame_add(gspca_dev, INTER_PACKET,
                pac_jpeg_header2, sizeof(pac_jpeg_header2));
 }
 
 /* this function is run at interrupt level */
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
        unsigned char *sof;
+       struct gspca_frame *frame;
 
        sof = pac_find_sof(&sd->sof_read, data, len);
        if (sof) {
                int n, lum_offset, footer_length;
 
+               frame = gspca_get_i_frame(gspca_dev);
+               if (frame == NULL) {
+                       gspca_dev->last_packet_type = DISCARD_PACKET;
+                       return;
+               }
+
                /* 6 bytes after the FF D9 EOF marker a number of lumination
                   bytes are send corresponding to different parts of the
                   image, the 14th and 15th byte after the EOF seem to
                        frame->data_end += n;
                        n = 0;
                }
-               frame = gspca_frame_add(gspca_dev, INTER_PACKET, frame,
+               gspca_frame_add(gspca_dev, INTER_PACKET,
                                        data, n);
                if (gspca_dev->last_packet_type != DISCARD_PACKET &&
                                frame->data_end[-2] == 0xff &&
                                frame->data_end[-1] == 0xd9)
-                       frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
+                       gspca_frame_add(gspca_dev, LAST_PACKET,
                                                NULL, 0);
 
                n = sof - data;
                pac_start_frame(gspca_dev, frame,
                        gspca_dev->height, gspca_dev->width);
        }
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
                        u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
                avg_lum >>= 9;
                atomic_set(&sd->avg_lum, avg_lum);
                gspca_frame_add(gspca_dev, LAST_PACKET,
-                               frame, data, len);
+                               data, len);
                return;
        }
        if (gspca_dev->last_packet_type == LAST_PACKET) {
                if (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv
                                & MODE_JPEG) {
-                       gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+                       gspca_frame_add(gspca_dev, FIRST_PACKET,
                                sd->jpeg_hdr, JPEG_HDR_SZ);
-                       gspca_frame_add(gspca_dev, INTER_PACKET, frame,
+                       gspca_frame_add(gspca_dev, INTER_PACKET,
                                data, len);
                } else {
-                       gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+                       gspca_frame_add(gspca_dev, FIRST_PACKET,
                                data, len);
                }
        } else {
-               gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+               gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
        }
 }
 
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       unsigned char *data,            /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        int i;
                                        pkt_type = DISCARD_PACKET;
                                }
 
-                               frame = gspca_frame_add(gspca_dev, pkt_type,
-                                                       frame, data, 0);
+                               gspca_frame_add(gspca_dev, pkt_type,
+                                               NULL, 0);
                                data += i + fr_h_sz;
                                len -= i + fr_h_sz;
                                gspca_frame_add(gspca_dev, FIRST_PACKET,
-                                               frame, data, len);
+                                               data, len);
                                return;
                        }
                }
        if (cam->cam_mode[gspca_dev->curr_mode].priv & MODE_RAW) {
                /* In raw mode we sometimes get some garbage after the frame
                   ignore this */
-               int used = frame->data_end - frame->data;
+               struct gspca_frame *frame;
+               int used;
                int size = cam->cam_mode[gspca_dev->curr_mode].sizeimage;
 
+               frame = gspca_get_i_frame(gspca_dev);
+               if (frame == NULL) {
+                       gspca_dev->last_packet_type = DISCARD_PACKET;
+                       return;
+               }
+               used = frame->data_end - frame->data;
                if (used + len > size)
                        len = size - used;
        }
 
-       gspca_frame_add(gspca_dev, INTER_PACKET,
-                       frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 
 /* scan the URB packets */
 /* This function is run at interrupt level. */
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
                        u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
 
                /* end of frame */
                gspca_frame_add(gspca_dev, LAST_PACKET,
-                               frame, data, sof + 2);
+                               data, sof + 2);
                if (sd->ag_cnt < 0)
                        return;
 /* w1 w2 w3 */
        if (gspca_dev->last_packet_type == LAST_PACKET) {
 
                /* put the JPEG 422 header */
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+               gspca_frame_add(gspca_dev, FIRST_PACKET,
                        sd->jpeg_hdr, JPEG_HDR_SZ);
        }
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
 /*                     gspca_dev->last_packet_type = DISCARD_PACKET; */
                        return;
                }
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
+               gspca_frame_add(gspca_dev, LAST_PACKET,
                                        ffd9, 2);
 
                /* put the JPEG header in the new frame */
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+               gspca_frame_add(gspca_dev, FIRST_PACKET,
                        sd->jpeg_hdr, JPEG_HDR_SZ);
 
                data += SPCA500_OFFSET_DATA;
        i = 0;
        do {
                if (data[i] == 0xff) {
-                       gspca_frame_add(gspca_dev, INTER_PACKET, frame,
+                       gspca_frame_add(gspca_dev, INTER_PACKET,
                                        data, i + 1);
                        len -= i;
                        data += i;
                }
                i++;
        } while (i < len);
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static void setbrightness(struct gspca_dev *gspca_dev)
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        switch (data[0]) {
        case 0:                         /* start of frame */
-               frame = gspca_frame_add(gspca_dev,
-                                       LAST_PACKET,
-                                       frame,
-                                       data, 0);
+               gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
                data += SPCA501_OFFSET_DATA;
                len -= SPCA501_OFFSET_DATA;
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
-                               data, len);
+               gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
                return;
        case 0xff:                      /* drop */
 /*             gspca_dev->last_packet_type = DISCARD_PACKET; */
        }
        data++;
        len--;
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame,
-                       data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
                        u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        switch (data[0]) {
        case 0:                         /* start of frame */
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
-                                       data, 0);
+               gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
                data += SPCA50X_OFFSET_DATA;
                len -= SPCA50X_OFFSET_DATA;
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
-                               data, len);
+               gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
                break;
        case 0xff:                      /* drop */
                break;
        default:
                data += 1;
                len -= 1;
-               gspca_frame_add(gspca_dev, INTER_PACKET, frame,
-                               data, len);
+               gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
                break;
        }
 }
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        switch (data[0]) {
        case 0:                         /* start of frame */
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
-                                       data, 0);
+               gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
                data += SPCA50X_OFFSET_DATA;
                len -= SPCA50X_OFFSET_DATA;
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
-                               data, len);
+               gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
                break;
        case 0xff:                      /* drop */
 /*             gspca_dev->last_packet_type = DISCARD_PACKET; */
        default:
                data += 1;
                len -= 1;
-               gspca_frame_add(gspca_dev, INTER_PACKET, frame,
-                               data, len);
+               gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
                break;
        }
 }
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
                        u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        switch (data[0]) {
        case 0:                         /* start of frame */
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
-                                       data, 0);
+               gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
                data += SPCA508_OFFSET_DATA;
                len -= SPCA508_OFFSET_DATA;
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
-                               data, len);
+               gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
                break;
        case 0xff:                      /* drop */
                break;
        default:
                data += 1;
                len -= 1;
-               gspca_frame_add(gspca_dev, INTER_PACKET, frame,
-                               data, len);
+               gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
                break;
        }
 }
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame, /* target */
-                       __u8 *data,             /* isoc packet */
+                       u8 *data,               /* isoc packet */
                        int len)                /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
        len--;
        switch (*data++) {                      /* sequence number */
        case 0:                                 /* start of frame */
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
-                                       data, 0);
+               gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
                if (data[1] & 0x10) {
                        /* compressed bayer */
-                       gspca_frame_add(gspca_dev, FIRST_PACKET,
-                                       frame, data, len);
+                       gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
                } else {
                        /* raw bayer (with a header, which we skip) */
                        if (sd->chip_revision == Rev012A) {
                                data += 16;
                                len -= 16;
                        }
-                       gspca_frame_add(gspca_dev, FIRST_PACKET,
-                                               frame, data, len);
+                       gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
                }
                return;
        case 0xff:                      /* drop (empty mpackets) */
                return;
        }
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 /* rev 72a only */
 
 {
        struct sd *dev = container_of(work, struct sd, work_struct);
        struct gspca_dev *gspca_dev = &dev->gspca_dev;
-       struct gspca_frame *frame;
        int bytes_left; /* bytes remaining in current frame. */
        int data_len;   /* size to use for the next read. */
        int header_read; /* true if we have already read the frame header. */
                        } else {
                                packet_type = INTER_PACKET;
                        }
-                       frame = gspca_get_i_frame(gspca_dev);
-                       if (frame) {
-                               frame = gspca_frame_add(gspca_dev, packet_type,
-                                               frame, data, data_len);
-                               /* If entire frame fits in one packet we still
-                                  need to add a LAST_PACKET */
-                               if (packet_type == FIRST_PACKET &&
-                                   bytes_left == 0)
-                                       frame = gspca_frame_add(gspca_dev,
-                                                       LAST_PACKET,
-                                                       frame, data, 0);
-                       }
+                       gspca_frame_add(gspca_dev, packet_type,
+                                       data, data_len);
+                       /* If entire frame fits in one packet we still
+                          need to add a LAST_PACKET */
+                       if (packet_type == FIRST_PACKET &&
+                           bytes_left == 0)
+                               gspca_frame_add(gspca_dev, LAST_PACKET,
+                                               NULL, 0);
                }
                if (gspca_dev->present) {
                        /* acknowledge the frame */
 
 {
        struct sd *dev = container_of(work, struct sd, work_struct);
        struct gspca_dev *gspca_dev = &dev->gspca_dev;
-       struct gspca_frame *frame;
        int bytes_left; /* bytes remaining in current frame. */
        int data_len;   /* size to use for the next read. */
        int act_len;
                PDEBUG(D_STREAM, "bytes_left = 0x%x", bytes_left);
                /* We keep the header. It has other information, too. */
                packet_type = FIRST_PACKET;
-               frame = gspca_get_i_frame(gspca_dev);
-               if (frame)
-                       gspca_frame_add(gspca_dev, packet_type,
-                               frame, buffer, FRAME_HEADER_LEN);
+               gspca_frame_add(gspca_dev, packet_type,
+                               buffer, FRAME_HEADER_LEN);
                while (bytes_left > 0 && gspca_dev->present) {
                        data_len = bytes_left > SQ905C_MAX_TRANSFER ?
                                SQ905C_MAX_TRANSFER : bytes_left;
                                packet_type = LAST_PACKET;
                        else
                                packet_type = INTER_PACKET;
-                       if (frame)
-                               gspca_frame_add(gspca_dev, packet_type,
-                                               frame, buffer, data_len);
+                       gspca_frame_add(gspca_dev, packet_type,
+                                       buffer, data_len);
                }
        }
 quit_stream:
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
         *              (without ending - ff d9)
         */
        if (data[0] == 0xff && data[1] == 0xfe) {
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
-                                       ffd9, 2);
+               gspca_frame_add(gspca_dev, LAST_PACKET,
+                               ffd9, 2);
 
                /* put the JPEG 411 header */
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+               gspca_frame_add(gspca_dev, FIRST_PACKET,
                        sd->jpeg_hdr, JPEG_HDR_SZ);
 
                /* beginning of the frame */
                data += STKHDRSZ;
                len -= STKHDRSZ;
        }
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,
-                       __u8 *data,
+                       u8 *data,
                        int len)
 {
        struct sd *sd = (struct sd *) gspca_dev;
        /* Finish the previous frame, we do this upon reception of the next
           packet, even though it is already complete so that the strange 16
           byte packets send after a corrupt frame can discard it. */
-       frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame, NULL, 0);
+       gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
 
        /* Store the just received frame */
-       gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
 }
 
 /* sub-driver description */
 
  * The 0005 and 0100 chunks seem to appear only in compressed stream.
  */
 static void stv06xx_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
                                sd->to_skip -= skip;
                        }
 
-                       gspca_frame_add(gspca_dev, INTER_PACKET, frame,
+                       gspca_frame_add(gspca_dev, INTER_PACKET,
                                        data, chunk_len);
                        break;
 
 
                        /* Create a new frame, chunk length should be zero */
                        gspca_frame_add(gspca_dev, FIRST_PACKET,
-                                       frame, data, 0);
+                                       NULL, 0);
 
                        if (sd->bridge == BRIDGE_ST6422)
                                sd->to_skip = gspca_dev->width * 4;
                        PDEBUG(D_PACK, "End of frame detected");
 
                        /* Complete the last frame (if any) */
-                       frame = gspca_frame_add(gspca_dev, LAST_PACKET,
-                                               frame, data, 0);
+                       gspca_frame_add(gspca_dev, LAST_PACKET,
+                                       NULL, 0);
 
                        if (chunk_len)
                                PDEBUG(D_ERR, "Chunk length is "
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
                        u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
                break;
        }
        if (sof) {              /* start of frame */
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
-                                       ffd9, 2);
+               gspca_frame_add(gspca_dev, LAST_PACKET,
+                               ffd9, 2);
 
                /* put the JPEG header in the new frame */
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+               gspca_frame_add(gspca_dev, FIRST_PACKET,
                        sd->jpeg_hdr, JPEG_HDR_SZ);
        }
 
        i = 0;
        do {
                if (data[i] == 0xff) {
-                       gspca_frame_add(gspca_dev, INTER_PACKET, frame,
+                       gspca_frame_add(gspca_dev, INTER_PACKET,
                                        data, i + 1);
                        len -= i;
                        data += i;
                }
                i++;
        } while (i < len);
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
                        u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
                /* extra bytes....., could be processed too but would be
                 * a waste of time, right now leave the application and
                 * libjpeg do it for ourserlves.. */
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
+               gspca_frame_add(gspca_dev, LAST_PACKET,
                                        ffd9, 2);
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, len);
+               gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
                return;
        }
 
                 * other's do not include it... */
                len -= 2;
        }
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
         * - 4 bytes
         */
        gspca_frame_add(gspca_dev, packet_type0,
-                       frame, data + 2, gspca_dev->width);
+                       data + 2, gspca_dev->width);
        gspca_frame_add(gspca_dev, packet_type1,
-                       frame, data + gspca_dev->width + 5, gspca_dev->width);
+                       data + gspca_dev->width + 5, gspca_dev->width);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
                        u8 *data,                       /* isoc packet */
                        int len)                        /* iso pkt length */
 {
        if (data[0] == 0xff && data[1] == 0xd8) {
                PDEBUG(D_PACK,
                        "vc032x header packet found len %d", len);
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
-                                               data, 0);
+               gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
                data += sd->image_offset;
                len -= sd->image_offset;
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
-                               data, len);
+               gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
                return;
        }
 
        /* The vc0321 sends some additional data after sending the complete
         * frame, we ignore this. */
-       if (sd->bridge == BRIDGE_VC0321
-           && len > frame->v4l2_buf.length - (frame->data_end - frame->data))
-               len = frame->v4l2_buf.length - (frame->data_end - frame->data);
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       if (sd->bridge == BRIDGE_VC0321) {
+               struct gspca_frame *frame;
+               int l;
+
+               frame = gspca_get_i_frame(gspca_dev);
+               l = frame->data_end - frame->data;
+               if (len > frame->v4l2_buf.length - l)
+                       len = frame->v4l2_buf.length - l;
+       }
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
 
    to be precise it sends: SOI, SOF, DRI, SOS, Y-data, SOS, U-data, SOS,
    V-data, EOI. */
 static void w9968cf_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,      /* target */
-                       __u8 *data,                     /* isoc packet */
+                       u8 *data,                       /* isoc packet */
                        int len)                        /* iso packet length */
 {
        struct sd *sd = (struct sd *) gspca_dev;
                if (len >= 2 &&
                    data[0] == 0xff &&
                    data[1] == 0xd8) {
-                       frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
+                       gspca_frame_add(gspca_dev, LAST_PACKET,
                                        NULL, 0);
-                       gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+                       gspca_frame_add(gspca_dev, FIRST_PACKET,
                                        sd->jpeg_hdr, JPEG_HDR_SZ);
                        /* Strip the ff d8, our own header (which adds
                           huffman and quantization tables) already has this */
        } else {
                /* In UYVY mode an empty packet signals EOF */
                if (gspca_dev->empty_packet) {
-                       frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
+                       gspca_frame_add(gspca_dev, LAST_PACKET,
                                                NULL, 0);
-                       gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+                       gspca_frame_add(gspca_dev, FIRST_PACKET,
                                        NULL, 0);
                        gspca_dev->empty_packet = 0;
                }
        }
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
-                       struct gspca_frame *frame,
-                       __u8 *data,
+                       u8 *data,
                        int len)
 {
        struct sd *sd = (struct sd *) gspca_dev;
 
        if (data[0] == 0xff && data[1] == 0xd8) {       /* start of frame */
-               frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
-                                       data, 0);
+               gspca_frame_add(gspca_dev, LAST_PACKET,
+                                       NULL, 0);
                /* put the JPEG header in the new frame */
-               gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+               gspca_frame_add(gspca_dev, FIRST_PACKET,
                        sd->jpeg_hdr, JPEG_HDR_SZ);
 
                /* remove the webcam's header:
                data += 18;
                len -= 18;
        }
-       gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)