drivers/media/sprd_isp/isp_drv.c

   1 /*
   2  * Copyright (C) 2012 Spreadtrum Communications Inc.
   3  *
   4  * This software is licensed under the terms of the GNU General Public
   5  * License version 2, as published by the Free Software Foundation, and
   6  * may be copied, distributed, and modified under those terms.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/errno.h>
  17 #include <linux/poll.h>
  18 #include <linux/mm.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/miscdevice.h>
  22 #include <linux/slab.h>
  23 #include <linux/types.h>
  24 #include <linux/delay.h>
  25 #include <linux/clk.h>
  26 #include <linux/of.h>
  27 #include <linux/of_device.h>
  28 #include <linux/vmalloc.h>
  29 //#include <mach/sci.h>
  30 #include <soc/sprd/sci.h>
  31 //#include <mach/hardware.h>
  32 #ifndef CONFIG_64BIT
  33 #include <soc/sprd/hardware.h>
  34 #endif
  35 #include <asm/cacheflush.h>
  36 #include <video/sprd_isp.h>
  37 #include "parse_hwinfo.h"
  38 #include "compat_isp_drv.h"
  39 #include "isp_drv.h"
  40 #include "isp_reg.h"
  41
  42 #define ISP_MINOR MISC_DYNAMIC_MINOR
  43
  44 static struct isp_k_private *s_isp_private;
  45
  46 static int isp_wr_addr(struct isp_reg_bits *ptr);
  47
  48 static int32_t isp_block_buf_alloc(struct isp_k_private *isp_private)
  49 {
  50         int32_t ret = 0;
  51         uint32_t buf_len = 0;
  52
  53         buf_len = ISP_REG_BUF_SIZE + ISP_RAW_AE_BUF_SIZE + ISP_FRGB_GAMMA_BUF_SIZE + ISP_YUV_YGAMMA_BUF_SIZE + ISP_RAW_AWB_BUF_SIZE;
  54
  55         isp_private->block_buf_addr = (unsigned long)vzalloc(buf_len);
  56         if (0 == isp_private->block_buf_addr) {
  57                 ret = -1;
  58                 printk("isp_block_buf_alloc: no memory error.\n");
  59         } else {
  60                 isp_private->block_buf_len = buf_len;
  61                 isp_private->reg_buf_addr = isp_private->block_buf_addr;
  62                 isp_private->reg_buf_len = ISP_REG_BUF_SIZE;
  63                 isp_private->raw_aem_buf_addr = isp_private->reg_buf_addr + isp_private->reg_buf_len;
  64                 isp_private->raw_aem_buf_len = ISP_RAW_AE_BUF_SIZE;
  65                 isp_private->full_gamma_buf_addr = isp_private->raw_aem_buf_addr + isp_private->raw_aem_buf_len;
  66                 isp_private->full_gamma_buf_len = ISP_FRGB_GAMMA_BUF_SIZE;
  67                 isp_private->yuv_ygamma_buf_addr = isp_private->full_gamma_buf_addr + isp_private->full_gamma_buf_len;
  68                 isp_private->yuv_ygamma_buf_len = ISP_YUV_YGAMMA_BUF_SIZE;
  69                 isp_private->raw_awbm_buf_addr = isp_private->yuv_ygamma_buf_addr + isp_private->yuv_ygamma_buf_len;
  70                 isp_private->raw_awbm_buf_len = ISP_RAW_AWB_BUF_SIZE;
  71         }
  72
  73         return ret;
  74 }
  75
  76 static int32_t isp_block_buf_free(struct isp_k_private *isp_private)
  77 {
  78         int32_t ret = 0;
  79
  80         if ((0x00 != isp_private->block_buf_addr)
  81                 && (0x00 != isp_private->block_buf_len)) {
  82                 vfree((void *)isp_private->block_buf_addr);
  83                 isp_private->block_buf_addr = 0x00;
  84                 isp_private->block_buf_len = 0x00;
  85                 isp_private->reg_buf_addr = 0x00;
  86                 isp_private->reg_buf_len = 0x00;
  87                 isp_private->raw_aem_buf_addr = 0x00;
  88                 isp_private->raw_aem_buf_len = 0x00;
  89                 isp_private->full_gamma_buf_addr = 0x00;
  90                 isp_private->full_gamma_buf_len = 0x00;
  91                 isp_private->yuv_ygamma_buf_addr = 0x00;
  92                 isp_private->yuv_ygamma_buf_len = 0x00;
  93                 isp_private->raw_awbm_buf_addr = 0x00;
  94                 isp_private->raw_awbm_buf_len = 0x00;
  95         }
  96         return ret;
  97 }
  98
  99 static int32_t isp_yiq_antiflicker_buf_free(struct isp_k_private *isp_private)
 100 {
 101         int32_t ret = 0;
 102
 103         if ((0x00 != isp_private->yiq_antiflicker_buf_addr)
 104                 && (0x00 != isp_private->yiq_antiflicker_order)) {
 105                 free_pages(isp_private->yiq_antiflicker_buf_addr, isp_private->yiq_antiflicker_order);
 106                 isp_private->yiq_antiflicker_buf_addr = 0x00;
 107                 isp_private->yiq_antiflicker_len = 0x00;
 108                 isp_private->yiq_antiflicker_order = 0x00;
 109         }
 110
 111         return ret;
 112 }
 113
 114 static int32_t isp_yiq_antiflicker_buf_alloc(struct isp_k_private *isp_private, uint32_t len)
 115 {
 116                 int32_t ret = 0x00;
 117 #ifndef CONFIG_64BIT
 118                 uint32_t buf = 0x00;
 119                 void *ptr = NULL;
 120 #endif
 121
 122                 if (0x00 < len) {
 123                         isp_private->yiq_antiflicker_len = len;
 124                         isp_private->yiq_antiflicker_order = get_order(len);
 125                         isp_private->yiq_antiflicker_buf_addr = (unsigned long)__get_free_pages(GFP_KERNEL | __GFP_COMP, isp_private->yiq_antiflicker_order);
 126                         if (NULL == (void*)isp_private->yiq_antiflicker_buf_addr) {
 127                                 printk("isp_yiq_antiflicker_buf_alloc: memory error, addr:0x%lx, len:0x%x, order:0x%x.\n",
 128                                         isp_private->yiq_antiflicker_buf_addr,
 129                                         isp_private->yiq_antiflicker_len,
 130                                         isp_private->yiq_antiflicker_order);
 131                                 return -1;
 132                         }
 133 #ifndef CONFIG_64BIT
 134                         ptr = (void*)isp_private->yiq_antiflicker_buf_addr;
 135                         buf = virt_to_phys((volatile void *)isp_private->yiq_antiflicker_buf_addr);
 136
 137                         dmac_flush_range(ptr, ptr + len);
 138                         outer_flush_range(__pa(ptr), __pa(ptr) + len);
 139 #endif
 140                 }
 141                 return ret;
 142 }
 143
 144 static int32_t isp_lsc_buf_free(struct isp_k_private *isp_private)
 145 {
 146         int32_t ret = 0;
 147
 148         if ((0x00 != isp_private->lsc_buf_addr)
 149                 && (0x00 != isp_private->lsc_buf_order)) {
 150                 free_pages(isp_private->lsc_buf_addr, isp_private->lsc_buf_order);
 151                 isp_private->lsc_buf_addr = 0x00;
 152                 isp_private->lsc_buf_len = 0x00;
 153                 isp_private->lsc_buf_order = 0x00;
 154         }
 155
 156                 return ret;
 157 }
 158
 159 static int32_t isp_lsc_buf_alloc(struct isp_k_private *isp_private, uint32_t len)
 160 {
 161         int32_t ret = 0x00;
 162 #ifndef CONFIG_64BIT
 163         uint32_t buf = 0x00;
 164         void *ptr = NULL;
 165 #endif
 166
 167         if (0x00 < len) {
 168                 isp_private->lsc_buf_len = len;
 169                 isp_private->lsc_buf_order = get_order(len);
 170                 isp_private->lsc_buf_addr = (unsigned long)__get_free_pages(GFP_KERNEL | __GFP_COMP, isp_private->lsc_buf_order);
 171                 if (NULL == (void*)isp_private->lsc_buf_addr) {
 172                         printk("isp_lsc_buf_alloc: memory error, addr:0x%lx, len:0x%x, order:0x%x.\n",
 173                                 isp_private->lsc_buf_addr,
 174                                 isp_private->lsc_buf_len,
 175                                 isp_private->lsc_buf_order);
 176                         return -1;
 177                 }
 178         #ifndef CONFIG_64BIT
 179                 ptr = (void*)isp_private->lsc_buf_addr;
 180                 buf = virt_to_phys((volatile void *)isp_private->lsc_buf_addr);
 181
 182                 dmac_flush_range(ptr, ptr + len);
 183                 outer_flush_range(__pa(ptr), __pa(ptr) + len);
 184         #endif
 185         }
 186
 187         return ret;
 188 }
 189
 190 static int32_t isp_binging4awb_buf_free(struct isp_k_private *isp_private)
 191 {
 192         int32_t ret = 0;
 193
 194         if ((0x00 != isp_private->bing4awb_buf_addr)
 195                 && (0x00 != isp_private->bing4awb_buf_len)) {
 196                 free_pages(isp_private->bing4awb_buf_addr, isp_private->bing4awb_buf_len);
 197                 isp_private->bing4awb_buf_addr = 0x00;
 198                 isp_private->bing4awb_buf_len = 0x00;
 199                 isp_private->bing4awb_buf_order = 0x00;
 200         }
 201
 202         return ret;
 203 }
 204
 205 static int32_t isp_binging4awb_buf_alloc(struct isp_k_private *isp_private, uint32_t len)
 206 {
 207         int32_t ret = 0x00;
 208 #ifndef CONFIG_64BIT
 209         uint32_t buf = 0x00;
 210         void *ptr = NULL;
 211 #endif
 212
 213         if (0x00 < len) {
 214                 isp_private->bing4awb_buf_len = len;
 215                 isp_private->bing4awb_buf_order = get_order(len);
 216                 isp_private->bing4awb_buf_addr = (unsigned long)__get_free_pages(GFP_KERNEL | __GFP_COMP,
 217                         isp_private->bing4awb_buf_order);
 218                 if (NULL == (void *)isp_private->bing4awb_buf_addr) {
 219                         printk("isp_binging4awb_buf_alloc: memory error, addr:0x%lx, len:0x%x, order:0x%x.\n",
 220                                 isp_private->bing4awb_buf_addr,
 221                                 isp_private->bing4awb_buf_len,
 222                                 isp_private->bing4awb_buf_order);
 223                         return -1;
 224                 }
 225         #ifndef CONFIG_64BIT
 226                 ptr = (void *)isp_private->bing4awb_buf_addr;
 227                 buf = virt_to_phys((volatile void *)isp_private->bing4awb_buf_addr);
 228                 dmac_flush_range(ptr, ptr + len);
 229                 outer_flush_range(__pa(ptr), __pa(ptr) + len);
 230         #endif
 231         }
 232
 233         return ret;
 234 }
 235
 236 static int32_t isp_b4awb_switch_buf(struct isp_k_private *isp_private)
 237 {
 238         int32_t ret = 0;
 239         int32_t i = 0;
 240
 241         /*first bypass b4awb*/
 242         REG_MWR(ISP_BINNING_PARAM, BIT_0, 0x1);
 243
 244         /*switch buf*/
 245         if (isp_private->b4awb_buf[0].buf_flag == 1) {
 246                 isp_private->b4awb_buf[1].buf_flag = 1;
 247                 REG_WR(ISP_BINNING_MEM_ADDR, isp_private->b4awb_buf[1].buf_phys_addr);
 248                 isp_private->b4awb_buf[0].buf_flag = 0;
 249         } else if (isp_private->b4awb_buf[1].buf_flag == 1) {
 250                 isp_private->b4awb_buf[0].buf_flag = 1;
 251                 REG_WR(ISP_BINNING_MEM_ADDR, isp_private->b4awb_buf[0].buf_phys_addr);
 252                 isp_private->b4awb_buf[1].buf_flag = 0;
 253         }
 254
 255         /*enable b4awb*/
 256         REG_MWR(ISP_BINNING_PARAM, BIT_0, 0x0);
 257
 258         return ret;
 259 }
 260
 261 static void isp_read_reg(struct isp_reg_bits *reg_bits_ptr, uint32_t counts)
 262 {
 263         uint32_t i = 0;
 264         unsigned long reg_val = 0, reg_addr = 0;
 265
 266         for (i = 0; i < counts; i++) {
 267                 reg_addr = ISP_BASE_ADDR + reg_bits_ptr[i].reg_addr;
 268                 reg_val = REG_RD(reg_addr);
 269                 reg_bits_ptr[i].reg_value = reg_val;
 270                 reg_bits_ptr[i].reg_addr = reg_addr;
 271         }
 272 }
 273
 274 static void isp_write_reg(struct isp_reg_bits *reg_bits_ptr, uint32_t counts)
 275 {
 276         uint32_t i = 0;
 277         unsigned long reg_val = 0, reg_addr = 0;
 278
 279         for (i = 0; i < counts; i++) {
 280                 reg_addr = reg_bits_ptr[i].reg_addr + ISP_BASE_ADDR;
 281                 reg_val = reg_bits_ptr[i].reg_value;
 282                 REG_WR(reg_addr, reg_val);
 283         }
 284 }
 285
 286 static int32_t isp_queue_init(struct isp_queue *queue)
 287 {
 288         if (NULL == queue) {
 289                 printk("isp_queue_init: queue is null error.\n");
 290                 return -1;
 291         }
 292
 293         memset(queue, 0x00, sizeof(*queue));
 294         queue->write = &queue->node[0];
 295         queue->read  = &queue->node[0];
 296         return 0;
 297 }
 298
 299 static int32_t isp_queue_write(struct isp_queue *queue, struct isp_node *node)
 300 {
 301         struct isp_node *ori_node = NULL;
 302
 303         if (NULL == queue || NULL == node) {
 304                 printk("isp_queue_write: queue or node is null error %p %p\n",
 305                         queue, node);
 306                 return -1;
 307         }
 308
 309         ori_node = queue->write;
 310
 311         *queue->write++ = *node;
 312         if (queue->write > &queue->node[ISP_QUEUE_LENGTH-1])
 313                 queue->write = &queue->node[0];
 314
 315         if (queue->write == queue->read)
 316                 queue->write = ori_node;
 317         return 0;
 318 }
 319
 320 static int32_t isp_queue_read(struct isp_queue *queue, struct isp_node *node)
 321 {
 322         if (NULL == queue || NULL == node) {
 323                 printk("isp_queue_read: queue or node is null error %p %p\n",
 324                         queue, node);
 325                 return -1;
 326         }
 327         if (queue->read != queue->write) {
 328                 *node = *queue->read++;
 329                 if (queue->read > &queue->node[ISP_QUEUE_LENGTH-1])
 330                         queue->read = &queue->node[0];
 331         }
 332         return 0;
 333 }
 334
 335 static int32_t isp_set_clk(struct isp_k_file *file, enum isp_clk_sel clk_sel)
 336 {
 337         int32_t ret = 0;
 338         char *parent = "clk_256m";
 339         struct clk *clk_parent = NULL;
 340         struct isp_k_private *isp_private = NULL;
 341
 342         if (!file) {
 343                 printk("isp_set_clk: file is null error.\n");
 344                 return -1;
 345         }
 346
 347         isp_private = file->isp_private;
 348         if (!isp_private) {
 349                 printk("isp_set_clk: isp_private is null error.\n");
 350                 return -1;
 351         }
 352
 353         switch (clk_sel) {
 354         case ISP_CLK_480M:
 355                 parent = "clk_usbpll";
 356                 break;
 357         case ISP_CLK_384M:
 358                 parent = "clk_384m";
 359                 break;
 360         case ISP_CLK_312M:
 361                 parent = "clk_312m";
 362                 break;
 363         case ISP_CLK_256M:
 364                 parent = "clk_256m";
 365                 break;
 366         case ISP_CLK_128M:
 367                 parent = "clk_128m";
 368                 break;
 369         case ISP_CLK_48M:
 370                 parent = "clk_48m";
 371                 break;
 372         case ISP_CLK_76M8:
 373                 parent = "clk_76p8m";
 374                 break;
 375         case ISP_CLK_NONE:
 376                 printk("isp_set_clk: close clock %d\n", (int)clk_get_rate(isp_private->clock));
 377                 if (isp_private->clock) {
 378                         clk_disable(isp_private->clock);
 379                         clk_put(isp_private->clock);
 380                         isp_private->clock = NULL;
 381                 }
 382                 return 0;
 383         default:
 384                 parent = "clk_128m";
 385                 break;
 386         }
 387
 388         if (NULL == isp_private->clock) {
 389                 isp_private->clock = parse_clk(isp_private->dn, "clk_isp");
 390                 if (IS_ERR(isp_private->clock)) {
 391                         printk("isp_set_clk: parse_clk error.\n");
 392                         return -1;
 393                 }
 394         } else {
 395                 clk_disable(isp_private->clock);
 396         }
 397
 398         clk_parent = clk_get(NULL, parent);
 399         if (IS_ERR(clk_parent)) {
 400                 printk("isp_set_clk: clk_get error %d\n", (int)clk_parent);
 401                 return -1;
 402         }
 403
 404         ret = clk_set_parent(isp_private->clock, clk_parent);
 405         if(ret){
 406                 printk("isp_set_clk: clk_set_parent error.\n");
 407         }
 408
 409         ret = clk_enable(isp_private->clock);
 410         if (ret) {
 411                 printk("isp_set_clk: clk_enable error.\n");
 412                 return -1;
 413         }
 414         return ret;
 415 }
 416
 417 static int32_t isp_module_rst(struct isp_k_file *file)
 418 {
 419         int32_t ret = 0;
 420         struct isp_k_private *isp_private = NULL;
 421
 422         if (!file) {
 423                 printk("isp_module_rst: file is null error.\n");
 424                 return -1;
 425         }
 426         isp_private = file->isp_private;
 427         if (!isp_private) {
 428                 printk("isp_module_rst: isp_private is null error.\n");
 429                 return -1;
 430         }
 431         if (0x00 != atomic_read(&isp_private->users)) {
 432                 ret = isp_axi_bus_waiting();
 433
 434                 isp_clr_int();
 435                 sci_glb_set(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
 436                 sci_glb_set(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
 437                 sci_glb_set(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
 438                 sci_glb_set(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
 439                 sci_glb_set(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
 440                 sci_glb_set(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
 441                 sci_glb_clr(ISP_MODULE_RESET, ISP_RST_CFG_BIT);
 442                 sci_glb_clr(ISP_MODULE_RESET, ISP_RST_LOG_BIT);
 443         }
 444         return ret;
 445 }
 446
 447 static int32_t isp_module_eb(struct isp_k_file *file)
 448 {
 449         int32_t ret = 0;
 450         struct isp_k_private *isp_private = NULL;
 451
 452         if (!file) {
 453                 printk("isp_module_eb: file is null error.\n");
 454                 return -1;
 455         }
 456
 457         isp_private = file->isp_private;
 458         if (!isp_private) {
 459                 printk("isp_module_eb: isp_private is null error.\n");
 460                 return -1;
 461         }
 462
 463         if (0x01 == atomic_inc_return(&isp_private->users)) {
 464
 465                 ret = clk_mm_i_eb(isp_private->dn, 1);
 466                 if (unlikely(0 != ret)) {
 467                         ret = -1;
 468                         printk("isp_module_eb: clk_mm_i_eb error.\n");
 469                 }
 470
 471         #if defined(CONFIG_MACH_SP7720EA)
 472                 ret = isp_set_clk(file, ISP_CLK_256M);
 473         #elif defined(CONFIG_ARCH_SCX35LT8)
 474                 ret = isp_set_clk(file, ISP_CLK_480M);
 475         #else
 476                 ret = isp_set_clk(file, ISP_CLK_312M);
 477         #endif
 478                 if (unlikely(0 != ret)) {
 479                         ret = -1;
 480                         printk("isp_module_eb: isp_set_clk error.\n");
 481                 }
 482         }
 483
 484         return ret;
 485 }
 486
 487 static int32_t isp_module_dis(struct isp_k_file *file)
 488 {
 489         int32_t ret = 0;
 490         struct isp_k_private *isp_private = NULL;
 491
 492         if (!file) {
 493                 printk("isp_module_dis: file is null error.\n");
 494                 return -1;
 495         }
 496
 497         isp_private = file->isp_private;
 498         if (!isp_private) {
 499                 printk("isp_module_dis: isp_private is null error.\n");
 500                 return -1;
 501         }
 502
 503         if (0x00 == atomic_dec_return(&isp_private->users)) {
 504
 505                 ret = isp_set_clk(file, ISP_CLK_NONE);
 506                 if (unlikely(0 != ret)) {
 507                         ret = -1;
 508                         printk("isp_module_dis: isp_set_clk error.\n");
 509                 }
 510
 511                 ret = clk_mm_i_eb(isp_private->dn, 0);
 512                 if (unlikely(0 != ret)) {
 513                         ret = -1;
 514                         printk("isp_module_dis: close clk_mm_i error.\n");
 515                 }
 516         }
 517
 518         return ret;
 519 }
 520
 521 static irqreturn_t isp_isr(int irq, void *dev_id)
 522 {
 523         int32_t ret = 0;
 524         unsigned long flag = 0;
 525         struct isp_node node;
 526         struct isp_k_file *fd = NULL;
 527         struct isp_drv_private *drv_private = NULL;
 528
 529         if (!dev_id) {
 530                 printk("isp_isr: dev_id is null error.\n");
 531                 return IRQ_NONE;
 532         }
 533
 534         fd = (struct isp_k_file *)dev_id;
 535         drv_private = (struct isp_drv_private *)&fd->drv_private;
 536
 537         if (!drv_private) {
 538                 printk("isp_isr: drv_private is null error.\n");
 539                 return IRQ_NONE;
 540         }
 541
 542         spin_lock_irqsave(&drv_private->isr_lock, flag);
 543         memset(&node, 0x00, sizeof(node));
 544         ret = isp_get_int_num(&node);
 545
 546         /*B4AWB INT*/
 547         if (node.irq_val1 & BIT_18) {
 548                 isp_b4awb_switch_buf(fd->isp_private);
 549         }
 550
 551         isp_queue_write((struct isp_queue *)&drv_private->queue, (struct isp_node *)&node);
 552         spin_unlock_irqrestore(&drv_private->isr_lock, flag);
 553
 554         up(&drv_private->isr_done_lock);
 555
 556         if (ret) {
 557                 return IRQ_NONE;
 558         } else {
 559                 return IRQ_HANDLED;
 560         }
 561 }
 562
 563 static int32_t isp_register_irq(struct isp_k_file *file)
 564 {
 565         int32_t ret = 0;
 566
 567         ret = request_irq(ISP_IRQ, isp_isr, IRQF_SHARED, "ISP", (void *)file);
 568
 569         return ret;
 570 }
 571
 572 static void isp_unregister_irq(struct isp_k_file *file)
 573 {
 574         free_irq (ISP_IRQ, (void *)file);
 575 }
 576
 577 static int isp_open (struct inode *node, struct file *file)
 578 {
 579         int ret = 0;
 580         struct isp_k_private *isp_private = s_isp_private;//platform_get_drvdata(rot_get_platform_device())
 581         struct isp_k_file *fd = NULL;
 582
 583         if (!file) {
 584                 ret = -EINVAL;
 585                 printk("isp_open: file is null error.\n");
 586                 return ret;
 587         }
 588
 589         if (!isp_private) {
 590                 ret = -EFAULT;
 591                 printk("isp_open: isp_private is null, error.\n");
 592                 return ret;
 593         }
 594
 595         down(&isp_private->device_lock);
 596
 597         fd = vzalloc(sizeof(*fd));
 598         if (!fd) {
 599                 ret = -ENOMEM;
 600                 up(&isp_private->device_lock);
 601                 printk("isp_open: no memory for fd, error.\n");
 602                 return ret;
 603         }
 604
 605         fd->isp_private = isp_private;
 606
 607         spin_lock_init(&fd->drv_private.isr_lock);
 608         sema_init(&fd->drv_private.isr_done_lock, 0);
 609         ret = isp_queue_init(&(fd->drv_private.queue));
 610         if (unlikely(0 != ret)) {
 611                 ret = -EFAULT;
 612                 vfree(fd);
 613                 up(&isp_private->device_lock);
 614                 printk("isp_open: isp_queue_init error.\n");
 615                 return ret;
 616         }
 617
 618         ret = isp_module_eb(fd);
 619         if (unlikely(0 != ret)) {
 620                 ret = -EIO;
 621                 printk("isp_open: isp_module_eb error.\n");
 622                 goto open_exit;
 623         }
 624
 625         ret = isp_module_rst(fd);
 626         if (unlikely(0 != ret)) {
 627                 ret = -EIO;
 628                 isp_module_dis(fd);
 629                 printk("isp_open: isp_module_rst error.\n");
 630                 goto open_exit;
 631         }
 632
 633         ret = isp_register_irq(fd);
 634         if (unlikely(0 != ret)) {
 635                 ret = -EIO;
 636                 isp_module_dis(fd);
 637                 printk("isp_open: isp_register_irq error.\n");
 638                 goto open_exit;
 639         }
 640
 641         file->private_data = fd;
 642
 643         printk("isp_open: success.\n");
 644
 645         return ret;
 646
 647 open_exit:
 648         vfree(fd);
 649         fd = NULL;
 650
 651         file->private_data = NULL;
 652
 653         up(&isp_private->device_lock);
 654
 655         return ret;
 656 }
 657
 658 static int isp_release (struct inode *node, struct file *file)
 659 {
 660         int ret = 0;
 661         struct isp_k_private *isp_private = NULL;
 662         struct isp_k_file *fd = NULL;
 663
 664         if (!file) {
 665                 ret = -EINVAL;
 666                 printk("isp_release: file is null error.\n");
 667                 return ret;
 668         }
 669
 670         fd = file->private_data;
 671         if (!fd) {
 672                 ret = -EFAULT;
 673                 printk("isp_release: fd is null error.\n");
 674                 return ret;
 675         }
 676
 677         isp_private = fd->isp_private;
 678         if (!isp_private) {
 679                 printk("isp_release: isp_private is null error.\n");
 680                 goto fd_free;
 681         }
 682
 683         down(&isp_private->ioctl_lock);
 684
 685         isp_unregister_irq(fd);
 686
 687         ret = isp_module_dis(fd);
 688
 689         up(&isp_private->ioctl_lock);
 690
 691 fd_free:
 692         vfree(fd);
 693         fd = NULL;
 694
 695         file->private_data = NULL;
 696
 697         if (isp_private)
 698                 up(&isp_private->device_lock);
 699
 700         printk("isp_release: success.\n");
 701
 702         return 0;
 703 }
 704
 705 static long isp_ioctl( struct file *file, unsigned int cmd, unsigned long param)
 706 {
 707         long ret = 0;
 708         struct isp_irq irq_param;
 709         struct isp_node node;
 710         struct isp_reg_param reg_param = {0, 0};
 711         struct isp_reg_bits *reg_bits_ptr = NULL;
 712         struct isp_k_private *isp_private = NULL;
 713         struct isp_drv_private *drv_private = NULL;
 714         struct isp_k_file *fd = NULL;
 715
 716         if (!file) {
 717                 ret = -EINVAL;
 718                 printk("isp_ioctl: file is null error.\n");
 719                 return ret;
 720         }
 721
 722         fd = file->private_data;
 723         if (!fd) {
 724                 ret = - EFAULT;
 725                 printk("isp_ioctl: private_data is null error.\n");
 726                 return ret;
 727         }
 728
 729         isp_private = fd->isp_private;
 730         if (!isp_private) {
 731                 ret = -EFAULT;
 732                 printk("isp_ioctl: isp_private is null error.\n");
 733                 return ret;
 734         }
 735
 736         drv_private = &fd->drv_private;
 737
 738         switch (cmd) {
 739         case ISP_IO_IRQ:
 740         {
 741                 ret = down_interruptible(&fd->drv_private.isr_done_lock);
 742                 if (ret) {
 743                         memset(&irq_param, 0, sizeof(irq_param));
 744                         irq_param.ret_val = ret;
 745                         ret = copy_to_user ((void *)param, (void *)&irq_param, sizeof(irq_param));
 746                         if ( 0 != ret) {
 747                                 printk("isp_ioctl: irq: copy_to_user error ret = %d\n", (uint32_t)ret);
 748                         }
 749                         ret = -ERESTARTSYS;
 750                         return ret;
 751                 }
 752
 753                 ret = isp_queue_read(&drv_private->queue, &node);
 754                 if (0 != ret) {
 755                         ret = -EFAULT;
 756                         printk("isp_ioctl: isp_queue_read error, ret = 0x%x\n", (uint32_t)ret);
 757                         return ret;
 758                 }
 759
 760                 memset(&irq_param, 0, sizeof(irq_param));
 761                 irq_param.irq_val0 = node.irq_val0;
 762                 irq_param.irq_val1 = node.irq_val1;
 763                 irq_param.irq_val2 = node.irq_val2;
 764                 irq_param.irq_val3 = node.irq_val3;
 765                 irq_param.reserved = node.reserved;
 766                 ret = copy_to_user ((void *)param, (void *)&irq_param, sizeof(irq_param));
 767                 if (0 != ret) {
 768                         ret = -EFAULT;
 769                         printk("isp_k: ioctl irq: copy_to_user error, ret = 0x%x", (uint32_t)ret);
 770                 }
 771                 break;
 772         }
 773
 774         case ISP_IO_READ:
 775         {
 776                 uint32_t buf_size = 0;
 777
 778                 down(&isp_private->ioctl_lock);
 779
 780                 ret = copy_from_user((void *)&reg_param, (void *)param, sizeof(struct isp_reg_param));
 781                 if ( 0 != ret) {
 782                         ret = -EFAULT;
 783                         printk("isp_ioctl: read copy_from_user 0 error, ret = 0x%x\n", (uint32_t)ret);
 784                         goto io_read_exit;
 785                 }
 786
 787                 buf_size = reg_param.counts * sizeof(struct isp_reg_bits);
 788                 if (buf_size > isp_private->reg_buf_len) {
 789                         ret = -EFAULT;
 790                         printk("isp_ioctl: read buf len error.\n");
 791                         goto io_read_exit;
 792                 }
 793
 794                 reg_bits_ptr = (struct isp_reg_bits *)isp_private->reg_buf_addr;
 795                 ret = copy_from_user((void *)reg_bits_ptr, (void *)reg_param.reg_param, buf_size);
 796                 if ( 0 != ret) {
 797                         ret = -EFAULT;
 798                         printk("isp_ioctl: read copy_from_user 1 error, ret = 0x%x\n", (uint32_t)ret);
 799                         goto io_read_exit;
 800                 }
 801
 802                 isp_read_reg(reg_bits_ptr, reg_param.counts);
 803
 804                 ret = copy_to_user((void *)reg_param.reg_param, (void *)reg_bits_ptr, buf_size);
 805                 if ( 0 != ret) {
 806                         ret = -EFAULT;
 807                         printk("isp_ioctl: read copy_to_user error, ret = 0x%x\n", (uint32_t)ret);
 808                         goto io_read_exit;
 809                 }
 810
 811                 io_read_exit:
 812                 if (reg_bits_ptr) {
 813                         memset((void *)isp_private->reg_buf_addr, 0x00, buf_size);
 814                         reg_bits_ptr = NULL;
 815                 }
 816
 817                 up(&isp_private->ioctl_lock);
 818
 819                 break;
 820         }
 821
 822         case ISP_IO_WRITE:
 823         {
 824                 uint32_t buf_size = 0;
 825
 826                 down(&isp_private->ioctl_lock);
 827
 828                 ret = copy_from_user((void *)&reg_param, (void *)param, sizeof(struct isp_reg_param));
 829                 if ( 0 != ret) {
 830                         printk("isp_ioctl: write copy_from_user 0 error, ret = 0x%x\n", (uint32_t)ret);
 831                         ret = -EFAULT;
 832                         goto io_write_exit;
 833                 }
 834
 835                 buf_size = reg_param.counts * sizeof(struct isp_reg_bits);
 836                 if (buf_size > isp_private->reg_buf_len) {
 837                         ret = -EFAULT;
 838                         printk("isp_ioctl: write buf len error.\n");
 839                         goto io_write_exit;
 840                 }
 841
 842                 reg_bits_ptr = (struct isp_reg_bits *)isp_private->reg_buf_addr;
 843                 ret = copy_from_user((void *)reg_bits_ptr, (void *)reg_param.reg_param, buf_size);
 844                 if ( 0 != ret) {
 845                         ret = -EFAULT;
 846                         printk("isp_ioctl: write copy_from_user 1 error, ret = 0x%x\n", (uint32_t)ret);
 847                         goto io_write_exit;
 848                 }
 849
 850                 isp_write_reg(reg_bits_ptr, reg_param.counts);
 851
 852                 io_write_exit:
 853                 if (reg_bits_ptr) {
 854                         memset((void *)isp_private->reg_buf_addr, 0x00, buf_size);
 855                         reg_bits_ptr = NULL;
 856                 }
 857
 858                 up(&isp_private->ioctl_lock);
 859
 860                 break;
 861         }
 862
 863         case ISP_IO_RST:
 864         {
 865                 down(&isp_private->ioctl_lock);
 866
 867                 ret = isp_module_rst(fd);
 868                 if (ret) {
 869                         ret = -EFAULT;
 870                         printk("isp_ioctl: restet error.\n");
 871                 }
 872
 873                 up(&isp_private->ioctl_lock);
 874
 875                 break;
 876         }
 877
 878         case ISP_IO_STOP:
 879         {
 880                 unsigned long flag = 0;
 881                 struct isp_node node;
 882
 883                 down(&isp_private->ioctl_lock);
 884
 885                 isp_en_irq(ISP_INT_CLEAR_MODE);
 886
 887                 spin_lock_irqsave(&drv_private->isr_lock,flag);
 888                 memset(&node, 0x00, sizeof(node));
 889                 node.reserved = ISP_INT_EVT_STOP;
 890                 isp_queue_write((struct isp_queue *)&drv_private->queue, (struct isp_node *)&node);
 891                 spin_unlock_irqrestore(&drv_private->isr_lock, flag);
 892
 893                 up(&fd->drv_private.isr_done_lock);
 894
 895                 up(&isp_private->ioctl_lock);
 896
 897                 break;
 898         }
 899
 900         case ISP_IO_INT:
 901         {
 902                 struct isp_interrupt int_param;
 903
 904                 down(&isp_private->ioctl_lock);
 905
 906                 ret = copy_from_user((void *)&int_param, (void *)param, sizeof(int_param));
 907                 if (ret) {
 908                         ret = -EFAULT;
 909                         printk("isp_ioctl: int copy_from_user error, ret = %d\n", (uint32_t)ret);
 910                 }
 911
 912                 if (0 == ret)
 913                         isp_en_irq(int_param.int_mode);
 914
 915                 up(&isp_private->ioctl_lock);
 916
 917                 break;
 918         }
 919
 920         case ISP_IO_CFG_PARAM:
 921                 down(&isp_private->ioctl_lock);
 922                 ret = isp_cfg_param((void *)param, isp_private);
 923                 up(&isp_private->ioctl_lock);
 924                 break;
 925
 926         case ISP_IO_CAPABILITY:
 927                 ret = isp_capability((void *)param);
 928                 break;
 929
 930         case ISP_REG_READ:
 931         {
 932                 int ret;
 933                 int num;
 934                 int i;
 935                 int ISP_REG_NUM = 20467;
 936
 937                 struct isp_reg_bits *ptr = (struct isp_reg_bits *)vmalloc(ISP_REG_NUM * sizeof(struct isp_reg_bits));
 938
 939                 if (NULL == ptr) {
 940                         printk("isp_ioctl:REG_READ: kmalloc error\n");
 941                         return -ENOMEM;
 942                 }
 943                 memset(ptr, 0, ISP_REG_NUM * sizeof(struct isp_reg_bits));
 944
 945                 num = isp_wr_addr(ptr);
 946
 947                 isp_read_reg(ptr, num);
 948
 949                 ret = copy_to_user((void *)param, (void *)ptr, ISP_REG_NUM * sizeof(struct isp_reg_bits));
 950                 if ( 0 != ret) {
 951                         printk("isp_ioctl: REG_READ: copy_to_user error ret = %d\n", (uint32_t)ret);
 952                         vfree(ptr);
 953                         return ret;
 954                         }
 955                 vfree(ptr);
 956                 break;
 957         }
 958
 959         default:
 960                 printk("isp_ioctl: cmd is unsupported, cmd = %x\n", (int32_t)cmd);
 961                 return -EFAULT;
 962         }
 963
 964         return ret;
 965 }
 966
 967 static struct file_operations isp_fops = {
 968         .owner = THIS_MODULE,
 969         .open = isp_open,
 970         .unlocked_ioctl = isp_ioctl,
 971         .compat_ioctl = compat_isp_ioctl,
 972         .release = isp_release,
 973 };
 974
 975 static struct miscdevice isp_dev = {
 976         .minor = ISP_MINOR,
 977         .name = "sprd_isp",
 978         .fops = &isp_fops,
 979 };
 980
 981 static int isp_probe(struct platform_device *pdev)
 982 {
 983         int ret = 0;
 984         struct isp_k_private *isp_private = NULL;
 985
 986         isp_private = devm_kzalloc(&pdev->dev, sizeof(*isp_private), GFP_KERNEL);
 987         if (!isp_private) {
 988                 printk("isp_probe: isp_private is null error.\n");
 989                 return -ENOMEM;
 990         }
 991
 992         atomic_set(&isp_private->users, 0);
 993         isp_private->dn = pdev->dev.of_node;
 994         isp_private->clock = NULL;
 995         sema_init(&isp_private->device_lock, 1);
 996         sema_init(&isp_private->ioctl_lock, 1);
 997         ret = isp_block_buf_alloc(isp_private);
 998         if (ret) {
 999                 ret = -ENOMEM;
1000                 devm_kfree(&pdev->dev, isp_private);
1001                 printk("isp_probe: no memory for isp_private, error.\n");
1002                 return ret;
1003         }
1004
1005         platform_set_drvdata(pdev, isp_private);
1006         s_isp_private = isp_private;
1007         ret = isp_lsc_buf_alloc(isp_private, ISP_LSC_BUF_SIZE);
1008         if (ret) {
1009                 ret = -ENOMEM;
1010                 isp_block_buf_free(isp_private);
1011                 devm_kfree(&pdev->dev, isp_private);
1012                 platform_set_drvdata(pdev, NULL);
1013                 printk("isp_probe: no memory for isp lsc buf alloc, error.\n");
1014                 return ret;
1015         }
1016
1017         ret = isp_binging4awb_buf_alloc(isp_private, ISP_BING4AWB_SIZE);
1018         if (ret) {
1019                 ret = -ENOMEM;
1020                 isp_lsc_buf_free(isp_private);
1021                 isp_block_buf_free(isp_private);
1022                 devm_kfree(&pdev->dev, isp_private);
1023                 platform_set_drvdata(pdev, NULL);
1024                 printk("isp_probe: no memory for isp lsc buf alloc, error.\n");
1025                 return ret;
1026         }
1027
1028         ret = isp_yiq_antiflicker_buf_alloc(isp_private, ISP_YIQ_ANTIFLICKER_SIZE);
1029         if (ret) {
1030                 ret = -ENOMEM;
1031                 isp_binging4awb_buf_free(isp_private);
1032                 isp_lsc_buf_free(isp_private);
1033                 isp_block_buf_free(isp_private);
1034                 devm_kfree(&pdev->dev, isp_private);
1035                 platform_set_drvdata(pdev, NULL);
1036                 printk("isp_probe: no memory for isp lsc buf alloc, error.\n");
1037                 return ret;
1038         }
1039
1040         ret = misc_register(&isp_dev);
1041         if (ret) {
1042                 ret = -EACCES;
1043                 isp_yiq_antiflicker_buf_free(isp_private);
1044                 isp_binging4awb_buf_free(isp_private);
1045                 isp_lsc_buf_free(isp_private);
1046                 isp_block_buf_free(isp_private);
1047                 devm_kfree(&pdev->dev, isp_private);
1048                 platform_set_drvdata(pdev, NULL);
1049                 printk("isp_probe: misc_register error.\n");
1050         }
1051
1052         parse_baseaddress(pdev->dev.of_node);
1053         printk("isp_probe: success.\n");
1054
1055         return ret;
1056 }
1057
1058 static int isp_remove(struct platform_device *dev)
1059 {
1060         struct isp_k_private *isp_private = NULL;
1061
1062         isp_private = platform_get_drvdata(dev);
1063
1064         if (isp_private) {
1065                 isp_yiq_antiflicker_buf_free(isp_private);
1066                 isp_binging4awb_buf_free(isp_private);
1067                 isp_lsc_buf_free(isp_private);
1068                 isp_block_buf_free(isp_private);
1069                 devm_kfree(&dev->dev, isp_private);
1070                 platform_set_drvdata(dev, NULL);
1071         } else {
1072                 printk("isp_remove: isp_private is null error.\n");
1073         }
1074
1075         misc_deregister(&isp_dev);
1076         printk("isp_remove: success.\n");
1077         return 0;
1078 }
1079
1080 static const struct of_device_id of_match_table_isp[] = {
1081         { .compatible = "sprd,sprd_isp", },
1082         { },
1083 };
1084
1085 static struct platform_driver isp_driver = {
1086         .probe = isp_probe,
1087         .remove = isp_remove,
1088         .driver = {
1089                 .owner = THIS_MODULE,
1090                 .name = "sprd_isp",
1091                 .of_match_table = of_match_ptr(of_match_table_isp),
1092         },
1093 };
1094
1095 static int __init isp_init(void)
1096 {
1097         printk ("isp_init: success.\n");
1098
1099         if (platform_driver_register(&isp_driver)) {
1100                 printk ("isp_init: platform_driver_register error.\n");
1101                 return -1;
1102         }
1103
1104         return 0;
1105 }
1106
1107 static void __exit isp_exit(void)
1108 {
1109         printk ("isp_exit: success.\n");
1110
1111         platform_driver_unregister(&isp_driver);
1112 }
1113
1114 static int isp_wr_addr(struct isp_reg_bits *ptr)
1115 {
1116                 int i;
1117                 int sum = 0;
1118
1119                 if(NULL == ptr){
1120                         printk("isp_wr_addr: ptr\n");
1121                         return -1;
1122                 }
1123
1124                 struct isp_reg_bits *ptr_reg = ptr;
1125
1126                 ptr_reg -> reg_addr = 0x0000; /* Interrupt part*/
1127                 sum++;
1128
1129                 for (i = 0; i < 17; i++)
1130                 {
1131                         ptr_reg++;
1132                         ptr_reg -> reg_addr = 0x0014 + i * 0x4;
1133                         sum++;
1134                 }
1135
1136                 for (i = 0; i < 4; i++)    /*Fetch*/
1137                 {
1138                         ptr_reg++;
1139                         ptr_reg -> reg_addr = 0x0100 + i * 0x4;
1140                         sum++;
1141                 }
1142
1143                 for(i = 0; i < 2; i++)
1144                 {
1145                         ptr_reg++;
1146                         ptr_reg -> reg_addr = 0x0114 + i * 0x4;
1147                         sum++;
1148                 }
1149
1150                 for(i = 0; i < 10; i++)
1151                 {
1152                         ptr_reg++;
1153                         ptr_reg -> reg_addr = 0x0120 + i * 0x4;
1154                         sum++;
1155                 }
1156
1157                 for(i = 0; i < 4; i++)  /* store*/
1158                 {
1159                         ptr_reg++;
1160                         ptr_reg -> reg_addr = 0x0200 + i * 0x4;
1161                         sum++;
1162                 }
1163
1164                 for(i = 0; i < 10; i++)
1165                 {
1166                         ptr_reg++;
1167                         ptr_reg -> reg_addr = 0x0214 + i * 0x4;
1168                         sum++;
1169                 }
1170
1171                 for(i = 0; i < 12; i++) /* dispatch */
1172                 {
1173                         ptr_reg++;
1174                         ptr_reg -> reg_addr = 0x0300 + i * 0x4;
1175                         sum++;
1176                 }
1177
1178                 for(i = 0; i < 2; i++) /* arbiter */
1179                 {
1180                         ptr_reg++;
1181                         ptr_reg -> reg_addr = 0x0400 + i * 0x4;
1182                         sum++;
1183                 }
1184
1185                 for(i = 0; i < 4; i++)
1186                 {
1187                         ptr_reg++;
1188                         ptr_reg -> reg_addr = 0x0414 + i * 0x4;
1189                         sum++;
1190                 }
1191
1192                 for(i = 0; i < 2; i++)  /* axi */
1193                 {
1194                         ptr_reg++;
1195                         ptr_reg -> reg_addr = 0x0500 + i * 0x4;
1196                         sum++;
1197                 }
1198
1199                 for(i = 0; i < 2; i++)
1200                 {
1201                         ptr_reg++;
1202                         ptr_reg -> reg_addr = 0x0514 + i * 0x4;
1203                         sum++;
1204                 }
1205
1206                 ptr_reg++;      /* raw sizer */
1207                 ptr_reg -> reg_addr = 0x0600;
1208                 sum++;
1209
1210                 for(i = 0; i < 45; i++)
1211                 {
1212                         ptr_reg++;
1213                         ptr_reg -> reg_addr = 0x0614 + i * 0x4;
1214                         sum++;
1215                 }
1216
1217                 for(i = 0; i < 3; i++)  /* common */
1218                 {
1219                         ptr_reg++;
1220             ptr_reg -> reg_addr = 0x0700 + i * 0x4;
1221                         sum++;
1222         }
1223
1224                 for(i = 0; i < 16; i++)
1225         {
1226             ptr_reg++;
1227             ptr_reg -> reg_addr = 0x0714 + i * 0x4;
1228                         sum++;
1229         }
1230
1231                 for(i = 0; i < 2; i++) /* global gain */
1232                 {
1233                         ptr_reg++;
1234                         ptr_reg -> reg_addr = 0x1000 + i * 0x14;
1235                         sum++;
1236                 }
1237
1238                 ptr_reg++;  /* BLC */
1239                 ptr_reg -> reg_addr = 0x1100;
1240                 sum++;
1241
1242                 for(i = 0; i < 3; i++)
1243                 {
1244                         ptr_reg++;
1245                         ptr_reg -> reg_addr = 0x1114 + i * 0x4;
1246                         sum++;
1247                 }
1248
1249                 ptr_reg++;  /* RGBG */
1250                 ptr_reg -> reg_addr = 0x1200;
1251                 sum++;
1252
1253                 for(i = 0; i < 3; i++)
1254                 {
1255                         ptr_reg++;
1256                         ptr_reg -> reg_addr = 0x1214 + i * 0x4;
1257                         sum++;
1258                 }
1259
1260                 for(i = 0; i < 2; i++) /* PWD */
1261                 {
1262                         ptr_reg++;
1263                         ptr_reg -> reg_addr = 0x1300 + i * 0x4;
1264                         sum++;
1265                 }
1266
1267                 for(i = 0; i < 11; i++)
1268                 {
1269                         ptr_reg++;
1270                         ptr_reg -> reg_addr = 0x1314 + i * 0x4;
1271                         sum++;
1272                 }
1273
1274                 ptr_reg++;  /* NLC */
1275                 ptr_reg -> reg_addr = 0x1400;
1276                 sum++;
1277
1278                 for(i = 0; (ptr_reg->reg_addr) < 0x14b0; i++)
1279                 {
1280                         ptr_reg++;
1281                         ptr_reg -> reg_addr = 0x1414 + i * 0x4;
1282                         sum++;
1283                 }
1284
1285                 ptr_reg++;  /* lens shading calibration */
1286                 ptr_reg -> reg_addr = 0x1500;
1287                 sum++;
1288
1289                 for(i = 0; i < 15; i++)
1290                 {
1291                         ptr_reg++;
1292                         ptr_reg -> reg_addr = 0x1514 + i * 0x4;
1293                         sum++;
1294                 }
1295
1296                 ptr_reg++;  /* binning */
1297                 ptr_reg -> reg_addr = 0x1600;
1298                 sum++;
1299
1300                 for(i = 0; i < 3; i++)
1301                 {
1302                         ptr_reg++;
1303                         ptr_reg -> reg_addr = 0x1614 + i * 0x4;
1304                         sum++;
1305                 }
1306
1307                 ptr_reg++;  /* AWBM */
1308                 ptr_reg -> reg_addr = 0x1700;
1309                 sum++;
1310
1311                 for(i = 0; i < 34; i++)
1312                 {
1313                         ptr_reg++;
1314                         ptr_reg -> reg_addr = 0x1714 + i * 0x4;
1315                         sum++;
1316                 }
1317
1318                 for(i = 0; i < 2; i++)
1319                 {
1320                         ptr_reg++;
1321                         ptr_reg -> reg_addr = 0x17A0 + i * 0x4;
1322                         sum++;
1323                 }
1324
1325                 ptr_reg++; /* AWBC */
1326                 ptr_reg -> reg_addr = 0x1800;
1327                 sum++;
1328
1329                 for(i = 0; i < 14; i++)
1330                 {
1331                         ptr_reg++;
1332                         ptr_reg -> reg_addr = 0x1814 + i * 0x4;
1333                         sum++;
1334                 }
1335
1336                 ptr_reg++; /* AEM */
1337                 ptr_reg -> reg_addr = 0x1900;
1338                 sum++;
1339
1340                 for(i = 0; i < 4; i++)
1341                 {
1342                         ptr_reg++;
1343                         ptr_reg -> reg_addr = 0x1914 + i * 0x4;
1344                         sum++;
1345                 }
1346
1347                 ptr_reg++; /* BPC */
1348                 ptr_reg -> reg_addr = 0x1A00;
1349                 sum++;
1350
1351                 for(i = 0; i < 14; i++)
1352                 {
1353                         ptr_reg++;
1354                         ptr_reg -> reg_addr = 0x1A14 + i * 0x4;
1355                         sum++;
1356                 }
1357
1358                 ptr_reg++; /* GRGB */
1359                 ptr_reg -> reg_addr = 0x1B00;
1360                 sum++;
1361
1362                 for(i = 0; i < 2; i++)
1363                 {
1364                         ptr_reg++;
1365                         ptr_reg -> reg_addr = 0x1B14 + i * 0x4;
1366                         sum++;
1367                 }
1368
1369                 ptr_reg++; /* BDN */
1370                 ptr_reg -> reg_addr = 0x1C00;
1371                 sum++;
1372
1373                 for(i = 0; i < 101; i++)
1374                 {
1375                         ptr_reg++;
1376                         ptr_reg -> reg_addr = 0x1C14 + i * 0x4;
1377                         sum++;
1378                 }
1379
1380                 for(i = 0; i < 7; i++)
1381                 {
1382                         ptr_reg++;
1383                         ptr_reg -> reg_addr = 0x1DA8 + i * 0x4;
1384                         sum++;
1385                 }
1386
1387                 ptr_reg++;  /* RGBG2 */
1388                 ptr_reg -> reg_addr = 0x1E00;
1389                 sum++;
1390
1391                 for(i = 0; i < 3; i++)
1392                 {
1393                         ptr_reg++;
1394                         ptr_reg -> reg_addr = 0x1E14 + i * 0x4;
1395                         sum++;
1396                 }
1397
1398                 ptr_reg++;  /* 1d lnc */
1399                 ptr_reg -> reg_addr = 0x1F00;
1400                 sum++;
1401
1402                 for(i = 0; i < 19; i++)
1403                 {
1404                         ptr_reg++;
1405                         ptr_reg -> reg_addr = 0x1F14 + i * 0x4;
1406                         sum++;
1407                 }
1408
1409                 ptr_reg++;  /* NLM VST IVST */
1410                 ptr_reg -> reg_addr = 0x2014;
1411                 sum++;
1412
1413                 ptr_reg++;
1414                 ptr_reg -> reg_addr = 0x2214;
1415                 sum++;
1416
1417                 for(i = 0; i < 3; i++)
1418                 {
1419                         ptr_reg++;
1420                         ptr_reg -> reg_addr = 0x2100 + i * 0x4;
1421                         sum++;
1422                 }
1423
1424                 for(i = 0; i < 35; i++)
1425                 {
1426                         ptr_reg++;
1427                         ptr_reg -> reg_addr = 0x2114 + i * 0x4;
1428                         sum++;
1429                 }
1430
1431                 ptr_reg++;  /* CFA: clolor filter array */
1432                 ptr_reg -> reg_addr = 0x3000;
1433                 sum++;
1434
1435                 for(i = 0; i < 7; i++)
1436                 {
1437                         ptr_reg++;
1438                         ptr_reg -> reg_addr = 0x3014 + i * 0x4;
1439                         sum++;
1440                 }
1441
1442                 for(i = 0; i < 2; i++)  /* CMC */
1443                 {
1444                         ptr_reg++;
1445                         ptr_reg -> reg_addr = 0x3100 + i * 0x4;
1446                         sum++;
1447                 }
1448
1449                 for(i = 0; i < 5; i++)
1450                 {
1451                         ptr_reg++;
1452                         ptr_reg -> reg_addr = 0x3114 + i * 0x4;
1453                         sum++;
1454                 }
1455
1456                 for(i = 0; i < 5; i++)
1457                 {
1458                         ptr_reg++;
1459                         ptr_reg -> reg_addr = 0x312C + i * 0x4;
1460                         sum++;
1461                 }
1462
1463                 for(i = 0; i < 2; i++)  /* GAMMA */
1464                 {
1465                         ptr_reg++;
1466                         ptr_reg -> reg_addr = 0x3300 + i * 0x14;
1467                         sum++;
1468                 }
1469
1470                 for(i = 0; i < 2; i++)  /* Color matrix correction for 8 bits */
1471                 {
1472                         ptr_reg++;
1473                         ptr_reg -> reg_addr = 0x3500 + i * 0x4;
1474                         sum++;
1475                 }
1476
1477                 for(i = 0; i < 16; i++)
1478                 {
1479                         ptr_reg++;
1480                         ptr_reg -> reg_addr = 0x3514 + i * 0x4;
1481                         sum++;
1482                 }
1483
1484                 for(i = 0; i < 2; i++) /* CT: Color transformation */
1485                 {
1486                         ptr_reg++;
1487                         ptr_reg -> reg_addr = 0x3600 + i * 0x4;
1488                         sum++;
1489                 }
1490
1491                 ptr_reg++;
1492                 ptr_reg -> reg_addr = 0x3614;
1493                 sum++;
1494
1495                 for(i = 0; i < 2; i++)  /* CCE: clolor conversion enhancement */
1496                 {
1497                         ptr_reg++;
1498                         ptr_reg -> reg_addr = 0x3700 + i * 0x4;
1499                         sum++;
1500                 }
1501
1502                 for(i = 0; i < 13; i++)
1503                 {
1504                         ptr_reg++;
1505                         ptr_reg -> reg_addr = 0x3714 + i * 0x4;
1506                         sum++;
1507                 }
1508
1509                 for(i = 0; i < 2; i++)  /* HSV */
1510                 {
1511                         ptr_reg++;
1512                         ptr_reg -> reg_addr = 0x3800 + i * 0x14;
1513                         sum++;
1514                 }
1515
1516                 ptr_reg++; /* Radial CSC */
1517                 ptr_reg -> reg_addr = 0x3900;
1518                 sum++;
1519
1520                 for(i = 0; i < 14; i++)
1521                 {
1522                         ptr_reg++;
1523                         ptr_reg -> reg_addr = 0x3914 + i * 0x4;
1524                         sum++;
1525                 }
1526
1527                 for(i = 0; i < 2; i++)  /* ISP_PRECNRNEW */
1528                 {
1529                         ptr_reg++;
1530                         ptr_reg -> reg_addr = 0x3A00 + i * 0x4;
1531                         sum++;
1532                 }
1533
1534                 for(i = 0; i < 4; i++)
1535                 {
1536                         ptr_reg++;
1537                         ptr_reg -> reg_addr = 0x3A14 + i * 0x4;
1538                         sum++;
1539                 }
1540
1541                 ptr_reg++; /* ISP_PSTRZ */
1542                 ptr_reg -> reg_addr = 0x3B00;
1543                 sum++;
1544
1545                 for(i = 0; i < 9; i++)
1546                 {
1547                         ptr_reg++;
1548                         ptr_reg -> reg_addr = 0x3B14 + i * 0x4;
1549                         sum++;
1550                 }
1551
1552                 for(i = 0; i < 2; i++) /* AFM: auto focus monitor */
1553                 {
1554                         ptr_reg++;
1555                         ptr_reg -> reg_addr = 0x3C00 + i * 0x4;
1556                         sum++;
1557                 }
1558
1559                 for(i = 0; i < 105; i++)
1560                 {
1561                         ptr_reg++;
1562                         ptr_reg -> reg_addr = 0x3C14 + i * 0x4;
1563                         sum++;
1564                 }
1565
1566                 ptr_reg++;  /* YIQ AEM */
1567                 ptr_reg -> reg_addr = 0x4100;
1568                 sum++;
1569
1570                 for(i = 0; i < 10; i++)
1571                 {
1572                         ptr_reg++;
1573                         ptr_reg -> reg_addr = 0x4114 + i * 0x4;
1574                         sum++;
1575                 }
1576
1577                 for(i = 0; i < 2; i++) /* ANTI FLICKER */
1578                 {
1579                         ptr_reg++;
1580                         ptr_reg -> reg_addr = 0x4200 + i * 0x4;
1581                         sum++;
1582                 }
1583
1584                 for(i = 0; i < 4; i++)
1585                 {
1586                         ptr_reg++;
1587                         ptr_reg -> reg_addr = 0x4214 + i * 0x4;
1588                         sum++;
1589                 }
1590
1591                 for(i = 0; i < 2; i++) /* YIQ AFM */
1592                 {
1593                         ptr_reg++;
1594                         ptr_reg -> reg_addr = 0x4300 + i * 0x4;
1595                         sum++;
1596                 }
1597
1598                 for(i = 0; i < 158; i++)
1599                 {
1600                         ptr_reg++;
1601                         ptr_reg -> reg_addr = 0x4314 + i * 0x4;
1602                         sum++;
1603                 }
1604
1605                 for(i = 0; i < 2; i++) /* Pre-CDN */
1606                 {
1607                         ptr_reg++;
1608                         ptr_reg -> reg_addr = 0x5000 + i * 0x4;
1609                         sum++;
1610                 }
1611
1612                 for(i = 0; i < 19; i++)
1613                 {
1614                         ptr_reg++;
1615                         ptr_reg -> reg_addr = 0x5014 + i * 0x4;
1616                         sum++;
1617                 }
1618
1619                 for(i = 0; i < 2; i++) /* Pre-Filter */
1620                 {
1621                         ptr_reg++;
1622                         ptr_reg -> reg_addr = 0x5100 + i * 0x4;
1623                         sum++;
1624                 }
1625
1626                 for(i = 0; i < 2; i++)
1627                 {
1628                         ptr_reg++;
1629                         ptr_reg -> reg_addr = 0x5114 + i * 0x4;
1630                         sum++;
1631                 }
1632
1633                 for(i = 0; i < 2; i++)  /* Brightness */
1634                 {
1635                         ptr_reg++;
1636                         ptr_reg -> reg_addr = 0x5300 + i * 0x14;
1637                         sum++;
1638                 }
1639
1640                 for(i = 0; i < 2; i++)  /* Contrast */
1641                 {
1642                         ptr_reg++;
1643                         ptr_reg -> reg_addr = 0x5400 + i * 0x14;
1644                         sum++;
1645                 }
1646
1647                 ptr_reg++; /* HIST: histogram */
1648                 ptr_reg -> reg_addr = 0x5500;
1649                 sum++;
1650
1651                 for(i = 0; i < 5; i++)
1652                 {
1653                         ptr_reg++;
1654                         ptr_reg -> reg_addr = 0x5514 + i * 0x4;
1655                         sum++;
1656                 }
1657
1658                 ptr_reg++; /* HIST2 */
1659                 ptr_reg -> reg_addr = 0x5600;
1660                 sum++;
1661
1662                 for(i = 0; i < 9; i++)
1663                 {
1664                         ptr_reg++;
1665                         ptr_reg -> reg_addr = 0x5614 + i * 0x4;
1666                         sum++;
1667                 }
1668
1669                 ptr_reg++; /* AUTOCONT: auto contrat adjustment */
1670                 ptr_reg -> reg_addr = 0x5700;
1671                 sum++;
1672
1673                 for(i = 0; i < 2; i++)
1674                 {
1675                         ptr_reg++;
1676                         ptr_reg -> reg_addr = 0x5714 + i * 0x4;
1677                         sum++;
1678                 }
1679
1680                 for(i = 0; i < 2; i++) /* cdn */
1681                 {
1682                         ptr_reg++;
1683                         ptr_reg -> reg_addr = 0x5800 + i * 0x4;
1684                         sum++;
1685                 }
1686
1687                 for(i = 0; i < 18; i++)
1688                 {
1689                         ptr_reg++;
1690                         ptr_reg -> reg_addr = 0x5814 + i * 0x4;
1691                         sum++;
1692                 }
1693
1694                 ptr_reg++; /* edge */
1695                 ptr_reg -> reg_addr = 0x5900;
1696                 sum++;
1697
1698                 for(i = 0; i < 12; i++)
1699                 {
1700                         ptr_reg++;
1701                         ptr_reg -> reg_addr = 0x5914 + i * 0x4;
1702                         sum++;
1703                 }
1704
1705                 for(i = 0; i < 2; i++) /* emboss */
1706                 {
1707                         ptr_reg++;
1708                         ptr_reg -> reg_addr = 0x5A00 + i * 0x14;
1709                         sum++;
1710                 }
1711
1712                 for(i = 0; i < 2; i++)
1713                 {
1714                         ptr_reg++;
1715                         ptr_reg -> reg_addr = 0x5A00 + i * 0x14;
1716                         sum++;
1717                 }
1718
1719                 ptr_reg++; /* CSS */
1720                 ptr_reg -> reg_addr = 0x5B00;
1721                 sum++;
1722
1723                 for(i = 0; i < 10; i++)
1724                 {
1725                         ptr_reg++;
1726                         ptr_reg -> reg_addr = 0x5B14 + i * 0x4;
1727                         sum++;
1728                 }
1729
1730                 for(i = 0; i < 2; i++) /* csa */
1731                 {
1732                         ptr_reg++;
1733                         ptr_reg -> reg_addr = 0x5C00 + i * 0x14;
1734                         sum++;
1735                 }
1736
1737                 for(i = 0; i < 2; i++) /* hua */
1738                 {
1739                         ptr_reg++;
1740                         ptr_reg -> reg_addr = 0x5D00 + i * 0x14;
1741                         sum++;
1742                 }
1743
1744                 ptr_reg++; /* post-cdn */
1745                 ptr_reg -> reg_addr = 0x5E00;
1746                 sum++;
1747
1748                 for(i = 0; i < 29; i++)
1749                 {
1750                         ptr_reg++;
1751                         ptr_reg -> reg_addr = 0x5E14 + i * 0x4;
1752                         sum++;
1753                 }
1754
1755                 ptr_reg++;
1756                 ptr_reg -> reg_addr = 0x5F14;
1757                 sum++;
1758
1759                 for(i = 0; i < 2; i++) /* ygamma */
1760                 {
1761                         ptr_reg++;
1762                         ptr_reg -> reg_addr = 0x6000 + i * 0x14;
1763                         sum++;
1764                 }
1765
1766                 for(i = 0; i < 2; i++) /* ydelay */
1767                 {
1768                         ptr_reg++;
1769                         ptr_reg -> reg_addr = 0x6100 + i * 0x14;
1770                         sum++;
1771                 }
1772
1773                 for(i = 0; i < 2; i++) /* iircnr */
1774                 {
1775                         ptr_reg++;
1776                         ptr_reg -> reg_addr = 0x6400 + i * 0x4;
1777                         sum++;
1778                 }
1779
1780                 for(i = 0; i < 16; i++)
1781                 {
1782                         ptr_reg++;
1783                         ptr_reg -> reg_addr = 0x6414 + i * 0x4;
1784                         sum++;
1785                 }
1786
1787                 for(i = 0; i < 2; i++)
1788                 {
1789                         ptr_reg++;
1790                         ptr_reg -> reg_addr = 0x2000 + i * 0x54;
1791                         sum++;
1792                 }
1793
1794                 for(i = 0; (ptr_reg->reg_addr) < 0x153fc; i++) // isp v memory1: awbm; isp v memory2:aem
1795                 {
1796                         ptr_reg++;
1797                         ptr_reg -> reg_addr = 0x10000 + i * 0x4;
1798                         sum++;
1799                 }
1800
1801                 for(i = 0; (ptr_reg->reg_addr) < 0x163fc; i++)
1802                 {
1803                         ptr_reg++;
1804                         ptr_reg -> reg_addr = 0x16000 + i * 0x4;
1805                         sum++;
1806                 }
1807
1808                 for(i = 0; (ptr_reg->reg_addr) < 0x17b60; i++)
1809                 {
1810                         ptr_reg++;
1811                         ptr_reg -> reg_addr = 0x17000 + i * 0x4;
1812                         sum++;
1813                 }
1814
1815                 for(i = 0; (ptr_reg->reg_addr) < 0x185a0; i++)
1816                 {
1817                         ptr_reg++;
1818                         ptr_reg -> reg_addr = 0x18000 + i * 0x4;
1819                         sum++;
1820                 }
1821
1822                 for(i = 0; (ptr_reg->reg_addr) < 0x1b200; i++)
1823                 {
1824                         ptr_reg++;
1825                         ptr_reg -> reg_addr = 0x19000 + i * 0x4;
1826                         sum++;
1827                 }
1828
1829                 for(i = 0; i < 3; i++)
1830                 {
1831                         int addr_n;
1832                         int addr_base = 0x1c000 + i * 0x1000;
1833                         for(addr_n = 0; (ptr_reg->reg_addr) < (addr_base + 0x200); addr_n++)
1834                         {
1835                                 ptr_reg++;
1836                                 ptr_reg -> reg_addr = addr_base + addr_n * 0x4;
1837                                 sum++;
1838                         }
1839                 }
1840
1841                 for(i = 0; (ptr_reg->reg_addr) < 0x20b60; i++)
1842                 {
1843                         ptr_reg++;
1844                         ptr_reg -> reg_addr = 0x1f000 + i * 0x4;
1845                         sum++;
1846                 }
1847
1848                 for(i = 0; (ptr_reg->reg_addr) < 0x215a0; i++)
1849                 {
1850                         ptr_reg++;
1851                         ptr_reg -> reg_addr = 0x21000 + i * 0x4;
1852                         sum++;
1853                 }
1854
1855                 for(i = 0; (ptr_reg->reg_addr) < 0x24200; i++)
1856                 {
1857                         ptr_reg++;
1858                         ptr_reg -> reg_addr = 0x22000 + i * 0x4;
1859                         sum++;
1860                 }
1861
1862                 for(i = 0; i < 3; i++)
1863                 {
1864                         int addr_n;
1865                         int addr_base = 0x25000 + i * 0x1000;
1866                         for(addr_n = 0; (ptr_reg->reg_addr) < (addr_base + 0x200); addr_n++)
1867                         {
1868                                 ptr_reg++;
1869                                 ptr_reg -> reg_addr = addr_base + addr_n * 0x4;
1870                                 sum++;
1871                         }
1872                 }
1873
1874                 for(i = 0; (ptr_reg->reg_addr) < 0x2b2fc; i++)
1875                 {
1876                         ptr_reg++;
1877                         ptr_reg -> reg_addr = 0x28000 + i * 0x4;
1878                         sum++;
1879                 }
1880
1881                 for(i = 0; (ptr_reg->reg_addr) < 0x2e2fc; i++)
1882                 {
1883                         ptr_reg++;
1884                         ptr_reg -> reg_addr = 0x2C000 + i * 0x4;
1885                         sum++;
1886                 }
1887
1888                 return sum;
1889 }
1890
1891 module_init(isp_init);
1892 module_exit(isp_exit);
1893 MODULE_DESCRIPTION("Isp Driver");
1894 MODULE_LICENSE("GPL");