msm: camera: tfe: Add pid and mid support for tfe

Process tfe page faults based on the pid and mid values.
When page fault happen kernel api gives the pid and mid value,
From pid and mid values TFE hw and tfe port that caused the
Page fault can be find. Added support for this in the tfe driver.
Based on the Pid and Mid values, get the HW id and port ids,
go through all context which has this hw id and port id and log
the data. Once context id is identified, log the acquire data and
last consumed client address details. Dump the hw register data
in the given buffer. Send the smmu page fault event through
v4l2 queue to user.

CRs-Fixed: 2775154
Change-Id: Iafaa7d1283ea0b836c223ed1fe6c419b0ac50c15
Signed-off-by: Ravikishore Pampana <[email protected]>

drivers/cam_isp/isp_hw_mgr/cam_ife_hw_mgr.c

@@ -6689,7 +6689,6 @@ static void cam_ife_mgr_dump_pf_data(
 	struct cam_hw_cmd_args *hw_cmd_args)
 {
 	struct cam_ife_hw_mgr_ctx *ctx;
-
 	struct cam_isp_hw_mgr_res          *hw_mgr_res;
 	struct cam_isp_hw_get_cmd_update    cmd_update;
 	struct cam_isp_hw_get_res_for_mid   get_res;

drivers/cam_isp/isp_hw_mgr/cam_tfe_hw_mgr.c

@@ -1105,7 +1105,7 @@ static int cam_tfe_hw_mgr_acquire_res_tfe_in(
 				continue;
 
 			hw_intf = tfe_hw_mgr->tfe_devices[
-				csid_res->hw_res[i]->hw_intf->hw_idx];
+				csid_res->hw_res[i]->hw_intf->hw_idx]->hw_intf;
 
 			/* fill in more acquire information as needed */
 			/* slave Camif resource, */
@@ -2782,10 +2782,10 @@ static int cam_tfe_mgr_reset_tfe_hw(struct cam_tfe_hw_mgr *hw_mgr,
 		if (!hw_mgr->tfe_devices[i])
 			continue;
 
-		if (hw_idx != hw_mgr->tfe_devices[i]->hw_idx)
+		if (hw_idx != hw_mgr->tfe_devices[i]->hw_intf->hw_idx)
 			continue;
 		CAM_DBG(CAM_ISP, "TFE (id = %d) reset", hw_idx);
-		tfe_hw_intf = hw_mgr->tfe_devices[i];
+		tfe_hw_intf = hw_mgr->tfe_devices[i]->hw_intf;
 		tfe_hw_intf->hw_ops.reset(tfe_hw_intf->hw_priv,
 			&tfe_reset_type, sizeof(tfe_reset_type));
 		break;
@@ -3089,7 +3089,7 @@ static int cam_tfe_mgr_user_dump_hw(
 	rc = cam_tfe_mgr_handle_reg_dump(tfe_ctx,
 		tfe_ctx->reg_dump_buf_desc,
 		tfe_ctx->num_reg_dump_buf,
-		CAM_ISP_PACKET_META_REG_DUMP_ON_ERROR,
+		CAM_ISP_TFE_PACKET_META_REG_DUMP_ON_ERROR,
 		&soc_dump_args,
 		true);
 	if (rc) {
@@ -4294,77 +4294,250 @@ static int cam_tfe_mgr_sof_irq_debug(
 	return rc;
 }
 
-static void cam_tfe_mgr_print_io_bufs(struct cam_packet *packet,
-	int32_t iommu_hdl, int32_t sec_mmu_hdl, uint32_t pf_buf_info,
-	bool *mem_found)
+static void cam_tfe_mgr_print_io_bufs(struct cam_tfe_hw_mgr  *hw_mgr,
+		uint32_t res_id, struct cam_packet *packet,
+		bool    *ctx_found, struct cam_tfe_hw_mgr_ctx *ctx)
 {
-	dma_addr_t  iova_addr;
-	size_t      src_buf_size;
-	int         i, j;
-	int         rc = 0;
-	int32_t     mmu_hdl;
 
 	struct cam_buf_io_cfg  *io_cfg = NULL;
+	int32_t      mmu_hdl, iommu_hdl, sec_mmu_hdl;
+	dma_addr_t   iova_addr;
+	size_t        src_buf_size;
+	int  i, j, rc = 0;
 
-	if (mem_found)
-		*mem_found = false;
+	iommu_hdl = hw_mgr->mgr_common.img_iommu_hdl;
+	sec_mmu_hdl = hw_mgr->mgr_common.img_iommu_hdl_secure;
 
 	io_cfg = (struct cam_buf_io_cfg *)((uint32_t *)&packet->payload +
 		packet->io_configs_offset / 4);
 
 	for (i = 0; i < packet->num_io_configs; i++) {
-		for (j = 0; j < CAM_PACKET_MAX_PLANES; j++) {
-			if (!io_cfg[i].mem_handle[j])
-				break;
+		if (io_cfg[i].resource_type != res_id)
+			continue;
+		else
+			break;
+	}
 
-			if (pf_buf_info &&
-				GET_FD_FROM_HANDLE(io_cfg[i].mem_handle[j]) ==
-				GET_FD_FROM_HANDLE(pf_buf_info)) {
-				CAM_INFO(CAM_ISP,
-					"Found PF at port: 0x%x mem 0x%x fd: 0x%x",
-					io_cfg[i].resource_type,
-					io_cfg[i].mem_handle[j],
-					pf_buf_info);
-				if (mem_found)
-					*mem_found = true;
-			}
+	if (i == packet->num_io_configs) {
+		CAM_ERR(CAM_ISP,
+			"getting io port for mid resource id failed ctx id:%d req id:%lld res id:0x%x",
+			ctx->ctx_index, packet->header.request_id,
+			res_id);
+		return;
+	}
 
-			CAM_INFO(CAM_ISP, "port: 0x%x f: %u format: %d dir %d",
-				io_cfg[i].resource_type,
-				io_cfg[i].fence,
-				io_cfg[i].format,
-				io_cfg[i].direction);
-
-			mmu_hdl = cam_mem_is_secure_buf(
-				io_cfg[i].mem_handle[j]) ? sec_mmu_hdl :
-				iommu_hdl;
-			rc = cam_mem_get_io_buf(io_cfg[i].mem_handle[j],
-				mmu_hdl, &iova_addr, &src_buf_size);
-			if (rc < 0) {
-				CAM_ERR(CAM_ISP,
-					"get src buf address fail mem_handle 0x%x",
-					io_cfg[i].mem_handle[j]);
-				continue;
-			}
-			if ((iova_addr & 0xFFFFFFFF) != iova_addr) {
-				CAM_ERR(CAM_ISP, "Invalid mapped address");
-				rc = -EINVAL;
+	for (j = 0; j < CAM_PACKET_MAX_PLANES; j++) {
+		if (!io_cfg[i].mem_handle[j])
+			break;
+
+		CAM_INFO(CAM_ISP, "port: 0x%x f: %u format: %d dir %d",
+			io_cfg[i].resource_type,
+			io_cfg[i].fence,
+			io_cfg[i].format,
+			io_cfg[i].direction);
+
+		mmu_hdl = cam_mem_is_secure_buf(
+			io_cfg[i].mem_handle[j]) ? sec_mmu_hdl :
+			iommu_hdl;
+		rc = cam_mem_get_io_buf(io_cfg[i].mem_handle[j],
+			mmu_hdl, &iova_addr, &src_buf_size);
+		if (rc < 0) {
+			CAM_ERR(CAM_ISP,
+				"get src buf address fail mem_handle 0x%x",
+				io_cfg[i].mem_handle[j]);
+			continue;
+		}
+		if ((iova_addr & 0xFFFFFFFF) != iova_addr) {
+			CAM_ERR(CAM_ISP, "Invalid mapped address");
+			rc = -EINVAL;
+			continue;
+		}
+
+		CAM_INFO(CAM_ISP,
+			"pln %d w %d h %d s %u size 0x%x addr 0x%x end_addr 0x%x offset %x memh %x",
+			j, io_cfg[i].planes[j].width,
+			io_cfg[i].planes[j].height,
+			io_cfg[i].planes[j].plane_stride,
+			(unsigned int)src_buf_size,
+			(unsigned int)iova_addr,
+			(unsigned int)iova_addr +
+			(unsigned int)src_buf_size,
+			io_cfg[i].offsets[j],
+			io_cfg[i].mem_handle[j]);
+	}
+}
+
+static void cam_tfe_mgr_pf_dump(uint32_t res_id,
+	struct cam_tfe_hw_mgr_ctx *ctx)
+{
+	struct cam_isp_hw_mgr_res        *hw_mgr_res;
+	struct cam_hw_intf               *hw_intf;
+	struct cam_isp_hw_get_cmd_update  cmd_update;
+	uint32_t                          res_id_out;
+	int  i, rc = 0;
+
+	/* dump the registers  */
+	rc = cam_tfe_mgr_handle_reg_dump(ctx, ctx->reg_dump_buf_desc,
+		ctx->num_reg_dump_buf,
+		CAM_ISP_TFE_PACKET_META_REG_DUMP_ON_ERROR, NULL, false);
+	if (rc) {
+		CAM_ERR(CAM_ISP,
+			"Reg dump on pf failed req id: %llu rc: %d",
+			ctx->applied_req_id, rc);
+	}
+
+	/* dump the acquire data */
+	list_for_each_entry(hw_mgr_res, &ctx->res_list_tfe_csid, list) {
+		for (i = 0; i < CAM_ISP_HW_SPLIT_MAX; i++) {
+			if (!hw_mgr_res->hw_res[i])
 				continue;
+
+			hw_intf = hw_mgr_res->hw_res[i]->hw_intf;
+			if (hw_intf && hw_intf->hw_ops.process_cmd) {
+				rc = hw_intf->hw_ops.process_cmd(
+					hw_intf->hw_priv,
+					CAM_TFE_CSID_LOG_ACQUIRE_DATA,
+					hw_mgr_res->hw_res[i],
+					sizeof(void *));
+				if (rc)
+					CAM_ERR(CAM_ISP,
+						"acquire dump data failed");
+			} else
+				CAM_ERR(CAM_ISP, "NULL hw_intf!");
+		}
+	}
+
+	res_id_out = res_id & 0xFF;
+
+	if (res_id_out >= CAM_TFE_HW_OUT_RES_MAX) {
+		CAM_ERR(CAM_ISP, "Invalid out resource id :%x",
+			res_id);
+		return;
+	}
+
+	hw_mgr_res =
+		&ctx->res_list_tfe_out[res_id_out];
+	for (i = 0; i < CAM_ISP_HW_SPLIT_MAX; i++) {
+		if (!hw_mgr_res->hw_res[i])
+			continue;
+
+		cmd_update.cmd_type = CAM_ISP_HW_CMD_DUMP_BUS_INFO;
+		cmd_update.res = hw_mgr_res->hw_res[i];
+		hw_intf = hw_mgr_res->hw_res[i]->hw_intf;
+		if (hw_intf->hw_ops.process_cmd) {
+			rc = hw_intf->hw_ops.process_cmd(
+				hw_intf->hw_priv,
+				CAM_ISP_HW_CMD_DUMP_BUS_INFO,
+				(void *)&cmd_update,
+				sizeof(struct cam_isp_hw_get_cmd_update));
+		}
+	}
+}
+
+static void cam_tfe_mgr_dump_pf_data(
+	struct cam_tfe_hw_mgr  *hw_mgr,
+	struct cam_hw_cmd_args *hw_cmd_args)
+{
+	struct cam_tfe_hw_mgr_ctx           *ctx;
+	struct cam_isp_hw_mgr_res           *hw_mgr_res;
+	struct cam_isp_hw_get_cmd_update     cmd_update;
+	struct cam_isp_hw_get_res_for_mid    get_res;
+	struct cam_packet                   *packet;
+	uint32_t  *resource_type;
+	uint32_t   hw_id;
+	bool      *ctx_found, hw_id_found = false;
+	int        i, j, rc = 0;
+
+	ctx = (struct cam_tfe_hw_mgr_ctx *)hw_cmd_args->ctxt_to_hw_map;
+
+	packet  = hw_cmd_args->u.pf_args.pf_data.packet;
+	ctx_found = hw_cmd_args->u.pf_args.ctx_found;
+	resource_type = hw_cmd_args->u.pf_args.resource_type;
+
+	if ((*ctx_found) && (*resource_type))
+		goto outportlog;
+
+	for (i = 0; i < CAM_TFE_HW_NUM_MAX; i++) {
+		if (!g_tfe_hw_mgr.tfe_devices[i])
+			continue;
+
+		for (j = 0; j < g_tfe_hw_mgr.tfe_devices[i]->num_hw_pid; j++) {
+			if (g_tfe_hw_mgr.tfe_devices[i]->hw_pid[j] ==
+				hw_cmd_args->u.pf_args.pid) {
+				hw_id_found = true;
+				hw_id = i;
+				break;
 			}
+		}
+		if (hw_id_found)
+			break;
+	}
 
-			CAM_INFO(CAM_ISP,
-				"pln %d w %d h %d s %u size 0x%x addr 0x%x end_addr 0x%x offset %x memh %x",
-				j, io_cfg[i].planes[j].width,
-				io_cfg[i].planes[j].height,
-				io_cfg[i].planes[j].plane_stride,
-				(unsigned int)src_buf_size,
-				(unsigned int)iova_addr,
-				(unsigned int)iova_addr +
-				(unsigned int)src_buf_size,
-				io_cfg[i].offsets[j],
-				io_cfg[i].mem_handle[j]);
+	if (i == CAM_TFE_HW_NUM_MAX) {
+		CAM_INFO(CAM_ISP,
+			"PID:%d  is not matching with any TFE HW PIDs ctx id:%d",
+			hw_cmd_args->u.pf_args.pid,  ctx->ctx_index);
+		return;
+	}
+
+	for (i = 0; i < ctx->num_base; i++) {
+		if (ctx->base[i].idx == hw_id) {
+			*ctx_found = true;
+			break;
 		}
 	}
+
+	if (!(*ctx_found)) {
+		CAM_INFO(CAM_ISP,
+			"This context does not cause pf:pid:%d hw id:%d ctx_id:%d",
+			hw_cmd_args->u.pf_args.pid, hw_id, ctx->ctx_index);
+		return;
+	}
+
+	for (i = 0; i < CAM_TFE_HW_OUT_RES_MAX; i++) {
+		hw_mgr_res = &ctx->res_list_tfe_out[i];
+		if (!hw_mgr_res->hw_res[0])
+			continue;
+
+		break;
+	}
+
+	if (i >= CAM_TFE_HW_OUT_RES_MAX) {
+		CAM_ERR(CAM_ISP,
+			"NO valid outport resources ctx id:%d req id:%lld",
+			ctx->ctx_index, packet->header.request_id);
+		return;
+	}
+
+	get_res.mid = hw_cmd_args->u.pf_args.mid;
+	cmd_update.res = hw_mgr_res->hw_res[0];
+	cmd_update.cmd_type = CAM_ISP_HW_CMD_GET_RES_FOR_MID;
+	cmd_update.data = (void *) &get_res;
+
+	/* get resource id for given mid */
+	rc = hw_mgr_res->hw_res[0]->hw_intf->hw_ops.process_cmd(
+		hw_mgr_res->hw_res[0]->hw_intf->hw_priv,
+		cmd_update.cmd_type, &cmd_update,
+		sizeof(struct cam_isp_hw_get_cmd_update));
+
+	if (rc) {
+		CAM_ERR(CAM_ISP,
+			"getting mid port resource id failed ctx id:%d req id:%lld",
+			ctx->ctx_index, packet->header.request_id);
+		return;
+	}
+	CAM_ERR(CAM_ISP,
+		"Page fault on resource id:0x%x ctx id:%d req id:%lld",
+		get_res.out_res_id, ctx->ctx_index, packet->header.request_id);
+	*resource_type = get_res.out_res_id;
+
+	cam_tfe_mgr_pf_dump(get_res.out_res_id, ctx);
+
+outportlog:
+	cam_tfe_mgr_print_io_bufs(hw_mgr, *resource_type, packet,
+		ctx_found, ctx);
+
+
 }
 
 static void cam_tfe_mgr_ctx_irq_dump(struct cam_tfe_hw_mgr_ctx *ctx)
@@ -4463,12 +4636,7 @@ static int cam_tfe_mgr_cmd(void *hw_mgr_priv, void *cmd_args)
 		}
 		break;
 	case CAM_HW_MGR_CMD_DUMP_PF_INFO:
-		cam_tfe_mgr_print_io_bufs(
-			hw_cmd_args->u.pf_args.pf_data.packet,
-			hw_mgr->mgr_common.img_iommu_hdl,
-			hw_mgr->mgr_common.img_iommu_hdl_secure,
-			hw_cmd_args->u.pf_args.buf_info,
-			hw_cmd_args->u.pf_args.mem_found);
+		cam_tfe_mgr_dump_pf_data(hw_mgr, hw_cmd_args);
 		break;
 	case CAM_HW_MGR_CMD_REG_DUMP_ON_FLUSH:
 		if (ctx->last_dump_flush_req_id == ctx->applied_req_id)
@@ -5277,9 +5445,10 @@ static int cam_tfe_hw_mgr_sort_dev_with_caps(
 	for (i = 0; i < CAM_TFE_HW_NUM_MAX; i++) {
 		if (!tfe_hw_mgr->tfe_devices[i])
 			continue;
-		if (tfe_hw_mgr->tfe_devices[i]->hw_ops.get_hw_caps) {
-			tfe_hw_mgr->tfe_devices[i]->hw_ops.get_hw_caps(
-				tfe_hw_mgr->tfe_devices[i]->hw_priv,
+
+		if (tfe_hw_mgr->tfe_devices[i]->hw_intf->hw_ops.get_hw_caps) {
+			tfe_hw_mgr->tfe_devices[i]->hw_intf->hw_ops.get_hw_caps(
+				tfe_hw_mgr->tfe_devices[i]->hw_intf->hw_priv,
 				&tfe_hw_mgr->tfe_dev_caps[i],
 				sizeof(tfe_hw_mgr->tfe_dev_caps[i]));
 		}
@@ -5406,7 +5575,7 @@ int cam_tfe_hw_mgr_init(struct cam_hw_mgr_intf *hw_mgr_intf, int *iommu_hdl)
 		rc = cam_tfe_hw_init(&g_tfe_hw_mgr.tfe_devices[i], i);
 		if (!rc) {
 			struct cam_hw_info *tfe_hw = (struct cam_hw_info *)
-				g_tfe_hw_mgr.tfe_devices[i]->hw_priv;
+				g_tfe_hw_mgr.tfe_devices[i]->hw_intf->hw_priv;
 			struct cam_hw_soc_info *soc_info = &tfe_hw->soc_info;
 
 			j++;

drivers/cam_isp/isp_hw_mgr/cam_tfe_hw_mgr.h

@@ -152,7 +152,7 @@ struct cam_tfe_hw_mgr {
 	struct cam_isp_hw_mgr          mgr_common;
 	struct cam_hw_intf            *tpg_devices[CAM_TOP_TPG_HW_NUM_MAX];
 	struct cam_hw_intf            *csid_devices[CAM_TFE_CSID_HW_NUM_MAX];
-	struct cam_hw_intf            *tfe_devices[CAM_TFE_HW_NUM_MAX];
+	struct cam_isp_hw_intf_data   *tfe_devices[CAM_TFE_HW_NUM_MAX];
 	struct cam_soc_reg_map        *cdm_reg_map[CAM_TFE_HW_NUM_MAX];
 	struct mutex                   ctx_mutex;
 	atomic_t                       active_ctx_cnt;

drivers/cam_isp/isp_hw_mgr/isp_hw/include/cam_tfe_csid_hw_intf.h

@@ -179,6 +179,7 @@ enum cam_tfe_csid_cmd_type {
 	CAM_TFE_CSID_SET_CSID_DEBUG,
 	CAM_TFE_CSID_SOF_IRQ_DEBUG,
 	CAM_TFE_CSID_CMD_GET_REG_DUMP,
+	CAM_TFE_CSID_LOG_ACQUIRE_DATA,
 	CAM_TFE_CSID_CMD_MAX,
 };
 

drivers/cam_isp/isp_hw_mgr/isp_hw/include/cam_tfe_hw_intf.h

@@ -248,6 +248,6 @@ struct cam_tfe_irq_evt_payload {
  *                          successful initialization
  * @hw_idx:                 Index of TFE HW
  */
-int cam_tfe_hw_init(struct cam_hw_intf **tfe_hw, uint32_t hw_idx);
+int cam_tfe_hw_init(struct cam_isp_hw_intf_data **tfe_hw, uint32_t hw_idx);
 
 #endif /* _CAM_TFE_HW_INTF_H_ */

drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_csid_hw/cam_tfe_csid_core.c

@@ -2530,6 +2530,53 @@ dump_bw:
 	return 0;
 }
 
+static int cam_tfe_csid_log_acquire_data(
+	struct cam_tfe_csid_hw   *csid_hw,  void *cmd_args)
+{
+	struct cam_isp_resource_node  *res =
+		(struct cam_isp_resource_node *)cmd_args;
+	struct cam_tfe_csid_path_cfg       *path_data;
+	struct cam_hw_soc_info                         *soc_info;
+	const struct cam_tfe_csid_reg_offset           *csid_reg;
+	uint32_t byte_cnt_ping, byte_cnt_pong;
+
+	path_data = (struct cam_tfe_csid_path_cfg *)res->res_priv;
+	csid_reg = csid_hw->csid_info->csid_reg;
+	soc_info = &csid_hw->hw_info->soc_info;
+
+	if (res->res_state <= CAM_ISP_RESOURCE_STATE_AVAILABLE) {
+		CAM_ERR(CAM_ISP,
+			"CSID:%d invalid res id:%d res type: %d state:%d",
+			csid_hw->hw_intf->hw_idx, res->res_id, res->res_type,
+			res->res_state);
+		return -EINVAL;
+	}
+
+	/* Dump all the acquire data for this  */
+	CAM_INFO(CAM_ISP,
+		"CSID:%d res id:%d type:%d state:%d in f:%d out f:%d st pix:%d end pix:%d st line:%d end line:%d",
+		csid_hw->hw_intf->hw_idx, res->res_id, res->res_type,
+		res->res_type, path_data->in_format, path_data->out_format,
+		path_data->start_pixel, path_data->end_pixel,
+		path_data->start_line, path_data->end_line);
+
+	if (res->res_id >= CAM_TFE_CSID_PATH_RES_RDI_0  &&
+		res->res_id <= CAM_TFE_CSID_PATH_RES_RDI_2) {
+		/* read total number of bytes transmitted through RDI */
+		byte_cnt_ping = cam_io_r_mb(soc_info->reg_map[0].mem_base +
+		csid_reg->rdi_reg[res->res_id]->csid_rdi_byte_cntr_ping_addr);
+		byte_cnt_pong = cam_io_r_mb(soc_info->reg_map[0].mem_base +
+		csid_reg->rdi_reg[res->res_id]->csid_rdi_byte_cntr_pong_addr);
+		CAM_INFO(CAM_ISP,
+			"CSID:%d res id:%d byte cnt val ping:%d pong:%d",
+			csid_hw->hw_intf->hw_idx, res->res_id,
+			byte_cnt_ping, byte_cnt_pong);
+	}
+
+	return 0;
+
+}
+
 static int cam_tfe_csid_process_cmd(void *hw_priv,
 	uint32_t cmd_type, void *cmd_args, uint32_t arg_size)
 {
@@ -2567,6 +2614,9 @@ static int cam_tfe_csid_process_cmd(void *hw_priv,
 	case CAM_ISP_HW_CMD_CSID_CHANGE_HALT_MODE:
 		rc = cam_tfe_csid_halt(csid_hw, cmd_args);
 		break;
+	case CAM_TFE_CSID_LOG_ACQUIRE_DATA:
+		rc = cam_tfe_csid_log_acquire_data(csid_hw, cmd_args);
+		break;
 	default:
 		CAM_ERR(CAM_ISP, "CSID:%d unsupported cmd:%d",
 			csid_hw->hw_intf->hw_idx, cmd_type);

drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_hw/cam_tfe530.h

@@ -740,6 +740,7 @@ static struct cam_tfe_bus_hw_info  tfe530_bus_hw_info = {
 			.max_height       = -1,
 			.composite_group  = CAM_TFE_BUS_COMP_GRP_5,
 			.rup_group_id     = CAM_TFE_BUS_RUP_GRP_1,
+			.mid              = 23,
 		},
 		{
 			.tfe_out_id       = CAM_TFE_BUS_TFE_OUT_RDI1,
@@ -747,6 +748,7 @@ static struct cam_tfe_bus_hw_info  tfe530_bus_hw_info = {
 			.max_height       = -1,
 			.composite_group  = CAM_TFE_BUS_COMP_GRP_6,
 			.rup_group_id     = CAM_TFE_BUS_RUP_GRP_2,
+			.mid              = 24,
 		},
 		{
 			.tfe_out_id       = CAM_TFE_BUS_TFE_OUT_RDI2,
@@ -754,6 +756,7 @@ static struct cam_tfe_bus_hw_info  tfe530_bus_hw_info = {
 			.max_height       = -1,
 			.composite_group  = CAM_TFE_BUS_COMP_GRP_7,
 			.rup_group_id     = CAM_TFE_BUS_RUP_GRP_3,
+			.mid              = 25,
 		},
 		{
 			.tfe_out_id       = CAM_TFE_BUS_TFE_OUT_FULL,
@@ -761,6 +764,7 @@ static struct cam_tfe_bus_hw_info  tfe530_bus_hw_info = {
 			.max_height       = 4096,
 			.composite_group  = CAM_TFE_BUS_COMP_GRP_0,
 			.rup_group_id     = CAM_TFE_BUS_RUP_GRP_0,
+			.mid              = 16,
 		},
 		{
 			.tfe_out_id       = CAM_TFE_BUS_TFE_OUT_RAW_DUMP,
@@ -768,6 +772,7 @@ static struct cam_tfe_bus_hw_info  tfe530_bus_hw_info = {
 			.max_height       = 4096,
 			.composite_group  = CAM_TFE_BUS_COMP_GRP_1,
 			.rup_group_id     = CAM_TFE_BUS_RUP_GRP_0,
+			.mid              = 17,
 		},
 		{
 			.tfe_out_id       = CAM_TFE_BUS_TFE_OUT_PDAF,
@@ -775,6 +780,7 @@ static struct cam_tfe_bus_hw_info  tfe530_bus_hw_info = {
 			.max_height       = 4096,
 			.composite_group  = CAM_TFE_BUS_COMP_GRP_7,
 			.rup_group_id     = CAM_TFE_BUS_RUP_GRP_3,
+			.mid              = 25,
 		},
 		{
 			.tfe_out_id       = CAM_TFE_BUS_TFE_OUT_STATS_HDR_BE,
@@ -782,6 +788,7 @@ static struct cam_tfe_bus_hw_info  tfe530_bus_hw_info = {
 			.max_height       = -1,
 			.composite_group  = CAM_TFE_BUS_COMP_GRP_3,
 			.rup_group_id     = CAM_TFE_BUS_RUP_GRP_0,
+			.mid              = 21,
 		},
 		{
 			.tfe_out_id       = CAM_TFE_BUS_TFE_OUT_STATS_HDR_BHIST,
@@ -789,6 +796,7 @@ static struct cam_tfe_bus_hw_info  tfe530_bus_hw_info = {
 			.max_height       = -1,
 			.composite_group  = CAM_TFE_BUS_COMP_GRP_2,
 			.rup_group_id     = CAM_TFE_BUS_RUP_GRP_0,
+			.mid              = 19,
 		},
 		{
 			.tfe_out_id       = CAM_TFE_BUS_TFE_OUT_STATS_TL_BG,
@@ -796,6 +804,7 @@ static struct cam_tfe_bus_hw_info  tfe530_bus_hw_info = {
 			.max_height       = -1,
 			.composite_group  = CAM_TFE_BUS_COMP_GRP_2,
 			.rup_group_id     = CAM_TFE_BUS_RUP_GRP_0,
+			.mid              = 18,
 		},
 		{
 			.tfe_out_id       = CAM_TFE_BUS_TFE_OUT_STATS_AWB_BG,
@@ -803,6 +812,7 @@ static struct cam_tfe_bus_hw_info  tfe530_bus_hw_info = {
 			.max_height       = -1,
 			.composite_group  = CAM_TFE_BUS_COMP_GRP_3,
 			.rup_group_id     = CAM_TFE_BUS_RUP_GRP_0,
+			.mid              = 20,
 		},
 		{
 			.tfe_out_id       = CAM_TFE_BUS_TFE_OUT_STATS_BF,
@@ -810,6 +820,7 @@ static struct cam_tfe_bus_hw_info  tfe530_bus_hw_info = {
 			.max_height       = -1,
 			.composite_group  = CAM_TFE_BUS_COMP_GRP_4,
 			.rup_group_id     = CAM_TFE_BUS_RUP_GRP_0,
+			.mid              = 22,
 		},
 	},
 	.comp_done_shift          = 8,

drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_hw/cam_tfe_bus.c

@@ -145,6 +145,7 @@ struct cam_tfe_bus_tfe_out_data {
 	uint32_t                         secure_mode;
 	void                            *priv;
 	cam_hw_mgr_event_cb_func         event_cb;
+	uint32_t                         mid;
 };
 
 struct cam_tfe_bus_priv {
@@ -1544,6 +1545,7 @@ static int cam_tfe_bus_init_tfe_out_resource(uint32_t  index,
 	rsrc_data->max_height      =
 		hw_info->tfe_out_hw_info[index].max_height;
 	rsrc_data->secure_mode  = CAM_SECURE_MODE_NON_SECURE;
+	rsrc_data->mid = hw_info->tfe_out_hw_info[index].mid;
 
 	tfe_out->hw_intf = bus_priv->common_data.hw_intf;
 
@@ -2099,6 +2101,113 @@ static int cam_tfe_bus_update_stripe_cfg(void *priv, void *cmd_args,
 	return 0;
 }
 
+static int cam_tfe_bus_get_res_id_for_mid(
+	struct cam_tfe_bus_priv    *bus_priv,
+	void *cmd_args, uint32_t arg_size)
+{
+	struct cam_tfe_bus_tfe_out_data     *tfe_out_data = NULL;
+	struct cam_isp_hw_get_cmd_update   *cmd_update =
+		(struct cam_isp_hw_get_cmd_update   *)cmd_args;
+	struct cam_isp_hw_get_res_for_mid       *get_res = NULL;
+	int i;
+
+	get_res = (struct cam_isp_hw_get_res_for_mid *)cmd_update->data;
+	if (!get_res) {
+		CAM_ERR(CAM_ISP,
+			"invalid get resource for mid paramas");
+		return -EINVAL;
+	}
+
+	for (i = 0; i < bus_priv->num_out; i++) {
+		tfe_out_data = (struct cam_tfe_bus_tfe_out_data  *)
+			bus_priv->tfe_out[i].res_priv;
+
+		if (!tfe_out_data)
+			continue;
+
+		if (tfe_out_data->mid == get_res->mid)
+			goto end;
+	}
+
+	if (i == bus_priv->num_out) {
+		CAM_ERR(CAM_ISP,
+			"mid:%d does not match with any out resource",
+			get_res->mid);
+		get_res->out_res_id = 0;
+		return -EINVAL;
+	}
+
+end:
+	CAM_INFO(CAM_ISP, "match mid :%d  out resource:%d found",
+		get_res->mid, bus_priv->tfe_out[i].res_id);
+	get_res->out_res_id = bus_priv->tfe_out[i].res_id;
+	return 0;
+}
+
+static int cam_tfe_bus_dump_bus_info(
+	struct cam_tfe_bus_priv    *bus_priv,
+	void *cmd_args, uint32_t arg_size)
+{
+	struct cam_tfe_bus_tfe_out_data     *tfe_out_data = NULL;
+	struct cam_isp_hw_get_cmd_update   *cmd_update =
+		(struct cam_isp_hw_get_cmd_update   *)cmd_args;
+	struct cam_tfe_bus_wm_resource_data   *wm_data;
+	struct cam_tfe_bus_common_data        *common_data;
+	uint32_t i, addr_status0, addr_status1, addr_status2, addr_status3;
+
+	tfe_out_data = (struct cam_tfe_bus_tfe_out_data  *)
+		cmd_update->res->res_priv;
+	common_data = tfe_out_data->common_data;
+
+	for (i = 0; i < tfe_out_data->num_wm; i++) {
+		wm_data = tfe_out_data->wm_res[i]->res_priv;
+		addr_status0 = cam_io_r_mb(common_data->mem_base +
+			wm_data->hw_regs->addr_status_0);
+		addr_status1 = cam_io_r_mb(common_data->mem_base +
+			wm_data->hw_regs->addr_status_1);
+		addr_status2 = cam_io_r_mb(common_data->mem_base +
+			wm_data->hw_regs->addr_status_2);
+		addr_status3 = cam_io_r_mb(common_data->mem_base +
+			wm_data->hw_regs->addr_status_3);
+		CAM_INFO(CAM_ISP,
+			"TFE:%d WM:%d %s last consumed addr:0x%x last frame addr:0x%x fifo cnt:0x%x cur clt addr:0x%x",
+			common_data->hw_intf->hw_idx,
+			wm_data->index,
+			wm_data->hw_regs->client_name,
+			addr_status0,
+			addr_status1,
+			addr_status2,
+			addr_status3);
+
+		CAM_INFO(CAM_ISP,
+			"WM:%d %s width0x%x height:0x%x format:%d stride:0x%x offset:0x%x encfg:%x",
+			wm_data->index,
+			wm_data->hw_regs->client_name,
+			wm_data->acquired_width,
+			wm_data->acquired_height,
+			wm_data->format,
+			wm_data->acquired_stride,
+			wm_data->offset,
+			wm_data->en_cfg);
+
+		CAM_INFO(CAM_ISP,
+			"WM:%d current width:0x%x height:0x%x stride:0x%x",
+			wm_data->index,
+			wm_data->width,
+			wm_data->height,
+			wm_data->stride);
+	}
+
+	for (i = 0; i < CAM_TFE_BUS_MAX_CLIENTS; i++) {
+		wm_data = bus_priv->bus_client[i].res_priv;
+		/* disable WM */
+			cam_io_w_mb(0, common_data->mem_base +
+				wm_data->hw_regs->cfg);
+
+	}
+	return 0;
+}
+
 static int cam_tfe_bus_init_hw(void *hw_priv,
 	void *init_hw_args, uint32_t arg_size)
 {
@@ -2198,6 +2307,12 @@ static int cam_tfe_bus_process_cmd(void *priv,
 		*support_consumed_addr =
 			bus_priv->common_data.support_consumed_addr;
 		break;
+	case CAM_ISP_HW_CMD_GET_RES_FOR_MID:
+		rc = cam_tfe_bus_get_res_id_for_mid(priv, cmd_args, arg_size);
+		break;
+	case CAM_ISP_HW_CMD_DUMP_BUS_INFO:
+		rc = cam_tfe_bus_dump_bus_info(priv, cmd_args, arg_size);
+		break;
 	default:
 		CAM_ERR_RATE_LIMIT(CAM_ISP, "Invalid camif process command:%d",
 			cmd_type);

drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_hw/cam_tfe_bus.h

@@ -18,6 +18,7 @@
 #define CAM_TFE_BUS_CLIENT_NAME_MAX_LENGTH 32
 
 #define CAM_TFE_BUS_1_0             0x1000
+#define CAM_TFE_BUS_MAX_MID_PER_PORT        1
 
 
 #define CAM_TFE_ADD_REG_VAL_PAIR(buf_array, index, offset, val)    \
@@ -157,6 +158,7 @@ struct cam_tfe_bus_reg_offset_bus_client {
  * max_height        Max height supported by outport
  * composite_group   Out port composite group id
  * rup_group_id      Reg update group of outport id
+ * mid:              ouport mid value
  */
 struct cam_tfe_bus_tfe_out_hw_info {
 	enum cam_tfe_bus_tfe_out_id         tfe_out_id;
@@ -164,6 +166,7 @@ struct cam_tfe_bus_tfe_out_hw_info {
 	uint32_t                            max_height;
 	uint32_t                            composite_group;
 	uint32_t                            rup_group_id;
+	uint32_t                            mid;
 };
 
 /*

drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_hw/cam_tfe_core.c

@@ -2811,6 +2811,8 @@ int cam_tfe_process_cmd(void *hw_priv, uint32_t cmd_type,
 	case CAM_ISP_HW_CMD_STOP_BUS_ERR_IRQ:
 	case CAM_ISP_HW_CMD_GET_SECURE_MODE:
 	case CAM_ISP_HW_CMD_IS_CONSUMED_ADDR_SUPPORT:
+	case CAM_ISP_HW_CMD_GET_RES_FOR_MID:
+	case CAM_ISP_HW_CMD_DUMP_BUS_INFO:
 		rc = core_info->tfe_bus->hw_ops.process_cmd(
 			core_info->tfe_bus->bus_priv, cmd_type, cmd_args,
 			arg_size);

drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_hw/cam_tfe_dev.c

@@ -12,7 +12,7 @@
 #include "cam_debug_util.h"
 #include "camera_main.h"
 
-static struct cam_hw_intf *cam_tfe_hw_list[CAM_TFE_HW_NUM_MAX] = {0, 0, 0};
+static struct cam_isp_hw_intf_data  cam_tfe_hw_list[CAM_TFE_HW_NUM_MAX];
 
 static char tfe_dev_name[8];
 
@@ -24,8 +24,10 @@ static int cam_tfe_component_bind(struct device *dev,
 	const struct of_device_id         *match_dev = NULL;
 	struct cam_tfe_hw_core_info       *core_info = NULL;
 	struct cam_tfe_hw_info            *hw_info = NULL;
+	struct cam_tfe_soc_private        *tfe_soc_priv;
 	int                                rc = 0;
 	struct platform_device *pdev = to_platform_device(dev);
+	uint32_t  i;
 
 	tfe_hw_intf = kzalloc(sizeof(struct cam_hw_intf), GFP_KERNEL);
 	if (!tfe_hw_intf) {
@@ -108,7 +110,18 @@ static int cam_tfe_component_bind(struct device *dev,
 	init_completion(&tfe_hw->hw_complete);
 
 	if (tfe_hw_intf->hw_idx < CAM_TFE_HW_NUM_MAX)
-		cam_tfe_hw_list[tfe_hw_intf->hw_idx] = tfe_hw_intf;
+		cam_tfe_hw_list[tfe_hw_intf->hw_idx].hw_intf = tfe_hw_intf;
+	else {
+		CAM_ERR(CAM_ISP, "HW index:%d is wrong max HW idx:%d",
+			tfe_hw_intf->hw_idx, CAM_TFE_HW_NUM_MAX);
+		goto deinit_soc;
+	}
+
+	tfe_soc_priv = tfe_hw->soc_info.soc_private;
+	cam_tfe_hw_list[tfe_hw_intf->hw_idx].num_hw_pid = tfe_soc_priv->num_pid;
+	for (i = 0; i < tfe_soc_priv->num_pid; i++)
+		cam_tfe_hw_list[tfe_hw_intf->hw_idx].hw_pid[i] =
+			tfe_soc_priv->pid[i];
 
 	cam_tfe_init_hw(tfe_hw, NULL, 0);
 	cam_tfe_deinit_hw(tfe_hw, NULL, 0);
@@ -149,7 +162,7 @@ static void cam_tfe_component_unbind(struct device *dev,
 		tfe_hw_intf->hw_type, tfe_hw_intf->hw_idx);
 
 	if (tfe_hw_intf->hw_idx < CAM_TFE_HW_NUM_MAX)
-		cam_tfe_hw_list[tfe_hw_intf->hw_idx] = NULL;
+		cam_tfe_hw_list[tfe_hw_intf->hw_idx].hw_intf = NULL;
 
 	tfe_hw = tfe_hw_intf->hw_priv;
 	if (!tfe_hw) {
@@ -206,15 +219,16 @@ int cam_tfe_remove(struct platform_device *pdev)
 	return 0;
 }
 
-int cam_tfe_hw_init(struct cam_hw_intf **tfe_hw, uint32_t hw_idx)
+int cam_tfe_hw_init(struct cam_isp_hw_intf_data **tfe_hw_intf,
+	uint32_t hw_idx)
 {
 	int rc = 0;
 
-	if (cam_tfe_hw_list[hw_idx]) {
-		*tfe_hw = cam_tfe_hw_list[hw_idx];
+	if (cam_tfe_hw_list[hw_idx].hw_intf) {
+		*tfe_hw_intf = &cam_tfe_hw_list[hw_idx];
 		rc = 0;
 	} else {
-		*tfe_hw = NULL;
+		*tfe_hw_intf = NULL;
 		rc = -ENODEV;
 	}
 	return rc;

drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_hw/cam_tfe_soc.c

@@ -25,9 +25,9 @@ static bool cam_tfe_cpas_cb(uint32_t client_handle, void *userdata,
 int cam_tfe_init_soc_resources(struct cam_hw_soc_info *soc_info,
 	irq_handler_t tfe_irq_handler, void *irq_data)
 {
-	int                               rc = 0;
 	struct cam_tfe_soc_private       *soc_private;
 	struct cam_cpas_register_params   cpas_register_param;
+	int    rc = 0,  i = 0, num_pid = 0;
 
 	soc_private = kzalloc(sizeof(struct cam_tfe_soc_private),
 		GFP_KERNEL);
@@ -43,6 +43,27 @@ int cam_tfe_init_soc_resources(struct cam_hw_soc_info *soc_info,
 		goto free_soc_private;
 	}
 
+	/* set some default values */
+	soc_private->num_pid = 0;
+
+	num_pid = of_property_count_u32_elems(soc_info->pdev->dev.of_node,
+		"cam_hw_pid");
+	CAM_DBG(CAM_CPAS, "tfe:%d pid count %d", soc_info->index, num_pid);
+
+	if (num_pid <= 0  || num_pid > CAM_ISP_HW_MAX_PID_VAL)
+		goto clk_option;
+
+	for (i = 0; i < num_pid; i++) {
+		of_property_read_u32_index(soc_info->pdev->dev.of_node,
+		"cam_hw_pid", i, &soc_private->pid[i]);
+		CAM_INFO(CAM_CPAS, "tfe:%d I:%d pid %d", soc_info->index,
+			i, soc_private->pid[i]);
+	}
+
+	soc_private->num_pid = num_pid;
+
+clk_option:
+
 	rc = cam_soc_util_get_option_clk_by_name(soc_info,
 		CAM_TFE_DSP_CLK_NAME, &soc_private->dsp_clk,
 		&soc_private->dsp_clk_index, &soc_private->dsp_clk_rate);

drivers/cam_isp/isp_hw_mgr/isp_hw/tfe_hw/cam_tfe_soc.h

@@ -26,6 +26,8 @@ enum cam_cpas_handle_id {
  *                           This handle is used for all further interface
  *                           with CPAS.
  * @cpas_version:            Has cpas version read from Hardware
+ * @num_pid:                 number of pids of tfe
+ * @pid:                     TFE pid value list
  */
 struct cam_tfe_soc_private {
 	uint32_t    cpas_handle;
@@ -33,6 +35,8 @@ struct cam_tfe_soc_private {
 	struct clk *dsp_clk;
 	int32_t     dsp_clk_index;
 	int32_t     dsp_clk_rate;
+	uint32_t    num_pid;
+	uint32_t    pid[CAM_ISP_HW_MAX_PID_VAL];
 };
 
 /*