/*******************************************************************************
 *   Copyright (c) 2020 Dortmund University of Applied Sciences and Arts and others.
 *
 *   This program and the accompanying materials are made
 *   available under the terms of the Eclipse Public License 2.0
 *   which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 *   SPDX-License-Identifier: EPL-2.0
 *
 *   Contributors:
 *        Dortmund University of Applied Sciences and Arts - initial API and implementation
 *******************************************************************************/

#ifndef SRC_PARALLELLA_TRACE_UTILS_BTF_H_
#define SRC_PARALLELLA_TRACE_UTILS_BTF_H_

/**
 * @file trace_utils_BTF.h
 * @author Anand Prakash
 * @date 23 May 2020
 * @brief This file declares and implement the BTF trace framework. It
 * consists of functions used to generate the trace information of the tasks, runnables
 * shared label access and hardware info in the BTF trace format.
 *
 * @see https://wiki.eclipse.org/images/e/e6/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include "RTFParallellaConfig.h"

#define RFTP_GENERATE_BTF_TRACE 0x01

#define BTF_TRACE_TRUE     0x01
#define BTF_TRACE_FALSE    0x00


/* BTF trace flags */
#define BTF_TRACE_BUFFER_SIZE           8
#define TIME_FLAG                       0
#define SOURCE_FLAG                     1
#define SOURCE_INSTANCE_FLAG            2
#define EVENT_TYPE_FLAG                 3
#define TARGET_FLAG                     4
#define TARGET_INSTANCE_FLAG            5
#define EVENT_FLAG                      6
#define DATA_FLAG                       7

/* Enum for event type ID */
typedef enum btf_trace_event_type_t
{
    TASK_EVENT,                        /**< BTF Task Event*/
    INT_SERVICE_ROUTINE_EVENT,         /**< BTF ISR Event*/
    RUNNABLE_EVENT,                    /**< BTF Runnable Event*/
    INS_BLOCK_EVENT,                   /**< BTF INS Block Event*/
    STIMULUS_EVENT,                    /**< BTF Stimulus Event*/
    ECU_EVENT,                         /**< BTF ECU Event*/
    PROCESSOR_EVENT,                   /**< BTF Processor Event*/
    CORE_EVENT,                        /**< BTF Hardware Core Event*/
    SCHEDULER_EVENT,                   /**< BTF Scheduler Event*/
    SIGNAL_EVENT,                      /**< BTF Signal Event for reading/writing labels*/
    SEMAPHORE_EVENT,                   /**< BTF Semaphore Event*/
    SIMULATION_EVENT                   /**< BTF Simulation Event*/
} btf_trace_event_type;

/* Enum for event name */
typedef enum btf_trace_event_name_t
{
    INIT = -1,            /**< Dummy Init Event name*/
    PROCESS_START,        /**< Starting a process/task/runnable*/
    PROCESS_TERMINATE,    /**< Terminating a process/task/runnable*/
    PROCESS_PREEMPT,      /**< Preempt a process/task*/
    PROCESS_SUSPEND,      /**< Suspend a runnable event*/
    PROCESS_RESUME,       /**< Resume a process/task/runnable*/
    SIGNAL_READ,          /**< Read event for signal/label*/
    SIGNAL_WRITE          /**< Write signal for signal/label*/
} btf_trace_event_name;


/**
 * Structure to hold BTF Header
 */
typedef struct btf_trace_header_config_t
{
    uint32_t timescale;           /**< This sets the scale of the time e.g 10, 100 etc.. */
    uint8_t creator[64];          /**< Target device on which the trace is generated */
    uint8_t modelfile[512];       /**< Model file used to generate the trace */
    uint8_t timeunit[4];          /**< Time unit e.g ns, ms, us, s..*/
} btf_trace_header_config_t;

/* BTF structure for storing the entity configuration */
typedef struct btf_trace_entity_entry_t
{
    uint16_t entity_id;                 /**< Entity ID to get the entity name */
    int16_t instance;                   /**< Current instance of the entity */
    btf_trace_event_name state;         /**< Current state of the entity */
    btf_trace_event_type entity_type;   /**< Entity type to get the source*/
    uint8_t entity_name[64];            /**< Entity name */

} btf_trace_entity_entry;

/* Structure to hold BTF trace data in task stack for processing */
typedef struct btf_trace_data_t
{
    int32_t ticks;                     /**< Tick count */
    int32_t srcId;                     /**< Source Id */
    int32_t srcInstance;               /**< Instance of the source */
    int32_t eventTypeId;               /**< Type of event Runnable , Task etc.. */
    int32_t taskId;                    /**< Task Id */
    int32_t taskInstance;              /**< Instance of the task */
    int32_t eventState;                /**< State of the event */
    int32_t data;                      /**< Notes */
} btf_trace_data;

/* Entity table structure */
typedef struct btf_trace_entity_table_t
{
    uint16_t is_occupied;                 /**< If 0, entry is available else not available */
    btf_trace_entity_entry entity_data;   /**< Entity details */
} btf_trace_entity_table;

/**
 * @brief Function to get the file name of the trace file along with the
 * absolute path.
 *
 * Arguments:
 * @param[inout] trace_file_path  : Pointer to the buffer where the BTF trace file path
 *                                  is stored.
 *
 * @return: void
 */
void get_btf_trace_file_path(char *trace_file_path);

/**
 * @brief Parse the command line arguments for generating the BTF trace file
 *
 * The provided parameters are used to configure the trace file required to
 * be generated. For example the trace file path, model file used to generate the
 * trace, device name and time scale.
 *
 * Arguments:
 * @param[in] argc  : The count for the number of arguments passed
 * @param[in] argv  : Pointer to the list of arguments
 *
 * @return: The integer value of the timescale used for the task execution.
 */
int parse_btf_trace_arguments(int argc, char **argv);

/**
 * @brief This function is responsible for writing the BTF trace header information.
 *
 * Function to write BTF header data to the trace file. It writes the version, creator,
 * input model file, time scale and timestamp section of the header file. It also writes
 * the entity table, type table and entity type table used in the task model.
 *
 * Arguments:
 * @param[in] stream  : File pointer to the stream where the data has to be
 *                      written.
 *
 * @return            : void
 */
void write_btf_trace_header_config(FILE *stream);

/**
 * @brief This function to write entity type in BTF header data.
 *
 * The function defines what kinds of entities are supported in the BTF
 * trace generated. It consists of entity type such as Tasks, Signals, Runnables
 * along with their IDs.
 * Refer to below link for more details:
 * https://wiki.eclipse.org/images/e/e6/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf
 *
 * Arguments:
 * @param[in] stream  : File pointer to the stream where the data has to be
 *                      written.
 * @param[in] type    : Type of the entity i.e. TASK, RUNNABLE, STIMULUS etc..
 *
 * @return: void
 */
void write_btf_trace_header_entity_type(FILE *stream, btf_trace_event_type type);

/**
 * @brief Function to write entity type in BTF header data
 *
 * The function writes the list of tasks, runnables, shared labels, cores in a
 * tabular format. It combines the entity type and entity type table.
 * Refer to below link for more details:
 * https://wiki.eclipse.org/images/e/e6/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf
 *
 * Arguments:
 * @param[in] stream  : File pointer to the stream where the data has to be
 *                     written.
 *
 * @return: void
 */
void write_btf_trace_header_entity_table(FILE *stream);

/**
 * @brief  This function writes the entity type table in the BTF header.
 *
 * The function writes the list of tasks, runnables, shared labels, cores in a
 * tabular format. It consists of the tasks, runnables and shared labels executed
 * on the specified cores along with their IDs.
 * Refer to below link for more details:
 * https://wiki.eclipse.org/images/e/e6/TA_BTF_Specification_2.1.3_Eclipse_Auto_IWG.pdf
 *
 * Arguments:
 * @param[in] stream  : File pointer to the stream where the data has to be
 *                      written.
 *
 * @return: void
 */
void write_btf_trace_header_entity_type_table(FILE *stream);

/**
 * @brief This function is used to store the entity information of all the
 * tasks, runnables and labels.
 *
 * Store the entity metadata which can be used to generate the entity
 * type and entity type table. Also this table entry is used to decode the
 * tasks and runnables information received from the Parallella framework.
 *
 * Arguments:
 * @param[in] typeId  : Unique entity type ID
 * @param[in] type    : Entity type..e.g TASK, RUNNABLE etc..
 * @param[in] name    : Entity name
 *
 * @return: void
 */
void store_entity_entry(entity_id typeId, btf_trace_event_type type, const char *name);

/**
 * @brief Function to write the data section of the BTF
 *
 * The function is responsible for writing the BTF trace data section in
 * CSV format which can be interpreted by the trace visualizing tools such as
 * Eclipse trace compass. Currently the support is provided for only two cores.
 * However, this can be extended further for multiple cores.
 *
 * Arguments:
 * @param[in] stream        : File pointer to the stream where the data has to be
 *                            written.
 * @param[in] core_id       : Core ID on which the task operations are performed
 * @param[in] data_buffer   : Data buffer containing the BTF trace information.
 *
 * @return: void
 */
void write_btf_trace_data(FILE *stream, uint8_t core_id, unsigned int * data_buffer);

#endif /* SRC_PARALLELLA_TRACE_UTILS_BTF_H_ */