// SPDX-License-Identifier: GPL-2.0
|
/*
|
* Support for Intel Camera Imaging ISP subsystem.
|
* Copyright (c) 2015, Intel Corporation.
|
*
|
* This program is free software; you can redistribute it and/or modify it
|
* under the terms and conditions of the GNU General Public License,
|
* version 2, as published by the Free Software Foundation.
|
*
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
* more details.
|
*/
|
|
#include <math_support.h>
|
#include <gdc_device.h> /* HR_GDC_N */
|
|
#include "hmm.h"
|
|
#include "isp.h" /* ISP_VEC_NELEMS */
|
|
#include "ia_css_binary.h"
|
#include "ia_css_debug.h"
|
#include "ia_css_util.h"
|
#include "ia_css_isp_param.h"
|
#include "sh_css_internal.h"
|
#include "sh_css_sp.h"
|
#include "sh_css_firmware.h"
|
#include "sh_css_defs.h"
|
#include "sh_css_legacy.h"
|
|
#include "atomisp_internal.h"
|
|
#include "vf/vf_1.0/ia_css_vf.host.h"
|
#include "sc/sc_1.0/ia_css_sc.host.h"
|
#include "sdis/sdis_1.0/ia_css_sdis.host.h"
|
#include "fixedbds/fixedbds_1.0/ia_css_fixedbds_param.h" /* FRAC_ACC */
|
|
#include "camera/pipe/interface/ia_css_pipe_binarydesc.h"
|
|
#include "assert_support.h"
|
|
#define IMPLIES(a, b) (!(a) || (b)) /* A => B */
|
|
static struct ia_css_binary_xinfo *all_binaries; /* ISP binaries only (no SP) */
|
static struct ia_css_binary_xinfo
|
*binary_infos[IA_CSS_BINARY_NUM_MODES] = { NULL, };
|
|
static void
|
ia_css_binary_dvs_env(const struct ia_css_binary_info *info,
|
const struct ia_css_resolution *dvs_env,
|
struct ia_css_resolution *binary_dvs_env)
|
{
|
if (info->enable.dvs_envelope) {
|
assert(dvs_env);
|
binary_dvs_env->width = max(dvs_env->width, SH_CSS_MIN_DVS_ENVELOPE);
|
binary_dvs_env->height = max(dvs_env->height, SH_CSS_MIN_DVS_ENVELOPE);
|
}
|
}
|
|
static void
|
ia_css_binary_internal_res(const struct ia_css_frame_info *in_info,
|
const struct ia_css_frame_info *bds_out_info,
|
const struct ia_css_frame_info *out_info,
|
const struct ia_css_resolution *dvs_env,
|
const struct ia_css_binary_info *info,
|
struct ia_css_resolution *internal_res)
|
{
|
unsigned int isp_tmp_internal_width = 0,
|
isp_tmp_internal_height = 0;
|
bool binary_supports_yuv_ds = info->enable.ds & 2;
|
struct ia_css_resolution binary_dvs_env;
|
|
binary_dvs_env.width = 0;
|
binary_dvs_env.height = 0;
|
ia_css_binary_dvs_env(info, dvs_env, &binary_dvs_env);
|
|
if (binary_supports_yuv_ds) {
|
if (in_info) {
|
isp_tmp_internal_width = in_info->res.width
|
+ info->pipeline.left_cropping + binary_dvs_env.width;
|
isp_tmp_internal_height = in_info->res.height
|
+ info->pipeline.top_cropping + binary_dvs_env.height;
|
}
|
} else if ((bds_out_info) && (out_info) &&
|
/* TODO: hack to make video_us case work. this should be reverted after
|
a nice solution in ISP */
|
(bds_out_info->res.width >= out_info->res.width)) {
|
isp_tmp_internal_width = bds_out_info->padded_width;
|
isp_tmp_internal_height = bds_out_info->res.height;
|
} else {
|
if (out_info) {
|
isp_tmp_internal_width = out_info->padded_width;
|
isp_tmp_internal_height = out_info->res.height;
|
}
|
}
|
|
/* We first calculate the resolutions used by the ISP. After that,
|
* we use those resolutions to compute sizes for tables etc. */
|
internal_res->width = __ISP_INTERNAL_WIDTH(isp_tmp_internal_width,
|
(int)binary_dvs_env.width,
|
info->pipeline.left_cropping, info->pipeline.mode,
|
info->pipeline.c_subsampling,
|
info->output.num_chunks, info->pipeline.pipelining);
|
internal_res->height = __ISP_INTERNAL_HEIGHT(isp_tmp_internal_height,
|
info->pipeline.top_cropping,
|
binary_dvs_env.height);
|
}
|
|
/* ISP2400 */
|
/* Computation results of the origin coordinate of bayer on the shading table. */
|
struct sh_css_shading_table_bayer_origin_compute_results {
|
u32 bayer_scale_hor_ratio_in; /* Horizontal ratio (in) of bayer scaling. */
|
u32 bayer_scale_hor_ratio_out; /* Horizontal ratio (out) of bayer scaling. */
|
u32 bayer_scale_ver_ratio_in; /* Vertical ratio (in) of bayer scaling. */
|
u32 bayer_scale_ver_ratio_out; /* Vertical ratio (out) of bayer scaling. */
|
u32 sc_bayer_origin_x_bqs_on_shading_table; /* X coordinate (in bqs) of bayer origin on shading table. */
|
u32 sc_bayer_origin_y_bqs_on_shading_table; /* Y coordinate (in bqs) of bayer origin on shading table. */
|
};
|
|
/* ISP2401 */
|
/* Requirements for the shading correction. */
|
struct sh_css_binary_sc_requirements {
|
/* Bayer scaling factor, for the scaling which is applied before shading correction. */
|
u32 bayer_scale_hor_ratio_in; /* Horizontal ratio (in) of scaling applied BEFORE shading correction. */
|
u32 bayer_scale_hor_ratio_out; /* Horizontal ratio (out) of scaling applied BEFORE shading correction. */
|
u32 bayer_scale_ver_ratio_in; /* Vertical ratio (in) of scaling applied BEFORE shading correction. */
|
u32 bayer_scale_ver_ratio_out; /* Vertical ratio (out) of scaling applied BEFORE shading correction. */
|
|
/* ISP internal frame is composed of the real sensor data and the padding data. */
|
u32 sensor_data_origin_x_bqs_on_internal; /* X origin (in bqs) of sensor data on internal frame
|
at shading correction. */
|
u32 sensor_data_origin_y_bqs_on_internal; /* Y origin (in bqs) of sensor data on internal frame
|
at shading correction. */
|
};
|
|
/* ISP2400: Get the requirements for the shading correction. */
|
static int
|
ia_css_binary_compute_shading_table_bayer_origin(
|
const struct ia_css_binary *binary, /* [in] */
|
unsigned int required_bds_factor, /* [in] */
|
const struct ia_css_stream_config *stream_config, /* [in] */
|
struct sh_css_shading_table_bayer_origin_compute_results *res) /* [out] */
|
{
|
int err;
|
|
/* Numerator and denominator of the fixed bayer downscaling factor.
|
(numerator >= denominator) */
|
unsigned int bds_num, bds_den;
|
|
/* Horizontal/Vertical ratio of bayer scaling
|
between input area and output area. */
|
unsigned int bs_hor_ratio_in;
|
unsigned int bs_hor_ratio_out;
|
unsigned int bs_ver_ratio_in;
|
unsigned int bs_ver_ratio_out;
|
|
/* Left padding set by InputFormatter. */
|
unsigned int left_padding_bqs; /* in bqs */
|
|
/* Flag for the NEED_BDS_FACTOR_2_00 macro defined in isp kernels. */
|
unsigned int need_bds_factor_2_00;
|
|
/* Left padding adjusted inside the isp. */
|
unsigned int left_padding_adjusted_bqs; /* in bqs */
|
|
/* Bad pixels caused by filters.
|
NxN-filter (before/after bayer scaling) moves the image position
|
to right/bottom directions by a few pixels.
|
It causes bad pixels at left/top sides,
|
and effective bayer size decreases. */
|
unsigned int bad_bqs_on_left_before_bs; /* in bqs */
|
unsigned int bad_bqs_on_left_after_bs; /* in bqs */
|
unsigned int bad_bqs_on_top_before_bs; /* in bqs */
|
unsigned int bad_bqs_on_top_after_bs; /* in bqs */
|
|
/* Get the numerator and denominator of bayer downscaling factor. */
|
err = sh_css_bds_factor_get_numerator_denominator
|
(required_bds_factor, &bds_num, &bds_den);
|
if (err)
|
return err;
|
|
/* Set the horizontal/vertical ratio of bayer scaling
|
between input area and output area. */
|
bs_hor_ratio_in = bds_num;
|
bs_hor_ratio_out = bds_den;
|
bs_ver_ratio_in = bds_num;
|
bs_ver_ratio_out = bds_den;
|
|
/* Set the left padding set by InputFormatter. (ifmtr.c) */
|
if (stream_config->left_padding == -1)
|
left_padding_bqs = _ISP_BQS(binary->left_padding);
|
else
|
left_padding_bqs = (unsigned int)((int)ISP_VEC_NELEMS
|
- _ISP_BQS(stream_config->left_padding));
|
|
/* Set the left padding adjusted inside the isp.
|
When bds_factor 2.00 is needed, some padding is added to left_padding
|
inside the isp, before bayer downscaling. (raw.isp.c)
|
(Hopefully, left_crop/left_padding/top_crop should be defined in css
|
appropriately, depending on bds_factor.)
|
*/
|
need_bds_factor_2_00 = ((binary->info->sp.bds.supported_bds_factors &
|
(PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_2_00) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_2_50) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_3_00) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_4_00) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_4_50) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_5_00) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_6_00) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_8_00))) != 0);
|
|
if (need_bds_factor_2_00 && binary->info->sp.pipeline.left_cropping > 0)
|
left_padding_adjusted_bqs = left_padding_bqs + ISP_VEC_NELEMS;
|
else
|
left_padding_adjusted_bqs = left_padding_bqs;
|
|
/* Currently, the bad pixel caused by filters before bayer scaling
|
is NOT considered, because the bad pixel is subtle.
|
When some large filter is used in the future,
|
we need to consider the bad pixel.
|
|
Currently, when bds_factor isn't 1.00, 3x3 anti-alias filter is applied
|
to each color plane(Gr/R/B/Gb) before bayer downscaling.
|
This filter moves each color plane to right/bottom directions
|
by 1 pixel at the most, depending on downscaling factor.
|
*/
|
bad_bqs_on_left_before_bs = 0;
|
bad_bqs_on_top_before_bs = 0;
|
|
/* Currently, the bad pixel caused by filters after bayer scaling
|
is NOT considered, because the bad pixel is subtle.
|
When some large filter is used in the future,
|
we need to consider the bad pixel.
|
|
Currently, when DPC&BNR is processed between bayer scaling and
|
shading correction, DPC&BNR moves each color plane to
|
right/bottom directions by 1 pixel.
|
*/
|
bad_bqs_on_left_after_bs = 0;
|
bad_bqs_on_top_after_bs = 0;
|
|
/* Calculate the origin of bayer (real sensor data area)
|
located on the shading table during the shading correction. */
|
res->sc_bayer_origin_x_bqs_on_shading_table =
|
((left_padding_adjusted_bqs + bad_bqs_on_left_before_bs)
|
* bs_hor_ratio_out + bs_hor_ratio_in / 2) / bs_hor_ratio_in
|
+ bad_bqs_on_left_after_bs;
|
/* "+ bs_hor_ratio_in/2": rounding for division by bs_hor_ratio_in */
|
res->sc_bayer_origin_y_bqs_on_shading_table =
|
(bad_bqs_on_top_before_bs * bs_ver_ratio_out + bs_ver_ratio_in / 2) / bs_ver_ratio_in
|
+ bad_bqs_on_top_after_bs;
|
/* "+ bs_ver_ratio_in/2": rounding for division by bs_ver_ratio_in */
|
|
res->bayer_scale_hor_ratio_in = (uint32_t)bs_hor_ratio_in;
|
res->bayer_scale_hor_ratio_out = (uint32_t)bs_hor_ratio_out;
|
res->bayer_scale_ver_ratio_in = (uint32_t)bs_ver_ratio_in;
|
res->bayer_scale_ver_ratio_out = (uint32_t)bs_ver_ratio_out;
|
|
return err;
|
}
|
|
/* ISP2401: Get the requirements for the shading correction. */
|
static int
|
sh_css_binary_get_sc_requirements(const struct ia_css_binary *binary, /* [in] */
|
unsigned int required_bds_factor, /* [in] */
|
const struct ia_css_stream_config *stream_config, /* [in] */
|
struct sh_css_binary_sc_requirements *scr) /* [out] */
|
{
|
int err;
|
|
/* Numerator and denominator of the fixed bayer downscaling factor. (numerator >= denominator) */
|
unsigned int bds_num, bds_den;
|
|
/* Horizontal/Vertical ratio of bayer scaling between input area and output area. */
|
unsigned int bs_hor_ratio_in, bs_hor_ratio_out, bs_ver_ratio_in, bs_ver_ratio_out;
|
|
/* Left padding set by InputFormatter. */
|
unsigned int left_padding_bqs;
|
|
/* Flags corresponding to NEED_BDS_FACTOR_2_00/NEED_BDS_FACTOR_1_50/NEED_BDS_FACTOR_1_25 macros
|
* defined in isp kernels. */
|
unsigned int need_bds_factor_2_00, need_bds_factor_1_50, need_bds_factor_1_25;
|
|
/* Left padding adjusted inside the isp kernels. */
|
unsigned int left_padding_adjusted_bqs;
|
|
/* Top padding padded inside the isp kernel for bayer downscaling binaries. */
|
unsigned int top_padding_bqs;
|
|
/* Bayer downscaling factor 1.0 by fixed-point. */
|
int bds_frac_acc = FRAC_ACC; /* FRAC_ACC is defined in ia_css_fixedbds_param.h. */
|
|
/* Right/Down shift amount caused by filters applied BEFORE shading corrertion. */
|
unsigned int right_shift_bqs_before_bs; /* right shift before bayer scaling */
|
unsigned int right_shift_bqs_after_bs; /* right shift after bayer scaling */
|
unsigned int down_shift_bqs_before_bs; /* down shift before bayer scaling */
|
unsigned int down_shift_bqs_after_bs; /* down shift after bayer scaling */
|
|
/* Origin of the real sensor data area on the internal frame at shading correction. */
|
unsigned int sensor_data_origin_x_bqs_on_internal;
|
unsigned int sensor_data_origin_y_bqs_on_internal;
|
|
unsigned int bs_frac = bds_frac_acc; /* scaling factor 1.0 in fixed point */
|
unsigned int bs_out, bs_in; /* scaling ratio in fixed point */
|
|
IA_CSS_ENTER_PRIVATE("binary=%p, required_bds_factor=%d, stream_config=%p",
|
binary, required_bds_factor, stream_config);
|
|
/* Get the numerator and denominator of the required bayer downscaling factor. */
|
err = sh_css_bds_factor_get_numerator_denominator(required_bds_factor,
|
&bds_num, &bds_den);
|
if (err) {
|
IA_CSS_LEAVE_ERR_PRIVATE(err);
|
return err;
|
}
|
|
IA_CSS_LOG("bds_num=%d, bds_den=%d", bds_num, bds_den);
|
|
/* Set the horizontal/vertical ratio of bayer scaling between input area and output area. */
|
bs_hor_ratio_in = bds_num;
|
bs_hor_ratio_out = bds_den;
|
bs_ver_ratio_in = bds_num;
|
bs_ver_ratio_out = bds_den;
|
|
/* Set the left padding set by InputFormatter. (ia_css_ifmtr_configure() in ifmtr.c) */
|
if (stream_config->left_padding == -1)
|
left_padding_bqs = _ISP_BQS(binary->left_padding);
|
else
|
left_padding_bqs = (unsigned int)((int)ISP_VEC_NELEMS - _ISP_BQS(stream_config->left_padding));
|
|
IA_CSS_LOG("stream.left_padding=%d, binary.left_padding=%d, left_padding_bqs=%d",
|
stream_config->left_padding, binary->left_padding,
|
left_padding_bqs);
|
|
/* Set the left padding adjusted inside the isp kernels.
|
* When the bds_factor isn't 1.00, the left padding size is adjusted inside the isp,
|
* before bayer downscaling. (scaled_hor_plane_index(), raw_compute_hphase() in raw.isp.c)
|
*/
|
need_bds_factor_2_00 = ((binary->info->sp.bds.supported_bds_factors &
|
(PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_2_00) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_2_50) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_3_00) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_4_00) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_4_50) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_5_00) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_6_00) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_8_00))) != 0);
|
|
need_bds_factor_1_50 = ((binary->info->sp.bds.supported_bds_factors &
|
(PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_1_50) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_2_25) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_3_00) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_4_50) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_6_00))) != 0);
|
|
need_bds_factor_1_25 = ((binary->info->sp.bds.supported_bds_factors &
|
(PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_1_25) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_2_50) |
|
PACK_BDS_FACTOR(SH_CSS_BDS_FACTOR_5_00))) != 0);
|
|
if (binary->info->sp.pipeline.left_cropping > 0 &&
|
(need_bds_factor_2_00 || need_bds_factor_1_50 || need_bds_factor_1_25)) {
|
/*
|
* downscale 2.0 -> first_vec_adjusted_bqs = 128
|
* downscale 1.5 -> first_vec_adjusted_bqs = 96
|
* downscale 1.25 -> first_vec_adjusted_bqs = 80
|
*/
|
unsigned int first_vec_adjusted_bqs = ISP_VEC_NELEMS * bs_hor_ratio_in / bs_hor_ratio_out;
|
left_padding_adjusted_bqs = first_vec_adjusted_bqs
|
- _ISP_BQS(binary->info->sp.pipeline.left_cropping);
|
} else {
|
left_padding_adjusted_bqs = left_padding_bqs;
|
}
|
|
IA_CSS_LOG("supported_bds_factors=%d, need_bds_factor:2_00=%d, 1_50=%d, 1_25=%d",
|
binary->info->sp.bds.supported_bds_factors,
|
need_bds_factor_2_00, need_bds_factor_1_50,
|
need_bds_factor_1_25);
|
IA_CSS_LOG("left_cropping=%d, left_padding_adjusted_bqs=%d",
|
binary->info->sp.pipeline.left_cropping,
|
left_padding_adjusted_bqs);
|
|
/* Set the top padding padded inside the isp kernel for bayer downscaling binaries.
|
* When the bds_factor isn't 1.00, the top padding is padded inside the isp
|
* before bayer downscaling, because the top cropping size (input margin) is not enough.
|
* (calculate_input_line(), raw_compute_vphase(), dma_read_raw() in raw.isp.c)
|
* NOTE: In dma_read_raw(), the factor passed to raw_compute_vphase() is got by get_bds_factor_for_dma_read().
|
* This factor is BDS_FPVAL_100/BDS_FPVAL_125/BDS_FPVAL_150/BDS_FPVAL_200.
|
*/
|
top_padding_bqs = 0;
|
if (binary->info->sp.pipeline.top_cropping > 0 &&
|
(required_bds_factor == SH_CSS_BDS_FACTOR_1_25 ||
|
required_bds_factor == SH_CSS_BDS_FACTOR_1_50 ||
|
required_bds_factor == SH_CSS_BDS_FACTOR_2_00)) {
|
/* Calculation from calculate_input_line() and raw_compute_vphase() in raw.isp.c. */
|
int top_cropping_bqs = _ISP_BQS(binary->info->sp.pipeline.top_cropping);
|
/* top cropping (in bqs) */
|
int factor = bds_num * bds_frac_acc /
|
bds_den; /* downscaling factor by fixed-point */
|
int top_padding_bqsxfrac_acc = (top_cropping_bqs * factor - top_cropping_bqs *
|
bds_frac_acc)
|
+ (2 * bds_frac_acc - factor); /* top padding by fixed-point (in bqs) */
|
|
top_padding_bqs = (unsigned int)((top_padding_bqsxfrac_acc + bds_frac_acc / 2 -
|
1) / bds_frac_acc);
|
}
|
|
IA_CSS_LOG("top_cropping=%d, top_padding_bqs=%d",
|
binary->info->sp.pipeline.top_cropping, top_padding_bqs);
|
|
/* Set the right/down shift amount caused by filters applied BEFORE bayer scaling,
|
* which scaling is applied BEFORE shading corrertion.
|
*
|
* When the bds_factor isn't 1.00, 3x3 anti-alias filter is applied to each color plane(Gr/R/B/Gb)
|
* before bayer downscaling.
|
* This filter shifts each color plane (Gr/R/B/Gb) to right/down directions by 1 pixel.
|
*/
|
right_shift_bqs_before_bs = 0;
|
down_shift_bqs_before_bs = 0;
|
|
if (need_bds_factor_2_00 || need_bds_factor_1_50 || need_bds_factor_1_25) {
|
right_shift_bqs_before_bs = 1;
|
down_shift_bqs_before_bs = 1;
|
}
|
|
IA_CSS_LOG("right_shift_bqs_before_bs=%d, down_shift_bqs_before_bs=%d",
|
right_shift_bqs_before_bs, down_shift_bqs_before_bs);
|
|
/* Set the right/down shift amount caused by filters applied AFTER bayer scaling,
|
* which scaling is applied BEFORE shading corrertion.
|
*
|
* When DPC&BNR is processed between bayer scaling and shading correction,
|
* DPC&BNR moves each color plane (Gr/R/B/Gb) to right/down directions by 1 pixel.
|
*/
|
right_shift_bqs_after_bs = 0;
|
down_shift_bqs_after_bs = 0;
|
|
/* if DPC&BNR is enabled in the binary */
|
if (binary->info->mem_offsets.offsets.param->dmem.dp.size != 0) {
|
right_shift_bqs_after_bs = 1;
|
down_shift_bqs_after_bs = 1;
|
}
|
|
IA_CSS_LOG("right_shift_bqs_after_bs=%d, down_shift_bqs_after_bs=%d",
|
right_shift_bqs_after_bs, down_shift_bqs_after_bs);
|
|
bs_out = bs_hor_ratio_out * bs_frac;
|
bs_in = bs_hor_ratio_in * bs_frac;
|
sensor_data_origin_x_bqs_on_internal =
|
((left_padding_adjusted_bqs + right_shift_bqs_before_bs) * bs_out + bs_in / 2) / bs_in
|
+ right_shift_bqs_after_bs; /* "+ bs_in/2": rounding */
|
|
bs_out = bs_ver_ratio_out * bs_frac;
|
bs_in = bs_ver_ratio_in * bs_frac;
|
sensor_data_origin_y_bqs_on_internal =
|
((top_padding_bqs + down_shift_bqs_before_bs) * bs_out + bs_in / 2) / bs_in
|
+ down_shift_bqs_after_bs; /* "+ bs_in/2": rounding */
|
|
scr->bayer_scale_hor_ratio_in = (uint32_t)bs_hor_ratio_in;
|
scr->bayer_scale_hor_ratio_out = (uint32_t)bs_hor_ratio_out;
|
scr->bayer_scale_ver_ratio_in = (uint32_t)bs_ver_ratio_in;
|
scr->bayer_scale_ver_ratio_out = (uint32_t)bs_ver_ratio_out;
|
scr->sensor_data_origin_x_bqs_on_internal = (uint32_t)sensor_data_origin_x_bqs_on_internal;
|
scr->sensor_data_origin_y_bqs_on_internal = (uint32_t)sensor_data_origin_y_bqs_on_internal;
|
|
IA_CSS_LOG("sc_requirements: %d, %d, %d, %d, %d, %d",
|
scr->bayer_scale_hor_ratio_in,
|
scr->bayer_scale_hor_ratio_out,
|
scr->bayer_scale_ver_ratio_in, scr->bayer_scale_ver_ratio_out,
|
scr->sensor_data_origin_x_bqs_on_internal,
|
scr->sensor_data_origin_y_bqs_on_internal);
|
|
IA_CSS_LEAVE_ERR_PRIVATE(err);
|
return err;
|
}
|
|
/* Get the shading information of Shading Correction Type 1. */
|
static int
|
isp2400_binary_get_shading_info_type_1(const struct ia_css_binary *binary, /* [in] */
|
unsigned int required_bds_factor, /* [in] */
|
const struct ia_css_stream_config *stream_config, /* [in] */
|
struct ia_css_shading_info *info) /* [out] */
|
{
|
int err;
|
struct sh_css_shading_table_bayer_origin_compute_results res;
|
|
assert(binary);
|
assert(info);
|
|
info->type = IA_CSS_SHADING_CORRECTION_TYPE_1;
|
|
info->info.type_1.enable = binary->info->sp.enable.sc;
|
info->info.type_1.num_hor_grids = binary->sctbl_width_per_color;
|
info->info.type_1.num_ver_grids = binary->sctbl_height;
|
info->info.type_1.bqs_per_grid_cell = (1 << binary->deci_factor_log2);
|
|
/* Initialize by default values. */
|
info->info.type_1.bayer_scale_hor_ratio_in = 1;
|
info->info.type_1.bayer_scale_hor_ratio_out = 1;
|
info->info.type_1.bayer_scale_ver_ratio_in = 1;
|
info->info.type_1.bayer_scale_ver_ratio_out = 1;
|
info->info.type_1.sc_bayer_origin_x_bqs_on_shading_table = 0;
|
info->info.type_1.sc_bayer_origin_y_bqs_on_shading_table = 0;
|
|
err = ia_css_binary_compute_shading_table_bayer_origin(
|
binary,
|
required_bds_factor,
|
stream_config,
|
&res);
|
if (err)
|
return err;
|
|
info->info.type_1.bayer_scale_hor_ratio_in = res.bayer_scale_hor_ratio_in;
|
info->info.type_1.bayer_scale_hor_ratio_out = res.bayer_scale_hor_ratio_out;
|
info->info.type_1.bayer_scale_ver_ratio_in = res.bayer_scale_ver_ratio_in;
|
info->info.type_1.bayer_scale_ver_ratio_out = res.bayer_scale_ver_ratio_out;
|
info->info.type_1.sc_bayer_origin_x_bqs_on_shading_table = res.sc_bayer_origin_x_bqs_on_shading_table;
|
info->info.type_1.sc_bayer_origin_y_bqs_on_shading_table = res.sc_bayer_origin_y_bqs_on_shading_table;
|
|
return err;
|
}
|
|
/* Get the shading information of Shading Correction Type 1. */
|
static int
|
isp2401_binary_get_shading_info_type_1(const struct ia_css_binary *binary, /* [in] */
|
unsigned int required_bds_factor, /* [in] */
|
const struct ia_css_stream_config *stream_config, /* [in] */
|
struct ia_css_shading_info *shading_info, /* [out] */
|
struct ia_css_pipe_config *pipe_config) /* [out] */
|
{
|
int err;
|
struct sh_css_binary_sc_requirements scr;
|
|
u32 in_width_bqs, in_height_bqs, internal_width_bqs, internal_height_bqs;
|
u32 num_hor_grids, num_ver_grids, bqs_per_grid_cell, tbl_width_bqs, tbl_height_bqs;
|
u32 sensor_org_x_bqs_on_internal, sensor_org_y_bqs_on_internal, sensor_width_bqs, sensor_height_bqs;
|
u32 sensor_center_x_bqs_on_internal, sensor_center_y_bqs_on_internal;
|
u32 left, right, upper, lower;
|
u32 adjust_left, adjust_right, adjust_upper, adjust_lower, adjust_width_bqs, adjust_height_bqs;
|
u32 internal_org_x_bqs_on_tbl, internal_org_y_bqs_on_tbl;
|
u32 sensor_org_x_bqs_on_tbl, sensor_org_y_bqs_on_tbl;
|
|
assert(binary);
|
assert(stream_config);
|
assert(shading_info);
|
assert(pipe_config);
|
|
IA_CSS_ENTER_PRIVATE("binary=%p, required_bds_factor=%d, stream_config=%p",
|
binary, required_bds_factor, stream_config);
|
|
/* Initialize by default values. */
|
*shading_info = DEFAULT_SHADING_INFO_TYPE_1;
|
|
err = sh_css_binary_get_sc_requirements(binary, required_bds_factor, stream_config, &scr);
|
if (err) {
|
IA_CSS_LEAVE_ERR_PRIVATE(err);
|
return err;
|
}
|
|
IA_CSS_LOG("binary: id=%d, sctbl=%dx%d, deci=%d",
|
binary->info->sp.id, binary->sctbl_width_per_color, binary->sctbl_height, binary->deci_factor_log2);
|
IA_CSS_LOG("binary: in=%dx%d, in_padded_w=%d, int=%dx%d, int_padded_w=%d, out=%dx%d, out_padded_w=%d",
|
binary->in_frame_info.res.width, binary->in_frame_info.res.height, binary->in_frame_info.padded_width,
|
binary->internal_frame_info.res.width, binary->internal_frame_info.res.height,
|
binary->internal_frame_info.padded_width,
|
binary->out_frame_info[0].res.width, binary->out_frame_info[0].res.height,
|
binary->out_frame_info[0].padded_width);
|
|
/* Set the input size from sensor, which includes left/top crop size. */
|
in_width_bqs = _ISP_BQS(binary->in_frame_info.res.width);
|
in_height_bqs = _ISP_BQS(binary->in_frame_info.res.height);
|
|
/*
|
* Frame size internally used in ISP, including sensor data and padding.
|
* This is the frame size, to which the shading correction is applied.
|
*/
|
internal_width_bqs = _ISP_BQS(binary->internal_frame_info.res.width);
|
internal_height_bqs = _ISP_BQS(binary->internal_frame_info.res.height);
|
|
/* Shading table. */
|
num_hor_grids = binary->sctbl_width_per_color;
|
num_ver_grids = binary->sctbl_height;
|
bqs_per_grid_cell = (1 << binary->deci_factor_log2);
|
tbl_width_bqs = (num_hor_grids - 1) * bqs_per_grid_cell;
|
tbl_height_bqs = (num_ver_grids - 1) * bqs_per_grid_cell;
|
|
IA_CSS_LOG("tbl_width_bqs=%d, tbl_height_bqs=%d", tbl_width_bqs, tbl_height_bqs);
|
|
/*
|
* Real sensor data area on the internal frame at shading correction.
|
* Filters and scaling are applied to the internal frame before
|
* shading correction, depending on the binary.
|
*/
|
sensor_org_x_bqs_on_internal = scr.sensor_data_origin_x_bqs_on_internal;
|
sensor_org_y_bqs_on_internal = scr.sensor_data_origin_y_bqs_on_internal;
|
{
|
unsigned int bs_frac = 8; /* scaling factor 1.0 in fixed point (8 == FRAC_ACC macro in ISP) */
|
unsigned int bs_out, bs_in; /* scaling ratio in fixed point */
|
|
bs_out = scr.bayer_scale_hor_ratio_out * bs_frac;
|
bs_in = scr.bayer_scale_hor_ratio_in * bs_frac;
|
sensor_width_bqs = (in_width_bqs * bs_out + bs_in / 2) / bs_in; /* "+ bs_in/2": rounding */
|
|
bs_out = scr.bayer_scale_ver_ratio_out * bs_frac;
|
bs_in = scr.bayer_scale_ver_ratio_in * bs_frac;
|
sensor_height_bqs = (in_height_bqs * bs_out + bs_in / 2) / bs_in; /* "+ bs_in/2": rounding */
|
}
|
|
/* Center of the sensor data on the internal frame at shading correction. */
|
sensor_center_x_bqs_on_internal = sensor_org_x_bqs_on_internal + sensor_width_bqs / 2;
|
sensor_center_y_bqs_on_internal = sensor_org_y_bqs_on_internal + sensor_height_bqs / 2;
|
|
/* Size of left/right/upper/lower sides of the sensor center on the internal frame. */
|
left = sensor_center_x_bqs_on_internal;
|
right = internal_width_bqs - sensor_center_x_bqs_on_internal;
|
upper = sensor_center_y_bqs_on_internal;
|
lower = internal_height_bqs - sensor_center_y_bqs_on_internal;
|
|
/* Align the size of left/right/upper/lower sides to a multiple of the grid cell size. */
|
adjust_left = CEIL_MUL(left, bqs_per_grid_cell);
|
adjust_right = CEIL_MUL(right, bqs_per_grid_cell);
|
adjust_upper = CEIL_MUL(upper, bqs_per_grid_cell);
|
adjust_lower = CEIL_MUL(lower, bqs_per_grid_cell);
|
|
/* Shading table should cover the adjusted frame size. */
|
adjust_width_bqs = adjust_left + adjust_right;
|
adjust_height_bqs = adjust_upper + adjust_lower;
|
|
IA_CSS_LOG("adjust_width_bqs=%d, adjust_height_bqs=%d", adjust_width_bqs, adjust_height_bqs);
|
|
if (adjust_width_bqs > tbl_width_bqs || adjust_height_bqs > tbl_height_bqs) {
|
IA_CSS_LEAVE_ERR_PRIVATE(-EINVAL);
|
return -EINVAL;
|
}
|
|
/* Origin of the internal frame on the shading table. */
|
internal_org_x_bqs_on_tbl = adjust_left - left;
|
internal_org_y_bqs_on_tbl = adjust_upper - upper;
|
|
/* Origin of the real sensor data area on the shading table. */
|
sensor_org_x_bqs_on_tbl = internal_org_x_bqs_on_tbl + sensor_org_x_bqs_on_internal;
|
sensor_org_y_bqs_on_tbl = internal_org_y_bqs_on_tbl + sensor_org_y_bqs_on_internal;
|
|
/* The shading information necessary as API is stored in the shading_info. */
|
shading_info->info.type_1.num_hor_grids = num_hor_grids;
|
shading_info->info.type_1.num_ver_grids = num_ver_grids;
|
shading_info->info.type_1.bqs_per_grid_cell = bqs_per_grid_cell;
|
|
shading_info->info.type_1.bayer_scale_hor_ratio_in = scr.bayer_scale_hor_ratio_in;
|
shading_info->info.type_1.bayer_scale_hor_ratio_out = scr.bayer_scale_hor_ratio_out;
|
shading_info->info.type_1.bayer_scale_ver_ratio_in = scr.bayer_scale_ver_ratio_in;
|
shading_info->info.type_1.bayer_scale_ver_ratio_out = scr.bayer_scale_ver_ratio_out;
|
|
shading_info->info.type_1.isp_input_sensor_data_res_bqs.width = in_width_bqs;
|
shading_info->info.type_1.isp_input_sensor_data_res_bqs.height = in_height_bqs;
|
|
shading_info->info.type_1.sensor_data_res_bqs.width = sensor_width_bqs;
|
shading_info->info.type_1.sensor_data_res_bqs.height = sensor_height_bqs;
|
|
shading_info->info.type_1.sensor_data_origin_bqs_on_sctbl.x = (int32_t)sensor_org_x_bqs_on_tbl;
|
shading_info->info.type_1.sensor_data_origin_bqs_on_sctbl.y = (int32_t)sensor_org_y_bqs_on_tbl;
|
|
/* The shading information related to ISP (but, not necessary as API) is stored in the pipe_config. */
|
pipe_config->internal_frame_origin_bqs_on_sctbl.x = (int32_t)internal_org_x_bqs_on_tbl;
|
pipe_config->internal_frame_origin_bqs_on_sctbl.y = (int32_t)internal_org_y_bqs_on_tbl;
|
|
IA_CSS_LOG("shading_info: grids=%dx%d, cell=%d, scale=%d,%d,%d,%d, input=%dx%d, data=%dx%d, origin=(%d,%d)",
|
shading_info->info.type_1.num_hor_grids,
|
shading_info->info.type_1.num_ver_grids,
|
shading_info->info.type_1.bqs_per_grid_cell,
|
shading_info->info.type_1.bayer_scale_hor_ratio_in,
|
shading_info->info.type_1.bayer_scale_hor_ratio_out,
|
shading_info->info.type_1.bayer_scale_ver_ratio_in,
|
shading_info->info.type_1.bayer_scale_ver_ratio_out,
|
shading_info->info.type_1.isp_input_sensor_data_res_bqs.width,
|
shading_info->info.type_1.isp_input_sensor_data_res_bqs.height,
|
shading_info->info.type_1.sensor_data_res_bqs.width,
|
shading_info->info.type_1.sensor_data_res_bqs.height,
|
shading_info->info.type_1.sensor_data_origin_bqs_on_sctbl.x,
|
shading_info->info.type_1.sensor_data_origin_bqs_on_sctbl.y);
|
|
IA_CSS_LOG("pipe_config: origin=(%d,%d)",
|
pipe_config->internal_frame_origin_bqs_on_sctbl.x,
|
pipe_config->internal_frame_origin_bqs_on_sctbl.y);
|
|
IA_CSS_LEAVE_ERR_PRIVATE(err);
|
return err;
|
}
|
|
|
int
|
ia_css_binary_get_shading_info(const struct ia_css_binary *binary, /* [in] */
|
enum ia_css_shading_correction_type type, /* [in] */
|
unsigned int required_bds_factor, /* [in] */
|
const struct ia_css_stream_config *stream_config, /* [in] */
|
struct ia_css_shading_info *shading_info, /* [out] */
|
struct ia_css_pipe_config *pipe_config) /* [out] */
|
{
|
int err;
|
|
assert(binary);
|
assert(shading_info);
|
|
IA_CSS_ENTER_PRIVATE("binary=%p, type=%d, required_bds_factor=%d, stream_config=%p",
|
binary, type, required_bds_factor, stream_config);
|
|
if (type != IA_CSS_SHADING_CORRECTION_TYPE_1) {
|
err = -ENOTSUPP;
|
|
IA_CSS_LEAVE_ERR_PRIVATE(err);
|
return err;
|
}
|
|
if (!IS_ISP2401)
|
err = isp2400_binary_get_shading_info_type_1(binary,
|
required_bds_factor,
|
stream_config,
|
shading_info);
|
else
|
err = isp2401_binary_get_shading_info_type_1(binary,
|
required_bds_factor,
|
stream_config,
|
shading_info,
|
pipe_config);
|
|
IA_CSS_LEAVE_ERR_PRIVATE(err);
|
return err;
|
}
|
|
static void sh_css_binary_common_grid_info(const struct ia_css_binary *binary,
|
struct ia_css_grid_info *info)
|
{
|
assert(binary);
|
assert(info);
|
|
info->isp_in_width = binary->internal_frame_info.res.width;
|
info->isp_in_height = binary->internal_frame_info.res.height;
|
|
info->vamem_type = IA_CSS_VAMEM_TYPE_2;
|
}
|
|
void
|
ia_css_binary_dvs_grid_info(const struct ia_css_binary *binary,
|
struct ia_css_grid_info *info,
|
struct ia_css_pipe *pipe)
|
{
|
struct ia_css_dvs_grid_info *dvs_info;
|
|
(void)pipe;
|
assert(binary);
|
assert(info);
|
|
dvs_info = &info->dvs_grid.dvs_grid_info;
|
|
/* for DIS, we use a division instead of a ceil_div. If this is smaller
|
* than the 3a grid size, it indicates that the outer values are not
|
* valid for DIS.
|
*/
|
dvs_info->enable = binary->info->sp.enable.dis;
|
dvs_info->width = binary->dis.grid.dim.width;
|
dvs_info->height = binary->dis.grid.dim.height;
|
dvs_info->aligned_width = binary->dis.grid.pad.width;
|
dvs_info->aligned_height = binary->dis.grid.pad.height;
|
dvs_info->bqs_per_grid_cell = 1 << binary->dis.deci_factor_log2;
|
dvs_info->num_hor_coefs = binary->dis.coef.dim.width;
|
dvs_info->num_ver_coefs = binary->dis.coef.dim.height;
|
|
sh_css_binary_common_grid_info(binary, info);
|
}
|
|
void
|
ia_css_binary_dvs_stat_grid_info(
|
const struct ia_css_binary *binary,
|
struct ia_css_grid_info *info,
|
struct ia_css_pipe *pipe)
|
{
|
(void)pipe;
|
sh_css_binary_common_grid_info(binary, info);
|
return;
|
}
|
|
int
|
ia_css_binary_3a_grid_info(const struct ia_css_binary *binary,
|
struct ia_css_grid_info *info,
|
struct ia_css_pipe *pipe) {
|
struct ia_css_3a_grid_info *s3a_info;
|
int err = 0;
|
|
IA_CSS_ENTER_PRIVATE("binary=%p, info=%p, pipe=%p",
|
binary, info, pipe);
|
|
assert(binary);
|
assert(info);
|
s3a_info = &info->s3a_grid;
|
|
/* 3A statistics grid */
|
s3a_info->enable = binary->info->sp.enable.s3a;
|
s3a_info->width = binary->s3atbl_width;
|
s3a_info->height = binary->s3atbl_height;
|
s3a_info->aligned_width = binary->s3atbl_isp_width;
|
s3a_info->aligned_height = binary->s3atbl_isp_height;
|
s3a_info->bqs_per_grid_cell = (1 << binary->deci_factor_log2);
|
s3a_info->deci_factor_log2 = binary->deci_factor_log2;
|
s3a_info->elem_bit_depth = SH_CSS_BAYER_BITS;
|
s3a_info->use_dmem = binary->info->sp.s3a.s3atbl_use_dmem;
|
#if defined(HAS_NO_HMEM)
|
s3a_info->has_histogram = 1;
|
#else
|
s3a_info->has_histogram = 0;
|
#endif
|
IA_CSS_LEAVE_ERR_PRIVATE(err);
|
return err;
|
}
|
|
static void
|
binary_init_pc_histogram(struct sh_css_pc_histogram *histo)
|
{
|
assert(histo);
|
|
histo->length = 0;
|
histo->run = NULL;
|
histo->stall = NULL;
|
}
|
|
static void
|
binary_init_metrics(struct sh_css_binary_metrics *metrics,
|
const struct ia_css_binary_info *info)
|
{
|
assert(metrics);
|
assert(info);
|
|
metrics->mode = info->pipeline.mode;
|
metrics->id = info->id;
|
metrics->next = NULL;
|
binary_init_pc_histogram(&metrics->isp_histogram);
|
binary_init_pc_histogram(&metrics->sp_histogram);
|
}
|
|
/* move to host part of output module */
|
static bool
|
binary_supports_output_format(const struct ia_css_binary_xinfo *info,
|
enum ia_css_frame_format format)
|
{
|
int i;
|
|
assert(info);
|
|
for (i = 0; i < info->num_output_formats; i++) {
|
if (info->output_formats[i] == format)
|
return true;
|
}
|
return false;
|
}
|
|
static bool
|
binary_supports_vf_format(const struct ia_css_binary_xinfo *info,
|
enum ia_css_frame_format format)
|
{
|
int i;
|
|
assert(info);
|
|
for (i = 0; i < info->num_vf_formats; i++) {
|
if (info->vf_formats[i] == format)
|
return true;
|
}
|
return false;
|
}
|
|
/* move to host part of bds module */
|
static bool
|
supports_bds_factor(u32 supported_factors,
|
uint32_t bds_factor)
|
{
|
return ((supported_factors & PACK_BDS_FACTOR(bds_factor)) != 0);
|
}
|
|
static int
|
binary_init_info(struct ia_css_binary_xinfo *info, unsigned int i,
|
bool *binary_found) {
|
const unsigned char *blob = sh_css_blob_info[i].blob;
|
unsigned int size = sh_css_blob_info[i].header.blob.size;
|
|
if ((!info) || (!binary_found))
|
return -EINVAL;
|
|
*info = sh_css_blob_info[i].header.info.isp;
|
*binary_found = blob;
|
info->blob_index = i;
|
/* we don't have this binary, skip it */
|
if (!size)
|
return 0;
|
|
info->xmem_addr = sh_css_load_blob(blob, size);
|
if (!info->xmem_addr)
|
return -ENOMEM;
|
return 0;
|
}
|
|
/* When binaries are put at the beginning, they will only
|
* be selected if no other primary matches.
|
*/
|
int
|
ia_css_binary_init_infos(void) {
|
unsigned int i;
|
unsigned int num_of_isp_binaries = sh_css_num_binaries - NUM_OF_SPS - NUM_OF_BLS;
|
|
if (num_of_isp_binaries == 0)
|
return 0;
|
|
all_binaries = kvmalloc(num_of_isp_binaries * sizeof(*all_binaries),
|
GFP_KERNEL);
|
if (!all_binaries)
|
return -ENOMEM;
|
|
for (i = 0; i < num_of_isp_binaries; i++)
|
{
|
int ret;
|
struct ia_css_binary_xinfo *binary = &all_binaries[i];
|
bool binary_found;
|
|
ret = binary_init_info(binary, i, &binary_found);
|
if (ret)
|
return ret;
|
if (!binary_found)
|
continue;
|
/* Prepend new binary information */
|
binary->next = binary_infos[binary->sp.pipeline.mode];
|
binary_infos[binary->sp.pipeline.mode] = binary;
|
binary->blob = &sh_css_blob_info[i];
|
binary->mem_offsets = sh_css_blob_info[i].mem_offsets;
|
}
|
return 0;
|
}
|
|
int
|
ia_css_binary_uninit(void) {
|
unsigned int i;
|
struct ia_css_binary_xinfo *b;
|
|
for (i = 0; i < IA_CSS_BINARY_NUM_MODES; i++)
|
{
|
for (b = binary_infos[i]; b; b = b->next) {
|
if (b->xmem_addr)
|
hmm_free(b->xmem_addr);
|
b->xmem_addr = mmgr_NULL;
|
}
|
binary_infos[i] = NULL;
|
}
|
kvfree(all_binaries);
|
return 0;
|
}
|
|
/* @brief Compute decimation factor for 3A statistics and shading correction.
|
*
|
* @param[in] width Frame width in pixels.
|
* @param[in] height Frame height in pixels.
|
* @return Log2 of decimation factor (= grid cell size) in bayer quads.
|
*/
|
static int
|
binary_grid_deci_factor_log2(int width, int height)
|
{
|
/* 3A/Shading decimation factor spcification (at August 2008)
|
* ------------------------------------------------------------------
|
* [Image Width (BQ)] [Decimation Factor (BQ)] [Resulting grid cells]
|
#ifndef ISP2401
|
* 1280 ?c 32 40 ?c
|
* 640 ?c 1279 16 40 ?c 80
|
* ?c 639 8 ?c 80
|
#else
|
* from 1280 32 from 40
|
* from 640 to 1279 16 from 40 to 80
|
* to 639 8 to 80
|
#endif
|
* ------------------------------------------------------------------
|
*/
|
/* Maximum and minimum decimation factor by the specification */
|
#define MAX_SPEC_DECI_FACT_LOG2 5
|
#define MIN_SPEC_DECI_FACT_LOG2 3
|
/* the smallest frame width in bayer quads when decimation factor (log2) is 5 or 4, by the specification */
|
#define DECI_FACT_LOG2_5_SMALLEST_FRAME_WIDTH_BQ 1280
|
#define DECI_FACT_LOG2_4_SMALLEST_FRAME_WIDTH_BQ 640
|
|
int smallest_factor; /* the smallest factor (log2) where the number of cells does not exceed the limitation */
|
int spec_factor; /* the factor (log2) which satisfies the specification */
|
|
/* Currently supported maximum width and height are 5120(=80*64) and 3840(=60*64). */
|
assert(ISP_BQ_GRID_WIDTH(width,
|
MAX_SPEC_DECI_FACT_LOG2) <= SH_CSS_MAX_BQ_GRID_WIDTH);
|
assert(ISP_BQ_GRID_HEIGHT(height,
|
MAX_SPEC_DECI_FACT_LOG2) <= SH_CSS_MAX_BQ_GRID_HEIGHT);
|
|
/* Compute the smallest factor. */
|
smallest_factor = MAX_SPEC_DECI_FACT_LOG2;
|
while (ISP_BQ_GRID_WIDTH(width,
|
smallest_factor - 1) <= SH_CSS_MAX_BQ_GRID_WIDTH &&
|
ISP_BQ_GRID_HEIGHT(height, smallest_factor - 1) <= SH_CSS_MAX_BQ_GRID_HEIGHT
|
&& smallest_factor > MIN_SPEC_DECI_FACT_LOG2)
|
smallest_factor--;
|
|
/* Get the factor by the specification. */
|
if (_ISP_BQS(width) >= DECI_FACT_LOG2_5_SMALLEST_FRAME_WIDTH_BQ)
|
spec_factor = 5;
|
else if (_ISP_BQS(width) >= DECI_FACT_LOG2_4_SMALLEST_FRAME_WIDTH_BQ)
|
spec_factor = 4;
|
else
|
spec_factor = 3;
|
|
/* If smallest_factor is smaller than or equal to spec_factor, choose spec_factor to follow the specification.
|
If smallest_factor is larger than spec_factor, choose smallest_factor.
|
|
ex. width=2560, height=1920
|
smallest_factor=4, spec_factor=5
|
smallest_factor < spec_factor -> return spec_factor
|
|
ex. width=300, height=3000
|
smallest_factor=5, spec_factor=3
|
smallest_factor > spec_factor -> return smallest_factor
|
*/
|
return max(smallest_factor, spec_factor);
|
|
#undef MAX_SPEC_DECI_FACT_LOG2
|
#undef MIN_SPEC_DECI_FACT_LOG2
|
#undef DECI_FACT_LOG2_5_SMALLEST_FRAME_WIDTH_BQ
|
#undef DECI_FACT_LOG2_4_SMALLEST_FRAME_WIDTH_BQ
|
}
|
|
static int
|
binary_in_frame_padded_width(int in_frame_width,
|
int isp_internal_width,
|
int dvs_env_width,
|
int stream_config_left_padding,
|
int left_cropping,
|
bool need_scaling)
|
{
|
int rval;
|
int nr_of_left_paddings; /* number of paddings pixels on the left of an image line */
|
|
#if defined(ISP2401)
|
/* the output image line of Input System 2401 does not have the left paddings */
|
nr_of_left_paddings = 0;
|
#else
|
/* in other cases, the left padding pixels are always 128 */
|
nr_of_left_paddings = 2 * ISP_VEC_NELEMS;
|
#endif
|
if (need_scaling) {
|
/* In SDV use-case, we need to match left-padding of
|
* primary and the video binary. */
|
if (stream_config_left_padding != -1) {
|
/* Different than before, we do left&right padding. */
|
rval =
|
CEIL_MUL(in_frame_width + nr_of_left_paddings,
|
2 * ISP_VEC_NELEMS);
|
} else {
|
/* Different than before, we do left&right padding. */
|
in_frame_width += dvs_env_width;
|
rval =
|
CEIL_MUL(in_frame_width +
|
(left_cropping ? nr_of_left_paddings : 0),
|
2 * ISP_VEC_NELEMS);
|
}
|
} else {
|
rval = isp_internal_width;
|
}
|
|
return rval;
|
}
|
|
int
|
ia_css_binary_fill_info(const struct ia_css_binary_xinfo *xinfo,
|
bool online,
|
bool two_ppc,
|
enum atomisp_input_format stream_format,
|
const struct ia_css_frame_info *in_info, /* can be NULL */
|
const struct ia_css_frame_info *bds_out_info, /* can be NULL */
|
const struct ia_css_frame_info *out_info[], /* can be NULL */
|
const struct ia_css_frame_info *vf_info, /* can be NULL */
|
struct ia_css_binary *binary,
|
struct ia_css_resolution *dvs_env,
|
int stream_config_left_padding,
|
bool accelerator) {
|
const struct ia_css_binary_info *info = &xinfo->sp;
|
unsigned int dvs_env_width = 0,
|
dvs_env_height = 0,
|
vf_log_ds = 0,
|
s3a_log_deci = 0,
|
bits_per_pixel = 0,
|
/* Resolution at SC/3A/DIS kernel. */
|
sc_3a_dis_width = 0,
|
/* Resolution at SC/3A/DIS kernel. */
|
sc_3a_dis_padded_width = 0,
|
/* Resolution at SC/3A/DIS kernel. */
|
sc_3a_dis_height = 0,
|
isp_internal_width = 0,
|
isp_internal_height = 0,
|
s3a_isp_width = 0;
|
|
bool need_scaling = false;
|
struct ia_css_resolution binary_dvs_env, internal_res;
|
int err;
|
unsigned int i;
|
const struct ia_css_frame_info *bin_out_info = NULL;
|
|
assert(info);
|
assert(binary);
|
|
binary->info = xinfo;
|
if (!accelerator)
|
{
|
/* binary->css_params has been filled by accelerator itself. */
|
err = ia_css_isp_param_allocate_isp_parameters(
|
&binary->mem_params, &binary->css_params,
|
&info->mem_initializers);
|
if (err) {
|
return err;
|
}
|
}
|
for (i = 0; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
|
{
|
if (out_info[i] && (out_info[i]->res.width != 0)) {
|
bin_out_info = out_info[i];
|
break;
|
}
|
}
|
if (in_info && bin_out_info)
|
{
|
need_scaling = (in_info->res.width != bin_out_info->res.width) ||
|
(in_info->res.height != bin_out_info->res.height);
|
}
|
|
/* binary_dvs_env has to be equal or larger than SH_CSS_MIN_DVS_ENVELOPE */
|
binary_dvs_env.width = 0;
|
binary_dvs_env.height = 0;
|
ia_css_binary_dvs_env(info, dvs_env, &binary_dvs_env);
|
dvs_env_width = binary_dvs_env.width;
|
dvs_env_height = binary_dvs_env.height;
|
binary->dvs_envelope.width = dvs_env_width;
|
binary->dvs_envelope.height = dvs_env_height;
|
|
/* internal resolution calculation */
|
internal_res.width = 0;
|
internal_res.height = 0;
|
ia_css_binary_internal_res(in_info, bds_out_info, bin_out_info, dvs_env,
|
info, &internal_res);
|
isp_internal_width = internal_res.width;
|
isp_internal_height = internal_res.height;
|
|
/* internal frame info */
|
if (bin_out_info) /* { */
|
binary->internal_frame_info.format = bin_out_info->format;
|
/* } */
|
binary->internal_frame_info.res.width = isp_internal_width;
|
binary->internal_frame_info.padded_width = CEIL_MUL(isp_internal_width, 2 * ISP_VEC_NELEMS);
|
binary->internal_frame_info.res.height = isp_internal_height;
|
binary->internal_frame_info.raw_bit_depth = bits_per_pixel;
|
|
if (in_info)
|
{
|
binary->effective_in_frame_res.width = in_info->res.width;
|
binary->effective_in_frame_res.height = in_info->res.height;
|
|
bits_per_pixel = in_info->raw_bit_depth;
|
|
/* input info */
|
binary->in_frame_info.res.width = in_info->res.width +
|
info->pipeline.left_cropping;
|
binary->in_frame_info.res.height = in_info->res.height +
|
info->pipeline.top_cropping;
|
|
binary->in_frame_info.res.width += dvs_env_width;
|
binary->in_frame_info.res.height += dvs_env_height;
|
|
binary->in_frame_info.padded_width =
|
binary_in_frame_padded_width(in_info->res.width,
|
isp_internal_width,
|
dvs_env_width,
|
stream_config_left_padding,
|
info->pipeline.left_cropping,
|
need_scaling);
|
|
binary->in_frame_info.format = in_info->format;
|
binary->in_frame_info.raw_bayer_order = in_info->raw_bayer_order;
|
binary->in_frame_info.crop_info = in_info->crop_info;
|
}
|
|
if (online)
|
{
|
bits_per_pixel = ia_css_util_input_format_bpp(
|
stream_format, two_ppc);
|
}
|
binary->in_frame_info.raw_bit_depth = bits_per_pixel;
|
|
for (i = 0; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
|
{
|
if (out_info[i]) {
|
binary->out_frame_info[i].res.width = out_info[i]->res.width;
|
binary->out_frame_info[i].res.height = out_info[i]->res.height;
|
binary->out_frame_info[i].padded_width = out_info[i]->padded_width;
|
if (info->pipeline.mode == IA_CSS_BINARY_MODE_COPY) {
|
binary->out_frame_info[i].raw_bit_depth = bits_per_pixel;
|
} else {
|
/* Only relevant for RAW format.
|
* At the moment, all outputs are raw, 16 bit per pixel, except for copy.
|
* To do this cleanly, the binary should specify in its info
|
* the bit depth per output channel.
|
*/
|
binary->out_frame_info[i].raw_bit_depth = 16;
|
}
|
binary->out_frame_info[i].format = out_info[i]->format;
|
}
|
}
|
|
if (vf_info && (vf_info->res.width != 0))
|
{
|
err = ia_css_vf_configure(binary, bin_out_info,
|
(struct ia_css_frame_info *)vf_info, &vf_log_ds);
|
if (err) {
|
if (!accelerator) {
|
ia_css_isp_param_destroy_isp_parameters(
|
&binary->mem_params,
|
&binary->css_params);
|
}
|
return err;
|
}
|
}
|
binary->vf_downscale_log2 = vf_log_ds;
|
|
binary->online = online;
|
binary->input_format = stream_format;
|
|
/* viewfinder output info */
|
if ((vf_info) && (vf_info->res.width != 0))
|
{
|
unsigned int vf_out_vecs, vf_out_width, vf_out_height;
|
|
binary->vf_frame_info.format = vf_info->format;
|
if (!bin_out_info)
|
return -EINVAL;
|
vf_out_vecs = __ISP_VF_OUTPUT_WIDTH_VECS(bin_out_info->padded_width,
|
vf_log_ds);
|
vf_out_width = _ISP_VF_OUTPUT_WIDTH(vf_out_vecs);
|
vf_out_height = _ISP_VF_OUTPUT_HEIGHT(bin_out_info->res.height,
|
vf_log_ds);
|
|
/* For preview mode, output pin is used instead of vf. */
|
if (info->pipeline.mode == IA_CSS_BINARY_MODE_PREVIEW) {
|
binary->out_frame_info[0].res.width =
|
(bin_out_info->res.width >> vf_log_ds);
|
binary->out_frame_info[0].padded_width = vf_out_width;
|
binary->out_frame_info[0].res.height = vf_out_height;
|
|
binary->vf_frame_info.res.width = 0;
|
binary->vf_frame_info.padded_width = 0;
|
binary->vf_frame_info.res.height = 0;
|
} else {
|
/* we also store the raw downscaled width. This is
|
* used for digital zoom in preview to zoom only on
|
* the width that we actually want to keep, not on
|
* the aligned width. */
|
binary->vf_frame_info.res.width =
|
(bin_out_info->res.width >> vf_log_ds);
|
binary->vf_frame_info.padded_width = vf_out_width;
|
binary->vf_frame_info.res.height = vf_out_height;
|
}
|
} else
|
{
|
binary->vf_frame_info.res.width = 0;
|
binary->vf_frame_info.padded_width = 0;
|
binary->vf_frame_info.res.height = 0;
|
}
|
|
if (info->enable.ca_gdc)
|
{
|
binary->morph_tbl_width =
|
_ISP_MORPH_TABLE_WIDTH(isp_internal_width);
|
binary->morph_tbl_aligned_width =
|
_ISP_MORPH_TABLE_ALIGNED_WIDTH(isp_internal_width);
|
binary->morph_tbl_height =
|
_ISP_MORPH_TABLE_HEIGHT(isp_internal_height);
|
} else
|
{
|
binary->morph_tbl_width = 0;
|
binary->morph_tbl_aligned_width = 0;
|
binary->morph_tbl_height = 0;
|
}
|
|
sc_3a_dis_width = binary->in_frame_info.res.width;
|
sc_3a_dis_padded_width = binary->in_frame_info.padded_width;
|
sc_3a_dis_height = binary->in_frame_info.res.height;
|
if (bds_out_info && in_info &&
|
bds_out_info->res.width != in_info->res.width)
|
{
|
/* TODO: Next, "internal_frame_info" should be derived from
|
* bds_out. So this part will change once it is in place! */
|
sc_3a_dis_width = bds_out_info->res.width + info->pipeline.left_cropping;
|
sc_3a_dis_padded_width = isp_internal_width;
|
sc_3a_dis_height = isp_internal_height;
|
}
|
|
s3a_isp_width = _ISP_S3A_ELEMS_ISP_WIDTH(sc_3a_dis_padded_width,
|
info->pipeline.left_cropping);
|
if (info->s3a.fixed_s3a_deci_log)
|
{
|
s3a_log_deci = info->s3a.fixed_s3a_deci_log;
|
} else
|
{
|
s3a_log_deci = binary_grid_deci_factor_log2(s3a_isp_width,
|
sc_3a_dis_height);
|
}
|
binary->deci_factor_log2 = s3a_log_deci;
|
|
if (info->enable.s3a)
|
{
|
binary->s3atbl_width =
|
_ISP_S3ATBL_WIDTH(sc_3a_dis_width,
|
s3a_log_deci);
|
binary->s3atbl_height =
|
_ISP_S3ATBL_HEIGHT(sc_3a_dis_height,
|
s3a_log_deci);
|
binary->s3atbl_isp_width =
|
_ISP_S3ATBL_ISP_WIDTH(s3a_isp_width,
|
s3a_log_deci);
|
binary->s3atbl_isp_height =
|
_ISP_S3ATBL_ISP_HEIGHT(sc_3a_dis_height,
|
s3a_log_deci);
|
} else
|
{
|
binary->s3atbl_width = 0;
|
binary->s3atbl_height = 0;
|
binary->s3atbl_isp_width = 0;
|
binary->s3atbl_isp_height = 0;
|
}
|
|
if (info->enable.sc)
|
{
|
if (!IS_ISP2401) {
|
binary->sctbl_width_per_color = _ISP2400_SCTBL_WIDTH_PER_COLOR(sc_3a_dis_padded_width, s3a_log_deci);
|
binary->sctbl_aligned_width_per_color = ISP2400_SH_CSS_MAX_SCTBL_ALIGNED_WIDTH_PER_COLOR;
|
binary->sctbl_height = _ISP2400_SCTBL_HEIGHT(sc_3a_dis_height, s3a_log_deci);
|
} else {
|
binary->sctbl_width_per_color = _ISP2401_SCTBL_WIDTH_PER_COLOR(isp_internal_width, s3a_log_deci);
|
binary->sctbl_aligned_width_per_color = ISP2401_SH_CSS_MAX_SCTBL_ALIGNED_WIDTH_PER_COLOR;
|
binary->sctbl_height = _ISP2401_SCTBL_HEIGHT(isp_internal_height, s3a_log_deci);
|
binary->sctbl_legacy_width_per_color = _ISP_SCTBL_LEGACY_WIDTH_PER_COLOR(sc_3a_dis_padded_width, s3a_log_deci);
|
binary->sctbl_legacy_height = _ISP_SCTBL_LEGACY_HEIGHT(sc_3a_dis_height, s3a_log_deci);
|
}
|
} else
|
{
|
binary->sctbl_width_per_color = 0;
|
binary->sctbl_aligned_width_per_color = 0;
|
binary->sctbl_height = 0;
|
if (IS_ISP2401) {
|
binary->sctbl_legacy_width_per_color = 0;
|
binary->sctbl_legacy_height = 0;
|
}
|
}
|
ia_css_sdis_init_info(&binary->dis,
|
sc_3a_dis_width,
|
sc_3a_dis_padded_width,
|
sc_3a_dis_height,
|
info->pipeline.isp_pipe_version,
|
info->enable.dis);
|
if (info->pipeline.left_cropping)
|
binary->left_padding = 2 * ISP_VEC_NELEMS - info->pipeline.left_cropping;
|
else
|
binary->left_padding = 0;
|
|
return 0;
|
}
|
|
static int __ia_css_binary_find(struct ia_css_binary_descr *descr,
|
struct ia_css_binary *binary) {
|
int mode;
|
bool online;
|
bool two_ppc;
|
enum atomisp_input_format stream_format;
|
const struct ia_css_frame_info *req_in_info,
|
*req_bds_out_info,
|
*req_out_info[IA_CSS_BINARY_MAX_OUTPUT_PORTS],
|
*req_bin_out_info = NULL,
|
*req_vf_info;
|
|
struct ia_css_binary_xinfo *xcandidate;
|
#ifndef ISP2401
|
bool need_ds, need_dz, need_dvs, need_xnr, need_dpc;
|
#else
|
bool need_ds, need_dz, need_dvs, need_xnr, need_dpc, need_tnr;
|
#endif
|
bool striped;
|
bool enable_yuv_ds;
|
bool enable_high_speed;
|
bool enable_dvs_6axis;
|
bool enable_reduced_pipe;
|
bool enable_capture_pp_bli;
|
#ifdef ISP2401
|
bool enable_luma_only;
|
#endif
|
int err = -EINVAL;
|
bool continuous;
|
unsigned int isp_pipe_version;
|
struct ia_css_resolution dvs_env, internal_res;
|
unsigned int i;
|
|
assert(descr);
|
/* MW: used after an error check, may accept NULL, but doubtfull */
|
assert(binary);
|
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() enter: descr=%p, (mode=%d), binary=%p\n",
|
descr, descr->mode,
|
binary);
|
|
mode = descr->mode;
|
online = descr->online;
|
two_ppc = descr->two_ppc;
|
stream_format = descr->stream_format;
|
req_in_info = descr->in_info;
|
req_bds_out_info = descr->bds_out_info;
|
for (i = 0; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
|
{
|
req_out_info[i] = descr->out_info[i];
|
if (req_out_info[i] && (req_out_info[i]->res.width != 0))
|
req_bin_out_info = req_out_info[i];
|
}
|
if (!req_bin_out_info)
|
return -EINVAL;
|
#ifndef ISP2401
|
req_vf_info = descr->vf_info;
|
#else
|
|
if ((descr->vf_info) && (descr->vf_info->res.width == 0))
|
/* width==0 means that there is no vf pin (e.g. in SkyCam preview case) */
|
req_vf_info = NULL;
|
else
|
req_vf_info = descr->vf_info;
|
#endif
|
|
need_xnr = descr->enable_xnr;
|
need_ds = descr->enable_fractional_ds;
|
need_dz = false;
|
need_dvs = false;
|
need_dpc = descr->enable_dpc;
|
#ifdef ISP2401
|
need_tnr = descr->enable_tnr;
|
#endif
|
enable_yuv_ds = descr->enable_yuv_ds;
|
enable_high_speed = descr->enable_high_speed;
|
enable_dvs_6axis = descr->enable_dvs_6axis;
|
enable_reduced_pipe = descr->enable_reduced_pipe;
|
enable_capture_pp_bli = descr->enable_capture_pp_bli;
|
#ifdef ISP2401
|
enable_luma_only = descr->enable_luma_only;
|
#endif
|
continuous = descr->continuous;
|
striped = descr->striped;
|
isp_pipe_version = descr->isp_pipe_version;
|
|
dvs_env.width = 0;
|
dvs_env.height = 0;
|
internal_res.width = 0;
|
internal_res.height = 0;
|
|
if (mode == IA_CSS_BINARY_MODE_VIDEO)
|
{
|
dvs_env = descr->dvs_env;
|
need_dz = descr->enable_dz;
|
/* Video is the only mode that has a nodz variant. */
|
need_dvs = dvs_env.width || dvs_env.height;
|
}
|
|
/* print a map of the binary file */
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "BINARY INFO:\n");
|
for (i = 0; i < IA_CSS_BINARY_NUM_MODES; i++)
|
{
|
xcandidate = binary_infos[i];
|
if (xcandidate) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "%d:\n", i);
|
while (xcandidate) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, " Name:%s Type:%d Cont:%d\n",
|
xcandidate->blob->name, xcandidate->type,
|
xcandidate->sp.enable.continuous);
|
xcandidate = xcandidate->next;
|
}
|
}
|
}
|
|
/* printf("sh_css_binary_find: pipe version %d\n", isp_pipe_version); */
|
for (xcandidate = binary_infos[mode]; xcandidate;
|
xcandidate = xcandidate->next)
|
{
|
struct ia_css_binary_info *candidate = &xcandidate->sp;
|
/* printf("sh_css_binary_find: evaluating candidate:
|
* %d\n",candidate->id); */
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() candidate = %p, mode = %d ID = %d\n",
|
candidate, candidate->pipeline.mode, candidate->id);
|
|
/*
|
* MW: Only a limited set of jointly configured binaries can
|
* be used in a continuous preview/video mode unless it is
|
* the copy mode and runs on SP.
|
*/
|
if (!candidate->enable.continuous &&
|
continuous && (mode != IA_CSS_BINARY_MODE_COPY)) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: !%d && %d && (%d != %d)\n",
|
__LINE__, candidate->enable.continuous,
|
continuous, mode,
|
IA_CSS_BINARY_MODE_COPY);
|
continue;
|
}
|
if (striped && candidate->iterator.num_stripes == 1) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: binary is not striped\n",
|
__LINE__);
|
continue;
|
}
|
|
if (candidate->pipeline.isp_pipe_version != isp_pipe_version &&
|
(mode != IA_CSS_BINARY_MODE_COPY) &&
|
(mode != IA_CSS_BINARY_MODE_CAPTURE_PP) &&
|
(mode != IA_CSS_BINARY_MODE_VF_PP)) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: (%d != %d)\n",
|
__LINE__,
|
candidate->pipeline.isp_pipe_version, isp_pipe_version);
|
continue;
|
}
|
if (!candidate->enable.reduced_pipe && enable_reduced_pipe) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: !%d && %d\n",
|
__LINE__,
|
candidate->enable.reduced_pipe,
|
enable_reduced_pipe);
|
continue;
|
}
|
if (!candidate->enable.dvs_6axis && enable_dvs_6axis) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: !%d && %d\n",
|
__LINE__,
|
candidate->enable.dvs_6axis,
|
enable_dvs_6axis);
|
continue;
|
}
|
if (candidate->enable.high_speed && !enable_high_speed) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: %d && !%d\n",
|
__LINE__,
|
candidate->enable.high_speed,
|
enable_high_speed);
|
continue;
|
}
|
if (!candidate->enable.xnr && need_xnr) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: %d && !%d\n",
|
__LINE__,
|
candidate->enable.xnr,
|
need_xnr);
|
continue;
|
}
|
if (!(candidate->enable.ds & 2) && enable_yuv_ds) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: !%d && %d\n",
|
__LINE__,
|
((candidate->enable.ds & 2) != 0),
|
enable_yuv_ds);
|
continue;
|
}
|
if ((candidate->enable.ds & 2) && !enable_yuv_ds) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: %d && !%d\n",
|
__LINE__,
|
((candidate->enable.ds & 2) != 0),
|
enable_yuv_ds);
|
continue;
|
}
|
|
if (mode == IA_CSS_BINARY_MODE_VIDEO &&
|
candidate->enable.ds && need_ds)
|
need_dz = false;
|
|
/* when we require vf output, we need to have vf_veceven */
|
if ((req_vf_info) && !(candidate->enable.vf_veceven ||
|
/* or variable vf vec even */
|
candidate->vf_dec.is_variable ||
|
/* or more than one output pin. */
|
xcandidate->num_output_pins > 1)) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: (%p != NULL) && !(%d || %d || (%d >%d))\n",
|
__LINE__, req_vf_info,
|
candidate->enable.vf_veceven,
|
candidate->vf_dec.is_variable,
|
xcandidate->num_output_pins, 1);
|
continue;
|
}
|
if (!candidate->enable.dvs_envelope && need_dvs) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: !%d && %d\n",
|
__LINE__,
|
candidate->enable.dvs_envelope, (int)need_dvs);
|
continue;
|
}
|
/* internal_res check considers input, output, and dvs envelope sizes */
|
ia_css_binary_internal_res(req_in_info, req_bds_out_info,
|
req_bin_out_info, &dvs_env, candidate, &internal_res);
|
if (internal_res.width > candidate->internal.max_width) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: (%d > %d)\n",
|
__LINE__, internal_res.width,
|
candidate->internal.max_width);
|
continue;
|
}
|
if (internal_res.height > candidate->internal.max_height) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: (%d > %d)\n",
|
__LINE__, internal_res.height,
|
candidate->internal.max_height);
|
continue;
|
}
|
if (!candidate->enable.ds && need_ds && !(xcandidate->num_output_pins > 1)) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: !%d && %d\n",
|
__LINE__, candidate->enable.ds, (int)need_ds);
|
continue;
|
}
|
if (!candidate->enable.uds && !candidate->enable.dvs_6axis && need_dz) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: !%d && !%d && %d\n",
|
__LINE__, candidate->enable.uds,
|
candidate->enable.dvs_6axis, (int)need_dz);
|
continue;
|
}
|
if (online && candidate->input.source == IA_CSS_BINARY_INPUT_MEMORY) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: %d && (%d == %d)\n",
|
__LINE__, online, candidate->input.source,
|
IA_CSS_BINARY_INPUT_MEMORY);
|
continue;
|
}
|
if (!online && candidate->input.source == IA_CSS_BINARY_INPUT_SENSOR) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: !%d && (%d == %d)\n",
|
__LINE__, online, candidate->input.source,
|
IA_CSS_BINARY_INPUT_SENSOR);
|
continue;
|
}
|
if (req_bin_out_info->res.width < candidate->output.min_width ||
|
req_bin_out_info->res.width > candidate->output.max_width) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: (%d > %d) || (%d < %d)\n",
|
__LINE__,
|
req_bin_out_info->padded_width,
|
candidate->output.min_width,
|
req_bin_out_info->padded_width,
|
candidate->output.max_width);
|
continue;
|
}
|
if (xcandidate->num_output_pins > 1 &&
|
/* in case we have a second output pin, */
|
req_vf_info) { /* and we need vf output. */
|
if (req_vf_info->res.width > candidate->output.max_width) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: (%d < %d)\n",
|
__LINE__,
|
req_vf_info->res.width,
|
candidate->output.max_width);
|
continue;
|
}
|
}
|
if (req_in_info->padded_width > candidate->input.max_width) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: (%d > %d)\n",
|
__LINE__, req_in_info->padded_width,
|
candidate->input.max_width);
|
continue;
|
}
|
if (!binary_supports_output_format(xcandidate, req_bin_out_info->format)) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: !%d\n",
|
__LINE__,
|
binary_supports_output_format(xcandidate, req_bin_out_info->format));
|
continue;
|
}
|
if (xcandidate->num_output_pins > 1 &&
|
/* in case we have a second output pin, */
|
req_vf_info && /* and we need vf output. */
|
/* check if the required vf format
|
is supported. */
|
!binary_supports_output_format(xcandidate, req_vf_info->format)) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: (%d > %d) && (%p != NULL) && !%d\n",
|
__LINE__, xcandidate->num_output_pins, 1,
|
req_vf_info,
|
binary_supports_output_format(xcandidate, req_vf_info->format));
|
continue;
|
}
|
|
/* Check if vf_veceven supports the requested vf format */
|
if (xcandidate->num_output_pins == 1 &&
|
req_vf_info && candidate->enable.vf_veceven &&
|
!binary_supports_vf_format(xcandidate, req_vf_info->format)) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: (%d == %d) && (%p != NULL) && %d && !%d\n",
|
__LINE__, xcandidate->num_output_pins, 1,
|
req_vf_info, candidate->enable.vf_veceven,
|
binary_supports_vf_format(xcandidate, req_vf_info->format));
|
continue;
|
}
|
|
/* Check if vf_veceven supports the requested vf width */
|
if (xcandidate->num_output_pins == 1 &&
|
req_vf_info && candidate->enable.vf_veceven) { /* and we need vf output. */
|
if (req_vf_info->res.width > candidate->output.max_width) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: (%d < %d)\n",
|
__LINE__,
|
req_vf_info->res.width,
|
candidate->output.max_width);
|
continue;
|
}
|
}
|
|
if (!supports_bds_factor(candidate->bds.supported_bds_factors,
|
descr->required_bds_factor)) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: 0x%x & 0x%x)\n",
|
__LINE__, candidate->bds.supported_bds_factors,
|
descr->required_bds_factor);
|
continue;
|
}
|
|
if (!candidate->enable.dpc && need_dpc) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: 0x%x & 0x%x)\n",
|
__LINE__, candidate->enable.dpc,
|
descr->enable_dpc);
|
continue;
|
}
|
|
if (candidate->uds.use_bci && enable_capture_pp_bli) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: 0x%x & 0x%x)\n",
|
__LINE__, candidate->uds.use_bci,
|
descr->enable_capture_pp_bli);
|
continue;
|
}
|
|
#ifdef ISP2401
|
if (candidate->enable.luma_only != enable_luma_only) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: %d != %d\n",
|
__LINE__, candidate->enable.luma_only,
|
descr->enable_luma_only);
|
continue;
|
}
|
|
if (!candidate->enable.tnr && need_tnr) {
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() [%d] continue: !%d && %d\n",
|
__LINE__, candidate->enable.tnr,
|
descr->enable_tnr);
|
continue;
|
}
|
|
#endif
|
/* reconfigure any variable properties of the binary */
|
err = ia_css_binary_fill_info(xcandidate, online, two_ppc,
|
stream_format, req_in_info,
|
req_bds_out_info,
|
req_out_info, req_vf_info,
|
binary, &dvs_env,
|
descr->stream_config_left_padding,
|
false);
|
|
if (err)
|
break;
|
binary_init_metrics(&binary->metrics, &binary->info->sp);
|
break;
|
}
|
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() selected = %p, mode = %d ID = %d\n",
|
xcandidate, xcandidate ? xcandidate->sp.pipeline.mode : 0, xcandidate ? xcandidate->sp.id : 0);
|
|
ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
|
"ia_css_binary_find() leave: return_err=%d\n", err);
|
|
if (!err && xcandidate)
|
dev_dbg(atomisp_dev,
|
"Using binary %s (id %d), type %d, mode %d, continuous %s\n",
|
xcandidate->blob->name,
|
xcandidate->sp.id,
|
xcandidate->type,
|
xcandidate->sp.pipeline.mode,
|
xcandidate->sp.enable.continuous ? "true" : "false");
|
|
|
return err;
|
}
|
|
int ia_css_binary_find(struct ia_css_binary_descr *descr,
|
struct ia_css_binary *binary)
|
{
|
int ret = __ia_css_binary_find(descr, binary);
|
|
if (unlikely(ret)) {
|
dev_dbg(atomisp_dev, "Seeking for binary failed at:");
|
dump_stack();
|
}
|
|
return ret;
|
}
|
|
unsigned
|
ia_css_binary_max_vf_width(void)
|
{
|
/* This is (should be) true for IPU1 and IPU2 */
|
/* For IPU3 (SkyCam) this pointer is guaranteed to be NULL simply because such a binary does not exist */
|
if (binary_infos[IA_CSS_BINARY_MODE_VF_PP])
|
return binary_infos[IA_CSS_BINARY_MODE_VF_PP]->sp.output.max_width;
|
return 0;
|
}
|
|
void
|
ia_css_binary_destroy_isp_parameters(struct ia_css_binary *binary)
|
{
|
if (binary) {
|
ia_css_isp_param_destroy_isp_parameters(&binary->mem_params,
|
&binary->css_params);
|
}
|
}
|
|
void
|
ia_css_binary_get_isp_binaries(struct ia_css_binary_xinfo **binaries,
|
uint32_t *num_isp_binaries)
|
{
|
assert(binaries);
|
|
if (num_isp_binaries)
|
*num_isp_binaries = 0;
|
|
*binaries = all_binaries;
|
if (all_binaries && num_isp_binaries) {
|
/* -1 to account for sp binary which is not stored in all_binaries */
|
if (sh_css_num_binaries > 0)
|
*num_isp_binaries = sh_css_num_binaries - 1;
|
}
|
}
|
