A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-08 12:58:12 -04:00
Code Issues Projects Releases Packages Wiki Activity

Merge "msm: cvp: Fence path for Lahaina"

Browse source
This commit is contained in:
qctecmdr 2019-12-17 21:46:53 -08:00 • committed by Gerrit - the friendly Code Review server
commit ea80f74288
11 changed files with 543 additions and 890 deletions
Download patch file Download diff file Expand all files Collapse all files

72
drivers/media/platform/msm/cvp/cvp_hfi.c
View file

@ -34,6 +34,7 @@
#define FIRMWARE_SIZE 0X00A00000
#define REG_ADDR_OFFSET_BITMASK 0x000FFFFF
#define QDSS_IOVA_START 0x80001000
#define MIN_PAYLOAD_SIZE 3
const struct msm_cvp_hfi_defs cvp_hfi_defs[] = {
{
@ -346,32 +347,6 @@ int get_pkt_index(struct cvp_hal_session_cmd_pkt *hdr)
return -EINVAL;
}
int set_feature_bitmask(int pkt_idx, unsigned long *bitmask)
{
if (!bitmask) {
dprintk(CVP_ERR, "%s: invalid bitmask\n", __func__);
return -EINVAL;
}
if (cvp_hfi_defs[pkt_idx].type == HFI_CMD_SESSION_CVP_DME_FRAME) {
set_bit(DME_BIT_OFFSET, bitmask);
return 0;
}
if (cvp_hfi_defs[pkt_idx].type == HFI_CMD_SESSION_CVP_ICA_FRAME) {
set_bit(ICA_BIT_OFFSET, bitmask);
return 0;
}
if (cvp_hfi_defs[pkt_idx].type == HFI_CMD_SESSION_CVP_FD_FRAME) {
set_bit(FD_BIT_OFFSET, bitmask);
return 0;
}
dprintk(CVP_ERR, "%s: invalid pkt_idx %d\n", __func__, pkt_idx);
return -EINVAL;
}
int get_hfi_version(void)
{
struct msm_cvp_core *core;
@ -1201,20 +1176,13 @@ static int __tzbsp_set_cvp_state(enum tzbsp_subsys_state state)
int rc = 0;
rc = qcom_scm_set_remote_state(state, TZBSP_CVP_PAS_ID);
dprintk(CVP_DBG, "Set state %d, resp %d\n", state, rc);
if (rc < 0) {
if (rc) {
dprintk(CVP_ERR, "Failed qcom_scm_set_remote_state %d\n", rc);
return rc;
}
dprintk(CVP_DBG, "Set state %d, resp %d\n", state, rc);
if (rc) {
dprintk(CVP_ERR,
"Failed to set cvp core state to suspend: %d\n",
rc);
return -EINVAL;
}
return 0;
}
@ -2896,15 +2864,35 @@ static void __flush_debug_queue(struct iris_hfi_device *device, u8 *packet)
log_level = CVP_ERR;
}
while (!__iface_dbgq_read(device, packet)) {
struct cvp_hfi_msg_sys_coverage_packet *pkt =
(struct cvp_hfi_msg_sys_coverage_packet *) packet;
#define SKIP_INVALID_PKT(pkt_size, payload_size, pkt_hdr_size) ({ \
if (pkt_size < pkt_hdr_size || \
payload_size < MIN_PAYLOAD_SIZE || \
payload_size > \
(pkt_size - pkt_hdr_size + sizeof(u8))) { \
dprintk(CVP_ERR, \
"%s: invalid msg size - %d\n", \
__func__, pkt->msg_size); \
continue; \
} \
})
if (pkt->packet_type == HFI_MSG_SYS_COV) {
dprintk(CVP_ERR, "STM_LOG not supported\n");
} else {
while (!__iface_dbgq_read(device, packet)) {
struct cvp_hfi_packet_header *pkt =
(struct cvp_hfi_packet_header *) packet;
if (pkt->size < sizeof(struct cvp_hfi_packet_header)) {
dprintk(CVP_ERR, "Invalid pkt size - %s\n",
__func__);
continue;
}
if (pkt->packet_type == HFI_MSG_SYS_DEBUG) {
struct cvp_hfi_msg_sys_debug_packet *pkt =
(struct cvp_hfi_msg_sys_debug_packet *) packet;
SKIP_INVALID_PKT(pkt->size,
pkt->msg_size, sizeof(*pkt));
/*
* All fw messages starts with new line character. This
* causes dprintk to print this message in two lines
@ -2912,9 +2900,11 @@ static void __flush_debug_queue(struct iris_hfi_device *device, u8 *packet)
* from the message fixes this to print it in a single
* line.
*/
pkt->rg_msg_data[pkt->msg_size-1] = '\0';
dprintk(log_level, "%s", &pkt->rg_msg_data[1]);
}
}
#undef SKIP_INVALID_PKT
if (local_packet)
kfree(packet);

7
drivers/media/platform/msm/cvp/cvp_hfi_api.h
View file

@ -98,12 +98,6 @@
#define HFI_MODEL_BUFFERS_OFFSET 7
#define HFI_MODEL_BUF_NUM 1
#define DFS_BIT_OFFSET (CVP_KMD_HFI_DFS_FRAME_CMD - CVP_KMD_CMD_START)
#define DME_BIT_OFFSET (CVP_KMD_HFI_DME_FRAME_CMD - CVP_KMD_CMD_START)
#define PERSIST_BIT_OFFSET (CVP_KMD_HFI_PERSIST_CMD - CVP_KMD_CMD_START)
#define ICA_BIT_OFFSET (CVP_KMD_HFI_ICA_FRAME_CMD - CVP_KMD_CMD_START)
#define FD_BIT_OFFSET (CVP_KMD_HFI_FD_FRAME_CMD - CVP_KMD_CMD_START)
#define HFI_VERSION_MAJOR_MASK 0xFF000000
#define HFI_VERSION_MAJOR_SHFIT 24
#define HFI_VERSION_MINOR_MASK 0x00FFFFE0
@ -428,7 +422,6 @@ void cvp_hfi_deinitialize(enum msm_cvp_hfi_type hfi_type,
int get_pkt_index(struct cvp_hal_session_cmd_pkt *hdr);
int get_signal_from_pkt_type(unsigned int type);
int set_feature_bitmask(int pkt_index, unsigned long *bitmask);
int get_hfi_version(void);
unsigned int get_msg_size(void);
unsigned int get_msg_session_id(void *msg);

27
drivers/media/platform/msm/cvp/cvp_hfi_helper.h
View file

@ -285,11 +285,16 @@ struct cvp_hfi_client {
u32 transaction_id;
u32 data1;
u32 data2;
u32 kdata1;
u32 kdata2;
union {
u64 kdata;
struct {
u32 kdata1;
u32 kdata2;
};
};
u32 reserved1;
u32 reserved2;
};
} __packed;
struct cvp_hfi_client_d {
u32 transaction_id;
@ -317,7 +322,7 @@ struct cvp_hfi_cmd_session_set_buffers_packet {
u32 session_id;
struct cvp_hfi_client client_data;
struct cvp_hfi_buf_type buf_type;
};
} __packed;
struct cvp_hfi_cmd_session_set_buffers_packet_d {
u32 size;
@ -337,7 +342,7 @@ struct cvp_session_release_buffers_packet {
u32 buffer_type;
u32 num_buffers;
u32 buffer_idx;
};
} __packed;
struct cvp_session_release_buffers_packet_d {
u32 size;
@ -355,7 +360,7 @@ struct cvp_hfi_cmd_session_hdr {
u32 session_id;
struct cvp_hfi_client client_data;
u32 stream_idx;
};
} __packed;
struct cvp_hfi_msg_session_hdr {
u32 size;
@ -364,7 +369,7 @@ struct cvp_hfi_msg_session_hdr {
u32 error_type;
struct cvp_hfi_client client_data;
u32 stream_idx;
};
} __packed;
struct cvp_hfi_msg_session_hdr_d {
u32 size;
@ -415,7 +420,7 @@ struct cvp_hfi_msg_session_op_cfg_packet {
struct cvp_hfi_client client_data;
u32 stream_idx;
u32 op_conf_id;
};
} __packed;
struct cvp_hfi_msg_release_buffer_ref_event_packet {
u32 packet_buffer;
@ -479,13 +484,9 @@ struct cvp_hfi_msg_sys_debug_packet {
u8 rg_msg_data[1];
};
struct cvp_hfi_msg_sys_coverage_packet {
struct cvp_hfi_packet_header {
u32 size;
u32 packet_type;
u32 msg_size;
u32 time_stamp_hi;
u32 time_stamp_lo;
u8 rg_msg_data[1];
};
struct cvp_hfi_sfr_struct {

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

@ -17,11 +17,6 @@
extern struct msm_cvp_drv *cvp_driver;
static int _deprecated_hfi_msg_process(u32 device_id,
struct cvp_hfi_msg_session_hdr *pkt,
struct msm_cvp_cb_info *info,
struct msm_cvp_inst *inst);
static enum cvp_status hfi_map_err_status(u32 hfi_err)
{
enum cvp_status cvp_err;
@ -450,6 +445,7 @@ static int hfi_process_session_cvp_msg(u32 device_id,
struct msm_cvp_inst *inst = NULL;
struct msm_cvp_core *core;
void *session_id;
struct cvp_session_queue *sq;
if (!pkt) {
dprintk(CVP_ERR, "%s: invalid param\n", __func__);
@ -467,24 +463,10 @@ static int hfi_process_session_cvp_msg(u32 device_id,
return -EINVAL;
}
if (inst->deprecate_bitmask) {
if (pkt->packet_type == HFI_MSG_SESSION_CVP_DME
|| pkt->packet_type == HFI_MSG_SESSION_CVP_ICA
|| pkt->packet_type == HFI_MSG_SESSION_CVP_FD) {
u64 ktid;
u32 kdata1, kdata2;
kdata1 = pkt->client_data.kdata1;
kdata2 = pkt->client_data.kdata2;
ktid = ((u64)kdata2 << 32) | kdata1;
msm_cvp_unmap_buf_cpu(inst, ktid);
return _deprecated_hfi_msg_process(device_id,
pkt, info, inst);
}
dprintk(CVP_ERR, "Invalid deprecate_bitmask %#x\n",
inst->deprecate_bitmask);
}
if (pkt->client_data.kdata & FENCE_BIT)
sq = &inst->session_queue_fence;
else
sq = &inst->session_queue;
sess_msg = kmem_cache_alloc(cvp_driver->msg_cache, GFP_KERNEL);
if (sess_msg == NULL) {
@ -499,139 +481,27 @@ static int hfi_process_session_cvp_msg(u32 device_id,
__func__, pkt->packet_type,
hfi_map_err_status(get_msg_errorcode(pkt)), session_id);
spin_lock(&inst->session_queue.lock);
if (inst->session_queue.msg_count >= MAX_NUM_MSGS_PER_SESSION) {
spin_lock(&sq->lock);
if (sq->msg_count >= MAX_NUM_MSGS_PER_SESSION) {
dprintk(CVP_ERR, "Reached session queue size limit\n");
goto error_handle_msg;
}
list_add_tail(&sess_msg->node, &inst->session_queue.msgs);
inst->session_queue.msg_count++;
spin_unlock(&inst->session_queue.lock);
list_add_tail(&sess_msg->node, &sq->msgs);
sq->msg_count++;
spin_unlock(&sq->lock);
wake_up_all(&inst->session_queue.wq);
wake_up_all(&sq->wq);
info->response_type = HAL_NO_RESP;
return 0;
error_handle_msg:
spin_unlock(&inst->session_queue.lock);
spin_unlock(&sq->lock);
kmem_cache_free(cvp_driver->msg_cache, sess_msg);
return -ENOMEM;
}
static int hfi_process_session_cvp_dme(u32 device_id,
struct cvp_hfi_msg_session_hdr *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 < get_msg_size()) {
dprintk(CVP_ERR, "%s: bad_pkt_size %d\n", __func__, pkt->size);
return -E2BIG;
}
cmd_done.device_id = device_id;
cmd_done.session_id = (void *)(uintptr_t)get_msg_session_id(pkt);
cmd_done.status = hfi_map_err_status(get_msg_errorcode(pkt));
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_ica(u32 device_id,
struct cvp_hfi_msg_session_hdr *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 < get_msg_size()) {
dprintk(CVP_ERR, "%s: bad_pkt_size %d\n", __func__, pkt->size);
return -E2BIG;
}
cmd_done.device_id = device_id;
cmd_done.session_id = (void *)(uintptr_t)get_msg_session_id(pkt);
cmd_done.status = hfi_map_err_status(get_msg_errorcode(pkt));
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_ICA_FRAME_CMD_DONE;
info->response.cmd = cmd_done;
return 0;
}
static int hfi_process_session_cvp_fd(u32 device_id,
struct cvp_hfi_msg_session_hdr *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 < get_msg_size()) {
dprintk(CVP_ERR, "%s: bad_pkt_size %d\n", __func__, pkt->size);
return -E2BIG;
}
cmd_done.device_id = device_id;
cmd_done.session_id = (void *)(uintptr_t)get_msg_session_id(pkt);
cmd_done.status = hfi_map_err_status(get_msg_errorcode(pkt));
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_FD_FRAME_CMD_DONE;
info->response.cmd = cmd_done;
return 0;
}
static int _deprecated_hfi_msg_process(u32 device_id,
struct cvp_hfi_msg_session_hdr *pkt,
struct msm_cvp_cb_info *info,
struct msm_cvp_inst *inst)
{
if (pkt->packet_type == HFI_MSG_SESSION_CVP_DME)
if (test_bit(DME_BIT_OFFSET,
&inst->deprecate_bitmask))
return hfi_process_session_cvp_dme(
device_id, (void *)pkt, info);
if (pkt->packet_type == HFI_MSG_SESSION_CVP_ICA)
if (test_bit(ICA_BIT_OFFSET,
&inst->deprecate_bitmask))
return hfi_process_session_cvp_ica(
device_id, (void *)pkt, info);
if (pkt->packet_type == HFI_MSG_SESSION_CVP_FD)
if (test_bit(FD_BIT_OFFSET,
&inst->deprecate_bitmask))
return hfi_process_session_cvp_fd(
device_id, (void *)pkt, info);
dprintk(CVP_ERR, "Deprecatd MSG doesn't match bitmask %x %lx\n",
pkt->packet_type, inst->deprecate_bitmask);
return -EINVAL;
}
static void hfi_process_sys_get_prop_image_version(
struct cvp_hfi_msg_sys_property_info_packet *pkt)
{

980
drivers/media/platform/msm/cvp/msm_cvp.c
View file

File diff suppressed because it is too large Load diff

58
drivers/media/platform/msm/cvp/msm_cvp_common.c
View file

@ -406,54 +406,6 @@ int wait_for_sess_signal_receipt(struct msm_cvp_inst *inst,
return rc;
}
int wait_for_sess_signal_receipt_fence(struct msm_cvp_inst *inst,
enum hal_command_response cmd)
{
int rc = 0;
struct cvp_hfi_device *hdev;
int retry = FENCE_WAIT_SIGNAL_RETRY_TIMES;
if (!IS_HAL_SESSION_CMD(cmd)) {
dprintk(CVP_ERR, "Invalid inst cmd response: %d\n", cmd);
return -EINVAL;
}
hdev = (struct cvp_hfi_device *)(inst->core->device);
while (retry) {
rc = wait_for_completion_timeout(
&inst->completions[SESSION_MSG_INDEX(cmd)],
msecs_to_jiffies(FENCE_WAIT_SIGNAL_TIMEOUT));
if (!rc) {
enum cvp_event_t event;
unsigned long flags = 0;
spin_lock_irqsave(&inst->event_handler.lock, flags);
event = inst->event_handler.event;
spin_unlock_irqrestore(
&inst->event_handler.lock, flags);
if (event == CVP_SSR_EVENT) {
dprintk(CVP_WARN, "%s: SSR triggered\n",
__func__);
return -ECONNRESET;
}
--retry;
} else {
rc = 0;
break;
}
}
if (!retry) {
dprintk(CVP_WARN, "Wait interrupted or timed out: %d\n",
SESSION_MSG_INDEX(cmd));
call_hfi_op(hdev, flush_debug_queue, hdev->hfi_device_data);
dump_hfi_queue(hdev->hfi_device_data);
rc = -EIO;
}
return rc;
}
static int wait_for_state(struct msm_cvp_inst *inst,
enum instance_state flipped_state,
enum instance_state desired_state,
@ -774,13 +726,6 @@ static void handle_session_close(enum hal_command_response cmd, void *data)
cvp_put_inst(inst);
}
static void handle_operation_config(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);
@ -794,9 +739,6 @@ void cvp_handle_cmd_response(enum hal_command_response cmd, void *data)
case HAL_SESSION_INIT_DONE:
handle_session_init_done(cmd, data);
break;
case HAL_SESSION_CVP_OPERATION_CONFIG:
handle_operation_config(cmd, data);
break;
case HAL_SESSION_RELEASE_RESOURCE_DONE:
handle_release_res_done(cmd, data);
break;

2
drivers/media/platform/msm/cvp/msm_cvp_common.h
View file

@ -41,8 +41,6 @@ void print_cvp_buffer(u32 tag, const char *str,
struct msm_cvp_internal_buffer *cbuf);
int wait_for_sess_signal_receipt(struct msm_cvp_inst *inst,
enum hal_command_response cmd);
int wait_for_sess_signal_receipt_fence(struct msm_cvp_inst *inst,
enum hal_command_response cmd);
int cvp_comm_set_arp_buffers(struct msm_cvp_inst *inst);
int cvp_comm_release_persist_buffers(struct msm_cvp_inst *inst);
void print_client_buffer(u32 tag, const char *str,

25
drivers/media/platform/msm/cvp/msm_cvp_core.c
View file

@ -220,7 +220,7 @@ static bool msm_cvp_check_for_inst_overload(struct msm_cvp_core *core)
return overload;
}
static int _init_session_queue(struct msm_cvp_inst *inst)
static int __init_session_queue(struct msm_cvp_inst *inst)
{
spin_lock_init(&inst->session_queue.lock);
INIT_LIST_HEAD(&inst->session_queue.msgs);
@ -230,6 +230,21 @@ static int _init_session_queue(struct msm_cvp_inst *inst)
return 0;
}
static void __init_fence_queue(struct msm_cvp_inst *inst)
{
spin_lock_init(&inst->fence_cmd_queue.lock);
INIT_LIST_HEAD(&inst->fence_cmd_queue.wait_list);
INIT_LIST_HEAD(&inst->fence_cmd_queue.sched_list);
init_waitqueue_head(&inst->fence_cmd_queue.wq);
inst->fence_cmd_queue.state = QUEUE_ACTIVE;
spin_lock_init(&inst->session_queue_fence.lock);
INIT_LIST_HEAD(&inst->session_queue_fence.msgs);
inst->session_queue_fence.msg_count = 0;
init_waitqueue_head(&inst->session_queue_fence.wq);
inst->session_queue_fence.state = QUEUE_ACTIVE;
}
static void _deinit_session_queue(struct msm_cvp_inst *inst)
{
struct cvp_session_msg *msg, *tmpmsg;
@ -295,7 +310,6 @@ void *msm_cvp_open(int core_id, int session_type)
pr_info(CVP_DBG_TAG "Opening cvp instance: %pK\n", "info", inst);
mutex_init(&inst->sync_lock);
mutex_init(&inst->lock);
mutex_init(&inst->fence_lock);
spin_lock_init(&inst->event_handler.lock);
INIT_MSM_CVP_LIST(&inst->persistbufs);
@ -316,7 +330,6 @@ void *msm_cvp_open(int core_id, int session_type)
inst->clk_data.sys_cache_bw = 0;
inst->clk_data.bitrate = 0;
inst->clk_data.core_id = 0;
inst->deprecate_bitmask = 0;
for (i = SESSION_MSG_INDEX(SESSION_MSG_START);
i <= SESSION_MSG_INDEX(SESSION_MSG_END); i++) {
@ -329,7 +342,9 @@ void *msm_cvp_open(int core_id, int session_type)
list_add_tail(&inst->list, &core->instances);
mutex_unlock(&core->lock);
rc = _init_session_queue(inst);
__init_fence_queue(inst);
rc = __init_session_queue(inst);
if (rc)
goto fail_init;
@ -351,7 +366,6 @@ fail_init:
mutex_unlock(&core->lock);
mutex_destroy(&inst->sync_lock);
mutex_destroy(&inst->lock);
mutex_destroy(&inst->fence_lock);
DEINIT_MSM_CVP_LIST(&inst->persistbufs);
DEINIT_MSM_CVP_LIST(&inst->cvpcpubufs);
@ -400,7 +414,6 @@ int msm_cvp_destroy(struct msm_cvp_inst *inst)
mutex_destroy(&inst->sync_lock);
mutex_destroy(&inst->lock);
mutex_destroy(&inst->fence_lock);
msm_cvp_debugfs_deinit_inst(inst);
_deinit_session_queue(inst);

38
drivers/media/platform/msm/cvp/msm_cvp_internal.h
View file

@ -23,6 +23,7 @@
#include <media/msm_media_info.h>
#include <media/msm_cvp_private.h>
#include "cvp_hfi_api.h"
#include <synx_api.h>
#define MAX_SUPPORTED_INSTANCES 16
#define MAX_NAME_LENGTH 64
@ -30,6 +31,11 @@
#define MAX_DSP_INIT_ATTEMPTS 16
#define FENCE_WAIT_SIGNAL_TIMEOUT 100
#define FENCE_WAIT_SIGNAL_RETRY_TIMES 20
#define FENCE_BIT (1ULL << 63)
#define FENCE_DME_ICA_ENABLED_IDX 0
#define FENCE_DME_DS_IDX 1
#define FENCE_DME_OUTPUT_IDX 7
#define SYS_MSG_START HAL_SYS_INIT_DONE
#define SYS_MSG_END HAL_SYS_ERROR
@ -265,6 +271,7 @@ struct cvp_session_prop {
u32 priority;
u32 is_secure;
u32 dsp_mask;
u32 fthread_nr;
u32 fdu_cycles;
u32 od_cycles;
u32 mpu_cycles;
@ -281,6 +288,14 @@ struct cvp_session_prop {
u32 ddr_op_cache;
};
struct cvp_fence_queue {
spinlock_t lock;
enum queue_state state;
struct list_head wait_list;
wait_queue_head_t wq;
struct list_head sched_list;
};
enum cvp_event_t {
CVP_NO_EVENT,
CVP_SSR_EVENT = 1,
@ -331,6 +346,7 @@ struct msm_cvp_inst {
struct msm_cvp_core *core;
enum session_type session_type;
struct cvp_session_queue session_queue;
struct cvp_session_queue session_queue_fence;
struct cvp_session_event event_handler;
void *session;
enum instance_state state;
@ -346,11 +362,11 @@ struct msm_cvp_inst {
enum msm_cvp_modes flags;
struct msm_cvp_capability capability;
struct kref kref;
unsigned long deprecate_bitmask;
struct cvp_kmd_request_power power;
struct cvp_session_prop prop;
u32 cur_cmd_type;
struct mutex fence_lock;
struct synx_session synx_session_id;
struct cvp_fence_queue fence_cmd_queue;
};
struct msm_cvp_fence_thread_data {
@ -360,6 +376,18 @@ struct msm_cvp_fence_thread_data {
unsigned int arg_type;
};
struct cvp_fence_type {
s32 h_synx;
u32 secure_key;
};
struct cvp_fence_command {
struct list_head list;
u32 type;
u32 synx[MAX_HFI_FENCE_SIZE/2];
struct cvp_hfi_cmd_session_hdr *pkt;
};
extern struct msm_cvp_drv *cvp_driver;
void cvp_handle_cmd_response(enum hal_command_response cmd, void *data);
@ -367,12 +395,6 @@ int msm_cvp_trigger_ssr(struct msm_cvp_core *core,
enum hal_ssr_trigger_type type);
int msm_cvp_noc_error_info(struct msm_cvp_core *core);
enum msm_cvp_flags {
MSM_CVP_FLAG_DEFERRED = BIT(0),
MSM_CVP_FLAG_RBR_PENDING = BIT(1),
MSM_CVP_FLAG_QUEUED = BIT(2),
};
struct msm_cvp_internal_buffer {
struct list_head list;
struct msm_cvp_smem smem;

86
drivers/media/platform/msm/cvp/msm_cvp_ioctl.c
View file

@ -165,37 +165,6 @@ static int _copy_sysprop_to_user(struct cvp_kmd_arg *kp,
}
static void _set_deprecate_bitmask(struct cvp_kmd_arg *kp,
struct msm_cvp_inst *inst)
{
dprintk(CVP_INFO, "%s: kp->type = %#x\n", __func__, kp->type);
switch (kp->type) {
case CVP_KMD_HFI_DFS_FRAME_CMD:
{
set_bit(DFS_BIT_OFFSET, &inst->deprecate_bitmask);
break;
}
case CVP_KMD_HFI_DME_FRAME_CMD:
{
set_bit(DME_BIT_OFFSET, &inst->deprecate_bitmask);
break;
}
case CVP_KMD_HFI_DME_FRAME_FENCE_CMD:
{
set_bit(DME_BIT_OFFSET, &inst->deprecate_bitmask);
break;
}
case CVP_KMD_HFI_FD_FRAME_CMD:
{
set_bit(FD_BIT_OFFSET, &inst->deprecate_bitmask);
break;
}
default:
break;
}
}
static void print_hfi_short(struct cvp_kmd_arg __user *up)
{
struct cvp_kmd_hfi_packet *pkt;
@ -262,8 +231,6 @@ static int convert_from_user(struct cvp_kmd_arg *kp,
if (get_user(kp->type, &up->type))
return -EFAULT;
_set_deprecate_bitmask(kp, inst);
if (get_user(kp->buf_offset, &up->buf_offset) ||
get_user(kp->buf_num, &up->buf_num))
return -EFAULT;
@ -336,27 +303,7 @@ static int convert_from_user(struct cvp_kmd_arg *kp,
return -EFAULT;
break;
}
case CVP_KMD_HFI_SEND_CMD:
{
struct cvp_kmd_send_cmd *k, *u;
k = &kp->data.send_cmd;
u = &up->data.send_cmd;
if (get_user(k->cmd_address_fd, &u->cmd_address_fd) ||
get_user(k->cmd_size, &u->cmd_size))
return -EFAULT;
for (i = 0; i < 10; i++)
if (get_user(k->reserved[i], &u->reserved[i]))
return -EFAULT;
break;
}
case CVP_KMD_SEND_CMD_PKT:
case CVP_KMD_HFI_DFS_CONFIG_CMD:
case CVP_KMD_HFI_DFS_FRAME_CMD:
case CVP_KMD_HFI_DME_CONFIG_CMD:
case CVP_KMD_HFI_DME_FRAME_CMD:
case CVP_KMD_HFI_PERSIST_CMD:
case CVP_KMD_HFI_FD_FRAME_CMD:
{
if (_get_pkt_hdr_from_user(up, &pkt_hdr)) {
dprintk(CVP_ERR, "Invalid syscall: %x, %x, %x\n",
@ -368,7 +315,6 @@ static int convert_from_user(struct cvp_kmd_arg *kp,
break;
}
case CVP_KMD_SEND_FENCE_CMD_PKT:
case CVP_KMD_HFI_DME_FRAME_FENCE_CMD:
{
if (_get_fence_pkt_hdr_from_user(up, &pkt_hdr)) {
dprintk(CVP_ERR, "Invalid syscall: %x, %x, %x\n",
@ -387,14 +333,9 @@ static int convert_from_user(struct cvp_kmd_arg *kp,
return -EFAULT;
}
set_feature_bitmask(pkt_idx, &inst->deprecate_bitmask);
rc = _copy_fence_pkt_from_user(kp, up, (pkt_hdr.size >> 2));
break;
}
case CVP_KMD_HFI_DFS_FRAME_CMD_RESPONSE:
case CVP_KMD_HFI_DME_FRAME_CMD_RESPONSE:
case CVP_KMD_HFI_PERSIST_CMD_RESPONSE:
case CVP_KMD_RECEIVE_MSG_PKT:
break;
case CVP_KMD_SESSION_CONTROL:
@ -529,33 +470,7 @@ static int convert_to_user(struct cvp_kmd_arg *kp, unsigned long arg)
return -EFAULT;
break;
}
case CVP_KMD_HFI_SEND_CMD:
{
struct cvp_kmd_send_cmd *k, *u;
dprintk(CVP_DBG, "%s: CVP_KMD_HFI_SEND_CMD\n",
__func__);
k = &kp->data.send_cmd;
u = &up->data.send_cmd;
if (put_user(k->cmd_address_fd, &u->cmd_address_fd) ||
put_user(k->cmd_size, &u->cmd_size))
return -EFAULT;
for (i = 0; i < 10; i++)
if (put_user(k->reserved[i], &u->reserved[i]))
return -EFAULT;
break;
}
case CVP_KMD_SEND_CMD_PKT:
case CVP_KMD_HFI_DFS_CONFIG_CMD:
case CVP_KMD_HFI_DFS_FRAME_CMD:
case CVP_KMD_HFI_DFS_FRAME_CMD_RESPONSE:
case CVP_KMD_HFI_DME_CONFIG_CMD:
case CVP_KMD_HFI_DME_FRAME_CMD:
case CVP_KMD_HFI_DME_FRAME_CMD_RESPONSE:
case CVP_KMD_HFI_PERSIST_CMD:
case CVP_KMD_HFI_PERSIST_CMD_RESPONSE:
case CVP_KMD_HFI_FD_FRAME_CMD:
{
if (_get_pkt_hdr_from_user(up, &pkt_hdr))
return -EFAULT;
@ -566,7 +481,6 @@ static int convert_to_user(struct cvp_kmd_arg *kp, unsigned long arg)
break;
}
case CVP_KMD_SEND_FENCE_CMD_PKT:
case CVP_KMD_HFI_DME_FRAME_FENCE_CMD:
{
if (_get_fence_pkt_hdr_from_user(up, &pkt_hdr))
return -EFAULT;

40
include/uapi/media/msm_cvp_private.h
View file

@ -8,12 +8,6 @@
#define MAX_DFS_HFI_PARAMS 20
#define HFI_MAX_PLANES 4
#define BASE_PRIVATE_CVP 36
/* VIDIOC private cvp command */
#define VIDIOC_CVP_CMD \
_IOWR('V', BASE_PRIVATE_CVP, struct cvp_kmd_arg)
/* Commands type */
#define CVP_KMD_CMD_BASE 0x10000000
#define CVP_KMD_CMD_START (CVP_KMD_CMD_BASE + 0x1000)
@ -51,30 +45,6 @@
*/
#define CVP_KMD_UNREGISTER_BUFFER (CVP_KMD_CMD_START + 4)
#define CVP_KMD_HFI_SEND_CMD (CVP_KMD_CMD_START + 5)
#define CVP_KMD_HFI_DFS_CONFIG_CMD (CVP_KMD_CMD_START + 6)
#define CVP_KMD_HFI_DFS_FRAME_CMD (CVP_KMD_CMD_START + 7)
#define CVP_KMD_HFI_DFS_FRAME_CMD_RESPONSE (CVP_KMD_CMD_START + 8)
#define CVP_KMD_HFI_DME_CONFIG_CMD (CVP_KMD_CMD_START + 9)
#define CVP_KMD_HFI_DME_FRAME_CMD (CVP_KMD_CMD_START + 10)
#define CVP_KMD_HFI_DME_FRAME_CMD_RESPONSE (CVP_KMD_CMD_START + 11)
#define CVP_KMD_HFI_PERSIST_CMD (CVP_KMD_CMD_START + 12)
#define CVP_KMD_HFI_PERSIST_CMD_RESPONSE (CVP_KMD_CMD_START + 13)
#define CVP_KMD_HFI_DME_FRAME_FENCE_CMD (CVP_KMD_CMD_START + 14)
#define CVP_KMD_HFI_ICA_FRAME_CMD (CVP_KMD_CMD_START + 15)
#define CVP_KMD_HFI_FD_FRAME_CMD (CVP_KMD_CMD_START + 16)
#define CVP_KMD_UPDATE_POWER (CVP_KMD_CMD_START + 17)
#define CVP_KMD_SEND_CMD_PKT (CVP_KMD_CMD_START + 64)
@ -87,7 +57,11 @@
#define CVP_KMD_SESSION_CONTROL (CVP_KMD_CMD_START + 68)
#define CVP_KMD_SEND_FENCE_CMD_PKT (0x10001000 + 69)
#define CVP_KMD_SEND_FENCE_CMD_PKT (CVP_KMD_CMD_START + 69)
#define CVP_KMD_FLUSH_ALL (CVP_KMD_CMD_START + 70)
#define CVP_KMD_FLUSH_FRAME (CVP_KMD_CMD_START + 71)
/* flags */
#define CVP_KMD_FLAG_UNSECURE 0x00000000
@ -275,8 +249,8 @@ struct cvp_kmd_hfi_fence_packet {
/**
* struct cvp_kmd_arg - argument passed with VIDIOC_CVP_CMD
* To be deprecated
* struct cvp_kmd_arg
*
* @type: command type
* @buf_offset: offset to buffer list in the command
* @buf_num: number of buffers in the command