mirror/android_kernel_fxtec_sm6115
3
0
Fork 0
mirror of https://github.com/LineageOS/android_kernel_fxtec_sm6115.git synced 2026-08-19 08:41:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

msm: cvp: Enable DFS and DME features on CVP

Browse Source 
Add support to enable DFS (depth from stereo) and DME
(descriptor motion estimate) features of CVP (computer
vision processor) on Kona.

Change-Id: Id8613c396bcfbecb8c39ddc3f0d64c2f6b85d57f
Signed-off-by: abhikran <abhikran@codeaurora.org>
Signed-off-by: George Shen <sqiao@codeaurora.org>
This commit is contained in:
abhikran
2019-02-06 15:02:13 +05:30
committed by George Shen
parent f5f317901c
commit 5c026fcbfe
16 changed files with 1185 additions and 1093 deletions
Download Patch File Download Diff File Expand all files Collapse all files

395
drivers/media/platform/msm/cvp/cvp_hfi.c
View File

@ -249,17 +249,6 @@ static void __sim_modify_cmd_packet(u8 *packet, struct venus_hfi_device *device)
}
break;
}
case HFI_CMD_SESSION_REGISTER_BUFFERS:
{
struct hfi_cmd_session_register_buffers_packet *pkt =
(struct hfi_cmd_session_register_buffers_packet *)
packet;
struct hfi_buffer_mapping_type *buf =
(struct hfi_buffer_mapping_type *)pkt->buffer;
for (i = 0; i < pkt->num_buffers; i++)
buf[i].device_addr -= fw_bias;
break;
}
default:
break;
}
@ -2602,76 +2591,6 @@ err_create_pkt:
return rc;
}
static int venus_hfi_session_register_buffer(void *sess,
struct cvp_register_buffer *buffer)
{
int rc = 0;
u8 packet[CVP_IFACEQ_VAR_LARGE_PKT_SIZE];
struct hfi_cmd_session_register_buffers_packet *pkt;
struct hal_session *session = sess;
struct venus_hfi_device *device;
if (!session || !session->device || !buffer) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
device = session->device;
mutex_lock(&device->lock);
if (!__is_session_valid(device, session, __func__)) {
rc = -EINVAL;
goto exit;
}
pkt = (struct hfi_cmd_session_register_buffers_packet *)packet;
rc = call_hfi_pkt_op(device, session_register_buffer, pkt,
session, buffer);
if (rc) {
dprintk(CVP_ERR, "%s: failed to create packet\n", __func__);
goto exit;
}
if (__iface_cmdq_write(session->device, pkt))
rc = -ENOTEMPTY;
exit:
mutex_unlock(&device->lock);
return rc;
}
static int venus_hfi_session_unregister_buffer(void *sess,
struct cvp_unregister_buffer *buffer)
{
int rc = 0;
u8 packet[CVP_IFACEQ_VAR_LARGE_PKT_SIZE];
struct hfi_cmd_session_unregister_buffers_packet *pkt;
struct hal_session *session = sess;
struct venus_hfi_device *device;
if (!session || !session->device || !buffer) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
device = session->device;
mutex_lock(&device->lock);
if (!__is_session_valid(device, session, __func__)) {
rc = -EINVAL;
goto exit;
}
pkt = (struct hfi_cmd_session_unregister_buffers_packet *)packet;
rc = call_hfi_pkt_op(device, session_unregister_buffer, pkt,
session, buffer);
if (rc) {
dprintk(CVP_ERR, "%s: failed to create packet\n", __func__);
goto exit;
}
if (__iface_cmdq_write(session->device, pkt))
rc = -ENOTEMPTY;
exit:
mutex_unlock(&device->lock);
return rc;
}
static int venus_hfi_session_start(void *session)
{
dprintk(CVP_ERR, "Deprecated function %s\n", __func__);
@ -2720,11 +2639,121 @@ static int venus_hfi_session_stop(void *session)
return rc;
}
static int venus_hfi_session_cvp_dfs_config(void *sess,
struct msm_cvp_dfsconfig *dfs_config)
static int venus_hfi_session_cvp_dme_config(void *sess,
struct msm_cvp_internal_dmeconfig *dme_config)
{
int rc = 0;
struct hfi_cmd_session_cvp_dfs_config pkt;
struct hfi_cmd_session_cvp_dme_config_packet pkt;
struct hal_session *session = sess;
struct venus_hfi_device *device;
if (!session || !session->device) {
dprintk(CVP_ERR, "invalid session");
return -ENODEV;
}
device = session->device;
mutex_lock(&device->lock);
if (!__is_session_valid(device, session, __func__)) {
rc = -EINVAL;
goto dme_config_err;
}
rc = call_hfi_pkt_op(device, session_cvp_dme_config,
&pkt, session, dme_config);
if (rc) {
dprintk(CVP_ERR,
"Session get buf req: failed to create pkt\n");
goto dme_config_err;
}
if (__iface_cmdq_write(session->device, &pkt))
rc = -ENOTEMPTY;
dprintk(CVP_DBG, "%s: calling __iface_cmdq_write\n", __func__);
dme_config_err:
mutex_unlock(&device->lock);
return rc;
}
static int venus_hfi_session_cvp_dme_frame(void *sess,
struct msm_cvp_internal_dmeframe *dme_frame)
{
int rc = 0;
struct hfi_cmd_session_cvp_dme_frame_packet pkt;
struct hal_session *session = sess;
struct venus_hfi_device *device;
if (!session || !session->device) {
dprintk(CVP_ERR, "invalid session");
return -ENODEV;
}
device = session->device;
mutex_lock(&device->lock);
if (!__is_session_valid(device, session, __func__)) {
rc = -EINVAL;
goto dme_frame_err;
}
rc = call_hfi_pkt_op(device, session_cvp_dme_frame,
&pkt, session, dme_frame);
if (rc) {
dprintk(CVP_ERR,
"Session get buf req: failed to create pkt\n");
goto dme_frame_err;
}
if (__iface_cmdq_write(session->device, &pkt))
rc = -ENOTEMPTY;
dprintk(CVP_DBG, "%s: done calling __iface_cmdq_write\n", __func__);
dme_frame_err:
mutex_unlock(&device->lock);
return rc;
}
static int venus_hfi_session_cvp_persist(void *sess,
struct msm_cvp_internal_persist_cmd *pbuf_cmd)
{
int rc = 0;
struct hfi_cmd_session_cvp_persist_packet pkt;
struct hal_session *session = sess;
struct venus_hfi_device *device;
if (!session || !session->device) {
dprintk(CVP_ERR, "invalid session");
return -ENODEV;
}
device = session->device;
mutex_lock(&device->lock);
if (!__is_session_valid(device, session, __func__)) {
rc = -EINVAL;
goto persist_err;
}
rc = call_hfi_pkt_op(device, session_cvp_persist,
&pkt, session, pbuf_cmd);
if (rc) {
dprintk(CVP_ERR,
"Failed to create persist pkt\n");
goto persist_err;
}
if (__iface_cmdq_write(session->device, &pkt))
rc = -ENOTEMPTY;
dprintk(CVP_DBG, "%s: done calling __iface_cmdq_write\n", __func__);
persist_err:
mutex_unlock(&device->lock);
return rc;
}
static int venus_hfi_session_cvp_dfs_config(void *sess,
struct msm_cvp_internal_dfsconfig *dfs_config)
{
int rc = 0;
struct hfi_cmd_session_cvp_dfs_config_packet pkt;
struct hal_session *session = sess;
struct venus_hfi_device *device;
@ -2760,10 +2789,10 @@ err_create_pkt:
}
static int venus_hfi_session_cvp_dfs_frame(void *sess,
struct msm_cvp_dfsframe *dfs_frame)
struct msm_cvp_internal_dfsframe *dfs_frame)
{
int rc = 0;
struct hfi_cmd_session_cvp_dfs_frame pkt;
struct hfi_cmd_session_cvp_dfs_frame_packet pkt;
struct hal_session *session = sess;
struct venus_hfi_device *device;
@ -2796,12 +2825,6 @@ err_create_pkt:
return rc;
}
static int venus_hfi_session_cvp_send_cmd(void *sess,
struct cvp_frame_data *input_frame)
{
return 0;
}
static int venus_hfi_session_get_buf_req(void *sess)
{
struct hfi_cmd_session_get_property_packet pkt;
@ -3205,6 +3228,80 @@ static struct hal_session *__get_session(struct venus_hfi_device *device,
return NULL;
}
#define _INVALID_MSG_ "Unrecognized MSG (%#x) session (%pK), discarding\n"
#define _INVALID_STATE_ "Ignore responses from %d to %d invalid state\n"
#define _DEVFREQ_FAIL_ "Failed to add devfreq device bus %s governor %s: %d\n"
static void process_system_msg(struct msm_cvp_cb_info *info,
struct venus_hfi_device *device,
void *raw_packet)
{
struct cvp_hal_sys_init_done sys_init_done = {0};
switch (info->response_type) {
case HAL_SYS_ERROR:
__process_sys_error(device);
break;
case HAL_SYS_RELEASE_RESOURCE_DONE:
dprintk(CVP_DBG, "Received SYS_RELEASE_RESOURCE\n");
break;
case HAL_SYS_INIT_DONE:
dprintk(CVP_DBG, "Received SYS_INIT_DONE\n");
sys_init_done.capabilities =
device->sys_init_capabilities;
cvp_hfi_process_sys_init_done_prop_read(
(struct hfi_msg_sys_init_done_packet *)
raw_packet, &sys_init_done);
info->response.cmd.data.sys_init_done = sys_init_done;
break;
default:
break;
}
}
static void **get_session_id(struct msm_cvp_cb_info *info)
{
void **session_id = NULL;
/* For session-related packets, validate session */
switch (info->response_type) {
case HAL_SESSION_INIT_DONE:
case HAL_SESSION_END_DONE:
case HAL_SESSION_ABORT_DONE:
case HAL_SESSION_STOP_DONE:
case HAL_SESSION_FLUSH_DONE:
case HAL_SESSION_SET_BUFFER_DONE:
case HAL_SESSION_SUSPEND_DONE:
case HAL_SESSION_RESUME_DONE:
case HAL_SESSION_SET_PROP_DONE:
case HAL_SESSION_GET_PROP_DONE:
case HAL_SESSION_RELEASE_BUFFER_DONE:
case HAL_SESSION_REGISTER_BUFFER_DONE:
case HAL_SESSION_UNREGISTER_BUFFER_DONE:
case HAL_SESSION_DFS_CONFIG_CMD_DONE:
case HAL_SESSION_DME_CONFIG_CMD_DONE:
case HAL_SESSION_DFS_FRAME_CMD_DONE:
case HAL_SESSION_DME_FRAME_CMD_DONE:
case HAL_SESSION_PERSIST_CMD_DONE:
case HAL_SESSION_PROPERTY_INFO:
session_id = &info->response.cmd.session_id;
break;
case HAL_SESSION_ERROR:
session_id = &info->response.data.session_id;
break;
case HAL_SESSION_EVENT_CHANGE:
session_id = &info->response.event.session_id;
break;
case HAL_RESPONSE_UNUSED:
default:
session_id = NULL;
break;
}
return session_id;
}
static int __response_handler(struct venus_hfi_device *device)
{
struct msm_cvp_cb_info *packets;
@ -3249,7 +3346,6 @@ static int __response_handler(struct venus_hfi_device *device)
while (!__iface_msgq_read(device, raw_packet)) {
void **session_id = NULL;
struct msm_cvp_cb_info *info = &packets[packet_count++];
struct cvp_hal_sys_init_done sys_init_done = {0};
int rc = 0;
rc = cvp_hfi_process_msg_packet(device->device_id,
@ -3262,59 +3358,9 @@ static int __response_handler(struct venus_hfi_device *device)
}
/* Process the packet types that we're interested in */
switch (info->response_type) {
case HAL_SYS_ERROR:
__process_sys_error(device);
break;
case HAL_SYS_RELEASE_RESOURCE_DONE:
dprintk(CVP_DBG, "Received SYS_RELEASE_RESOURCE\n");
break;
case HAL_SYS_INIT_DONE:
dprintk(CVP_DBG, "Received SYS_INIT_DONE\n");
sys_init_done.capabilities =
device->sys_init_capabilities;
cvp_hfi_process_sys_init_done_prop_read(
(struct hfi_msg_sys_init_done_packet *)
raw_packet, &sys_init_done);
info->response.cmd.data.sys_init_done = sys_init_done;
break;
default:
break;
}
/* For session-related packets, validate session */
switch (info->response_type) {
case HAL_SESSION_INIT_DONE:
case HAL_SESSION_END_DONE:
case HAL_SESSION_ABORT_DONE:
case HAL_SESSION_STOP_DONE:
case HAL_SESSION_FLUSH_DONE:
case HAL_SESSION_SET_BUFFER_DONE:
case HAL_SESSION_SUSPEND_DONE:
case HAL_SESSION_RESUME_DONE:
case HAL_SESSION_SET_PROP_DONE:
case HAL_SESSION_GET_PROP_DONE:
case HAL_SESSION_RELEASE_BUFFER_DONE:
case HAL_SESSION_REGISTER_BUFFER_DONE:
case HAL_SESSION_UNREGISTER_BUFFER_DONE:
case HAL_SESSION_DFS_CONFIG_CMD_DONE:
case HAL_SESSION_DFS_FRAME_CMD_DONE:
case HAL_SESSION_PROPERTY_INFO:
session_id = &info->response.cmd.session_id;
break;
case HAL_SESSION_ERROR:
session_id = &info->response.data.session_id;
break;
case HAL_SESSION_EVENT_CHANGE:
session_id = &info->response.event.session_id;
break;
case HAL_RESPONSE_UNUSED:
default:
session_id = NULL;
break;
}
process_system_msg(info, device, raw_packet);
session_id = get_session_id(info);
/*
* hfi_process_msg_packet provides a session_id that's a hashed
* value of struct hal_session, we need to coerce the hashed
@ -3333,8 +3379,7 @@ static int __response_handler(struct venus_hfi_device *device)
session = __get_session(device,
(u32)(uintptr_t)*session_id);
if (!session) {
dprintk(CVP_ERR,
"Received a packet (%#x) for an unrecognized session (%pK), discarding\n",
dprintk(CVP_ERR, _INVALID_MSG_,
info->response_type,
*session_id);
--packet_count;
@ -3347,7 +3392,7 @@ static int __response_handler(struct venus_hfi_device *device)
if (packet_count >= cvp_max_packets &&
__get_q_size(device, CVP_IFACEQ_MSGQ_IDX)) {
dprintk(CVP_WARN,
"Too many packets in message queue to handle at once, deferring read\n");
"Too many packets in message queue!\n");
break;
}
@ -3420,8 +3465,7 @@ err_no_work:
if (!__core_in_valid_state(device)) {
dprintk(CVP_ERR,
"Ignore responses from %d to %d as device is in invalid state",
(i + 1), num_responses);
_INVALID_STATE_, (i + 1), num_responses);
break;
}
dprintk(CVP_DBG, "Processing response %d of %d, type %d\n",
@ -3732,9 +3776,8 @@ static int __init_bus(struct venus_hfi_device *device)
&bus->devfreq_prof, bus->governor, NULL);
if (IS_ERR_OR_NULL(bus->devfreq)) {
rc = PTR_ERR(bus->devfreq) ?: -EBADHANDLE;
dprintk(CVP_ERR,
"Failed to add devfreq device for bus %s and governor %s: %d\n",
bus->name, bus->governor, rc);
dprintk(CVP_ERR, _DEVFREQ_FAIL_,
bus->name, bus->governor, rc);
bus->devfreq = NULL;
goto err_add_dev;
}
@ -3969,16 +4012,30 @@ static int __enable_regulators(struct venus_hfi_device *device)
dprintk(CVP_DBG, "Enabling regulators\n");
venus_hfi_for_each_regulator(device, rinfo) {
rc = regulator_enable(rinfo->regulator);
if (rc) {
dprintk(CVP_ERR,
"Failed to enable %s: %d\n",
rinfo->name, rc);
goto err_reg_enable_failed;
}
if (rinfo->has_hw_power_collapse) {
rc = regulator_set_mode(rinfo->regulator,
REGULATOR_MODE_FAST);
if (rc) {
dprintk(CVP_ERR,
"Failed to enable hwctrl%s: %d\n",
rinfo->name, rc);
goto err_reg_enable_failed;
}
dprintk(CVP_DBG, "Enabled regulator %s hw ctrl\n",
rinfo->name);
dprintk(CVP_DBG, "Enabled regulator %s\n",
rinfo->name);
} else {
rc = regulator_enable(rinfo->regulator);
if (rc) {
dprintk(CVP_ERR,
"Failed to enable %s: %d\n",
rinfo->name, rc);
goto err_reg_enable_failed;
}
dprintk(CVP_DBG, "Enabled regulator %s\n",
rinfo->name);
}
c++;
}
@ -3997,8 +4054,12 @@ static int __disable_regulators(struct venus_hfi_device *device)
dprintk(CVP_DBG, "Disabling regulators\n");
venus_hfi_for_each_regulator_reverse(device, rinfo)
venus_hfi_for_each_regulator_reverse(device, rinfo) {
__disable_regulator(rinfo, device);
if (rinfo->has_hw_power_collapse)
regulator_set_mode(rinfo->regulator,
REGULATOR_MODE_NORMAL);
}
return 0;
}
@ -4085,7 +4146,7 @@ static int __venus_power_on(struct venus_hfi_device *device)
rc = __scale_clocks(device);
if (rc) {
dprintk(CVP_WARN,
"Failed to scale clocks, performance might be affected\n");
"Failed to scale clocks, perf may regress\n");
rc = 0;
}
@ -4647,15 +4708,15 @@ static void venus_init_hfi_callbacks(struct hfi_device *hdev)
hdev->session_clean = venus_hfi_session_clean;
hdev->session_set_buffers = venus_hfi_session_set_buffers;
hdev->session_release_buffers = venus_hfi_session_release_buffers;
hdev->session_register_buffer = venus_hfi_session_register_buffer;
hdev->session_unregister_buffer = venus_hfi_session_unregister_buffer;
hdev->session_start = venus_hfi_session_start;
hdev->session_continue = venus_hfi_session_continue;
hdev->session_stop = venus_hfi_session_stop;
hdev->session_get_buf_req = venus_hfi_session_get_buf_req;
hdev->session_cvp_dfs_config = venus_hfi_session_cvp_dfs_config;
hdev->session_cvp_dfs_frame = venus_hfi_session_cvp_dfs_frame;
hdev->session_cvp_send_cmd = venus_hfi_session_cvp_send_cmd;
hdev->session_cvp_dme_config = venus_hfi_session_cvp_dme_config;
hdev->session_cvp_dme_frame = venus_hfi_session_cvp_dme_frame;
hdev->session_cvp_persist = venus_hfi_session_cvp_persist;
hdev->session_flush = venus_hfi_session_flush;
hdev->session_set_property = venus_hfi_session_set_property;
hdev->session_get_property = venus_hfi_session_get_property;

92
drivers/media/platform/msm/cvp/cvp_hfi.h
View File

@ -326,10 +326,6 @@ struct hfi_uncompressed_plane_actual_constraints_info {
#define HFI_CMD_SESSION_CVP_START \
(HFI_DOMAIN_BASE_CVP + HFI_ARCH_COMMON_OFFSET + \
HFI_CMD_START_OFFSET + 0x1000)
#define HFI_CMD_SESSION_REGISTER_BUFFERS \
(HFI_CMD_SESSION_CVP_START + 0x0A0)
#define HFI_CMD_SESSION_UNREGISTER_BUFFERS \
(HFI_CMD_SESSION_CVP_START + 0x0A1)
/* =============BASIC OPERATIONS=================*/
#define HFI_CMD_SESSION_CVP_SET_BUFFERS\
@ -384,6 +380,13 @@ struct hfi_uncompressed_plane_actual_constraints_info {
#define HFI_CMD_SESSION_CVP_PYS_HCD_CONFIG\
(HFI_CMD_SESSION_CVP_START + 0x017)
#define HFI_CMD_SESSION_CVP_DME_CONFIG\
(HFI_CMD_SESSION_CVP_START + 0x039)
#define HFI_CMD_SESSION_CVP_DME_FRAME\
(HFI_CMD_SESSION_CVP_START + 0x03A)
#define HFI_CMD_SESSION_CVP_SET_PERSIST_BUFFERS\
(HFI_CMD_SESSION_CVP_START + 0x04D)
#define HFI_MSG_SYS_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_MSG_START_OFFSET + 0x0000)
@ -409,10 +412,6 @@ struct hfi_uncompressed_plane_actual_constraints_info {
#define HFI_MSG_SESSION_CVP_START \
(HFI_DOMAIN_BASE_CVP + HFI_ARCH_COMMON_OFFSET + \
HFI_MSG_START_OFFSET + 0x1000)
#define HFI_MSG_SESSION_REGISTER_BUFFERS_DONE \
(HFI_MSG_SESSION_CVP_START + 0x0A0)
#define HFI_MSG_SESSION_UNREGISTER_BUFFERS_DONE \
(HFI_MSG_SESSION_CVP_START + 0x0A1)
/* =================BASIC OPERATIONS=================*/
#define HFI_MSG_SESSION_CVP_SET_BUFFERS\
@ -436,7 +435,12 @@ struct hfi_uncompressed_plane_actual_constraints_info {
#define HFI_MSG_SESSION_CVP_FTEXT\
(HFI_MSG_SESSION_CVP_START + 0x00A)
#define HFI_MSG_SESSION_CVP_OPERATION_CONFIG (HFI_MSG_SESSION_CVP_START + 0x010)
#define HFI_MSG_SESSION_CVP_DME\
(HFI_MSG_SESSION_CVP_START + 0x023)
#define HFI_MSG_SESSION_CVP_OPERATION_CONFIG (HFI_MSG_SESSION_CVP_START + 0x030)
#define HFI_MSG_SESSION_CVP_SET_PERSIST_BUFFERS\
(HFI_MSG_SESSION_CVP_START + 0x034)
#define CVP_IFACEQ_MAX_PKT_SIZE 1024
#define CVP_IFACEQ_MED_PKT_SIZE 768
@ -577,36 +581,40 @@ struct HFI_CVP_COLOR_PLANE_INFO {
u32 buf_size[HFI_MAX_PLANES];
};
struct hfi_cmd_session_cvp_dfs_config {
struct hfi_cmd_session_hdr {
u32 size;
u32 packet_type;
u32 session_id;
u32 srcbuffer_format;
struct HFI_CVP_COLOR_PLANE_INFO left_plane_info;
struct HFI_CVP_COLOR_PLANE_INFO right_plane_info;
u32 width;
u32 height;
u32 occlusionmask_enable;
u32 occlusioncost;
u32 occlusionbound;
u32 occlusionshift;
u32 maxdisparity;
u32 disparityoffset;
u32 medianfilter_enable;
u32 occlusionfilling_enable;
u32 occlusionmaskdump;
struct hfi_cvp_client_data clientdata;
};
struct hfi_cmd_session_cvp_dfs_frame {
u32 size;
u32 packet_type;
u32 session_id;
u32 left_buffer_index;
u32 right_buffer_index;
u32 disparitymap_buffer_idx;
u32 occlusionmask_buffer_idx;
struct hfi_cvp_client_data clientdata;
struct hfi_cmd_session_cvp_dfs_config_packet {
u32 cvp_internal_dfs_config[CVP_DFS_CONFIG_CMD_SIZE];
};
struct hfi_cmd_session_cvp_dfs_frame_packet {
u32 cvp_dfs_frame[CVP_DFS_FRAME_BUFFERS_OFFSET];
u32 left_view_buffer_addr;
u32 left_view_buffer_size;
u32 right_view_buffer_addr;
u32 right_view_buffer_size;
u32 disparity_map_buffer_addr;
u32 disparity_map_buffer_size;
u32 occlusion_mask_buffer_addr;
u32 occlusion_mask_buffer_size;
};
struct hfi_cmd_session_cvp_dme_config_packet {
u32 cvp_internal_dme_config[CVP_DME_CONFIG_CMD_SIZE];
};
struct hfi_cmd_session_cvp_dme_frame_packet {
u32 cvp_dme_frame[CVP_DME_FRAME_BUFFERS_OFFSET];
struct buf_desc bufs[8];
};
struct hfi_cmd_session_cvp_persist_packet {
u32 cvp_persist_frame[CVP_PERSIST_BUFFERS_OFFSET];
struct buf_desc bufs[CVP_PSRSIST_BUF_NUM];
};
struct hfi_cmd_session_release_buffer_packet {
@ -814,22 +822,6 @@ struct hfi_msg_session_release_buffers_done_packet {
u32 rg_buffer_info[1];
};
struct hfi_msg_session_register_buffers_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 client_data;
u32 error_type;
};
struct hfi_msg_session_unregister_buffers_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 client_data;
u32 error_type;
};
struct hfi_extradata_mb_quantization_payload {
u8 rg_mb_qp[1];
};

110
drivers/media/platform/msm/cvp/cvp_hfi_api.h
View File

@ -904,24 +904,6 @@ struct cvp_resource_hdr {
void *resource_handle;
};
struct cvp_register_buffer {
enum hal_buffer type;
u32 index;
u32 size;
u32 device_addr;
u32 response_required;
u32 client_data;
};
struct cvp_unregister_buffer {
enum hal_buffer type;
u32 index;
u32 size;
u32 device_addr;
u32 response_required;
u32 client_data;
};
struct cvp_buffer_addr_info {
enum hal_buffer buffer_type;
u32 buffer_size;
@ -1118,7 +1100,6 @@ enum hal_command_response {
HAL_SESSION_ABORT_DONE,
HAL_SESSION_STOP_DONE,
HAL_SESSION_CVP_OPERATION_CONFIG,
HAL_SESSION_CVP_DFS,
HAL_SESSION_FLUSH_DONE,
HAL_SESSION_SUSPEND_DONE,
HAL_SESSION_RESUME_DONE,
@ -1130,6 +1111,9 @@ enum hal_command_response {
HAL_SESSION_RELEASE_RESOURCE_DONE,
HAL_SESSION_DFS_CONFIG_CMD_DONE,
HAL_SESSION_DFS_FRAME_CMD_DONE,
HAL_SESSION_DME_CONFIG_CMD_DONE,
HAL_SESSION_DME_FRAME_CMD_DONE,
HAL_SESSION_PERSIST_CMD_DONE,
HAL_SESSION_PROPERTY_INFO,
HAL_SESSION_ERROR,
HAL_RESPONSE_UNUSED = 0x10000000,
@ -1278,8 +1262,6 @@ struct msm_cvp_cb_cmd_done {
struct cvp_hal_sys_init_done sys_init_done;
struct cvp_hal_session_init_done session_init_done;
struct hal_buffer_info buffer_info;
struct cvp_register_buffer regbuf;
struct cvp_unregister_buffer unregbuf;
union hal_get_property property;
enum hal_flush flush_type;
} data;
@ -1428,6 +1410,76 @@ struct hal_vbv_hdr_buf_size {
#define call_hfi_op(q, op, args...) \
(((q) && (q)->op) ? ((q)->op(args)) : 0)
/* DFS related structures */
struct msm_cvp_internal_dfsconfig {
struct list_head list;
struct msm_smem smem;
struct msm_cvp_dfs_config dfs_config;
};
struct buf_desc {
u32 fd;
u32 size;
};
/**
* struct msm_cvp_dfs_frame_kmd - argument passed with VIDIOC_CVP_CMD
* @cvp_dfs_frame: parameters for DFS frame command
* @left_view_buffer_fd: fd for left view buffer
* @left_view_buffer_size: size for left view buffer
* @right_view_buffer_fd: fd for right view buffer
* @right_view_buffer_size: size for right view buffer
* @disparity_map_buffer_fd: fd for disparity map buffer
* @disparity_map_buffer_size: size for disparity map buffer
* @occlusion_mask_buffer_fd: fd for occlusion mask buffer
* @occlusion_mask_buffer_size: size for occlusion mask buffer
*/
struct msm_cvp_dfs_frame_kmd {
unsigned int cvp_dfs_frame[CVP_DFS_FRAME_BUFFERS_OFFSET];
unsigned int left_view_buffer_fd;
unsigned int left_view_buffer_size;
unsigned int right_view_buffer_fd;
unsigned int right_view_buffer_size;
unsigned int disparity_map_buffer_fd;
unsigned int disparity_map_buffer_size;
unsigned int occlusion_mask_buffer_fd;
unsigned int occlusion_mask_buffer_size;
};
struct msm_cvp_internal_dfsframe {
struct list_head list;
struct msm_cvp_dfs_frame_kmd dfs_frame;
};
/* DME related structures */
struct msm_cvp_internal_dmeconfig {
struct list_head list;
struct msm_smem smem;
struct msm_cvp_dme_config dme_config;
};
struct msm_cvp_dme_frame_kmd {
unsigned int cvp_dme_frame[CVP_DME_FRAME_BUFFERS_OFFSET];
struct buf_desc bufs[CVP_DME_BUF_NUM];
};
struct msm_cvp_internal_dmeframe {
struct list_head list;
struct msm_cvp_dme_frame_kmd dme_frame;
};
struct msm_cvp_persist_kmd {
unsigned int cvp_pcmd[CVP_PERSIST_BUFFERS_OFFSET];
struct buf_desc bufs[CVP_PSRSIST_BUF_NUM];
};
struct msm_cvp_internal_persist_cmd {
struct list_head list;
struct msm_cvp_persist_kmd persist_cmd;
};
struct hfi_device {
void *hfi_device_data;
@ -1445,10 +1497,6 @@ struct hfi_device {
struct cvp_buffer_addr_info *buffer_info);
int (*session_release_buffers)(void *sess,
struct cvp_buffer_addr_info *buffer_info);
int (*session_register_buffer)(void *sess,
struct cvp_register_buffer *buffer);
int (*session_unregister_buffer)(void *sess,
struct cvp_unregister_buffer *buffer);
int (*session_load_res)(void *sess);
int (*session_release_res)(void *sess);
int (*session_start)(void *sess);
@ -1457,11 +1505,15 @@ struct hfi_device {
int (*session_cvp_operation_config)(void *sess,
struct cvp_frame_data *input_frame);
int (*session_cvp_dfs_config)(void *sess,
struct msm_cvp_dfsconfig *dfs_config);
struct msm_cvp_internal_dfsconfig *dfs_config);
int (*session_cvp_dfs_frame)(void *sess,
struct msm_cvp_dfsframe *dfs_frame);
int (*session_cvp_send_cmd)(void *sess,
struct cvp_frame_data *input_frame);
struct msm_cvp_internal_dfsframe *dfs_frame);
int (*session_cvp_dme_config)(void *sess,
struct msm_cvp_internal_dmeconfig *dme_config);
int (*session_cvp_dme_frame)(void *sess,
struct msm_cvp_internal_dmeframe *dme_frame);
int (*session_cvp_persist)(void *sess,
struct msm_cvp_internal_persist_cmd *pbuf_cmd);
int (*session_get_buf_req)(void *sess);
int (*session_flush)(void *sess, enum hal_flush flush_mode);
int (*session_set_property)(void *sess, enum hal_property ptype,

82
drivers/media/platform/msm/cvp/cvp_hfi_helper.h
View File

@ -1036,26 +1036,6 @@ struct hfi_buffer_mapping_type {
u32 size;
};
struct hfi_cmd_session_register_buffers_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 client_data;
u32 response_req;
u32 num_buffers;
struct hfi_buffer_mapping_type buffer[1];
};
struct hfi_cmd_session_unregister_buffers_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 client_data;
u32 response_req;
u32 num_buffers;
struct hfi_buffer_mapping_type buffer[1];
};
struct hfi_cmd_session_sync_process_packet {
u32 size;
u32 packet_type;
@ -1084,24 +1064,76 @@ struct hfi_msg_session_cvp_operation_config_done_packet_type {
u32 size;
u32 packet_type;
u32 session_id;
struct hfi_cvp_client_data client_data;
u32 op_conf_id;
u32 error_type;
struct hfi_cvp_client_data client_data;
};
struct hfi_msg_session_cvp_dfs_packet_type {
u32 size;
u32 packet_type;
u32 session_id;
struct hfi_cvp_client_data client_data;
u32 error_type;
u32 left_view_buffer_index;
u32 right_view_buffer_index;
u32 width;
u32 height;
u32 occlusionmask_enable;
u32 disparitymap_buffer_idx;
u32 occlusionmask_buffer_idx;
u32 left_view_buf_addr;
u32 left_view_buf_size;
u32 right_view_buf_addr;
u32 right_view_buf_size;
u32 disparity_map_buf_addr;
u32 disparity_map_buf_size;
u32 occ_mask_buf_addr;
u32 occ_mask_buf_size;
};
struct hfi_msg_session_cvp_dme_packet_type {
u32 size;
u32 packet_type;
u32 session_id;
struct hfi_cvp_client_data client_data;
u32 error_type;
u32 skip_mv_calc;
u32 src_buf_addr;
u32 src_buf_size;
u32 nSrcBuffer_size;
u32 src_frame_ctx_buf_addr;
u32 src_frame_ctx_buf_size;
u32 ref_buf_addr;
u32 ref_buf_size;
u32 ref_frame_ctxt_buf_addr;
u32 ref_frame_ctxt_buf_size;
u32 video_spatial_temp_status_buf_addr;
u32 video_spatial_temp_status_buf_size;
u32 full_res_height;
u32 full_res_width;
u32 proc_frame_width;
u32 proc_frame_height;
u32 transform_confidence;
u32 frame_sum_gradient;
u32 frame_sum_square_gradient1;
u32 frame_sum_square_gradient2;
u16 n_luma_hist[8];
s32 mvx_sum;
s32 mvy_Sum;
u32 num_mvs;
s32 final_transform[9];
s32 pad;
s64 transform[9];
};
struct hfi_msg_session_cvp_persist_packet_type {
u32 size;
u32 packet_type;
u32 session_id;
struct hfi_cvp_client_data client_data;
u32 error_type;
u32 cvp_op;
u32 persist1_buffer_fd;
u32 persist1_size;
u32 persist2_fd;
u32 persist2_size;
};
struct hfi_msg_release_buffer_ref_event_packet {

322
drivers/media/platform/msm/cvp/hfi_packetization.c
View File

@ -673,72 +673,6 @@ int cvp_create_pkt_cmd_session_release_buffers(
return 0;
}
int cvp_create_pkt_cmd_session_register_buffer(
struct hfi_cmd_session_register_buffers_packet *pkt,
struct hal_session *session,
struct cvp_register_buffer *buffer)
{
int rc = 0, i;
struct hfi_buffer_mapping_type *buf;
if (!pkt || !session) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
pkt->packet_type = HFI_CMD_SESSION_REGISTER_BUFFERS;
pkt->session_id = hash32_ptr(session);
pkt->client_data = buffer->client_data;
pkt->response_req = buffer->response_required;
pkt->num_buffers = 1;
pkt->size = sizeof(struct hfi_cmd_session_register_buffers_packet) -
sizeof(u32) + (pkt->num_buffers *
sizeof(struct hfi_buffer_mapping_type));
buf = (struct hfi_buffer_mapping_type *)pkt->buffer;
for (i = 0; i < pkt->num_buffers; i++) {
buf->index = buffer->index;
buf->device_addr = buffer->device_addr;
buf->size = buffer->size;
buf++;
}
return rc;
}
int cvp_create_pkt_cmd_session_unregister_buffer(
struct hfi_cmd_session_unregister_buffers_packet *pkt,
struct hal_session *session,
struct cvp_unregister_buffer *buffer)
{
int rc = 0, i;
struct hfi_buffer_mapping_type *buf;
if (!pkt || !session) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
pkt->packet_type = HFI_CMD_SESSION_UNREGISTER_BUFFERS;
pkt->session_id = hash32_ptr(session);
pkt->client_data = buffer->client_data;
pkt->response_req = buffer->response_required;
pkt->num_buffers = 1;
pkt->size = sizeof(struct hfi_cmd_session_unregister_buffers_packet) -
sizeof(u32) + (pkt->num_buffers *
sizeof(struct hfi_buffer_mapping_type));
buf = (struct hfi_buffer_mapping_type *)pkt->buffer;
for (i = 0; i < pkt->num_buffers; i++) {
buf->index = buffer->index;
buf->device_addr = buffer->device_addr;
buf->size = buffer->size;
buf++;
}
return rc;
}
int cvp_create_pkt_cmd_session_etb_decoder(
struct hfi_cmd_session_empty_buffer_compressed_packet *pkt,
struct hal_session *session, struct cvp_frame_data *input_frame)
@ -865,131 +799,167 @@ int cvp_create_pkt_cmd_session_get_buf_req(
}
int cvp_create_pkt_cmd_session_cvp_dfs_config(
struct hfi_cmd_session_cvp_dfs_config *pkt,
struct hfi_cmd_session_cvp_dfs_config_packet *pkt,
struct hal_session *session,
struct msm_cvp_dfsconfig *dfs_config)
struct msm_cvp_internal_dfsconfig *dfs_config)
{
int rc = 0, i = 0;
struct hfi_cmd_session_hdr *ptr =
(struct hfi_cmd_session_hdr *)pkt;
if (!pkt || !session)
return -EINVAL;
pkt->size = sizeof(struct hfi_cmd_session_cvp_dfs_config);
pkt->packet_type = HFI_CMD_SESSION_CVP_DFS_CONFIG;
pkt->session_id = hash32_ptr(session);
pkt->srcbuffer_format = dfs_config->srcbuffer_format;
for (i = 0; i < HFI_MAX_PLANES; i++) {
pkt->left_plane_info.stride[i] =
dfs_config->left_plane_info.stride[i];
pkt->left_plane_info.buf_size[i] =
dfs_config->left_plane_info.buf_size[i];
pkt->right_plane_info.stride[i] =
dfs_config->right_plane_info.stride[i];
pkt->right_plane_info.buf_size[i] =
dfs_config->right_plane_info.buf_size[i];
}
pkt->width = dfs_config->width;
pkt->height = dfs_config->height;
pkt->occlusionmask_enable = dfs_config->occlusionmask_enable;
pkt->occlusioncost = dfs_config->occlusioncost;
pkt->occlusionbound = dfs_config->occlusionbound;
pkt->occlusionshift = dfs_config->occlusionshift;
pkt->maxdisparity = dfs_config->maxdisparity;
pkt->disparityoffset = dfs_config->disparityoffset;
pkt->medianfilter_enable = dfs_config->medianfilter_enable;
pkt->occlusionfilling_enable = dfs_config->occlusionfilling_enable;
pkt->occlusionmaskdump = dfs_config->occlusionmaskdump;
pkt->clientdata.transactionid =
dfs_config->clientdata.transactionid;
pkt->clientdata.client_data1 =
dfs_config->clientdata.client_data1;
pkt->clientdata.client_data2 =
dfs_config->clientdata.client_data2;
memcpy(pkt, &dfs_config->dfs_config,
CVP_DFS_CONFIG_CMD_SIZE*sizeof(unsigned int));
dprintk(CVP_DBG,
"%s: size=%d packet_type=%d session_id=%d height=%d", __func__,
pkt->size, pkt->packet_type, pkt->session_id, pkt->height);
dprintk(CVP_DBG,
"occlusionmask_enable=%d occlusioncost=%d occlusionbound=%d",
pkt->occlusionmask_enable, pkt->occlusioncost,
pkt->occlusionbound);
dprintk(CVP_DBG,
"occlusionshift=%d maxdisparity=%d disparityoffset=%d",
pkt->occlusionshift, pkt->maxdisparity,
pkt->disparityoffset);
dprintk(CVP_DBG,
"medianfilter_enable=%d occlusionfilling_enable=%d occlusionmaskdump=%d",
pkt->medianfilter_enable, pkt->occlusionfilling_enable,
pkt->occlusionmaskdump);
dprintk(CVP_DBG,
"left_plane_info.ActualStride[HFI_COLOR_PLANE_PICDATA]:%u",
pkt->left_plane_info.stride[HFI_COLOR_PLANE_PICDATA]
);
dprintk(CVP_DBG,
"LeftViewColPlaneInfo.ActualStride[HFI_COLOR_PLANE_METADATA]:%u",
pkt->left_plane_info.stride[HFI_COLOR_PLANE_METADATA]
);
dprintk(CVP_DBG,
"LeftViewColPlaneInfo.ActualBufSize[HFI_COLOR_PLANE_PICDATA]:%u,",
pkt->left_plane_info.buf_size[HFI_COLOR_PLANE_PICDATA]
);
dprintk(CVP_DBG,
"LeftViewColPlaneInfo.ActualBufSize[HFI_COLOR_PLANE_METADATA]%u",
pkt->left_plane_info.buf_size[HFI_COLOR_PLANE_METADATA]
);
dprintk(CVP_DBG,
"RightViewColPlaneInfo:stride[HFI_COLOR_PLANE_PICDATA]:%u",
pkt->right_plane_info.stride[HFI_COLOR_PLANE_PICDATA]
);
dprintk(CVP_DBG,
"RightViewColPlaneInfo.stride[HFI_COLOR_PLANE_METADATA]:%u",
pkt->right_plane_info.stride[HFI_COLOR_PLANE_METADATA]
);
dprintk(CVP_DBG,
"RightViewColPlaneInfo.ActualBufSize[HFI_COLOR_PLANE_PICDATA] :%u",
pkt->right_plane_info.buf_size[HFI_COLOR_PLANE_PICDATA]
);
dprintk(CVP_DBG,
"RightViewColPlaneInfo.ActualBufSize[HFI_COLOR_PLANE_METADATA] %u",
pkt->right_plane_info.buf_size[HFI_COLOR_PLANE_METADATA]
);
if (ptr->size != CVP_DFS_CONFIG_CMD_SIZE*sizeof(unsigned int))
goto error_dfs_config;
return rc;
if (ptr->packet_type != HFI_CMD_SESSION_CVP_DFS_CONFIG)
goto error_dfs_config;
if (ptr->session_id != hash32_ptr(session))
goto error_dfs_config;
return 0;
error_dfs_config:
dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",
__func__, ptr->size, ptr->packet_type, ptr->session_id);
return -EINVAL;
}
int cvp_create_pkt_cmd_session_cvp_dfs_frame(
struct hfi_cmd_session_cvp_dfs_frame *pkt,
struct hfi_cmd_session_cvp_dfs_frame_packet *pkt,
struct hal_session *session,
struct msm_cvp_dfsframe *dfs_frame)
struct msm_cvp_internal_dfsframe *dfs_frame)
{
int rc = 0;
struct hfi_cmd_session_hdr *ptr =
(struct hfi_cmd_session_hdr *)pkt;
if (!pkt || !session)
return -EINVAL;
pkt->size = sizeof(struct hfi_cmd_session_cvp_dfs_frame);
pkt->packet_type = HFI_CMD_SESSION_CVP_DFS_FRAME;
pkt->session_id = hash32_ptr(session);
pkt->left_buffer_index = dfs_frame->left_buffer_index;
pkt->right_buffer_index = dfs_frame->right_buffer_index;
pkt->disparitymap_buffer_idx = dfs_frame->disparitymap_buffer_idx;
pkt->occlusionmask_buffer_idx = dfs_frame->occlusionmask_buffer_idx;
pkt->clientdata.transactionid = dfs_frame->clientdata.transactionid;
pkt->clientdata.client_data1 = dfs_frame->clientdata.client_data1;
memcpy(pkt, &dfs_frame->dfs_frame,
CVP_DFS_FRAME_CMD_SIZE*sizeof(unsigned int));
dprintk(CVP_DBG,
"%s: size=%d, packet_type=%d session_id=%d left_buffer_index=%d",
__func__, pkt->size, pkt->packet_type, pkt->session_id,
pkt->left_buffer_index);
dprintk(CVP_DBG,
"right_buffer_index=%d disparitymap_buffer_idx=%d",
pkt->right_buffer_index, pkt->disparitymap_buffer_idx);
dprintk(CVP_DBG,
"occlusionmask_buffer_idx=%d ",
pkt->occlusionmask_buffer_idx);
if (ptr->size != CVP_DFS_FRAME_CMD_SIZE*sizeof(unsigned int))
goto error_dfs_frame;
if (ptr->packet_type != HFI_CMD_SESSION_CVP_DFS_FRAME)
goto error_dfs_frame;
if (ptr->session_id != hash32_ptr(session))
goto error_dfs_frame;
return 0;
error_dfs_frame:
dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",
__func__, ptr->size, ptr->packet_type, ptr->session_id);
return -EINVAL;
}
int cvp_create_pkt_cmd_session_cvp_dme_config(
struct hfi_cmd_session_cvp_dme_config_packet *pkt,
struct hal_session *session,
struct msm_cvp_internal_dmeconfig *dme_config)
{
struct hfi_cmd_session_hdr *ptr =
(struct hfi_cmd_session_hdr *)pkt;
if (!pkt || !session)
return -EINVAL;
memcpy(pkt, &dme_config->dme_config,
CVP_DME_CONFIG_CMD_SIZE*sizeof(unsigned int));
if (ptr->size != CVP_DME_CONFIG_CMD_SIZE*sizeof(unsigned int))
goto error_dme_config;
if (ptr->packet_type != HFI_CMD_SESSION_CVP_DME_CONFIG)
goto error_dme_config;
if (ptr->session_id != hash32_ptr(session))
goto error_dme_config;
return 0;
error_dme_config:
dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",
__func__, ptr->size, ptr->packet_type, ptr->session_id);
return -EINVAL;
}
int cvp_create_pkt_cmd_session_cvp_dme_frame(
struct hfi_cmd_session_cvp_dme_frame_packet *pkt,
struct hal_session *session,
struct msm_cvp_internal_dmeframe *dme_frame)
{
struct hfi_cmd_session_hdr *ptr =
(struct hfi_cmd_session_hdr *)pkt;
if (!pkt || !session)
return -EINVAL;
memcpy(pkt, &dme_frame->dme_frame,
CVP_DME_FRAME_CMD_SIZE*sizeof(unsigned int));
if (ptr->size != CVP_DME_FRAME_CMD_SIZE*sizeof(unsigned int))
goto error_dme_frame;
if (ptr->packet_type != HFI_CMD_SESSION_CVP_DME_FRAME)
goto error_dme_frame;
if (ptr->session_id != hash32_ptr(session))
goto error_dme_frame;
return 0;
error_dme_frame:
dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",
__func__, ptr->size, ptr->packet_type, ptr->session_id);
return -EINVAL;
}
int cvp_create_pckt_cmd_session_cvp_persist(
struct hfi_cmd_session_cvp_persist_packet *pkt,
struct hal_session *session,
struct msm_cvp_internal_persist_cmd *pbuf_cmd)
{
struct hfi_cmd_session_hdr *ptr =
(struct hfi_cmd_session_hdr *)pkt;
if (!pkt || !session)
return -EINVAL;
memcpy(pkt, &pbuf_cmd->persist_cmd,
CVP_PERSIST_CMD_SIZE*sizeof(unsigned int));
if (ptr->size != CVP_PERSIST_CMD_SIZE*sizeof(unsigned int))
goto error_persist;
if (ptr->packet_type != HFI_CMD_SESSION_CVP_SET_PERSIST_BUFFERS)
goto error_persist;
if (ptr->session_id != hash32_ptr(session))
goto error_persist;
return 0;
error_persist:
dprintk(CVP_ERR, "%s: size=%d type=%d sessionid=%d\n",
__func__, ptr->size, ptr->packet_type, ptr->session_id);
return -EINVAL;
return rc;
}
@ -2189,10 +2159,6 @@ static struct hfi_packetization_ops hfi_default = {
cvp_create_pkt_cmd_session_set_buffers,
.session_release_buffers =
cvp_create_pkt_cmd_session_release_buffers,
.session_register_buffer =
cvp_create_pkt_cmd_session_register_buffer,
.session_unregister_buffer =
cvp_create_pkt_cmd_session_unregister_buffer,
.session_etb_decoder = cvp_create_pkt_cmd_session_etb_decoder,
.session_etb_encoder = cvp_create_pkt_cmd_session_etb_encoder,
.session_ftb = cvp_create_pkt_cmd_session_ftb,
@ -2204,6 +2170,12 @@ static struct hfi_packetization_ops hfi_default = {
cvp_create_pkt_cmd_session_cvp_dfs_config,
.session_cvp_dfs_frame =
cvp_create_pkt_cmd_session_cvp_dfs_frame,
.session_cvp_dme_config =
cvp_create_pkt_cmd_session_cvp_dme_config,
.session_cvp_dme_frame =
cvp_create_pkt_cmd_session_cvp_dme_frame,
.session_cvp_persist =
cvp_create_pckt_cmd_session_cvp_persist,
};
struct hfi_packetization_ops *cvp_hfi_get_pkt_ops_handle(

28
drivers/media/platform/msm/cvp/hfi_packetization.h
View File

@ -51,14 +51,6 @@ struct hfi_packetization_ops {
struct hfi_cmd_session_cvp_release_buffers_packet *pkt,
struct hal_session *session,
struct cvp_buffer_addr_info *buffer_info);
int (*session_register_buffer)(
struct hfi_cmd_session_register_buffers_packet *pkt,
struct hal_session *session,
struct cvp_register_buffer *buffer);
int (*session_unregister_buffer)(
struct hfi_cmd_session_unregister_buffers_packet *pkt,
struct hal_session *session,
struct cvp_unregister_buffer *buffer);
int (*session_etb_decoder)(
struct hfi_cmd_session_empty_buffer_compressed_packet *pkt,
struct hal_session *session,
@ -86,13 +78,25 @@ struct hfi_packetization_ops {
struct hfi_cmd_session_sync_process_packet *pkt,
struct hal_session *session);
int (*session_cvp_dfs_config)(
struct hfi_cmd_session_cvp_dfs_config *pkt,
struct hfi_cmd_session_cvp_dfs_config_packet *pkt,
struct hal_session *session,
struct msm_cvp_dfsconfig *dfs_config);
struct msm_cvp_internal_dfsconfig *dfs_config);
int (*session_cvp_dfs_frame)(
struct hfi_cmd_session_cvp_dfs_frame *pkt,
struct hfi_cmd_session_cvp_dfs_frame_packet *pkt,
struct hal_session *session,
struct msm_cvp_dfsframe *dfs_frame);
struct msm_cvp_internal_dfsframe *dfs_frame);
int (*session_cvp_dme_config)(
struct hfi_cmd_session_cvp_dme_config_packet *pkt,
struct hal_session *session,
struct msm_cvp_internal_dmeconfig *dme_config);
int (*session_cvp_dme_frame)(
struct hfi_cmd_session_cvp_dme_frame_packet *pkt,
struct hal_session *session,
struct msm_cvp_internal_dmeframe *dme_frame);
int (*session_cvp_persist)(
struct hfi_cmd_session_cvp_persist_packet *pkt,
struct hal_session *session,
struct msm_cvp_internal_persist_cmd *pbuf_cmd);
};
struct hfi_packetization_ops *cvp_hfi_get_pkt_ops_handle(

154
drivers/media/platform/msm/cvp/hfi_response_handler.c
View File

@ -743,61 +743,6 @@ static int hfi_process_session_init_done(u32 device_id,
return 0;
}
static int hfi_process_session_register_buffer_done(u32 device_id,
struct hfi_msg_session_register_buffers_done_packet *pkt,
struct msm_cvp_cb_info *info)
{
struct msm_cvp_cb_cmd_done cmd_done = {0};
if (!pkt || pkt->size <
sizeof(struct hfi_msg_session_register_buffers_done_packet)) {
dprintk(CVP_ERR, "%s: bad packet/packet size %d\n",
__func__, pkt ? pkt->size : 0);
return -E2BIG;
}
dprintk(CVP_DBG, "RECEIVED: SESSION_REGISTER_BUFFERS_DONE[%#x]\n",
pkt->session_id);
cmd_done.device_id = device_id;
cmd_done.size = sizeof(struct msm_cvp_cb_cmd_done);
cmd_done.session_id = (void *)(uintptr_t)pkt->session_id;
cmd_done.status = hfi_map_err_status(pkt->error_type);
cmd_done.data.regbuf.client_data = pkt->client_data;
info->response_type = HAL_SESSION_REGISTER_BUFFER_DONE;
info->response.cmd = cmd_done;
return 0;
}
static int hfi_process_session_unregister_buffer_done(u32 device_id,
struct hfi_msg_session_unregister_buffers_done_packet *pkt,
struct msm_cvp_cb_info *info)
{
struct msm_cvp_cb_cmd_done cmd_done = {0};
if (!pkt || pkt->size <
sizeof(struct hfi_msg_session_unregister_buffers_done_packet)) {
dprintk(CVP_ERR, "%s: bad packet/packet size %d\n",
__func__, pkt ? pkt->size : 0);
return -E2BIG;
}
dprintk(CVP_DBG, "RECEIVED: SESSION_UNREGISTER_BUFFERS_DONE[%#x]\n",
pkt->session_id);
cmd_done.device_id = device_id;
cmd_done.size = sizeof(struct msm_cvp_cb_cmd_done);
cmd_done.session_id = (void *)(uintptr_t)pkt->session_id;
cmd_done.status = hfi_map_err_status(pkt->error_type);
cmd_done.data.unregbuf.client_data = pkt->client_data;
info->response_type = HAL_SESSION_UNREGISTER_BUFFER_DONE;
info->response.cmd = cmd_done;
return 0;
}
static int hfi_process_session_end_done(u32 device_id,
struct hfi_msg_sys_session_end_done_packet *pkt,
struct msm_cvp_cb_info *info)
@ -924,9 +869,22 @@ static int hfi_process_session_cvp_operation_config(u32 device_id,
cmd_done.status = hfi_map_err_status(pkt->error_type);
cmd_done.size = 0;
dprintk(CVP_DBG, "%s: device_id=%d cmd_done.status=%d\n",
__func__, device_id, cmd_done.status);
dprintk(CVP_DBG,
"%s: device_id=%d status=%d, sessionid=%x config=%x\n",
__func__, device_id, cmd_done.status,
cmd_done.session_id, pkt->op_conf_id);
switch (pkt->op_conf_id) {
case HFI_CMD_SESSION_CVP_DFS_CONFIG:
info->response_type = HAL_SESSION_DFS_CONFIG_CMD_DONE;
break;
case HFI_CMD_SESSION_CVP_DME_CONFIG:
info->response_type = HAL_SESSION_DME_CONFIG_CMD_DONE;
break;
default:
dprintk(CVP_ERR, "%s Invalid op config id\n", __func__);
return -EINVAL;
}
info->response.cmd = cmd_done;
return 0;
}
@ -951,14 +909,73 @@ static int hfi_process_session_cvp_dfs(u32 device_id,
cmd_done.status = hfi_map_err_status(pkt->error_type);
cmd_done.size = 0;
dprintk(CVP_DBG, "%s: device_id=%d cmd_done.status=%d\n",
__func__, device_id, cmd_done.status);
dprintk(CVP_DBG,
"%s: device_id=%d cmd_done.status=%d sessionid=%x\n",
__func__, device_id, cmd_done.status, cmd_done.session_id);
info->response_type = HAL_SESSION_DFS_FRAME_CMD_DONE;
info->response.cmd = cmd_done;
return 0;
}
static int hfi_process_session_cvp_dme(u32 device_id,
struct hfi_msg_session_cvp_dme_packet_type *pkt,
struct msm_cvp_cb_info *info)
{
struct msm_cvp_cb_cmd_done cmd_done = {0};
if (!pkt) {
dprintk(CVP_ERR, "%s: invalid param\n", __func__);
return -EINVAL;
} else if (pkt->size < sizeof(*pkt)) {
dprintk(CVP_ERR,
"%s: bad_pkt_size\n", __func__);
return -E2BIG;
}
cmd_done.device_id = device_id;
cmd_done.session_id = (void *)(uintptr_t)pkt->session_id;
cmd_done.status = hfi_map_err_status(pkt->error_type);
cmd_done.size = 0;
dprintk(CVP_DBG,
"%s: device_id=%d cmd_done.status=%d sessionid=%x\n",
__func__, device_id, cmd_done.status, cmd_done.session_id);
info->response_type = HAL_SESSION_DME_FRAME_CMD_DONE;
info->response.cmd = cmd_done;
return 0;
}
static int hfi_process_session_cvp_persist(u32 device_id,
struct hfi_msg_session_cvp_persist_packet_type *pkt,
struct msm_cvp_cb_info *info)
{
struct msm_cvp_cb_cmd_done cmd_done = {0};
if (!pkt) {
dprintk(CVP_ERR, "%s: invalid param\n", __func__);
return -EINVAL;
} else if (pkt->size < sizeof(*pkt)) {
dprintk(CVP_ERR,
"%s: bad_pkt_size\n", __func__);
return -E2BIG;
}
cmd_done.device_id = device_id;
cmd_done.session_id = (void *)(uintptr_t)pkt->session_id;
cmd_done.status = hfi_map_err_status(pkt->error_type);
cmd_done.size = 0;
dprintk(CVP_DBG,
"%s: device_id=%d cmd_done.status=%d sessionid=%x\n",
__func__, device_id, cmd_done.status, cmd_done.session_id);
info->response_type = HAL_SESSION_PERSIST_CMD_DONE,
info->response.cmd = cmd_done;
return 0;
}
static void hfi_process_sys_get_prop_image_version(
struct hfi_msg_sys_property_info_packet *pkt)
{
@ -1065,20 +1082,12 @@ int cvp_hfi_process_msg_packet(u32 device_id,
case HFI_MSG_SYS_SESSION_END_DONE:
pkt_func = (pkt_func_def)hfi_process_session_end_done;
break;
case HFI_MSG_SESSION_REGISTER_BUFFERS_DONE:
pkt_func = (pkt_func_def)
hfi_process_session_register_buffer_done;
break;
case HFI_MSG_SESSION_CVP_SET_BUFFERS:
pkt_func = (pkt_func_def) hfi_process_session_set_buf_done;
break;
case HFI_MSG_SESSION_CVP_RELEASE_BUFFERS:
pkt_func = (pkt_func_def)hfi_process_session_rel_buf_done;
break;
case HFI_MSG_SESSION_UNREGISTER_BUFFERS_DONE:
pkt_func = (pkt_func_def)
hfi_process_session_unregister_buffer_done;
break;
case HFI_MSG_SYS_SESSION_ABORT_DONE:
pkt_func = (pkt_func_def)hfi_process_session_abort_done;
break;
@ -1093,6 +1102,17 @@ int cvp_hfi_process_msg_packet(u32 device_id,
"Received HFI_MSG_SESSION_CVP_DFS from firmware");
pkt_func = (pkt_func_def)hfi_process_session_cvp_dfs;
break;
case HFI_MSG_SESSION_CVP_DME:
dprintk(CVP_DBG,
"Received HFI_MSG_SESSION_CVP_DME from firmware");
pkt_func = (pkt_func_def)hfi_process_session_cvp_dme;
break;
case HFI_MSG_SESSION_CVP_SET_PERSIST_BUFFERS:
dprintk(CVP_DBG,
"Received HFI_MSG_SESSION_CVP_PERSIST from firmware");
pkt_func = (pkt_func_def)hfi_process_session_cvp_persist;
break;
default:
dprintk(CVP_DBG, "Unable to parse message: %#x\n",
msg_hdr->packet);

659
drivers/media/platform/msm/cvp/msm_cvp.c
View File

@ -57,171 +57,6 @@ static enum hal_buffer get_hal_buftype(const char *str, unsigned int type)
return buftype;
}
void cvp_handle_session_register_buffer_done(enum hal_command_response cmd,
void *resp)
{
struct msm_cvp_cb_cmd_done *response = resp;
struct msm_cvp_inst *inst;
struct msm_cvp_internal_buffer *cbuf;
struct v4l2_event event = {0};
u32 *data;
bool found;
if (!response) {
dprintk(CVP_ERR, "%s: invalid response\n", __func__);
return;
}
inst = cvp_get_inst(get_cvp_core(response->device_id),
response->session_id);
if (!inst) {
dprintk(CVP_ERR, "%s: invalid session %pK\n", __func__,
response->session_id);
return;
}
mutex_lock(&inst->cvpbufs.lock);
found = false;
list_for_each_entry(cbuf, &inst->cvpbufs.list, list) {
if (response->data.regbuf.client_data ==
cbuf->smem.device_addr) {
found = true;
break;
}
}
mutex_unlock(&inst->cvpbufs.lock);
if (!found) {
dprintk(CVP_ERR, "%s: client_data %x not found\n",
__func__, response->data.regbuf.client_data);
goto exit;
}
print_cvp_internal_buffer(CVP_DBG, "register_done", inst, cbuf);
event.type = V4L2_EVENT_MSM_CVP_REGISTER_BUFFER_DONE;
data = (u32 *)event.u.data;
data[0] = cbuf->buf.index;
data[1] = cbuf->buf.type;
data[2] = cbuf->buf.fd;
data[3] = cbuf->buf.offset;
v4l2_event_queue_fh(&inst->event_handler, &event);
exit:
cvp_put_inst(inst);
}
void cvp_handle_session_unregister_buffer_done(enum hal_command_response cmd,
void *resp)
{
int rc;
struct msm_cvp_cb_cmd_done *response = resp;
struct msm_cvp_inst *inst;
struct msm_cvp_internal_buffer *cbuf, *dummy;
struct v4l2_event event = {0};
u32 *data;
bool found;
if (!response) {
dprintk(CVP_ERR, "%s: invalid response\n", __func__);
return;
}
inst = cvp_get_inst(get_cvp_core(response->device_id),
response->session_id);
if (!inst) {
dprintk(CVP_ERR, "%s: invalid session %pK\n", __func__,
response->session_id);
return;
}
mutex_lock(&inst->cvpbufs.lock);
found = false;
list_for_each_entry_safe(cbuf, dummy, &inst->cvpbufs.list, list) {
if (response->data.unregbuf.client_data ==
cbuf->smem.device_addr) {
found = true;
break;
}
}
mutex_unlock(&inst->cvpbufs.lock);
if (!found) {
dprintk(CVP_ERR, "%s: client_data %x not found\n",
__func__, response->data.unregbuf.client_data);
goto exit;
}
print_cvp_internal_buffer(CVP_DBG, "unregister_done", inst, cbuf);
rc = msm_cvp_smem_unmap_dma_buf(inst, &cbuf->smem);
if (rc) {
print_cvp_internal_buffer(CVP_ERR, "unmap fail", inst, cbuf);
goto exit;
}
event.type = V4L2_EVENT_MSM_CVP_UNREGISTER_BUFFER_DONE;
data = (u32 *)event.u.data;
data[0] = cbuf->buf.index;
data[1] = cbuf->buf.type;
data[2] = cbuf->buf.fd;
data[3] = cbuf->buf.offset;
v4l2_event_queue_fh(&inst->event_handler, &event);
mutex_lock(&inst->cvpbufs.lock);
list_del(&cbuf->list);
mutex_unlock(&inst->cvpbufs.lock);
kfree(cbuf);
cbuf = NULL;
exit:
cvp_put_inst(inst);
}
static void print_cvp_cycles(struct msm_cvp_inst *inst)
{
struct msm_cvp_core *core;
struct msm_cvp_inst *temp;
if (!inst || !inst->core)
return;
core = inst->core;
mutex_lock(&core->lock);
list_for_each_entry(temp, &core->instances, list) {
if (temp->session_type == MSM_CVP_CORE) {
dprintk(CVP_ERR, "session %#x, vpss %d ise %d\n",
hash32_ptr(temp->session),
temp->clk_data.vpss_cycles,
temp->clk_data.ise_cycles);
}
}
mutex_unlock(&core->lock);
}
static bool msm_cvp_clock_aggregation(struct msm_cvp_inst *inst,
u32 vpss_cycles, u32 ise_cycles)
{
struct msm_cvp_core *core;
struct msm_cvp_inst *temp;
u32 total_vpss_cycles = 0;
u32 total_ise_cycles = 0;
if (!inst || !inst->core) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return false;
}
core = inst->core;
mutex_lock(&core->lock);
list_for_each_entry(temp, &core->instances, list) {
if (temp->session_type == MSM_CVP_CORE) {
total_vpss_cycles += inst->clk_data.vpss_cycles;
total_ise_cycles += inst->clk_data.ise_cycles;
}
}
mutex_unlock(&core->lock);
if ((total_vpss_cycles > MAX_CVP_VPSS_CYCLES) ||
(total_ise_cycles > MAX_CVP_ISE_CYCLES))
return false;
return true;
}
static int msm_cvp_scale_clocks_and_bus(struct msm_cvp_inst *inst)
{
int rc = 0;
@ -267,13 +102,45 @@ static int msm_cvp_get_session_info(struct msm_cvp_inst *inst,
return rc;
}
static int msm_cvp_session_get_iova_addr(
struct msm_cvp_inst *inst,
struct msm_cvp_internal_buffer *cbuf,
unsigned int search_fd, unsigned int search_size,
unsigned int *iova,
unsigned int *iova_size)
{
bool found = false;
mutex_lock(&inst->cvpbufs.lock);
list_for_each_entry(cbuf, &inst->cvpbufs.list, list) {
if (cbuf->buf.fd == search_fd) {
found = true;
break;
}
}
mutex_unlock(&inst->cvpbufs.lock);
if (!found)
return -EINVAL;
*iova = cbuf->smem.device_addr;
if (search_size != cbuf->buf.size) {
dprintk(CVP_ERR,
"%s:: invalid size received fd = %d\n",
__func__, search_fd);
return -EINVAL;
}
*iova_size = cbuf->buf.size;
return 0;
}
/* DFS feature system call handling */
static int msm_cvp_session_cvp_dfs_config(
struct msm_cvp_inst *inst,
struct msm_cvp_dfsconfig *dfs_config)
struct msm_cvp_dfs_config *dfs_config)
{
int rc = 0;
struct hfi_device *hdev;
struct msm_cvp_dfsconfig vdfs_config;
struct msm_cvp_internal_dfsconfig internal_dfs_config;
dprintk(CVP_DBG, "%s:: Enter inst = %pK\n", __func__, inst);
@ -282,10 +149,11 @@ static int msm_cvp_session_cvp_dfs_config(
return -EINVAL;
}
hdev = inst->core->device;
memcpy(&vdfs_config, dfs_config, sizeof(struct msm_cvp_dfsconfig));
memcpy(&internal_dfs_config.dfs_config.cvp_dfs_config,
dfs_config, sizeof(struct msm_cvp_dfs_config));
rc = call_hfi_op(hdev, session_cvp_dfs_config,
(void *)inst->session, &vdfs_config);
(void *)inst->session, &internal_dfs_config);
if (!rc) {
rc = wait_for_sess_signal_receipt(inst,
HAL_SESSION_DFS_CONFIG_CMD_DONE);
@ -303,11 +171,14 @@ static int msm_cvp_session_cvp_dfs_config(
static int msm_cvp_session_cvp_dfs_frame(
struct msm_cvp_inst *inst,
struct msm_cvp_dfsframe *dfs_frame)
struct msm_cvp_dfs_frame *dfs_frame)
{
int rc = 0;
struct hfi_device *hdev;
struct msm_cvp_dfsframe vdfs_frame;
struct msm_cvp_internal_dfsframe internal_dfs_frame;
struct msm_cvp_dfs_frame_kmd *dest_ptr = &internal_dfs_frame.dfs_frame;
struct msm_cvp_dfs_frame_kmd src_frame;
struct msm_cvp_internal_buffer *cbuf;
dprintk(CVP_DBG, "%s:: Enter inst = %pK\n", __func__, inst);
@ -315,11 +186,60 @@ static int msm_cvp_session_cvp_dfs_frame(
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
src_frame = *(struct msm_cvp_dfs_frame_kmd *)dfs_frame;
hdev = inst->core->device;
memcpy(&vdfs_frame, dfs_frame, sizeof(vdfs_frame));
memset(&internal_dfs_frame, 0,
sizeof(struct msm_cvp_internal_dfsframe));
memcpy(&internal_dfs_frame.dfs_frame, dfs_frame,
CVP_DFS_FRAME_CMD_SIZE*sizeof(unsigned int));
rc = msm_cvp_session_get_iova_addr(inst, cbuf,
src_frame.left_view_buffer_fd,
src_frame.left_view_buffer_size,
&dest_ptr->left_view_buffer_fd,
&dest_ptr->left_view_buffer_size);
if (rc) {
dprintk(CVP_ERR, "%s:: left buffer not registered. rc=%d\n",
__func__, rc);
return rc;
}
rc = msm_cvp_session_get_iova_addr(inst, cbuf,
src_frame.right_view_buffer_fd,
src_frame.right_view_buffer_size,
&dest_ptr->right_view_buffer_fd,
&dest_ptr->right_view_buffer_size);
if (rc) {
dprintk(CVP_ERR, "%s:: right buffer not registered. rc=%d\n",
__func__, rc);
return rc;
}
rc = msm_cvp_session_get_iova_addr(inst, cbuf,
src_frame.disparity_map_buffer_fd,
src_frame.disparity_map_buffer_size,
&dest_ptr->disparity_map_buffer_fd,
&dest_ptr->disparity_map_buffer_size);
if (rc) {
dprintk(CVP_ERR, "%s:: disparity map not registered. rc=%d\n",
__func__, rc);
return rc;
}
rc = msm_cvp_session_get_iova_addr(inst, cbuf,
src_frame.occlusion_mask_buffer_fd,
src_frame.occlusion_mask_buffer_size,
&dest_ptr->occlusion_mask_buffer_fd,
&dest_ptr->occlusion_mask_buffer_size);
if (rc) {
dprintk(CVP_ERR, "%s:: occlusion mask not registered. rc=%d\n",
__func__, rc);
return rc;
}
rc = call_hfi_op(hdev, session_cvp_dfs_frame,
(void *)inst->session, &vdfs_frame);
(void *)inst->session, &internal_dfs_frame);
if (rc) {
dprintk(CVP_ERR,
@ -332,7 +252,7 @@ static int msm_cvp_session_cvp_dfs_frame(
static int msm_cvp_session_cvp_dfs_frame_response(
struct msm_cvp_inst *inst,
struct msm_cvp_dfsframe *dfs_frame)
struct msm_cvp_dfs_frame *dfs_frame)
{
int rc = 0;
@ -348,73 +268,207 @@ static int msm_cvp_session_cvp_dfs_frame_response(
dprintk(CVP_ERR,
"%s: wait for signal failed, rc %d\n",
__func__, rc);
return rc;
}
/* DME feature system call handling */
static int msm_cvp_session_cvp_dme_config(
struct msm_cvp_inst *inst,
struct msm_cvp_dme_config *dme_config)
{
int rc = 0;
struct hfi_device *hdev;
struct msm_cvp_internal_dmeconfig internal_dme_config;
dprintk(CVP_DBG, "%s:: Enter inst = %d", __func__, inst);
if (!inst || !inst->core || !dme_config) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
hdev = inst->core->device;
memcpy(&internal_dme_config.dme_config.cvp_dme_config,
dme_config, sizeof(struct msm_cvp_dme_config));
rc = call_hfi_op(hdev, session_cvp_dme_config,
(void *)inst->session, &internal_dme_config);
if (!rc) {
rc = wait_for_sess_signal_receipt(inst,
HAL_SESSION_DME_CONFIG_CMD_DONE);
if (rc)
dprintk(CVP_ERR,
"%s: wait for signal failed, rc %d\n",
__func__, rc);
} else {
dprintk(CVP_ERR, "%s Failed in call_hfi_op\n", __func__);
}
return rc;
}
static int msm_cvp_session_cvp_dme_frame(
struct msm_cvp_inst *inst,
struct msm_cvp_dme_frame *dme_frame)
{
int rc = 0;
struct hfi_device *hdev;
struct msm_cvp_internal_dmeframe internal_dme_frame;
struct msm_cvp_dme_frame_kmd *dest_ptr = &internal_dme_frame.dme_frame;
struct msm_cvp_dme_frame_kmd src_frame;
struct msm_cvp_internal_buffer *cbuf;
dprintk(CVP_DBG, "%s:: Enter inst = %d", __func__, inst);
if (!inst || !inst->core || !dme_frame) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
src_frame = *(struct msm_cvp_dme_frame_kmd *)dme_frame;
hdev = inst->core->device;
memset(&internal_dme_frame, 0,
sizeof(struct msm_cvp_internal_dmeframe));
memcpy(&internal_dme_frame.dme_frame, dme_frame,
CVP_DME_FRAME_CMD_SIZE*sizeof(unsigned int));
for (int i = 0; i < CVP_DME_BUF_NUM; i++) {
if (!src_frame.bufs[i].fd) {
dest_ptr->bufs[i].fd = src_frame.bufs[i].fd;
dest_ptr->bufs[i].size = src_frame.bufs[i].size;
continue;
}
rc = msm_cvp_session_get_iova_addr(inst, cbuf,
src_frame.bufs[i].fd,
src_frame.bufs[i].size,
&dest_ptr->bufs[i].fd,
&dest_ptr->bufs[i].size);
if (rc) {
dprintk(CVP_ERR,
"%s: %d buffer not registered. rc=%d\n",
__func__, i, rc);
return rc;
}
}
rc = call_hfi_op(hdev, session_cvp_dme_frame,
(void *)inst->session, &internal_dme_frame);
if (rc) {
dprintk(CVP_ERR,
"%s:: Failed in call_hfi_op\n",
__func__);
}
return rc;
}
static int msm_cvp_session_cvp_persist(
struct msm_cvp_inst *inst,
struct msm_cvp_persist_buf *pbuf_cmd)
{
int rc = 0;
struct hfi_device *hdev;
struct msm_cvp_internal_persist_cmd internal_pcmd;
struct msm_cvp_persist_kmd *dest_ptr = &internal_pcmd.persist_cmd;
struct msm_cvp_persist_kmd src_frame;
struct msm_cvp_internal_buffer *cbuf;
dprintk(CVP_DBG, "%s:: Enter inst = %d", __func__, inst);
if (!inst || !inst->core || !pbuf_cmd) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
src_frame = *(struct msm_cvp_persist_kmd *)pbuf_cmd;
hdev = inst->core->device;
memset(&internal_pcmd, 0,
sizeof(struct msm_cvp_internal_persist_cmd));
memcpy(&internal_pcmd.persist_cmd, pbuf_cmd,
CVP_PERSIST_CMD_SIZE*sizeof(unsigned int));
for (int i = 0; i < CVP_PSRSIST_BUF_NUM; i++) {
if (!src_frame.bufs[i].fd) {
dest_ptr->bufs[i].fd = src_frame.bufs[i].fd;
dest_ptr->bufs[i].size = src_frame.bufs[i].size;
continue;
}
rc = msm_cvp_session_get_iova_addr(inst, cbuf,
src_frame.bufs[i].fd,
src_frame.bufs[i].size,
&dest_ptr->bufs[i].fd,
&dest_ptr->bufs[i].size);
if (rc) {
dprintk(CVP_ERR,
"%s:: %d buffer not registered. rc=%d\n",
__func__, i, rc);
return rc;
}
}
rc = call_hfi_op(hdev, session_cvp_persist,
(void *)inst->session, &internal_pcmd);
if (rc)
dprintk(CVP_ERR, "%s: Failed in call_hfi_op\n", __func__);
return rc;
}
static int msm_cvp_session_cvp_dme_frame_response(
struct msm_cvp_inst *inst,
struct msm_cvp_dme_frame *dme_frame)
{
int rc = 0;
dprintk(CVP_DBG, "%s:: Enter inst = %d", __func__, inst);
if (!inst || !inst->core || !dme_frame) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
rc = wait_for_sess_signal_receipt(inst,
HAL_SESSION_DME_FRAME_CMD_DONE);
if (rc)
dprintk(CVP_ERR,
"%s: wait for signal failed, rc %d\n",
__func__, rc);
return rc;
}
static int msm_cvp_session_cvp_persist_response(
struct msm_cvp_inst *inst,
struct msm_cvp_persist_buf *pbuf_cmd)
{
int rc = 0;
dprintk(CVP_DBG, "%s:: Enter inst = %d", __func__, inst);
if (!inst || !inst->core || !pbuf_cmd) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
rc = wait_for_sess_signal_receipt(inst,
HAL_SESSION_PERSIST_CMD_DONE);
if (rc)
dprintk(CVP_ERR,
"%s: wait for signal failed, rc %d\n",
__func__, rc);
return rc;
}
static int msm_cvp_send_cmd(struct msm_cvp_inst *inst,
struct msm_cvp_send_cmd *send_cmd)
{
int rc = 0;
bool found;
struct hfi_device *hdev;
struct msm_cvp_internal_send_cmd *csend_cmd;
//struct cvp_register_buffer vbuf;
struct cvp_frame_data input_frame;
dprintk(CVP_ERR, "%s: UMD gave a deprecated cmd", __func__);
dprintk(CVP_DBG, "%s:: Enter 1", __func__);
if (!inst || !inst->core || !send_cmd) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
return -EINVAL;
}
hdev = inst->core->device;
//print_client_buffer(CVP_DBG, "register", inst, send_cmd);
mutex_lock(&inst->cvpbufs.lock);
found = false;
list_for_each_entry(csend_cmd, &inst->cvpbufs.list, list) {
if (csend_cmd->send_cmd.cmd_address_fd ==
send_cmd->cmd_address_fd &&
csend_cmd->send_cmd.cmd_size == send_cmd->cmd_size) {
found = true;
break;
}
}
mutex_unlock(&inst->cvpbufs.lock);
if (found)
return -EINVAL;
csend_cmd = kzalloc(
sizeof(struct msm_cvp_internal_send_cmd), GFP_KERNEL);
if (!csend_cmd) {
dprintk(CVP_ERR, "%s: csend_cmd alloc failed\n", __func__);
return -ENOMEM;
}
mutex_lock(&inst->cvpbufs.lock);
list_add_tail(&csend_cmd->list, &inst->cvpbufs.list);
mutex_unlock(&inst->cvpbufs.lock);
memset(&input_frame, 0, sizeof(struct cvp_frame_data));
rc = call_hfi_op(hdev, session_cvp_send_cmd,
(void *)inst->session, &input_frame);
if (rc)
goto exit;
return rc;
exit:
if (csend_cmd->smem.device_addr)
msm_cvp_smem_unmap_dma_buf(inst, &csend_cmd->smem);
mutex_lock(&inst->cvpbufs.lock);
list_del(&csend_cmd->list);
mutex_unlock(&inst->cvpbufs.lock);
kfree(csend_cmd);
csend_cmd = NULL;
return rc;
return 0;
}
static int msm_cvp_request_power(struct msm_cvp_inst *inst,
struct msm_cvp_request_power *power)
{
@ -430,51 +484,6 @@ static int msm_cvp_request_power(struct msm_cvp_inst *inst,
__func__, power->clock_cycles_a, power->clock_cycles_b,
power->ddr_bw, power->sys_cache_bw);
rc = msm_cvp_clock_aggregation(inst, power->clock_cycles_a,
power->clock_cycles_b);
if (!rc) {
dprintk(CVP_ERR,
"%s: session %#x rejected, cycles: vpss %d, ise %d\n",
__func__, hash32_ptr(inst->session),
power->clock_cycles_a, power->clock_cycles_b);
print_cvp_cycles(inst);
msm_cvp_comm_kill_session(inst);
return -EOVERFLOW;
}
inst->clk_data.min_freq = max(power->clock_cycles_a,
power->clock_cycles_b);
/* convert client provided bps into kbps as expected by driver */
inst->clk_data.ddr_bw = power->ddr_bw / 1000;
inst->clk_data.sys_cache_bw = power->sys_cache_bw / 1000;
rc = msm_cvp_scale_clocks_and_bus(inst);
if (rc) {
dprintk(CVP_ERR,
"%s: failed to scale clocks and bus for inst %pK (%#x)\n",
__func__, inst, hash32_ptr(inst->session));
goto exit;
}
if (!inst->clk_data.min_freq && !inst->clk_data.ddr_bw &&
!inst->clk_data.sys_cache_bw) {
rc = msm_cvp_session_pause(inst);
if (rc) {
dprintk(CVP_ERR,
"%s: failed to pause inst %pK (%#x)\n",
__func__, inst, hash32_ptr(inst->session));
goto exit;
}
} else {
rc = msm_cvp_session_resume(inst);
if (rc) {
dprintk(CVP_ERR,
"%s: failed to resume inst %pK (%#x)\n",
__func__, inst, hash32_ptr(inst->session));
goto exit;
}
}
exit:
return rc;
}
@ -485,7 +494,6 @@ static int msm_cvp_register_buffer(struct msm_cvp_inst *inst,
bool found;
struct hfi_device *hdev;
struct msm_cvp_internal_buffer *cbuf;
struct cvp_register_buffer vbuf;
if (!inst || !inst->core || !buf) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
@ -497,8 +505,7 @@ static int msm_cvp_register_buffer(struct msm_cvp_inst *inst,
mutex_lock(&inst->cvpbufs.lock);
found = false;
list_for_each_entry(cbuf, &inst->cvpbufs.list, list) {
if (cbuf->buf.index == buf->index &&
cbuf->buf.fd == buf->fd &&
if (cbuf->buf.fd == buf->fd &&
cbuf->buf.offset == buf->offset) {
found = true;
break;
@ -524,26 +531,13 @@ static int msm_cvp_register_buffer(struct msm_cvp_inst *inst,
cbuf->smem.fd = buf->fd;
cbuf->smem.offset = buf->offset;
cbuf->smem.size = buf->size;
cbuf->smem.flags = buf->flags;
rc = msm_cvp_smem_map_dma_buf(inst, &cbuf->smem);
if (rc) {
print_client_buffer(CVP_ERR, "map failed", inst, buf);
goto exit;
}
memset(&vbuf, 0, sizeof(struct cvp_register_buffer));
vbuf.index = buf->index;
vbuf.type = get_hal_buftype(__func__, buf->type);
vbuf.size = buf->size;
vbuf.device_addr = cbuf->smem.device_addr;
vbuf.client_data = cbuf->smem.device_addr;
vbuf.response_required = true;
rc = call_hfi_op(hdev, session_register_buffer,
(void *)inst->session, &vbuf);
if (rc) {
print_cvp_internal_buffer(CVP_ERR,
"register failed", inst, cbuf);
goto exit;
}
return rc;
exit:
@ -565,7 +559,6 @@ static int msm_cvp_unregister_buffer(struct msm_cvp_inst *inst,
bool found;
struct hfi_device *hdev;
struct msm_cvp_internal_buffer *cbuf;
struct cvp_unregister_buffer vbuf;
if (!inst || !inst->core || !buf) {
dprintk(CVP_ERR, "%s: invalid params\n", __func__);
@ -577,10 +570,13 @@ static int msm_cvp_unregister_buffer(struct msm_cvp_inst *inst,
mutex_lock(&inst->cvpbufs.lock);
found = false;
list_for_each_entry(cbuf, &inst->cvpbufs.list, list) {
if (cbuf->buf.index == buf->index &&
cbuf->buf.fd == buf->fd &&
if (cbuf->buf.fd == buf->fd &&
cbuf->buf.offset == buf->offset) {
found = true;
if (cbuf->smem.device_addr)
msm_cvp_smem_unmap_dma_buf(inst, &cbuf->smem);
list_del(&cbuf->list);
kfree(cbuf);
break;
}
}
@ -590,19 +586,6 @@ static int msm_cvp_unregister_buffer(struct msm_cvp_inst *inst,
return -EINVAL;
}
memset(&vbuf, 0, sizeof(struct cvp_unregister_buffer));
vbuf.index = cbuf->buf.index;
vbuf.type = get_hal_buftype(__func__, cbuf->buf.type);
vbuf.size = cbuf->buf.size;
vbuf.device_addr = cbuf->smem.device_addr;
vbuf.client_data = cbuf->smem.device_addr;
vbuf.response_required = true;
rc = call_hfi_op(hdev, session_unregister_buffer,
(void *)inst->session, &vbuf);
if (rc)
print_cvp_internal_buffer(CVP_ERR,
"unregister failed", inst, cbuf);
return rc;
}
@ -661,26 +644,66 @@ int msm_cvp_handle_syscall(struct msm_cvp_inst *inst, struct msm_cvp_arg *arg)
}
case MSM_CVP_HFI_DFS_CONFIG_CMD:
{
struct msm_cvp_dfsconfig *dfsconfig =
(struct msm_cvp_dfsconfig *)&arg->data.dfsconfig;
struct msm_cvp_dfs_config *dfs_config =
(struct msm_cvp_dfs_config *)&arg->data.dfs_config;
rc = msm_cvp_session_cvp_dfs_config(inst, dfsconfig);
rc = msm_cvp_session_cvp_dfs_config(inst, dfs_config);
break;
}
case MSM_CVP_HFI_DFS_FRAME_CMD:
{
struct msm_cvp_dfsframe *dfsframe =
(struct msm_cvp_dfsframe *)&arg->data.dfsframe;
struct msm_cvp_dfs_frame *dfs_frame =
(struct msm_cvp_dfs_frame *)&arg->data.dfs_frame;
rc = msm_cvp_session_cvp_dfs_frame(inst, dfsframe);
rc = msm_cvp_session_cvp_dfs_frame(inst, dfs_frame);
break;
}
case MSM_CVP_HFI_DFS_FRAME_CMD_RESPONSE:
{
struct msm_cvp_dfsframe *dfsframe =
(struct msm_cvp_dfsframe *)&arg->data.dfsframe;
struct msm_cvp_dfs_frame *dfs_frame =
(struct msm_cvp_dfs_frame *)&arg->data.dfs_frame;
rc = msm_cvp_session_cvp_dfs_frame_response(inst, dfsframe);
rc = msm_cvp_session_cvp_dfs_frame_response(inst, dfs_frame);
break;
}
case MSM_CVP_HFI_DME_CONFIG_CMD:
{
struct msm_cvp_dme_config *dme_config =
(struct msm_cvp_dme_config *)&arg->data.dme_config;
rc = msm_cvp_session_cvp_dme_config(inst, dme_config);
break;
}
case MSM_CVP_HFI_DME_FRAME_CMD:
{
struct msm_cvp_dme_frame *dme_frame =
(struct msm_cvp_dme_frame *)&arg->data.dme_frame;
rc = msm_cvp_session_cvp_dme_frame(inst, dme_frame);
break;
}
case MSM_CVP_HFI_DME_FRAME_CMD_RESPONSE:
{
struct msm_cvp_dme_frame *dmeframe =
(struct msm_cvp_dme_frame *)&arg->data.dme_frame;
rc = msm_cvp_session_cvp_dme_frame_response(inst, dmeframe);
break;
}
case MSM_CVP_HFI_PERSIST_CMD:
{
struct msm_cvp_persist_buf *pbuf_cmd =
(struct msm_cvp_persist_buf *)&arg->data.pbuf_cmd;
rc = msm_cvp_session_cvp_persist(inst, pbuf_cmd);
break;
}
case MSM_CVP_HFI_PERSIST_CMD_RESPONSE:
{
struct msm_cvp_persist_buf *pbuf_cmd =
(struct msm_cvp_persist_buf *)&arg->data.pbuf_cmd;
rc = msm_cvp_session_cvp_persist_response(inst, pbuf_cmd);
break;
}
default:

4
drivers/media/platform/msm/cvp/msm_cvp.h
View File

@ -11,10 +11,6 @@
#include "msm_cvp_clocks.h"
#include "msm_cvp_debug.h"
void cvp_handle_session_register_buffer_done(enum hal_command_response cmd,
void *resp);
void cvp_handle_session_unregister_buffer_done(enum hal_command_response cmd,
void *resp);
int msm_cvp_handle_syscall(struct msm_cvp_inst *inst, struct msm_cvp_arg *arg);
int msm_cvp_session_init(struct msm_cvp_inst *inst);
int msm_cvp_session_deinit(struct msm_cvp_inst *inst);

21
drivers/media/platform/msm/cvp/msm_cvp_common.c
View File

@ -585,7 +585,7 @@ struct msm_cvp_inst *cvp_get_inst(struct msm_cvp_core *core,
return inst;
}
static void cvp_handle_session_dfs_cmd_done(enum hal_command_response cmd,
static void cvp_handle_session_cmd_done(enum hal_command_response cmd,
void *data)
{
struct msm_cvp_cb_cmd_done *response = data;
@ -1679,11 +1679,6 @@ enum hal_buffer msm_cvp_comm_get_hal_output_buffer(struct msm_cvp_inst *inst)
return HAL_BUFFER_OUTPUT;
}
static void handle_dfs(enum hal_command_response cmd, void *data)
{
dprintk(CVP_ERR, "%s: is called\n", __func__);
}
void cvp_handle_cmd_response(enum hal_command_response cmd, void *data)
{
dprintk(CVP_DBG, "Command response = %d\n", cmd);
@ -1700,9 +1695,6 @@ void cvp_handle_cmd_response(enum hal_command_response cmd, void *data)
case HAL_SESSION_CVP_OPERATION_CONFIG:
handle_operation_config(cmd, data);
break;
case HAL_SESSION_CVP_DFS:
handle_dfs(cmd, data);
break;
case HAL_SESSION_RELEASE_RESOURCE_DONE:
handle_release_res_done(cmd, data);
break;
@ -1729,15 +1721,12 @@ void cvp_handle_cmd_response(enum hal_command_response cmd, void *data)
case HAL_SESSION_RELEASE_BUFFER_DONE:
handle_session_release_buf_done(cmd, data);
break;
case HAL_SESSION_REGISTER_BUFFER_DONE:
cvp_handle_session_register_buffer_done(cmd, data);
break;
case HAL_SESSION_UNREGISTER_BUFFER_DONE:
cvp_handle_session_unregister_buffer_done(cmd, data);
break;
case HAL_SESSION_DFS_CONFIG_CMD_DONE:
case HAL_SESSION_DFS_FRAME_CMD_DONE:
cvp_handle_session_dfs_cmd_done(cmd, data);
case HAL_SESSION_DME_CONFIG_CMD_DONE:
case HAL_SESSION_DME_FRAME_CMD_DONE:
case HAL_SESSION_PERSIST_CMD_DONE:
cvp_handle_session_cmd_done(cmd, data);
break;
default:
dprintk(CVP_DBG, "response unhandled: %d\n", cmd);

6
drivers/media/platform/msm/cvp/msm_cvp_internal.h
View File

@ -526,12 +526,6 @@ struct msm_cvp_internal_send_cmd {
struct msm_cvp_send_cmd send_cmd;
};
struct msm_cvp_internal_dfsconfig {
struct list_head list;
struct msm_smem smem;
struct msm_cvp_dfsconfig dfsconfig;
};
void msm_cvp_comm_handle_thermal_event(void);
int msm_cvp_smem_alloc(size_t size, u32 align, u32 flags,
enum hal_buffer buffer_type, int map_kernel,

2
drivers/media/platform/msm/cvp/msm_cvp_platform.c
View File

@ -94,7 +94,7 @@ static struct msm_cvp_common_data sm8250_common_data[] = {
},
{
.key = "qcom,sw-power-collapse",
.value = 1,
.value = 0,
},
{
.key = "qcom,domain-attr-non-fatal-faults",

11
drivers/media/platform/msm/cvp/msm_cvp_res_parse.c
View File

@ -907,8 +907,17 @@ static int msm_cvp_setup_context_bank(struct msm_cvp_platform_resources *res,
goto remove_cb;
}
if (cb->is_secure)
if (cb->is_secure) {
secure_vmid = get_secure_vmid(cb);
rc = iommu_domain_set_attr(cb->mapping->domain,
DOMAIN_ATTR_SECURE_VMID, &secure_vmid);
if (rc) {
dprintk(CVP_ERR,
"%s - Couldn't arm_iommu_set_attr vmid\n",
__func__);
goto release_mapping;
}
}
if (res->cache_pagetables) {
int cache_pagetables = 1;

5
drivers/media/platform/msm/cvp/msm_v4l2_cvp.c
View File

@ -63,16 +63,15 @@ static int msm_cvp_v4l2_open(struct file *filp)
static int msm_cvp_v4l2_close(struct file *filp)
{
int rc = 0;
struct msm_cvp_inst *cvp_inst;
trace_msm_v4l2_cvp_close_start("msm v4l2_close start");
cvp_inst = get_cvp_inst(filp, NULL);
rc = msm_cvp_close(cvp_inst);
//rc = msm_cvp_close(cvp_inst);
filp->private_data = NULL;
trace_msm_v4l2_cvp_close_end("msm v4l2_close end");
return rc;
return 0;
}
static int msm_cvp_v4l2_querycap(struct file *filp, void *fh,

255
drivers/media/platform/msm/cvp/msm_v4l2_private.c
View File

@ -105,87 +105,77 @@ static int convert_from_user(struct msm_cvp_arg *kp, unsigned long arg)
}
case MSM_CVP_HFI_DFS_CONFIG_CMD:
{
struct msm_cvp_dfsconfig *k, *u;
struct msm_cvp_dfs_config *k, *u;
dprintk(CVP_DBG, "%s: MSM_CVP_HFI_DFS_CONFIG_CMD\n",
__func__);
k = &kp->data.dfsconfig;
u = &up->data.dfsconfig;
if (get_user(k->cmd_address, &u->cmd_address) ||
get_user(k->cmd_size, &u->cmd_size) ||
get_user(k->packet_type, &u->packet_type) ||
get_user(k->session_id, &u->session_id) ||
get_user(k->srcbuffer_format, &u->srcbuffer_format) ||
get_user(
k->left_plane_info.stride[HFI_MAX_PLANES - 1],
&u->left_plane_info.stride[HFI_MAX_PLANES - 1]) ||
get_user(
k->left_plane_info.buf_size[HFI_MAX_PLANES - 1],
&u->left_plane_info.buf_size[HFI_MAX_PLANES - 1]) ||
get_user(
k->right_plane_info.stride[HFI_MAX_PLANES - 1],
&u->right_plane_info.stride[HFI_MAX_PLANES - 1]) ||
get_user(
k->right_plane_info.buf_size[HFI_MAX_PLANES - 1],
&u->right_plane_info.buf_size[HFI_MAX_PLANES - 1]) ||
get_user(k->width, &u->width) ||
get_user(k->height, &u->height) ||
get_user(k->occlusionmask_enable,
&u->occlusionmask_enable) ||
get_user(k->occlusioncost, &u->occlusioncost) ||
get_user(k->occlusionshift, &u->occlusionshift) ||
get_user(k->maxdisparity, &u->maxdisparity) ||
get_user(k->disparityoffset, &u->disparityoffset) ||
get_user(k->medianfilter_enable,
&u->medianfilter_enable) ||
get_user(k->occlusionbound, &u->occlusionbound) ||
get_user(k->occlusionfilling_enable,
&u->occlusionfilling_enable) ||
get_user(k->occlusionmaskdump,
&u->occlusionmaskdump) ||
get_user(k->clientdata.transactionid,
&u->clientdata.transactionid) ||
get_user(k->clientdata.client_data1,
&u->clientdata.client_data1) ||
get_user(k->clientdata.client_data2,
&u->clientdata.client_data2))
return -EFAULT;
for (i = 0; i < MAX_DFS_HFI_PARAMS; i++)
if (get_user(k->reserved[i], &u->reserved[i]))
dprintk(CVP_DBG, "%s: MSM_CVP_HFI_DFS_CONFIG_CMD\n", __func__);
k = &kp->data.dfs_config;
u = &up->data.dfs_config;
for (i = 0; i < CVP_DFS_CONFIG_CMD_SIZE; i++)
if (get_user(k->cvp_dfs_config[i],
&u->cvp_dfs_config[i]))
return -EFAULT;
break;
}
case MSM_CVP_HFI_DFS_FRAME_CMD:
case MSM_CVP_HFI_DFS_FRAME_CMD_RESPONSE:
{
struct msm_cvp_dfsframe *k, *u;
struct msm_cvp_dfs_frame *k, *u;
dprintk(CVP_DBG, "%s: Type =%d\n",
__func__, kp->type);
k = &kp->data.dfsframe;
u = &up->data.dfsframe;
if (get_user(k->cmd_address, &u->cmd_address) ||
get_user(k->cmd_size, &u->cmd_size) ||
get_user(k->packet_type, &u->packet_type) ||
get_user(k->session_id, &u->session_id) ||
get_user(k->left_buffer_index,
&u->left_buffer_index) ||
get_user(k->right_buffer_index,
&u->right_buffer_index) ||
get_user(k->disparitymap_buffer_idx,
&u->disparitymap_buffer_idx) ||
get_user(k->occlusionmask_buffer_idx,
&u->occlusionmask_buffer_idx) ||
get_user(k->clientdata.transactionid,
&u->clientdata.transactionid) ||
get_user(k->clientdata.client_data1,
&u->clientdata.client_data1) ||
get_user(k->clientdata.client_data2,
&u->clientdata.client_data2))
return -EFAULT;
dprintk(CVP_DBG, "%s: Type =%d\n", __func__, kp->type);
k = &kp->data.dfs_frame;
u = &up->data.dfs_frame;
for (i = 0; i < CVP_DFS_FRAME_CMD_SIZE; i++)
if (get_user(k->frame_data[i], &u->frame_data[i]))
return -EFAULT;
break;
}
case MSM_CVP_HFI_DME_CONFIG_CMD:
{
struct msm_cvp_dme_config *k, *u;
dprintk(CVP_DBG, "%s: MSM_CVP_HFI_DFS_CONFIG_CMD\n", __func__);
k = &kp->data.dme_config;
u = &up->data.dme_config;
for (i = 0; i < CVP_DME_CONFIG_CMD_SIZE; i++)
if (get_user(k->cvp_dme_config[i],
&u->cvp_dme_config[i]))
return -EFAULT;
break;
}
case MSM_CVP_HFI_DME_FRAME_CMD:
case MSM_CVP_HFI_DME_FRAME_CMD_RESPONSE:
{
struct msm_cvp_dme_frame *k, *u;
dprintk(CVP_DBG, "%s: type = %d\n",
__func__, kp->type);
k = &kp->data.dme_frame;
u = &up->data.dme_frame;
for (i = 0; i < CVP_DME_FRAME_CMD_SIZE; i++)
if (get_user(k->frame_data[i], &u->frame_data[i]))
return -EFAULT;
break;
}
case MSM_CVP_HFI_PERSIST_CMD:
case MSM_CVP_HFI_PERSIST_CMD_RESPONSE:
{
struct msm_cvp_persist_buf *k, *u;
dprintk(CVP_DBG, "%s: type = %d\n",
__func__, kp->type);
k = &kp->data.pbuf_cmd;
u = &up->data.pbuf_cmd;
for (i = 0; i < CVP_PERSIST_CMD_SIZE; i++)
if (get_user(k->persist_data[i], &u->persist_data[i]))
return -EFAULT;
break;
}
default:
dprintk(CVP_ERR, "%s: unknown cmd type 0x%x\n",
__func__, kp->type);
@ -297,87 +287,78 @@ static int convert_to_user(struct msm_cvp_arg *kp, unsigned long arg)
}
case MSM_CVP_HFI_DFS_CONFIG_CMD:
{
struct msm_cvp_dfsconfig *k, *u;
struct msm_cvp_dfs_config *k, *u;
dprintk(CVP_DBG, "%s: MSM_CVP_HFI_DFS_CONFIG_CMD\n",
__func__);
k = &kp->data.dfsconfig;
u = &up->data.dfsconfig;
if (put_user(k->cmd_address, &u->cmd_address) ||
put_user(k->cmd_size, &u->cmd_size) ||
put_user(k->packet_type, &u->packet_type) ||
put_user(k->session_id, &u->session_id) ||
put_user(k->srcbuffer_format, &u->srcbuffer_format) ||
put_user(
k->left_plane_info.stride[HFI_MAX_PLANES - 1],
&u->left_plane_info.stride[HFI_MAX_PLANES - 1]) ||
put_user(
k->left_plane_info.buf_size[HFI_MAX_PLANES - 1],
&u->left_plane_info.buf_size[HFI_MAX_PLANES - 1]) ||
put_user(
k->right_plane_info.stride[HFI_MAX_PLANES - 1],
&u->right_plane_info.stride[HFI_MAX_PLANES - 1]) ||
put_user(
k->right_plane_info.buf_size[HFI_MAX_PLANES - 1],
&u->right_plane_info.buf_size[HFI_MAX_PLANES - 1])
|| put_user(k->width, &u->width) ||
put_user(k->height, &u->height) ||
put_user(k->occlusionmask_enable,
&u->occlusionmask_enable) ||
put_user(k->occlusioncost, &u->occlusioncost) ||
put_user(k->occlusionshift, &u->occlusionshift) ||
put_user(k->maxdisparity, &u->maxdisparity) ||
put_user(
k->disparityoffset, &u->disparityoffset) ||
put_user(k->medianfilter_enable,
&u->medianfilter_enable) ||
put_user(k->occlusionbound, &u->occlusionbound) ||
put_user(k->occlusionfilling_enable,
&u->occlusionfilling_enable) ||
put_user(k->occlusionmaskdump,
&u->occlusionmaskdump) ||
put_user(k->clientdata.transactionid,
&u->clientdata.transactionid) ||
put_user(k->clientdata.client_data1,
&u->clientdata.client_data1) ||
put_user(k->clientdata.client_data2,
&u->clientdata.client_data2))
return -EFAULT;
for (i = 0; i < MAX_DFS_HFI_PARAMS; i++)
if (put_user(k->reserved[i], &u->reserved[i]))
k = &kp->data.dfs_config;
u = &up->data.dfs_config;
for (i = 0; i < CVP_DFS_CONFIG_CMD_SIZE; i++)
if (put_user(k->cvp_dfs_config[i],
&u->cvp_dfs_config[i]))
return -EFAULT;
break;
}
case MSM_CVP_HFI_DFS_FRAME_CMD:
case MSM_CVP_HFI_DFS_FRAME_CMD_RESPONSE:
{
struct msm_cvp_dfsframe *k, *u;
struct msm_cvp_dfs_frame *k, *u;
dprintk(CVP_DBG, "%s: type = %d\n",
__func__, kp->type);
k = &kp->data.dfsframe;
u = &up->data.dfsframe;
k = &kp->data.dfs_frame;
u = &up->data.dfs_frame;
for (i = 0; i < CVP_DFS_FRAME_CMD_SIZE; i++)
if (put_user(k->frame_data[i], &u->frame_data[i]))
return -EFAULT;
break;
}
case MSM_CVP_HFI_DME_CONFIG_CMD:
{
struct msm_cvp_dme_config *k, *u;
dprintk(CVP_DBG, "%s: MSM_CVP_HFI_DME_CONFIG_CMD\n", __func__);
k = &kp->data.dme_config;
u = &up->data.dme_config;
for (i = 0; i < CVP_DME_CONFIG_CMD_SIZE; i++)
if (put_user(k->cvp_dme_config[i],
&u->cvp_dme_config[i]))
return -EFAULT;
break;
}
case MSM_CVP_HFI_DME_FRAME_CMD:
case MSM_CVP_HFI_DME_FRAME_CMD_RESPONSE:
{
struct msm_cvp_dme_frame *k, *u;
dprintk(CVP_DBG, "%s: type = %d\n",
__func__, kp->type);
k = &kp->data.dme_frame;
u = &up->data.dme_frame;
for (i = 0; i < CVP_DME_FRAME_CMD_SIZE; i++)
if (put_user(k->frame_data[i], &u->frame_data[i]))
return -EFAULT;
break;
}
case MSM_CVP_HFI_PERSIST_CMD:
case MSM_CVP_HFI_PERSIST_CMD_RESPONSE:
{
struct msm_cvp_persist_buf *k, *u;
dprintk(CVP_DBG, "%s: type = %d\n",
__func__, kp->type);
k = &kp->data.pbuf_cmd;
u = &up->data.pbuf_cmd;
for (i = 0; i < CVP_PERSIST_CMD_SIZE; i++)
if (put_user(k->persist_data[i], &u->persist_data[i]))
return -EFAULT;
if (put_user(k->cmd_address, &u->cmd_address) ||
put_user(k->cmd_size, &u->cmd_size) ||
put_user(k->packet_type, &u->packet_type) ||
put_user(k->session_id, &u->session_id) ||
put_user(k->left_buffer_index,
&u->left_buffer_index) ||
put_user(k->right_buffer_index,
&u->right_buffer_index) ||
put_user(k->disparitymap_buffer_idx,
&u->disparitymap_buffer_idx) ||
put_user(k->occlusionmask_buffer_idx,
&u->occlusionmask_buffer_idx) ||
put_user(k->clientdata.transactionid,
&u->clientdata.transactionid) ||
put_user(k->clientdata.client_data1,
&u->clientdata.client_data1) ||
put_user(k->clientdata.client_data2,
&u->clientdata.client_data2))
return -EFAULT;
break;
}
default:

132
include/uapi/media/msm_cvp_private.h
View File

@ -8,6 +8,7 @@
#include <linux/videodev2.h>
#define MAX_DFS_HFI_PARAMS 20
#define HFI_MAX_PLANES 4
/* VIDIOC private cvp command */
#define VIDIOC_CVP_CMD \
@ -58,6 +59,16 @@
#define MSM_CVP_HFI_DFS_FRAME_CMD_RESPONSE (MSM_CVP_CMD_START + 8)
#define MSM_CVP_HFI_DME_CONFIG_CMD (MSM_CVP_CMD_START + 9)
#define MSM_CVP_HFI_DME_FRAME_CMD (MSM_CVP_CMD_START + 10)
#define MSM_CVP_HFI_DME_FRAME_CMD_RESPONSE (MSM_CVP_CMD_START + 11)
#define MSM_CVP_HFI_PERSIST_CMD (MSM_CVP_CMD_START + 12)
#define MSM_CVP_HFI_PERSIST_CMD_RESPONSE (MSM_CVP_CMD_START + 13)
/* flags */
#define MSM_CVP_FLAG_UNSECURE 0x00000000
#define MSM_CVP_FLAG_SECURE 0x00000001
@ -125,15 +136,6 @@ struct msm_cvp_send_cmd {
unsigned int reserved[10];
};
/**
* enum HFI_COLOR_PLANE_TYPE - define the type of plane
*/
enum HFI_COLOR_PLANE_TYPE {
HFI_COLOR_PLANE_METADATA,
HFI_COLOR_PLANE_PICDATA,
HFI_MAX_PLANES
};
/**
* struct msm_cvp_color_plane_info - color plane info
* @stride: stride of plane
@ -157,77 +159,40 @@ struct msm_cvp_client_data {
unsigned int client_data2;
};
/**
* struct msm_cvp_dfsconfig - dfs config packet
* @cmd_size: command size in bytes
* @cmd_address: command address
* @size: packet size in bytes
* @packet_type: HFI_CMD_SESSION_CVP_DFS
* @session_id: id value associated with a session
* @srcbuffer_format: buffer format of source imagesize
* @left_plane_info: left view buffer plane info
* @right_plane_info: right view buffer plane info
* @width: image width
* @height: image height
* @occlusionmask_enable: 0: disable, 1: enable
* @occlusioncost: occlusion cost threshold
* @occlusionbound: occlusion bound
* @occlusionshift: occlusion shift
* @maxdisparity: max disparitymap in integer precision
* @disparityoffset: disparity offset
* @medianfilter_enable: enable median filter on disparity map
* @occlusionfilling_enable:0: disable, 1: enable
* @occlusionmaskdump: 0: disable, 1: enable
* @clientdata: client data for mapping command
* and message pairs
*/
struct msm_cvp_dfsconfig {
unsigned int cmd_size;
unsigned int cmd_address;
unsigned int size;
unsigned int packet_type;
unsigned int session_id;
unsigned int srcbuffer_format;
struct msm_cvp_color_plane_info left_plane_info;
struct msm_cvp_color_plane_info right_plane_info;
unsigned int width;
unsigned int height;
unsigned int occlusionmask_enable;
unsigned int occlusioncost;
unsigned int occlusionbound;
unsigned int occlusionshift;
unsigned int maxdisparity;
unsigned int disparityoffset;
unsigned int medianfilter_enable;
unsigned int occlusionfilling_enable;
unsigned int occlusionmaskdump;
struct msm_cvp_client_data clientdata;
unsigned int reserved[MAX_DFS_HFI_PARAMS];
#define CVP_COLOR_PLANE_INFO_SIZE \
sizeof(struct msm_cvp_color_plane_info)
#define CVP_CLIENT_DATA_SIZE sizeof(struct msm_cvp_client_data)
#define CVP_DFS_CONFIG_CMD_SIZE 38
#define CVP_DFS_FRAME_CMD_SIZE 16
#define CVP_DFS_FRAME_BUFFERS_OFFSET 8
#define CVP_DME_CONFIG_CMD_SIZE 181
#define CVP_DME_FRAME_CMD_SIZE 28
#define CVP_DME_FRAME_BUFFERS_OFFSET 12
#define CVP_DME_BUF_NUM 8
#define CVP_PERSIST_CMD_SIZE 11
#define CVP_PERSIST_BUFFERS_OFFSET 7
#define CVP_PSRSIST_BUF_NUM 2
struct msm_cvp_dfs_config {
unsigned int cvp_dfs_config[CVP_DFS_CONFIG_CMD_SIZE];
};
/**
* struct msm_cvp_dfsframe - dfs frame packet
* @cmd_size: command size in bytes
* @cmd_address: command address
* @size: packet size in bytes
* @packet_type: HFI_CMD_SESSION_CVP_DFS
* @session_id: id value associated with a session
* @left_buffer_index: left buffer index
* @right_buffer_index: right buffer index
* @disparitymap_buffer_idx: disparity map buffer index
* @occlusionmask_buffer_idx:occlusion mask buffer index
*/
struct msm_cvp_dfsframe {
unsigned int cmd_size;
unsigned int cmd_address;
unsigned int size;
unsigned int packet_type;
unsigned int session_id;
unsigned int left_buffer_index;
unsigned int right_buffer_index;
unsigned int disparitymap_buffer_idx;
unsigned int occlusionmask_buffer_idx;
struct msm_cvp_client_data clientdata;
struct msm_cvp_dfs_frame {
unsigned int frame_data[CVP_DFS_FRAME_CMD_SIZE];
};
struct msm_cvp_dme_config {
unsigned int cvp_dme_config[CVP_DME_CONFIG_CMD_SIZE];
};
struct msm_cvp_dme_frame {
unsigned int frame_data[CVP_DME_FRAME_CMD_SIZE];
};
struct msm_cvp_persist_buf {
unsigned int persist_data[CVP_PERSIST_CMD_SIZE];
};
/**
@ -238,8 +203,8 @@ struct msm_cvp_dfsframe {
* @regbuf: buffer to be registered
* @unregbuf: buffer to be unregistered
* @send_cmd: sending generic HFI command
* @dfsconfig: sending DFS config command
* @dfsframe: sending DFS frame command
* @dfs_config: sending DFS config command
* @dfs_frame: sending DFS frame command
*/
struct msm_cvp_arg {
unsigned int type;
@ -249,8 +214,11 @@ struct msm_cvp_arg {
struct msm_cvp_buffer regbuf;
struct msm_cvp_buffer unregbuf;
struct msm_cvp_send_cmd send_cmd;
struct msm_cvp_dfsconfig dfsconfig;
struct msm_cvp_dfsframe dfsframe;
struct msm_cvp_dfs_config dfs_config;
struct msm_cvp_dfs_frame dfs_frame;
struct msm_cvp_dme_config dme_config;
struct msm_cvp_dme_frame dme_frame;
struct msm_cvp_persist_buf pbuf_cmd;
} data;
unsigned int reserved[12];
};