From 8e4bff4cab0ddac6060645b0715210484d02ff40 Mon Sep 17 00:00:00 2001
From: Yuval Adam <_@yuv.al>
Date: Wed, 30 Aug 2017 08:25:59 +0000
Subject: Initial file dump from open source release

---
 drivers/media/sprd_isp/isp1.0/isp_drv_kernel.c | 1494 ++++++++++++++++++++++++
 1 file changed, 1494 insertions(+)
 create mode 100644 drivers/media/sprd_isp/isp1.0/isp_drv_kernel.c

(limited to 'drivers/media/sprd_isp/isp1.0/isp_drv_kernel.c')

diff --git a/drivers/media/sprd_isp/isp1.0/isp_drv_kernel.c b/drivers/media/sprd_isp/isp1.0/isp_drv_kernel.c
new file mode 100644
index 00000000..9a6acbef
--- /dev/null
+++ b/drivers/media/sprd_isp/isp1.0/isp_drv_kernel.c
@@ -0,0 +1,1494 @@
+/*
+ * 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/kernel.h>
+#include <linux/errno.h>
+#include <linux/poll.h>
+#include <linux/fs.h>
+#include <linux/irq.h>
+#include <linux/mm.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/miscdevice.h>
+#include <asm/io.h>
+#include <linux/file.h>
+#include <linux/slab.h>
+#include <linux/err.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/sched.h>
+#include <linux/spinlock_types.h>
+#include <linux/semaphore.h>
+#include <linux/delay.h>
+#include <linux/proc_fs.h>
+#include <video/isp_drv_kernel.h>
+#include <soc/sprd/sci.h>
+#include <linux/clk.h>
+#include <asm/cacheflush.h>
+#ifndef CONFIG_64BIT
+#include <soc/sprd/hardware.h>
+#endif
+#include "compat_isp_drv_kernel.h"
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/vmalloc.h>
+#include <linux/kthread.h>
+
+#include "Shark_reg_isp.h"
+#include "parse_hwinfo.h"
+
+
+#define DEBUG_ISP_DRV
+#ifdef DEBUG_ISP_DRV
+#define ISP_PRINT   printk
+#else
+#define ISP_PRINT(...)
+#endif
+
+#define ISP_QUEUE_LENGTH 16
+#define SA_SHIRQ	IRQF_SHARED
+static uint32_t                    g_isp_irq = 0x12345678;/*for share irq handler function*/
+//static uint32_t                    g_dcam_irq = 0x12345678;/*for share irq handler function*/
+
+#define ISP_MINOR		MISC_DYNAMIC_MINOR/*isp minor number*/
+#define init_MUTEX(sem)		sema_init(sem, 1)
+#define init_MUTEX_LOCKED(sem)	sema_init(sem, 0)
+#define IO_PTR          volatile void __iomem *
+#define ISP_READL(a)	__raw_readl((IO_PTR)a)
+#define ISP_WRITEL(a,v)	__raw_writel(v,(IO_PTR)a)
+#define ISP_OWR(a,v)	__raw_writel((__raw_readl((IO_PTR)a) | v), (IO_PTR)a)
+#define ISP_AWR(a,v)	__raw_writel((__raw_readl((IO_PTR)a) & v), (IO_PTR)a)
+#define ISP_NAWR(a,v)	__raw_writel((__raw_readl((IO_PTR)a) & ~v), (IO_PTR)a)
+#define ISP_REG_RD(a)	ISP_READL(((IO_PTR)a))
+#define DEBUG_STR                         "Error L %d, %s \n"
+#define DEBUG_ARGS                        __LINE__,__FUNCTION__
+#define ISP_LOWEST_ADDR                0x800
+#define ISP_ADDR_INVALID(addr)         ((unsigned long)(addr) < (unsigned long)ISP_LOWEST_ADDR)
+#define ISP_CHECK_ZERO(a)                                      \
+	do {                                                       \
+		if (ISP_ADDR_INVALID(a)) {                       \
+			printk("isp_k, zero pointer \n");           \
+			printk(DEBUG_STR, DEBUG_ARGS);               \
+			return -EFAULT;                              \
+		}                                                   \
+	} while(0)
+
+#define ISP_CHECK_ZERO_VOID(a)                                 \
+	do {                                                       \
+		if (ISP_ADDR_INVALID(a)) {                       \
+			printk("isp_k, zero pointer \n");           \
+			printk(DEBUG_STR, DEBUG_ARGS);               \
+			return;                                      \
+		}                                                   \
+	} while(0)
+
+#define ISP_DCAM_IRQ_MASK	0x03
+#define ISP_DCAM_IRQ_NUM	0x02
+#define ISP_BUF_MAX_SIZE ISP_TMP_BUF_SIZE_MAX_V0001
+#define ISP_IRQ_NUM ISP_IRQ_NUM_V0001
+#define ISP_IRQ_HW_MASK ISP_IRQ_HW_MASK_V0001
+#define ISP_TIME_OUT_MAX (500)
+
+struct isp_node {
+	uint32_t	isp_irq_val;
+	uint32_t	dcam_irq_val;
+	uint64_t	system_time;
+};
+
+struct isp_queue {
+	struct isp_node 	node[ISP_QUEUE_LENGTH];
+	struct isp_node 	*write;
+	struct isp_node 	*read;
+};
+
+struct isp_lnc_load {
+	uint8_t   load_lnc_flag;
+	uint8_t   cap_eof_flag;
+	uint32_t param_counts;
+	unsigned long load_buf;
+	struct semaphore  load_done_sem;
+};
+struct isp_device_t
+{
+	unsigned long reg_base_addr;/*the pointer of isp register context*/
+	uint32_t size;/* struct size*/
+	unsigned long buf_addr;
+	uint32_t buf_len;
+	struct isp_queue queue;
+	struct semaphore sem_isr;/*for interrupts*/
+	struct semaphore sem_isp;/*for the isp device, protect the isp hardware; protect  only  one caller use the oi*/
+				/*controll/read/write functions*/
+	struct clk* s_isp_clk_mm_i;
+	struct clk              *s_isp_clk;
+	struct semaphore  kernel_sem;
+	struct task_struct*  kernel_thread;
+	struct isp_lnc_load lnc_load;
+	uint32_t is_kernel_thread_stop;
+};
+enum dcam_irq_id {
+	DCAM_SN_SOF = 0,
+	DCAM_SN_EOF,
+	DCAM_CAP_SOF,
+	DCAM_CAP_EOF,
+	DCAM_PATH0_DONE,
+	DCAM_PATH0_OV,
+	DCAM_PATH1_DONE,
+	DCAM_PATH1_OV,
+	DCAM_PATH2_DONE,
+	DCAM_PATH2_OV,
+	DCAM_SN_LINE_ERR,
+	DCAM_SN_FRAME_ERR,
+	DCAM_JPEG_BUF_OV,
+	DCAM_ISP_OV,
+	DCAM_MIPI_OV,
+	DCAM_ROT_DONE,
+	DCAM_PATH1_SLICE_DONE,
+	DCAM_PATH2_SLICE_DONE,
+	DCAM_RAW_SLICE_DONE,
+	DCAM_PATH1_SOF,
+	DCAM_PATH2_SOF,
+	DCAM_IRQ_NUMBER
+};
+struct dcam_frame {
+	uint32_t               type;
+	uint32_t               lock;
+	uint32_t               flags;
+	uint32_t               fid;
+	uint32_t               width;
+	uint32_t               height;
+	uint32_t               yaddr;
+	uint32_t               uaddr;
+	uint32_t               vaddr;
+	struct dcam_frame      *prev;
+	struct dcam_frame      *next;
+};
+typedef int (*dcam_isr_func)(struct dcam_frame* frame, void* u_data);
+extern int32_t dcam_reg_isr(enum dcam_irq_id id, dcam_isr_func user_func, void* user_data);
+
+static atomic_t s_isp_users = ATOMIC_INIT(0);
+static struct mutex s_isp_lock;	/*for the isp driver, protect the isp module; protect only one user open this module*/
+static struct proc_dir_entry*  isp_proc_file;
+static struct isp_device_t *g_isp_dev_ptr = NULL;
+
+uint32_t s_dcam_int_eb = 0x00;
+unsigned long s_isp_alloc_addr = 0x00;
+uint32_t s_isp_alloc_order = 0x00;
+uint32_t s_isp_alloc_len = 0x00;
+
+static DEFINE_SPINLOCK(isp_spin_lock);
+static int32_t _isp_set_clk(enum isp_clk_sel clk_sel);
+static int32_t _isp_module_eb(void);
+static int32_t _isp_module_dis(void);
+static int  _isp_registerirq(void);
+static void _isp_unregisterirq(void);
+static irqreturn_t _isp_irq_root(int irq, void *dev_id);
+void _dcam_isp_root(void);
+static int _isp_queue_init(struct isp_queue *queue);
+static int _isp_queue_write(struct isp_queue *queue, struct isp_node *node);
+static int _isp_queue_read(struct isp_queue *queue, struct isp_node *node);
+static inline void _isp_regread(char *dst,  char *src, size_t n);
+static inline void  _isp_regwrite(char *dst,  char *src, size_t n);
+static void _read_reg(struct isp_reg_bits *reg_bits_ptr, uint32_t counts);
+static void _write_reg(struct isp_reg_bits *reg_bits_ptr, uint32_t counts);
+
+/**file operation functions declare**/
+static int32_t _isp_kernel_open(struct inode *node, struct file *filp);
+static int32_t _isp_kernel_release(struct inode *node, struct file *filp);
+static long _isp_kernel_ioctl( struct file *fl, unsigned int cmd, unsigned long param);
+/**driver'  functions declare**/
+static int32_t _isp_probe(struct platform_device *pdev);
+static int32_t _isp_remove(struct platform_device *dev);
+/**module'  functions declare**/
+static int32_t __init isp_kernel_init(void);
+static void isp_kernel_exit(void);
+static int32_t _isp_lnc_param_load_ex(struct isp_reg_bits *reg_bits_ptr, uint32_t counts);
+static int _isp_stop_kernel_thread(void* param);
+
+static struct file_operations isp_fops = {
+	.owner	= THIS_MODULE,
+	.open	= _isp_kernel_open,
+	.unlocked_ioctl	= _isp_kernel_ioctl,
+	.compat_ioctl = compat_isp_kernel_ioctl,
+	.release	= _isp_kernel_release,
+};
+
+static struct miscdevice isp_dev = {
+	.minor	= ISP_MINOR,
+	.name	= "sprd_isp",
+	.fops	= &isp_fops,
+};
+
+static const struct of_device_id of_match_table_isp[] = {
+	{ .compatible = "sprd,sprd_isp", },
+	{ },
+};
+
+static struct platform_driver isp_driver = {
+	.probe	= _isp_probe,
+	.remove	= _isp_remove,
+	.driver	= {
+		.owner = THIS_MODULE,
+		.name = "sprd_isp",
+		.of_match_table = of_match_ptr(of_match_table_isp),
+	},
+};
+
+static int32_t _isp_get_systemtime(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;
+}
+
+static int32_t _isp_module_eb(void)
+{
+	int32_t ret = 0;
+
+	if (0x01 == atomic_inc_return(&s_isp_users)) {
+
+		ret = clk_mm_i_eb(isp_dev.this_device->of_node,1);
+		ret = _isp_set_clk(ISP_CLK_312M);
+		if (unlikely(0 != ret)) {
+			ISP_PRINT("isp_k: set clock error\n");
+			ret = -EIO;
+		}
+	}
+
+	ISP_PRINT("_isp_module_eb: end\n");
+
+	return ret;
+}
+
+static int32_t _isp_module_dis(void)
+{
+	int32_t	ret = 0;
+
+	if (0x00 == atomic_dec_return(&s_isp_users)) {
+
+		ret = _isp_set_clk(ISP_CLK_NONE);
+		if (unlikely(0 != ret)) {
+			ISP_PRINT("isp_k: close clock error\n");
+			ret = -EFAULT;
+			return ret;
+		}
+		ret =  clk_mm_i_eb(isp_dev.this_device->of_node,0);
+	}
+	return ret;
+}
+
+static int32_t _isp_module_rst(void)
+{
+	int32_t ret = 0;
+	uint32_t reg_value=0x00;
+	int32_t time_out_cnt = 0;
+
+	if (0x00 != atomic_read(&s_isp_users)) {
+
+		ISP_OWR(ISP_AXI_MASTER_STOP, BIT_0);
+
+		reg_value=ISP_READL(ISP_AXI_MASTER);
+		while((0x00==(reg_value&0x08)) && (time_out_cnt < (ISP_TIME_OUT_MAX * 2)))
+		{
+			time_out_cnt++;
+			udelay(50);
+			reg_value=ISP_READL(ISP_AXI_MASTER);
+		}
+		if (time_out_cnt >= ISP_TIME_OUT_MAX) {
+			ret = -1;
+			ISP_PRINT("_isp_module_rst: time out\n");
+		}
+
+		ISP_WRITEL(ISP_INT_CLEAR, ISP_IRQ_HW_MASK);
+
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
+		sci_glb_set(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
+
+		sci_glb_clr(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
+		sci_glb_clr(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
+	}
+
+	ISP_PRINT("_isp_module_rst: exit\n");
+
+	return 0;
+}
+
+void* _isp_cap_eof(struct dcam_frame* frame, void* u_data)
+{
+	struct isp_device_t * p_isp = (struct isp_device_t *)u_data;
+	if (p_isp) {
+		p_isp->lnc_load.cap_eof_flag = 1;
+		if (p_isp->lnc_load.load_lnc_flag) {
+			up(&p_isp->kernel_sem);
+			p_isp->lnc_load.load_lnc_flag = 0;
+		} else {
+		}
+	}
+}
+int _isp_kernel_proc(void *arg)
+{
+	struct isp_device_t          *dev = (struct isp_device_t*)arg;
+	int32_t                      time_out_cnt = 0;
+	uint32_t                     reg_value=0x00;
+	int                          ret = 0;
+	struct isp_reg_bits *reg_bits_ptr;
+	uint32_t counts;
+	while(1) {
+		if (0 == down_interruptible(&dev->kernel_sem)) {
+			if (dev->is_kernel_thread_stop) {
+				printk("isp_k: _isp_kernel_proc stop \n");
+				break;
+			}
+			reg_bits_ptr = (struct isp_reg_bits*) g_isp_dev_ptr->lnc_load.load_buf;
+			counts = g_isp_dev_ptr->lnc_load.param_counts;
+			ret = _isp_lnc_param_load_ex(reg_bits_ptr, counts);
+			memset((void *)g_isp_dev_ptr->lnc_load.load_buf, 0x00, ISP_BUF_MAX_SIZE);
+		}
+	}
+	dev->is_kernel_thread_stop = 0;
+	return 0;
+}
+int _isp_kernel_thread(void* param)
+{
+	struct isp_device_t          *dev = (struct isp_device_t*)param;
+	if (dev == NULL) {
+		printk("isp_k: _isp_kernel_thread, dev is NULL \n");
+		return -1;
+	}
+	dev->lnc_load.load_lnc_flag = 0;
+	dev->lnc_load.cap_eof_flag = 0;
+	dev->is_kernel_thread_stop = 0;
+	sema_init(&dev->kernel_sem, 0);
+	sema_init(&dev->lnc_load.load_done_sem, 0);
+	dev->kernel_thread = kthread_run(_isp_kernel_proc, param, "isp_kernel_proc_thread");
+	if (IS_ERR(dev->kernel_thread)) {
+		printk("isp_k: _isp_kernel_thread error!\n");
+		return -1;
+	}
+	return 0;
+}
+static int _isp_stop_kernel_thread(void* param)
+{
+	struct isp_device_t          *dev = (struct isp_device_t*)param;
+	int cnt = 0;
+	if (dev == NULL) {
+		printk("SPRD_IMG: sprd_img_opt_flash, dev is NULL \n");
+		return -1;
+	}
+	if (dev->kernel_thread) {
+		dev->is_kernel_thread_stop = 1;
+		up(&dev->kernel_sem);
+		if (0 != dev->is_kernel_thread_stop) {
+			while (cnt < 500) {
+				cnt++;
+				if (0 == dev->is_kernel_thread_stop)
+					break;
+				msleep(1);
+			}
+		}
+		dev->kernel_thread = NULL;
+	}
+	return 0;
+}
+static int32_t _isp_lnc_param_load_ex(struct isp_reg_bits *reg_bits_ptr, uint32_t counts)
+{
+	int32_t ret = 0;
+	int32_t time_out_cnt = 0;
+	volatile uint32_t reg_value=0x00;
+
+	if((0x00!=s_isp_alloc_addr)
+		&&(0x00!=s_isp_alloc_len)) {
+
+		void *ptr = (void*)s_isp_alloc_addr;
+		uint32_t len=s_isp_alloc_len;
+
+		#ifndef CONFIG_64BIT
+		dmac_flush_range(ptr, ptr + len);
+		outer_flush_range(__pa(ptr), __pa(ptr) + len);
+		#endif
+
+		reg_bits_ptr->reg_value=(uint32_t)__pa(reg_bits_ptr->reg_value);
+//#if defined(CONFIG_MACH_CORE3)
+
+
+			reg_value=ISP_READL(ISP_LNC_STATUS);
+			while((0x00==(reg_value&ISP_LNC_STATUS_OK)) && (time_out_cnt < (ISP_TIME_OUT_MAX*1000))) {
+				udelay(1);
+				reg_value=ISP_READL(ISP_LNC_STATUS);
+				time_out_cnt++;
+			}
+			if (time_out_cnt >= (ISP_TIME_OUT_MAX*1000)) {
+				ret = -1;
+				ISP_PRINT("isp_k: isp lnc status time out\n");
+			}
+		ISP_OWR(ISP_INT_EN, ISP_INT_LENS_LOAD);
+			_write_reg(reg_bits_ptr, counts);
+	}else {
+		ISP_PRINT("isp_k: isp load lnc param error\n");
+	}
+	return ret;
+}
+static int32_t _isp_lnc_param_load(struct isp_reg_bits *reg_bits_ptr, uint32_t counts)
+{
+	int32_t ret = 0;
+	int32_t time_out_cnt = 0;
+	uint32_t reg_value=0x00;
+	printk("isp_k: _isp_lnc_param_load \n");
+	if((0x00!=s_isp_alloc_addr)
+		&&(0x00!=s_isp_alloc_len)) {
+		void *ptr = (void*)s_isp_alloc_addr;
+		uint32_t len=s_isp_alloc_len;
+		#ifndef CONFIG_64BIT
+		dmac_flush_range(ptr, ptr + len);
+		outer_flush_range(__pa(ptr), __pa(ptr) + len);
+		#endif
+		reg_bits_ptr->reg_value=(uint32_t)__pa(reg_bits_ptr->reg_value);
+               {
+                       unsigned long flags;
+                       reg_value=ISP_READL(ISP_LNC_STATUS);
+                       while((0x00==(reg_value&ISP_LNC_STATUS_OK)) && (time_out_cnt < (ISP_TIME_OUT_MAX*1000))) {
+                               udelay(1);
+                               reg_value=ISP_READL(ISP_LNC_STATUS);
+                               time_out_cnt++;
+		}
+                       if (time_out_cnt >= (ISP_TIME_OUT_MAX*1000)) {
+                               ret = -1;
+                               ISP_PRINT("isp_k: isp lnc status time out\n");
+                       }
+		_write_reg(reg_bits_ptr, counts);
+			printk("isp_k: load, 0x%x: 0x%x, 0x%x, counts %d \n", reg_bits_ptr, reg_bits_ptr->reg_addr, reg_bits_ptr->reg_value, counts);
+               }
+
+		time_out_cnt = 0;
+		reg_value=ISP_READL(ISP_INT_RAW);
+
+		while ((0x00 == (reg_value&ISP_INT_LENS_LOAD)) && (time_out_cnt < ISP_TIME_OUT_MAX)) {
+			udelay(1);
+			reg_value=ISP_READL(ISP_INT_RAW);
+			time_out_cnt++;
+		}
+		if (time_out_cnt >= ISP_TIME_OUT_MAX) {
+			ret = -1;
+			ISP_PRINT("isp_k: isp load lnc param time out\n");
+		}
+		ISP_OWR(ISP_INT_CLEAR, ISP_INT_LENS_LOAD);
+	}else {
+		ISP_PRINT("isp_k: isp load lnc param error\n");
+	}
+
+	return ret;
+}
+
+static int32_t _isp_lnc_param_set(uint32_t* addr, uint32_t len)
+{
+	int32_t ret = 0;
+
+	if((0x00!=s_isp_alloc_addr)
+		&&(0x00!=addr)) {
+		memcpy((void*)s_isp_alloc_addr, (void*)addr, len);
+	}
+
+	return ret;
+}
+
+static int32_t _isp_free(void)
+{
+	int32_t ret = 0;
+
+	if((0x00!=s_isp_alloc_addr)
+		&&(0x00!=s_isp_alloc_order)) {
+		free_pages(s_isp_alloc_addr, s_isp_alloc_order);
+		s_isp_alloc_order = 0x00;
+		s_isp_alloc_addr = 0x00;
+		s_isp_alloc_len=0x00;
+	}
+
+	return ret;
+}
+
+static int32_t _isp_alloc(unsigned long* addr, uint32_t len)
+{
+	int32_t ret = 0x00;
+	unsigned long buf=0x00;
+	void *ptr = 0x00;
+
+	if((0x00!=s_isp_alloc_addr)
+		&&(len<=s_isp_alloc_len)) {
+		*addr = s_isp_alloc_addr;
+	} else {
+		_isp_free();
+	}
+
+	if(0x00==s_isp_alloc_addr) {
+		s_isp_alloc_len=len;
+		s_isp_alloc_order = get_order(len);
+		s_isp_alloc_addr = __get_free_pages(GFP_KERNEL | __GFP_COMP, s_isp_alloc_order);
+		if (NULL == (void*)s_isp_alloc_addr) {
+			ISP_PRINT("ISP_RAW:_isp_alloc order:0x%x, addr:0x%lx, len:0x%x error\n", s_isp_alloc_order, s_isp_alloc_addr, s_isp_alloc_len);
+			return 1;
+		}
+		ptr = (void*)s_isp_alloc_addr;
+		*addr = s_isp_alloc_addr;
+		buf = virt_to_phys((volatile void *)s_isp_alloc_addr);
+
+		#ifndef CONFIG_64BIT
+		dmac_flush_range(ptr, ptr + len);
+		outer_flush_range(__pa(ptr), __pa(ptr) + len);
+		#endif
+	}
+
+	return ret;
+}
+
+static int32_t _isp_set_clk(enum isp_clk_sel clk_sel)
+{
+	struct clk              *clk_parent;
+	char                    *parent = "clk_256m";
+	int32_t       rtn = 0;
+
+	ISP_CHECK_ZERO(g_isp_dev_ptr);
+
+#ifdef CONFIG_SC_FPGA
+	return 0;
+#endif
+
+	switch (clk_sel) {
+	case ISP_CLK_312M:
+		parent = "clk_312m";
+		break;
+	case ISP_CLK_256M:
+		parent = "clk_256m";
+		break;
+	case ISP_CLK_128M:
+		parent = "clk_128m";
+		break;
+	case ISP_CLK_48M:
+		parent = "clk_48m";
+		break;
+	case ISP_CLK_76M8:
+		parent = "clk_76p8m";
+		break;
+
+	case ISP_CLK_NONE:
+		ISP_PRINT("isp_k: ISP close CLK %d \n", (int)clk_get_rate(g_isp_dev_ptr->s_isp_clk));
+		if (g_isp_dev_ptr->s_isp_clk) {
+			clk_disable(g_isp_dev_ptr->s_isp_clk);
+			clk_put(g_isp_dev_ptr->s_isp_clk);
+			g_isp_dev_ptr->s_isp_clk = NULL;
+		}
+		return 0;
+	default:
+		parent = "clk_128m";
+		break;
+	}
+
+	if (NULL == g_isp_dev_ptr->s_isp_clk) {
+		g_isp_dev_ptr->s_isp_clk = parse_clk(isp_dev.this_device->of_node, "clk_isp");
+		if (IS_ERR(g_isp_dev_ptr->s_isp_clk)) {
+			ISP_PRINT("isp_k: parse_clk fail, %p \n", (int)g_isp_dev_ptr->s_isp_clk);
+			return -1;
+		} else {
+			ISP_PRINT("isp_k: get clk_parent ok \n");
+		}
+	} else {
+		clk_disable(g_isp_dev_ptr->s_isp_clk);
+	}
+
+	clk_parent = clk_get(NULL, parent);
+	if (IS_ERR(clk_parent)) {
+		ISP_PRINT("isp_k: dcam_set_clk fail, %p \n", clk_parent);
+		return -1;
+	} else {
+		ISP_PRINT("isp_k: get clk_parent ok \n");
+	}
+
+	rtn = clk_set_parent(g_isp_dev_ptr->s_isp_clk, clk_parent);
+	if(rtn){
+		ISP_PRINT("isp_k: clk_set_parent fail, %d \n", rtn);
+	}
+
+	rtn = clk_enable(g_isp_dev_ptr->s_isp_clk);
+	if (rtn) {
+		ISP_PRINT("isp_k: enable isp clk error.\n");
+		return -1;
+	}
+
+	return rtn;
+}
+
+static int _isp_queue_init(struct isp_queue *queue)
+{
+	if (NULL == queue)
+		return -EINVAL;
+
+	memset(queue, 0x00, sizeof(*queue));
+	queue->write = &queue->node[0];
+	queue->read  = &queue->node[0];
+
+	return 0;
+}
+
+static int _isp_queue_write(struct isp_queue *queue, struct isp_node *node)
+{
+	struct isp_node 	*ori_node;
+
+	if (NULL == queue || NULL == node)
+	return -EINVAL;
+
+	ori_node = queue->write;
+
+	//ISP_PRINT("_isp_queue_write called!\n");
+	*queue->write++ = *node;
+	if (queue->write > &queue->node[ISP_QUEUE_LENGTH-1]) {
+		queue->write = &queue->node[0];
+	}
+
+	if (queue->write == queue->read) {
+	queue->write = ori_node;
+	}
+
+	//ISP_PRINT("_isp_queue_write finished!\n");
+	return 0;
+}
+
+static int _isp_queue_read(struct isp_queue *queue, struct isp_node *node)
+{
+	int ret = 0;
+
+	if (NULL == queue || NULL == node)
+		return -EINVAL;
+	//ISP_PRINT("_isp_queue_read called!\n");
+	if (queue->read != queue->write) {
+		*node = *queue->read++;
+		if (queue->read > &queue->node[ISP_QUEUE_LENGTH-1]) {
+			queue->read = &queue->node[0];
+		}
+	}
+	//ISP_PRINT("_isp_queue_read finished!\n");
+	return ret;
+}
+
+static inline void _isp_regread(char *dst,  char *src, size_t n)
+{
+	char tmp  = 0;
+	uint32_t tmp2 = 0;
+	char *char_src = 0,*d = 0;
+	uint32_t *d2 = (uint32_t*) dst;
+	uint32_t *int_src =  (uint32_t*) src;
+	uint32_t counts = (n>>2)<<2;
+	uint32_t res_counts = n -counts;
+	counts = counts>>2;
+
+	while (counts--) {
+		tmp2 = ISP_READL(int_src);
+		*d2++ = tmp2;
+		int_src++;
+	}
+
+	if(res_counts) {
+		d = (char*) d2;
+		char_src = (char*) int_src;
+		while(res_counts--) {
+			tmp = __raw_readb(char_src);
+			*d = tmp;
+			char_src++;
+		}
+	}
+}
+
+static inline void _isp_regwrite(char *dst,  char *src, size_t n)
+{
+	uint32_t tmp2 = 0;
+	char *char_src = 0, *d = 0;
+	uint32_t *int_src = 0, *d2 = 0;
+	uint32_t counts = 0, res_counts = 0;
+
+	int_src = (uint32_t*) src;
+	d2 = (uint32_t*) dst;
+	counts = (n>>2)<<2;
+	res_counts = n - counts;
+	counts = counts>>2;
+
+	while (counts--) {
+		tmp2 = *int_src++;
+		ISP_WRITEL(d2, tmp2);
+		d2++;
+	}
+
+	if(res_counts) {
+		d = (char*) d2;
+		char_src = (char*) int_src;
+
+		while(res_counts--) {
+			tmp2 = *char_src++;
+			 __raw_writeb(tmp2, d);
+			d++;
+		}
+	}
+
+}
+static int32_t _isp_get_ctlr(void *param)
+{
+	struct isp_device_t *dev_ptr = (struct isp_device_t *) param;
+
+	down(&dev_ptr->sem_isp);
+
+	return 0;
+}
+static int32_t _isp_put_ctlr(void *param)
+{
+	struct isp_device_t *dev_ptr = (struct isp_device_t *) param;
+
+	up(&dev_ptr->sem_isp);
+
+	return 0;
+}
+
+static int _isp_en_irq(unsigned long int_num)
+{
+	uint32_t ret = 0;
+
+	ISP_WRITEL(ISP_INT_CLEAR, ISP_IRQ_HW_MASK);
+	ISP_WRITEL(ISP_INT_EN, int_num);
+
+	return ret;
+}
+
+static int _isp_registerirq(void)
+{
+	uint32_t ret = 0;
+
+	ret = request_irq(ISP_IRQ, _isp_irq_root, IRQF_SHARED, "ISP", &g_isp_irq);
+
+	return ret;
+}
+static void _isp_unregisterirq(void)
+{
+	free_irq (ISP_IRQ, &g_isp_irq);
+}
+
+static int _isp_cfg_dcam_int(uint32_t param)
+{
+	uint32_t ret = 0;
+
+	s_dcam_int_eb = param;
+
+	return ret;
+}
+
+static void _read_reg(struct isp_reg_bits *reg_bits_ptr, uint32_t counts)
+{
+	uint32_t i = 0;
+	unsigned long reg_val = 0;
+	unsigned long reg_addr = 0;
+
+	for (i = 0; i<counts; ++i) {
+		//reg_addr = reg_bits_ptr[i].reg_addr;
+		reg_addr = ISP_BASE_ADDR + reg_bits_ptr[i].reg_addr;
+		reg_val = ISP_READL(reg_addr);
+		reg_bits_ptr[i].reg_value = reg_val;
+	}
+
+}
+
+static void _write_reg(struct isp_reg_bits *reg_bits_ptr, uint32_t counts)
+{
+	uint32_t i = 0;
+	unsigned long reg_val = 0;
+	unsigned long reg_addr = 0;
+
+	for (i = 0; i<counts; ++i) {
+		reg_addr = reg_bits_ptr[i].reg_addr+ISP_BASE_ADDR;
+		reg_val = reg_bits_ptr[i].reg_value;
+		ISP_WRITEL(reg_addr, reg_val);
+	}
+}
+
+/**********************************************************
+*open the device
+*
+***********************************************************/
+static int32_t _isp_kernel_open (struct inode *node, struct file *pf)
+{
+	int32_t ret = 0;
+	ISP_PRINT ("isp_k: open start \n");
+
+	ISP_CHECK_ZERO(g_isp_dev_ptr);
+
+	ret =  _isp_get_ctlr(g_isp_dev_ptr);
+	if (unlikely(ret)) {
+		ISP_PRINT ("isp_k: get control error \n");
+		ret = -EFAULT;
+		return ret;
+	}
+
+	g_isp_dev_ptr->reg_base_addr = (unsigned long)ISP_BASE_ADDR;
+	g_isp_dev_ptr->size = ISP_REG_MAX_SIZE;
+
+	ret = _isp_queue_init(&(g_isp_dev_ptr->queue));
+	if (unlikely(0 != ret)) {
+		ISP_PRINT("isp_k: queue init error\n");
+		ret = -EIO;
+		goto ISP_K_OPEN_ERROR_EXIT;
+	}
+
+	ret = _isp_module_eb();
+	if (unlikely(0 != ret)) {
+		ISP_PRINT("isp_k: enable isp module error\n");
+		ret = -EIO;
+		goto ISP_K_OPEN_ERROR_EXIT;
+	}
+
+	ret = _isp_module_rst();
+	if (unlikely(0 != ret)) {
+		ISP_PRINT("isp_k: reset isp module error \n");
+		ret = -EIO;
+		_isp_module_dis();
+		goto ISP_K_OPEN_ERROR_EXIT;
+	}
+
+	dcam_reg_isr(DCAM_CAP_EOF, _isp_cap_eof, g_isp_dev_ptr);
+	ret = _isp_kernel_thread(g_isp_dev_ptr);
+	if (unlikely(0 != ret)) {
+		ISP_PRINT("isp_k: create isp_kernel_thread fail \n");
+		ret = -EIO;
+		_isp_module_dis();
+		goto ISP_K_OPEN_ERROR_EXIT;
+	}
+
+	ret = _isp_registerirq();
+	if (unlikely(0 != ret)) {
+		ISP_PRINT("isp_k: reg irq fail \n");
+		ret = -EIO;
+		_isp_stop_kernel_thread(g_isp_dev_ptr);
+		_isp_module_dis();
+		goto ISP_K_OPEN_ERROR_EXIT;
+	}
+
+	ISP_PRINT ("isp_k: open end \n");
+	return ret;
+
+ISP_K_OPEN_ERROR_EXIT:
+	ret =  _isp_put_ctlr(g_isp_dev_ptr);
+	if (unlikely(ret)) {
+		ISP_PRINT ("isp_k: get control error \n");
+		ret = -EFAULT;
+	}
+	ISP_PRINT ("isp_k: open error \n");
+	return -EIO;
+}
+
+static irqreturn_t _isp_irq_root(int irq, void *dev_id)
+{
+	int32_t	    ret = 0;
+	uint32_t	status = 0;
+	uint32_t	irq_line = 0;
+	uint32_t	irq_status = 0;
+	unsigned long flag = 0;
+	int32_t     i = 0;
+	struct isp_node    node = { 0 };
+	struct timeval system_time;
+
+	status = ISP_REG_RD(ISP_INT_STATUS);
+	irq_line = status&ISP_IRQ_HW_MASK;
+	//ISP_PRINT("ISP_RAW:isp_k: isp irq: 0x%x\n", irq_line);
+	if ( 0 == irq_line ) {
+		return IRQ_NONE;
+	}
+
+	spin_lock_irqsave(&isp_spin_lock,flag);
+	if ((ISP_INT_LENS_LOAD & irq_line) == ISP_INT_LENS_LOAD) {
+		irq_line &= ~ISP_INT_LENS_LOAD;
+		ISP_OWR(ISP_INT_CLEAR, ISP_INT_LENS_LOAD);
+		up(&g_isp_dev_ptr->lnc_load.load_done_sem);
+		if (!irq_line) {
+			spin_unlock_irqrestore(&isp_spin_lock, flag);
+			return IRQ_HANDLED;
+		}
+	}
+	for (i = ISP_IRQ_NUM- 1; i >= 0; i--) {
+		if (irq_line & (1 << (uint32_t)i)) {
+		irq_status |= 1 << (uint32_t)i;
+		}
+		irq_line &= ~(uint32_t)(1 << (uint32_t)i); //clear the interrupt flag
+		if(!irq_line) //no interrupt source left
+		break;
+	}
+
+	ISP_WRITEL(ISP_INT_CLEAR, irq_status);
+	node.isp_irq_val = irq_status;
+	_isp_get_systemtime(&system_time);
+	system_time.tv_sec = system_time.tv_sec * 1000000;
+	node.system_time = (uint64_t)(system_time.tv_sec+system_time.tv_usec);
+	ret = _isp_queue_write((struct isp_queue *)&g_isp_dev_ptr->queue, (struct isp_node*)&node);
+	spin_unlock_irqrestore(&isp_spin_lock, flag);
+	up(&g_isp_dev_ptr->sem_isr);
+
+	return IRQ_HANDLED;
+}
+//static irqreturn_t _dcam_irq_root(int irq, void *dev_id)
+void _dcam_isp_root(void)
+{
+	int32_t	ret = 0;
+	unsigned long flag = 0;
+	struct isp_node node = { 0 };
+	struct timeval system_time;
+
+	//ISP_PRINT ("ISP_RAW: isp_k: _dcam_isp_root %d \n", s_dcam_int_eb);
+
+	if(0x00 !=s_dcam_int_eb)
+	{
+		spin_lock_irqsave(&isp_spin_lock,flag);
+		#if defined(CONFIG_MACH_CORE3)
+		node.dcam_irq_val = ISP_INT_FETCH_EOF;
+		#else
+		node.dcam_irq_val = ISP_INT_FETCH_SOF;
+		#endif
+
+		//ISP_PRINT("isp_k: dcam sof irq :0x%x\n", node.dcam_irq_val);
+		_isp_get_systemtime(&system_time);
+		system_time.tv_sec = system_time.tv_sec * 1000000;
+		node.system_time = (uint64_t)(system_time.tv_sec+system_time.tv_usec);
+		ret = _isp_queue_write((struct isp_queue *)&g_isp_dev_ptr->queue, (struct isp_node*)&node);
+		spin_unlock_irqrestore(&isp_spin_lock, flag);
+		up(&g_isp_dev_ptr->sem_isr);
+	}
+
+	//return IRQ_HANDLED;
+}
+
+/**********************************************************
+*release the device
+*
+***********************************************************/
+static int32_t _isp_kernel_release (struct inode *node, struct file *pf)
+{
+	int ret = 0;
+	ISP_PRINT ("isp_k: release start \n");
+
+	mutex_lock(&s_isp_lock);
+
+	_isp_unregisterirq();
+	ret = _isp_module_dis();
+
+	mutex_unlock(&s_isp_lock);
+
+	_isp_stop_kernel_thread(g_isp_dev_ptr);
+	ISP_CHECK_ZERO(g_isp_dev_ptr);
+	ret = _isp_put_ctlr(g_isp_dev_ptr);
+	if (unlikely (ret) ) {
+		ISP_PRINT ("isp_k: release control error \n");
+		return -EFAULT;
+	}
+	ISP_PRINT ("isp_k: release end \n");
+	return ret;
+}
+/**********************************************************
+*read info from  file
+*size_t size:
+*loff_t p:
+***********************************************************/
+#if 0
+static int32_t _isp_kernel_proc_read (char *page, char **start, off_t off, int count, int *eof, void *data)
+{
+	int	 len = 0;
+	uint32_t	 reg_buf_len = 200;
+	uint32_t	 print_len = 0, print_cnt = 0;
+	uint32_t	*reg_ptr = 0;
+
+	ISP_PRINT ("isp_k: _isp_kernel_proc_read 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x \n", (uint32_t)page, (uint32_t)start, (uint32_t)off, (uint32_t)count, (uint32_t)eof, (uint32_t)data);
+
+	(void)start; (void)off; (void)count; (void)eof;
+
+	if(0x00==g_isp_device.reg_base_addr)
+	{
+		return 0x00;
+	}
+
+	reg_ptr = (uint32_t*)g_isp_device.reg_base_addr;
+	len += sprintf(page + len, "Context for ISP device \n");
+	len += sprintf(page + len, "********************************************* \n");
+	while (print_len < reg_buf_len) {
+	len += sprintf(page + len, "offset 0x%x : 0x%x, 0x%x, 0x%x, 0x%x \n",
+		print_len,
+		reg_ptr[print_cnt],
+		reg_ptr[print_cnt+1],
+		reg_ptr[print_cnt+2],
+		reg_ptr[print_cnt+3]);
+	print_cnt += 4;
+	print_len += 16;
+	}
+	len += sprintf(page + len, "********************************************* \n");
+	len += sprintf(page + len, "The end of ISP device \n");
+	return len;
+}
+#endif
+/**********************************************************
+*the io controller of isp
+*unsigned int cmd:
+*unsigned long param:
+***********************************************************/
+static long _isp_kernel_ioctl( struct file *fl, unsigned int cmd, unsigned long param)
+{
+	long ret = 0;
+	uint32_t isp_irq, dcam_irq;
+	struct isp_irq_param irq_param = { 0 };
+	struct isp_node isp_node = { 0 };
+	struct isp_reg_param reg_param = { 0 };
+	struct isp_reg_bits *reg_bits_ptr = 0;
+
+	//ISP_PRINT("isp_k:_ioctl called, cmd: %x\n", cmd);
+
+	if (!fl) {
+		return -EINVAL;
+	}
+
+	ISP_CHECK_ZERO(g_isp_dev_ptr);
+
+	if(ISP_IO_IRQ==cmd)
+	{
+		ret = down_interruptible(&g_isp_dev_ptr->sem_isr);
+		if (ret) {
+			ISP_PRINT("isp_k: ioctl irq: down failed ret = %ld",ret);
+			memset(&irq_param, 0, sizeof(irq_param));
+			irq_param.ret_val = ret;
+			ret = copy_to_user ((void*) param, (void*)&irq_param, sizeof(irq_param));
+			if ( 0 != ret) {
+				ISP_PRINT("isp_k: ioctl irq: copy_to_user failed ret = %ld", ret);
+			}
+			ret = -ERESTARTSYS;
+			goto ISP_IOCTL_EXIT;
+		}
+		ret=_isp_queue_read(&g_isp_dev_ptr->queue, &isp_node);
+		if ( 0 != ret) {
+
+			ISP_PRINT("isp_k: ioctl irq: _isp_queue_read error, ret = 0x%x", (uint32_t)ret);
+			ret = -EFAULT;
+			goto ISP_IOCTL_EXIT;
+		}
+
+		irq_param.dcam_irq_val = isp_node.dcam_irq_val;
+		irq_param.isp_irq_val = isp_node.isp_irq_val;
+		isp_irq = isp_node.isp_irq_val;
+		dcam_irq = isp_node.dcam_irq_val;
+		irq_param.irq_val = dcam_irq|isp_irq;
+		irq_param.system_time = isp_node.system_time;
+		ret = copy_to_user ((void*) param, (void*)&irq_param, sizeof(struct isp_irq_param));
+		if ( 0 != ret) {
+
+			ISP_PRINT("isp_k: ioctl irq: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+			ret = -EFAULT;
+		}
+
+	} else {
+
+		mutex_lock(&s_isp_lock);
+
+		switch (cmd)
+		{
+			case ISP_IO_READ: {
+			uint32_t buf_size = 0;
+			//ISP_PRINT("  isp_k:_ioctl read called \n");
+			ret = copy_from_user((void*)&reg_param, (void*)param, sizeof(struct isp_reg_param));
+			if ( 0 != ret) {
+
+				ISP_PRINT("isp_k: ioctl read: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+				ret = -EFAULT;
+				goto IO_READ_EXIT;
+			}
+			buf_size = reg_param.counts*sizeof(struct isp_reg_bits);
+			if (buf_size > g_isp_dev_ptr->buf_len) {
+				ret  =-EFAULT;
+				goto IO_READ_EXIT;
+			}
+			reg_bits_ptr = (struct isp_reg_bits*) g_isp_dev_ptr->buf_addr;
+			ret = copy_from_user((void*)reg_bits_ptr, (void*)reg_param.reg_param, buf_size);
+			if ( 0 != ret) {
+
+				ISP_PRINT("isp_k: ioctl read: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+				ret  =-EFAULT;
+				goto IO_READ_EXIT;
+			}
+			_read_reg(reg_bits_ptr, reg_param.counts);
+
+			ret = copy_to_user((void*)reg_param.reg_param, (void*)reg_bits_ptr, buf_size);
+			if ( 0 != ret) {
+
+				ISP_PRINT("isp_k: ioctl read: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+				ret = -EFAULT;
+				goto IO_READ_EXIT;
+			}
+			IO_READ_EXIT:
+			if(reg_bits_ptr) {
+				memset((void *)g_isp_dev_ptr->buf_addr, 0x00, buf_size);
+				reg_bits_ptr = NULL;
+			}
+			}
+			break;
+
+			case ISP_IO_WRITE: {
+			uint32_t buf_size = 0;
+			//ISP_PRINT(" isp_k:_ioctl write called \n");
+			ret = copy_from_user((void*)&reg_param, (void*)param, sizeof(struct isp_reg_param));
+			if ( 0 != ret) {
+
+				ISP_PRINT("isp_k: ioctl write: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+				ret = -EFAULT;
+				goto IO_WRITE_EXIT;
+			}
+			buf_size = reg_param.counts*sizeof(struct isp_reg_bits);
+			if(buf_size > g_isp_dev_ptr->buf_len)
+			{
+				ret = -EFAULT;
+				goto IO_WRITE_EXIT;
+			}
+			reg_bits_ptr = (struct isp_reg_bits*) g_isp_dev_ptr->buf_addr;
+
+			ret = copy_from_user((void*)reg_bits_ptr, (void*)reg_param.reg_param, buf_size);
+			if ( 0 != ret) {
+
+				ISP_PRINT("isp_k: ioctl write: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+				ret = -EFAULT;
+				goto IO_WRITE_EXIT;
+			}
+			_write_reg(reg_bits_ptr, reg_param.counts);
+
+			IO_WRITE_EXIT:
+			if(reg_bits_ptr) {
+				memset((void *)g_isp_dev_ptr->buf_addr, 0x00, buf_size);
+				reg_bits_ptr = NULL;
+			}
+
+			}
+			break;
+
+			case ISP_IO_RST: {
+			ISP_PRINT(" isp_k:ioctl restet start \n");
+			g_isp_dev_ptr->lnc_load.cap_eof_flag = 0;
+			ret = _isp_module_rst();
+			if (ret) {
+
+				ISP_PRINT("isp_k: ioctl restet error!\n");
+				ret = -EFAULT;
+			}
+			}
+			break;
+
+			case ISP_IO_SETCLK: {
+			ISP_PRINT(" isp_k:ioctl set clock start \n");
+			}
+			break;
+
+			case ISP_IO_STOP: {
+			unsigned long flag = 0;
+			struct isp_node node = { 0 };
+			ret = _isp_en_irq(0);//dis-enable the interrupt
+			ISP_PRINT("isp_k: ioctl  stop start !\n");
+			spin_lock_irqsave(&isp_spin_lock,flag);
+			node.dcam_irq_val = ISP_INT_STOP;
+			ret = _isp_queue_write((struct isp_queue *)&g_isp_dev_ptr->queue, (struct isp_node*)&node);
+			spin_unlock_irqrestore(&isp_spin_lock, flag);
+			up(&g_isp_dev_ptr->sem_isr);
+			}
+			break;
+
+			case ISP_IO_INT: {
+				unsigned long int_num;
+				ret = copy_from_user((void*)&int_num, (void*)param, 0x04);
+				if (ret) {
+					ISP_PRINT ("isp_k:io int copy param error, ret = %d \n", (uint32_t)ret);
+					ret = -EFAULT;
+					goto ISP_IOCTL_LOCKED_CMD_EXIT;
+				}
+				ret = _isp_en_irq(int_num);
+				//ret = _isp_registerirq();
+				if (unlikely(ret)) {
+					ISP_PRINT ("isp_k:enable  interrupt error \n");
+					ret = -EFAULT;
+				}
+			}
+			break;
+
+			case ISP_IO_DCAM_INT: {
+				unsigned long int_param;
+				ret = copy_from_user((void*)&int_param, (void*)param, 0x04);
+				if (ret) {
+					ISP_PRINT ("isp_k:dcam int copy params error, ret = %d \n", (uint32_t)ret);
+					ret = -EFAULT;
+					goto ISP_IOCTL_LOCKED_CMD_EXIT;
+				}
+				ret = _isp_cfg_dcam_int(int_param);
+				if (unlikely(ret)) {
+					ISP_PRINT ("isp_k:cfg dcam interrupt error \n");
+					ret = -EFAULT;
+				}
+			}
+			break;
+
+			case ISP_IO_LNC_PARAM: {
+				uint32_t buf_size = 0;
+				uint32_t* addr = 0;
+				ret = copy_from_user((void*)&reg_param, (void*)param, sizeof(struct isp_reg_param));
+				if ( 0 != ret) {
+
+					ISP_PRINT("isp_k: ioctl lnc param: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+					goto IO_LNC_PARAM_EXIT;
+				}
+				buf_size = reg_param.counts;
+				if(buf_size > g_isp_dev_ptr->buf_len){
+
+					ret = -EFAULT;
+					goto IO_LNC_PARAM_EXIT;
+				}
+				addr = (uint32_t*) g_isp_dev_ptr->buf_addr;
+				ret = copy_from_user((void*)addr, (void*)reg_param.reg_param, buf_size);
+				if ( 0 != ret) {
+
+					ISP_PRINT("isp_k: ioctl lnc param: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+					goto IO_LNC_PARAM_EXIT;
+				}
+				ret = _isp_lnc_param_set(addr, buf_size);
+				if ( 0 != ret) {
+					ISP_PRINT("isp_k: ioctl lnc param error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+					goto IO_LNC_PARAM_EXIT;
+				}
+
+				IO_LNC_PARAM_EXIT:
+				if(addr) {
+					memset((void *)g_isp_dev_ptr->buf_addr, 0x00, buf_size);
+					addr = NULL;
+				}
+			}
+			break;
+
+			case ISP_IO_LNC: {
+				uint32_t buf_size = 0;
+				ret = copy_from_user((void*)&reg_param, (void*)param, sizeof(struct isp_reg_param));
+				if ( 0 != ret) {
+					ISP_PRINT("isp_k: ioctl lnc: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+					goto IO_LNC_EXIT;
+				}
+				buf_size = reg_param.counts*sizeof(struct isp_reg_bits);
+				if(buf_size > g_isp_dev_ptr->buf_len)
+				{
+					ret = -EFAULT;
+					ISP_PRINT("isp_k: isp_io_lnc: buf len failed\n");
+					goto IO_LNC_EXIT;
+				}
+				reg_bits_ptr = (struct isp_reg_bits*) g_isp_dev_ptr->buf_addr;
+				ret = copy_from_user((void*)reg_bits_ptr, (void*)reg_param.reg_param, buf_size);
+				if ( 0 != ret) {
+					ISP_PRINT("isp_k: ioctl lnc: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+					goto IO_LNC_EXIT;
+				}
+
+				if (g_isp_dev_ptr->lnc_load.cap_eof_flag == 0) {
+				ret = _isp_lnc_param_load(reg_bits_ptr, reg_param.counts);
+				} else {
+					memcpy((void *)g_isp_dev_ptr->lnc_load.load_buf, (void *)reg_bits_ptr, buf_size);
+					g_isp_dev_ptr->lnc_load.param_counts = reg_param.counts;
+					g_isp_dev_ptr->lnc_load.load_lnc_flag = 1;
+					ret = down_timeout(&g_isp_dev_ptr->lnc_load.load_done_sem,  msecs_to_jiffies(500));
+				}
+				if (unlikely(ret)) {
+					ISP_PRINT ("isp_k:load lnc error \n");
+					ret = -EFAULT;
+				}
+				IO_LNC_EXIT:
+				if(reg_bits_ptr) {
+					memset((void *)g_isp_dev_ptr->buf_addr, 0x00, buf_size);
+					reg_bits_ptr = NULL;
+				}
+			}
+			break;
+
+			case ISP_IO_ALLOC: {
+
+				ret = copy_from_user((void*)&reg_param, (void*)param, sizeof(struct isp_reg_param));
+				if ( 0 != ret) {
+					ISP_PRINT("isp_k: ioctl write: copy_to_user error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+					break;
+				}
+				ret = _isp_alloc(&reg_param.reg_param, reg_param.counts);
+				if ( 0 == ret) {
+					ret = copy_to_user((void*)param, (void*)&reg_param, sizeof(struct isp_reg_param));
+				} else {
+					ISP_PRINT("isp_k: ioctl alloc error, ret = 0x%x", (uint32_t)ret);
+					ret = -EFAULT;
+				}
+			}
+			break;
+
+			default:
+			mutex_unlock(&s_isp_lock);
+			ISP_PRINT("isp_k:_ioctl cmd is unsupported, cmd = %x\n", (int32_t)cmd);
+			return -EFAULT;
+		}
+
+		ISP_IOCTL_LOCKED_CMD_EXIT:
+		mutex_unlock(&s_isp_lock);
+	}
+
+	//ISP_PRINT("isp_k:_ioctl finished\n");
+	ISP_IOCTL_EXIT:
+	return ret;
+}
+
+static int _isp_probe(struct platform_device *pdev)
+{
+	int ret = 0;
+	ISP_PRINT ("isp_k:probe start\n");
+
+	ret = misc_register(&isp_dev);
+	if (ret) {
+		ISP_PRINT ( "isp_k:probe cannot register miscdev on minor=%d (%d)\n",(int32_t)ISP_MINOR, (int32_t)ret);
+		return ret;
+	}
+	mutex_init(&s_isp_lock);
+/*
+	isp_proc_file = create_proc_read_entry("driver/sprd_isp" ,
+					0444,
+					NULL,
+					_isp_kernel_proc_read,
+					NULL);
+	if (unlikely(NULL == isp_proc_file)) {
+		ISP_PRINT("isp_k:probe Can't create an entry for isp in /proc \n");
+		ret = ENOMEM;
+		return ret;
+	}
+*/
+	isp_dev.this_device->of_node = pdev->dev.of_node;
+	parse_baseaddress(pdev->dev.of_node);
+	ISP_PRINT (" isp_k:probe end\n");
+	return 0;
+}
+
+static int _isp_remove(struct platform_device * dev)
+{
+	ISP_PRINT ("isp_k: remove start \n");
+
+	misc_deregister(&isp_dev);
+
+	if (isp_proc_file) {
+		remove_proc_entry("driver/sprd_isp", NULL);
+	}
+
+	ISP_PRINT ("isp_k: remove end !\n");
+
+	return 0;
+}
+
+static int32_t __init isp_kernel_init(void)
+{
+	int32_t ret = 0;
+	unsigned long addr = 0;
+	ISP_PRINT ("isp_k: init start \n");
+	if (platform_driver_register(&isp_driver) != 0) {
+		ISP_PRINT ("isp_kernel_init: platform device register error \n");
+		return -1;
+	}
+
+	g_isp_dev_ptr = (struct isp_device_t*)vzalloc(sizeof(struct isp_device_t));
+	ISP_CHECK_ZERO(g_isp_dev_ptr);
+	init_MUTEX(&g_isp_dev_ptr->sem_isp);
+	init_MUTEX_LOCKED(&g_isp_dev_ptr->sem_isr); /*for interrupt */
+	g_isp_dev_ptr->s_isp_clk = NULL;
+	g_isp_dev_ptr->s_isp_clk_mm_i = NULL;
+	g_isp_dev_ptr->buf_addr = 0;
+	g_isp_dev_ptr->buf_len = 0;
+
+	g_isp_dev_ptr->buf_addr = (unsigned long)vzalloc(ISP_BUF_MAX_SIZE);
+	if (0 == g_isp_dev_ptr->buf_addr) {
+		ret = -1;
+		ISP_PRINT ("isp_kernel_init 1: alloc  error \n");
+		goto ISP_K_INIT_EXIT;
+	}
+	g_isp_dev_ptr->buf_len = ISP_BUF_MAX_SIZE;
+
+	g_isp_dev_ptr->lnc_load.load_buf = (unsigned long)vzalloc(ISP_BUF_MAX_SIZE);
+	if (0 == g_isp_dev_ptr->lnc_load.load_buf) {
+		ret = -1;
+		ISP_PRINT ("isp_kernel_init 3: alloc  error \n");
+		goto ISP_K_INIT_EXIT;
+	}
+	ret = _isp_alloc(&addr, ISP_BUF_MAX_SIZE);
+	if (ret) {
+		ret = -1;
+		ISP_PRINT ("isp_kernel_init 2: alloc  error \n");
+		goto ISP_K_INIT_EXIT;
+	}
+
+	ISP_PRINT ("isp_k: init end\n");
+
+	return ret;
+
+ISP_K_INIT_EXIT:
+	_isp_free();
+	if (g_isp_dev_ptr->buf_addr) {
+		vfree((void *)g_isp_dev_ptr->buf_addr);
+		g_isp_dev_ptr->buf_addr = 0;
+		g_isp_dev_ptr->buf_len = 0;
+	}
+	if (g_isp_dev_ptr->lnc_load.load_buf) {
+		vfree((void *)g_isp_dev_ptr->lnc_load.load_buf);
+		g_isp_dev_ptr->lnc_load.load_buf = 0;
+	}
+	if (g_isp_dev_ptr) {
+		vfree(g_isp_dev_ptr);
+		g_isp_dev_ptr = 0;
+	}
+
+	return ret;
+}
+
+static void isp_kernel_exit(void)
+{
+	ISP_PRINT ("isp_k: exit start \n");
+
+	platform_driver_unregister(&isp_driver);
+	mutex_destroy(&s_isp_lock);
+	_isp_free();
+	ISP_CHECK_ZERO_VOID(g_isp_dev_ptr);
+	if (g_isp_dev_ptr->buf_addr) {
+		vfree((void *)g_isp_dev_ptr->buf_addr);
+		g_isp_dev_ptr->buf_addr = 0;
+		g_isp_dev_ptr->buf_len = 0;
+	}
+	if(g_isp_dev_ptr->lnc_load.load_buf) {
+		vfree((void *)g_isp_dev_ptr->lnc_load.load_buf);
+		g_isp_dev_ptr->lnc_load.load_buf = 0;
+	}
+	vfree(g_isp_dev_ptr);
+	g_isp_dev_ptr = NULL;
+
+	ISP_PRINT ("isp_k: exit end \n");
+}
+
+module_init(isp_kernel_init);
+module_exit(isp_kernel_exit);
+
+MODULE_DESCRIPTION("Isp Driver");
+MODULE_LICENSE("GPL");
-- 
cgit v1.3.1