diff options
Diffstat (limited to 'drivers/media/sprd_dcam/common/dcam_img.c')
| -rwxr-xr-x | drivers/media/sprd_dcam/common/dcam_img.c | 3779 |
1 files changed, 3779 insertions, 0 deletions
diff --git a/drivers/media/sprd_dcam/common/dcam_img.c b/drivers/media/sprd_dcam/common/dcam_img.c new file mode 100755 index 00000000..5ca10bd1 --- /dev/null +++ b/drivers/media/sprd_dcam/common/dcam_img.c @@ -0,0 +1,3779 @@ +/* + * Copyright (C) 2012 Spreadtrum Communications Inc. + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * 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. + */ +#include <linux/module.h> +#include <linux/delay.h> +#include <linux/errno.h> +#include <linux/fs.h> +#include <linux/kernel.h> +#include <linux/mm.h> +#include <linux/ioport.h> +#include <linux/init.h> +#include <linux/sched.h> +#include <linux/version.h> +#include <linux/mutex.h> +#include <linux/interrupt.h> +#include <linux/kthread.h> +#include <linux/highmem.h> +#include <linux/freezer.h> +#include <linux/platform_device.h> +#include <linux/miscdevice.h> +#ifndef CONFIG_64BIT +#include <soc/sprd/board.h> +#include <soc/sprd/hardware.h> +#include <soc/sprd/adi.h> +#endif +#include <linux/module.h> +#include <linux/slab.h> +#include <linux/proc_fs.h> +#include <linux/of.h> +#include <linux/of_device.h> + +#include <linux/vmalloc.h> +#include "dcam_drv.h" + +#include <asm/io.h> + + +#include <../flash/flash.h> +#include <video/sprd_img.h> + +#include "../../sprd_sensor/csi2/csi_api.h" + +//#define LOCAL static +#define LOCAL + +#define IMG_DEVICE_NAME "sprd_image" +#define IMAGE_MINOR MISC_DYNAMIC_MINOR +#define DCAM_INVALID_FOURCC 0xFFFFFFFF +#define DCAM_MAJOR_VERSION 1 +#define DCAM_MINOR_VERSION 0 +#define DCAM_RELEASE 0 +#define DCAM_QUEUE_LENGTH 16 +#define DCAM_TIMING_LEN 16 +#if CONFIG_SC_FPGA +#define DCAM_TIMEOUT (2000*100) +#else +#define DCAM_TIMEOUT 2000 +#endif + +#define DCAM_ZOOM_LEVEL_MAX 4 +#define DCAM_ZOOM_STEP(x, y) (((x) - (y)) / DCAM_ZOOM_LEVEL_MAX) +#define DCAM_PIXEL_ALIGNED 4 +#define DCAM_WIDTH(w) ((w)& ~(DCAM_PIXEL_ALIGNED - 1)) +#define DCAM_HEIGHT(h) ((h)& ~(DCAM_PIXEL_ALIGNED - 1)) + +#define DEBUG_STR "Error L %d, %s: \n" +#define DEBUG_ARGS __LINE__,__FUNCTION__ +#define IMG_RTN_IF_ERR(n) \ + do { \ + if(unlikely(n)) { \ + printk(DEBUG_STR,DEBUG_ARGS); \ + goto exit; \ + } \ + } while(0) + +#define IMG_PRINT_IF_ERR(n) \ + do { \ + if(unlikely(n)) { \ + printk(DEBUG_STR,DEBUG_ARGS); \ + } \ + } while(0) + +#define DCAM_VERSION \ + KERNEL_VERSION(DCAM_MAJOR_VERSION, DCAM_MINOR_VERSION, DCAM_RELEASE) + +typedef int (*path_cfg_func)(enum dcam_cfg_id, void *); + +enum +{ + PATH_IDLE = 0x00, + PATH_RUN, +}; + +struct dcam_format { + char *name; + uint32_t fourcc; + int depth; +}; + +struct dcam_node { + uint32_t irq_flag; + uint32_t f_type; + uint32_t index; + uint32_t height; + uint32_t yaddr; + uint32_t uaddr; + uint32_t vaddr; + uint32_t yaddr_vir; + uint32_t uaddr_vir; + uint32_t vaddr_vir; + uint32_t invalid_flag; + struct timeval time; + uint32_t reserved; +}; + +struct dcam_queue { + struct dcam_node node[DCAM_QUEUE_LENGTH]; + struct dcam_node *write; + struct dcam_node *read; + uint32_t wcnt; + uint32_t rcnt; +}; + +struct dcam_img_buf_addr { + struct dcam_addr frm_addr; + struct dcam_addr frm_addr_vir; +}; + +struct dcam_img_buf_queue { + struct dcam_img_buf_addr buf_addr[DCAM_FRM_CNT_MAX]; + struct dcam_img_buf_addr *write; + struct dcam_img_buf_addr *read; + uint32_t wcnt; + uint32_t rcnt; +}; + +struct dcam_path_spec { + uint32_t is_work; + uint32_t is_from_isp; + uint32_t rot_mode; + uint32_t status; + struct dcam_size in_size; + struct dcam_path_dec img_deci; + struct dcam_rect in_rect; + struct dcam_rect in_rect_current; + struct dcam_rect in_rect_backup; + struct dcam_size out_size; + enum dcam_fmt out_fmt; + struct dcam_endian_sel end_sel; + uint32_t fourcc; + uint32_t pixel_depth; + uint32_t frm_id_base; + uint32_t frm_type; + uint32_t index[DCAM_FRM_CNT_MAX]; + //struct dcam_addr frm_addr[DCAM_FRM_CNT_MAX]; + //struct dcam_addr frm_addr_vir[DCAM_FRM_CNT_MAX]; + struct dcam_img_buf_queue buf_queue; + struct dcam_addr frm_reserved_addr; + struct dcam_addr frm_reserved_addr_vir; + struct dcam_frame *frm_ptr[DCAM_FRM_CNT_MAX]; + uint32_t frm_cnt_act; + uint32_t path_frm_deci; + uint32_t shrink; +}; + +struct dcam_info { + uint32_t if_mode; + uint32_t sn_mode; + uint32_t yuv_ptn; + uint32_t data_bits; + uint32_t is_loose; + uint32_t lane_num; + uint32_t pclk; + struct dcam_cap_sync_pol sync_pol; + uint32_t frm_deci; + struct dcam_cap_dec img_deci; + struct dcam_size cap_in_size; + struct dcam_rect cap_in_rect; + struct dcam_size cap_out_size; + struct dcam_size dst_size; + uint32_t pxl_fmt; + uint32_t need_isp_tool; + uint32_t need_isp; + uint32_t need_shrink; + struct dcam_rect path_input_rect; + + struct dcam_path_spec dcam_path[DCAM_PATH_NUM]; + + uint32_t capture_mode; + uint32_t skip_number; + uint32_t flash_status; + uint32_t after_af; + uint32_t is_smooth_zoom; + struct timeval timestamp; +}; + +struct dcam_dev { + struct mutex dcam_mutex; + struct semaphore irq_sem; + atomic_t users; + struct dcam_info dcam_cxt; + atomic_t stream_on; + uint32_t stream_mode; + struct dcam_queue queue; + struct timer_list dcam_timer; + atomic_t run_flag; + uint32_t got_resizer; + struct proc_dir_entry* proc_file; + struct semaphore flash_thread_sem; + struct task_struct* flash_thread; + uint32_t is_flash_thread_stop; + uint32_t frame_skipped; + struct semaphore zoom_thread_sem; + struct task_struct* zoom_thread; + uint32_t is_zoom_thread_stop; + uint32_t zoom_level; + uint32_t channel_id; + void *driver_data; +}; + +#ifndef __SIMULATOR__ +LOCAL int sprd_img_tx_done(struct dcam_frame *frame, void* param); +LOCAL int sprd_img_tx_error(struct dcam_frame *frame, void* param); +LOCAL int sprd_img_no_mem(struct dcam_frame *frame, void* param); +LOCAL int sprd_img_queue_write(struct dcam_queue *queue, struct dcam_node *node); +LOCAL int sprd_img_queue_read(struct dcam_queue *queue, struct dcam_node *node); +LOCAL int sprd_img_queue_disable(struct dcam_queue *queue, uint32_t channel_id); +LOCAL int sprd_img_queue_enable(struct dcam_queue *queue, uint32_t channel_id); +LOCAL int sprd_img_buf_queue_init(struct dcam_img_buf_queue *queue); +LOCAL int sprd_img_queue_init(struct dcam_queue *queue); +LOCAL int sprd_img_buf_queue_write(struct dcam_img_buf_queue *queue, struct dcam_img_buf_addr *buf_addr); +LOCAL int sprd_img_buf_queue_read(struct dcam_img_buf_queue *queue, struct dcam_img_buf_addr *buf_addr); +LOCAL int sprd_start_timer(struct timer_list *dcam_timer, uint32_t time_val); +LOCAL int sprd_stop_timer(struct timer_list *dcam_timer); +LOCAL int sprd_img_streampause(struct file *file, uint32_t channel_id, uint32_t reconfig_flag); +LOCAL int sprd_img_streamresume(struct file *file, uint32_t channel_id); +LOCAL int sprd_img_reg_isr(struct dcam_dev* param); +LOCAL int sprd_img_reg_path2_isr(struct dcam_dev* param); +LOCAL int sprd_img_unreg_isr(struct dcam_dev* param); +LOCAL int sprd_img_unreg_path2_isr(struct dcam_dev* param); +/*LOCAL int sprd_img_proc_read(char *page, char **start,off_t off, int count, int *eof, void *data);*/ +LOCAL void sprd_img_print_reg(void); +LOCAL int sprd_img_start_zoom(struct dcam_frame *frame, void* param); +LOCAL int sprd_img_path_cfg_output_addr(path_cfg_func path_cfg, struct dcam_path_spec* path_spec); + +LOCAL struct dcam_format dcam_img_fmt[] = { + { + .name = "4:2:2, packed, YUYV", + .fourcc = IMG_PIX_FMT_YUYV, + .depth = 16, + }, + { + .name = "4:2:2, packed, YVYU", + .fourcc = IMG_PIX_FMT_YVYU, + .depth = 16, + }, + { + .name = "4:2:2, packed, UYVY", + .fourcc = IMG_PIX_FMT_UYVY, + .depth = 16, + }, + { + .name = "4:2:2, packed, VYUY", + .fourcc = IMG_PIX_FMT_VYUY, + .depth = 16, + }, + { + .name = "YUV 4:2:2, planar, (Y-Cb-Cr)", + .fourcc = IMG_PIX_FMT_YUV422P, + .depth = 16, + }, + { + .name = "YUV 4:2:0 planar (Y-CbCr)", + .fourcc = IMG_PIX_FMT_NV12, + .depth = 12, + }, + { + .name = "YVU 4:2:0 planar (Y-CrCb)", + .fourcc = IMG_PIX_FMT_NV21, + .depth = 12, + }, + + { + .name = "YUV 4:2:0 planar (Y-Cb-Cr)", + .fourcc = IMG_PIX_FMT_YUV420, + .depth = 12, + }, + { + .name = "YVU 4:2:0 planar (Y-Cr-Cb)", + .fourcc = IMG_PIX_FMT_YVU420, + .depth = 12, + }, + { + .name = "RGB565 (LE)", + .fourcc = IMG_PIX_FMT_RGB565, + .depth = 16, + }, + { + .name = "RGB565 (BE)", + .fourcc = IMG_PIX_FMT_RGB565X, + .depth = 16, + }, + { + .name = "RawRGB", + .fourcc = IMG_PIX_FMT_GREY, + .depth = 8, + }, + { + .name = "JPEG", + .fourcc = IMG_PIX_FMT_JPEG, + .depth = 8, + }, +}; +#else +LOCAL struct dcam_format dcam_img_fmt[] = { + {"4:2:2, packed, YUYV", IMG_PIX_FMT_YUYV, 16}, + {"4:2:2, packed, YVYU", IMG_PIX_FMT_YVYU, 16}, + {"4:2:2, packed, UYVY", IMG_PIX_FMT_UYVY, 16}, + {"4:2:2, packed, VYUY", IMG_PIX_FMT_VYUY, 16}, + {"YUV 4:2:2, planar, (Y-Cb-Cr)", IMG_PIX_FMT_YUV422P, 16}, + {"YUV 4:2:0 planar (Y-CbCr)", IMG_PIX_FMT_NV12, 12}, + {"YVU 4:2:0 planar (Y-CrCb)", IMG_PIX_FMT_NV21, 12}, + {"YUV 4:2:0 planar (Y-Cb-Cr)", IMG_PIX_FMT_YUV420, 12}, + {"YVU 4:2:0 planar (Y-Cr-Cb)", IMG_PIX_FMT_YVU420, 12}, + {"RGB565 (LE)", IMG_PIX_FMT_RGB565, 16}, + {"RGB565 (BE)", IMG_PIX_FMT_RGB565X, 16}, + {"RawRGB", IMG_PIX_FMT_GREY, 8}, + {"JPEG", IMG_PIX_FMT_JPEG, 8} +}; +#endif + +enum cmr_flash_status { + FLASH_CLOSE = 0x0, + FLASH_OPEN = 0x1, + FLASH_TORCH = 0x2, /*user only set flash to close/open/torch state */ + FLASH_AUTO = 0x3, + FLASH_CLOSE_AFTER_OPEN = 0x10, /* following is set to sensor */ + FLASH_HIGH_LIGHT = 0x11, + FLASH_OPEN_ON_RECORDING = 0x22, + FLASH_CLOSE_AFTER_AUTOFOCUS = 0x30, + FLASH_STATUS_MAX +}; + +#define DISCARD_FRAME_TIME (10000) + +LOCAL int img_get_timestamp(struct timeval *tv) +{ + struct timespec ts; + + ktime_get_ts(&ts); + tv->tv_sec = ts.tv_sec; + tv->tv_usec = ts.tv_nsec / NSEC_PER_USEC; + return 0; +} + +LOCAL int sprd_img_setflash(uint32_t flash_mode) +{ + + switch (flash_mode) { + case FLASH_OPEN: /*flash on */ + case FLASH_TORCH: /*for torch */ + /*low light */ + sprd_flash_on(); + break; + case FLASH_HIGH_LIGHT: + /*high light */ + sprd_flash_high_light(); + break; + case FLASH_CLOSE_AFTER_OPEN: /*close flash */ + case FLASH_CLOSE_AFTER_AUTOFOCUS: + case FLASH_CLOSE: + /*close the light */ + sprd_flash_close(); + break; + default: + printk("sprd_img_setflash unknow mode:flash_mode 0x%x \n", flash_mode); + break; + } + + DCAM_TRACE("sprd_img_setflash: flash_mode 0x%x \n", flash_mode); + + return 0; +} + +LOCAL int sprd_img_opt_flash(struct dcam_frame *frame, void* param) +{ + struct dcam_dev *dev = (struct dcam_dev*)param; + struct dcam_info *info = NULL; + + if (dev == NULL) { + DCAM_TRACE("SPRD_IMG: sprd_img_opt_flash, dev is NULL \n"); + return 0; + } + + info = &dev->dcam_cxt; + if (info->flash_status < FLASH_STATUS_MAX) { + DCAM_TRACE("SPRD_IMG: sprd_img_opt_flash, status %d \n", info->flash_status); + if(info->flash_status == FLASH_CLOSE_AFTER_AUTOFOCUS) { + img_get_timestamp(&info->timestamp); + info->after_af = 1; + DCAM_TRACE("SPRD_IMG: sprd_img_opt_flash, time, %d %d \n", + (int)info->timestamp.tv_sec, (int)info->timestamp.tv_usec); + } + sprd_img_setflash(info->flash_status); + info->flash_status = FLASH_STATUS_MAX; + } + + return 0; +} + +LOCAL int sprd_img_start_flash(struct dcam_frame *frame, void* param) +{ + struct dcam_dev *dev = (struct dcam_dev*)param; + struct dcam_info *info = NULL; + uint32_t need_light = 1; + + if (dev == NULL) { + DCAM_TRACE("SPRD_IMG: sprd_img_start_flash, dev is NULL \n"); + return -1; + } + + info = &dev->dcam_cxt; + if (info->flash_status < FLASH_STATUS_MAX) { + if (FLASH_HIGH_LIGHT == info->flash_status) { + dev->frame_skipped ++; + if (dev->frame_skipped >= info->skip_number) { + //flash lighted at the last SOF before the right capture frame + DCAM_TRACE("V4L2: waiting finished \n"); + } else { + need_light = 0; + DCAM_TRACE("V4L2: wait for the next SOF, %d ,%d \n", + dev->frame_skipped, info->skip_number); + } + } + if (need_light) { + up(&dev->flash_thread_sem); + } + } + + return 0; +} + +int flash_thread_loop(void *arg) +{ + struct dcam_dev *dev = (struct dcam_dev*)arg; + + if (dev == NULL) { + DCAM_TRACE("SPRD_IMG: flash_thread_loop, dev is NULL \n"); + return -1; + } + while (1) { + if (0 == down_interruptible(&dev->flash_thread_sem)) { + if (dev->is_flash_thread_stop) { + sprd_img_setflash(0); + DCAM_TRACE("SPRD_IMG: flash_thread_loop stop \n"); + break; + } + sprd_img_opt_flash(NULL, arg); + } else { + DCAM_TRACE("SPRD_IMG: flash int!"); + break; + } + } + dev->is_flash_thread_stop = 0; + + return 0; +} + +int dcam_create_flash_thread(void* param) +{ + struct dcam_dev *dev = (struct dcam_dev*)param; + + if (dev == NULL) { + DCAM_TRACE("SPRD_IMG: dcam_create_flash_thread, dev is NULL \n"); + return -1; + } + dev->is_flash_thread_stop = 0; + sema_init(&dev->flash_thread_sem, 0); + dev->flash_thread = kthread_run(flash_thread_loop, param, "dcam_flash_thread"); + if (IS_ERR(dev->flash_thread)) { + printk("SPRD_IMG: dcam_create_flash_thread error!\n"); + return -1; + } + return 0; +} + +int dcam_stop_flash_thread(void* param) +{ + struct dcam_dev *dev = (struct dcam_dev*)param; + int cnt = 0; + + if (dev == NULL) { + DCAM_TRACE("SPRD_IMG: sprd_img_opt_flash, dev is NULL \n"); + return -1; + } + if (dev->flash_thread) { + dev->is_flash_thread_stop = 1; + up(&dev->flash_thread_sem); + if (0 != dev->is_flash_thread_stop) { + while (cnt < 500) { + cnt++; + if (0 == dev->is_flash_thread_stop) + break; + msleep(1); + } + } + dev->flash_thread = NULL; + } + + return 0; +} + +LOCAL int sprd_img_discard_frame(struct dcam_frame *frame, void* param) +{ + int ret = DCAM_RTN_PARA_ERR; + struct dcam_dev *dev = (struct dcam_dev*)param; + struct dcam_info *info = NULL; + struct timeval timestamp; + uint32_t flag = 0; + + info = &dev->dcam_cxt; + img_get_timestamp(×tamp); + DCAM_TRACE("SPRD_IMG: sprd_img_discard_frame, time, %d %d \n", + (int)timestamp.tv_sec, (int)timestamp.tv_usec); + if ((timestamp.tv_sec == info->timestamp.tv_sec) + && (timestamp.tv_usec -info->timestamp.tv_usec >= DISCARD_FRAME_TIME)){ + flag = 1; + } else if (timestamp.tv_sec > info->timestamp.tv_sec) { + if ((1000000 -info->timestamp.tv_sec) + timestamp.tv_sec >= DISCARD_FRAME_TIME) { + flag = 1; + } + } + + if (flag) { + DCAM_TRACE("SPRD_IMG: sprd_img_discard_frame,unlock frame %p \n", frame); + //dcam_frame_unlock(frame); + ret = DCAM_RTN_SUCCESS; + } + return ret; +} + +LOCAL struct dcam_format *sprd_img_get_format(uint32_t fourcc) +{ + struct dcam_format *fmt; + uint32_t i; + + for (i = 0; i < ARRAY_SIZE(dcam_img_fmt); i++) { + fmt = &dcam_img_fmt[i]; + if (fmt->fourcc == fourcc) + break; + } + + if (unlikely(i == ARRAY_SIZE(dcam_img_fmt))) + return NULL; + + return &dcam_img_fmt[i]; +} + +LOCAL uint32_t sprd_img_get_fourcc(struct dcam_path_spec *path) +{ + uint32_t fourcc = DCAM_INVALID_FOURCC; + + switch (path->out_fmt) { + case DCAM_YUV422: + fourcc = IMG_PIX_FMT_YUV422P; + break; + case DCAM_YUV420: + if (likely(DCAM_ENDIAN_LITTLE == path->end_sel.uv_endian)) + fourcc = IMG_PIX_FMT_NV12; + else + fourcc = IMG_PIX_FMT_NV21; + break; + case DCAM_YUV420_3FRAME: + fourcc = IMG_PIX_FMT_YUV420; + break; + case DCAM_RGB565: + if (likely(DCAM_ENDIAN_HALFBIG == path->end_sel.uv_endian)) + fourcc = IMG_PIX_FMT_RGB565; + else + fourcc = IMG_PIX_FMT_RGB565X; + break; + case DCAM_RAWRGB: + fourcc = IMG_PIX_FMT_GREY; + break; + case DCAM_JPEG: + fourcc = IMG_PIX_FMT_JPEG; + break; + default: + break; + } + return fourcc; +} + +LOCAL uint32_t sprd_img_get_deci_factor(uint32_t src_size, uint32_t dst_size) +{ + uint32_t factor = 0; + + if (0 == src_size || 0 == dst_size) { + return factor; + } + + for (factor = 0; factor < DCAM_CAP_X_DECI_FAC_MAX; factor ++) { + if (src_size < (uint32_t)(dst_size * (1 << factor))) { + break; + } + } + + return factor; +} + +LOCAL uint32_t sprd_img_endian_sel(uint32_t fourcc, struct dcam_path_spec *path) +{ + uint32_t depth = 0; + + if (IMG_PIX_FMT_YUV422P == fourcc || + IMG_PIX_FMT_RGB565 == fourcc || + IMG_PIX_FMT_RGB565X == fourcc) { + depth = 16; + if (IMG_PIX_FMT_YUV422P == fourcc) { + path->out_fmt = DCAM_YUV422; + } else { + path->out_fmt = DCAM_RGB565; + if (IMG_PIX_FMT_RGB565 == fourcc) { + path->end_sel.y_endian = DCAM_ENDIAN_HALFBIG; + } else { + path->end_sel.y_endian = DCAM_ENDIAN_BIG; + } + } + } else { + depth = 12; + if (IMG_PIX_FMT_YUV420 == fourcc || + IMG_PIX_FMT_YVU420 == fourcc) { + path->out_fmt = DCAM_YUV420_3FRAME; + } else { + path->out_fmt = DCAM_YUV420; + if (IMG_PIX_FMT_NV12 == fourcc) { + path->end_sel.uv_endian = DCAM_ENDIAN_LITTLE; + } else { + path->end_sel.uv_endian = DCAM_ENDIAN_HALFBIG; + } + } + } + + return depth; +} + +LOCAL int sprd_img_check_path0_cap(uint32_t fourcc, + struct sprd_img_format *f, + struct dcam_info *info) +{ + struct dcam_path_spec *path = &info->dcam_path[DCAM_PATH0]; + + DCAM_TRACE("SPRD_IMG: check format for path0 \n"); + + path->is_from_isp = f->need_isp; + + path->frm_type = f->channel_id; + path->is_work = 0; + + switch (fourcc) { + case IMG_PIX_FMT_GREY: + path->out_fmt = info->is_loose; // 0 - word/packet, 1 - half word + break; + + case IMG_PIX_FMT_JPEG: + path->out_fmt = 0; // 0 - word, 1 - half word + path->end_sel.y_endian = DCAM_ENDIAN_LITTLE; + break; + + case IMG_PIX_FMT_YUYV: + path->out_fmt = DCAM_OUTPUT_YVYU_1FRAME; + path->end_sel.y_endian = DCAM_ENDIAN_LITTLE; + break; + + case IMG_PIX_FMT_NV21: + case IMG_PIX_FMT_NV12: + path->out_fmt = DCAM_OUTPUT_YUV420; + path->end_sel.y_endian = DCAM_ENDIAN_LITTLE; + if (IMG_PIX_FMT_NV12 == fourcc) { + path->end_sel.uv_endian = DCAM_ENDIAN_LITTLE; + } else { + path->end_sel.uv_endian = DCAM_ENDIAN_HALFBIG; + } + printk("SPRD_IMG: path->end_sel.uv_endian=%d \n", path->end_sel.uv_endian); + break; + + default: + printk("SPRD_IMG: unsupported image format for path0 0x%x \n", fourcc); + return -EINVAL; + } + path->fourcc = fourcc; + + DCAM_TRACE("SPRD_IMG: check format for path0: out_fmt=%d, is_loose=%d \n", path->out_fmt, info->is_loose); + path->out_size.w = f->width; + path->out_size.h = f->height; + + path->is_work = 1; + + return 0; +} + +LOCAL int sprd_img_check_path1_cap(uint32_t fourcc, + struct sprd_img_format *f, + struct dcam_info *info) +{ + uint32_t maxw, maxh, tempw,temph; + uint32_t depth_pixel = 0; + struct dcam_path_spec *path = &info->dcam_path[DCAM_PATH1]; + uint32_t need_recal = 0; + + DCAM_TRACE("SPRD_IMG: check format for path1 \n"); + + path->frm_type = f->channel_id; + path->is_from_isp = f->need_isp; + path->rot_mode = f->reserved[0]; + path->end_sel.y_endian = DCAM_ENDIAN_LITTLE; + path->end_sel.uv_endian = DCAM_ENDIAN_LITTLE; + path->is_work = 0; + path->pixel_depth = 0; + path->img_deci.x_factor = 0; + path->img_deci.y_factor = 0; + tempw = path->in_rect.w; + temph = path->in_rect.h; + info->img_deci.x_factor = 0; + f->need_binning = 0; + printk("zcf sprd_img_check_path1_cap rot_mode:%d\n",path->rot_mode); + /*app should fill in this field(fmt.pix.priv) to set the base index of frame buffer, + and lately this field will return the flag whether ISP is needed for this work path*/ + + switch (fourcc) { + case IMG_PIX_FMT_GREY: + case IMG_PIX_FMT_JPEG: + case IMG_PIX_FMT_YUYV: + case IMG_PIX_FMT_YVYU: + case IMG_PIX_FMT_UYVY: + case IMG_PIX_FMT_VYUY: + if (unlikely(f->width != tempw || + f->height != temph)) { + /*need need scaling or triming*/ + printk("SPRD_IMG: Can not scaling for this image fmt src %d %d, dst %d %d \n", + tempw, + temph, + f->width, + f->height); + return -EINVAL; + } + + if (unlikely(DCAM_CAP_MODE_JPEG != info->sn_mode && + IMG_PIX_FMT_JPEG == fourcc)) { + /* the output of sensor is not JPEG which is needed by app*/ + printk("SPRD_IMG: It's not JPEG sensor \n"); + return -EINVAL; + } + + if (unlikely(DCAM_CAP_MODE_RAWRGB != info->sn_mode && + IMG_PIX_FMT_GREY == fourcc)) { + /* the output of sensor is not RawRGB which is needed by app*/ + printk("SPRD_IMG: It's not RawRGB sensor \n"); + return -EINVAL; + } + + if (IMG_PIX_FMT_GREY == fourcc) { + if (DCAM_CAP_IF_CSI2 == info->if_mode && 0 == info->is_loose) { + depth_pixel = 10; + } else { + depth_pixel = 16; + } + DCAM_TRACE("SPRD_IMG: RawRGB sensor, %d %d \n", info->is_loose, depth_pixel); + } else if (IMG_PIX_FMT_JPEG == fourcc) { + depth_pixel = 8; + } else { + depth_pixel = 16; + } + + if (IMG_PIX_FMT_GREY == fourcc) { + path->out_fmt = DCAM_RAWRGB; + path->end_sel.y_endian = DCAM_ENDIAN_BIG; + } else { + path->out_fmt = DCAM_JPEG; + } + break; + case IMG_PIX_FMT_YUV422P: + case IMG_PIX_FMT_YUV420: + case IMG_PIX_FMT_YVU420: + case IMG_PIX_FMT_NV12: + case IMG_PIX_FMT_NV21: + case IMG_PIX_FMT_RGB565: + case IMG_PIX_FMT_RGB565X: + if (DCAM_CAP_MODE_RAWRGB == info->sn_mode && + path->is_from_isp) { + if (unlikely(info->cap_out_size.w > DCAM_ISP_LINE_BUF_LENGTH)) { + if (0 == info->if_mode) { + /*CCIR CAP, no bining*/ + printk("SPRD_IMG: CCIR CAP, no bining for this path, %d %d \n", + f->width, + f->height); + return -EINVAL; + } else { + /*MIPI CAP, support 1/2 bining*/ + DCAM_TRACE("Need Binning \n"); + tempw = tempw >> 1; + if (unlikely(tempw > DCAM_ISP_LINE_BUF_LENGTH)) { + printk("SPRD_IMG: the width is out of ISP line buffer, %d %d \n", + tempw, + DCAM_ISP_LINE_BUF_LENGTH); + return -EINVAL; + } + info->img_deci.x_factor = 1; + f->need_binning = 1; + DCAM_TRACE("x_factor, %d \n", info->img_deci.x_factor); + path->in_size.w = path->in_size.w >> 1; + path->in_rect.x = path->in_rect.x >> 1; + path->in_rect.w = path->in_rect.w >> 1; + path->in_rect.w = path->in_rect.w & (~3); + } + } + } + if (DCAM_CAP_MODE_YUV == info->sn_mode || + DCAM_CAP_MODE_SPI == info->sn_mode) { + if (tempw != f->width || temph != f->height) { + /*scaling needed*/ + if (unlikely(f->width > DCAM_PATH1_LINE_BUF_LENGTH)) { + /*out of scaling capbility*/ + printk("SPRD_IMG: the output width %d can not be more than %d \n", + f->width, + DCAM_PATH1_LINE_BUF_LENGTH); + return -EINVAL; + } + + /* To check whether the output size is too lager*/ + maxw = tempw * DCAM_SC_COEFF_UP_MAX; + maxh = temph * DCAM_SC_COEFF_UP_MAX; + if (unlikely(f->width > maxw || f->height > maxh)) { + /*out of scaling capbility*/ + printk("SPRD_IMG: the output size is too large, %d %d \n", + f->width, + f->height); + return -EINVAL; + } + + /* To check whether the output size is too small*/ + maxw = f->width * DCAM_SC_COEFF_DOWN_MAX; + if (unlikely( tempw > maxw)) { + path->img_deci.x_factor = sprd_img_get_deci_factor(tempw, maxw); + if (path->img_deci.x_factor > DCAM_PATH_DECI_FAC_MAX) { + printk("SPRD_IMG: the output size is too small, %d %d \n", + f->width, + f->height); + return -EINVAL; + } + } + + maxh = f->height * DCAM_SC_COEFF_DOWN_MAX; + if (unlikely(temph > maxh)) { + path->img_deci.y_factor = sprd_img_get_deci_factor(temph, maxh); + if (path->img_deci.y_factor > DCAM_PATH_DECI_FAC_MAX) { + printk("SPRD_IMG: the output size is too small, %d %d \n", + f->width, + f->height); + return -EINVAL; + } + } + + if (path->img_deci.x_factor) { + tempw = path->in_rect.w >> 1; + need_recal = 1; + } + + if (path->img_deci.y_factor) { + temph = path->in_rect.h >> 1; + need_recal = 1; + } + + if (need_recal && (tempw != f->width || temph != f->height)) { + /*scaling needed*/ + if (unlikely(f->width > DCAM_PATH1_LINE_BUF_LENGTH)) { + /*out of scaling capbility*/ + printk("SPRD_IMG: the output width %d can not be more than %d \n", + f->width, + DCAM_PATH1_LINE_BUF_LENGTH); + return -EINVAL; + } + } + } + } else if (DCAM_CAP_MODE_RAWRGB == info->sn_mode) { + if (path->is_from_isp) { + + if (tempw != f->width || + temph != f->height) { + /*scaling needed*/ + maxw = f->width * DCAM_SC_COEFF_DOWN_MAX; + maxw = maxw * (1 << DCAM_PATH_DECI_FAC_MAX); + maxh = f->height * DCAM_SC_COEFF_DOWN_MAX; + maxh = maxh * (1 << DCAM_PATH_DECI_FAC_MAX); + if (unlikely(tempw > maxw || temph > maxh)) { + /*out of scaling capbility*/ + printk("SPRD_IMG: the output size is too small, %d %d \n", + f->width, + f->height); + return -EINVAL; + } + + if (unlikely(f->width > DCAM_PATH1_LINE_BUF_LENGTH)) { + /*out of scaling capbility*/ + printk("SPRD_IMG: the output width %d can not be more than %d \n", + f->width, + DCAM_PATH1_LINE_BUF_LENGTH); + return -EINVAL; + } + + maxw = tempw * DCAM_SC_COEFF_UP_MAX; + maxh = temph * DCAM_SC_COEFF_UP_MAX; + if (unlikely(f->width > maxw || f->height > maxh)) { + /*out of scaling capbility*/ + printk("SPRD_IMG: the output size is too large, %d %d \n", + f->width, + f->height); + return -EINVAL; + } + } + } else { + /*no ISP ,only RawRGB data can be sampled*/ + printk("SPRD_IMG: RawRGB sensor, no ISP, format 0x%x can't be supported \n", + fourcc); + return -EINVAL; + } + } + + depth_pixel = sprd_img_endian_sel(fourcc, path); + break; + default: + printk("SPRD_IMG: unsupported image format for path2 0x%x \n", fourcc); + return -EINVAL; + } + + path->fourcc = fourcc; + path->pixel_depth = depth_pixel; + f->bytesperline = (f->width * depth_pixel) >> 3; + path->out_size.w = f->width; + path->out_size.h = f->height; + path->is_work = 1; + return 0; +} + +LOCAL int sprd_img_check_path2_cap(uint32_t fourcc, + struct sprd_img_format *f, + struct dcam_info *info) +{ + uint32_t maxw, maxh, tempw,temph; + uint32_t depth_pixel = 0; + struct dcam_path_spec *path = &info->dcam_path[DCAM_PATH2]; + uint32_t need_recal = 0; + + //return -EINVAL; + + DCAM_TRACE("SPRD_IMG: check format for path2 \n"); + + path->frm_type = f->channel_id; + path->is_from_isp = f->need_isp; + path->rot_mode= f->reserved[0]; + path->end_sel.y_endian = DCAM_ENDIAN_LITTLE; + path->end_sel.uv_endian = DCAM_ENDIAN_LITTLE; + path->is_work = 0; + path->pixel_depth = 0; + printk("zcf sprd_img_check_path2_cap rot:%d\n",path->rot_mode); + if (info->img_deci.x_factor) { + tempw = path->in_rect.w >> 1; + path->in_size.w = path->in_size.w >> 1; + path->in_rect.w = path->in_rect.w >> 1; + path->in_rect.x = path->in_rect.x >> 1; + } else { + tempw = path->in_rect.w; + } + temph = path->in_rect.h; + switch (fourcc) { + case IMG_PIX_FMT_YUV422P: + case IMG_PIX_FMT_YUV420: + case IMG_PIX_FMT_YVU420: + case IMG_PIX_FMT_NV12: + case IMG_PIX_FMT_NV21: + + if (DCAM_CAP_MODE_JPEG == info->sn_mode || + info->sn_mode >= DCAM_CAP_MODE_MAX) { + return -EINVAL; + } + + if (DCAM_CAP_MODE_RAWRGB == info->sn_mode) { + path->is_from_isp = 1; + } + + if (DCAM_CAP_MODE_YUV == info->sn_mode || + DCAM_CAP_MODE_SPI == info->sn_mode) { + if (tempw != f->width || temph != f->height) { + /*scaling needed*/ + if (unlikely(f->width > DCAM_PATH2_LINE_BUF_LENGTH)) { + /*out of scaling capbility*/ + printk("SPRD_IMG: the output width %d can not be more than %d \n", + f->width, + DCAM_PATH2_LINE_BUF_LENGTH); + return -EINVAL; + } + + /* To check whether the output size is too lager*/ + maxw = tempw * DCAM_SC_COEFF_UP_MAX; + maxh = temph * DCAM_SC_COEFF_UP_MAX; + if (unlikely(f->width > maxw || f->height > maxh)) { + /*out of scaling capbility*/ + printk("SPRD_IMG: the output size is too large, %d %d \n", + f->width, + f->height); + return -EINVAL; + } + + /* To check whether the output size is too small*/ + maxw = f->width * DCAM_SC_COEFF_DOWN_MAX; + if (unlikely( tempw > maxw)) { + path->img_deci.x_factor = sprd_img_get_deci_factor(tempw, maxw); + if (path->img_deci.x_factor > DCAM_PATH_DECI_FAC_MAX) { + printk("SPRD_IMG: the output size is too small, %d %d \n", + f->width, + f->height); + return -EINVAL; + } + } + + maxh = f->height * DCAM_SC_COEFF_DOWN_MAX; + if (unlikely(temph > maxh)) { + path->img_deci.y_factor = sprd_img_get_deci_factor(temph, maxh); + if (path->img_deci.y_factor > DCAM_PATH_DECI_FAC_MAX) { + printk("SPRD_IMG: the output size is too small, %d %d \n", + f->width, + f->height); + return -EINVAL; + } + } + + if (path->img_deci.x_factor) { + tempw = path->in_rect.w >> 1; + need_recal = 1; + } + + if (path->img_deci.y_factor) { + temph = path->in_rect.h >> 1; + need_recal = 1; + } + + if (need_recal && (tempw != f->width || temph != f->height)) { + /*scaling needed*/ + if (unlikely(f->width > DCAM_PATH2_LINE_BUF_LENGTH)) { + /*out of scaling capbility*/ + printk("SPRD_IMG: the output width %d can not be more than %d \n", + f->width, + DCAM_PATH2_LINE_BUF_LENGTH); + return -EINVAL; + } + } + } + } else if (DCAM_CAP_MODE_RAWRGB == info->sn_mode) { + if (path->is_from_isp) { + + if (tempw != f->width || + temph != f->height) { + /*scaling needed*/ + maxw = f->width * DCAM_SC_COEFF_DOWN_MAX; + maxw = maxw * (1 << DCAM_PATH_DECI_FAC_MAX); + maxh = f->height * DCAM_SC_COEFF_DOWN_MAX; + maxh = maxh * (1 << DCAM_PATH_DECI_FAC_MAX); + if (unlikely(tempw > maxw || temph > maxh)) { + /*out of scaling capbility*/ + printk("SPRD_IMG: the output size is too small, %d %d \n", + f->width, + f->height); + return -EINVAL; + } + + if (unlikely(f->width > DCAM_PATH2_LINE_BUF_LENGTH)) { + /*out of scaling capbility*/ + printk("SPRD_IMG: the output width %d can not be more than %d \n", + f->width, + DCAM_PATH2_LINE_BUF_LENGTH); + return -EINVAL; + } + + maxw = tempw * DCAM_SC_COEFF_UP_MAX; + maxh = temph * DCAM_SC_COEFF_UP_MAX; + if (unlikely(f->width > maxw || f->height > maxh)) { + /*out of scaling capbility*/ + printk("SPRD_IMG: the output size is too large, %d %d \n", + f->width, + f->height); + return -EINVAL; + } + } + } else { + /*no ISP ,only RawRGB data can be sampled*/ + printk("SPRD_IMG: RawRGB sensor, no ISP, format 0x%x can't be supported \n", + fourcc); + return -EINVAL; + } + } + + + depth_pixel = sprd_img_endian_sel(fourcc, path); + //path->end_sel.uv_endian = DCAM_ENDIAN_LITTLE; // tmp fix: output is vu, jpeg only support vu + break; + default: + printk("SPRD_IMG: unsupported image format for path2 0x%x \n", fourcc); + return -EINVAL; + } + + path->fourcc = fourcc; + f->need_isp = path->is_from_isp; + path->pixel_depth = depth_pixel; + f->bytesperline = (f->width * depth_pixel) >> 3; + path->out_size.w = f->width; + path->out_size.h = f->height; + path->is_work = 1; + + return 0; +} + +LOCAL int sprd_img_cap_cfg(struct dcam_info* info) +{ + int ret = DCAM_RTN_SUCCESS; + uint32_t param = 0; + + if (NULL == info) + return -EINVAL; + + ret = dcam_cap_cfg(DCAM_CAP_SYNC_POL, &info->sync_pol); + IMG_RTN_IF_ERR(ret); + + if ((info->dcam_path[DCAM_PATH0].is_work && info->dcam_path[DCAM_PATH0].is_from_isp) || + (info->dcam_path[DCAM_PATH1].is_work && info->dcam_path[DCAM_PATH1].is_from_isp) || + (info->dcam_path[DCAM_PATH2].is_work && info->dcam_path[DCAM_PATH2].is_from_isp)) { + param = 1; + } else if (!info->dcam_path[DCAM_PATH0].is_work && + !info->dcam_path[DCAM_PATH1].is_work && + !info->dcam_path[DCAM_PATH2].is_work && (DCAM_CAP_MODE_RAWRGB == info->sn_mode)) { + param = 1; + } else { + param = 0; + } + ret = dcam_cap_cfg(DCAM_CAP_TO_ISP, ¶m); + IMG_RTN_IF_ERR(ret); + + ret = dcam_cap_cfg(DCAM_CAP_YUV_TYPE, &info->yuv_ptn); + IMG_RTN_IF_ERR(ret); + + ret = dcam_cap_cfg(DCAM_CAP_DATA_BITS, &info->data_bits); + IMG_RTN_IF_ERR(ret); + + if (DCAM_CAP_MODE_RAWRGB == info->sn_mode && + DCAM_CAP_IF_CSI2 == info->if_mode) + { + ret = dcam_cap_cfg(DCAM_CAP_DATA_PACKET, &info->is_loose); + IMG_RTN_IF_ERR(ret); + } + + ret = dcam_cap_cfg(DCAM_CAP_FRM_DECI, &info->frm_deci); + IMG_RTN_IF_ERR(ret); + + ret = dcam_cap_cfg(DCAM_CAP_INPUT_RECT, &info->cap_in_rect); + IMG_RTN_IF_ERR(ret); + + ret = dcam_cap_cfg(DCAM_CAP_FRM_COUNT_CLR, NULL); + IMG_RTN_IF_ERR(ret); + + ret = dcam_cap_cfg(DCAM_CAP_PRE_SKIP_CNT, &info->skip_number); + IMG_RTN_IF_ERR(ret); + + ret = dcam_cap_cfg(DCAM_CAP_SAMPLE_MODE, &info->capture_mode); + IMG_RTN_IF_ERR(ret); + + ret = dcam_cap_cfg(DCAM_CAP_ZOOM_MODE, &info->is_smooth_zoom); + + ret = dcam_cap_cfg(DCAM_CAP_IMAGE_XY_DECI, &info->img_deci); + +exit: + return ret; +} + +LOCAL void sprd_img_frm_pop(struct dcam_frame *frame, void* param) +{ +#if 0 + uint32_t i = 0; + uint32_t frame_count = 0; + struct dcam_path_spec *path = NULL; + struct dcam_dev *dev = (struct dcam_dev*)param; + struct dcam_info *info = NULL; + + info = &dev->dcam_cxt; + + switch (frame->type) { + case DCAM_PATH0: + path = &info->dcam_path[DCAM_PATH0]; + break; + case DCAM_PATH1: + path = &info->dcam_path[DCAM_PATH1]; + break; + case DCAM_PATH2: + path = &info->dcam_path[DCAM_PATH2]; + break; + default: + printk("SPRD_IMG error: sprd_img_frm_pop, path 0x%x \n", frame->type); + return -EINVAL; + } + DCAM_TRACE("SPRD_IMG: sprd_img_frm_pop start, path 0x%x \n", frame->type); + DCAM_TRACE("SPRD_IMG: sprd_img_frm_pop, yaddr 0x%x 0x%x \n", frame->yaddr, path->frm_addr[0].yaddr); + if (frame->yaddr == path->frm_addr[0].yaddr) { + for (i = 0; i < path->frm_cnt_act - 1; i++) { + path->frm_addr[i] = path->frm_addr[i+1]; + path->frm_addr_vir[i] = path->frm_addr_vir[i+1]; + } + path->frm_cnt_act--; + memset(&path->frm_addr[path->frm_cnt_act], 0, sizeof(struct dcam_addr)); + memset(&path->frm_addr_vir[path->frm_cnt_act], 0, sizeof(struct dcam_addr)); + } else { + printk("SPRD_IMG error: sprd_img_frm_pop, yaddr 0x%x 0x%x \n", frame->yaddr, path->frm_addr[0].yaddr); + } + DCAM_TRACE("SPRD_IMG: sprd_img_frm_pop end, path 0x%x yaddr 0x%x \n", frame->type, frame->yaddr); +#endif + return; +} + +LOCAL int sprd_img_tx_done(struct dcam_frame *frame, void* param) +{ + int ret = DCAM_RTN_SUCCESS; + struct dcam_dev *dev = (struct dcam_dev*)param; + struct dcam_path_spec *path; + struct dcam_node node; + uint32_t fmr_index; + struct dcam_img_buf_addr buf_addr; + struct timeval time; + + if (NULL == frame || NULL == param || 0 == atomic_read(&dev->stream_on)) + return -EINVAL; + path = &dev->dcam_cxt.dcam_path[frame->type]; + if (PATH_IDLE == path->status) { + return ret; + } + + atomic_set(&dev->run_flag, 1); + + img_get_timestamp(&time); + DCAM_TRACE("time, %ld %ld \n", (unsigned long)time.tv_sec, (unsigned long)time.tv_usec); + + memset((void*)&node, 0, sizeof(struct dcam_node)); + node.irq_flag = IMG_TX_DONE; + node.f_type = frame->type; + node.index = frame->fid; + node.height = frame->height; + node.yaddr = frame->yaddr; + node.uaddr = frame->uaddr; + node.vaddr = frame->vaddr; + node.yaddr_vir = frame->yaddr_vir; + node.uaddr_vir = frame->uaddr_vir; + node.vaddr_vir = frame->vaddr_vir; + node.time.tv_sec = time.tv_sec; + node.time.tv_usec = time.tv_usec; + + DCAM_TRACE("SPRD_IMG: flag 0x%x type 0x%x index 0x%x \n", + node.irq_flag, node.f_type, node.index); + +/* path = &dev->dcam_cxt.dcam_path[frame->type]; + ret = sprd_img_buf_queue_read(&path->buf_queue, &buf_addr); + if (ret) + return ret; + + node.yaddr_vir = buf_addr.frm_addr_vir.yaddr; + node.uaddr_vir = buf_addr.frm_addr_vir.uaddr; + node.vaddr_vir = buf_addr.frm_addr_vir.vaddr; +*/ + if (DCAM_PATH0 == frame->type && DCAM_CAP_MODE_JPEG == dev->dcam_cxt.sn_mode) { + dcam_cap_get_info(DCAM_CAP_JPEG_GET_LENGTH, &node.reserved); + printk("SPRD_IMG: JPEG length 0x%x \n", node.reserved); + if (node.reserved < DCAM_JPEG_LENGTH_MIN) { + return sprd_img_tx_error(frame, param); + } + } + + if (dev->dcam_cxt.after_af && DCAM_PATH1 == frame->type) { + ret = sprd_img_discard_frame(frame, param); + if (DCAM_RTN_SUCCESS == ret) { + dev->dcam_cxt.after_af = 0; + node.irq_flag = IMG_CANCELED_BUF; + } + } + + ret = sprd_img_queue_write(&dev->queue, &node); + if (ret) + return ret; + + up(&dev->irq_sem); + return ret; +} + +LOCAL int sprd_img_tx_error(struct dcam_frame *frame, void* param) +{ + int ret = DCAM_RTN_SUCCESS; + struct dcam_dev *dev = (struct dcam_dev*)param; + struct dcam_path_spec *path; + struct dcam_node node; + struct dcam_img_buf_addr buf_addr; + + if (NULL == param || 0 == atomic_read(&dev->stream_on)) + return -EINVAL; + + memset((void*)&node, 0, sizeof(struct dcam_node)); + atomic_set(&dev->run_flag, 1);//to avoid time out processing + node.irq_flag = IMG_TX_ERR; + if (NULL != frame) { + node.f_type = frame->type; + node.index = frame->fid; + node.height = frame->height; + node.yaddr = frame->yaddr; + node.uaddr = frame->uaddr; + node.vaddr = frame->vaddr; + node.yaddr_vir = frame->yaddr_vir; + node.uaddr_vir = frame->uaddr_vir; + node.vaddr_vir = frame->vaddr_vir; + +/* path = &dev->dcam_cxt.dcam_path[frame->type]; + ret = sprd_img_buf_queue_read(&path->buf_queue, &buf_addr); + if (ret) + return ret; + + node.yaddr_vir = buf_addr.frm_addr_vir.yaddr; + node.uaddr_vir = buf_addr.frm_addr_vir.uaddr; + node.vaddr_vir = buf_addr.frm_addr_vir.vaddr;*/ + } + ret = sprd_img_queue_write(&dev->queue, &node); + if (ret) + return ret; + + up(&dev->irq_sem); + + printk("SPRD_IMG: tx_error \n"); + //mm_clk_register_trace(); + return ret; +} + +LOCAL int sprd_img_no_mem(struct dcam_frame *frame, void* param) +{ + int ret = DCAM_RTN_SUCCESS; + struct dcam_dev *dev = (struct dcam_dev*)param; + struct dcam_path_spec *path; + struct dcam_node node; + struct dcam_img_buf_addr buf_addr; + + if (NULL == param || 0 == atomic_read(&dev->stream_on)) + return -EINVAL; + atomic_set(&dev->run_flag, 1);//to avoid time out processing + + memset((void*)&node, 0, sizeof(struct dcam_node)); + node.irq_flag = IMG_NO_MEM; + node.f_type = frame->type; + node.index = frame->fid; + node.height = frame->height; + node.yaddr = frame->yaddr; + node.uaddr = frame->uaddr; + node.vaddr = frame->vaddr; + node.yaddr_vir = frame->yaddr_vir; + node.uaddr_vir = frame->uaddr_vir; + node.vaddr_vir = frame->vaddr_vir; + + +/* path = &dev->dcam_cxt.dcam_path[frame->type]; + ret = sprd_img_buf_queue_read(&path->buf_queue, &buf_addr); + if (ret) + return ret; + + node.yaddr_vir = buf_addr.frm_addr_vir.yaddr; + node.uaddr_vir = buf_addr.frm_addr_vir.uaddr; + node.vaddr_vir = buf_addr.frm_addr_vir.vaddr;*/ + ret = sprd_img_queue_write(&dev->queue, &node); + if (ret) + return ret; + + up(&dev->irq_sem); + printk("SPRD_IMG: no mem \n"); + return ret; +} + +LOCAL int sprd_img_tx_stop(void* param) +{ + int ret = DCAM_RTN_SUCCESS; + struct dcam_dev *dev = (struct dcam_dev*)param; + struct dcam_node node; + + memset((void*)&node, 0, sizeof(struct dcam_node)); + node.irq_flag = IMG_TX_STOP; + ret = sprd_img_queue_write(&dev->queue, &node); + if (ret) + return ret; + + up(&dev->irq_sem); + + return ret; +} + +LOCAL int sprd_img_reg_isr(struct dcam_dev* param) +{ + dcam_reg_isr(DCAM_PATH0_DONE, sprd_img_tx_done, param); + dcam_reg_isr(DCAM_PATH1_DONE, sprd_img_tx_done, param); + dcam_reg_isr(DCAM_PATH0_OV, sprd_img_tx_error, param); + dcam_reg_isr(DCAM_PATH1_OV, sprd_img_tx_error, param); + dcam_reg_isr(DCAM_ISP_OV, sprd_img_tx_error, param); + dcam_reg_isr(DCAM_MIPI_OV, sprd_img_tx_error, param); + dcam_reg_isr(DCAM_SN_LINE_ERR, sprd_img_tx_error, param); + dcam_reg_isr(DCAM_SN_FRAME_ERR, sprd_img_tx_error, param); + dcam_reg_isr(DCAM_JPEG_BUF_OV, sprd_img_no_mem, param); + dcam_reg_isr(DCAM_SN_EOF, sprd_img_start_flash, param); + dcam_reg_isr(DCAM_PATH1_SOF, sprd_img_start_zoom, param); + + return 0; +} + +LOCAL int sprd_img_reg_path2_isr(struct dcam_dev* param) +{ + dcam_reg_isr(DCAM_PATH2_DONE, sprd_img_tx_done, param); + dcam_reg_isr(DCAM_PATH2_OV, sprd_img_tx_error, param); + + return 0; +} + +LOCAL int sprd_img_unreg_isr(struct dcam_dev* param) +{ + dcam_reg_isr(DCAM_PATH0_DONE, NULL, param); + dcam_reg_isr(DCAM_PATH1_DONE, NULL, param); + dcam_reg_isr(DCAM_PATH0_OV, NULL, param); + dcam_reg_isr(DCAM_PATH1_OV, NULL, param); + dcam_reg_isr(DCAM_ISP_OV, NULL, param); + dcam_reg_isr(DCAM_MIPI_OV, NULL, param); + dcam_reg_isr(DCAM_SN_LINE_ERR, NULL, param); + dcam_reg_isr(DCAM_SN_FRAME_ERR, NULL, param); + dcam_reg_isr(DCAM_JPEG_BUF_OV, NULL, param); + dcam_reg_isr(DCAM_SN_EOF, NULL, param); + dcam_reg_isr(DCAM_PATH1_SOF, NULL, param); + + return 0; +} + +LOCAL int sprd_img_unreg_path2_isr(struct dcam_dev* param) +{ + dcam_reg_isr(DCAM_PATH2_DONE, NULL, NULL); + dcam_reg_isr(DCAM_PATH2_OV, NULL, NULL); + + return 0; +} + +LOCAL int sprd_img_path0_cfg(path_cfg_func path_cfg, + struct dcam_path_spec* path_spec) +{ + int ret = DCAM_RTN_SUCCESS; + uint32_t param, i; + + if (NULL == path_cfg || NULL == path_spec) + return -EINVAL; + + if (path_spec->is_from_isp) { + param = 1; + } else { + param = 0; + } + ret = path_cfg(DCAM_PATH_SRC_SEL, ¶m); + /*IMG_RTN_IF_ERR(ret);*/ + + ret = path_cfg(DCAM_PATH_INPUT_SIZE, &path_spec->in_size); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_INPUT_RECT, &path_spec->in_rect); + /*IMG_RTN_IF_ERR(ret);*/ + + ret = path_cfg(DCAM_PATH_OUTPUT_FORMAT, &path_spec->out_fmt); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_FRAME_BASE_ID, &path_spec->frm_id_base); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_FRAME_TYPE, &path_spec->frm_type); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_DATA_ENDIAN, &path_spec->end_sel); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_FRM_DECI, &path_spec->path_frm_deci); + IMG_RTN_IF_ERR(ret); + + ret = sprd_img_path_cfg_output_addr(path_cfg, path_spec); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_OUTPUT_RESERVED_ADDR, &path_spec->frm_reserved_addr); + + param = 1; + ret = path_cfg(DCAM_PATH_ENABLE, ¶m); + +exit: + return ret; +} + +LOCAL int sprd_img_path_cfg(path_cfg_func path_cfg, + struct dcam_path_spec* path_spec) +{ + int ret = DCAM_RTN_SUCCESS; + uint32_t param, i; + + if (NULL == path_cfg || NULL == path_spec) + return -EINVAL; + + if (path_spec->is_from_isp) { + param = 1; + } else { + param = 0; + } + ret = path_cfg(DCAM_PATH_SRC_SEL, ¶m); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_ROT_MODE, &path_spec->rot_mode); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_INPUT_SIZE, &path_spec->in_size); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_INPUT_RECT, &path_spec->in_rect); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_OUTPUT_SIZE, &path_spec->out_size); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_OUTPUT_FORMAT, &path_spec->out_fmt); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_FRAME_BASE_ID, &path_spec->frm_id_base); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_FRAME_TYPE, &path_spec->frm_type); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_DATA_ENDIAN, &path_spec->end_sel); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_FRM_DECI, &path_spec->path_frm_deci); + IMG_RTN_IF_ERR(ret); + + ret = sprd_img_path_cfg_output_addr(path_cfg, path_spec); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_OUTPUT_RESERVED_ADDR, &path_spec->frm_reserved_addr); + + ret = path_cfg(DCAM_PATH_SHRINK, &path_spec->shrink); + + param = 1; + ret = path_cfg(DCAM_PATH_ENABLE, ¶m); + +exit: + return ret; +} + +LOCAL int sprd_img_path_lightly_cfg(path_cfg_func path_cfg, + struct dcam_path_spec* path_spec) +{ + int ret = DCAM_RTN_SUCCESS; + uint32_t param; + + if (NULL == path_cfg || NULL == path_spec) + return -EINVAL; + + if (path_spec->is_from_isp) { + param = 1; + } else { + param = 0; + } + ret = path_cfg(DCAM_PATH_SRC_SEL, ¶m); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_INPUT_SIZE, &path_spec->in_size); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_INPUT_RECT, &path_spec->in_rect); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_OUTPUT_SIZE, &path_spec->out_size); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_OUTPUT_FORMAT, &path_spec->out_fmt); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_FRAME_BASE_ID, &path_spec->frm_id_base); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_FRAME_TYPE, &path_spec->frm_type); + IMG_RTN_IF_ERR(ret); + + ret = path_cfg(DCAM_PATH_DATA_ENDIAN, &path_spec->end_sel); + IMG_RTN_IF_ERR(ret); + +exit: + return ret; +} + + +LOCAL int sprd_img_local_deinit(struct dcam_dev *dev) +{ + int ret = 0; + struct dcam_path_spec *path = &dev->dcam_cxt.dcam_path[DCAM_PATH1]; + printk("SPRD_IMG: sprd_img_local_deinit, frm_cnt_act %d \n", path->frm_cnt_act); + if (unlikely(NULL == dev || NULL == path)) { + return -EINVAL; + } + path->is_work = 0; + path->frm_cnt_act = 0; + memset((void*)&path->frm_reserved_addr, 0, sizeof(struct dcam_addr)); + sprd_img_buf_queue_init(&path->buf_queue); + + path = &dev->dcam_cxt.dcam_path[DCAM_PATH2]; + if (unlikely(NULL == path)) + return -EINVAL; + path->is_work = 0; + path->frm_cnt_act = 0; + memset((void*)&path->frm_reserved_addr, 0, sizeof(struct dcam_addr)); + sprd_img_buf_queue_init(&path->buf_queue); + + path = &dev->dcam_cxt.dcam_path[DCAM_PATH0]; + if (unlikely(NULL == path)) + return -EINVAL; + path->is_work = 0; + path->frm_cnt_act = 0; + memset((void*)&path->frm_reserved_addr, 0, sizeof(struct dcam_addr)); + sprd_img_buf_queue_init(&path->buf_queue); + + ret = sprd_img_queue_init(&dev->queue); + if (unlikely(ret != 0)) { + printk("SPRD_IMG: Failed to init queue \n"); + return -EINVAL; + } + + printk("SPRD_IMG: sprd_img_local_deinit, frm_cnt_act %d \n", path->frm_cnt_act); + + return 0; +} + +LOCAL int sprd_img_queue_init(struct dcam_queue *queue) +{ + if (NULL == queue) + return -EINVAL; + + memset(queue, 0, sizeof(*queue)); + queue->write = &queue->node[0]; + queue->read = &queue->node[0]; + + return 0; +} + +LOCAL int sprd_img_queue_write(struct dcam_queue *queue, struct dcam_node *node) +{ + struct dcam_node *ori_node; + unsigned long lock_flag; + + if (NULL == queue || NULL == node) + return -EINVAL; + + ori_node = queue->write; + queue->wcnt++; + DCAM_TRACE("SPRD_IMG: sprd_img_queue_write \n"); + *queue->write++ = *node; + if (queue->write > &queue->node[DCAM_QUEUE_LENGTH-1]) { + queue->write = &queue->node[0]; + } + + if (queue->write == queue->read) { + queue->write = ori_node; + printk("SPRD_IMG: warning, queue is full, cannot write, flag 0x%x type 0x%x index 0x%x wcht %d %d\n", + node->irq_flag, node->f_type, node->index, queue->wcnt, queue->rcnt); + } + + return 0; +} + +LOCAL int sprd_img_queue_read(struct dcam_queue *queue, struct dcam_node *node) +{ + int ret = DCAM_RTN_SUCCESS; + int flag = 0; + + if (NULL == queue || NULL == node) + return -EINVAL; + + DCAM_TRACE("SPRD_IMG: sprd_img_queue_read \n"); + + if (queue->read != queue->write) { + flag = 1; + *node = *queue->read; + queue->read->yaddr = 0; + queue->read->yaddr_vir = 0; + queue->read++; + queue->rcnt++; + if (queue->read > &queue->node[DCAM_QUEUE_LENGTH-1]) { + queue->read = &queue->node[0]; + } + } + if (!flag) { + ret = EAGAIN; + } + DCAM_TRACE("SPRD_IMG: sprd_img_queue_read type %d \n", node->f_type); + return ret; +} + +LOCAL int sprd_img_queue_disable(struct dcam_queue *queue, uint32_t channel_id) +{ + struct dcam_node *cur_node; + + if (NULL == queue) + return -EINVAL; + + cur_node = queue->read; + while (cur_node != queue->write) { + if (channel_id == cur_node->f_type) { + cur_node->invalid_flag = 1; + } + if (cur_node >= &queue->node[DCAM_QUEUE_LENGTH-1]) { + cur_node = &queue->node[0]; + } else { + cur_node++; + } + } + + + return 0; +} + +LOCAL int sprd_img_queue_enable(struct dcam_queue *queue, uint32_t channel_id) +{ + struct dcam_node *cur_node; + unsigned int i = 0; + + if (NULL == queue) + return -EINVAL; + + for (i=0 ; i < DCAM_QUEUE_LENGTH ; i++) { + queue->node[i].invalid_flag = 0; + } + + return 0; +} + +LOCAL int sprd_img_buf_queue_init(struct dcam_img_buf_queue *queue) +{ + if (NULL == queue) + return -EINVAL; + + printk("SPRD_IMG: sprd_img_buf_queue_init \n"); + memset(queue, 0, sizeof(*queue)); + queue->write = &queue->buf_addr[0]; + queue->read = &queue->buf_addr[0]; + + return 0; +} + +LOCAL int sprd_img_buf_queue_write(struct dcam_img_buf_queue *queue, struct dcam_img_buf_addr *buf_addr) +{ + struct dcam_img_buf_addr *ori_node; + + if (NULL == queue || NULL == buf_addr) + return -EINVAL; + + ori_node = queue->write; + DCAM_TRACE("SPRD_IMG: sprd_img_buf_queue_write \n"); + *queue->write++ = *buf_addr; + queue->wcnt++; + if (queue->write > &queue->buf_addr[DCAM_FRM_CNT_MAX-1]) { + queue->write = &queue->buf_addr[0]; + } + + if (queue->write == queue->read) { + queue->write = ori_node; + printk("SPRD_IMG: warning, queue is full, cannot write %d %d", queue->wcnt, queue->rcnt); + return -EINVAL; + } + + return 0; +} + +LOCAL int sprd_img_buf_queue_read(struct dcam_img_buf_queue *queue, struct dcam_img_buf_addr *buf_addr) +{ + int ret = DCAM_RTN_SUCCESS; + + if (NULL == queue || NULL == buf_addr) + return -EINVAL; + + DCAM_TRACE("SPRD_IMG: sprd_img_buf_queue_read \n"); + if (queue->read != queue->write) { + *buf_addr = *queue->read++; + queue->rcnt++; + if (queue->read > &queue->buf_addr[DCAM_FRM_CNT_MAX-1]) { + queue->read = &queue->buf_addr[0]; + } + } else { + printk("SPRD_IMG: buf_queue_read fail %d\n", queue->rcnt); + ret = EAGAIN; + } + + DCAM_TRACE("SPRD_IMG: sprd_img_buf_queue_read \n"); + return ret; +} + +LOCAL int sprd_img_path_cfg_output_addr(path_cfg_func path_cfg, struct dcam_path_spec* path_spec) +{ + int ret = DCAM_RTN_SUCCESS; + struct dcam_img_buf_addr *cur_node; + struct dcam_img_buf_queue *queue; + struct dcam_addr frm_addr; + + if (NULL == path_cfg || NULL == path_spec) + return -EINVAL; + + queue = &path_spec->buf_queue; + + for (cur_node = queue->read; cur_node != queue->write; cur_node++) { + if (cur_node > &queue->buf_addr[DCAM_FRM_CNT_MAX-1]) { + cur_node = &queue->buf_addr[0]; + } + frm_addr.yaddr = cur_node->frm_addr.yaddr; + frm_addr.uaddr = cur_node->frm_addr.uaddr; + frm_addr.vaddr = cur_node->frm_addr.vaddr; + frm_addr.yaddr_vir = cur_node->frm_addr_vir.yaddr; + frm_addr.uaddr_vir = cur_node->frm_addr_vir.uaddr; + frm_addr.vaddr_vir = cur_node->frm_addr_vir.vaddr; + ret = path_cfg(DCAM_PATH_OUTPUT_ADDR, &frm_addr); + IMG_RTN_IF_ERR(ret); + } + +exit: + return ret; +} + + +LOCAL int sprd_img_get_path_index(uint32_t channel_id) +{ + int path_index; + + switch (channel_id) { + case DCAM_PATH0: + path_index = DCAM_PATH_IDX_0; + break; + case DCAM_PATH1: + path_index = DCAM_PATH_IDX_1; + break; + case DCAM_PATH2: + path_index = DCAM_PATH_IDX_2; + break; + default: + path_index = DCAM_PATH_IDX_NONE; + printk("SPRD_IMG: get path index error, invalid channel_id=0x%x \n", channel_id); + } + return path_index; +} + +LOCAL int img_get_zoom_rect(struct dcam_rect *src_rect, struct dcam_rect *dst_rect, struct dcam_rect *output_rect, uint32_t zoom_level) +{ + uint32_t trim_width = 0; + uint32_t trim_height = 0; + uint32_t zoom_step_w = 0, zoom_step_h = 0; + + if (NULL == src_rect || NULL == dst_rect || NULL == output_rect) { + printk("SPRD_IMG: img_get_zoom_rect: %p, %p, %p\n", src_rect, dst_rect, output_rect); + return -EINVAL; + } + + if (0 == dst_rect->w || 0 == dst_rect->h) { + printk("SPRD_IMG: img_get_zoom_rect: dst0x%x, 0x%x\n", dst_rect->w, dst_rect->h); + return -EINVAL; + } + + if (src_rect->w > dst_rect->w && src_rect->h > dst_rect->h) { + zoom_step_w = DCAM_ZOOM_STEP(src_rect->w, dst_rect->w); + zoom_step_w &= ~1; + zoom_step_w *= zoom_level; + trim_width = src_rect->w - zoom_step_w; + + zoom_step_h = DCAM_ZOOM_STEP(src_rect->h, dst_rect->h); + zoom_step_h &= ~1; + zoom_step_h *= zoom_level; + trim_height = src_rect->h - zoom_step_h; + + output_rect->x = src_rect->x + ((src_rect->w - trim_width) >> 1); + output_rect->y = src_rect->y + ((src_rect->h - trim_height) >> 1); + } else if (src_rect->w < dst_rect->w && src_rect->h < dst_rect->h) { + zoom_step_w = DCAM_ZOOM_STEP(dst_rect->w, src_rect->w); + zoom_step_w &= ~1; + zoom_step_w *= zoom_level; + trim_width = src_rect->w + zoom_step_w; + + zoom_step_h = DCAM_ZOOM_STEP(dst_rect->h, src_rect->h); + zoom_step_h &= ~1; + zoom_step_h *= zoom_level; + trim_height = src_rect->h + zoom_step_h; + + output_rect->x = src_rect->x - ((trim_width - src_rect->w) >> 1); + output_rect->y = src_rect->y - ((trim_height - src_rect->h) >> 1); + } else { + printk("SPRD_IMG: SPRD_IMG img_get_zoom_rect: param error\n"); + return -EINVAL; + } + + output_rect->x = DCAM_WIDTH(output_rect->x); + output_rect->y = DCAM_HEIGHT(output_rect->y); + output_rect->w = DCAM_WIDTH(trim_width); + output_rect->h = DCAM_HEIGHT(trim_height); + DCAM_TRACE("SPRD_IMG: zoom_level %d, trim rect, %d %d %d %d\n", + zoom_level, + output_rect->x, + output_rect->y, + output_rect->w, + output_rect->h); + + return 0; +} + +LOCAL int sprd_img_start_zoom(struct dcam_frame *frame, void* param) +{ + struct dcam_dev *dev = (struct dcam_dev*)param; + + if (dev == NULL) { + DCAM_TRACE("SPRD_IMG: sprd_img_start_zoom, dev is NULL \n"); + return -1; + } + DCAM_TRACE("SPRD_IMG: start zoom level %d \n", dev->zoom_level); + if (dev->zoom_level <= DCAM_ZOOM_LEVEL_MAX && dev->dcam_cxt.is_smooth_zoom) { + up(&dev->zoom_thread_sem); + } else { + dcam_stop_sc_coeff(); + } + + return 0; +} + +int sprd_img_zoom_thread_loop(void *arg) +{ + struct dcam_dev *dev = (struct dcam_dev*)arg; + int ret = DCAM_RTN_SUCCESS; + struct dcam_rect zoom_rect = {0}; + struct dcam_path_spec *path = NULL; + enum dcam_path_index path_index; + + if (dev == NULL) { + printk("SPRD_IMG: zoom_thread_loop, dev is NULL \n"); + return -1; + } + while (1) { + if (0 == down_interruptible(&dev->zoom_thread_sem)) { + DCAM_TRACE("SPRD_IMG: zoom thread level %d \n", dev->zoom_level); + if (dev->is_zoom_thread_stop) { + DCAM_TRACE("SPRD_IMG: zoom_thread_loop stop \n"); + break; + } + + if (dev->zoom_level > DCAM_ZOOM_LEVEL_MAX) { + continue; + } + mutex_lock(&dev->dcam_mutex); + path = &dev->dcam_cxt.dcam_path[dev->channel_id]; + path_index = sprd_img_get_path_index(dev->channel_id); + if (dev->zoom_level < DCAM_ZOOM_LEVEL_MAX) { + ret = img_get_zoom_rect(&path->in_rect_backup, &path->in_rect, &zoom_rect, dev->zoom_level); + if (!ret) { + memcpy((void*)&path->in_rect_current, (void*)&zoom_rect, sizeof(struct dcam_rect)); + dcam_update_path(path_index, &path->in_size, &zoom_rect, &path->out_size); + } + } else { + dcam_update_path(path_index, &path->in_size, &path->in_rect, &path->out_size); + memcpy((void*)&path->in_rect_backup, (void*)&path->in_rect, sizeof(struct dcam_rect)); + memcpy((void*)&path->in_rect_current, (void*)&path->in_rect_backup, sizeof(struct dcam_rect)); + } + dev->zoom_level++; + mutex_unlock(&dev->dcam_mutex); + DCAM_TRACE("SPRD_IMG: zoom thread level %d end \n", dev->zoom_level); + + } else { + printk("SPRD_IMG: zoom int!"); + break; + } + } + dev->is_zoom_thread_stop = 0; + + return 0; +} + +int sprd_img_create_zoom_thread(void* param) +{ + struct dcam_dev *dev = (struct dcam_dev*)param; + + if (dev == NULL) { + DCAM_TRACE("create_zoom_thread, dev is NULL \n"); + return -1; + } + printk("SPRD_IMG: create_zoom_thread E!\n"); + + dev->is_zoom_thread_stop = 0; + dev->zoom_level = DCAM_ZOOM_LEVEL_MAX + 1; + sema_init(&dev->zoom_thread_sem, 0); + dev->zoom_thread = kthread_run(sprd_img_zoom_thread_loop, param, "img_zoom_thread"); + if (IS_ERR(dev->zoom_thread)) { + printk("SPRD_IMG: create_zoom_thread error!\n"); + return -1; + } + return 0; +} + +int sprd_img_stop_zoom_thread(void* param) +{ + struct dcam_dev *dev = (struct dcam_dev*)param; + int cnt = 0; + + if (dev == NULL) { + DCAM_TRACE("stop_zoom_thread, dev is NULL \n"); + return -1; + } + DCAM_TRACE("SPRD_IMG: stop_zoom_thread E!\n"); + if (dev->zoom_thread) { + dev->is_zoom_thread_stop = 1; + up(&dev->zoom_thread_sem); + if (dev->is_zoom_thread_stop != 0) { + while (cnt < 500) { + cnt++; + if (0 == dev->is_zoom_thread_stop) + break; + msleep(1); + } + } + dev->zoom_thread = NULL; + } + + return 0; +} + +LOCAL int sprd_img_update_video(struct file *file, uint32_t channel_id) +{ + struct dcam_dev *dev = file->private_data; + int ret = DCAM_RTN_SUCCESS; + struct dcam_path_spec *path = NULL; + path_cfg_func path_cfg; + enum dcam_path_index path_index; + + + DCAM_TRACE("SPRD_IMG: sprd_img_update_video, channel=%d \n", channel_id); + + mutex_lock(&dev->dcam_mutex); + + path = &dev->dcam_cxt.dcam_path[channel_id]; + path_index = sprd_img_get_path_index(channel_id); + + if (DCAM_PATH0 == channel_id) { + path_cfg = dcam_path0_cfg; + } else if (DCAM_PATH1 == channel_id) { + path_cfg = dcam_path1_cfg; + }else if (DCAM_PATH2 == channel_id) { + path_cfg = dcam_path2_cfg; + } + + if (dev->dcam_cxt.is_smooth_zoom && DCAM_PATH0 != channel_id) { + dev->zoom_level = 1; + dev->channel_id = channel_id; + if (0 == path->in_rect_backup.w || 0 == path->in_rect_backup.h) { + path->in_rect_backup.x = 0; + path->in_rect_backup.y = 0; + path->in_rect_backup.w = path->in_size.w; + path->in_rect_backup.h = path->in_size.h; + memcpy((void*)&path->in_rect_current, (void*)&path->in_rect_backup, sizeof(struct dcam_rect)); + } else { + memcpy((void*)&path->in_rect_backup, (void*)&path->in_rect_current, sizeof(struct dcam_rect)); + } + + DCAM_TRACE("SPRD_IMG: in_size{%d %d}, in_rect{%d %d %d %d}, in_rect_backup{%d %d %d %d}, out_size{%d %d}\n", + path->in_size.w, + path->in_size.h, + path->in_rect.x, + path->in_rect.y, + path->in_rect.w, + path->in_rect.h, + path->in_rect_backup.x, + path->in_rect_backup.y, + path->in_rect_backup.w, + path->in_rect_backup.h, + path->out_size.w, + path->out_size.h); + } else { + DCAM_TRACE("SPRD_IMG: in_size{%d %d}, in_rect{%d %d %d %d}, out_size{%d %d}\n", + path->in_size.w, + path->in_size.h, + path->in_rect.x, + path->in_rect.y, + path->in_rect.w, + path->in_rect.h, + path->out_size.w, + path->out_size.h); + ret = dcam_update_path(path_index, &path->in_size, &path->in_rect, &path->out_size); + } + + mutex_unlock(&dev->dcam_mutex); + DCAM_TRACE("SPRD_IMG: update video 0x%x \n", ret); + if (ret) { + printk("SPRD_IMG: Failed to update video 0x%x \n", ret); + } + + return ret; +} + +LOCAL int sprd_img_streampause(struct file *file, uint32_t channel_id, uint32_t reconfig_flag) +{ + struct dcam_dev *dev = file->private_data; + struct dcam_path_spec *path = NULL; + int ret = 0; + enum dcam_path_index path_index; + + printk("SPRD_IMG: pause, channel %d ,recfg flag %d\n", channel_id, reconfig_flag); + + path = &dev->dcam_cxt.dcam_path[channel_id]; + path_index = sprd_img_get_path_index(channel_id); + + if (PATH_RUN == path->status) { + path->status = PATH_IDLE; + ret = dcam_stop_path(path_index); + IMG_PRINT_IF_ERR(ret); + if ((reconfig_flag)/* && (DCAM_PATH2 == channel_id)*/) { + //path->is_work = 0; + path->frm_cnt_act = 0; + sprd_img_buf_queue_init(&path->buf_queue); + sprd_img_queue_disable(&dev->queue, channel_id); + ret = sprd_img_unreg_path2_isr(dev); + IMG_PRINT_IF_ERR(ret); + } + + if (DCAM_PATH2 == channel_id && dev->got_resizer) { + dcam_rel_resizer(); + dev->got_resizer = 0; + } + printk("SPRD_IMG: pause, channel=%d done \n", channel_id); + } else { + printk("SPRD_IMG: pause, path %d not running, status=%d \n", + channel_id, path->status); + } + + return ret; +} + +LOCAL int sprd_img_streamresume(struct file *file, uint32_t channel_id) +{ + struct dcam_dev *dev = NULL; + struct dcam_path_spec *path = NULL; + enum dcam_path_index path_index; + path_cfg_func path_cfg; + int ret = 0; + int on_flag = 1; + + DCAM_TRACE("SPRD_IMG: resume, channel=%d \n", channel_id); + + dev = file->private_data; + if (!dev) { + printk("SPRD_IMG: dev is NULL \n"); + return -EFAULT; + } + + path = &dev->dcam_cxt.dcam_path[channel_id]; + path_index = sprd_img_get_path_index(channel_id); + + if (unlikely(0 == atomic_read(&dev->stream_on))) { + printk("SPRD_IMG: resume stream not on\n"); + ret = sprd_img_local_deinit(dev); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + } + on_flag = 0; + } + if (PATH_IDLE == path->status && on_flag) { + if (path->is_work) { + if (DCAM_PATH0 == channel_id) { + path_cfg = dcam_path0_cfg; + } else if (DCAM_PATH1 == channel_id) { + path_cfg = dcam_path1_cfg; + } else if (DCAM_PATH2 == channel_id) { + if (0 == dev->got_resizer) { + /* if not owned resiezer, try to get it */ + if (unlikely(dcam_get_resizer(DCAM_WAIT_FOREVER))) { + /*no wait to get the controller of resizer, failed*/ + printk("SPRD_IMG: resume, path2 has been occupied by other app \n"); + return -EIO; + } + dev->got_resizer = 1; + } + ret = sprd_img_reg_path2_isr(dev); + IMG_PRINT_IF_ERR(ret); + path_cfg = dcam_path2_cfg; + } else { + printk("SPRD_IMG: resume, invalid channel_id=0x%x \n", channel_id); + return -EINVAL; + } + + if (DCAM_PATH0 == channel_id) { + ret = sprd_img_path0_cfg(path_cfg, path); + } else { + ret = sprd_img_path_cfg(path_cfg, path); + } + sprd_img_queue_enable(&dev->queue, channel_id); + IMG_RTN_IF_ERR(ret); + ret = dcam_start_path(path_index); + IMG_PRINT_IF_ERR(ret); + + path->status = PATH_RUN; + }else{ + DCAM_TRACE("SPRD_IMG: resume, path %d no parameter, is_work=%d, cannot resume \n", + channel_id, path->is_work); + } + }else{ + DCAM_TRACE("SPRD_IMG: resume, path %d not idle, status=%d, cannot resume \n", + channel_id, path->status); + } +exit: + if (ret) { + DCAM_TRACE("SPRD_IMG: fail resume, path %d, ret = 0x%x\n", channel_id, ret); + } + return ret; +} + +LOCAL void sprd_img_print_reg(void) +{ + uint32_t* reg_buf = NULL; + uint32_t reg_buf_len = 0x400; + int ret; + uint32_t print_len = 0, print_cnt = 0; + + reg_buf = (uint32_t*)vzalloc(reg_buf_len); + if (NULL == reg_buf) + return; + + ret = dcam_read_registers(reg_buf, ®_buf_len); + if (ret) { + vfree(reg_buf); + return; + } + + mm_clk_register_trace(); + printk("dcam registers \n"); + while (print_len < reg_buf_len) { + printk("offset 0x%03x : 0x%08x, 0x%08x, 0x%08x, 0x%08x \n", + print_len, + reg_buf[print_cnt], + reg_buf[print_cnt+1], + reg_buf[print_cnt+2], + reg_buf[print_cnt+3]); + print_cnt += 4; + print_len += 16; + } +#if 0 + ret = csi_read_registers(reg_buf, ®_buf_len); + if (ret) { + vfree(reg_buf); + return; + } + + print_len = 0; + print_cnt = 0; + printk("csi registers \n"); + while (print_len < reg_buf_len) { + printk("offset 0x%3x : 0x%8x, 0x%8x, 0x%8x, 0x%8x \n", + print_len, + reg_buf[print_cnt], + reg_buf[print_cnt+1], + reg_buf[print_cnt+2], + reg_buf[print_cnt+3]); + print_cnt += 4; + print_len += 16; + } +#endif + udelay(1); + vfree(reg_buf); + + return; + +} +LOCAL void sprd_timer_callback(unsigned long data) +{ + struct dcam_dev *dev = (struct dcam_dev*)data; + struct dcam_node node; + int ret = 0; + + DCAM_TRACE("SPRD_IMG: sprd_timer_callback \n"); + + if (0 == data || 0 == atomic_read(&dev->stream_on)) { + printk("SPRD_IMG: timer cb error \n"); + return; + } + + if (0 == atomic_read(&dev->run_flag)) { + printk("DCAM timeout.\n"); + node.irq_flag = IMG_TIMEOUT; + node.invalid_flag = 0; + ret = sprd_img_queue_write(&dev->queue, &node); + if (ret) { + printk("SPRD_IMG: timer cb write queue error \n"); + } + up(&dev->irq_sem); + } +} +LOCAL int sprd_init_timer(struct timer_list *dcam_timer, unsigned long data) +{ + int ret = 0; + + setup_timer(dcam_timer, sprd_timer_callback, data); + return ret; +} +LOCAL int sprd_start_timer(struct timer_list *dcam_timer, uint32_t time_val) +{ + int ret = 0; + + DCAM_TRACE("SPRD_IMG: starting timer %ld \n",jiffies); + ret = mod_timer(dcam_timer, jiffies + msecs_to_jiffies(time_val)); + if (ret) { + printk("SPRD_IMG: Error in mod_timer %d \n",ret); + } + return ret; +} + +LOCAL int sprd_stop_timer(struct timer_list *dcam_timer) +{ + int ret = 0; + + DCAM_TRACE("SPRD_IMG: stop timer \n"); + del_timer_sync(dcam_timer); + return ret; +} + +LOCAL int sprd_init_handle(struct dcam_dev *dev) +{ + struct dcam_info *info = &dev->dcam_cxt; + struct dcam_path_spec *path; + uint32_t i = 0; + + if (NULL == info) { + printk("SPRD_IMG: init handle fail \n"); + return -EINVAL; + } + info->flash_status = FLASH_STATUS_MAX; + info->after_af = 0; + for (i = 0; i < DCAM_PATH_MAX; i++) { + path = &info->dcam_path[i]; + if (NULL == path) { + printk("SPRD_IMG: init path %d fail \n", i); + return -EINVAL; + } + memset((void*)path->frm_ptr, + 0, + (uint32_t)(DCAM_FRM_CNT_MAX * sizeof(struct dcam_frame*))); + path->frm_cnt_act = 0; + sprd_img_buf_queue_init(&path->buf_queue); + path->status = PATH_IDLE; + } + atomic_set(&dev->stream_on, 0); + dev->got_resizer = 0; + return 0; +} + +LOCAL int sprd_img_k_open(struct inode *node, struct file *file) +{ + struct dcam_dev *dev = NULL; + struct miscdevice *md = file->private_data; + int ret = 0; + + dev = vzalloc(sizeof(*dev)); + if (!dev) { + ret = -ENOMEM; + printk("sprd_img_k_open fail alloc \n"); + return ret; + } + + mutex_init(&dev->dcam_mutex); + sema_init(&dev->irq_sem, 0); + + if (unlikely(atomic_inc_return(&dev->users) > 1)) { + ret = -EBUSY; + goto exit; + } + + DCAM_TRACE("sprd_img_k_open \n"); + ret = dcam_module_en(md->this_device->of_node); + if (unlikely(ret != 0)) { + printk("SPRD_IMG: Failed to enable dcam module \n"); + ret = -EIO; + goto exit; + } + + ret = sprd_img_queue_init(&dev->queue); + if (unlikely(ret != 0)) { + printk("SPRD_IMG: Failed to init queue \n"); + ret = -EIO; + goto exit; + } + + ret = sprd_init_timer(&dev->dcam_timer,(unsigned long)dev); + if (unlikely(ret != 0)) { + printk("SPRD_IMG: Failed to init timer \n"); + ret = -EIO; + goto exit; + } + + ret = sprd_init_handle(dev); + if (unlikely(ret != 0)) { + printk("SPRD_IMG: Failed to init queue \n"); + ret = -EIO; + goto exit; + } + + ret = dcam_create_flash_thread(dev); + if (unlikely(ret != 0)) { + printk("SPRD_IMG: Failed to create flash thread \n"); + ret = -EIO; + goto exit; + } + + ret = sprd_img_create_zoom_thread(dev); + if (unlikely(ret != 0)) { + printk("SPRD_IMG: Failed to create zoom thread \n"); + ret = -EIO; + goto exit; + } + + dev->driver_data = (void*)md; + file->private_data = (void*)dev; + +exit: + if (unlikely(ret)) { + atomic_dec(&dev->users); + } else { +#if 0 + dev->proc_file = create_proc_read_entry(DCAM_PROC_FILE_NAME, + 0444, + NULL, + sprd_img_proc_read, + (void*)dev); + if (unlikely(NULL == dev->proc_file)) { + printk("SPRD_IMG: Can't create an entry for video0 in /proc \n"); + ret = ENOMEM; + } +#endif + } + + DCAM_TRACE("sprd_img_k_open %d \n", ret); + return ret; +} + +static int sprd_img_k_release(struct inode *node, struct file *file) +{ + struct dcam_dev *dev = NULL; + struct miscdevice *md = NULL; + int ret = 0; + + DCAM_TRACE("SPRD_IMG: Close start\n"); +#if 0 + if (dev->proc_file) { + DCAM_TRACE("SPRD_IMG: sprd_img_k_release \n"); + remove_proc_entry(DCAM_PROC_FILE_NAME, NULL); + dev->proc_file = NULL; + } +#endif + + dev = file->private_data; + if (!dev) + goto exit; + + md = dev->driver_data; + + mutex_lock(&dev->dcam_mutex); + dcam_reset(DCAM_RST_ALL, 0); + if (dev->got_resizer) { + dcam_rel_resizer(); + dev->got_resizer = 0; + sprd_img_unreg_path2_isr(dev); + } + + atomic_set(&dev->stream_on, 0); + dcam_module_deinit(dev->dcam_cxt.if_mode, dev->dcam_cxt.sn_mode); + sprd_img_local_deinit(dev); + sema_init(&dev->irq_sem, 0); + ret = dcam_module_dis(md->this_device->of_node); + if (unlikely(0 != ret)) { + printk("SPRD_IMG: Failed to enable dcam module \n"); + ret = -EIO; + } + sprd_stop_timer(&dev->dcam_timer); + atomic_dec(&dev->users); + dcam_stop_flash_thread(dev); + sprd_img_stop_zoom_thread(dev); + mutex_unlock(&dev->dcam_mutex); + + vfree(dev); + dev = NULL; + file->private_data = NULL; + +exit: + DCAM_TRACE("SPRD_IMG: Close end.\n"); + return ret; +} + +static long sprd_img_k_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +{ + struct dcam_dev *dev = NULL; + struct dcam_info *info = NULL; + uint32_t path_cnt; + uint32_t channel_id; + uint32_t mode; + uint32_t skip_num; + uint32_t freq_flag; + uint32_t flash_status; + uint32_t zoom; + struct sprd_img_parm parm; + struct sprd_img_size size; + struct sprd_img_rect rect; + struct dcam_path_spec *path = NULL; + struct dcam_rect *input_rect; + struct dcam_size *input_size; + path_cfg_func path_cfg; + int ret = DCAM_RTN_SUCCESS; + + DCAM_TRACE("sprd_img_k_ioctl: cmd: 0x%x \n", cmd); + + dev = file->private_data; + if (!dev) { + ret = -EFAULT; + printk("sprd_img_k_ioctl: dev is NULL \n"); + goto exit; + } + + info = &dev->dcam_cxt; + + switch (cmd) { + case SPRD_IMG_IO_SET_MODE: + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&mode, (uint32_t *)arg, sizeof(uint32_t)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + dev->dcam_cxt.capture_mode = mode; + mutex_unlock(&dev->dcam_mutex); + DCAM_TRACE("SPRD_IMG: capture mode %d \n", dev->dcam_cxt.capture_mode); + break; + + case SPRD_IMG_IO_SET_FREQ_FLAG: + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&freq_flag, (uint32_t *)arg, sizeof(uint32_t)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } +#ifdef CONFIG_CPLL_1024M + dcam_set_highclk_flag(freq_flag); +#endif + mutex_unlock(&dev->dcam_mutex); + DCAM_TRACE("SPRD_IMG: freq flag %d \n", freq_flag); + break; + + case SPRD_IMG_IO_SET_SKIP_NUM: + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&skip_num, (uint32_t *)arg, sizeof(uint32_t)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + dev->dcam_cxt.skip_number = skip_num; + mutex_unlock(&dev->dcam_mutex); + DCAM_TRACE("SPRD_IMG: cap skip number %d \n", dev->dcam_cxt.skip_number); + break; + + case SPRD_IMG_IO_SET_SENSOR_SIZE: + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&size, (struct sprd_img_size *)arg, sizeof(struct sprd_img_size)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + dev->dcam_cxt.cap_in_size.w = size.w; + dev->dcam_cxt.cap_in_size.h = size.h; + mutex_unlock(&dev->dcam_mutex); + DCAM_TRACE("SPRD_IMG: sensor size %d %d \n", + dev->dcam_cxt.cap_in_size.w, + dev->dcam_cxt.cap_in_size.h); + break; + + case SPRD_IMG_IO_SET_SENSOR_TRIM: + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&rect, (struct sprd_img_rect *)arg, sizeof(struct sprd_img_rect)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + dev->dcam_cxt.cap_in_rect.x = rect.x; + dev->dcam_cxt.cap_in_rect.y = rect.y; + dev->dcam_cxt.cap_in_rect.w = rect.w; + dev->dcam_cxt.cap_in_rect.h = rect.h; + + dev->dcam_cxt.cap_out_size.w = dev->dcam_cxt.cap_in_rect.w; + dev->dcam_cxt.cap_out_size.h = dev->dcam_cxt.cap_in_rect.h; + mutex_unlock(&dev->dcam_mutex); + DCAM_TRACE("SPRD_IMG: sensor trim x y w h %d %d %d %d\n", + dev->dcam_cxt.cap_in_rect.x, + dev->dcam_cxt.cap_in_rect.y, + dev->dcam_cxt.cap_in_rect.w, + dev->dcam_cxt.cap_in_rect.h); + break; + + case SPRD_IMG_IO_SET_FRM_ID_BASE: + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&parm, (struct sprd_img_parm *)arg, sizeof(struct sprd_img_parm)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + switch (parm.channel_id) { + case DCAM_PATH0: + case DCAM_PATH1: + case DCAM_PATH2: + dev->dcam_cxt.dcam_path[parm.channel_id].frm_id_base = parm.frame_base_id; + break; + default: + printk("SPRD_IMG: Wrong channel ID, %d \n", parm.channel_id); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + mutex_unlock(&dev->dcam_mutex); + DCAM_TRACE("SPRD_IMG: channel %d, base id 0x%x \n", + parm.channel_id, + parm.frame_base_id); + break; + + case SPRD_IMG_IO_SET_CROP: + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&parm, (struct sprd_img_parm *)arg, sizeof(struct sprd_img_parm)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + + if (unlikely(parm.crop_rect.x + parm.crop_rect.w > dev->dcam_cxt.cap_in_size.w || + parm.crop_rect.y + parm.crop_rect.h > dev->dcam_cxt.cap_in_size.h)) { + mutex_unlock(&dev->dcam_mutex); + ret = -EINVAL; + goto exit; + } + + DCAM_TRACE("SPRD_IMG: SPRD_IMG_IO_SET_CROP, window %d %d %d %d \n", + parm.crop_rect.x, + parm.crop_rect.y, + parm.crop_rect.w, + parm.crop_rect.h); + + switch (parm.channel_id) { + case DCAM_PATH0: + case DCAM_PATH1: + case DCAM_PATH2: + input_size = &dev->dcam_cxt.dcam_path[parm.channel_id].in_size; + input_rect = &dev->dcam_cxt.dcam_path[parm.channel_id].in_rect; + break; + default: + printk("SPRD_IMG: Wrong channel ID, %d \n", parm.channel_id); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + + input_size->w = dev->dcam_cxt.cap_out_size.w; + input_size->h = dev->dcam_cxt.cap_out_size.h; + input_rect->x = parm.crop_rect.x; + input_rect->y = parm.crop_rect.y; + input_rect->w = parm.crop_rect.w; + input_rect->h = parm.crop_rect.h; + + DCAM_TRACE("SPRD_IMG: SPRD_IMG_IO_SET_CROP, Path %d, cap crop: cap_rect %d %d %d %d, cap_out:%d %d \n", + parm.channel_id, input_rect->x, input_rect->y, + input_rect->w, input_rect->h, + input_size->w, input_size->h); + mutex_unlock(&dev->dcam_mutex); + break; + + case SPRD_IMG_IO_SET_FLASH: + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&flash_status, (uint32_t *)arg, sizeof(uint32_t)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + dev->dcam_cxt.flash_status = flash_status; + mutex_unlock(&dev->dcam_mutex); + if ((dev->dcam_cxt.flash_status == FLASH_CLOSE_AFTER_OPEN) + || (dev->dcam_cxt.flash_status == FLASH_CLOSE) + || (dev->dcam_cxt.flash_status == FLASH_CLOSE_AFTER_AUTOFOCUS)) { + up(&dev->flash_thread_sem); + } + DCAM_TRACE("SPRD_IMG: SPRD_IMG_IO_SET_FLASH, flash status %d \n", dev->dcam_cxt.flash_status); + break; + + case SPRD_IMG_IO_SET_OUTPUT_SIZE: + DCAM_TRACE("SPRD_IMG: set output size \n"); + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&parm, (struct sprd_img_parm *)arg, sizeof(struct sprd_img_parm)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + dev->dcam_cxt.dst_size.w = parm.dst_size.w; + dev->dcam_cxt.dst_size.h = parm.dst_size.h; + dev->dcam_cxt.pxl_fmt = parm.pixel_fmt; + dev->dcam_cxt.need_isp_tool = parm.need_isp_tool; + dev->dcam_cxt.need_isp = parm.need_isp; + dev->dcam_cxt.need_shrink = parm.shrink; + dev->dcam_cxt.path_input_rect.x = parm.crop_rect.x; + dev->dcam_cxt.path_input_rect.y = parm.crop_rect.y; + dev->dcam_cxt.path_input_rect.w = parm.crop_rect.w; + dev->dcam_cxt.path_input_rect.h = parm.crop_rect.h; + mutex_unlock(&dev->dcam_mutex); + break; + + case SPRD_IMG_IO_SET_ZOOM_MODE: + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&zoom, (uint32_t *)arg, sizeof(uint32_t)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + dev->dcam_cxt.is_smooth_zoom = zoom; + mutex_unlock(&dev->dcam_mutex); + DCAM_TRACE("SPRD_IMG: SPRD_IMG_IO_SET_ZOOM_MODE, zoom mode %d \n", dev->dcam_cxt.is_smooth_zoom); + break; + + case SPRD_IMG_IO_SET_SENSOR_IF: + { + struct sprd_img_sensor_if sensor_if; + + DCAM_TRACE("SPRD_IMG: set sensor if \n"); + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&sensor_if, (struct sprd_img_sensor_if *)arg, sizeof(struct sprd_img_sensor_if)); + if (unlikely(ret)) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + + if (IF_OPEN == sensor_if.res[0]) { + dev->dcam_cxt.if_mode = sensor_if.if_type; + dev->dcam_cxt.sn_mode = sensor_if.img_fmt; + dev->dcam_cxt.yuv_ptn = sensor_if.img_ptn; + dev->dcam_cxt.frm_deci = sensor_if.frm_deci; + + DCAM_TRACE("SPRD_IMG: interface %d, mode %d frm_deci %d \n", + dev->dcam_cxt.if_mode, + dev->dcam_cxt.sn_mode, + dev->dcam_cxt.frm_deci); + + if (DCAM_CAP_IF_CCIR == dev->dcam_cxt.if_mode) { + /* CCIR interface */ + dev->dcam_cxt.sync_pol.vsync_pol = sensor_if.if_spec.ccir.v_sync_pol; + dev->dcam_cxt.sync_pol.hsync_pol = sensor_if.if_spec.ccir.h_sync_pol; + dev->dcam_cxt.sync_pol.pclk_pol = sensor_if.if_spec.ccir.pclk_pol; + dev->dcam_cxt.data_bits = 8; + DCAM_TRACE("SPRD_IMG: CIR interface, vsync %d hsync %d pclk %d psrc %d bits %d \n", + dev->dcam_cxt.sync_pol.vsync_pol, + dev->dcam_cxt.sync_pol.hsync_pol, + dev->dcam_cxt.sync_pol.pclk_pol, + dev->dcam_cxt.sync_pol.pclk_src, + dev->dcam_cxt.data_bits); + } else { + dev->dcam_cxt.sync_pol.need_href = sensor_if.if_spec.mipi.use_href; + dev->dcam_cxt.is_loose = sensor_if.if_spec.mipi.is_loose; + dev->dcam_cxt.data_bits = sensor_if.if_spec.mipi.bits_per_pxl; + dev->dcam_cxt.lane_num = sensor_if.if_spec.mipi.lane_num; + dev->dcam_cxt.pclk = sensor_if.if_spec.mipi.pclk; + DCAM_TRACE("SPRD_IMG: MIPI interface, ref %d is_loose %d bits %d lanes %d pclk %d\n", + dev->dcam_cxt.sync_pol.need_href, + dev->dcam_cxt.is_loose, + dev->dcam_cxt.data_bits, + dev->dcam_cxt.lane_num, + dev->dcam_cxt.pclk); + } + } + mutex_unlock(&dev->dcam_mutex); + break; + } + + case SPRD_IMG_IO_SET_FRAME_ADDR: + DCAM_TRACE("SPRD_IMG: set frame addr \n"); + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&parm, (struct sprd_img_parm *)arg, sizeof(struct sprd_img_parm)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + + switch (parm.channel_id) { + case DCAM_PATH0: + path = &info->dcam_path[DCAM_PATH0]; + path_cnt = DCAM_PATH_0_FRM_CNT_MAX; + path_cfg = dcam_path0_cfg; + break; + case DCAM_PATH1: + path = &info->dcam_path[DCAM_PATH1]; + path_cnt = DCAM_PATH_1_FRM_CNT_MAX; + path_cfg = dcam_path1_cfg; + break; + case DCAM_PATH2: + path = &info->dcam_path[DCAM_PATH2]; + path_cnt = DCAM_PATH_2_FRM_CNT_MAX; + path_cfg = dcam_path2_cfg; + break; + default: + printk("SPRD_IMG error: SPRD_IMG_IO_SET_FRAME_ADDR, path 0x%x \n", parm.channel_id); + mutex_unlock(&dev->dcam_mutex); + return -EINVAL; + } + + + DCAM_TRACE("SPRD_IMG: SPRD_IMG_IO_SET_FRAME_ADDR, status %d, frm_cnt_act %d \n", + path->status, path->frm_cnt_act); + + if (unlikely(0 == parm.frame_addr.y)) { + printk("SPRD_IMG: No yaddr \n"); + mutex_unlock(&dev->dcam_mutex); + ret = -EINVAL; + } else { + if (1 == parm.is_reserved_buf) { + path->frm_reserved_addr.yaddr = parm.frame_addr.y; + path->frm_reserved_addr.uaddr = parm.frame_addr.u; + path->frm_reserved_addr.vaddr = parm.frame_addr.v; + path->frm_reserved_addr_vir.yaddr = parm.frame_addr_vir.y; + path->frm_reserved_addr_vir.uaddr = parm.frame_addr_vir.u; + path->frm_reserved_addr_vir.vaddr = parm.frame_addr_vir.v; + } else { + struct dcam_addr frame_addr; + struct dcam_img_buf_addr buf_addr; + + frame_addr.yaddr = parm.frame_addr.y; + frame_addr.uaddr = parm.frame_addr.u; + frame_addr.vaddr = parm.frame_addr.v; + frame_addr.yaddr_vir = parm.frame_addr_vir.y; + frame_addr.uaddr_vir = parm.frame_addr_vir.u; + frame_addr.vaddr_vir = parm.frame_addr_vir.v; + + DCAM_TRACE("SPRD_IMG: SPRD_IMG_IO_SET_FRAME_ADDR, yaddr: 0x%x, uaddr: 0x%x, vaddr: 0x%x\n", + parm.frame_addr.y, + parm.frame_addr.u, + parm.frame_addr.v); + + if (unlikely(1 == atomic_read(&dev->stream_on)) && path->status == PATH_RUN) { + ret = path_cfg(DCAM_PATH_OUTPUT_ADDR, &frame_addr); + } else { + buf_addr.frm_addr.yaddr = parm.frame_addr.y; + buf_addr.frm_addr.uaddr = parm.frame_addr.u; + buf_addr.frm_addr.vaddr = parm.frame_addr.v; + buf_addr.frm_addr_vir.yaddr = parm.frame_addr_vir.y; + buf_addr.frm_addr_vir.uaddr = parm.frame_addr_vir.u; + buf_addr.frm_addr_vir.vaddr = parm.frame_addr_vir.v; + ret = sprd_img_buf_queue_write(&path->buf_queue, &buf_addr); + } + } + } + mutex_unlock(&dev->dcam_mutex); + break; + + case SPRD_IMG_IO_PATH_FRM_DECI: + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&parm, (struct sprd_img_parm *)arg, sizeof(struct sprd_img_parm)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + path = &dev->dcam_cxt.dcam_path[parm.channel_id]; + path->path_frm_deci = 0;//parm.deci; // aiden tmp changes + mutex_unlock(&dev->dcam_mutex); + DCAM_TRACE("SPRD_IMG: channel %d, frm_deci=%d \n", parm.channel_id, path->path_frm_deci); + break; + + case SPRD_IMG_IO_SET_SHRINK: + mutex_lock(&dev->dcam_mutex); + ret = copy_from_user(&parm, (struct sprd_img_parm *)arg, sizeof(struct sprd_img_parm)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + path = &dev->dcam_cxt.dcam_path[parm.channel_id]; + path->shrink = parm.shrink; + mutex_unlock(&dev->dcam_mutex); + DCAM_TRACE("SPRD_IMG: channel %d, shrink=%d \n", parm.channel_id, path->shrink); + break; + + case SPRD_IMG_IO_PATH_PAUSE: + ret = copy_from_user(&parm, (struct sprd_img_parm *)arg, sizeof(struct sprd_img_parm)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + goto exit; + } + sprd_img_streampause(file, parm.channel_id, parm.reserved[0]); + break; + + case SPRD_IMG_IO_PATH_RESUME: + ret = copy_from_user(&channel_id, (uint32_t *)arg, sizeof(uint32_t)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + goto exit; + } + sprd_img_streamresume(file, channel_id); + break; + + case SPRD_IMG_IO_STREAM_ON: + { + struct dcam_path_spec *path_0 = NULL; + struct dcam_path_spec *path_1 = NULL; + struct dcam_path_spec *path_2 = NULL; + + DCAM_TRACE("SPRD_IMG: SPRD_IMG_IO_STREAM_ON \n"); + + mutex_lock(&dev->dcam_mutex); + + path_0 = &dev->dcam_cxt.dcam_path[DCAM_PATH0]; + path_1 = &dev->dcam_cxt.dcam_path[DCAM_PATH1]; + path_2 = &dev->dcam_cxt.dcam_path[DCAM_PATH2]; + memset((void*)path_0->frm_ptr, + 0, + (uint32_t)(DCAM_FRM_CNT_MAX * sizeof(struct dcam_frame*))); + memset((void*)path_1->frm_ptr, + 0, + (uint32_t)(DCAM_FRM_CNT_MAX * sizeof(struct dcam_frame*))); + memset((void*)path_2->frm_ptr, + 0, + (uint32_t)(DCAM_FRM_CNT_MAX * sizeof(struct dcam_frame*))); + + DCAM_TRACE("SPRD_IMG: streamon, is_work: path_0 = %d, path_1 = %d, path_2 = %d, stream_on = %d \n", + path_0->is_work, path_1->is_work, path_2->is_work, atomic_read(&dev->stream_on)); + + memset((void*)&path_1->in_rect_backup, 0x00, sizeof(struct dcam_rect)); + memset((void*)&path_1->in_rect_current, 0x00, sizeof(struct dcam_rect)); + + do { + /* dcam driver module initialization */ + ret = dcam_module_init(dev->dcam_cxt.if_mode, dev->dcam_cxt.sn_mode); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + + ret = sprd_img_queue_init(&dev->queue); + if (unlikely(ret != 0)) { + printk("SPRD_IMG: Failed to init queue \n"); + break; + } + + if (path_0->is_work || path_1->is_work || path_2->is_work) { + ret = sprd_img_reg_isr(dev); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + } + /* config cap sub-module */ + ret = sprd_img_cap_cfg(&dev->dcam_cxt); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + + /* config path1 sub-module if necessary*/ + if (path_1->is_work) { + ret = sprd_img_path_cfg(dcam_path1_cfg, path_1); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + path_1->status = PATH_RUN; + } else { + ret = dcam_path1_cfg(DCAM_PATH_ENABLE, &path_1->is_work); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + } + + /* config path2 sub-module if necessary*/ + if (path_2->is_work) { + ret = sprd_img_path_cfg(dcam_path2_cfg, path_2); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + ret = sprd_img_reg_path2_isr(dev); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + path_2->status = PATH_RUN; + } else { + ret = dcam_path2_cfg(DCAM_PATH_ENABLE, &path_2->is_work); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + } + + if (path_0->is_work) { + ret = sprd_img_path0_cfg(dcam_path0_cfg, path_0); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + path_0->status = PATH_RUN; + } else { + ret = dcam_path0_cfg(DCAM_PATH_ENABLE, &path_0->is_work); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + } + } while(0); + dev->frame_skipped = 0; + if (FLASH_HIGH_LIGHT == dev->dcam_cxt.flash_status) { + if (0 == dev->dcam_cxt.skip_number) { + sprd_img_start_flash(NULL, dev); + } + } + + ret = dcam_start(); + atomic_set(&dev->stream_on, 1); + + if (ret) { + sprd_img_unreg_path2_isr(dev); + sprd_img_unreg_isr(dev); + printk("SPRD_IMG: Failed to start stream 0x%x \n", ret); + } else { + atomic_set(&dev->run_flag, 0); + if (path_0->is_work || path_1->is_work || path_2->is_work) { + sprd_start_timer(&dev->dcam_timer, DCAM_TIMEOUT); + } + } + + mutex_unlock(&dev->dcam_mutex); + break; + } + + case SPRD_IMG_IO_STREAM_OFF: + { + struct dcam_path_spec *path_0 = NULL; + struct dcam_path_spec *path_1 = NULL; + struct dcam_path_spec *path_2 = NULL; + + DCAM_TRACE("SPRD_IMG: SPRD_IMG_IO_STREAM_OFF \n"); + + mutex_lock(&dev->dcam_mutex); + + path_0 = &dev->dcam_cxt.dcam_path[DCAM_PATH0]; + path_1 = &dev->dcam_cxt.dcam_path[DCAM_PATH1]; + path_2 = &dev->dcam_cxt.dcam_path[DCAM_PATH2]; + + DCAM_TRACE("SPRD_IMG: streamoff, is_work: path_0 = %d, path_1 = %d, path_2 = %d, stream_on = %d \n", + path_0->is_work, path_1->is_work, path_2->is_work, atomic_read(&dev->stream_on)); + + if (unlikely(0 == atomic_read(&dev->stream_on))) { + printk("SPRD_IMG: stream not on\n"); + ret = sprd_img_local_deinit(dev); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + } + mutex_unlock(&dev->dcam_mutex); + goto exit; + } + + do { + ret = sprd_stop_timer(&dev->dcam_timer); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + ret = dcam_stop(); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + + ret = dcam_stop_cap(); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + + ret = sprd_img_unreg_isr(dev); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + + if (path_1->is_work) { + path_1->status = PATH_IDLE; + path_1->is_work = 0; + } + + if (path_2->is_work) { + path_2->status = PATH_IDLE; + + if (dev->got_resizer) { + ret = sprd_img_unreg_path2_isr(dev); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + dcam_rel_resizer(); + dev->got_resizer = 0; + } + + path_2->is_work = 0; + } + + if (path_0->is_work) { + path_0->status = PATH_IDLE; + path_0->is_work = 0; + } + DCAM_TRACE("SPRD_IMG: off, path work %d %d %d \n", path_0->is_work, path_1->is_work, path_2->is_work); + atomic_set(&dev->stream_on, 0); + #if 0 + if (DCAM_CAP_IF_CSI2 == dev->dcam_cxt.if_mode) { + ret = csi_api_close(); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + } + #endif + + ret = dcam_module_deinit(dev->dcam_cxt.if_mode, dev->dcam_cxt.sn_mode); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + + ret = sprd_img_local_deinit(dev); + if (unlikely(ret)) { + printk(DEBUG_STR,DEBUG_ARGS); + break; + } + } while(0); + + mutex_unlock(&dev->dcam_mutex); + break; + } + + case SPRD_IMG_IO_GET_FMT: + { + struct dcam_format *fmt; + struct sprd_img_get_fmt fmt_desc; + + DCAM_TRACE("SPRD_IMG: SPRD_IMG_IO_GET_FMT \n"); + ret = copy_from_user(&fmt_desc, (struct sprd_img_get_fmt *)arg, sizeof(struct sprd_img_get_fmt)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + goto exit; + } + if (unlikely(fmt_desc.index >= ARRAY_SIZE(dcam_img_fmt))) + return -EINVAL; + + fmt = &dcam_img_fmt[fmt_desc.index]; + fmt_desc.fmt = fmt->fourcc; + + ret = copy_to_user((struct sprd_img_get_fmt *)arg, &fmt_desc, sizeof(struct sprd_img_get_fmt)); + break; + } + + case SPRD_IMG_IO_GET_CH_ID: + { + struct dcam_path_spec *path_0 = NULL; + struct dcam_path_spec *path_1 = NULL; + struct dcam_path_spec *path_2 = NULL; + struct dcam_get_path_id path_id; + + DCAM_TRACE("SPRD_IMG: SPRD_IMG_IO_GET_CH_ID \n"); + path_0 = &dev->dcam_cxt.dcam_path[DCAM_PATH0]; + path_1 = &dev->dcam_cxt.dcam_path[DCAM_PATH1]; + path_2 = &dev->dcam_cxt.dcam_path[DCAM_PATH2]; + + memset((void*)&path_id, 0, sizeof(struct dcam_get_path_id)); + path_id.input_size.w = dev->dcam_cxt.cap_in_rect.w; + path_id.input_size.h = dev->dcam_cxt.cap_in_rect.h; + path_id.output_size.w = dev->dcam_cxt.dst_size.w; + path_id.output_size.h = dev->dcam_cxt.dst_size.h; + path_id.fourcc = dev->dcam_cxt.pxl_fmt; + path_id.need_isp_tool = dev->dcam_cxt.need_isp_tool; + path_id.need_isp = dev->dcam_cxt.need_isp; + path_id.need_shrink = dev->dcam_cxt.need_shrink; + path_id.input_trim.x = dev->dcam_cxt.path_input_rect.x; + path_id.input_trim.y = dev->dcam_cxt.path_input_rect.y; + path_id.input_trim.w = dev->dcam_cxt.path_input_rect.w; + path_id.input_trim.h = dev->dcam_cxt.path_input_rect.h; + DCAM_TRACE("SPRD_IMG: get param, path work %d %d %d \n", path_0->is_work, path_1->is_work, path_2->is_work); + path_id.is_path_work[DCAM_PATH0] = path_0->is_work; + path_id.is_path_work[DCAM_PATH1] = path_1->is_work; + path_id.is_path_work[DCAM_PATH2] = path_2->is_work; + ret = dcam_get_path_id(&path_id, &channel_id); + ret = copy_to_user((uint32_t *)arg, &channel_id, sizeof(uint32_t)); + DCAM_TRACE("SPRD_IMG: get channel_id %d \n", channel_id); + break; + } + + case SPRD_IMG_IO_GET_TIME: + { + struct timeval time; + struct sprd_img_time utime; + + DCAM_TRACE("SPRD_IMG: SPRD_IMG_IO_GET_TIME \n"); + img_get_timestamp(&time); + utime.sec = time.tv_sec; + utime.usec = time.tv_usec; + ret = copy_to_user((struct sprd_img_time *)arg, &utime, sizeof(struct sprd_img_time)); + break; + } + + case SPRD_IMG_IO_CHECK_FMT: + { + struct dcam_format *fmt; + struct sprd_img_format img_format; + + DCAM_TRACE("SPRD_IMG: SPRD_IMG_IO_CHECK_FMT \n"); + ret = copy_from_user(&img_format, (struct sprd_img_format *)arg, sizeof(struct sprd_img_format)); + if (ret) { + printk("sprd_img_k_ioctl: fail to get user info \n"); + goto exit; + } + + fmt = sprd_img_get_format(img_format.fourcc); + if (unlikely(!fmt)) { + printk("SPRD_IMG: Fourcc format (0x%08x) invalid. \n", + img_format.fourcc); + return -EINVAL; + } + + if (DCAM_PATH1 == img_format.channel_id) { + mutex_lock(&dev->dcam_mutex); + ret = sprd_img_check_path1_cap(fmt->fourcc, &img_format, &dev->dcam_cxt); + mutex_unlock(&dev->dcam_mutex); + channel_id = DCAM_PATH1; + } else if (DCAM_PATH2 == img_format.channel_id) { + if (img_format.is_lightly) { + mutex_lock(&dev->dcam_mutex); + ret = sprd_img_check_path2_cap(fmt->fourcc, &img_format, &dev->dcam_cxt); + mutex_unlock(&dev->dcam_mutex); + } else { + if (unlikely(dcam_get_resizer(DCAM_WAIT_FOREVER))) { + /*no wait to get the controller of resizer, failed*/ + printk("SPRD_IMG: path2 has been occupied by other app \n"); + return -EIO; + } + dev->got_resizer = 1; + mutex_lock(&dev->dcam_mutex); + ret = sprd_img_check_path2_cap(fmt->fourcc, &img_format, &dev->dcam_cxt); + mutex_unlock(&dev->dcam_mutex); + if (ret) { + /*failed to set path2, release the controller of resizer*/ + dcam_rel_resizer(); + dev->got_resizer = 0; + } + } + channel_id = DCAM_PATH2; + } else if (DCAM_PATH0 == img_format.channel_id) { + mutex_lock(&dev->dcam_mutex); + ret = sprd_img_check_path0_cap(fmt->fourcc, &img_format, &dev->dcam_cxt); + mutex_unlock(&dev->dcam_mutex); + channel_id = DCAM_PATH0; + } else { + printk("SPRD_IMG: Buf type invalid. \n"); + return -EINVAL; + } + + memcpy((void*)&img_format.reserved[0], (void*)&dev->dcam_cxt.dcam_path[channel_id].end_sel, sizeof(struct dcam_endian_sel)); + if ((0 == ret) && (0 != atomic_read(&dev->stream_on))) { + if (DCAM_PATH1 == channel_id || DCAM_PATH2 == channel_id) { + ret = sprd_img_update_video(file, channel_id); + } + } + ret = copy_to_user((struct sprd_img_format *)arg, &img_format, sizeof(struct sprd_img_format)); + break; + } + + default: + printk("sprd_img_k_ioctl: invalid cmd %d \n", cmd); + break; + } + + +exit: + return ret; +} + +ssize_t sprd_img_read(struct file *file, char __user *u_data, size_t cnt, loff_t *cnt_ret) +{ + struct dcam_dev *dev = file->private_data; + struct dcam_node node; + struct dcam_path_spec *path; + struct sprd_img_read_op read_op; + struct dcam_path_capability path_capability; + int fmr_index, i; + int ret = 0; + + DCAM_TRACE("SPRD_IMG: sprd_img_read %ld, dev %p \n", cnt, dev); + + if (!dev) + return -EFAULT; + + if (cnt < sizeof(struct sprd_img_read_op)) { + printk("sprd_img_read: error, cnt %ld read_op %ld \n", cnt, sizeof(struct sprd_img_read_op)); + return -EIO; + } + + ret = copy_from_user(&read_op, (struct sprd_img_read_op *)u_data, sizeof(struct sprd_img_read_op)); + if (ret) { + printk("sprd_img_read: fail to get user info \n"); + return ret; + } + + switch (read_op.cmd) { + case SPRD_IMG_GET_SCALE_CAP: + DCAM_TRACE("SPRD_IMG: get scale capbility \n"); + read_op.parm.reserved[0] = DCAM_PATH2_LINE_BUF_LENGTH; + read_op.parm.reserved[1] = DCAM_SC_COEFF_UP_MAX; + read_op.parm.reserved[2] = DCAM_SCALING_THRESHOLD; + DCAM_TRACE("SPRD_IMG: sprd_img_read line threshold %d, sc factor %d, scaling %d.\n", + read_op.parm.reserved[0], + read_op.parm.reserved[1], + read_op.parm.reserved[2]); + break; + + case SPRD_IMG_GET_FRM_BUFFER: + DCAM_TRACE("SPRD_IMG: read frame buffer \n"); + memset(&read_op, 0, sizeof(struct sprd_img_read_op)); + while (1) { + ret = down_interruptible(&dev->irq_sem); + if (0 == ret) { + break; + } else if (-EINTR == ret) { + read_op.evt = IMG_SYS_BUSY; + ret = DCAM_RTN_SUCCESS; + goto read_end; + }else { + printk("SPRD_IMG: read frame buffer, failed to down, %d \n", ret); + return -EPERM; + } + } + + if (sprd_img_queue_read(&dev->queue, &node)) { + printk("SPRD_IMG: read frame buffer, queue is null \n"); + read_op.evt = IMG_SYS_BUSY; + ret = DCAM_RTN_SUCCESS; + goto read_end; + } else { + if (node.invalid_flag) { + printk("SPRD_IMG: read frame buffer, invalid node\n"); + read_op.evt = IMG_SYS_BUSY; + ret = DCAM_RTN_SUCCESS; + goto read_end; + } + } + + DCAM_TRACE("SPRD_IMG: time, %ld %ld \n", (unsigned long)node.time.tv_sec, (unsigned long)node.time.tv_usec); + + read_op.evt = node.irq_flag; + if (IMG_TX_DONE == read_op.evt || IMG_CANCELED_BUF == read_op.evt) { + read_op.parm.frame.channel_id = node.f_type; + path = &dev->dcam_cxt.dcam_path[read_op.parm.frame.channel_id]; + DCAM_TRACE("SPRD_IMG: node, 0x%x %d %d \n", node, node.index, path->frm_id_base); + read_op.parm.frame.index = path->frm_id_base;//node.index; + read_op.parm.frame.height = node.height; + read_op.parm.frame.length = node.reserved; + read_op.parm.frame.sec = node.time.tv_sec; + read_op.parm.frame.usec = node.time.tv_usec; + //fmr_index = node.index - path->frm_id_base; + //read_op.parm.frame.real_index = path->index[fmr_index]; + read_op.parm.frame.frm_base_id = path->frm_id_base; + read_op.parm.frame.img_fmt = path->fourcc; + read_op.parm.frame.yaddr = node.yaddr; + read_op.parm.frame.uaddr = node.uaddr; + read_op.parm.frame.vaddr = node.vaddr; + read_op.parm.frame.yaddr_vir = node.yaddr_vir; + read_op.parm.frame.uaddr_vir = node.uaddr_vir; + read_op.parm.frame.vaddr_vir = node.vaddr_vir; + DCAM_TRACE("index %d real_index %d frm_id_base %d fmr_index %d \n", + read_op.parm.frame.index, + read_op.parm.frame.real_index, + read_op.parm.frame.frm_base_id, + fmr_index); + } else { + if (IMG_TIMEOUT == read_op.evt || + IMG_TX_ERR == read_op.evt) + sprd_img_print_reg(); + } + DCAM_TRACE("SPRD_IMG: read frame buffer, evt 0x%x channel_id 0x%x index 0x%x \n", + read_op.evt, + read_op.parm.frame.channel_id, + read_op.parm.frame.index); + break; + + case SPRD_IMG_GET_PATH_CAP: + DCAM_TRACE("SPRD_IMG: get path capbility \n"); + dcam_get_path_capability(&path_capability); + read_op.parm.capability.count = path_capability.count; + for (i = 0; i< path_capability.count; i++) { + read_op.parm.capability.path_info[i].line_buf = path_capability.path_info[i].line_buf; + read_op.parm.capability.path_info[i].support_yuv = path_capability.path_info[i].support_yuv; + read_op.parm.capability.path_info[i].support_raw = path_capability.path_info[i].support_raw; + read_op.parm.capability.path_info[i].support_jpeg = path_capability.path_info[i].support_jpeg; + read_op.parm.capability.path_info[i].support_scaling = path_capability.path_info[i].support_scaling; + read_op.parm.capability.path_info[i].support_trim = path_capability.path_info[i].support_trim; + read_op.parm.capability.path_info[i].is_scaleing_path = path_capability.path_info[i].is_scaleing_path; + } + break; + + default: + printk("SPRD_IMG: sprd_img_read, invalid cmd \n"); + return EINVAL; + } +read_end: + return copy_to_user((struct sprd_img_read_op *)u_data, &read_op, sizeof(struct sprd_img_read_op)); +} + +ssize_t sprd_img_write(struct file *file, const char __user * u_data, size_t cnt, loff_t *cnt_ret) +{ + struct dcam_dev *dev = file->private_data; + struct dcam_info *info = &dev->dcam_cxt; + struct dcam_path_spec *path; + struct sprd_img_write_op write_op; + uint32_t index; + int ret = 0; + + DCAM_TRACE("SPRD_IMG: sprd_img_write %ld, dev %p \n", cnt, dev); + + if (!dev) + return -EFAULT; + + if (cnt < sizeof(struct sprd_img_write_op)) { + printk("sprd_img_write: error, cnt %ld read_op %ld \n", cnt, sizeof(struct sprd_img_write_op)); + return -EIO; + } + + ret = copy_from_user(&write_op, (struct sprd_img_write_op *)u_data, sizeof(struct sprd_img_write_op)); + if (ret) { + printk("sprd_img_write: fail to get user info \n"); + return ret; + } + + switch (write_op.cmd) { + case SPRD_IMG_STOP_DCAM: + mutex_lock(&dev->dcam_mutex); + ret = sprd_img_tx_stop(dev); + if (ret) + ret = 0; + else + ret = 1; + mutex_unlock(&dev->dcam_mutex); + break; + + case SPRD_IMG_FREE_FRAME: + if (0 == atomic_read(&dev->stream_on)) { + printk("SPRD_IMG: dev close, no need free!"); + break; + } + switch (write_op.channel_id) { + case DCAM_PATH0: + case DCAM_PATH1: + case DCAM_PATH2: + path = &info->dcam_path[write_op.channel_id]; + break; + default: + printk("SPRD_IMG: error free frame buffer, channel_id 0x%x \n", write_op.channel_id); + return -EINVAL; + } + + if (PATH_IDLE == path->status) { + DCAM_TRACE("SPRD_IMG: error free frame buffer, wrong status, channel_id 0x%x \n", + write_op.channel_id); + return -EINVAL; + } + + if (unlikely(write_op.index > path->frm_id_base + path->frm_cnt_act - 1)) { + printk("SPRD_IMG: error, index %d, frm_id_base %d frm_cnt_act %d \n", + write_op.index, path->frm_id_base, path->frm_cnt_act); + ret = -EINVAL; + } else if (write_op.index < path->frm_id_base) { + printk("SPRD_IMG: error, index %d, frm_id_base %d \n", + write_op.index, path->frm_id_base); + ret = -EINVAL; + } else { + index = write_op.index - path->frm_id_base; + if (path->frm_ptr[index]) { + dcam_frame_unlock(path->frm_ptr[index]); + } + DCAM_TRACE("SPRD_IMG: free frame buffer, channel_id 0x%x, index 0x%x \n", + write_op.channel_id, write_op.index); + } + break; + + default: + printk("SPRD_IMG: cmd error! \n"); + ret = -EINVAL; + break; + } + + return ret; +} + +int32_t sprd_dcam_registers_dump(void *buf, uint32_t buf_len) +{ + if (NULL == buf || buf_len < 0x400) { + printk("%s input para is error", __FUNCTION__); + return -1; + } + + uint32_t* reg_buf = (uint32_t*)buf; + uint32_t reg_buf_len = 0x400; + int ret; + + ret = dcam_read_registers(reg_buf, ®_buf_len); + if (ret) { + printk("dcam_read_registers return error: %d", ret); + return -1; + } + + return reg_buf_len; +} + +#if 0 +LOCAL int sprd_img_proc_read(char *page, + char **start, + off_t off, + int count, + int *eof, + void *data) +{ + int len = 0, ret; + struct dcam_dev *dev = (struct dcam_dev*)data; + uint32_t* reg_buf; + uint32_t reg_buf_len = 0x400; + uint32_t print_len = 0, print_cnt = 0; + + (void)start; (void)off; (void)count; (void)eof; + + len += sprintf(page + len, "Context for DCAM device \n"); + len += sprintf(page + len, "*************************************************************** \n"); + len += sprintf(page + len, "SPRD_ION_MM_SIZE: 0x%x \n", SPRD_ION_MM_SIZE); + len += sprintf(page + len, "the configuration of CAP \n"); + len += sprintf(page + len, " 1. interface mode, %d \n", dev->dcam_cxt.if_mode); + len += sprintf(page + len, " 2. sensor mode, %d \n", dev->dcam_cxt.sn_mode); + len += sprintf(page + len, " 3. YUV pattern, %d \n", dev->dcam_cxt.yuv_ptn); + len += sprintf(page + len, " 4. sync polarities, v %d h %d p %d href %d \n", + dev->dcam_cxt.sync_pol.vsync_pol, + dev->dcam_cxt.sync_pol.hsync_pol, + dev->dcam_cxt.sync_pol.pclk_pol, + dev->dcam_cxt.sync_pol.need_href); + len += sprintf(page + len, " 5. Data bit-width, %d \n", dev->dcam_cxt.data_bits); + len += sprintf(page + len, " 6. need ISP, %d \n", dev->dcam_cxt.dcam_path[DCAM_PATH1].is_from_isp); + len += sprintf(page + len, "*************************************************************** \n"); + len += sprintf(page + len, "the configuration of PATH1 \n"); + len += sprintf(page + len, " 1. input rect, %d %d %d %d \n", + dev->dcam_cxt.dcam_path[DCAM_PATH1].in_rect.x, + dev->dcam_cxt.dcam_path[DCAM_PATH1].in_rect.y, + dev->dcam_cxt.dcam_path[DCAM_PATH1].in_rect.w, + dev->dcam_cxt.dcam_path[DCAM_PATH1].in_rect.h); + len += sprintf(page + len, " 2. output size, %d %d \n", + dev->dcam_cxt.dcam_path[DCAM_PATH1].out_size.w, + dev->dcam_cxt.dcam_path[DCAM_PATH1].out_size.h); + len += sprintf(page + len, " 3. output format, %d \n", + dev->dcam_cxt.dcam_path[DCAM_PATH1].out_fmt); + len += sprintf(page + len, " 4. frame base index, 0x%x \n", dev->dcam_cxt.dcam_path[DCAM_PATH1].frm_id_base); + len += sprintf(page + len, " 5. frame count, 0x%x \n", dev->dcam_cxt.dcam_path[DCAM_PATH1].frm_cnt_act); + len += sprintf(page + len, " 6. frame type, 0x%x \n", dev->dcam_cxt.dcam_path[DCAM_PATH1].frm_type); + for (print_cnt = 0; print_cnt < DCAM_PATH_1_FRM_CNT_MAX; print_cnt ++) { + len += sprintf(page + len, "%2d. frame buffer%d, 0x%08x 0x%08x 0x%08x \n", + (6 + print_cnt), + print_cnt, + dev->dcam_cxt.dcam_path[DCAM_PATH1].frm_addr[print_cnt].yaddr, + dev->dcam_cxt.dcam_path[DCAM_PATH1].frm_addr[print_cnt].uaddr, + dev->dcam_cxt.dcam_path[DCAM_PATH1].frm_addr[print_cnt].vaddr); + } + + if (dev->dcam_cxt.dcam_path[DCAM_PATH2].is_work) { + len += sprintf(page + len, "*************************************************************** \n"); + len += sprintf(page + len, "the configuration of PATH2 \n"); + len += sprintf(page + len, " 1. input rect, %d %d %d %d \n", + dev->dcam_cxt.dcam_path[DCAM_PATH2].in_rect.x, + dev->dcam_cxt.dcam_path[DCAM_PATH2].in_rect.y, + dev->dcam_cxt.dcam_path[DCAM_PATH2].in_rect.w, + dev->dcam_cxt.dcam_path[DCAM_PATH2].in_rect.h); + len += sprintf(page + len, " 2. output size, %d %d \n", + dev->dcam_cxt.dcam_path[DCAM_PATH2].out_size.w, + dev->dcam_cxt.dcam_path[DCAM_PATH2].out_size.h); + len += sprintf(page + len, " 3. output format, %d \n", + dev->dcam_cxt.dcam_path[DCAM_PATH2].out_fmt); + len += sprintf(page + len, " 4. frame base index, 0x%x \n", dev->dcam_cxt.dcam_path[DCAM_PATH2].frm_id_base); + len += sprintf(page + len, " 5. frame count, 0x%x \n", dev->dcam_cxt.dcam_path[DCAM_PATH2].frm_cnt_act); + len += sprintf(page + len, " 6. frame type, 0x%x \n", dev->dcam_cxt.dcam_path[DCAM_PATH2].frm_type); + for (print_cnt = 0; print_cnt < DCAM_PATH_2_FRM_CNT_MAX; print_cnt ++) { + len += sprintf(page + len, "%2d. frame buffer%d, 0x%8x 0x%8x 0x%8x \n", + (6 + print_cnt), + print_cnt, + dev->dcam_cxt.dcam_path[DCAM_PATH2].frm_addr[print_cnt].yaddr, + dev->dcam_cxt.dcam_path[DCAM_PATH2].frm_addr[print_cnt].uaddr, + dev->dcam_cxt.dcam_path[DCAM_PATH2].frm_addr[print_cnt].vaddr); + } + + } + + reg_buf = (uint32_t*)vzalloc(reg_buf_len); + ret = dcam_read_registers(reg_buf, ®_buf_len); + if (ret) { + vfree(reg_buf); + return len; + } + + len += sprintf(page + len, "*************************************************************** \n"); + len += sprintf(page + len, "dcam registers \n"); + print_cnt = 0; + while (print_len < reg_buf_len) { + len += sprintf(page + len, "offset 0x%03x: 0x%08x, 0x%08x, 0x%08x, 0x%08x \n", + print_len, + reg_buf[print_cnt], + reg_buf[print_cnt+1], + reg_buf[print_cnt+2], + reg_buf[print_cnt+3]); + print_cnt += 4; + print_len += 16; + } + + ret = csi_read_registers(reg_buf, ®_buf_len); + if (ret) { + vfree(reg_buf); + return len; + } + + len += sprintf(page + len, "*************************************************************** \n"); + len += sprintf(page + len, "csi host registers \n"); + print_cnt = 0; + print_len = 0; + while (print_len < reg_buf_len) { + len += sprintf(page + len, "offset 0x%03x: 0x%08x, 0x%08x, 0x%08x, 0x%08x \n", + print_len, + reg_buf[print_cnt], + reg_buf[print_cnt+1], + reg_buf[print_cnt+2], + reg_buf[print_cnt+3]); + print_cnt += 4; + print_len += 16; + } + len += sprintf(page + len, "*************************************************************** \n"); + len += sprintf(page + len, "The end of DCAM device \n"); + msleep(10); + vfree(reg_buf); + + return len; +} +#endif + +static struct file_operations image_fops = { + .owner = THIS_MODULE, + .open = sprd_img_k_open, + .unlocked_ioctl = sprd_img_k_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = sprd_img_k_ioctl, +#endif + .release = sprd_img_k_release, + .read = sprd_img_read, + .write = sprd_img_write, +}; + +static struct miscdevice image_dev = { + .minor = IMAGE_MINOR, + .name = IMG_DEVICE_NAME, + .fops = &image_fops, +}; + + +int sprd_img_probe(struct platform_device *pdev) +{ + int ret = 0; + + printk(KERN_ALERT "sprd_img_probe called\n"); + + ret = misc_register(&image_dev); + if (ret) { + printk(KERN_ERR "cannot register miscdev on minor=%d (%d)\n", + IMAGE_MINOR, ret); + ret = -EACCES; + goto exit; + } + image_dev.this_device->of_node = pdev->dev.of_node; + parse_baseaddress(pdev->dev.of_node); + + printk(KERN_ALERT "sprd_img_probe Success\n"); + goto exit; + +exit: + return ret; +} + +static int sprd_img_remove(struct platform_device *pdev) +{ + misc_deregister(&image_dev); + return 0; +} + +static void sprd_img_shutdown(struct platform_device *pdev) +{ + sprd_flash_close(); +} + +LOCAL const struct of_device_id of_match_table_dcam[] = { + { .compatible = "sprd,sprd_dcam", }, + { }, +}; +LOCAL struct platform_driver sprd_img_driver = { + .probe = sprd_img_probe, + .remove = sprd_img_remove, + .shutdown = sprd_img_shutdown, + .driver = { + .owner = THIS_MODULE, + .name = IMG_DEVICE_NAME, + .of_match_table = of_match_ptr(of_match_table_dcam), + }, +}; + +int __init sprd_img_k_init(void) +{ + if (platform_driver_register(&sprd_img_driver) != 0) { + printk("platform device register Failed \n"); + return -1; + } + + if (dcam_scale_coeff_alloc()) { + printk("dcam_scale_coeff_alloc Failed \n"); + return -1; + } + + printk(KERN_INFO "Video Technology Magazine Virtual Video " + "Capture Board ver %u.%u.%u successfully loaded.\n", + (DCAM_VERSION >> 16) & 0xFF, (DCAM_VERSION >> 8) & 0xFF, + DCAM_VERSION & 0xFF); + return 0; +} + +void sprd_img_k_exit(void) +{ + dcam_scale_coeff_free(); + platform_driver_unregister(&sprd_img_driver); +} + +module_init(sprd_img_k_init); +module_exit(sprd_img_k_exit); +MODULE_DESCRIPTION("DCAM Driver"); +MODULE_AUTHOR("Multimedia_Camera@Spreadtrum"); +MODULE_LICENSE("GPL"); + |