1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Support for Intel Camera Imaging ISP subsystem.
4 * Copyright (c) 2015, Intel Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13 * more details.
14 */
15
16#include <linux/kernel.h>
17#include <linux/math.h>
18
19#include "ia_css_pipe_binarydesc.h"
20#include "ia_css_frame_format.h"
21#include "ia_css_pipe.h"
22#include "ia_css_pipe_util.h"
23#include "ia_css_util.h"
24#include "ia_css_debug.h"
25#include "sh_css_params.h"
26#include <assert_support.h>
27/* HRT_GDC_N */
28#include "gdc_device.h"
29
30/* This module provides a binary descriptions to used to find a binary. Since,
31 * every stage is associated with a binary, it implicity helps stage
32 * description. Apart from providing a binary description, this module also
33 * populates the frame info's when required.*/
34
35/* Generic descriptor for offline binaries. Internal function. */
36static void pipe_binarydesc_get_offline(
37    struct ia_css_pipe const *const pipe,
38    const int mode,
39    struct ia_css_binary_descr *descr,
40    struct ia_css_frame_info *in_info,
41    struct ia_css_frame_info *out_info[],
42    struct ia_css_frame_info *vf_info)
43{
44	unsigned int i;
45	/* in_info, out_info, vf_info can be NULL */
46	assert(pipe);
47	assert(descr);
48	ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
49			    "pipe_binarydesc_get_offline() enter:\n");
50
51	descr->mode = mode;
52	descr->online = false;
53	descr->continuous = pipe->stream->config.continuous;
54	descr->striped = false;
55	descr->two_ppc = false;
56	descr->enable_yuv_ds = false;
57	descr->enable_high_speed = false;
58	descr->enable_dvs_6axis = false;
59	descr->enable_reduced_pipe = false;
60	descr->enable_dz = true;
61	descr->enable_xnr = false;
62	descr->enable_dpc = false;
63	descr->enable_tnr = false;
64	descr->enable_capture_pp_bli = false;
65	descr->enable_fractional_ds = false;
66	descr->dvs_env.width = 0;
67	descr->dvs_env.height = 0;
68	descr->stream_format = pipe->stream->config.input_config.format;
69	descr->in_info = in_info;
70	descr->bds_out_info = NULL;
71	for (i = 0; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
72		descr->out_info[i] = out_info[i];
73	descr->vf_info = vf_info;
74	descr->isp_pipe_version = pipe->config.isp_pipe_version;
75	descr->required_bds_factor = SH_CSS_BDS_FACTOR_1_00;
76	descr->stream_config_left_padding = -1;
77}
78
79void ia_css_pipe_get_copy_binarydesc(
80    struct ia_css_pipe const *const pipe,
81    struct ia_css_binary_descr *copy_descr,
82    struct ia_css_frame_info *in_info,
83    struct ia_css_frame_info *out_info,
84    struct ia_css_frame_info *vf_info)
85{
86	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
87	unsigned int i;
88	/* out_info can be NULL */
89	assert(pipe);
90	assert(in_info);
91	IA_CSS_ENTER_PRIVATE("");
92
93	*in_info = *out_info;
94	out_infos[0] = out_info;
95	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
96		out_infos[i] = NULL;
97	pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_COPY,
98				    copy_descr, in_info, out_infos, vf_info);
99	copy_descr->online = true;
100	copy_descr->continuous = false;
101	copy_descr->two_ppc = (pipe->stream->config.pixels_per_clock == 2);
102	copy_descr->enable_dz = false;
103	copy_descr->isp_pipe_version = IA_CSS_PIPE_VERSION_1;
104	IA_CSS_LEAVE_PRIVATE("");
105}
106
107void ia_css_pipe_get_vfpp_binarydesc(
108    struct ia_css_pipe const *const pipe,
109    struct ia_css_binary_descr *vf_pp_descr,
110    struct ia_css_frame_info *in_info,
111    struct ia_css_frame_info *out_info)
112{
113	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
114	unsigned int i;
115	/* out_info can be NULL ??? */
116	assert(pipe);
117	assert(in_info);
118	IA_CSS_ENTER_PRIVATE("");
119
120	in_info->raw_bit_depth = 0;
121	out_infos[0] = out_info;
122	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
123		out_infos[i] = NULL;
124
125	pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_VF_PP,
126				    vf_pp_descr, in_info, out_infos, NULL);
127	vf_pp_descr->enable_fractional_ds = true;
128	IA_CSS_LEAVE_PRIVATE("");
129}
130
131static struct u32_fract bds_factors_list[] = {
132	[SH_CSS_BDS_FACTOR_1_00] = {1, 1},
133	[SH_CSS_BDS_FACTOR_1_25] = {5, 4},
134	[SH_CSS_BDS_FACTOR_1_50] = {3, 2},
135	[SH_CSS_BDS_FACTOR_2_00] = {2, 1},
136	[SH_CSS_BDS_FACTOR_2_25] = {9, 4},
137	[SH_CSS_BDS_FACTOR_2_50] = {5, 2},
138	[SH_CSS_BDS_FACTOR_3_00] = {3, 1},
139	[SH_CSS_BDS_FACTOR_4_00] = {4, 1},
140	[SH_CSS_BDS_FACTOR_4_50] = {9, 2},
141	[SH_CSS_BDS_FACTOR_5_00] = {5, 1},
142	[SH_CSS_BDS_FACTOR_6_00] = {6, 1},
143	[SH_CSS_BDS_FACTOR_8_00] = {8, 1},
144};
145
146int sh_css_bds_factor_get_fract(unsigned int bds_factor, struct u32_fract *bds)
147{
148	/* Throw an error since bds_factor cannot be found in bds_factors_list */
149	if (bds_factor >= ARRAY_SIZE(bds_factors_list))
150		return -EINVAL;
151
152	*bds = bds_factors_list[bds_factor];
153	return 0;
154}
155
156int binarydesc_calculate_bds_factor(
157    struct ia_css_resolution input_res,
158    struct ia_css_resolution output_res,
159    unsigned int *bds_factor)
160{
161	unsigned int i;
162	unsigned int in_w = input_res.width,
163		     in_h = input_res.height,
164		     out_w = output_res.width, out_h = output_res.height;
165
166	unsigned int max_bds_factor = 8;
167	unsigned int max_rounding_margin = 2;
168	/* delta in pixels to account for rounding margin in the calculation */
169	unsigned int delta = max_bds_factor * max_rounding_margin;
170
171	/* Assert if the resolutions are not set */
172	assert(in_w != 0 && in_h != 0);
173	assert(out_w != 0 && out_h != 0);
174
175	/* Loop over all bds factors until a match is found */
176	for (i = 0; i < ARRAY_SIZE(bds_factors_list); i++) {
177		unsigned int num = bds_factors_list[i].numerator;
178		unsigned int den = bds_factors_list[i].denominator;
179
180		/* See width-wise and height-wise if this bds_factor
181		 * satisfies the condition */
182		bool cond = (out_w * num / den + delta > in_w) &&
183			    (out_w * num / den <= in_w) &&
184			    (out_h * num / den + delta > in_h) &&
185			    (out_h * num / den <= in_h);
186
187		if (cond) {
188			*bds_factor = i;
189			return 0;
190		}
191	}
192
193	/* Throw an error since a suitable bds_factor cannot be found */
194	return -EINVAL;
195}
196
197int ia_css_pipe_get_preview_binarydesc(
198    struct ia_css_pipe *const pipe,
199    struct ia_css_binary_descr *preview_descr,
200    struct ia_css_frame_info *in_info,
201    struct ia_css_frame_info *bds_out_info,
202    struct ia_css_frame_info *out_info,
203    struct ia_css_frame_info *vf_info)
204{
205	int err;
206	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
207	int mode = IA_CSS_BINARY_MODE_PREVIEW;
208	unsigned int i;
209
210	assert(pipe);
211	assert(in_info);
212	assert(out_info);
213	assert(vf_info);
214	IA_CSS_ENTER_PRIVATE("");
215
216	/*
217	 * Set up the info of the input frame with
218	 * the ISP required resolution
219	 */
220	in_info->res = pipe->config.input_effective_res;
221	in_info->padded_width = in_info->res.width;
222	in_info->raw_bit_depth = ia_css_pipe_util_pipe_input_format_bpp(pipe);
223
224	if (ia_css_util_is_input_format_yuv(pipe->stream->config.input_config.format))
225		mode = IA_CSS_BINARY_MODE_COPY;
226	else
227		in_info->format = IA_CSS_FRAME_FORMAT_RAW;
228
229	out_infos[0] = out_info;
230	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
231		out_infos[i] = NULL;
232
233	pipe_binarydesc_get_offline(pipe, mode,
234				    preview_descr, in_info, out_infos, vf_info);
235	if (pipe->stream->config.online) {
236		preview_descr->online = pipe->stream->config.online;
237		preview_descr->two_ppc =
238		    (pipe->stream->config.pixels_per_clock == 2);
239	}
240	preview_descr->stream_format = pipe->stream->config.input_config.format;
241
242	/* TODO: Remove this when bds_out_info is available! */
243	*bds_out_info = *in_info;
244
245	if (pipe->extra_config.enable_raw_binning) {
246		if (pipe->config.bayer_ds_out_res.width != 0 &&
247		    pipe->config.bayer_ds_out_res.height != 0) {
248			bds_out_info->res.width =
249			    pipe->config.bayer_ds_out_res.width;
250			bds_out_info->res.height =
251			    pipe->config.bayer_ds_out_res.height;
252			bds_out_info->padded_width =
253			    pipe->config.bayer_ds_out_res.width;
254			err =
255			    binarydesc_calculate_bds_factor(in_info->res,
256							    bds_out_info->res,
257							    &preview_descr->required_bds_factor);
258			if (err)
259				return err;
260		} else {
261			bds_out_info->res.width = in_info->res.width / 2;
262			bds_out_info->res.height = in_info->res.height / 2;
263			bds_out_info->padded_width = in_info->padded_width / 2;
264			preview_descr->required_bds_factor =
265			    SH_CSS_BDS_FACTOR_2_00;
266		}
267	} else {
268		/* TODO: Remove this when bds_out_info->is available! */
269		bds_out_info->res.width = in_info->res.width;
270		bds_out_info->res.height = in_info->res.height;
271		bds_out_info->padded_width = in_info->padded_width;
272		preview_descr->required_bds_factor = SH_CSS_BDS_FACTOR_1_00;
273	}
274	pipe->required_bds_factor = preview_descr->required_bds_factor;
275
276	/* bayer ds and fractional ds cannot be enabled at the same time,
277	so we disable bds_out_info when fractional ds is used */
278	if (!pipe->extra_config.enable_fractional_ds)
279		preview_descr->bds_out_info = bds_out_info;
280	else
281		preview_descr->bds_out_info = NULL;
282	/*
283	   ----Preview binary-----
284	   --in-->|--out->|vf_veceven|--|--->vf
285	   -----------------------
286	   * Preview binary normally doesn't have a vf_port but
287	   * instead it has an output port. However, the output is
288	   * generated by vf_veceven module in which we might have
289	   * a downscaling (by 1x, 2x, or 4x). Because the resolution
290	   * might change, we need two different info, namely out_info
291	   * & vf_info. In fill_binary_info we use out&vf info to
292	   * calculate vf decimation factor.
293	 */
294	*out_info = *vf_info;
295
296	/* In case of preview_ds binary, we can do any fractional amount
297	 * of downscale, so there is no DS needed in vf_veceven. Therefore,
298	 * out and vf infos will be the same. Otherwise, we set out resolution
299	 * equal to in resolution. */
300	if (!pipe->extra_config.enable_fractional_ds) {
301		/* TODO: Change this when bds_out_info is available! */
302		out_info->res.width = bds_out_info->res.width;
303		out_info->res.height = bds_out_info->res.height;
304		out_info->padded_width = bds_out_info->padded_width;
305	}
306	preview_descr->enable_fractional_ds =
307	    pipe->extra_config.enable_fractional_ds;
308
309	preview_descr->enable_dpc = pipe->config.enable_dpc;
310
311	preview_descr->isp_pipe_version = pipe->config.isp_pipe_version;
312	IA_CSS_LEAVE_ERR_PRIVATE(0);
313	return 0;
314}
315
316int ia_css_pipe_get_video_binarydesc(
317    struct ia_css_pipe *const pipe,
318    struct ia_css_binary_descr *video_descr,
319    struct ia_css_frame_info *in_info,
320    struct ia_css_frame_info *bds_out_info,
321    struct ia_css_frame_info *out_info,
322    struct ia_css_frame_info *vf_info,
323    int stream_config_left_padding)
324{
325	int mode = IA_CSS_BINARY_MODE_VIDEO;
326	unsigned int i;
327	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
328	int err = 0;
329	bool stream_dz_config = false;
330
331	/* vf_info can be NULL */
332	assert(pipe);
333	assert(in_info);
334	/* assert(vf_info != NULL); */
335	IA_CSS_ENTER_PRIVATE("");
336
337	/* The solution below is not optimal; we should move to using ia_css_pipe_get_copy_binarydesc()
338	 * But for now this fixes things; this code used to be there but was removed
339	 * with gerrit 8908 as this was wrong for Skycam; however 240x still needs this
340	 */
341	if (ia_css_util_is_input_format_yuv(pipe->stream->config.input_config.format))
342		mode = IA_CSS_BINARY_MODE_COPY;
343
344	in_info->res = pipe->config.input_effective_res;
345	in_info->padded_width = in_info->res.width;
346	in_info->format = IA_CSS_FRAME_FORMAT_RAW;
347	in_info->raw_bit_depth = ia_css_pipe_util_pipe_input_format_bpp(pipe);
348	out_infos[0] = out_info;
349	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
350		out_infos[i] = NULL;
351
352	pipe_binarydesc_get_offline(pipe, mode,
353				    video_descr, in_info, out_infos, vf_info);
354
355	if (pipe->stream->config.online) {
356		video_descr->online = pipe->stream->config.online;
357		video_descr->two_ppc =
358		    (pipe->stream->config.pixels_per_clock == 2);
359	}
360
361	if (mode == IA_CSS_BINARY_MODE_VIDEO) {
362		stream_dz_config =
363		    ((pipe->stream->isp_params_configs->dz_config.dx !=
364		      HRT_GDC_N)
365		     || (pipe->stream->isp_params_configs->dz_config.dy !=
366			 HRT_GDC_N));
367
368		video_descr->enable_dz = pipe->config.enable_dz
369					 || stream_dz_config;
370		video_descr->dvs_env = pipe->config.dvs_envelope;
371		video_descr->enable_yuv_ds = pipe->extra_config.enable_yuv_ds;
372		video_descr->enable_high_speed =
373		    pipe->extra_config.enable_high_speed;
374		video_descr->enable_dvs_6axis =
375		    pipe->extra_config.enable_dvs_6axis;
376		video_descr->enable_reduced_pipe =
377		    pipe->extra_config.enable_reduced_pipe;
378		video_descr->isp_pipe_version = pipe->config.isp_pipe_version;
379		video_descr->enable_fractional_ds =
380		    pipe->extra_config.enable_fractional_ds;
381		video_descr->enable_dpc =
382		    pipe->config.enable_dpc;
383		video_descr->enable_tnr =
384		    pipe->config.enable_tnr;
385
386		if (pipe->extra_config.enable_raw_binning) {
387			if (pipe->config.bayer_ds_out_res.width != 0 &&
388			    pipe->config.bayer_ds_out_res.height != 0) {
389				bds_out_info->res.width =
390				    pipe->config.bayer_ds_out_res.width;
391				bds_out_info->res.height =
392				    pipe->config.bayer_ds_out_res.height;
393				bds_out_info->padded_width =
394				    pipe->config.bayer_ds_out_res.width;
395				err =
396				    binarydesc_calculate_bds_factor(
397					in_info->res, bds_out_info->res,
398					&video_descr->required_bds_factor);
399				if (err)
400					return err;
401			} else {
402				bds_out_info->res.width =
403				    in_info->res.width / 2;
404				bds_out_info->res.height =
405				    in_info->res.height / 2;
406				bds_out_info->padded_width =
407				    in_info->padded_width / 2;
408				video_descr->required_bds_factor =
409				    SH_CSS_BDS_FACTOR_2_00;
410			}
411		} else {
412			bds_out_info->res.width = in_info->res.width;
413			bds_out_info->res.height = in_info->res.height;
414			bds_out_info->padded_width = in_info->padded_width;
415			video_descr->required_bds_factor =
416			    SH_CSS_BDS_FACTOR_1_00;
417		}
418
419		pipe->required_bds_factor = video_descr->required_bds_factor;
420
421		/* bayer ds and fractional ds cannot be enabled
422		at the same time, so we disable bds_out_info when
423		fractional ds is used */
424		if (!pipe->extra_config.enable_fractional_ds)
425			video_descr->bds_out_info = bds_out_info;
426		else
427			video_descr->bds_out_info = NULL;
428
429		video_descr->enable_fractional_ds =
430		    pipe->extra_config.enable_fractional_ds;
431		video_descr->stream_config_left_padding = stream_config_left_padding;
432	}
433	IA_CSS_LEAVE_ERR_PRIVATE(err);
434	return err;
435}
436
437void ia_css_pipe_get_yuvscaler_binarydesc(
438    struct ia_css_pipe const *const pipe,
439    struct ia_css_binary_descr *yuv_scaler_descr,
440    struct ia_css_frame_info *in_info,
441    struct ia_css_frame_info *out_info,
442    struct ia_css_frame_info *internal_out_info,
443    struct ia_css_frame_info *vf_info)
444{
445	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
446	struct ia_css_frame_info *this_vf_info = NULL;
447
448	assert(pipe);
449	assert(in_info);
450	/* Note: if the following assert fails, the number of ports has been
451	 * changed; in that case an additional initializer must be added
452	 * a few lines below after which this assert can be updated.
453	 */
454	assert(IA_CSS_BINARY_MAX_OUTPUT_PORTS == 2);
455	IA_CSS_ENTER_PRIVATE("");
456
457	in_info->padded_width = in_info->res.width;
458	in_info->raw_bit_depth = 0;
459	ia_css_frame_info_set_width(in_info, in_info->res.width, 0);
460	out_infos[0] = out_info;
461	out_infos[1] = internal_out_info;
462	/* add initializers here if
463	 * assert(IA_CSS_BINARY_MAX_OUTPUT_PORTS == ...);
464	 * fails
465	 */
466
467	if (vf_info) {
468		this_vf_info = (vf_info->res.width == 0 &&
469				vf_info->res.height == 0) ? NULL : vf_info;
470	}
471
472	pipe_binarydesc_get_offline(pipe,
473				    IA_CSS_BINARY_MODE_CAPTURE_PP,
474				    yuv_scaler_descr,
475				    in_info, out_infos, this_vf_info);
476
477	yuv_scaler_descr->enable_fractional_ds = true;
478	IA_CSS_LEAVE_PRIVATE("");
479}
480
481void ia_css_pipe_get_capturepp_binarydesc(
482    struct ia_css_pipe *const pipe,
483    struct ia_css_binary_descr *capture_pp_descr,
484    struct ia_css_frame_info *in_info,
485    struct ia_css_frame_info *out_info,
486    struct ia_css_frame_info *vf_info)
487{
488	unsigned int i;
489	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
490
491	assert(pipe);
492	assert(in_info);
493	assert(vf_info);
494	IA_CSS_ENTER_PRIVATE("");
495
496	/* the in_info is only used for resolution to enable
497	   bayer down scaling. */
498	if (pipe->out_yuv_ds_input_info.res.width)
499		*in_info = pipe->out_yuv_ds_input_info;
500	else
501		*in_info = *out_info;
502	in_info->format = IA_CSS_FRAME_FORMAT_YUV420;
503	in_info->raw_bit_depth = 0;
504	ia_css_frame_info_set_width(in_info, in_info->res.width, 0);
505
506	out_infos[0] = out_info;
507	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
508		out_infos[i] = NULL;
509
510	pipe_binarydesc_get_offline(pipe,
511				    IA_CSS_BINARY_MODE_CAPTURE_PP,
512				    capture_pp_descr,
513				    in_info, out_infos, vf_info);
514
515	capture_pp_descr->enable_capture_pp_bli =
516	    pipe->config.default_capture_config.enable_capture_pp_bli;
517	capture_pp_descr->enable_fractional_ds = true;
518	capture_pp_descr->enable_xnr =
519	    pipe->config.default_capture_config.enable_xnr != 0;
520	IA_CSS_LEAVE_PRIVATE("");
521}
522
523/* lookup table for high quality primary binaries */
524static unsigned int primary_hq_binary_modes[NUM_PRIMARY_HQ_STAGES] = {
525	IA_CSS_BINARY_MODE_PRIMARY_HQ_STAGE0,
526	IA_CSS_BINARY_MODE_PRIMARY_HQ_STAGE1,
527	IA_CSS_BINARY_MODE_PRIMARY_HQ_STAGE2,
528	IA_CSS_BINARY_MODE_PRIMARY_HQ_STAGE3,
529	IA_CSS_BINARY_MODE_PRIMARY_HQ_STAGE4,
530	IA_CSS_BINARY_MODE_PRIMARY_HQ_STAGE5
531};
532
533void ia_css_pipe_get_primary_binarydesc(
534    struct ia_css_pipe const *const pipe,
535    struct ia_css_binary_descr *prim_descr,
536    struct ia_css_frame_info *in_info,
537    struct ia_css_frame_info *out_info,
538    struct ia_css_frame_info *vf_info,
539    unsigned int stage_idx)
540{
541	enum ia_css_pipe_version pipe_version = pipe->config.isp_pipe_version;
542	int mode;
543	unsigned int i;
544	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
545
546	assert(pipe);
547	assert(in_info);
548	assert(out_info);
549	assert(stage_idx < NUM_PRIMARY_HQ_STAGES);
550	/* vf_info can be NULL - example video_binarydescr */
551	/*assert(vf_info != NULL);*/
552	IA_CSS_ENTER_PRIVATE("");
553
554	if (pipe_version == IA_CSS_PIPE_VERSION_2_6_1)
555		mode = primary_hq_binary_modes[stage_idx];
556	else
557		mode = IA_CSS_BINARY_MODE_PRIMARY;
558
559	if (ia_css_util_is_input_format_yuv(pipe->stream->config.input_config.format))
560		mode = IA_CSS_BINARY_MODE_COPY;
561
562	in_info->res = pipe->config.input_effective_res;
563	in_info->padded_width = in_info->res.width;
564
565	if (pipe->stream->config.pack_raw_pixels)
566		in_info->format = IA_CSS_FRAME_FORMAT_RAW_PACKED;
567	else
568		in_info->format = IA_CSS_FRAME_FORMAT_RAW;
569
570	in_info->raw_bit_depth = ia_css_pipe_util_pipe_input_format_bpp(pipe);
571	out_infos[0] = out_info;
572	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
573		out_infos[i] = NULL;
574
575	pipe_binarydesc_get_offline(pipe, mode,
576				    prim_descr, in_info, out_infos, vf_info);
577
578	if (pipe->stream->config.online &&
579	    pipe->stream->config.mode != IA_CSS_INPUT_MODE_MEMORY) {
580		prim_descr->online = true;
581		prim_descr->two_ppc =
582		    (pipe->stream->config.pixels_per_clock == 2);
583		prim_descr->stream_format = pipe->stream->config.input_config.format;
584	}
585	if (mode == IA_CSS_BINARY_MODE_PRIMARY) {
586		prim_descr->isp_pipe_version = pipe->config.isp_pipe_version;
587		prim_descr->enable_fractional_ds =
588		    pipe->extra_config.enable_fractional_ds;
589		/* We have both striped and non-striped primary binaries,
590		 * if continuous viewfinder is required, then we must select
591		 * a striped one. Otherwise we prefer to use a non-striped
592		 * since it has better performance. */
593		if (pipe_version == IA_CSS_PIPE_VERSION_2_6_1)
594			prim_descr->striped = false;
595		else
596			prim_descr->striped = prim_descr->continuous &&
597					      (!pipe->stream->stop_copy_preview || !pipe->stream->disable_cont_vf);
598	}
599	IA_CSS_LEAVE_PRIVATE("");
600}
601
602void ia_css_pipe_get_pre_gdc_binarydesc(
603    struct ia_css_pipe const *const pipe,
604    struct ia_css_binary_descr *pre_gdc_descr,
605    struct ia_css_frame_info *in_info,
606    struct ia_css_frame_info *out_info)
607{
608	unsigned int i;
609	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
610
611	assert(pipe);
612	assert(in_info);
613	assert(out_info);
614	IA_CSS_ENTER_PRIVATE("");
615
616	*in_info = *out_info;
617	in_info->format = IA_CSS_FRAME_FORMAT_RAW;
618	in_info->raw_bit_depth = ia_css_pipe_util_pipe_input_format_bpp(pipe);
619	out_infos[0] = out_info;
620	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
621		out_infos[i] = NULL;
622
623	pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_PRE_ISP,
624				    pre_gdc_descr, in_info, out_infos, NULL);
625	pre_gdc_descr->isp_pipe_version = pipe->config.isp_pipe_version;
626	IA_CSS_LEAVE_PRIVATE("");
627}
628
629void ia_css_pipe_get_gdc_binarydesc(
630    struct ia_css_pipe const *const pipe,
631    struct ia_css_binary_descr *gdc_descr,
632    struct ia_css_frame_info *in_info,
633    struct ia_css_frame_info *out_info)
634{
635	unsigned int i;
636	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
637
638	assert(pipe);
639	assert(in_info);
640	assert(out_info);
641	IA_CSS_ENTER_PRIVATE("");
642
643	*in_info = *out_info;
644	in_info->format = IA_CSS_FRAME_FORMAT_QPLANE6;
645	out_infos[0] = out_info;
646	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
647		out_infos[i] = NULL;
648
649	pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_GDC,
650				    gdc_descr, in_info, out_infos, NULL);
651	IA_CSS_LEAVE_PRIVATE("");
652}
653
654void ia_css_pipe_get_post_gdc_binarydesc(
655    struct ia_css_pipe const *const pipe,
656    struct ia_css_binary_descr *post_gdc_descr,
657    struct ia_css_frame_info *in_info,
658    struct ia_css_frame_info *out_info,
659    struct ia_css_frame_info *vf_info)
660{
661	unsigned int i;
662	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
663
664	assert(pipe);
665	assert(in_info);
666	assert(out_info);
667	assert(vf_info);
668	IA_CSS_ENTER_PRIVATE("");
669
670	*in_info = *out_info;
671	in_info->format = IA_CSS_FRAME_FORMAT_YUV420_16;
672	in_info->raw_bit_depth = 16;
673	out_infos[0] = out_info;
674	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
675		out_infos[i] = NULL;
676
677	pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_POST_ISP,
678				    post_gdc_descr, in_info, out_infos, vf_info);
679
680	post_gdc_descr->isp_pipe_version = pipe->config.isp_pipe_version;
681	IA_CSS_LEAVE_PRIVATE("");
682}
683
684void ia_css_pipe_get_pre_de_binarydesc(
685    struct ia_css_pipe const *const pipe,
686    struct ia_css_binary_descr *pre_de_descr,
687    struct ia_css_frame_info *in_info,
688    struct ia_css_frame_info *out_info)
689{
690	unsigned int i;
691	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
692
693	assert(pipe);
694	assert(in_info);
695	assert(out_info);
696	IA_CSS_ENTER_PRIVATE("");
697
698	*in_info = *out_info;
699	in_info->format = IA_CSS_FRAME_FORMAT_RAW;
700	in_info->raw_bit_depth = ia_css_pipe_util_pipe_input_format_bpp(pipe);
701	out_infos[0] = out_info;
702	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
703		out_infos[i] = NULL;
704
705	if (pipe->config.isp_pipe_version == IA_CSS_PIPE_VERSION_1)
706		pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_PRE_ISP,
707					    pre_de_descr, in_info, out_infos, NULL);
708	else if (pipe->config.isp_pipe_version == IA_CSS_PIPE_VERSION_2_2) {
709		pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_PRE_DE,
710					    pre_de_descr, in_info, out_infos, NULL);
711	}
712
713	if (pipe->stream->config.online) {
714		pre_de_descr->online = true;
715		pre_de_descr->two_ppc =
716		    (pipe->stream->config.pixels_per_clock == 2);
717		pre_de_descr->stream_format = pipe->stream->config.input_config.format;
718	}
719	pre_de_descr->isp_pipe_version = pipe->config.isp_pipe_version;
720	IA_CSS_LEAVE_PRIVATE("");
721}
722
723void ia_css_pipe_get_pre_anr_binarydesc(
724    struct ia_css_pipe const *const pipe,
725    struct ia_css_binary_descr *pre_anr_descr,
726    struct ia_css_frame_info *in_info,
727    struct ia_css_frame_info *out_info)
728{
729	unsigned int i;
730	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
731
732	assert(pipe);
733	assert(in_info);
734	assert(out_info);
735	IA_CSS_ENTER_PRIVATE("");
736
737	*in_info = *out_info;
738	in_info->format = IA_CSS_FRAME_FORMAT_RAW;
739	in_info->raw_bit_depth = ia_css_pipe_util_pipe_input_format_bpp(pipe);
740	out_infos[0] = out_info;
741	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
742		out_infos[i] = NULL;
743
744	pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_PRE_ISP,
745				    pre_anr_descr, in_info, out_infos, NULL);
746
747	if (pipe->stream->config.online) {
748		pre_anr_descr->online = true;
749		pre_anr_descr->two_ppc =
750		    (pipe->stream->config.pixels_per_clock == 2);
751		pre_anr_descr->stream_format = pipe->stream->config.input_config.format;
752	}
753	pre_anr_descr->isp_pipe_version = pipe->config.isp_pipe_version;
754	IA_CSS_LEAVE_PRIVATE("");
755}
756
757void ia_css_pipe_get_anr_binarydesc(
758    struct ia_css_pipe const *const pipe,
759    struct ia_css_binary_descr *anr_descr,
760    struct ia_css_frame_info *in_info,
761    struct ia_css_frame_info *out_info)
762{
763	unsigned int i;
764	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
765
766	assert(pipe);
767	assert(in_info);
768	assert(out_info);
769	IA_CSS_ENTER_PRIVATE("");
770
771	*in_info = *out_info;
772	in_info->format = IA_CSS_FRAME_FORMAT_RAW;
773	in_info->raw_bit_depth = ANR_ELEMENT_BITS;
774	out_infos[0] = out_info;
775	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
776		out_infos[i] = NULL;
777
778	pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_ANR,
779				    anr_descr, in_info, out_infos, NULL);
780
781	anr_descr->isp_pipe_version = pipe->config.isp_pipe_version;
782	IA_CSS_LEAVE_PRIVATE("");
783}
784
785void ia_css_pipe_get_post_anr_binarydesc(
786    struct ia_css_pipe const *const pipe,
787    struct ia_css_binary_descr *post_anr_descr,
788    struct ia_css_frame_info *in_info,
789    struct ia_css_frame_info *out_info,
790    struct ia_css_frame_info *vf_info)
791{
792	unsigned int i;
793	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
794
795	assert(pipe);
796	assert(in_info);
797	assert(out_info);
798	assert(vf_info);
799	IA_CSS_ENTER_PRIVATE("");
800
801	*in_info = *out_info;
802	in_info->format = IA_CSS_FRAME_FORMAT_RAW;
803	in_info->raw_bit_depth = ANR_ELEMENT_BITS;
804	out_infos[0] = out_info;
805	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
806		out_infos[i] = NULL;
807
808	pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_POST_ISP,
809				    post_anr_descr, in_info, out_infos, vf_info);
810
811	post_anr_descr->isp_pipe_version = pipe->config.isp_pipe_version;
812	IA_CSS_LEAVE_PRIVATE("");
813}
814
815void ia_css_pipe_get_ldc_binarydesc(
816    struct ia_css_pipe const *const pipe,
817    struct ia_css_binary_descr *ldc_descr,
818    struct ia_css_frame_info *in_info,
819    struct ia_css_frame_info *out_info)
820{
821	unsigned int i;
822	struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
823
824	assert(pipe);
825	assert(in_info);
826	assert(out_info);
827	IA_CSS_ENTER_PRIVATE("");
828
829	*in_info = *out_info;
830
831	in_info->format = IA_CSS_FRAME_FORMAT_YUV420;
832	in_info->raw_bit_depth = 0;
833	ia_css_frame_info_set_width(in_info, in_info->res.width, 0);
834
835	out_infos[0] = out_info;
836	for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
837		out_infos[i] = NULL;
838
839	pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_CAPTURE_PP,
840				    ldc_descr, in_info, out_infos, NULL);
841	ldc_descr->enable_dvs_6axis =
842	    pipe->extra_config.enable_dvs_6axis;
843	IA_CSS_LEAVE_PRIVATE("");
844}
845