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 *
rkisp1_params_get_format_info(u32 dataformat)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
rkisp1_param_set_bits(struct rkisp1_params * params,u32 reg,u32 bit_mask)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
rkisp1_param_clear_bits(struct rkisp1_params * params,u32 reg,u32 bit_mask)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 */
rkisp1_dpcc_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_dpcc_config * arg)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 */
rkisp1_bls_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_bls_config * arg)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
rkisp1_lsc_matrix_config_v10(struct rkisp1_params * params,const struct rkisp1_cif_isp_lsc_config * pconfig)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
rkisp1_lsc_matrix_config_v12(struct rkisp1_params * params,const struct rkisp1_cif_isp_lsc_config * pconfig)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
rkisp1_lsc_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_lsc_config * arg)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 */
rkisp1_flt_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_flt_config * arg)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 */
rkisp1_bdm_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_bdm_config * arg)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 */
rkisp1_sdg_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_sdg_config * arg)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 */
rkisp1_goc_config_v10(struct rkisp1_params * params,const struct rkisp1_cif_isp_goc_config * arg)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
rkisp1_goc_config_v12(struct rkisp1_params * params,const struct rkisp1_cif_isp_goc_config * arg)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 */
rkisp1_ctk_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_ctk_config * arg)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
rkisp1_ctk_enable(struct rkisp1_params * params,bool en)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 */
rkisp1_awb_meas_config_v10(struct rkisp1_params * params,const struct rkisp1_cif_isp_awb_meas_config * arg)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
rkisp1_awb_meas_config_v12(struct rkisp1_params * params,const struct rkisp1_cif_isp_awb_meas_config * arg)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
rkisp1_awb_meas_enable_v10(struct rkisp1_params * params,const struct rkisp1_cif_isp_awb_meas_config * arg,bool en)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
rkisp1_awb_meas_enable_v12(struct rkisp1_params * params,const struct rkisp1_cif_isp_awb_meas_config * arg,bool en)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
rkisp1_awb_gain_config_v10(struct rkisp1_params * params,const struct rkisp1_cif_isp_awb_gain_config * arg)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
rkisp1_awb_gain_config_v12(struct rkisp1_params * params,const struct rkisp1_cif_isp_awb_gain_config * arg)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
rkisp1_aec_config_v10(struct rkisp1_params * params,const struct rkisp1_cif_isp_aec_config * arg)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
rkisp1_aec_config_v12(struct rkisp1_params * params,const struct rkisp1_cif_isp_aec_config * arg)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
rkisp1_cproc_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_cproc_config * arg)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
rkisp1_hst_config_v10(struct rkisp1_params * params,const struct rkisp1_cif_isp_hst_config * arg)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
rkisp1_hst_config_v12(struct rkisp1_params * params,const struct rkisp1_cif_isp_hst_config * arg)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
rkisp1_hst_enable_v10(struct rkisp1_params * params,const struct rkisp1_cif_isp_hst_config * arg,bool en)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
rkisp1_hst_enable_v12(struct rkisp1_params * params,const struct rkisp1_cif_isp_hst_config * arg,bool en)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
rkisp1_afm_config_v10(struct rkisp1_params * params,const struct rkisp1_cif_isp_afc_config * arg)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
rkisp1_afm_config_v12(struct rkisp1_params * params,const struct rkisp1_cif_isp_afc_config * arg)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
rkisp1_ie_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_ie_config * arg)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
rkisp1_ie_enable(struct rkisp1_params * params,bool en)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
rkisp1_csm_config(struct rkisp1_params * params)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 */
rkisp1_dpf_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_dpf_config * arg)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
rkisp1_dpf_strength_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_dpf_strength_config * arg)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
rkisp1_compand_write_px_curve(struct rkisp1_params * params,unsigned int addr,const u8 * curve)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
rkisp1_compand_write_curve_mem(struct rkisp1_params * params,unsigned int reg_addr,unsigned int reg_data,const u32 curve[RKISP1_CIF_ISP_COMPAND_NUM_POINTS])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
rkisp1_compand_bls_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_compand_bls_config * arg)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
rkisp1_compand_expand_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_compand_curve_config * arg)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
rkisp1_compand_compress_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_compand_curve_config * arg)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
rkisp1_wdr_config(struct rkisp1_params * params,const struct rkisp1_cif_isp_wdr_config * arg)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
rkisp1_isp_isr_other_config(struct rkisp1_params * params,const struct rkisp1_params_cfg * new_params)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
rkisp1_isp_isr_lsc_config(struct rkisp1_params * params,const struct rkisp1_params_cfg * new_params)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
rkisp1_isp_isr_meas_config(struct rkisp1_params * params,struct rkisp1_params_cfg * new_params)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
rkisp1_ext_params_bls(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_dpcc(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_sdg(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_lsc(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_awbg(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_flt(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_bdm(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_ctk(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_goc(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_dpf(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_dpfs(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_cproc(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_ie(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_awbm(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_hstm(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_aecm(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_afcm(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_compand_bls(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_compand_expand(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_compand_compress(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_wdr(struct rkisp1_params * params,const union rkisp1_ext_params_config * block)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
rkisp1_ext_params_config(struct rkisp1_params * params,struct rkisp1_ext_params_cfg * cfg,u32 block_group_mask)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
rkisp1_params_complete_buffer(struct rkisp1_params * params,struct rkisp1_params_buffer * buf,unsigned int frame_sequence)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
rkisp1_params_isr(struct rkisp1_device * rkisp1)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
rkisp1_params_pre_configure(struct rkisp1_params * params,enum rkisp1_fmt_raw_pat_type bayer_pat,enum v4l2_quantization quantization,enum v4l2_ycbcr_encoding ycbcr_encoding)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
rkisp1_params_post_configure(struct rkisp1_params * params)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 */
rkisp1_params_disable(struct rkisp1_params * params)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
rkisp1_params_enum_fmt_meta_out(struct file * file,void * priv,struct v4l2_fmtdesc * f)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
rkisp1_params_g_fmt_meta_out(struct file * file,void * fh,struct v4l2_format * f)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
rkisp1_params_try_fmt_meta_out(struct file * file,void * fh,struct v4l2_format * f)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
rkisp1_params_s_fmt_meta_out(struct file * file,void * fh,struct v4l2_format * f)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
rkisp1_params_querycap(struct file * file,void * priv,struct v4l2_capability * cap)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
rkisp1_params_vb2_queue_setup(struct vb2_queue * vq,unsigned int * num_buffers,unsigned int * num_planes,unsigned int sizes[],struct device * alloc_devs[])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
rkisp1_params_vb2_buf_init(struct vb2_buffer * vb)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
rkisp1_params_vb2_buf_cleanup(struct vb2_buffer * vb)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
rkisp1_params_vb2_buf_queue(struct vb2_buffer * vb)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
rkisp1_params_prepare_ext_params(struct rkisp1_params * params,struct vb2_buffer * vb)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
rkisp1_params_vb2_buf_prepare(struct vb2_buffer * vb)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
rkisp1_params_vb2_stop_streaming(struct vb2_queue * vq)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
rkisp1_params_init_vb2_queue(struct vb2_queue * q,struct rkisp1_params * params)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
rkisp1_params_ctrl_init(struct rkisp1_params * params)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
rkisp1_params_register(struct rkisp1_device * rkisp1)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
rkisp1_params_unregister(struct rkisp1_device * rkisp1)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