2008-04-06 18:24:56 -06: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-14 23:57:48 -06:00
|
|
|
#include <linux/io.h>
|
2008-04-06 18:24:56 -06: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/device.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/clk.h>
|
2009-11-04 10:18:04 -07:00
|
|
|
#include <linux/sched.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
#include <media/v4l2-common.h>
|
|
|
|
#include <media/v4l2-dev.h>
|
2008-07-11 17:50:31 -06:00
|
|
|
#include <media/videobuf-dma-sg.h>
|
2008-04-06 18:24:56 -06:00
|
|
|
#include <media/soc_camera.h>
|
2009-12-11 07:46:49 -07:00
|
|
|
#include <media/soc_mediabus.h>
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
#include <linux/videodev2.h>
|
|
|
|
|
2009-01-02 08:16:02 -07:00
|
|
|
#include <mach/dma.h>
|
2012-08-24 07:16:48 -06:00
|
|
|
#include <linux/platform_data/camera-pxa.h>
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2011-06-25 08:28:37 -06:00
|
|
|
#define PXA_CAM_VERSION "0.0.6"
|
2008-04-06 18:24:56 -06:00
|
|
|
#define PXA_CAM_DRV_NAME "pxa27x-camera"
|
|
|
|
|
2008-12-18 07:15:50 -07: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-14 23:57:48 -06: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 07:36:32 -06: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-14 23:57:48 -06: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-06 18:24:56 -06: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 07:36:32 -06: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-06 18:24:56 -06:00
|
|
|
|
|
|
|
/* buffer for one video frame */
|
|
|
|
struct pxa_buffer {
|
|
|
|
/* common v4l buffer stuff -- must be first */
|
2009-12-11 07:46:49 -07:00
|
|
|
struct videobuf_buffer vb;
|
|
|
|
enum v4l2_mbus_pixelcode code;
|
2008-04-22 07:36:32 -06:00
|
|
|
/* our descriptor lists for Y, U and V channels */
|
2009-12-11 07:46:49 -07:00
|
|
|
struct pxa_cam_dma dmas[3];
|
|
|
|
int inwork;
|
|
|
|
enum pxa_camera_active_dma active_dma;
|
2008-04-06 18:24:56 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct pxa_camera_dev {
|
2009-04-24 09:55:18 -06:00
|
|
|
struct soc_camera_host soc_host;
|
2009-12-11 07:15:05 -07:00
|
|
|
/*
|
|
|
|
* PXA27x is only supposed to handle one camera on its Quick Capture
|
2008-04-06 18:24:56 -06:00
|
|
|
* interface. If anyone ever builds hardware to enable more than
|
2009-12-11 07:15:05 -07:00
|
|
|
* one camera, they will have to modify this driver too
|
|
|
|
*/
|
2008-04-06 18:24:56 -06:00
|
|
|
struct soc_camera_device *icd;
|
|
|
|
struct clk *clk;
|
|
|
|
|
|
|
|
unsigned int irq;
|
|
|
|
void __iomem *base;
|
2008-04-22 07:36:32 -06:00
|
|
|
|
2008-04-22 07:37:49 -06:00
|
|
|
int channels;
|
2008-04-22 07:36:32 -06:00
|
|
|
unsigned int dma_chans[3];
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
struct pxacamera_platform_data *pdata;
|
|
|
|
struct resource *res;
|
|
|
|
unsigned long platform_flags;
|
2008-12-18 07:38:03 -07:00
|
|
|
unsigned long ciclk;
|
|
|
|
unsigned long mclk;
|
|
|
|
u32 mclk_divisor;
|
2011-07-27 13:37:45 -06:00
|
|
|
u16 width_flags; /* max 10 bits */
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
struct list_head capture;
|
|
|
|
|
|
|
|
spinlock_t lock;
|
|
|
|
|
|
|
|
struct pxa_buffer *active;
|
2008-04-22 07:40:23 -06:00
|
|
|
struct pxa_dma_desc *sg_tail[3];
|
2008-08-02 04:10:04 -06:00
|
|
|
|
|
|
|
u32 save_cicr[5];
|
2008-04-06 18:24:56 -06:00
|
|
|
};
|
|
|
|
|
2009-08-25 08:50:46 -06:00
|
|
|
struct pxa_cam {
|
|
|
|
unsigned long flags;
|
|
|
|
};
|
|
|
|
|
2008-04-06 18:24:56 -06: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-14 23:57:48 -06:00
|
|
|
static int pxa_videobuf_setup(struct videobuf_queue *vq, unsigned int *count,
|
|
|
|
unsigned int *size)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
|
|
|
struct soc_camera_device *icd = vq->priv_data;
|
|
|
|
|
2011-07-15 17:03:38 -06:00
|
|
|
dev_dbg(icd->parent, "count=%d, size=%d\n", *count, *size);
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2012-03-21 05:03:21 -06:00
|
|
|
*size = icd->sizeimage;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
if (0 == *count)
|
|
|
|
*count = 32;
|
2010-03-21 13:02:45 -06:00
|
|
|
if (*size * *count > vid_limit * 1024 * 1024)
|
|
|
|
*count = (vid_limit * 1024 * 1024) / *size;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_buffer(struct videobuf_queue *vq, struct pxa_buffer *buf)
|
|
|
|
{
|
|
|
|
struct soc_camera_device *icd = vq->priv_data;
|
2011-07-15 17:03:38 -06:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
|
2008-04-06 18:24:56 -06:00
|
|
|
struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);
|
2008-04-22 07:36:32 -06:00
|
|
|
int i;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
BUG_ON(in_interrupt());
|
|
|
|
|
2011-07-15 17:03:38 -06:00
|
|
|
dev_dbg(icd->parent, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
|
2008-04-06 18:24:56 -06:00
|
|
|
&buf->vb, buf->vb.baddr, buf->vb.bsize);
|
|
|
|
|
2009-12-11 07:15:05 -07:00
|
|
|
/*
|
|
|
|
* This waits until this buffer is out of danger, i.e., until it is no
|
|
|
|
* longer in STATE_QUEUED or STATE_ACTIVE
|
|
|
|
*/
|
2010-09-26 06:01:26 -06:00
|
|
|
videobuf_waiton(vq, &buf->vb, 0, 0);
|
2010-05-11 07:36:30 -06:00
|
|
|
videobuf_dma_unmap(vq->dev, dma);
|
2008-04-06 18:24:56 -06:00
|
|
|
videobuf_dma_free(dma);
|
|
|
|
|
2008-04-22 07:36:32 -06:00
|
|
|
for (i = 0; i < ARRAY_SIZE(buf->dmas); i++) {
|
|
|
|
if (buf->dmas[i].sg_cpu)
|
2009-08-25 08:53:23 -06:00
|
|
|
dma_free_coherent(ici->v4l2_dev.dev,
|
|
|
|
buf->dmas[i].sg_size,
|
2008-04-22 07:36:32 -06:00
|
|
|
buf->dmas[i].sg_cpu,
|
|
|
|
buf->dmas[i].sg_dma);
|
|
|
|
buf->dmas[i].sg_cpu = NULL;
|
|
|
|
}
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
buf->vb.state = VIDEOBUF_NEEDS_INIT;
|
|
|
|
}
|
|
|
|
|
2009-03-31 00:44:21 -06: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 07:36:32 -06: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 00:44:21 -06:00
|
|
|
int cibr, int size,
|
|
|
|
struct scatterlist **sg_first, int *sg_first_ofs)
|
2008-04-22 07:36:32 -06:00
|
|
|
{
|
|
|
|
struct pxa_cam_dma *pxa_dma = &buf->dmas[channel];
|
2009-08-25 08:43:33 -06:00
|
|
|
struct device *dev = pcdev->soc_host.v4l2_dev.dev;
|
2009-03-31 00:44:21 -06:00
|
|
|
struct scatterlist *sg;
|
|
|
|
int i, offset, sglen;
|
|
|
|
int dma_len = 0, xfer_len = 0;
|
2008-04-22 07:36:32 -06:00
|
|
|
|
|
|
|
if (pxa_dma->sg_cpu)
|
2009-08-25 08:43:33 -06:00
|
|
|
dma_free_coherent(dev, pxa_dma->sg_size,
|
2008-04-22 07:36:32 -06:00
|
|
|
pxa_dma->sg_cpu, pxa_dma->sg_dma);
|
|
|
|
|
2009-03-31 00:44:21 -06:00
|
|
|
sglen = calculate_dma_sglen(*sg_first, dma->sglen,
|
|
|
|
*sg_first_ofs, size);
|
|
|
|
|
2008-04-22 07:36:32 -06:00
|
|
|
pxa_dma->sg_size = (sglen + 1) * sizeof(struct pxa_dma_desc);
|
2009-08-25 08:43:33 -06:00
|
|
|
pxa_dma->sg_cpu = dma_alloc_coherent(dev, pxa_dma->sg_size,
|
2008-04-22 07:36:32 -06:00
|
|
|
&pxa_dma->sg_dma, GFP_KERNEL);
|
|
|
|
if (!pxa_dma->sg_cpu)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
pxa_dma->sglen = sglen;
|
2009-03-31 00:44:21 -06:00
|
|
|
offset = *sg_first_ofs;
|
2008-04-22 07:36:32 -06:00
|
|
|
|
2009-08-25 08:43:33 -06:00
|
|
|
dev_dbg(dev, "DMA: sg_first=%p, sglen=%d, ofs=%d, dma.desc=%x\n",
|
2009-03-31 00:44:21 -06:00
|
|
|
*sg_first, sglen, *sg_first_ofs, pxa_dma->sg_dma);
|
2008-04-22 07:36:32 -06:00
|
|
|
|
2009-03-31 00:44:21 -06:00
|
|
|
|
|
|
|
for_each_sg(*sg_first, sg, sglen, i) {
|
|
|
|
dma_len = sg_dma_len(sg);
|
2008-04-22 07:36:32 -06:00
|
|
|
|
|
|
|
/* PXA27x Developer's Manual 27.4.4.1: round up to 8 bytes */
|
2009-03-31 00:44:21 -06:00
|
|
|
xfer_len = roundup(min(dma_len - offset, size), 8);
|
2008-04-22 07:36:32 -06:00
|
|
|
|
2009-03-31 00:44:21 -06: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 07:36:32 -06:00
|
|
|
pxa_dma->sg_cpu[i].dcmd =
|
|
|
|
DCMD_FLOWSRC | DCMD_BURST8 | DCMD_INCTRGADDR | xfer_len;
|
2009-03-31 00:44:21 -06:00
|
|
|
#ifdef DEBUG
|
|
|
|
if (!i)
|
|
|
|
pxa_dma->sg_cpu[i].dcmd |= DCMD_STARTIRQEN;
|
|
|
|
#endif
|
2008-04-22 07:36:32 -06:00
|
|
|
pxa_dma->sg_cpu[i].ddadr =
|
|
|
|
pxa_dma->sg_dma + (i + 1) * sizeof(struct pxa_dma_desc);
|
2009-03-31 00:44:21 -06:00
|
|
|
|
2009-08-25 08:43:33 -06:00
|
|
|
dev_vdbg(dev, "DMA: desc.%08x->@phys=0x%08x, len=%d\n",
|
2009-03-31 00:44:21 -06: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 07:36:32 -06:00
|
|
|
}
|
|
|
|
|
2009-03-31 00:44:21 -06:00
|
|
|
pxa_dma->sg_cpu[sglen].ddadr = DDADR_STOP;
|
|
|
|
pxa_dma->sg_cpu[sglen].dcmd = DCMD_FLOWSRC | DCMD_BURST8 | DCMD_ENDIRQEN;
|
2008-04-22 07:36:32 -06:00
|
|
|
|
2009-03-31 00:44:21 -06: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 07:36:32 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-31 00:44:21 -06: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-14 23:57:48 -06:00
|
|
|
static int pxa_videobuf_prepare(struct videobuf_queue *vq,
|
|
|
|
struct videobuf_buffer *vb, enum v4l2_field field)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
|
|
|
struct soc_camera_device *icd = vq->priv_data;
|
2011-07-15 17:03:38 -06:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
|
2008-04-06 18:24:56 -06:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
2009-08-25 08:43:33 -06:00
|
|
|
struct device *dev = pcdev->soc_host.v4l2_dev.dev;
|
2008-04-06 18:24:56 -06:00
|
|
|
struct pxa_buffer *buf = container_of(vb, struct pxa_buffer, vb);
|
2008-04-22 07:36:32 -06:00
|
|
|
int ret;
|
|
|
|
int size_y, size_u = 0, size_v = 0;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2009-08-25 08:43:33 -06:00
|
|
|
dev_dbg(dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
|
2008-04-06 18:24:56 -06:00
|
|
|
vb, vb->baddr, vb->bsize);
|
|
|
|
|
|
|
|
/* Added list head initialization on alloc */
|
|
|
|
WARN_ON(!list_empty(&vb->queue));
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2009-12-11 07:15:05 -07:00
|
|
|
/*
|
|
|
|
* This can be useful if you want to see if we actually fill
|
|
|
|
* the buffer with something
|
|
|
|
*/
|
2008-04-06 18:24:56 -06:00
|
|
|
memset((void *)vb->baddr, 0xaa, vb->bsize);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
BUG_ON(NULL == icd->current_fmt);
|
|
|
|
|
2009-12-11 07:15:05 -07:00
|
|
|
/*
|
|
|
|
* I think, in buf_prepare you only have to protect global data,
|
|
|
|
* the actual buffer is yours
|
|
|
|
*/
|
2008-04-06 18:24:56 -06:00
|
|
|
buf->inwork = 1;
|
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
if (buf->code != icd->current_fmt->code ||
|
2009-08-25 08:50:46 -06:00
|
|
|
vb->width != icd->user_width ||
|
|
|
|
vb->height != icd->user_height ||
|
2008-04-06 18:24:56 -06:00
|
|
|
vb->field != field) {
|
2009-12-11 07:46:49 -07:00
|
|
|
buf->code = icd->current_fmt->code;
|
2009-08-25 08:50:46 -06:00
|
|
|
vb->width = icd->user_width;
|
|
|
|
vb->height = icd->user_height;
|
2008-04-06 18:24:56 -06:00
|
|
|
vb->field = field;
|
|
|
|
vb->state = VIDEOBUF_NEEDS_INIT;
|
|
|
|
}
|
|
|
|
|
2012-03-21 05:03:21 -06:00
|
|
|
vb->size = icd->sizeimage;
|
2008-04-06 18:24:56 -06:00
|
|
|
if (0 != vb->baddr && vb->bsize < vb->size) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vb->state == VIDEOBUF_NEEDS_INIT) {
|
2009-03-31 00:44:21 -06:00
|
|
|
int size = vb->size;
|
|
|
|
int next_ofs = 0;
|
2008-04-06 18:24:56 -06:00
|
|
|
struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
|
2009-03-31 00:44:21 -06:00
|
|
|
struct scatterlist *sg;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
ret = videobuf_iolock(vq, vb, NULL);
|
|
|
|
if (ret)
|
|
|
|
goto fail;
|
|
|
|
|
2008-04-22 07:40:23 -06:00
|
|
|
if (pcdev->channels == 3) {
|
2008-04-22 07:36:32 -06:00
|
|
|
size_y = size / 2;
|
|
|
|
size_u = size_v = size / 4;
|
|
|
|
} else {
|
|
|
|
size_y = size;
|
|
|
|
}
|
|
|
|
|
2009-03-31 00:44:21 -06:00
|
|
|
sg = dma->sglist;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2009-03-31 00:44:21 -06:00
|
|
|
/* init DMA for Y channel */
|
|
|
|
ret = pxa_init_dma_channel(pcdev, buf, dma, 0, CIBR0, size_y,
|
|
|
|
&sg, &next_ofs);
|
2008-04-22 07:36:32 -06:00
|
|
|
if (ret) {
|
2009-08-25 08:43:33 -06:00
|
|
|
dev_err(dev, "DMA initialization for Y/RGB failed\n");
|
2008-04-06 18:24:56 -06:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2009-03-31 00:44:21 -06: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 08:43:33 -06:00
|
|
|
dev_err(dev, "DMA initialization for U failed\n");
|
2009-03-31 00:44:21 -06: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 08:43:33 -06:00
|
|
|
dev_err(dev, "DMA initialization for V failed\n");
|
2009-03-31 00:44:21 -06:00
|
|
|
goto fail_v;
|
2008-04-06 18:24:56 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
vb->state = VIDEOBUF_PREPARED;
|
|
|
|
}
|
|
|
|
|
|
|
|
buf->inwork = 0;
|
2009-03-31 00:44:21 -06:00
|
|
|
pxa_videobuf_set_actdma(pcdev, buf);
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2008-04-22 07:36:32 -06:00
|
|
|
fail_v:
|
2009-08-25 08:43:33 -06:00
|
|
|
dma_free_coherent(dev, buf->dmas[1].sg_size,
|
2008-04-22 07:36:32 -06:00
|
|
|
buf->dmas[1].sg_cpu, buf->dmas[1].sg_dma);
|
|
|
|
fail_u:
|
2009-08-25 08:43:33 -06:00
|
|
|
dma_free_coherent(dev, buf->dmas[0].sg_size,
|
2008-04-22 07:36:32 -06:00
|
|
|
buf->dmas[0].sg_cpu, buf->dmas[0].sg_dma);
|
2008-04-06 18:24:56 -06:00
|
|
|
fail:
|
|
|
|
free_buffer(vq, buf);
|
|
|
|
out:
|
|
|
|
buf->inwork = 0;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-03-31 00:44:21 -06: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 08:47:00 -06:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev,
|
|
|
|
"%s (channel=%d) ddadr=%08x\n", __func__,
|
2009-03-31 00:44:21 -06: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 08:47:00 -06:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev,
|
|
|
|
"%s (channel=%d)\n", __func__, i);
|
2009-03-31 00:44:21 -06: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 00:44:22 -06: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 00:44:21 -06:00
|
|
|
|
2009-03-31 00:44:22 -06:00
|
|
|
/* Update the channel tail */
|
|
|
|
pcdev->sg_tail[i] = buf_last_desc;
|
|
|
|
}
|
2009-03-31 00:44:21 -06: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)
|
|
|
|
{
|
2010-04-20 00:51:29 -06:00
|
|
|
unsigned long cicr0;
|
2009-03-31 00:44:21 -06:00
|
|
|
|
2009-08-25 08:43:33 -06:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev, "%s\n", __func__);
|
2009-03-31 00:44:21 -06:00
|
|
|
/* 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 00:44:22 -06:00
|
|
|
pcdev->active = NULL;
|
2009-08-25 08:43:33 -06:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev, "%s\n", __func__);
|
2009-03-31 00:44:21 -06:00
|
|
|
}
|
|
|
|
|
2009-08-05 17:06:31 -06:00
|
|
|
/* Called under spinlock_irqsave(&pcdev->lock, ...) */
|
2008-04-14 23:57:48 -06:00
|
|
|
static void pxa_videobuf_queue(struct videobuf_queue *vq,
|
|
|
|
struct videobuf_buffer *vb)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
|
|
|
struct soc_camera_device *icd = vq->priv_data;
|
2011-07-15 17:03:38 -06:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
|
2008-04-06 18:24:56 -06:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
struct pxa_buffer *buf = container_of(vb, struct pxa_buffer, vb);
|
|
|
|
|
2011-07-15 17:03:38 -06:00
|
|
|
dev_dbg(icd->parent, "%s (vb=0x%p) 0x%08lx %d active=%p\n",
|
2009-08-25 08:47:00 -06:00
|
|
|
__func__, vb, vb->baddr, vb->bsize, pcdev->active);
|
2009-03-31 00:44:21 -06:00
|
|
|
|
2008-04-06 18:24:56 -06:00
|
|
|
list_add_tail(&vb->queue, &pcdev->capture);
|
|
|
|
|
|
|
|
vb->state = VIDEOBUF_ACTIVE;
|
2009-03-31 00:44:21 -06:00
|
|
|
pxa_dma_add_tail_buf(pcdev, buf);
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2009-03-31 00:44:21 -06:00
|
|
|
if (!pcdev->active)
|
|
|
|
pxa_camera_start_capture(pcdev);
|
2008-04-06 18:24:56 -06: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;
|
2011-07-15 17:03:38 -06:00
|
|
|
struct device *dev = icd->parent;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2009-08-25 08:47:00 -06:00
|
|
|
dev_dbg(dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
|
2008-04-06 18:24:56 -06:00
|
|
|
vb, vb->baddr, vb->bsize);
|
|
|
|
|
|
|
|
switch (vb->state) {
|
|
|
|
case VIDEOBUF_ACTIVE:
|
2009-08-25 08:47:00 -06:00
|
|
|
dev_dbg(dev, "%s (active)\n", __func__);
|
2008-04-06 18:24:56 -06:00
|
|
|
break;
|
|
|
|
case VIDEOBUF_QUEUED:
|
2009-08-25 08:47:00 -06:00
|
|
|
dev_dbg(dev, "%s (queued)\n", __func__);
|
2008-04-06 18:24:56 -06:00
|
|
|
break;
|
|
|
|
case VIDEOBUF_PREPARED:
|
2009-08-25 08:47:00 -06:00
|
|
|
dev_dbg(dev, "%s (prepared)\n", __func__);
|
2008-04-06 18:24:56 -06:00
|
|
|
break;
|
|
|
|
default:
|
2009-08-25 08:47:00 -06:00
|
|
|
dev_dbg(dev, "%s (unknown)\n", __func__);
|
2008-04-06 18:24:56 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
free_buffer(vq, buf);
|
|
|
|
}
|
|
|
|
|
2008-04-22 07:36:32 -06:00
|
|
|
static void pxa_camera_wakeup(struct pxa_camera_dev *pcdev,
|
|
|
|
struct videobuf_buffer *vb,
|
|
|
|
struct pxa_buffer *buf)
|
|
|
|
{
|
2009-03-31 00:44:21 -06:00
|
|
|
int i;
|
2008-12-18 07:15:50 -07:00
|
|
|
|
2008-04-22 07:36:32 -06:00
|
|
|
/* _init is used to debug races, see comment in pxa_camera_reqbufs() */
|
|
|
|
list_del_init(&vb->queue);
|
|
|
|
vb->state = VIDEOBUF_DONE;
|
2012-09-15 12:14:42 -06:00
|
|
|
v4l2_get_timestamp(&vb->ts);
|
2008-04-22 07:36:32 -06:00
|
|
|
vb->field_count++;
|
|
|
|
wake_up(&vb->done);
|
2009-08-25 08:43:33 -06:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev, "%s dequeud buffer (vb=0x%p)\n",
|
|
|
|
__func__, vb);
|
2008-04-22 07:36:32 -06:00
|
|
|
|
|
|
|
if (list_empty(&pcdev->capture)) {
|
2009-03-31 00:44:21 -06:00
|
|
|
pxa_camera_stop_capture(pcdev);
|
|
|
|
for (i = 0; i < pcdev->channels; i++)
|
|
|
|
pcdev->sg_tail[i] = NULL;
|
2008-04-22 07:36:32 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
pcdev->active = list_entry(pcdev->capture.next,
|
|
|
|
struct pxa_buffer, vb.queue);
|
|
|
|
}
|
|
|
|
|
2009-03-31 00:44:21 -06: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
|
2011-03-30 19:57:33 -06:00
|
|
|
* stopped. This means the tailed buffer would never be transferred by DMA.
|
2009-03-31 00:44:21 -06:00
|
|
|
* 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 08:43:33 -06:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev,
|
|
|
|
"%s : top queued buffer=%p, dma_stopped=%d\n",
|
2009-03-31 00:44:21 -06:00
|
|
|
__func__, pcdev->active, is_dma_stopped);
|
|
|
|
if (pcdev->active && is_dma_stopped)
|
|
|
|
pxa_camera_start_capture(pcdev);
|
|
|
|
}
|
|
|
|
|
2008-04-22 07:36:32 -06:00
|
|
|
static void pxa_camera_dma_irq(int channel, struct pxa_camera_dev *pcdev,
|
|
|
|
enum pxa_camera_active_dma act_dma)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
2009-08-25 08:43:33 -06:00
|
|
|
struct device *dev = pcdev->soc_host.v4l2_dev.dev;
|
2008-04-06 18:24:56 -06:00
|
|
|
struct pxa_buffer *buf;
|
|
|
|
unsigned long flags;
|
2008-04-22 07:37:49 -06:00
|
|
|
u32 status, camera_status, overrun;
|
2008-04-06 18:24:56 -06:00
|
|
|
struct videobuf_buffer *vb;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&pcdev->lock, flags);
|
|
|
|
|
2008-04-22 07:36:32 -06:00
|
|
|
status = DCSR(channel);
|
2009-03-31 00:44:21 -06: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-14 23:57:48 -06:00
|
|
|
|
2008-04-06 18:24:56 -06:00
|
|
|
if (status & DCSR_BUSERR) {
|
2009-08-25 08:43:33 -06:00
|
|
|
dev_err(dev, "DMA Bus Error IRQ!\n");
|
2008-04-06 18:24:56 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-03-31 00:44:21 -06:00
|
|
|
if (!(status & (DCSR_ENDINTR | DCSR_STARTINTR))) {
|
2009-08-25 08:43:33 -06:00
|
|
|
dev_err(dev, "Unknown DMA IRQ source, status: 0x%08x\n",
|
|
|
|
status);
|
2008-04-06 18:24:56 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-03-31 00:44:22 -06: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-06 18:24:56 -06: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 08:43:33 -06:00
|
|
|
dev_dbg(dev, "%s channel=%d %s%s(vb=0x%p) dma.desc=%x\n",
|
2009-03-31 00:44:21 -06:00
|
|
|
__func__, channel, status & DCSR_STARTINTR ? "SOF " : "",
|
|
|
|
status & DCSR_ENDINTR ? "EOF " : "", vb, DDADR(channel));
|
|
|
|
|
|
|
|
if (status & DCSR_ENDINTR) {
|
2009-03-31 00:44:22 -06: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 08:43:33 -06:00
|
|
|
dev_dbg(dev, "FIFO overrun! CISR: %x\n",
|
2009-03-31 00:44:21 -06: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-06 18:24:56 -06:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&pcdev->lock, flags);
|
|
|
|
}
|
|
|
|
|
2008-04-22 07:36:32 -06: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-14 23:57:48 -06:00
|
|
|
static struct videobuf_queue_ops pxa_videobuf_ops = {
|
2008-04-06 18:24:56 -06:00
|
|
|
.buf_setup = pxa_videobuf_setup,
|
|
|
|
.buf_prepare = pxa_videobuf_prepare,
|
|
|
|
.buf_queue = pxa_videobuf_queue,
|
|
|
|
.buf_release = pxa_videobuf_release,
|
|
|
|
};
|
|
|
|
|
2008-07-11 17:59:34 -06:00
|
|
|
static void pxa_camera_init_videobuf(struct videobuf_queue *q,
|
2008-07-11 17:50:31 -06:00
|
|
|
struct soc_camera_device *icd)
|
|
|
|
{
|
2011-07-15 17:03:38 -06:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
|
2008-07-11 17:59:34 -06:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
|
2009-12-11 07:15:05 -07:00
|
|
|
/*
|
|
|
|
* We must pass NULL as dev pointer, then all pci_* dma operations
|
|
|
|
* transform to normal dma_* ones.
|
|
|
|
*/
|
2008-07-11 17:59:34 -06:00
|
|
|
videobuf_queue_sg_init(q, &pxa_videobuf_ops, NULL, &pcdev->lock,
|
2008-07-11 17:50:31 -06:00
|
|
|
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
|
2013-01-30 05:25:25 -07:00
|
|
|
sizeof(struct pxa_buffer), icd, &ici->host_lock);
|
2008-07-11 17:50:31 -06:00
|
|
|
}
|
|
|
|
|
2009-08-25 08:28:22 -06:00
|
|
|
static u32 mclk_get_divisor(struct platform_device *pdev,
|
|
|
|
struct pxa_camera_dev *pcdev)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
2008-12-18 07:38:03 -07:00
|
|
|
unsigned long mclk = pcdev->mclk;
|
2009-08-25 08:50:46 -06:00
|
|
|
struct device *dev = &pdev->dev;
|
2008-12-18 07:38:03 -07:00
|
|
|
u32 div;
|
2008-04-06 18:24:56 -06:00
|
|
|
unsigned long lcdclk;
|
|
|
|
|
2008-12-18 07:38:03 -07:00
|
|
|
lcdclk = clk_get_rate(pcdev->clk);
|
|
|
|
pcdev->ciclk = lcdclk;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2008-12-18 07:38:03 -07:00
|
|
|
/* mclk <= ciclk / 4 (27.4.2) */
|
|
|
|
if (mclk > lcdclk / 4) {
|
|
|
|
mclk = lcdclk / 4;
|
2009-08-25 08:43:33 -06:00
|
|
|
dev_warn(dev, "Limiting master clock to %lu\n", mclk);
|
2008-12-18 07:38:03 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* We verify mclk != 0, so if anyone breaks it, here comes their Oops */
|
|
|
|
div = (lcdclk + 2 * mclk - 1) / (2 * mclk) - 1;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2008-12-18 07:38:03 -07: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-06 18:24:56 -06:00
|
|
|
|
2009-08-25 08:43:33 -06:00
|
|
|
dev_dbg(dev, "LCD clock %luHz, target freq %luHz, divisor %u\n",
|
2009-08-25 08:28:22 -06:00
|
|
|
lcdclk, mclk, div);
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
return div;
|
|
|
|
}
|
|
|
|
|
2008-12-18 07:38:03 -07: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-14 23:57:48 -06:00
|
|
|
static void pxa_camera_activate(struct pxa_camera_dev *pcdev)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
|
|
|
u32 cicr4 = 0;
|
|
|
|
|
2008-12-18 07:15:50 -07:00
|
|
|
/* disable all interrupts */
|
|
|
|
__raw_writel(0x3ff, pcdev->base + CICR0);
|
2008-04-06 18:24:56 -06: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 07:38:03 -07: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-06 18:24:56 -06:00
|
|
|
|
2012-03-15 12:13:31 -06:00
|
|
|
clk_prepare_enable(pcdev->clk);
|
2008-04-06 18:24:56 -06:00
|
|
|
}
|
|
|
|
|
2008-04-14 23:57:48 -06:00
|
|
|
static void pxa_camera_deactivate(struct pxa_camera_dev *pcdev)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
2012-03-15 12:13:31 -06:00
|
|
|
clk_disable_unprepare(pcdev->clk);
|
2008-04-06 18:24:56 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t pxa_camera_irq(int irq, void *data)
|
|
|
|
{
|
|
|
|
struct pxa_camera_dev *pcdev = data;
|
2010-04-20 00:51:29 -06:00
|
|
|
unsigned long status, cifr, cicr0;
|
2009-03-31 00:44:21 -06:00
|
|
|
struct pxa_buffer *buf;
|
|
|
|
struct videobuf_buffer *vb;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2008-12-18 07:15:50 -07:00
|
|
|
status = __raw_readl(pcdev->base + CISR);
|
2009-08-25 08:47:00 -06:00
|
|
|
dev_dbg(pcdev->soc_host.v4l2_dev.dev,
|
|
|
|
"Camera interrupt status 0x%lx\n", status);
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2008-04-22 07:37:49 -06:00
|
|
|
if (!status)
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
2008-12-18 07:15:50 -07:00
|
|
|
__raw_writel(status, pcdev->base + CISR);
|
2008-04-22 07:37:49 -06:00
|
|
|
|
|
|
|
if (status & CISR_EOF) {
|
2010-04-20 00:51:29 -06:00
|
|
|
/* Reset the FIFOs */
|
|
|
|
cifr = __raw_readl(pcdev->base + CIFR) | CIFR_RESET_F;
|
|
|
|
__raw_writel(cifr, pcdev->base + CIFR);
|
|
|
|
|
2009-03-31 00:44:21 -06: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 07:15:50 -07:00
|
|
|
cicr0 = __raw_readl(pcdev->base + CICR0) | CICR0_EOFM;
|
|
|
|
__raw_writel(cicr0, pcdev->base + CICR0);
|
2008-04-22 07:37:49 -06:00
|
|
|
}
|
|
|
|
|
2008-04-06 18:24:56 -06:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2008-12-18 08:28:54 -07:00
|
|
|
/*
|
|
|
|
* The following two functions absolutely depend on the fact, that
|
|
|
|
* there can be only one camera on PXA quick capture interface
|
2012-12-24 05:31:33 -07:00
|
|
|
* Called with .host_lock held
|
2008-12-18 08:28:54 -07:00
|
|
|
*/
|
2008-04-14 23:57:48 -06:00
|
|
|
static int pxa_camera_add_device(struct soc_camera_device *icd)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
2011-07-15 17:03:38 -06:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
|
2008-04-06 18:24:56 -06:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
|
2009-08-25 08:43:33 -06:00
|
|
|
if (pcdev->icd)
|
|
|
|
return -EBUSY;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2008-04-14 23:57:48 -06:00
|
|
|
pxa_camera_activate(pcdev);
|
2009-08-25 08:28:22 -06:00
|
|
|
|
|
|
|
pcdev->icd = icd;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2011-07-15 17:03:38 -06:00
|
|
|
dev_info(icd->parent, "PXA Camera driver attached to camera %d\n",
|
2009-08-25 08:28:22 -06:00
|
|
|
icd->devnum);
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2009-08-25 08:28:22 -06:00
|
|
|
return 0;
|
2008-04-06 18:24:56 -06:00
|
|
|
}
|
|
|
|
|
2012-12-24 05:31:33 -07:00
|
|
|
/* Called with .host_lock held */
|
2008-04-14 23:57:48 -06:00
|
|
|
static void pxa_camera_remove_device(struct soc_camera_device *icd)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
2011-07-15 17:03:38 -06:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
|
2008-04-06 18:24:56 -06:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
|
|
|
|
BUG_ON(icd != pcdev->icd);
|
|
|
|
|
2011-07-15 17:03:38 -06:00
|
|
|
dev_info(icd->parent, "PXA Camera driver detached from camera %d\n",
|
2008-04-06 18:24:56 -06:00
|
|
|
icd->devnum);
|
|
|
|
|
|
|
|
/* disable capture, disable interrupts */
|
2008-12-18 07:15:50 -07:00
|
|
|
__raw_writel(0x3ff, pcdev->base + CICR0);
|
2008-04-22 07:36:32 -06:00
|
|
|
|
2008-04-06 18:24:56 -06:00
|
|
|
/* Stop DMA engine */
|
2008-04-22 07:36:32 -06:00
|
|
|
DCSR(pcdev->dma_chans[0]) = 0;
|
|
|
|
DCSR(pcdev->dma_chans[1]) = 0;
|
|
|
|
DCSR(pcdev->dma_chans[2]) = 0;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2008-04-14 23:57:48 -06:00
|
|
|
pxa_camera_deactivate(pcdev);
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
pcdev->icd = NULL;
|
|
|
|
}
|
|
|
|
|
2008-03-07 17:57:18 -07:00
|
|
|
static int test_platform_param(struct pxa_camera_dev *pcdev,
|
|
|
|
unsigned char buswidth, unsigned long *flags)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
2008-03-07 17:57:18 -07: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 ?
|
2011-07-27 13:37:45 -06:00
|
|
|
V4L2_MBUS_MASTER : V4L2_MBUS_SLAVE) |
|
|
|
|
V4L2_MBUS_HSYNC_ACTIVE_HIGH |
|
|
|
|
V4L2_MBUS_HSYNC_ACTIVE_LOW |
|
|
|
|
V4L2_MBUS_VSYNC_ACTIVE_HIGH |
|
|
|
|
V4L2_MBUS_VSYNC_ACTIVE_LOW |
|
|
|
|
V4L2_MBUS_DATA_ACTIVE_HIGH |
|
|
|
|
V4L2_MBUS_PCLK_SAMPLE_RISING |
|
|
|
|
V4L2_MBUS_PCLK_SAMPLE_FALLING;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
/* If requested data width is supported by the platform, use it */
|
2011-07-27 13:37:45 -06:00
|
|
|
if ((1 << (buswidth - 1)) & pcdev->width_flags)
|
|
|
|
return 0;
|
2008-03-07 17:57:18 -07:00
|
|
|
|
2011-07-27 13:37:45 -06:00
|
|
|
return -EINVAL;
|
2008-03-07 17:57:18 -07:00
|
|
|
}
|
|
|
|
|
2009-08-25 08:50:46 -06:00
|
|
|
static void pxa_camera_setup_cicr(struct soc_camera_device *icd,
|
|
|
|
unsigned long flags, __u32 pixfmt)
|
2008-03-07 17:57:18 -07:00
|
|
|
{
|
2011-07-15 17:03:38 -06:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
|
2008-03-07 17:57:18 -07:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
2009-12-11 07:14:46 -07:00
|
|
|
struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
|
2009-08-25 08:50:46 -06:00
|
|
|
unsigned long dw, bpp;
|
2009-12-11 07:14:46 -07:00
|
|
|
u32 cicr0, cicr1, cicr2, cicr3, cicr4 = 0, y_skip_top;
|
|
|
|
int ret = v4l2_subdev_call(sd, sensor, g_skip_top_lines, &y_skip_top);
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
y_skip_top = 0;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2009-12-11 07:15:05 -07:00
|
|
|
/*
|
|
|
|
* Datawidth is now guaranteed to be equal to one of the three values.
|
|
|
|
* We fix bit-per-pixel equal to data-width...
|
|
|
|
*/
|
2011-07-27 13:37:45 -06:00
|
|
|
switch (icd->current_fmt->host_fmt->bits_per_sample) {
|
|
|
|
case 10:
|
2008-04-06 18:24:56 -06:00
|
|
|
dw = 4;
|
|
|
|
bpp = 0x40;
|
|
|
|
break;
|
2011-07-27 13:37:45 -06:00
|
|
|
case 9:
|
2008-04-06 18:24:56 -06:00
|
|
|
dw = 3;
|
|
|
|
bpp = 0x20;
|
|
|
|
break;
|
|
|
|
default:
|
2009-12-11 07:15:05 -07:00
|
|
|
/*
|
|
|
|
* Actually it can only be 8 now,
|
|
|
|
* default is just to silence compiler warnings
|
|
|
|
*/
|
2011-07-27 13:37:45 -06:00
|
|
|
case 8:
|
2008-04-06 18:24:56 -06: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;
|
2011-07-27 13:37:45 -06:00
|
|
|
if (flags & V4L2_MBUS_PCLK_SAMPLE_FALLING)
|
2008-04-06 18:24:56 -06:00
|
|
|
cicr4 |= CICR4_PCP;
|
2011-07-27 13:37:45 -06:00
|
|
|
if (flags & V4L2_MBUS_HSYNC_ACTIVE_LOW)
|
2008-04-06 18:24:56 -06:00
|
|
|
cicr4 |= CICR4_HSP;
|
2011-07-27 13:37:45 -06:00
|
|
|
if (flags & V4L2_MBUS_VSYNC_ACTIVE_LOW)
|
2008-04-06 18:24:56 -06:00
|
|
|
cicr4 |= CICR4_VSP;
|
|
|
|
|
2008-12-18 07:15:50 -07:00
|
|
|
cicr0 = __raw_readl(pcdev->base + CICR0);
|
2008-04-06 18:24:56 -06:00
|
|
|
if (cicr0 & CICR0_ENB)
|
2008-12-18 07:15:50 -07:00
|
|
|
__raw_writel(cicr0 & ~CICR0_ENB, pcdev->base + CICR0);
|
2008-04-22 07:36:32 -06:00
|
|
|
|
2009-08-25 08:50:46 -06:00
|
|
|
cicr1 = CICR1_PPL_VAL(icd->user_width - 1) | bpp | dw;
|
2008-04-22 07:36:32 -06:00
|
|
|
|
|
|
|
switch (pixfmt) {
|
|
|
|
case V4L2_PIX_FMT_YUV422P:
|
2008-04-22 07:37:49 -06:00
|
|
|
pcdev->channels = 3;
|
2008-04-22 07:36:32 -06:00
|
|
|
cicr1 |= CICR1_YCBCR_F;
|
2008-12-01 05:45:35 -07: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 07:36:32 -06:00
|
|
|
case V4L2_PIX_FMT_YUYV:
|
2008-12-01 05:45:35 -07:00
|
|
|
case V4L2_PIX_FMT_YVYU:
|
2008-04-22 07:36:32 -06: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 07:15:50 -07:00
|
|
|
cicr2 = 0;
|
2009-08-25 08:50:46 -06:00
|
|
|
cicr3 = CICR3_LPF_VAL(icd->user_height - 1) |
|
2009-12-11 07:14:46 -07:00
|
|
|
CICR3_BFW_VAL(min((u32)255, y_skip_top));
|
2008-12-18 07:38:03 -07:00
|
|
|
cicr4 |= pcdev->mclk_divisor;
|
2008-12-18 07:15:50 -07: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-06 18:24:56 -06:00
|
|
|
|
|
|
|
/* CIF interrupts are not used, only DMA */
|
2008-12-18 07:15:50 -07: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 08:50:46 -06:00
|
|
|
}
|
|
|
|
|
2011-09-21 14:52:51 -06:00
|
|
|
static int pxa_camera_set_bus_param(struct soc_camera_device *icd)
|
2009-08-25 08:50:46 -06:00
|
|
|
{
|
2011-07-27 13:37:45 -06:00
|
|
|
struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
|
2011-07-15 17:03:38 -06:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
|
2009-08-25 08:50:46 -06:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
2011-07-27 13:37:45 -06:00
|
|
|
struct v4l2_mbus_config cfg = {.type = V4L2_MBUS_PARALLEL,};
|
2011-09-21 14:52:51 -06:00
|
|
|
u32 pixfmt = icd->current_fmt->host_fmt->fourcc;
|
2011-07-27 13:37:45 -06:00
|
|
|
unsigned long bus_flags, common_flags;
|
2009-12-11 07:46:49 -07:00
|
|
|
int ret;
|
2009-08-25 08:50:46 -06:00
|
|
|
struct pxa_cam *cam = icd->host_priv;
|
|
|
|
|
2011-05-18 03:49:54 -06:00
|
|
|
ret = test_platform_param(pcdev, icd->current_fmt->host_fmt->bits_per_sample,
|
|
|
|
&bus_flags);
|
2009-08-25 08:50:46 -06:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2011-07-27 13:37:45 -06:00
|
|
|
ret = v4l2_subdev_call(sd, video, g_mbus_config, &cfg);
|
|
|
|
if (!ret) {
|
|
|
|
common_flags = soc_mbus_config_compatible(&cfg,
|
|
|
|
bus_flags);
|
|
|
|
if (!common_flags) {
|
|
|
|
dev_warn(icd->parent,
|
|
|
|
"Flags incompatible: camera 0x%x, host 0x%lx\n",
|
|
|
|
cfg.flags, bus_flags);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
} else if (ret != -ENOIOCTLCMD) {
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
common_flags = bus_flags;
|
|
|
|
}
|
2009-08-25 08:50:46 -06:00
|
|
|
|
|
|
|
pcdev->channels = 1;
|
|
|
|
|
|
|
|
/* Make choises, based on platform preferences */
|
2011-07-27 13:37:45 -06:00
|
|
|
if ((common_flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH) &&
|
|
|
|
(common_flags & V4L2_MBUS_HSYNC_ACTIVE_LOW)) {
|
2009-08-25 08:50:46 -06:00
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_HSP)
|
2011-07-27 13:37:45 -06:00
|
|
|
common_flags &= ~V4L2_MBUS_HSYNC_ACTIVE_HIGH;
|
2009-08-25 08:50:46 -06:00
|
|
|
else
|
2011-07-27 13:37:45 -06:00
|
|
|
common_flags &= ~V4L2_MBUS_HSYNC_ACTIVE_LOW;
|
2009-08-25 08:50:46 -06:00
|
|
|
}
|
|
|
|
|
2011-07-27 13:37:45 -06:00
|
|
|
if ((common_flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH) &&
|
|
|
|
(common_flags & V4L2_MBUS_VSYNC_ACTIVE_LOW)) {
|
2009-08-25 08:50:46 -06:00
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_VSP)
|
2011-07-27 13:37:45 -06:00
|
|
|
common_flags &= ~V4L2_MBUS_VSYNC_ACTIVE_HIGH;
|
2009-08-25 08:50:46 -06:00
|
|
|
else
|
2011-07-27 13:37:45 -06:00
|
|
|
common_flags &= ~V4L2_MBUS_VSYNC_ACTIVE_LOW;
|
2009-08-25 08:50:46 -06:00
|
|
|
}
|
|
|
|
|
2011-07-27 13:37:45 -06:00
|
|
|
if ((common_flags & V4L2_MBUS_PCLK_SAMPLE_RISING) &&
|
|
|
|
(common_flags & V4L2_MBUS_PCLK_SAMPLE_FALLING)) {
|
2009-08-25 08:50:46 -06:00
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_PCP)
|
2011-07-27 13:37:45 -06:00
|
|
|
common_flags &= ~V4L2_MBUS_PCLK_SAMPLE_RISING;
|
2009-08-25 08:50:46 -06:00
|
|
|
else
|
2011-07-27 13:37:45 -06:00
|
|
|
common_flags &= ~V4L2_MBUS_PCLK_SAMPLE_FALLING;
|
2009-08-25 08:50:46 -06:00
|
|
|
}
|
|
|
|
|
2011-07-27 13:37:45 -06:00
|
|
|
cfg.flags = common_flags;
|
|
|
|
ret = v4l2_subdev_call(sd, video, s_mbus_config, &cfg);
|
|
|
|
if (ret < 0 && ret != -ENOIOCTLCMD) {
|
|
|
|
dev_dbg(icd->parent, "camera s_mbus_config(0x%lx) returned %d\n",
|
|
|
|
common_flags, ret);
|
2009-08-25 08:50:46 -06:00
|
|
|
return ret;
|
2011-07-27 13:37:45 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
cam->flags = common_flags;
|
2009-08-25 08:50:46 -06:00
|
|
|
|
|
|
|
pxa_camera_setup_cicr(icd, common_flags, pixfmt);
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-01 05:45:35 -07:00
|
|
|
static int pxa_camera_try_bus_param(struct soc_camera_device *icd,
|
|
|
|
unsigned char buswidth)
|
2008-03-07 17:57:18 -07:00
|
|
|
{
|
2011-07-27 13:37:45 -06:00
|
|
|
struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
|
2011-07-15 17:03:38 -06:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
|
2008-03-07 17:57:18 -07:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
2011-07-27 13:37:45 -06:00
|
|
|
struct v4l2_mbus_config cfg = {.type = V4L2_MBUS_PARALLEL,};
|
|
|
|
unsigned long bus_flags, common_flags;
|
2008-12-01 05:45:35 -07:00
|
|
|
int ret = test_platform_param(pcdev, buswidth, &bus_flags);
|
2008-03-07 17:57:18 -07:00
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2011-07-27 13:37:45 -06:00
|
|
|
ret = v4l2_subdev_call(sd, video, g_mbus_config, &cfg);
|
|
|
|
if (!ret) {
|
|
|
|
common_flags = soc_mbus_config_compatible(&cfg,
|
|
|
|
bus_flags);
|
|
|
|
if (!common_flags) {
|
|
|
|
dev_warn(icd->parent,
|
|
|
|
"Flags incompatible: camera 0x%x, host 0x%lx\n",
|
|
|
|
cfg.flags, bus_flags);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
} else if (ret == -ENOIOCTLCMD) {
|
|
|
|
ret = 0;
|
|
|
|
}
|
2008-03-07 17:57:18 -07:00
|
|
|
|
2011-07-27 13:37:45 -06:00
|
|
|
return ret;
|
2008-03-07 17:57:18 -07:00
|
|
|
}
|
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
static const struct soc_mbus_pixelfmt pxa_camera_formats[] = {
|
2008-12-01 05:45:35 -07:00
|
|
|
{
|
2009-12-11 07:46:49 -07:00
|
|
|
.fourcc = V4L2_PIX_FMT_YUV422P,
|
|
|
|
.name = "Planar YUV422 16 bit",
|
|
|
|
.bits_per_sample = 8,
|
|
|
|
.packing = SOC_MBUS_PACKING_2X8_PADHI,
|
|
|
|
.order = SOC_MBUS_ORDER_LE,
|
2012-03-21 05:03:23 -06:00
|
|
|
.layout = SOC_MBUS_LAYOUT_PLANAR_2Y_U_V,
|
2008-12-01 05:45:35 -07:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
/* This will be corrected as we get more formats */
|
|
|
|
static bool pxa_camera_packing_supported(const struct soc_mbus_pixelfmt *fmt)
|
2008-03-07 17:57:18 -07:00
|
|
|
{
|
2009-12-11 07:46:49 -07:00
|
|
|
return fmt->packing == SOC_MBUS_PACKING_NONE ||
|
|
|
|
(fmt->bits_per_sample == 8 &&
|
|
|
|
fmt->packing == SOC_MBUS_PACKING_2X8_PADHI) ||
|
|
|
|
(fmt->bits_per_sample > 8 &&
|
|
|
|
fmt->packing == SOC_MBUS_PACKING_EXTEND16);
|
2008-12-01 05:45:35 -07:00
|
|
|
}
|
|
|
|
|
2010-05-08 14:55:00 -06:00
|
|
|
static int pxa_camera_get_formats(struct soc_camera_device *icd, unsigned int idx,
|
2008-12-01 05:45:35 -07:00
|
|
|
struct soc_camera_format_xlate *xlate)
|
|
|
|
{
|
2009-12-11 07:46:49 -07:00
|
|
|
struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
|
2011-07-15 17:03:38 -06:00
|
|
|
struct device *dev = icd->parent;
|
2009-12-11 07:46:49 -07:00
|
|
|
int formats = 0, ret;
|
2009-08-25 08:50:46 -06:00
|
|
|
struct pxa_cam *cam;
|
2009-12-11 07:46:49 -07:00
|
|
|
enum v4l2_mbus_pixelcode code;
|
|
|
|
const struct soc_mbus_pixelfmt *fmt;
|
2008-12-01 05:45:35 -07:00
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
ret = v4l2_subdev_call(sd, video, enum_mbus_fmt, idx, &code);
|
|
|
|
if (ret < 0)
|
|
|
|
/* No more formats */
|
|
|
|
return 0;
|
2008-12-01 05:45:35 -07:00
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
fmt = soc_mbus_get_fmtdesc(code);
|
|
|
|
if (!fmt) {
|
2010-05-08 14:55:00 -06:00
|
|
|
dev_err(dev, "Invalid format code #%u: %d\n", idx, code);
|
2008-12-01 05:45:35 -07:00
|
|
|
return 0;
|
2009-12-11 07:46:49 -07:00
|
|
|
}
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
/* This also checks support for the requested bits-per-sample */
|
|
|
|
ret = pxa_camera_try_bus_param(icd, fmt->bits_per_sample);
|
2008-12-01 05:45:35 -07:00
|
|
|
if (ret < 0)
|
|
|
|
return 0;
|
|
|
|
|
2009-08-25 08:50:46 -06:00
|
|
|
if (!icd->host_priv) {
|
|
|
|
cam = kzalloc(sizeof(*cam), GFP_KERNEL);
|
|
|
|
if (!cam)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
icd->host_priv = cam;
|
|
|
|
} else {
|
|
|
|
cam = icd->host_priv;
|
|
|
|
}
|
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
switch (code) {
|
2010-07-22 13:52:51 -06:00
|
|
|
case V4L2_MBUS_FMT_UYVY8_2X8:
|
2008-12-01 05:45:35 -07:00
|
|
|
formats++;
|
|
|
|
if (xlate) {
|
2009-12-11 07:46:49 -07:00
|
|
|
xlate->host_fmt = &pxa_camera_formats[0];
|
|
|
|
xlate->code = code;
|
2008-12-01 05:45:35 -07:00
|
|
|
xlate++;
|
2009-12-11 07:46:49 -07:00
|
|
|
dev_dbg(dev, "Providing format %s using code %d\n",
|
|
|
|
pxa_camera_formats[0].name, code);
|
2008-12-01 05:45:35 -07:00
|
|
|
}
|
2010-07-22 13:52:51 -06:00
|
|
|
case V4L2_MBUS_FMT_VYUY8_2X8:
|
|
|
|
case V4L2_MBUS_FMT_YUYV8_2X8:
|
|
|
|
case V4L2_MBUS_FMT_YVYU8_2X8:
|
2009-12-11 07:46:49 -07:00
|
|
|
case V4L2_MBUS_FMT_RGB565_2X8_LE:
|
|
|
|
case V4L2_MBUS_FMT_RGB555_2X8_PADHI_LE:
|
|
|
|
if (xlate)
|
2009-08-25 08:47:00 -06:00
|
|
|
dev_dbg(dev, "Providing format %s packed\n",
|
2009-12-11 07:46:49 -07:00
|
|
|
fmt->name);
|
2008-12-01 05:45:35 -07:00
|
|
|
break;
|
|
|
|
default:
|
2009-12-11 07:46:49 -07:00
|
|
|
if (!pxa_camera_packing_supported(fmt))
|
|
|
|
return 0;
|
|
|
|
if (xlate)
|
2009-08-25 08:47:00 -06:00
|
|
|
dev_dbg(dev,
|
2008-12-01 05:45:35 -07:00
|
|
|
"Providing format %s in pass-through mode\n",
|
2009-12-11 07:46:49 -07:00
|
|
|
fmt->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Generic pass-through */
|
|
|
|
formats++;
|
|
|
|
if (xlate) {
|
|
|
|
xlate->host_fmt = fmt;
|
|
|
|
xlate->code = code;
|
|
|
|
xlate++;
|
2008-12-01 05:45:35 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return formats;
|
|
|
|
}
|
|
|
|
|
2009-08-25 08:50:46 -06:00
|
|
|
static void pxa_camera_put_formats(struct soc_camera_device *icd)
|
|
|
|
{
|
|
|
|
kfree(icd->host_priv);
|
|
|
|
icd->host_priv = NULL;
|
|
|
|
}
|
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
static int pxa_camera_check_frame(u32 width, u32 height)
|
2009-08-25 08:50:46 -06:00
|
|
|
{
|
|
|
|
/* limit to pxa hardware capabilities */
|
2009-12-11 07:46:49 -07:00
|
|
|
return height < 32 || height > 2048 || width < 48 || width > 2048 ||
|
|
|
|
(width & 0x01);
|
2009-08-25 08:50:46 -06:00
|
|
|
}
|
|
|
|
|
2009-03-13 03:08:20 -06:00
|
|
|
static int pxa_camera_set_crop(struct soc_camera_device *icd,
|
2012-09-28 04:27:30 -06:00
|
|
|
const struct v4l2_crop *a)
|
2009-03-13 03:08:20 -06:00
|
|
|
{
|
2012-09-28 04:27:30 -06:00
|
|
|
const struct v4l2_rect *rect = &a->c;
|
2011-07-15 17:03:38 -06:00
|
|
|
struct device *dev = icd->parent;
|
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(dev);
|
2009-03-13 03:08:20 -06:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
2009-08-25 08:46:59 -06:00
|
|
|
struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
|
2009-03-13 03:08:20 -06:00
|
|
|
struct soc_camera_sense sense = {
|
|
|
|
.master_clock = pcdev->mclk,
|
|
|
|
.pixel_clock_max = pcdev->ciclk / 4,
|
|
|
|
};
|
2009-12-11 07:46:49 -07:00
|
|
|
struct v4l2_mbus_framefmt mf;
|
2009-08-25 08:50:46 -06:00
|
|
|
struct pxa_cam *cam = icd->host_priv;
|
2009-12-11 07:46:49 -07:00
|
|
|
u32 fourcc = icd->current_fmt->host_fmt->fourcc;
|
2009-03-13 03:08:20 -06: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 08:46:54 -06:00
|
|
|
ret = v4l2_subdev_call(sd, video, s_crop, a);
|
2009-03-13 03:08:20 -06:00
|
|
|
|
|
|
|
icd->sense = NULL;
|
|
|
|
|
|
|
|
if (ret < 0) {
|
2009-08-25 08:47:00 -06:00
|
|
|
dev_warn(dev, "Failed to crop to %ux%u@%u:%u\n",
|
2009-03-13 03:08:20 -06:00
|
|
|
rect->width, rect->height, rect->left, rect->top);
|
2009-08-25 08:50:46 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
ret = v4l2_subdev_call(sd, video, g_mbus_fmt, &mf);
|
2009-08-25 08:50:46 -06:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
if (pxa_camera_check_frame(mf.width, mf.height)) {
|
2009-08-25 08:50:46 -06:00
|
|
|
/*
|
|
|
|
* Camera cropping produced a frame beyond our capabilities.
|
|
|
|
* FIXME: just extract a subframe, that we can process.
|
|
|
|
*/
|
2009-12-11 07:46:49 -07:00
|
|
|
v4l_bound_align_image(&mf.width, 48, 2048, 1,
|
|
|
|
&mf.height, 32, 2048, 0,
|
|
|
|
fourcc == V4L2_PIX_FMT_YUV422P ? 4 : 0);
|
|
|
|
ret = v4l2_subdev_call(sd, video, s_mbus_fmt, &mf);
|
2009-08-25 08:50:46 -06:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
if (pxa_camera_check_frame(mf.width, mf.height)) {
|
2011-07-15 17:03:38 -06:00
|
|
|
dev_warn(icd->parent,
|
2009-08-25 08:50:46 -06:00
|
|
|
"Inconsistent state. Use S_FMT to repair\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sense.flags & SOCAM_SENSE_PCLK_CHANGED) {
|
2009-03-13 03:08:20 -06:00
|
|
|
if (sense.pixel_clock > sense.pixel_clock_max) {
|
2009-08-25 08:47:00 -06:00
|
|
|
dev_err(dev,
|
2009-03-13 03:08:20 -06:00
|
|
|
"pixel clock %lu set by the camera too high!",
|
|
|
|
sense.pixel_clock);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
recalculate_fifo_timeout(pcdev, sense.pixel_clock);
|
|
|
|
}
|
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
icd->user_width = mf.width;
|
|
|
|
icd->user_height = mf.height;
|
2009-08-25 08:50:46 -06:00
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
pxa_camera_setup_cicr(icd, cam->flags, fourcc);
|
2009-08-25 08:50:46 -06:00
|
|
|
|
2009-03-13 03:08:20 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-12-01 05:45:21 -07:00
|
|
|
static int pxa_camera_set_fmt(struct soc_camera_device *icd,
|
2009-03-13 03:08:20 -06:00
|
|
|
struct v4l2_format *f)
|
2008-03-07 17:57:18 -07:00
|
|
|
{
|
2011-07-15 17:03:38 -06:00
|
|
|
struct device *dev = icd->parent;
|
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(dev);
|
2008-12-18 07:38:03 -07:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
2009-08-25 08:46:59 -06:00
|
|
|
struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
|
2009-02-23 08:11:25 -07:00
|
|
|
const struct soc_camera_format_xlate *xlate = NULL;
|
2008-12-18 07:38:03 -07:00
|
|
|
struct soc_camera_sense sense = {
|
|
|
|
.master_clock = pcdev->mclk,
|
|
|
|
.pixel_clock_max = pcdev->ciclk / 4,
|
|
|
|
};
|
2009-03-13 03:08:20 -06:00
|
|
|
struct v4l2_pix_format *pix = &f->fmt.pix;
|
2009-12-11 07:46:49 -07:00
|
|
|
struct v4l2_mbus_framefmt mf;
|
2009-02-23 08:11:25 -07:00
|
|
|
int ret;
|
2008-12-01 05:44:59 -07:00
|
|
|
|
2009-03-13 03:08:20 -06:00
|
|
|
xlate = soc_camera_xlate_by_fourcc(icd, pix->pixelformat);
|
|
|
|
if (!xlate) {
|
2009-08-25 08:47:00 -06:00
|
|
|
dev_warn(dev, "Format %x not found\n", pix->pixelformat);
|
2009-03-13 03:08:20 -06:00
|
|
|
return -EINVAL;
|
2009-02-23 08:11:25 -07:00
|
|
|
}
|
2008-12-01 05:45:35 -07:00
|
|
|
|
2008-12-18 07:38:03 -07:00
|
|
|
/* If PCLK is used to latch data from the sensor, check sense */
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_PCLK_EN)
|
2009-12-11 07:46:49 -07:00
|
|
|
/* The caller holds a mutex. */
|
2008-12-18 07:38:03 -07:00
|
|
|
icd->sense = &sense;
|
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
mf.width = pix->width;
|
|
|
|
mf.height = pix->height;
|
|
|
|
mf.field = pix->field;
|
|
|
|
mf.colorspace = pix->colorspace;
|
|
|
|
mf.code = xlate->code;
|
|
|
|
|
|
|
|
ret = v4l2_subdev_call(sd, video, s_mbus_fmt, &mf);
|
|
|
|
|
|
|
|
if (mf.code != xlate->code)
|
|
|
|
return -EINVAL;
|
2008-12-01 05:45:35 -07:00
|
|
|
|
2008-12-18 07:38:03 -07:00
|
|
|
icd->sense = NULL;
|
|
|
|
|
|
|
|
if (ret < 0) {
|
2009-08-25 08:47:00 -06:00
|
|
|
dev_warn(dev, "Failed to configure for format %x\n",
|
2009-03-13 03:08:20 -06:00
|
|
|
pix->pixelformat);
|
2009-12-11 07:46:49 -07:00
|
|
|
} else if (pxa_camera_check_frame(mf.width, mf.height)) {
|
2009-08-25 08:50:46 -06:00
|
|
|
dev_warn(dev,
|
|
|
|
"Camera driver produced an unsupported frame %dx%d\n",
|
2009-12-11 07:46:49 -07:00
|
|
|
mf.width, mf.height);
|
2009-08-25 08:50:46 -06:00
|
|
|
ret = -EINVAL;
|
2008-12-18 07:38:03 -07:00
|
|
|
} else if (sense.flags & SOCAM_SENSE_PCLK_CHANGED) {
|
|
|
|
if (sense.pixel_clock > sense.pixel_clock_max) {
|
2009-08-25 08:47:00 -06:00
|
|
|
dev_err(dev,
|
2008-12-18 07:38:03 -07: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 05:45:35 -07:00
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
pix->width = mf.width;
|
|
|
|
pix->height = mf.height;
|
|
|
|
pix->field = mf.field;
|
|
|
|
pix->colorspace = mf.colorspace;
|
|
|
|
icd->current_fmt = xlate;
|
2008-12-01 05:44:59 -07:00
|
|
|
|
|
|
|
return ret;
|
2008-03-07 17:57:18 -07:00
|
|
|
}
|
|
|
|
|
2008-12-01 05:45:21 -07:00
|
|
|
static int pxa_camera_try_fmt(struct soc_camera_device *icd,
|
|
|
|
struct v4l2_format *f)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
2009-08-25 08:46:59 -06:00
|
|
|
struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
|
2008-12-01 05:45:35 -07:00
|
|
|
const struct soc_camera_format_xlate *xlate;
|
|
|
|
struct v4l2_pix_format *pix = &f->fmt.pix;
|
2009-12-11 07:46:49 -07:00
|
|
|
struct v4l2_mbus_framefmt mf;
|
2008-12-01 05:45:35 -07:00
|
|
|
__u32 pixfmt = pix->pixelformat;
|
2008-12-18 07:53:51 -07:00
|
|
|
int ret;
|
2008-12-01 05:44:53 -07:00
|
|
|
|
2008-12-01 05:45:35 -07:00
|
|
|
xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
|
|
|
|
if (!xlate) {
|
2011-07-15 17:03:38 -06:00
|
|
|
dev_warn(icd->parent, "Format %x not found\n", pixfmt);
|
2008-12-01 05:44:59 -07:00
|
|
|
return -EINVAL;
|
2008-12-01 05:45:35 -07:00
|
|
|
}
|
2008-12-01 05:44:59 -07:00
|
|
|
|
2009-03-31 00:44:21 -06:00
|
|
|
/*
|
2009-05-30 18:45:46 -06: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 00:44:21 -06:00
|
|
|
*/
|
2009-05-30 18:45:46 -06:00
|
|
|
v4l_bound_align_image(&pix->width, 48, 2048, 1,
|
|
|
|
&pix->height, 32, 2048, 0,
|
2009-08-25 08:50:46 -06:00
|
|
|
pixfmt == V4L2_PIX_FMT_YUV422P ? 4 : 0);
|
2009-03-31 00:44:21 -06:00
|
|
|
|
2008-03-07 17:57:18 -07:00
|
|
|
/* limit to sensor capabilities */
|
2009-12-11 07:46:49 -07:00
|
|
|
mf.width = pix->width;
|
|
|
|
mf.height = pix->height;
|
2011-06-07 02:44:19 -06:00
|
|
|
/* Only progressive video supported so far */
|
|
|
|
mf.field = V4L2_FIELD_NONE;
|
2009-12-11 07:46:49 -07:00
|
|
|
mf.colorspace = pix->colorspace;
|
|
|
|
mf.code = xlate->code;
|
2008-12-18 07:53:51 -07:00
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
ret = v4l2_subdev_call(sd, video, try_mbus_fmt, &mf);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2008-12-18 08:52:08 -07:00
|
|
|
|
2009-12-11 07:46:49 -07:00
|
|
|
pix->width = mf.width;
|
|
|
|
pix->height = mf.height;
|
|
|
|
pix->colorspace = mf.colorspace;
|
|
|
|
|
|
|
|
switch (mf.field) {
|
|
|
|
case V4L2_FIELD_ANY:
|
|
|
|
case V4L2_FIELD_NONE:
|
|
|
|
pix->field = V4L2_FIELD_NONE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* TODO: support interlaced at least in pass-through mode */
|
2011-07-15 17:03:38 -06:00
|
|
|
dev_err(icd->parent, "Field type %d unsupported.\n",
|
2009-12-11 07:46:49 -07:00
|
|
|
mf.field);
|
2008-12-18 08:52:08 -07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-12-18 07:53:51 -07:00
|
|
|
return ret;
|
2008-04-06 18:24:56 -06:00
|
|
|
}
|
|
|
|
|
2010-08-17 11:29:51 -06:00
|
|
|
static int pxa_camera_reqbufs(struct soc_camera_device *icd,
|
2008-04-14 23:57:48 -06:00
|
|
|
struct v4l2_requestbuffers *p)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2009-12-11 07:15:05 -07:00
|
|
|
/*
|
|
|
|
* This is for locking debugging only. I removed spinlocks and now I
|
2008-04-06 18:24:56 -06:00
|
|
|
* 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
|
2009-12-11 07:15:05 -07:00
|
|
|
* it hadn't triggered
|
|
|
|
*/
|
2008-04-06 18:24:56 -06:00
|
|
|
for (i = 0; i < p->count; i++) {
|
2010-08-17 11:29:51 -06:00
|
|
|
struct pxa_buffer *buf = container_of(icd->vb_vidq.bufs[i],
|
2008-04-06 18:24:56 -06:00
|
|
|
struct pxa_buffer, vb);
|
|
|
|
buf->inwork = 0;
|
|
|
|
INIT_LIST_HEAD(&buf->vb.queue);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-14 23:57:48 -06:00
|
|
|
static unsigned int pxa_camera_poll(struct file *file, poll_table *pt)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
2010-08-17 11:29:51 -06:00
|
|
|
struct soc_camera_device *icd = file->private_data;
|
2008-04-06 18:24:56 -06:00
|
|
|
struct pxa_buffer *buf;
|
|
|
|
|
2010-08-17 11:29:51 -06:00
|
|
|
buf = list_entry(icd->vb_vidq.stream.next, struct pxa_buffer,
|
2008-04-06 18:24:56 -06:00
|
|
|
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-14 23:57:48 -06:00
|
|
|
static int pxa_camera_querycap(struct soc_camera_host *ici,
|
|
|
|
struct v4l2_capability *cap)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
|
|
|
/* cap->name is set by the firendly caller:-> */
|
|
|
|
strlcpy(cap->card, pxa_cam_driver_description, sizeof(cap->card));
|
|
|
|
cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-06-29 08:45:01 -06:00
|
|
|
static int pxa_camera_suspend(struct device *dev)
|
2008-08-02 04:10:04 -06:00
|
|
|
{
|
2011-06-29 08:45:01 -06:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(dev);
|
2008-08-02 04:10:04 -06:00
|
|
|
struct pxa_camera_dev *pcdev = ici->priv;
|
|
|
|
int i = 0, ret = 0;
|
|
|
|
|
2008-12-18 07:15:50 -07: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 04:10:04 -06:00
|
|
|
|
2011-06-07 02:50:15 -06:00
|
|
|
if (pcdev->icd) {
|
2011-06-29 08:45:01 -06:00
|
|
|
struct v4l2_subdev *sd = soc_camera_to_subdev(pcdev->icd);
|
2011-06-07 02:50:15 -06:00
|
|
|
ret = v4l2_subdev_call(sd, core, s_power, 0);
|
|
|
|
if (ret == -ENOIOCTLCMD)
|
|
|
|
ret = 0;
|
|
|
|
}
|
2008-08-02 04:10:04 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-06-29 08:45:01 -06:00
|
|
|
static int pxa_camera_resume(struct device *dev)
|
2008-08-02 04:10:04 -06:00
|
|
|
{
|
2011-06-29 08:45:01 -06:00
|
|
|
struct soc_camera_host *ici = to_soc_camera_host(dev);
|
2008-08-02 04:10:04 -06: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 01:26:43 -06: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 04:10:04 -06:00
|
|
|
|
2008-12-18 07:15:50 -07: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 04:10:04 -06:00
|
|
|
|
2011-06-07 02:50:15 -06:00
|
|
|
if (pcdev->icd) {
|
2011-06-29 08:45:01 -06:00
|
|
|
struct v4l2_subdev *sd = soc_camera_to_subdev(pcdev->icd);
|
2011-06-07 02:50:15 -06:00
|
|
|
ret = v4l2_subdev_call(sd, core, s_power, 1);
|
|
|
|
if (ret == -ENOIOCTLCMD)
|
|
|
|
ret = 0;
|
|
|
|
}
|
2008-08-02 04:10:04 -06:00
|
|
|
|
|
|
|
/* Restart frame capture if active buffer exists */
|
2009-03-31 00:44:21 -06:00
|
|
|
if (!ret && pcdev->active)
|
|
|
|
pxa_camera_start_capture(pcdev);
|
2008-08-02 04:10:04 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-04-04 10:41:25 -06: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,
|
2009-03-13 03:08:20 -06:00
|
|
|
.set_crop = pxa_camera_set_crop,
|
2008-12-01 05:45:35 -07:00
|
|
|
.get_formats = pxa_camera_get_formats,
|
2009-08-25 08:50:46 -06:00
|
|
|
.put_formats = pxa_camera_put_formats,
|
2008-12-01 05:45:21 -07:00
|
|
|
.set_fmt = pxa_camera_set_fmt,
|
|
|
|
.try_fmt = pxa_camera_try_fmt,
|
2008-07-11 17:50:31 -06:00
|
|
|
.init_videobuf = pxa_camera_init_videobuf,
|
2008-04-04 10:41:25 -06:00
|
|
|
.reqbufs = pxa_camera_reqbufs,
|
|
|
|
.poll = pxa_camera_poll,
|
|
|
|
.querycap = pxa_camera_querycap,
|
|
|
|
.set_bus_param = pxa_camera_set_bus_param,
|
|
|
|
};
|
|
|
|
|
2012-12-21 14:17:53 -07:00
|
|
|
static int pxa_camera_probe(struct platform_device *pdev)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
|
|
|
struct pxa_camera_dev *pcdev;
|
|
|
|
struct resource *res;
|
|
|
|
void __iomem *base;
|
2008-06-13 06:03:45 -06:00
|
|
|
int irq;
|
2008-04-06 18:24:56 -06:00
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
irq = platform_get_irq(pdev, 0);
|
2013-01-07 05:51:21 -07:00
|
|
|
if (!res || irq < 0)
|
|
|
|
return -ENODEV;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2013-01-07 05:51:21 -07:00
|
|
|
pcdev = devm_kzalloc(&pdev->dev, sizeof(*pcdev), GFP_KERNEL);
|
2008-04-06 18:24:56 -06:00
|
|
|
if (!pcdev) {
|
2008-04-14 23:57:48 -06:00
|
|
|
dev_err(&pdev->dev, "Could not allocate pcdev\n");
|
2013-01-07 05:51:21 -07:00
|
|
|
return -ENOMEM;
|
2008-04-06 18:24:56 -06:00
|
|
|
}
|
|
|
|
|
2013-01-07 05:51:21 -07:00
|
|
|
pcdev->clk = devm_clk_get(&pdev->dev, NULL);
|
|
|
|
if (IS_ERR(pcdev->clk))
|
|
|
|
return PTR_ERR(pcdev->clk);
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
pcdev->res = res;
|
|
|
|
|
|
|
|
pcdev->pdata = pdev->dev.platform_data;
|
|
|
|
pcdev->platform_flags = pcdev->pdata->flags;
|
2008-03-07 17:57:18 -07:00
|
|
|
if (!(pcdev->platform_flags & (PXA_CAMERA_DATAWIDTH_8 |
|
|
|
|
PXA_CAMERA_DATAWIDTH_9 | PXA_CAMERA_DATAWIDTH_10))) {
|
2009-12-11 07:15:05 -07:00
|
|
|
/*
|
|
|
|
* Platform hasn't set available data widths. This is bad.
|
|
|
|
* Warn and use a default.
|
|
|
|
*/
|
2008-04-06 18:24:56 -06:00
|
|
|
dev_warn(&pdev->dev, "WARNING! Platform hasn't set available "
|
|
|
|
"data widths, using default 10 bit\n");
|
|
|
|
pcdev->platform_flags |= PXA_CAMERA_DATAWIDTH_10;
|
|
|
|
}
|
2011-07-27 13:37:45 -06:00
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_DATAWIDTH_8)
|
|
|
|
pcdev->width_flags = 1 << 7;
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_DATAWIDTH_9)
|
|
|
|
pcdev->width_flags |= 1 << 8;
|
|
|
|
if (pcdev->platform_flags & PXA_CAMERA_DATAWIDTH_10)
|
|
|
|
pcdev->width_flags |= 1 << 9;
|
2008-12-18 07:38:03 -07:00
|
|
|
pcdev->mclk = pcdev->pdata->mclk_10khz * 10000;
|
|
|
|
if (!pcdev->mclk) {
|
2008-04-06 18:24:56 -06:00
|
|
|
dev_warn(&pdev->dev,
|
2008-12-18 07:38:03 -07:00
|
|
|
"mclk == 0! Please, fix your platform data. "
|
2008-04-06 18:24:56 -06:00
|
|
|
"Using default 20MHz\n");
|
2008-12-18 07:38:03 -07:00
|
|
|
pcdev->mclk = 20000000;
|
2008-04-06 18:24:56 -06:00
|
|
|
}
|
|
|
|
|
2009-08-25 08:28:22 -06:00
|
|
|
pcdev->mclk_divisor = mclk_get_divisor(pdev, pcdev);
|
2008-12-18 07:38:03 -07:00
|
|
|
|
2008-04-06 18:24:56 -06:00
|
|
|
INIT_LIST_HEAD(&pcdev->capture);
|
|
|
|
spin_lock_init(&pcdev->lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Request the regions.
|
|
|
|
*/
|
2013-01-07 05:51:21 -07:00
|
|
|
base = devm_request_and_ioremap(&pdev->dev, res);
|
|
|
|
if (!base)
|
|
|
|
return -ENOMEM;
|
2008-04-06 18:24:56 -06:00
|
|
|
pcdev->irq = irq;
|
|
|
|
pcdev->base = base;
|
|
|
|
|
|
|
|
/* request dma */
|
2008-09-18 14:50:15 -06:00
|
|
|
err = pxa_request_dma("CI_Y", DMA_PRIO_HIGH,
|
|
|
|
pxa_camera_dma_irq_y, pcdev);
|
|
|
|
if (err < 0) {
|
2009-04-24 09:55:48 -06:00
|
|
|
dev_err(&pdev->dev, "Can't request DMA for Y\n");
|
2013-01-07 05:51:21 -07:00
|
|
|
return err;
|
2008-04-06 18:24:56 -06:00
|
|
|
}
|
2008-09-18 14:50:15 -06:00
|
|
|
pcdev->dma_chans[0] = err;
|
2009-04-24 09:55:48 -06:00
|
|
|
dev_dbg(&pdev->dev, "got DMA channel %d\n", pcdev->dma_chans[0]);
|
2008-04-22 07:36:32 -06:00
|
|
|
|
2008-09-18 14:50:15 -06:00
|
|
|
err = pxa_request_dma("CI_U", DMA_PRIO_HIGH,
|
|
|
|
pxa_camera_dma_irq_u, pcdev);
|
|
|
|
if (err < 0) {
|
2009-04-24 09:55:48 -06:00
|
|
|
dev_err(&pdev->dev, "Can't request DMA for U\n");
|
2008-04-22 07:36:32 -06:00
|
|
|
goto exit_free_dma_y;
|
|
|
|
}
|
2008-09-18 14:50:15 -06:00
|
|
|
pcdev->dma_chans[1] = err;
|
2009-04-24 09:55:48 -06:00
|
|
|
dev_dbg(&pdev->dev, "got DMA channel (U) %d\n", pcdev->dma_chans[1]);
|
2008-04-22 07:36:32 -06:00
|
|
|
|
2008-09-18 14:50:15 -06:00
|
|
|
err = pxa_request_dma("CI_V", DMA_PRIO_HIGH,
|
|
|
|
pxa_camera_dma_irq_v, pcdev);
|
|
|
|
if (err < 0) {
|
2009-04-24 09:55:48 -06:00
|
|
|
dev_err(&pdev->dev, "Can't request DMA for V\n");
|
2008-04-22 07:36:32 -06:00
|
|
|
goto exit_free_dma_u;
|
|
|
|
}
|
2008-09-18 14:50:15 -06:00
|
|
|
pcdev->dma_chans[2] = err;
|
2009-04-24 09:55:48 -06:00
|
|
|
dev_dbg(&pdev->dev, "got DMA channel (V) %d\n", pcdev->dma_chans[2]);
|
2008-04-06 18:24:56 -06: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 01:26:43 -06: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-06 18:24:56 -06:00
|
|
|
|
|
|
|
/* request irq */
|
2013-01-07 05:51:21 -07:00
|
|
|
err = devm_request_irq(&pdev->dev, pcdev->irq, pxa_camera_irq, 0,
|
|
|
|
PXA_CAM_DRV_NAME, pcdev);
|
2008-04-06 18:24:56 -06:00
|
|
|
if (err) {
|
2013-01-07 05:51:21 -07:00
|
|
|
dev_err(&pdev->dev, "Camera interrupt register failed\n");
|
2008-04-06 18:24:56 -06:00
|
|
|
goto exit_free_dma;
|
|
|
|
}
|
|
|
|
|
2009-04-24 09:55:18 -06: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 08:43:33 -06:00
|
|
|
pcdev->soc_host.v4l2_dev.dev = &pdev->dev;
|
2009-04-24 09:55:18 -06:00
|
|
|
pcdev->soc_host.nr = pdev->id;
|
2009-04-24 09:55:48 -06:00
|
|
|
|
2009-04-24 09:55:18 -06:00
|
|
|
err = soc_camera_host_register(&pcdev->soc_host);
|
2008-04-06 18:24:56 -06:00
|
|
|
if (err)
|
2013-01-07 05:51:21 -07:00
|
|
|
goto exit_free_dma;
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
exit_free_dma:
|
2008-04-22 07:36:32 -06: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-06 18:24:56 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-12-21 14:17:53 -07:00
|
|
|
static int pxa_camera_remove(struct platform_device *pdev)
|
2008-04-06 18:24:56 -06:00
|
|
|
{
|
2009-04-24 09:55:48 -06: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-06 18:24:56 -06:00
|
|
|
|
2008-04-22 07:36:32 -06:00
|
|
|
pxa_free_dma(pcdev->dma_chans[0]);
|
|
|
|
pxa_free_dma(pcdev->dma_chans[1]);
|
|
|
|
pxa_free_dma(pcdev->dma_chans[2]);
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2009-04-24 09:55:48 -06:00
|
|
|
soc_camera_host_unregister(soc_host);
|
2008-04-06 18:24:56 -06:00
|
|
|
|
2008-04-14 23:57:48 -06:00
|
|
|
dev_info(&pdev->dev, "PXA Camera driver unloaded\n");
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-06-29 08:45:01 -06:00
|
|
|
static struct dev_pm_ops pxa_camera_pm = {
|
|
|
|
.suspend = pxa_camera_suspend,
|
|
|
|
.resume = pxa_camera_resume,
|
|
|
|
};
|
|
|
|
|
2008-04-06 18:24:56 -06:00
|
|
|
static struct platform_driver pxa_camera_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = PXA_CAM_DRV_NAME,
|
2011-06-29 08:45:01 -06:00
|
|
|
.pm = &pxa_camera_pm,
|
2008-04-06 18:24:56 -06:00
|
|
|
},
|
|
|
|
.probe = pxa_camera_probe,
|
2012-12-21 14:17:53 -07:00
|
|
|
.remove = pxa_camera_remove,
|
2008-04-06 18:24:56 -06:00
|
|
|
};
|
|
|
|
|
2012-01-09 23:21:49 -07:00
|
|
|
module_platform_driver(pxa_camera_driver);
|
2008-04-06 18:24:56 -06:00
|
|
|
|
|
|
|
MODULE_DESCRIPTION("PXA27x SoC Camera Host driver");
|
|
|
|
MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
|
|
|
|
MODULE_LICENSE("GPL");
|
2011-06-25 08:28:37 -06:00
|
|
|
MODULE_VERSION(PXA_CAM_VERSION);
|
2009-08-25 08:28:22 -06:00
|
|
|
MODULE_ALIAS("platform:" PXA_CAM_DRV_NAME);
|