Skip to contentSkip to conversation

: RK3399 pd power down failed

REPORT_ISSUE Ulf Hansson 4 participants 5 messages Feb 23, 2021 – Feb 24, 2021 1 message not in the archive

Subsystems (5)
lore
Share & tools
lore
#1 lore raw
In reply to a message not in the archive
Quoted 36 lines · On Wed, 20 Jan 2021 at 10:30, [email protected]…

Hi, Heiko :

In rk3399 evb board, I found a probabilistic problem about PD. Turning off PD occasionally failed.

log show:
Open the vop
#modetest -M rockchip -s 42@36:1536x2048 -P 31@36:1536x2048@AR24 -a

close the vop
#enter

 # cat sys/kernel/debug/pm_genpd/pm_genpd_summary
domain                          status          slaves
    /device                                             runtime status
----------------------------------------------------------------------
pd_vopl                         off
pd_vopb                         on
    /devices/platform/ff903f00.iommu                     suspended
    /devices/platform/ff900000.vop                          suspended

I have checked the codes and concluded that there is a window of time for PD to be closed when using the device link. Once queue_work is executed immediately, PD power off may be failed. The process is as follows:

VOP requests to power off PD:
pm_runtime_put_sync(vop->dev)

    -> rpm_idle(vop)
        -> rpm_suspend(vop)
            -> __update_runtime_status(dev, RPM_SUSPENDING)
                -> rpm_callback(vop)
                    -> __rpm_callback(vop)
                        -> do power off pd callback(genpd_power_off)
                            -> list_for_each_entry(pdd, &genpd->dev_list, list_node), ff900000.vop: suspending, ff903f00.iommu : active,so not_suspended = 2 return -EBUSY; Not really power off PD。
                                -> Handle link device callbacks according to device link(rpm_put_suppliers)
                                    -> pm_runtime_put(link->supplier)
                                        -> queue_work(pm_wq, &dev->power.work), execute immediately
Quoted 8 lines
                                            ->rpm_idle(iommu)
                                                -> rpm_suspend(iommu)
                                                    -> rpm_callback(iommu)
                                                        -> rk_iommu_suspend
                                                            ->  do power off pd callback(genpd_power_off)
                                                                -> list_for_each_entry(pdd, &genpd->dev_list, list_node), ff900000.vop: suspending, ff903f00.iommu : suspending,so not_suspended = 2 return -EBUSY; Not really power off PD。
                                                                    -> iommu do __update_runtime_status(dev, RPM_SUSPENDED)
                                                                        -> vop do __update_runtime_status(dev, RPM_SUSPENDED)

So, rpm_suspend() tries to suspend the supplier device link via rpm_put_suppliers(), before it has updated its consumer device's state to RPM_SUSPENDED.

This looks worrying to me, both because it's seems wrong to allow a supplier to be suspended before a consumers device's state has reached RPM_SUSPENDED - but also because it's not consistent with the way we treat parent/child devices. The child's state will always be set to RPM_SUSPENDED, before we try to suspend its parent by calling rpm_idle() for it in rpm_suspend().

Rafael, what's your take on this? Would it make sense to align the behavior for consumer/supplier-links in rpm_suspend() according to child/parents?

Quoted 18 lines

So the whole process goes down, the PD is not really power off, but the state of the child devices is SUSPENDED. Pm_runtime_put (link->supplier) used to power off PD is asynchronous and is added to queue_work(pm_wq, &dev-bbb>wer-work); If the queue_work is queued, the PD shutdown will succeed
The call is as follows:

VOP requests to power off PD:
pm_runtime_put_sync(vop->dev)

    -> rpm_idle(vop)
        -> rpm_suspend(vop)
            -> __update_runtime_status(dev, RPM_SUSPENDING)
                -> rpm_callback(vop)
                    -> __rpm_callback(vop)
                        -> do power off pd callback(genpd_power_off)
                            ->  list_for_each_entry(pdd, &genpd->dev_list, list_node), ff900000.vop: suspending, ff903f00.iommu : active,so not_suspended = 2 return -EBUSY; Not really power off PD。
                                 -> Handle link device callbacks according to device link(rpm_put_suppliers)
                                    -> pm_runtime_put(link->supplier)
                                         -> queue_work(pm_wq, &dev->power.work),
Quoted 9 lines
                                             -> vop do  __update_runtime_status(dev, RPM_SUSPENDED)
                                                -> do queue_work (pm_runtime_work)
                                                    ->  rpm_idle(iommu)
                                                         -> rpm_suspend(iommu)
                                                            -> do callback( rk_iommu_suspend)
                                                                -> do callback (genpd_power_off)
                                                                    -> list_for_each_entry(pdd, &genpd->dev_list, list_node), ff900000.vop: suspended, ff903f00.iommu : suspending,so not_suspended = 1; do _genpd_power_off, Really turn off PD。
                                                                        -> iommu do  __update_runtime_status(dev, RPM_SUSPENDED)

[...]

Kind regards
Uffe

_______________________________________________
Linux-rockchip mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-rockchip

#2 lore raw
Quoted 58 lines · CET Ulf Hansson
Quoted 36 lines · On Wed, 20 Jan 2021 at 10:30, [email protected]…

Hi, Heiko :

In rk3399 evb board, I found a probabilistic problem about PD. Turning off PD occasionally failed.

log show:
Open the vop
#modetest -M rockchip -s 42@36:1536x2048 -P 31@36:1536x2048@AR24 -a

close the vop
#enter

 # cat sys/kernel/debug/pm_genpd/pm_genpd_summary
domain                          status          slaves
    /device                                             runtime status
----------------------------------------------------------------------
pd_vopl                         off
pd_vopb                         on
    /devices/platform/ff903f00.iommu                     suspended
    /devices/platform/ff900000.vop                          suspended

I have checked the codes and concluded that there is a window of time for PD to be closed when using the device link. Once queue_work is executed immediately, PD power off may be failed. The process is as follows:

VOP requests to power off PD:
pm_runtime_put_sync(vop->dev)

    -> rpm_idle(vop)
        -> rpm_suspend(vop)
            -> __update_runtime_status(dev, RPM_SUSPENDING)
                -> rpm_callback(vop)
                    -> __rpm_callback(vop)
                        -> do power off pd callback(genpd_power_off)
                            -> list_for_each_entry(pdd, &genpd->dev_list, list_node), ff900000.vop: suspending, ff903f00.iommu : active,so not_suspended = 2 return -EBUSY; Not really power off PD。
                                -> Handle link device callbacks according to device link(rpm_put_suppliers)
                                    -> pm_runtime_put(link->supplier)
                                        -> queue_work(pm_wq, &dev->power.work), execute immediately
Quoted 8 lines
                                            ->rpm_idle(iommu)
                                                -> rpm_suspend(iommu)
                                                    -> rpm_callback(iommu)
                                                        -> rk_iommu_suspend
                                                            ->  do power off pd callback(genpd_power_off)
                                                                -> list_for_each_entry(pdd, &genpd->dev_list, list_node), ff900000.vop: suspending, ff903f00.iommu : suspending,so not_suspended = 2 return -EBUSY; Not really power off PD。
                                                                    -> iommu do __update_runtime_status(dev, RPM_SUSPENDED)
                                                                        -> vop do __update_runtime_status(dev, RPM_SUSPENDED)

So, rpm_suspend() tries to suspend the supplier device link via rpm_put_suppliers(), before it has updated its consumer device's state to RPM_SUSPENDED.

This looks worrying to me, both because it's seems wrong to allow a supplier to be suspended before a consumers device's state has reached RPM_SUSPENDED - but also because it's not consistent with the way we treat parent/child devices. The child's state will always be set to RPM_SUSPENDED, before we try to suspend its parent by calling rpm_idle() for it in rpm_suspend().

Quoted 3 lines

Rafael, what's your take on this? Would it make sense to align the behavior for consumer/supplier-links in rpm_suspend() according to child/parents?

Suspending the suppliers before changing the consumer RPM status to "suspended" is indeed incorrect, which is something I overlooked when writing the code in question.

Fortunately, it seems to be relatively easy to address.

Please see the appended tentative patch (untested). It also avoids reading runtime_status outside the lock which is arguably fishy.

---
 drivers/base/power/runtime.c |   24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)
drivers/base/power/runtime.c +20 -4
Index: linux-pm/drivers/base/power/runtime.c
===================================================================
@@ -330,7 +330,11 @@ static int __rpm_callback(int (*cb)(stru
 
 	if (dev->power.irq_safe) {
 		spin_unlock(&dev->power.lock);
+	} else if (!use_links) {
+		spin_unlock_irq(&dev->power.lock);
 	} else {
+		bool get = dev->power.runtime_status == RPM_RESUMING;
+
 		spin_unlock_irq(&dev->power.lock);
 
 		/*
@@ -340,7 +344,7 @@ static int __rpm_callback(int (*cb)(stru
 		 * routine returns, so it is safe to read the status outside of
 		 * the lock.
 		 */
-		if (use_links && dev->power.runtime_status == RPM_RESUMING) {
+		if (get) {
 			idx = device_links_read_lock();
 
 			retval = rpm_get_suppliers(dev);
@@ -355,7 +359,21 @@ static int __rpm_callback(int (*cb)(stru
 
 	if (dev->power.irq_safe) {
 		spin_lock(&dev->power.lock);
+	} if (!use_links) {
+		spin_lock_irq(&dev->power.lock);
 	} else {
+		bool put;
+
+		spin_lock_irq(&dev->power.lock);
+
+		put = dev->power.runtime_status == RPM_SUSPENDING && !retval;
+		if (put)
+			__update_runtime_status(dev, RPM_SUSPENDED);
+		else
+			put = dev->power.runtime_status == RPM_RESUMING && retval;
+
+		spin_unlock_irq(&dev->power.lock);
+
 		/*
 		 * If the device is suspending and the callback has returned
 		 * success, drop the usage counters of the suppliers that have
@@ -363,9 +381,7 @@ static int __rpm_callback(int (*cb)(stru
 		 *
 		 * Do that if resume fails too.
 		 */
-		if (use_links
-		    && ((dev->power.runtime_status == RPM_SUSPENDING && !retval)
-		    || (dev->power.runtime_status == RPM_RESUMING && retval))) {
+		if (put) {
 			idx = device_links_read_lock();
 
  fail:

_______________________________________________
Linux-rockchip mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-rockchip

#3 lore raw

Hi,  Rafael:

Quoted 121 lines · Rafael J. Wysocki
Quoted 56 lines · CET Ulf Hansson
Quoted 35 lines · On Wed, 20 Jan 2021 at 10:30, [email protected]…

Hi, Heiko :

In rk3399 evb board, I found a probabilistic problem about PD. Turning off PD occasionally failed.

log show:
Open the vop
#modetest -M rockchip -s 42@36:1536x2048 -P 31@36:1536x2048@AR24 -a

close the vop
#enter

  # cat sys/kernel/debug/pm_genpd/pm_genpd_summary
domain                          status          slaves
     /device                                             runtime status
----------------------------------------------------------------------
pd_vopl                         off
pd_vopb                         on
     /devices/platform/ff903f00.iommu                     suspended
     /devices/platform/ff900000.vop                          suspended

I have checked the codes and concluded that there is a window of time for PD to be closed when using the device link. Once queue_work is executed immediately, PD power off may be failed. The process is as follows:

VOP requests to power off PD:
pm_runtime_put_sync(vop->dev)

     -> rpm_idle(vop)
         -> rpm_suspend(vop)
             -> __update_runtime_status(dev, RPM_SUSPENDING)
                 -> rpm_callback(vop)
                     -> __rpm_callback(vop)
                         -> do power off pd callback(genpd_power_off)
                             -> list_for_each_entry(pdd, &genpd->dev_list, list_node), ff900000.vop: suspending, ff903f00.iommu : active,so not_suspended = 2 return -EBUSY; Not really power off PD。
                                 -> Handle link device callbacks according to device link(rpm_put_suppliers)
                                     -> pm_runtime_put(link->supplier)
                                         -> queue_work(pm_wq, &dev->power.work), execute immediately
Quoted 8 lines
                                             ->rpm_idle(iommu)
                                                 -> rpm_suspend(iommu)
                                                     -> rpm_callback(iommu)
                                                         -> rk_iommu_suspend
                                                             ->  do power off pd callback(genpd_power_off)
                                                                 -> list_for_each_entry(pdd, &genpd->dev_list, list_node), ff900000.vop: suspending, ff903f00.iommu : suspending,so not_suspended = 2 return -EBUSY; Not really power off PD。
                                                                     -> iommu do __update_runtime_status(dev, RPM_SUSPENDED)
                                                                         -> vop do __update_runtime_status(dev, RPM_SUSPENDED)

So, rpm_suspend() tries to suspend the supplier device link via rpm_put_suppliers(), before it has updated its consumer device's state to RPM_SUSPENDED.

This looks worrying to me, both because it's seems wrong to allow a supplier to be suspended before a consumers device's state has reached RPM_SUSPENDED - but also because it's not consistent with the way we treat parent/child devices. The child's state will always be set to RPM_SUSPENDED, before we try to suspend its parent by calling rpm_idle() for it in rpm_suspend().

Quoted 3 lines

Rafael, what's your take on this? Would it make sense to align the behavior for consumer/supplier-links in rpm_suspend() according to child/parents?

Suspending the suppliers before changing the consumer RPM status to "suspended" is indeed incorrect, which is something I overlooked when writing the code in question.

Fortunately, it seems to be relatively easy to address.

Please see the appended tentative patch (untested). It also avoids reading runtime_status outside the lock which is arguably fishy.

---
  drivers/base/power/runtime.c |   24 ++++++++++++++++++++----
  1 file changed, 20 insertions(+), 4 deletions(-)

Index: linux-pm/drivers/base/power/runtime.c
===================================================================

drivers/base/power/runtime.c +19 -1
@@ -330,7 +330,11 @@ static int __rpm_callback(int (*cb)(stru
 
  	if (dev->power.irq_safe) {
  		spin_unlock(&dev->power.lock);
+	} else if (!use_links) {
+		spin_unlock_irq(&dev->power.lock);
  	} else {
+		bool get = dev->power.runtime_status == RPM_RESUMING;
+
  		spin_unlock_irq(&dev->power.lock);
 
  		/*
@@ -340,7 +344,7 @@ static int __rpm_callback(int (*cb)(stru
  		 * routine returns, so it is safe to read the status outside of
  		 * the lock.
  		 */
-		if (use_links && dev->power.runtime_status == RPM_RESUMING) {
+		if (get) {
  			idx = device_links_read_lock();
 
  			retval = rpm_get_suppliers(dev);
@@ -355,7 +359,21 @@ static int __rpm_callback(int (*cb)(stru
 
  	if (dev->power.irq_safe) {
  		spin_lock(&dev->power.lock);
+	} if (!use_links) {
+		spin_lock_irq(&dev->power.lock);
  	} else {
+		bool put;
+
+		spin_lock_irq(&dev->power.lock);
+
+		put = dev->power.runtime_status == RPM_SUSPENDING && !retval;
+		if (put)
+			__update_runtime_status(dev, RPM_SUSPENDED);
+		else
+			put = dev->power.runtime_status == RPM_RESUMING && retval;
+
+		spin_unlock_irq(&dev->power.lock);
+
  		/*
  		 * If the device is suspending and the callback has returned
  		 * success, drop the usage counters of the suppliers that have

drivers/base/power/runtime.c static int __rpm_callback(int (*cb)(stru · line 387

Quoted 10 lines
drivers/base/power/runtime.c +1 -3
@@ -363,9 +381,7 @@ static int __rpm_callback(int (*cb)(stru
  		 *
  		 * Do that if resume fails too.
  		 */
-		if (use_links
-		    && ((dev->power.runtime_status == RPM_SUSPENDING && !retval)
-		    || (dev->power.runtime_status == RPM_RESUMING && retval))) {
+		if (put) {
  			idx = device_links_read_lock();
 
   fail:

Thank you for your reply.

I have tested this patch, and it's works well.Perfect solution to our problem.

We expect this patch to be committed to the mainline branch.

Quoted 4 lines

_______________________________________________
Linux-rockchip mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-rockchip

#4 lore raw
In reply to Rafael J. Wysocki
Quoted 64 lines · Rafael J. Wysocki
Quoted 58 lines · CET Ulf Hansson
Quoted 36 lines · On Wed, 20 Jan 2021 at 10:30, [email protected]…

Hi, Heiko :

In rk3399 evb board, I found a probabilistic problem about PD. Turning off PD occasionally failed.

log show:
Open the vop
#modetest -M rockchip -s 42@36:1536x2048 -P 31@36:1536x2048@AR24 -a

close the vop
#enter

 # cat sys/kernel/debug/pm_genpd/pm_genpd_summary
domain                          status          slaves
    /device                                             runtime status
----------------------------------------------------------------------
pd_vopl                         off
pd_vopb                         on
    /devices/platform/ff903f00.iommu                     suspended
    /devices/platform/ff900000.vop                          suspended

I have checked the codes and concluded that there is a window of time for PD to be closed when using the device link. Once queue_work is executed immediately, PD power off may be failed. The process is as follows:

VOP requests to power off PD:
pm_runtime_put_sync(vop->dev)

    -> rpm_idle(vop)
        -> rpm_suspend(vop)
            -> __update_runtime_status(dev, RPM_SUSPENDING)
                -> rpm_callback(vop)
                    -> __rpm_callback(vop)
                        -> do power off pd callback(genpd_power_off)
                            -> list_for_each_entry(pdd, &genpd->dev_list, list_node), ff900000.vop: suspending, ff903f00.iommu : active,so not_suspended = 2 return -EBUSY; Not really power off PD。
                                -> Handle link device callbacks according to device link(rpm_put_suppliers)
                                    -> pm_runtime_put(link->supplier)
                                        -> queue_work(pm_wq, &dev->power.work), execute immediately
Quoted 8 lines
                                            ->rpm_idle(iommu)
                                                -> rpm_suspend(iommu)
                                                    -> rpm_callback(iommu)
                                                        -> rk_iommu_suspend
                                                            ->  do power off pd callback(genpd_power_off)
                                                                -> list_for_each_entry(pdd, &genpd->dev_list, list_node), ff900000.vop: suspending, ff903f00.iommu : suspending,so not_suspended = 2 return -EBUSY; Not really power off PD。
                                                                    -> iommu do __update_runtime_status(dev, RPM_SUSPENDED)
                                                                        -> vop do __update_runtime_status(dev, RPM_SUSPENDED)

So, rpm_suspend() tries to suspend the supplier device link via rpm_put_suppliers(), before it has updated its consumer device's state to RPM_SUSPENDED.

This looks worrying to me, both because it's seems wrong to allow a supplier to be suspended before a consumers device's state has reached RPM_SUSPENDED - but also because it's not consistent with the way we treat parent/child devices. The child's state will always be set to RPM_SUSPENDED, before we try to suspend its parent by calling rpm_idle() for it in rpm_suspend().

Quoted 3 lines

Rafael, what's your take on this? Would it make sense to align the behavior for consumer/supplier-links in rpm_suspend() according to child/parents?

Quoted 8 lines

Suspending the suppliers before changing the consumer RPM status to "suspended" is indeed incorrect, which is something I overlooked when writing the code in question.

Fortunately, it seems to be relatively easy to address.

Please see the appended tentative patch (untested). It also avoids reading runtime_status outside the lock which is arguably fishy.

Great, thanks for your quick reply!

A minor comment on the below change, but otherwise feel free add my reviewed-by tag.

Kind regards
Uffe

Quoted 31 lines
---
 drivers/base/power/runtime.c |   24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

Index: linux-pm/drivers/base/power/runtime.c
===================================================================

drivers/base/power/runtime.c +5 -1
@@ -330,7 +330,11 @@ static int __rpm_callback(int (*cb)(stru
 
        if (dev->power.irq_safe) {
                spin_unlock(&dev->power.lock);
+       } else if (!use_links) {
+               spin_unlock_irq(&dev->power.lock);
        } else {
+               bool get = dev->power.runtime_status == RPM_RESUMING;
+
                spin_unlock_irq(&dev->power.lock);
 
                /*
@@ -340,7 +344,7 @@ static int __rpm_callback(int (*cb)(stru
                 * routine returns, so it is safe to read the status outside of
                 * the lock.
                 */
-               if (use_links && dev->power.runtime_status == RPM_RESUMING) {
+               if (get) {
                        idx = device_links_read_lock();
 
                        retval = rpm_get_suppliers(dev);

drivers/base/power/runtime.c static int __rpm_callback(int (*cb)(stru · line 362

Quoted 4 lines
drivers/base/power/runtime.c +1 -0
@@ -355,7 +359,21 @@ static int __rpm_callback(int (*cb)(stru
 
        if (dev->power.irq_safe) {
                spin_lock(&dev->power.lock);
+       } if (!use_links) {

This should be an "else if", I think.

Quoted 21 lines
drivers/base/power/runtime.c +13 -0
+               spin_lock_irq(&dev->power.lock);
        } else {
+               bool put;
+
+               spin_lock_irq(&dev->power.lock);
+
+               put = dev->power.runtime_status == RPM_SUSPENDING && !retval;
+               if (put)
+                       __update_runtime_status(dev, RPM_SUSPENDED);
+               else
+                       put = dev->power.runtime_status == RPM_RESUMING && retval;
+
+               spin_unlock_irq(&dev->power.lock);
+
                /*
                 * If the device is suspending and the callback has returned
                 * success, drop the usage counters of the suppliers that have

drivers/base/power/runtime.c static int __rpm_callback(int (*cb)(stru · line 387

Quoted 10 lines
drivers/base/power/runtime.c +1 -3
@@ -363,9 +381,7 @@ static int __rpm_callback(int (*cb)(stru
                 *
                 * Do that if resume fails too.
                 */
-               if (use_links
-                   && ((dev->power.runtime_status == RPM_SUSPENDING && !retval)
-                   || (dev->power.runtime_status == RPM_RESUMING && retval))) {
+               if (put) {
                        idx = device_links_read_lock();
 
  fail:

_______________________________________________
Linux-rockchip mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-rockchip

#5 lore raw
Quoted 72 lines · Ulf Hansson
Quoted 70 lines · Rafael J. Wysocki
Quoted 58 lines · CET Ulf Hansson
Quoted 36 lines · On Wed, 20 Jan 2021 at 10:30, [email protected]…

Hi, Heiko :

In rk3399 evb board, I found a probabilistic problem about PD. Turning off PD occasionally failed.

log show:
Open the vop
#modetest -M rockchip -s 42@36:1536x2048 -P 31@36:1536x2048@AR24 -a

close the vop
#enter

 # cat sys/kernel/debug/pm_genpd/pm_genpd_summary
domain                          status          slaves
    /device                                             runtime status
----------------------------------------------------------------------
pd_vopl                         off
pd_vopb                         on
    /devices/platform/ff903f00.iommu                     suspended
    /devices/platform/ff900000.vop                          suspended

I have checked the codes and concluded that there is a window of time for PD to be closed when using the device link. Once queue_work is executed immediately, PD power off may be failed. The process is as follows:

VOP requests to power off PD:
pm_runtime_put_sync(vop->dev)

    -> rpm_idle(vop)
        -> rpm_suspend(vop)
            -> __update_runtime_status(dev, RPM_SUSPENDING)
                -> rpm_callback(vop)
                    -> __rpm_callback(vop)
                        -> do power off pd callback(genpd_power_off)
                            -> list_for_each_entry(pdd, &genpd->dev_list, list_node), ff900000.vop: suspending, ff903f00.iommu : active,so not_suspended = 2 return -EBUSY; Not really power off PD。
                                -> Handle link device callbacks according to device link(rpm_put_suppliers)
                                    -> pm_runtime_put(link->supplier)
                                        -> queue_work(pm_wq, &dev->power.work), execute immediately
Quoted 8 lines
                                            ->rpm_idle(iommu)
                                                -> rpm_suspend(iommu)
                                                    -> rpm_callback(iommu)
                                                        -> rk_iommu_suspend
                                                            ->  do power off pd callback(genpd_power_off)
                                                                -> list_for_each_entry(pdd, &genpd->dev_list, list_node), ff900000.vop: suspending, ff903f00.iommu : suspending,so not_suspended = 2 return -EBUSY; Not really power off PD。
                                                                    -> iommu do __update_runtime_status(dev, RPM_SUSPENDED)
                                                                        -> vop do __update_runtime_status(dev, RPM_SUSPENDED)

So, rpm_suspend() tries to suspend the supplier device link via rpm_put_suppliers(), before it has updated its consumer device's state to RPM_SUSPENDED.

This looks worrying to me, both because it's seems wrong to allow a supplier to be suspended before a consumers device's state has reached RPM_SUSPENDED - but also because it's not consistent with the way we treat parent/child devices. The child's state will always be set to RPM_SUSPENDED, before we try to suspend its parent by calling rpm_idle() for it in rpm_suspend().

Quoted 3 lines

Rafael, what's your take on this? Would it make sense to align the behavior for consumer/supplier-links in rpm_suspend() according to child/parents?

Suspending the suppliers before changing the consumer RPM status to "suspended" is indeed incorrect, which is something I overlooked when writing the code in question.

Fortunately, it seems to be relatively easy to address.

Quoted 7 lines
Quoted 2 lines

Please see the appended tentative patch (untested). It also avoids reading runtime_status outside the lock which is arguably fishy.

Great, thanks for your quick reply!

A minor comment on the below change, but otherwise feel free add my reviewed-by tag.

Thanks!

I'm going to submit an updated patch that avoids some unnecessary locking overhead.

Quoted 29 lines
Quoted 29 lines
---
 drivers/base/power/runtime.c |   24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

Index: linux-pm/drivers/base/power/runtime.c
===================================================================

drivers/base/power/runtime.c +5 -1
@@ -330,7 +330,11 @@ static int __rpm_callback(int (*cb)(stru
 
        if (dev->power.irq_safe) {
                spin_unlock(&dev->power.lock);
+       } else if (!use_links) {
+               spin_unlock_irq(&dev->power.lock);
        } else {
+               bool get = dev->power.runtime_status == RPM_RESUMING;
+
                spin_unlock_irq(&dev->power.lock);
 
                /*
@@ -340,7 +344,7 @@ static int __rpm_callback(int (*cb)(stru
                 * routine returns, so it is safe to read the status outside of
                 * the lock.
                 */
-               if (use_links && dev->power.runtime_status == RPM_RESUMING) {
+               if (get) {
                        idx = device_links_read_lock();
 
Quoted 8 lines

drivers/base/power/runtime.c static int __rpm_callback(int (*cb)(stru · line 362

Quoted 6 lines
drivers/base/power/runtime.c +1 -0
                        retval = rpm_get_suppliers(dev);
@@ -355,7 +359,21 @@ static int __rpm_callback(int (*cb)(stru
 
        if (dev->power.irq_safe) {
                spin_lock(&dev->power.lock);
+       } if (!use_links) {

This should be an "else if", I think.

Yes, it should, thanks!

Quoted 27 lines
Quoted 27 lines
drivers/base/power/runtime.c +14 -3
+               spin_lock_irq(&dev->power.lock);
        } else {
+               bool put;
+
+               spin_lock_irq(&dev->power.lock);
+
+               put = dev->power.runtime_status == RPM_SUSPENDING && !retval;
+               if (put)
+                       __update_runtime_status(dev, RPM_SUSPENDED);
+               else
+                       put = dev->power.runtime_status == RPM_RESUMING && retval;
+
+               spin_unlock_irq(&dev->power.lock);
+
                /*
                 * If the device is suspending and the callback has returned
                 * success, drop the usage counters of the suppliers that have
@@ -363,9 +381,7 @@ static int __rpm_callback(int (*cb)(stru
                 *
                 * Do that if resume fails too.
                 */
-               if (use_links
-                   && ((dev->power.runtime_status == RPM_SUSPENDING && !retval)
-                   || (dev->power.runtime_status == RPM_RESUMING && retval))) {
+               if (put) {
                        idx = device_links_read_lock();
 
Quoted 4 lines

drivers/base/power/runtime.c static int __rpm_callback(int (*cb)(stru · line 387

Quoted 4 lines
drivers/base/power/runtime.c +0 -0
  fail:

_______________________________________________
Linux-rockchip mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-rockchip