// Copyright(c) 2018-2020, Intel Corporation
//
// Redistribution  and  use  in source  and  binary  forms,  with  or  without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of  source code  must retain the  above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
// * Neither the name  of Intel Corporation  nor the names of its contributors
//   may be used to  endorse or promote  products derived  from this  software
//   without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO,  THE
// IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED.  IN NO EVENT  SHALL THE COPYRIGHT OWNER  OR CONTRIBUTORS BE
// LIABLE  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR
// CONSEQUENTIAL  DAMAGES  (INCLUDING,  BUT  NOT LIMITED  TO,  PROCUREMENT  OF
// SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE,  DATA, OR PROFITS;  OR BUSINESS
// INTERRUPTION)  HOWEVER CAUSED  AND ON ANY THEORY  OF LIABILITY,  WHETHER IN
// CONTRACT,  STRICT LIABILITY,  OR TORT  (INCLUDING NEGLIGENCE  OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

/**
* \file metrics_int.h
* \brief fpga metrics utils functions
*/

#ifndef __FPGA_METRICS_INT_H__
#define __FPGA_METRICS_INT_H__

#include "vector.h"
#include "opae/metrics.h"
#include "metrics_metadata.h"
#include "metrics/bmc/bmc.h"
#include "types_int.h"
// Power,Thermal & Performance definations

#define PERF                               "*perf"


#define PWRMGMT                             "power_mgmt"
#define THERLGMT                            "thermal_mgmt"
#define REVISION                            "revision"
#define PERF_FREEZE                         "freeze"
#define PERF_ENABLE                         "enable"
#define PERF_CACHE                          "cache"
#define PERF_FABRIC                         "fabric"
#define PERF_IOMMU                          "iommu"
#define PERFORMANCE                         "performance"
#define FPGA_LIMIT                          "fpga_limit"
#define XEON_LIMIT                          "xeon_limit"
#define TEMP                                "Centigrade"

#define TEMPERATURE                         "Temperature"
#define VOLTAGE                             "Voltage"
#define CURRENT                             "Current"
#define POWER                               "Power"
#define CLOCK                               "Clock"


#define TEMPERATURE_UNITS                   "Celsius"
#define VOLTAGE_UNITS                       "Volts"
#define CURRENT_UNITS                       "Amps"
#define POWER_UNITS                         "Watts"
#define CLOCK_UNITS                         "Hz"

#define MAX10_SYSFS_PATH                     "spi-*/spi_master/spi*/spi*.*"
#define MAX10_SENSOR_SYSFS_PATH              "spi-*/spi_master/spi*/spi*.*/sensor*"

#define SENSOR_SYSFS_NAME                    "name"
#define SENSOR_SYSFS_TYPE                    "type"
#define SENSOR_SYSFS_ID                      "id"
#define SENSOR_SYSFS_VALUE                   "value"
#define MILLI                                 1000

#define  FPGA_DISCRETE_VC_DEVICEID           0x0B30

#define  FPGA_DISCRETE_DC_DEVICEID           0x0B2B

#define BMC_LIB                             "libmodbmc.so"

// AFU DFH Struct
struct DFH {
	union {
		uint64_t csr;
		struct {
			uint64_t id:12;
			uint64_t  revision:4;
			uint64_t next_header_offset:24;
			uint64_t eol:1;
			uint64_t reserved:19;
			uint64_t  type:4;
		};
	};
};

struct NEXT_AFU {
	union {
		uint64_t csr;
		struct {
			uint32_t next_afu:24;
			uint64_t reserved:40;
		};
	};
};

typedef struct {
	struct DFH dfh;
	uint64_t guid[2];
	struct NEXT_AFU next_afu;
} feature_definition;

// metric group csr
struct metric_bbb_group {
	union {
		uint64_t csr;
		struct {
			uint64_t reserved:28;
			uint64_t units:8;
			uint64_t group_id:8;
			uint64_t eol:1;
			uint64_t next_group_offset:16;
			uint64_t reset:1;
			uint64_t reset_access:2;
		};
	};
};

// metric value csr
struct metric_bbb_value {
	union {
		uint64_t csr;
		struct {
			uint64_t reserved:7;
			uint64_t eol:1;
			uint64_t counter_id:8;
			uint64_t value:48;
		};
	};
};

// Metrics utils functions
fpga_result metric_sysfs_path_is_file(const char *path);

fpga_result metric_sysfs_path_is_dir(const char *path);

fpga_result add_metric_vector(fpga_metric_vector *vector,
				uint64_t metric_id,
				const char *qualifier_name,
				const char *group_name,
				const char *group_sysfs,
				const char *metric_name,
				const char *metric_sysfs,
				const char *metric_units,
				enum fpga_metric_datatype metric_datatype,
				enum fpga_metric_type	metric_type,
				enum fpga_hw_type	hw_type,
				uint64_t mmio_offset);

fpga_result enum_thermalmgmt_metrics(fpga_metric_vector *vector,
					uint64_t *metric_id,
					const char *sysfspath,
					enum fpga_hw_type hw_type);

fpga_result enum_powermgmt_metrics(fpga_metric_vector *vector,
					uint64_t *metric_id,
					const char *sysfspath,
					enum fpga_hw_type hw_type);

fpga_result enum_perf_counter_items(fpga_metric_vector *vector,
					uint64_t *metric_id,
					const char *qualifier_name,
					const char *sysfspath,
					const char *sysfs_name,
					enum fpga_metric_type metric_type,
					enum fpga_hw_type hw_type);

fpga_result enum_perf_counter_metrics(fpga_metric_vector *vector,
					uint64_t *metric_id,
					const char *sysfspath,
					enum fpga_hw_type  hw_type);

fpga_result enum_fpga_metrics(fpga_handle handle);


fpga_result get_fme_metric_value(fpga_handle handle,
				fpga_metric_vector *enum_vector,
				uint64_t metric_id,
				struct fpga_metric *fpga_metric);

fpga_result add_metric_info(struct _fpga_enum_metric *_enum_metrics,
				struct fpga_metric_info *fpga_metric_info);

fpga_result free_fpga_enum_metrics_vector(struct _fpga_handle *_handle);


fpga_result parse_metric_num_name(const char *search_string,
				fpga_metric_vector *fpga_enum_metrics_vector,
				uint64_t *metric_num);

fpga_result enum_bmc_metrics_info(struct _fpga_handle *_handle,
				fpga_metric_vector *vector,
				uint64_t *metric_id,
				enum fpga_hw_type hw_type);

fpga_result get_fpga_object_type(fpga_handle handle, fpga_objtype *objtype);

fpga_result get_pwr_thermal_value(const char *sysfs_path, uint64_t *value);

fpga_result clear_cached_values(fpga_handle handle);


fpga_result get_performance_counter_value(const char *group_sysfs,
					const char *metric_sysfs,
					uint64_t *value);

fpga_result get_bmc_metrics_values(fpga_handle handle,
				struct _fpga_enum_metric *_fpga_enum_metric,
				struct fpga_metric *fpga_metric);

// AFU Metric
fpga_result enum_afu_metrics(fpga_handle handle,
				fpga_metric_vector *vector,
				uint64_t *metric_id,
				uint64_t metrics_offset);

fpga_result get_afu_metric_value(fpga_handle handle,
				fpga_metric_vector	*enum_vector,
				uint64_t metric_num,
				struct fpga_metric *fpga_metric);

fpga_result add_afu_metrics_vector(fpga_metric_vector *vector,
				uint64_t *metric_id,
				uint64_t group_value,
				uint64_t metric_value,
				uint64_t metric_offset);

fpga_result discover_afu_metrics_feature(fpga_handle handle, uint64_t *offset);

fpga_result get_metric_data_info(const char *group_name,
		const char *metric_name,
		fpga_metric_metadata *metric_data_search,
		uint64_t size,
		fpga_metric_metadata *metric_data);

fpga_result xfpga_bmcLoadSDRs(struct _fpga_handle *_handle,
	bmc_sdr_handle *records,
	uint32_t *num_sensors);

fpga_result xfpga_bmcDestroySDRs(struct _fpga_handle *_handle,
	bmc_sdr_handle *records);

fpga_result xfpga_bmcReadSensorValues(struct _fpga_handle *_handle,
	bmc_sdr_handle records,
	bmc_values_handle *values,
	uint32_t *num_values);

fpga_result xfpga_bmcDestroySensorValues(struct _fpga_handle *_handle,
	bmc_values_handle *values);

fpga_result xfpga_bmcGetSensorReading(struct _fpga_handle *_handle,
	bmc_values_handle values,
	uint32_t sensor_number,
	uint32_t *is_valid,
	double *value);

fpga_result xfpga_bmcGetSDRDetails(struct _fpga_handle *_handle,
	bmc_values_handle values,
	uint32_t sensor_number,
	sdr_details *details);

void *metrics_load_bmc_lib(void);

#endif // __FPGA_METRICS_INT_H__