1 // SPDX-License-Identifier: (GPL-2.0+ OR MIT) 2 /* 3 * Rockchip ISP1 Driver - Params subdevice 4 * 5 * Copyright (C) 2017 Rockchip Electronics Co., Ltd. 6 */ 7 8 #include <linux/bitfield.h> 9 #include <linux/math.h> 10 #include <linux/string.h> 11 12 #include <media/v4l2-common.h> 13 #include <media/v4l2-event.h> 14 #include <media/v4l2-ioctl.h> 15 #include <media/videobuf2-core.h> 16 #include <media/videobuf2-vmalloc.h> /* for ISP params */ 17 18 #include "rkisp1-common.h" 19 20 #define RKISP1_PARAMS_DEV_NAME RKISP1_DRIVER_NAME "_params" 21 22 #define RKISP1_ISP_PARAMS_REQ_BUFS_MIN 2 23 #define RKISP1_ISP_PARAMS_REQ_BUFS_MAX 8 24 25 #define RKISP1_ISP_DPCC_METHODS_SET(n) \ 26 (RKISP1_CIF_ISP_DPCC_METHODS_SET_1 + 0x4 * (n)) 27 #define RKISP1_ISP_DPCC_LINE_THRESH(n) \ 28 (RKISP1_CIF_ISP_DPCC_LINE_THRESH_1 + 0x14 * (n)) 29 #define RKISP1_ISP_DPCC_LINE_MAD_FAC(n) \ 30 (RKISP1_CIF_ISP_DPCC_LINE_MAD_FAC_1 + 0x14 * (n)) 31 #define RKISP1_ISP_DPCC_PG_FAC(n) \ 32 (RKISP1_CIF_ISP_DPCC_PG_FAC_1 + 0x14 * (n)) 33 #define RKISP1_ISP_DPCC_RND_THRESH(n) \ 34 (RKISP1_CIF_ISP_DPCC_RND_THRESH_1 + 0x14 * (n)) 35 #define RKISP1_ISP_DPCC_RG_FAC(n) \ 36 (RKISP1_CIF_ISP_DPCC_RG_FAC_1 + 0x14 * (n)) 37 #define RKISP1_ISP_CC_COEFF(n) \ 38 (RKISP1_CIF_ISP_CC_COEFF_0 + (n) * 4) 39 40 #define RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS BIT(0) 41 #define RKISP1_EXT_PARAMS_BLOCK_GROUP_LSC BIT(1) 42 43 union rkisp1_ext_params_config { 44 struct rkisp1_ext_params_block_header header; 45 struct rkisp1_ext_params_bls_config bls; 46 struct rkisp1_ext_params_dpcc_config dpcc; 47 struct rkisp1_ext_params_sdg_config sdg; 48 struct rkisp1_ext_params_lsc_config lsc; 49 struct rkisp1_ext_params_awb_gain_config awbg; 50 struct rkisp1_ext_params_flt_config flt; 51 struct rkisp1_ext_params_bdm_config bdm; 52 struct rkisp1_ext_params_ctk_config ctk; 53 struct rkisp1_ext_params_goc_config goc; 54 struct rkisp1_ext_params_dpf_config dpf; 55 struct rkisp1_ext_params_dpf_strength_config dpfs; 56 struct rkisp1_ext_params_cproc_config cproc; 57 struct rkisp1_ext_params_ie_config ie; 58 struct rkisp1_ext_params_awb_meas_config awbm; 59 struct rkisp1_ext_params_hst_config hst; 60 struct rkisp1_ext_params_aec_config aec; 61 struct rkisp1_ext_params_afc_config afc; 62 struct rkisp1_ext_params_compand_bls_config compand_bls; 63 struct rkisp1_ext_params_compand_curve_config compand_curve; 64 struct rkisp1_ext_params_wdr_config wdr; 65 }; 66 67 enum rkisp1_params_formats { 68 RKISP1_PARAMS_FIXED, 69 RKISP1_PARAMS_EXTENSIBLE, 70 }; 71 72 static const struct v4l2_meta_format rkisp1_params_formats[] = { 73 [RKISP1_PARAMS_FIXED] = { 74 .dataformat = V4L2_META_FMT_RK_ISP1_PARAMS, 75 .buffersize = sizeof(struct rkisp1_params_cfg), 76 }, 77 [RKISP1_PARAMS_EXTENSIBLE] = { 78 .dataformat = V4L2_META_FMT_RK_ISP1_EXT_PARAMS, 79 .buffersize = sizeof(struct rkisp1_ext_params_cfg), 80 }, 81 }; 82 83 static const struct v4l2_meta_format * 84 rkisp1_params_get_format_info(u32 dataformat) 85 { 86 for (unsigned int i = 0; i < ARRAY_SIZE(rkisp1_params_formats); i++) { 87 if (rkisp1_params_formats[i].dataformat == dataformat) 88 return &rkisp1_params_formats[i]; 89 } 90 91 return &rkisp1_params_formats[RKISP1_PARAMS_FIXED]; 92 } 93 94 static inline void 95 rkisp1_param_set_bits(struct rkisp1_params *params, u32 reg, u32 bit_mask) 96 { 97 u32 val; 98 99 val = rkisp1_read(params->rkisp1, reg); 100 rkisp1_write(params->rkisp1, reg, val | bit_mask); 101 } 102 103 static inline void 104 rkisp1_param_clear_bits(struct rkisp1_params *params, u32 reg, u32 bit_mask) 105 { 106 u32 val; 107 108 val = rkisp1_read(params->rkisp1, reg); 109 rkisp1_write(params->rkisp1, reg, val & ~bit_mask); 110 } 111 112 /* ISP BP interface function */ 113 static void rkisp1_dpcc_config(struct rkisp1_params *params, 114 const struct rkisp1_cif_isp_dpcc_config *arg) 115 { 116 unsigned int i; 117 u32 mode; 118 119 /* 120 * The enable bit is controlled in rkisp1_isp_isr_other_config() and 121 * must be preserved. The grayscale mode should be configured 122 * automatically based on the media bus code on the ISP sink pad, so 123 * only the STAGE1_ENABLE bit can be set by userspace. 124 */ 125 mode = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_DPCC_MODE); 126 mode &= RKISP1_CIF_ISP_DPCC_MODE_DPCC_ENABLE; 127 mode |= arg->mode & RKISP1_CIF_ISP_DPCC_MODE_STAGE1_ENABLE; 128 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPCC_MODE, mode); 129 130 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPCC_OUTPUT_MODE, 131 arg->output_mode & RKISP1_CIF_ISP_DPCC_OUTPUT_MODE_MASK); 132 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPCC_SET_USE, 133 arg->set_use & RKISP1_CIF_ISP_DPCC_SET_USE_MASK); 134 135 for (i = 0; i < RKISP1_CIF_ISP_DPCC_METHODS_MAX; i++) { 136 rkisp1_write(params->rkisp1, RKISP1_ISP_DPCC_METHODS_SET(i), 137 arg->methods[i].method & 138 RKISP1_CIF_ISP_DPCC_METHODS_SET_MASK); 139 rkisp1_write(params->rkisp1, RKISP1_ISP_DPCC_LINE_THRESH(i), 140 arg->methods[i].line_thresh & 141 RKISP1_CIF_ISP_DPCC_LINE_THRESH_MASK); 142 rkisp1_write(params->rkisp1, RKISP1_ISP_DPCC_LINE_MAD_FAC(i), 143 arg->methods[i].line_mad_fac & 144 RKISP1_CIF_ISP_DPCC_LINE_MAD_FAC_MASK); 145 rkisp1_write(params->rkisp1, RKISP1_ISP_DPCC_PG_FAC(i), 146 arg->methods[i].pg_fac & 147 RKISP1_CIF_ISP_DPCC_PG_FAC_MASK); 148 rkisp1_write(params->rkisp1, RKISP1_ISP_DPCC_RND_THRESH(i), 149 arg->methods[i].rnd_thresh & 150 RKISP1_CIF_ISP_DPCC_RND_THRESH_MASK); 151 rkisp1_write(params->rkisp1, RKISP1_ISP_DPCC_RG_FAC(i), 152 arg->methods[i].rg_fac & 153 RKISP1_CIF_ISP_DPCC_RG_FAC_MASK); 154 } 155 156 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPCC_RND_OFFS, 157 arg->rnd_offs & RKISP1_CIF_ISP_DPCC_RND_OFFS_MASK); 158 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPCC_RO_LIMITS, 159 arg->ro_limits & RKISP1_CIF_ISP_DPCC_RO_LIMIT_MASK); 160 } 161 162 /* ISP black level subtraction interface function */ 163 static void rkisp1_bls_config(struct rkisp1_params *params, 164 const struct rkisp1_cif_isp_bls_config *arg) 165 { 166 /* avoid to override the old enable value */ 167 u32 new_control; 168 169 new_control = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_BLS_CTRL); 170 new_control &= RKISP1_CIF_ISP_BLS_ENA; 171 /* fixed subtraction values */ 172 if (!arg->enable_auto) { 173 static const u32 regs[] = { 174 RKISP1_CIF_ISP_BLS_A_FIXED, 175 RKISP1_CIF_ISP_BLS_B_FIXED, 176 RKISP1_CIF_ISP_BLS_C_FIXED, 177 RKISP1_CIF_ISP_BLS_D_FIXED, 178 }; 179 u32 swapped[4]; 180 181 rkisp1_bls_swap_regs(params->raw_type, regs, swapped); 182 183 rkisp1_write(params->rkisp1, swapped[0], arg->fixed_val.r); 184 rkisp1_write(params->rkisp1, swapped[1], arg->fixed_val.gr); 185 rkisp1_write(params->rkisp1, swapped[2], arg->fixed_val.gb); 186 rkisp1_write(params->rkisp1, swapped[3], arg->fixed_val.b); 187 } else { 188 if (arg->en_windows & BIT(1)) { 189 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_BLS_H2_START, 190 arg->bls_window2.h_offs); 191 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_BLS_H2_STOP, 192 arg->bls_window2.h_size); 193 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_BLS_V2_START, 194 arg->bls_window2.v_offs); 195 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_BLS_V2_STOP, 196 arg->bls_window2.v_size); 197 new_control |= RKISP1_CIF_ISP_BLS_WINDOW_2; 198 } 199 200 if (arg->en_windows & BIT(0)) { 201 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_BLS_H1_START, 202 arg->bls_window1.h_offs); 203 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_BLS_H1_STOP, 204 arg->bls_window1.h_size); 205 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_BLS_V1_START, 206 arg->bls_window1.v_offs); 207 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_BLS_V1_STOP, 208 arg->bls_window1.v_size); 209 new_control |= RKISP1_CIF_ISP_BLS_WINDOW_1; 210 } 211 212 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_BLS_SAMPLES, 213 arg->bls_samples); 214 215 new_control |= RKISP1_CIF_ISP_BLS_MODE_MEASURED; 216 } 217 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_BLS_CTRL, new_control); 218 } 219 220 /* ISP LS correction interface function */ 221 static void 222 rkisp1_lsc_matrix_config_v10(struct rkisp1_params *params, 223 const struct rkisp1_cif_isp_lsc_config *pconfig) 224 { 225 struct rkisp1_device *rkisp1 = params->rkisp1; 226 u32 lsc_status, sram_addr, lsc_table_sel; 227 unsigned int i, j; 228 229 lsc_status = rkisp1_read(rkisp1, RKISP1_CIF_ISP_LSC_STATUS); 230 231 /* RKISP1_CIF_ISP_LSC_TABLE_ADDRESS_153 = ( 17 * 18 ) >> 1 */ 232 sram_addr = lsc_status & RKISP1_CIF_ISP_LSC_ACTIVE_TABLE ? 233 RKISP1_CIF_ISP_LSC_TABLE_ADDRESS_0 : 234 RKISP1_CIF_ISP_LSC_TABLE_ADDRESS_153; 235 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_R_TABLE_ADDR, sram_addr); 236 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_GR_TABLE_ADDR, sram_addr); 237 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_GB_TABLE_ADDR, sram_addr); 238 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_B_TABLE_ADDR, sram_addr); 239 240 /* program data tables (table size is 9 * 17 = 153) */ 241 for (i = 0; i < RKISP1_CIF_ISP_LSC_SAMPLES_MAX; i++) { 242 const __u16 *r_tbl = pconfig->r_data_tbl[i]; 243 const __u16 *gr_tbl = pconfig->gr_data_tbl[i]; 244 const __u16 *gb_tbl = pconfig->gb_data_tbl[i]; 245 const __u16 *b_tbl = pconfig->b_data_tbl[i]; 246 247 /* 248 * 17 sectors with 2 values in one DWORD = 9 249 * DWORDs (2nd value of last DWORD unused) 250 */ 251 for (j = 0; j < RKISP1_CIF_ISP_LSC_SAMPLES_MAX - 1; j += 2) { 252 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_R_TABLE_DATA, 253 RKISP1_CIF_ISP_LSC_TABLE_DATA_V10( 254 r_tbl[j], r_tbl[j + 1])); 255 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_GR_TABLE_DATA, 256 RKISP1_CIF_ISP_LSC_TABLE_DATA_V10( 257 gr_tbl[j], gr_tbl[j + 1])); 258 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_GB_TABLE_DATA, 259 RKISP1_CIF_ISP_LSC_TABLE_DATA_V10( 260 gb_tbl[j], gb_tbl[j + 1])); 261 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_B_TABLE_DATA, 262 RKISP1_CIF_ISP_LSC_TABLE_DATA_V10( 263 b_tbl[j], b_tbl[j + 1])); 264 } 265 266 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_R_TABLE_DATA, 267 RKISP1_CIF_ISP_LSC_TABLE_DATA_V10(r_tbl[j], 0)); 268 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_GR_TABLE_DATA, 269 RKISP1_CIF_ISP_LSC_TABLE_DATA_V10(gr_tbl[j], 0)); 270 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_GB_TABLE_DATA, 271 RKISP1_CIF_ISP_LSC_TABLE_DATA_V10(gb_tbl[j], 0)); 272 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_B_TABLE_DATA, 273 RKISP1_CIF_ISP_LSC_TABLE_DATA_V10(b_tbl[j], 0)); 274 } 275 276 lsc_table_sel = lsc_status & RKISP1_CIF_ISP_LSC_ACTIVE_TABLE ? 277 RKISP1_CIF_ISP_LSC_TABLE_0 : RKISP1_CIF_ISP_LSC_TABLE_1; 278 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_TABLE_SEL, lsc_table_sel); 279 } 280 281 static void 282 rkisp1_lsc_matrix_config_v12(struct rkisp1_params *params, 283 const struct rkisp1_cif_isp_lsc_config *pconfig) 284 { 285 struct rkisp1_device *rkisp1 = params->rkisp1; 286 u32 lsc_status, sram_addr, lsc_table_sel; 287 unsigned int i, j; 288 289 lsc_status = rkisp1_read(rkisp1, RKISP1_CIF_ISP_LSC_STATUS); 290 291 /* RKISP1_CIF_ISP_LSC_TABLE_ADDRESS_153 = ( 17 * 18 ) >> 1 */ 292 sram_addr = lsc_status & RKISP1_CIF_ISP_LSC_ACTIVE_TABLE ? 293 RKISP1_CIF_ISP_LSC_TABLE_ADDRESS_0 : 294 RKISP1_CIF_ISP_LSC_TABLE_ADDRESS_153; 295 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_R_TABLE_ADDR, sram_addr); 296 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_GR_TABLE_ADDR, sram_addr); 297 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_GB_TABLE_ADDR, sram_addr); 298 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_B_TABLE_ADDR, sram_addr); 299 300 /* program data tables (table size is 9 * 17 = 153) */ 301 for (i = 0; i < RKISP1_CIF_ISP_LSC_SAMPLES_MAX; i++) { 302 const __u16 *r_tbl = pconfig->r_data_tbl[i]; 303 const __u16 *gr_tbl = pconfig->gr_data_tbl[i]; 304 const __u16 *gb_tbl = pconfig->gb_data_tbl[i]; 305 const __u16 *b_tbl = pconfig->b_data_tbl[i]; 306 307 /* 308 * 17 sectors with 2 values in one DWORD = 9 309 * DWORDs (2nd value of last DWORD unused) 310 */ 311 for (j = 0; j < RKISP1_CIF_ISP_LSC_SAMPLES_MAX - 1; j += 2) { 312 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_R_TABLE_DATA, 313 RKISP1_CIF_ISP_LSC_TABLE_DATA_V12( 314 r_tbl[j], r_tbl[j + 1])); 315 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_GR_TABLE_DATA, 316 RKISP1_CIF_ISP_LSC_TABLE_DATA_V12( 317 gr_tbl[j], gr_tbl[j + 1])); 318 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_GB_TABLE_DATA, 319 RKISP1_CIF_ISP_LSC_TABLE_DATA_V12( 320 gb_tbl[j], gb_tbl[j + 1])); 321 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_B_TABLE_DATA, 322 RKISP1_CIF_ISP_LSC_TABLE_DATA_V12( 323 b_tbl[j], b_tbl[j + 1])); 324 } 325 326 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_R_TABLE_DATA, 327 RKISP1_CIF_ISP_LSC_TABLE_DATA_V12(r_tbl[j], 0)); 328 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_GR_TABLE_DATA, 329 RKISP1_CIF_ISP_LSC_TABLE_DATA_V12(gr_tbl[j], 0)); 330 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_GB_TABLE_DATA, 331 RKISP1_CIF_ISP_LSC_TABLE_DATA_V12(gb_tbl[j], 0)); 332 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_B_TABLE_DATA, 333 RKISP1_CIF_ISP_LSC_TABLE_DATA_V12(b_tbl[j], 0)); 334 } 335 336 lsc_table_sel = lsc_status & RKISP1_CIF_ISP_LSC_ACTIVE_TABLE ? 337 RKISP1_CIF_ISP_LSC_TABLE_0 : RKISP1_CIF_ISP_LSC_TABLE_1; 338 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_TABLE_SEL, lsc_table_sel); 339 } 340 341 static void rkisp1_lsc_config(struct rkisp1_params *params, 342 const struct rkisp1_cif_isp_lsc_config *arg) 343 { 344 struct rkisp1_device *rkisp1 = params->rkisp1; 345 u32 lsc_ctrl, data; 346 unsigned int i; 347 348 /* To config must be off , store the current status firstly */ 349 lsc_ctrl = rkisp1_read(rkisp1, RKISP1_CIF_ISP_LSC_CTRL); 350 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_LSC_CTRL, 351 RKISP1_CIF_ISP_LSC_CTRL_ENA); 352 params->ops->lsc_matrix_config(params, arg); 353 354 for (i = 0; i < RKISP1_CIF_ISP_LSC_SECTORS_TBL_SIZE / 2; i++) { 355 /* program x size tables */ 356 data = RKISP1_CIF_ISP_LSC_SECT_SIZE(arg->x_size_tbl[i * 2], 357 arg->x_size_tbl[i * 2 + 1]); 358 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_XSIZE(i), data); 359 360 /* program x grad tables */ 361 data = RKISP1_CIF_ISP_LSC_SECT_GRAD(arg->x_grad_tbl[i * 2], 362 arg->x_grad_tbl[i * 2 + 1]); 363 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_XGRAD(i), data); 364 365 /* program y size tables */ 366 data = RKISP1_CIF_ISP_LSC_SECT_SIZE(arg->y_size_tbl[i * 2], 367 arg->y_size_tbl[i * 2 + 1]); 368 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_YSIZE(i), data); 369 370 /* program y grad tables */ 371 data = RKISP1_CIF_ISP_LSC_SECT_GRAD(arg->y_grad_tbl[i * 2], 372 arg->y_grad_tbl[i * 2 + 1]); 373 rkisp1_write(rkisp1, RKISP1_CIF_ISP_LSC_YGRAD(i), data); 374 } 375 376 /* restore the lsc ctrl status */ 377 if (lsc_ctrl & RKISP1_CIF_ISP_LSC_CTRL_ENA) 378 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_LSC_CTRL, 379 RKISP1_CIF_ISP_LSC_CTRL_ENA); 380 else 381 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_LSC_CTRL, 382 RKISP1_CIF_ISP_LSC_CTRL_ENA); 383 } 384 385 /* ISP Filtering function */ 386 static void rkisp1_flt_config(struct rkisp1_params *params, 387 const struct rkisp1_cif_isp_flt_config *arg) 388 { 389 u32 filt_mode; 390 391 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_FILT_THRESH_BL0, 392 arg->thresh_bl0); 393 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_FILT_THRESH_BL1, 394 arg->thresh_bl1); 395 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_FILT_THRESH_SH0, 396 arg->thresh_sh0); 397 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_FILT_THRESH_SH1, 398 arg->thresh_sh1); 399 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_FILT_FAC_BL0, 400 arg->fac_bl0); 401 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_FILT_FAC_BL1, 402 arg->fac_bl1); 403 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_FILT_FAC_MID, 404 arg->fac_mid); 405 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_FILT_FAC_SH0, 406 arg->fac_sh0); 407 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_FILT_FAC_SH1, 408 arg->fac_sh1); 409 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_FILT_LUM_WEIGHT, 410 arg->lum_weight); 411 412 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_FILT_MODE, 413 (arg->mode ? RKISP1_CIF_ISP_FLT_MODE_DNR : 0) | 414 RKISP1_CIF_ISP_FLT_CHROMA_V_MODE(arg->chr_v_mode) | 415 RKISP1_CIF_ISP_FLT_CHROMA_H_MODE(arg->chr_h_mode) | 416 RKISP1_CIF_ISP_FLT_GREEN_STAGE1(arg->grn_stage1)); 417 418 /* avoid to override the old enable value */ 419 filt_mode = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_FILT_MODE); 420 filt_mode &= RKISP1_CIF_ISP_FLT_ENA; 421 if (arg->mode) 422 filt_mode |= RKISP1_CIF_ISP_FLT_MODE_DNR; 423 filt_mode |= RKISP1_CIF_ISP_FLT_CHROMA_V_MODE(arg->chr_v_mode) | 424 RKISP1_CIF_ISP_FLT_CHROMA_H_MODE(arg->chr_h_mode) | 425 RKISP1_CIF_ISP_FLT_GREEN_STAGE1(arg->grn_stage1); 426 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_FILT_MODE, filt_mode); 427 } 428 429 /* ISP demosaic interface function */ 430 static int rkisp1_bdm_config(struct rkisp1_params *params, 431 const struct rkisp1_cif_isp_bdm_config *arg) 432 { 433 u32 bdm_th; 434 435 /* avoid to override the old enable value */ 436 bdm_th = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_DEMOSAIC); 437 bdm_th &= RKISP1_CIF_ISP_DEMOSAIC_BYPASS; 438 bdm_th |= arg->demosaic_th & ~RKISP1_CIF_ISP_DEMOSAIC_BYPASS; 439 /* set demosaic threshold */ 440 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DEMOSAIC, bdm_th); 441 return 0; 442 } 443 444 /* ISP GAMMA correction interface function */ 445 static void rkisp1_sdg_config(struct rkisp1_params *params, 446 const struct rkisp1_cif_isp_sdg_config *arg) 447 { 448 unsigned int i; 449 450 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_GAMMA_DX_LO, 451 arg->xa_pnts.gamma_dx0); 452 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_GAMMA_DX_HI, 453 arg->xa_pnts.gamma_dx1); 454 455 for (i = 0; i < RKISP1_CIF_ISP_DEGAMMA_CURVE_SIZE; i++) { 456 rkisp1_write(params->rkisp1, 457 RKISP1_CIF_ISP_GAMMA_R_Y0 + i * 4, 458 arg->curve_r.gamma_y[i]); 459 rkisp1_write(params->rkisp1, 460 RKISP1_CIF_ISP_GAMMA_G_Y0 + i * 4, 461 arg->curve_g.gamma_y[i]); 462 rkisp1_write(params->rkisp1, 463 RKISP1_CIF_ISP_GAMMA_B_Y0 + i * 4, 464 arg->curve_b.gamma_y[i]); 465 } 466 } 467 468 /* ISP GAMMA correction interface function */ 469 static void rkisp1_goc_config_v10(struct rkisp1_params *params, 470 const struct rkisp1_cif_isp_goc_config *arg) 471 { 472 unsigned int i; 473 474 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_CTRL, 475 RKISP1_CIF_ISP_CTRL_ISP_GAMMA_OUT_ENA); 476 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_GAMMA_OUT_MODE_V10, 477 arg->mode); 478 479 for (i = 0; i < RKISP1_CIF_ISP_GAMMA_OUT_MAX_SAMPLES_V10; i++) 480 rkisp1_write(params->rkisp1, 481 RKISP1_CIF_ISP_GAMMA_OUT_Y_0_V10 + i * 4, 482 arg->gamma_y[i]); 483 } 484 485 static void rkisp1_goc_config_v12(struct rkisp1_params *params, 486 const struct rkisp1_cif_isp_goc_config *arg) 487 { 488 unsigned int i; 489 u32 value; 490 491 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_CTRL, 492 RKISP1_CIF_ISP_CTRL_ISP_GAMMA_OUT_ENA); 493 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_GAMMA_OUT_MODE_V12, 494 arg->mode); 495 496 for (i = 0; i < RKISP1_CIF_ISP_GAMMA_OUT_MAX_SAMPLES_V12 / 2; i++) { 497 value = RKISP1_CIF_ISP_GAMMA_VALUE_V12( 498 arg->gamma_y[2 * i + 1], 499 arg->gamma_y[2 * i]); 500 rkisp1_write(params->rkisp1, 501 RKISP1_CIF_ISP_GAMMA_OUT_Y_0_V12 + i * 4, value); 502 } 503 } 504 505 /* ISP Cross Talk */ 506 static void rkisp1_ctk_config(struct rkisp1_params *params, 507 const struct rkisp1_cif_isp_ctk_config *arg) 508 { 509 unsigned int i, j, k = 0; 510 511 for (i = 0; i < 3; i++) 512 for (j = 0; j < 3; j++) 513 rkisp1_write(params->rkisp1, 514 RKISP1_CIF_ISP_CT_COEFF_0 + 4 * k++, 515 arg->coeff[i][j]); 516 for (i = 0; i < 3; i++) 517 rkisp1_write(params->rkisp1, 518 RKISP1_CIF_ISP_CT_OFFSET_R + i * 4, 519 arg->ct_offset[i]); 520 } 521 522 static void rkisp1_ctk_enable(struct rkisp1_params *params, bool en) 523 { 524 if (en) 525 return; 526 527 /* Write back the default values. */ 528 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_CT_COEFF_0, 0x80); 529 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_CT_COEFF_1, 0); 530 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_CT_COEFF_2, 0); 531 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_CT_COEFF_3, 0); 532 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_CT_COEFF_4, 0x80); 533 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_CT_COEFF_5, 0); 534 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_CT_COEFF_6, 0); 535 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_CT_COEFF_7, 0); 536 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_CT_COEFF_8, 0x80); 537 538 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_CT_OFFSET_R, 0); 539 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_CT_OFFSET_G, 0); 540 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_CT_OFFSET_B, 0); 541 } 542 543 /* ISP White Balance Mode */ 544 static void rkisp1_awb_meas_config_v10(struct rkisp1_params *params, 545 const struct rkisp1_cif_isp_awb_meas_config *arg) 546 { 547 u32 reg_val = 0; 548 /* based on the mode,configure the awb module */ 549 if (arg->awb_mode == RKISP1_CIF_ISP_AWB_MODE_YCBCR) { 550 /* Reference Cb and Cr */ 551 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_REF_V10, 552 RKISP1_CIF_ISP_AWB_REF_CR_SET(arg->awb_ref_cr) | 553 arg->awb_ref_cb); 554 /* Yc Threshold */ 555 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_THRESH_V10, 556 RKISP1_CIF_ISP_AWB_MAX_Y_SET(arg->max_y) | 557 RKISP1_CIF_ISP_AWB_MIN_Y_SET(arg->min_y) | 558 RKISP1_CIF_ISP_AWB_MAX_CS_SET(arg->max_csum) | 559 arg->min_c); 560 } 561 562 reg_val = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_AWB_PROP_V10); 563 if (arg->enable_ymax_cmp) 564 reg_val |= RKISP1_CIF_ISP_AWB_YMAX_CMP_EN; 565 else 566 reg_val &= ~RKISP1_CIF_ISP_AWB_YMAX_CMP_EN; 567 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_PROP_V10, reg_val); 568 569 /* window offset */ 570 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_WND_V_OFFS_V10, 571 arg->awb_wnd.v_offs); 572 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_WND_H_OFFS_V10, 573 arg->awb_wnd.h_offs); 574 /* AWB window size */ 575 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_WND_V_SIZE_V10, 576 arg->awb_wnd.v_size); 577 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_WND_H_SIZE_V10, 578 arg->awb_wnd.h_size); 579 /* Number of frames */ 580 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_FRAMES_V10, 581 arg->frames); 582 } 583 584 static void rkisp1_awb_meas_config_v12(struct rkisp1_params *params, 585 const struct rkisp1_cif_isp_awb_meas_config *arg) 586 { 587 u32 reg_val = 0; 588 /* based on the mode,configure the awb module */ 589 if (arg->awb_mode == RKISP1_CIF_ISP_AWB_MODE_YCBCR) { 590 /* Reference Cb and Cr */ 591 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_REF_V12, 592 RKISP1_CIF_ISP_AWB_REF_CR_SET(arg->awb_ref_cr) | 593 arg->awb_ref_cb); 594 /* Yc Threshold */ 595 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_THRESH_V12, 596 RKISP1_CIF_ISP_AWB_MAX_Y_SET(arg->max_y) | 597 RKISP1_CIF_ISP_AWB_MIN_Y_SET(arg->min_y) | 598 RKISP1_CIF_ISP_AWB_MAX_CS_SET(arg->max_csum) | 599 arg->min_c); 600 } 601 602 reg_val = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_AWB_PROP_V12); 603 if (arg->enable_ymax_cmp) 604 reg_val |= RKISP1_CIF_ISP_AWB_YMAX_CMP_EN; 605 else 606 reg_val &= ~RKISP1_CIF_ISP_AWB_YMAX_CMP_EN; 607 reg_val &= ~RKISP1_CIF_ISP_AWB_SET_FRAMES_MASK_V12; 608 reg_val |= RKISP1_CIF_ISP_AWB_SET_FRAMES_V12(arg->frames); 609 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_PROP_V12, reg_val); 610 611 /* window offset */ 612 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_OFFS_V12, 613 arg->awb_wnd.v_offs << 16 | arg->awb_wnd.h_offs); 614 /* AWB window size */ 615 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_SIZE_V12, 616 arg->awb_wnd.v_size << 16 | arg->awb_wnd.h_size); 617 } 618 619 static void 620 rkisp1_awb_meas_enable_v10(struct rkisp1_params *params, 621 const struct rkisp1_cif_isp_awb_meas_config *arg, 622 bool en) 623 { 624 u32 reg_val = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_AWB_PROP_V10); 625 626 /* switch off */ 627 reg_val &= RKISP1_CIF_ISP_AWB_MODE_MASK_NONE; 628 629 if (en) { 630 if (arg->awb_mode == RKISP1_CIF_ISP_AWB_MODE_RGB) 631 reg_val |= RKISP1_CIF_ISP_AWB_MODE_RGB_EN; 632 else 633 reg_val |= RKISP1_CIF_ISP_AWB_MODE_YCBCR_EN; 634 635 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_PROP_V10, 636 reg_val); 637 638 /* Measurements require AWB block be active. */ 639 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_CTRL, 640 RKISP1_CIF_ISP_CTRL_ISP_AWB_ENA); 641 } else { 642 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_PROP_V10, 643 reg_val); 644 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_CTRL, 645 RKISP1_CIF_ISP_CTRL_ISP_AWB_ENA); 646 } 647 } 648 649 static void 650 rkisp1_awb_meas_enable_v12(struct rkisp1_params *params, 651 const struct rkisp1_cif_isp_awb_meas_config *arg, 652 bool en) 653 { 654 u32 reg_val = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_AWB_PROP_V12); 655 656 /* switch off */ 657 reg_val &= RKISP1_CIF_ISP_AWB_MODE_MASK_NONE; 658 659 if (en) { 660 if (arg->awb_mode == RKISP1_CIF_ISP_AWB_MODE_RGB) 661 reg_val |= RKISP1_CIF_ISP_AWB_MODE_RGB_EN; 662 else 663 reg_val |= RKISP1_CIF_ISP_AWB_MODE_YCBCR_EN; 664 665 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_PROP_V12, 666 reg_val); 667 668 /* Measurements require AWB block be active. */ 669 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_CTRL, 670 RKISP1_CIF_ISP_CTRL_ISP_AWB_ENA); 671 } else { 672 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_PROP_V12, 673 reg_val); 674 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_CTRL, 675 RKISP1_CIF_ISP_CTRL_ISP_AWB_ENA); 676 } 677 } 678 679 static void 680 rkisp1_awb_gain_config_v10(struct rkisp1_params *params, 681 const struct rkisp1_cif_isp_awb_gain_config *arg) 682 { 683 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_GAIN_G_V10, 684 RKISP1_CIF_ISP_AWB_GAIN_R_SET(arg->gain_green_r) | 685 arg->gain_green_b); 686 687 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_GAIN_RB_V10, 688 RKISP1_CIF_ISP_AWB_GAIN_R_SET(arg->gain_red) | 689 arg->gain_blue); 690 } 691 692 static void 693 rkisp1_awb_gain_config_v12(struct rkisp1_params *params, 694 const struct rkisp1_cif_isp_awb_gain_config *arg) 695 { 696 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_GAIN_G_V12, 697 RKISP1_CIF_ISP_AWB_GAIN_R_SET(arg->gain_green_r) | 698 arg->gain_green_b); 699 700 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AWB_GAIN_RB_V12, 701 RKISP1_CIF_ISP_AWB_GAIN_R_SET(arg->gain_red) | 702 arg->gain_blue); 703 } 704 705 static void rkisp1_aec_config_v10(struct rkisp1_params *params, 706 const struct rkisp1_cif_isp_aec_config *arg) 707 { 708 unsigned int block_hsize, block_vsize; 709 u32 exp_ctrl; 710 711 /* avoid to override the old enable value */ 712 exp_ctrl = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_EXP_CTRL); 713 exp_ctrl &= RKISP1_CIF_ISP_EXP_ENA; 714 if (arg->autostop) 715 exp_ctrl |= RKISP1_CIF_ISP_EXP_CTRL_AUTOSTOP; 716 if (arg->mode == RKISP1_CIF_ISP_EXP_MEASURING_MODE_1) 717 exp_ctrl |= RKISP1_CIF_ISP_EXP_CTRL_MEASMODE_1; 718 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_EXP_CTRL, exp_ctrl); 719 720 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_EXP_H_OFFSET_V10, 721 arg->meas_window.h_offs); 722 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_EXP_V_OFFSET_V10, 723 arg->meas_window.v_offs); 724 725 block_hsize = arg->meas_window.h_size / 726 RKISP1_CIF_ISP_EXP_COLUMN_NUM_V10 - 1; 727 block_vsize = arg->meas_window.v_size / 728 RKISP1_CIF_ISP_EXP_ROW_NUM_V10 - 1; 729 730 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_EXP_H_SIZE_V10, 731 RKISP1_CIF_ISP_EXP_H_SIZE_SET_V10(block_hsize)); 732 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_EXP_V_SIZE_V10, 733 RKISP1_CIF_ISP_EXP_V_SIZE_SET_V10(block_vsize)); 734 } 735 736 static void rkisp1_aec_config_v12(struct rkisp1_params *params, 737 const struct rkisp1_cif_isp_aec_config *arg) 738 { 739 u32 exp_ctrl; 740 u32 block_hsize, block_vsize; 741 u32 wnd_num_idx = 1; 742 static const u32 ae_wnd_num[] = { 5, 9, 15, 15 }; 743 744 /* avoid to override the old enable value */ 745 exp_ctrl = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_EXP_CTRL); 746 exp_ctrl &= RKISP1_CIF_ISP_EXP_ENA; 747 if (arg->autostop) 748 exp_ctrl |= RKISP1_CIF_ISP_EXP_CTRL_AUTOSTOP; 749 if (arg->mode == RKISP1_CIF_ISP_EXP_MEASURING_MODE_1) 750 exp_ctrl |= RKISP1_CIF_ISP_EXP_CTRL_MEASMODE_1; 751 exp_ctrl |= RKISP1_CIF_ISP_EXP_CTRL_WNDNUM_SET_V12(wnd_num_idx); 752 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_EXP_CTRL, exp_ctrl); 753 754 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_EXP_OFFS_V12, 755 RKISP1_CIF_ISP_EXP_V_OFFSET_SET_V12(arg->meas_window.v_offs) | 756 RKISP1_CIF_ISP_EXP_H_OFFSET_SET_V12(arg->meas_window.h_offs)); 757 758 block_hsize = arg->meas_window.h_size / ae_wnd_num[wnd_num_idx] - 1; 759 block_vsize = arg->meas_window.v_size / ae_wnd_num[wnd_num_idx] - 1; 760 761 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_EXP_SIZE_V12, 762 RKISP1_CIF_ISP_EXP_V_SIZE_SET_V12(block_vsize) | 763 RKISP1_CIF_ISP_EXP_H_SIZE_SET_V12(block_hsize)); 764 } 765 766 static void rkisp1_cproc_config(struct rkisp1_params *params, 767 const struct rkisp1_cif_isp_cproc_config *arg) 768 { 769 struct rkisp1_cif_isp_isp_other_cfg *cur_other_cfg = 770 container_of(arg, struct rkisp1_cif_isp_isp_other_cfg, cproc_config); 771 struct rkisp1_cif_isp_ie_config *cur_ie_config = 772 &cur_other_cfg->ie_config; 773 u32 effect = cur_ie_config->effect; 774 u32 quantization = params->quantization; 775 776 rkisp1_write(params->rkisp1, RKISP1_CIF_C_PROC_CONTRAST, 777 arg->contrast); 778 rkisp1_write(params->rkisp1, RKISP1_CIF_C_PROC_HUE, arg->hue); 779 rkisp1_write(params->rkisp1, RKISP1_CIF_C_PROC_SATURATION, arg->sat); 780 rkisp1_write(params->rkisp1, RKISP1_CIF_C_PROC_BRIGHTNESS, 781 arg->brightness); 782 783 if (quantization != V4L2_QUANTIZATION_FULL_RANGE || 784 effect != V4L2_COLORFX_NONE) { 785 rkisp1_param_clear_bits(params, RKISP1_CIF_C_PROC_CTRL, 786 RKISP1_CIF_C_PROC_YOUT_FULL | 787 RKISP1_CIF_C_PROC_YIN_FULL | 788 RKISP1_CIF_C_PROC_COUT_FULL); 789 } else { 790 rkisp1_param_set_bits(params, RKISP1_CIF_C_PROC_CTRL, 791 RKISP1_CIF_C_PROC_YOUT_FULL | 792 RKISP1_CIF_C_PROC_YIN_FULL | 793 RKISP1_CIF_C_PROC_COUT_FULL); 794 } 795 } 796 797 static void rkisp1_hst_config_v10(struct rkisp1_params *params, 798 const struct rkisp1_cif_isp_hst_config *arg) 799 { 800 unsigned int block_hsize, block_vsize; 801 static const u32 hist_weight_regs[] = { 802 RKISP1_CIF_ISP_HIST_WEIGHT_00TO30_V10, 803 RKISP1_CIF_ISP_HIST_WEIGHT_40TO21_V10, 804 RKISP1_CIF_ISP_HIST_WEIGHT_31TO12_V10, 805 RKISP1_CIF_ISP_HIST_WEIGHT_22TO03_V10, 806 RKISP1_CIF_ISP_HIST_WEIGHT_13TO43_V10, 807 RKISP1_CIF_ISP_HIST_WEIGHT_04TO34_V10, 808 }; 809 const u8 *weight; 810 unsigned int i; 811 u32 hist_prop; 812 813 /* avoid to override the old enable value */ 814 hist_prop = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_HIST_PROP_V10); 815 hist_prop &= RKISP1_CIF_ISP_HIST_PROP_MODE_MASK_V10; 816 hist_prop |= RKISP1_CIF_ISP_HIST_PREDIV_SET_V10(arg->histogram_predivider); 817 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_HIST_PROP_V10, hist_prop); 818 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_HIST_H_OFFS_V10, 819 arg->meas_window.h_offs); 820 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_HIST_V_OFFS_V10, 821 arg->meas_window.v_offs); 822 823 block_hsize = arg->meas_window.h_size / 824 RKISP1_CIF_ISP_HIST_COLUMN_NUM_V10 - 1; 825 block_vsize = arg->meas_window.v_size / RKISP1_CIF_ISP_HIST_ROW_NUM_V10 - 1; 826 827 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_HIST_H_SIZE_V10, 828 block_hsize); 829 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_HIST_V_SIZE_V10, 830 block_vsize); 831 832 weight = arg->hist_weight; 833 for (i = 0; i < ARRAY_SIZE(hist_weight_regs); ++i, weight += 4) 834 rkisp1_write(params->rkisp1, hist_weight_regs[i], 835 RKISP1_CIF_ISP_HIST_WEIGHT_SET_V10(weight[0], weight[1], 836 weight[2], weight[3])); 837 838 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_HIST_WEIGHT_44_V10, 839 weight[0] & 0x1f); 840 } 841 842 static void rkisp1_hst_config_v12(struct rkisp1_params *params, 843 const struct rkisp1_cif_isp_hst_config *arg) 844 { 845 unsigned int i, j; 846 u32 block_hsize, block_vsize; 847 u32 wnd_num_idx, hist_weight_num, hist_ctrl, value; 848 u8 weight15x15[RKISP1_CIF_ISP_HIST_WEIGHT_REG_SIZE_V12]; 849 static const u32 hist_wnd_num[] = { 5, 9, 15, 15 }; 850 851 /* now we just support 9x9 window */ 852 wnd_num_idx = 1; 853 memset(weight15x15, 0x00, sizeof(weight15x15)); 854 /* avoid to override the old enable value */ 855 hist_ctrl = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_HIST_CTRL_V12); 856 hist_ctrl &= RKISP1_CIF_ISP_HIST_CTRL_MODE_MASK_V12 | 857 RKISP1_CIF_ISP_HIST_CTRL_EN_MASK_V12; 858 hist_ctrl = hist_ctrl | 859 RKISP1_CIF_ISP_HIST_CTRL_INTRSEL_SET_V12(1) | 860 RKISP1_CIF_ISP_HIST_CTRL_DATASEL_SET_V12(0) | 861 RKISP1_CIF_ISP_HIST_CTRL_WATERLINE_SET_V12(0) | 862 RKISP1_CIF_ISP_HIST_CTRL_AUTOSTOP_SET_V12(0) | 863 RKISP1_CIF_ISP_HIST_CTRL_WNDNUM_SET_V12(1) | 864 RKISP1_CIF_ISP_HIST_CTRL_STEPSIZE_SET_V12(arg->histogram_predivider); 865 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_HIST_CTRL_V12, hist_ctrl); 866 867 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_HIST_OFFS_V12, 868 RKISP1_CIF_ISP_HIST_OFFS_SET_V12(arg->meas_window.h_offs, 869 arg->meas_window.v_offs)); 870 871 block_hsize = arg->meas_window.h_size / hist_wnd_num[wnd_num_idx] - 1; 872 block_vsize = arg->meas_window.v_size / hist_wnd_num[wnd_num_idx] - 1; 873 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_HIST_SIZE_V12, 874 RKISP1_CIF_ISP_HIST_SIZE_SET_V12(block_hsize, block_vsize)); 875 876 for (i = 0; i < hist_wnd_num[wnd_num_idx]; i++) { 877 for (j = 0; j < hist_wnd_num[wnd_num_idx]; j++) { 878 weight15x15[i * RKISP1_CIF_ISP_HIST_ROW_NUM_V12 + j] = 879 arg->hist_weight[i * hist_wnd_num[wnd_num_idx] + j]; 880 } 881 } 882 883 hist_weight_num = RKISP1_CIF_ISP_HIST_WEIGHT_REG_SIZE_V12; 884 for (i = 0; i < (hist_weight_num / 4); i++) { 885 value = RKISP1_CIF_ISP_HIST_WEIGHT_SET_V12( 886 weight15x15[4 * i + 0], 887 weight15x15[4 * i + 1], 888 weight15x15[4 * i + 2], 889 weight15x15[4 * i + 3]); 890 rkisp1_write(params->rkisp1, 891 RKISP1_CIF_ISP_HIST_WEIGHT_V12 + 4 * i, value); 892 } 893 value = RKISP1_CIF_ISP_HIST_WEIGHT_SET_V12(weight15x15[4 * i + 0], 0, 0, 0); 894 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_HIST_WEIGHT_V12 + 4 * i, 895 value); 896 } 897 898 static void 899 rkisp1_hst_enable_v10(struct rkisp1_params *params, 900 const struct rkisp1_cif_isp_hst_config *arg, bool en) 901 { 902 if (en) { 903 u32 hist_prop = rkisp1_read(params->rkisp1, 904 RKISP1_CIF_ISP_HIST_PROP_V10); 905 906 hist_prop &= ~RKISP1_CIF_ISP_HIST_PROP_MODE_MASK_V10; 907 hist_prop |= arg->mode; 908 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_HIST_PROP_V10, 909 hist_prop); 910 } else { 911 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_HIST_PROP_V10, 912 RKISP1_CIF_ISP_HIST_PROP_MODE_MASK_V10); 913 } 914 } 915 916 static void 917 rkisp1_hst_enable_v12(struct rkisp1_params *params, 918 const struct rkisp1_cif_isp_hst_config *arg, bool en) 919 { 920 if (en) { 921 u32 hist_ctrl = rkisp1_read(params->rkisp1, 922 RKISP1_CIF_ISP_HIST_CTRL_V12); 923 924 hist_ctrl &= ~RKISP1_CIF_ISP_HIST_CTRL_MODE_MASK_V12; 925 hist_ctrl |= RKISP1_CIF_ISP_HIST_CTRL_MODE_SET_V12(arg->mode); 926 hist_ctrl |= RKISP1_CIF_ISP_HIST_CTRL_EN_SET_V12(1); 927 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_HIST_CTRL_V12, 928 hist_ctrl); 929 } else { 930 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_HIST_CTRL_V12, 931 RKISP1_CIF_ISP_HIST_CTRL_MODE_MASK_V12 | 932 RKISP1_CIF_ISP_HIST_CTRL_EN_MASK_V12); 933 } 934 } 935 936 static void rkisp1_afm_config_v10(struct rkisp1_params *params, 937 const struct rkisp1_cif_isp_afc_config *arg) 938 { 939 size_t num_of_win = min_t(size_t, ARRAY_SIZE(arg->afm_win), 940 arg->num_afm_win); 941 u32 afm_ctrl = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_AFM_CTRL); 942 unsigned int i; 943 944 /* Switch off to configure. */ 945 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_AFM_CTRL, 946 RKISP1_CIF_ISP_AFM_ENA); 947 948 for (i = 0; i < num_of_win; i++) { 949 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AFM_LT_A + i * 8, 950 RKISP1_CIF_ISP_AFM_WINDOW_X(arg->afm_win[i].h_offs) | 951 RKISP1_CIF_ISP_AFM_WINDOW_Y(arg->afm_win[i].v_offs)); 952 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AFM_RB_A + i * 8, 953 RKISP1_CIF_ISP_AFM_WINDOW_X(arg->afm_win[i].h_size + 954 arg->afm_win[i].h_offs) | 955 RKISP1_CIF_ISP_AFM_WINDOW_Y(arg->afm_win[i].v_size + 956 arg->afm_win[i].v_offs)); 957 } 958 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AFM_THRES, arg->thres); 959 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AFM_VAR_SHIFT, 960 arg->var_shift); 961 /* restore afm status */ 962 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AFM_CTRL, afm_ctrl); 963 } 964 965 static void rkisp1_afm_config_v12(struct rkisp1_params *params, 966 const struct rkisp1_cif_isp_afc_config *arg) 967 { 968 size_t num_of_win = min_t(size_t, ARRAY_SIZE(arg->afm_win), 969 arg->num_afm_win); 970 u32 afm_ctrl = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_AFM_CTRL); 971 u32 lum_var_shift, afm_var_shift; 972 unsigned int i; 973 974 /* Switch off to configure. */ 975 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_AFM_CTRL, 976 RKISP1_CIF_ISP_AFM_ENA); 977 978 for (i = 0; i < num_of_win; i++) { 979 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AFM_LT_A + i * 8, 980 RKISP1_CIF_ISP_AFM_WINDOW_X(arg->afm_win[i].h_offs) | 981 RKISP1_CIF_ISP_AFM_WINDOW_Y(arg->afm_win[i].v_offs)); 982 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AFM_RB_A + i * 8, 983 RKISP1_CIF_ISP_AFM_WINDOW_X(arg->afm_win[i].h_size + 984 arg->afm_win[i].h_offs) | 985 RKISP1_CIF_ISP_AFM_WINDOW_Y(arg->afm_win[i].v_size + 986 arg->afm_win[i].v_offs)); 987 } 988 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AFM_THRES, arg->thres); 989 990 lum_var_shift = RKISP1_CIF_ISP_AFM_GET_LUM_SHIFT_a_V12(arg->var_shift); 991 afm_var_shift = RKISP1_CIF_ISP_AFM_GET_AFM_SHIFT_a_V12(arg->var_shift); 992 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AFM_VAR_SHIFT, 993 RKISP1_CIF_ISP_AFM_SET_SHIFT_a_V12(lum_var_shift, afm_var_shift) | 994 RKISP1_CIF_ISP_AFM_SET_SHIFT_b_V12(lum_var_shift, afm_var_shift) | 995 RKISP1_CIF_ISP_AFM_SET_SHIFT_c_V12(lum_var_shift, afm_var_shift)); 996 997 /* restore afm status */ 998 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_AFM_CTRL, afm_ctrl); 999 } 1000 1001 static void rkisp1_ie_config(struct rkisp1_params *params, 1002 const struct rkisp1_cif_isp_ie_config *arg) 1003 { 1004 u32 eff_ctrl; 1005 1006 eff_ctrl = rkisp1_read(params->rkisp1, RKISP1_CIF_IMG_EFF_CTRL); 1007 eff_ctrl &= ~RKISP1_CIF_IMG_EFF_CTRL_MODE_MASK; 1008 1009 if (params->quantization == V4L2_QUANTIZATION_FULL_RANGE) 1010 eff_ctrl |= RKISP1_CIF_IMG_EFF_CTRL_YCBCR_FULL; 1011 1012 switch (arg->effect) { 1013 case V4L2_COLORFX_SEPIA: 1014 eff_ctrl |= RKISP1_CIF_IMG_EFF_CTRL_MODE_SEPIA; 1015 break; 1016 case V4L2_COLORFX_SET_CBCR: 1017 rkisp1_write(params->rkisp1, RKISP1_CIF_IMG_EFF_TINT, 1018 arg->eff_tint); 1019 eff_ctrl |= RKISP1_CIF_IMG_EFF_CTRL_MODE_SEPIA; 1020 break; 1021 /* 1022 * Color selection is similar to water color(AQUA): 1023 * grayscale + selected color w threshold 1024 */ 1025 case V4L2_COLORFX_AQUA: 1026 eff_ctrl |= RKISP1_CIF_IMG_EFF_CTRL_MODE_COLOR_SEL; 1027 rkisp1_write(params->rkisp1, RKISP1_CIF_IMG_EFF_COLOR_SEL, 1028 arg->color_sel); 1029 break; 1030 case V4L2_COLORFX_EMBOSS: 1031 eff_ctrl |= RKISP1_CIF_IMG_EFF_CTRL_MODE_EMBOSS; 1032 rkisp1_write(params->rkisp1, RKISP1_CIF_IMG_EFF_MAT_1, 1033 arg->eff_mat_1); 1034 rkisp1_write(params->rkisp1, RKISP1_CIF_IMG_EFF_MAT_2, 1035 arg->eff_mat_2); 1036 rkisp1_write(params->rkisp1, RKISP1_CIF_IMG_EFF_MAT_3, 1037 arg->eff_mat_3); 1038 break; 1039 case V4L2_COLORFX_SKETCH: 1040 eff_ctrl |= RKISP1_CIF_IMG_EFF_CTRL_MODE_SKETCH; 1041 rkisp1_write(params->rkisp1, RKISP1_CIF_IMG_EFF_MAT_3, 1042 arg->eff_mat_3); 1043 rkisp1_write(params->rkisp1, RKISP1_CIF_IMG_EFF_MAT_4, 1044 arg->eff_mat_4); 1045 rkisp1_write(params->rkisp1, RKISP1_CIF_IMG_EFF_MAT_5, 1046 arg->eff_mat_5); 1047 break; 1048 case V4L2_COLORFX_BW: 1049 eff_ctrl |= RKISP1_CIF_IMG_EFF_CTRL_MODE_BLACKWHITE; 1050 break; 1051 case V4L2_COLORFX_NEGATIVE: 1052 eff_ctrl |= RKISP1_CIF_IMG_EFF_CTRL_MODE_NEGATIVE; 1053 break; 1054 default: 1055 break; 1056 } 1057 1058 rkisp1_write(params->rkisp1, RKISP1_CIF_IMG_EFF_CTRL, eff_ctrl); 1059 } 1060 1061 static void rkisp1_ie_enable(struct rkisp1_params *params, bool en) 1062 { 1063 if (en) { 1064 rkisp1_param_set_bits(params, RKISP1_CIF_VI_ICCL, 1065 RKISP1_CIF_VI_ICCL_IE_CLK); 1066 rkisp1_write(params->rkisp1, RKISP1_CIF_IMG_EFF_CTRL, 1067 RKISP1_CIF_IMG_EFF_CTRL_ENABLE); 1068 rkisp1_param_set_bits(params, RKISP1_CIF_IMG_EFF_CTRL, 1069 RKISP1_CIF_IMG_EFF_CTRL_CFG_UPD); 1070 } else { 1071 rkisp1_param_clear_bits(params, RKISP1_CIF_IMG_EFF_CTRL, 1072 RKISP1_CIF_IMG_EFF_CTRL_ENABLE); 1073 rkisp1_param_clear_bits(params, RKISP1_CIF_VI_ICCL, 1074 RKISP1_CIF_VI_ICCL_IE_CLK); 1075 } 1076 } 1077 1078 static void rkisp1_csm_config(struct rkisp1_params *params) 1079 { 1080 struct csm_coeffs { 1081 u16 limited[9]; 1082 u16 full[9]; 1083 }; 1084 static const struct csm_coeffs rec601_coeffs = { 1085 .limited = { 1086 0x0021, 0x0042, 0x000d, 1087 0x01ed, 0x01db, 0x0038, 1088 0x0038, 0x01d1, 0x01f7, 1089 }, 1090 .full = { 1091 0x0026, 0x004b, 0x000f, 1092 0x01ea, 0x01d6, 0x0040, 1093 0x0040, 0x01ca, 0x01f6, 1094 }, 1095 }; 1096 static const struct csm_coeffs rec709_coeffs = { 1097 .limited = { 1098 0x0018, 0x0050, 0x0008, 1099 0x01f3, 0x01d5, 0x0038, 1100 0x0038, 0x01cd, 0x01fb, 1101 }, 1102 .full = { 1103 0x001b, 0x005c, 0x0009, 1104 0x01f1, 0x01cf, 0x0040, 1105 0x0040, 0x01c6, 0x01fa, 1106 }, 1107 }; 1108 static const struct csm_coeffs rec2020_coeffs = { 1109 .limited = { 1110 0x001d, 0x004c, 0x0007, 1111 0x01f0, 0x01d8, 0x0038, 1112 0x0038, 0x01cd, 0x01fb, 1113 }, 1114 .full = { 1115 0x0022, 0x0057, 0x0008, 1116 0x01ee, 0x01d2, 0x0040, 1117 0x0040, 0x01c5, 0x01fb, 1118 }, 1119 }; 1120 static const struct csm_coeffs smpte240m_coeffs = { 1121 .limited = { 1122 0x0018, 0x004f, 0x000a, 1123 0x01f3, 0x01d5, 0x0038, 1124 0x0038, 0x01ce, 0x01fa, 1125 }, 1126 .full = { 1127 0x001b, 0x005a, 0x000b, 1128 0x01f1, 0x01cf, 0x0040, 1129 0x0040, 0x01c7, 0x01f9, 1130 }, 1131 }; 1132 1133 const struct csm_coeffs *coeffs; 1134 const u16 *csm; 1135 unsigned int i; 1136 1137 switch (params->ycbcr_encoding) { 1138 case V4L2_YCBCR_ENC_601: 1139 default: 1140 coeffs = &rec601_coeffs; 1141 break; 1142 case V4L2_YCBCR_ENC_709: 1143 coeffs = &rec709_coeffs; 1144 break; 1145 case V4L2_YCBCR_ENC_BT2020: 1146 coeffs = &rec2020_coeffs; 1147 break; 1148 case V4L2_YCBCR_ENC_SMPTE240M: 1149 coeffs = &smpte240m_coeffs; 1150 break; 1151 } 1152 1153 if (params->quantization == V4L2_QUANTIZATION_FULL_RANGE) { 1154 csm = coeffs->full; 1155 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_CTRL, 1156 RKISP1_CIF_ISP_CTRL_ISP_CSM_Y_FULL_ENA | 1157 RKISP1_CIF_ISP_CTRL_ISP_CSM_C_FULL_ENA); 1158 } else { 1159 csm = coeffs->limited; 1160 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_CTRL, 1161 RKISP1_CIF_ISP_CTRL_ISP_CSM_Y_FULL_ENA | 1162 RKISP1_CIF_ISP_CTRL_ISP_CSM_C_FULL_ENA); 1163 } 1164 1165 for (i = 0; i < 9; i++) 1166 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_CC_COEFF_0 + i * 4, 1167 csm[i]); 1168 } 1169 1170 /* ISP De-noise Pre-Filter(DPF) function */ 1171 static void rkisp1_dpf_config(struct rkisp1_params *params, 1172 const struct rkisp1_cif_isp_dpf_config *arg) 1173 { 1174 unsigned int isp_dpf_mode, spatial_coeff, i; 1175 1176 switch (arg->gain.mode) { 1177 case RKISP1_CIF_ISP_DPF_GAIN_USAGE_NF_GAINS: 1178 isp_dpf_mode = RKISP1_CIF_ISP_DPF_MODE_USE_NF_GAIN | 1179 RKISP1_CIF_ISP_DPF_MODE_AWB_GAIN_COMP; 1180 break; 1181 case RKISP1_CIF_ISP_DPF_GAIN_USAGE_LSC_GAINS: 1182 isp_dpf_mode = RKISP1_CIF_ISP_DPF_MODE_LSC_GAIN_COMP; 1183 break; 1184 case RKISP1_CIF_ISP_DPF_GAIN_USAGE_NF_LSC_GAINS: 1185 isp_dpf_mode = RKISP1_CIF_ISP_DPF_MODE_USE_NF_GAIN | 1186 RKISP1_CIF_ISP_DPF_MODE_AWB_GAIN_COMP | 1187 RKISP1_CIF_ISP_DPF_MODE_LSC_GAIN_COMP; 1188 break; 1189 case RKISP1_CIF_ISP_DPF_GAIN_USAGE_AWB_GAINS: 1190 isp_dpf_mode = RKISP1_CIF_ISP_DPF_MODE_AWB_GAIN_COMP; 1191 break; 1192 case RKISP1_CIF_ISP_DPF_GAIN_USAGE_AWB_LSC_GAINS: 1193 isp_dpf_mode = RKISP1_CIF_ISP_DPF_MODE_LSC_GAIN_COMP | 1194 RKISP1_CIF_ISP_DPF_MODE_AWB_GAIN_COMP; 1195 break; 1196 case RKISP1_CIF_ISP_DPF_GAIN_USAGE_DISABLED: 1197 default: 1198 isp_dpf_mode = 0; 1199 break; 1200 } 1201 1202 if (arg->nll.scale_mode == RKISP1_CIF_ISP_NLL_SCALE_LOGARITHMIC) 1203 isp_dpf_mode |= RKISP1_CIF_ISP_DPF_MODE_NLL_SEGMENTATION; 1204 if (arg->rb_flt.fltsize == RKISP1_CIF_ISP_DPF_RB_FILTERSIZE_9x9) 1205 isp_dpf_mode |= RKISP1_CIF_ISP_DPF_MODE_RB_FLTSIZE_9x9; 1206 if (!arg->rb_flt.r_enable) 1207 isp_dpf_mode |= RKISP1_CIF_ISP_DPF_MODE_R_FLT_DIS; 1208 if (!arg->rb_flt.b_enable) 1209 isp_dpf_mode |= RKISP1_CIF_ISP_DPF_MODE_B_FLT_DIS; 1210 if (!arg->g_flt.gb_enable) 1211 isp_dpf_mode |= RKISP1_CIF_ISP_DPF_MODE_GB_FLT_DIS; 1212 if (!arg->g_flt.gr_enable) 1213 isp_dpf_mode |= RKISP1_CIF_ISP_DPF_MODE_GR_FLT_DIS; 1214 1215 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_DPF_MODE, 1216 isp_dpf_mode); 1217 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPF_NF_GAIN_B, 1218 arg->gain.nf_b_gain); 1219 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPF_NF_GAIN_R, 1220 arg->gain.nf_r_gain); 1221 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPF_NF_GAIN_GB, 1222 arg->gain.nf_gb_gain); 1223 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPF_NF_GAIN_GR, 1224 arg->gain.nf_gr_gain); 1225 1226 for (i = 0; i < RKISP1_CIF_ISP_DPF_MAX_NLF_COEFFS; i++) { 1227 rkisp1_write(params->rkisp1, 1228 RKISP1_CIF_ISP_DPF_NULL_COEFF_0 + i * 4, 1229 arg->nll.coeff[i]); 1230 } 1231 1232 spatial_coeff = arg->g_flt.spatial_coeff[0] | 1233 (arg->g_flt.spatial_coeff[1] << 8) | 1234 (arg->g_flt.spatial_coeff[2] << 16) | 1235 (arg->g_flt.spatial_coeff[3] << 24); 1236 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPF_S_WEIGHT_G_1_4, 1237 spatial_coeff); 1238 1239 spatial_coeff = arg->g_flt.spatial_coeff[4] | 1240 (arg->g_flt.spatial_coeff[5] << 8); 1241 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPF_S_WEIGHT_G_5_6, 1242 spatial_coeff); 1243 1244 spatial_coeff = arg->rb_flt.spatial_coeff[0] | 1245 (arg->rb_flt.spatial_coeff[1] << 8) | 1246 (arg->rb_flt.spatial_coeff[2] << 16) | 1247 (arg->rb_flt.spatial_coeff[3] << 24); 1248 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPF_S_WEIGHT_RB_1_4, 1249 spatial_coeff); 1250 1251 spatial_coeff = arg->rb_flt.spatial_coeff[4] | 1252 (arg->rb_flt.spatial_coeff[5] << 8); 1253 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPF_S_WEIGHT_RB_5_6, 1254 spatial_coeff); 1255 } 1256 1257 static void 1258 rkisp1_dpf_strength_config(struct rkisp1_params *params, 1259 const struct rkisp1_cif_isp_dpf_strength_config *arg) 1260 { 1261 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPF_STRENGTH_B, arg->b); 1262 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPF_STRENGTH_G, arg->g); 1263 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_DPF_STRENGTH_R, arg->r); 1264 } 1265 1266 static void rkisp1_compand_write_px_curve(struct rkisp1_params *params, 1267 unsigned int addr, const u8 *curve) 1268 { 1269 const unsigned int points_per_reg = 6; 1270 const unsigned int num_regs = 1271 DIV_ROUND_UP(RKISP1_CIF_ISP_COMPAND_NUM_POINTS, 1272 points_per_reg); 1273 1274 /* 1275 * The compand curve is specified as a piecewise linear function with 1276 * 64 points. X coordinates are stored as a log2 of the displacement 1277 * from the previous point, in 5 bits, with 6 values per register. The 1278 * last register stores 4 values. 1279 */ 1280 for (unsigned int reg = 0; reg < num_regs; ++reg) { 1281 unsigned int num_points = 1282 min(RKISP1_CIF_ISP_COMPAND_NUM_POINTS - 1283 reg * points_per_reg, points_per_reg); 1284 u32 val = 0; 1285 1286 for (unsigned int i = 0; i < num_points; i++) 1287 val |= (*curve++ & 0x1f) << (i * 5); 1288 1289 rkisp1_write(params->rkisp1, addr, val); 1290 addr += 4; 1291 } 1292 } 1293 1294 static void 1295 rkisp1_compand_write_curve_mem(struct rkisp1_params *params, 1296 unsigned int reg_addr, unsigned int reg_data, 1297 const u32 curve[RKISP1_CIF_ISP_COMPAND_NUM_POINTS]) 1298 { 1299 for (unsigned int i = 0; i < RKISP1_CIF_ISP_COMPAND_NUM_POINTS; i++) { 1300 rkisp1_write(params->rkisp1, reg_addr, i); 1301 rkisp1_write(params->rkisp1, reg_data, curve[i]); 1302 } 1303 } 1304 1305 static void 1306 rkisp1_compand_bls_config(struct rkisp1_params *params, 1307 const struct rkisp1_cif_isp_compand_bls_config *arg) 1308 { 1309 static const u32 regs[] = { 1310 RKISP1_CIF_ISP_COMPAND_BLS_A_FIXED, 1311 RKISP1_CIF_ISP_COMPAND_BLS_B_FIXED, 1312 RKISP1_CIF_ISP_COMPAND_BLS_C_FIXED, 1313 RKISP1_CIF_ISP_COMPAND_BLS_D_FIXED, 1314 }; 1315 u32 swapped[4]; 1316 1317 rkisp1_bls_swap_regs(params->raw_type, regs, swapped); 1318 1319 rkisp1_write(params->rkisp1, swapped[0], arg->r); 1320 rkisp1_write(params->rkisp1, swapped[1], arg->gr); 1321 rkisp1_write(params->rkisp1, swapped[2], arg->gb); 1322 rkisp1_write(params->rkisp1, swapped[3], arg->b); 1323 } 1324 1325 static void 1326 rkisp1_compand_expand_config(struct rkisp1_params *params, 1327 const struct rkisp1_cif_isp_compand_curve_config *arg) 1328 { 1329 rkisp1_compand_write_px_curve(params, RKISP1_CIF_ISP_COMPAND_EXPAND_PX_N(0), 1330 arg->px); 1331 rkisp1_compand_write_curve_mem(params, RKISP1_CIF_ISP_COMPAND_EXPAND_Y_ADDR, 1332 RKISP1_CIF_ISP_COMPAND_EXPAND_Y_WRITE_DATA, 1333 arg->y); 1334 rkisp1_compand_write_curve_mem(params, RKISP1_CIF_ISP_COMPAND_EXPAND_X_ADDR, 1335 RKISP1_CIF_ISP_COMPAND_EXPAND_X_WRITE_DATA, 1336 arg->x); 1337 } 1338 1339 static void 1340 rkisp1_compand_compress_config(struct rkisp1_params *params, 1341 const struct rkisp1_cif_isp_compand_curve_config *arg) 1342 { 1343 rkisp1_compand_write_px_curve(params, RKISP1_CIF_ISP_COMPAND_COMPRESS_PX_N(0), 1344 arg->px); 1345 rkisp1_compand_write_curve_mem(params, RKISP1_CIF_ISP_COMPAND_COMPRESS_Y_ADDR, 1346 RKISP1_CIF_ISP_COMPAND_COMPRESS_Y_WRITE_DATA, 1347 arg->y); 1348 rkisp1_compand_write_curve_mem(params, RKISP1_CIF_ISP_COMPAND_COMPRESS_X_ADDR, 1349 RKISP1_CIF_ISP_COMPAND_COMPRESS_X_WRITE_DATA, 1350 arg->x); 1351 } 1352 1353 static void rkisp1_wdr_config(struct rkisp1_params *params, 1354 const struct rkisp1_cif_isp_wdr_config *arg) 1355 { 1356 unsigned int i; 1357 u32 value; 1358 1359 value = rkisp1_read(params->rkisp1, RKISP1_CIF_ISP_WDR_CTRL) 1360 & ~(RKISP1_CIF_ISP_WDR_USE_IREF | 1361 RKISP1_CIF_ISP_WDR_COLOR_SPACE_SELECT | 1362 RKISP1_CIF_ISP_WDR_CR_MAPPING_DISABLE | 1363 RKISP1_CIF_ISP_WDR_USE_Y9_8 | 1364 RKISP1_CIF_ISP_WDR_USE_RGB7_8 | 1365 RKISP1_CIF_ISP_WDR_DISABLE_TRANSIENT | 1366 RKISP1_CIF_ISP_WDR_RGB_FACTOR_MASK); 1367 1368 /* Colorspace and chrominance mapping */ 1369 if (arg->use_rgb_colorspace) 1370 value |= RKISP1_CIF_ISP_WDR_COLOR_SPACE_SELECT; 1371 1372 if (!arg->use_rgb_colorspace && arg->bypass_chroma_mapping) 1373 value |= RKISP1_CIF_ISP_WDR_CR_MAPPING_DISABLE; 1374 1375 /* Illumination reference */ 1376 if (arg->use_iref) { 1377 value |= RKISP1_CIF_ISP_WDR_USE_IREF; 1378 1379 if (arg->iref_config.use_y9_8) 1380 value |= RKISP1_CIF_ISP_WDR_USE_Y9_8; 1381 1382 if (arg->iref_config.use_rgb7_8) 1383 value |= RKISP1_CIF_ISP_WDR_USE_RGB7_8; 1384 1385 if (arg->iref_config.disable_transient) 1386 value |= RKISP1_CIF_ISP_WDR_DISABLE_TRANSIENT; 1387 1388 value |= FIELD_PREP(RKISP1_CIF_ISP_WDR_RGB_FACTOR_MASK, 1389 min(arg->iref_config.rgb_factor, 1390 RKISP1_CIF_ISP_WDR_RGB_FACTOR_MAX)); 1391 } 1392 1393 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_WDR_CTRL, value); 1394 1395 /* RGB and Luminance offsets */ 1396 value = FIELD_PREP(RKISP1_CIF_ISP_WDR_RGB_OFFSET_MASK, 1397 arg->rgb_offset) 1398 | FIELD_PREP(RKISP1_CIF_ISP_WDR_LUM_OFFSET_MASK, 1399 arg->luma_offset); 1400 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_WDR_OFFSET, value); 1401 1402 /* DeltaMin */ 1403 value = FIELD_PREP(RKISP1_CIF_ISP_WDR_DMIN_THRESH_MASK, 1404 arg->dmin_thresh) 1405 | FIELD_PREP(RKISP1_CIF_ISP_WDR_DMIN_STRENGTH_MASK, 1406 min(arg->dmin_strength, 1407 RKISP1_CIF_ISP_WDR_DMIN_STRENGTH_MAX)); 1408 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_WDR_DELTAMIN, value); 1409 1410 /* Tone curve */ 1411 for (i = 0; i < RKISP1_CIF_ISP_WDR_CURVE_NUM_DY_REGS; i++) 1412 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_WDR_TONECURVE(i), 1413 arg->tone_curve.dY[i]); 1414 for (i = 0; i < RKISP1_CIF_ISP_WDR_CURVE_NUM_COEFF; i++) 1415 rkisp1_write(params->rkisp1, RKISP1_CIF_ISP_WDR_TONECURVE_YM(i), 1416 arg->tone_curve.ym[i] & 1417 RKISP1_CIF_ISP_WDR_TONE_CURVE_YM_MASK); 1418 } 1419 1420 static void 1421 rkisp1_isp_isr_other_config(struct rkisp1_params *params, 1422 const struct rkisp1_params_cfg *new_params) 1423 { 1424 unsigned int module_en_update, module_cfg_update, module_ens; 1425 1426 module_en_update = new_params->module_en_update; 1427 module_cfg_update = new_params->module_cfg_update; 1428 module_ens = new_params->module_ens; 1429 1430 if (!rkisp1_has_feature(params->rkisp1, BLS)) { 1431 module_en_update &= ~RKISP1_CIF_ISP_MODULE_BLS; 1432 module_cfg_update &= ~RKISP1_CIF_ISP_MODULE_BLS; 1433 module_ens &= ~RKISP1_CIF_ISP_MODULE_BLS; 1434 } 1435 1436 /* update dpc config */ 1437 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_DPCC) 1438 rkisp1_dpcc_config(params, 1439 &new_params->others.dpcc_config); 1440 1441 if (module_en_update & RKISP1_CIF_ISP_MODULE_DPCC) { 1442 if (module_ens & RKISP1_CIF_ISP_MODULE_DPCC) 1443 rkisp1_param_set_bits(params, 1444 RKISP1_CIF_ISP_DPCC_MODE, 1445 RKISP1_CIF_ISP_DPCC_MODE_DPCC_ENABLE); 1446 else 1447 rkisp1_param_clear_bits(params, 1448 RKISP1_CIF_ISP_DPCC_MODE, 1449 RKISP1_CIF_ISP_DPCC_MODE_DPCC_ENABLE); 1450 } 1451 1452 /* update bls config */ 1453 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_BLS) 1454 rkisp1_bls_config(params, 1455 &new_params->others.bls_config); 1456 1457 if (module_en_update & RKISP1_CIF_ISP_MODULE_BLS) { 1458 if (module_ens & RKISP1_CIF_ISP_MODULE_BLS) 1459 rkisp1_param_set_bits(params, 1460 RKISP1_CIF_ISP_BLS_CTRL, 1461 RKISP1_CIF_ISP_BLS_ENA); 1462 else 1463 rkisp1_param_clear_bits(params, 1464 RKISP1_CIF_ISP_BLS_CTRL, 1465 RKISP1_CIF_ISP_BLS_ENA); 1466 } 1467 1468 /* update sdg config */ 1469 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_SDG) 1470 rkisp1_sdg_config(params, 1471 &new_params->others.sdg_config); 1472 1473 if (module_en_update & RKISP1_CIF_ISP_MODULE_SDG) { 1474 if (module_ens & RKISP1_CIF_ISP_MODULE_SDG) 1475 rkisp1_param_set_bits(params, 1476 RKISP1_CIF_ISP_CTRL, 1477 RKISP1_CIF_ISP_CTRL_ISP_GAMMA_IN_ENA); 1478 else 1479 rkisp1_param_clear_bits(params, 1480 RKISP1_CIF_ISP_CTRL, 1481 RKISP1_CIF_ISP_CTRL_ISP_GAMMA_IN_ENA); 1482 } 1483 1484 /* update awb gains */ 1485 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_AWB_GAIN) 1486 params->ops->awb_gain_config(params, &new_params->others.awb_gain_config); 1487 1488 if (module_en_update & RKISP1_CIF_ISP_MODULE_AWB_GAIN) { 1489 if (module_ens & RKISP1_CIF_ISP_MODULE_AWB_GAIN) 1490 rkisp1_param_set_bits(params, 1491 RKISP1_CIF_ISP_CTRL, 1492 RKISP1_CIF_ISP_CTRL_ISP_AWB_ENA); 1493 else 1494 rkisp1_param_clear_bits(params, 1495 RKISP1_CIF_ISP_CTRL, 1496 RKISP1_CIF_ISP_CTRL_ISP_AWB_ENA); 1497 } 1498 1499 /* update bdm config */ 1500 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_BDM) 1501 rkisp1_bdm_config(params, 1502 &new_params->others.bdm_config); 1503 1504 if (module_en_update & RKISP1_CIF_ISP_MODULE_BDM) { 1505 if (module_ens & RKISP1_CIF_ISP_MODULE_BDM) 1506 rkisp1_param_set_bits(params, 1507 RKISP1_CIF_ISP_DEMOSAIC, 1508 RKISP1_CIF_ISP_DEMOSAIC_BYPASS); 1509 else 1510 rkisp1_param_clear_bits(params, 1511 RKISP1_CIF_ISP_DEMOSAIC, 1512 RKISP1_CIF_ISP_DEMOSAIC_BYPASS); 1513 } 1514 1515 /* update filter config */ 1516 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_FLT) 1517 rkisp1_flt_config(params, 1518 &new_params->others.flt_config); 1519 1520 if (module_en_update & RKISP1_CIF_ISP_MODULE_FLT) { 1521 if (module_ens & RKISP1_CIF_ISP_MODULE_FLT) 1522 rkisp1_param_set_bits(params, 1523 RKISP1_CIF_ISP_FILT_MODE, 1524 RKISP1_CIF_ISP_FLT_ENA); 1525 else 1526 rkisp1_param_clear_bits(params, 1527 RKISP1_CIF_ISP_FILT_MODE, 1528 RKISP1_CIF_ISP_FLT_ENA); 1529 } 1530 1531 /* update ctk config */ 1532 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_CTK) 1533 rkisp1_ctk_config(params, 1534 &new_params->others.ctk_config); 1535 1536 if (module_en_update & RKISP1_CIF_ISP_MODULE_CTK) 1537 rkisp1_ctk_enable(params, !!(module_ens & RKISP1_CIF_ISP_MODULE_CTK)); 1538 1539 /* update goc config */ 1540 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_GOC) 1541 params->ops->goc_config(params, &new_params->others.goc_config); 1542 1543 if (module_en_update & RKISP1_CIF_ISP_MODULE_GOC) { 1544 if (module_ens & RKISP1_CIF_ISP_MODULE_GOC) 1545 rkisp1_param_set_bits(params, 1546 RKISP1_CIF_ISP_CTRL, 1547 RKISP1_CIF_ISP_CTRL_ISP_GAMMA_OUT_ENA); 1548 else 1549 rkisp1_param_clear_bits(params, 1550 RKISP1_CIF_ISP_CTRL, 1551 RKISP1_CIF_ISP_CTRL_ISP_GAMMA_OUT_ENA); 1552 } 1553 1554 /* update cproc config */ 1555 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_CPROC) 1556 rkisp1_cproc_config(params, 1557 &new_params->others.cproc_config); 1558 1559 if (module_en_update & RKISP1_CIF_ISP_MODULE_CPROC) { 1560 if (module_ens & RKISP1_CIF_ISP_MODULE_CPROC) 1561 rkisp1_param_set_bits(params, 1562 RKISP1_CIF_C_PROC_CTRL, 1563 RKISP1_CIF_C_PROC_CTR_ENABLE); 1564 else 1565 rkisp1_param_clear_bits(params, 1566 RKISP1_CIF_C_PROC_CTRL, 1567 RKISP1_CIF_C_PROC_CTR_ENABLE); 1568 } 1569 1570 /* update ie config */ 1571 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_IE) 1572 rkisp1_ie_config(params, &new_params->others.ie_config); 1573 1574 if (module_en_update & RKISP1_CIF_ISP_MODULE_IE) 1575 rkisp1_ie_enable(params, !!(module_ens & RKISP1_CIF_ISP_MODULE_IE)); 1576 1577 /* update dpf config */ 1578 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_DPF) 1579 rkisp1_dpf_config(params, &new_params->others.dpf_config); 1580 1581 if (module_en_update & RKISP1_CIF_ISP_MODULE_DPF) { 1582 if (module_ens & RKISP1_CIF_ISP_MODULE_DPF) 1583 rkisp1_param_set_bits(params, 1584 RKISP1_CIF_ISP_DPF_MODE, 1585 RKISP1_CIF_ISP_DPF_MODE_EN); 1586 else 1587 rkisp1_param_clear_bits(params, 1588 RKISP1_CIF_ISP_DPF_MODE, 1589 RKISP1_CIF_ISP_DPF_MODE_EN); 1590 } 1591 1592 if ((module_en_update & RKISP1_CIF_ISP_MODULE_DPF_STRENGTH) || 1593 (module_cfg_update & RKISP1_CIF_ISP_MODULE_DPF_STRENGTH)) { 1594 /* update dpf strength config */ 1595 rkisp1_dpf_strength_config(params, 1596 &new_params->others.dpf_strength_config); 1597 } 1598 } 1599 1600 static void 1601 rkisp1_isp_isr_lsc_config(struct rkisp1_params *params, 1602 const struct rkisp1_params_cfg *new_params) 1603 { 1604 unsigned int module_en_update, module_cfg_update, module_ens; 1605 1606 module_en_update = new_params->module_en_update; 1607 module_cfg_update = new_params->module_cfg_update; 1608 module_ens = new_params->module_ens; 1609 1610 /* update lsc config */ 1611 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_LSC) 1612 rkisp1_lsc_config(params, 1613 &new_params->others.lsc_config); 1614 1615 if (module_en_update & RKISP1_CIF_ISP_MODULE_LSC) { 1616 if (module_ens & RKISP1_CIF_ISP_MODULE_LSC) 1617 rkisp1_param_set_bits(params, 1618 RKISP1_CIF_ISP_LSC_CTRL, 1619 RKISP1_CIF_ISP_LSC_CTRL_ENA); 1620 else 1621 rkisp1_param_clear_bits(params, 1622 RKISP1_CIF_ISP_LSC_CTRL, 1623 RKISP1_CIF_ISP_LSC_CTRL_ENA); 1624 } 1625 } 1626 1627 static void rkisp1_isp_isr_meas_config(struct rkisp1_params *params, 1628 struct rkisp1_params_cfg *new_params) 1629 { 1630 unsigned int module_en_update, module_cfg_update, module_ens; 1631 1632 module_en_update = new_params->module_en_update; 1633 module_cfg_update = new_params->module_cfg_update; 1634 module_ens = new_params->module_ens; 1635 1636 /* update awb config */ 1637 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_AWB) 1638 params->ops->awb_meas_config(params, &new_params->meas.awb_meas_config); 1639 1640 if (module_en_update & RKISP1_CIF_ISP_MODULE_AWB) 1641 params->ops->awb_meas_enable(params, 1642 &new_params->meas.awb_meas_config, 1643 !!(module_ens & RKISP1_CIF_ISP_MODULE_AWB)); 1644 1645 /* update afc config */ 1646 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_AFC) 1647 params->ops->afm_config(params, 1648 &new_params->meas.afc_config); 1649 1650 if (module_en_update & RKISP1_CIF_ISP_MODULE_AFC) { 1651 if (module_ens & RKISP1_CIF_ISP_MODULE_AFC) 1652 rkisp1_param_set_bits(params, 1653 RKISP1_CIF_ISP_AFM_CTRL, 1654 RKISP1_CIF_ISP_AFM_ENA); 1655 else 1656 rkisp1_param_clear_bits(params, 1657 RKISP1_CIF_ISP_AFM_CTRL, 1658 RKISP1_CIF_ISP_AFM_ENA); 1659 } 1660 1661 /* update hst config */ 1662 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_HST) 1663 params->ops->hst_config(params, 1664 &new_params->meas.hst_config); 1665 1666 if (module_en_update & RKISP1_CIF_ISP_MODULE_HST) 1667 params->ops->hst_enable(params, 1668 &new_params->meas.hst_config, 1669 !!(module_ens & RKISP1_CIF_ISP_MODULE_HST)); 1670 1671 /* update aec config */ 1672 if (module_cfg_update & RKISP1_CIF_ISP_MODULE_AEC) 1673 params->ops->aec_config(params, 1674 &new_params->meas.aec_config); 1675 1676 if (module_en_update & RKISP1_CIF_ISP_MODULE_AEC) { 1677 if (module_ens & RKISP1_CIF_ISP_MODULE_AEC) 1678 rkisp1_param_set_bits(params, 1679 RKISP1_CIF_ISP_EXP_CTRL, 1680 RKISP1_CIF_ISP_EXP_ENA); 1681 else 1682 rkisp1_param_clear_bits(params, 1683 RKISP1_CIF_ISP_EXP_CTRL, 1684 RKISP1_CIF_ISP_EXP_ENA); 1685 } 1686 } 1687 1688 /*------------------------------------------------------------------------------ 1689 * Extensible parameters format handling 1690 */ 1691 1692 static void 1693 rkisp1_ext_params_bls(struct rkisp1_params *params, 1694 const union rkisp1_ext_params_config *block) 1695 { 1696 const struct rkisp1_ext_params_bls_config *bls = &block->bls; 1697 1698 if (bls->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1699 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_BLS_CTRL, 1700 RKISP1_CIF_ISP_BLS_ENA); 1701 return; 1702 } 1703 1704 rkisp1_bls_config(params, &bls->config); 1705 1706 if ((bls->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1707 !(params->enabled_blocks & BIT(bls->header.type))) 1708 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_BLS_CTRL, 1709 RKISP1_CIF_ISP_BLS_ENA); 1710 } 1711 1712 static void 1713 rkisp1_ext_params_dpcc(struct rkisp1_params *params, 1714 const union rkisp1_ext_params_config *block) 1715 { 1716 const struct rkisp1_ext_params_dpcc_config *dpcc = &block->dpcc; 1717 1718 if (dpcc->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1719 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_DPCC_MODE, 1720 RKISP1_CIF_ISP_DPCC_MODE_DPCC_ENABLE); 1721 return; 1722 } 1723 1724 rkisp1_dpcc_config(params, &dpcc->config); 1725 1726 if ((dpcc->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1727 !(params->enabled_blocks & BIT(dpcc->header.type))) 1728 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_DPCC_MODE, 1729 RKISP1_CIF_ISP_DPCC_MODE_DPCC_ENABLE); 1730 } 1731 1732 static void 1733 rkisp1_ext_params_sdg(struct rkisp1_params *params, 1734 const union rkisp1_ext_params_config *block) 1735 { 1736 const struct rkisp1_ext_params_sdg_config *sdg = &block->sdg; 1737 1738 if (sdg->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1739 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_CTRL, 1740 RKISP1_CIF_ISP_CTRL_ISP_GAMMA_IN_ENA); 1741 return; 1742 } 1743 1744 rkisp1_sdg_config(params, &sdg->config); 1745 1746 if ((sdg->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1747 !(params->enabled_blocks & BIT(sdg->header.type))) 1748 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_CTRL, 1749 RKISP1_CIF_ISP_CTRL_ISP_GAMMA_IN_ENA); 1750 } 1751 1752 static void 1753 rkisp1_ext_params_lsc(struct rkisp1_params *params, 1754 const union rkisp1_ext_params_config *block) 1755 { 1756 const struct rkisp1_ext_params_lsc_config *lsc = &block->lsc; 1757 1758 if (lsc->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1759 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_LSC_CTRL, 1760 RKISP1_CIF_ISP_LSC_CTRL_ENA); 1761 return; 1762 } 1763 1764 rkisp1_lsc_config(params, &lsc->config); 1765 1766 if ((lsc->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1767 !(params->enabled_blocks & BIT(lsc->header.type))) 1768 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_LSC_CTRL, 1769 RKISP1_CIF_ISP_LSC_CTRL_ENA); 1770 } 1771 1772 static void 1773 rkisp1_ext_params_awbg(struct rkisp1_params *params, 1774 const union rkisp1_ext_params_config *block) 1775 { 1776 const struct rkisp1_ext_params_awb_gain_config *awbg = &block->awbg; 1777 1778 if (awbg->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1779 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_CTRL, 1780 RKISP1_CIF_ISP_CTRL_ISP_AWB_ENA); 1781 return; 1782 } 1783 1784 params->ops->awb_gain_config(params, &awbg->config); 1785 1786 if ((awbg->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1787 !(params->enabled_blocks & BIT(awbg->header.type))) 1788 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_CTRL, 1789 RKISP1_CIF_ISP_CTRL_ISP_AWB_ENA); 1790 } 1791 1792 static void 1793 rkisp1_ext_params_flt(struct rkisp1_params *params, 1794 const union rkisp1_ext_params_config *block) 1795 { 1796 const struct rkisp1_ext_params_flt_config *flt = &block->flt; 1797 1798 if (flt->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1799 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_FILT_MODE, 1800 RKISP1_CIF_ISP_FLT_ENA); 1801 return; 1802 } 1803 1804 rkisp1_flt_config(params, &flt->config); 1805 1806 if ((flt->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1807 !(params->enabled_blocks & BIT(flt->header.type))) 1808 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_FILT_MODE, 1809 RKISP1_CIF_ISP_FLT_ENA); 1810 } 1811 1812 static void 1813 rkisp1_ext_params_bdm(struct rkisp1_params *params, 1814 const union rkisp1_ext_params_config *block) 1815 { 1816 const struct rkisp1_ext_params_bdm_config *bdm = &block->bdm; 1817 1818 if (bdm->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1819 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_DEMOSAIC, 1820 RKISP1_CIF_ISP_DEMOSAIC_BYPASS); 1821 return; 1822 } 1823 1824 rkisp1_bdm_config(params, &bdm->config); 1825 1826 if ((bdm->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1827 !(params->enabled_blocks & BIT(bdm->header.type))) 1828 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_DEMOSAIC, 1829 RKISP1_CIF_ISP_DEMOSAIC_BYPASS); 1830 } 1831 1832 static void 1833 rkisp1_ext_params_ctk(struct rkisp1_params *params, 1834 const union rkisp1_ext_params_config *block) 1835 { 1836 const struct rkisp1_ext_params_ctk_config *ctk = &block->ctk; 1837 1838 if (ctk->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1839 rkisp1_ctk_enable(params, false); 1840 return; 1841 } 1842 1843 rkisp1_ctk_config(params, &ctk->config); 1844 1845 if ((ctk->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1846 !(params->enabled_blocks & BIT(ctk->header.type))) 1847 rkisp1_ctk_enable(params, true); 1848 } 1849 1850 static void 1851 rkisp1_ext_params_goc(struct rkisp1_params *params, 1852 const union rkisp1_ext_params_config *block) 1853 { 1854 const struct rkisp1_ext_params_goc_config *goc = &block->goc; 1855 1856 if (goc->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1857 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_CTRL, 1858 RKISP1_CIF_ISP_CTRL_ISP_GAMMA_OUT_ENA); 1859 return; 1860 } 1861 1862 params->ops->goc_config(params, &goc->config); 1863 1864 /* 1865 * Unconditionally re-enable the GOC module which gets disabled by 1866 * goc_config(). 1867 */ 1868 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_CTRL, 1869 RKISP1_CIF_ISP_CTRL_ISP_GAMMA_OUT_ENA); 1870 } 1871 1872 static void 1873 rkisp1_ext_params_dpf(struct rkisp1_params *params, 1874 const union rkisp1_ext_params_config *block) 1875 { 1876 const struct rkisp1_ext_params_dpf_config *dpf = &block->dpf; 1877 1878 if (dpf->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1879 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_DPF_MODE, 1880 RKISP1_CIF_ISP_DPF_MODE_EN); 1881 return; 1882 } 1883 1884 rkisp1_dpf_config(params, &dpf->config); 1885 1886 if ((dpf->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1887 !(params->enabled_blocks & BIT(dpf->header.type))) 1888 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_DPF_MODE, 1889 RKISP1_CIF_ISP_DPF_MODE_EN); 1890 } 1891 1892 static void 1893 rkisp1_ext_params_dpfs(struct rkisp1_params *params, 1894 const union rkisp1_ext_params_config *block) 1895 { 1896 const struct rkisp1_ext_params_dpf_strength_config *dpfs = &block->dpfs; 1897 1898 rkisp1_dpf_strength_config(params, &dpfs->config); 1899 } 1900 1901 static void 1902 rkisp1_ext_params_cproc(struct rkisp1_params *params, 1903 const union rkisp1_ext_params_config *block) 1904 { 1905 const struct rkisp1_ext_params_cproc_config *cproc = &block->cproc; 1906 1907 if (cproc->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1908 rkisp1_param_clear_bits(params, RKISP1_CIF_C_PROC_CTRL, 1909 RKISP1_CIF_C_PROC_CTR_ENABLE); 1910 return; 1911 } 1912 1913 rkisp1_cproc_config(params, &cproc->config); 1914 1915 if ((cproc->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1916 !(params->enabled_blocks & BIT(cproc->header.type))) 1917 rkisp1_param_set_bits(params, RKISP1_CIF_C_PROC_CTRL, 1918 RKISP1_CIF_C_PROC_CTR_ENABLE); 1919 } 1920 1921 static void 1922 rkisp1_ext_params_ie(struct rkisp1_params *params, 1923 const union rkisp1_ext_params_config *block) 1924 { 1925 const struct rkisp1_ext_params_ie_config *ie = &block->ie; 1926 1927 if (ie->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1928 rkisp1_ie_enable(params, false); 1929 return; 1930 } 1931 1932 rkisp1_ie_config(params, &ie->config); 1933 1934 if ((ie->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1935 !(params->enabled_blocks & BIT(ie->header.type))) 1936 rkisp1_ie_enable(params, true); 1937 } 1938 1939 static void 1940 rkisp1_ext_params_awbm(struct rkisp1_params *params, 1941 const union rkisp1_ext_params_config *block) 1942 { 1943 const struct rkisp1_ext_params_awb_meas_config *awbm = &block->awbm; 1944 1945 if (awbm->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1946 params->ops->awb_meas_enable(params, &awbm->config, 1947 false); 1948 return; 1949 } 1950 1951 params->ops->awb_meas_config(params, &awbm->config); 1952 1953 if ((awbm->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1954 !(params->enabled_blocks & BIT(awbm->header.type))) 1955 params->ops->awb_meas_enable(params, &awbm->config, 1956 true); 1957 } 1958 1959 static void 1960 rkisp1_ext_params_hstm(struct rkisp1_params *params, 1961 const union rkisp1_ext_params_config *block) 1962 { 1963 const struct rkisp1_ext_params_hst_config *hst = &block->hst; 1964 1965 if (hst->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1966 params->ops->hst_enable(params, &hst->config, false); 1967 return; 1968 } 1969 1970 params->ops->hst_config(params, &hst->config); 1971 1972 if ((hst->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1973 !(params->enabled_blocks & BIT(hst->header.type))) 1974 params->ops->hst_enable(params, &hst->config, true); 1975 } 1976 1977 static void 1978 rkisp1_ext_params_aecm(struct rkisp1_params *params, 1979 const union rkisp1_ext_params_config *block) 1980 { 1981 const struct rkisp1_ext_params_aec_config *aec = &block->aec; 1982 1983 if (aec->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 1984 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_EXP_CTRL, 1985 RKISP1_CIF_ISP_EXP_ENA); 1986 return; 1987 } 1988 1989 params->ops->aec_config(params, &aec->config); 1990 1991 if ((aec->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 1992 !(params->enabled_blocks & BIT(aec->header.type))) 1993 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_EXP_CTRL, 1994 RKISP1_CIF_ISP_EXP_ENA); 1995 } 1996 1997 static void 1998 rkisp1_ext_params_afcm(struct rkisp1_params *params, 1999 const union rkisp1_ext_params_config *block) 2000 { 2001 const struct rkisp1_ext_params_afc_config *afc = &block->afc; 2002 2003 if (afc->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 2004 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_AFM_CTRL, 2005 RKISP1_CIF_ISP_AFM_ENA); 2006 return; 2007 } 2008 2009 params->ops->afm_config(params, &afc->config); 2010 2011 if ((afc->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 2012 !(params->enabled_blocks & BIT(afc->header.type))) 2013 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_AFM_CTRL, 2014 RKISP1_CIF_ISP_AFM_ENA); 2015 } 2016 2017 static void rkisp1_ext_params_compand_bls(struct rkisp1_params *params, 2018 const union rkisp1_ext_params_config *block) 2019 { 2020 const struct rkisp1_ext_params_compand_bls_config *bls = 2021 &block->compand_bls; 2022 2023 if (bls->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 2024 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_COMPAND_CTRL, 2025 RKISP1_CIF_ISP_COMPAND_CTRL_BLS_ENABLE); 2026 return; 2027 } 2028 2029 rkisp1_compand_bls_config(params, &bls->config); 2030 2031 if ((bls->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 2032 !(params->enabled_blocks & BIT(bls->header.type))) 2033 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_COMPAND_CTRL, 2034 RKISP1_CIF_ISP_COMPAND_CTRL_BLS_ENABLE); 2035 } 2036 2037 static void rkisp1_ext_params_compand_expand(struct rkisp1_params *params, 2038 const union rkisp1_ext_params_config *block) 2039 { 2040 const struct rkisp1_ext_params_compand_curve_config *curve = 2041 &block->compand_curve; 2042 2043 if (curve->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 2044 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_COMPAND_CTRL, 2045 RKISP1_CIF_ISP_COMPAND_CTRL_EXPAND_ENABLE); 2046 return; 2047 } 2048 2049 rkisp1_compand_expand_config(params, &curve->config); 2050 2051 if ((curve->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 2052 !(params->enabled_blocks & BIT(curve->header.type))) 2053 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_COMPAND_CTRL, 2054 RKISP1_CIF_ISP_COMPAND_CTRL_EXPAND_ENABLE); 2055 } 2056 2057 static void rkisp1_ext_params_compand_compress(struct rkisp1_params *params, 2058 const union rkisp1_ext_params_config *block) 2059 { 2060 const struct rkisp1_ext_params_compand_curve_config *curve = 2061 &block->compand_curve; 2062 2063 if (curve->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 2064 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_COMPAND_CTRL, 2065 RKISP1_CIF_ISP_COMPAND_CTRL_COMPRESS_ENABLE); 2066 return; 2067 } 2068 2069 rkisp1_compand_compress_config(params, &curve->config); 2070 2071 if ((curve->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 2072 !(params->enabled_blocks & BIT(curve->header.type))) 2073 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_COMPAND_CTRL, 2074 RKISP1_CIF_ISP_COMPAND_CTRL_COMPRESS_ENABLE); 2075 } 2076 2077 static void rkisp1_ext_params_wdr(struct rkisp1_params *params, 2078 const union rkisp1_ext_params_config *block) 2079 { 2080 const struct rkisp1_ext_params_wdr_config *wdr = &block->wdr; 2081 2082 if (wdr->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) { 2083 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_WDR_CTRL, 2084 RKISP1_CIF_ISP_WDR_CTRL_ENABLE); 2085 return; 2086 } 2087 2088 rkisp1_wdr_config(params, &wdr->config); 2089 2090 if ((wdr->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) && 2091 !(params->enabled_blocks & BIT(wdr->header.type))) 2092 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_WDR_CTRL, 2093 RKISP1_CIF_ISP_WDR_CTRL_ENABLE); 2094 } 2095 2096 typedef void (*rkisp1_block_handler)(struct rkisp1_params *params, 2097 const union rkisp1_ext_params_config *config); 2098 2099 static const struct rkisp1_ext_params_handler { 2100 size_t size; 2101 rkisp1_block_handler handler; 2102 unsigned int group; 2103 unsigned int features; 2104 } rkisp1_ext_params_handlers[] = { 2105 [RKISP1_EXT_PARAMS_BLOCK_TYPE_BLS] = { 2106 .size = sizeof(struct rkisp1_ext_params_bls_config), 2107 .handler = rkisp1_ext_params_bls, 2108 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2109 .features = RKISP1_FEATURE_BLS, 2110 }, 2111 [RKISP1_EXT_PARAMS_BLOCK_TYPE_DPCC] = { 2112 .size = sizeof(struct rkisp1_ext_params_dpcc_config), 2113 .handler = rkisp1_ext_params_dpcc, 2114 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2115 }, 2116 [RKISP1_EXT_PARAMS_BLOCK_TYPE_SDG] = { 2117 .size = sizeof(struct rkisp1_ext_params_sdg_config), 2118 .handler = rkisp1_ext_params_sdg, 2119 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2120 }, 2121 [RKISP1_EXT_PARAMS_BLOCK_TYPE_AWB_GAIN] = { 2122 .size = sizeof(struct rkisp1_ext_params_awb_gain_config), 2123 .handler = rkisp1_ext_params_awbg, 2124 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2125 }, 2126 [RKISP1_EXT_PARAMS_BLOCK_TYPE_FLT] = { 2127 .size = sizeof(struct rkisp1_ext_params_flt_config), 2128 .handler = rkisp1_ext_params_flt, 2129 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2130 }, 2131 [RKISP1_EXT_PARAMS_BLOCK_TYPE_BDM] = { 2132 .size = sizeof(struct rkisp1_ext_params_bdm_config), 2133 .handler = rkisp1_ext_params_bdm, 2134 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2135 }, 2136 [RKISP1_EXT_PARAMS_BLOCK_TYPE_CTK] = { 2137 .size = sizeof(struct rkisp1_ext_params_ctk_config), 2138 .handler = rkisp1_ext_params_ctk, 2139 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2140 }, 2141 [RKISP1_EXT_PARAMS_BLOCK_TYPE_GOC] = { 2142 .size = sizeof(struct rkisp1_ext_params_goc_config), 2143 .handler = rkisp1_ext_params_goc, 2144 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2145 }, 2146 [RKISP1_EXT_PARAMS_BLOCK_TYPE_DPF] = { 2147 .size = sizeof(struct rkisp1_ext_params_dpf_config), 2148 .handler = rkisp1_ext_params_dpf, 2149 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2150 }, 2151 [RKISP1_EXT_PARAMS_BLOCK_TYPE_DPF_STRENGTH] = { 2152 .size = sizeof(struct rkisp1_ext_params_dpf_strength_config), 2153 .handler = rkisp1_ext_params_dpfs, 2154 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2155 }, 2156 [RKISP1_EXT_PARAMS_BLOCK_TYPE_CPROC] = { 2157 .size = sizeof(struct rkisp1_ext_params_cproc_config), 2158 .handler = rkisp1_ext_params_cproc, 2159 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2160 }, 2161 [RKISP1_EXT_PARAMS_BLOCK_TYPE_IE] = { 2162 .size = sizeof(struct rkisp1_ext_params_ie_config), 2163 .handler = rkisp1_ext_params_ie, 2164 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2165 }, 2166 [RKISP1_EXT_PARAMS_BLOCK_TYPE_LSC] = { 2167 .size = sizeof(struct rkisp1_ext_params_lsc_config), 2168 .handler = rkisp1_ext_params_lsc, 2169 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_LSC, 2170 }, 2171 [RKISP1_EXT_PARAMS_BLOCK_TYPE_AWB_MEAS] = { 2172 .size = sizeof(struct rkisp1_ext_params_awb_meas_config), 2173 .handler = rkisp1_ext_params_awbm, 2174 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2175 }, 2176 [RKISP1_EXT_PARAMS_BLOCK_TYPE_HST_MEAS] = { 2177 .size = sizeof(struct rkisp1_ext_params_hst_config), 2178 .handler = rkisp1_ext_params_hstm, 2179 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2180 }, 2181 [RKISP1_EXT_PARAMS_BLOCK_TYPE_AEC_MEAS] = { 2182 .size = sizeof(struct rkisp1_ext_params_aec_config), 2183 .handler = rkisp1_ext_params_aecm, 2184 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2185 }, 2186 [RKISP1_EXT_PARAMS_BLOCK_TYPE_AFC_MEAS] = { 2187 .size = sizeof(struct rkisp1_ext_params_afc_config), 2188 .handler = rkisp1_ext_params_afcm, 2189 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2190 }, 2191 [RKISP1_EXT_PARAMS_BLOCK_TYPE_COMPAND_BLS] = { 2192 .size = sizeof(struct rkisp1_ext_params_compand_bls_config), 2193 .handler = rkisp1_ext_params_compand_bls, 2194 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2195 .features = RKISP1_FEATURE_COMPAND, 2196 }, 2197 [RKISP1_EXT_PARAMS_BLOCK_TYPE_COMPAND_EXPAND] = { 2198 .size = sizeof(struct rkisp1_ext_params_compand_curve_config), 2199 .handler = rkisp1_ext_params_compand_expand, 2200 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2201 .features = RKISP1_FEATURE_COMPAND, 2202 }, 2203 [RKISP1_EXT_PARAMS_BLOCK_TYPE_COMPAND_COMPRESS] = { 2204 .size = sizeof(struct rkisp1_ext_params_compand_curve_config), 2205 .handler = rkisp1_ext_params_compand_compress, 2206 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2207 .features = RKISP1_FEATURE_COMPAND, 2208 }, 2209 [RKISP1_EXT_PARAMS_BLOCK_TYPE_WDR] = { 2210 .size = sizeof(struct rkisp1_ext_params_wdr_config), 2211 .handler = rkisp1_ext_params_wdr, 2212 .group = RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS, 2213 }, 2214 }; 2215 2216 static void rkisp1_ext_params_config(struct rkisp1_params *params, 2217 struct rkisp1_ext_params_cfg *cfg, 2218 u32 block_group_mask) 2219 { 2220 size_t block_offset = 0; 2221 2222 if (WARN_ON(!cfg)) 2223 return; 2224 2225 /* Walk the list of parameter blocks and process them. */ 2226 while (block_offset < cfg->data_size) { 2227 const struct rkisp1_ext_params_handler *block_handler; 2228 const union rkisp1_ext_params_config *block; 2229 2230 block = (const union rkisp1_ext_params_config *) 2231 &cfg->data[block_offset]; 2232 block_offset += block->header.size; 2233 2234 /* 2235 * Make sure the block is supported by the platform and in the 2236 * list of groups to configure. 2237 */ 2238 block_handler = &rkisp1_ext_params_handlers[block->header.type]; 2239 if (!(block_handler->group & block_group_mask)) 2240 continue; 2241 2242 if ((params->rkisp1->info->features & block_handler->features) != 2243 block_handler->features) 2244 continue; 2245 2246 block_handler->handler(params, block); 2247 2248 if (block->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE) 2249 params->enabled_blocks &= ~BIT(block->header.type); 2250 else if (block->header.flags & RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE) 2251 params->enabled_blocks |= BIT(block->header.type); 2252 } 2253 } 2254 2255 static void rkisp1_params_complete_buffer(struct rkisp1_params *params, 2256 struct rkisp1_params_buffer *buf, 2257 unsigned int frame_sequence) 2258 { 2259 list_del(&buf->queue); 2260 2261 buf->vb.sequence = frame_sequence; 2262 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE); 2263 } 2264 2265 void rkisp1_params_isr(struct rkisp1_device *rkisp1) 2266 { 2267 struct rkisp1_params *params = &rkisp1->params; 2268 struct rkisp1_params_buffer *cur_buf; 2269 2270 spin_lock(¶ms->config_lock); 2271 2272 cur_buf = list_first_entry_or_null(¶ms->params, 2273 struct rkisp1_params_buffer, queue); 2274 if (!cur_buf) 2275 goto unlock; 2276 2277 if (params->metafmt->dataformat == V4L2_META_FMT_RK_ISP1_PARAMS) { 2278 rkisp1_isp_isr_other_config(params, cur_buf->cfg); 2279 rkisp1_isp_isr_lsc_config(params, cur_buf->cfg); 2280 rkisp1_isp_isr_meas_config(params, cur_buf->cfg); 2281 } else { 2282 rkisp1_ext_params_config(params, cur_buf->cfg, 2283 RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS | 2284 RKISP1_EXT_PARAMS_BLOCK_GROUP_LSC); 2285 } 2286 2287 /* update shadow register immediately */ 2288 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_CTRL, 2289 RKISP1_CIF_ISP_CTRL_ISP_CFG_UPD); 2290 2291 /* 2292 * This isr is called when the ISR finishes processing a frame 2293 * (RKISP1_CIF_ISP_FRAME). Configurations performed here will be 2294 * applied on the next frame. Since frame_sequence is updated on the 2295 * vertical sync signal, we should use frame_sequence + 1 here to 2296 * indicate to userspace on which frame these parameters are being 2297 * applied. 2298 */ 2299 rkisp1_params_complete_buffer(params, cur_buf, 2300 rkisp1->isp.frame_sequence + 1); 2301 2302 unlock: 2303 spin_unlock(¶ms->config_lock); 2304 } 2305 2306 static const struct rkisp1_cif_isp_awb_meas_config rkisp1_awb_params_default_config = { 2307 { 2308 0, 0, RKISP1_DEFAULT_WIDTH, RKISP1_DEFAULT_HEIGHT 2309 }, 2310 RKISP1_CIF_ISP_AWB_MODE_YCBCR, 200, 30, 20, 20, 0, 128, 128 2311 }; 2312 2313 static const struct rkisp1_cif_isp_aec_config rkisp1_aec_params_default_config = { 2314 RKISP1_CIF_ISP_EXP_MEASURING_MODE_0, 2315 RKISP1_CIF_ISP_EXP_CTRL_AUTOSTOP_0, 2316 { 2317 RKISP1_DEFAULT_WIDTH >> 2, RKISP1_DEFAULT_HEIGHT >> 2, 2318 RKISP1_DEFAULT_WIDTH >> 1, RKISP1_DEFAULT_HEIGHT >> 1 2319 } 2320 }; 2321 2322 static const struct rkisp1_cif_isp_hst_config rkisp1_hst_params_default_config = { 2323 RKISP1_CIF_ISP_HISTOGRAM_MODE_RGB_COMBINED, 2324 3, 2325 { 2326 RKISP1_DEFAULT_WIDTH >> 2, RKISP1_DEFAULT_HEIGHT >> 2, 2327 RKISP1_DEFAULT_WIDTH >> 1, RKISP1_DEFAULT_HEIGHT >> 1 2328 }, 2329 { 2330 0, /* To be filled in with 0x01 at runtime. */ 2331 } 2332 }; 2333 2334 static const struct rkisp1_cif_isp_afc_config rkisp1_afc_params_default_config = { 2335 1, 2336 { 2337 { 2338 300, 225, 200, 150 2339 } 2340 }, 2341 4, 2342 14 2343 }; 2344 2345 void rkisp1_params_pre_configure(struct rkisp1_params *params, 2346 enum rkisp1_fmt_raw_pat_type bayer_pat, 2347 enum v4l2_quantization quantization, 2348 enum v4l2_ycbcr_encoding ycbcr_encoding) 2349 { 2350 struct rkisp1_cif_isp_hst_config hst = rkisp1_hst_params_default_config; 2351 struct rkisp1_params_buffer *cur_buf; 2352 2353 params->quantization = quantization; 2354 params->ycbcr_encoding = ycbcr_encoding; 2355 params->raw_type = bayer_pat; 2356 2357 params->ops->awb_meas_config(params, &rkisp1_awb_params_default_config); 2358 params->ops->awb_meas_enable(params, &rkisp1_awb_params_default_config, 2359 true); 2360 2361 params->ops->aec_config(params, &rkisp1_aec_params_default_config); 2362 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_EXP_CTRL, 2363 RKISP1_CIF_ISP_EXP_ENA); 2364 2365 params->ops->afm_config(params, &rkisp1_afc_params_default_config); 2366 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_AFM_CTRL, 2367 RKISP1_CIF_ISP_AFM_ENA); 2368 2369 memset(hst.hist_weight, 0x01, sizeof(hst.hist_weight)); 2370 params->ops->hst_config(params, &hst); 2371 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_HIST_PROP_V10, 2372 rkisp1_hst_params_default_config.mode); 2373 2374 rkisp1_csm_config(params); 2375 2376 spin_lock_irq(¶ms->config_lock); 2377 2378 /* apply the first buffer if there is one already */ 2379 2380 cur_buf = list_first_entry_or_null(¶ms->params, 2381 struct rkisp1_params_buffer, queue); 2382 if (!cur_buf) 2383 goto unlock; 2384 2385 if (params->metafmt->dataformat == V4L2_META_FMT_RK_ISP1_PARAMS) { 2386 rkisp1_isp_isr_other_config(params, cur_buf->cfg); 2387 rkisp1_isp_isr_meas_config(params, cur_buf->cfg); 2388 } else { 2389 rkisp1_ext_params_config(params, cur_buf->cfg, 2390 RKISP1_EXT_PARAMS_BLOCK_GROUP_OTHERS); 2391 } 2392 2393 /* update shadow register immediately */ 2394 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_CTRL, 2395 RKISP1_CIF_ISP_CTRL_ISP_CFG_UPD); 2396 2397 unlock: 2398 spin_unlock_irq(¶ms->config_lock); 2399 } 2400 2401 void rkisp1_params_post_configure(struct rkisp1_params *params) 2402 { 2403 struct rkisp1_params_buffer *cur_buf; 2404 2405 spin_lock_irq(¶ms->config_lock); 2406 2407 /* 2408 * Apply LSC parameters from the first buffer (if any is already 2409 * available. This must be done after the ISP gets started in the 2410 * ISP8000Nano v18.02 (found in the i.MX8MP) as access to the LSC RAM 2411 * is gated by the ISP_CTRL.ISP_ENABLE bit. As this initialization 2412 * ordering doesn't affect other ISP versions negatively, do so 2413 * unconditionally. 2414 */ 2415 cur_buf = list_first_entry_or_null(¶ms->params, 2416 struct rkisp1_params_buffer, queue); 2417 if (!cur_buf) 2418 goto unlock; 2419 2420 if (params->metafmt->dataformat == V4L2_META_FMT_RK_ISP1_PARAMS) 2421 rkisp1_isp_isr_lsc_config(params, cur_buf->cfg); 2422 else 2423 rkisp1_ext_params_config(params, cur_buf->cfg, 2424 RKISP1_EXT_PARAMS_BLOCK_GROUP_LSC); 2425 2426 /* update shadow register immediately */ 2427 rkisp1_param_set_bits(params, RKISP1_CIF_ISP_CTRL, 2428 RKISP1_CIF_ISP_CTRL_ISP_CFG_UPD); 2429 2430 rkisp1_params_complete_buffer(params, cur_buf, 0); 2431 2432 unlock: 2433 spin_unlock_irq(¶ms->config_lock); 2434 } 2435 2436 /* 2437 * Not called when the camera is active, therefore there is no need to acquire 2438 * a lock. 2439 */ 2440 void rkisp1_params_disable(struct rkisp1_params *params) 2441 { 2442 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_DPCC_MODE, 2443 RKISP1_CIF_ISP_DPCC_MODE_DPCC_ENABLE); 2444 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_LSC_CTRL, 2445 RKISP1_CIF_ISP_LSC_CTRL_ENA); 2446 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_BLS_CTRL, 2447 RKISP1_CIF_ISP_BLS_ENA); 2448 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_CTRL, 2449 RKISP1_CIF_ISP_CTRL_ISP_GAMMA_IN_ENA); 2450 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_CTRL, 2451 RKISP1_CIF_ISP_CTRL_ISP_GAMMA_OUT_ENA); 2452 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_DEMOSAIC, 2453 RKISP1_CIF_ISP_DEMOSAIC_BYPASS); 2454 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_FILT_MODE, 2455 RKISP1_CIF_ISP_FLT_ENA); 2456 params->ops->awb_meas_enable(params, NULL, false); 2457 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_CTRL, 2458 RKISP1_CIF_ISP_CTRL_ISP_AWB_ENA); 2459 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_EXP_CTRL, 2460 RKISP1_CIF_ISP_EXP_ENA); 2461 rkisp1_ctk_enable(params, false); 2462 rkisp1_param_clear_bits(params, RKISP1_CIF_C_PROC_CTRL, 2463 RKISP1_CIF_C_PROC_CTR_ENABLE); 2464 params->ops->hst_enable(params, NULL, false); 2465 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_AFM_CTRL, 2466 RKISP1_CIF_ISP_AFM_ENA); 2467 rkisp1_ie_enable(params, false); 2468 rkisp1_param_clear_bits(params, RKISP1_CIF_ISP_DPF_MODE, 2469 RKISP1_CIF_ISP_DPF_MODE_EN); 2470 } 2471 2472 static const struct rkisp1_params_ops rkisp1_v10_params_ops = { 2473 .lsc_matrix_config = rkisp1_lsc_matrix_config_v10, 2474 .goc_config = rkisp1_goc_config_v10, 2475 .awb_meas_config = rkisp1_awb_meas_config_v10, 2476 .awb_meas_enable = rkisp1_awb_meas_enable_v10, 2477 .awb_gain_config = rkisp1_awb_gain_config_v10, 2478 .aec_config = rkisp1_aec_config_v10, 2479 .hst_config = rkisp1_hst_config_v10, 2480 .hst_enable = rkisp1_hst_enable_v10, 2481 .afm_config = rkisp1_afm_config_v10, 2482 }; 2483 2484 static const struct rkisp1_params_ops rkisp1_v12_params_ops = { 2485 .lsc_matrix_config = rkisp1_lsc_matrix_config_v12, 2486 .goc_config = rkisp1_goc_config_v12, 2487 .awb_meas_config = rkisp1_awb_meas_config_v12, 2488 .awb_meas_enable = rkisp1_awb_meas_enable_v12, 2489 .awb_gain_config = rkisp1_awb_gain_config_v12, 2490 .aec_config = rkisp1_aec_config_v12, 2491 .hst_config = rkisp1_hst_config_v12, 2492 .hst_enable = rkisp1_hst_enable_v12, 2493 .afm_config = rkisp1_afm_config_v12, 2494 }; 2495 2496 static int rkisp1_params_enum_fmt_meta_out(struct file *file, void *priv, 2497 struct v4l2_fmtdesc *f) 2498 { 2499 struct video_device *video = video_devdata(file); 2500 2501 if (f->index >= ARRAY_SIZE(rkisp1_params_formats) || 2502 f->type != video->queue->type) 2503 return -EINVAL; 2504 2505 f->pixelformat = rkisp1_params_formats[f->index].dataformat; 2506 2507 return 0; 2508 } 2509 2510 static int rkisp1_params_g_fmt_meta_out(struct file *file, void *fh, 2511 struct v4l2_format *f) 2512 { 2513 struct video_device *video = video_devdata(file); 2514 struct rkisp1_params *params = video_get_drvdata(video); 2515 struct v4l2_meta_format *meta = &f->fmt.meta; 2516 2517 if (f->type != video->queue->type) 2518 return -EINVAL; 2519 2520 *meta = *params->metafmt; 2521 2522 return 0; 2523 } 2524 2525 static int rkisp1_params_try_fmt_meta_out(struct file *file, void *fh, 2526 struct v4l2_format *f) 2527 { 2528 struct video_device *video = video_devdata(file); 2529 struct v4l2_meta_format *meta = &f->fmt.meta; 2530 2531 if (f->type != video->queue->type) 2532 return -EINVAL; 2533 2534 *meta = *rkisp1_params_get_format_info(meta->dataformat); 2535 2536 return 0; 2537 } 2538 2539 static int rkisp1_params_s_fmt_meta_out(struct file *file, void *fh, 2540 struct v4l2_format *f) 2541 { 2542 struct video_device *video = video_devdata(file); 2543 struct rkisp1_params *params = video_get_drvdata(video); 2544 struct v4l2_meta_format *meta = &f->fmt.meta; 2545 2546 if (f->type != video->queue->type) 2547 return -EINVAL; 2548 2549 if (vb2_is_busy(video->queue)) 2550 return -EBUSY; 2551 2552 params->metafmt = rkisp1_params_get_format_info(meta->dataformat); 2553 *meta = *params->metafmt; 2554 2555 return 0; 2556 } 2557 2558 static int rkisp1_params_querycap(struct file *file, 2559 void *priv, struct v4l2_capability *cap) 2560 { 2561 struct video_device *vdev = video_devdata(file); 2562 2563 strscpy(cap->driver, RKISP1_DRIVER_NAME, sizeof(cap->driver)); 2564 strscpy(cap->card, vdev->name, sizeof(cap->card)); 2565 strscpy(cap->bus_info, RKISP1_BUS_INFO, sizeof(cap->bus_info)); 2566 2567 return 0; 2568 } 2569 2570 /* ISP params video device IOCTLs */ 2571 static const struct v4l2_ioctl_ops rkisp1_params_ioctl = { 2572 .vidioc_reqbufs = vb2_ioctl_reqbufs, 2573 .vidioc_querybuf = vb2_ioctl_querybuf, 2574 .vidioc_create_bufs = vb2_ioctl_create_bufs, 2575 .vidioc_qbuf = vb2_ioctl_qbuf, 2576 .vidioc_dqbuf = vb2_ioctl_dqbuf, 2577 .vidioc_prepare_buf = vb2_ioctl_prepare_buf, 2578 .vidioc_expbuf = vb2_ioctl_expbuf, 2579 .vidioc_streamon = vb2_ioctl_streamon, 2580 .vidioc_streamoff = vb2_ioctl_streamoff, 2581 .vidioc_enum_fmt_meta_out = rkisp1_params_enum_fmt_meta_out, 2582 .vidioc_g_fmt_meta_out = rkisp1_params_g_fmt_meta_out, 2583 .vidioc_s_fmt_meta_out = rkisp1_params_s_fmt_meta_out, 2584 .vidioc_try_fmt_meta_out = rkisp1_params_try_fmt_meta_out, 2585 .vidioc_querycap = rkisp1_params_querycap, 2586 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2587 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2588 }; 2589 2590 static int rkisp1_params_vb2_queue_setup(struct vb2_queue *vq, 2591 unsigned int *num_buffers, 2592 unsigned int *num_planes, 2593 unsigned int sizes[], 2594 struct device *alloc_devs[]) 2595 { 2596 struct rkisp1_params *params = vq->drv_priv; 2597 2598 *num_buffers = clamp_t(u32, *num_buffers, 2599 RKISP1_ISP_PARAMS_REQ_BUFS_MIN, 2600 RKISP1_ISP_PARAMS_REQ_BUFS_MAX); 2601 2602 *num_planes = 1; 2603 2604 sizes[0] = params->metafmt->buffersize; 2605 2606 return 0; 2607 } 2608 2609 static int rkisp1_params_vb2_buf_init(struct vb2_buffer *vb) 2610 { 2611 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 2612 struct rkisp1_params_buffer *params_buf = to_rkisp1_params_buffer(vbuf); 2613 struct rkisp1_params *params = vb->vb2_queue->drv_priv; 2614 2615 params_buf->cfg = kvmalloc(params->metafmt->buffersize, 2616 GFP_KERNEL); 2617 if (!params_buf->cfg) 2618 return -ENOMEM; 2619 2620 return 0; 2621 } 2622 2623 static void rkisp1_params_vb2_buf_cleanup(struct vb2_buffer *vb) 2624 { 2625 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 2626 struct rkisp1_params_buffer *params_buf = to_rkisp1_params_buffer(vbuf); 2627 2628 kvfree(params_buf->cfg); 2629 params_buf->cfg = NULL; 2630 } 2631 2632 static void rkisp1_params_vb2_buf_queue(struct vb2_buffer *vb) 2633 { 2634 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 2635 struct rkisp1_params_buffer *params_buf = to_rkisp1_params_buffer(vbuf); 2636 struct vb2_queue *vq = vb->vb2_queue; 2637 struct rkisp1_params *params = vq->drv_priv; 2638 2639 spin_lock_irq(¶ms->config_lock); 2640 list_add_tail(¶ms_buf->queue, ¶ms->params); 2641 spin_unlock_irq(¶ms->config_lock); 2642 } 2643 2644 static int rkisp1_params_prepare_ext_params(struct rkisp1_params *params, 2645 struct vb2_buffer *vb) 2646 { 2647 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 2648 struct rkisp1_params_buffer *params_buf = to_rkisp1_params_buffer(vbuf); 2649 size_t header_size = offsetof(struct rkisp1_ext_params_cfg, data); 2650 struct rkisp1_ext_params_cfg *cfg = params_buf->cfg; 2651 size_t payload_size = vb2_get_plane_payload(vb, 0); 2652 struct rkisp1_ext_params_cfg *usr_cfg = 2653 vb2_plane_vaddr(&vbuf->vb2_buf, 0); 2654 size_t block_offset = 0; 2655 size_t cfg_size; 2656 2657 /* 2658 * Validate the buffer payload size before copying the parameters. The 2659 * payload has to be smaller than the destination buffer size and larger 2660 * than the header size. 2661 */ 2662 if (payload_size > params->metafmt->buffersize) { 2663 dev_dbg(params->rkisp1->dev, 2664 "Too large buffer payload size %zu\n", payload_size); 2665 return -EINVAL; 2666 } 2667 2668 if (payload_size < header_size) { 2669 dev_dbg(params->rkisp1->dev, 2670 "Buffer payload %zu smaller than header size %zu\n", 2671 payload_size, header_size); 2672 return -EINVAL; 2673 } 2674 2675 /* 2676 * Copy the parameters buffer to the internal scratch buffer to avoid 2677 * userspace modifying the buffer content while the driver processes it. 2678 */ 2679 memcpy(cfg, usr_cfg, payload_size); 2680 2681 /* Only v1 is supported at the moment. */ 2682 if (cfg->version != RKISP1_EXT_PARAM_BUFFER_V1) { 2683 dev_dbg(params->rkisp1->dev, 2684 "Unsupported extensible format version: %u\n", 2685 cfg->version); 2686 return -EINVAL; 2687 } 2688 2689 /* Validate the size reported in the parameters buffer header. */ 2690 cfg_size = header_size + cfg->data_size; 2691 if (cfg_size != payload_size) { 2692 dev_dbg(params->rkisp1->dev, 2693 "Data size %zu different than buffer payload size %zu\n", 2694 cfg_size, payload_size); 2695 return -EINVAL; 2696 } 2697 2698 /* Walk the list of parameter blocks and validate them. */ 2699 cfg_size = cfg->data_size; 2700 while (cfg_size >= sizeof(struct rkisp1_ext_params_block_header)) { 2701 const struct rkisp1_ext_params_block_header *block; 2702 const struct rkisp1_ext_params_handler *handler; 2703 2704 block = (const struct rkisp1_ext_params_block_header *) 2705 &cfg->data[block_offset]; 2706 2707 if (block->type >= ARRAY_SIZE(rkisp1_ext_params_handlers)) { 2708 dev_dbg(params->rkisp1->dev, 2709 "Invalid parameters block type\n"); 2710 return -EINVAL; 2711 } 2712 2713 if (block->size > cfg_size) { 2714 dev_dbg(params->rkisp1->dev, 2715 "Premature end of parameters data\n"); 2716 return -EINVAL; 2717 } 2718 2719 if ((block->flags & (RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE | 2720 RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE)) == 2721 (RKISP1_EXT_PARAMS_FL_BLOCK_ENABLE | 2722 RKISP1_EXT_PARAMS_FL_BLOCK_DISABLE)) { 2723 dev_dbg(params->rkisp1->dev, 2724 "Invalid parameters block flags\n"); 2725 return -EINVAL; 2726 } 2727 2728 handler = &rkisp1_ext_params_handlers[block->type]; 2729 if (block->size != handler->size) { 2730 dev_dbg(params->rkisp1->dev, 2731 "Invalid parameters block size\n"); 2732 return -EINVAL; 2733 } 2734 2735 block_offset += block->size; 2736 cfg_size -= block->size; 2737 } 2738 2739 if (cfg_size) { 2740 dev_dbg(params->rkisp1->dev, 2741 "Unexpected data after the parameters buffer end\n"); 2742 return -EINVAL; 2743 } 2744 2745 return 0; 2746 } 2747 2748 static int rkisp1_params_vb2_buf_prepare(struct vb2_buffer *vb) 2749 { 2750 struct rkisp1_params *params = vb->vb2_queue->drv_priv; 2751 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 2752 struct rkisp1_params_buffer *params_buf = to_rkisp1_params_buffer(vbuf); 2753 struct rkisp1_params_cfg *cfg = vb2_plane_vaddr(&vbuf->vb2_buf, 0); 2754 size_t payload = vb2_get_plane_payload(vb, 0); 2755 2756 if (params->metafmt->dataformat == V4L2_META_FMT_RK_ISP1_EXT_PARAMS) 2757 return rkisp1_params_prepare_ext_params(params, vb); 2758 2759 /* 2760 * For the fixed parameters format the payload size must be exactly the 2761 * size of the parameters structure. 2762 */ 2763 if (payload != sizeof(*cfg)) 2764 return -EINVAL; 2765 2766 /* 2767 * Copy the parameters buffer to the internal scratch buffer to avoid 2768 * userspace modifying the buffer content while the driver processes it. 2769 */ 2770 memcpy(params_buf->cfg, cfg, payload); 2771 2772 return 0; 2773 } 2774 2775 static void rkisp1_params_vb2_stop_streaming(struct vb2_queue *vq) 2776 { 2777 struct rkisp1_params *params = vq->drv_priv; 2778 struct rkisp1_params_buffer *buf; 2779 LIST_HEAD(tmp_list); 2780 2781 /* 2782 * we first move the buffers into a local list 'tmp_list' 2783 * and then we can iterate it and call vb2_buffer_done 2784 * without holding the lock 2785 */ 2786 spin_lock_irq(¶ms->config_lock); 2787 list_splice_init(¶ms->params, &tmp_list); 2788 spin_unlock_irq(¶ms->config_lock); 2789 2790 list_for_each_entry(buf, &tmp_list, queue) 2791 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR); 2792 2793 params->enabled_blocks = 0; 2794 } 2795 2796 static const struct vb2_ops rkisp1_params_vb2_ops = { 2797 .queue_setup = rkisp1_params_vb2_queue_setup, 2798 .buf_init = rkisp1_params_vb2_buf_init, 2799 .buf_cleanup = rkisp1_params_vb2_buf_cleanup, 2800 .buf_queue = rkisp1_params_vb2_buf_queue, 2801 .buf_prepare = rkisp1_params_vb2_buf_prepare, 2802 .stop_streaming = rkisp1_params_vb2_stop_streaming, 2803 }; 2804 2805 static const struct v4l2_file_operations rkisp1_params_fops = { 2806 .mmap = vb2_fop_mmap, 2807 .unlocked_ioctl = video_ioctl2, 2808 .poll = vb2_fop_poll, 2809 .open = v4l2_fh_open, 2810 .release = vb2_fop_release 2811 }; 2812 2813 static int rkisp1_params_init_vb2_queue(struct vb2_queue *q, 2814 struct rkisp1_params *params) 2815 { 2816 struct rkisp1_vdev_node *node; 2817 2818 node = container_of(q, struct rkisp1_vdev_node, buf_queue); 2819 2820 q->type = V4L2_BUF_TYPE_META_OUTPUT; 2821 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF; 2822 q->drv_priv = params; 2823 q->ops = &rkisp1_params_vb2_ops; 2824 q->mem_ops = &vb2_vmalloc_memops; 2825 q->buf_struct_size = sizeof(struct rkisp1_params_buffer); 2826 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 2827 q->lock = &node->vlock; 2828 2829 return vb2_queue_init(q); 2830 } 2831 2832 static int rkisp1_params_ctrl_init(struct rkisp1_params *params) 2833 { 2834 struct v4l2_ctrl_config ctrl_config = { 2835 .id = RKISP1_CID_SUPPORTED_PARAMS_BLOCKS, 2836 .name = "Supported Params Blocks", 2837 .type = V4L2_CTRL_TYPE_BITMASK, 2838 .flags = V4L2_CTRL_FLAG_READ_ONLY, 2839 }; 2840 int ret; 2841 2842 v4l2_ctrl_handler_init(¶ms->ctrls, 1); 2843 2844 for (unsigned int i = 0; i < ARRAY_SIZE(rkisp1_ext_params_handlers); i++) { 2845 const struct rkisp1_ext_params_handler *block_handler; 2846 2847 block_handler = &rkisp1_ext_params_handlers[i]; 2848 ctrl_config.max |= BIT(i); 2849 2850 if ((params->rkisp1->info->features & block_handler->features) != 2851 block_handler->features) 2852 continue; 2853 2854 ctrl_config.def |= BIT(i); 2855 } 2856 2857 v4l2_ctrl_new_custom(¶ms->ctrls, &ctrl_config, NULL); 2858 2859 params->vnode.vdev.ctrl_handler = ¶ms->ctrls; 2860 2861 if (params->ctrls.error) { 2862 ret = params->ctrls.error; 2863 v4l2_ctrl_handler_free(¶ms->ctrls); 2864 return ret; 2865 } 2866 2867 return 0; 2868 } 2869 2870 int rkisp1_params_register(struct rkisp1_device *rkisp1) 2871 { 2872 struct rkisp1_params *params = &rkisp1->params; 2873 struct rkisp1_vdev_node *node = ¶ms->vnode; 2874 struct video_device *vdev = &node->vdev; 2875 int ret; 2876 2877 params->rkisp1 = rkisp1; 2878 mutex_init(&node->vlock); 2879 INIT_LIST_HEAD(¶ms->params); 2880 spin_lock_init(¶ms->config_lock); 2881 2882 strscpy(vdev->name, RKISP1_PARAMS_DEV_NAME, sizeof(vdev->name)); 2883 2884 video_set_drvdata(vdev, params); 2885 vdev->ioctl_ops = &rkisp1_params_ioctl; 2886 vdev->fops = &rkisp1_params_fops; 2887 vdev->release = video_device_release_empty; 2888 /* 2889 * Provide a mutex to v4l2 core. It will be used 2890 * to protect all fops and v4l2 ioctls. 2891 */ 2892 vdev->lock = &node->vlock; 2893 vdev->v4l2_dev = &rkisp1->v4l2_dev; 2894 vdev->queue = &node->buf_queue; 2895 vdev->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_META_OUTPUT; 2896 vdev->vfl_dir = VFL_DIR_TX; 2897 ret = rkisp1_params_init_vb2_queue(vdev->queue, params); 2898 if (ret) 2899 goto err_media; 2900 2901 params->metafmt = &rkisp1_params_formats[RKISP1_PARAMS_FIXED]; 2902 2903 if (params->rkisp1->info->isp_ver == RKISP1_V12) 2904 params->ops = &rkisp1_v12_params_ops; 2905 else 2906 params->ops = &rkisp1_v10_params_ops; 2907 2908 video_set_drvdata(vdev, params); 2909 2910 node->pad.flags = MEDIA_PAD_FL_SOURCE; 2911 ret = media_entity_pads_init(&vdev->entity, 1, &node->pad); 2912 if (ret) 2913 goto err_media; 2914 2915 ret = rkisp1_params_ctrl_init(params); 2916 if (ret) { 2917 dev_err(rkisp1->dev, "Control initialization error %d\n", ret); 2918 goto err_media; 2919 } 2920 2921 ret = video_register_device(vdev, VFL_TYPE_VIDEO, -1); 2922 if (ret) { 2923 dev_err(rkisp1->dev, 2924 "failed to register %s, ret=%d\n", vdev->name, ret); 2925 goto err_ctrl; 2926 } 2927 2928 return 0; 2929 2930 err_ctrl: 2931 v4l2_ctrl_handler_free(¶ms->ctrls); 2932 err_media: 2933 media_entity_cleanup(&vdev->entity); 2934 mutex_destroy(&node->vlock); 2935 return ret; 2936 } 2937 2938 void rkisp1_params_unregister(struct rkisp1_device *rkisp1) 2939 { 2940 struct rkisp1_params *params = &rkisp1->params; 2941 struct rkisp1_vdev_node *node = ¶ms->vnode; 2942 struct video_device *vdev = &node->vdev; 2943 2944 if (!video_is_registered(vdev)) 2945 return; 2946 2947 vb2_video_unregister_device(vdev); 2948 v4l2_ctrl_handler_free(¶ms->ctrls); 2949 media_entity_cleanup(&vdev->entity); 2950 mutex_destroy(&node->vlock); 2951 } 2952