This patch adds the soc_camera mode support in marvell-ccic driver.
It also removes the old mode for maintaining single mode in the future.
Signed-off-by: Libin Yang <lbyang@xxxxxxxxxxx>
Signed-off-by: Albert Wang <twang13@xxxxxxxxxxx>
---
drivers/media/platform/Makefile | 4 +-
drivers/media/platform/marvell-ccic/Kconfig | 6 +-
drivers/media/platform/marvell-ccic/mcam-core.c | 1084 +++++++---------------
drivers/media/platform/marvell-ccic/mcam-core.h | 27 +-
drivers/media/platform/marvell-ccic/mmp-driver.c | 73 +-
include/media/mmp-camera.h | 5 +
6 files changed, 402 insertions(+), 797 deletions(-)
diff --git a/drivers/media/platform/Makefile b/drivers/media/platform/Makefile
index 4817d28..1a345c8 100644
--- a/drivers/media/platform/Makefile
+++ b/drivers/media/platform/Makefile
@@ -11,8 +11,6 @@ obj-$(CONFIG_VIDEO_TIMBERDALE) += timblogiw.o
obj-$(CONFIG_VIDEO_M32R_AR_M64278) += arv.o
obj-$(CONFIG_VIDEO_VIA_CAMERA) += via-camera.o
-obj-$(CONFIG_VIDEO_CAFE_CCIC) += marvell-ccic/
-obj-$(CONFIG_VIDEO_MMP_CAMERA) += marvell-ccic/
obj-$(CONFIG_VIDEO_OMAP2) += omap2cam.o
obj-$(CONFIG_VIDEO_OMAP3) += omap3isp/
@@ -43,6 +41,8 @@ obj-$(CONFIG_ARCH_DAVINCI) += davinci/
obj-$(CONFIG_VIDEO_SH_VOU) += sh_vou.o
obj-$(CONFIG_SOC_CAMERA) += soc_camera/
+obj-$(CONFIG_VIDEO_CAFE_CCIC) += marvell-ccic/
+obj-$(CONFIG_VIDEO_MMP_CAMERA) += marvell-ccic/
obj-y += davinci/
diff --git a/drivers/media/platform/marvell-ccic/Kconfig b/drivers/media/platform/marvell-ccic/Kconfig
index bf739e3..7fa3c62 100755
--- a/drivers/media/platform/marvell-ccic/Kconfig
+++ b/drivers/media/platform/marvell-ccic/Kconfig
@@ -10,14 +10,14 @@ config VIDEO_CAFE_CCIC
generation OLPC systems.
config VIDEO_MMP_CAMERA
- tristate "Marvell Armada 610 integrated camera controller support"
+ tristate "Marvell Armada integrated camera controller support"
depends on ARCH_MMP && I2C && VIDEO_V4L2
- select VIDEO_OV7670
select I2C_GPIO
+ select VIDEOBUF2_DMA_CONTIG
select VIDEOBUF2_DMA_SG
---help---
This is a Video4Linux2 driver for the integrated camera
- controller found on Marvell Armada 610 application
+ controller found on Marvell Armada application
processors (and likely beyond). This is the controller found
in OLPC XO 1.75 systems.
diff --git a/drivers/media/platform/marvell-ccic/mcam-core.c b/drivers/media/platform/marvell-ccic/mcam-core.c
index b668f2b..16ba045 100755
--- a/drivers/media/platform/marvell-ccic/mcam-core.c
+++ b/drivers/media/platform/marvell-ccic/mcam-core.c
@@ -24,10 +24,11 @@
#include <media/v4l2-device.h>
#include <media/v4l2-ioctl.h>
#include <media/v4l2-chip-ident.h>
-#include <media/ov7670.h>
#include <media/videobuf2-vmalloc.h>
#include <media/videobuf2-dma-contig.h>
#include <media/videobuf2-dma-sg.h>
+#include <media/soc_camera.h>
+#include <media/soc_mediabus.h>
#include "mcam-core.h"
@@ -99,84 +100,38 @@ MODULE_PARM_DESC(buffer_mode,
#define CF_FRAME_SOF2 9
#define sensor_call(cam, o, f, args...) \
- v4l2_subdev_call(cam->sensor, o, f, ##args)
-
-static struct mcam_format_struct {
- __u8 *desc;
- __u32 pixelformat;
- int bpp; /* Bytes per pixel */
- bool planar;
- enum v4l2_mbus_pixelcode mbus_code;
-} mcam_formats[] = {
- {
- .desc = "YUYV 4:2:2",
- .pixelformat = V4L2_PIX_FMT_YUYV,
- .mbus_code = V4L2_MBUS_FMT_YUYV8_2X8,
- .bpp = 2,
- .planar = false,
- },
- {
- .desc = "UYVY 4:2:2",
- .pixelformat = V4L2_PIX_FMT_UYVY,
- .mbus_code = V4L2_MBUS_FMT_YUYV8_2X8,
- .bpp = 2,
- .planar = false,
- },
- {
- .desc = "YUV 4:2:2 PLANAR",
- .pixelformat = V4L2_PIX_FMT_YUV422P,
- .mbus_code = V4L2_MBUS_FMT_YUYV8_2X8,
- .bpp = 2,
- .planar = true,
- },
- {
- .desc = "YUV 4:2:0 PLANAR",
- .pixelformat = V4L2_PIX_FMT_YUV420,
- .mbus_code = V4L2_MBUS_FMT_YUYV8_2X8,
- .bpp = 2,
- .planar = true,
- },
+ v4l2_subdev_call(soc_camera_to_subdev(cam->icd), o, f, ##args)
+
+static const struct soc_mbus_pixelfmt mcam_formats[] = {
{
- .desc = "YVU 4:2:0 PLANAR",
- .pixelformat = V4L2_PIX_FMT_YVU420,
- .mbus_code = V4L2_MBUS_FMT_YUYV8_2X8,
- .bpp = 2,
- .planar = true,
+ .fourcc = V4L2_PIX_FMT_UYVY,
+ .name = "YUV422PACKED",
+ .bits_per_sample = 8,
+ .packing = SOC_MBUS_PACKING_2X8_PADLO,
+ .order = SOC_MBUS_ORDER_LE,
},
{
- .desc = "RGB 444",
- .pixelformat = V4L2_PIX_FMT_RGB444,
- .mbus_code = V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE,
- .bpp = 2,
- .planar = false,
+ .fourcc = V4L2_PIX_FMT_YUV422P,
+ .name = "YUV422PLANAR",
+ .bits_per_sample = 8,
+ .packing = SOC_MBUS_PACKING_2X8_PADLO,
+ .order = SOC_MBUS_ORDER_LE,
},
{
- .desc = "RGB 565",
- .pixelformat = V4L2_PIX_FMT_RGB565,
- .mbus_code = V4L2_MBUS_FMT_RGB565_2X8_LE,
- .bpp = 2,
- .planar = false,
+ .fourcc = V4L2_PIX_FMT_YUV420,
+ .name = "YUV420PLANAR",
+ .bits_per_sample = 12,
+ .packing = SOC_MBUS_PACKING_NONE,
+ .order = SOC_MBUS_ORDER_LE,
},
{
- .desc = "Raw RGB Bayer",
- .pixelformat = V4L2_PIX_FMT_SBGGR8,
- .mbus_code = V4L2_MBUS_FMT_SBGGR8_1X8,
- .bpp = 1,
- .planar = false,
+ .fourcc = V4L2_PIX_FMT_YVU420,
+ .name = "YVU420PLANAR",
+ .bits_per_sample = 12,
+ .packing = SOC_MBUS_PACKING_NONE,
+ .order = SOC_MBUS_ORDER_LE,
},
};
-#define N_MCAM_FMTS ARRAY_SIZE(mcam_formats)
-
-static struct mcam_format_struct *mcam_find_format(u32 pixelformat)
-{
- unsigned i;
-
- for (i = 0; i < N_MCAM_FMTS; i++)
- if (mcam_formats[i].pixelformat == pixelformat)
- return mcam_formats + i;
- /* Not found? Then return the first format. */
- return mcam_formats;
-}
/*
* The default format we use until somebody says otherwise.
@@ -507,10 +462,23 @@ static inline int mcam_check_dma_buffers(struct mcam_camera *cam)
static bool mcam_fmt_is_planar(__u32 pfmt)
{
- struct mcam_format_struct *f;
-
- f = mcam_find_format(pfmt);
- return f->planar;
+ switch (pfmt) {
+ case V4L2_PIX_FMT_YVU410:
+ case V4L2_PIX_FMT_YUYV:
+ case V4L2_PIX_FMT_YYUV:
+ case V4L2_PIX_FMT_YVYU:
+ case V4L2_PIX_FMT_UYVY:
+ case V4L2_PIX_FMT_VYUY:
+ return false;
+ case V4L2_PIX_FMT_YVU420: /* Need check here */
+ case V4L2_PIX_FMT_YUV420: /* Need check here */
+ case V4L2_PIX_FMT_YUV422P:
+ case V4L2_PIX_FMT_NV12M:
+ case V4L2_PIX_FMT_YUV420M:
+ return true;
+ default:
+ return false;
+ }
}
/*
@@ -827,31 +795,6 @@ static void mcam_ctlr_irq_disable(struct mcam_camera *cam)
mcam_reg_clear_bit(cam, REG_IRQMASK, FRAMEIRQS);
}
-
-
-static void mcam_ctlr_init(struct mcam_camera *cam)
-{
- unsigned long flags;
-
- spin_lock_irqsave(&cam->dev_lock, flags);
- /*
- * Make sure it's not powered down.
- */
- mcam_reg_clear_bit(cam, REG_CTRL1, C1_PWRDWN);
- /*
- * Turn off the enable bit. It sure should be off anyway,
- * but it's good to be sure.
- */
- mcam_reg_clear_bit(cam, REG_CTRL0, C0_ENABLE);
- /*
- * Clock the sensor appropriately. Controller clock should
- * be 48MHz, sensor "typical" value is half that.
- */
- mcam_reg_write_mask(cam, REG_CLKCTRL, 2, CLK_DIV_MASK);
- spin_unlock_irqrestore(&cam->dev_lock, flags);
-}
-
-
/*
* Stop the controller, and don't return until we're really sure that no
* further DMA is going on.
@@ -926,43 +869,6 @@ static int __mcam_cam_reset(struct mcam_camera *cam)
}
/*
- * We have found the sensor on the i2c. Let's try to have a
- * conversation.
- */
-static int mcam_cam_init(struct mcam_camera *cam)
-{
- struct v4l2_dbg_chip_ident chip;
- int ret;
-
- mutex_lock(&cam->s_mutex);
- if (cam->state != S_NOTREADY)
- cam_warn(cam, "Cam init with device in funky state %d",
- cam->state);
- ret = __mcam_cam_reset(cam);
- if (ret)
- goto out;
- chip.ident = V4L2_IDENT_NONE;
- chip.match.type = V4L2_CHIP_MATCH_I2C_ADDR;
- chip.match.addr = cam->sensor_addr;
- ret = sensor_call(cam, core, g_chip_ident, &chip);
- if (ret)
- goto out;
- cam->sensor_type = chip.ident;
- if (cam->sensor_type != V4L2_IDENT_OV7670) {
- cam_err(cam, "Unsupported sensor type 0x%x", cam->sensor_type);
- ret = -EINVAL;
- goto out;
- }
-/* Get/set parameters? */
- ret = 0;
- cam->state = S_IDLE;
-out:
- mcam_ctlr_power_down(cam);
- mutex_unlock(&cam->s_mutex);
- return ret;
-}
-
-/*
* Configure the sensor to match the parameters we have. Caller should
* hold s_mutex
*/
@@ -1050,7 +956,7 @@ static int mcam_vb_queue_setup(struct vb2_queue *vq,
unsigned int *num_planes, unsigned int sizes[],
void *alloc_ctxs[])
{
- struct mcam_camera *cam = vb2_get_drv_priv(vq);
+ struct mcam_camera *cam = vq_to_mcam(vq);
unsigned int minbufs = (cam->buffer_mode == B_DMA_CONTIG) ? 3 : 2;
sizes[0] = cam->pix_format.sizeimage;
@@ -1066,14 +972,17 @@ static int mcam_vb_queue_setup(struct vb2_queue *vq,
static void mcam_vb_buf_queue(struct vb2_buffer *vb)
{
struct mcam_vb_buffer *mvb = vb_to_mvb(vb);
- struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
+ struct mcam_camera *cam = vq_to_mcam(vb->vb2_queue);
struct v4l2_pix_format *fmt = &cam->pix_format;
unsigned long flags;
int start;
dma_addr_t dma_handle;
+ unsigned long size;
u32 pixel_count = fmt->width * fmt->height;
spin_lock_irqsave(&cam->dev_lock, flags);
+ size = vb2_plane_size(vb, 0);
+ vb2_set_plane_payload(vb, 0, size);
dma_handle = vb2_dma_contig_plane_dma_addr(vb, 0);
BUG_ON(!dma_handle);
start = (cam->state == S_BUFWAIT) && !list_empty(&cam->buffers);
@@ -1112,14 +1021,14 @@ static void mcam_vb_buf_queue(struct vb2_buffer *vb)
*/
static void mcam_vb_wait_prepare(struct vb2_queue *vq)
{
- struct mcam_camera *cam = vb2_get_drv_priv(vq);
+ struct mcam_camera *cam = vq_to_mcam(vq);
mutex_unlock(&cam->s_mutex);
}
static void mcam_vb_wait_finish(struct vb2_queue *vq)
{
- struct mcam_camera *cam = vb2_get_drv_priv(vq);
+ struct mcam_camera *cam = vq_to_mcam(vq);
mutex_lock(&cam->s_mutex);
}
@@ -1129,9 +1038,12 @@ static void mcam_vb_wait_finish(struct vb2_queue *vq)
*/
static int mcam_vb_start_streaming(struct vb2_queue *vq, unsigned int count)
{
- struct mcam_camera *cam = vb2_get_drv_priv(vq);
+ struct mcam_camera *cam = vq_to_mcam(vq);
unsigned int frame;
+ if (count < 2)
+ return -EINVAL;
+
if (cam->state != S_IDLE) {
INIT_LIST_HEAD(&cam->buffers);
return -EINVAL;
@@ -1161,7 +1073,7 @@ static int mcam_vb_start_streaming(struct vb2_queue *vq, unsigned int count)
static int mcam_vb_stop_streaming(struct vb2_queue *vq)
{
- struct mcam_camera *cam = vb2_get_drv_priv(vq);
+ struct mcam_camera *cam = vq_to_mcam(vq);
unsigned long flags;
if (cam->state == S_BUFWAIT) {
@@ -1172,6 +1084,7 @@ static int mcam_vb_stop_streaming(struct vb2_queue *vq)
if (cam->state != S_STREAMING)
return -EINVAL;
mcam_ctlr_stop_dma(cam);
+ cam->state = S_IDLE;
/*
* Reset the CCIC PHY after stopping streaming,
* otherwise, the CCIC may be unstable.
@@ -1207,7 +1120,7 @@ static const struct vb2_ops mcam_vb2_ops = {
static int mcam_vb_sg_buf_init(struct vb2_buffer *vb)
{
struct mcam_vb_buffer *mvb = vb_to_mvb(vb);
- struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
+ struct mcam_camera *cam = vq_to_mcam(vb->vb2_queue);
int ndesc = cam->pix_format.sizeimage/PAGE_SIZE + 1;
mvb->dma_desc = dma_alloc_coherent(cam->dev,
@@ -1223,7 +1136,7 @@ static int mcam_vb_sg_buf_init(struct vb2_buffer *vb)
static int mcam_vb_sg_buf_prepare(struct vb2_buffer *vb)
{
struct mcam_vb_buffer *mvb = vb_to_mvb(vb);
- struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
+ struct mcam_camera *cam = vq_to_mcam(vb->vb2_queue);
struct vb2_dma_sg_desc *sgd = vb2_dma_sg_plane_desc(vb, 0);
struct mcam_dma_desc *desc = mvb->dma_desc;
struct scatterlist *sg;
@@ -1243,7 +1156,7 @@ static int mcam_vb_sg_buf_prepare(struct vb2_buffer *vb)
static int mcam_vb_sg_buf_finish(struct vb2_buffer *vb)
{
- struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
+ struct mcam_camera *cam = vq_to_mcam(vb->vb2_queue);
struct vb2_dma_sg_desc *sgd = vb2_dma_sg_plane_desc(vb, 0);
dma_unmap_sg(cam->dev, sgd->sglist, sgd->num_pages, DMA_FROM_DEVICE);
@@ -1252,7 +1165,7 @@ static int mcam_vb_sg_buf_finish(struct vb2_buffer *vb)
static void mcam_vb_sg_buf_cleanup(struct vb2_buffer *vb)
{
- struct mcam_camera *cam = vb2_get_drv_priv(vb->vb2_queue);
+ struct mcam_camera *cam = vq_to_mcam(vb->vb2_queue);
struct mcam_vb_buffer *mvb = vb_to_mvb(vb);
int ndesc = cam->pix_format.sizeimage/PAGE_SIZE + 1;
@@ -1276,581 +1189,351 @@ static const struct vb2_ops mcam_vb2_sg_ops = {
#endif /* MCAM_MODE_DMA_SG */
-static int mcam_setup_vb2(struct mcam_camera *cam)
-{
- struct vb2_queue *vq = &cam->vb_queue;
-
- memset(vq, 0, sizeof(*vq));
- vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- vq->drv_priv = cam;
- INIT_LIST_HEAD(&cam->buffers);
- switch (cam->buffer_mode) {
- case B_DMA_CONTIG:
-#ifdef MCAM_MODE_DMA_CONTIG
- vq->ops = &mcam_vb2_ops;
- vq->mem_ops = &vb2_dma_contig_memops;
- cam->vb_alloc_ctx = vb2_dma_contig_init_ctx(cam->dev);
- vq->io_modes = VB2_MMAP | VB2_USERPTR;
- cam->dma_setup = mcam_ctlr_dma_contig;
- cam->frame_complete = mcam_dma_contig_done;
-#endif
- break;
- case B_DMA_SG:
-#ifdef MCAM_MODE_DMA_SG
- vq->ops = &mcam_vb2_sg_ops;
- vq->mem_ops = &vb2_dma_sg_memops;
- vq->io_modes = VB2_MMAP | VB2_USERPTR;
- cam->dma_setup = mcam_ctlr_dma_sg;
- cam->frame_complete = mcam_dma_sg_done;
-#endif
- break;
- case B_VMALLOC:
-#ifdef MCAM_MODE_VMALLOC
- tasklet_init(&cam->s_tasklet, mcam_frame_tasklet,
- (unsigned long) cam);
- vq->ops = &mcam_vb2_ops;
- vq->mem_ops = &vb2_vmalloc_memops;
- vq->buf_struct_size = sizeof(struct mcam_vb_buffer);
- vq->io_modes = VB2_MMAP;
- cam->dma_setup = mcam_ctlr_dma_vmalloc;
- cam->frame_complete = mcam_vmalloc_done;
-#endif
- break;
- }
- return vb2_queue_init(vq);
-}
-
-static void mcam_cleanup_vb2(struct mcam_camera *cam)
-{
- vb2_queue_release(&cam->vb_queue);
-#ifdef MCAM_MODE_DMA_CONTIG
- if (cam->buffer_mode == B_DMA_CONTIG)
- vb2_dma_contig_cleanup_ctx(cam->vb_alloc_ctx);
-#endif
-}
-
-
-/* ---------------------------------------------------------------------- */
-/*
- * The long list of V4L2 ioctl() operations.
- */
-
-static int mcam_vidioc_streamon(struct file *filp, void *priv,
- enum v4l2_buf_type type)
+static int mcam_camera_add_device(struct soc_camera_device *icd)
{
- struct mcam_camera *cam = filp->private_data;
+ struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+ struct mcam_camera *mcam = ici->priv;
int ret;
- mutex_lock(&cam->s_mutex);
- ret = vb2_streamon(&cam->vb_queue, type);
- mutex_unlock(&cam->s_mutex);
- return ret;
-}
-
-
-static int mcam_vidioc_streamoff(struct file *filp, void *priv,
- enum v4l2_buf_type type)
-{
- struct mcam_camera *cam = filp->private_data;
- int ret;
-
- mutex_lock(&cam->s_mutex);
- ret = vb2_streamoff(&cam->vb_queue, type);
- mutex_unlock(&cam->s_mutex);
- return ret;
-}
-
-
-static int mcam_vidioc_reqbufs(struct file *filp, void *priv,
- struct v4l2_requestbuffers *req)
-{
- struct mcam_camera *cam = filp->private_data;
- int ret;
-
- mutex_lock(&cam->s_mutex);
- ret = vb2_reqbufs(&cam->vb_queue, req);
- mutex_unlock(&cam->s_mutex);
- return ret;
-}
-
-
-static int mcam_vidioc_querybuf(struct file *filp, void *priv,
- struct v4l2_buffer *buf)
-{
- struct mcam_camera *cam = filp->private_data;
- int ret;
-
- mutex_lock(&cam->s_mutex);
- ret = vb2_querybuf(&cam->vb_queue, buf);
- mutex_unlock(&cam->s_mutex);
- return ret;
-}
-
-static int mcam_vidioc_qbuf(struct file *filp, void *priv,
- struct v4l2_buffer *buf)
-{
- struct mcam_camera *cam = filp->private_data;
- int ret;
+ if (mcam->icd)
+ return -EBUSY;
- mutex_lock(&cam->s_mutex);
- ret = vb2_qbuf(&cam->vb_queue, buf);
- mutex_unlock(&cam->s_mutex);
- return ret;
-}
+ mcam->frame_state.frames = 0;
+ mcam->frame_state.singles = 0;
+ mcam->frame_state.delivered = 0;
+
+ mcam->pll1 = devm_clk_get(mcam->dev, "pll1");
+ if (IS_ERR_OR_NULL(mcam->pll1) && mcam->dphy[2] == 0) {
+ cam_err(mcam, "Could not get pll1 clock\n");
+ if (IS_ERR(mcam->pll1)) {
+ mcam->pll1 = NULL;
+ return PTR_ERR(mcam->pll1);
+ } else
+ return -EINVAL;
+ }
-static int mcam_vidioc_dqbuf(struct file *filp, void *priv,
- struct v4l2_buffer *buf)
-{
- struct mcam_camera *cam = filp->private_data;
- int ret;
+ mcam->flags = 0;
+ mcam->icd = icd;
+ mcam->state = S_IDLE;
+ mcam_ctlr_power_up(mcam);
+ mcam_ctlr_stop(mcam);
+ mcam_set_config_needed(mcam, 1);
+ mcam_reg_write(mcam, REG_CTRL1, C1_RESERVED | C1_DMAPOSTED);
+ mcam_reg_write(mcam, REG_CLKCTRL,
+ (mcam->mclk_src << 29) | mcam->mclk_div);
+ cam_dbg(mcam, "camera: set sensor mclk = %dMHz\n", mcam->mclk_min);
+ /*
+ * Need sleep 1ms to wait for CCIC stable
+ */
+ usleep_range(1000, 2000);
- mutex_lock(&cam->s_mutex);
- ret = vb2_dqbuf(&cam->vb_queue, buf, filp->f_flags & O_NONBLOCK);
- mutex_unlock(&cam->s_mutex);
- return ret;
+ /*
+ * Mask all interrupts.
+ */
+ mcam_reg_write(mcam, REG_IRQMASK, 0);
+ ret = sensor_call(mcam, core, init, 0);
+ /*
+ * When sensor_call return -ENOIOCTLCMD,
+ * means No ioctl command
+ */
+ if ((ret < 0) && (ret != -ENOIOCTLCMD) && (ret != -ENODEV)) {
+ dev_err(icd->parent,
+ "camera: Failed to initialize subdev: %d\n", ret);
+ return ret;
+ }
+ return 0;
}
-
-
-static int mcam_vidioc_queryctrl(struct file *filp, void *priv,
- struct v4l2_queryctrl *qc)
+static void mcam_camera_remove_device(struct soc_camera_device *icd)
{
- struct mcam_camera *cam = priv;
- int ret;
+ struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+ struct mcam_camera *mcam = ici->priv;
- mutex_lock(&cam->s_mutex);
- ret = sensor_call(cam, core, queryctrl, qc);
- mutex_unlock(&cam->s_mutex);
- return ret;
+ BUG_ON(icd != mcam->icd);
+ cam_dbg(mcam, "Release %d frames, %d singles, %d delivered\n",
+ mcam->frame_state.frames, mcam->frame_state.singles,
+ mcam->frame_state.delivered);
+ mcam_config_mipi(mcam, 0);
+ mcam_ctlr_power_down(mcam);
+ mcam->icd = NULL;
}
-
-static int mcam_vidioc_g_ctrl(struct file *filp, void *priv,
- struct v4l2_control *ctrl)
+static int mcam_camera_set_fmt(struct soc_camera_device *icd,
+ struct v4l2_format *f)
{
- struct mcam_camera *cam = priv;
+ struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+ struct mcam_camera *mcam = ici->priv;
+ const struct soc_camera_format_xlate *xlate = NULL;
+ struct v4l2_mbus_framefmt mf;
+ struct v4l2_pix_format *pix = &f->fmt.pix;
int ret;
- mutex_lock(&cam->s_mutex);
- ret = sensor_call(cam, core, g_ctrl, ctrl);
- mutex_unlock(&cam->s_mutex);
- return ret;
-}
-
-
-static int mcam_vidioc_s_ctrl(struct file *filp, void *priv,
- struct v4l2_control *ctrl)
-{
- struct mcam_camera *cam = priv;
- int ret;
-
- mutex_lock(&cam->s_mutex);
- ret = sensor_call(cam, core, s_ctrl, ctrl);
- mutex_unlock(&cam->s_mutex);
- return ret;
-}
-
-
-static int mcam_vidioc_querycap(struct file *file, void *priv,
- struct v4l2_capability *cap)
-{
- strcpy(cap->driver, "marvell_ccic");
- strcpy(cap->card, "marvell_ccic");
- cap->version = 1;
- cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
- V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
- return 0;
-}
-
-
-static int mcam_vidioc_enum_fmt_vid_cap(struct file *filp,
- void *priv, struct v4l2_fmtdesc *fmt)
-{
- if (fmt->index >= N_MCAM_FMTS)
+ cam_dbg(mcam, "camera: set_fmt: %c, width = %u, height = %u\n",
+ pix->pixelformat, pix->width, pix->height);
+ xlate = soc_camera_xlate_by_fourcc(icd, pix->pixelformat);
+ if (!xlate) {
+ cam_err(mcam, "camera: format: %c not found\n",
+ pix->pixelformat);
return -EINVAL;
- strlcpy(fmt->description, mcam_formats[fmt->index].desc,
- sizeof(fmt->description));
- fmt->pixelformat = mcam_formats[fmt->index].pixelformat;
- return 0;
-}
-
-static int mcam_vidioc_try_fmt_vid_cap(struct file *filp, void *priv,
- struct v4l2_format *fmt)
-{
- struct mcam_camera *cam = priv;
- struct mcam_format_struct *f;
- struct v4l2_pix_format *pix = &fmt->fmt.pix;
- struct v4l2_mbus_framefmt mbus_fmt;
- int ret;
-
- f = mcam_find_format(pix->pixelformat);
- pix->pixelformat = f->pixelformat;
- v4l2_fill_mbus_format(&mbus_fmt, pix, f->mbus_code);
- mutex_lock(&cam->s_mutex);
- ret = sensor_call(cam, video, try_mbus_fmt, &mbus_fmt);
- mutex_unlock(&cam->s_mutex);
- v4l2_fill_pix_format(pix, &mbus_fmt);
- switch (f->pixelformat) {
- case V4L2_PIX_FMT_YUV420:
- case V4L2_PIX_FMT_YVU420:
- pix->bytesperline = pix->width * 3 / 2;
- break;
- default:
- pix->bytesperline = pix->width * f->bpp;
- break;
}
- pix->sizeimage = pix->height * pix->bytesperline;
- return ret;
-}
-static int mcam_vidioc_s_fmt_vid_cap(struct file *filp, void *priv,
- struct v4l2_format *fmt)
-{
- struct mcam_camera *cam = priv;
- struct mcam_format_struct *f;
- int ret;
+ mf.width = pix->width;
+ mf.height = pix->height;
+ mf.field = V4L2_FIELD_NONE;
+ mf.colorspace = pix->colorspace;
+ mf.code = xlate->code;
- /*
- * Can't do anything if the device is not idle
- * Also can't if there are streaming buffers in place.
- */
- if (cam->state != S_IDLE || cam->vb_queue.num_buffers > 0)
- return -EBUSY;
+ ret = sensor_call(mcam, video, s_mbus_fmt, &mf);
+ if (ret < 0) {
+ cam_err(mcam, "camera: set_fmt failed %d\n", __LINE__);
+ return ret;
+ }
- f = mcam_find_format(fmt->fmt.pix.pixelformat);
+ if (mf.code != xlate->code) {
+ cam_err(mcam, "camera: wrong code %s %d\n", __func__, __LINE__);
+ return -EINVAL;
+ }
- /*
- * See if the formatting works in principle.
- */
- ret = mcam_vidioc_try_fmt_vid_cap(filp, priv, fmt);
- if (ret)
- return ret;
- /*
- * Now we start to change things for real, so let's do it
- * under lock.
- */
- mutex_lock(&cam->s_mutex);
- cam->pix_format = fmt->fmt.pix;
- cam->mbus_code = f->mbus_code;
+ pix->width = mf.width;
+ pix->height = mf.height;
+ pix->field = mf.field;
+ pix->colorspace = mf.colorspace;
+ mcam->pix_format.sizeimage = pix->sizeimage;
+ icd->current_fmt = xlate;
+ memcpy(&(mcam->pix_format), pix, sizeof(struct v4l2_pix_format));
+ mcam_ctlr_image(mcam);
/*
* Make sure we have appropriate DMA buffers.
*/
- if (cam->buffer_mode == B_VMALLOC) {
- ret = mcam_check_dma_buffers(cam);
+ if (mcam->buffer_mode == B_VMALLOC) {
+ ret = mcam_check_dma_buffers(mcam);
if (ret)
goto out;
}
- mcam_set_config_needed(cam, 1);
+ mcam_set_config_needed(mcam, 1);
out:
- mutex_unlock(&cam->s_mutex);
return ret;
}
-/*
- * Return our stored notion of how the camera is/should be configured.
- * The V4l2 spec wants us to be smarter, and actually get this from
- * the camera (and not mess with it at open time). Someday.
- */
-static int mcam_vidioc_g_fmt_vid_cap(struct file *filp, void *priv,
- struct v4l2_format *f)
+static int mcam_camera_try_fmt(struct soc_camera_device *icd,
+ struct v4l2_format *f)
{
- struct mcam_camera *cam = priv;
+ struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+ struct mcam_camera *mcam = ici->priv;
+ const struct soc_camera_format_xlate *xlate;
+ struct v4l2_pix_format *pix = &f->fmt.pix;
+ struct v4l2_mbus_framefmt mf;
+ __u32 pixfmt = pix->pixelformat;
+ int ret;
- f->fmt.pix = cam->pix_format;
- return 0;
-}
+ xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
+ if (!xlate) {
+ /* using default fmt and try again*/
+ /* to be verified */
+ memcpy(pix, &mcam_def_pix_format,
+ sizeof(struct v4l2_pix_format));
+ }
-/*
- * We only have one input - the sensor - so minimize the nonsense here.
- */
-static int mcam_vidioc_enum_input(struct file *filp, void *priv,
- struct v4l2_input *input)
-{
- if (input->index != 0)
+ xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
+ if (!xlate) {
+ /* it seems something really bad happens */
+ cam_err(mcam, "camera: format: %c not found\n",
+ pix->pixelformat);
return -EINVAL;
+ }
- input->type = V4L2_INPUT_TYPE_CAMERA;
- input->std = V4L2_STD_ALL; /* Not sure what should go here */
- strcpy(input->name, "Camera");
- return 0;
-}
-
-static int mcam_vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
-{
- *i = 0;
- return 0;
-}
+ if (pix->bytesperline < 0)
+ return pix->bytesperline;
-static int mcam_vidioc_s_input(struct file *filp, void *priv, unsigned int i)
-{
- if (i != 0)
- return -EINVAL;
- return 0;
-}
-
-/* from vivi.c */
-static int mcam_vidioc_s_std(struct file *filp, void *priv, v4l2_std_id *a)
-{
- return 0;
-}
+ /*
+ * limit to sensor capabilities
+ */
+ mf.width = pix->width;
+ mf.height = pix->height;
+ mf.field = V4L2_FIELD_NONE;
+ mf.colorspace = pix->colorspace;
+ mf.code = xlate->code;
-/*
- * G/S_PARM. Most of this is done by the sensor, but we are
- * the level which controls the number of read buffers.
- */
-static int mcam_vidioc_g_parm(struct file *filp, void *priv,
- struct v4l2_streamparm *parms)
-{
- struct mcam_camera *cam = priv;
- int ret;
+ ret = sensor_call(mcam, video, try_mbus_fmt, &mf);
+ if (ret < 0)
+ return ret;
- mutex_lock(&cam->s_mutex);
- ret = sensor_call(cam, video, g_parm, parms);
- mutex_unlock(&cam->s_mutex);
- parms->parm.capture.readbuffers = n_dma_bufs;
- return ret;
-}
+ pix->width = mf.width;
+ pix->height = mf.height;
+ pix->colorspace = mf.colorspace;
-static int mcam_vidioc_s_parm(struct file *filp, void *priv,
- struct v4l2_streamparm *parms)
-{
- struct mcam_camera *cam = priv;
- int ret;
+ switch (mf.field) {
+ case V4L2_FIELD_ANY:
+ case V4L2_FIELD_NONE:
+ pix->field = V4L2_FIELD_NONE;
+ break;
+ default:
+ cam_warn(mcam, "cam: Field type %d unsupported.\n", mf.field);
+ pix->field = V4L2_FIELD_NONE;
+ break;
+ }
- mutex_lock(&cam->s_mutex);
- ret = sensor_call(cam, video, s_parm, parms);
- mutex_unlock(&cam->s_mutex);
- parms->parm.capture.readbuffers = n_dma_bufs;
return ret;
}
-static int mcam_vidioc_g_chip_ident(struct file *file, void *priv,
- struct v4l2_dbg_chip_ident *chip)
+static int mcam_camera_init_videobuf(struct vb2_queue *q,
+ struct soc_camera_device *icd)
{
- struct mcam_camera *cam = priv;
+ struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+ struct mcam_camera *cam = ici->priv;
- chip->ident = V4L2_IDENT_NONE;
- chip->revision = 0;
- if (v4l2_chip_match_host(&chip->match)) {
- chip->ident = cam->chip_id;
- return 0;
+ memset(q, 0, sizeof(*q));
+ q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ q->drv_priv = icd;
+ INIT_LIST_HEAD(&cam->buffers);
+ q->buf_struct_size = sizeof(struct mcam_vb_buffer);
+ switch (cam->buffer_mode) {
+ case B_DMA_CONTIG:
+#ifdef MCAM_MODE_DMA_CONTIG
+ q->ops = &mcam_vb2_ops;
+ q->mem_ops = &vb2_dma_contig_memops;
+ cam->vb_alloc_ctx = vb2_dma_contig_init_ctx(cam->dev);
+ q->io_modes = VB2_MMAP | VB2_USERPTR;
+ cam->dma_setup = mcam_ctlr_dma_contig;
+ cam->frame_complete = mcam_dma_contig_done;
+#endif
+ break;
+ case B_DMA_SG:
+#ifdef MCAM_MODE_DMA_SG
+ q->ops = &mcam_vb2_sg_ops;
+ q->mem_ops = &vb2_dma_sg_memops;
+ q->io_modes = VB2_MMAP | VB2_USERPTR;
+ cam->dma_setup = mcam_ctlr_dma_sg;
+ cam->frame_complete = mcam_dma_sg_done;
+#endif
+ break;
+ case B_VMALLOC:
+#ifdef MCAM_MODE_VMALLOC
+ tasklet_init(&cam->s_tasklet, mcam_frame_tasklet,
+ (unsigned long) cam);
+ q->ops = &mcam_vb2_ops;
+ q->mem_ops = &vb2_vmalloc_memops;
+ q->io_modes = VB2_MMAP;
+ cam->dma_setup = mcam_ctlr_dma_vmalloc;
+ cam->frame_complete = mcam_vmalloc_done;
+#endif
+ break;
}
- return sensor_call(cam, core, g_chip_ident, chip);
+ return vb2_queue_init(q);
}
-static int mcam_vidioc_enum_framesizes(struct file *filp, void *priv,
- struct v4l2_frmsizeenum *sizes)
+static unsigned int mcam_camera_poll(struct file *file, poll_table *pt)
{
- struct mcam_camera *cam = priv;
- int ret;
+ struct soc_camera_device *icd = file->private_data;
- mutex_lock(&cam->s_mutex);
- ret = sensor_call(cam, video, enum_framesizes, sizes);
- mutex_unlock(&cam->s_mutex);
- return ret;
+ return vb2_poll(&icd->vb2_vidq, file, pt);
}
-static int mcam_vidioc_enum_frameintervals(struct file *filp, void *priv,
- struct v4l2_frmivalenum *interval)
+static int mcam_camera_querycap(struct soc_camera_host *ici,
+ struct v4l2_capability *cap)
{
- struct mcam_camera *cam = priv;
- int ret;
+ struct mcam_camera *mcam = ici->priv;
- mutex_lock(&cam->s_mutex);
- ret = sensor_call(cam, video, enum_frameintervals, interval);
- mutex_unlock(&cam->s_mutex);
- return ret;
-}
+ cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+ cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
-#ifdef CONFIG_VIDEO_ADV_DEBUG
-static int mcam_vidioc_g_register(struct file *file, void *priv,
- struct v4l2_dbg_register *reg)
-{
- struct mcam_camera *cam = priv;
+ strcpy(cap->card, mcam->card_name);
+ strcpy(cap->driver, "marvell_ccic");
- if (v4l2_chip_match_host(®->match)) {
- reg->val = mcam_reg_read(cam, reg->reg);
- reg->size = 4;
- return 0;
- }
- return sensor_call(cam, core, g_register, reg);
+ return 0;
}
-static int mcam_vidioc_s_register(struct file *file, void *priv,
- struct v4l2_dbg_register *reg)
+static int mcam_camera_set_bus_param(struct soc_camera_device *icd)
{
- struct mcam_camera *cam = priv;
-
- if (v4l2_chip_match_host(®->match)) {
- mcam_reg_write(cam, reg->reg, reg->val);
- return 0;
- }
- return sensor_call(cam, core, s_register, reg);
+ return 0;
}
-#endif
-
-static const struct v4l2_ioctl_ops mcam_v4l_ioctl_ops = {
- .vidioc_querycap = mcam_vidioc_querycap,
- .vidioc_enum_fmt_vid_cap = mcam_vidioc_enum_fmt_vid_cap,
- .vidioc_try_fmt_vid_cap = mcam_vidioc_try_fmt_vid_cap,
- .vidioc_s_fmt_vid_cap = mcam_vidioc_s_fmt_vid_cap,
- .vidioc_g_fmt_vid_cap = mcam_vidioc_g_fmt_vid_cap,
- .vidioc_enum_input = mcam_vidioc_enum_input,
- .vidioc_g_input = mcam_vidioc_g_input,
- .vidioc_s_input = mcam_vidioc_s_input,
- .vidioc_s_std = mcam_vidioc_s_std,
- .vidioc_reqbufs = mcam_vidioc_reqbufs,
- .vidioc_querybuf = mcam_vidioc_querybuf,
- .vidioc_qbuf = mcam_vidioc_qbuf,
- .vidioc_dqbuf = mcam_vidioc_dqbuf,
- .vidioc_streamon = mcam_vidioc_streamon,
- .vidioc_streamoff = mcam_vidioc_streamoff,
- .vidioc_queryctrl = mcam_vidioc_queryctrl,
- .vidioc_g_ctrl = mcam_vidioc_g_ctrl,
- .vidioc_s_ctrl = mcam_vidioc_s_ctrl,
- .vidioc_g_parm = mcam_vidioc_g_parm,
- .vidioc_s_parm = mcam_vidioc_s_parm,
- .vidioc_enum_framesizes = mcam_vidioc_enum_framesizes,
- .vidioc_enum_frameintervals = mcam_vidioc_enum_frameintervals,
- .vidioc_g_chip_ident = mcam_vidioc_g_chip_ident,
-#ifdef CONFIG_VIDEO_ADV_DEBUG
- .vidioc_g_register = mcam_vidioc_g_register,
- .vidioc_s_register = mcam_vidioc_s_register,
-#endif
-};
-/* ---------------------------------------------------------------------- */
-/*
- * Our various file operations.
- */
-static int mcam_v4l_open(struct file *filp)
+static int mcam_camera_get_formats(struct soc_camera_device *icd, u32 idx,
+ struct soc_camera_format_xlate *xlate)
{
- struct mcam_camera *cam = video_drvdata(filp);
- int ret = 0;
+ struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+ struct mcam_camera *mcam = ici->priv;
+ enum v4l2_mbus_pixelcode code;
+ const struct soc_mbus_pixelfmt *fmt;
+ int formats = 0, ret, i;
- filp->private_data = cam;
+ ret = sensor_call(mcam, video, enum_mbus_fmt, idx, &code);
+ if (ret < 0)
+ /*
+ * No more formats
+ */
+ return 0;
- cam->frame_state.frames = 0;
- cam->frame_state.singles = 0;
- cam->frame_state.delivered = 0;
- mutex_lock(&cam->s_mutex);
- if (cam->users == 0) {
- ret = mcam_setup_vb2(cam);
- if (ret)
- goto out;
- mcam_ctlr_power_up(cam);
- __mcam_cam_reset(cam);
- mcam_set_config_needed(cam, 1);
+ fmt = soc_mbus_get_fmtdesc(code);
+ if (!fmt) {
+ cam_err(mcam, "camera: Invalid format #%u: %d\n", idx, code);
+ return 0;
}
- (cam->users)++;
- if (cam->bus_type == V4L2_MBUS_CSI2) {
- cam->pll1 = devm_clk_get(cam->dev, "pll1");
- if (IS_ERR_OR_NULL(cam->pll1) && cam->dphy[2] == 0) {
- cam_err(cam, "Could not get pll1 clock\n");
- if (IS_ERR(cam->pll1))
- ret = PTR_ERR(cam->pll1);
- else
- ret = -EINVAL;
+
+ switch (code) {
+ /*
+ * Refer to mbus_fmt struct
+ */
+ case V4L2_MBUS_FMT_UYVY8_2X8:
+ /*
+ * Add support for YUV420 and YUV422P
+ */
+ formats = ARRAY_SIZE(mcam_formats);
+ if (xlate) {
+ for (i = 0; i < ARRAY_SIZE(mcam_formats); i++) {
+ xlate->host_fmt = &mcam_formats[i];
+ xlate->code = code;
+ xlate++;
+ }
}
+ return formats;
+ case V4L2_MBUS_FMT_JPEG_1X8:
+ if (xlate)
+ cam_dbg(mcam, "camera: Providing format: %s\n",
+ fmt->name);
+ break;
+ default:
+ /*
+ * camera controller can not support
+ * this format, which might supported by the sensor
+ */
+ cam_warn(mcam, "camera: Not support fmt: %s\n", fmt->name);
+ return 0;
}
-out:
- mutex_unlock(&cam->s_mutex);
- return ret;
-}
-
-static int mcam_v4l_release(struct file *filp)
-{
- struct mcam_camera *cam = filp->private_data;
-
- cam_dbg(cam, "Release, %d frames, %d singles, %d delivered\n",
- cam->frame_state.frames, cam->frame_state.singles,
- cam->frame_state.delivered);
- mutex_lock(&cam->s_mutex);
- (cam->users)--;
- if (cam->users == 0) {
- mcam_ctlr_stop_dma(cam);
- mcam_cleanup_vb2(cam);
- mcam_config_mipi(cam, 0);
- mcam_ctlr_power_down(cam);
- if (cam->buffer_mode == B_VMALLOC && alloc_bufs_at_read)
- mcam_free_dma_bufs(cam);
- }
- if (cam->bus_type == V4L2_MBUS_CSI2) {
- devm_clk_put(cam->dev, cam->pll1);
- cam->pll1 = NULL;
+ formats++;
+ if (xlate) {
+ xlate->host_fmt = fmt;
+ xlate->code = code;
+ xlate++;
}
- mutex_unlock(&cam->s_mutex);
- return 0;
-}
-
-static ssize_t mcam_v4l_read(struct file *filp,
- char __user *buffer, size_t len, loff_t *pos)
-{
- struct mcam_camera *cam = filp->private_data;
- int ret;
-
- mutex_lock(&cam->s_mutex);
- ret = vb2_read(&cam->vb_queue, buffer, len, pos,
- filp->f_flags & O_NONBLOCK);
- mutex_unlock(&cam->s_mutex);
- return ret;
-}
-
-
-
-static unsigned int mcam_v4l_poll(struct file *filp,
- struct poll_table_struct *pt)
-{
- struct mcam_camera *cam = filp->private_data;
- int ret;
-
- mutex_lock(&cam->s_mutex);
- ret = vb2_poll(&cam->vb_queue, filp, pt);
- mutex_unlock(&cam->s_mutex);
- return ret;
-}
-
+ return formats;
+}
+
+struct soc_camera_host_ops mcam_soc_camera_host_ops = {
+ .owner = THIS_MODULE,
+ .add = mcam_camera_add_device,
+ .remove = mcam_camera_remove_device,
+ .set_fmt = mcam_camera_set_fmt,
+ .try_fmt = mcam_camera_try_fmt,
+ .init_videobuf2 = mcam_camera_init_videobuf,
+ .poll = mcam_camera_poll,
+ .querycap = mcam_camera_querycap,
+ .set_bus_param = mcam_camera_set_bus_param,
+ .get_formats = mcam_camera_get_formats,
+};
-static int mcam_v4l_mmap(struct file *filp, struct vm_area_struct *vma)
+int mcam_soc_camera_host_register(struct mcam_camera *mcam)
{
- struct mcam_camera *cam = filp->private_data;
- int ret;
-
- mutex_lock(&cam->s_mutex);
- ret = vb2_mmap(&cam->vb_queue, vma);
- mutex_unlock(&cam->s_mutex);
- return ret;
+ mcam->soc_host.drv_name = "mmp-camera";
+ mcam->soc_host.ops = &mcam_soc_camera_host_ops;
+ mcam->soc_host.priv = mcam;
+ mcam->soc_host.v4l2_dev.dev = mcam->dev;
+ mcam->soc_host.nr = mcam->ccic_id;
+ return soc_camera_host_register(&mcam->soc_host);
}
-
-
-static const struct v4l2_file_operations mcam_v4l_fops = {
- .owner = THIS_MODULE,
- .open = mcam_v4l_open,
- .release = mcam_v4l_release,
- .read = mcam_v4l_read,
- .poll = mcam_v4l_poll,
- .mmap = mcam_v4l_mmap,
- .unlocked_ioctl = video_ioctl2,
-};
-
-
-/*
- * This template device holds all of those v4l2 methods; we
- * clone it for specific real devices.
- */
-static struct video_device mcam_v4l_template = {
- .name = "mcam",
- .tvnorms = V4L2_STD_NTSC_M,
- .current_norm = V4L2_STD_NTSC_M, /* make mplayer happy */
-
- .fops = &mcam_v4l_fops,
- .ioctl_ops = &mcam_v4l_ioctl_ops,
- .release = video_device_release_empty,
-};
-
/* ---------------------------------------------------------------------- */
/*
* Interrupt handler stuff
@@ -1925,51 +1608,29 @@ int mccic_irq(struct mcam_camera *cam, unsigned int irqs)
return handled;
}
-/* ---------------------------------------------------------------------- */
-/*
- * Registration and such.
- */
-static struct ov7670_config sensor_cfg = {
- /*
- * Exclude QCIF mode, because it only captures a tiny portion
- * of the sensor FOV
- */
- .min_width = 320,
- .min_height = 240,
-};
-
-
int mccic_register(struct mcam_camera *cam)
{
- struct i2c_board_info ov7670_info = {
- .type = "ov7670",
- .addr = 0x42 >> 1,
- .platform_data = &sensor_cfg,
- };
int ret;
+ if (buffer_mode >= 0)
+ cam->buffer_mode = buffer_mode;
/*
* Validate the requested buffer mode.
*/
- if (buffer_mode >= 0)
- cam->buffer_mode = buffer_mode;
- if (cam->buffer_mode == B_DMA_SG &&
- cam->chip_id == V4L2_IDENT_CAFE) {
- printk(KERN_ERR "marvell-cam: Cafe can't do S/G I/O, "
- "attempting vmalloc mode instead\n");
- cam->buffer_mode = B_VMALLOC;
- }
if (!mcam_buffer_mode_supported(cam->buffer_mode)) {
- printk(KERN_ERR "marvell-cam: buffer mode %d unsupported\n",
+ cam_err(cam, "marvell-cam: buffer mode %d unsupported\n",
cam->buffer_mode);
return -EINVAL;
}
- /*
- * Register with V4L
- */
- ret = v4l2_device_register(cam->dev, &cam->v4l2_dev);
- if (ret)
- return ret;
+
+#ifdef MCAM_MODE_DMA_CONTIG
+ if (cam->buffer_mode == B_DMA_CONTIG) {
+ cam->vb_alloc_ctx =
+ vb2_dma_contig_init_ctx(cam->dev);
+ if (IS_ERR(cam->vb_alloc_ctx))
+ return PTR_ERR(cam->vb_alloc_ctx);
+ }
+#endif
mutex_init(&cam->s_mutex);
cam->state = S_NOTREADY;
@@ -1977,56 +1638,20 @@ int mccic_register(struct mcam_camera *cam)
cam->pix_format = mcam_def_pix_format;
cam->mbus_code = mcam_def_mbus_code;
INIT_LIST_HEAD(&cam->buffers);
- mcam_ctlr_init(cam);
-
- /*
- * Try to find the sensor.
- */
- sensor_cfg.clock_speed = cam->clock_speed;
- sensor_cfg.use_smbus = cam->use_smbus;
- cam->sensor_addr = ov7670_info.addr;
- cam->sensor = v4l2_i2c_new_subdev_board(&cam->v4l2_dev,
- cam->i2c_adapter, &ov7670_info, NULL);
- if (cam->sensor == NULL) {
- ret = -ENODEV;
- goto out_unregister;
- }
-
- ret = mcam_cam_init(cam);
- if (ret)
- goto out_unregister;
- /*
- * Get the v4l2 setup done.
- */
- mutex_lock(&cam->s_mutex);
- cam->vdev = mcam_v4l_template;
- cam->vdev.debug = 0;
- cam->vdev.v4l2_dev = &cam->v4l2_dev;
- ret = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
- if (ret)
- goto out;
- video_set_drvdata(&cam->vdev, cam);
-
- /*
- * If so requested, try to get our DMA buffers now.
- */
- if (cam->buffer_mode == B_VMALLOC && !alloc_bufs_at_read) {
- if (mcam_alloc_dma_bufs(cam, 1))
- cam_warn(cam, "Unable to alloc DMA buffers at load"
- " will try again later.");
+ ret = mcam_soc_camera_host_register(cam);
+#ifdef MCAM_MODE_DMA_CONTIG
+ if ((cam->buffer_mode == B_DMA_CONTIG) && ret) {
+ vb2_dma_contig_cleanup_ctx(cam->vb_alloc_ctx);
+ cam->vb_alloc_ctx = NULL;
}
-
-out:
- mutex_unlock(&cam->s_mutex);
- return ret;
-out_unregister:
- v4l2_device_unregister(&cam->v4l2_dev);
+#endif
return ret;
}
void mccic_shutdown(struct mcam_camera *cam)
{
+ struct soc_camera_host *soc_host = &cam->soc_host;
/*
* If we have no users (and we really, really should have no
* users) the device will already be powered down. Trying to
@@ -2037,11 +1662,14 @@ void mccic_shutdown(struct mcam_camera *cam)
cam_warn(cam, "Removing a device with users!\n");
mcam_ctlr_power_down(cam);
}
- vb2_queue_release(&cam->vb_queue);
- if (cam->buffer_mode == B_VMALLOC)
- mcam_free_dma_bufs(cam);
- video_unregister_device(&cam->vdev);
- v4l2_device_unregister(&cam->v4l2_dev);
+
+ soc_camera_host_unregister(soc_host);
+#ifdef MCAM_MODE_DMA_CONTIG
+ if (cam->buffer_mode == B_DMA_CONTIG) {
+ vb2_dma_contig_cleanup_ctx(cam->vb_alloc_ctx);
+ cam->vb_alloc_ctx = NULL;
+ }
+#endif
}
/*
diff --git a/drivers/media/platform/marvell-ccic/mcam-core.h b/drivers/media/platform/marvell-ccic/mcam-core.h
index 4cb68e0..12af7d2 100755
--- a/drivers/media/platform/marvell-ccic/mcam-core.h
+++ b/drivers/media/platform/marvell-ccic/mcam-core.h
@@ -10,6 +10,8 @@
#include <media/v4l2-common.h>
#include <media/v4l2-dev.h>
#include <media/videobuf2-core.h>
+#include <media/soc_camera.h>
+#include <media/soc_mediabus.h>
/*
* Create our own symbols for the supported buffer modes, but, for now,
@@ -91,6 +93,8 @@ struct mcam_frame_state {
* dev_lock is also required for access to device registers.
*/
struct mcam_camera {
+ struct soc_camera_host soc_host;
+ struct soc_camera_device *icd;
/*
* These fields should be set by the platform code prior to
* calling mcam_register().
@@ -104,6 +108,10 @@ struct mcam_camera {
short int use_smbus; /* SMBUS or straight I2c? */
enum mcam_buffer_mode buffer_mode;
+ int mclk_min;
+ int mclk_src;
+ int mclk_div;
+ char *card_name;
int ccic_id;
enum v4l2_mbus_type bus_type;
/* MIPI support */
@@ -133,15 +141,8 @@ struct mcam_camera {
int users; /* How many open FDs */
struct mcam_frame_state frame_state; /* Frame state counter */
- /*
- * Subsystem structures.
- */
- struct video_device vdev;
- struct v4l2_subdev *sensor;
- unsigned short sensor_addr;
/* Videobuf2 stuff */
- struct vb2_queue vb_queue;
struct list_head buffers; /* Available frames */
unsigned int nbufs; /* How many are alloc'd */
@@ -166,7 +167,6 @@ struct mcam_camera {
void (*frame_complete)(struct mcam_camera *cam, unsigned int frame);
/* Current operating parameters */
- u32 sensor_type; /* Currently ov7670 only */
struct v4l2_pix_format pix_format;
enum v4l2_mbus_pixelcode mbus_code;
@@ -216,6 +216,14 @@ static inline void mcam_reg_set_bit(struct mcam_camera *cam,
mcam_reg_write_mask(cam, reg, val, val);
}
+static inline struct mcam_camera *vq_to_mcam(struct vb2_queue *vq)
+{
+ struct soc_camera_device *icd = container_of(vq,
+ struct soc_camera_device, vb2_vidq);
+ struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+ return ici->priv;
+}
+
/*
* Functions for use by platform code.
*/
@@ -258,6 +266,7 @@ int mccic_resume(struct mcam_camera *cam);
#define IMGP_YP_MASK 0x00003ffc /* Y pitch field */
#define IMGP_UVP_SHFT 18 /* UV pitch (planar) */
#define IMGP_UVP_MASK 0x3ffc0000
+/* Bits below IRQ_TWSI* are not present in mmp */
#define REG_IRQSTATRAW 0x28 /* RAW IRQ Status */
#define IRQ_EOF0 0x00000001 /* End of frame 0 */
#define IRQ_EOF1 0x00000002 /* End of frame 1 */
@@ -333,6 +342,7 @@ int mccic_resume(struct mcam_camera *cam);
/* Bits below C1_444ALPHA are not present in Cafe */
#define REG_CTRL1 0x40 /* Control 1 */
#define C1_CLKGATE 0x00000001 /* Sensor clock gate */
+#define C1_RESERVED 0x0000003c /* Reserved and shouldn't be changed */
#define C1_DESC_ENA 0x00000100 /* DMA descriptor enable */
#define C1_DESC_3WORD 0x00000200 /* Three-word descriptors used */
#define C1_444ALPHA 0x00f00000 /* Alpha field in RGB444 */
@@ -343,6 +353,7 @@ int mccic_resume(struct mcam_camera *cam);
#define C1_DMAB_MASK 0x06000000
#define C1_TWOBUFS 0x08000000 /* Use only two DMA buffers */
#define C1_PWRDWN 0x10000000 /* Power down */
+#define C1_DMAPOSTED 0x40000000 /* DMA Posted Select */
#define REG_CLKCTRL 0x88 /* Clock control */
#define CLK_DIV_MASK 0x0000ffff /* Upper bits RW "reserved" */
diff --git a/drivers/media/platform/marvell-ccic/mmp-driver.c b/drivers/media/platform/marvell-ccic/mmp-driver.c
index 732af16..3d5db24 100755
--- a/drivers/media/platform/marvell-ccic/mmp-driver.c
+++ b/drivers/media/platform/marvell-ccic/mmp-driver.c
@@ -28,6 +28,10 @@
#include <linux/list.h>
#include <linux/pm.h>
#include <linux/clk.h>
+#include <linux/regulator/consumer.h>
+#include <media/videobuf2-dma-contig.h>
+#include <media/soc_camera.h>
+#include <media/soc_mediabus.h>
#include "mcam-core.h"
@@ -140,23 +144,13 @@ static void mmpcam_power_up_ctlr(struct mmp_camera *cam)
static void mmpcam_power_up(struct mcam_camera *mcam)
{
struct mmp_camera *cam = mcam_to_cam(mcam);
- struct mmp_camera_platform_data *pdata;
+
/*
* Turn on power and clocks to the controller.
*/
mmpcam_power_up_ctlr(cam);
-/*
- * Provide power to the sensor.
- */
mcam_reg_write(mcam, REG_CLKCTRL, 0x60000002);
- pdata = cam->pdev->dev.platform_data;
- gpio_set_value(pdata->sensor_power_gpio, 1);
- mdelay(5);
mcam_reg_clear_bit(mcam, REG_CTRL1, 0x10000000);
- gpio_set_value(pdata->sensor_reset_gpio, 0); /* reset is active low */
- mdelay(5);
- gpio_set_value(pdata->sensor_reset_gpio, 1); /* reset is active low */
- mdelay(5);
mcam_clk_enable(mcam);
}
@@ -164,18 +158,12 @@ static void mmpcam_power_up(struct mcam_camera *mcam)
static void mmpcam_power_down(struct mcam_camera *mcam)
{
struct mmp_camera *cam = mcam_to_cam(mcam);
- struct mmp_camera_platform_data *pdata;
+
/*
* Turn off clocks and set reset lines
*/
iowrite32(0, cam->power_regs + REG_CCIC_DCGCR);
iowrite32(0, cam->power_regs + REG_CCIC_CRCR);
-/*
- * Shut down the sensor.
- */
- pdata = cam->pdev->dev.platform_data;
- gpio_set_value(pdata->sensor_power_gpio, 0);
- gpio_set_value(pdata->sensor_reset_gpio, 0);
mcam_clk_disable(mcam);
}
@@ -349,6 +337,7 @@ static int mmpcam_probe(struct platform_device *pdev)
INIT_LIST_HEAD(&cam->devlist);
mcam = &cam->mcam;
+ spin_lock_init(&mcam->dev_lock);
mcam->plat_power_up = mmpcam_power_up;
mcam->plat_power_down = mmpcam_power_down;
mcam->ctlr_reset = mcam_ctlr_reset;
@@ -356,6 +345,11 @@ static int mmpcam_probe(struct platform_device *pdev)
mcam->dev = &pdev->dev;
mcam->use_smbus = 0;
mcam->ccic_id = pdev->id;
+ mcam->card_name = pdata->name;
+ mcam->mclk_min = pdata->mclk_min;
+ mcam->mclk_src = pdata->mclk_src;
+ mcam->mclk_div = pdata->mclk_div;
+ mcam->chip_id = pdata->chip_id;
mcam->bus_type = pdata->bus_type;
mcam->dphy = pdata->dphy;
/* mosetly it won't happen. dphy is an array in pdata, but in case .. */
@@ -364,9 +358,9 @@ static int mmpcam_probe(struct platform_device *pdev)
mcam->mipi_enabled = 0;
mcam->lane = pdata->lane;
- mcam->chip_id = V4L2_IDENT_ARMADA610;
- mcam->buffer_mode = B_DMA_SG;
- spin_lock_init(&mcam->dev_lock);
+ /* set B_DMA_CONTIG as default */
+ mcam->buffer_mode = B_DMA_CONTIG;
+ INIT_LIST_HEAD(&mcam->buffers);
/*
* Get our I/O memory.
*/
@@ -398,41 +392,10 @@ static int mmpcam_probe(struct platform_device *pdev)
ret = mcam_init_clk(mcam, pdata);
if (ret)
return ret;
- /*
- * Find the i2c adapter. This assumes, of course, that the
- * i2c bus is already up and functioning.
- */
- mcam->i2c_adapter = platform_get_drvdata(pdata->i2c_device);
- if (mcam->i2c_adapter == NULL) {
- dev_err(&pdev->dev, "No i2c adapter\n");
- return -ENODEV;
- }
- /*
- * Sensor GPIO pins.
- */
- ret = devm_gpio_request(&pdev->dev, pdata->sensor_power_gpio,
- "cam-power");
- if (ret) {
- dev_err(&pdev->dev, "Can't get sensor power gpio %d",
- pdata->sensor_power_gpio);
- return ret;
- }
- gpio_direction_output(pdata->sensor_power_gpio, 0);
- ret = devm_gpio_request(&pdev->dev, pdata->sensor_reset_gpio,
- "cam-reset");
- if (ret) {
- dev_err(&pdev->dev, "Can't get sensor reset gpio %d",
- pdata->sensor_reset_gpio);
- return ret;
- }
- gpio_direction_output(pdata->sensor_reset_gpio, 0);
- /*
- * Power the device up and hand it off to the core.
- */
- mmpcam_power_up(mcam);
+
ret = mccic_register(mcam);
if (ret)
- goto out_power_down;
+ return ret;
/*
* Finally, set up our IRQ now that the core is ready to
* deal with it.
@@ -452,8 +415,6 @@ static int mmpcam_probe(struct platform_device *pdev)
out_unregister:
mccic_shutdown(mcam);
-out_power_down:
- mmpcam_power_down(mcam);
return ret;
}
diff --git a/include/media/mmp-camera.h b/include/media/mmp-camera.h
index 813efe2..513d846 100755
--- a/include/media/mmp-camera.h
+++ b/include/media/mmp-camera.h
@@ -7,7 +7,12 @@ struct mmp_camera_platform_data {
struct platform_device *i2c_device;
int sensor_power_gpio;
int sensor_reset_gpio;
+ char name[16];
enum v4l2_mbus_type bus_type;
+ int mclk_min;
+ int mclk_src;
+ int mclk_div;
+ int chip_id;
/*
* MIPI support
*/
--
1.7.9.5
--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
