drivers/media/platform/rk-isp10/cif_isp10_isp.c

   1 /*
   2  *************************************************************************
   3  * Rockchip driver for CIF ISP 1.0
   4  * (Based on Intel driver for sofiaxxx)
   5  *
   6  * Copyright (C) 2015 Intel Mobile Communications GmbH
   7  * Copyright (C) 2016 Fuzhou Rockchip Electronics Co., Ltd.
   8  *
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *************************************************************************
  15  */
  16
  17 #include <linux/types.h>
  18 #include <linux/kernel.h>
  19 #include <linux/slab.h>
  20 #include <media/v4l2-device.h>
  21 #include <media/v4l2-ioctl.h>
  22 #include <linux/videodev2.h>
  23 #include <media/videobuf-core.h>
  24 #include <media/videobuf-vmalloc.h>     /* for ISP statistics */
  25 #include <linux/io.h>
  26 #include <linux/wait.h>
  27 #include <linux/sched.h>
  28 #include <linux/workqueue.h>
  29 #include "cif_isp10_regs.h"
  30 #include "cif_isp10_isp.h"
  31 #include "cif_isp10_pltfrm.h"
  32 #include "cif_isp10.h"
  33
  34 #define _GET_ 0
  35 #define _SET_ 1
  36 #define CIFISP_MODULE_EN(v, m)             ((v) |= (m))
  37 #define CIFISP_MODULE_DIS(v, m)            ((v) &= ~(m))
  38 #define CIFISP_MODULE_IS_EN(v, m)          (((v) & (m)) == (m))
  39 #define CIFISP_MODULE_UPDATE(v, m)         ((v) |= (m))
  40 #define CIFISP_MODULE_CLR_UPDATE(v, m)     ((v) &= ~(m))
  41 #define CIFISP_MODULE_IS_UPDATE(v, m)      (((v) & (m)) == (m))
  42
  43 /* Demosaic */
  44 #define CIFISP_BDM_BYPASS_EN(val)          ((val) << 10)
  45 /* HIST */
  46 #define CIFISP_HIST_PREDIV_SET(val)        ((val) << 3)
  47 #define CIFISP_HIST_WEIGHT_SET(v0, v1, v2, v3)  ((v0) | ((v1) << 8)  |\
  48                                                 ((v2) << 16) | ((v3) << 24))
  49 #define CIFISP_HIST_WINDOW_OFFSET_RESERVED (0xFFFFF000)
  50 #define CIFISP_HIST_WINDOW_SIZE_RESERVED   (0xFFFFF800)
  51 #define CIFISP_HIST_WEIGHT_RESERVED        (0xE0E0E0E0)
  52 #define CIFISP_MAX_HIST_PREDIVIDER         (0x0000007F)
  53 #define CIFISP_HIST_ROW_NUM                (5)
  54 #define CIFISP_HIST_COLUMN_NUM             (5)
  55 /* ISP Ctrl */
  56 #define CIF_ISP_CTRL_ISP_GAMMA_IN_ENA       BIT(6)
  57 #define CIF_ISP_CTRL_ISP_AWB_ENA            BIT(7)
  58 #define CIF_ISP_CTRL_ISP_GAMMA_OUT_ENA      BIT(11)
  59 /* AWB */
  60 #define CIFISP_AWB_GAIN_R_SET(val)   ((val) << 16)
  61 #define CIFISP_AWB_GAIN_R_READ(val)  ((val) >> 16)
  62 #define CIFISP_AWB_GAIN_B_READ(val)  ((val) & 0xFFFF)
  63
  64 #define CIFISP_AWB_YMAX_CMP_EN       BIT(2)
  65 #define CIFISP_AWB_REF_CR_SET(val)   ((val) << 8)
  66 #define CIFISP_AWB_REF_CR_READ(val)  ((val) >> 8)
  67 #define CIFISP_AWB_REF_CB_READ(val)  ((val) & 0xFF)
  68 #define CIFISP_AWB_MAX_CS_SET(val)   ((val) << 8)
  69 #define CIFISP_AWB_MAX_CS_READ(val)  (((val) >> 8) & 0xFF)
  70 #define CIFISP_AWB_MIN_C_READ(val)   ((val) & 0xFF)
  71 #define CIFISP_AWB_MIN_Y_SET(val)    ((val) << 16)
  72 #define CIFISP_AWB_MIN_Y_READ(val)   (((val) >> 16) & 0xFF)
  73 #define CIFISP_AWB_MAX_Y_SET(val)    ((val) << 24)
  74 #define CIFISP_AWB_MAX_Y_READ(val)   ((val) >> 24)
  75 #define CIFISP_AWB_MODE_RGB_EN       ((1 << 31) | (0x02 << 0))
  76 #define CIFISP_AWB_MODE_YCBCR_EN     ((0 << 31) | (0x02 << 0))
  77 #define CIFISP_AWB_MODE_READ(val)    ((val) & 3)
  78 #define CIFISP_AWB_YMAX_READ(val)    (((val) >> 2) & 1)
  79
  80 #define CIFISP_AWB_GET_MEAN_CR(val)   ((val) & 0xFF)
  81 #define CIFISP_AWB_GET_MEAN_CB(val)   (((val) >> 8) & 0xFF)
  82 #define CIFISP_AWB_GET_MEAN_Y(val)    (((val) >> 16) & 0xFF)
  83 #define CIFISP_AWB_GET_MEAN_R(val)    ((val) & 0xFF)
  84 #define CIFISP_AWB_GET_MEAN_B(val)    (((val) >> 8) & 0xFF)
  85 #define CIFISP_AWB_GET_MEAN_G(val)    (((val) >> 16) & 0xFF)
  86 #define CIFISP_AWB_GET_PIXEL_CNT(val) ((val) & 0x3FFFFFF)
  87
  88 #define CIFISP_AWB_GAINS_MAX_VAL           (0x000003FF)
  89 #define CIFISP_AWB_WINDOW_OFFSET_MAX       (0x00000FFF)
  90 #define CIFISP_AWB_WINDOW_MAX_SIZE         (0x00001FFF)
  91 #define CIFISP_AWB_CBCR_MAX_REF            (0x000000FF)
  92 #define CIFISP_AWB_THRES_MAX_YC            (0x000000FF)
  93 /* AE */
  94 #define CIFISP_EXP_ENA                     (1)
  95 #define CIFISP_EXP_DIS                     (0)
  96 #define CIFISP_EXP_ROW_NUM                 (5)
  97 #define CIFISP_EXP_COLUMN_NUM              (5)
  98 #define CIFISP_EXP_NUM_LUMA_REGS           (CIFISP_EXP_ROW_NUM *\
  99                 CIFISP_EXP_COLUMN_NUM)
 100 #define CIFISP_EXP_MAX_HOFFS               (2424)
 101 #define CIFISP_EXP_MAX_VOFFS               (1806)
 102 #define CIFISP_EXP_BLOCK_MAX_HSIZE         (516)
 103 #define CIFISP_EXP_BLOCK_MIN_HSIZE         (35)
 104 #define CIFISP_EXP_BLOCK_MAX_VSIZE         (390)
 105 #define CIFISP_EXP_BLOCK_MIN_VSIZE         (28)
 106 #define CIFISP_EXP_MAX_HSIZE    \
 107         (CIFISP_EXP_BLOCK_MAX_HSIZE * CIFISP_EXP_COLUMN_NUM + 1)
 108 #define CIFISP_EXP_MIN_HSIZE    \
 109         (CIFISP_EXP_BLOCK_MIN_HSIZE * CIFISP_EXP_COLUMN_NUM + 1)
 110 #define CIFISP_EXP_MAX_VSIZE    \
 111         (CIFISP_EXP_BLOCK_MAX_VSIZE * CIFISP_EXP_ROW_NUM + 1)
 112 #define CIFISP_EXP_MIN_VSIZE    \
 113         (CIFISP_EXP_BLOCK_MIN_VSIZE * CIFISP_EXP_ROW_NUM + 1)
 114 #define CIFISP_EXP_HEIGHT_MASK             (0x000007FF)
 115 #define CIFISP_EXP_MAX_HOFFSET             (0x00000FFF)
 116 #define CIFISP_EXP_MAX_VOFFSET             (0x00000FFF)
 117
 118 #define CIFISP_EXP_CTRL_AUTOSTOP(val)      ((val) << 1)
 119 #define CIFISP_EXP_CTRL_MEASMODE(val)      ((val) << 31)
 120 #define CIFISP_EXP_HSIZE(val)              ((val) & 0x7FF)
 121 #define CIFISP_EXP_VSIZE(val)              ((val) & 0x7FE)
 122 /* LSC */
 123 #define CIFISP_LSC_GRADH_SET(val)          ((val) << 11)
 124 #define CIFISP_LSC_SECTH_SET(val)          ((val) << 10)
 125
 126 /* FLT */
 127 #define CIFISP_FLT_MODE_MAX                (1)
 128 #define CIFISP_FLT_CHROMA_MODE_MAX         (3)
 129 #define CIFISP_FLT_GREEN_STAGE1_MAX        (8)
 130 #define CIFISP_FLT_MODE(v)                 ((v) << 1)
 131 #define CIFISP_FLT_CHROMA_V_MODE(v)        ((v) << 4)
 132 #define CIFISP_FLT_CHROMA_H_MODE(v)        ((v) << 6)
 133 #define CIFISP_FLT_GREEN_STAGE1(v)         ((v) << 8)
 134 #define CIFISP_FLT_THREAD_RESERVED         (0xfffffc00)
 135 #define CIFISP_FLT_FAC_RESERVED        (0xffffffc0)
 136 #define CIFISP_FLT_LUM_WEIGHT_RESERVED (0xfff80000)
 137 #define CIFISP_FLT_ENA                 (1)
 138 #define CIFISP_FLT_DIS                 (0)
 139
 140 #define CIFISP_CTK_COEFF_RESERVED      0xFFFFF800
 141 #define CIFISP_XTALK_OFFSET_RESERVED   0xFFFFF000
 142
 143 /* GOC */
 144 #define CIFISP_GOC_MODE_MAX            (1)
 145 #define CIFISP_GOC_RESERVED            0xFFFFF800
 146 #define CIF_ISP_CTRL_ISP_GAMMA_OUT_ENA_READ(value) (((value) >> 11) & 1)
 147 /* DPCC */
 148 #define CIFISP_DPCC_ENA                BIT(0)
 149 #define CIFISP_DPCC_DIS                (0 << 0)
 150 #define CIFISP_DPCC_MODE_MAX           (0x07)
 151 #define CIFISP_DPCC_OUTPUTMODE_MAX     (0x0f)
 152 #define CIFISP_DPCC_SETUSE_MAX         (0x0f)
 153 #define CIFISP_DPCC_METHODS_SET_RESERVED    (0xFFFFE000)
 154 #define CIFISP_DPCC_LINE_THRESH_RESERVED    (0xFFFF0000)
 155 #define CIFISP_DPCC_LINE_MAD_FAC_RESERVED   (0xFFFFC0C0)
 156 #define CIFISP_DPCC_PG_FAC_RESERVED         (0xFFFFC0C0)
 157 #define CIFISP_DPCC_RND_THRESH_RESERVED     (0xFFFF0000)
 158 #define CIFISP_DPCC_RG_FAC_RESERVED         (0xFFFFC0C0)
 159 #define CIFISP_DPCC_RO_LIMIT_RESERVED       (0xFFFFF000)
 160 #define CIFISP_DPCC_RND_OFFS_RESERVED       (0xFFFFF000)
 161 /* BLS */
 162 #define CIFISP_BLS_ENA           BIT(0)
 163 #define CIFISP_BLS_DIS           (0 << 0)
 164 #define CIFISP_BLS_MODE_MEASURED BIT(1)
 165 #define CIFISP_BLS_MODE_FIXED    (0 << 1)
 166 #define CIFISP_BLS_WINDOW_1      BIT(2)
 167 #define CIFISP_BLS_WINDOW_2      BIT(3)
 168 /* GAMMA-IN */
 169 #define CIFISP_DEGAMMA_X_RESERVED       \
 170         ((1 << 31) | (1 << 27) | (1 << 23) | (1 << 19) |\
 171         (1 << 15) | (1 << 11) | (1 << 7) | (1 << 3))
 172 #define CIFISP_DEGAMMA_Y_RESERVED          0xFFFFF000
 173 /*CPROC*/
 174 #define CIFISP_CPROC_CTRL_RESERVED         0xFFFFFFFE
 175 #define CIFISP_CPROC_CONTRAST_RESERVED     0xFFFFFF00
 176 #define CIFISP_CPROC_BRIGHTNESS_RESERVED   0xFFFFFF00
 177 #define CIFISP_CPROC_HUE_RESERVED          0xFFFFFF00
 178 #define CIFISP_CPROC_SATURATION_RESERVED   0xFFFFFF00
 179 #define CIFISP_CPROC_MACC_RESERVED         0xE000E000
 180 #define CIFISP_CPROC_TONE_RESERVED         0xF000
 181 #define CIFISP_CPROC_TONE_Y(value)         ((value) << 16)
 182 #define CIFISP_CPROC_TONE_C(value)         ((value))
 183 #define CIFISP_CPROC_TONE_Y_READ(value)    ((value) >> 16)
 184 #define CIFISP_CPROC_TONE_C_READ(value)    ((value) & 0xFFFF)
 185 #define CIFISP_CPROC_EN                    1
 186 #define CIFISP_CPROC_MACC_EN               BIT(4)
 187 #define CIFISP_CPROC_TMAP_EN               BIT(5)
 188 /* LSC */
 189 #define CIFISP_LSC_SECT_SIZE_RESERVED      0xFC00FC00
 190 #define CIFISP_LSC_GRAD_RESERVED           0xF000F000
 191 #define CIFISP_LSC_SAMPLE_RESERVED         0xF000F000
 192 #define CIFISP_LSC_SECTORS_MAX             16
 193 #define CIFISP_LSC_TABLE_DATA(v0, v1)     (v0 | ((v1) << 12))
 194 #define CIFISP_LSC_SECT_SIZE(v0, v1)      (v0 | ((v1) << 16))
 195 #define CIFISP_LSC_GRAD_SIZE(v0, v1)      (v0 | ((v1) << 16))
 196 /* AFC */
 197 #define CIFISP_AFC_THRES_RESERVED     0xFFFF0000
 198 #define CIFISP_AFC_VAR_SHIFT_RESERVED 0xFFF8FFF8
 199 #define CIFISP_AFC_WINDOW_X_RESERVED  0xE000
 200 #define CIFISP_AFC_WINDOW_Y_RESERVED  0xF000
 201 #define CIFISP_AFC_WINDOW_X_MIN       0x5
 202 #define CIFISP_AFC_WINDOW_Y_MIN       0x2
 203 #define CIFISP_AFC_WINDOW_X(value)    ((value) << 16)
 204 #define CIFISP_AFC_WINDOW_Y(value)    (value)
 205 #define CIFISP_AFC_ENA                (1)
 206 #define CIFISP_AFC_DIS                (0)
 207
 208 /* DPF */
 209 #define CIFISP_DPF_NF_GAIN_RESERVED     0xFFFFF000
 210 #define CIFISP_DPF_SPATIAL_COEFF_MAX    0x1f
 211 #define CIFISP_DPF_NLL_COEFF_N_MAX      0x3ff
 212
 213 #define CIFISP_DPF_MODE_USE_NF_GAIN     BIT(9)
 214 #define CIFISP_DPF_MODE_LSC_GAIN_COMP   BIT(8)
 215 #define CIFISP_DPF_MODE_AWB_GAIN_COMP   BIT(7)
 216 #define CIFISP_DPF_MODE_NLL_SEGMENTATION(a)   ((a) << 6)
 217 #define CIFISP_DPF_MODE_RB_FLTSIZE(a)         ((a) << 5)
 218 #define CIFISP_DPF_MODE_R_FLT_DIS             BIT(4)
 219 #define CIFISP_DPF_MODE_R_FLT_EN              (0 << 4)
 220 #define CIFISP_DPF_MODE_GR_FLT_DIS            BIT(3)
 221 #define CIFISP_DPF_MODE_GR_FLT_EN             (0 << 3)
 222 #define CIFISP_DPF_MODE_GB_FLT_DIS            BIT(2)
 223 #define CIFISP_DPF_MODE_GB_FLT_EN             (0 << 2)
 224 #define CIFISP_DPF_MODE_B_FLT_DIS             BIT(1)
 225 #define CIFISP_DPF_MODE_B_FLT_EN              (0 << 1)
 226 #define CIFISP_DPF_MODE_EN                    BIT(0)
 227
 228 #define CIFISP_DEBUG                        BIT(0)
 229 #define CIFISP_ERROR                        BIT(1)
 230
 231 /*
 232  * Empirical rough (relative) times it takes to perform
 233  * given function.
 234  */
 235 #define CIFISP_MODULE_DPCC_PROC_TIME     3
 236 #define CIFISP_MODULE_BLS_PROC_TIME      10
 237 #define CIFISP_MODULE_LSC_PROC_TIME      1747
 238 #define CIFISP_MODULE_FLT_PROC_TIME      15
 239 #define CIFISP_MODULE_BDM_PROC_TIME      1
 240 #define CIFISP_MODULE_SDG_PROC_TIME      53
 241 #define CIFISP_MODULE_GOC_PROC_TIME      1000
 242 #define CIFISP_MODULE_CTK_PROC_TIME      772
 243 #define CIFISP_MODULE_AWB_PROC_TIME      8
 244 #define CIFISP_MODULE_HST_PROC_TIME      5
 245 #define CIFISP_MODULE_AEC_PROC_TIME      5
 246 #define CIFISP_MODULE_AWB_GAIN_PROC_TIME 2
 247 #define CIFISP_MODULE_CPROC_PROC_TIME    5
 248 #define CIFISP_MODULE_AFC_PROC_TIME      8
 249 #define CIFISP_MODULE_IE_PROC_TIME       5
 250 #define CIFISP_MODULE_DPF_TIME           5
 251 #define CIFISP_MODULE_DPF_STRENGTH_TIME  2
 252 #define CIFISP_MODULE_CSM_PROC_TIME      8
 253
 254 /* For Debugging only!!! */
 255
 256 #define CIFISP_MODULE_DEFAULT_VBLANKING_TIME 2000
 257
 258 #define V4L2_DEV_DEBUG_LEVEL 0
 259
 260 #define CIFISP_DPRINT(level, fmt, arg...) \
 261         do { \
 262                 if (level == CIFISP_ERROR) \
 263                         pr_err(fmt, ##arg); \
 264                 else \
 265                         pr_debug(fmt, ##arg); \
 266         } while (0)
 267
 268 #define cifisp_iowrite32(d, a) \
 269         cif_isp10_pltfrm_write_reg(NULL, (u32)(d), isp_dev->base_addr + (a))
 270 #define cifisp_ioread32(a) \
 271         cif_isp10_pltfrm_read_reg(NULL, isp_dev->base_addr + (a))
 272 #define cifisp_iowrite32OR(d, a) \
 273         cif_isp10_pltfrm_write_reg_OR(NULL, (u32)(d), isp_dev->base_addr + (a))
 274 #define cifisp_iowrite32AND(d, a) \
 275         cif_isp10_pltfrm_write_reg_AND(NULL, (u32)(d), isp_dev->base_addr + (a))
 276
 277 /*
 278  * Set this flag to enable CIF ISP Register debug
 279  * #define CIFISP_DEBUG_REG
 280  */
 281 /*
 282  * Set this flag to dump the parameters
 283  * #define CIFISP_DEBUG_PARAM
 284  */
 285 /*
 286  * Set this flag to trace the capture params
 287  * #define LOG_CAPTURE_PARAMS
 288  */
 289 /*
 290  * Set this flag to trace the isr execution time
 291  * #define LOG_ISR_EXE_TIME
 292  */
 293 /*
 294  * Set this flag to exclude everything except
 295  * measurements
 296  * #define CIFISP_DEBUG_DISABLE_BLOCKS
 297  */
 298
 299 #ifdef LOG_CAPTURE_PARAMS
 300 static struct cifisp_last_capture_config g_last_capture_config;
 301 #endif
 302
 303 #ifdef LOG_ISR_EXE_TIME
 304 static unsigned int g_longest_isr_time;
 305 #endif
 306
 307 /* Functions for Debugging */
 308 static void cifisp_param_dump(const void *config, unsigned int module);
 309 #ifdef CIFISP_DEBUG_REG
 310 static void cifisp_reg_dump(const struct cif_isp10_isp_dev *isp_dev,
 311                             unsigned int module, int level);
 312 #endif
 313 #ifdef LOG_CAPTURE_PARAMS
 314 static void cifisp_reg_dump_capture(const struct cif_isp10_isp_dev *isp_dev);
 315 #endif
 316
 317 static int cifisp_module_enable(struct cif_isp10_isp_dev *isp_dev,
 318         bool flag, __s32 *value, unsigned int module)
 319 {
 320         unsigned int *curr_ens, *updates, *new_ens;
 321         unsigned long lock_flags = 0;
 322         int retval = 0;
 323
 324         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
 325
 326         if (module & (CIFISP_MODULE_AWB |
 327                 CIFISP_MODULE_AEC |
 328                 CIFISP_MODULE_AFC |
 329                 CIFISP_MODULE_HST)) {
 330                 curr_ens = &isp_dev->meas_cfgs.curr->module_ens;
 331                 new_ens = &isp_dev->meas_cfgs.last_or_new->module_ens;
 332                 updates = &isp_dev->meas_cfgs.module_updates;
 333         } else {
 334                 curr_ens = &isp_dev->other_cfgs.curr->module_ens;
 335                 new_ens = &isp_dev->other_cfgs.last_or_new->module_ens;
 336                 updates = &isp_dev->other_cfgs.module_updates;
 337         }
 338
 339         if (flag == _GET_) {
 340                 *value = CIFISP_MODULE_IS_EN(*curr_ens, module);
 341                 goto end;
 342         }
 343
 344         if (CIFISP_MODULE_IS_EN(*curr_ens, module) != *value) {
 345                 if (*value)
 346                         CIFISP_MODULE_EN(*new_ens, module);
 347                 else
 348                         CIFISP_MODULE_DIS(*new_ens, module);
 349
 350                 CIFISP_MODULE_UPDATE(*updates, module);
 351         }
 352
 353 end:
 354         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
 355
 356         return retval;
 357 }
 358
 359 /* ISP BP interface function */
 360 static int cifisp_dpcc_param(struct cif_isp10_isp_dev *isp_dev,
 361                             bool flag, struct cifisp_dpcc_config *arg)
 362 {
 363         unsigned long lock_flags = 0;
 364         unsigned int i;
 365         struct cifisp_dpcc_methods_config *method;
 366         int retval = 0;
 367
 368         if (!arg) {
 369                 CIFISP_DPRINT(CIFISP_ERROR,
 370                               "arg is NULL: %s\n", __func__);
 371
 372                 return -EINVAL;
 373         }
 374
 375         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
 376
 377         if (flag == _GET_) {
 378                 memcpy(arg,
 379                         &isp_dev->other_cfgs.curr->dpcc_config,
 380                         sizeof(*arg));
 381                 goto end;
 382         }
 383
 384         cifisp_param_dump(arg, CIFISP_MODULE_DPCC);
 385
 386         if (memcmp(arg,
 387                 &isp_dev->other_cfgs.curr->dpcc_config,
 388                 sizeof(*arg)) == 0) {
 389                 CIFISP_DPRINT(CIFISP_DEBUG,
 390                               "same param in function: %s\n", __func__);
 391                 goto end;
 392         }
 393
 394         if (arg->mode > CIFISP_DPCC_MODE_MAX ||
 395                 arg->output_mode > CIFISP_DPCC_OUTPUTMODE_MAX ||
 396                 arg->set_use > CIFISP_DPCC_SETUSE_MAX ||
 397                 arg->ro_limits & CIFISP_DPCC_RO_LIMIT_RESERVED ||
 398                 arg->rnd_offs & CIFISP_DPCC_RND_OFFS_RESERVED) {
 399                 CIFISP_DPRINT(CIFISP_ERROR,
 400                               "incompatible param in function: %s\n", __func__);
 401                 retval = -EINVAL;
 402                 goto end;
 403         }
 404
 405         method = &arg->methods[i];
 406         for (i = 0; i < CIFISP_DPCC_METHODS_MAX; i++) {
 407                 if ((method->method &
 408                         CIFISP_DPCC_METHODS_SET_RESERVED) ||
 409                         (method->line_thresh &
 410                         CIFISP_DPCC_LINE_THRESH_RESERVED) ||
 411                         (method->line_mad_fac &
 412                         CIFISP_DPCC_LINE_MAD_FAC_RESERVED) ||
 413                         (method->pg_fac &
 414                         CIFISP_DPCC_PG_FAC_RESERVED) ||
 415                         (method->rnd_thresh &
 416                         CIFISP_DPCC_RND_THRESH_RESERVED) ||
 417                         (method->rg_fac & CIFISP_DPCC_RG_FAC_RESERVED)) {
 418                         CIFISP_DPRINT(CIFISP_ERROR,
 419                               "incompatible param in function: %s\n", __func__);
 420                         retval = -EINVAL;
 421                         goto end;
 422                 }
 423                 method++;
 424         }
 425
 426         memcpy(&isp_dev->other_cfgs.last_or_new->dpcc_config,
 427                 arg,
 428                 sizeof(struct cifisp_dpcc_config));
 429         CIFISP_MODULE_UPDATE(
 430                 isp_dev->other_cfgs.module_updates,
 431                 CIFISP_MODULE_DPCC);
 432 end:
 433         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
 434
 435         return retval;
 436 }
 437
 438 /* ISP black level subtraction interface function */
 439 static int cifisp_bls_param(struct cif_isp10_isp_dev *isp_dev,
 440                             bool flag, struct cifisp_bls_config *arg)
 441 {
 442         unsigned long lock_flags = 0;
 443         int retval = 0;
 444
 445         if (!arg)
 446                 return -EINVAL;
 447
 448         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
 449
 450         if (flag == _GET_) {
 451                 memcpy(arg,
 452                         &isp_dev->other_cfgs.curr->bls_config,
 453                         sizeof(*arg));
 454                 goto end;
 455         }
 456
 457         cifisp_param_dump(arg, CIFISP_MODULE_BLS);
 458
 459         if (memcmp(arg,
 460                 &isp_dev->other_cfgs.curr->bls_config,
 461                 sizeof(*arg)) == 0) {
 462                 CIFISP_DPRINT(CIFISP_DEBUG,
 463                               "same param in function: %s\n", __func__);
 464                 goto end;
 465         }
 466
 467         if (arg->bls_window1.h_offs > CIFISP_BLS_START_H_MAX ||
 468             arg->bls_window1.h_size > CIFISP_BLS_STOP_H_MAX ||
 469             arg->bls_window1.v_offs > CIFISP_BLS_START_V_MAX ||
 470             arg->bls_window1.v_size > CIFISP_BLS_STOP_V_MAX ||
 471             arg->bls_window2.h_offs > CIFISP_BLS_START_H_MAX ||
 472             arg->bls_window2.h_size > CIFISP_BLS_STOP_H_MAX ||
 473             arg->bls_window2.v_offs > CIFISP_BLS_START_V_MAX ||
 474             arg->bls_window2.v_size > CIFISP_BLS_STOP_V_MAX ||
 475             arg->bls_samples > CIFISP_BLS_SAMPLES_MAX ||
 476             arg->fixed_val.r > CIFISP_BLS_FIX_SUB_MAX ||
 477             arg->fixed_val.gr > CIFISP_BLS_FIX_SUB_MAX ||
 478             arg->fixed_val.gb > CIFISP_BLS_FIX_SUB_MAX ||
 479             arg->fixed_val.b > CIFISP_BLS_FIX_SUB_MAX ||
 480             arg->fixed_val.r < (s16)CIFISP_BLS_FIX_SUB_MIN ||
 481             arg->fixed_val.gr < (s16)CIFISP_BLS_FIX_SUB_MIN ||
 482             arg->fixed_val.gb < (s16)CIFISP_BLS_FIX_SUB_MIN ||
 483             arg->fixed_val.b < (s16)CIFISP_BLS_FIX_SUB_MIN) {
 484                 CIFISP_DPRINT(CIFISP_ERROR,
 485                               "incompatible param in function: %s\n", __func__);
 486                 retval = -EINVAL;
 487                 goto end;
 488         }
 489
 490         memcpy(&isp_dev->other_cfgs.last_or_new->bls_config,
 491                 arg,
 492                 sizeof(struct cifisp_bls_config));
 493         CIFISP_MODULE_UPDATE(
 494                 isp_dev->other_cfgs.module_updates,
 495                 CIFISP_MODULE_BLS);
 496 end:
 497         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
 498
 499         return retval;
 500 }
 501
 502 /* ISP LS correction interface function */
 503 static int cifisp_lsc_param(struct cif_isp10_isp_dev *isp_dev,
 504                             bool flag, struct cifisp_lsc_config *arg)
 505 {
 506         int i;
 507         unsigned long lock_flags = 0;
 508         int retval = 0;
 509
 510         if (!arg)
 511                 return -EINVAL;
 512
 513         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
 514
 515         if (flag == _GET_) {
 516                 memcpy(arg,
 517                         &isp_dev->other_cfgs.curr->lsc_config,
 518                         sizeof(*arg));
 519                 goto end;
 520         }
 521
 522         cifisp_param_dump(arg, CIFISP_MODULE_LSC);
 523
 524         if (memcmp(arg,
 525                 &isp_dev->other_cfgs.curr->lsc_config,
 526                 sizeof(*arg)) == 0) {
 527                 CIFISP_DPRINT(CIFISP_DEBUG,
 528                               "same param in function: %s\n", __func__);
 529                 goto end;
 530         }
 531
 532         for (i = 0; i < CIFISP_LSC_SIZE_TBL_SIZE; i++) {
 533                 if ((*(arg->x_size_tbl + i) & CIFISP_LSC_SECT_SIZE_RESERVED) ||
 534                     (*(arg->y_size_tbl + i) & CIFISP_LSC_SECT_SIZE_RESERVED)) {
 535                         CIFISP_DPRINT(CIFISP_ERROR,
 536                                       "incompatible sect size x 0x%x y 0x%x in function: %s\n",
 537                                       *(arg->x_size_tbl + i),
 538                                       *(arg->y_size_tbl + i), __func__);
 539                         retval = -EINVAL;
 540                         goto end;
 541                 }
 542         }
 543
 544         for (i = 0; i < CIFISP_LSC_GRAD_TBL_SIZE; i++) {
 545                 if ((*(arg->x_grad_tbl + i) & CIFISP_LSC_GRAD_RESERVED) ||
 546                     (*(arg->y_grad_tbl + i) & CIFISP_LSC_GRAD_RESERVED)) {
 547                         CIFISP_DPRINT(CIFISP_ERROR,
 548                                       "incompatible grad x 0x%x y 0x%xin function: %s\n",
 549                                       *(arg->x_grad_tbl + i),
 550                                       *(arg->y_grad_tbl + i), __func__);
 551                         retval = -EINVAL;
 552                         goto end;
 553                 }
 554         }
 555
 556         for (i = 0; i < CIFISP_LSC_DATA_TBL_SIZE; i++) {
 557                 if ((*(arg->r_data_tbl + i) &
 558                         CIFISP_LSC_SAMPLE_RESERVED) ||
 559                         (*(arg->gr_data_tbl + i) &
 560                         CIFISP_LSC_SAMPLE_RESERVED) ||
 561                         (*(arg->gb_data_tbl + i) &
 562                         CIFISP_LSC_SAMPLE_RESERVED) ||
 563                         (*(arg->b_data_tbl + i) &
 564                         CIFISP_LSC_SAMPLE_RESERVED)) {
 565                         CIFISP_DPRINT(CIFISP_ERROR,
 566                                         "incompatible sample r 0x%x gr 0x%x gb 0x%x b 0x%x in function: %s\n",
 567                                         *(arg->r_data_tbl + i),
 568                                         *(arg->gr_data_tbl + i),
 569                                         *(arg->gb_data_tbl + i),
 570                                         *(arg->b_data_tbl + i), __func__);
 571                         retval = -EINVAL;
 572                         goto end;
 573                 }
 574         }
 575
 576         memcpy(&isp_dev->other_cfgs.last_or_new->lsc_config,
 577                 arg,
 578                 sizeof(struct cifisp_lsc_config));
 579         CIFISP_MODULE_UPDATE(
 580                 isp_dev->other_cfgs.module_updates,
 581                 CIFISP_MODULE_LSC);
 582 end:
 583         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
 584
 585         return retval;
 586 }
 587
 588 /* ISP Filtering function */
 589 static int cifisp_flt_param(struct cif_isp10_isp_dev *isp_dev,
 590                             bool flag, struct cifisp_flt_config *arg)
 591 {
 592         unsigned long lock_flags = 0;
 593         int retval = 0;
 594
 595         if (!arg)
 596                 return -EINVAL;
 597
 598         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
 599
 600         if (flag == _GET_) {
 601                 memcpy(arg,
 602                         &isp_dev->other_cfgs.curr->flt_config,
 603                         sizeof(*arg));
 604                 goto end;
 605         }
 606
 607         cifisp_param_dump(arg, CIFISP_MODULE_FLT);
 608
 609         if (memcmp(arg,
 610                 &isp_dev->other_cfgs.curr->flt_config,
 611                 sizeof(*arg)) == 0) {
 612                 CIFISP_DPRINT(CIFISP_DEBUG,
 613                               "same param in function: %s\n", __func__);
 614                 goto end;
 615         }
 616
 617         /* Parameter check */
 618         if (arg->mode > CIFISP_FLT_MODE_MAX ||
 619                 arg->grn_stage1 > CIFISP_FLT_GREEN_STAGE1_MAX ||
 620                 arg->chr_v_mode > CIFISP_FLT_CHROMA_MODE_MAX ||
 621                 arg->chr_h_mode > CIFISP_FLT_CHROMA_MODE_MAX ||
 622                 arg->thresh_sh0 & CIFISP_FLT_THREAD_RESERVED ||
 623                 arg->thresh_sh1 & CIFISP_FLT_THREAD_RESERVED ||
 624                 arg->thresh_bl0 & CIFISP_FLT_THREAD_RESERVED ||
 625                 arg->thresh_bl1 & CIFISP_FLT_THREAD_RESERVED ||
 626                 arg->fac_bl0 & CIFISP_FLT_FAC_RESERVED ||
 627                 arg->fac_bl1 & CIFISP_FLT_FAC_RESERVED ||
 628                 arg->fac_sh0 & CIFISP_FLT_FAC_RESERVED ||
 629                 arg->fac_sh1 & CIFISP_FLT_FAC_RESERVED ||
 630                 arg->fac_mid & CIFISP_FLT_FAC_RESERVED ||
 631                 arg->lum_weight & CIFISP_FLT_LUM_WEIGHT_RESERVED) {
 632                 CIFISP_DPRINT(CIFISP_ERROR,
 633                               "incompatible param in function: %s\n", __func__);
 634                 retval = -EINVAL;
 635                 goto end;
 636         }
 637
 638         memcpy(&isp_dev->other_cfgs.last_or_new->flt_config,
 639                 arg,
 640                 sizeof(struct cifisp_flt_config));
 641         CIFISP_MODULE_UPDATE(
 642                 isp_dev->other_cfgs.module_updates,
 643                 CIFISP_MODULE_FLT);
 644 end:
 645         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
 646
 647         return retval;
 648 }
 649
 650 /* ISP demosaic interface function */
 651 static int cifisp_bdm_param(struct cif_isp10_isp_dev *isp_dev,
 652                             bool flag, struct cifisp_bdm_config *arg)
 653 {
 654         unsigned long lock_flags = 0;
 655         int retval = 0;
 656
 657         if (!arg)
 658                 return -EINVAL;
 659
 660         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
 661
 662         if (flag == _GET_) {
 663                 memcpy(arg,
 664                         &isp_dev->other_cfgs.curr->bdm_config,
 665                         sizeof(*arg));
 666                 goto end;
 667         }
 668
 669         cifisp_param_dump(arg, CIFISP_MODULE_BDM);
 670
 671         if (memcmp(arg,
 672                 &isp_dev->other_cfgs.curr->bdm_config,
 673                 sizeof(*arg)) == 0) {
 674                 CIFISP_DPRINT(CIFISP_DEBUG,
 675                               "same param in function: %s\n", __func__);
 676                 goto end;
 677         }
 678
 679         memcpy(&isp_dev->other_cfgs.last_or_new->bdm_config,
 680                 arg,
 681                 sizeof(struct cifisp_bdm_config));
 682         CIFISP_MODULE_UPDATE(
 683                 isp_dev->other_cfgs.module_updates,
 684                 CIFISP_MODULE_BDM);
 685 end:
 686         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
 687
 688         return retval;
 689 }
 690
 691 /* ISP GAMMA correction interface function */
 692 static int cifisp_sdg_param(struct cif_isp10_isp_dev *isp_dev,
 693                             bool flag, struct cifisp_sdg_config *arg)
 694 {
 695         unsigned long lock_flags = 0;
 696         unsigned int i;
 697         int retval = 0;
 698
 699         if (!arg)
 700                 return -EINVAL;
 701
 702         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
 703
 704         if (flag == _GET_) {
 705                 memcpy(arg,
 706                         &isp_dev->other_cfgs.curr->sdg_config,
 707                         sizeof(*arg));
 708                 goto end;
 709         }
 710
 711         cifisp_param_dump(arg, CIFISP_MODULE_SDG);
 712
 713         if (memcmp(arg,
 714                 &isp_dev->other_cfgs.curr->sdg_config,
 715                 sizeof(*arg)) == 0) {
 716                 CIFISP_DPRINT(CIFISP_DEBUG,
 717                               "same param in function: %s\n", __func__);
 718                 goto end;
 719         }
 720
 721         if (arg->xa_pnts.gamma_dx0 & CIFISP_DEGAMMA_X_RESERVED ||
 722             arg->xa_pnts.gamma_dx1 & CIFISP_DEGAMMA_X_RESERVED) {
 723                 CIFISP_DPRINT(CIFISP_ERROR,
 724                               "incompatible param in function: %s\n", __func__);
 725                 retval = -EINVAL;
 726                 goto end;
 727         }
 728
 729         for (i = 0; i < CIFISP_DEGAMMA_CURVE_SIZE; i++) {
 730                 if ((arg->curve_b.gamma_y[i] & CIFISP_DEGAMMA_Y_RESERVED) ||
 731                         (arg->curve_r.gamma_y[i] & CIFISP_DEGAMMA_Y_RESERVED) ||
 732                         (arg->curve_g.gamma_y[i] & CIFISP_DEGAMMA_Y_RESERVED)) {
 733                         CIFISP_DPRINT(CIFISP_ERROR,
 734                               "incompatible param in function: %s\n", __func__);
 735                         retval = -EINVAL;
 736                         goto end;
 737                 }
 738         }
 739
 740         memcpy(&isp_dev->other_cfgs.last_or_new->sdg_config,
 741                 arg,
 742                 sizeof(struct cifisp_sdg_config));
 743         CIFISP_MODULE_UPDATE(
 744                 isp_dev->other_cfgs.module_updates,
 745                 CIFISP_MODULE_SDG);
 746 end:
 747         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
 748
 749         return retval;
 750 }
 751
 752 /* ISP GAMMA correction interface function */
 753 static int cifisp_goc_param(struct cif_isp10_isp_dev *isp_dev,
 754                             bool flag, struct cifisp_goc_config *arg)
 755 {
 756         unsigned long lock_flags = 0;
 757         int retval = 0;
 758
 759         if (!arg)
 760                 return -EINVAL;
 761
 762         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
 763
 764         if (flag == _GET_) {
 765                 memcpy(arg,
 766                         &isp_dev->other_cfgs.curr->goc_config,
 767                         sizeof(*arg));
 768                 goto end;
 769         }
 770
 771         cifisp_param_dump(arg, CIFISP_MODULE_GOC);
 772
 773         if (memcmp(arg,
 774                 &isp_dev->other_cfgs.curr->goc_config,
 775                 sizeof(*arg)) == 0) {
 776                 CIFISP_DPRINT(CIFISP_DEBUG,
 777                               "same param in function: %s\n", __func__);
 778                 goto end;
 779         }
 780
 781         if (arg->mode > CIFISP_GOC_MODE_MAX) {
 782                 CIFISP_DPRINT(CIFISP_ERROR,
 783                                       "incompatible param 0x%x in  function: %s\n",
 784                                       arg->mode, __func__);
 785                 retval = -EINVAL;
 786                 goto end;
 787         }
 788
 789         memcpy(&isp_dev->other_cfgs.last_or_new->goc_config,
 790                 arg,
 791                 sizeof(struct cifisp_goc_config));
 792         CIFISP_MODULE_UPDATE(
 793                 isp_dev->other_cfgs.module_updates,
 794                 CIFISP_MODULE_GOC);
 795 end:
 796         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
 797
 798         return retval;
 799 }
 800
 801 /* ISP Cross Talk */
 802 static int cifisp_ctk_param(struct cif_isp10_isp_dev *isp_dev,
 803                             bool flag, struct cifisp_ctk_config *arg)
 804 {
 805         unsigned long lock_flags = 0;
 806         int retval = 0;
 807
 808         if (!arg)
 809                 return -EINVAL;
 810
 811         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
 812
 813         if (flag == _GET_) {
 814                 memcpy(arg,
 815                         &isp_dev->other_cfgs.curr->ctk_config,
 816                         sizeof(*arg));
 817                 goto end;
 818         }
 819
 820         cifisp_param_dump(arg, CIFISP_MODULE_CTK);
 821
 822         if (memcmp(arg,
 823                 &isp_dev->other_cfgs.curr->ctk_config,
 824                 sizeof(*arg)) == 0) {
 825                 CIFISP_DPRINT(CIFISP_DEBUG,
 826                               "same param in function: %s\n", __func__);
 827                 goto end;
 828         }
 829
 830         /* Perform parameter check */
 831         if (arg->coeff0 & CIFISP_CTK_COEFF_RESERVED ||
 832             arg->coeff1 & CIFISP_CTK_COEFF_RESERVED ||
 833             arg->coeff2 & CIFISP_CTK_COEFF_RESERVED ||
 834             arg->coeff3 & CIFISP_CTK_COEFF_RESERVED ||
 835             arg->coeff4 & CIFISP_CTK_COEFF_RESERVED ||
 836             arg->coeff5 & CIFISP_CTK_COEFF_RESERVED ||
 837             arg->coeff6 & CIFISP_CTK_COEFF_RESERVED ||
 838             arg->coeff7 & CIFISP_CTK_COEFF_RESERVED ||
 839             arg->coeff8 & CIFISP_CTK_COEFF_RESERVED ||
 840             arg->ct_offset_r & CIFISP_XTALK_OFFSET_RESERVED ||
 841             arg->ct_offset_g & CIFISP_XTALK_OFFSET_RESERVED ||
 842             arg->ct_offset_b & CIFISP_XTALK_OFFSET_RESERVED) {
 843                 CIFISP_DPRINT(CIFISP_ERROR,
 844                               "incompatible param in function: %s\n", __func__);
 845                 retval = -EINVAL;
 846                 goto end;
 847         }
 848
 849         memcpy(&isp_dev->other_cfgs.last_or_new->ctk_config,
 850                 arg,
 851                 sizeof(struct cifisp_ctk_config));
 852         CIFISP_MODULE_UPDATE(
 853                 isp_dev->other_cfgs.module_updates,
 854                 CIFISP_MODULE_CTK);
 855 end:
 856         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
 857
 858         return retval;
 859 }
 860
 861 /* ISP White Balance Mode */
 862 static int cifisp_awb_meas_param(struct cif_isp10_isp_dev *isp_dev,
 863                                  bool flag, struct cifisp_awb_meas_config *arg)
 864 {
 865         unsigned long lock_flags = 0;
 866         int retval = 0;
 867
 868         if (!arg)
 869                 return -EINVAL;
 870
 871         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
 872
 873         if (flag == _GET_) {
 874                 memcpy(arg,
 875                         &isp_dev->meas_cfgs.curr->awb_meas_config,
 876                         sizeof(*arg));
 877                 goto end;
 878         }
 879
 880         cifisp_param_dump(arg, CIFISP_MODULE_AWB);
 881
 882         if (memcmp(arg,
 883                 &isp_dev->meas_cfgs.curr->awb_meas_config,
 884                 sizeof(*arg)) == 0) {
 885                 CIFISP_DPRINT(CIFISP_DEBUG,
 886                               "same param in function: %s\n", __func__);
 887                 goto end;
 888         }
 889
 890         if (arg->awb_mode > CIFISP_AWB_MODE_YCBCR ||
 891             arg->awb_wnd.h_offs > CIFISP_AWB_WINDOW_OFFSET_MAX ||
 892             arg->awb_wnd.v_offs > CIFISP_AWB_WINDOW_OFFSET_MAX ||
 893             arg->awb_wnd.h_size > CIFISP_AWB_WINDOW_MAX_SIZE ||
 894             arg->awb_wnd.v_size > CIFISP_AWB_WINDOW_MAX_SIZE ||
 895             arg->frames > CIFISP_AWB_MAX_FRAMES) {
 896                 CIFISP_DPRINT(CIFISP_ERROR,
 897                               "incompatible param in function: %s\n", __func__);
 898                 retval = -EINVAL;
 899                 goto end;
 900         }
 901
 902         memcpy(&isp_dev->meas_cfgs.last_or_new->awb_meas_config,
 903                 arg,
 904                 sizeof(struct cifisp_awb_meas_config));
 905         CIFISP_MODULE_UPDATE(
 906                 isp_dev->meas_cfgs.module_updates,
 907                 CIFISP_MODULE_AWB);
 908 end:
 909         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
 910
 911         return retval;
 912 }
 913
 914 static int cifisp_awb_gain_param(struct cif_isp10_isp_dev *isp_dev,
 915                                  bool flag, struct cifisp_awb_gain_config *arg)
 916 {
 917         unsigned long lock_flags = 0;
 918         int retval = 0;
 919
 920         if (!arg)
 921                 return -EINVAL;
 922
 923         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
 924
 925         if (flag == _GET_) {
 926                 memcpy(arg,
 927                         &isp_dev->other_cfgs.curr->awb_gain_config,
 928                         sizeof(*arg));
 929                 goto end;
 930         }
 931
 932         cifisp_param_dump(arg, CIFISP_MODULE_AWB_GAIN);
 933
 934         if (memcmp(arg,
 935                 &isp_dev->other_cfgs.curr->awb_gain_config,
 936                 sizeof(*arg)) == 0) {
 937                 CIFISP_DPRINT(CIFISP_DEBUG,
 938                               "same param in function: %s\n", __func__);
 939                 goto end;
 940         }
 941
 942         if (arg->gain_red > CIFISP_AWB_GAINS_MAX_VAL ||
 943             arg->gain_green_r > CIFISP_AWB_GAINS_MAX_VAL ||
 944             arg->gain_green_b > CIFISP_AWB_GAINS_MAX_VAL ||
 945             arg->gain_blue > CIFISP_AWB_GAINS_MAX_VAL) {
 946                 CIFISP_DPRINT(CIFISP_ERROR,
 947                               "incompatible param in function: %s\n", __func__);
 948                 retval = -EINVAL;
 949                 goto end;
 950         }
 951
 952         memcpy(&isp_dev->other_cfgs.last_or_new->awb_gain_config,
 953                 arg,
 954                 sizeof(struct cifisp_awb_gain_config));
 955         CIFISP_MODULE_UPDATE(
 956                 isp_dev->other_cfgs.module_updates,
 957                 CIFISP_MODULE_AWB_GAIN);
 958 end:
 959         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
 960
 961         return retval;
 962 }
 963
 964 static int cifisp_aec_param(struct cif_isp10_isp_dev *isp_dev,
 965                             bool flag, struct cifisp_aec_config *arg)
 966 {
 967         unsigned long lock_flags = 0;
 968         int retval = 0;
 969
 970         if (!arg)
 971                 return -EINVAL;
 972
 973         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
 974
 975         if (flag == _GET_) {
 976                 memcpy(arg,
 977                         &isp_dev->meas_cfgs.curr->aec_config,
 978                         sizeof(*arg));
 979                 goto end;
 980         }
 981
 982         cifisp_param_dump(arg, CIFISP_MODULE_AEC);
 983
 984         if (memcmp(arg,
 985                 &isp_dev->meas_cfgs.curr->aec_config,
 986                 sizeof(*arg)) == 0) {
 987                 CIFISP_DPRINT(CIFISP_DEBUG,
 988                               "same param in function: %s\n", __func__);
 989                 goto end;
 990         }
 991
 992         if (arg->meas_window.h_offs > CIFISP_EXP_MAX_HOFFS ||
 993                 arg->meas_window.h_size > CIFISP_EXP_MAX_HSIZE ||
 994                 arg->meas_window.h_size < CIFISP_EXP_MIN_HSIZE ||
 995                 arg->meas_window.v_offs > CIFISP_EXP_MAX_VOFFS ||
 996                 arg->meas_window.v_size > CIFISP_EXP_MAX_VSIZE ||
 997                 arg->meas_window.v_size < CIFISP_EXP_MIN_VSIZE ||
 998                 arg->mode > CIFISP_EXP_MEASURING_MODE_1) {
 999                 CIFISP_DPRINT(CIFISP_ERROR,
1000                               "incompatible param in function: %s\n", __func__);
1001                 retval = -EINVAL;
1002                 goto end;
1003         }
1004
1005         memcpy(&isp_dev->meas_cfgs.last_or_new->aec_config,
1006                 arg,
1007                 sizeof(struct cifisp_aec_config));
1008         CIFISP_MODULE_UPDATE(
1009                 isp_dev->meas_cfgs.module_updates,
1010                 CIFISP_MODULE_AEC);
1011 end:
1012         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
1013
1014         return retval;
1015 }
1016
1017 static int cifisp_cproc_param(struct cif_isp10_isp_dev *isp_dev,
1018                               bool flag, struct cifisp_cproc_config *arg)
1019 {
1020         unsigned long lock_flags = 0;
1021         int retval = 0;
1022
1023         if (!arg)
1024                 return -EINVAL;
1025
1026         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
1027
1028         if (flag == _GET_) {
1029                 memcpy(arg,
1030                         &isp_dev->other_cfgs.curr->cproc_config,
1031                         sizeof(*arg));
1032                 goto end;
1033         }
1034
1035         cifisp_param_dump(arg, CIFISP_MODULE_CPROC);
1036
1037         if (memcmp(arg,
1038                 &isp_dev->other_cfgs.curr->cproc_config,
1039                 sizeof(*arg)) == 0) {
1040                 CIFISP_DPRINT(CIFISP_DEBUG,
1041                               "same param in function: %s\n", __func__);
1042                 goto end;
1043         }
1044
1045         if (arg->c_out_range & CIFISP_CPROC_CTRL_RESERVED ||
1046             arg->y_out_range & CIFISP_CPROC_CTRL_RESERVED ||
1047             arg->y_in_range & CIFISP_CPROC_CTRL_RESERVED ||
1048             arg->contrast & CIFISP_CPROC_CONTRAST_RESERVED ||
1049             arg->brightness & CIFISP_CPROC_BRIGHTNESS_RESERVED ||
1050             arg->sat & CIFISP_CPROC_SATURATION_RESERVED ||
1051             arg->hue & CIFISP_CPROC_HUE_RESERVED) {
1052                 CIFISP_DPRINT(CIFISP_ERROR,
1053                               "incompatible param in function: %s\n", __func__);
1054                 retval = -EINVAL;
1055                 goto end;
1056         }
1057
1058         memcpy(&isp_dev->other_cfgs.last_or_new->cproc_config,
1059                 arg,
1060                 sizeof(struct cifisp_cproc_config));
1061         CIFISP_MODULE_UPDATE(
1062                 isp_dev->other_cfgs.module_updates,
1063                 CIFISP_MODULE_CPROC);
1064 end:
1065         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
1066
1067         return retval;
1068 }
1069
1070 static int cifisp_hst_param(struct cif_isp10_isp_dev *isp_dev,
1071                             bool flag, struct cifisp_hst_config *arg)
1072 {
1073         unsigned long lock_flags = 0;
1074         unsigned int i;
1075         int retval = 0;
1076
1077         if (!arg)
1078                 return -EINVAL;
1079
1080         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
1081
1082         if (flag == _GET_) {
1083                 memcpy(arg,
1084                         &isp_dev->meas_cfgs.curr->hst_config,
1085                         sizeof(*arg));
1086                 goto end;
1087         }
1088
1089         if (memcmp(arg,
1090                 &isp_dev->meas_cfgs.curr->hst_config,
1091                 sizeof(*arg)) == 0) {
1092                 CIFISP_DPRINT(CIFISP_DEBUG,
1093                               "same param in function: %s\n", __func__);
1094                 goto end;
1095         }
1096
1097         if (arg->mode > CIFISP_HISTOGRAM_MODE_Y_HISTOGRAM ||
1098                 arg->histogram_predivider > CIFISP_MAX_HIST_PREDIVIDER ||
1099                 arg->meas_window.v_offs & CIFISP_HIST_WINDOW_OFFSET_RESERVED ||
1100                 arg->meas_window.h_offs & CIFISP_HIST_WINDOW_OFFSET_RESERVED ||
1101                 (arg->meas_window.v_size / (CIFISP_HIST_ROW_NUM - 1)) &
1102                         CIFISP_HIST_WINDOW_SIZE_RESERVED ||
1103                 (arg->meas_window.h_size / (CIFISP_HIST_COLUMN_NUM - 1)) &
1104                         CIFISP_HIST_WINDOW_SIZE_RESERVED) {
1105                 CIFISP_DPRINT(CIFISP_ERROR,
1106                 "incompatible param in function: %s line: %d\n",
1107                 __func__, __LINE__);
1108                 retval = -EINVAL;
1109                 goto end;
1110         }
1111
1112         for (i = 0; i < CIFISP_HISTOGRAM_WEIGHT_GRIDS_SIZE; i++) {
1113                 if (arg->hist_weight[i] & CIFISP_HIST_WEIGHT_RESERVED) {
1114                         CIFISP_DPRINT(CIFISP_ERROR,
1115                         "incompatible param in function: %s line: %d\n",
1116                         __func__, __LINE__);
1117                         retval = -EINVAL;
1118                         goto end;
1119                 }
1120         }
1121
1122         memcpy(&isp_dev->meas_cfgs.last_or_new->hst_config,
1123                 arg,
1124                 sizeof(struct cifisp_hst_config));
1125         CIFISP_MODULE_UPDATE(
1126                 isp_dev->meas_cfgs.module_updates,
1127                 CIFISP_MODULE_HST);
1128 end:
1129         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
1130
1131         return retval;
1132 }
1133
1134 static int cifisp_afc_param(struct cif_isp10_isp_dev *isp_dev,
1135                             bool flag, struct cifisp_afc_config *arg)
1136 {
1137         unsigned long lock_flags = 0;
1138         int i;
1139         int retval = 0;
1140
1141         if (!arg)
1142                 return -EINVAL;
1143
1144         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
1145
1146         if (flag == _GET_) {
1147                 memcpy(arg,
1148                         &isp_dev->meas_cfgs.curr->afc_config,
1149                         sizeof(*arg));
1150                 goto end;
1151         }
1152
1153         cifisp_param_dump(arg, CIFISP_MODULE_AFC);
1154
1155         if (memcmp(arg,
1156                 &isp_dev->meas_cfgs.curr->afc_config,
1157                 sizeof(*arg)) == 0) {
1158                 CIFISP_DPRINT(CIFISP_DEBUG,
1159                               "same param in function: %s\n", __func__);
1160                 goto end;
1161         }
1162
1163         if (arg->num_afm_win > CIFISP_AFM_MAX_WINDOWS ||
1164             arg->thres & CIFISP_AFC_THRES_RESERVED ||
1165             arg->var_shift & CIFISP_AFC_VAR_SHIFT_RESERVED) {
1166                 CIFISP_DPRINT(CIFISP_ERROR,
1167                               "incompatible param in function: %s\n", __func__);
1168                 retval = -EINVAL;
1169                 goto end;
1170         }
1171
1172         for (i = 0; i < arg->num_afm_win; i++) {
1173                 if (arg->afm_win[i].h_offs & CIFISP_AFC_WINDOW_X_RESERVED ||
1174                     arg->afm_win[i].h_offs < CIFISP_AFC_WINDOW_X_MIN ||
1175                     arg->afm_win[i].v_offs & CIFISP_AFC_WINDOW_Y_RESERVED ||
1176                     arg->afm_win[i].v_offs < CIFISP_AFC_WINDOW_Y_MIN ||
1177                     arg->afm_win[i].h_size & CIFISP_AFC_WINDOW_X_RESERVED ||
1178                     arg->afm_win[i].v_size & CIFISP_AFC_WINDOW_Y_RESERVED) {
1179                         CIFISP_DPRINT(CIFISP_ERROR,
1180                                       "incompatible param in function: %s\n",
1181                                       __func__);
1182                         retval = -EINVAL;
1183                         goto end;
1184                 }
1185         }
1186
1187         memcpy(&isp_dev->meas_cfgs.last_or_new->afc_config,
1188                 arg,
1189                 sizeof(struct cifisp_afc_config));
1190         CIFISP_MODULE_UPDATE(
1191                 isp_dev->meas_cfgs.module_updates,
1192                 CIFISP_MODULE_AFC);
1193 end:
1194         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
1195
1196         return retval;
1197 }
1198
1199 static int cifisp_ie_param(struct cif_isp10_isp_dev *isp_dev,
1200                             bool flag, struct cifisp_ie_config *arg)
1201 {
1202         unsigned long lock_flags = 0;
1203         int retval = 0;
1204
1205         if (!arg)
1206                 return -EINVAL;
1207
1208         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
1209
1210         if (flag == _GET_) {
1211                 memcpy(arg,
1212                         &isp_dev->other_cfgs.curr->ie_config,
1213                         sizeof(*arg));
1214                 goto end;
1215         }
1216
1217         cifisp_param_dump(arg, CIFISP_MODULE_IE);
1218
1219         if (memcmp(arg,
1220                 &isp_dev->other_cfgs.curr->ie_config,
1221                 sizeof(*arg)) == 0) {
1222                 CIFISP_DPRINT(CIFISP_DEBUG,
1223                               "same param in function: %s\n", __func__);
1224                 goto end;
1225         }
1226
1227         if (arg->effect != V4L2_COLORFX_NONE &&
1228                         arg->effect != V4L2_COLORFX_BW &&
1229                         arg->effect != V4L2_COLORFX_SEPIA &&
1230                         arg->effect != V4L2_COLORFX_NEGATIVE &&
1231                         arg->effect != V4L2_COLORFX_EMBOSS &&
1232                         arg->effect != V4L2_COLORFX_SKETCH &&
1233                         arg->effect != V4L2_COLORFX_AQUA &&
1234                         arg->effect != V4L2_COLORFX_SET_CBCR) {
1235                 CIFISP_DPRINT(CIFISP_ERROR,
1236                               "incompatible param in function: %s\n", __func__);
1237                 retval = -EINVAL;
1238                 goto end;
1239         }
1240
1241         memcpy(&isp_dev->other_cfgs.last_or_new->ie_config,
1242                 arg,
1243                 sizeof(struct cifisp_ie_config));
1244         CIFISP_MODULE_UPDATE(
1245                 isp_dev->other_cfgs.module_updates,
1246                 CIFISP_MODULE_IE);
1247 end:
1248         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
1249
1250         return retval;
1251 }
1252
1253 /* ISP De-noise Pre-Filter(DPF) function */
1254 static int cifisp_dpf_param(struct cif_isp10_isp_dev *isp_dev,
1255                             bool flag, struct cifisp_dpf_config *arg)
1256 {
1257         unsigned long lock_flags = 0;
1258         unsigned int i;
1259         int retval = 0;
1260
1261         if (!arg)
1262                 return -EINVAL;
1263
1264         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
1265
1266         if (flag == _GET_) {
1267                 memcpy(arg,
1268                         &isp_dev->other_cfgs.curr->dpf_config,
1269                         sizeof(*arg));
1270                 goto end;
1271         }
1272
1273         cifisp_param_dump(arg, CIFISP_MODULE_DPF);
1274
1275         if (memcmp(arg,
1276                 &isp_dev->other_cfgs.curr->dpf_config,
1277                 sizeof(*arg)) == 0) {
1278                 CIFISP_DPRINT(CIFISP_DEBUG,
1279                               "same param in function: %s\n", __func__);
1280                 goto end;
1281         }
1282
1283         /* Parameter check */
1284         if ((arg->gain.mode >= CIFISP_DPF_GAIN_USAGE_MAX) ||
1285                 (arg->gain.mode < CIFISP_DPF_GAIN_USAGE_DISABLED) ||
1286                 (arg->gain.nf_b_gain & CIFISP_DPF_NF_GAIN_RESERVED) ||
1287                 (arg->gain.nf_r_gain & CIFISP_DPF_NF_GAIN_RESERVED) ||
1288                 (arg->gain.nf_gr_gain & CIFISP_DPF_NF_GAIN_RESERVED) ||
1289                 (arg->gain.nf_gb_gain & CIFISP_DPF_NF_GAIN_RESERVED)) {
1290                 CIFISP_DPRINT(CIFISP_ERROR,
1291                 "incompatible DPF GAIN param in function: %s\n",
1292                 __func__);
1293                 retval = -EINVAL;
1294                 goto end;
1295         }
1296
1297         for (i = 0; i < CIFISP_DPF_MAX_SPATIAL_COEFFS; i++) {
1298                 if ((arg->g_flt.spatial_coeff[i] >
1299                         CIFISP_DPF_SPATIAL_COEFF_MAX)) {
1300                         CIFISP_DPRINT(CIFISP_ERROR,
1301                         "incompatible DPF G Spatial param in function: %s\n",
1302                         __func__);
1303                         retval = -EINVAL;
1304                         goto end;
1305                 }
1306
1307                 if (arg->rb_flt.spatial_coeff[i] >
1308                         CIFISP_DPF_SPATIAL_COEFF_MAX) {
1309                         CIFISP_DPRINT(CIFISP_ERROR,
1310                         "incompatible DPF RB Spatial param in function: %s\n",
1311                         __func__);
1312                         retval = -EINVAL;
1313                         goto end;
1314                 }
1315         }
1316
1317         if ((arg->rb_flt.fltsize != CIFISP_DPF_RB_FILTERSIZE_9x9) &&
1318                 (arg->rb_flt.fltsize != CIFISP_DPF_RB_FILTERSIZE_13x9)) {
1319                 CIFISP_DPRINT(CIFISP_ERROR,
1320                         "incompatible DPF RB filter size param in function: %s\n",
1321                         __func__);
1322                 retval = -EINVAL;
1323                 goto end;
1324         }
1325
1326         for (i = 0; i < CIFISP_DPF_MAX_NLF_COEFFS; i++) {
1327                 if (arg->nll.coeff[i] > CIFISP_DPF_NLL_COEFF_N_MAX) {
1328                         CIFISP_DPRINT(CIFISP_ERROR,
1329                                 "incompatible DPF NLL coeff param in function: %s\n",
1330                                 __func__);
1331                         retval = -EINVAL;
1332                         goto end;
1333                 }
1334         }
1335
1336         if ((arg->nll.scale_mode != CIFISP_NLL_SCALE_LINEAR) &&
1337                 (arg->nll.scale_mode != CIFISP_NLL_SCALE_LOGARITHMIC)) {
1338                 CIFISP_DPRINT(CIFISP_ERROR,
1339                         "incompatible DPF NLL scale mode param in function: %s\n",
1340                         __func__);
1341                 retval = -EINVAL;
1342                 goto end;
1343         }
1344
1345         memcpy(&isp_dev->other_cfgs.last_or_new->dpf_config,
1346                 arg,
1347                 sizeof(struct cifisp_dpf_config));
1348         CIFISP_MODULE_UPDATE(
1349                 isp_dev->other_cfgs.module_updates,
1350                 CIFISP_MODULE_DPF);
1351 end:
1352         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
1353
1354         return retval;
1355 }
1356
1357 static int cifisp_dpf_strength_param(struct cif_isp10_isp_dev *isp_dev,
1358                             bool flag, struct cifisp_dpf_strength_config *arg)
1359 {
1360         unsigned long lock_flags = 0;
1361         int retval = 0;
1362
1363         if (!arg)
1364                 return -EINVAL;
1365
1366         spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
1367
1368         if (flag == _GET_) {
1369                 memcpy(arg,
1370                         &isp_dev->other_cfgs.curr->dpf_strength_config,
1371                         sizeof(*arg));
1372                 goto end;
1373         }
1374
1375         cifisp_param_dump(arg, CIFISP_MODULE_DPF_STRENGTH);
1376
1377         if (memcmp(arg,
1378                 &isp_dev->other_cfgs.curr->dpf_strength_config,
1379                 sizeof(*arg)) == 0) {
1380                 CIFISP_DPRINT(CIFISP_DEBUG,
1381                               "same param in function: %s\n", __func__);
1382                 goto end;
1383         }
1384
1385         memcpy(&isp_dev->other_cfgs.last_or_new->dpf_strength_config,
1386                 arg,
1387                 sizeof(struct cifisp_dpf_strength_config));
1388         CIFISP_MODULE_UPDATE(
1389                 isp_dev->other_cfgs.module_updates,
1390                 CIFISP_MODULE_DPF_STRENGTH);
1391 end:
1392         spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
1393
1394         return retval;
1395 }
1396
1397 static int cifisp_last_capture_config(struct cifisp_last_capture_config *arg)
1398 {
1399 #ifdef LOG_CAPTURE_PARAMS
1400         if (!arg)
1401                 return -EINVAL;
1402
1403         memcpy(arg, &g_last_capture_config, sizeof(*arg));
1404
1405         return 0;
1406 #else
1407         return -EPERM;
1408 #endif
1409 }
1410
1411 /* DPCC */
1412 static void cifisp_dpcc_config(const struct cif_isp10_isp_dev *isp_dev)
1413 {
1414         const struct cifisp_dpcc_config *pconfig =
1415                 &isp_dev->other_cfgs.last_or_new->dpcc_config;
1416         unsigned int i;
1417
1418         cifisp_iowrite32(pconfig->mode, CIF_ISP_DPCC_MODE);
1419         cifisp_iowrite32(pconfig->output_mode, CIF_ISP_DPCC_OUTPUT_MODE);
1420         cifisp_iowrite32(pconfig->set_use, CIF_ISP_DPCC_SET_USE);
1421
1422         cifisp_iowrite32(pconfig->methods[0].method,
1423                         CIF_ISP_DPCC_METHODS_SET_1);
1424         cifisp_iowrite32(pconfig->methods[1].method,
1425                         CIF_ISP_DPCC_METHODS_SET_2);
1426         cifisp_iowrite32(pconfig->methods[2].method,
1427                         CIF_ISP_DPCC_METHODS_SET_3);
1428         for (i = 0; i < CIFISP_DPCC_METHODS_MAX; i++) {
1429                 cifisp_iowrite32(pconfig->methods[i].line_thresh,
1430                         CIF_ISP_DPCC_LINE_THRESH_1 + 0x14 * i);
1431                 cifisp_iowrite32(pconfig->methods[i].line_mad_fac,
1432                         CIF_ISP_DPCC_LINE_MAD_FAC_1 + 0x14 * i);
1433                 cifisp_iowrite32(pconfig->methods[i].pg_fac,
1434                         CIF_ISP_DPCC_PG_FAC_1 + 0x14 * i);
1435                 cifisp_iowrite32(pconfig->methods[i].rnd_thresh,
1436                         CIF_ISP_DPCC_RND_THRESH_1 + 0x14 * i);
1437                 cifisp_iowrite32(pconfig->methods[i].rg_fac,
1438                         CIF_ISP_DPCC_RG_FAC_1 + 0x14 * i);
1439         }
1440
1441         cifisp_iowrite32(pconfig->rnd_offs, CIF_ISP_DPCC_RND_OFFS);
1442         cifisp_iowrite32(pconfig->ro_limits, CIF_ISP_DPCC_RO_LIMITS);
1443 }
1444
1445 static void cifisp_dpcc_en(const struct cif_isp10_isp_dev *isp_dev)
1446 {
1447         cifisp_iowrite32OR(CIFISP_DPCC_ENA, CIF_ISP_DPCC_MODE);
1448 }
1449
1450 static void cifisp_dpcc_end(const struct cif_isp10_isp_dev *isp_dev)
1451 {
1452         cifisp_iowrite32(CIFISP_DPCC_DIS, CIF_ISP_DPCC_MODE);
1453 }
1454
1455 /* Lens Shade Correction */
1456
1457 /*****************************************************************************/
1458 static void cifisp_lsc_end(const struct cif_isp10_isp_dev *isp_dev)
1459 {
1460         cifisp_iowrite32(0, CIF_ISP_LSC_CTRL);
1461 }
1462
1463 static bool cifisp_lsc_correct_matrix_config(struct cif_isp10_isp_dev *isp_dev)
1464 {
1465         int i, n;
1466         unsigned int isp_lsc_status, sram_addr, isp_lsc_table_sel;
1467         unsigned int data;
1468         struct cifisp_lsc_config *pconfig =
1469                 &isp_dev->other_cfgs.last_or_new->lsc_config;
1470
1471         isp_lsc_status = cifisp_ioread32(CIF_ISP_LSC_STATUS);
1472         sram_addr = (isp_lsc_status & 0x2U) ? 0U : 153U; /* ( 17 * 18 ) >> 1 */
1473
1474         cifisp_iowrite32(sram_addr, CIF_ISP_LSC_R_TABLE_ADDR);
1475         cifisp_iowrite32(sram_addr, CIF_ISP_LSC_GR_TABLE_ADDR);
1476         cifisp_iowrite32(sram_addr, CIF_ISP_LSC_GB_TABLE_ADDR);
1477         cifisp_iowrite32(sram_addr, CIF_ISP_LSC_B_TABLE_ADDR);
1478
1479         /* program data tables (table size is 9 * 17 = 153) */
1480         for (n = 0; n < ((CIFISP_LSC_SECTORS_MAX + 1) *
1481                         (CIFISP_LSC_SECTORS_MAX + 1));
1482                         n += CIFISP_LSC_SECTORS_MAX + 1) {
1483                 /*
1484                  * 17 sectors with 2 values in one DWORD = 9
1485                  * DWORDs (8 steps + 1 outside loop)
1486                  */
1487                 for (i = 0; i < (CIFISP_LSC_SECTORS_MAX); i += 2) {
1488                         data = CIFISP_LSC_TABLE_DATA(pconfig->r_data_tbl[n + i],
1489                                 pconfig->r_data_tbl[n + i + 1]);
1490                         cifisp_iowrite32(data, CIF_ISP_LSC_R_TABLE_DATA);
1491
1492                         data = CIFISP_LSC_TABLE_DATA(
1493                                 pconfig->gr_data_tbl[n + i],
1494                                 pconfig->gr_data_tbl[n + i + 1]);
1495                         cifisp_iowrite32(data, CIF_ISP_LSC_GR_TABLE_DATA);
1496
1497                         data = CIFISP_LSC_TABLE_DATA(
1498                                 pconfig->gb_data_tbl[n + i],
1499                                 pconfig->gb_data_tbl[n + i + 1]);
1500                         cifisp_iowrite32(data, CIF_ISP_LSC_GB_TABLE_DATA);
1501
1502                         data = CIFISP_LSC_TABLE_DATA(pconfig->b_data_tbl[n + i],
1503                                 pconfig->b_data_tbl[n + i + 1]);
1504                         cifisp_iowrite32(data, CIF_ISP_LSC_B_TABLE_DATA);
1505                 }
1506
1507                 data = CIFISP_LSC_TABLE_DATA(
1508                         pconfig->r_data_tbl[n + CIFISP_LSC_SECTORS_MAX],
1509                         /* isp_dev->lsc_config.r_data_tbl[n + i] */0);
1510                 cifisp_iowrite32(data, CIF_ISP_LSC_R_TABLE_DATA);
1511
1512                 data = CIFISP_LSC_TABLE_DATA(
1513                         pconfig->gr_data_tbl[n + CIFISP_LSC_SECTORS_MAX],
1514                         /* isp_dev->lsc_config.gr_data_tbl[n + i] */0);
1515                 cifisp_iowrite32(data, CIF_ISP_LSC_GR_TABLE_DATA);
1516
1517                 data = CIFISP_LSC_TABLE_DATA(
1518                         pconfig->gb_data_tbl[n + CIFISP_LSC_SECTORS_MAX],
1519                         /* isp_dev->lsc_config.gr_data_tbl[n + i] */0);
1520                 cifisp_iowrite32(data, CIF_ISP_LSC_GB_TABLE_DATA);
1521
1522                 data = CIFISP_LSC_TABLE_DATA(
1523                                 pconfig->b_data_tbl[n + CIFISP_LSC_SECTORS_MAX],
1524                                 /* isp_dev->lsc_config.b_data_tbl[n + i] */0);
1525                 cifisp_iowrite32(data, CIF_ISP_LSC_B_TABLE_DATA);
1526         }
1527
1528         isp_lsc_table_sel = (isp_lsc_status & 0x2U) ? 0U : 1U;
1529         cifisp_iowrite32(isp_lsc_table_sel, CIF_ISP_LSC_TABLE_SEL);
1530         return true;
1531 }
1532
1533 /*****************************************************************************/
1534 static bool cifisp_lsc_config(struct cif_isp10_isp_dev *isp_dev)
1535 {
1536         int i;
1537         unsigned int data;
1538         struct cifisp_lsc_config *pconfig =
1539                 &isp_dev->other_cfgs.last_or_new->lsc_config;
1540
1541         if (pconfig->config_width != isp_dev->input_width ||
1542                 pconfig->config_height != isp_dev->input_height) {
1543                 CIFISP_DPRINT(CIFISP_DEBUG,
1544                         "LSC config: lsc_w %d lsc_h %d act_w %d act_h %d\n",
1545                         pconfig->config_width,
1546                         pconfig->config_height,
1547                         isp_dev->input_width,
1548                         isp_dev->input_height);
1549                 return false;
1550         }
1551
1552         CIFISP_DPRINT(CIFISP_DEBUG,
1553                 "LSC config: lsc_w %d lsc_h %d\n",
1554                 pconfig->config_width,
1555                 pconfig->config_height);
1556
1557         /* To config must be off */
1558         cifisp_iowrite32(0, CIF_ISP_LSC_CTRL);
1559
1560         cifisp_lsc_correct_matrix_config(isp_dev);
1561
1562         if (isp_dev->active_lsc_width !=
1563                 pconfig->config_width ||
1564                 isp_dev->active_lsc_height !=
1565                 pconfig->config_height) {
1566                 for (i = 0; i < 4; i++) {
1567                         /* program x size tables */
1568                         data = CIFISP_LSC_SECT_SIZE(
1569                                         pconfig->x_size_tbl[i * 2],
1570                                         pconfig->x_size_tbl[i * 2 + 1]);
1571                         cifisp_iowrite32(data, CIF_ISP_LSC_XSIZE_01 + i * 4);
1572
1573                         /* program x grad tables */
1574                         data = CIFISP_LSC_SECT_SIZE(
1575                                         pconfig->x_grad_tbl[i * 2],
1576                                         pconfig->x_grad_tbl[i * 2 + 1]);
1577                         cifisp_iowrite32(data, CIF_ISP_LSC_XGRAD_01 + i * 4);
1578
1579                         /* program y size tables */
1580                         data = CIFISP_LSC_SECT_SIZE(
1581                                         pconfig->y_size_tbl[i * 2],
1582                                         pconfig->y_size_tbl[i * 2 + 1]);
1583                         cifisp_iowrite32(data, CIF_ISP_LSC_YSIZE_01 + i * 4);
1584
1585                         /* program y grad tables */
1586                         data = CIFISP_LSC_SECT_SIZE(
1587                                         pconfig->y_grad_tbl[i * 2],
1588                                         pconfig->y_grad_tbl[i * 2 + 1]);
1589                         cifisp_iowrite32(data, CIF_ISP_LSC_YGRAD_01 + i * 4);
1590                 }
1591
1592                 isp_dev->active_lsc_width = pconfig->config_width;
1593                 isp_dev->active_lsc_height = pconfig->config_height;
1594         }
1595
1596         cifisp_iowrite32(1, CIF_ISP_LSC_CTRL);
1597
1598         return true;
1599 }
1600
1601 #ifdef LOG_CAPTURE_PARAMS
1602 static void cifisp_lsc_config_read(const struct cif_isp10_isp_dev *isp_dev,
1603                                    struct cifisp_lsc_config *pconfig)
1604 {
1605 );
1606 }
1607 #endif
1608
1609 /*****************************************************************************/
1610 static void cifisp_bls_get_meas(const struct cif_isp10_isp_dev *isp_dev,
1611         struct cifisp_stat_buffer *pbuf)
1612 {
1613         const struct cif_isp10_device *cif_dev =
1614                 container_of(isp_dev, struct cif_isp10_device, isp_dev);
1615         enum cif_isp10_pix_fmt in_pix_fmt;
1616
1617         in_pix_fmt = cif_dev->config.isp_config.input->pix_fmt;
1618         if (CIF_ISP10_PIX_FMT_BAYER_PAT_IS_BGGR(in_pix_fmt)) {
1619                 pbuf->params.ae.bls_val.meas_b =
1620                         cifisp_ioread32(CIF_ISP_BLS_A_MEASURED);
1621                 pbuf->params.ae.bls_val.meas_gb =
1622                         cifisp_ioread32(CIF_ISP_BLS_B_MEASURED);
1623                 pbuf->params.ae.bls_val.meas_gr =
1624                         cifisp_ioread32(CIF_ISP_BLS_C_MEASURED);
1625                 pbuf->params.ae.bls_val.meas_r =
1626                         cifisp_ioread32(CIF_ISP_BLS_D_MEASURED);
1627         } else if (CIF_ISP10_PIX_FMT_BAYER_PAT_IS_GBRG(in_pix_fmt)) {
1628                 pbuf->params.ae.bls_val.meas_gb =
1629                         cifisp_ioread32(CIF_ISP_BLS_A_MEASURED);
1630                 pbuf->params.ae.bls_val.meas_b =
1631                         cifisp_ioread32(CIF_ISP_BLS_B_MEASURED);
1632                 pbuf->params.ae.bls_val.meas_r =
1633                         cifisp_ioread32(CIF_ISP_BLS_C_MEASURED);
1634                 pbuf->params.ae.bls_val.meas_gr =
1635                         cifisp_ioread32(CIF_ISP_BLS_D_MEASURED);
1636         } else if (CIF_ISP10_PIX_FMT_BAYER_PAT_IS_GRBG(in_pix_fmt)) {
1637                 pbuf->params.ae.bls_val.meas_gr =
1638                         cifisp_ioread32(CIF_ISP_BLS_A_MEASURED);
1639                 pbuf->params.ae.bls_val.meas_r =
1640                         cifisp_ioread32(CIF_ISP_BLS_B_MEASURED);
1641                 pbuf->params.ae.bls_val.meas_b =
1642                         cifisp_ioread32(CIF_ISP_BLS_C_MEASURED);
1643                 pbuf->params.ae.bls_val.meas_gb =
1644                         cifisp_ioread32(CIF_ISP_BLS_D_MEASURED);
1645         } else if (CIF_ISP10_PIX_FMT_BAYER_PAT_IS_RGGB(in_pix_fmt)) {
1646                 pbuf->params.ae.bls_val.meas_r =
1647                         cifisp_ioread32(CIF_ISP_BLS_A_MEASURED);
1648                 pbuf->params.ae.bls_val.meas_gr =
1649                         cifisp_ioread32(CIF_ISP_BLS_B_MEASURED);
1650                 pbuf->params.ae.bls_val.meas_gb =
1651                         cifisp_ioread32(CIF_ISP_BLS_C_MEASURED);
1652                 pbuf->params.ae.bls_val.meas_b =
1653                         cifisp_ioread32(CIF_ISP_BLS_D_MEASURED);
1654         }
1655 }
1656
1657 /*****************************************************************************/
1658 static void cifisp_bls_config(const struct cif_isp10_isp_dev *isp_dev)
1659 {
1660         const struct cifisp_bls_config *pconfig =
1661                 &isp_dev->other_cfgs.last_or_new->bls_config;
1662         u32 new_control = 0;
1663         const struct cif_isp10_device *cif_dev =
1664                 container_of(isp_dev, struct cif_isp10_device, isp_dev);
1665         enum cif_isp10_pix_fmt in_pix_fmt;
1666
1667         in_pix_fmt = cif_dev->config.isp_config.input->pix_fmt;
1668
1669         /* fixed subtraction values */
1670         if (!pconfig->enable_auto) {
1671                 const struct cifisp_bls_fixed_val *pval =
1672                     &isp_dev->other_cfgs.last_or_new->bls_config.fixed_val;
1673
1674                 if (CIF_ISP10_PIX_FMT_BAYER_PAT_IS_BGGR(in_pix_fmt)) {
1675                         cifisp_iowrite32(pval->r, CIF_ISP_BLS_D_FIXED);
1676                         cifisp_iowrite32(pval->gr, CIF_ISP_BLS_C_FIXED);
1677                         cifisp_iowrite32(pval->gb, CIF_ISP_BLS_B_FIXED);
1678                         cifisp_iowrite32(pval->b, CIF_ISP_BLS_A_FIXED);
1679                 } else if (CIF_ISP10_PIX_FMT_BAYER_PAT_IS_GBRG(in_pix_fmt)) {
1680                         cifisp_iowrite32(pval->r, CIF_ISP_BLS_C_FIXED);
1681                         cifisp_iowrite32(pval->gr, CIF_ISP_BLS_D_FIXED);
1682                         cifisp_iowrite32(pval->gb, CIF_ISP_BLS_A_FIXED);
1683                         cifisp_iowrite32(pval->b, CIF_ISP_BLS_B_FIXED);
1684                 } else if (CIF_ISP10_PIX_FMT_BAYER_PAT_IS_GRBG(in_pix_fmt)) {
1685                         cifisp_iowrite32(pval->r, CIF_ISP_BLS_B_FIXED);
1686                         cifisp_iowrite32(pval->gr, CIF_ISP_BLS_A_FIXED);
1687                         cifisp_iowrite32(pval->gb, CIF_ISP_BLS_D_FIXED);
1688                         cifisp_iowrite32(pval->b, CIF_ISP_BLS_C_FIXED);
1689                 } else if (CIF_ISP10_PIX_FMT_BAYER_PAT_IS_RGGB(in_pix_fmt)) {
1690                         cifisp_iowrite32(pval->r, CIF_ISP_BLS_A_FIXED);
1691                         cifisp_iowrite32(pval->gr, CIF_ISP_BLS_B_FIXED);
1692                         cifisp_iowrite32(pval->gb, CIF_ISP_BLS_C_FIXED);
1693                         cifisp_iowrite32(pval->b, CIF_ISP_BLS_D_FIXED);
1694                 }
1695
1696                 new_control = CIFISP_BLS_MODE_FIXED;
1697                 cifisp_iowrite32(new_control, CIF_ISP_BLS_CTRL);
1698         } else {
1699                 if (pconfig->en_windows & 2) {
1700                         cifisp_iowrite32(pconfig->bls_window2.h_offs,
1701                                       CIF_ISP_BLS_H2_START);
1702                         cifisp_iowrite32(pconfig->bls_window2.h_size,
1703                                       CIF_ISP_BLS_H2_STOP);
1704                         cifisp_iowrite32(pconfig->bls_window2.v_offs,
1705                                       CIF_ISP_BLS_V2_START);
1706                         cifisp_iowrite32(pconfig->bls_window2.v_size,
1707                                       CIF_ISP_BLS_V2_STOP);
1708                         new_control |= CIFISP_BLS_WINDOW_2;
1709                 }
1710
1711                 if (pconfig->en_windows & 1) {
1712                         cifisp_iowrite32(pconfig->bls_window1.h_offs,
1713                                       CIF_ISP_BLS_H1_START);
1714                         cifisp_iowrite32(pconfig->bls_window1.h_size,
1715                                       CIF_ISP_BLS_H1_STOP);
1716                         cifisp_iowrite32(pconfig->bls_window1.v_offs,
1717                                       CIF_ISP_BLS_V1_START);
1718                         cifisp_iowrite32(pconfig->bls_window1.v_size,
1719                                       CIF_ISP_BLS_V1_STOP);
1720                         new_control |= CIFISP_BLS_WINDOW_1;
1721                 }
1722
1723                 cifisp_iowrite32(pconfig->bls_samples, CIF_ISP_BLS_SAMPLES);
1724
1725                 new_control |= CIFISP_BLS_MODE_MEASURED;
1726
1727                 cifisp_iowrite32(new_control, CIF_ISP_BLS_CTRL);
1728         }
1729 }
1730
1731 /*****************************************************************************/
1732 static void cifisp_bls_en(const struct cif_isp10_isp_dev *isp_dev)
1733 {
1734         cifisp_iowrite32OR(CIFISP_BLS_ENA, CIF_ISP_BLS_CTRL);
1735 }
1736
1737 /*****************************************************************************/
1738 static void cifisp_bls_end(const struct cif_isp10_isp_dev *isp_dev)
1739 {
1740         cifisp_iowrite32(CIFISP_BLS_DIS, CIF_ISP_BLS_CTRL);
1741 }
1742
1743 /* Gamma correction */
1744 /*****************************************************************************/
1745 static void cifisp_sdg_config(const struct cif_isp10_isp_dev *isp_dev)
1746 {
1747         const struct cifisp_sdg_config *pconfig =
1748                 &isp_dev->other_cfgs.last_or_new->sdg_config;
1749         unsigned int i;
1750
1751         cifisp_iowrite32(pconfig->xa_pnts.gamma_dx0, CIF_ISP_GAMMA_DX_LO);
1752         cifisp_iowrite32(pconfig->xa_pnts.gamma_dx1, CIF_ISP_GAMMA_DX_HI);
1753
1754         for (i = 0; i < CIFISP_DEGAMMA_CURVE_SIZE; i++) {
1755                 cifisp_iowrite32(pconfig->curve_r.gamma_y[i],
1756                         CIF_ISP_GAMMA_R_Y0 + i * 4);
1757                 cifisp_iowrite32(pconfig->curve_g.gamma_y[i],
1758                         CIF_ISP_GAMMA_G_Y0 + i * 4);
1759                 cifisp_iowrite32(pconfig->curve_b.gamma_y[i],
1760                         CIF_ISP_GAMMA_B_Y0 + i * 4);
1761         }
1762 }
1763
1764 #ifdef LOG_CAPTURE_PARAMS
1765 static void cifisp_sdg_config_read(const struct cif_isp10_isp_dev *isp_dev,
1766                                    struct cifisp_sdg_config *pconfig)
1767 {
1768 }
1769 #endif
1770
1771 /*****************************************************************************/
1772 static void cifisp_sdg_en(const struct cif_isp10_isp_dev *isp_dev)
1773 {
1774         cifisp_iowrite32OR(CIF_ISP_CTRL_ISP_GAMMA_IN_ENA, CIF_ISP_CTRL);
1775 }
1776
1777 /*****************************************************************************/
1778 static void cifisp_sdg_end(const struct cif_isp10_isp_dev *isp_dev)
1779 {
1780         cifisp_iowrite32AND(~CIF_ISP_CTRL_ISP_GAMMA_IN_ENA, CIF_ISP_CTRL);
1781 }
1782
1783 /*****************************************************************************/
1784 static void cifisp_goc_config(const struct cif_isp10_isp_dev *isp_dev)
1785 {
1786         int i;
1787         const struct cifisp_goc_config *pconfig =
1788                 &isp_dev->other_cfgs.last_or_new->goc_config;
1789
1790         cifisp_iowrite32AND(~CIF_ISP_CTRL_ISP_GAMMA_OUT_ENA, CIF_ISP_CTRL);
1791
1792         cifisp_iowrite32(pconfig->mode, CIF_ISP_GAMMA_OUT_MODE);
1793         for (i = 0; i < CIFISP_GAMMA_OUT_MAX_SAMPLES; i++)
1794                 cifisp_iowrite32(pconfig->gamma_y[i],
1795                 CIF_ISP_GAMMA_OUT_Y_0 + i * 4);
1796 }
1797
1798 #ifdef LOG_CAPTURE_PARAMS
1799 static void cifisp_goc_config_read(const struct cif_isp10_isp_dev *isp_dev,
1800                                    struct cifisp_goc_config *pconfig)
1801 {
1802 }
1803 #endif
1804
1805 /*****************************************************************************/
1806 static void cifisp_goc_en(const struct cif_isp10_isp_dev *isp_dev)
1807 {
1808         cifisp_iowrite32OR(CIF_ISP_CTRL_ISP_GAMMA_OUT_ENA, CIF_ISP_CTRL);
1809 }
1810
1811 /*****************************************************************************/
1812 static void cifisp_goc_end(const struct cif_isp10_isp_dev *isp_dev)
1813 {
1814         cifisp_iowrite32AND(~CIF_ISP_CTRL_ISP_GAMMA_OUT_ENA, CIF_ISP_CTRL);
1815 }
1816
1817 /*****************************************************************************/
1818 static void cifisp_bdm_config(const struct cif_isp10_isp_dev *isp_dev)
1819 {
1820         const struct cifisp_bdm_config *pconfig =
1821                 &isp_dev->other_cfgs.last_or_new->bdm_config;
1822
1823         /*set demosaic threshold */
1824         cifisp_iowrite32(pconfig->demosaic_th, CIF_ISP_DEMOSAIC);
1825 }
1826
1827 /*****************************************************************************/
1828 static void cifisp_bdm_en(const struct cif_isp10_isp_dev *isp_dev)
1829 {
1830         cifisp_iowrite32AND(~(CIFISP_BDM_BYPASS_EN(1)), CIF_ISP_DEMOSAIC);
1831 }
1832
1833 /*****************************************************************************/
1834 static void cifisp_bdm_end(const struct cif_isp10_isp_dev *isp_dev)
1835 {
1836         cifisp_iowrite32(0, CIF_ISP_DEMOSAIC);
1837 }
1838
1839 /*****************************************************************************/
1840 static void cifisp_flt_config(const struct cif_isp10_isp_dev *isp_dev)
1841 {
1842         const struct cifisp_flt_config *pconfig =
1843                 &isp_dev->other_cfgs.last_or_new->flt_config;
1844
1845         cifisp_iowrite32(pconfig->thresh_bl0,
1846                 CIF_ISP_FILT_THRESH_BL0);
1847         cifisp_iowrite32(pconfig->thresh_bl1,
1848                 CIF_ISP_FILT_THRESH_BL1);
1849         cifisp_iowrite32(pconfig->thresh_sh0,
1850                 CIF_ISP_FILT_THRESH_SH0);
1851         cifisp_iowrite32(pconfig->thresh_sh1,
1852                 CIF_ISP_FILT_THRESH_SH1);
1853         cifisp_iowrite32(pconfig->fac_bl0,
1854                 CIF_ISP_FILT_FAC_BL0);
1855         cifisp_iowrite32(pconfig->fac_bl1,
1856                 CIF_ISP_FILT_FAC_BL1);
1857         cifisp_iowrite32(pconfig->fac_mid,
1858                 CIF_ISP_FILT_FAC_MID);
1859         cifisp_iowrite32(pconfig->fac_sh0,
1860                 CIF_ISP_FILT_FAC_SH0);
1861         cifisp_iowrite32(pconfig->fac_sh1,
1862                 CIF_ISP_FILT_FAC_SH1);
1863         cifisp_iowrite32(pconfig->lum_weight,
1864                 CIF_ISP_FILT_LUM_WEIGHT);
1865
1866         cifisp_iowrite32(CIFISP_FLT_MODE(pconfig->mode) |
1867                 CIFISP_FLT_CHROMA_V_MODE(pconfig->chr_v_mode) |
1868                 CIFISP_FLT_CHROMA_H_MODE(pconfig->chr_h_mode) |
1869                 CIFISP_FLT_GREEN_STAGE1(pconfig->grn_stage1),
1870                 CIF_ISP_FILT_MODE);
1871 }
1872
1873 #ifdef LOG_CAPTURE_PARAMS
1874 static void cifisp_flt_config_read(const struct cif_isp10_isp_dev *isp_dev,
1875                                    struct cifisp_flt_config *pconfig)
1876 {
1877 }
1878 #endif
1879
1880 /*****************************************************************************/
1881 static void cifisp_flt_en(const struct cif_isp10_isp_dev *isp_dev)
1882 {
1883         cifisp_iowrite32OR(CIFISP_FLT_ENA, CIF_ISP_FILT_MODE);
1884 }
1885
1886 /*****************************************************************************/
1887 static void cifisp_flt_end(const struct cif_isp10_isp_dev *isp_dev)
1888 {
1889         cifisp_iowrite32(CIFISP_FLT_DIS, CIF_ISP_FILT_MODE);
1890 }
1891
1892 /* Auto White Balance */
1893 /*****************************************************************************/
1894 static void cifisp_awb_gain_config(const struct cif_isp10_isp_dev *isp_dev)
1895 {
1896         const struct cifisp_awb_gain_config *pconfig =
1897             &isp_dev->other_cfgs.last_or_new->awb_gain_config;
1898
1899         cifisp_iowrite32(CIFISP_AWB_GAIN_R_SET(pconfig->gain_green_r) |
1900                       pconfig->gain_green_b, CIF_ISP_AWB_GAIN_G);
1901
1902         cifisp_iowrite32(CIFISP_AWB_GAIN_R_SET(pconfig->gain_red) |
1903                       pconfig->gain_blue, CIF_ISP_AWB_GAIN_RB);
1904 }
1905
1906 #ifdef LOG_CAPTURE_PARAMS
1907 static void cifisp_awb_gain_config_read(const struct cif_isp10_isp_dev *isp_dev,
1908                                         struct cifisp_awb_gain_config *pconfig)
1909 {
1910         unsigned int reg = cifisp_ioread32(CIF_ISP_AWB_GAIN_G);
1911
1912         pconfig->gain_green_r = CIFISP_AWB_GAIN_R_READ(reg);
1913         pconfig->gain_green_b = CIFISP_AWB_GAIN_B_READ(reg);
1914         reg = cifisp_ioread32(CIF_ISP_AWB_GAIN_RB);
1915         pconfig->gain_red = CIFISP_AWB_GAIN_R_READ(reg);
1916         pconfig->gain_blue = CIFISP_AWB_GAIN_B_READ(reg);
1917 }
1918 #endif
1919
1920 /*****************************************************************************/
1921 static void cifisp_awb_meas_config(const struct cif_isp10_isp_dev *isp_dev)
1922 {
1923         const struct cifisp_awb_meas_config *pconfig =
1924                 &isp_dev->meas_cfgs.last_or_new->awb_meas_config;
1925         unsigned int awb_prob = 0;
1926
1927         /* based on the mode,configure the awb module */
1928         if (pconfig->awb_mode == CIFISP_AWB_MODE_RGB) {
1929                 awb_prob = CIFISP_AWB_MODE_RGB_EN;
1930         } else {
1931                 if (pconfig->enable_ymax_cmp)
1932                         awb_prob = CIFISP_AWB_YMAX_CMP_EN;
1933
1934                 /* Reference Cb and Cr */
1935                 cifisp_iowrite32(CIFISP_AWB_REF_CR_SET(pconfig->awb_ref_cr) |
1936                         pconfig->awb_ref_cb, CIF_ISP_AWB_REF);
1937                 /* Yc Threshold */
1938                 cifisp_iowrite32(CIFISP_AWB_MAX_Y_SET(pconfig->max_y) |
1939                         CIFISP_AWB_MIN_Y_SET(pconfig->min_y) |
1940                         CIFISP_AWB_MAX_CS_SET(pconfig->max_csum) |
1941                         pconfig->min_c, CIF_ISP_AWB_THRESH);
1942         }
1943
1944         /* Common Configuration */
1945         cifisp_iowrite32(awb_prob, CIF_ISP_AWB_PROP);
1946         /* window offset */
1947         cifisp_iowrite32(pconfig->awb_wnd.v_offs,
1948                 CIF_ISP_AWB_WND_V_OFFS);
1949         cifisp_iowrite32(pconfig->awb_wnd.h_offs,
1950                 CIF_ISP_AWB_WND_H_OFFS);
1951         /* AWB window size */
1952         cifisp_iowrite32(pconfig->awb_wnd.v_size, CIF_ISP_AWB_WND_V_SIZE);
1953         cifisp_iowrite32(pconfig->awb_wnd.h_size, CIF_ISP_AWB_WND_H_SIZE);
1954         /* Number of frames */
1955         cifisp_iowrite32(pconfig->frames, CIF_ISP_AWB_FRAMES);
1956 }
1957
1958 #ifdef LOG_CAPTURE_PARAMS
1959 static void cifisp_awb_meas_config_read(const struct cif_isp10_isp_dev *isp_dev,
1960                                         struct cifisp_awb_meas_config *pconfig)
1961 {
1962 }
1963 #endif
1964
1965 /*****************************************************************************/
1966 static void cifisp_awb_meas_en(struct cif_isp10_isp_dev *isp_dev)
1967 {
1968         const struct cifisp_awb_meas_config *pconfig =
1969                 &isp_dev->meas_cfgs.last_or_new->awb_meas_config;
1970         u32 reg_val = cifisp_ioread32(CIF_ISP_AWB_PROP);
1971
1972         /* switch off */
1973         reg_val &= 0xFFFFFFFC;
1974
1975         if (pconfig->awb_mode == CIFISP_AWB_MODE_RGB)
1976                 reg_val |= CIFISP_AWB_MODE_RGB_EN;
1977         else
1978                 reg_val |= CIFISP_AWB_MODE_YCBCR_EN;
1979
1980         cifisp_iowrite32(reg_val, CIF_ISP_AWB_PROP);
1981
1982         isp_dev->active_meas |= CIF_ISP_AWB_DONE;
1983
1984         /* Measurements require AWB block be active. */
1985         cifisp_iowrite32OR(CIF_ISP_CTRL_ISP_AWB_ENA, CIF_ISP_CTRL);
1986 }
1987
1988 /*****************************************************************************/
1989 static void cifisp_awb_meas_end(struct cif_isp10_isp_dev *isp_dev)
1990 {
1991         u32 reg_val = cifisp_ioread32(CIF_ISP_AWB_PROP);
1992
1993         /* switch off */
1994         reg_val &= 0xFFFFFFFC;
1995
1996         cifisp_iowrite32(reg_val, CIF_ISP_AWB_PROP);
1997
1998         isp_dev->active_meas &= ~CIF_ISP_AWB_DONE;
1999
2000         if (!CIFISP_MODULE_IS_EN(
2001                 isp_dev->meas_cfgs.last_or_new->module_ens,
2002                 CIFISP_MODULE_AWB))
2003                 cifisp_iowrite32AND(~CIF_ISP_CTRL_ISP_AWB_ENA,
2004                 CIF_ISP_CTRL);
2005 }
2006
2007 /*****************************************************************************/
2008 static void cifisp_awb_gain_en(const struct cif_isp10_isp_dev *isp_dev)
2009 {
2010         cifisp_iowrite32OR(CIF_ISP_CTRL_ISP_AWB_ENA, CIF_ISP_CTRL);
2011 }
2012
2013 /*****************************************************************************/
2014 static void cifisp_awb_gain_end(const struct cif_isp10_isp_dev *isp_dev)
2015 {
2016         if (!CIFISP_MODULE_IS_EN(
2017                 isp_dev->meas_cfgs.last_or_new->module_ens,
2018                 CIFISP_MODULE_AWB))
2019                 cifisp_iowrite32AND(~CIF_ISP_CTRL_ISP_AWB_ENA,
2020                 CIF_ISP_CTRL);
2021 }
2022
2023 /*****************************************************************************/
2024 static void cifisp_get_awb_meas(struct cif_isp10_isp_dev *isp_dev,
2025         struct cifisp_stat_buffer *pbuf)
2026 {
2027         /* Protect against concurrent access from ISR? */
2028         u32 reg_val;
2029         const struct cifisp_awb_meas_config *pconfig =
2030                 &isp_dev->meas_cfgs.curr->awb_meas_config;
2031
2032         pbuf->meas_type |= CIFISP_STAT_AWB;
2033         reg_val = cifisp_ioread32(CIF_ISP_AWB_WHITE_CNT);
2034         pbuf->params.awb.awb_mean[0].cnt =
2035                 CIFISP_AWB_GET_PIXEL_CNT(reg_val);
2036         reg_val = cifisp_ioread32(CIF_ISP_AWB_MEAN);
2037
2038         if (pconfig->awb_mode == CIFISP_AWB_MODE_RGB) {
2039                 pbuf->params.awb.awb_mean[0].mean_r =
2040                         CIFISP_AWB_GET_MEAN_R(reg_val);
2041                 pbuf->params.awb.awb_mean[0].mean_b =
2042                         CIFISP_AWB_GET_MEAN_B(reg_val);
2043                 pbuf->params.awb.awb_mean[0].mean_g =
2044                         CIFISP_AWB_GET_MEAN_G(reg_val);
2045         } else {
2046                 pbuf->params.awb.awb_mean[0].mean_cr =
2047                         (u8)CIFISP_AWB_GET_MEAN_CR(reg_val);
2048                 pbuf->params.awb.awb_mean[0].mean_cb =
2049                         (u8)CIFISP_AWB_GET_MEAN_CB(reg_val);
2050                 pbuf->params.awb.awb_mean[0].mean_y =
2051                         (u8)CIFISP_AWB_GET_MEAN_Y(reg_val);
2052         }
2053 }
2054
2055 /* Auto Exposure */
2056 /*****************************************************************************/
2057 static void cifisp_aec_config(const struct cif_isp10_isp_dev *isp_dev)
2058 {
2059         const struct cifisp_aec_config *pconfig =
2060                 &isp_dev->meas_cfgs.last_or_new->aec_config;
2061         unsigned int block_hsize, block_vsize;
2062
2063         cifisp_iowrite32(CIFISP_EXP_CTRL_AUTOSTOP(pconfig->autostop) |
2064                         CIFISP_EXP_CTRL_MEASMODE(pconfig->mode),
2065                         CIF_ISP_EXP_CTRL);
2066
2067         cifisp_iowrite32(pconfig->meas_window.h_offs, CIF_ISP_EXP_H_OFFSET);
2068         cifisp_iowrite32(pconfig->meas_window.v_offs, CIF_ISP_EXP_V_OFFSET);
2069
2070         block_hsize = pconfig->meas_window.h_size /
2071                 CIFISP_EXP_COLUMN_NUM - 1;
2072         block_vsize = pconfig->meas_window.v_size /
2073                 CIFISP_EXP_ROW_NUM - 1;
2074
2075         cifisp_iowrite32(CIFISP_EXP_HSIZE(block_hsize), CIF_ISP_EXP_H_SIZE);
2076         cifisp_iowrite32(CIFISP_EXP_VSIZE(block_vsize), CIF_ISP_EXP_V_SIZE);
2077 }
2078
2079 /*****************************************************************************/
2080 static void cifisp_aec_en(struct cif_isp10_isp_dev *isp_dev)
2081 {
2082         isp_dev->active_meas |= CIF_ISP_EXP_END;
2083
2084         cifisp_iowrite32OR(CIFISP_EXP_ENA, CIF_ISP_EXP_CTRL);
2085 }
2086
2087 /*****************************************************************************/
2088 static void cifisp_aec_end(struct cif_isp10_isp_dev *isp_dev)
2089 {
2090         cifisp_iowrite32(CIFISP_EXP_DIS, CIF_ISP_EXP_CTRL);
2091
2092         isp_dev->active_meas &= ~CIF_ISP_EXP_END;
2093 }
2094
2095 /*****************************************************************************/
2096 static void cifisp_get_aec_meas(struct cif_isp10_isp_dev *isp_dev,
2097                                 struct cifisp_stat_buffer *pbuf)
2098 {
2099         unsigned int i;
2100
2101         pbuf->meas_type |= CIFISP_STAT_AUTOEXP; /*Set the measurement type */
2102         for (i = 0; i < CIFISP_AE_MEAN_MAX; i++) {
2103                 pbuf->params.ae.exp_mean[i] =
2104                         (u8)cifisp_ioread32(CIF_ISP_EXP_MEAN_00 + i * 4);
2105         }
2106 }
2107
2108 /* X-Talk Matrix */
2109 /*****************************************************************************/
2110 static void cifisp_ctk_config(const struct cif_isp10_isp_dev *isp_dev)
2111 {
2112         /* Nothing to do */
2113 }
2114
2115 #ifdef LOG_CAPTURE_PARAMS
2116 static void cifisp_ctk_config_read(const struct cif_isp10_isp_dev *isp_dev,
2117                                    struct cifisp_ctk_config *pconfig)
2118 {
2119         pconfig->coeff0 = cifisp_ioread32(CIF_ISP_CT_COEFF_0);
2120         pconfig->coeff1 = cifisp_ioread32(CIF_ISP_CT_COEFF_1);
2121         pconfig->coeff2 = cifisp_ioread32(CIF_ISP_CT_COEFF_2);
2122         pconfig->coeff3 = cifisp_ioread32(CIF_ISP_CT_COEFF_3);
2123         pconfig->coeff4 = cifisp_ioread32(CIF_ISP_CT_COEFF_4);
2124         pconfig->coeff5 = cifisp_ioread32(CIF_ISP_CT_COEFF_5);
2125         pconfig->coeff6 = cifisp_ioread32(CIF_ISP_CT_COEFF_6);
2126         pconfig->coeff7 = cifisp_ioread32(CIF_ISP_CT_COEFF_7);
2127         pconfig->coeff8 = cifisp_ioread32(CIF_ISP_CT_COEFF_8);
2128         pconfig->ct_offset_r = cifisp_ioread32(CIF_ISP_CT_OFFSET_R);
2129         pconfig->ct_offset_g = cifisp_ioread32(CIF_ISP_CT_OFFSET_G);
2130         pconfig->ct_offset_b = cifisp_ioread32(CIF_ISP_CT_OFFSET_B);
2131 }
2132 #endif
2133
2134 /*****************************************************************************/
2135 static void cifisp_ctk_en(const struct cif_isp10_isp_dev *isp_dev)
2136 {
2137         const struct cifisp_ctk_config *pconfig =
2138                 &isp_dev->other_cfgs.last_or_new->ctk_config;
2139
2140         cifisp_iowrite32(pconfig->coeff0, CIF_ISP_CT_COEFF_0);
2141         cifisp_iowrite32(pconfig->coeff1, CIF_ISP_CT_COEFF_1);
2142         cifisp_iowrite32(pconfig->coeff2, CIF_ISP_CT_COEFF_2);
2143         cifisp_iowrite32(pconfig->coeff3, CIF_ISP_CT_COEFF_3);
2144         cifisp_iowrite32(pconfig->coeff4, CIF_ISP_CT_COEFF_4);
2145         cifisp_iowrite32(pconfig->coeff5, CIF_ISP_CT_COEFF_5);
2146         cifisp_iowrite32(pconfig->coeff6, CIF_ISP_CT_COEFF_6);
2147         cifisp_iowrite32(pconfig->coeff7, CIF_ISP_CT_COEFF_7);
2148         cifisp_iowrite32(pconfig->coeff8, CIF_ISP_CT_COEFF_8);
2149         cifisp_iowrite32(pconfig->ct_offset_r, CIF_ISP_CT_OFFSET_R);
2150         cifisp_iowrite32(pconfig->ct_offset_g, CIF_ISP_CT_OFFSET_G);
2151         cifisp_iowrite32(pconfig->ct_offset_b, CIF_ISP_CT_OFFSET_B);
2152 }
2153
2154 /*****************************************************************************/
2155 static void cifisp_ctk_end(const struct cif_isp10_isp_dev *isp_dev)
2156 {
2157         /* Write back the default values. */
2158         cifisp_iowrite32(0x80, CIF_ISP_CT_COEFF_0);
2159         cifisp_iowrite32(0, CIF_ISP_CT_COEFF_1);
2160         cifisp_iowrite32(0, CIF_ISP_CT_COEFF_2);
2161         cifisp_iowrite32(0, CIF_ISP_CT_COEFF_3);
2162         cifisp_iowrite32(0x80, CIF_ISP_CT_COEFF_4);
2163         cifisp_iowrite32(0, CIF_ISP_CT_COEFF_5);
2164         cifisp_iowrite32(0, CIF_ISP_CT_COEFF_6);
2165         cifisp_iowrite32(0, CIF_ISP_CT_COEFF_7);
2166         cifisp_iowrite32(0x80, CIF_ISP_CT_COEFF_8);
2167
2168         cifisp_iowrite32(0, CIF_ISP_CT_OFFSET_R);
2169         cifisp_iowrite32(0, CIF_ISP_CT_OFFSET_G);
2170         cifisp_iowrite32(0, CIF_ISP_CT_OFFSET_B);
2171 }
2172
2173 /* CPROC */
2174 /*****************************************************************************/
2175 static void cifisp_cproc_config(const struct cif_isp10_isp_dev *isp_dev,
2176         enum cif_isp10_pix_fmt_quantization quantization)
2177 {
2178         const struct cifisp_cproc_config *pconfig =
2179                 &isp_dev->other_cfgs.last_or_new->cproc_config;
2180         const struct cifisp_ie_config *ie_pconfig =
2181                 &isp_dev->other_cfgs.last_or_new->ie_config;
2182
2183         cifisp_iowrite32(pconfig->contrast, CIF_C_PROC_CONTRAST);
2184         cifisp_iowrite32(pconfig->hue, CIF_C_PROC_HUE);
2185         cifisp_iowrite32(pconfig->sat, CIF_C_PROC_SATURATION);
2186         cifisp_iowrite32(pconfig->brightness, CIF_C_PROC_BRIGHTNESS);
2187
2188         if ((quantization != CIF_ISP10_QUANTIZATION_FULL_RANGE) ||
2189                  (ie_pconfig->effect != V4L2_COLORFX_NONE)) {
2190                 cifisp_iowrite32(
2191                         ~(CIF_C_PROC_YOUT_FULL |
2192                         CIF_C_PROC_YIN_FULL |
2193                         CIF_C_PROC_COUT_FULL),
2194                         CIF_C_PROC_CTRL);
2195         } else {
2196                 cifisp_iowrite32OR(
2197                         (CIF_C_PROC_YOUT_FULL |
2198                         CIF_C_PROC_YIN_FULL |
2199                         CIF_C_PROC_COUT_FULL),
2200                         CIF_C_PROC_CTRL);
2201         }
2202 }
2203
2204 #ifdef LOG_CAPTURE_PARAMS
2205 static void cifisp_cproc_config_read(const struct cif_isp10_isp_dev *isp_dev,
2206                                      struct cifisp_cproc_config *pconfig)
2207 {
2208         unsigned int reg;
2209
2210         pconfig->contrast = cifisp_ioread32(CIF_C_PROC_CONTRAST);
2211         pconfig->hue = cifisp_ioread32(CIF_C_PROC_HUE);
2212         pconfig->sat = cifisp_ioread32(CIF_C_PROC_SATURATION);
2213         pconfig->brightness = cifisp_ioread32(CIF_C_PROC_BRIGHTNESS);
2214         reg = cifisp_ioread32(CIF_C_PROC_CTRL);
2215         pconfig->y_out_range = (reg >> 1) & 1;
2216         pconfig->y_in_range = (reg >> 2) & 1;
2217         pconfig->c_out_range = (reg >> 3) & 1;
2218 }
2219 #endif
2220
2221 /*****************************************************************************/
2222 static void cifisp_cproc_en(const struct cif_isp10_isp_dev *isp_dev)
2223 {
2224         cifisp_iowrite32OR(CIFISP_CPROC_EN, CIF_C_PROC_CTRL);
2225 }
2226
2227 /*****************************************************************************/
2228 static void cifisp_cproc_end(const struct cif_isp10_isp_dev *isp_dev)
2229 {
2230         cifisp_iowrite32AND(~CIFISP_CPROC_EN, CIF_C_PROC_CTRL);
2231 }
2232
2233 static void cifisp_afc_config(const struct cif_isp10_isp_dev *isp_dev)
2234 {
2235         const struct cifisp_afc_config *pconfig =
2236                 &isp_dev->meas_cfgs.last_or_new->afc_config;
2237         int num_of_win = pconfig->num_afm_win, i;
2238
2239         /* Switch off to configure. Enabled during normal flow in frame isr. */
2240         cifisp_iowrite32(0, CIF_ISP_AFM_CTRL);
2241
2242         for (i = 0; i < num_of_win; i++) {
2243                 cifisp_iowrite32(
2244                         CIFISP_AFC_WINDOW_X(pconfig->afm_win[0].h_offs) |
2245                         CIFISP_AFC_WINDOW_Y(pconfig->afm_win[0].v_offs),
2246                         CIF_ISP_AFM_LT_A + i * 8);
2247                 cifisp_iowrite32(
2248                         CIFISP_AFC_WINDOW_X(pconfig->afm_win[0].h_size +
2249                         pconfig->afm_win[0].h_offs) |
2250                         CIFISP_AFC_WINDOW_Y(pconfig->afm_win[0].v_size +
2251                         pconfig->afm_win[0].v_offs),
2252                         CIF_ISP_AFM_RB_A + i * 8);
2253         }
2254
2255         cifisp_iowrite32(pconfig->thres, CIF_ISP_AFM_THRES);
2256         cifisp_iowrite32(pconfig->var_shift, CIF_ISP_AFM_VAR_SHIFT);
2257 }
2258
2259 /*****************************************************************************/
2260 static void cifisp_afc_en(struct cif_isp10_isp_dev *isp_dev)
2261 {
2262         isp_dev->active_meas |= CIF_ISP_AFM_FIN;
2263
2264         cifisp_iowrite32(CIFISP_AFC_ENA, CIF_ISP_AFM_CTRL);
2265 }
2266
2267 /*****************************************************************************/
2268 static void cifisp_afc_end(struct cif_isp10_isp_dev *isp_dev)
2269 {
2270         cifisp_iowrite32(CIFISP_AFC_DIS, CIF_ISP_AFM_CTRL);
2271         isp_dev->active_meas &= ~CIF_ISP_AFM_FIN;
2272 }
2273
2274 /*****************************************************************************/
2275 static void cifisp_get_afc_meas(struct cif_isp10_isp_dev *isp_dev,
2276                                 struct cifisp_stat_buffer *pbuf)
2277 {
2278         pbuf->meas_type = CIFISP_STAT_AFM_FIN;
2279
2280         pbuf->params.af.window[0].sum =
2281                 cifisp_ioread32(CIF_ISP_AFM_SUM_A);
2282         pbuf->params.af.window[0].lum =
2283                 cifisp_ioread32(CIF_ISP_AFM_LUM_A);
2284         pbuf->params.af.window[1].sum =
2285                 cifisp_ioread32(CIF_ISP_AFM_SUM_B);
2286         pbuf->params.af.window[1].lum =
2287                 cifisp_ioread32(CIF_ISP_AFM_LUM_B);
2288         pbuf->params.af.window[2].sum =
2289                 cifisp_ioread32(CIF_ISP_AFM_SUM_C);
2290         pbuf->params.af.window[2].lum =
2291                 cifisp_ioread32(CIF_ISP_AFM_LUM_C);
2292 }
2293
2294 /* HISTOGRAM CALCULATION */
2295 /*****************************************************************************/
2296 static void cifisp_hst_config(const struct cif_isp10_isp_dev *isp_dev)
2297 {
2298         const struct cifisp_hst_config *pconfig =
2299                 &isp_dev->meas_cfgs.last_or_new->hst_config;
2300         unsigned int block_hsize, block_vsize;
2301
2302         cifisp_iowrite32(CIFISP_HIST_PREDIV_SET(pconfig->histogram_predivider),
2303                       CIF_ISP_HIST_PROP);
2304         cifisp_iowrite32(pconfig->meas_window.h_offs, CIF_ISP_HIST_H_OFFS);
2305         cifisp_iowrite32(pconfig->meas_window.v_offs, CIF_ISP_HIST_V_OFFS);
2306
2307         block_hsize = pconfig->meas_window.h_size /
2308                 CIFISP_HIST_COLUMN_NUM - 1;
2309         block_vsize = pconfig->meas_window.v_size /
2310                 CIFISP_HIST_ROW_NUM - 1;
2311
2312         cifisp_iowrite32(block_hsize, CIF_ISP_HIST_H_SIZE);
2313         cifisp_iowrite32(block_vsize, CIF_ISP_HIST_V_SIZE);
2314
2315         cifisp_iowrite32(CIFISP_HIST_WEIGHT_SET(pconfig->hist_weight[0],
2316                 pconfig->hist_weight[1], pconfig->hist_weight[2],
2317                 pconfig->hist_weight[3]), CIF_ISP_HIST_WEIGHT_00TO30);
2318         cifisp_iowrite32(CIFISP_HIST_WEIGHT_SET(pconfig->hist_weight[4],
2319                 pconfig->hist_weight[5], pconfig->hist_weight[6],
2320                 pconfig->hist_weight[7]), CIF_ISP_HIST_WEIGHT_40TO21);
2321         cifisp_iowrite32(CIFISP_HIST_WEIGHT_SET(pconfig->hist_weight[8],
2322                 pconfig->hist_weight[9], pconfig->hist_weight[10],
2323                 pconfig->hist_weight[11]), CIF_ISP_HIST_WEIGHT_31TO12);
2324         cifisp_iowrite32(CIFISP_HIST_WEIGHT_SET(pconfig->hist_weight[12],
2325                 pconfig->hist_weight[13], pconfig->hist_weight[14],
2326                 pconfig->hist_weight[15]), CIF_ISP_HIST_WEIGHT_22TO03);
2327         cifisp_iowrite32(CIFISP_HIST_WEIGHT_SET(pconfig->hist_weight[16],
2328                 pconfig->hist_weight[17], pconfig->hist_weight[18],
2329                 pconfig->hist_weight[19]), CIF_ISP_HIST_WEIGHT_13TO43);
2330         cifisp_iowrite32(CIFISP_HIST_WEIGHT_SET(pconfig->hist_weight[20],
2331                 pconfig->hist_weight[21], pconfig->hist_weight[22],
2332                 pconfig->hist_weight[23]), CIF_ISP_HIST_WEIGHT_04TO34);
2333         cifisp_iowrite32(CIFISP_HIST_WEIGHT_SET(pconfig->hist_weight[24],
2334                 0, 0, 0), CIF_ISP_HIST_WEIGHT_44);
2335 }
2336
2337 static void cifisp_hst_en(struct cif_isp10_isp_dev *isp_dev)
2338 {
2339         const struct cifisp_hst_config *pconfig =
2340                 &isp_dev->meas_cfgs.last_or_new->hst_config;
2341
2342         isp_dev->active_meas |= CIF_ISP_HIST_MEASURE_RDY;
2343
2344         cifisp_iowrite32OR(pconfig->mode,
2345                 CIF_ISP_HIST_PROP);
2346 }
2347
2348 /*****************************************************************************/
2349 static void cifisp_hst_end(struct cif_isp10_isp_dev *isp_dev)
2350 {
2351         /* Disable measurement */
2352         cifisp_iowrite32(CIFISP_HISTOGRAM_MODE_DISABLE,
2353                 CIF_ISP_HIST_PROP);
2354
2355         isp_dev->active_meas &= ~CIF_ISP_HIST_MEASURE_RDY;
2356 }
2357
2358 /*****************************************************************************/
2359 static void cifisp_get_hst_meas(const struct cif_isp10_isp_dev *isp_dev,
2360                                 struct cifisp_stat_buffer *pbuf)
2361 {
2362         int i;
2363
2364         pbuf->meas_type |= CIFISP_STAT_HIST;
2365         for (i = 0; i < CIFISP_HIST_BIN_N_MAX; i++) {
2366                 pbuf->params.hist.hist_bins[i] =
2367                     cifisp_ioread32(CIF_ISP_HIST_BIN_0 + (i * 4));
2368         }
2369 }
2370
2371 /* IMAGE EFFECT */
2372 /*****************************************************************************/
2373 static void cifisp_ie_config(const struct cif_isp10_isp_dev *isp_dev)
2374 {
2375         const struct cifisp_ie_config *pconfig =
2376                 &isp_dev->other_cfgs.last_or_new->ie_config;
2377
2378         switch (pconfig->effect) {
2379         case V4L2_COLORFX_SET_CBCR:
2380                 cifisp_iowrite32(pconfig->eff_tint, CIF_IMG_EFF_TINT);
2381                 break;
2382         /*
2383          * Color selection is similar to water color(AQUA):
2384          * grayscale + selected color w threshold
2385          */
2386         case V4L2_COLORFX_AQUA:
2387                 cifisp_iowrite32(pconfig->color_sel, CIF_IMG_EFF_COLOR_SEL);
2388                 break;
2389         case V4L2_COLORFX_EMBOSS:
2390                 cifisp_iowrite32(pconfig->eff_mat_1, CIF_IMG_EFF_MAT_1);
2391                 cifisp_iowrite32(pconfig->eff_mat_2, CIF_IMG_EFF_MAT_2);
2392                 cifisp_iowrite32(pconfig->eff_mat_3, CIF_IMG_EFF_MAT_3);
2393                 break;
2394         case V4L2_COLORFX_SKETCH:
2395                 cifisp_iowrite32(pconfig->eff_mat_3, CIF_IMG_EFF_MAT_3);
2396                 cifisp_iowrite32(pconfig->eff_mat_4, CIF_IMG_EFF_MAT_4);
2397                 cifisp_iowrite32(pconfig->eff_mat_5, CIF_IMG_EFF_MAT_5);
2398                 break;
2399         default:
2400                 break;
2401         }
2402 }
2403
2404 static void cifisp_ie_en(const struct cif_isp10_isp_dev *isp_dev)
2405 {
2406         const struct cifisp_ie_config *pconfig =
2407                 &isp_dev->other_cfgs.last_or_new->ie_config;
2408         enum cif_isp10_image_effect effect;
2409
2410         switch (pconfig->effect) {
2411         case V4L2_COLORFX_SEPIA:
2412         case V4L2_COLORFX_SET_CBCR:
2413                 effect = CIF_ISP10_IE_SEPIA;
2414                 break;
2415         case V4L2_COLORFX_BW:
2416                 effect = CIF_ISP10_IE_BW;
2417                 break;
2418         case V4L2_COLORFX_NEGATIVE:
2419                 effect = CIF_ISP10_IE_NEGATIVE;
2420                 break;
2421         case V4L2_COLORFX_EMBOSS:
2422                 effect = CIF_ISP10_IE_EMBOSS;
2423                 break;
2424         case V4L2_COLORFX_SKETCH:
2425                 effect = CIF_ISP10_IE_SKETCH;
2426                 break;
2427         case V4L2_COLORFX_AQUA:
2428                 effect = CIF_ISP10_IE_C_SEL;
2429                 break;
2430         case V4L2_COLORFX_NONE:
2431         default:
2432                 effect = CIF_ISP10_IE_NONE;
2433                 break;
2434         }
2435
2436         if (effect < CIF_ISP10_IE_NONE) {
2437                 cifisp_iowrite32OR(CIF_ICCL_IE_CLK, CIF_ICCL);
2438                 cifisp_iowrite32(CIF_IMG_EFF_CTRL_ENABLE |
2439                         effect << 1, CIF_IMG_EFF_CTRL);
2440                 cifisp_iowrite32OR(CIF_IMG_EFF_CTRL_CFG_UPD, CIF_IMG_EFF_CTRL);
2441         } else if (effect == CIF_ISP10_IE_NONE) {
2442                 cifisp_iowrite32AND(~CIF_IMG_EFF_CTRL_ENABLE, CIF_IMG_EFF_CTRL);
2443                 cifisp_iowrite32AND(~CIF_ICCL_IE_CLK, CIF_ICCL);
2444         }
2445 }
2446
2447 static void cifisp_ie_end(const struct cif_isp10_isp_dev *isp_dev)
2448 {
2449         /* Disable measurement */
2450         cifisp_iowrite32AND(~CIF_IMG_EFF_CTRL_ENABLE, CIF_IMG_EFF_CTRL);
2451         cifisp_iowrite32AND(~CIF_ICCL_IE_CLK, CIF_ICCL);
2452 }
2453
2454 static void cifisp_csm_config(const struct cif_isp10_isp_dev *isp_dev,
2455         enum cif_isp10_pix_fmt_quantization quantization)
2456 {
2457         const struct cifisp_ie_config *pconfig =
2458                 &isp_dev->other_cfgs.last_or_new->ie_config;
2459
2460         if ((quantization != CIF_ISP10_QUANTIZATION_FULL_RANGE) ||
2461                 ((pconfig->effect != V4L2_COLORFX_NONE) &&
2462                 CIFISP_MODULE_IS_EN(
2463                 isp_dev->other_cfgs.last_or_new->module_ens,
2464                 CIFISP_MODULE_CPROC))) {
2465                 /* Limit range conversion */
2466                 cifisp_iowrite32(0x21, CIF_ISP_CC_COEFF_0);
2467                 cifisp_iowrite32(0x40, CIF_ISP_CC_COEFF_1);
2468                 cifisp_iowrite32(0xd, CIF_ISP_CC_COEFF_2);
2469                 cifisp_iowrite32(0x1ed, CIF_ISP_CC_COEFF_3);
2470                 cifisp_iowrite32(0x1db, CIF_ISP_CC_COEFF_4);
2471                 cifisp_iowrite32(0x38, CIF_ISP_CC_COEFF_5);
2472                 cifisp_iowrite32(0x38, CIF_ISP_CC_COEFF_6);
2473                 cifisp_iowrite32(0x1d1, CIF_ISP_CC_COEFF_7);
2474                 cifisp_iowrite32(0x1f7, CIF_ISP_CC_COEFF_8);
2475                 cifisp_iowrite32AND(~CIF_ISP_CTRL_ISP_CSM_Y_FULL_ENA,
2476                         CIF_ISP_CTRL);
2477                 cifisp_iowrite32AND(~CIF_ISP_CTRL_ISP_CSM_C_FULL_ENA,
2478                         CIF_ISP_CTRL);
2479         } else {
2480                 cifisp_iowrite32(0x26, CIF_ISP_CC_COEFF_0);
2481                 cifisp_iowrite32(0x4b, CIF_ISP_CC_COEFF_1);
2482                 cifisp_iowrite32(0xf, CIF_ISP_CC_COEFF_2);
2483                 cifisp_iowrite32(0x1ea, CIF_ISP_CC_COEFF_3);
2484                 cifisp_iowrite32(0x1d6, CIF_ISP_CC_COEFF_4);
2485                 cifisp_iowrite32(0x40, CIF_ISP_CC_COEFF_5);
2486                 cifisp_iowrite32(0x40, CIF_ISP_CC_COEFF_6);
2487                 cifisp_iowrite32(0x1ca, CIF_ISP_CC_COEFF_7);
2488                 cifisp_iowrite32(0x1f6, CIF_ISP_CC_COEFF_8);
2489                 cifisp_iowrite32OR(CIF_ISP_CTRL_ISP_CSM_Y_FULL_ENA,
2490                         CIF_ISP_CTRL);
2491                 cifisp_iowrite32OR(CIF_ISP_CTRL_ISP_CSM_C_FULL_ENA,
2492                         CIF_ISP_CTRL);
2493         }
2494 }
2495
2496 /* DPF */
2497 /*****************************************************************************/
2498 static void cifisp_dpf_config(const struct cif_isp10_isp_dev *isp_dev)
2499 {
2500         const struct cifisp_dpf_config *pconfig =
2501                 &isp_dev->other_cfgs.last_or_new->dpf_config;
2502         unsigned int isp_dpf_mode;
2503         unsigned int i;
2504         unsigned int spatial_coeff;
2505
2506         isp_dpf_mode = 0x00;
2507
2508         switch (pconfig->gain.mode) {
2509         case CIFISP_DPF_GAIN_USAGE_DISABLED:
2510                 break;
2511         case CIFISP_DPF_GAIN_USAGE_NF_GAINS:
2512                 isp_dpf_mode |= CIFISP_DPF_MODE_USE_NF_GAIN |
2513                         CIFISP_DPF_MODE_AWB_GAIN_COMP;
2514                 break;
2515         case CIFISP_DPF_GAIN_USAGE_LSC_GAINS:
2516                 isp_dpf_mode |= CIFISP_DPF_MODE_LSC_GAIN_COMP;
2517                 break;
2518         case CIFISP_DPF_GAIN_USAGE_NF_LSC_GAINS:
2519                 isp_dpf_mode |= CIFISP_DPF_MODE_USE_NF_GAIN |
2520                         CIFISP_DPF_MODE_AWB_GAIN_COMP |
2521                         CIFISP_DPF_MODE_LSC_GAIN_COMP;
2522                 break;
2523         case CIFISP_DPF_GAIN_USAGE_AWB_GAINS:
2524                 isp_dpf_mode |= CIFISP_DPF_MODE_AWB_GAIN_COMP;
2525                 break;
2526         case CIFISP_DPF_GAIN_USAGE_AWB_LSC_GAINS:
2527                 isp_dpf_mode |= CIFISP_DPF_MODE_LSC_GAIN_COMP |
2528                         CIFISP_DPF_MODE_AWB_GAIN_COMP;
2529                 break;
2530         default:
2531                 break;
2532         }
2533
2534         isp_dpf_mode |=
2535         CIFISP_DPF_MODE_NLL_SEGMENTATION(pconfig->nll.scale_mode);
2536         isp_dpf_mode |=
2537         CIFISP_DPF_MODE_RB_FLTSIZE(pconfig->rb_flt.fltsize);
2538
2539         isp_dpf_mode |= (pconfig->rb_flt.r_enable) ?
2540                 CIFISP_DPF_MODE_R_FLT_EN : CIFISP_DPF_MODE_R_FLT_DIS;
2541         isp_dpf_mode |= (pconfig->rb_flt.b_enable) ?
2542                 CIFISP_DPF_MODE_B_FLT_EN : CIFISP_DPF_MODE_B_FLT_DIS;
2543         isp_dpf_mode |= (pconfig->g_flt.gb_enable) ?
2544                 CIFISP_DPF_MODE_GB_FLT_EN : CIFISP_DPF_MODE_GB_FLT_DIS;
2545         isp_dpf_mode |= (pconfig->g_flt.gr_enable) ?
2546                 CIFISP_DPF_MODE_GR_FLT_EN : CIFISP_DPF_MODE_GR_FLT_DIS;
2547
2548         cifisp_iowrite32(isp_dpf_mode, CIF_ISP_DPF_MODE);
2549         cifisp_iowrite32(pconfig->gain.nf_b_gain, CIF_ISP_DPF_NF_GAIN_B);
2550         cifisp_iowrite32(pconfig->gain.nf_r_gain, CIF_ISP_DPF_NF_GAIN_R);
2551         cifisp_iowrite32(pconfig->gain.nf_gb_gain, CIF_ISP_DPF_NF_GAIN_GB);
2552         cifisp_iowrite32(pconfig->gain.nf_gr_gain, CIF_ISP_DPF_NF_GAIN_GR);
2553
2554         for (i = 0; i < CIFISP_DPF_MAX_NLF_COEFFS; i++) {
2555                 cifisp_iowrite32(pconfig->nll.coeff[i],
2556                         CIF_ISP_DPF_NULL_COEFF_0 + i * 4);
2557         }
2558
2559         spatial_coeff = pconfig->g_flt.spatial_coeff[0] |
2560                 ((unsigned int)pconfig->g_flt.spatial_coeff[1] << 8) |
2561                 ((unsigned int)pconfig->g_flt.spatial_coeff[2] << 16) |
2562                 ((unsigned int)pconfig->g_flt.spatial_coeff[3] << 24);
2563         cifisp_iowrite32(spatial_coeff, CIF_ISP_DPF_S_WEIGHT_G_1_4);
2564         spatial_coeff = pconfig->g_flt.spatial_coeff[4] |
2565                 ((unsigned int)pconfig->g_flt.spatial_coeff[5] << 8);
2566         cifisp_iowrite32(spatial_coeff, CIF_ISP_DPF_S_WEIGHT_G_5_6);
2567         spatial_coeff = pconfig->rb_flt.spatial_coeff[0] |
2568                 ((unsigned int)pconfig->rb_flt.spatial_coeff[1] << 8) |
2569                 ((unsigned int)pconfig->rb_flt.spatial_coeff[2] << 16) |
2570                 ((unsigned int)pconfig->rb_flt.spatial_coeff[3] << 24);
2571         cifisp_iowrite32(spatial_coeff, CIF_ISP_DPF_S_WEIGHT_RB_1_4);
2572         spatial_coeff = pconfig->rb_flt.spatial_coeff[4] |
2573                 ((unsigned int)pconfig->rb_flt.spatial_coeff[5] << 8);
2574         cifisp_iowrite32(spatial_coeff, CIF_ISP_DPF_S_WEIGHT_RB_5_6);
2575 }
2576
2577 static void cifisp_dpf_strength_config(const struct cif_isp10_isp_dev *isp_dev)
2578 {
2579         const struct cifisp_dpf_strength_config *pconfig =
2580                 &isp_dev->other_cfgs.last_or_new->dpf_strength_config;
2581
2582         cifisp_iowrite32(pconfig->b, CIF_ISP_DPF_STRENGTH_B);
2583         cifisp_iowrite32(pconfig->g, CIF_ISP_DPF_STRENGTH_G);
2584         cifisp_iowrite32(pconfig->r, CIF_ISP_DPF_STRENGTH_R);
2585 }
2586
2587 static void cifisp_dpf_en(struct cif_isp10_isp_dev *isp_dev)
2588 {
2589         cifisp_iowrite32OR(CIFISP_DPF_MODE_EN,
2590                 CIF_ISP_DPF_MODE);
2591 }
2592
2593 static void cifisp_dpf_end(struct cif_isp10_isp_dev *isp_dev)
2594 {
2595         cifisp_iowrite32AND(~CIFISP_DPF_MODE_EN,
2596                 CIF_ISP_DPF_MODE);
2597 }
2598
2599 /* ================================QUEUE OPS ================== */
2600 static int cifisp_stat_vbq_setup(struct videobuf_queue *vq,
2601                                  unsigned int *cnt, unsigned int *size)
2602 {
2603         *size = sizeof(struct cifisp_stat_buffer);
2604
2605         return 0;
2606 }
2607
2608 static void cifisp_stat_vbq_release(struct videobuf_queue *vq,
2609                                     struct videobuf_buffer *vb)
2610 {
2611         CIFISP_DPRINT(CIFISP_DEBUG, "Releasing buffer entry!\n");
2612
2613         videobuf_waiton(vq, vb, 0, 0);
2614
2615         videobuf_vmalloc_free(vb);
2616
2617         CIFISP_DPRINT(CIFISP_DEBUG, "Releasing buffer exit!\n");
2618 }
2619
2620 static int cifisp_stat_vbq_prepare(struct videobuf_queue *vq,
2621                                    struct videobuf_buffer *vb,
2622                                    enum v4l2_field field)
2623 {
2624         int err = 0;
2625
2626         vb->size = sizeof(struct cifisp_stat_buffer);
2627         vb->width = 0;
2628         vb->height = 0;
2629         vb->field = field;
2630
2631         if (vb->state == VIDEOBUF_NEEDS_INIT)
2632                 err = videobuf_iolock(vq, vb, NULL);
2633
2634         if (!err)
2635                 vb->state = VIDEOBUF_PREPARED;
2636         else
2637                 cifisp_stat_vbq_release(vq, vb);
2638
2639         return err;
2640 }
2641
2642 static void cifisp_stat_vbq_queue(struct videobuf_queue *vq,
2643                                   struct videobuf_buffer *vb)
2644 {
2645         struct cif_isp10_isp_dev *isp_dev = vq->priv_data;
2646
2647         vb->state = VIDEOBUF_QUEUED;
2648
2649         CIFISP_DPRINT(CIFISP_DEBUG, "Queueing stat buffer!\n");
2650
2651         list_add_tail(&vb->queue, &isp_dev->stat);
2652 }
2653
2654 /* Queue Ops */
2655 static struct videobuf_queue_ops cifisp_stat_qops = {
2656         .buf_setup = cifisp_stat_vbq_setup,
2657         .buf_prepare = cifisp_stat_vbq_prepare,
2658         .buf_queue = cifisp_stat_vbq_queue,
2659         .buf_release = cifisp_stat_vbq_release,
2660 };
2661
2662 /* ================== IOCTL implementation ========================= */
2663 static int cifisp_reqbufs(struct file *file, void *priv,
2664                           struct v4l2_requestbuffers *p)
2665 {
2666         struct cif_isp10_isp_dev *isp_dev =
2667                 video_get_drvdata(video_devdata(file));
2668
2669         CIFISP_DPRINT(CIFISP_DEBUG,
2670                       " %s: %s: p->type %d p->count %d\n",
2671                       ISP_VDEV_NAME, __func__, p->type, p->count);
2672
2673         return videobuf_reqbufs(&isp_dev->vbq_stat, p);
2674 }
2675
2676 static int cifisp_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
2677 {
2678         struct cif_isp10_isp_dev *isp_dev =
2679                 video_get_drvdata(video_devdata(file));
2680
2681         CIFISP_DPRINT(CIFISP_DEBUG,
2682                       " %s: %s: p->type %d p->index %d\n",
2683                       ISP_VDEV_NAME, __func__, p->type, p->index);
2684
2685         return videobuf_querybuf(&isp_dev->vbq_stat, p);
2686 }
2687
2688 static int cifisp_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
2689 {
2690         struct cif_isp10_isp_dev *isp_dev =
2691                 video_get_drvdata(video_devdata(file));
2692
2693         CIFISP_DPRINT(CIFISP_DEBUG,
2694                       " %s: %s: p->type %d p->index %d\n",
2695                       ISP_VDEV_NAME, __func__, p->type, p->index);
2696
2697         return videobuf_qbuf(&isp_dev->vbq_stat, p);
2698 }
2699
2700 /* ========================================================== */
2701
2702 static int cifisp_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
2703 {
2704         struct cif_isp10_isp_dev *isp_dev =
2705                 video_get_drvdata(video_devdata(file));
2706
2707         CIFISP_DPRINT(CIFISP_DEBUG,
2708                       " %s: %s: p->type %d p->index %d\n",
2709                       ISP_VDEV_NAME, __func__, p->type, p->index);
2710
2711         return videobuf_dqbuf(&isp_dev->vbq_stat, p,
2712                               file->f_flags & O_NONBLOCK);
2713 }
2714
2715 static int cifisp_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
2716 {
2717         struct cif_isp10_isp_dev *isp_dev =
2718                 video_get_drvdata(video_devdata(file));
2719
2720         int ret = videobuf_streamon(&isp_dev->vbq_stat);
2721
2722         if (ret == 0)
2723                 isp_dev->streamon = true;
2724
2725         CIFISP_DPRINT(CIFISP_DEBUG,
2726                       " %s: %s: ret %d\n", ISP_VDEV_NAME, __func__, ret);
2727
2728         return ret;
2729 }
2730
2731 /* ========================================================== */
2732 static int cifisp_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
2733 {
2734         struct cif_isp10_isp_dev *isp_dev =
2735                 video_get_drvdata(video_devdata(file));
2736         int ret;
2737
2738         drain_workqueue(isp_dev->readout_wq);
2739
2740         ret = videobuf_streamoff(&isp_dev->vbq_stat);
2741
2742         if (ret == 0)
2743                 isp_dev->streamon = false;
2744
2745         CIFISP_DPRINT(CIFISP_DEBUG,
2746                 " %s: %s: ret %d\n", ISP_VDEV_NAME, __func__, ret);
2747
2748         return ret;
2749 }
2750
2751 static int cifisp_g_ctrl(struct file *file, void *priv, struct v4l2_control *vc)
2752 {
2753         int ret;
2754
2755         struct cif_isp10_isp_dev *isp_dev =
2756                 video_get_drvdata(video_devdata(file));
2757
2758         switch (vc->id) {
2759         case V4L2_CID_CIFISP_DPCC:
2760                 ret = cifisp_module_enable(
2761                         isp_dev,
2762                         _GET_,
2763                         &vc->value,
2764                         CIFISP_MODULE_DPCC);
2765                 break;
2766         case V4L2_CID_CIFISP_BLS:
2767                 ret = cifisp_module_enable(
2768                         isp_dev,
2769                         _GET_,
2770                         &vc->value,
2771                         CIFISP_MODULE_BLS);
2772                 break;
2773         case V4L2_CID_CIFISP_SDG:
2774                 ret = cifisp_module_enable(
2775                         isp_dev,
2776                         _GET_,
2777                         &vc->value,
2778                         CIFISP_MODULE_SDG);
2779                 break;
2780         case V4L2_CID_CIFISP_LSC:
2781                 ret = cifisp_module_enable(
2782                         isp_dev,
2783                         _GET_,
2784                         &vc->value,
2785                         CIFISP_MODULE_LSC);
2786                 break;
2787         case V4L2_CID_CIFISP_AWB_MEAS:
2788                 ret = cifisp_module_enable(
2789                         isp_dev,
2790                         _GET_,
2791                         &vc->value,
2792                         CIFISP_MODULE_AWB);
2793                 break;
2794         case V4L2_CID_CIFISP_AWB_GAIN:
2795                 ret = cifisp_module_enable(
2796                         isp_dev,
2797                         _GET_,
2798                         &vc->value,
2799                         CIFISP_MODULE_AWB_GAIN);
2800                 break;
2801         case V4L2_CID_CIFISP_FLT:
2802                 ret = cifisp_module_enable(
2803                         isp_dev,
2804                         _GET_,
2805                         &vc->value,
2806                         CIFISP_MODULE_FLT);
2807                 break;
2808         case V4L2_CID_CIFISP_BDM:
2809                 ret = cifisp_module_enable(
2810                         isp_dev,
2811                         _GET_,
2812                         &vc->value,
2813                         CIFISP_MODULE_BDM);
2814                 break;
2815         case V4L2_CID_CIFISP_CTK:
2816                 ret = cifisp_module_enable(
2817                         isp_dev,
2818                         _GET_,
2819                         &vc->value,
2820                         CIFISP_MODULE_CTK);
2821                 break;
2822         case V4L2_CID_CIFISP_GOC:
2823                 ret = cifisp_module_enable(
2824                         isp_dev,
2825                         _GET_,
2826                         &vc->value,
2827                         CIFISP_MODULE_GOC);
2828                 break;
2829         case V4L2_CID_CIFISP_HST:
2830                 ret = cifisp_module_enable(
2831                         isp_dev,
2832                         _GET_,
2833                         &vc->value,
2834                         CIFISP_MODULE_HST);
2835                 break;
2836         case V4L2_CID_CIFISP_AEC:
2837                 ret = cifisp_module_enable(
2838                         isp_dev,
2839                         _GET_,
2840                         &vc->value,
2841                         CIFISP_MODULE_AEC);
2842                 break;
2843         case V4L2_CID_CIFISP_CPROC:
2844                 ret = cifisp_module_enable(
2845                         isp_dev,
2846                         _GET_,
2847                         &vc->value,
2848                         CIFISP_MODULE_CPROC);
2849                 break;
2850         case V4L2_CID_CIFISP_AFC:
2851                 ret = cifisp_module_enable(
2852                         isp_dev,
2853                         _GET_,
2854                         &vc->value,
2855                         CIFISP_MODULE_AFC);
2856                 break;
2857         case V4L2_CID_CIFISP_IE:
2858                 ret = cifisp_module_enable(
2859                         isp_dev,
2860                         _GET_,
2861                         &vc->value,
2862                         CIFISP_MODULE_IE);
2863                 break;
2864         case V4L2_CID_CIFISP_DPF:
2865                 ret = cifisp_module_enable(
2866                         isp_dev,
2867                         _GET_,
2868                         &vc->value,
2869                         CIFISP_MODULE_DPF);
2870                 break;
2871         default:
2872                 ret = -EINVAL;
2873                 break;
2874         }
2875         return ret;
2876 }
2877
2878 static int cifisp_s_ctrl(struct file *file, void *priv, struct v4l2_control *vc)
2879 {
2880         struct cif_isp10_isp_dev *isp_dev =
2881                 video_get_drvdata(video_devdata(file));
2882         int ret;
2883
2884         switch (vc->id) {
2885         case V4L2_CID_CIFISP_DPCC:
2886                 ret = cifisp_module_enable(
2887                         isp_dev,
2888                         _SET_,
2889                         &vc->value,
2890                         CIFISP_MODULE_DPCC);
2891                 break;
2892         case V4L2_CID_CIFISP_BLS:
2893                 ret = cifisp_module_enable(
2894                         isp_dev,
2895                         _SET_,
2896                         &vc->value,
2897                         CIFISP_MODULE_BLS);
2898                 break;
2899         case V4L2_CID_CIFISP_SDG:
2900                 ret = cifisp_module_enable(
2901                         isp_dev,
2902                         _SET_,
2903                         &vc->value,
2904                         CIFISP_MODULE_SDG);
2905                 break;
2906         case V4L2_CID_CIFISP_LSC:
2907                 ret = cifisp_module_enable(
2908                         isp_dev,
2909                         _SET_,
2910                         &vc->value,
2911                         CIFISP_MODULE_LSC);
2912                 break;
2913         case V4L2_CID_CIFISP_AWB_MEAS:
2914                 ret = cifisp_module_enable(
2915                         isp_dev,
2916                         _SET_,
2917                         &vc->value,
2918                         CIFISP_MODULE_AWB);
2919                 break;
2920         case V4L2_CID_CIFISP_AWB_GAIN:
2921                 ret = cifisp_module_enable(
2922                         isp_dev,
2923                         _SET_,
2924                         &vc->value,
2925                         CIFISP_MODULE_AWB_GAIN);
2926                 break;
2927         case V4L2_CID_CIFISP_FLT:
2928                 ret = cifisp_module_enable(
2929                         isp_dev,
2930                         _SET_,
2931                         &vc->value,
2932                         CIFISP_MODULE_FLT);
2933                 break;
2934         case V4L2_CID_CIFISP_BDM:
2935                 ret = cifisp_module_enable(
2936                         isp_dev,
2937                         _SET_,
2938                         &vc->value,
2939                         CIFISP_MODULE_BDM);
2940                 break;
2941         case V4L2_CID_CIFISP_CTK:
2942                 ret = cifisp_module_enable(
2943                         isp_dev,
2944                         _SET_,
2945                         &vc->value,
2946                         CIFISP_MODULE_CTK);
2947                 break;
2948         case V4L2_CID_CIFISP_GOC:
2949                 ret = cifisp_module_enable(
2950                         isp_dev,
2951                         _SET_,
2952                         &vc->value,
2953                         CIFISP_MODULE_GOC);
2954                 break;
2955         case V4L2_CID_CIFISP_HST:
2956                 ret = cifisp_module_enable(
2957                         isp_dev,
2958                         _SET_,
2959                         &vc->value,
2960                         CIFISP_MODULE_HST);
2961                         break;
2962         case V4L2_CID_CIFISP_AEC:
2963                 ret = cifisp_module_enable(
2964                         isp_dev,
2965                         _SET_,
2966                         &vc->value,
2967                         CIFISP_MODULE_AEC);
2968                 break;
2969         case V4L2_CID_CIFISP_CPROC:
2970                 ret = cifisp_module_enable(
2971                         isp_dev,
2972                         _SET_,
2973                         &vc->value,
2974                         CIFISP_MODULE_CPROC);
2975                 break;
2976         case V4L2_CID_CIFISP_AFC:
2977                 ret = cifisp_module_enable(
2978                         isp_dev,
2979                         _SET_,
2980                         &vc->value,
2981                         CIFISP_MODULE_AFC);
2982                 break;
2983         case V4L2_CID_CIFISP_IE:
2984                 ret = cifisp_module_enable(
2985                         isp_dev,
2986                         _SET_,
2987                         &vc->value,
2988                         CIFISP_MODULE_IE);
2989                 break;
2990         case V4L2_CID_CIFISP_DPF:
2991                 ret = cifisp_module_enable(
2992                         isp_dev,
2993                         _SET_,
2994                         &vc->value,
2995                         CIFISP_MODULE_DPF);
2996                 break;
2997         default:
2998                 ret = -EINVAL;
2999                 break;
3000         }
3001         return ret;
3002 }
3003
3004 static long cifisp_ioctl_default(struct file *file,
3005          void *fh, bool valid_prio, unsigned int cmd, void *arg)
3006 {
3007         struct cif_isp10_isp_dev *isp = video_get_drvdata(video_devdata(file));
3008         long ret;
3009
3010         switch (cmd) {
3011         case CIFISP_IOC_G_DPCC:
3012                 ret = cifisp_dpcc_param(isp, _GET_, arg);
3013                 break;
3014         case CIFISP_IOC_S_DPCC:
3015                 ret = cifisp_dpcc_param(isp, _SET_, arg);
3016                 break;
3017         case CIFISP_IOC_G_BLS:
3018                 ret = cifisp_bls_param(isp, _GET_, arg);
3019                 break;
3020         case CIFISP_IOC_S_BLS:
3021                 ret = cifisp_bls_param(isp, _SET_, arg);
3022                 break;
3023         case CIFISP_IOC_G_SDG:
3024                 ret = cifisp_sdg_param(isp, _GET_, arg);
3025                 break;
3026         case CIFISP_IOC_S_SDG:
3027                 ret = cifisp_sdg_param(isp, _SET_, arg);
3028                 break;
3029         case CIFISP_IOC_G_LSC:
3030                 ret = cifisp_lsc_param(isp, _GET_, arg);
3031                 break;
3032         case CIFISP_IOC_S_LSC:
3033                 ret = cifisp_lsc_param(isp, _SET_, arg);
3034                 break;
3035         case CIFISP_IOC_G_AWB_MEAS:
3036                 ret = cifisp_awb_meas_param(isp, _GET_, arg);
3037                 break;
3038         case CIFISP_IOC_S_AWB_MEAS:
3039                 ret = cifisp_awb_meas_param(isp, _SET_, arg);
3040                 break;
3041         case CIFISP_IOC_G_AWB_GAIN:
3042                 ret = cifisp_awb_gain_param(isp, _GET_, arg);
3043                 break;
3044         case CIFISP_IOC_S_AWB_GAIN:
3045                 ret = cifisp_awb_gain_param(isp, _SET_, arg);
3046                 break;
3047         case CIFISP_IOC_G_FLT:
3048                 ret = cifisp_flt_param(isp, _GET_, arg);
3049                 break;
3050         case CIFISP_IOC_S_FLT:
3051                 ret = cifisp_flt_param(isp, _SET_, arg);
3052                 break;
3053         case CIFISP_IOC_G_BDM:
3054                 ret = cifisp_bdm_param(isp, _GET_, arg);
3055                 break;
3056         case CIFISP_IOC_S_BDM:
3057                 ret = cifisp_bdm_param(isp, _SET_, arg);
3058                 break;
3059         case CIFISP_IOC_G_CTK:
3060                 ret = cifisp_ctk_param(isp, _GET_, arg);
3061                 break;
3062         case CIFISP_IOC_S_CTK:
3063                 ret = cifisp_ctk_param(isp, _SET_, arg);
3064                 break;
3065         case CIFISP_IOC_G_GOC:
3066                 ret = cifisp_goc_param(isp, _GET_, arg);
3067                 break;
3068         case CIFISP_IOC_S_GOC:
3069                 ret = cifisp_goc_param(isp, _SET_, arg);
3070                 break;
3071         case CIFISP_IOC_G_HST:
3072                 ret = cifisp_hst_param(isp, _GET_, arg);
3073                 break;
3074         case CIFISP_IOC_S_HST:
3075                 ret = cifisp_hst_param(isp, _SET_, arg);
3076                 break;
3077         case CIFISP_IOC_G_AEC:
3078                 ret = cifisp_aec_param(isp, _GET_, arg);
3079                 break;
3080         case CIFISP_IOC_S_AEC:
3081                 ret = cifisp_aec_param(isp, _SET_, arg);
3082                 break;
3083         case CIFISP_IOC_G_CPROC:
3084                 ret = cifisp_cproc_param(isp, _GET_, arg);
3085                 break;
3086         case CIFISP_IOC_S_CPROC:
3087                 ret = cifisp_cproc_param(isp, _SET_, arg);
3088                 break;
3089         case CIFISP_IOC_G_AFC:
3090                 ret = cifisp_afc_param(isp, _GET_, arg);
3091                 break;
3092         case CIFISP_IOC_S_AFC:
3093                 ret = cifisp_afc_param(isp, _SET_, arg);
3094                 break;
3095         case CIFISP_IOC_G_IE:
3096                 ret = cifisp_ie_param(isp, _GET_, arg);
3097                 break;
3098         case CIFISP_IOC_S_IE:
3099                 ret = cifisp_ie_param(isp, _SET_, arg);
3100                 break;
3101         case CIFISP_IOC_G_DPF:
3102                 ret = cifisp_dpf_param(isp, _GET_, arg);
3103                 break;
3104         case CIFISP_IOC_S_DPF:
3105                 ret = cifisp_dpf_param(isp, _SET_, arg);
3106                 break;
3107         case CIFISP_IOC_G_DPF_STRENGTH:
3108                 ret = cifisp_dpf_strength_param(isp, _GET_, arg);
3109                 break;
3110         case CIFISP_IOC_S_DPF_STRENGTH:
3111                 ret = cifisp_dpf_strength_param(isp, _SET_, arg);
3112                 break;
3113         case CIFISP_IOC_G_LAST_CONFIG:
3114                 ret = cifisp_last_capture_config(arg);
3115                 break;
3116         default:
3117                 ret = -EINVAL;
3118                 break;
3119         }
3120         return ret;
3121 }
3122
3123 static int cifisp_g_fmt_vid_cap(struct file *file, void *fh,
3124                                 struct v4l2_format *f)
3125 {
3126         /*
3127          * Dummy function needed to allow allocation of
3128          * buffers on this device
3129          */
3130         return 0;
3131 }
3132
3133 static int cifisp_querycap(struct file *file,
3134                          void *priv, struct v4l2_capability *cap)
3135 {
3136         struct video_device *vdev = video_devdata(file);
3137         struct cif_isp10_isp_dev *isp_dev = video_get_drvdata(vdev);
3138
3139         strcpy(cap->driver, DRIVER_NAME);
3140         strlcpy(cap->card, vdev->name, sizeof(cap->card));
3141         snprintf(cap->bus_info, sizeof(cap->bus_info),
3142                 "platform:" DRIVER_NAME "-%03i",
3143                 *isp_dev->dev_id);
3144
3145         cap->capabilities = V4L2_CAP_DEVICE_CAPS;
3146         cap->device_caps = V4L2_CAP_DEVICE_CAPS;
3147         return 0;
3148 }
3149
3150 /* ISP video device IOCTLs */
3151 static const struct v4l2_ioctl_ops cifisp_ioctl = {
3152         .vidioc_reqbufs = cifisp_reqbufs,
3153         .vidioc_querybuf = cifisp_querybuf,
3154         .vidioc_qbuf = cifisp_qbuf,
3155         .vidioc_dqbuf = cifisp_dqbuf,
3156         .vidioc_streamon = cifisp_streamon,
3157         .vidioc_streamoff = cifisp_streamoff,
3158         .vidioc_g_ctrl = cifisp_g_ctrl,
3159         .vidioc_s_ctrl = cifisp_s_ctrl,
3160         .vidioc_default = cifisp_ioctl_default,
3161         .vidioc_g_fmt_vid_cap = cifisp_g_fmt_vid_cap,
3162         .vidioc_querycap = cifisp_querycap
3163 };
3164
3165 /* ======================================================== */
3166
3167 static unsigned int cifisp_poll(struct file *file,
3168                                 struct poll_table_struct *wait)
3169 {
3170         struct cif_isp10_isp_dev *isp_dev =
3171                 video_get_drvdata(video_devdata(file));
3172         unsigned int ret;
3173
3174         ret = videobuf_poll_stream(file, &isp_dev->vbq_stat, wait);
3175
3176         CIFISP_DPRINT(CIFISP_DEBUG,
3177                       "Polling on vbq_stat buffer %d\n", ret);
3178
3179         return ret;
3180 }
3181
3182 /* ======================================================== */
3183 static int cifisp_mmap(struct file *file, struct vm_area_struct *vma)
3184 {
3185         struct cif_isp10_isp_dev *isp_dev =
3186                 video_get_drvdata(video_devdata(file));
3187
3188         return videobuf_mmap_mapper(&isp_dev->vbq_stat, vma);
3189 }
3190
3191 /* ddl@rock-chips.com: v1.0.8 */
3192 static int cifisp_reset(struct file *file)
3193 {
3194         struct cif_isp10_isp_dev *isp_dev =
3195                 video_get_drvdata(video_devdata(file));
3196
3197         memset(isp_dev->other_cfgs.cfgs, 0, sizeof(isp_dev->other_cfgs.cfgs));
3198         memset(isp_dev->meas_cfgs.cfgs, 0, sizeof(isp_dev->meas_cfgs.cfgs));
3199
3200         isp_dev->other_cfgs.last_or_new = &isp_dev->other_cfgs.cfgs[0];
3201         isp_dev->other_cfgs.curr = &isp_dev->other_cfgs.cfgs[1];
3202         isp_dev->other_cfgs.module_updates = 0;
3203
3204         isp_dev->meas_cfgs.last_or_new = &isp_dev->meas_cfgs.cfgs[0];
3205         isp_dev->meas_cfgs.curr = &isp_dev->meas_cfgs.cfgs[1];
3206         isp_dev->meas_cfgs.module_updates = 0;
3207         isp_dev->active_lsc_width = 0;
3208         isp_dev->active_lsc_height = 0;
3209
3210         isp_dev->streamon = false;
3211         isp_dev->active_meas = 0;
3212         isp_dev->frame_id = 0;
3213         isp_dev->cif_ism_cropping = false;
3214         return 0;
3215 }
3216
3217 static int cifisp_open(struct file *file)
3218 {
3219         CIFISP_DPRINT(CIFISP_DEBUG, "cifisp_open\n");
3220
3221         cifisp_reset(file);
3222
3223         return 0;
3224 }
3225
3226 static int cifisp_close(struct file *file)
3227 {
3228         struct cif_isp10_isp_dev *isp_dev =
3229                 video_get_drvdata(video_devdata(file));
3230
3231         CIFISP_DPRINT(CIFISP_DEBUG, "cifisp_close\n");
3232
3233         videobuf_stop(&isp_dev->vbq_stat);
3234         videobuf_mmap_free(&isp_dev->vbq_stat);
3235
3236         /* cifisp_reset(file); */
3237         return 0;
3238 }
3239
3240 struct v4l2_file_operations cifisp_fops = {
3241         .mmap = cifisp_mmap,
3242         .unlocked_ioctl = video_ioctl2,
3243 #ifdef CONFIG_COMPAT
3244         .compat_ioctl32 = video_ioctl2,
3245 #endif
3246         .poll = cifisp_poll,
3247         .open = cifisp_open,
3248         .release = cifisp_close
3249 };
3250
3251 static void cifisp_release(struct video_device *vdev)
3252 {
3253         struct cif_isp10_isp_dev *isp_dev = video_get_drvdata(vdev);
3254
3255         CIFISP_DPRINT(CIFISP_DEBUG, "cifisp_release\n");
3256         video_device_release(vdev);
3257         destroy_workqueue(isp_dev->readout_wq);
3258 }
3259
3260 /************************************************************/
3261 int register_cifisp_device(struct cif_isp10_isp_dev *isp_dev,
3262         struct video_device *vdev_cifisp,
3263         struct v4l2_device *v4l2_dev,
3264         void __iomem *cif_reg_baseaddress)
3265 {
3266         isp_dev->base_addr = cif_reg_baseaddress;
3267         WARN_ON(!(isp_dev->base_addr));
3268
3269         INIT_LIST_HEAD(&isp_dev->stat);
3270         spin_lock_init(&isp_dev->irq_lock);
3271         spin_lock_init(&isp_dev->config_lock);
3272         strlcpy(vdev_cifisp->name, ISP_VDEV_NAME, sizeof(vdev_cifisp->name));
3273         vdev_cifisp->vfl_type = V4L2_CAP_VIDEO_CAPTURE;
3274         video_set_drvdata(vdev_cifisp, isp_dev);
3275         vdev_cifisp->ioctl_ops = &cifisp_ioctl;
3276         vdev_cifisp->fops = &cifisp_fops;
3277
3278         /*
3279          * This might not release all resources,
3280          * but unregistering is anyway not going to happen.
3281          */
3282         vdev_cifisp->release = cifisp_release;
3283         mutex_init(&isp_dev->mutex);
3284         /*
3285          * Provide a mutex to v4l2 core. It will be used
3286          * to protect all fops and v4l2 ioctls.
3287          */
3288         vdev_cifisp->lock = &isp_dev->mutex;
3289         vdev_cifisp->v4l2_dev = v4l2_dev;
3290
3291         videobuf_queue_vmalloc_init(
3292                 &isp_dev->vbq_stat,
3293                 &cifisp_stat_qops,
3294                 NULL,
3295                 &isp_dev->irq_lock,
3296                 V4L2_BUF_TYPE_VIDEO_CAPTURE,
3297                 V4L2_FIELD_NONE,
3298                 sizeof(struct videobuf_buffer),
3299                 isp_dev,
3300                 NULL);  /* ext_lock: NULL */
3301
3302         if (video_register_device(vdev_cifisp, VFL_TYPE_GRABBER, -1) < 0) {
3303                 dev_err(&vdev_cifisp->dev,
3304                         "could not register Video for Linux device\n");
3305                 return -ENODEV;
3306         }
3307
3308         CIFISP_DPRINT(CIFISP_DEBUG,
3309                 "%s: CIFISP vdev minor =  %d\n",
3310                 __func__, vdev_cifisp->minor);
3311
3312         isp_dev->readout_wq =
3313                 alloc_workqueue("measurement_queue",
3314                         WQ_UNBOUND | WQ_MEM_RECLAIM, 1);
3315
3316         if (!isp_dev->readout_wq)
3317                 return -ENOMEM;
3318
3319         isp_dev->v_blanking_us = CIFISP_MODULE_DEFAULT_VBLANKING_TIME;
3320
3321         return 0;
3322 }
3323
3324 void unregister_cifisp_device(struct video_device *vdev_cifisp)
3325 {
3326         if (!IS_ERR_OR_NULL(vdev_cifisp))
3327                 video_unregister_device(vdev_cifisp);
3328 }
3329
3330 static void cifisp_dump_reg(struct cif_isp10_isp_dev *isp_dev, int level)
3331 {
3332 #ifdef CIFISP_DEBUG_REG
3333         if (isp_dev->dpcc_en)
3334                 cifisp_reg_dump(isp_dev, CIFISP_MODULE_DPCC, level);
3335
3336         if (isp_dev->lsc_en)
3337                 cifisp_reg_dump(isp_dev, CIFISP_MODULE_LSC, level);
3338
3339         if (isp_dev->bls_en)
3340                 cifisp_reg_dump(isp_dev, CIFISP_MODULE_BLS, level);
3341
3342         if (isp_dev->sdg_en)
3343                 cifisp_reg_dump(isp_dev, CIFISP_MODULE_SDG, level);
3344
3345         if (isp_dev->goc_en)
3346                 cifisp_reg_dump(isp_dev, CIFISP_MODULE_GOC, level);
3347
3348         if (isp_dev->bdm_en)
3349                 cifisp_reg_dump(isp_dev, CIFISP_MODULE_BDM, level);
3350
3351         if (isp_dev->flt_en)
3352                 cifisp_reg_dump(isp_dev, CIFISP_MODULE_FLT, level);
3353
3354         if (isp_dev->awb_meas_en || isp_dev->awb_gain_en)
3355                 cifisp_reg_dump(isp_dev, CIFISP_MODULE_AWB, level);
3356
3357         if (isp_dev->aec_en)
3358                 cifisp_reg_dump(isp_dev, CIFISP_MODULE_AEC, level);
3359
3360         if (isp_dev->ctk_en)
3361                 cifisp_reg_dump(isp_dev, CIFISP_MODULE_CTK, level);
3362
3363         if (isp_dev->cproc_en)
3364                 cifisp_reg_dump(isp_dev, CIFISP_MODULE_CPROC, level);
3365
3366         if (isp_dev->afc_en)
3367                 cifisp_reg_dump(isp_dev, CIFISP_MODULE_AFC, level);
3368
3369         if (isp_dev->hst_en)
3370                 cifisp_reg_dump(isp_dev, CIFISP_MODULE_HST, level);
3371 #endif
3372 }
3373
3374 static inline void cifisp_meas_config_swap(
3375         struct cif_isp10_isp_dev *isp_dev)
3376 {
3377         struct cifisp_isp_meas_cfg *new_cfg;
3378
3379         new_cfg = isp_dev->meas_cfgs.last_or_new;
3380         new_cfg->s_frame_id = isp_dev->frame_id;
3381         isp_dev->meas_cfgs.last_or_new =
3382                 isp_dev->meas_cfgs.curr;
3383         isp_dev->meas_cfgs.curr = new_cfg;
3384 }
3385
3386 static inline void cifisp_other_config_swap(
3387         struct cif_isp10_isp_dev *isp_dev)
3388 {
3389         struct cifisp_isp_other_cfg *new_cfg;
3390
3391         new_cfg = isp_dev->other_cfgs.last_or_new;
3392         new_cfg->s_frame_id = isp_dev->frame_id;
3393         isp_dev->other_cfgs.last_or_new =
3394                 isp_dev->other_cfgs.curr;
3395         isp_dev->other_cfgs.curr = new_cfg;
3396 }
3397
3398 /* Not called when the camera active, thus not isr protection. */
3399 void cifisp_configure_isp(
3400         struct cif_isp10_isp_dev *isp_dev,
3401         enum cif_isp10_pix_fmt in_pix_fmt,
3402         enum cif_isp10_pix_fmt_quantization quantization)
3403 {
3404         unsigned int *other_ens, *other_updates;
3405         unsigned int *meas_ens, *meas_updates;
3406
3407         CIFISP_DPRINT(CIFISP_DEBUG, "%s\n", __func__);
3408
3409         mutex_lock(&isp_dev->mutex);
3410         spin_lock(&isp_dev->config_lock);
3411
3412         other_ens = &isp_dev->other_cfgs.last_or_new->module_ens;
3413         other_updates = &isp_dev->other_cfgs.module_updates;
3414         meas_ens = &isp_dev->meas_cfgs.last_or_new->module_ens;
3415         meas_updates = &isp_dev->meas_cfgs.module_updates;
3416         isp_dev->quantization = quantization;
3417         if (CIF_ISP10_PIX_FMT_IS_RAW_BAYER(in_pix_fmt)) {
3418                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_DPCC)) {
3419                         cifisp_dpcc_config(isp_dev);
3420                         cifisp_dpcc_en(isp_dev);
3421                         CIFISP_MODULE_CLR_UPDATE(*other_updates,
3422                                 CIFISP_MODULE_DPCC);
3423                 }
3424
3425                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_LSC)) {
3426                         if (cifisp_lsc_config(isp_dev))
3427                                 CIFISP_MODULE_CLR_UPDATE(*other_updates,
3428                                         CIFISP_MODULE_LSC);
3429                 }
3430
3431                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_BLS)) {
3432                         cifisp_bls_config(isp_dev);
3433                         cifisp_bls_en(isp_dev);
3434                         CIFISP_MODULE_CLR_UPDATE(*other_updates,
3435                                 CIFISP_MODULE_BLS);
3436                 }
3437
3438                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_SDG)) {
3439                         cifisp_sdg_config(isp_dev);
3440                         cifisp_sdg_en(isp_dev);
3441                         CIFISP_MODULE_CLR_UPDATE(*other_updates,
3442                                 CIFISP_MODULE_SDG);
3443                 }
3444
3445                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_GOC)) {
3446                         cifisp_goc_config(isp_dev);
3447                         cifisp_goc_en(isp_dev);
3448                         CIFISP_MODULE_CLR_UPDATE(*other_updates,
3449                                 CIFISP_MODULE_GOC);
3450                 }
3451
3452                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_BDM)) {
3453                         cifisp_bdm_config(isp_dev);
3454                         cifisp_bdm_en(isp_dev);
3455                         CIFISP_MODULE_CLR_UPDATE(*other_updates,
3456                                 CIFISP_MODULE_BDM);
3457                 }
3458
3459                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_FLT)) {
3460                         cifisp_flt_config(isp_dev);
3461                         cifisp_flt_en(isp_dev);
3462                         CIFISP_MODULE_CLR_UPDATE(*other_updates,
3463                                 CIFISP_MODULE_FLT);
3464                 }
3465
3466                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_AWB_GAIN)) {
3467                         cifisp_awb_gain_config(isp_dev);
3468                         cifisp_awb_gain_en(isp_dev);
3469                         CIFISP_MODULE_CLR_UPDATE(*other_updates,
3470                                 CIFISP_MODULE_AWB_GAIN);
3471                 }
3472
3473                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_CTK)) {
3474                         cifisp_ctk_config(isp_dev);
3475                         cifisp_ctk_en(isp_dev);
3476                         CIFISP_MODULE_CLR_UPDATE(*other_updates,
3477                                 CIFISP_MODULE_CTK);
3478                 }
3479
3480                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_CPROC)) {
3481                         cifisp_cproc_config(isp_dev, quantization);
3482                         cifisp_cproc_en(isp_dev);
3483                         CIFISP_MODULE_CLR_UPDATE(*other_updates,
3484                                 CIFISP_MODULE_CPROC);
3485                 }
3486
3487                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_IE)) {
3488                         cifisp_ie_config(isp_dev);
3489                         cifisp_ie_en(isp_dev);
3490                         CIFISP_MODULE_CLR_UPDATE(*other_updates,
3491                                 CIFISP_MODULE_IE);
3492                 }
3493
3494                 cifisp_csm_config(isp_dev, quantization);
3495
3496                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_DPF)) {
3497                         cifisp_dpf_config(isp_dev);
3498                         cifisp_dpf_strength_config(isp_dev);
3499                         cifisp_dpf_en(isp_dev);
3500                         CIFISP_MODULE_CLR_UPDATE(*other_updates,
3501                                 CIFISP_MODULE_DPF | CIFISP_MODULE_DPF_STRENGTH);
3502                 }
3503
3504                 if (CIFISP_MODULE_IS_EN(*meas_ens, CIFISP_MODULE_AFC)) {
3505                         cifisp_afc_config(isp_dev);
3506                         cifisp_afc_en(isp_dev);
3507                         CIFISP_MODULE_CLR_UPDATE(*meas_updates,
3508                                 CIFISP_MODULE_AFC);
3509                 }
3510
3511                 if (CIFISP_MODULE_IS_EN(*meas_ens, CIFISP_MODULE_AWB)) {
3512                         cifisp_awb_meas_config(isp_dev);
3513                         cifisp_awb_meas_en(isp_dev);
3514                         CIFISP_MODULE_CLR_UPDATE(*meas_updates,
3515                                 CIFISP_MODULE_AWB);
3516                 }
3517
3518                 if (CIFISP_MODULE_IS_EN(*meas_ens, CIFISP_MODULE_AEC)) {
3519                         cifisp_aec_config(isp_dev);
3520                         cifisp_aec_en(isp_dev);
3521                         CIFISP_MODULE_CLR_UPDATE(*meas_updates,
3522                                 CIFISP_MODULE_AEC);
3523                 }
3524
3525                 if (CIFISP_MODULE_IS_EN(*meas_ens, CIFISP_MODULE_HST)) {
3526                         cifisp_hst_config(isp_dev);
3527                         cifisp_hst_en(isp_dev);
3528                         CIFISP_MODULE_CLR_UPDATE(*meas_updates,
3529                                 CIFISP_MODULE_HST);
3530                 }
3531         } else {
3532                 /* Disable modules for yuv */
3533                 cifisp_dpcc_end(isp_dev);
3534                 CIFISP_MODULE_CLR_UPDATE(*other_updates,
3535                                 CIFISP_MODULE_DPCC);
3536
3537                 cifisp_lsc_end(isp_dev);
3538                 CIFISP_MODULE_CLR_UPDATE(*other_updates,
3539                                 CIFISP_MODULE_LSC);
3540
3541                 cifisp_bls_end(isp_dev);
3542                 CIFISP_MODULE_CLR_UPDATE(*other_updates,
3543                                 CIFISP_MODULE_BLS);
3544
3545                 cifisp_sdg_end(isp_dev);
3546                 CIFISP_MODULE_CLR_UPDATE(*other_updates,
3547                                 CIFISP_MODULE_SDG);
3548
3549                 cifisp_goc_end(isp_dev);
3550                 CIFISP_MODULE_CLR_UPDATE(*other_updates,
3551                                 CIFISP_MODULE_GOC);
3552
3553                 cifisp_bdm_end(isp_dev);
3554                 CIFISP_MODULE_CLR_UPDATE(*other_updates,
3555                                 CIFISP_MODULE_BDM);
3556
3557                 cifisp_flt_end(isp_dev);
3558                 CIFISP_MODULE_CLR_UPDATE(*other_updates,
3559                                 CIFISP_MODULE_FLT);
3560
3561                 cifisp_awb_meas_end(isp_dev);
3562                 CIFISP_MODULE_CLR_UPDATE(*meas_updates,
3563                                 CIFISP_MODULE_AWB);
3564
3565                 cifisp_awb_gain_end(isp_dev);
3566                 CIFISP_MODULE_CLR_UPDATE(*other_updates,
3567                                 CIFISP_MODULE_AWB_GAIN);
3568
3569                 cifisp_aec_end(isp_dev);
3570                 CIFISP_MODULE_CLR_UPDATE(*meas_updates,
3571                                 CIFISP_MODULE_AEC);
3572
3573                 cifisp_ctk_end(isp_dev);
3574                 CIFISP_MODULE_CLR_UPDATE(*other_updates,
3575                                 CIFISP_MODULE_CTK);
3576
3577                 cifisp_dpf_end(isp_dev);
3578                 CIFISP_MODULE_CLR_UPDATE(*other_updates,
3579                                 CIFISP_MODULE_DPF);
3580
3581                 /* cproc can be used for yuv in reduced range */
3582                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_CPROC)) {
3583                         cifisp_cproc_config(isp_dev, false);
3584                         cifisp_cproc_en(isp_dev);
3585                         CIFISP_MODULE_CLR_UPDATE(*other_updates,
3586                                 CIFISP_MODULE_CPROC);
3587                 }
3588
3589                 cifisp_hst_end(isp_dev);
3590                 CIFISP_MODULE_CLR_UPDATE(*meas_updates,
3591                                 CIFISP_MODULE_HST);
3592
3593                 cifisp_afc_end(isp_dev);
3594                 CIFISP_MODULE_CLR_UPDATE(*meas_updates,
3595                                 CIFISP_MODULE_AFC);
3596                 /* ie can be used for yuv */
3597                 if (CIFISP_MODULE_IS_EN(*other_ens, CIFISP_MODULE_IE)) {
3598                         cifisp_ie_config(isp_dev);
3599                         cifisp_ie_en(isp_dev);
3600                         CIFISP_MODULE_CLR_UPDATE(*other_updates,
3601                                 CIFISP_MODULE_IE);
3602                 } else {
3603                         cifisp_ie_end(isp_dev);
3604                 }
3605         }
3606
3607         cifisp_dump_reg(isp_dev, CIFISP_DEBUG);
3608
3609         cifisp_meas_config_swap(isp_dev);
3610         cifisp_other_config_swap(isp_dev);
3611
3612         memcpy(isp_dev->other_cfgs.last_or_new,
3613                 isp_dev->other_cfgs.curr,
3614                 sizeof(struct cifisp_isp_other_cfg));
3615         memcpy(isp_dev->meas_cfgs.last_or_new,
3616                 isp_dev->meas_cfgs.curr,
3617                 sizeof(struct cifisp_isp_meas_cfg));
3618
3619         spin_unlock(&isp_dev->config_lock);
3620         mutex_unlock(&isp_dev->mutex);
3621 }
3622
3623 void cifisp_frame_in(
3624         struct cif_isp10_isp_dev *isp_dev,
3625         const struct timeval *fi_t)
3626 {
3627         /* Called in an interrupt context. */
3628         isp_dev->fi_t = *fi_t;
3629 }
3630
3631 void cifisp_v_start(
3632         struct cif_isp10_isp_dev *isp_dev,
3633         const struct timeval *vs_t)
3634 {
3635         /* Called in an interrupt context. */
3636         isp_dev->frame_id += 2;
3637         isp_dev->vs_t = *vs_t;
3638 }
3639
3640 /* Not called when the camera active, thus not isr protection. */
3641 void cifisp_disable_isp(struct cif_isp10_isp_dev *isp_dev)
3642 {
3643         CIFISP_DPRINT(CIFISP_DEBUG, "%s\n", __func__);
3644
3645         mutex_lock(&isp_dev->mutex);
3646
3647         cifisp_dpcc_end(isp_dev);
3648         cifisp_lsc_end(isp_dev);
3649         cifisp_bls_end(isp_dev);
3650         cifisp_sdg_end(isp_dev);
3651         cifisp_goc_end(isp_dev);
3652         cifisp_bdm_end(isp_dev);
3653         cifisp_flt_end(isp_dev);
3654         cifisp_awb_meas_end(isp_dev);
3655         cifisp_awb_gain_end(isp_dev);
3656         cifisp_aec_end(isp_dev);
3657         cifisp_ctk_end(isp_dev);
3658         cifisp_cproc_end(isp_dev);
3659         cifisp_hst_end(isp_dev);
3660         cifisp_afc_end(isp_dev);
3661         cifisp_ie_end(isp_dev);
3662         cifisp_dpf_end(isp_dev);
3663
3664         /*
3665          * Isp isn't active, isp interrupt isn't enabled, spin_lock is enough;
3666          */
3667         spin_lock(&isp_dev->config_lock);
3668
3669         isp_dev->other_cfgs.last_or_new->module_ens = 0;
3670         isp_dev->meas_cfgs.last_or_new->module_ens = 0;
3671
3672         /*
3673          * 1. Swap last_or_new and curr pointer;
3674          * 2. Sync last_or_new and curr configuration;
3675          */
3676         cifisp_meas_config_swap(isp_dev);
3677         cifisp_other_config_swap(isp_dev);
3678
3679         memcpy(isp_dev->other_cfgs.last_or_new,
3680                 isp_dev->other_cfgs.curr,
3681                 sizeof(struct cifisp_isp_other_cfg));
3682         memcpy(isp_dev->meas_cfgs.last_or_new,
3683                 isp_dev->meas_cfgs.curr,
3684                 sizeof(struct cifisp_isp_meas_cfg));
3685
3686         spin_unlock(&isp_dev->config_lock);
3687
3688         mutex_unlock(&isp_dev->mutex);
3689 }
3690
3691 static void cifisp_send_measurement(
3692         struct cif_isp10_isp_dev *isp_dev,
3693         struct cif_isp10_isp_readout_work *meas_work)
3694 {
3695         unsigned long lock_flags = 0;
3696         struct videobuf_buffer *vb = NULL;
3697         unsigned int active_meas = isp_dev->active_meas;
3698         struct cifisp_stat_buffer *stat_buf;
3699         struct cif_isp10_device *cif_dev =
3700                 container_of(isp_dev, struct cif_isp10_device, isp_dev);
3701
3702         spin_lock_irqsave(&isp_dev->irq_lock, lock_flags);
3703         if (isp_dev->frame_id != meas_work->frame_id) {
3704                 spin_unlock_irqrestore(&isp_dev->irq_lock, lock_flags);
3705                 CIFISP_DPRINT(CIFISP_ERROR,
3706                         "Measurement late(%d, %d)\n",
3707                         isp_dev->frame_id,
3708                         meas_work->frame_id);
3709                 goto end;
3710         }
3711
3712         if (!list_empty(&isp_dev->stat)) {
3713                 vb = list_first_entry(&isp_dev->stat,
3714                 struct videobuf_buffer, queue);
3715         } else {
3716                 spin_unlock_irqrestore(&isp_dev->irq_lock, lock_flags);
3717                 CIFISP_DPRINT(CIFISP_DEBUG,
3718                         "Not enought measurement bufs\n");
3719                 goto end;
3720         }
3721
3722         spin_unlock_irqrestore(&isp_dev->irq_lock, lock_flags);
3723         vb->state = VIDEOBUF_ACTIVE;
3724
3725         stat_buf = (struct cifisp_stat_buffer *)videobuf_to_vmalloc(vb);
3726         memset(stat_buf, 0x00, sizeof(struct cifisp_stat_buffer));
3727
3728         if (active_meas & CIF_ISP_AWB_DONE)
3729                 cifisp_get_awb_meas(isp_dev, stat_buf);
3730
3731         if (active_meas & CIF_ISP_AFM_FIN)
3732                 cifisp_get_afc_meas(isp_dev, stat_buf);
3733
3734         if (active_meas & CIF_ISP_EXP_END) {
3735                 cifisp_get_aec_meas(isp_dev, stat_buf);
3736                 cifisp_bls_get_meas(isp_dev, stat_buf);
3737         }
3738
3739         if (active_meas & CIF_ISP_HIST_MEASURE_RDY)
3740                 cifisp_get_hst_meas(isp_dev, stat_buf);
3741
3742         spin_lock_irqsave(&isp_dev->irq_lock, lock_flags);
3743
3744         if (isp_dev->frame_id != meas_work->frame_id) {
3745                 spin_unlock_irqrestore(&isp_dev->irq_lock, lock_flags);
3746                 CIFISP_DPRINT(CIFISP_ERROR,
3747                         "Measurement late(%d, %d)\n",
3748                         isp_dev->frame_id,
3749                         meas_work->frame_id);
3750                 goto end;
3751         }
3752
3753         vb->ts = isp_dev->vs_t;
3754         list_del(&vb->queue);
3755         spin_unlock_irqrestore(&isp_dev->irq_lock, lock_flags);
3756
3757         if (active_meas & CIF_ISP_AWB_DONE) {
3758                 memcpy(&isp_dev->meas_stats.stat.params.awb,
3759                         &stat_buf->params.awb,
3760                         sizeof(struct cifisp_awb_stat));
3761                 isp_dev->meas_stats.stat.meas_type |= CIFISP_STAT_AWB;
3762         }
3763         if (active_meas & CIF_ISP_AFM_FIN) {
3764                 memcpy(&isp_dev->meas_stats.stat.params.af,
3765                         &stat_buf->params.af,
3766                         sizeof(struct cifisp_af_stat));
3767                 isp_dev->meas_stats.stat.meas_type |= CIFISP_STAT_AFM_FIN;
3768         }
3769         if (active_meas & CIF_ISP_EXP_END) {
3770                 cif_isp10_sensor_mode_data_sync(cif_dev,
3771                         meas_work->frame_id,
3772                         &stat_buf->sensor_mode);
3773                 memcpy(&isp_dev->meas_stats.stat.params.ae,
3774                         &stat_buf->params.ae,
3775                         sizeof(struct cifisp_ae_stat));
3776                 memcpy(&isp_dev->meas_stats.stat.sensor_mode,
3777                         &stat_buf->sensor_mode,
3778                         sizeof(struct isp_supplemental_sensor_mode_data));
3779
3780                 isp_dev->meas_stats.stat.meas_type |= CIFISP_STAT_AUTOEXP;
3781         }
3782         if (active_meas & CIF_ISP_HIST_MEASURE_RDY) {
3783                 memcpy(&isp_dev->meas_stats.stat.params.hist,
3784                         &stat_buf->params.hist,
3785                         sizeof(struct cifisp_hist_stat));
3786                 isp_dev->meas_stats.stat.meas_type |= CIFISP_STAT_HIST;
3787         }
3788         isp_dev->meas_stats.g_frame_id = meas_work->frame_id;
3789
3790         vb->field_count = meas_work->frame_id;
3791         vb->state = VIDEOBUF_DONE;
3792         wake_up(&vb->done);
3793
3794         CIFISP_DPRINT(CIFISP_DEBUG,
3795                 "Measurement done(%d, %d)\n",
3796                 vb->field_count,
3797                 vb->i);
3798         vb = NULL;
3799 end:
3800
3801         if (vb && (vb->state == VIDEOBUF_ACTIVE))
3802                 vb->state = VIDEOBUF_QUEUED;
3803 }
3804
3805 void cifisp_isp_readout_work(struct work_struct *work)
3806 {
3807         struct cif_isp10_isp_readout_work *readout_work =
3808                 (struct cif_isp10_isp_readout_work *)work;
3809         struct cif_isp10_isp_dev *isp_dev =
3810                 readout_work->isp_dev;
3811         struct cif_isp10_device *cif_dev =
3812                 container_of(isp_dev, struct cif_isp10_device, isp_dev);
3813         unsigned long int lock_flags;
3814
3815         if (!isp_dev->streamon)
3816                 return;
3817
3818         switch (readout_work->readout) {
3819         case CIF_ISP10_ISP_READOUT_MEAS:
3820                 cifisp_send_measurement(isp_dev, readout_work);
3821                 break;
3822
3823         case CIF_ISP10_ISP_READOUT_META: {
3824                 struct cifisp_isp_other_cfg *other_new = NULL;
3825                 struct cifisp_isp_meas_cfg *meas_new = NULL;
3826                 struct cifisp_stat_buffer *stat_new = NULL;
3827
3828                 spin_lock_irqsave(&isp_dev->config_lock, lock_flags);
3829
3830                 if (isp_dev->other_cfgs.module_updates == 0) {
3831                         if (readout_work->frame_id ==
3832                                 isp_dev->other_cfgs.curr->s_frame_id)
3833                                 other_new = isp_dev->other_cfgs.last_or_new;
3834                         else if (readout_work->frame_id >
3835                                 isp_dev->other_cfgs.curr->s_frame_id)
3836                                 other_new = isp_dev->other_cfgs.curr;
3837                         else
3838                                 other_new = NULL;
3839                 }
3840
3841                 if (isp_dev->meas_cfgs.module_updates == 0) {
3842                         if (readout_work->frame_id ==
3843                                 isp_dev->meas_cfgs.curr->s_frame_id)
3844                                 meas_new = isp_dev->meas_cfgs.last_or_new;
3845                         else if (readout_work->frame_id >
3846                                 isp_dev->meas_cfgs.curr->s_frame_id)
3847                                 meas_new = isp_dev->meas_cfgs.curr;
3848                         else
3849                                 meas_new = NULL;
3850                 }
3851
3852                 if ((isp_dev->meas_stats.g_frame_id ==
3853                         readout_work->frame_id) &&
3854                         isp_dev->meas_stats.stat.meas_type)
3855                         stat_new = &isp_dev->meas_stats.stat;
3856                 else
3857                         stat_new = NULL;
3858
3859                 cif_isp10_s_isp_metadata(
3860                         cif_dev,
3861                         readout_work,
3862                         other_new,
3863                         meas_new,
3864                         stat_new);
3865                 spin_unlock_irqrestore(&isp_dev->config_lock, lock_flags);
3866
3867                 break;
3868         }
3869         default:
3870                 break;
3871         }
3872
3873         kfree((void *)work);
3874 }
3875
3876 static inline bool cifisp_isp_isr_other_config(
3877         struct cif_isp10_isp_dev *isp_dev,
3878         unsigned int *time_left)
3879 {
3880         unsigned int time_in = *time_left;
3881         bool config_chk;
3882         unsigned int *ens;
3883
3884         ens = &isp_dev->other_cfgs.last_or_new->module_ens;
3885
3886         if (CIFISP_MODULE_IS_UPDATE(
3887                 isp_dev->other_cfgs.module_updates,
3888                 CIFISP_MODULE_DPCC)) {
3889                 /*update dpc config */
3890                 cifisp_dpcc_config(isp_dev);
3891
3892                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_DPCC))
3893                         cifisp_dpcc_en(isp_dev);
3894                 else
3895                         cifisp_dpcc_end(isp_dev);
3896
3897                 CIFISP_MODULE_CLR_UPDATE(
3898                         isp_dev->other_cfgs.module_updates,
3899                         CIFISP_MODULE_DPCC);
3900
3901                 *time_left -= CIFISP_MODULE_DPCC_PROC_TIME;
3902
3903                 CIFISP_DPRINT(CIFISP_DEBUG,
3904                         "dpcc time-left :%d\n",
3905                         *time_left);
3906         }
3907
3908         if (CIFISP_MODULE_IS_UPDATE(
3909                 isp_dev->other_cfgs.module_updates,
3910                 CIFISP_MODULE_BLS) &&
3911                 *time_left >= CIFISP_MODULE_BLS_PROC_TIME) {
3912                 /* update bls config */
3913                 cifisp_bls_config(isp_dev);
3914
3915                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_BLS))
3916                         cifisp_bls_en(isp_dev);
3917                 else
3918                         cifisp_bls_end(isp_dev);
3919
3920                 CIFISP_MODULE_CLR_UPDATE(
3921                         isp_dev->other_cfgs.module_updates,
3922                         CIFISP_MODULE_BLS);
3923
3924                 *time_left -= CIFISP_MODULE_BLS_PROC_TIME;
3925                 CIFISP_DPRINT(CIFISP_DEBUG,
3926                         "bls time-left :%d\n",
3927                         *time_left);
3928         }
3929
3930         if (CIFISP_MODULE_IS_UPDATE(
3931                 isp_dev->other_cfgs.module_updates,
3932                 CIFISP_MODULE_SDG) &&
3933                 *time_left >= CIFISP_MODULE_SDG_PROC_TIME) {
3934                 /* update sdg config */
3935                 cifisp_sdg_config(isp_dev);
3936
3937                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_SDG))
3938                         cifisp_sdg_en(isp_dev);
3939                 else
3940                         cifisp_sdg_end(isp_dev);
3941
3942                 CIFISP_MODULE_CLR_UPDATE(
3943                         isp_dev->other_cfgs.module_updates,
3944                         CIFISP_MODULE_SDG);
3945
3946                 *time_left -= CIFISP_MODULE_SDG_PROC_TIME;
3947                 CIFISP_DPRINT(CIFISP_DEBUG,
3948                         "sdg time-left :%d\n",
3949                         *time_left);
3950         }
3951
3952         if (CIFISP_MODULE_IS_UPDATE(
3953                 isp_dev->other_cfgs.module_updates,
3954                 CIFISP_MODULE_LSC) &&
3955                 *time_left >= CIFISP_MODULE_LSC_PROC_TIME) {
3956                 /* update lsc config */
3957                 bool res = true;
3958
3959                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_LSC)) {
3960                         if (!cifisp_lsc_config(isp_dev))
3961                                 res = false;
3962                 } else {
3963                         cifisp_lsc_end(isp_dev);
3964                 }
3965
3966                 if (res)
3967                         CIFISP_MODULE_CLR_UPDATE(
3968                                 isp_dev->other_cfgs.module_updates,
3969                                 CIFISP_MODULE_LSC);
3970
3971                 *time_left -= CIFISP_MODULE_LSC_PROC_TIME;
3972                 CIFISP_DPRINT(CIFISP_DEBUG,
3973                         "lsc time-left :%d\n",
3974                         *time_left);
3975         }
3976
3977         if (CIFISP_MODULE_IS_UPDATE(
3978                 isp_dev->other_cfgs.module_updates,
3979                 CIFISP_MODULE_AWB_GAIN) &&
3980                 *time_left >= CIFISP_MODULE_AWB_GAIN_PROC_TIME) {
3981                 /* update awb gains */
3982                 cifisp_awb_gain_config(isp_dev);
3983
3984                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_AWB_GAIN))
3985                         cifisp_awb_gain_en(isp_dev);
3986                 else
3987                         cifisp_awb_gain_end(isp_dev);
3988
3989                 CIFISP_MODULE_CLR_UPDATE(
3990                         isp_dev->other_cfgs.module_updates,
3991                         CIFISP_MODULE_AWB_GAIN);
3992
3993                 *time_left -= CIFISP_MODULE_AWB_GAIN_PROC_TIME;
3994                 CIFISP_DPRINT(CIFISP_DEBUG,
3995                         "awb-g time-left :%d\n",
3996                         *time_left);
3997         }
3998
3999         if (CIFISP_MODULE_IS_UPDATE(
4000                 isp_dev->other_cfgs.module_updates,
4001                 CIFISP_MODULE_BDM) &&
4002                 *time_left >= CIFISP_MODULE_BDM_PROC_TIME) {
4003                 /* update bdm config */
4004                 cifisp_bdm_config(isp_dev);
4005
4006                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_BDM))
4007                         cifisp_bdm_en(isp_dev);
4008                 else
4009                         cifisp_bdm_end(isp_dev);
4010
4011                 CIFISP_MODULE_CLR_UPDATE(
4012                         isp_dev->other_cfgs.module_updates,
4013                         CIFISP_MODULE_BDM);
4014
4015                 *time_left -= CIFISP_MODULE_BDM_PROC_TIME;
4016                 CIFISP_DPRINT(CIFISP_DEBUG,
4017                         "bdm time-left :%d\n",
4018                         *time_left);
4019         }
4020
4021         if (CIFISP_MODULE_IS_UPDATE(
4022                 isp_dev->other_cfgs.module_updates,
4023                 CIFISP_MODULE_FLT) &&
4024                 *time_left >= CIFISP_MODULE_FLT_PROC_TIME) {
4025                 /* update filter config */
4026                 cifisp_flt_config(isp_dev);
4027
4028                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_FLT))
4029                         cifisp_flt_en(isp_dev);
4030                 else
4031                         cifisp_flt_end(isp_dev);
4032
4033                 CIFISP_MODULE_CLR_UPDATE(
4034                         isp_dev->other_cfgs.module_updates,
4035                         CIFISP_MODULE_FLT);
4036
4037                 *time_left -= CIFISP_MODULE_FLT_PROC_TIME;
4038                 CIFISP_DPRINT(CIFISP_DEBUG,
4039                         "flt time-left :%d\n",
4040                         *time_left);
4041         }
4042
4043         if (CIFISP_MODULE_IS_UPDATE(
4044                 isp_dev->other_cfgs.module_updates,
4045                 CIFISP_MODULE_CTK) &&
4046                 *time_left >= CIFISP_MODULE_CTK_PROC_TIME) {
4047                 /* update ctk config */
4048                 cifisp_ctk_config(isp_dev);
4049
4050                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_CTK))
4051                         cifisp_ctk_en(isp_dev);
4052                 else
4053                         cifisp_ctk_end(isp_dev);
4054
4055                 CIFISP_MODULE_CLR_UPDATE(
4056                         isp_dev->other_cfgs.module_updates,
4057                         CIFISP_MODULE_CTK);
4058
4059                 *time_left -= CIFISP_MODULE_CTK_PROC_TIME;
4060                 CIFISP_DPRINT(CIFISP_DEBUG,
4061                         "ctk time-left :%d\n",
4062                         *time_left);
4063         }
4064
4065         if (CIFISP_MODULE_IS_UPDATE(
4066                 isp_dev->other_cfgs.module_updates,
4067                 CIFISP_MODULE_GOC) &&
4068                 *time_left >= CIFISP_MODULE_GOC_PROC_TIME) {
4069                 /* update goc config */
4070                 cifisp_goc_config(isp_dev);
4071
4072                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_GOC))
4073                         cifisp_goc_en(isp_dev);
4074                 else
4075                         cifisp_goc_end(isp_dev);
4076
4077                 CIFISP_MODULE_CLR_UPDATE(
4078                         isp_dev->other_cfgs.module_updates,
4079                         CIFISP_MODULE_IE);
4080
4081                 *time_left -= CIFISP_MODULE_GOC_PROC_TIME;
4082                 CIFISP_DPRINT(CIFISP_DEBUG,
4083                         "goc time-left :%d\n",
4084                         *time_left);
4085         }
4086
4087         if (CIFISP_MODULE_IS_UPDATE(
4088                 isp_dev->other_cfgs.module_updates,
4089                 CIFISP_MODULE_CPROC) &&
4090                 *time_left >= CIFISP_MODULE_CPROC_PROC_TIME) {
4091                 /* update cprc config */
4092                 cifisp_cproc_config(
4093                         isp_dev,
4094                         isp_dev->quantization);
4095
4096                 cifisp_csm_config(isp_dev,
4097                         isp_dev->quantization);
4098
4099                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_CPROC))
4100                         cifisp_cproc_en(isp_dev);
4101                 else
4102                         cifisp_cproc_end(isp_dev);
4103
4104                 CIFISP_MODULE_CLR_UPDATE(
4105                         isp_dev->other_cfgs.module_updates,
4106                         CIFISP_MODULE_CPROC);
4107
4108                 *time_left -= CIFISP_MODULE_CPROC_PROC_TIME;
4109                 CIFISP_DPRINT(CIFISP_DEBUG,
4110                         "cproc time-left :%d\n",
4111                         *time_left);
4112         }
4113
4114         if (CIFISP_MODULE_IS_UPDATE(
4115                 isp_dev->other_cfgs.module_updates,
4116                 CIFISP_MODULE_IE) &&
4117                 *time_left >= CIFISP_MODULE_IE_PROC_TIME) {
4118                 /* update ie config */
4119                 cifisp_ie_config(isp_dev);
4120
4121                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_IE))
4122                         cifisp_ie_en(isp_dev);
4123                 else
4124                         cifisp_ie_end(isp_dev);
4125
4126                 CIFISP_MODULE_CLR_UPDATE(
4127                         isp_dev->other_cfgs.module_updates,
4128                         CIFISP_MODULE_IE);
4129
4130                 *time_left -= CIFISP_MODULE_IE_PROC_TIME;
4131                 CIFISP_DPRINT(CIFISP_DEBUG,
4132                         "ie time-left :%d\n",
4133                         *time_left);
4134         }
4135
4136         if (CIFISP_MODULE_IS_UPDATE(
4137                 isp_dev->other_cfgs.module_updates,
4138                 CIFISP_MODULE_DPF) &&
4139                 *time_left >= CIFISP_MODULE_DPF_TIME) {
4140                 /* update dpf  config */
4141                 cifisp_dpf_config(isp_dev);
4142
4143                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_DPF))
4144                         cifisp_dpf_en(isp_dev);
4145                 else
4146                         cifisp_dpf_end(isp_dev);
4147
4148                 CIFISP_MODULE_CLR_UPDATE(
4149                         isp_dev->other_cfgs.module_updates,
4150                         CIFISP_MODULE_DPF);
4151
4152                 *time_left -= CIFISP_MODULE_DPF_TIME;
4153                 CIFISP_DPRINT(CIFISP_DEBUG,
4154                         "dpf time-left :%d\n",
4155                         *time_left);
4156         }
4157
4158         if (CIFISP_MODULE_IS_UPDATE(
4159                 isp_dev->other_cfgs.module_updates,
4160                 CIFISP_MODULE_DPF_STRENGTH) &&
4161                 *time_left >= CIFISP_MODULE_DPF_STRENGTH_TIME) {
4162                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_DPF)) {
4163                         /* update dpf strength config */
4164                         cifisp_dpf_strength_config(isp_dev);
4165                         cifisp_dpf_en(isp_dev);
4166                 } else {
4167                         cifisp_dpf_end(isp_dev);
4168                 }
4169
4170                 CIFISP_MODULE_CLR_UPDATE(
4171                         isp_dev->other_cfgs.module_updates,
4172                         CIFISP_MODULE_DPF_STRENGTH);
4173
4174                 *time_left -= CIFISP_MODULE_DPF_STRENGTH_TIME;
4175                 CIFISP_DPRINT(CIFISP_DEBUG,
4176                         "dpf strength time-left :%d\n",
4177                         *time_left);
4178         }
4179
4180         config_chk = time_in > *time_left;
4181         if (config_chk)
4182                 cifisp_other_config_swap(isp_dev);
4183
4184         return config_chk;
4185 }
4186
4187 static inline bool cifisp_isp_isr_meas_config(
4188         struct cif_isp10_isp_dev *isp_dev,
4189         unsigned int *time_left)
4190 {
4191         unsigned int time_in = *time_left;
4192         bool config_chk;
4193         unsigned int *ens;
4194
4195         ens = &isp_dev->meas_cfgs.last_or_new->module_ens;
4196
4197         if (CIFISP_MODULE_IS_UPDATE(
4198                 isp_dev->meas_cfgs.module_updates,
4199                 CIFISP_MODULE_AWB)) {
4200                 /* update awb config */
4201                 cifisp_awb_meas_config(isp_dev);
4202
4203                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_AWB))
4204                         cifisp_awb_meas_en(isp_dev);
4205                 else
4206                         cifisp_awb_meas_end(isp_dev);
4207
4208                 CIFISP_MODULE_CLR_UPDATE(
4209                         isp_dev->meas_cfgs.module_updates,
4210                         CIFISP_MODULE_AWB);
4211                 *time_left -= CIFISP_MODULE_AWB_PROC_TIME;
4212         }
4213
4214         if (CIFISP_MODULE_IS_UPDATE(
4215                 isp_dev->meas_cfgs.module_updates,
4216                 CIFISP_MODULE_AFC)) {
4217                 /* update afc config */
4218                 cifisp_afc_config(isp_dev);
4219
4220                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_AFC))
4221                         cifisp_afc_en(isp_dev);
4222                 else
4223                         cifisp_afc_end(isp_dev);
4224
4225                 CIFISP_MODULE_CLR_UPDATE(
4226                         isp_dev->meas_cfgs.module_updates,
4227                         CIFISP_MODULE_AFC);
4228                 *time_left -= CIFISP_MODULE_AFC_PROC_TIME;
4229         }
4230
4231         if (CIFISP_MODULE_IS_UPDATE(
4232                 isp_dev->meas_cfgs.module_updates,
4233                 CIFISP_MODULE_HST)) {
4234                 /* update hst config */
4235                 cifisp_hst_config(isp_dev);
4236
4237                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_HST))
4238                         cifisp_hst_en(isp_dev);
4239                 else
4240                         cifisp_hst_end(isp_dev);
4241
4242                 CIFISP_MODULE_CLR_UPDATE(
4243                         isp_dev->meas_cfgs.module_updates,
4244                         CIFISP_MODULE_HST);
4245                 *time_left -= CIFISP_MODULE_HST_PROC_TIME;
4246         }
4247
4248         if (CIFISP_MODULE_IS_UPDATE(
4249                 isp_dev->meas_cfgs.module_updates,
4250                 CIFISP_MODULE_AEC)) {
4251                 /* update aec config */
4252                 cifisp_aec_config(isp_dev);
4253
4254                 if (CIFISP_MODULE_IS_EN(*ens, CIFISP_MODULE_AEC))
4255                         cifisp_aec_en(isp_dev);
4256                 else
4257                         cifisp_aec_end(isp_dev);
4258
4259                 CIFISP_MODULE_CLR_UPDATE(
4260                         isp_dev->meas_cfgs.module_updates,
4261                         CIFISP_MODULE_AEC);
4262                 *time_left -= CIFISP_MODULE_AEC_PROC_TIME;
4263         }
4264
4265         config_chk = time_in > *time_left;
4266         if (config_chk)
4267                 cifisp_meas_config_swap(isp_dev);
4268
4269         return config_chk;
4270 }
4271
4272 int cifisp_isp_isr(struct cif_isp10_isp_dev *isp_dev, u32 isp_mis)
4273 {
4274         unsigned int isp_mis_tmp = 0;
4275         struct cif_isp10_isp_readout_work *work;
4276         unsigned int time_left = isp_dev->v_blanking_us;
4277 #ifdef LOG_ISR_EXE_TIME
4278         ktime_t in_t = ktime_get();
4279 #endif
4280         if (isp_mis & (CIF_ISP_DATA_LOSS | CIF_ISP_PIC_SIZE_ERROR))
4281                 return 0;
4282
4283         if (isp_mis & CIF_ISP_FRAME) {
4284                 u32 isp_ris = cifisp_ioread32(CIF_ISP_RIS);
4285
4286                 cifisp_iowrite32(
4287                         (CIF_ISP_AWB_DONE | CIF_ISP_AFM_FIN |
4288                         CIF_ISP_EXP_END | CIF_ISP_HIST_MEASURE_RDY),
4289                         CIF_ISP_ICR);
4290                 isp_mis_tmp = cifisp_ioread32(CIF_ISP_MIS);
4291                 if (isp_mis_tmp &
4292                         (CIF_ISP_AWB_DONE | CIF_ISP_AFM_FIN |
4293                         CIF_ISP_EXP_END | CIF_ISP_HIST_MEASURE_RDY))
4294                         CIFISP_DPRINT(CIFISP_ERROR,
4295                                       "isp icr 3A info err: 0x%x\n",
4296                                       isp_mis_tmp);
4297
4298                 CIFISP_DPRINT(CIFISP_DEBUG, "isp_ris 0x%x\n", isp_ris);
4299
4300                 if (((isp_dev->meas_cfgs.module_updates &
4301                         (CIFISP_MODULE_AWB |
4302                         CIFISP_MODULE_AEC |
4303                         CIFISP_MODULE_AFC)) == 0) &&
4304                         isp_dev->active_meas &&
4305                         ((isp_dev->active_meas & isp_ris) ==
4306                         isp_dev->active_meas)) {
4307                         work = (struct cif_isp10_isp_readout_work *)
4308                                 kmalloc(sizeof(
4309                                 struct cif_isp10_isp_readout_work),
4310                                 GFP_ATOMIC);
4311                         if (work) {
4312                                 INIT_WORK((struct work_struct *)work,
4313                                         cifisp_isp_readout_work);
4314                                 work->readout = CIF_ISP10_ISP_READOUT_MEAS;
4315                                 work->isp_dev = isp_dev;
4316                                 work->frame_id = isp_dev->frame_id;
4317                                 if (!queue_work(isp_dev->readout_wq,
4318                                         (struct work_struct *)work)) {
4319                                         CIFISP_DPRINT(CIFISP_ERROR,
4320                                         "Could not schedule work\n");
4321                                         kfree((void *)work);
4322                                 }
4323                         } else {
4324                                 CIFISP_DPRINT(CIFISP_ERROR,
4325                                 "Could not allocate work\n");
4326                         }
4327                 }
4328
4329                 /*
4330                  * Then update  changed configs. Some of them involve
4331                  * lot of register writes. Do those only one per frame.
4332                  * Do the updates in the order of the processing flow.
4333                  */
4334                 spin_lock(&isp_dev->config_lock);
4335                 if (cifisp_isp_isr_other_config(isp_dev, &time_left) == false)
4336                         cifisp_isp_isr_meas_config(isp_dev, &time_left);
4337                 spin_unlock(&isp_dev->config_lock);
4338
4339                 cifisp_dump_reg(isp_dev, CIFISP_DEBUG);
4340         }
4341 #ifdef LOG_ISR_EXE_TIME
4342         if (isp_mis & (CIF_ISP_EXP_END | CIF_ISP_AWB_DONE |
4343                 CIF_ISP_FRAME | CIF_ISP_HIST_MEASURE_RDY)) {
4344                 unsigned int diff_us =
4345                     ktime_to_us(ktime_sub(ktime_get(), in_t));
4346
4347                 if (diff_us > g_longest_isr_time)
4348                         g_longest_isr_time = diff_us;
4349
4350                 pr_info("isp_isr time %d %d\n", diff_us, g_longest_isr_time);
4351         }
4352 #endif
4353
4354         return 0;
4355 }
4356
4357 static void cifisp_param_dump(const void *config, unsigned int module)
4358 {
4359 #ifdef CIFISP_DEBUG_PARAM
4360         switch (module) {
4361         case CIFISP_MODULE_AWB_GAIN:{
4362                         struct cifisp_awb_gain_config *pconfig =
4363                             (struct cifisp_awb_gain_config *)config;
4364                         CIFISP_DPRINT(CIFISP_DEBUG,
4365                                       "#### %s: AWB Gain Parameters - BEGIN ####\n",
4366                                       ISP_VDEV_NAME);
4367                         CIFISP_DPRINT(CIFISP_DEBUG, "g_g: %d\n",
4368                                       pconfig->gain_green_r);
4369                         CIFISP_DPRINT(CIFISP_DEBUG, "g_b: %d\n",
4370                                       pconfig->gain_green_b);
4371                         CIFISP_DPRINT(CIFISP_DEBUG, "r: %d\n",
4372                                       pconfig->gain_red);
4373                         CIFISP_DPRINT(CIFISP_DEBUG, "b: %d\n",
4374                                       pconfig->gain_blue);
4375                         CIFISP_DPRINT(CIFISP_DEBUG,
4376                                       "#### %s: AWB Gain Parameters - END ####\n",
4377                                       ISP_VDEV_NAME);
4378                 }
4379                 break;
4380         case CIFISP_MODULE_DPCC:{
4381                 }
4382                 break;
4383
4384         case CIFISP_MODULE_BLS:{
4385                         struct cifisp_bls_config *pconfig =
4386                             (struct cifisp_bls_config *)config;
4387                         struct cifisp_bls_fixed_val *pval = &pconfig->fixed_val;
4388
4389                         CIFISP_DPRINT(CIFISP_DEBUG,
4390                                       "#### %s: BLS Parameters - BEGIN ####\n",
4391                                       ISP_VDEV_NAME);
4392                         CIFISP_DPRINT(CIFISP_DEBUG, " enable_auto: %d\n",
4393                                       pconfig->enable_auto);
4394                         CIFISP_DPRINT(CIFISP_DEBUG, " en_windows: %d\n",
4395                                       pconfig->en_windows);
4396                         CIFISP_DPRINT(CIFISP_DEBUG,
4397                                       " bls_window1.h_offs: %d\n",
4398                                       pconfig->bls_window1.h_offs);
4399                         CIFISP_DPRINT(CIFISP_DEBUG,
4400                                       " bls_window1.v_offs: %d\n",
4401                                       pconfig->bls_window1.v_offs);
4402                         CIFISP_DPRINT(CIFISP_DEBUG,
4403                                       " bls_window1.h_size: %d\n",
4404                                       pconfig->bls_window1.h_size);
4405                         CIFISP_DPRINT(CIFISP_DEBUG,
4406                                       " bls_window1.v_size: %d\n",
4407                                       pconfig->bls_window1.v_size);
4408                         CIFISP_DPRINT(CIFISP_DEBUG,
4409                                       " bls_window2.h_offs: %d\n",
4410                                       pconfig->bls_window2.h_offs);
4411                         CIFISP_DPRINT(CIFISP_DEBUG,
4412                                       " bls_window2.v_offs: %d\n",
4413                                       pconfig->bls_window2.v_offs);
4414                         CIFISP_DPRINT(CIFISP_DEBUG,
4415                                       " bls_window2.h_size: %d\n",
4416                                       pconfig->bls_window2.h_size);
4417                         CIFISP_DPRINT(CIFISP_DEBUG,
4418                                       " bls_window2.v_size: %d\n",
4419                                       pconfig->bls_window2.v_size);
4420                         CIFISP_DPRINT(CIFISP_DEBUG, " bls_samples: %d\n",
4421                                       pconfig->bls_samples);
4422                         CIFISP_DPRINT(CIFISP_DEBUG, " fixed_A: %d\n",
4423                                       pval->fixed_a);
4424                         CIFISP_DPRINT(CIFISP_DEBUG, " fixed_B: %d\n",
4425                                       pval->fixed_b);
4426                         CIFISP_DPRINT(CIFISP_DEBUG, " fixed_C: %d\n",
4427                                       pval->fixed_c);
4428                         CIFISP_DPRINT(CIFISP_DEBUG, " fixed_D: %d\n",
4429                                       pval->fixed_d);
4430                         CIFISP_DPRINT(CIFISP_DEBUG,
4431                                       "#### %s: BLS Parameters - END ####\n",
4432                                       ISP_VDEV_NAME);
4433                 } break;
4434         case CIFISP_MODULE_LSC:{
4435                         CIFISP_DPRINT(CIFISP_DEBUG,
4436                                       "#### LSC Parameters - BEGIN ####\n");
4437                         CIFISP_DPRINT(CIFISP_DEBUG,
4438                                       "#### LSC Parameters - END ####\n");
4439                 }
4440                 break;
4441         case CIFISP_MODULE_FLT:{
4442                         struct cifisp_flt_config *pconfig =
4443                             (struct cifisp_flt_config *)config;
4444                         CIFISP_DPRINT(CIFISP_DEBUG,
4445                                       "#### %s: FLT Parameters - BEGIN ####\n",
4446                                       ISP_VDEV_NAME);
4447                         CIFISP_DPRINT(CIFISP_DEBUG,
4448                                       " flt_mask_sharp0: %d\n",
4449                                       pconfig->flt_mask_sharp0);
4450                         CIFISP_DPRINT(CIFISP_DEBUG,
4451                                       " flt_mask_sharp1: %d\n",
4452                                       pconfig->flt_mask_sharp1);
4453                         CIFISP_DPRINT(CIFISP_DEBUG, " flt_mask_diag: %d\n",
4454                                       pconfig->flt_mask_diag);
4455                         CIFISP_DPRINT(CIFISP_DEBUG,
4456                                       " flt_mask_blur_max: %d\n",
4457                                       pconfig->flt_mask_blur_max);
4458                         CIFISP_DPRINT(CIFISP_DEBUG, " flt_mask_blur: %d\n",
4459                                       pconfig->flt_mask_blur);
4460                         CIFISP_DPRINT(CIFISP_DEBUG, " flt_mask_lin: %d\n",
4461                                       pconfig->flt_mask_lin);
4462                         CIFISP_DPRINT(CIFISP_DEBUG, " flt_mask_orth: %d\n",
4463                                       pconfig->flt_mask_orth);
4464                         CIFISP_DPRINT(CIFISP_DEBUG,
4465                                       " flt_mask_v_diag: %d\n",
4466                                       pconfig->flt_mask_v_diag);
4467                         CIFISP_DPRINT(CIFISP_DEBUG,
4468                                       " flt_mask_h_diag: %d\n",
4469                                       pconfig->flt_mask_h_diag);
4470                         CIFISP_DPRINT(CIFISP_DEBUG,
4471                                       " flt_lum_weight: %d\n",
4472                                       pconfig->flt_lum_weight);
4473                         CIFISP_DPRINT(CIFISP_DEBUG, " flt_blur_th0: %d\n",
4474                                       pconfig->flt_blur_th0);
4475                         CIFISP_DPRINT(CIFISP_DEBUG, " flt_blur_th1: %d\n",
4476                                       pconfig->flt_blur_th1);
4477                         CIFISP_DPRINT(CIFISP_DEBUG, " flt_sharp0_th: %d\n",
4478                                       pconfig->flt_sharp0_th);
4479                         CIFISP_DPRINT(CIFISP_DEBUG, " flt_sharp1_th: %d\n",
4480                                       pconfig->flt_sharp1_th);
4481                         CIFISP_DPRINT(CIFISP_DEBUG,
4482                                       " flt_chrom_h_mode: %d\n",
4483                                       pconfig->flt_chrom_h_mode);
4484                         CIFISP_DPRINT(CIFISP_DEBUG,
4485                                       " flt_chrom_v_mode: %d\n",
4486                                       pconfig->flt_chrom_v_mode);
4487                         CIFISP_DPRINT(CIFISP_DEBUG,
4488                                       " flt_diag_sharp_mode: %d\n",
4489                                       pconfig->flt_diag_sharp_mode);
4490                         CIFISP_DPRINT(CIFISP_DEBUG, " flt_mode: %d\n",
4491                                       pconfig->flt_mode);
4492                         CIFISP_DPRINT(CIFISP_DEBUG,
4493                                       "#### %s: FLT Parameters - END ####\n",
4494                                       ISP_VDEV_NAME);
4495                 } break;
4496
4497         case CIFISP_MODULE_BDM:{
4498                         struct cifisp_bdm_config *pconfig =
4499                             (struct cifisp_bdm_config *)config;
4500                         CIFISP_DPRINT(CIFISP_DEBUG,
4501                                       "#### %s: BDM Parameters - BEGIN ####\n",
4502                                       ISP_VDEV_NAME);
4503                         CIFISP_DPRINT(CIFISP_DEBUG, " demosaic_th: %d\n",
4504                                       pconfig->demosaic_th);
4505                         CIFISP_DPRINT(CIFISP_DEBUG,
4506                                       "#### %s: BDM Parameters - END ####\n",
4507                                       ISP_VDEV_NAME);
4508                 } break;
4509
4510         case CIFISP_MODULE_SDG:{
4511                         struct cifisp_sdg_config *pconfig =
4512                             (struct cifisp_sdg_config *)config;
4513                         unsigned int i;
4514
4515                         CIFISP_DPRINT(CIFISP_DEBUG,
4516                                       "#### %s: SDG Parameters - BEGIN ####\n",
4517                                       ISP_VDEV_NAME);
4518                         CIFISP_DPRINT(CIFISP_DEBUG,
4519                                       " RED -Curve parameters\n");
4520                         for (i = 0; i < CIFISP_DEGAMMA_CURVE_SIZE; i++) {
4521                                 CIFISP_DPRINT(CIFISP_DEBUG,
4522                                         " gamma_y[%d]: %d\n",
4523                                         pconfig->curve_r.gamma_y[i]);
4524                         }
4525                         CIFISP_DPRINT(CIFISP_DEBUG,
4526                                       " GREEN -Curve parameters\n");
4527                         for (i = 0; i < CIFISP_DEGAMMA_CURVE_SIZE; i++) {
4528                                 CIFISP_DPRINT(CIFISP_DEBUG,
4529                                         " gamma_y[%d]: %d\n",
4530                                         pconfig->curve_g.gamma_y[i]);
4531                         }
4532                         CIFISP_DPRINT(CIFISP_DEBUG,
4533                                       " BLUE -Curve parameters\n");
4534                         for (i = 0; i < CIFISP_DEGAMMA_CURVE_SIZE; i++) {
4535                                 CIFISP_DPRINT(CIFISP_DEBUG,
4536                                         " gamma_y[%d]: %d\n",
4537                                         pconfig->curve_b.gamma_y[i]);
4538                         }
4539                         CIFISP_DPRINT(CIFISP_DEBUG,
4540                                       "#### %s: SDG Parameters - END ####\n",
4541                                       ISP_VDEV_NAME);
4542                 } break;
4543
4544         case CIFISP_MODULE_GOC:{
4545                         CIFISP_DPRINT(CIFISP_DEBUG,
4546                                       "#### %s: GOC Parameters - BEGIN ####\n",
4547                                       ISP_VDEV_NAME);
4548                         CIFISP_DPRINT(CIFISP_DEBUG,
4549                                       "#### %s: GOC Parameters - END ####\n",
4550                                       ISP_VDEV_NAME);
4551                 } break;
4552
4553         case CIFISP_MODULE_CTK:{
4554                         struct cifisp_ctk_config *pconfig =
4555                             (struct cifisp_ctk_config *)config;
4556                         CIFISP_DPRINT(CIFISP_DEBUG,
4557                                       "#### %s: CTK Parameters - BEGIN ####\n",
4558                                       ISP_VDEV_NAME);
4559                         CIFISP_DPRINT(CIFISP_DEBUG, " coeff0: %d\n",
4560                                       pconfig->coeff0);
4561                         CIFISP_DPRINT(CIFISP_DEBUG, " coeff1: %d\n",
4562                                       pconfig->coeff1);
4563                         CIFISP_DPRINT(CIFISP_DEBUG, " coeff2: %d\n",
4564                                       pconfig->coeff2);
4565                         CIFISP_DPRINT(CIFISP_DEBUG, " coeff3: %d\n",
4566                                       pconfig->coeff3);
4567                         CIFISP_DPRINT(CIFISP_DEBUG, " coeff4: %d\n",
4568                                       pconfig->coeff4);
4569                         CIFISP_DPRINT(CIFISP_DEBUG, " coeff5: %d\n",
4570                                       pconfig->coeff5);
4571                         CIFISP_DPRINT(CIFISP_DEBUG, " coeff6: %d\n",
4572                                       pconfig->coeff6);
4573                         CIFISP_DPRINT(CIFISP_DEBUG, " coeff7: %d\n",
4574                                       pconfig->coeff7);
4575                         CIFISP_DPRINT(CIFISP_DEBUG, " coeff8: %d\n",
4576                                       pconfig->coeff8);
4577                         CIFISP_DPRINT(CIFISP_DEBUG, " ct_offset_r: %d\n",
4578                                       pconfig->ct_offset_r);
4579                         CIFISP_DPRINT(CIFISP_DEBUG, " ct_offset_g: %d\n",
4580                                       pconfig->ct_offset_g);
4581                         CIFISP_DPRINT(CIFISP_DEBUG, " ct_offset_b: %d\n",
4582                                       pconfig->ct_offset_b);
4583                         CIFISP_DPRINT(CIFISP_DEBUG,
4584                                       "#### %s: CTK Parameters - END ####\n",
4585                                       ISP_VDEV_NAME);
4586                 } break;
4587
4588         case CIFISP_MODULE_AWB:{
4589                         struct cifisp_awb_meas_config *pconfig =
4590                             (struct cifisp_awb_meas_config *)config;
4591                         CIFISP_DPRINT(CIFISP_DEBUG,
4592                                       "#### %s: AWB Parameters - BEGIN ####\n",
4593                                       ISP_VDEV_NAME);
4594                         CIFISP_DPRINT(CIFISP_DEBUG, " awb_mode: %d\n",
4595                                       pconfig->awb_mode);
4596                         CIFISP_DPRINT(CIFISP_DEBUG, " max_y: %d\n",
4597                                       pconfig->max_y);
4598                         CIFISP_DPRINT(CIFISP_DEBUG, " min_y: %d\n",
4599                                       pconfig->min_y);
4600                         CIFISP_DPRINT(CIFISP_DEBUG, " max_csum: %d\n",
4601                                       pconfig->max_csum);
4602                         CIFISP_DPRINT(CIFISP_DEBUG, " min_c: %d\n",
4603                                       pconfig->min_c);
4604                         CIFISP_DPRINT(CIFISP_DEBUG, " frames: %d\n",
4605                                       pconfig->frames);
4606                         CIFISP_DPRINT(CIFISP_DEBUG, " awb_ref_cr: %d\n",
4607                                       pconfig->awb_ref_cr);
4608                         CIFISP_DPRINT(CIFISP_DEBUG, " awb_ref_cb: %d\n",
4609                                       pconfig->awb_ref_cb);
4610                         CIFISP_DPRINT(CIFISP_DEBUG, " gb_sat: %d\n",
4611                                       pconfig->gb_sat);
4612                         CIFISP_DPRINT(CIFISP_DEBUG, " gr_sat: %d\n",
4613                                       pconfig->gr_sat);
4614                         CIFISP_DPRINT(CIFISP_DEBUG, " r_sat: %d\n",
4615                                       pconfig->b_sat);
4616                         CIFISP_DPRINT(CIFISP_DEBUG, " grid_h_dim: %d\n",
4617                                       pconfig->grid_h_dim);
4618                         CIFISP_DPRINT(CIFISP_DEBUG, " grid_v_dim: %d\n",
4619                                       pconfig->grid_v_dim);
4620                         CIFISP_DPRINT(CIFISP_DEBUG, " grid_h_dist: %d\n",
4621                                       pconfig->grid_h_dist);
4622                         CIFISP_DPRINT(CIFISP_DEBUG, " grid_v_dist: %d\n",
4623                                       pconfig->grid_v_dist);
4624                         CIFISP_DPRINT(CIFISP_DEBUG,
4625                                       " enable_ymax_cmp: %d\n",
4626                                       pconfig->enable_ymax_cmp);
4627                         CIFISP_DPRINT(CIFISP_DEBUG, " rgb_meas_pnt: %d\n",
4628                                       pconfig->rgb_meas_pnt);
4629                         CIFISP_DPRINT(CIFISP_DEBUG, " AWB Window size\n");
4630                         CIFISP_DPRINT(CIFISP_DEBUG, " h_offs: %d\n",
4631                                       pconfig->awb_wnd.h_offs);
4632                         CIFISP_DPRINT(CIFISP_DEBUG, " v_offs: %d\n",
4633                                       pconfig->awb_wnd.v_offs);
4634                         CIFISP_DPRINT(CIFISP_DEBUG, " h_size: %d\n",
4635                                       pconfig->awb_wnd.h_size);
4636                         CIFISP_DPRINT(CIFISP_DEBUG, " v_size: %d\n",
4637                                       pconfig->awb_wnd.v_size);
4638                         CIFISP_DPRINT(CIFISP_DEBUG,
4639                                       "#### %s: AWB Parameters - END ####\n",
4640                                       ISP_VDEV_NAME);
4641                 } break;
4642
4643         case CIFISP_MODULE_HST:{
4644                         struct cifisp_hst_config *pconfig =
4645                             (struct cifisp_hst_config *)config;
4646                         CIFISP_DPRINT(CIFISP_DEBUG,
4647                                       "#### %s: HST Parameters - BEGIN ####\n",
4648                                       ISP_VDEV_NAME);
4649                         CIFISP_DPRINT(CIFISP_DEBUG, " mode: %d\n",
4650                                       pconfig->mode);
4651                         CIFISP_DPRINT(CIFISP_DEBUG,
4652                                       " histogram_predivider: %d\n",
4653                                       pconfig->histogram_predivider);
4654                         CIFISP_DPRINT(CIFISP_DEBUG, " HST Window size\n");
4655                         CIFISP_DPRINT(CIFISP_DEBUG, " h_offs: %d\n",
4656                                       pconfig->meas_window.h_offs);
4657                         CIFISP_DPRINT(CIFISP_DEBUG, " v_offs: %d\n",
4658                                       pconfig->meas_window.v_offs);
4659                         CIFISP_DPRINT(CIFISP_DEBUG, " h_size: %d\n",
4660                                       pconfig->meas_window.h_size);
4661                         CIFISP_DPRINT(CIFISP_DEBUG, " v_size: %d\n",
4662                                       pconfig->meas_window.v_size);
4663                         CIFISP_DPRINT(CIFISP_DEBUG,
4664                                       "#### %s: HST Parameters - END ####\n",
4665                                       ISP_VDEV_NAME);
4666
4667                 } break;
4668
4669         case CIFISP_MODULE_AEC:{
4670                         struct cifisp_aec_config *pconfig =
4671                             (struct cifisp_aec_config *)config;
4672                         CIFISP_DPRINT(CIFISP_DEBUG,
4673                                       "#### %s: AEC Parameters - BEGIN ####\n",
4674                                       ISP_VDEV_NAME);
4675                         CIFISP_DPRINT(CIFISP_DEBUG, " autostop: %d\n",
4676                                       pconfig->autostop);
4677                         CIFISP_DPRINT(CIFISP_DEBUG, " AEC Window size\n");
4678                         CIFISP_DPRINT(CIFISP_DEBUG, " h_offs: %d\n",
4679                                       pconfig->meas_window.h_offs);
4680                         CIFISP_DPRINT(CIFISP_DEBUG, " v_offs: %d\n",
4681                                       pconfig->meas_window.v_offs);
4682                         CIFISP_DPRINT(CIFISP_DEBUG, " h_size: %d\n",
4683                                       pconfig->meas_window.h_size);
4684                         CIFISP_DPRINT(CIFISP_DEBUG, " v_size: %d\n",
4685                                       pconfig->meas_window.v_size);
4686                         CIFISP_DPRINT(CIFISP_DEBUG,
4687                                       "#### %s: AEC Parameters - END ####\n",
4688                                       ISP_VDEV_NAME);
4689                 } break;
4690
4691         case CIFISP_MODULE_CPROC:{
4692                         struct cifisp_cproc_config *pconfig =
4693                             (struct cifisp_cproc_config *)config;
4694                         CIFISP_DPRINT(CIFISP_DEBUG,
4695                                       "#### %s: CPROC Parameters - BEGIN ####\n",
4696                                       ISP_VDEV_NAME);
4697                         CIFISP_DPRINT(CIFISP_DEBUG, " contrast: %d\n",
4698                                       pconfig->contrast);
4699                         CIFISP_DPRINT(CIFISP_DEBUG, " hue: %d\n",
4700                                       pconfig->hue);
4701                         CIFISP_DPRINT(CIFISP_DEBUG, " sat: %d\n",
4702                                       pconfig->sat);
4703                         CIFISP_DPRINT(CIFISP_DEBUG, " brightness: %d\n",
4704                                       pconfig->brightness);
4705                         CIFISP_DPRINT(CIFISP_DEBUG,
4706                                       "#### %s: CPROC Parameters - END ####\n",
4707                                       ISP_VDEV_NAME);
4708                 } break;
4709         case CIFISP_MODULE_YCFLT:{
4710                         struct cifisp_ycflt_config *pconfig =
4711                             (struct cifisp_ycflt_config *)config;
4712                         CIFISP_DPRINT(CIFISP_DEBUG,
4713                                       "#### %s: YCFLT Parameters - BEGIN ####\n",
4714                                       ISP_VDEV_NAME);
4715                         CIFISP_DPRINT(CIFISP_DEBUG, " chr_ss_ctrl: %d\n",
4716                         CIFISP_DPRINT(CIFISP_DEBUG, " ctrl: %d\n",
4717                                         pconfig->ctrl);
4718                         CIFISP_DPRINT(CIFISP_DEBUG, " chr_ss_ctrl: %d\n",
4719                                       pconfig->chr_ss_ctrl);
4720                         CIFISP_DPRINT(CIFISP_DEBUG, " chr_ss_fac: %d\n",
4721                                       pconfig->chr_ss_fac);
4722                         CIFISP_DPRINT(CIFISP_DEBUG, " chr_ss_offs: %d\n",
4723                                       pconfig->chr_ss_offs);
4724                         CIFISP_DPRINT(CIFISP_DEBUG, " chr_nr_ctrl: %d\n",
4725                                       pconfig->chr_nr_ctrl);
4726                         CIFISP_DPRINT(CIFISP_DEBUG,
4727                                       " lum_eenr_edge_gain: %d\n",
4728                                       pconfig->lum_eenr_edge_gain);
4729                         CIFISP_DPRINT(CIFISP_DEBUG,
4730                                       " lum_eenr_corner_gain: %d\n",
4731                                       pconfig->lum_eenr_corner_gain);
4732                         CIFISP_DPRINT(CIFISP_DEBUG,
4733                                       " lum_eenr_fc_crop_neg: %d\n",
4734                                       pconfig->lum_eenr_fc_crop_neg);
4735                         CIFISP_DPRINT(CIFISP_DEBUG,
4736                                       " lum_eenr_fc_crop_pos: %d\n",
4737                                       pconfig->lum_eenr_fc_crop_pos);
4738                         CIFISP_DPRINT(CIFISP_DEBUG,
4739                                       " lum_eenr_fc_gain_neg: %d\n",
4740                                       pconfig->lum_eenr_fc_gain_neg);
4741                         CIFISP_DPRINT(CIFISP_DEBUG,
4742                                       " lum_eenr_fc_gain_pos: %d\n",
4743                                       pconfig->lum_eenr_fc_gain_pos);
4744                         CIFISP_DPRINT(CIFISP_DEBUG,
4745                                       "#### %s: YCFLT Parameters - END ####\n",
4746                                       ISP_VDEV_NAME);
4747                         break;
4748                 }
4749         case CIFISP_MODULE_AFC:{
4750                         struct cifisp_afc_config *pconfig =
4751                             (struct cifisp_afc_config *)config;
4752                         CIFISP_DPRINT(CIFISP_DEBUG,
4753                                       "#### %s: AFC Parameters - BEGIN ####\n",
4754                                       ISP_VDEV_NAME);
4755                         CIFISP_DPRINT(CIFISP_DEBUG,
4756                                       " window A %d %d %d %d\n",
4757                                       pconfig->afm_win[0].h_offs,
4758                                       pconfig->afm_win[0].v_offs,
4759                                       pconfig->afm_win[0].h_size,
4760                                       pconfig->afm_win[0].v_size);
4761                         CIFISP_DPRINT(CIFISP_DEBUG,
4762                                       " window B %d %d %d %d\n",
4763                                       pconfig->afm_win[1].h_offs,
4764                                       pconfig->afm_win[1].v_offs,
4765                                       pconfig->afm_win[1].h_size,
4766                                       pconfig->afm_win[1].v_size);
4767                         CIFISP_DPRINT(CIFISP_DEBUG,
4768                                       " window C %d %d %d %d\n",
4769                                       pconfig->afm_win[2].h_offs,
4770                                       pconfig->afm_win[2].v_offs,
4771                                       pconfig->afm_win[2].h_size,
4772                                       pconfig->afm_win[2].v_size);
4773                         CIFISP_DPRINT(CIFISP_DEBUG, " thres: %d\n",
4774                                       pconfig->thres);
4775                         CIFISP_DPRINT(CIFISP_DEBUG, " var_shift: %d\n",
4776                                       pconfig->var_shift);
4777                         break;
4778                 }
4779         case CIFISP_MODULE_IE: {
4780                         struct cifisp_ie_config *pconfig =
4781                             (struct cifisp_ie_config *)config;
4782                         CIFISP_DPRINT(CIFISP_DEBUG,
4783                                 "effect %d, %x, %x, %x, %x, %x, %x %d\n",
4784                                 pconfig->effect, pconfig->color_sel,
4785                                 pconfig->eff_mat_1, pconfig->eff_mat_2,
4786                                 pconfig->eff_mat_3, pconfig->eff_mat_4,
4787                                 pconfig->eff_mat_5, pconfig->eff_tint);
4788                         break;
4789                 }
4790         default:
4791                 CIFISP_DPRINT(CIFISP_DEBUG,
4792                 "####%s: Invalid Module ID ####\n", ISP_VDEV_NAME);
4793                 break;
4794         }
4795 #endif
4796 }
4797
4798 #ifdef LOG_CAPTURE_PARAMS
4799 static void cifisp_reg_dump_capture(const struct cif_isp10_isp_dev *isp_dev)
4800 {
4801         memset(&g_last_capture_config, 0, sizeof(g_last_capture_config));
4802
4803         if (isp_dev->bls_en) {
4804                 g_last_capture_config.bls.fixed_val.fixed_a =
4805                     cifisp_ioread32(CIF_ISP_BLS_A_FIXED);
4806                 g_last_capture_config.bls.fixed_val.fixed_b =
4807                     cifisp_ioread32(CIF_ISP_BLS_B_FIXED);
4808                 g_last_capture_config.bls.fixed_val.fixed_c =
4809                     cifisp_ioread32(CIF_ISP_BLS_C_FIXED);
4810                 g_last_capture_config.bls.fixed_val.fixed_d =
4811                     cifisp_ioread32(CIF_ISP_BLS_D_FIXED);
4812         }
4813
4814         if (isp_dev->lsc_en)
4815                 cifisp_lsc_config_read(isp_dev, &g_last_capture_config.lsc);
4816
4817         if (isp_dev->flt_en)
4818                 cifisp_flt_config_read(isp_dev, &g_last_capture_config.flt);
4819
4820         if (isp_dev->bdm_en)
4821                 g_last_capture_config.bdm.demosaic_th =
4822                     cifisp_ioread32(CIF_ISP_DEMOSAIC);
4823
4824         if (isp_dev->sdg_en)
4825                 cifisp_sdg_config_read(isp_dev, &g_last_capture_config.sdg);
4826
4827         if (isp_dev->goc_en)
4828                 cifisp_goc_config_read(isp_dev, &g_last_capture_config.goc);
4829
4830         if (isp_dev->ctk_en)
4831                 cifisp_ctk_config_read(isp_dev, &g_last_capture_config.ctk);
4832
4833         if (isp_dev->awb_meas_en)
4834                 cifisp_awb_meas_config_read(isp_dev,
4835                                             &g_last_capture_config.awb_meas);
4836
4837         if (isp_dev->awb_gain_en)
4838                 cifisp_awb_gain_config_read(isp_dev,
4839                                             &g_last_capture_config.awb_gain);
4840
4841         if (isp_dev->cproc_en)
4842                 cifisp_cproc_config_read(isp_dev, &g_last_capture_config.cproc);
4843 }
4844 #endif
4845
4846 #ifdef CIFISP_DEBUG_REG
4847 static void cifisp_reg_dump(const struct cif_isp10_isp_dev *isp_dev,
4848                             unsigned int module, int level)
4849 {
4850         switch (module) {
4851         case CIFISP_MODULE_DPCC:
4852                 CIFISP_DPRINT(level, "#### BPC Registers - BEGIN ####\n");
4853                 CIFISP_DPRINT(level, "#### BPC Registers - END ####\n");
4854                 break;
4855         case CIFISP_MODULE_BLS:
4856                 CIFISP_DPRINT(level, "#### BLS Registers - BEGIN ####\n");
4857                 CIFISP_DPRINT(level, " CIF_ISP_BLS_CTRL: %d\n",
4858                               cifisp_ioread32(CIF_ISP_BLS_CTRL));
4859                 CIFISP_DPRINT(level, " CIF_ISP_BLS_SAMPLES: %d\n",
4860                               cifisp_ioread32(CIF_ISP_BLS_SAMPLES));
4861                 CIFISP_DPRINT(level, " CIF_ISP_BLS_H1_START: %d\n",
4862                               cifisp_ioread32(CIF_ISP_BLS_H1_START));
4863                 CIFISP_DPRINT(level, " CIF_ISP_BLS_H1_STOP: %d\n",
4864                               cifisp_ioread32(CIF_ISP_BLS_H1_STOP));
4865                 CIFISP_DPRINT(level, " CIF_ISP_BLS_H1_START: %d\n",
4866                               cifisp_ioread32(CIF_ISP_BLS_H1_START));
4867                 CIFISP_DPRINT(level, " CIF_ISP_BLS_V1_START: %d\n",
4868                               cifisp_ioread32(CIF_ISP_BLS_V1_START));
4869                 CIFISP_DPRINT(level, " CIF_ISP_BLS_V1_STOP: %d\n",
4870                               cifisp_ioread32(CIF_ISP_BLS_V1_STOP));
4871                 CIFISP_DPRINT(level, " CIF_ISP_BLS_H2_START: %d\n",
4872                               cifisp_ioread32(CIF_ISP_BLS_H2_START));
4873                 CIFISP_DPRINT(level, " CIF_ISP_BLS_H2_STOP: %d\n",
4874                               cifisp_ioread32(CIF_ISP_BLS_H2_STOP));
4875                 CIFISP_DPRINT(level, " CIF_ISP_BLS_V2_START: %d\n",
4876                               cifisp_ioread32(CIF_ISP_BLS_V2_START));
4877                 CIFISP_DPRINT(level, " CIF_ISP_BLS_V2_STOP: %d\n",
4878                               cifisp_ioread32(CIF_ISP_BLS_V2_STOP));
4879                 CIFISP_DPRINT(level, "#### BLS Registers - END ####\n");
4880                 break;
4881         case CIFISP_MODULE_LSC:
4882                 CIFISP_DPRINT(level, "#### LSC Registers - BEGIN ####\n");
4883                 CIFISP_DPRINT(level, "#### LSC Registers - END ####\n");
4884                 break;
4885         case CIFISP_MODULE_FLT:{
4886                         CIFISP_DPRINT(level,
4887                                 "#### %s: FLT Registers - BEGIN ####\n",
4888                                 ISP_VDEV_NAME);
4889                         CIFISP_DPRINT(level,
4890                                 " CIF_ISP_FILT_MODE: %d\n",
4891                                 cifisp_ioread32(CIF_ISP_FILT_MODE));
4892                         CIFISP_DPRINT(level,
4893                                 " CIF_ISP_FILT_LUM_WEIGHT: %d\n",
4894                                 cifisp_ioread32(CIF_ISP_FILT_LUM_WEIGHT));
4895                         CIFISP_DPRINT(level,
4896                                 "#### %s: FLT Registers - END ####\n",
4897                                 ISP_VDEV_NAME);
4898                 }
4899                 break;
4900
4901         case CIFISP_MODULE_BDM:{
4902                         CIFISP_DPRINT(level,
4903                                       "#### %s: BDM Registers - BEGIN ####\n",
4904                                       ISP_VDEV_NAME);
4905                         CIFISP_DPRINT(level, " CIF_ISP_DEMOSAIC: %d\n",
4906                                       cifisp_ioread32(CIF_ISP_DEMOSAIC));
4907                         CIFISP_DPRINT(level,
4908                                       "#### %s: BDM Registers - END ####\n",
4909                                       ISP_VDEV_NAME);
4910                 }
4911                 break;
4912
4913         case CIFISP_MODULE_SDG:{
4914                         CIFISP_DPRINT(level,
4915                                       "#### %s: SDG Registers - BEGIN ####\n",
4916                                       ISP_VDEV_NAME);
4917                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_DX_LO: %d\n",
4918                                       cifisp_ioread32(CIF_ISP_GAMMA_DX_LO));
4919                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_DX_HI: %d\n",
4920                                       cifisp_ioread32(CIF_ISP_GAMMA_DX_HI));
4921
4922                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y0: %d\n",
4923                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y0));
4924                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y1: %d\n",
4925                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y1));
4926                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y2: %d\n",
4927                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y2));
4928                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y3: %d\n",
4929                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y3));
4930                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y4: %d\n",
4931                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y4));
4932                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y5: %d\n",
4933                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y5));
4934                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y6: %d\n",
4935                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y6));
4936                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y7: %d\n",
4937                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y7));
4938                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y8: %d\n",
4939                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y8));
4940                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y9: %d\n",
4941                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y9));
4942                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y10: %d\n",
4943                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y10));
4944                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y11: %d\n",
4945                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y11));
4946                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y12: %d\n",
4947                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y12));
4948                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y13: %d\n",
4949                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y13));
4950                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y14: %d\n",
4951                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y14));
4952                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y15: %d\n",
4953                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y15));
4954                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_R_Y16: %d\n",
4955                                       cifisp_ioread32(CIF_ISP_GAMMA_R_Y16));
4956
4957                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y0: %d\n",
4958                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y0));
4959                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y1: %d\n",
4960                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y1));
4961                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y2: %d\n",
4962                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y2));
4963                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y3: %d\n",
4964                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y3));
4965                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y4: %d\n",
4966                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y4));
4967                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y5: %d\n",
4968                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y5));
4969                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y6: %d\n",
4970                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y6));
4971                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y7: %d\n",
4972                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y7));
4973                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y8: %d\n",
4974                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y8));
4975                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y9: %d\n",
4976                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y9));
4977                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y10: %d\n",
4978                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y10));
4979                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y11: %d\n",
4980                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y11));
4981                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y12: %d\n",
4982                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y12));
4983                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y13: %d\n",
4984                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y13));
4985                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y14: %d\n",
4986                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y14));
4987                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y15: %d\n",
4988                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y15));
4989                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_G_Y16: %d\n",
4990                                       cifisp_ioread32(CIF_ISP_GAMMA_G_Y16));
4991
4992                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y0: %d\n",
4993                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y0));
4994                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y1: %d\n",
4995                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y1));
4996                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y2: %d\n",
4997                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y2));
4998                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y3: %d\n",
4999                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y3));
5000                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y4: %d\n",
5001                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y4));
5002                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y5: %d\n",
5003                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y5));
5004                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y6: %d\n",
5005                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y6));
5006                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y7: %d\n",
5007                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y7));
5008                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y8: %d\n",
5009                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y8));
5010                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y9: %d\n",
5011                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y9));
5012                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y10: %d\n",
5013                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y10));
5014                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y11: %d\n",
5015                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y11));
5016                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y12: %d\n",
5017                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y12));
5018                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y13: %d\n",
5019                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y13));
5020                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y14: %d\n",
5021                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y14));
5022                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y15: %d\n",
5023                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y15));
5024                         CIFISP_DPRINT(level, " CIF_ISP_GAMMA_B_Y16: %d\n",
5025                                       cifisp_ioread32(CIF_ISP_GAMMA_B_Y16));
5026                         CIFISP_DPRINT(level,
5027                                       "#### %s: SDG Registers - END ####\n",
5028                                       ISP_VDEV_NAME);
5029                 }
5030                 break;
5031
5032         case CIFISP_MODULE_GOC:{
5033                         CIFISP_DPRINT(level,
5034                                       "#### %s: GOC Registers - BEGIN ####\n",
5035                                       ISP_VDEV_NAME);
5036                         CIFISP_DPRINT(level,
5037                                       "#### %s: GOC registers - END ####\n",
5038                                       ISP_VDEV_NAME);
5039                 }
5040                 break;
5041
5042         case CIFISP_MODULE_CTK:{
5043                         CIFISP_DPRINT(level,
5044                                       "#### %s: CTK Registers - BEGIN ####\n",
5045                                       ISP_VDEV_NAME);
5046                         CIFISP_DPRINT(level, " CIF_ISP_CT_COEFF_0: %d\n",
5047                                       cifisp_ioread32(CIF_ISP_CT_COEFF_0));
5048                         CIFISP_DPRINT(level, " CIF_ISP_CT_COEFF_1: %d\n",
5049                                       cifisp_ioread32(CIF_ISP_CT_COEFF_1));
5050                         CIFISP_DPRINT(level, " CIF_ISP_CT_COEFF_2: %d\n",
5051                                       cifisp_ioread32(CIF_ISP_CT_COEFF_2));
5052                         CIFISP_DPRINT(level, " CIF_ISP_CT_COEFF_3: %d\n",
5053                                       cifisp_ioread32(CIF_ISP_CT_COEFF_3));
5054                         CIFISP_DPRINT(level, " CIF_ISP_CT_COEFF_4: %d\n",
5055                                       cifisp_ioread32(CIF_ISP_CT_COEFF_4));
5056                         CIFISP_DPRINT(level, " CIF_ISP_CT_COEFF_5: %d\n",
5057                                       cifisp_ioread32(CIF_ISP_CT_COEFF_5));
5058                         CIFISP_DPRINT(level, " CIF_ISP_CT_COEFF_6: %d\n",
5059                                       cifisp_ioread32(CIF_ISP_CT_COEFF_6));
5060                         CIFISP_DPRINT(level, " CIF_ISP_CT_COEFF_7: %d\n",
5061                                       cifisp_ioread32(CIF_ISP_CT_COEFF_7));
5062                         CIFISP_DPRINT(level, " CIF_ISP_CT_COEFF_8: %d\n",
5063                                       cifisp_ioread32(CIF_ISP_CT_COEFF_8));
5064                         CIFISP_DPRINT(level, " CIF_ISP_CT_OFFSET_R: %d\n",
5065                                       cifisp_ioread32(CIF_ISP_CT_OFFSET_R));
5066                         CIFISP_DPRINT(level, " CIF_ISP_CT_OFFSET_G: %d\n",
5067                                       cifisp_ioread32(CIF_ISP_CT_OFFSET_G));
5068                         CIFISP_DPRINT(level, " CIF_ISP_CT_OFFSET_B: %d\n",
5069                                       cifisp_ioread32(CIF_ISP_CT_OFFSET_B));
5070                         CIFISP_DPRINT(level,
5071                                       "#### %s: CTK Registers - END ####\n",
5072                                       ISP_VDEV_NAME);
5073                 }
5074                 break;
5075
5076         case CIFISP_MODULE_AWB:{
5077                         CIFISP_DPRINT(level,
5078                                       "#### %s: AWB Registers - BEGIN ####\n",
5079                                       ISP_VDEV_NAME);
5080                         CIFISP_DPRINT(level, " CIF_ISP_AWB_PROP: %x\n",
5081                                       cifisp_ioread32(CIF_ISP_AWB_PROP));
5082                         CIFISP_DPRINT(level, " CIF_ISP_AWB_GAIN_G: %x\n",
5083                                       cifisp_ioread32(CIF_ISP_AWB_GAIN_G));
5084                         CIFISP_DPRINT(level, " CIF_ISP_AWB_GAIN_RB: %x\n",
5085                                       cifisp_ioread32(CIF_ISP_AWB_GAIN_RB));
5086                         CIFISP_DPRINT(level, " CIF_ISP_AWB_REF: %x\n",
5087                                       cifisp_ioread32(CIF_ISP_AWB_REF));
5088                         CIFISP_DPRINT(level, " CIF_ISP_AWB_GAIN_RB: %x\n",
5089                                       cifisp_ioread32(CIF_ISP_AWB_PROP));
5090                         CIFISP_DPRINT(level, " CIF_ISP_AWB_FRAMES: %x\n",
5091                                       cifisp_ioread32(CIF_ISP_AWB_FRAMES));
5092                         CIFISP_DPRINT(level,
5093                                       "#### %s: AWB Registers - END ####\n",
5094                                       ISP_VDEV_NAME);
5095                 }
5096                 break;
5097
5098         case CIFISP_MODULE_HST:{
5099                         CIFISP_DPRINT(level,
5100                                       "#### %s: HST Registers - BEGIN ####\n",
5101                                       ISP_VDEV_NAME);
5102                         CIFISP_DPRINT(level, " CIF_ISP_HIST_PROP: %d\n",
5103                                       cifisp_ioread32(CIF_ISP_HIST_PROP));
5104                         CIFISP_DPRINT(level, " CIF_ISP_HIST_H_OFFS: %d\n",
5105                                       cifisp_ioread32(CIF_ISP_HIST_H_OFFS));
5106                         CIFISP_DPRINT(level, " CIF_ISP_HIST_H_SIZE: %d\n",
5107                                       cifisp_ioread32(CIF_ISP_HIST_H_SIZE));
5108                         CIFISP_DPRINT(level, " CIF_ISP_HIST_V_OFFS: %d\n",
5109                                       cifisp_ioread32(CIF_ISP_HIST_V_OFFS));
5110                         CIFISP_DPRINT(level, " CIF_ISP_HIST_V_SIZE: %d\n",
5111                                       cifisp_ioread32(CIF_ISP_HIST_V_SIZE));
5112                         CIFISP_DPRINT(level,
5113                                       "#### %s: HST Registers - END ####\n",
5114                                       ISP_VDEV_NAME);
5115                 }
5116                 break;
5117
5118         case CIFISP_MODULE_AEC:{
5119                         CIFISP_DPRINT(level,
5120                                       "#### %s: AEC Registers - BEGIN ####\n",
5121                                       ISP_VDEV_NAME);
5122                         CIFISP_DPRINT(level, " CIF_ISP_EXP_CTRL: %d\n",
5123                                       cifisp_ioread32(CIF_ISP_EXP_CTRL));
5124                         CIFISP_DPRINT(level, " CIF_ISP_EXP_H_OFFSET: %d\n",
5125                                       cifisp_ioread32(CIF_ISP_EXP_H_OFFSET));
5126                         CIFISP_DPRINT(level, " CIF_ISP_EXP_V_OFFSET: %d\n",
5127                                       cifisp_ioread32(CIF_ISP_EXP_V_OFFSET));
5128                         CIFISP_DPRINT(level, " CIF_ISP_EXP_H_SIZE: %d\n",
5129                                       cifisp_ioread32(CIF_ISP_EXP_H_SIZE));
5130                         CIFISP_DPRINT(level, " CIF_ISP_EXP_V_SIZE: %d\n",
5131                                       cifisp_ioread32(CIF_ISP_EXP_V_SIZE));
5132                         CIFISP_DPRINT(level,
5133                                       "#### %s: AEC Registers - END ####\n",
5134                                       ISP_VDEV_NAME);
5135                 }
5136                 break;
5137
5138         case CIFISP_MODULE_CPROC:{
5139                         CIFISP_DPRINT(level,
5140                                       "#### %s: CPROC Registers - BEGIN ####\n",
5141                                       ISP_VDEV_NAME);
5142                         CIFISP_DPRINT(level, " ctrl: %d\n",
5143                                       cifisp_ioread32(CIF_C_PROC_CTRL));
5144                         CIFISP_DPRINT(level, " contrast: %d\n",
5145                                       cifisp_ioread32(CIF_C_PROC_CONTRAST));
5146                         CIFISP_DPRINT(level, " hue: %d\n",
5147                                       cifisp_ioread32(CIF_C_PROC_HUE));
5148                         CIFISP_DPRINT(level, " sat: %d\n",
5149                                       cifisp_ioread32(CIF_C_PROC_SATURATION));
5150                         CIFISP_DPRINT(level, " brightness: %d\n",
5151                                       cifisp_ioread32(CIF_C_PROC_BRIGHTNESS));
5152                         CIFISP_DPRINT(level,
5153                                       "#### %s: CPROC Registers - END ####\n",
5154                                       ISP_VDEV_NAME);
5155                 }
5156                 break;
5157         case CIFISP_MODULE_AFC:{
5158                         CIFISP_DPRINT(level,
5159                                       "#### %s: AFC Registers - BEGIN ####\n",
5160                                       ISP_VDEV_NAME);
5161                         CIFISP_DPRINT(level, " afm_ctr: %d\n",
5162                                       cifisp_ioread32(CIF_ISP_AFM_CTRL));
5163                         CIFISP_DPRINT(level, " afm_lt_a: %d\n",
5164                                       cifisp_ioread32(CIF_ISP_AFM_LT_A));
5165                         CIFISP_DPRINT(level, " afm_rb_a: %d\n",
5166                                       cifisp_ioread32(CIF_ISP_AFM_RB_A));
5167                         CIFISP_DPRINT(level, " afm_lt_b: %d\n",
5168                                       cifisp_ioread32(CIF_ISP_AFM_LT_B));
5169                         CIFISP_DPRINT(level, " afm_rb_b: %d\n",
5170                                       cifisp_ioread32(CIF_ISP_AFM_RB_B));
5171                         CIFISP_DPRINT(level, " afm_lt_c: %d\n",
5172                                       cifisp_ioread32(CIF_ISP_AFM_LT_C));
5173                         CIFISP_DPRINT(level, " afm_rb_c: %d\n",
5174                                       cifisp_ioread32(CIF_ISP_AFM_RB_C));
5175                         CIFISP_DPRINT(level, " afm_thres: %d\n",
5176                                       cifisp_ioread32(CIF_ISP_AFM_THRES));
5177                         CIFISP_DPRINT(level, " afm_var_shift: %d\n",
5178                                       cifisp_ioread32(CIF_ISP_AFM_VAR_SHIFT));
5179                         CIFISP_DPRINT(level,
5180                                       "#### %s: YCFLT Registers - END ####\n",
5181                                       ISP_VDEV_NAME);
5182                 }
5183                 break;
5184         default:
5185                 CIFISP_DPRINT(level, "####%s: Invalid Module ID ####\n",
5186                               ISP_VDEV_NAME);
5187                 break;
5188         }
5189 }
5190 #endif