msm: eva: Enhance SMMU fault debugability

Changes only applicable on CPU EVA path, including
- tracking packet type and buffer index for each dma_buf
- print feature config packet type
- print session properties in error cases.

Change-Id: I938cf463bee9284760145f3fd9e030b3b8134caa
Signed-off-by: George Shen <quic_sqiao@quicinc.com>

msm/eva/cvp_hfi.c

@@ -626,6 +626,8 @@ static int __smem_alloc(struct iris_hfi_device *dev, struct cvp_mem_addr *mem,
 	mem->mem_size = alloc->size;
 	mem->align_virtual_addr = alloc->kvaddr;
 	mem->align_device_addr = alloc->device_addr;
+	alloc->pkt_type = 0;
+	alloc->buf_idx = 0;
 
 	return rc;
 fail_smem_alloc:

msm/eva/cvp_hfi_api.h

@@ -234,11 +234,14 @@ struct cvp_hal_cmd_sys_get_property_packet {
 #define call_hfi_op(q, op, args...)			\
 	(((q) && (q)->op) ? ((q)->op(args)) : 0)
 
+#define PKT_NAME_LEN 32
+
 struct msm_cvp_hfi_defs {
 	unsigned int size;
 	unsigned int type;
 	bool is_config_pkt;
 	enum hal_command_response resp;
+	char name[PKT_NAME_LEN];
 };
 
 struct cvp_hfi_device {

msm/eva/msm_cvp.c

@@ -187,6 +187,10 @@ static int msm_cvp_session_process_hfi(
 		is_config_pkt = cvp_hfi_defs[pkt_idx].is_config_pkt;
 	}
 
+	if (is_config_pkt)
+		pr_info(CVP_DBG_TAG "inst %pK config %s\n", "sess",
+			inst, cvp_hfi_defs[pkt_idx].name);
+
 	if (signal == HAL_NO_RESP) {
 		/* Frame packets are not allowed before session starts*/
 		sq = &inst->session_queue;
@@ -655,6 +659,7 @@ static int msm_cvp_session_process_hfi_fence(struct msm_cvp_inst *inst,
 	struct cvp_fence_queue *q;
 	u32 *fence;
 	enum op_mode mode;
+	bool is_config_pkt;
 
 	if (!inst || !inst->core || !arg || !inst->core->device) {
 		dprintk(CVP_ERR, "%s: invalid params\n", __func__);
@@ -689,6 +694,8 @@ static int msm_cvp_session_process_hfi_fence(struct msm_cvp_inst *inst,
 		dprintk(CVP_ERR, "%s incorrect packet %d %#x\n", __func__,
 				pkt->size, pkt->packet_type);
 		goto exit;
+	} else {
+		is_config_pkt = cvp_hfi_defs[idx].is_config_pkt;
 	}
 
 	if (in_offset && in_buf_num) {
@@ -700,6 +707,11 @@ static int msm_cvp_session_process_hfi_fence(struct msm_cvp_inst *inst,
 		dprintk(CVP_ERR, "Incorrect buf num and offset in cmd\n");
 		goto exit;
 	}
+
+	if (is_config_pkt)
+		pr_info(CVP_DBG_TAG "inst %pK config %s\n",
+			inst, cvp_hfi_defs[idx].name);
+
 	rc = msm_cvp_map_frame(inst, (struct eva_kmd_hfi_packet *)pkt, offset,
 				buf_num);
 	if (rc)
@@ -1197,8 +1209,8 @@ static int msm_cvp_session_stop(struct msm_cvp_inst *inst,
 	}
 	sq->state = QUEUE_STOP;
 
-	pr_info_ratelimited(CVP_DBG_TAG "Stop session: %pK session_id = %d\n",
+	dprintk(CVP_SESS, "Stop session: %pK session_id = %d\n",
-		"sess", inst, hash32_ptr(inst->session));
+			inst, hash32_ptr(inst->session));
 	spin_unlock(&sq->lock);
 
 	wake_up_all(&inst->session_queue.wq);

msm/eva/msm_cvp_buf.c

@@ -39,6 +39,10 @@ static int _wncc_unmap_metadata_bufs(struct eva_kmd_hfi_packet* in_pkt,
 int print_smem(u32 tag, const char *str, struct msm_cvp_inst *inst,
 		struct msm_cvp_smem *smem)
 {
+	int i;
+	char name[PKT_NAME_LEN] = "Unknown";
+
+
 	if (!(tag & msm_cvp_debug))
 		return 0;
 
@@ -49,11 +53,21 @@ int print_smem(u32 tag, const char *str, struct msm_cvp_inst *inst,
 	}
 
 	if (smem->dma_buf) {
+		if (!atomic_read(&smem->refcount))
+			return 0;
+
+		for (i = 0; i < get_pkt_array_size(); i++)
+			if (cvp_hfi_defs[i].type == smem->pkt_type) {
+				strlcpy(name, cvp_hfi_defs[i].name, PKT_NAME_LEN);
+				break;
+			}
+
 		dprintk(tag,
-			"%s: %x : %s size %d flags %#x iova %#x idx %d ref %d",
+			"%s: %x : %s size %d flags %#x iova %#x idx %d ref %d pkt_type %s buf_idx %#x",
 			str, hash32_ptr(inst->session), smem->dma_buf->name,
 			smem->size, smem->flags, smem->device_addr,
-			smem->bitmap_index, smem->refcount);
+			smem->bitmap_index, atomic_read(&smem->refcount),
+			name, smem->buf_idx);
 	}
 	return 0;
 }
@@ -81,8 +95,11 @@ static void print_internal_buffer(u32 tag, const char *str,
 void print_cvp_buffer(u32 tag, const char *str, struct msm_cvp_inst *inst,
 		struct cvp_internal_buf *cbuf)
 {
-	dprintk(tag, "%s addr: %x size %u\n", str,
+	if (!inst || !cbuf)
-			cbuf->smem->device_addr, cbuf->size);
+		dprintk(CVP_ERR,
+			"%s Invalid params inst %pK, cbuf %pK\n", inst, cbuf);
+
+	print_smem(tag, str, inst, cbuf->smem);
 }
 
 static void _log_smem(struct inst_snapshot *snapshot, struct msm_cvp_inst *inst,
@@ -102,6 +119,8 @@ static void _log_smem(struct inst_snapshot *snapshot, struct msm_cvp_inst *inst,
 		s->device_addr = smem->device_addr;
 		s->bitmap_index = smem->bitmap_index;
 		s->refcount = atomic_read(&smem->refcount);
+		s->pkt_type = smem->pkt_type;
+		s->buf_idx = smem->buf_idx;
 	}
 }
 
@@ -282,6 +301,8 @@ int msm_cvp_map_buf_dsp(struct msm_cvp_inst *inst, struct eva_kmd_buffer *buf)
 
 	smem->dma_buf = dma_buf;
 	smem->bitmap_index = MAX_DMABUF_NUMS;
+	smem->pkt_type = 0;
+	smem->buf_idx = 0;
 	dprintk(CVP_MEM, "%s: dma_buf = %llx\n", __func__, dma_buf);
 	rc = msm_cvp_map_smem(inst, smem, "map dsp");
 	if (rc) {
@@ -439,6 +460,8 @@ int msm_cvp_map_buf_wncc(struct msm_cvp_inst *inst,
 
 	smem->dma_buf = dma_buf;
 	smem->bitmap_index = MAX_DMABUF_NUMS;
+	smem->pkt_type = 0;
+	smem->buf_idx = 0;
 	dprintk(CVP_MEM, "%s: dma_buf = %llx", __func__, dma_buf);
 	rc = msm_cvp_map_smem(inst, smem, "map wncc");
 	if (rc) {
@@ -1183,7 +1206,8 @@ exit:
 }
 
 static u32 msm_cvp_map_user_persist_buf(struct msm_cvp_inst *inst,
-				struct cvp_buf_type *buf)
+				struct cvp_buf_type *buf,
+				u32 pkt_type, u32 buf_idx)
 {
 	u32 iova = 0;
 	struct msm_cvp_smem *smem = NULL;
@@ -1203,6 +1227,8 @@ static u32 msm_cvp_map_user_persist_buf(struct msm_cvp_inst *inst,
 		goto exit;
 
 	smem->flags |= SMEM_PERSIST;
+	smem->pkt_type = pkt_type;
+	smem->buf_idx = buf_idx;
 	pbuf->smem = smem;
 	pbuf->fd = buf->fd;
 	pbuf->size = buf->size;
@@ -1226,7 +1252,8 @@ exit:
 
 u32 msm_cvp_map_frame_buf(struct msm_cvp_inst *inst,
 			struct cvp_buf_type *buf,
-			struct msm_cvp_frame *frame)
+			struct msm_cvp_frame *frame,
+			u32 pkt_type, u32 buf_idx)
 {
 	u32 iova = 0;
 	struct msm_cvp_smem *smem = NULL;
@@ -1248,6 +1275,9 @@ u32 msm_cvp_map_frame_buf(struct msm_cvp_inst *inst,
 	if (!smem)
 		return 0;
 
+	smem->pkt_type = pkt_type;
+	smem->buf_idx = buf_idx;
+
 	frame->bufs[nr].fd = buf->fd;
 	frame->bufs[nr].smem = smem;
 	frame->bufs[nr].size = buf->size;
@@ -1284,6 +1314,7 @@ static void msm_cvp_unmap_frame_buf(struct msm_cvp_inst *inst,
 			/* smem not in dmamap cache */
 			msm_cvp_unmap_smem(inst, smem, "unmap cpu");
 			dma_heap_buffer_free(smem->dma_buf);
+			smem->pkt_type = smem->buf_idx = 0;
 			kmem_cache_free(cvp_driver->smem_cache, smem);
 			buf->smem = NULL;
 		} else {
@@ -1292,6 +1323,7 @@ static void msm_cvp_unmap_frame_buf(struct msm_cvp_inst *inst,
 				CLEAR_USE_BITMAP(smem->bitmap_index, inst);
 				print_smem(CVP_MEM, "Map dereference",
 					inst, smem);
+				smem->pkt_type = smem->buf_idx = 0;
 			}
 			mutex_unlock(&inst->dma_cache.lock);
 		}
@@ -1362,16 +1394,19 @@ int msm_cvp_unmap_user_persist(struct msm_cvp_inst *inst,
 				msm_cvp_unmap_smem(inst, smem,
 						"unmap cpu");
 				dma_heap_buffer_free(smem->dma_buf);
+				smem->pkt_type = smem->buf_idx = 0;
 				kmem_cache_free(
 					cvp_driver->smem_cache,
 					smem);
 				pbuf->smem = NULL;
 			} else {
 				mutex_lock(&inst->dma_cache.lock);
-				if (atomic_dec_and_test(&smem->refcount))
+				if (atomic_dec_and_test(&smem->refcount)) {
 					CLEAR_USE_BITMAP(
 						smem->bitmap_index,
 						inst);
+					smem->pkt_type = smem->buf_idx = 0;
+				}
 				mutex_unlock(&inst->dma_cache.lock);
 			}
 
@@ -1436,12 +1471,14 @@ int msm_cvp_map_user_persist(struct msm_cvp_inst *inst,
 			unsigned int offset, unsigned int buf_num)
 {
 	struct cvp_buf_type *buf;
+	struct cvp_hfi_cmd_session_hdr *cmd_hdr;
 	int i;
 	u32 iova;
 
 	if (!offset || !buf_num)
 		return 0;
 
+	cmd_hdr = (struct cvp_hfi_cmd_session_hdr *)in_pkt;
 	for (i = 0; i < buf_num; i++) {
 		buf = (struct cvp_buf_type *)&in_pkt->pkt_data[offset];
 		offset += sizeof(*buf) >> 2;
@@ -1449,7 +1486,7 @@ int msm_cvp_map_user_persist(struct msm_cvp_inst *inst,
 		if (buf->fd < 0 || !buf->size)
 			continue;
 
-		iova = msm_cvp_map_user_persist_buf(inst, buf);
+		iova = msm_cvp_map_user_persist_buf(inst, buf, cmd_hdr->packet_type, i);
 		if (!iova) {
 			dprintk(CVP_ERR,
 				"%s: buf %d register failed.\n",
@@ -1496,7 +1533,7 @@ int msm_cvp_map_frame(struct msm_cvp_inst *inst,
 		if (buf->fd < 0 || !buf->size)
 			continue;
 
-		iova = msm_cvp_map_frame_buf(inst, buf, frame);
+		iova = msm_cvp_map_frame_buf(inst, buf, frame, cmd_hdr->packet_type, i);
 		if (!iova) {
 			dprintk(CVP_ERR,
 				"%s: buf %d register failed.\n",
@@ -1690,7 +1727,9 @@ struct cvp_internal_buf *cvp_allocate_arp_bufs(struct msm_cvp_inst *inst,
 		dprintk(CVP_ERR, "Failed to allocate ARP memory\n");
 		goto err_no_mem;
 	}
+	buf->smem->pkt_type = buf->smem->buf_idx = 0;
 
+	buf->smem->pkt_type = buf->smem->buf_idx = 0;
 	buf->size = buf->smem->size;
 	buf->type = HFI_BUFFER_INTERNAL_PERSIST_1;
 	buf->ownership = DRIVER;
@@ -1826,6 +1865,7 @@ int cvp_allocate_dsp_bufs(struct msm_cvp_inst *inst,
 		dprintk(CVP_ERR, "Failed to allocate ARP memory\n");
 		goto err_no_mem;
 	}
+	buf->smem->pkt_type = buf->smem->buf_idx = 0;
 
 	dprintk(CVP_MEM, "%s dma_buf %pK\n", __func__, buf->smem->dma_buf);
 

msm/eva/msm_cvp_buf.h

@@ -72,6 +72,8 @@ struct msm_cvp_smem {
 	u32 size;
 	u32 bitmap_index;
 	u32 flags;
+	u32 pkt_type;
+	u32 buf_idx;
 	struct cvp_dma_mapping_info mapping_info;
 };
 
@@ -98,6 +100,8 @@ static inline void INIT_DMAMAP_CACHE(struct cvp_dmamap_cache *cache)
 static inline void DEINIT_DMAMAP_CACHE(struct cvp_dmamap_cache *cache)
 {
 	mutex_destroy(&cache->lock);
+	cache->usage_bitmap = 0;
+	cache->nr = 0;
 }
 
 struct cvp_buf_type {
@@ -200,7 +204,8 @@ void msm_cvp_cache_operations(struct msm_cvp_smem *smem,
 			u32 type, u32 offset, u32 size);
 u32 msm_cvp_map_frame_buf(struct msm_cvp_inst *inst,
 			struct cvp_buf_type *buf,
-			struct msm_cvp_frame *frame);
+			struct msm_cvp_frame *frame,
+			u32 pkt_type, u32 buf_idx);
 int msm_cvp_mark_user_persist(struct msm_cvp_inst *inst,
 			struct eva_kmd_hfi_packet *in_pkt,
 			unsigned int offset, unsigned int buf_num);

msm/eva/msm_cvp_common.c

@@ -625,10 +625,7 @@ static void handle_sys_error(enum hal_command_response cmd, void *data)
 	}
 	call_hfi_op(hdev, flush_debug_queue, hdev->hfi_device_data);
 	list_for_each_entry(inst, &core->instances, list) {
-		dprintk(CVP_WARN,
+		cvp_print_inst(CVP_WARN, inst);
-			"%s: sys error inst %#x kref %x, state %x\n",
-				__func__, inst, kref_read(&inst->kref),
-				inst->state);
 		if (inst->state != MSM_CVP_CORE_INVALID) {
 			change_cvp_inst_state(inst, MSM_CVP_CORE_INVALID);
 			if (cvp_clean_session_queues(inst))
@@ -642,8 +639,10 @@ static void handle_sys_error(enum hal_command_response cmd, void *data)
 			wake_up_all(&inst->event_handler.wq);
 		}
 
-		if (!core->trigger_ssr)
+		if (!core->trigger_ssr) {
+			cvp_print_inst(CVP_WARN, inst);
 			msm_cvp_print_inst_bufs(inst, false);
+		}
 	}
 
 	/* handle the hw error before core released to get full debug info */
@@ -1554,3 +1553,18 @@ bool is_cvp_inst_valid(struct msm_cvp_inst *inst)
 	return false;
 }
 
+int cvp_print_inst(u32 tag, struct msm_cvp_inst *inst)
+{
+	if (!inst) {
+		dprintk(CVP_ERR, "%s invalid inst %pK\n", __func__, inst);
+		return -EINVAL;
+	}
+
+	dprintk(tag, "inst %pK id = %#x type %#x prio %#x secure %#x kmask %#x dmask %#x, kref %#x state %#x\n",
+		inst, hash32_ptr(inst->session),
+		inst->prop.type, inst->prop.priority, inst->prop.is_secure,
+		inst, inst->prop.kernel_mask, inst->prop.dsp_mask,
+		kref_read(&inst->kref), inst->state);
+
+	return 0;
+}

msm/eva/msm_cvp_common.h

@@ -31,4 +31,5 @@ int wait_for_sess_signal_receipt(struct msm_cvp_inst *inst,
 int cvp_comm_set_arp_buffers(struct msm_cvp_inst *inst);
 int cvp_comm_release_persist_buffers(struct msm_cvp_inst *inst);
 int msm_cvp_noc_error_info(struct msm_cvp_core *core);
+int cvp_print_inst(u32 tag, struct msm_cvp_inst *inst);
 #endif

msm/eva/msm_cvp_core.c

@@ -154,8 +154,7 @@ void *msm_cvp_open(int core_id, int session_type)
 		dprintk(CVP_ERR, "Instance num reached Max, rejecting session");
 		mutex_lock(&core->lock);
 		list_for_each_entry(inst, &core->instances, list)
-			dprintk(CVP_ERR, "inst %pK, id %d\n",
+			cvp_print_inst(CVP_ERR, inst);
-				inst, hash32_ptr(inst->session));
 		mutex_unlock(&core->lock);
 
 		return NULL;

msm/eva/msm_cvp_dsp.c

@@ -1119,8 +1119,8 @@ static int eva_fastrpc_driver_register(uint32_t handle)
 		if (!wait_for_completion_timeout(
 				&frpc_node->fastrpc_probe_completion,
 				msecs_to_jiffies(CVP_DSP_RESPONSE_TIMEOUT))) {
-			dprintk(CVP_ERR, "%s fastrpc driver_register timeout\n",
+			dprintk(CVP_ERR, "%s fastrpc driver_register timeout %#x\n",
-				__func__);
+				__func__, frpc_node->handle);
 			skip_deregister = false;
 			goto fail_fastrpc_driver_register;
 		}

msm/eva/msm_cvp_internal.h

@@ -287,6 +287,8 @@ struct smem_data {
 	u32 device_addr;
 	u32 bitmap_index;
 	u32 refcount;
+	u32 pkt_type;
+	u32 buf_idx;
 };
 
 struct cvp_buf_data {

msm/eva/msm_cvp_platform.c

@@ -270,248 +270,291 @@ static const struct of_device_id msm_cvp_dt_match[] = {
 	{},
 };
 
+/*
+ * WARN: name field can not hold more than 31 chars
+ *
+ */
 const struct msm_cvp_hfi_defs cvp_hfi_defs[] = {
 	{
 		.size = HFI_DFS_CONFIG_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_DFS_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "DFS",
 	},
 	{
 		.size = HFI_DFS_FRAME_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_DFS_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "DFS_FRAME",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_SGM_OF_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "SGM_OF",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_SGM_OF_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "SGM_OF_FRAME",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_WARP_NCC_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "WARP_NCC",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_WARP_NCC_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "WARP_NCC_FRAME",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_WARP_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "WARP",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_WARP_DS_PARAMS,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "WARP_DS_PARAMS",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_WARP_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "WARP_FRAME",
 	},
 	{
 		.size = HFI_DMM_CONFIG_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_DMM_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "DMM",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_DMM_PARAMS,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "DMM_PARAMS",
 	},
 	{
 		.size = HFI_DMM_FRAME_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_DMM_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "DMM_FRAME",
 	},
 	{
 		.size = HFI_PERSIST_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_SET_PERSIST_BUFFERS,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "SET_PERSIST",
 	},
 	{
 		.size = 0xffffffff,
 		.type = HFI_CMD_SESSION_CVP_RELEASE_PERSIST_BUFFERS,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "REL_PERSIST",
 	},
 	{
 		.size = HFI_DS_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_DS,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "DS",
 	},
 	{
 		.size = HFI_OF_CONFIG_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_CV_TME_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "TME",
 	},
 	{
 		.size = HFI_OF_FRAME_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_CV_TME_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "TME_FRAME",
 	},
 	{
 		.size = HFI_ODT_CONFIG_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_CV_ODT_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "ODT",
 	},
 	{
 		.size = HFI_ODT_FRAME_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_CV_ODT_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "ODT_FRAME",
 	},
 	{
 		.size = HFI_OD_CONFIG_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_CV_OD_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "OD",
 	},
 	{
 		.size = HFI_OD_FRAME_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_CV_OD_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "OD_FRAME",
 	},
 	{
 		.size = HFI_NCC_CONFIG_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_NCC_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "NCC",
 	},
 	{
 		.size = HFI_NCC_FRAME_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_NCC_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "NCC_FRAME",
 	},
 	{
 		.size = HFI_ICA_CONFIG_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_ICA_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "ICA",
 	},
 	{
 		.size = HFI_ICA_FRAME_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_ICA_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "ICA_FRAME",
 	},
 	{
 		.size = HFI_HCD_CONFIG_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_HCD_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "HCD",
 	},
 	{
 		.size = HFI_HCD_FRAME_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_HCD_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "HCD_FRAME",
 	},
 	{
 		.size = HFI_DCM_CONFIG_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_DC_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "DC",
 	},
 	{
 		.size = HFI_DCM_FRAME_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_DC_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "DC_FRAME",
 	},
 	{
 		.size = HFI_DCM_CONFIG_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_DCM_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "DCM",
 	},
 	{
 		.size = HFI_DCM_FRAME_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_DCM_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "DCM_FRAME",
 	},
 	{
 		.size = HFI_PYS_HCD_CONFIG_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_PYS_HCD_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "PYS_HCD",
 	},
 	{
 		.size = HFI_PYS_HCD_FRAME_CMD_SIZE,
 		.type = HFI_CMD_SESSION_CVP_PYS_HCD_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "PYS_HCD_FRAME",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_SET_MODEL_BUFFERS,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "SET_MODEL",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_SET_SNAPSHOT_BUFFERS,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "SET_SNAPSHOT",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_RELEASE_SNAPSHOT_BUFFERS,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "REL_SNAPSHOT",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_SET_SNAPSHOT_MODE,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "SNAPSHOT_MODE",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_SNAPSHOT_WRITE_DONE,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "SNAPSHOT_DONE",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_FD_CONFIG,
 		.is_config_pkt = true,
 		.resp = HAL_NO_RESP,
+		.name = "FD",
 	},
 	{
 		.size = 0xFFFFFFFF,
 		.type = HFI_CMD_SESSION_CVP_FD_FRAME,
 		.is_config_pkt = false,
 		.resp = HAL_NO_RESP,
+		.name = "FD_FRAME",
 	},
-
 };
 
 int get_pkt_array_size(void)

msm/eva/msm_cvp_res_parse.c

@@ -971,6 +971,7 @@ int msm_cvp_smmu_fault_handler(struct iommu_domain *domain,
 	mutex_lock(&core->lock);
 	log = (core->log.snapshot_index > 0)? false : true;
 	list_for_each_entry(inst, &core->instances, list) {
+		cvp_print_inst(CVP_ERR, inst);
 		msm_cvp_print_inst_bufs(inst, log);
 	}
 	hdev = core->device->hfi_device_data;