drivers/vision/npu/npu-fw-test-handler.c - LeafOS-Devices/android_kernel_samsung_exynos9820 - Gitiles


 #include <linux/wait.h>
 #include <linux/slab.h>
 #include <linux/limits.h>
 #include <linux/device.h>
 #include <asm/cacheflush.h>

 #include "npu-vs4l.h"
 #include "npu-log.h"
 #include "npu-common.h"
 #include "npu-session.h"
 #include "npu-qos.h"
 #include "npu-util-statekeeper.h"
 #include "npu-binary.h"
 #include "npu-errno.h"

 /* State management */
 typedef enum {
 	FW_TEST_STATE_UNLOADED = 0,
 	FW_TEST_STATE_LOADED,
 	FW_TEST_STATE_EXECUTING,
 	FW_TEST_STATE_INVALID,
 } fw_test_state_e;

 const char *FW_TEST_STATE_NAME[FW_TEST_STATE_INVALID + 1]
 	= {"UNLOADED", "LOADED", "EXECUTING", "INVALID"};

 static const u8 fw_test_state_transition[][STATE_KEEPER_MAX_STATE] = {
 	/* From    -   To       UNLOADED        LOADED          EXECUTING       INVALID*/
 	/* UNLOADED     */ {    0,              1,              0,              0},
 	/* LOADED       */ {    1,              1,              1,              0},
 	/* EXECUTING    */ {    0,              1,              0,              0},
 	/* INVALID      */ {    0,              0,              0,              0},
 };

 /* Reference to manage object */
 static struct npu_fw_test_handler *ft_handle;

 static struct device *get_dev_from_session(struct npu_session *sess)
 {
 	struct npu_vertex_ctx	*ctx;
 	struct npu_vertex	*vertex;
 	struct npu_device	*device;
 	struct device		*dev;

 	BUG_ON(!sess);
 	ctx = &sess->vctx;
 	BUG_ON(!ctx);
 	vertex = ctx->vertex;
 	BUG_ON(!vertex);
 	device = container_of(vertex, struct npu_device, vertex);
 	BUG_ON(!device);
 	dev = device->dev;
 	BUG_ON(!dev);
 	return dev;
 }

 __attribute__((unused)) static int load_fw_utc_vector(struct npu_session *sess, struct vs4l_param *param)
 {
 	struct device			*dev;
 	char				*vector_path;
 	size_t				vector_len = 0;
 	int				ret;
 	struct npu_binary		vector_binary;
 	struct npu_memory_buffer	*dram_buf;
 	u8				*p8;

 	BUG_ON(!ft_handle);
 	BUG_ON(!sess);
 	dev = get_dev_from_session(sess);

 	dram_buf = ft_handle->dram_fw_log_buf;

 	npu_trace("%s() started.\n", __func__);

 	if (!SKEEPER_IS_TRANSITABLE(&ft_handle->sk, FW_TEST_STATE_LOADED))
 		return -EINVAL;

 	vector_path = kzalloc(PATH_MAX, GFP_KERNEL);
 	if (!vector_path) {
 		ret = -ENOMEM;
 		goto err_exit;
 	}

 	/* Retreve vector filename from parameter */
 	if (param->size <= 0 || param->size >= PATH_MAX) {
 		npu_err("Invalid size specified : %u\n", param->size);
 		ret = -EINVAL;
 		goto err_exit;
 	}
 	if (!param->addr) {
 		npu_err("Invalid addr specified : %lu\n", param->addr);
 		ret = -EINVAL;
 		goto err_exit;
 	}
 	ret = copy_from_user(vector_path, (__user void *)param->addr, param->size);
 	if (ret) {
 		npu_err("copy_from_user failed(%d)\n", ret);
 		ret = -EFAULT;
 		goto err_exit;
 	}
 	vector_path[param->size] = '\0';
 	npu_dbg("Loading FW test vector from : %s\n", vector_path);

 	/* Check file's integrity */
 	ret = npu_binary_init(&vector_binary, dev, vector_path, "\0", "\0");
 	if (ret) {
 		npu_err("npu_binary_init() failed : %d\n", ret);
 		ret = -EINVAL;
 		goto err_exit;
 	}
 	ret = npu_binary_g_size(&vector_binary, &vector_len);
 	if (ret) {
 		npu_err("npu_binary_g_size() failed : %d\n", ret);
 		ret = -EINVAL;
 		goto err_exit;
 	}
 	if (vector_len <= 0) {
 		npu_err("Vector file[%s] is not found or invalid.\n", vector_path);
 		ret = -EINVAL;
 		goto err_exit;
 	}
 	if (vector_len >= dram_buf->size) {
 		npu_err("Vector file[%s] is too large(%zuB). Maximum DRAM buf is %zuB\n",
 			vector_path, vector_len, dram_buf->size);
 		ret = -EINVAL;
 		goto err_exit;
 	}
 	/* Disable store log, because it shares same DRAM buffer */
 	npu_store_log_deinit();
 	npu_info("Store log is disabled, until next resume.\n");

 	/* Load file contents to memory */
 	npu_info("Loading FW test vector[%s] to vaddr[%pK], len = %zuB\n",
 		vector_path, dram_buf->vaddr, vector_len);
 	if (!dram_buf->vaddr) {
 		npu_err("DRAM buffer is not initialized.\n");
 		ret = -EFAULT;
 		goto err_exit;
 	}
 	ret = npu_binary_read(&vector_binary, dram_buf->vaddr, vector_len);
 	if (ret) {
 		npu_err("npu_binary_read([%s], %pK, %zu) failed : %d\n",
 			vector_path, dram_buf->vaddr, vector_len, ret);
 		ret = -EFAULT;
 		goto err_exit;
 	}

 	/* Printout signature */
 	if (vector_len > 4) {
 		p8 = (u8 *)dram_buf->vaddr;
 		npu_info("FW test vector HEAD=[%02x %02x %02x %02x], TAIL=[%02x %02x %02x %02x]\n",
 			p8[0], p8[1], p8[2], p8[3],
 			p8[vector_len - 1], p8[vector_len - 2],
 			p8[vector_len - 3], p8[vector_len - 4]);
 	} else {
 		npu_warn("FW vector is too short. Signature is not available.\n");
 	}

 	/* Cache invalidation */
 	__dma_map_area(dram_buf->vaddr, vector_len, DMA_TO_DEVICE);

 	/* Transition state */
 	npu_statekeeper_transition(&ft_handle->sk, FW_TEST_STATE_LOADED);

 	ret = 0;

 err_exit:
 	if (vector_path)
 		kfree(vector_path);

 	npu_trace("%s() completed. ret = %d\n", __func__, ret);
 	return ret;
 }

 static int fw_utc_save_result_cb(struct npu_session *sess, struct nw_result result)
 {
 	ft_handle->result = result;
 	atomic_set(&ft_handle->wait_flag, 1);
 	npu_info("FW test result received : [%u]\n", result.result_code);

 	if (sess != ft_handle->cur_sess) {
 		npu_warn("Session mismatch [%pK] / [%pK]. Something wrong.\n",
 			sess, ft_handle->cur_sess);
 	} else {
 		/* Wake-up user thread */
 		wake_up_all(&ft_handle->wq);
 	}

 	return 0;
 }

 static int execute_fw_utc_vector(struct npu_session *sess, struct vs4l_param *param)
 {
 	int				ret = 0;
 	struct npu_nw			nw;
 	int				test_result = 0;
 	struct npu_system		*system;

 	npu_trace("%s() started.\n", __func__);
 	BUG_ON(!ft_handle);

 	if (!SKEEPER_IS_TRANSITABLE(&ft_handle->sk, FW_TEST_STATE_EXECUTING))
 		return -EINVAL;

 	npu_statekeeper_transition(&ft_handle->sk, FW_TEST_STATE_EXECUTING);

 	/* Setting QoS to make the NPU at operation clock */
 	system = container_of(ft_handle, struct npu_system, npu_fw_test_handler);
 	BUG_ON(!system);
 	ret = npu_qos_start(system);
 	if (ret) {
 		npu_uerr("npu_qos_start failed : (%d)\n", sess, ret);
 		test_result = NPU_ERR_DRIVER(NPU_ERR_INVALID_STATE);
 		goto err_exit;
 	}

 	/* Prepare npu_nw message */
 	/* TODO: It is good to have common initialzier for npu_nw */
 	memset(&nw, 0, sizeof(nw));
 	nw.uid = sess->uid;
 	nw.session = sess;
 	nw.cmd = NPU_NW_CMD_FW_TC_EXECUTE;
 	nw.param0 = param->offset;
 	nw.magic_tail = NPU_NW_MAGIC_TAIL;

 	npu_uinfo("Executing FW test #%u\n", sess, nw.param0);

 	/* Setting callback */
 	nw.notify_func = fw_utc_save_result_cb;
 	ft_handle->cur_sess = sess;	/* For sanity check */

 	/* Post message and wait until the callback is invoked */
 	atomic_set(&ft_handle->wait_flag, 0);
 	ret = npu_ncp_mgmt_put(&nw);
 	if (!ret) {
 		npu_uerr("npu_ncp_mgmt_put failed : (%d)\n", sess, ret);
 		test_result = NPU_ERR_DRIVER(NPU_ERR_INVALID_STATE);
 		goto qos_off;
 	}

 	/* Collect result */
 	ret = wait_event_timeout(
 		ft_handle->wq,
 		atomic_read(&ft_handle->wait_flag) > 0,
 		FW_TC_EXEC_TIMEOUT);

 	/* Construct return value */
 	if (ret == 0) {
 		/* Timeout and result is not available */
 		npu_uerr("Test timeout\n", sess);
 		test_result = NPU_ERR_DRIVER(FW_TC_RESULT_TIMEOUT);
 	} else {
 		npu_uinfo("Test finished with code [%u]\n", sess, ft_handle->result.result_code);
 		/* Set result value */
 		test_result = ft_handle->result.result_code;
 	}

 qos_off:
 	ret = npu_qos_stop(system);
 	if (ret) {
 		npu_uerr("npu_qos_stop failed : (%d)\n", sess, ret);
 		test_result = NPU_ERR_DRIVER(NPU_ERR_INVALID_STATE);
 		goto err_exit;
 	}

 err_exit:
 	ft_handle->cur_sess = NULL;
 	npu_statekeeper_transition(&ft_handle->sk, FW_TEST_STATE_LOADED);
 	npu_trace("%s() completed with result [%d].\n", __func__, test_result);
 	return test_result;
 }

 int npu_fw_test_initialize(struct npu_system *system, struct npu_memory_buffer *dram_fw_log_buf)
 {
 	BUG_ON(!system);
 	BUG_ON(!dram_fw_log_buf);
 	BUG_ON(!dram_fw_log_buf->vaddr);

 	ft_handle = &(system->npu_fw_test_handler);
 	memset(ft_handle, 0, sizeof(*ft_handle));

 	/* Initialize state keeper */
 	npu_statekeeper_initialize(
 		&ft_handle->sk, FW_TEST_STATE_INVALID,
 		FW_TEST_STATE_NAME, fw_test_state_transition);

 	/* Keep reference to device and DRAM buffer */
 	ft_handle->dev = &(system->pdev->dev);
 	ft_handle->dram_fw_log_buf = dram_fw_log_buf;

 	/* Initialize wait q */
 	init_waitqueue_head(&ft_handle->wq);

 	npu_info("fw_test : initialized.\n");
 	return 0;
 }

 npu_s_param_ret fw_test_s_param_handler(struct npu_session *sess, struct vs4l_param *param, int *retval)
 {
 	int		ret;

 	BUG_ON(!sess);
 	BUG_ON(!param);

 	switch (param->target) {
 	case NPU_S_PARAM_FW_UTC_LOAD:
 #ifdef CONFIG_EXYNOS_NPU_DRAM_FW_LOG_BUF
 		ret = load_fw_utc_vector(sess, param);
 		return S_PARAM_HANDLED;
 #else
 		npu_err("Firmware UTC support requires CONFIG_EXYNOS_NPU_DRAM_FW_LOG_BUF option.\n");
 		return S_PARAM_ERROR;
 #endif

 	case NPU_S_PARAM_FW_UTC_EXECUTE:
 		ret = execute_fw_utc_vector(sess, param);
 		return S_PARAM_HANDLED;

 	default:
 		/* Unknown set param command -> Pass to next handler */
 		return S_PARAM_NOMB;
 	}
 }

	#include <linux/wait.h>
	#include <linux/slab.h>
	#include <linux/limits.h>
	#include <linux/device.h>
	#include <asm/cacheflush.h>

	#include "npu-vs4l.h"
	#include "npu-log.h"
	#include "npu-common.h"
	#include "npu-session.h"
	#include "npu-qos.h"
	#include "npu-util-statekeeper.h"
	#include "npu-binary.h"
	#include "npu-errno.h"

	/* State management */
	typedef enum {
	FW_TEST_STATE_UNLOADED = 0,
	FW_TEST_STATE_LOADED,
	FW_TEST_STATE_EXECUTING,
	FW_TEST_STATE_INVALID,
	} fw_test_state_e;

	const char *FW_TEST_STATE_NAME[FW_TEST_STATE_INVALID + 1]
	= {"UNLOADED", "LOADED", "EXECUTING", "INVALID"};

	static const u8 fw_test_state_transition[][STATE_KEEPER_MAX_STATE] = {
	/* From - To UNLOADED LOADED EXECUTING INVALID*/
	/* UNLOADED */ { 0, 1, 0, 0},
	/* LOADED */ { 1, 1, 1, 0},
	/* EXECUTING */ { 0, 1, 0, 0},
	/* INVALID */ { 0, 0, 0, 0},
	};

	/* Reference to manage object */
	static struct npu_fw_test_handler *ft_handle;

	static struct device get_dev_from_session(struct npu_session sess)
	{
	struct npu_vertex_ctx *ctx;
	struct npu_vertex *vertex;
	struct npu_device *device;
	struct device *dev;

	BUG_ON(!sess);
	ctx = &sess->vctx;
	BUG_ON(!ctx);
	vertex = ctx->vertex;
	BUG_ON(!vertex);
	device = container_of(vertex, struct npu_device, vertex);
	BUG_ON(!device);
	dev = device->dev;
	BUG_ON(!dev);
	return dev;
	}

	__attribute__((unused)) static int load_fw_utc_vector(struct npu_session sess, struct vs4l_param param)
	{
	struct device *dev;
	char *vector_path;
	size_t vector_len = 0;
	int ret;
	struct npu_binary vector_binary;
	struct npu_memory_buffer *dram_buf;
	u8 *p8;

	BUG_ON(!ft_handle);
	BUG_ON(!sess);
	dev = get_dev_from_session(sess);

	dram_buf = ft_handle->dram_fw_log_buf;

	npu_trace("%s() started.\n", __func__);

	if (!SKEEPER_IS_TRANSITABLE(&ft_handle->sk, FW_TEST_STATE_LOADED))
	return -EINVAL;

	vector_path = kzalloc(PATH_MAX, GFP_KERNEL);
	if (!vector_path) {
	ret = -ENOMEM;
	goto err_exit;
	}

	/* Retreve vector filename from parameter */
	if (param->size <= 0 \|\| param->size >= PATH_MAX) {
	npu_err("Invalid size specified : %u\n", param->size);
	ret = -EINVAL;
	goto err_exit;
	}
	if (!param->addr) {
	npu_err("Invalid addr specified : %lu\n", param->addr);
	ret = -EINVAL;
	goto err_exit;
	}
	ret = copy_from_user(vector_path, (__user void *)param->addr, param->size);
	if (ret) {
	npu_err("copy_from_user failed(%d)\n", ret);
	ret = -EFAULT;
	goto err_exit;
	}
	vector_path[param->size] = '\0';
	npu_dbg("Loading FW test vector from : %s\n", vector_path);

	/* Check file's integrity */
	ret = npu_binary_init(&vector_binary, dev, vector_path, "\0", "\0");
	if (ret) {
	npu_err("npu_binary_init() failed : %d\n", ret);
	ret = -EINVAL;
	goto err_exit;
	}
	ret = npu_binary_g_size(&vector_binary, &vector_len);
	if (ret) {
	npu_err("npu_binary_g_size() failed : %d\n", ret);
	ret = -EINVAL;
	goto err_exit;
	}
	if (vector_len <= 0) {
	npu_err("Vector file[%s] is not found or invalid.\n", vector_path);
	ret = -EINVAL;
	goto err_exit;
	}
	if (vector_len >= dram_buf->size) {
	npu_err("Vector file[%s] is too large(%zuB). Maximum DRAM buf is %zuB\n",
	vector_path, vector_len, dram_buf->size);
	ret = -EINVAL;
	goto err_exit;
	}
	/* Disable store log, because it shares same DRAM buffer */
	npu_store_log_deinit();
	npu_info("Store log is disabled, until next resume.\n");

	/* Load file contents to memory */
	npu_info("Loading FW test vector[%s] to vaddr[%pK], len = %zuB\n",
	vector_path, dram_buf->vaddr, vector_len);
	if (!dram_buf->vaddr) {
	npu_err("DRAM buffer is not initialized.\n");
	ret = -EFAULT;
	goto err_exit;
	}
	ret = npu_binary_read(&vector_binary, dram_buf->vaddr, vector_len);
	if (ret) {
	npu_err("npu_binary_read([%s], %pK, %zu) failed : %d\n",
	vector_path, dram_buf->vaddr, vector_len, ret);
	ret = -EFAULT;
	goto err_exit;
	}

	/* Printout signature */
	if (vector_len > 4) {
	p8 = (u8 *)dram_buf->vaddr;
	npu_info("FW test vector HEAD=[%02x %02x %02x %02x], TAIL=[%02x %02x %02x %02x]\n",
	p8[0], p8[1], p8[2], p8[3],
	p8[vector_len - 1], p8[vector_len - 2],
	p8[vector_len - 3], p8[vector_len - 4]);
	} else {
	npu_warn("FW vector is too short. Signature is not available.\n");
	}

	/* Cache invalidation */
	__dma_map_area(dram_buf->vaddr, vector_len, DMA_TO_DEVICE);

	/* Transition state */
	npu_statekeeper_transition(&ft_handle->sk, FW_TEST_STATE_LOADED);

	ret = 0;

	err_exit:
	if (vector_path)
	kfree(vector_path);

	npu_trace("%s() completed. ret = %d\n", __func__, ret);
	return ret;
	}

	static int fw_utc_save_result_cb(struct npu_session *sess, struct nw_result result)
	{
	ft_handle->result = result;
	atomic_set(&ft_handle->wait_flag, 1);
	npu_info("FW test result received : [%u]\n", result.result_code);

	if (sess != ft_handle->cur_sess) {
	npu_warn("Session mismatch [%pK] / [%pK]. Something wrong.\n",
	sess, ft_handle->cur_sess);
	} else {
	/* Wake-up user thread */
	wake_up_all(&ft_handle->wq);
	}

	return 0;
	}

	static int execute_fw_utc_vector(struct npu_session sess, struct vs4l_param param)
	{
	int ret = 0;
	struct npu_nw nw;
	int test_result = 0;
	struct npu_system *system;

	npu_trace("%s() started.\n", __func__);
	BUG_ON(!ft_handle);

	if (!SKEEPER_IS_TRANSITABLE(&ft_handle->sk, FW_TEST_STATE_EXECUTING))
	return -EINVAL;

	npu_statekeeper_transition(&ft_handle->sk, FW_TEST_STATE_EXECUTING);

	/* Setting QoS to make the NPU at operation clock */
	system = container_of(ft_handle, struct npu_system, npu_fw_test_handler);
	BUG_ON(!system);
	ret = npu_qos_start(system);
	if (ret) {
	npu_uerr("npu_qos_start failed : (%d)\n", sess, ret);
	test_result = NPU_ERR_DRIVER(NPU_ERR_INVALID_STATE);
	goto err_exit;
	}

	/* Prepare npu_nw message */
	/* TODO: It is good to have common initialzier for npu_nw */
	memset(&nw, 0, sizeof(nw));
	nw.uid = sess->uid;
	nw.session = sess;
	nw.cmd = NPU_NW_CMD_FW_TC_EXECUTE;
	nw.param0 = param->offset;
	nw.magic_tail = NPU_NW_MAGIC_TAIL;

	npu_uinfo("Executing FW test #%u\n", sess, nw.param0);

	/* Setting callback */
	nw.notify_func = fw_utc_save_result_cb;
	ft_handle->cur_sess = sess; /* For sanity check */

	/* Post message and wait until the callback is invoked */
	atomic_set(&ft_handle->wait_flag, 0);
	ret = npu_ncp_mgmt_put(&nw);
	if (!ret) {
	npu_uerr("npu_ncp_mgmt_put failed : (%d)\n", sess, ret);
	test_result = NPU_ERR_DRIVER(NPU_ERR_INVALID_STATE);
	goto qos_off;
	}

	/* Collect result */
	ret = wait_event_timeout(
	ft_handle->wq,
	atomic_read(&ft_handle->wait_flag) > 0,
	FW_TC_EXEC_TIMEOUT);

	/* Construct return value */
	if (ret == 0) {
	/* Timeout and result is not available */
	npu_uerr("Test timeout\n", sess);
	test_result = NPU_ERR_DRIVER(FW_TC_RESULT_TIMEOUT);
	} else {
	npu_uinfo("Test finished with code [%u]\n", sess, ft_handle->result.result_code);
	/* Set result value */
	test_result = ft_handle->result.result_code;
	}

	qos_off:
	ret = npu_qos_stop(system);
	if (ret) {
	npu_uerr("npu_qos_stop failed : (%d)\n", sess, ret);
	test_result = NPU_ERR_DRIVER(NPU_ERR_INVALID_STATE);
	goto err_exit;
	}

	err_exit:
	ft_handle->cur_sess = NULL;
	npu_statekeeper_transition(&ft_handle->sk, FW_TEST_STATE_LOADED);
	npu_trace("%s() completed with result [%d].\n", __func__, test_result);
	return test_result;
	}

	int npu_fw_test_initialize(struct npu_system system, struct npu_memory_buffer dram_fw_log_buf)
	{
	BUG_ON(!system);
	BUG_ON(!dram_fw_log_buf);
	BUG_ON(!dram_fw_log_buf->vaddr);

	ft_handle = &(system->npu_fw_test_handler);
	memset(ft_handle, 0, sizeof(*ft_handle));

	/* Initialize state keeper */
	npu_statekeeper_initialize(
	&ft_handle->sk, FW_TEST_STATE_INVALID,
	FW_TEST_STATE_NAME, fw_test_state_transition);

	/* Keep reference to device and DRAM buffer */
	ft_handle->dev = &(system->pdev->dev);
	ft_handle->dram_fw_log_buf = dram_fw_log_buf;

	/* Initialize wait q */
	init_waitqueue_head(&ft_handle->wq);

	npu_info("fw_test : initialized.\n");
	return 0;
	}

	npu_s_param_ret fw_test_s_param_handler(struct npu_session sess, struct vs4l_param param, int *retval)
	{
	int ret;

	BUG_ON(!sess);
	BUG_ON(!param);

	switch (param->target) {
	case NPU_S_PARAM_FW_UTC_LOAD:
	#ifdef CONFIG_EXYNOS_NPU_DRAM_FW_LOG_BUF
	ret = load_fw_utc_vector(sess, param);
	return S_PARAM_HANDLED;
	#else
	npu_err("Firmware UTC support requires CONFIG_EXYNOS_NPU_DRAM_FW_LOG_BUF option.\n");
	return S_PARAM_ERROR;
	#endif

	case NPU_S_PARAM_FW_UTC_EXECUTE:
	ret = execute_fw_utc_vector(sess, param);
	return S_PARAM_HANDLED;

	default:
	/* Unknown set param command -> Pass to next handler */
	return S_PARAM_NOMB;
	}
	}