samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

msm: camera: reqmgr: Add notify frame skip interface

Browse Source 
This change adds support to notify frame skip when CRM
not ready to apply a normal setting. Sensor and custom
device also want to update the HW settings in some
conditions even if a frame is skipped.

CRs-Fixed: 2691642
Change-Id: Ibd2b22655d0f6b6c90663df75a0f5fad8565e918
Signed-off-by: Depeng Shao <depengs@codeaurora.org>
This commit is contained in:
Depeng Shao
2020-05-21 10:55:37 +08:00
parent cbac6f37f9
commit c782e8c3ab
12 changed files with 335 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
drivers/cam_core/cam_context.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only // 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.
*/ */
#include <linux/slab.h> #include <linux/slab.h>
@@ -182,7 +182,7 @@ int cam_context_handle_crm_apply_req(struct cam_context *ctx,
return rc; return rc;
} }
int cam_context_handle_crm_apply_default_req( int cam_context_handle_crm_notify_frame_skip(
struct cam_context *ctx, struct cam_context *ctx,
struct cam_req_mgr_apply_request *apply) struct cam_req_mgr_apply_request *apply)
{ {
@@ -199,11 +199,12 @@ int cam_context_handle_crm_apply_default_req(
} }
mutex_lock(&ctx->ctx_mutex); mutex_lock(&ctx->ctx_mutex);
if (ctx->state_machine[ctx->state].crm_ops.apply_default) if (ctx->state_machine[ctx->state].crm_ops.notify_frame_skip)
rc = ctx->state_machine[ctx->state].crm_ops.apply_default(ctx, rc = ctx->state_machine[ctx->state].crm_ops.notify_frame_skip(
apply); ctx, apply);
else else
CAM_DBG(CAM_CORE, "No crm apply_default in dev %d, state %d", CAM_DBG(CAM_CORE,
"No crm notify_frame_skip in dev %d, state %d",
ctx->dev_hdl, ctx->state); ctx->dev_hdl, ctx->state);
mutex_unlock(&ctx->ctx_mutex); mutex_unlock(&ctx->ctx_mutex);

14
drivers/cam_core/cam_context.h
View File

@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */ /* 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_H_ #ifndef _CAM_CONTEXT_H_
@@ -121,7 +121,7 @@ struct cam_ctx_ioctl_ops {
* @link: Link the context * @link: Link the context
* @unlink: Unlink the context * @unlink: Unlink the context
* @apply_req: Apply setting for the context * @apply_req: Apply setting for the context
* @apply_default: Apply default settings for the context * @notify_frame_skip: Notify device that a frame is skipped
* @flush_req: Flush request to remove request ids * @flush_req: Flush request to remove request ids
* @process_evt: Handle event notification from CRM.(optional) * @process_evt: Handle event notification from CRM.(optional)
* @dump_req: Dump information for the issue request * @dump_req: Dump information for the issue request
@@ -136,7 +136,7 @@ struct cam_ctx_crm_ops {
struct cam_req_mgr_core_dev_link_setup *unlink); struct cam_req_mgr_core_dev_link_setup *unlink);
int (*apply_req)(struct cam_context *ctx, int (*apply_req)(struct cam_context *ctx,
struct cam_req_mgr_apply_request *apply); struct cam_req_mgr_apply_request *apply);
int (*apply_default)(struct cam_context *ctx, int (*notify_frame_skip)(struct cam_context *ctx,
struct cam_req_mgr_apply_request *apply); struct cam_req_mgr_apply_request *apply);
int (*flush_req)(struct cam_context *ctx, int (*flush_req)(struct cam_context *ctx,
struct cam_req_mgr_flush_request *flush); struct cam_req_mgr_flush_request *flush);
@@ -306,15 +306,15 @@ int cam_context_handle_crm_apply_req(struct cam_context *ctx,
struct cam_req_mgr_apply_request *apply); struct cam_req_mgr_apply_request *apply);
/** /**
* cam_context_handle_crm_apply_default_req() * cam_context_handle_crm_notify_frame_skip()
* *
* @brief: Handle apply default request command * @brief: Handle notify frame skip command
* *
* @ctx: Object pointer for cam_context * @ctx: Object pointer for cam_context
* @apply: Apply default request command payload * @apply: Notify frame skip command payload
* *
*/ */
int cam_context_handle_crm_apply_default_req( int cam_context_handle_crm_notify_frame_skip(
struct cam_context *ctx, struct cam_req_mgr_apply_request *apply); struct cam_context *ctx, struct cam_req_mgr_apply_request *apply);
/** /**

9
drivers/cam_core/cam_node.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only // 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.
*/ */
#include <linux/debugfs.h> #include <linux/debugfs.h>
@@ -570,7 +570,7 @@ static int __cam_node_crm_apply_req(struct cam_req_mgr_apply_request *apply)
return cam_context_handle_crm_apply_req(ctx, apply); return cam_context_handle_crm_apply_req(ctx, apply);
} }
static int __cam_node_crm_apply_default_req( static int __cam_node_crm_notify_frame_skip(
struct cam_req_mgr_apply_request *apply) struct cam_req_mgr_apply_request *apply)
{ {
struct cam_context *ctx = NULL; struct cam_context *ctx = NULL;
@@ -587,7 +587,7 @@ static int __cam_node_crm_apply_default_req(
trace_cam_apply_req("Node", apply->request_id); trace_cam_apply_req("Node", apply->request_id);
return cam_context_handle_crm_apply_default_req(ctx, apply); return cam_context_handle_crm_notify_frame_skip(ctx, apply);
} }
static int __cam_node_crm_flush_req(struct cam_req_mgr_flush_request *flush) static int __cam_node_crm_flush_req(struct cam_req_mgr_flush_request *flush)
@@ -703,7 +703,8 @@ int cam_node_init(struct cam_node *node, struct cam_hw_mgr_intf *hw_mgr_intf,
node->crm_node_intf.flush_req = __cam_node_crm_flush_req; node->crm_node_intf.flush_req = __cam_node_crm_flush_req;
node->crm_node_intf.process_evt = __cam_node_crm_process_evt; node->crm_node_intf.process_evt = __cam_node_crm_process_evt;
node->crm_node_intf.dump_req = __cam_node_crm_dump_req; node->crm_node_intf.dump_req = __cam_node_crm_dump_req;
node->crm_node_intf.apply_default = __cam_node_crm_apply_default_req; node->crm_node_intf.notify_frame_skip =
__cam_node_crm_notify_frame_skip;
mutex_init(&node->list_mutex); mutex_init(&node->list_mutex);
INIT_LIST_HEAD(&node->free_ctx_list); INIT_LIST_HEAD(&node->free_ctx_list);

11
drivers/cam_cust/cam_custom_context.c
View File

@@ -219,7 +219,7 @@ static struct cam_ctx_ops
.ioctl_ops = {}, .ioctl_ops = {},
.crm_ops = { .crm_ops = {
.apply_req = __cam_custom_ctx_apply_req_in_activated, .apply_req = __cam_custom_ctx_apply_req_in_activated,
.apply_default = .notify_frame_skip =
__cam_custom_ctx_apply_default_settings, __cam_custom_ctx_apply_default_settings,
}, },
.irq_ops = NULL, .irq_ops = NULL,
@@ -229,7 +229,7 @@ static struct cam_ctx_ops
.ioctl_ops = {}, .ioctl_ops = {},
.crm_ops = { .crm_ops = {
.apply_req = __cam_custom_ctx_apply_req_in_activated, .apply_req = __cam_custom_ctx_apply_req_in_activated,
.apply_default = .notify_frame_skip =
__cam_custom_ctx_apply_default_settings, __cam_custom_ctx_apply_default_settings,
}, },
.irq_ops = NULL, .irq_ops = NULL,
@@ -414,7 +414,6 @@ static int __cam_custom_ctx_get_dev_info_in_acquired(struct cam_context *ctx,
dev_info->dev_id = CAM_REQ_MGR_DEVICE_CUSTOM_HW; dev_info->dev_id = CAM_REQ_MGR_DEVICE_CUSTOM_HW;
dev_info->p_delay = 1; dev_info->p_delay = 1;
dev_info->trigger = CAM_TRIGGER_POINT_SOF; dev_info->trigger = CAM_TRIGGER_POINT_SOF;
dev_info->enable_apply_default = true;
return 0; return 0;
} }
@@ -1452,8 +1451,8 @@ static int __cam_custom_ctx_apply_default_req(
ctx_ops = &custom_ctx->substate_machine[ ctx_ops = &custom_ctx->substate_machine[
custom_ctx->substate_activated]; custom_ctx->substate_activated];
if (ctx_ops->crm_ops.apply_default) { if (ctx_ops->crm_ops.notify_frame_skip) {
rc = ctx_ops->crm_ops.apply_default(ctx, apply); rc = ctx_ops->crm_ops.notify_frame_skip(ctx, apply);
} else { } else {
CAM_WARN_RATE_LIMIT(CAM_CUSTOM, CAM_WARN_RATE_LIMIT(CAM_CUSTOM,
"No handle function in activated substate %d", "No handle function in activated substate %d",
@@ -1547,7 +1546,7 @@ static struct cam_ctx_ops
.crm_ops = { .crm_ops = {
.unlink = __cam_custom_ctx_unlink_in_activated, .unlink = __cam_custom_ctx_unlink_in_activated,
.apply_req = __cam_custom_ctx_apply_req, .apply_req = __cam_custom_ctx_apply_req,
.apply_default = .notify_frame_skip =
__cam_custom_ctx_apply_default_req, __cam_custom_ctx_apply_default_req,
.flush_req = __cam_custom_ctx_flush_req_in_top_state, .flush_req = __cam_custom_ctx_flush_req_in_top_state,
.process_evt = __cam_custom_ctx_process_evt, .process_evt = __cam_custom_ctx_process_evt,

173
drivers/cam_req_mgr/cam_req_mgr_core.c
View File

@@ -21,6 +21,8 @@ static struct cam_req_mgr_core_link g_links[MAXIMUM_LINKS_PER_SESSION];
void cam_req_mgr_core_link_reset(struct cam_req_mgr_core_link *link) void cam_req_mgr_core_link_reset(struct cam_req_mgr_core_link *link)
{ {
uint32_t pd = 0;
link->link_hdl = 0; link->link_hdl = 0;
link->num_devs = 0; link->num_devs = 0;
link->max_delay = CAM_PIPELINE_DELAY_0; link->max_delay = CAM_PIPELINE_DELAY_0;
@@ -49,9 +51,13 @@ void cam_req_mgr_core_link_reset(struct cam_req_mgr_core_link *link)
link->initial_skip = true; link->initial_skip = true;
link->sof_timestamp = 0; link->sof_timestamp = 0;
link->prev_sof_timestamp = 0; link->prev_sof_timestamp = 0;
link->enable_apply_default = false;
link->skip_init_frame = false; link->skip_init_frame = false;
atomic_set(&link->eof_event_cnt, 0); atomic_set(&link->eof_event_cnt, 0);
for (pd = 0; pd < CAM_PIPELINE_DELAY_MAX; pd++) {
link->req.apply_data[pd].req_id = -1;
link->req.prev_apply_data[pd].req_id = -1;
}
} }
void cam_req_mgr_handle_core_shutdown(void) void cam_req_mgr_handle_core_shutdown(void)
@@ -212,32 +218,77 @@ static void __cam_req_mgr_find_dev_name(
} }
/** /**
* __cam_req_mgr_apply_default() * __cam_req_mgr_notify_frame_skip()
* *
* @brief : Apply default settings to all devices * @brief : Notify all devices of frame skipping
* @link : link on which we are applying these settings * @link : link on which we are applying these settings
* *
*/ */
static void __cam_req_mgr_apply_default( static int __cam_req_mgr_notify_frame_skip(
struct cam_req_mgr_core_link *link) struct cam_req_mgr_core_link *link,
uint32_t trigger)
{ {
int i; int rc = 0, i, pd, idx;
struct cam_req_mgr_apply_request apply_req; struct cam_req_mgr_apply_request frame_skip;
struct cam_req_mgr_apply *apply_data = NULL;
struct cam_req_mgr_connected_device *dev = NULL; struct cam_req_mgr_connected_device *dev = NULL;
struct cam_req_mgr_tbl_slot *slot = NULL;
if (!link->enable_apply_default) apply_data = link->req.prev_apply_data;
return;
for (i = 0; i < link->num_devs; i++) { for (i = 0; i < link->num_devs; i++) {
dev = &link->l_dev[i]; dev = &link->l_dev[i];
apply_req.request_id = 0; if (!dev)
apply_req.dev_hdl = dev->dev_hdl; continue;
apply_req.link_hdl = link->link_hdl;
apply_req.trigger_point = 0; pd = dev->dev_info.p_delay;
apply_req.report_if_bubble = 0; if (pd >= CAM_PIPELINE_DELAY_MAX) {
if (dev->ops && dev->ops->apply_default) CAM_WARN(CAM_CRM, "pd %d greater than max",
dev->ops->apply_default(&apply_req); pd);
continue;
}
idx = apply_data[pd].idx;
slot = &dev->pd_tbl->slot[idx];
if ((slot->ops.dev_hdl == dev->dev_hdl) &&
(slot->ops.is_applied)) {
slot->ops.is_applied = false;
continue;
}
/*
* If apply_at_eof is enabled do not apply at SOF
* e.x. Flash device
*/
if ((trigger == CAM_TRIGGER_POINT_SOF) &&
(dev->dev_hdl == slot->ops.dev_hdl) &&
(slot->ops.apply_at_eof))
continue;
/*
* If apply_at_eof is not enabled ignore EOF
*/
if ((trigger == CAM_TRIGGER_POINT_EOF) &&
(dev->dev_hdl == slot->ops.dev_hdl) &&
(!slot->ops.apply_at_eof))
continue;
frame_skip.dev_hdl = dev->dev_hdl;
frame_skip.link_hdl = link->link_hdl;
frame_skip.request_id =
apply_data[pd].req_id;
frame_skip.trigger_point = trigger;
frame_skip.report_if_bubble = 0;
CAM_DBG(CAM_REQ,
"Notify_frame_skip: pd %d req_id %lld",
link->link_hdl, pd, apply_data[pd].req_id);
if ((dev->ops) && (dev->ops->notify_frame_skip))
dev->ops->notify_frame_skip(&frame_skip);
} }
return rc;
} }
/** /**
@@ -716,6 +767,7 @@ static int __cam_req_mgr_send_req(struct cam_req_mgr_core_link *link,
struct cam_req_mgr_apply_request apply_req; struct cam_req_mgr_apply_request apply_req;
struct cam_req_mgr_link_evt_data evt_data; struct cam_req_mgr_link_evt_data evt_data;
struct cam_req_mgr_tbl_slot *slot = NULL; struct cam_req_mgr_tbl_slot *slot = NULL;
struct cam_req_mgr_apply *apply_data = NULL;
apply_req.link_hdl = link->link_hdl; apply_req.link_hdl = link->link_hdl;
apply_req.report_if_bubble = 0; apply_req.report_if_bubble = 0;
@@ -725,6 +777,8 @@ static int __cam_req_mgr_send_req(struct cam_req_mgr_core_link *link,
apply_req.re_apply = true; apply_req.re_apply = true;
} }
apply_data = link->req.apply_data;
/* /*
* This For loop is to address the special operation requested * This For loop is to address the special operation requested
* by device * by device
@@ -740,7 +794,7 @@ static int __cam_req_mgr_send_req(struct cam_req_mgr_core_link *link,
continue; continue;
} }
idx = link->req.apply_data[pd].idx; idx = apply_data[pd].idx;
slot = &dev->pd_tbl->slot[idx]; slot = &dev->pd_tbl->slot[idx];
if (slot->ops.dev_hdl < 0) { if (slot->ops.dev_hdl < 0) {
@@ -772,20 +826,21 @@ static int __cam_req_mgr_send_req(struct cam_req_mgr_core_link *link,
if ((trigger == CAM_TRIGGER_POINT_EOF) && if ((trigger == CAM_TRIGGER_POINT_EOF) &&
(!slot->ops.apply_at_eof)) { (!slot->ops.apply_at_eof)) {
CAM_DBG(CAM_CRM, "NO EOF DATA FOR REQ: %llu", CAM_DBG(CAM_CRM, "NO EOF DATA FOR REQ: %llu",
link->req.apply_data[pd].req_id); apply_data[pd].req_id);
break; break;
} }
apply_req.dev_hdl = dev->dev_hdl; apply_req.dev_hdl = dev->dev_hdl;
apply_req.request_id = apply_req.request_id =
link->req.apply_data[pd].req_id; apply_data[pd].req_id;
apply_req.trigger_point = trigger; apply_req.trigger_point = trigger;
if ((dev->ops) && (dev->ops->apply_req) && if ((dev->ops) && (dev->ops->apply_req) &&
(!slot->ops.is_applied)) { (!slot->ops.is_applied)) {
rc = dev->ops->apply_req(&apply_req); rc = dev->ops->apply_req(&apply_req);
if (rc) { if (rc) {
*failed_dev = dev; *failed_dev = dev;
__cam_req_mgr_apply_default(link); __cam_req_mgr_notify_frame_skip(link,
trigger);
return rc; return rc;
} }
} }
@@ -801,7 +856,8 @@ static int __cam_req_mgr_send_req(struct cam_req_mgr_core_link *link,
CAM_DBG(CAM_REQ, CAM_DBG(CAM_REQ,
"SEND: link_hdl: %x pd: %d req_id %lld", "SEND: link_hdl: %x pd: %d req_id %lld",
link->link_hdl, pd, apply_req.request_id); link->link_hdl, pd, apply_req.request_id);
__cam_req_mgr_apply_default(link); __cam_req_mgr_notify_frame_skip(link,
trigger);
return -EAGAIN; return -EAGAIN;
} else if ((trigger == CAM_TRIGGER_POINT_EOF) && } else if ((trigger == CAM_TRIGGER_POINT_EOF) &&
(slot->ops.apply_at_eof)) { (slot->ops.apply_at_eof)) {
@@ -810,7 +866,7 @@ static int __cam_req_mgr_send_req(struct cam_req_mgr_core_link *link,
atomic_dec(&link->eof_event_cnt); atomic_dec(&link->eof_event_cnt);
CAM_DBG(CAM_REQ, CAM_DBG(CAM_REQ,
"Req_id: %llu eof_event_cnt : %d", "Req_id: %llu eof_event_cnt : %d",
link->req.apply_data[pd].req_id, apply_data[pd].req_id,
link->eof_event_cnt); link->eof_event_cnt);
return 0; return 0;
} }
@@ -830,27 +886,27 @@ static int __cam_req_mgr_send_req(struct cam_req_mgr_core_link *link,
if (!(dev->dev_info.trigger & trigger)) if (!(dev->dev_info.trigger & trigger))
continue; continue;
if (link->req.apply_data[pd].skip_idx || if (apply_data[pd].skip_idx ||
(link->req.apply_data[pd].req_id < 0)) { (apply_data[pd].req_id < 0)) {
CAM_DBG(CAM_CRM, CAM_DBG(CAM_CRM,
"dev %s skip %d req_id %lld", "dev %s skip %d req_id %lld",
dev->dev_info.name, dev->dev_info.name,
link->req.apply_data[pd].skip_idx, apply_data[pd].skip_idx,
link->req.apply_data[pd].req_id); apply_data[pd].req_id);
apply_req.dev_hdl = dev->dev_hdl; apply_req.dev_hdl = dev->dev_hdl;
apply_req.request_id = 0; apply_req.request_id =
link->req.prev_apply_data[pd].req_id;
apply_req.trigger_point = 0; apply_req.trigger_point = 0;
apply_req.report_if_bubble = 0; apply_req.report_if_bubble = 0;
if ((link->enable_apply_default) && if ((dev->ops) && (dev->ops->notify_frame_skip))
(dev->ops) && (dev->ops->apply_default)) dev->ops->notify_frame_skip(&apply_req);
dev->ops->apply_default(&apply_req);
continue; continue;
} }
apply_req.dev_hdl = dev->dev_hdl; apply_req.dev_hdl = dev->dev_hdl;
apply_req.request_id = apply_req.request_id =
link->req.apply_data[pd].req_id; apply_data[pd].req_id;
idx = link->req.apply_data[pd].idx; idx = apply_data[pd].idx;
slot = &dev->pd_tbl->slot[idx]; slot = &dev->pd_tbl->slot[idx];
apply_req.report_if_bubble = apply_req.report_if_bubble =
in_q->slot[idx].recover; in_q->slot[idx].recover;
@@ -880,7 +936,7 @@ static int __cam_req_mgr_send_req(struct cam_req_mgr_core_link *link,
apply_req.trigger_point = trigger; apply_req.trigger_point = trigger;
CAM_DBG(CAM_REQ, CAM_DBG(CAM_REQ,
"SEND: link_hdl: %x pd %d req_id %lld", "SEND: %d link_hdl: %x pd %d req_id %lld",
link->link_hdl, pd, apply_req.request_id); link->link_hdl, pd, apply_req.request_id);
if (dev->ops && dev->ops->apply_req) { if (dev->ops && dev->ops->apply_req) {
rc = dev->ops->apply_req(&apply_req); rc = dev->ops->apply_req(&apply_req);
@@ -906,8 +962,13 @@ static int __cam_req_mgr_send_req(struct cam_req_mgr_core_link *link,
if (dev->ops && dev->ops->process_evt) if (dev->ops && dev->ops->process_evt)
dev->ops->process_evt(&evt_data); dev->ops->process_evt(&evt_data);
} }
__cam_req_mgr_apply_default(link); __cam_req_mgr_notify_frame_skip(link, trigger);
} else {
memcpy(link->req.prev_apply_data, link->req.apply_data,
CAM_PIPELINE_DELAY_MAX *
sizeof(struct cam_req_mgr_apply));
} }
return rc; return rc;
} }
@@ -1598,7 +1659,7 @@ static int __cam_req_mgr_process_req(struct cam_req_mgr_core_link *link,
rc = -EPERM; rc = -EPERM;
} }
spin_unlock_bh(&link->link_state_spin_lock); spin_unlock_bh(&link->link_state_spin_lock);
__cam_req_mgr_apply_default(link); __cam_req_mgr_notify_frame_skip(link, trigger);
goto error; goto error;
} }
} }
@@ -2197,38 +2258,6 @@ static void __cam_req_mgr_unreserve_link(
/* Workqueue context processing section */ /* Workqueue context processing section */
/**
* cam_req_mgr_process_send_req()
*
* @brief: This runs in workque thread context. Call core funcs to send
* apply request id to drivers.
* @priv : link information.
* @data : contains information about frame_id, link etc.
*
* @return: 0 on success.
*/
int cam_req_mgr_process_send_req(void *priv, void *data)
{
int rc = 0;
struct cam_req_mgr_core_link *link = NULL;
struct cam_req_mgr_send_request *send_req = NULL;
struct cam_req_mgr_req_queue *in_q = NULL;
struct cam_req_mgr_connected_device *dev;
if (!data || !priv) {
CAM_ERR(CAM_CRM, "input args NULL %pK %pK", data, priv);
rc = -EINVAL;
goto end;
}
link = (struct cam_req_mgr_core_link *)priv;
send_req = (struct cam_req_mgr_send_request *)data;
in_q = send_req->in_q;
rc = __cam_req_mgr_send_req(link, in_q, CAM_TRIGGER_POINT_SOF, &dev);
end:
return rc;
}
/** /**
* cam_req_mgr_process_flush_req() * cam_req_mgr_process_flush_req()
* *
@@ -2242,6 +2271,7 @@ end:
int cam_req_mgr_process_flush_req(void *priv, void *data) int cam_req_mgr_process_flush_req(void *priv, void *data)
{ {
int rc = 0, i = 0, idx = -1; int rc = 0, i = 0, idx = -1;
uint32_t pd = 0;
struct cam_req_mgr_flush_info *flush_info = NULL; struct cam_req_mgr_flush_info *flush_info = NULL;
struct cam_req_mgr_core_link *link = NULL; struct cam_req_mgr_core_link *link = NULL;
struct cam_req_mgr_req_queue *in_q = NULL; struct cam_req_mgr_req_queue *in_q = NULL;
@@ -2306,6 +2336,12 @@ int cam_req_mgr_process_flush_req(void *priv, void *data)
if (device->ops && device->ops->flush_req) if (device->ops && device->ops->flush_req)
rc = device->ops->flush_req(&flush_req); rc = device->ops->flush_req(&flush_req);
} }
for (pd = 0; pd < CAM_PIPELINE_DELAY_MAX; pd++) {
link->req.apply_data[pd].req_id = -1;
link->req.prev_apply_data[pd].req_id = -1;
}
complete(&link->workq_comp); complete(&link->workq_comp);
mutex_unlock(&link->req.lock); mutex_unlock(&link->req.lock);
@@ -3297,9 +3333,6 @@ static int __cam_req_mgr_setup_link_info(struct cam_req_mgr_core_link *link,
if (dev->dev_info.p_delay > max_delay) if (dev->dev_info.p_delay > max_delay)
max_delay = dev->dev_info.p_delay; max_delay = dev->dev_info.p_delay;
if (dev->dev_info.enable_apply_default)
link->enable_apply_default = true;
subscribe_event |= (uint32_t)dev->dev_info.trigger; subscribe_event |= (uint32_t)dev->dev_info.trigger;
} }

18
drivers/cam_req_mgr/cam_req_mgr_core.h
View File

@@ -281,17 +281,20 @@ struct cam_req_mgr_req_queue {
/** /**
* struct cam_req_mgr_req_data * struct cam_req_mgr_req_data
* @in_q : Poiner to Input request queue * @in_q : Poiner to Input request queue
* @l_tbl : unique pd request tables. * @l_tbl : unique pd request tables.
* @num_tbl : how many unique pd value devices are present * @num_tbl : how many unique pd value devices are present
* @apply_data : Holds information about request id for a request * @apply_data : Holds information about request id for a request
* @lock : mutex lock protecting request data ops. * @prev_apply_data : Holds information about request id for a previous
* applied request
* @lock : mutex lock protecting request data ops.
*/ */
struct cam_req_mgr_req_data { struct cam_req_mgr_req_data {
struct cam_req_mgr_req_queue *in_q; struct cam_req_mgr_req_queue *in_q;
struct cam_req_mgr_req_tbl *l_tbl; struct cam_req_mgr_req_tbl *l_tbl;
int32_t num_tbl; int32_t num_tbl;
struct cam_req_mgr_apply apply_data[CAM_PIPELINE_DELAY_MAX]; struct cam_req_mgr_apply apply_data[CAM_PIPELINE_DELAY_MAX];
struct cam_req_mgr_apply prev_apply_data[CAM_PIPELINE_DELAY_MAX];
struct mutex lock; struct mutex lock;
}; };
@@ -365,10 +368,6 @@ struct cam_req_mgr_connected_device {
* applying the settings * applying the settings
* @trigger_cnt : trigger count value per device initiating the trigger * @trigger_cnt : trigger count value per device initiating the trigger
* @eof_event_cnt : Atomic variable to track the number of EOF requests * @eof_event_cnt : Atomic variable to track the number of EOF requests
* @enable_apply_default : Link will apply a default settings to devices on
* frames where actual settings are not available.
* This will account for all devices irrespective of
* pipeline delay
* @skip_init_frame : skip initial frames crm_wd_timer validation in the * @skip_init_frame : skip initial frames crm_wd_timer validation in the
* case of long exposure use case * case of long exposure use case
*/ */
@@ -404,7 +403,6 @@ struct cam_req_mgr_core_link {
bool dual_trigger; bool dual_trigger;
uint32_t trigger_cnt[CAM_REQ_MGR_MAX_TRIGGERS]; uint32_t trigger_cnt[CAM_REQ_MGR_MAX_TRIGGERS];
atomic_t eof_event_cnt; atomic_t eof_event_cnt;
bool enable_apply_default;
bool skip_init_frame; bool skip_init_frame;
}; };

49
drivers/cam_req_mgr/cam_req_mgr_interface.h
View File

@@ -44,17 +44,20 @@ typedef int (*cam_req_mgr_notify_stop)(struct cam_req_mgr_notify_stop *);
/** /**
* @brief: cam req mgr to camera device drivers * @brief: cam req mgr to camera device drivers
* *
* @cam_req_mgr_get_dev_info: to fetch details about device linked * @cam_req_mgr_get_dev_info : to fetch details about device linked
* @cam_req_mgr_link_setup : to establish link with device for a session * @cam_req_mgr_link_setup : to establish link with device for a session
* @cam_req_mgr_apply_req : CRM asks device to apply certain request id * @cam_req_mgr_apply_req : CRM asks device to apply certain request id
* @cam_req_mgr_flush_req : Flush or cancel request * @cam_req_mgr_notify_frame_skip: CRM asks device to apply setting for
* cam_req_mgr_process_evt : generic events * frame skip
* @cam_req_mgr_dump_req : dump request * @cam_req_mgr_flush_req : Flush or cancel request
* cam_req_mgr_process_evt : generic events
* @cam_req_mgr_dump_req : dump request
*/ */
typedef int (*cam_req_mgr_get_dev_info) (struct cam_req_mgr_device_info *); typedef int (*cam_req_mgr_get_dev_info) (struct cam_req_mgr_device_info *);
typedef int (*cam_req_mgr_link_setup)(struct cam_req_mgr_core_dev_link_setup *); typedef int (*cam_req_mgr_link_setup)(struct cam_req_mgr_core_dev_link_setup *);
typedef int (*cam_req_mgr_apply_req)(struct cam_req_mgr_apply_request *); typedef int (*cam_req_mgr_apply_req)(struct cam_req_mgr_apply_request *);
typedef int (*cam_req_mgr_apply_default)(struct cam_req_mgr_apply_request *); typedef int (*cam_req_mgr_notify_frame_skip)(
struct cam_req_mgr_apply_request *);
typedef int (*cam_req_mgr_flush_req)(struct cam_req_mgr_flush_request *); typedef int (*cam_req_mgr_flush_req)(struct cam_req_mgr_flush_request *);
typedef int (*cam_req_mgr_process_evt)(struct cam_req_mgr_link_evt_data *); typedef int (*cam_req_mgr_process_evt)(struct cam_req_mgr_link_evt_data *);
typedef int (*cam_req_mgr_dump_req)(struct cam_req_mgr_dump_info *); typedef int (*cam_req_mgr_dump_req)(struct cam_req_mgr_dump_info *);
@@ -79,22 +82,22 @@ struct cam_req_mgr_crm_cb {
/** /**
* @brief : cam_req_mgr_kmd_ops - func table * @brief : cam_req_mgr_kmd_ops - func table
* *
* @get_dev_info : payload to fetch device details * @get_dev_info : payload to fetch device details
* @link_setup : payload to establish link with device * @link_setup : payload to establish link with device
* @apply_req : payload to apply request id on a device linked * @apply_req : payload to apply request id on a device linked
* @apply_default: payload to trigger default apply settings * @notify_frame_skip: payload to notify frame skip
* @flush_req : payload to flush request * @flush_req : payload to flush request
* @process_evt : payload to generic event * @process_evt : payload to generic event
* @dump_req : payload to dump request * @dump_req : payload to dump request
*/ */
struct cam_req_mgr_kmd_ops { struct cam_req_mgr_kmd_ops {
cam_req_mgr_get_dev_info get_dev_info; cam_req_mgr_get_dev_info get_dev_info;
cam_req_mgr_link_setup link_setup; cam_req_mgr_link_setup link_setup;
cam_req_mgr_apply_req apply_req; cam_req_mgr_apply_req apply_req;
cam_req_mgr_apply_default apply_default; cam_req_mgr_notify_frame_skip notify_frame_skip;
cam_req_mgr_flush_req flush_req; cam_req_mgr_flush_req flush_req;
cam_req_mgr_process_evt process_evt; cam_req_mgr_process_evt process_evt;
cam_req_mgr_dump_req dump_req; cam_req_mgr_dump_req dump_req;
}; };
/** /**
@@ -296,9 +299,6 @@ struct cam_req_mgr_notify_stop {
* @p_delay : delay between time settings applied and take effect * @p_delay : delay between time settings applied and take effect
* @trigger : Trigger point for the client * @trigger : Trigger point for the client
* @trigger_on : This device provides trigger * @trigger_on : This device provides trigger
* @enable_apply_default : Device requests CRM to apply default
* settings for devices on a link if actual
* settings for a given frame is not available
*/ */
struct cam_req_mgr_device_info { struct cam_req_mgr_device_info {
int32_t dev_hdl; int32_t dev_hdl;
@@ -307,7 +307,6 @@ struct cam_req_mgr_device_info {
enum cam_pipeline_delay p_delay; enum cam_pipeline_delay p_delay;
uint32_t trigger; uint32_t trigger;
bool trigger_on; bool trigger_on;
bool enable_apply_default;
}; };
/** /**

130
drivers/cam_sensor_module/cam_sensor/cam_sensor_core.c
View File

@@ -78,6 +78,20 @@ static void cam_sensor_release_per_frame_resource(
} }
} }
} }
if (s_ctrl->i2c_data.frame_skip != NULL) {
for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) {
i2c_set = &(s_ctrl->i2c_data.frame_skip[i]);
if (i2c_set->is_settings_valid == 1) {
i2c_set->is_settings_valid = -1;
rc = delete_request(i2c_set);
if (rc < 0)
CAM_ERR(CAM_SENSOR,
"delete request: %lld rc: %d",
i2c_set->request_id, rc);
}
}
}
} }
static int32_t cam_sensor_i2c_pkt_parse(struct cam_sensor_ctrl_t *s_ctrl, static int32_t cam_sensor_i2c_pkt_parse(struct cam_sensor_ctrl_t *s_ctrl,
@@ -137,7 +151,6 @@ static int32_t cam_sensor_i2c_pkt_parse(struct cam_sensor_ctrl_t *s_ctrl,
CAM_ERR(CAM_SENSOR, "Invalid packet params"); CAM_ERR(CAM_SENSOR, "Invalid packet params");
rc = -EINVAL; rc = -EINVAL;
goto end; goto end;
} }
if ((csl_packet->header.op_code & 0xFFFFFF) != if ((csl_packet->header.op_code & 0xFFFFFF) !=
@@ -240,6 +253,22 @@ static int32_t cam_sensor_i2c_pkt_parse(struct cam_sensor_ctrl_t *s_ctrl,
} }
break; break;
} }
case CAM_SENSOR_PACKET_OPCODE_SENSOR_FRAME_SKIP_UPDATE: {
if ((s_ctrl->sensor_state == CAM_SENSOR_INIT) ||
(s_ctrl->sensor_state == CAM_SENSOR_ACQUIRE)) {
CAM_WARN(CAM_SENSOR,
"Rxed Update packets without linking");
goto end;
}
i2c_reg_settings =
&i2c_data->frame_skip[csl_packet->header.request_id %
MAX_PER_FRAME_ARRAY];
CAM_DBG(CAM_SENSOR, "Received not ready packet: %lld req: %lld",
csl_packet->header.request_id % MAX_PER_FRAME_ARRAY,
csl_packet->header.request_id);
break;
}
case CAM_SENSOR_PACKET_OPCODE_SENSOR_NOP: { case CAM_SENSOR_PACKET_OPCODE_SENSOR_NOP: {
if ((s_ctrl->sensor_state == CAM_SENSOR_INIT) || if ((s_ctrl->sensor_state == CAM_SENSOR_INIT) ||
(s_ctrl->sensor_state == CAM_SENSOR_ACQUIRE)) { (s_ctrl->sensor_state == CAM_SENSOR_ACQUIRE)) {
@@ -275,6 +304,12 @@ static int32_t cam_sensor_i2c_pkt_parse(struct cam_sensor_ctrl_t *s_ctrl,
cam_sensor_update_req_mgr(s_ctrl, csl_packet); cam_sensor_update_req_mgr(s_ctrl, csl_packet);
} }
if ((csl_packet->header.op_code & 0xFFFFFF) ==
CAM_SENSOR_PACKET_OPCODE_SENSOR_FRAME_SKIP_UPDATE) {
i2c_reg_settings->request_id =
csl_packet->header.request_id;
}
end: end:
return rc; return rc;
} }
@@ -1207,6 +1242,7 @@ int cam_sensor_apply_settings(struct cam_sensor_ctrl_t *s_ctrl,
break; break;
} }
case CAM_SENSOR_PACKET_OPCODE_SENSOR_UPDATE: case CAM_SENSOR_PACKET_OPCODE_SENSOR_UPDATE:
case CAM_SENSOR_PACKET_OPCODE_SENSOR_FRAME_SKIP_UPDATE:
case CAM_SENSOR_PACKET_OPCODE_SENSOR_PROBE: case CAM_SENSOR_PACKET_OPCODE_SENSOR_PROBE:
default: default:
return 0; return 0;
@@ -1227,11 +1263,16 @@ int cam_sensor_apply_settings(struct cam_sensor_ctrl_t *s_ctrl,
} }
} else { } else {
offset = req_id % MAX_PER_FRAME_ARRAY; offset = req_id % MAX_PER_FRAME_ARRAY;
i2c_set = &(s_ctrl->i2c_data.per_frame[offset]);
if (i2c_set->is_settings_valid == 1 && if (opcode == CAM_SENSOR_PACKET_OPCODE_SENSOR_FRAME_SKIP_UPDATE)
i2c_set->request_id == req_id) { i2c_set = s_ctrl->i2c_data.frame_skip;
else
i2c_set = s_ctrl->i2c_data.per_frame;
if (i2c_set[offset].is_settings_valid == 1 &&
i2c_set[offset].request_id == req_id) {
list_for_each_entry(i2c_list, list_for_each_entry(i2c_list,
&(i2c_set->list_head), list) { &(i2c_set[offset].list_head), list) {
rc = cam_sensor_i2c_modes_util( rc = cam_sensor_i2c_modes_util(
&(s_ctrl->io_master_info), &(s_ctrl->io_master_info),
i2c_list); i2c_list);
@@ -1250,13 +1291,13 @@ int cam_sensor_apply_settings(struct cam_sensor_ctrl_t *s_ctrl,
/* Change the logic dynamically */ /* Change the logic dynamically */
for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) { for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) {
if ((req_id >= if ((req_id >=
s_ctrl->i2c_data.per_frame[i].request_id) && i2c_set[i].request_id) &&
(top < (top <
s_ctrl->i2c_data.per_frame[i].request_id) && i2c_set[i].request_id) &&
(s_ctrl->i2c_data.per_frame[i].is_settings_valid (i2c_set[i].is_settings_valid
== 1)) { == 1)) {
del_req_id = top; del_req_id = top;
top = s_ctrl->i2c_data.per_frame[i].request_id; top = i2c_set[i].request_id;
} }
} }
@@ -1276,12 +1317,12 @@ int cam_sensor_apply_settings(struct cam_sensor_ctrl_t *s_ctrl,
for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) { for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) {
if ((del_req_id > if ((del_req_id >
s_ctrl->i2c_data.per_frame[i].request_id) && ( i2c_set[i].request_id) && (
s_ctrl->i2c_data.per_frame[i].is_settings_valid i2c_set[i].is_settings_valid
== 1)) { == 1)) {
s_ctrl->i2c_data.per_frame[i].request_id = 0; i2c_set[i].request_id = 0;
rc = delete_request( rc = delete_request(
&(s_ctrl->i2c_data.per_frame[i])); &(i2c_set[i]));
if (rc < 0) if (rc < 0)
CAM_ERR(CAM_SENSOR, CAM_ERR(CAM_SENSOR,
"Delete request Fail:%lld rc:%d", "Delete request Fail:%lld rc:%d",
@@ -1297,6 +1338,8 @@ int32_t cam_sensor_apply_request(struct cam_req_mgr_apply_request *apply)
{ {
int32_t rc = 0; int32_t rc = 0;
struct cam_sensor_ctrl_t *s_ctrl = NULL; struct cam_sensor_ctrl_t *s_ctrl = NULL;
enum cam_sensor_packet_opcodes opcode =
CAM_SENSOR_PACKET_OPCODE_SENSOR_UPDATE;
if (!apply) if (!apply)
return -EINVAL; return -EINVAL;
@@ -1307,11 +1350,40 @@ int32_t cam_sensor_apply_request(struct cam_req_mgr_apply_request *apply)
CAM_ERR(CAM_SENSOR, "Device data is NULL"); CAM_ERR(CAM_SENSOR, "Device data is NULL");
return -EINVAL; return -EINVAL;
} }
CAM_DBG(CAM_REQ, " Sensor update req id: %lld", apply->request_id);
CAM_DBG(CAM_REQ, " Sensor[%d] update req id: %lld",
s_ctrl->soc_info.index, apply->request_id);
trace_cam_apply_req("Sensor", apply->request_id); trace_cam_apply_req("Sensor", apply->request_id);
mutex_lock(&(s_ctrl->cam_sensor_mutex)); mutex_lock(&(s_ctrl->cam_sensor_mutex));
rc = cam_sensor_apply_settings(s_ctrl, apply->request_id, rc = cam_sensor_apply_settings(s_ctrl, apply->request_id,
CAM_SENSOR_PACKET_OPCODE_SENSOR_UPDATE); opcode);
mutex_unlock(&(s_ctrl->cam_sensor_mutex));
return rc;
}
int32_t cam_sensor_notify_frame_skip(struct cam_req_mgr_apply_request *apply)
{
int32_t rc = 0;
struct cam_sensor_ctrl_t *s_ctrl = NULL;
enum cam_sensor_packet_opcodes opcode =
CAM_SENSOR_PACKET_OPCODE_SENSOR_FRAME_SKIP_UPDATE;
if (!apply)
return -EINVAL;
s_ctrl = (struct cam_sensor_ctrl_t *)
cam_get_device_priv(apply->dev_hdl);
if (!s_ctrl) {
CAM_ERR(CAM_SENSOR, "Device data is NULL");
return -EINVAL;
}
CAM_DBG(CAM_REQ, " Sensor[%d] handle frame skip for req id: %lld",
s_ctrl->soc_info.index, apply->request_id);
trace_cam_notify_frame_skip("Sensor", apply->request_id);
mutex_lock(&(s_ctrl->cam_sensor_mutex));
rc = cam_sensor_apply_settings(s_ctrl, apply->request_id,
opcode);
mutex_unlock(&(s_ctrl->cam_sensor_mutex)); mutex_unlock(&(s_ctrl->cam_sensor_mutex));
return rc; return rc;
} }
@@ -1346,6 +1418,12 @@ int32_t cam_sensor_flush_request(struct cam_req_mgr_flush_request *flush_req)
return -EINVAL; return -EINVAL;
} }
if (s_ctrl->i2c_data.frame_skip == NULL) {
CAM_ERR(CAM_SENSOR, "i2c not ready data is NULL");
mutex_unlock(&(s_ctrl->cam_sensor_mutex));
return -EINVAL;
}
if (flush_req->type == CAM_REQ_MGR_FLUSH_TYPE_ALL) { if (flush_req->type == CAM_REQ_MGR_FLUSH_TYPE_ALL) {
s_ctrl->last_flush_req = flush_req->req_id; s_ctrl->last_flush_req = flush_req->req_id;
CAM_DBG(CAM_SENSOR, "last reqest to flush is %lld", CAM_DBG(CAM_SENSOR, "last reqest to flush is %lld",
@@ -1374,6 +1452,28 @@ int32_t cam_sensor_flush_request(struct cam_req_mgr_flush_request *flush_req)
} }
} }
for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) {
i2c_set = &(s_ctrl->i2c_data.frame_skip[i]);
if ((flush_req->type == CAM_REQ_MGR_FLUSH_TYPE_CANCEL_REQ)
&& (i2c_set->request_id != flush_req->req_id))
continue;
if (i2c_set->is_settings_valid == 1) {
rc = delete_request(i2c_set);
if (rc < 0)
CAM_ERR(CAM_SENSOR,
"delete request for not ready packet: %lld rc: %d",
i2c_set->request_id, rc);
if (flush_req->type ==
CAM_REQ_MGR_FLUSH_TYPE_CANCEL_REQ) {
cancel_req_id_found = 1;
break;
}
}
}
if (flush_req->type == CAM_REQ_MGR_FLUSH_TYPE_CANCEL_REQ && if (flush_req->type == CAM_REQ_MGR_FLUSH_TYPE_CANCEL_REQ &&
!cancel_req_id_found) !cancel_req_id_found)
CAM_DBG(CAM_SENSOR, CAM_DBG(CAM_SENSOR,

9
drivers/cam_sensor_module/cam_sensor/cam_sensor_core.h
View File

@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */ /* SPDX-License-Identifier: GPL-2.0-only */
/* /*
* Copyright (c) 2017-2018, The Linux Foundation. All rights reserved. * Copyright (c) 2017-2018,2020, The Linux Foundation. All rights reserved.
*/ */
#ifndef _CAM_SENSOR_CORE_H_ #ifndef _CAM_SENSOR_CORE_H_
@@ -47,6 +47,13 @@ int cam_sensor_apply_settings(struct cam_sensor_ctrl_t *s_ctrl, int64_t req_id,
*/ */
int cam_sensor_apply_request(struct cam_req_mgr_apply_request *apply); int cam_sensor_apply_request(struct cam_req_mgr_apply_request *apply);
/**
* @apply: Req mgr structure for notifying frame skip
*
* This API notifies a frame is skipped
*/
int cam_sensor_notify_frame_skip(struct cam_req_mgr_apply_request *apply);
/** /**
* @flush: Req mgr structure for flushing request * @flush: Req mgr structure for flushing request
* *

35
drivers/cam_sensor_module/cam_sensor/cam_sensor_dev.c
View File

@@ -176,25 +176,39 @@ static int32_t cam_sensor_driver_i2c_probe(struct i2c_client *client,
goto unreg_subdev; goto unreg_subdev;
} }
s_ctrl->i2c_data.frame_skip =
kzalloc(sizeof(struct i2c_settings_array) *
MAX_PER_FRAME_ARRAY, GFP_KERNEL);
if (s_ctrl->i2c_data.frame_skip == NULL) {
rc = -ENOMEM;
goto free_perframe;
}
INIT_LIST_HEAD(&(s_ctrl->i2c_data.init_settings.list_head)); INIT_LIST_HEAD(&(s_ctrl->i2c_data.init_settings.list_head));
INIT_LIST_HEAD(&(s_ctrl->i2c_data.config_settings.list_head)); INIT_LIST_HEAD(&(s_ctrl->i2c_data.config_settings.list_head));
INIT_LIST_HEAD(&(s_ctrl->i2c_data.streamon_settings.list_head)); INIT_LIST_HEAD(&(s_ctrl->i2c_data.streamon_settings.list_head));
INIT_LIST_HEAD(&(s_ctrl->i2c_data.streamoff_settings.list_head)); INIT_LIST_HEAD(&(s_ctrl->i2c_data.streamoff_settings.list_head));
INIT_LIST_HEAD(&(s_ctrl->i2c_data.read_settings.list_head)); INIT_LIST_HEAD(&(s_ctrl->i2c_data.read_settings.list_head));
for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) {
INIT_LIST_HEAD(&(s_ctrl->i2c_data.per_frame[i].list_head)); INIT_LIST_HEAD(&(s_ctrl->i2c_data.per_frame[i].list_head));
INIT_LIST_HEAD(&(s_ctrl->i2c_data.frame_skip[i].list_head));
}
s_ctrl->bridge_intf.device_hdl = -1; s_ctrl->bridge_intf.device_hdl = -1;
s_ctrl->bridge_intf.link_hdl = -1; s_ctrl->bridge_intf.link_hdl = -1;
s_ctrl->bridge_intf.ops.get_dev_info = cam_sensor_publish_dev_info; s_ctrl->bridge_intf.ops.get_dev_info = cam_sensor_publish_dev_info;
s_ctrl->bridge_intf.ops.link_setup = cam_sensor_establish_link; s_ctrl->bridge_intf.ops.link_setup = cam_sensor_establish_link;
s_ctrl->bridge_intf.ops.apply_req = cam_sensor_apply_request; s_ctrl->bridge_intf.ops.apply_req = cam_sensor_apply_request;
s_ctrl->bridge_intf.ops.notify_frame_skip =
cam_sensor_notify_frame_skip;
s_ctrl->bridge_intf.ops.flush_req = cam_sensor_flush_request; s_ctrl->bridge_intf.ops.flush_req = cam_sensor_flush_request;
s_ctrl->sensordata->power_info.dev = soc_info->dev; s_ctrl->sensordata->power_info.dev = soc_info->dev;
return rc; return rc;
free_perframe:
kfree(s_ctrl->i2c_data.per_frame);
unreg_subdev: unreg_subdev:
cam_unregister_subdev(&(s_ctrl->v4l2_dev_str)); cam_unregister_subdev(&(s_ctrl->v4l2_dev_str));
free_s_ctrl: free_s_ctrl:
@@ -252,20 +266,32 @@ static int cam_sensor_component_bind(struct device *dev,
goto unreg_subdev; goto unreg_subdev;
} }
s_ctrl->i2c_data.frame_skip =
kzalloc(sizeof(struct i2c_settings_array) *
MAX_PER_FRAME_ARRAY, GFP_KERNEL);
if (s_ctrl->i2c_data.frame_skip == NULL) {
rc = -ENOMEM;
goto free_perframe;
}
INIT_LIST_HEAD(&(s_ctrl->i2c_data.init_settings.list_head)); INIT_LIST_HEAD(&(s_ctrl->i2c_data.init_settings.list_head));
INIT_LIST_HEAD(&(s_ctrl->i2c_data.config_settings.list_head)); INIT_LIST_HEAD(&(s_ctrl->i2c_data.config_settings.list_head));
INIT_LIST_HEAD(&(s_ctrl->i2c_data.streamon_settings.list_head)); INIT_LIST_HEAD(&(s_ctrl->i2c_data.streamon_settings.list_head));
INIT_LIST_HEAD(&(s_ctrl->i2c_data.streamoff_settings.list_head)); INIT_LIST_HEAD(&(s_ctrl->i2c_data.streamoff_settings.list_head));
INIT_LIST_HEAD(&(s_ctrl->i2c_data.read_settings.list_head)); INIT_LIST_HEAD(&(s_ctrl->i2c_data.read_settings.list_head));
for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) for (i = 0; i < MAX_PER_FRAME_ARRAY; i++) {
INIT_LIST_HEAD(&(s_ctrl->i2c_data.per_frame[i].list_head)); INIT_LIST_HEAD(&(s_ctrl->i2c_data.per_frame[i].list_head));
INIT_LIST_HEAD(&(s_ctrl->i2c_data.frame_skip[i].list_head));
}
s_ctrl->bridge_intf.device_hdl = -1; s_ctrl->bridge_intf.device_hdl = -1;
s_ctrl->bridge_intf.link_hdl = -1; s_ctrl->bridge_intf.link_hdl = -1;
s_ctrl->bridge_intf.ops.get_dev_info = cam_sensor_publish_dev_info; s_ctrl->bridge_intf.ops.get_dev_info = cam_sensor_publish_dev_info;
s_ctrl->bridge_intf.ops.link_setup = cam_sensor_establish_link; s_ctrl->bridge_intf.ops.link_setup = cam_sensor_establish_link;
s_ctrl->bridge_intf.ops.apply_req = cam_sensor_apply_request; s_ctrl->bridge_intf.ops.apply_req = cam_sensor_apply_request;
s_ctrl->bridge_intf.ops.notify_frame_skip =
cam_sensor_notify_frame_skip;
s_ctrl->bridge_intf.ops.flush_req = cam_sensor_flush_request; s_ctrl->bridge_intf.ops.flush_req = cam_sensor_flush_request;
s_ctrl->sensordata->power_info.dev = &pdev->dev; s_ctrl->sensordata->power_info.dev = &pdev->dev;
@@ -274,6 +300,9 @@ static int cam_sensor_component_bind(struct device *dev,
CAM_DBG(CAM_SENSOR, "Component bound successfully"); CAM_DBG(CAM_SENSOR, "Component bound successfully");
return rc; return rc;
free_perframe:
kfree(s_ctrl->i2c_data.per_frame);
unreg_subdev: unreg_subdev:
cam_unregister_subdev(&(s_ctrl->v4l2_dev_str)); cam_unregister_subdev(&(s_ctrl->v4l2_dev_str));
free_s_ctrl: free_s_ctrl:
@@ -305,6 +334,7 @@ static void cam_sensor_component_unbind(struct device *dev,
devm_clk_put(soc_info->dev, soc_info->clk[i]); devm_clk_put(soc_info->dev, soc_info->clk[i]);
kfree(s_ctrl->i2c_data.per_frame); kfree(s_ctrl->i2c_data.per_frame);
kfree(s_ctrl->i2c_data.frame_skip);
platform_set_drvdata(pdev, NULL); platform_set_drvdata(pdev, NULL);
v4l2_set_subdevdata(&(s_ctrl->v4l2_dev_str.sd), NULL); v4l2_set_subdevdata(&(s_ctrl->v4l2_dev_str.sd), NULL);
devm_kfree(&pdev->dev, s_ctrl); devm_kfree(&pdev->dev, s_ctrl);
@@ -342,6 +372,7 @@ static int cam_sensor_driver_i2c_remove(struct i2c_client *client)
devm_clk_put(soc_info->dev, soc_info->clk[i]); devm_clk_put(soc_info->dev, soc_info->clk[i]);
kfree(s_ctrl->i2c_data.per_frame); kfree(s_ctrl->i2c_data.per_frame);
kfree(s_ctrl->i2c_data.frame_skip);
v4l2_set_subdevdata(&(s_ctrl->v4l2_dev_str.sd), NULL); v4l2_set_subdevdata(&(s_ctrl->v4l2_dev_str.sd), NULL);
kfree(s_ctrl); kfree(s_ctrl);

2
drivers/cam_sensor_module/cam_sensor_utils/cam_sensor_cmn_header.h
View File

@@ -154,6 +154,7 @@ enum cam_sensor_packet_opcodes {
CAM_SENSOR_PACKET_OPCODE_SENSOR_CONFIG, CAM_SENSOR_PACKET_OPCODE_SENSOR_CONFIG,
CAM_SENSOR_PACKET_OPCODE_SENSOR_STREAMOFF, CAM_SENSOR_PACKET_OPCODE_SENSOR_STREAMOFF,
CAM_SENSOR_PACKET_OPCODE_SENSOR_READ, CAM_SENSOR_PACKET_OPCODE_SENSOR_READ,
CAM_SENSOR_PACKET_OPCODE_SENSOR_FRAME_SKIP_UPDATE,
CAM_SENSOR_PACKET_OPCODE_SENSOR_NOP = 127 CAM_SENSOR_PACKET_OPCODE_SENSOR_NOP = 127
}; };
@@ -306,6 +307,7 @@ struct i2c_data_settings {
struct i2c_settings_array streamoff_settings; struct i2c_settings_array streamoff_settings;
struct i2c_settings_array read_settings; struct i2c_settings_array read_settings;
struct i2c_settings_array *per_frame; struct i2c_settings_array *per_frame;
struct i2c_settings_array *frame_skip;
}; };
struct cam_sensor_power_ctrl_t { struct cam_sensor_power_ctrl_t {

19
drivers/cam_utils/cam_trace.h
View File

@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */ /* 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.
*/ */
#if !defined(_CAM_TRACE_H) || defined(TRACE_HEADER_MULTI_READ) #if !defined(_CAM_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
@@ -140,6 +140,23 @@ TRACE_EVENT(cam_apply_req,
) )
); );
TRACE_EVENT(cam_notify_frame_skip,
TP_PROTO(const char *entity, uint64_t req_id),
TP_ARGS(entity, req_id),
TP_STRUCT__entry(
__string(entity, entity)
__field(uint64_t, req_id)
),
TP_fast_assign(
__assign_str(entity, entity);
__entry->req_id = req_id;
),
TP_printk(
"%8s: NotifyFrameSkip request=%llu",
__get_str(entity), __entry->req_id
)
);
TRACE_EVENT(cam_flush_req, TRACE_EVENT(cam_flush_req,
TP_PROTO(struct cam_req_mgr_core_link *link, TP_PROTO(struct cam_req_mgr_core_link *link,
struct cam_req_mgr_flush_info *info), struct cam_req_mgr_flush_info *info),