/*
 * 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 "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 */
#if !defined(HAS_NO_INPUT_SYSTEM)
#include "ia_css_isys.h"
#endif
#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"
#ifdef USE_INPUT_SYSTEM_VERSION_2
#include "ia_css_isys.h"
#endif

#include "memory_access.h"
#include "tag.h"
#include "assert_support.h"
#include "math_support.h"
#include "sw_event_global.h"                    /* Event IDs.*/
#if !defined(HAS_NO_INPUT_FORMATTER)
#include "ia_css_ifmtr.h"
#endif
#if !defined(HAS_NO_INPUT_SYSTEM)
#include "input_system.h"
#endif
#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 "platform_support.h" /* hrt_sleep(), inline */
#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 (*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;
        uint32_t                       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 (1 << HIVE_GPIO_STROBE_TRIGGER_PIN)

static bool fw_explicitly_loaded = false;

/*
 * Local prototypes
 */

static enum ia_css_err
allocate_delay_frames(struct ia_css_pipe *pipe);

static enum ia_css_err
sh_css_pipe_start(struct ia_css_stream *stream);

#ifdef ISP2401
/*
 * @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
 * - IA_CSS_SUCCESS, 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 enum ia_css_err
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.
 */
static bool
sh_css_pipes_have_stopped(struct ia_css_stream *stream);

static enum ia_css_err
ia_css_pipe_check_format(struct ia_css_pipe *pipe, enum ia_css_frame_format format);

static enum ia_css_err
check_pipe_resolutions(const struct ia_css_pipe *pipe);

#endif

static enum ia_css_err
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 enum ia_css_err 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 enum ia_css_err 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 enum ia_css_err
sh_css_pipe_load_binaries(struct ia_css_pipe *pipe);

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

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

static enum ia_css_err
capture_start(struct ia_css_pipe *pipe);

static enum ia_css_err
video_start(struct ia_css_pipe *pipe);

static enum ia_css_err
preview_start(struct ia_css_pipe *pipe);

static enum ia_css_err
yuvpp_start(struct ia_css_pipe *pipe);

static bool copy_on_sp(struct ia_css_pipe *pipe);

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

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

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

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

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

static void
pipe_global_init(void);

static enum ia_css_err
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 enum ia_css_err
create_host_pipeline_structure(struct ia_css_stream *stream);

static enum ia_css_err
create_host_pipeline(struct ia_css_stream *stream);

static enum ia_css_err
create_host_preview_pipeline(struct ia_css_pipe *pipe);

static enum ia_css_err
create_host_video_pipeline(struct ia_css_pipe *pipe);

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

static enum ia_css_err
create_host_isyscopy_capture_pipeline(struct ia_css_pipe *pipe);

static enum ia_css_err
create_host_capture_pipeline(struct ia_css_pipe *pipe);

static enum ia_css_err
create_host_yuvpp_pipeline(struct ia_css_pipe *pipe);

static enum ia_css_err
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(hrt_vaddress 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 enum ia_css_err set_config_on_frame_enqueue(struct ia_css_frame_info *info, struct frame_data_wrapper *frame);
#endif

#ifdef USE_INPUT_SYSTEM_VERSION_2401
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);
#endif

#ifdef ISP2401
#ifdef USE_INPUT_SYSTEM_VERSION_2401
static enum ia_css_err
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 enum ia_css_err
aspect_ratio_crop(struct ia_css_pipe *curr_pipe,
                struct ia_css_resolution *effective_res);
#endif

#endif
static void
sh_css_pipe_free_shading_table(struct ia_css_pipe *pipe)
{
        assert(pipe != NULL);
        if (pipe == NULL) {
                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 enum ia_css_err
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 != NULL);
        assert(pipe->stream != NULL);

        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 IA_CSS_ERR_INVALID_ARGUMENTS;
        return IA_CSS_SUCCESS;
}

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

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

        return bpp;
}

#if !defined(HAS_NO_INPUT_SYSTEM) && defined(USE_INPUT_SYSTEM_VERSION_2)
static enum ia_css_err
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;
        enum ia_css_err err = IA_CSS_SUCCESS;

        assert(stream != NULL);
        assert(pipe != NULL);

        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 != IA_CSS_SUCCESS)
                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 != IA_CSS_SUCCESS)
                        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 defined(IS_ISP_2400_SYSTEM)
                if (pipe->stream->config.mode == IA_CSS_INPUT_MODE_TPG) {
                        /* TODO: move define to proper file in tools */
                        #define GP_ISEL_TPG_MODE 0x90058
                        ia_css_device_store_uint32(GP_ISEL_TPG_MODE, 0);
                }
#endif
        }
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE,
                "sh_css_config_input_network() leave:\n");
        return IA_CSS_SUCCESS;
}
#elif !defined(HAS_NO_INPUT_SYSTEM) && defined(USE_INPUT_SYSTEM_VERSION_2401)
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:
        {
                enum ia_css_err 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 != IA_CSS_SUCCESS)
                        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 USE_INPUT_SYSTEM_VERSION_2401
                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 != IA_CSS_SUCCESS)
                        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 != IA_CSS_SUCCESS)
                                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 USE_INPUT_SYSTEM_VERSION_2401
                        /* 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 ??
         */

        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");

        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 enum ia_css_err
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;
        uint32_t isys_stream_id;
        bool early_polling = false;

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

        if (stream->config.continuous == true) {
                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;
                }
        }

        assert(pipe != NULL);
        if (pipe == NULL)
                return IA_CSS_ERR_INTERNAL_ERROR;

        if (pipe->pipeline.stages != NULL)
                if (pipe->pipeline.stages->binary != NULL)
                        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 IA_CSS_ERR_INTERNAL_ERROR;
        /* 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 IA_CSS_ERR_INTERNAL_ERROR;

                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 IA_CSS_ERR_INTERNAL_ERROR;

                /* 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 IA_CSS_ERR_INTERNAL_ERROR;
                }
        }

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

        return IA_CSS_SUCCESS;
}

static inline struct ia_css_pipe *stream_get_last_pipe(
                struct ia_css_stream *stream)
{
        struct ia_css_pipe *last_pipe = NULL;
        if (stream != NULL)
                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 != NULL) &&
            (last_pipe != NULL) &&
            (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 enum ia_css_err stream_csi_rx_helper(
        struct ia_css_stream *stream,
        enum ia_css_err (*func)(enum mipi_port_id, uint32_t))
{
        enum ia_css_err retval = IA_CSS_ERR_INTERNAL_ERROR;
        uint32_t sp_thread_id, stream_id;
        bool rc;
        struct ia_css_pipe *target_pipe = NULL;

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

        target_pipe = stream_get_target_pipe(stream);

        if (target_pipe == NULL)
                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) {
                        uint32_t 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 == IA_CSS_SUCCESS) &&
                 (stream_id < IA_CSS_STREAM_MAX_ISYS_STREAM_PER_CH));

exit:
        return retval;
}

static inline enum ia_css_err 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 enum ia_css_err 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 i;
        unsigned cnt_run = 0;
        unsigned cnt_stall = 0;

        if (hist == NULL)
                return;

        sh_css_print("%s histogram length = %d\n", core_name, hist->length);
        sh_css_print("%s PC\trun\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 binay->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)
{
        struct ia_css_stream *stream;

        assert(pipe != NULL);
        /* Acceleration uses firmware, the binary thus can be NULL */
        /* assert(binary != NULL); */

        (void)binary;

#if !defined(HAS_NO_INPUT_SYSTEM)
        stream = pipe->stream;
#else
        (void)pipe;
        (void)stream;
#endif

        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(HAS_NO_INPUT_SYSTEM) && !defined(USE_INPUT_SYSTEM_VERSION_2401)
        if (stream->reconfigure_css_rx) {
                ia_css_isys_rx_configure(&pipe->stream->csi_rx_config,
                                         pipe->stream->config.mode);
                stream->reconfigure_css_rx = false;
        }
#endif
}

/* start the copy function on the SP */
static enum ia_css_err
start_copy_on_sp(struct ia_css_pipe *pipe,
                 struct ia_css_frame *out_frame)
{

        (void)out_frame;
        assert(pipe != NULL);
        assert(pipe->stream != NULL);

        if ((pipe == NULL) || (pipe->stream == NULL))
                return IA_CSS_ERR_INVALID_ARGUMENTS;

#if !defined(HAS_NO_INPUT_SYSTEM) && !defined(USE_INPUT_SYSTEM_VERSION_2401)
        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 IA_CSS_ERR_INTERNAL_ERROR;
        sh_css_sp_start_binary_copy(ia_css_pipe_get_pipe_num(pipe), out_frame, pipe->stream->config.pixels_per_clock == 2);

#if !defined(HAS_NO_INPUT_SYSTEM) && !defined(USE_INPUT_SYSTEM_VERSION_2401)
        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 IA_CSS_SUCCESS;
}

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

#ifndef ISP2401
        for (i = 0; i < NUM_VIDEO_TNR_FRAMES; i++)
#else
        for (i = 0; i < NUM_TNR_FRAMES; i++)
#endif
                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)
{
#if defined(HAS_NO_INPUT_SYSTEM)
        (void)input_mode;
#endif

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

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

        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
#if !defined(HAS_NO_INPUT_SYSTEM)
                                ,(input_mode==IA_CSS_INPUT_MODE_MEMORY) ?
                                        (enum mipi_port_id)0 :
                                        me->stream->config.source.port.port
#endif
#ifdef ISP2401
                                ,&me->config.internal_frame_origin_bqs_on_sctbl,
                                me->stream->isp_params_configs
#endif
                        );

        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 != NULL);

        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] != NULL);
                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");
}

#ifndef ISP2401
static void
enable_interrupts(enum ia_css_irq_type irq_type)
{
#ifdef USE_INPUT_SYSTEM_VERSION_2
        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(
                        (virq_id_t)(IRQ_SW_CHANNEL0_ID + IRQ_SW_CHANNEL_OFFSET),
                        true);
        /* Enable SW interrupt 1, this is used to signal PSYS events */
        cnd_virq_enable_channel(
                        (virq_id_t)(IRQ_SW_CHANNEL1_ID + IRQ_SW_CHANNEL_OFFSET),
                        true);
#if !defined(HAS_IRQ_MAP_VERSION_2)
        /* IRQ_SW_CHANNEL2_ID does not exist on 240x systems */
        cnd_virq_enable_channel(
                        (virq_id_t)(IRQ_SW_CHANNEL2_ID + IRQ_SW_CHANNEL_OFFSET),
                        true);
        virq_clear_all();
#endif

#ifdef USE_INPUT_SYSTEM_VERSION_2
        for (port = 0; port < N_MIPI_PORT_ID; port++)
                ia_css_isys_rx_enable_all_interrupts(port);
#endif

        IA_CSS_LEAVE_PRIVATE("");
}

#endif

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 == NULL)||(spctrl_cfg == NULL))
                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;
}

bool
ia_css_check_firmware_version(const struct ia_css_fw  *fw)
{
        bool retval = false;

        if (fw != NULL) {
                retval = sh_css_check_firmware_version(fw->data);
        }
        return retval;
}

enum ia_css_err
ia_css_load_firmware(const struct ia_css_env *env,
            const struct ia_css_fw  *fw)
{
        enum ia_css_err err;

        if (env == NULL)
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        if (fw == NULL)
                return IA_CSS_ERR_INVALID_ARGUMENTS;

        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(fw->data, fw->bytes);
        if (err == IA_CSS_SUCCESS) {
                err = ia_css_binary_init_infos();
                if (err == IA_CSS_SUCCESS)
                        fw_explicitly_loaded = true;
        }

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

enum ia_css_err
ia_css_init(const struct ia_css_env *env,
            const struct ia_css_fw  *fw,
            uint32_t                 mmu_l1_base,
            enum ia_css_irq_type     irq_type)
{
        enum ia_css_err 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 == NULL && !fw_explicitly_loaded)
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        if (env == NULL)
            return IA_CSS_ERR_INVALID_ARGUMENTS;

        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);
#ifndef ISP2401
        my_css_save.mmu_base = mmu_l1_base;
#else
        ia_css_save_mmu_base_addr(mmu_l1_base);
#endif

        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_SUCCESS) {
                IA_CSS_LEAVE_ERR(err);
                return err;
        }

#ifndef ISP2401
        IA_CSS_LOG("init: %d", my_css_save_initialized);
#else
        ia_css_save_restore_data_init();
#endif

#ifndef ISP2401
        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);
        }
#endif
        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;
#ifndef ISP2401
        my_css_save.irq_type = irq_type;
#else
        ia_css_save_irq_type(irq_type);
#endif
        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_SUCCESS) {
                IA_CSS_LEAVE_ERR(err);
                return err;
        }
        err = sh_css_params_init();
        if (err != IA_CSS_SUCCESS) {
                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(fw->data, fw->bytes);
                if (err != IA_CSS_SUCCESS) {
                        IA_CSS_LEAVE_ERR(err);
                        return err;
                }
                err = ia_css_binary_init_infos();
                if (err != IA_CSS_SUCCESS) {
                        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 IA_CSS_ERR_INTERNAL_ERROR;

        err = ia_css_spctrl_load_fw(SP0_ID, &spctrl_cfg);
        if (err != IA_CSS_SUCCESS) {
                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(IA_CSS_ERR_SYSTEM_NOT_IDLE);
                return IA_CSS_ERR_SYSTEM_NOT_IDLE;
        }
        /* 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(HAS_INPUT_SYSTEM_VERSION_2) && defined(HAS_INPUT_SYSTEM_VERSION_2401)
#if     defined(USE_INPUT_SYSTEM_VERSION_2)
        gp_device_reg_store(GP_DEVICE0_ID, _REG_GP_SWITCH_ISYS2401_ADDR, 0);
#elif defined (USE_INPUT_SYSTEM_VERSION_2401)
        gp_device_reg_store(GP_DEVICE0_ID, _REG_GP_SWITCH_ISYS2401_ADDR, 1);
#endif
#endif

#if !defined(HAS_NO_INPUT_SYSTEM)
        dma_set_max_burst_size(DMA0_ID, HIVE_DMA_BUS_DDR_CONN,
                               ISP_DMA_MAX_BURST_LENGTH);

        if(ia_css_isys_init() != INPUT_SYSTEM_ERR_NO_ERROR)
                err = IA_CSS_ERR_INVALID_ARGUMENTS;
#endif

        sh_css_params_map_and_store_default_gdc_lut();

        IA_CSS_LEAVE_ERR(err);
        return err;
}

enum ia_css_err ia_css_suspend(void)
{
        int i;
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "ia_css_suspend() enter\n");
        my_css_save.mode = sh_css_mode_suspend;
        for(i=0;i<MAX_ACTIVE_STREAMS;i++)
                if (my_css_save.stream_seeds[i].stream != NULL)
                {
                        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "==*> unloading seed %d (%p)\n", i, my_css_save.stream_seeds[i].stream);
                        ia_css_stream_unload(my_css_save.stream_seeds[i].stream);
                }
        my_css_save.mode = sh_css_mode_working;
        ia_css_stop_sp();
        ia_css_uninit();
        for(i=0;i<MAX_ACTIVE_STREAMS;i++)
                ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "==*> after 1: seed %d (%p)\n", i, my_css_save.stream_seeds[i].stream);
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "ia_css_suspend() leave\n");
        return IA_CSS_SUCCESS;
}

enum ia_css_err
ia_css_resume(void)
{
        int i, j;
        enum ia_css_err err;
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "ia_css_resume() enter: void\n");

        err = ia_css_init(&(my_css_save.driver_env), my_css_save.loaded_fw, my_css_save.mmu_base, my_css_save.irq_type);
        if (err != IA_CSS_SUCCESS)
                return err;
        err = ia_css_start_sp();
        if (err != IA_CSS_SUCCESS)
                return err;
        my_css_save.mode = sh_css_mode_resume;
        for(i=0;i<MAX_ACTIVE_STREAMS;i++)
        {
                ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "==*> seed stream %p\n", my_css_save.stream_seeds[i].stream);
                if (my_css_save.stream_seeds[i].stream != NULL)
                {
                        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "==*> loading seed %d\n", i);
                        err = ia_css_stream_load(my_css_save.stream_seeds[i].stream);
                        if (err != IA_CSS_SUCCESS)
                        {
                                if (i)
                                        for(j=0;j<i;j++)
                                                ia_css_stream_unload(my_css_save.stream_seeds[j].stream);
                                return err;
                        }
                        err = ia_css_stream_start(my_css_save.stream_seeds[i].stream);
                        if (err != IA_CSS_SUCCESS)
                        {
                                for(j=0;j<=i;j++)
                                {
                                        ia_css_stream_stop(my_css_save.stream_seeds[j].stream);
                                        ia_css_stream_unload(my_css_save.stream_seeds[j].stream);
                                }
                                return err;
                        }
                        *my_css_save.stream_seeds[i].orig_stream = my_css_save.stream_seeds[i].stream;
                        for(j=0;j<my_css_save.stream_seeds[i].num_pipes;j++)
                                *(my_css_save.stream_seeds[i].orig_pipes[j]) = my_css_save.stream_seeds[i].pipes[j];
                }
        }
        my_css_save.mode = sh_css_mode_working;
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "ia_css_resume() leave: return_void\n");
        return IA_CSS_SUCCESS;
}

enum ia_css_err
ia_css_enable_isys_event_queue(bool enable)
{
        if (sh_css_sp_is_running())
                return IA_CSS_ERR_RESOURCE_NOT_AVAILABLE;
        sh_css_sp_enable_isys_event_queue(enable);
        return IA_CSS_SUCCESS;
}

void *sh_css_malloc(size_t size)
{
        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "sh_css_malloc() enter: size=%zu\n",size);
        /* FIXME: This first test can probably go away */
        if (size == 0)
                return NULL;
        if (size > PAGE_SIZE)
                return vmalloc(size);
        return kmalloc(size, GFP_KERNEL);
}

void *sh_css_calloc(size_t N, size_t size)
{
        void *p;

        ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE, "sh_css_calloc() enter: N=%zu, size=%zu\n",N,size);

        /* FIXME: this test can probably go away */
        if (size > 0) {
                p = sh_css_malloc(N*size);
                if (p)
                        memset(p, 0, size);
                return p;
        }
        return NULL;
}

void sh_css_free(void *ptr)
{
        if (is_vmalloc_addr(ptr))
                vfree(ptr);
        else
                kfree(ptr);
}

/* 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 != NULL) && (my_css.flush != NULL))
                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 enum ia_css_err
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;
        enum ia_css_err err = IA_CSS_SUCCESS;
        enum ia_css_pipe_id pipe_id;

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

        if (stream == NULL) {
                IA_CSS_LEAVE_ERR_PRIVATE(IA_CSS_ERR_INVALID_ARGUMENTS);
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        }

        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 enum ia_css_err
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;
        enum ia_css_err err = IA_CSS_SUCCESS;
        unsigned int copy_pipe_delay = 0,
                     capture_pipe_delay = 0;

        assert(stream != NULL);
        IA_CSS_ENTER_PRIVATE("stream = %p", stream);

        if (stream == NULL) {
                IA_CSS_LEAVE_ERR_PRIVATE(IA_CSS_ERR_INVALID_ARGUMENTS);
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        }

        main_pipe       = stream->last_pipe;
        assert(main_pipe != NULL);
        if (main_pipe == NULL) {
                IA_CSS_LEAVE_ERR_PRIVATE(IA_CSS_ERR_INVALID_ARGUMENTS);
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        }

        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 = IA_CSS_ERR_INVALID_ARGUMENTS;
        }

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

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

        if ((IA_CSS_SUCCESS == 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 && IA_CSS_SUCCESS == 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 enum ia_css_err
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;
        enum ia_css_err err = IA_CSS_SUCCESS;
        unsigned max_input_width = 0;

        IA_CSS_ENTER_PRIVATE("stream = %p", stream);
        if (stream == NULL) {
                IA_CSS_LEAVE_ERR_PRIVATE(IA_CSS_ERR_INVALID_ARGUMENTS);
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        }

        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 != IA_CSS_SUCCESS)
                                goto ERR;
                }

        }

#if defined(USE_INPUT_SYSTEM_VERSION_2)
        /* 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 != IA_CSS_SUCCESS)
                        goto ERR;
        }
#elif defined(USE_INPUT_SYSTEM_VERSION_2401)
        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 != IA_CSS_SUCCESS)
                        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 != IA_CSS_SUCCESS)
                        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 != IA_CSS_SUCCESS)
                        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 != IA_CSS_SUCCESS)
                        goto ERR;

                break;

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

                break;
        default:
                err = IA_CSS_ERR_INVALID_ARGUMENTS;
        }
        if (err != IA_CSS_SUCCESS)
                goto ERR;

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

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

        if (acc_pipe) {
                err = create_host_acc_pipeline(acc_pipe);
                if (err != IA_CSS_SUCCESS)
                        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 && IA_CSS_SUCCESS == 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 = IA_CSS_ERR_INVALID_ARGUMENTS;
                        }
                        if (err != IA_CSS_SUCCESS)
                                goto ERR;
                }
        }

ERR:
        IA_CSS_LEAVE_ERR_PRIVATE(err);
        return err;
}

static enum ia_css_err
init_pipe_defaults(enum ia_css_pipe_mode mode,
               struct ia_css_pipe *pipe,
               bool copy_pipe)
{
        if (pipe == NULL) {
                IA_CSS_ERROR("NULL pipe parameter");
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        }

        /* Initialize pipe to pre-defined defaults */
        *pipe = IA_CSS_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;
                pipe->pipe_settings.preview = IA_CSS_DEFAULT_PREVIEW_SETTINGS;
                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;
                }
                pipe->pipe_settings.capture = IA_CSS_DEFAULT_CAPTURE_SETTINGS;
                break;
        case IA_CSS_PIPE_MODE_VIDEO:
                pipe->mode = IA_CSS_PIPE_ID_VIDEO;
                pipe->pipe_settings.video = IA_CSS_DEFAULT_VIDEO_SETTINGS;
                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;
                pipe->pipe_settings.yuvpp = IA_CSS_DEFAULT_YUVPP_SETTINGS;
                break;
        default:
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        }

        return IA_CSS_SUCCESS;
}

static void
pipe_global_init(void)
{
        uint8_t i;

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

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

        if (pipe == NULL) {
                IA_CSS_ERROR("NULL pipe parameter");
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        }

        /* 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] == NULL) {
                        /*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 IA_CSS_ERR_RESOURCE_EXHAUSTED;
        }

        my_css.pipe_counter++;

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

        *pipe_number = pipe_num;
        return IA_CSS_SUCCESS;
}

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 enum ia_css_err
create_pipe(enum ia_css_pipe_mode mode,
            struct ia_css_pipe **pipe,
            bool copy_pipe)
{
        enum ia_css_err err = IA_CSS_SUCCESS;
        struct ia_css_pipe *me;

        if (pipe == NULL) {
                IA_CSS_ERROR("NULL pipe parameter");
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        }

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

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

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

        *pipe = me;
        return IA_CSS_SUCCESS;
}

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;

        assert(pipe != NULL);
        if (pipe == NULL) {
                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);
        }
}

enum ia_css_err
ia_css_pipe_destroy(struct ia_css_pipe *pipe)
{
        enum ia_css_err err = IA_CSS_SUCCESS;
        IA_CSS_ENTER("pipe = %p", pipe);

        if (pipe == NULL) {
                IA_CSS_LEAVE_ERR(IA_CSS_ERR_INVALID_ARGUMENTS);
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        }

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

        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_VIDEO_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(HAS_NO_INPUT_FORMATTER)
        /* 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);
#if defined(USE_INPUT_SYSTEM_VERSION_2) || defined(USE_INPUT_SYSTEM_VERSION_2401)
        /* check and free any remaining mipi frames */
        free_mipi_frames(NULL);
#endif

        sh_css_sp_reset_global_vars();

#if !defined(HAS_NO_INPUT_SYSTEM)
        ia_css_isys_uninit();
#endif

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

#if defined(HAS_IRQ_MAP_VERSION_2)
enum ia_css_err ia_css_irq_translate(
        unsigned int *irq_infos)
{
        virq_id_t       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 IA_CSS_ERR_INTERNAL_ERROR;

#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;
#if !defined(HAS_NO_INPUT_SYSTEM)
                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;
#endif
#if !defined(HAS_NO_INPUT_FORMATTER)
                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 IA_CSS_SUCCESS;
}

enum ia_css_err ia_css_irq_enable(
        enum ia_css_irq_info info,
        bool enable)
{
        virq_id_t       irq = N_virq_id;
        IA_CSS_ENTER("info=%d, enable=%d", info, enable);

        switch (info) {
#if !defined(HAS_NO_INPUT_FORMATTER)
        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;
#endif
#if !defined(HAS_NO_INPUT_FORMATTER)
        case IA_CSS_IRQ_INFO_IF_ERROR:
                irq = virq_ifmt0_id;
                break;
#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(IA_CSS_ERR_INVALID_ARGUMENTS);
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        }

        cnd_virq_enable_channel(irq, enable);

        IA_CSS_LEAVE_ERR(IA_CSS_SUCCESS);
        return IA_CSS_SUCCESS;
}

#else
#error "sh_css.c: IRQ MAP must be one of \
        {IRQ_MAP_VERSION_2}"
#endif

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 enum ia_css_err 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;
        enum ia_css_err err;
        struct ia_css_binary_descr copy_descr;

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

        if (next_binary != NULL) {
                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 : NULL/*TODO: &copy_vf_info*/);
        err = ia_css_binary_find(&copy_descr, copy_binary);
        if (err != IA_CSS_SUCCESS)
                return err;
        copy_binary->left_padding = left_padding;
        return IA_CSS_SUCCESS;
}

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

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

        if ((pipe == NULL) || (pipe->stream == NULL)) {
                IA_CSS_LEAVE_ERR_PRIVATE(IA_CSS_ERR_INVALID_ARGUMENTS);
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        }

        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(IA_CSS_ERR_INTERNAL_ERROR);
                return IA_CSS_ERR_INTERNAL_ERROR;
        }

#if defined(USE_INPUT_SYSTEM_VERSION_2401)
        /* 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;
                capture_pipe = pipe->pipe_settings.preview.capture_pipe;
        } else if (pipe_id == IA_CSS_PIPE_ID_VIDEO) {
                pipe->pipe_settings.video.video_binary.in_frame_info.format = ref_info.format;
                capture_pipe = pipe->pipe_settings.video.capture_pipe;
        } else {
                /* should not happen */
                IA_CSS_LEAVE_ERR_PRIVATE(IA_CSS_ERR_INTERNAL_ERROR);
                return IA_CSS_ERR_INTERNAL_ERROR;
        }

        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_SUCCESS) {
                                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(IA_CSS_SUCCESS);
        return IA_CSS_SUCCESS;
}

enum ia_css_err
ia_css_alloc_continuous_frame_remain(struct ia_css_stream *stream)
{
        if (stream == NULL)
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        return alloc_continuous_frames(stream->continuous_pipe, false);
}

static enum ia_css_err
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;
        enum ia_css_err err = IA_CSS_SUCCESS;
        bool continuous, need_vf_pp = false;
        bool need_isp_copy_binary = false;
#ifdef USE_INPUT_SYSTEM_VERSION_2401
        bool sensor = false;
#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 != NULL);
        assert(pipe->stream != NULL);
        assert(pipe->mode == IA_CSS_PIPE_ID_PREVIEW);

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

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

        err = ia_css_util_check_input(&pipe->stream->config, false, false);
        if (err != IA_CSS_SUCCESS)
                return err;
        err = ia_css_frame_check_info(pipe_out_info);
        if (err != IA_CSS_SUCCESS)
                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 != IA_CSS_SUCCESS)
                return err;
        err = ia_css_binary_find(&preview_descr, &mycs->preview_binary);
        if (err != IA_CSS_SUCCESS)
                return err;

#ifdef 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);

#endif
        /* 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 != IA_CSS_SUCCESS)
                        return err;
                err = ia_css_binary_find(&preview_descr,
                                &mycs->preview_binary);
                if (err != IA_CSS_SUCCESS)

                        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 != IA_CSS_SUCCESS)
                        return err;
        }

#ifdef USE_INPUT_SYSTEM_VERSION_2401
        /* 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
#ifndef ISP2401
        need_isp_copy_binary = !online && !continuous;
#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.
         */
        need_isp_copy_binary = !online && !continuous && !(pipe->stream->config.mode == IA_CSS_INPUT_MODE_MEMORY);
#endif
#endif

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

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

        return IA_CSS_SUCCESS;
}

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

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

        if ((pipe == NULL) || (pipe->mode != IA_CSS_PIPE_ID_PREVIEW)) {
                IA_CSS_LEAVE_ERR_PRIVATE(IA_CSS_ERR_INVALID_ARGUMENTS);
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        }
        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(IA_CSS_SUCCESS);
        return IA_CSS_SUCCESS;
}

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 enum ia_css_err 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)
{
        enum ia_css_err err = IA_CSS_SUCCESS;
        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 != IA_CSS_SUCCESS)
                        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 enum ia_css_err 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;
        enum ia_css_err err = IA_CSS_SUCCESS;
        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 == NULL)
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        if (in_frame == NULL)
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        if (vf_pp_binary == NULL)
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        if (vf_pp_stage == NULL)
                return IA_CSS_ERR_INVALID_ARGUMENTS;

        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 != IA_CSS_SUCCESS)
                        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 enum ia_css_err 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;
        enum ia_css_err err = IA_CSS_SUCCESS;
        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 != NULL);
        assert(pipe != NULL);
        assert(me != NULL);
        assert(yuv_scaler_binary != NULL);
        assert(pre_vf_pp_stage != NULL);
        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 != IA_CSS_SUCCESS)
                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 enum ia_css_err 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;
        enum ia_css_err err = IA_CSS_SUCCESS;
        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 != NULL);
        assert(pipe != NULL);
        assert(me != NULL);
        assert(capture_pp_binary != NULL);
        assert(capture_pp_stage != NULL);
        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 != IA_CSS_SUCCESS)
                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 != IA_CSS_SUCCESS)
                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 enum ia_css_err
init_vf_frameinfo_defaults(struct ia_css_pipe *pipe,
        struct ia_css_frame *vf_frame, unsigned int idx)
{
        enum ia_css_err err = IA_CSS_SUCCESS;
        unsigned int thread_id;
        enum sh_css_queue_id queue_id;

        assert(vf_frame != NULL);

        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 USE_INPUT_SYSTEM_VERSION_2401
static unsigned int
get_crop_lines_for_bayer_order (
                const struct ia_css_stream_config *config)
{
        assert(config != NULL);
        if ((IA_CSS_BAYER_ORDER_BGGR == config->input_config.bayer_order)
            || (IA_CSS_BAYER_ORDER_GBRG == config->input_config.bayer_order))
                return 1;

        return 0;
}

static unsigned int
get_crop_columns_for_bayer_order (
                const struct ia_css_stream_config *config)
{
        assert(config != NULL);
        if ((IA_CSS_BAYER_ORDER_RGGB == config->input_config.bayer_order)
            || (IA_CSS_BAYER_ORDER_GBRG == config->input_config.bayer_order))
                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 != NULL);
        assert(pipe->stream != NULL);
        assert(in_frame != NULL);

        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 enum ia_css_err
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;
        enum ia_css_err err = IA_CSS_SUCCESS;
        unsigned int thread_id;
        enum sh_css_queue_id queue_id;

        assert(frame != NULL);
        in_frame = frame;

        in_frame->info.format = format;

#ifdef USE_INPUT_SYSTEM_VERSION_2401
        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 USE_INPUT_SYSTEM_VERSION_2401
        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 enum ia_css_err
init_out_frameinfo_defaults(struct ia_css_pipe *pipe,
        struct ia_css_frame *out_frame, unsigned int idx)
{
        enum ia_css_err err = IA_CSS_SUCCESS;
        unsigned int thread_id;
        enum sh_css_queue_id queue_id;

        assert(out_frame != NULL);

        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 enum ia_css_err 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;
        enum ia_css_err err = IA_CSS_SUCCESS;
        bool need_copy   = false;
        bool need_vf_pp  = false;
        bool need_yuv_pp = false;
        unsigned num_output_pins;
        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 == NULL) || (pipe->stream == NULL) || (pipe->mode != IA_CSS_PIPE_ID_VIDEO)) {
                IA_CSS_LEAVE_ERR_PRIVATE(IA_CSS_ERR_INVALID_ARGUMENTS);
                return IA_CSS_ERR_INVALID_ARGUMENTS;
        }
        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 USE_INPUT_SYSTEM_VERSION_2401
        /* 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 != IA_CSS_SUCCESS)
                        goto ERR;
        }

        out_frame->data = 0;
        err = init_out_frameinfo_defaults(pipe, out_frame, 0);
        if (err != IA_CSS_SUCCESS)
                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 != IA_CSS_SUCCESS)
                        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;
        num_output_pins = video_binary->info->num_output_pins;

        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 != NULL && copy_binary->info != NULL);
        need_vf_pp  = (vf_pp_binary != NULL && vf_pp_binary->info != NULL);
        need_yuv_pp = (yuv_scaler_binary != NULL && yuv_scaler_binary->info != NULL);

        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 != IA_CSS_SUCCESS)
                        goto ERR;
                in_frame = me->stages->args.out_frame[0];
        } else if (pipe->stream->config.continuous) {
#ifdef USE_INPUT_SYSTEM_VERSION_2401
                /* 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 != IA_CSS_SUCCESS)
                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 != IA_CSS_SUCCESS)
                        goto ERR;
        }
        if (video_stage) {
                int frm;
#ifndef ISP2401
                for (frm = 0; frm < NUM_VIDEO_TNR_FRAMES; frm++) {
#else
                for (frm = 0; frm < NUM_TNR_FRAMES; frm++) {
#endif
                        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 != IA_CSS_SUCCESS)
                                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 != IA_CSS_SUCCESS)
                        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++) {
                        if (is_output_stage[i] == true) {
                                tmp_out_frame = out_frame;
                        } else {
                                tmp_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_SUCCESS) {
                                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 enum ia_css_err
create_host_acc_pipeline(struct ia_css_pipe *pipe)
{
        enum ia_css_err err = IA_CSS_SUCCESS;
        const struct ia_css_fw_info *fw;
        unsigned int i;

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

        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 != IA_CSS_SUCCESS)
                        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 != IA_CSS_SUCCESS)
                        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 enum ia_css_err
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;
        enum ia_css_err err = IA_CSS_SUCCESS;
        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 USE_INPUT_SYSTEM_VERSION_2401
        bool sensor = false;
        bool buffered_sensor = false;
        bool online = false;
        bool continuous = false;
#endif

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


        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 USE_INPUT_SYSTEM_VERSION_2401
        /* 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 != IA_CSS_SUCCESS)
                        goto ERR;

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

        err = init_out_frameinfo_defaults(pipe, &me->out_frame[0], 0);
        if (err != IA_CSS_SUCCESS)
                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 != IA_CSS_SUCCESS)
                        goto ERR;
                in_frame = me->stages->args.out_frame[0];
#ifndef ISP2401
        } else {
#else
        } else if (pipe->stream->config.continuous) {
#endif
#ifdef USE_INPUT_SYSTEM_VERSION_2401
                /* 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 != IA_CSS_SUCCESS)
                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 != IA_CSS_SUCCESS)
                        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 enum ia_css_err
preview_start(struct ia_css_pipe *pipe)
{
        struct ia_css_pipeline *me ;
        struct ia_css_binary *copy_binary, *preview_binary, *vf_pp_binary = NULL;
        enum ia_css_err err = IA_CSS_SUCCESS;
        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;

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

        me = &pipe->pipeline;

        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;

        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;

        sh_css_metrics_start_frame();