Skip to contentSkip to conversation

counter: intel-qep: Replace manual mutex logic with lock guards

PATCH In review Joao Paulo Menezes Linaris 2 participants 3 messages Apr 22 – Apr 30

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 counter: intel-qep: Replace manual mutex logic with lock guards

Use scoped_guard() for handling mutex lock instead of locking and unlocking mutex explicitly. This improves readability by eliminating the need for gotos and by clearly indicating mutex will be locked only when execution is in scoped_guard() scope.

---
 drivers/counter/intel-qep.c | 126 +++++++++++++++++-------------------
 1 file changed, 58 insertions(+), 68 deletions(-)
drivers/counter/intel-qep.c +58 -68
index c49c17805..199a8d562 100644
@@ -188,25 +188,22 @@ static int intel_qep_ceiling_write(struct counter_device *counter,
 				   struct counter_count *count, u64 max)
 {
 	struct intel_qep *qep = counter_priv(counter);
-	int ret = 0;
 
 	/* Intel QEP ceiling configuration only supports 32-bit values */
 	if (max != (u32)max)
 		return -ERANGE;
 
-	mutex_lock(&qep->lock);
-	if (qep->enabled) {
-		ret = -EBUSY;
-		goto out;
-	}
+	/* Lock mutex while execution in scoped_guard() scope */
+	scoped_guard(mutex, &qep->lock){
+		if (qep->enabled) 
+			return -EBUSY;
 
-	pm_runtime_get_sync(qep->dev);
-	intel_qep_writel(qep, INTEL_QEPMAX, max);
-	pm_runtime_put(qep->dev);
+		pm_runtime_get_sync(qep->dev);
+		intel_qep_writel(qep, INTEL_QEPMAX, max);
+		pm_runtime_put(qep->dev);
+	}
 
-out:
-	mutex_unlock(&qep->lock);
-	return ret;
+	return 0;
 }
 
 static int intel_qep_enable_read(struct counter_device *counter,
@@ -226,28 +223,28 @@ static int intel_qep_enable_write(struct counter_device *counter,
 	u32 reg;
 	bool changed;
 
-	mutex_lock(&qep->lock);
-	changed = val ^ qep->enabled;
-	if (!changed)
-		goto out;
-
-	pm_runtime_get_sync(qep->dev);
-	reg = intel_qep_readl(qep, INTEL_QEPCON);
-	if (val) {
-		/* Enable peripheral and keep runtime PM always on */
-		reg |= INTEL_QEPCON_EN;
-		pm_runtime_get_noresume(qep->dev);
-	} else {
-		/* Let runtime PM be idle and disable peripheral */
-		pm_runtime_put_noidle(qep->dev);
-		reg &= ~INTEL_QEPCON_EN;
+	/* Lock mutex while execution in scoped_guard() scope */
+	scoped_guard(mutex, &qep->lock){
+		changed = val ^ qep->enabled;
+		if (!changed) 
+			return 0;
+
+		pm_runtime_get_sync(qep->dev);
+		reg = intel_qep_readl(qep, INTEL_QEPCON);
+		if (val) {
+			/* Enable peripheral and keep runtime PM always on */
+			reg |= INTEL_QEPCON_EN;
+			pm_runtime_get_noresume(qep->dev);
+		} else {
+			/* Let runtime PM be idle and disable peripheral */
+			pm_runtime_put_noidle(qep->dev);
+			reg &= ~INTEL_QEPCON_EN;
+		}
+		intel_qep_writel(qep, INTEL_QEPCON, reg);
+		pm_runtime_put(qep->dev);
+		qep->enabled = val;
 	}
-	intel_qep_writel(qep, INTEL_QEPCON, reg);
-	pm_runtime_put(qep->dev);
-	qep->enabled = val;
 
-out:
-	mutex_unlock(&qep->lock);
 	return 0;
 }
 
@@ -279,7 +276,6 @@ static int intel_qep_spike_filter_ns_write(struct counter_device *counter,
 	struct intel_qep *qep = counter_priv(counter);
 	u32 reg;
 	bool enable;
-	int ret = 0;
 
 	/*
 	 * Spike filter length is (MAX_COUNT + 2) clock periods.
@@ -300,25 +296,23 @@ static int intel_qep_spike_filter_ns_write(struct counter_device *counter,
 	if (length > INTEL_QEPFLT_MAX_COUNT(length))
 		return -ERANGE;
 
-	mutex_lock(&qep->lock);
-	if (qep->enabled) {
-		ret = -EBUSY;
-		goto out;
+	/* Lock mutex while execution in scoped_guard() scope */
+	scoped_guard(mutex, &qep->lock){
+		if (qep->enabled)
+			return -EBUSY;
+
+		pm_runtime_get_sync(qep->dev);
+		reg = intel_qep_readl(qep, INTEL_QEPCON);
+		if (enable)
+			reg |= INTEL_QEPCON_FLT_EN;
+		else
+			reg &= ~INTEL_QEPCON_FLT_EN;
+		intel_qep_writel(qep, INTEL_QEPFLT, length);
+		intel_qep_writel(qep, INTEL_QEPCON, reg);
+		pm_runtime_put(qep->dev);
 	}
 
-	pm_runtime_get_sync(qep->dev);
-	reg = intel_qep_readl(qep, INTEL_QEPCON);
-	if (enable)
-		reg |= INTEL_QEPCON_FLT_EN;
-	else
-		reg &= ~INTEL_QEPCON_FLT_EN;
-	intel_qep_writel(qep, INTEL_QEPFLT, length);
-	intel_qep_writel(qep, INTEL_QEPCON, reg);
-	pm_runtime_put(qep->dev);
-
-out:
-	mutex_unlock(&qep->lock);
-	return ret;
+	return 0;
 }
 
 static int intel_qep_preset_enable_read(struct counter_device *counter,
@@ -342,28 +336,24 @@ static int intel_qep_preset_enable_write(struct counter_device *counter,
 {
 	struct intel_qep *qep = counter_priv(counter);
 	u32 reg;
-	int ret = 0;
-
-	mutex_lock(&qep->lock);
-	if (qep->enabled) {
-		ret = -EBUSY;
-		goto out;
-	}
 
-	pm_runtime_get_sync(qep->dev);
-	reg = intel_qep_readl(qep, INTEL_QEPCON);
-	if (val)
-		reg &= ~INTEL_QEPCON_COUNT_RST_MODE;
-	else
-		reg |= INTEL_QEPCON_COUNT_RST_MODE;
+	/* Lock mutex while execution in scoped_guard() scope */
+	scoped_guard(mutex, &qep->lock){
+		if (qep->enabled) 
+			return -EBUSY;
 
-	intel_qep_writel(qep, INTEL_QEPCON, reg);
-	pm_runtime_put(qep->dev);
+		pm_runtime_get_sync(qep->dev);
+		reg = intel_qep_readl(qep, INTEL_QEPCON);
+		if (val)
+			reg &= ~INTEL_QEPCON_COUNT_RST_MODE;
+		else
+			reg |= INTEL_QEPCON_COUNT_RST_MODE;
 
-out:
-	mutex_unlock(&qep->lock);
+		intel_qep_writel(qep, INTEL_QEPCON, reg);
+		pm_runtime_put(qep->dev);
+	}
 
-	return ret;
+	return 0;
 }
 
 static struct counter_comp intel_qep_count_ext[] = {
Signature · 1 line
2.34.1
maintainer
#1 lore raw
Quoted 1 line · Joao Paulo Menezes Linaris

Use scoped_guard() for handling mutex lock instead of locking and unlocking mutex explicitly. This improves readability by eliminating the need for gotos and by clearly indicating mutex will be locked only when execution is in scoped_guard() scope.

Please fold the changelog text properly.

Quoted 18 lines
---
 drivers/counter/intel-qep.c | 126 +++++++++++++++++-------------------
 1 file changed, 58 insertions(+), 68 deletions(-)
drivers/counter/intel-qep.c +0 -1
index c49c17805..199a8d562 100644
@@ -188,25 +188,22 @@ static int intel_qep_ceiling_write(struct counter_device *counter,
 				   struct counter_count *count, u64 max)
 {
 	struct intel_qep *qep = counter_priv(counter);
-	int ret = 0;
 

drivers/counter/intel-qep.c static int intel_qep_ceiling_write(struct counter_device *counter, · line 196

Quoted 10 lines
drivers/counter/intel-qep.c +1 -5
 	/* Intel QEP ceiling configuration only supports 32-bit values */
 	if (max != (u32)max)
 		return -ERANGE;
 
-	mutex_lock(&qep->lock);
-	if (qep->enabled) {
-		ret = -EBUSY;
-		goto out;
-	}
+	/* Lock mutex while execution in scoped_guard() scope */

Why add dead obvious comments like this. Please don't do it.

Quoted 6 lines
drivers/counter/intel-qep.c +3 -2
+	scoped_guard(mutex, &qep->lock){
+		if (qep->enabled) 
+			return -EBUSY;
 
-	pm_runtime_get_sync(qep->dev);
-	intel_qep_writel(qep, INTEL_QEPMAX, max);

drivers/counter/intel-qep.c static int intel_qep_ceiling_write(struct counter_device *counter, · line 206

Quoted 10 lines
drivers/counter/intel-qep.c +5 -4
-	pm_runtime_put(qep->dev);
+		pm_runtime_get_sync(qep->dev);
+		intel_qep_writel(qep, INTEL_QEPMAX, max);
+		pm_runtime_put(qep->dev);
+	}
 
-out:
-	mutex_unlock(&qep->lock);
-	return ret;
+	return 0;

Why is using scoped variable of guard necessary in these cases??? Are you just making these changes using some tool without inspecting if the end result makes sense or not??

Also, runtime PM also has guards support added (admittedly changing them doesn't remove gotos). But one of the cases seems non-pairing so that seems not convertable to guard.

Quoted 145 lines
drivers/counter/intel-qep.c +49 -56
 }
 
 static int intel_qep_enable_read(struct counter_device *counter,
@@ -226,28 +223,28 @@ static int intel_qep_enable_write(struct counter_device *counter,
 	u32 reg;
 	bool changed;
 
-	mutex_lock(&qep->lock);
-	changed = val ^ qep->enabled;
-	if (!changed)
-		goto out;
-
-	pm_runtime_get_sync(qep->dev);
-	reg = intel_qep_readl(qep, INTEL_QEPCON);
-	if (val) {
-		/* Enable peripheral and keep runtime PM always on */
-		reg |= INTEL_QEPCON_EN;
-		pm_runtime_get_noresume(qep->dev);
-	} else {
-		/* Let runtime PM be idle and disable peripheral */
-		pm_runtime_put_noidle(qep->dev);
-		reg &= ~INTEL_QEPCON_EN;
+	/* Lock mutex while execution in scoped_guard() scope */
+	scoped_guard(mutex, &qep->lock){
+		changed = val ^ qep->enabled;
+		if (!changed) 
+			return 0;
+
+		pm_runtime_get_sync(qep->dev);
+		reg = intel_qep_readl(qep, INTEL_QEPCON);
+		if (val) {
+			/* Enable peripheral and keep runtime PM always on */
+			reg |= INTEL_QEPCON_EN;
+			pm_runtime_get_noresume(qep->dev);
+		} else {
+			/* Let runtime PM be idle and disable peripheral */
+			pm_runtime_put_noidle(qep->dev);
+			reg &= ~INTEL_QEPCON_EN;
+		}
+		intel_qep_writel(qep, INTEL_QEPCON, reg);
+		pm_runtime_put(qep->dev);
+		qep->enabled = val;
 	}
-	intel_qep_writel(qep, INTEL_QEPCON, reg);
-	pm_runtime_put(qep->dev);
-	qep->enabled = val;
 
-out:
-	mutex_unlock(&qep->lock);
 	return 0;
 }
 
@@ -279,7 +276,6 @@ static int intel_qep_spike_filter_ns_write(struct counter_device *counter,
 	struct intel_qep *qep = counter_priv(counter);
 	u32 reg;
 	bool enable;
-	int ret = 0;
 
 	/*
 	 * Spike filter length is (MAX_COUNT + 2) clock periods.
@@ -300,25 +296,23 @@ static int intel_qep_spike_filter_ns_write(struct counter_device *counter,
 	if (length > INTEL_QEPFLT_MAX_COUNT(length))
 		return -ERANGE;
 
-	mutex_lock(&qep->lock);
-	if (qep->enabled) {
-		ret = -EBUSY;
-		goto out;
+	/* Lock mutex while execution in scoped_guard() scope */
+	scoped_guard(mutex, &qep->lock){
+		if (qep->enabled)
+			return -EBUSY;
+
+		pm_runtime_get_sync(qep->dev);
+		reg = intel_qep_readl(qep, INTEL_QEPCON);
+		if (enable)
+			reg |= INTEL_QEPCON_FLT_EN;
+		else
+			reg &= ~INTEL_QEPCON_FLT_EN;
+		intel_qep_writel(qep, INTEL_QEPFLT, length);
+		intel_qep_writel(qep, INTEL_QEPCON, reg);
+		pm_runtime_put(qep->dev);
 	}
 
-	pm_runtime_get_sync(qep->dev);
-	reg = intel_qep_readl(qep, INTEL_QEPCON);
-	if (enable)
-		reg |= INTEL_QEPCON_FLT_EN;
-	else
-		reg &= ~INTEL_QEPCON_FLT_EN;
-	intel_qep_writel(qep, INTEL_QEPFLT, length);
-	intel_qep_writel(qep, INTEL_QEPCON, reg);
-	pm_runtime_put(qep->dev);
-
-out:
-	mutex_unlock(&qep->lock);
-	return ret;
+	return 0;
 }
 
 static int intel_qep_preset_enable_read(struct counter_device *counter,
@@ -342,28 +336,24 @@ static int intel_qep_preset_enable_write(struct counter_device *counter,
 {
 	struct intel_qep *qep = counter_priv(counter);
 	u32 reg;
-	int ret = 0;
-
-	mutex_lock(&qep->lock);
-	if (qep->enabled) {
-		ret = -EBUSY;
-		goto out;
-	}
 
-	pm_runtime_get_sync(qep->dev);
-	reg = intel_qep_readl(qep, INTEL_QEPCON);
-	if (val)
-		reg &= ~INTEL_QEPCON_COUNT_RST_MODE;
-	else
-		reg |= INTEL_QEPCON_COUNT_RST_MODE;
+	/* Lock mutex while execution in scoped_guard() scope */
+	scoped_guard(mutex, &qep->lock){
+		if (qep->enabled) 
+			return -EBUSY;
 
-	intel_qep_writel(qep, INTEL_QEPCON, reg);
-	pm_runtime_put(qep->dev);
+		pm_runtime_get_sync(qep->dev);
+		reg = intel_qep_readl(qep, INTEL_QEPCON);
+		if (val)
+			reg &= ~INTEL_QEPCON_COUNT_RST_MODE;
+		else
+			reg |= INTEL_QEPCON_COUNT_RST_MODE;
 
-out:
-	mutex_unlock(&qep->lock);
+		intel_qep_writel(qep, INTEL_QEPCON, reg);
+		pm_runtime_put(qep->dev);
+	}
 
-	return ret;
+	return 0;
 }
 
 static struct counter_comp intel_qep_count_ext[] = {
Signature · 1 line
 i.
#2 lore raw

Hello. Thanks for the suggestions!

Em qui., 23 de abr. de 2026 às 08:42, Ilpo Järvinen <[email protected]> escreveu:

Quoted 55 lines · Joao Paulo Menezes Linaris
Quoted 2 lines

Use scoped_guard() for handling mutex lock instead of locking and unlocking mutex explicitly. This improves readability by eliminating the need for gotos and by clearly indicating mutex will be locked only when execution is in scoped_guard() scope.

Please fold the changelog text properly.

Quoted 18 lines
---
 drivers/counter/intel-qep.c | 126 +++++++++++++++++-------------------
 1 file changed, 58 insertions(+), 68 deletions(-)
drivers/counter/intel-qep.c +0 -1
index c49c17805..199a8d562 100644
@@ -188,25 +188,22 @@ static int intel_qep_ceiling_write(struct counter_device *counter,
                                 struct counter_count *count, u64 max)
 {
      struct intel_qep *qep = counter_priv(counter);
-     int ret = 0;
 

drivers/counter/intel-qep.c static int intel_qep_ceiling_write(struct counter_device *counter, · line 196

Quoted 10 lines
drivers/counter/intel-qep.c +1 -5
      /* Intel QEP ceiling configuration only supports 32-bit values */
      if (max != (u32)max)
              return -ERANGE;
 
-     mutex_lock(&qep->lock);
-     if (qep->enabled) {
-             ret = -EBUSY;
-             goto out;
-     }
+     /* Lock mutex while execution in scoped_guard() scope */

Why add dead obvious comments like this. Please don't do it.

Quoted 6 lines
drivers/counter/intel-qep.c +3 -2
+     scoped_guard(mutex, &qep->lock){
+             if (qep->enabled)
+                     return -EBUSY;
 
-     pm_runtime_get_sync(qep->dev);
-     intel_qep_writel(qep, INTEL_QEPMAX, max);

drivers/counter/intel-qep.c static int intel_qep_ceiling_write(struct counter_device *counter, · line 206

Quoted 10 lines
drivers/counter/intel-qep.c +5 -4
-     pm_runtime_put(qep->dev);
+             pm_runtime_get_sync(qep->dev);
+             intel_qep_writel(qep, INTEL_QEPMAX, max);
+             pm_runtime_put(qep->dev);
+     }
 
-out:
-     mutex_unlock(&qep->lock);
-     return ret;
+     return 0;
Quoted 8 lines

Why is using scoped variable of guard necessary in these cases??? Are you just making these changes using some tool without inspecting if the end result makes sense or not??

Also, runtime PM also has guards support added (admittedly changing them doesn't remove gotos). But one of the cases seems non-pairing so that seems not convertable to guard.

Just to be sure I'm on the right page regarding this suggestion, according to pm_runtime documentation, pm_runtim_get_sync and pm_runtime_put, in the functions I changed, would be the pairs we are talking about. And, therefore, if we have something like:

ret = pm_runtime_get_sync(dev);
if (ret < 0)

    // returns before the decrement of device's usage counter
    return ret;

pm_runtime_put(dev);

This would be considered a non-pairing case, which seems not convertible to guard. Is that right? In the functions I implemented the lock guards, I couldn't find any case in which the function could return in between get/put calls. In this case, would it be correct to keep all the added guards?

Quoted 143 lines
Quoted 143 lines
drivers/counter/intel-qep.c +49 -56
 }
 
 static int intel_qep_enable_read(struct counter_device *counter,
@@ -226,28 +223,28 @@ static int intel_qep_enable_write(struct counter_device *counter,
      u32 reg;
      bool changed;
 
-     mutex_lock(&qep->lock);
-     changed = val ^ qep->enabled;
-     if (!changed)
-             goto out;
-
-     pm_runtime_get_sync(qep->dev);
-     reg = intel_qep_readl(qep, INTEL_QEPCON);
-     if (val) {
-             /* Enable peripheral and keep runtime PM always on */
-             reg |= INTEL_QEPCON_EN;
-             pm_runtime_get_noresume(qep->dev);
-     } else {
-             /* Let runtime PM be idle and disable peripheral */
-             pm_runtime_put_noidle(qep->dev);
-             reg &= ~INTEL_QEPCON_EN;
+     /* Lock mutex while execution in scoped_guard() scope */
+     scoped_guard(mutex, &qep->lock){
+             changed = val ^ qep->enabled;
+             if (!changed)
+                     return 0;
+
+             pm_runtime_get_sync(qep->dev);
+             reg = intel_qep_readl(qep, INTEL_QEPCON);
+             if (val) {
+                     /* Enable peripheral and keep runtime PM always on */
+                     reg |= INTEL_QEPCON_EN;
+                     pm_runtime_get_noresume(qep->dev);
+             } else {
+                     /* Let runtime PM be idle and disable peripheral */
+                     pm_runtime_put_noidle(qep->dev);
+                     reg &= ~INTEL_QEPCON_EN;
+             }
+             intel_qep_writel(qep, INTEL_QEPCON, reg);
+             pm_runtime_put(qep->dev);
+             qep->enabled = val;
      }
-     intel_qep_writel(qep, INTEL_QEPCON, reg);
-     pm_runtime_put(qep->dev);
-     qep->enabled = val;
 
-out:
-     mutex_unlock(&qep->lock);
      return 0;
 }
 
@@ -279,7 +276,6 @@ static int intel_qep_spike_filter_ns_write(struct counter_device *counter,
      struct intel_qep *qep = counter_priv(counter);
      u32 reg;
      bool enable;
-     int ret = 0;
 
      /*
       * Spike filter length is (MAX_COUNT + 2) clock periods.
@@ -300,25 +296,23 @@ static int intel_qep_spike_filter_ns_write(struct counter_device *counter,
      if (length > INTEL_QEPFLT_MAX_COUNT(length))
              return -ERANGE;
 
-     mutex_lock(&qep->lock);
-     if (qep->enabled) {
-             ret = -EBUSY;
-             goto out;
+     /* Lock mutex while execution in scoped_guard() scope */
+     scoped_guard(mutex, &qep->lock){
+             if (qep->enabled)
+                     return -EBUSY;
+
+             pm_runtime_get_sync(qep->dev);
+             reg = intel_qep_readl(qep, INTEL_QEPCON);
+             if (enable)
+                     reg |= INTEL_QEPCON_FLT_EN;
+             else
+                     reg &= ~INTEL_QEPCON_FLT_EN;
+             intel_qep_writel(qep, INTEL_QEPFLT, length);
+             intel_qep_writel(qep, INTEL_QEPCON, reg);
+             pm_runtime_put(qep->dev);
      }
 
-     pm_runtime_get_sync(qep->dev);
-     reg = intel_qep_readl(qep, INTEL_QEPCON);
-     if (enable)
-             reg |= INTEL_QEPCON_FLT_EN;
-     else
-             reg &= ~INTEL_QEPCON_FLT_EN;
-     intel_qep_writel(qep, INTEL_QEPFLT, length);
-     intel_qep_writel(qep, INTEL_QEPCON, reg);
-     pm_runtime_put(qep->dev);
-
-out:
-     mutex_unlock(&qep->lock);
-     return ret;
+     return 0;
 }
 
 static int intel_qep_preset_enable_read(struct counter_device *counter,
@@ -342,28 +336,24 @@ static int intel_qep_preset_enable_write(struct counter_device *counter,
 {
      struct intel_qep *qep = counter_priv(counter);
      u32 reg;
-     int ret = 0;
-
-     mutex_lock(&qep->lock);
-     if (qep->enabled) {
-             ret = -EBUSY;
-             goto out;
-     }
 
-     pm_runtime_get_sync(qep->dev);
-     reg = intel_qep_readl(qep, INTEL_QEPCON);
-     if (val)
-             reg &= ~INTEL_QEPCON_COUNT_RST_MODE;
-     else
-             reg |= INTEL_QEPCON_COUNT_RST_MODE;
+     /* Lock mutex while execution in scoped_guard() scope */
+     scoped_guard(mutex, &qep->lock){
+             if (qep->enabled)
+                     return -EBUSY;
 
-     intel_qep_writel(qep, INTEL_QEPCON, reg);
-     pm_runtime_put(qep->dev);
+             pm_runtime_get_sync(qep->dev);
+             reg = intel_qep_readl(qep, INTEL_QEPCON);
+             if (val)
+                     reg &= ~INTEL_QEPCON_COUNT_RST_MODE;
+             else
+                     reg |= INTEL_QEPCON_COUNT_RST_MODE;
 
-out:
-     mutex_unlock(&qep->lock);
+             intel_qep_writel(qep, INTEL_QEPCON, reg);
+             pm_runtime_put(qep->dev);
+     }
 
-     return ret;
+     return 0;
 }
 
Quoted 6 lines

drivers/counter/intel-qep.c static int intel_qep_preset_enable_write(struct counter_device *counter, · line 359

Quoted 2 lines
drivers/counter/intel-qep.c +0 -0
 static struct counter_comp intel_qep_count_ext[] = {

--
i.

--
Best regards,
Joao Paulo Menezes Linaris