2008-04-07 08:24:56 +08:00
|
|
|
/*
|
|
|
|
* V4L2 Driver for PXA camera host
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006, Sascha Hauer, Pengutronix
|
|
|
|
* Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/module.h>
|
2008-04-15 13:57:48 +08:00
|
|
|
#include <linux/io.h>
|
2008-04-07 08:24:56 +08:00
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/version.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/clk.h>
|
2009-11-05 01:18:04 +08:00
|
|
|
#include <linux/sched.h>
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
#include <media/v4l2-common.h>
|
|
|
|
#include <media/v4l2-dev.h>
|
2008-07-12 07:50:31 +08:00
|
|
|
#include <media/videobuf-dma-sg.h>
|
2008-04-07 08:24:56 +08:00
|
|
|
#include <media/soc_camera.h>
|
|
|
|
|
|
|
|
#include <linux/videodev2.h>
|
|
|
|
|
2009-01-02 23:16:02 +08:00
|
|
|
#include <mach/dma.h>
|
2008-08-05 23:14:15 +08:00
|
|
|
#include <mach/camera.h>
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
#define PXA_CAM_VERSION_CODE KERNEL_VERSION(0, 0, 5)
|
|
|
|
#define PXA_CAM_DRV_NAME "pxa27x-camera"
|
|
|
|
|
2008-12-18 22:15:50 +08:00
|
|
|
/* Camera Interface */
|
|
|
|
#define CICR0 0x0000
|
|
|
|
#define CICR1 0x0004
|
|
|
|
#define CICR2 0x0008
|
|
|
|
#define CICR3 0x000C
|
|
|
|
#define CICR4 0x0010
|
|
|
|
#define CISR 0x0014
|
|
|
|
#define CIFR 0x0018
|
|
|
|
#define CITOR 0x001C
|
|
|
|
#define CIBR0 0x0028
|
|
|
|
#define CIBR1 0x0030
|
|
|
|
#define CIBR2 0x0038
|
|
|
|
|
|
|
|
#define CICR0_DMAEN (1 << 31) /* DMA request enable */
|
|
|
|
#define CICR0_PAR_EN (1 << 30) /* Parity enable */
|
|
|
|
#define CICR0_SL_CAP_EN (1 << 29) /* Capture enable for slave mode */
|
|
|
|
#define CICR0_ENB (1 << 28) /* Camera interface enable */
|
|
|
|
#define CICR0_DIS (1 << 27) /* Camera interface disable */
|
|
|
|
#define CICR0_SIM (0x7 << 24) /* Sensor interface mode mask */
|
|
|
|
#define CICR0_TOM (1 << 9) /* Time-out mask */
|
|
|
|
#define CICR0_RDAVM (1 << 8) /* Receive-data-available mask */
|
|
|
|
#define CICR0_FEM (1 << 7) /* FIFO-empty mask */
|
|
|
|
#define CICR0_EOLM (1 << 6) /* End-of-line mask */
|
|
|
|
#define CICR0_PERRM (1 << 5) /* Parity-error mask */
|
|
|
|
#define CICR0_QDM (1 << 4) /* Quick-disable mask */
|
|
|
|
#define CICR0_CDM (1 << 3) /* Disable-done mask */
|
|
|
|
#define CICR0_SOFM (1 << 2) /* Start-of-frame mask */
|
|
|
|
#define CICR0_EOFM (1 << 1) /* End-of-frame mask */
|
|
|
|
#define CICR0_FOM (1 << 0) /* FIFO-overrun mask */
|
|
|
|
|
|
|
|
#define CICR1_TBIT (1 << 31) /* Transparency bit */
|
|
|
|
#define CICR1_RGBT_CONV (0x3 << 29) /* RGBT conversion mask */
|
|
|
|
#define CICR1_PPL (0x7ff << 15) /* Pixels per line mask */
|
|
|
|
#define CICR1_RGB_CONV (0x7 << 12) /* RGB conversion mask */
|
|
|
|
#define CICR1_RGB_F (1 << 11) /* RGB format */
|
|
|
|
#define CICR1_YCBCR_F (1 << 10) /* YCbCr format */
|
|
|
|
#define CICR1_RGB_BPP (0x7 << 7) /* RGB bis per pixel mask */
|
|
|
|
#define CICR1_RAW_BPP (0x3 << 5) /* Raw bis per pixel mask */
|
|
|
|
#define CICR1_COLOR_SP (0x3 << 3) /* Color space mask */
|
|
|
|
#define CICR1_DW (0x7 << 0) /* Data width mask */
|
|
|
|
|
|
|
|
#define CICR2_BLW (0xff << 24) /* Beginning-of-line pixel clock
|
|
|
|
wait count mask */
|
|
|
|
#define CICR2_ELW (0xff << 16) /* End-of-line pixel clock
|
|
|
|
wait count mask */
|
|
|
|
#define CICR2_HSW (0x3f << 10) /* Horizontal sync pulse width mask */
|
|
|
|
#define CICR2_BFPW (0x3f << 3) /* Beginning-of-frame pixel clock
|
|
|
|
wait count mask */
|
|
|
|
#define CICR2_FSW (0x7 << 0) /* Frame stabilization
|
|
|
|
wait count mask */
|
|
|
|
|
|
|
|
#define CICR3_BFW (0xff << 24) /* Beginning-of-frame line clock
|
|
|
|
wait count mask */
|
|
|
|
#define CICR3_EFW (0xff << 16) /* End-of-frame line clock
|
|
|
|
wait count mask */
|
|
|
|
#define CICR3_VSW (0x3f << 10) /* Vertical sync pulse width mask */
|
|
|
|
#define CICR3_BFPW (0x3f << 3) /* Beginning-of-frame pixel clock
|
|
|
|
wait count mask */
|
|
|
|
#define CICR3_LPF (0x7ff << 0) /* Lines per frame mask */
|
|
|
|
|
|
|
|
#define CICR4_MCLK_DLY (0x3 << 24) /* MCLK Data Capture Delay mask */
|
|
|
|
#define CICR4_PCLK_EN (1 << 23) /* Pixel clock enable */
|
|
|
|
#define CICR4_PCP (1 << 22) /* Pixel clock polarity */
|
|
|
|
#define CICR4_HSP (1 << 21) /* Horizontal sync polarity */
|
|
|
|
#define CICR4_VSP (1 << 20) /* Vertical sync polarity */
|
|
|
|
#define CICR4_MCLK_EN (1 << 19) /* MCLK enable */
|
|
|
|
#define CICR4_FR_RATE (0x7 << 8) /* Frame rate mask */
|
|
|
|
#define CICR4_DIV (0xff << 0) /* Clock divisor mask */
|
|
|
|
|
|
|
|
#define CISR_FTO (1 << 15) /* FIFO time-out */
|
|
|
|
#define CISR_RDAV_2 (1 << 14) /* Channel 2 receive data available */
|
|
|
|
#define CISR_RDAV_1 (1 << 13) /* Channel 1 receive data available */
|
|
|
|
#define CISR_RDAV_0 (1 << 12) /* Channel 0 receive data available */
|
|
|
|
#define CISR_FEMPTY_2 (1 << 11) /* Channel 2 FIFO empty */
|
|
|
|
#define CISR_FEMPTY_1 (1 << 10) /* Channel 1 FIFO empty */
|
|
|
|
#define CISR_FEMPTY_0 (1 << 9) /* Channel 0 FIFO empty */
|
|
|
|
#define CISR_EOL (1 << 8) /* End of line */
|
|
|
|
#define CISR_PAR_ERR (1 << 7) /* Parity error */
|
|
|
|
#define CISR_CQD (1 << 6) /* Camera interface quick disable */
|
|
|
|
#define CISR_CDD (1 << 5) /* Camera interface disable done */
|
|
|
|
#define CISR_SOF (1 << 4) /* Start of frame */
|
|
|
|
#define CISR_EOF (1 << 3) /* End of frame */
|
|
|
|
#define CISR_IFO_2 (1 << 2) /* FIFO overrun for Channel 2 */
|
|
|
|
#define CISR_IFO_1 (1 << 1) /* FIFO overrun for Channel 1 */
|
|
|
|
#define CISR_IFO_0 (1 << 0) /* FIFO overrun for Channel 0 */
|
|
|
|
|
|
|
|
#define CIFR_FLVL2 (0x7f << 23) /* FIFO 2 level mask */
|
|
|
|
#define CIFR_FLVL1 (0x7f << 16) /* FIFO 1 level mask */
|
|
|
|
#define CIFR_FLVL0 (0xff << 8) /* FIFO 0 level mask */
|
|
|
|
#define CIFR_THL_0 (0x3 << 4) /* Threshold Level for Channel 0 FIFO */
|
|
|
|
#define CIFR_RESET_F (1 << 3) /* Reset input FIFOs */
|
|
|
|
#define CIFR_FEN2 (1 << 2) /* FIFO enable for channel 2 */
|
|
|
|
#define CIFR_FEN1 (1 << 1) /* FIFO enable for channel 1 */
|
|
|
|
#define CIFR_FEN0 (1 << 0) /* FIFO enable for channel 0 */
|
|
|
|
|
2008-04-15 13:57:48 +08:00
|
|
|
#define CICR0_SIM_MP (0 << 24)
|
|
|
|
#define CICR0_SIM_SP (1 << 24)
|
|
|
|
#define CICR0_SIM_MS (2 << 24)
|
|
|
|
#define CICR0_SIM_EP (3 << 24)
|
|
|
|
#define CICR0_SIM_ES (4 << 24)
|
|
|
|
|
|
|
|
#define CICR1_DW_VAL(x) ((x) & CICR1_DW) /* Data bus width */
|
|
|
|
#define CICR1_PPL_VAL(x) (((x) << 15) & CICR1_PPL) /* Pixels per line */
|
2008-04-22 21:36:32 +08:00
|
|
|
#define CICR1_COLOR_SP_VAL(x) (((x) << 3) & CICR1_COLOR_SP) /* color space */
|
|
|
|
#define CICR1_RGB_BPP_VAL(x) (((x) << 7) & CICR1_RGB_BPP) /* bpp for rgb */
|
|
|
|
#define CICR1_RGBT_CONV_VAL(x) (((x) << 29) & CICR1_RGBT_CONV) /* rgbt conv */
|
2008-04-15 13:57:48 +08:00
|
|
|
|
|
|
|
#define CICR2_BLW_VAL(x) (((x) << 24) & CICR2_BLW) /* Beginning-of-line pixel clock wait count */
|
|
|
|
#define CICR2_ELW_VAL(x) (((x) << 16) & CICR2_ELW) /* End-of-line pixel clock wait count */
|
|
|
|
#define CICR2_HSW_VAL(x) (((x) << 10) & CICR2_HSW) /* Horizontal sync pulse width */
|
|
|
|
#define CICR2_BFPW_VAL(x) (((x) << 3) & CICR2_BFPW) /* Beginning-of-frame pixel clock wait count */
|
|
|
|
#define CICR2_FSW_VAL(x) (((x) << 0) & CICR2_FSW) /* Frame stabilization wait count */
|
|
|
|
|
|
|
|
#define CICR3_BFW_VAL(x) (((x) << 24) & CICR3_BFW) /* Beginning-of-frame line clock wait count */
|
|
|
|
#define CICR3_EFW_VAL(x) (((x) << 16) & CICR3_EFW) /* End-of-frame line clock wait count */
|
|
|
|
#define CICR3_VSW_VAL(x) (((x) << 11) & CICR3_VSW) /* Vertical sync pulse width */
|
|
|
|
#define CICR3_LPF_VAL(x) (((x) << 0) & CICR3_LPF) /* Lines per frame */
|
|
|
|
|
2008-04-07 08:24:56 +08:00
|
|
|
#define CICR0_IRQ_MASK (CICR0_TOM | CICR0_RDAVM | CICR0_FEM | CICR0_EOLM | \
|
|
|
|
CICR0_PERRM | CICR0_QDM | CICR0_CDM | CICR0_SOFM | \
|
|
|
|
CICR0_EOFM | CICR0_FOM)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structures
|
|
|
|
*/
|
2008-04-22 21:36:32 +08:00
|
|
|
enum pxa_camera_active_dma {
|
|
|
|
DMA_Y = 0x1,
|
|
|
|
DMA_U = 0x2,
|
|
|
|
DMA_V = 0x4,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* descriptor needed for the PXA DMA engine */
|
|
|
|
struct pxa_cam_dma {
|
|
|
|
dma_addr_t sg_dma;
|
|
|
|
struct pxa_dma_desc *sg_cpu;
|
|
|
|
size_t sg_size;
|
|
|
|
int sglen;
|
|
|
|
};
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
/* buffer for one video frame */
|
|
|
|
struct pxa_buffer {
|
|
|
|
/* common v4l buffer stuff -- must be first */
|
|
|
|
struct videobuf_buffer vb;
|
|
|
|
|
|
|
|
const struct soc_camera_data_format *fmt;
|
|
|
|
|
2008-04-22 21:36:32 +08:00
|
|
|
/* our descriptor lists for Y, U and V channels */
|
|
|
|
struct pxa_cam_dma dmas[3];
|
|
|
|
|
2008-04-07 08:24:56 +08:00
|
|
|
int inwork;
|
2008-04-22 21:36:32 +08:00
|
|
|
|
|
|
|
enum pxa_camera_active_dma active_dma;
|
2008-04-07 08:24:56 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct pxa_camera_dev {
|
2009-04-24 23:55:18 +08:00
|
|
|
struct soc_camera_host soc_host;
|
2008-04-07 08:24:56 +08:00
|
|
|
/* PXA27x is only supposed to handle one camera on its Quick Capture
|
|
|
|
* interface. If anyone ever builds hardware to enable more than
|
|
|
|
* one camera, they will have to modify this driver too */
|
|
|
|
struct soc_camera_device *icd;
|
|
|
|
struct clk *clk;
|
|
|
|
|
|
|
|
unsigned int irq;
|
|
|
|
void __iomem *base;
|
2008-04-22 21:36:32 +08:00
|
|
|
|
2008-04-22 21:37:49 +08:00
|
|
|
int channels;
|
2008-04-22 21:36:32 +08:00
|
|
|
unsigned int dma_chans[3];
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
struct pxacamera_platform_data *pdata;
|
|
|
|
struct resource *res;
|
|
|
|
unsigned long platform_flags;
|
2008-12-18 22:38:03 +08:00
|
|
|
unsigned long ciclk;
|
|
|
|
unsigned long mclk;
|
|
|
|
u32 mclk_divisor;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
struct list_head capture;
|
|
|
|
|
|
|
|
spinlock_t lock;
|
|
|
|
|
|
|
|
struct pxa_buffer *active;
|
2008-04-22 21:40:23 +08:00
|
|
|
struct pxa_dma_desc *sg_tail[3];
|
2008-08-02 18:10:04 +08:00
|
|
|
|
|
|
|
u32 save_cicr[5];
|
2008-04-07 08:24:56 +08:00
|
|
|
};
|
|
|
|
|
2009-08-25 22:50:46 +08:00
|
|
|
struct pxa_cam {
|
|
|
|
unsigned long flags;
|
|
|
|
};
|
|
|
|
|
2008-04-07 08:24:56 +08:00
|
|
|
static const char *pxa_cam_driver_description = "PXA_Camera";
|
|
|
|
|
|
|
|
static unsigned int vid_limit = 16; /* Video memory limit, in Mb */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Videobuf operations
|
|
|
|
*/
|
2008-04-15 13:57:48 +08:00
|
|
|
static int pxa_videobuf_setup(struct videobuf_queue *vq, unsigned int *count,
|
|
|
|
unsigned int *size)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
|
|
|
struct soc_camera_device *icd = vq->priv_data;
|
|
|
|
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(icd->dev.parent, "count=%d, size=%d\n", *count, *size);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2009-08-25 22:50:46 +08:00
|
|
|
*size = roundup(icd->user_width * icd->user_height *
|
2009-03-31 14:44:21 +08:00
|
|
|
((icd->current_fmt->depth + 7) >> 3), 8);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
if (0 == *count)
|
|
|
|
*count = 32;
|
|
|
|
while (*size * *count > vid_limit * 1024 * 1024)
|
|
|
|
(*count)--;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_buffer(struct videobuf_queue *vq, struct pxa_buffer *buf)
|
|
|
|
{
|
|
|
|
struct soc_camera_device *icd = vq->priv_data;
|
2008-12-18 22:51:55 +08:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
2008-04-07 08:24:56 +08:00
|
|
|
struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);
|
2008-04-22 21:36:32 +08:00
|
|
|
int i;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
BUG_ON(in_interrupt());
|
|
|
|
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(icd->dev.parent, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
|
2008-04-07 08:24:56 +08:00
|
|
|
&buf->vb, buf->vb.baddr, buf->vb.bsize);
|
|
|
|
|
|
|
|
/* This waits until this buffer is out of danger, i.e., until it is no
|
|
|
|
* longer in STATE_QUEUED or STATE_ACTIVE */
|
|
|
|
videobuf_waiton(&buf->vb, 0, 0);
|
|
|
|
videobuf_dma_unmap(vq, dma);
|
|
|
|
videobuf_dma_free(dma);
|
|
|
|
|
2008-04-22 21:36:32 +08:00
|
|
|
for (i = 0; i < ARRAY_SIZE(buf->dmas); i++) {
|
|
|
|
if (buf->dmas[i].sg_cpu)
|
2009-08-25 22:53:23 +08:00
|
|
|
dma_free_coherent(ici->v4l2_dev.dev,
|
|
|
|
buf->dmas[i].sg_size,
|
2008-04-22 21:36:32 +08:00
|
|
|
buf->dmas[i].sg_cpu,
|
|
|
|
buf->dmas[i].sg_dma);
|
|
|
|
buf->dmas[i].sg_cpu = NULL;
|
|
|
|
}
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
buf->vb.state = VIDEOBUF_NEEDS_INIT;
|
|
|
|
}
|
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
static int calculate_dma_sglen(struct scatterlist *sglist, int sglen,
|
|
|
|
int sg_first_ofs, int size)
|
|
|
|
{
|
|
|
|
int i, offset, dma_len, xfer_len;
|
|
|
|
struct scatterlist *sg;
|
|
|
|
|
|
|
|
offset = sg_first_ofs;
|
|
|
|
for_each_sg(sglist, sg, sglen, i) {
|
|
|
|
dma_len = sg_dma_len(sg);
|
|
|
|
|
|
|
|
/* PXA27x Developer's Manual 27.4.4.1: round up to 8 bytes */
|
|
|
|
xfer_len = roundup(min(dma_len - offset, size), 8);
|
|
|
|
|
|
|
|
size = max(0, size - xfer_len);
|
|
|
|
offset = 0;
|
|
|
|
if (size == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
BUG_ON(size != 0);
|
|
|
|
return i + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pxa_init_dma_channel - init dma descriptors
|
|
|
|
* @pcdev: pxa camera device
|
|
|
|
* @buf: pxa buffer to find pxa dma channel
|
|
|
|
* @dma: dma video buffer
|
|
|
|
* @channel: dma channel (0 => 'Y', 1 => 'U', 2 => 'V')
|
|
|
|
* @cibr: camera Receive Buffer Register
|
|
|
|
* @size: bytes to transfer
|
|
|
|
* @sg_first: first element of sg_list
|
|
|
|
* @sg_first_ofs: offset in first element of sg_list
|
|
|
|
*
|
|
|
|
* Prepares the pxa dma descriptors to transfer one camera channel.
|
|
|
|
* Beware sg_first and sg_first_ofs are both input and output parameters.
|
|
|
|
*
|
|
|
|
* Returns 0 or -ENOMEM if no coherent memory is available
|
|
|
|
*/
|
2008-04-22 21:36:32 +08:00
|
|
|
static int pxa_init_dma_channel(struct pxa_camera_dev *pcdev,
|
|
|
|
struct pxa_buffer *buf,
|
|
|
|
struct videobuf_dmabuf *dma, int channel,
|
2009-03-31 14:44:21 +08:00
|
|
|
int cibr, int size,
|
|
|
|
struct scatterlist **sg_first, int *sg_first_ofs)
|
2008-04-22 21:36:32 +08:00
|
|
|
{
|
|
|
|
struct pxa_cam_dma *pxa_dma = &buf->dmas[channel];
|
2009-08-25 22:43:33 +08:00
|
|
|
struct device *dev = pcdev->soc_host.v4l2_dev.dev;
|
2009-03-31 14:44:21 +08:00
|
|
|
struct scatterlist *sg;
|
|
|
|
int i, offset, sglen;
|
|
|
|
int dma_len = 0, xfer_len = 0;
|
2008-04-22 21:36:32 +08:00
|
|
|
|
|
|
|
if (pxa_dma->sg_cpu)
|
2009-08-25 22:43:33 +08:00
|
|
|
dma_free_coherent(dev, pxa_dma->sg_size,
|
2008-04-22 21:36:32 +08:00
|
|
|
pxa_dma->sg_cpu, pxa_dma->sg_dma);
|
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
sglen = calculate_dma_sglen(*sg_first, dma->sglen,
|
|
|
|
*sg_first_ofs, size);
|
|
|
|
|
2008-04-22 21:36:32 +08:00
|
|
|
pxa_dma->sg_size = (sglen + 1) * sizeof(struct pxa_dma_desc);
|
2009-08-25 22:43:33 +08:00
|
|
|
pxa_dma->sg_cpu = dma_alloc_coherent(dev, pxa_dma->sg_size,
|
2008-04-22 21:36:32 +08:00
|
|
|
&pxa_dma->sg_dma, GFP_KERNEL);
|
|
|
|
if (!pxa_dma->sg_cpu)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
pxa_dma->sglen = sglen;
|
2009-03-31 14:44:21 +08:00
|
|
|
offset = *sg_first_ofs;
|
2008-04-22 21:36:32 +08:00
|
|
|
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_dbg(dev, "DMA: sg_first=%p, sglen=%d, ofs=%d, dma.desc=%x\n",
|
2009-03-31 14:44:21 +08:00
|
|
|
*sg_first, sglen, *sg_first_ofs, pxa_dma->sg_dma);
|
2008-04-22 21:36:32 +08:00
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
|
|
|
|
for_each_sg(*sg_first, sg, sglen, i) {
|
|
|
|
dma_len = sg_dma_len(sg);
|
2008-04-22 21:36:32 +08:00
|
|
|
|
|
|
|
/* PXA27x Developer's Manual 27.4.4.1: round up to 8 bytes */
|
2009-03-31 14:44:21 +08:00
|
|
|
xfer_len = roundup(min(dma_len - offset, size), 8);
|
2008-04-22 21:36:32 +08:00
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
size = max(0, size - xfer_len);
|
|
|
|
|
|
|
|
pxa_dma->sg_cpu[i].dsadr = pcdev->res->start + cibr;
|
|
|
|
pxa_dma->sg_cpu[i].dtadr = sg_dma_address(sg) + offset;
|
2008-04-22 21:36:32 +08:00
|
|
|
pxa_dma->sg_cpu[i].dcmd =
|
|
|
|
DCMD_FLOWSRC | DCMD_BURST8 | DCMD_INCTRGADDR | xfer_len;
|
2009-03-31 14:44:21 +08:00
|
|
|
#ifdef DEBUG
|
|
|
|
if (!i)
|
|
|
|
pxa_dma->sg_cpu[i].dcmd |= DCMD_STARTIRQEN;
|
|
|
|
#endif
|
2008-04-22 21:36:32 +08:00
|
|
|
pxa_dma->sg_cpu[i].ddadr =
|
|
|
|
pxa_dma->sg_dma + (i + 1) * sizeof(struct pxa_dma_desc);
|
2009-03-31 14:44:21 +08:00
|
|
|
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_vdbg(dev, "DMA: desc.%08x->@phys=0x%08x, len=%d\n",
|
2009-03-31 14:44:21 +08:00
|
|
|
pxa_dma->sg_dma + i * sizeof(struct pxa_dma_desc),
|
|
|
|
sg_dma_address(sg) + offset, xfer_len);
|
|
|
|
offset = 0;
|
|
|
|
|
|
|
|
if (size == 0)
|
|
|
|
break;
|
2008-04-22 21:36:32 +08:00
|
|
|
}
|
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
pxa_dma->sg_cpu[sglen].ddadr = DDADR_STOP;
|
|
|
|
pxa_dma->sg_cpu[sglen].dcmd = DCMD_FLOWSRC | DCMD_BURST8 | DCMD_ENDIRQEN;
|
2008-04-22 21:36:32 +08:00
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
/*
|
|
|
|
* Handle 1 special case :
|
|
|
|
* - in 3 planes (YUV422P format), we might finish with xfer_len equal
|
|
|
|
* to dma_len (end on PAGE boundary). In this case, the sg element
|
|
|
|
* for next plane should be the next after the last used to store the
|
|
|
|
* last scatter gather RAM page
|
|
|
|
*/
|
|
|
|
if (xfer_len >= dma_len) {
|
|
|
|
*sg_first_ofs = xfer_len - dma_len;
|
|
|
|
*sg_first = sg_next(sg);
|
|
|
|
} else {
|
|
|
|
*sg_first_ofs = xfer_len;
|
|
|
|
*sg_first = sg;
|
|
|
|
}
|
|
|
|
|
2008-04-22 21:36:32 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
static void pxa_videobuf_set_actdma(struct pxa_camera_dev *pcdev,
|
|
|
|
struct pxa_buffer *buf)
|
|
|
|
{
|
|
|
|
buf->active_dma = DMA_Y;
|
|
|
|
if (pcdev->channels == 3)
|
|
|
|
buf->active_dma |= DMA_U | DMA_V;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Please check the DMA prepared buffer structure in :
|
|
|
|
* Documentation/video4linux/pxa_camera.txt
|
|
|
|
* Please check also in pxa_camera_check_link_miss() to understand why DMA chain
|
|
|
|
* modification while DMA chain is running will work anyway.
|
|
|
|
*/
|
2008-04-15 13:57:48 +08:00
|
|
|
static int pxa_videobuf_prepare(struct videobuf_queue *vq,
|
|
|
|
struct videobuf_buffer *vb, enum v4l2_field field)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
|
|
|
struct soc_camera_device *icd = vq->priv_data;
|
2008-12-18 22:51:55 +08:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
2008-04-07 08:24:56 +08:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
2009-08-25 22:43:33 +08:00
|
|
|
struct device *dev = pcdev->soc_host.v4l2_dev.dev;
|
2008-04-07 08:24:56 +08:00
|
|
|
struct pxa_buffer *buf = container_of(vb, struct pxa_buffer, vb);
|
2008-04-22 21:36:32 +08:00
|
|
|
int ret;
|
|
|
|
int size_y, size_u = 0, size_v = 0;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_dbg(dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
|
2008-04-07 08:24:56 +08:00
|
|
|
vb, vb->baddr, vb->bsize);
|
|
|
|
|
|
|
|
/* Added list head initialization on alloc */
|
|
|
|
WARN_ON(!list_empty(&vb->queue));
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
/* This can be useful if you want to see if we actually fill
|
|
|
|
* the buffer with something */
|
|
|
|
memset((void *)vb->baddr, 0xaa, vb->bsize);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
BUG_ON(NULL == icd->current_fmt);
|
|
|
|
|
|
|
|
/* I think, in buf_prepare you only have to protect global data,
|
|
|
|
* the actual buffer is yours */
|
|
|
|
buf->inwork = 1;
|
|
|
|
|
|
|
|
if (buf->fmt != icd->current_fmt ||
|
2009-08-25 22:50:46 +08:00
|
|
|
vb->width != icd->user_width ||
|
|
|
|
vb->height != icd->user_height ||
|
2008-04-07 08:24:56 +08:00
|
|
|
vb->field != field) {
|
|
|
|
buf->fmt = icd->current_fmt;
|
2009-08-25 22:50:46 +08:00
|
|
|
vb->width = icd->user_width;
|
|
|
|
vb->height = icd->user_height;
|
2008-04-07 08:24:56 +08:00
|
|
|
vb->field = field;
|
|
|
|
vb->state = VIDEOBUF_NEEDS_INIT;
|
|
|
|
}
|
|
|
|
|
|
|
|
vb->size = vb->width * vb->height * ((buf->fmt->depth + 7) >> 3);
|
|
|
|
if (0 != vb->baddr && vb->bsize < vb->size) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vb->state == VIDEOBUF_NEEDS_INIT) {
|
2009-03-31 14:44:21 +08:00
|
|
|
int size = vb->size;
|
|
|
|
int next_ofs = 0;
|
2008-04-07 08:24:56 +08:00
|
|
|
struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
|
2009-03-31 14:44:21 +08:00
|
|
|
struct scatterlist *sg;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
ret = videobuf_iolock(vq, vb, NULL);
|
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
2008-04-22 21:40:23 +08:00
|
|
|
if (pcdev->channels == 3) {
|
2008-04-22 21:36:32 +08:00
|
|
|
size_y = size / 2;
|
|
|
|
size_u = size_v = size / 4;
|
|
|
|
} else {
|
|
|
|
size_y = size;
|
|
|
|
}
|
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
sg = dma->sglist;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
/* init DMA for Y channel */
|
|
|
|
ret = pxa_init_dma_channel(pcdev, buf, dma, 0, CIBR0, size_y,
|
|
|
|
&sg, &next_ofs);
|
2008-04-22 21:36:32 +08:00
|
|
|
if (ret) {
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_err(dev, "DMA initialization for Y/RGB failed\n");
|
2008-04-07 08:24:56 +08:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
/* init DMA for U channel */
|
|
|
|
if (size_u)
|
|
|
|
ret = pxa_init_dma_channel(pcdev, buf, dma, 1, CIBR1,
|
|
|
|
size_u, &sg, &next_ofs);
|
|
|
|
if (ret) {
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_err(dev, "DMA initialization for U failed\n");
|
2009-03-31 14:44:21 +08:00
|
|
|
goto fail_u;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* init DMA for V channel */
|
|
|
|
if (size_v)
|
|
|
|
ret = pxa_init_dma_channel(pcdev, buf, dma, 2, CIBR2,
|
|
|
|
size_v, &sg, &next_ofs);
|
|
|
|
if (ret) {
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_err(dev, "DMA initialization for V failed\n");
|
2009-03-31 14:44:21 +08:00
|
|
|
goto fail_v;
|
2008-04-07 08:24:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
vb->state = VIDEOBUF_PREPARED;
|
|
|
|
}
|
|
|
|
|
|
|
|
buf->inwork = 0;
|
2009-03-31 14:44:21 +08:00
|
|
|
pxa_videobuf_set_actdma(pcdev, buf);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2008-04-22 21:36:32 +08:00
|
|
|
fail_v:
|
2009-08-25 22:43:33 +08:00
|
|
|
dma_free_coherent(dev, buf->dmas[1].sg_size,
|
2008-04-22 21:36:32 +08:00
|
|
|
buf->dmas[1].sg_cpu, buf->dmas[1].sg_dma);
|
|
|
|
fail_u:
|
2009-08-25 22:43:33 +08:00
|
|
|
dma_free_coherent(dev, buf->dmas[0].sg_size,
|
2008-04-22 21:36:32 +08:00
|
|
|
buf->dmas[0].sg_cpu, buf->dmas[0].sg_dma);
|
2008-04-07 08:24:56 +08:00
|
|
|
fail:
|
|
|
|
free_buffer(vq, buf);
|
|
|
|
out:
|
|
|
|
buf->inwork = 0;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
/**
|
|
|
|
* pxa_dma_start_channels - start DMA channel for active buffer
|
|
|
|
* @pcdev: pxa camera device
|
|
|
|
*
|
|
|
|
* Initialize DMA channels to the beginning of the active video buffer, and
|
|
|
|
* start these channels.
|
|
|
|
*/
|
|
|
|
static void pxa_dma_start_channels(struct pxa_camera_dev *pcdev)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct pxa_buffer *active;
|
|
|
|
|
|
|
|
active = pcdev->active;
|
|
|
|
|
|
|
|
for (i = 0; i < pcdev->channels; i++) {
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev,
|
|
|
|
"%s (channel=%d) ddadr=%08x\n", __func__,
|
2009-03-31 14:44:21 +08:00
|
|
|
i, active->dmas[i].sg_dma);
|
|
|
|
DDADR(pcdev->dma_chans[i]) = active->dmas[i].sg_dma;
|
|
|
|
DCSR(pcdev->dma_chans[i]) = DCSR_RUN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa_dma_stop_channels(struct pxa_camera_dev *pcdev)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < pcdev->channels; i++) {
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev,
|
|
|
|
"%s (channel=%d)\n", __func__, i);
|
2009-03-31 14:44:21 +08:00
|
|
|
DCSR(pcdev->dma_chans[i]) = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa_dma_add_tail_buf(struct pxa_camera_dev *pcdev,
|
|
|
|
struct pxa_buffer *buf)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct pxa_dma_desc *buf_last_desc;
|
|
|
|
|
|
|
|
for (i = 0; i < pcdev->channels; i++) {
|
|
|
|
buf_last_desc = buf->dmas[i].sg_cpu + buf->dmas[i].sglen;
|
|
|
|
buf_last_desc->ddadr = DDADR_STOP;
|
|
|
|
|
2009-03-31 14:44:22 +08:00
|
|
|
if (pcdev->sg_tail[i])
|
|
|
|
/* Link the new buffer to the old tail */
|
|
|
|
pcdev->sg_tail[i]->ddadr = buf->dmas[i].sg_dma;
|
2009-03-31 14:44:21 +08:00
|
|
|
|
2009-03-31 14:44:22 +08:00
|
|
|
/* Update the channel tail */
|
|
|
|
pcdev->sg_tail[i] = buf_last_desc;
|
|
|
|
}
|
2009-03-31 14:44:21 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pxa_camera_start_capture - start video capturing
|
|
|
|
* @pcdev: camera device
|
|
|
|
*
|
|
|
|
* Launch capturing. DMA channels should not be active yet. They should get
|
|
|
|
* activated at the end of frame interrupt, to capture only whole frames, and
|
|
|
|
* never begin the capture of a partial frame.
|
|
|
|
*/
|
|
|
|
static void pxa_camera_start_capture(struct pxa_camera_dev *pcdev)
|
|
|
|
{
|
|
|
|
unsigned long cicr0, cifr;
|
|
|
|
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev, "%s\n", __func__);
|
2009-03-31 14:44:21 +08:00
|
|
|
/* Reset the FIFOs */
|
|
|
|
cifr = __raw_readl(pcdev->base + CIFR) | CIFR_RESET_F;
|
|
|
|
__raw_writel(cifr, pcdev->base + CIFR);
|
|
|
|
/* Enable End-Of-Frame Interrupt */
|
|
|
|
cicr0 = __raw_readl(pcdev->base + CICR0) | CICR0_ENB;
|
|
|
|
cicr0 &= ~CICR0_EOFM;
|
|
|
|
__raw_writel(cicr0, pcdev->base + CICR0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa_camera_stop_capture(struct pxa_camera_dev *pcdev)
|
|
|
|
{
|
|
|
|
unsigned long cicr0;
|
|
|
|
|
|
|
|
pxa_dma_stop_channels(pcdev);
|
|
|
|
|
|
|
|
cicr0 = __raw_readl(pcdev->base + CICR0) & ~CICR0_ENB;
|
|
|
|
__raw_writel(cicr0, pcdev->base + CICR0);
|
|
|
|
|
2009-03-31 14:44:22 +08:00
|
|
|
pcdev->active = NULL;
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev, "%s\n", __func__);
|
2009-03-31 14:44:21 +08:00
|
|
|
}
|
|
|
|
|
2009-08-06 07:06:31 +08:00
|
|
|
/* Called under spinlock_irqsave(&pcdev->lock, ...) */
|
2008-04-15 13:57:48 +08:00
|
|
|
static void pxa_videobuf_queue(struct videobuf_queue *vq,
|
|
|
|
struct videobuf_buffer *vb)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
|
|
|
struct soc_camera_device *icd = vq->priv_data;
|
2008-12-18 22:51:55 +08:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
2008-04-07 08:24:56 +08:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
struct pxa_buffer *buf = container_of(vb, struct pxa_buffer, vb);
|
|
|
|
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(icd->dev.parent, "%s (vb=0x%p) 0x%08lx %d active=%p\n",
|
|
|
|
__func__, vb, vb->baddr, vb->bsize, pcdev->active);
|
2009-03-31 14:44:21 +08:00
|
|
|
|
2008-04-07 08:24:56 +08:00
|
|
|
list_add_tail(&vb->queue, &pcdev->capture);
|
|
|
|
|
|
|
|
vb->state = VIDEOBUF_ACTIVE;
|
2009-03-31 14:44:21 +08:00
|
|
|
pxa_dma_add_tail_buf(pcdev, buf);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
if (!pcdev->active)
|
|
|
|
pxa_camera_start_capture(pcdev);
|
2008-04-07 08:24:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa_videobuf_release(struct videobuf_queue *vq,
|
|
|
|
struct videobuf_buffer *vb)
|
|
|
|
{
|
|
|
|
struct pxa_buffer *buf = container_of(vb, struct pxa_buffer, vb);
|
|
|
|
#ifdef DEBUG
|
|
|
|
struct soc_camera_device *icd = vq->priv_data;
|
2009-08-25 22:47:00 +08:00
|
|
|
struct device *dev = icd->dev.parent;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
|
2008-04-07 08:24:56 +08:00
|
|
|
vb, vb->baddr, vb->bsize);
|
|
|
|
|
|
|
|
switch (vb->state) {
|
|
|
|
case VIDEOBUF_ACTIVE:
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(dev, "%s (active)\n", __func__);
|
2008-04-07 08:24:56 +08:00
|
|
|
break;
|
|
|
|
case VIDEOBUF_QUEUED:
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(dev, "%s (queued)\n", __func__);
|
2008-04-07 08:24:56 +08:00
|
|
|
break;
|
|
|
|
case VIDEOBUF_PREPARED:
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(dev, "%s (prepared)\n", __func__);
|
2008-04-07 08:24:56 +08:00
|
|
|
break;
|
|
|
|
default:
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(dev, "%s (unknown)\n", __func__);
|
2008-04-07 08:24:56 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
free_buffer(vq, buf);
|
|
|
|
}
|
|
|
|
|
2008-04-22 21:36:32 +08:00
|
|
|
static void pxa_camera_wakeup(struct pxa_camera_dev *pcdev,
|
|
|
|
struct videobuf_buffer *vb,
|
|
|
|
struct pxa_buffer *buf)
|
|
|
|
{
|
2009-03-31 14:44:21 +08:00
|
|
|
int i;
|
2008-12-18 22:15:50 +08:00
|
|
|
|
2008-04-22 21:36:32 +08:00
|
|
|
/* _init is used to debug races, see comment in pxa_camera_reqbufs() */
|
|
|
|
list_del_init(&vb->queue);
|
|
|
|
vb->state = VIDEOBUF_DONE;
|
|
|
|
do_gettimeofday(&vb->ts);
|
|
|
|
vb->field_count++;
|
|
|
|
wake_up(&vb->done);
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev, "%s dequeud buffer (vb=0x%p)\n",
|
|
|
|
__func__, vb);
|
2008-04-22 21:36:32 +08:00
|
|
|
|
|
|
|
if (list_empty(&pcdev->capture)) {
|
2009-03-31 14:44:21 +08:00
|
|
|
pxa_camera_stop_capture(pcdev);
|
|
|
|
for (i = 0; i < pcdev->channels; i++)
|
|
|
|
pcdev->sg_tail[i] = NULL;
|
2008-04-22 21:36:32 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
pcdev->active = list_entry(pcdev->capture.next,
|
|
|
|
struct pxa_buffer, vb.queue);
|
|
|
|
}
|
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
/**
|
|
|
|
* pxa_camera_check_link_miss - check missed DMA linking
|
|
|
|
* @pcdev: camera device
|
|
|
|
*
|
|
|
|
* The DMA chaining is done with DMA running. This means a tiny temporal window
|
|
|
|
* remains, where a buffer is queued on the chain, while the chain is already
|
|
|
|
* stopped. This means the tailed buffer would never be transfered by DMA.
|
|
|
|
* This function restarts the capture for this corner case, where :
|
|
|
|
* - DADR() == DADDR_STOP
|
|
|
|
* - a videobuffer is queued on the pcdev->capture list
|
|
|
|
*
|
|
|
|
* Please check the "DMA hot chaining timeslice issue" in
|
|
|
|
* Documentation/video4linux/pxa_camera.txt
|
|
|
|
*
|
|
|
|
* Context: should only be called within the dma irq handler
|
|
|
|
*/
|
|
|
|
static void pxa_camera_check_link_miss(struct pxa_camera_dev *pcdev)
|
|
|
|
{
|
|
|
|
int i, is_dma_stopped = 1;
|
|
|
|
|
|
|
|
for (i = 0; i < pcdev->channels; i++)
|
|
|
|
if (DDADR(pcdev->dma_chans[i]) != DDADR_STOP)
|
|
|
|
is_dma_stopped = 0;
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev,
|
|
|
|
"%s : top queued buffer=%p, dma_stopped=%d\n",
|
2009-03-31 14:44:21 +08:00
|
|
|
__func__, pcdev->active, is_dma_stopped);
|
|
|
|
if (pcdev->active && is_dma_stopped)
|
|
|
|
pxa_camera_start_capture(pcdev);
|
|
|
|
}
|
|
|
|
|
2008-04-22 21:36:32 +08:00
|
|
|
static void pxa_camera_dma_irq(int channel, struct pxa_camera_dev *pcdev,
|
|
|
|
enum pxa_camera_active_dma act_dma)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
2009-08-25 22:43:33 +08:00
|
|
|
struct device *dev = pcdev->soc_host.v4l2_dev.dev;
|
2008-04-07 08:24:56 +08:00
|
|
|
struct pxa_buffer *buf;
|
|
|
|
unsigned long flags;
|
2008-04-22 21:37:49 +08:00
|
|
|
u32 status, camera_status, overrun;
|
2008-04-07 08:24:56 +08:00
|
|
|
struct videobuf_buffer *vb;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&pcdev->lock, flags);
|
|
|
|
|
2008-04-22 21:36:32 +08:00
|
|
|
status = DCSR(channel);
|
2009-03-31 14:44:21 +08:00
|
|
|
DCSR(channel) = status;
|
|
|
|
|
|
|
|
camera_status = __raw_readl(pcdev->base + CISR);
|
|
|
|
overrun = CISR_IFO_0;
|
|
|
|
if (pcdev->channels == 3)
|
|
|
|
overrun |= CISR_IFO_1 | CISR_IFO_2;
|
2008-04-15 13:57:48 +08:00
|
|
|
|
2008-04-07 08:24:56 +08:00
|
|
|
if (status & DCSR_BUSERR) {
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_err(dev, "DMA Bus Error IRQ!\n");
|
2008-04-07 08:24:56 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
if (!(status & (DCSR_ENDINTR | DCSR_STARTINTR))) {
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_err(dev, "Unknown DMA IRQ source, status: 0x%08x\n",
|
|
|
|
status);
|
2008-04-07 08:24:56 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-03-31 14:44:22 +08:00
|
|
|
/*
|
|
|
|
* pcdev->active should not be NULL in DMA irq handler.
|
|
|
|
*
|
|
|
|
* But there is one corner case : if capture was stopped due to an
|
|
|
|
* overrun of channel 1, and at that same channel 2 was completed.
|
|
|
|
*
|
|
|
|
* When handling the overrun in DMA irq for channel 1, we'll stop the
|
|
|
|
* capture and restart it (and thus set pcdev->active to NULL). But the
|
|
|
|
* DMA irq handler will already be pending for channel 2. So on entering
|
|
|
|
* the DMA irq handler for channel 2 there will be no active buffer, yet
|
|
|
|
* that is normal.
|
|
|
|
*/
|
|
|
|
if (!pcdev->active)
|
2008-04-07 08:24:56 +08:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
vb = &pcdev->active->vb;
|
|
|
|
buf = container_of(vb, struct pxa_buffer, vb);
|
|
|
|
WARN_ON(buf->inwork || list_empty(&vb->queue));
|
|
|
|
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_dbg(dev, "%s channel=%d %s%s(vb=0x%p) dma.desc=%x\n",
|
2009-03-31 14:44:21 +08:00
|
|
|
__func__, channel, status & DCSR_STARTINTR ? "SOF " : "",
|
|
|
|
status & DCSR_ENDINTR ? "EOF " : "", vb, DDADR(channel));
|
|
|
|
|
|
|
|
if (status & DCSR_ENDINTR) {
|
2009-03-31 14:44:22 +08:00
|
|
|
/*
|
|
|
|
* It's normal if the last frame creates an overrun, as there
|
|
|
|
* are no more DMA descriptors to fetch from QCI fifos
|
|
|
|
*/
|
|
|
|
if (camera_status & overrun &&
|
|
|
|
!list_is_last(pcdev->capture.next, &pcdev->capture)) {
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_dbg(dev, "FIFO overrun! CISR: %x\n",
|
2009-03-31 14:44:21 +08:00
|
|
|
camera_status);
|
|
|
|
pxa_camera_stop_capture(pcdev);
|
|
|
|
pxa_camera_start_capture(pcdev);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
buf->active_dma &= ~act_dma;
|
|
|
|
if (!buf->active_dma) {
|
|
|
|
pxa_camera_wakeup(pcdev, vb, buf);
|
|
|
|
pxa_camera_check_link_miss(pcdev);
|
|
|
|
}
|
|
|
|
}
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&pcdev->lock, flags);
|
|
|
|
}
|
|
|
|
|
2008-04-22 21:36:32 +08:00
|
|
|
static void pxa_camera_dma_irq_y(int channel, void *data)
|
|
|
|
{
|
|
|
|
struct pxa_camera_dev *pcdev = data;
|
|
|
|
pxa_camera_dma_irq(channel, pcdev, DMA_Y);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa_camera_dma_irq_u(int channel, void *data)
|
|
|
|
{
|
|
|
|
struct pxa_camera_dev *pcdev = data;
|
|
|
|
pxa_camera_dma_irq(channel, pcdev, DMA_U);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pxa_camera_dma_irq_v(int channel, void *data)
|
|
|
|
{
|
|
|
|
struct pxa_camera_dev *pcdev = data;
|
|
|
|
pxa_camera_dma_irq(channel, pcdev, DMA_V);
|
|
|
|
}
|
|
|
|
|
2008-04-15 13:57:48 +08:00
|
|
|
static struct videobuf_queue_ops pxa_videobuf_ops = {
|
2008-04-07 08:24:56 +08:00
|
|
|
.buf_setup = pxa_videobuf_setup,
|
|
|
|
.buf_prepare = pxa_videobuf_prepare,
|
|
|
|
.buf_queue = pxa_videobuf_queue,
|
|
|
|
.buf_release = pxa_videobuf_release,
|
|
|
|
};
|
|
|
|
|
2008-07-12 07:59:34 +08:00
|
|
|
static void pxa_camera_init_videobuf(struct videobuf_queue *q,
|
2008-07-12 07:50:31 +08:00
|
|
|
struct soc_camera_device *icd)
|
|
|
|
{
|
2008-07-12 07:59:34 +08:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
|
2008-07-12 07:50:31 +08:00
|
|
|
/* We must pass NULL as dev pointer, then all pci_* dma operations
|
|
|
|
* transform to normal dma_* ones. */
|
2008-07-12 07:59:34 +08:00
|
|
|
videobuf_queue_sg_init(q, &pxa_videobuf_ops, NULL, &pcdev->lock,
|
2008-07-12 07:50:31 +08:00
|
|
|
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
|
|
|
|
sizeof(struct pxa_buffer), icd);
|
|
|
|
}
|
|
|
|
|
2009-08-25 22:28:22 +08:00
|
|
|
static u32 mclk_get_divisor(struct platform_device *pdev,
|
|
|
|
struct pxa_camera_dev *pcdev)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
2008-12-18 22:38:03 +08:00
|
|
|
unsigned long mclk = pcdev->mclk;
|
2009-08-25 22:50:46 +08:00
|
|
|
struct device *dev = &pdev->dev;
|
2008-12-18 22:38:03 +08:00
|
|
|
u32 div;
|
2008-04-07 08:24:56 +08:00
|
|
|
unsigned long lcdclk;
|
|
|
|
|
2008-12-18 22:38:03 +08:00
|
|
|
lcdclk = clk_get_rate(pcdev->clk);
|
|
|
|
pcdev->ciclk = lcdclk;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2008-12-18 22:38:03 +08:00
|
|
|
/* mclk <= ciclk / 4 (27.4.2) */
|
|
|
|
if (mclk > lcdclk / 4) {
|
|
|
|
mclk = lcdclk / 4;
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_warn(dev, "Limiting master clock to %lu\n", mclk);
|
2008-12-18 22:38:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* We verify mclk != 0, so if anyone breaks it, here comes their Oops */
|
|
|
|
div = (lcdclk + 2 * mclk - 1) / (2 * mclk) - 1;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2008-12-18 22:38:03 +08:00
|
|
|
/* If we're not supplying MCLK, leave it at 0 */
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_MCLK_EN)
|
|
|
|
pcdev->mclk = lcdclk / (2 * (div + 1));
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_dbg(dev, "LCD clock %luHz, target freq %luHz, divisor %u\n",
|
2009-08-25 22:28:22 +08:00
|
|
|
lcdclk, mclk, div);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
return div;
|
|
|
|
}
|
|
|
|
|
2008-12-18 22:38:03 +08:00
|
|
|
static void recalculate_fifo_timeout(struct pxa_camera_dev *pcdev,
|
|
|
|
unsigned long pclk)
|
|
|
|
{
|
|
|
|
/* We want a timeout > 1 pixel time, not ">=" */
|
|
|
|
u32 ciclk_per_pixel = pcdev->ciclk / pclk + 1;
|
|
|
|
|
|
|
|
__raw_writel(ciclk_per_pixel, pcdev->base + CITOR);
|
|
|
|
}
|
|
|
|
|
2008-04-15 13:57:48 +08:00
|
|
|
static void pxa_camera_activate(struct pxa_camera_dev *pcdev)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
|
|
|
struct pxacamera_platform_data *pdata = pcdev->pdata;
|
2009-08-25 22:43:33 +08:00
|
|
|
struct device *dev = pcdev->soc_host.v4l2_dev.dev;
|
2008-04-07 08:24:56 +08:00
|
|
|
u32 cicr4 = 0;
|
|
|
|
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_dbg(dev, "Registered platform device at %p data %p\n",
|
2008-04-07 08:24:56 +08:00
|
|
|
pcdev, pdata);
|
|
|
|
|
|
|
|
if (pdata && pdata->init) {
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_dbg(dev, "%s: Init gpios\n", __func__);
|
|
|
|
pdata->init(dev);
|
2008-04-07 08:24:56 +08:00
|
|
|
}
|
|
|
|
|
2008-12-18 22:15:50 +08:00
|
|
|
/* disable all interrupts */
|
|
|
|
__raw_writel(0x3ff, pcdev->base + CICR0);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_PCLK_EN)
|
|
|
|
cicr4 |= CICR4_PCLK_EN;
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_MCLK_EN)
|
|
|
|
cicr4 |= CICR4_MCLK_EN;
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_PCP)
|
|
|
|
cicr4 |= CICR4_PCP;
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_HSP)
|
|
|
|
cicr4 |= CICR4_HSP;
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_VSP)
|
|
|
|
cicr4 |= CICR4_VSP;
|
|
|
|
|
2008-12-18 22:38:03 +08:00
|
|
|
__raw_writel(pcdev->mclk_divisor | cicr4, pcdev->base + CICR4);
|
|
|
|
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_MCLK_EN)
|
|
|
|
/* Initialise the timeout under the assumption pclk = mclk */
|
|
|
|
recalculate_fifo_timeout(pcdev, pcdev->mclk);
|
|
|
|
else
|
|
|
|
/* "Safe default" - 13MHz */
|
|
|
|
recalculate_fifo_timeout(pcdev, 13000000);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
clk_enable(pcdev->clk);
|
|
|
|
}
|
|
|
|
|
2008-04-15 13:57:48 +08:00
|
|
|
static void pxa_camera_deactivate(struct pxa_camera_dev *pcdev)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
|
|
|
clk_disable(pcdev->clk);
|
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t pxa_camera_irq(int irq, void *data)
|
|
|
|
{
|
|
|
|
struct pxa_camera_dev *pcdev = data;
|
2008-12-18 22:15:50 +08:00
|
|
|
unsigned long status, cicr0;
|
2009-03-31 14:44:21 +08:00
|
|
|
struct pxa_buffer *buf;
|
|
|
|
struct videobuf_buffer *vb;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2008-12-18 22:15:50 +08:00
|
|
|
status = __raw_readl(pcdev->base + CISR);
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev,
|
|
|
|
"Camera interrupt status 0x%lx\n", status);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2008-04-22 21:37:49 +08:00
|
|
|
if (!status)
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
2008-12-18 22:15:50 +08:00
|
|
|
__raw_writel(status, pcdev->base + CISR);
|
2008-04-22 21:37:49 +08:00
|
|
|
|
|
|
|
if (status & CISR_EOF) {
|
2009-03-31 14:44:21 +08:00
|
|
|
pcdev->active = list_first_entry(&pcdev->capture,
|
|
|
|
struct pxa_buffer, vb.queue);
|
|
|
|
vb = &pcdev->active->vb;
|
|
|
|
buf = container_of(vb, struct pxa_buffer, vb);
|
|
|
|
pxa_videobuf_set_actdma(pcdev, buf);
|
|
|
|
|
|
|
|
pxa_dma_start_channels(pcdev);
|
|
|
|
|
2008-12-18 22:15:50 +08:00
|
|
|
cicr0 = __raw_readl(pcdev->base + CICR0) | CICR0_EOFM;
|
|
|
|
__raw_writel(cicr0, pcdev->base + CICR0);
|
2008-04-22 21:37:49 +08:00
|
|
|
}
|
|
|
|
|
2008-04-07 08:24:56 +08:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2008-12-18 23:28:54 +08:00
|
|
|
/*
|
|
|
|
* The following two functions absolutely depend on the fact, that
|
|
|
|
* there can be only one camera on PXA quick capture interface
|
|
|
|
* Called with .video_lock held
|
|
|
|
*/
|
2008-04-15 13:57:48 +08:00
|
|
|
static int pxa_camera_add_device(struct soc_camera_device *icd)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
|
2009-08-25 22:43:33 +08:00
|
|
|
if (pcdev->icd)
|
|
|
|
return -EBUSY;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2008-04-15 13:57:48 +08:00
|
|
|
pxa_camera_activate(pcdev);
|
2009-08-25 22:28:22 +08:00
|
|
|
|
|
|
|
pcdev->icd = icd;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_info(icd->dev.parent, "PXA Camera driver attached to camera %d\n",
|
2009-08-25 22:28:22 +08:00
|
|
|
icd->devnum);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2009-08-25 22:28:22 +08:00
|
|
|
return 0;
|
2008-04-07 08:24:56 +08:00
|
|
|
}
|
|
|
|
|
2008-12-18 23:28:54 +08:00
|
|
|
/* Called with .video_lock held */
|
2008-04-15 13:57:48 +08:00
|
|
|
static void pxa_camera_remove_device(struct soc_camera_device *icd)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
|
|
|
|
BUG_ON(icd != pcdev->icd);
|
|
|
|
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_info(icd->dev.parent, "PXA Camera driver detached from camera %d\n",
|
2008-04-07 08:24:56 +08:00
|
|
|
icd->devnum);
|
|
|
|
|
|
|
|
/* disable capture, disable interrupts */
|
2008-12-18 22:15:50 +08:00
|
|
|
__raw_writel(0x3ff, pcdev->base + CICR0);
|
2008-04-22 21:36:32 +08:00
|
|
|
|
2008-04-07 08:24:56 +08:00
|
|
|
/* Stop DMA engine */
|
2008-04-22 21:36:32 +08:00
|
|
|
DCSR(pcdev->dma_chans[0]) = 0;
|
|
|
|
DCSR(pcdev->dma_chans[1]) = 0;
|
|
|
|
DCSR(pcdev->dma_chans[2]) = 0;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2008-04-15 13:57:48 +08:00
|
|
|
pxa_camera_deactivate(pcdev);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
pcdev->icd = NULL;
|
|
|
|
}
|
|
|
|
|
2008-03-08 08:57:18 +08:00
|
|
|
static int test_platform_param(struct pxa_camera_dev *pcdev,
|
|
|
|
unsigned char buswidth, unsigned long *flags)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
2008-03-08 08:57:18 +08:00
|
|
|
/*
|
|
|
|
* Platform specified synchronization and pixel clock polarities are
|
|
|
|
* only a recommendation and are only used during probing. The PXA270
|
|
|
|
* quick capture interface supports both.
|
|
|
|
*/
|
|
|
|
*flags = (pcdev->platform_flags & PXA_CAMERA_MASTER ?
|
|
|
|
SOCAM_MASTER : SOCAM_SLAVE) |
|
|
|
|
SOCAM_HSYNC_ACTIVE_HIGH |
|
|
|
|
SOCAM_HSYNC_ACTIVE_LOW |
|
|
|
|
SOCAM_VSYNC_ACTIVE_HIGH |
|
|
|
|
SOCAM_VSYNC_ACTIVE_LOW |
|
2009-02-23 23:12:58 +08:00
|
|
|
SOCAM_DATA_ACTIVE_HIGH |
|
2008-03-08 08:57:18 +08:00
|
|
|
SOCAM_PCLK_SAMPLE_RISING |
|
|
|
|
SOCAM_PCLK_SAMPLE_FALLING;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
/* If requested data width is supported by the platform, use it */
|
2008-03-08 08:57:18 +08:00
|
|
|
switch (buswidth) {
|
2008-04-07 08:24:56 +08:00
|
|
|
case 10:
|
2008-03-08 08:57:18 +08:00
|
|
|
if (!(pcdev->platform_flags & PXA_CAMERA_DATAWIDTH_10))
|
|
|
|
return -EINVAL;
|
|
|
|
*flags |= SOCAM_DATAWIDTH_10;
|
2008-04-07 08:24:56 +08:00
|
|
|
break;
|
|
|
|
case 9:
|
2008-03-08 08:57:18 +08:00
|
|
|
if (!(pcdev->platform_flags & PXA_CAMERA_DATAWIDTH_9))
|
|
|
|
return -EINVAL;
|
|
|
|
*flags |= SOCAM_DATAWIDTH_9;
|
2008-04-07 08:24:56 +08:00
|
|
|
break;
|
|
|
|
case 8:
|
2008-03-08 08:57:18 +08:00
|
|
|
if (!(pcdev->platform_flags & PXA_CAMERA_DATAWIDTH_8))
|
|
|
|
return -EINVAL;
|
|
|
|
*flags |= SOCAM_DATAWIDTH_8;
|
2008-12-01 20:45:35 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
2008-04-07 08:24:56 +08:00
|
|
|
}
|
2008-03-08 08:57:18 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-25 22:50:46 +08:00
|
|
|
static void pxa_camera_setup_cicr(struct soc_camera_device *icd,
|
|
|
|
unsigned long flags, __u32 pixfmt)
|
2008-03-08 08:57:18 +08:00
|
|
|
{
|
2008-12-18 22:51:55 +08:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
2008-03-08 08:57:18 +08:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
2009-08-25 22:50:46 +08:00
|
|
|
unsigned long dw, bpp;
|
2008-12-18 22:15:50 +08:00
|
|
|
u32 cicr0, cicr1, cicr2, cicr3, cicr4 = 0;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
/* Datawidth is now guaranteed to be equal to one of the three values.
|
|
|
|
* We fix bit-per-pixel equal to data-width... */
|
2009-08-25 22:50:46 +08:00
|
|
|
switch (flags & SOCAM_DATAWIDTH_MASK) {
|
2008-03-08 08:57:18 +08:00
|
|
|
case SOCAM_DATAWIDTH_10:
|
2008-04-07 08:24:56 +08:00
|
|
|
dw = 4;
|
|
|
|
bpp = 0x40;
|
|
|
|
break;
|
2008-03-08 08:57:18 +08:00
|
|
|
case SOCAM_DATAWIDTH_9:
|
2008-04-07 08:24:56 +08:00
|
|
|
dw = 3;
|
|
|
|
bpp = 0x20;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Actually it can only be 8 now,
|
|
|
|
* default is just to silence compiler warnings */
|
2008-03-08 08:57:18 +08:00
|
|
|
case SOCAM_DATAWIDTH_8:
|
2008-04-07 08:24:56 +08:00
|
|
|
dw = 2;
|
|
|
|
bpp = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_PCLK_EN)
|
|
|
|
cicr4 |= CICR4_PCLK_EN;
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_MCLK_EN)
|
|
|
|
cicr4 |= CICR4_MCLK_EN;
|
2009-08-25 22:50:46 +08:00
|
|
|
if (flags & SOCAM_PCLK_SAMPLE_FALLING)
|
2008-04-07 08:24:56 +08:00
|
|
|
cicr4 |= CICR4_PCP;
|
2009-08-25 22:50:46 +08:00
|
|
|
if (flags & SOCAM_HSYNC_ACTIVE_LOW)
|
2008-04-07 08:24:56 +08:00
|
|
|
cicr4 |= CICR4_HSP;
|
2009-08-25 22:50:46 +08:00
|
|
|
if (flags & SOCAM_VSYNC_ACTIVE_LOW)
|
2008-04-07 08:24:56 +08:00
|
|
|
cicr4 |= CICR4_VSP;
|
|
|
|
|
2008-12-18 22:15:50 +08:00
|
|
|
cicr0 = __raw_readl(pcdev->base + CICR0);
|
2008-04-07 08:24:56 +08:00
|
|
|
if (cicr0 & CICR0_ENB)
|
2008-12-18 22:15:50 +08:00
|
|
|
__raw_writel(cicr0 & ~CICR0_ENB, pcdev->base + CICR0);
|
2008-04-22 21:36:32 +08:00
|
|
|
|
2009-08-25 22:50:46 +08:00
|
|
|
cicr1 = CICR1_PPL_VAL(icd->user_width - 1) | bpp | dw;
|
2008-04-22 21:36:32 +08:00
|
|
|
|
|
|
|
switch (pixfmt) {
|
|
|
|
case V4L2_PIX_FMT_YUV422P:
|
2008-04-22 21:37:49 +08:00
|
|
|
pcdev->channels = 3;
|
2008-04-22 21:36:32 +08:00
|
|
|
cicr1 |= CICR1_YCBCR_F;
|
2008-12-01 20:45:35 +08:00
|
|
|
/*
|
|
|
|
* Normally, pxa bus wants as input UYVY format. We allow all
|
|
|
|
* reorderings of the YUV422 format, as no processing is done,
|
|
|
|
* and the YUV stream is just passed through without any
|
|
|
|
* transformation. Note that UYVY is the only format that
|
|
|
|
* should be used if pxa framebuffer Overlay2 is used.
|
|
|
|
*/
|
|
|
|
case V4L2_PIX_FMT_UYVY:
|
|
|
|
case V4L2_PIX_FMT_VYUY:
|
2008-04-22 21:36:32 +08:00
|
|
|
case V4L2_PIX_FMT_YUYV:
|
2008-12-01 20:45:35 +08:00
|
|
|
case V4L2_PIX_FMT_YVYU:
|
2008-04-22 21:36:32 +08:00
|
|
|
cicr1 |= CICR1_COLOR_SP_VAL(2);
|
|
|
|
break;
|
|
|
|
case V4L2_PIX_FMT_RGB555:
|
|
|
|
cicr1 |= CICR1_RGB_BPP_VAL(1) | CICR1_RGBT_CONV_VAL(2) |
|
|
|
|
CICR1_TBIT | CICR1_COLOR_SP_VAL(1);
|
|
|
|
break;
|
|
|
|
case V4L2_PIX_FMT_RGB565:
|
|
|
|
cicr1 |= CICR1_COLOR_SP_VAL(1) | CICR1_RGB_BPP_VAL(2);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-12-18 22:15:50 +08:00
|
|
|
cicr2 = 0;
|
2009-08-25 22:50:46 +08:00
|
|
|
cicr3 = CICR3_LPF_VAL(icd->user_height - 1) |
|
2008-04-07 08:24:56 +08:00
|
|
|
CICR3_BFW_VAL(min((unsigned short)255, icd->y_skip_top));
|
2008-12-18 22:38:03 +08:00
|
|
|
cicr4 |= pcdev->mclk_divisor;
|
2008-12-18 22:15:50 +08:00
|
|
|
|
|
|
|
__raw_writel(cicr1, pcdev->base + CICR1);
|
|
|
|
__raw_writel(cicr2, pcdev->base + CICR2);
|
|
|
|
__raw_writel(cicr3, pcdev->base + CICR3);
|
|
|
|
__raw_writel(cicr4, pcdev->base + CICR4);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
/* CIF interrupts are not used, only DMA */
|
2008-12-18 22:15:50 +08:00
|
|
|
cicr0 = (cicr0 & CICR0_ENB) | (pcdev->platform_flags & PXA_CAMERA_MASTER ?
|
|
|
|
CICR0_SIM_MP : (CICR0_SL_CAP_EN | CICR0_SIM_SP));
|
|
|
|
cicr0 |= CICR0_DMAEN | CICR0_IRQ_MASK;
|
|
|
|
__raw_writel(cicr0, pcdev->base + CICR0);
|
2009-08-25 22:50:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int pxa_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
|
|
|
|
{
|
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
unsigned long bus_flags, camera_flags, common_flags;
|
|
|
|
int ret = test_platform_param(pcdev, icd->buswidth, &bus_flags);
|
|
|
|
struct pxa_cam *cam = icd->host_priv;
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
camera_flags = icd->ops->query_bus_param(icd);
|
|
|
|
|
|
|
|
common_flags = soc_camera_bus_param_compatible(camera_flags, bus_flags);
|
|
|
|
if (!common_flags)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
pcdev->channels = 1;
|
|
|
|
|
|
|
|
/* Make choises, based on platform preferences */
|
|
|
|
if ((common_flags & SOCAM_HSYNC_ACTIVE_HIGH) &&
|
|
|
|
(common_flags & SOCAM_HSYNC_ACTIVE_LOW)) {
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_HSP)
|
|
|
|
common_flags &= ~SOCAM_HSYNC_ACTIVE_HIGH;
|
|
|
|
else
|
|
|
|
common_flags &= ~SOCAM_HSYNC_ACTIVE_LOW;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((common_flags & SOCAM_VSYNC_ACTIVE_HIGH) &&
|
|
|
|
(common_flags & SOCAM_VSYNC_ACTIVE_LOW)) {
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_VSP)
|
|
|
|
common_flags &= ~SOCAM_VSYNC_ACTIVE_HIGH;
|
|
|
|
else
|
|
|
|
common_flags &= ~SOCAM_VSYNC_ACTIVE_LOW;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((common_flags & SOCAM_PCLK_SAMPLE_RISING) &&
|
|
|
|
(common_flags & SOCAM_PCLK_SAMPLE_FALLING)) {
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_PCP)
|
|
|
|
common_flags &= ~SOCAM_PCLK_SAMPLE_RISING;
|
|
|
|
else
|
|
|
|
common_flags &= ~SOCAM_PCLK_SAMPLE_FALLING;
|
|
|
|
}
|
|
|
|
|
|
|
|
cam->flags = common_flags;
|
|
|
|
|
|
|
|
ret = icd->ops->set_bus_param(icd, common_flags);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
pxa_camera_setup_cicr(icd, common_flags, pixfmt);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-01 20:45:35 +08:00
|
|
|
static int pxa_camera_try_bus_param(struct soc_camera_device *icd,
|
|
|
|
unsigned char buswidth)
|
2008-03-08 08:57:18 +08:00
|
|
|
{
|
2008-12-18 22:38:03 +08:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
2008-03-08 08:57:18 +08:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
unsigned long bus_flags, camera_flags;
|
2008-12-01 20:45:35 +08:00
|
|
|
int ret = test_platform_param(pcdev, buswidth, &bus_flags);
|
2008-03-08 08:57:18 +08:00
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
camera_flags = icd->ops->query_bus_param(icd);
|
|
|
|
|
|
|
|
return soc_camera_bus_param_compatible(camera_flags, bus_flags) ? 0 : -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-12-01 20:45:35 +08:00
|
|
|
static const struct soc_camera_data_format pxa_camera_formats[] = {
|
|
|
|
{
|
|
|
|
.name = "Planar YUV422 16 bit",
|
|
|
|
.depth = 16,
|
|
|
|
.fourcc = V4L2_PIX_FMT_YUV422P,
|
|
|
|
.colorspace = V4L2_COLORSPACE_JPEG,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static bool buswidth_supported(struct soc_camera_device *icd, int depth)
|
2008-03-08 08:57:18 +08:00
|
|
|
{
|
2008-12-01 20:45:35 +08:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
|
|
|
|
switch (depth) {
|
|
|
|
case 8:
|
|
|
|
return !!(pcdev->platform_flags & PXA_CAMERA_DATAWIDTH_8);
|
|
|
|
case 9:
|
|
|
|
return !!(pcdev->platform_flags & PXA_CAMERA_DATAWIDTH_9);
|
|
|
|
case 10:
|
|
|
|
return !!(pcdev->platform_flags & PXA_CAMERA_DATAWIDTH_10);
|
|
|
|
}
|
|
|
|
return false;
|
2008-03-08 08:57:18 +08:00
|
|
|
}
|
|
|
|
|
2008-12-01 20:45:35 +08:00
|
|
|
static int required_buswidth(const struct soc_camera_data_format *fmt)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
2008-12-01 20:45:35 +08:00
|
|
|
switch (fmt->fourcc) {
|
|
|
|
case V4L2_PIX_FMT_UYVY:
|
|
|
|
case V4L2_PIX_FMT_VYUY:
|
|
|
|
case V4L2_PIX_FMT_YUYV:
|
|
|
|
case V4L2_PIX_FMT_YVYU:
|
|
|
|
case V4L2_PIX_FMT_RGB565:
|
|
|
|
case V4L2_PIX_FMT_RGB555:
|
|
|
|
return 8;
|
|
|
|
default:
|
|
|
|
return fmt->depth;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pxa_camera_get_formats(struct soc_camera_device *icd, int idx,
|
|
|
|
struct soc_camera_format_xlate *xlate)
|
|
|
|
{
|
2009-08-25 22:47:00 +08:00
|
|
|
struct device *dev = icd->dev.parent;
|
2008-12-01 20:45:35 +08:00
|
|
|
int formats = 0, buswidth, ret;
|
2009-08-25 22:50:46 +08:00
|
|
|
struct pxa_cam *cam;
|
2008-12-01 20:45:35 +08:00
|
|
|
|
|
|
|
buswidth = required_buswidth(icd->formats + idx);
|
|
|
|
|
|
|
|
if (!buswidth_supported(icd, buswidth))
|
|
|
|
return 0;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
2008-12-01 20:45:35 +08:00
|
|
|
ret = pxa_camera_try_bus_param(icd, buswidth);
|
|
|
|
if (ret < 0)
|
|
|
|
return 0;
|
|
|
|
|
2009-08-25 22:50:46 +08:00
|
|
|
if (!icd->host_priv) {
|
|
|
|
cam = kzalloc(sizeof(*cam), GFP_KERNEL);
|
|
|
|
if (!cam)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
icd->host_priv = cam;
|
|
|
|
} else {
|
|
|
|
cam = icd->host_priv;
|
|
|
|
}
|
|
|
|
|
2008-12-01 20:45:35 +08:00
|
|
|
switch (icd->formats[idx].fourcc) {
|
|
|
|
case V4L2_PIX_FMT_UYVY:
|
|
|
|
formats++;
|
|
|
|
if (xlate) {
|
|
|
|
xlate->host_fmt = &pxa_camera_formats[0];
|
|
|
|
xlate->cam_fmt = icd->formats + idx;
|
|
|
|
xlate->buswidth = buswidth;
|
|
|
|
xlate++;
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(dev, "Providing format %s using %s\n",
|
2008-12-01 20:45:35 +08:00
|
|
|
pxa_camera_formats[0].name,
|
|
|
|
icd->formats[idx].name);
|
|
|
|
}
|
|
|
|
case V4L2_PIX_FMT_VYUY:
|
|
|
|
case V4L2_PIX_FMT_YUYV:
|
|
|
|
case V4L2_PIX_FMT_YVYU:
|
|
|
|
case V4L2_PIX_FMT_RGB565:
|
|
|
|
case V4L2_PIX_FMT_RGB555:
|
|
|
|
formats++;
|
|
|
|
if (xlate) {
|
|
|
|
xlate->host_fmt = icd->formats + idx;
|
|
|
|
xlate->cam_fmt = icd->formats + idx;
|
|
|
|
xlate->buswidth = buswidth;
|
|
|
|
xlate++;
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(dev, "Providing format %s packed\n",
|
2008-12-01 20:45:35 +08:00
|
|
|
icd->formats[idx].name);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Generic pass-through */
|
|
|
|
formats++;
|
|
|
|
if (xlate) {
|
|
|
|
xlate->host_fmt = icd->formats + idx;
|
|
|
|
xlate->cam_fmt = icd->formats + idx;
|
|
|
|
xlate->buswidth = icd->formats[idx].depth;
|
|
|
|
xlate++;
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_dbg(dev,
|
2008-12-01 20:45:35 +08:00
|
|
|
"Providing format %s in pass-through mode\n",
|
|
|
|
icd->formats[idx].name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return formats;
|
|
|
|
}
|
|
|
|
|
2009-08-25 22:50:46 +08:00
|
|
|
static void pxa_camera_put_formats(struct soc_camera_device *icd)
|
|
|
|
{
|
|
|
|
kfree(icd->host_priv);
|
|
|
|
icd->host_priv = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pxa_camera_check_frame(struct v4l2_pix_format *pix)
|
|
|
|
{
|
|
|
|
/* limit to pxa hardware capabilities */
|
|
|
|
return pix->height < 32 || pix->height > 2048 || pix->width < 48 ||
|
|
|
|
pix->width > 2048 || (pix->width & 0x01);
|
|
|
|
}
|
|
|
|
|
2009-03-13 17:08:20 +08:00
|
|
|
static int pxa_camera_set_crop(struct soc_camera_device *icd,
|
2009-08-25 22:46:54 +08:00
|
|
|
struct v4l2_crop *a)
|
2009-03-13 17:08:20 +08:00
|
|
|
{
|
2009-08-25 22:46:54 +08:00
|
|
|
struct v4l2_rect *rect = &a->c;
|
2009-03-13 17:08:20 +08:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
2009-08-25 22:47:00 +08:00
|
|
|
struct device *dev = icd->dev.parent;
|
2009-08-25 22:46:59 +08:00
|
|
|
struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
|
2009-03-13 17:08:20 +08:00
|
|
|
struct soc_camera_sense sense = {
|
|
|
|
.master_clock = pcdev->mclk,
|
|
|
|
.pixel_clock_max = pcdev->ciclk / 4,
|
|
|
|
};
|
2009-08-25 22:50:46 +08:00
|
|
|
struct v4l2_format f;
|
|
|
|
struct v4l2_pix_format *pix = &f.fmt.pix, pix_tmp;
|
|
|
|
struct pxa_cam *cam = icd->host_priv;
|
2009-03-13 17:08:20 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* If PCLK is used to latch data from the sensor, check sense */
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_PCLK_EN)
|
|
|
|
icd->sense = &sense;
|
|
|
|
|
2009-08-25 22:46:54 +08:00
|
|
|
ret = v4l2_subdev_call(sd, video, s_crop, a);
|
2009-03-13 17:08:20 +08:00
|
|
|
|
|
|
|
icd->sense = NULL;
|
|
|
|
|
|
|
|
if (ret < 0) {
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_warn(dev, "Failed to crop to %ux%u@%u:%u\n",
|
2009-03-13 17:08:20 +08:00
|
|
|
rect->width, rect->height, rect->left, rect->top);
|
2009-08-25 22:50:46 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
f.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
|
|
|
|
|
|
|
ret = v4l2_subdev_call(sd, video, g_fmt, &f);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
pix_tmp = *pix;
|
|
|
|
if (pxa_camera_check_frame(pix)) {
|
|
|
|
/*
|
|
|
|
* Camera cropping produced a frame beyond our capabilities.
|
|
|
|
* FIXME: just extract a subframe, that we can process.
|
|
|
|
*/
|
|
|
|
v4l_bound_align_image(&pix->width, 48, 2048, 1,
|
|
|
|
&pix->height, 32, 2048, 0,
|
|
|
|
icd->current_fmt->fourcc == V4L2_PIX_FMT_YUV422P ?
|
|
|
|
4 : 0);
|
|
|
|
ret = v4l2_subdev_call(sd, video, s_fmt, &f);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (pxa_camera_check_frame(pix)) {
|
|
|
|
dev_warn(icd->dev.parent,
|
|
|
|
"Inconsistent state. Use S_FMT to repair\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sense.flags & SOCAM_SENSE_PCLK_CHANGED) {
|
2009-03-13 17:08:20 +08:00
|
|
|
if (sense.pixel_clock > sense.pixel_clock_max) {
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_err(dev,
|
2009-03-13 17:08:20 +08:00
|
|
|
"pixel clock %lu set by the camera too high!",
|
|
|
|
sense.pixel_clock);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
recalculate_fifo_timeout(pcdev, sense.pixel_clock);
|
|
|
|
}
|
|
|
|
|
2009-08-25 22:50:46 +08:00
|
|
|
icd->user_width = pix->width;
|
|
|
|
icd->user_height = pix->height;
|
|
|
|
|
|
|
|
pxa_camera_setup_cicr(icd, cam->flags, icd->current_fmt->fourcc);
|
|
|
|
|
2009-03-13 17:08:20 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-12-01 20:45:21 +08:00
|
|
|
static int pxa_camera_set_fmt(struct soc_camera_device *icd,
|
2009-03-13 17:08:20 +08:00
|
|
|
struct v4l2_format *f)
|
2008-03-08 08:57:18 +08:00
|
|
|
{
|
2008-12-01 20:45:35 +08:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
2008-12-18 22:38:03 +08:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
2009-08-25 22:47:00 +08:00
|
|
|
struct device *dev = icd->dev.parent;
|
2009-08-25 22:46:59 +08:00
|
|
|
struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
|
2009-02-23 23:11:25 +08:00
|
|
|
const struct soc_camera_data_format *cam_fmt = NULL;
|
|
|
|
const struct soc_camera_format_xlate *xlate = NULL;
|
2008-12-18 22:38:03 +08:00
|
|
|
struct soc_camera_sense sense = {
|
|
|
|
.master_clock = pcdev->mclk,
|
|
|
|
.pixel_clock_max = pcdev->ciclk / 4,
|
|
|
|
};
|
2009-03-13 17:08:20 +08:00
|
|
|
struct v4l2_pix_format *pix = &f->fmt.pix;
|
|
|
|
struct v4l2_format cam_f = *f;
|
2009-02-23 23:11:25 +08:00
|
|
|
int ret;
|
2008-12-01 20:44:59 +08:00
|
|
|
|
2009-03-13 17:08:20 +08:00
|
|
|
xlate = soc_camera_xlate_by_fourcc(icd, pix->pixelformat);
|
|
|
|
if (!xlate) {
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_warn(dev, "Format %x not found\n", pix->pixelformat);
|
2009-03-13 17:08:20 +08:00
|
|
|
return -EINVAL;
|
2009-02-23 23:11:25 +08:00
|
|
|
}
|
2008-12-01 20:45:35 +08:00
|
|
|
|
2009-03-13 17:08:20 +08:00
|
|
|
cam_fmt = xlate->cam_fmt;
|
|
|
|
|
2008-12-18 22:38:03 +08:00
|
|
|
/* If PCLK is used to latch data from the sensor, check sense */
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_PCLK_EN)
|
|
|
|
icd->sense = &sense;
|
|
|
|
|
2009-03-13 17:08:20 +08:00
|
|
|
cam_f.fmt.pix.pixelformat = cam_fmt->fourcc;
|
2009-10-05 23:54:34 +08:00
|
|
|
ret = v4l2_subdev_call(sd, video, s_fmt, &cam_f);
|
|
|
|
cam_f.fmt.pix.pixelformat = pix->pixelformat;
|
|
|
|
*pix = cam_f.fmt.pix;
|
2008-12-01 20:45:35 +08:00
|
|
|
|
2008-12-18 22:38:03 +08:00
|
|
|
icd->sense = NULL;
|
|
|
|
|
|
|
|
if (ret < 0) {
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_warn(dev, "Failed to configure for format %x\n",
|
2009-03-13 17:08:20 +08:00
|
|
|
pix->pixelformat);
|
2009-08-25 22:50:46 +08:00
|
|
|
} else if (pxa_camera_check_frame(pix)) {
|
|
|
|
dev_warn(dev,
|
|
|
|
"Camera driver produced an unsupported frame %dx%d\n",
|
|
|
|
pix->width, pix->height);
|
|
|
|
ret = -EINVAL;
|
2008-12-18 22:38:03 +08:00
|
|
|
} else if (sense.flags & SOCAM_SENSE_PCLK_CHANGED) {
|
|
|
|
if (sense.pixel_clock > sense.pixel_clock_max) {
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_err(dev,
|
2008-12-18 22:38:03 +08:00
|
|
|
"pixel clock %lu set by the camera too high!",
|
|
|
|
sense.pixel_clock);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
recalculate_fifo_timeout(pcdev, sense.pixel_clock);
|
|
|
|
}
|
2008-12-01 20:45:35 +08:00
|
|
|
|
2009-03-13 17:08:20 +08:00
|
|
|
if (!ret) {
|
2009-02-23 23:11:25 +08:00
|
|
|
icd->buswidth = xlate->buswidth;
|
|
|
|
icd->current_fmt = xlate->host_fmt;
|
2008-12-01 20:45:35 +08:00
|
|
|
}
|
2008-12-01 20:44:59 +08:00
|
|
|
|
|
|
|
return ret;
|
2008-03-08 08:57:18 +08:00
|
|
|
}
|
|
|
|
|
2008-12-01 20:45:21 +08:00
|
|
|
static int pxa_camera_try_fmt(struct soc_camera_device *icd,
|
|
|
|
struct v4l2_format *f)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
2008-12-01 20:45:35 +08:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
2009-08-25 22:46:59 +08:00
|
|
|
struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
|
2008-12-01 20:45:35 +08:00
|
|
|
const struct soc_camera_format_xlate *xlate;
|
|
|
|
struct v4l2_pix_format *pix = &f->fmt.pix;
|
|
|
|
__u32 pixfmt = pix->pixelformat;
|
2008-12-18 23:52:08 +08:00
|
|
|
enum v4l2_field field;
|
2008-12-18 22:53:51 +08:00
|
|
|
int ret;
|
2008-12-01 20:44:53 +08:00
|
|
|
|
2008-12-01 20:45:35 +08:00
|
|
|
xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
|
|
|
|
if (!xlate) {
|
2009-08-25 22:43:33 +08:00
|
|
|
dev_warn(ici->v4l2_dev.dev, "Format %x not found\n", pixfmt);
|
2008-12-01 20:44:59 +08:00
|
|
|
return -EINVAL;
|
2008-12-01 20:45:35 +08:00
|
|
|
}
|
2008-12-01 20:44:59 +08:00
|
|
|
|
2009-03-31 14:44:21 +08:00
|
|
|
/*
|
2009-05-31 08:45:46 +08:00
|
|
|
* Limit to pxa hardware capabilities. YUV422P planar format requires
|
|
|
|
* images size to be a multiple of 16 bytes. If not, zeros will be
|
|
|
|
* inserted between Y and U planes, and U and V planes, which violates
|
|
|
|
* the YUV422P standard.
|
2009-03-31 14:44:21 +08:00
|
|
|
*/
|
2009-05-31 08:45:46 +08:00
|
|
|
v4l_bound_align_image(&pix->width, 48, 2048, 1,
|
|
|
|
&pix->height, 32, 2048, 0,
|
2009-08-25 22:50:46 +08:00
|
|
|
pixfmt == V4L2_PIX_FMT_YUV422P ? 4 : 0);
|
2009-03-31 14:44:21 +08:00
|
|
|
|
2008-12-01 20:45:35 +08:00
|
|
|
pix->bytesperline = pix->width *
|
|
|
|
DIV_ROUND_UP(xlate->host_fmt->depth, 8);
|
|
|
|
pix->sizeimage = pix->height * pix->bytesperline;
|
2008-12-01 20:44:59 +08:00
|
|
|
|
2008-12-18 22:53:51 +08:00
|
|
|
/* camera has to see its format, but the user the original one */
|
|
|
|
pix->pixelformat = xlate->cam_fmt->fourcc;
|
2008-03-08 08:57:18 +08:00
|
|
|
/* limit to sensor capabilities */
|
2009-08-25 22:46:59 +08:00
|
|
|
ret = v4l2_subdev_call(sd, video, try_fmt, f);
|
2009-08-25 22:50:46 +08:00
|
|
|
pix->pixelformat = pixfmt;
|
2008-12-18 22:53:51 +08:00
|
|
|
|
2008-12-18 23:52:08 +08:00
|
|
|
field = pix->field;
|
|
|
|
|
|
|
|
if (field == V4L2_FIELD_ANY) {
|
|
|
|
pix->field = V4L2_FIELD_NONE;
|
|
|
|
} else if (field != V4L2_FIELD_NONE) {
|
2009-08-25 22:47:00 +08:00
|
|
|
dev_err(icd->dev.parent, "Field type %d unsupported.\n", field);
|
2008-12-18 23:52:08 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-12-18 22:53:51 +08:00
|
|
|
return ret;
|
2008-04-07 08:24:56 +08:00
|
|
|
}
|
|
|
|
|
2008-04-15 13:57:48 +08:00
|
|
|
static int pxa_camera_reqbufs(struct soc_camera_file *icf,
|
|
|
|
struct v4l2_requestbuffers *p)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* This is for locking debugging only. I removed spinlocks and now I
|
|
|
|
* check whether .prepare is ever called on a linked buffer, or whether
|
|
|
|
* a dma IRQ can occur for an in-work or unlinked buffer. Until now
|
|
|
|
* it hadn't triggered */
|
|
|
|
for (i = 0; i < p->count; i++) {
|
|
|
|
struct pxa_buffer *buf = container_of(icf->vb_vidq.bufs[i],
|
|
|
|
struct pxa_buffer, vb);
|
|
|
|
buf->inwork = 0;
|
|
|
|
INIT_LIST_HEAD(&buf->vb.queue);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-15 13:57:48 +08:00
|
|
|
static unsigned int pxa_camera_poll(struct file *file, poll_table *pt)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
|
|
|
struct soc_camera_file *icf = file->private_data;
|
|
|
|
struct pxa_buffer *buf;
|
|
|
|
|
|
|
|
buf = list_entry(icf->vb_vidq.stream.next, struct pxa_buffer,
|
|
|
|
vb.stream);
|
|
|
|
|
|
|
|
poll_wait(file, &buf->vb.done, pt);
|
|
|
|
|
|
|
|
if (buf->vb.state == VIDEOBUF_DONE ||
|
|
|
|
buf->vb.state == VIDEOBUF_ERROR)
|
|
|
|
return POLLIN|POLLRDNORM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-15 13:57:48 +08:00
|
|
|
static int pxa_camera_querycap(struct soc_camera_host *ici,
|
|
|
|
struct v4l2_capability *cap)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
|
|
|
/* cap->name is set by the firendly caller:-> */
|
|
|
|
strlcpy(cap->card, pxa_cam_driver_description, sizeof(cap->card));
|
|
|
|
cap->version = PXA_CAM_VERSION_CODE;
|
|
|
|
cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-02 18:10:04 +08:00
|
|
|
static int pxa_camera_suspend(struct soc_camera_device *icd, pm_message_t state)
|
|
|
|
{
|
2008-12-18 22:51:55 +08:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
2008-08-02 18:10:04 +08:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
int i = 0, ret = 0;
|
|
|
|
|
2008-12-18 22:15:50 +08:00
|
|
|
pcdev->save_cicr[i++] = __raw_readl(pcdev->base + CICR0);
|
|
|
|
pcdev->save_cicr[i++] = __raw_readl(pcdev->base + CICR1);
|
|
|
|
pcdev->save_cicr[i++] = __raw_readl(pcdev->base + CICR2);
|
|
|
|
pcdev->save_cicr[i++] = __raw_readl(pcdev->base + CICR3);
|
|
|
|
pcdev->save_cicr[i++] = __raw_readl(pcdev->base + CICR4);
|
2008-08-02 18:10:04 +08:00
|
|
|
|
|
|
|
if ((pcdev->icd) && (pcdev->icd->ops->suspend))
|
|
|
|
ret = pcdev->icd->ops->suspend(pcdev->icd, state);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pxa_camera_resume(struct soc_camera_device *icd)
|
|
|
|
{
|
2008-12-18 22:51:55 +08:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
|
2008-08-02 18:10:04 +08:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
int i = 0, ret = 0;
|
|
|
|
|
[ARM] pxa: simplify DMA register definitions
1. DRCMRxx is no longer recommended, use DRCMR(xx) instead, and
pass DRCMR index by "struct resource" if possible
2. DCSRxx, DDADRxx, DSADRxx, DTADRxx, DCMDxx is never used, use
DCSR(), DDADR(), DSADR(), DTADR(), DCMD() instead
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Acked-by: Nicolas Pitre <nico@cam.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2008-09-08 15:26:43 +08:00
|
|
|
DRCMR(68) = pcdev->dma_chans[0] | DRCMR_MAPVLD;
|
|
|
|
DRCMR(69) = pcdev->dma_chans[1] | DRCMR_MAPVLD;
|
|
|
|
DRCMR(70) = pcdev->dma_chans[2] | DRCMR_MAPVLD;
|
2008-08-02 18:10:04 +08:00
|
|
|
|
2008-12-18 22:15:50 +08:00
|
|
|
__raw_writel(pcdev->save_cicr[i++] & ~CICR0_ENB, pcdev->base + CICR0);
|
|
|
|
__raw_writel(pcdev->save_cicr[i++], pcdev->base + CICR1);
|
|
|
|
__raw_writel(pcdev->save_cicr[i++], pcdev->base + CICR2);
|
|
|
|
__raw_writel(pcdev->save_cicr[i++], pcdev->base + CICR3);
|
|
|
|
__raw_writel(pcdev->save_cicr[i++], pcdev->base + CICR4);
|
2008-08-02 18:10:04 +08:00
|
|
|
|
|
|
|
if ((pcdev->icd) && (pcdev->icd->ops->resume))
|
|
|
|
ret = pcdev->icd->ops->resume(pcdev->icd);
|
|
|
|
|
|
|
|
/* Restart frame capture if active buffer exists */
|
2009-03-31 14:44:21 +08:00
|
|
|
if (!ret && pcdev->active)
|
|
|
|
pxa_camera_start_capture(pcdev);
|
2008-08-02 18:10:04 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-04-05 00:41:25 +08:00
|
|
|
static struct soc_camera_host_ops pxa_soc_camera_host_ops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.add = pxa_camera_add_device,
|
|
|
|
.remove = pxa_camera_remove_device,
|
2008-08-02 18:10:04 +08:00
|
|
|
.suspend = pxa_camera_suspend,
|
|
|
|
.resume = pxa_camera_resume,
|
2009-03-13 17:08:20 +08:00
|
|
|
.set_crop = pxa_camera_set_crop,
|
2008-12-01 20:45:35 +08:00
|
|
|
.get_formats = pxa_camera_get_formats,
|
2009-08-25 22:50:46 +08:00
|
|
|
.put_formats = pxa_camera_put_formats,
|
2008-12-01 20:45:21 +08:00
|
|
|
.set_fmt = pxa_camera_set_fmt,
|
|
|
|
.try_fmt = pxa_camera_try_fmt,
|
2008-07-12 07:50:31 +08:00
|
|
|
.init_videobuf = pxa_camera_init_videobuf,
|
2008-04-05 00:41:25 +08:00
|
|
|
.reqbufs = pxa_camera_reqbufs,
|
|
|
|
.poll = pxa_camera_poll,
|
|
|
|
.querycap = pxa_camera_querycap,
|
|
|
|
.set_bus_param = pxa_camera_set_bus_param,
|
|
|
|
};
|
|
|
|
|
2009-06-04 22:07:16 +08:00
|
|
|
static int __devinit pxa_camera_probe(struct platform_device *pdev)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
|
|
|
struct pxa_camera_dev *pcdev;
|
|
|
|
struct resource *res;
|
|
|
|
void __iomem *base;
|
2008-06-13 20:03:45 +08:00
|
|
|
int irq;
|
2008-04-07 08:24:56 +08:00
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
irq = platform_get_irq(pdev, 0);
|
2008-06-13 20:03:45 +08:00
|
|
|
if (!res || irq < 0) {
|
2008-04-07 08:24:56 +08:00
|
|
|
err = -ENODEV;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
pcdev = kzalloc(sizeof(*pcdev), GFP_KERNEL);
|
|
|
|
if (!pcdev) {
|
2008-04-15 13:57:48 +08:00
|
|
|
dev_err(&pdev->dev, "Could not allocate pcdev\n");
|
2008-04-07 08:24:56 +08:00
|
|
|
err = -ENOMEM;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2008-11-12 01:52:32 +08:00
|
|
|
pcdev->clk = clk_get(&pdev->dev, NULL);
|
2008-04-07 08:24:56 +08:00
|
|
|
if (IS_ERR(pcdev->clk)) {
|
|
|
|
err = PTR_ERR(pcdev->clk);
|
|
|
|
goto exit_kfree;
|
|
|
|
}
|
|
|
|
|
|
|
|
pcdev->res = res;
|
|
|
|
|
|
|
|
pcdev->pdata = pdev->dev.platform_data;
|
|
|
|
pcdev->platform_flags = pcdev->pdata->flags;
|
2008-03-08 08:57:18 +08:00
|
|
|
if (!(pcdev->platform_flags & (PXA_CAMERA_DATAWIDTH_8 |
|
|
|
|
PXA_CAMERA_DATAWIDTH_9 | PXA_CAMERA_DATAWIDTH_10))) {
|
2008-04-07 08:24:56 +08:00
|
|
|
/* Platform hasn't set available data widths. This is bad.
|
|
|
|
* Warn and use a default. */
|
|
|
|
dev_warn(&pdev->dev, "WARNING! Platform hasn't set available "
|
|
|
|
"data widths, using default 10 bit\n");
|
|
|
|
pcdev->platform_flags |= PXA_CAMERA_DATAWIDTH_10;
|
|
|
|
}
|
2008-12-18 22:38:03 +08:00
|
|
|
pcdev->mclk = pcdev->pdata->mclk_10khz * 10000;
|
|
|
|
if (!pcdev->mclk) {
|
2008-04-07 08:24:56 +08:00
|
|
|
dev_warn(&pdev->dev,
|
2008-12-18 22:38:03 +08:00
|
|
|
"mclk == 0! Please, fix your platform data. "
|
2008-04-07 08:24:56 +08:00
|
|
|
"Using default 20MHz\n");
|
2008-12-18 22:38:03 +08:00
|
|
|
pcdev->mclk = 20000000;
|
2008-04-07 08:24:56 +08:00
|
|
|
}
|
|
|
|
|
2009-08-25 22:28:22 +08:00
|
|
|
pcdev->mclk_divisor = mclk_get_divisor(pdev, pcdev);
|
2008-12-18 22:38:03 +08:00
|
|
|
|
2008-04-07 08:24:56 +08:00
|
|
|
INIT_LIST_HEAD(&pcdev->capture);
|
|
|
|
spin_lock_init(&pcdev->lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Request the regions.
|
|
|
|
*/
|
2009-04-24 23:55:18 +08:00
|
|
|
if (!request_mem_region(res->start, resource_size(res),
|
2008-04-07 08:24:56 +08:00
|
|
|
PXA_CAM_DRV_NAME)) {
|
|
|
|
err = -EBUSY;
|
|
|
|
goto exit_clk;
|
|
|
|
}
|
|
|
|
|
2009-04-24 23:55:18 +08:00
|
|
|
base = ioremap(res->start, resource_size(res));
|
2008-04-07 08:24:56 +08:00
|
|
|
if (!base) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto exit_release;
|
|
|
|
}
|
|
|
|
pcdev->irq = irq;
|
|
|
|
pcdev->base = base;
|
|
|
|
|
|
|
|
/* request dma */
|
2008-09-19 04:50:15 +08:00
|
|
|
err = pxa_request_dma("CI_Y", DMA_PRIO_HIGH,
|
|
|
|
pxa_camera_dma_irq_y, pcdev);
|
|
|
|
if (err < 0) {
|
2009-04-24 23:55:48 +08:00
|
|
|
dev_err(&pdev->dev, "Can't request DMA for Y\n");
|
2008-04-07 08:24:56 +08:00
|
|
|
goto exit_iounmap;
|
|
|
|
}
|
2008-09-19 04:50:15 +08:00
|
|
|
pcdev->dma_chans[0] = err;
|
2009-04-24 23:55:48 +08:00
|
|
|
dev_dbg(&pdev->dev, "got DMA channel %d\n", pcdev->dma_chans[0]);
|
2008-04-22 21:36:32 +08:00
|
|
|
|
2008-09-19 04:50:15 +08:00
|
|
|
err = pxa_request_dma("CI_U", DMA_PRIO_HIGH,
|
|
|
|
pxa_camera_dma_irq_u, pcdev);
|
|
|
|
if (err < 0) {
|
2009-04-24 23:55:48 +08:00
|
|
|
dev_err(&pdev->dev, "Can't request DMA for U\n");
|
2008-04-22 21:36:32 +08:00
|
|
|
goto exit_free_dma_y;
|
|
|
|
}
|
2008-09-19 04:50:15 +08:00
|
|
|
pcdev->dma_chans[1] = err;
|
2009-04-24 23:55:48 +08:00
|
|
|
dev_dbg(&pdev->dev, "got DMA channel (U) %d\n", pcdev->dma_chans[1]);
|
2008-04-22 21:36:32 +08:00
|
|
|
|
2008-09-19 04:50:15 +08:00
|
|
|
err = pxa_request_dma("CI_V", DMA_PRIO_HIGH,
|
|
|
|
pxa_camera_dma_irq_v, pcdev);
|
|
|
|
if (err < 0) {
|
2009-04-24 23:55:48 +08:00
|
|
|
dev_err(&pdev->dev, "Can't request DMA for V\n");
|
2008-04-22 21:36:32 +08:00
|
|
|
goto exit_free_dma_u;
|
|
|
|
}
|
2008-09-19 04:50:15 +08:00
|
|
|
pcdev->dma_chans[2] = err;
|
2009-04-24 23:55:48 +08:00
|
|
|
dev_dbg(&pdev->dev, "got DMA channel (V) %d\n", pcdev->dma_chans[2]);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
[ARM] pxa: simplify DMA register definitions
1. DRCMRxx is no longer recommended, use DRCMR(xx) instead, and
pass DRCMR index by "struct resource" if possible
2. DCSRxx, DDADRxx, DSADRxx, DTADRxx, DCMDxx is never used, use
DCSR(), DDADR(), DSADR(), DTADR(), DCMD() instead
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Acked-by: Nicolas Pitre <nico@cam.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2008-09-08 15:26:43 +08:00
|
|
|
DRCMR(68) = pcdev->dma_chans[0] | DRCMR_MAPVLD;
|
|
|
|
DRCMR(69) = pcdev->dma_chans[1] | DRCMR_MAPVLD;
|
|
|
|
DRCMR(70) = pcdev->dma_chans[2] | DRCMR_MAPVLD;
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
/* request irq */
|
|
|
|
err = request_irq(pcdev->irq, pxa_camera_irq, 0, PXA_CAM_DRV_NAME,
|
|
|
|
pcdev);
|
|
|
|
if (err) {
|
2009-04-24 23:55:48 +08:00
|
|
|
dev_err(&pdev->dev, "Camera interrupt register failed \n");
|
2008-04-07 08:24:56 +08:00
|
|
|
goto exit_free_dma;
|
|
|
|
}
|
|
|
|
|
2009-04-24 23:55:18 +08:00
|
|
|
pcdev->soc_host.drv_name = PXA_CAM_DRV_NAME;
|
|
|
|
pcdev->soc_host.ops = &pxa_soc_camera_host_ops;
|
|
|
|
pcdev->soc_host.priv = pcdev;
|
2009-08-25 22:43:33 +08:00
|
|
|
pcdev->soc_host.v4l2_dev.dev = &pdev->dev;
|
2009-04-24 23:55:18 +08:00
|
|
|
pcdev->soc_host.nr = pdev->id;
|
2009-04-24 23:55:48 +08:00
|
|
|
|
2009-04-24 23:55:18 +08:00
|
|
|
err = soc_camera_host_register(&pcdev->soc_host);
|
2008-04-07 08:24:56 +08:00
|
|
|
if (err)
|
|
|
|
goto exit_free_irq;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
exit_free_irq:
|
|
|
|
free_irq(pcdev->irq, pcdev);
|
|
|
|
exit_free_dma:
|
2008-04-22 21:36:32 +08:00
|
|
|
pxa_free_dma(pcdev->dma_chans[2]);
|
|
|
|
exit_free_dma_u:
|
|
|
|
pxa_free_dma(pcdev->dma_chans[1]);
|
|
|
|
exit_free_dma_y:
|
|
|
|
pxa_free_dma(pcdev->dma_chans[0]);
|
2008-04-07 08:24:56 +08:00
|
|
|
exit_iounmap:
|
|
|
|
iounmap(base);
|
|
|
|
exit_release:
|
2009-04-24 23:55:18 +08:00
|
|
|
release_mem_region(res->start, resource_size(res));
|
2008-04-07 08:24:56 +08:00
|
|
|
exit_clk:
|
|
|
|
clk_put(pcdev->clk);
|
|
|
|
exit_kfree:
|
|
|
|
kfree(pcdev);
|
|
|
|
exit:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __devexit pxa_camera_remove(struct platform_device *pdev)
|
|
|
|
{
|
2009-04-24 23:55:48 +08:00
|
|
|
struct soc_camera_host *soc_host = to_soc_camera_host(&pdev->dev);
|
|
|
|
struct pxa_camera_dev *pcdev = container_of(soc_host,
|
|
|
|
struct pxa_camera_dev, soc_host);
|
2008-04-07 08:24:56 +08:00
|
|
|
struct resource *res;
|
|
|
|
|
|
|
|
clk_put(pcdev->clk);
|
|
|
|
|
2008-04-22 21:36:32 +08:00
|
|
|
pxa_free_dma(pcdev->dma_chans[0]);
|
|
|
|
pxa_free_dma(pcdev->dma_chans[1]);
|
|
|
|
pxa_free_dma(pcdev->dma_chans[2]);
|
2008-04-07 08:24:56 +08:00
|
|
|
free_irq(pcdev->irq, pcdev);
|
|
|
|
|
2009-04-24 23:55:48 +08:00
|
|
|
soc_camera_host_unregister(soc_host);
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
iounmap(pcdev->base);
|
|
|
|
|
|
|
|
res = pcdev->res;
|
2009-04-24 23:55:18 +08:00
|
|
|
release_mem_region(res->start, resource_size(res));
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
kfree(pcdev);
|
|
|
|
|
2008-04-15 13:57:48 +08:00
|
|
|
dev_info(&pdev->dev, "PXA Camera driver unloaded\n");
|
2008-04-07 08:24:56 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct platform_driver pxa_camera_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = PXA_CAM_DRV_NAME,
|
|
|
|
},
|
|
|
|
.probe = pxa_camera_probe,
|
2009-06-04 22:07:16 +08:00
|
|
|
.remove = __devexit_p(pxa_camera_remove),
|
2008-04-07 08:24:56 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2009-06-04 22:07:16 +08:00
|
|
|
static int __init pxa_camera_init(void)
|
2008-04-07 08:24:56 +08:00
|
|
|
{
|
|
|
|
return platform_driver_register(&pxa_camera_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit pxa_camera_exit(void)
|
|
|
|
{
|
2008-08-02 06:48:51 +08:00
|
|
|
platform_driver_unregister(&pxa_camera_driver);
|
2008-04-07 08:24:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(pxa_camera_init);
|
|
|
|
module_exit(pxa_camera_exit);
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION("PXA27x SoC Camera Host driver");
|
|
|
|
MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
|
|
|
|
MODULE_LICENSE("GPL");
|
2009-08-25 22:28:22 +08:00
|
|
|
MODULE_ALIAS("platform:" PXA_CAM_DRV_NAME);
|