OMAP2 camera and TCM825x sensor drivers

Signed-off-by Sakari Ailus <[email protected]>

---
 drivers/media/video/omap/omap24xxcam-sensor.c |    6 ++++--
 drivers/media/video/omap/omap24xxcam.c        |   12 +++++++-----
 drivers/media/video/omap/omap24xxcam.h        |    2 +-
 3 files changed, 12 insertions(+), 8 deletions(-)

I think you have not looked at patches posted by me about OMAP2420 camera. Part of the changes are taken from N800 kernel tree and TI's tree. Those sensor interface changes are also changed to adapt TI Micron sensor. I believe you should have worked on those changes and modified sensor interface for N800. Why re-work?

http://linux.omap.com/pipermail/linux-omap-open-source/2007-February/009062.html

http://linux.omap.com/pipermail/linux-omap-open-source/2007-February/009063.html

http://linux.omap.com/pipermail/linux-omap-open-source/2007-February/009069.html

http://linux.omap.com/pipermail/linux-omap-open-source/2007-February/009064.html

http://linux.omap.com/pipermail/linux-omap-open-source/2007-February/009065.html

Please help me to review above patches instead, then we will have less re-work and come to conclusion, whose patches should be integrated instead. BTW, I have N800 so I can test this sensor now.

This is a modified version of the camera driver originally from Montavista.

Signed-off-by Sakari Ailus <[email protected]>

---
 drivers/media/video/omap/Makefile             |    1 +
 drivers/media/video/omap/omap24xxcam-core.c   |  202 ++++
 drivers/media/video/omap/omap24xxcam-dma.c    |  320 +++++++
 drivers/media/video/omap/omap24xxcam-dma.h    |   65 ++
 drivers/media/video/omap/omap24xxcam-dmahw.c  |  224 +++++
 drivers/media/video/omap/omap24xxcam-sensor.c |  226 +++++
 drivers/media/video/omap/omap24xxcam-sgdma.c  |  298 ++++++
 drivers/media/video/omap/omap24xxcam-vbq.c    |  370 ++++++++

drivers/media/video/omap/omap24xxcam.c | 1216 > +

drivers/media/video/omap/omap24xxcam-core.c new file +11 -0

+#include "omap24xxcam.h"
+
+/* Program the camera interface xclk for the frequency cam->img.xclk based on
+ * the functional clock frequency cam->img.mclk.  If the specifed cam->img.xclk
+ * frequency is not possible based on the value of cam->img.mclk, then the
+ * closest xclk frequency lower than the specified xclk will be selected.
+ * The actual xclk frequency is returned in cam->img.xclk.  If cam->img.xclk is zero,
+ * then xclk is turned off (stable low value).
+ */
+
+void omap24xxcam_core_init(struct omap24xxcam_core *core,

drivers/media/video/omap/omap24xxcam-core.c new file +17 -0

+
+/* Interrupt service routine for camera core interrupts. */
+void omap24xxcam_core_isr(struct omap24xxcam_core *core)
+{
+       unsigned long cc_irqstatus;
+       const unsigned long cc_irqstatus_err =
+               CC_IRQSTATUS_FW_ERR_IRQ
+               | CC_IRQSTATUS_FSC_ERR_IRQ
+               | CC_IRQSTATUS_SSC_ERR_IRQ
+               | CC_IRQSTATUS_FIFO_UF_IRQ
+               | CC_IRQSTATUS_FIFO_OF_IRQ;
+
+       DBG;
+
+       cc_irqstatus = omap24xxcam_reg_in(core->base, CC_IRQSTATUS);
+       omap24xxcam_reg_out(core->base, CC_IRQSTATUS, cc_irqstatus);
+

drivers/media/video/omap/omap24xxcam-dma.c new file +0 -0

new file mode 100644
index 0000000..d10f1c8
@@ -0,0 +1,320 @@

drivers/media/video/omap/omap24xxcam-dmahw.c new file +8 -0

+ *
+ * Video-for-Linux (Version 2) camera capture driver for
+ * the OMAP24xx camera controller.
+ *
+ * Author: David Cohen <[email protected]>
+ * Based on: omap24xxcam.c by Andy Lowe ([email protected])
+ *
+ * Copyright (C) 2004 MontaVista Software, Inc.

drivers/media/video/omap/omap24xxcam-dmahw.c new file +12 -0

+
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/smp_lock.h>
+#include <linux/types.h>
+#include <linux/wait.h>
+#include <linux/videodev.h>
+#include <linux/pci.h>         /* needed for videobufs */

drivers/media/video/omap/omap24xxcam-dmahw.c new file +21 -0

+               csr = omap24xxcam_reg_in(base, CAMDMA_CSR(i));
+               /* ack interrupt in CSR */
+               omap24xxcam_reg_out(base, CAMDMA_CSR(i), csr);
+       }
+       omap24xxcam_reg_out(base, CAMDMA_IRQSTATUS_L0, 0xffffffff);
+}
+
+/* Ack dmach on CSR and IRQSTATUS_L0 */
+unsigned long omap24xxcam_dmahw_ack_ch(unsigned long base, int dmach)
+{
+       unsigned long csr;
+
+       csr = omap24xxcam_reg_in(base, CAMDMA_CSR(dmach));
+       /* ack interrupt in CSR */
+       omap24xxcam_reg_out(base, CAMDMA_CSR(dmach), csr);
+       /* ack interrupt in IRQSTATUS */
+       omap24xxcam_reg_out(base, CAMDMA_IRQSTATUS_L0, (1 << dmach));
+
+       return csr;
+}
+

drivers/media/video/omap/omap24xxcam-sensor.c new file +19 -0

+ *
+ * Video-for-Linux (Version 2) camera capture driver for
+ * the OMAP24xx camera controller.
+ *
+ * Author: David Cohen <[email protected]>
+ * Based on: omap24xxcam.c by Andy Lowe ([email protected])
+ *
+ * Copyright (C) 2004 MontaVista Software, Inc.
+ * Copyright (C) 2004 Texas Instruments.
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ *
+ * History:
+ * 2005/nov - David Cohen <[email protected]>
+ *            Updated the driver for the Linux Device Model and new version of V4L2.
+ */
+

drivers/media/video/omap/omap24xxcam-sensor.c new file +5 -0

+
+       omap24xxcam_sensor_disable(cam);
+
+       omap24xxcam_sensor_enable(cam);
+}

drivers/media/video/omap/omap24xxcam-sensor.c new file +15 -0

+
+/* This should be called by the sensor code whenever it's ready */
+int omap24xxcam_sensor_register(struct omap_camera *oc,
+                               struct omap_camera_sensor *os)
+{
+       struct omap24xxcam_device *cam = oc->priv;
+       int rval;
+
+       /* the device has not been initialised yet */
+       if (cam == NULL)
+               return -ENODEV;
+       if (os == NULL)
+               return -EINVAL;
+       if (cam->sensor != NULL)
+               return -EBUSY;

drivers/media/video/omap/omap24xxcam-sensor.c new file +13 -0

+
+void omap24xxcam_sensor_unregister(struct omap_camera *oc,
+                                  struct omap_camera_sensor *os)
+{
+       struct omap24xxcam_device *cam = oc->priv;
+
+       BUG_ON(cam->users != 0);
+       BUG_ON(cam->sensor == NULL);
+
+       cam->sensor = NULL;
+}
+
+EXPORT_SYMBOL(omap24xxcam_sensor_unregister);

drivers/media/video/omap/omap24xxcam-sgdma.c new file +1 -0

new file mode 100644
index 0000000..0243a59
@@ -0,0 +1,298 @@
+/*

drivers/media/video/omap/omap24xxcam-sgdma.c new file +32 -0

+/* Sync scatter-gather DMA by aborting any DMA transfers currently in progress.
+ * Any queued scatter-gather DMA transactions that have not yet been started
+ * will remain queued.  The DMA controller will be idle after this routine
+ * completes.  When the scatter-gather queue is restarted, the next
+ * scatter-gather DMA transfer will begin at the start of a new transaction.
+ */
+void
+omap24xxcam_sgdma_sync(struct omap24xxcam_sgdma *sgdma, unsigned long csr)
+{
+       unsigned long irqflags;
+       int sgslot;
+       struct sgdma_state *sg_state;
+
+       DBG;
+
+       /* stop any DMA transfers in progress */
+       omap24xxcam_dma_stop(&sgdma->dma, csr);
+
+       spin_lock_irqsave(&sgdma->lock, irqflags);
+
+       if (sgdma->free_sgdma < NUM_SG_DMA) {
+               sgslot = (sgdma->next_sgdma + sgdma->free_sgdma) % NUM_SG_DMA;
+               sg_state = sgdma->sg_state + sgslot;
+               if (sg_state->next_sglist != 0) {
+                       /* This DMA transfer was in progress, so abort it. */
+                       sgdma_callback_t callback = sg_state->callback;
+                       void *arg = sg_state->arg;
+                       sgdma->free_sgdma++;
+                       if (callback) {
+                               /* leave interrupts masked */
+                               spin_unlock(&sgdma->lock);
+                               (*callback) (sgdma, csr, arg);

drivers/media/video/omap/omap24xxcam-vbq.c new file +4 -0

new file mode 100644
index 0000000..f6d8803
@@ -0,0 +1,370 @@
+/*
+ * OMAP 24xx camera high-level DMA (not hardware) and scatter-gather
+ * DMA handling
+ *

drivers/media/video/omap/omap24xxcam.c new file +45 -0

new file mode 100644
index 0000000..4f954ed
@@ -0,0 +1,1216 @@
+/*
+ * drivers/media/video/omap/omap24xxcam.c
+ *
+ * Video-for-Linux (Version 2) camera capture driver for
+ * the OMAP24xx camera controller.
+ *
+ * Author: Andy Lowe ([email protected])
+ *
+ * Copyright (C) 2004 MontaVista Software, Inc.
+ * Copyright (C) 2004 Texas Instruments.
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ *
+ * History:
+ * 2005/nov - David Cohen <[email protected]>
+ *            Updated the driver for the Linux Device Model and new version of V4L2.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/delay.h>
+#include <linux/timer.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/smp_lock.h>
+#include <linux/interrupt.h>
+#include <linux/kdev_t.h>
+#include <linux/types.h>
+#include <linux/wait.h>
+#include <linux/i2c.h>
+#include <linux/videodev2.h>
+#include <linux/pci.h>         /* needed for videobufs */
+#include <linux/dma-mapping.h>
+#include <linux/device.h>
+#include <linux/input.h>
+#include <linux/version.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>

drivers/media/video/omap/omap24xxcam.c new file +8 -0

+
+#include "omap24xxcam.h"
+#include "omap24xxcam-dma.h"
+
+#include "sensor_if.h"
+
+/* configuration macros */
+

drivers/media/video/omap/omap24xxcam.c new file +17 -0

+
+static int
+omap24xxcam_mmap(struct file *file, struct vm_area_struct *vma)
+{
+       struct omap24xxcam_fh *fh = file->private_data;
+       int err;
+
+       /* let the video-buf mapper check arguments and set-up structures */
+       err = videobuf_mmap_mapper(&fh->vbq, vma);
+       if (err)
+               goto err1;
+
+       vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+
+       /* do mapping to our allocated buffers */
+       err = omap24xxcam_mmap_buffers(file, vma);
+       if (err)

drivers/media/video/omap/omap24xxcam.c new file +4 -0

+
+       clk_put(cam->img.ick);
+       clk_put(cam->img.fck);
+}

drivers/media/video/omap/omap24xxcam.c new file +45 -0

+
+       if (video_register_device(vfd, VFL_TYPE_GRABBER, video_nr) < 0) {
+               printk(KERN_ERR CAM_NAME
+                      ": could not register Video for Linux device\n");
+               vfd->minor = -1;
+               rval = -EBUSY;
+               goto err;
+       }
+
+       printk(KERN_INFO CAM_NAME
+              ": registered device video%d [v4l2]\n", vfd->minor);
+
+       return 0;
+
+err:
+       omap24xxcam_device_disable(cam);
+
+       return rval;
+}
+
+void omap24xxcam_device_disable(struct omap24xxcam_device *cam)
+{
+       omap24xxcam_sensor_exit(cam);
+
+       if (cam->vfd) {
+               if (cam->vfd->minor == -1) {
+                       /* The device was never registered, so release the
+                        * video_device struct directly.
+                        */
+                       video_device_release(cam->vfd);
+               } else {
+                       /* The unregister function will release the video_device
+                        * struct as well as unregistering it.
+                        */
+                       video_unregister_device(cam->vfd);
+               }
+               cam->vfd = NULL;
+       }
+}
+
+static int omap24xxcam_probe(struct platform_device *pdev)
+{
+       struct omap24xxcam_device *cam;
+       DBG;
+

drivers/media/video/omap/omap24xxcam.c new file +11 -0

+
+       /* set driver specific data to use in power management functions */
+       platform_set_drvdata(pdev, cam);
+
+       mutex_init(&cam->mutex);
+       cam->users = 0;
+
+       cam->camera_block_alive = 1;
+
+       omap24xxcam_device_enable(cam);
+

drivers/media/video/omap/omap24xxcam.c new file +34 -0

+
+       if (!cam)
+               return 0;
+
+       omap24xxcam_device_disable(cam);
+
+       if (cam->irq) {
+               free_irq(cam->irq, cam);
+               cam->irq = 0;
+       }
+
+       omap24xxcam_sgdma_exit(&cam->sgdma);
+       omap24xxcam_core_exit(&cam->core);
+
+       omap24xxcam_clock_off(cam);
+       omap24xxcam_clock_put(cam);
+
+       if (cam->mmio_base) {
+               iounmap((void *)cam->mmio_base);
+               cam->mmio_base = 0;
+       }
+
+       if (cam->mmio_base_phys) {
+               release_mem_region(cam->mmio_base_phys,
+                                  cam->mmio_size);
+               cam->mmio_base_phys = 0;
+       }
+
+       kfree(cam);
+       camera_module = NULL;
+
+       return 0;
+}
+

drivers/media/video/omap/omap24xxcam.h new file +22 -0

+ *
+ * Video-for-Linux (Version 2) camera capture driver for
+ * the OMAP24xx camera controller.
+ *
+ * Author: Andy Lowe ([email protected])
+ *
+ * Copyright (C) 2004 MontaVista Software, Inc.
+ * Copyright (C) 2004 Texas Instruments.
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+
+#ifndef OMAP24XXCAM_H
+#define OMAP24XXCAM_H
+
+#include "sensor_if.h"
+
+//#define DEBUG_CAM
+
+#define CAM_NAME       "omap24xxcam"

Quoted 21 lines · Sakari Ailus

drivers/media/video/omap/omap24xxcam-sensor.c new file +21 -0

+
+/* This should be called by the sensor code whenever it's ready */
+int omap24xxcam_sensor_register(struct omap_camera *oc,
+                               struct omap_camera_sensor *os)
+{
+       struct omap24xxcam_device *cam = oc->priv;
+       int rval;
+
+       /* the device has not been initialised yet */
+       if (cam == NULL)
+               return -ENODEV;
+       if (os == NULL)
+               return -EINVAL;
+       if (cam->sensor != NULL)
+               return -EBUSY;
+
+       cam->sensor = os;
+       rval = omap24xxcam_device_enable(cam);
+
+       if (rval)
+               cam->sensor = NULL;

drivers/media/video/omap/omap24xxcam-sensor.c line 213

Quoted 4 lines

drivers/media/video/omap/omap24xxcam-sensor.c new file +4 -0

+       return rval;
+}
+
+EXPORT_SYMBOL(omap24xxcam_sensor_register);

What registration functionality is done above? I can see only checking against the sensor initialization and enabling it if not. Please use proper name.

Quoted 5 lines

drivers/media/video/omap/omap24xxcam.c new file +0 -0

new file mode 100644
index 0000000..4f954ed

drivers/media/video/omap/omap24xxcam.c line 712

Quoted 5 lines

drivers/media/video/omap/omap24xxcam.c new file +5 -0

+
+static void omap24xxcam_clock_put(struct omap24xxcam_device *cam)
+{
+       if (cam->img.ick == NULL)
+               return;

What about img.fck check ?

Quoted 4 lines

drivers/media/video/omap/omap24xxcam.c new file +4 -0

+
+        */
+       /* choose an arbitrary xclk frequency */
+       omap24xxcam_core_xclk_set(&cam->core, 12000000);

drivers/media/video/omap/omap24xxcam.c line 974

Quoted 6 lines

drivers/media/video/omap/omap24xxcam.c new file +6 -0

+
+       omap24xxcam_camera.priv = cam;
+
+       if ((rval = omap24xxcam_sensor_init(cam))) {
+               goto err;
+       }

No need of { }. Also please use proper goto labels as suggested earlier.

drivers/media/video/omap/omap24xxcam.c line 1096

Quoted 10 lines

drivers/media/video/omap/omap24xxcam.c new file +6 -0

+
+       /* install the interrupt service routine */
+       if (request_irq(INT_24XX_CAM_IRQ, omap24xxcam_isr, IRQF_DISABLED,
+                       CAM_NAME, cam)) {
+               printk(KERN_ERR CAM_NAME
+                      ": could not install interrupt service 

routine\n");

drivers/media/video/omap/omap24xxcam.c new file +3 -0

+               goto err;
+       }
+       cam->irq = INT_24XX_CAM_IRQ;

Please make proper use of platform_data and resources. irq should have come from device.c registration of platform resource. Please check my patches.

http://linux.omap.com/pipermail/linux-omap-open-source/2007-February/009064.html

-----Original Message-----
From: [email protected] [mailto:[email protected]]

Behalf Of Sakari Ailus
Sent: Wednesday, February 28, 2007 9:59 AM
To: [email protected]
Subject: [PATCH] ARM: OMAP2: Camera: Add OMAP2 24xx camera driver.

This is a modified version of the camera driver originally from

Signed-off-by Sakari Ailus <[email protected]>

---

drivers/media/video/omap/Makefile             |    1 +
drivers/media/video/omap/omap24xxcam-core.c   |  202 ++++
drivers/media/video/omap/omap24xxcam-dma.c    |  320 +++++++
drivers/media/video/omap/omap24xxcam-dma.h    |   65 ++
drivers/media/video/omap/omap24xxcam-dmahw.c  |  224 +++++
drivers/media/video/omap/omap24xxcam-sensor.c |  226 +++++
drivers/media/video/omap/omap24xxcam-sgdma.c  |  298 ++++++
drivers/media/video/omap/omap24xxcam-vbq.c    |  370 ++++++++
drivers/media/video/omap/omap24xxcam.c        | 1216
+++++++++++++++++++++++++
drivers/media/video/omap/omap24xxcam.h        |  659 +++++++++++++
10 files changed, 3581 insertions(+), 0 deletions(-)

create mode 100644 drivers/media/video/omap/omap24xxcam-core.c create mode 100644 drivers/media/video/omap/omap24xxcam-dma.c create mode 100644 drivers/media/video/omap/omap24xxcam-dma.h create mode 100644 drivers/media/video/omap/omap24xxcam-dmahw.c create mode 100644 drivers/media/video/omap/omap24xxcam-sensor.c create mode 100644 drivers/media/video/omap/omap24xxcam-sgdma.c create mode 100644 drivers/media/video/omap/omap24xxcam-vbq.c create mode 100644 drivers/media/video/omap/omap24xxcam.c create mode 100644 drivers/media/video/omap/omap24xxcam.h

drivers/media/video/omap/Makefile +0 -0

index 36ae615..4ca1d1d 100644
@@ -4,6 +4,7 @@ obj-$(CONFIG_VIDEO_OMAP_CAMERA) += omapcamera.o

obj-$(CONFIG_VIDEO_CAMERA_SENSOR_OV9640) += sensor_ov9640.o

objs-y$(CONFIG_ARCH_OMAP16XX) += omap16xxcam.o camera_core.o +objs-y$(CONFIG_ARCH_OMAP24XX) += omap24xxcam.o omap24xxcam-sgdma.o omap24xxcam-dma.o omap24xxcam-dmahw.o omap24xxcam-core.o omap24xxcam- sensor.o omap24xxcam-vbq.o
objs-y$(CONFIG_MACH_OMAP_H3) += h3_sensor_power.o objs-y$(CONFIG_MACH_OMAP_H4) += h4_sensor_power.o

drivers/media/video/omap/omap24xxcam-core.c new file +42 -0

new file mode 100644
index 0000000..1e30768
@@ -0,0 +1,202 @@
+/*
+ * OMAP 24xx camera high-level DMA (not hardware) and scatter-gather
+ * DMA handling
+ *
+ * Author: Andy Lowe ([email protected])
+ *
+ * Copyright (C) 2004 MontaVista Software, Inc.
+ * Copyright (C) 2004 Texas Instruments.
+ * Copyright (C) 2007 Nokia Corporation.
+ *
+ * Contact: Sakari Ailus <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/smp_lock.h>
+#include <linux/types.h>
+#include <linux/wait.h>
+#include <linux/videodev.h>
+#include <linux/pci.h>		/* needed for videobufs */
+#include <media/video-buf.h>
+#include <linux/dma-mapping.h>
+#include <linux/input.h>
+#include <linux/version.h>

on
+ * the functional clock frequency cam->img.mclk. If the specifed cam-

Quoted 1 line

img.xclk

+ * frequency is not possible based on the value of cam->img.mclk, then

+ * closest xclk frequency lower than the specified xclk will be

drivers/media/video/omap/omap24xxcam-core.c new file +11 -0

+
+	core->xclk_enabled = 0;
+}
+
+void omap24xxcam_core_exit(const struct omap24xxcam_core *core)
+{
+}
+
+/* Enable the camera core interface. */
+void omap24xxcam_core_enable(struct omap24xxcam_core *core)
+{

drivers/media/video/omap/omap24xxcam-core.c new file +35 -0

+
+	/* enable the camera interface */
+	omap24xxcam_reg_out(core->base, CC_CTRL,
+		   CC_CTRL_NOBT_SYNCHRO
+		   | CC_CTRL_PAR_MODE_NOBT8
+		   | CC_CTRL_CC_EN);
+
+	if (core->xclk_enabled)
+		omap24xxcam_core_xclk_enable(core);
+}
+
+void omap24xxcam_core_disable(struct omap24xxcam_core *core)
+{
+	omap24xxcam_reg_out(core->base, CC_CTRL, 0);
+	omap24xxcam_reg_out(core->base, CC_CTRL, CC_CTRL_CC_RST);
+}
+
+void omap24xxcam_core_enable_callback(struct omap24xxcam_device *cam)
+{
+	omap24xxcam_core_enable(&cam->core);
+}
+/* reset core fifo and dma */
+/* void omap24xxcam_core_reset(struct omap24xxcam_device *cam) */
+/* { */
+/* 	omap24xxcam_reg_out(cam, CC_CTRL, CC_CTRL_CC_RST); */
+/* } */
+
+/* Interrupt service routine for camera core interrupts. */
+void omap24xxcam_core_isr(struct omap24xxcam_core *core)
+{
+	unsigned long cc_irqstatus;
+	const unsigned long cc_irqstatus_err =
+		CC_IRQSTATUS_FW_ERR_IRQ
+		| CC_IRQSTATUS_FSC_ERR_IRQ
+		| CC_IRQSTATUS_SSC_ERR_IRQ

drivers/media/video/omap/omap24xxcam-core.c new file +8 -0

+	} else {
+		if (cc_irqstatus & 0xffff)
+			printk("%s: cc_irqstatus 0x%lx\n",
+			       __FUNCTION__, cc_irqstatus);
+	}
+
+}
+

drivers/media/video/omap/omap24xxcam-core.c new file +44 -0

+	} else
+		omap24xxcam_reg_out(core->base, CC_CTRL_XCLK,
+			   CC_CTRL_XCLK_DIV_STABLE_LOW);
+
+}
+
+void omap24xxcam_core_xclk_enable(struct omap24xxcam_core *core)
+{
+	core->xclk_enabled = 1;
+	xclk_set(core);
+}
+
+void omap24xxcam_core_xclk_disable(struct omap24xxcam_core *core)
+{
+
+	core->xclk_enabled = 0;
+	xclk_set(core);
+}
+
+void omap24xxcam_core_xclk_set(struct omap24xxcam_core *core,
+			       unsigned long xclk)
+{
+	unsigned long divisor;
+
+	DBG;
+
+	if (xclk > core->mclk)
+		xclk = core->mclk;
+
+	divisor = core->mclk / xclk;
+	if (xclk * divisor < core->mclk)
+		divisor += 1;
+	if (divisor > 30)
+		divisor = 30;
+	core->xclk = core->mclk / divisor;
+
+	xclk_set(core);
+}
+
+void omap24xxcam_core_mclk_set(struct omap24xxcam_core *core,
+			       unsigned long mclk)
+{
+	core->mclk = mclk;
+}

drivers/media/video/omap/omap24xxcam-dma.c new file +3 -0

new file mode 100644
index 0000000..d10f1c8
@@ -0,0 +1,320 @@
+/*
+ * drivers/media/video/omap/omap24xxcam-dma.c
+ *

drivers/media/video/omap/omap24xxcam-dma.c new file +5 -0

+ * kind, whether express or implied.
+ *
+ * History:
+ * 2005/nov - David Cohen <[email protected]>
+ *            Updated the driver for the Linux Device Model and new

version of V4L2.
+ */

drivers/media/video/omap/omap24xxcam-dma.c new file +22 -0

+
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/smp_lock.h>
+#include <linux/types.h>
+#include <linux/wait.h>
+#include <linux/videodev.h>
+#include <linux/pci.h>		/* needed for videobufs */
+#include <media/video-buf.h>
+#include <linux/dma-mapping.h>
+#include <linux/input.h>
+#include <linux/version.h>
+
+#include <asm/io.h>
+#include <asm/byteorder.h>
+#include <asm/scatterlist.h>
+#include <asm/irq.h>
+#include <asm/semaphore.h>

all
+ * DMA channels are already in use or starting is currently inhibited.
+ */

drivers/media/video/omap/omap24xxcam-dma.c new file +19 -0

+int
+omap24xxcam_dma_start(struct omap24xxcam_dma *dma, dma_addr_t start,
+	unsigned long len, dma_callback_t callback, void *arg)
+{
+	unsigned long irqflags;
+	int dmach;
+	void (*dma_notify)(struct omap24xxcam_device *cam);
+
+	DBG;
+
+	spin_lock_irqsave(&dma->lock, irqflags);
+
+	if (!dma->free_dmach || dma->dma_stop) {
+		spin_unlock_irqrestore(&dma->lock, irqflags);
+		DBG_MID(3);
+		return -EBUSY;
+	}
+
+	dmach = dma->next_dmach;

drivers/media/video/omap/omap24xxcam-dma.c new file +15 -0

+		 * now.
+		 */
+		omap24xxcam_dmahw_transfer_start(dma->base, dmach);
+	}
+
+	dma->next_dmach = (dma->next_dmach + 1) % NUM_CAMDMA_CHANNELS;
+	dma->free_dmach--;
+
+	dma_notify = dma->dma_notify;
+	dma->dma_notify = NULL;
+
+	spin_unlock_irqrestore(&dma->lock, irqflags);
+
+	if (dma_notify)
+		(*dma_notify)(container_of(container_of(dma, struct

omap24xxcam_sgdma, dma), struct omap24xxcam_device, sgdma));

and
+ * the DMA controller is idle, the completion routines for any aborted transfers
+ * will be called in sequence. The DMA controller may not be idle

this
+ * routine completes, because the completion routines might start new transfers.
+ */

drivers/media/video/omap/omap24xxcam-dma.c new file +4 -0

+void
+omap24xxcam_dma_abort(struct omap24xxcam_dma *dma, unsigned long csr)
+{
+	unsigned long irqflags;

drivers/media/video/omap/omap24xxcam-dma.c new file +13 -0

+	 * started before this routine was called.
+	 */
+	free_dmach = dma->free_dmach;
+	while ((dma->free_dmach < NUM_CAMDMA_CHANNELS) &&
+	       (free_dmach < NUM_CAMDMA_CHANNELS)) {
+		dmach = (dma->next_dmach + dma->free_dmach)
+		    % NUM_CAMDMA_CHANNELS;
+		callback = dma->ch_state[dmach].callback;
+		arg = dma->ch_state[dmach].arg;
+		dma->free_dmach++;
+		free_dmach++;
+		if (callback) {
+			/* leave interrupts disabled during callback */

and
+ * the DMA controller is idle, the completion routines for any aborted transfers
+ * will be called in sequence. If the completion routines attempt to start a
+ * new DMA transfer it will fail, so the DMA controller will be idle

this
+ * routine completes.
+ */

drivers/media/video/omap/omap24xxcam-dma.c new file +7 -0

+void
+omap24xxcam_dma_stop(struct omap24xxcam_dma *dma, unsigned long csr)
+{
+	unsigned long irqflags;
+
+	DBG;
+

is
+ * started. The purpose of this is to allow the camera interface to

+ * started only after a DMA transaction has been queued in order to

+ * DMA overruns. The registered callback routine will only be called

+ * time and then discarded. Only one callback routine may be

drivers/media/video/omap/omap24xxcam-dma.c new file +26 -0

+{
+	unsigned long irqflags;
+
+	DBG;
+
+	spin_lock_irqsave(&dma->lock, irqflags);
+
+	if (dma->dma_notify && (dma->dma_notify != callback)) {
+		spin_unlock_irqrestore(&dma->lock, irqflags);
+		return -EBUSY;
+	}
+
+	dma->dma_notify = callback;
+
+	spin_unlock_irqrestore(&dma->lock, irqflags);
+
+	return 0;
+}
+
+/* Camera DMA interrupt service routine. */
+void omap24xxcam_dma_isr(struct omap24xxcam_dma *dma)
+{
+	int dmach;
+	dma_callback_t callback;
+	void *arg;
+	unsigned long csr;

drivers/media/video/omap/omap24xxcam-dma.c new file +10 -0

+			 * progress.
+			 */
+			spin_unlock(&dma->lock);
+			omap24xxcam_dma_stop(dma, csr);
+			return;
+		} else {
+			callback = dma->ch_state[dmach].callback;
+			arg = dma->ch_state[dmach].arg;
+			dma->free_dmach++;
+			if (callback) {

drivers/media/video/omap/omap24xxcam-dma.c new file +53 -0

+{
+	int ch;
+
+	DBG;
+
+	/* group all channels on DMA IRQ0 and unmask irq */
+	spin_lock_init(&dma->lock);
+	dma->base = base;
+	dma->free_dmach = NUM_CAMDMA_CHANNELS;
+	dma->next_dmach = 0;
+	for (ch = 0; ch < NUM_CAMDMA_CHANNELS; ch++) {
+		dma->ch_state[ch].callback = NULL;
+		dma->ch_state[ch].arg = NULL;
+	}
+}
+
+/* Shutdown the camera DMA driver and controller. */
+void
+omap24xxcam_dma_exit(struct omap24xxcam_dma *dma)
+{
+	DBG;
+
+	omap24xxcam_dma_disable(dma);
+}
+
+void omap24xxcam_dma_enable(struct omap24xxcam_dma *dma)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&dma->lock, flags);
+
+	omap24xxcam_dmahw_init(dma->base);
+	omap24xxcam_dmahw_unmask_irq0(dma->base);
+
+	spin_unlock_irqrestore(&dma->lock, flags);
+}
+
+void omap24xxcam_dma_disable(struct omap24xxcam_dma *dma)
+{
+	int ch;
+	unsigned long flags;
+
+	spin_lock_irqsave(&dma->lock, flags);
+
+	/* Mask all DMA interrupts */
+	omap24xxcam_dmahw_mask_all(dma->base);
+
+	/* disable all DMA channels */
+	for (ch = 0; ch < NUM_CAMDMA_CHANNELS; ch++)
+		omap24xxcam_dmahw_disable_ch(dma->base, ch);
+
+	spin_unlock_irqrestore(&dma->lock, flags);
+}

drivers/media/video/omap/omap24xxcam-dma.h new file +0 -0

new file mode 100644
index 0000000..5898fd9

drivers/media/video/omap/omap24xxcam-dma.h new file +3 -0

+			 sgdma_callback_t callback, void *arg);
+void
+omap24xxcam_sgdma_sync(struct omap24xxcam_sgdma *sgdma, unsigned long

csr);
+void omap24xxcam_sgdma_init(struct omap24xxcam_sgdma *sgdma, unsigned

drivers/media/video/omap/omap24xxcam-dma.h new file +7 -0

+void omap24xxcam_dma_isr(struct omap24xxcam_dma *dma);
+void
+omap24xxcam_dma_init(struct omap24xxcam_dma *dma, unsigned long base);
+void
+omap24xxcam_dma_exit(struct omap24xxcam_dma *dma);
+void
+omap24xxcam_dma_enable(struct omap24xxcam_dma *dma);

drivers/media/video/omap/omap24xxcam-dma.h new file +10 -0

+void omap24xxcam_dmahw_transfer_chain(unsigned long base, int dmach,
+				      int free_dmach);
+void omap24xxcam_dmahw_transfer_start(unsigned long base, int dmach);
+void
+omap24xxcam_dmahw_abort_ch(unsigned long base, int dmach);
+void omap24xxcam_dmahw_mask_all(unsigned long base);
+void omap24xxcam_dmahw_unmask_irq0(unsigned long base);
+void omap24xxcam_dmahw_disable_ch(unsigned long base, int ch);
+void omap24xxcam_dmahw_init(unsigned long base);
+

drivers/media/video/omap/omap24xxcam-dmahw.c new file +3 -0

new file mode 100644
index 0000000..21d23db
@@ -0,0 +1,224 @@
+/*
+ * drivers/media/video/omap/omap24xxcam-dma.c
+ *

drivers/media/video/omap/omap24xxcam-dmahw.c new file +5 -0

+ * kind, whether express or implied.
+ *
+ * History:
+ * 2005/nov - David Cohen <[email protected]>
+ *            Updated the driver for the Linux Device Model and new

version of V4L2.
+ */

drivers/media/video/omap/omap24xxcam-dmahw.c new file +61 -0

+
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/smp_lock.h>
+#include <linux/types.h>
+#include <linux/wait.h>
+#include <linux/videodev.h>
+#include <linux/pci.h>		/* needed for videobufs */
+#include <media/video-buf.h>
+#include <linux/dma-mapping.h>
+#include <linux/input.h>
+#include <linux/version.h>
+
+#include <asm/io.h>
+#include <asm/byteorder.h>
+#include <asm/scatterlist.h>
+#include <asm/irq.h>
+#include <asm/semaphore.h>
+
+#include "omap24xxcam.h"
+#include "omap24xxcam-dma.h"
+
+/* configuration macros */
+#define CAM_NAME 	"omap24xxcam"
+#define CONFIG_H4
+
+/* Ack all interrupt on CSR and IRQSTATUS_L0 */
+void omap24xxcam_dmahw_ack_all(unsigned long base)
+{
+	unsigned long csr;
+	int i;
+
+	for (i = 0; i< 4; ++i) {
+		csr = omap24xxcam_reg_in(base, CAMDMA_CSR(i));
+		/* ack interrupt in CSR */
+		omap24xxcam_reg_out(base, CAMDMA_CSR(i), csr);
+	}
+	omap24xxcam_reg_out(base, CAMDMA_IRQSTATUS_L0, 0xffffffff);
+}
+
+/* Ack dmach on CSR and IRQSTATUS_L0 */
+unsigned long omap24xxcam_dmahw_ack_ch(unsigned long base, int dmach)
+{
+	unsigned long csr;
+
+	csr = omap24xxcam_reg_in(base, CAMDMA_CSR(dmach));
+	/* ack interrupt in CSR */
+	omap24xxcam_reg_out(base, CAMDMA_CSR(dmach), csr);
+	/* ack interrupt in IRQSTATUS */
+	omap24xxcam_reg_out(base, CAMDMA_IRQSTATUS_L0, (1 << dmach));
+
+	return csr;
+}
+
+int omap24xxcam_dmahw_running(unsigned long base, int dmach)
+{
+	return omap24xxcam_reg_in(base, CAMDMA_CCR(dmach)) &

CAMDMA_CCR_ENABLE;

drivers/media/video/omap/omap24xxcam-dmahw.c new file +82 -0

+}
+
+void omap24xxcam_dmahw_transfer_setup(unsigned long base, int dmach,
+			     dma_addr_t start, unsigned long len)
+{
+	omap24xxcam_reg_out(base, CAMDMA_CCR(dmach),
+		       CAMDMA_CCR_SEL_SRC_DST_SYNC
+		       | CAMDMA_CCR_BS
+		       | CAMDMA_CCR_DST_AMODE_POST_INC
+		       | CAMDMA_CCR_SRC_AMODE_POST_INC
+		       | CAMDMA_CCR_FS
+		       | CAMDMA_CCR_WR_ACTIVE
+		       | CAMDMA_CCR_RD_ACTIVE
+		       | CAMDMA_CCR_SYNCHRO_CAMERA);
+	omap24xxcam_reg_out(base, CAMDMA_CLNK_CTRL(dmach), 0);
+	omap24xxcam_reg_out(base, CAMDMA_CEN(dmach), len);
+	omap24xxcam_reg_out(base, CAMDMA_CFN(dmach), 1);
+	omap24xxcam_reg_out(base, CAMDMA_CSDP(dmach),
+		       CAMDMA_CSDP_WRITE_MODE_POSTED
+		       | CAMDMA_CSDP_DST_BURST_EN_32
+		       | CAMDMA_CSDP_DST_PACKED
+		       | CAMDMA_CSDP_SRC_BURST_EN_32
+		       | CAMDMA_CSDP_SRC_PACKED
+		       | CAMDMA_CSDP_DATA_TYPE_8BITS);
+	omap24xxcam_reg_out(base, CAMDMA_CSSA(dmach), 0);
+	omap24xxcam_reg_out(base, CAMDMA_CDSA(dmach), start);
+	omap24xxcam_reg_out(base, CAMDMA_CSEI(dmach), 0);
+	omap24xxcam_reg_out(base, CAMDMA_CSFI(dmach), DMA_THRESHOLD);
+	omap24xxcam_reg_out(base, CAMDMA_CDEI(dmach), 0);
+	omap24xxcam_reg_out(base, CAMDMA_CDFI(dmach), 0);
+	omap24xxcam_reg_out(base, CAMDMA_CSR(dmach),
+		       CAMDMA_CSR_MISALIGNED_ERR
+		       | CAMDMA_CSR_SUPERVISOR_ERR
+		       | CAMDMA_CSR_SECURE_ERR
+		       | CAMDMA_CSR_TRANS_ERR
+		       | CAMDMA_CSR_BLOCK
+		       | CAMDMA_CSR_DROP);
+	omap24xxcam_reg_out(base, CAMDMA_CICR(dmach),
+		       CAMDMA_CICR_MISALIGNED_ERR_IE
+		       | CAMDMA_CICR_SUPERVISOR_ERR_IE
+		       | CAMDMA_CICR_SECURE_ERR_IE
+		       | CAMDMA_CICR_TRANS_ERR_IE
+		       | CAMDMA_CICR_BLOCK_IE
+		       | CAMDMA_CICR_DROP_IE);
+}
+
+void omap24xxcam_dmahw_transfer_chain(unsigned long base, int dmach,
+				      int free_dmach)
+{
+	int prev_dmach, ch;
+
+	if (dmach == 0)
+		prev_dmach = NUM_CAMDMA_CHANNELS - 1;
+	else
+		prev_dmach = dmach - 1;
+	omap24xxcam_reg_out(base, CAMDMA_CLNK_CTRL(prev_dmach),
+		       CAMDMA_CLNK_CTRL_ENABLE_LNK | dmach);
+	/* Did we chain the DMA transfer before the previous one
+	 * finished?
+	 */
+	ch = (dmach + free_dmach) % NUM_CAMDMA_CHANNELS;
+	DBG_MID(1);
+	while (!(omap24xxcam_reg_in(base, CAMDMA_CCR(ch))
+		 & CAMDMA_CCR_ENABLE))
+	{
+		if (ch == dmach) {
+			/* The previous transfer has ended and this one
+			 * hasn't started, so we must not have chained
+			 * to the previous one in time.  We'll have to
+			 * start it now.
+			 */
+			omap24xxcam_dmahw_transfer_start(base, dmach);
+			break;
+		} else
+			ch = (ch + 1) % NUM_CAMDMA_CHANNELS;
+	}
+	DBG_MID(2);
+}
+
+void omap24xxcam_dmahw_transfer_start(unsigned long base, int dmach)
+{
+	omap24xxcam_reg_out(base, CAMDMA_CCR(dmach),

and
+ * the DMA controller is idle, the completion routines for any aborted transfers
+ * will be called in sequence. The DMA controller may not be idle

this
+ * routine completes, because the completion routines might start new transfers.
+ */

drivers/media/video/omap/omap24xxcam-dmahw.c new file +37 -0

+}
+
+/* Mask all DMA interrupts */
+void omap24xxcam_dmahw_mask_all(unsigned long base)
+{
+	omap24xxcam_reg_out(base, CAMDMA_IRQENABLE_L0, 0);
+	omap24xxcam_reg_out(base, CAMDMA_IRQENABLE_L1, 0);
+	omap24xxcam_reg_out(base, CAMDMA_IRQENABLE_L2, 0);
+	omap24xxcam_reg_out(base, CAMDMA_IRQENABLE_L3, 0);
+}
+
+/* group all channels on DMA IRQ0 and unmask irq */
+void omap24xxcam_dmahw_unmask_irq0(unsigned long base)
+{
+	omap24xxcam_reg_out(base, CAMDMA_IRQENABLE_L0, 0xffffffff);
+	omap24xxcam_reg_out(base, CAMDMA_IRQENABLE_L1, 0);
+	omap24xxcam_reg_out(base, CAMDMA_IRQENABLE_L2, 0);
+	omap24xxcam_reg_out(base, CAMDMA_IRQENABLE_L3, 0);
+}
+
+void omap24xxcam_dmahw_disable_ch(unsigned long base, int ch)
+{
+	omap24xxcam_reg_out(base, CAMDMA_CCR(ch), 0);
+}
+
+void omap24xxcam_dmahw_init(unsigned long base)
+{
+	DBG;
+	omap24xxcam_reg_out(base, CAMDMA_OCP_SYSCONFIG,
+		CAMDMA_OCP_SYSCONFIG_MIDLEMODE_FSTANDBY
+	      | CAMDMA_OCP_SYSCONFIG_SIDLEMODE_FIDLE
+	      | CAMDMA_OCP_SYSCONFIG_AUTOIDLE);
+
+	omap24xxcam_reg_merge(base, CAMDMA_GCR, 0x10,
+		CAMDMA_GCR_MAX_CHANNEL_FIFO_DEPTH);
+}
+

drivers/media/video/omap/omap24xxcam-sensor.c new file +3 -0

new file mode 100644
index 0000000..bde7429
@@ -0,0 +1,226 @@
+/*
+ * drivers/media/video/omap/omap24xxcam-dma.c
+ *

drivers/media/video/omap/omap24xxcam-sensor.c new file +5 -0

+ * kind, whether express or implied.
+ *
+ * History:
+ * 2005/nov - David Cohen <[email protected]>
+ *            Updated the driver for the Linux Device Model and new

version of V4L2.
+ */

drivers/media/video/omap/omap24xxcam-sensor.c new file +36 -0

+
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/smp_lock.h>
+#include <linux/types.h>
+#include <linux/wait.h>
+#include <linux/videodev.h>
+#include <linux/pci.h>		/* needed for videobufs */
+#include <media/video-buf.h>
+#include <linux/dma-mapping.h>
+#include <linux/input.h>
+#include <linux/version.h>
+
+#include <asm/io.h>
+#include <asm/byteorder.h>
+#include <asm/scatterlist.h>
+#include <asm/irq.h>
+#include <asm/semaphore.h>
+
+#include "omap24xxcam.h"
+#include "sensor_if.h"
+#include "omap24xxcam-dma.h"
+
+/* camera driver: initialise sensor */
+int omap24xxcam_sensor_init(struct omap24xxcam_device *cam)
+{
+	int err = 0;
+
+	if (cam->sensor == NULL)
+		return -ENODEV;
+
+	if (cam->sensor_alive)

Quoted 1 line

img.pix */

drivers/media/video/omap/omap24xxcam-sensor.c new file +30 -0

+	err = cam->sensor->init(cam->sensor,
+				&cam->img.pix,
+				&omap24xxcam_camera);
+	if (err) {
+		printk(KERN_ERR CAM_NAME
+		       ": cannot initialize sensor, error %d\n", err);
+		goto out;
+	}
+	printk(KERN_INFO "Sensor is %s\n", cam->sensor->name);
+
+out:
+	omap24xxcam_core_xclk_disable(&cam->core);
+	omap24xxcam_clock_off(cam);
+
+	if (cam->sensor->power_off)
+		cam->sensor->power_off(cam->sensor);
+
+	cam->sensor_alive = 1;
+
+	return err;
+}
+
+void omap24xxcam_sensor_exit(struct omap24xxcam_device *cam)
+{
+	if (cam->sensor == NULL)
+		return;
+	if (!cam->sensor_alive)
+		return;
+
+	omap24xxcam_sensor_disable(cam);

drivers/media/video/omap/omap24xxcam-sensor.c new file +6 -0

+	 * frame rate
+	 */
+	omap24xxcam_core_xclk_set(
+		&cam->core,
+		cam->sensor->calc_xclk(
+			cam->sensor,

drivers/media/video/omap/omap24xxcam-sensor.c new file +5 -0

+
+	return 0;
+}
+
+void omap24xxcam_sensor_disable(struct omap24xxcam_device *cam)

drivers/media/video/omap/omap24xxcam-sensor.c new file +7 -0

+
+	omap24xxcam_sensor_disable(cam);
+
+	omap24xxcam_sensor_enable(cam);
+}
+
+void omap24xxcam_sensor_reset_schedule(struct omap_camera *oc,

drivers/media/video/omap/omap24xxcam-sensor.c new file +19 -0

+{
+	return cam->sensor->calc_xclk(cam->sensor,
+				      pix,
+				      timeperframe);
+}
+
+int omap24xxcam_sensor_try_format(struct omap24xxcam_device *cam,
+				  struct v4l2_pix_format *pix)
+{
+	return cam->sensor->try_format(cam->sensor,
+				       pix);
+}
+
+int omap24xxcam_sensor_set_format(struct omap24xxcam_device *cam,
+				  struct v4l2_pix_format *pix,
+				  struct v4l2_fract *timeperframe,
+				  unsigned long *xclk)
+{
+	int err;

drivers/media/video/omap/omap24xxcam-sensor.c new file +41 -0

+
+	return err;
+}
+
+/* This should be called by the sensor code whenever it's ready */
+int omap24xxcam_sensor_register(struct omap_camera *oc,
+				struct omap_camera_sensor *os)
+{
+	struct omap24xxcam_device *cam = oc->priv;
+	int rval;
+
+	/* the device has not been initialised yet */
+	if (cam == NULL)
+		return -ENODEV;
+	if (os == NULL)
+		return -EINVAL;
+	if (cam->sensor != NULL)
+		return -EBUSY;
+
+	cam->sensor = os;
+	rval = omap24xxcam_device_enable(cam);
+
+	if (rval)
+		cam->sensor = NULL;
+	return rval;
+}
+
+EXPORT_SYMBOL(omap24xxcam_sensor_register);
+
+void omap24xxcam_sensor_unregister(struct omap_camera *oc,
+				   struct omap_camera_sensor *os)
+{
+	struct omap24xxcam_device *cam = oc->priv;
+
+	BUG_ON(cam->users != 0);
+	BUG_ON(cam->sensor == NULL);
+
+	cam->sensor = NULL;
+}
+
+EXPORT_SYMBOL(omap24xxcam_sensor_unregister);

drivers/media/video/omap/omap24xxcam-sgdma.c new file +52 -0

new file mode 100644
index 0000000..0243a59
@@ -0,0 +1,298 @@
+/*
+ * OMAP 24xx camera high-level DMA (not hardware) and scatter-gather
+ * DMA handling
+ *
+ * Author: Andy Lowe ([email protected])
+ *
+ * Copyright (C) 2004 MontaVista Software, Inc.
+ * Copyright (C) 2004 Texas Instruments.
+ * Copyright (C) 2007 Nokia Corporation.
+ *
+ * Contact: Sakari Ailus <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/smp_lock.h>
+#include <linux/types.h>
+#include <linux/wait.h>
+#include <linux/videodev.h>
+#include <linux/pci.h>		/* needed for videobufs */
+#include <media/video-buf.h>
+#include <linux/dma-mapping.h>
+#include <linux/input.h>
+#include <linux/version.h>
+
+#include <asm/io.h>
+#include <asm/byteorder.h>
+#include <asm/scatterlist.h>
+#include <asm/irq.h>
+#include <asm/semaphore.h>
+
+#include "omap24xxcam.h"
+#include "omap24xxcam-dma.h"
+

drivers/media/video/omap/omap24xxcam-sgdma.c new file +18 -0

+			    void *arg)
+{
+	struct omap24xxcam_sgdma *sgdma =
+		container_of(dma, struct omap24xxcam_sgdma, dma);
+	int sgslot = (int)arg;
+	struct sgdma_state *sg_state;
+	const unsigned long csr_error = CAMDMA_CSR_MISALIGNED_ERR
+	    | CAMDMA_CSR_SUPERVISOR_ERR | CAMDMA_CSR_SECURE_ERR
+	    | CAMDMA_CSR_TRANS_ERR | CAMDMA_CSR_DROP;
+
+	DBG;
+
+	spin_lock(&sgdma->lock);
+
+	/* We got an interrupt, we can remove the timer */
+	del_timer(&sgdma->reset_timer);
+
+	sg_state = sgdma->sg_state + sgslot;

drivers/media/video/omap/omap24xxcam-sgdma.c new file +11 -0

+		 * done.
+		 */
+		if ((sg_state->next_sglist == sg_state->sglen)
+		    || (sg_state->csr & csr_error)) {
+			sgdma_callback_t callback = sg_state->callback;
+			void *arg = sg_state->arg;
+			unsigned long sg_csr = sg_state->csr;
+			/* All done with this sglist */
+			sgdma->free_sgdma++;
+			if (callback) {
+				spin_unlock(&sgdma->lock);

drivers/media/video/omap/omap24xxcam-sgdma.c new file +13 -0

+void omap24xxcam_sgdma_process(struct omap24xxcam_sgdma *sgdma)
+{
+	unsigned long irqflags;
+	int queued_sgdma, sgslot;
+	struct sgdma_state *sg_state;
+	const unsigned long csr_error = CAMDMA_CSR_MISALIGNED_ERR
+	    | CAMDMA_CSR_SUPERVISOR_ERR | CAMDMA_CSR_SECURE_ERR
+	    | CAMDMA_CSR_TRANS_ERR | CAMDMA_CSR_DROP;
+
+	DBG;
+
+	spin_lock_irqsave(&sgdma->lock, irqflags);
+

drivers/media/video/omap/omap24xxcam-sgdma.c new file +18 -0

+				return;
+			} else {
+				unsigned long expires;
+				/* DMA start was successful */
+				sg_state->next_sglist++;
+				sg_state->bytes_read += len;
+				sg_state->queued_sglist++;
+
+				/* We start the reset timer */
+				expires = jiffies + HZ;
+				mod_timer(&sgdma->reset_timer, expires);
+			}
+		}
+		queued_sgdma--;
+		sgslot = (sgslot + 1) % NUM_SG_DMA;
+	}
+
+	spin_unlock_irqrestore(&sgdma->lock, irqflags);

drivers/media/video/omap/omap24xxcam-sgdma.c new file +40 -0

+			 sgdma_callback_t callback, void *arg)
+{
+	unsigned long irqflags;
+	struct sgdma_state *sg_state;
+
+	DBG;
+
+	if ((sglen < 0) || ((sglen > 0) & !sglist))
+		return -EINVAL;
+
+	spin_lock_irqsave(&sgdma->lock, irqflags);
+
+	if (!sgdma->free_sgdma) {
+		spin_unlock_irqrestore(&sgdma->lock, irqflags);
+		return -EBUSY;
+	}
+
+	sg_state = sgdma->sg_state + sgdma->next_sgdma;
+
+	sg_state->sglist = sglist;
+	sg_state->sglen = sglen;
+	sg_state->next_sglist = 0;
+	sg_state->bytes_read = 0;
+	sg_state->len = len;
+	sg_state->queued_sglist = 0;
+	sg_state->csr = 0;
+	sg_state->callback = callback;
+	sg_state->arg = arg;
+
+	sgdma->next_sgdma = (sgdma->next_sgdma + 1) % NUM_SG_DMA;
+	sgdma->free_sgdma--;
+
+	spin_unlock_irqrestore(&sgdma->lock, irqflags);
+
+	omap24xxcam_sgdma_process(sgdma);
+
+	return 0;
+}
+
+/* Sync scatter-gather DMA by aborting any DMA transfers currently in

progress.
+ * Any queued scatter-gather DMA transactions that have not yet been started
+ * will remain queued. The DMA controller will be idle after this

drivers/media/video/omap/omap24xxcam-sgdma.c new file +4 -0

+{
+	unsigned long irqflags;
+	int sgslot;
+	struct sgdma_state *sg_state;

drivers/media/video/omap/omap24xxcam-sgdma.c new file +7 -0

+			sgdma_callback_t callback = sg_state->callback;
+			void *arg = sg_state->arg;
+			sgdma->free_sgdma++;
+			if (callback) {
+				/* leave interrupts masked */
+				spin_unlock(&sgdma->lock);
+				(*callback) (sgdma, csr, arg);

base)

drivers/media/video/omap/omap24xxcam-sgdma.c new file +38 -0

+{
+	int sg;
+
+	DBG;
+
+	spin_lock_init(&sgdma->lock);
+	sgdma->free_sgdma = NUM_SG_DMA;
+	sgdma->next_sgdma = 0;
+	for (sg = 0; sg < NUM_SG_DMA; sg++) {
+		sgdma->sg_state[sg].sglen = 0;
+		sgdma->sg_state[sg].next_sglist = 0;
+		sgdma->sg_state[sg].bytes_read = 0;
+		sgdma->sg_state[sg].queued_sglist = 0;
+		sgdma->sg_state[sg].csr = 0;
+		sgdma->sg_state[sg].callback = NULL;
+		sgdma->sg_state[sg].arg = NULL;
+	}
+
+	omap24xxcam_dma_init(&sgdma->dma, base);
+}
+
+void omap24xxcam_sgdma_exit(struct omap24xxcam_sgdma *sgdma)
+{
+	omap24xxcam_sgdma_sync(sgdma, CAMDMA_CSR_TRANS_ERR);
+	omap24xxcam_dma_exit(&sgdma->dma);
+}
+
+void omap24xxcam_sgdma_enable(struct omap24xxcam_sgdma *sgdma)
+{
+	omap24xxcam_dma_enable(&sgdma->dma);
+	omap24xxcam_sgdma_process(sgdma);
+}
+
+void omap24xxcam_sgdma_disable(struct omap24xxcam_sgdma *sgdma)
+{
+	omap24xxcam_sgdma_sync(sgdma, CAMDMA_CSR_TRANS_ERR);
+	omap24xxcam_dma_disable(&sgdma->dma);
+}

drivers/media/video/omap/omap24xxcam-vbq.c new file +69 -0

new file mode 100644
index 0000000..f6d8803
@@ -0,0 +1,370 @@
+/*
+ * OMAP 24xx camera high-level DMA (not hardware) and scatter-gather
+ * DMA handling
+ *
+ * Author: Andy Lowe ([email protected])
+ *
+ * Copyright (C) 2004 MontaVista Software, Inc.
+ * Copyright (C) 2004 Texas Instruments.
+ * Copyright (C) 2007 Nokia Corporation.
+ *
+ * Contact: Sakari Ailus <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/smp_lock.h>
+#include <linux/types.h>
+#include <linux/wait.h>
+#include <linux/videodev.h>
+#include <linux/pci.h>		/* needed for videobufs */
+#include <media/video-buf.h>
+#include <linux/dma-mapping.h>
+#include <linux/input.h>
+#include <linux/version.h>
+
+#include <asm/io.h>
+#include <asm/byteorder.h>
+#include <asm/scatterlist.h>
+#include <asm/irq.h>
+#include <asm/semaphore.h>
+
+#include "omap24xxcam.h"
+#include "omap24xxcam-dma.h"
+
+static void
+omap24xxcam_vbq_free_mmap_buffer(struct videobuf_buffer *vb)
+{
+	int i;
+	size_t alloc_size;
+	struct page *page;
+
+	if (vb->dma.sglist == NULL)
+		return;
+
+	i = vb->dma.sglen;
+	while (i) {
+		i--;
+		alloc_size = vb->dma.sglist[i].length;
+		page = vb->dma.sglist[i].page;
+		do {
+			ClearPageReserved(page++);

drivers/media/video/omap/omap24xxcam-vbq.c new file +6 -0

+		vb->dma.sglist[i].page = page;
+		vb->dma.sglist[i].length = (PAGE_SIZE << order);
+		vb->dma.sglen++;
+		i++;
+
+		alloc_size = (PAGE_SIZE << order);

buf

drivers/media/video/omap/omap24xxcam-vbq.c new file +29 -0

+	 * is passing nr_pages for e.g. unmap_sg calls */
+	vb->dma.nr_pages = vb->dma.sglen;
+	vb->dma.direction = PCI_DMA_FROMDEVICE;
+
+	return 0;
+
+out:
+	omap24xxcam_vbq_free_mmap_buffer(vb);
+	return err;
+}
+
+int
+omap24xxcam_vbq_alloc_mmap_buffers(struct videobuf_queue *vbq,
+				   unsigned int count)
+{
+	int i, err = 0;
+
+	mutex_lock(&vbq->lock);
+	for (i = 0; i < count; i++) {
+		err = omap24xxcam_vbq_alloc_mmap_buffer(vbq->bufs[i]);
+		if (err)
+			goto out;
+		printk("%s: sglen is %d for buffer %d\n",
+		       __FUNCTION__, vbq->bufs[i]->dma.sglen, i);
+	}
+	mutex_unlock(&vbq->lock);
+
+	return 0;
+out:

csr,

drivers/media/video/omap/omap24xxcam-vbq.c new file +10 -0

+			 void *arg)
+{
+	struct omap24xxcam_device *cam =
+		container_of(sgdma, struct omap24xxcam_device, sgdma);
+	struct omap24xxcam_capture *capture = &cam->capture;
+	struct videobuf_buffer *vb = (struct videobuf_buffer *)arg;
+	const unsigned long csr_error = CAMDMA_CSR_MISALIGNED_ERR
+	    | CAMDMA_CSR_SUPERVISOR_ERR | CAMDMA_CSR_SECURE_ERR
+	    | CAMDMA_CSR_TRANS_ERR | CAMDMA_CSR_DROP;
+

*vb)

drivers/media/video/omap/omap24xxcam-vbq.c new file +9 -0

+{
+	struct videobuf_dmabuf *dma = &vb->dma;
+	DBG;
+
+	videobuf_waiton(vb, 0, 0);
+	if (vb->memory == V4L2_MEMORY_MMAP) {
+		dma_unmap_sg(vbq->dev, dma->sglist, dma->sglen,
+			     dma->direction);
+		dma->direction = PCI_DMA_NONE;

+ * number requested, the currently selected image size, and the

*/

drivers/media/video/omap/omap24xxcam-vbq.c new file +8 -0

+
+	if (*cnt > VIDEO_MAX_FRAME)
+		*cnt = VIDEO_MAX_FRAME;
+
+	spin_lock(&cam->img.img_lock);
+
+	*size = cam->img.pix.sizeimage;
+