/*
 * Copyright (C) 2020 Intel Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#include <ia_css_psys_terminal_manifest.h>

/* Data object types on the terminals */
#include <ia_css_program_group_data.h>
/* for ia_css_kernel_bitmap_t, ia_css_kernel_bitmap_clear, ia_css_... */
#include <ia_css_kernel_bitmap.h>

#include "ia_css_psys_program_group_private.h"
#include "ia_css_terminal_manifest.h"
#include "ia_css_terminal_manifest_types.h"

#include <error_support.h>
#include <print_support.h>
#include <misc_support.h>
#include "ia_css_psys_static_trace.h"

#ifndef __IA_CSS_PSYS_STATIC_INLINE__
#include "ia_css_psys_terminal_manifest_impl.h"
#endif
#include "ia_css_terminal_manifest.h"

/* We need to refactor those files in order to build in the firmware only
   what is needed, switches are put current to workaround compilation problems
   in the firmware (for example lack of uint64_t support)
   supported in the firmware
  */
#if !defined(__HIVECC)
static const char *terminal_type_strings[IA_CSS_N_TERMINAL_TYPES + 1] = {
    "IA_CSS_TERMINAL_TYPE_DATA_IN",
    "IA_CSS_TERMINAL_TYPE_DATA_OUT",
    "IA_CSS_TERMINAL_TYPE_PARAM_STREAM",
    /**< Type 1-5 parameter input */
    "IA_CSS_TERMINAL_TYPE_PARAM_CACHED_IN",
    /**< Type 1-5 parameter output */
    "IA_CSS_TERMINAL_TYPE_PARAM_CACHED_OUT",
    /**< Represent the new type of terminal for
     * the "spatial dependent parameters", when params go in
     */
    "IA_CSS_TERMINAL_TYPE_PARAM_SPATIAL_IN",
    /**< Represent the new type of terminal for
     * the "spatial dependent parameters", when params go out
     */
    "IA_CSS_TERMINAL_TYPE_PARAM_SPATIAL_OUT",
    /**< Represent the new type of terminal for
     * the explicit slicing, when params go in
     */
    "IA_CSS_TERMINAL_TYPE_PARAM_SLICED_IN",
    /**< Represent the new type of terminal for
     * the explicit slicing, when params go out
     */
    "IA_CSS_TERMINAL_TYPE_PARAM_SLICED_OUT",
    /**< State (private data) input */
    "IA_CSS_TERMINAL_TYPE_STATE_IN",
    /**< State (private data) output */
    "IA_CSS_TERMINAL_TYPE_STATE_OUT",
    "IA_CSS_TERMINAL_TYPE_PROGRAM",
    "IA_CSS_TERMINAL_TYPR_PROGRAM_CONTROL_INIT",
    "UNDEFINED_TERMINAL_TYPE"};

int ia_css_data_terminal_manifest_set_kernel_bitmap_unique(
    ia_css_data_terminal_manifest_t *manifest,
    const unsigned int index)
{
    int retval = -1;

    IA_CSS_TRACE_0(PSYSAPI_STATIC, VERBOSE,
        "ia_css_data_terminal_manifest_set_kernel_bitmap_unique(): enter:\n");

    if (manifest != NULL) {
        ia_css_kernel_bitmap_t kernel_bitmap =
                    ia_css_kernel_bitmap_clear();

        kernel_bitmap = ia_css_kernel_bitmap_set(kernel_bitmap, index);
        verifexit(!ia_css_is_kernel_bitmap_empty(kernel_bitmap));
        verifexit(ia_css_data_terminal_manifest_set_kernel_bitmap(
                manifest, kernel_bitmap) == 0);
        retval = 0;
    }

EXIT:
    if (retval != 0) {
        IA_CSS_TRACE_1(PSYSAPI_STATIC, ERROR,
            "ia_css_data_terminal_manifest_set_kernel_bitmap_unique failed (%i)\n",
            retval);
    }
    return retval;
}

int ia_css_data_terminal_manifest_set_min_size(
    ia_css_data_terminal_manifest_t    *manifest,
    const uint16_t min_size[IA_CSS_N_DATA_DIMENSION])
{
    int retval = -1;

    IA_CSS_TRACE_0(PSYSAPI_STATIC, VERBOSE,
        "ia_css_data_terminal_manifest_set_min_size(): enter:\n");

    verifexit(manifest != NULL);

    manifest->min_size[IA_CSS_COL_DIMENSION] =
        min_size[IA_CSS_COL_DIMENSION];
    manifest->min_size[IA_CSS_ROW_DIMENSION] =
        min_size[IA_CSS_ROW_DIMENSION];
    retval = 0;

EXIT:
    if (NULL == manifest) {
        IA_CSS_TRACE_0(PSYSAPI_STATIC, ERROR,
            "ia_css_data_terminal_manifest_set_min_size: invalid argument\n");
    }
    return retval;
}

int ia_css_data_terminal_manifest_set_max_size(
    ia_css_data_terminal_manifest_t    *manifest,
    const uint16_t max_size[IA_CSS_N_DATA_DIMENSION])
{
    int retval = -1;

    IA_CSS_TRACE_0(PSYSAPI_STATIC, VERBOSE,
        "ia_css_data_terminal_manifest_set_max_size(): enter:\n");

    verifexit(manifest != NULL);

    manifest->max_size[IA_CSS_COL_DIMENSION] =
        max_size[IA_CSS_COL_DIMENSION];
    manifest->max_size[IA_CSS_ROW_DIMENSION] =
        max_size[IA_CSS_ROW_DIMENSION];
    retval = 0;

EXIT:
    if (NULL == manifest) {
        IA_CSS_TRACE_0(PSYSAPI_STATIC, ERROR,
            "ia_css_data_terminal_manifest_set_max_size: invalid argument\n");
    }
    return retval;
}
#endif

int ia_css_data_terminal_manifest_get_min_size(
    const ia_css_data_terminal_manifest_t *manifest,
    uint16_t min_size[IA_CSS_N_DATA_DIMENSION])
{
    int retval = -1;

    IA_CSS_TRACE_0(PSYSAPI_STATIC, VERBOSE,
        "ia_css_data_terminal_manifest_get_min_size(): enter:\n");

    verifexit(manifest != NULL);

    min_size[IA_CSS_COL_DIMENSION] =
        manifest->min_size[IA_CSS_COL_DIMENSION];
    min_size[IA_CSS_ROW_DIMENSION] =
        manifest->min_size[IA_CSS_ROW_DIMENSION];
    retval = 0;

EXIT:
    if (NULL == manifest) {
        IA_CSS_TRACE_0(PSYSAPI_STATIC, ERROR,
            "ia_css_data_terminal_manifest_get_min_size: invalid argument\n");
    }
    return retval;
}

int ia_css_data_terminal_manifest_get_max_size(
    const ia_css_data_terminal_manifest_t *manifest,
    uint16_t max_size[IA_CSS_N_DATA_DIMENSION])
{
    int retval = -1;

    IA_CSS_TRACE_0(PSYSAPI_STATIC, VERBOSE,
        "ia_css_data_terminal_manifest_get_max_size(): enter:\n");

    verifexit(manifest != NULL);

    max_size[IA_CSS_COL_DIMENSION] =
        manifest->max_size[IA_CSS_COL_DIMENSION];
    max_size[IA_CSS_ROW_DIMENSION] =
        manifest->max_size[IA_CSS_ROW_DIMENSION];
    retval = 0;

EXIT:
    if (NULL == manifest) {
        IA_CSS_TRACE_0(PSYSAPI_STATIC, ERROR,
            "ia_css_data_terminal_manifest_get_max_size: invalid argument\n");
    }
    return retval;
}

#if !defined(__HIVECC)
int ia_css_data_terminal_manifest_set_min_fragment_size(
    ia_css_data_terminal_manifest_t    *manifest,
    const uint16_t min_size[IA_CSS_N_DATA_DIMENSION])
{
    int retval = -1;

    IA_CSS_TRACE_0(PSYSAPI_STATIC, VERBOSE,
        "ia_css_data_terminal_manifest_set_min_fragment_size(): enter:\n");

    verifexit(manifest != NULL);

    manifest->min_fragment_size[IA_CSS_COL_DIMENSION] =
        min_size[IA_CSS_COL_DIMENSION];
    manifest->min_fragment_size[IA_CSS_ROW_DIMENSION] =
        min_size[IA_CSS_ROW_DIMENSION];
    retval = 0;

EXIT:
    if (NULL == manifest) {
        IA_CSS_TRACE_0(PSYSAPI_STATIC, ERROR,
            "ia_css_data_terminal_manifest_set_min_fragment_size invalid argument\n");
    }
    return retval;
}

int ia_css_data_terminal_manifest_set_max_fragment_size(
    ia_css_data_terminal_manifest_t    *manifest,
    const uint16_t max_size[IA_CSS_N_DATA_DIMENSION])
{
    int retval = -1;

    IA_CSS_TRACE_0(PSYSAPI_STATIC, VERBOSE,
        "ia_css_data_terminal_manifest_set_max_fragment_size(): enter:\n");

    verifexit(manifest != NULL);

    manifest->max_fragment_size[IA_CSS_COL_DIMENSION] =
        max_size[IA_CSS_COL_DIMENSION];
    manifest->max_fragment_size[IA_CSS_ROW_DIMENSION] =
        max_size[IA_CSS_ROW_DIMENSION];
    retval = 0;

EXIT:
    if (NULL == manifest) {
        IA_CSS_TRACE_0(PSYSAPI_STATIC, ERROR,
            "ia_css_data_terminal_manifest_set_max_fragment_size invalid argument\n");
    }
    return retval;
}
#endif

int ia_css_data_terminal_manifest_get_min_fragment_size(
    const ia_css_data_terminal_manifest_t *manifest,
    uint16_t min_size[IA_CSS_N_DATA_DIMENSION])
{
    int retval = -1;

    IA_CSS_TRACE_0(PSYSAPI_STATIC, VERBOSE,
        "ia_css_data_terminal_manifest_get_min_fragment_size(): enter:\n");

    verifexit(manifest != NULL);

    min_size[IA_CSS_COL_DIMENSION] =
        manifest->min_fragment_size[IA_CSS_COL_DIMENSION];
    min_size[IA_CSS_ROW_DIMENSION] =
        manifest->min_fragment_size[IA_CSS_ROW_DIMENSION];
    retval = 0;

EXIT:
    if (NULL == manifest) {
        IA_CSS_TRACE_0(PSYSAPI_STATIC, ERROR,
            "ia_css_data_terminal_manifest_get_min_fragment_size invalid argument\n");
    }
    return retval;
}

int ia_css_data_terminal_manifest_get_max_fragment_size(
    const ia_css_data_terminal_manifest_t *manifest,
    uint16_t max_size[IA_CSS_N_DATA_DIMENSION])
{
    int retval = -1;

    IA_CSS_TRACE_0(PSYSAPI_STATIC, VERBOSE,
        "ia_css_data_terminal_manifest_get_max_fragment_size(): enter:\n");

    verifexit(manifest != NULL);

    max_size[IA_CSS_COL_DIMENSION] =
        manifest->max_fragment_size[IA_CSS_COL_DIMENSION];
    max_size[IA_CSS_ROW_DIMENSION] =
        manifest->max_fragment_size[IA_CSS_ROW_DIMENSION];
    retval = 0;

EXIT:
    if (NULL == manifest) {
        IA_CSS_TRACE_0(PSYSAPI_STATIC, ERROR,
            "ia_css_data_terminal_manifest_get_max_fragment_size invalid argument\n");
    }
    return retval;
}

/* We need to refactor those files in order to build in the firmware only
   what is needed, switches are put current to workaround compilation problems
   in the firmware (for example lack of uint64_t support)
   supported in the firmware
  */
#if !defined(__HIVECC)

#define PRINT_DIMENSION(name, var) IA_CSS_TRACE_3(PSYSAPI_STATIC, \
    INFO, "%s:\t%d %d\n", \
    (name), \
    (var)[IA_CSS_COL_DIMENSION], \
    (var)[IA_CSS_ROW_DIMENSION])

int ia_css_terminal_manifest_print(
    const ia_css_terminal_manifest_t *manifest,
    void *fid)
{
    int retval = -1;
    ia_css_terminal_type_t terminal_type =
        ia_css_terminal_manifest_get_type(manifest);

    IA_CSS_TRACE_0(PSYSAPI_STATIC, INFO,
        "ia_css_terminal_manifest_print(): enter:\n");

    verifexit(manifest != NULL);
    NOT_USED(fid);
    NOT_USED(terminal_type_strings);

    IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO, "sizeof(manifest) = %d\n",
        (int)ia_css_terminal_manifest_get_size(manifest));
#ifndef __XTENSA_FW__
    IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO, "typeof(manifest) = %s\n",
            terminal_type_strings[terminal_type]);
#endif
    if (terminal_type == IA_CSS_TERMINAL_TYPE_PARAM_CACHED_IN ||
        terminal_type == IA_CSS_TERMINAL_TYPE_PARAM_CACHED_OUT) {
        ia_css_param_terminal_manifest_t *pterminal_manifest =
            (ia_css_param_terminal_manifest_t *)manifest;
        uint16_t section_count =
            pterminal_manifest->param_manifest_section_desc_count;
        int    i;

        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "sections(manifest) = %d\n", (int)section_count);
        for (i = 0; i < section_count; i++) {
            const ia_css_param_manifest_section_desc_t *manifest =
        ia_css_param_terminal_manifest_get_prm_sct_desc(
            pterminal_manifest, i);
            verifjmpexit(manifest != NULL);
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "kernel_id = %d\n", (int)ia_css_param_manifest_section_desc_get_kernel_id(manifest));
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "mem_type_id = %d\n",
                (int)ia_css_param_manifest_section_desc_get_mem_type_id(manifest));
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "max_mem_size = %d\n",
                (int)manifest->max_mem_size);
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "region_id = %d\n",
                (int)ia_css_param_manifest_section_desc_get_region_id(manifest));
        }
    } else if (terminal_type == IA_CSS_TERMINAL_TYPE_PARAM_SLICED_IN ||
        terminal_type == IA_CSS_TERMINAL_TYPE_PARAM_SLICED_OUT) {
        ia_css_sliced_param_terminal_manifest_t
        *sliced_terminal_manifest =
            (ia_css_sliced_param_terminal_manifest_t *)manifest;
        uint32_t kernel_id;
        uint16_t section_count;
        uint16_t section_idx;

        kernel_id = sliced_terminal_manifest->kernel_id;
        section_count =
            sliced_terminal_manifest->sliced_param_section_count;

        NOT_USED(kernel_id);

        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "kernel_id = %d\n", (int)kernel_id);
        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "section_count = %d\n", (int)section_count);

        for (section_idx = 0; section_idx < section_count;
            section_idx++) {
            ia_css_sliced_param_manifest_section_desc_t
                *sliced_param_manifest_section_desc;

            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "section %d\n", (int)section_idx);
            sliced_param_manifest_section_desc =
        ia_css_sliced_param_terminal_manifest_get_sliced_prm_sct_desc(
                sliced_terminal_manifest, section_idx);
            verifjmpexit(sliced_param_manifest_section_desc !=
                NULL);
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "mem_type_id = %d\n",
            (int)sliced_param_manifest_section_desc->mem_type_id);
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "region_id = %d\n",
            (int)sliced_param_manifest_section_desc->region_id);
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "max_mem_size = %d\n",
            (int)sliced_param_manifest_section_desc->max_mem_size);
        }
    } else if (terminal_type == IA_CSS_TERMINAL_TYPE_PROGRAM) {
        ia_css_program_terminal_manifest_t *program_terminal_manifest =
            (ia_css_program_terminal_manifest_t *)manifest;
        uint32_t sequencer_info_kernel_id;
        uint16_t max_kernel_fragment_sequencer_command_desc;
        uint16_t kernel_fragment_sequencer_info_manifest_info_count;
        uint16_t seq_info_idx;
        uint16_t section_count =
            program_terminal_manifest->fragment_param_manifest_section_desc_count;
        uint16_t sec_idx;

        sequencer_info_kernel_id =
            program_terminal_manifest->sequencer_info_kernel_id;
        max_kernel_fragment_sequencer_command_desc =
            program_terminal_manifest->
            max_kernel_fragment_sequencer_command_desc;
        kernel_fragment_sequencer_info_manifest_info_count =
            program_terminal_manifest->
            kernel_fragment_sequencer_info_manifest_info_count;

        NOT_USED(sequencer_info_kernel_id);
        NOT_USED(max_kernel_fragment_sequencer_command_desc);

        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "sequencer_info_kernel_id = %d\n",
            (int)sequencer_info_kernel_id);
        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "max_kernel_fragment_sequencer_command_desc = %d\n",
            (int)max_kernel_fragment_sequencer_command_desc);
        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "kernel_fragment_sequencer_info_manifest_info_count = %d\n",
            (int)
            kernel_fragment_sequencer_info_manifest_info_count);

        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "fragment_param_manifest_section_desc_count = %d\n", (int)section_count);
        for (sec_idx = 0; sec_idx < section_count; sec_idx++) {
            const ia_css_fragment_param_manifest_section_desc_t *ptmanifest =
        ia_css_program_terminal_manifest_get_frgmnt_prm_sct_desc(
            program_terminal_manifest, sec_idx);
            NOT_USED(ptmanifest);
            verifjmpexit(manifest != NULL);
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "kernel_id = %d\n", (int)ia_css_fragment_param_manifest_section_desc_get_kernel_id(ptmanifest));
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "mem_type_id = %d\n",
                (int)ia_css_fragment_param_manifest_section_desc_get_mem_type_id(ptmanifest));
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "max_mem_size = %d\n",
                (int)ptmanifest->max_mem_size);
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "region_id = %d\n",
                (int)ia_css_fragment_param_manifest_section_desc_get_region_id(ptmanifest));
        }
        for (seq_info_idx = 0; seq_info_idx <
            kernel_fragment_sequencer_info_manifest_info_count;
                seq_info_idx++) {
            ia_css_kernel_fragment_sequencer_info_manifest_desc_t
                *sequencer_info_manifest_desc;

            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "sequencer info %d\n", (int)seq_info_idx);
            sequencer_info_manifest_desc =
        ia_css_program_terminal_manifest_get_kernel_frgmnt_seq_info_desc
                (program_terminal_manifest, seq_info_idx);
            verifjmpexit(sequencer_info_manifest_desc != NULL);
            IA_CSS_TRACE_2(PSYSAPI_STATIC, INFO,
                "min_fragment_grid_slice_dimension[] = {%d, %d}\n",
                (int)sequencer_info_manifest_desc->
                min_fragment_grid_slice_dimension[
                        IA_CSS_COL_DIMENSION],
                (int)sequencer_info_manifest_desc->
                min_fragment_grid_slice_dimension[
                        IA_CSS_ROW_DIMENSION]);
            IA_CSS_TRACE_2(PSYSAPI_STATIC, INFO,
                "max_fragment_grid_slice_dimension[] = {%d, %d}\n",
                (int)sequencer_info_manifest_desc->
                max_fragment_grid_slice_dimension[
                        IA_CSS_COL_DIMENSION],
                (int)sequencer_info_manifest_desc->
                max_fragment_grid_slice_dimension[
                        IA_CSS_ROW_DIMENSION]);
            IA_CSS_TRACE_2(PSYSAPI_STATIC, INFO,
                "min_fragment_grid_slice_count[] = {%d, %d}\n",
                (int)sequencer_info_manifest_desc->
                min_fragment_grid_slice_count[
                        IA_CSS_COL_DIMENSION],
                (int)sequencer_info_manifest_desc->
                min_fragment_grid_slice_count[
                        IA_CSS_ROW_DIMENSION]);
            IA_CSS_TRACE_2(PSYSAPI_STATIC, INFO,
                "max_fragment_grid_slice_count[] = {%d, %d}\n",
                (int)sequencer_info_manifest_desc->
                max_fragment_grid_slice_count[
                        IA_CSS_COL_DIMENSION],
                (int)sequencer_info_manifest_desc->
                max_fragment_grid_slice_count[
                        IA_CSS_ROW_DIMENSION]);
            IA_CSS_TRACE_2(PSYSAPI_STATIC, INFO,
                "min_fragment_grid_point_decimation_factor[] = {%d, %d}\n",
                (int)sequencer_info_manifest_desc->
                min_fragment_grid_point_decimation_factor[
                        IA_CSS_COL_DIMENSION],
                (int)sequencer_info_manifest_desc->
                min_fragment_grid_point_decimation_factor[
                        IA_CSS_ROW_DIMENSION]);
            IA_CSS_TRACE_2(PSYSAPI_STATIC, INFO,
                "max_fragment_grid_point_decimation_factor[] = {%d, %d}\n",
                (int)sequencer_info_manifest_desc->
                max_fragment_grid_point_decimation_factor[
                        IA_CSS_COL_DIMENSION],
                (int)sequencer_info_manifest_desc->
                max_fragment_grid_point_decimation_factor[
                        IA_CSS_ROW_DIMENSION]);
            IA_CSS_TRACE_2(PSYSAPI_STATIC, INFO,
                "min_fragment_grid_overlay_on_pixel_topleft_index[] = {%d, %d}\n",
                (int)sequencer_info_manifest_desc->
            min_fragment_grid_overlay_pixel_topleft_index[
                        IA_CSS_COL_DIMENSION],
                (int)sequencer_info_manifest_desc->
            min_fragment_grid_overlay_pixel_topleft_index[
                        IA_CSS_ROW_DIMENSION]);
            IA_CSS_TRACE_2(PSYSAPI_STATIC, INFO,
                "max_fragment_grid_overlay_on_pixel_topleft_index[] = {%d, %d}\n",
                (int)sequencer_info_manifest_desc->
            max_fragment_grid_overlay_pixel_topleft_index[
                        IA_CSS_COL_DIMENSION],
                (int)sequencer_info_manifest_desc->
            max_fragment_grid_overlay_pixel_topleft_index[
                        IA_CSS_ROW_DIMENSION]);
            IA_CSS_TRACE_2(PSYSAPI_STATIC, INFO,
                "min_fragment_grid_overlay_on_pixel_dimension[] = {%d, %d}\n",
                (int)sequencer_info_manifest_desc->
                min_fragment_grid_overlay_pixel_dimension[
                        IA_CSS_COL_DIMENSION],
                (int)sequencer_info_manifest_desc->
                min_fragment_grid_overlay_pixel_dimension[
                        IA_CSS_ROW_DIMENSION]);
            IA_CSS_TRACE_2(PSYSAPI_STATIC, INFO,
                "max_fragment_grid_overlay_on_pixel_dimension[] = {%d, %d}\n",
                (int)sequencer_info_manifest_desc->
                max_fragment_grid_overlay_pixel_dimension[
                        IA_CSS_COL_DIMENSION],
                (int)sequencer_info_manifest_desc->
                max_fragment_grid_overlay_pixel_dimension[
                        IA_CSS_ROW_DIMENSION]);
        }
    } else if (terminal_type == IA_CSS_TERMINAL_TYPE_PROGRAM_CONTROL_INIT) {
        ia_css_program_control_init_terminal_manifest_t *progctrlinit_man =
            (ia_css_program_control_init_terminal_manifest_t *)manifest;
        ia_css_program_control_init_terminal_manifest_print(progctrlinit_man);
    } else if (terminal_type == IA_CSS_TERMINAL_TYPE_DATA_IN ||
        terminal_type == IA_CSS_TERMINAL_TYPE_DATA_OUT) {

        ia_css_data_terminal_manifest_t *dterminal_manifest =
            (ia_css_data_terminal_manifest_t *)manifest;
        int i;

        NOT_USED(dterminal_manifest);

        verifexit(ia_css_kernel_bitmap_print(
            ia_css_data_terminal_manifest_get_kernel_bitmap(
                dterminal_manifest), fid) == 0);
        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "formats(manifest) = %04x\n",
        (int)ia_css_data_terminal_manifest_get_frame_format_bitmap(
            dterminal_manifest));
        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "connection(manifest) = %04x\n",
        (int)ia_css_data_terminal_manifest_get_connection_bitmap(
            dterminal_manifest));
        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "dependent(manifest) = %d\n",
            (int)dterminal_manifest->terminal_dependency);

        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "\tmin_size[%d]   = {\n",
            IA_CSS_N_DATA_DIMENSION);
        for (i = 0; i < (int)IA_CSS_N_DATA_DIMENSION - 1; i++) {
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "\t\t%4d,\n", dterminal_manifest->min_size[i]);
        }
        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "\t\t%4d }\n", dterminal_manifest->min_size[i]);

        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "\tmax_size[%d]   = {\n", IA_CSS_N_DATA_DIMENSION);
        for (i = 0; i < (int)IA_CSS_N_DATA_DIMENSION - 1; i++) {
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "\t\t%4d,\n", dterminal_manifest->max_size[i]);
        }
        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "\t\t%4d }\n", dterminal_manifest->max_size[i]);

        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "\tmin_fragment_size[%d]   = {\n",
            IA_CSS_N_DATA_DIMENSION);
        for (i = 0; i < (int)IA_CSS_N_DATA_DIMENSION - 1; i++) {
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "\t\t%4d,\n",
                dterminal_manifest->min_fragment_size[i]);
        }
        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "\t\t%4d }\n",
            dterminal_manifest->min_fragment_size[i]);

        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "\tmax_fragment_size[%d]   = {\n",
            IA_CSS_N_DATA_DIMENSION);
        for (i = 0; i < (int)IA_CSS_N_DATA_DIMENSION - 1; i++) {
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
                "\t\t%4d,\n",
                dterminal_manifest->max_fragment_size[i]);
        }
        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO,
            "\t\t%4d }\n",
            dterminal_manifest->max_fragment_size[i]);

    } else if (terminal_type == IA_CSS_TERMINAL_TYPE_PARAM_SPATIAL_IN ||
        terminal_type == IA_CSS_TERMINAL_TYPE_PARAM_SPATIAL_OUT) {

        ia_css_spatial_param_terminal_manifest_t *stm =
            (ia_css_spatial_param_terminal_manifest_t *)manifest;
        ia_css_frame_grid_param_manifest_section_desc_t *sec;
        int sec_count =
            stm->frame_grid_param_manifest_section_desc_count;
        int sec_index;

        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO, "kernel_id:\t\t%d\n",
            stm->kernel_id);
        IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO, "compute_units_p_elem:\t%d\n",
            stm->compute_units_p_elem);
#ifndef __XTENSA_FW__
        PRINT_DIMENSION("min_fragment_grid_dimension",
            stm->common_fragment_grid_desc.min_fragment_grid_dimension);
        PRINT_DIMENSION("max_fragment_grid_dimension",
            stm->common_fragment_grid_desc.max_fragment_grid_dimension);
        PRINT_DIMENSION("min_frame_grid_dimension",
            stm->frame_grid_desc.min_frame_grid_dimension);
        PRINT_DIMENSION("max_frame_grid_dimension",
            stm->frame_grid_desc.max_frame_grid_dimension);
#endif
        for (sec_index = 0; sec_index < sec_count; sec_index++) {
            sec = ia_css_spatial_param_terminal_manifest_get_frm_grid_prm_sct_desc(
                stm, sec_index);
            verifjmpexit(sec != NULL);

            IA_CSS_TRACE_0(PSYSAPI_STATIC, INFO, "--------------------------\n");
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO, "\tmem_type_id:\t%d\n",
                sec->mem_type_id);
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO, "\tregion_id:\t%d\n",
                sec->region_id);
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO, "\telem_size:\t%d\n",
                sec->elem_size);
            IA_CSS_TRACE_1(PSYSAPI_STATIC, INFO, "\tmax_mem_size:\t%d\n",
                sec->max_mem_size);
        }
    } else if (terminal_type < IA_CSS_N_TERMINAL_TYPES) {
        IA_CSS_TRACE_0(PSYSAPI_STATIC, WARNING,
            "terminal type can not be pretty printed, not supported\n");
    }

    retval = 0;
EXIT:
    if (retval != 0) {
        IA_CSS_TRACE_1(PSYSAPI_STATIC, ERROR,
            "ia_css_terminal_manifest_print failed (%i)\n",
            retval);
    }
    return retval;
}

/* Program control init Terminal */
unsigned int ia_css_program_control_init_terminal_manifest_get_connect_section_count(
    const ia_css_program_control_init_manifest_program_desc_t *prog)
{
    assert(prog);
    return prog->connect_section_count;
}


unsigned int ia_css_program_control_init_terminal_manifest_get_load_section_count(
    const ia_css_program_control_init_manifest_program_desc_t *prog)
{
    assert(prog);
    return prog->load_section_count;
}

unsigned int ia_css_program_control_init_terminal_manifest_get_size(
    const uint16_t nof_programs,
    const uint16_t *nof_load_sections,
    const uint16_t *nof_connect_sections)
{
    (void)nof_load_sections; /* might be needed in future */
    (void)nof_connect_sections; /* might be needed in future */

    return sizeof(ia_css_program_control_init_terminal_manifest_t) +
        nof_programs *
        sizeof(ia_css_program_control_init_manifest_program_desc_t);
}

ia_css_program_control_init_manifest_program_desc_t *
ia_css_program_control_init_terminal_manifest_get_program_desc(
    const ia_css_program_control_init_terminal_manifest_t *terminal,
    unsigned int program)
{
    ia_css_program_control_init_manifest_program_desc_t *progs;

    assert(terminal != NULL);
    assert(program < terminal->program_count);

    progs = (ia_css_program_control_init_manifest_program_desc_t *)
        ((const char *)terminal + terminal->program_desc_offset);

    return &progs[program];
}

int ia_css_program_control_init_terminal_manifest_init(
    ia_css_program_control_init_terminal_manifest_t *terminal,
    const uint16_t nof_programs,
    const uint16_t *nof_load_sections,
    const uint16_t *nof_connect_sections)
{
    unsigned int i;
    ia_css_program_control_init_manifest_program_desc_t *progs;

    if (terminal == NULL) {
        return -EFAULT;
    }

    terminal->program_count = nof_programs;
    terminal->program_desc_offset =
        sizeof(ia_css_program_control_init_terminal_manifest_t);

    progs = ia_css_program_control_init_terminal_manifest_get_program_desc(
        terminal, 0);

    for (i = 0; i < nof_programs; i++) {
        progs[i].load_section_count = nof_load_sections[i];
        progs[i].connect_section_count = nof_connect_sections[i];
    }
    return 0;
}

void ia_css_program_control_init_terminal_manifest_print(
    ia_css_program_control_init_terminal_manifest_t *terminal)
{
    unsigned int i;

    ia_css_program_control_init_manifest_program_desc_t *progs;

    progs = ia_css_program_control_init_terminal_manifest_get_program_desc(
        terminal, 0);

    assert(progs);
    (void)progs;

    for (i = 0; i < terminal->program_count; i++) {
        IA_CSS_TRACE_3(PSYSAPI_STATIC, INFO,
            "program index: %d, load sec: %d, connect sec: %d\n",
            i,
            progs[i].load_section_count,
            progs[i].connect_section_count);
    }
}

#endif