// SPDX-License-Identifier: GPL-2.0
/*
 * Support for Intel Camera Imaging ISP subsystem.
 * Copyright (c) 2015, Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 */

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

#include "hmm.h"

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

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

#define SH_CSS_VIDEO_BUFFER_ALIGNMENT 0

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

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

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

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

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

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

struct sh_css my_css;

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

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

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

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

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

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

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

static struct sh_css_hmm_buffer_record hmm_buffer_record[MAX_HMM_BUFFER_NUM];

#define GPIO_FLASH_PIN_MASK BIT(HIVE_GPIO_STROBE_TRIGGER_PIN)

static bool fw_explicitly_loaded;

/*
 * Local prototypes
 */

static int
allocate_delay_frames(struct ia_css_pipe *pipe);

static int
sh_css_pipe_start(struct ia_css_stream *stream);

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

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

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

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

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

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

static void
sh_css_init_host_sp_control_vars(void);

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

static bool
need_capture_pp(const struct ia_css_pipe *pipe);

static bool
need_yuv_scaler_stage(const struct ia_css_pipe *pipe);

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

static void ia_css_pipe_destroy_cas_scaler_desc(struct ia_css_cas_binary_descr
        *descr);

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

static bool need_capt_ldc(const struct ia_css_pipe *pipe);

static int
sh_css_pipe_load_binaries(struct ia_css_pipe *pipe);

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

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

static int
capture_start(struct ia_css_pipe *pipe);

static int
video_start(struct ia_css_pipe *pipe);

static int
preview_start(struct ia_css_pipe *pipe);

static int
yuvpp_start(struct ia_css_pipe *pipe);

static bool copy_on_sp(struct ia_css_pipe *pipe);

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

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

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

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

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

static void
pipe_global_init(void);

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

static void
pipe_release_pipe_num(unsigned int pipe_num);

static int
create_host_pipeline_structure(struct ia_css_stream *stream);

static int
create_host_pipeline(struct ia_css_stream *stream);

static int
create_host_preview_pipeline(struct ia_css_pipe *pipe);

static int
create_host_video_pipeline(struct ia_css_pipe *pipe);

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

static int
create_host_isyscopy_capture_pipeline(struct ia_css_pipe *pipe);

static int
create_host_capture_pipeline(struct ia_css_pipe *pipe);

static int
create_host_yuvpp_pipeline(struct ia_css_pipe *pipe);

static int
create_host_acc_pipeline(struct ia_css_pipe *pipe);

static unsigned int
sh_css_get_sw_interrupt_value(unsigned int irq);

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

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

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

static void
sh_css_hmm_buffer_record_init(void);

static void
sh_css_hmm_buffer_record_uninit(void);

static void
sh_css_hmm_buffer_record_reset(struct sh_css_hmm_buffer_record *buffer_record);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        return bpp;
}

#define GP_ISEL_TPG_MODE 0x90058

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

        assert(stream);
        assert(pipe);

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

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

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

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

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

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

        return rval;
}

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

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

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

                break;
        case IA_CSS_INPUT_MODE_PRBS:

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

                break;
        case IA_CSS_INPUT_MODE_BUFFERED_SENSOR:

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

                break;
        default:
                rc = false;
                break;
        }

        return rc;
}

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

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

                isys_stream_descr->mode = INPUT_SYSTEM_SOURCE_TYPE_TPG;

                break;
        case IA_CSS_INPUT_MODE_PRBS:

                isys_stream_descr->mode = INPUT_SYSTEM_SOURCE_TYPE_PRBS;

                break;
        case IA_CSS_INPUT_MODE_SENSOR:
        case IA_CSS_INPUT_MODE_BUFFERED_SENSOR:

                isys_stream_descr->mode = INPUT_SYSTEM_SOURCE_TYPE_SENSOR;
                break;

        default:
                rc = false;
                break;
        }

        return rc;
}

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

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

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

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

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

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

                break;
        case IA_CSS_INPUT_MODE_PRBS:

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

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

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

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

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

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

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

        return rc;
}

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

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

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

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

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

        align_req_in_bytes = ia_css_csi2_calculate_input_system_alignment(fmt_type);

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

        return true;
}

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

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

                  stream_cfg, isys_stream_descr, isys_stream_idx);

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

        return rc;
}

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

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

        return true;
}

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

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

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

        if (!pipe)
                return -EINVAL;

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

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

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

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

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

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

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

                if (!rc)
                        return -EINVAL;

                isys_stream_id = ia_css_isys_generate_stream_id(sp_thread_id, i);

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

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

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

        return 0;
}

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

        if (stream)
                last_pipe = stream->last_pipe;

        return last_pipe;
}

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

        last_pipe = stream_get_last_pipe(stream);

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

        return copy_pipe;
}

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

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

        return target_pipe;
}

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

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

        target_pipe = stream_get_target_pipe(stream);

        if (!target_pipe)
                goto exit;

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

        if (!rc)
                goto exit;

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

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

exit:
        return retval;
}

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

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

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

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

        if (!hist)
                return;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        return 0;
}

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

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

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


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

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

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

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

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

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

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

        assert(stream);

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

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

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

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

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

        cnd_virq_enable_channel(virq_sp, true);

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

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

        IA_CSS_LEAVE_PRIVATE("");
}

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

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

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

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

        return true;
}

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

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

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

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

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

        default_css.irq_type = IA_CSS_IRQ_TYPE_EDGE;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        sh_css_printf = env->print_env.debug_print;

        IA_CSS_ENTER("void");

        flush_func     = env->cpu_mem_env.flush;

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

        ia_css_device_access_init(&env->hw_access_env);

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

        my_css_save.mmu_base = mmu_l1_base;

        ia_css_reset_defaults(&my_css);

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

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

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

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

        mipi_init();

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

#endif
        my_css.irq_type = irq_type;

        my_css_save.irq_type = irq_type;

        enable_interrupts(my_css.irq_type);

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

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

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

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

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


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

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

        sh_css_params_map_and_store_default_gdc_lut();

        IA_CSS_LEAVE_ERR(err);
        return err;
}

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

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

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

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

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

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

        ia_css_pipeline_map(main_pipe->pipe_num, map);

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

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

        case IA_CSS_PIPE_ID_CAPTURE:
        case IA_CSS_PIPE_ID_ACC:
        default:
                break;
        }

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

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

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

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

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

        IA_CSS_LEAVE_ERR_PRIVATE(err);
        return err;
}

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

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

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

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

        pipe_id = main_pipe->mode;

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

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

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

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

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

        default:
                err = -EINVAL;
        }

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

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

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

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

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

        IA_CSS_LEAVE_ERR_PRIVATE(err);
        return err;
}

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

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