OMAP2 camera and TCM825x sensor drivers

-----Original Message-----
From: [email protected] [mailto:linux-omap- [email protected]] On Behalf Of Sakari Ailus
Sent: Wednesday, February 28, 2007 9:49 AM
To: [email protected]
Subject: [PATCH] OMAP2 camera and TCM825x sensor drivers

Hi,

I'm about to send a patch set of OMAP 2 camera and a TCM825x sensor drivers. Compared to those from maemo.org, there are clean-ups and the overlay support has been removed, among other things.

This is all still very much work in progress but I'd be glad to hear comments about it.

Both drivers should compile, and also function with 2.6.18 from maemo.org. (Except that there's a bug in VIDIOC_DQBUF in 2.6.18.) Some N800-specific code is missing for the moment. Also locking is in sore state. The interface changes (temporarily) break existing OMAP 1 camera driver and the ov9640 sensor driver.

These patches are against Tony's tree.

I recommend not to apply these for the time being. :)

Regards,

--
Sakari Ailus
[email protected]
_______________________________________________
Linux-omap-open-source mailing list
[email protected]
http://linux.omap.com/mailman/listinfo/linux-omap-open-source

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(-)

If some patches are for review please mark them as "RFC". "Patch" is when it has to go into tree - Some one can correct me if I am wrong.

Sakari,

Thanks for the code, do you have any kind of design doc or ppt that gives a brief overview of what the code is and the interface considered etc. Its bit hard to go directly to code :(

The second issue is merging TI's camera code with this. I can post our design considerations for camera. We can see how to integrate TIs sensor and additional functionality provided by TI's camera code (like rotation, scatter gather dma, multiple sensors handling etc).

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"

Syed,

Quoted 8 lines · Khasim

If some patches are for review please mark them as "RFC". "Patch" is when it has to go into tree - Some one can correct me if I am wrong.

Sakari,

Thanks for the code, do you have any kind of design doc or ppt that gives a brief overview of what the code is and the interface considered etc. Its bit hard to go directly to code :(

I don't think that you will need this. What interface you would like to understand? Please phrase the questions based on the code and may Sakari can help you to understand :) I believe some of the changes in N800 camera driver was also done to reduce the interrupt latencies and bugs in video-buf.

Quoted 4 lines

The second issue is merging TI's camera code with this. I can post our design considerations for camera. We can see how to integrate TIs sensor and additional functionality provided by TI's camera code (like rotation, scatter gather dma, multiple sensors handling etc).

Do you mean "rotation" of the preview window ? See, preview in camera driver is just a add-on functionality _but_ not must. I would not use this auto preview functionality, instead captured stream will go to /dev/fb1 and then shown on the LCD/TV out and rotated based on the N800 sensor or app commands.

Quoted 2 lines

do you have any kind of design doc or ppt that gives a brief overview of what the code is and the interface

Quoted 5 lines

Do you mean "rotation" of the preview window ? See, preview in camera driver is just a add-on functionality _but_ not must. I would not use this auto preview functionality, instead captured stream will go to /dev/fb1 and then shown on the LCD/TV out and rotated based on the N800 sensor or app commands.

-----Original Message-----
From: [email protected] [mailto:[email protected]]
Sent: Thursday, March 01, 2007 2:07 AM
To: Trilok Soni
Cc: Syed Mohammed, Khasim; [email protected]
Subject: Re: [PATCH] OMAP2 camera and TCM825x sensor drivers

Quoted 10 lines · Trilok Soni

Syed,

Quoted 7 lines · Khasim

If some patches are for review please mark them as "RFC". "Patch" is when it has to go into tree - Some one can correct me if I am wrong.

Sakari,

Thanks for the code, do you have any kind of design doc or ppt that gives a brief overview of what the code is and the interface

Quoted 6 lines

Quoted 1 line

etc. Its bit hard to go directly to code :(

I don't think that you will need this. What interface you would like to understand? Please phrase the questions based on the code and may Sakari can help you to understand :) I believe some of the changes in N800 camera driver was also done to reduce the interrupt latencies

Quoted 1 line

bugs in video-buf.

I agree with Trilok. The idea is to do incremental changes based on patches.

Quoted 1 line

Quoted 1 line

The second issue is merging TI's camera code with this. I can post

Quoted 1 line

Quoted 1 line

design considerations for camera. We can see how to integrate TIs

Quoted 8 lines

Quoted 2 lines

and additional functionality provided by TI's camera code (like rotation, scatter gather dma, multiple sensors handling etc).

Do you mean "rotation" of the preview window ? See, preview in camera driver is just a add-on functionality _but_ not must. I would not use this auto preview functionality, instead captured stream will go to /dev/fb1 and then shown on the LCD/TV out and rotated based on the N800 sensor or app commands.

Yyp, additional features are easy to add later once we have basics in place.

Regards,

Tony

Quoted 3 lines

Quoted 3 lines

do you have any kind of design doc or ppt that gives a brief overview of what the code is and the interface

considered

Sakari, taking this back :) Sorry was kind of used to these for a while.

Quoted 5 lines

Quoted 5 lines

Do you mean "rotation" of the preview window ? See, preview in camera driver is just a add-on functionality _but_ not must. I would not use this auto preview functionality, instead captured stream will go to /dev/fb1 and then shown on the LCD/TV out and rotated based on the N800 sensor or app commands.

Trilok, this may be your use case but not true for all OMAP users :) Few take preview seriously; I have seen demands for a preview with rotation/mirroring/cropping/scaling :) Again it's as per demands. Why to send a data to app that is not getting stored?

No issues, as Tony suggested we can go ahead and add more functionality later (if required).

Trilok, will you be pushing the Micron sensor library too?

Regards,
Khasim

Quoted 7 lines

-----Original Message-----
From: [email protected] [mailto:[email protected]]
Sent: Thursday, March 01, 2007 2:07 AM
To: Trilok Soni
Cc: Syed Mohammed, Khasim; [email protected]
Subject: Re: [PATCH] OMAP2 camera and TCM825x sensor drivers

Quoted 11 lines

Quoted 10 lines · Trilok Soni

Syed,

Quoted 7 lines · Khasim

If some patches are for review please mark them as "RFC". "Patch" is when it has to go into tree - Some one can correct me if I am wrong.

Sakari,

Thanks for the code, do you have any kind of design doc or ppt that gives a brief overview of what the code is and the interface

considered

Quoted 6 lines

Quoted 6 lines

Quoted 1 line

etc. Its bit hard to go directly to code :(

I don't think that you will need this. What interface you would like to understand? Please phrase the questions based on the code and may Sakari can help you to understand :) I believe some of the changes in N800 camera driver was also done to reduce the interrupt latencies

and

Quoted 6 lines

Quoted 1 line

bugs in video-buf.

I agree with Trilok. The idea is to do incremental changes based on patches.

Quoted 1 line

Quoted 1 line

The second issue is merging TI's camera code with this. I can post

our

Quoted 1 line

Quoted 1 line

Quoted 1 line

design considerations for camera. We can see how to integrate TIs

sensor

Quoted 9 lines

Quoted 8 lines

Quoted 2 lines

and additional functionality provided by TI's camera code (like rotation, scatter gather dma, multiple sensors handling etc).

Do you mean "rotation" of the preview window ? See, preview in camera driver is just a add-on functionality _but_ not must. I would not use this auto preview functionality, instead captured stream will go to /dev/fb1 and then shown on the LCD/TV out and rotated based on the N800 sensor or app commands.

Quoted 6 lines

Yyp, additional features are easy to add later once we have basics in place.

Regards,

Tony

_______________________________________________
Linux-omap-open-source mailing list
[email protected]
http://linux.omap.com/mailman/listinfo/linux-omap-open-source

If some patches are for review please mark them as "RFC". "Patch" is when it has to go into tree - Some one can correct me if I am wrong.

Thanks for the code, do you have any kind of design doc or ppt that gives a brief overview of what the code is and the interface considered etc. Its bit hard to go directly to code :(

The second issue is merging TI's camera code with this. I can post our design considerations for camera. We can see how to integrate TIs sensor and additional functionality provided by TI's camera code (like rotation, scatter gather dma, multiple sensors handling etc).

Hi All

Can some one tell me when I use the camera on N800 then which part of the code gets executed?
I mean is there some application, which starts running and opens camera driver or there is no application program on the top of camera driver, it is just the camera driver which gets started when I start using the camera and takes care of capturing pics?

If it is some application on top of camera driver then how does it interact with the camera driver? does it interacts in a linux std way, I mean first it opens /dev/video0 then it sends ioctl commands etc.?
Please enlighten these points, I am confused.

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.

-----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;
+