// 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.
 */

/*! \file */
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>

#include "hmm.h"

#include "ia_css.h"
#include "sh_css_hrt.h"         /* only for file 2 MIPI */
#include "ia_css_buffer.h"
#include "ia_css_binary.h"
#include "sh_css_internal.h"
#include "sh_css_mipi.h"
#include "sh_css_sp.h"          /* sh_css_sp_group */
#include "ia_css_isys.h"
#include "ia_css_frame.h"
#include "sh_css_defs.h"
#include "sh_css_firmware.h"
#include "sh_css_params.h"
#include "sh_css_params_internal.h"
#include "sh_css_param_shading.h"
#include "ia_css_refcount.h"
#include "ia_css_rmgr.h"
#include "ia_css_debug.h"
#include "ia_css_debug_pipe.h"
#include "ia_css_device_access.h"
#include "device_access.h"
#include "sh_css_legacy.h"
#include "ia_css_pipeline.h"
#include "ia_css_stream.h"
#include "sh_css_stream_format.h"
#include "ia_css_pipe.h"
#include "ia_css_util.h"
#include "ia_css_pipe_util.h"
#include "ia_css_pipe_binarydesc.h"
#include "ia_css_pipe_stagedesc.h"

#include "tag.h"
#include "assert_support.h"
#include "math_support.h"
#include "sw_event_global.h"                    /* Event IDs.*/
#if !defined(ISP2401)
#include "ia_css_ifmtr.h"
#endif
#include "input_system.h"
#include "mmu_device.h"         /* mmu_set_page_table_base_index(), ... */
#include "ia_css_mmu_private.h" /* sh_css_mmu_set_page_table_base_index() */
#include "gdc_device.h"         /* HRT_GDC_N */
#include "dma.h"                /* dma_set_max_burst_size() */
#include "irq.h"                        /* virq */
#include "sp.h"                         /* cnd_sp_irq_enable() */
#include "isp.h"                        /* cnd_isp_irq_enable, ISP_VEC_NELEMS */
#include "gp_device.h"          /* gp_device_reg_store() */
#define __INLINE_GPIO__
#include "gpio.h"
#include "timed_ctrl.h"
#include "ia_css_inputfifo.h"
#define WITH_PC_MONITORING  0

#define SH_CSS_VIDEO_BUFFER_ALIGNMENT 0

#if WITH_PC_MONITORING
#define MULTIPLE_SAMPLES 1
#define NOF_SAMPLES      60
#include "linux/kthread.h"
#include "linux/sched.h"
#include "linux/delay.h"
#include "sh_css_metrics.h"
static int thread_alive;
#endif /* WITH_PC_MONITORING */

#include "ia_css_spctrl.h"
#include "ia_css_version_data.h"
#include "sh_css_struct.h"
#include "ia_css_bufq.h"
#include "ia_css_timer.h" /* clock_value_t */

#include "isp/modes/interface/input_buf.isp.h"

/* Name of the sp program: should not be built-in */
#define SP_PROG_NAME "sp"
/* Size of Refcount List */
#define REFCOUNT_SIZE 1000

/* for JPEG, we don't know the length of the image upfront,
 * but since we support sensor upto 16MP, we take this as
 * upper limit.
 */
#define JPEG_BYTES (16 * 1024 * 1024)

#define STATS_ENABLED(stage) (stage && stage->binary && stage->binary->info && \
        (stage->binary->info->sp.enable.s3a || stage->binary->info->sp.enable.dis))

struct sh_css my_css;

int  __printf(1, 0) (*sh_css_printf)(const char *fmt, va_list args) = NULL;

/* modes of work: stream_create and stream_destroy will update the save/restore data
   only when in working mode, not suspend/resume
*/
enum ia_sh_css_modes {
        sh_css_mode_none = 0,
        sh_css_mode_working,
        sh_css_mode_suspend,
        sh_css_mode_resume
};

/* a stream seed, to save and restore the stream data.
   the stream seed contains all the data required to "grow" the seed again after it was closed.
*/
struct sh_css_stream_seed {
        struct ia_css_stream
                **orig_stream;                /* pointer to restore the original handle */
        struct ia_css_stream            *stream;                      /* handle, used as ID too.*/
        struct ia_css_stream_config     stream_config;                          /* stream config struct */
        int                             num_pipes;
        struct ia_css_pipe              *pipes[IA_CSS_PIPE_ID_NUM];                     /* pipe handles */
        struct ia_css_pipe
                **orig_pipes[IA_CSS_PIPE_ID_NUM];       /* pointer to restore original handle */
        struct ia_css_pipe_config
                pipe_config[IA_CSS_PIPE_ID_NUM];        /* pipe config structs */
};

#define MAX_ACTIVE_STREAMS      5
/* A global struct for save/restore to hold all the data that should sustain power-down:
   MMU base, IRQ type, env for routines, binary loaded FW and the stream seeds.
*/
struct sh_css_save {
        enum ia_sh_css_modes            mode;
        u32                    mmu_base;                                /* the last mmu_base */
        enum ia_css_irq_type           irq_type;
        struct sh_css_stream_seed      stream_seeds[MAX_ACTIVE_STREAMS];
        struct ia_css_fw               *loaded_fw;                              /* fw struct previously loaded */
        struct ia_css_env              driver_env;                              /* driver-supplied env copy */
};

static bool my_css_save_initialized;    /* if my_css_save was initialized */
static struct sh_css_save my_css_save;

/* pqiao NOTICE: this is for css internal buffer recycling when stopping pipeline,
   this array is temporary and will be replaced by resource manager*/
/* Taking the biggest Size for number of Elements */
#define MAX_HMM_BUFFER_NUM      \
        (SH_CSS_MAX_NUM_QUEUES * (IA_CSS_NUM_ELEMS_SP2HOST_BUFFER_QUEUE + 2))

struct sh_css_hmm_buffer_record {
        bool in_use;
        enum ia_css_buffer_type type;
        struct ia_css_rmgr_vbuf_handle *h_vbuf;
        hrt_address kernel_ptr;
};

static struct sh_css_hmm_buffer_record hmm_buffer_record[MAX_HMM_BUFFER_NUM];

#define GPIO_FLASH_PIN_MASK BIT(HIVE_GPIO_STROBE_TRIGGER_PIN)

static bool fw_explicitly_loaded;

/*
 * Local prototypes
 */

static int
allocate_delay_frames(struct ia_css_pipe *pipe);

static int
sh_css_pipe_start(struct ia_css_stream *stream);

/* ISP 2401 */
/*
 * @brief Stop all "ia_css_pipe" instances in the target
 * "ia_css_stream" instance.
 *
 * @param[in] stream    Point to the target "ia_css_stream" instance.
 *
 * @return
 * - 0, if the "stop" requests have been successfully sent out.
 * - CSS error code, otherwise.
 *
 *
 * NOTE
 * This API sends the "stop" requests to the "ia_css_pipe"
 * instances in the same "ia_css_stream" instance. It will
 * return without waiting for all "ia_css_pipe" instatnces
 * being stopped.
 */
static int
sh_css_pipes_stop(struct ia_css_stream *stream);

/*
 * @brief Check if all "ia_css_pipe" instances in the target
 * "ia_css_stream" instance have stopped.
 *
 * @param[in] stream    Point to the target "ia_css_stream" instance.
 *
 * @return
 * - true, if all "ia_css_pipe" instances in the target "ia_css_stream"
 *   instance have ben stopped.
 * - false, otherwise.
 */
/* ISP 2401 */
static bool
sh_css_pipes_have_stopped(struct ia_css_stream *stream);

/* ISP 2401 */
static int
ia_css_pipe_check_format(struct ia_css_pipe *pipe,
                         enum ia_css_frame_format format);

/* ISP 2401 */
static int
check_pipe_resolutions(const struct ia_css_pipe *pipe);

static int
ia_css_pipe_load_extension(struct ia_css_pipe *pipe,
                           struct ia_css_fw_info *firmware);

static void
ia_css_pipe_unload_extension(struct ia_css_pipe *pipe,
                             struct ia_css_fw_info *firmware);
static void
ia_css_reset_defaults(struct sh_css *css);

static void
sh_css_init_host_sp_control_vars(void);

static int
set_num_primary_stages(unsigned int *num, enum ia_css_pipe_version version);

static bool
need_capture_pp(const struct ia_css_pipe *pipe);

static bool
need_yuv_scaler_stage(const struct ia_css_pipe *pipe);

static int ia_css_pipe_create_cas_scaler_desc_single_output(
    struct ia_css_frame_info *cas_scaler_in_info,
    struct ia_css_frame_info *cas_scaler_out_info,
    struct ia_css_frame_info *cas_scaler_vf_info,
    struct ia_css_cas_binary_descr *descr);

static void ia_css_pipe_destroy_cas_scaler_desc(struct ia_css_cas_binary_descr
        *descr);

static bool
need_downscaling(const struct ia_css_resolution in_res,
                 const struct ia_css_resolution out_res);

static bool need_capt_ldc(const struct ia_css_pipe *pipe);

static int
sh_css_pipe_load_binaries(struct ia_css_pipe *pipe);

static
int sh_css_pipe_get_viewfinder_frame_info(
    struct ia_css_pipe *pipe,
    struct ia_css_frame_info *info,
    unsigned int idx);

static int
sh_css_pipe_get_output_frame_info(struct ia_css_pipe *pipe,
                                  struct ia_css_frame_info *info,
                                  unsigned int idx);

static int
capture_start(struct ia_css_pipe *pipe);

static int
video_start(struct ia_css_pipe *pipe);

static int
preview_start(struct ia_css_pipe *pipe);

static int
yuvpp_start(struct ia_css_pipe *pipe);

static bool copy_on_sp(struct ia_css_pipe *pipe);

static int
init_vf_frameinfo_defaults(struct ia_css_pipe *pipe,
                           struct ia_css_frame *vf_frame, unsigned int idx);

static int
init_in_frameinfo_memory_defaults(struct ia_css_pipe *pipe,
                                  struct ia_css_frame *frame, enum ia_css_frame_format format);

static int
init_out_frameinfo_defaults(struct ia_css_pipe *pipe,
                            struct ia_css_frame *out_frame, unsigned int idx);

static int
sh_css_pipeline_add_acc_stage(struct ia_css_pipeline *pipeline,
                              const void *acc_fw);

static int
alloc_continuous_frames(struct ia_css_pipe *pipe, bool init_time);

static void
pipe_global_init(void);

static int
pipe_generate_pipe_num(const struct ia_css_pipe *pipe,
                       unsigned int *pipe_number);

static void
pipe_release_pipe_num(unsigned int pipe_num);

static int
create_host_pipeline_structure(struct ia_css_stream *stream);

static int
create_host_pipeline(struct ia_css_stream *stream);

static int
create_host_preview_pipeline(struct ia_css_pipe *pipe);

static int
create_host_video_pipeline(struct ia_css_pipe *pipe);

static int
create_host_copy_pipeline(struct ia_css_pipe *pipe,
                          unsigned int max_input_width,
                          struct ia_css_frame *out_frame);

static int
create_host_isyscopy_capture_pipeline(struct ia_css_pipe *pipe);

static int
create_host_capture_pipeline(struct ia_css_pipe *pipe);

static int
create_host_yuvpp_pipeline(struct ia_css_pipe *pipe);

static int
create_host_acc_pipeline(struct ia_css_pipe *pipe);

static unsigned int
sh_css_get_sw_interrupt_value(unsigned int irq);

static struct ia_css_binary *ia_css_pipe_get_shading_correction_binary(
    const struct ia_css_pipe *pipe);

static struct ia_css_binary *
ia_css_pipe_get_s3a_binary(const struct ia_css_pipe *pipe);

static struct ia_css_binary *
ia_css_pipe_get_sdis_binary(const struct ia_css_pipe *pipe);

static void
sh_css_hmm_buffer_record_init(void);

static void
sh_css_hmm_buffer_record_uninit(void);

static void
sh_css_hmm_buffer_record_reset(struct sh_css_hmm_buffer_record *buffer_record);

static struct sh_css_hmm_buffer_record
*sh_css_hmm_buffer_record_acquire(struct ia_css_rmgr_vbuf_handle *h_vbuf,
                                  enum ia_css_buffer_type type,
                                  hrt_address kernel_ptr);

static struct sh_css_hmm_buffer_record
*sh_css_hmm_buffer_record_validate(ia_css_ptr ddr_buffer_addr,
                                   enum ia_css_buffer_type type);

void
ia_css_get_acc_configs(
    struct ia_css_pipe *pipe,
    struct ia_css_isp_config *config);

#if CONFIG_ON_FRAME_ENQUEUE()
static int set_config_on_frame_enqueue(struct ia_css_frame_info
        *info, struct frame_data_wrapper *frame);
#endif

#ifdef ISP2401
static unsigned int get_crop_lines_for_bayer_order(const struct
        ia_css_stream_config *config);
static unsigned int get_crop_columns_for_bayer_order(const struct
        ia_css_stream_config *config);
static void get_pipe_extra_pixel(struct ia_css_pipe *pipe,
                                 unsigned int *extra_row, unsigned int *extra_column);
static int
aspect_ratio_crop_init(struct ia_css_stream *curr_stream,
                       struct ia_css_pipe *pipes[],
                       bool *do_crop_status);

static bool
aspect_ratio_crop_check(bool enabled, struct ia_css_pipe *curr_pipe);

static int
aspect_ratio_crop(struct ia_css_pipe *curr_pipe,
                  struct ia_css_resolution *effective_res);
#endif

static void
sh_css_pipe_free_shading_table(struct ia_css_pipe *pipe)
{
        if (!pipe) {
                IA_CSS_ERROR("NULL input parameter");
                return;
        }

        if (pipe->shading_table)
                ia_css_shading_table_free(pipe->shading_table);
        pipe->shading_table = NULL;
}

static enum ia_css_frame_format yuv420_copy_formats[] = {
        IA_CSS_FRAME_FORMAT_NV12,
        IA_CSS_FRAME_FORMAT_NV21,
        IA_CSS_FRAME_FORMAT_YV12,
        IA_CSS_FRAME_FORMAT_YUV420,
        IA_CSS_FRAME_FORMAT_YUV420_16,
        IA_CSS_FRAME_FORMAT_CSI_MIPI_YUV420_8,
        IA_CSS_FRAME_FORMAT_CSI_MIPI_LEGACY_YUV420_8
};

static enum ia_css_frame_format yuv422_copy_formats[] = {
        IA_CSS_FRAME_FORMAT_NV12,
        IA_CSS_FRAME_FORMAT_NV16,
        IA_CSS_FRAME_FORMAT_NV21,
        IA_CSS_FRAME_FORMAT_NV61,
        IA_CSS_FRAME_FORMAT_YV12,
        IA_CSS_FRAME_FORMAT_YV16,
        IA_CSS_FRAME_FORMAT_YUV420,
        IA_CSS_FRAME_FORMAT_YUV420_16,
        IA_CSS_FRAME_FORMAT_YUV422,
        IA_CSS_FRAME_FORMAT_YUV422_16,
        IA_CSS_FRAME_FORMAT_UYVY,
        IA_CSS_FRAME_FORMAT_YUYV
};

/* Verify whether the selected output format is can be produced
 * by the copy binary given the stream format.
 * */
static int
verify_copy_out_frame_format(struct ia_css_pipe *pipe)
{
        enum ia_css_frame_format out_fmt = pipe->output_info[0].format;
        unsigned int i, found = 0;

        assert(pipe);
        assert(pipe->stream);

        switch (pipe->stream->config.input_config.format) {
        case ATOMISP_INPUT_FORMAT_YUV420_8_LEGACY:
        case ATOMISP_INPUT_FORMAT_YUV420_8:
                for (i = 0; i < ARRAY_SIZE(yuv420_copy_formats) && !found; i++)
                        found = (out_fmt == yuv420_copy_formats[i]);
                break;
        case ATOMISP_INPUT_FORMAT_YUV420_10:
        case ATOMISP_INPUT_FORMAT_YUV420_16:
                found = (out_fmt == IA_CSS_FRAME_FORMAT_YUV420_16);
                break;
        case ATOMISP_INPUT_FORMAT_YUV422_8:
                for (i = 0; i < ARRAY_SIZE(yuv422_copy_formats) && !found; i++)
                        found = (out_fmt == yuv422_copy_formats[i]);
                break;
        case ATOMISP_INPUT_FORMAT_YUV422_10:
        case ATOMISP_INPUT_FORMAT_YUV422_16:
                found = (out_fmt == IA_CSS_FRAME_FORMAT_YUV422_16 ||
                         out_fmt == IA_CSS_FRAME_FORMAT_YUV420_16);
                break;
        case ATOMISP_INPUT_FORMAT_RGB_444:
        case ATOMISP_INPUT_FORMAT_RGB_555:
        case ATOMISP_INPUT_FORMAT_RGB_565:
                found = (out_fmt == IA_CSS_FRAME_FORMAT_RGBA888 ||
                         out_fmt == IA_CSS_FRAME_FORMAT_RGB565);
                break;
        case ATOMISP_INPUT_FORMAT_RGB_666:
        case ATOMISP_INPUT_FORMAT_RGB_888:
                found = (out_fmt == IA_CSS_FRAME_FORMAT_RGBA888 ||
                         out_fmt == IA_CSS_FRAME_FORMAT_YUV420);
                break;
        case ATOMISP_INPUT_FORMAT_RAW_6:
        case ATOMISP_INPUT_FORMAT_RAW_7:
        case ATOMISP_INPUT_FORMAT_RAW_8:
        case ATOMISP_INPUT_FORMAT_RAW_10:
        case ATOMISP_INPUT_FORMAT_RAW_12:
        case ATOMISP_INPUT_FORMAT_RAW_14:
        case ATOMISP_INPUT_FORMAT_RAW_16:
                found = (out_fmt == IA_CSS_FRAME_FORMAT_RAW) ||
                (out_fmt == IA_CSS_FRAME_FORMAT_RAW_PACKED);
                break;
        case ATOMISP_INPUT_FORMAT_BINARY_8:
                found = (out_fmt == IA_CSS_FRAME_FORMAT_BINARY_8);
                break;
        default:
                break;
        }
        if (!found)
                return -EINVAL;
        return 0;
}

unsigned int
ia_css_stream_input_format_bits_per_pixel(struct ia_css_stream *stream)
{
        int bpp = 0;

        if (stream)
                bpp = ia_css_util_input_format_bpp(stream->config.input_config.format,
                                                   stream->config.pixels_per_clock == 2);

        return bpp;
}

#define GP_ISEL_TPG_MODE 0x90058

#if !defined(ISP2401)
static int
sh_css_config_input_network(struct ia_css_stream *stream)
{
        unsigned int fmt_type;
        struct ia_css_pipe *pipe = stream->last_pipe;
        struct ia_css_binary *binary = NULL;
        int err = 0;

        assert(stream);
        assert(pipe);

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                            "sh_css_config_input_network() enter:\n");

        if (pipe->pipeline.stages)
                binary = pipe->pipeline.stages->binary;

        err = ia_css_isys_convert_stream_format_to_mipi_format(
            stream->config.input_config.format,
            stream->csi_rx_config.comp,
            &fmt_type);
        if (err)
                return err;
        sh_css_sp_program_input_circuit(fmt_type,
                                        stream->config.channel_id,
                                        stream->config.mode);

        if ((binary && (binary->online || stream->config.continuous)) ||
            pipe->config.mode == IA_CSS_PIPE_MODE_COPY) {
                err = ia_css_ifmtr_configure(&stream->config,
                                             binary);
                if (err)
                        return err;
        }

        if (stream->config.mode == IA_CSS_INPUT_MODE_TPG ||
            stream->config.mode == IA_CSS_INPUT_MODE_PRBS) {
                unsigned int hblank_cycles = 100,
                vblank_lines = 6,
                width,
                height,
                vblank_cycles;
                width  = (stream->config.input_config.input_res.width) / (1 +
                        (stream->config.pixels_per_clock == 2));
                height = stream->config.input_config.input_res.height;
                vblank_cycles = vblank_lines * (width + hblank_cycles);
                sh_css_sp_configure_sync_gen(width, height, hblank_cycles,
                                             vblank_cycles);
                if (!IS_ISP2401) {
                        if (pipe->stream->config.mode == IA_CSS_INPUT_MODE_TPG) {
                                /* TODO: move define to proper file in tools */
                                ia_css_device_store_uint32(GP_ISEL_TPG_MODE, 0);
                        }
                }
        }
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                            "sh_css_config_input_network() leave:\n");
        return 0;
}
#elif defined(ISP2401)
static unsigned int csi2_protocol_calculate_max_subpixels_per_line(
    enum atomisp_input_format   format,
    unsigned int                        pixels_per_line)
{
        unsigned int rval;

        switch (format) {
        case ATOMISP_INPUT_FORMAT_YUV420_8_LEGACY:
                /*
                 * The frame format layout is shown below.
                 *
                 *              Line    0:      UYY0 UYY0 ... UYY0
                 *              Line    1:      VYY0 VYY0 ... VYY0
                 *              Line    2:      UYY0 UYY0 ... UYY0
                 *              Line    3:      VYY0 VYY0 ... VYY0
                 *              ...
                 *              Line (n-2):     UYY0 UYY0 ... UYY0
                 *              Line (n-1):     VYY0 VYY0 ... VYY0
                 *
                 *      In this frame format, the even-line is
                 *      as wide as the odd-line.
                 *      The 0 is introduced by the input system
                 *      (mipi backend).
                 */
                rval = pixels_per_line * 2;
                break;
        case ATOMISP_INPUT_FORMAT_YUV420_8:
        case ATOMISP_INPUT_FORMAT_YUV420_10:
        case ATOMISP_INPUT_FORMAT_YUV420_16:
                /*
                 * The frame format layout is shown below.
                 *
                 *              Line    0:      YYYY YYYY ... YYYY
                 *              Line    1:      UYVY UYVY ... UYVY UYVY
                 *              Line    2:      YYYY YYYY ... YYYY
                 *              Line    3:      UYVY UYVY ... UYVY UYVY
                 *              ...
                 *              Line (n-2):     YYYY YYYY ... YYYY
                 *              Line (n-1):     UYVY UYVY ... UYVY UYVY
                 *
                 * In this frame format, the odd-line is twice
                 * wider than the even-line.
                 */
                rval = pixels_per_line * 2;
                break;
        case ATOMISP_INPUT_FORMAT_YUV422_8:
        case ATOMISP_INPUT_FORMAT_YUV422_10:
        case ATOMISP_INPUT_FORMAT_YUV422_16:
                /*
                 * The frame format layout is shown below.
                 *
                 *              Line    0:      UYVY UYVY ... UYVY
                 *              Line    1:      UYVY UYVY ... UYVY
                 *              Line    2:      UYVY UYVY ... UYVY
                 *              Line    3:      UYVY UYVY ... UYVY
                 *              ...
                 *              Line (n-2):     UYVY UYVY ... UYVY
                 *              Line (n-1):     UYVY UYVY ... UYVY
                 *
                 * In this frame format, the even-line is
                 * as wide as the odd-line.
                 */
                rval = pixels_per_line * 2;
                break;
        case ATOMISP_INPUT_FORMAT_RGB_444:
        case ATOMISP_INPUT_FORMAT_RGB_555:
        case ATOMISP_INPUT_FORMAT_RGB_565:
        case ATOMISP_INPUT_FORMAT_RGB_666:
        case ATOMISP_INPUT_FORMAT_RGB_888:
                /*
                 * The frame format layout is shown below.
                 *
                 *              Line    0:      ABGR ABGR ... ABGR
                 *              Line    1:      ABGR ABGR ... ABGR
                 *              Line    2:      ABGR ABGR ... ABGR
                 *              Line    3:      ABGR ABGR ... ABGR
                 *              ...
                 *              Line (n-2):     ABGR ABGR ... ABGR
                 *              Line (n-1):     ABGR ABGR ... ABGR
                 *
                 * In this frame format, the even-line is
                 * as wide as the odd-line.
                 */
                rval = pixels_per_line * 4;
                break;
        case ATOMISP_INPUT_FORMAT_RAW_6:
        case ATOMISP_INPUT_FORMAT_RAW_7:
        case ATOMISP_INPUT_FORMAT_RAW_8:
        case ATOMISP_INPUT_FORMAT_RAW_10:
        case ATOMISP_INPUT_FORMAT_RAW_12:
        case ATOMISP_INPUT_FORMAT_RAW_14:
        case ATOMISP_INPUT_FORMAT_RAW_16:
        case ATOMISP_INPUT_FORMAT_BINARY_8:
        case ATOMISP_INPUT_FORMAT_USER_DEF1:
        case ATOMISP_INPUT_FORMAT_USER_DEF2:
        case ATOMISP_INPUT_FORMAT_USER_DEF3:
        case ATOMISP_INPUT_FORMAT_USER_DEF4:
        case ATOMISP_INPUT_FORMAT_USER_DEF5:
        case ATOMISP_INPUT_FORMAT_USER_DEF6:
        case ATOMISP_INPUT_FORMAT_USER_DEF7:
        case ATOMISP_INPUT_FORMAT_USER_DEF8:
                /*
                 * The frame format layout is shown below.
                 *
                 *              Line    0:      Pixel Pixel ... Pixel
                 *              Line    1:      Pixel Pixel ... Pixel
                 *              Line    2:      Pixel Pixel ... Pixel
                 *              Line    3:      Pixel Pixel ... Pixel
                 *              ...
                 *              Line (n-2):     Pixel Pixel ... Pixel
                 *              Line (n-1):     Pixel Pixel ... Pixel
                 *
                 * In this frame format, the even-line is
                 * as wide as the odd-line.
                 */
                rval = pixels_per_line;
                break;
        default:
                rval = 0;
                break;
        }

        return rval;
}

static bool sh_css_translate_stream_cfg_to_input_system_input_port_id(
    struct ia_css_stream_config *stream_cfg,
    ia_css_isys_descr_t *isys_stream_descr)
{
        bool rc;

        rc = true;
        switch (stream_cfg->mode) {
        case IA_CSS_INPUT_MODE_TPG:

                if (stream_cfg->source.tpg.id == IA_CSS_TPG_ID0)
                        isys_stream_descr->input_port_id = INPUT_SYSTEM_PIXELGEN_PORT0_ID;
                else if (stream_cfg->source.tpg.id == IA_CSS_TPG_ID1)
                        isys_stream_descr->input_port_id = INPUT_SYSTEM_PIXELGEN_PORT1_ID;
                else if (stream_cfg->source.tpg.id == IA_CSS_TPG_ID2)
                        isys_stream_descr->input_port_id = INPUT_SYSTEM_PIXELGEN_PORT2_ID;

                break;
        case IA_CSS_INPUT_MODE_PRBS:

                if (stream_cfg->source.prbs.id == IA_CSS_PRBS_ID0)
                        isys_stream_descr->input_port_id = INPUT_SYSTEM_PIXELGEN_PORT0_ID;
                else if (stream_cfg->source.prbs.id == IA_CSS_PRBS_ID1)
                        isys_stream_descr->input_port_id = INPUT_SYSTEM_PIXELGEN_PORT1_ID;
                else if (stream_cfg->source.prbs.id == IA_CSS_PRBS_ID2)
                        isys_stream_descr->input_port_id = INPUT_SYSTEM_PIXELGEN_PORT2_ID;

                break;
        case IA_CSS_INPUT_MODE_BUFFERED_SENSOR:

                if (stream_cfg->source.port.port == MIPI_PORT0_ID)
                        isys_stream_descr->input_port_id = INPUT_SYSTEM_CSI_PORT0_ID;
                else if (stream_cfg->source.port.port == MIPI_PORT1_ID)
                        isys_stream_descr->input_port_id = INPUT_SYSTEM_CSI_PORT1_ID;
                else if (stream_cfg->source.port.port == MIPI_PORT2_ID)
                        isys_stream_descr->input_port_id = INPUT_SYSTEM_CSI_PORT2_ID;

                break;
        default:
                rc = false;
                break;
        }

        return rc;
}

static bool sh_css_translate_stream_cfg_to_input_system_input_port_type(
    struct ia_css_stream_config *stream_cfg,
    ia_css_isys_descr_t *isys_stream_descr)
{
        bool rc;

        rc = true;
        switch (stream_cfg->mode) {
        case IA_CSS_INPUT_MODE_TPG:

                isys_stream_descr->mode = INPUT_SYSTEM_SOURCE_TYPE_TPG;

                break;
        case IA_CSS_INPUT_MODE_PRBS:

                isys_stream_descr->mode = INPUT_SYSTEM_SOURCE_TYPE_PRBS;

                break;
        case IA_CSS_INPUT_MODE_SENSOR:
        case IA_CSS_INPUT_MODE_BUFFERED_SENSOR:

                isys_stream_descr->mode = INPUT_SYSTEM_SOURCE_TYPE_SENSOR;
                break;

        default:
                rc = false;
                break;
        }

        return rc;
}

static bool sh_css_translate_stream_cfg_to_input_system_input_port_attr(
    struct ia_css_stream_config *stream_cfg,
    ia_css_isys_descr_t *isys_stream_descr,
    int isys_stream_idx)
{
        bool rc;

        rc = true;
        switch (stream_cfg->mode) {
        case IA_CSS_INPUT_MODE_TPG:
                if (stream_cfg->source.tpg.mode == IA_CSS_TPG_MODE_RAMP)
                        isys_stream_descr->tpg_port_attr.mode = PIXELGEN_TPG_MODE_RAMP;
                else if (stream_cfg->source.tpg.mode == IA_CSS_TPG_MODE_CHECKERBOARD)
                        isys_stream_descr->tpg_port_attr.mode = PIXELGEN_TPG_MODE_CHBO;
                else if (stream_cfg->source.tpg.mode == IA_CSS_TPG_MODE_MONO)
                        isys_stream_descr->tpg_port_attr.mode = PIXELGEN_TPG_MODE_MONO;
                else
                        rc = false;

                /*
                 * TODO
                 * - Make "color_cfg" as part of "ia_css_tpg_config".
                 */
                isys_stream_descr->tpg_port_attr.color_cfg.R1 = 51;
                isys_stream_descr->tpg_port_attr.color_cfg.G1 = 102;
                isys_stream_descr->tpg_port_attr.color_cfg.B1 = 255;
                isys_stream_descr->tpg_port_attr.color_cfg.R2 = 0;
                isys_stream_descr->tpg_port_attr.color_cfg.G2 = 100;
                isys_stream_descr->tpg_port_attr.color_cfg.B2 = 160;

                isys_stream_descr->tpg_port_attr.mask_cfg.h_mask =
                    stream_cfg->source.tpg.x_mask;
                isys_stream_descr->tpg_port_attr.mask_cfg.v_mask =
                    stream_cfg->source.tpg.y_mask;
                isys_stream_descr->tpg_port_attr.mask_cfg.hv_mask =
                    stream_cfg->source.tpg.xy_mask;

                isys_stream_descr->tpg_port_attr.delta_cfg.h_delta =
                    stream_cfg->source.tpg.x_delta;
                isys_stream_descr->tpg_port_attr.delta_cfg.v_delta =
                    stream_cfg->source.tpg.y_delta;

                /*
                 * TODO
                 * - Make "sync_gen_cfg" as part of "ia_css_tpg_config".
                 */
                isys_stream_descr->tpg_port_attr.sync_gen_cfg.hblank_cycles = 100;
                isys_stream_descr->tpg_port_attr.sync_gen_cfg.vblank_cycles = 100;
                isys_stream_descr->tpg_port_attr.sync_gen_cfg.pixels_per_clock =
                    stream_cfg->pixels_per_clock;
                isys_stream_descr->tpg_port_attr.sync_gen_cfg.nr_of_frames = (uint32_t)~(0x0);
                isys_stream_descr->tpg_port_attr.sync_gen_cfg.pixels_per_line =
                    stream_cfg->isys_config[IA_CSS_STREAM_DEFAULT_ISYS_STREAM_IDX].input_res.width;
                isys_stream_descr->tpg_port_attr.sync_gen_cfg.lines_per_frame =
                    stream_cfg->isys_config[IA_CSS_STREAM_DEFAULT_ISYS_STREAM_IDX].input_res.height;

                break;
        case IA_CSS_INPUT_MODE_PRBS:

                isys_stream_descr->prbs_port_attr.seed0 = stream_cfg->source.prbs.seed;
                isys_stream_descr->prbs_port_attr.seed1 = stream_cfg->source.prbs.seed1;

                /*
                 * TODO
                 * - Make "sync_gen_cfg" as part of "ia_css_prbs_config".
                 */
                isys_stream_descr->prbs_port_attr.sync_gen_cfg.hblank_cycles = 100;
                isys_stream_descr->prbs_port_attr.sync_gen_cfg.vblank_cycles = 100;
                isys_stream_descr->prbs_port_attr.sync_gen_cfg.pixels_per_clock =
                    stream_cfg->pixels_per_clock;
                isys_stream_descr->prbs_port_attr.sync_gen_cfg.nr_of_frames = (uint32_t)~(0x0);
                isys_stream_descr->prbs_port_attr.sync_gen_cfg.pixels_per_line =
                    stream_cfg->isys_config[IA_CSS_STREAM_DEFAULT_ISYS_STREAM_IDX].input_res.width;
                isys_stream_descr->prbs_port_attr.sync_gen_cfg.lines_per_frame =
                    stream_cfg->isys_config[IA_CSS_STREAM_DEFAULT_ISYS_STREAM_IDX].input_res.height;

                break;
        case IA_CSS_INPUT_MODE_BUFFERED_SENSOR: {
                int err;
                unsigned int fmt_type;

                err = ia_css_isys_convert_stream_format_to_mipi_format(
                          stream_cfg->isys_config[isys_stream_idx].format,
                          MIPI_PREDICTOR_NONE,
                          &fmt_type);
                if (err)
                        rc = false;

                isys_stream_descr->csi_port_attr.active_lanes =
                    stream_cfg->source.port.num_lanes;
                isys_stream_descr->csi_port_attr.fmt_type = fmt_type;
                isys_stream_descr->csi_port_attr.ch_id = stream_cfg->channel_id;
#ifdef ISP2401
                isys_stream_descr->online = stream_cfg->online;
#endif
                err |= ia_css_isys_convert_compressed_format(
                           &stream_cfg->source.port.compression,
                           isys_stream_descr);
                if (err)
                        rc = false;

                /* metadata */
                isys_stream_descr->metadata.enable = false;
                if (stream_cfg->metadata_config.resolution.height > 0) {
                        err = ia_css_isys_convert_stream_format_to_mipi_format(
                                  stream_cfg->metadata_config.data_type,
                                  MIPI_PREDICTOR_NONE,
                                  &fmt_type);
                        if (err)
                                rc = false;
                        isys_stream_descr->metadata.fmt_type = fmt_type;
                        isys_stream_descr->metadata.bits_per_pixel =
                            ia_css_util_input_format_bpp(stream_cfg->metadata_config.data_type, true);
                        isys_stream_descr->metadata.pixels_per_line =
                            stream_cfg->metadata_config.resolution.width;
                        isys_stream_descr->metadata.lines_per_frame =
                            stream_cfg->metadata_config.resolution.height;
#ifdef ISP2401
                        /* For new input system, number of str2mmio requests must be even.
                         * So we round up number of metadata lines to be even. */
                        if (isys_stream_descr->metadata.lines_per_frame > 0)
                                isys_stream_descr->metadata.lines_per_frame +=
                                    (isys_stream_descr->metadata.lines_per_frame & 1);
#endif
                        isys_stream_descr->metadata.align_req_in_bytes =
                            ia_css_csi2_calculate_input_system_alignment(
                                stream_cfg->metadata_config.data_type);
                        isys_stream_descr->metadata.enable = true;
                }

                break;
        }
        default:
                rc = false;
                break;
        }

        return rc;
}

static bool sh_css_translate_stream_cfg_to_input_system_input_port_resolution(
    struct ia_css_stream_config *stream_cfg,
    ia_css_isys_descr_t *isys_stream_descr,
    int isys_stream_idx)
{
        unsigned int bits_per_subpixel;
        unsigned int max_subpixels_per_line;
        unsigned int lines_per_frame;
        unsigned int align_req_in_bytes;
        enum atomisp_input_format fmt_type;

        fmt_type = stream_cfg->isys_config[isys_stream_idx].format;
        if ((stream_cfg->mode == IA_CSS_INPUT_MODE_SENSOR ||
             stream_cfg->mode == IA_CSS_INPUT_MODE_BUFFERED_SENSOR) &&
            stream_cfg->source.port.compression.type != IA_CSS_CSI2_COMPRESSION_TYPE_NONE) {
                if (stream_cfg->source.port.compression.uncompressed_bits_per_pixel ==
                    UNCOMPRESSED_BITS_PER_PIXEL_10)
                        fmt_type = ATOMISP_INPUT_FORMAT_RAW_10;
                else if (stream_cfg->source.port.compression.uncompressed_bits_per_pixel ==
                           UNCOMPRESSED_BITS_PER_PIXEL_12)
                        fmt_type = ATOMISP_INPUT_FORMAT_RAW_12;
                else
                        return false;
        }

        bits_per_subpixel =
            sh_css_stream_format_2_bits_per_subpixel(fmt_type);
        if (bits_per_subpixel == 0)
                return false;

        max_subpixels_per_line =
            csi2_protocol_calculate_max_subpixels_per_line(fmt_type,
                    stream_cfg->isys_config[isys_stream_idx].input_res.width);
        if (max_subpixels_per_line == 0)
                return false;

        lines_per_frame = stream_cfg->isys_config[isys_stream_idx].input_res.height;
        if (lines_per_frame == 0)
                return false;

        align_req_in_bytes = ia_css_csi2_calculate_input_system_alignment(fmt_type);

        /* HW needs subpixel info for their settings */
        isys_stream_descr->input_port_resolution.bits_per_pixel = bits_per_subpixel;
        isys_stream_descr->input_port_resolution.pixels_per_line =
            max_subpixels_per_line;
        isys_stream_descr->input_port_resolution.lines_per_frame = lines_per_frame;
        isys_stream_descr->input_port_resolution.align_req_in_bytes =
            align_req_in_bytes;

        return true;
}

static bool sh_css_translate_stream_cfg_to_isys_stream_descr(
    struct ia_css_stream_config *stream_cfg,
    bool early_polling,
    ia_css_isys_descr_t *isys_stream_descr,
    int isys_stream_idx)
{
        bool rc;

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                            "sh_css_translate_stream_cfg_to_isys_stream_descr() enter:\n");
        rc  = sh_css_translate_stream_cfg_to_input_system_input_port_id(stream_cfg,
                isys_stream_descr);
        rc &= sh_css_translate_stream_cfg_to_input_system_input_port_type(stream_cfg,
                isys_stream_descr);
        rc &= sh_css_translate_stream_cfg_to_input_system_input_port_attr(stream_cfg,
                isys_stream_descr, isys_stream_idx);
        rc &= sh_css_translate_stream_cfg_to_input_system_input_port_resolution(

                  stream_cfg, isys_stream_descr, isys_stream_idx);

        isys_stream_descr->raw_packed = stream_cfg->pack_raw_pixels;
        isys_stream_descr->linked_isys_stream_id = (int8_t)
                stream_cfg->isys_config[isys_stream_idx].linked_isys_stream_id;
        /*
         * Early polling is required for timestamp accuracy in certain case.
         * The ISYS HW polling is started on
         * ia_css_isys_stream_capture_indication() instead of
         * ia_css_pipeline_sp_wait_for_isys_stream_N() as isp processing of
         * capture takes longer than getting an ISYS frame
         *
         * Only 2401 relevant ??
         */
#if 0 // FIXME: NOT USED on Yocto Aero
        isys_stream_descr->polling_mode
            = early_polling ? INPUT_SYSTEM_POLL_ON_CAPTURE_REQUEST
              : INPUT_SYSTEM_POLL_ON_WAIT_FOR_FRAME;
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                            "sh_css_translate_stream_cfg_to_isys_stream_descr() leave:\n");
#endif

        return rc;
}

static bool sh_css_translate_binary_info_to_input_system_output_port_attr(
    struct ia_css_binary *binary,
    ia_css_isys_descr_t     *isys_stream_descr)
{
        if (!binary)
                return false;

        isys_stream_descr->output_port_attr.left_padding = binary->left_padding;
        isys_stream_descr->output_port_attr.max_isp_input_width =
            binary->info->sp.input.max_width;

        return true;
}

static int
sh_css_config_input_network(struct ia_css_stream *stream)
{
        bool                                    rc;
        ia_css_isys_descr_t                     isys_stream_descr;
        unsigned int                            sp_thread_id;
        struct sh_css_sp_pipeline_terminal      *sp_pipeline_input_terminal;
        struct ia_css_pipe *pipe = NULL;
        struct ia_css_binary *binary = NULL;
        int i;
        u32 isys_stream_id;
        bool early_polling = false;

        assert(stream);
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                            "sh_css_config_input_network() enter 0x%p:\n", stream);

        if (stream->config.continuous) {
                if (stream->last_pipe->config.mode == IA_CSS_PIPE_MODE_CAPTURE)
                        pipe = stream->last_pipe;
                else if (stream->last_pipe->config.mode == IA_CSS_PIPE_MODE_YUVPP)
                        pipe = stream->last_pipe;
                else if (stream->last_pipe->config.mode == IA_CSS_PIPE_MODE_PREVIEW)
                        pipe = stream->last_pipe->pipe_settings.preview.copy_pipe;
                else if (stream->last_pipe->config.mode == IA_CSS_PIPE_MODE_VIDEO)
                        pipe = stream->last_pipe->pipe_settings.video.copy_pipe;
        } else {
                pipe = stream->last_pipe;
                if (stream->last_pipe->config.mode == IA_CSS_PIPE_MODE_CAPTURE) {
                        /*
                         * We need to poll the ISYS HW in capture_indication itself
                         * for "non-continuous" capture usecase for getting accurate
                         * isys frame capture timestamps.
                         * This is because the capturepipe propcessing takes longer
                         * to execute than the input system frame capture.
                         * 2401 specific
                         */
                        early_polling = true;
                }
        }

        if (!pipe)
                return -EINVAL;

        if (pipe->pipeline.stages)
                if (pipe->pipeline.stages->binary)
                        binary = pipe->pipeline.stages->binary;

        if (binary) {
                /* this was being done in ifmtr in 2400.
                 * online and cont bypass the init_in_frameinfo_memory_defaults
                 * so need to do it here
                 */
                ia_css_get_crop_offsets(pipe, &binary->in_frame_info);
        }

        /* get the SP thread id */
        rc = ia_css_pipeline_get_sp_thread_id(ia_css_pipe_get_pipe_num(pipe), &sp_thread_id);
        if (!rc)
                return -EINVAL;
        /* get the target input terminal */
        sp_pipeline_input_terminal = &sh_css_sp_group.pipe_io[sp_thread_id].input;

        for (i = 0; i < IA_CSS_STREAM_MAX_ISYS_STREAM_PER_CH; i++) {
                /* initialization */
                memset((void *)(&isys_stream_descr), 0, sizeof(ia_css_isys_descr_t));
                sp_pipeline_input_terminal->context.virtual_input_system_stream[i].valid = 0;
                sp_pipeline_input_terminal->ctrl.virtual_input_system_stream_cfg[i].valid = 0;

                if (!stream->config.isys_config[i].valid)
                        continue;

                /* translate the stream configuration to the Input System (2401) configuration */
                rc = sh_css_translate_stream_cfg_to_isys_stream_descr(
                         &stream->config,
                         early_polling,
                         &(isys_stream_descr), i);

                if (stream->config.online) {
                        rc &= sh_css_translate_binary_info_to_input_system_output_port_attr(
                                  binary,
                                  &(isys_stream_descr));
                }

                if (!rc)
                        return -EINVAL;

                isys_stream_id = ia_css_isys_generate_stream_id(sp_thread_id, i);

                /* create the virtual Input System (2401) */
                rc =  ia_css_isys_stream_create(
                          &(isys_stream_descr),
                          &sp_pipeline_input_terminal->context.virtual_input_system_stream[i],
                          isys_stream_id);
                if (!rc)
                        return -EINVAL;

                /* calculate the configuration of the virtual Input System (2401) */
                rc = ia_css_isys_stream_calculate_cfg(
                         &sp_pipeline_input_terminal->context.virtual_input_system_stream[i],
                         &(isys_stream_descr),
                         &sp_pipeline_input_terminal->ctrl.virtual_input_system_stream_cfg[i]);
                if (!rc) {
                        ia_css_isys_stream_destroy(
                            &sp_pipeline_input_terminal->context.virtual_input_system_stream[i]);
                        return -EINVAL;
                }
        }

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                            "sh_css_config_input_network() leave:\n");

        return 0;
}

static inline struct ia_css_pipe *stream_get_last_pipe(
    struct ia_css_stream *stream)
{
        struct ia_css_pipe *last_pipe = NULL;

        if (stream)
                last_pipe = stream->last_pipe;

        return last_pipe;
}

static inline struct ia_css_pipe *stream_get_copy_pipe(
    struct ia_css_stream *stream)
{
        struct ia_css_pipe *copy_pipe = NULL;
        struct ia_css_pipe *last_pipe = NULL;
        enum ia_css_pipe_id pipe_id;

        last_pipe = stream_get_last_pipe(stream);

        if ((stream) &&
            (last_pipe) &&
            (stream->config.continuous)) {
                pipe_id = last_pipe->mode;
                switch (pipe_id) {
                case IA_CSS_PIPE_ID_PREVIEW:
                        copy_pipe = last_pipe->pipe_settings.preview.copy_pipe;
                        break;
                case IA_CSS_PIPE_ID_VIDEO:
                        copy_pipe = last_pipe->pipe_settings.video.copy_pipe;
                        break;
                default:
                        copy_pipe = NULL;
                        break;
                }
        }

        return copy_pipe;
}

static inline struct ia_css_pipe *stream_get_target_pipe(
    struct ia_css_stream *stream)
{
        struct ia_css_pipe *target_pipe;

        /* get the pipe that consumes the stream */
        if (stream->config.continuous)
                target_pipe = stream_get_copy_pipe(stream);
        else
                target_pipe = stream_get_last_pipe(stream);

        return target_pipe;
}

static int stream_csi_rx_helper(
    struct ia_css_stream *stream,
    int (*func)(enum mipi_port_id, uint32_t))
{
        int retval = -EINVAL;
        u32 sp_thread_id, stream_id;
        bool rc;
        struct ia_css_pipe *target_pipe = NULL;

        if ((!stream) || (stream->config.mode != IA_CSS_INPUT_MODE_BUFFERED_SENSOR))
                goto exit;

        target_pipe = stream_get_target_pipe(stream);

        if (!target_pipe)
                goto exit;

        rc = ia_css_pipeline_get_sp_thread_id(
                 ia_css_pipe_get_pipe_num(target_pipe),
                 &sp_thread_id);

        if (!rc)
                goto exit;

        /* (un)register all valid "virtual isys streams" within the ia_css_stream */
        stream_id = 0;
        do {
                if (stream->config.isys_config[stream_id].valid) {
                        u32 isys_stream_id = ia_css_isys_generate_stream_id(sp_thread_id, stream_id);

                        retval = func(stream->config.source.port.port, isys_stream_id);
                }
                stream_id++;
        } while ((retval == 0) &&
                 (stream_id < IA_CSS_STREAM_MAX_ISYS_STREAM_PER_CH));

exit:
        return retval;
}

static inline int stream_register_with_csi_rx(
    struct ia_css_stream *stream)
{
        return stream_csi_rx_helper(stream, ia_css_isys_csi_rx_register_stream);
}

static inline int stream_unregister_with_csi_rx(
    struct ia_css_stream *stream)
{
        return stream_csi_rx_helper(stream, ia_css_isys_csi_rx_unregister_stream);
}
#endif

#if WITH_PC_MONITORING
static struct task_struct *my_kthread;    /* Handle for the monitoring thread */
static int sh_binary_running;         /* Enable sampling in the thread */

static void print_pc_histo(char *core_name, struct sh_css_pc_histogram *hist)
{
        unsigned int i;
        unsigned int cnt_run = 0;
        unsigned int cnt_stall = 0;

        if (!hist)
                return;

        sh_css_print("%s histogram length = %d\n", core_name, hist->length);
        sh_css_print("%s PC\turn\tstall\n", core_name);

        for (i = 0; i < hist->length; i++) {
                if ((hist->run[i] == 0) && (hist->run[i] == hist->stall[i]))
                        continue;
                sh_css_print("%s %d\t%d\t%d\n",
                             core_name, i, hist->run[i], hist->stall[i]);
                cnt_run += hist->run[i];
                cnt_stall += hist->stall[i];
        }

        sh_css_print(" Statistics for %s, cnt_run = %d, cnt_stall = %d, hist->length = %d\n",
                     core_name, cnt_run, cnt_stall, hist->length);
}

static void print_pc_histogram(void)
{
        struct ia_css_binary_metrics *metrics;

        for (metrics = sh_css_metrics.binary_metrics;
             metrics;
             metrics = metrics->next) {
                if (metrics->mode == IA_CSS_BINARY_MODE_PREVIEW ||
                    metrics->mode == IA_CSS_BINARY_MODE_VF_PP) {
                        sh_css_print("pc_histogram for binary %d is SKIPPED\n",
                                     metrics->id);
                        continue;
                }

                sh_css_print(" pc_histogram for binary %d\n", metrics->id);
                print_pc_histo("  ISP", &metrics->isp_histogram);
                print_pc_histo("  SP",   &metrics->sp_histogram);
                sh_css_print("print_pc_histogram() done for binary->id = %d, done.\n",
                             metrics->id);
        }

        sh_css_print("PC_MONITORING:print_pc_histogram() -- DONE\n");
}

static int pc_monitoring(void *data)
{
        int i = 0;

        (void)data;
        while (true) {
                if (sh_binary_running) {
                        sh_css_metrics_sample_pcs();
#if MULTIPLE_SAMPLES
                        for (i = 0; i < NOF_SAMPLES; i++)
                                sh_css_metrics_sample_pcs();
#endif
                }
                usleep_range(10, 50);
        }
        return 0;
}

static void spying_thread_create(void)
{
        my_kthread = kthread_run(pc_monitoring, NULL, "sh_pc_monitor");
        sh_css_metrics_enable_pc_histogram(1);
}

static void input_frame_info(struct ia_css_frame_info frame_info)
{
        sh_css_print("SH_CSS:input_frame_info() -- frame->info.res.width = %d, frame->info.res.height = %d, format = %d\n",
                     frame_info.res.width, frame_info.res.height, frame_info.format);
}
#endif /* WITH_PC_MONITORING */

static void
start_binary(struct ia_css_pipe *pipe,
             struct ia_css_binary *binary)
{
        assert(pipe);
        /* Acceleration uses firmware, the binary thus can be NULL */

        if (binary)
                sh_css_metrics_start_binary(&binary->metrics);

#if WITH_PC_MONITORING
        sh_css_print("PC_MONITORING: %s() -- binary id = %d , enable_dvs_envelope = %d\n",
                     __func__, binary->info->sp.id,
                     binary->info->sp.enable.dvs_envelope);
        input_frame_info(binary->in_frame_info);

        if (binary && binary->info->sp.pipeline.mode == IA_CSS_BINARY_MODE_VIDEO)
                sh_binary_running = true;
#endif

#if !defined(ISP2401)
        if (pipe->stream->reconfigure_css_rx) {
                ia_css_isys_rx_configure(&pipe->stream->csi_rx_config,
                                         pipe->stream->config.mode);
                pipe->stream->reconfigure_css_rx = false;
        }
#endif
}

/* start the copy function on the SP */
static int
start_copy_on_sp(struct ia_css_pipe *pipe,
                 struct ia_css_frame *out_frame)
{
        (void)out_frame;

        if ((!pipe) || (!pipe->stream))
                return -EINVAL;

#if !defined(ISP2401)
        if (pipe->stream->reconfigure_css_rx)
                ia_css_isys_rx_disable();
#endif

        if (pipe->stream->config.input_config.format != ATOMISP_INPUT_FORMAT_BINARY_8)
                return -EINVAL;
        sh_css_sp_start_binary_copy(ia_css_pipe_get_pipe_num(pipe), out_frame, pipe->stream->config.pixels_per_clock == 2);

#if !defined(ISP2401)
        if (pipe->stream->reconfigure_css_rx) {
                ia_css_isys_rx_configure(&pipe->stream->csi_rx_config,
                                         pipe->stream->config.mode);
                pipe->stream->reconfigure_css_rx = false;
        }
#endif

        return 0;
}

void sh_css_binary_args_reset(struct sh_css_binary_args *args)
{
        unsigned int i;

        for (i = 0; i < NUM_TNR_FRAMES; i++)
                args->tnr_frames[i] = NULL;
        for (i = 0; i < MAX_NUM_VIDEO_DELAY_FRAMES; i++)
                args->delay_frames[i] = NULL;
        args->in_frame      = NULL;
        for (i = 0; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++)
                args->out_frame[i] = NULL;
        args->out_vf_frame  = NULL;
        args->copy_vf       = false;
        args->copy_output   = true;
        args->vf_downscale_log2 = 0;
}

static void start_pipe(
    struct ia_css_pipe *me,
    enum sh_css_pipe_config_override copy_ovrd,
    enum ia_css_input_mode input_mode)
{
        const struct ia_css_coordinate *coord = NULL;
        const struct ia_css_isp_parameters *params = NULL;


        IA_CSS_ENTER_PRIVATE("me = %p, copy_ovrd = %d, input_mode = %d",
                             me, copy_ovrd, input_mode);

        assert(me); /* all callers are in this file and call with non null argument */

        if (!IS_ISP2401) {
                coord = &me->config.internal_frame_origin_bqs_on_sctbl;
                params = me->stream->isp_params_configs;
        }

        sh_css_sp_init_pipeline(&me->pipeline,
                                me->mode,
                                (uint8_t)ia_css_pipe_get_pipe_num(me),
                                me->config.default_capture_config.enable_xnr != 0,
                                me->stream->config.pixels_per_clock == 2,
                                me->stream->config.continuous,
                                false,
                                me->required_bds_factor,
                                copy_ovrd,
                                input_mode,
                                &me->stream->config.metadata_config,
                                &me->stream->info.metadata_info
                                , (input_mode == IA_CSS_INPUT_MODE_MEMORY) ?
                                (enum mipi_port_id)0 :
                                me->stream->config.source.port.port,
                                coord,
                                params);

        if (me->config.mode != IA_CSS_PIPE_MODE_COPY) {
                struct ia_css_pipeline_stage *stage;

                stage = me->pipeline.stages;
                if (stage) {
                        me->pipeline.current_stage = stage;
                        start_binary(me, stage->binary);
                }
        }
        IA_CSS_LEAVE_PRIVATE("void");
}

void
sh_css_invalidate_shading_tables(struct ia_css_stream *stream)
{
        int i;

        assert(stream);

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
                            "sh_css_invalidate_shading_tables() enter:\n");

        for (i = 0; i < stream->num_pipes; i++) {
                assert(stream->pipes[i]);
                sh_css_pipe_free_shading_table(stream->pipes[i]);
        }

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
                            "sh_css_invalidate_shading_tables() leave: return_void\n");
}

static void
enable_interrupts(enum ia_css_irq_type irq_type)
{
#ifndef ISP2401
        enum mipi_port_id port;
#endif
        bool enable_pulse = irq_type != IA_CSS_IRQ_TYPE_EDGE;

        IA_CSS_ENTER_PRIVATE("");
        /* Enable IRQ on the SP which signals that SP goes to idle
         * (aka ready state) */
        cnd_sp_irq_enable(SP0_ID, true);
        /* Set the IRQ device 0 to either level or pulse */
        irq_enable_pulse(IRQ0_ID, enable_pulse);

        cnd_virq_enable_channel(virq_sp, true);

        /* Enable SW interrupt 0, this is used to signal ISYS events */
        cnd_virq_enable_channel(
            (enum virq_id)(IRQ_SW_CHANNEL0_ID + IRQ_SW_CHANNEL_OFFSET),
            true);
        /* Enable SW interrupt 1, this is used to signal PSYS events */
        cnd_virq_enable_channel(
            (enum virq_id)(IRQ_SW_CHANNEL1_ID + IRQ_SW_CHANNEL_OFFSET),
            true);

#ifndef ISP2401
        for (port = 0; port < N_MIPI_PORT_ID; port++)
                ia_css_isys_rx_enable_all_interrupts(port);
#endif

        IA_CSS_LEAVE_PRIVATE("");
}

static bool sh_css_setup_spctrl_config(const struct ia_css_fw_info *fw,
                                       const char *program,
                                       ia_css_spctrl_cfg  *spctrl_cfg)
{
        if ((!fw) || (!spctrl_cfg))
                return false;
        spctrl_cfg->sp_entry = 0;
        spctrl_cfg->program_name = (char *)(program);

        spctrl_cfg->ddr_data_offset =  fw->blob.data_source;
        spctrl_cfg->dmem_data_addr = fw->blob.data_target;
        spctrl_cfg->dmem_bss_addr = fw->blob.bss_target;
        spctrl_cfg->data_size = fw->blob.data_size;
        spctrl_cfg->bss_size = fw->blob.bss_size;

        spctrl_cfg->spctrl_config_dmem_addr = fw->info.sp.init_dmem_data;
        spctrl_cfg->spctrl_state_dmem_addr = fw->info.sp.sw_state;

        spctrl_cfg->code_size = fw->blob.size;
        spctrl_cfg->code      = fw->blob.code;
        spctrl_cfg->sp_entry  = fw->info.sp.sp_entry; /* entry function ptr on SP */

        return true;
}

void
ia_css_unload_firmware(void)
{
        if (sh_css_num_binaries) {
                /* we have already loaded before so get rid of the old stuff */
                ia_css_binary_uninit();
                sh_css_unload_firmware();
        }
        fw_explicitly_loaded = false;
}

static void
ia_css_reset_defaults(struct sh_css *css)
{
        struct sh_css default_css;

        /* Reset everything to zero */
        memset(&default_css, 0, sizeof(default_css));

        /* Initialize the non zero values*/
        default_css.check_system_idle = true;
        default_css.num_cont_raw_frames = NUM_CONTINUOUS_FRAMES;

        /* All should be 0: but memset does it already.
         * default_css.num_mipi_frames[N_CSI_PORTS] = 0;
         */

        default_css.irq_type = IA_CSS_IRQ_TYPE_EDGE;

        /*Set the defaults to the output */
        *css = default_css;
}

int
ia_css_load_firmware(struct device *dev, const struct ia_css_env *env,
                     const struct ia_css_fw  *fw)
{
        int err;

        if (!env)
                return -EINVAL;
        if (!fw)
                return -EINVAL;

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "ia_css_load_firmware() enter\n");

        /* make sure we initialize my_css */
        if (my_css.flush != env->cpu_mem_env.flush) {
                ia_css_reset_defaults(&my_css);
                my_css.flush = env->cpu_mem_env.flush;
        }

        ia_css_unload_firmware(); /* in case we are called twice */
        err = sh_css_load_firmware(dev, fw->data, fw->bytes);
        if (!err) {
                err = ia_css_binary_init_infos();
                if (!err)
                        fw_explicitly_loaded = true;
        }

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "ia_css_load_firmware() leave\n");
        return err;
}

int
ia_css_init(struct device *dev, const struct ia_css_env *env,
            const struct ia_css_fw  *fw,
            u32                 mmu_l1_base,
            enum ia_css_irq_type     irq_type)
{
        int err;
        ia_css_spctrl_cfg spctrl_cfg;

        void (*flush_func)(struct ia_css_acc_fw *fw);
        hrt_data select, enable;

        /*
         * The C99 standard does not specify the exact object representation of structs;
         * the representation is compiler dependent.
         *
         * The structs that are communicated between host and SP/ISP should have the
         * exact same object representation. The compiler that is used to compile the
         * firmware is hivecc.
         *
         * To check if a different compiler, used to compile a host application, uses
         * another object representation, macros are defined specifying the size of
         * the structs as expected by the firmware.
         *
         * A host application shall verify that a sizeof( ) of the struct is equal to
         * the SIZE_OF_XXX macro of the corresponding struct. If they are not
         * equal, functionality will break.
         */
        /* Check struct sh_css_ddr_address_map */
        COMPILATION_ERROR_IF(sizeof(struct sh_css_ddr_address_map)              != SIZE_OF_SH_CSS_DDR_ADDRESS_MAP_STRUCT);
        /* Check struct host_sp_queues */
        COMPILATION_ERROR_IF(sizeof(struct host_sp_queues)                      != SIZE_OF_HOST_SP_QUEUES_STRUCT);
        COMPILATION_ERROR_IF(sizeof(struct ia_css_circbuf_desc_s)               != SIZE_OF_IA_CSS_CIRCBUF_DESC_S_STRUCT);
        COMPILATION_ERROR_IF(sizeof(struct ia_css_circbuf_elem_s)               != SIZE_OF_IA_CSS_CIRCBUF_ELEM_S_STRUCT);

        /* Check struct host_sp_communication */
        COMPILATION_ERROR_IF(sizeof(struct host_sp_communication)               != SIZE_OF_HOST_SP_COMMUNICATION_STRUCT);
        COMPILATION_ERROR_IF(sizeof(struct sh_css_event_irq_mask)               != SIZE_OF_SH_CSS_EVENT_IRQ_MASK_STRUCT);

        /* Check struct sh_css_hmm_buffer */
        COMPILATION_ERROR_IF(sizeof(struct sh_css_hmm_buffer)                   != SIZE_OF_SH_CSS_HMM_BUFFER_STRUCT);
        COMPILATION_ERROR_IF(sizeof(struct ia_css_isp_3a_statistics)            != SIZE_OF_IA_CSS_ISP_3A_STATISTICS_STRUCT);
        COMPILATION_ERROR_IF(sizeof(struct ia_css_isp_dvs_statistics)           != SIZE_OF_IA_CSS_ISP_DVS_STATISTICS_STRUCT);
        COMPILATION_ERROR_IF(sizeof(struct ia_css_metadata)                     != SIZE_OF_IA_CSS_METADATA_STRUCT);

        /* Check struct ia_css_init_dmem_cfg */
        COMPILATION_ERROR_IF(sizeof(struct ia_css_sp_init_dmem_cfg)             != SIZE_OF_IA_CSS_SP_INIT_DMEM_CFG_STRUCT);

        if (!fw && !fw_explicitly_loaded)
                return -EINVAL;
        if (!env)
                return -EINVAL;

        sh_css_printf = env->print_env.debug_print;

        IA_CSS_ENTER("void");

        flush_func     = env->cpu_mem_env.flush;

        pipe_global_init();
        ia_css_pipeline_init();
        ia_css_queue_map_init();

        ia_css_device_access_init(&env->hw_access_env);

        select = gpio_reg_load(GPIO0_ID, _gpio_block_reg_do_select)
        & (~GPIO_FLASH_PIN_MASK);
        enable = gpio_reg_load(GPIO0_ID, _gpio_block_reg_do_e)
        | GPIO_FLASH_PIN_MASK;
        sh_css_mmu_set_page_table_base_index(mmu_l1_base);

        my_css_save.mmu_base = mmu_l1_base;

        ia_css_reset_defaults(&my_css);

        my_css_save.driver_env = *env;
        my_css.flush     = flush_func;

        err = ia_css_rmgr_init();
        if (err) {
                IA_CSS_LEAVE_ERR(err);
                return err;
        }

        IA_CSS_LOG("init: %d", my_css_save_initialized);

        if (!my_css_save_initialized) {
                my_css_save_initialized = true;
                my_css_save.mode = sh_css_mode_working;
                memset(my_css_save.stream_seeds, 0,
                       sizeof(struct sh_css_stream_seed) * MAX_ACTIVE_STREAMS);
                IA_CSS_LOG("init: %d mode=%d", my_css_save_initialized, my_css_save.mode);
        }

        mipi_init();

#ifndef ISP2401
        /* In case this has been programmed already, update internal
           data structure ... DEPRECATED */
        my_css.page_table_base_index = mmu_get_page_table_base_index(MMU0_ID);

#endif
        my_css.irq_type = irq_type;

        my_css_save.irq_type = irq_type;

        enable_interrupts(my_css.irq_type);

        /* configure GPIO to output mode */
        gpio_reg_store(GPIO0_ID, _gpio_block_reg_do_select, select);
        gpio_reg_store(GPIO0_ID, _gpio_block_reg_do_e, enable);
        gpio_reg_store(GPIO0_ID, _gpio_block_reg_do_0, 0);

        err = ia_css_refcount_init(REFCOUNT_SIZE);
        if (err) {
                IA_CSS_LEAVE_ERR(err);
                return err;
        }
        err = sh_css_params_init();
        if (err) {
                IA_CSS_LEAVE_ERR(err);
                return err;
        }
        if (fw) {
                ia_css_unload_firmware(); /* in case we already had firmware loaded */
                err = sh_css_load_firmware(dev, fw->data, fw->bytes);
                if (err) {
                        IA_CSS_LEAVE_ERR(err);
                        return err;
                }
                err = ia_css_binary_init_infos();
                if (err) {
                        IA_CSS_LEAVE_ERR(err);
                        return err;
                }
                fw_explicitly_loaded = false;
#ifndef ISP2401
                my_css_save.loaded_fw = (struct ia_css_fw *)fw;
#endif
        }
        if (!sh_css_setup_spctrl_config(&sh_css_sp_fw, SP_PROG_NAME, &spctrl_cfg))
                return -EINVAL;

        err = ia_css_spctrl_load_fw(SP0_ID, &spctrl_cfg);
        if (err) {
                IA_CSS_LEAVE_ERR(err);
                return err;
        }

#if WITH_PC_MONITORING
        if (!thread_alive) {
                thread_alive++;
                sh_css_print("PC_MONITORING: %s() -- create thread DISABLED\n",
                             __func__);
                spying_thread_create();
        }
#endif
        if (!sh_css_hrt_system_is_idle()) {
                IA_CSS_LEAVE_ERR(-EBUSY);
                return -EBUSY;
        }
        /* can be called here, queuing works, but:
           - when sp is started later, it will wipe queued items
           so for now we leave it for later and make sure
           updates are not called to frequently.
        sh_css_init_buffer_queues();
        */

#if defined(ISP2401)
        gp_device_reg_store(GP_DEVICE0_ID, _REG_GP_SWITCH_ISYS2401_ADDR, 1);
#endif


        if (!IS_ISP2401)
                dma_set_max_burst_size(DMA0_ID, HIVE_DMA_BUS_DDR_CONN,
                                       ISP2400_DMA_MAX_BURST_LENGTH);
        else
                dma_set_max_burst_size(DMA0_ID, HIVE_DMA_BUS_DDR_CONN,
                                       ISP2401_DMA_MAX_BURST_LENGTH);

        if (ia_css_isys_init() != INPUT_SYSTEM_ERR_NO_ERROR)
                err = -EINVAL;

        sh_css_params_map_and_store_default_gdc_lut();

        IA_CSS_LEAVE_ERR(err);
        return err;
}

int
ia_css_enable_isys_event_queue(bool enable)
{
        if (sh_css_sp_is_running())
                return -EBUSY;
        sh_css_sp_enable_isys_event_queue(enable);
        return 0;
}

/* For Acceleration API: Flush FW (shared buffer pointer) arguments */
void
sh_css_flush(struct ia_css_acc_fw *fw)
{
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "sh_css_flush() enter:\n");
        if ((fw) && (my_css.flush))
                my_css.flush(fw);
}

/* Mapping sp threads. Currently, this is done when a stream is created and
 * pipelines are ready to be converted to sp pipelines. Be careful if you are
 * doing it from stream_create since we could run out of sp threads due to
 * allocation on inactive pipelines. */
static int
map_sp_threads(struct ia_css_stream *stream, bool map)
{
        struct ia_css_pipe *main_pipe = NULL;
        struct ia_css_pipe *copy_pipe = NULL;
        struct ia_css_pipe *capture_pipe = NULL;
        struct ia_css_pipe *acc_pipe = NULL;
        int err = 0;
        enum ia_css_pipe_id pipe_id;

        IA_CSS_ENTER_PRIVATE("stream = %p, map = %s",
                             stream, map ? "true" : "false");

        if (!stream) {
                IA_CSS_LEAVE_ERR_PRIVATE(-EINVAL);
                return -EINVAL;
        }

        main_pipe = stream->last_pipe;
        pipe_id = main_pipe->mode;

        ia_css_pipeline_map(main_pipe->pipe_num, map);

        switch (pipe_id) {
        case IA_CSS_PIPE_ID_PREVIEW:
                copy_pipe    = main_pipe->pipe_settings.preview.copy_pipe;
                capture_pipe = main_pipe->pipe_settings.preview.capture_pipe;
                acc_pipe     = main_pipe->pipe_settings.preview.acc_pipe;
                break;

        case IA_CSS_PIPE_ID_VIDEO:
                copy_pipe    = main_pipe->pipe_settings.video.copy_pipe;
                capture_pipe = main_pipe->pipe_settings.video.capture_pipe;
                break;

        case IA_CSS_PIPE_ID_CAPTURE:
        case IA_CSS_PIPE_ID_ACC:
        default:
                break;
        }

        if (acc_pipe)
                ia_css_pipeline_map(acc_pipe->pipe_num, map);

        if (capture_pipe)
                ia_css_pipeline_map(capture_pipe->pipe_num, map);

        /* Firmware expects copy pipe to be the last pipe mapped. (if needed) */
        if (copy_pipe)
                ia_css_pipeline_map(copy_pipe->pipe_num, map);

        /* DH regular multi pipe - not continuous mode: map the next pipes too */
        if (!stream->config.continuous) {
                int i;

                for (i = 1; i < stream->num_pipes; i++)
                        ia_css_pipeline_map(stream->pipes[i]->pipe_num, map);
        }

        IA_CSS_LEAVE_ERR_PRIVATE(err);
        return err;
}

/* creates a host pipeline skeleton for all pipes in a stream. Called during
 * stream_create. */
static int
create_host_pipeline_structure(struct ia_css_stream *stream)
{
        struct ia_css_pipe *copy_pipe = NULL, *capture_pipe = NULL;
        struct ia_css_pipe *acc_pipe = NULL;
        enum ia_css_pipe_id pipe_id;
        struct ia_css_pipe *main_pipe = NULL;
        int err = 0;
        unsigned int copy_pipe_delay = 0,
        capture_pipe_delay = 0;

        IA_CSS_ENTER_PRIVATE("stream = %p", stream);

        if (!stream) {
                IA_CSS_LEAVE_ERR_PRIVATE(-EINVAL);
                return -EINVAL;
        }

        main_pipe       = stream->last_pipe;
        if (!main_pipe) {
                IA_CSS_LEAVE_ERR_PRIVATE(-EINVAL);
                return -EINVAL;
        }

        pipe_id = main_pipe->mode;

        switch (pipe_id) {
        case IA_CSS_PIPE_ID_PREVIEW:
                copy_pipe    = main_pipe->pipe_settings.preview.copy_pipe;
                copy_pipe_delay = main_pipe->dvs_frame_delay;
                capture_pipe = main_pipe->pipe_settings.preview.capture_pipe;
                capture_pipe_delay = IA_CSS_FRAME_DELAY_0;
                acc_pipe     = main_pipe->pipe_settings.preview.acc_pipe;
                err = ia_css_pipeline_create(&main_pipe->pipeline, main_pipe->mode,
                                             main_pipe->pipe_num, main_pipe->dvs_frame_delay);
                break;

        case IA_CSS_PIPE_ID_VIDEO:
                copy_pipe    = main_pipe->pipe_settings.video.copy_pipe;
                copy_pipe_delay = main_pipe->dvs_frame_delay;
                capture_pipe = main_pipe->pipe_settings.video.capture_pipe;
                capture_pipe_delay = IA_CSS_FRAME_DELAY_0;
                err = ia_css_pipeline_create(&main_pipe->pipeline, main_pipe->mode,
                                             main_pipe->pipe_num, main_pipe->dvs_frame_delay);
                break;

        case IA_CSS_PIPE_ID_CAPTURE:
                capture_pipe = main_pipe;
                capture_pipe_delay = main_pipe->dvs_frame_delay;
                break;

        case IA_CSS_PIPE_ID_YUVPP:
                err = ia_css_pipeline_create(&main_pipe->pipeline, main_pipe->mode,
                                             main_pipe->pipe_num, main_pipe->dvs_frame_delay);
                break;

        case IA_CSS_PIPE_ID_ACC:
                err = ia_css_pipeline_create(&main_pipe->pipeline, main_pipe->mode,
                                             main_pipe->pipe_num, main_pipe->dvs_frame_delay);
                break;

        default:
                err = -EINVAL;
        }

        if (!(err) && copy_pipe)
                err = ia_css_pipeline_create(&copy_pipe->pipeline,
                                             copy_pipe->mode,
                                             copy_pipe->pipe_num,
                                             copy_pipe_delay);

        if (!(err) && capture_pipe)
                err = ia_css_pipeline_create(&capture_pipe->pipeline,
                                             capture_pipe->mode,
                                             capture_pipe->pipe_num,
                                             capture_pipe_delay);

        if (!(err) && acc_pipe)
                err = ia_css_pipeline_create(&acc_pipe->pipeline, acc_pipe->mode,
                                             acc_pipe->pipe_num, main_pipe->dvs_frame_delay);

        /* DH regular multi pipe - not continuous mode: create the next pipelines too */
        if (!stream->config.continuous) {
                int i;

                for (i = 1; i < stream->num_pipes && 0 == err; i++) {
                        main_pipe = stream->pipes[i];
                        err = ia_css_pipeline_create(&main_pipe->pipeline,
                                                     main_pipe->mode,
                                                     main_pipe->pipe_num,
                                                     main_pipe->dvs_frame_delay);
                }
        }

        IA_CSS_LEAVE_ERR_PRIVATE(err);
        return err;
}

/* creates a host pipeline for all pipes in a stream. Called during
 * stream_start. */
static int
create_host_pipeline(struct ia_css_stream *stream)
{
        struct ia_css_pipe *copy_pipe = NULL, *capture_pipe = NULL;
        struct ia_css_pipe *acc_pipe = NULL;
        enum ia_css_pipe_id pipe_id;
        struct ia_css_pipe *main_pipe = NULL;
        int err = 0;
        unsigned int max_input_width = 0;

        IA_CSS_ENTER_PRIVATE("stream = %p", stream);
        if (!stream) {

                IA_CSS_LEAVE_ERR_PRIVATE(-EINVAL);
                return -EINVAL;
        }

        main_pipe       = stream->last_pipe;
        pipe_id = main_pipe->mode;

        /* No continuous frame allocation for capture pipe. It uses the
         * "main" pipe's frames. */
        if ((pipe_id == IA_CSS_PIPE_ID_PREVIEW) ||
            (pipe_id == IA_CSS_PIPE_ID_VIDEO)) {
                /* About pipe_id == IA_CSS_PIPE_ID_PREVIEW && stream->config.mode != IA_CSS_INPUT_MODE_MEMORY:
                 * The original condition pipe_id == IA_CSS_PIPE_ID_PREVIEW is too strong. E.g. in SkyCam (with memory
                 * based input frames) there is no continuous mode and thus no need for allocated continuous frames
                 * This is not only for SkyCam but for all preview cases that use DDR based input frames. For this
                 * reason the stream->config.mode != IA_CSS_INPUT_MODE_MEMORY has beed added.
                 */
                if (stream->config.continuous ||
                    (pipe_id == IA_CSS_PIPE_ID_PREVIEW &&
                     stream->config.mode != IA_CSS_INPUT_MODE_MEMORY)) {
                        err = alloc_continuous_frames(main_pipe, true);
                        if (err)
                                goto ERR;
                }
        }

#if !defined(ISP2401)
        /* old isys: need to allocate_mipi_frames() even in IA_CSS_PIPE_MODE_COPY */
        if (pipe_id != IA_CSS_PIPE_ID_ACC) {
                err = allocate_mipi_frames(main_pipe, &stream->info);
                if (err)
                        goto ERR;
        }
#elif defined(ISP2401)
        if ((pipe_id != IA_CSS_PIPE_ID_ACC) &&
            (main_pipe->config.mode != IA_CSS_PIPE_MODE_COPY)) {
                err = allocate_mipi_frames(main_pipe, &stream->info);
                if (err)
                        goto ERR;
        }
#endif

        switch (pipe_id) {
        case IA_CSS_PIPE_ID_PREVIEW:
                copy_pipe    = main_pipe->pipe_settings.preview.copy_pipe;
                capture_pipe = main_pipe->pipe_settings.preview.capture_pipe;
                acc_pipe     = main_pipe->pipe_settings.preview.acc_pipe;
                max_input_width =
                    main_pipe->pipe_settings.preview.preview_binary.info->sp.input.max_width;

                err = create_host_preview_pipeline(main_pipe);
                if (err)
                        goto ERR;

                break;

        case IA_CSS_PIPE_ID_VIDEO:
                copy_pipe    = main_pipe->pipe_settings.video.copy_pipe;
                capture_pipe = main_pipe->pipe_settings.video.capture_pipe;
                max_input_width =
                    main_pipe->pipe_settings.video.video_binary.info->sp.input.max_width;

                err = create_host_video_pipeline(main_pipe);
                if (err)
                        goto ERR;

                break;

        case IA_CSS_PIPE_ID_CAPTURE:
                capture_pipe = main_pipe;

                break;

        case IA_CSS_PIPE_ID_YUVPP:
                err = create_host_yuvpp_pipeline(main_pipe);
                if (err)
                        goto ERR;

                break;

        case IA_CSS_PIPE_ID_ACC:
                err = create_host_acc_pipeline(main_pipe);
                if (err)
                        goto ERR;

                break;
        default:
                err = -EINVAL;
        }
        if (err)
                goto ERR;

        if (copy_pipe) {
                err = create_host_copy_pipeline(copy_pipe, max_input_width,
                                                main_pipe->continuous_frames[0]);
                if (err)
                        goto ERR;
        }

        if (capture_pipe) {
                err = create_host_capture_pipeline(capture_pipe);
                if (err)
                        goto ERR;
        }

        if (acc_pipe) {
                err = create_host_acc_pipeline(acc_pipe);
                if (err)
                        goto ERR;
        }

        /* DH regular multi pipe - not continuous mode: create the next pipelines too */
        if (!stream->config.continuous) {
                int i;

                for (i = 1; i < stream->num_pipes && 0 == err; i++) {
                        switch (stream->pipes[i]->mode) {
                        case IA_CSS_PIPE_ID_PREVIEW:
                                err = create_host_preview_pipeline(stream->pipes[i]);
                                break;
                        case IA_CSS_PIPE_ID_VIDEO:
                                err = create_host_video_pipeline(stream->pipes[i]);
                                break;
                        case IA_CSS_PIPE_ID_CAPTURE:
                                err = create_host_capture_pipeline(stream->pipes[i]);
                                break;
                        case IA_CSS_PIPE_ID_YUVPP:
                                err = create_host_yuvpp_pipeline(stream->pipes[i]);
                                break;
                        case IA_CSS_PIPE_ID_ACC:
                                err = create_host_acc_pipeline(stream->pipes[i]);
                                break;
                        default:
                                err = -EINVAL;
                        }
                        if (err)
                                goto ERR;
                }
        }

ERR:
        IA_CSS_LEAVE_ERR_PRIVATE(err);
        return err;
}

static const struct ia_css_pipe default_pipe = IA_CSS_DEFAULT_PIPE;
static const struct ia_css_preview_settings preview = IA_CSS_DEFAULT_PREVIEW_SETTINGS;
static const struct ia_css_capture_settings capture = IA_CSS_DEFAULT_CAPTURE_SETTINGS;
static const struct ia_css_video_settings video = IA_CSS_DEFAULT_VIDEO_SETTINGS;
static const struct ia_css_yuvpp_settings yuvpp = IA_CSS_DEFAULT_YUVPP_SETTINGS;

static int
init_pipe_defaults(enum ia_css_pipe_mode mode,
                   struct ia_css_pipe *pipe,
                   bool copy_pipe)
{
        if (!pipe) {
                IA_CSS_ERROR("NULL pipe parameter");
                return -EINVAL;
        }

        /* Initialize pipe to pre-defined defaults */
        memcpy(pipe, &default_pipe, sizeof(default_pipe));

        /* TODO: JB should not be needed, but temporary backward reference */
        switch (mode) {
        case IA_CSS_PIPE_MODE_PREVIEW:
                pipe->mode = IA_CSS_PIPE_ID_PREVIEW;
                memcpy(&pipe->pipe_settings.preview, &preview, sizeof(preview));
                break;
        case IA_CSS_PIPE_MODE_CAPTURE:
                if (copy_pipe)
                        pipe->mode = IA_CSS_PIPE_ID_COPY;
                else
                        pipe->mode = IA_CSS_PIPE_ID_CAPTURE;

                memcpy(&pipe->pipe_settings.capture, &capture, sizeof(capture));
                break;
        case IA_CSS_PIPE_MODE_VIDEO:
                pipe->mode = IA_CSS_PIPE_ID_VIDEO;
                memcpy(&pipe->pipe_settings.video, &video, sizeof(video));
                break;
        case IA_CSS_PIPE_MODE_ACC:
                pipe->mode = IA_CSS_PIPE_ID_ACC;
                break;
        case IA_CSS_PIPE_MODE_COPY:
                pipe->mode = IA_CSS_PIPE_ID_CAPTURE;
                break;
        case IA_CSS_PIPE_MODE_YUVPP:
                pipe->mode = IA_CSS_PIPE_ID_YUVPP;
                memcpy(&pipe->pipe_settings.yuvpp, &yuvpp, sizeof(yuvpp));
                break;
        default:
                return -EINVAL;
        }

        return 0;
}

static void
pipe_global_init(void)
{
        u8 i;

        my_css.pipe_counter = 0;
        for (i = 0; i < IA_CSS_PIPELINE_NUM_MAX; i++)
                my_css.all_pipes[i] = NULL;
}

static int
pipe_generate_pipe_num(const struct ia_css_pipe *pipe,
                       unsigned int *pipe_number)
{
        const u8 INVALID_PIPE_NUM = (uint8_t)~(0);
        u8 pipe_num = INVALID_PIPE_NUM;
        u8 i;

        if (!pipe) {
                IA_CSS_ERROR("NULL pipe parameter");
                return -EINVAL;
        }

        /* Assign a new pipe_num .... search for empty place */
        for (i = 0; i < IA_CSS_PIPELINE_NUM_MAX; i++) {
                if (!my_css.all_pipes[i]) {
                        /*position is reserved */
                        my_css.all_pipes[i] = (struct ia_css_pipe *)pipe;
                        pipe_num = i;
                        break;
                }
        }
        if (pipe_num == INVALID_PIPE_NUM) {
                /* Max number of pipes already allocated */
                IA_CSS_ERROR("Max number of pipes already created");
                return -ENOSPC;
        }

        my_css.pipe_counter++;

        IA_CSS_LOG("pipe_num (%d)", pipe_num);

        *pipe_number = pipe_num;
        return 0;
}

static void
pipe_release_pipe_num(unsigned int pipe_num)
{
        my_css.all_pipes[pipe_num] = NULL;
        my_css.pipe_counter--;
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
                            "pipe_release_pipe_num (%d)\n", pipe_num);
}

static int
create_pipe(enum ia_css_pipe_mode mode,
            struct ia_css_pipe **pipe,
            bool copy_pipe)
{
        int err = 0;
        struct ia_css_pipe *me;

        if (!pipe) {
                IA_CSS_ERROR("NULL pipe parameter");
                return -EINVAL;
        }

        me = kmalloc(sizeof(*me), GFP_KERNEL);
        if (!me)
                return -ENOMEM;

        err = init_pipe_defaults(mode, me, copy_pipe);
        if (err) {
                kfree(me);
                return err;
        }

        err = pipe_generate_pipe_num(me, &me->pipe_num);
        if (err) {
                kfree(me);
                return err;
        }

        *pipe = me;
        return 0;
}

struct ia_css_pipe *
find_pipe_by_num(uint32_t pipe_num)
{
        unsigned int i;

        for (i = 0; i < IA_CSS_PIPELINE_NUM_MAX; i++) {
                if (my_css.all_pipes[i] &&
                    ia_css_pipe_get_pipe_num(my_css.all_pipes[i]) == pipe_num) {
                        return my_css.all_pipes[i];
                }
        }
        return NULL;
}

static void sh_css_pipe_free_acc_binaries(
    struct ia_css_pipe *pipe)
{
        struct ia_css_pipeline *pipeline;
        struct ia_css_pipeline_stage *stage;

        if (!pipe) {
                IA_CSS_ERROR("NULL input pointer");
                return;
        }
        pipeline = &pipe->pipeline;

        /* loop through the stages and unload them */
        for (stage = pipeline->stages; stage; stage = stage->next) {
                struct ia_css_fw_info *firmware = (struct ia_css_fw_info *)
                                                  stage->firmware;
                if (firmware)
                        ia_css_pipe_unload_extension(pipe, firmware);
        }
}

int
ia_css_pipe_destroy(struct ia_css_pipe *pipe)
{
        int err = 0;

        IA_CSS_ENTER("pipe = %p", pipe);

        if (!pipe) {
                IA_CSS_LEAVE_ERR(-EINVAL);
                return -EINVAL;
        }

        if (pipe->stream) {
                IA_CSS_LOG("ia_css_stream_destroy not called!");
                IA_CSS_LEAVE_ERR(-EINVAL);
                return -EINVAL;
        }

        switch (pipe->config.mode) {
        case IA_CSS_PIPE_MODE_PREVIEW:
                /* need to take into account that this function is also called
                   on the internal copy pipe */
                if (pipe->mode == IA_CSS_PIPE_ID_PREVIEW) {
                        ia_css_frame_free_multiple(NUM_CONTINUOUS_FRAMES,
                                                   pipe->continuous_frames);
                        ia_css_metadata_free_multiple(NUM_CONTINUOUS_FRAMES,
                                                      pipe->cont_md_buffers);
                        if (pipe->pipe_settings.preview.copy_pipe) {
                                err = ia_css_pipe_destroy(pipe->pipe_settings.preview.copy_pipe);
                                ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
                                                    "ia_css_pipe_destroy(): destroyed internal copy pipe err=%d\n",
                                                    err);
                        }
                }
                break;
        case IA_CSS_PIPE_MODE_VIDEO:
                if (pipe->mode == IA_CSS_PIPE_ID_VIDEO) {
                        ia_css_frame_free_multiple(NUM_CONTINUOUS_FRAMES,
                                                   pipe->continuous_frames);
                        ia_css_metadata_free_multiple(NUM_CONTINUOUS_FRAMES,
                                                      pipe->cont_md_buffers);
                        if (pipe->pipe_settings.video.copy_pipe) {
                                err = ia_css_pipe_destroy(pipe->pipe_settings.video.copy_pipe);
                                ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
                                                    "ia_css_pipe_destroy(): destroyed internal copy pipe err=%d\n",
                                                    err);
                        }
                }
#ifndef ISP2401
                ia_css_frame_free_multiple(NUM_TNR_FRAMES,
                                           pipe->pipe_settings.video.tnr_frames);
#else
                ia_css_frame_free_multiple(NUM_TNR_FRAMES,
                                           pipe->pipe_settings.video.tnr_frames);
#endif
                ia_css_frame_free_multiple(MAX_NUM_VIDEO_DELAY_FRAMES,
                                           pipe->pipe_settings.video.delay_frames);
                break;
        case IA_CSS_PIPE_MODE_CAPTURE:
                ia_css_frame_free_multiple(MAX_NUM_VIDEO_DELAY_FRAMES,
                                           pipe->pipe_settings.capture.delay_frames);
                break;
        case IA_CSS_PIPE_MODE_ACC:
                sh_css_pipe_free_acc_binaries(pipe);
                break;
        case IA_CSS_PIPE_MODE_COPY:
                break;
        case IA_CSS_PIPE_MODE_YUVPP:
                break;
        }

        sh_css_params_free_gdc_lut(pipe->scaler_pp_lut);
        pipe->scaler_pp_lut = mmgr_NULL;

        my_css.active_pipes[ia_css_pipe_get_pipe_num(pipe)] = NULL;
        sh_css_pipe_free_shading_table(pipe);

        ia_css_pipeline_destroy(&pipe->pipeline);
        pipe_release_pipe_num(ia_css_pipe_get_pipe_num(pipe));

        /* Temporarily, not every sh_css_pipe has an acc_extension. */
        if (pipe->config.acc_extension)
                ia_css_pipe_unload_extension(pipe, pipe->config.acc_extension);

        kfree(pipe);
        IA_CSS_LEAVE("err = %d", err);
        return err;
}

void
ia_css_uninit(void)
{
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "ia_css_uninit() enter: void\n");
#if WITH_PC_MONITORING
        sh_css_print("PC_MONITORING: %s() -- started\n", __func__);
        print_pc_histogram();
#endif

        sh_css_params_free_default_gdc_lut();

        /* TODO: JB: implement decent check and handling of freeing mipi frames */
        //assert(ref_count_mipi_allocation == 0); //mipi frames are not freed
        /* cleanup generic data */
        sh_css_params_uninit();
        ia_css_refcount_uninit();

        ia_css_rmgr_uninit();

#if !defined(ISP2401)
        /* needed for reprogramming the inputformatter after power cycle of css */
        ifmtr_set_if_blocking_mode_reset = true;
#endif

        if (!fw_explicitly_loaded)
                ia_css_unload_firmware();

        ia_css_spctrl_unload_fw(SP0_ID);
        sh_css_sp_set_sp_running(false);
        /* check and free any remaining mipi frames */
        free_mipi_frames(NULL);

        sh_css_sp_reset_global_vars();

        ia_css_isys_uninit();

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "ia_css_uninit() leave: return_void\n");
}

int ia_css_irq_translate(
    unsigned int *irq_infos)
{
        enum virq_id    irq;
        enum hrt_isp_css_irq_status status = hrt_isp_css_irq_status_more_irqs;
        unsigned int infos = 0;

        /* irq_infos can be NULL, but that would make the function useless */
        /* assert(irq_infos != NULL); */
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
                            "ia_css_irq_translate() enter: irq_infos=%p\n", irq_infos);

        while (status == hrt_isp_css_irq_status_more_irqs) {
                status = virq_get_channel_id(&irq);
                if (status == hrt_isp_css_irq_status_error)
                        return -EINVAL;

#if WITH_PC_MONITORING
                sh_css_print("PC_MONITORING: %s() irq = %d, sh_binary_running set to 0\n",
                             __func__, irq);
                sh_binary_running = 0;
#endif

                switch (irq) {
                case virq_sp:
                        /* When SP goes to idle, info is available in the
                         * event queue. */
                        infos |= IA_CSS_IRQ_INFO_EVENTS_READY;
                        break;
                case virq_isp:
                        break;
                case virq_isys_sof:
                        infos |= IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF;
                        break;
                case virq_isys_eof:
                        infos |= IA_CSS_IRQ_INFO_CSS_RECEIVER_EOF;
                        break;
                case virq_isys_csi:
                        infos |= IA_CSS_IRQ_INFO_INPUT_SYSTEM_ERROR;
                        break;
#if !defined(ISP2401)
                case virq_ifmt0_id:
                        infos |= IA_CSS_IRQ_INFO_IF_ERROR;
                        break;
#endif
                case virq_dma:
                        infos |= IA_CSS_IRQ_INFO_DMA_ERROR;
                        break;
                case virq_sw_pin_0:
                        infos |= sh_css_get_sw_interrupt_value(0);
                        break;
                case virq_sw_pin_1:
                        infos |= sh_css_get_sw_interrupt_value(1);
                        /* pqiao TODO: also assumption here */
                        break;
                default:
                        break;
                }
        }

        if (irq_infos)
                *irq_infos = infos;

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
                            "ia_css_irq_translate() leave: irq_infos=%u\n",
                            infos);

        return 0;
}

int ia_css_irq_enable(
    enum ia_css_irq_info info,
    bool enable)
{
        enum virq_id    irq = N_virq_id;

        IA_CSS_ENTER("info=%d, enable=%d", info, enable);

        switch (info) {
#if !defined(ISP2401)
        case IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF:
                irq = virq_isys_sof;
                break;
        case IA_CSS_IRQ_INFO_CSS_RECEIVER_EOF:
                irq = virq_isys_eof;
                break;
        case IA_CSS_IRQ_INFO_INPUT_SYSTEM_ERROR:
                irq = virq_isys_csi;
                break;
        case IA_CSS_IRQ_INFO_IF_ERROR:
                irq = virq_ifmt0_id;
                break;
#else
        case IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF:
        case IA_CSS_IRQ_INFO_CSS_RECEIVER_EOF:
        case IA_CSS_IRQ_INFO_INPUT_SYSTEM_ERROR:
        case IA_CSS_IRQ_INFO_IF_ERROR:
                /* Just ignore those unused IRQs without printing errors */
                return 0;
#endif
        case IA_CSS_IRQ_INFO_DMA_ERROR:
                irq = virq_dma;
                break;
        case IA_CSS_IRQ_INFO_SW_0:
                irq = virq_sw_pin_0;
                break;
        case IA_CSS_IRQ_INFO_SW_1:
                irq = virq_sw_pin_1;
                break;
        default:
                IA_CSS_LEAVE_ERR(-EINVAL);
                return -EINVAL;
        }

        cnd_virq_enable_channel(irq, enable);

        IA_CSS_LEAVE_ERR(0);
        return 0;
}


static unsigned int
sh_css_get_sw_interrupt_value(unsigned int irq)
{
        unsigned int irq_value;

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
                            "sh_css_get_sw_interrupt_value() enter: irq=%d\n", irq);
        irq_value = sh_css_sp_get_sw_interrupt_value(irq);
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
                            "sh_css_get_sw_interrupt_value() leave: irq_value=%d\n", irq_value);
        return irq_value;
}

/* configure and load the copy binary, the next binary is used to
   determine whether the copy binary needs to do left padding. */
static int load_copy_binary(
    struct ia_css_pipe *pipe,
    struct ia_css_binary *copy_binary,
    struct ia_css_binary *next_binary)
{
        struct ia_css_frame_info copy_out_info, copy_in_info, copy_vf_info;
        unsigned int left_padding;
        int err;
        struct ia_css_binary_descr copy_descr;

        /* next_binary can be NULL */
        assert(pipe);
        assert(copy_binary);
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                            "load_copy_binary() enter:\n");

        if (next_binary) {
                copy_out_info = next_binary->in_frame_info;
                left_padding = next_binary->left_padding;
        } else {
                copy_out_info = pipe->output_info[0];
                copy_vf_info = pipe->vf_output_info[0];
                ia_css_frame_info_set_format(&copy_vf_info, IA_CSS_FRAME_FORMAT_YUV_LINE);
                left_padding = 0;
        }

        ia_css_pipe_get_copy_binarydesc(pipe, &copy_descr,
                                        &copy_in_info, &copy_out_info,
                                        (next_binary) ? NULL : NULL/*TODO: &copy_vf_info*/);
        err = ia_css_binary_find(&copy_descr, copy_binary);
        if (err)
                return err;
        copy_binary->left_padding = left_padding;
        return 0;
}

static int
alloc_continuous_frames(struct ia_css_pipe *pipe, bool init_time)
{
        int err = 0;
        struct ia_css_frame_info ref_info;
        enum ia_css_pipe_id pipe_id;
        bool continuous;
        unsigned int i, idx;
        unsigned int num_frames;

        IA_CSS_ENTER_PRIVATE("pipe = %p, init_time = %d", pipe, init_time);

        if ((!pipe) || (!pipe->stream)) {
                IA_CSS_LEAVE_ERR_PRIVATE(-EINVAL);
                return -EINVAL;
        }

        pipe_id = pipe->mode;
        continuous = pipe->stream->config.continuous;

        if (continuous) {
                if (init_time) {
                        num_frames = pipe->stream->config.init_num_cont_raw_buf;
                        pipe->stream->continuous_pipe = pipe;
                } else {
                        num_frames = pipe->stream->config.target_num_cont_raw_buf;
                }
        } else {
                num_frames = NUM_ONLINE_INIT_CONTINUOUS_FRAMES;
        }

        if (pipe_id == IA_CSS_PIPE_ID_PREVIEW) {
                ref_info = pipe->pipe_settings.preview.preview_binary.in_frame_info;
        } else if (pipe_id == IA_CSS_PIPE_ID_VIDEO) {
                ref_info = pipe->pipe_settings.video.video_binary.in_frame_info;
        } else {
                /* should not happen */
                IA_CSS_LEAVE_ERR_PRIVATE(-EINVAL);
                return -EINVAL;
        }

#if defined(ISP2401)
        /* For CSI2+, the continuous frame will hold the full input frame */
        ref_info.res.width = pipe->stream->config.input_config.input_res.width;
        ref_info.res.height = pipe->stream->config.input_config.input_res.height;

        /* Ensure padded width is aligned for 2401 */
        ref_info.padded_width = CEIL_MUL(ref_info.res.width, 2 * ISP_VEC_NELEMS);
#endif

#if !defined(HAS_NO_PACKED_RAW_PIXELS)
        if (pipe->stream->config.pack_raw_pixels) {
                ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                                    "alloc_continuous_frames() IA_CSS_FRAME_FORMAT_RAW_PACKED\n");
                ref_info.format = IA_CSS_FRAME_FORMAT_RAW_PACKED;
        } else
#endif
        {
                ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                                    "alloc_continuous_frames() IA_CSS_FRAME_FORMAT_RAW\n");
                ref_info.format = IA_CSS_FRAME_FORMAT_RAW;
        }

        /* Write format back to binary */
        if (pipe_id == IA_CSS_PIPE_ID_PREVIEW) {
                pipe->pipe_settings.preview.preview_binary.in_frame_info.format =
                    ref_info.format;
        } else if (pipe_id == IA_CSS_PIPE_ID_VIDEO) {
                pipe->pipe_settings.video.video_binary.in_frame_info.format = ref_info.format;
        } else {
                /* should not happen */
                IA_CSS_LEAVE_ERR_PRIVATE(-EINVAL);
                return -EINVAL;
        }

        if (init_time)
                idx = 0;
        else
                idx = pipe->stream->config.init_num_cont_raw_buf;

        for (i = idx; i < NUM_CONTINUOUS_FRAMES; i++) {
                /* free previous frame */
                if (pipe->continuous_frames[i]) {
                        ia_css_frame_free(pipe->continuous_frames[i]);
                        pipe->continuous_frames[i] = NULL;
                }
                /* free previous metadata buffer */
                ia_css_metadata_free(pipe->cont_md_buffers[i]);
                pipe->cont_md_buffers[i] = NULL;

                /* check if new frame needed */
                if (i < num_frames) {
                        /* allocate new frame */
                        err = ia_css_frame_allocate_from_info(
                                  &pipe->continuous_frames[i],
                                  &ref_info);
                        if (err) {
                                IA_CSS_LEAVE_ERR_PRIVATE(err);
                                return err;
                        }
                        /* allocate metadata buffer */
                        pipe->cont_md_buffers[i] = ia_css_metadata_allocate(
                                                       &pipe->stream->info.metadata_info);
                }
        }
        IA_CSS_LEAVE_ERR_PRIVATE(0);
        return 0;
}

int
ia_css_alloc_continuous_frame_remain(struct ia_css_stream *stream)
{
        if (!stream)
                return -EINVAL;
        return alloc_continuous_frames(stream->continuous_pipe, false);
}

static int
load_preview_binaries(struct ia_css_pipe *pipe)
{
        struct ia_css_frame_info prev_in_info,
                prev_bds_out_info,
                prev_out_info,
                prev_vf_info;
        struct ia_css_binary_descr preview_descr;
        bool online;
        int err = 0;
        bool need_vf_pp = false;
        bool need_isp_copy_binary = false;
#ifdef ISP2401
        bool sensor = false;
#else
        bool continuous;
#endif
        /* preview only have 1 output pin now */
        struct ia_css_frame_info *pipe_out_info = &pipe->output_info[0];
        struct ia_css_preview_settings *mycs  = &pipe->pipe_settings.preview;

        IA_CSS_ENTER_PRIVATE("");
        assert(pipe);
        assert(pipe->stream);
        assert(pipe->mode == IA_CSS_PIPE_ID_PREVIEW);

        online = pipe->stream->config.online;
#ifdef ISP2401
        sensor = pipe->stream->config.mode == IA_CSS_INPUT_MODE_SENSOR;
#else
        continuous = pipe->stream->config.continuous;
#endif

        if (mycs->preview_binary.info)
                return 0;

        err = ia_css_util_check_input(&pipe->stream->config, false, false);
        if (err)
                return err;
        err = ia_css_frame_check_info(pipe_out_info);
        if (err)
                return err;

        /* Note: the current selection of vf_pp binary and
         * parameterization of the preview binary contains a few pieces
         * of hardcoded knowledge. This needs to be cleaned up such that
         * the binary selection becomes more generic.
         * The vf_pp binary is needed if one or more of the following features
         * are required:
         * 1. YUV downscaling.
         * 2. Digital zoom.
         * 3. An output format that is not supported by the preview binary.
         *    In practice this means something other than yuv_line or nv12.
         * The decision if the vf_pp binary is needed for YUV downscaling is
         * made after the preview binary selection, since some preview binaries
         * can perform the requested YUV downscaling.
         * */
        need_vf_pp = pipe->config.enable_dz;
        need_vf_pp |= pipe_out_info->format != IA_CSS_FRAME_FORMAT_YUV_LINE &&
        !(pipe_out_info->format == IA_CSS_FRAME_FORMAT_NV12 ||
          pipe_out_info->format == IA_CSS_FRAME_FORMAT_NV12_16 ||
          pipe_out_info->format == IA_CSS_FRAME_FORMAT_NV12_TILEY);

        /* Preview step 1 */
        if (pipe->vf_yuv_ds_input_info.res.width)
                prev_vf_info = pipe->vf_yuv_ds_input_info;
        else
                prev_vf_info = *pipe_out_info;
        /* If vf_pp is needed, then preview must output yuv_line.
         * The exception is when vf_pp is manually disabled, that is only
         * used in combination with a pipeline extension that requires
         * yuv_line as input.
         * */
        if (need_vf_pp)
                ia_css_frame_info_set_format(&prev_vf_info,
                                             IA_CSS_FRAME_FORMAT_YUV_LINE);

        err = ia_css_pipe_get_preview_binarydesc(
            pipe,
            &preview_descr,
            &prev_in_info,
            &prev_bds_out_info,
            &prev_out_info,
            &prev_vf_info);
        if (err)
                return err;
        err = ia_css_binary_find(&preview_descr, &mycs->preview_binary);
        if (err)
                return err;

        if (IS_ISP2401) {
                /* The delay latency determines the number of invalid frames after
                * a stream is started. */
                pipe->num_invalid_frames = pipe->dvs_frame_delay;
                pipe->info.num_invalid_frames = pipe->num_invalid_frames;

                ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE,
                                    "load_preview_binaries() num_invalid_frames=%d dvs_frame_delay=%d\n",
                                    pipe->num_invalid_frames, pipe->dvs_frame_delay);
        }

        /* The vf_pp binary is needed when (further) YUV downscaling is required */
        need_vf_pp |= mycs->preview_binary.out_frame_info[0].res.width != pipe_out_info->res.width;
        need_vf_pp |= mycs->preview_binary.out_frame_info[0].res.height != pipe_out_info->res.height;

        /* When vf_pp is needed, then the output format of the selected
         * preview binary must be yuv_line. If this is not the case,
         * then the preview binary selection is done again.
         */
        if (need_vf_pp &&
            (mycs->preview_binary.out_frame_info[0].format != IA_CSS_FRAME_FORMAT_YUV_LINE)) {
                /* Preview step 2 */
                if (pipe->vf_yuv_ds_input_info.res.width)
                        prev_vf_info = pipe->vf_yuv_ds_input_info;
                else
                        prev_vf_info = *pipe_out_info;

                ia_css_frame_info_set_format(&prev_vf_info,
                                             IA_CSS_FRAME_FORMAT_YUV_LINE);

                err = ia_css_pipe_get_preview_binarydesc(
                    pipe,
                    &preview_descr,
                    &prev_in_info,
                    &prev_bds_out_info,
                    &prev_out_info,
                    &prev_vf_info);
                if (err)
                        return err;
                err = ia_css_binary_find(&preview_descr,
                                         &mycs->preview_binary);
                if (err)
                        return err;
        }

        if (need_vf_pp) {
                struct ia_css_binary_descr vf_pp_descr;

                /* Viewfinder post-processing */
                ia_css_pipe_get_vfpp_binarydesc(pipe, &vf_pp_descr,
                                                &mycs->preview_binary.out_frame_info[0],
                                                pipe_out_info);
                err = ia_css_binary_find(&vf_pp_descr,
                                         &mycs->vf_pp_binary);
                if (err)
                        return err;
        }

#ifdef ISP2401
        /* When the input system is 2401, only the Direct Sensor Mode
         * Offline Preview uses the ISP copy binary.
         */
        need_isp_copy_binary = !online && sensor;
#else
        /* About pipe->stream->config.mode == IA_CSS_INPUT_MODE_MEMORY:
         * This is typical the case with SkyCam (which has no input system) but it also applies to all cases
         * where the driver chooses for memory based input frames. In these cases, a copy binary (which typical
         * copies sensor data to DDR) does not have much use.
         */
        if (!IS_ISP2401)
                need_isp_copy_binary = !online && !continuous;
        else
                need_isp_copy_binary = !online && !continuous && !(pipe->stream->config.mode == IA_CSS_INPUT_MODE_MEMORY);
#endif

        /* Copy */
        if (need_isp_copy_binary) {
                err = load_copy_binary(pipe,
                                       &mycs->copy_binary,
                                       &mycs->preview_binary);
                if (err)
                        return err;
        }

        if (pipe->shading_table) {
                ia_css_shading_table_free(pipe->shading_table);
                pipe->shading_table = NULL;
        }

        return 0;
}

static void
ia_css_binary_unload(struct ia_css_binary *binary)
{
        ia_css_binary_destroy_isp_parameters(binary);
}

static int
unload_preview_binaries(struct ia_css_pipe *pipe)
{
        IA_CSS_ENTER_PRIVATE("pipe = %p", pipe);

        if ((!pipe) || (pipe->mode != IA_CSS_PIPE_ID_PREVIEW)) {
                IA_CSS_LEAVE_ERR_PRIVATE(-EINVAL);
                return -EINVAL;
        }
        ia_css_binary_unload(&pipe->pipe_settings.preview.copy_binary);
        ia_css_binary_unload(&pipe->pipe_settings.preview.preview_binary);
        ia_css_binary_unload(&pipe->pipe_settings.preview.vf_pp_binary);

        IA_CSS_LEAVE_ERR_PRIVATE(0);
        return 0;
}

static const struct ia_css_fw_info *last_output_firmware(
    const struct ia_css_fw_info *fw)
{
        const struct ia_css_fw_info *last_fw = NULL;
        /* fw can be NULL */
        IA_CSS_ENTER_LEAVE_PRIVATE("");

        for (; fw; fw = fw->next) {
                const struct ia_css_fw_info *info = fw;

                if (info->info.isp.sp.enable.output)
                        last_fw = fw;
        }
        return last_fw;
}

static int add_firmwares(
    struct ia_css_pipeline *me,
    struct ia_css_binary *binary,
    const struct ia_css_fw_info *fw,
    const struct ia_css_fw_info *last_fw,
    unsigned int binary_mode,
    struct ia_css_frame *in_frame,
    struct ia_css_frame *out_frame,
    struct ia_css_frame *vf_frame,
    struct ia_css_pipeline_stage **my_stage,
    struct ia_css_pipeline_stage **vf_stage)
{
        int err = 0;
        struct ia_css_pipeline_stage *extra_stage = NULL;
        struct ia_css_pipeline_stage_desc stage_desc;

        /* all args can be NULL ??? */
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                            "add_firmwares() enter:\n");

        for (; fw; fw = fw->next) {
                struct ia_css_frame *out[IA_CSS_BINARY_MAX_OUTPUT_PORTS] = {NULL};
                struct ia_css_frame *in = NULL;
                struct ia_css_frame *vf = NULL;

                if ((fw == last_fw) && (fw->info.isp.sp.enable.out_frame  != 0))
                        out[0] = out_frame;

                if (fw->info.isp.sp.enable.in_frame != 0)
                        in = in_frame;

                if (fw->info.isp.sp.enable.out_frame != 0)
                        vf = vf_frame;

                ia_css_pipe_get_firmwares_stage_desc(&stage_desc, binary,
                                                     out, in, vf, fw, binary_mode);
                err = ia_css_pipeline_create_and_add_stage(me, &stage_desc,
                                                           &extra_stage);
                if (err)
                        return err;

                if (fw->info.isp.sp.enable.output != 0)
                        in_frame = extra_stage->args.out_frame[0];
                if (my_stage && !*my_stage && extra_stage)
                        *my_stage = extra_stage;
                if (vf_stage && !*vf_stage && extra_stage &&
                    fw->info.isp.sp.enable.vf_veceven)
                        *vf_stage = extra_stage;
        }
        return err;
}

static int add_vf_pp_stage(
    struct ia_css_pipe *pipe,
    struct ia_css_frame *in_frame,
    struct ia_css_frame *out_frame,
    struct ia_css_binary *vf_pp_binary,
    struct ia_css_pipeline_stage **vf_pp_stage)
{
        struct ia_css_pipeline *me = NULL;
        const struct ia_css_fw_info *last_fw = NULL;
        int err = 0;
        struct ia_css_frame *out_frames[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
        struct ia_css_pipeline_stage_desc stage_desc;

        /* out_frame can be NULL ??? */

        if (!pipe)
                return -EINVAL;
        if (!in_frame)
                return -EINVAL;
        if (!vf_pp_binary)
                return -EINVAL;
        if (!vf_pp_stage)
                return -EINVAL;

        ia_css_pipe_util_create_output_frames(out_frames);
        me = &pipe->pipeline;

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                            "add_vf_pp_stage() enter:\n");

        *vf_pp_stage = NULL;

        last_fw = last_output_firmware(pipe->vf_stage);
        if (!pipe->extra_config.disable_vf_pp) {
                if (last_fw) {
                        ia_css_pipe_util_set_output_frames(out_frames, 0, NULL);
                        ia_css_pipe_get_generic_stage_desc(&stage_desc, vf_pp_binary,
                                                           out_frames, in_frame, NULL);
                } else {
                        ia_css_pipe_util_set_output_frames(out_frames, 0, out_frame);
                        ia_css_pipe_get_generic_stage_desc(&stage_desc, vf_pp_binary,
                                                           out_frames, in_frame, NULL);
                }
                err = ia_css_pipeline_create_and_add_stage(me, &stage_desc, vf_pp_stage);
                if (err)
                        return err;
                in_frame = (*vf_pp_stage)->args.out_frame[0];
        }
        err = add_firmwares(me, vf_pp_binary, pipe->vf_stage, last_fw,
                            IA_CSS_BINARY_MODE_VF_PP,
                            in_frame, out_frame, NULL,
                            vf_pp_stage, NULL);
        return err;
}

static int add_yuv_scaler_stage(
    struct ia_css_pipe *pipe,
    struct ia_css_pipeline *me,
    struct ia_css_frame *in_frame,
    struct ia_css_frame *out_frame,
    struct ia_css_frame *internal_out_frame,
    struct ia_css_binary *yuv_scaler_binary,
    struct ia_css_pipeline_stage **pre_vf_pp_stage)
{
        const struct ia_css_fw_info *last_fw;
        int err = 0;
        struct ia_css_frame *vf_frame = NULL;
        struct ia_css_frame *out_frames[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
        struct ia_css_pipeline_stage_desc stage_desc;

        /* out_frame can be NULL ??? */
        assert(in_frame);
        assert(pipe);
        assert(me);
        assert(yuv_scaler_binary);
        assert(pre_vf_pp_stage);
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                            "add_yuv_scaler_stage() enter:\n");

        *pre_vf_pp_stage = NULL;
        ia_css_pipe_util_create_output_frames(out_frames);

        last_fw = last_output_firmware(pipe->output_stage);

        if (last_fw) {
                ia_css_pipe_util_set_output_frames(out_frames, 0, NULL);
                ia_css_pipe_get_generic_stage_desc(&stage_desc,
                                                   yuv_scaler_binary, out_frames, in_frame, vf_frame);
        } else {
                ia_css_pipe_util_set_output_frames(out_frames, 0, out_frame);
                ia_css_pipe_util_set_output_frames(out_frames, 1, internal_out_frame);
                ia_css_pipe_get_generic_stage_desc(&stage_desc,
                                                   yuv_scaler_binary, out_frames, in_frame, vf_frame);
        }
        err = ia_css_pipeline_create_and_add_stage(me, &stage_desc,
                                                   pre_vf_pp_stage);
        if (err)
                return err;
        in_frame = (*pre_vf_pp_stage)->args.out_frame[0];

        err = add_firmwares(me, yuv_scaler_binary, pipe->output_stage, last_fw,
                            IA_CSS_BINARY_MODE_CAPTURE_PP,
                            in_frame, out_frame, vf_frame,
                            NULL, pre_vf_pp_stage);
        /* If a firmware produce vf_pp output, we set that as vf_pp input */
        (*pre_vf_pp_stage)->args.vf_downscale_log2 =
            yuv_scaler_binary->vf_downscale_log2;

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                            "add_yuv_scaler_stage() leave:\n");
        return err;
}

static int add_capture_pp_stage(
    struct ia_css_pipe *pipe,
    struct ia_css_pipeline *me,
    struct ia_css_frame *in_frame,
    struct ia_css_frame *out_frame,
    struct ia_css_binary *capture_pp_binary,
    struct ia_css_pipeline_stage **capture_pp_stage)
{
        const struct ia_css_fw_info *last_fw = NULL;
        int err = 0;
        struct ia_css_frame *vf_frame = NULL;
        struct ia_css_frame *out_frames[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
        struct ia_css_pipeline_stage_desc stage_desc;

        /* out_frame can be NULL ??? */
        assert(in_frame);
        assert(pipe);
        assert(me);
        assert(capture_pp_binary);
        assert(capture_pp_stage);
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                            "add_capture_pp_stage() enter:\n");

        *capture_pp_stage = NULL;
        ia_css_pipe_util_create_output_frames(out_frames);

        last_fw = last_output_firmware(pipe->output_stage);
        err = ia_css_frame_allocate_from_info(&vf_frame,
                                              &capture_pp_binary->vf_frame_info);
        if (err)
                return err;
        if (last_fw)    {
                ia_css_pipe_util_set_output_frames(out_frames, 0, NULL);
                ia_css_pipe_get_generic_stage_desc(&stage_desc,
                                                   capture_pp_binary, out_frames, NULL, vf_frame);
        } else {
                ia_css_pipe_util_set_output_frames(out_frames, 0, out_frame);
                ia_css_pipe_get_generic_stage_desc(&stage_desc,
                                                   capture_pp_binary, out_frames, NULL, vf_frame);
        }
        err = ia_css_pipeline_create_and_add_stage(me, &stage_desc,
                                                   capture_pp_stage);
        if (err)
                return err;
        err = add_firmwares(me, capture_pp_binary, pipe->output_stage, last_fw,
                            IA_CSS_BINARY_MODE_CAPTURE_PP,
                            in_frame, out_frame, vf_frame,
                            NULL, capture_pp_stage);
        /* If a firmware produce vf_pp output, we set that as vf_pp input */
        if (*capture_pp_stage) {
                (*capture_pp_stage)->args.vf_downscale_log2 =
                    capture_pp_binary->vf_downscale_log2;
        }
        return err;
}

static void sh_css_setup_queues(void)
{
        const struct ia_css_fw_info *fw;
        unsigned int HIVE_ADDR_host_sp_queues_initialized;

        sh_css_hmm_buffer_record_init();

        sh_css_event_init_irq_mask();

        fw = &sh_css_sp_fw;
        HIVE_ADDR_host_sp_queues_initialized =
            fw->info.sp.host_sp_queues_initialized;

        ia_css_bufq_init();

        /* set "host_sp_queues_initialized" to "true" */
        sp_dmem_store_uint32(SP0_ID,
                             (unsigned int)sp_address_of(host_sp_queues_initialized),
                             (uint32_t)(1));
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "sh_css_setup_queues() leave:\n");
}

static int
init_vf_frameinfo_defaults(struct ia_css_pipe *pipe,
                           struct ia_css_frame *vf_frame, unsigned int idx)
{
        int err = 0;
        unsigned int thread_id;
        enum sh_css_queue_id queue_id;

        assert(vf_frame);

        sh_css_pipe_get_viewfinder_frame_info(pipe, &vf_frame->info, idx);
        vf_frame->contiguous = false;
        vf_frame->flash_state = IA_CSS_FRAME_FLASH_STATE_NONE;
        ia_css_pipeline_get_sp_thread_id(ia_css_pipe_get_pipe_num(pipe), &thread_id);
        ia_css_query_internal_queue_id(IA_CSS_BUFFER_TYPE_VF_OUTPUT_FRAME + idx, thread_id, &queue_id);
        vf_frame->dynamic_queue_id = queue_id;
        vf_frame->buf_type = IA_CSS_BUFFER_TYPE_VF_OUTPUT_FRAME + idx;

        err = ia_css_frame_init_planes(vf_frame);
        return err;
}

#ifdef ISP2401
static unsigned int
get_crop_lines_for_bayer_order(const struct ia_css_stream_config *config)
{
        assert(config);
        if ((config->input_config.bayer_order == IA_CSS_BAYER_ORDER_BGGR) ||
            (config->input_config.bayer_order == IA_CSS_BAYER_ORDER_GBRG))
                return 1;

        return 0;
}

static unsigned int
get_crop_columns_for_bayer_order(const struct ia_css_stream_config *config)
{
        assert(config);
        if ((config->input_config.bayer_order == IA_CSS_BAYER_ORDER_RGGB) ||
            (config->input_config.bayer_order == IA_CSS_BAYER_ORDER_GBRG))
                return 1;

        return 0;
}

/* This function is to get the sum of all extra pixels in addition to the effective
 * input, it includes dvs envelop and filter run-in */
static void get_pipe_extra_pixel(struct ia_css_pipe *pipe,
                                 unsigned int *extra_row, unsigned int *extra_column)
{
        enum ia_css_pipe_id pipe_id = pipe->mode;
        unsigned int left_cropping = 0, top_cropping = 0;
        unsigned int i;
        struct ia_css_resolution dvs_env = pipe->config.dvs_envelope;

        /* The dvs envelope info may not be correctly sent down via pipe config
         * The check is made and the correct value is populated in the binary info
         * Use this value when computing crop, else excess lines may get trimmed
         */
        switch (pipe_id) {
        case IA_CSS_PIPE_ID_PREVIEW:
                if (pipe->pipe_settings.preview.preview_binary.info) {
                        left_cropping =
                            pipe->pipe_settings.preview.preview_binary.info->sp.pipeline.left_cropping;
                        top_cropping =
                            pipe->pipe_settings.preview.preview_binary.info->sp.pipeline.top_cropping;
                }
                dvs_env = pipe->pipe_settings.preview.preview_binary.dvs_envelope;
                break;
        case IA_CSS_PIPE_ID_VIDEO:
                if (pipe->pipe_settings.video.video_binary.info) {
                        left_cropping =
                            pipe->pipe_settings.video.video_binary.info->sp.pipeline.left_cropping;
                        top_cropping =
                            pipe->pipe_settings.video.video_binary.info->sp.pipeline.top_cropping;
                }
                dvs_env = pipe->pipe_settings.video.video_binary.dvs_envelope;
                break;
        case IA_CSS_PIPE_ID_CAPTURE:
                for (i = 0; i < pipe->pipe_settings.capture.num_primary_stage; i++) {
                        if (pipe->pipe_settings.capture.primary_binary[i].info) {
                                left_cropping +=
                                    pipe->pipe_settings.capture.primary_binary[i].info->sp.pipeline.left_cropping;
                                top_cropping +=
                                    pipe->pipe_settings.capture.primary_binary[i].info->sp.pipeline.top_cropping;
                        }
                        dvs_env.width +=
                            pipe->pipe_settings.capture.primary_binary[i].dvs_envelope.width;
                        dvs_env.height +=
                            pipe->pipe_settings.capture.primary_binary[i].dvs_envelope.height;
                }
                break;
        default:
                break;
        }

        *extra_row = top_cropping + dvs_env.height;
        *extra_column = left_cropping + dvs_env.width;
}

void
ia_css_get_crop_offsets(
    struct ia_css_pipe *pipe,
    struct ia_css_frame_info *in_frame)
{
        unsigned int row = 0;
        unsigned int column = 0;
        struct ia_css_resolution *input_res;
        struct ia_css_resolution *effective_res;
        unsigned int extra_row = 0, extra_col = 0;
        unsigned int min_reqd_height, min_reqd_width;

        assert(pipe);
        assert(pipe->stream);
        assert(in_frame);

        IA_CSS_ENTER_PRIVATE("pipe = %p effective_wd = %u effective_ht = %u",
                             pipe, pipe->config.input_effective_res.width,
                             pipe->config.input_effective_res.height);

        input_res = &pipe->stream->config.input_config.input_res;
#ifndef ISP2401
        effective_res = &pipe->stream->config.input_config.effective_res;
#else
        effective_res = &pipe->config.input_effective_res;
#endif

        get_pipe_extra_pixel(pipe, &extra_row, &extra_col);

        in_frame->raw_bayer_order = pipe->stream->config.input_config.bayer_order;

        min_reqd_height = effective_res->height + extra_row;
        min_reqd_width = effective_res->width + extra_col;

        if (input_res->height > min_reqd_height) {
                row = (input_res->height - min_reqd_height) / 2;
                row &= ~0x1;
        }
        if (input_res->width > min_reqd_width) {
                column = (input_res->width - min_reqd_width) / 2;
                column &= ~0x1;
        }

        /*
         * TODO:
         * 1. Require the special support for RAW10 packed mode.
         * 2. Require the special support for the online use cases.
         */

        /* ISP expects GRBG bayer order, we skip one line and/or one row
         * to correct in case the input bayer order is different.
         */
        column += get_crop_columns_for_bayer_order(&pipe->stream->config);
        row += get_crop_lines_for_bayer_order(&pipe->stream->config);

        in_frame->crop_info.start_column = column;
        in_frame->crop_info.start_line = row;

        IA_CSS_LEAVE_PRIVATE("void start_col: %u start_row: %u", column, row);

        return;
}
#endif

static int
init_in_frameinfo_memory_defaults(struct ia_css_pipe *pipe,
                                  struct ia_css_frame *frame, enum ia_css_frame_format format)
{
        struct ia_css_frame *in_frame;
        int err = 0;
        unsigned int thread_id;
        enum sh_css_queue_id queue_id;

        assert(frame);
        in_frame = frame;

        in_frame->info.format = format;

#ifdef ISP2401
        if (format == IA_CSS_FRAME_FORMAT_RAW)
                in_frame->info.format = (pipe->stream->config.pack_raw_pixels) ?
                IA_CSS_FRAME_FORMAT_RAW_PACKED : IA_CSS_FRAME_FORMAT_RAW;
#endif

        in_frame->info.res.width = pipe->stream->config.input_config.input_res.width;
        in_frame->info.res.height = pipe->stream->config.input_config.input_res.height;
        in_frame->info.raw_bit_depth =
        ia_css_pipe_util_pipe_input_format_bpp(pipe);
        ia_css_frame_info_set_width(&in_frame->info, pipe->stream->config.input_config.input_res.width, 0);
        in_frame->contiguous = false;
        in_frame->flash_state = IA_CSS_FRAME_FLASH_STATE_NONE;
        ia_css_pipeline_get_sp_thread_id(ia_css_pipe_get_pipe_num(pipe), &thread_id);
        ia_css_query_internal_queue_id(IA_CSS_BUFFER_TYPE_INPUT_FRAME, thread_id, &queue_id);
        in_frame->dynamic_queue_id = queue_id;
        in_frame->buf_type = IA_CSS_BUFFER_TYPE_INPUT_FRAME;
#ifdef ISP2401
        ia_css_get_crop_offsets(pipe, &in_frame->info);
#endif
        err = ia_css_frame_init_planes(in_frame);

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                            "init_in_frameinfo_memory_defaults() bayer_order = %d:\n", in_frame->info.raw_bayer_order);

        return err;
}

static int
init_out_frameinfo_defaults(struct ia_css_pipe *pipe,
                            struct ia_css_frame *out_frame, unsigned int idx)
{
        int err = 0;
        unsigned int thread_id;
        enum sh_css_queue_id queue_id;

        assert(out_frame);

        sh_css_pipe_get_output_frame_info(pipe, &out_frame->info, idx);
        out_frame->contiguous = false;
        out_frame->flash_state = IA_CSS_FRAME_FLASH_STATE_NONE;
        ia_css_pipeline_get_sp_thread_id(ia_css_pipe_get_pipe_num(pipe), &thread_id);
        ia_css_query_internal_queue_id(IA_CSS_BUFFER_TYPE_OUTPUT_FRAME + idx, thread_id, &queue_id);
        out_frame->dynamic_queue_id = queue_id;
        out_frame->buf_type = IA_CSS_BUFFER_TYPE_OUTPUT_FRAME + idx;
        err = ia_css_frame_init_planes(out_frame);

        return err;
}

/* Create stages for video pipe */
static int create_host_video_pipeline(struct ia_css_pipe *pipe)
{
        struct ia_css_pipeline_stage_desc stage_desc;
        struct ia_css_binary *copy_binary, *video_binary,
                       *yuv_scaler_binary, *vf_pp_binary;
        struct ia_css_pipeline_stage *copy_stage  = NULL;
        struct ia_css_pipeline_stage *video_stage = NULL;
        struct ia_css_pipeline_stage *yuv_scaler_stage  = NULL;
        struct ia_css_pipeline_stage *vf_pp_stage = NULL;
        struct ia_css_pipeline *me;
        struct ia_css_frame *in_frame = NULL;
        struct ia_css_frame *out_frame;
        struct ia_css_frame *out_frames[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
        struct ia_css_frame *vf_frame = NULL;
        int err = 0;
        bool need_copy   = false;
        bool need_vf_pp  = false;
        bool need_yuv_pp = false;
        bool need_in_frameinfo_memory = false;

        unsigned int i, num_yuv_scaler;
        bool *is_output_stage = NULL;

        IA_CSS_ENTER_PRIVATE("pipe = %p", pipe);
        if ((!pipe) || (!pipe->stream) || (pipe->mode != IA_CSS_PIPE_ID_VIDEO)) {
                IA_CSS_LEAVE_ERR_PRIVATE(-EINVAL);
                return -EINVAL;
        }
        ia_css_pipe_util_create_output_frames(out_frames);
        out_frame = &pipe->out_frame_struct;

        /* pipeline already created as part of create_host_pipeline_structure */
        me = &pipe->pipeline;
        ia_css_pipeline_clean(me);

        me->dvs_frame_delay = pipe->dvs_frame_delay;

#ifdef ISP2401
        /* When the input system is 2401, always enable 'in_frameinfo_memory'
         * except for the following: online or continuous
         */
        need_in_frameinfo_memory = !(pipe->stream->config.online ||
                                     pipe->stream->config.continuous);
#else
        /* Construct in_frame info (only in case we have dynamic input */
        need_in_frameinfo_memory = pipe->stream->config.mode ==
                                   IA_CSS_INPUT_MODE_MEMORY;
#endif

        /* Construct in_frame info (only in case we have dynamic input */
        if (need_in_frameinfo_memory) {
                in_frame = &pipe->in_frame_struct;
                err = init_in_frameinfo_memory_defaults(pipe, in_frame,
                                                        IA_CSS_FRAME_FORMAT_RAW);
                if (err)
                        goto ERR;
        }

        out_frame->data = 0;
        err = init_out_frameinfo_defaults(pipe, out_frame, 0);
        if (err)
                goto ERR;

        if (pipe->enable_viewfinder[IA_CSS_PIPE_OUTPUT_STAGE_0]) {
                vf_frame = &pipe->vf_frame_struct;
                vf_frame->data = 0;
                err = init_vf_frameinfo_defaults(pipe, vf_frame, 0);
                if (err)
                        goto ERR;
        }

        copy_binary  = &pipe->pipe_settings.video.copy_binary;
        video_binary = &pipe->pipe_settings.video.video_binary;
        vf_pp_binary = &pipe->pipe_settings.video.vf_pp_binary;

        yuv_scaler_binary = pipe->pipe_settings.video.yuv_scaler_binary;
        num_yuv_scaler  = pipe->pipe_settings.video.num_yuv_scaler;
        is_output_stage = pipe->pipe_settings.video.is_output_stage;

        need_copy   = (copy_binary && copy_binary->info);
        need_vf_pp  = (vf_pp_binary && vf_pp_binary->info);
        need_yuv_pp = (yuv_scaler_binary && yuv_scaler_binary->info);

        if (need_copy) {
                ia_css_pipe_util_set_output_frames(out_frames, 0, NULL);
                ia_css_pipe_get_generic_stage_desc(&stage_desc, copy_binary,
                                                   out_frames, NULL, NULL);
                err = ia_css_pipeline_create_and_add_stage(me, &stage_desc,
                                                           &copy_stage);
                if (err)
                        goto ERR;
                in_frame = me->stages->args.out_frame[0];
        } else if (pipe->stream->config.continuous) {
#ifdef ISP2401
                /* When continuous is enabled, configure in_frame with the
                 * last pipe, which is the copy pipe.
                 */
                in_frame = pipe->stream->last_pipe->continuous_frames[0];
#else
                in_frame = pipe->continuous_frames[0];
#endif
        }

        ia_css_pipe_util_set_output_frames(out_frames, 0,
                                           need_yuv_pp ? NULL : out_frame);

        /* when the video binary supports a second output pin,
           it can directly produce the vf_frame.  */
        if (need_vf_pp) {
                ia_css_pipe_get_generic_stage_desc(&stage_desc, video_binary,
                                                   out_frames, in_frame, NULL);
        } else {
                ia_css_pipe_get_generic_stage_desc(&stage_desc, video_binary,
                                                   out_frames, in_frame, vf_frame);
        }
        err = ia_css_pipeline_create_and_add_stage(me, &stage_desc,
                                                   &video_stage);
        if (err)
                goto ERR;

        /* If we use copy iso video, the input must be yuv iso raw */
        if (video_stage) {
                video_stage->args.copy_vf =
                    video_binary->info->sp.pipeline.mode == IA_CSS_BINARY_MODE_COPY;
                video_stage->args.copy_output = video_stage->args.copy_vf;
        }

        /* when the video binary supports only 1 output pin, vf_pp is needed to
        produce the vf_frame.*/
        if (need_vf_pp && video_stage) {
                in_frame = video_stage->args.out_vf_frame;
                err = add_vf_pp_stage(pipe, in_frame, vf_frame, vf_pp_binary,
                                      &vf_pp_stage);
                if (err)
                        goto ERR;
        }
        if (video_stage) {
                int frm;

                for (frm = 0; frm < NUM_TNR_FRAMES; frm++) {
                        video_stage->args.tnr_frames[frm] =
                            pipe->pipe_settings.video.tnr_frames[frm];
                }
                for (frm = 0; frm < MAX_NUM_VIDEO_DELAY_FRAMES; frm++) {
                        video_stage->args.delay_frames[frm] =
                            pipe->pipe_settings.video.delay_frames[frm];
                }
        }

        /* Append Extension on Video out, if enabled */
        if (!need_vf_pp && video_stage && pipe->config.acc_extension &&
            (pipe->config.acc_extension->info.isp.type == IA_CSS_ACC_OUTPUT)) {
                struct ia_css_frame *out = NULL;
                struct ia_css_frame *in = NULL;

                if ((pipe->config.acc_extension->info.isp.sp.enable.output) &&
                    (pipe->config.acc_extension->info.isp.sp.enable.in_frame) &&
                    (pipe->config.acc_extension->info.isp.sp.enable.out_frame)) {
                        /* In/Out Frame mapping to support output frame extension.*/
                        out = video_stage->args.out_frame[0];
                        err = ia_css_frame_allocate_from_info(&in, &pipe->output_info[0]);
                        if (err)
                                goto ERR;
                        video_stage->args.out_frame[0] = in;
                }

                err = add_firmwares(me, video_binary, pipe->output_stage,
                                    last_output_firmware(pipe->output_stage),
                                    IA_CSS_BINARY_MODE_VIDEO,
                                    in, out, NULL, &video_stage, NULL);
                if (err)
                        goto ERR;
        }

        if (need_yuv_pp && video_stage) {
                struct ia_css_frame *tmp_in_frame = video_stage->args.out_frame[0];
                struct ia_css_frame *tmp_out_frame = NULL;

                for (i = 0; i < num_yuv_scaler; i++) {
                        tmp_out_frame = is_output_stage[i] ? out_frame : NULL;

                        err = add_yuv_scaler_stage(pipe, me, tmp_in_frame,
                                                   tmp_out_frame, NULL,
                                                   &yuv_scaler_binary[i],
                                                   &yuv_scaler_stage);

                        if (err) {
                                IA_CSS_LEAVE_ERR_PRIVATE(err);
                                return err;
                        }
                        /* we use output port 1 as internal output port */
                        if (yuv_scaler_stage)
                                tmp_in_frame = yuv_scaler_stage->args.out_frame[1];
                }
        }

        pipe->pipeline.acquire_isp_each_stage = false;
        ia_css_pipeline_finalize_stages(&pipe->pipeline,
                                        pipe->stream->config.continuous);

ERR:
        IA_CSS_LEAVE_ERR_PRIVATE(err);
        return err;
}

static int
create_host_acc_pipeline(struct ia_css_pipe *pipe)
{
        int err = 0;
        const struct ia_css_fw_info *fw;
        unsigned int i;

        IA_CSS_ENTER_PRIVATE("pipe = %p", pipe);
        if ((!pipe) || (!pipe->stream)) {
                IA_CSS_LEAVE_ERR_PRIVATE(-EINVAL);
                return -EINVAL;
        }

        pipe->pipeline.num_execs = pipe->config.acc_num_execs;
        /* Reset pipe_qos_config to default disable all QOS extension stages */
        if (pipe->config.acc_extension)
                pipe->pipeline.pipe_qos_config = 0;

        fw = pipe->vf_stage;
        for (i = 0; fw; fw = fw->next) {
                err = sh_css_pipeline_add_acc_stage(&pipe->pipeline, fw);
                if (err)
                        goto ERR;
        }

        for (i = 0; i < pipe->config.num_acc_stages; i++) {
                struct ia_css_fw_info *fw = pipe->config.acc_stages[i];

                err = sh_css_pipeline_add_acc_stage(&pipe->pipeline, fw);
                if (err)
                        goto ERR;
        }

        ia_css_pipeline_finalize_stages(&pipe->pipeline, pipe->stream->config.continuous);

ERR:
        IA_CSS_LEAVE_ERR_PRIVATE(err);
        return err;
}

/* Create stages for preview */
static int
create_host_preview_pipeline(struct ia_css_pipe *pipe)
{
        struct ia_css_pipeline_stage *copy_stage = NULL;
        struct ia_css_pipeline_stage *preview_stage = NULL;
        struct ia_css_pipeline_stage *vf_pp_stage = NULL;
        struct ia_css_pipeline_stage_desc stage_desc;
        struct ia_css_pipeline *me = NULL;
        struct ia_css_binary *copy_binary, *preview_binary, *vf_pp_binary = NULL;
        struct ia_css_frame *in_frame = NULL;
        int err = 0;
        struct ia_css_frame *out_frame;
        struct ia_css_frame *out_frames[IA_CSS_BINARY_MAX_OUTPUT_PORTS];
        bool need_in_frameinfo_memory = false;
#ifdef ISP2401
        bool sensor = false;
        bool buffered_sensor = false;
        bool online = false;
        bool continuous = false;
#endif

        IA_CSS_ENTER_PRIVATE("pipe = %p", pipe);
        if ((!pipe) || (!pipe->stream) || (pipe->mode != IA_CSS_PIPE_ID_PREVIEW)) {
                IA_CSS_LEAVE_ERR_PRIVATE(-EINVAL);
                return -EINVAL;
        }

        ia_css_pipe_util_create_output_frames(out_frames);
        /* pipeline already created as part of create_host_pipeline_structure */
        me = &pipe->pipeline;
        ia_css_pipeline_clean(me);

#ifdef ISP2401
        /* When the input system is 2401, always enable 'in_frameinfo_memory'
         * except for the following:
         * - Direct Sensor Mode Online Preview
         * - Buffered Sensor Mode Online Preview
         * - Direct Sensor Mode Continuous Preview
         * - Buffered Sensor Mode Continuous Preview
         */
        sensor = (pipe->stream->config.mode == IA_CSS_INPUT_MODE_SENSOR);
        buffered_sensor = (pipe->stream->config.mode == IA_CSS_INPUT_MODE_BUFFERED_SENSOR);
        online = pipe->stream->config.online;
        continuous = pipe->stream->config.continuous;
        need_in_frameinfo_memory =
        !((sensor && (online || continuous)) || (buffered_sensor && (online || continuous)));
#else
        /* Construct in_frame info (only in case we have dynamic input */
        need_in_frameinfo_memory = pipe->stream->config.mode == IA_CSS_INPUT_MODE_MEMORY;
#endif
        if (need_in_frameinfo_memory) {
                err = init_in_frameinfo_memory_defaults(pipe, &me->in_frame,
                                                        IA_CSS_FRAME_FORMAT_RAW);
                if (err)
                        goto ERR;

                in_frame = &me->in_frame;
        } else {
                in_frame = NULL;
        }

        err = init_out_frameinfo_defaults(pipe, &me->out_frame[0], 0);
        if (err)
                goto ERR;
        out_frame = &me->out_frame[0];

        copy_binary    = &pipe->pipe_settings.preview.copy_binary;
        preview_binary = &pipe->pipe_settings.preview.preview_binary;
        if (pipe->pipe_settings.preview.vf_pp_binary.info)
                vf_pp_binary = &pipe->pipe_settings.preview.vf_pp_binary;

        if (pipe->pipe_settings.preview.copy_binary.info) {
                ia_css_pipe_util_set_output_frames(out_frames, 0, NULL);
                ia_css_pipe_get_generic_stage_desc(&stage_desc, copy_binary,
                                                   out_frames, NULL, NULL);
                err = ia_css_pipeline_create_and_add_stage(me, &stage_desc,
                                                           &copy_stage);
                if (err)
                        goto ERR;
                in_frame = me->stages->args.out_frame[0];
        } else if (pipe->stream->config.continuous) {
#ifdef ISP2401
                /* When continuous is enabled, configure in_frame with the
                 * last pipe, which is the copy pipe.
                 */
                if (continuous || !online)
                        in_frame = pipe->stream->last_pipe->continuous_frames[0];

#else
                in_frame = pipe->continuous_frames[0];
#endif
        }

        if (vf_pp_binary) {
                ia_css_pipe_util_set_output_frames(out_frames, 0, NULL);
                ia_css_pipe_get_generic_stage_desc(&stage_desc, preview_binary,
                                                   out_frames, in_frame, NULL);
        } else {
                ia_css_pipe_util_set_output_frames(out_frames, 0, out_frame);
                ia_css_pipe_get_generic_stage_desc(&stage_desc, preview_binary,
                                                   out_frames, in_frame, NULL);
        }
        err = ia_css_pipeline_create_and_add_stage(me, &stage_desc,
                                                   &preview_stage);
        if (err)
                goto ERR;
        /* If we use copy iso preview, the input must be yuv iso raw */
        preview_stage->args.copy_vf =
            preview_binary->info->sp.pipeline.mode == IA_CSS_BINARY_MODE_COPY;
        preview_stage->args.copy_output = !preview_stage->args.copy_vf;
        if (preview_stage->args.copy_vf && !preview_stage->args.out_vf_frame) {
                /* in case of copy, use the vf frame as output frame */
                preview_stage->args.out_vf_frame =
                    preview_stage->args.out_frame[0];
        }
        if (vf_pp_binary) {
                if (preview_binary->info->sp.pipeline.mode == IA_CSS_BINARY_MODE_COPY)
                        in_frame = preview_stage->args.out_vf_frame;
                else
                        in_frame = preview_stage->args.out_frame[0];
                err = add_vf_pp_stage(pipe, in_frame, out_frame, vf_pp_binary,
                                      &vf_pp_stage);
                if (err)
                        goto ERR;
        }

        pipe->pipeline.acquire_isp_each_stage = false;
        ia_css_pipeline_finalize_stages(&pipe->pipeline, pipe->stream->config.continuous);

ERR:
        IA_CSS_LEAVE_ERR_PRIVATE(err);
        return err;
}

static void send_raw_frames(struct ia_css_pipe *pipe)
{
        if (pipe->stream->config.continuous) {
                unsigned int i;

                sh_css_update_host2sp_cont_num_raw_frames
                (pipe->stream->config.init_num_cont_raw_buf, true);
                sh_css_update_host2sp_cont_num_raw_frames
                (pipe->stream->config.target_num_cont_raw_buf, false);

                /* Hand-over all the SP-internal buffers */
                for (i = 0; i < pipe->stream->config.init_num_cont_raw_buf; i++) {
                        sh_css_update_host2sp_offline_frame(i,
                                                            pipe->continuous_frames[i], pipe->cont_md_buffers[i]);
                }
        }

        return;
}

static int
preview_start(struct ia_css_pipe *pipe)
{
        int err = 0;
        struct ia_css_pipe *copy_pipe, *capture_pipe;
        struct ia_css_pipe *acc_pipe;
        enum sh_css_pipe_config_override copy_ovrd;
        enum ia_css_input_mode preview_pipe_input_mode;
        const struct ia_css_coordinate *coord = NULL;
        const struct ia_css_isp_parameters *params = NULL;

        IA_CSS_ENTER_PRIVATE("pipe = %p", pipe);
        if ((!pipe) || (!pipe->stream) || (pipe->mode != IA_CSS_PIPE_ID_PREVIEW)) {
                IA_CSS_LEAVE_ERR_PRIVATE(-EINVAL);
                return -EINVAL;
        }

        preview_pipe_input_mode = pipe->stream->config.mode;

        copy_pipe    = pipe->pipe_settings.preview.copy_pipe;
        capture_pipe = pipe->pipe_settings.preview.capture_pipe;
        acc_pipe     = pipe->pipe_settings.preview.acc_pipe;

        sh_css_metrics_start_frame();

        /* multi stream video needs mipi buffers */
        err = send_mipi_frames(pipe);
        if (err) {
                IA_CSS_LEAVE_ERR_PRIVATE(err);
                return err;
        }
        send_raw_frames(pipe);

        {
                unsigned int thread_id;

                ia_css_pipeline_get_sp_thread_id(ia_css_pipe_get_pipe_num(pipe), &thread_id);
                copy_ovrd = 1 << thread_id;

                if (pipe->stream->cont_capt) {
                        ia_css_pipeline_get_sp_thread_id(ia_css_pipe_get_pipe_num(capture_pipe),
                                                         &thread_id);
                        copy_ovrd |= 1 << thread_id;
                }
        }

        if (IS_ISP2401) {
                coord = &pipe->config.internal_frame_origin_bqs_on_sctbl;
                params = pipe->stream->isp_params_configs;
        }

        /* Construct and load the copy pipe */
        if (pipe->stream->config.continuous) {
                sh_css_sp_init_pipeline(&copy_pipe->pipeline,
                                        IA_CSS_PIPE_ID_COPY,
                                        (uint8_t)ia_css_pipe_get_pipe_num(copy_pipe),
                                        false,
                                        pipe->stream->config.pixels_per_clock == 2, false,
                                        false, pipe->required_bds_factor,
                                        copy_ovrd,
                                        pipe->stream->config.mode,
                                        &pipe->stream->config.metadata_config,
                                        &pipe->stream->info.metadata_info,
                                        pipe->stream->config.source.port.port,
                                        coord,
                                        params);

                /* make the preview pipe start with mem mode input, copy handles
                   the actual mode */
                preview_pipe_input_mode = IA_CSS_INPUT_MODE_MEMORY;
        }

        /* Construct and load the capture pipe */
        if (pipe->stream->cont_capt) {
                sh_css_sp_init_pipeline(&capture_pipe->pipeline,
                                        IA_CSS_PIPE_ID_CAPTURE,
                                        (uint8_t)ia_css_pipe_get_pipe_num(capture_pipe),
                                        capture_pipe->config.default_capture_config.enable_xnr != 0,
                                        capture_pipe->stream->config.pixels_per_clock == 2,
                                        true, /* continuous */
                                        false, /* offline */
                                        capture_pipe->required_bds_factor,
                                        0,
                                        IA_CSS_INPUT_MODE_MEMORY,
                                        &pipe->stream->config.metadata_config,
                                        &pipe->stream->info.metadata_info,
                                        (enum mipi_port_id)0,
                                        coord,
                                        params);
        }

        if (acc_pipe) {
                sh_css_sp_init_pipeline(&acc_pipe->pipeline,
                                        IA_CSS_PIPE_ID_ACC,
                                        (uint8_t)ia_css_pipe_get_pipe_num(acc_pipe),
                                        false,
                                        pipe->stream->config.pixels_per_clock == 2,
                                        false, /* continuous */
                                        false, /* offline */
                                        pipe->required_bds_factor,
                                        0,
                                        IA_CSS_INPUT_MODE_MEMORY,
                                        NULL,
                                        NULL,
                                        (enum mipi_port_id)0,
                                        coord,
                                        params);
        }

        start_pipe(pipe, copy_ovrd, preview_pipe_input_mode);

        IA_CSS_LEAVE_ERR_PRIVATE(err);
        return err;
}

int
ia_css_pipe_enqueue_buffer(struct ia_css_pipe *pipe,
                           const struct ia_css_buffer *buffer)
{
        int return_err = 0;
        unsigned int thread_id;
        enum sh_css_queue_id queue_id;
        struct ia_css_pipeline *pipeline;
        struct ia_css_pipeline_stage *stage;
        struct ia_css_rmgr_vbuf_handle p_vbuf;
        struct ia_css_rmgr_vbuf_handle *h_vbuf;
        struct sh_css_hmm_buffer ddr_buffer;
        enum ia_css_buffer_type buf_type;
        enum ia_css_pipe_id pipe_id;
        bool ret_err;

        IA_CSS_ENTER("pipe=%p, buffer=%p", pipe, buffer);

        if ((!pipe) || (!buffer)) {
                IA_CSS_LEAVE_ERR(-EINVAL);
                return -EINVAL;
        }

        buf_type = buffer->type;
        /* following code will be enabled when IA_CSS_BUFFER_TYPE_SEC_OUTPUT_FRAME
           is removed */
#if 0
        if (buf_type == IA_CSS_BUFFER_TYPE_OUTPUT_FRAME) {
                bool found_pipe = false;

                for (i = 0; i < IA_CSS_PIPE_MAX_OUTPUT_STAGE; i++) {
                        if ((buffer->data.frame->info.res.width == pipe->output_info[i].res.width) &&
                            (buffer->data.frame->info.res.height == pipe->output_info[i].res.height)) {
                                buf_type += i;
                                found_pipe = true;
                                break;
                        }
                }
                if (!found_pipe)
                        return -EINVAL;
        }
        if (buf_type == IA_CSS_BUFFER_TYPE_VF_OUTPUT_FRAME) {
                bool found_pipe = false;

                for (i = 0; i < IA_CSS_PIPE_MAX_OUTPUT_STAGE; i++) {
                        if ((buffer->data.frame->info.res.width == pipe->vf_output_info[i].res.width) &&
                            (buffer->data.frame->info.res.height == pipe->vf_output_info[i].res.height)) {
                                buf_type += i;
                                found_pipe = true;
                                break;
                        }
                }
                if (!found_pipe)
                        return -EINVAL;