1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2018 Intel Corporation
3
4 #include <linux/device.h>
5
6 #include "ipu3-css.h"
7 #include "ipu3-css-fw.h"
8 #include "ipu3-tables.h"
9 #include "ipu3-css-params.h"
10
11 #define DIV_ROUND_CLOSEST_DOWN(a, b) (((a) + ((b) / 2) - 1) / (b))
12 #define roundclosest_down(a, b) (DIV_ROUND_CLOSEST_DOWN(a, b) * (b))
13
14 #define IPU3_UAPI_ANR_MAX_RESET ((1 << 12) - 1)
15 #define IPU3_UAPI_ANR_MIN_RESET (((-1) << 12) + 1)
16
17 struct imgu_css_scaler_info {
18 unsigned int phase_step; /* Same for luma/chroma */
19 int exp_shift;
20
21 unsigned int phase_init; /* luma/chroma dependent */
22 int pad_left;
23 int pad_right;
24 int crop_left;
25 int crop_top;
26 };
27
imgu_css_scaler_get_exp(unsigned int counter,unsigned int divider)28 static unsigned int imgu_css_scaler_get_exp(unsigned int counter,
29 unsigned int divider)
30 {
31 int i = fls(divider) - fls(counter);
32
33 if (i <= 0)
34 return 0;
35
36 if (divider >> i < counter)
37 i = i - 1;
38
39 return i;
40 }
41
42 /* Set up the CSS scaler look up table */
43 static void
imgu_css_scaler_setup_lut(unsigned int taps,unsigned int input_width,unsigned int output_width,int phase_step_correction,const int * coeffs,unsigned int coeffs_size,s8 coeff_lut[],struct imgu_css_scaler_info * info)44 imgu_css_scaler_setup_lut(unsigned int taps, unsigned int input_width,
45 unsigned int output_width, int phase_step_correction,
46 const int *coeffs, unsigned int coeffs_size,
47 s8 coeff_lut[], struct imgu_css_scaler_info *info)
48 {
49 int tap, phase, phase_sum_left, phase_sum_right;
50 int exponent = imgu_css_scaler_get_exp(output_width, input_width);
51 int mantissa = (1 << exponent) * output_width;
52 unsigned int phase_step, phase_taps;
53
54 if (input_width == output_width) {
55 for (phase = 0; phase < IMGU_SCALER_PHASES; phase++) {
56 phase_taps = phase * IMGU_SCALER_FILTER_TAPS;
57 for (tap = 0; tap < taps; tap++)
58 coeff_lut[phase_taps + tap] = 0;
59 }
60
61 info->phase_step = IMGU_SCALER_PHASES *
62 (1 << IMGU_SCALER_PHASE_COUNTER_PREC_REF);
63 info->exp_shift = 0;
64 info->pad_left = 0;
65 info->pad_right = 0;
66 info->phase_init = 0;
67 info->crop_left = 0;
68 info->crop_top = 0;
69 return;
70 }
71
72 for (phase = 0; phase < IMGU_SCALER_PHASES; phase++) {
73 phase_taps = phase * IMGU_SCALER_FILTER_TAPS;
74 for (tap = 0; tap < taps; tap++) {
75 /* flip table to for convolution reverse indexing */
76 s64 coeff = coeffs[coeffs_size -
77 ((tap * (coeffs_size / taps)) + phase) - 1];
78 coeff *= mantissa;
79 coeff = div64_long(coeff, input_width);
80
81 /* Add +"0.5" */
82 coeff += 1 << (IMGU_SCALER_COEFF_BITS - 1);
83 coeff >>= IMGU_SCALER_COEFF_BITS;
84 coeff_lut[phase_taps + tap] = coeff;
85 }
86 }
87
88 phase_step = IMGU_SCALER_PHASES *
89 (1 << IMGU_SCALER_PHASE_COUNTER_PREC_REF) *
90 output_width / input_width;
91 phase_step += phase_step_correction;
92 phase_sum_left = (taps / 2 * IMGU_SCALER_PHASES *
93 (1 << IMGU_SCALER_PHASE_COUNTER_PREC_REF)) -
94 (1 << (IMGU_SCALER_PHASE_COUNTER_PREC_REF - 1));
95 phase_sum_right = (taps / 2 * IMGU_SCALER_PHASES *
96 (1 << IMGU_SCALER_PHASE_COUNTER_PREC_REF)) +
97 (1 << (IMGU_SCALER_PHASE_COUNTER_PREC_REF - 1));
98
99 info->exp_shift = IMGU_SCALER_MAX_EXPONENT_SHIFT - exponent;
100 info->pad_left = (phase_sum_left % phase_step == 0) ?
101 phase_sum_left / phase_step - 1 : phase_sum_left / phase_step;
102 info->pad_right = (phase_sum_right % phase_step == 0) ?
103 phase_sum_right / phase_step - 1 : phase_sum_right / phase_step;
104 info->phase_init = phase_sum_left - phase_step * info->pad_left;
105 info->phase_step = phase_step;
106 info->crop_left = taps - 1;
107 info->crop_top = taps - 1;
108 }
109
110 /*
111 * Calculates the exact output image width/height, based on phase_step setting
112 * (must be perfectly aligned with hardware).
113 */
114 static unsigned int
imgu_css_scaler_calc_scaled_output(unsigned int input,struct imgu_css_scaler_info * info)115 imgu_css_scaler_calc_scaled_output(unsigned int input,
116 struct imgu_css_scaler_info *info)
117 {
118 unsigned int arg1 = input * info->phase_step +
119 (1 - IMGU_SCALER_TAPS_Y / 2) * IMGU_SCALER_FIR_PHASES -
120 IMGU_SCALER_FIR_PHASES / (2 * IMGU_SCALER_PHASES);
121 unsigned int arg2 = ((IMGU_SCALER_TAPS_Y / 2) * IMGU_SCALER_FIR_PHASES +
122 IMGU_SCALER_FIR_PHASES / (2 * IMGU_SCALER_PHASES)) *
123 IMGU_SCALER_FIR_PHASES + info->phase_step / 2;
124
125 return ((arg1 + (arg2 - IMGU_SCALER_FIR_PHASES * info->phase_step) /
126 IMGU_SCALER_FIR_PHASES) / (2 * IMGU_SCALER_FIR_PHASES)) * 2;
127 }
128
129 /*
130 * Calculate the output width and height, given the luma
131 * and chroma details of a scaler
132 */
133 static void
imgu_css_scaler_calc(u32 input_width,u32 input_height,u32 target_width,u32 target_height,struct imgu_abi_osys_config * cfg,struct imgu_css_scaler_info * info_luma,struct imgu_css_scaler_info * info_chroma,unsigned int * output_width,unsigned int * output_height,unsigned int * procmode)134 imgu_css_scaler_calc(u32 input_width, u32 input_height, u32 target_width,
135 u32 target_height, struct imgu_abi_osys_config *cfg,
136 struct imgu_css_scaler_info *info_luma,
137 struct imgu_css_scaler_info *info_chroma,
138 unsigned int *output_width, unsigned int *output_height,
139 unsigned int *procmode)
140 {
141 u32 out_width = target_width;
142 u32 out_height = target_height;
143 const unsigned int height_alignment = 2;
144 int phase_step_correction = -1;
145
146 /*
147 * Calculate scaled output width. If the horizontal and vertical scaling
148 * factor is different, then choose the biggest and crop off excess
149 * lines or columns after formatting.
150 */
151 if (target_height * input_width > target_width * input_height)
152 target_width = DIV_ROUND_UP(target_height * input_width,
153 input_height);
154
155 if (input_width == target_width)
156 *procmode = IMGU_ABI_OSYS_PROCMODE_BYPASS;
157 else
158 *procmode = IMGU_ABI_OSYS_PROCMODE_DOWNSCALE;
159
160 memset(&cfg->scaler_coeffs_chroma, 0,
161 sizeof(cfg->scaler_coeffs_chroma));
162 memset(&cfg->scaler_coeffs_luma, 0, sizeof(cfg->scaler_coeffs_luma));
163 do {
164 phase_step_correction++;
165
166 imgu_css_scaler_setup_lut(IMGU_SCALER_TAPS_Y,
167 input_width, target_width,
168 phase_step_correction,
169 imgu_css_downscale_4taps,
170 IMGU_SCALER_DOWNSCALE_4TAPS_LEN,
171 cfg->scaler_coeffs_luma, info_luma);
172
173 imgu_css_scaler_setup_lut(IMGU_SCALER_TAPS_UV,
174 input_width, target_width,
175 phase_step_correction,
176 imgu_css_downscale_2taps,
177 IMGU_SCALER_DOWNSCALE_2TAPS_LEN,
178 cfg->scaler_coeffs_chroma,
179 info_chroma);
180
181 out_width = imgu_css_scaler_calc_scaled_output(input_width,
182 info_luma);
183 out_height = imgu_css_scaler_calc_scaled_output(input_height,
184 info_luma);
185 } while ((out_width < target_width || out_height < target_height ||
186 !IS_ALIGNED(out_height, height_alignment)) &&
187 phase_step_correction <= 5);
188
189 *output_width = out_width;
190 *output_height = out_height;
191 }
192
193 /********************** Osys routines for scaler****************************/
194
imgu_css_osys_set_format(enum imgu_abi_frame_format host_format,unsigned int * osys_format,unsigned int * osys_tiling)195 static void imgu_css_osys_set_format(enum imgu_abi_frame_format host_format,
196 unsigned int *osys_format,
197 unsigned int *osys_tiling)
198 {
199 *osys_format = IMGU_ABI_OSYS_FORMAT_YUV420;
200 *osys_tiling = IMGU_ABI_OSYS_TILING_NONE;
201
202 switch (host_format) {
203 case IMGU_ABI_FRAME_FORMAT_YUV420:
204 *osys_format = IMGU_ABI_OSYS_FORMAT_YUV420;
205 break;
206 case IMGU_ABI_FRAME_FORMAT_YV12:
207 *osys_format = IMGU_ABI_OSYS_FORMAT_YV12;
208 break;
209 case IMGU_ABI_FRAME_FORMAT_NV12:
210 *osys_format = IMGU_ABI_OSYS_FORMAT_NV12;
211 break;
212 case IMGU_ABI_FRAME_FORMAT_NV16:
213 *osys_format = IMGU_ABI_OSYS_FORMAT_NV16;
214 break;
215 case IMGU_ABI_FRAME_FORMAT_NV21:
216 *osys_format = IMGU_ABI_OSYS_FORMAT_NV21;
217 break;
218 case IMGU_ABI_FRAME_FORMAT_NV12_TILEY:
219 *osys_format = IMGU_ABI_OSYS_FORMAT_NV12;
220 *osys_tiling = IMGU_ABI_OSYS_TILING_Y;
221 break;
222 default:
223 /* For now, assume use default values */
224 break;
225 }
226 }
227
228 /*
229 * Function calculates input frame stripe offset, based
230 * on output frame stripe offset and filter parameters.
231 */
imgu_css_osys_calc_stripe_offset(int stripe_offset_out,int fir_phases,int phase_init,int phase_step,int pad_left)232 static int imgu_css_osys_calc_stripe_offset(int stripe_offset_out,
233 int fir_phases, int phase_init,
234 int phase_step, int pad_left)
235 {
236 int stripe_offset_inp = stripe_offset_out * fir_phases -
237 pad_left * phase_step;
238
239 return DIV_ROUND_UP(stripe_offset_inp - phase_init, phase_step);
240 }
241
242 /*
243 * Calculate input frame phase, given the output frame
244 * stripe offset and filter parameters
245 */
imgu_css_osys_calc_stripe_phase_init(int stripe_offset_out,int fir_phases,int phase_init,int phase_step,int pad_left)246 static int imgu_css_osys_calc_stripe_phase_init(int stripe_offset_out,
247 int fir_phases, int phase_init,
248 int phase_step, int pad_left)
249 {
250 int stripe_offset_inp =
251 imgu_css_osys_calc_stripe_offset(stripe_offset_out,
252 fir_phases, phase_init,
253 phase_step, pad_left);
254
255 return phase_init + ((pad_left + stripe_offset_inp) * phase_step) -
256 stripe_offset_out * fir_phases;
257 }
258
259 /*
260 * This function calculates input frame stripe width,
261 * based on output frame stripe offset and filter parameters
262 */
imgu_css_osys_calc_inp_stripe_width(int stripe_width_out,int fir_phases,int phase_init,int phase_step,int fir_taps,int pad_left,int pad_right)263 static int imgu_css_osys_calc_inp_stripe_width(int stripe_width_out,
264 int fir_phases, int phase_init,
265 int phase_step, int fir_taps,
266 int pad_left, int pad_right)
267 {
268 int stripe_width_inp = (stripe_width_out + fir_taps - 1) * fir_phases;
269
270 stripe_width_inp = DIV_ROUND_UP(stripe_width_inp - phase_init,
271 phase_step);
272
273 return stripe_width_inp - pad_left - pad_right;
274 }
275
276 /*
277 * This function calculates output frame stripe width, basedi
278 * on output frame stripe offset and filter parameters
279 */
imgu_css_osys_out_stripe_width(int stripe_width_inp,int fir_phases,int phase_init,int phase_step,int fir_taps,int pad_left,int pad_right,int column_offset)280 static int imgu_css_osys_out_stripe_width(int stripe_width_inp, int fir_phases,
281 int phase_init, int phase_step,
282 int fir_taps, int pad_left,
283 int pad_right, int column_offset)
284 {
285 int stripe_width_out = (pad_left + stripe_width_inp +
286 pad_right - column_offset) * phase_step;
287
288 stripe_width_out = (stripe_width_out + phase_init) / fir_phases;
289
290 return stripe_width_out - (fir_taps - 1);
291 }
292
293 struct imgu_css_reso {
294 unsigned int input_width;
295 unsigned int input_height;
296 enum imgu_abi_frame_format input_format;
297 unsigned int pin_width[IMGU_ABI_OSYS_PINS];
298 unsigned int pin_height[IMGU_ABI_OSYS_PINS];
299 unsigned int pin_stride[IMGU_ABI_OSYS_PINS];
300 enum imgu_abi_frame_format pin_format[IMGU_ABI_OSYS_PINS];
301 int chunk_width;
302 int chunk_height;
303 int block_height;
304 int block_width;
305 };
306
307 struct imgu_css_frame_params {
308 /* Output pins */
309 unsigned int enable;
310 unsigned int format;
311 unsigned int flip;
312 unsigned int mirror;
313 unsigned int tiling;
314 unsigned int reduce_range;
315 unsigned int width;
316 unsigned int height;
317 unsigned int stride;
318 unsigned int scaled;
319 unsigned int crop_left;
320 unsigned int crop_top;
321 };
322
323 struct imgu_css_stripe_params {
324 unsigned int processing_mode;
325 unsigned int phase_step;
326 unsigned int exp_shift;
327 unsigned int phase_init_left_y;
328 unsigned int phase_init_left_uv;
329 unsigned int phase_init_top_y;
330 unsigned int phase_init_top_uv;
331 unsigned int pad_left_y;
332 unsigned int pad_left_uv;
333 unsigned int pad_right_y;
334 unsigned int pad_right_uv;
335 unsigned int pad_top_y;
336 unsigned int pad_top_uv;
337 unsigned int pad_bottom_y;
338 unsigned int pad_bottom_uv;
339 unsigned int crop_left_y;
340 unsigned int crop_top_y;
341 unsigned int crop_left_uv;
342 unsigned int crop_top_uv;
343 unsigned int start_column_y;
344 unsigned int start_column_uv;
345 unsigned int chunk_width;
346 unsigned int chunk_height;
347 unsigned int block_width;
348 unsigned int block_height;
349 unsigned int input_width;
350 unsigned int input_height;
351 int output_width[IMGU_ABI_OSYS_PINS];
352 int output_height[IMGU_ABI_OSYS_PINS];
353 int output_offset[IMGU_ABI_OSYS_PINS];
354 };
355
356 /*
357 * frame_params - size IMGU_ABI_OSYS_PINS
358 * stripe_params - size IPU3_UAPI_MAX_STRIPES
359 */
imgu_css_osys_calc_frame_and_stripe_params(struct imgu_css * css,unsigned int stripes,struct imgu_abi_osys_config * osys,struct imgu_css_scaler_info * scaler_luma,struct imgu_css_scaler_info * scaler_chroma,struct imgu_css_frame_params frame_params[],struct imgu_css_stripe_params stripe_params[],unsigned int pipe)360 static int imgu_css_osys_calc_frame_and_stripe_params(
361 struct imgu_css *css, unsigned int stripes,
362 struct imgu_abi_osys_config *osys,
363 struct imgu_css_scaler_info *scaler_luma,
364 struct imgu_css_scaler_info *scaler_chroma,
365 struct imgu_css_frame_params frame_params[],
366 struct imgu_css_stripe_params stripe_params[],
367 unsigned int pipe)
368 {
369 struct imgu_css_reso reso;
370 unsigned int output_width, pin, s;
371 u32 input_width, input_height, target_width, target_height;
372 unsigned int procmode = 0;
373 struct imgu_css_pipe *css_pipe = &css->pipes[pipe];
374
375 input_width = css_pipe->rect[IPU3_CSS_RECT_GDC].width;
376 input_height = css_pipe->rect[IPU3_CSS_RECT_GDC].height;
377 target_width = css_pipe->queue[IPU3_CSS_QUEUE_VF].fmt.mpix.width;
378 target_height = css_pipe->queue[IPU3_CSS_QUEUE_VF].fmt.mpix.height;
379
380 /* Frame parameters */
381
382 /* Input width for Output System is output width of DVS (with GDC) */
383 reso.input_width = css_pipe->rect[IPU3_CSS_RECT_GDC].width;
384
385 /* Input height for Output System is output height of DVS (with GDC) */
386 reso.input_height = css_pipe->rect[IPU3_CSS_RECT_GDC].height;
387
388 reso.input_format =
389 css_pipe->queue[IPU3_CSS_QUEUE_OUT].css_fmt->frame_format;
390
391 reso.pin_width[IMGU_ABI_OSYS_PIN_OUT] =
392 css_pipe->queue[IPU3_CSS_QUEUE_OUT].fmt.mpix.width;
393 reso.pin_height[IMGU_ABI_OSYS_PIN_OUT] =
394 css_pipe->queue[IPU3_CSS_QUEUE_OUT].fmt.mpix.height;
395 reso.pin_stride[IMGU_ABI_OSYS_PIN_OUT] =
396 css_pipe->queue[IPU3_CSS_QUEUE_OUT].width_pad;
397 reso.pin_format[IMGU_ABI_OSYS_PIN_OUT] =
398 css_pipe->queue[IPU3_CSS_QUEUE_OUT].css_fmt->frame_format;
399
400 reso.pin_width[IMGU_ABI_OSYS_PIN_VF] =
401 css_pipe->queue[IPU3_CSS_QUEUE_VF].fmt.mpix.width;
402 reso.pin_height[IMGU_ABI_OSYS_PIN_VF] =
403 css_pipe->queue[IPU3_CSS_QUEUE_VF].fmt.mpix.height;
404 reso.pin_stride[IMGU_ABI_OSYS_PIN_VF] =
405 css_pipe->queue[IPU3_CSS_QUEUE_VF].width_pad;
406 reso.pin_format[IMGU_ABI_OSYS_PIN_VF] =
407 css_pipe->queue[IPU3_CSS_QUEUE_VF].css_fmt->frame_format;
408
409 /* Configure the frame parameters for all output pins */
410
411 frame_params[IMGU_ABI_OSYS_PIN_OUT].width =
412 css_pipe->queue[IPU3_CSS_QUEUE_OUT].fmt.mpix.width;
413 frame_params[IMGU_ABI_OSYS_PIN_OUT].height =
414 css_pipe->queue[IPU3_CSS_QUEUE_OUT].fmt.mpix.height;
415 frame_params[IMGU_ABI_OSYS_PIN_VF].width =
416 css_pipe->queue[IPU3_CSS_QUEUE_VF].fmt.mpix.width;
417 frame_params[IMGU_ABI_OSYS_PIN_VF].height =
418 css_pipe->queue[IPU3_CSS_QUEUE_VF].fmt.mpix.height;
419 frame_params[IMGU_ABI_OSYS_PIN_VF].crop_top = 0;
420 frame_params[IMGU_ABI_OSYS_PIN_VF].crop_left = 0;
421
422 for (pin = 0; pin < IMGU_ABI_OSYS_PINS; pin++) {
423 int enable = 0;
424 int scaled = 0;
425 unsigned int format = 0;
426 unsigned int tiling = 0;
427
428 frame_params[pin].flip = 0;
429 frame_params[pin].mirror = 0;
430 frame_params[pin].reduce_range = 0;
431 if (reso.pin_width[pin] != 0 && reso.pin_height[pin] != 0) {
432 enable = 1;
433 if (pin == IMGU_ABI_OSYS_PIN_OUT) {
434 if (reso.input_width < reso.pin_width[pin] ||
435 reso.input_height < reso.pin_height[pin])
436 return -EINVAL;
437 /*
438 * When input and output resolution is
439 * different instead of scaling, cropping
440 * should happen. Determine the crop factor
441 * to do the symmetric cropping
442 */
443 frame_params[pin].crop_left = roundclosest_down(
444 (reso.input_width -
445 reso.pin_width[pin]) / 2,
446 IMGU_OSYS_DMA_CROP_W_LIMIT);
447 frame_params[pin].crop_top = roundclosest_down(
448 (reso.input_height -
449 reso.pin_height[pin]) / 2,
450 IMGU_OSYS_DMA_CROP_H_LIMIT);
451 } else {
452 if (reso.pin_width[pin] != reso.input_width ||
453 reso.pin_height[pin] != reso.input_height) {
454 /*
455 * If resolution is different at input
456 * and output of OSYS, scaling is
457 * considered except when pin is MAIN.
458 * Later it will be decide whether
459 * scaler factor is 1 or other
460 * and cropping has to be done or not.
461 */
462 scaled = 1;
463 }
464 }
465 imgu_css_osys_set_format(reso.pin_format[pin], &format,
466 &tiling);
467 } else {
468 enable = 0;
469 }
470 frame_params[pin].enable = enable;
471 frame_params[pin].format = format;
472 frame_params[pin].tiling = tiling;
473 frame_params[pin].stride = reso.pin_stride[pin];
474 frame_params[pin].scaled = scaled;
475 }
476
477 imgu_css_scaler_calc(input_width, input_height, target_width,
478 target_height, osys, scaler_luma, scaler_chroma,
479 &reso.pin_width[IMGU_ABI_OSYS_PIN_VF],
480 &reso.pin_height[IMGU_ABI_OSYS_PIN_VF], &procmode);
481 dev_dbg(css->dev, "osys scaler procmode is %u", procmode);
482 output_width = reso.pin_width[IMGU_ABI_OSYS_PIN_VF];
483
484 if (output_width < reso.input_width / 2) {
485 /* Scaling factor <= 0.5 */
486 reso.chunk_width = IMGU_OSYS_BLOCK_WIDTH;
487 reso.block_width = IMGU_OSYS_BLOCK_WIDTH;
488 } else { /* 0.5 <= Scaling factor <= 1.0 */
489 reso.chunk_width = IMGU_OSYS_BLOCK_WIDTH / 2;
490 reso.block_width = IMGU_OSYS_BLOCK_WIDTH;
491 }
492
493 if (output_width <= reso.input_width * 7 / 8) {
494 /* Scaling factor <= 0.875 */
495 reso.chunk_height = IMGU_OSYS_BLOCK_HEIGHT;
496 reso.block_height = IMGU_OSYS_BLOCK_HEIGHT;
497 } else { /* 1.0 <= Scaling factor <= 1.75 */
498 reso.chunk_height = IMGU_OSYS_BLOCK_HEIGHT / 2;
499 reso.block_height = IMGU_OSYS_BLOCK_HEIGHT;
500 }
501
502 /*
503 * Calculate scaler configuration parameters based on input and output
504 * resolution.
505 */
506
507 if (frame_params[IMGU_ABI_OSYS_PIN_VF].enable) {
508 /*
509 * When aspect ratio is different between target resolution and
510 * required resolution, determine the crop factor to do
511 * symmetric cropping
512 */
513 u32 w = reso.pin_width[IMGU_ABI_OSYS_PIN_VF] -
514 frame_params[IMGU_ABI_OSYS_PIN_VF].width;
515 u32 h = reso.pin_height[IMGU_ABI_OSYS_PIN_VF] -
516 frame_params[IMGU_ABI_OSYS_PIN_VF].height;
517
518 frame_params[IMGU_ABI_OSYS_PIN_VF].crop_left =
519 roundclosest_down(w / 2, IMGU_OSYS_DMA_CROP_W_LIMIT);
520 frame_params[IMGU_ABI_OSYS_PIN_VF].crop_top =
521 roundclosest_down(h / 2, IMGU_OSYS_DMA_CROP_H_LIMIT);
522
523 if (reso.input_height % 4 || reso.input_width % 8) {
524 dev_err(css->dev, "OSYS input width is not multiple of 8 or\n");
525 dev_err(css->dev, "height is not multiple of 4\n");
526 return -EINVAL;
527 }
528 }
529
530 /* Stripe parameters */
531
532 if (frame_params[IMGU_ABI_OSYS_PIN_VF].enable) {
533 output_width = reso.pin_width[IMGU_ABI_OSYS_PIN_VF];
534 } else {
535 /*
536 * in case scaler output is not enabled
537 * take output width as input width since
538 * there is no scaling at main pin.
539 * Due to the fact that main pin can be different
540 * from input resolution to osys in the case of cropping,
541 * main pin resolution is not taken.
542 */
543 output_width = reso.input_width;
544 }
545
546 for (s = 0; s < stripes; s++) {
547 int stripe_offset_inp_y = 0;
548 int stripe_offset_inp_uv = 0;
549 int stripe_offset_out_y = 0;
550 int stripe_offset_out_uv = 0;
551 int stripe_phase_init_y = scaler_luma->phase_init;
552 int stripe_phase_init_uv = scaler_chroma->phase_init;
553 int stripe_offset_blk_y = 0;
554 int stripe_offset_blk_uv = 0;
555 int stripe_offset_col_y = 0;
556 int stripe_offset_col_uv = 0;
557 int stripe_pad_left_y = scaler_luma->pad_left;
558 int stripe_pad_left_uv = scaler_chroma->pad_left;
559 int stripe_pad_right_y = scaler_luma->pad_right;
560 int stripe_pad_right_uv = scaler_chroma->pad_right;
561 int stripe_crop_left_y = scaler_luma->crop_left;
562 int stripe_crop_left_uv = scaler_chroma->crop_left;
563 int stripe_input_width_y = reso.input_width;
564 int stripe_input_width_uv = 0;
565 int stripe_output_width_y = output_width;
566 int stripe_output_width_uv = 0;
567 int chunk_floor_y = 0;
568 int chunk_floor_uv = 0;
569 int chunk_ceil_uv = 0;
570
571 if (stripes > 1) {
572 if (s > 0) {
573 /* Calculate stripe offsets */
574 stripe_offset_out_y =
575 output_width * s / stripes;
576 stripe_offset_out_y =
577 rounddown(stripe_offset_out_y,
578 IPU3_UAPI_ISP_VEC_ELEMS);
579 stripe_offset_out_uv = stripe_offset_out_y /
580 IMGU_LUMA_TO_CHROMA_RATIO;
581 stripe_offset_inp_y =
582 imgu_css_osys_calc_stripe_offset(
583 stripe_offset_out_y,
584 IMGU_OSYS_FIR_PHASES,
585 scaler_luma->phase_init,
586 scaler_luma->phase_step,
587 scaler_luma->pad_left);
588 stripe_offset_inp_uv =
589 imgu_css_osys_calc_stripe_offset(
590 stripe_offset_out_uv,
591 IMGU_OSYS_FIR_PHASES,
592 scaler_chroma->phase_init,
593 scaler_chroma->phase_step,
594 scaler_chroma->pad_left);
595
596 /* Calculate stripe phase init */
597 stripe_phase_init_y =
598 imgu_css_osys_calc_stripe_phase_init(
599 stripe_offset_out_y,
600 IMGU_OSYS_FIR_PHASES,
601 scaler_luma->phase_init,
602 scaler_luma->phase_step,
603 scaler_luma->pad_left);
604 stripe_phase_init_uv =
605 imgu_css_osys_calc_stripe_phase_init(
606 stripe_offset_out_uv,
607 IMGU_OSYS_FIR_PHASES,
608 scaler_chroma->phase_init,
609 scaler_chroma->phase_step,
610 scaler_chroma->pad_left);
611
612 /*
613 * Chunk boundary corner case - luma and chroma
614 * start from different input chunks.
615 */
616 chunk_floor_y = rounddown(stripe_offset_inp_y,
617 reso.chunk_width);
618 chunk_floor_uv =
619 rounddown(stripe_offset_inp_uv,
620 reso.chunk_width /
621 IMGU_LUMA_TO_CHROMA_RATIO);
622
623 if (chunk_floor_y != chunk_floor_uv *
624 IMGU_LUMA_TO_CHROMA_RATIO) {
625 /*
626 * Match starting luma/chroma chunks.
627 * Decrease offset for UV and add output
628 * cropping.
629 */
630 stripe_offset_inp_uv -= 1;
631 stripe_crop_left_uv += 1;
632 stripe_phase_init_uv -=
633 scaler_luma->phase_step;
634 if (stripe_phase_init_uv < 0)
635 stripe_phase_init_uv =
636 stripe_phase_init_uv +
637 IMGU_OSYS_FIR_PHASES;
638 }
639 /*
640 * FW workaround for a HW bug: if the first
641 * chroma pixel is generated exactly at the end
642 * of chunck scaler HW may not output the pixel
643 * for downscale factors smaller than 1.5
644 * (timing issue).
645 */
646 chunk_ceil_uv =
647 roundup(stripe_offset_inp_uv,
648 reso.chunk_width /
649 IMGU_LUMA_TO_CHROMA_RATIO);
650
651 if (stripe_offset_inp_uv ==
652 chunk_ceil_uv - IMGU_OSYS_TAPS_UV) {
653 /*
654 * Decrease input offset and add
655 * output cropping
656 */
657 stripe_offset_inp_uv -= 1;
658 stripe_phase_init_uv -=
659 scaler_luma->phase_step;
660 if (stripe_phase_init_uv < 0) {
661 stripe_phase_init_uv +=
662 IMGU_OSYS_FIR_PHASES;
663 stripe_crop_left_uv += 1;
664 }
665 }
666
667 /*
668 * Calculate block and column offsets for the
669 * input stripe
670 */
671 stripe_offset_blk_y =
672 rounddown(stripe_offset_inp_y,
673 IMGU_INPUT_BLOCK_WIDTH);
674 stripe_offset_blk_uv =
675 rounddown(stripe_offset_inp_uv,
676 IMGU_INPUT_BLOCK_WIDTH /
677 IMGU_LUMA_TO_CHROMA_RATIO);
678 stripe_offset_col_y = stripe_offset_inp_y -
679 stripe_offset_blk_y;
680 stripe_offset_col_uv = stripe_offset_inp_uv -
681 stripe_offset_blk_uv;
682
683 /* Left padding is only for the first stripe */
684 stripe_pad_left_y = 0;
685 stripe_pad_left_uv = 0;
686 }
687
688 /* Right padding is only for the last stripe */
689 if (s < stripes - 1) {
690 int next_offset;
691
692 stripe_pad_right_y = 0;
693 stripe_pad_right_uv = 0;
694
695 next_offset = output_width * (s + 1) / stripes;
696 next_offset = rounddown(next_offset, 64);
697 stripe_output_width_y = next_offset -
698 stripe_offset_out_y;
699 } else {
700 stripe_output_width_y = output_width -
701 stripe_offset_out_y;
702 }
703
704 /* Calculate target output stripe width */
705 stripe_output_width_uv = stripe_output_width_y /
706 IMGU_LUMA_TO_CHROMA_RATIO;
707 /* Calculate input stripe width */
708 stripe_input_width_y = stripe_offset_col_y +
709 imgu_css_osys_calc_inp_stripe_width(
710 stripe_output_width_y,
711 IMGU_OSYS_FIR_PHASES,
712 stripe_phase_init_y,
713 scaler_luma->phase_step,
714 IMGU_OSYS_TAPS_Y,
715 stripe_pad_left_y,
716 stripe_pad_right_y);
717
718 stripe_input_width_uv = stripe_offset_col_uv +
719 imgu_css_osys_calc_inp_stripe_width(
720 stripe_output_width_uv,
721 IMGU_OSYS_FIR_PHASES,
722 stripe_phase_init_uv,
723 scaler_chroma->phase_step,
724 IMGU_OSYS_TAPS_UV,
725 stripe_pad_left_uv,
726 stripe_pad_right_uv);
727
728 stripe_input_width_uv = max(DIV_ROUND_UP(
729 stripe_input_width_y,
730 IMGU_LUMA_TO_CHROMA_RATIO),
731 stripe_input_width_uv);
732
733 stripe_input_width_y = stripe_input_width_uv *
734 IMGU_LUMA_TO_CHROMA_RATIO;
735
736 if (s >= stripes - 1) {
737 stripe_input_width_y = reso.input_width -
738 stripe_offset_blk_y;
739 /*
740 * The scaler requires that the last stripe
741 * spans at least two input blocks.
742 */
743 }
744
745 /*
746 * Spec: input stripe width must be a multiple of 8.
747 * Increase the input width and recalculate the output
748 * width. This may produce an extra column of junk
749 * blocks which will be overwritten by the
750 * next stripe.
751 */
752 stripe_input_width_y = ALIGN(stripe_input_width_y, 8);
753 stripe_output_width_y =
754 imgu_css_osys_out_stripe_width(
755 stripe_input_width_y,
756 IMGU_OSYS_FIR_PHASES,
757 stripe_phase_init_y,
758 scaler_luma->phase_step,
759 IMGU_OSYS_TAPS_Y,
760 stripe_pad_left_y,
761 stripe_pad_right_y,
762 stripe_offset_col_y);
763
764 stripe_output_width_y =
765 rounddown(stripe_output_width_y,
766 IMGU_LUMA_TO_CHROMA_RATIO);
767 }
768 /*
769 * Following section executes and process parameters
770 * for both cases - Striping or No Striping.
771 */
772 {
773 unsigned int i;
774 /*Input resolution */
775
776 stripe_params[s].input_width = stripe_input_width_y;
777 stripe_params[s].input_height = reso.input_height;
778
779 for (i = 0; i < IMGU_ABI_OSYS_PINS; i++) {
780 if (frame_params[i].scaled) {
781 /*
782 * Output stripe resolution and offset
783 * as produced by the scaler; actual
784 * output resolution may be slightly
785 * smaller.
786 */
787 stripe_params[s].output_width[i] =
788 stripe_output_width_y;
789 stripe_params[s].output_height[i] =
790 reso.pin_height[i];
791 stripe_params[s].output_offset[i] =
792 stripe_offset_out_y;
793 } else {
794 /* Unscaled pin */
795 stripe_params[s].output_width[i] =
796 stripe_params[s].input_width;
797 stripe_params[s].output_height[i] =
798 stripe_params[s].input_height;
799 stripe_params[s].output_offset[i] =
800 stripe_offset_blk_y;
801 }
802 }
803
804 /* If no pin use scale, we use BYPASS mode */
805 stripe_params[s].processing_mode = procmode;
806 stripe_params[s].phase_step = scaler_luma->phase_step;
807 stripe_params[s].exp_shift = scaler_luma->exp_shift;
808 stripe_params[s].phase_init_left_y =
809 stripe_phase_init_y;
810 stripe_params[s].phase_init_left_uv =
811 stripe_phase_init_uv;
812 stripe_params[s].phase_init_top_y =
813 scaler_luma->phase_init;
814 stripe_params[s].phase_init_top_uv =
815 scaler_chroma->phase_init;
816 stripe_params[s].pad_left_y = stripe_pad_left_y;
817 stripe_params[s].pad_left_uv = stripe_pad_left_uv;
818 stripe_params[s].pad_right_y = stripe_pad_right_y;
819 stripe_params[s].pad_right_uv = stripe_pad_right_uv;
820 stripe_params[s].pad_top_y = scaler_luma->pad_left;
821 stripe_params[s].pad_top_uv = scaler_chroma->pad_left;
822 stripe_params[s].pad_bottom_y = scaler_luma->pad_right;
823 stripe_params[s].pad_bottom_uv =
824 scaler_chroma->pad_right;
825 stripe_params[s].crop_left_y = stripe_crop_left_y;
826 stripe_params[s].crop_top_y = scaler_luma->crop_top;
827 stripe_params[s].crop_left_uv = stripe_crop_left_uv;
828 stripe_params[s].crop_top_uv = scaler_chroma->crop_top;
829 stripe_params[s].start_column_y = stripe_offset_col_y;
830 stripe_params[s].start_column_uv = stripe_offset_col_uv;
831 stripe_params[s].chunk_width = reso.chunk_width;
832 stripe_params[s].chunk_height = reso.chunk_height;
833 stripe_params[s].block_width = reso.block_width;
834 stripe_params[s].block_height = reso.block_height;
835 }
836 }
837
838 return 0;
839 }
840
841 /*
842 * This function configures the Output Formatter System, given the number of
843 * stripes, scaler luma and chrome parameters
844 */
imgu_css_osys_calc(struct imgu_css * css,unsigned int pipe,unsigned int stripes,struct imgu_abi_osys_config * osys,struct imgu_css_scaler_info * scaler_luma,struct imgu_css_scaler_info * scaler_chroma,struct imgu_abi_stripes block_stripes[])845 static int imgu_css_osys_calc(struct imgu_css *css, unsigned int pipe,
846 unsigned int stripes,
847 struct imgu_abi_osys_config *osys,
848 struct imgu_css_scaler_info *scaler_luma,
849 struct imgu_css_scaler_info *scaler_chroma,
850 struct imgu_abi_stripes block_stripes[])
851 {
852 struct imgu_css_frame_params frame_params[IMGU_ABI_OSYS_PINS];
853 struct imgu_css_stripe_params stripe_params[IPU3_UAPI_MAX_STRIPES];
854 struct imgu_abi_osys_formatter_params *param;
855 unsigned int pin, s;
856 struct imgu_css_pipe *css_pipe = &css->pipes[pipe];
857
858 memset(osys, 0, sizeof(*osys));
859
860 /* Compute the frame and stripe params */
861 if (imgu_css_osys_calc_frame_and_stripe_params(css, stripes, osys,
862 scaler_luma,
863 scaler_chroma,
864 frame_params,
865 stripe_params, pipe))
866 return -EINVAL;
867
868 /* Output formatter system parameters */
869
870 for (s = 0; s < stripes; s++) {
871 struct imgu_abi_osys_scaler_params *scaler =
872 &osys->scaler[s].param;
873 int fifo_addr_fmt = IMGU_FIFO_ADDR_SCALER_TO_FMT;
874 int fifo_addr_ack = IMGU_FIFO_ADDR_SCALER_TO_SP;
875
876 /* OUTPUT 0 / PIN 0 is only Scaler output */
877 scaler->inp_buf_y_st_addr = IMGU_VMEM1_INP_BUF_ADDR;
878
879 /*
880 * = (IMGU_OSYS_BLOCK_WIDTH / IMGU_VMEM1_ELEMS_PER_VEC)
881 * = (2 * IPU3_UAPI_ISP_VEC_ELEMS) /
882 * (IMGU_HIVE_OF_SYS_OF_SYSTEM_NWAYS)
883 * = 2 * 64 / 32 = 4
884 */
885 scaler->inp_buf_y_line_stride = IMGU_VMEM1_Y_STRIDE;
886 /*
887 * = (IMGU_VMEM1_V_OFFSET + VMEM1_uv_size)
888 * = (IMGU_VMEM1_U_OFFSET + VMEM1_uv_size) +
889 * (VMEM1_y_size / 4)
890 * = (VMEM1_y_size) + (VMEM1_y_size / 4) +
891 * (IMGU_OSYS_BLOCK_HEIGHT * IMGU_VMEM1_Y_STRIDE)/4
892 * = (IMGU_OSYS_BLOCK_HEIGHT * IMGU_VMEM1_Y_STRIDE)
893 */
894 scaler->inp_buf_y_buffer_stride = IMGU_VMEM1_BUF_SIZE;
895 scaler->inp_buf_u_st_addr = IMGU_VMEM1_INP_BUF_ADDR +
896 IMGU_VMEM1_U_OFFSET;
897 scaler->inp_buf_v_st_addr = IMGU_VMEM1_INP_BUF_ADDR +
898 IMGU_VMEM1_V_OFFSET;
899 scaler->inp_buf_uv_line_stride = IMGU_VMEM1_UV_STRIDE;
900 scaler->inp_buf_uv_buffer_stride = IMGU_VMEM1_BUF_SIZE;
901 scaler->inp_buf_chunk_width = stripe_params[s].chunk_width;
902 scaler->inp_buf_nr_buffers = IMGU_OSYS_NUM_INPUT_BUFFERS;
903
904 /* Output buffers */
905 scaler->out_buf_y_st_addr = IMGU_VMEM1_INT_BUF_ADDR;
906 scaler->out_buf_y_line_stride = stripe_params[s].block_width /
907 IMGU_VMEM1_ELEMS_PER_VEC;
908 scaler->out_buf_y_buffer_stride = IMGU_VMEM1_BUF_SIZE;
909 scaler->out_buf_u_st_addr = IMGU_VMEM1_INT_BUF_ADDR +
910 IMGU_VMEM1_U_OFFSET;
911 scaler->out_buf_v_st_addr = IMGU_VMEM1_INT_BUF_ADDR +
912 IMGU_VMEM1_V_OFFSET;
913 scaler->out_buf_uv_line_stride = stripe_params[s].block_width /
914 IMGU_VMEM1_ELEMS_PER_VEC / 2;
915 scaler->out_buf_uv_buffer_stride = IMGU_VMEM1_BUF_SIZE;
916 scaler->out_buf_nr_buffers = IMGU_OSYS_NUM_INTERM_BUFFERS;
917
918 /* Intermediate buffers */
919 scaler->int_buf_y_st_addr = IMGU_VMEM2_BUF_Y_ADDR;
920 scaler->int_buf_y_line_stride = IMGU_VMEM2_BUF_Y_STRIDE;
921 scaler->int_buf_u_st_addr = IMGU_VMEM2_BUF_U_ADDR;
922 scaler->int_buf_v_st_addr = IMGU_VMEM2_BUF_V_ADDR;
923 scaler->int_buf_uv_line_stride = IMGU_VMEM2_BUF_UV_STRIDE;
924 scaler->int_buf_height = IMGU_VMEM2_LINES_PER_BLOCK;
925 scaler->int_buf_chunk_width = stripe_params[s].chunk_height;
926 scaler->int_buf_chunk_height = stripe_params[s].block_width;
927
928 /* Context buffers */
929 scaler->ctx_buf_hor_y_st_addr = IMGU_VMEM3_HOR_Y_ADDR;
930 scaler->ctx_buf_hor_u_st_addr = IMGU_VMEM3_HOR_U_ADDR;
931 scaler->ctx_buf_hor_v_st_addr = IMGU_VMEM3_HOR_V_ADDR;
932 scaler->ctx_buf_ver_y_st_addr = IMGU_VMEM3_VER_Y_ADDR;
933 scaler->ctx_buf_ver_u_st_addr = IMGU_VMEM3_VER_U_ADDR;
934 scaler->ctx_buf_ver_v_st_addr = IMGU_VMEM3_VER_V_ADDR;
935
936 /* Addresses for release-input and process-output tokens */
937 scaler->release_inp_buf_addr = fifo_addr_ack;
938 scaler->release_inp_buf_en = 1;
939 scaler->release_out_buf_en = 1;
940 scaler->process_out_buf_addr = fifo_addr_fmt;
941
942 /* Settings dimensions, padding, cropping */
943 scaler->input_image_y_width = stripe_params[s].input_width;
944 scaler->input_image_y_height = stripe_params[s].input_height;
945 scaler->input_image_y_start_column =
946 stripe_params[s].start_column_y;
947 scaler->input_image_uv_start_column =
948 stripe_params[s].start_column_uv;
949 scaler->input_image_y_left_pad = stripe_params[s].pad_left_y;
950 scaler->input_image_uv_left_pad = stripe_params[s].pad_left_uv;
951 scaler->input_image_y_right_pad = stripe_params[s].pad_right_y;
952 scaler->input_image_uv_right_pad =
953 stripe_params[s].pad_right_uv;
954 scaler->input_image_y_top_pad = stripe_params[s].pad_top_y;
955 scaler->input_image_uv_top_pad = stripe_params[s].pad_top_uv;
956 scaler->input_image_y_bottom_pad =
957 stripe_params[s].pad_bottom_y;
958 scaler->input_image_uv_bottom_pad =
959 stripe_params[s].pad_bottom_uv;
960 scaler->processing_mode = stripe_params[s].processing_mode;
961 scaler->scaling_ratio = stripe_params[s].phase_step;
962 scaler->y_left_phase_init = stripe_params[s].phase_init_left_y;
963 scaler->uv_left_phase_init =
964 stripe_params[s].phase_init_left_uv;
965 scaler->y_top_phase_init = stripe_params[s].phase_init_top_y;
966 scaler->uv_top_phase_init = stripe_params[s].phase_init_top_uv;
967 scaler->coeffs_exp_shift = stripe_params[s].exp_shift;
968 scaler->out_y_left_crop = stripe_params[s].crop_left_y;
969 scaler->out_uv_left_crop = stripe_params[s].crop_left_uv;
970 scaler->out_y_top_crop = stripe_params[s].crop_top_y;
971 scaler->out_uv_top_crop = stripe_params[s].crop_top_uv;
972
973 for (pin = 0; pin < IMGU_ABI_OSYS_PINS; pin++) {
974 int in_fifo_addr;
975 int out_fifo_addr;
976 int block_width_vecs;
977 int input_width_s;
978 int input_width_vecs;
979 int input_buf_y_st_addr;
980 int input_buf_u_st_addr;
981 int input_buf_v_st_addr;
982 int input_buf_y_line_stride;
983 int input_buf_uv_line_stride;
984 int output_buf_y_line_stride;
985 int output_buf_uv_line_stride;
986 int output_buf_nr_y_lines;
987 int block_height;
988 int block_width;
989 struct imgu_abi_osys_frame_params *fr_pr;
990
991 fr_pr = &osys->frame[pin].param;
992
993 /* Frame parameters */
994 fr_pr->enable = frame_params[pin].enable;
995 fr_pr->format = frame_params[pin].format;
996 fr_pr->mirror = frame_params[pin].mirror;
997 fr_pr->flip = frame_params[pin].flip;
998 fr_pr->tiling = frame_params[pin].tiling;
999 fr_pr->width = frame_params[pin].width;
1000 fr_pr->height = frame_params[pin].height;
1001 fr_pr->stride = frame_params[pin].stride;
1002 fr_pr->scaled = frame_params[pin].scaled;
1003
1004 /* Stripe parameters */
1005 osys->stripe[s].crop_top[pin] =
1006 frame_params[pin].crop_top;
1007 osys->stripe[s].input_width =
1008 stripe_params[s].input_width;
1009 osys->stripe[s].input_height =
1010 stripe_params[s].input_height;
1011 osys->stripe[s].block_height =
1012 stripe_params[s].block_height;
1013 osys->stripe[s].block_width =
1014 stripe_params[s].block_width;
1015 osys->stripe[s].output_width[pin] =
1016 stripe_params[s].output_width[pin];
1017 osys->stripe[s].output_height[pin] =
1018 stripe_params[s].output_height[pin];
1019
1020 if (s == 0) {
1021 /* Only first stripe should do left cropping */
1022 osys->stripe[s].crop_left[pin] =
1023 frame_params[pin].crop_left;
1024 osys->stripe[s].output_offset[pin] =
1025 stripe_params[s].output_offset[pin];
1026 } else {
1027 /*
1028 * Stripe offset for other strips should be
1029 * adjusted according to the cropping done
1030 * at the first strip
1031 */
1032 osys->stripe[s].crop_left[pin] = 0;
1033 osys->stripe[s].output_offset[pin] =
1034 (stripe_params[s].output_offset[pin] -
1035 osys->stripe[0].crop_left[pin]);
1036 }
1037
1038 if (!frame_params[pin].enable)
1039 continue;
1040
1041 /* Formatter: configurations */
1042
1043 /*
1044 * Get the dimensions of the input blocks of the
1045 * formatter, which is the same as the output
1046 * blocks of the scaler.
1047 */
1048 if (frame_params[pin].scaled) {
1049 block_height = stripe_params[s].block_height;
1050 block_width = stripe_params[s].block_width;
1051 } else {
1052 block_height = IMGU_OSYS_BLOCK_HEIGHT;
1053 block_width = IMGU_OSYS_BLOCK_WIDTH;
1054 }
1055 block_width_vecs =
1056 block_width / IMGU_VMEM1_ELEMS_PER_VEC;
1057 /*
1058 * The input/output line stride depends on the
1059 * block size.
1060 */
1061 input_buf_y_line_stride = block_width_vecs;
1062 input_buf_uv_line_stride = block_width_vecs / 2;
1063 output_buf_y_line_stride = block_width_vecs;
1064 output_buf_uv_line_stride = block_width_vecs / 2;
1065 output_buf_nr_y_lines = block_height;
1066 if (frame_params[pin].format ==
1067 IMGU_ABI_OSYS_FORMAT_NV12 ||
1068 frame_params[pin].format ==
1069 IMGU_ABI_OSYS_FORMAT_NV21)
1070 output_buf_uv_line_stride =
1071 output_buf_y_line_stride;
1072
1073 /*
1074 * Tiled outputs use a different output buffer
1075 * configuration. The input (= scaler output) block
1076 * width translates to a tile height, and the block
1077 * height to the tile width. The default block size of
1078 * 128x32 maps exactly onto a 4kB tile (512x8) for Y.
1079 * For UV, the tile width is always half.
1080 */
1081 if (frame_params[pin].tiling) {
1082 output_buf_nr_y_lines = 8;
1083 output_buf_y_line_stride = 512 /
1084 IMGU_VMEM1_ELEMS_PER_VEC;
1085 output_buf_uv_line_stride = 256 /
1086 IMGU_VMEM1_ELEMS_PER_VEC;
1087 }
1088
1089 /*
1090 * Store the output buffer line stride. Will be
1091 * used to compute buffer offsets in boundary
1092 * conditions when output blocks are partially
1093 * outside the image.
1094 */
1095 osys->stripe[s].buf_stride[pin] =
1096 output_buf_y_line_stride *
1097 IMGU_HIVE_OF_SYS_OF_SYSTEM_NWAYS;
1098 if (frame_params[pin].scaled) {
1099 /*
1100 * The input buffs are the intermediate
1101 * buffers (scalers' output)
1102 */
1103 input_buf_y_st_addr = IMGU_VMEM1_INT_BUF_ADDR;
1104 input_buf_u_st_addr = IMGU_VMEM1_INT_BUF_ADDR +
1105 IMGU_VMEM1_U_OFFSET;
1106 input_buf_v_st_addr = IMGU_VMEM1_INT_BUF_ADDR +
1107 IMGU_VMEM1_V_OFFSET;
1108 } else {
1109 /*
1110 * The input bufferss are the buffers
1111 * filled by the SP
1112 */
1113 input_buf_y_st_addr = IMGU_VMEM1_INP_BUF_ADDR;
1114 input_buf_u_st_addr = IMGU_VMEM1_INP_BUF_ADDR +
1115 IMGU_VMEM1_U_OFFSET;
1116 input_buf_v_st_addr = IMGU_VMEM1_INP_BUF_ADDR +
1117 IMGU_VMEM1_V_OFFSET;
1118 }
1119
1120 /*
1121 * The formatter input width must be rounded to
1122 * the block width. Otherwise the formatter will
1123 * not recognize the end of the line, resulting
1124 * in incorrect tiling (system may hang!) and
1125 * possibly other problems.
1126 */
1127 input_width_s =
1128 roundup(stripe_params[s].output_width[pin],
1129 block_width);
1130 input_width_vecs = input_width_s /
1131 IMGU_VMEM1_ELEMS_PER_VEC;
1132 out_fifo_addr = IMGU_FIFO_ADDR_FMT_TO_SP;
1133 /*
1134 * Process-output tokens must be sent to the SP.
1135 * When scaling, the release-input tokens can be
1136 * sent directly to the scaler, otherwise the
1137 * formatter should send them to the SP.
1138 */
1139 if (frame_params[pin].scaled)
1140 in_fifo_addr = IMGU_FIFO_ADDR_FMT_TO_SCALER;
1141 else
1142 in_fifo_addr = IMGU_FIFO_ADDR_FMT_TO_SP;
1143
1144 /* Formatter */
1145 param = &osys->formatter[s][pin].param;
1146
1147 param->format = frame_params[pin].format;
1148 param->flip = frame_params[pin].flip;
1149 param->mirror = frame_params[pin].mirror;
1150 param->tiling = frame_params[pin].tiling;
1151 param->reduce_range = frame_params[pin].reduce_range;
1152 param->alpha_blending = 0;
1153 param->release_inp_addr = in_fifo_addr;
1154 param->release_inp_en = 1;
1155 param->process_out_buf_addr = out_fifo_addr;
1156 param->image_width_vecs = input_width_vecs;
1157 param->image_height_lines =
1158 stripe_params[s].output_height[pin];
1159 param->inp_buff_y_st_addr = input_buf_y_st_addr;
1160 param->inp_buff_y_line_stride = input_buf_y_line_stride;
1161 param->inp_buff_y_buffer_stride = IMGU_VMEM1_BUF_SIZE;
1162 param->int_buff_u_st_addr = input_buf_u_st_addr;
1163 param->int_buff_v_st_addr = input_buf_v_st_addr;
1164 param->inp_buff_uv_line_stride =
1165 input_buf_uv_line_stride;
1166 param->inp_buff_uv_buffer_stride = IMGU_VMEM1_BUF_SIZE;
1167 param->out_buff_level = 0;
1168 param->out_buff_nr_y_lines = output_buf_nr_y_lines;
1169 param->out_buff_u_st_offset = IMGU_VMEM1_U_OFFSET;
1170 param->out_buff_v_st_offset = IMGU_VMEM1_V_OFFSET;
1171 param->out_buff_y_line_stride =
1172 output_buf_y_line_stride;
1173 param->out_buff_uv_line_stride =
1174 output_buf_uv_line_stride;
1175 param->hist_buff_st_addr = IMGU_VMEM1_HST_BUF_ADDR;
1176 param->hist_buff_line_stride =
1177 IMGU_VMEM1_HST_BUF_STRIDE;
1178 param->hist_buff_nr_lines = IMGU_VMEM1_HST_BUF_NLINES;
1179 }
1180 }
1181
1182 block_stripes[0].offset = 0;
1183 if (stripes <= 1) {
1184 block_stripes[0].width = stripe_params[0].input_width;
1185 block_stripes[0].height = stripe_params[0].input_height;
1186 } else {
1187 struct imgu_fw_info *bi =
1188 &css->fwp->binary_header[css_pipe->bindex];
1189 unsigned int sp_block_width =
1190 bi->info.isp.sp.block.block_width *
1191 IPU3_UAPI_ISP_VEC_ELEMS;
1192
1193 block_stripes[0].width = roundup(stripe_params[0].input_width,
1194 sp_block_width);
1195 block_stripes[1].offset =
1196 rounddown(css_pipe->rect[IPU3_CSS_RECT_GDC].width -
1197 stripe_params[1].input_width, sp_block_width);
1198 block_stripes[1].width =
1199 roundup(css_pipe->rect[IPU3_CSS_RECT_GDC].width -
1200 block_stripes[1].offset, sp_block_width);
1201 block_stripes[0].height = css_pipe->rect[IPU3_CSS_RECT_GDC].height;
1202 block_stripes[1].height = block_stripes[0].height;
1203 }
1204
1205 return 0;
1206 }
1207
1208 /*********************** Mostly 3A operations ******************************/
1209
1210 /*
1211 * This function creates a "TO-DO list" (operations) for the sp code.
1212 *
1213 * There are 2 types of operations:
1214 * 1. Transfer: Issue DMA transfer request for copying grid cells from DDR to
1215 * accelerator space (NOTE that this space is limited) associated data:
1216 * DDR address + accelerator's config set index(acc's address).
1217 *
1218 * 2. Issue "Process Lines Command" to shd accelerator
1219 * associated data: #lines + which config set to use (actually, accelerator
1220 * will use x AND (x+1)%num_of_sets - NOTE that this implies the restriction
1221 * of not touching config sets x & (x+1)%num_of_sets when process_lines(x)
1222 * is active).
1223 *
1224 * Basically there are 2 types of operations "chunks":
1225 * 1. "initial chunk": Initially, we do as much transfers as we can (and need)
1226 * [0 - max sets(3) ] followed by 1 or 2 "process lines" operations.
1227 *
1228 * 2. "regular chunk" - 1 transfer followed by 1 process line operation.
1229 * (in some cases we might need additional transfer ate the last chunk).
1230 *
1231 * for some case:
1232 * --> init
1233 * tr (0)
1234 * tr (1)
1235 * tr (2)
1236 * pl (0)
1237 * pl (1)
1238 * --> ack (0)
1239 * tr (3)
1240 * pl (2)
1241 * --> ack (1)
1242 * pl (3)
1243 * --> ack (2)
1244 * do nothing
1245 * --> ack (3)
1246 * do nothing
1247 */
1248
1249 static int
imgu_css_shd_ops_calc(struct imgu_abi_shd_intra_frame_operations_data * ops,const struct ipu3_uapi_shd_grid_config * grid,unsigned int image_height)1250 imgu_css_shd_ops_calc(struct imgu_abi_shd_intra_frame_operations_data *ops,
1251 const struct ipu3_uapi_shd_grid_config *grid,
1252 unsigned int image_height)
1253 {
1254 unsigned int block_height = 1 << grid->block_height_log2;
1255 unsigned int grid_height_per_slice = grid->grid_height_per_slice;
1256 unsigned int set_height = grid_height_per_slice * block_height;
1257
1258 /* We currently support only abs(y_start) > grid_height_per_slice */
1259 unsigned int positive_y_start = (unsigned int)-grid->y_start;
1260 unsigned int first_process_lines =
1261 set_height - (positive_y_start % set_height);
1262 unsigned int last_set_height;
1263 unsigned int num_of_sets;
1264
1265 struct imgu_abi_acc_operation *p_op;
1266 struct imgu_abi_acc_process_lines_cmd_data *p_pl;
1267 struct imgu_abi_shd_transfer_luts_set_data *p_tr;
1268
1269 unsigned int op_idx, pl_idx, tr_idx;
1270 unsigned char tr_set_num, pl_cfg_set;
1271
1272 /*
1273 * When the number of lines for the last process lines command
1274 * is equal to a set height, we need another line of grid cell -
1275 * additional transfer is required.
1276 */
1277 unsigned char last_tr = 0;
1278
1279 /* Add "process lines" command to the list of operations */
1280 bool add_pl;
1281 /* Add DMA xfer (config set) command to the list of ops */
1282 bool add_tr;
1283
1284 /*
1285 * Available partial grid (the part that fits into #IMGU_SHD_SETS sets)
1286 * doesn't cover whole frame - need to process in chunks
1287 */
1288 if (image_height > first_process_lines) {
1289 last_set_height =
1290 (image_height - first_process_lines) % set_height;
1291 num_of_sets = last_set_height > 0 ?
1292 (image_height - first_process_lines) / set_height + 2 :
1293 (image_height - first_process_lines) / set_height + 1;
1294 last_tr = (set_height - last_set_height <= block_height ||
1295 last_set_height == 0) ? 1 : 0;
1296 } else { /* partial grid covers whole frame */
1297 last_set_height = 0;
1298 num_of_sets = 1;
1299 first_process_lines = image_height;
1300 last_tr = set_height - image_height <= block_height ? 1 : 0;
1301 }
1302
1303 /* Init operations lists and counters */
1304 p_op = ops->operation_list;
1305 op_idx = 0;
1306 p_pl = ops->process_lines_data;
1307 pl_idx = 0;
1308 p_tr = ops->transfer_data;
1309 tr_idx = 0;
1310
1311 memset(ops, 0, sizeof(*ops));
1312
1313 /* Cyclic counters that holds config set number [0,IMGU_SHD_SETS) */
1314 tr_set_num = 0;
1315 pl_cfg_set = 0;
1316
1317 /*
1318 * Always start with a transfer - process lines command must be
1319 * initiated only after appropriate config sets are in place
1320 * (2 configuration sets per process line command, except for last one).
1321 */
1322 add_pl = false;
1323 add_tr = true;
1324
1325 while (add_pl || add_tr) {
1326 /* Transfer ops */
1327 if (add_tr) {
1328 if (op_idx >= IMGU_ABI_SHD_MAX_OPERATIONS ||
1329 tr_idx >= IMGU_ABI_SHD_MAX_TRANSFERS)
1330 return -EINVAL;
1331 p_op[op_idx].op_type =
1332 IMGU_ABI_ACC_OPTYPE_TRANSFER_DATA;
1333 p_op[op_idx].op_indicator = IMGU_ABI_ACC_OP_IDLE;
1334 op_idx++;
1335 p_tr[tr_idx].set_number = tr_set_num;
1336 tr_idx++;
1337 tr_set_num = (tr_set_num + 1) % IMGU_SHD_SETS;
1338 }
1339
1340 /* Process-lines ops */
1341 if (add_pl) {
1342 if (op_idx >= IMGU_ABI_SHD_MAX_OPERATIONS ||
1343 pl_idx >= IMGU_ABI_SHD_MAX_PROCESS_LINES)
1344 return -EINVAL;
1345 p_op[op_idx].op_type =
1346 IMGU_ABI_ACC_OPTYPE_PROCESS_LINES;
1347
1348 /*
1349 * In case we have 2 process lines commands -
1350 * don't stop after the first one
1351 */
1352 if (pl_idx == 0 && num_of_sets != 1)
1353 p_op[op_idx].op_indicator =
1354 IMGU_ABI_ACC_OP_IDLE;
1355 /*
1356 * Initiate last process lines command -
1357 * end of operation list.
1358 */
1359 else if (pl_idx == num_of_sets - 1)
1360 p_op[op_idx].op_indicator =
1361 IMGU_ABI_ACC_OP_END_OF_OPS;
1362 /*
1363 * Intermediate process line command - end of operation
1364 * "chunk" (meaning few "transfers" followed by few
1365 * "process lines" commands).
1366 */
1367 else
1368 p_op[op_idx].op_indicator =
1369 IMGU_ABI_ACC_OP_END_OF_ACK;
1370
1371 op_idx++;
1372
1373 /* first process line operation */
1374 if (pl_idx == 0)
1375 p_pl[pl_idx].lines = first_process_lines;
1376 /* Last process line operation */
1377 else if (pl_idx == num_of_sets - 1 &&
1378 last_set_height > 0)
1379 p_pl[pl_idx].lines = last_set_height;
1380 else /* "regular" process lines operation */
1381 p_pl[pl_idx].lines = set_height;
1382
1383 p_pl[pl_idx].cfg_set = pl_cfg_set;
1384 pl_idx++;
1385 pl_cfg_set = (pl_cfg_set + 1) % IMGU_SHD_SETS;
1386 }
1387
1388 /*
1389 * Initially, we always transfer
1390 * min(IMGU_SHD_SETS, num_of_sets) - after that we fill in the
1391 * corresponding process lines commands.
1392 */
1393 if (tr_idx == IMGU_SHD_SETS ||
1394 tr_idx == num_of_sets + last_tr) {
1395 add_tr = false;
1396 add_pl = true;
1397 }
1398
1399 /*
1400 * We have finished the "initial" operations chunk -
1401 * be ready to get more chunks.
1402 */
1403 if (pl_idx == 2) {
1404 add_tr = true;
1405 add_pl = true;
1406 }
1407
1408 /* Stop conditions for each operation type */
1409 if (tr_idx == num_of_sets + last_tr)
1410 add_tr = false;
1411 if (pl_idx == num_of_sets)
1412 add_pl = false;
1413 }
1414
1415 return 0;
1416 }
1417
1418 /*
1419 * The follow handshake procotol is the same for AF, AWB and AWB FR.
1420 *
1421 * for n sets of meta-data, the flow is:
1422 * --> init
1423 * process-lines (0)
1424 * process-lines (1) eoc
1425 * --> ack (0)
1426 * read-meta-data (0)
1427 * process-lines (2) eoc
1428 * --> ack (1)
1429 * read-meta-data (1)
1430 * process-lines (3) eoc
1431 * ...
1432 *
1433 * --> ack (n-3)
1434 * read-meta-data (n-3)
1435 * process-lines (n-1) eoc
1436 * --> ack (n-2)
1437 * read-meta-data (n-2) eoc
1438 * --> ack (n-1)
1439 * read-meta-data (n-1) eof
1440 *
1441 * for 2 sets we get:
1442 * --> init
1443 * pl (0)
1444 * pl (1) eoc
1445 * --> ack (0)
1446 * pl (2) - rest of image, if applicable)
1447 * rmd (0) eoc
1448 * --> ack (1)
1449 * rmd (1) eof
1450 * --> (ack (2))
1451 * do nothing
1452 *
1453 * for only one set:
1454 *
1455 * --> init
1456 * pl(0) eoc
1457 * --> ack (0)
1458 * rmd (0) eof
1459 *
1460 * grid smaller than image case
1461 * for example 128x128 grid (block size 8x8, 16x16 num of blocks)
1462 * start at (0,0)
1463 * 1st set holds 160 cells - 10 blocks vertical, 16 horizontal
1464 * => 1st process lines = 80
1465 * we're left with 128-80=48 lines (6 blocks vertical)
1466 * => 2nd process lines = 48
1467 * last process lines to cover the image - image_height - 128
1468 *
1469 * --> init
1470 * pl (0) first
1471 * pl (1) last-in-grid
1472 * --> ack (0)
1473 * rmd (0)
1474 * pl (2) after-grid
1475 * --> ack (1)
1476 * rmd (1) eof
1477 * --> ack (2)
1478 * do nothing
1479 */
1480 struct process_lines {
1481 unsigned int image_height;
1482 unsigned short grid_height;
1483 unsigned short block_height;
1484 unsigned short y_start;
1485 unsigned char grid_height_per_slice;
1486
1487 unsigned short max_op; /* max operation */
1488 unsigned short max_tr; /* max transaction */
1489 unsigned char acc_enable;
1490 };
1491
1492 /* Helper to config intra_frame_operations_data. */
1493 static int
imgu_css_acc_process_lines(const struct process_lines * pl,struct imgu_abi_acc_operation * p_op,struct imgu_abi_acc_process_lines_cmd_data * p_pl,struct imgu_abi_acc_transfer_op_data * p_tr)1494 imgu_css_acc_process_lines(const struct process_lines *pl,
1495 struct imgu_abi_acc_operation *p_op,
1496 struct imgu_abi_acc_process_lines_cmd_data *p_pl,
1497 struct imgu_abi_acc_transfer_op_data *p_tr)
1498 {
1499 unsigned short op_idx = 0, pl_idx = 0, tr_idx = 0;
1500 unsigned char tr_set_num = 0, pl_cfg_set = 0;
1501 const unsigned short grid_last_line =
1502 pl->y_start + pl->grid_height * pl->block_height;
1503 const unsigned short process_lines =
1504 pl->grid_height_per_slice * pl->block_height;
1505
1506 unsigned int process_lines_after_grid;
1507 unsigned short first_process_lines;
1508 unsigned short last_process_lines_in_grid;
1509
1510 unsigned short num_of_process_lines;
1511 unsigned short num_of_sets;
1512
1513 if (pl->grid_height_per_slice == 0)
1514 return -EINVAL;
1515
1516 if (pl->acc_enable && grid_last_line > pl->image_height)
1517 return -EINVAL;
1518
1519 num_of_sets = pl->grid_height / pl->grid_height_per_slice;
1520 if (num_of_sets * pl->grid_height_per_slice < pl->grid_height)
1521 num_of_sets++;
1522
1523 /* Account for two line delay inside the FF */
1524 if (pl->max_op == IMGU_ABI_AF_MAX_OPERATIONS) {
1525 first_process_lines = process_lines + pl->y_start + 2;
1526 last_process_lines_in_grid =
1527 (grid_last_line - first_process_lines) -
1528 ((num_of_sets - 2) * process_lines) + 4;
1529 process_lines_after_grid =
1530 pl->image_height - grid_last_line - 4;
1531 } else {
1532 first_process_lines = process_lines + pl->y_start;
1533 last_process_lines_in_grid =
1534 (grid_last_line - first_process_lines) -
1535 ((num_of_sets - 2) * process_lines);
1536 process_lines_after_grid = pl->image_height - grid_last_line;
1537 }
1538
1539 num_of_process_lines = num_of_sets;
1540 if (process_lines_after_grid > 0)
1541 num_of_process_lines++;
1542
1543 while (tr_idx < num_of_sets || pl_idx < num_of_process_lines) {
1544 /* Read meta-data */
1545 if (pl_idx >= 2 || (pl_idx == 1 && num_of_sets == 1)) {
1546 if (op_idx >= pl->max_op || tr_idx >= pl->max_tr)
1547 return -EINVAL;
1548
1549 p_op[op_idx].op_type =
1550 IMGU_ABI_ACC_OPTYPE_TRANSFER_DATA;
1551
1552 if (tr_idx == num_of_sets - 1)
1553 /* The last operation is always a tr */
1554 p_op[op_idx].op_indicator =
1555 IMGU_ABI_ACC_OP_END_OF_OPS;
1556 else if (tr_idx == num_of_sets - 2)
1557 if (process_lines_after_grid == 0)
1558 /*
1559 * No additional pl op left -
1560 * this op is left as lats of cycle
1561 */
1562 p_op[op_idx].op_indicator =
1563 IMGU_ABI_ACC_OP_END_OF_ACK;
1564 else
1565 /*
1566 * We still have to process-lines after
1567 * the grid so have one more pl op
1568 */
1569 p_op[op_idx].op_indicator =
1570 IMGU_ABI_ACC_OP_IDLE;
1571 else
1572 /* Default - usually there's a pl after a tr */
1573 p_op[op_idx].op_indicator =
1574 IMGU_ABI_ACC_OP_IDLE;
1575
1576 op_idx++;
1577 if (p_tr) {
1578 p_tr[tr_idx].set_number = tr_set_num;
1579 tr_set_num = 1 - tr_set_num;
1580 }
1581 tr_idx++;
1582 }
1583
1584 /* process_lines */
1585 if (pl_idx < num_of_process_lines) {
1586 if (op_idx >= pl->max_op || pl_idx >= pl->max_tr)
1587 return -EINVAL;
1588
1589 p_op[op_idx].op_type =
1590 IMGU_ABI_ACC_OPTYPE_PROCESS_LINES;
1591 if (pl_idx == 0)
1592 if (num_of_process_lines == 1)
1593 /* Only one pl op */
1594 p_op[op_idx].op_indicator =
1595 IMGU_ABI_ACC_OP_END_OF_ACK;
1596 else
1597 /* On init - do two pl ops */
1598 p_op[op_idx].op_indicator =
1599 IMGU_ABI_ACC_OP_IDLE;
1600 else
1601 /* Usually pl is the end of the ack cycle */
1602 p_op[op_idx].op_indicator =
1603 IMGU_ABI_ACC_OP_END_OF_ACK;
1604
1605 op_idx++;
1606
1607 if (pl_idx == 0)
1608 /* First process line */
1609 p_pl[pl_idx].lines = first_process_lines;
1610 else if (pl_idx == num_of_sets - 1)
1611 /* Last in grid */
1612 p_pl[pl_idx].lines = last_process_lines_in_grid;
1613 else if (pl_idx == num_of_process_lines - 1)
1614 /* After the grid */
1615 p_pl[pl_idx].lines = process_lines_after_grid;
1616 else
1617 /* Inside the grid */
1618 p_pl[pl_idx].lines = process_lines;
1619
1620 if (p_tr) {
1621 p_pl[pl_idx].cfg_set = pl_cfg_set;
1622 pl_cfg_set = 1 - pl_cfg_set;
1623 }
1624 pl_idx++;
1625 }
1626 }
1627
1628 return 0;
1629 }
1630
imgu_css_af_ops_calc(struct imgu_css * css,unsigned int pipe,struct imgu_abi_af_config * af_config)1631 static int imgu_css_af_ops_calc(struct imgu_css *css, unsigned int pipe,
1632 struct imgu_abi_af_config *af_config)
1633 {
1634 struct imgu_abi_af_intra_frame_operations_data *to =
1635 &af_config->operations_data;
1636 struct imgu_css_pipe *css_pipe = &css->pipes[pipe];
1637 struct imgu_fw_info *bi =
1638 &css->fwp->binary_header[css_pipe->bindex];
1639
1640 struct process_lines pl = {
1641 .image_height = css_pipe->rect[IPU3_CSS_RECT_BDS].height,
1642 .grid_height = af_config->config.grid_cfg.height,
1643 .block_height =
1644 1 << af_config->config.grid_cfg.block_height_log2,
1645 .y_start = af_config->config.grid_cfg.y_start &
1646 IPU3_UAPI_GRID_START_MASK,
1647 .grid_height_per_slice =
1648 af_config->stripes[0].grid_cfg.height_per_slice,
1649 .max_op = IMGU_ABI_AF_MAX_OPERATIONS,
1650 .max_tr = IMGU_ABI_AF_MAX_TRANSFERS,
1651 .acc_enable = bi->info.isp.sp.enable.af,
1652 };
1653
1654 return imgu_css_acc_process_lines(&pl, to->ops, to->process_lines_data,
1655 NULL);
1656 }
1657
1658 static int
imgu_css_awb_fr_ops_calc(struct imgu_css * css,unsigned int pipe,struct imgu_abi_awb_fr_config * awb_fr_config)1659 imgu_css_awb_fr_ops_calc(struct imgu_css *css, unsigned int pipe,
1660 struct imgu_abi_awb_fr_config *awb_fr_config)
1661 {
1662 struct imgu_abi_awb_fr_intra_frame_operations_data *to =
1663 &awb_fr_config->operations_data;
1664 struct imgu_css_pipe *css_pipe = &css->pipes[pipe];
1665 struct imgu_fw_info *bi =
1666 &css->fwp->binary_header[css_pipe->bindex];
1667 struct process_lines pl = {
1668 .image_height = css_pipe->rect[IPU3_CSS_RECT_BDS].height,
1669 .grid_height = awb_fr_config->config.grid_cfg.height,
1670 .block_height =
1671 1 << awb_fr_config->config.grid_cfg.block_height_log2,
1672 .y_start = awb_fr_config->config.grid_cfg.y_start &
1673 IPU3_UAPI_GRID_START_MASK,
1674 .grid_height_per_slice =
1675 awb_fr_config->stripes[0].grid_cfg.height_per_slice,
1676 .max_op = IMGU_ABI_AWB_FR_MAX_OPERATIONS,
1677 .max_tr = IMGU_ABI_AWB_FR_MAX_PROCESS_LINES,
1678 .acc_enable = bi->info.isp.sp.enable.awb_fr_acc,
1679 };
1680
1681 return imgu_css_acc_process_lines(&pl, to->ops, to->process_lines_data,
1682 NULL);
1683 }
1684
imgu_css_awb_ops_calc(struct imgu_css * css,unsigned int pipe,struct imgu_abi_awb_config * awb_config)1685 static int imgu_css_awb_ops_calc(struct imgu_css *css, unsigned int pipe,
1686 struct imgu_abi_awb_config *awb_config)
1687 {
1688 struct imgu_abi_awb_intra_frame_operations_data *to =
1689 &awb_config->operations_data;
1690 struct imgu_css_pipe *css_pipe = &css->pipes[pipe];
1691 struct imgu_fw_info *bi =
1692 &css->fwp->binary_header[css_pipe->bindex];
1693
1694 struct process_lines pl = {
1695 .image_height = css_pipe->rect[IPU3_CSS_RECT_BDS].height,
1696 .grid_height = awb_config->config.grid.height,
1697 .block_height =
1698 1 << awb_config->config.grid.block_height_log2,
1699 .y_start = awb_config->config.grid.y_start,
1700 .grid_height_per_slice =
1701 awb_config->stripes[0].grid.height_per_slice,
1702 .max_op = IMGU_ABI_AWB_MAX_OPERATIONS,
1703 .max_tr = IMGU_ABI_AWB_MAX_TRANSFERS,
1704 .acc_enable = bi->info.isp.sp.enable.awb_acc,
1705 };
1706
1707 return imgu_css_acc_process_lines(&pl, to->ops, to->process_lines_data,
1708 to->transfer_data);
1709 }
1710
imgu_css_grid_end(u16 start,u8 width,u8 block_width_log2)1711 static u16 imgu_css_grid_end(u16 start, u8 width, u8 block_width_log2)
1712 {
1713 return (start & IPU3_UAPI_GRID_START_MASK) +
1714 (width << block_width_log2) - 1;
1715 }
1716
imgu_css_grid_end_calc(struct ipu3_uapi_grid_config * grid_cfg)1717 static void imgu_css_grid_end_calc(struct ipu3_uapi_grid_config *grid_cfg)
1718 {
1719 grid_cfg->x_end = imgu_css_grid_end(grid_cfg->x_start, grid_cfg->width,
1720 grid_cfg->block_width_log2);
1721 grid_cfg->y_end = imgu_css_grid_end(grid_cfg->y_start, grid_cfg->height,
1722 grid_cfg->block_height_log2);
1723 }
1724
1725 /****************** config computation *****************************/
1726
imgu_css_cfg_acc_stripe(struct imgu_css * css,unsigned int pipe,struct imgu_abi_acc_param * acc)1727 static int imgu_css_cfg_acc_stripe(struct imgu_css *css, unsigned int pipe,
1728 struct imgu_abi_acc_param *acc)
1729 {
1730 struct imgu_css_pipe *css_pipe = &css->pipes[pipe];
1731 const struct imgu_fw_info *bi =
1732 &css->fwp->binary_header[css_pipe->bindex];
1733 struct imgu_css_scaler_info scaler_luma, scaler_chroma;
1734 const unsigned int stripes = bi->info.isp.sp.iterator.num_stripes;
1735 const unsigned int f = IPU3_UAPI_ISP_VEC_ELEMS * 2;
1736 unsigned int bds_ds, i;
1737
1738 memset(acc, 0, sizeof(*acc));
1739
1740 /* acc_param: osys_config */
1741
1742 if (imgu_css_osys_calc(css, pipe, stripes, &acc->osys, &scaler_luma,
1743 &scaler_chroma, acc->stripe.block_stripes))
1744 return -EINVAL;
1745
1746 /* acc_param: stripe data */
1747
1748 /*
1749 * For the striped case the approach is as follows:
1750 * 1. down-scaled stripes are calculated - with 128 overlap
1751 * (this is the main limiter therefore it's first)
1752 * 2. input stripes are derived by up-scaling the down-scaled stripes
1753 * (there are no alignment requirements on input stripes)
1754 * 3. output stripes are derived from down-scaled stripes too
1755 */
1756
1757 acc->stripe.num_of_stripes = stripes;
1758 acc->stripe.input_frame.width =
1759 css_pipe->queue[IPU3_CSS_QUEUE_IN].fmt.mpix.width;
1760 acc->stripe.input_frame.height =
1761 css_pipe->queue[IPU3_CSS_QUEUE_IN].fmt.mpix.height;
1762 acc->stripe.input_frame.bayer_order =
1763 css_pipe->queue[IPU3_CSS_QUEUE_IN].css_fmt->bayer_order;
1764
1765 for (i = 0; i < stripes; i++)
1766 acc->stripe.bds_out_stripes[i].height =
1767 css_pipe->rect[IPU3_CSS_RECT_BDS].height;
1768 acc->stripe.bds_out_stripes[0].offset = 0;
1769 if (stripes <= 1) {
1770 acc->stripe.bds_out_stripes[0].width =
1771 ALIGN(css_pipe->rect[IPU3_CSS_RECT_BDS].width, f);
1772 } else {
1773 /* Image processing is divided into two stripes */
1774 acc->stripe.bds_out_stripes[0].width =
1775 acc->stripe.bds_out_stripes[1].width =
1776 (css_pipe->rect[IPU3_CSS_RECT_BDS].width / 2 & ~(f - 1)) + f;
1777 /*
1778 * Sum of width of the two stripes should not be smaller
1779 * than output width and must be even times of overlapping
1780 * unit f.
1781 */
1782 if ((css_pipe->rect[IPU3_CSS_RECT_BDS].width / f & 1) !=
1783 !!(css_pipe->rect[IPU3_CSS_RECT_BDS].width & (f - 1)))
1784 acc->stripe.bds_out_stripes[0].width += f;
1785 if ((css_pipe->rect[IPU3_CSS_RECT_BDS].width / f & 1) &&
1786 (css_pipe->rect[IPU3_CSS_RECT_BDS].width & (f - 1))) {
1787 acc->stripe.bds_out_stripes[0].width += f;
1788 acc->stripe.bds_out_stripes[1].width += f;
1789 }
1790 /* Overlap between stripes is IPU3_UAPI_ISP_VEC_ELEMS * 4 */
1791 acc->stripe.bds_out_stripes[1].offset =
1792 acc->stripe.bds_out_stripes[0].width - 2 * f;
1793 }
1794
1795 acc->stripe.effective_stripes[0].height =
1796 css_pipe->rect[IPU3_CSS_RECT_EFFECTIVE].height;
1797 acc->stripe.effective_stripes[0].offset = 0;
1798 acc->stripe.bds_out_stripes_no_overlap[0].height =
1799 css_pipe->rect[IPU3_CSS_RECT_BDS].height;
1800 acc->stripe.bds_out_stripes_no_overlap[0].offset = 0;
1801 acc->stripe.output_stripes[0].height =
1802 css_pipe->queue[IPU3_CSS_QUEUE_OUT].fmt.mpix.height;
1803 acc->stripe.output_stripes[0].offset = 0;
1804 if (stripes <= 1) {
1805 acc->stripe.down_scaled_stripes[0].width =
1806 css_pipe->rect[IPU3_CSS_RECT_BDS].width;
1807 acc->stripe.down_scaled_stripes[0].height =
1808 css_pipe->rect[IPU3_CSS_RECT_BDS].height;
1809 acc->stripe.down_scaled_stripes[0].offset = 0;
1810
1811 acc->stripe.effective_stripes[0].width =
1812 css_pipe->rect[IPU3_CSS_RECT_EFFECTIVE].width;
1813 acc->stripe.bds_out_stripes_no_overlap[0].width =
1814 ALIGN(css_pipe->rect[IPU3_CSS_RECT_BDS].width, f);
1815
1816 acc->stripe.output_stripes[0].width =
1817 css_pipe->queue[IPU3_CSS_QUEUE_OUT].fmt.mpix.width;
1818 } else { /* Two stripes */
1819 bds_ds = css_pipe->rect[IPU3_CSS_RECT_EFFECTIVE].width *
1820 IMGU_BDS_GRANULARITY /
1821 css_pipe->rect[IPU3_CSS_RECT_BDS].width;
1822
1823 acc->stripe.down_scaled_stripes[0] =
1824 acc->stripe.bds_out_stripes[0];
1825 acc->stripe.down_scaled_stripes[1] =
1826 acc->stripe.bds_out_stripes[1];
1827 if (!IS_ALIGNED(css_pipe->rect[IPU3_CSS_RECT_BDS].width, f))
1828 acc->stripe.down_scaled_stripes[1].width +=
1829 (css_pipe->rect[IPU3_CSS_RECT_BDS].width
1830 & (f - 1)) - f;
1831
1832 acc->stripe.effective_stripes[0].width = bds_ds *
1833 acc->stripe.down_scaled_stripes[0].width /
1834 IMGU_BDS_GRANULARITY;
1835 acc->stripe.effective_stripes[1].width = bds_ds *
1836 acc->stripe.down_scaled_stripes[1].width /
1837 IMGU_BDS_GRANULARITY;
1838 acc->stripe.effective_stripes[1].height =
1839 css_pipe->rect[IPU3_CSS_RECT_EFFECTIVE].height;
1840 acc->stripe.effective_stripes[1].offset = bds_ds *
1841 acc->stripe.down_scaled_stripes[1].offset /
1842 IMGU_BDS_GRANULARITY;
1843
1844 acc->stripe.bds_out_stripes_no_overlap[0].width =
1845 acc->stripe.bds_out_stripes_no_overlap[1].offset =
1846 ALIGN(css_pipe->rect[IPU3_CSS_RECT_BDS].width, 2 * f) / 2;
1847 acc->stripe.bds_out_stripes_no_overlap[1].width =
1848 DIV_ROUND_UP(css_pipe->rect[IPU3_CSS_RECT_BDS].width, f)
1849 / 2 * f;
1850 acc->stripe.bds_out_stripes_no_overlap[1].height =
1851 css_pipe->rect[IPU3_CSS_RECT_BDS].height;
1852
1853 acc->stripe.output_stripes[0].width =
1854 acc->stripe.down_scaled_stripes[0].width - f;
1855 acc->stripe.output_stripes[1].width =
1856 acc->stripe.down_scaled_stripes[1].width - f;
1857 acc->stripe.output_stripes[1].height =
1858 css_pipe->queue[IPU3_CSS_QUEUE_OUT].fmt.mpix.height;
1859 acc->stripe.output_stripes[1].offset =
1860 acc->stripe.output_stripes[0].width;
1861 }
1862
1863 acc->stripe.output_system_in_frame_width =
1864 css_pipe->rect[IPU3_CSS_RECT_GDC].width;
1865 acc->stripe.output_system_in_frame_height =
1866 css_pipe->rect[IPU3_CSS_RECT_GDC].height;
1867
1868 acc->stripe.effective_frame_width =
1869 css_pipe->rect[IPU3_CSS_RECT_EFFECTIVE].width;
1870 acc->stripe.bds_frame_width = css_pipe->rect[IPU3_CSS_RECT_BDS].width;
1871 acc->stripe.out_frame_width =
1872 css_pipe->queue[IPU3_CSS_QUEUE_OUT].fmt.mpix.width;
1873 acc->stripe.out_frame_height =
1874 css_pipe->queue[IPU3_CSS_QUEUE_OUT].fmt.mpix.height;
1875 acc->stripe.gdc_in_buffer_width =
1876 css_pipe->aux_frames[IPU3_CSS_AUX_FRAME_REF].bytesperline /
1877 css_pipe->aux_frames[IPU3_CSS_AUX_FRAME_REF].bytesperpixel;
1878 acc->stripe.gdc_in_buffer_height =
1879 css_pipe->aux_frames[IPU3_CSS_AUX_FRAME_REF].height;
1880 acc->stripe.gdc_in_buffer_offset_x = IMGU_GDC_BUF_X;
1881 acc->stripe.gdc_in_buffer_offset_y = IMGU_GDC_BUF_Y;
1882 acc->stripe.display_frame_width =
1883 css_pipe->queue[IPU3_CSS_QUEUE_VF].fmt.mpix.width;
1884 acc->stripe.display_frame_height =
1885 css_pipe->queue[IPU3_CSS_QUEUE_VF].fmt.mpix.height;
1886 acc->stripe.bds_aligned_frame_width =
1887 roundup(css_pipe->rect[IPU3_CSS_RECT_BDS].width,
1888 2 * IPU3_UAPI_ISP_VEC_ELEMS);
1889
1890 if (stripes > 1)
1891 acc->stripe.half_overlap_vectors =
1892 IMGU_STRIPE_FIXED_HALF_OVERLAP;
1893 else
1894 acc->stripe.half_overlap_vectors = 0;
1895
1896 return 0;
1897 }
1898
imgu_css_cfg_acc_dvs(struct imgu_css * css,struct imgu_abi_acc_param * acc,unsigned int pipe)1899 static void imgu_css_cfg_acc_dvs(struct imgu_css *css,
1900 struct imgu_abi_acc_param *acc,
1901 unsigned int pipe)
1902 {
1903 unsigned int i;
1904 struct imgu_css_pipe *css_pipe = &css->pipes[pipe];
1905
1906 /* Disable DVS statistics */
1907 acc->dvs_stat.operations_data.process_lines_data[0].lines =
1908 css_pipe->rect[IPU3_CSS_RECT_BDS].height;
1909 acc->dvs_stat.operations_data.process_lines_data[0].cfg_set = 0;
1910 acc->dvs_stat.operations_data.ops[0].op_type =
1911 IMGU_ABI_ACC_OPTYPE_PROCESS_LINES;
1912 acc->dvs_stat.operations_data.ops[0].op_indicator =
1913 IMGU_ABI_ACC_OP_NO_OPS;
1914 for (i = 0; i < IMGU_ABI_DVS_STAT_LEVELS; i++)
1915 acc->dvs_stat.cfg.grd_config[i].enable = 0;
1916 }
1917
acc_bds_per_stripe_data(struct imgu_css * css,struct imgu_abi_acc_param * acc,const int i,unsigned int pipe)1918 static void acc_bds_per_stripe_data(struct imgu_css *css,
1919 struct imgu_abi_acc_param *acc,
1920 const int i, unsigned int pipe)
1921 {
1922 struct imgu_css_pipe *css_pipe = &css->pipes[pipe];
1923
1924 acc->bds.per_stripe.aligned_data[i].data.crop.hor_crop_en = 0;
1925 acc->bds.per_stripe.aligned_data[i].data.crop.hor_crop_start = 0;
1926 acc->bds.per_stripe.aligned_data[i].data.crop.hor_crop_end = 0;
1927 acc->bds.per_stripe.aligned_data[i].data.hor_ctrl0 =
1928 acc->bds.hor.hor_ctrl0;
1929 acc->bds.per_stripe.aligned_data[i].data.hor_ctrl0.out_frame_width =
1930 acc->stripe.down_scaled_stripes[i].width;
1931 acc->bds.per_stripe.aligned_data[i].data.ver_ctrl1.out_frame_width =
1932 acc->stripe.down_scaled_stripes[i].width;
1933 acc->bds.per_stripe.aligned_data[i].data.ver_ctrl1.out_frame_height =
1934 css_pipe->rect[IPU3_CSS_RECT_BDS].height;
1935 }
1936
1937 /*
1938 * Configure `acc' parameters. `acc_old' contains the old values (or is NULL)
1939 * and `acc_user' contains new prospective values. `use' contains flags
1940 * telling which fields to take from the old values (or generate if it is NULL)
1941 * and which to take from the new user values.
1942 */
imgu_css_cfg_acc(struct imgu_css * css,unsigned int pipe,struct ipu3_uapi_flags * use,struct imgu_abi_acc_param * acc,struct imgu_abi_acc_param * acc_old,struct ipu3_uapi_acc_param * acc_user)1943 int imgu_css_cfg_acc(struct imgu_css *css, unsigned int pipe,
1944 struct ipu3_uapi_flags *use,
1945 struct imgu_abi_acc_param *acc,
1946 struct imgu_abi_acc_param *acc_old,
1947 struct ipu3_uapi_acc_param *acc_user)
1948 {
1949 struct imgu_css_pipe *css_pipe = &css->pipes[pipe];
1950 const struct imgu_fw_info *bi =
1951 &css->fwp->binary_header[css_pipe->bindex];
1952 const unsigned int stripes = bi->info.isp.sp.iterator.num_stripes;
1953 const unsigned int tnr_frame_width =
1954 acc->stripe.bds_aligned_frame_width;
1955 const unsigned int min_overlap = 10;
1956 const struct v4l2_pix_format_mplane *pixm =
1957 &css_pipe->queue[IPU3_CSS_QUEUE_IN].fmt.mpix;
1958 const struct imgu_css_bds_config *cfg_bds;
1959 struct imgu_abi_input_feeder_data *feeder_data;
1960
1961 unsigned int bds_ds, ofs_x, ofs_y, i, width, height;
1962 u8 b_w_log2; /* Block width log2 */
1963
1964 /* Update stripe using chroma and luma */
1965
1966 if (imgu_css_cfg_acc_stripe(css, pipe, acc))
1967 return -EINVAL;
1968
1969 /* acc_param: input_feeder_config */
1970
1971 ofs_x = ((pixm->width -
1972 css_pipe->rect[IPU3_CSS_RECT_EFFECTIVE].width) >> 1) & ~1;
1973 ofs_x += css_pipe->queue[IPU3_CSS_QUEUE_IN].css_fmt->bayer_order ==
1974 IMGU_ABI_BAYER_ORDER_RGGB ||
1975 css_pipe->queue[IPU3_CSS_QUEUE_IN].css_fmt->bayer_order ==
1976 IMGU_ABI_BAYER_ORDER_GBRG ? 1 : 0;
1977 ofs_y = ((pixm->height -
1978 css_pipe->rect[IPU3_CSS_RECT_EFFECTIVE].height) >> 1) & ~1;
1979 ofs_y += css_pipe->queue[IPU3_CSS_QUEUE_IN].css_fmt->bayer_order ==
1980 IMGU_ABI_BAYER_ORDER_BGGR ||
1981 css_pipe->queue[IPU3_CSS_QUEUE_IN].css_fmt->bayer_order ==
1982 IMGU_ABI_BAYER_ORDER_GBRG ? 1 : 0;
1983 acc->input_feeder.data.row_stride = pixm->plane_fmt[0].bytesperline;
1984 acc->input_feeder.data.start_row_address =
1985 ofs_x / IMGU_PIXELS_PER_WORD * IMGU_BYTES_PER_WORD +
1986 ofs_y * acc->input_feeder.data.row_stride;
1987 acc->input_feeder.data.start_pixel = ofs_x % IMGU_PIXELS_PER_WORD;
1988
1989 acc->input_feeder.data_per_stripe.input_feeder_data[0].data =
1990 acc->input_feeder.data;
1991
1992 ofs_x += acc->stripe.effective_stripes[1].offset;
1993
1994 feeder_data =
1995 &acc->input_feeder.data_per_stripe.input_feeder_data[1].data;
1996 feeder_data->row_stride = acc->input_feeder.data.row_stride;
1997 feeder_data->start_row_address =
1998 ofs_x / IMGU_PIXELS_PER_WORD * IMGU_BYTES_PER_WORD +
1999 ofs_y * acc->input_feeder.data.row_stride;
2000 feeder_data->start_pixel = ofs_x % IMGU_PIXELS_PER_WORD;
2001
2002 /* acc_param: bnr_static_config */
2003
2004 /*
2005 * Originate from user or be the original default values if user has
2006 * never set them before, when user gives a new set of parameters,
2007 * for each chunk in the parameter structure there is a flag use->xxx
2008 * whether to use the user-provided parameter or not. If not, the
2009 * parameter remains unchanged in the driver:
2010 * it's value is taken from acc_old.
2011 */
2012 if (use && use->acc_bnr) {
2013 /* Take values from user */
2014 acc->bnr = acc_user->bnr;
2015 } else if (acc_old) {
2016 /* Use old value */
2017 acc->bnr = acc_old->bnr;
2018 } else {
2019 /* Calculate from scratch */
2020 acc->bnr = imgu_css_bnr_defaults;
2021 }
2022
2023 acc->bnr.column_size = tnr_frame_width;
2024
2025 /* acc_param: bnr_static_config_green_disparity */
2026
2027 if (use && use->acc_green_disparity) {
2028 /* Take values from user */
2029 acc->green_disparity = acc_user->green_disparity;
2030 } else if (acc_old) {
2031 /* Use old value */
2032 acc->green_disparity = acc_old->green_disparity;
2033 } else {
2034 /* Calculate from scratch */
2035 memset(&acc->green_disparity, 0, sizeof(acc->green_disparity));
2036 }
2037
2038 /* acc_param: dm_config */
2039
2040 if (use && use->acc_dm) {
2041 /* Take values from user */
2042 acc->dm = acc_user->dm;
2043 } else if (acc_old) {
2044 /* Use old value */
2045 acc->dm = acc_old->dm;
2046 } else {
2047 /* Calculate from scratch */
2048 acc->dm = imgu_css_dm_defaults;
2049 }
2050
2051 acc->dm.frame_width = tnr_frame_width;
2052
2053 /* acc_param: ccm_mat_config */
2054
2055 if (use && use->acc_ccm) {
2056 /* Take values from user */
2057 acc->ccm = acc_user->ccm;
2058 } else if (acc_old) {
2059 /* Use old value */
2060 acc->ccm = acc_old->ccm;
2061 } else {
2062 /* Calculate from scratch */
2063 acc->ccm = imgu_css_ccm_defaults;
2064 }
2065
2066 /* acc_param: gamma_config */
2067
2068 if (use && use->acc_gamma) {
2069 /* Take values from user */
2070 acc->gamma = acc_user->gamma;
2071 } else if (acc_old) {
2072 /* Use old value */
2073 acc->gamma = acc_old->gamma;
2074 } else {
2075 /* Calculate from scratch */
2076 acc->gamma.gc_ctrl.enable = 1;
2077 acc->gamma.gc_lut = imgu_css_gamma_lut;
2078 }
2079
2080 /* acc_param: csc_mat_config */
2081
2082 if (use && use->acc_csc) {
2083 /* Take values from user */
2084 acc->csc = acc_user->csc;
2085 } else if (acc_old) {
2086 /* Use old value */
2087 acc->csc = acc_old->csc;
2088 } else {
2089 /* Calculate from scratch */
2090 acc->csc = imgu_css_csc_defaults;
2091 }
2092
2093 /* acc_param: cds_params */
2094
2095 if (use && use->acc_cds) {
2096 /* Take values from user */
2097 acc->cds = acc_user->cds;
2098 } else if (acc_old) {
2099 /* Use old value */
2100 acc->cds = acc_old->cds;
2101 } else {
2102 /* Calculate from scratch */
2103 acc->cds = imgu_css_cds_defaults;
2104 }
2105
2106 /* acc_param: shd_config */
2107
2108 if (use && use->acc_shd) {
2109 /* Take values from user */
2110 acc->shd.shd = acc_user->shd.shd;
2111 acc->shd.shd_lut = acc_user->shd.shd_lut;
2112 } else if (acc_old) {
2113 /* Use old value */
2114 acc->shd.shd = acc_old->shd.shd;
2115 acc->shd.shd_lut = acc_old->shd.shd_lut;
2116 } else {
2117 /* Calculate from scratch */
2118 acc->shd.shd = imgu_css_shd_defaults;
2119 memset(&acc->shd.shd_lut, 0, sizeof(acc->shd.shd_lut));
2120 }
2121
2122 if (acc->shd.shd.grid.width <= 0)
2123 return -EINVAL;
2124
2125 acc->shd.shd.grid.grid_height_per_slice =
2126 IMGU_ABI_SHD_MAX_CELLS_PER_SET / acc->shd.shd.grid.width;
2127
2128 if (acc->shd.shd.grid.grid_height_per_slice <= 0)
2129 return -EINVAL;
2130
2131 acc->shd.shd.general.init_set_vrt_offst_ul =
2132 (-acc->shd.shd.grid.y_start >>
2133 acc->shd.shd.grid.block_height_log2) %
2134 acc->shd.shd.grid.grid_height_per_slice;
2135
2136 if (imgu_css_shd_ops_calc(&acc->shd.shd_ops, &acc->shd.shd.grid,
2137 css_pipe->rect[IPU3_CSS_RECT_BDS].height))
2138 return -EINVAL;
2139
2140 /* acc_param: dvs_stat_config */
2141 imgu_css_cfg_acc_dvs(css, acc, pipe);
2142
2143 /* acc_param: yuvp1_iefd_config */
2144
2145 if (use && use->acc_iefd) {
2146 /* Take values from user */
2147 acc->iefd = acc_user->iefd;
2148 } else if (acc_old) {
2149 /* Use old value */
2150 acc->iefd = acc_old->iefd;
2151 } else {
2152 /* Calculate from scratch */
2153 acc->iefd = imgu_css_iefd_defaults;
2154 }
2155
2156 /* acc_param: yuvp1_yds_config yds_c0 */
2157
2158 if (use && use->acc_yds_c0) {
2159 /* Take values from user */
2160 acc->yds_c0 = acc_user->yds_c0;
2161 } else if (acc_old) {
2162 /* Use old value */
2163 acc->yds_c0 = acc_old->yds_c0;
2164 } else {
2165 /* Calculate from scratch */
2166 acc->yds_c0 = imgu_css_yds_defaults;
2167 }
2168
2169 /* acc_param: yuvp1_chnr_config chnr_c0 */
2170
2171 if (use && use->acc_chnr_c0) {
2172 /* Take values from user */
2173 acc->chnr_c0 = acc_user->chnr_c0;
2174 } else if (acc_old) {
2175 /* Use old value */
2176 acc->chnr_c0 = acc_old->chnr_c0;
2177 } else {
2178 /* Calculate from scratch */
2179 acc->chnr_c0 = imgu_css_chnr_defaults;
2180 }
2181
2182 /* acc_param: yuvp1_y_ee_nr_config */
2183
2184 if (use && use->acc_y_ee_nr) {
2185 /* Take values from user */
2186 acc->y_ee_nr = acc_user->y_ee_nr;
2187 } else if (acc_old) {
2188 /* Use old value */
2189 acc->y_ee_nr = acc_old->y_ee_nr;
2190 } else {
2191 /* Calculate from scratch */
2192 acc->y_ee_nr = imgu_css_y_ee_nr_defaults;
2193 }
2194
2195 /* acc_param: yuvp1_yds_config yds */
2196
2197 if (use && use->acc_yds) {
2198 /* Take values from user */
2199 acc->yds = acc_user->yds;
2200 } else if (acc_old) {
2201 /* Use old value */
2202 acc->yds = acc_old->yds;
2203 } else {
2204 /* Calculate from scratch */
2205 acc->yds = imgu_css_yds_defaults;
2206 }
2207
2208 /* acc_param: yuvp1_chnr_config chnr */
2209
2210 if (use && use->acc_chnr) {
2211 /* Take values from user */
2212 acc->chnr = acc_user->chnr;
2213 } else if (acc_old) {
2214 /* Use old value */
2215 acc->chnr = acc_old->chnr;
2216 } else {
2217 /* Calculate from scratch */
2218 acc->chnr = imgu_css_chnr_defaults;
2219 }
2220
2221 /* acc_param: yuvp2_y_tm_lut_static_config */
2222
2223 for (i = 0; i < IMGU_ABI_YUVP2_YTM_LUT_ENTRIES; i++)
2224 acc->ytm.entries[i] = i * 32;
2225 acc->ytm.enable = 0; /* Always disabled on IPU3 */
2226
2227 /* acc_param: yuvp1_yds_config yds2 */
2228
2229 if (use && use->acc_yds2) {
2230 /* Take values from user */
2231 acc->yds2 = acc_user->yds2;
2232 } else if (acc_old) {
2233 /* Use old value */
2234 acc->yds2 = acc_old->yds2;
2235 } else {
2236 /* Calculate from scratch */
2237 acc->yds2 = imgu_css_yds_defaults;
2238 }
2239
2240 /* acc_param: yuvp2_tcc_static_config */
2241
2242 if (use && use->acc_tcc) {
2243 /* Take values from user */
2244 acc->tcc = acc_user->tcc;
2245 } else if (acc_old) {
2246 /* Use old value */
2247 acc->tcc = acc_old->tcc;
2248 } else {
2249 /* Calculate from scratch */
2250 memset(&acc->tcc, 0, sizeof(acc->tcc));
2251
2252 acc->tcc.gen_control.en = 1;
2253 acc->tcc.gen_control.blend_shift = 3;
2254 acc->tcc.gen_control.gain_according_to_y_only = 1;
2255 acc->tcc.gen_control.gamma = 8;
2256 acc->tcc.gen_control.delta = 0;
2257
2258 for (i = 0; i < IPU3_UAPI_YUVP2_TCC_MACC_TABLE_ELEMENTS; i++) {
2259 acc->tcc.macc_table.entries[i].a = 1024;
2260 acc->tcc.macc_table.entries[i].b = 0;
2261 acc->tcc.macc_table.entries[i].c = 0;
2262 acc->tcc.macc_table.entries[i].d = 1024;
2263 }
2264
2265 acc->tcc.inv_y_lut.entries[6] = 1023;
2266 for (i = 7; i < IPU3_UAPI_YUVP2_TCC_INV_Y_LUT_ELEMENTS; i++)
2267 acc->tcc.inv_y_lut.entries[i] = 1024 >> (i - 6);
2268
2269 acc->tcc.gain_pcwl = imgu_css_tcc_gain_pcwl_lut;
2270 acc->tcc.r_sqr_lut = imgu_css_tcc_r_sqr_lut;
2271 }
2272
2273 /* acc_param: dpc_config */
2274
2275 if (use && use->acc_dpc)
2276 return -EINVAL; /* Not supported yet */
2277
2278 /* Just disable by default */
2279 memset(&acc->dpc, 0, sizeof(acc->dpc));
2280
2281 /* acc_param: bds_config */
2282
2283 bds_ds = (css_pipe->rect[IPU3_CSS_RECT_EFFECTIVE].height *
2284 IMGU_BDS_GRANULARITY) / css_pipe->rect[IPU3_CSS_RECT_BDS].height;
2285 if (bds_ds < IMGU_BDS_MIN_SF_INV ||
2286 bds_ds - IMGU_BDS_MIN_SF_INV >= ARRAY_SIZE(imgu_css_bds_configs))
2287 return -EINVAL;
2288
2289 cfg_bds = &imgu_css_bds_configs[bds_ds - IMGU_BDS_MIN_SF_INV];
2290 acc->bds.hor.hor_ctrl1.hor_crop_en = 0;
2291 acc->bds.hor.hor_ctrl1.hor_crop_start = 0;
2292 acc->bds.hor.hor_ctrl1.hor_crop_end = 0;
2293 acc->bds.hor.hor_ctrl0.sample_patrn_length =
2294 cfg_bds->sample_patrn_length;
2295 acc->bds.hor.hor_ctrl0.hor_ds_en = cfg_bds->hor_ds_en;
2296 acc->bds.hor.hor_ctrl0.min_clip_val = IMGU_BDS_MIN_CLIP_VAL;
2297 acc->bds.hor.hor_ctrl0.max_clip_val = IMGU_BDS_MAX_CLIP_VAL;
2298 acc->bds.hor.hor_ctrl0.out_frame_width =
2299 css_pipe->rect[IPU3_CSS_RECT_BDS].width;
2300 acc->bds.hor.hor_ptrn_arr = cfg_bds->ptrn_arr;
2301 acc->bds.hor.hor_phase_arr = cfg_bds->hor_phase_arr;
2302 acc->bds.hor.hor_ctrl2.input_frame_height =
2303 css_pipe->rect[IPU3_CSS_RECT_EFFECTIVE].height;
2304 acc->bds.ver.ver_ctrl0.min_clip_val = IMGU_BDS_MIN_CLIP_VAL;
2305 acc->bds.ver.ver_ctrl0.max_clip_val = IMGU_BDS_MAX_CLIP_VAL;
2306 acc->bds.ver.ver_ctrl0.sample_patrn_length =
2307 cfg_bds->sample_patrn_length;
2308 acc->bds.ver.ver_ctrl0.ver_ds_en = cfg_bds->ver_ds_en;
2309 acc->bds.ver.ver_ptrn_arr = cfg_bds->ptrn_arr;
2310 acc->bds.ver.ver_phase_arr = cfg_bds->ver_phase_arr;
2311 acc->bds.ver.ver_ctrl1.out_frame_width =
2312 css_pipe->rect[IPU3_CSS_RECT_BDS].width;
2313 acc->bds.ver.ver_ctrl1.out_frame_height =
2314 css_pipe->rect[IPU3_CSS_RECT_BDS].height;
2315 for (i = 0; i < stripes; i++)
2316 acc_bds_per_stripe_data(css, acc, i, pipe);
2317
2318 acc->bds.enabled = cfg_bds->hor_ds_en || cfg_bds->ver_ds_en;
2319
2320 /* acc_param: anr_config */
2321
2322 if (use && use->acc_anr) {
2323 /* Take values from user */
2324 acc->anr.transform = acc_user->anr.transform;
2325 acc->anr.stitch.anr_stitch_en =
2326 acc_user->anr.stitch.anr_stitch_en;
2327 memcpy(acc->anr.stitch.pyramid, acc_user->anr.stitch.pyramid,
2328 sizeof(acc->anr.stitch.pyramid));
2329 } else if (acc_old) {
2330 /* Use old value */
2331 acc->anr.transform = acc_old->anr.transform;
2332 acc->anr.stitch.anr_stitch_en =
2333 acc_old->anr.stitch.anr_stitch_en;
2334 memcpy(acc->anr.stitch.pyramid, acc_old->anr.stitch.pyramid,
2335 sizeof(acc->anr.stitch.pyramid));
2336 } else {
2337 /* Calculate from scratch */
2338 acc->anr = imgu_css_anr_defaults;
2339 }
2340
2341 /* Always enabled */
2342 acc->anr.search.enable = 1;
2343 acc->anr.transform.enable = 1;
2344 acc->anr.tile2strm.enable = 1;
2345 acc->anr.tile2strm.frame_width =
2346 ALIGN(css_pipe->rect[IPU3_CSS_RECT_BDS].width, IMGU_ISP_VMEM_ALIGN);
2347 acc->anr.search.frame_width = acc->anr.tile2strm.frame_width;
2348 acc->anr.stitch.frame_width = acc->anr.tile2strm.frame_width;
2349 acc->anr.tile2strm.frame_height = css_pipe->rect[IPU3_CSS_RECT_BDS].height;
2350 acc->anr.search.frame_height = acc->anr.tile2strm.frame_height;
2351 acc->anr.stitch.frame_height = acc->anr.tile2strm.frame_height;
2352
2353 width = ALIGN(css_pipe->rect[IPU3_CSS_RECT_BDS].width, IMGU_ISP_VMEM_ALIGN);
2354 height = css_pipe->rect[IPU3_CSS_RECT_BDS].height;
2355
2356 if (acc->anr.transform.xreset + width > IPU3_UAPI_ANR_MAX_RESET)
2357 acc->anr.transform.xreset = IPU3_UAPI_ANR_MAX_RESET - width;
2358 if (acc->anr.transform.xreset < IPU3_UAPI_ANR_MIN_RESET)
2359 acc->anr.transform.xreset = IPU3_UAPI_ANR_MIN_RESET;
2360
2361 if (acc->anr.transform.yreset + height > IPU3_UAPI_ANR_MAX_RESET)
2362 acc->anr.transform.yreset = IPU3_UAPI_ANR_MAX_RESET - height;
2363 if (acc->anr.transform.yreset < IPU3_UAPI_ANR_MIN_RESET)
2364 acc->anr.transform.yreset = IPU3_UAPI_ANR_MIN_RESET;
2365
2366 /* acc_param: awb_fr_config */
2367
2368 if (use && use->acc_awb_fr) {
2369 /* Take values from user */
2370 acc->awb_fr.config = acc_user->awb_fr;
2371 } else if (acc_old) {
2372 /* Use old value */
2373 acc->awb_fr.config = acc_old->awb_fr.config;
2374 } else {
2375 /* Set from scratch */
2376 acc->awb_fr.config = imgu_css_awb_fr_defaults;
2377 }
2378
2379 imgu_css_grid_end_calc(&acc->awb_fr.config.grid_cfg);
2380
2381 if (acc->awb_fr.config.grid_cfg.width <= 0)
2382 return -EINVAL;
2383
2384 acc->awb_fr.config.grid_cfg.height_per_slice =
2385 IMGU_ABI_AWB_FR_MAX_CELLS_PER_SET /
2386 acc->awb_fr.config.grid_cfg.width;
2387
2388 for (i = 0; i < stripes; i++)
2389 acc->awb_fr.stripes[i] = acc->awb_fr.config;
2390
2391 if (acc->awb_fr.config.grid_cfg.x_start >=
2392 acc->stripe.down_scaled_stripes[1].offset + min_overlap) {
2393 /* Enable only for rightmost stripe, disable left */
2394 acc->awb_fr.stripes[0].grid_cfg.y_start &=
2395 ~IPU3_UAPI_GRID_Y_START_EN;
2396 } else if (acc->awb_fr.config.grid_cfg.x_end <=
2397 acc->stripe.bds_out_stripes[0].width - min_overlap) {
2398 /* Enable only for leftmost stripe, disable right */
2399 acc->awb_fr.stripes[1].grid_cfg.y_start &=
2400 ~IPU3_UAPI_GRID_Y_START_EN;
2401 } else {
2402 /* Enable for both stripes */
2403 u16 end; /* width for grid end */
2404
2405 acc->awb_fr.stripes[0].grid_cfg.width =
2406 (acc->stripe.bds_out_stripes[0].width - min_overlap -
2407 acc->awb_fr.config.grid_cfg.x_start + 1) >>
2408 acc->awb_fr.config.grid_cfg.block_width_log2;
2409 acc->awb_fr.stripes[1].grid_cfg.width =
2410 acc->awb_fr.config.grid_cfg.width -
2411 acc->awb_fr.stripes[0].grid_cfg.width;
2412
2413 b_w_log2 = acc->awb_fr.stripes[0].grid_cfg.block_width_log2;
2414 end = imgu_css_grid_end(acc->awb_fr.stripes[0].grid_cfg.x_start,
2415 acc->awb_fr.stripes[0].grid_cfg.width,
2416 b_w_log2);
2417 acc->awb_fr.stripes[0].grid_cfg.x_end = end;
2418
2419 acc->awb_fr.stripes[1].grid_cfg.x_start =
2420 (acc->awb_fr.stripes[0].grid_cfg.x_end + 1 -
2421 acc->stripe.down_scaled_stripes[1].offset) &
2422 IPU3_UAPI_GRID_START_MASK;
2423 b_w_log2 = acc->awb_fr.stripes[1].grid_cfg.block_width_log2;
2424 end = imgu_css_grid_end(acc->awb_fr.stripes[1].grid_cfg.x_start,
2425 acc->awb_fr.stripes[1].grid_cfg.width,
2426 b_w_log2);
2427 acc->awb_fr.stripes[1].grid_cfg.x_end = end;
2428
2429 /*
2430 * To reduce complexity of debubbling and loading
2431 * statistics fix grid_height_per_slice to 1 for both
2432 * stripes.
2433 */
2434 for (i = 0; i < stripes; i++)
2435 acc->awb_fr.stripes[i].grid_cfg.height_per_slice = 1;
2436 }
2437
2438 if (imgu_css_awb_fr_ops_calc(css, pipe, &acc->awb_fr))
2439 return -EINVAL;
2440
2441 /* acc_param: ae_config */
2442
2443 if (use && use->acc_ae) {
2444 /* Take values from user */
2445 acc->ae.grid_cfg = acc_user->ae.grid_cfg;
2446 acc->ae.ae_ccm = acc_user->ae.ae_ccm;
2447 for (i = 0; i < IPU3_UAPI_AE_WEIGHTS; i++)
2448 acc->ae.weights[i] = acc_user->ae.weights[i];
2449 } else if (acc_old) {
2450 /* Use old value */
2451 acc->ae.grid_cfg = acc_old->ae.grid_cfg;
2452 acc->ae.ae_ccm = acc_old->ae.ae_ccm;
2453 for (i = 0; i < IPU3_UAPI_AE_WEIGHTS; i++)
2454 acc->ae.weights[i] = acc_old->ae.weights[i];
2455 } else {
2456 /* Set from scratch */
2457 static const struct ipu3_uapi_ae_weight_elem
2458 weight_def = { 1, 1, 1, 1, 1, 1, 1, 1 };
2459
2460 acc->ae.grid_cfg = imgu_css_ae_grid_defaults;
2461 acc->ae.ae_ccm = imgu_css_ae_ccm_defaults;
2462 for (i = 0; i < IPU3_UAPI_AE_WEIGHTS; i++)
2463 acc->ae.weights[i] = weight_def;
2464 }
2465
2466 b_w_log2 = acc->ae.grid_cfg.block_width_log2;
2467 acc->ae.grid_cfg.x_end = imgu_css_grid_end(acc->ae.grid_cfg.x_start,
2468 acc->ae.grid_cfg.width,
2469 b_w_log2);
2470 b_w_log2 = acc->ae.grid_cfg.block_height_log2;
2471 acc->ae.grid_cfg.y_end = imgu_css_grid_end(acc->ae.grid_cfg.y_start,
2472 acc->ae.grid_cfg.height,
2473 b_w_log2);
2474
2475 for (i = 0; i < stripes; i++)
2476 acc->ae.stripes[i].grid = acc->ae.grid_cfg;
2477
2478 if (acc->ae.grid_cfg.x_start >=
2479 acc->stripe.down_scaled_stripes[1].offset) {
2480 /* Enable only for rightmost stripe, disable left */
2481 acc->ae.stripes[0].grid.ae_en = 0;
2482 } else if (acc->ae.grid_cfg.x_end <=
2483 acc->stripe.bds_out_stripes[0].width) {
2484 /* Enable only for leftmost stripe, disable right */
2485 acc->ae.stripes[1].grid.ae_en = 0;
2486 } else {
2487 /* Enable for both stripes */
2488 u8 b_w_log2;
2489
2490 acc->ae.stripes[0].grid.width =
2491 (acc->stripe.bds_out_stripes[0].width -
2492 acc->ae.grid_cfg.x_start + 1) >>
2493 acc->ae.grid_cfg.block_width_log2;
2494
2495 acc->ae.stripes[1].grid.width =
2496 acc->ae.grid_cfg.width - acc->ae.stripes[0].grid.width;
2497
2498 b_w_log2 = acc->ae.stripes[0].grid.block_width_log2;
2499 acc->ae.stripes[0].grid.x_end =
2500 imgu_css_grid_end(acc->ae.stripes[0].grid.x_start,
2501 acc->ae.stripes[0].grid.width,
2502 b_w_log2);
2503
2504 acc->ae.stripes[1].grid.x_start =
2505 (acc->ae.stripes[0].grid.x_end + 1 -
2506 acc->stripe.down_scaled_stripes[1].offset) &
2507 IPU3_UAPI_GRID_START_MASK;
2508 b_w_log2 = acc->ae.stripes[1].grid.block_width_log2;
2509 acc->ae.stripes[1].grid.x_end =
2510 imgu_css_grid_end(acc->ae.stripes[1].grid.x_start,
2511 acc->ae.stripes[1].grid.width,
2512 b_w_log2);
2513 }
2514
2515 /* acc_param: af_config */
2516
2517 if (use && use->acc_af) {
2518 /* Take values from user */
2519 acc->af.config.filter_config = acc_user->af.filter_config;
2520 acc->af.config.grid_cfg = acc_user->af.grid_cfg;
2521 } else if (acc_old) {
2522 /* Use old value */
2523 acc->af.config = acc_old->af.config;
2524 } else {
2525 /* Set from scratch */
2526 acc->af.config.filter_config =
2527 imgu_css_af_defaults.filter_config;
2528 acc->af.config.grid_cfg = imgu_css_af_defaults.grid_cfg;
2529 }
2530
2531 imgu_css_grid_end_calc(&acc->af.config.grid_cfg);
2532
2533 if (acc->af.config.grid_cfg.width <= 0)
2534 return -EINVAL;
2535
2536 acc->af.config.grid_cfg.height_per_slice =
2537 IMGU_ABI_AF_MAX_CELLS_PER_SET / acc->af.config.grid_cfg.width;
2538 acc->af.config.frame_size.width =
2539 ALIGN(css_pipe->rect[IPU3_CSS_RECT_BDS].width, IMGU_ISP_VMEM_ALIGN);
2540 acc->af.config.frame_size.height =
2541 css_pipe->rect[IPU3_CSS_RECT_BDS].height;
2542
2543 if (acc->stripe.bds_out_stripes[0].width <= min_overlap)
2544 return -EINVAL;
2545
2546 for (i = 0; i < stripes; i++) {
2547 acc->af.stripes[i].grid_cfg = acc->af.config.grid_cfg;
2548 acc->af.stripes[i].frame_size.height =
2549 css_pipe->rect[IPU3_CSS_RECT_BDS].height;
2550 acc->af.stripes[i].frame_size.width =
2551 acc->stripe.bds_out_stripes[i].width;
2552 }
2553
2554 if (acc->af.config.grid_cfg.x_start >=
2555 acc->stripe.down_scaled_stripes[1].offset + min_overlap) {
2556 /* Enable only for rightmost stripe, disable left */
2557 acc->af.stripes[0].grid_cfg.y_start &=
2558 ~IPU3_UAPI_GRID_Y_START_EN;
2559 acc->af.stripes[1].grid_cfg.x_start =
2560 (acc->af.stripes[1].grid_cfg.x_start -
2561 acc->stripe.down_scaled_stripes[1].offset) &
2562 IPU3_UAPI_GRID_START_MASK;
2563 b_w_log2 = acc->af.stripes[1].grid_cfg.block_width_log2;
2564 acc->af.stripes[1].grid_cfg.x_end =
2565 imgu_css_grid_end(acc->af.stripes[1].grid_cfg.x_start,
2566 acc->af.stripes[1].grid_cfg.width,
2567 b_w_log2);
2568 } else if (acc->af.config.grid_cfg.x_end <=
2569 acc->stripe.bds_out_stripes[0].width - min_overlap) {
2570 /* Enable only for leftmost stripe, disable right */
2571 acc->af.stripes[1].grid_cfg.y_start &=
2572 ~IPU3_UAPI_GRID_Y_START_EN;
2573 } else {
2574 /* Enable for both stripes */
2575
2576 acc->af.stripes[0].grid_cfg.width =
2577 (acc->stripe.bds_out_stripes[0].width - min_overlap -
2578 acc->af.config.grid_cfg.x_start + 1) >>
2579 acc->af.config.grid_cfg.block_width_log2;
2580 acc->af.stripes[1].grid_cfg.width =
2581 acc->af.config.grid_cfg.width -
2582 acc->af.stripes[0].grid_cfg.width;
2583
2584 b_w_log2 = acc->af.stripes[0].grid_cfg.block_width_log2;
2585 acc->af.stripes[0].grid_cfg.x_end =
2586 imgu_css_grid_end(acc->af.stripes[0].grid_cfg.x_start,
2587 acc->af.stripes[0].grid_cfg.width,
2588 b_w_log2);
2589
2590 acc->af.stripes[1].grid_cfg.x_start =
2591 (acc->af.stripes[0].grid_cfg.x_end + 1 -
2592 acc->stripe.down_scaled_stripes[1].offset) &
2593 IPU3_UAPI_GRID_START_MASK;
2594
2595 b_w_log2 = acc->af.stripes[1].grid_cfg.block_width_log2;
2596 acc->af.stripes[1].grid_cfg.x_end =
2597 imgu_css_grid_end(acc->af.stripes[1].grid_cfg.x_start,
2598 acc->af.stripes[1].grid_cfg.width,
2599 b_w_log2);
2600
2601 /*
2602 * To reduce complexity of debubbling and loading statistics
2603 * fix grid_height_per_slice to 1 for both stripes
2604 */
2605 for (i = 0; i < stripes; i++)
2606 acc->af.stripes[i].grid_cfg.height_per_slice = 1;
2607 }
2608
2609 if (imgu_css_af_ops_calc(css, pipe, &acc->af))
2610 return -EINVAL;
2611
2612 /* acc_param: awb_config */
2613
2614 if (use && use->acc_awb) {
2615 /* Take values from user */
2616 acc->awb.config = acc_user->awb.config;
2617 } else if (acc_old) {
2618 /* Use old value */
2619 acc->awb.config = acc_old->awb.config;
2620 } else {
2621 /* Set from scratch */
2622 acc->awb.config = imgu_css_awb_defaults;
2623 }
2624
2625 if (acc->awb.config.grid.width <= 0)
2626 return -EINVAL;
2627
2628 acc->awb.config.grid.height_per_slice =
2629 IMGU_ABI_AWB_MAX_CELLS_PER_SET / acc->awb.config.grid.width,
2630 imgu_css_grid_end_calc(&acc->awb.config.grid);
2631
2632 for (i = 0; i < stripes; i++)
2633 acc->awb.stripes[i] = acc->awb.config;
2634
2635 if (acc->awb.config.grid.x_start >=
2636 acc->stripe.down_scaled_stripes[1].offset + min_overlap) {
2637 /* Enable only for rightmost stripe, disable left */
2638 acc->awb.stripes[0].rgbs_thr_b &= ~IPU3_UAPI_AWB_RGBS_THR_B_EN;
2639
2640 acc->awb.stripes[1].grid.x_start =
2641 (acc->awb.stripes[1].grid.x_start -
2642 acc->stripe.down_scaled_stripes[1].offset) &
2643 IPU3_UAPI_GRID_START_MASK;
2644
2645 b_w_log2 = acc->awb.stripes[1].grid.block_width_log2;
2646 acc->awb.stripes[1].grid.x_end =
2647 imgu_css_grid_end(acc->awb.stripes[1].grid.x_start,
2648 acc->awb.stripes[1].grid.width,
2649 b_w_log2);
2650 } else if (acc->awb.config.grid.x_end <=
2651 acc->stripe.bds_out_stripes[0].width - min_overlap) {
2652 /* Enable only for leftmost stripe, disable right */
2653 acc->awb.stripes[1].rgbs_thr_b &= ~IPU3_UAPI_AWB_RGBS_THR_B_EN;
2654 } else {
2655 /* Enable for both stripes */
2656
2657 acc->awb.stripes[0].grid.width =
2658 (acc->stripe.bds_out_stripes[0].width -
2659 acc->awb.config.grid.x_start + 1) >>
2660 acc->awb.config.grid.block_width_log2;
2661 acc->awb.stripes[1].grid.width = acc->awb.config.grid.width -
2662 acc->awb.stripes[0].grid.width;
2663
2664 b_w_log2 = acc->awb.stripes[0].grid.block_width_log2;
2665 acc->awb.stripes[0].grid.x_end =
2666 imgu_css_grid_end(acc->awb.stripes[0].grid.x_start,
2667 acc->awb.stripes[0].grid.width,
2668 b_w_log2);
2669
2670 acc->awb.stripes[1].grid.x_start =
2671 (acc->awb.stripes[0].grid.x_end + 1 -
2672 acc->stripe.down_scaled_stripes[1].offset) &
2673 IPU3_UAPI_GRID_START_MASK;
2674
2675 b_w_log2 = acc->awb.stripes[1].grid.block_width_log2;
2676 acc->awb.stripes[1].grid.x_end =
2677 imgu_css_grid_end(acc->awb.stripes[1].grid.x_start,
2678 acc->awb.stripes[1].grid.width,
2679 b_w_log2);
2680
2681 /*
2682 * To reduce complexity of debubbling and loading statistics
2683 * fix grid_height_per_slice to 1 for both stripes
2684 */
2685 for (i = 0; i < stripes; i++)
2686 acc->awb.stripes[i].grid.height_per_slice = 1;
2687 }
2688
2689 if (imgu_css_awb_ops_calc(css, pipe, &acc->awb))
2690 return -EINVAL;
2691
2692 return 0;
2693 }
2694
2695 /*
2696 * Fill the indicated structure in `new_binary_params' from the possible
2697 * sources based on `use_user' flag: if the flag is false, copy from
2698 * `old_binary_params', or if the flag is true, copy from `user_setting'
2699 * and return NULL (or error pointer on error).
2700 * If the flag is false and `old_binary_params' is NULL, return pointer
2701 * to the structure inside `new_binary_params'. In that case the caller
2702 * should calculate and fill the structure from scratch.
2703 */
imgu_css_cfg_copy(struct imgu_css * css,unsigned int pipe,bool use_user,void * user_setting,void * old_binary_params,void * new_binary_params,enum imgu_abi_memories m,struct imgu_fw_isp_parameter * par,size_t par_size)2704 static void *imgu_css_cfg_copy(struct imgu_css *css,
2705 unsigned int pipe, bool use_user,
2706 void *user_setting, void *old_binary_params,
2707 void *new_binary_params,
2708 enum imgu_abi_memories m,
2709 struct imgu_fw_isp_parameter *par,
2710 size_t par_size)
2711 {
2712 const enum imgu_abi_param_class c = IMGU_ABI_PARAM_CLASS_PARAM;
2713 void *new_setting, *old_setting;
2714
2715 new_setting = imgu_css_fw_pipeline_params(css, pipe, c, m, par,
2716 par_size, new_binary_params);
2717 if (!new_setting)
2718 return ERR_PTR(-EPROTO); /* Corrupted firmware */
2719
2720 if (use_user) {
2721 /* Take new user parameters */
2722 memcpy(new_setting, user_setting, par_size);
2723 } else if (old_binary_params) {
2724 /* Take previous value */
2725 old_setting = imgu_css_fw_pipeline_params(css, pipe, c, m, par,
2726 par_size,
2727 old_binary_params);
2728 if (!old_setting)
2729 return ERR_PTR(-EPROTO);
2730 memcpy(new_setting, old_setting, par_size);
2731 } else {
2732 return new_setting; /* Need to calculate */
2733 }
2734
2735 return NULL; /* Copied from other value */
2736 }
2737
2738 /*
2739 * Configure VMEM0 parameters (late binding parameters).
2740 */
imgu_css_cfg_vmem0(struct imgu_css * css,unsigned int pipe,struct ipu3_uapi_flags * use,void * vmem0,void * vmem0_old,struct ipu3_uapi_params * user)2741 int imgu_css_cfg_vmem0(struct imgu_css *css, unsigned int pipe,
2742 struct ipu3_uapi_flags *use,
2743 void *vmem0, void *vmem0_old,
2744 struct ipu3_uapi_params *user)
2745 {
2746 const struct imgu_fw_info *bi =
2747 &css->fwp->binary_header[css->pipes[pipe].bindex];
2748 struct imgu_fw_param_memory_offsets *pofs = (void *)css->fwp +
2749 bi->blob.memory_offsets.offsets[IMGU_ABI_PARAM_CLASS_PARAM];
2750 struct ipu3_uapi_isp_lin_vmem_params *lin_vmem = NULL;
2751 struct ipu3_uapi_isp_tnr3_vmem_params *tnr_vmem = NULL;
2752 struct ipu3_uapi_isp_xnr3_vmem_params *xnr_vmem = NULL;
2753 const enum imgu_abi_param_class c = IMGU_ABI_PARAM_CLASS_PARAM;
2754 const enum imgu_abi_memories m = IMGU_ABI_MEM_ISP_VMEM0;
2755 unsigned int i;
2756
2757 /* Configure VMEM0 */
2758
2759 memset(vmem0, 0, bi->info.isp.sp.mem_initializers.params[c][m].size);
2760
2761 /* Configure Linearization VMEM0 parameters */
2762
2763 lin_vmem = imgu_css_cfg_copy(css, pipe, use && use->lin_vmem_params,
2764 &user->lin_vmem_params, vmem0_old, vmem0,
2765 m, &pofs->vmem.lin, sizeof(*lin_vmem));
2766 if (!IS_ERR_OR_NULL(lin_vmem)) {
2767 /* Generate parameter from scratch */
2768 for (i = 0; i < IPU3_UAPI_LIN_LUT_SIZE; i++) {
2769 lin_vmem->lin_lutlow_gr[i] = 32 * i;
2770 lin_vmem->lin_lutlow_r[i] = 32 * i;
2771 lin_vmem->lin_lutlow_b[i] = 32 * i;
2772 lin_vmem->lin_lutlow_gb[i] = 32 * i;
2773
2774 lin_vmem->lin_lutdif_gr[i] = 32;
2775 lin_vmem->lin_lutdif_r[i] = 32;
2776 lin_vmem->lin_lutdif_b[i] = 32;
2777 lin_vmem->lin_lutdif_gb[i] = 32;
2778 }
2779 }
2780
2781 /* Configure TNR3 VMEM parameters */
2782 if (css->pipes[pipe].pipe_id == IPU3_CSS_PIPE_ID_VIDEO) {
2783 tnr_vmem = imgu_css_cfg_copy(css, pipe,
2784 use && use->tnr3_vmem_params,
2785 &user->tnr3_vmem_params,
2786 vmem0_old, vmem0, m,
2787 &pofs->vmem.tnr3,
2788 sizeof(*tnr_vmem));
2789 if (!IS_ERR_OR_NULL(tnr_vmem)) {
2790 /* Generate parameter from scratch */
2791 for (i = 0; i < IPU3_UAPI_ISP_TNR3_VMEM_LEN; i++)
2792 tnr_vmem->sigma[i] = 256;
2793 }
2794 }
2795 i = IPU3_UAPI_ISP_TNR3_VMEM_LEN;
2796
2797 /* Configure XNR3 VMEM parameters */
2798
2799 xnr_vmem = imgu_css_cfg_copy(css, pipe, use && use->xnr3_vmem_params,
2800 &user->xnr3_vmem_params, vmem0_old, vmem0,
2801 m, &pofs->vmem.xnr3, sizeof(*xnr_vmem));
2802 if (!IS_ERR_OR_NULL(xnr_vmem)) {
2803 xnr_vmem->x[i] = imgu_css_xnr3_vmem_defaults.x
2804 [i % IMGU_XNR3_VMEM_LUT_LEN];
2805 xnr_vmem->a[i] = imgu_css_xnr3_vmem_defaults.a
2806 [i % IMGU_XNR3_VMEM_LUT_LEN];
2807 xnr_vmem->b[i] = imgu_css_xnr3_vmem_defaults.b
2808 [i % IMGU_XNR3_VMEM_LUT_LEN];
2809 xnr_vmem->c[i] = imgu_css_xnr3_vmem_defaults.c
2810 [i % IMGU_XNR3_VMEM_LUT_LEN];
2811 }
2812
2813 return IS_ERR(lin_vmem) || IS_ERR(tnr_vmem) || IS_ERR(xnr_vmem) ?
2814 -EPROTO : 0;
2815 }
2816
2817 /*
2818 * Configure DMEM0 parameters (late binding parameters).
2819 */
imgu_css_cfg_dmem0(struct imgu_css * css,unsigned int pipe,struct ipu3_uapi_flags * use,void * dmem0,void * dmem0_old,struct ipu3_uapi_params * user)2820 int imgu_css_cfg_dmem0(struct imgu_css *css, unsigned int pipe,
2821 struct ipu3_uapi_flags *use,
2822 void *dmem0, void *dmem0_old,
2823 struct ipu3_uapi_params *user)
2824 {
2825 struct imgu_css_pipe *css_pipe = &css->pipes[pipe];
2826 const struct imgu_fw_info *bi =
2827 &css->fwp->binary_header[css_pipe->bindex];
2828 struct imgu_fw_param_memory_offsets *pofs = (void *)css->fwp +
2829 bi->blob.memory_offsets.offsets[IMGU_ABI_PARAM_CLASS_PARAM];
2830
2831 struct ipu3_uapi_isp_tnr3_params *tnr_dmem = NULL;
2832 struct ipu3_uapi_isp_xnr3_params *xnr_dmem;
2833
2834 const enum imgu_abi_param_class c = IMGU_ABI_PARAM_CLASS_PARAM;
2835 const enum imgu_abi_memories m = IMGU_ABI_MEM_ISP_DMEM0;
2836
2837 /* Configure DMEM0 */
2838
2839 memset(dmem0, 0, bi->info.isp.sp.mem_initializers.params[c][m].size);
2840
2841 /* Configure TNR3 DMEM0 parameters */
2842 if (css_pipe->pipe_id == IPU3_CSS_PIPE_ID_VIDEO) {
2843 tnr_dmem = imgu_css_cfg_copy(css, pipe,
2844 use && use->tnr3_dmem_params,
2845 &user->tnr3_dmem_params,
2846 dmem0_old, dmem0, m,
2847 &pofs->dmem.tnr3,
2848 sizeof(*tnr_dmem));
2849 if (!IS_ERR_OR_NULL(tnr_dmem)) {
2850 /* Generate parameter from scratch */
2851 tnr_dmem->knee_y1 = 768;
2852 tnr_dmem->knee_y2 = 1280;
2853 }
2854 }
2855
2856 /* Configure XNR3 DMEM0 parameters */
2857
2858 xnr_dmem = imgu_css_cfg_copy(css, pipe, use && use->xnr3_dmem_params,
2859 &user->xnr3_dmem_params, dmem0_old, dmem0,
2860 m, &pofs->dmem.xnr3, sizeof(*xnr_dmem));
2861 if (!IS_ERR_OR_NULL(xnr_dmem)) {
2862 /* Generate parameter from scratch */
2863 xnr_dmem->alpha.y0 = 2047;
2864 xnr_dmem->alpha.u0 = 2047;
2865 xnr_dmem->alpha.v0 = 2047;
2866 }
2867
2868 return IS_ERR(tnr_dmem) || IS_ERR(xnr_dmem) ? -EPROTO : 0;
2869 }
2870
2871 /* Generate unity morphing table without morphing effect */
imgu_css_cfg_gdc_table(struct imgu_abi_gdc_warp_param * gdc,int frame_in_x,int frame_in_y,int frame_out_x,int frame_out_y,int env_w,int env_h)2872 void imgu_css_cfg_gdc_table(struct imgu_abi_gdc_warp_param *gdc,
2873 int frame_in_x, int frame_in_y,
2874 int frame_out_x, int frame_out_y,
2875 int env_w, int env_h)
2876 {
2877 static const unsigned int FRAC_BITS = IMGU_ABI_GDC_FRAC_BITS;
2878 static const unsigned int XMEM_ALIGN = 1 << 4;
2879 const unsigned int XMEM_ALIGN_MASK = ~(XMEM_ALIGN - 1);
2880 static const unsigned int BCI_ENV = 4;
2881 static const unsigned int BYP = 2; /* Bytes per pixel */
2882 const unsigned int OFFSET_X = 2 * IMGU_DVS_BLOCK_W + env_w + 1;
2883 const unsigned int OFFSET_Y = IMGU_DVS_BLOCK_H + env_h + 1;
2884
2885 struct imgu_abi_gdc_warp_param gdc_luma, gdc_chroma;
2886
2887 unsigned int blocks_x = ALIGN(DIV_ROUND_UP(frame_out_x,
2888 IMGU_DVS_BLOCK_W), 2);
2889 unsigned int blocks_y = DIV_ROUND_UP(frame_out_y, IMGU_DVS_BLOCK_H);
2890 unsigned int y0, x0, x1, x, y;
2891
2892 /* Global luma settings */
2893 gdc_luma.origin_x = 0;
2894 gdc_luma.origin_y = 0;
2895 gdc_luma.p0_x = (OFFSET_X - (OFFSET_X & XMEM_ALIGN_MASK)) << FRAC_BITS;
2896 gdc_luma.p0_y = 0;
2897 gdc_luma.p1_x = gdc_luma.p0_x + (IMGU_DVS_BLOCK_W << FRAC_BITS);
2898 gdc_luma.p1_y = gdc_luma.p0_y;
2899 gdc_luma.p2_x = gdc_luma.p0_x;
2900 gdc_luma.p2_y = gdc_luma.p0_y + (IMGU_DVS_BLOCK_H << FRAC_BITS);
2901 gdc_luma.p3_x = gdc_luma.p1_x;
2902 gdc_luma.p3_y = gdc_luma.p2_y;
2903
2904 gdc_luma.in_block_width = IMGU_DVS_BLOCK_W + BCI_ENV +
2905 OFFSET_X - (OFFSET_X & XMEM_ALIGN_MASK);
2906 gdc_luma.in_block_width_a = DIV_ROUND_UP(gdc_luma.in_block_width,
2907 IPU3_UAPI_ISP_VEC_ELEMS);
2908 gdc_luma.in_block_width_b = DIV_ROUND_UP(gdc_luma.in_block_width,
2909 IMGU_ABI_ISP_DDR_WORD_BYTES /
2910 BYP);
2911 gdc_luma.in_block_height = IMGU_DVS_BLOCK_H + BCI_ENV;
2912 gdc_luma.padding = 0;
2913
2914 /* Global chroma settings */
2915 gdc_chroma.origin_x = 0;
2916 gdc_chroma.origin_y = 0;
2917 gdc_chroma.p0_x = (OFFSET_X / 2 - (OFFSET_X / 2 & XMEM_ALIGN_MASK)) <<
2918 FRAC_BITS;
2919 gdc_chroma.p0_y = 0;
2920 gdc_chroma.p1_x = gdc_chroma.p0_x + (IMGU_DVS_BLOCK_W << FRAC_BITS);
2921 gdc_chroma.p1_y = gdc_chroma.p0_y;
2922 gdc_chroma.p2_x = gdc_chroma.p0_x;
2923 gdc_chroma.p2_y = gdc_chroma.p0_y + (IMGU_DVS_BLOCK_H / 2 << FRAC_BITS);
2924 gdc_chroma.p3_x = gdc_chroma.p1_x;
2925 gdc_chroma.p3_y = gdc_chroma.p2_y;
2926
2927 gdc_chroma.in_block_width = IMGU_DVS_BLOCK_W + BCI_ENV;
2928 gdc_chroma.in_block_width_a = DIV_ROUND_UP(gdc_chroma.in_block_width,
2929 IPU3_UAPI_ISP_VEC_ELEMS);
2930 gdc_chroma.in_block_width_b = DIV_ROUND_UP(gdc_chroma.in_block_width,
2931 IMGU_ABI_ISP_DDR_WORD_BYTES /
2932 BYP);
2933 gdc_chroma.in_block_height = IMGU_DVS_BLOCK_H / 2 + BCI_ENV;
2934 gdc_chroma.padding = 0;
2935
2936 /* Calculate block offsets for luma and chroma */
2937 for (y0 = 0; y0 < blocks_y; y0++) {
2938 for (x0 = 0; x0 < blocks_x / 2; x0++) {
2939 for (x1 = 0; x1 < 2; x1++) {
2940 /* Luma blocks */
2941 x = (x0 * 2 + x1) * IMGU_DVS_BLOCK_W + OFFSET_X;
2942 x &= XMEM_ALIGN_MASK;
2943 y = y0 * IMGU_DVS_BLOCK_H + OFFSET_Y;
2944 *gdc = gdc_luma;
2945 gdc->in_addr_offset =
2946 (y * frame_in_x + x) * BYP;
2947 gdc++;
2948 }
2949
2950 /* Chroma block */
2951 x = x0 * IMGU_DVS_BLOCK_W + OFFSET_X / 2;
2952 x &= XMEM_ALIGN_MASK;
2953 y = y0 * (IMGU_DVS_BLOCK_H / 2) + OFFSET_Y / 2;
2954 *gdc = gdc_chroma;
2955 gdc->in_addr_offset = (y * frame_in_x + x) * BYP;
2956 gdc++;
2957 }
2958 }
2959 }
2960