acquire & release sensor fixes (#49) (#55) (#5)

* 1).acq & rel sensor fix for HSD 15015753611
2).release_firmware fix for HSD 14022301639
3).vid/pid mismatch fix for HSD 15015491881



* Revert testapp to use external acq/rel.



---------

Signed-off-by: Srinivas Alla <alla.srinivas@intel.com>

Author: asrini4

drivers/misc/icvs/intel_cvs.c

@@ -72,6 +72,9 @@ static void cvs_wdt_reset_thread(struct work_struct *work)
 
 	if (icvs->rst_retry--) {
 		icvs->owner = CVS_CAMERA_NONE;
+		icvs->ref_count = 0;
+		icvs->int_ref_count = 0;
+
 		msleep(RST_TIME);
 		gpiod_set_value_cansleep(icvs->rst, 1);
 		hrtimer_start(&icvs->wdt, ms_to_ktime(WDT_TIMEOUT),
@@ -267,7 +270,6 @@ static void cvs_i2c_remove(struct i2c_client *i2c)
 		dev_info(&i2c->dev, "%s\n", __func__);
 		icvs = i2c_get_clientdata(i2c);
 		if (icvs) {
-			release_firmware(cvs->file);
 			cvs->close_fw_dl_task = true;
 
 			while (cvs->ref_count) {
@@ -328,7 +330,7 @@ int cvs_acquire_camera_sensor_internal(void)
 	if (!cvs)
 		return -EINVAL;
 
-	if (cvs->icvs_state == CV_FW_DOWNLOADING_STATE)
+	if (cvs->icvs_state == CV_FW_DOWNLOADING_STATE || cvs->icvs_state == CV_FW_FLASHING_STATE)
 		return -EBUSY;
 
 	if (cvs->owner != CVS_CAMERA_IPU) {
@@ -341,6 +343,8 @@ int cvs_acquire_camera_sensor_internal(void)
 		if (val != 0)
 			goto err_out;
 	}
+
+	cvs->owner = CVS_CAMERA_IPU;
 	cvs->int_ref_count++;
 	return 0;
 
@@ -359,7 +363,10 @@ int cvs_release_camera_sensor_internal(void)
 	if (cvs->icvs_state == CV_FW_DOWNLOADING_STATE)
 		return -EBUSY;
 
-	if (cvs->owner != CVS_CAMERA_CVS) {
+	if (cvs->int_ref_count == 0)
+		return 0;
+
+	if (cvs->owner != CVS_CAMERA_CVS && cvs->int_ref_count == 1) {
 		do {
 			gpiod_set_value_cansleep(cvs->req, 1);
 			mdelay(GPIO_READ_DELAY_MS);
@@ -369,8 +376,12 @@ int cvs_release_camera_sensor_internal(void)
 		if (val != 1)
 			goto err_out;
 	}
+
 	cvs->int_ref_count--;
+	cvs->owner = (cvs->int_ref_count == 0) ? CVS_CAMERA_CVS :
+		CVS_CAMERA_IPU;
 	return 0;
+
 err_out:
 	dev_err(cvs->dev, "%s:error! val %d (!=1)\n", __func__, val);
 	return -EIO;
@@ -388,10 +399,7 @@ int cvs_acquire_camera_sensor(struct cvs_mipi_config *config,
 	ret = cvs_acquire_camera_sensor_internal();
 	if (!ret) {
 		spin_lock(&cvs->lock);
-		cvs->owner = (cvs->ref_count <= 0) ? CVS_CAMERA_IPU :
-						     cvs->owner;
-		cvs->ref_count = (cvs->ref_count <= 0) ? 1 :
-							 (cvs->ref_count + 1);
+		cvs->ref_count++;
 		spin_unlock(&cvs->lock);
 	}
 	return (ret) ? ret : 0;
@@ -408,33 +416,16 @@ int cvs_release_camera_sensor(struct cvs_camera_status *status)
 	ret = cvs_release_camera_sensor_internal();
 	if (!ret) {
 		spin_lock(&cvs->lock);
-		cvs->ref_count = (cvs->ref_count > 0) ? (cvs->ref_count - 1) :
-							0;
+		cvs->ref_count = (cvs->ref_count > 0) ? (cvs->ref_count - 1) : 0;
 		cvs->owner = (cvs->ref_count == 0) ? CVS_CAMERA_CVS :
-						     cvs->owner;
+					CVS_CAMERA_IPU;
 		spin_unlock(&cvs->lock);
 	}
 	return (ret) ? ret : 0;
 }
 EXPORT_SYMBOL_GPL(cvs_release_camera_sensor);
 
 #ifdef DEBUG_CVS
-int cvs_get_state()
-{
-	if (!cvs)
-		return -EINVAL;
-
-	if (cvs_acquire_camera_sensor_internal())
-		return -EINVAL;
-
-	if (cvs_read_i2c(GET_DEVICE_STATE, (char *)&cvs->cvs_state,
-			 sizeof(char)) <= 0)
-		return -EIO;
-
-	cvs_release_camera_sensor_internal();
-	return 0;
-}
-
 int cvs_exec_cmd(enum cvs_command command)
 {
 	int rc;
@@ -448,20 +439,34 @@ int cvs_exec_cmd(enum cvs_command command)
 
 	switch (command) {
 	case GET_DEVICE_STATE:
+		if(cvs->icvs_state == CV_FW_FLASHING_STATE) {
+			dev_dbg(cvs->dev, "%s: Device Busy. State can't be queried now", __func__);
+			return -EBUSY;
+		}
 		rc = cvs_read_i2c(GET_DEVICE_STATE, (char *)&cvs->cvs_state,
 				  sizeof(char));
 		if (rc <= 0)
 			goto err_out;
 		break;
 
 	case GET_FW_VERSION:
+		if(cvs->icvs_state == CV_FW_DOWNLOADING_STATE || cvs->icvs_state == CV_FW_FLASHING_STATE) {
+			dev_dbg(cvs->dev, "%s: Device Busy. Version can't be queried now", __func__);
+			return -EBUSY;
+		}
+		
 		rc = cvs_read_i2c(GET_FW_VERSION, (char *)&cvs->ver,
 				  sizeof(struct cvs_fw));
 		if (rc <= 0)
 			goto err_out;
 		break;
 
 	case GET_VID_PID:
+		if(cvs->icvs_state == CV_FW_DOWNLOADING_STATE || cvs->icvs_state == CV_FW_FLASHING_STATE) {
+			dev_dbg(cvs->dev, "%s: Device Busy. ID can't be queried now", __func__);
+			return -EBUSY;
+		}
+		
 		rc = cvs_read_i2c(GET_VID_PID, (char *)&cvs->id,
 				  sizeof(struct cvs_id));
 		if (rc <= 0)
@@ -482,7 +487,6 @@ int cvs_exec_cmd(enum cvs_command command)
 	if (cvs->i2c_shared && cvs->icvs_state != CV_FW_DOWNLOADING_STATE)
 		cvs_release_camera_sensor_internal();
 
-
 	pr_err("%s:CVs command 0x%x failed, cvs_read_i2c: %d\n", __func__,
 	       command, rc);
 	return -EIO;
@@ -532,30 +536,27 @@ static ssize_t coredump_show(struct device *dev, struct device_attribute *attr,
 		cvs->ver.hotfix, cvs->ver.build, cvs->ver.major, cvs->ver.minor,
 		cvs->ver.hotfix, cvs->ver.build, cvs->cvs_state, stat_name,
 		cvs->ref_count, cvs->int_ref_count,
-		(cvs->owner == CVS_CAMERA_CVS) ?
-			"CVS" :
-			((cvs->owner == CVS_CAMERA_IPU) ? "IPU" : "none"),
+		((cvs->owner == CVS_CAMERA_NONE) ? "NONE" :
+		(cvs->owner == CVS_CAMERA_CVS)  ? "CVS" :
+		(cvs->owner == CVS_CAMERA_IPU && cvs->ref_count) ? "IPU" : 
+		(cvs->owner == CVS_CAMERA_IPU && cvs->int_ref_count) ? "VDRV" : "UNKNOWN"),
 		cvs->i2c_shared);
 }
 static DEVICE_ATTR_RO(coredump);
 
 static ssize_t cmd_store(struct device *dev, struct device_attribute *attr,
 			 const char *buf, size_t count)
 {
-	if (sysfs_streq(buf, "reset"))
-		schedule_work(&cvs->rst_task);
-	else if (sysfs_streq(buf, "acquire"))
+	if (sysfs_streq(buf, "acquire"))
 		cvs_acquire_camera_sensor(NULL, NULL, NULL, NULL);
 	else if (sysfs_streq(buf, "release"))
 		cvs_release_camera_sensor(NULL);
 	else if (sysfs_streq(buf, "state"))
-		cvs_get_state();
+		cvs_exec_cmd(GET_DEVICE_STATE);
 	else if (sysfs_streq(buf, "version"))
 		cvs_exec_cmd(GET_FW_VERSION);
 	else if (sysfs_streq(buf, "id"))
 		cvs_exec_cmd(GET_VID_PID);
-	else if (sysfs_streq(buf, "update"))
-		pr_err("%s:update not implemented\n", __func__);
 	else
 		pr_err("%s:invalid %s command\n", __func__, buf);
 
@@ -567,7 +568,7 @@ static ssize_t cmd_show(struct device *dev, struct device_attribute *attr,
 {
 	return sysfs_emit(
 		buf, "command: %s\n",
-		"[coredump, reset, acquire, release, state, version, id, update]");
+		"[coredump, acquire, release, state, version, id]");
 }
 static DEVICE_ATTR_RW(cmd);
 
@@ -587,6 +588,7 @@ static int cvs_suspend(struct device *dev)
 	int ret = 0; 
 	u64 timeout;
 
+	dev_info(icvs->dev, "%s entered\n", __func__);
 	/* Wait for FW update complete */
 	if (icvs->cap == ICVS_FULLCAP && cvs->fw_dl_task_finished != true) {	
 		cvs->close_fw_dl_task = true;
@@ -601,6 +603,7 @@ static int cvs_suspend(struct device *dev)
 			ret = -EAGAIN;
 		}
 	}
+
 	if (icvs->cap == ICVS_FULLCAP) {	
 		/* Disable wdt & IRQ */
 		hrtimer_cancel(&icvs->wdt);
@@ -617,6 +620,7 @@ static int cvs_resume(struct device *dev)
 	struct intel_cvs *icvs = i2c_get_clientdata(i2c);
 	int val = -1, retry = FW_MAX_RETRY;
 
+	dev_info(icvs->dev, "%s entered\n", __func__);
 	/* Wait for bridge ready */
 	while (val < 0 && retry--) {
 		val = gpiod_get_value_cansleep(cvs->resp);

drivers/misc/icvs/intel_cvs_update.c

@@ -106,7 +106,7 @@ int cvs_get_dev_state(void)
 	}
 
 	if (ctx->i2c_shared) {
-		if (ctx->icvs_sensor_state != CV_SENSOR_IPU_ACQUIRED_STATE) {
+		if (ctx->icvs_sensor_state == CV_SENSOR_RELEASED_STATE) {
 			if (cvs_acquire_camera_sensor_internal()) {
 				dev_err(cvs->dev, "%s:Acquire sensor fail",__func__);
 				return -EIO;
@@ -293,6 +293,7 @@ int cvs_dev_fw_dl_end(void)
 
 	ctx->icvs_state = CV_FW_FLASHING_STATE;
 	status = cvs_get_device_state(&fw_state);
+	ctx->cv_fw_state = fw_state;
 	return status;
 }
 
@@ -351,6 +352,12 @@ int cvs_dev_fw_dl(void)
 
 	do {
 		status = cvs_wait_for_host_wake(ctx->max_flashtime_ms);
+		if (status) {
+			dev_err(cvs->dev, "%s: FW flash hostwake error",
+				__func__);
+			return -ETIMEDOUT;
+		}
+		ctx->icvs_state = CV_INIT_STATE;
 		status = cvs_get_dev_state();
 	} while ((!ctx->cv_fw_state) ||
 		 (ctx->cv_fw_state & DEVICE_DWNLD_BUSY_MASK));
@@ -434,6 +441,13 @@ static int cvs_fw_parse(void)
 		return -EINVAL;
 	}
 
+	if ((ptr_fw_header->vid_pid.vid != cvs->id.vid) ||
+		(ptr_fw_header->vid_pid.pid != cvs->id.pid)) {
+		dev_err(cvs->dev, "%s:dev & lib vid, pid mismatch",
+			__func__);
+		return -EINVAL;
+	}
+
 	dev_info(cvs->dev, "%s:Lib FW version is %d.%d.%d.%d",
 			__func__, ptr_fw_header->fw_ver.major,
 			ptr_fw_header->fw_ver.minor,
@@ -501,8 +515,8 @@ static bool evaluate_fw(void)
 		devm_kzalloc(cvs->dev, cvs->fw_buffer_size, GFP_KERNEL);
 	if (IS_ERR_OR_NULL(cvs->fw_buffer)) {
 		dev_err(cvs->dev, "%s:No memory for fw_buffer", __func__);
-		status = -ENOMEM;
-		goto err_fw_release;
+		release_firmware(cvs->file);
+		return -ENOMEM;
 	}
 
 	dev_dbg(cvs->dev, "%s:fw_buff:%p size:0x%x, out_buf:%p",
@@ -513,15 +527,9 @@ static bool evaluate_fw(void)
 	wmb(); /* Flush WC buffers after writing fw_buffer */
 
 	status = cvs_fw_parse();
-	if (status) {
+	if (status)
 		dev_err(cvs->dev, "%s: FW bin file is invalid", __func__);
-		goto err_fw_release;
-	}
 
-	return 0;
-
-err_fw_release:
-	dev_err(cvs->dev, "%s:Calling release_firmware()\n", __func__);
 	release_firmware(cvs->file);
 	return status;
 }
@@ -555,7 +563,7 @@ void cvs_fw_dl_thread(struct work_struct *arg)
 	ctx->fw_update_retries = CV_FW_DL_MAX_TRY_DEFAULT;
 
 	if (cvs->i2c_shared &&
-	    ctx->icvs_sensor_state != CV_SENSOR_IPU_ACQUIRED_STATE) {
+		ctx->icvs_sensor_state == CV_SENSOR_RELEASED_STATE) {
 		if (cvs_acquire_camera_sensor_internal())
 			goto err_exit;
 	}
@@ -565,14 +573,15 @@ void cvs_fw_dl_thread(struct work_struct *arg)
 		dev_info(cvs->dev, "%s:Device FW version is %d.%d.%d.%d",
 			__func__, cvs->ver.major, cvs->ver.minor,
 			cvs->ver.hotfix, cvs->ver.build);
+
 		if (evaluate_fw()) {
 			dev_err(cvs->dev, "%s:FW file not found",
 				__func__);
 			goto err_exit;
 		}
 	}
 	else {
-		dev_info(cvs->dev, "%s:I2C error. Not able to read vid/pid",
+		dev_err(cvs->dev, "%s:I2C error. Not able to read vid/pid",
 			__func__);
 		goto err_exit;
 	}
@@ -597,9 +606,8 @@ void cvs_fw_dl_thread(struct work_struct *arg)
 				goto err_exit;
 			}
 
-			if (ctx->icvs_sensor_state !=
-				    CV_SENSOR_IPU_ACQUIRED_STATE &&
-			    ctx->i2c_shared) {
+			if (ctx->icvs_sensor_state == CV_SENSOR_RELEASED_STATE &&
+					ctx->i2c_shared) {
 				status = cvs_acquire_camera_sensor_internal();
 				if (status) {
 					dev_err(cvs->dev,

include/linux/intel_cvs.h

@@ -201,7 +201,6 @@ int cvs_release_camera_sensor(struct cvs_camera_status *status);
 #ifdef DEBUG_CVS
 int cvs_sysfs_dump(char *buf);
 int cvs_exec_cmd(enum cvs_command command);
-int cvs_get_state(void);
 #endif
 
 #endif // __INTEL_CVS_H__