* [PATCH 1/4] v4l2: add vb2_get_unmapped_area in vb2 core
@ 2011-09-13 18:34 Scott Jiang
2011-09-13 8:17 ` Guennadi Liakhovetski
` (3 more replies)
0 siblings, 4 replies; 39+ messages in thread
From: Scott Jiang @ 2011-09-13 18:34 UTC (permalink / raw)
To: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil,
Guennadi Liakhovetski
Cc: linux-media, uclinux-dist-devel, Scott Jiang
no mmu system needs get_unmapped_area file operations to do mmap
Signed-off-by: Scott Jiang <scott.jiang.linux@gmail.com>
---
drivers/media/video/videobuf2-core.c | 31 +++++++++++++++++++++++++++++++
include/media/videobuf2-core.h | 7 +++++++
2 files changed, 38 insertions(+), 0 deletions(-)
diff --git a/drivers/media/video/videobuf2-core.c b/drivers/media/video/videobuf2-core.c
index 3015e60..02a0ec6 100644
--- a/drivers/media/video/videobuf2-core.c
+++ b/drivers/media/video/videobuf2-core.c
@@ -1344,6 +1344,37 @@ int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma)
}
EXPORT_SYMBOL_GPL(vb2_mmap);
+#ifndef CONFIG_MMU
+unsigned long vb2_get_unmapped_area(struct vb2_queue *q,
+ unsigned long addr,
+ unsigned long len,
+ unsigned long pgoff,
+ unsigned long flags)
+{
+ unsigned long off = pgoff << PAGE_SHIFT;
+ struct vb2_buffer *vb;
+ unsigned int buffer, plane;
+ int ret;
+
+ if (q->memory != V4L2_MEMORY_MMAP) {
+ dprintk(1, "Queue is not currently set up for mmap\n");
+ return -EINVAL;
+ }
+
+ /*
+ * Find the plane corresponding to the offset passed by userspace.
+ */
+ ret = __find_plane_by_offset(q, off, &buffer, &plane);
+ if (ret)
+ return ret;
+
+ vb = q->bufs[buffer];
+
+ return (unsigned long)vb2_plane_vaddr(vb, plane);
+}
+EXPORT_SYMBOL_GPL(vb2_get_unmapped_area);
+#endif
+
static int __vb2_init_fileio(struct vb2_queue *q, int read);
static int __vb2_cleanup_fileio(struct vb2_queue *q);
diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h
index f87472a..5c7b5b4 100644
--- a/include/media/videobuf2-core.h
+++ b/include/media/videobuf2-core.h
@@ -302,6 +302,13 @@ int vb2_streamon(struct vb2_queue *q, enum v4l2_buf_type type);
int vb2_streamoff(struct vb2_queue *q, enum v4l2_buf_type type);
int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma);
+#ifndef CONFIG_MMU
+unsigned long vb2_get_unmapped_area(struct vb2_queue *q,
+ unsigned long addr,
+ unsigned long len,
+ unsigned long pgoff,
+ unsigned long flags);
+#endif
unsigned int vb2_poll(struct vb2_queue *q, struct file *file, poll_table *wait);
size_t vb2_read(struct vb2_queue *q, char __user *data, size_t count,
loff_t *ppos, int nonblock);
--
1.7.0.4
^ permalink raw reply related [flat|nested] 39+ messages in thread* Re: [PATCH 1/4] v4l2: add vb2_get_unmapped_area in vb2 core 2011-09-13 18:34 [PATCH 1/4] v4l2: add vb2_get_unmapped_area in vb2 core Scott Jiang @ 2011-09-13 8:17 ` Guennadi Liakhovetski 2011-09-13 8:36 ` Scott Jiang 2011-09-13 18:34 ` [PATCH 2/4] v4l2: add adv7183 decoder driver Scott Jiang ` (2 subsequent siblings) 3 siblings, 1 reply; 39+ messages in thread From: Guennadi Liakhovetski @ 2011-09-13 8:17 UTC (permalink / raw) To: Scott Jiang Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel On Tue, 13 Sep 2011, Scott Jiang wrote: > no mmu system needs get_unmapped_area file operations to do mmap > > Signed-off-by: Scott Jiang <scott.jiang.linux@gmail.com> > --- > drivers/media/video/videobuf2-core.c | 31 +++++++++++++++++++++++++++++++ > include/media/videobuf2-core.h | 7 +++++++ > 2 files changed, 38 insertions(+), 0 deletions(-) > > diff --git a/drivers/media/video/videobuf2-core.c b/drivers/media/video/videobuf2-core.c > index 3015e60..02a0ec6 100644 > --- a/drivers/media/video/videobuf2-core.c > +++ b/drivers/media/video/videobuf2-core.c > @@ -1344,6 +1344,37 @@ int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma) > } > EXPORT_SYMBOL_GPL(vb2_mmap); > > +#ifndef CONFIG_MMU > +unsigned long vb2_get_unmapped_area(struct vb2_queue *q, > + unsigned long addr, > + unsigned long len, > + unsigned long pgoff, > + unsigned long flags) > +{ > + unsigned long off = pgoff << PAGE_SHIFT; > + struct vb2_buffer *vb; > + unsigned int buffer, plane; > + int ret; > + > + if (q->memory != V4L2_MEMORY_MMAP) { > + dprintk(1, "Queue is not currently set up for mmap\n"); > + return -EINVAL; > + } > + > + /* > + * Find the plane corresponding to the offset passed by userspace. > + */ > + ret = __find_plane_by_offset(q, off, &buffer, &plane); > + if (ret) > + return ret; > + > + vb = q->bufs[buffer]; > + > + return (unsigned long)vb2_plane_vaddr(vb, plane); > +} > +EXPORT_SYMBOL_GPL(vb2_get_unmapped_area); Hm, wouldn't it be better to use vb2_mmap() and provide a dummy .mmap() method in videobuf2-dma-contig.c for the NOMMU case? Thanks Guennadi > +#endif > + > static int __vb2_init_fileio(struct vb2_queue *q, int read); > static int __vb2_cleanup_fileio(struct vb2_queue *q); > > diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h > index f87472a..5c7b5b4 100644 > --- a/include/media/videobuf2-core.h > +++ b/include/media/videobuf2-core.h > @@ -302,6 +302,13 @@ int vb2_streamon(struct vb2_queue *q, enum v4l2_buf_type type); > int vb2_streamoff(struct vb2_queue *q, enum v4l2_buf_type type); > > int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma); > +#ifndef CONFIG_MMU > +unsigned long vb2_get_unmapped_area(struct vb2_queue *q, > + unsigned long addr, > + unsigned long len, > + unsigned long pgoff, > + unsigned long flags); > +#endif > unsigned int vb2_poll(struct vb2_queue *q, struct file *file, poll_table *wait); > size_t vb2_read(struct vb2_queue *q, char __user *data, size_t count, > loff_t *ppos, int nonblock); > -- > 1.7.0.4 > > --- Guennadi Liakhovetski, Ph.D. Freelance Open-Source Software Developer http://www.open-technology.de/ ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 1/4] v4l2: add vb2_get_unmapped_area in vb2 core 2011-09-13 8:17 ` Guennadi Liakhovetski @ 2011-09-13 8:36 ` Scott Jiang 0 siblings, 0 replies; 39+ messages in thread From: Scott Jiang @ 2011-09-13 8:36 UTC (permalink / raw) To: Guennadi Liakhovetski Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel > > Hm, wouldn't it be better to use vb2_mmap() and provide a dummy .mmap() > method in videobuf2-dma-contig.c for the NOMMU case? > these are two different file operations called by mm system. ^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 2/4] v4l2: add adv7183 decoder driver 2011-09-13 18:34 [PATCH 1/4] v4l2: add vb2_get_unmapped_area in vb2 core Scott Jiang 2011-09-13 8:17 ` Guennadi Liakhovetski @ 2011-09-13 18:34 ` Scott Jiang 2011-09-14 3:05 ` [uclinux-dist-devel] " Mike Frysinger 2011-09-13 18:34 ` [PATCH 3/4] v4l2: add vs6624 sensor driver Scott Jiang 2011-09-13 18:34 ` [PATCH 4/4] v4l2: add blackfin capture bridge driver Scott Jiang 3 siblings, 1 reply; 39+ messages in thread From: Scott Jiang @ 2011-09-13 18:34 UTC (permalink / raw) To: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski Cc: linux-media, uclinux-dist-devel, Scott Jiang this driver is a v4l2 subdevice driver to support Analog Devices ADV7183 SDTV video decoder Signed-off-by: Scott Jiang <scott.jiang.linux@gmail.com> --- drivers/media/video/Kconfig | 10 + drivers/media/video/Makefile | 1 + drivers/media/video/adv7183.c | 684 ++++++++++++++++++++++++++++++++++++ drivers/media/video/adv7183_regs.h | 107 ++++++ include/media/adv7183.h | 47 +++ include/media/v4l2-chip-ident.h | 3 + 6 files changed, 852 insertions(+), 0 deletions(-) create mode 100644 drivers/media/video/adv7183.c create mode 100644 drivers/media/video/adv7183_regs.h create mode 100644 include/media/adv7183.h diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig index f574dc0..af8ed6b 100644 --- a/drivers/media/video/Kconfig +++ b/drivers/media/video/Kconfig @@ -273,6 +273,16 @@ config VIDEO_ADV7180 To compile this driver as a module, choose M here: the module will be called adv7180. +config VIDEO_ADV7183 + tristate "Analog Devices ADV7183 decoder" + depends on VIDEO_V4L2 && I2C + ---help--- + V4l2 subdevice driver for the Analog Devices + ADV7183 video decoder. + + To compile this driver as a module, choose M here: the + module will be called adv7183. + config VIDEO_BT819 tristate "BT819A VideoStream decoder" depends on VIDEO_V4L2 && I2C diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile index 2723900..b0329ae 100644 --- a/drivers/media/video/Makefile +++ b/drivers/media/video/Makefile @@ -40,6 +40,7 @@ obj-$(CONFIG_VIDEO_SAA7191) += saa7191.o obj-$(CONFIG_VIDEO_ADV7170) += adv7170.o obj-$(CONFIG_VIDEO_ADV7175) += adv7175.o obj-$(CONFIG_VIDEO_ADV7180) += adv7180.o +obj-$(CONFIG_VIDEO_ADV7183) += adv7183.o obj-$(CONFIG_VIDEO_ADV7343) += adv7343.o obj-$(CONFIG_VIDEO_VPX3220) += vpx3220.o obj-$(CONFIG_VIDEO_BT819) += bt819.o diff --git a/drivers/media/video/adv7183.c b/drivers/media/video/adv7183.c new file mode 100644 index 0000000..afcaf5d --- /dev/null +++ b/drivers/media/video/adv7183.c @@ -0,0 +1,684 @@ +/* + * adv7183.c Analog Devices ADV7183 video decoder driver + * + * Copyright (c) 2011 Analog Devices Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include <linux/module.h> +#include <linux/init.h> +#include <linux/errno.h> +#include <linux/types.h> +#include <linux/i2c.h> +#include <linux/slab.h> +#include <linux/delay.h> +#include <linux/gpio.h> +#include <linux/videodev2.h> +#include <media/v4l2-device.h> +#include <media/v4l2-chip-ident.h> +#include <media/v4l2-ctrls.h> +#include <media/adv7183.h> +#include "adv7183_regs.h" + +struct adv7183 { + struct v4l2_subdev sd; + struct v4l2_ctrl_handler hdl; + + v4l2_std_id std; /* Current set standard */ + u32 input; + u32 output; + unsigned reset_pin; + unsigned oe_pin; + struct v4l2_mbus_framefmt fmt; +}; + +/* EXAMPLES USING 27 MHz CLOCK + * Mode 1 CVBS Input (Composite Video on AIN5) + * All standards are supported through autodetect, 8-bit, 4:2:2, ITU-R BT.656 output on P15 to P8. + */ +static const unsigned char adv7183_init_regs[] = { + ADV7183_IN_CTRL, 0x04, /* CVBS input on AIN5 */ + ADV7183_DIGI_CLAMP_CTRL_1, 0x00, /* Slow down digital clamps */ + ADV7183_SHAP_FILT_CTRL, 0x41, /* Set CSFM to SH1 */ + ADV7183_ADC_CTRL, 0x16, /* Power down ADC 1 and ADC 2 */ + ADV7183_CTI_DNR_CTRL_4, 0x04, /* Set DNR threshold to 4 for flat response */ + /* ADI recommended programming sequence */ + ADV7183_ADI_CTRL, 0x80, + ADV7183_CTI_DNR_CTRL_4, 0x20, + 0x52, 0x18, + 0x58, 0xED, + 0x77, 0xC5, + 0x7C, 0x93, + 0x7D, 0x00, + 0xD0, 0x48, + 0xD5, 0xA0, + 0xD7, 0xEA, + ADV7183_SD_SATURATION_CR, 0x3E, + ADV7183_PAL_V_END, 0x3E, + ADV7183_PAL_F_TOGGLE, 0x0F, + ADV7183_ADI_CTRL, 0x00, +}; + +static inline struct adv7183 *to_adv7183(struct v4l2_subdev *sd) +{ + return container_of(sd, struct adv7183, sd); +} +static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl) +{ + return &container_of(ctrl->handler, struct adv7183, hdl)->sd; +} + +static inline int adv7183_read(struct v4l2_subdev *sd, unsigned char reg) +{ + struct i2c_client *client = v4l2_get_subdevdata(sd); + + return i2c_smbus_read_byte_data(client, reg); +} + +static inline int adv7183_write(struct v4l2_subdev *sd, unsigned char reg, + unsigned char value) +{ + struct i2c_client *client = v4l2_get_subdevdata(sd); + + return i2c_smbus_write_byte_data(client, reg, value); +} + +static int adv7183_writeregs(struct v4l2_subdev *sd, + const unsigned char *regs, unsigned int num) +{ + unsigned char reg, data; + unsigned int cnt = 0; + + if (num & 0x1) { + v4l2_err(sd, "invalid regs array\n"); + return -1; + } + + while (cnt < num) { + reg = *regs++; + data = *regs++; + cnt += 2; + + adv7183_write(sd, reg, data); + } + return 0; +} + +static int adv7183_log_status(struct v4l2_subdev *sd) +{ + struct adv7183 *decoder = to_adv7183(sd); + + v4l2_info(sd, "adv7183: Input control = 0x%02x\n", + adv7183_read(sd, ADV7183_IN_CTRL)); + v4l2_info(sd, "adv7183: Video selection = 0x%02x\n", + adv7183_read(sd, ADV7183_VD_SEL)); + v4l2_info(sd, "adv7183: Output control = 0x%02x\n", + adv7183_read(sd, ADV7183_OUT_CTRL)); + v4l2_info(sd, "adv7183: Extended output control = 0x%02x\n", + adv7183_read(sd, ADV7183_EXT_OUT_CTRL)); + v4l2_info(sd, "adv7183: Autodetect enable = 0x%02x\n", + adv7183_read(sd, ADV7183_AUTO_DET_EN)); + v4l2_info(sd, "adv7183: Contrast = 0x%02x\n", + adv7183_read(sd, ADV7183_CONTRAST)); + v4l2_info(sd, "adv7183: Brightness = 0x%02x\n", + adv7183_read(sd, ADV7183_BRIGHTNESS)); + v4l2_info(sd, "adv7183: Hue = 0x%02x\n", + adv7183_read(sd, ADV7183_HUE)); + v4l2_info(sd, "adv7183: Default value Y = 0x%02x\n", + adv7183_read(sd, ADV7183_DEF_Y)); + v4l2_info(sd, "adv7183: Default value C = 0x%02x\n", + adv7183_read(sd, ADV7183_DEF_C)); + v4l2_info(sd, "adv7183: ADI control = 0x%02x\n", + adv7183_read(sd, ADV7183_ADI_CTRL)); + v4l2_info(sd, "adv7183: Power Management = 0x%02x\n", + adv7183_read(sd, ADV7183_POW_MANAGE)); + v4l2_info(sd, "adv7183: Status 1 2 and 3 = 0x%02x 0x%02x 0x%02x\n", + adv7183_read(sd, ADV7183_STATUS_1), + adv7183_read(sd, ADV7183_STATUS_2), + adv7183_read(sd, ADV7183_STATUS_3)); + v4l2_info(sd, "adv7183: Ident = 0x%02x\n", + adv7183_read(sd, ADV7183_IDENT)); + v4l2_info(sd, "adv7183: Analog clamp control = 0x%02x\n", + adv7183_read(sd, ADV7183_ANAL_CLAMP_CTRL)); + v4l2_info(sd, "adv7183: Digital clamp control 1 = 0x%02x\n", + adv7183_read(sd, ADV7183_DIGI_CLAMP_CTRL_1)); + v4l2_info(sd, "adv7183: Shaping filter control 1 and 2 = 0x%02x 0x%02x\n", + adv7183_read(sd, ADV7183_SHAP_FILT_CTRL), + adv7183_read(sd, ADV7183_SHAP_FILT_CTRL_2)); + v4l2_info(sd, "adv7183: Comb filter control = 0x%02x\n", + adv7183_read(sd, ADV7183_COMB_FILT_CTRL)); + v4l2_info(sd, "adv7183: ADI control 2 = 0x%02x\n", + adv7183_read(sd, ADV7183_ADI_CTRL_2)); + v4l2_info(sd, "adv7183: Pixel delay control = 0x%02x\n", + adv7183_read(sd, ADV7183_PIX_DELAY_CTRL)); + v4l2_info(sd, "adv7183: Misc gain control = 0x%02x\n", + adv7183_read(sd, ADV7183_MISC_GAIN_CTRL)); + v4l2_info(sd, "adv7183: AGC mode control = 0x%02x\n", + adv7183_read(sd, ADV7183_AGC_MODE_CTRL)); + v4l2_info(sd, "adv7183: Chroma gain control 1 and 2 = 0x%02x 0x%02x\n", + adv7183_read(sd, ADV7183_CHRO_GAIN_CTRL_1), + adv7183_read(sd, ADV7183_CHRO_GAIN_CTRL_2)); + v4l2_info(sd, "adv7183: Luma gain control 1 and 2 = 0x%02x 0x%02x\n", + adv7183_read(sd, ADV7183_LUMA_GAIN_CTRL_1), + adv7183_read(sd, ADV7183_LUMA_GAIN_CTRL_2)); + v4l2_info(sd, "adv7183: Vsync field control 1 2 and 3 = 0x%02x 0x%02x 0x%02x\n", + adv7183_read(sd, ADV7183_VS_FIELD_CTRL_1), + adv7183_read(sd, ADV7183_VS_FIELD_CTRL_2), + adv7183_read(sd, ADV7183_VS_FIELD_CTRL_3)); + v4l2_info(sd, "adv7183: Hsync positon control 1 2 and 3 = 0x%02x 0x%02x 0x%02x\n", + adv7183_read(sd, ADV7183_HS_POS_CTRL_1), + adv7183_read(sd, ADV7183_HS_POS_CTRL_2), + adv7183_read(sd, ADV7183_HS_POS_CTRL_3)); + v4l2_info(sd, "adv7183: Polarity = 0x%02x\n", + adv7183_read(sd, ADV7183_POLARITY)); + v4l2_info(sd, "adv7183: ADC control = 0x%02x\n", + adv7183_read(sd, ADV7183_ADC_CTRL)); + v4l2_info(sd, "adv7183: SD offset Cb and Cr = 0x%02x 0x%02x\n", + adv7183_read(sd, ADV7183_SD_OFFSET_CB), + adv7183_read(sd, ADV7183_SD_OFFSET_CR)); + v4l2_info(sd, "adv7183: SD saturation Cb and Cr = 0x%02x 0x%02x\n", + adv7183_read(sd, ADV7183_SD_SATURATION_CB), + adv7183_read(sd, ADV7183_SD_SATURATION_CR)); + v4l2_info(sd, "adv7183: Drive strength = 0x%02x\n", + adv7183_read(sd, ADV7183_DRIVE_STR)); + v4l2_ctrl_handler_log_status(&decoder->hdl, sd->name); + return 0; +} + +static int adv7183_s_std(struct v4l2_subdev *sd, v4l2_std_id std) +{ + struct adv7183 *decoder = to_adv7183(sd); + int reg; + + if (std == decoder->std) + return 0; + reg = adv7183_read(sd, ADV7183_IN_CTRL) & 0xF; + if (std == V4L2_STD_ALL) + adv7183_write(sd, ADV7183_IN_CTRL, reg); + else { + if (std == V4L2_STD_PAL_60) + reg |= 0x60; + else if (std == V4L2_STD_NTSC_443) + reg |= 0x70; + else if (std == V4L2_STD_PAL_N) + reg |= 0x90; + else if (std == V4L2_STD_PAL_M) + reg |= 0xA0; + else if (std == V4L2_STD_PAL_Nc) + reg |= 0xC0; + else if (std & V4L2_STD_PAL) + reg |= 0x80; + else if (std & V4L2_STD_NTSC) + reg |= 0x50; + else if (std & V4L2_STD_SECAM) + reg |= 0xE0; + else + return -EINVAL; + adv7183_write(sd, ADV7183_IN_CTRL, reg); + } + + decoder->std = std; + + return 0; +} + +static int adv7183_reset(struct v4l2_subdev *sd, u32 val) +{ + int reg; + + reg = adv7183_read(sd, ADV7183_POW_MANAGE) | 0x80; + adv7183_write(sd, ADV7183_POW_MANAGE, reg); + /* wait 5ms before any further i2c writes are performed */ + usleep_range(5000, 10000); + return 0; +} + +static int adv7183_s_routing(struct v4l2_subdev *sd, + u32 input, u32 output, u32 config) +{ + struct adv7183 *decoder = to_adv7183(sd); + int reg; + + if ((input > ADV7183_COMPONENT1) || (output > ADV7183_16BIT_OUT)) + return -EINVAL; + + if (input != decoder->input) { + decoder->input = input; + reg = adv7183_read(sd, ADV7183_IN_CTRL) & 0xF0; + switch (input) { + case ADV7183_COMPOSITE1: + reg |= 0x1; + break; + case ADV7183_COMPOSITE2: + reg |= 0x2; + break; + case ADV7183_COMPOSITE3: + reg |= 0x3; + break; + case ADV7183_COMPOSITE4: + reg |= 0x4; + break; + case ADV7183_COMPOSITE5: + reg |= 0x5; + break; + case ADV7183_COMPOSITE6: + reg |= 0xB; + break; + case ADV7183_COMPOSITE7: + reg |= 0xC; + break; + case ADV7183_COMPOSITE8: + reg |= 0xD; + break; + case ADV7183_COMPOSITE9: + reg |= 0xE; + break; + case ADV7183_COMPOSITE10: + reg |= 0xF; + break; + case ADV7183_SVIDEO0: + reg |= 0x6; + break; + case ADV7183_SVIDEO1: + reg |= 0x7; + break; + case ADV7183_SVIDEO2: + reg |= 0x8; + break; + case ADV7183_COMPONENT0: + reg |= 0x9; + break; + case ADV7183_COMPONENT1: + reg |= 0xA; + break; + default: + break; + } + adv7183_write(sd, ADV7183_IN_CTRL, reg); + } + + if (output != decoder->output) { + decoder->output = output; + reg = adv7183_read(sd, ADV7183_OUT_CTRL) & 0xC0; + switch (output) { + case ADV7183_16BIT_OUT: + reg |= 0x9; + break; + default: + reg |= 0xC; + break; + } + adv7183_write(sd, ADV7183_OUT_CTRL, reg); + } + + return 0; +} + +static int adv7183_s_ctrl(struct v4l2_ctrl *ctrl) +{ + struct v4l2_subdev *sd = to_sd(ctrl); + int val = ctrl->val; + + switch (ctrl->id) { + case V4L2_CID_BRIGHTNESS: + if (val < 0) + val = 127 - val; + adv7183_write(sd, ADV7183_BRIGHTNESS, val); + break; + case V4L2_CID_CONTRAST: + adv7183_write(sd, ADV7183_CONTRAST, val); + break; + case V4L2_CID_SATURATION: + adv7183_write(sd, ADV7183_SD_SATURATION_CB, val >> 8); + adv7183_write(sd, ADV7183_SD_SATURATION_CR, (val & 0xFF)); + break; + case V4L2_CID_HUE: + adv7183_write(sd, ADV7183_SD_OFFSET_CB, val >> 8); + adv7183_write(sd, ADV7183_SD_OFFSET_CR, (val & 0xFF)); + break; + default: + return -EINVAL; + } + + return 0; +} + +static int adv7183_querystd(struct v4l2_subdev *sd, v4l2_std_id *std) +{ + struct adv7183 *decoder = to_adv7183(sd); + int reg; + + if (decoder->std == V4L2_STD_ALL) { + reg = adv7183_read(sd, ADV7183_STATUS_1); + switch ((reg >> 0x4) & 0x7) { + case 0: + *std = V4L2_STD_NTSC; + break; + case 1: + *std = V4L2_STD_NTSC_443; + break; + case 2: + *std = V4L2_STD_PAL_M; + break; + case 3: + *std = V4L2_STD_PAL_60; + break; + case 4: + *std = V4L2_STD_PAL; + break; + case 5: + *std = V4L2_STD_SECAM; + break; + case 6: + *std = V4L2_STD_PAL_Nc; + break; + case 7: + *std = V4L2_STD_SECAM; + break; + default: + *std = V4L2_STD_UNKNOWN; + break; + } + } else + *std = decoder->std; + return 0; +} + +static int adv7183_g_input_status(struct v4l2_subdev *sd, u32 *status) +{ + int reg; + + *status = V4L2_IN_ST_NO_SIGNAL; + reg = adv7183_read(sd, ADV7183_STATUS_1); + if (reg < 0) + return reg; + else if (reg & 0x1) + *status = 0; + return 0; +} + +static int adv7183_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned index, + enum v4l2_mbus_pixelcode *code) +{ + if (index > 0) + return -EINVAL; + + *code = V4L2_MBUS_FMT_UYVY8_2X8; + return 0; +} + +static int adv7183_try_mbus_fmt(struct v4l2_subdev *sd, + struct v4l2_mbus_framefmt *fmt) +{ + v4l2_std_id std; + + fmt->code = V4L2_MBUS_FMT_UYVY8_2X8; + fmt->colorspace = V4L2_COLORSPACE_SMPTE170M; + adv7183_querystd(sd, &std); + if (std & V4L2_STD_525_60) { + fmt->field = V4L2_FIELD_SEQ_TB; + fmt->width = 720; + fmt->height = 480; + } else { + fmt->field = V4L2_FIELD_SEQ_BT; + fmt->width = 720; + fmt->height = 576; + } + return 0; +} + +static int adv7183_s_mbus_fmt(struct v4l2_subdev *sd, + struct v4l2_mbus_framefmt *fmt) +{ + struct adv7183 *decoder = to_adv7183(sd); + + adv7183_try_mbus_fmt(sd, fmt); + decoder->fmt = *fmt; + return 0; +} + +static int adv7183_g_mbus_fmt(struct v4l2_subdev *sd, + struct v4l2_mbus_framefmt *fmt) +{ + struct adv7183 *decoder = to_adv7183(sd); + + *fmt = decoder->fmt; + return 0; +} + +static int adv7183_s_stream(struct v4l2_subdev *sd, int enable) +{ + struct adv7183 *decoder = to_adv7183(sd); + + if (enable) + gpio_direction_output(decoder->oe_pin, 0); + else + gpio_direction_output(decoder->oe_pin, 1); + udelay(1); + return 0; +} + +static int adv7183_g_chip_ident(struct v4l2_subdev *sd, + struct v4l2_dbg_chip_ident *chip) +{ + int rev; + struct i2c_client *client = v4l2_get_subdevdata(sd); + + /* 0x11 for adv7183, 0x13 for adv7183b */ + rev = adv7183_read(sd, ADV7183_IDENT); + + return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_ADV7183, rev); +} + +#ifdef CONFIG_VIDEO_ADV_DEBUG +static int adv7183_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg) +{ + struct i2c_client *client = v4l2_get_subdevdata(sd); + + if (!v4l2_chip_match_i2c_client(client, ®->match)) + return -EINVAL; + if (!capable(CAP_SYS_ADMIN)) + return -EPERM; + reg->val = adv7183_read(sd, reg->reg & 0xff); + reg->size = 1; + return 0; +} + +static int adv7183_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg) +{ + struct i2c_client *client = v4l2_get_subdevdata(sd); + + if (!v4l2_chip_match_i2c_client(client, ®->match)) + return -EINVAL; + if (!capable(CAP_SYS_ADMIN)) + return -EPERM; + adv7183_write(sd, reg->reg & 0xff, reg->val & 0xff); + return 0; +} +#endif + +static const struct v4l2_ctrl_ops adv7183_ctrl_ops = { + .s_ctrl = adv7183_s_ctrl, +}; + +static const struct v4l2_subdev_core_ops adv7183_core_ops = { + .log_status = adv7183_log_status, + .s_std = adv7183_s_std, + .reset = adv7183_reset, + .g_chip_ident = adv7183_g_chip_ident, + .g_ext_ctrls = v4l2_subdev_g_ext_ctrls, + .try_ext_ctrls = v4l2_subdev_try_ext_ctrls, + .s_ext_ctrls = v4l2_subdev_s_ext_ctrls, + .g_ctrl = v4l2_subdev_g_ctrl, + .s_ctrl = v4l2_subdev_s_ctrl, + .queryctrl = v4l2_subdev_queryctrl, + .querymenu = v4l2_subdev_querymenu, +#ifdef CONFIG_VIDEO_ADV_DEBUG + .g_register = adv7183_g_register, + .s_register = adv7183_s_register, +#endif +}; + +static const struct v4l2_subdev_video_ops adv7183_video_ops = { + .s_routing = adv7183_s_routing, + .querystd = adv7183_querystd, + .g_input_status = adv7183_g_input_status, + .enum_mbus_fmt = adv7183_enum_mbus_fmt, + .try_mbus_fmt = adv7183_try_mbus_fmt, + .s_mbus_fmt = adv7183_s_mbus_fmt, + .g_mbus_fmt = adv7183_g_mbus_fmt, + .s_stream = adv7183_s_stream, +}; + +static const struct v4l2_subdev_ops adv7183_ops = { + .core = &adv7183_core_ops, + .video = &adv7183_video_ops, +}; + +static int adv7183_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct adv7183 *decoder; + struct v4l2_subdev *sd; + struct v4l2_ctrl_handler *hdl; + int ret; + const unsigned *pin_array; + + /* Check if the adapter supports the needed features */ + if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) + return -EIO; + + v4l_info(client, "chip found @ 0x%02x (%s)\n", + client->addr << 1, client->adapter->name); + + pin_array = client->dev.platform_data; + if (pin_array == NULL) + return -EINVAL; + + decoder = kzalloc(sizeof(struct adv7183), GFP_KERNEL); + if (decoder == NULL) + return -ENOMEM; + + decoder->reset_pin = pin_array[0]; + decoder->oe_pin = pin_array[1]; + + if (gpio_request(decoder->reset_pin, "ADV7183 Reset")) { + v4l_err(client, "failed to request GPIO %d\n", decoder->reset_pin); + ret = -EBUSY; + goto err_free_decoder; + } + + if (gpio_request(decoder->oe_pin, "ADV7183 Output Enable")) { + v4l_err(client, "failed to request GPIO %d\n", decoder->oe_pin); + ret = -EBUSY; + goto err_free_reset; + } + + sd = &decoder->sd; + v4l2_i2c_subdev_init(sd, client, &adv7183_ops); + + hdl = &decoder->hdl; + v4l2_ctrl_handler_init(hdl, 4); + v4l2_ctrl_new_std(hdl, &adv7183_ctrl_ops, + V4L2_CID_BRIGHTNESS, -128, 127, 1, 0); + v4l2_ctrl_new_std(hdl, &adv7183_ctrl_ops, + V4L2_CID_CONTRAST, 0, 0xFF, 1, 0x80); + v4l2_ctrl_new_std(hdl, &adv7183_ctrl_ops, + V4L2_CID_SATURATION, 0, 0xFFFF, 1, 0x8080); + v4l2_ctrl_new_std(hdl, &adv7183_ctrl_ops, + V4L2_CID_HUE, 0, 0xFFFF, 1, 0x8080); + /* hook the control handler into the driver */ + sd->ctrl_handler = hdl; + if (hdl->error) { + ret = hdl->error; + + v4l2_ctrl_handler_free(hdl); + goto err_free_oe; + } + + decoder->std = V4L2_STD_ALL; /* Default is autodetect */ + decoder->input = ADV7183_COMPOSITE4; + decoder->output = ADV7183_8BIT_OUT; + + gpio_direction_output(decoder->oe_pin, 1); + /* reset chip */ + gpio_direction_output(decoder->reset_pin, 0); + /* reset pulse width at least 5ms */ + mdelay(10); + gpio_direction_output(decoder->reset_pin, 1); + /* wait 5ms before any further i2c writes are performed */ + mdelay(5); + + adv7183_writeregs(sd, adv7183_init_regs, ARRAY_SIZE(adv7183_init_regs)); + + /* initialize the hardware to the default control values */ + v4l2_ctrl_handler_setup(hdl); + + return 0; +err_free_oe: + gpio_free(decoder->oe_pin); +err_free_reset: + gpio_free(decoder->reset_pin); +err_free_decoder: + kfree(decoder); + return ret; +} + +static int adv7183_remove(struct i2c_client *client) +{ + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct adv7183 *decoder = to_adv7183(sd); + + v4l2_device_unregister_subdev(sd); + v4l2_ctrl_handler_free(sd->ctrl_handler); + gpio_free(decoder->oe_pin); + gpio_free(decoder->reset_pin); + kfree(decoder); + return 0; +} + +static const struct i2c_device_id adv7183_id[] = { + {"adv7183", 0}, + {}, +}; + +MODULE_DEVICE_TABLE(i2c, adv7183_id); + +static struct i2c_driver adv7183_driver = { + .driver = { + .owner = THIS_MODULE, + .name = "adv7183", + }, + .probe = adv7183_probe, + .remove = __devexit_p(adv7183_remove), + .id_table = adv7183_id, +}; + +static __init int adv7183_init(void) +{ + return i2c_add_driver(&adv7183_driver); +} + +static __exit void adv7183_exit(void) +{ + i2c_del_driver(&adv7183_driver); +} + +module_init(adv7183_init); +module_exit(adv7183_exit); + +MODULE_DESCRIPTION("Analog Devices ADV7183 video decoder driver"); +MODULE_AUTHOR("Scott Jiang <Scott.Jiang.Linux@gmail.com>"); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/media/video/adv7183_regs.h b/drivers/media/video/adv7183_regs.h new file mode 100644 index 0000000..c2378c8 --- /dev/null +++ b/drivers/media/video/adv7183_regs.h @@ -0,0 +1,107 @@ +/* + * adv7183 - Analog Devices ADV7183 video decoder registers + * + * Copyright (c) 2011 Analog Devices Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _ADV7183_REGS_H_ +#define _ADV7183_REGS_H_ + +#define ADV7183_IN_CTRL 0x00 /* Input control */ +#define ADV7183_VD_SEL 0x01 /* Video selection */ +#define ADV7183_OUT_CTRL 0x03 /* Output control */ +#define ADV7183_EXT_OUT_CTRL 0x04 /* Extended output control */ +#define ADV7183_AUTO_DET_EN 0x07 /* Autodetect enable */ +#define ADV7183_CONTRAST 0x08 /* Contrast */ +#define ADV7183_BRIGHTNESS 0x0A /* Brightness */ +#define ADV7183_HUE 0x0B /* Hue */ +#define ADV7183_DEF_Y 0x0C /* Default value Y */ +#define ADV7183_DEF_C 0x0D /* Default value C */ +#define ADV7183_ADI_CTRL 0x0E /* ADI control */ +#define ADV7183_POW_MANAGE 0x0F /* Power Management */ +#define ADV7183_STATUS_1 0x10 /* Status 1 */ +#define ADV7183_IDENT 0x11 /* Ident */ +#define ADV7183_STATUS_2 0x12 /* Status 2 */ +#define ADV7183_STATUS_3 0x13 /* Status 3 */ +#define ADV7183_ANAL_CLAMP_CTRL 0x14 /* Analog clamp control */ +#define ADV7183_DIGI_CLAMP_CTRL_1 0x15 /* Digital clamp control 1 */ +#define ADV7183_SHAP_FILT_CTRL 0x17 /* Shaping filter control */ +#define ADV7183_SHAP_FILT_CTRL_2 0x18 /* Shaping filter control 2 */ +#define ADV7183_COMB_FILT_CTRL 0x19 /* Comb filter control */ +#define ADV7183_ADI_CTRL_2 0x1D /* ADI control 2 */ +#define ADV7183_PIX_DELAY_CTRL 0x27 /* Pixel delay control */ +#define ADV7183_MISC_GAIN_CTRL 0x2B /* Misc gain control */ +#define ADV7183_AGC_MODE_CTRL 0x2C /* AGC mode control */ +#define ADV7183_CHRO_GAIN_CTRL_1 0x2D /* Chroma gain control 1 */ +#define ADV7183_CHRO_GAIN_CTRL_2 0x2E /* Chroma gain control 2 */ +#define ADV7183_LUMA_GAIN_CTRL_1 0x2F /* Luma gain control 1 */ +#define ADV7183_LUMA_GAIN_CTRL_2 0x30 /* Luma gain control 2 */ +#define ADV7183_VS_FIELD_CTRL_1 0x31 /* Vsync field control 1 */ +#define ADV7183_VS_FIELD_CTRL_2 0x32 /* Vsync field control 2 */ +#define ADV7183_VS_FIELD_CTRL_3 0x33 /* Vsync field control 3 */ +#define ADV7183_HS_POS_CTRL_1 0x34 /* Hsync positon control 1 */ +#define ADV7183_HS_POS_CTRL_2 0x35 /* Hsync positon control 2 */ +#define ADV7183_HS_POS_CTRL_3 0x36 /* Hsync positon control 3 */ +#define ADV7183_POLARITY 0x37 /* Polarity */ +#define ADV7183_NTSC_COMB_CTRL 0x38 /* NTSC comb control */ +#define ADV7183_PAL_COMB_CTRL 0x39 /* PAL comb control */ +#define ADV7183_ADC_CTRL 0x3A /* ADC control */ +#define ADV7183_MAN_WIN_CTRL 0x3D /* Manual window control */ +#define ADV7183_RESAMPLE_CTRL 0x41 /* Resample control */ +#define ADV7183_GEMSTAR_CTRL_1 0x48 /* Gemstar ctrl 1 */ +#define ADV7183_GEMSTAR_CTRL_2 0x49 /* Gemstar ctrl 2 */ +#define ADV7183_GEMSTAR_CTRL_3 0x4A /* Gemstar ctrl 3 */ +#define ADV7183_GEMSTAR_CTRL_4 0x4B /* Gemstar ctrl 4 */ +#define ADV7183_GEMSTAR_CTRL_5 0x4C /* Gemstar ctrl 5 */ +#define ADV7183_CTI_DNR_CTRL_1 0x4D /* CTI DNR ctrl 1 */ +#define ADV7183_CTI_DNR_CTRL_2 0x4E /* CTI DNR ctrl 2 */ +#define ADV7183_CTI_DNR_CTRL_4 0x50 /* CTI DNR ctrl 4 */ +#define ADV7183_LOCK_CNT 0x51 /* Lock count */ +#define ADV7183_FREE_LINE_LEN 0x8F /* Free-Run line length 1 */ +#define ADV7183_VBI_INFO 0x90 /* VBI info */ +#define ADV7183_WSS_1 0x91 /* WSS 1 */ +#define ADV7183_WSS_2 0x92 /* WSS 2 */ +#define ADV7183_EDTV_1 0x93 /* EDTV 1 */ +#define ADV7183_EDTV_2 0x94 /* EDTV 2 */ +#define ADV7183_EDTV_3 0x95 /* EDTV 3 */ +#define ADV7183_CGMS_1 0x96 /* CGMS 1 */ +#define ADV7183_CGMS_2 0x97 /* CGMS 2 */ +#define ADV7183_CGMS_3 0x98 /* CGMS 3 */ +#define ADV7183_CCAP_1 0x99 /* CCAP 1 */ +#define ADV7183_CCAP_2 0x9A /* CCAP 2 */ +#define ADV7183_LETTERBOX_1 0x9B /* Letterbox 1 */ +#define ADV7183_LETTERBOX_2 0x9C /* Letterbox 2 */ +#define ADV7183_LETTERBOX_3 0x9D /* Letterbox 3 */ +#define ADV7183_CRC_EN 0xB2 /* CRC enable */ +#define ADV7183_ADC_SWITCH_1 0xC3 /* ADC switch 1 */ +#define ADV7183_ADC_SWITCH_2 0xC4 /* ADC swithc 2 */ +#define ADV7183_LETTERBOX_CTRL_1 0xDC /* Letterbox control 1 */ +#define ADV7183_LETTERBOX_CTRL_2 0xDD /* Letterbox control 2 */ +#define ADV7183_SD_OFFSET_CB 0xE1 /* SD offset Cb */ +#define ADV7183_SD_OFFSET_CR 0xE2 /* SD offset Cr */ +#define ADV7183_SD_SATURATION_CB 0xE3 /* SD saturation Cb */ +#define ADV7183_SD_SATURATION_CR 0xE4 /* SD saturation Cr */ +#define ADV7183_NTSC_V_BEGIN 0xE5 /* NTSC V bit begin */ +#define ADV7183_NTSC_V_END 0xE6 /* NTSC V bit end */ +#define ADV7183_NTSC_F_TOGGLE 0xE7 /* NTSC F bit toggle */ +#define ADV7183_PAL_V_BEGIN 0xE8 /* PAL V bit begin */ +#define ADV7183_PAL_V_END 0xE9 /* PAL V bit end */ +#define ADV7183_PAL_F_TOGGLE 0xEA /* PAL F bit toggle */ +#define ADV7183_DRIVE_STR 0xF4 /* Drive strength */ +#define ADV7183_IF_COMP_CTRL 0xF8 /* IF comp control */ +#define ADV7183_VS_MODE_CTRL 0xF9 /* VS mode control */ + +#endif diff --git a/include/media/adv7183.h b/include/media/adv7183.h new file mode 100644 index 0000000..ef99a00 --- /dev/null +++ b/include/media/adv7183.h @@ -0,0 +1,47 @@ +/* + * adv7183.h - definition for adv7183 inputs and outputs + * + * Copyright (c) 2011 Analog Devices Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _ADV7183_H_ +#define _ADV7183_H_ + +/* ADV7183 HW inputs */ +#define ADV7183_COMPOSITE0 0 /* CVBS in on AIN1 */ +#define ADV7183_COMPOSITE1 1 /* CVBS in on AIN2 */ +#define ADV7183_COMPOSITE2 2 /* CVBS in on AIN3 */ +#define ADV7183_COMPOSITE3 3 /* CVBS in on AIN4 */ +#define ADV7183_COMPOSITE4 4 /* CVBS in on AIN5 */ +#define ADV7183_COMPOSITE5 5 /* CVBS in on AIN6 */ +#define ADV7183_COMPOSITE6 6 /* CVBS in on AIN7 */ +#define ADV7183_COMPOSITE7 7 /* CVBS in on AIN8 */ +#define ADV7183_COMPOSITE8 8 /* CVBS in on AIN9 */ +#define ADV7183_COMPOSITE9 9 /* CVBS in on AIN10 */ +#define ADV7183_COMPOSITE10 10 /* CVBS in on AIN11 */ + +#define ADV7183_SVIDEO0 11 /* Y on AIN1, C on AIN4 */ +#define ADV7183_SVIDEO1 12 /* Y on AIN2, C on AIN5 */ +#define ADV7183_SVIDEO2 13 /* Y on AIN3, C on AIN6 */ + +#define ADV7183_COMPONENT0 14 /* Y on AIN1, Pr on AIN4, Pb on AIN5 */ +#define ADV7183_COMPONENT1 15 /* Y on AIN2, Pr on AIN3, Pb on AIN6 */ + +/* ADV7183 HW outputs */ +#define ADV7183_8BIT_OUT 0 +#define ADV7183_16BIT_OUT 1 + +#endif diff --git a/include/media/v4l2-chip-ident.h b/include/media/v4l2-chip-ident.h index 63fd9d3..20fd16d 100644 --- a/include/media/v4l2-chip-ident.h +++ b/include/media/v4l2-chip-ident.h @@ -162,6 +162,9 @@ enum { /* module adv7180: just ident 7180 */ V4L2_IDENT_ADV7180 = 7180, + /* module adv7183: just ident 7183 */ + V4L2_IDENT_ADV7183 = 7183, + /* module saa7185: just ident 7185 */ V4L2_IDENT_SAA7185 = 7185, -- 1.7.0.4 ^ permalink raw reply related [flat|nested] 39+ messages in thread
* Re: [uclinux-dist-devel] [PATCH 2/4] v4l2: add adv7183 decoder driver 2011-09-13 18:34 ` [PATCH 2/4] v4l2: add adv7183 decoder driver Scott Jiang @ 2011-09-14 3:05 ` Mike Frysinger 0 siblings, 0 replies; 39+ messages in thread From: Mike Frysinger @ 2011-09-14 3:05 UTC (permalink / raw) To: Scott Jiang Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski, uclinux-dist-devel, linux-media On Tue, Sep 13, 2011 at 14:34, Scott Jiang wrote: > --- /dev/null > +++ b/drivers/media/video/adv7183_regs.h > > +#define ADV7183_IN_CTRL 0x00 /* Input control */ should be a space after the #define, not a tab > --- /dev/null > +++ b/include/media/adv7183.h > > +#define ADV7183_16BIT_OUT 1 same here -mike ^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 3/4] v4l2: add vs6624 sensor driver 2011-09-13 18:34 [PATCH 1/4] v4l2: add vb2_get_unmapped_area in vb2 core Scott Jiang 2011-09-13 8:17 ` Guennadi Liakhovetski 2011-09-13 18:34 ` [PATCH 2/4] v4l2: add adv7183 decoder driver Scott Jiang @ 2011-09-13 18:34 ` Scott Jiang 2011-09-13 7:42 ` Guennadi Liakhovetski 2011-09-14 3:28 ` [uclinux-dist-devel] " Mike Frysinger 2011-09-13 18:34 ` [PATCH 4/4] v4l2: add blackfin capture bridge driver Scott Jiang 3 siblings, 2 replies; 39+ messages in thread From: Scott Jiang @ 2011-09-13 18:34 UTC (permalink / raw) To: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski Cc: linux-media, uclinux-dist-devel, Scott Jiang this is a v4l2 sensor-level driver for the ST VS6624 camera Signed-off-by: Scott Jiang <scott.jiang.linux@gmail.com> --- drivers/media/video/Kconfig | 10 + drivers/media/video/Makefile | 1 + drivers/media/video/vs6624.c | 941 +++++++++++++++++++++++++++++++++++++ drivers/media/video/vs6624_regs.h | 337 +++++++++++++ include/media/v4l2-chip-ident.h | 3 + 5 files changed, 1292 insertions(+), 0 deletions(-) create mode 100644 drivers/media/video/vs6624.c create mode 100644 drivers/media/video/vs6624_regs.h diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig index af8ed6b..1c03abf 100644 --- a/drivers/media/video/Kconfig +++ b/drivers/media/video/Kconfig @@ -477,6 +477,16 @@ config VIDEO_OV7670 OV7670 VGA camera. It currently only works with the M88ALP01 controller. +config VIDEO_VS6624 + tristate "ST VS6624 sensor support" + depends on VIDEO_V4L2 && I2C + ---help--- + This is a Video4Linux2 sensor-level driver for the ST VS6624 + camera. + + To compile this driver as a module, choose M here: the + module will be called vs6624. + config VIDEO_MT9V011 tristate "Micron mt9v011 sensor support" depends on I2C && VIDEO_V4L2 diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile index b0329ae..127eba5 100644 --- a/drivers/media/video/Makefile +++ b/drivers/media/video/Makefile @@ -42,6 +42,7 @@ obj-$(CONFIG_VIDEO_ADV7175) += adv7175.o obj-$(CONFIG_VIDEO_ADV7180) += adv7180.o obj-$(CONFIG_VIDEO_ADV7183) += adv7183.o obj-$(CONFIG_VIDEO_ADV7343) += adv7343.o +obj-$(CONFIG_VIDEO_VS6624) += vs6624.o obj-$(CONFIG_VIDEO_VPX3220) += vpx3220.o obj-$(CONFIG_VIDEO_BT819) += bt819.o obj-$(CONFIG_VIDEO_BT856) += bt856.o diff --git a/drivers/media/video/vs6624.c b/drivers/media/video/vs6624.c new file mode 100644 index 0000000..b0030ab --- /dev/null +++ b/drivers/media/video/vs6624.c @@ -0,0 +1,941 @@ +/* + * vs6624.c ST VS6624 CMOS image sensor driver + * + * Copyright (c) 2011 Analog Devices Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include <linux/module.h> +#include <linux/init.h> +#include <linux/errno.h> +#include <linux/types.h> +#include <linux/i2c.h> +#include <linux/slab.h> +#include <linux/delay.h> +#include <linux/videodev2.h> +#include <media/v4l2-device.h> +#include <media/v4l2-chip-ident.h> +#include <media/v4l2-ctrls.h> +#include <media/v4l2-mediabus.h> +#include <asm/gpio.h> +#include "vs6624_regs.h" + +#define VS6624_DEVICE_ID 624 + +#define VGA_WIDTH 640 +#define VGA_HEIGHT 480 +#define QVGA_WIDTH 320 +#define QVGA_HEIGHT 240 +#define QQVGA_WIDTH 160 +#define QQVGA_HEIGHT 120 +#define CIF_WIDTH 352 +#define CIF_HEIGHT 288 +#define QCIF_WIDTH 176 +#define QCIF_HEIGHT 144 +#define QQCIF_WIDTH 88 +#define QQCIF_HEIGHT 72 + +#define MAX_FRAME_RATE 30 + +struct vs6624 { + struct v4l2_subdev sd; + struct v4l2_ctrl_handler hdl; + struct v4l2_fract frame_rate; + struct v4l2_mbus_framefmt fmt; + unsigned ce_pin; +}; + +static const struct vs6624_format { + enum v4l2_mbus_pixelcode mbus_code; + enum v4l2_colorspace colorspace; +} vs6624_formats[] = { + { + .mbus_code = V4L2_MBUS_FMT_UYVY8_2X8, + .colorspace = V4L2_COLORSPACE_JPEG, + }, + { + .mbus_code = V4L2_MBUS_FMT_YUYV8_2X8, + .colorspace = V4L2_COLORSPACE_JPEG, + }, + { + .mbus_code = V4L2_MBUS_FMT_RGB565_2X8_LE, + .colorspace = V4L2_COLORSPACE_SRGB, + }, +}; + +static struct v4l2_mbus_framefmt vs6624_default_fmt = { + .width = VGA_WIDTH, + .height = VGA_HEIGHT, + .code = V4L2_MBUS_FMT_UYVY8_2X8, + .field = V4L2_FIELD_NONE, + .colorspace = V4L2_COLORSPACE_JPEG, +}; + +static const u16 vs6624_p1[] = { + 0x8104, 0x03, + 0x8105, 0x01, + 0xc900, 0x03, + 0xc904, 0x47, + 0xc905, 0x10, + 0xc906, 0x80, + 0xc907, 0x3a, + 0x903a, 0x02, + 0x903b, 0x47, + 0x903c, 0x15, + 0xc908, 0x31, + 0xc909, 0xdc, + 0xc90a, 0x80, + 0xc90b, 0x44, + 0x9044, 0x02, + 0x9045, 0x31, + 0x9046, 0xe2, + 0xc90c, 0x07, + 0xc90d, 0xe0, + 0xc90e, 0x80, + 0xc90f, 0x47, + 0x9047, 0x90, + 0x9048, 0x83, + 0x9049, 0x81, + 0x904a, 0xe0, + 0x904b, 0x60, + 0x904c, 0x08, + 0x904d, 0x90, + 0x904e, 0xc0, + 0x904f, 0x43, + 0x9050, 0x74, + 0x9051, 0x01, + 0x9052, 0xf0, + 0x9053, 0x80, + 0x9054, 0x05, + 0x9055, 0xE4, + 0x9056, 0x90, + 0x9057, 0xc0, + 0x9058, 0x43, + 0x9059, 0xf0, + 0x905a, 0x02, + 0x905b, 0x07, + 0x905c, 0xec, + 0xc910, 0x5d, + 0xc911, 0xca, + 0xc912, 0x80, + 0xc913, 0x5d, + 0x905d, 0xa3, + 0x905e, 0x04, + 0x905f, 0xf0, + 0x9060, 0xa3, + 0x9061, 0x04, + 0x9062, 0xf0, + 0x9063, 0x22, + 0xc914, 0x72, + 0xc915, 0x92, + 0xc916, 0x80, + 0xc917, 0x64, + 0x9064, 0x74, + 0x9065, 0x01, + 0x9066, 0x02, + 0x9067, 0x72, + 0x9068, 0x95, + 0xc918, 0x47, + 0xc919, 0xf2, + 0xc91a, 0x81, + 0xc91b, 0x69, + 0x9169, 0x74, + 0x916a, 0x02, + 0x916b, 0xf0, + 0x916c, 0xec, + 0x916d, 0xb4, + 0x916e, 0x10, + 0x916f, 0x0a, + 0x9170, 0x90, + 0x9171, 0x80, + 0x9172, 0x16, + 0x9173, 0xe0, + 0x9174, 0x70, + 0x9175, 0x04, + 0x9176, 0x90, + 0x9177, 0xd3, + 0x9178, 0xc4, + 0x9179, 0xf0, + 0x917a, 0x22, + 0xc91c, 0x0a, + 0xc91d, 0xbe, + 0xc91e, 0x80, + 0xc91f, 0x73, + 0x9073, 0xfc, + 0x9074, 0xa3, + 0x9075, 0xe0, + 0x9076, 0xf5, + 0x9077, 0x82, + 0x9078, 0x8c, + 0x9079, 0x83, + 0x907a, 0xa3, + 0x907b, 0xa3, + 0x907c, 0xe0, + 0x907d, 0xfc, + 0x907e, 0xa3, + 0x907f, 0xe0, + 0x9080, 0xc3, + 0x9081, 0x9f, + 0x9082, 0xff, + 0x9083, 0xec, + 0x9084, 0x9e, + 0x9085, 0xfe, + 0x9086, 0x02, + 0x9087, 0x0a, + 0x9088, 0xea, + 0xc920, 0x47, + 0xc921, 0x38, + 0xc922, 0x80, + 0xc923, 0x89, + 0x9089, 0xec, + 0x908a, 0xd3, + 0x908b, 0x94, + 0x908c, 0x20, + 0x908d, 0x40, + 0x908e, 0x01, + 0x908f, 0x1c, + 0x9090, 0x90, + 0x9091, 0xd3, + 0x9092, 0xd4, + 0x9093, 0xec, + 0x9094, 0xf0, + 0x9095, 0x02, + 0x9096, 0x47, + 0x9097, 0x3d, + 0xc924, 0x45, + 0xc925, 0xca, + 0xc926, 0x80, + 0xc927, 0x98, + 0x9098, 0x12, + 0x9099, 0x77, + 0x909a, 0xd6, + 0x909b, 0x02, + 0x909c, 0x45, + 0x909d, 0xcd, + 0xc928, 0x20, + 0xc929, 0xd5, + 0xc92a, 0x80, + 0xc92b, 0x9e, + 0x909e, 0x90, + 0x909f, 0x82, + 0x90a0, 0x18, + 0x90a1, 0xe0, + 0x90a2, 0xb4, + 0x90a3, 0x03, + 0x90a4, 0x0e, + 0x90a5, 0x90, + 0x90a6, 0x83, + 0x90a7, 0xbf, + 0x90a8, 0xe0, + 0x90a9, 0x60, + 0x90aa, 0x08, + 0x90ab, 0x90, + 0x90ac, 0x81, + 0x90ad, 0xfc, + 0x90ae, 0xe0, + 0x90af, 0xff, + 0x90b0, 0xc3, + 0x90b1, 0x13, + 0x90b2, 0xf0, + 0x90b3, 0x90, + 0x90b4, 0x81, + 0x90b5, 0xfc, + 0x90b6, 0xe0, + 0x90b7, 0xff, + 0x90b8, 0x02, + 0x90b9, 0x20, + 0x90ba, 0xda, + 0xc92c, 0x70, + 0xc92d, 0xbc, + 0xc92e, 0x80, + 0xc92f, 0xbb, + 0x90bb, 0x90, + 0x90bc, 0x82, + 0x90bd, 0x18, + 0x90be, 0xe0, + 0x90bf, 0xb4, + 0x90c0, 0x03, + 0x90c1, 0x06, + 0x90c2, 0x90, + 0x90c3, 0xc1, + 0x90c4, 0x06, + 0x90c5, 0x74, + 0x90c6, 0x05, + 0x90c7, 0xf0, + 0x90c8, 0x90, + 0x90c9, 0xd3, + 0x90ca, 0xa0, + 0x90cb, 0x02, + 0x90cc, 0x70, + 0x90cd, 0xbf, + 0xc930, 0x72, + 0xc931, 0x21, + 0xc932, 0x81, + 0xc933, 0x3b, + 0x913b, 0x7d, + 0x913c, 0x02, + 0x913d, 0x7f, + 0x913e, 0x7b, + 0x913f, 0x02, + 0x9140, 0x72, + 0x9141, 0x25, + 0xc934, 0x28, + 0xc935, 0xae, + 0xc936, 0x80, + 0xc937, 0xd2, + 0x90d2, 0xf0, + 0x90d3, 0x90, + 0x90d4, 0xd2, + 0x90d5, 0x0a, + 0x90d6, 0x02, + 0x90d7, 0x28, + 0x90d8, 0xb4, + 0xc938, 0x28, + 0xc939, 0xb1, + 0xc93a, 0x80, + 0xc93b, 0xd9, + 0x90d9, 0x90, + 0x90da, 0x83, + 0x90db, 0xba, + 0x90dc, 0xe0, + 0x90dd, 0xff, + 0x90de, 0x90, + 0x90df, 0xd2, + 0x90e0, 0x08, + 0x90e1, 0xe0, + 0x90e2, 0xe4, + 0x90e3, 0xef, + 0x90e4, 0xf0, + 0x90e5, 0xa3, + 0x90e6, 0xe0, + 0x90e7, 0x74, + 0x90e8, 0xff, + 0x90e9, 0xf0, + 0x90ea, 0x90, + 0x90eb, 0xd2, + 0x90ec, 0x0a, + 0x90ed, 0x02, + 0x90ee, 0x28, + 0x90ef, 0xb4, + 0xc93c, 0x29, + 0xc93d, 0x79, + 0xc93e, 0x80, + 0xc93f, 0xf0, + 0x90f0, 0xf0, + 0x90f1, 0x90, + 0x90f2, 0xd2, + 0x90f3, 0x0e, + 0x90f4, 0x02, + 0x90f5, 0x29, + 0x90f6, 0x7f, + 0xc940, 0x29, + 0xc941, 0x7c, + 0xc942, 0x80, + 0xc943, 0xf7, + 0x90f7, 0x90, + 0x90f8, 0x83, + 0x90f9, 0xba, + 0x90fa, 0xe0, + 0x90fb, 0xff, + 0x90fc, 0x90, + 0x90fd, 0xd2, + 0x90fe, 0x0c, + 0x90ff, 0xe0, + 0x9100, 0xe4, + 0x9101, 0xef, + 0x9102, 0xf0, + 0x9103, 0xa3, + 0x9104, 0xe0, + 0x9105, 0x74, + 0x9106, 0xff, + 0x9107, 0xf0, + 0x9108, 0x90, + 0x9109, 0xd2, + 0x910a, 0x0e, + 0x910b, 0x02, + 0x910c, 0x29, + 0x910d, 0x7f, + 0xc944, 0x2a, + 0xc945, 0x42, + 0xc946, 0x81, + 0xc947, 0x0e, + 0x910e, 0xf0, + 0x910f, 0x90, + 0x9110, 0xd2, + 0x9111, 0x12, + 0x9112, 0x02, + 0x9113, 0x2a, + 0x9114, 0x48, + 0xc948, 0x2a, + 0xc949, 0x45, + 0xc94a, 0x81, + 0xc94b, 0x15, + 0x9115, 0x90, + 0x9116, 0x83, + 0x9117, 0xba, + 0x9118, 0xe0, + 0x9119, 0xff, + 0x911a, 0x90, + 0x911b, 0xd2, + 0x911c, 0x10, + 0x911d, 0xe0, + 0x911e, 0xe4, + 0x911f, 0xef, + 0x9120, 0xf0, + 0x9121, 0xa3, + 0x9122, 0xe0, + 0x9123, 0x74, + 0x9124, 0xff, + 0x9125, 0xf0, + 0x9126, 0x90, + 0x9127, 0xd2, + 0x9128, 0x12, + 0x9129, 0x02, + 0x912a, 0x2a, + 0x912b, 0x48, + 0xc900, 0x01, + 0x0000, 0x00, +}; + +static const u16 vs6624_p2[] = { + 0x806f, 0x01, + 0x058c, 0x01, + 0x0000, 0x00, +}; + +static const u16 vs6624_run_setup[] = { + 0x1d18, 0x00, /* Enableconstrainedwhitebalance */ + 0x200d, 0x3c, /* Damper PeakGain Output MSB */ + 0x200e, 0x66, /* Damper PeakGain Output LSB */ + 0x1f03, 0x65, /* Damper Low MSB */ + 0x1f04, 0xd1, /* Damper Low LSB */ + 0x1f07, 0x66, /* Damper High MSB */ + 0x1f08, 0x62, /* Damper High LSB */ + 0x1f0b, 0x00, /* Damper Min output MSB */ + 0x1f0c, 0x00, /* Damper Min output LSB */ + 0x2600, 0x00, /* Nora fDisable */ + 0x2602, 0x04, /* Nora usage */ + 0x260d, 0x63, /* Damper Low MSB Changed 0x63 to 0x65 */ + 0x260e, 0xd1, /* Damper Low LSB */ + 0x2611, 0x68, /* Damper High MSB */ + 0x2612, 0xdd, /* Damper High LSB */ + 0x2615, 0x3a, /* Damper Min output MSB */ + 0x2616, 0x00, /* Damper Min output LSB */ + 0x2480, 0x00, /* Disable */ + 0x1d8a, 0x30, /* MAXWeightHigh */ + 0x1d91, 0x62, /* fpDamperLowThresholdHigh MSB */ + 0x1d92, 0x4a, /* fpDamperLowThresholdHigh LSB */ + 0x1d95, 0x65, /* fpDamperHighThresholdHigh MSB */ + 0x1d96, 0x0e, /* fpDamperHighThresholdHigh LSB */ + 0x1da1, 0x3a, /* fpMinimumDamperOutputLow MSB */ + 0x1da2, 0xb8, /* fpMinimumDamperOutputLow LSB */ + 0x1e08, 0x06, /* MAXWeightLow */ + 0x1e0a, 0x0a, /* MAXWeightHigh */ + 0x1601, 0x3a, /* Red A MSB */ + 0x1602, 0x14, /* Red A LSB */ + 0x1605, 0x3b, /* Blue A MSB */ + 0x1606, 0x85, /* BLue A LSB */ + 0x1609, 0x3b, /* RED B MSB */ + 0x160a, 0x85, /* RED B LSB */ + 0x160d, 0x3a, /* Blue B MSB */ + 0x160e, 0x14, /* Blue B LSB */ + 0x1611, 0x30, /* Max Distance from Locus MSB */ + 0x1612, 0x8f, /* Max Distance from Locus MSB */ + 0x1614, 0x01, /* Enable constrainer */ + 0x0000, 0x00, +}; + +static const u16 vs6624_default[] = { + VS6624_CONTRAST0, 0x84, + VS6624_SATURATION0, 0x75, + VS6624_GAMMA0, 0x11, + VS6624_CONTRAST1, 0x84, + VS6624_SATURATION1, 0x75, + VS6624_GAMMA1, 0x11, + VS6624_MAN_RG, 0x80, + VS6624_MAN_GG, 0x80, + VS6624_MAN_BG, 0x80, + VS6624_WB_MODE, 0x1, + VS6624_EXPO_COMPENSATION, 0xfe, + VS6624_EXPO_METER, 0x0, + VS6624_LIGHT_FREQ, 0x64, + VS6624_PEAK_GAIN, 0xe, + VS6624_PEAK_LOW_THR, 0x28, + VS6624_HMIRROR0, 0x0, + VS6624_VFLIP0, 0x0, + VS6624_ZOOM_HSTEP0_MSB, 0x0, + VS6624_ZOOM_HSTEP0_LSB, 0x1, + VS6624_ZOOM_VSTEP0_MSB, 0x0, + VS6624_ZOOM_VSTEP0_LSB, 0x1, + VS6624_PAN_HSTEP0_MSB, 0x0, + VS6624_PAN_HSTEP0_LSB, 0xf, + VS6624_PAN_VSTEP0_MSB, 0x0, + VS6624_PAN_VSTEP0_LSB, 0xf, + VS6624_SENSOR_MODE, 0x1, + VS6624_SYNC_CODE_SETUP, 0x21, + VS6624_DISABLE_FR_DAMPER, 0x0, + VS6624_FR_DEN, 0x1, + VS6624_FR_NUM_LSB, 0xf, + VS6624_INIT_PIPE_SETUP, 0x0, + VS6624_IMG_FMT0, 0x0, + VS6624_YUV_SETUP, 0x1, + VS6624_IMAGE_SIZE0, 0x2, + 0x0000, 0x00, +}; + +static inline struct vs6624 *to_vs6624(struct v4l2_subdev *sd) +{ + return container_of(sd, struct vs6624, sd); +} +static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl) +{ + return &container_of(ctrl->handler, struct vs6624, hdl)->sd; +} + +static inline int vs6624_read(struct v4l2_subdev *sd, u16 index) +{ + struct i2c_client *client = v4l2_get_subdevdata(sd); + u8 buf[2]; + + buf[0] = index >> 8; + buf[1] = index; + i2c_master_send(client, buf, 2); + i2c_master_recv(client, buf, 1); + + return buf[0]; +} + +static inline int vs6624_write(struct v4l2_subdev *sd, u16 index, + u8 value) +{ + struct i2c_client *client = v4l2_get_subdevdata(sd); + u8 buf[3]; + + buf[0] = index >> 8; + buf[1] = index; + buf[2] = value; + + return i2c_master_send(client, buf, 3); +} + +static int vs6624_writeregs(struct v4l2_subdev *sd, const u16 *regs) +{ + u16 reg, data; + + while (*regs != 0x00) { + reg = *regs++; + data = *regs++; + + vs6624_write(sd, reg, (u8)data); + } + return 0; +} + +static int vs6624_s_ctrl(struct v4l2_ctrl *ctrl) +{ + struct v4l2_subdev *sd = to_sd(ctrl); + + switch (ctrl->id) { + case V4L2_CID_CONTRAST: + vs6624_write(sd, VS6624_CONTRAST0, ctrl->val); + break; + case V4L2_CID_SATURATION: + vs6624_write(sd, VS6624_SATURATION0, ctrl->val); + break; + case V4L2_CID_HFLIP: + vs6624_write(sd, VS6624_HMIRROR0, ctrl->val); + break; + case V4L2_CID_VFLIP: + vs6624_write(sd, VS6624_VFLIP0, ctrl->val); + break; + default: + return -EINVAL; + } + + return 0; +} + +static int vs6624_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned index, + enum v4l2_mbus_pixelcode *code) +{ + if (index >= ARRAY_SIZE(vs6624_formats)) + return -EINVAL; + + *code = vs6624_formats[index].mbus_code; + return 0; +} + +static int vs6624_try_mbus_fmt(struct v4l2_subdev *sd, + struct v4l2_mbus_framefmt *fmt) +{ + int index; + + for (index = 0; index < ARRAY_SIZE(vs6624_formats); index++) + if (vs6624_formats[index].mbus_code == fmt->code) + break; + if (index >= ARRAY_SIZE(vs6624_formats)) { + /* default to first format */ + index = 0; + fmt->code = vs6624_formats[0].mbus_code; + } + + /* sensor mode is VGA */ + if (fmt->width > VGA_WIDTH) + fmt->width = VGA_WIDTH; + if (fmt->height > VGA_HEIGHT) + fmt->height = VGA_HEIGHT; + fmt->width = fmt->width & (~3); + fmt->height = fmt->height & (~3); + fmt->field = V4L2_FIELD_NONE; + fmt->colorspace = vs6624_formats[index].colorspace; + return 0; +} + +static int vs6624_s_mbus_fmt(struct v4l2_subdev *sd, + struct v4l2_mbus_framefmt *fmt) +{ + struct vs6624 *sensor = to_vs6624(sd); + int ret; + + ret = vs6624_try_mbus_fmt(sd, fmt); + if (ret) + return ret; + + /* set image format */ + switch (fmt->code) { + case V4L2_MBUS_FMT_UYVY8_2X8: + vs6624_write(sd, VS6624_IMG_FMT0, 0x0); + vs6624_write(sd, VS6624_YUV_SETUP, 0x1); + break; + case V4L2_MBUS_FMT_YUYV8_2X8: + vs6624_write(sd, VS6624_IMG_FMT0, 0x0); + vs6624_write(sd, VS6624_YUV_SETUP, 0x3); + break; + case V4L2_MBUS_FMT_RGB565_2X8_LE: + vs6624_write(sd, VS6624_IMG_FMT0, 0x4); + vs6624_write(sd, VS6624_RGB_SETUP, 0x0); + break; + default: + return -EINVAL; + } + + /* set image size */ + if ((fmt->width == VGA_WIDTH) && (fmt->height == VGA_HEIGHT)) + vs6624_write(sd, VS6624_IMAGE_SIZE0, 0x2); + else if ((fmt->width == QVGA_WIDTH) && (fmt->height == QVGA_HEIGHT)) + vs6624_write(sd, VS6624_IMAGE_SIZE0, 0x4); + else if ((fmt->width == QQVGA_WIDTH) && (fmt->height == QQVGA_HEIGHT)) + vs6624_write(sd, VS6624_IMAGE_SIZE0, 0x6); + else if ((fmt->width == CIF_WIDTH) && (fmt->height == CIF_HEIGHT)) + vs6624_write(sd, VS6624_IMAGE_SIZE0, 0x3); + else if ((fmt->width == QCIF_WIDTH) && (fmt->height == QCIF_HEIGHT)) + vs6624_write(sd, VS6624_IMAGE_SIZE0, 0x5); + else if ((fmt->width == QQCIF_WIDTH) && (fmt->height == QQCIF_HEIGHT)) + vs6624_write(sd, VS6624_IMAGE_SIZE0, 0x7); + else { + vs6624_write(sd, VS6624_IMAGE_SIZE0, 0x8); + vs6624_write(sd, VS6624_MAN_HSIZE0_MSB, fmt->width >> 8); + vs6624_write(sd, VS6624_MAN_HSIZE0_LSB, fmt->width & 0xFF); + vs6624_write(sd, VS6624_MAN_VSIZE0_MSB, fmt->height >> 8); + vs6624_write(sd, VS6624_MAN_VSIZE0_LSB, fmt->height & 0xFF); + vs6624_write(sd, VS6624_CROP_CTRL0, 0x1); + } + + sensor->fmt = *fmt; + + return 0; +} + +static int vs6624_g_mbus_fmt(struct v4l2_subdev *sd, + struct v4l2_mbus_framefmt *fmt) +{ + struct vs6624 *sensor = to_vs6624(sd); + + *fmt = sensor->fmt; + return 0; +} + +static int vs6624_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms) +{ + struct vs6624 *sensor = to_vs6624(sd); + struct v4l2_captureparm *cp = &parms->parm.capture; + + if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) + return -EINVAL; + + memset(cp, 0, sizeof(*cp)); + cp->capability = V4L2_CAP_TIMEPERFRAME; + cp->timeperframe.numerator = sensor->frame_rate.denominator; + cp->timeperframe.denominator = sensor->frame_rate.numerator; + return 0; +} + +static int vs6624_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms) +{ + struct vs6624 *sensor = to_vs6624(sd); + struct v4l2_captureparm *cp = &parms->parm.capture; + struct v4l2_fract *tpf = &cp->timeperframe; + + if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) + return -EINVAL; + if (cp->extendedmode != 0) + return -EINVAL; + + if (tpf->numerator == 0 || tpf->denominator == 0 + || (tpf->denominator > tpf->numerator * MAX_FRAME_RATE)) { + /* reset to max frame rate */ + tpf->numerator = 1; + tpf->denominator = MAX_FRAME_RATE; + } + sensor->frame_rate.numerator = tpf->denominator; + sensor->frame_rate.denominator = tpf->numerator; + vs6624_write(sd, VS6624_DISABLE_FR_DAMPER, 0x0); + vs6624_write(sd, VS6624_FR_NUM_MSB, + sensor->frame_rate.numerator >> 8); + vs6624_write(sd, VS6624_FR_NUM_LSB, + sensor->frame_rate.numerator & 0xFF); + vs6624_write(sd, VS6624_FR_DEN, + sensor->frame_rate.denominator & 0xFF); + return 0; +} + +static int vs6624_s_stream(struct v4l2_subdev *sd, int enable) +{ + if (enable) + vs6624_write(sd, VS6624_USER_CMD, 0x2); + else + vs6624_write(sd, VS6624_USER_CMD, 0x4); + udelay(100); + return 0; +} + +static int vs6624_g_chip_ident(struct v4l2_subdev *sd, + struct v4l2_dbg_chip_ident *chip) +{ + int rev; + struct i2c_client *client = v4l2_get_subdevdata(sd); + + rev = vs6624_read(sd, VS6624_FW_VSN_MAJOR) << 8 + | vs6624_read(sd, VS6624_FW_VSN_MINOR); + + return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_VS6624, rev); +} + +#ifdef CONFIG_VIDEO_ADV_DEBUG +static int vs6624_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg) +{ + struct i2c_client *client = v4l2_get_subdevdata(sd); + + if (!v4l2_chip_match_i2c_client(client, ®->match)) + return -EINVAL; + if (!capable(CAP_SYS_ADMIN)) + return -EPERM; + reg->val = vs6624_read(sd, reg->reg & 0xffff); + reg->size = 1; + return 0; +} + +static int vs6624_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg) +{ + struct i2c_client *client = v4l2_get_subdevdata(sd); + + if (!v4l2_chip_match_i2c_client(client, ®->match)) + return -EINVAL; + if (!capable(CAP_SYS_ADMIN)) + return -EPERM; + vs6624_write(sd, reg->reg & 0xffff, reg->val & 0xff); + return 0; +} +#endif + +static const struct v4l2_ctrl_ops vs6624_ctrl_ops = { + .s_ctrl = vs6624_s_ctrl, +}; + +static const struct v4l2_subdev_core_ops vs6624_core_ops = { + .g_chip_ident = vs6624_g_chip_ident, + .g_ext_ctrls = v4l2_subdev_g_ext_ctrls, + .try_ext_ctrls = v4l2_subdev_try_ext_ctrls, + .s_ext_ctrls = v4l2_subdev_s_ext_ctrls, + .g_ctrl = v4l2_subdev_g_ctrl, + .s_ctrl = v4l2_subdev_s_ctrl, + .queryctrl = v4l2_subdev_queryctrl, + .querymenu = v4l2_subdev_querymenu, +#ifdef CONFIG_VIDEO_ADV_DEBUG + .g_register = vs6624_g_register, + .s_register = vs6624_s_register, +#endif +}; + +static const struct v4l2_subdev_video_ops vs6624_video_ops = { + .enum_mbus_fmt = vs6624_enum_mbus_fmt, + .try_mbus_fmt = vs6624_try_mbus_fmt, + .s_mbus_fmt = vs6624_s_mbus_fmt, + .g_mbus_fmt = vs6624_g_mbus_fmt, + .s_parm = vs6624_s_parm, + .g_parm = vs6624_g_parm, + .s_stream = vs6624_s_stream, +}; + +static const struct v4l2_subdev_ops vs6624_ops = { + .core = &vs6624_core_ops, + .video = &vs6624_video_ops, +}; + +static int __devinit vs6624_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct vs6624 *sensor; + struct v4l2_subdev *sd; + struct v4l2_ctrl_handler *hdl; + u16 device_id; + const unsigned *ce; + int ret; + + /* Check if the adapter supports the needed features */ + if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) + return -EIO; + + ce = client->dev.platform_data; + if (ce == NULL) + return -EINVAL; + + ret = gpio_request(*ce, "VS6624 Chip Enable"); + if (ret) { + v4l_err(client, "failed to request GPIO %d\n", *ce); + return ret; + } + gpio_direction_output(*ce, 1); + /* wait 100ms before any further i2c writes are performed */ + mdelay(100); + + sensor = kzalloc(sizeof(*sensor), GFP_KERNEL); + if (sensor == NULL) { + gpio_free(*ce); + return -ENOMEM; + } + + sd = &sensor->sd; + v4l2_i2c_subdev_init(sd, client, &vs6624_ops); + + vs6624_writeregs(sd, vs6624_p1); + vs6624_write(sd, VS6624_MICRO_EN, 0x2); + vs6624_write(sd, VS6624_DIO_EN, 0x1); + mdelay(10); + vs6624_writeregs(sd, vs6624_p2); + + /* make sure the sensor is vs6624 */ + device_id = vs6624_read(sd, VS6624_DEV_ID_MSB) << 8 + | vs6624_read(sd, VS6624_DEV_ID_LSB); + if (device_id != VS6624_DEVICE_ID) { + v4l_info(client, "chip found @ 0x%02x (%s) is not vs6624\n", + client->addr << 1, client->adapter->name); + kfree(sensor); + gpio_free(*ce); + return -ENODEV; + } + + vs6624_writeregs(sd, vs6624_default); + vs6624_write(sd, VS6624_HSYNC_SETUP, 0xF); + vs6624_writeregs(sd, vs6624_run_setup); + + /* set frame rate */ + sensor->frame_rate.numerator = MAX_FRAME_RATE; + sensor->frame_rate.denominator = 1; + vs6624_write(sd, VS6624_DISABLE_FR_DAMPER, 0x0); + vs6624_write(sd, VS6624_FR_NUM_MSB, + sensor->frame_rate.numerator >> 8); + vs6624_write(sd, VS6624_FR_NUM_LSB, + sensor->frame_rate.numerator & 0xFF); + vs6624_write(sd, VS6624_FR_DEN, + sensor->frame_rate.denominator & 0xFF); + + sensor->fmt = vs6624_default_fmt; + sensor->ce_pin = *ce; + + v4l_info(client, "chip found @ 0x%02x (%s)\n", + client->addr << 1, client->adapter->name); + + hdl = &sensor->hdl; + v4l2_ctrl_handler_init(hdl, 4); + v4l2_ctrl_new_std(hdl, &vs6624_ctrl_ops, + V4L2_CID_CONTRAST, 0, 0xFF, 1, 0x87); + v4l2_ctrl_new_std(hdl, &vs6624_ctrl_ops, + V4L2_CID_SATURATION, 0, 0xFF, 1, 0x78); + v4l2_ctrl_new_std(hdl, &vs6624_ctrl_ops, + V4L2_CID_HFLIP, 0, 1, 1, 0); + v4l2_ctrl_new_std(hdl, &vs6624_ctrl_ops, + V4L2_CID_VFLIP, 0, 1, 1, 0); + /* hook the control handler into the driver */ + sd->ctrl_handler = hdl; + if (hdl->error) { + int err = hdl->error; + + v4l2_ctrl_handler_free(hdl); + kfree(sensor); + gpio_free(*ce); + return err; + } + + /* initialize the hardware to the default control values */ + v4l2_ctrl_handler_setup(hdl); + return 0; +} + +static int __devexit vs6624_remove(struct i2c_client *client) +{ + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct vs6624 *sensor = to_vs6624(sd); + + v4l2_device_unregister_subdev(sd); + v4l2_ctrl_handler_free(sd->ctrl_handler); + gpio_free(sensor->ce_pin); + kfree(sensor); + return 0; +} + +static const struct i2c_device_id vs6624_id[] = { + {"vs6624", 0}, + {}, +}; + +MODULE_DEVICE_TABLE(i2c, vs6624_id); + +static struct i2c_driver vs6624_driver = { + .driver = { + .owner = THIS_MODULE, + .name = "vs6624", + }, + .probe = vs6624_probe, + .remove = __devexit_p(vs6624_remove), + .id_table = vs6624_id, +}; + +static __init int vs6624_init(void) +{ + return i2c_add_driver(&vs6624_driver); +} + +static __exit void vs6624_exit(void) +{ + i2c_del_driver(&vs6624_driver); +} + +module_init(vs6624_init); +module_exit(vs6624_exit); + +MODULE_DESCRIPTION("VS6624 sensor driver"); +MODULE_AUTHOR("Scott Jiang <Scott.Jiang.Linux@gmail.com>"); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/media/video/vs6624_regs.h b/drivers/media/video/vs6624_regs.h new file mode 100644 index 0000000..6ba2ee2 --- /dev/null +++ b/drivers/media/video/vs6624_regs.h @@ -0,0 +1,337 @@ +/* + * vs6624 - ST VS6624 CMOS image sensor registers + * + * Copyright (c) 2011 Analog Devices Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef _VS6624_REGS_H_ +#define _VS6624_REGS_H_ + +/* low level control registers */ +#define VS6624_MICRO_EN 0xC003 /* power enable for all MCU clock */ +#define VS6624_DIO_EN 0xC044 /* enable digital I/O */ +/* device parameters */ +#define VS6624_DEV_ID_MSB 0x0001 /* device id MSB */ +#define VS6624_DEV_ID_LSB 0x0002 /* device id LSB */ +#define VS6624_FW_VSN_MAJOR 0x0004 /* firmware version major */ +#define VS6624_FW_VSN_MINOR 0x0006 /* firmware version minor */ +#define VS6624_PATCH_VSN_MAJOR 0x0008 /* patch version major */ +#define VS6624_PATCH_VSN_MINOR 0x000A /* patch version minor */ +/* host interface manager control */ +#define VS6624_USER_CMD 0x0180 /* user level control of operating states */ +/* host interface manager status */ +#define VS6624_STATE 0x0202 /* current state of the mode manager */ +/* run mode control */ +#define VS6624_METER_ON 0x0280 /* if false AE and AWB are disabled */ +/* mode setup */ +#define VS6624_ACTIVE_PIPE_SETUP 0x0302 /* select the active bank for non view live mode */ +#define VS6624_SENSOR_MODE 0x0308 /* select the different sensor mode */ +/* pipe setup bank0 */ +#define VS6624_IMAGE_SIZE0 0x0380 /* required output dimension */ +#define VS6624_MAN_HSIZE0_MSB 0x0383 /* input required manual H size MSB */ +#define VS6624_MAN_HSIZE0_LSB 0x0384 /* input required manual H size LSB */ +#define VS6624_MAN_VSIZE0_MSB 0x0387 /* input required manual V size MSB */ +#define VS6624_MAN_VSIZE0_LSB 0x0388 /* input required manual V size LSB */ +#define VS6624_ZOOM_HSTEP0_MSB 0x038B /* set the zoom H step MSB */ +#define VS6624_ZOOM_HSTEP0_LSB 0x038C /* set the zoom H step LSB */ +#define VS6624_ZOOM_VSTEP0_MSB 0x038F /* set the zoom V step MSB */ +#define VS6624_ZOOM_VSTEP0_LSB 0x0390 /* set the zoom V step LSB */ +#define VS6624_ZOOM_CTRL0 0x0392 /* control zoon in, out and stop */ +#define VS6624_PAN_HSTEP0_MSB 0x0395 /* set the pan H step MSB */ +#define VS6624_PAN_HSTEP0_LSB 0x0396 /* set the pan H step LSB */ +#define VS6624_PAN_VSTEP0_MSB 0x0399 /* set the pan V step MSB */ +#define VS6624_PAN_VSTEP0_LSB 0x039A /* set the pan V step LSB */ +#define VS6624_PAN_CTRL0 0x039C /* control pan operation */ +#define VS6624_CROP_CTRL0 0x039E /* select cropping mode */ +#define VS6624_CROP_HSTART0_MSB 0x03A1 /* set the cropping H start address MSB */ +#define VS6624_CROP_HSTART0_LSB 0x03A2 /* set the cropping H start address LSB */ +#define VS6624_CROP_HSIZE0_MSB 0x03A5 /* set the cropping H size MSB */ +#define VS6624_CROP_HSIZE0_LSB 0x03A6 /* set the cropping H size LSB */ +#define VS6624_CROP_VSTART0_MSB 0x03A9 /* set the cropping V start address MSB */ +#define VS6624_CROP_VSTART0_LSB 0x03AA /* set the cropping V start address LSB */ +#define VS6624_CROP_VSIZE0_MSB 0x03AD /* set the cropping V size MSB */ +#define VS6624_CROP_VSIZE0_LSB 0x03AE /* set the cropping V size LSB */ +#define VS6624_IMG_FMT0 0x03B0 /* select required output image format */ +#define VS6624_BAYER_OUT_ALIGN0 0x03B2 /* set bayer output alignment */ +#define VS6624_CONTRAST0 0x03B4 /* contrast control for output */ +#define VS6624_SATURATION0 0x03B6 /* saturation control for output */ +#define VS6624_GAMMA0 0x03B8 /* gamma settings */ +#define VS6624_HMIRROR0 0x03BA /* horizontal image orientation flip */ +#define VS6624_VFLIP0 0x03BC /* vertical image orientation flip */ +#define VS6624_CHANNEL_ID0 0x03BE /* logical DMA channel number */ +/* pipe setup bank1 */ +#define VS6624_IMAGE_SIZE1 0x0400 /* required output dimension */ +#define VS6624_MAN_HSIZE1_MSB 0x0403 /* input required manual H size MSB */ +#define VS6624_MAN_HSIZE1_LSB 0x0404 /* input required manual H size LSB */ +#define VS6624_MAN_VSIZE1_MSB 0x0407 /* input required manual V size MSB */ +#define VS6624_MAN_VSIZE1_LSB 0x0408 /* input required manual V size LSB */ +#define VS6624_ZOOM_HSTEP1_MSB 0x040B /* set the zoom H step MSB */ +#define VS6624_ZOOM_HSTEP1_LSB 0x040C /* set the zoom H step LSB */ +#define VS6624_ZOOM_VSTEP1_MSB 0x040F /* set the zoom V step MSB */ +#define VS6624_ZOOM_VSTEP1_LSB 0x0410 /* set the zoom V step LSB */ +#define VS6624_ZOOM_CTRL1 0x0412 /* control zoon in, out and stop */ +#define VS6624_PAN_HSTEP1_MSB 0x0415 /* set the pan H step MSB */ +#define VS6624_PAN_HSTEP1_LSB 0x0416 /* set the pan H step LSB */ +#define VS6624_PAN_VSTEP1_MSB 0x0419 /* set the pan V step MSB */ +#define VS6624_PAN_VSTEP1_LSB 0x041A /* set the pan V step LSB */ +#define VS6624_PAN_CTRL1 0x041C /* control pan operation */ +#define VS6624_CROP_CTRL1 0x041E /* select cropping mode */ +#define VS6624_CROP_HSTART1_MSB 0x0421 /* set the cropping H start address MSB */ +#define VS6624_CROP_HSTART1_LSB 0x0422 /* set the cropping H start address LSB */ +#define VS6624_CROP_HSIZE1_MSB 0x0425 /* set the cropping H size MSB */ +#define VS6624_CROP_HSIZE1_LSB 0x0426 /* set the cropping H size LSB */ +#define VS6624_CROP_VSTART1_MSB 0x0429 /* set the cropping V start address MSB */ +#define VS6624_CROP_VSTART1_LSB 0x042A /* set the cropping V start address LSB */ +#define VS6624_CROP_VSIZE1_MSB 0x042D /* set the cropping V size MSB */ +#define VS6624_CROP_VSIZE1_LSB 0x042E /* set the cropping V size LSB */ +#define VS6624_IMG_FMT1 0x0430 /* select required output image format */ +#define VS6624_BAYER_OUT_ALIGN1 0x0432 /* set bayer output alignment */ +#define VS6624_CONTRAST1 0x0434 /* contrast control for output */ +#define VS6624_SATURATION1 0x0436 /* saturation control for output */ +#define VS6624_GAMMA1 0x0438 /* gamma settings */ +#define VS6624_HMIRROR1 0x043A /* horizontal image orientation flip */ +#define VS6624_VFLIP1 0x043C /* vertical image orientation flip */ +#define VS6624_CHANNEL_ID1 0x043E /* logical DMA channel number */ +/* view live control */ +#define VS6624_VIEW_LIVE_EN 0x0480 /* enable view live mode */ +#define VS6624_INIT_PIPE_SETUP 0x0482 /* select initial pipe setup bank */ +/* view live status */ +#define VS6624_CUR_PIPE_SETUP 0x0500 /* indicates most recently applied setup bank */ +/* power management */ +#define VS6624_TIME_TO_POWER_DOWN 0x0580 /* automatically transition time to stop mode */ +/* video timing parameter host inputs */ +#define VS6624_EXT_CLK_FREQ_NUM_MSB 0x0605 /* external clock frequency numerator MSB */ +#define VS6624_EXT_CLK_FREQ_NUM_LSB 0x0606 /* external clock frequency numerator LSB */ +#define VS6624_EXT_CLK_FREQ_DEN 0x0608 /* external clock frequency denominator */ +/* video timing control */ +#define VS6624_SYS_CLK_MODE 0x0880 /* decides system clock frequency */ +/* frame dimension parameter host inputs */ +#define VS6624_LIGHT_FREQ 0x0C80 /* AC frequency used for flicker free time */ +#define VS6624_FLICKER_COMPAT 0x0C82 /* flicker compatible frame length */ +/* static frame rate control */ +#define VS6624_FR_NUM_MSB 0x0D81 /* desired frame rate numerator MSB */ +#define VS6624_FR_NUM_LSB 0x0D82 /* desired frame rate numerator LSB */ +#define VS6624_FR_DEN 0x0D84 /* desired frame rate denominator */ +/* automatic frame rate control */ +#define VS6624_DISABLE_FR_DAMPER 0x0E80 /* defines frame rate mode */ +#define VS6624_MIN_DAMPER_OUT_MSB 0x0E8C /* minimum frame rate MSB */ +#define VS6624_MIN_DAMPER_OUT_LSB 0x0E8A /* minimum frame rate LSB */ +/* exposure controls */ +#define VS6624_EXPO_MODE 0x1180 /* exposure mode */ +#define VS6624_EXPO_METER 0x1182 /* weights to be associated with the zones */ +#define VS6624_EXPO_TIME_NUM 0x1184 /* exposure time numerator */ +#define VS6624_EXPO_TIME_DEN 0x1186 /* exposure time denominator */ +#define VS6624_EXPO_TIME_MSB 0x1189 /* exposure time for the Manual Mode MSB */ +#define VS6624_EXPO_TIME_LSB 0x118A /* exposure time for the Manual Mode LSB */ +#define VS6624_EXPO_COMPENSATION 0x1190 /* exposure compensation */ +#define VS6624_DIRECT_COARSE_MSB 0x1195 /* coarse integration lines for Direct Mode MSB */ +#define VS6624_DIRECT_COARSE_LSB 0x1196 /* coarse integration lines for Direct Mode LSB */ +#define VS6624_DIRECT_FINE_MSB 0x1199 /* fine integration pixels for Direct Mode MSB */ +#define VS6624_DIRECT_FINE_LSB 0x119A /* fine integration pixels for Direct Mode LSB */ +#define VS6624_DIRECT_ANAL_GAIN_MSB 0x119D /* analog gain for Direct Mode MSB */ +#define VS6624_DIRECT_ANAL_GAIN_LSB 0x119E /* analog gain for Direct Mode LSB */ +#define VS6624_DIRECT_DIGI_GAIN_MSB 0x11A1 /* digital gain for Direct Mode MSB */ +#define VS6624_DIRECT_DIGI_GAIN_LSB 0x11A2 /* digital gain for Direct Mode LSB */ +#define VS6624_FLASH_COARSE_MSB 0x11A5 /* coarse integration lines for Flash Gun Mode MSB */ +#define VS6624_FLASH_COARSE_LSB 0x11A6 /* coarse integration lines for Flash Gun Mode LSB */ +#define VS6624_FLASH_FINE_MSB 0x11A9 /* fine integration pixels for Flash Gun Mode MSB */ +#define VS6624_FLASH_FINE_LSB 0x11AA /* fine integration pixels for Flash Gun Mode LSB */ +#define VS6624_FLASH_ANAL_GAIN_MSB 0x11AD /* analog gain for Flash Gun Mode MSB */ +#define VS6624_FLASH_ANAL_GAIN_LSB 0x11AE /* analog gain for Flash Gun Mode LSB */ +#define VS6624_FLASH_DIGI_GAIN_MSB 0x11B1 /* digital gain for Flash Gun Mode MSB */ +#define VS6624_FLASH_DIGI_GAIN_LSB 0x11B2 /* digital gain for Flash Gun Mode LSB */ +#define VS6624_FREEZE_AE 0x11B4 /* freeze auto exposure */ +#define VS6624_MAX_INT_TIME_MSB 0x11B7 /* user maximum integration time MSB */ +#define VS6624_MAX_INT_TIME_LSB 0x11B8 /* user maximum integration time LSB */ +#define VS6624_FLASH_AG_THR_MSB 0x11BB /* recommend flash gun analog gain threshold MSB */ +#define VS6624_FLASH_AG_THR_LSB 0x11BC /* recommend flash gun analog gain threshold LSB */ +#define VS6624_ANTI_FLICKER_MODE 0x11C0 /* anti flicker mode */ +/* white balance control */ +#define VS6624_WB_MODE 0x1480 /* set white balance mode */ +#define VS6624_MAN_RG 0x1482 /* user setting for red channel gain */ +#define VS6624_MAN_GG 0x1484 /* user setting for green channel gain */ +#define VS6624_MAN_BG 0x1486 /* user setting for blue channel gain */ +#define VS6624_FLASH_RG_MSB 0x148B /* red gain for Flash Gun MSB */ +#define VS6624_FLASH_RG_LSB 0x148C /* red gain for Flash Gun LSB */ +#define VS6624_FLASH_GG_MSB 0x148F /* green gain for Flash Gun MSB */ +#define VS6624_FLASH_GG_LSB 0x1490 /* green gain for Flash Gun LSB */ +#define VS6624_FLASH_BG_MSB 0x1493 /* blue gain for Flash Gun MSB */ +#define VS6624_FLASH_BG_LSB 0x1494 /* blue gain for Flash Gun LSB */ +/* sensor setup */ +#define VS6624_BC_OFFSET 0x1990 /* Black Correction Offset */ +/* image stability */ +#define VS6624_STABLE_WB 0x1900 /* white balance stable */ +#define VS6624_STABLE_EXPO 0x1902 /* exposure stable */ +#define VS6624_STABLE 0x1906 /* system stable */ +/* flash control */ +#define VS6624_FLASH_MODE 0x1A80 /* flash mode */ +#define VS6624_FLASH_OFF_LINE_MSB 0x1A83 /* off line at flash pulse mode MSB */ +#define VS6624_FLASH_OFF_LINE_LSB 0x1A84 /* off line at flash pulse mode LSB */ +/* flash status */ +#define VS6624_FLASH_RECOM 0x1B00 /* flash gun is recommended */ +#define VS6624_FLASH_GRAB_COMPLETE 0x1B02 /* flash gun image has been grabbed */ +/* scythe filter controls */ +#define VS6624_SCYTHE_FILTER 0x1D80 /* disable scythe defect correction */ +/* jack filter controls */ +#define VS6624_JACK_FILTER 0x1E00 /* disable jack defect correction */ +/* demosaic control */ +#define VS6624_ANTI_ALIAS_FILTER 0x1E80 /* anti alias filter suppress */ +/* color matrix dampers */ +#define VS6624_CM_DISABLE 0x1F00 /* disable color matrix damper */ +#define VS6624_CM_LOW_THR_MSB 0x1F03 /* low threshold for exposure MSB */ +#define VS6624_CM_LOW_THR_LSB 0x1F04 /* low threshold for exposure LSB */ +#define VS6624_CM_HIGH_THR_MSB 0x1F07 /* high threshold for exposure MSB */ +#define VS6624_CM_HIGH_THR_LSB 0x1F08 /* high threshold for exposure LSB */ +#define VS6624_CM_MIN_OUT_MSB 0x1F0B /* minimum possible damper output MSB */ +#define VS6624_CM_MIN_OUT_LSB 0x1F0C /* minimum possible damper output LSB */ +/* peaking control */ +#define VS6624_PEAK_GAIN 0x2000 /* controls peaking gain */ +#define VS6624_PEAK_G_DISABLE 0x2002 /* disable peak gain damping */ +#define VS6624_PEAK_LOW_THR_G_MSB 0x2005 /* low threshold for exposure for gain MSB */ +#define VS6624_PEAK_LOW_THR_G_LSB 0x2006 /* low threshold for exposure for gain LSB */ +#define VS6624_PEAK_HIGH_THR_G_MSB 0x2009 /* high threshold for exposure for gain MSB */ +#define VS6624_PEAK_HIGH_THR_G_LSB 0x200A /* high threshold for exposure for gain LSB */ +#define VS6624_PEAK_MIN_OUT_G_MSB 0x200D /* minimum damper output for gain MSB */ +#define VS6624_PEAK_MIN_OUT_G_LSB 0x200E /* minimum damper output for gain LSB */ +#define VS6624_PEAK_LOW_THR 0x2010 /* adjust degree of coring */ +#define VS6624_PEAK_C_DISABLE 0x2012 /* disable coring damping */ +#define VS6624_PEAK_HIGH_THR 0x2014 /* adjust maximum gain */ +#define VS6624_PEAK_LOW_THR_C_MSB 0x2017 /* low threshold for exposure for coring MSB */ +#define VS6624_PEAK_LOW_THR_C_LSB 0x2018 /* low threshold for exposure for coring LSB */ +#define VS6624_PEAK_HIGH_THR_C_MSB 0x201B /* high threshold for exposure for coring MSB */ +#define VS6624_PEAK_HIGH_THR_C_LSB 0x201C /* high threshold for exposure for coring LSB */ +#define VS6624_PEAK_MIN_OUT_C_MSB 0x201F /* minimum damper output for coring MSB */ +#define VS6624_PEAK_MIN_OUT_C_LSB 0x2020 /* minimum damper output for coring LSB */ +/* pipe 0 RGB to YUV matrix manual control */ +#define VS6624_RYM0_MAN_CTRL 0x2180 /* enable manual RGB to YUV matrix */ +#define VS6624_RYM0_W00_MSB 0x2183 /* row 0 column 0 of YUV matrix MSB */ +#define VS6624_RYM0_W00_LSB 0x2184 /* row 0 column 0 of YUV matrix LSB */ +#define VS6624_RYM0_W01_MSB 0x2187 /* row 0 column 1 of YUV matrix MSB */ +#define VS6624_RYM0_W01_LSB 0x2188 /* row 0 column 1 of YUV matrix LSB */ +#define VS6624_RYM0_W02_MSB 0x218C /* row 0 column 2 of YUV matrix MSB */ +#define VS6624_RYM0_W02_LSB 0x218D /* row 0 column 2 of YUV matrix LSB */ +#define VS6624_RYM0_W10_MSB 0x2190 /* row 1 column 0 of YUV matrix MSB */ +#define VS6624_RYM0_W10_LSB 0x218F /* row 1 column 0 of YUV matrix LSB */ +#define VS6624_RYM0_W11_MSB 0x2193 /* row 1 column 1 of YUV matrix MSB */ +#define VS6624_RYM0_W11_LSB 0x2194 /* row 1 column 1 of YUV matrix LSB */ +#define VS6624_RYM0_W12_MSB 0x2197 /* row 1 column 2 of YUV matrix MSB */ +#define VS6624_RYM0_W12_LSB 0x2198 /* row 1 column 2 of YUV matrix LSB */ +#define VS6624_RYM0_W20_MSB 0x219B /* row 2 column 0 of YUV matrix MSB */ +#define VS6624_RYM0_W20_LSB 0x219C /* row 2 column 0 of YUV matrix LSB */ +#define VS6624_RYM0_W21_MSB 0x21A0 /* row 2 column 1 of YUV matrix MSB */ +#define VS6624_RYM0_W21_LSB 0x219F /* row 2 column 1 of YUV matrix LSB */ +#define VS6624_RYM0_W22_MSB 0x21A3 /* row 2 column 2 of YUV matrix MSB */ +#define VS6624_RYM0_W22_LSB 0x21A4 /* row 2 column 2 of YUV matrix LSB */ +#define VS6624_RYM0_YINY_MSB 0x21A7 /* Y in Y MSB */ +#define VS6624_RYM0_YINY_LSB 0x21A8 /* Y in Y LSB */ +#define VS6624_RYM0_YINCB_MSB 0x21AB /* Y in Cb MSB */ +#define VS6624_RYM0_YINCB_LSB 0x21AC /* Y in Cb LSB */ +#define VS6624_RYM0_YINCR_MSB 0x21B0 /* Y in Cr MSB */ +#define VS6624_RYM0_YINCR_LSB 0x21AF /* Y in Cr LSB */ +/* pipe 1 RGB to YUV matrix manual control */ +#define VS6624_RYM1_MAN_CTRL 0x2200 /* enable manual RGB to YUV matrix */ +#define VS6624_RYM1_W00_MSB 0x2203 /* row 0 column 0 of YUV matrix MSB */ +#define VS6624_RYM1_W00_LSB 0x2204 /* row 0 column 0 of YUV matrix LSB */ +#define VS6624_RYM1_W01_MSB 0x2207 /* row 0 column 1 of YUV matrix MSB */ +#define VS6624_RYM1_W01_LSB 0x2208 /* row 0 column 1 of YUV matrix LSB */ +#define VS6624_RYM1_W02_MSB 0x220C /* row 0 column 2 of YUV matrix MSB */ +#define VS6624_RYM1_W02_LSB 0x220D /* row 0 column 2 of YUV matrix LSB */ +#define VS6624_RYM1_W10_MSB 0x2210 /* row 1 column 0 of YUV matrix MSB */ +#define VS6624_RYM1_W10_LSB 0x220F /* row 1 column 0 of YUV matrix LSB */ +#define VS6624_RYM1_W11_MSB 0x2213 /* row 1 column 1 of YUV matrix MSB */ +#define VS6624_RYM1_W11_LSB 0x2214 /* row 1 column 1 of YUV matrix LSB */ +#define VS6624_RYM1_W12_MSB 0x2217 /* row 1 column 2 of YUV matrix MSB */ +#define VS6624_RYM1_W12_LSB 0x2218 /* row 1 column 2 of YUV matrix LSB */ +#define VS6624_RYM1_W20_MSB 0x221B /* row 2 column 0 of YUV matrix MSB */ +#define VS6624_RYM1_W20_LSB 0x221C /* row 2 column 0 of YUV matrix LSB */ +#define VS6624_RYM1_W21_MSB 0x2220 /* row 2 column 1 of YUV matrix MSB */ +#define VS6624_RYM1_W21_LSB 0x221F /* row 2 column 1 of YUV matrix LSB */ +#define VS6624_RYM1_W22_MSB 0x2223 /* row 2 column 2 of YUV matrix MSB */ +#define VS6624_RYM1_W22_LSB 0x2224 /* row 2 column 2 of YUV matrix LSB */ +#define VS6624_RYM1_YINY_MSB 0x2227 /* Y in Y MSB */ +#define VS6624_RYM1_YINY_LSB 0x2228 /* Y in Y LSB */ +#define VS6624_RYM1_YINCB_MSB 0x222B /* Y in Cb MSB */ +#define VS6624_RYM1_YINCB_LSB 0x222C /* Y in Cb LSB */ +#define VS6624_RYM1_YINCR_MSB 0x2220 /* Y in Cr MSB */ +#define VS6624_RYM1_YINCR_LSB 0x222F /* Y in Cr LSB */ +/* pipe 0 gamma manual control */ +#define VS6624_GAMMA_MAN_CTRL0 0x2280 /* enable manual gamma setup */ +#define VS6624_GAMMA_PEAK_R0 0x2282 /* peaked red channel gamma value */ +#define VS6624_GAMMA_PEAK_G0 0x2284 /* peaked green channel gamma value */ +#define VS6624_GAMMA_PEAK_B0 0x2286 /* peaked blue channel gamma value */ +#define VS6624_GAMMA_UNPEAK_R0 0x2288 /* unpeaked red channel gamma value */ +#define VS6624_GAMMA_UNPEAK_G0 0x228A /* unpeaked green channel gamma value */ +#define VS6624_GAMMA_UNPEAK_B0 0x228C /* unpeaked blue channel gamma value */ +/* pipe 1 gamma manual control */ +#define VS6624_GAMMA_MAN_CTRL1 0x2300 /* enable manual gamma setup */ +#define VS6624_GAMMA_PEAK_R1 0x2302 /* peaked red channel gamma value */ +#define VS6624_GAMMA_PEAK_G1 0x2304 /* peaked green channel gamma value */ +#define VS6624_GAMMA_PEAK_B1 0x2306 /* peaked blue channel gamma value */ +#define VS6624_GAMMA_UNPEAK_R1 0x2308 /* unpeaked red channel gamma value */ +#define VS6624_GAMMA_UNPEAK_G1 0x230A /* unpeaked green channel gamma value */ +#define VS6624_GAMMA_UNPEAK_B1 0x230C /* unpeaked blue channel gamma value */ +/* fade to black */ +#define VS6624_F2B_DISABLE 0x2480 /* disable fade to black */ +#define VS6624_F2B_BLACK_VAL_MSB 0x2483 /* black value MSB */ +#define VS6624_F2B_BLACK_VAL_LSB 0x2484 /* black value LSB */ +#define VS6624_F2B_LOW_THR_MSB 0x2487 /* low threshold for exposure MSB */ +#define VS6624_F2B_LOW_THR_LSB 0x2488 /* low threshold for exposure LSB */ +#define VS6624_F2B_HIGH_THR_MSB 0x248B /* high threshold for exposure MSB */ +#define VS6624_F2B_HIGH_THR_LSB 0x248C /* high threshold for exposure LSB */ +#define VS6624_F2B_MIN_OUT_MSB 0x248F /* minimum damper output MSB */ +#define VS6624_F2B_MIN_OUT_LSB 0x2490 /* minimum damper output LSB */ +/* output formatter control */ +#define VS6624_CODE_CK_EN 0x2580 /* code check enable */ +#define VS6624_BLANK_FMT 0x2582 /* blank format */ +#define VS6624_SYNC_CODE_SETUP 0x2584 /* sync code setup */ +#define VS6624_HSYNC_SETUP 0x2586 /* H sync setup */ +#define VS6624_VSYNC_SETUP 0x2588 /* V sync setup */ +#define VS6624_PCLK_SETUP 0x258A /* PCLK setup */ +#define VS6624_PCLK_EN 0x258C /* PCLK enable */ +#define VS6624_OPF_SP_SETUP 0x258E /* output formatter sp setup */ +#define VS6624_BLANK_DATA_MSB 0x2590 /* blank data MSB */ +#define VS6624_BLANK_DATA_LSB 0x2592 /* blank data LSB */ +#define VS6624_RGB_SETUP 0x2594 /* RGB setup */ +#define VS6624_YUV_SETUP 0x2596 /* YUV setup */ +#define VS6624_VSYNC_RIS_COARSE_H 0x2598 /* V sync rising coarse high */ +#define VS6624_VSYNC_RIS_COARSE_L 0x259A /* V sync rising coarse low */ +#define VS6624_VSYNC_RIS_FINE_H 0x259C /* V sync rising fine high */ +#define VS6624_VSYNC_RIS_FINE_L 0x259E /* V sync rising fine low */ +#define VS6624_VSYNC_FALL_COARSE_H 0x25A0 /* V sync falling coarse high */ +#define VS6624_VSYNC_FALL_COARSE_L 0x25A2 /* V sync falling coarse low */ +#define VS6624_VSYNC_FALL_FINE_H 0x25A4 /* V sync falling fine high */ +#define VS6624_VSYNC_FALL_FINE_L 0x25A6 /* V sync falling fine low */ +#define VS6624_HSYNC_RIS_H 0x25A8 /* H sync rising high */ +#define VS6624_HSYNC_RIS_L 0x25AA /* H sync rising low */ +#define VS6624_HSYNC_FALL_H 0x25AC /* H sync falling high */ +#define VS6624_HSYNC_FALL_L 0x25AE /* H sync falling low */ +#define VS6624_OUT_IF 0x25B0 /* output interface */ +#define VS6624_CCP_EXT_DATA 0x25B2 /* CCP extra data */ +/* NoRA controls */ +#define VS6624_NORA_DISABLE 0x2600 /* NoRA control mode */ +#define VS6624_NORA_USAGE 0x2602 /* usage */ +#define VS6624_NORA_SPLIT_KN 0x2604 /* split kn */ +#define VS6624_NORA_SPLIT_NI 0x2606 /* split ni */ +#define VS6624_NORA_TIGHT_G 0x2608 /* tight green */ +#define VS6624_NORA_DISABLE_NP 0x260A /* disable noro promoting */ +#define VS6624_NORA_LOW_THR_MSB 0x260D /* low threshold for exposure MSB */ +#define VS6624_NORA_LOW_THR_LSB 0x260E /* low threshold for exposure LSB */ +#define VS6624_NORA_HIGH_THR_MSB 0x2611 /* high threshold for exposure MSB */ +#define VS6624_NORA_HIGH_THR_LSB 0x2612 /* high threshold for exposure LSB */ +#define VS6624_NORA_MIN_OUT_MSB 0x2615 /* minimum damper output MSB */ +#define VS6624_NORA_MIN_OUT_LSB 0x2616 /* minimum damper output LSB */ + +#endif diff --git a/include/media/v4l2-chip-ident.h b/include/media/v4l2-chip-ident.h index 20fd16d..0133b3b 100644 --- a/include/media/v4l2-chip-ident.h +++ b/include/media/v4l2-chip-ident.h @@ -143,6 +143,9 @@ enum { /* module saa6588: just ident 6588 */ V4L2_IDENT_SAA6588 = 6588, + /* module vs6624: just ident 6624 */ + V4L2_IDENT_VS6624 = 6624, + /* module saa6752hs: reserved range 6750-6759 */ V4L2_IDENT_SAA6752HS = 6752, V4L2_IDENT_SAA6752HS_AC3 = 6753, -- 1.7.0.4 ^ permalink raw reply related [flat|nested] 39+ messages in thread
* Re: [PATCH 3/4] v4l2: add vs6624 sensor driver 2011-09-13 18:34 ` [PATCH 3/4] v4l2: add vs6624 sensor driver Scott Jiang @ 2011-09-13 7:42 ` Guennadi Liakhovetski 2011-09-13 8:20 ` Scott Jiang 2011-09-14 3:28 ` [uclinux-dist-devel] " Mike Frysinger 1 sibling, 1 reply; 39+ messages in thread From: Guennadi Liakhovetski @ 2011-09-13 7:42 UTC (permalink / raw) To: Scott Jiang Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel Hi Scott Thanks for the patch. I am not doing a full review, just a couple of notes: On Tue, 13 Sep 2011, Scott Jiang wrote: > this is a v4l2 sensor-level driver for the ST VS6624 camera > > Signed-off-by: Scott Jiang <scott.jiang.linux@gmail.com> > --- [snip] > diff --git a/drivers/media/video/vs6624.c b/drivers/media/video/vs6624.c > new file mode 100644 > index 0000000..b0030ab > --- /dev/null > +++ b/drivers/media/video/vs6624.c > @@ -0,0 +1,941 @@ [snip] > +#define VGA_WIDTH 640 > +#define VGA_HEIGHT 480 > +#define QVGA_WIDTH 320 > +#define QVGA_HEIGHT 240 > +#define QQVGA_WIDTH 160 > +#define QQVGA_HEIGHT 120 > +#define CIF_WIDTH 352 > +#define CIF_HEIGHT 288 > +#define QCIF_WIDTH 176 > +#define QCIF_HEIGHT 144 > +#define QQCIF_WIDTH 88 > +#define QQCIF_HEIGHT 72 ...Can anyone put these in a central header, please? really, please?;-) [snip] > +static const u16 vs6624_p1[] = { > + 0x8104, 0x03, > + 0x8105, 0x01, > + 0xc900, 0x03, > + 0xc904, 0x47, > + 0xc905, 0x10, > + 0xc906, 0x80, > + 0xc907, 0x3a, > + 0x903a, 0x02, > + 0x903b, 0x47, > + 0x903c, 0x15, > + 0xc908, 0x31, > + 0xc909, 0xdc, > + 0xc90a, 0x80, > + 0xc90b, 0x44, > + 0x9044, 0x02, > + 0x9045, 0x31, > + 0x9046, 0xe2, > + 0xc90c, 0x07, > + 0xc90d, 0xe0, > + 0xc90e, 0x80, > + 0xc90f, 0x47, > + 0x9047, 0x90, > + 0x9048, 0x83, > + 0x9049, 0x81, > + 0x904a, 0xe0, > + 0x904b, 0x60, > + 0x904c, 0x08, > + 0x904d, 0x90, > + 0x904e, 0xc0, > + 0x904f, 0x43, > + 0x9050, 0x74, > + 0x9051, 0x01, > + 0x9052, 0xf0, > + 0x9053, 0x80, > + 0x9054, 0x05, > + 0x9055, 0xE4, > + 0x9056, 0x90, > + 0x9057, 0xc0, > + 0x9058, 0x43, > + 0x9059, 0xf0, > + 0x905a, 0x02, > + 0x905b, 0x07, > + 0x905c, 0xec, > + 0xc910, 0x5d, > + 0xc911, 0xca, > + 0xc912, 0x80, > + 0xc913, 0x5d, > + 0x905d, 0xa3, > + 0x905e, 0x04, > + 0x905f, 0xf0, > + 0x9060, 0xa3, > + 0x9061, 0x04, > + 0x9062, 0xf0, > + 0x9063, 0x22, > + 0xc914, 0x72, > + 0xc915, 0x92, > + 0xc916, 0x80, > + 0xc917, 0x64, > + 0x9064, 0x74, > + 0x9065, 0x01, > + 0x9066, 0x02, > + 0x9067, 0x72, > + 0x9068, 0x95, > + 0xc918, 0x47, > + 0xc919, 0xf2, > + 0xc91a, 0x81, > + 0xc91b, 0x69, > + 0x9169, 0x74, > + 0x916a, 0x02, > + 0x916b, 0xf0, > + 0x916c, 0xec, > + 0x916d, 0xb4, > + 0x916e, 0x10, > + 0x916f, 0x0a, > + 0x9170, 0x90, > + 0x9171, 0x80, > + 0x9172, 0x16, > + 0x9173, 0xe0, > + 0x9174, 0x70, > + 0x9175, 0x04, > + 0x9176, 0x90, > + 0x9177, 0xd3, > + 0x9178, 0xc4, > + 0x9179, 0xf0, > + 0x917a, 0x22, > + 0xc91c, 0x0a, > + 0xc91d, 0xbe, > + 0xc91e, 0x80, > + 0xc91f, 0x73, > + 0x9073, 0xfc, > + 0x9074, 0xa3, > + 0x9075, 0xe0, > + 0x9076, 0xf5, > + 0x9077, 0x82, > + 0x9078, 0x8c, > + 0x9079, 0x83, > + 0x907a, 0xa3, > + 0x907b, 0xa3, > + 0x907c, 0xe0, > + 0x907d, 0xfc, > + 0x907e, 0xa3, > + 0x907f, 0xe0, > + 0x9080, 0xc3, > + 0x9081, 0x9f, > + 0x9082, 0xff, > + 0x9083, 0xec, > + 0x9084, 0x9e, > + 0x9085, 0xfe, > + 0x9086, 0x02, > + 0x9087, 0x0a, > + 0x9088, 0xea, > + 0xc920, 0x47, > + 0xc921, 0x38, > + 0xc922, 0x80, > + 0xc923, 0x89, > + 0x9089, 0xec, > + 0x908a, 0xd3, > + 0x908b, 0x94, > + 0x908c, 0x20, > + 0x908d, 0x40, > + 0x908e, 0x01, > + 0x908f, 0x1c, > + 0x9090, 0x90, > + 0x9091, 0xd3, > + 0x9092, 0xd4, > + 0x9093, 0xec, > + 0x9094, 0xf0, > + 0x9095, 0x02, > + 0x9096, 0x47, > + 0x9097, 0x3d, > + 0xc924, 0x45, > + 0xc925, 0xca, > + 0xc926, 0x80, > + 0xc927, 0x98, > + 0x9098, 0x12, > + 0x9099, 0x77, > + 0x909a, 0xd6, > + 0x909b, 0x02, > + 0x909c, 0x45, > + 0x909d, 0xcd, > + 0xc928, 0x20, > + 0xc929, 0xd5, > + 0xc92a, 0x80, > + 0xc92b, 0x9e, > + 0x909e, 0x90, > + 0x909f, 0x82, > + 0x90a0, 0x18, > + 0x90a1, 0xe0, > + 0x90a2, 0xb4, > + 0x90a3, 0x03, > + 0x90a4, 0x0e, > + 0x90a5, 0x90, > + 0x90a6, 0x83, > + 0x90a7, 0xbf, > + 0x90a8, 0xe0, > + 0x90a9, 0x60, > + 0x90aa, 0x08, > + 0x90ab, 0x90, > + 0x90ac, 0x81, > + 0x90ad, 0xfc, > + 0x90ae, 0xe0, > + 0x90af, 0xff, > + 0x90b0, 0xc3, > + 0x90b1, 0x13, > + 0x90b2, 0xf0, > + 0x90b3, 0x90, > + 0x90b4, 0x81, > + 0x90b5, 0xfc, > + 0x90b6, 0xe0, > + 0x90b7, 0xff, > + 0x90b8, 0x02, > + 0x90b9, 0x20, > + 0x90ba, 0xda, > + 0xc92c, 0x70, > + 0xc92d, 0xbc, > + 0xc92e, 0x80, > + 0xc92f, 0xbb, > + 0x90bb, 0x90, > + 0x90bc, 0x82, > + 0x90bd, 0x18, > + 0x90be, 0xe0, > + 0x90bf, 0xb4, > + 0x90c0, 0x03, > + 0x90c1, 0x06, > + 0x90c2, 0x90, > + 0x90c3, 0xc1, > + 0x90c4, 0x06, > + 0x90c5, 0x74, > + 0x90c6, 0x05, > + 0x90c7, 0xf0, > + 0x90c8, 0x90, > + 0x90c9, 0xd3, > + 0x90ca, 0xa0, > + 0x90cb, 0x02, > + 0x90cc, 0x70, > + 0x90cd, 0xbf, > + 0xc930, 0x72, > + 0xc931, 0x21, > + 0xc932, 0x81, > + 0xc933, 0x3b, > + 0x913b, 0x7d, > + 0x913c, 0x02, > + 0x913d, 0x7f, > + 0x913e, 0x7b, > + 0x913f, 0x02, > + 0x9140, 0x72, > + 0x9141, 0x25, > + 0xc934, 0x28, > + 0xc935, 0xae, > + 0xc936, 0x80, > + 0xc937, 0xd2, > + 0x90d2, 0xf0, > + 0x90d3, 0x90, > + 0x90d4, 0xd2, > + 0x90d5, 0x0a, > + 0x90d6, 0x02, > + 0x90d7, 0x28, > + 0x90d8, 0xb4, > + 0xc938, 0x28, > + 0xc939, 0xb1, > + 0xc93a, 0x80, > + 0xc93b, 0xd9, > + 0x90d9, 0x90, > + 0x90da, 0x83, > + 0x90db, 0xba, > + 0x90dc, 0xe0, > + 0x90dd, 0xff, > + 0x90de, 0x90, > + 0x90df, 0xd2, > + 0x90e0, 0x08, > + 0x90e1, 0xe0, > + 0x90e2, 0xe4, > + 0x90e3, 0xef, > + 0x90e4, 0xf0, > + 0x90e5, 0xa3, > + 0x90e6, 0xe0, > + 0x90e7, 0x74, > + 0x90e8, 0xff, > + 0x90e9, 0xf0, > + 0x90ea, 0x90, > + 0x90eb, 0xd2, > + 0x90ec, 0x0a, > + 0x90ed, 0x02, > + 0x90ee, 0x28, > + 0x90ef, 0xb4, > + 0xc93c, 0x29, > + 0xc93d, 0x79, > + 0xc93e, 0x80, > + 0xc93f, 0xf0, > + 0x90f0, 0xf0, > + 0x90f1, 0x90, > + 0x90f2, 0xd2, > + 0x90f3, 0x0e, > + 0x90f4, 0x02, > + 0x90f5, 0x29, > + 0x90f6, 0x7f, > + 0xc940, 0x29, > + 0xc941, 0x7c, > + 0xc942, 0x80, > + 0xc943, 0xf7, > + 0x90f7, 0x90, > + 0x90f8, 0x83, > + 0x90f9, 0xba, > + 0x90fa, 0xe0, > + 0x90fb, 0xff, > + 0x90fc, 0x90, > + 0x90fd, 0xd2, > + 0x90fe, 0x0c, > + 0x90ff, 0xe0, > + 0x9100, 0xe4, > + 0x9101, 0xef, > + 0x9102, 0xf0, > + 0x9103, 0xa3, > + 0x9104, 0xe0, > + 0x9105, 0x74, > + 0x9106, 0xff, > + 0x9107, 0xf0, > + 0x9108, 0x90, > + 0x9109, 0xd2, > + 0x910a, 0x0e, > + 0x910b, 0x02, > + 0x910c, 0x29, > + 0x910d, 0x7f, > + 0xc944, 0x2a, > + 0xc945, 0x42, > + 0xc946, 0x81, > + 0xc947, 0x0e, > + 0x910e, 0xf0, > + 0x910f, 0x90, > + 0x9110, 0xd2, > + 0x9111, 0x12, > + 0x9112, 0x02, > + 0x9113, 0x2a, > + 0x9114, 0x48, > + 0xc948, 0x2a, > + 0xc949, 0x45, > + 0xc94a, 0x81, > + 0xc94b, 0x15, > + 0x9115, 0x90, > + 0x9116, 0x83, > + 0x9117, 0xba, > + 0x9118, 0xe0, > + 0x9119, 0xff, > + 0x911a, 0x90, > + 0x911b, 0xd2, > + 0x911c, 0x10, > + 0x911d, 0xe0, > + 0x911e, 0xe4, > + 0x911f, 0xef, > + 0x9120, 0xf0, > + 0x9121, 0xa3, > + 0x9122, 0xe0, > + 0x9123, 0x74, > + 0x9124, 0xff, > + 0x9125, 0xf0, > + 0x9126, 0x90, > + 0x9127, 0xd2, > + 0x9128, 0x12, > + 0x9129, 0x02, > + 0x912a, 0x2a, > + 0x912b, 0x48, > + 0xc900, 0x01, > + 0x0000, 0x00, > +}; > + > +static const u16 vs6624_p2[] = { > + 0x806f, 0x01, > + 0x058c, 0x01, > + 0x0000, 0x00, > +}; > + > +static const u16 vs6624_run_setup[] = { > + 0x1d18, 0x00, /* Enableconstrainedwhitebalance */ I'm sure many other reviewers will also ask you to replace numerical register addresses with symbolic names, since it looks like a sufficiently detailed documentation is available to you. > + 0x200d, 0x3c, /* Damper PeakGain Output MSB */ Actually, some of these registers are already defined in your header: +#define VS6624_PEAK_MIN_OUT_G_MSB 0x200D /* minimum damper output for gain MSB */ so, please, just use those names here and add defines for missing registers > + 0x200e, 0x66, /* Damper PeakGain Output LSB */ > + 0x1f03, 0x65, /* Damper Low MSB */ > + 0x1f04, 0xd1, /* Damper Low LSB */ > + 0x1f07, 0x66, /* Damper High MSB */ > + 0x1f08, 0x62, /* Damper High LSB */ > + 0x1f0b, 0x00, /* Damper Min output MSB */ > + 0x1f0c, 0x00, /* Damper Min output LSB */ > + 0x2600, 0x00, /* Nora fDisable */ > + 0x2602, 0x04, /* Nora usage */ > + 0x260d, 0x63, /* Damper Low MSB Changed 0x63 to 0x65 */ > + 0x260e, 0xd1, /* Damper Low LSB */ > + 0x2611, 0x68, /* Damper High MSB */ > + 0x2612, 0xdd, /* Damper High LSB */ > + 0x2615, 0x3a, /* Damper Min output MSB */ > + 0x2616, 0x00, /* Damper Min output LSB */ > + 0x2480, 0x00, /* Disable */ > + 0x1d8a, 0x30, /* MAXWeightHigh */ > + 0x1d91, 0x62, /* fpDamperLowThresholdHigh MSB */ > + 0x1d92, 0x4a, /* fpDamperLowThresholdHigh LSB */ > + 0x1d95, 0x65, /* fpDamperHighThresholdHigh MSB */ > + 0x1d96, 0x0e, /* fpDamperHighThresholdHigh LSB */ > + 0x1da1, 0x3a, /* fpMinimumDamperOutputLow MSB */ > + 0x1da2, 0xb8, /* fpMinimumDamperOutputLow LSB */ > + 0x1e08, 0x06, /* MAXWeightLow */ > + 0x1e0a, 0x0a, /* MAXWeightHigh */ > + 0x1601, 0x3a, /* Red A MSB */ > + 0x1602, 0x14, /* Red A LSB */ > + 0x1605, 0x3b, /* Blue A MSB */ > + 0x1606, 0x85, /* BLue A LSB */ > + 0x1609, 0x3b, /* RED B MSB */ > + 0x160a, 0x85, /* RED B LSB */ > + 0x160d, 0x3a, /* Blue B MSB */ > + 0x160e, 0x14, /* Blue B LSB */ > + 0x1611, 0x30, /* Max Distance from Locus MSB */ > + 0x1612, 0x8f, /* Max Distance from Locus MSB */ > + 0x1614, 0x01, /* Enable constrainer */ > + 0x0000, 0x00, > +}; > + > +static const u16 vs6624_default[] = { > + VS6624_CONTRAST0, 0x84, > + VS6624_SATURATION0, 0x75, > + VS6624_GAMMA0, 0x11, > + VS6624_CONTRAST1, 0x84, > + VS6624_SATURATION1, 0x75, > + VS6624_GAMMA1, 0x11, > + VS6624_MAN_RG, 0x80, > + VS6624_MAN_GG, 0x80, > + VS6624_MAN_BG, 0x80, > + VS6624_WB_MODE, 0x1, > + VS6624_EXPO_COMPENSATION, 0xfe, > + VS6624_EXPO_METER, 0x0, > + VS6624_LIGHT_FREQ, 0x64, > + VS6624_PEAK_GAIN, 0xe, > + VS6624_PEAK_LOW_THR, 0x28, > + VS6624_HMIRROR0, 0x0, > + VS6624_VFLIP0, 0x0, > + VS6624_ZOOM_HSTEP0_MSB, 0x0, > + VS6624_ZOOM_HSTEP0_LSB, 0x1, > + VS6624_ZOOM_VSTEP0_MSB, 0x0, > + VS6624_ZOOM_VSTEP0_LSB, 0x1, > + VS6624_PAN_HSTEP0_MSB, 0x0, > + VS6624_PAN_HSTEP0_LSB, 0xf, > + VS6624_PAN_VSTEP0_MSB, 0x0, > + VS6624_PAN_VSTEP0_LSB, 0xf, > + VS6624_SENSOR_MODE, 0x1, > + VS6624_SYNC_CODE_SETUP, 0x21, > + VS6624_DISABLE_FR_DAMPER, 0x0, > + VS6624_FR_DEN, 0x1, > + VS6624_FR_NUM_LSB, 0xf, > + VS6624_INIT_PIPE_SETUP, 0x0, > + VS6624_IMG_FMT0, 0x0, > + VS6624_YUV_SETUP, 0x1, > + VS6624_IMAGE_SIZE0, 0x2, > + 0x0000, 0x00, > +}; [snip] > +static int __devinit vs6624_probe(struct i2c_client *client, > + const struct i2c_device_id *id) > +{ > + struct vs6624 *sensor; > + struct v4l2_subdev *sd; > + struct v4l2_ctrl_handler *hdl; > + u16 device_id; > + const unsigned *ce; > + int ret; > + > + /* Check if the adapter supports the needed features */ > + if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) > + return -EIO; > + > + ce = client->dev.platform_data; > + if (ce == NULL) > + return -EINVAL; > + > + ret = gpio_request(*ce, "VS6624 Chip Enable"); > + if (ret) { > + v4l_err(client, "failed to request GPIO %d\n", *ce); > + return ret; > + } > + gpio_direction_output(*ce, 1); > + /* wait 100ms before any further i2c writes are performed */ > + mdelay(100); Logically, it could be a good idea to toggle chip-enable in your v4l2_subdev_core_ops::s_power() method, but if you really have to wait for 100ms before accessing the chip... > + > + sensor = kzalloc(sizeof(*sensor), GFP_KERNEL); > + if (sensor == NULL) { > + gpio_free(*ce); > + return -ENOMEM; > + } > + > + sd = &sensor->sd; > + v4l2_i2c_subdev_init(sd, client, &vs6624_ops); > + > + vs6624_writeregs(sd, vs6624_p1); > + vs6624_write(sd, VS6624_MICRO_EN, 0x2); > + vs6624_write(sd, VS6624_DIO_EN, 0x1); > + mdelay(10); > + vs6624_writeregs(sd, vs6624_p2); > + > + /* make sure the sensor is vs6624 */ > + device_id = vs6624_read(sd, VS6624_DEV_ID_MSB) << 8 > + | vs6624_read(sd, VS6624_DEV_ID_LSB); Wow... this is like saying - sorry, guys, the chip, we just killed by writing random rubbish to it wasn't a vs6624;-) I mean, are ID registers really unreadable before writing defaults to registers? Thanks Guennadi --- Guennadi Liakhovetski, Ph.D. Freelance Open-Source Software Developer http://www.open-technology.de/ ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 3/4] v4l2: add vs6624 sensor driver 2011-09-13 7:42 ` Guennadi Liakhovetski @ 2011-09-13 8:20 ` Scott Jiang 2011-09-13 8:22 ` Guennadi Liakhovetski 0 siblings, 1 reply; 39+ messages in thread From: Scott Jiang @ 2011-09-13 8:20 UTC (permalink / raw) To: Guennadi Liakhovetski Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel >> +#define VGA_WIDTH 640 >> +#define VGA_HEIGHT 480 >> +#define QVGA_WIDTH 320 >> +#define QVGA_HEIGHT 240 >> +#define QQVGA_WIDTH 160 >> +#define QQVGA_HEIGHT 120 >> +#define CIF_WIDTH 352 >> +#define CIF_HEIGHT 288 >> +#define QCIF_WIDTH 176 >> +#define QCIF_HEIGHT 144 >> +#define QQCIF_WIDTH 88 >> +#define QQCIF_HEIGHT 72 > > ...Can anyone put these in a central header, please? really, please?;-) > if already exists in some common file, please tell me > > I'm sure many other reviewers will also ask you to replace numerical > register addresses with symbolic names, since it looks like a sufficiently > detailed documentation is available to you. > sorry, I can't find these names in the datasheet I downloaded from st website. > >> + 0x200d, 0x3c, /* Damper PeakGain Output MSB */ > > Actually, some of these registers are already defined in your header: > > +#define VS6624_PEAK_MIN_OUT_G_MSB 0x200D /* minimum damper output for gain MSB */ > > so, please, just use those names here and add defines for missing registers > I can't find many register names in datasheet. so I treat it as a binary firmware patch. >> + ret = gpio_request(*ce, "VS6624 Chip Enable"); >> + if (ret) { >> + v4l_err(client, "failed to request GPIO %d\n", *ce); >> + return ret; >> + } >> + gpio_direction_output(*ce, 1); >> + /* wait 100ms before any further i2c writes are performed */ >> + mdelay(100); > > Logically, it could be a good idea to toggle chip-enable in your > v4l2_subdev_core_ops::s_power() method, but if you really have to wait for > 100ms before accessing the chip... yes, I found if I don't wait a long time, the i2c operation will fail > >> + >> + vs6624_writeregs(sd, vs6624_p1); >> + vs6624_write(sd, VS6624_MICRO_EN, 0x2); >> + vs6624_write(sd, VS6624_DIO_EN, 0x1); >> + mdelay(10); >> + vs6624_writeregs(sd, vs6624_p2); >> + >> + /* make sure the sensor is vs6624 */ >> + device_id = vs6624_read(sd, VS6624_DEV_ID_MSB) << 8 >> + | vs6624_read(sd, VS6624_DEV_ID_LSB); > > Wow... this is like saying - sorry, guys, the chip, we just killed by > writing random rubbish to it wasn't a vs6624;-) I mean, are ID registers > really unreadable before writing defaults to registers? > I remember I put this before writing registers at the first version but it failed... Perhaps I should remove the id check, it looks strange Scott ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 3/4] v4l2: add vs6624 sensor driver 2011-09-13 8:20 ` Scott Jiang @ 2011-09-13 8:22 ` Guennadi Liakhovetski 0 siblings, 0 replies; 39+ messages in thread From: Guennadi Liakhovetski @ 2011-09-13 8:22 UTC (permalink / raw) To: Scott Jiang Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel On Tue, 13 Sep 2011, Scott Jiang wrote: > >> +#define VGA_WIDTH 640 > >> +#define VGA_HEIGHT 480 > >> +#define QVGA_WIDTH 320 > >> +#define QVGA_HEIGHT 240 > >> +#define QQVGA_WIDTH 160 > >> +#define QQVGA_HEIGHT 120 > >> +#define CIF_WIDTH 352 > >> +#define CIF_HEIGHT 288 > >> +#define QCIF_WIDTH 176 > >> +#define QCIF_HEIGHT 144 > >> +#define QQCIF_WIDTH 88 > >> +#define QQCIF_HEIGHT 72 > > > > ...Can anyone put these in a central header, please? really, please?;-) > > > if already exists in some common file, please tell me > > > > > I'm sure many other reviewers will also ask you to replace numerical > > register addresses with symbolic names, since it looks like a sufficiently > > detailed documentation is available to you. > > > sorry, I can't find these names in the datasheet I downloaded from st website. > > > > >> + 0x200d, 0x3c, /* Damper PeakGain Output MSB */ > > > > Actually, some of these registers are already defined in your header: > > > > +#define VS6624_PEAK_MIN_OUT_G_MSB 0x200D /* minimum damper output for gain MSB */ > > > > so, please, just use those names here and add defines for missing registers > > > I can't find many register names in datasheet. so I treat it as a > binary firmware patch. Please, at least use those, that you already define in your header. Thanks Guennadi > > >> + ret = gpio_request(*ce, "VS6624 Chip Enable"); > >> + if (ret) { > >> + v4l_err(client, "failed to request GPIO %d\n", *ce); > >> + return ret; > >> + } > >> + gpio_direction_output(*ce, 1); > >> + /* wait 100ms before any further i2c writes are performed */ > >> + mdelay(100); > > > > Logically, it could be a good idea to toggle chip-enable in your > > v4l2_subdev_core_ops::s_power() method, but if you really have to wait for > > 100ms before accessing the chip... > yes, I found if I don't wait a long time, the i2c operation will fail > > > > >> + > >> + vs6624_writeregs(sd, vs6624_p1); > >> + vs6624_write(sd, VS6624_MICRO_EN, 0x2); > >> + vs6624_write(sd, VS6624_DIO_EN, 0x1); > >> + mdelay(10); > >> + vs6624_writeregs(sd, vs6624_p2); > >> + > >> + /* make sure the sensor is vs6624 */ > >> + device_id = vs6624_read(sd, VS6624_DEV_ID_MSB) << 8 > >> + | vs6624_read(sd, VS6624_DEV_ID_LSB); > > > > Wow... this is like saying - sorry, guys, the chip, we just killed by > > writing random rubbish to it wasn't a vs6624;-) I mean, are ID registers > > really unreadable before writing defaults to registers? > > > I remember I put this before writing registers at the first version > but it failed... > Perhaps I should remove the id check, it looks strange > > Scott > --- Guennadi Liakhovetski, Ph.D. Freelance Open-Source Software Developer http://www.open-technology.de/ ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [uclinux-dist-devel] [PATCH 3/4] v4l2: add vs6624 sensor driver 2011-09-13 18:34 ` [PATCH 3/4] v4l2: add vs6624 sensor driver Scott Jiang 2011-09-13 7:42 ` Guennadi Liakhovetski @ 2011-09-14 3:28 ` Mike Frysinger 2011-09-14 7:28 ` Scott Jiang 1 sibling, 1 reply; 39+ messages in thread From: Mike Frysinger @ 2011-09-14 3:28 UTC (permalink / raw) To: Scott Jiang Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski, uclinux-dist-devel, linux-media On Tue, Sep 13, 2011 at 14:34, Scott Jiang wrote: > --- a/drivers/media/video/Makefile > +++ b/drivers/media/video/Makefile > > +obj-$(CONFIG_VIDEO_VS6624) += vs6624.o > obj-$(CONFIG_VIDEO_VPX3220) += vpx3220.o should be after vpx, not before ? > --- /dev/null > +++ b/drivers/media/video/vs6624.c > > +#include <asm/gpio.h> run these patches through checkpatch.pl ? this should be linux/gpio.h ... > +static const u16 vs6624_p1[] = { > +static const u16 vs6624_p2[] = { add comments as to what these are for ? > +static inline int vs6624_read(struct v4l2_subdev *sd, u16 index) > +static inline int vs6624_write(struct v4l2_subdev *sd, u16 index, > + u8 value) should these be inline ? they're a little "fat" ... better to let the compiler choose > +static int vs6624_writeregs(struct v4l2_subdev *sd, const u16 *regs) > +{ > + u16 reg, data; > + > + while (*regs != 0x00) { > + reg = *regs++; > + data = *regs++; > + > + vs6624_write(sd, reg, (u8)data); what's the point of declaring data as u16 if the top 8 bits are never used ? > +static int vs6624_g_chip_ident(struct v4l2_subdev *sd, > + struct v4l2_dbg_chip_ident *chip) > +{ > + int rev; > + struct i2c_client *client = v4l2_get_subdevdata(sd); > + > + rev = vs6624_read(sd, VS6624_FW_VSN_MAJOR) << 8 > + | vs6624_read(sd, VS6624_FW_VSN_MINOR); i'm a little surprised the compiler didnt warn about this. usually bit shifts + bitwise operators want paren to keep things clear. > +#ifdef CONFIG_VIDEO_ADV_DEBUG just use DEBUG ? > + v4l_info(client, "chip found @ 0x%02x (%s)\n", > + client->addr << 1, client->adapter->name); is that "<< 1" correct ? i dont think so ... -mike ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [uclinux-dist-devel] [PATCH 3/4] v4l2: add vs6624 sensor driver 2011-09-14 3:28 ` [uclinux-dist-devel] " Mike Frysinger @ 2011-09-14 7:28 ` Scott Jiang 2011-09-18 2:52 ` Mike Frysinger 0 siblings, 1 reply; 39+ messages in thread From: Scott Jiang @ 2011-09-14 7:28 UTC (permalink / raw) To: Mike Frysinger Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski, uclinux-dist-devel, linux-media > >> +#ifdef CONFIG_VIDEO_ADV_DEBUG > > just use DEBUG ? > no, v4l2 use CONFIG_VIDEO_ADV_DEBUG >> + v4l_info(client, "chip found @ 0x%02x (%s)\n", >> + client->addr << 1, client->adapter->name); > > is that "<< 1" correct ? i dont think so ... every driver under media I see use this, so what's wrong? ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [uclinux-dist-devel] [PATCH 3/4] v4l2: add vs6624 sensor driver 2011-09-14 7:28 ` Scott Jiang @ 2011-09-18 2:52 ` Mike Frysinger 0 siblings, 0 replies; 39+ messages in thread From: Mike Frysinger @ 2011-09-18 2:52 UTC (permalink / raw) To: Scott Jiang Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski, uclinux-dist-devel, linux-media On Wed, Sep 14, 2011 at 03:28, Scott Jiang wrote: >>> +#ifdef CONFIG_VIDEO_ADV_DEBUG >> >> just use DEBUG ? >> > no, v4l2 use CONFIG_VIDEO_ADV_DEBUG ok, i was thinking this was something we added (since we have "ADVxxx" parts) >>> + v4l_info(client, "chip found @ 0x%02x (%s)\n", >>> + client->addr << 1, client->adapter->name); >> >> is that "<< 1" correct ? i dont think so ... > > every driver under media I see use this, so what's wrong? meh, they're all wrong imo then :p. they're shifting the address to accommodate datasheets that incorrectly specify the i2c "address" with the read/write as bit 0. but it's fine for this driver to do that if it's the standard that the rest of the v4l code has adopted. -mike ^ permalink raw reply [flat|nested] 39+ messages in thread
* [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-13 18:34 [PATCH 1/4] v4l2: add vb2_get_unmapped_area in vb2 core Scott Jiang ` (2 preceding siblings ...) 2011-09-13 18:34 ` [PATCH 3/4] v4l2: add vs6624 sensor driver Scott Jiang @ 2011-09-13 18:34 ` Scott Jiang 2011-09-13 8:11 ` Guennadi Liakhovetski ` (3 more replies) 3 siblings, 4 replies; 39+ messages in thread From: Scott Jiang @ 2011-09-13 18:34 UTC (permalink / raw) To: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski Cc: linux-media, uclinux-dist-devel, Scott Jiang this is a v4l2 bridge driver for Blackfin video capture device, support ppi interface Signed-off-by: Scott Jiang <scott.jiang.linux@gmail.com> --- drivers/media/video/Makefile | 2 + drivers/media/video/blackfin/Kconfig | 10 + drivers/media/video/blackfin/Makefile | 2 + drivers/media/video/blackfin/bfin_capture.c | 1099 +++++++++++++++++++++++++++ drivers/media/video/blackfin/ppi.c | 204 +++++ 5 files changed, 1317 insertions(+), 0 deletions(-) create mode 100644 drivers/media/video/blackfin/Kconfig create mode 100644 drivers/media/video/blackfin/Makefile create mode 100644 drivers/media/video/blackfin/bfin_capture.c create mode 100644 drivers/media/video/blackfin/ppi.c diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile index 127eba5..bc53aee 100644 --- a/drivers/media/video/Makefile +++ b/drivers/media/video/Makefile @@ -177,6 +177,8 @@ obj-$(CONFIG_VIDEO_SAMSUNG_S5P_FIMC) += s5p-fimc/ obj-$(CONFIG_VIDEO_SAMSUNG_S5P_MFC) += s5p-mfc/ obj-$(CONFIG_VIDEO_SAMSUNG_S5P_TV) += s5p-tv/ +obj-$(CONFIG_BLACKFIN) += blackfin/ + obj-$(CONFIG_ARCH_DAVINCI) += davinci/ obj-$(CONFIG_VIDEO_SH_VOU) += sh_vou.o diff --git a/drivers/media/video/blackfin/Kconfig b/drivers/media/video/blackfin/Kconfig new file mode 100644 index 0000000..2c6e921 --- /dev/null +++ b/drivers/media/video/blackfin/Kconfig @@ -0,0 +1,10 @@ +config VIDEO_BLACKFIN_CAPTURE + tristate "Blackfin Video Capture Driver" + depends on VIDEO_DEV && BLACKFIN + select VIDEOBUF2_DMA_CONTIG + help + V4L2 bridge driver for Blackfin video capture device. + Choose PPI or EPPI as its interface. + + To compile this driver as a module, choose M here: the + module will be called bfin_video_capture. diff --git a/drivers/media/video/blackfin/Makefile b/drivers/media/video/blackfin/Makefile new file mode 100644 index 0000000..aa3a0a2 --- /dev/null +++ b/drivers/media/video/blackfin/Makefile @@ -0,0 +1,2 @@ +bfin_video_capture-objs := bfin_capture.o ppi.o +obj-$(CONFIG_VIDEO_BLACKFIN_CAPTURE) += bfin_video_capture.o diff --git a/drivers/media/video/blackfin/bfin_capture.c b/drivers/media/video/blackfin/bfin_capture.c new file mode 100644 index 0000000..24f89f2 --- /dev/null +++ b/drivers/media/video/blackfin/bfin_capture.c @@ -0,0 +1,1099 @@ +/* + * Analog Devices video capture driver + * + * Copyright (c) 2011 Analog Devices Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <linux/kernel.h> +#include <linux/init.h> +#include <linux/module.h> +#include <linux/io.h> +#include <linux/delay.h> +#include <linux/errno.h> +#include <linux/fs.h> +#include <linux/interrupt.h> +#include <linux/completion.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> +#include <linux/sched.h> +#include <linux/slab.h> + +#include <media/v4l2-common.h> +#include <media/v4l2-ioctl.h> +#include <media/v4l2-device.h> +#include <media/videobuf2-dma-contig.h> +#include <media/v4l2-chip-ident.h> + +#include <asm/dma.h> + +#include <media/blackfin/bfin_capture.h> + +#define CAPTURE_DRV_NAME "bfin_capture" +#define BCAP_MIN_NUM_BUF 2 + +struct bcap_format { + u8 *desc; + u32 pixelformat; + enum v4l2_mbus_pixelcode mbus_code; + int bpp; /* bytes per pixel */ +}; + +struct bcap_buffer { + struct vb2_buffer vb; + struct list_head list; +}; + +struct bcap_device { + /* capture device instance */ + struct v4l2_device v4l2_dev; + /* device node data */ + struct video_device *video_dev; + /* sub device instance */ + struct v4l2_subdev *sd; + /* caputre config */ + struct bfin_capture_config *cfg; + /* ppi interface */ + struct ppi_if *ppi; + /* current input */ + unsigned int cur_input; + /* current selected standard */ + v4l2_std_id std; + /* used to store pixel format */ + struct v4l2_pix_format fmt; + /* bytes per pixel*/ + int bpp; + /* pointing to current video buffer */ + struct bcap_buffer *cur_frm; + /* pointing to next video buffer */ + struct bcap_buffer *next_frm; + /* buffer queue used in videobuf2 */ + struct vb2_queue buffer_queue; + /* allocator-specific contexts for each plane */ + struct vb2_alloc_ctx *alloc_ctx; + /* queue of filled frames */ + struct list_head dma_queue; + /* used in videobuf2 callback */ + spinlock_t lock; + /* used to access capture device */ + struct mutex mutex; + /* used to wait ppi to complete one transfer */ + struct completion comp; + /* number of users performing IO */ + u32 io_usrs; + /* number of open instances of the device */ + u32 usrs; + /* indicate whether streaming has started */ + u8 started; +}; + +struct bcap_fh { + struct v4l2_fh fh; + struct bcap_device *bcap_dev; + /* indicates whether this file handle is doing IO */ + u8 io_allowed; +}; + +static const struct bcap_format bcap_formats[] = { + { + .desc = "YCbCr 4:2:2 Interleaved UYVY", + .pixelformat = V4L2_PIX_FMT_UYVY, + .mbus_code = V4L2_MBUS_FMT_UYVY8_2X8, + .bpp = 2, + }, + { + .desc = "YCbCr 4:2:2 Interleaved YUYV", + .pixelformat = V4L2_PIX_FMT_YUYV, + .mbus_code = V4L2_MBUS_FMT_YUYV8_2X8, + .bpp = 2, + }, + { + .desc = "RGB 565", + .pixelformat = V4L2_PIX_FMT_RGB565, + .mbus_code = V4L2_MBUS_FMT_RGB565_2X8_LE, + .bpp = 2, + }, + { + .desc = "RGB 444", + .pixelformat = V4L2_PIX_FMT_RGB444, + .mbus_code = V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE, + .bpp = 2, + }, + +}; +#define BCAP_MAX_FMTS ARRAY_SIZE(bcap_formats) + +static irqreturn_t bcap_isr(int irq, void *dev_id); + +static struct bcap_buffer *to_bcap_vb(struct vb2_buffer *vb) +{ + return container_of(vb, struct bcap_buffer, vb); +} + +static int bcap_open(struct file *file) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + struct video_device *vfd = bcap_dev->video_dev; + struct bcap_fh *bcap_fh; + int ret; + + if (!bcap_dev->sd) { + v4l2_err(&bcap_dev->v4l2_dev, "No sub device registered\n"); + return -ENODEV; + } + + bcap_fh = kzalloc(sizeof(*bcap_fh), GFP_KERNEL); + if (!bcap_fh) { + v4l2_err(&bcap_dev->v4l2_dev, + "unable to allocate memory for file handle object\n"); + return -ENOMEM; + } + + ret = v4l2_fh_init(&bcap_fh->fh, vfd); + if (ret) { + kfree(bcap_fh); + return ret; + } + + /* store pointer to v4l2_fh in private_data member of file */ + file->private_data = &bcap_fh->fh; + v4l2_fh_add(&bcap_fh->fh); + bcap_fh->bcap_dev = bcap_dev; + bcap_dev->usrs++; + bcap_fh->io_allowed = 0; + return 0; +} + +static int bcap_release(struct file *file) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + struct v4l2_fh *fh = file->private_data; + struct bcap_fh *bcap_fh = container_of(fh, struct bcap_fh, fh); + + /* if this instance is doing IO */ + if (bcap_fh->io_allowed) { + vb2_queue_release(&bcap_dev->buffer_queue); + bcap_dev->io_usrs = 0; + } + + bcap_dev->usrs--; + file->private_data = NULL; + v4l2_fh_del(&bcap_fh->fh); + v4l2_fh_exit(&bcap_fh->fh); + kfree(bcap_fh); + return 0; +} + +static int bcap_mmap(struct file *file, struct vm_area_struct *vma) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + return vb2_mmap(&bcap_dev->buffer_queue, vma); +} + +#ifndef CONFIG_MMU +static unsigned long bcap_get_unmapped_area(struct file *file, + unsigned long addr, + unsigned long len, + unsigned long pgoff, + unsigned long flags) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + return vb2_get_unmapped_area(&bcap_dev->buffer_queue, + addr, + len, + pgoff, + flags); +} +#endif + +static unsigned int bcap_poll(struct file *file, poll_table *wait) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + if (bcap_dev->started) + return vb2_poll(&bcap_dev->buffer_queue, file, wait); + return 0; +} + +static int bcap_queue_setup(struct vb2_queue *vq, unsigned int *nbuffers, + unsigned int *nplanes, unsigned long sizes[], + void *alloc_ctxs[]) +{ + struct bcap_device *bcap_dev = vb2_get_drv_priv(vq); + + if (*nbuffers < BCAP_MIN_NUM_BUF) + *nbuffers = BCAP_MIN_NUM_BUF; + + *nplanes = 1; + sizes[0] = bcap_dev->fmt.sizeimage; + alloc_ctxs[0] = bcap_dev->alloc_ctx; + + return 0; +} + +static int bcap_buffer_init(struct vb2_buffer *vb) +{ + struct bcap_buffer *buf = to_bcap_vb(vb); + + INIT_LIST_HEAD(&buf->list); + return 0; +} + +static int bcap_buffer_prepare(struct vb2_buffer *vb) +{ + struct bcap_device *bcap_dev = vb2_get_drv_priv(vb->vb2_queue); + struct bcap_buffer *buf = to_bcap_vb(vb); + unsigned long size; + + size = bcap_dev->fmt.sizeimage; + if (vb2_plane_size(vb, 0) < size) { + v4l2_err(&bcap_dev->v4l2_dev, "buffer too small (%lu < %lu)\n", + vb2_plane_size(vb, 0), size); + return -EINVAL; + } + vb2_set_plane_payload(&buf->vb, 0, size); + + return 0; +} + +static void bcap_buffer_queue(struct vb2_buffer *vb) +{ + struct bcap_device *bcap_dev = vb2_get_drv_priv(vb->vb2_queue); + struct bcap_buffer *buf = to_bcap_vb(vb); + unsigned long flags = 0; + + spin_lock_irqsave(&bcap_dev->lock, flags); + list_add_tail(&buf->list, &bcap_dev->dma_queue); + spin_unlock_irqrestore(&bcap_dev->lock, flags); +} + +static void bcap_buffer_cleanup(struct vb2_buffer *vb) +{ + struct bcap_device *bcap_dev = vb2_get_drv_priv(vb->vb2_queue); + struct bcap_buffer *buf = to_bcap_vb(vb); + unsigned long flags = 0; + + spin_lock_irqsave(&bcap_dev->lock, flags); + list_del_init(&buf->list); + spin_unlock_irqrestore(&bcap_dev->lock, flags); +} + +static void bcap_lock(struct vb2_queue *vq) +{ + struct bcap_device *bcap_dev = vb2_get_drv_priv(vq); + mutex_lock(&bcap_dev->mutex); +} + +static void bcap_unlock(struct vb2_queue *vq) +{ + struct bcap_device *bcap_dev = vb2_get_drv_priv(vq); + mutex_unlock(&bcap_dev->mutex); +} + +static int bcap_start_streaming(struct vb2_queue *vq) +{ + struct bcap_device *bcap_dev = vb2_get_drv_priv(vq); + struct ppi_if *ppi = bcap_dev->ppi; + struct ppi_params params; + int ret; + + /* enable streamon on the sub device */ + ret = v4l2_subdev_call(bcap_dev->sd, video, s_stream, 1); + if (ret && (ret != -ENOIOCTLCMD)) { + v4l2_err(&bcap_dev->v4l2_dev, "stream on failed in subdev\n"); + return ret; + } + + /* attach ppi DMA irq handler */ + ret = ppi->ops->attach_irq(ppi, bcap_isr); + if (ret < 0) { + v4l2_err(&bcap_dev->v4l2_dev, + "Error in attaching interrupt handler\n"); + return -EFAULT; + } + + /* set ppi params */ + params.width = bcap_dev->fmt.width; + params.height = bcap_dev->fmt.height; + params.bpp = bcap_dev->bpp; + params.ppi_control = bcap_dev->cfg->ppi_control; + ret = ppi->ops->set_params(ppi, ¶ms); + if (ret < 0) { + v4l2_err(&bcap_dev->v4l2_dev, + "Error in setting ppi params\n"); + ppi->ops->detach_irq(ppi); + return -EINVAL; + } + + INIT_COMPLETION(bcap_dev->comp); + return 0; +} + +static int bcap_stop_streaming(struct vb2_queue *vq) +{ + struct bcap_device *bcap_dev = vb2_get_drv_priv(vq); + struct ppi_if *ppi = bcap_dev->ppi; + int ret; + + if (bcap_dev->started) { + bcap_dev->started = 0; + wait_for_completion(&bcap_dev->comp); + ppi->ops->stop(ppi); + ppi->ops->detach_irq(ppi); + ret = v4l2_subdev_call(bcap_dev->sd, video, s_stream, 0); + if (ret && (ret != -ENOIOCTLCMD)) + v4l2_err(&bcap_dev->v4l2_dev, + "stream off failed in subdev\n"); + + /* release all active buffers */ + while (!list_empty(&bcap_dev->dma_queue)) { + bcap_dev->next_frm = list_entry(bcap_dev->dma_queue.next, + struct bcap_buffer, list); + list_del(&bcap_dev->next_frm->list); + vb2_buffer_done(&bcap_dev->next_frm->vb, VB2_BUF_STATE_ERROR); + } + } + return 0; +} + +static struct vb2_ops bcap_video_qops = { + .queue_setup = bcap_queue_setup, + .buf_init = bcap_buffer_init, + .buf_prepare = bcap_buffer_prepare, + .buf_cleanup = bcap_buffer_cleanup, + .buf_queue = bcap_buffer_queue, + .wait_prepare = bcap_unlock, + .wait_finish = bcap_lock, + .start_streaming = bcap_start_streaming, + .stop_streaming = bcap_stop_streaming, +}; + +static int bcap_reqbufs(struct file *file, void *priv, + struct v4l2_requestbuffers *req_buf) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + struct v4l2_fh *fh = file->private_data; + struct bcap_fh *bcap_fh = container_of(fh, struct bcap_fh, fh); + + if (bcap_dev->io_usrs != 0) { + v4l2_err(&bcap_dev->v4l2_dev, "Only one IO user allowed\n"); + return -EBUSY; + } + + bcap_fh->io_allowed = 1; + bcap_dev->io_usrs = 1; + + return vb2_reqbufs(&bcap_dev->buffer_queue, req_buf); +} + +static int bcap_querybuf(struct file *file, void *priv, + struct v4l2_buffer *buf) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + return vb2_querybuf(&bcap_dev->buffer_queue, buf); +} + +static int bcap_qbuf(struct file *file, void *priv, + struct v4l2_buffer *buf) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + struct v4l2_fh *fh = file->private_data; + struct bcap_fh *bcap_fh = container_of(fh, struct bcap_fh, fh); + + if (!bcap_fh->io_allowed) + return -EACCES; + + return vb2_qbuf(&bcap_dev->buffer_queue, buf); +} + +static int bcap_dqbuf(struct file *file, void *priv, + struct v4l2_buffer *buf) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + struct v4l2_fh *fh = file->private_data; + struct bcap_fh *bcap_fh = container_of(fh, struct bcap_fh, fh); + + if (!bcap_fh->io_allowed) + return -EACCES; + + return vb2_dqbuf(&bcap_dev->buffer_queue, + buf, file->f_flags & O_NONBLOCK); +} + +static irqreturn_t bcap_isr(int irq, void *dev_id) +{ + struct ppi_if *ppi = dev_id; + struct bcap_device *bcap_dev = ppi->priv; + struct timeval timevalue; + struct vb2_buffer *vb = &bcap_dev->cur_frm->vb; + dma_addr_t *addr; + + spin_lock(&bcap_dev->lock); + + if (bcap_dev->cur_frm != bcap_dev->next_frm) { + do_gettimeofday(&timevalue); + vb->v4l2_buf.timestamp = timevalue; + vb2_buffer_done(vb, VB2_BUF_STATE_DONE); + bcap_dev->cur_frm = bcap_dev->next_frm; + } + + ppi->ops->stop(ppi); + + if (!bcap_dev->started) + complete(&bcap_dev->comp); + else { + if (!list_empty(&bcap_dev->dma_queue)) { + bcap_dev->next_frm = list_entry(bcap_dev->dma_queue.next, + struct bcap_buffer, list); + list_del(&bcap_dev->next_frm->list); + addr = vb2_plane_cookie(&bcap_dev->next_frm->vb, 0); + ppi->ops->update_addr(ppi, (unsigned long)(*addr)); + } + ppi->ops->start(ppi); + } + + spin_unlock(&bcap_dev->lock); + + return IRQ_HANDLED; +} + +static int bcap_streamon(struct file *file, void *priv, + enum v4l2_buf_type buf_type) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + struct bcap_fh *fh = file->private_data; + struct ppi_if *ppi = bcap_dev->ppi; + dma_addr_t *addr; + int ret; + + if (!fh->io_allowed) + return -EACCES; + + if (bcap_dev->started) + return -EBUSY; + + /* call streamon to start streaming in videobuf */ + ret = vb2_streamon(&bcap_dev->buffer_queue, buf_type); + if (ret) + return ret; + + /* if dma queue is empty, return error */ + if (list_empty(&bcap_dev->dma_queue)) { + v4l2_err(&bcap_dev->v4l2_dev, "dma queue is empty\n"); + ret = -EIO; + goto err; + } + + /* get the next frame from the dma queue */ + bcap_dev->next_frm = list_entry(bcap_dev->dma_queue.next, + struct bcap_buffer, list); + bcap_dev->cur_frm = bcap_dev->next_frm; + /* remove buffer from the dma queue */ + list_del(&bcap_dev->cur_frm->list); + addr = vb2_plane_cookie(&bcap_dev->cur_frm->vb, 0); + /* update DMA address */ + ppi->ops->update_addr(ppi, (unsigned long)(*addr)); + /* enable ppi */ + ppi->ops->start(ppi); + bcap_dev->started = 1; + + return 0; +err: + vb2_streamoff(&bcap_dev->buffer_queue, buf_type); + return ret; +} + +static int bcap_streamoff(struct file *file, void *priv, + enum v4l2_buf_type buf_type) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + struct bcap_fh *fh = file->private_data; + + if (!fh->io_allowed) + return -EACCES; + + if (!bcap_dev->started) + return -EINVAL; + + return vb2_streamoff(&bcap_dev->buffer_queue, buf_type); +} + +static int bcap_queryctrl(struct file *file, void *priv, + struct v4l2_queryctrl *qctrl) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + return v4l2_subdev_call(bcap_dev->sd, core, queryctrl, qctrl); +} + +static int bcap_g_ctrl(struct file *file, void *priv, + struct v4l2_control *ctrl) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + return v4l2_subdev_call(bcap_dev->sd, core, g_ctrl, ctrl); +} + +static int bcap_s_ctrl(struct file *file, void *priv, + struct v4l2_control *ctrl) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + return v4l2_subdev_call(bcap_dev->sd, core, s_ctrl, ctrl); +} + +static int bcap_querystd(struct file *file, void *priv, v4l2_std_id *std) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + int ret; + + ret = v4l2_subdev_call(bcap_dev->sd, video, querystd, std); + return ret; +} + +static int bcap_g_std(struct file *file, void *priv, v4l2_std_id *std) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + if (bcap_dev->std) { + *std = bcap_dev->std; + return 0; + } else + return -EINVAL; +} + +static int bcap_s_std(struct file *file, void *priv, v4l2_std_id *std) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + int ret; + + /* if streaming is started, return error */ + if (bcap_dev->started) { + v4l2_err(&bcap_dev->v4l2_dev, "Streaming is started\n"); + return -EBUSY; + } + + ret = v4l2_subdev_call(bcap_dev->sd, core, s_std, *std); + if (ret < 0) + return ret; + + bcap_dev->std = *std; + return 0; +} + +static int bcap_enum_input(struct file *file, void *priv, + struct v4l2_input *input) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + struct bfin_capture_config *config = bcap_dev->cfg; + int ret; + u32 status; + + if (input->index >= config->num_inputs) + return -EINVAL; + + memcpy(input, &config->inputs[input->index], + sizeof(*input)); + /* get input status */ + ret = v4l2_subdev_call(bcap_dev->sd, video, g_input_status, &status); + if (!ret) + input->status = status; + return 0; +} + +static int bcap_g_input(struct file *file, void *priv, unsigned int *index) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + *index = bcap_dev->cur_input; + return 0; +} + +static int bcap_s_input(struct file *file, void *priv, unsigned int index) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + struct bfin_capture_config *config = bcap_dev->cfg; + struct bcap_route *route; + int ret; + + /* if streaming is started, return error */ + if (bcap_dev->started) { + v4l2_err(&bcap_dev->v4l2_dev, "Streaming is started\n"); + return -EBUSY; + } + + if (index >= config->num_inputs) + return -EINVAL; + + route = &config->routes[index]; + ret = v4l2_subdev_call(bcap_dev->sd, video, s_routing, + route->input, route->output, 0); + if ((ret < 0) && (ret != -ENOIOCTLCMD)) { + v4l2_err(&bcap_dev->v4l2_dev, "Failed to set input\n"); + return ret; + } + bcap_dev->cur_input = index; + return 0; +} + +static int bcap_try_format(struct bcap_device *bcap, + struct v4l2_pix_format *pixfmt, + enum v4l2_mbus_pixelcode *mbus_code, + int *bpp) +{ + const struct bcap_format *fmt; + struct v4l2_mbus_framefmt mbus_fmt; + int ret, i; + + for (i = 0; i < BCAP_MAX_FMTS; i++) { + if ((pixfmt->pixelformat == bcap_formats[i].pixelformat)) { + fmt = &bcap_formats[i]; + if (mbus_code) + *mbus_code = fmt->mbus_code; + if (bpp) + *bpp = fmt->bpp; + v4l2_fill_mbus_format(&mbus_fmt, pixfmt, + fmt->mbus_code); + ret = v4l2_subdev_call(bcap->sd, video, + try_mbus_fmt, &mbus_fmt); + if (ret < 0) + return ret; + v4l2_fill_pix_format(pixfmt, &mbus_fmt); + pixfmt->bytesperline = pixfmt->width * fmt->bpp; + pixfmt->sizeimage = pixfmt->bytesperline + * pixfmt->height; + return 0; + } + } + return -EINVAL; +} + +static int bcap_enum_fmt_vid_cap(struct file *file, void *priv, + struct v4l2_fmtdesc *fmt) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + enum v4l2_mbus_pixelcode mbus_code; + u32 index = fmt->index; + int ret, i; + + ret = v4l2_subdev_call(bcap_dev->sd, video, + enum_mbus_fmt, index, &mbus_code); + if (ret < 0) + return ret; + + for (i = 0; i < BCAP_MAX_FMTS; i++) { + if (mbus_code == bcap_formats[i].mbus_code) { + fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + strlcpy(fmt->description, + bcap_formats[index].desc, + sizeof(fmt->description)); + fmt->pixelformat = bcap_formats[index].pixelformat; + return 0; + } + } + v4l2_err(&bcap_dev->v4l2_dev, + "subdev fmt is not supported by bcap\n"); + return -EINVAL; +} + +static int bcap_try_fmt_vid_cap(struct file *file, void *priv, + struct v4l2_format *fmt) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + struct v4l2_pix_format *pixfmt = &fmt->fmt.pix; + + if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) + return -EINVAL; + + return bcap_try_format(bcap_dev, pixfmt, NULL, NULL); +} + +static int bcap_g_fmt_vid_cap(struct file *file, void *priv, + struct v4l2_format *fmt) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + struct v4l2_mbus_framefmt mbus_fmt; + const struct bcap_format *bcap_fmt; + struct v4l2_pix_format *pixfmt = &fmt->fmt.pix; + int ret, i; + + if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) + return -EINVAL; + + ret = v4l2_subdev_call(bcap_dev->sd, video, + g_mbus_fmt, &mbus_fmt); + if (ret < 0) + return ret; + + for (i = 0; i < BCAP_MAX_FMTS; i++) { + if (mbus_fmt.code == bcap_formats[i].mbus_code) { + bcap_fmt = &bcap_formats[i]; + v4l2_fill_pix_format(pixfmt, &mbus_fmt); + pixfmt->bytesperline = pixfmt->width * bcap_fmt->bpp; + pixfmt->sizeimage = pixfmt->bytesperline + * pixfmt->height; + return 0; + } + } + v4l2_err(&bcap_dev->v4l2_dev, + "subdev fmt is not supported by bcap\n"); + return -EINVAL; +} + +static int bcap_s_fmt_vid_cap(struct file *file, void *priv, + struct v4l2_format *fmt) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + struct v4l2_mbus_framefmt mbus_fmt; + enum v4l2_mbus_pixelcode mbus_code; + struct v4l2_pix_format *pixfmt = &fmt->fmt.pix; + int ret, bpp; + + /* if streaming is started, return error */ + if (bcap_dev->started) { + v4l2_err(&bcap_dev->v4l2_dev, "Streaming is started\n"); + return -EBUSY; + } + + if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) + return -EINVAL; + /* see if format works */ + ret = bcap_try_format(bcap_dev, pixfmt, &mbus_code, &bpp); + if (ret < 0) + return ret; + + v4l2_fill_mbus_format(&mbus_fmt, pixfmt, mbus_code); + ret = v4l2_subdev_call(bcap_dev->sd, video, s_mbus_fmt, &mbus_fmt); + if (ret < 0) + return ret; + bcap_dev->fmt = *pixfmt; + bcap_dev->bpp = bpp; + return 0; +} + +static int bcap_querycap(struct file *file, void *priv, + struct v4l2_capability *cap) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; + strlcpy(cap->driver, CAPTURE_DRV_NAME, sizeof(cap->driver)); + strlcpy(cap->bus_info, "Blackfin Platform", sizeof(cap->bus_info)); + strlcpy(cap->card, bcap_dev->cfg->card_name, sizeof(cap->card)); + return 0; +} + +static int bcap_cropcap(struct file *file, void *priv, + struct v4l2_cropcap *crop) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) + return -EINVAL; + + return v4l2_subdev_call(bcap_dev->sd, video, cropcap, crop); +} + +static int bcap_g_parm(struct file *file, void *fh, + struct v4l2_streamparm *a) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) + return -EINVAL; + return v4l2_subdev_call(bcap_dev->sd, video, g_parm, a); +} + +static int bcap_s_parm(struct file *file, void *fh, + struct v4l2_streamparm *a) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) + return -EINVAL; + return v4l2_subdev_call(bcap_dev->sd, video, s_parm, a); +} + +static int bcap_g_chip_ident(struct file *file, void *priv, + struct v4l2_dbg_chip_ident *chip) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + chip->ident = V4L2_IDENT_NONE; + chip->revision = 0; + if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER && + chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR) + return -EINVAL; + + return v4l2_subdev_call(bcap_dev->sd, core, + g_chip_ident, chip); +} + +#ifdef CONFIG_VIDEO_ADV_DEBUG +static int bcap_dbg_g_register(struct file *file, void *priv, + struct v4l2_dbg_register *reg) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + return v4l2_subdev_call(bcap_dev->sd, core, + g_register, reg); +} + +static int bcap_dbg_s_register(struct file *file, void *priv, + struct v4l2_dbg_register *reg) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + + return v4l2_subdev_call(bcap_dev->sd, core, + s_register, reg); +} +#endif + +static int bcap_log_status(struct file *file, void *priv) +{ + struct bcap_device *bcap_dev = video_drvdata(file); + /* status for sub devices */ + v4l2_device_call_all(&bcap_dev->v4l2_dev, 0, core, log_status); + return 0; +} + +static const struct v4l2_ioctl_ops bcap_ioctl_ops = { + .vidioc_querycap = bcap_querycap, + .vidioc_g_fmt_vid_cap = bcap_g_fmt_vid_cap, + .vidioc_enum_fmt_vid_cap = bcap_enum_fmt_vid_cap, + .vidioc_s_fmt_vid_cap = bcap_s_fmt_vid_cap, + .vidioc_try_fmt_vid_cap = bcap_try_fmt_vid_cap, + .vidioc_enum_input = bcap_enum_input, + .vidioc_g_input = bcap_g_input, + .vidioc_s_input = bcap_s_input, + .vidioc_querystd = bcap_querystd, + .vidioc_s_std = bcap_s_std, + .vidioc_g_std = bcap_g_std, + .vidioc_queryctrl = bcap_queryctrl, + .vidioc_g_ctrl = bcap_g_ctrl, + .vidioc_s_ctrl = bcap_s_ctrl, + .vidioc_reqbufs = bcap_reqbufs, + .vidioc_querybuf = bcap_querybuf, + .vidioc_qbuf = bcap_qbuf, + .vidioc_dqbuf = bcap_dqbuf, + .vidioc_streamon = bcap_streamon, + .vidioc_streamoff = bcap_streamoff, + .vidioc_cropcap = bcap_cropcap, + .vidioc_g_parm = bcap_g_parm, + .vidioc_s_parm = bcap_s_parm, + .vidioc_g_chip_ident = bcap_g_chip_ident, +#ifdef CONFIG_VIDEO_ADV_DEBUG + .vidioc_g_register = bcap_dbg_g_register, + .vidioc_s_register = bcap_dbg_s_register, +#endif + .vidioc_log_status = bcap_log_status, +}; + +static struct v4l2_file_operations bcap_fops = { + .owner = THIS_MODULE, + .open = bcap_open, + .release = bcap_release, + .unlocked_ioctl = video_ioctl2, + .mmap = bcap_mmap, +#ifndef CONFIG_MMU + .get_unmapped_area = bcap_get_unmapped_area, +#endif + .poll = bcap_poll +}; + +static int __devinit bcap_probe(struct platform_device *pdev) +{ + struct bcap_device *bcap_dev; + struct video_device *vfd; + struct i2c_adapter *i2c_adap; + struct bfin_capture_config *config; + struct vb2_queue *q; + int ret; + + config = pdev->dev.platform_data; + if (!config) { + v4l2_err(pdev->dev.driver, "Unable to get board config\n"); + return -ENODEV; + } + + bcap_dev = kzalloc(sizeof(*bcap_dev), GFP_KERNEL); + if (!bcap_dev) { + v4l2_err(pdev->dev.driver, "Unable to alloc bcap_dev\n"); + return -ENOMEM; + } + + bcap_dev->cfg = config; + + bcap_dev->ppi = create_ppi_instance(config->ppi_info); + if (!bcap_dev->ppi) { + v4l2_err(pdev->dev.driver, "Unable to create ppi\n"); + ret = -ENODEV; + goto err_free_dev; + } + bcap_dev->ppi->priv = bcap_dev; + + bcap_dev->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev); + if (IS_ERR(bcap_dev->alloc_ctx)) { + ret = PTR_ERR(bcap_dev->alloc_ctx); + goto err_free_ppi; + } + + vfd = video_device_alloc(); + if (!vfd) { + ret = -ENOMEM; + v4l2_err(pdev->dev.driver, "Unable to alloc video device\n"); + goto err_cleanup_ctx; + } + + /* initialize field of video device */ + vfd->release = video_device_release; + vfd->fops = &bcap_fops; + vfd->ioctl_ops = &bcap_ioctl_ops; + vfd->tvnorms = 0; + vfd->v4l2_dev = &bcap_dev->v4l2_dev; + set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); + strncpy(vfd->name, CAPTURE_DRV_NAME, sizeof(vfd->name)); + bcap_dev->video_dev = vfd; + + ret = v4l2_device_register(&pdev->dev, &bcap_dev->v4l2_dev); + if (ret) { + v4l2_err(pdev->dev.driver, + "Unable to register v4l2 device\n"); + goto err_release_vdev; + } + v4l2_info(&bcap_dev->v4l2_dev, "v4l2 device registered\n"); + + spin_lock_init(&bcap_dev->lock); + /* initialize queue */ + q = &bcap_dev->buffer_queue; + memset(q, 0, sizeof(*q)); + q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + q->io_modes = VB2_MMAP; + q->drv_priv = bcap_dev; + q->buf_struct_size = sizeof(struct bcap_buffer); + q->ops = &bcap_video_qops; + q->mem_ops = &vb2_dma_contig_memops; + + vb2_queue_init(q); + + mutex_init(&bcap_dev->mutex); + init_completion(&bcap_dev->comp); + + /* init video dma queues */ + INIT_LIST_HEAD(&bcap_dev->dma_queue); + + vfd->lock = &bcap_dev->mutex; + + /* register video device */ + ret = video_register_device(bcap_dev->video_dev, VFL_TYPE_GRABBER, -1); + if (ret) { + v4l2_err(&bcap_dev->v4l2_dev, + "Unable to register video device\n"); + goto err_unreg_v4l2; + } + video_set_drvdata(bcap_dev->video_dev, bcap_dev); + v4l2_info(&bcap_dev->v4l2_dev, "video device registered as: %s\n", + video_device_node_name(vfd)); + + /* load up the subdevice */ + i2c_adap = i2c_get_adapter(config->i2c_adapter_id); + if (!i2c_adap) { + v4l2_err(&bcap_dev->v4l2_dev, + "Unable to find i2c adapter\n"); + goto err_unreg_vdev; + + } + bcap_dev->sd = v4l2_i2c_new_subdev_board(&bcap_dev->v4l2_dev, + i2c_adap, + &config->board_info, + NULL); + if (bcap_dev->sd) { + int i; + /* update tvnorms from the sub devices */ + for (i = 0; i < config->num_inputs; i++) + vfd->tvnorms |= config->inputs[i].std; + /* set default std */ + bcap_dev->std = vfd->tvnorms; + } else { + v4l2_err(&bcap_dev->v4l2_dev, + "Unable to register sub device\n"); + goto err_unreg_vdev; + } + v4l2_info(&bcap_dev->v4l2_dev, "v4l2 sub device registered\n"); + return 0; +err_unreg_vdev: + video_unregister_device(bcap_dev->video_dev); +err_unreg_v4l2: + v4l2_device_unregister(&bcap_dev->v4l2_dev); +err_release_vdev: + if (!video_is_registered(bcap_dev->video_dev)) + video_device_release(bcap_dev->video_dev); +err_cleanup_ctx: + vb2_dma_contig_cleanup_ctx(bcap_dev->alloc_ctx); +err_free_ppi: + delete_ppi_instance(bcap_dev->ppi); +err_free_dev: + kfree(bcap_dev); + return ret; +} + +static int __devexit bcap_remove(struct platform_device *pdev) +{ + struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev); + struct bcap_device *bcap_dev = container_of(v4l2_dev, + struct bcap_device, v4l2_dev); + + video_unregister_device(bcap_dev->video_dev); + v4l2_device_unregister(v4l2_dev); + vb2_dma_contig_cleanup_ctx(bcap_dev->alloc_ctx); + delete_ppi_instance(bcap_dev->ppi); + kfree(bcap_dev); + return 0; +} + +static struct platform_driver bcap_driver = { + .driver = { + .name = CAPTURE_DRV_NAME, + .owner = THIS_MODULE, + }, + .probe = bcap_probe, + .remove = __devexit_p(bcap_remove), +}; + +static __init int bcap_init(void) +{ + return platform_driver_register(&bcap_driver); +} + +static __exit void bcap_exit(void) +{ + platform_driver_unregister(&bcap_driver); +} + +module_init(bcap_init); +module_exit(bcap_exit); + +MODULE_DESCRIPTION("Analog Devices video capture driver"); +MODULE_AUTHOR("Scott Jiang <Scott.Jiang.Linux@gmail.com>"); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/media/video/blackfin/ppi.c b/drivers/media/video/blackfin/ppi.c new file mode 100644 index 0000000..8139940 --- /dev/null +++ b/drivers/media/video/blackfin/ppi.c @@ -0,0 +1,204 @@ +/* + * ppi.c Analog Devices Parallel Peripheral Interface driver + * + * Copyright (c) 2011 Analog Devices Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include <linux/kernel.h> +#include <linux/slab.h> +#include <linux/ioport.h> +#include <linux/platform_device.h> + +#include <asm/bfin_ppi.h> +#include <asm/dma.h> +#include <asm/cacheflush.h> +#include <asm/blackfin.h> +#include <asm/portmux.h> + +#include <media/blackfin/ppi.h> + +static int ppi_attach_irq(struct ppi_if *ppi, irq_handler_t handler); +static void ppi_detach_irq(struct ppi_if *ppi); +static int ppi_start(struct ppi_if *ppi); +static int ppi_stop(struct ppi_if *ppi); +static int ppi_set_params(struct ppi_if *ppi, struct ppi_params *params); +static void ppi_update_addr(struct ppi_if *ppi, unsigned long addr); + +static const struct ppi_ops ppi_ops = { + .attach_irq = ppi_attach_irq, + .detach_irq = ppi_detach_irq, + .start = ppi_start, + .stop = ppi_stop, + .set_params = ppi_set_params, + .update_addr = ppi_update_addr, +}; + +static irqreturn_t ppi_irq_err(int irq, void *dev_id) +{ + struct ppi_if *ppi = dev_id; + const struct ppi_info *info = ppi->info; + unsigned short status; + + if (!strcmp(info->name, "ppi")) { + struct bfin_ppi_regs __iomem *reg = + (struct bfin_ppi_regs __iomem *)info->base; + status = bfin_read16(reg->status); + if (printk_ratelimit()) + pr_info("%s: status = 0x%x\n", __func__, status); + bfin_write16(®->status, 0xff); + } + + return IRQ_HANDLED; +} + +static int ppi_attach_irq(struct ppi_if *ppi, irq_handler_t handler) +{ + const struct ppi_info *info = ppi->info; + + if (request_dma(info->dma_ch, "PPI_DMA") < 0) { + pr_err("Unable to allocate DMA channel for PPI\n"); + return -EBUSY; + } + set_dma_callback(info->dma_ch, handler, ppi); + + if (request_irq(info->irq_err, ppi_irq_err, IRQF_DISABLED, + "PPI ERROR", ppi)) { + pr_err("Unable to allocate IRQ for PPI\n"); + free_dma(info->dma_ch); + return -EBUSY; + } + return 0; +} + +static void ppi_detach_irq(struct ppi_if *ppi) +{ + const struct ppi_info *info = ppi->info; + + free_irq(info->irq_err, ppi); + free_dma(info->dma_ch); +} + +static int ppi_start(struct ppi_if *ppi) +{ + const struct ppi_info *info = ppi->info; + + /* enable DMA */ + enable_dma(info->dma_ch); + + /* enable PPI */ + ppi->ppi_control |= PORT_EN; + if (!strcmp(info->name, "ppi")) { + struct bfin_ppi_regs __iomem *reg = + (struct bfin_ppi_regs __iomem *)info->base; + bfin_write16(®->control, ppi->ppi_control); + } + + SSYNC(); + return 0; +} + +static int ppi_stop(struct ppi_if *ppi) +{ + const struct ppi_info *info = ppi->info; + + /* disable PPI */ + ppi->ppi_control &= ~PORT_EN; + if (!strcmp(info->name, "ppi")) { + struct bfin_ppi_regs __iomem *reg = + (struct bfin_ppi_regs __iomem *)info->base; + bfin_write16(®->control, ppi->ppi_control); + } + + /* disable DMA */ + clear_dma_irqstat(info->dma_ch); + disable_dma(info->dma_ch); + + SSYNC(); + return 0; +} + +static int ppi_set_params(struct ppi_if *ppi, struct ppi_params *params) +{ + const struct ppi_info *info = ppi->info; + + ppi->bytes_per_line = params->width * params->bpp; + ppi->lines_per_frame = params->height; + + /* config DMA */ + ppi->dma_config = (DMA_FLOW_STOP | WNR | RESTART | DMA2D | DI_EN); + if (params->ppi_control & DMA32) { + ppi->dma_config |= WDSIZE_32; + set_dma_x_count(info->dma_ch, ppi->bytes_per_line >> 2); + set_dma_x_modify(info->dma_ch, 4); + set_dma_y_modify(info->dma_ch, 4); + } else { + ppi->dma_config |= WDSIZE_16; + set_dma_x_count(info->dma_ch, ppi->bytes_per_line >> 1); + set_dma_x_modify(info->dma_ch, 2); + set_dma_y_modify(info->dma_ch, 2); + } + set_dma_y_count(info->dma_ch, ppi->lines_per_frame); + set_dma_config(info->dma_ch, ppi->dma_config); + + /* config PPI */ + ppi->ppi_control = params->ppi_control & ~PORT_EN; + if (!strcmp(info->name, "ppi")) { + struct bfin_ppi_regs __iomem *reg = + (struct bfin_ppi_regs __iomem *)info->base; + bfin_write16(®->control, ppi->ppi_control); + bfin_write16(®->count, ppi->bytes_per_line - 1); + bfin_write16(®->frame, ppi->lines_per_frame); + } + + SSYNC(); + return 0; +} + +static void ppi_update_addr(struct ppi_if *ppi, unsigned long addr) +{ + set_dma_start_addr(ppi->info->dma_ch, addr); +} + +struct ppi_if *create_ppi_instance(const struct ppi_info *info) +{ + struct ppi_if *ppi; + + if ((info == NULL) || (info->name == NULL) || (info->pin_req == NULL)) + return NULL; + + if (peripheral_request_list(info->pin_req, KBUILD_MODNAME)) { + pr_err("request peripheral failed\n"); + return NULL; + } + + ppi = kzalloc(sizeof(*ppi), GFP_KERNEL); + if (ppi == NULL) { + peripheral_free_list(info->pin_req); + pr_err("unable to allocate memory for ppi handle\n"); + return NULL; + } + ppi->ops = &ppi_ops; + ppi->info = info; + + pr_info("ppi probe success\n"); + return ppi; +} + +void delete_ppi_instance(struct ppi_if *ppi) +{ + peripheral_free_list(ppi->info->pin_req); + kfree(ppi); +} -- 1.7.0.4 ^ permalink raw reply related [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-13 18:34 ` [PATCH 4/4] v4l2: add blackfin capture bridge driver Scott Jiang @ 2011-09-13 8:11 ` Guennadi Liakhovetski 2011-09-13 9:56 ` Scott Jiang 2011-09-15 6:37 ` Scott Jiang 2011-09-13 21:19 ` Sylwester Nawrocki ` (2 subsequent siblings) 3 siblings, 2 replies; 39+ messages in thread From: Guennadi Liakhovetski @ 2011-09-13 8:11 UTC (permalink / raw) To: Scott Jiang Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel Again, no complete review, just a couple of remarks On Tue, 13 Sep 2011, Scott Jiang wrote: > this is a v4l2 bridge driver for Blackfin video capture device, > support ppi interface > > Signed-off-by: Scott Jiang <scott.jiang.linux@gmail.com> > --- [snip] > diff --git a/drivers/media/video/blackfin/bfin_capture.c b/drivers/media/video/blackfin/bfin_capture.c > new file mode 100644 > index 0000000..24f89f2 > --- /dev/null > +++ b/drivers/media/video/blackfin/bfin_capture.c > @@ -0,0 +1,1099 @@ > +/* > + * Analog Devices video capture driver > + * > + * Copyright (c) 2011 Analog Devices Inc. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License version 2 as > + * published by the Free Software Foundation. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * You should have received a copy of the GNU General Public License > + * along with this program; if not, write to the Free Software > + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. > + */ > + > + > +#include <linux/kernel.h> > +#include <linux/init.h> > +#include <linux/module.h> > +#include <linux/io.h> > +#include <linux/delay.h> > +#include <linux/errno.h> > +#include <linux/fs.h> > +#include <linux/interrupt.h> > +#include <linux/completion.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> > +#include <linux/sched.h> > +#include <linux/slab.h> > + > +#include <media/v4l2-common.h> > +#include <media/v4l2-ioctl.h> > +#include <media/v4l2-device.h> > +#include <media/videobuf2-dma-contig.h> > +#include <media/v4l2-chip-ident.h> > + > +#include <asm/dma.h> > + > +#include <media/blackfin/bfin_capture.h> Alphabetic order of headers is preferred. Also holds for other your patches. > + > +#define CAPTURE_DRV_NAME "bfin_capture" > +#define BCAP_MIN_NUM_BUF 2 > + > +struct bcap_format { > + u8 *desc; > + u32 pixelformat; > + enum v4l2_mbus_pixelcode mbus_code; > + int bpp; /* bytes per pixel */ Don't you think you might have to process 12 bpp formats at some point, like YUV 4:2:0, or NV12? Maybe better calculate in bits from the beginning? > +}; > + > +struct bcap_buffer { > + struct vb2_buffer vb; > + struct list_head list; > +}; > + > +struct bcap_device { > + /* capture device instance */ > + struct v4l2_device v4l2_dev; > + /* device node data */ > + struct video_device *video_dev; > + /* sub device instance */ > + struct v4l2_subdev *sd; > + /* caputre config */ > + struct bfin_capture_config *cfg; > + /* ppi interface */ > + struct ppi_if *ppi; > + /* current input */ > + unsigned int cur_input; > + /* current selected standard */ > + v4l2_std_id std; > + /* used to store pixel format */ > + struct v4l2_pix_format fmt; > + /* bytes per pixel*/ > + int bpp; > + /* pointing to current video buffer */ > + struct bcap_buffer *cur_frm; > + /* pointing to next video buffer */ > + struct bcap_buffer *next_frm; > + /* buffer queue used in videobuf2 */ > + struct vb2_queue buffer_queue; > + /* allocator-specific contexts for each plane */ > + struct vb2_alloc_ctx *alloc_ctx; > + /* queue of filled frames */ > + struct list_head dma_queue; > + /* used in videobuf2 callback */ > + spinlock_t lock; > + /* used to access capture device */ > + struct mutex mutex; > + /* used to wait ppi to complete one transfer */ > + struct completion comp; > + /* number of users performing IO */ > + u32 io_usrs; Does it really have to be fixed 32 bits? Seems a plane simple int would do just fine. > + /* number of open instances of the device */ > + u32 usrs; ditto > + /* indicate whether streaming has started */ > + u8 started; bool? > +}; > + > +struct bcap_fh { > + struct v4l2_fh fh; > + struct bcap_device *bcap_dev; > + /* indicates whether this file handle is doing IO */ > + u8 io_allowed; bool [snip] > +static irqreturn_t bcap_isr(int irq, void *dev_id) > +{ > + struct ppi_if *ppi = dev_id; > + struct bcap_device *bcap_dev = ppi->priv; > + struct timeval timevalue; > + struct vb2_buffer *vb = &bcap_dev->cur_frm->vb; > + dma_addr_t *addr; > + > + spin_lock(&bcap_dev->lock); > + > + if (bcap_dev->cur_frm != bcap_dev->next_frm) { > + do_gettimeofday(&timevalue); > + vb->v4l2_buf.timestamp = timevalue; > + vb2_buffer_done(vb, VB2_BUF_STATE_DONE); > + bcap_dev->cur_frm = bcap_dev->next_frm; > + } > + > + ppi->ops->stop(ppi); > + > + if (!bcap_dev->started) > + complete(&bcap_dev->comp); > + else { > + if (!list_empty(&bcap_dev->dma_queue)) { > + bcap_dev->next_frm = list_entry(bcap_dev->dma_queue.next, > + struct bcap_buffer, list); > + list_del(&bcap_dev->next_frm->list); > + addr = vb2_plane_cookie(&bcap_dev->next_frm->vb, 0); I think, the direct use of vb2_plane_cookie() is discouraged. vb2_dma_contig_plane_dma_addr() should work for you. > + ppi->ops->update_addr(ppi, (unsigned long)(*addr)); > + } > + ppi->ops->start(ppi); > + } > + > + spin_unlock(&bcap_dev->lock); > + > + return IRQ_HANDLED; > +} [snip] > +static int bcap_try_format(struct bcap_device *bcap, > + struct v4l2_pix_format *pixfmt, > + enum v4l2_mbus_pixelcode *mbus_code, > + int *bpp) > +{ > + const struct bcap_format *fmt; > + struct v4l2_mbus_framefmt mbus_fmt; > + int ret, i; > + > + for (i = 0; i < BCAP_MAX_FMTS; i++) { > + if ((pixfmt->pixelformat == bcap_formats[i].pixelformat)) { > + fmt = &bcap_formats[i]; > + if (mbus_code) > + *mbus_code = fmt->mbus_code; > + if (bpp) > + *bpp = fmt->bpp; > + v4l2_fill_mbus_format(&mbus_fmt, pixfmt, > + fmt->mbus_code); > + ret = v4l2_subdev_call(bcap->sd, video, > + try_mbus_fmt, &mbus_fmt); > + if (ret < 0) > + return ret; > + v4l2_fill_pix_format(pixfmt, &mbus_fmt); > + pixfmt->bytesperline = pixfmt->width * fmt->bpp; > + pixfmt->sizeimage = pixfmt->bytesperline > + * pixfmt->height; > + return 0; > + } > + } > + return -EINVAL; > +} > + > +static int bcap_enum_fmt_vid_cap(struct file *file, void *priv, > + struct v4l2_fmtdesc *fmt) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + enum v4l2_mbus_pixelcode mbus_code; > + u32 index = fmt->index; > + int ret, i; > + > + ret = v4l2_subdev_call(bcap_dev->sd, video, > + enum_mbus_fmt, index, &mbus_code); > + if (ret < 0) > + return ret; > + > + for (i = 0; i < BCAP_MAX_FMTS; i++) { > + if (mbus_code == bcap_formats[i].mbus_code) { > + fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; > + strlcpy(fmt->description, > + bcap_formats[index].desc, > + sizeof(fmt->description)); > + fmt->pixelformat = bcap_formats[index].pixelformat; > + return 0; > + } > + } > + v4l2_err(&bcap_dev->v4l2_dev, > + "subdev fmt is not supported by bcap\n"); > + return -EINVAL; > +} > + > +static int bcap_try_fmt_vid_cap(struct file *file, void *priv, > + struct v4l2_format *fmt) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct v4l2_pix_format *pixfmt = &fmt->fmt.pix; > + > + if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) > + return -EINVAL; > + > + return bcap_try_format(bcap_dev, pixfmt, NULL, NULL); > +} > + > +static int bcap_g_fmt_vid_cap(struct file *file, void *priv, > + struct v4l2_format *fmt) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct v4l2_mbus_framefmt mbus_fmt; > + const struct bcap_format *bcap_fmt; > + struct v4l2_pix_format *pixfmt = &fmt->fmt.pix; > + int ret, i; > + > + if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) > + return -EINVAL; > + > + ret = v4l2_subdev_call(bcap_dev->sd, video, > + g_mbus_fmt, &mbus_fmt); > + if (ret < 0) > + return ret; > + > + for (i = 0; i < BCAP_MAX_FMTS; i++) { > + if (mbus_fmt.code == bcap_formats[i].mbus_code) { > + bcap_fmt = &bcap_formats[i]; > + v4l2_fill_pix_format(pixfmt, &mbus_fmt); > + pixfmt->bytesperline = pixfmt->width * bcap_fmt->bpp; > + pixfmt->sizeimage = pixfmt->bytesperline > + * pixfmt->height; It seems to me, you're forgetting to fill in ->pixelformat? Thanks Guennadi --- Guennadi Liakhovetski, Ph.D. Freelance Open-Source Software Developer http://www.open-technology.de/ ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-13 8:11 ` Guennadi Liakhovetski @ 2011-09-13 9:56 ` Scott Jiang 2011-09-13 11:15 ` Guennadi Liakhovetski 2011-09-15 6:37 ` Scott Jiang 1 sibling, 1 reply; 39+ messages in thread From: Scott Jiang @ 2011-09-13 9:56 UTC (permalink / raw) To: Guennadi Liakhovetski Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel >> + >> +struct bcap_format { >> + u8 *desc; >> + u32 pixelformat; >> + enum v4l2_mbus_pixelcode mbus_code; >> + int bpp; /* bytes per pixel */ > > Don't you think you might have to process 12 bpp formats at some point, > like YUV 4:2:0, or NV12? Maybe better calculate in bits from the beginning? > sounds good, changed in v2 > > Does it really have to be fixed 32 bits? Seems a plane simple int would do > just fine. > users can't be negative, so I used u32 >> +struct bcap_fh { >> + struct v4l2_fh fh; >> + struct bcap_device *bcap_dev; >> + /* indicates whether this file handle is doing IO */ >> + u8 io_allowed; > > bool > does kernel prefer bool now? >> + if (!bcap_dev->started) >> + complete(&bcap_dev->comp); >> + else { >> + if (!list_empty(&bcap_dev->dma_queue)) { >> + bcap_dev->next_frm = list_entry(bcap_dev->dma_queue.next, >> + struct bcap_buffer, list); >> + list_del(&bcap_dev->next_frm->list); >> + addr = vb2_plane_cookie(&bcap_dev->next_frm->vb, 0); > > I think, the direct use of vb2_plane_cookie() is discouraged. > vb2_dma_contig_plane_dma_addr() should work for you. > I guess you mean vb2_dma_contig_plane_paddr >> + >> + for (i = 0; i < BCAP_MAX_FMTS; i++) { >> + if (mbus_fmt.code == bcap_formats[i].mbus_code) { >> + bcap_fmt = &bcap_formats[i]; >> + v4l2_fill_pix_format(pixfmt, &mbus_fmt); >> + pixfmt->bytesperline = pixfmt->width * bcap_fmt->bpp; >> + pixfmt->sizeimage = pixfmt->bytesperline >> + * pixfmt->height; > > It seems to me, you're forgetting to fill in ->pixelformat? > yes, add in v2 ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-13 9:56 ` Scott Jiang @ 2011-09-13 11:15 ` Guennadi Liakhovetski 2011-09-14 6:14 ` Scott Jiang 2011-09-16 8:11 ` Scott Jiang 0 siblings, 2 replies; 39+ messages in thread From: Guennadi Liakhovetski @ 2011-09-13 11:15 UTC (permalink / raw) To: Scott Jiang Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel On Tue, 13 Sep 2011, Scott Jiang wrote: > >> + > >> +struct bcap_format { > >> + u8 *desc; > >> + u32 pixelformat; > >> + enum v4l2_mbus_pixelcode mbus_code; > >> + int bpp; /* bytes per pixel */ > > > > Don't you think you might have to process 12 bpp formats at some point, > > like YUV 4:2:0, or NV12? Maybe better calculate in bits from the beginning? > > > sounds good, changed in v2 > > > > > Does it really have to be fixed 32 bits? Seems a plane simple int would do > > just fine. > > > users can't be negative, so I used u32 no, then use unsigned int. > >> +struct bcap_fh { > >> + struct v4l2_fh fh; > >> + struct bcap_device *bcap_dev; > >> + /* indicates whether this file handle is doing IO */ > >> + u8 io_allowed; > > > > bool > > > does kernel prefer bool now? yes > >> + if (!bcap_dev->started) > >> + complete(&bcap_dev->comp); > >> + else { > >> + if (!list_empty(&bcap_dev->dma_queue)) { > >> + bcap_dev->next_frm = list_entry(bcap_dev->dma_queue.next, > >> + struct bcap_buffer, list); > >> + list_del(&bcap_dev->next_frm->list); > >> + addr = vb2_plane_cookie(&bcap_dev->next_frm->vb, 0); > > > > I think, the direct use of vb2_plane_cookie() is discouraged. > > vb2_dma_contig_plane_dma_addr() should work for you. > > > I guess you mean vb2_dma_contig_plane_paddr no, in the current kernel it's vb2_dma_contig_plane_dma_addr(). See http://git.linuxtv.org/media_tree.git/shortlog/refs/heads/staging/for_v3.2 > > >> + > >> + for (i = 0; i < BCAP_MAX_FMTS; i++) { > >> + if (mbus_fmt.code == bcap_formats[i].mbus_code) { > >> + bcap_fmt = &bcap_formats[i]; > >> + v4l2_fill_pix_format(pixfmt, &mbus_fmt); > >> + pixfmt->bytesperline = pixfmt->width * bcap_fmt->bpp; > >> + pixfmt->sizeimage = pixfmt->bytesperline > >> + * pixfmt->height; > > > > It seems to me, you're forgetting to fill in ->pixelformat? > > > yes, add in v2 > Thanks Guennadi --- Guennadi Liakhovetski, Ph.D. Freelance Open-Source Software Developer http://www.open-technology.de/ ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-13 11:15 ` Guennadi Liakhovetski @ 2011-09-14 6:14 ` Scott Jiang 2011-09-16 8:11 ` Scott Jiang 1 sibling, 0 replies; 39+ messages in thread From: Scott Jiang @ 2011-09-14 6:14 UTC (permalink / raw) To: Guennadi Liakhovetski Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel >> > I think, the direct use of vb2_plane_cookie() is discouraged. >> > vb2_dma_contig_plane_dma_addr() should work for you. >> > >> I guess you mean vb2_dma_contig_plane_paddr > > no, in the current kernel it's vb2_dma_contig_plane_dma_addr(). See > > http://git.linuxtv.org/media_tree.git/shortlog/refs/heads/staging/for_v3.2 > my git repo is http://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-2.6.git branch is v4l_for_linus Is this the official git repo or in linuxtv.org? My patch is against 3.1 not 3.2. ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-13 11:15 ` Guennadi Liakhovetski 2011-09-14 6:14 ` Scott Jiang @ 2011-09-16 8:11 ` Scott Jiang 2011-09-16 8:46 ` Guennadi Liakhovetski 1 sibling, 1 reply; 39+ messages in thread From: Scott Jiang @ 2011-09-16 8:11 UTC (permalink / raw) To: Guennadi Liakhovetski Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel 2011/9/13 Guennadi Liakhovetski <g.liakhovetski@gmx.de>: > On Tue, 13 Sep 2011, Scott Jiang wrote: > >> >> + >> >> +struct bcap_format { >> >> + u8 *desc; >> >> + u32 pixelformat; >> >> + enum v4l2_mbus_pixelcode mbus_code; >> >> + int bpp; /* bytes per pixel */ >> > >> > Don't you think you might have to process 12 bpp formats at some point, >> > like YUV 4:2:0, or NV12? Maybe better calculate in bits from the beginning? >> > ppi only stores raw format into memory. I wonder if there is sensor transmit data in planar format? If planar format only exists in memory, I think I don't need to modify this. ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-16 8:11 ` Scott Jiang @ 2011-09-16 8:46 ` Guennadi Liakhovetski 0 siblings, 0 replies; 39+ messages in thread From: Guennadi Liakhovetski @ 2011-09-16 8:46 UTC (permalink / raw) To: Scott Jiang Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel On Fri, 16 Sep 2011, Scott Jiang wrote: > 2011/9/13 Guennadi Liakhovetski <g.liakhovetski@gmx.de>: > > On Tue, 13 Sep 2011, Scott Jiang wrote: > > > >> >> + > >> >> +struct bcap_format { > >> >> + u8 *desc; > >> >> + u32 pixelformat; > >> >> + enum v4l2_mbus_pixelcode mbus_code; > >> >> + int bpp; /* bytes per pixel */ > >> > > >> > Don't you think you might have to process 12 bpp formats at some point, > >> > like YUV 4:2:0, or NV12? Maybe better calculate in bits from the beginning? > >> > > ppi only stores raw format into memory. I wonder if there is sensor > transmit data in planar format? > If planar format only exists in memory, I think I don't need to modify this. There are also packed 12-bit formats, like yuv 4:1:1 (V4L2_PIX_FMT_Y41P). Thanks Guennadi --- Guennadi Liakhovetski, Ph.D. Freelance Open-Source Software Developer http://www.open-technology.de/ ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-13 8:11 ` Guennadi Liakhovetski 2011-09-13 9:56 ` Scott Jiang @ 2011-09-15 6:37 ` Scott Jiang 2011-09-15 8:49 ` Sylwester Nawrocki 1 sibling, 1 reply; 39+ messages in thread From: Scott Jiang @ 2011-09-15 6:37 UTC (permalink / raw) To: Guennadi Liakhovetski Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel > >> + >> +#define CAPTURE_DRV_NAME "bfin_capture" >> +#define BCAP_MIN_NUM_BUF 2 >> + >> +struct bcap_format { >> + u8 *desc; >> + u32 pixelformat; >> + enum v4l2_mbus_pixelcode mbus_code; >> + int bpp; /* bytes per pixel */ > > Don't you think you might have to process 12 bpp formats at some point, > like YUV 4:2:0, or NV12? Maybe better calculate in bits from the beginning? > I have a question here. How to calculate bytesperline for planar format? According to v4l2 specification width, height and bytesperline apply to largest plane. Does it mean bytesperline equal to Y plane distance between two line? And so you can't use bytesperline x height to calculate sizeimage? ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-15 6:37 ` Scott Jiang @ 2011-09-15 8:49 ` Sylwester Nawrocki 0 siblings, 0 replies; 39+ messages in thread From: Sylwester Nawrocki @ 2011-09-15 8:49 UTC (permalink / raw) To: Scott Jiang Cc: Guennadi Liakhovetski, Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel On 09/15/2011 08:37 AM, Scott Jiang wrote: >> >>> + >>> +#define CAPTURE_DRV_NAME "bfin_capture" >>> +#define BCAP_MIN_NUM_BUF 2 >>> + >>> +struct bcap_format { >>> + u8 *desc; >>> + u32 pixelformat; >>> + enum v4l2_mbus_pixelcode mbus_code; >>> + int bpp; /* bytes per pixel */ >> >> Don't you think you might have to process 12 bpp formats at some point, >> like YUV 4:2:0, or NV12? Maybe better calculate in bits from the beginning? >> > I have a question here. How to calculate bytesperline for planar format? > According to v4l2 specification width, height and bytesperline apply > to largest plane. > Does it mean bytesperline equal to Y plane distance between two line? For planar formats - I think so. > And so you can't use bytesperline x height to calculate sizeimage? No, you can't. Please see this thread: http://www.mail-archive.com/linux-media@vger.kernel.org/msg28957.html Regards, -- Sylwester Nawrocki Samsung Poland R&D Center ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-13 18:34 ` [PATCH 4/4] v4l2: add blackfin capture bridge driver Scott Jiang 2011-09-13 8:11 ` Guennadi Liakhovetski @ 2011-09-13 21:19 ` Sylwester Nawrocki 2011-09-14 7:10 ` Scott Jiang 2011-09-14 3:19 ` [uclinux-dist-devel] " Mike Frysinger 2011-09-17 20:54 ` Guennadi Liakhovetski 3 siblings, 1 reply; 39+ messages in thread From: Sylwester Nawrocki @ 2011-09-13 21:19 UTC (permalink / raw) To: Scott Jiang Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski, linux-media, uclinux-dist-devel Hi Scott, On 09/13/2011 08:34 PM, Scott Jiang wrote: > this is a v4l2 bridge driver for Blackfin video capture device, > support ppi interface > > Signed-off-by: Scott Jiang<scott.jiang.linux@gmail.com> > --- > drivers/media/video/Makefile | 2 + > drivers/media/video/blackfin/Kconfig | 10 + > drivers/media/video/blackfin/Makefile | 2 + > drivers/media/video/blackfin/bfin_capture.c | 1099 +++++++++++++++++++++++++++ > drivers/media/video/blackfin/ppi.c | 204 +++++ > 5 files changed, 1317 insertions(+), 0 deletions(-) > create mode 100644 drivers/media/video/blackfin/Kconfig > create mode 100644 drivers/media/video/blackfin/Makefile > create mode 100644 drivers/media/video/blackfin/bfin_capture.c > create mode 100644 drivers/media/video/blackfin/ppi.c > ... > diff --git a/drivers/media/video/blackfin/bfin_capture.c b/drivers/media/video/blackfin/bfin_capture.c > new file mode 100644 > index 0000000..24f89f2 > --- /dev/null > +++ b/drivers/media/video/blackfin/bfin_capture.c > @@ -0,0 +1,1099 @@ > +/* > + * Analog Devices video capture driver > + * > + * Copyright (c) 2011 Analog Devices Inc. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License version 2 as > + * published by the Free Software Foundation. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * You should have received a copy of the GNU General Public License > + * along with this program; if not, write to the Free Software > + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. > + */ > + > + > +#include<linux/kernel.h> > +#include<linux/init.h> > +#include<linux/module.h> > +#include<linux/io.h> > +#include<linux/delay.h> > +#include<linux/errno.h> > +#include<linux/fs.h> > +#include<linux/interrupt.h> > +#include<linux/completion.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> > +#include<linux/sched.h> > +#include<linux/slab.h> > + > +#include<media/v4l2-common.h> > +#include<media/v4l2-ioctl.h> > +#include<media/v4l2-device.h> > +#include<media/videobuf2-dma-contig.h> > +#include<media/v4l2-chip-ident.h> > + > +#include<asm/dma.h> > + > +#include<media/blackfin/bfin_capture.h> > + > +#define CAPTURE_DRV_NAME "bfin_capture" > +#define BCAP_MIN_NUM_BUF 2 > + > +struct bcap_format { > + u8 *desc; > + u32 pixelformat; > + enum v4l2_mbus_pixelcode mbus_code; > + int bpp; /* bytes per pixel */ > +}; > + > +struct bcap_buffer { > + struct vb2_buffer vb; > + struct list_head list; > +}; > + > +struct bcap_device { > + /* capture device instance */ > + struct v4l2_device v4l2_dev; > + /* device node data */ > + struct video_device *video_dev; > + /* sub device instance */ > + struct v4l2_subdev *sd; > + /* caputre config */ typo: caputre -> capture > + struct bfin_capture_config *cfg; > + /* ppi interface */ > + struct ppi_if *ppi; > + /* current input */ > + unsigned int cur_input; > + /* current selected standard */ > + v4l2_std_id std; > + /* used to store pixel format */ > + struct v4l2_pix_format fmt; > + /* bytes per pixel*/ > + int bpp; > + /* pointing to current video buffer */ > + struct bcap_buffer *cur_frm; > + /* pointing to next video buffer */ > + struct bcap_buffer *next_frm; > + /* buffer queue used in videobuf2 */ > + struct vb2_queue buffer_queue; > + /* allocator-specific contexts for each plane */ > + struct vb2_alloc_ctx *alloc_ctx; > + /* queue of filled frames */ > + struct list_head dma_queue; > + /* used in videobuf2 callback */ > + spinlock_t lock; > + /* used to access capture device */ > + struct mutex mutex; > + /* used to wait ppi to complete one transfer */ > + struct completion comp; > + /* number of users performing IO */ > + u32 io_usrs; > + /* number of open instances of the device */ > + u32 usrs; > + /* indicate whether streaming has started */ > + u8 started; > +}; > + > +struct bcap_fh { > + struct v4l2_fh fh; > + struct bcap_device *bcap_dev; > + /* indicates whether this file handle is doing IO */ > + u8 io_allowed; > +}; > + > +static const struct bcap_format bcap_formats[] = { > + { > + .desc = "YCbCr 4:2:2 Interleaved UYVY", > + .pixelformat = V4L2_PIX_FMT_UYVY, > + .mbus_code = V4L2_MBUS_FMT_UYVY8_2X8, > + .bpp = 2, > + }, > + { > + .desc = "YCbCr 4:2:2 Interleaved YUYV", > + .pixelformat = V4L2_PIX_FMT_YUYV, > + .mbus_code = V4L2_MBUS_FMT_YUYV8_2X8, > + .bpp = 2, > + }, > + { > + .desc = "RGB 565", > + .pixelformat = V4L2_PIX_FMT_RGB565, > + .mbus_code = V4L2_MBUS_FMT_RGB565_2X8_LE, > + .bpp = 2, > + }, > + { > + .desc = "RGB 444", > + .pixelformat = V4L2_PIX_FMT_RGB444, > + .mbus_code = V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE, > + .bpp = 2, Are these all formats supported by the device ? IIRC it has been already pointed out, wouldn't "bits per pixel" be more useful ? If there are other formats added in future with e.g. 12 bits/pixel it won't be easy to compute the buffers size. > + }, > + > +}; > +#define BCAP_MAX_FMTS ARRAY_SIZE(bcap_formats) > + > +static irqreturn_t bcap_isr(int irq, void *dev_id); > + > +static struct bcap_buffer *to_bcap_vb(struct vb2_buffer *vb) > +{ > + return container_of(vb, struct bcap_buffer, vb); > +} > + > +static int bcap_open(struct file *file) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct video_device *vfd = bcap_dev->video_dev; > + struct bcap_fh *bcap_fh; > + int ret; > + > + if (!bcap_dev->sd) { > + v4l2_err(&bcap_dev->v4l2_dev, "No sub device registered\n"); > + return -ENODEV; > + } > + > + bcap_fh = kzalloc(sizeof(*bcap_fh), GFP_KERNEL); > + if (!bcap_fh) { > + v4l2_err(&bcap_dev->v4l2_dev, > + "unable to allocate memory for file handle object\n"); > + return -ENOMEM; > + } > + > + ret = v4l2_fh_init(&bcap_fh->fh, vfd); > + if (ret) { > + kfree(bcap_fh); > + return ret; > + } > + > + /* store pointer to v4l2_fh in private_data member of file */ > + file->private_data =&bcap_fh->fh; > + v4l2_fh_add(&bcap_fh->fh); > + bcap_fh->bcap_dev = bcap_dev; > + bcap_dev->usrs++; > + bcap_fh->io_allowed = 0; > + return 0; > +} > + > +static int bcap_release(struct file *file) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct v4l2_fh *fh = file->private_data; > + struct bcap_fh *bcap_fh = container_of(fh, struct bcap_fh, fh); > + > + /* if this instance is doing IO */ > + if (bcap_fh->io_allowed) { > + vb2_queue_release(&bcap_dev->buffer_queue); > + bcap_dev->io_usrs = 0; > + } > + > + bcap_dev->usrs--; > + file->private_data = NULL; > + v4l2_fh_del(&bcap_fh->fh); > + v4l2_fh_exit(&bcap_fh->fh); > + kfree(bcap_fh); > + return 0; > +} > + > +static int bcap_mmap(struct file *file, struct vm_area_struct *vma) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + return vb2_mmap(&bcap_dev->buffer_queue, vma); > +} > + > +#ifndef CONFIG_MMU > +static unsigned long bcap_get_unmapped_area(struct file *file, > + unsigned long addr, > + unsigned long len, > + unsigned long pgoff, > + unsigned long flags) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + return vb2_get_unmapped_area(&bcap_dev->buffer_queue, > + addr, > + len, > + pgoff, > + flags); > +} > +#endif > + > +static unsigned int bcap_poll(struct file *file, poll_table *wait) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + if (bcap_dev->started) > + return vb2_poll(&bcap_dev->buffer_queue, file, wait); > + return 0; > +} > + > +static int bcap_queue_setup(struct vb2_queue *vq, unsigned int *nbuffers, > + unsigned int *nplanes, unsigned long sizes[], > + void *alloc_ctxs[]) > +{ > + struct bcap_device *bcap_dev = vb2_get_drv_priv(vq); > + > + if (*nbuffers< BCAP_MIN_NUM_BUF) > + *nbuffers = BCAP_MIN_NUM_BUF; > + > + *nplanes = 1; > + sizes[0] = bcap_dev->fmt.sizeimage; > + alloc_ctxs[0] = bcap_dev->alloc_ctx; > + > + return 0; > +} > + > +static int bcap_buffer_init(struct vb2_buffer *vb) > +{ > + struct bcap_buffer *buf = to_bcap_vb(vb); > + > + INIT_LIST_HEAD(&buf->list); > + return 0; > +} > + > +static int bcap_buffer_prepare(struct vb2_buffer *vb) > +{ > + struct bcap_device *bcap_dev = vb2_get_drv_priv(vb->vb2_queue); > + struct bcap_buffer *buf = to_bcap_vb(vb); > + unsigned long size; > + > + size = bcap_dev->fmt.sizeimage; > + if (vb2_plane_size(vb, 0)< size) { > + v4l2_err(&bcap_dev->v4l2_dev, "buffer too small (%lu< %lu)\n", > + vb2_plane_size(vb, 0), size); > + return -EINVAL; > + } > + vb2_set_plane_payload(&buf->vb, 0, size); > + > + return 0; > +} > + > +static void bcap_buffer_queue(struct vb2_buffer *vb) > +{ > + struct bcap_device *bcap_dev = vb2_get_drv_priv(vb->vb2_queue); > + struct bcap_buffer *buf = to_bcap_vb(vb); > + unsigned long flags = 0; > + > + spin_lock_irqsave(&bcap_dev->lock, flags); > + list_add_tail(&buf->list,&bcap_dev->dma_queue); > + spin_unlock_irqrestore(&bcap_dev->lock, flags); > +} > + > +static void bcap_buffer_cleanup(struct vb2_buffer *vb) > +{ > + struct bcap_device *bcap_dev = vb2_get_drv_priv(vb->vb2_queue); > + struct bcap_buffer *buf = to_bcap_vb(vb); > + unsigned long flags = 0; > + > + spin_lock_irqsave(&bcap_dev->lock, flags); > + list_del_init(&buf->list); > + spin_unlock_irqrestore(&bcap_dev->lock, flags); > +} > + > +static void bcap_lock(struct vb2_queue *vq) > +{ > + struct bcap_device *bcap_dev = vb2_get_drv_priv(vq); > + mutex_lock(&bcap_dev->mutex); > +} > + > +static void bcap_unlock(struct vb2_queue *vq) > +{ > + struct bcap_device *bcap_dev = vb2_get_drv_priv(vq); > + mutex_unlock(&bcap_dev->mutex); > +} > + > +static int bcap_start_streaming(struct vb2_queue *vq) > +{ > + struct bcap_device *bcap_dev = vb2_get_drv_priv(vq); > + struct ppi_if *ppi = bcap_dev->ppi; > + struct ppi_params params; > + int ret; > + > + /* enable streamon on the sub device */ > + ret = v4l2_subdev_call(bcap_dev->sd, video, s_stream, 1); > + if (ret&& (ret != -ENOIOCTLCMD)) { > + v4l2_err(&bcap_dev->v4l2_dev, "stream on failed in subdev\n"); > + return ret; > + } > + > + /* attach ppi DMA irq handler */ > + ret = ppi->ops->attach_irq(ppi, bcap_isr); > + if (ret< 0) { > + v4l2_err(&bcap_dev->v4l2_dev, > + "Error in attaching interrupt handler\n"); > + return -EFAULT; > + } > + > + /* set ppi params */ > + params.width = bcap_dev->fmt.width; > + params.height = bcap_dev->fmt.height; > + params.bpp = bcap_dev->bpp; > + params.ppi_control = bcap_dev->cfg->ppi_control; > + ret = ppi->ops->set_params(ppi,¶ms); > + if (ret< 0) { > + v4l2_err(&bcap_dev->v4l2_dev, > + "Error in setting ppi params\n"); > + ppi->ops->detach_irq(ppi); > + return -EINVAL; > + } > + > + INIT_COMPLETION(bcap_dev->comp); > + return 0; > +} > + > +static int bcap_stop_streaming(struct vb2_queue *vq) > +{ > + struct bcap_device *bcap_dev = vb2_get_drv_priv(vq); > + struct ppi_if *ppi = bcap_dev->ppi; > + int ret; > + > + if (bcap_dev->started) { How about just doing: if (!bcap_dev->started) return 0; and avoid indentation ? > + bcap_dev->started = 0; > + wait_for_completion(&bcap_dev->comp); > + ppi->ops->stop(ppi); > + ppi->ops->detach_irq(ppi); > + ret = v4l2_subdev_call(bcap_dev->sd, video, s_stream, 0); > + if (ret&& (ret != -ENOIOCTLCMD)) > + v4l2_err(&bcap_dev->v4l2_dev, > + "stream off failed in subdev\n"); > + > + /* release all active buffers */ > + while (!list_empty(&bcap_dev->dma_queue)) { > + bcap_dev->next_frm = list_entry(bcap_dev->dma_queue.next, > + struct bcap_buffer, list); > + list_del(&bcap_dev->next_frm->list); > + vb2_buffer_done(&bcap_dev->next_frm->vb, VB2_BUF_STATE_ERROR); > + } > + } > + return 0; > +} > + > +static struct vb2_ops bcap_video_qops = { > + .queue_setup = bcap_queue_setup, > + .buf_init = bcap_buffer_init, > + .buf_prepare = bcap_buffer_prepare, > + .buf_cleanup = bcap_buffer_cleanup, > + .buf_queue = bcap_buffer_queue, > + .wait_prepare = bcap_unlock, > + .wait_finish = bcap_lock, > + .start_streaming = bcap_start_streaming, > + .stop_streaming = bcap_stop_streaming, > +}; > + > +static int bcap_reqbufs(struct file *file, void *priv, > + struct v4l2_requestbuffers *req_buf) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct v4l2_fh *fh = file->private_data; > + struct bcap_fh *bcap_fh = container_of(fh, struct bcap_fh, fh); > + > + if (bcap_dev->io_usrs != 0) { > + v4l2_err(&bcap_dev->v4l2_dev, "Only one IO user allowed\n"); > + return -EBUSY; > + } > + > + bcap_fh->io_allowed = 1; > + bcap_dev->io_usrs = 1; > + > + return vb2_reqbufs(&bcap_dev->buffer_queue, req_buf); > +} > + > +static int bcap_querybuf(struct file *file, void *priv, > + struct v4l2_buffer *buf) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + return vb2_querybuf(&bcap_dev->buffer_queue, buf); > +} > + > +static int bcap_qbuf(struct file *file, void *priv, > + struct v4l2_buffer *buf) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct v4l2_fh *fh = file->private_data; > + struct bcap_fh *bcap_fh = container_of(fh, struct bcap_fh, fh); > + > + if (!bcap_fh->io_allowed) > + return -EACCES; I suppose -EBUSY would be more appropriate here. > + > + return vb2_qbuf(&bcap_dev->buffer_queue, buf); > +} > + > +static int bcap_dqbuf(struct file *file, void *priv, > + struct v4l2_buffer *buf) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct v4l2_fh *fh = file->private_data; > + struct bcap_fh *bcap_fh = container_of(fh, struct bcap_fh, fh); > + > + if (!bcap_fh->io_allowed) > + return -EACCES; Ditto. > + > + return vb2_dqbuf(&bcap_dev->buffer_queue, > + buf, file->f_flags& O_NONBLOCK); > +} > + > +static irqreturn_t bcap_isr(int irq, void *dev_id) > +{ > + struct ppi_if *ppi = dev_id; > + struct bcap_device *bcap_dev = ppi->priv; > + struct timeval timevalue; > + struct vb2_buffer *vb =&bcap_dev->cur_frm->vb; > + dma_addr_t *addr; > + > + spin_lock(&bcap_dev->lock); > + > + if (bcap_dev->cur_frm != bcap_dev->next_frm) { > + do_gettimeofday(&timevalue); > + vb->v4l2_buf.timestamp = timevalue; > + vb2_buffer_done(vb, VB2_BUF_STATE_DONE); > + bcap_dev->cur_frm = bcap_dev->next_frm; > + } > + > + ppi->ops->stop(ppi); > + > + if (!bcap_dev->started) > + complete(&bcap_dev->comp); Need braces around if/else as well. > + else { > + if (!list_empty(&bcap_dev->dma_queue)) { > + bcap_dev->next_frm = list_entry(bcap_dev->dma_queue.next, > + struct bcap_buffer, list); > + list_del(&bcap_dev->next_frm->list); > + addr = vb2_plane_cookie(&bcap_dev->next_frm->vb, 0); > + ppi->ops->update_addr(ppi, (unsigned long)(*addr)); > + } > + ppi->ops->start(ppi); > + } > + > + spin_unlock(&bcap_dev->lock); > + > + return IRQ_HANDLED; > +} > + > +static int bcap_streamon(struct file *file, void *priv, > + enum v4l2_buf_type buf_type) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct bcap_fh *fh = file->private_data; > + struct ppi_if *ppi = bcap_dev->ppi; > + dma_addr_t *addr; > + int ret; > + > + if (!fh->io_allowed) > + return -EACCES; > + > + if (bcap_dev->started) > + return -EBUSY; > + > + /* call streamon to start streaming in videobuf */ > + ret = vb2_streamon(&bcap_dev->buffer_queue, buf_type); > + if (ret) > + return ret; > + > + /* if dma queue is empty, return error */ > + if (list_empty(&bcap_dev->dma_queue)) { > + v4l2_err(&bcap_dev->v4l2_dev, "dma queue is empty\n"); > + ret = -EIO; According to the specification this should be -EINVAL. But I might be wrong, please check: http://linuxtv.org/downloads/v4l-dvb-apis/vidioc-streamon.html Have you rebased this driver onto latest staging/for_v3.2 branch ? There have been yet another;) change in videobuf2. >From now on there is a number of queued buffers passed by vb2 in start_streaming. It seems more relevant to move this logic to the start_streaming callback. And if you ever need read/write methods this will work out of the box this way. Also calling vb2_streamoff from vidioc_streamon might be not necessarily the right way to go. > + goto err; > + } > + > + /* get the next frame from the dma queue */ > + bcap_dev->next_frm = list_entry(bcap_dev->dma_queue.next, > + struct bcap_buffer, list); > + bcap_dev->cur_frm = bcap_dev->next_frm; > + /* remove buffer from the dma queue */ > + list_del(&bcap_dev->cur_frm->list); > + addr = vb2_plane_cookie(&bcap_dev->cur_frm->vb, 0); As pointed out already, if you need to retrieve DMA adders the proper API is vb2_dma_contig_plane_dma_addr(). > + /* update DMA address */ > + ppi->ops->update_addr(ppi, (unsigned long)(*addr)); > + /* enable ppi */ > + ppi->ops->start(ppi); > + bcap_dev->started = 1; > + > + return 0; > +err: > + vb2_streamoff(&bcap_dev->buffer_queue, buf_type); > + return ret; > +} > + > +static int bcap_streamoff(struct file *file, void *priv, > + enum v4l2_buf_type buf_type) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct bcap_fh *fh = file->private_data; > + > + if (!fh->io_allowed) > + return -EACCES; > + > + if (!bcap_dev->started) > + return -EINVAL; > + > + return vb2_streamoff(&bcap_dev->buffer_queue, buf_type); > +} > + > +static int bcap_queryctrl(struct file *file, void *priv, > + struct v4l2_queryctrl *qctrl) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + return v4l2_subdev_call(bcap_dev->sd, core, queryctrl, qctrl); > +} > + > +static int bcap_g_ctrl(struct file *file, void *priv, > + struct v4l2_control *ctrl) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + return v4l2_subdev_call(bcap_dev->sd, core, g_ctrl, ctrl); > +} > + > +static int bcap_s_ctrl(struct file *file, void *priv, > + struct v4l2_control *ctrl) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + return v4l2_subdev_call(bcap_dev->sd, core, s_ctrl, ctrl); > +} I think you don't need all these control operations in the host driver. If the sensor and host driver uses new control framework the sensor's controls get inherited by the host driver when the sensor is registered. And the subdev's s_ctrl function will be called when required. For more details please see: Documentation/video4linux/v4l2-controls.txt > + > +static int bcap_querystd(struct file *file, void *priv, v4l2_std_id *std) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + int ret; > + > + ret = v4l2_subdev_call(bcap_dev->sd, video, querystd, std); > + return ret; > +} > + > +static int bcap_g_std(struct file *file, void *priv, v4l2_std_id *std) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + if (bcap_dev->std) { > + *std = bcap_dev->std; > + return 0; > + } else > + return -EINVAL; > +} > + > +static int bcap_s_std(struct file *file, void *priv, v4l2_std_id *std) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + int ret; > + > + /* if streaming is started, return error */ > + if (bcap_dev->started) { > + v4l2_err(&bcap_dev->v4l2_dev, "Streaming is started\n"); > + return -EBUSY; > + } > + > + ret = v4l2_subdev_call(bcap_dev->sd, core, s_std, *std); > + if (ret< 0) > + return ret; > + > + bcap_dev->std = *std; > + return 0; > +} > + > +static int bcap_enum_input(struct file *file, void *priv, > + struct v4l2_input *input) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct bfin_capture_config *config = bcap_dev->cfg; > + int ret; > + u32 status; > + > + if (input->index>= config->num_inputs) > + return -EINVAL; > + > + memcpy(input,&config->inputs[input->index], > + sizeof(*input)); Unecessary wrapping? How about just doing: input = &config->inputs[input->index]; ? > + /* get input status */ > + ret = v4l2_subdev_call(bcap_dev->sd, video, g_input_status,&status); > + if (!ret) > + input->status = status; > + return 0; > +} > + > +static int bcap_g_input(struct file *file, void *priv, unsigned int *index) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + *index = bcap_dev->cur_input; > + return 0; > +} > + > +static int bcap_s_input(struct file *file, void *priv, unsigned int index) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct bfin_capture_config *config = bcap_dev->cfg; > + struct bcap_route *route; > + int ret; > + > + /* if streaming is started, return error */ > + if (bcap_dev->started) { > + v4l2_err(&bcap_dev->v4l2_dev, "Streaming is started\n"); > + return -EBUSY; > + } > + > + if (index>= config->num_inputs) > + return -EINVAL; > + > + route =&config->routes[index]; > + ret = v4l2_subdev_call(bcap_dev->sd, video, s_routing, > + route->input, route->output, 0); > + if ((ret< 0)&& (ret != -ENOIOCTLCMD)) { > + v4l2_err(&bcap_dev->v4l2_dev, "Failed to set input\n"); > + return ret; > + } > + bcap_dev->cur_input = index; > + return 0; > +} > + > +static int bcap_try_format(struct bcap_device *bcap, > + struct v4l2_pix_format *pixfmt, > + enum v4l2_mbus_pixelcode *mbus_code, > + int *bpp) > +{ > + const struct bcap_format *fmt; > + struct v4l2_mbus_framefmt mbus_fmt; > + int ret, i; > + > + for (i = 0; i< BCAP_MAX_FMTS; i++) { > + if ((pixfmt->pixelformat == bcap_formats[i].pixelformat)) { if ((pixfmt->pixelformat != bcap_formats[i].pixelformat)) continue; to avoid indentation ? > + fmt =&bcap_formats[i]; > + if (mbus_code) > + *mbus_code = fmt->mbus_code; > + if (bpp) > + *bpp = fmt->bpp; > + v4l2_fill_mbus_format(&mbus_fmt, pixfmt, > + fmt->mbus_code); > + ret = v4l2_subdev_call(bcap->sd, video, > + try_mbus_fmt,&mbus_fmt); > + if (ret< 0) > + return ret; > + v4l2_fill_pix_format(pixfmt,&mbus_fmt); > + pixfmt->bytesperline = pixfmt->width * fmt->bpp; > + pixfmt->sizeimage = pixfmt->bytesperline > + * pixfmt->height; Still pixfmt->pixelformat isn't filled. > + return 0; > + } > + } > + return -EINVAL; I think you should return some default format, rather than giving up when the fourcc doesn't match. However I'm not 100% sure this is the specification requirement. > +} > + > +static int bcap_enum_fmt_vid_cap(struct file *file, void *priv, > + struct v4l2_fmtdesc *fmt) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + enum v4l2_mbus_pixelcode mbus_code; > + u32 index = fmt->index; > + int ret, i; > + > + ret = v4l2_subdev_call(bcap_dev->sd, video, > + enum_mbus_fmt, index,&mbus_code); > + if (ret< 0) > + return ret; > + > + for (i = 0; i< BCAP_MAX_FMTS; i++) { > + if (mbus_code == bcap_formats[i].mbus_code) { if (mbus_code != bcap_formats[i].mbus_code) continue; ? > + fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; > + strlcpy(fmt->description, > + bcap_formats[index].desc, > + sizeof(fmt->description)); > + fmt->pixelformat = bcap_formats[index].pixelformat; > + return 0; > + } > + } > + v4l2_err(&bcap_dev->v4l2_dev, > + "subdev fmt is not supported by bcap\n"); > + return -EINVAL; > +} > + > +static int bcap_try_fmt_vid_cap(struct file *file, void *priv, > + struct v4l2_format *fmt) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct v4l2_pix_format *pixfmt =&fmt->fmt.pix; > + > + if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) > + return -EINVAL; > + > + return bcap_try_format(bcap_dev, pixfmt, NULL, NULL); > +} > + > +static int bcap_g_fmt_vid_cap(struct file *file, void *priv, > + struct v4l2_format *fmt) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct v4l2_mbus_framefmt mbus_fmt; > + const struct bcap_format *bcap_fmt; > + struct v4l2_pix_format *pixfmt =&fmt->fmt.pix; > + int ret, i; > + > + if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) > + return -EINVAL; > + > + ret = v4l2_subdev_call(bcap_dev->sd, video, > + g_mbus_fmt,&mbus_fmt); > + if (ret< 0) > + return ret; > + > + for (i = 0; i< BCAP_MAX_FMTS; i++) { > + if (mbus_fmt.code == bcap_formats[i].mbus_code) { if (mbus_fmt.code != bcap_formats[i].mbus_code) continue; ? > + bcap_fmt =&bcap_formats[i]; > + v4l2_fill_pix_format(pixfmt,&mbus_fmt); > + pixfmt->bytesperline = pixfmt->width * bcap_fmt->bpp; > + pixfmt->sizeimage = pixfmt->bytesperline > + * pixfmt->height; > + return 0; > + } > + } > + v4l2_err(&bcap_dev->v4l2_dev, > + "subdev fmt is not supported by bcap\n"); > + return -EINVAL; > +} > + > +static int bcap_s_fmt_vid_cap(struct file *file, void *priv, > + struct v4l2_format *fmt) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + struct v4l2_mbus_framefmt mbus_fmt; > + enum v4l2_mbus_pixelcode mbus_code; > + struct v4l2_pix_format *pixfmt =&fmt->fmt.pix; > + int ret, bpp; > + > + /* if streaming is started, return error */ > + if (bcap_dev->started) { > + v4l2_err(&bcap_dev->v4l2_dev, "Streaming is started\n"); > + return -EBUSY; > + } > + > + if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) > + return -EINVAL; > + /* see if format works */ > + ret = bcap_try_format(bcap_dev, pixfmt,&mbus_code,&bpp); > + if (ret< 0) > + return ret; > + > + v4l2_fill_mbus_format(&mbus_fmt, pixfmt, mbus_code); > + ret = v4l2_subdev_call(bcap_dev->sd, video, s_mbus_fmt,&mbus_fmt); > + if (ret< 0) > + return ret; > + bcap_dev->fmt = *pixfmt; > + bcap_dev->bpp = bpp; > + return 0; > +} > + > +static int bcap_querycap(struct file *file, void *priv, > + struct v4l2_capability *cap) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING; > + strlcpy(cap->driver, CAPTURE_DRV_NAME, sizeof(cap->driver)); > + strlcpy(cap->bus_info, "Blackfin Platform", sizeof(cap->bus_info)); > + strlcpy(cap->card, bcap_dev->cfg->card_name, sizeof(cap->card)); > + return 0; > +} > + > +static int bcap_cropcap(struct file *file, void *priv, > + struct v4l2_cropcap *crop) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) > + return -EINVAL; > + > + return v4l2_subdev_call(bcap_dev->sd, video, cropcap, crop); > +} > + > +static int bcap_g_parm(struct file *file, void *fh, > + struct v4l2_streamparm *a) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) > + return -EINVAL; > + return v4l2_subdev_call(bcap_dev->sd, video, g_parm, a); > +} > + > +static int bcap_s_parm(struct file *file, void *fh, > + struct v4l2_streamparm *a) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) > + return -EINVAL; > + return v4l2_subdev_call(bcap_dev->sd, video, s_parm, a); > +} > + > +static int bcap_g_chip_ident(struct file *file, void *priv, > + struct v4l2_dbg_chip_ident *chip) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + chip->ident = V4L2_IDENT_NONE; > + chip->revision = 0; > + if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER&& > + chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR) > + return -EINVAL; > + > + return v4l2_subdev_call(bcap_dev->sd, core, > + g_chip_ident, chip); > +} > + > +#ifdef CONFIG_VIDEO_ADV_DEBUG > +static int bcap_dbg_g_register(struct file *file, void *priv, > + struct v4l2_dbg_register *reg) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + return v4l2_subdev_call(bcap_dev->sd, core, > + g_register, reg); > +} > + > +static int bcap_dbg_s_register(struct file *file, void *priv, > + struct v4l2_dbg_register *reg) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + > + return v4l2_subdev_call(bcap_dev->sd, core, > + s_register, reg); > +} > +#endif > + > +static int bcap_log_status(struct file *file, void *priv) > +{ > + struct bcap_device *bcap_dev = video_drvdata(file); > + /* status for sub devices */ > + v4l2_device_call_all(&bcap_dev->v4l2_dev, 0, core, log_status); > + return 0; > +} This is also not needed, if the subdev implements log_status(). > + > +static const struct v4l2_ioctl_ops bcap_ioctl_ops = { > + .vidioc_querycap = bcap_querycap, > + .vidioc_g_fmt_vid_cap = bcap_g_fmt_vid_cap, > + .vidioc_enum_fmt_vid_cap = bcap_enum_fmt_vid_cap, > + .vidioc_s_fmt_vid_cap = bcap_s_fmt_vid_cap, > + .vidioc_try_fmt_vid_cap = bcap_try_fmt_vid_cap, > + .vidioc_enum_input = bcap_enum_input, > + .vidioc_g_input = bcap_g_input, > + .vidioc_s_input = bcap_s_input, > + .vidioc_querystd = bcap_querystd, > + .vidioc_s_std = bcap_s_std, > + .vidioc_g_std = bcap_g_std, > + .vidioc_queryctrl = bcap_queryctrl, > + .vidioc_g_ctrl = bcap_g_ctrl, > + .vidioc_s_ctrl = bcap_s_ctrl, > + .vidioc_reqbufs = bcap_reqbufs, > + .vidioc_querybuf = bcap_querybuf, > + .vidioc_qbuf = bcap_qbuf, > + .vidioc_dqbuf = bcap_dqbuf, > + .vidioc_streamon = bcap_streamon, > + .vidioc_streamoff = bcap_streamoff, > + .vidioc_cropcap = bcap_cropcap, > + .vidioc_g_parm = bcap_g_parm, > + .vidioc_s_parm = bcap_s_parm, > + .vidioc_g_chip_ident = bcap_g_chip_ident, > +#ifdef CONFIG_VIDEO_ADV_DEBUG > + .vidioc_g_register = bcap_dbg_g_register, > + .vidioc_s_register = bcap_dbg_s_register, > +#endif > + .vidioc_log_status = bcap_log_status, > +}; > + > +static struct v4l2_file_operations bcap_fops = { > + .owner = THIS_MODULE, > + .open = bcap_open, > + .release = bcap_release, > + .unlocked_ioctl = video_ioctl2, > + .mmap = bcap_mmap, > +#ifndef CONFIG_MMU > + .get_unmapped_area = bcap_get_unmapped_area, > +#endif > + .poll = bcap_poll > +}; > + > +static int __devinit bcap_probe(struct platform_device *pdev) > +{ > + struct bcap_device *bcap_dev; > + struct video_device *vfd; > + struct i2c_adapter *i2c_adap; > + struct bfin_capture_config *config; > + struct vb2_queue *q; > + int ret; > + > + config = pdev->dev.platform_data; > + if (!config) { > + v4l2_err(pdev->dev.driver, "Unable to get board config\n"); > + return -ENODEV; > + } > + > + bcap_dev = kzalloc(sizeof(*bcap_dev), GFP_KERNEL); > + if (!bcap_dev) { > + v4l2_err(pdev->dev.driver, "Unable to alloc bcap_dev\n"); > + return -ENOMEM; > + } > + > + bcap_dev->cfg = config; > + > + bcap_dev->ppi = create_ppi_instance(config->ppi_info); > + if (!bcap_dev->ppi) { > + v4l2_err(pdev->dev.driver, "Unable to create ppi\n"); > + ret = -ENODEV; > + goto err_free_dev; > + } > + bcap_dev->ppi->priv = bcap_dev; > + > + bcap_dev->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev); > + if (IS_ERR(bcap_dev->alloc_ctx)) { > + ret = PTR_ERR(bcap_dev->alloc_ctx); > + goto err_free_ppi; > + } > + > + vfd = video_device_alloc(); > + if (!vfd) { > + ret = -ENOMEM; > + v4l2_err(pdev->dev.driver, "Unable to alloc video device\n"); > + goto err_cleanup_ctx; > + } > + > + /* initialize field of video device */ > + vfd->release = video_device_release; > + vfd->fops =&bcap_fops; > + vfd->ioctl_ops =&bcap_ioctl_ops; > + vfd->tvnorms = 0; > + vfd->v4l2_dev =&bcap_dev->v4l2_dev; > + set_bit(V4L2_FL_USE_FH_PRIO,&vfd->flags); > + strncpy(vfd->name, CAPTURE_DRV_NAME, sizeof(vfd->name)); > + bcap_dev->video_dev = vfd; > + > + ret = v4l2_device_register(&pdev->dev,&bcap_dev->v4l2_dev); > + if (ret) { > + v4l2_err(pdev->dev.driver, > + "Unable to register v4l2 device\n"); > + goto err_release_vdev; > + } > + v4l2_info(&bcap_dev->v4l2_dev, "v4l2 device registered\n"); > + > + spin_lock_init(&bcap_dev->lock); > + /* initialize queue */ > + q =&bcap_dev->buffer_queue; > + memset(q, 0, sizeof(*q)); > + q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; > + q->io_modes = VB2_MMAP; > + q->drv_priv = bcap_dev; > + q->buf_struct_size = sizeof(struct bcap_buffer); > + q->ops =&bcap_video_qops; > + q->mem_ops =&vb2_dma_contig_memops; > + > + vb2_queue_init(q); > + > + mutex_init(&bcap_dev->mutex); > + init_completion(&bcap_dev->comp); > + > + /* init video dma queues */ > + INIT_LIST_HEAD(&bcap_dev->dma_queue); > + > + vfd->lock =&bcap_dev->mutex; > + > + /* register video device */ > + ret = video_register_device(bcap_dev->video_dev, VFL_TYPE_GRABBER, -1); I think the video node registration should be very last thing done in this function, after everything else is initialized. The device is not really ready for use at this point, is it ? > + if (ret) { > + v4l2_err(&bcap_dev->v4l2_dev, > + "Unable to register video device\n"); > + goto err_unreg_v4l2; > + } > + video_set_drvdata(bcap_dev->video_dev, bcap_dev); > + v4l2_info(&bcap_dev->v4l2_dev, "video device registered as: %s\n", > + video_device_node_name(vfd)); > + > + /* load up the subdevice */ > + i2c_adap = i2c_get_adapter(config->i2c_adapter_id); > + if (!i2c_adap) { > + v4l2_err(&bcap_dev->v4l2_dev, > + "Unable to find i2c adapter\n"); > + goto err_unreg_vdev; > + > + } > + bcap_dev->sd = v4l2_i2c_new_subdev_board(&bcap_dev->v4l2_dev, > + i2c_adap, > + &config->board_info, > + NULL); > + if (bcap_dev->sd) { > + int i; > + /* update tvnorms from the sub devices */ > + for (i = 0; i< config->num_inputs; i++) > + vfd->tvnorms |= config->inputs[i].std; > + /* set default std */ > + bcap_dev->std = vfd->tvnorms; > + } else { > + v4l2_err(&bcap_dev->v4l2_dev, > + "Unable to register sub device\n"); > + goto err_unreg_vdev; > + } > + v4l2_info(&bcap_dev->v4l2_dev, "v4l2 sub device registered\n"); > + return 0; > +err_unreg_vdev: > + video_unregister_device(bcap_dev->video_dev); > +err_unreg_v4l2: > + v4l2_device_unregister(&bcap_dev->v4l2_dev); > +err_release_vdev: > + if (!video_is_registered(bcap_dev->video_dev)) > + video_device_release(bcap_dev->video_dev); > +err_cleanup_ctx: > + vb2_dma_contig_cleanup_ctx(bcap_dev->alloc_ctx); > +err_free_ppi: > + delete_ppi_instance(bcap_dev->ppi); > +err_free_dev: > + kfree(bcap_dev); > + return ret; > +} > + > +static int __devexit bcap_remove(struct platform_device *pdev) > +{ > + struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev); > + struct bcap_device *bcap_dev = container_of(v4l2_dev, > + struct bcap_device, v4l2_dev); > + > + video_unregister_device(bcap_dev->video_dev); > + v4l2_device_unregister(v4l2_dev); > + vb2_dma_contig_cleanup_ctx(bcap_dev->alloc_ctx); > + delete_ppi_instance(bcap_dev->ppi); > + kfree(bcap_dev); > + return 0; > +} > + > +static struct platform_driver bcap_driver = { > + .driver = { > + .name = CAPTURE_DRV_NAME, > + .owner = THIS_MODULE, > + }, > + .probe = bcap_probe, > + .remove = __devexit_p(bcap_remove), > +}; > + > +static __init int bcap_init(void) > +{ > + return platform_driver_register(&bcap_driver); > +} > + > +static __exit void bcap_exit(void) > +{ > + platform_driver_unregister(&bcap_driver); > +} > + > +module_init(bcap_init); > +module_exit(bcap_exit); > + > +MODULE_DESCRIPTION("Analog Devices video capture driver"); > +MODULE_AUTHOR("Scott Jiang<Scott.Jiang.Linux@gmail.com>"); > +MODULE_LICENSE("GPL v2"); > diff --git a/drivers/media/video/blackfin/ppi.c b/drivers/media/video/blackfin/ppi.c > new file mode 100644 > index 0000000..8139940 > --- /dev/null > +++ b/drivers/media/video/blackfin/ppi.c > @@ -0,0 +1,204 @@ > +/* > + * ppi.c Analog Devices Parallel Peripheral Interface driver > + * > + * Copyright (c) 2011 Analog Devices Inc. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License version 2 as > + * published by the Free Software Foundation. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * You should have received a copy of the GNU General Public License > + * along with this program; if not, write to the Free Software > + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. > + */ > + > +#include<linux/kernel.h> > +#include<linux/slab.h> > +#include<linux/ioport.h> > +#include<linux/platform_device.h> > + > +#include<asm/bfin_ppi.h> > +#include<asm/dma.h> > +#include<asm/cacheflush.h> > +#include<asm/blackfin.h> > +#include<asm/portmux.h> > + > +#include<media/blackfin/ppi.h> > + > +static int ppi_attach_irq(struct ppi_if *ppi, irq_handler_t handler); > +static void ppi_detach_irq(struct ppi_if *ppi); > +static int ppi_start(struct ppi_if *ppi); > +static int ppi_stop(struct ppi_if *ppi); > +static int ppi_set_params(struct ppi_if *ppi, struct ppi_params *params); > +static void ppi_update_addr(struct ppi_if *ppi, unsigned long addr); > + > +static const struct ppi_ops ppi_ops = { > + .attach_irq = ppi_attach_irq, > + .detach_irq = ppi_detach_irq, > + .start = ppi_start, > + .stop = ppi_stop, > + .set_params = ppi_set_params, > + .update_addr = ppi_update_addr, > +}; How about moving this struct to the bottom of the file and getting rid of all the above forward declarations ? > + > +static irqreturn_t ppi_irq_err(int irq, void *dev_id) > +{ > + struct ppi_if *ppi = dev_id; > + const struct ppi_info *info = ppi->info; > + unsigned short status; > + > + if (!strcmp(info->name, "ppi")) { > + struct bfin_ppi_regs __iomem *reg = > + (struct bfin_ppi_regs __iomem *)info->base; > + status = bfin_read16(reg->status); > + if (printk_ratelimit()) > + pr_info("%s: status = 0x%x\n", __func__, status); > + bfin_write16(®->status, 0xff); > + } > + > + return IRQ_HANDLED; > +} > + > +static int ppi_attach_irq(struct ppi_if *ppi, irq_handler_t handler) > +{ > + const struct ppi_info *info = ppi->info; > + > + if (request_dma(info->dma_ch, "PPI_DMA")< 0) { > + pr_err("Unable to allocate DMA channel for PPI\n"); > + return -EBUSY; > + } > + set_dma_callback(info->dma_ch, handler, ppi); > + > + if (request_irq(info->irq_err, ppi_irq_err, IRQF_DISABLED, > + "PPI ERROR", ppi)) { > + pr_err("Unable to allocate IRQ for PPI\n"); > + free_dma(info->dma_ch); > + return -EBUSY; > + } > + return 0; > +} > + > +static void ppi_detach_irq(struct ppi_if *ppi) > +{ > + const struct ppi_info *info = ppi->info; > + > + free_irq(info->irq_err, ppi); > + free_dma(info->dma_ch); > +} > + > +static int ppi_start(struct ppi_if *ppi) > +{ > + const struct ppi_info *info = ppi->info; > + > + /* enable DMA */ The comment seems redundant. > + enable_dma(info->dma_ch); > + > + /* enable PPI */ > + ppi->ppi_control |= PORT_EN; > + if (!strcmp(info->name, "ppi")) { > + struct bfin_ppi_regs __iomem *reg = > + (struct bfin_ppi_regs __iomem *)info->base; > + bfin_write16(®->control, ppi->ppi_control); > + } > + > + SSYNC(); > + return 0; > +} > + > +static int ppi_stop(struct ppi_if *ppi) > +{ > + const struct ppi_info *info = ppi->info; > + > + /* disable PPI */ > + ppi->ppi_control&= ~PORT_EN; > + if (!strcmp(info->name, "ppi")) { > + struct bfin_ppi_regs __iomem *reg = > + (struct bfin_ppi_regs __iomem *)info->base; > + bfin_write16(®->control, ppi->ppi_control); > + } > + + /* disable DMA */ > + clear_dma_irqstat(info->dma_ch); > + disable_dma(info->dma_ch); > + > + SSYNC(); > + return 0; > +} > + > +static int ppi_set_params(struct ppi_if *ppi, struct ppi_params *params) > +{ > + const struct ppi_info *info = ppi->info; > + > + ppi->bytes_per_line = params->width * params->bpp; > + ppi->lines_per_frame = params->height; > + > + /* config DMA */ > + ppi->dma_config = (DMA_FLOW_STOP | WNR | RESTART | DMA2D | DI_EN); > + if (params->ppi_control& DMA32) { > + ppi->dma_config |= WDSIZE_32; > + set_dma_x_count(info->dma_ch, ppi->bytes_per_line>> 2); > + set_dma_x_modify(info->dma_ch, 4); > + set_dma_y_modify(info->dma_ch, 4); > + } else { > + ppi->dma_config |= WDSIZE_16; > + set_dma_x_count(info->dma_ch, ppi->bytes_per_line>> 1); > + set_dma_x_modify(info->dma_ch, 2); > + set_dma_y_modify(info->dma_ch, 2); > + } > + set_dma_y_count(info->dma_ch, ppi->lines_per_frame); > + set_dma_config(info->dma_ch, ppi->dma_config); > + > + /* config PPI */ > + ppi->ppi_control = params->ppi_control& ~PORT_EN; > + if (!strcmp(info->name, "ppi")) { > + struct bfin_ppi_regs __iomem *reg = > + (struct bfin_ppi_regs __iomem *)info->base; > + bfin_write16(®->control, ppi->ppi_control); > + bfin_write16(®->count, ppi->bytes_per_line - 1); > + bfin_write16(®->frame, ppi->lines_per_frame); > + } > + > + SSYNC(); > + return 0; > +} > + > +static void ppi_update_addr(struct ppi_if *ppi, unsigned long addr) > +{ > + set_dma_start_addr(ppi->info->dma_ch, addr); > +} > + > +struct ppi_if *create_ppi_instance(const struct ppi_info *info) > +{ > + struct ppi_if *ppi; > + > + if ((info == NULL) || (info->name == NULL) || (info->pin_req == NULL)) The individual inner braces seem superfluous. > + return NULL; > + > + if (peripheral_request_list(info->pin_req, KBUILD_MODNAME)) { > + pr_err("request peripheral failed\n"); > + return NULL; > + } > + > + ppi = kzalloc(sizeof(*ppi), GFP_KERNEL); > + if (ppi == NULL) { > + peripheral_free_list(info->pin_req); > + pr_err("unable to allocate memory for ppi handle\n"); > + return NULL; > + } > + ppi->ops =&ppi_ops; > + ppi->info = info; > + > + pr_info("ppi probe success\n"); > + return ppi; > +} > + > +void delete_ppi_instance(struct ppi_if *ppi) > +{ > + peripheral_free_list(ppi->info->pin_req); > + kfree(ppi); > +} As a side note, I was not sure if this is just a resend of your original patches or a second version. It would be good to indicate that in the message subject. I think it's not a big deal and makes the reviewers' life easier. -- Thanks, Sylwester ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-13 21:19 ` Sylwester Nawrocki @ 2011-09-14 7:10 ` Scott Jiang 2011-09-14 14:30 ` Sylwester Nawrocki 0 siblings, 1 reply; 39+ messages in thread From: Scott Jiang @ 2011-09-14 7:10 UTC (permalink / raw) To: Sylwester Nawrocki Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski, linux-media, uclinux-dist-devel >> +static int bcap_qbuf(struct file *file, void *priv, >> + struct v4l2_buffer *buf) >> +{ >> + struct bcap_device *bcap_dev = video_drvdata(file); >> + struct v4l2_fh *fh = file->private_data; >> + struct bcap_fh *bcap_fh = container_of(fh, struct bcap_fh, fh); >> + >> + if (!bcap_fh->io_allowed) >> + return -EACCES; > > I suppose -EBUSY would be more appropriate here. > no, io_allowed is to control which file instance has the right to do I/O. >> + fmt =&bcap_formats[i]; >> + if (mbus_code) >> + *mbus_code = fmt->mbus_code; >> + if (bpp) >> + *bpp = fmt->bpp; >> + v4l2_fill_mbus_format(&mbus_fmt, pixfmt, >> + fmt->mbus_code); >> + ret = v4l2_subdev_call(bcap->sd, video, >> + try_mbus_fmt,&mbus_fmt); >> + if (ret< 0) >> + return ret; >> + v4l2_fill_pix_format(pixfmt,&mbus_fmt); >> + pixfmt->bytesperline = pixfmt->width * fmt->bpp; >> + pixfmt->sizeimage = pixfmt->bytesperline >> + * pixfmt->height; > > Still pixfmt->pixelformat isn't filled. > no here pixfmt->pixelformat is passed in >> + return 0; >> + } >> + } >> + return -EINVAL; > > I think you should return some default format, rather than giving up > when the fourcc doesn't match. However I'm not 100% sure this is > the specification requirement. > no, there is no default format for bridge driver because it knows nothing about this. all the format info bridge needs ask subdevice. >> +static const struct ppi_ops ppi_ops = { >> + .attach_irq = ppi_attach_irq, >> + .detach_irq = ppi_detach_irq, >> + .start = ppi_start, >> + .stop = ppi_stop, >> + .set_params = ppi_set_params, >> + .update_addr = ppi_update_addr, >> +}; > > How about moving this struct to the bottom of the file and getting rid of > all the above forward declarations ? > I'd like to put global varible before function in a file. >> + >> +void delete_ppi_instance(struct ppi_if *ppi) >> +{ >> + peripheral_free_list(ppi->info->pin_req); >> + kfree(ppi); >> +} > > As a side note, I was not sure if this is just a resend of your original > patches or a second version. It would be good to indicate that in the message > subject. I think it's not a big deal and makes the reviewers' life easier. if I don't add a version number in subject, it means it is the first version. ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-14 7:10 ` Scott Jiang @ 2011-09-14 14:30 ` Sylwester Nawrocki 2011-09-15 2:40 ` Scott Jiang 2011-09-26 14:25 ` Hans Verkuil 0 siblings, 2 replies; 39+ messages in thread From: Sylwester Nawrocki @ 2011-09-14 14:30 UTC (permalink / raw) To: Scott Jiang Cc: Sylwester Nawrocki, Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski, linux-media, uclinux-dist-devel On 09/14/2011 09:10 AM, Scott Jiang wrote: >>> +static int bcap_qbuf(struct file *file, void *priv, >>> + struct v4l2_buffer *buf) >>> +{ >>> + struct bcap_device *bcap_dev = video_drvdata(file); >>> + struct v4l2_fh *fh = file->private_data; >>> + struct bcap_fh *bcap_fh = container_of(fh, struct bcap_fh, fh); >>> + >>> + if (!bcap_fh->io_allowed) >>> + return -EACCES; >> >> I suppose -EBUSY would be more appropriate here. >> > no, io_allowed is to control which file instance has the right to do I/O. Looks like you are doing here what the v4l2 priority mechanism is meant for. Have you considered the access priority (VIDIOC_G_PRIORITY/VIDIOC_S_PRIORITY and friends)? Does it have any shortcomings? > >>> + fmt =&bcap_formats[i]; >>> + if (mbus_code) >>> + *mbus_code = fmt->mbus_code; >>> + if (bpp) >>> + *bpp = fmt->bpp; >>> + v4l2_fill_mbus_format(&mbus_fmt, pixfmt, >>> + fmt->mbus_code); >>> + ret = v4l2_subdev_call(bcap->sd, video, >>> + try_mbus_fmt,&mbus_fmt); >>> + if (ret< 0) >>> + return ret; >>> + v4l2_fill_pix_format(pixfmt,&mbus_fmt); >>> + pixfmt->bytesperline = pixfmt->width * fmt->bpp; >>> + pixfmt->sizeimage = pixfmt->bytesperline >>> + * pixfmt->height; >> >> Still pixfmt->pixelformat isn't filled. >> > no here pixfmt->pixelformat is passed in > >>> + return 0; >>> + } >>> + } >>> + return -EINVAL; >> >> I think you should return some default format, rather than giving up >> when the fourcc doesn't match. However I'm not 100% sure this is >> the specification requirement. >> > no, there is no default format for bridge driver because it knows > nothing about this. > all the format info bridge needs ask subdevice. It's the bridge driver that exports a device node and is responsible for setting the default format. It should be possible to start streaming right after opening the device, without VIDIOC_S_FMT, with some reasonable defaults. If, as you say, the bridge knows nothing about formats what the bcap_formats[] array is here for ? > >>> +static const struct ppi_ops ppi_ops = { >>> + .attach_irq = ppi_attach_irq, >>> + .detach_irq = ppi_detach_irq, >>> + .start = ppi_start, >>> + .stop = ppi_stop, >>> + .set_params = ppi_set_params, >>> + .update_addr = ppi_update_addr, >>> +}; >> >> How about moving this struct to the bottom of the file and getting rid of >> all the above forward declarations ? >> > I'd like to put global varible before function in a file. > >>> + >>> +void delete_ppi_instance(struct ppi_if *ppi) >>> +{ >>> + peripheral_free_list(ppi->info->pin_req); >>> + kfree(ppi); >>> +} >> >> As a side note, I was not sure if this is just a resend of your original >> patches or a second version. It would be good to indicate that in the message >> subject. I think it's not a big deal and makes the reviewers' life easier. > if I don't add a version number in subject, it means it is the first version. Sorry, please ignore this. I got confused by the mailer and thought the same patches appeared twice on the list. Thanks, -- Sylwester Nawrocki Samsung Poland R&D Center ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-14 14:30 ` Sylwester Nawrocki @ 2011-09-15 2:40 ` Scott Jiang 2011-09-15 6:35 ` Guennadi Liakhovetski 2011-09-15 21:17 ` Sylwester Nawrocki 2011-09-26 14:25 ` Hans Verkuil 1 sibling, 2 replies; 39+ messages in thread From: Scott Jiang @ 2011-09-15 2:40 UTC (permalink / raw) To: Sylwester Nawrocki Cc: Sylwester Nawrocki, Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski, linux-media, uclinux-dist-devel 2011/9/14 Sylwester Nawrocki <s.nawrocki@samsung.com>: > On 09/14/2011 09:10 AM, Scott Jiang wrote: >>>> +static int bcap_qbuf(struct file *file, void *priv, >>>> + struct v4l2_buffer *buf) >>>> +{ >>>> + struct bcap_device *bcap_dev = video_drvdata(file); >>>> + struct v4l2_fh *fh = file->private_data; >>>> + struct bcap_fh *bcap_fh = container_of(fh, struct bcap_fh, fh); >>>> + >>>> + if (!bcap_fh->io_allowed) >>>> + return -EACCES; >>> >>> I suppose -EBUSY would be more appropriate here. >>> >> no, io_allowed is to control which file instance has the right to do I/O. > > Looks like you are doing here what the v4l2 priority mechanism is meant for. > Have you considered the access priority (VIDIOC_G_PRIORITY/VIDIOC_S_PRIORITY > and friends)? Does it have any shortcomings? > I refer to davinci driver, perhaps it is not good enough, I'd like to modify it later. >> >>>> + fmt =&bcap_formats[i]; >>>> + if (mbus_code) >>>> + *mbus_code = fmt->mbus_code; >>>> + if (bpp) >>>> + *bpp = fmt->bpp; >>>> + v4l2_fill_mbus_format(&mbus_fmt, pixfmt, >>>> + fmt->mbus_code); >>>> + ret = v4l2_subdev_call(bcap->sd, video, >>>> + try_mbus_fmt,&mbus_fmt); >>>> + if (ret< 0) >>>> + return ret; >>>> + v4l2_fill_pix_format(pixfmt,&mbus_fmt); >>>> + pixfmt->bytesperline = pixfmt->width * fmt->bpp; >>>> + pixfmt->sizeimage = pixfmt->bytesperline >>>> + * pixfmt->height; >>> >>> Still pixfmt->pixelformat isn't filled. >>> >> no here pixfmt->pixelformat is passed in >> >>>> + return 0; >>>> + } >>>> + } >>>> + return -EINVAL; >>> >>> I think you should return some default format, rather than giving up >>> when the fourcc doesn't match. However I'm not 100% sure this is >>> the specification requirement. >>> >> no, there is no default format for bridge driver because it knows >> nothing about this. >> all the format info bridge needs ask subdevice. > > It's the bridge driver that exports a device node and is responsible for > setting the default format. It should be possible to start streaming right > after opening the device, without VIDIOC_S_FMT, with some reasonable defaults. > > If, as you say, the bridge knows nothing about formats what the bcap_formats[] > array is here for ? > accually this array is to convert mbus to pixformat. ppi supports any formats. Ideally it should contain all formats in v4l2, but it is enough at present for our platform. If I find someone needs more, I will add it. So return -EINVAL means this format is out of range, it can't be supported now. about default format, I think I can only call bcap_g_fmt_vid_cap in probe to get this info. Dose anybody have a better solution? ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-15 2:40 ` Scott Jiang @ 2011-09-15 6:35 ` Guennadi Liakhovetski 2011-09-15 6:48 ` Scott Jiang 2011-09-15 21:17 ` Sylwester Nawrocki 1 sibling, 1 reply; 39+ messages in thread From: Guennadi Liakhovetski @ 2011-09-15 6:35 UTC (permalink / raw) To: Scott Jiang Cc: Sylwester Nawrocki, Sylwester Nawrocki, Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel On Thu, 15 Sep 2011, Scott Jiang wrote: > accually this array is to convert mbus to pixformat. ppi supports any formats. You mean, it doesn't distinguish formats? It just packs bytes in RAM exactly as it ready them from the bus, and doesn't support any formats natively, i.e., doesn't offer any data processing? > Ideally it should contain all formats in v4l2, but it is enough at > present for our platform. > If I find someone needs more, I will add it. > So return -EINVAL means this format is out of range, it can't be supported now. You might consider using drivers/media/video/soc_mediabus.c If your driver were using soc-camera, it could benefit from the dynamically built pixel translation table, see drivers/media/video/soc_camera.c::soc_camera_init_user_formats() and simpler examples like mx1_camera.c or more complex ones like sh_mobile_ceu_camera.c, pxa_camera.c or mx3_camera.c and the use of the soc_camera_xlate_by_fourcc() function in them. > about default format, I think I can only call bcap_g_fmt_vid_cap in > probe to get this info. > Dose anybody have a better solution? In soc-camera we just use .g_mbus_fmt() to get sensor's default format and see what we can produce from it for the user. Thanks Guennadi --- Guennadi Liakhovetski, Ph.D. Freelance Open-Source Software Developer http://www.open-technology.de/ ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-15 6:35 ` Guennadi Liakhovetski @ 2011-09-15 6:48 ` Scott Jiang 2011-09-15 7:14 ` Guennadi Liakhovetski 0 siblings, 1 reply; 39+ messages in thread From: Scott Jiang @ 2011-09-15 6:48 UTC (permalink / raw) To: Guennadi Liakhovetski Cc: Sylwester Nawrocki, Sylwester Nawrocki, Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel 2011/9/15 Guennadi Liakhovetski <g.liakhovetski@gmx.de>: > On Thu, 15 Sep 2011, Scott Jiang wrote: > >> accually this array is to convert mbus to pixformat. ppi supports any formats. > > You mean, it doesn't distinguish formats? It just packs bytes in RAM > exactly as it ready them from the bus, and doesn't support any formats > natively, i.e., doesn't offer any data processing? > yes, ppi means Parallel Peripheral Interface. >> Ideally it should contain all formats in v4l2, but it is enough at >> present for our platform. >> If I find someone needs more, I will add it. >> So return -EINVAL means this format is out of range, it can't be supported now. > > You might consider using > > drivers/media/video/soc_mediabus.c > > If your driver were using soc-camera, it could benefit from the > dynamically built pixel translation table, see > > drivers/media/video/soc_camera.c::soc_camera_init_user_formats() > > and simpler examples like mx1_camera.c or more complex ones like > sh_mobile_ceu_camera.c, pxa_camera.c or mx3_camera.c and the use of the > soc_camera_xlate_by_fourcc() function in them. > I have considered using soc, but it can't support decoder when I began to write this driver in 2.6.38. ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-15 6:48 ` Scott Jiang @ 2011-09-15 7:14 ` Guennadi Liakhovetski 2011-09-15 7:26 ` Scott Jiang 0 siblings, 1 reply; 39+ messages in thread From: Guennadi Liakhovetski @ 2011-09-15 7:14 UTC (permalink / raw) To: Scott Jiang Cc: Sylwester Nawrocki, Sylwester Nawrocki, Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel On Thu, 15 Sep 2011, Scott Jiang wrote: > 2011/9/15 Guennadi Liakhovetski <g.liakhovetski@gmx.de>: > > On Thu, 15 Sep 2011, Scott Jiang wrote: > > > >> accually this array is to convert mbus to pixformat. ppi supports any formats. > > > > You mean, it doesn't distinguish formats? It just packs bytes in RAM > > exactly as it ready them from the bus, and doesn't support any formats > > natively, i.e., doesn't offer any data processing? > > > yes, ppi means Parallel Peripheral Interface. > > >> Ideally it should contain all formats in v4l2, but it is enough at > >> present for our platform. > >> If I find someone needs more, I will add it. > >> So return -EINVAL means this format is out of range, it can't be supported now. > > > > You might consider using > > > > drivers/media/video/soc_mediabus.c > > > > If your driver were using soc-camera, it could benefit from the > > dynamically built pixel translation table, see > > > > drivers/media/video/soc_camera.c::soc_camera_init_user_formats() > > > > and simpler examples like mx1_camera.c or more complex ones like > > sh_mobile_ceu_camera.c, pxa_camera.c or mx3_camera.c and the use of the > > soc_camera_xlate_by_fourcc() function in them. > > > I have considered using soc, but it can't support decoder when I began > to write this driver in 2.6.38. soc_mediabus.c is a stand-alone module, it has no dependencies on soc-camera. Out of interest - what kind of decoder you mean? A tv-decoder? We do have a tv-decoder driver tw9910 under soc-camera. Thanks Guennadi --- Guennadi Liakhovetski, Ph.D. Freelance Open-Source Software Developer http://www.open-technology.de/ ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-15 7:14 ` Guennadi Liakhovetski @ 2011-09-15 7:26 ` Scott Jiang 2011-09-15 7:32 ` Guennadi Liakhovetski 0 siblings, 1 reply; 39+ messages in thread From: Scott Jiang @ 2011-09-15 7:26 UTC (permalink / raw) To: Guennadi Liakhovetski Cc: Sylwester Nawrocki, Sylwester Nawrocki, Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel >> I have considered using soc, but it can't support decoder when I began >> to write this driver in 2.6.38. > > soc_mediabus.c is a stand-alone module, it has no dependencies on > soc-camera. > > Out of interest - what kind of decoder you mean? A tv-decoder? We do have > a tv-decoder driver tw9910 under soc-camera. > static int soc_camera_s_input(struct file *file, void *priv, unsigned int i) { if (i > 0) return -EINVAL; return 0; } I don't think most of tv-decoders only support one input. ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-15 7:26 ` Scott Jiang @ 2011-09-15 7:32 ` Guennadi Liakhovetski 0 siblings, 0 replies; 39+ messages in thread From: Guennadi Liakhovetski @ 2011-09-15 7:32 UTC (permalink / raw) To: Scott Jiang Cc: Sylwester Nawrocki, Sylwester Nawrocki, Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel On Thu, 15 Sep 2011, Scott Jiang wrote: > >> I have considered using soc, but it can't support decoder when I began > >> to write this driver in 2.6.38. > > > > soc_mediabus.c is a stand-alone module, it has no dependencies on > > soc-camera. > > > > Out of interest - what kind of decoder you mean? A tv-decoder? We do have > > a tv-decoder driver tw9910 under soc-camera. > > > static int soc_camera_s_input(struct file *file, void *priv, unsigned int i) > { > if (i > 0) > return -EINVAL; > > return 0; > } > I don't think most of tv-decoders only support one input. Ah:-) soc-camera is a living project, it's not set in stone. Until now we didn't have any need for more than one input, but as soon as such a need would arise, this would be changed in no time. Thanks Guennadi --- Guennadi Liakhovetski, Ph.D. Freelance Open-Source Software Developer http://www.open-technology.de/ ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-15 2:40 ` Scott Jiang 2011-09-15 6:35 ` Guennadi Liakhovetski @ 2011-09-15 21:17 ` Sylwester Nawrocki 2011-09-16 2:34 ` Scott Jiang 1 sibling, 1 reply; 39+ messages in thread From: Sylwester Nawrocki @ 2011-09-15 21:17 UTC (permalink / raw) To: Scott Jiang Cc: Sylwester Nawrocki, Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski, linux-media, uclinux-dist-devel On 09/15/2011 04:40 AM, Scott Jiang wrote: > 2011/9/14 Sylwester Nawrocki<s.nawrocki@samsung.com>: >> On 09/14/2011 09:10 AM, Scott Jiang wrote: >>> >>>>> + fmt =&bcap_formats[i]; >>>>> + if (mbus_code) >>>>> + *mbus_code = fmt->mbus_code; >>>>> + if (bpp) >>>>> + *bpp = fmt->bpp; >>>>> + v4l2_fill_mbus_format(&mbus_fmt, pixfmt, >>>>> + fmt->mbus_code); >>>>> + ret = v4l2_subdev_call(bcap->sd, video, >>>>> + try_mbus_fmt,&mbus_fmt); >>>>> + if (ret< 0) >>>>> + return ret; >>>>> + v4l2_fill_pix_format(pixfmt,&mbus_fmt); >>>>> + pixfmt->bytesperline = pixfmt->width * fmt->bpp; >>>>> + pixfmt->sizeimage = pixfmt->bytesperline >>>>> + * pixfmt->height; No need to clamp mbus_fmt.width and mbus_fmt.height to some maximum values to prevent allocating huge memory buffers ? >>>> >>>> Still pixfmt->pixelformat isn't filled. >>>> >>> no here pixfmt->pixelformat is passed in >>> >>>>> + return 0; >>>>> + } >>>>> + } >>>>> + return -EINVAL; >>>> >>>> I think you should return some default format, rather than giving up >>>> when the fourcc doesn't match. However I'm not 100% sure this is >>>> the specification requirement. >>>> >>> no, there is no default format for bridge driver because it knows >>> nothing about this. >>> all the format info bridge needs ask subdevice. >> >> It's the bridge driver that exports a device node and is responsible for >> setting the default format. It should be possible to start streaming right >> after opening the device, without VIDIOC_S_FMT, with some reasonable defaults. >> >> If, as you say, the bridge knows nothing about formats what the bcap_formats[] >> array is here for ? >> > accually this array is to convert mbus to pixformat. ppi supports any formats. > Ideally it should contain all formats in v4l2, but it is enough at > present for our platform. > If I find someone needs more, I will add it. > So return -EINVAL means this format is out of range, it can't be supported now. Ok, fair enough. I guess you rely on subdev driver to return some supported value through mbus_try_fmt and then the bridge driver must be able to handle this. However it might make sense to validate the resolution in some places to prevent allocating insanely huge buffers, when the sensor subdev misbehaves. > > about default format, I think I can only call bcap_g_fmt_vid_cap in > probe to get this info. > Dose anybody have a better solution? How about doing that when device is opened for the first time ? However it could make more sense to try to set format at the subdev and then check how it was adjusted. Not all subdevs might implement g_mbus_fmt op or some might not deliver sane default values. ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-15 21:17 ` Sylwester Nawrocki @ 2011-09-16 2:34 ` Scott Jiang 2011-09-16 6:48 ` Guennadi Liakhovetski 0 siblings, 1 reply; 39+ messages in thread From: Scott Jiang @ 2011-09-16 2:34 UTC (permalink / raw) To: Sylwester Nawrocki Cc: Sylwester Nawrocki, Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski, linux-media, uclinux-dist-devel 2011/9/16 Sylwester Nawrocki <snjw23@gmail.com>: > On 09/15/2011 04:40 AM, Scott Jiang wrote: >> 2011/9/14 Sylwester Nawrocki<s.nawrocki@samsung.com>: >>> On 09/14/2011 09:10 AM, Scott Jiang wrote: >>>> >>>>>> + fmt =&bcap_formats[i]; >>>>>> + if (mbus_code) >>>>>> + *mbus_code = fmt->mbus_code; >>>>>> + if (bpp) >>>>>> + *bpp = fmt->bpp; >>>>>> + v4l2_fill_mbus_format(&mbus_fmt, pixfmt, >>>>>> + fmt->mbus_code); >>>>>> + ret = v4l2_subdev_call(bcap->sd, video, >>>>>> + try_mbus_fmt,&mbus_fmt); >>>>>> + if (ret< 0) >>>>>> + return ret; >>>>>> + v4l2_fill_pix_format(pixfmt,&mbus_fmt); >>>>>> + pixfmt->bytesperline = pixfmt->width * fmt->bpp; >>>>>> + pixfmt->sizeimage = pixfmt->bytesperline >>>>>> + * pixfmt->height; > > No need to clamp mbus_fmt.width and mbus_fmt.height to some maximum values > to prevent allocating huge memory buffers ? > >>>>> >>>>> Still pixfmt->pixelformat isn't filled. >>>>> >>>> no here pixfmt->pixelformat is passed in >>>> >>>>>> + return 0; >>>>>> + } >>>>>> + } >>>>>> + return -EINVAL; >>>>> >>>>> I think you should return some default format, rather than giving up >>>>> when the fourcc doesn't match. However I'm not 100% sure this is >>>>> the specification requirement. >>>>> >>>> no, there is no default format for bridge driver because it knows >>>> nothing about this. >>>> all the format info bridge needs ask subdevice. >>> >>> It's the bridge driver that exports a device node and is responsible for >>> setting the default format. It should be possible to start streaming right >>> after opening the device, without VIDIOC_S_FMT, with some reasonable defaults. >>> >>> If, as you say, the bridge knows nothing about formats what the bcap_formats[] >>> array is here for ? >>> >> accually this array is to convert mbus to pixformat. ppi supports any formats. >> Ideally it should contain all formats in v4l2, but it is enough at >> present for our platform. >> If I find someone needs more, I will add it. >> So return -EINVAL means this format is out of range, it can't be supported now. > > Ok, fair enough. I guess you rely on subdev driver to return some supported > value through mbus_try_fmt and then the bridge driver must be able to handle > this. However it might make sense to validate the resolution in some places > to prevent allocating insanely huge buffers, when the sensor subdev misbehaves. > all the format info is got from sensor, so it isn't out of control >> >> about default format, I think I can only call bcap_g_fmt_vid_cap in >> probe to get this info. >> Dose anybody have a better solution? > > How about doing that when device is opened for the first time ? > no, different input and std has different default format, so I think there is no default format is a good choice. app should negotiate format before use. I'm not sure all the v4l2 app will do this step. v4l2 spec only says driver must implement xx ioctl, but it doesn't say app must call xx ioctl. Anyone can tell me how many steps app must call? > However it > could make more sense to try to set format at the subdev and then check how > it was adjusted. Not all subdevs might implement g_mbus_fmt op or some might > not deliver sane default values. > in try_format and s_fmt I have implemented this in bridge driver and all my sensor drivers have implemented relative callback. ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-16 2:34 ` Scott Jiang @ 2011-09-16 6:48 ` Guennadi Liakhovetski 0 siblings, 0 replies; 39+ messages in thread From: Guennadi Liakhovetski @ 2011-09-16 6:48 UTC (permalink / raw) To: Scott Jiang Cc: Sylwester Nawrocki, Sylwester Nawrocki, Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel On Fri, 16 Sep 2011, Scott Jiang wrote: > 2011/9/16 Sylwester Nawrocki <snjw23@gmail.com>: > > On 09/15/2011 04:40 AM, Scott Jiang wrote: > >> 2011/9/14 Sylwester Nawrocki<s.nawrocki@samsung.com>: > >>> On 09/14/2011 09:10 AM, Scott Jiang wrote: > >>>> > >>>>>> + fmt =&bcap_formats[i]; > >>>>>> + if (mbus_code) > >>>>>> + *mbus_code = fmt->mbus_code; > >>>>>> + if (bpp) > >>>>>> + *bpp = fmt->bpp; > >>>>>> + v4l2_fill_mbus_format(&mbus_fmt, pixfmt, > >>>>>> + fmt->mbus_code); > >>>>>> + ret = v4l2_subdev_call(bcap->sd, video, > >>>>>> + try_mbus_fmt,&mbus_fmt); > >>>>>> + if (ret< 0) > >>>>>> + return ret; > >>>>>> + v4l2_fill_pix_format(pixfmt,&mbus_fmt); > >>>>>> + pixfmt->bytesperline = pixfmt->width * fmt->bpp; > >>>>>> + pixfmt->sizeimage = pixfmt->bytesperline > >>>>>> + * pixfmt->height; > > > > No need to clamp mbus_fmt.width and mbus_fmt.height to some maximum values > > to prevent allocating huge memory buffers ? > > > >>>>> > >>>>> Still pixfmt->pixelformat isn't filled. > >>>>> > >>>> no here pixfmt->pixelformat is passed in > >>>> > >>>>>> + return 0; > >>>>>> + } > >>>>>> + } > >>>>>> + return -EINVAL; > >>>>> > >>>>> I think you should return some default format, rather than giving up > >>>>> when the fourcc doesn't match. However I'm not 100% sure this is > >>>>> the specification requirement. > >>>>> > >>>> no, there is no default format for bridge driver because it knows > >>>> nothing about this. > >>>> all the format info bridge needs ask subdevice. > >>> > >>> It's the bridge driver that exports a device node and is responsible for > >>> setting the default format. It should be possible to start streaming right > >>> after opening the device, without VIDIOC_S_FMT, with some reasonable defaults. > >>> > >>> If, as you say, the bridge knows nothing about formats what the bcap_formats[] > >>> array is here for ? > >>> > >> accually this array is to convert mbus to pixformat. ppi supports any formats. > >> Ideally it should contain all formats in v4l2, but it is enough at > >> present for our platform. > >> If I find someone needs more, I will add it. > >> So return -EINVAL means this format is out of range, it can't be supported now. > > > > Ok, fair enough. I guess you rely on subdev driver to return some supported > > value through mbus_try_fmt and then the bridge driver must be able to handle > > this. However it might make sense to validate the resolution in some places > > to prevent allocating insanely huge buffers, when the sensor subdev misbehaves. > > > all the format info is got from sensor, so it isn't out of control > > >> > >> about default format, I think I can only call bcap_g_fmt_vid_cap in > >> probe to get this info. > >> Dose anybody have a better solution? > > > > How about doing that when device is opened for the first time ? > > > no, different input and std has different default format, so I think > there is no default format is a good choice. > app should negotiate format before use. I'm not sure all the v4l2 app > will do this step. > v4l2 spec only says driver must implement xx ioctl, but it doesn't say > app must call xx ioctl. > Anyone can tell me how many steps app must call? IIRC, the user shall be able to open a v4l2 device, queue buffers and start streaming - without setting any format. > > However it > > could make more sense to try to set format at the subdev and then check how > > it was adjusted. Not all subdevs might implement g_mbus_fmt op or some might > > not deliver sane default values. > > > in try_format and s_fmt I have implemented this in bridge driver and > all my sensor drivers have implemented relative callback. Thanks Guennadi --- Guennadi Liakhovetski, Ph.D. Freelance Open-Source Software Developer http://www.open-technology.de/ ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-14 14:30 ` Sylwester Nawrocki 2011-09-15 2:40 ` Scott Jiang @ 2011-09-26 14:25 ` Hans Verkuil 2011-10-01 10:03 ` Sylwester Nawrocki 1 sibling, 1 reply; 39+ messages in thread From: Hans Verkuil @ 2011-09-26 14:25 UTC (permalink / raw) To: Sylwester Nawrocki Cc: Scott Jiang, Sylwester Nawrocki, Mauro Carvalho Chehab, Laurent Pinchart, Guennadi Liakhovetski, linux-media, uclinux-dist-devel On Wednesday, September 14, 2011 16:30:47 Sylwester Nawrocki wrote: > On 09/14/2011 09:10 AM, Scott Jiang wrote: > >>> +static int bcap_qbuf(struct file *file, void *priv, > >>> + struct v4l2_buffer *buf) > >>> +{ > >>> + struct bcap_device *bcap_dev = video_drvdata(file); > >>> + struct v4l2_fh *fh = file->private_data; > >>> + struct bcap_fh *bcap_fh = container_of(fh, struct bcap_fh, fh); > >>> + > >>> + if (!bcap_fh->io_allowed) > >>> + return -EACCES; > >> > >> I suppose -EBUSY would be more appropriate here. > >> > > no, io_allowed is to control which file instance has the right to do I/O. > > Looks like you are doing here what the v4l2 priority mechanism is meant for. > Have you considered the access priority (VIDIOC_G_PRIORITY/VIDIOC_S_PRIORITY > and friends)? Does it have any shortcomings? Sylwester, the priority handling doesn't take care of this particular case. When it comes to streaming you need to administrate which filehandle started the streaming and block any other filehandle from interfering with that. This check should really be done in vb2. Regards, Hans ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-26 14:25 ` Hans Verkuil @ 2011-10-01 10:03 ` Sylwester Nawrocki 0 siblings, 0 replies; 39+ messages in thread From: Sylwester Nawrocki @ 2011-10-01 10:03 UTC (permalink / raw) To: Hans Verkuil Cc: Sylwester Nawrocki, Scott Jiang, Mauro Carvalho Chehab, Laurent Pinchart, Guennadi Liakhovetski, linux-media, uclinux-dist-devel Hello Hans, On 09/26/2011 04:25 PM, Hans Verkuil wrote: > On Wednesday, September 14, 2011 16:30:47 Sylwester Nawrocki wrote: >> On 09/14/2011 09:10 AM, Scott Jiang wrote: >>>>> +static int bcap_qbuf(struct file *file, void *priv, >>>>> + struct v4l2_buffer *buf) >>>>> +{ >>>>> + struct bcap_device *bcap_dev = video_drvdata(file); >>>>> + struct v4l2_fh *fh = file->private_data; >>>>> + struct bcap_fh *bcap_fh = container_of(fh, struct bcap_fh, fh); >>>>> + >>>>> + if (!bcap_fh->io_allowed) >>>>> + return -EACCES; >>>> >>>> I suppose -EBUSY would be more appropriate here. >>>> >>> no, io_allowed is to control which file instance has the right to do I/O. >> >> Looks like you are doing here what the v4l2 priority mechanism is meant for. >> Have you considered the access priority (VIDIOC_G_PRIORITY/VIDIOC_S_PRIORITY >> and friends)? Does it have any shortcomings? > > Sylwester, the priority handling doesn't take care of this particular case. > > When it comes to streaming you need to administrate which filehandle started > the streaming and block any other filehandle from interfering with that. > > This check should really be done in vb2. True, I've noticed QBUF/DQBUF are not touched by the priority handling. Perhaps I didn't follow the discussions in this topic carefully enough. Then we seem to have another feature request for vb2. -- Thanks, Sylwester ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [uclinux-dist-devel] [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-13 18:34 ` [PATCH 4/4] v4l2: add blackfin capture bridge driver Scott Jiang 2011-09-13 8:11 ` Guennadi Liakhovetski 2011-09-13 21:19 ` Sylwester Nawrocki @ 2011-09-14 3:19 ` Mike Frysinger 2011-09-14 7:16 ` Scott Jiang 2011-09-17 20:54 ` Guennadi Liakhovetski 3 siblings, 1 reply; 39+ messages in thread From: Mike Frysinger @ 2011-09-14 3:19 UTC (permalink / raw) To: Scott Jiang Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski, uclinux-dist-devel, linux-media On Tue, Sep 13, 2011 at 14:34, Scott Jiang wrote: > --- /dev/null > +++ b/drivers/media/video/blackfin/Kconfig > @@ -0,0 +1,10 @@ > +config VIDEO_BLACKFIN_CAPTURE > + tristate "Blackfin Video Capture Driver" > + depends on VIDEO_DEV && BLACKFIN > + select VIDEOBUF2_DMA_CONTIG since the code needs i2c, this needs to list I2C under depends > --- /dev/null > +++ b/drivers/media/video/blackfin/bfin_capture.c > > +#include <linux/moduleparam.h> > +#include <linux/version.h> > +#include <linux/clk.h> i think at least these three are unused and should get punted > +static int __devinit bcap_probe(struct platform_device *pdev) > +{ > + struct bcap_device *bcap_dev; > + struct video_device *vfd; > + struct i2c_adapter *i2c_adap; you need to include linux/i2c.h for this > +static struct platform_driver bcap_driver = { > + .driver = { > + .name = CAPTURE_DRV_NAME, > + .owner = THIS_MODULE, > + }, > + .probe = bcap_probe, > + .remove = __devexit_p(bcap_remove), > +}; no suspend/resume ? :) > +MODULE_DESCRIPTION("Analog Devices video capture driver"); should mention the device part name in the desc > --- /dev/null > +++ b/drivers/media/video/blackfin/ppi.c > > +struct ppi_if *create_ppi_instance(const struct ppi_info *info) > +void delete_ppi_instance(struct ppi_if *ppi) should be ppi_{create,delete}_instance to match existing ppi_xxx style -mike ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [uclinux-dist-devel] [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-14 3:19 ` [uclinux-dist-devel] " Mike Frysinger @ 2011-09-14 7:16 ` Scott Jiang 2011-09-14 7:22 ` Guennadi Liakhovetski 0 siblings, 1 reply; 39+ messages in thread From: Scott Jiang @ 2011-09-14 7:16 UTC (permalink / raw) To: Mike Frysinger Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, Guennadi Liakhovetski, uclinux-dist-devel, linux-media > i think at least these three are unused and should get punted > >> +static int __devinit bcap_probe(struct platform_device *pdev) >> +{ >> + struct bcap_device *bcap_dev; >> + struct video_device *vfd; >> + struct i2c_adapter *i2c_adap; > > you need to include linux/i2c.h for this > no, bfin_capture.h already contains this. ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [uclinux-dist-devel] [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-14 7:16 ` Scott Jiang @ 2011-09-14 7:22 ` Guennadi Liakhovetski 0 siblings, 0 replies; 39+ messages in thread From: Guennadi Liakhovetski @ 2011-09-14 7:22 UTC (permalink / raw) To: Scott Jiang Cc: Mike Frysinger, Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, uclinux-dist-devel, linux-media On Wed, 14 Sep 2011, Scott Jiang wrote: > > i think at least these three are unused and should get punted > > > >> +static int __devinit bcap_probe(struct platform_device *pdev) > >> +{ > >> + struct bcap_device *bcap_dev; > >> + struct video_device *vfd; > >> + struct i2c_adapter *i2c_adap; > > > > you need to include linux/i2c.h for this > > > no, bfin_capture.h already contains this. It doesn't matter. You're supposed to _explicitly_ include every header, that is required to build your code. Thanks Guennadi --- Guennadi Liakhovetski, Ph.D. Freelance Open-Source Software Developer http://www.open-technology.de/ ^ permalink raw reply [flat|nested] 39+ messages in thread
* Re: [PATCH 4/4] v4l2: add blackfin capture bridge driver 2011-09-13 18:34 ` [PATCH 4/4] v4l2: add blackfin capture bridge driver Scott Jiang ` (2 preceding siblings ...) 2011-09-14 3:19 ` [uclinux-dist-devel] " Mike Frysinger @ 2011-09-17 20:54 ` Guennadi Liakhovetski 3 siblings, 0 replies; 39+ messages in thread From: Guennadi Liakhovetski @ 2011-09-17 20:54 UTC (permalink / raw) To: Scott Jiang Cc: Mauro Carvalho Chehab, Laurent Pinchart, Hans Verkuil, linux-media, uclinux-dist-devel One more clean-up possibility: On Tue, 13 Sep 2011, Scott Jiang wrote: > this is a v4l2 bridge driver for Blackfin video capture device, > support ppi interface > > Signed-off-by: Scott Jiang <scott.jiang.linux@gmail.com> > --- [snip] > diff --git a/drivers/media/video/blackfin/bfin_capture.c b/drivers/media/video/blackfin/bfin_capture.c > new file mode 100644 > index 0000000..24f89f2 > --- /dev/null > +++ b/drivers/media/video/blackfin/bfin_capture.c > @@ -0,0 +1,1099 @@ [snip] > +static int __devinit bcap_probe(struct platform_device *pdev) > +{ > + struct bcap_device *bcap_dev; > + struct video_device *vfd; > + struct i2c_adapter *i2c_adap; > + struct bfin_capture_config *config; > + struct vb2_queue *q; > + int ret; > + > + config = pdev->dev.platform_data; > + if (!config) { > + v4l2_err(pdev->dev.driver, "Unable to get board config\n"); > + return -ENODEV; > + } > + > + bcap_dev = kzalloc(sizeof(*bcap_dev), GFP_KERNEL); > + if (!bcap_dev) { > + v4l2_err(pdev->dev.driver, "Unable to alloc bcap_dev\n"); > + return -ENOMEM; > + } > + > + bcap_dev->cfg = config; > + > + bcap_dev->ppi = create_ppi_instance(config->ppi_info); > + if (!bcap_dev->ppi) { > + v4l2_err(pdev->dev.driver, "Unable to create ppi\n"); > + ret = -ENODEV; > + goto err_free_dev; > + } > + bcap_dev->ppi->priv = bcap_dev; > + > + bcap_dev->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev); > + if (IS_ERR(bcap_dev->alloc_ctx)) { > + ret = PTR_ERR(bcap_dev->alloc_ctx); > + goto err_free_ppi; > + } > + > + vfd = video_device_alloc(); > + if (!vfd) { > + ret = -ENOMEM; > + v4l2_err(pdev->dev.driver, "Unable to alloc video device\n"); > + goto err_cleanup_ctx; > + } > + > + /* initialize field of video device */ > + vfd->release = video_device_release; > + vfd->fops = &bcap_fops; > + vfd->ioctl_ops = &bcap_ioctl_ops; > + vfd->tvnorms = 0; > + vfd->v4l2_dev = &bcap_dev->v4l2_dev; > + set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); > + strncpy(vfd->name, CAPTURE_DRV_NAME, sizeof(vfd->name)); > + bcap_dev->video_dev = vfd; > + > + ret = v4l2_device_register(&pdev->dev, &bcap_dev->v4l2_dev); > + if (ret) { > + v4l2_err(pdev->dev.driver, > + "Unable to register v4l2 device\n"); > + goto err_release_vdev; > + } > + v4l2_info(&bcap_dev->v4l2_dev, "v4l2 device registered\n"); > + > + spin_lock_init(&bcap_dev->lock); > + /* initialize queue */ > + q = &bcap_dev->buffer_queue; > + memset(q, 0, sizeof(*q)); This is superfluous: bcap_dev is allocated with kzalloc(). Thanks Guennadi --- Guennadi Liakhovetski, Ph.D. Freelance Open-Source Software Developer http://www.open-technology.de/ ^ permalink raw reply [flat|nested] 39+ messages in thread
end of thread, other threads:[~2011-10-01 10:03 UTC | newest] Thread overview: 39+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2011-09-13 18:34 [PATCH 1/4] v4l2: add vb2_get_unmapped_area in vb2 core Scott Jiang 2011-09-13 8:17 ` Guennadi Liakhovetski 2011-09-13 8:36 ` Scott Jiang 2011-09-13 18:34 ` [PATCH 2/4] v4l2: add adv7183 decoder driver Scott Jiang 2011-09-14 3:05 ` [uclinux-dist-devel] " Mike Frysinger 2011-09-13 18:34 ` [PATCH 3/4] v4l2: add vs6624 sensor driver Scott Jiang 2011-09-13 7:42 ` Guennadi Liakhovetski 2011-09-13 8:20 ` Scott Jiang 2011-09-13 8:22 ` Guennadi Liakhovetski 2011-09-14 3:28 ` [uclinux-dist-devel] " Mike Frysinger 2011-09-14 7:28 ` Scott Jiang 2011-09-18 2:52 ` Mike Frysinger 2011-09-13 18:34 ` [PATCH 4/4] v4l2: add blackfin capture bridge driver Scott Jiang 2011-09-13 8:11 ` Guennadi Liakhovetski 2011-09-13 9:56 ` Scott Jiang 2011-09-13 11:15 ` Guennadi Liakhovetski 2011-09-14 6:14 ` Scott Jiang 2011-09-16 8:11 ` Scott Jiang 2011-09-16 8:46 ` Guennadi Liakhovetski 2011-09-15 6:37 ` Scott Jiang 2011-09-15 8:49 ` Sylwester Nawrocki 2011-09-13 21:19 ` Sylwester Nawrocki 2011-09-14 7:10 ` Scott Jiang 2011-09-14 14:30 ` Sylwester Nawrocki 2011-09-15 2:40 ` Scott Jiang 2011-09-15 6:35 ` Guennadi Liakhovetski 2011-09-15 6:48 ` Scott Jiang 2011-09-15 7:14 ` Guennadi Liakhovetski 2011-09-15 7:26 ` Scott Jiang 2011-09-15 7:32 ` Guennadi Liakhovetski 2011-09-15 21:17 ` Sylwester Nawrocki 2011-09-16 2:34 ` Scott Jiang 2011-09-16 6:48 ` Guennadi Liakhovetski 2011-09-26 14:25 ` Hans Verkuil 2011-10-01 10:03 ` Sylwester Nawrocki 2011-09-14 3:19 ` [uclinux-dist-devel] " Mike Frysinger 2011-09-14 7:16 ` Scott Jiang 2011-09-14 7:22 ` Guennadi Liakhovetski 2011-09-17 20:54 ` Guennadi Liakhovetski
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox