config SOC_CAMERA
        tristate "SoC camera support"
        depends on VIDEO_V4L2 && HAS_DMA
-       select VIDEOBUF_DMA_SG
+       select VIDEOBUF_GEN
        help
          SoC Camera is a common API to several cameras, not connecting
          over a bus like PCI or USB. For example some i2c camera connected
        tristate "PXA27x Quick Capture Interface driver"
        depends on VIDEO_DEV && PXA27x
        select SOC_CAMERA
+       select VIDEOBUF_DMA_SG
        ---help---
          This is a v4l2 driver for the PXA27x Quick Capture Interface
 
 
 
 #include <media/v4l2-common.h>
 #include <media/v4l2-dev.h>
+#include <media/videobuf-dma-sg.h>
 #include <media/soc_camera.h>
 
 #include <linux/videodev2.h>
        .buf_release    = pxa_videobuf_release,
 };
 
+static void pxa_camera_init_videobuf(struct videobuf_queue *q, spinlock_t *lock,
+                             struct soc_camera_device *icd)
+{
+       /* We must pass NULL as dev pointer, then all pci_* dma operations
+        * transform to normal dma_* ones. */
+       videobuf_queue_sg_init(q, &pxa_videobuf_ops, NULL, lock,
+                               V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
+                               sizeof(struct pxa_buffer), icd);
+}
+
 static int mclk_get_divisor(struct pxa_camera_dev *pcdev)
 {
        unsigned int mclk_10khz = pcdev->platform_mclk_10khz;
        .remove         = pxa_camera_remove_device,
        .set_fmt_cap    = pxa_camera_set_fmt_cap,
        .try_fmt_cap    = pxa_camera_try_fmt_cap,
+       .init_videobuf  = pxa_camera_init_videobuf,
        .reqbufs        = pxa_camera_reqbufs,
        .poll           = pxa_camera_poll,
        .querycap       = pxa_camera_querycap,
 /* Should be allocated dynamically too, but we have only one. */
 static struct soc_camera_host pxa_soc_camera_host = {
        .drv_name               = PXA_CAM_DRV_NAME,
-       .vbq_ops                = &pxa_videobuf_ops,
-       .msize                  = sizeof(struct pxa_buffer),
        .ops                    = &pxa_soc_camera_host_ops,
 };
 
 
 
 #include <media/v4l2-common.h>
 #include <media/v4l2-dev.h>
+#include <media/videobuf-core.h>
 #include <media/soc_camera.h>
 
 static LIST_HEAD(hosts);
        file->private_data = icf;
        dev_dbg(&icd->dev, "camera device open\n");
 
-       /* We must pass NULL as dev pointer, then all pci_* dma operations
-        * transform to normal dma_* ones. */
-       videobuf_queue_sg_init(&icf->vb_vidq, ici->vbq_ops, NULL, icf->lock,
-                               V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
-                               ici->msize, icd);
+       ici->ops->init_videobuf(&icf->vb_vidq, icf->lock, icd);
 
        return 0;
 
        int ret;
        struct soc_camera_host *ix;
 
-       if (!ici->vbq_ops || !ici->ops->add || !ici->ops->remove)
+       if (!ici->ops->init_videobuf || !ici->ops->add || !ici->ops->remove)
                return -EINVAL;
 
        /* Number might be equal to the platform device ID */
 
 #define SOC_CAMERA_H
 
 #include <linux/videodev2.h>
-#include <media/videobuf-dma-sg.h>
+#include <media/videobuf-core.h>
 
 struct soc_camera_device {
        struct list_head list;
        struct list_head list;
        struct device dev;
        unsigned char nr;                               /* Host number */
-       size_t msize;
-       struct videobuf_queue_ops *vbq_ops;
        void *priv;
        char *drv_name;
        struct soc_camera_host_ops *ops;
        int (*set_fmt_cap)(struct soc_camera_device *, __u32,
                           struct v4l2_rect *);
        int (*try_fmt_cap)(struct soc_camera_device *, struct v4l2_format *);
+       void (*init_videobuf)(struct videobuf_queue*, spinlock_t *,
+                             struct soc_camera_device *);
        int (*reqbufs)(struct soc_camera_file *, struct v4l2_requestbuffers *);
        int (*querycap)(struct soc_camera_host *, struct v4l2_capability *);
        int (*try_bus_param)(struct soc_camera_device *, __u32);