From ba4792aae1b9395cf4b68ec22aecc6d4c7b9b8c9 Mon Sep 17 00:00:00 2001
From: Amir Vajid <avajid@codeaurora.org>
Date: Wed, 12 Feb 2020 15:44:59 -0800
Subject: [PATCH] PM / devfreq: Remove dependencies between sysfs nodes and
 suspend count

This change reverts commit 5e33579a6a9c ("devfreq: Do not allow tunable
updates when device is suspended") and commit db4f4a0933ce ("PM/devfreq:
Do not switch governors from sysfs when device is suspended").

Userspace updates to sysfs nodes like governor and polling_interval are
currently not allowed when there is a non-zero suspend count. This
requirement existed in the past due to hardware dependencies in some
devfreq drivers. However, these hardware dependencies should be handled
by the relevant devfreq drivers rather than the devfreq framework so
remove the suspend count checks in these devfreq framework sysfs APIs.

Change-Id: I8010b519d72784a6b90955acc7899c1a520aa7e7
Signed-off-by: Amir Vajid <avajid@codeaurora.org>
---
 drivers/devfreq/devfreq.c | 52 +++++++++++++--------------------------
 1 file changed, 17 insertions(+), 35 deletions(-)

diff --git a/drivers/devfreq/devfreq.c b/drivers/devfreq/devfreq.c
index 1503f22b6fe8..46f0eb1f88a9 100644
--- a/drivers/devfreq/devfreq.c
+++ b/drivers/devfreq/devfreq.c
@@ -888,31 +888,30 @@ EXPORT_SYMBOL(devm_devfreq_remove_device);
  */
 int devfreq_suspend_device(struct devfreq *devfreq)
 {
-	int ret = 0;
+	int ret;
 
 	if (!devfreq)
 		return -EINVAL;
 
-	event_mutex_lock(devfreq);
 	if (atomic_inc_return(&devfreq->suspend_count) > 1)
-		goto unlock_out;
+		return 0;
 
 	if (devfreq->governor) {
+		event_mutex_lock(devfreq);
 		ret = devfreq->governor->event_handler(devfreq,
 					DEVFREQ_GOV_SUSPEND, NULL);
+		event_mutex_unlock(devfreq);
 		if (ret)
-			goto unlock_out;
+			return ret;
 	}
 
 	if (devfreq->suspend_freq) {
 		ret = devfreq_set_target(devfreq, devfreq->suspend_freq, 0);
 		if (ret)
-			goto unlock_out;
+			return ret;
 	}
 
-unlock_out:
-	event_mutex_unlock(devfreq);
-	return ret;
+	return 0;
 }
 EXPORT_SYMBOL(devfreq_suspend_device);
 
@@ -926,31 +925,30 @@ EXPORT_SYMBOL(devfreq_suspend_device);
  */
 int devfreq_resume_device(struct devfreq *devfreq)
 {
-	int ret = 0;
+	int ret;
 
 	if (!devfreq)
 		return -EINVAL;
 
-	event_mutex_lock(devfreq);
 	if (atomic_dec_return(&devfreq->suspend_count) >= 1)
-		goto unlock_out;
+		return 0;
 
 	if (devfreq->resume_freq) {
 		ret = devfreq_set_target(devfreq, devfreq->resume_freq, 0);
 		if (ret)
-			goto unlock_out;
+			return ret;
 	}
 
 	if (devfreq->governor) {
+		event_mutex_lock(devfreq);
 		ret = devfreq->governor->event_handler(devfreq,
 					DEVFREQ_GOV_RESUME, NULL);
+		event_mutex_unlock(devfreq);
 		if (ret)
-			goto unlock_out;
+			return ret;
 	}
 
-unlock_out:
-	event_mutex_unlock(devfreq);
-	return ret;
+	return 0;
 }
 EXPORT_SYMBOL(devfreq_resume_device);
 
@@ -1155,10 +1153,6 @@ static ssize_t governor_store(struct device *dev, struct device_attribute *attr,
 	}
 
 	event_mutex_lock(df);
-	if (atomic_read(&df->suspend_count) > 0) {
-		ret = -EINVAL;
-		goto gov_stop_out;
-	}
 	if (df->governor) {
 		ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL);
 		if (ret) {
@@ -1275,16 +1269,14 @@ static ssize_t polling_interval_store(struct device *dev,
 	unsigned int value;
 	int ret;
 
+	if (!df->governor)
+		return -EINVAL;
+
 	ret = sscanf(buf, "%u", &value);
 	if (ret != 1)
 		return -EINVAL;
 
 	event_mutex_lock(df);
-	if (!df->governor || atomic_read(&df->suspend_count) > 0) {
-		dev_warn(dev, "device suspended, operation not allowed\n");
-		event_mutex_unlock(df);
-		return -EINVAL;
-	}
 	df->governor->event_handler(df, DEVFREQ_GOV_INTERVAL, &value);
 	ret = count;
 	event_mutex_unlock(df);
@@ -1305,11 +1297,6 @@ static ssize_t min_freq_store(struct device *dev, struct device_attribute *attr,
 		return -EINVAL;
 
 	event_mutex_lock(df);
-	if (atomic_read(&df->suspend_count) > 0) {
-		dev_warn(dev, "device suspended, min freq not allowed\n");
-		event_mutex_unlock(df);
-		return -EINVAL;
-	}
 	mutex_lock(&df->lock);
 
 	if (value) {
@@ -1356,11 +1343,6 @@ static ssize_t max_freq_store(struct device *dev, struct device_attribute *attr,
 		return -EINVAL;
 
 	event_mutex_lock(df);
-	if (atomic_read(&df->suspend_count) > 0) {
-		event_mutex_unlock(df);
-		dev_warn(dev, "device suspended, max freq not allowed\n");
-		return -EINVAL;
-	}
 	mutex_lock(&df->lock);
 
 	if (value) {