Merge "msm: cvp: Set up CVP buffer for session init" (a34e80ef) · Commits · e / devices / android_kernel_xiaomi_nabu

drivers/media/platform/msm/cvp/cvp_hfi.c

+15 −47

Original line number	Original line	Diff line number	Diff line
	@@ -2530,8 +2530,7 @@ static int venus_hfi_session_abort(void *sess)
	static int venus_hfi_session_set_buffers(void *sess,		static int venus_hfi_session_set_buffers(void *sess,
	struct cvp_buffer_addr_info *buffer_info)		struct cvp_buffer_addr_info *buffer_info)
	{		{
	struct hfi_cmd_session_set_buffers_packet *pkt;		struct hfi_cmd_session_cvp_set_buffers_packet pkt;
	u8 packet[CVP_IFACEQ_VAR_LARGE_PKT_SIZE];
	int rc = 0;		int rc = 0;
	struct hal_session *session = sess;		struct hal_session *session = sess;
	struct venus_hfi_device *device;		struct venus_hfi_device *device;
	@@ -2548,26 +2547,16 @@ static int venus_hfi_session_set_buffers(void *sess,
	rc = -EINVAL;		rc = -EINVAL;
	goto err_create_pkt;		goto err_create_pkt;
	}		}
	if (buffer_info->buffer_type == HAL_BUFFER_INPUT) {
	/*
	* Hardware doesn't care about input buffers being
	* published beforehand
	*/
	rc = 0;
	goto err_create_pkt;
	}

	pkt = (struct hfi_cmd_session_set_buffers_packet *)packet;

	rc = call_hfi_pkt_op(device, session_set_buffers,		rc = call_hfi_pkt_op(device, session_set_buffers,
	pkt, session, buffer_info);		&pkt, session, buffer_info);
	if (rc) {		if (rc) {
	dprintk(CVP_ERR, "set buffers: failed to create packet\n");		dprintk(CVP_ERR, "set buffers: failed to create packet\n");
	goto err_create_pkt;		goto err_create_pkt;
	}		}

	dprintk(CVP_INFO, "set buffers: %#x\n", buffer_info->buffer_type);		dprintk(CVP_INFO, "set buffers: %#x\n", buffer_info->buffer_type);
	if (__iface_cmdq_write(session->device, pkt))		if (__iface_cmdq_write(session->device, &pkt))
	rc = -ENOTEMPTY;		rc = -ENOTEMPTY;

	err_create_pkt:		err_create_pkt:
	@@ -2578,8 +2567,7 @@ static int venus_hfi_session_set_buffers(void *sess,
	static int venus_hfi_session_release_buffers(void *sess,		static int venus_hfi_session_release_buffers(void *sess,
	struct cvp_buffer_addr_info *buffer_info)		struct cvp_buffer_addr_info *buffer_info)
	{		{
	struct hfi_cmd_session_release_buffer_packet *pkt;		struct hfi_cmd_session_cvp_release_buffers_packet pkt;
	u8 packet[CVP_IFACEQ_VAR_LARGE_PKT_SIZE];
	int rc = 0;		int rc = 0;
	struct hal_session *session = sess;		struct hal_session *session = sess;
	struct venus_hfi_device *device;		struct venus_hfi_device *device;
	@@ -2596,22 +2584,20 @@ static int venus_hfi_session_release_buffers(void *sess,
	rc = -EINVAL;		rc = -EINVAL;
	goto err_create_pkt;		goto err_create_pkt;
	}		}
	if (buffer_info->buffer_type == HAL_BUFFER_INPUT) {		if (buffer_info->buffer_type != HAL_BUFFER_INTERNAL_PERSIST_1) {
	rc = 0;		dprintk(CVP_ERR, "INTERNAL_PERSIST_1 expected\n");
			rc = -EINVAL;
	goto err_create_pkt;		goto err_create_pkt;
	}		}

	pkt = (struct hfi_cmd_session_release_buffer_packet *) packet;

	rc = call_hfi_pkt_op(device, session_release_buffers,		rc = call_hfi_pkt_op(device, session_release_buffers,
	pkt, session, buffer_info);		&pkt, session, buffer_info);
	if (rc) {		if (rc) {
	dprintk(CVP_ERR, "release buffers: failed to create packet\n");		dprintk(CVP_ERR, "release buffers: failed to create packet\n");
	goto err_create_pkt;		goto err_create_pkt;
	}		}

	dprintk(CVP_INFO, "Release buffers: %#x\n", buffer_info->buffer_type);		if (__iface_cmdq_write(session->device, &pkt))
	if (__iface_cmdq_write(session->device, pkt))
	rc = -ENOTEMPTY;		rc = -ENOTEMPTY;

	err_create_pkt:		err_create_pkt:
	@@ -2691,25 +2677,10 @@ static int venus_hfi_session_unregister_buffer(void *sess,

	static int venus_hfi_session_start(void *session)		static int venus_hfi_session_start(void *session)
	{		{
	struct hal_session *sess;		dprintk(CVP_ERR, "Deprecated function %s\n", __func__);
	struct venus_hfi_device *device;
	int rc = 0;

	if (!session) {
	dprintk(CVP_ERR, "Invalid Params %s\n", __func__);
	return -EINVAL;		return -EINVAL;
	}		}

	sess = session;
	device = sess->device;

	mutex_lock(&device->lock);
	rc = __send_session_cmd(sess, HFI_CMD_SESSION_START);
	mutex_unlock(&device->lock);

	return rc;
	}

	static int venus_hfi_session_continue(void *session)		static int venus_hfi_session_continue(void *session)
	{		{
	struct hal_session *sess;		struct hal_session *sess;
	@@ -3320,9 +3291,9 @@ static int __response_handler(struct venus_hfi_device *device)
	case HAL_SESSION_INIT_DONE:		case HAL_SESSION_INIT_DONE:
	case HAL_SESSION_END_DONE:		case HAL_SESSION_END_DONE:
	case HAL_SESSION_ABORT_DONE:		case HAL_SESSION_ABORT_DONE:
	case HAL_SESSION_START_DONE:
	case HAL_SESSION_STOP_DONE:		case HAL_SESSION_STOP_DONE:
	case HAL_SESSION_FLUSH_DONE:		case HAL_SESSION_FLUSH_DONE:
			case HAL_SESSION_SET_BUFFER_DONE:
	case HAL_SESSION_SUSPEND_DONE:		case HAL_SESSION_SUSPEND_DONE:
	case HAL_SESSION_RESUME_DONE:		case HAL_SESSION_RESUME_DONE:
	case HAL_SESSION_SET_PROP_DONE:		case HAL_SESSION_SET_PROP_DONE:
	@@ -3890,7 +3861,6 @@ static int __protect_cp_mem(struct venus_hfi_device *device)
	struct context_bank_info *cb;		struct context_bank_info *cb;
	struct scm_desc desc = {0};		struct scm_desc desc = {0};

	return 0;
	if (!device)		if (!device)
	return -EINVAL;		return -EINVAL;

	@@ -3900,14 +3870,14 @@ static int __protect_cp_mem(struct venus_hfi_device *device)
	memprot.cp_nonpixel_size = 0x0;		memprot.cp_nonpixel_size = 0x0;

	list_for_each_entry(cb, &device->res->context_banks, list) {		list_for_each_entry(cb, &device->res->context_banks, list) {
	if (!strcmp(cb->name, "venus_ns")) {		if (!strcmp(cb->name, "cvp_hlos")) {
	desc.args[1] = memprot.cp_size =		desc.args[1] = memprot.cp_size =
	cb->addr_range.start;		cb->addr_range.start;
	dprintk(CVP_DBG, "%s memprot.cp_size: %#x\n",		dprintk(CVP_DBG, "%s memprot.cp_size: %#x\n",
	__func__, memprot.cp_size);		__func__, memprot.cp_size);
	}		}

	if (!strcmp(cb->name, "venus_sec_non_pixel")) {		if (!strcmp(cb->name, "cvp_sec_nonpixel")) {
	desc.args[2] = memprot.cp_nonpixel_start =		desc.args[2] = memprot.cp_nonpixel_start =
	cb->addr_range.start;		cb->addr_range.start;
	desc.args[3] = memprot.cp_nonpixel_size =		desc.args[3] = memprot.cp_nonpixel_size =
	@@ -3920,8 +3890,7 @@ static int __protect_cp_mem(struct venus_hfi_device *device)
	}		}

	desc.arginfo = SCM_ARGS(4);		desc.arginfo = SCM_ARGS(4);
	rc = scm_call2(SCM_SIP_FNID(SCM_SVC_MP,		rc = 0;
	TZBSP_MEM_PROTECT_VIDEO_VAR), &desc);
	resp = desc.ret[0];		resp = desc.ret[0];

	if (rc) {		if (rc) {
	@@ -4322,8 +4291,7 @@ static int __load_fw(struct venus_hfi_device *device)
	}		}
	}		}

	/* Not needed for FW boot */		if (!device->res->firmware_base) {
	if (!device->res->use_non_secure_pil && !device->res->firmware_base) {
	rc = __protect_cp_mem(device);		rc = __protect_cp_mem(device);
	if (rc) {		if (rc) {
	dprintk(CVP_ERR, "Failed to protect memory\n");		dprintk(CVP_ERR, "Failed to protect memory\n");

drivers/media/platform/msm/cvp/cvp_hfi.h

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -306,7 +306,6 @@ struct hfi_uncompressed_plane_actual_constraints_info {

	#define HFI_CMD_SESSION_OX_START \		#define HFI_CMD_SESSION_OX_START \
	(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_CMD_START_OFFSET + 0x1000)		(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_CMD_START_OFFSET + 0x1000)
	#define HFI_CMD_SESSION_LOAD_RESOURCES (HFI_CMD_SESSION_OX_START + 0x001)
	#define HFI_CMD_SESSION_START (HFI_CMD_SESSION_OX_START + 0x002)		#define HFI_CMD_SESSION_START (HFI_CMD_SESSION_OX_START + 0x002)
	#define HFI_CMD_SESSION_STOP (HFI_CMD_SESSION_OX_START + 0x003)		#define HFI_CMD_SESSION_STOP (HFI_CMD_SESSION_OX_START + 0x003)
	#define HFI_CMD_SESSION_EMPTY_BUFFER (HFI_CMD_SESSION_OX_START + 0x004)		#define HFI_CMD_SESSION_EMPTY_BUFFER (HFI_CMD_SESSION_OX_START + 0x004)

drivers/media/platform/msm/cvp/cvp_hfi_api.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -1114,8 +1114,8 @@ enum hal_command_response {
	HAL_SESSION_EVENT_CHANGE,		HAL_SESSION_EVENT_CHANGE,
	HAL_SESSION_INIT_DONE,		HAL_SESSION_INIT_DONE,
	HAL_SESSION_END_DONE,		HAL_SESSION_END_DONE,
			HAL_SESSION_SET_BUFFER_DONE,
	HAL_SESSION_ABORT_DONE,		HAL_SESSION_ABORT_DONE,
	HAL_SESSION_START_DONE,
	HAL_SESSION_STOP_DONE,		HAL_SESSION_STOP_DONE,
	HAL_SESSION_CVP_OPERATION_CONFIG,		HAL_SESSION_CVP_OPERATION_CONFIG,
	HAL_SESSION_CVP_DFS,		HAL_SESSION_CVP_DFS,

drivers/media/platform/msm/cvp/cvp_hfi_helper.h

+44 −0

Original line number	Original line	Diff line number	Diff line
	@@ -974,6 +974,50 @@ struct hfi_cmd_session_set_property_packet {
	u32 rg_property_data[1];		u32 rg_property_data[1];
	};		};

			struct hfi_cvp_client {
			u32 transaction_id;
			u32 data1;
			u32 data2;
			};

			struct hfi_cmd_session_cvp_set_buffers_packet {
			u32 size;
			u32 packet_type;
			u32 session_id;
			u32 buffer_addr;
			u32 buffer_size;
			struct hfi_cvp_client client_data;
			};

			struct hfi_cmd_session_cvp_release_buffers_packet {
			u32 size;
			u32 packet_type;
			u32 session_id;
			u32 buffer_type;
			u32 num_buffers;
			u32 buffer_idx;
			struct hfi_cvp_client client_data;
			};

			struct hfi_msg_session_cvp_release_buffers_done_packet {
			u32 size;
			u32 packet_type;
			u32 session_id;
			u32 error_type;
			struct hfi_cvp_client client_data;
			};

			struct hfi_msg_session_cvp_set_buffers_done_packet {
			u32 size;
			u32 packet_type;
			u32 session_id;
			u32 error_type;
			u32 buffer_type;
			u32 buffer_addr;
			u32 buffer_size;
			struct hfi_cvp_client client_data;
			};

	struct hfi_cmd_session_set_buffers_packet {		struct hfi_cmd_session_set_buffers_packet {
	u32 size;		u32 size;
	u32 packet_type;		u32 packet_type;

drivers/media/platform/msm/cvp/hfi_packetization.c

+11 −71

Original line number	Original line	Diff line number	Diff line
	@@ -638,99 +638,39 @@ static u32 get_hfi_work_mode(enum hal_work_mode work_mode)
	}		}

	int cvp_create_pkt_cmd_session_set_buffers(		int cvp_create_pkt_cmd_session_set_buffers(
	struct hfi_cmd_session_set_buffers_packet *pkt,		struct hfi_cmd_session_cvp_set_buffers_packet *pkt,
	struct hal_session *session,		struct hal_session *session,
	struct cvp_buffer_addr_info *buffer_info)		struct cvp_buffer_addr_info *buffer_info)
	{		{
	int rc = 0;		int rc = 0;
	int i = 0;

	if (!pkt \|\| !session)		if (!pkt \|\| !session)
	return -EINVAL;		return -EINVAL;

	pkt->packet_type = HFI_CMD_SESSION_SET_BUFFERS;		pkt->packet_type = HFI_CMD_SESSION_CVP_SET_BUFFERS;
	pkt->session_id = hash32_ptr(session);		pkt->session_id = hash32_ptr(session);
			pkt->buffer_addr = buffer_info->align_device_addr;
	pkt->buffer_size = buffer_info->buffer_size;		pkt->buffer_size = buffer_info->buffer_size;
	pkt->min_buffer_size = buffer_info->buffer_size;		pkt->size = sizeof(struct hfi_cmd_session_cvp_set_buffers_packet);
	pkt->num_buffers = buffer_info->num_buffers;

	if (buffer_info->buffer_type == HAL_BUFFER_OUTPUT \|\|
	buffer_info->buffer_type == HAL_BUFFER_OUTPUT2) {
	struct hfi_buffer_info *buff;

	pkt->extra_data_size = buffer_info->extradata_size;

	pkt->size = sizeof(struct hfi_cmd_session_set_buffers_packet) -
	sizeof(u32) + (buffer_info->num_buffers *
	sizeof(struct hfi_buffer_info));
	buff = (struct hfi_buffer_info *) pkt->rg_buffer_info;
	for (i = 0; i < pkt->num_buffers; i++) {
	buff->buffer_addr =
	(u32)buffer_info->align_device_addr;
	buff->extra_data_addr =
	(u32)buffer_info->extradata_addr;
	}
	} else {
	pkt->extra_data_size = 0;
	pkt->size = sizeof(struct hfi_cmd_session_set_buffers_packet) +
	((buffer_info->num_buffers - 1) * sizeof(u32));
	for (i = 0; i < pkt->num_buffers; i++) {
	pkt->rg_buffer_info[i] =
	(u32)buffer_info->align_device_addr;
	}
	}

	pkt->buffer_type = get_hfi_buffer(buffer_info->buffer_type);
	if (!pkt->buffer_type)
	return -EINVAL;

	return rc;		return rc;
	}		}

	int cvp_create_pkt_cmd_session_release_buffers(		int cvp_create_pkt_cmd_session_release_buffers(
	struct hfi_cmd_session_release_buffer_packet *pkt,		struct hfi_cmd_session_cvp_release_buffers_packet *pkt,
	struct hal_session *session,		struct hal_session *session,
	struct cvp_buffer_addr_info *buffer_info)		struct cvp_buffer_addr_info *buffer_info)
	{		{
	int rc = 0;
	int i = 0;

	if (!pkt \|\| !session)		if (!pkt \|\| !session)
	return -EINVAL;		return -EINVAL;

	pkt->packet_type = HFI_CMD_SESSION_RELEASE_BUFFERS;		pkt->packet_type = HFI_CMD_SESSION_CVP_RELEASE_BUFFERS;
	pkt->session_id = hash32_ptr(session);		pkt->session_id = hash32_ptr(session);
	pkt->buffer_size = buffer_info->buffer_size;		pkt->buffer_type = 0xdeadbeef;
	pkt->num_buffers = buffer_info->num_buffers;		pkt->num_buffers = 0;
			pkt->size = sizeof(struct hfi_cmd_session_cvp_release_buffers_packet);
	if (buffer_info->buffer_type == HAL_BUFFER_OUTPUT \|\|
	buffer_info->buffer_type == HAL_BUFFER_OUTPUT2) {
	struct hfi_buffer_info *buff;

	buff = (struct hfi_buffer_info *) pkt->rg_buffer_info;		return 0;
	for (i = 0; i < pkt->num_buffers; i++) {
	buff->buffer_addr =
	(u32)buffer_info->align_device_addr;
	buff->extra_data_addr =
	(u32)buffer_info->extradata_addr;
	}
	pkt->size = sizeof(struct hfi_cmd_session_set_buffers_packet) -
	sizeof(u32) + (buffer_info->num_buffers *
	sizeof(struct hfi_buffer_info));
	} else {
	for (i = 0; i < pkt->num_buffers; i++) {
	pkt->rg_buffer_info[i] =
	(u32)buffer_info->align_device_addr;
	}
	pkt->extra_data_size = 0;
	pkt->size = sizeof(struct hfi_cmd_session_set_buffers_packet) +
	((buffer_info->num_buffers - 1) * sizeof(u32));
	}
	pkt->response_req = buffer_info->response_required;
	pkt->buffer_type = get_hfi_buffer(buffer_info->buffer_type);
	if (!pkt->buffer_type)
	return -EINVAL;
	return rc;
	}		}

	int cvp_create_pkt_cmd_session_register_buffer(		int cvp_create_pkt_cmd_session_register_buffer(