msm: camera: isp: Add support for the new error codes

Add support for more error codes in the kernel code to
report more errors to user.

CRs-Fixed: 3112574
Change-Id: I6eef2bd73d5ff7cac9d0ed95682c76c4438cfa47
Signed-off-by: Jigar Agrawal <[email protected]>

drivers/cam_isp/isp_hw_mgr/cam_ife_hw_mgr.c

@@ -12239,31 +12239,63 @@ static int cam_ife_hw_mgr_handle_csid_error(
 	if (err_type & CAM_ISP_HW_ERROR_CSID_SENSOR_FRAME_DROP)
 		cam_ife_hw_mgr_handle_csid_frame_drop(event_info, ctx);
 
-	if ((err_type & CAM_ISP_HW_ERROR_CSID_FATAL) &&
+	if ((err_type & (CAM_ISP_HW_ERROR_CSID_LANE_FIFO_OVERFLOW |
+		CAM_ISP_HW_ERROR_CSID_PKT_HDR_CORRUPTED |
+		CAM_ISP_HW_ERROR_CSID_MISSING_PKT_HDR_DATA |
+		CAM_ISP_HW_ERROR_CSID_SENSOR_SWITCH_ERROR |
+		CAM_ISP_HW_ERROR_CSID_FATAL |
+		CAM_ISP_HW_ERROR_CSID_UNBOUNDED_FRAME |
+		CAM_ISP_HW_ERROR_CSID_MISSING_EOT |
+		CAM_ISP_HW_ERROR_CSID_PKT_PAYLOAD_CORRUPTED)) &&
 		g_ife_hw_mgr.debug_cfg.enable_csid_recovery) {
 
 		error_event_data.error_type = CAM_ISP_HW_ERROR_CSID_FATAL;
-		error_event_data.error_code = CAM_REQ_MGR_CSID_FATAL_ERROR;
+
+		if (err_type & CAM_ISP_HW_ERROR_CSID_SENSOR_SWITCH_ERROR)
+			error_event_data.error_code |=
+				CAM_REQ_MGR_CSID_ERR_ON_SENSOR_SWITCHING;
+
+		if (err_type & CAM_ISP_HW_ERROR_CSID_LANE_FIFO_OVERFLOW)
+			error_event_data.error_code |= CAM_REQ_MGR_CSID_LANE_FIFO_OVERFLOW_ERROR;
+
+		if (err_type & CAM_ISP_HW_ERROR_CSID_PKT_HDR_CORRUPTED)
+			error_event_data.error_code |= CAM_REQ_MGR_CSID_RX_PKT_HDR_CORRUPTION;
+
+		if (err_type & CAM_ISP_HW_ERROR_CSID_MISSING_PKT_HDR_DATA)
+			error_event_data.error_code |= CAM_REQ_MGR_CSID_MISSING_PKT_HDR_DATA;
+
+		if (err_type & CAM_ISP_HW_ERROR_CSID_FATAL)
+			error_event_data.error_code |= CAM_REQ_MGR_ISP_UNREPORTED_ERROR;
+
+		if (err_type & CAM_ISP_HW_ERROR_CSID_UNBOUNDED_FRAME)
+			error_event_data.error_code |= CAM_REQ_MGR_CSID_UNBOUNDED_FRAME;
+
+		if (err_type & CAM_ISP_HW_ERROR_CSID_MISSING_EOT)
+			error_event_data.error_code |= CAM_REQ_MGR_CSID_MISSING_EOT;
+
+		if (err_type & CAM_ISP_HW_ERROR_CSID_PKT_PAYLOAD_CORRUPTED)
+			error_event_data.error_code |= CAM_REQ_MGR_CSID_RX_PKT_PAYLOAD_CORRUPTION;
+
 		rc = cam_ife_hw_mgr_find_affected_ctx(&error_event_data,
 			event_info->hw_idx, &recovery_data);
 		goto end;
 	}
 
-	if (err_type & (CAM_ISP_HW_ERROR_CSID_FIFO_OVERFLOW |
+	if (err_type & (CAM_ISP_HW_ERROR_CSID_OUTPUT_FIFO_OVERFLOW |
 		CAM_ISP_HW_ERROR_RECOVERY_OVERFLOW |
 		CAM_ISP_HW_ERROR_CSID_FRAME_SIZE)) {
 
 		cam_ife_hw_mgr_notify_overflow(event_info, ctx);
 		error_event_data.error_type = CAM_ISP_HW_ERROR_OVERFLOW;
-		if (err_type & CAM_ISP_HW_ERROR_CSID_FIFO_OVERFLOW)
-			error_event_data.error_code |=
-				CAM_REQ_MGR_CSID_FIFO_OVERFLOW_ERROR;
+		if (err_type & CAM_ISP_HW_ERROR_CSID_OUTPUT_FIFO_OVERFLOW)
+			error_event_data.error_code |= CAM_REQ_MGR_CSID_FIFO_OVERFLOW_ERROR;
+
 		if (err_type & CAM_ISP_HW_ERROR_RECOVERY_OVERFLOW)
-			error_event_data.error_code |=
-				CAM_REQ_MGR_CSID_RECOVERY_OVERFLOW_ERROR;
+			error_event_data.error_code |= CAM_REQ_MGR_CSID_RECOVERY_OVERFLOW_ERROR;
+
 		if (err_type & CAM_ISP_HW_ERROR_CSID_FRAME_SIZE)
-			error_event_data.error_code |=
-				CAM_REQ_MGR_CSID_PIXEL_COUNT_MISMATCH;
+			error_event_data.error_code |= CAM_REQ_MGR_CSID_PIXEL_COUNT_MISMATCH;
+
 		rc = cam_ife_hw_mgr_find_affected_ctx(&error_event_data,
 			event_info->hw_idx, &recovery_data);
 	}

drivers/cam_isp/isp_hw_mgr/include/cam_isp_hw_mgr_intf.h

@@ -108,16 +108,23 @@ enum cam_isp_hw_secondary_event_type {
  *                         ISP hardware event CAM_ISP_HW_EVENT_ERROR
  */
 enum cam_isp_hw_err_type {
-	CAM_ISP_HW_ERROR_NONE = 0x0001,
-	CAM_ISP_HW_ERROR_OVERFLOW = 0x0002,
-	CAM_ISP_HW_ERROR_P2I_ERROR = 0x0004,
-	CAM_ISP_HW_ERROR_VIOLATION = 0x0008,
-	CAM_ISP_HW_ERROR_BUSIF_OVERFLOW = 0x0010,
-	CAM_ISP_HW_ERROR_CSID_FATAL = 0x0020,
-	CAM_ISP_HW_ERROR_CSID_FIFO_OVERFLOW = 0x0040,
-	CAM_ISP_HW_ERROR_RECOVERY_OVERFLOW = 0x0080,
-	CAM_ISP_HW_ERROR_CSID_FRAME_SIZE = 0x0100,
-	CAM_ISP_HW_ERROR_CSID_SENSOR_FRAME_DROP = 0x0200,
+	CAM_ISP_HW_ERROR_NONE                         = 0x00000001,
+	CAM_ISP_HW_ERROR_OVERFLOW                     = 0x00000002,
+	CAM_ISP_HW_ERROR_P2I_ERROR                    = 0x00000004,
+	CAM_ISP_HW_ERROR_VIOLATION                    = 0x00000008,
+	CAM_ISP_HW_ERROR_BUSIF_OVERFLOW               = 0x00000010,
+	CAM_ISP_HW_ERROR_CSID_FATAL                   = 0x00000020,
+	CAM_ISP_HW_ERROR_CSID_OUTPUT_FIFO_OVERFLOW    = 0x00000040,
+	CAM_ISP_HW_ERROR_RECOVERY_OVERFLOW            = 0x00000080,
+	CAM_ISP_HW_ERROR_CSID_FRAME_SIZE              = 0x00000100,
+	CAM_ISP_HW_ERROR_CSID_LANE_FIFO_OVERFLOW      = 0x00000200,
+	CAM_ISP_HW_ERROR_CSID_PKT_HDR_CORRUPTED       = 0x00000400,
+	CAM_ISP_HW_ERROR_CSID_MISSING_PKT_HDR_DATA    = 0x00000800,
+	CAM_ISP_HW_ERROR_CSID_SENSOR_SWITCH_ERROR     = 0x00001000,
+	CAM_ISP_HW_ERROR_CSID_UNBOUNDED_FRAME         = 0x00002000,
+	CAM_ISP_HW_ERROR_CSID_SENSOR_FRAME_DROP       = 0x00004000,
+	CAM_ISP_HW_ERROR_CSID_MISSING_EOT             = 0x00008000,
+	CAM_ISP_HW_ERROR_CSID_PKT_PAYLOAD_CORRUPTED   = 0x00010000,
 };
 
 /**

drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid480.h

@@ -412,8 +412,8 @@ static struct cam_ife_csid_csi2_rx_reg_info
 	.lane_cfg_shift                  = 4,
 	.phy_type_shift                  = 24,
 	.phy_num_shift                   = 20,
-	.fatal_err_mask                  = 0x497A000,
-	.part_fatal_err_mask             = 0x1081800,
+	.fatal_err_mask                  = 0x59FA800,
+	.part_fatal_err_mask             = 0x0001000,
 	.non_fatal_err_mask              = 0x0200000,
 };
 

drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid680.h

@@ -1085,8 +1085,8 @@ static struct cam_ife_csid_csi2_rx_reg_info
 		.short_pkt_strobe_rst_shift      = 1,
 		.cphy_pkt_strobe_rst_shift       = 2,
 		.unmapped_pkt_strobe_rst_shift   = 3,
-		.fatal_err_mask                  = 0x097A000,
-		.part_fatal_err_mask             = 0x1081800,
+		.fatal_err_mask                  = 0x19FA800,
+		.part_fatal_err_mask             = 0x0001000,
 		.non_fatal_err_mask              = 0x0200000,
 		.top_irq_mask                    = 0x4,
 };

drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid780.h

@@ -254,7 +254,7 @@ static const struct cam_ife_csid_irq_desc cam_ife_csid_780_path_irq_desc[] = {
 static const struct cam_ife_csid_top_irq_desc cam_ife_csid_780_top_irq_desc[] = {
 	{
 		.bitmask  = BIT(1),
-		.err_type = CAM_ISP_HW_ERROR_CSID_FATAL,
+		.err_type = CAM_ISP_HW_ERROR_CSID_SENSOR_SWITCH_ERROR,
 		.err_name = "FATAL_SENSOR_SWITCHING_IRQ",
 		.desc = "Fatal Error duirng dynamically switching between 2 sensors",
 	},
@@ -272,7 +272,7 @@ static const struct cam_ife_csid_top_irq_desc cam_ife_csid_780_top_irq_desc[] =
 	},
 	{
 		.bitmask  = BIT(20),
-		.err_type = CAM_ISP_HW_ERROR_CSID_FIFO_OVERFLOW,
+		.err_type = CAM_ISP_HW_ERROR_CSID_OUTPUT_FIFO_OVERFLOW,
 		.err_name = "ERROR_RDI_LINE_BUFFER_CONFLICT",
 		.desc = "Two or more RDIs programmed to access the shared line buffer",
 		.err_handler = cam_ife_csid_hw_ver2_rdi_line_buffer_conflict_handler,
@@ -1152,8 +1152,8 @@ static struct cam_ife_csid_csi2_rx_reg_info
 		.short_pkt_strobe_rst_shift      = 1,
 		.cphy_pkt_strobe_rst_shift       = 2,
 		.unmapped_pkt_strobe_rst_shift   = 3,
-		.fatal_err_mask                  = 0x097A000,
-		.part_fatal_err_mask             = 0x1081800,
+		.fatal_err_mask                  = 0x19FA800,
+		.part_fatal_err_mask             = 0x0001000,
 		.non_fatal_err_mask              = 0x0200000,
 		.top_irq_mask                    = 0x4,
 };

drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_hw_ver1.c

@@ -3976,37 +3976,48 @@ static int cam_ife_csid_ver1_rx_bottom_half_handler(
 	if (irq_status) {
 		CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len, "Fatal Errors:\n");
 
-		if (irq_status & IFE_CSID_VER1_RX_LANE0_FIFO_OVERFLOW)
+		if (irq_status & IFE_CSID_VER1_RX_LANE0_FIFO_OVERFLOW) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_LANE_FIFO_OVERFLOW;
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
 				"RX_ERROR_LANE0_FIFO_OVERFLOW: Skew/Less Data on lanes/ Slow csid clock:%luHz\n",
 				soc_info->applied_src_clk_rate);
+		}
 
-		if (irq_status & IFE_CSID_VER1_RX_LANE1_FIFO_OVERFLOW)
+		if (irq_status & IFE_CSID_VER1_RX_LANE1_FIFO_OVERFLOW) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_LANE_FIFO_OVERFLOW;
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
 				"RX_ERROR_LANE1_FIFO_OVERFLOW: Skew/Less Data on lanes/ Slow csid clock:%luHz\n",
 				soc_info->applied_src_clk_rate);
+		}
 
-		if (irq_status & IFE_CSID_VER1_RX_LANE2_FIFO_OVERFLOW)
+		if (irq_status & IFE_CSID_VER1_RX_LANE2_FIFO_OVERFLOW) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_LANE_FIFO_OVERFLOW;
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
 				"RX_ERROR_LANE2_FIFO_OVERFLOW: Skew/Less Data on lanes/ Slow csid clock:%luHz\n",
 				soc_info->applied_src_clk_rate);
+		}
 
-		if (irq_status & IFE_CSID_VER1_RX_LANE3_FIFO_OVERFLOW)
+		if (irq_status & IFE_CSID_VER1_RX_LANE3_FIFO_OVERFLOW) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_LANE_FIFO_OVERFLOW;
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
 				"RX_ERROR_LANE3_FIFO_OVERFLOW: Skew/Less Data on lanes/ Slow csid clock:%luHz\n",
 				soc_info->applied_src_clk_rate);
+		}
 
 		if (irq_status & IFE_CSID_VER1_RX_TG_FIFO_OVERFLOW) {
-			event_type |= CAM_ISP_HW_ERROR_CSID_FIFO_OVERFLOW;
+			event_type |= CAM_ISP_HW_ERROR_CSID_OUTPUT_FIFO_OVERFLOW;
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
 				"RX_ERROR_TPG_FIFO_OVERFLOW: Backpressure from IFE\n");
 		}
 
-		if (irq_status & IFE_CSID_VER1_RX_CPHY_PH_CRC)
+		if (irq_status & IFE_CSID_VER1_RX_CPHY_PH_CRC) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_PKT_HDR_CORRUPTED;
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
 				"CPHY_PH_CRC: Pkt Hdr CRC mismatch\n");
+		}
 
 		if (irq_status & IFE_CSID_VER1_RX_STREAM_UNDERFLOW) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_MISSING_PKT_HDR_DATA;
 			val = cam_io_r_mb(soc_info->reg_map[0].mem_base +
 				csi2_reg->captured_long_pkt_0_addr);
 
@@ -4015,36 +4026,45 @@ static int cam_ife_csid_ver1_rx_bottom_half_handler(
 				val & 0xFFFF);
 		}
 
-		if (irq_status & IFE_CSID_VER1_RX_ERROR_ECC)
+		if (irq_status & IFE_CSID_VER1_RX_ERROR_ECC) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_PKT_HDR_CORRUPTED;
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
 				"DPHY_ERROR_ECC: Pkt hdr errors unrecoverable\n");
-	}
-
-	irq_status = evt_payload->irq_status[CAM_IFE_CSID_IRQ_REG_RX] &
-		csi2_reg->part_fatal_err_mask;
+		}
 
-	if (irq_status) {
-		CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
-			"Recoverable-errors:\n");
+		if (irq_status & IFE_CSID_VER1_RX_UNBOUNDED_FRAME) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_UNBOUNDED_FRAME;
+			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
+				"UNBOUNDED_FRAME: Frame started with EOF or No EOF\n");
+		}
 
-		if (irq_status & IFE_CSID_VER1_RX_CPHY_EOT_RECEPTION)
+		if (irq_status & IFE_CSID_VER1_RX_CPHY_EOT_RECEPTION) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_MISSING_EOT;
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
 				"CPHY_EOT_RECEPTION: No EOT on lane/s, is_EPD: %d, PHY_Type: %s(%u)\n",
 				csid_hw->rx_cfg.epd_supported,
 				(csid_hw->rx_cfg.lane_type) ? "cphy" : "dphy",
 				csid_hw->rx_cfg.lane_type);
+		}
 
-		if (irq_status & IFE_CSID_VER1_RX_CPHY_SOT_RECEPTION)
-			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
-				"CPHY_SOT_RECEPTION: Less SOTs on lane/s\n");
-
-		if (irq_status & IFE_CSID_VER1_RX_ERROR_CRC)
+		if (irq_status & IFE_CSID_VER1_RX_ERROR_CRC) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_PKT_PAYLOAD_CORRUPTED;
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
 				"CPHY_ERROR_CRC: Long pkt payload CRC mismatch\n");
+		}
+	}
+
+	irq_status = evt_payload->irq_status[CAM_IFE_CSID_IRQ_REG_RX] &
+		csi2_reg->part_fatal_err_mask;
+
+	if (irq_status) {
+		CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
+			"Recoverable-errors:\n");
 
-		if (irq_status & IFE_CSID_VER1_RX_UNBOUNDED_FRAME)
+		if (irq_status & IFE_CSID_VER1_RX_CPHY_SOT_RECEPTION) {
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
-				"UNBOUNDED_FRAME: Frame started with EOF or No EOF\n");
+				"CPHY_SOT_RECEPTION: Less SOTs on lane/s\n");
+		}
 	}
 
 	irq_status = evt_payload->irq_status[CAM_IFE_CSID_IRQ_REG_RX] &
@@ -4067,19 +4087,16 @@ static int cam_ife_csid_ver1_rx_bottom_half_handler(
 		CAM_ERR_RATE_LIMIT(CAM_ISP, "CSID[%u] %s",
 			csid_hw->hw_intf->hw_idx, log_buf);
 
-	if (!csid_hw->flags.reset_awaited) {
-		if (csid_hw->flags.fatal_err_detected) {
+	if ((!csid_hw->flags.reset_awaited) && csid_hw->flags.fatal_err_detected) {
+		if (!event_type)
 			event_type |= CAM_ISP_HW_ERROR_CSID_FATAL;
-			cam_subdev_notify_message(CAM_CSIPHY_DEVICE_TYPE,
-					CAM_SUBDEV_MESSAGE_IRQ_ERR,
-					(void *)&data_idx);
-		}
 
-		if (event_type) {
-			cam_ife_csid_ver1_handle_event_err(csid_hw,
-				evt_payload, event_type);
-			csid_hw->flags.reset_awaited = true;
-		}
+		cam_subdev_notify_message(CAM_CSIPHY_DEVICE_TYPE,
+				CAM_SUBDEV_MESSAGE_IRQ_ERR,
+				(void *)&data_idx);
+
+		cam_ife_csid_ver1_handle_event_err(csid_hw, evt_payload, event_type);
+		csid_hw->flags.reset_awaited = true;
 	}
 
 	return IRQ_HANDLED;
@@ -4128,7 +4145,7 @@ static int cam_ife_csid_ver1_path_bottom_half_handler(
 	if (evt_payload->irq_status[index] &
 		IFE_CSID_VER1_PATH_ERROR_FIFO_OVERFLOW)
 		cam_ife_csid_ver1_handle_event_err(csid_hw,
-			evt_payload, CAM_ISP_HW_ERROR_CSID_FIFO_OVERFLOW);
+			evt_payload, CAM_ISP_HW_ERROR_CSID_OUTPUT_FIFO_OVERFLOW);
 
 	return 0;
 }
@@ -4262,18 +4279,9 @@ static int cam_ife_csid_ver1_rx_top_half(
 	}
 
 	if (status & csi2_reg->part_fatal_err_mask) {
-		if (status & IFE_CSID_VER1_RX_CPHY_EOT_RECEPTION)
-			csid_hw->counters.error_irq_count++;
-
 		if (status & IFE_CSID_VER1_RX_CPHY_SOT_RECEPTION)
 			csid_hw->counters.error_irq_count++;
 
-		if (status & IFE_CSID_VER1_RX_ERROR_CRC)
-			csid_hw->counters.error_irq_count++;
-
-		if (status & IFE_CSID_VER1_RX_UNBOUNDED_FRAME)
-			csid_hw->counters.error_irq_count++;
-
 		CAM_DBG(CAM_ISP, "CSID[%u] Recoverable Error Count:%u",
 			csid_hw->hw_intf->hw_idx,
 			csid_hw->counters.error_irq_count);

drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_hw_ver2.c

@@ -730,16 +730,18 @@ static int cam_ife_csid_ver2_rx_err_top_half(
 		return -ENODEV;
 	}
 
-	if (csid_hw->rx_cfg.epd_supported &&
-		(th_payload->evt_status_arr[CAM_IFE_CSID_IRQ_REG_RX] ==
-			IFE_CSID_VER2_RX_CPHY_EOT_RECEPTION)) {
-		CAM_DBG(CAM_ISP, "CSID[%u] Rcvd Only ERROR_EOT for EPD sensor",
-			csid_hw->hw_intf->hw_idx);
-		return -ENODEV;
-	}
-
 	status = th_payload->evt_status_arr[CAM_IFE_CSID_IRQ_REG_RX];
 
+	if (csid_hw->rx_cfg.epd_supported) {
+		if (status == IFE_CSID_VER2_RX_CPHY_EOT_RECEPTION) {
+			CAM_DBG(CAM_ISP, "CSID[%u] Rcvd Only ERROR_EOT for EPD sensor",
+				csid_hw->hw_intf->hw_idx);
+			return -ENODEV;
+		}
+
+		status &= (~IFE_CSID_VER2_RX_CPHY_EOT_RECEPTION);
+	}
+
 	if (status & csi2_reg->fatal_err_mask) {
 		csid_hw->flags.fatal_err_detected = true;
 		cam_ife_csid_ver2_stop_csi2_in_err(csid_hw);
@@ -747,18 +749,9 @@ static int cam_ife_csid_ver2_rx_err_top_half(
 	}
 
 	if (status & csi2_reg->part_fatal_err_mask) {
-		if (status & IFE_CSID_VER2_RX_CPHY_EOT_RECEPTION)
-			csid_hw->counters.error_irq_count++;
-
 		if (status & IFE_CSID_VER2_RX_CPHY_SOT_RECEPTION)
 			csid_hw->counters.error_irq_count++;
 
-		if (status & IFE_CSID_VER2_RX_ERROR_CRC)
-			csid_hw->counters.error_irq_count++;
-
-		if (status & IFE_CSID_VER2_RX_UNBOUNDED_FRAME)
-			csid_hw->counters.error_irq_count++;
-
 		CAM_DBG(CAM_ISP, "CSID[%u] Recoverable Error Count:%u",
 			csid_hw->hw_intf->hw_idx,
 			csid_hw->counters.error_irq_count);
@@ -779,8 +772,7 @@ end:
 				csid_hw->hw_intf->hw_idx, i,
 				th_payload->evt_status_arr[i]);
 	} else {
-		evt_payload->irq_reg_val[CAM_IFE_CSID_IRQ_REG_RX] =
-			th_payload->evt_status_arr[CAM_IFE_CSID_IRQ_REG_RX];
+		evt_payload->irq_reg_val[CAM_IFE_CSID_IRQ_REG_RX] = status;
 		th_payload->evt_payload_priv = evt_payload;
 	}
 	return rc;
@@ -1065,16 +1057,21 @@ static int cam_ife_csid_ver2_rx_err_bottom_half(
 			}
 		}
 
-		if (lane_overflow)
+		if (lane_overflow) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_LANE_FIFO_OVERFLOW;
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
 				"INPUT_FIFO_OVERFLOW [Lanes:%s]: Skew/Less Data on lanes/ Slow csid clock:%luHz",
 				tmp_buf, soc_info->applied_src_clk_rate);
+		}
 
-		if (irq_status & IFE_CSID_VER2_RX_ERROR_CPHY_PH_CRC)
+		if (irq_status & IFE_CSID_VER2_RX_ERROR_CPHY_PH_CRC) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_PKT_HDR_CORRUPTED;
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
 				"CPHY_PH_CRC: Pkt Hdr CRC mismatch");
+		}
 
 		if (irq_status & IFE_CSID_VER2_RX_STREAM_UNDERFLOW) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_MISSING_PKT_HDR_DATA;
 			val = cam_io_r_mb(soc_info->reg_map[0].mem_base +
 				csi2_reg->captured_long_pkt_0_addr);
 
@@ -1083,37 +1080,32 @@ static int cam_ife_csid_ver2_rx_err_bottom_half(
 				val & 0xFFFF);
 		}
 
-		if (irq_status & IFE_CSID_VER2_RX_ERROR_ECC)
+		if (irq_status & IFE_CSID_VER2_RX_ERROR_ECC) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_PKT_HDR_CORRUPTED;
 			CAM_ERR_BUF(CAM_ISP, log_buf,
 				CAM_IFE_CSID_LOG_BUF_LEN, &len,
 				"DPHY_ERROR_ECC: Pkt hdr errors unrecoverable. ECC: 0x%x",
 				cam_io_r_mb(soc_info->reg_map[0].mem_base +
 					csi2_reg->captured_long_pkt_1_addr));
+		}
 
-		CAM_ERR(CAM_ISP, "Fatal Errors: %s", log_buf);
-
-		rx_irq_status |= irq_status;
-		csid_hw->flags.fatal_err_detected = true;
-	}
-
-	irq_status = payload->irq_reg_val[CAM_IFE_CSID_IRQ_REG_RX] &
-		csi2_reg->part_fatal_err_mask;
-
-	if (irq_status) {
-		len = 0;
+		if (irq_status & IFE_CSID_VER2_RX_UNBOUNDED_FRAME) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_UNBOUNDED_FRAME;
+			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
+				"UNBOUNDED_FRAME: Frame started with EOF or No EOF");
+		}
 
-		if (irq_status & IFE_CSID_VER2_RX_CPHY_EOT_RECEPTION)
+		if (irq_status & IFE_CSID_VER2_RX_CPHY_EOT_RECEPTION) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_MISSING_EOT;
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
 				"CPHY_EOT_RECEPTION: No EOT on lane/s, is_EPD: %c, PHY_Type: %s(%u)",
 				(csid_hw->rx_cfg.epd_supported & CAM_ISP_EPD_SUPPORT) ? 'Y' : 'N',
 				(csid_hw->rx_cfg.lane_type) ? "cphy" : "dphy",
 				csid_hw->rx_cfg.lane_type);
-
-		if (irq_status & IFE_CSID_VER2_RX_CPHY_SOT_RECEPTION)
-			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
-				"CPHY_SOT_RECEPTION: Less SOTs on lane/s");
+		}
 
 		if (irq_status & IFE_CSID_VER2_RX_ERROR_CRC) {
+			event_type |= CAM_ISP_HW_ERROR_CSID_PKT_PAYLOAD_CORRUPTED;
 			long_pkt_ftr_val = cam_io_r_mb(
 				soc_info->reg_map[0].mem_base +
 				csi2_reg->captured_long_pkt_ftr_addr);
@@ -1141,9 +1133,21 @@ static int cam_ife_csid_ver2_rx_err_bottom_half(
 			}
 		}
 
-		if (irq_status & IFE_CSID_VER2_RX_UNBOUNDED_FRAME)
+		CAM_ERR(CAM_ISP, "Fatal Errors: %s", log_buf);
+
+		rx_irq_status |= irq_status;
+		csid_hw->flags.fatal_err_detected = true;
+	}
+
+	irq_status = payload->irq_reg_val[CAM_IFE_CSID_IRQ_REG_RX] &
+		csi2_reg->part_fatal_err_mask;
+
+	if (irq_status) {
+		len = 0;
+		if (irq_status & IFE_CSID_VER2_RX_CPHY_SOT_RECEPTION) {
 			CAM_ERR_BUF(CAM_ISP, log_buf, CAM_IFE_CSID_LOG_BUF_LEN, &len,
-				"UNBOUNDED_FRAME: Frame started with EOF or No EOF");
+				"CPHY_SOT_RECEPTION: Less SOTs on lane/s");
+		}
 
 		CAM_ERR(CAM_ISP, "Recoverable-errors: %s", log_buf);
 		rx_irq_status |= irq_status;
@@ -1154,7 +1158,6 @@ static int cam_ife_csid_ver2_rx_err_bottom_half(
 
 	if (irq_status) {
 		len = 0;
-
 		if (irq_status & IFE_CSID_VER2_RX_MMAPPED_VC_DT) {
 			val = cam_io_r_mb(soc_info->reg_map[0].mem_base +
 				csi2_reg->captured_long_pkt_0_addr);
@@ -1171,19 +1174,15 @@ static int cam_ife_csid_ver2_rx_err_bottom_half(
 		csid_hw->hw_intf->hw_idx,
 		payload->irq_reg_val[CAM_IFE_CSID_IRQ_REG_RX]);
 
-	if (!csid_hw->flags.reset_awaited) {
-		if (csid_hw->flags.fatal_err_detected) {
+	if ((!csid_hw->flags.reset_awaited) && csid_hw->flags.fatal_err_detected) {
+		if (!event_type)
 			event_type |= CAM_ISP_HW_ERROR_CSID_FATAL;
 
-			cam_subdev_notify_message(CAM_CSIPHY_DEVICE_TYPE,
-				CAM_SUBDEV_MESSAGE_IRQ_ERR, (void *)&data_idx);
-		}
-
-		if (event_type) {
-			cam_ife_csid_ver2_handle_event_err(csid_hw,
-				rx_irq_status, event_type, false, NULL);
-			csid_hw->flags.reset_awaited = true;
-		}
+		cam_subdev_notify_message(CAM_CSIPHY_DEVICE_TYPE,
+			CAM_SUBDEV_MESSAGE_IRQ_ERR, (void *)&data_idx);
+		cam_ife_csid_ver2_handle_event_err(csid_hw,
+			rx_irq_status, event_type, false, NULL);
+		csid_hw->flags.reset_awaited = true;
 	}
 unlock:
 	spin_unlock(&csid_hw->lock_state);
@@ -1810,7 +1809,6 @@ static int cam_ife_csid_ver2_rdi_bottom_half(
 
 	spin_unlock(&csid_hw->lock_state);
 	if (err_type) {
-
 		cam_ife_csid_ver2_handle_event_err(csid_hw,
 			irq_status_rdi, err_type, false, res);
 		goto end;

drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_lite480.h

@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
- * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2019-2021, The Linux Foundation. All rights reserved.
  */
 
 #ifndef _CAM_IFE_CSID_LITE_480_H_
@@ -323,9 +323,9 @@ static struct cam_ife_csid_csi2_rx_reg_info
 	.capture_cphy_pkt_dt_shift            = 20,
 	.capture_cphy_pkt_vc_shift            = 26,
 	.phy_num_mask                         = 0x7,
-	.fatal_err_mask                       = 0x78000,
-	.part_fatal_err_mask                  = 0x1801800,
-	.non_fatal_err_mask                   = 0x380000,
+	.fatal_err_mask                       = 0x59FA800,
+	.part_fatal_err_mask                  = 0x0001000,
+	.non_fatal_err_mask                   = 0x0200000,
 	.lane_num_shift                       = 0,
 	.lane_cfg_shift                       = 4,
 	.phy_type_shift                       = 24,

drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_lite680.h

@@ -457,9 +457,9 @@ static struct cam_ife_csid_csi2_rx_reg_info
 		.short_pkt_strobe_rst_shift           = 1,
 		.cphy_pkt_strobe_rst_shift            = 2,
 		.unmapped_pkt_strobe_rst_shift        = 3,
-		.fatal_err_mask                       = 0x78000,
-		.part_fatal_err_mask                  = 0x1801800,
-		.non_fatal_err_mask                   = 0x380000,
+		.fatal_err_mask                       = 0x19FA800,
+		.part_fatal_err_mask                  = 0x0001000,
+		.non_fatal_err_mask                   = 0x0200000,
 };
 
 static struct cam_ife_csid_ver2_path_reg_info

drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw/cam_ife_csid_lite780.h

@@ -249,7 +249,7 @@ static const struct cam_ife_csid_irq_desc cam_ife_csid_lite_780_path_irq_desc[]
 static const struct cam_ife_csid_top_irq_desc cam_ife_csid_lite_780_top_irq_desc[] = {
 	{
 		.bitmask  = BIT(1),
-		.err_type = CAM_ISP_HW_ERROR_CSID_FATAL,
+		.err_type = CAM_ISP_HW_ERROR_CSID_SENSOR_SWITCH_ERROR,
 		.err_name = "FATAL_SENSOR_SWITCHING_IRQ",
 		.desc = "Fatal Error duirng dynamically switching between 2 sensors",
 	},
@@ -267,7 +267,7 @@ static const struct cam_ife_csid_top_irq_desc cam_ife_csid_lite_780_top_irq_desc
 	},
 	{
 		.bitmask  = BIT(20),
-		.err_type = CAM_ISP_HW_ERROR_CSID_FIFO_OVERFLOW,
+		.err_type = CAM_ISP_HW_ERROR_CSID_OUTPUT_FIFO_OVERFLOW,
 		.err_name = "ERROR_RDI_LINE_BUFFER_CONFLICT",
 		.desc = "Two or more RDIs programmed to access the shared line buffer",
 		.err_handler = cam_ife_csid_hw_ver2_rdi_line_buffer_conflict_handler,
@@ -494,9 +494,9 @@ static struct cam_ife_csid_csi2_rx_reg_info
 		.short_pkt_strobe_rst_shift           = 1,
 		.cphy_pkt_strobe_rst_shift            = 2,
 		.unmapped_pkt_strobe_rst_shift        = 3,
-		.fatal_err_mask                       = 0x78000,
-		.part_fatal_err_mask                  = 0x1801800,
-		.non_fatal_err_mask                   = 0x380000,
+		.fatal_err_mask                       = 0x19FA800,
+		.part_fatal_err_mask                  = 0x0001000,
+		.non_fatal_err_mask                   = 0x0200000,
 };
 
 static struct cam_ife_csid_ver2_path_reg_info