Merge "msm: camera: cpas: Add more cpas log event triggers" into camera-kernel.lnx.5.0

drivers/cam_core/cam_context.h

@@ -196,6 +196,9 @@ struct cam_ctx_ops {
  * @state_machine:         Top level state machine
  * @ctx_priv:              Private context pointer
  * @ctxt_to_hw_map:        Context to hardware mapping pointer
+ * @hw_mgr_ctx_id:         Hw Mgr context id returned from hw mgr
+ * @ctx_id_string:         Context id string constructed with dev type,
+ *                         ctx id, hw mgr ctx id
  * @refcount:              Context object refcount
  * @node:                  The main node to which this context belongs
  * @sync_mutex:            mutex to sync with sync cb thread
@@ -237,6 +240,8 @@ struct cam_context {
 
 	void                          *ctx_priv;
 	void                          *ctxt_to_hw_map;
+	uint32_t                       hw_mgr_ctx_id;
+	char                           ctx_id_string[128];
 
 	struct kref                    refcount;
 	void                          *node;
@@ -248,6 +253,7 @@ struct cam_context {
 	struct cam_hw_update_entry    *hw_update_entry;
 	struct cam_hw_fence_map_entry *in_map_entries;
 	struct cam_hw_fence_map_entry *out_map_entries;
+
 };
 
 /**

drivers/cam_core/cam_context_utils.c

@@ -18,6 +18,7 @@
 #include "cam_sync_api.h"
 #include "cam_trace.h"
 #include "cam_debug_util.h"
+#include "cam_cpas_api.h"
 
 static uint cam_debug_ctx_req_list;
 module_param(cam_debug_ctx_req_list, uint, 0644);
@@ -184,6 +185,8 @@ int cam_context_buf_done_from_hw(struct cam_context *ctx,
 			"[%s][%d] : Moving req[%llu] from active_list to free_list",
 			ctx->dev_name, ctx->ctx_id, req->request_id);
 
+	cam_cpas_notify_event(ctx->ctx_id_string, req->request_id);
+
 	/*
 	 * another thread may be adding/removing from free list,
 	 * so hold the lock
@@ -634,6 +637,7 @@ int32_t cam_context_acquire_dev_to_hw(struct cam_context *ctx,
 
 	/* fill in parameters */
 	param.context_data = ctx;
+	param.ctx_id = ctx->ctx_id;
 	param.event_cb = ctx->irq_cb_intf;
 	param.num_acq = cmd->num_resources;
 	param.acquire_info = cmd->resource_hdl;
@@ -657,6 +661,13 @@ int32_t cam_context_acquire_dev_to_hw(struct cam_context *ctx,
 	}
 
 	ctx->ctxt_to_hw_map = param.ctxt_to_hw_map;
+	ctx->hw_mgr_ctx_id = param.hw_mgr_ctx_id;
+
+	snprintf(ctx->ctx_id_string, sizeof(ctx->ctx_id_string),
+		"%s_ctx[%d]_hwmgrctx[%d]_Done",
+		ctx->dev_name,
+		ctx->ctx_id,
+		ctx->hw_mgr_ctx_id);
 
 	/* if hw resource acquire successful, acquire dev handle */
 	req_hdl_param.session_hdl = cmd->session_handle;

drivers/cam_core/cam_hw_mgr_intf.h

@@ -107,10 +107,12 @@ struct cam_hw_done_event_data {
  * struct cam_hw_acquire_args - Payload for acquire command
  *
  * @context_data:          Context data pointer for the callback function
+ * @ctx_id:                Core context id
  * @event_cb:              Callback function array
  * @num_acq:               Total number of acquire in the payload
  * @acquire_info:          Acquired resource array pointer
  * @ctxt_to_hw_map:        HW context (returned)
+ * @hw_mgr_ctx_id          HWMgr context id(returned)
  * @custom_enabled:        ctx has custom enabled
  * @use_frame_header_ts:   Use frame header for qtimer ts
  * @support_consumed_addr: The platform has last consumed addr register
@@ -123,11 +125,13 @@ struct cam_hw_done_event_data {
  */
 struct cam_hw_acquire_args {
 	void                        *context_data;
+	uint32_t                     ctx_id;
 	cam_hw_event_cb_func         event_cb;
 	uint32_t                     num_acq;
 	uint32_t                     acquire_info_size;
 	uintptr_t                    acquire_info;
 	void                        *ctxt_to_hw_map;
+	uint32_t                     hw_mgr_ctx_id;
 	bool                         custom_enabled;
 	bool                         use_frame_header_ts;
 	bool                         support_consumed_addr;

drivers/cam_cpas/cam_cpas_hw.c

@@ -2001,6 +2001,9 @@ static void cam_cpas_update_monitor_array(struct cam_hw_info *cpas_hw,
 		uint32_t be_mnoc_offset =
 			soc_private->rpmh_info[CAM_RPMH_BCM_BE_OFFSET] +
 			(0x4 * soc_private->rpmh_info[CAM_RPMH_BCM_MNOC_INDEX]);
+		uint32_t be_shub_offset =
+			soc_private->rpmh_info[CAM_RPMH_BCM_BE_OFFSET] +
+			(0x4 * 1); /* i=1 for SHUB, hardcode for now */
 
 		/*
 		 * 0x4, 0x800 - DDR
@@ -2010,6 +2013,7 @@ static void cam_cpas_update_monitor_array(struct cam_hw_info *cpas_hw,
 		entry->fe_mnoc = cam_io_r_mb(rpmh_base + fe_mnoc_offset);
 		entry->be_ddr = cam_io_r_mb(rpmh_base + be_ddr_offset);
 		entry->be_mnoc = cam_io_r_mb(rpmh_base + be_mnoc_offset);
+		entry->be_shub = cam_io_r_mb(rpmh_base + be_shub_offset);
 	}
 
 	entry->camnoc_fill_level[0] = cam_io_r_mb(
@@ -2094,9 +2098,9 @@ static void cam_cpas_dump_monitor_array(
 
 		if (cpas_core->regbase_index[CAM_CPAS_REG_RPMH] != -1) {
 			CAM_INFO(CAM_CPAS,
-				"fe_ddr=0x%x, fe_mnoc=0x%x, be_ddr=0x%x, be_mnoc=0x%x",
+				"fe_ddr=0x%x, fe_mnoc=0x%x, be_ddr=0x%x, be_mnoc=0x%x, be_shub=0x%x",
 				entry->fe_ddr, entry->fe_mnoc,
-				entry->be_ddr, entry->be_mnoc);
+				entry->be_ddr, entry->be_mnoc, entry->be_shub);
 		}
 
 		CAM_INFO(CAM_CPAS,

drivers/cam_cpas/cam_cpas_hw.h

@@ -45,7 +45,7 @@
 #define CAM_RPMH_BCM_MNOC_INDEX 4
 #define CAM_RPMH_BCM_INFO_MAX   5
 
-#define CAM_CPAS_MONITOR_MAX_ENTRIES   60
+#define CAM_CPAS_MONITOR_MAX_ENTRIES   100
 #define CAM_CPAS_INC_MONITOR_HEAD(head, ret) \
 	div_u64_rem(atomic64_add_return(1, head),\
 	CAM_CPAS_MONITOR_MAX_ENTRIES, (ret))
@@ -214,6 +214,8 @@ struct cam_cpas_axi_port_debug_info {
  *           This indicates requested clock plan
  * @be_mnoc: RPMH MNOC BCM BE (back-end) status register value.
  *           This indicates actual current clock plan
+ * @be_shub: RPMH SHUB BCM BE (back-end) status register value.
+ *           This indicates actual current clock plan
  * @camnoc_fill_level: Camnoc fill level register info
  */
 struct cam_cpas_monitor {
@@ -227,6 +229,7 @@ struct cam_cpas_monitor {
 	uint32_t                            be_ddr;
 	uint32_t                            fe_mnoc;
 	uint32_t                            be_mnoc;
+	uint32_t                            be_shub;
 	uint32_t                            camnoc_fill_level[5];
 };
 

drivers/cam_icp/icp_hw/icp_hw_mgr/cam_icp_hw_mgr.c

@@ -101,10 +101,16 @@ static const char *cam_icp_dev_type_to_name(
 	switch (dev_type) {
 	case CAM_ICP_RES_TYPE_BPS:
 		return "BPS";
-	case CAM_ICP_RES_TYPE_IPE_RT:
-		return "IPE_RT";
+	case CAM_ICP_RES_TYPE_BPS_RT:
+		return "BPS_RT";
+	case CAM_ICP_RES_TYPE_BPS_SEMI_RT:
+		return "BPS_SEMI_RT";
 	case CAM_ICP_RES_TYPE_IPE:
 		return "IPE";
+	case CAM_ICP_RES_TYPE_IPE_RT:
+		return "IPE_RT";
+	case CAM_ICP_RES_TYPE_IPE_SEMI_RT:
+		return "IPE_SEMI_RT";
 	default:
 		return "Invalid dev type";
 	}
@@ -1464,10 +1470,18 @@ static int cam_icp_update_clk_rate(struct cam_icp_hw_mgr *hw_mgr,
 		dev_intf = bps_dev_intf;
 		curr_clk_rate = hw_mgr->clk_info[ICP_CLK_HW_BPS].curr_clk;
 		id = CAM_ICP_BPS_CMD_UPDATE_CLK;
+		cam_cpas_notify_event("Before BPS Clk Update",
+			hw_mgr->clk_info[ICP_CLK_HW_BPS].prev_clk);
+		hw_mgr->clk_info[ICP_CLK_HW_BPS].prev_clk = curr_clk_rate;
+		cam_cpas_notify_event("After BPS Clk Update", curr_clk_rate);
 	} else {
 		dev_intf = ipe0_dev_intf;
 		curr_clk_rate = hw_mgr->clk_info[ICP_CLK_HW_IPE].curr_clk;
 		id = CAM_ICP_IPE_CMD_UPDATE_CLK;
+		cam_cpas_notify_event("Before IPE Clk Update",
+			hw_mgr->clk_info[ICP_CLK_HW_IPE].prev_clk);
+		hw_mgr->clk_info[ICP_CLK_HW_IPE].prev_clk = curr_clk_rate;
+		cam_cpas_notify_event("After IPE Clk Update", curr_clk_rate);
 	}
 
 	CAM_DBG(CAM_PERF, "clk_rate %u for dev_type %d", curr_clk_rate,
@@ -4114,6 +4128,8 @@ static int cam_icp_mgr_config_hw(void *hw_mgr_priv, void *config_hw_args)
 			"Anomaly submitting flushed req %llu [last_flush %llu] in ctx %u",
 			req_id, ctx_data->last_flush_req, ctx_data->ctx_id);
 
+	cam_cpas_notify_event(ctx_data->ctx_id_string, req_id);
+
 	rc = cam_icp_mgr_enqueue_config(hw_mgr, config_args);
 	if (rc)
 		goto config_err;
@@ -5759,6 +5775,14 @@ static int cam_icp_mgr_acquire_hw(void *hw_mgr_priv, void *acquire_hw_args)
 
 	ctx_data->context_priv = args->context_data;
 	args->ctxt_to_hw_map = ctx_data;
+	args->hw_mgr_ctx_id = ctx_data->ctx_id;
+
+	snprintf(ctx_data->ctx_id_string, sizeof(ctx_data->ctx_id_string),
+		"%s_ctx[%d]_hwmgrctx[%d]_Submit",
+		cam_icp_dev_type_to_name(
+		ctx_data->icp_dev_acquire_info->dev_type),
+		args->ctx_id,
+		ctx_data->ctx_id);
 
 	bitmap_size = BITS_TO_LONGS(CAM_FRAME_CMD_MAX) * sizeof(long);
 	ctx_data->hfi_frame_process.bitmap =

drivers/cam_icp/icp_hw/icp_hw_mgr/cam_icp_hw_mgr.h

@@ -265,6 +265,7 @@ struct cam_icp_hw_ctx_data {
 	uint32_t watch_dog_reset_counter;
 	struct cam_icp_acquire_dev_info icp_dev_io_info;
 	uint64_t last_flush_req;
+	char ctx_id_string[128];
 };
 
 /**
@@ -283,6 +284,7 @@ struct icp_cmd_generic_blob {
  * struct cam_icp_clk_info
  * @base_clk: Base clock to process request
  * @curr_clk: Current clock of hadrware
+ * @prev_clk: Previous clock of hadrware
  * @threshold: Threshold for overclk count
  * @over_clked: Over clock count
  * @uncompressed_bw: Current bandwidth voting
@@ -296,6 +298,7 @@ struct icp_cmd_generic_blob {
 struct cam_icp_clk_info {
 	uint32_t base_clk;
 	uint32_t curr_clk;
+	uint32_t prev_clk;
 	uint32_t threshold;
 	uint32_t over_clked;
 	uint64_t uncompressed_bw;

drivers/cam_isp/isp_hw_mgr/isp_hw/vfe_hw/vfe_top/cam_vfe_camif_ver3.c

@@ -1453,6 +1453,8 @@ static int cam_vfe_camif_ver3_handle_irq_bottom_half(void *handler_priv,
 		camif_priv->epoch_ts.tv_nsec =
 			payload->ts.mono_time.tv_nsec;
 
+		cam_cpas_notify_event("IFE EPOCH", evt_info.hw_idx);
+
 		if (camif_priv->event_cb)
 			camif_priv->event_cb(camif_priv->priv,
 				CAM_ISP_HW_EVENT_EPOCH, (void *)&evt_info);

drivers/cam_jpeg/jpeg_hw/cam_jpeg_hw_mgr.c

@@ -28,6 +28,7 @@
 #include "cam_cdm_intf_api.h"
 #include "cam_debug_util.h"
 #include "cam_common_util.h"
+#include "cam_cpas_api.h"
 
 #define CAM_JPEG_HW_ENTRIES_MAX  20
 #define CAM_JPEG_CHBASE          0
@@ -151,6 +152,8 @@ static int cam_jpeg_process_next_hw_update(void *priv, void *data,
 		goto end_error;
 	}
 
+	cam_cpas_notify_event("JPEG Submit", config_args->request_id);
+
 	return 0;
 end_error:
 	return rc;

drivers/cam_jpeg/jpeg_hw/jpeg_enc_hw/jpeg_enc_core.c

@@ -212,6 +212,7 @@ irqreturn_t cam_jpeg_enc_irq(int irq_num, void *data)
 			} else {
 				CAM_ERR(CAM_JPEG, "unexpected done, no cb");
 			}
+			cam_cpas_notify_event("JPEG FrameDone", 0);
 		} else {
 			CAM_ERR(CAM_JPEG, "unexpected done irq");
 		}