/*
 * Firmware trace handling on the DHD side. Kernel thread reads the trace data and writes
 * to the file and implements various utility functions.
 *
 * Broadcom Proprietary and Confidential. Copyright (C) 2020,
 * All Rights Reserved.
 *
 * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom;
 * the contents of this file may not be disclosed to third parties,
 * copied or duplicated in any form, in whole or in part, without
 * the prior written permission of Broadcom.
 *
 *
 * <<Broadcom-WL-IPTag/Proprietary:>>
 *
 * $Id$
 */

#ifdef BCMINTERNAL

#ifdef DHD_FWTRACE

#include <typedefs.h>
#include <osl.h>

#include <bcmutils.h>
#include <bcmendian.h>

#include <dngl_stats.h>
#include <dhd.h>
#include <dhd_proto.h>
#include <dhd_dbg.h>
#include <dhd_debug.h>

#include <dhd_fwtrace.h>

static int fwtrace_write_to_file(uint8 *buf, uint16 buf_len, dhd_pub_t *dhdp);
static int fwtrace_close_file(dhd_pub_t *dhdp);
static int fwtrace_open_file(uint32 fw_trace_enabled, dhd_pub_t *dhdp);
static fwtrace_buf_t *fwtrace_get_trace_data_ptr(dhd_pub_t *dhdp);
static void fwtrace_free_trace_buf(dhd_pub_t *dhdp);

typedef struct fwtrace_info {
	struct file *fw_trace_fp;
	int file_index;
	int part_index;
	int trace_buf_index;
	int trace_buf_count;
	uint16 overflow_counter;

	char trace_file[TRACE_FILE_NAME_LEN];

	fwtrace_buf_t *trace_data_ptr;

	uint16 prev_seq;

	uint32 fwtrace_enable;		/* Enable firmware tracing and the
					 * trace file management.
					 */
	struct mutex fwtrace_lock;	/* Synchronization between the
					 * ioctl and the kernel thread.
					 */
	dhd_dma_buf_t fwtrace_buf;	/* firmware trace buffer */
} fwtrace_info_t;

int
dhd_fwtrace_attach(dhd_pub_t *dhdp)
{
	fwtrace_info_t *fwtrace_info;

	/* Allocate prot structure */
	if (!(fwtrace_info = (fwtrace_info_t *)VMALLOCZ(dhdp->osh, sizeof(*fwtrace_info)))) {
		DHD_ERROR(("%s: kmalloc failed\n", __FUNCTION__));
		return (BCME_NOMEM);
	}

	bzero(fwtrace_info, sizeof(*fwtrace_info));
	dhdp->fwtrace_info = fwtrace_info;

	mutex_init(&dhdp->fwtrace_info->fwtrace_lock);

	DHD_INFO(("allocated DHD fwtrace\n"));

	return BCME_OK;
}

int
dhd_fwtrace_detach(dhd_pub_t *dhdp)
{
	fwtrace_info_t *fwtrace_info;

	DHD_TRACE(("%s: %d\n", __FUNCTION__, __LINE__));

	if (!dhdp) {
		return BCME_OK;
	}

	if (!dhdp->fwtrace_info) {
		return BCME_OK;
	}

	fwtrace_info = dhdp->fwtrace_info;

	dhd_dma_buf_free(dhdp, &dhdp->fwtrace_info->fwtrace_buf);

	/* close the file if valid */
	if (!(IS_ERR_OR_NULL(dhdp->fwtrace_info->fw_trace_fp))) {
		(void) filp_close(dhdp->fwtrace_info->fw_trace_fp, 0);
	}

	mutex_destroy(&dhdp->fwtrace_info->fwtrace_lock);

	VMFREE(dhdp->osh, fwtrace_info, sizeof(*fwtrace_info));

	dhdp->fwtrace_info = NULL;

	DHD_INFO(("Deallocated DHD fwtrace_info\n"));

	return (BCME_OK);
}

uint16
get_fw_trace_overflow_counter(dhd_pub_t *dhdp)
{
	return (dhdp->fwtrace_info->overflow_counter);
}

void
process_fw_trace_data(dhd_pub_t *dhdp)
{
	fwtrace_info_t *fwtrace_info = dhdp->fwtrace_info;
	uint16 length;
	uint16 incoming_seq;
	uint32 trace_buf_index = fwtrace_info->trace_buf_index;
	fwtrace_buf_t * trace_buf;
	fwtrace_buf_t * curr_buf;

	mutex_lock(&fwtrace_info->fwtrace_lock);

	if (fwtrace_info->fw_trace_fp == NULL) {
		goto done;
	}

	if ((trace_buf = fwtrace_get_trace_data_ptr(dhdp)) == NULL) {
		goto done;
	}

	do {
		curr_buf = trace_buf + trace_buf_index;

		length = curr_buf->info.length;
		/* If the incoming length is 0, means nothing is updated by the firmware */
		if (length == 0) {
			break;
		}

		incoming_seq = curr_buf->info.seq_num;

		if (((uint16)(fwtrace_info->prev_seq + 1) != incoming_seq) &&
			length != sizeof(*curr_buf)) {
			DHD_ERROR(("*** invalid trace len idx = %u, length = %u, "
				"cur seq = %u, in-seq = %u \n",
				trace_buf_index, length,
				fwtrace_info->prev_seq, incoming_seq));
			break;
		}

		DHD_TRACE(("*** TRACE BUS: IDX:%d, in-seq:%d(prev-%d), ptr:%p(%llu), len:%d\n",
				trace_buf_index, incoming_seq, fwtrace_info->prev_seq,
				curr_buf, (uint64)curr_buf, length));

		/* Write trace data to a file */
		if (fwtrace_write_to_file((uint8 *) curr_buf, length, dhdp) != BCME_OK) {
			DHD_ERROR(("*** fwtrace_write_to_file has failed \n"));
			break;
		}

		/* Reset length after consuming the fwtrace data */
		curr_buf->info.length = 0;

		if ((fwtrace_info->prev_seq + 1) != incoming_seq) {
			DHD_ERROR(("*** seq mismatch, index = %u, length = %u, "
				"cur seq = %u, in-seq = %u \n",
				trace_buf_index, length,
				fwtrace_info->prev_seq, incoming_seq));
		}
		fwtrace_info->prev_seq = incoming_seq;

		trace_buf_index++;
		trace_buf_index &= (fwtrace_info->trace_buf_count - 1u);
		fwtrace_info->trace_buf_index = trace_buf_index;
	} while (true);

done:
	mutex_unlock(&fwtrace_info->fwtrace_lock);
	return;
}

/*
 * Write the incoming trace data to a file. The maximum file size is 1MB. After that
 * the trace data is saved into a new file.
 */
static int
fwtrace_write_to_file(uint8 *buf, uint16 buf_len, dhd_pub_t *dhdp)
{
	fwtrace_info_t *fwtrace_info = dhdp->fwtrace_info;
	int ret_val = BCME_OK;
	int ret_val_1 = 0;
	mm_segment_t old_fs;
	loff_t pos = 0;
	struct kstat stat;
	int error;

	/* Change to KERNEL_DS address limit */
	old_fs = get_fs();
	set_fs(KERNEL_DS);

	if (buf == NULL) {
		ret_val = BCME_ERROR;
		goto done;
	}

	if (IS_ERR_OR_NULL(fwtrace_info->fw_trace_fp)) {
		ret_val = BCME_ERROR;
		goto done;
	}

	//
	// Get the file size
	// if the size + buf_len > TRACE_FILE_SIZE, then write to a different file.
	//
	error = vfs_stat(fwtrace_info->trace_file, &stat);
	if (error) {
		DHD_ERROR(("vfs_stat has failed with error code = %d\n", error));
		goto done;
	}

	if ((int) stat.size + buf_len > TRACE_FILE_SIZE) {
		fwtrace_close_file(dhdp);
		(fwtrace_info->part_index)++;
		fwtrace_open_file(TRUE, dhdp);
	}

	pos = fwtrace_info->fw_trace_fp->f_pos;
	/* Write buf to file */
	ret_val_1 = vfs_write(fwtrace_info->fw_trace_fp,
	                      (char *) buf, (uint32) buf_len, &pos);
	if (ret_val_1 < 0) {
		DHD_ERROR(("write file error, err = %d\n", ret_val_1));
		ret_val = BCME_ERROR;
		goto done;
	}
	fwtrace_info->fw_trace_fp->f_pos = pos;

	/* Sync file from filesystem to physical media */
	ret_val_1 = vfs_fsync(fwtrace_info->fw_trace_fp, 0);
	if (ret_val_1 < 0) {
		DHD_ERROR(("sync file error, error = %d\n", ret_val_1));
		ret_val = BCME_ERROR;
		goto done;
	}

done:
	/* restore previous address limit */
	set_fs(old_fs);
	return (ret_val);
}

/*
 * Start the trace, gets called from the ioctl handler.
 */
int
fw_trace_start(dhd_pub_t *dhdp, uint32 fw_trace_enabled)
{
	int ret_val = BCME_OK;

	(dhdp->fwtrace_info->file_index)++;
	dhdp->fwtrace_info->part_index = 1;

	dhdp->fwtrace_info->trace_buf_index = 0;

	mutex_lock(&dhdp->fwtrace_info->fwtrace_lock);
	ret_val = fwtrace_open_file(fw_trace_enabled, dhdp);
	if (ret_val == BCME_OK) {
		dhdp->fwtrace_info->fwtrace_enable = fw_trace_enabled;
	}
	mutex_unlock(&dhdp->fwtrace_info->fwtrace_lock);

	return (ret_val);
}

/*
 * Stop the trace collection and close the file descriptor.
 */
int
fw_trace_stop(dhd_pub_t *dhdp)
{
	int ret_val = BCME_OK;

	/* Check to see if there is any trace data */
	process_fw_trace_data(dhdp);

	mutex_lock(&dhdp->fwtrace_info->fwtrace_lock); /* acquire lock */
	/* flush the trace buffer */
	ret_val = fwtrace_close_file(dhdp);

	/* free the trace buffer */
	fwtrace_free_trace_buf(dhdp);
	mutex_unlock(&dhdp->fwtrace_info->fwtrace_lock); /* release the lock */

	return (ret_val);
}

/*
 * The trace file format is: fw_trace_w_part_x_y_z
 *     where w is the file index, x is the part index,
 *	     y is in seconds and z is in milliseconds
 *
 *     fw_trace_1_part_1_1539298163209110
 *     fw_trace_1_part_2_1539298194739003  etc.
 *
 */
static int
fwtrace_open_file(uint32 fw_trace_enabled, dhd_pub_t *dhdp)
{
	fwtrace_info_t *fwtrace_info = dhdp->fwtrace_info;
	int ret_val = BCME_OK;
	uint32 file_mode;
	char ts_str[DEBUG_DUMP_TIME_BUF_LEN];

	if (fw_trace_enabled) {
		if (!(IS_ERR_OR_NULL(fwtrace_info->fw_trace_fp))) {
			(void) filp_close(fwtrace_info->fw_trace_fp, 0);
		}

		DHD_INFO((" *** Creating the trace file \n"));

		file_mode = O_CREAT | O_WRONLY | O_SYNC;
		clear_debug_dump_time(ts_str);
		get_debug_dump_time(ts_str);

		snprintf(fwtrace_info->trace_file,
		         sizeof(fwtrace_info->trace_file),
		         "%sfw_trace_%d_part_%d_%x_%s",
		         DHD_COMMON_DUMP_PATH, fwtrace_info->file_index,
		         fwtrace_info->part_index,
		         dhd_bus_get_bp_base(dhdp),
		         ts_str);

		fwtrace_info->fw_trace_fp =
		        filp_open(fwtrace_info->trace_file, file_mode, 0664);

		if (IS_ERR(fwtrace_info->fw_trace_fp)) {
			DHD_ERROR(("Unable to create the fw trace file file: %s\n",
			           fwtrace_info->trace_file));
			ret_val = BCME_ERROR;
			goto done;
		}
	}

done:
	return (ret_val);
}

static int
fwtrace_close_file(dhd_pub_t *dhdp)
{
	int ret_val = BCME_OK;

	if (!(IS_ERR_OR_NULL(dhdp->fwtrace_info->fw_trace_fp))) {
		(void) filp_close(dhdp->fwtrace_info->fw_trace_fp, 0);
	}

	dhdp->fwtrace_info->fw_trace_fp = NULL;

	return (ret_val);
}

#define FWTRACE_HADDR_PARAMS_SIZE	256u
#define FW_TRACE_FLUSH			0x8u /* bit 3 */

static int send_fw_trace_val(dhd_pub_t *dhdp, int val);

/*
 * Initialize FWTRACE.
 * Allocate trace buffer and open trace file.
 */
int
fwtrace_init(dhd_pub_t *dhdp)
{
	int ret_val = BCME_OK;
	fwtrace_hostaddr_info_t host_buf_info;

	if (dhdp->fwtrace_info->fwtrace_buf.va != NULL) {
		/* Already initialized */
		goto done;
	}

	ret_val = fwtrace_get_haddr(dhdp, &host_buf_info);

	if (ret_val != BCME_OK) {
		goto done;
	}

	DHD_INFO(("dhd_get_trace_haddr: addr = %llx, len = %u\n",
		host_buf_info.haddr.u64, host_buf_info.num_bufs));

	/* Initialize and setup the file */
	ret_val = fw_trace_start(dhdp, TRUE);

done:
	return ret_val;
}

/*
 * Process the fwtrace set command to enable/disable firmware tracing.
 * Always, enable preceeds with disable.
 */
int
handle_set_fwtrace(dhd_pub_t *dhdp, uint32 val)
{
	int ret, ret_val = BCME_OK;

	/* On set, consider only lower two bytes for now */
	dhdp->fwtrace_info->fwtrace_enable = (val & 0xFFFF);

	if (val & FW_TRACE_FLUSH) { /* only flush the trace buffer */
		if ((ret_val = send_fw_trace_val(dhdp, val)) != BCME_OK) {
			goto done;
		}
	} else if (val == 0) { /* disable the tracing */
		/* Disable the trace in the firmware */
		if ((ret_val = send_fw_trace_val(dhdp, val)) != BCME_OK) {
			goto done;
		}

		/* cleanup in the driver */
		fw_trace_stop(dhdp);
	} else {		/* enable the tracing */
		fwtrace_hostaddr_info_t haddr_info;

		ret_val = fwtrace_init(dhdp);
		if (ret_val != BCME_OK) {
			goto done;
		}

		if ((ret_val = fwtrace_get_haddr(dhdp, &haddr_info)) != BCME_OK) {
			DHD_ERROR(("%s: set dhd_iovar has failed for "
				"fw_trace_haddr, "
				"ret=%d\n", __FUNCTION__, ret_val));
			goto done;
		}

		ret = dhd_iovar(dhdp, 0, "dngl:fwtrace_haddr",
		                (char *) &haddr_info, sizeof(haddr_info),
		                NULL, 0, TRUE);
		if (ret < 0) {
			DHD_ERROR(("%s: set dhd_iovar has failed for "
			           "fwtrace_haddr, "
			           "ret=%d\n", __FUNCTION__, ret));
			ret_val = BCME_NOMEM;
			goto done;
		}

		/* Finaly, enable the trace in the firmware */
		if ((ret_val = send_fw_trace_val(dhdp, val)) != BCME_OK) {
			goto done;
		}
	}
done:
	return (ret_val);
}

/*
 * Send dngl:fwtrace IOVAR to the firmware.
 */

static int
send_fw_trace_val(dhd_pub_t *dhdp, int val)
{
	int ret_val = BCME_OK;

	if ((ret_val = dhd_iovar(dhdp, 0, "dngl:fwtrace", (char *)&val, sizeof(val),
	                         NULL, 0, TRUE)) < 0) {
		DHD_ERROR(("%s: set dhd_iovar has failed fwtrace, "
		           "ret=%d\n", __FUNCTION__, ret_val));
	}

	return (ret_val);
}

/*
 * Returns the virual address for the firmware trace buffer.
 * DHD monitors this buffer for an update from the firmware.
 */
static fwtrace_buf_t *
fwtrace_get_trace_data_ptr(dhd_pub_t *dhdp)
{
	return ((fwtrace_buf_t *) dhdp->fwtrace_info->fwtrace_buf.va);
}

int
fwtrace_get_haddr(dhd_pub_t *dhdp,  fwtrace_hostaddr_info_t *haddr_info)
{
	int ret_val = BCME_NOMEM;
	int num_host_buffers = FWTRACE_NUM_HOST_BUFFERS;

	if (haddr_info == NULL) {
		ret_val = BCME_BADARG;
		goto done;
	}

	if (dhdp->fwtrace_info->fwtrace_buf.va != NULL) {
		/* Use the existing buffer and send to the firmware */
		haddr_info->haddr.u64 = HTOL64(*(uint64 *)
			&dhdp->fwtrace_info->fwtrace_buf.pa);
		haddr_info->num_bufs = dhdp->fwtrace_info->trace_buf_count;
		haddr_info->buf_len = sizeof(fwtrace_buf_t);
		ret_val = BCME_OK;
		goto done;
	}

	do {
		/* Initialize firmware trace buffer */
		if (dhd_dma_buf_alloc(dhdp, &dhdp->fwtrace_info->fwtrace_buf,
			sizeof(fwtrace_buf_t) * num_host_buffers) == BCME_OK) {
			dhdp->fwtrace_info->trace_buf_count = num_host_buffers;
			ret_val = BCME_OK;
			break;
		}

		DHD_ERROR(("%s: Allocing %d buffers of size %lu bytes failed\n",
			__FUNCTION__, num_host_buffers,
			sizeof(fwtrace_buf_t) * num_host_buffers));

		/* Retry with smaller numbers */
		num_host_buffers >>= 1;
	} while (num_host_buffers > 0);

	haddr_info->haddr.u64 = HTOL64(*(uint64 *)&dhdp->fwtrace_info->fwtrace_buf.pa);
	haddr_info->num_bufs = num_host_buffers;
	haddr_info->buf_len = sizeof(fwtrace_buf_t);

	DHD_INFO(("Firmware trace buffer, host address = %llx, count = %u \n",
	          haddr_info->haddr.u64,
	          haddr_info->num_bufs));
done:
	return (ret_val);
}

/*
 * Frees the host buffer.
 */
static void
fwtrace_free_trace_buf(dhd_pub_t *dhdp)
{
	dhd_dma_buf_free(dhdp, &dhdp->fwtrace_info->fwtrace_buf);
	return;
}

#endif	/* DHD_FWTRACE */

#endif /* BCMINTERNAL */