// 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.

#include "bmc.h"

#define _TIMESPEC_DEFINED

#include "../../types_int.h"

#include "bmcdata.h"

#include <sys/types.h>

#include <sys/stat.h>

#include <string.h>

#ifndef _WIN32

#include <unistd.h>

#else

#include <io.h>

#endif

#include <fcntl.h>

#include <stdlib.h>

#include <glob.h>

#define NULL_CHECK(x)                                                          \

	do {                                                                   \

		if (NULL == (x)) {                                             \

			return FPGA_INVALID_PARAM;                             \

		}                                                              \

	} while (0)

fpga_result read_sysfs_file(fpga_token token, const char *file,

		   void **buf, uint32_t *tot_bytes_ret)

{

	char sysfspath[SYSFS_PATH_MAX] = { 0, };

	struct stat stats;

	int fd = 0;

	fpga_result res = FPGA_OK;

	NULL_CHECK(token);

	NULL_CHECK(buf);

	NULL_CHECK(file);

	NULL_CHECK(tot_bytes_ret);

	*buf = NULL;

	*tot_bytes_ret = 0;

	struct _fpga_token *tok = (struct _fpga_token *)token;

	if (FPGA_TOKEN_MAGIC != tok->magic) {

		return FPGA_INVALID_PARAM;

	}

	if (snprintf(sysfspath, sizeof(sysfspath),

		     "%s/%s", tok->sysfspath, file) < 0) {

		OPAE_ERR("snprintf buffer overflow");

		return FPGA_EXCEPTION;

	}

	glob_t pglob;

	int gres = glob(sysfspath, GLOB_NOSORT, NULL, &pglob);

	if ((gres) || (1 != pglob.gl_pathc)) {

		globfree(&pglob);

		return FPGA_NOT_FOUND;

	}

	fd = open(pglob.gl_pathv[0], O_RDONLY);

	globfree(&pglob);

	if (fd < 0) {

		return FPGA_NOT_FOUND;

	}

	if (fstat(fd, &stats) != 0) {

		close(fd);

		return FPGA_NOT_FOUND;

	}

	// fstat for a sysfs file is not accurate for the BMC

	// Read the entire file into a temp buffer to get actual size of file

	*buf = (void *)calloc(stats.st_size, 1);

	int32_t tot_bytes = 0;

	int32_t bytes_read = 0;

	do {

		bytes_read = (int32_t)read(fd, *buf, stats.st_size);

		if (bytes_read < 0) {

			if (errno == EINTR) {

				bytes_read = 1; // Fool the while loop

				continue;

			}

		}

		tot_bytes += bytes_read;

	} while ((tot_bytes < stats.st_size) && (bytes_read > 0));

	close(fd);

	if ((tot_bytes > stats.st_size) || (bytes_read < 0)) {

		res = FPGA_EXCEPTION;

		free(*buf);

		*buf = NULL;

		goto out;

	}

	*tot_bytes_ret = tot_bytes;

out:

	return res;

}

fpga_result bmcLoadSDRs(fpga_token token, bmc_sdr_handle *records,

			uint32_t *num_sensors)

{

	fpga_result res = FPGA_OK;

	size_t len;

	NULL_CHECK(token);

	NULL_CHECK(num_sensors);

	struct _sdr_rec *recs = NULL;

	struct _sdr_content *tmp = NULL;

	uint32_t tot_bytes;

	res = read_sysfs_file(token, SYSFS_SDR_FILE, (void **)&tmp, &tot_bytes);

	if (FPGA_OK != res) {

		if (tmp) {

			free(tmp);

		}

		goto out;

	}

	uint32_t sz = sizeof(sdr_header) + sizeof(sdr_key) + sizeof(sdr_body);

	uint32_t num_of_sensors = (tot_bytes + sz - 1) / sz;

	*num_sensors = num_of_sensors;

	if (NULL == records) {

		free(tmp);

		return FPGA_OK;

	}

	*records = (bmc_sdr_handle)calloc(1, sizeof(struct _sdr_rec));

	if (NULL == *records) {

		free(tmp);

		return FPGA_NO_MEMORY;

	}

	recs = (struct _sdr_rec *)*records;

	recs->contents = tmp;

	recs->magic = BMC_SDR_MAGIC;

	recs->num_records = num_of_sensors;

	struct _fpga_token *tok = (struct _fpga_token *)token;

	len = strnlen(tok->sysfspath, SYSFS_PATH_MAX - 1);

	strncpy(recs->sysfs_path, tok->sysfspath, len + 1);

	recs->token = token;

out:

	return res;

}

fpga_result bmcReadSensorValues(bmc_sdr_handle records, bmc_values_handle *values,

				uint32_t *num_values)

{

	fpga_result res = FPGA_OK;

	struct _bmc_values *vals = NULL;

	NULL_CHECK(records);

	struct _sdr_rec *sdr = (struct _sdr_rec *)records;

	struct _sensor_reading *tmp = NULL;

	if (BMC_SDR_MAGIC != sdr->magic) {

		return FPGA_INVALID_PARAM;

	}

	NULL_CHECK(num_values);

	if (NULL == values) {

		*num_values = sdr->num_records;

		return FPGA_OK;

	}

	uint32_t tot_bytes;

	res = read_sysfs_file(sdr->token, SYSFS_SENSOR_FILE, (void **)&tmp,

			      &tot_bytes);

	if ((NULL == tmp) || (FPGA_OK != res)) {

		fprintf(stderr, "Cannot read sensor file.\n");

		if (tmp) {

			free(tmp);

		}

		return FPGA_EXCEPTION;

	}

	if (tot_bytes != (sdr->num_records * sizeof(sensor_reading))) {

		fprintf(stderr,

			"Struct / file size mismatch: file size %d,"

			" struct size %d.\n",

			(int)tot_bytes,

			(int)(sdr->num_records * sizeof(sensor_reading)));

		free(tmp);

		return FPGA_EXCEPTION;

	}

	*num_values = sdr->num_records;

	*values = (bmc_values_handle)calloc(1, sizeof(struct _bmc_values));

	if (NULL == *values) {

		free(tmp);

		return FPGA_NO_MEMORY;

	}

	vals = (struct _bmc_values *)*values;

	vals->contents = tmp;

	vals->magic = BMC_VALUES_MAGIC;

	vals->num_records = sdr->num_records;

	vals->values = (Values **)calloc(sdr->num_records, sizeof(Values *));

	if (NULL == vals->values) {

		return FPGA_NO_MEMORY;

	}

	uint32_t i;

	for (i = 0; i < sdr->num_records; i++) {

		vals->values[i] = bmc_build_values(

			&vals->contents[i], &sdr->contents[i].header,

			&sdr->contents[i].key, &sdr->contents[i].body);

		vals->values[i]->sdr = &sdr->contents[i];

	}

	return res;

}

fpga_result bmcGetSensorReading(bmc_values_handle values,

				uint32_t sensor_number, uint32_t *is_valid,

				double *value)

{

	NULL_CHECK(values);

	NULL_CHECK(value);

	struct _bmc_values *vals = (struct _bmc_values *)values;

	if (BMC_VALUES_MAGIC != vals->magic) {

		return FPGA_INVALID_PARAM;

	}

	if (sensor_number >= vals->num_records) {

		return FPGA_INVALID_PARAM;

	}

	*is_valid = vals->values[sensor_number]->is_valid;

	*value = vals->values[sensor_number]->value.f_val;

	return FPGA_OK;

}

fpga_result bmcThresholdsTripped(bmc_values_handle values,

				 tripped_thresholds **tripped,

				 uint32_t *num_tripped)

{

	fpga_result res = FPGA_OK;

	int num_tripd = 0;

	NULL_CHECK(values);

	NULL_CHECK(num_tripped);

	struct _bmc_values *vals = (struct _bmc_values *)values;

	uint32_t i;

	if (BMC_VALUES_MAGIC != vals->magic) {

		res = FPGA_INVALID_PARAM;

		goto out;

	}

	// Count the number tripped

	for (i = 0; i < vals->num_records; i++) {

		uint8_t indicators = vals->contents[i].threshold_events._value

				     & BMC_THRESHOLD_EVENT_MASK;

		if (0 == indicators) {

			continue;

		}

		num_tripd++;

	}

	*num_tripped = num_tripd;

	if (0 == num_tripd) {

		if (NULL != tripped) {

			*tripped = NULL;

		}

		goto out;

	}

	*tripped = (tripped_thresholds *)calloc(num_tripd,

						sizeof(tripped_thresholds));

	if (NULL == *tripped) {

		return FPGA_NO_MEMORY;

	}

	tripped_thresholds *rets = *tripped;

	int index = 0;

	// Fill in the tripped structures

	for (i = 0; i < vals->num_records; i++) {

		struct _sdr_content *sdr = vals->values[i]->sdr;

		uint8_t indicators = vals->contents[i].threshold_events._value

				     & BMC_THRESHOLD_EVENT_MASK;

		if (0 == indicators) {

			continue;

		}

		rets[index].sensor_number = i;

		rets[index].sensor_type = SDR_SENSOR_IS_POWER(&sdr->body)

			? BMC_POWER : BMC_THERMAL;

		rets[index].which_thresholds = indicators;

		index++;

	}

out:

	return res;

}

fpga_result bmcDestroySDRs(bmc_sdr_handle *records)

{

	fpga_result res = FPGA_OK;

	NULL_CHECK(records);

	struct _sdr_rec *sdr = (struct _sdr_rec *)*records;

	if (BMC_SDR_MAGIC != sdr->magic) {

		res = FPGA_INVALID_PARAM;

		goto out;

	}

	free(sdr->contents);

	sdr->magic = 0;

	free(sdr);

	*records = NULL;

out:

	return res;

}

fpga_result bmcDestroySensorValues(bmc_values_handle *values)

{

	fpga_result res = FPGA_OK;

	NULL_CHECK(values);

	NULL_CHECK(*values);

	struct _bmc_values *vals = (struct _bmc_values *)*values;

	uint32_t i;

	if (BMC_VALUES_MAGIC != vals->magic) {

		res = FPGA_INVALID_PARAM;

		goto out;

	}

	for (i = 0; i < vals->num_records; i++) {

		free(vals->values[i]->name);

		free(vals->values[i]);

	}

	free(vals->contents);

	free(vals->values);

	vals->magic = 0;

	free(vals);

	*values = NULL;

out:

	return res;

}

static void getThresholdValues(sdr_details *details, Values *this_val,

			       struct _sdr_content *sdr)

{

	uint8_t settable =

		(sdr->body.discrete_settable_readable_threshold_mask._value

		 & 0x3f00)

		>> 8;

	details->thresholds.upper_nr_thresh.is_valid = 0;

	details->thresholds.upper_c_thresh.is_valid = 0;

	details->thresholds.upper_nc_thresh.is_valid = 0;

	details->thresholds.lower_nr_thresh.is_valid = 0;

	details->thresholds.lower_c_thresh.is_valid = 0;

	details->thresholds.lower_nc_thresh.is_valid = 0;

	if (!settable) {

		return;

	}

	if (settable & (1 << 5)) {

		details->thresholds.upper_nr_thresh.is_valid = 1;

		details->thresholds.upper_nr_thresh.value =

			getvalue(this_val, sdr->body.upper_nr_threshold);

	}

	if (settable & (1 << 4)) {

		details->thresholds.upper_c_thresh.is_valid = 1;

		details->thresholds.upper_c_thresh.value =

			getvalue(this_val, sdr->body.upper_c_threshold);

	}

	if (settable & (1 << 3)) {

		details->thresholds.upper_nc_thresh.is_valid = 1;

		details->thresholds.upper_nc_thresh.value =

			getvalue(this_val, sdr->body.upper_nc_threshold);

	}

	if (settable & (1 << 2)) {

		details->thresholds.lower_nr_thresh.is_valid = 1;

		details->thresholds.lower_nr_thresh.value =

			getvalue(this_val, sdr->body.lower_nr_threshold);

	}

	if (settable & (1 << 1)) {

		details->thresholds.lower_c_thresh.is_valid = 1;

		details->thresholds.lower_c_thresh.value =

			getvalue(this_val, sdr->body.lower_c_threshold);

	}

	if (settable & (1 << 0)) {

		details->thresholds.lower_nc_thresh.is_valid = 1;

		details->thresholds.lower_nc_thresh.value =

			getvalue(this_val, sdr->body.lower_nc_threshold);

	}

}

fpga_result bmcGetSDRDetails(bmc_values_handle values, uint32_t sensor_number,

			     sdr_details *details)

{

	fpga_result res = FPGA_OK;

	NULL_CHECK(values);

	NULL_CHECK(details);

	struct _bmc_values *vals = (struct _bmc_values *)values;

	Values *this_val = NULL;

	if (BMC_VALUES_MAGIC != vals->magic) {

		res = FPGA_INVALID_PARAM;

		goto out;

	}

	if (sensor_number >= vals->num_records) {

		res = FPGA_INVALID_PARAM;

		goto out;

	}

	this_val = vals->values[sensor_number];

	details->sensor_number = sensor_number;

	details->sensor_type = this_val->sensor_type;

	details->name = this_val->name;

	details->units = this_val->units;

	details->M = this_val->M;

	details->B = this_val->B;

	details->accuracy = this_val->accuracy;

	details->tolerance = this_val->tolerance;

	details->result_exp = this_val->result_exp;

	getThresholdValues(details, this_val, vals->values[sensor_number]->sdr);

out:

	return res;

}

fpga_result bmcDestroyTripped(tripped_thresholds *tripped)

{

	fpga_result res = FPGA_OK;

	NULL_CHECK(tripped);

	free(tripped);

	return res;

}

fpga_result bmcGetFirmwareVersion(fpga_token token, uint32_t *version)

{

	fpga_result res = FPGA_OK;

	NULL_CHECK(token);

	NULL_CHECK(version);

	*version = (uint32_t)-1;

	device_id *tmp = NULL;

	uint32_t tot_bytes;

	res = read_sysfs_file(token, SYSFS_DEVID_FILE, (void **)&tmp,

			      &tot_bytes);

	if (FPGA_OK != res) {

		goto out;

	}

	if (!tmp) {

		res = FPGA_EXCEPTION;

		goto out;

	}

	if (tmp->completion_code != 0) {

		res = FPGA_NOT_FOUND;

		goto out;

	}

	*version = tmp->aux_fw_rev_0_7 | (tmp->aux_fw_rev_8_15 << 8)

		   | (tmp->aux_fw_rev_16_23 << 16)

		   | (tmp->aux_fw_rev_24_31 << 24);

out:

	if (tmp) {

		free(tmp);

	}

	return res;

}

fpga_result bmcGetLastPowerdownCause(fpga_token token, char **cause)

{

	fpga_result res = FPGA_OK;

	NULL_CHECK(token);

	NULL_CHECK(cause);

	*cause = NULL;

	powerdown_cause *tmp = NULL;

	uint32_t tot_bytes;

	res = read_sysfs_file(token, SYSFS_PWRDN_FILE, (void **)&tmp,

			      &tot_bytes);

	if (FPGA_OK != res) {

		goto out;

	}

	if (!tmp) {

		res = FPGA_EXCEPTION;

		goto out;

	}

	if (tmp->completion_code != 0) {

		res = FPGA_NOT_FOUND;

		goto out;

	}

	*cause = strndup((const char *)tmp->message,

		strnlen((const char *)tmp->message, SYSFS_PATH_MAX));

out:

	if (tmp) {

		free(tmp);

	}

	return res;

}

fpga_result bmcGetLastResetCause(fpga_token token, char **cause)

{

	fpga_result res = FPGA_OK;

	NULL_CHECK(token);

	NULL_CHECK(cause);

	*cause = NULL;

	reset_cause *tmp = NULL;

	uint32_t tot_bytes;

	res = read_sysfs_file(token, SYSFS_RESET_FILE, (void **)&tmp,

			      &tot_bytes);

	if (FPGA_OK != res) {

		goto out;

	}

	if (!tmp) {

		res = FPGA_EXCEPTION;

		goto out;

	}

	if (tmp->completion_code != 0) {

		res = FPGA_NOT_FOUND;

		*cause = strndup((const char *)"Unavailable",

			strnlen((const char *)"Unavailable", SYSFS_PATH_MAX));

		goto out;

	}

	if (0 == tmp->reset_cause) {

		*cause = strndup((const char *)"None",

			strnlen((const char *)"None", SYSFS_PATH_MAX));

		goto out;

	}

	if (tmp->reset_cause & CHIP_RESET_CAUSE_EXTRST) {

		*cause = strndup((const char *)"External reset",

			strnlen((const char *)"External reset", SYSFS_PATH_MAX));

		goto out;

	}

	if (tmp->reset_cause & CHIP_RESET_CAUSE_BOD_IO) {

		*cause = strndup((const char *)"Brown-out detected",

			strnlen((const char *)"Brown-out detected", SYSFS_PATH_MAX));

		goto out;

	}

	if (tmp->reset_cause & CHIP_RESET_CAUSE_OCD) {

		*cause = strndup((const char *)"On-chip debug system",

			strnlen((const char *)"On-chip debug system", SYSFS_PATH_MAX));

		goto out;

	}

	if (tmp->reset_cause & CHIP_RESET_CAUSE_POR) {

		*cause = strndup((const char *)"Power-on-reset",

			strnlen((const char *)"Power-on-reset", SYSFS_PATH_MAX));

		goto out;

	}

	if (tmp->reset_cause & CHIP_RESET_CAUSE_SOFT) {

		*cause = strndup((const char *)"Software reset",

			strnlen((const char *)"Software reset", SYSFS_PATH_MAX));

		goto out;

	}

	if (tmp->reset_cause & CHIP_RESET_CAUSE_SPIKE) {

		*cause = strndup((const char *)"Spike detected",

			strnlen((const char *)"Spike detected", SYSFS_PATH_MAX));

		goto out;

	}

	if (tmp->reset_cause & CHIP_RESET_CAUSE_WDT) {

		*cause = strndup((const char *)"Watchdog timeout",

			strnlen((const char *)"Watchdog timeout", SYSFS_PATH_MAX));

		goto out;

	}

	*cause = strndup((const char *)"Unknown",

		strnlen((const char *)"Unknown", SYSFS_PATH_MAX));

out:

	if (tmp) {

		free(tmp);

	}

	return res;

}