mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-08 21:22:09 -04:00
msm: cvp: Fence path for Lahaina
Camera requires new features supported in cvp driver but the existing camera fence path framework in cvp driver is not scable.Redesign fench path to enhance its scability by adding worker thread pool. Change-Id: If8b31ddb082089463aca1f3d600a9fed1ed05996 Signed-off-by: Ruofei Ma <ruofeim@codeaurora.org>
This commit is contained in:
Ruofei Ma
Gerrit - the friendly Code Review server
parent
13879ddd57
commit
385d8d832b
11 changed files with 543 additions and 890 deletions
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in a new issue