genesi/linux-legacy
1
0
Fork 0
mirror of https://github.com/genesi/linux-legacy.git synced 2026-07-08 17:56:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

ENGR00137557 MXC V4L2 overlay:Fix preview issue on DI1 BG fb

Browse Source 
1) Add DISP3 BG-DI1 output support.
2) Remove ADC output support.

Signed-off-by: Liu Ying <b17645@freescale.com>
This commit is contained in:
Liu Ying
2011-01-04 14:21:14 +08:00
committed by Matt Sealey
parent 3ac0117c12
commit 4100e61a89
5 changed files with 43 additions and 664 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
drivers/media/video/mxc/capture/Kconfig
View File

@@ -91,16 +91,6 @@ config MXC_IPU_PRP_VF_SDC
MEM -> IC (ROT) -> MEM
MEM -> SDC (FG/BG)
config MXC_IPU_PRP_VF_ADC
tristate "Pre-Processor VF ADC library"
depends on VIDEO_MXC_IPU_CAMERA && FB_MXC_ASYNC_PANEL
default y
---help---
Use case PRP_VF_ADC:
Preprocessing image from smart sensor for viewfinder and
displaying it on asynchronous display.
CSI -> IC (PRP VF) -> ADC2
config MXC_IPU_PRP_ENC
tristate "Pre-processor Encoder library"
depends on VIDEO_MXC_IPU_CAMERA

1
drivers/media/video/mxc/capture/Makefile
View File

@@ -1,6 +1,5 @@
ifeq ($(CONFIG_VIDEO_MXC_IPU_CAMERA),y)
obj-$(CONFIG_VIDEO_MXC_CAMERA) += mxc_v4l2_capture.o
obj-$(CONFIG_MXC_IPU_PRP_VF_ADC) += ipu_prp_vf_adc.o
obj-$(CONFIG_MXC_IPU_PRP_VF_SDC) += ipu_prp_vf_sdc.o ipu_prp_vf_sdc_bg.o
obj-$(CONFIG_MXC_IPU_PRP_ENC) += ipu_prp_enc.o ipu_still.o
obj-$(CONFIG_MXC_IPU_CSI_ENC) += ipu_csi_enc.o ipu_still.o

4
drivers/media/video/mxc/capture/ipu_prp_sw.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2004-2009 Freescale Semiconductor, Inc. All Rights Reserved.
* Copyright 2004-2011 Freescale Semiconductor, Inc. All Rights Reserved.
*/
/*
@@ -26,10 +26,8 @@ int csi_enc_select(void *private);
int csi_enc_deselect(void *private);
int prp_enc_select(void *private);
int prp_enc_deselect(void *private);
int prp_vf_adc_select(void *private);
int prp_vf_sdc_select(void *private);
int prp_vf_sdc_select_bg(void *private);
int prp_vf_adc_deselect(void *private);
int prp_vf_sdc_deselect(void *private);
int prp_vf_sdc_deselect_bg(void *private);
int prp_still_select(void *private);

601
drivers/media/video/mxc/capture/ipu_prp_vf_adc.c
View File

@@ -1,601 +0,0 @@
/*
* Copyright 2004-2009 Freescale Semiconductor, Inc. All Rights Reserved.
*/
/*
* The code contained herein is licensed under the GNU General Public
* License. You may obtain a copy of the GNU General Public License
* Version 2 or later at the following locations:
*
* http://www.opensource.org/licenses/gpl-license.html
* http://www.gnu.org/copyleft/gpl.html
*/
/*!
* @file ipu_prp_vf_adc.c
*
* @brief IPU Use case for PRP-VF
*
* @ingroup IPU
*/
#include "mxc_v4l2_capture.h"
#include "ipu_prp_sw.h"
#include <mach/mxcfb.h>
#include <mach/ipu.h>
#include <linux/dma-mapping.h>
/*
* Function definitions
*/
/*!
* prpvf_start - start the vf task
*
* @param private cam_data * mxc v4l2 main structure
*
*/
static int prpvf_start(void *private)
{
cam_data *cam = (cam_data *) private;
ipu_channel_params_t vf;
ipu_channel_params_t params;
u32 format = IPU_PIX_FMT_RGB565;
u32 size = 2;
int err = 0;
if (!cam) {
printk(KERN_ERR "prpvf_start private is NULL\n");
return -ENXIO;
}
if (cam->overlay_active == true) {
printk(KERN_ERR "prpvf_start already start.\n");
return 0;
}
mxcfb_set_refresh_mode(cam->overlay_fb, MXCFB_REFRESH_OFF, 0);
memset(&vf, 0, sizeof(ipu_channel_params_t));
ipu_csi_get_window_size(&vf.csi_prp_vf_adc.in_width,
&vf.csi_prp_vf_adc.in_height);
vf.csi_prp_vf_adc.in_pixel_fmt = IPU_PIX_FMT_UYVY;
vf.csi_prp_vf_adc.out_width = cam->win.w.width;
vf.csi_prp_vf_adc.out_height = cam->win.w.height;
vf.csi_prp_vf_adc.graphics_combine_en = 0;
vf.csi_prp_vf_adc.out_left = cam->win.w.left;
/* hope to be removed when those offset taken cared by adc driver. */
#ifdef CONFIG_FB_MXC_EPSON_QVGA_PANEL
vf.csi_prp_vf_adc.out_left += 12;
#endif
#ifdef CONFIG_FB_MXC_EPSON_PANEL
vf.csi_prp_vf_adc.out_left += 2;
#endif
vf.csi_prp_vf_adc.out_top = cam->win.w.top;
if (cam->vf_rotation >= IPU_ROTATE_90_RIGHT) {
vf.csi_prp_vf_adc.out_width = cam->win.w.height;
vf.csi_prp_vf_adc.out_height = cam->win.w.width;
size = cam->win.w.width * cam->win.w.height * size;
vf.csi_prp_vf_adc.out_pixel_fmt = format;
err = ipu_init_channel(CSI_PRP_VF_MEM, &vf);
if (err != 0)
return err;
ipu_csi_enable_mclk_if(CSI_MCLK_VF, cam->csi, true, true);
if (cam->vf_bufs_vaddr[0]) {
dma_free_coherent(0, cam->vf_bufs_size[0],
cam->vf_bufs_vaddr[0],
cam->vf_bufs[0]);
}
if (cam->vf_bufs_vaddr[1]) {
dma_free_coherent(0, cam->vf_bufs_size[1],
cam->vf_bufs_vaddr[1],
cam->vf_bufs[1]);
}
cam->vf_bufs_size[0] = size;
cam->vf_bufs_vaddr[0] = (void *)dma_alloc_coherent(0,
cam->
vf_bufs_size
[0],
&cam->
vf_bufs[0],
GFP_DMA |
GFP_KERNEL);
if (cam->vf_bufs_vaddr[0] == NULL) {
printk(KERN_ERR
"prpvf_start: Error to allocate vf buffer\n");
err = -ENOMEM;
goto out_3;
}
cam->vf_bufs_size[1] = size;
cam->vf_bufs_vaddr[1] = (void *)dma_alloc_coherent(0,
cam->
vf_bufs_size
[1],
&cam->
vf_bufs[1],
GFP_DMA |
GFP_KERNEL);
if (cam->vf_bufs_vaddr[1] == NULL) {
printk(KERN_ERR
"prpvf_start: Error to allocate vf buffer\n");
err = -ENOMEM;
goto out_3;
}
err = ipu_init_channel_buffer(CSI_PRP_VF_MEM, IPU_OUTPUT_BUFFER,
format,
vf.csi_prp_vf_mem.out_width,
vf.csi_prp_vf_mem.out_height,
vf.csi_prp_vf_mem.out_width,
IPU_ROTATE_NONE,
cam->vf_bufs[0], cam->vf_bufs[1],
0, 0);
if (err != 0)
goto out_3;
if (cam->rot_vf_bufs[0]) {
dma_free_coherent(0, cam->rot_vf_buf_size[0],
cam->rot_vf_bufs_vaddr[0],
cam->rot_vf_bufs[0]);
}
if (cam->rot_vf_bufs[1]) {
dma_free_coherent(0, cam->rot_vf_buf_size[1],
cam->rot_vf_bufs_vaddr[1],
cam->rot_vf_bufs[1]);
}
cam->rot_vf_buf_size[0] = PAGE_ALIGN(size);
cam->rot_vf_bufs_vaddr[0] = (void *)dma_alloc_coherent(0,
cam->
rot_vf_buf_size
[0],
&cam->
rot_vf_bufs
[0],
GFP_DMA |
GFP_KERNEL);
if (cam->rot_vf_bufs_vaddr[0] == NULL) {
printk(KERN_ERR
"prpvf_start: Error to allocate rot_vf_bufs\n");
err = -ENOMEM;
goto out_3;
}
cam->rot_vf_buf_size[1] = PAGE_ALIGN(size);
cam->rot_vf_bufs_vaddr[1] = (void *)dma_alloc_coherent(0,
cam->
rot_vf_buf_size
[1],
&cam->
rot_vf_bufs
[1],
GFP_DMA |
GFP_KERNEL);
if (cam->rot_vf_bufs_vaddr[1] == NULL) {
printk(KERN_ERR
"prpvf_start: Error to allocate rot_vf_bufs\n");
err = -ENOMEM;
goto out_3;
}
err = ipu_init_channel(MEM_ROT_VF_MEM, NULL);
if (err != 0) {
printk(KERN_ERR "prpvf_start :Error "
"MEM_ROT_VF_MEM channel\n");
goto out_3;
}
err = ipu_init_channel_buffer(MEM_ROT_VF_MEM, IPU_INPUT_BUFFER,
format,
vf.csi_prp_vf_mem.out_width,
vf.csi_prp_vf_mem.out_height,
vf.csi_prp_vf_mem.out_width,
cam->vf_rotation, cam->vf_bufs[0],
cam->vf_bufs[1], 0, 0);
if (err != 0) {
printk(KERN_ERR "prpvf_start: Error "
"MEM_ROT_VF_MEM input buffer\n");
goto out_2;
}
err = ipu_init_channel_buffer(MEM_ROT_VF_MEM, IPU_OUTPUT_BUFFER,
format,
vf.csi_prp_vf_mem.out_height,
vf.csi_prp_vf_mem.out_width,
vf.csi_prp_vf_mem.out_height,
IPU_ROTATE_NONE,
cam->rot_vf_bufs[0],
cam->rot_vf_bufs[1], 0, 0);
if (err != 0) {
printk(KERN_ERR "prpvf_start: Error "
"MEM_ROT_VF_MEM output buffer\n");
goto out_2;
}
err = ipu_link_channels(CSI_PRP_VF_MEM, MEM_ROT_VF_MEM);
if (err < 0) {
printk(KERN_ERR "prpvf_start: Error "
"linking CSI_PRP_VF_MEM-MEM_ROT_VF_MEM\n");
goto out_2;
}
ipu_disable_channel(ADC_SYS2, false);
ipu_uninit_channel(ADC_SYS2);
params.adc_sys2.disp = DISP0;
params.adc_sys2.ch_mode = WriteTemplateNonSeq;
params.adc_sys2.out_left = cam->win.w.left;
/* going to be removed when those offset taken cared by adc driver. */
#ifdef CONFIG_FB_MXC_EPSON_QVGA_PANEL
params.adc_sys2.out_left += 12;
#endif
#ifdef CONFIG_FB_MXC_EPSON_PANEL
params.adc_sys2.out_left += 2;
#endif
params.adc_sys2.out_top = cam->win.w.top;
err = ipu_init_channel(ADC_SYS2, &params);
if (err != 0) {
printk(KERN_ERR
"prpvf_start: Error initializing ADC SYS1\n");
goto out_2;
}
err = ipu_init_channel_buffer(ADC_SYS2, IPU_INPUT_BUFFER,
format,
vf.csi_prp_vf_mem.out_height,
vf.csi_prp_vf_mem.out_width,
vf.csi_prp_vf_mem.out_height,
IPU_ROTATE_NONE,
cam->rot_vf_bufs[0],
cam->rot_vf_bufs[1], 0, 0);
if (err != 0) {
printk(KERN_ERR "Error initializing ADC SYS1 buffer\n");
goto out_1;
}
err = ipu_link_channels(MEM_ROT_VF_MEM, ADC_SYS2);
if (err < 0) {
printk(KERN_ERR
"Error linking MEM_ROT_VF_MEM-ADC_SYS2\n");
goto out_1;
}
ipu_enable_channel(CSI_PRP_VF_MEM);
ipu_enable_channel(MEM_ROT_VF_MEM);
ipu_enable_channel(ADC_SYS2);
ipu_select_buffer(CSI_PRP_VF_MEM, IPU_OUTPUT_BUFFER, 0);
ipu_select_buffer(CSI_PRP_VF_MEM, IPU_OUTPUT_BUFFER, 1);
ipu_select_buffer(MEM_ROT_VF_MEM, IPU_OUTPUT_BUFFER, 0);
ipu_select_buffer(MEM_ROT_VF_MEM, IPU_OUTPUT_BUFFER, 1);
}
#ifndef CONFIG_MXC_IPU_PRP_VF_SDC
else if (cam->vf_rotation == IPU_ROTATE_NONE) {
vf.csi_prp_vf_adc.out_pixel_fmt = IPU_PIX_FMT_BGR32;
err = ipu_init_channel(CSI_PRP_VF_ADC, &vf);
if (err != 0) {
printk(KERN_ERR "prpvf_start: Error "
"initializing CSI_PRP_VF_ADC\n");
return err;
}
ipu_csi_enable_mclk_if(CSI_MCLK_VF, cam->csi, true, true);
err = ipu_init_channel_buffer(CSI_PRP_VF_ADC, IPU_OUTPUT_BUFFER,
format, cam->win.w.width,
cam->win.w.height,
cam->win.w.width, IPU_ROTATE_NONE,
0, 0, 0, 0);
if (err != 0) {
printk(KERN_ERR "prpvf_start: Error "
"initializing CSI_PRP_VF_MEM\n");
return err;
}
ipu_enable_channel(CSI_PRP_VF_ADC);
}
#endif
else {
size = cam->win.w.width * cam->win.w.height * size;
vf.csi_prp_vf_adc.out_pixel_fmt = format;
err = ipu_init_channel(CSI_PRP_VF_MEM, &vf);
if (err != 0) {
printk(KERN_ERR "prpvf_start: Error "
"initializing CSI_PRP_VF_MEM\n");
return err;
}
ipu_csi_enable_mclk_if(CSI_MCLK_VF, cam->csi, true, true);
if (cam->vf_bufs[0]) {
dma_free_coherent(0, cam->vf_bufs_size[0],
cam->vf_bufs_vaddr[0],
cam->vf_bufs[0]);
}
if (cam->vf_bufs[1]) {
dma_free_coherent(0, cam->vf_bufs_size[1],
cam->vf_bufs_vaddr[1],
cam->vf_bufs[1]);
}
cam->vf_bufs_size[0] = PAGE_ALIGN(size);
cam->vf_bufs_vaddr[0] = (void *)dma_alloc_coherent(0,
cam->
vf_bufs_size
[0],
&cam->
vf_bufs[0],
GFP_DMA |
GFP_KERNEL);
if (cam->vf_bufs_vaddr[0] == NULL) {
printk(KERN_ERR
"prpvf_start: Error to allocate vf_bufs\n");
err = -ENOMEM;
goto out_3;
}
cam->vf_bufs_size[1] = PAGE_ALIGN(size);
cam->vf_bufs_vaddr[1] = (void *)dma_alloc_coherent(0,
cam->
vf_bufs_size
[1],
&cam->
vf_bufs[1],
GFP_DMA |
GFP_KERNEL);
if (cam->vf_bufs_vaddr[1] == NULL) {
printk(KERN_ERR
"prpvf_start: Error to allocate vf_bufs\n");
err = -ENOMEM;
goto out_3;
}
err = ipu_init_channel_buffer(CSI_PRP_VF_MEM, IPU_OUTPUT_BUFFER,
format,
vf.csi_prp_vf_mem.out_width,
vf.csi_prp_vf_mem.out_height,
vf.csi_prp_vf_mem.out_width,
cam->vf_rotation,
cam->vf_bufs[0], cam->vf_bufs[1],
0, 0);
if (err != 0) {
printk(KERN_ERR "prpvf_start: Error "
"initializing CSI_PRP_VF_MEM\n");
goto out_3;
}
ipu_disable_channel(ADC_SYS2, false);
ipu_uninit_channel(ADC_SYS2);
params.adc_sys2.disp = DISP0;
params.adc_sys2.ch_mode = WriteTemplateNonSeq;
params.adc_sys2.out_left = cam->win.w.left;
// going to be removed when those offset taken cared by adc driver.
#ifdef CONFIG_FB_MXC_EPSON_QVGA_PANEL
params.adc_sys2.out_left += 12;
#endif
#ifdef CONFIG_FB_MXC_EPSON_PANEL
params.adc_sys2.out_left += 2;
#endif
params.adc_sys2.out_top = cam->win.w.top;
err = ipu_init_channel(ADC_SYS2, &params);
if (err != 0) {
printk(KERN_ERR "prpvf_start: Error "
"initializing ADC_SYS2\n");
goto out_3;
}
err = ipu_init_channel_buffer(ADC_SYS2, IPU_INPUT_BUFFER,
format,
vf.csi_prp_vf_mem.out_width,
vf.csi_prp_vf_mem.out_height,
vf.csi_prp_vf_mem.out_width,
IPU_ROTATE_NONE, cam->vf_bufs[0],
cam->vf_bufs[1], 0, 0);
if (err != 0) {
printk(KERN_ERR "prpvf_start: Error "
"initializing ADC SYS1 buffer\n");
goto out_1;
}
err = ipu_link_channels(CSI_PRP_VF_MEM, ADC_SYS2);
if (err < 0) {
printk(KERN_ERR "prpvf_start: Error "
"linking MEM_ROT_VF_MEM-ADC_SYS2\n");
goto out_1;
}
ipu_enable_channel(CSI_PRP_VF_MEM);
ipu_enable_channel(ADC_SYS2);
ipu_select_buffer(CSI_PRP_VF_MEM, IPU_OUTPUT_BUFFER, 0);
ipu_select_buffer(CSI_PRP_VF_MEM, IPU_OUTPUT_BUFFER, 1);
}
cam->overlay_active = true;
return err;
out_1:
ipu_uninit_channel(ADC_SYS2);
out_2:
if (cam->vf_rotation >= IPU_ROTATE_90_RIGHT) {
ipu_uninit_channel(MEM_ROT_VF_MEM);
}
out_3:
ipu_uninit_channel(CSI_PRP_VF_MEM);
if (cam->rot_vf_bufs_vaddr[0]) {
dma_free_coherent(0, cam->rot_vf_buf_size[0],
cam->rot_vf_bufs_vaddr[0],
cam->rot_vf_bufs[0]);
cam->rot_vf_bufs_vaddr[0] = NULL;
cam->rot_vf_bufs[0] = 0;
}
if (cam->rot_vf_bufs_vaddr[1]) {
dma_free_coherent(0, cam->rot_vf_buf_size[1],
cam->rot_vf_bufs_vaddr[1],
cam->rot_vf_bufs[1]);
cam->rot_vf_bufs_vaddr[1] = NULL;
cam->rot_vf_bufs[1] = 0;
}
if (cam->vf_bufs_vaddr[0]) {
dma_free_coherent(0, cam->vf_bufs_size[0],
cam->vf_bufs_vaddr[0], cam->vf_bufs[0]);
cam->vf_bufs_vaddr[0] = NULL;
cam->vf_bufs[0] = 0;
}
if (cam->vf_bufs_vaddr[1]) {
dma_free_coherent(0, cam->vf_bufs_size[1],
cam->vf_bufs_vaddr[1], cam->vf_bufs[1]);
cam->vf_bufs_vaddr[1] = NULL;
cam->vf_bufs[1] = 0;
}
return err;
}
/*!
* prpvf_stop - stop the vf task
*
* @param private cam_data * mxc v4l2 main structure
*
*/
static int prpvf_stop(void *private)
{
cam_data *cam = (cam_data *) private;
int err = 0;
if (cam->overlay_active == false)
return 0;
if (cam->vf_rotation >= IPU_ROTATE_90_RIGHT) {
ipu_unlink_channels(CSI_PRP_VF_MEM, MEM_ROT_VF_MEM);
ipu_unlink_channels(MEM_ROT_VF_MEM, ADC_SYS2);
ipu_disable_channel(CSI_PRP_VF_MEM, true);
ipu_disable_channel(MEM_ROT_VF_MEM, true);
ipu_disable_channel(ADC_SYS2, true);
ipu_uninit_channel(CSI_PRP_VF_MEM);
ipu_uninit_channel(MEM_ROT_VF_MEM);
ipu_uninit_channel(ADC_SYS2);
ipu_csi_enable_mclk_if(CSI_MCLK_VF, cam->csi, false, false);
}
#ifndef CONFIG_MXC_IPU_PRP_VF_SDC
else if (cam->vf_rotation == IPU_ROTATE_NONE) {
ipu_disable_channel(CSI_PRP_VF_ADC, false);
ipu_uninit_channel(CSI_PRP_VF_ADC);
ipu_csi_enable_mclk_if(CSI_MCLK_VF, cam->csi, false, false);
}
#endif
else {
ipu_unlink_channels(CSI_PRP_VF_MEM, ADC_SYS2);
ipu_disable_channel(CSI_PRP_VF_MEM, true);
ipu_disable_channel(ADC_SYS2, true);
ipu_uninit_channel(CSI_PRP_VF_MEM);
ipu_uninit_channel(ADC_SYS2);
ipu_csi_enable_mclk_if(CSI_MCLK_VF, cam->csi, false, false);
}
if (cam->vf_bufs_vaddr[0]) {
dma_free_coherent(0, cam->vf_bufs_size[0],
cam->vf_bufs_vaddr[0], cam->vf_bufs[0]);
cam->vf_bufs_vaddr[0] = NULL;
cam->vf_bufs[0] = 0;
}
if (cam->vf_bufs_vaddr[1]) {
dma_free_coherent(0, cam->vf_bufs_size[1],
cam->vf_bufs_vaddr[1], cam->vf_bufs[1]);
cam->vf_bufs_vaddr[1] = NULL;
cam->vf_bufs[1] = 0;
}
if (cam->rot_vf_bufs_vaddr[0]) {
dma_free_coherent(0, cam->rot_vf_buf_size[0],
cam->rot_vf_bufs_vaddr[0],
cam->rot_vf_bufs[0]);
cam->rot_vf_bufs_vaddr[0] = NULL;
cam->rot_vf_bufs[0] = 0;
}
if (cam->rot_vf_bufs_vaddr[1]) {
dma_free_coherent(0, cam->rot_vf_buf_size[1],
cam->rot_vf_bufs_vaddr[1],
cam->rot_vf_bufs[1]);
cam->rot_vf_bufs_vaddr[1] = NULL;
cam->rot_vf_bufs[1] = 0;
}
cam->overlay_active = false;
mxcfb_set_refresh_mode(cam->overlay_fb, MXCFB_REFRESH_PARTIAL, 0);
return err;
}
/*!
* function to select PRP-VF as the working path
*
* @param private cam_data * mxc v4l2 main structure
*
* @return status
*/
int prp_vf_adc_select(void *private)
{
cam_data *cam;
if (private) {
cam = (cam_data *) private;
cam->vf_start_adc = prpvf_start;
cam->vf_stop_adc = prpvf_stop;
cam->overlay_active = false;
} else {
return -EIO;
}
return 0;
}
/*!
* function to de-select PRP-VF as the working path
*
* @param private cam_data * mxc v4l2 main structure
*
* @return status
*/
int prp_vf_adc_deselect(void *private)
{
cam_data *cam;
int err = 0;
err = prpvf_stop(private);
if (private) {
cam = (cam_data *) private;
cam->vf_start_adc = NULL;
cam->vf_stop_adc = NULL;
}
return err;
}
/*!
* Init viewfinder task.
*
* @return Error code indicating success or failure
*/
__init int prp_vf_adc_init(void)
{
return 0;
}
/*!
* Deinit viewfinder task.
*
* @return Error code indicating success or failure
*/
void __exit prp_vf_adc_exit(void)
{
}
module_init(prp_vf_adc_init);
module_exit(prp_vf_adc_exit);
EXPORT_SYMBOL(prp_vf_adc_select);
EXPORT_SYMBOL(prp_vf_adc_deselect);
MODULE_AUTHOR("Freescale Semiconductor, Inc.");
MODULE_DESCRIPTION("IPU PRP VF ADC Driver");
MODULE_LICENSE("GPL");

91
drivers/media/video/mxc/capture/mxc_v4l2_capture.c
View File

@@ -55,7 +55,7 @@ static struct v4l2_output mxc_capture_outputs[MXC_V4L2_CAPTURE_NUM_OUTPUTS] = {
},
{
.index = 1,
.name = "DISP0",
.name = "DISP3 BG - DI1",
.type = V4L2_OUTPUT_TYPE_ANALOG,
.audioset = 0,
.modulator = 0,
@@ -441,23 +441,42 @@ static int verify_preview(cam_data *cam, struct v4l2_window *win)
{
int i = 0, width_bound = 0, height_bound = 0;
int *width, *height;
struct fb_info *bg_fbi = NULL;
unsigned int ipu_ch = CHAN_NONE;
struct fb_info *bg_fbi = NULL, *fbi = NULL;
bool foregound_fb;
mm_segment_t old_fs;
pr_debug("In MVC: verify_preview\n");
do {
cam->overlay_fb = (struct fb_info *)registered_fb[i];
if (cam->overlay_fb == NULL) {
fbi = (struct fb_info *)registered_fb[i];
if (fbi == NULL) {
pr_err("ERROR: verify_preview frame buffer NULL.\n");
return -1;
}
if (strcmp(cam->overlay_fb->fix.id, "DISP3 BG") == 0)
bg_fbi = cam->overlay_fb;
if (strcmp(cam->overlay_fb->fix.id,
/* Which DI supports 2 layers? */
if (strncmp(fbi->fix.id, "DISP3 BG", 8) == 0) {
if (fbi->fbops->fb_ioctl) {
old_fs = get_fs();
set_fs(KERNEL_DS);
fbi->fbops->fb_ioctl(fbi, MXCFB_GET_FB_IPU_CHAN,
(unsigned long)&ipu_ch);
set_fs(old_fs);
}
if (ipu_ch == MEM_BG_SYNC) {
bg_fbi = fbi;
pr_debug("Found background frame buffer.\n");
}
}
/* Found the frame buffer to preview on. */
if (strcmp(fbi->fix.id,
mxc_capture_outputs[cam->output].name) == 0) {
if (strcmp(cam->overlay_fb->fix.id, "DISP3 FG") == 0)
if (strcmp(fbi->fix.id, "DISP3 FG") == 0)
foregound_fb = true;
cam->overlay_fb = fbi;
break;
}
} while (++i < FB_MAX);
@@ -548,35 +567,19 @@ static int start_preview(cam_data *cam)
pr_debug("MVC: start_preview\n");
#if defined(CONFIG_MXC_IPU_PRP_VF_SDC) || defined(CONFIG_MXC_IPU_PRP_VF_SDC_MODULE)
pr_debug(" This is an SDC display\n");
if (cam->output == 0 || cam->output == 2) {
if (cam->v4l2_fb.flags == V4L2_FBUF_FLAG_OVERLAY)
err = prp_vf_sdc_select(cam);
else if (cam->v4l2_fb.flags == V4L2_FBUF_FLAG_PRIMARY)
err = prp_vf_sdc_select_bg(cam);
if (err != 0)
return err;
if (cam->v4l2_fb.flags == V4L2_FBUF_FLAG_OVERLAY)
err = prp_vf_sdc_select(cam);
else if (cam->v4l2_fb.flags == V4L2_FBUF_FLAG_PRIMARY)
err = prp_vf_sdc_select_bg(cam);
if (err != 0)
return err;
err = cam->vf_start_sdc(cam);
if (err != 0)
return err;
err = cam->vf_start_sdc(cam);
if (err != 0)
return err;
if (cam->vf_enable_csi)
err = cam->vf_enable_csi(cam);
}
#endif
#if defined(CONFIG_MXC_IPU_PRP_VF_ADC) || defined(CONFIG_MXC_IPU_PRP_VF_ADC_MODULE)
pr_debug(" This is an ADC display\n");
if (cam->output == 1) {
err = prp_vf_adc_select(cam);
if (err != 0)
return err;
err = cam->vf_start_adc(cam);
}
#endif
if (cam->vf_enable_csi)
err = cam->vf_enable_csi(cam);
pr_debug("End of %s: v2f pix widthxheight %d x %d\n",
__func__,
@@ -607,26 +610,16 @@ static int stop_preview(cam_data *cam)
pr_debug("MVC: stop preview\n");
#if defined(CONFIG_MXC_IPU_PRP_VF_ADC) || defined(CONFIG_MXC_IPU_PRP_VF_ADC_MODULE)
if (cam->output == 1) {
err = prp_vf_adc_deselect(cam);
}
#endif
#if defined(CONFIG_MXC_IPU_PRP_VF_SDC) || defined(CONFIG_MXC_IPU_PRP_VF_SDC_MODULE)
if (cam->vf_disable_csi) {
err = cam->vf_disable_csi(cam);
if (err != 0)
return err;
}
if (cam->output == 0 || cam->output == 2) {
if (cam->v4l2_fb.flags == V4L2_FBUF_FLAG_OVERLAY)
err = prp_vf_sdc_deselect(cam);
else if (cam->v4l2_fb.flags == V4L2_FBUF_FLAG_PRIMARY)
err = prp_vf_sdc_deselect_bg(cam);
}
#endif
if (cam->v4l2_fb.flags == V4L2_FBUF_FLAG_OVERLAY)
err = prp_vf_sdc_deselect(cam);
else if (cam->v4l2_fb.flags == V4L2_FBUF_FLAG_PRIMARY)
err = prp_vf_sdc_deselect_bg(cam);
return err;
}