Merge "msm: npu: Remove load and execute v1 path for npu_2x" (bb0bb2fb) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/media/platform/msm/npu/npu_dev.c

+4 −76

Original line number	Diff line number	Diff line
		@@ -74,14 +74,10 @@ static int npu_get_info(struct npu_client *client, unsigned long arg);
		static int npu_map_buf(struct npu_client *client, unsigned long arg);
		static int npu_unmap_buf(struct npu_client *client,
		unsigned long arg);
		static int npu_load_network(struct npu_client *client,
		unsigned long arg);
		static int npu_load_network_v2(struct npu_client *client,
		unsigned long arg);
		static int npu_unload_network(struct npu_client *client,
		unsigned long arg);
		static int npu_exec_network(struct npu_client *client,
		unsigned long arg);
		static int npu_exec_network_v2(struct npu_client *client,
		unsigned long arg);
		static int npu_receive_event(struct npu_client *client,
		@@ -1095,38 +1091,6 @@ static int npu_unmap_buf(struct npu_client *client, unsigned long arg)
		return 0;
		}

		static int npu_load_network(struct npu_client *client,
		unsigned long arg)
		{
		struct msm_npu_load_network_ioctl req;
		struct msm_npu_unload_network_ioctl unload_req;
		void __user argp = (void __user )arg;
		int ret = 0;

		ret = copy_from_user(&req, argp, sizeof(req));

		if (ret) {
		NPU_ERR("fail to copy from user\n");
		return -EFAULT;
		}

		NPU_DBG("network load with perf request %d\n", req.perf_mode);

		ret = npu_host_load_network(client, &req);
		if (ret) {
		NPU_ERR("npu_host_load_network failed %d\n", ret);
		return ret;
		}

		ret = copy_to_user(argp, &req, sizeof(req));
		if (ret) {
		NPU_ERR("fail to copy to user\n");
		ret = -EFAULT;
		unload_req.network_hdl = req.network_hdl;
		npu_host_unload_network(client, &unload_req);
		}
		return ret;
		}

		static int npu_load_network_v2(struct npu_client *client,
		unsigned long arg)
		@@ -1216,44 +1180,6 @@ static int npu_unload_network(struct npu_client *client,
		return 0;
		}

		static int npu_exec_network(struct npu_client *client,
		unsigned long arg)
		{
		struct msm_npu_exec_network_ioctl req;
		void __user argp = (void __user )arg;
		int ret = 0;

		ret = copy_from_user(&req, argp, sizeof(req));

		if (ret) {
		NPU_ERR("fail to copy from user\n");
		return -EFAULT;
		}

		if ((req.input_layer_num > MSM_NPU_MAX_INPUT_LAYER_NUM) \|\|
		(req.output_layer_num > MSM_NPU_MAX_OUTPUT_LAYER_NUM)) {
		NPU_ERR("Invalid input/out layer num %d[max:%d] %d[max:%d]\n",
		req.input_layer_num, MSM_NPU_MAX_INPUT_LAYER_NUM,
		req.output_layer_num, MSM_NPU_MAX_OUTPUT_LAYER_NUM);
		return -EINVAL;
		}

		ret = npu_host_exec_network(client, &req);

		if (ret) {
		NPU_ERR("npu_host_exec_network failed %d\n", ret);
		return ret;
		}

		ret = copy_to_user(argp, &req, sizeof(req));

		if (ret) {
		NPU_ERR("fail to copy to user\n");
		return -EFAULT;
		}
		return 0;
		}

		static int npu_exec_network_v2(struct npu_client *client,
		unsigned long arg)
		{
		@@ -1446,7 +1372,8 @@ static long npu_ioctl(struct file *file, unsigned int cmd,
		ret = npu_unmap_buf(client, arg);
		break;
		case MSM_NPU_LOAD_NETWORK:
		ret = npu_load_network(client, arg);
		NPU_ERR("npu_load_network_v1 is no longer supported\n");
		ret = -ENOTTY;
		break;
		case MSM_NPU_LOAD_NETWORK_V2:
		ret = npu_load_network_v2(client, arg);
		@@ -1455,7 +1382,8 @@ static long npu_ioctl(struct file *file, unsigned int cmd,
		ret = npu_unload_network(client, arg);
		break;
		case MSM_NPU_EXEC_NETWORK:
		ret = npu_exec_network(client, arg);
		NPU_ERR("npu_exec_network_v1 is no longer supported\n");
		ret = -ENOTTY;
		break;
		case MSM_NPU_EXEC_NETWORK_V2:
		ret = npu_exec_network_v2(client, arg);

drivers/media/platform/msm/npu/npu_mgr.c

+0 −251

Original line number	Diff line number	Diff line
		@@ -1546,28 +1546,6 @@ static int npu_send_misc_cmd(struct npu_device *npu_dev, uint32_t q_idx,
		return ret;
		}

		static void host_copy_patch_data(struct npu_patch_tuple *param, uint32_t value,
		struct msm_npu_layer *layer_info)
		{
		param->value = value;
		param->chunk_id = layer_info->patch_info.chunk_id;
		param->loc_offset = layer_info->patch_info.loc_offset;
		param->instruction_size_in_bytes =
		layer_info->patch_info.instruction_size_in_bytes;
		param->shift_value_in_bits =
		layer_info->patch_info.shift_value_in_bits;
		param->variable_size_in_bits =
		layer_info->patch_info.variable_size_in_bits;

		NPU_DBG("copy_patch_data: %x %d %x %x %x %x\n",
		param->value,
		param->chunk_id,
		param->loc_offset,
		param->instruction_size_in_bytes,
		param->shift_value_in_bits,
		param->variable_size_in_bits);
		}

		static void host_copy_patch_data_v2(struct npu_patch_tuple_v2 *param,
		struct msm_npu_patch_info_v2 *patch_info)
		{
		@@ -1627,110 +1605,6 @@ static int set_perf_mode(struct npu_device *npu_dev)
		return ret;
		}

		int32_t npu_host_load_network(struct npu_client *client,
		struct msm_npu_load_network_ioctl *load_ioctl)
		{
		int ret = 0;
		struct npu_device *npu_dev = client->npu_dev;
		struct npu_network *network;
		struct ipc_cmd_load_pkt load_packet;
		struct npu_host_ctx *host_ctx = &npu_dev->host_ctx;

		ret = enable_fw(npu_dev);
		if (ret)
		return ret;

		mutex_lock(&host_ctx->lock);
		network = alloc_network(host_ctx, client);
		if (!network) {
		ret = -ENOMEM;
		goto err_deinit_fw;
		}

		network_get(network);
		network->buf_hdl = load_ioctl->buf_ion_hdl;
		network->size = load_ioctl->buf_size;
		network->phy_add = load_ioctl->buf_phys_addr;
		network->first_block_size = load_ioctl->first_block_size;
		network->priority = load_ioctl->priority;
		network->perf_mode = load_ioctl->perf_mode;

		/* verify mapped physical address */
		if (!npu_mem_verify_addr(client, network->phy_add)) {
		ret = -EINVAL;
		goto error_free_network;
		}

		ret = set_perf_mode(npu_dev);
		if (ret) {
		NPU_ERR("set_perf_mode failed\n");
		goto error_free_network;
		}

		load_packet.header.cmd_type = NPU_IPC_CMD_LOAD;
		load_packet.header.size = sizeof(struct ipc_cmd_load_pkt);
		load_packet.header.trans_id =
		atomic_add_return(1, &host_ctx->ipc_trans_id);
		load_packet.header.flags = load_ioctl->flags;

		/* ACO Buffer. Use the npu mapped aco address */
		load_packet.buf_pkt.address = (uint64_t)network->phy_add;
		load_packet.buf_pkt.buf_size = network->first_block_size;
		load_packet.buf_pkt.network_id = network->id;

		/* NPU_IPC_CMD_LOAD will go onto IPC_QUEUE_APPS_EXEC */
		reinit_completion(&network->cmd_done);
		ret = npu_send_network_cmd(npu_dev, network, &load_packet, false,
		false);
		if (ret) {
		NPU_ERR("NPU_IPC_CMD_LOAD sent failed: %d\n", ret);
		goto error_free_network;
		}

		mutex_unlock(&host_ctx->lock);

		ret = wait_for_completion_interruptible_timeout(
		&network->cmd_done,
		(host_ctx->fw_dbg_mode & FW_DBG_MODE_INC_TIMEOUT) ?
		NW_DEBUG_TIMEOUT : NW_CMD_TIMEOUT);

		mutex_lock(&host_ctx->lock);
		if (!ret) {
		NPU_ERR("NPU_IPC_CMD_LOAD time out\n");
		npu_dump_debug_info(npu_dev);
		ret = -ETIMEDOUT;
		goto error_free_network;
		} else if (ret < 0) {
		NPU_ERR("NPU_IPC_CMD_LOAD is interrupted by signal\n");
		goto error_free_network;
		}

		if (network->fw_error) {
		ret = -EIO;
		NPU_ERR("fw is in error state during load network\n");
		goto error_free_network;
		}

		ret = network->cmd_ret_status;
		if (ret)
		goto error_free_network;

		load_ioctl->network_hdl = network->network_hdl;
		network->is_active = true;
		network_put(network);
		mutex_unlock(&host_ctx->lock);

		return ret;

		error_free_network:
		network_put(network);
		free_network(host_ctx, client, network->id);
		err_deinit_fw:
		mutex_unlock(&host_ctx->lock);
		disable_fw(npu_dev);
		return ret;
		}

		int32_t npu_host_load_network_v2(struct npu_client *client,
		struct msm_npu_load_network_ioctl_v2 *load_ioctl,
		struct msm_npu_patch_info_v2 *patch_info)
		@@ -1971,131 +1845,6 @@ int32_t npu_host_unload_network(struct npu_client *client,
		return ret;
		}

		int32_t npu_host_exec_network(struct npu_client *client,
		struct msm_npu_exec_network_ioctl *exec_ioctl)
		{
		struct npu_device *npu_dev = client->npu_dev;
		struct ipc_cmd_execute_pkt exec_packet;
		/* npu mapped addr */
		uint64_t input_off, output_off;
		int32_t ret;
		struct npu_network *network;
		struct npu_host_ctx *host_ctx = &npu_dev->host_ctx;
		bool async_ioctl = !!exec_ioctl->async;

		mutex_lock(&host_ctx->lock);
		network = get_network_by_hdl(host_ctx, client,
		exec_ioctl->network_hdl);

		if (!network) {
		mutex_unlock(&host_ctx->lock);
		return -EINVAL;
		}

		if (!network->is_active) {
		NPU_ERR("network is not active\n");
		ret = -EINVAL;
		goto exec_done;
		}

		if (network->fw_error) {
		NPU_ERR("fw is in error state\n");
		ret = -EIO;
		goto exec_done;
		}

		NPU_DBG("execute network %lld\n", network->id);
		memset(&exec_packet, 0, sizeof(exec_packet));
		if (exec_ioctl->patching_required) {
		if ((exec_ioctl->input_layer_num != 1) \|\|
		(exec_ioctl->output_layer_num != 1)) {
		NPU_ERR("Invalid input/output layer num\n");
		ret = -EINVAL;
		goto exec_done;
		}

		input_off = exec_ioctl->input_layers[0].buf_phys_addr;
		output_off = exec_ioctl->output_layers[0].buf_phys_addr;
		/* verify mapped physical address */
		if (!npu_mem_verify_addr(client, input_off) \|\|
		!npu_mem_verify_addr(client, output_off)) {
		NPU_ERR("Invalid patch buf address\n");
		ret = -EINVAL;
		goto exec_done;
		}

		exec_packet.patch_params.num_params = 2;
		host_copy_patch_data(&exec_packet.patch_params.param[0],
		(uint32_t)input_off, &exec_ioctl->input_layers[0]);
		host_copy_patch_data(&exec_packet.patch_params.param[1],
		(uint32_t)output_off, &exec_ioctl->output_layers[0]);
		} else {
		exec_packet.patch_params.num_params = 0;
		}

		exec_packet.header.cmd_type = NPU_IPC_CMD_EXECUTE;
		exec_packet.header.size = sizeof(struct ipc_cmd_execute_pkt);
		exec_packet.header.trans_id =
		atomic_add_return(1, &host_ctx->ipc_trans_id);
		exec_packet.header.flags = 0xF;
		exec_packet.network_hdl = network->network_hdl;

		/* Send it on the high priority queue */
		reinit_completion(&network->cmd_done);
		ret = npu_send_network_cmd(npu_dev, network, &exec_packet, async_ioctl,
		false);

		if (ret) {
		NPU_ERR("NPU_IPC_CMD_EXECUTE sent failed: %d\n", ret);
		goto exec_done;
		}

		if (async_ioctl) {
		NPU_DBG("Async ioctl, return now\n");
		goto exec_done;
		}

		mutex_unlock(&host_ctx->lock);

		ret = wait_for_completion_timeout(
		&network->cmd_done,
		(host_ctx->fw_dbg_mode & FW_DBG_MODE_INC_TIMEOUT) ?
		NW_DEBUG_TIMEOUT : NW_CMD_TIMEOUT);

		mutex_lock(&host_ctx->lock);
		if (!ret) {
		NPU_ERR("npu: %x NPU_IPC_CMD_EXECUTE time out\n",
		network->id);
		npu_dump_debug_info(npu_dev);
		network->cmd_pending = false;
		ret = -ETIMEDOUT;
		goto exec_done;
		}

		if (network->fw_error) {
		ret = -EIO;
		NPU_ERR("fw is in error state during execute network\n");
		} else {
		ret = network->cmd_ret_status;
		NPU_DBG("execution status %d\n", ret);
		}

		exec_done:
		network_put(network);
		mutex_unlock(&host_ctx->lock);

		/*
		* treat network execution timed out as error in order to
		* force npu fw to stop execution
		*/
		if (ret == -ETIMEDOUT) {
		NPU_ERR("Error handling after execution failure\n");
		host_error_hdlr(npu_dev, true);
		}

		return ret;
		}

		int32_t npu_host_exec_network_v2(struct npu_client *client,
		struct msm_npu_exec_network_ioctl_v2 *exec_ioctl,
		struct msm_npu_patch_buf_info *patch_buf_info)

drivers/media/platform/msm/npu/npu_mgr.h

+0 −4

Original line number	Diff line number	Diff line
		@@ -131,15 +131,11 @@ int32_t npu_host_map_buf(struct npu_client *client,
		struct msm_npu_map_buf_ioctl *map_ioctl);
		int32_t npu_host_unmap_buf(struct npu_client *client,
		struct msm_npu_unmap_buf_ioctl *unmap_ioctl);
		int32_t npu_host_load_network(struct npu_client *client,
		struct msm_npu_load_network_ioctl *load_ioctl);
		int32_t npu_host_load_network_v2(struct npu_client *client,
		struct msm_npu_load_network_ioctl_v2 *load_ioctl,
		struct msm_npu_patch_info_v2 *patch_info);
		int32_t npu_host_unload_network(struct npu_client *client,
		struct msm_npu_unload_network_ioctl *unload);
		int32_t npu_host_exec_network(struct npu_client *client,
		struct msm_npu_exec_network_ioctl *exec_ioctl);
		int32_t npu_host_exec_network_v2(struct npu_client *client,
		struct msm_npu_exec_network_ioctl_v2 *exec_ioctl,
		struct msm_npu_patch_buf_info *patch_buf_info);