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: camera: core: Handle request abort and signal fence CANCEL" into camera-kernel.lnx.4.0

Browse source
This commit is contained in:
Camera Software Integration 2020-07-02 17:46:10 -07:00 • committed by Gerrit - the friendly Code Review server
commit cbd7f1bc3e
8 changed files with 49 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

23
drivers/cam_core/cam_context_utils.c
View file

@ -32,7 +32,7 @@ static inline int cam_context_validate_thread(void)
}
int cam_context_buf_done_from_hw(struct cam_context *ctx,
void *done_event_data, uint32_t bubble_state)
void *done_event_data, uint32_t evt_id)
{
int j;
int result;
@ -84,21 +84,20 @@ int cam_context_buf_done_from_hw(struct cam_context *ctx,
*/
list_del_init(&req->list);
spin_unlock(&ctx->lock);
if (!bubble_state) {
if (evt_id == CAM_CTX_EVT_ID_SUCCESS)
result = CAM_SYNC_STATE_SIGNALED_SUCCESS;
} else {
CAM_DBG(CAM_REQ,
"[%s][ctx_id %d] : req[%llu] is done with error",
ctx->dev_name, ctx->ctx_id, req->request_id);
for (j = 0; j < req->num_out_map_entries; j++)
CAM_DBG(CAM_REQ, "fence %d signaled with error",
req->out_map_entries[j].sync_id);
else if (evt_id == CAM_CTX_EVT_ID_CANCEL)
result = CAM_SYNC_STATE_SIGNALED_CANCEL;
else
result = CAM_SYNC_STATE_SIGNALED_ERROR;
}
CAM_DBG(CAM_REQ,
"[%s][ctx_id %d] : req[%llu] : Signaling %d",
ctx->dev_name, ctx->ctx_id, req->request_id, result);
for (j = 0; j < req->num_out_map_entries; j++) {
CAM_DBG(CAM_REQ, "fence %d signal with %d",
req->out_map_entries[j].sync_id, result);
cam_sync_signal(req->out_map_entries[j].sync_id, result);
req->out_map_entries[j].sync_id = -1;
}

4
drivers/cam_core/cam_context_utils.h
View file

@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
*/
#ifndef _CAM_CONTEXT_UTILS_H_
@ -9,7 +9,7 @@
#include <linux/types.h>
int cam_context_buf_done_from_hw(struct cam_context *ctx,
void *done_event_data, uint32_t bubble_state);
void *done_event_data, uint32_t evt_id);
int32_t cam_context_release_dev_to_hw(struct cam_context *ctx,
struct cam_release_dev_cmd *cmd);
int32_t cam_context_prepare_dev_to_hw(struct cam_context *ctx,

4
drivers/cam_core/cam_hw_mgr_intf.h
View file

@ -35,6 +35,10 @@ enum cam_context_dump_id {
CAM_CTX_DUMP_TYPE_MAX,
};
#define CAM_CTX_EVT_ID_SUCCESS 0
#define CAM_CTX_EVT_ID_ERROR 1
#define CAM_CTX_EVT_ID_CANCEL 2
/* hardware event callback function type */
typedef int (*cam_hw_event_cb_func)(void *context, uint32_t evt_id,
void *evt_data);

7
drivers/cam_fd/fd_hw_mgr/cam_fd_hw_mgr.c
View file

@ -947,7 +947,7 @@ static int32_t cam_fd_mgr_workq_irq_cb(void *priv, void *data)
struct cam_fd_mgr_work_data *work_data;
struct cam_fd_mgr_frame_request *frame_req = NULL;
enum cam_fd_hw_irq_type irq_type;
bool frame_abort = true;
uint32_t evt_id = CAM_CTX_EVT_ID_ERROR;
int rc;
if (!data || !priv) {
@ -1013,12 +1013,11 @@ static int32_t cam_fd_mgr_workq_irq_cb(void *priv, void *data)
if (rc) {
CAM_ERR(CAM_FD, "Failed in CMD_PRESTART %d",
rc);
frame_abort = true;
goto notify_context;
}
}
frame_abort = false;
evt_id = CAM_CTX_EVT_ID_SUCCESS;
}
trace_cam_irq_handled("FD", irq_type);
@ -1035,7 +1034,7 @@ notify_context:
buf_data.request_id = frame_req->request_id;
rc = frame_req->hw_ctx->event_cb(frame_req->hw_ctx->cb_priv,
frame_abort, &buf_data);
evt_id, &buf_data);
if (rc)
CAM_ERR(CAM_FD, "Error in event cb handling %d", rc);
}

20
drivers/cam_icp/icp_hw/icp_hw_mgr/cam_icp_hw_mgr.c
View file

@ -1995,7 +1995,7 @@ static int cam_icp_mgr_cleanup_ctx(struct cam_icp_hw_ctx_data *ctx_data)
continue;
buf_data.request_id = hfi_frame_process->request_id[i];
ctx_data->ctxt_event_cb(ctx_data->context_priv,
false, &buf_data);
CAM_CTX_EVT_ID_SUCCESS, &buf_data);
hfi_frame_process->request_id[i] = 0;
if (ctx_data->hfi_frame_process.in_resource[i] > 0) {
CAM_DBG(CAM_ICP, "Delete merged sync in object: %d",
@ -2096,6 +2096,7 @@ static int cam_icp_mgr_handle_frame_process(uint32_t *msg_ptr, int flag)
struct hfi_frame_process_info *hfi_frame_process;
struct cam_hw_done_event_data buf_data;
uint32_t clk_type;
uint32_t event_id;
ioconfig_ack = (struct hfi_msg_ipebps_async_ack *)msg_ptr;
request_id = ioconfig_ack->user_data2;
@ -2138,12 +2139,13 @@ static int cam_icp_mgr_handle_frame_process(uint32_t *msg_ptr, int flag)
idx = i;
if (flag == ICP_FRAME_PROCESS_FAILURE) {
if (ioconfig_ack->err_type == CAMERAICP_EABORTED)
if (ioconfig_ack->err_type == CAMERAICP_EABORTED) {
CAM_WARN(CAM_ICP,
"ctx_id %d req %llu dev %d has been aborted[flushed]",
ctx_data->ctx_id, request_id,
ctx_data->icp_dev_acquire_info->dev_type);
else
event_id = CAM_CTX_EVT_ID_CANCEL;
} else {
CAM_ERR(CAM_ICP,
"Done with error: %u err_type= [%s] on ctx_id %d dev %d for req %llu",
ioconfig_ack->err_type,
@ -2152,10 +2154,14 @@ static int cam_icp_mgr_handle_frame_process(uint32_t *msg_ptr, int flag)
ctx_data->ctx_id,
ctx_data->icp_dev_acquire_info->dev_type,
request_id);
event_id = CAM_CTX_EVT_ID_ERROR;
}
} else {
event_id = CAM_CTX_EVT_ID_SUCCESS;
}
buf_data.request_id = hfi_frame_process->request_id[idx];
ctx_data->ctxt_event_cb(ctx_data->context_priv, flag, &buf_data);
ctx_data->ctxt_event_cb(ctx_data->context_priv, event_id, &buf_data);
hfi_frame_process->request_id[idx] = 0;
if (ctx_data->hfi_frame_process.in_resource[idx] > 0) {
CAM_DBG(CAM_ICP, "Delete merged sync in object: %d",
@ -3890,7 +3896,8 @@ static int cam_icp_mgr_handle_config_err(
struct cam_hw_done_event_data buf_data;
buf_data.request_id = *(uint64_t *)config_args->priv;
ctx_data->ctxt_event_cb(ctx_data->context_priv, false, &buf_data);
ctx_data->ctxt_event_cb(ctx_data->context_priv, CAM_CTX_EVT_ID_SUCCESS,
&buf_data);
ctx_data->hfi_frame_process.request_id[idx] = 0;
ctx_data->hfi_frame_process.fw_process_flag[idx] = false;
@ -4962,7 +4969,8 @@ static int cam_icp_mgr_send_abort_status(struct cam_icp_hw_ctx_data *ctx_data)
if (!hfi_frame_process->request_id[idx])
continue;
ctx_data->ctxt_event_cb(ctx_data->context_priv, true,
ctx_data->ctxt_event_cb(ctx_data->context_priv,
CAM_CTX_EVT_ID_CANCEL,
&hfi_frame_process->request_id[idx]);
/* now release memory for hfi frame process command */

6
drivers/cam_jpeg/jpeg_hw/cam_jpeg_hw_mgr.c
View file

@ -175,7 +175,8 @@ static int cam_jpeg_mgr_process_irq(void *priv, void *data)
}
buf_data.request_id =
PTR_TO_U64(p_cfg_req->hw_cfg_args.priv);
ctx_data->ctxt_event_cb(ctx_data->context_priv, 0, &buf_data);
ctx_data->ctxt_event_cb(ctx_data->context_priv, CAM_CTX_EVT_ID_SUCCESS,
&buf_data);
mutex_lock(&g_jpeg_hw_mgr.hw_mgr_mutex);
list_add_tail(&p_cfg_req->list, &hw_mgr->free_req_list);
@ -505,7 +506,8 @@ end_callcb:
}
buf_data.request_id =
(uintptr_t)p_cfg_req->hw_cfg_args.priv;
ctx_data->ctxt_event_cb(ctx_data->context_priv, 0, &buf_data);
ctx_data->ctxt_event_cb(ctx_data->context_priv,
CAM_CTX_EVT_ID_ERROR, &buf_data);
}
end_unusedev:
mutex_lock(&hw_mgr->hw_mgr_mutex);

12
drivers/cam_lrme/lrme_hw_mgr/cam_lrme_hw_mgr.c
View file

@ -498,7 +498,7 @@ static int cam_lrme_mgr_cb(void *data,
{
struct cam_lrme_hw_mgr *hw_mgr = &g_lrme_hw_mgr;
int rc = 0;
bool frame_abort = true;
uint32_t evt_id = CAM_CTX_EVT_ID_ERROR;
struct cam_lrme_frame_request *frame_req;
struct cam_lrme_device *hw_device;
@ -530,10 +530,10 @@ static int cam_lrme_mgr_cb(void *data,
if (cb_args->cb_type & CAM_LRME_CB_BUF_DONE) {
cb_args->cb_type &= ~CAM_LRME_CB_BUF_DONE;
frame_abort = false;
evt_id = CAM_CTX_EVT_ID_SUCCESS;
} else if (cb_args->cb_type & CAM_LRME_CB_ERROR) {
cb_args->cb_type &= ~CAM_LRME_CB_ERROR;
frame_abort = true;
evt_id = CAM_CTX_EVT_ID_ERROR;
} else {
CAM_ERR(CAM_LRME, "Wrong cb type %d, req %lld",
cb_args->cb_type, frame_req->req_id);
@ -544,10 +544,10 @@ static int cam_lrme_mgr_cb(void *data,
struct cam_hw_done_event_data buf_data;
buf_data.request_id = frame_req->req_id;
CAM_DBG(CAM_LRME, "frame req %llu, frame_abort %d",
frame_req->req_id, frame_abort);
CAM_DBG(CAM_LRME, "frame req %llu, evt_id %d",
frame_req->req_id, evt_id);
rc = hw_mgr->event_cb(frame_req->ctxt_to_hw_map,
frame_abort, &buf_data);
evt_id, &buf_data);
} else {
CAM_ERR(CAM_LRME, "No cb function");
}

9
drivers/cam_ope/ope_hw_mgr/cam_ope_hw_mgr.c
View file

@ -1519,7 +1519,7 @@ static void cam_ope_ctx_cdm_callback(uint32_t handle, void *userdata,
struct cam_ope_request *ope_req;
struct cam_hw_done_event_data buf_data;
struct timespec64 ts;
bool flag = false;
uint32_t evt_id = CAM_CTX_EVT_ID_SUCCESS;
if (!userdata) {
CAM_ERR(CAM_OPE, "Invalid ctx from CDM callback");
@ -1582,7 +1582,7 @@ static void cam_ope_ctx_cdm_callback(uint32_t handle, void *userdata,
if (status != CAM_CDM_CB_STATUS_HW_FLUSH)
cam_ope_dump_req_data(ope_req);
rc = cam_ope_mgr_reset_hw();
flag = true;
evt_id = CAM_CTX_EVT_ID_ERROR;
}
ctx->req_cnt--;
@ -1595,7 +1595,7 @@ static void cam_ope_ctx_cdm_callback(uint32_t handle, void *userdata,
kzfree(ctx->req_list[cookie]);
ctx->req_list[cookie] = NULL;
clear_bit(cookie, ctx->bitmap);
ctx->ctxt_event_cb(ctx->context_priv, flag, &buf_data);
ctx->ctxt_event_cb(ctx->context_priv, evt_id, &buf_data);
end:
mutex_unlock(&ctx->ctx_mutex);
@ -3203,7 +3203,8 @@ static int cam_ope_mgr_handle_config_err(
ope_req = config_args->priv;
buf_data.request_id = ope_req->request_id;
ctx_data->ctxt_event_cb(ctx_data->context_priv, false, &buf_data);
ctx_data->ctxt_event_cb(ctx_data->context_priv, CAM_CTX_EVT_ID_ERROR,
&buf_data);
req_idx = ope_req->req_idx;
ope_req->request_id = 0;